| Name | QTPYGUI JSON |
| Version |
1.0.2
JSON |
| download |
| home_page | None |
| Summary | A Simple Python Declarative User Interface Wrapper Around Pyside6 |
| upload_time | 2024-05-25 23:02:23 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.8 |
| license | GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> 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. <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year> <name of author> 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 <https://www.gnu.org/licenses/>. 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: <program> Copyright (C) <year> <name of author> 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 <https://www.gnu.org/licenses/>. 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 <https://www.gnu.org/licenses/why-not-lgpl.html>. |
| keywords |
pypi
cicd
pyside6
ui
gui
qt
qtpygui
declarative
wrapper
user-interface
qt-bindings
python-qt
gui-framework
ui-library
pyside6-wrapper
pyside
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# QTPYGUI
### Author: David Worboys
##### 2024-04-11 - Initial Draft
##### Update
## Index
1. [Introduction](#introduction)
2. [Installation](#installation)
3. [Basic Concepts](#basic-concepts)
- [Containers](#containers)
- [GUI Controls](#gui-controls)
- [Event Handling](#event-handling)
4. [Hello World Application](#building-your-first-application)
5. [Application Distribution](#distributing-your-application)
6. [Boot Camp](#boot-camp)
7. [QTPYGUI Control Reference](#qtpygui-control-api-reference)
8. [QTPYGUI Enumerated Types/Classes](#qtpygui-enumerated-typesclass-reference)
## Introduction
QTPYGUI is a declarative user interface wrapper around Pyside6 and, as there are
a number of GUI (Graphical User Interface) wrappers around various widget sets,
including Pyside6, the natural question is why another one? The answer lies in
at least two parts, my dissatisfaction with how the other GUI wrappers were
implemented/managed and because I could and there is much to be learned with
that approach.
The next question the reader might find themselves asking is why not a web UI
based on the old favourites of HTML, CSS and Javascript, something like React
perhaps? I am a firm believer in "horses for courses", so why bring a browser to
the desktop fight and all the resources, memory/compute, that entails when a
well-designed widget set with better performance and memory usage is
available. Worse, building web apps is a complicated business even with the
web UI frameworks, of course some may same the same of desktop widget sets, and
this is where GUI wrappers like QTPYGUI come in.
In closing, it is worth noting that a major advantage in utilising a GUI wrapper,
aside from ease of programming, is that if the underlying widget set is
deprecated, or licensing changes, then the GUI wrapper can change widget sets.
Although this would be a large task, the major benefit is that applications using
the GUI wrapper will be minimally impacted.
### What Is A Declarative User Interface?
A declarative UI (user interface) is an application user interface coded in
the application source code using a formal specification. There is no need for
GUI designers, and the application programmer writes the UI as just another
part of the code. This is an old idea, going back at least to the early 1980's
and applications like dBase II and Clipper but just because it is old does not
mean it is bad or not relevant.
### Notes
1. Development of QTPYGUI started privately in 2020, moving to a public release in 2024.
- This version is an early public release and doco and code streamlining is onging.
- Although QTPYGUI is used in production applications, there are bound to be bugs,
certainly Dateedit and Treeview need much more work as they are infrequently
used.
- The feature set of other GUI components needs to be widened. Missing also is
theming and this will be required for a larger audience.
2. **HELP IS WANTED AND I WELCOME ALL CONTRIBUTIONS!**
- Please reach out to me via Discussions (https://github.com/David-Worboys/QTPYGUI/discussions)
if you want to help or have ideas on improvements
- Bugs can be logged at https://github.com/David-Worboys/QTPYGUI/issues
3. QTPYGUI will always remain opensource, unlike some other similar frameworks
that used "bait and switch" tactics
4. QTPYGUI uses Python 3.11 for development and ruff (https://github.com/astral-sh/ruff)
for formatting. Type hinting is mandatory as are asserts to check all arguments to
functions/methods
5. My time is limited (both figuratively and literally), but I will put in as
much effort as I can to help move things along
6. I strongly suggest using Nutika (https://nuitka.net/) to distribute your
Python desktop applications. I use this method exclusively with great success.
7. Finally, to the reader's relief, I only use Linx Mint for development and
do not have access to a Windows installation, and therefore
- ***HELP IS Neeeded
To Verify QTPYGUI's Operations Under Windows***
### Where To Find An Application That Uses QTPYGUI?
https://github.com/David-Worboys/Black-DVD-Archiver
## QTPYGUI 101
First up, QTPYGUI is pronounced "Cutey Pie GUI" which follows the "QT Groups"
own pronunciation and appeals to my, admitably lame, sense of humour.
### Prerequities
1. Python version >= 3.8
- If Nuitka is used for application distribution, then Python versions 3.12
and above are not currently supported.
### Installation
1. Create your Python project folder and set up your Python project using
the virtual environment manager of your choice
2. pip install QTPYGUI
### Boot Camp
First up, check out the examples in https://github.com/David-Worboys/QTPYGUI/tree/master/examples .
There is one example per python source file, and I will be adding more as time
progresses.
#### Basic Concepts
1. QTPYGUI is event driven and there are no "busy" loops waiting for something
to happen
2. By default, width and height settings are in characters
- Pixels can be used as an argument is provided to allow for this
- This works best with monospaced fonts
- The default font is "IBM Plex Mono" and the default font size is 10
- This is included in the installation of QTPYGUI
- If this font is missing, then QTPYGUI will try and find a system font that
will work
3. The basic structure of a QTPY GUI Program is as follows:
```
import QTPYGUI.qtpygui as qtg
Class Example_App
def __init__(self):
""" Setup application instance variable """
self.example_app = qtg.QtPyApp(
display_name="Example App",
callback=self.event_handler,
height=100,
width=100,
)
def event_handler(self, event: qtg.Action):
"""Handles events"""
def layout()-> qtg.VBoxContainer:
""" Defines The User Interface Layout """
def run(self):
"""Run Example App"""
self.example_app.run(layout=self.layout())
if __name__ == "__main__":
example_app = Example_App()
example_app.run()
```
1. This defines the structure of the application main.py file
2. https://github.com/David-Worboys/QTPYGUI/blob/master/examples/example_01.py
shows this in action.
3. The python classes that utilise a GUI are defined as below:
```
import QTPYGUI.qtpygui as qtg
Class Example_Class:
def event_handler(self, event: qtg.Action):
"""Handles events"""
def layout()-> qtg.VBoxContainer:
""" Defines The User Interface Layout """
```
1. When the Example_Class is instantiated, the layout method is called to
generate the GUI elements of the display and this is assigned to the calling
window/GUI object
##### Containers
Containers are at the heart of the QTPYGUI system and define the layout of the
GUI items. The following are four types of containers:
- FormContainer
- Lays out [GUI Controls](#gui-controls-1) vertically as per the associated platform (Linux,
Windows, Mac) GUI specifications
- HBoxContainer
- Lays out the [GUI Controls](#gui-controls-1) horizontally
- VBoxContainer
- Lays out the [GUI Controls](#gui-controls-1) vertically, similar to the FormContainer but does
not adhere as tightly to the associated platform specifications
- GridContainer
- Lays out the [GUI Controls](#gui-controls-1) as a grid. This container is seldom used.
To add a GUI control to a container, the ```add_row``` method is used as below:
```
qtg.HBoxContainer(tag="button_example").add_row(
qtg.Button(
tag="example_1", text="Example 1", callback=self.event_handler, width=10
),
qtg.Button(
tag="example_2", text="Example 2", callback=self.event_handler, width=10
),
)
```
- This will lay out two Buttons Horizontally. If a FormContainer or a VBoxContainer
was used, the buttons would be laid out vertically.
- **Note the use of the tag, text and callback arguments as these are fundamental
to the operation of QTPYGUI [GUI Controls](#gui-controls)**
- If a Container has a text argument, it becomes a Group box.
##### GUI Controls
These are the GUI components that comprise the UI of an application. Declaring them
utilises a standard pattern of arguments with additional arguments for specific
[GUI Controls](#gui-controls-1).
**Note: If an argument is not supported by a GUI control, it is ignored.**
Let us consider the Button GUI control
````commandline
qtg.Button(tag="example_1", text="Example 1",label="Click Me!", callback=self.event_handler)
````
**Note: The following arguments are common to all QTPYGUI controls**
"tag" — The "tag" is the name of the control, as it is housed in a container
then the container "tag" and the button "tag" make a unique pair.
- This makes it easier to code larger applications as each GUI element
does not have to have a unique name.
- If a "tag" is not provided, then the application generates one automatically.
- This is fine for "Container" and "Label" objects where the programmer does
not intend to reference an object.
"text" — The "text" is the text displayed on the control, it is optional
"label" — The "label" argument places a label to the left of the control, it is
optional
"callback" — Is the name of the method that will process the events generated
by the GUI control. By convention, I declare this as the "event_handler" method.
- If a callback method is not provided, then the control cannot send events to it
- The "event_handler" method takes only one argument—the [Action](#action)
instance whose properties and methods are at the heart of QTPYGUI programming
##### Event Handling
The burning question in the reader's mind is what happens when an operation occurs
on a GUI control, say if a Button (as defined below) is clicked on:
```
qtg.Button(tag="example_2", text="Example 2", callback=self.event_handler, width=10),
```
The answer is that the ```callback``` method ```self.event_handler``` is triggered
with a CLICKED event, and it can be processed as below:
```
def event_handler(self, event: qtg.Action):
"""Handles form events
Args:
event (qtg.Action): The triggering event
"""
assert isinstance(self,event:qtg.Action), f"{event=}. Must be Action"
match event.event:
case qtg.Sys_Events.CLICKED:
match event.tag:
case "example_2":
popups.PopMessage(title="Hi", message="Example 2 Was Clicked").show()
```
This results in a Pop-up window opening with a title of "Hi" displaying
"Example 2 Was Clicked"
**Note: This is the essence of event driven programming, nothing happens until an
event is triggered, mostly by the application[GUI Controls](#gui-controls-1) - like Buttons.**
The observant reader may notice the event instance passed to the ```event handler```
is a class of [Action](#action) which probably should have been named
```Event``` but for historical reasons that nomenclature is staying.
The [Action](#action) class has a number of very useful methods and properties, and
a programmer using QTPYGUI will become very familiar with them.
#### Building Your First Application:
As is traditional, a "hello world" program needs to be written first, so let's
get to it!
```
import QTPYGUI.qtpygui as qtg
class Hello_World:
def __init__(self):
self.hello_world = qtg.QtPyApp(
display_name="Hello World",
callback=self.event_handler,
height=100,
width=100,
)
def event_handler(self, event: qtg.Action):
"""Handles form events
Args:
event (qtg.Action): The triggering event
"""
assert isinstance(event, qtg.Action), f"{event=}. Must be Action"
match event.event:
case qtg.Sys_Events.CLICKED:
match event.tag:
case "ok":
self.hello_world.app_exit()
def layout(self) -> qtg.VBoxContainer:
"""The layout of the window
Returns:
qtg.VBoxContainer: The layout
"""
return qtg.VBoxContainer(align=qtg.Align.BOTTOMRIGHT).add_row(
qtg.FormContainer().add_row(
qtg.Label(
text="Hello World!",
txt_fontsize=48,
txt_align=qtg.Align.CENTER,
txt_font=qtg.Font(backcolor="blue", forecolor="yellow"),
),
),
qtg.HBoxContainer().add_row(
qtg.Button(
tag="ok",
text="OK",
callback=self.event_handler,
width=10,
tooltip="Exit Example 01",
),
),
)
def run(self):
"""Run example_01"""
self.hello_world.run(layout=self.layout())
if __name__ == "__main__":
hello_world = Hello_World()
hello_world.run()
```
This is a slightly simplified version of example_01.
Copy the above source code into a hello_world.py file and run it like so:
```python3 -OO hello_world.py```
And the follwing screen will be displayed:
<br><br>
#### Distributing Your Application
I strongly recommend using Nuitka (https://nuitka.net/) to distribute your
program as it can produce a single compiled file, housing all dependencies
that can be copied to a host machine.
Nuitka's Kay Hayen is simply the Python GOAT when it comes to this type of thing.
To compile ```hello_world.py``` the reader will need to install Nuitka
```pip install Nuitka```
and run this command:
```
python -m nuitka \
--show-anti-bloat-changes \
--assume-yes-for-downloads \
--lto=yes \
--python-flag=-OO \
--python-flag=no_warnings \
--python-flag=isolated \
--standalone \
--onefile \
--prefer-source-code \
--enable-plugin=pyside6 \
--include-qt-plugins=sensible \
--include-package-data=QTPYGUI \
hello_world.py
```
This will produce a ```hello_world.bin``` file on Linux, double-click on it and
the ```hello_world``` application will start.
Note:
1. On occasion the ```hello_world.bin``` file will need to be made executable, and this
is done as follows:
- Right-click on the ```hello_world.bin``` file and select "Properties." This
will open the file properties window. select "Permissions" and tick "Allow
executing file as program" and then "Close"
2. At the time of writing, this will produce a 58MB ```hello_world.bin```
executable file - This is simply how it is when distributing Python applications
as so much is included during the build process. It is worth noting that
PyInstaller produces even larger executables!
## QTPYGUI Control API Reference
This section details the wide variety of GUI (Graphical User Interface) controls
that are available to design a user interface (UI) with QTPYGUI.
Not all properties or methods will be detailed as many are inherited from their
ancestor, the [qtpyBase_Control](#_qtpybase_control)
The properties used by almost all controls, and which should be committed to memory, are:
- **"tag"**, the system name for the control
- Must be specified if the control is going to be used in the code,
if not, it can be omitted and the system will generate
a unique tag name
- **"callback"**, the method that will process events generated by the GUI control.
- Takes one argument - an [Action](#action) instance which has many useful
properties and methods and is critical to QTPYGUI programming.
- callback can be omitted for controls, like [Label](#label), where the
programmer has no interest in the events generated by the control
- **"text"**, not all controls use this as they do not display text
- **"width"**, the width of the control in characters if pixel_unit is False, Otherwise in pixels
- **"height"**, the height of the control in characters if the pixel_unit is False, Otherwise in pixels
Only where a programmer is after a special layout or effect, will the other properties come into play
- Some controls, like the [Grid](#grid), will have special properties that need setting
It is suggested to set the "height" and "width" properties as the font selected might not
automatically size correctly and the defaults might not suit.
- This is particularly the case in fonts that are not monospaced.
Where the "txt_font" is set, it overrides the other text related font properties
[GUI Controls](#gui-controls-1) are housed in [Containers](#containers) and the container_tag and
tag make a unique pair in the form layout
#### GUI Controls
| Control | Description |
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|
| [Button](#button) | Creates a button, text and icon are optional |
| [Checkbox](#checkbox) | Creates a check box that a user can click on or off |
| [ComboBox](#combobox) | Creates a drop down selection box, icon in list is <br/>optional |
| [Dateedit](#dateedit) | Creates a date edit control with a dropdown calendar and <br/>an erase button |
| [FolderView](#folderview) | Creates a control that displays the contents of a folder in a grid format |
| [Grid](#grid) | Creates a control that displays data in a table (grid) format |
| [Image](#image) | Creates a control that displays an image |
| [Label](#label) | Creates a text string |
| [LCD](#lcd) | Creates a control that displays an LCD calculator display<br>Only numbers can be displayed |
| [LineEdit](#lineedit) | Creates a control that allows text to be edited and displayed<br/> in a single line |
| [Menu](#menu) | Creates a menu just below the title bar |
| [ProgressBar](#progressbar) | Creates a control that displays the progress of an operation |
| [RadioButton](#radiobutton) | Creates a radio button control. In a group only one can be <br/>selected at a time |
| [Slider](#slider) | Creates a slider control than can be used to set a value <br/>by dragging the handle |
| [Spacer](#spacer) | Creates a spacer control used to format layout |
| [Spinbox](#spinbox) | Creates a spinbox control that allows numbers to be set <br/>via clicking up and down arrows or entering the number directly |
| [Switch](#switch) | Creates a switch control that can be used to turn on and <br/>off a feature |
| [Tab](#tab) | Creates a tab control that has multiple pages, each <br/>housing their own set of [GUI Controls](#gui-controls-1) |
| [TextEdit](#textedit) | Creates a text entry control that can span multiple lines |
| [Timeedit](#timeedit) | Creates a time edit control with an erase button |
| Treeview | Creates a control that displays data as a tree view |
### _qtpyBase_Control
This is the ancestor of all QTPYGUI [GUI controls](#qtpygui-control-api-reference),
and the properties here are used to set the behavior of the GUI control when instantiated.
**Properties**
- Not all properties will be supported or used by descendant [GUI Controls](#gui-controls-1) and will be ignored
- Some properties will be overridden by descendant [GUI Controls](#gui-controls-1)
| **Property** | **Type** | **Description** |
|-------------------|------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------|
| align | [Align](#align) (Align.LEFT) | Used to align [GUI Controls](#gui-controls-1) in containers |
| allow_clear | bool (True) | True, allow [GUI Controls](#gui-controls-1) that can be cleared to be cleared, Otherwise not |
| bold | bool (False) | True, sets [GUI Controls](#gui-controls-1) that have text bold, Otherwise not |
| buddy_control | _qtpyBase_Control \| None (None) | Set the buddy GUI control or Container |
| buddy_callback | Callable \| None (None) | Sets the callback method for the buddy GUI control (Functon, Method or Lambda) |
| callback | Callable \| None (None) | Sets the callback method for the GUI control (Functon, Method or Lambda) |
| container_tag | str ("") | Sets the container_tag for the GUI control. If "" then system generated |
| editable | bool (True) | True, sets [GUI Controls](#gui-controls-1) that support editing into edit mode, Otherwise not |
| enabled | bool (True) | True, enables the GUI control, Otherwise disable the GUI control |
| frame | [Widget_Frame](#widget_frame) \| None (None) | Sets the frame of a GUI control tht supports frames |
| icon | None \| qtG.QIcon \| qtG.QPixmap \| str (None) | Sets the icon on a GUI control were supported. If a str then this is the filename of the icon |
| italic | bool (False) | True, sets [GUI Controls](#gui-controls-1) that have text italic, Otherwise not |
| height | int (-1) | The height of the GUI control in characters if pixel_unit is False, Otherwise the height is in pixels.<br> -1 automatically calculates the height |
| label | str ("") | The label string, if not provided no label is shown |
| label_align | [Align_Text](#align_text) (Align_Text.RIGHT) | The alignment of the label text |
| label_width | int (-1) | The width of the label in characters if pixel_unit is False, Otherwise the width is in pixels.<br> -1 automatically calculates the width |
| label_font | [Font](#font) \| None (None) | The Font of the label |
| pixel_unit | bool (False) | True, width and height settings are in pixels, Otherwise in characters |
| size_fixed | bool (True) | True, Sets the size of the [GUI Controls](#gui-controls-1) as fixed, Otherwise not fixed. TODO: fix this setting as it has no effect |
| tag | str ("") | The tag of the GUI control, system generated. If "" then system generated |
| text | str ("") | The text displayed on the GUI control if this is supported by the GUI control |
| tooltip | str ("") | The tooltip displayed when the mouse hovers over the GUI control |
| txt_align | [Align_Text](#align_text) (Align_Text.LEFT) | Aligns the [GUI Controls](#gui-controls-1) text, if supported. |
| txt_font | [Font](#None)\| None (None) | The font of the [GUI Controls](#gui-controls-1) text, if supported |
| txt_fontsize | int (DEFAULT_FONT_SIZE) | The fontsize in points of the GUI control text, if supported |
| tune_vsize | int (0) | Used to adjust the vertical size of the GUI control. In pixels |
| tune_hsize | int (0) | Used to adjust the horizontal size of the GUI control. In pixels |
| translate | bool (True) | True, translate the text on the GUI control, if supported, Otherwiise not |
| width | int (-1) | The width of the GUI control in characters if pixel_unit is False, Otherwise the width is in pixels.<br> -1 automatically calculates the width |
| underline | bool (False) | True, sets [GUI Controls](#gui-controls-1) that have text underline, Otherwise not |
| user_data | any (None) | User sepecified data attached to the GUI control |
| validate_callback | Callable \| None (None) | A callback to validate the contents of the GUI control. Applicable only to GUI controls that allow the entry of text |
| visible | bool (True) | True, make the GUI control visible,Otherwise hide the GUI control |
**Methods**
- Not all methods will be used by descendant [GUI Controls](#gui-controls-1)
- Some methods will be overridden
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|---------------------|-----------------|------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|--------------|
| block_signals | | None | Blocks or unblocks signals for the widget (Used rarely where signals might be generated very frequently e.g. [Slider](#slider)) | |
| | block_signals | bool (True) | True, stop this widget from generating signals (events), Otherwise do not do not stop signals (events) being generated . | ✓ |
| clear | | None | Clears the contents of the GUI control, if supported | |
| buddy_text_set | | None | Sets the text on the buddy control, where supported | |
| | value | str | The label text set to the left of the buddy widget. | ❌ |
| ediitable_set | | None | Controls the edit setting of a GUI control, where supported. | |
| | editable | bool (False) | True, set the GUI control editable, where supported, Otherwise not. | ✓ |
| enable_get | | bool | <br><b>Returns:</b><br> The enable value of the widget.<br> | |
| enable_set | | int | Enables/Disables the GUI control where supported <br><b>Returns:</b><br> 1 - set ok, -1 - set failed<br> | |
| | enable | bool | True enable control, Otherwise disable the control. | ❌ |
| fonts_available_get | | tuple[str] | <br><b>Returns:</b><br> A tuple of font name strings.<br> | |
| font_set | | None | Sets the font on the GUI control (Usually used internally as the [Font](#font) property is set when the GUI control is instantiated) | |
| | app_font | Font | Application font | ❌ |
| | widget_font | Font | Control font | ❌ |
| | widget | qtW.QWidget (None) | The QT widget having the font set (defaults to current GUI control) | ✓ |
| font_system_get | | None | Gets the sstem font <br><b>Returns:</b><br> A QFont object.<br> | |
| | fixed | bool (True) | True, return the fixed size system font, Otherwise not | |
| frame_style_set | | None | Sets the frame style of the GUI control, where supported | |
| | frame | [Widget_Frame](#widget_frame) | Frame definition object. | ✓ |
| icon_set | | None | | |
| | icon | None \| qtG.QIcon \| qtG.QPixmap \| str | Sets the icon on a GUI control were supported. If a str then this is the filename of the icon | ❌ |
| guiwidget_get | | qtW.QWidget | Returns the underlying QT widget so that specialised operations can be performed<br><b>Returns:</b><br> The QT GUI widget.<br> | |
| guiwidget_set | | None | Sets the GUI Control (Almost never used by QTPYGUI programmers) | |
| | widget | qtW.QWidget \| qtG.QAction | The widget being set | ❌ |
| pixel_str_size | | [Char_Pixel_Size](#char_pixel_size) | <br><b>Returns:</b><br> The pixel size of the string in a [Char_Pixel_Size](#char_pixel_size) instance .<br> | |
| | text | str | The text to be measured | ❌ |
| pixel_char_size | | [Char_Pixel_Size](#char_pixel_size) | The size of a char in pixels<br><b>Returns:</b><br> [Char_Pixel_Size](#char_pixel_size) <br> | |
| | char_height | int | Character height in chars | ❌ |
| | char_width | int | Character width in chars | ❌ |
| | height_fudge | float (1.1) | Fudge factor multiplier to provide height adjustment | ✓ |
| | width_fudge | float (1.1) | Fudge factor multiplier to provide width adjustment | ✓ |
| text_pixel_size | | tuple[int,int] | Returns the height and width of a string of text in pixels <br><b>Returns:</b><br> The [height,width] of the text in pixels.<br> | |
| | text | str | The text to be measured. | ❌ |
| tooltip_get | | str | <br><b>Returns:</b><br> The tooltip text.<br> | |
| tooltip_set | | None | | |
| | tooltip | str | The text to display in the tooltip. | ❌ |
| | width | int (200) _Currently 400 for testing_ | The width of the tooltip in pixels. ( Width setting is still being ignored TODO Find Fix) | ✓ |
| | txt_color | str | The color of the tooltip text. Defaults to black. | ✓ |
| | bg_color | str | The background color of the tooltip. Defaults to white. | ✓ |
| | border | str | The border style of the tooltip. Defaults to "1px solid #000000". | ✓ |
| tooltipsvisible_get | | bool | <br><b>Returns:</b><br> True - visible, False - not visible.<br> | |
| tooltipsvisible_set | | None | | |
| | visible | bool | True, tooltip visible, Otherwise not. | ❌ |
| trans_get | | bool | <br><b>Returns:</b><br> True - text translated, False - text not translate<br> | |
| trans_set | | None | | |
| | no_trans | bool | True, text not translated, Otherwise text is translated | ❌ |
| trans_str | | str | <br><b>Returns:</b><br> The translated text.<br> | |
| | text | str | The text to be translated. | ❌ |
| | force_translate | bool (False) | Translate text if True,Otherwise do not translate text. Defaults to False | ✓ |
| validate | | bool | <br><b>Returns:</b><br> True if validation ok, otherwise False<br> | |
| value_get | | any | <br><b>Returns:</b><br> The value of the widget.<br> | |
| userdata_get | | any | <br><b>Returns:</b><br> The user data stored on the widget | |
| userdata_set | | None | Sets the user data on the widget. | |
| | user_data | any | The user data can be of any type | ❌ ||
| value_set | | None | Sets the widget value | |
| | value | bool \| int \| float \| [Combo_Data](#combo_data) \| str \| datetime.date \| datetime.datetime | Sets the value of the widget | ❌ |
| visible_get | | bool | <br><b>Returns:</b><br> True - widget visible, False - widget hidden.<br> | |
| visible_set | | None | | |
| | visible | bool | True, sets widget visible, Otherwise widget hidden. | ❌ |
#### Button
Calling Button in a layout will generate a button control on a form.
The "tag", "text" and "callback" arguments are generally the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br>The following properties apply when a button is instantiated with the Button
call, as in the "fully loaded" declaration below
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|----------------------|------------------------------------------------------------------------------------------------------|---------------------------------------------|--------------|
| auto_repeat_interval | If > 0 the button keeps firing Clicked events when <br>held down (milliseconds) | int >= 0 (0) | ✓ |
| bold | Sets the button text bold if True otherwise not | bool (False) | ✓ |
| buddy_control | Control or container with controls that sit to the right of the button | Container or GUI Control | ✓ |
| callback | The method called when the button is pressed | Callable (None) | ✓ |
| enabled | Enables/Disables the button | bool (True) | ✓ |
| height | The height of the button (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (10) | ✓ |
| icon | The icon image displayed on the button | str [File Name]<br/>,QIcon,QPixmap | ✓ |
| italic | Sets the button text italic if True otherwise not | bool (False) | ✓ |
| label | Displays text to the left of the button | str ("") | ✓ |
| label_align | Alignment of the text displayed in the label | [Align_Text](#align_text) (Align_Text.LEFT) | ✓ |
| label_font | The font definition for the label | [Font](#font) | ✓ |
| label_width | Sets the label width (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (0) | ✓ |
| pixel_unit | Use pixels for width/height, pixels if True, Otherwise characters | bool (False) | ✓ |
| tag | The application name of the button | str (System Generated) | ✓ |
| text | The text displayed on the button | str ("") | ✓ |
| txt_align | Alignment of the text displayed on the button | [Align_Text](#align_text) (Align_Text.LEFT) | ✓ |
| txt_font | The font definition for the button (style will override<br> italic,size will override txt_fontsize ) | [Font](#font) | ✓ |
| txt_fontsize | The point size of the text | int (10) | ✓ |
| tune_hsize | Add or subtracts pixels units to the width. Used in aligning controls | int (0) | ✓ |
| tune_vsize | Add or subtracts pixels units to the height. Used in aligning controls | int (0) | ✓ |
| tooltip | Sets the tooltip displayed when the button is hovered over | str | ✓ |
| translate | Translates text if True Otherwise does not translate | bool (True) | ✓ |
| user_data | Any data item the user wants to attach to the button | any (None ) | ✓ |
| underline | Underlines the button text if True otherwise not | bool (False) | ✓ |
| visible | Makes the button visible if True otherwise invisible | bool (True) | ✓ |
| width | The width of the button (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (10) | ✓ |
<br>A fully loaded button declaration:
<br><br>**Note: Only "tag", "text" and "callback" are usually needed**
```
Button(
tag="button_1",
text="Button",
label="Button 1",
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE,size=14),
callback=self.event_handler,
width=10,
height=1,
txt_align=qtg.Align_Text.CENTER,
txt_font =qtg.Font(style=qtg.Font_Style.NORMAL,size=15),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="Button 1 Press Me",
tune_hsize=15,
tune_vsize=15,
user_data = {"key":"value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Checkbox(tag="button_check", text="Tick Me!", callback=self.event_handler, width=12)
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Button instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|-------------|-------------------------------------|--------------|
| text_set | | None | Sets the text on the button | |
| | button_text | str | The text to be placed on the button | ❌ |
| | translate | bool (True) | Translate the text | ✓ |
#### Checkbox
Calling Checkbox in a layout will generate a checkbox control on a form.
The "tag", "text" and "callback" arguments are generally the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br>The following properties apply when a Checkbox is instantiated with the Checkbox
call, as in the "fully loaded" declaration below
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|---------------|--------------------------------------------------------------------------------------------------------|---------------------------------------------|--------------|
| bold | Sets the checkbox text bold if True otherwise not | bool (False) | ✓ |
| buddy_control | Control or container with controls that sit to the right of the checkbox | Container or GUI Control | ✓ |
| callback | The method called when the checkbox is checked | Callable (None) | ✓ |
| enabled | Enables/Disables the checkbox | bool (True) | ✓ |
| height | The height of the checkbox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | ✓ |
| italic | Sets the checkbox text italic if True otherwise not | bool (False) | ✓ |
| label | Displays text to the left of the checkbox | str ("") | ✓ |
| label_align | Alignment of the text displayed in the label | [Align_Text](#align_text) (Align_Text.LEFT) | ✓ |
| label_font | The font definition for the label | [Font](#font) | ✓ |
| label_width | Sets the label width (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (0) | ✓ |
| pixel_unit | Use pixels for width/height, pixels if True, Otherwise characters | bool (False) | ✓ |
| tag | The application name of the checkbox | str (System Generated) | ✓ |
| text | The text displayed next to the checkbox | str ("") | ✓ |
| txt_align | Alignment of the text displayed next to the checkbox | [Align_Text](#align_text) (Align_Text.LEFT) | ✓ |
| txt_font | The font definition for the checkbox (style will override<br> italic,size will override txt_fontsize ) | [Font](#font) | ✓ |
| txt_fontsize | The point size of the text | int (10) | ✓ |
| tune_hsize | Add or subtracts pixels units to the width. Used in aligning controls | int (0) | ✓ |
| tune_vsize | Add or subtracts pixels units to the height. Used in aligning controls | int (0) | ✓ |
| tooltip | Sets the tooltip displayed when the checkbox is hovered over | str | ✓ |
| translate | Translates text if True Otherwise does not translate | bool (True) | ✓ |
| user_data | Any data item the user wants to attach to the checkbox | any (None ) | ✓ |
| underline | Underlines the checkbox text if True otherwise not | bool (False) | ✓ |
| visible | Makes the checkbox visible if True otherwise invisible | bool (True) | ✓ |
| width | The width of the checkbox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | ✓ |
<br>A fully loaded checkbox declaration:
<br><br>**Note: Only "tag", "text" and "callback" are usually needed**
- txt_font overrides the other text font settings
```
Checkbox(
tag="checkbox",
text="Tick Me!",
label="Check Box",
callback=self.event_handler,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),
width=6,
height=1,
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=20),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="Check Box Press Me",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(tag="button_push", text="Push Me!", callback=self.event_handler, width=12)
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Checkbox instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|----------------|---------------|----------|----------------------------------------------------------------|--------------|
| button_checked | | bool | <br><b>Returns:</b><br> The checked state of the checkbox.<br> | |
| button_toggle | | None | | |
| | value (True) | bool | True checkbox is checked, False checkbox is unchecked. | ✓ |
| label_get | | str | <br><b>Returns:</b><br> The text of the label.<br> | |
| value_get | | bool | <br><b>Returns:</b><br> True checked, False not checked<br> | |
| value_set | | None | | |
| | value | bool | True checkbox is checked, False checkbox is unchecked. | ❌ |
#### ComboBox
Calling ComboBox in a layout will generate a dropdown combobox control on a form.
The "tag" ,"text", "callback" and "items" arguments are generally the only
arguments used. It is suggested to set width and height as the font selected
might not automatically size correctly.
<br>**Properties**
<br>The following properties apply when a ComboBox is instantiated with the ComboBox
call, as in the "fully loaded" declaration below
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|-------------------|----------------------------------------------------------------------------------------------------------------------|---------------------------------------------|--------------|
| bold | Sets the combobox text bold if True otherwise not | bool (False) | ✓ |
| buddy_control | Control or container with controls that sit to the right of the combobox | Container or GUI Control | ✓ |
| callback | The method called when the combobox is modified | Callable (None) | ✓ |
| display_na | Displays N/A (Not Applicable/Available) in the drop down list if True Otherwise not | bool (True) | ✓ |
| dropdown_width | The width of the combobox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | ✓ |
| enabled | Enables/Disables the combobox | bool (True) | ✓ |
| height | The height of the combobox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | ✓ |
| italic | Sets the combobox text italic if True otherwise not | bool (False) | ✓ |
| items | Items to add to the ComboBox when it is instantied | list or tuple [Combo_Item](#combo_item) | ✓ |
| label | Displays text to the left of the combobox | str ("") | ✓ |
| label_align | Alignment of the text displayed in the label | [Align_Text](#align_text) (Align_Text.LEFT) | ✓ |
| label_font | The font definition for the label | [Font](#font) | ✓ |
| label_width | Sets the label width (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (0) | ✓ |
| csv_file_def | Defines the csv file that will be loaded into the ComboBox when it is instantiated | [CSV_File_Def](#csv_file_def) (None) | ✓ |
| num_visible_items | Number of items displayed in the dropdown list | int >= 1 (15) | ✓ |
| pixel_unit | Use pixels for width/height, pixels if True, Otherwise characters | bool (False) | ✓ |
| tag | The application name of the combobox | str (System Generated) | ✓ |
| txt_font | The font definition for the combobox dropdown list (style will override<br> italic,size will override txt_fontsize ) | [Font](#font) | ✓ |
| txt_fontsize | The point size of the text in the combobox dropdown list | int (10) | ✓ |
| tune_hsize | Add or subtracts pixels units to the width. Used in aligning controls | int (0) | ✓ |
| tune_vsize | Add or subtracts pixels units to the height. Used in aligning controls | int (0) | ✓ |
| tooltip | Sets the tooltip displayed when the combobox is hovered over | str | ✓ |
| translate | Translates dropdown text if True Otherwise does not translate | bool (True) | ✓ |
| user_data | Any data item the user wants to attach to the combobox | any (None ) | ✓ |
| underline | Underlines the combobox dropdown text if True otherwise not | bool (False) | ✓ |
| visible | Makes the combobox visible if True otherwise invisible | bool (True) | ✓ |
| width | The width of the combobox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | ✓ |
<br>A fully loaded combobox declaration:
<br><br>**Note: Only "tag", "text" ,"callback" and "items" are usually needed**
- txt_font overrides the other text font settings
```
ComboBox(
tag="combo_box",
label="Combo Box",
display_na=True,
dropdown_width=35,
items=[
qtg.Combo_Item(
display="Item 1",
data=None,
icon=qtg.Sys_Icon.computericon.get(),
user_data=None,
),
qtg.Combo_Item(
display="Item 2", data=None, icon=None, user_data=None
),
qtg.Combo_Item(
display="Item 3", data=None, icon=None, user_data=None
),
],
callback=self.event_handler,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),
width=8,
height=1,
txt_font=qtg.Font(style=qtg.Font_Style.ITALIC, size=12),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="Check Box Press Me",
tune_hsize=15,
tune_vsize=1,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(tag="button_push2", text="Push Me 2!", callback=self.event_handler, width=12)
),
),
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to ComboBox instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|----------------------|----------------|--------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| count_items | | int \>= 0 <= number of items in list | <br><b>Returns:</b><br> The number of items in the Combobox<br> | |
| display_width_set | | None | | |
| | display_width | int | The number of characters to display in the Combobox | ❌ |
| get_items | | list [Combo_Data](#combo_data) | <br><b>Returns:</b><br> returns the List of items in the combo box<br> | |
| icon_set | | int | <br><b>Returns:</b><br> 1 if successful, -1 if not<br> | |
| | combo_index | int | Row index in the combobox where the icon is to be placed | ❌ |
| | icon | str [File Name], QIcon,QPixmap | A QPixmap, QIcon or the icon file name | ❌ |
| is_combo_child | | bool | <br><b>Returns:</b><br> True if the Combobox is child of another combo box. False if not.<br> | |
| load_csv_file | | tuple[int,str] | <br><b>Returns:</b><br> Length of maximum item if load OK, Otherwise -1 and error message<br> | |
| | csv_file_def | [CSV_File_Def](#csv_file_def) | The CSV file definition | ❌ |
| load_items | | int | <br><b>Returns:</b><br> int<br> | |
| | auto_na | bool (True) | True puts na_string (Not Available) in combobox, Otherwise not | ✓ |
| | clear_items | bool (True) | Clears existing items from the combobox | ✓ |
| | na_string | str ("N/A") | The "Not Available" string | ✓ |
| print_all_to_console | | None | Debug method - prints items to console | |
| select_index | | None | Scrolls to an index in the combobox and sets the current index of the widget to the select_index argument | |
| | select_index | int | The index of the item to select | ❌ |
| select_text | | int | Selects the text in the combobox <br><b>Returns:</b><br> The index of the selected text in the dropdown. | |
| | select_text | int | <br><b>Returns:</b><br> The index of the selected text in the dropdown.<br> | ❌ |
| | case_sensitive | bool (False) | Whether to perform a case-sensitive match. | ✓ |
| | partial_match | bool (False) | Whether to perform a partial text match. | ✓ |
| | select_text | str | The text to select. | |
| value_get | | [Combo_Data](#combo_data) | <br><b>Returns:</b><br> Current row [Combo_Data](combo_data) if index = -1, Selected row [Combo_Data](combo_data) if row > 0<br> | |
| | index | int (-1) | The index of the item to get. Defaults to current row. | ✓ |
| value_remove | | None | Remove an item from the combobox a the given index. | |
| | index | int | The index of the item to remove. | ❌ |
| value_set | | None | Sets a value in the dropdown and scrolls to that value. if COMBO_DATA index is -1 then data and display. <br> Values must match for scroll to happen | |
| | value | str \| [Combo_Data](#combo_data) | Inserts a value in the dropdown. <br>If [Combo_Data](#combo_data) index = -1 insert alphabetically when insert_alpha is True, Otherwise insert at bottom of list. if index > 1 insert at index position | ❌ | |
| | insert_alpha | bool (True) | Insert alphabetically | ✓ |
#### Dateedit
Calling Dateedit in a layout will generate a Dateedit control, with an erase button
and a dropdown calendar, on a form.
The "tag" ,"text" and "callback" arguments are generally the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
**Constants**
| **Constant** | **Description** | **Type** |
|--------------|------------------------------------------------------------|------------------|
| MINDATE | The minimum date supported by Dateedit (1 Jan 100 AD) | QDate(100, 1, 1) |
| NODATE | Used internally by Dateedit to signify a no date condition | QDate(1, 1, 1) |
<br>**Properties**
<br>The following properties apply when a Datedit is instantiated with the
Datedit call, as in the "fully loaded" declaration below
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|------------------------------------------------------------------------------------------------------------------------------------|----------|--------------|
| date | Set to the current date if not set ("") | str ("") | ✓ |
| format | Date format. The `format` property is set to the current locale's date format if this is not set ("")<br>Follows QT date formating | str ("") | ✓ |
| min_date | Set to **MINDATE** if not set ("") | str ("") | ✓ |
| max_date | Set to the to the current date if not set ("") | str ("") | ✓ |
<br>A fully loaded Dateedit declaration:
<br><br>**Note: Only "tag", "text" ,and "callback" are usually needed**
- text behaves a little differently here as it serves to set the tooltip on the erase button
- max_date, min_date and format can be used to configure the date range and
format of the Dateedit GUI Control if desired
- txt_font overrides the other text font settings
```
Dateedit(
tag="dateedit2",
text="Tick Me!",
date="2022-01-01",
format="yyyy-MM-dd",
max_date="2032-01-01",
min_date="2000-01-01",
label="Date edit 2",
callback=self.event_handler,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),
width=6,
height=1,
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=20),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="Date Edit 2 ",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(
tag="dateedit_button_push",
text="Date Edit 2 Push Me!",
callback=self.event_handler,
width=12,
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Dateedit instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------|--------------|
| clear | | None | Clears the date displayed | |
| | default_text | str ("-") | Date text to place in the edit control (must be a valid date string or - to clear the date) | ✓ |
| date_get | | str \| [Date_Tuple](#date_tuple) | Gets the date. If date_tuple as a [Date_Tuple](#date_tuple), Otherwise a string formatted as per date_format<br> | |
| | date_format ("") | str | Set the date format for a string return if date_tuple is False<br>Follows QT date formating | ✓ |
| | date_tuple (False) | bool | True, return date format as a [Date_Tuple](#date_tuple), Otherwise a string, formated as per date_format | ✓ |
| date_set | | None | Sets the date in the control | |
| | date | str ("") | A string representing the date to set, formatted as 'y-m-d'. | ✓ |
| | date_format | str ("") | The format of the date string, defaults to an empty string. | ✓ |
| | default_text | str ("-") | if the date string is '-' then the date control is cleared | ✓ |
| date_valid | | bool | Checks if a date is valid<br><b>Returns:</b><br> True if date is valid, False otherwise<br> | |
| | date | str | date in string format | ❌ |
| | date_format | str | The format of the date string. | ❌ |
| value_get | | str \| [Date_Tuple](#date_tuple) | Gets the date. If date_tuple as a [Date_Tuple](#date_tuple), Otherwise a string formatted as per date_format<br> | |
| | date_format ("") | str | Set the date format for a string return if date_tuple is False<br>Follows QT date formating | ✓ |
| | date_tuple (False) | bool | True, return date format as a [Date_Tuple](#date_tuple), Otherwise a string, formated as per date_format | ✓ |
| value_set | | None | Sets the date in the control | |
| | date | str ("") | A string representing the date to set, formatted as 'y-m-d'. | ✓ |
| | date_format | str ("") | The format of the date string, defaults to an empty string. | ✓ |
### FolderView
Calling FolderView in a layout will generate a FolderView control on a form.
The "tag", "text", "callback", "header_widths" and "height" arguments are generally
the only arguments used.
<br>It is suggested to set width and height as the font
selected might not automatically size correctly.
<br>**Properties**
<br>The following properties apply when a FolderView is instantiated with the
FolderView call, as in the "fully loaded" declaration below
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------|--------------|
| width | The width of the FolderView GUI control <br>Generally not set as header_widths determines the widths<br> Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (40) | ✓ |
| height | The height of the FolderView GUI control<br> Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (15) # In lines | ✓ |
| root_dir | Sets root path of the FolderView | str ("\\") #Current directory | ✓ |
| dir_only | True, displays directories only, Otherwise display all directories and files | bool (False) | ✓ |
| multiselect | True, allows multiple files and/or folders to be selected, Otherwise only allow one file and/or folder to be selected at a time | bool (False) | ✓ |
| header_widths | Sets the header widths - maximum of 4 allowed <br> Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | list [int,...] \| tuple(int,...) = (40,) | ✓ |
| header_font | Sets the font properties of the header row | [Font](#font) \| None (None) | ✓ |
| click_expand | True, expand folders when clicked on, Otherwise only expand folders if the handle is clicked | bool (False) | ✓ |
<br>A fully loaded FolderView declaration:
<br><br>**Note: Only "tag", "text", "callback", "header_widths" and "height" are usually needed**
- txt_font overrides the other text font settings
```
FolderView(
tag="folderview",
label="Folder View",
callback=self.event_handler,
height=5,
header_widths=[10, 10, 10, 10],
multiselect=False,
click_expand=False,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=20),
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=14),
header_font=qtg.Font(
style=qtg.Font_Style.OBLIQUE,
backcolor="cyan",
forecolor="orange",
size=20,
),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="FolderView Press Me",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(
tag="folderview_button_push",
text="Push Me!",
callback=self.event_handler,
width=12,
),
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to FolderView instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|-----------------|---------------|-------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| change_folder | | None | Changes the root folder for the directory view, clearing the view in the process. | |
| | folder | str | THe new root folder. This is not checked for validity. | ❌ |
| expand_on_click | | bool | <br><b>Returns:</b><br> The expand on click setting. If True then the dir node expands when dir name clicked on, Otherwise not<br> | |
| value_get | | tuple[selected_node(s)] | This will return named tuple(s) of selected_nodes (selected_node, name, path, size, modified, date_modified type, isdir). <br><b>Returns:</b><br> One tuple if multiselect is False, Otherwise one or more tuples containing the file values from the selected node<br> | |
| value_set | | None | Sets the text value of the selected node. Note: may not work in dir view only mode | |
| | value | str | The text to set as the current node text | ❌ |
### Grid
Calling Grid in a layout will generate a Grid control on a form.
The "tag", "text", "callback", "col_def" and "height" arguments are generally
the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br>The following properties apply when a Grid is instantiated with the
Grid call, as in the "fully loaded" declaration below
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------|--------------|
| width | The width of the Grid <br>-1 defaults to the grid column widths being used to calculate the width | int (-1) | ✓ |
| height | The height of the grid | int (BUTTON_SIZE.height) | ✓ |
| col_def | This is the column definitions of the grid | list \| tuple [Col_Def](#col_del) | ❌ |
| grid_items | If an initial grid load is required then set this to a list of [Grid_Items](#grid_item).<br> The tag field of the [Grid_Item](#grid_item) must be set to "" | list [Grid_Item](#grid_item) ([]) | ✓ |
| multiselect | True, allow multiple selections in the grid, Otherwise do not | bool (False) | ✓ |
| noselection | True, do not allow any selections in the grid, Otherwise allow selections | bool (False) | ✓ |
| header_sort | True, Allow header sorting, Otherwise do not | bool (True) | ✓ |
<br>A fully loaded Grid declaration:
<br><br>**Note: Only "tag", "text", "callback", "col_def" and "height" are usually needed**
- Initial Grid loading is usually done by loading grid_items as below
- txt_font overrides the other text font settings
```
Grid(
tag="grid",
label="Grid",
callback=self.event_handler,
col_def=[
qtg.Col_Def(
label="Col 1", checkable=True, editable=False, tag="col_1", width=10
),
qtg.Col_Def(
label="Col 2", checkable=False, editable=True, tag="col_2", width=10
),
],
grid_items=[
qtg.Grid_Item(row_index=0, col_index=0,current_value="value 1" , user_data=None,tag=""),
qtg.Grid_Item(row_index=0, col_index=1,current_value="value 2" , user_data=None,tag=""),
qtg.Grid_Item(row_index=1, col_index=0, current_value="value 3", user_data=None, tag=""),
qtg.Grid_Item(row_index=1, col_index=1, current_value="value 4", user_data=None, tag=""),
],
height=3,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE,backcolor="red", size=14),
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=15), #Does not set colours
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="Grid Me",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(
tag="grid_push",
text="Grid Push Me!",
callback=self.event_handler,
width=12,
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Grid instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|-------------------------|---------------|--------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| changed | | bool | <br><b>Returns:</b><br> True if the grid has been changed, False otherwise.<br> | |
| changed | | None | Sets the changed property. | |
| | value | bool | Set True if the grid has been changed, False otherwise. | ❌ |
| checkitemrow_get | | [Grid_Item](#grid_item) \| empty tuple () | <br><b>Returns:</b><br> A Grid_Item definition containing the row_index,col_index, tag, current_value, and user_data of a item at the given row/col position.<br> | |
| | col | int | The index of the column to retrieve the item from. | ❌ |
| | row | int | The index of the row to retrieve the item from. | ❌ |
| checkitemrow_set | | None | Sets the check state of the item at the row and column specified. | |
| | checked | bool | True, check the item, Otherwise do not | ❌ |
| | col | int | The index of the column to set the check state for. | ❌ |
| | row | int | The index of the row to set the check state for. | ❌ |
| checkitems_all | | None | Checks all items in the grid that are checkable. | |
| | checked | bool (True) | True, check an item, Otherwise uncheck. | |
| | col_tag | str ("") | The column tag name. Only items in this column will be checked/unchecked. If col_tag is "" then all columns will be examined to see if they can be checked/uncheked. | ✓ |
| checkitems_get | | [Grid_Item](#grid_item) \| empty tuple () | <br><b>Returns:</b><br> A tuple of all checked Grid_items in the grid or an empty tuple if no items checked<br> | ✓ |
| clear | | None | Clears the grid of all data | |
| col_count | | int | <br><b>Returns:</b><br> The number of columns in the grid<br> | |
| colindex_get | | int | <br><b>Returns:</b><br> The column index for a column tag name.<br> If the column tag is invalid an assertion error is raised | |
| | column_tag | str | The column tag name. | ❌ |
| coltag_get | | str | <br><b>Returns:</b><br> The column tag name.<br>If the column index is invalid an assertion error is raised.<br> | |
| | column_index | int | The column index reference. | ❌ |
| get_previous_value | | bool\| datetime.date \| datetime.datetime \| datetime.time \| float \| int \| str \| None | <br><b>Returns:</b><br> The previous value stored in the column referred to by row and col<br> | |
| | col | int (-1) | Col index reference. Defaults to current column | ✓ |
| | row | int (-1) | Row index reference. Defaults to current row | ✓ |
| grid_item_get | | [Grid_Item](#grid_item) \|None | <br><b>Returns:</b><br> The Grid item referred to by row and col<br> | |
| | col | int (-1) | Column index reference. Defaults to current column | ✓ |
| | row | int (-1) | Row index reference. Defaults to current column | ✓ |
| item_ids_from_row | | list[int] | <br><b>Returns:</b><br> List of item_ids of the items found in a specified row<br> | |
| | row | int | The table widget row | ❌ |
| load_csv_file | | int | <br><b>Returns:</b><br> The length of the maximum item loaded or -1 if there is a problem with the file.<br> | |
| | data_index | int (1) | The column index in the CSV file containing the user data to associate with the loaded data. | |
| | delimiter | str "," | The field separator used in the CSV file. Defaults to ",". | |
| | file_name | str | The name of the CSV file. | ❌ |
| | ignore_header | bool (True) | Set to True if the CSV file has a header row that should be ignored | ✓ |
| | line_start | int (1) | The line number in the CSV file to start loading data from | ✓ |
| | text_index | int (1) | The column index in the CSV file containing the text to display in the grid | |
| move_checked_block_down | | None | Move the checked block down one position in the Grid | |
| move_checked_block_up | | None | Move the checked block up one position in the Grid | |
| move_row_down | | int | Move the currently selected row down one position in the Grid <br><b>Returns:</b><br> The new row or -1 if the row is at the bottom of the table<br> | |
| | move_row | int | The index of the row to move | ❌ |
| move_row_up | | int | Move the currently selected row up one position in the table<br><b>Returns:</b><br> The new row or -1 if the row is at the top of the table<br> | |
| | move_row | int | The index of the row to move. | ❌ |
| row_append | | int | Appends a blank row to the grid<br><b>Returns:</b><br> Row number inserted.<br> | |
| row_count | | int | <br><b>Returns:</b><br> Row Count (number of rows in the grid)<br> | |
| row_delete | | None | Deletes a row | |
| | row | int | Row index of the row in the grid that is to be deleted | ❌ |
| row_from_item_id | | int | Returns the row index of the item with the specified item_id<br><b>Returns:</b><br> The row index of the item with the specified item_id. -1 if item_id not found<br> | |
| | item_id | int | The item_id of the item you want to find the row index for | ❌ |
| row_insert | | None | Inserts a row at the given row index. If row is > number of rows then a new row is inserted. | |
| | row | int | The row index in the grid. | ❌ |
| | scroll_to | bool (True) | True scroll to the inserted row, Otherwise not | ✓ |
| row_scroll_to | | None | Scrolls to a row (Deprecated will be removed in a later release. Use select_row) | |
| | col | int (-1) | -1 no column selected, Otherwise select the column indicated by col index | ✓ |
| | row | int | Row to scroll to | ❌ |
| row_widget_get | | [_qtpyBase_Control](#_qtpybase_control) \| [Container](#containers) | <br><b>Returns:</b><br> If found, the widget or the widget container stored in the specified row and column, Otherwise None<br> | |
| | col | int | Grid column index. If -1, the current column is used, Otherwise the specified column. | ❌ |
| | container_tag | str ("") | Container tag is needed if the desired widget is in a container | ✓ |
| | row | int | Grid row index. If -1, the current row is used, Otherwise the specified row. | ❌ |
| | tag | str ("-") | control tag name. If "-" is supplied, the container is returned. | |
| row_widget_set | | None | Sets a widget at the specified row and column | ✓ |
| | col | int | The column index of the cell to set the widget for. | ❌ |
| | group_text | str ("") | If group_text is provided the widget will be displayed in a group box with the group_text as a title | ✓ |
| | row | int | The row index of the cell you want to set the widget for. | ❌ |
| | widget | [_qtpyBase_Control](#_qtpybase_control) | The widget to be inserted into the grid | ❌ |
| row_widget_tag_delete | | int | Deletes a row if the row contains a row widget with a tag that matches the row and tag passed to the method<br><b>Returns:</b><br> 1 row found and deleted, -1 no row found that matches the tag passed to the method<br> | |
| | container_tag | str ("") | This is the container tag of the widget (used only where the widget container tag has been set. Defaults to self.container). | ✓ |
| | tag | str | The tag of the widget to be deleted. | ❌ |
| | widget_row | int | The row housing the widget | ❌ |
| select_col | | None | Sets the current column | |
| | col | int | The column index in the grid. | ❌ |
| | row | int | The row index in the grid. | ❌ |
| select_row | | None | Scrolls to the given row | |
| | col | int (-1) | The column index in the grid (defaults to -1 scroll to row only). | ✓ |
| | row | int | The row index in the grid. | ❌ |
| selected_col | | int | <br><b>Returns:</b><br> The currently selected col<br> | |
| selected_row | | int | <br><b>Returns:</b><br> The currently selected row<br> | |
| userdata_get | | any | <br><b>Returns:</b><br> User data stored in column referred to by row and col<br> | |
| | col | int (-1) | If -1, the current column, Otherwise column specified by column | ✓ |
| | row | int (-1) | if -1, the current row, Otherwise row specified by row | ✓ |
| userdata_set | | None | Sets the user data stored on the given column referred to by row and col | |
| | col | int (-1) | If -1, the current column, Otherwise column specified by column | ✓ |
| | row | int (-1) | if -1, the current row, Otherwise row specified by row | ✓ |
| | user_data | any (None) | User data to be stored | |
| value_get | | bool \| datetime.date \| datetime.datetime \| datetime.time \| float \| int \| str \| None | <br><b>Returns:</b><br> The value stored in the column referenced by row and column<br> | |
| | col | int (-1) | If -1, the current column, Otherwise column specified by column | ✓ |
| | row | int (-1) | if -1, the current row, Otherwise row specified by row | ✓ |
| value_set | | None | Sets a display value (and user data if supplied) at a given row and column | |
| | bold | bool (False) | If True **bolds** the display font, Otherwise not | ✓ |
| | col | int | Column index reference. | ❌ |
| | italic | bool (False) | If True _italicises_ the display font, Otherwise not | ✓ |
| | row | int | Row index reference. | ❌ |
| | tooltip | str ("") | Tooltip to be displayed. | ✓ |
| | underline | bool (False) | If True underlines the display font, Otherwise not | ✓ |
| | user_data | any | User data to be stored. | ❌ |
| | value | bool \| datetime.date \| datetime.datetime \|datetime.time \| float \| int \|str \| None | The value to be displayed. | ❌ |
| valueorig_get | | bool \| datetime.date \| datetime.datetime \|datetime.time \| float \| int \|str \| None | <br><b>Returns:</b><br> The original value stored in the column referenced to by row and col<br> | |
| | col | int (-1) | If -1, the current column, Otherwise column specified by column | ✓ |
| | row | int (-1) | if -1, the current row, Otherwise row specified by row | ✓ |
### Image
Calling Image in a layout will generate an Image control on a form.
The "tag", "text", "callback", "height" and width arguments are generally the
only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br>The following properties apply when an Image is instantiated with the
Image call, as in the "fully loaded" declaration below.
<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference)
properties also apply and some are used in the "fully loaded" declaration below
| **Property** | **Description** | **Type** | **Optional** |
|----------------|-----------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| width | The width of the image | int (1) | ✓ |
| height | The height of the Image | int (1) | ✓ |
| image | str [File name] \| QPixmap]] \| bytes (None) | If str the image is at the file path specified, If bytes must be image file contents, Otherwise the image must be a QPixmap or None | ✓ |
| cached_height | int (-1) | If -1, no cached images is stored, Otherwise the cached image will be stored at the specific height<br>Aspect ratio is always maintained | ✓ |
| cached_width | int (-1) | If -1, no cached image is stored , Otherwise the cached image will be stored at the specified width<br>Aspect ratio is always maintained | ✓ |
| rotate_degrees | int (0) | Rotates the image by the specified number of degrees<br>Must be int between +- 0 and 360 | ✓ |
<br>A fully loaded Image declaration:
<br><br>**Note: Only "tag", "text", "callback", "height", "width" and "image" are usually needed**
- For implementation reasons, txt_fontsize affects image size and I would
suggest setting to 10 or 12.
- txt_font overrides the other text font settings
```
qtg.Image(
tag="image",
label="Image",
#width=13,
height=10,
callback=self.event_handler,
image="example.jpg",
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=12),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="Image Press Me",
tune_hsize=1,
tune_vsize=1,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(
tag="image_button_push",
text="Push Me!",
callback=self.event_handler,
width=12,
height=2,
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Image instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|----------------------|---------------------|-------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| clear | | None | Clears the visible items from the image | |
| clip_get | | QPixmap \| None | Gets a QPixmap clip of the image at the given coordinates of the given size<br><b>Returns:</b><br> A QPixmap clipped image or None if something went wrong.<br> | |
| | height | int | The height of the image portion to be clipped. | ❌ |
| | width | int | The width of the image portion to be clipped. | ❌ |
| | x | int | The x coordinate of the left corner of the rectangle to be clipped. | ❌ |
| | y | int | The y coordinate of top of the rectangle to be clipped. | ❌ |
| get_height_width | | tuple[int, int] | Gets the height and width of the image as a tuple of pixels. <br><b>Returns:</b><br> (Height,Width) in pixels<br> | |
| image_cache_get | | QPixmap \| None | Returns the cached image<br><b>Returns:</b><br> The cached image if it has been set or None<br> | |
| image_cache_set | | None | Sets a cached image - used to speed things up if we do not want to load the image again | |
| | image | QPixmap | The image to be cached. | ❌ |
| image_file_get | | str | Gets the file path of the source file<br><b>Returns:</b><br> The file path of the source file or "" if the image is not sourced from a file<br> | |
| image_set | | int | Sets an image to be displayed<br><b>Returns:</b><br> 1 Ok, -1 If not | |
| | cached_height | int (-1) | If -1 no cached image is stored, Otherwise create a cached image of a specific height<br>Aspect ratio always maintained | ✓ |
| | cached_width | int (-1) | If -1 no cached image is stored, Otherwise create a cached image of a specific width<br>Aspect ratio always maintained | ✓ |
| | height | int (-1) | Height of image, If -1 scaled to the width | ✓ |
| | high_quality | bool (False) | Display image in high quality | ✓ |
| | image | str \| qtG.QPixmap \| bytes | Image to be displayed | ❌ |
| | rotate_degrees | int (0) | Rotate the image in degrees | ✓ |
| | scaled | bool (True) | Scale the image to fit height and width | ✓ |
| | width | int (-1) | Width of image. If -1 scaled to the height | ✓ |
| numpy_array_get | | tuple[int, int, ndarray] | Generates an RGB numpy array suited for dlib (and other libs the author imagines) type operations <br><b>Returns:</b><br> The tuple (image height (pixels),image width (pixels), np.ndarray)<br>The last element is the RGB numpy array that represents the pixmap that is displayed. Assumes only one image is displayed!<br> | |
| | dlib | bool (False) | If True, the array will be converted to 32bit RGB, Otherwise left as is | |
| rectangle_coords_get | | [Rect_Coords](#rect_cords) | Returns an instance of [Rect_Coords](#rect_cords) containing the coordinates of a rectangle, given its id<br><b>Returns:</b><br> The coordinates of the rectangle.These will be set to -1 if rect_id not found<br>str<br>int<br>int<br>int<br>int<br> | |
| | rect_id | str | The ID of the rectangle. | ❌ |
| rectangle_delete | | bool | Deletes a specific rectangle if the rect_id is provided else deletes all the rectangles in the image <br><b>Returns:</b><br> True if rectangle deleted or False if rectangle not found<br> | |
| | rect_id | str | The rect_id of the rectangle to be deleted or "" if all rectangles are to be deleted. | ✓ |
| rectangle_draw | | None | Draws a rectangle on the currently loaded image | |
| | colour | str ("red") | Colour of rectangle line (mostly legal HTML colours) | ✓ |
| | height | int (-1) | If -1, top + 50, Otherwise Height of rectangle in pixels | ✓ |
| | item_id | str | Rectangle identifier. Must be a non-empty str | ❌ |
| | left | int | Left position in pixels | ❌ |
| | top | int | Top position in pixels | ❌ |
| | visible | bool (True) | If True, rectangle is visible, Otherwise not | ✓ |
| | width | int (-1) | If -1, left + 20 , Otherwise width of rectangle in pixels | ✓ |
| rectangle_id_change | | None | Updates the rectangle id | |
| | new_id | str | The new rectangle_id | ❌ |
| | old_id | str | The old rectangle_id | ❌ |
| rectangle_overlaps | | tuple [Overlap_Rect](#overlap_rect) | Returns a tuple of overlapping rectangles<br><b>Returns:</b><br> A tuple containing the ids and coords of overlapping rectangles.<br> | |
| | overlap_ratio | float (0.3) | The ratio to determine overlapping. 0 - No overlap to 1 - Complete overlap | ✓ |
| rectangle_show | | None | | |
| | rect_id | str | The id of the rectangle that will be shown/hidden depending on visible | ❌ |
| | suppress_rect_check | bool (False) | Used for debugging, suppresses the assert for checking if a rect_id is in the image | ✓ |
| | visible | bool | True shows the rectangle, False hides the rectangle | ❌ |
| rectangles_changed | | dict [str, [Rect_Changed](#rect_changed)] | Returns a dict of changed rectangles <br><b>Returns:</b><br> Dict of changed rectangles.<br> | |
### Label
Calling Label in a layout will generate a Label control on a form.
The "tag" and "text" are generally the only arguments used, and "tag" is only
needed if you plan on referencing the label in your code.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br> A Label has no special properties, but can use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties as in the "fully loaded" example below
<br>A fully loaded Label declaration:
<br><br>**Note: Only "tag", "text"are usually needed**
- txt_font overrides the other text font settings
```
Label(
tag="example03",
label="Label",
text="Example 03",
label_font=qtg.Font(
font_name="Courier",
style=qtg.Font_Style.OBLIQUE,
size=42,
backcolor="yellow",
forecolor="blue",
),
txt_fontsize=42,
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(
font_name="DejaVu Sans Mono",
backcolor="blue",
forecolor="yellow",
size=50,
),
width=8,
frame=qtg.Widget_Frame(
frame_style=qtg.Frame_Style.BOX,
frame=qtg.Frame.RAISED,
line_width=5,
midline_width=2,
),
height=2,
tune_hsize=30,
tune_vsize=15
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Label instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|----------|--------------------------------------------|--------------|
| value_get | | str | <br><b>Returns:</b><br> The label text<br> | |
| value_set | | None | Sets the label text | |
| | value | str | text value to set in the label | ❌ |
### LCD
Calling LCD in a layout will generate an LCD control, with an LCD like number
display, on a form. This control is unusual in that it only displays a limited set
0/O, 1, 2, 3, 4, 5/S, 6, 7, 8, 9/g, minus, decimal point, A, B, C, D, E, F,
h, H, L, o, P, r, u, U, Y, colon, degree sign (which is specified as single
quote in the string) and space.
Refer to the [Calculator](https://github.com/David-Worboys/QTPYGUI/blob/master/examples/example_02_calculator.py) for a simple program example
The "tag" and "text" are generally the only arguments used, and "tag" is only
needed if you plan on referencing the label in your code.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br> An LCD has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties as in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|-----------------------------|----------|--------------|
| digit_count | Number of digits in display | int (8) | ✓ |
<br>A fully loaded LCD declaration:
<br><br>**Note: Only "tag", "text"are usually needed**
- txt_font, other than size, has little effect on the LCD control display and most text
settings will not apply.
```
qtg.LCD(
tag="lcd",
label="LCD",
callback=self.event_handler,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, backcolor="yellow", size=14),
txt_font=qtg.Font(size=15),
width=8,
height=1,
txt_fontsize=12,
digit_count=9,
text="-123456.7",
width=9,
enabled=True,
visible=True,
tooltip="LCD Control",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Spacer(width=1),
qtg.Button(
tag="lcd_button",
text="Press Me!",
callback=self.event_handler,
width=12,
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to LCD instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|---------------------|------------------------------------------------------------------|--------------|
| value_set | | None | Sets the LCD number display | |
| | value | str \| int \| float | The value to be displayed in the LCD<br>Only numbers are allowed | ❌ |
### LineEdit
Calling LineEdit in a layout will generate a LineEdit control on a form.
The "tag", "text" and "callback" arguments are generally the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br> A LineEdit has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties as in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|-------------------|----------------------------------------------------------------------|------------------------|--------------|
| char_length | The maximum number of characters that can be entered in the LineEdit | int (MAX_CHARS) | ✓ |
| input_mask | The input mask that determines what is shown in the LineEdit | str ("") | ✓ |
| text | Place holder text | str ("") | ✓ |
| validate_callback | A callback that validates the text entered | Callable\| None (None) | ✓ |
<br>**Input Mask**
| **Character** | **Meaning** |
|---------------|-----------------------------------------------------------------------------------------------------------------------|
| A | Character of the Letter category required, such as A-Z, a-z. |
| a | Character of the Letter category permitted but not required. |
| N | Character of the Letter or Number category required, such as A-Z, a-z, 0-9 |
| n | Character of the Letter or Number category permitted but not required |
| X | Any non-blank character required |
| x | Any non-blank character permitted but not required |
| 9 | Character of the Number category required, e.g 0-9 |
| 0 | Character of the Number category permitted but not required |
| D | Character of the Number category and larger than zero required, such as 1-9 |
| d | Character of the Number category and larger than zero permitted but not required, such as 1-9 |
| # | Character of the Number category, or plus/minus sign permitted but not required |
| H | Hexadecimal character required. A-F, a-f, 0-9 |
| h | Hexadecimal character permitted but not required |
| B | Binary character required. 0-1 |
| b | Binary character permitted but not required |
| > | All following alphabetic characters are uppercased |
| < | All following alphabetic characters are lowercased |
| ! | Switch off case conversion |
| ;c | Terminates the input mask and sets the blank character to c. |
| [ ] { } | Reserved |
| \ | Use \ to escape the special characters listed above to use them as separators | |
| @ | First char indicates password, following chars is the input mask. Display characters as they are entered |
| * | First char indicates password, following chars is the input mask. Display platform-dependent password mask characters | |
<br>A fully loaded LineEdit declaration:
<br><br>**Note: Only "tag" is usually needed and "text" if a placeholder is required**
- If an input mask is provided, the placeholder text is not visible
- A password mask would look like this: *XXXXXXXX
- txt_font overrides the other text font settings
- It is suggested to set "height" and width arguments as the font selected
might not automatically size correctly.
```
LineEdit(
tag="lineedit",
label="Line Edit",
text="Place Holder",
callback=self.event_handler,
input_mask="(9999) 999-9999",
width=15,
height=1,
char_length=15,
label_align=qtg.Align_Text.CENTER,
label_width=10,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),
txt_align=qtg.Align_Text.CENTER,
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=10),
txt_fontsize=12,
bold=True,
italic=True,
underline=True,
enabled=True,
visible=True,
tooltip="LineEDit ",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Checkbox(
tag="telephone_checkbox_check",
text="Phone Number!",
callback=self.event_handler,
width=13,
),
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to LineEdit instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|----------------|----------------|--------------|------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| input_mask_set | | None | Set the input mask | |
| | input_mask | str | Input mask character string | |
| max_chars_get | | int | Returns the maximum number of characters allowed in the text field<br><b>Returns:</b><br>The max number of characters allowed in the text field.<br> | |
| max_chars_set | | None | Sets char_length and checks if is > 0 and < MAX_CHARS | |
| | max_chars | int | The maximum number of characters to use in the line edit control. | |
| modified | | bool | True, LineEdit modified, Otherwise not modified | |
| value_get | | str | <br><b>Returns:</b><br> original taxt if `original_value` is `True otherwise the modified text<br> | |
| | original_value | bool (False) | True - Return original value, Otherwise return the current value | |
| value_set | | None | Set the LineEdit text to the value string | |
| | value | str | The value to set. | |
### Menu
Calling Menu in a layout will generate a menu control on the top of the window
that contains the application forms.
<br>**Properties**
<br> A Menu_Element has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties.
| **Property** | **Description** | **Type** | **Optional** |
|---------------|-----------------------------------------------------------------------------------------------------------|----------|--------------|
| container_tag | The system name of the menu container (required if the [Menu_Entry](#menu_entry) is accessed at run time) | str | ✓❌ |
| tag | The system name of the menu | str | ✓ |
A menu is built up of [menu elements](#menu_element) and creating a menu is straight forward:
<br>
1. Create a Menu instance
2. Add The top row menu elements with the element_add method and the parent_tag = ""
3. Add submenu elements with the parent tag pointing to the tag of the parent menu element
4. Repeat Step 3 as often as needed to make up the menu structure.
5. If a seperator is needed, set menu element text to "---" which is the constant MENU_SEPERATOR <br>
or set menu element seperator=True
The code below illustrates this process
```
menu = qtg.Menu(container_tag="main_menu",tag="top_level") # Create menu object
# Make top row menu elements - as many as needed, in this case one
menu.element_add(
parent_tag="",
menu_element=qtg.Menu_Element(
text="&Test", tag="test", callback=self.event_handler
),
)
# Add menu elements to the top row menu elements
menu.element_add(
parent_tag="test",
menu_element=qtg.Menu_Element(
text="&Level 2 Test 1",
tag="level2_test1",
callback=self.event_handler,
tooltip="Test 2",
),
)
# A seperator draws a line between menu elements - there are 2 ways as illustrated.
# The least preferred (using text) is commented out
menu.element_add(
parent_tag="test",
menu_element=qtg.Menu_Element(
separator=True,
# text= MENU_SEPERATOR
),
)
menu.element_add(
parent_tag="test",
menu_element=qtg.Menu_Element(
text="&Level 2 Test 2",
tag="level2_test",
callback=self.event_handler,
tooltip="",
),
)
# Add sub-menus in this case to parent_tag="level2_test
menu.element_add(
parent_tag="level2_test",
menu_element=qtg.Menu_Element(
text="&Level 3 Test",
tag="level3_test",
callback=self.event_handler,
tooltip="",
),
)
# Add sub-menus in this case to parent_tag="level3_test
menu.element_add(
parent_tag="level3_test",
menu_element=qtg.Menu_Element(
text="&Level 4 Test",
tag="level4_test",
callback=self.event_handler,
checkable=True,
font=qtg.Font(style=qtg.Font_Style.ITALIC, forecolor="red", size=14),
tooltip="level4_test",
icon= qtg.Sys_Icon.filenew.get(),
),
)
(
menu.element_add(
parent_tag="level3_test", menu_element=qtg.Menu_Element(text="---")
),
)
menu.element_add(
parent_tag="level3_test",
menu_element=qtg.Menu_Element(
text="&Level 4 Test 1",
tag="level4_test1",
callback=self.event_handler,
tooltip="",
),
)
```
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|-------------|---------------|-------------------------------|-----------------------------------------------------------------------------|--------------|
| element_add | | None | | |
| | menu_element | [Menu_Element](#menu_element) | Menu Element instance | ❌ |
| | parent_tag | str | Menu element tag of the parent menu element. "" is the top level parent_tag | ❌ |
#### Menu_Element
A Menu_Element is a menu control element added to the [Menu](#menu) via the
element_add method that defines a menu item entry.
<br>**Properties**
<br> A Menu_Element has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties.
| **Property** | **Description** | **Type** | **Optional** |
|--------------|------------------------------------------------------------------------------------------------|----------------------------------------|--------------|
| callback | The event handler method to call when the menu item is clicked on | Callable | ❌ |
| checkable | Makes a check box in te menu item | bool (False) | ✓ |
| enabled | If True enables the menu_item, Otherwise disabled the menu item | bool (True) | ✓ |
| font | Sets the font of the menu item (colours are not currently working) | [Font](#font) \| Nonw (None) | ✓ |
| icon | Sets an icon on the menu item | str \| qtG.QIcon \| qtG.QPixmap (None) | ✓ |
| separator | Draws a line to separate menu items | bool (False) | ✓ |
| tag | The menu items system name (required if the [Menu_Entry](#menu_entry) is accessed at run time) | str | ✓❌ |
| text | The menu item text | str | ❌ |
| tooltip | The menu item tooltip that displays when the cursor is hovering over the menu item | str | ✓ |
| visible | if True makes the menu item visible, otherwise the menu_item is invisible | bool (True) | ✓ |
#### Menu_Entry
A Menu_Entry instance is returned in the callback event handler method when a
[Menu](#menu) item is selected
<br>**Properties**
<br> A Menu_Entry has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties.
| **Property** | **Description** | **Type** | **Optional** |
|--------------|-------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------|--------------|
| element | The [Menu Element](#menu_element) definition that is contained in this Menu Entry | [Menu_Element](#menu_element) | ❌ |
| parent_tag | The tag name of the [Menu Element](#menu_element) that is the parent of this Menu_Entry<br> Top level menu items do not have a parent_tag | str ("") | ✓ |
| tag | The tag name of the [Menu Element](#menu_element) that is contained in this Menu Entry | str | ❌ |
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Menu_Entry instances
<br><br>**Note: A menu item cannot have a checked box and an icon simultaneously. If an icon is set then a checkbox is not displayed**
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|-------------|---------------|-----------------------------------------|---------------------------------------------------------------------------------------|--------------|
| checked_get | | bool | <br><b>Returns:</b><br> True - Menu Item Checked, Otherwise Menu Item Not Checked<br> | |
| checked_set | | None | Sets a menu item to be checked or not checked | |
| | checked | bool | True - Check menu item, False - Uncheck Menu Item | ❌ |
| enabled_get | | bool | br><b>Returns:</b><br> True - Menu Item Enabled, False - Menu Item Disabled<br> | |
| enabled_set | | None | Sets a menu item to be enabled or not enabled | |
| | enabled | bool | True - Enable menu item, Otherwise disable Menu Item | ❌ |
| font_get | | QFont | <br><b>Returns:</b><br> The font of the menu item<br> | |
| font_set | | None | Sets the font of the menu item | |
| | font | [Font](#font) | | ❌ |
| icon_get | | None | <br><b>Returns:</b><br> The icon of the menu item<br> | |
| icon_set | | str \| qtG.QPixmap \| qtG.QIcon \| None | Sets the icon of the menu item | |
| text_get | | str | <br><b>Returns:</b><br> The text of the menu item<br> | ❌ |
| text_set | | None | Sets the text of the menu item | |
| | text | str | The text to set | ❌ |
| tooltip_get | | str | <br><b>Returns:</b><br> The tooltip of the menu item<br> | |
| tooltip_set | | None | Sets the tooltip of the menu item | |
| | tooltip | str | The tooltip to set | ❌ |
| visible_get | | bool | <br><b>Returns:</b><br> True - Menu Item Visible, False - Menu Item Not Visible<br> | |
| visible_set | | None | Sets a menu item to visible or not visible | |
| | visible | bool | True - Menu item visible, Otherwise Menu item not visible | ❌ |
### ProgressBar
Calling ProgressBar in a layout will generate a ProgressBar control on a form.
The "tag", "text" and "callback" arguments are generally the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br> A ProgressBar has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties as in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|---------------------------------------------------------------------------|-------------|--------------|
| callback | The event handler method to call when the PrgressBar is does something | Callable | ❌ |
| horizontal | True a horizontal ProgressBath, Otherwise a vertical ProgressBar | bool (True) | ✓ |
| label | The label to the left of the ProgressBar that indicates what is is for | str | ✓ |
| range_min | The minimum range of a ProgressBar >=0 | int (0) | ✓ |
| range_max | The maximum range of a ProgressBar >= 0 | int (100) | ✓ |
| tag | The system name of the ProgressBar (required for updates) | str | ❌ |
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | ✓ ||
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | ✓ ||
<br>A fully loaded ProgressBar declaration:
<br><br>**Note: Only "tag","range_min","range_max" and "callback" is usually needed**
```
ProgressBar(
tag="progressbar",
label="Progress Bar",
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),
callback=self.event_handler,
horizontal=True,
width=15,
height=1,
range_min=0,
range_max=200,
enabled=True,
visible=True,
tooltip="Progress Bar",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="progressbar_button",
text="Press Me!",
callback=self.event_handler,
width=12,
),
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to ProgressBar instances
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|----------|-----------------------------------------------------------|--------------|
| range_set | | None | Sets the range of the progressbar. | |
| | max | int | The maximum value of the progressbar. | ❌ |
| | min | int | The minimum value of the progressbar. | ❌ |
| reset | | None | Resets the progressbar to the minimum value | |
| value_get | | int | <br><b>Returns:</b><br> The value of the progressbar.<br> | |
| value_set | | None | Sets the value of the progressbar | |
| | value | int | The value to set the progressbar to. | ❌ |
### RadioButton
Calling RadioButton in a layout will generate a RadioButton control on a form.
Normally, there is a group of radio buttons, and they are placed in a container
to ensure only one can be selected at a time. The container will have its text
property set to make it a visible groupbox housing the radio buttons
<br>**Properties**
<br> A RadioButton has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties as in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|-------------------------------------------------------------------------|----------|--------------|
| callback | The event handler method to call when the RadioButton is does something | Callable | ❌ |
| tag | The system name of the RadioButton (required for updates) | str | ❌ |
| text | The text displayed to the left of the RadioButton | str | ❌ |
<br>A fully loaded RadioButton declaration:
<br><br>**Note: This example is hardly realistic but shows the reader what is possible**
<br>- Normally all that is required is this:
```
qtg.RadioButton(tag="radio2", text="Radio 2", callback=self.event_handler)
```
```
HBoxContainer(text="Radio Buttons", tag="radios").add_row(
qtg.RadioButton(
tag="radio1",
text="Radio 1",
checked=True,
callback=self.event_handler,
label="Radio Button 1",
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),
enabled=True,
visible=True,
tooltip="Radio Button",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="radio_button_push",
text="R1 Push Me!",
callback=self.event_handler,
width=15,
height=1,
)),
),
qtg.RadioButton(
tag="radio2", text="Radio 2", callback=self.event_handler
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a RadioButton instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|----------------|---------------|----------|-----------------------------------------------------------------------------------------|--------------|
| button_checked | | bool | <br><b>Returns:</b><br> True - Checked, False - Not Checked<br> | |
| button_toggle | | None | Set the radiobutton to checked or unchecked | |
| | value | bool | True - radio button checked. False - radio button not-checked. | ❌ |
| value_get | | bool | <br><b>Returns:</b><br> True - Radiobutton Checked, False - Radiobutton not checked<br> | |
| value_set | | None | Sets the radiobutton to checked or unchecked | |
| | value | bool | True - checked. False - not checked. | ❌ |
### Slider
Calling Slider in a layout will generate a Slider control on a form.
The "tag", "text" and "callback" arguments are generally the only arguments used.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br> A Slider has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties as in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|----------------------|---------------------------------------------------------------------------|--------------------|--------------|
| callback | The event handler method to call when the PrgressBar is does something | Callable | ❌ |
| orientation | "vertical" or "horizonral" presentation of the slider | str ("horizontal") | ✓ |
| page_step | The step size when the page up/down is pressed | int (10) | ✓ |
| range_max | The maximum value of the slider | int (100) | ✓ |
| range_min | The minimum value of the slider | int (0) | ✓ |
| scale_factor_percent | Scales the value internally by a certain perentage (_Experimental_) | float (0.0) | ✓ |
| single_step | The step size when a single step is taken | int (1) | ✓ |
| tag | The system name of the RadioButton (required for updates) | str | ❌ |
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | ✓ |
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | ✓ |
<br>A fully loaded Slider declaration:
<br><br>**Note: Only "tag","range_min","range_max" and "callback" is usually needed**
```
Slider(
tag="slider",
label="Slider",
callback=self.event_handler,
range_min=0,
range_max=500,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE,backcolor="yellow", size=15),
enabled=True,
visible=True,
tooltip="Sliders",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="slider_push",
text="Sliders!",
callback=self.event_handler,
width=10,
height=1,
)
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a RadioButton instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|---------------|---------------|--------------|---------------------------------------------------------------------|--------------|
| scale_factor | | float | The scale factor calculated from the percentage | |
| scale_factor | | None | Sets the scale factor as a percentage. | |
| | value | float | The scale factor as a percentage | ❌ |
| range_min_set | | None | Sets the minimum value of the slider.<br><br> | |
| | range_min | int | The minimum value of the slider. | ❌ |
| range_max_set | | None | Sets the maximum value of the slider.<br><br> | |
| | range_max | int | The maximum value of the slider. | ❌ |
| value_get | | int | <br><b>Returns:</b><br> - int: The value of the slider.<br> | |
| value_set | | None | Sets the value of the slider.<br><br> | |
| | value | int | The value to set the slider to. | ❌ |
| | block_signals | bool (False) | True, stop the slider from emitting signals, Otherwise emit signals | ✓ |
### Spacer
Calling Spacer in a layout will generate a Spacer control on a form. A Spacer control is
used to control layout, acting as filler.
Only the "width" and "height matter for a Spacer control. Although it is not
recommended, the "text_font" can be set which will alter the Spacer size.
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
<br>**Properties**
<br> A Spacer has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown, in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|---------------------------------------------------------------------------|----------|--------------|
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | ✓ |
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | ✓ |
<br>A fully loaded Spacer declaration:
<br><br>**Note: Only "width" and "height" need to be used for Spacers**
- Spacers can also have buddy controls and labels, but this would be considered a
very unusual "use case"
```
Spacer(width=1, height=2)
```
<br>**Methods**
<br>Although a subset of the [_qtpyBase_Control](#_qtpybase_control) methods may apply
to a Spacer instance, no methods are defined for Spacers, and it is not
anticipated any of the ancestral methods will be used.
## Spinbox
Calling Spinbox in a layout will generate a Spinbox control on a form. A
Spinbox control is used to enter numbers with up and down arrows so that
a user can quickly set a number.
<br>**Properties**
<br> A Spinbox has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|---------------------------------------------------------------------------|-----------|--------------|
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | ✓ |
| prefix | A text string appended to the front of the number display eg $ | str ("") | ✓ |
| range_max | The maximum value of the slider | int (100) | ✓ |
| range_min | The minimum value of the slider | int (0) | ✓ |
| single_step | The step size when a single step is taken | int (1) | ✓ |
| suffix | A text string appended to the end of the number display eg. km | str ("") | ✓ |
| tag | The system name of the Spinbox (required for updates) | str | ❌ |
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | ✓ |
<br>A fully loaded Spinbox declaration:
<br><br>**Note: Only "tag","range_min","range_max" and "callback" is usually needed**
<br>It is suggested to set width and height as the font selected might not automatically
size correctly.
```
Spinbox(
tag="spinbox",
label="Spin Box",
prefix="Far ",
suffix=" km",
callback=self.event_handler,
range_max=500,
range_min=0,
width=15,
height=1,
label_font=qtg.Font(
style=qtg.Font_Style.OBLIQUE,
backcolor="blue",
font_name="DejaVu Sans Mono",
forecolor="yellow",
size=10,
),
enabled=True,
visible=True,
tooltip="Spin Box",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="spinbox_push",
text="Spin Box!",
callback=self.event_handler,
width=10,
height=1,
)
),
),
),
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a Spinbox instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|----------|-------------------------------------------------------|--------------|
| value_get | | int | <br><b>Returns:</b><br> The value of the spinbox.<br> | |
| value_set | | None | | |
| | value | int | The value to set the spinbox to. | ✓ |
### Switch
Calling Switch in a layout will generate a Switch control on a form. A Switch
control is used to flick a setting on and off.
.
<br>**Properties**
<br> A Switch has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|---------------------------------------------|--------------|--------------|
| checked | True, Switch is on, Otherwise Switch is off | bool (False) | ✓ |
| label | Sets a text label to the left | str ("") | ✓ |
| text | Sets a text label to the right | str ("") | ✓ |
<br>A fully loaded Switch declaration:
<br><br>**Note: Only "tag","label","text" and "callback" are usually needed**
<br>It is suggested **NOT** to set width and height as the defaults suit the Switch style.
- It has been noted with a buddy_control it is necessary to adjust ```tune_vsize=-10```
Where 10 is an arbitrary figure and the programmer will need to experiment to find
the correct value
```
Switch(
tag="switch1",
label="SW1 Off",
text="SW1 On!",
callback=self.event_handler,
label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),
txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=15),
enabled=True,
visible=True,
height=1,
tooltip="Sw 1",
tune_hsize=-15,
tune_vsize=-10,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="switch_button_push",
text="SW1 Push Me!",
callback=self.event_handler,
width=15,
height=1,
)
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a Switch instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------------|---------------|-------------------------------|------------------------------------------------------------------------|--------------|
| button_checked | | bool | <br><b>Returns:</b><br> True - Switch is on, False - Switch is off<br> | |
| button_toggle | | None | Toggles the state of the Twitch | |
| | value | bool (True) | True - Switch on, False Switch off | ✓ |
| track_colour_set | | None | Sets the colour of the Switch track | |
| | disable | TEXT_COLORS (system disabled) | The disabled color of the Switch track | ❌ |
| | enable | TEXT_COLORS (system enabled) | The enabled color of the Switch track | ❌ |
| value_get | | bool | <br><b>Returns:</b><br> True - Switch is on, False - Switch is off<br> | |
| value_set | | None | | |
| | value | bool | True - Switch on, False Switch off | |
### Tab
Calling Tab in a layout will generate a Tab control on a form. A Tab control
can have multiple pages that can house [GUI Controls](#gui-controls-1).
<br>**Properties**
<br> A Tab control has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------------|-------------------------------------------------------------------------------------------------------------------|----------|--------------|
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (1) | ✓ ||
| page_right_margin | Controls the right margin of the [Container](#containers) that fills the form. <br>- Seldom Used <br>- in pixels | int (10) | ✓ |
| page_bottom_margin | Controls the bottom margin of the [Container](#containers) that fills the form. <br>- Seldom Used <br>- in pixels | int (50) | ✓ |
| tag | The system name of the Tab (required for application processing) | str | ❌ |
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (10) | ✓ ||
<br>A fully loaded Tab declaration:
<br><br>**Note: Only "tag" and "callback" are usually needed**
Creating a Tab control is a three-step process
<br>
- 1 Create the tab instance (label properties are optional)
<br><br>
```
tab = qtg.Tab(
tag="tab",
label="Example Tab",
label_font=qtg.Font(backcolor="yellow", forecolor="blue", size=20),
callback=self.event_handler,
width=35,
height=13,
)
```
- 2 Add pages (The control argument is mandatory, even if it is only an empty [Container](#containers))
- Here we add a VBoxContainer with an [Image](#image) and two [Buttons](#button)
as an example
- It is a good idea to declare the control layout as a separate declaration
(like tab in Step 1, except it will be a [Container](#containers)) as it will be clearer
- This means any [GUI Controls](#gui-controls-1), including another [Tab](#tab) control, can be
placed on a tab page
- **Note: Only "tag", "title" (tab page title), "control" and "callback" are usually needed**
```
tab.page_add(
tag="tab_pg1",
title="Page 1",
control=qtg.VBoxContainer(align=qtg.Align.CENTER).add_row(
qtg.Spacer(height=1),
qtg.Image(
tag="image",
# label="Image",
width=20,
height=20,
callback=self.event_handler,
image="example.jpg",
),
qtg.Spacer(height=1),
qtg.Button(
tag="add_page", text="Add Page", callback=self.event_handler
),
qtg.Button(
tag="delete_page",
text="Delete Page",
callback=self.event_handler,
),
),
)
```
- 3 Repeat Step 2 until done
Putting it all together, this is how to declare a Tab with one page ([Example 04](https://github.com/David-Worboys/QTPYGUI/blob/master/examples/example_04_tab_control.py))
```
def tab_definition() -> qtg.Tab:
"""Creates the tab control definition"""
# 1st Create a tab page layout (this could be in another function, file or method)
# Here we have an Image with two buttons layed out horizontally under it
tab_page_layout = qtg.VBoxContainer(align=qtg.Align.CENTER).add_row(
qtg.Spacer(height=1),
qtg.Image(
tag="image",
# label="Image",
width=20,
height=20,
callback=self.event_handler,
image="example.jpg",
),
qtg.Spacer(height=1),
qtg.HBoxContainer().add_row(
qtg.Button(
tag="add_page", text="Add Page", callback=self.event_handler
),
qtg.Button(
tag="delete_page",
text="Delete Page",
callback=self.event_handler,
),
),
)
# 2nd, Create the tab
tab = qtg.Tab(
tag="tab",
label="Example Tab",
label_font=qtg.Font(backcolor="yellow", forecolor="blue", size=20),
callback=self.event_handler,
width=35,
height=13,
)
# 3rd, Add Pages
tab.page_add(
tag="tab_pg1",
title="Page 1",
control=tab_page_layout,
)
return tab
```
And this is how the Tab control can be manipulated at application run time in the callback method "event_handler"
<br>
```
def event_handler(self, event: qtg.Action):
"""Handles form events
Args:
event (qtg.Action): The triggering event
"""
assert isinstance(event, qtg.Action), f"{event=}. Must be Action"
match event.event:
case qtg.Sys_Events.CLICKED:
if event.tag == "add_page":
# Get tab widget
tab_widget = cast(
qtg.Tab,
event.widget_get(container_tag="tab_container", tag="tab"),
)
# Add page
page_count = tab_widget.page_count()
new_page_tag = f"tab_page{page_count + 1}"
if tab_widget.page_exists(new_page_tag):
tab_widget.page_remove(new_page_tag)
tab_widget.page_add(
tag=new_page_tag,
title=f"Page {page_count + 1}",
control=qtg.VBoxContainer().add_row(
qtg.Label(
text=f"Page {page_count + 1}",
align=qtg.Align.CENTER,
),
qtg.Button(
text="Delete Page",
tag=f"delete_page{page_count + 1}",
callback=self.event_handler,
),
),
)
elif event.tag.startswith("delete_page"):
# Get tab widget
tab_widget = cast(
qtg.Tab,
event.widget_get(container_tag="tab_container", tag="tab"),
)
page_count = tab_widget.page_count()
page_tag = tab_widget.current_page_tag()
# Never delete the first page. page_index returns 0 if first page
if page_count == 1 or tab_widget.page_index(page_tag) == 0:
popups.PopError(
title="Error...",
message="A Tab Must Have One Page And First Page Can Not Be Deleted",
).show()
else:
# Delete page
tab_widget.page_remove(page_tag)
elif event.tag == "ok":
self.example_04.app_exit()
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a Tab instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------------|----------------|----------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| current_page_tag | | str | <br><b>Returns:</b><br> The current tab page tag<br> | |
| enable_get | | bool | | |
| | tag | str | The tag name of the Tab control or tab page depending on which enable state is required. | ❌ |
| enable_set | | int | <br><b>Returns:</b><br> 1 - Success, -1 - Failure<br> | |
| | enable (True) | bool | True - Enable the tab or tab page, False - Disable the tab or tab page. | ✓ |
| | tag ("") | str | The tag name of the tab or tab page depending on which enable state is required.<br>-If tag is "" then enable applies to all tab pages <br>-If tag is the Tab tag name then enable applies to the Tab control, Otherwise it applies to the tab page with the tag name | ✓ |
| page_add | | None | Creates and adds a new tab page <br><b>Returns:</b><br> The Tab control<br> | |
| | control | [Container](#containers) \| [GUI Control](#gui-controls) | The [Container](#containers) \| [GUI Control](#gui-controls) defining the tab page GUI layout | ❌ |
| | enabled (True) | bool | Sets the tab page enabled/disabled | ✓ |
| | icon | str [File Name] \| QPixmap \| qtG.QIcon (None) | Add an icon to the tab page title | ✓ |
| | tag | str | Tab page tag | ❌ |
| | title | str | Tab page title | ❌ |
| | tooltip ("") | str | The tab page tooltip | ✓ |
| | visible (True) | bool | Sets the tab page visible/invisible | ✓ |
| page_count | | int | <br><b>Returns:</b><br> The number of tab pages<br> | |
| page_exists | | bool | <br><b>Returns:</b><br> True if the tab page exists<br> | |
| | tag | str | The tag name of the tab page | ❌ |
| page_icon_set | | None | Sets a tab page icon | |
| | icon | str [File Name] \| QPixmap \| qtG.QIcon (None) | Add an icon to the tab page title | ❌ |
| | tag | str | The tag name of the page whose icon is to be set on. | ❌ |
| page_index | | int | <br><b>Returns:</b><br> The index of the tab page or -1 if tab not found<br> | |
| | tag | str | The tag name of the tab page | ❌ |
| page_remove | | None | Removes a tab page from the tab widget | |
| | tag | str | tag name of the page to be removed | ❌ |
| pages_remove_all | | None | Removes all the pages from the Tab control | |
| page_visible_get | | bool | <br><b>Returns:</b><br> `<br>True` if the tab page with the given tag name is visible, `False` otherwise<br> | |
| | tag | str | tag name of the page to be checked | ❌ |
| page_visible_set | | None | Sets the visibility of a tab page | |
| | tag | str | tag name of the page to be set | ❌ |
| | visible | bool | True to make the page visible, False to hide it | ❌ |
| select_tab | | None | Selects the tab page with the given tag name | |
| | tag_name | str | The tag name of the tab page to be selected | ❌ |
| tooltip_get | | str | <br><b>Returns:</b><br> The tooltip text for the tab page with the tag name.<br> | |
| | tag | str | The tag name of the tab to get the tooltip from. | ❌ |
| tooltip_set | | None | Selects the tab page with the given tag name | |
| | tag | str | tag name of the tab page to set the tooltip text | ❌ |
| | tooltip | str | The tooltip text | ❌ |
### TextEdit
Calling TextEdit in a layout will generate a TextEdit control on a form.
A TextEdit control is used to enter a large amount of text.
<br>**Properties**
<br> A TextEdit control has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|--------------|---------------------------------------------------------------------------------------------------|---------------|--------------|
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (1) | ✓ | |
| max_chars | The maximum number of characters that can be entered into the TextEdit control | int (-1) | ✓ |
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (10) | ✓ | |
| word_wrap | True, text line wraps, Otherwise it does not | bool (True) | ✓ |
| tag | The system name of the TextEdit control (required for application processing) | str | ❌ |
<br>A fully loaded TextEdit declaration:
<br><br>**Note: Only "tag", "text" (To preload the TextEdit control) and "callback" are usually needed**
- It is possible to paste text into the TextEdit control and to a large degree
this will retain the original formatting
```
TextEdit(
tag="textedit",
text="Text Edit",
label="Text Edit",
callback=self.event_handler,
height=5,
max_chars=10,
word_wrap=True,
label_font=qtg.Font(
style=qtg.Font_Style.OBLIQUE, backcolor="blue",forecolor="yellow", size=12
),
txt_font=qtg.Font(
style=qtg.Font_Style.NORMAL, backcolor="yellow", size=15,font_name="DejaVu Sans Mono"
),
enabled=True,
visible=True,
tooltip="Text Edit",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="textedit_push",
text="Text Edit!",
callback=self.event_handler,
width=10,
height=1,
)
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a TextEdit instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|-------------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| value_get | | str | Returns the text from the TextEdit` widget as either plain text or HTML<br><b>Returns:</b><br> The text in the text box in the selected format.<br> | |
| | plain_text (True) | bool | True - Returns the text as plain text, Otherwise Returns the text as HTML. | ✓ |
| value_set | | None | Sets the text of the widget to the string value | |
| | value | str | The string value to set the TextEdit widget to. | ❌ |
### Timeedit
Calling Timeedit in a layout will generate a Timeedit control on a form.
A Timeedit control is used to enter the time.
<br>**Properties**
<br> A Timeedit control has the following properties, but can also use a subset of
[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the "fully loaded" example below
| **Property** | **Description** | **Type** | **Optional** |
|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|--------------|
| display_format | The time format display | str ("hh:mm") | |
| display_width | The width of the display. It is unlikely this will need setting | int (10) | |
| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. It is unlikely this will need setting but this depends on the display format mask | int (1) | ✓ |
| hour | The hour as an integer number | int (-1) | |
| min | The minute as an integer number | int (-1) | |
| sec | The second as an integer number | int (-1) | |
| msec | The milliseconds as an intger number | int (-1) | |
| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting if the display format is different from the default | int (10) | ✓ |
| tag | The system name of the TextEdit control (required for application processing) | str | ❌ |
| validate_callback | A callback that validates the time entered | Callable\| None (None) | ✓ |
<br>**Display Format Mask Characters**
| **Format** | **Description** |
|------------|------------------------------------------------------------------------|
| h | the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display) |
| hh | the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display) |
| m | the minute without a leading zero (0 to 59) |
| mm | the minute with a leading zero (00 to 59) |
| s | the second without a leading zero (0 to 59) |
| ss | the second with a leading zero (00 to 59) |
| z | the milliseconds without leading zeroes (0 to 999) |
| zzz | the milliseconds with leading zeroes (000 to 999) |
| AP | interpret as an AM/PM time. AP must be either “AM” or “PM”. |
| ap | Interpret as an AM/PM time. ap must be either “am” or “pm”. |
<br>A fully loaded Timeedit declaration:
<br><br>**Note: Only "tag", "hour", "min", "sec","msec"" (If the Timedit is to be preloaded then all these properties are required) and "callback" are usually needed**
```
Timeedit(
tag="timeedit",
label="Time Edit",
callback=self.event_handler,
hour=12,
min=23,
sec=1,
msec=0,
txt_font=qtg.Font(
style=qtg.Font_Style.NORMAL,
backcolor="wheat",
forecolor="darkgray",
size=15,
font_name="DejaVu Sans Mono",
),
label_font=qtg.Font(
style=qtg.Font_Style.OBLIQUE,
backcolor="blue",
forecolor="yellow",
size=20,
),
enabled=True,
visible=True,
tooltip="Time Edit",
tune_hsize=15,
tune_vsize=15,
user_data={"key": "value"},
buddy_control=qtg.HBoxContainer().add_row(
qtg.Button(
tag="timeedit_push",
text="Time Edit!",
callback=self.event_handler,
width=10,
height=1,
)
),
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods also apply to a TextEdit instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| clear | | None | Clears the displayed value | |
| | default_text | str ("-") | The time text string or "-" for no time text to be `displayed | ✓ |
| time_get | | [Time_Struct](#time_struct) | <br><b>Returns:</b><br> [Time_Struct](#time_struct) (hour,min,sec,msec)<br> | |
| time_set | | None | Sets the time.<br>If the hour = -1 & min = -1 & sec = -1 & msec = -1 then the displayed value is cleared<br> All arguments must be set | |
| | hour | int (-1) | Hour value | ✓ |
| | min | int (-1) | Minute value | ✓ |
| | msec | int (-1) | Millisecond value | ✓ |
| | sec | int (-1) | Second value | ✓ |
| value_get | | str\| [Time_Struct](#time_struct) | Returns the time value | |
| | format | str ("-") | Format string. <br>If "-" then the time is returned as a string formatted to system short-format <br>if "" then a [Time_Struct](#time_struct) is returned<br>Otherwise the format statement is used and a formatted time string returned | ✓ |
| | time_struct | bool (False) | If True return a [Time_Struct](#time_struct), Otherwise return a string | ✓ |
| value_set | | None | | |
| | hour | int (-1) | Hour value | ✓ |
| | min | int (-1) | Minute value | ✓ |
| | msec | int (-1) | Millisecond value | ✓ |
| | sec | int (-1) | Second value | ✓ |
### Treeview
Calling Treeview in a layout will generate a Treeview control on a form.
<br>**Properties**
| **Property** | **Description** | **Type** | **Optional** |
|----------------|-----------------------------------------------------------------|----------------------------------|--------------|
| headers | Set this if a Treeview requires headers | list[str] \| tuple[str, ...]] () | ✓ |
| header_widths | The header item widths, defaults to 15 if not set | tuple[int, ...] \| list[int]] () | ✓ |
| header_font | The font of the header text | [Font](#font) | ✓ |
| height | Height of Treeview in chars | int (15) | ✓ |
| multiselect | True select multiple items, Otherwise select only a single item | bool (False) | ✓ |
| toplevel_items | A tuple or list of toplevel items | list[str] \|tuple[str, ...] () | ✓ |
| width | Width of Treeview in chars | int (40) | ✓ |
<br>A fully loaded Treeview declaration:
<br><br>**Note: Only "tag", "toplevel_items" (To preload the Treeview control) and "callback" are usually needed**
```
Treeview(
tag="treeview",
label="Treeview",
callback=self.event_handler,
width=15,
height=5,
toplevel_items=["Test 1", "Test 2"],
)
```
<br><br>
In the event_handler method child nodes can be added as needed:
```
def event_handler(self, event: qtg.Action):
"""Handles form events
Args:
event (qtg.Action): The triggering event
"""
assert isinstance(event, qtg.Action), f"{event=}. Must be Action"
match event.event:
case qtg.Sys_Events.APPPOSTINIT:
treeview = event.widget_get(container_tag="row_5",tag="treeview")
treeview.child_add(treeview_path="Test 1", items="Test 3")
treeview.child_add(
treeview_path=["Test 1", "Test 3"], items="Test 4"
)
```
<br>**Methods**
<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods also apply to a Treeview instance
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|--------------------|---------------|----------|---------------------------------------------------------------------------------------------|--------------|
| child_add | | int | <br><b>Returns:</b><br> 1 Succeeded, -1 Failed<br> | |
| child_checked | | None | <br><b>Returns:</b><br> 1 Succeeded, -1 Failed<br> | |
| | checked | bool | True - Checked, False - Unchecked | |
| toplevel_add | | None | | |
| toplevel_items_get | | None | <br><b>Returns:</b><br> A list of strings.<br> | |
| value_get | | None | <br><b>Returns:</b><br> Current Tree view node value tuple (node text, node user value)<br> | |
| value_set | | None | | |
| | col | int | The column to set. Default is 0. | |
| | value | str | The value to set. | |
| widget_set | | None | | |
| | col | int | The column number to place the widget in | |
### QTPYGUI Enumerated Types/Helper Class Reference
The following enumerated types and helper classes are used to define the features and
behaviour of QTPYGUI
### Action
The Action class is crucial as it is the sole argument of the event handler
and has methods and properties that are essential for implementing QTPYGUI
programs.
**Properties**
| **Property** | **Description** | **Type** |
|---------------|-------------------------------------------------------------------------------------------------------|-------------------------------------------|
| action | The event name as a str | str |
| container_tag | The name of the [Container](#containers) housing the widget that triggered the event | str |
| control_name | The type name of the [GUI Control](#gui-controls-1) triggering the event (e.g. [Button](#button)) | str |
| event | The enumerated name of the event (Preferred over action) | Sys_Events |
| object | A reference to the internal Event_Handler class (Generally not used) | _Event_Handler (Internal Class) |
| window_id | The window id of the window housing the widget (Generally not used) | int |
| parent_app | The parent application of the widget (Generally not used) | QtPyApp |
| parent_widget | The parent widget of the event that was triggered | [GUI Controls](#gui-controls-1) |
| tag | The name of the [GUI Control](#gui-controls-1) triggering the event | str |
| value | The value of the [GUI Control](#gui-controls-1) triggering the event (Some events never have a value) | any \| None |
| widget_dict | The widget dictionary of the container as an internal _Widget_Entry class (Generally not used) | dict[str, _Widget_Registry._Widget_Entry] |
<br>
**Methods**
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|--------------|---------------|--------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| trans_str | | str | It takes a string, translates it, and returns the translated string<br><b>Returns:</b><br> The translated text.<br> | |
| | text | str | The text to be translated. | ❌ |
| value_get | | any | Returns the value sourced from a given widget<br><b>Returns:</b><br> The value of the widget.<br> | |
| | container_tag | str | The tag name of the container that the widget is in. | ❌ |
| | tag | str | The tag name of the widget you want to get the value of. | ❌ |
| value_set | | None | Sets the value of a widget | |
| | container_tag | str | The tag name of the container widget that the widget is in. | |
| | tag | str | The tag name of the widget you want to set the value of. | ❌ |
| | value | any | The value to set the widget to. | ❌ |
| widget_del | | None | Deletes a widget from a container <br> Use widget_exist before widget_delete to ensure the widget exists | |
| | container_tag | str | The tag name of the container widget that the widget to be deleted is in. | ❌ |
| | tag | str | The tag name of the widget to be deleted. | ❌ |
| widget_exist | | bool | Determines if a widget with the given tag name exists in the given container<br><b>Returns:</b><br> True if the widget exists, False otherwise.<br> | |
| | container_tag | str | The tag name of the container widget that contains the widget you want to check. | ❌ |
| | tag | str | The tag name of the widget you want to check for. | ❌ |
| widget_get | | [GUI Controls](#gui-controls-1) \| [Containers](#containers) | Gets a widget from a container<br><b>Returns:</b><br> The requested widget.<br>If the requested widget does not exist a runtime error is raised<br> Use widget_exist before widget_get to ensure the widget exists<br> | |
| | container_tag | str | The tag name of the container widget that holds the widget you want to get. | ❌ |
| | tag | str | The tag name of the widget to get. | ❌ |
#### Align
Align is an enumerated type used in defining the alignment of [Containers](#containers) and [GUI Controls](#gui-controls-1)
| **Property** | **Description** | **Type** |
|--------------|-----------------|----------------------------------|
| LEFT | | Qt.AlignLeft |
| CENTER | | Qt.AlignCenter |
| CENTERLEFT | | Qt.AlignCenter \| Qt.AlignLeft |
| CENTERRIGHT | | Qt.AlignCenter \| Qt.AlignRight |
| RIGHT | | Qt.AlignRight |
| TOP | | Qt.AlignTop |
| TOPCENTER | | Qt.AlignTop |
| TOPLEFT | | Qt.AlignTop \| Qt.AlignLeft |
| TOPRIGHT | | Qt.AlignTop \| Qt.AlignRight |
| BOTTOM | | Qt.AlignBottom |
| VCENTER | | Qt.AlignVCenter |
| HCENTER | | Qt.AlignHCenter |
| BOTTOMCENTER | | Qt.AlignBottom \| Qt.AlignCenter |
| BOTTOMLEFT | | Qt.AlignBottom \| Qt.AlignLeft |
| BOTTOMRIGHT | | Qt.AlignBottom \| Qt.AlignRight |
#### Align_Text
Align_Text is an enumerated type that aligns text using style sheet type
declaration (Some controls will remap to [Align](#align) types)
| **Property** | **Description** | **Type** |
|--------------|-----------------|-------------------|
| LEFT | | text-align:left |
| CENTER | | text-align:center |
| RIGHT | | text-align:right |
| TOP | | text-align:top |
| BOTTOM | | text-align:bottom |
### Char_Pixel_Size
Char_Pixel_Size is a helper class that stores the width and height values in
pixels
| **Property** | **Description** | **Type** |
|--------------|------------------|----------|
| height | Height in pixels | int |
| } width | Width in pixels | int |
#### Combo_Data
Combo_Data is a helper class used to store data sourced from combo box items
| **Property** | **Description** | **Type** |
|--------------|--------------------------------------|--------------------------------------------------------------------|
| display | Text displayed in dropdown row | str |
| data | user data held in dropdown row | str, int, float, bytes, bool, None |
| index | Row index of data item | int >= 0 |
| user_data | Data stored by user in dropdown row | None , str, int , float , bytes , bool , tuple , list , dict, None |
#### Col_Def
Col_Def is a helper class used to set the column attributes of grid controls. All attributes are mandatory.
| **Property** | **Description** | **Type** |
|--------------|-----------------------------------------------------------------------------------------------|----------|
| checkable | The column rows have a check-box if True, Otherwise no checkbox is displayed | bool |
| editable | The column rows can be edited if True, Otherwise the column rows can not be edited | bool |
| label | the label displayed in the columns first row denoting the column name | str |
| tag | The application name for the column | str |
| width | The width of the column in chars if GUI control argument pixel_unit is True, Otherwise pixels | int > 0 |
#### Combo_Item
Combo_Item is a helper class used to set combo box items. All attributes are mandatory.
| **Property** | **Description** | **Type** |
|--------------|----------------------------------------|--------------------------------------------------------------------|
| display | Text displayed in dropdown row | str |
| data | user data held in dropdown row | str, int, float, bytes, bool, None |
| icon | The icon image displayed on the button | str [File Name]<br/>,QIcon,QPixmap, None |
| user_data | Data stored by user in dropdown row | None , str, int , float , bytes , bool , tuple , list , dict, None |
#### Coords
Coords is a helper class used by [Image](#image) helper classes to represent co-ordinates
**Properties**
| **Property** | **Description** | **Type** |
|--------------|-----------------------------------------------|----------|
| top | Top position in pixels | NUMBER |
| left | Left position in pixels | NUMBER |
| height | Height in pixels | NUMBER |
| width | Width in pixels | NUMBER |
| area | Calculates the area of the Coords | NUMBER |
| perimeter | Calculates the perimeter length of the Coords | NUMBER |
| diagonal | Calculates the diagonal length of the Coords | NUMBER |
**Methods**
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|-------------|----------------------------------------------------------------------------|--------------|
| overlaps | | bool | True if another set of Coords overlaps this set of Coords, Otherwise False | |
| | other_cords | Coords | The other set of coordinates to check for overlap | ❌ |
| | overlap_ratio | float (0.3) | The ratio to determine overlapping. 0 - No overlap to 1 - Complete overlap | ✓|
### CSV_File_Def
CSV_File_Def is a helper class used by the [Combobox](#combobox) to load a csv file.
| **Property** | **Description** | **Type** | **Optional** |
|---------------|-------------------------------------------------|-------------|--------------|
| data_index | The column in the file to load into user data | int (1) | ✓ |
| delimiter | CSV file field separator | str (",") | ✓ |
| file_name | The path to the CSV file | str | ❌ |
| ignore_header | Set True if the CSV file has a header row | bool (true) | ✓ |
| line_start | The line in the file to start loading data from | int (1) | ✓ |
| select_text | The text to select after load | str (") | ✓ |
| text_index | The column in the CSV file to load into display | int (1) | ✓ |
### Date_Tuple
Date_Tuple is a helper class used by [Dateedit](#dateedit) to store the date.
Basic date validation checks are done.
| **Property** | **Description** | **Type** |
|--------------|-----------------|----------|
| year | The year | int |
| month | The month | int |
| day | The day | int |
#### Font
Font is a helper class that defines the [font](#font) properties, utilised in
font related arguments in GUI control definitions.
Colours are checked to ensure they are valid and will raise an assertion error
if they are not.
| **Property** | **Description** | **Type** |
|--------------|-----------------------------|--------------------------------------|
| backcolor | Background colour | str ("") |
| forecolor | Foreground colour | str ("") |
| font_name | The font name | str ("") |
| selectback | Selection background colour | str ("") |
| selectfore | Selection foreground colour | str ("") |
| size | The font point size | int (10) |
| style | The font style | [Font_Style](#font_style) (NORMAL) |
| weight | The font weight | [Font_Weight](#font_weight) (NORMAL) |
#### Font_Style
Font_Style is an enumerated type that defines the style of the [font](#font)
| **Property** | **Description** | **Type** |
|--------------|-------------------------------|--------------------|
| NORMAL | Font has no special features | QFont.StyleNormal |
| ITALIC | Defines font as italic style | QFont.StyleItalic |
| OBLIQUE | Defines font as oblique style | QFont.StyleOblique |
#### Font_Weight
Font_Weight is an enumerated that defines the weight of the [font](#font)
| **Property** | **Description** | **Type** |
|--------------|-----------------------------------------------------|------------|
| BLACK | Defines the font as black | Enumerated |
| BOLD | Defines the font as bold | Enumerated |
| DEMIBOLD | Defines the font as demibold | Enumerated |
| EXTRABOLD | Defines the font as extra bold | Enumerated |
| EXTRALIGHT | Defines the font as extra light | Enumerated |
| LIGHT | Defines the font as light | Enumerated |
| MEDIUM | Defines the font as medium | Enumerated |
| NORMAL | Defines the font as normal with no special features | Enumerated |
| THIN | Defines the font as thin | Enumerated |
#### Frame
Frane is an enumerated type that defines the frame of a GUI control where supported
| **Property** | **Description** | **Type** |
|--------------|-----------------|-------------------|
| PLAIN | A flat frame | qtW.QFrame.Plain |
| RAISED | A raised frame | qtW.QFrame.Raised |
| SUNKEN | A sunken frame | qtW.QFrame.Sunken |
#### Frame_Style
Frame_Style is an enumerated type that defines the frame of a GUI control where supported
| **Property** | **Description** | **Type** |
|--------------|-------------------------|------------------------|
| BOX | A box frame | qtW.QFrame.Box |
| PANEL | A panel frame | qtW.QFrame.Panel |
| HLINE | A horizontal line frame | qtW.QFrame.HLine |
| NONE | No frame | qtW.QFrame.NoFrame |
| VLINE | A vertical line frame | qtW.QFrame.VLine |
| WPANEL | A window panel frame | qtW.QFrame.WinPanel |
| STYLED | A Styled panel frame | qtW.QFrame.StyledPanel |
### Grid_Item
Grid_Item is a helper class used by [Grid](#grid) to store row information
| **Property** | **Description** | **Type** |
|---------------|-------------------------------------|----------|
| row_index | The row index | int |
| col_index | The column index | int |
| tag | The tag of the row/col | str |
| current_value | The existing value in the row/col | any |
| user_data | The user data stored in the row/col | any |
### Overlap_Rect
Overlap_Rect is a helper class used by [Image](#image) to represent the overlapping
of two rectangles
| **Property** | **Description** | **Type** |
|--------------|--------------------------|-------------------|
| a_rect_id | Rectangle A Id | str |
| a_coords | Rectangle A Co-ordinates | [Coords](#coords) |
| b_rect_id | Rectangle B Id | str |
| b_coords | Rectangle B Co-Ordinates | [Coords](#coords) |
### Rect_Changed
Rect_Changed is a helper class used by [Image](#image) to represent a changed rectangle
| **Property** | **Description** | **Type** |
|--------------|------------------------|-------------------|
| rect_id | Rectangle Id | str |
| coords | Rectangle Co-ordinates | [Coords](#coords) |
### Rect_Cords
Rect_Cords is a helper class used by [Image](#image) to represent a rectangle
| **Property** | **Description** | **Type** |
|--------------|-------------------------|-------------------|
| rect_id | Rectangle Id | str |
| coords | Rectangle co-ordinates | [Coords](#coords) |
| left | Left position in pixels | int |
| top | Top position in pixels | int |
| width | Width in pixels | int |
| height | Height in pixels | int |
### Sys_Events
A Sys_Event is the enumerated type assigned to the [Action](#action) event
property that reflects the type of GUI event that was triggered.
| **Property** | **Description** | **Type** |
|---------------------|------------------------------------------------------------|----------|
| APPINIT | The application is being initialised | int = 0 |
| APPPOSTINIT | The application just finished initialising | int = 1 |
| APPCLOSED | The application is being closed | int = 2 |
| APPEXIT | The application is exiting | int = 3 |
| ACTIVATED | The widget has been activated | int = 5 |
| BADINPUT | The input is not valid | int = 4 |
| CHANGED | The widget has changed | int = 6 |
| CLEAR_TYPING_BUFFER | A [Grid](#grid) widget is about to clear the typing buffer | int = 7 |
| CLICKED | The widget has been clicked | int = 8 |
| COLLAPSED | A node has been collapsed | int = 9 |
| CLOSED | The widget has been closed | int = 10 |
| CURSORCHANGED | The cursor has changed | int = 11 |
| DATECHANGED | The date has changed | int = 12 |
| EDITCHANGED | The text has changed | int = 13 |
| ENTERED | The widget has been entered | int = 14 |
| EXPANDED | A node has been expanded | int = 15 |
| DOUBLECLICKED | The widget has been double-clicked | int = 16 |
| FOCUSIN | The widget has gained focus | int = 17 |
| FOCUSOUT | The widget has lost focus | int = 18 |
| GROUPINIT | The group has been initialised | int = 19 |
| HIGHLIGHTED | The widget has been highlighted | int = 20 |
| INDEXCHANGED | The index has changed | int = 21 |
| MAXCHARS | The maximum number of characters has been reached | int = 22 |
| MENUCLICKED | The menu has been clicked | int = 23 |
| MOVED | A control generated a moved event | int = 24 |
| PRESSED | The widget has been pressed | int = 25 |
| RELEASED | The widget has been released | int = 26 |
| POPUP | The popup has been shown | int = 27 |
| POPCAL | The popup calendar has been shown | int = 28 |
| POSTINIT | The post init event has been triggered | int = 29 |
| SCROLLH | The horizontal scroll bar has been moved | int = 30 |
| SCROLLV | The vertical scroll bar has been moved | int = 31 |
| SELECTIONCHANGED | The selection has changed | int = 32 |
| TEXTCHANGED | The text has changed | int = 33 |
| TEXTEDIT | The text has been edited | int = 34 |
| TIMECHANGED | The time has changed | int = 35 |
| TOGGLED | The widget has been toggled | int = 36 |
| TRIGGERED | The widged has triggered | int = 37 |
| WINDOWCLOSED | The window has been closed | int = 38 |
| WINDOWOPEN | The window has been opened | int = 39 |
| WINDOWPOSTOPEN | Triggered after the window has been opened | int = 40 |
| CUSTOM | Where the user wants to hotwire an event for their own use | int = 41 |
### Time_Struct
Time_Struct is a helper class used by [Timeedit](#timeedit) to return Time information
| **Method** | **Arguments** | **Type** | **Description** | **Optional** |
|------------|---------------|----------|----------------------|--------------|
| hour | | int | Get the hour | |
| hour | | None | Set the hour | |
| | value | int | The hour | ❌ |
| min | | int | Get the minute | |
| msec | | int | Get the milliseconds | |
| msec | | None | Set the milliseconds | |
| | value | int | The milliseconds | ❌ |
| sec | | int | Get the second | |
| sec | | None | Set the second | |
| | value | int | The seconds | ❌ |
#### Widget_Frame
Widget_Frame is a helper class that defines the style of the frame around a widget
| **Property** | **Description** | **Type** |
|---------------|-----------------|-----------------------------|
| frame | | [Frame](#frame) |
| frame_style | | [Frame_Style](#frame_style) |
| line_width | | int =3 |
| midline_width | | int = 0 |
# TO BE CONTINUED....
Raw data
{
"_id": null,
"home_page": null,
"name": "QTPYGUI",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "pypi, cicd, pyside6, ui, gui, qt, qtpygui, declarative, wrapper, user-interface, qt-bindings, python-qt, gui-framework, ui-library, pyside6-wrapper, pyside",
"author": null,
"author_email": "David Worboys <davidaworboys@gmail.com>",
"download_url": null,
"platform": null,
"description": "# QTPYGUI\n### Author: David Worboys \n##### 2024-04-11 - Initial Draft\n##### Update\n## Index\n1. [Introduction](#introduction)\n2. [Installation](#installation)\n3. [Basic Concepts](#basic-concepts)\n - [Containers](#containers)\n - [GUI Controls](#gui-controls)\n - [Event Handling](#event-handling)\n4. [Hello World Application](#building-your-first-application)\n5. [Application Distribution](#distributing-your-application)\n6. [Boot Camp](#boot-camp)\n7. [QTPYGUI Control Reference](#qtpygui-control-api-reference) \n8. [QTPYGUI Enumerated Types/Classes](#qtpygui-enumerated-typesclass-reference)\n\n## Introduction\nQTPYGUI is a declarative user interface wrapper around Pyside6 and, as there are \na number of GUI (Graphical User Interface) wrappers around various widget sets,\nincluding Pyside6, the natural question is why another one? The answer lies in \nat least two parts, my dissatisfaction with how the other GUI wrappers were \nimplemented/managed and because I could and there is much to be learned with \nthat approach.\n\nThe next question the reader might find themselves asking is why not a web UI\nbased on the old favourites of HTML, CSS and Javascript, something like React \nperhaps? I am a firm believer in \"horses for courses\", so why bring a browser to\nthe desktop fight and all the resources, memory/compute, that entails when a \nwell-designed widget set with better performance and memory usage is \navailable. Worse, building web apps is a complicated business even with the\nweb UI frameworks, of course some may same the same of desktop widget sets, and \nthis is where GUI wrappers like QTPYGUI come in.\n\nIn closing, it is worth noting that a major advantage in utilising a GUI wrapper,\naside from ease of programming, is that if the underlying widget set is \ndeprecated, or licensing changes, then the GUI wrapper can change widget sets.\nAlthough this would be a large task, the major benefit is that applications using \nthe GUI wrapper will be minimally impacted.\n\n### What Is A Declarative User Interface?\nA declarative UI (user interface) is an application user interface coded in\nthe application source code using a formal specification. There is no need for\nGUI designers, and the application programmer writes the UI as just another \npart of the code. This is an old idea, going back at least to the early 1980's\nand applications like dBase II and Clipper but just because it is old does not \nmean it is bad or not relevant.\n\n### Notes\n1. Development of QTPYGUI started privately in 2020, moving to a public release in 2024.\n - This version is an early public release and doco and code streamlining is onging.\n \n - Although QTPYGUI is used in production applications, there are bound to be bugs, \n certainly Dateedit and Treeview need much more work as they are infrequently \n used.\n \n - The feature set of other GUI components needs to be widened. Missing also is\n theming and this will be required for a larger audience.\n\n2. **HELP IS WANTED AND I WELCOME ALL CONTRIBUTIONS!**\n\n - Please reach out to me via Discussions (https://github.com/David-Worboys/QTPYGUI/discussions)\n if you want to help or have ideas on improvements\n \n - Bugs can be logged at https://github.com/David-Worboys/QTPYGUI/issues \n\n3. QTPYGUI will always remain opensource, unlike some other similar frameworks\n that used \"bait and switch\" tactics\n\n4. QTPYGUI uses Python 3.11 for development and ruff (https://github.com/astral-sh/ruff)\nfor formatting. Type hinting is mandatory as are asserts to check all arguments to \nfunctions/methods\n\n5. My time is limited (both figuratively and literally), but I will put in as \nmuch effort as I can to help move things along\n\n6. I strongly suggest using Nutika (https://nuitka.net/) to distribute your \nPython desktop applications. I use this method exclusively with great success.\n\n7. Finally, to the reader's relief, I only use Linx Mint for development and \ndo not have access to a Windows installation, and therefore\n\n - ***HELP IS Neeeded \n To Verify QTPYGUI's Operations Under Windows***\n\n\n### Where To Find An Application That Uses QTPYGUI?\nhttps://github.com/David-Worboys/Black-DVD-Archiver\n\n\n\n## QTPYGUI 101\nFirst up, QTPYGUI is pronounced \"Cutey Pie GUI\" which follows the \"QT Groups\"\nown pronunciation and appeals to my, admitably lame, sense of humour.\n### Prerequities\n1. Python version >= 3.8 \n - If Nuitka is used for application distribution, then Python versions 3.12 \n and above are not currently supported.\n### Installation\n1. Create your Python project folder and set up your Python project using \nthe virtual environment manager of your choice\n\n2. pip install QTPYGUI\n\n### Boot Camp\nFirst up, check out the examples in https://github.com/David-Worboys/QTPYGUI/tree/master/examples .\nThere is one example per python source file, and I will be adding more as time \nprogresses.\n\n#### Basic Concepts\n1. QTPYGUI is event driven and there are no \"busy\" loops waiting for something\nto happen\n\n2. By default, width and height settings are in characters\n - Pixels can be used as an argument is provided to allow for this\n - This works best with monospaced fonts\n \n - The default font is \"IBM Plex Mono\" and the default font size is 10\n - This is included in the installation of QTPYGUI \n - If this font is missing, then QTPYGUI will try and find a system font that \n will work\n\n3. The basic structure of a QTPY GUI Program is as follows:\n\n```\nimport QTPYGUI.qtpygui as qtg\n\nClass Example_App\n def __init__(self):\n \"\"\" Setup application instance variable \"\"\"\n self.example_app = qtg.QtPyApp(\n display_name=\"Example App\",\n callback=self.event_handler,\n height=100,\n width=100,\n ) \n \n def event_handler(self, event: qtg.Action):\n \"\"\"Handles events\"\"\"\n \n def layout()-> qtg.VBoxContainer:\n \"\"\" Defines The User Interface Layout \"\"\"\n \n def run(self):\n \"\"\"Run Example App\"\"\"\n self.example_app.run(layout=self.layout())\n \nif __name__ == \"__main__\":\n example_app = Example_App()\n example_app.run() \n \n```\n1. This defines the structure of the application main.py file\n\n2. https://github.com/David-Worboys/QTPYGUI/blob/master/examples/example_01.py\nshows this in action.\n\n3. The python classes that utilise a GUI are defined as below:\n```\nimport QTPYGUI.qtpygui as qtg\n\nClass Example_Class:\n def event_handler(self, event: qtg.Action):\n \"\"\"Handles events\"\"\"\n \n def layout()-> qtg.VBoxContainer:\n \"\"\" Defines The User Interface Layout \"\"\" \n\n```\n1. When the Example_Class is instantiated, the layout method is called to \ngenerate the GUI elements of the display and this is assigned to the calling \nwindow/GUI object\n\n##### Containers\nContainers are at the heart of the QTPYGUI system and define the layout of the \nGUI items. The following are four types of containers:\n\n- FormContainer\n - Lays out [GUI Controls](#gui-controls-1) vertically as per the associated platform (Linux, \n Windows, Mac) GUI specifications\n- HBoxContainer\n - Lays out the [GUI Controls](#gui-controls-1) horizontally \n \n- VBoxContainer\n - Lays out the [GUI Controls](#gui-controls-1) vertically, similar to the FormContainer but does\n not adhere as tightly to the associated platform specifications\n \n- GridContainer\n - Lays out the [GUI Controls](#gui-controls-1) as a grid. This container is seldom used.\n\nTo add a GUI control to a container, the ```add_row``` method is used as below:\n\n```\nqtg.HBoxContainer(tag=\"button_example\").add_row(\n qtg.Button(\n tag=\"example_1\", text=\"Example 1\", callback=self.event_handler, width=10\n ),\n qtg.Button(\n tag=\"example_2\", text=\"Example 2\", callback=self.event_handler, width=10\n ),\n) \n```\n- This will lay out two Buttons Horizontally. If a FormContainer or a VBoxContainer\nwas used, the buttons would be laid out vertically.\n\n- **Note the use of the tag, text and callback arguments as these are fundamental\nto the operation of QTPYGUI [GUI Controls](#gui-controls)**\n - If a Container has a text argument, it becomes a Group box.\n\n##### GUI Controls\nThese are the GUI components that comprise the UI of an application. Declaring them\nutilises a standard pattern of arguments with additional arguments for specific\n[GUI Controls](#gui-controls-1).\n\n**Note: If an argument is not supported by a GUI control, it is ignored.**\n\nLet us consider the Button GUI control\n\n````commandline\nqtg.Button(tag=\"example_1\", text=\"Example 1\",label=\"Click Me!\", callback=self.event_handler)\n````\n**Note: The following arguments are common to all QTPYGUI controls**\n\n\"tag\" \u2014 The \"tag\" is the name of the control, as it is housed in a container \nthen the container \"tag\" and the button \"tag\" make a unique pair.\n- This makes it easier to code larger applications as each GUI element \n does not have to have a unique name.\n \n- If a \"tag\" is not provided, then the application generates one automatically.\n - This is fine for \"Container\" and \"Label\" objects where the programmer does \n not intend to reference an object. \n \n\"text\" \u2014 The \"text\" is the text displayed on the control, it is optional\n\n\"label\" \u2014 The \"label\" argument places a label to the left of the control, it is\noptional\n\n\"callback\" \u2014 Is the name of the method that will process the events generated\nby the GUI control. By convention, I declare this as the \"event_handler\" method. \n\n- If a callback method is not provided, then the control cannot send events to it\n\n- The \"event_handler\" method takes only one argument\u2014the [Action](#action) \ninstance whose properties and methods are at the heart of QTPYGUI programming \n \n \n\n\n##### Event Handling\nThe burning question in the reader's mind is what happens when an operation occurs\non a GUI control, say if a Button (as defined below) is clicked on:\n```\nqtg.Button(tag=\"example_2\", text=\"Example 2\", callback=self.event_handler, width=10),\n```\nThe answer is that the ```callback``` method ```self.event_handler``` is triggered \nwith a CLICKED event, and it can be processed as below:\n\n```\n def event_handler(self, event: qtg.Action):\n \"\"\"Handles form events\n Args:\n event (qtg.Action): The triggering event\n \"\"\"\n assert isinstance(self,event:qtg.Action), f\"{event=}. Must be Action\"\n\n match event.event:\n case qtg.Sys_Events.CLICKED:\n match event.tag: \n case \"example_2\":\n popups.PopMessage(title=\"Hi\", message=\"Example 2 Was Clicked\").show()\n```\nThis results in a Pop-up window opening with a title of \"Hi\" displaying\n\"Example 2 Was Clicked\" \n\n**Note: This is the essence of event driven programming, nothing happens until an\nevent is triggered, mostly by the application[GUI Controls](#gui-controls-1) - like Buttons.**\n\nThe observant reader may notice the event instance passed to the ```event handler``` \nis a class of [Action](#action) which probably should have been named \n```Event``` but for historical reasons that nomenclature is staying. \n\nThe [Action](#action) class has a number of very useful methods and properties, and \na programmer using QTPYGUI will become very familiar with them.\n\n#### Building Your First Application:\n\nAs is traditional, a \"hello world\" program needs to be written first, so let's \nget to it!\n\n```\nimport QTPYGUI.qtpygui as qtg\n\nclass Hello_World:\n def __init__(self):\n self.hello_world = qtg.QtPyApp(\n display_name=\"Hello World\",\n callback=self.event_handler,\n height=100,\n width=100,\n )\n\n def event_handler(self, event: qtg.Action):\n \"\"\"Handles form events\n Args:\n event (qtg.Action): The triggering event\n \"\"\"\n assert isinstance(event, qtg.Action), f\"{event=}. Must be Action\"\n\n match event.event:\n case qtg.Sys_Events.CLICKED:\n match event.tag:\n case \"ok\":\n self.hello_world.app_exit()\n\n def layout(self) -> qtg.VBoxContainer:\n \"\"\"The layout of the window\n Returns:\n qtg.VBoxContainer: The layout\n \"\"\"\n return qtg.VBoxContainer(align=qtg.Align.BOTTOMRIGHT).add_row(\n qtg.FormContainer().add_row(\n qtg.Label(\n text=\"Hello World!\",\n txt_fontsize=48,\n txt_align=qtg.Align.CENTER,\n txt_font=qtg.Font(backcolor=\"blue\", forecolor=\"yellow\"),\n ),\n ),\n qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"ok\",\n text=\"OK\",\n callback=self.event_handler,\n width=10,\n tooltip=\"Exit Example 01\",\n ),\n ),\n )\n\n def run(self):\n \"\"\"Run example_01\"\"\"\n self.hello_world.run(layout=self.layout())\n\nif __name__ == \"__main__\":\n hello_world = Hello_World()\n hello_world.run()\n```\n\nThis is a slightly simplified version of example_01.\n\nCopy the above source code into a hello_world.py file and run it like so:\n\n```python3 -OO hello_world.py```\n\nAnd the follwing screen will be displayed:\n<br><br>\n\n#### Distributing Your Application\nI strongly recommend using Nuitka (https://nuitka.net/) to distribute your \nprogram as it can produce a single compiled file, housing all dependencies \nthat can be copied to a host machine. \n\nNuitka's Kay Hayen is simply the Python GOAT when it comes to this type of thing.\n\nTo compile ```hello_world.py``` the reader will need to install Nuitka\n\n```pip install Nuitka```\n\nand run this command:\n```\npython -m nuitka \\\n--show-anti-bloat-changes \\\n--assume-yes-for-downloads \\\n--lto=yes \\\n--python-flag=-OO \\\n--python-flag=no_warnings \\\n--python-flag=isolated \\\n--standalone \\\n--onefile \\\n--prefer-source-code \\\n--enable-plugin=pyside6 \\\n--include-qt-plugins=sensible \\\n--include-package-data=QTPYGUI \\\nhello_world.py\n```\nThis will produce a ```hello_world.bin``` file on Linux, double-click on it and \nthe ```hello_world``` application will start.\n\nNote:\n1. On occasion the ```hello_world.bin``` file will need to be made executable, and this\nis done as follows:\n\n- Right-click on the ```hello_world.bin``` file and select \"Properties.\" This \nwill open the file properties window. select \"Permissions\" and tick \"Allow \nexecuting file as program\" and then \"Close\"\n\n2. At the time of writing, this will produce a 58MB ```hello_world.bin``` \nexecutable file - This is simply how it is when distributing Python applications\n as so much is included during the build process. It is worth noting that \nPyInstaller produces even larger executables! \n\n## QTPYGUI Control API Reference\n\nThis section details the wide variety of GUI (Graphical User Interface) controls \nthat are available to design a user interface (UI) with QTPYGUI.\n\nNot all properties or methods will be detailed as many are inherited from their \nancestor, the [qtpyBase_Control](#_qtpybase_control)\n\nThe properties used by almost all controls, and which should be committed to memory, are:\n\n - **\"tag\"**, the system name for the control\n - Must be specified if the control is going to be used in the code, \n if not, it can be omitted and the system will generate\na unique tag name\n - **\"callback\"**, the method that will process events generated by the GUI control. \n - Takes one argument - an [Action](#action) instance which has many useful \n properties and methods and is critical to QTPYGUI programming. \n - callback can be omitted for controls, like [Label](#label), where the \n programmer has no interest in the events generated by the control\n - **\"text\"**, not all controls use this as they do not display text\n - **\"width\"**, the width of the control in characters if pixel_unit is False, Otherwise in pixels\n - **\"height\"**, the height of the control in characters if the pixel_unit is False, Otherwise in pixels\n\nOnly where a programmer is after a special layout or effect, will the other properties come into play\n- Some controls, like the [Grid](#grid), will have special properties that need setting\n \nIt is suggested to set the \"height\" and \"width\" properties as the font selected might not\nautomatically size correctly and the defaults might not suit.\n- This is particularly the case in fonts that are not monospaced.\n\nWhere the \"txt_font\" is set, it overrides the other text related font properties\n\n[GUI Controls](#gui-controls-1) are housed in [Containers](#containers) and the container_tag and \ntag make a unique pair in the form layout\n\n#### GUI Controls\n\n| Control | Description |\n|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|\n| [Button](#button) | Creates a button, text and icon are optional |\n| [Checkbox](#checkbox) | Creates a check box that a user can click on or off | \n| [ComboBox](#combobox) | Creates a drop down selection box, icon in list is <br/>optional |\n| [Dateedit](#dateedit) | Creates a date edit control with a dropdown calendar and <br/>an erase button |\n| [FolderView](#folderview) | Creates a control that displays the contents of a folder in a grid format |\n| [Grid](#grid) | Creates a control that displays data in a table (grid) format |\n| [Image](#image) | Creates a control that displays an image |\n| [Label](#label) | Creates a text string |\n| [LCD](#lcd) | Creates a control that displays an LCD calculator display<br>Only numbers can be displayed |\n| [LineEdit](#lineedit) | Creates a control that allows text to be edited and displayed<br/> in a single line |\n| [Menu](#menu) | Creates a menu just below the title bar |\n| [ProgressBar](#progressbar) | Creates a control that displays the progress of an operation |\n| [RadioButton](#radiobutton) | Creates a radio button control. In a group only one can be <br/>selected at a time |\n| [Slider](#slider) | Creates a slider control than can be used to set a value <br/>by dragging the handle |\n| [Spacer](#spacer) | Creates a spacer control used to format layout |\n| [Spinbox](#spinbox) | Creates a spinbox control that allows numbers to be set <br/>via clicking up and down arrows or entering the number directly |\n| [Switch](#switch) | Creates a switch control that can be used to turn on and <br/>off a feature |\n| [Tab](#tab) | Creates a tab control that has multiple pages, each <br/>housing their own set of [GUI Controls](#gui-controls-1) |\n| [TextEdit](#textedit) | Creates a text entry control that can span multiple lines |\n| [Timeedit](#timeedit) | Creates a time edit control with an erase button |\n| Treeview | Creates a control that displays data as a tree view |\n\n### _qtpyBase_Control\n \nThis is the ancestor of all QTPYGUI [GUI controls](#qtpygui-control-api-reference),\nand the properties here are used to set the behavior of the GUI control when instantiated.\n \n**Properties** \n- Not all properties will be supported or used by descendant [GUI Controls](#gui-controls-1) and will be ignored\n- Some properties will be overridden by descendant [GUI Controls](#gui-controls-1)\n\n| **Property** | **Type** | **Description** |\n|-------------------|------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------|\n| align | [Align](#align) (Align.LEFT) | Used to align [GUI Controls](#gui-controls-1) in containers |\n| allow_clear | bool (True) | True, allow [GUI Controls](#gui-controls-1) that can be cleared to be cleared, Otherwise not |\n| bold | bool (False) | True, sets [GUI Controls](#gui-controls-1) that have text bold, Otherwise not |\n| buddy_control | _qtpyBase_Control \\| None (None) | Set the buddy GUI control or Container | \n| buddy_callback | Callable \\| None (None) | Sets the callback method for the buddy GUI control (Functon, Method or Lambda) |\n| callback | Callable \\| None (None) | Sets the callback method for the GUI control (Functon, Method or Lambda) |\n| container_tag | str (\"\") | Sets the container_tag for the GUI control. If \"\" then system generated |\n| editable | bool (True) | True, sets [GUI Controls](#gui-controls-1) that support editing into edit mode, Otherwise not |\n| enabled | bool (True) | True, enables the GUI control, Otherwise disable the GUI control |\n| frame | [Widget_Frame](#widget_frame) \\| None (None) | Sets the frame of a GUI control tht supports frames |\n| icon | None \\| qtG.QIcon \\| qtG.QPixmap \\| str (None) | Sets the icon on a GUI control were supported. If a str then this is the filename of the icon |\n| italic | bool (False) | True, sets [GUI Controls](#gui-controls-1) that have text italic, Otherwise not |\n| height | int (-1) | The height of the GUI control in characters if pixel_unit is False, Otherwise the height is in pixels.<br> -1 automatically calculates the height |\n| label | str (\"\") | The label string, if not provided no label is shown |\n| label_align | [Align_Text](#align_text) (Align_Text.RIGHT) | The alignment of the label text |\n| label_width | int (-1) | The width of the label in characters if pixel_unit is False, Otherwise the width is in pixels.<br> -1 automatically calculates the width |\n| label_font | [Font](#font) \\| None (None) | The Font of the label |\n| pixel_unit | bool (False) | True, width and height settings are in pixels, Otherwise in characters |\n| size_fixed | bool (True) | True, Sets the size of the [GUI Controls](#gui-controls-1) as fixed, Otherwise not fixed. TODO: fix this setting as it has no effect |\n| tag | str (\"\") | The tag of the GUI control, system generated. If \"\" then system generated |\n| text | str (\"\") | The text displayed on the GUI control if this is supported by the GUI control |\n| tooltip | str (\"\") | The tooltip displayed when the mouse hovers over the GUI control |\n| txt_align | [Align_Text](#align_text) (Align_Text.LEFT) | Aligns the [GUI Controls](#gui-controls-1) text, if supported. |\n| txt_font | [Font](#None)\\| None (None) | The font of the [GUI Controls](#gui-controls-1) text, if supported |\n| txt_fontsize | int (DEFAULT_FONT_SIZE) | The fontsize in points of the GUI control text, if supported |\n| tune_vsize | int (0) | Used to adjust the vertical size of the GUI control. In pixels |\n| tune_hsize | int (0) | Used to adjust the horizontal size of the GUI control. In pixels |\n| translate | bool (True) | True, translate the text on the GUI control, if supported, Otherwiise not |\n| width | int (-1) | The width of the GUI control in characters if pixel_unit is False, Otherwise the width is in pixels.<br> -1 automatically calculates the width |\n| underline | bool (False) | True, sets [GUI Controls](#gui-controls-1) that have text underline, Otherwise not |\n| user_data | any (None) | User sepecified data attached to the GUI control |\n| validate_callback | Callable \\| None (None) | A callback to validate the contents of the GUI control. Applicable only to GUI controls that allow the entry of text |\n| visible | bool (True) | True, make the GUI control visible,Otherwise hide the GUI control |\n\n**Methods** \n- Not all methods will be used by descendant [GUI Controls](#gui-controls-1)\n- Some methods will be overridden\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|---------------------|-----------------|------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| block_signals | | None | Blocks or unblocks signals for the widget (Used rarely where signals might be generated very frequently e.g. [Slider](#slider)) | |\n| | block_signals | bool (True) | True, stop this widget from generating signals (events), Otherwise do not do not stop signals (events) being generated . | \u2713 |\n| clear | | None | Clears the contents of the GUI control, if supported | | \n| buddy_text_set | | None | Sets the text on the buddy control, where supported | |\n| | value | str | The label text set to the left of the buddy widget. | \u274c |\n| ediitable_set | | None | Controls the edit setting of a GUI control, where supported. | |\n| | editable | bool (False) | True, set the GUI control editable, where supported, Otherwise not. | \u2713 |\n| enable_get | | bool | <br><b>Returns:</b><br> The enable value of the widget.<br> | |\n| enable_set | | int | Enables/Disables the GUI control where supported <br><b>Returns:</b><br> 1 - set ok, -1 - set failed<br> | |\n| | enable | bool | True enable control, Otherwise disable the control. | \u274c |\n| fonts_available_get | | tuple[str] | <br><b>Returns:</b><br> A tuple of font name strings.<br> | |\n| font_set | | None | Sets the font on the GUI control (Usually used internally as the [Font](#font) property is set when the GUI control is instantiated) | |\n| | app_font | Font | Application font | \u274c |\n| | widget_font | Font | Control font | \u274c |\n| | widget | qtW.QWidget (None) | The QT widget having the font set (defaults to current GUI control) | \u2713 |\n| font_system_get | | None | Gets the sstem font <br><b>Returns:</b><br> A QFont object.<br> | |\n| | fixed | bool (True) | True, return the fixed size system font, Otherwise not | |\n| frame_style_set | | None | Sets the frame style of the GUI control, where supported | |\n| | frame | [Widget_Frame](#widget_frame) | Frame definition object. | \u2713 |\n| icon_set | | None | | |\n| | icon | None \\| qtG.QIcon \\| qtG.QPixmap \\| str | Sets the icon on a GUI control were supported. If a str then this is the filename of the icon | \u274c |\n| guiwidget_get | | qtW.QWidget | Returns the underlying QT widget so that specialised operations can be performed<br><b>Returns:</b><br> The QT GUI widget.<br> | |\n| guiwidget_set | | None | Sets the GUI Control (Almost never used by QTPYGUI programmers) | |\n| | widget | qtW.QWidget \\| qtG.QAction | The widget being set | \u274c |\n| pixel_str_size | | [Char_Pixel_Size](#char_pixel_size) | <br><b>Returns:</b><br> The pixel size of the string in a [Char_Pixel_Size](#char_pixel_size) instance .<br> | |\n| | text | str | The text to be measured | \u274c |\n| pixel_char_size | | [Char_Pixel_Size](#char_pixel_size) | The size of a char in pixels<br><b>Returns:</b><br> [Char_Pixel_Size](#char_pixel_size) <br> | |\n| | char_height | int | Character height in chars | \u274c |\n| | char_width | int | Character width in chars | \u274c |\n| | height_fudge | float (1.1) | Fudge factor multiplier to provide height adjustment | \u2713 |\n| | width_fudge | float (1.1) | Fudge factor multiplier to provide width adjustment | \u2713 |\n| text_pixel_size | | tuple[int,int] | Returns the height and width of a string of text in pixels <br><b>Returns:</b><br> The [height,width] of the text in pixels.<br> | |\n| | text | str | The text to be measured. | \u274c |\n| tooltip_get | | str | <br><b>Returns:</b><br> The tooltip text.<br> | |\n| tooltip_set | | None | | |\n| | tooltip | str | The text to display in the tooltip. | \u274c |\n| | width | int (200) _Currently 400 for testing_ | The width of the tooltip in pixels. ( Width setting is still being ignored TODO Find Fix) | \u2713 |\n| | txt_color | str | The color of the tooltip text. Defaults to black. | \u2713 |\n| | bg_color | str | The background color of the tooltip. Defaults to white. | \u2713 |\n| | border | str | The border style of the tooltip. Defaults to \"1px solid #000000\". | \u2713 |\n| tooltipsvisible_get | | bool | <br><b>Returns:</b><br> True - visible, False - not visible.<br> | |\n| tooltipsvisible_set | | None | | |\n| | visible | bool | True, tooltip visible, Otherwise not. | \u274c |\n| trans_get | | bool | <br><b>Returns:</b><br> True - text translated, False - text not translate<br> | |\n| trans_set | | None | | |\n| | no_trans | bool | True, text not translated, Otherwise text is translated | \u274c |\n| trans_str | | str | <br><b>Returns:</b><br> The translated text.<br> | |\n| | text | str | The text to be translated. | \u274c |\n| | force_translate | bool (False) | Translate text if True,Otherwise do not translate text. Defaults to False | \u2713 |\n| validate | | bool | <br><b>Returns:</b><br> True if validation ok, otherwise False<br> | |\n| value_get | | any | <br><b>Returns:</b><br> The value of the widget.<br> | |\n| userdata_get | | any | <br><b>Returns:</b><br> The user data stored on the widget | |\n| userdata_set | | None | Sets the user data on the widget. | |\n| | user_data | any | The user data can be of any type | \u274c ||\n| value_set | | None | Sets the widget value | |\n| | value | bool \\| int \\| float \\| [Combo_Data](#combo_data) \\| str \\| datetime.date \\| datetime.datetime | Sets the value of the widget | \u274c |\n| visible_get | | bool | <br><b>Returns:</b><br> True - widget visible, False - widget hidden.<br> | |\n| visible_set | | None | | |\n| | visible | bool | True, sets widget visible, Otherwise widget hidden. | \u274c |\n\n#### Button\n\nCalling Button in a layout will generate a button control on a form. \n\nThe \"tag\", \"text\" and \"callback\" arguments are generally the only arguments used. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly. \n\n<br>**Properties**\n<br>The following properties apply when a button is instantiated with the Button \ncall, as in the \"fully loaded\" declaration below \n\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|----------------------|------------------------------------------------------------------------------------------------------|---------------------------------------------|--------------|\n| auto_repeat_interval | If > 0 the button keeps firing Clicked events when <br>held down (milliseconds) | int >= 0 (0) | \u2713 |\n| bold | Sets the button text bold if True otherwise not | bool (False) | \u2713 |\n| buddy_control | Control or container with controls that sit to the right of the button | Container or GUI Control | \u2713 | \n| callback | The method called when the button is pressed | Callable (None) | \u2713 |\n| enabled | Enables/Disables the button | bool (True) | \u2713 |\n| height | The height of the button (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (10) | \u2713 |\n| icon | The icon image displayed on the button | str [File Name]<br/>,QIcon,QPixmap | \u2713 |\n| italic | Sets the button text italic if True otherwise not | bool (False) | \u2713 |\n| label | Displays text to the left of the button | str (\"\") | \u2713 |\n| label_align | Alignment of the text displayed in the label | [Align_Text](#align_text) (Align_Text.LEFT) | \u2713 |\n| label_font | The font definition for the label | [Font](#font) | \u2713 |\n| label_width | Sets the label width (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (0) | \u2713 |\n| pixel_unit | Use pixels for width/height, pixels if True, Otherwise characters | bool (False) | \u2713 |\n| tag | The application name of the button | str (System Generated) | \u2713 |\n| text | The text displayed on the button | str (\"\") | \u2713 |\n| txt_align | Alignment of the text displayed on the button | [Align_Text](#align_text) (Align_Text.LEFT) | \u2713 |\n| txt_font | The font definition for the button (style will override<br> italic,size will override txt_fontsize ) | [Font](#font) | \u2713 |\n| txt_fontsize | The point size of the text | int (10) | \u2713 |\n| tune_hsize | Add or subtracts pixels units to the width. Used in aligning controls | int (0) | \u2713 |\n| tune_vsize | Add or subtracts pixels units to the height. Used in aligning controls | int (0) | \u2713 |\n| tooltip | Sets the tooltip displayed when the button is hovered over | str | \u2713 |\n| translate | Translates text if True Otherwise does not translate | bool (True) | \u2713 |\n| user_data | Any data item the user wants to attach to the button | any (None ) | \u2713 |\n| underline | Underlines the button text if True otherwise not | bool (False) | \u2713 |\n| visible | Makes the button visible if True otherwise invisible | bool (True) | \u2713 |\n| width | The width of the button (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (10) | \u2713 |\n\n<br>A fully loaded button declaration:\n<br><br>**Note: Only \"tag\", \"text\" and \"callback\" are usually needed**\n\n```\nButton(\n tag=\"button_1\",\n text=\"Button\",\n label=\"Button 1\",\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE,size=14),\n callback=self.event_handler,\n width=10,\n height=1,\n txt_align=qtg.Align_Text.CENTER,\n txt_font =qtg.Font(style=qtg.Font_Style.NORMAL,size=15),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True, \n visible=True,\n tooltip=\"Button 1 Press Me\",\n tune_hsize=15,\n tune_vsize=15,\n user_data = {\"key\":\"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Checkbox(tag=\"button_check\", text=\"Tick Me!\", callback=self.event_handler, width=12)\n ),\n )\n```\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Button instances \n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|-------------|-------------------------------------|--------------|\n| text_set | | None | Sets the text on the button | |\n| | button_text | str | The text to be placed on the button | \u274c |\n| | translate | bool (True) | Translate the text | \u2713 |\n\n#### Checkbox\n\nCalling Checkbox in a layout will generate a checkbox control on a form. \n\nThe \"tag\", \"text\" and \"callback\" arguments are generally the only arguments used.\n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br>The following properties apply when a Checkbox is instantiated with the Checkbox \ncall, as in the \"fully loaded\" declaration below\n\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|---------------|--------------------------------------------------------------------------------------------------------|---------------------------------------------|--------------|\n| bold | Sets the checkbox text bold if True otherwise not | bool (False) | \u2713 |\n| buddy_control | Control or container with controls that sit to the right of the checkbox | Container or GUI Control | \u2713 | \n| callback | The method called when the checkbox is checked | Callable (None) | \u2713 |\n| enabled | Enables/Disables the checkbox | bool (True) | \u2713 |\n| height | The height of the checkbox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | \u2713 |\n| italic | Sets the checkbox text italic if True otherwise not | bool (False) | \u2713 |\n| label | Displays text to the left of the checkbox | str (\"\") | \u2713 |\n| label_align | Alignment of the text displayed in the label | [Align_Text](#align_text) (Align_Text.LEFT) | \u2713 |\n| label_font | The font definition for the label | [Font](#font) | \u2713 |\n| label_width | Sets the label width (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (0) | \u2713 |\n| pixel_unit | Use pixels for width/height, pixels if True, Otherwise characters | bool (False) | \u2713 |\n| tag | The application name of the checkbox | str (System Generated) | \u2713 |\n| text | The text displayed next to the checkbox | str (\"\") | \u2713 |\n| txt_align | Alignment of the text displayed next to the checkbox | [Align_Text](#align_text) (Align_Text.LEFT) | \u2713 |\n| txt_font | The font definition for the checkbox (style will override<br> italic,size will override txt_fontsize ) | [Font](#font) | \u2713 |\n| txt_fontsize | The point size of the text | int (10) | \u2713 |\n| tune_hsize | Add or subtracts pixels units to the width. Used in aligning controls | int (0) | \u2713 |\n| tune_vsize | Add or subtracts pixels units to the height. Used in aligning controls | int (0) | \u2713 |\n| tooltip | Sets the tooltip displayed when the checkbox is hovered over | str | \u2713 |\n| translate | Translates text if True Otherwise does not translate | bool (True) | \u2713 |\n| user_data | Any data item the user wants to attach to the checkbox | any (None ) | \u2713 |\n| underline | Underlines the checkbox text if True otherwise not | bool (False) | \u2713 |\n| visible | Makes the checkbox visible if True otherwise invisible | bool (True) | \u2713 |\n| width | The width of the checkbox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | \u2713 |\n\n<br>A fully loaded checkbox declaration:\n<br><br>**Note: Only \"tag\", \"text\" and \"callback\" are usually needed**\n- txt_font overrides the other text font settings\n\n```\nCheckbox(\n tag=\"checkbox\",\n text=\"Tick Me!\",\n label=\"Check Box\",\n callback=self.event_handler,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),\n width=6,\n height=1,\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=20),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"Check Box Press Me\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(tag=\"button_push\", text=\"Push Me!\", callback=self.event_handler, width=12)\n ),\n \n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Checkbox instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|----------------|---------------|----------|----------------------------------------------------------------|--------------|\n| button_checked | | bool | <br><b>Returns:</b><br> The checked state of the checkbox.<br> | |\n| button_toggle | | None | | |\n| | value (True) | bool | True checkbox is checked, False checkbox is unchecked. | \u2713 |\n| label_get | | str | <br><b>Returns:</b><br> The text of the label.<br> | |\n| value_get | | bool | <br><b>Returns:</b><br> True checked, False not checked<br> | |\n| value_set | | None | | |\n| | value | bool | True checkbox is checked, False checkbox is unchecked. | \u274c |\n\n#### ComboBox\n\nCalling ComboBox in a layout will generate a dropdown combobox control on a form. \n\nThe \"tag\" ,\"text\", \"callback\" and \"items\" arguments are generally the only \narguments used. It is suggested to set width and height as the font selected \nmight not automatically size correctly.\n\n<br>**Properties**\n<br>The following properties apply when a ComboBox is instantiated with the ComboBox \ncall, as in the \"fully loaded\" declaration below\n\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|-------------------|----------------------------------------------------------------------------------------------------------------------|---------------------------------------------|--------------|\n| bold | Sets the combobox text bold if True otherwise not | bool (False) | \u2713 |\n| buddy_control | Control or container with controls that sit to the right of the combobox | Container or GUI Control | \u2713 | \n| callback | The method called when the combobox is modified | Callable (None) | \u2713 |\n| display_na | Displays N/A (Not Applicable/Available) in the drop down list if True Otherwise not | bool (True) | \u2713 |\n| dropdown_width | The width of the combobox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | \u2713 |\n| enabled | Enables/Disables the combobox | bool (True) | \u2713 |\n| height | The height of the combobox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | \u2713 |\n| italic | Sets the combobox text italic if True otherwise not | bool (False) | \u2713 |\n| items | Items to add to the ComboBox when it is instantied | list or tuple [Combo_Item](#combo_item) | \u2713 |\n| label | Displays text to the left of the combobox | str (\"\") | \u2713 |\n| label_align | Alignment of the text displayed in the label | [Align_Text](#align_text) (Align_Text.LEFT) | \u2713 |\n| label_font | The font definition for the label | [Font](#font) | \u2713 |\n| label_width | Sets the label width (in characters if pixel_unit is<br> False,Otherwise pixels) | int > 0 (0) | \u2713 |\n| csv_file_def | Defines the csv file that will be loaded into the ComboBox when it is instantiated | [CSV_File_Def](#csv_file_def) (None) | \u2713 |\n| num_visible_items | Number of items displayed in the dropdown list | int >= 1 (15) | \u2713 |\n| pixel_unit | Use pixels for width/height, pixels if True, Otherwise characters | bool (False) | \u2713 |\n| tag | The application name of the combobox | str (System Generated) | \u2713 |\n| txt_font | The font definition for the combobox dropdown list (style will override<br> italic,size will override txt_fontsize ) | [Font](#font) | \u2713 |\n| txt_fontsize | The point size of the text in the combobox dropdown list | int (10) | \u2713 |\n| tune_hsize | Add or subtracts pixels units to the width. Used in aligning controls | int (0) | \u2713 |\n| tune_vsize | Add or subtracts pixels units to the height. Used in aligning controls | int (0) | \u2713 |\n| tooltip | Sets the tooltip displayed when the combobox is hovered over | str | \u2713 |\n| translate | Translates dropdown text if True Otherwise does not translate | bool (True) | \u2713 |\n| user_data | Any data item the user wants to attach to the combobox | any (None ) | \u2713 |\n| underline | Underlines the combobox dropdown text if True otherwise not | bool (False) | \u2713 |\n| visible | Makes the combobox visible if True otherwise invisible | bool (True) | \u2713 |\n| width | The width of the combobox (in characters if pixel_unit is False,Otherwise pixels) | int > 0 (10) | \u2713 |\n\n<br>A fully loaded combobox declaration:\n<br><br>**Note: Only \"tag\", \"text\" ,\"callback\" and \"items\" are usually needed**\n- txt_font overrides the other text font settings\n```\nComboBox(\n tag=\"combo_box\",\n label=\"Combo Box\",\n display_na=True,\n dropdown_width=35,\n items=[\n qtg.Combo_Item(\n display=\"Item 1\",\n data=None,\n icon=qtg.Sys_Icon.computericon.get(),\n user_data=None,\n ),\n qtg.Combo_Item(\n display=\"Item 2\", data=None, icon=None, user_data=None\n ),\n qtg.Combo_Item(\n display=\"Item 3\", data=None, icon=None, user_data=None\n ),\n ],\n callback=self.event_handler,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),\n width=8,\n height=1,\n txt_font=qtg.Font(style=qtg.Font_Style.ITALIC, size=12),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"Check Box Press Me\",\n tune_hsize=15,\n tune_vsize=1,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(tag=\"button_push2\", text=\"Push Me 2!\", callback=self.event_handler, width=12)\n ),\n ),\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to ComboBox instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|----------------------|----------------|--------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| count_items | | int \\>= 0 <= number of items in list | <br><b>Returns:</b><br> The number of items in the Combobox<br> | |\n| display_width_set | | None | | |\n| | display_width | int | The number of characters to display in the Combobox | \u274c |\n| get_items | | list [Combo_Data](#combo_data) | <br><b>Returns:</b><br> returns the List of items in the combo box<br> | |\n| icon_set | | int | <br><b>Returns:</b><br> 1 if successful, -1 if not<br> | |\n| | combo_index | int | Row index in the combobox where the icon is to be placed | \u274c |\n| | icon | str [File Name], QIcon,QPixmap | A QPixmap, QIcon or the icon file name | \u274c |\n| is_combo_child | | bool | <br><b>Returns:</b><br> True if the Combobox is child of another combo box. False if not.<br> | |\n| load_csv_file | | tuple[int,str] | <br><b>Returns:</b><br> Length of maximum item if load OK, Otherwise -1 and error message<br> | |\n| | csv_file_def | [CSV_File_Def](#csv_file_def) | The CSV file definition | \u274c |\n| load_items | | int | <br><b>Returns:</b><br> int<br> | |\n| | auto_na | bool (True) | True puts na_string (Not Available) in combobox, Otherwise not | \u2713 |\n| | clear_items | bool (True) | Clears existing items from the combobox | \u2713 |\n| | na_string | str (\"N/A\") | The \"Not Available\" string | \u2713 |\n| print_all_to_console | | None | Debug method - prints items to console | |\n| select_index | | None | Scrolls to an index in the combobox and sets the current index of the widget to the select_index argument | |\n| | select_index | int | The index of the item to select | \u274c |\n| select_text | | int | Selects the text in the combobox <br><b>Returns:</b><br> The index of the selected text in the dropdown. | |\n| | select_text | int | <br><b>Returns:</b><br> The index of the selected text in the dropdown.<br> | \u274c |\n| | case_sensitive | bool (False) | Whether to perform a case-sensitive match. | \u2713 |\n| | partial_match | bool (False) | Whether to perform a partial text match. | \u2713 |\n| | select_text | str | The text to select. | |\n| value_get | | [Combo_Data](#combo_data) | <br><b>Returns:</b><br> Current row [Combo_Data](combo_data) if index = -1, Selected row [Combo_Data](combo_data) if row > 0<br> | |\n| | index | int (-1) | The index of the item to get. Defaults to current row. | \u2713 |\n| value_remove | | None | Remove an item from the combobox a the given index. | |\n| | index | int | The index of the item to remove. | \u274c |\n| value_set | | None | Sets a value in the dropdown and scrolls to that value. if COMBO_DATA index is -1 then data and display. <br> Values must match for scroll to happen | |\n| | value | str \\| [Combo_Data](#combo_data) | Inserts a value in the dropdown. <br>If [Combo_Data](#combo_data) index = -1 insert alphabetically when insert_alpha is True, Otherwise insert at bottom of list. if index > 1 insert at index position | \u274c | |\n| | insert_alpha | bool (True) | Insert alphabetically | \u2713 |\n\n#### Dateedit\n\nCalling Dateedit in a layout will generate a Dateedit control, with an erase button\nand a dropdown calendar, on a form. \n\nThe \"tag\" ,\"text\" and \"callback\" arguments are generally the only arguments used. \n<br>It is suggested to set width and height as the font selected might not automatically \nsize correctly.\n\n**Constants**\n\n| **Constant** | **Description** | **Type** |\n|--------------|------------------------------------------------------------|------------------|\n| MINDATE | The minimum date supported by Dateedit (1 Jan 100 AD) | QDate(100, 1, 1) |\n| NODATE | Used internally by Dateedit to signify a no date condition | QDate(1, 1, 1) |\n\n<br>**Properties**\n<br>The following properties apply when a Datedit is instantiated with the \nDatedit call, as in the \"fully loaded\" declaration below\n\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|------------------------------------------------------------------------------------------------------------------------------------|----------|--------------|\n| date | Set to the current date if not set (\"\") | str (\"\") | \u2713 |\n| format | Date format. The `format` property is set to the current locale's date format if this is not set (\"\")<br>Follows QT date formating | str (\"\") | \u2713 |\n| min_date | Set to **MINDATE** if not set (\"\") | str (\"\") | \u2713 |\n| max_date | Set to the to the current date if not set (\"\") | str (\"\") | \u2713 |\n\n<br>A fully loaded Dateedit declaration:\n<br><br>**Note: Only \"tag\", \"text\" ,and \"callback\" are usually needed**\n - text behaves a little differently here as it serves to set the tooltip on the erase button\n - max_date, min_date and format can be used to configure the date range and \n format of the Dateedit GUI Control if desired\n - txt_font overrides the other text font settings\n\n```\nDateedit(\n tag=\"dateedit2\",\n text=\"Tick Me!\",\n date=\"2022-01-01\",\n format=\"yyyy-MM-dd\",\n max_date=\"2032-01-01\",\n min_date=\"2000-01-01\",\n label=\"Date edit 2\",\n callback=self.event_handler,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),\n width=6,\n height=1,\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=20),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"Date Edit 2 \",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(\n tag=\"dateedit_button_push\",\n text=\"Date Edit 2 Push Me!\",\n callback=self.event_handler,\n width=12,\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Dateedit instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------|--------------|\n| clear | | None | Clears the date displayed | |\n| | default_text | str (\"-\") | Date text to place in the edit control (must be a valid date string or - to clear the date) | \u2713 |\n| date_get | | str \\| [Date_Tuple](#date_tuple) | Gets the date. If date_tuple as a [Date_Tuple](#date_tuple), Otherwise a string formatted as per date_format<br> | |\n| | date_format (\"\") | str | Set the date format for a string return if date_tuple is False<br>Follows QT date formating | \u2713 |\n| | date_tuple (False) | bool | True, return date format as a [Date_Tuple](#date_tuple), Otherwise a string, formated as per date_format | \u2713 |\n| date_set | | None | Sets the date in the control | |\n| | date | str (\"\") | A string representing the date to set, formatted as 'y-m-d'. | \u2713 |\n| | date_format | str (\"\") | The format of the date string, defaults to an empty string. | \u2713 |\n| | default_text | str (\"-\") | if the date string is '-' then the date control is cleared | \u2713 |\n| date_valid | | bool | Checks if a date is valid<br><b>Returns:</b><br> True if date is valid, False otherwise<br> | |\n| | date | str | date in string format | \u274c |\n| | date_format | str | The format of the date string. | \u274c |\n| value_get | | str \\| [Date_Tuple](#date_tuple) | Gets the date. If date_tuple as a [Date_Tuple](#date_tuple), Otherwise a string formatted as per date_format<br> | |\n| | date_format (\"\") | str | Set the date format for a string return if date_tuple is False<br>Follows QT date formating | \u2713 |\n| | date_tuple (False) | bool | True, return date format as a [Date_Tuple](#date_tuple), Otherwise a string, formated as per date_format | \u2713 |\n| value_set | | None | Sets the date in the control | |\n| | date | str (\"\") | A string representing the date to set, formatted as 'y-m-d'. | \u2713 |\n| | date_format | str (\"\") | The format of the date string, defaults to an empty string. | \u2713 |\n\n### FolderView\n\nCalling FolderView in a layout will generate a FolderView control on a form.\n\nThe \"tag\", \"text\", \"callback\", \"header_widths\" and \"height\" arguments are generally\nthe only arguments used. \n<br>It is suggested to set width and height as the font \nselected might not automatically size correctly.\n\n<br>**Properties**\n<br>The following properties apply when a FolderView is instantiated with the \nFolderView call, as in the \"fully loaded\" declaration below\n\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------|--------------|\n| width | The width of the FolderView GUI control <br>Generally not set as header_widths determines the widths<br> Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (40) | \u2713 |\n| height | The height of the FolderView GUI control<br> Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (15) # In lines | \u2713 |\n| root_dir | Sets root path of the FolderView | str (\"\\\\\") #Current directory | \u2713 |\n| dir_only | True, displays directories only, Otherwise display all directories and files | bool (False) | \u2713 |\n| multiselect | True, allows multiple files and/or folders to be selected, Otherwise only allow one file and/or folder to be selected at a time | bool (False) | \u2713 |\n| header_widths | Sets the header widths - maximum of 4 allowed <br> Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | list [int,...] \\| tuple(int,...) = (40,) | \u2713 | \n| header_font | Sets the font properties of the header row | [Font](#font) \\| None (None) | \u2713 |\n| click_expand | True, expand folders when clicked on, Otherwise only expand folders if the handle is clicked | bool (False) | \u2713 |\n\n<br>A fully loaded FolderView declaration:\n<br><br>**Note: Only \"tag\", \"text\", \"callback\", \"header_widths\" and \"height\" are usually needed**\n- txt_font overrides the other text font settings\n\n```\nFolderView(\n tag=\"folderview\",\n label=\"Folder View\",\n callback=self.event_handler,\n height=5,\n header_widths=[10, 10, 10, 10],\n multiselect=False,\n click_expand=False,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=20),\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=14),\n header_font=qtg.Font(\n style=qtg.Font_Style.OBLIQUE,\n backcolor=\"cyan\",\n forecolor=\"orange\",\n size=20,\n ),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"FolderView Press Me\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(\n tag=\"folderview_button_push\",\n text=\"Push Me!\",\n callback=self.event_handler,\n width=12,\n ),\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to FolderView instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|-----------------|---------------|-------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| change_folder | | None | Changes the root folder for the directory view, clearing the view in the process. | |\n| | folder | str | THe new root folder. This is not checked for validity. | \u274c |\n| expand_on_click | | bool | <br><b>Returns:</b><br> The expand on click setting. If True then the dir node expands when dir name clicked on, Otherwise not<br> | |\n| value_get | | tuple[selected_node(s)] | This will return named tuple(s) of selected_nodes (selected_node, name, path, size, modified, date_modified type, isdir). <br><b>Returns:</b><br> One tuple if multiselect is False, Otherwise one or more tuples containing the file values from the selected node<br> | |\n| value_set | | None | Sets the text value of the selected node. Note: may not work in dir view only mode | |\n| | value | str | The text to set as the current node text | \u274c |\n\n### Grid\n\nCalling Grid in a layout will generate a Grid control on a form. \n\nThe \"tag\", \"text\", \"callback\", \"col_def\" and \"height\" arguments are generally \nthe only arguments used. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br>The following properties apply when a Grid is instantiated with the \nGrid call, as in the \"fully loaded\" declaration below\n\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------|--------------|\n| width | The width of the Grid <br>-1 defaults to the grid column widths being used to calculate the width | int (-1) | \u2713 |\n| height | The height of the grid | int (BUTTON_SIZE.height) | \u2713 |\n| col_def | This is the column definitions of the grid | list \\| tuple [Col_Def](#col_del) | \u274c |\n| grid_items | If an initial grid load is required then set this to a list of [Grid_Items](#grid_item).<br> The tag field of the [Grid_Item](#grid_item) must be set to \"\" | list [Grid_Item](#grid_item) ([]) | \u2713 |\n| multiselect | True, allow multiple selections in the grid, Otherwise do not | bool (False) | \u2713 |\n| noselection | True, do not allow any selections in the grid, Otherwise allow selections | bool (False) | \u2713 |\n| header_sort | True, Allow header sorting, Otherwise do not | bool (True) | \u2713 |\n\n<br>A fully loaded Grid declaration:\n<br><br>**Note: Only \"tag\", \"text\", \"callback\", \"col_def\" and \"height\" are usually needed**\n - Initial Grid loading is usually done by loading grid_items as below\n - txt_font overrides the other text font settings\n\n```\nGrid(\n tag=\"grid\",\n label=\"Grid\",\n callback=self.event_handler,\n col_def=[\n qtg.Col_Def(\n label=\"Col 1\", checkable=True, editable=False, tag=\"col_1\", width=10\n ),\n qtg.Col_Def(\n label=\"Col 2\", checkable=False, editable=True, tag=\"col_2\", width=10\n ),\n ],\n grid_items=[\n qtg.Grid_Item(row_index=0, col_index=0,current_value=\"value 1\" , user_data=None,tag=\"\"),\n qtg.Grid_Item(row_index=0, col_index=1,current_value=\"value 2\" , user_data=None,tag=\"\"),\n qtg.Grid_Item(row_index=1, col_index=0, current_value=\"value 3\", user_data=None, tag=\"\"),\n qtg.Grid_Item(row_index=1, col_index=1, current_value=\"value 4\", user_data=None, tag=\"\"),\n ],\n height=3,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE,backcolor=\"red\", size=14),\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=15), #Does not set colours\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"Grid Me\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(\n tag=\"grid_push\",\n text=\"Grid Push Me!\",\n callback=self.event_handler,\n width=12,\n ),\n )\n``` \n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Grid instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|-------------------------|---------------|--------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| changed | | bool | <br><b>Returns:</b><br> True if the grid has been changed, False otherwise.<br> | |\n| changed | | None | Sets the changed property. | |\n| | value | bool | Set True if the grid has been changed, False otherwise. | \u274c |\n| checkitemrow_get | | [Grid_Item](#grid_item) \\| empty tuple () | <br><b>Returns:</b><br> A Grid_Item definition containing the row_index,col_index, tag, current_value, and user_data of a item at the given row/col position.<br> | |\n| | col | int | The index of the column to retrieve the item from. | \u274c |\n| | row | int | The index of the row to retrieve the item from. | \u274c |\n| checkitemrow_set | | None | Sets the check state of the item at the row and column specified. | |\n| | checked | bool | True, check the item, Otherwise do not | \u274c |\n| | col | int | The index of the column to set the check state for. | \u274c |\n| | row | int | The index of the row to set the check state for. | \u274c |\n| checkitems_all | | None | Checks all items in the grid that are checkable. | |\n| | checked | bool (True) | True, check an item, Otherwise uncheck. | |\n| | col_tag | str (\"\") | The column tag name. Only items in this column will be checked/unchecked. If col_tag is \"\" then all columns will be examined to see if they can be checked/uncheked. | \u2713 |\n| checkitems_get | | [Grid_Item](#grid_item) \\| empty tuple () | <br><b>Returns:</b><br> A tuple of all checked Grid_items in the grid or an empty tuple if no items checked<br> | \u2713 |\n| clear | | None | Clears the grid of all data | |\n| col_count | | int | <br><b>Returns:</b><br> The number of columns in the grid<br> | |\n| colindex_get | | int | <br><b>Returns:</b><br> The column index for a column tag name.<br> If the column tag is invalid an assertion error is raised | |\n| | column_tag | str | The column tag name. | \u274c |\n| coltag_get | | str | <br><b>Returns:</b><br> The column tag name.<br>If the column index is invalid an assertion error is raised.<br> | |\n| | column_index | int | The column index reference. | \u274c |\n| get_previous_value | | bool\\| datetime.date \\| datetime.datetime \\| datetime.time \\| float \\| int \\| str \\| None | <br><b>Returns:</b><br> The previous value stored in the column referred to by row and col<br> | | \n| | col | int (-1) | Col index reference. Defaults to current column | \u2713 |\n| | row | int (-1) | Row index reference. Defaults to current row | \u2713 |\n| grid_item_get | | [Grid_Item](#grid_item) \\|None | <br><b>Returns:</b><br> The Grid item referred to by row and col<br> | |\n| | col | int (-1) | Column index reference. Defaults to current column | \u2713 |\n| | row | int (-1) | Row index reference. Defaults to current column | \u2713 |\n| item_ids_from_row | | list[int] | <br><b>Returns:</b><br> List of item_ids of the items found in a specified row<br> | |\n| | row | int | The table widget row | \u274c |\n| load_csv_file | | int | <br><b>Returns:</b><br> The length of the maximum item loaded or -1 if there is a problem with the file.<br> | |\n| | data_index | int (1) | The column index in the CSV file containing the user data to associate with the loaded data. | |\n| | delimiter | str \",\" | The field separator used in the CSV file. Defaults to \",\". | |\n| | file_name | str | The name of the CSV file. | \u274c |\n| | ignore_header | bool (True) | Set to True if the CSV file has a header row that should be ignored | \u2713 |\n| | line_start | int (1) | The line number in the CSV file to start loading data from | \u2713 |\n| | text_index | int (1) | The column index in the CSV file containing the text to display in the grid | |\n| move_checked_block_down | | None | Move the checked block down one position in the Grid | |\n| move_checked_block_up | | None | Move the checked block up one position in the Grid | |\n| move_row_down | | int | Move the currently selected row down one position in the Grid <br><b>Returns:</b><br> The new row or -1 if the row is at the bottom of the table<br> | |\n| | move_row | int | The index of the row to move | \u274c |\n| move_row_up | | int | Move the currently selected row up one position in the table<br><b>Returns:</b><br> The new row or -1 if the row is at the top of the table<br> | |\n| | move_row | int | The index of the row to move. | \u274c |\n| row_append | | int | Appends a blank row to the grid<br><b>Returns:</b><br> Row number inserted.<br> | |\n| row_count | | int | <br><b>Returns:</b><br> Row Count (number of rows in the grid)<br> | |\n| row_delete | | None | Deletes a row | |\n| | row | int | Row index of the row in the grid that is to be deleted | \u274c |\n| row_from_item_id | | int | Returns the row index of the item with the specified item_id<br><b>Returns:</b><br> The row index of the item with the specified item_id. -1 if item_id not found<br> | |\n| | item_id | int | The item_id of the item you want to find the row index for | \u274c |\n| row_insert | | None | Inserts a row at the given row index. If row is > number of rows then a new row is inserted. | |\n| | row | int | The row index in the grid. | \u274c |\n| | scroll_to | bool (True) | True scroll to the inserted row, Otherwise not | \u2713 |\n| row_scroll_to | | None | Scrolls to a row (Deprecated will be removed in a later release. Use select_row) | |\n| | col | int (-1) | -1 no column selected, Otherwise select the column indicated by col index | \u2713 |\n| | row | int | Row to scroll to | \u274c |\n| row_widget_get | | [_qtpyBase_Control](#_qtpybase_control) \\| [Container](#containers) | <br><b>Returns:</b><br> If found, the widget or the widget container stored in the specified row and column, Otherwise None<br> | |\n| | col | int | Grid column index. If -1, the current column is used, Otherwise the specified column. | \u274c |\n| | container_tag | str (\"\") | Container tag is needed if the desired widget is in a container | \u2713 |\n| | row | int | Grid row index. If -1, the current row is used, Otherwise the specified row. | \u274c |\n| | tag | str (\"-\") | control tag name. If \"-\" is supplied, the container is returned. | |\n| row_widget_set | | None | Sets a widget at the specified row and column | \u2713 |\n| | col | int | The column index of the cell to set the widget for. | \u274c |\n| | group_text | str (\"\") | If group_text is provided the widget will be displayed in a group box with the group_text as a title | \u2713 |\n| | row | int | The row index of the cell you want to set the widget for. | \u274c |\n| | widget | [_qtpyBase_Control](#_qtpybase_control) | The widget to be inserted into the grid | \u274c |\n| row_widget_tag_delete | | int | Deletes a row if the row contains a row widget with a tag that matches the row and tag passed to the method<br><b>Returns:</b><br> 1 row found and deleted, -1 no row found that matches the tag passed to the method<br> | |\n| | container_tag | str (\"\") | This is the container tag of the widget (used only where the widget container tag has been set. Defaults to self.container). | \u2713 |\n| | tag | str | The tag of the widget to be deleted. | \u274c |\n| | widget_row | int | The row housing the widget | \u274c |\n| select_col | | None | Sets the current column | |\n| | col | int | The column index in the grid. | \u274c |\n| | row | int | The row index in the grid. | \u274c |\n| select_row | | None | Scrolls to the given row | |\n| | col | int (-1) | The column index in the grid (defaults to -1 scroll to row only). | \u2713 |\n| | row | int | The row index in the grid. | \u274c |\n| selected_col | | int | <br><b>Returns:</b><br> The currently selected col<br> | |\n| selected_row | | int | <br><b>Returns:</b><br> The currently selected row<br> | |\n| userdata_get | | any | <br><b>Returns:</b><br> User data stored in column referred to by row and col<br> | |\n| | col | int (-1) | If -1, the current column, Otherwise column specified by column | \u2713 |\n| | row | int (-1) | if -1, the current row, Otherwise row specified by row | \u2713 |\n| userdata_set | | None | Sets the user data stored on the given column referred to by row and col | |\n| | col | int (-1) | If -1, the current column, Otherwise column specified by column | \u2713 |\n| | row | int (-1) | if -1, the current row, Otherwise row specified by row | \u2713 |\n| | user_data | any (None) | User data to be stored | |\n| value_get | | bool \\| datetime.date \\| datetime.datetime \\| datetime.time \\| float \\| int \\| str \\| None | <br><b>Returns:</b><br> The value stored in the column referenced by row and column<br> | |\n| | col | int (-1) | If -1, the current column, Otherwise column specified by column | \u2713 |\n| | row | int (-1) | if -1, the current row, Otherwise row specified by row | \u2713 |\n| value_set | | None | Sets a display value (and user data if supplied) at a given row and column | |\n| | bold | bool (False) | If True **bolds** the display font, Otherwise not | \u2713 |\n| | col | int | Column index reference. | \u274c |\n| | italic | bool (False) | If True _italicises_ the display font, Otherwise not | \u2713 |\n| | row | int | Row index reference. | \u274c |\n| | tooltip | str (\"\") | Tooltip to be displayed. | \u2713 |\n| | underline | bool (False) | If True underlines the display font, Otherwise not | \u2713 |\n| | user_data | any | User data to be stored. | \u274c |\n| | value | bool \\| datetime.date \\| datetime.datetime \\|datetime.time \\| float \\| int \\|str \\| None | The value to be displayed. | \u274c |\n| valueorig_get | | bool \\| datetime.date \\| datetime.datetime \\|datetime.time \\| float \\| int \\|str \\| None | <br><b>Returns:</b><br> The original value stored in the column referenced to by row and col<br> | |\n| | col | int (-1) | If -1, the current column, Otherwise column specified by column | \u2713 |\n| | row | int (-1) | if -1, the current row, Otherwise row specified by row | \u2713 |\n\n### Image\n\nCalling Image in a layout will generate an Image control on a form. \n\nThe \"tag\", \"text\", \"callback\", \"height\" and width arguments are generally the \nonly arguments used.\n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br>The following properties apply when an Image is instantiated with the \nImage call, as in the \"fully loaded\" declaration below.\n<br><br>Note: A subset of [_qtpyBase_Control](#qtpygui-control-api-reference) \nproperties also apply and some are used in the \"fully loaded\" declaration below \n\n| **Property** | **Description** | **Type** | **Optional** |\n|----------------|-----------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| width | The width of the image | int (1) | \u2713 |\n| height | The height of the Image | int (1) | \u2713 |\n| image | str [File name] \\| QPixmap]] \\| bytes (None) | If str the image is at the file path specified, If bytes must be image file contents, Otherwise the image must be a QPixmap or None | \u2713 | \n| cached_height | int (-1) | If -1, no cached images is stored, Otherwise the cached image will be stored at the specific height<br>Aspect ratio is always maintained | \u2713 |\n| cached_width | int (-1) | If -1, no cached image is stored , Otherwise the cached image will be stored at the specified width<br>Aspect ratio is always maintained | \u2713 |\n| rotate_degrees | int (0) | Rotates the image by the specified number of degrees<br>Must be int between +- 0 and 360 | \u2713 |\n\n<br>A fully loaded Image declaration:\n<br><br>**Note: Only \"tag\", \"text\", \"callback\", \"height\", \"width\" and \"image\" are usually needed**\n - For implementation reasons, txt_fontsize affects image size and I would \n suggest setting to 10 or 12. \n - txt_font overrides the other text font settings\n\n```\nqtg.Image(\n tag=\"image\",\n label=\"Image\",\n #width=13,\n height=10,\n callback=self.event_handler,\n image=\"example.jpg\",\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=14),\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=12),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"Image Press Me\",\n tune_hsize=1,\n tune_vsize=1,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(\n tag=\"image_button_push\",\n text=\"Push Me!\",\n callback=self.event_handler,\n width=12,\n height=2,\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Image instances\n\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|----------------------|---------------------|-------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| clear | | None | Clears the visible items from the image | |\n| clip_get | | QPixmap \\| None | Gets a QPixmap clip of the image at the given coordinates of the given size<br><b>Returns:</b><br> A QPixmap clipped image or None if something went wrong.<br> | |\n| | height | int | The height of the image portion to be clipped. | \u274c |\n| | width | int | The width of the image portion to be clipped. | \u274c |\n| | x | int | The x coordinate of the left corner of the rectangle to be clipped. | \u274c |\n| | y | int | The y coordinate of top of the rectangle to be clipped. | \u274c |\n| get_height_width | | tuple[int, int] | Gets the height and width of the image as a tuple of pixels. <br><b>Returns:</b><br> (Height,Width) in pixels<br> | |\n| image_cache_get | | QPixmap \\| None | Returns the cached image<br><b>Returns:</b><br> The cached image if it has been set or None<br> | |\n| image_cache_set | | None | Sets a cached image - used to speed things up if we do not want to load the image again | |\n| | image | QPixmap | The image to be cached. | \u274c |\n| image_file_get | | str | Gets the file path of the source file<br><b>Returns:</b><br> The file path of the source file or \"\" if the image is not sourced from a file<br> | |\n| image_set | | int | Sets an image to be displayed<br><b>Returns:</b><br> 1 Ok, -1 If not | |\n| | cached_height | int (-1) | If -1 no cached image is stored, Otherwise create a cached image of a specific height<br>Aspect ratio always maintained | \u2713 |\n| | cached_width | int (-1) | If -1 no cached image is stored, Otherwise create a cached image of a specific width<br>Aspect ratio always maintained | \u2713 |\n| | height | int (-1) | Height of image, If -1 scaled to the width | \u2713 |\n| | high_quality | bool (False) | Display image in high quality | \u2713 |\n| | image | str \\| qtG.QPixmap \\| bytes | Image to be displayed | \u274c |\n| | rotate_degrees | int (0) | Rotate the image in degrees | \u2713 |\n| | scaled | bool (True) | Scale the image to fit height and width | \u2713 |\n| | width | int (-1) | Width of image. If -1 scaled to the height | \u2713 |\n| numpy_array_get | | tuple[int, int, ndarray] | Generates an RGB numpy array suited for dlib (and other libs the author imagines) type operations <br><b>Returns:</b><br> The tuple (image height (pixels),image width (pixels), np.ndarray)<br>The last element is the RGB numpy array that represents the pixmap that is displayed. Assumes only one image is displayed!<br> | |\n| | dlib | bool (False) | If True, the array will be converted to 32bit RGB, Otherwise left as is | |\n| rectangle_coords_get | | [Rect_Coords](#rect_cords) | Returns an instance of [Rect_Coords](#rect_cords) containing the coordinates of a rectangle, given its id<br><b>Returns:</b><br> The coordinates of the rectangle.These will be set to -1 if rect_id not found<br>str<br>int<br>int<br>int<br>int<br> | |\n| | rect_id | str | The ID of the rectangle. | \u274c |\n| rectangle_delete | | bool | Deletes a specific rectangle if the rect_id is provided else deletes all the rectangles in the image <br><b>Returns:</b><br> True if rectangle deleted or False if rectangle not found<br> | |\n| | rect_id | str | The rect_id of the rectangle to be deleted or \"\" if all rectangles are to be deleted. | \u2713 |\n| rectangle_draw | | None | Draws a rectangle on the currently loaded image | |\n| | colour | str (\"red\") | Colour of rectangle line (mostly legal HTML colours) | \u2713 |\n| | height | int (-1) | If -1, top + 50, Otherwise Height of rectangle in pixels | \u2713 |\n| | item_id | str | Rectangle identifier. Must be a non-empty str | \u274c |\n| | left | int | Left position in pixels | \u274c |\n| | top | int | Top position in pixels | \u274c |\n| | visible | bool (True) | If True, rectangle is visible, Otherwise not | \u2713 |\n| | width | int (-1) | If -1, left + 20 , Otherwise width of rectangle in pixels | \u2713 |\n| rectangle_id_change | | None | Updates the rectangle id | |\n| | new_id | str | The new rectangle_id | \u274c |\n| | old_id | str | The old rectangle_id | \u274c |\n| rectangle_overlaps | | tuple [Overlap_Rect](#overlap_rect) | Returns a tuple of overlapping rectangles<br><b>Returns:</b><br> A tuple containing the ids and coords of overlapping rectangles.<br> | |\n| | overlap_ratio | float (0.3) | The ratio to determine overlapping. 0 - No overlap to 1 - Complete overlap | \u2713 |\n| rectangle_show | | None | | |\n| | rect_id | str | The id of the rectangle that will be shown/hidden depending on visible | \u274c |\n| | suppress_rect_check | bool (False) | Used for debugging, suppresses the assert for checking if a rect_id is in the image | \u2713 |\n| | visible | bool | True shows the rectangle, False hides the rectangle | \u274c |\n| rectangles_changed | | dict [str, [Rect_Changed](#rect_changed)] | Returns a dict of changed rectangles <br><b>Returns:</b><br> Dict of changed rectangles.<br> | |\n\n### Label\n\nCalling Label in a layout will generate a Label control on a form. \n\nThe \"tag\" and \"text\" are generally the only arguments used, and \"tag\" is only \nneeded if you plan on referencing the label in your code. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n\n<br>**Properties**\n<br> A Label has no special properties, but can use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties as in the \"fully loaded\" example below\n\n<br>A fully loaded Label declaration:\n<br><br>**Note: Only \"tag\", \"text\"are usually needed** \n - txt_font overrides the other text font settings\n\n```\nLabel(\n tag=\"example03\",\n label=\"Label\",\n text=\"Example 03\",\n label_font=qtg.Font(\n font_name=\"Courier\",\n style=qtg.Font_Style.OBLIQUE,\n size=42,\n backcolor=\"yellow\",\n forecolor=\"blue\",\n ),\n txt_fontsize=42,\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(\n font_name=\"DejaVu Sans Mono\",\n backcolor=\"blue\",\n forecolor=\"yellow\",\n size=50,\n ),\n width=8,\n frame=qtg.Widget_Frame(\n frame_style=qtg.Frame_Style.BOX,\n frame=qtg.Frame.RAISED,\n line_width=5,\n midline_width=2,\n ),\n height=2,\n tune_hsize=30,\n tune_vsize=15\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Label instances\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|----------|--------------------------------------------|--------------|\n| value_get | | str | <br><b>Returns:</b><br> The label text<br> | |\n| value_set | | None | Sets the label text | |\n| | value | str | text value to set in the label | \u274c |\n\n### LCD\nCalling LCD in a layout will generate an LCD control, with an LCD like number \ndisplay, on a form. This control is unusual in that it only displays a limited set \n0/O, 1, 2, 3, 4, 5/S, 6, 7, 8, 9/g, minus, decimal point, A, B, C, D, E, F, \nh, H, L, o, P, r, u, U, Y, colon, degree sign (which is specified as single \nquote in the string) and space.\n\nRefer to the [Calculator](https://github.com/David-Worboys/QTPYGUI/blob/master/examples/example_02_calculator.py) for a simple program example\n\nThe \"tag\" and \"text\" are generally the only arguments used, and \"tag\" is only \nneeded if you plan on referencing the label in your code. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br> An LCD has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties as in the \"fully loaded\" example below\n\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|-----------------------------|----------|--------------|\n| digit_count | Number of digits in display | int (8) | \u2713 |\n\n<br>A fully loaded LCD declaration:\n<br><br>**Note: Only \"tag\", \"text\"are usually needed**\n\n - txt_font, other than size, has little effect on the LCD control display and most text \nsettings will not apply.\n\n```\nqtg.LCD(\n tag=\"lcd\",\n label=\"LCD\",\n callback=self.event_handler,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, backcolor=\"yellow\", size=14),\n txt_font=qtg.Font(size=15),\n width=8,\n height=1, \n txt_fontsize=12,\n digit_count=9,\n text=\"-123456.7\",\n width=9,\n enabled=True,\n visible=True,\n tooltip=\"LCD Control\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Spacer(width=1),\n qtg.Button(\n tag=\"lcd_button\",\n text=\"Press Me!\",\n callback=self.event_handler,\n width=12,\n ),\n )\n```\n \n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to LCD instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|---------------------|------------------------------------------------------------------|--------------|\n| value_set | | None | Sets the LCD number display | |\n| | value | str \\| int \\| float | The value to be displayed in the LCD<br>Only numbers are allowed | \u274c |\n\n\n### LineEdit\nCalling LineEdit in a layout will generate a LineEdit control on a form. \n\nThe \"tag\", \"text\" and \"callback\" arguments are generally the only arguments used. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br> A LineEdit has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties as in the \"fully loaded\" example below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|-------------------|----------------------------------------------------------------------|------------------------|--------------|\n| char_length | The maximum number of characters that can be entered in the LineEdit | int (MAX_CHARS) | \u2713 |\n| input_mask | The input mask that determines what is shown in the LineEdit | str (\"\") | \u2713 |\n| text | Place holder text | str (\"\") | \u2713 |\n| validate_callback | A callback that validates the text entered | Callable\\| None (None) | \u2713 |\n\n\n<br>**Input Mask**\n\n| **Character** | **Meaning** |\n|---------------|-----------------------------------------------------------------------------------------------------------------------|\n| A | Character of the Letter category required, such as A-Z, a-z. |\n| a | Character of the Letter category permitted but not required. |\n| N | Character of the Letter or Number category required, such as A-Z, a-z, 0-9 |\n| n | Character of the Letter or Number category permitted but not required |\n| X | Any non-blank character required |\n| x | Any non-blank character permitted but not required |\n| 9 | Character of the Number category required, e.g 0-9 |\n| 0 | Character of the Number category permitted but not required |\n| D | Character of the Number category and larger than zero required, such as 1-9 |\n| d | Character of the Number category and larger than zero permitted but not required, such as 1-9 |\n| # | Character of the Number category, or plus/minus sign permitted but not required |\n| H | Hexadecimal character required. A-F, a-f, 0-9 |\n| h | Hexadecimal character permitted but not required |\n| B | Binary character required. 0-1 |\n| b | Binary character permitted but not required |\n| > | All following alphabetic characters are uppercased |\n| < | All following alphabetic characters are lowercased |\n| ! | Switch off case conversion |\n| ;c | Terminates the input mask and sets the blank character to c. |\n| [ ] { } | Reserved |\n| \\ | Use \\ to escape the special characters listed above to use them as separators | |\n| @ | First char indicates password, following chars is the input mask. Display characters as they are entered |\n| * | First char indicates password, following chars is the input mask. Display platform-dependent password mask characters | |\n\n<br>A fully loaded LineEdit declaration:\n<br><br>**Note: Only \"tag\" is usually needed and \"text\" if a placeholder is required**\n \n - If an input mask is provided, the placeholder text is not visible\n - A password mask would look like this: *XXXXXXXX\n - txt_font overrides the other text font settings\n - It is suggested to set \"height\" and width arguments as the font selected \nmight not automatically size correctly.\n \n```\nLineEdit(\n tag=\"lineedit\",\n label=\"Line Edit\",\n text=\"Place Holder\",\n callback=self.event_handler,\n input_mask=\"(9999) 999-9999\",\n width=15,\n height=1,\n char_length=15,\n label_align=qtg.Align_Text.CENTER,\n label_width=10,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),\n txt_align=qtg.Align_Text.CENTER,\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=10),\n txt_fontsize=12,\n bold=True,\n italic=True,\n underline=True,\n enabled=True,\n visible=True,\n tooltip=\"LineEDit \",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Checkbox(\n tag=\"telephone_checkbox_check\",\n text=\"Phone Number!\",\n callback=self.event_handler,\n width=13,\n ),\n ),\n )\n```\n \n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to LineEdit instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|----------------|----------------|--------------|------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| input_mask_set | | None | Set the input mask | |\n| | input_mask | str | Input mask character string | |\n| max_chars_get | | int | Returns the maximum number of characters allowed in the text field<br><b>Returns:</b><br>The max number of characters allowed in the text field.<br> | |\n| max_chars_set | | None | Sets char_length and checks if is > 0 and < MAX_CHARS | |\n| | max_chars | int | The maximum number of characters to use in the line edit control. | |\n| modified | | bool | True, LineEdit modified, Otherwise not modified | |\n| value_get | | str | <br><b>Returns:</b><br> original taxt if `original_value` is `True otherwise the modified text<br> | |\n| | original_value | bool (False) | True - Return original value, Otherwise return the current value | |\n| value_set | | None | Set the LineEdit text to the value string | |\n| | value | str | The value to set. | |\n\n### Menu\nCalling Menu in a layout will generate a menu control on the top of the window \nthat contains the application forms.\n\n<br>**Properties**\n<br> A Menu_Element has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties.\n\n| **Property** | **Description** | **Type** | **Optional** |\n|---------------|-----------------------------------------------------------------------------------------------------------|----------|--------------|\n| container_tag | The system name of the menu container (required if the [Menu_Entry](#menu_entry) is accessed at run time) | str | \u2713\u274c |\n| tag | The system name of the menu | str | \u2713 |\n\n\nA menu is built up of [menu elements](#menu_element) and creating a menu is straight forward:\n<br>\n1. Create a Menu instance\n2. Add The top row menu elements with the element_add method and the parent_tag = \"\"\n3. Add submenu elements with the parent tag pointing to the tag of the parent menu element\n4. Repeat Step 3 as often as needed to make up the menu structure.\n5. If a seperator is needed, set menu element text to \"---\" which is the constant MENU_SEPERATOR <br>\nor set menu element seperator=True\n\nThe code below illustrates this process\n\n\n```\nmenu = qtg.Menu(container_tag=\"main_menu\",tag=\"top_level\") # Create menu object\n\n# Make top row menu elements - as many as needed, in this case one \nmenu.element_add(\n parent_tag=\"\",\n menu_element=qtg.Menu_Element(\n text=\"&Test\", tag=\"test\", callback=self.event_handler\n ),\n)\n\n\n\n# Add menu elements to the top row menu elements\nmenu.element_add(\n parent_tag=\"test\",\n menu_element=qtg.Menu_Element(\n text=\"&Level 2 Test 1\",\n tag=\"level2_test1\",\n callback=self.event_handler,\n tooltip=\"Test 2\",\n ),\n)\n\n# A seperator draws a line between menu elements - there are 2 ways as illustrated.\n# The least preferred (using text) is commented out \nmenu.element_add(\n parent_tag=\"test\",\n menu_element=qtg.Menu_Element( \n separator=True,\n # text= MENU_SEPERATOR \n ),\n)\n\nmenu.element_add(\n parent_tag=\"test\",\n menu_element=qtg.Menu_Element(\n text=\"&Level 2 Test 2\",\n tag=\"level2_test\",\n callback=self.event_handler,\n tooltip=\"\",\n ),\n)\n\n# Add sub-menus in this case to parent_tag=\"level2_test\nmenu.element_add(\n parent_tag=\"level2_test\",\n menu_element=qtg.Menu_Element(\n text=\"&Level 3 Test\",\n tag=\"level3_test\",\n callback=self.event_handler,\n tooltip=\"\",\n ),\n)\n\n# Add sub-menus in this case to parent_tag=\"level3_test \nmenu.element_add(\n parent_tag=\"level3_test\",\n menu_element=qtg.Menu_Element(\n text=\"&Level 4 Test\",\n tag=\"level4_test\",\n callback=self.event_handler,\n checkable=True,\n font=qtg.Font(style=qtg.Font_Style.ITALIC, forecolor=\"red\", size=14),\n tooltip=\"level4_test\",\n icon= qtg.Sys_Icon.filenew.get(),\n ),\n)\n\n(\n menu.element_add(\n parent_tag=\"level3_test\", menu_element=qtg.Menu_Element(text=\"---\")\n ),\n)\n\nmenu.element_add(\n parent_tag=\"level3_test\",\n menu_element=qtg.Menu_Element(\n text=\"&Level 4 Test 1\",\n tag=\"level4_test1\",\n callback=self.event_handler,\n tooltip=\"\",\n ),\n)\n```\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|-------------|---------------|-------------------------------|-----------------------------------------------------------------------------|--------------|\n| element_add | | None | | |\n| | menu_element | [Menu_Element](#menu_element) | Menu Element instance | \u274c |\n| | parent_tag | str | Menu element tag of the parent menu element. \"\" is the top level parent_tag | \u274c |\n\n#### Menu_Element\nA Menu_Element is a menu control element added to the [Menu](#menu) via the \nelement_add method that defines a menu item entry.\n\n<br>**Properties**\n<br> A Menu_Element has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties.\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|------------------------------------------------------------------------------------------------|----------------------------------------|--------------|\n| callback | The event handler method to call when the menu item is clicked on | Callable | \u274c |\n| checkable | Makes a check box in te menu item | bool (False) | \u2713 |\n| enabled | If True enables the menu_item, Otherwise disabled the menu item | bool (True) | \u2713 |\n| font | Sets the font of the menu item (colours are not currently working) | [Font](#font) \\| Nonw (None) | \u2713 |\n| icon | Sets an icon on the menu item | str \\| qtG.QIcon \\| qtG.QPixmap (None) | \u2713 |\n| separator | Draws a line to separate menu items | bool (False) | \u2713 |\n| tag | The menu items system name (required if the [Menu_Entry](#menu_entry) is accessed at run time) | str | \u2713\u274c |\n| text | The menu item text | str | \u274c |\n| tooltip | The menu item tooltip that displays when the cursor is hovering over the menu item | str | \u2713 |\n| visible | if True makes the menu item visible, otherwise the menu_item is invisible | bool (True) | \u2713 |\n\n\n#### Menu_Entry\nA Menu_Entry instance is returned in the callback event handler method when a \n[Menu](#menu) item is selected\n\n<br>**Properties**\n<br> A Menu_Entry has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties.\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|-------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------|--------------|\n| element | The [Menu Element](#menu_element) definition that is contained in this Menu Entry | [Menu_Element](#menu_element) | \u274c |\n| parent_tag | The tag name of the [Menu Element](#menu_element) that is the parent of this Menu_Entry<br> Top level menu items do not have a parent_tag | str (\"\") | \u2713 |\n| tag | The tag name of the [Menu Element](#menu_element) that is contained in this Menu Entry | str | \u274c |\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to Menu_Entry instances\n<br><br>**Note: A menu item cannot have a checked box and an icon simultaneously. If an icon is set then a checkbox is not displayed**\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|-------------|---------------|-----------------------------------------|---------------------------------------------------------------------------------------|--------------|\n| checked_get | | bool | <br><b>Returns:</b><br> True - Menu Item Checked, Otherwise Menu Item Not Checked<br> | |\n| checked_set | | None | Sets a menu item to be checked or not checked | |\n| | checked | bool | True - Check menu item, False - Uncheck Menu Item | \u274c |\n| enabled_get | | bool | br><b>Returns:</b><br> True - Menu Item Enabled, False - Menu Item Disabled<br> | |\n| enabled_set | | None | Sets a menu item to be enabled or not enabled | |\n| | enabled | bool | True - Enable menu item, Otherwise disable Menu Item | \u274c |\n| font_get | | QFont | <br><b>Returns:</b><br> The font of the menu item<br> | |\n| font_set | | None | Sets the font of the menu item | |\n| | font | [Font](#font) | | \u274c |\n| icon_get | | None | <br><b>Returns:</b><br> The icon of the menu item<br> | |\n| icon_set | | str \\| qtG.QPixmap \\| qtG.QIcon \\| None | Sets the icon of the menu item | |\n| text_get | | str | <br><b>Returns:</b><br> The text of the menu item<br> | \u274c |\n| text_set | | None | Sets the text of the menu item | |\n| | text | str | The text to set | \u274c |\n| tooltip_get | | str | <br><b>Returns:</b><br> The tooltip of the menu item<br> | |\n| tooltip_set | | None | Sets the tooltip of the menu item | |\n| | tooltip | str | The tooltip to set | \u274c |\n| visible_get | | bool | <br><b>Returns:</b><br> True - Menu Item Visible, False - Menu Item Not Visible<br> | |\n| visible_set | | None | Sets a menu item to visible or not visible | |\n| | visible | bool | True - Menu item visible, Otherwise Menu item not visible | \u274c |\n\n\n### ProgressBar\n\nCalling ProgressBar in a layout will generate a ProgressBar control on a form. \n\nThe \"tag\", \"text\" and \"callback\" arguments are generally the only arguments used. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br> A ProgressBar has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties as in the \"fully loaded\" example below\n \n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|---------------------------------------------------------------------------|-------------|--------------|\n| callback | The event handler method to call when the PrgressBar is does something | Callable | \u274c |\n| horizontal | True a horizontal ProgressBath, Otherwise a vertical ProgressBar | bool (True) | \u2713 |\n| label | The label to the left of the ProgressBar that indicates what is is for | str | \u2713 |\n| range_min | The minimum range of a ProgressBar >=0 | int (0) | \u2713 |\n| range_max | The maximum range of a ProgressBar >= 0 | int (100) | \u2713 |\n| tag | The system name of the ProgressBar (required for updates) | str | \u274c |\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | \u2713 ||\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | \u2713 ||\n \n<br>A fully loaded ProgressBar declaration:\n<br><br>**Note: Only \"tag\",\"range_min\",\"range_max\" and \"callback\" is usually needed**\n```\nProgressBar(\n tag=\"progressbar\",\n label=\"Progress Bar\",\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),\n callback=self.event_handler,\n horizontal=True,\n width=15,\n height=1,\n range_min=0,\n range_max=200,\n enabled=True,\n visible=True,\n tooltip=\"Progress Bar\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"progressbar_button\",\n text=\"Press Me!\",\n callback=self.event_handler,\n width=12,\n ),\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to ProgressBar instances\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|----------|-----------------------------------------------------------|--------------|\n| range_set | | None | Sets the range of the progressbar. | |\n| | max | int | The maximum value of the progressbar. | \u274c |\n| | min | int | The minimum value of the progressbar. | \u274c |\n| reset | | None | Resets the progressbar to the minimum value | |\n| value_get | | int | <br><b>Returns:</b><br> The value of the progressbar.<br> | |\n| value_set | | None | Sets the value of the progressbar | |\n| | value | int | The value to set the progressbar to. | \u274c |\n\n\n### RadioButton\n \nCalling RadioButton in a layout will generate a RadioButton control on a form. \nNormally, there is a group of radio buttons, and they are placed in a container \nto ensure only one can be selected at a time. The container will have its text \nproperty set to make it a visible groupbox housing the radio buttons \n\n<br>**Properties**\n<br> A RadioButton has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties as in the \"fully loaded\" example below\n \n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|-------------------------------------------------------------------------|----------|--------------|\n| callback | The event handler method to call when the RadioButton is does something | Callable | \u274c |\n| tag | The system name of the RadioButton (required for updates) | str | \u274c |\n| text | The text displayed to the left of the RadioButton | str | \u274c |\n\n<br>A fully loaded RadioButton declaration:\n<br><br>**Note: This example is hardly realistic but shows the reader what is possible**\n<br>- Normally all that is required is this:\n ```\n qtg.RadioButton(tag=\"radio2\", text=\"Radio 2\", callback=self.event_handler)\n ```\n\n\n\n```\nHBoxContainer(text=\"Radio Buttons\", tag=\"radios\").add_row(\n qtg.RadioButton(\n tag=\"radio1\",\n text=\"Radio 1\",\n checked=True,\n callback=self.event_handler,\n label=\"Radio Button 1\",\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),\n enabled=True,\n visible=True,\n tooltip=\"Radio Button\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"radio_button_push\",\n text=\"R1 Push Me!\",\n callback=self.event_handler,\n width=15,\n height=1,\n )),\n ),\n qtg.RadioButton(\n tag=\"radio2\", text=\"Radio 2\", callback=self.event_handler\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a RadioButton instance\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|----------------|---------------|----------|-----------------------------------------------------------------------------------------|--------------|\n| button_checked | | bool | <br><b>Returns:</b><br> True - Checked, False - Not Checked<br> | |\n| button_toggle | | None | Set the radiobutton to checked or unchecked | |\n| | value | bool | True - radio button checked. False - radio button not-checked. | \u274c |\n| value_get | | bool | <br><b>Returns:</b><br> True - Radiobutton Checked, False - Radiobutton not checked<br> | |\n| value_set | | None | Sets the radiobutton to checked or unchecked | |\n| | value | bool | True - checked. False - not checked. | \u274c |\n\n\n### Slider\n\nCalling Slider in a layout will generate a Slider control on a form. \n\nThe \"tag\", \"text\" and \"callback\" arguments are generally the only arguments used. \n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br> A Slider has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties as in the \"fully loaded\" example below\n \n| **Property** | **Description** | **Type** | **Optional** |\n|----------------------|---------------------------------------------------------------------------|--------------------|--------------|\n| callback | The event handler method to call when the PrgressBar is does something | Callable | \u274c |\n| orientation | \"vertical\" or \"horizonral\" presentation of the slider | str (\"horizontal\") | \u2713 |\n| page_step | The step size when the page up/down is pressed | int (10) | \u2713 |\n| range_max | The maximum value of the slider | int (100) | \u2713 |\n| range_min | The minimum value of the slider | int (0) | \u2713 |\n| scale_factor_percent | Scales the value internally by a certain perentage (_Experimental_) | float (0.0) | \u2713 |\n| single_step | The step size when a single step is taken | int (1) | \u2713 |\n| tag | The system name of the RadioButton (required for updates) | str | \u274c |\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | \u2713 |\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | \u2713 |\n \n<br>A fully loaded Slider declaration:\n<br><br>**Note: Only \"tag\",\"range_min\",\"range_max\" and \"callback\" is usually needed**\n\n```\nSlider(\n tag=\"slider\",\n label=\"Slider\",\n callback=self.event_handler,\n range_min=0,\n range_max=500, \n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE,backcolor=\"yellow\", size=15),\n enabled=True,\n visible=True,\n tooltip=\"Sliders\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"slider_push\",\n text=\"Sliders!\",\n callback=self.event_handler,\n width=10,\n height=1,\n )\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a RadioButton instance\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|---------------|---------------|--------------|---------------------------------------------------------------------|--------------|\n| scale_factor | | float | The scale factor calculated from the percentage | |\n| scale_factor | | None | Sets the scale factor as a percentage. | |\n| | value | float | The scale factor as a percentage | \u274c |\n| range_min_set | | None | Sets the minimum value of the slider.<br><br> | |\n| | range_min | int | The minimum value of the slider. | \u274c |\n| range_max_set | | None | Sets the maximum value of the slider.<br><br> | |\n| | range_max | int | The maximum value of the slider. | \u274c |\n| value_get | | int | <br><b>Returns:</b><br> - int: The value of the slider.<br> | |\n| value_set | | None | Sets the value of the slider.<br><br> | |\n| | value | int | The value to set the slider to. | \u274c |\n| | block_signals | bool (False) | True, stop the slider from emitting signals, Otherwise emit signals | \u2713 |\n\n### Spacer\n \nCalling Spacer in a layout will generate a Spacer control on a form. A Spacer control is\nused to control layout, acting as filler. \n\nOnly the \"width\" and \"height matter for a Spacer control. Although it is not \nrecommended, the \"text_font\" can be set which will alter the Spacer size.\n\n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n<br>**Properties**\n<br> A Spacer has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown, in the \"fully loaded\" example below\n \n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|---------------------------------------------------------------------------|----------|--------------|\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | \u2713 |\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | \u2713 |\n\n\n<br>A fully loaded Spacer declaration:\n<br><br>**Note: Only \"width\" and \"height\" need to be used for Spacers** \n\n- Spacers can also have buddy controls and labels, but this would be considered a \n very unusual \"use case\"\n\n```\nSpacer(width=1, height=2)\n\n```\n\n<br>**Methods**\n<br>Although a subset of the [_qtpyBase_Control](#_qtpybase_control) methods may apply \nto a Spacer instance, no methods are defined for Spacers, and it is not \nanticipated any of the ancestral methods will be used.\n\n## Spinbox\n\nCalling Spinbox in a layout will generate a Spinbox control on a form. A \nSpinbox control is used to enter numbers with up and down arrows so that\na user can quickly set a number. \n\n<br>**Properties**\n<br> A Spinbox has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the \"fully loaded\" example below\n \n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|---------------------------------------------------------------------------|-----------|--------------|\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (1) | \u2713 |\n| prefix | A text string appended to the front of the number display eg $ | str (\"\") | \u2713 |\n| range_max | The maximum value of the slider | int (100) | \u2713 |\n| range_min | The minimum value of the slider | int (0) | \u2713 |\n| single_step | The step size when a single step is taken | int (1) | \u2713 |\n| suffix | A text string appended to the end of the number display eg. km | str (\"\") | \u2713 |\n| tag | The system name of the Spinbox (required for updates) | str | \u274c |\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels | int (10) | \u2713 |\n\n<br>A fully loaded Spinbox declaration:\n<br><br>**Note: Only \"tag\",\"range_min\",\"range_max\" and \"callback\" is usually needed**\n<br>It is suggested to set width and height as the font selected might not automatically\nsize correctly.\n\n```\nSpinbox(\n tag=\"spinbox\",\n label=\"Spin Box\",\n prefix=\"Far \",\n suffix=\" km\",\n callback=self.event_handler,\n range_max=500,\n range_min=0,\n width=15,\n height=1,\n label_font=qtg.Font(\n style=qtg.Font_Style.OBLIQUE,\n backcolor=\"blue\",\n font_name=\"DejaVu Sans Mono\",\n forecolor=\"yellow\",\n size=10,\n ),\n enabled=True,\n visible=True,\n tooltip=\"Spin Box\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"spinbox_push\",\n text=\"Spin Box!\",\n callback=self.event_handler,\n width=10,\n height=1,\n )\n ),\n ),\n ),\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a Spinbox instance \n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|----------|-------------------------------------------------------|--------------|\n| value_get | | int | <br><b>Returns:</b><br> The value of the spinbox.<br> | |\n| value_set | | None | | |\n| | value | int | The value to set the spinbox to. | \u2713 |\n\n### Switch\n \nCalling Switch in a layout will generate a Switch control on a form. A Switch\ncontrol is used to flick a setting on and off.\n. \n\n<br>**Properties**\n<br> A Switch has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the \"fully loaded\" example below\n \n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|---------------------------------------------|--------------|--------------|\n| checked | True, Switch is on, Otherwise Switch is off | bool (False) | \u2713 |\n| label | Sets a text label to the left | str (\"\") | \u2713 |\n| text | Sets a text label to the right | str (\"\") | \u2713 |\n\n\n \n<br>A fully loaded Switch declaration:\n<br><br>**Note: Only \"tag\",\"label\",\"text\" and \"callback\" are usually needed**\n<br>It is suggested **NOT** to set width and height as the defaults suit the Switch style.\n- It has been noted with a buddy_control it is necessary to adjust ```tune_vsize=-10```\nWhere 10 is an arbitrary figure and the programmer will need to experiment to find \nthe correct value\n\n```\nSwitch(\n tag=\"switch1\",\n label=\"SW1 Off\",\n text=\"SW1 On!\",\n callback=self.event_handler,\n label_font=qtg.Font(style=qtg.Font_Style.OBLIQUE, size=10),\n txt_font=qtg.Font(style=qtg.Font_Style.NORMAL, size=15),\n enabled=True,\n visible=True,\n height=1,\n tooltip=\"Sw 1\",\n tune_hsize=-15,\n tune_vsize=-10,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"switch_button_push\",\n text=\"SW1 Push Me!\",\n callback=self.event_handler,\n width=15,\n height=1,\n )\n ),\n )\n```\n\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a Switch instance\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------------|---------------|-------------------------------|------------------------------------------------------------------------|--------------|\n| button_checked | | bool | <br><b>Returns:</b><br> True - Switch is on, False - Switch is off<br> | |\n| button_toggle | | None | Toggles the state of the Twitch | |\n| | value | bool (True) | True - Switch on, False Switch off | \u2713 |\n| track_colour_set | | None | Sets the colour of the Switch track | |\n| | disable | TEXT_COLORS (system disabled) | The disabled color of the Switch track | \u274c |\n| | enable | TEXT_COLORS (system enabled) | The enabled color of the Switch track | \u274c |\n| value_get | | bool | <br><b>Returns:</b><br> True - Switch is on, False - Switch is off<br> | |\n| value_set | | None | | |\n| | value | bool | True - Switch on, False Switch off | |\n\n\n### Tab\n \nCalling Tab in a layout will generate a Tab control on a form. A Tab control \ncan have multiple pages that can house [GUI Controls](#gui-controls-1).\n \n\n<br>**Properties**\n<br> A Tab control has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the \"fully loaded\" example below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------------|-------------------------------------------------------------------------------------------------------------------|----------|--------------|\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (1) | \u2713 ||\n| page_right_margin | Controls the right margin of the [Container](#containers) that fills the form. <br>- Seldom Used <br>- in pixels | int (10) | \u2713 |\n| page_bottom_margin | Controls the bottom margin of the [Container](#containers) that fills the form. <br>- Seldom Used <br>- in pixels | int (50) | \u2713 |\n| tag | The system name of the Tab (required for application processing) | str | \u274c |\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (10) | \u2713 ||\n\n<br>A fully loaded Tab declaration:\n<br><br>**Note: Only \"tag\" and \"callback\" are usually needed**\n\nCreating a Tab control is a three-step process\n<br>\n- 1 Create the tab instance (label properties are optional) \n<br><br>\n```\ntab = qtg.Tab(\n tag=\"tab\",\n label=\"Example Tab\",\n label_font=qtg.Font(backcolor=\"yellow\", forecolor=\"blue\", size=20),\n callback=self.event_handler,\n width=35,\n height=13,\n ) \n```\n\n- 2 Add pages (The control argument is mandatory, even if it is only an empty [Container](#containers)) \n - Here we add a VBoxContainer with an [Image](#image) and two [Buttons](#button) \n as an example\n - It is a good idea to declare the control layout as a separate declaration \n (like tab in Step 1, except it will be a [Container](#containers)) as it will be clearer\n - This means any [GUI Controls](#gui-controls-1), including another [Tab](#tab) control, can be\n placed on a tab page\n - **Note: Only \"tag\", \"title\" (tab page title), \"control\" and \"callback\" are usually needed**\n\n ```\n tab.page_add(\n tag=\"tab_pg1\",\n title=\"Page 1\",\n control=qtg.VBoxContainer(align=qtg.Align.CENTER).add_row(\n qtg.Spacer(height=1),\n qtg.Image(\n tag=\"image\",\n # label=\"Image\",\n width=20,\n height=20,\n callback=self.event_handler,\n image=\"example.jpg\",\n ),\n qtg.Spacer(height=1),\n qtg.Button(\n tag=\"add_page\", text=\"Add Page\", callback=self.event_handler\n ),\n qtg.Button(\n tag=\"delete_page\",\n text=\"Delete Page\",\n callback=self.event_handler,\n ),\n ),\n )\n ```\n\n- 3 Repeat Step 2 until done\n\nPutting it all together, this is how to declare a Tab with one page ([Example 04](https://github.com/David-Worboys/QTPYGUI/blob/master/examples/example_04_tab_control.py))\n \n```\n def tab_definition() -> qtg.Tab:\n \"\"\"Creates the tab control definition\"\"\"\n\n # 1st Create a tab page layout (this could be in another function, file or method)\n # Here we have an Image with two buttons layed out horizontally under it\n tab_page_layout = qtg.VBoxContainer(align=qtg.Align.CENTER).add_row(\n qtg.Spacer(height=1),\n qtg.Image(\n tag=\"image\",\n # label=\"Image\",\n width=20,\n height=20,\n callback=self.event_handler,\n image=\"example.jpg\",\n ),\n qtg.Spacer(height=1),\n qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"add_page\", text=\"Add Page\", callback=self.event_handler\n ),\n qtg.Button(\n tag=\"delete_page\",\n text=\"Delete Page\",\n callback=self.event_handler,\n ),\n ),\n )\n\n # 2nd, Create the tab\n tab = qtg.Tab(\n tag=\"tab\",\n label=\"Example Tab\",\n label_font=qtg.Font(backcolor=\"yellow\", forecolor=\"blue\", size=20),\n callback=self.event_handler,\n width=35,\n height=13,\n )\n\n # 3rd, Add Pages\n tab.page_add(\n tag=\"tab_pg1\",\n title=\"Page 1\",\n control=tab_page_layout,\n )\n\n return tab\n```\n\nAnd this is how the Tab control can be manipulated at application run time in the callback method \"event_handler\"\n<br>\n```\n def event_handler(self, event: qtg.Action):\n \"\"\"Handles form events\n Args:\n event (qtg.Action): The triggering event\n \"\"\"\n assert isinstance(event, qtg.Action), f\"{event=}. Must be Action\"\n\n match event.event:\n case qtg.Sys_Events.CLICKED:\n if event.tag == \"add_page\":\n # Get tab widget\n tab_widget = cast(\n qtg.Tab,\n event.widget_get(container_tag=\"tab_container\", tag=\"tab\"),\n )\n\n # Add page\n page_count = tab_widget.page_count()\n\n new_page_tag = f\"tab_page{page_count + 1}\"\n\n if tab_widget.page_exists(new_page_tag):\n tab_widget.page_remove(new_page_tag)\n\n tab_widget.page_add(\n tag=new_page_tag,\n title=f\"Page {page_count + 1}\",\n control=qtg.VBoxContainer().add_row(\n qtg.Label(\n text=f\"Page {page_count + 1}\",\n align=qtg.Align.CENTER,\n ),\n qtg.Button(\n text=\"Delete Page\",\n tag=f\"delete_page{page_count + 1}\",\n callback=self.event_handler,\n ),\n ),\n )\n elif event.tag.startswith(\"delete_page\"):\n # Get tab widget\n tab_widget = cast(\n qtg.Tab,\n event.widget_get(container_tag=\"tab_container\", tag=\"tab\"),\n )\n\n page_count = tab_widget.page_count()\n page_tag = tab_widget.current_page_tag()\n\n # Never delete the first page. page_index returns 0 if first page \n if page_count == 1 or tab_widget.page_index(page_tag) == 0:\n popups.PopError(\n title=\"Error...\",\n message=\"A Tab Must Have One Page And First Page Can Not Be Deleted\",\n ).show()\n else:\n # Delete page\n tab_widget.page_remove(page_tag)\n elif event.tag == \"ok\":\n self.example_04.app_exit()\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a Tab instance\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------------|----------------|----------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| current_page_tag | | str | <br><b>Returns:</b><br> The current tab page tag<br> | |\n| enable_get | | bool | | |\n| | tag | str | The tag name of the Tab control or tab page depending on which enable state is required. | \u274c |\n| enable_set | | int | <br><b>Returns:</b><br> 1 - Success, -1 - Failure<br> | |\n| | enable (True) | bool | True - Enable the tab or tab page, False - Disable the tab or tab page. | \u2713 |\n| | tag (\"\") | str | The tag name of the tab or tab page depending on which enable state is required.<br>-If tag is \"\" then enable applies to all tab pages <br>-If tag is the Tab tag name then enable applies to the Tab control, Otherwise it applies to the tab page with the tag name | \u2713 |\n| page_add | | None | Creates and adds a new tab page <br><b>Returns:</b><br> The Tab control<br> | |\n| | control | [Container](#containers) \\| [GUI Control](#gui-controls) | The [Container](#containers) \\| [GUI Control](#gui-controls) defining the tab page GUI layout | \u274c |\n| | enabled (True) | bool | Sets the tab page enabled/disabled | \u2713 |\n| | icon | str [File Name] \\| QPixmap \\| qtG.QIcon (None) | Add an icon to the tab page title | \u2713 |\n| | tag | str | Tab page tag | \u274c |\n| | title | str | Tab page title | \u274c |\n| | tooltip (\"\") | str | The tab page tooltip | \u2713 |\n| | visible (True) | bool | Sets the tab page visible/invisible | \u2713 |\n| page_count | | int | <br><b>Returns:</b><br> The number of tab pages<br> | |\n| page_exists | | bool | <br><b>Returns:</b><br> True if the tab page exists<br> | |\n| | tag | str | The tag name of the tab page | \u274c |\n| page_icon_set | | None | Sets a tab page icon | |\n| | icon | str [File Name] \\| QPixmap \\| qtG.QIcon (None) | Add an icon to the tab page title | \u274c |\n| | tag | str | The tag name of the page whose icon is to be set on. | \u274c |\n| page_index | | int | <br><b>Returns:</b><br> The index of the tab page or -1 if tab not found<br> | |\n| | tag | str | The tag name of the tab page | \u274c |\n| page_remove | | None | Removes a tab page from the tab widget | |\n| | tag | str | tag name of the page to be removed | \u274c |\n| pages_remove_all | | None | Removes all the pages from the Tab control | |\n| page_visible_get | | bool | <br><b>Returns:</b><br> `<br>True` if the tab page with the given tag name is visible, `False` otherwise<br> | |\n| | tag | str | tag name of the page to be checked | \u274c |\n| page_visible_set | | None | Sets the visibility of a tab page | |\n| | tag | str | tag name of the page to be set | \u274c |\n| | visible | bool | True to make the page visible, False to hide it | \u274c |\n| select_tab | | None | Selects the tab page with the given tag name | |\n| | tag_name | str | The tag name of the tab page to be selected | \u274c |\n| tooltip_get | | str | <br><b>Returns:</b><br> The tooltip text for the tab page with the tag name.<br> | |\n| | tag | str | The tag name of the tab to get the tooltip from. | \u274c |\n| tooltip_set | | None | Selects the tab page with the given tag name | |\n| | tag | str | tag name of the tab page to set the tooltip text | \u274c |\n| | tooltip | str | The tooltip text | \u274c |\n\n### TextEdit\n\nCalling TextEdit in a layout will generate a TextEdit control on a form. \nA TextEdit control is used to enter a large amount of text.\n \n\n<br>**Properties**\n<br> A TextEdit control has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the \"fully loaded\" example below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|--------------|---------------------------------------------------------------------------------------------------|---------------|--------------|\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (1) | \u2713 | |\n| max_chars | The maximum number of characters that can be entered into the TextEdit control | int (-1) | \u2713 |\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting | int (10) | \u2713 | |\n| word_wrap | True, text line wraps, Otherwise it does not | bool (True) | \u2713 |\n| tag | The system name of the TextEdit control (required for application processing) | str | \u274c |\n \n\n<br>A fully loaded TextEdit declaration:\n<br><br>**Note: Only \"tag\", \"text\" (To preload the TextEdit control) and \"callback\" are usually needed**\n- It is possible to paste text into the TextEdit control and to a large degree \nthis will retain the original formatting\n\n```\nTextEdit(\n tag=\"textedit\",\n text=\"Text Edit\",\n label=\"Text Edit\",\n callback=self.event_handler,\n height=5,\n max_chars=10,\n word_wrap=True,\n \n label_font=qtg.Font(\n style=qtg.Font_Style.OBLIQUE, backcolor=\"blue\",forecolor=\"yellow\", size=12\n ),\n txt_font=qtg.Font(\n style=qtg.Font_Style.NORMAL, backcolor=\"yellow\", size=15,font_name=\"DejaVu Sans Mono\"\n ),\n enabled=True,\n visible=True,\n tooltip=\"Text Edit\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"textedit_push\",\n text=\"Text Edit!\",\n callback=self.event_handler,\n width=10,\n height=1,\n )\n ),\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods apply to a TextEdit instance\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|-------------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| value_get | | str | Returns the text from the TextEdit` widget as either plain text or HTML<br><b>Returns:</b><br> The text in the text box in the selected format.<br> | |\n| | plain_text (True) | bool | True - Returns the text as plain text, Otherwise Returns the text as HTML. | \u2713 |\n| value_set | | None | Sets the text of the widget to the string value | |\n| | value | str | The string value to set the TextEdit widget to. | \u274c |\n\n### Timeedit\n\nCalling Timeedit in a layout will generate a Timeedit control on a form. \nA Timeedit control is used to enter the time.\n \n\n<br>**Properties**\n<br> A Timeedit control has the following properties, but can also use a subset of \n[_qtpyBase_Control](#_qtpybase_control) properties, which are not shown in the \"fully loaded\" example below\n\n| **Property** | **Description** | **Type** | **Optional** |\n|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|--------------|\n| display_format | The time format display | str (\"hh:mm\") | |\n| display_width | The width of the display. It is unlikely this will need setting | int (10) | |\n| height | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. It is unlikely this will need setting but this depends on the display format mask | int (1) | \u2713 | \n| hour | The hour as an integer number | int (-1) | |\n| min | The minute as an integer number | int (-1) | |\n| sec | The second as an integer number | int (-1) | |\n| msec | The milliseconds as an intger number | int (-1) | |\n| width | Characters if [pixel_unit](#_qtpybase_control) is False, Otherwise pixels. This will need setting if the display format is different from the default | int (10) | \u2713 | \n| tag | The system name of the TextEdit control (required for application processing) | str | \u274c |\n| validate_callback | A callback that validates the time entered | Callable\\| None (None) | \u2713 |\n \n<br>**Display Format Mask Characters**\n\n| **Format** | **Description** |\n|------------|------------------------------------------------------------------------|\n| h | \tthe hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display) |\n| hh | \tthe hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display) |\n| m | \tthe minute without a leading zero (0 to 59) |\n| mm | \tthe minute with a leading zero (00 to 59) |\n| s | \tthe second without a leading zero (0 to 59) |\n| ss | \tthe second with a leading zero (00 to 59) |\n| z | \tthe milliseconds without leading zeroes (0 to 999) |\n| zzz | \tthe milliseconds with leading zeroes (000 to 999) |\n| AP | \tinterpret as an AM/PM time. AP must be either \u201cAM\u201d or \u201cPM\u201d. |\n| ap | \tInterpret as an AM/PM time. ap must be either \u201cam\u201d or \u201cpm\u201d. |\n\n<br>A fully loaded Timeedit declaration:\n<br><br>**Note: Only \"tag\", \"hour\", \"min\", \"sec\",\"msec\"\" (If the Timedit is to be preloaded then all these properties are required) and \"callback\" are usually needed**\n\n```\nTimeedit(\n tag=\"timeedit\",\n label=\"Time Edit\",\n callback=self.event_handler,\n hour=12,\n min=23,\n sec=1,\n msec=0,\n txt_font=qtg.Font(\n style=qtg.Font_Style.NORMAL,\n backcolor=\"wheat\",\n forecolor=\"darkgray\",\n size=15,\n font_name=\"DejaVu Sans Mono\",\n ),\n label_font=qtg.Font(\n style=qtg.Font_Style.OBLIQUE,\n backcolor=\"blue\",\n forecolor=\"yellow\",\n size=20,\n ),\n enabled=True,\n visible=True,\n tooltip=\"Time Edit\",\n tune_hsize=15,\n tune_vsize=15,\n user_data={\"key\": \"value\"},\n buddy_control=qtg.HBoxContainer().add_row(\n qtg.Button(\n tag=\"timeedit_push\",\n text=\"Time Edit!\",\n callback=self.event_handler,\n width=10,\n height=1,\n )\n ),\n )\n```\n\n\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods also apply to a TextEdit instance\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| clear | | None | Clears the displayed value | |\n| | default_text | str (\"-\") | The time text string or \"-\" for no time text to be `displayed | \u2713 |\n| time_get | | [Time_Struct](#time_struct) | <br><b>Returns:</b><br> [Time_Struct](#time_struct) (hour,min,sec,msec)<br> | |\n| time_set | | None | Sets the time.<br>If the hour = -1 & min = -1 & sec = -1 & msec = -1 then the displayed value is cleared<br> All arguments must be set | |\n| | hour | int (-1) | Hour value | \u2713 |\n| | min | int (-1) | Minute value | \u2713 |\n| | msec | int (-1) | Millisecond value | \u2713 |\n| | sec | int (-1) | Second value | \u2713 |\n| value_get | | str\\| [Time_Struct](#time_struct) | Returns the time value | |\n| | format | str (\"-\") | Format string. <br>If \"-\" then the time is returned as a string formatted to system short-format <br>if \"\" then a [Time_Struct](#time_struct) is returned<br>Otherwise the format statement is used and a formatted time string returned | \u2713 |\n| | time_struct | bool (False) | If True return a [Time_Struct](#time_struct), Otherwise return a string | \u2713 | \n| value_set | | None | | |\n| | hour | int (-1) | Hour value | \u2713 |\n| | min | int (-1) | Minute value | \u2713 |\n| | msec | int (-1) | Millisecond value | \u2713 |\n| | sec | int (-1) | Second value | \u2713 |\n\n### Treeview\n\nCalling Treeview in a layout will generate a Treeview control on a form. \n\n\n<br>**Properties**\n\n| **Property** | **Description** | **Type** | **Optional** |\n|----------------|-----------------------------------------------------------------|----------------------------------|--------------|\n| headers | Set this if a Treeview requires headers | list[str] \\| tuple[str, ...]] () | \u2713 |\n| header_widths | The header item widths, defaults to 15 if not set | tuple[int, ...] \\| list[int]] () | \u2713 |\n| header_font | The font of the header text | [Font](#font) | \u2713 |\n| height | Height of Treeview in chars | int (15) | \u2713 |\n| multiselect | True select multiple items, Otherwise select only a single item | bool (False) | \u2713 |\n| toplevel_items | A tuple or list of toplevel items | list[str] \\|tuple[str, ...] () | \u2713 |\n| width | Width of Treeview in chars | int (40) | \u2713 |\n\n<br>A fully loaded Treeview declaration:\n<br><br>**Note: Only \"tag\", \"toplevel_items\" (To preload the Treeview control) and \"callback\" are usually needed**\n```\nTreeview(\n tag=\"treeview\",\n label=\"Treeview\",\n callback=self.event_handler,\n width=15,\n height=5,\n toplevel_items=[\"Test 1\", \"Test 2\"],\n )\n```\n\n<br><br>\nIn the event_handler method child nodes can be added as needed:\n```\n def event_handler(self, event: qtg.Action):\n \"\"\"Handles form events\n Args:\n event (qtg.Action): The triggering event\n \"\"\"\n assert isinstance(event, qtg.Action), f\"{event=}. Must be Action\"\n \n match event.event:\n case qtg.Sys_Events.APPPOSTINIT:\n treeview = event.widget_get(container_tag=\"row_5\",tag=\"treeview\")\n treeview.child_add(treeview_path=\"Test 1\", items=\"Test 3\")\n treeview.child_add(\n treeview_path=[\"Test 1\", \"Test 3\"], items=\"Test 4\"\n )\n```\n\n<br>**Methods**\n<br>A subset of the [_qtpyBase_Control](#_qtpybase_control) methods also apply to a Treeview instance\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|--------------------|---------------|----------|---------------------------------------------------------------------------------------------|--------------|\n| child_add | | int | <br><b>Returns:</b><br> 1 Succeeded, -1 Failed<br> | |\n| child_checked | | None | <br><b>Returns:</b><br> 1 Succeeded, -1 Failed<br> | |\n| | checked | bool | True - Checked, False - Unchecked | |\n| toplevel_add | | None | | |\n| toplevel_items_get | | None | <br><b>Returns:</b><br> A list of strings.<br> | |\n| value_get | | None | <br><b>Returns:</b><br> Current Tree view node value tuple (node text, node user value)<br> | |\n| value_set | | None | | |\n| | col | int | The column to set. Default is 0. | |\n| | value | str | The value to set. | |\n| widget_set | | None | | |\n| | col | int | The column number to place the widget in | |\n\n### QTPYGUI Enumerated Types/Helper Class Reference\n\nThe following enumerated types and helper classes are used to define the features and \nbehaviour of QTPYGUI \n\n### Action\n \nThe Action class is crucial as it is the sole argument of the event handler \nand has methods and properties that are essential for implementing QTPYGUI \nprograms. \n\n**Properties**\n\n| **Property** | **Description** | **Type** |\n|---------------|-------------------------------------------------------------------------------------------------------|-------------------------------------------|\n| action | The event name as a str | str |\n| container_tag | The name of the [Container](#containers) housing the widget that triggered the event | str |\n| control_name | The type name of the [GUI Control](#gui-controls-1) triggering the event (e.g. [Button](#button)) | str |\n| event | The enumerated name of the event (Preferred over action) | Sys_Events |\n| object | A reference to the internal Event_Handler class (Generally not used) | _Event_Handler (Internal Class) |\n| window_id | The window id of the window housing the widget (Generally not used) | int |\n| parent_app | The parent application of the widget (Generally not used) | QtPyApp |\n| parent_widget | The parent widget of the event that was triggered | [GUI Controls](#gui-controls-1) |\n| tag | The name of the [GUI Control](#gui-controls-1) triggering the event | str |\n| value | The value of the [GUI Control](#gui-controls-1) triggering the event (Some events never have a value) | any \\| None |\n| widget_dict | The widget dictionary of the container as an internal _Widget_Entry class (Generally not used) | dict[str, _Widget_Registry._Widget_Entry] | \n\n\n<br>\n\n**Methods**\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|--------------|---------------|--------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|\n| trans_str | | str | It takes a string, translates it, and returns the translated string<br><b>Returns:</b><br> The translated text.<br> | |\n| | text | str | The text to be translated. | \u274c |\n| value_get | | any | Returns the value sourced from a given widget<br><b>Returns:</b><br> The value of the widget.<br> | |\n| | container_tag | str | The tag name of the container that the widget is in. | \u274c |\n| | tag | str | The tag name of the widget you want to get the value of. | \u274c |\n| value_set | | None | Sets the value of a widget | |\n| | container_tag | str | The tag name of the container widget that the widget is in. | |\n| | tag | str | The tag name of the widget you want to set the value of. | \u274c |\n| | value | any | The value to set the widget to. | \u274c |\n| widget_del | | None | Deletes a widget from a container <br> Use widget_exist before widget_delete to ensure the widget exists | |\n| | container_tag | str | The tag name of the container widget that the widget to be deleted is in. | \u274c |\n| | tag | str | The tag name of the widget to be deleted. | \u274c |\n| widget_exist | | bool | Determines if a widget with the given tag name exists in the given container<br><b>Returns:</b><br> True if the widget exists, False otherwise.<br> | |\n| | container_tag | str | The tag name of the container widget that contains the widget you want to check. | \u274c |\n| | tag | str | The tag name of the widget you want to check for. | \u274c |\n| widget_get | | [GUI Controls](#gui-controls-1) \\| [Containers](#containers) | Gets a widget from a container<br><b>Returns:</b><br> The requested widget.<br>If the requested widget does not exist a runtime error is raised<br> Use widget_exist before widget_get to ensure the widget exists<br> | |\n| | container_tag | str | The tag name of the container widget that holds the widget you want to get. | \u274c |\n| | tag | str | The tag name of the widget to get. | \u274c |\n\n#### Align\n\nAlign is an enumerated type used in defining the alignment of [Containers](#containers) and [GUI Controls](#gui-controls-1)\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------|----------------------------------|\n | LEFT | | Qt.AlignLeft |\n| CENTER | | Qt.AlignCenter |\n| CENTERLEFT | | Qt.AlignCenter \\| Qt.AlignLeft |\n| CENTERRIGHT | | Qt.AlignCenter \\| Qt.AlignRight |\n| RIGHT | | Qt.AlignRight |\n| TOP | | Qt.AlignTop |\n| TOPCENTER | | Qt.AlignTop |\n| TOPLEFT | | Qt.AlignTop \\| Qt.AlignLeft |\n | TOPRIGHT | | Qt.AlignTop \\| Qt.AlignRight |\n| BOTTOM | | Qt.AlignBottom |\n| VCENTER | | Qt.AlignVCenter |\n| HCENTER | | Qt.AlignHCenter |\n| BOTTOMCENTER | | Qt.AlignBottom \\| Qt.AlignCenter |\n| BOTTOMLEFT | | Qt.AlignBottom \\| Qt.AlignLeft |\n| BOTTOMRIGHT | | Qt.AlignBottom \\| Qt.AlignRight |\n\n#### Align_Text\n\nAlign_Text is an enumerated type that aligns text using style sheet type \ndeclaration (Some controls will remap to [Align](#align) types)\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------|-------------------|\n | LEFT | | text-align:left |\n| CENTER | | text-align:center |\n| RIGHT | | text-align:right |\n| TOP | | text-align:top |\n| BOTTOM | | text-align:bottom |\n\n### Char_Pixel_Size\n\nChar_Pixel_Size is a helper class that stores the width and height values in \npixels \n\n| **Property** | **Description** | **Type** |\n|--------------|------------------|----------|\n| height | Height in pixels | int |\n| } width | Width in pixels | int |\n\n#### Combo_Data\n\nCombo_Data is a helper class used to store data sourced from combo box items\n\n| **Property** | **Description** | **Type** |\n|--------------|--------------------------------------|--------------------------------------------------------------------|\n| display | Text displayed in dropdown row | str |\n| data | user data held in dropdown row | str, int, float, bytes, bool, None |\n| index | Row index of data item | int >= 0 |\n| user_data | Data stored by user in dropdown row | None , str, int , float , bytes , bool , tuple , list , dict, None |\n\n#### Col_Def\n\nCol_Def is a helper class used to set the column attributes of grid controls. All attributes are mandatory.\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------------------------------------------------------------------------------------|----------|\n| checkable | The column rows have a check-box if True, Otherwise no checkbox is displayed | bool |\n| editable | The column rows can be edited if True, Otherwise the column rows can not be edited | bool |\n| label | the label displayed in the columns first row denoting the column name | str |\n| tag | The application name for the column | str |\n| width | The width of the column in chars if GUI control argument pixel_unit is True, Otherwise pixels | int > 0 |\n\n#### Combo_Item\n\nCombo_Item is a helper class used to set combo box items. All attributes are mandatory.\n\n| **Property** | **Description** | **Type** |\n|--------------|----------------------------------------|--------------------------------------------------------------------|\n| display | Text displayed in dropdown row | str |\n| data | user data held in dropdown row | str, int, float, bytes, bool, None |\n| icon | The icon image displayed on the button | str [File Name]<br/>,QIcon,QPixmap, None |\n| user_data | Data stored by user in dropdown row | None , str, int , float , bytes , bool , tuple , list , dict, None |\n\n#### Coords\nCoords is a helper class used by [Image](#image) helper classes to represent co-ordinates\n\n**Properties**\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------------------------------------|----------|\n| top | Top position in pixels | NUMBER |\n| left | Left position in pixels | NUMBER |\n| height | Height in pixels | NUMBER |\n| width | Width in pixels | NUMBER |\n| area | Calculates the area of the Coords | NUMBER |\n| perimeter | Calculates the perimeter length of the Coords | NUMBER |\n| diagonal | Calculates the diagonal length of the Coords | NUMBER |\n\n\n **Methods**\n\n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|-------------|----------------------------------------------------------------------------|--------------|\n| overlaps | | bool | True if another set of Coords overlaps this set of Coords, Otherwise False | |\n| | other_cords | Coords | The other set of coordinates to check for overlap | \u274c |\n| | overlap_ratio | float (0.3) | The ratio to determine overlapping. 0 - No overlap to 1 - Complete overlap | \u2713|\n\n### CSV_File_Def\nCSV_File_Def is a helper class used by the [Combobox](#combobox) to load a csv file.\n\n | **Property** | **Description** | **Type** | **Optional** |\n |---------------|-------------------------------------------------|-------------|--------------|\n | data_index | The column in the file to load into user data | int (1) | \u2713 |\n | delimiter | CSV file field separator | str (\",\") | \u2713 |\n | file_name | The path to the CSV file | str | \u274c |\n | ignore_header | Set True if the CSV file has a header row | bool (true) | \u2713 |\n | line_start | The line in the file to start loading data from | int (1) | \u2713 |\n | select_text | The text to select after load | str (\") | \u2713 |\n | text_index | The column in the CSV file to load into display | int (1) | \u2713 |\n\n\n### Date_Tuple\nDate_Tuple is a helper class used by [Dateedit](#dateedit) to store the date. \nBasic date validation checks are done.\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------|----------|\n| year | The year | int |\n| month | The month | int |\n| day | The day | int |\n\n#### Font\n\nFont is a helper class that defines the [font](#font) properties, utilised in \nfont related arguments in GUI control definitions.\n\nColours are checked to ensure they are valid and will raise an assertion error \nif they are not. \n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------------------|--------------------------------------|\n| backcolor | Background colour | str (\"\") |\n| forecolor | Foreground colour | str (\"\") |\n| font_name | The font name | str (\"\") |\n| selectback | Selection background colour | str (\"\") |\n| selectfore | Selection foreground colour | str (\"\") |\n| size | The font point size | int (10) |\n| style | The font style | [Font_Style](#font_style) (NORMAL) |\n| weight | The font weight | [Font_Weight](#font_weight) (NORMAL) |\n\n#### Font_Style\nFont_Style is an enumerated type that defines the style of the [font](#font)\n\n| **Property** | **Description** | **Type** |\n|--------------|-------------------------------|--------------------|\n| NORMAL | Font has no special features | QFont.StyleNormal |\n| ITALIC | Defines font as italic style | QFont.StyleItalic |\n| OBLIQUE | Defines font as oblique style | QFont.StyleOblique |\n\n#### Font_Weight\nFont_Weight is an enumerated that defines the weight of the [font](#font)\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------------------------------------------|------------|\n| BLACK | Defines the font as black | Enumerated |\n| BOLD | Defines the font as bold | Enumerated |\n| DEMIBOLD | Defines the font as demibold | Enumerated |\n| EXTRABOLD | Defines the font as extra bold | Enumerated |\n| EXTRALIGHT | Defines the font as extra light | Enumerated |\n| LIGHT | Defines the font as light | Enumerated |\n| MEDIUM | Defines the font as medium | Enumerated |\n| NORMAL | Defines the font as normal with no special features | Enumerated |\n| THIN | Defines the font as thin | Enumerated |\n\n#### Frame\nFrane is an enumerated type that defines the frame of a GUI control where supported\n\n| **Property** | **Description** | **Type** |\n|--------------|-----------------|-------------------|\n| PLAIN | A flat frame | qtW.QFrame.Plain |\n| RAISED | A raised frame | qtW.QFrame.Raised |\n| SUNKEN | A sunken frame | qtW.QFrame.Sunken |\n\n#### Frame_Style\nFrame_Style is an enumerated type that defines the frame of a GUI control where supported\n\n| **Property** | **Description** | **Type** |\n|--------------|-------------------------|------------------------|\n| BOX | A box frame | qtW.QFrame.Box |\n| PANEL | A panel frame | qtW.QFrame.Panel |\n| HLINE | A horizontal line frame | qtW.QFrame.HLine |\n| NONE | No frame | qtW.QFrame.NoFrame |\n| VLINE | A vertical line frame | qtW.QFrame.VLine |\n| WPANEL | A window panel frame | qtW.QFrame.WinPanel |\n| STYLED | A Styled panel frame | qtW.QFrame.StyledPanel |\n\n### Grid_Item\nGrid_Item is a helper class used by [Grid](#grid) to store row information\n\n| **Property** | **Description** | **Type** |\n|---------------|-------------------------------------|----------|\n| row_index | The row index | int |\n| col_index | The column index | int |\n| tag | The tag of the row/col | str |\n| current_value | The existing value in the row/col | any |\n| user_data | The user data stored in the row/col | any |\n\n### Overlap_Rect\nOverlap_Rect is a helper class used by [Image](#image) to represent the overlapping\nof two rectangles\n\n| **Property** | **Description** | **Type** |\n|--------------|--------------------------|-------------------|\n| a_rect_id | Rectangle A Id | str |\n| a_coords | Rectangle A Co-ordinates | [Coords](#coords) |\n| b_rect_id | Rectangle B Id | str |\n| b_coords | Rectangle B Co-Ordinates | [Coords](#coords) |\n\n### Rect_Changed\nRect_Changed is a helper class used by [Image](#image) to represent a changed rectangle\n\n| **Property** | **Description** | **Type** |\n|--------------|------------------------|-------------------|\n| rect_id | Rectangle Id | str |\n| coords | Rectangle Co-ordinates | [Coords](#coords) |\n\n### Rect_Cords\n \n Rect_Cords is a helper class used by [Image](#image) to represent a rectangle\n\n\n| **Property** | **Description** | **Type** |\n|--------------|-------------------------|-------------------|\n| rect_id | Rectangle Id | str |\n| coords | Rectangle co-ordinates | [Coords](#coords) | \n| left | Left position in pixels | int |\n| top | Top position in pixels | int |\n| width | Width in pixels | int |\n| height | Height in pixels | int |\n\n### Sys_Events\n \nA Sys_Event is the enumerated type assigned to the [Action](#action) event\nproperty that reflects the type of GUI event that was triggered.\n\n\n| **Property** | **Description** | **Type** |\n|---------------------|------------------------------------------------------------|----------|\n| APPINIT | The application is being initialised | int = 0 |\n| APPPOSTINIT | The application just finished initialising | int = 1 |\n| APPCLOSED | The application is being closed | int = 2 |\n| APPEXIT | The application is exiting | int = 3 |\n| ACTIVATED | The widget has been activated | int = 5 |\n| BADINPUT | The input is not valid | int = 4 |\n| CHANGED | The widget has changed | int = 6 |\n| CLEAR_TYPING_BUFFER | A [Grid](#grid) widget is about to clear the typing buffer | int = 7 |\n| CLICKED | The widget has been clicked | int = 8 |\n| COLLAPSED | A node has been collapsed | int = 9 |\n| CLOSED | The widget has been closed | int = 10 |\n| CURSORCHANGED | The cursor has changed | int = 11 |\n| DATECHANGED | The date has changed | int = 12 |\n| EDITCHANGED | The text has changed | int = 13 |\n| ENTERED | The widget has been entered | int = 14 |\n| EXPANDED | A node has been expanded | int = 15 |\n| DOUBLECLICKED | The widget has been double-clicked | int = 16 |\n| FOCUSIN | The widget has gained focus | int = 17 |\n| FOCUSOUT | The widget has lost focus | int = 18 |\n| GROUPINIT | The group has been initialised | int = 19 |\n| HIGHLIGHTED | The widget has been highlighted | int = 20 |\n| INDEXCHANGED | The index has changed | int = 21 |\n| MAXCHARS | The maximum number of characters has been reached | int = 22 |\n| MENUCLICKED | The menu has been clicked | int = 23 |\n| MOVED | A control generated a moved event | int = 24 |\n| PRESSED | The widget has been pressed | int = 25 |\n| RELEASED | The widget has been released | int = 26 |\n| POPUP | The popup has been shown | int = 27 |\n| POPCAL | The popup calendar has been shown | int = 28 |\n| POSTINIT | The post init event has been triggered | int = 29 |\n| SCROLLH | The horizontal scroll bar has been moved | int = 30 |\n| SCROLLV | The vertical scroll bar has been moved | int = 31 |\n| SELECTIONCHANGED | The selection has changed | int = 32 |\n| TEXTCHANGED | The text has changed | int = 33 |\n| TEXTEDIT | The text has been edited | int = 34 |\n| TIMECHANGED | The time has changed | int = 35 |\n| TOGGLED | The widget has been toggled | int = 36 |\n| TRIGGERED | The widged has triggered | int = 37 |\n| WINDOWCLOSED | The window has been closed | int = 38 |\n| WINDOWOPEN | The window has been opened | int = 39 |\n| WINDOWPOSTOPEN | Triggered after the window has been opened | int = 40 |\n| CUSTOM | Where the user wants to hotwire an event for their own use | int = 41 |\n\n### Time_Struct\nTime_Struct is a helper class used by [Timeedit](#timeedit) to return Time information\n \n| **Method** | **Arguments** | **Type** | **Description** | **Optional** |\n|------------|---------------|----------|----------------------|--------------|\n| hour | | int | Get the hour | |\n| hour | | None | Set the hour | |\n| | value | int | The hour | \u274c |\n| min | | int | Get the minute | |\n| msec | | int | Get the milliseconds | |\n| msec | | None | Set the milliseconds | |\n| | value | int | The milliseconds | \u274c |\n| sec | | int | Get the second | |\n| sec | | None | Set the second | |\n| | value | int | The seconds | \u274c |\n\n\n#### Widget_Frame\n Widget_Frame is a helper class that defines the style of the frame around a widget\n\n| **Property** | **Description** | **Type** |\n|---------------|-----------------|-----------------------------|\n| frame | | [Frame](#frame) |\n| frame_style | | [Frame_Style](#frame_style) |\n| line_width | | int =3 |\n| midline_width | | int = 0 |\n\n\n\n\n\n# TO BE CONTINUED....\n",
"bugtrack_url": null,
"license": "GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> 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. <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year> <name of author> 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 <https://www.gnu.org/licenses/>. 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: <program> Copyright (C) <year> <name of author> 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 <https://www.gnu.org/licenses/>. 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 <https://www.gnu.org/licenses/why-not-lgpl.html>. ",
"summary": "A Simple Python Declarative User Interface Wrapper Around Pyside6",
"version": "1.0.2",
"project_urls": {
"Documentation": "https://github.com/David-Worboys/QTPYGUI/blob/master/README.md",
"Homepage": "https://github.com/David-Worboys/QTPYGUI",
"Issues": "https://github.com/David-Worboys/QTPYGUI/issues",
"Repository": "https://github.com/David-Worboys/QTPYGUI"
},
"split_keywords": [
"pypi",
" cicd",
" pyside6",
" ui",
" gui",
" qt",
" qtpygui",
" declarative",
" wrapper",
" user-interface",
" qt-bindings",
" python-qt",
" gui-framework",
" ui-library",
" pyside6-wrapper",
" pyside"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "4c7f37fafe3b69a073725ee73f75b3ba7e147aadebdc37be430cf588ba251bc4",
"md5": "74b8e22835b181299bdba530caaad9bb",
"sha256": "e7e1cac0dbdb9f6a3b3cd82d60fb72d11dc2e4d693f38ecbcb79ac71c2eb5052"
},
"downloads": -1,
"filename": "QTPYGUI-1.0.2-py3-none-any.whl",
"has_sig": false,
"md5_digest": "74b8e22835b181299bdba530caaad9bb",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 1116098,
"upload_time": "2024-05-25T23:02:23",
"upload_time_iso_8601": "2024-05-25T23:02:23.778767Z",
"url": "https://files.pythonhosted.org/packages/4c/7f/37fafe3b69a073725ee73f75b3ba7e147aadebdc37be430cf588ba251bc4/QTPYGUI-1.0.2-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-05-25 23:02:23",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "David-Worboys",
"github_project": "QTPYGUI",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [],
"lcname": "qtpygui"
}
