pax_global_header00006660000000000000000000000064150300613660014512gustar00rootroot0000000000000052 comment=b9b8c343f398ee623ee966e584ed515d8f844212 slop-7.7/000077500000000000000000000000001503006136600123445ustar00rootroot00000000000000slop-7.7/.gitignore000066400000000000000000000001631503006136600143340ustar00rootroot00000000000000CMakeCache.txt CMakeFiles/ Makefile bin/ cmake_install.cmake libslopy.so .vscode libslopy.so* install_manifest.txt slop-7.7/CMakeLists.txt000066400000000000000000000077121503006136600151130ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.5.0) project(slop VERSION 7.7 LANGUAGES CXX) set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)") if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "..." FORCE) endif() include(GNUInstallDirs) set( BUILD_SHARED_LIBS ON CACHE BOOL "Build all libraries as shared" ) # This should really never be disabled. The pure-X mode of slop is very expensive and buggy. # It also doesn't work on Wayland. Though if a system is never running a compositor, or # doesn't have OpenGL, this could remove some linking dependencies I suppose. set( SLOP_OPENGL TRUE CACHE BOOL "To enable or disable OpenGL support." ) if ( SLOP_OPENGL ) add_definitions(-DSLOP_OPENGL="True") set(OpenGL_GL_PREFERENCE "GLVND") endif() set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/") include_directories("${PROJECT_BINARY_DIR}") add_definitions(-DSLOP_VERSION="v${PROJECT_VERSION}") # The names have to be unique unfortunately. set(EXECUTABLE_NAME "slop") set(LIBRARY_NAME "slopy") add_library(${LIBRARY_NAME} src/mouse.cpp src/keyboard.cpp src/x.cpp src/slopstates.cpp src/resource.cpp src/slop.cpp src/rectangle.cpp src/xshaperectangle.cpp) set_target_properties(${LIBRARY_NAME} PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION}) if ( SLOP_OPENGL ) target_sources(${LIBRARY_NAME} PRIVATE src/shader.cpp src/window.cpp src/framebuffer.cpp src/glrectangle.cpp) endif() set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD 17) set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_EXTENSIONS OFF) add_executable(${EXECUTABLE_NAME} src/main.cpp) set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD 17) set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_EXTENSIONS OFF) set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" ) find_package(GLM REQUIRED) find_package(X11 REQUIRED) find_package(XExt REQUIRED) if ( SLOP_OPENGL ) find_package(GLEW REQUIRED) find_package(OpenGL REQUIRED) find_package(GLX REQUIRED) find_package(XRender REQUIRED) # Ahhhh, finally this eliminates the segfault on preload. find_package(Threads REQUIRED) endif() include_directories(${X11_INCLUDE_DIR} ${GLM_INCLUDE_DIR} ${GLX_INCLUDE_DIR}) target_link_libraries(${LIBRARY_NAME} ${X11_LIBRARIES} ${GLM_LIBRARIES} ${XEXT_LIBRARIES}) if ( SLOP_OPENGL ) include_directories( ${XEXT_INCLUDE_DIR} GLEW::GLEW ${XRENDER_INCLUDE_DIR} ${OPENGL_INCLUDE_DIR} ) target_link_libraries(${LIBRARY_NAME} ${OPENGL_LIBRARIES} ${XRENDER_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${GLX_LIBRARY} GLEW::GLEW) endif() target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME} ) if( CMAKE<3.7 ) message( WARNING "CMake version is below 3.7, CMake version >= 3.7 is required for unicode support." ) else() find_package(ICU COMPONENTS uc) set( SLOP_UNICODE TRUE CACHE BOOL "To enable or disable unicode support." ) if ( SLOP_UNICODE AND ICU_FOUND ) add_definitions(-DCXXOPTS_USE_UNICODE) include_directories( ${ICU_INCLUDE_DIR} ) target_link_libraries(${EXECUTABLE_NAME} ${ICU_UC_LIBRARIES} ) endif() endif() install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_BINDIR}" ) install( TARGETS ${LIBRARY_NAME} DESTINATION "${CMAKE_INSTALL_LIBDIR}" ) install( FILES ${CMAKE_SOURCE_DIR}/src/slop.hpp DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" COMPONENT development ) install( FILES ${CMAKE_SOURCE_DIR}/slop.1 DESTINATION "${CMAKE_INSTALL_MANDIR}/man1" COMPONENT doc ) slop-7.7/COPYING000066400000000000000000001045131503006136600134030ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . slop-7.7/README.md000066400000000000000000000155611503006136600136330ustar00rootroot00000000000000# slop slop (Select Operation) is an application that queries for a selection from the user and prints the region to stdout. ## Features * Hovering over a window will cause a selection rectangle to appear over it. * Clicking on a window makes slop return the dimensions of the window, and it's ID. * OpenGL accelerated graphics where possible. * Supports simple arguments: * Change selection rectangle border size. * Select X display. * Set padding size. * Force window, or pixel selections with the tolerance flag. * Set the color of the selection rectangles to match your theme! (Even supports transparency!) * Remove window decorations from selections. * Supports custom programmable shaders. * Move started selection by holding down the space bar. ## Practical Applications slop can be used to create a video recording script in only three lines of code. ```bash #!/bin/bash slop=$(slop -f "%x %y %w %h %g %i") || exit 1 read -r X Y W H G ID <<< $slop ffmpeg -f x11grab -s "$W"x"$H" -i :0.0+$X,$Y -f alsa -i pulse ~/myfile.webm ``` You can also take images using imagemagick like so: ```bash #!/bin/bash slop=$(slop -f "%g") || exit 1 read -r G <<< $slop import -window root -crop $G ~/myimage.png ``` Furthermore, if you are adventurous, you can create a simple script to copy things from an image itself, unselectable pdf, or just VERY quick rectangular selection or for places where there is no columnar selection (very useful for dataoperators) You need to have tesseract with support for the specific language, xclip and others are nice if you just want them in clipboard. ```bash #!/bin/env bash imagefile="/tmp/sloppy.$RANDOM.png" text="/tmp/translation" echo "$imagefile" slop=$(slop -f "%g") || exit 1 read -r G <<< $slop import -window root -crop $G $imagefile tesseract $imagefile $text 2>/dev/null cat $text".txt" | xclip -selection c ``` ![GIF Example of tesseract](https://media.giphy.com/media/fYP0sFWaB0XUEcYDoI/giphy.gif) If you don't like ImageMagick's import: Check out [maim](https://github.com/naelstrof/maim) for a better screenshot utility. ## Lets see some action Ok. Here's a comparison between 'scrot -s's selection and slop's: ![scrotbad](scrotbad.png) ![slopgood](slopgood.png) You can see scrot leaves garbage lines over the things you're trying to screenshot! While slop not only looks nicer, it's impossible for it to end up in screenshots or recordings because it waits for DestroyNotify events before completely shutting down. Only after the window is completely destroyed can anything take a screenshot. ## how to install ### Install using your Package Manager (Preferred) * [Arch Linux: extra/slop](https://www.archlinux.org/packages/extra/x86_64/slop/) * [Void Linux: slop](https://github.com/void-linux/void-packages/blob/master/srcpkgs/slop/template) * [FreeBSD: x11/slop](http://www.freshports.org/x11/slop/) * [NetBSD: x11/slop](http://pkgsrc.se/x11/slop) * [OpenBSD: graphics/slop](https://openports.pl/path/graphics/slop) * [Gentoo: x11-misc/slop](https://packages.gentoo.org/packages/x11-misc/slop) * [NixOS: slop](https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/misc/slop/default.nix) * [GNU Guix: slop](https://www.gnu.org/software/guix/packages/#slop) * [Debian: slop](https://packages.debian.org/sid/slop) * [Ubuntu: slop](https://packages.ubuntu.com/slop) * [Fedora: slop](https://src.fedoraproject.org/rpms/slop) * [Red Hat Enterprise Linux (via EPEL): slop](https://src.fedoraproject.org/rpms/slop) * [CentOS Stream and similar (via EPEL): slop](https://src.fedoraproject.org/rpms/slop) * [Ravenports: slop](http://www.ravenports.com/catalog/bucket_CB/slop/standard/) * [Alpine Linux: community/slop](https://pkgs.alpinelinux.org/package/edge/community/x86_64/slop) * Please make a package for slop on your favorite system, and make a pull request to add it to this list. ### Install using CMake (Requires CMake) *Note: Dependencies should be installed first: libxext, glew, and glm.* ```bash git clone https://github.com/naelstrof/slop.git cd slop cmake -DCMAKE_INSTALL_PREFIX="/usr" ./ make && sudo make install ``` ### Shaders Slop allows for chained post-processing shaders. Shaders are written in a language called GLSL, and have access to the following data from slop: | GLSL Name | Data Type | Bound to | | ---------- | -------------- | ----------------------------------------------------------------------------------------------- | | mouse | vec2 | The mouse position on the screen. | | desktop | sampler2D | An upside-down snapshot of the desktop, this doesn't update as the screen changes. | | texture | sampler2D | The current pixel values of slop's frame buffer. Usually just contains the selection rectangle. | | screenSize | vec2 | The dimensions of the screen, where the x value is the width. | | position | vec2 attribute | This contains the vertex data for the rectangle. Only contains (0,0), (1,0), (1,1), and (0,1). | | uv | vec2 attribute | Same as the position, this contians the UV information of each vertex. | The desktop texture is upside-down because flipping it would cost valuable time. Shaders must be placed in your `${XDG_CONFIG_HOME}/slop` directory, where *XDG_CONFIG_HOME* is typically `~/.config/`. This folder won't exist unless you make it yourself. Shaders are loaded from the `--shader` flag in slop. They are delimited by commas, and rendered in order from left to right. This way you can combine multiple shaders for interesting effects! For example, `slop -rblur1,wiggle` would load `~/.config/slop/blur1{.frag,.vert}` and `~/.config/slop/wiggle{.frag,.vert}`. Then render the selection rectangle twice, each time accumulating the changes from the different shaders. Enough chatting about it though, here's some example shaders you can copy from [shaderexamples](https://github.com/naelstrof/slop/tree/master/shaderexamples) to `~/.config/slop` to try out! The files listed to the right of the `|` are the required files for the command to the left to work correctly. * `slop -r blur1,blur2 -b 100` | `~/.config/slop/{blur1,blur2}{.frag,.vert}` ![slop blur](https://my.mixtape.moe/bvsrzr.png) * `slop -r wiggle -b 10` | `~/.config/slop/wiggle{.frag,.vert}` ![slop animation](http://i.giphy.com/12vjSbFZ0CWDW8.gif) And all together now... * `slop -r blur1,blur2,wiggle -b 50 -c 1,1,1` | `~/.config/slop/{blur1,blur2,wiggle}{.frag,.vert}` ![slop animation](http://i.giphy.com/kfBLafeJfLs2Y.gif) Finally here's an example of a magnifying glass. * `slop -r crosshair` | `~/.config/slop/crosshair{.frag,.vert}` ![slop animation](http://i.giphy.com/2xy0fC2LOFQfm.gif) It's fairly easy to adjust how the shaders work by editing them with your favourite text editor. Or even make your own! slop-7.7/license.txt000066400000000000000000000013171503006136600145310ustar00rootroot00000000000000Copyright (C) 2014 Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors) 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 . slop-7.7/modules/000077500000000000000000000000001503006136600140145ustar00rootroot00000000000000slop-7.7/modules/FindGLM.cmake000066400000000000000000000022171503006136600162400ustar00rootroot00000000000000# # Find GLM # # Try to find GLM : OpenGL Mathematics. # This module defines # - GLM_INCLUDE_DIRS # - GLM_FOUND # # The following variables can be set as arguments for the module. # - GLM_ROOT_DIR : Root library directory of GLM # # References: # - https://github.com/Groovounet/glm/blob/master/util/FindGLM.cmake # - https://bitbucket.org/alfonse/gltut/src/28636298c1c0/glm-0.9.0.7/FindGLM.cmake # # Additional modules include(FindPackageHandleStandardArgs) if (WIN32) # Find include files find_path( GLM_INCLUDE_DIR NAMES glm/glm.hpp PATHS $ENV{PROGRAMFILES}/include ${GLM_ROOT_DIR}/include DOC "The directory where glm/glm.hpp resides") else() # Find include files find_path( GLM_INCLUDE_DIR NAMES glm/glm.hpp PATHS /usr/include /usr/local/include /sw/include /opt/local/include ${GLM_ROOT_DIR}/include DOC "The directory where glm/glm.hpp resides") endif() # Handle REQUIRD argument, define *_FOUND variable find_package_handle_standard_args(GLM DEFAULT_MSG GLM_INCLUDE_DIR) # Define GLM_INCLUDE_DIRS if (GLM_FOUND) set(GLM_INCLUDE_DIRS ${GLM_INCLUDE_DIR}) endif() # Hide some variables mark_as_advanced(GLM_INCLUDE_DIR) slop-7.7/modules/FindGLX.cmake000066400000000000000000000024421503006136600162530ustar00rootroot00000000000000# Try to find GLX. Once done, this will define: # # GLX_FOUND - variable which returns the result of the search # GLX_INCLUDE_DIRS - list of include directories # GLX_LIBRARIES - options for the linker #============================================================================= # Copyright 2012 Benjamin Eikel # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) find_package(PkgConfig) pkg_check_modules(PC_GLX QUIET glx) find_path(GLX_INCLUDE_DIR GL/glx.h HINTS ${PC_GLX_INCLUDEDIR} ${PC_GLX_INCLUDE_DIRS} ) find_library(GLX_LIBRARY GL HINTS ${PC_GLX_LIBDIR} ${PC_GLX_LIBRARY_DIRS} ) set(GLX_INCLUDE_DIRS ${GLX_INCLUDE_DIR}) set(GLX_LIBRARIES ${GLX_LIBRARY}) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(GLX DEFAULT_MSG GLX_INCLUDE_DIR GLX_LIBRARY ) mark_as_advanced( GLX_INCLUDE_DIR GLX_LIBRARY ) slop-7.7/modules/FindXExt.cmake000066400000000000000000000014461503006136600165140ustar00rootroot00000000000000# - Find XExt # Find the XExtension libraries (WARNING: It's geared and tested specifically for the XShape extension though) # # This module defines the following variables: # XEXT_FOUND - 1 if XEXT_INCLUDE_DIR & XEXT_LIBRARY are found, 0 otherwise # XEXT_INCLUDE_DIR - where to find Xlib.h, etc. # XEXT_LIBRARY - the X11 library # find_path( XEXT_INCLUDE_DIR NAMES X11/extensions/shape.h PATH_SUFFIXES X11/extensions DOC "The XExtension include directory" ) find_library( XEXT_LIBRARY NAMES Xext PATHS /usr/lib /lib DOC "The XExtension library" ) if( XEXT_INCLUDE_DIR AND XEXT_LIBRARY ) set( XEXT_FOUND 1 ) else() set( XEXT_FOUND 0 ) endif() mark_as_advanced( XEXT_INCLUDE_DIR XEXT_LIBRARY ) slop-7.7/modules/FindXRender.cmake000066400000000000000000000032721503006136600171720ustar00rootroot00000000000000# - Find XRender # Find the XRender libraries # # This module defines the following variables: # XRENDER_FOUND - true if XRENDER_INCLUDE_DIR & XRENDER_LIBRARY are found # XRENDER_LIBRARIES - Set when Xrender_LIBRARY is found # XRENDER_INCLUDE_DIRS - Set when Xrender_INCLUDE_DIR is found # # XRENDER_INCLUDE_DIR - where to find Xrender.h, etc. # XRENDER_LIBRARY - the Xrender library # #============================================================================= # Copyright 2013 Corey Clayton # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. #============================================================================= find_path(XRENDER_INCLUDE_DIR NAMES X11/extensions/Xrender.h PATHS /opt/X11/include DOC "The Xrender include directory") find_library(XRENDER_LIBRARY NAMES Xrender PATHS /opt/X11/lib DOC "The Xrender library") include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(XRender DEFAULT_MSG XRENDER_LIBRARY XRENDER_INCLUDE_DIR) if(XRENDER_FOUND) set(XRENDER_LIBRARIES ${XRENDER_LIBRARY}) set(XRENDER_INCLUDE_DIRS ${XRENDER_INCLUDE_DIR}) endif() mark_as_advanced(XRENDER_INCLUDE_DIR XRENDER_LIBRARY) slop-7.7/scrotbad.png000066400000000000000000002147461503006136600146710ustar00rootroot00000000000000PNG  IHDRsJsBITO IDATx^-IUݹ{nafI$$( (Fȧ|Ӈ~$ 'Y``fwfn{s$p9oUkZUjUƓq^' u_vk[mw=sht0l;IEaV'Q_m''w[-cd, p]/~? ǁ㙦&qgae0mE`;eIƢHvՊaB4t-kRde-wNpL(r۰0M۶`pb[iZi-@}>vU>mJs2'i ?A5\LmÉiU :d,[kpƱyX;Vfh ڔݵ(< ڭ$ +CΫ"͓(3S qEc;adu+4ܶ]mJ:$l׆vn\;l9nphEmI/Iyp0 ZAE!4O0wf1 :pir:䜳Ɠ8ʭ* qݔ,N8Y^q `TxiFqv, 7jc(I˲"䱓+iXUxy~GITm縹cinjF%a$`<:A]0 hc,J-Kv˛EVkӮ'hkwc:fpZ57 jY0z2;QL3{< 32ߴGa(y,lFagFV{GBoYi>.C\|yfݍqPs \=ܜ$1i'5eg^6u52bx :6vt?=Aex5IkFydcLnAhFku`c׻4lo띞ca.\QS4nȋ[kkiP}l^uScV[jګf8ʲtI83t2 7iOh~dGNzŮ3"G}m$L {.FM $w. cti <7b+tW|DZFaǓfɊ hew\*A~fd^ l -'ts%%N;Va;9·2Zet?:2U1#(KFnЗ$KgG pVo8:,Bӽey=1"$tjVjLB}b ;6QQ-l e2hQ=*Ax2A.3(\.vZȟQ`zEnƀf բs f9l!$ BqZh`V^< #N-A! mdɮw="3BôD^2Ҡqyt)ҁVoY) iI^ipMQE6]oSc*꧱!7xW1)zb4Wl'+Κ!Zئ/c\ˍVdZ:rl: $8|28iv]]J at+e©qnf8 4H{ 6[n[Ĥ:2պ6pǃ%QU>>Iߵ]=fEzFl6K"ݚb`81k?~yf228o h{$KN;Ȍy&E+,Kwn|I qfI F9:Ut`QLm' ;vDb'2(.nڮڃ81 qT[R`>y|L@rzi.&#_(d; 5_t=HZWR$΍C}m8y\|QVz ヸ{=NŀD=b(K쀁Sv۸2ºx#]( L:"bqx2.%c BS>M &06#:V3 c1_xffMGcC׻ NRnU';F1A<--(2񨸎iܘ^&ߧnW{}E Pa]ߖBGaKqFN`GxQ\|,EsbR$bH u9ՇjPE4bVWU{0h뽞c8m qMLbn\\};trK+nҗ f7g`s{= m;۽Nw26#m"h뷶mգFbl-w+MsZaC;Eߧ.zㄦKȨ:Xf"^ lX̎u݈j|i]y6-c3<]=wqaL+-w;C˺v]x69 ՘kۨIaqVQP݁M]aPlz(2wh z/# At^o&8Nc̗ By4"i69pz񸅷+JiƸQ .c *+4U 4A釄R zlh/i(2l;,q:1J1Ej:!AkxkNPx^suWnk7!wMjBatdiD%# :'8VџM6$N,kcM"vFsPkĘF \9N7Dz;ۃ=bO$XÀEPJFſp6,' Az.QI q|#Z挋jw$tB!f,!$o Uץӣ[2 H4ЧvAuxxUV Z_7Iu:X] i$Y7юA2 wtNDNh4jc0I%> V(On7mb6̉zrXEm1?r„Ɖhĺh lq8 QC.﹄Bz,|~GYeM&Mh#qEС=UڇYX5o\$plCˀhwdAs"߰ǃ-蘈Hڭc'N%<(frHVi(E{aóaMca0wS<'f櫆Oyۑ.N¸4ӄjd. v1lдc(WLfvr8=0iw+̑]gVVIzhMl8_ńGoLvC`*M#=A*Ly"fLxDU k1j@@9& 7Q=pp?#>T[+ZV+N}b8 &_ ,4|J_Cs> Њ@~ .L? l8] %N>bD Z`ancCYǔ/_̸Vm66 ɐX-&1fqB"qPc!/J]LSQACTرnWR,C%с %e?n;1ڒ͌S4BˢR-Z%@ڒEnm GLV8﷑30"c2L`PD(l2'{p֘:p|u{{_4G'[whP̙{f҆p@VAawz&|k;#0 n?˒<107&8)s~28L@c1oۡkI;V18FdJM\ću;p5DkEQ r`g>2\L0$P$r(qLV./5b!7 1,C0):,i:LPܫ DJ7 σX T4C־Жb4 3@d`$rJ4܎+X1 l63D{4_<*B<Ǚ{!!vbym %1i8jǹ ^S bdhωobݭwgVC$MO27{ 6݈bS{aʾt,m9Pf 3Z]]ahHBxvYf`ʜ/O\ )jYh:Lgahb3:&@`de gYgwVZ|llaMb9#kL>[c+t&ZK( DdNvZ~4]`#pr.1e=;Т d\E(Lb:_bpn,.~8^ )%"`Y0*2D3Z&ZhT<}G= #)^xGDH=L>рd!dt;)ÇWmFrۙS*z3#],Z?-'[JU3~/_Jwe ]Q)Hv .*O"S45JG-E8m./eM sc{ (fe2n/rCbjEh]7&LKkAM()Txm|7Z,c81l.1bዙ`u#vpb2`c/",k+O8Qnq+1bY9ckzqX'm3F%cjvS0.Ca0Di ŨV|90h%â?R"6,rqT7mgG(8BuAkO%ъHZ:ip6$r4ڑeku7iM$nm g\D+++񱓇EEfauN bQr$:s#hQ8a L{U.l'l=ڏ!f,СˎݎY7̽sU-d[7aKq$O{b pʚ(_# e!;}q /%dûƕ#8ʺHF7rx0B1W]1`Fm3]>bhżGfA-wp_>{x 00aسw됱tĕYiӞ$F 7 Ĝ=+<‰%S2m"n k'88uzdž$-Oj4;wךחe`8di?4c&Px?e{w IDATAeG-UCb:6n;({di 7flULo7br SŹqfX2V8d/鈓n6 ӉmmvZWH0;̲6aIF&% ^f4](:YjΤ g `Ram074xkDMMN&B*q*p0|(N6Is̔ %"ު'b)N \bDYKNo>Kmf6ŲX!Oi$@B324 d2E^76;M7ݝvT]ĽaNV,g]*_sSj*)UEK%ղ@;YlnKU BKrL ZJW c:c";"pʽ(tBQZXgR7IwK@%^(0!*vꖧk ҢhL:NG)%J( Q(Ig-̴oSqƷh \pP$NDK% uήSz4ɩ%񚇺k*}"Vi~U ͚J O3UieJMZn02!aGtJ>J@+F!ɣNqZ+,+< AݨJVȢjY>*|5h :QJ!4P40OJ NTG&(G SB Ҷ呰#RR>tyLCUSU}CIPVq̘7)Jr+f~+ e]ƲU)Y׈JH#ά41>v#Vɜu$@A Ŭo{Qƞ+]ckWqS6(RZ-(@R߰Ow)Vr*Rʬ5Joԓ"u\ִ[kͽz"k &L&(QWR:`2k ռ©2+r;_?|O24X 8? 5'%ySOHNщZ eש'3຤ƒZ\7aQ^+JZ% T(i˟*2lMG\*N_U oGc,1N1lLy*8 kHL>)B$Jmk+~2K]`Y+!ߚ/ IB%UKhLԹf&wE}\3U ayZIQKW2SaeG..uA.jX Q_,T>e)tNŸj|G{&^*E]I^eE(, UWB[V.K T> -ܪJ)۪P%X9ͲhNU\)`v<+¡~桬d/Xש5}U|R.YcgF(,_ <5GhH*L U)uW;F'ytm5FoUd] +hD.e ^Z'Ox}ŲdUNYjV:B"-#\(S?(4j Ϊ.teBh@AR"/Juฤِ̠S%e[\0)[^NZP,Ur⚺ruyUeя QV"M)2ߔkI(Ju)pEVPT%BQ*YQ3Ԕ0GZeK @x/=$( UyДU!|Wi}Dspo&#Nc$ zhwU˒ t[YZ_YɦDֻ(˓R%Mսդ^N)Q K* `+:Aj$i$haX* OI'9oŎ^5kt Bu14PC R13h[͹Ux%?v0SiL,ʪ*@K0*z*¦FӔz4$K)"?S;f#JRU)|u*S= .n*Ƥ[Ϳ˔MߔH"Jfz))YuRš1EUA*ETBVEը8 !BriihrU@ۙk;TkO@UOԺ(S=9$ؔmrR̾c,^3d%1KݓDL#T?Rm܀ә+JT;؁TUCUWnRmNէDjGi% a@VaI3X3 :Z%R,5StemTB|jbҏ`nbE()iŽn:]*I7F)Ds`2K]F v-5iU3EBB@JBRNEw3yxYQ颤VXuJJ@zl]S eծ2Lie@^ՀuV)Y[9€AW͗JB)x.m.m)kU+Ơ俲+ ՜$Uؙ2Jo^)5kH7F;fPyhK?x{|=^uqir ޯ^z7 %2ytN;N2]>fGqD29IeG03N3~"GJM;B(-SAn>yuEY+W3CѨZՌIzKK^\fɸo<(b%=Ze<)d|[aH4Y(՟ ._DqE+ۅ B)-s(xQ:Q`o`MhPe{XV=udyߊbW,UXuY4.nPf"٫R DaybөM6kf9\],gV ?[ƔpSVWib(WW\0tzɵN 2״.Q]ZAcI4|E^p5ͤd_MHP,&$hRiu?)W Y|Pe+FI ^_?>3ڍ[r^GŎʐX2UAa8ׁVrH*{?9rs;a9*_]:Le3MUkթvZ)R-P䷮چ!!Kx]ke7 ް隖d4H˖`3xtب=DZNXVdɨjU 5X+FDr+hUYi IJS4Ff1UjMY S):\ʇwh f푤KFgfD(wE(U/k I1qk:m} .t,#O*є{NsE-a:}@ ղ.,sveڍ,klǍ}RUN3kx@wtl; h5I-~k٪Ep:k޿bR6*)RZ:ʢ0+J0VL |y)Z5{ w>]G)B^%~+rQ9ḏp!kC~8ubU8_>P.?g.{nBzS4Y)2UsJ;g7U#Ta*m \RE͑ղݍ!ޖMS?6R8Y?3Â{>˯Pi)WY9%fCg[1\9ROpUUŕp9,hRJ_{K@\htNE/TʣLF'_R87rN%?1J4QYJ3ɉ2l6S)4[!Q Xչk JoGy>\v@S~Mn@q;_yǔg+&ܷoXۇxVц$ը.}ĤeM"RPɖazh š5H W4B cS?N֦hU(jN WO\f,Kޔ1;[qħT>[ yQl fqBKC%?gOoln^{^z+O{cYZXyLos'+r9 gs:u*\&R㞗BItύ-EK [jB[ق]} ff KaD;M1N!IBTUajfTBk/ijeJ-]˷dU6iwI1,JP k~Nk>ޟ٘f+hE_4 *V#;/Gv#eƯ{[X#0 c]p&GˉoXa5T\xΗUgs!7m.N +9{ES}{r&o/=n=8YwN3w9gHV tzպjL9M;Ti0!ݬ S-"owh+ޤQf{X<=),&(y37K4Swm݅߸L!ƪ 3<^Uw3uGm\rvaij(Y ̢u"cq 6PsWu{EE݁yQz?M[֬_5eɟ}G͝>_N'C\x|;!gR<O 7퐋nJ|1Ywvy7apD#N]NSBrKp5Bm^u!kfb- ɸSU-R,u HeۊYœwNRl;r7\p)7y;58ޒ;KvP0UuK\jExs2^ARͨn<ށqKoV>NG4WUW\qXO~/&w5p;i :Ӧ`@նEF^>Wz5ަ$sݦZYV>\r9K_od8?N][[{ғtw˱S$'>~[-mӟSȏ>O.w}{_O~_`n݆]t9_SO=y{}'=Ǯۿ_dwS"k'Nʱc/e/{O|~~R`S>77o>?aUZ= 7xP.__GH"u> oxwܤxϊ'fzHUK* ;()eMH~Wӏ;TeCark[P的.`;K_k uJLnaZ5 3V#s4'ѹktbuْx\v}ͅ r5; /59jtu.74=c<ЇB*Uz?S?c>gMo}[S.~ӛބ {#ܝt'_L?(A.gtʯʻn\G=QPѡO{?qW}o4 >,]y['?Q~7/׽jl^Usiׯ(׾?s??7?O~H"??[e60A0s{;ΨE*FL(򗿜S~뷐K^@aHwfַcVzRBug?&&RuTWd)6J-s&($'X&WA͌y|i&6Iz]Aɗ[CTm 7ϓdeg\qUmɄklCrʌ\ OdiR Bl$( Tn,oHC+0t3:'P7 {_1^30se27+_X.L;[56;Ʌw<'E8w10\tPy Uwӑ|.Cb":Y> CKK( 7*NBعضO<^fI3==},5Ї>TEi4ה;yhRo:rtFFڞzai,^w(&tk'j*uj]^7ö9Ou (6)P0MѐR%Ri3lk53*hVlp Xߵm IDATd1s!(wV*Vܗk9؜[Hwr)-iTn7wWcI#h4w8 Wա" aoz&F}Lg;t<` 19ݝPͰ:, !]zC܌ Ȼ' ։JDΫӑ|.+8|x= :!8@F`4ݹˀD" @DLuYk^ANW՚+d}Iq^3)M-.tf$nVL;yQ85ԲNlOl8MN*j[VS36v t'+a hU ֤L~O`Vzn YX ~ۃÊL/zewm̅[v)'?晢jI$\2?~o;Vw?\?  >uȟFf3ktKF5,^5QC6T`ԐU H8O3.>mNd@uu1Cka".W.laf@#XUzЃ5PhLtFЕyCbq3 In)*GtoI^ø` BӯWB n,Pb@ ҸT4/wJH3 yN)OνQ\hG?iO}ag Iʅ_F?z7u:YiϝyFh}cFXh[+}`#p.~_JИ!Faf!BՇ~@*zߖgFwP?'h}?%:GLx穊S3RsTe^W%!͌5f Ʀz{wHzLj {gorf3 VjĦy5 KQ#9MB <'y{9T>O^bQ>̗:)9KEX X<0 j/vƼ L3"Ӭ>=}#vtZQ7|39שfBH5NTӉcy{YGfb냩: 90*կс1Pat? p!(?C9٣4^~, 6*1LebxƆB=moCeW_C dSÇ 17x4y^tM .?ӟٟe,Dzd5=zwWzum jAnP ߫S䚵l) xEeKkm~4 4L<3kt&XgJ0]Mb♕m%dY3iۭĿ(>yN7͕-?ALo=rh[PӖAzSumxi) W5fNbj#twz9({#A2D _ }D~HA0uOBj:]A2&+dMU ъre 5͒VY w;ROU t{F7?eAX,g>چ80Fvg߉;W9\p  ټqBT"  C/&eFP{x^¯thҺ|lFh M`։h 5dt YlU%f՚4)5:oby5j&b.6!&J#؍! n_w~ΨӲT4uYdnu޴w+wl:A+&.7]On:ޘwD犢2h赺_g.)_՝eA:P<56g4ujNyg4si-Ls)?38l 0N՘63*ۙ_l-DˉgdV[;eBhA m"븉,d_9|]b_Jغm-s jJde)" Jح"g Y ̦2qOQMa̸%aGwi[(S'w:FU기kٝ-on`0xHƱ@ˣڮ~Zw}닝DX?[fjֲ0Wvomاős4#X֔+xVi@7X_vc/23vkݫt_9pNسQϻZfq񄑆,M%\DdVl -HP.3n5=Nq;.8MIu=ց'RXl@b샇\q1p&{08\a5T)1,Mf!$Wҙ0;ڽy^Ԑٳ9Wa%i#8VcL6w’;[cg̷b 8&ppaʐ. R] s4S0{S@|׌yXxi~mh>Ck&B[[ג]!x̒o; hVXl-7-8\4|WbpZ}rp\ gQ;Jh4δ8pM7 wwͰ 6pMCN{8-WX(k'q8LGDI\9`?uiu*6X~-1\ӔHۓ,طr#V{;OHZ2Tn(o0pCѵmN%VV:ߞ ӗ)K Lcp;N5;mX$PorxOaE:>+rmNM[G T?xv%/y ݭbGF>ʾ'|)&DWoş>l2lp굗&p\/\z/G>&mKGߞ4G_ya|=wvQE}'wp2åG@2}CEaF-B)-of  .⎙DqU Yp9&Q eS9풫%R V&d!ӊo!kEmWh7^qQ<ãy31hg!<ꭋn.bE\N1Oum!vex}u}ٺ\sqrl1WB.3[=0)OvCS~{wYJN7\Ƿ",Qa 'Ee$ 'c-LȵX8Š`;RS18V>M0_W`}+8oX^dmeW|%? y'&ðb~/kg9'/X738]oDΒ:wŅi.Dhş 1|ȏu^_Ox7P\K ܂F3A|Ga)(ajG_~˕ϬHR(l:Iwm7=l/Iez<1^XFL~^p}sjE?Ug/%/⫟܋:_?˔nZ <~.w޴?nmm-羸0)]ohu8LJ'؎&춻I͓ .gcjQ&Չ{,A=ׁvD/9SO8}/!XJƒn䗾Ezx>onnpen,eqgq wfNB\١=Q咚>WHyxK_zSz2L˰+n'R$C_0bn{˃X>7pl\Wd2Ƭh L,zVuJa8v?M{۹#$4_?Ď |8;J V^K&uC2i0Xx&%RY D>I@sm >=rd7(Ll l/J6E#,5#mObp8Ir+:| "Y$gJm-Y7֍nKɿƶv8̓>Y2G,%@-gQe8k O|k;n\p´){k}Sl??0{G:}3't؎\VSp>y oOoYddX̮?]XeRF8&oG<YَMwW4 ˳G 9L1&k\iss#z٘Udqݺɋƺvd>$9;״83-<g?9Ib(:ź5{W~lž[M |o~ c]G}`g*%R 2~|#}e~:J;¨aw pk[):U2rѧgstr\\eR^ ҂Ӭ{E/ 8o;aD١XVN sVVg-wΔ3 @.fL1 / gL&K]lz0>}&)q~ψxxoc^m&ij= |]( Uy"ͼ'n-9rnX1?w-w:(I`A,LC Ӥ1&5ęY*ב銬s{=-,9W|Ӳ,m5Ÿ{gY]J/Wp7qYX#bخmnAW?uG&G%^DZ<ʢ(~ج$O8C44v:!5mi _^0?Yc~M֋꽫]Δ~R $]{кE^f\J [3L0-N214 h>Ie+Dnpnw)zm|̕ke* ,!6wsFwۥn9zI[4$ Lx\Y'7oj Nc|\zbh;e"<|!N\]}q?0?Gޅ10 ˫ gLd+{{zT5FAqE !ID]GKP DhĘ5 Fey73ʯ IDAT~;(}yof^vuթS=QJ(;vD{?a%e 9RjdqhaXQKӱr=֙eM[pXojU-{5+`xe˗r@ml6dWJ֚083!֖JJ`7'i ~gD69m=qf1wLǚ̅Q4ud_Şs=M58T.եn")2E)42ĩb58p.w{neyOo^:wrr*)0/{;O.*Xmn]D;k6ةN-^UpSH` μcZKK[ G0fu!(FYڼx.A wTe ؁

U ">ş*b0>W|m? j)J5ʨf.2/y:<{[{+dOj$P)TA'CVʹ0ӷk`p |0Hd9w\wՒ僿̴nCX T/!|VCCʟ %UA|58oNSgII -sO}'cZjt5L7}cw8$2Z.e6DP-Uxlʲ6jj#$09+G]F+}+dOY*EIB:Iֺ^1ضA_8hwɉE&*yā4 Ta Hq[-M]YI,8nJdrBA@uۻy0:x/%σl-*(+Ktc"儍>fc`%!87j\UY6Ka%09Qe9v\u%E~&ʦ$a,8,-m.mbt6>MXb[T?v۝9‘e'p·kJVj&(:꨻Yvuu~)gu""Vi*l(pZrmo擰K#1/dGKTVu18ʲ1ec&娲UW29yR%*@jh;l7Lb#La/ vVn˒02,H Qbu{O'69||o=>WSE^QOO>sHӻܷl-/{ *x:/\E􈹯_?86ws/뼔sڤcΒ9q0=67Yhk`M̳o*^_!V\ oy't2n",g)Ywc!RD`›fdګ?S)FxH@Nd7x1Ͻ,[Gnecu0t,-invf.zGQKW;j=[,o-NZ ϼu?s?E}«va~?Rs*,p?^ I2jo㇗N}v+{ٻN>cJ=8 *LQe+o旫rf,Aļ_wy\~zscSY|}/K `\a@廨AZ0s^v:kdb{νaIV'SFU) l w0$- R8kFQc/\iHs$WNdl)( ( lI *Kp'Y\+%D1}˲F(LwaFGu[RfQJJCuA1 ؟;/p@=YtV xSP8$z4Gg"bqF4FVY폆if~ϯqQqڞE=Fjf(aY"B4k44d\p9QFV$xgx;p_Ws9bE:Gy$*좋. АY$% c2YQJf3i;e-R343(o?{cn2:gx8]w݃;#:JOʽ6 (M~[nj:N%肦 l7 'C=]3])$HPƗ_~|=i{̭>'tǑ?O1^W̷m^>/~Q@\pJ0rCQ/})U@xscگڹ+w?n= J7Z׼??)"߯cts)}>7Ͱa:7p%\/{gqQG}c+ u{pݏx_/| ;-c?;w~8GNeэ X6 }c9faaeZmwс)C*YRl>yOsI~%l :N2;┈9FDip^\h(hIY1Gw޽QzT93Zc}_ϔCvկ~NwsI}@2=]zuIF:?><9˼-nqqlj[&}K^r-oy ^{>:: Ls7i[VL-2[i`RB<$~W?O"{ŅU/ґ o)hB H;Nۿ-7(fl]ůw龿,ַtQ3`(W4H 7/o&A-!Lui6'E,N&1jˮi G }ݞ=/6Խu?;R"B@[ɘ^˘ _S_&^7D3+p Tz?EAĉ3@,ˢ12fbc qw__7LG)"Iu~ _t> TRs[$ς%UT| RF+/RX\Kȴh8Lv~HGOz-Yy3@˓흹1 LPyey+7?i&2\&A֘Go2L6Ƅ*!?řlLR&sсv'b+D~׈Rs*qԦH }$2LjNuFqTK,Mo"ECq=Ȳ]]:ERz׻aa|*Jk][x_%J!HHVlUUuGTlz3<OJ̢uYbv{Si? S_\\D8O'S N\tCaQs_:KxFȄ= :l7YbQ/LGy<~똲ud=Qve[83E’HխnкIֵ쪺ԃJ?2-Զ%I<ܲ5ko "mpIJ9c5t\tX'^/b> '5W)> ٺ661awi \V$ !}!BG6Iě1ZmtvX=azZ a_tH73mf3ATo|E[Ću,tXcˌ Sdq_Ej+67kpXX!H{2|7z_~Jl'>񉜖@jq' ]]SO(_Auۿ-EyX| *RwKOBZUwԑ fѮ+70XBj (8f-nmA_.]J0. 9z3>?yI) =ڸꪫf=8#o}kķ$u펃 1vu6)áN/QK'#mr4u4XS„2V;yL H!2 2Fqwl sd0uVyrs ss5-2M;ձL;5{Zjpp(P( Q:J2&?[c|t'È%Ω]2c7HBwLΌY'qz٤gkasMs ~?NI b-e͈Xvc"xCRP_[eRBwV*.$B-f6HCk0a{7}ǰlr>b4I%NX[{zIHƕzZ] :ܺ=D6O9Ftq~5ٹ~跍YW ]%%W*9,t) ӰkaYQs0hiti-7v$$$08K8I'9<t5N-`% oiH_UI( ( ( J-l7RxnTo].ExT?}@G%nVa*O7W?) (<-lj`Nn/eazFz1!iIL7%Fj0U+ ( ly $nFkZ2"Au\S8MX z Ot 94( ( ( lX tL+qJۆiwF鵀i͵l@Hgy`S;R H?/Nl7KeAS`M0$8 {6P}ɢF?0[s$$7w {18[qZ F-68fwڣ0s$G18M%0p.C"30/5ĘE!t0 xA(ҩtl(A"8B?bFYb>cQN$+4.&: : =_DZn@jCQxk IDAT#N6iP򊔒! XrM B HR朖A `n) NJd{\Dr~9 ?kX[$h#E'v>*Af $šCmM #'&뿢("Cc4tĦ8)5A2RːR,U`. c`A( lv < ΠQoIJw5M" 5=]~n=烥; >&"l2"x)DHN MLoX',Ԑ,[$3) u,>U\WұH$:dh~ڂ `gHP~dC0K ;N3!9!% Rd[gjaBQǫҷAXN= hLq܀Y3.M8$2Ŏ0mb >#LC!GiuZÈ#\_]9^*!Dd~;\-e_G"\/ 4eRٍíCe6~w&ڠev` ,G&8K"MZHE=(!6K'VaQ<+2\ԯJcxwa헑.pA zm~2vq1f.Mt )?0۠rI p?1lA8h(D&Ԟ8kki:Otr脵SN9?)Д< CU*,2*èƞlC{_O d ~رG~< ¶fg?ji='ԓ,:3G]6%Jw*)DGQ%rPqU D$ﶢ)ZJb3+IGI"}㔈9 h%5O`e3`0iq0ؑzT#6VO*p#cH2ft]ct.ܳvZgp-:rEq+p5Оu"$p0%PUN9lƺXG-$R鐝QzafX?Ѷ -L (>=|36X$$pH53"v hKޞ#}?p/P i9m*6YtN5TI@I`K@ϲ9qF5s8$t 6Vs-l;EM.$B4YppN j&7R Rg}6UpqB|c.lLW[Ia Dshsxl48C-gA#(<ﾅޞNLc[3CYsJr!Vͻ2 +]Խ}oC*oXVePP8pē+ip AIeV.5Ѳ)%\̥.b7 i͐{IdR =x5̰EjE ὺ"*L$@<0?tka&HA^k9 87hQN=*B 5 x[xZNwb*؀aK, Ĭ@">J,8X3?؀~" ʂ(8_8u%Dx`ݝD,sI74tPn5L>pKa PD .]Yd޺tQ STfpVLMS+;$ ]tk_o1HYv8m[ɐ;!r |CKDQb`ʗF Vf j/'o=mT+ JPuc%, Ĉ 3<я`޺t XU%yAjmv4ۮMjm6ϒ¾,\=,mܿ؝XL4\HU&`mcq*参c1DK T,; BPOOEIJz^&b=72d #J\^ע*H]{_3G_Wx7M|satXC-+e=H-4ۍgyU`PxDzuw~R8SDIkޅEǴ;ͥ\3S8ϝX箷G$KźOPa}e{\K("`1ݰH[$+wꩧ*P.39{(;MQΣLut +t(822"R=DDEo9bz ^ -EQ4}{(0;yN6y+oᒣOOᐪO:jtVJJJXAskA,.r pQpjZiǚ֏2' tWŚk qxhsu0 05tK#̖f8NkZ,Ba|#E%%-nԹ{wNlvP\k h,FZ'|.~]iJ+Ơ p!8(u|@O_lӞ4wPs/*cuBAl\9e8L6C?pzcAQ{l˿K6B/((keP ]#$כ3ݶ!82߹cn 9bngZ^f 81lу2$A;$yD 3l.^6qmuq 77o~3(,'pB]:"drB:u L05AwR};ށ"_6on=uf"'>,k_q)aWj d҂n xh^ G JiFpva|4̛!~qx+}.Phd 3=@= <} 2(IЇ@5~_,pO7q{ <|I6m0Iґ?wr=1O}# 8M \v zNN.3M)-]R쁐TthzX! K 1`!em# `2e T$#_*,x`1*0+C2?\g0+H2B00LE#XfA< ]O}SQ`` ?//=Mjh] 鶼`%} qN IAh m82gzO'3oF__$r ,$j9v/}K D-L_0I/>Qz+,͡XL9`Ϙ|+>"iv2.pub>d MqR0 ƃ@'hQtPITD0yaui/}(@8ؙh̢vzI+|:^2ʖ-O¡&&ϹOBA #0Wjk8zg}6t&nBE'B#󶷽:^b3TazE+X TB׿u HL ߸KPNjsv"vΐzF;RLQ.w8=a j9؉Bᵌ%<)75f`z:cD5)KA!ZLNhج9ft[lJab2bxa)E:Ccċ[b#74#:U??d _7Lkʟ!euoxG&$#rI`cu4JzVL(E8Ӌǻ#ni ]9f瞎ױڝID~D$L\Y*8 =2QELb~I,>oH yk+a}DâvkTKe;hRPI4T$82(8 s+JO %!0AdϨu "zNYI_R)DȋʖNΡ&|J.2!Ecyav1-1!q6(Dx];`3@ }h寤_]3}NheYl,n,vz%Xce-*q`& I<_K^$-8$ 8=s!\yV|3 DE"O 3Fm%2Ke@jW57~Wa&IbǪ+2Wl̗kih)aQdƯT!J,p( Dac)KrzE!0BVeu+_~ƖDHVult2,4qVKOc/eJfHE1Yd+3`:߁D&#puIF J lsO Ml)l[ZO1(L,/X#NpQypPa~ȍRԢl倬$K4^޾l"!""z2WBL$/*\dj7l;si6"-\LbC-^_M׌-Q7̱r:) |c^@dP,>%d׼}RФR,Ⱥn‹ _qRxn,/ NcJ &QcL_nqhOh ->1pH$+W*eC(BC]vbBdK'(LNuY(;)Vn ʦ:^aA`Kg? Ox}&eBtzul/8^<_"_O~h:%;QrR~+'V.1Sh$YG]<'@ `lf({Wjvki޺cp)X)s@+W*s6$2nرbpMMgX$*uxJ`"8~[:W8=Vlu+%b%sPV? IDAT7ۧcێoB-N$ڎ$ݐ Sr@ UߵnWXXO86eaU0$ŒX~t¡bMV t_u޶JЈ{`Ƕb3g6p$ސj<x )KrXpTNW*,@G}rL%sjX9k;da޾w[hgw=ט1f.hZ89qSI`b@Cѫn+dnm[<ξutAZFAQ`~`K?fadEJU%%%+]6K9`ym/ km]Ԥ҂cn䏶;\{ݏl\)Δ6vflw9힕F`{Z gVqnk{nwN{hi>fQI@I`8DFݻ$ۛ7i0gMN#sZvn~v݋?c5R%%% ,H׎ݶ3#:inߏ[NX[wsk 4bsuY-nbMI@Iగeq#ڂs0ZLbTIA6\݊4VLDPPPFQԲZ`fv[](lDij6V#E,qz_𘄵<[*LSSoP[l|NE8Ԏq1N 䚩k4TFbav n`uPw%& "uAKFt])`%hG]t 8~FC~-BW6'vUn_EW52֨Uu/W̪ꚮPL7@ElC9寄_`ؐ;틋 ?MÄ|)Y!8pQT @!gVU'f0uԵjo8-ƣ[tv.oߵg#5ڭPb:̂gHsxXY&Wp tOJSx'C} |}Lp89kV[N^alhfAl{͎=ꏮ_\ܳsg[me12Sĕe}G|^/Jc' ";t?$We6@܏AФ|( ^'A(2£AD2N4D Q#@d4b"( `KYl <6[%K'vwoK@8,~GDU)7+%g &-$_w;Av-"Xl@l@ *Ǝ@'p oh&a+-KiP(Eٺ@cNUJeq h \4\,0&MDp.zN#Mςqy:.#!Z FIPtQn5Q qOH-d3Ǡ 6aM(EN|O8,?R 8teQhaf hTDDS@yJ9*YBBV" $ K݇#RXKgʹ,7:^DQ3M1zDO^#7}s`^uɛ/0 (b]oV^ be^+2C+ 'J1f&]ҴjX\ w!d/ :_3|I&S3u~wts#fN8u #Mh8C%Y:L˩qH#լ4f}Udk,r8QEH@޽.z`aCJdaWZfZx);YMN0L"pP+R(')X(hRjgRDDT Sz9<g6l47PܜMT: K冠pM]HWSNgVʭ:1Q0K:e\ MsļePM !ڈDEQ0ipkuKɕCjY;M= 0/6*q~Ad=ںްBcX_\7#/mg ԓ8 ?6501/2I鸓(>^}B @ʜBŇO+$1JRL+Ҝ[&+&CCelX* E22L_9KRnu*g0' dNT[.D"+7Lf(:C(ދ33ȐIp$SW#ؐ}aU)ey/UlSw*3he`D23vul~eFv.*F$ce`N-m21 )>¢*g(佄+ZZ0u)[PJ*&d@2e!.ҫe*gwQ++-wk2EF PL*.Zbpf*kפWʳ, Cd=.Ct)z'ĵސ D -;?s4 NY`c:յ|П1)8^Ch9-0XBeȾ''Ϭ',]L:bsn,O0ބS`w &Vǒ Rc'a(L[9*VWoT&iй\WoYE3wx()x(8 aíAV~lHj\NJL .AcICZ3Ÿ[XAs `3sv1pg|E1N8[zZ2ŋ=ACKR1cG Yԩi1l&B\l;B'[9'"u!cemޔ9ǰtǼ_ HLg˴u,1fx1.ju4!&;mǹt}+=dXʂW4d@H6,oqDOۘ'QzvNN:.}Oa +ufѳԢ/g 0" q}JAVYou Gp4bq(Ie$\2C0DZAw 7naۊQmRP8HX$o:v>zDwn9:w2#05.,U)ڍ9#LLkvy-Α8l;8ɰV) kMD9U$_$4y8ƮkK8\cQ1pIkJ϶LX#_!N#qUFI@II@'T}.8nr=habyZ7ZLT[D, K6L-|eHNpf0ܸqakMS*$$$p{ M[j\_usRhis $t/{^ȇӿ6Pb.ˣP]l!(VOY34 GQ$h̽|MVnNI@I@I _s;|977Ж ikn|v]ϣϤ+) ( ( ld knlS3tNJN(F8a%!Y.J( ( ( L+u_[זP))\ز,ATNq I-#*?u\H@]ECOzғ 3v!']d?`b k*~]\+< \rOr̪Ƨ~.C3O939F0_>e󘁬EAy |<(1L=KS00!s(fQ=.xs;3G~ u 3@*oSXж 7{#n)V[~.^PZva 1jpaCFF gzAMbAxìY*1b ̊SF?u<#PnSP:u^ݬB_a$QXc-W\(Wr8t AincqΈJp`?`F% 9`Wa`I P@ |`L`,mKh>;#uc'>*$s$Q 1>я%GO~EPH2(/~Q DaS#iT,+BL]|"3K%!7U˱DJPW"; $Hi`Y**I  *mb׵Hr^x]1 HA)vPsqYѕ G@121\dU/l~͵Pv"(<:!.*+F>{l $ӃmL}sLTfK@2{a#~؛n4{PgRQDZ2Ux I>/~>BK2E8Bá^Y/J/ J vC2h/+t3A8~6[9S.r,J X8,`TJO?AWh+FbSWD$\YE)L-ړ0rCH1 "uU4bH09ȓD]ע\3q$xOAbǏhB%Vn8Agm`at+zpV" KGvĎ>"8_jNK (Yptˣ;(5XfR 0p'zJsXckF}?dWN6ֱϬDi .*,Et16%ƚSWZ0ԍu⼎C9~2Inbx,Wa +V1u[@E˛9ܻ YHiy)gq}52u{)@JLit (BCһsIb(Xٗ&)o?ᴢq"}\9I_=F#W~C@ AGņ}F1=*$Rǀ-jJ "4hOil;@q&uUTj~PעYU14։JWcXe+%Fz݀!?M|8&k~YJ8TPVPfH_9i9>`*Аr7??O,'Iv$1Ki\vɕc.\ݰA17 {,*=яKW{eE48<1i1:,yh "W)ҔenW+~i~qciSDymiYaO5 I ?sЊ0Ն_|ޖAa ğpcɂ#: PCp?//%Ilﳩ 彅Nl7 ѷI37gQ3#mN 0`\&*-st<7E{ZϺ-obZ$3i\iYn 3n !nv&B 7{+M*,_F%}~P@3bN?=!:;gX[[4uJJ]n&[n+mok݄%dR0"߼2>Arsk7^$$ph%^*>zQ{wKtplʌ9dzm6Ў UX k;}#}vO_c`9;XOÉ8n#LL ˵Ōќগ*$$p0$~C(\CM,:s( Pm/ F?U&sT9tĀ29H䘻ٚM$$pH _ZTtWXV`E!+/df+]wUJJJ+I YGrˁ0qEs$bje~=7WQg>3vd=p!HR @pE2hUE'ҕcr^#۱ WtwUez]Ѯ:6Q9] `"."[8O-(0EH$"$_^p"ֵuce8d L8/;G}|kXs幆nqbDbEg&^d+yLWD'P&ť hi "LKf2qwD lqLkd ڤ|XlK[/ EIHӘc"Hj\pJ碋. 0V=ૈ5X"jA!LT C'pt* 6J| @MVCqQp[Nr5A4FTYEA7"À)ZX-j=C&cյucF8|Xdy_!oz]vMhv1ݝ6dQh@TW5[3"f)fFPIR9#lYEblJMf24fVK-P،cM18rb)Z"⌈慾Ex ~L"HpagaM#L:mة~^Rh@zp^"IE厫cC/KnD%Yl/zyEǤQfy傈".q58-tc.6x dX@tDa䅄d,&i&ɲ8¯"*h9]d+w&p%"Y8c&QE#~Ս@ʂMj=KlMNdkCO1׶8d[v@Vi~dNuY^4:wNu`§`HʋU WOA6Nlf"u\t :4Hude/?lʼɔU$ d3 RF :l :1neĥad]/$B2]4LHnD5<5Yd(36Fpl"VO׺o_ˆ"&b q|rQi옃`$d5Y?3 Ągܠc&C0$ j\#&ÊJpLj%`ŜuUҜm" vckL 4 {3ȶ2D-#Xvq@VUD-#.̀Hc.݈/Yd|"S@ nXYuu ټ`6SGZN=="33Zղmp#La{宵4PÂ&ؙBͱ5')^kh+m HbV4 8$,bXmAf Xz1bz)~saۯ6h4s~X{.ʟ'E4irFvG8j#cK3Dn4$te5$4T1ߟ~=?/|vܑdỺ.# mZdS-zR5wTWdaKH1ZuZ'@宻?}8E6e[Rb#<2 ڔ;#Qp*69vGBT3gۂRC%&նgW=4.$g/ In,oim2|㇈7 < 4-ikkAYO22=ӛDˈ˻^m3bm2{zoM!Xg":.5U>sM˫Z9xHF RőnBP yD!șE6L ^/xA[j^O/`#H7v8B?Ϸ;8q98;HnV"eʦ$F"[ijHkh;Ӑ\73?}p(΄=b [vTl¸b?^v(qg YG>؈o 92fb?z! :h$'c;8d]VRUQ!*)PiIW>`s'; 'sP`!2t{rFhUBh^hʲ_Fh iLLzLa0(KJ )NSm oϝ"ݝE#D\l>; \Mnz*¦hͱ,)Z G8Uy|, .Q ^_v)s9NOcvY,XYR:,kQԆ.5%$vUI&cI(Q@7.*C+E3IB?nH,:: aHJ8dsoQLk: Z  ?ڒfݭg29O-]!ܐ&UugYxiJ=Q֡%jΉ،ZEζA8J6˴$ ~KbZFEصˇLH; <x^׾ܫ^*|oFdBT@FP?DaDܖo$_yU$MtՅ{53˝}]I˿}ݛ.W k#mN.QcyWAv~ܹQ?/ ?hYF؅(HHnrLԣ0㌣T~ġ9%[x.$/ْˆDIHe2ٍs={p.e/{p^ܽrmO>8wDG˼*v2;|1MmrmSR\z`:O: <H*EkeR4ϑmĖSYoLG56m%G~w(QY)}~缩U9RNaZ-BzK!)nX=D6B9n/n(Q~Q`7AD^ϲg:8컾٣8 M'€ye/=#}: t(p)Sgg֚a 8Ki>©:r0a7MB#pIԷqu](Qಧ[܊*p<[2=ߴ +yGB'>2&i~M1l˞: t8PEuzK8KWi̝x !:Osd84Q%JaaQ~.vHs:̩L%˲Ӧi(eau(p)&+&Yn5Pٖۘ,M]ڈ'sV1q8C?n: \`߮簡&CHV*J"'fj+/C𾙖e82INmUVw[.iQ@^fi8«Q$LZn-% !G!2g"0z>: <(?~GziVvt|ɓd(钎aӆ3WEEzQ7WX"6LX+OF_6ԮDqWl4 0DҎ (tRvr9sԩSab|Qƿꪫ>qDL∃.5Dęz6FO=ѩe]rʁ\솫3j؜S%EqQEW^G>FF'N }O~?nll\YiUOFj.^4f|p5D0ˢ z=up.JQlʭŲQ3ܕ|HTdw!ʡT{P )%՝ˁ@;  U@Ƶѽ+ܝwym=IO ;%DgG?EQD~/B㦛nG?zwݸWWWO~=B{}혊 B?*҂ eSzA4<qNz8I(.]>CTGs#G*yνOqt!S:r8#0rp-=aOySw;ACiK;|ߎ)Ī.GY|dU$Y}ʹ!/UA@򼩋SGqޗZV<’DrVu9qhk]wzݕ8 Yʣj涿Y vï*_ƾ~H }SEIe#Soq6V$Z''-, dZkF&RPp6G4zYVް_.M9uww(p(iu]֬_~[an39rVlu={w];LYl[y3Axw7cҽ?˯ujXP5] 4fp8C9 ݢ2,lT4P佧$դy; tW R1oV^4 hX__7aȎqok4m!g>tvVɅXA]{ t<NhEUd*j*0sWO.4U%9eZ"/#jC'.݃.QiY+bvk @7S vkEǡH3 }G\b4IJ~#A:)0yJٓ\+*%l1E2D]a2>sU9rݧ@GGl!6#gn@Qb~* IDAT,Yho/7NWS ~Yz"ٸǯ,܉$P$! pu9i?N\:rO\pE*V}: th8E=y޾*P2?}2kۿ]6۰w{da;pQ*^d) 9"C HGz.H0Qx|^ԧ.]ăj I9"q5ɟa4ElӍN%QzhL*v . q(|k)m{zDWEn#(qBHeTjIYbr60dN3I̳h4| KѵQJD__FDGZY;vo]؛+IfǝʳJj,HTgFIXnva8]. mo{\n>~CJVϱ4'%,&ΐ4E*Ins2v%I$Q( >A*CvQC:]/ %z&7ӱ%%(drWP|?\dz2o\(7vu(QbP8:&)3.RBcpR!ErOZ]VlleiiC;: t(pv YU40tiJ?+ iA4Ju0D|: \D .)Kkǭ=N)C@q7wu(5?uϝ=e^8U: \ڴ*ly;N\ru]Kt i p6+|/|? ( @GCLSQS_KeYԝj=暜:=ٌIu6ֲ>:TQ@S-H !eW锟Iw:2~0<#:Q@GP⴩aZW5栒p*\'gs閤 FAUK>W椣@GK\*8Gکdz׆k?[y6{3؆̺ NEZGLna4V}#9Y^WeZhiRՔa;DL!tu(Q`_)09W߬ G>i}F飜%K2`V)r+MUdVٺqۿ(pP[#8n)lN67ƚ\cFTV u6u*mGEm$Tsi ֞C.# 5r.5{N|ZcOl3 I\JXkZNRWݥK^7Ԏz$GizǼv̊oԗVV/Ғu N]0xi,zC4~ -4L+ԋ$-:KFq7vC-ñˈNP; t8/ͥAmndQ-u$_JBwPfS yOOQD<ϸkx\"[Ǯn@ZcN9kIj^ -P=LO+&__A+;;1n#)(^?M>=sĉOugHi//Esr~|e7AYR5 ,]aJ!t?u(Ei.pGez 틾苨xF_]4̝L 2[Lʖ?F`J曉#{N!oByqc??~_y|\diIٜIŶt~EK^yLЁ~S9%%C' ELiQbnkFT/%]R_ h ?Y,}|)kkHn,v;utk_u$1ǯ~I hb[T4/]p0 _X E;8766^,y·C9kbh5T77ϱF ܿY¯ 9+Nk߉eGkH꫹v,,\.*cam1cHton4@ uŌ#RRo~^wԩYk0<2O$ cpv{WY3Gb6&b?Ϟg_8y^ࢅS^dʞ'1l]m1{s ,wؘ.U[+kЛ1Q55T i~u9f+eU>npq!)lj Ņ]B~90H$+"#v2KX=B l0:`1l. s*_Q oV.2|.*Cf؆XހCQD'd +Z 8QfHVgbͰ%E:QTNY,|Y;_&"FenfI~ުL;S4yD"LTM&T }NMb ?QM2>p-s0h9 VSDsi Xfx;`Xxqaa~_\BZ›Yۛm;g"q@4H^7i!3B7ZYme``noYal"z߻ @G!UwtX;ʶ#C 8OpVI@s{ =B{-%<y7Sh!n6h')j'4yku<-̗m*w_SǗYVզ!;,ѷ愺J9bQ%.8/^?X9r~GXۿͫ1sWX ?.$7  _foG}vpj ijz3 +/f2_5)r[OHkEnюNn|W}~Ȋ 8(l݉Y3Ͽw!Ui|w7y="#0Z<޾ŏ  ရ|#{ ( I߿[RY#P!^x![}j΀e|; }pzu\uq Tծe KFaXAVLtZU^K!9UZbYyѢ^ (eA/e L3BLq'\¬ˋfZ}x?`+^\}CK6,[ݺfL3(*Y/s{Q׬`ܭ'x!#>mwny_UѴ +F}qì]HUa,R:,l /p#0*zylU10! n^ 1 qG2/|'x g~pڼv˂;|`-pnS#맛_i]زa!RYyIA(S/Q[[DreIMTx_g0m0.3R>dOOGTC?]K2 oxʯ³(RepEΝ]H~^tM7qy!.ulE jW;`!Νm`¶h#Aucn/|&2@od Nۮ3:X`dC3Jtyٗ?[>Aѽ,//(<:=At}8x-xnE}Og*2TɦI|I9&$'A9P*$pe͆/&AcCeK3p54"8i{1vP x**LV 6XUWmp P7xj6+[f2:6°۾Kfcavq sb=Qɦǝ&/)%^;]KeիGjc.[n@1$y~d0'۝r,a=dИ9xHc{Hk|e#}EB"0Ҫ;5 CҚ N9q4E3$IVGM~@ٖM!})4|inVV@}yMvSZL3)X.yHa6*iOga)!Zth"X 4(kHYfq`/&/c+ҟ)DZK-@Pa+й?ה#"@V z t W7]H_6:uZXt5ݣ6fM) 1WP䰢ԓQ69:u%,I ,#ݔj鼮mp+֕ a_}]ZreOEfVV榮Փ~RƵ gUy}#=)Ӟf&|GenL=ۆKդ"8wz[f%LwŬkF$6w!,a9d'$vQ =Ut<kJVmHLqyd.rM8Ql ^4Z]q28-Βw-n<"7 ǵp-e& ?"P)LAb9$c/oz2s5kj)pea$zBH´4N8BLJ̣ \_dt IʏÇ}dʼgi#'0tr<[$ƣ3~~ [>iD"Aۜ f'.uY 6::,0Ɠ)-Xm;̳'MM ./)URz6MHxq =c^Zn]AV8 {~/AZia0ȡ\۝7RV?H@thEw|u^6&DS| !ȜYySL)v+MJi2o/t%gV/$&iJDgYqmq,{=ϰsĺ.H4?N,8)I hM%-C0FM=^LA?`:lJs(5boL)%6Fڈ`ݢ S/W͆ɶ#ȖQ;ҔX  e=JLn&<$* M [Ui >(-?j>X}/Bu):UEYW0ƵpiDqYcp ˩0F<* 4l_'F-F5J 5sGOjH1zڔTԴ410RF{a1n\:-k'd%8ЁÆi¥輸PԴs]OzJS4pl!IΈ {p2 Y$e Lv?ORp*D`ex7J 3ЎgZ:F!sMdlyL?e1trJP(QrODfl0Q=Ȓ[XR8]#IDATQ4ɪB:G(iXIQ#Bk^V`/r~J. vZ?MP5,]#_efoĚA2C%ƈ}x WmJƜSGSb# еU,y2 (kJ94*ay<e5ZS_OJMiGfq;v(z OҚrەMЛ|5 DU`d 1BΓB+OK,~e3T*vQ 0,E5IP}T# 7XIDM BymhiM~GTP^ԌEEMѷl@1*q h:AW LqO/Y<d9l!KV[X\;X8T88ΈôStuXب&XJH]UmĶ,/"z̈e GiZbBQ,TV" ڼ"zKipOj?  p3Bh'|s=khUI:AXh2-&6h %]9L|`VfP2VpzဵI^3dVM+5 = ?s>0Pri!y,)T'^XwߣJ-ܦr?PM+P;S\xp8}~bԈdvzBpT- )J!G1U?,fF YR ܈CiU*(BFd V&YyRKtf|])8ze!<F~y8F%rxQ^ (ka|1: A"`&?0^ie,&K!U0L"4@j9+h<8AZn@:XCN೔ZPS7/,\(r(1 ŕЙ.a5c!95Z7XGLp$'ɑtXx΄ 'a7A}ۃT8zi  鋇;Q"FIWf<uIy{(Y4WaMg ][G\ܓiءVB)>HVj8:TpOʰ)Qp>nGFa⩘LS'k O"K ܈BzLc<NP 4K'OonAq @)lRصc e|LXPFeQp)vcr!pÊ<|R ~?9zHM%(@y@r\&Yl<)F٪UqͭMrx(l2+ËT>!WK$_H*&@H@[I(8P\iI1"N*0ÀAԫ_Ut̵U9ƴPa?+锍~hO?Un.L4 \Ub6p-c&Ze a ix*}ҿCHXC8Q-וB#N#uB,G.~hp+ciM<&68Cg^݃Aa}x#C=,!lN'-@(Bp(2fL HWZ[he,i:H8\ `%AL.Yl߃ckWa5KRHh;q;n2 36: ^2'ԥf M+PBea3)8#Y}~o3W BFbe! sbx m@U{(0=Ar- H<̱1[k%ةAmt)֢čŚ*w:4 U!!#`@4^ g4$nf+Lf<σJ .![7WDZ8s^dLb,J~U#]Yʡ?NjC0b+Q{wXj1BǼcq)MA &AX3&!ey#kBa2 |M+ dY3a'b֧$RBQNr6,kX[&b Le!zq,m<ъ#'VS CI (eruU0} qrb m<(pJc`XĢqug>j=& 0:Qu1GA!Wx ]Y 3؋zZ{pL30MkFjzhcO&S<'aq;2=돷-euTp.RJ]N( h˫{%jv00Udq^(!$Np*=[ v&{h%Pp, Pu<N“<Y6;xЃÈ&@Z 0K|k | Ⱦ%|N1Gh( AI8"pcTM=@kn>j c  `~ ~ sH1 $^Z-QzQS173,x֎ &;Y:>L[Y;79821\h6^DdmS3O#\ߓ`2yW>~r43"$#?#t2pًLe&hZ7ḅ P}':3]P[Zp^*|4|BDzv1A&5@z`,@ى-,Sma sem > A/&~I诊i$)>t UEn+q ~x fhp<1X١B[,a;,& v4"i`)*ŏcTRAQrCU(7 5%ؚ?' yyu%17W*M?= +~V؏Q5F0L!hO ƕ9fp;Zg% WF m(;'el'ZKc), cTeCPbۑ^k-3_1q>җ{ =Pe}wA D!.L.!ejseE$*fYy*u5:tgGq9XaE`/;j6>2"a59$B4'=̲"Yj?Va!{Iky8LX魢l@JOebdZ9_vOIh$X]sUWtX J I˱8W@onT,3P(/2^"RU@zL MmPѠ&ccY*@43[fjl)Jĕ>f2>7BDţ ECz󸮁ʡHsvp')'DAJJNl|<o=۲8#Ol[`[=P+=@߂-jRc nE!t4A) شPW-& ibp\f:UU,F!6#;Tdx4 l`R,@JUJp[p pGz: [A#[VCJdJv QTUDbr+zoz ,x =0Q{T=q8I+RrU$Xml&Ï_9UagD36 hr ,$8=@m=~dt,XBO a#HӶWLnx X}s,c-Ͳ0(4gbz6[IRK/ 2Ȧ!"&20ˤCDy@ý5^e`X9`=U0#̌bZ/DP;\oSN-XxB%ĈntЎ;~$`)ٮIf9! 6(w ;w6@:_Rە0qL(C,x+u!ٽ|鸹váqdE+ >< /q_N[;9J izIENDB`slop-7.7/shaderexamples/000077500000000000000000000000001503006136600153515ustar00rootroot00000000000000slop-7.7/shaderexamples/blur1.frag000066400000000000000000000033351503006136600172430ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform sampler2D desktop; uniform vec2 screenSize; varying vec2 uvCoord; // Stolen from https://github.com/Jam3/glsl-fast-gaussian-blur kinda void main() { float radius = 1; vec2 upsideDownUV = vec2( uvCoord.x, -uvCoord.y ); vec4 color = vec4(0.0); vec2 off1 = vec2(1.411764705882353) * vec2( radius, 0 ); vec2 off2 = vec2(3.2941176470588234) * vec2( radius, 0 ); vec2 off3 = vec2(5.176470588235294) * vec2( radius, 0 ); color += texture2D(desktop, upsideDownUV) * 0.1964825501511404; color += texture2D(desktop, upsideDownUV + (off1 / screenSize)) * 0.2969069646728344; color += texture2D(desktop, upsideDownUV - (off1 / screenSize)) * 0.2969069646728344; color += texture2D(desktop, upsideDownUV + (off2 / screenSize)) * 0.09447039785044732; color += texture2D(desktop, upsideDownUV - (off2 / screenSize)) * 0.09447039785044732; color += texture2D(desktop, upsideDownUV + (off3 / screenSize)) * 0.010381362401148057; color += texture2D(desktop, upsideDownUV - (off3 / screenSize)) * 0.010381362401148057; vec4 tcolor = vec4(0.0); tcolor += texture2D(texture, uvCoord) * 0.1964825501511404; tcolor += texture2D(texture, uvCoord + (off1 / screenSize)) * 0.2969069646728344; tcolor += texture2D(texture, uvCoord - (off1 / screenSize)) * 0.2969069646728344; tcolor += texture2D(texture, uvCoord + (off2 / screenSize)) * 0.09447039785044732; tcolor += texture2D(texture, uvCoord - (off2 / screenSize)) * 0.09447039785044732; tcolor += texture2D(texture, uvCoord + (off3 / screenSize)) * 0.010381362401148057; tcolor += texture2D(texture, uvCoord - (off3 / screenSize)) * 0.010381362401148057; gl_FragColor = (tcolor * color); } slop-7.7/shaderexamples/blur1.vert000066400000000000000000000002241503006136600172760ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/blur2.frag000066400000000000000000000017661503006136600172520ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform vec2 screenSize; varying vec2 uvCoord; // Stolen from https://github.com/Jam3/glsl-fast-gaussian-blur kinda void main() { float radius = 1; vec4 color = vec4(0.0); vec2 off1 = vec2(1.411764705882353) * vec2( 0, radius ); vec2 off2 = vec2(3.2941176470588234) * vec2( 0, radius ); vec2 off3 = vec2(5.176470588235294) * vec2( 0, radius ); color += texture2D(texture, uvCoord) * 0.1964825501511404; color += texture2D(texture, uvCoord + (off1 / screenSize)) * 0.2969069646728344; color += texture2D(texture, uvCoord - (off1 / screenSize)) * 0.2969069646728344; color += texture2D(texture, uvCoord + (off2 / screenSize)) * 0.09447039785044732; color += texture2D(texture, uvCoord - (off2 / screenSize)) * 0.09447039785044732; color += texture2D(texture, uvCoord + (off3 / screenSize)) * 0.010381362401148057; color += texture2D(texture, uvCoord - (off3 / screenSize)) * 0.010381362401148057; gl_FragColor = color; } slop-7.7/shaderexamples/blur2.vert000066400000000000000000000002241503006136600172770ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/boxzoom.frag000066400000000000000000000042021503006136600177050ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform sampler2D desktop; uniform vec2 screenSize; uniform vec2 mouse; varying vec2 uvCoord; void main() { // Adjustable parameters ------- vec2 boxOffset = vec2(-64,-64); vec2 boxSize = vec2(128,128); float magstrength = 5; vec2 borderSize = vec2(1,1); vec4 borderColor = vec4(0,0,0,1); bool crosshair = true; //------------------------------ // actual code (don't touch unless you're brave) // convert to UV space boxOffset = boxOffset/screenSize; boxSize = boxSize/screenSize; borderSize = borderSize/screenSize; // get mouse position in UV space vec2 mpos = vec2(mouse.x, -mouse.y)/screenSize + vec2(0,1); vec4 color; // Check if our current UV is inside our box. if ( uvCoord.x < mpos.x+boxOffset.x+boxSize.x && uvCoord.x > mpos.x+boxOffset.x && uvCoord.y > mpos.y+boxOffset.y && uvCoord.y < mpos.y+boxOffset.y+boxSize.y ) { // Check if we're actually inside the crosshair area. if ( (distance(uvCoord.x, mpos.x+boxOffset.x+boxSize.x/2) <= borderSize.x || distance(uvCoord.y, mpos.y+boxOffset.y+boxSize.y/2) <= borderSize.y) && crosshair ) { color = borderColor; } else { // Calculate where the UV should be. vec2 zoomedUV = ((uvCoord-mpos)-(boxOffset+boxSize/2))/magstrength+mpos; // The desktop texture is upside-down due to X11 vec2 zoomedUVFlipped = vec2( zoomedUV.x, -zoomedUV.y ); // Then change the color to the desktop color to draw, then add on our rectangle on top. vec4 rectColor = texture2D( texture, zoomedUV ); color = mix( texture2D( desktop, zoomedUVFlipped ), rectColor, rectColor.a ); } // Then check if we're in our border size. } else if( uvCoord.x <= mpos.x+boxOffset.x+boxSize.x+borderSize.x && uvCoord.x >= mpos.x+boxOffset.x-borderSize.x && uvCoord.y >= mpos.y+boxOffset.y-borderSize.y && uvCoord.y <= mpos.y+boxOffset.y+boxSize.y+borderSize.y ) { color = borderColor; } else { color = texture2D( texture, uvCoord ); } gl_FragColor = color; } slop-7.7/shaderexamples/boxzoom.vert000066400000000000000000000002241503006136600177460ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/crosshair.frag000066400000000000000000000024761503006136600202200ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform sampler2D desktop; uniform vec2 screenSize; uniform vec2 mouse; varying vec2 uvCoord; void main() { // adjustable parameters float circleSize = 128; float borderSize = 2; // The smaller this value is, the more intense the magnification! float magnifyNerf = 1.1; vec4 borderColor = vec4(0,0,0,1); bool crosshair = true; // actual code vec2 mUV = vec2(mouse.x, -mouse.y)/screenSize + vec2(0,1); float du = distance(mUV,uvCoord); float dr = distance(mUV*screenSize,uvCoord*screenSize); vec4 color = vec4(0); if ( dr > circleSize+borderSize ) { color = texture2D( texture, uvCoord ); } else if ( dr < circleSize ) { if ( crosshair && (distance(mUV.x, uvCoord.x)<1/screenSize.x || distance(mUV.y,uvCoord.y)<1/screenSize.y) ) { color = borderColor; } else { float t = 1-du; vec2 b = uvCoord; vec2 c = (mUV-uvCoord); vec2 upsideDown = c/magnifyNerf*t*t+b; vec4 textureColor = texture2D( texture, upsideDown ); color = mix( texture2D( desktop, vec2(upsideDown.x, -upsideDown.y) ), textureColor, textureColor.a ); } } else if ( dr < circleSize+borderSize ) { color = borderColor; } gl_FragColor = color; } slop-7.7/shaderexamples/crosshair.vert000066400000000000000000000002241503006136600202460ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/hippie.frag000066400000000000000000000013431503006136600174710ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform vec2 screenSize; uniform float time; varying vec2 uvCoord; const float pi = 3.14159265f; vec3 color(float x) { return max(min(sin(vec3(x,x+pi*2.0/3.0,x+pi*4.0/3.0))+0.5,1.0),0.0); } void main() { vec2 pos = (( gl_FragCoord.xy / screenSize.xy )-0.5)*screenSize.xy/screenSize.x*4.0; pos+=normalize(pos); pos.xy+=sin(pos.yx*10.0)*0.1; float r=(2.0/(dot(pos,pos)*10.0+1.0)); vec2 rr=vec2(cos(r),sin(r)); pos=pos.xy*rr.xx+pos.yx*rr.yy*vec2(-1.0,1.0); float f=(length(pos)*10.0)+time; //f=acos((pos.x/length(pos)*0.5+0.5)*pi); f+=sin(atan(pos.y,pos.x)*7.0)*5.0; vec4 rect = texture2D(texture,uvCoord); gl_FragColor = vec4(color(f),1.f)*rect; } slop-7.7/shaderexamples/hippie.vert000066400000000000000000000002241503006136600175270ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/invert.frag000066400000000000000000000004451503006136600175240ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform sampler2D desktop; varying vec2 uvCoord; void main() { vec2 uv = vec2(uvCoord.x, -uvCoord.y); vec4 color = texture2D(desktop,uv); vec4 rect = texture2D(texture,uvCoord); gl_FragColor = vec4( 1.0 - color.rgb, color.a )*rect; } slop-7.7/shaderexamples/invert.vert000066400000000000000000000002241503006136600175600ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/refract.frag000066400000000000000000000055751503006136600176540ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform sampler2D desktop; uniform vec2 screenSize; uniform float time; varying vec2 uvCoord; vec2 getDesktopUV( vec2 uv ) { // Desktop image is upside-down, blame X11 lmao uv.y = -uv.y; return uv; } const float pi = 3.14159265f; void main() { float sigma = 5; float numBlurPixelsPerSide = 2.0f; float blurMultiplier = 2.0f; vec2 tc = uvCoord.xy; vec2 p = -1.0 + 2.0 * tc; float len = length(p); vec2 offset = (p/len)*cos(len*12.0-time*4.0)*0.005; // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889) float blurSize = 1.f/screenSize.x*blurMultiplier; vec2 blurMultiplyVec = vec2(0.0f, 1.0f); vec3 incrementalGaussian; incrementalGaussian.x = 1.0f / (sqrt(2.0f * pi) * sigma); incrementalGaussian.y = exp(-0.5f / (sigma * sigma)); incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y; vec4 avgValue = vec4(0.0f, 0.0f, 0.0f, 0.0f); float coefficientSum = 0.0f; // Take the central sample first... vec4 color = texture2D( desktop, getDesktopUV( uvCoord.xy ) + offset ); avgValue += color * incrementalGaussian.x; coefficientSum += incrementalGaussian.x; incrementalGaussian.xy *= incrementalGaussian.yz; // Go through the remaining 8 vertical samples (4 on each side of the center) for (float i = 1.0f; i <= numBlurPixelsPerSide; i++) { vec2 uv = (uvCoord.xy - i * blurSize * blurMultiplyVec); color = texture2D( desktop, getDesktopUV( uv ) + offset ); avgValue += color * incrementalGaussian.x; uv = (uvCoord.xy + i * blurSize * blurMultiplyVec); color = texture2D( desktop, getDesktopUV( uv ) + offset ); avgValue += color * incrementalGaussian.x; coefficientSum += 2 * incrementalGaussian.x; incrementalGaussian.xy *= incrementalGaussian.yz; } //Reset blurSize = 1.f/screenSize.x*blurMultiplier; blurMultiplyVec = vec2(1.0f, 0.0f); incrementalGaussian.x = 1.0f / (sqrt(2.0f * pi) * sigma); incrementalGaussian.y = exp(-0.5f / (sigma * sigma)); incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y; // Go through the remaining 8 horizontal samples (4 on each side of the center) for (float i = 1.0f; i <= numBlurPixelsPerSide; i++) { vec2 uv = (uvCoord.xy - i * blurSize * blurMultiplyVec); vec4 color = texture2D( desktop, getDesktopUV( uv ) + offset ); avgValue += color * incrementalGaussian.x; uv = (uvCoord.xy + i * blurSize * blurMultiplyVec); color = texture2D( desktop, getDesktopUV( uv ) + offset ); avgValue += color * incrementalGaussian.x; coefficientSum += 2 * incrementalGaussian.x; incrementalGaussian.xy *= incrementalGaussian.yz; } vec4 rect = texture2D(texture,uvCoord); gl_FragColor = (avgValue / coefficientSum)*rect; } slop-7.7/shaderexamples/refract.vert000066400000000000000000000002241503006136600176770ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/shaderexamples/wiggle.frag000066400000000000000000000011521503006136600174670ustar00rootroot00000000000000#version 120 uniform sampler2D texture; uniform vec2 screenSize; uniform float time; varying vec2 uvCoord; void main() { // Higher strength means bigger wobble float strength = 10; float flatness = 4; // Higher speed means faster wobble float speed = 2; float variation = cos(time); float x = uvCoord.x + (sin( time*speed + uvCoord.y/flatness * screenSize.y/strength ) + 0.5)/screenSize.x*strength; float y = uvCoord.y + variation*(cos( time*speed + uvCoord.x/flatness * screenSize.x/strength ) + 0.5)/screenSize.y*strength; gl_FragColor = texture2D( texture, vec2( x, y ) ); } slop-7.7/shaderexamples/wiggle.vert000066400000000000000000000002241503006136600175270ustar00rootroot00000000000000#version 120 attribute vec2 position; attribute vec2 uv; varying vec2 uvCoord; void main() { uvCoord = uv; gl_Position = vec4(position,0,1); } slop-7.7/slop.1000066400000000000000000000066031503006136600134100ustar00rootroot00000000000000.\" Manpage for slop. .\" Contact naelstrof@gmail.com to correct errors or typos. .TH SLOP 1 2021-02-03 Linux "slop man page" .SH NAME slop \- select operation, either mark screen region or pick window .SH SYNOPSIS slop [-klqn] [OPTIONS] .SH DESCRIPTION slop is an application that queries for a selection from the user and prints the region to stdout. It grabs the mouse and turns it into a crosshair, lets the user click and drag to make a selection (or click on a window) while drawing a pretty box around it, then finally prints the selection's dimensions to stdout. .SH OPTIONS .TP .BR \-h ", " \-\-help Print help and exit. .TP .BR \-v ", " \-\-version Print version and exit. .TP .BR \-x ", " \-\-xdisplay=\fIhostname:number.screen_number\fR Sets the xdisplay to use. .TP .BR \-b ", " \-\-bordersize=\fIFLOAT\fR Sets the selection rectangle's thickness. .TP .BR \-p ", " \-\-padding=\fIFLOAT\fR Sets the padding size for the selection, this can be negative. .TP .BR \-t ", " \-\-tolerance=\fIFLOAT\fR How far in pixels the mouse can move after clicking, and still be detected as a normal click instead of a click-and-drag. Setting this to 0 will disable window selections. Alternatively setting it to 9999999 would force a window selection. .TP .BR \-c ", " \-\-color=\fIFLOAT,FLOAT,FLOAT,FLOAT\fR Sets the selection rectangle's color. Supports RGB or RGBA input. Depending on the system's window manager/OpenGL support, the opacity may be ignored. .TP .BR \-r ", " \-\-shader=\fISTRING\fR This sets the vertex shader, and fragment shader combo to use when drawing the final framebuffer to the screen. This obviously only works when OpenGL is enabled. The shaders are loaded from ~/.config/slop. See https://github.com/naelstrof/slop for more information on how to create your own shaders. .TP .BR \-f ", " \-\-format=\fISTRING\fR Sets the output format for slop. Format specifiers are %x (x offset), %y (y offset), %w (width), %h (height), %i (window id), %c (1 if cancelled, 0 otherwise), %g (geometry - `%wx%h+%x+%y'), and %% for a literal percent sign. .TP .BR \-n ", " \-\-nodecorations=INT Sets the level of aggressiveness when trying to remove window decorations. `0' is off, `1' will try lightly to remove decorations, and `2' will recursively descend into the root tree until it gets the deepest available visible child under the mouse. Defaults to `0'. Supplying slop with just `-n` is equivalent to supplying `-n1`. .TP .BR \-l ", " \-\-highlight Instead of outlining a selection, slop will highlight it instead. This is particularly useful if the color is set to an opacity lower than 1. .TP .BR \-D ", " \-\-nodrag Allows you to click twice to indicate a selection, rather than click-dragging. .TP .BR \-q ", " \-\-quiet Disable any unnecessary cerr output. Any warnings simply won't print. .TP .BR \-k ", " \-\-nokeyboard Disables the ability to cancel selections with the keyboard. .TP .BR \-o ", " \-\-noopengl Disables graphics acceleration. Might be useful if you get rendering bugs. .SH EXAMPLES To emulate a windows XP selection, you can use something like this: .PP .nf .RS slop --highlight --tolerance=0 --color=0.3,0.4,0.6,0.4 .RE .fi .PP In order to avoid using .BR eval(1) in your scripts (pretty big security issue), you can use slop like this instead: .PP .nf .RS read -r X Y W H G ID < <(slop -f "%x %y %w %h %g %i") .RE .fi .PP .SH SEE ALSO .BR maim(1) .SH BUGS No known bugs. .SH AUTHOR Dalton Nell (naelstrof@gmail.com) slop-7.7/slopgood.png000066400000000000000000002165401503006136600147100ustar00rootroot00000000000000PNG  IHDRsJsBITO IDATx^eIU'ӓ0 >DHPy"DA@aPqE}di'_U{9zx}VZ֪Vծ2cd4Ӵ9uW\9f]YȌ4`߷o;s3v1i% }ԙ:@Ot!|VAizʣ8Fs'r|ʼne2H0AjE0 T)}HeO va.;7Mk+˲$"giZ&aS a[TaVŎ!(BB[w4#ѻɨI<ˁ8|9 ɲV-RTÐ3EAE"hkSI .} Dɤ qL¶񷱵Ε Z3}סaYA,-r7$`T-ɨø6͡e0 -[0uC& Qb9'kL~jnq΍(i8W]#Abih_>e ;Y5v6mT?-LߜlCc:VbdDU0OnB*vӄKH}ɋQ 2&bG  Ѫݚ4I1R[f 4εL icq0]x\hXqAqWFߡ6SNc dqoeX](:~kM4nuSo:^]MgMhN[d89v7ƒâ,ke>F16Zv \|G5,E󓐇K#]Ƃ;bL*&ux`ޝm~OHöECT#k$uf29Ysm$]` |:K.+0s'b->|rE(.AY<|;t J)Q1Ja4dY򱄐 6R"鄦qx00t6Lou`XgX|0d0zz v0 [xr+LȤt0wPXy,/} Y0eԄ18&޵Gtd*@ǧVLٰStm$44~RslNGzRDpƌ6`xF|J*#p7p;sUDhm1 T|pb0FDʅIa(^N_^G&\?$Y@R#nz^ L64\/jz.q8Gݢ%"aP%@8^CcfLcܔ bYLJ}ãGr[ $^@qm?YiW1 ,D3"' p6Pؒ iGS~*~ CqfoM&N)x6;LĒ@{-HGXg[f{4nl0oVߋ"cn9߷έ64Ur< ] 3ln =5: ͘Vß6OoYġ` !̅g`H]8ͼYzA|c8<Ś;MUz^w}bԕ"#V记^8k^7Xs\Z̳鄥#T6Jۃ"C{-`RfbBأ@G\a/}IIBn0 za d[hm&w^__c,N'MS*|VA=1 Zl #Ń5GG"j Gp!јEXgb3(v{-8(ͣ(@"h7YZ6 ;cօ*8_%&A1WVVYEiB‚*S7 H܁y%:]b>n&X|d(Ɲkg :j 6"NeS<]1Jd4&xݎFxψK1ؒLQ"ˋ01+/ Nra1ejEk2T BbplZtщ[Y-iY+i ^;.Z*4aB|_qEQ 5?9ޙw!6LbpeՈ6NbpF(6}fއ 쯯1Bz8Ś.!OptLpW\ VOg6& l"xr:".#$Ye 61G, E)sFבּaQ+Z􎊣30HLs`t {k s8> ' wr&%H\__7[66Dr3sFN0Tg,Qs2LmXұO /ͬZv9ãۡ]faZۓAUxB4h:+hL~h5&)^Bfb E&$vֳmEFjL &l1m:K40v V$nB`Ýo0N# h P4:p̔Cڂd?/ L@ 5lfÇSk !+VfW)Rb&CZ$2qױdU4B6e)Vr  w&V]8ї( `ED3 a/_&+H7-7xD I:tқ[m{8>3z@YgP'%PW&3DY΍ÄPq14n 8V%aAd' 땬(f凹#=`/ JraG"@ҢUd-cp1e31JX࣬)3oa{ɵ {,CkP)@1 \dXa,c?-SMB,3TI#9Ԉ`!l4a%Ue]¸W"Ne1P.6@"P@B5~% lP:=bLq'{fmU~zZ)v#L`tZadxH XU D*mHn'hw/+2PKA,ˉ]\#]ﰃbԇۘ fά:qNJzPbF;&oklCIE- N0:YÌ-;Áx"݋'q؍řoލc \EOuZR6!De;k(N6fvf 7=k`_SC2 7t̊.Ů,bPM8&DFt;ΓnBbZ5a̳aV(ф$F!"!Lٕrje C=e/Ē"B#T._FwklfNL"٬2JlpjȽ̦*YXPL%CBn%~BMX!f*k,!h6j );*sp2eIHQXuumn%.ʢ'=2VOx-P:eB)~?~ޝ/2C,L6TDZ#,^ItLTO)XB-a# mGum9L2o$L8e02gh]B3]#עX. Dz7 |)jNl̫+ѡ[9 b|4*[Qٳ#en`]v'x!:v2`mE w,^0NBIoek,Ԍ~_δ$:rm71{lq:rb㱉Ȯ% aJ"o%qd.\Mx:QqTK, {]=>uiTh6;`D\YN`L@0 XpaŘ(83"'\%{MmJ9,RQV)6;kl*QQؕF CWcN(b6bb>{O°x-l|帯;8cE*_' DTh ^p? VVI4XFnO IDATC64*12DL"}1N"@upSɢ`2]Ltf kDRPf1e Jf͡Q3NP{T ď=B|XL_Vkcb \0ɤ XZ๧E V j\B"18;fۣ5& '37G,\L&vՑlqX6/J!- kY22UmbVj+!#^3:x@`1v?X$u67Ǹ s6"ʐel:)aٛolu Sv#^ѱxuƁuٿa/ocƆ /&9`IJ6]k4u1Q5wlDhBesp\lNN#BI>+JY01,3]Ey2:E r4~h62 &lFё5/ iW$F<պvy6d$Zq41 16~+xM!g(6cP& ! J{W}lxy*K!9٬6g^Ah͒ȶ/;pq=Ɖ}ǖi\3+Q50R+y?MA]>SQeu kOYNޚ6!YcT~y;~6HŔ4$8T~ͨEO%FeP'5hPpeS|3X>mD9;QP5%Mx$ׄfKw*S@6C Bآeԃnh5&y%%i;SIiPV[Qraʬ&[rKAZY OJhjvEqAC9A ӿ`B)+;]ʆp]vXN`Ɇsp)k }'{0@Gyԡiw^.Q$"euՐKeA0Jy295R "5*Pjmbf͔ Y,OZS]h8]l\T%A( SUJZx+**YRF,?;':Y- ek!WyuAT5|ΪTX6)@3AHM^=k3%T[@2JU4B£iZ:C!SrIj (k_dӟMS)?ݐ!u.l! )1jF;J*K4m* uLH7*fUj*jP*0X!))[T;kh ԷF$f3m,_SM7Y<>]^F~0ur=uy{P\[Wwt]%Z%J 4R*T/K zӥpM4?^ aJaW5~T/ _ V ] !tipUN ͩ_RpPƩKM4f w-xu.K9W`_x%REMpFC+Δ׭+2V*JR3O ̔?u&X}_kU,S%+΋.[#)ݧЖ]i];RS3W(R*jʅ VEšZXRE֯gJe'|pRkR)enhΤ9479)K8 չknW iz#GOj˳fRH*+;h"j 4tY)luz0$tTZH(0`]ZzRHbI&JA5к"KWIjάhE$tJF ^^SJ R#BqIUWӏJ$G&k$REWwMYDCVXh+@6%MF@]b.itI"iZ;dV]R@P}ZOߒY ` !@XEmU头 :Ud rxؤRBmis)Tzi֡STPW-GqŊ[.Hh;S W"\ͭ__<}@kՕ' 9xgTL"pmޜP^畝x 8`֗(xA^_ڝ:f?5]oU0eN sBAX񥞊\qGՄ4!]-%A25*_'6i leU$5d~h¨DщJpU龁"ZR\K5&@Ț %OU(/$TP@u![A]A`@ |.;CfC]VN/ l&UE\܉캺OudPU;7:gϺQna72PUde{W|csgχvn(Krڇڒ[/x;7_u}HNyxf!$[X>k7ě#9/cO;FjNtF>_m8"b~ݛ*WJk*%5 m5S,uw.ʛ浌(j6`3]%}tu5ڊjkr p.$gíԈ ,x~ul 'rzs 8O$VX- sLS4وi}exJ;7g:Ii#Ta*o RREUyAMS?6R8LÂ{ҏ=+Ri)WEqEx69o#_L]2`NdfI. ▏DD厞[ w:Ztq[*n!s’IJ# vcvV:uR៚TZ˨ZW*¥NlNɩRm5巣ZD )IMnE$q_5x܋^CJϒɶ6]߷oSsB6k(YVus8\-rU(WO&~RRazh א&5HS)KbSpg1-SI͵FBQsb蔸jb)RR=}Rmț ޙA)᭺bkywu,Nը:[A4P> gͭ7͛n>| >OӞ}ۡE8A") dC-2]d*Y*uI%uI=υ'"EK [jB2k*EQL%QU!s5h))$iUjLMJ~iuz˔YNoI$(xmhƲz]lïpo25,,EbՔ ^H|#|:5nLoz #xEpk^DUNh3M2k_v0%>qE}1_~=y~+++;0wӝ?.yJt~?OoǟogYpݔڑ#G;O5y|3}C~V`s{;qʯ%\r~]ja^"|̿˿}C0^׽o?N_y$w/| o .8s0>ly{_̲'U M([ނ>|>$J I|&z @} _BgwGiwRQ.bJ=G M |uuuя~45tMЧ=iH;??h;C)ܔm ?o;cͶkn#_~Y`j63_J#'΢-7~3sGai滿]abV r!J}k0^җWU:Ðg]nC?n&޻YovS&RBZ+I\-590ߺfqL~`UMOPu =Zjp ,|i&4`LW V4@[tLrvU#z\dDй[̌}i2jl'A0ܸcXtwV-ú A+1Rv*co7\} "`(!DHNPn9 -.8Bt҈)E~¾{[ߊDsVЭBpe̢yu{S}c98碋[~^ԏ462c2('jLrSa+8p??pt ;ۖ>_W"$i{GgH׸Ї{?_2/*u8)Ad,7 !6wdjL?ustzM =shfҿ5"( IDATZ $PެNSR0śd71Ftv1ڜVc.6m.\'wXRJpDh_ϫܐlrC&w*|yUqkkK f٭0 Pڄ7"Ԩu:0PSgy'BlͰ:, +E {GHFnQݍhD"&]":t7&`b 7 ":,&$fPt,bWN77.DpjP oT/}KfM-nǦ#R`u&L (f:W- [iJEju&3Q$ᒙs=X q1j:O3J{g5-Gq ׃e1DF@ ՉZV'a u/>vZ=%zqWk` )a>S''<~?o{<ܞ/kh&"LaY&kXcÇe]> IRpC[]s5bLT)/r!BkTl",fcЉO~g߼s=,Dܿ/HEےLT4O|_1}jf\'?HӇ7 6oV*VI{]IFl&sEDoR\- VhjkbSӲȅσB <皟*mgf;A*Z,$>,/{DL", y5?fD}<2O|я4Vs$>5,hI׿uiK-zЃḎ~,|# 3m]k 7p` 4TC.F,Jpa:t=޿`3o'@jnTFIfl(ӻn?Q֯Q=D{@6Ϩ{<__C]XQd̴;Y(H<}, zֳSOĦ@l>6NB>1 u#twMrPiFgX`GZ6rH1$k&5z<V3Hfr몛ȗWT{TZ\,!&Ҫ②i^#R51iy1!4 iʾ_.0*g)"x=<*gu,$jU^h7<; l7[ =[mCQś=r gi hti-l<4QC'ub-):WgH[kg^\bjF^&3M5&XD%&Piy$7"Z(NE";es88k;N3{K\&3Զm.*֧[vkw@:A+.X^ӎn15Eb3D(a+ҥr>KKA` Sxhn\VYHX@LM " ͗lpͬV7 Ǧ%Z˴6:9~0u,u+qu+#uӛnΠ]*["2ZlvX:̓&j*S] |s&yͬɭc@-T[ ɛf{)Ǩ8@u&v7oOr8Q8rLޮ=GY^gyr@ Kw 9.Rb^ϧt]V6Ϩg]l<ץ3ekfB"ub3$G@ Nsش@"jeOj,ǯ;mwbp1szou5L;73E2. 4kx[pe}7~VlaU1Oys ;]:DPhإ;q2:k-x iB6x?`ڍ 0LB)]^Xp55f~6wk#P3!@ u2KU(,F1ٶs.B%vl3W^@EqNrqq$'+q}oB {mbr,vANp{k֝Zq3\pM7ݤoqf>׌)xw./cxa%e;hCn&b!-kh _zfIϷ^! .^rbyo1N~q#SnSIp9/06Axp?&w0hԢFa/fDžFRos)*7Cs&Pq\ DQ~7p< +%qeOפUL_rێt=_Dڙ o;Y*dČ0l^oHwS-R}̟G}9tnM9qۏ¢~W+YZQ *EЋo:1mn= {_u=Sse^p|2eɁۈ} nީZwCVI5ι' @8EXUE>8tp-Ѵ:C=i,+# ^*9繺pAh7 |8+4M1G|ϼ┻==Q>\/ /XNRR㟿?[?__ ]{Ԅ?SGߟ㞿wZtYDoh Fܬ/klF-.L8MW$?ߟyUɾ3ڥ_I] }# -?s}"hh7w{z(ϼ;\w#x|kUqQc/XG8"$:qaftR-26&X p[AE?XBNa9WZJ}+]Ts[+oXgښLtoxndqQ<ãZƳb҈sx4of<.җ<{fM\{?1WGtχvhviGR3grp)>6Gw9G-J\~ʩ!,#̡"%\fo`XEhL-46>pa4COaw`:waj֘cVBZ|H%šky),%V\9>LGte6\=>Gߺ}(mš,S QqW%0SBµ[2gxsv5~ v,doF BoLJ&6XVZeA,/Es;CvYk. &uk_Z6h~MgJ+5֘{{w66μw H߽zCRo=Gۏ|V\ɦ@aϽ_]ܐb-wCXCo*yߟuV,v<%vۻg%n":QkƦ:H[| ro 44E e#E qSTRGа^ujZv#K<5 ։AZ޺]֡~[ 5Nct5e_{z0F sqy?ba7YZwttWOy]<x:p s7!yv2#̳asxe2!T_t 4i[+WuiK`|uvVp޲)5ʮzLμ3܇aek9G_[ 5_ ޜ]M8ֿR4KbtU!\s#&Dßo>G<G7>9!-kԲԒ#q׾[}H[w8ELjFcEW^|W,#~:;ƻT[{ݩHozEl[ի _î`!Y+?v.Eeʒ.Wwnw߻nO|[[[ ,Lg a>ҕ'N9-NERhn /<(nq:nxzȟ韲f5 m-Eײ[2}Ɂ%n=K~k_Arsw%O~|sss7MO-sk4 V4VtOj]&m8nc>C+ys,VL=qS:,bTݸ՗_yuWڮbgJ %[/et5^K ᏿}pڝ~Q,?K,9Ps`UTtg>)h3.a=f`4\$>173p*iYqJg~/__uwCwa=)Oa!-^aXX݉xI/^c/pf/HbU:)8" tooYd:\uY]tasK|qHO~eg;6ݵ^sȡ!3V++ĈS.w&B"|"(֍\r%kszƉIs|[77 @iv'y 8{<.jj/_G1Yx^Sfy;P>*o}_w2ʍ= x̳~8ÞE~iKT1?wZ۷L]rˁcZptGIo8glL"PS'Wbȵ6wJa;[á&gqsN8pN2 @.&D1 / '\M8,,<\x妼7GJ} >"xK֘4Cڼ%^UxB^h5'gAPDNSA?~8Ǟ_f.9'75w˚IoU'}a+ro{GHnc瞭[V.&]9lN ""*t/8iTq\A g</ >cs7KetOM _7zoøy3"gA_fLgkZ^rqxC6lɓӊX>(ۭ>t8ˎVT]Op8JVfv艒t_ßPEB} \\rv:ֳ0 `GdFtz7pIfwݟ<^P@Hd" &d A rd0`r0`@F`"l؀|6 " /M~}׌ބ}nv7_Q A/O9ncFsOQXjGDKZ" IDATkp`9~2nc8||oklvZ&Q"lNxv nH'N۩2L)U~F#M<yYU8Jsr:5X'&$߫&S-$P# Lb[0DM}cM 2T ']F(z~O\z2 6~gG]= q;҉gjjf@ܙ,T0HVg&􌫸u7ѺLJzg' 8lPXlY?;\pjIәZʛ68|Iw37 +Ͷ8&fBdûhݖfqjxt{aAbv\6f efx\m[.;OeI/eL$o:0&BhDˮbtڋ9-_ݸ9Vhm0/?; _tsî|!~ϞaVwo韵8o߾,I$;?KՔ_h폷n]bqL,vK߅숐ʀ9{<y/Q7J. o;66nz;疧8fOYcna9]Wx-ŪKG2␮eo(|LTay7I'U0z].'PQ21!JQDJ黡D~rʨd.OD[E"A[)V]JdfMi yl{惙*G;Nrn(EXhgj^d)]CV?Za{t4=餓⊫x*`=!ĉxw9#owۥoҕ"L4'Wz>ɲp;eO"h ù/d^[#K[Qǃ_E΢ A5_cFPsG!޽-Nns6.=XnH b{9l'9{nU@֔evgD[Ki"V\=<rNC, ogo~l,јm., k([LQGbKCvG( *۬a]T_Я/'={岅%.~[39= ~`9A~ K"GPaNA:i[sP~˿W hwUU?wܻͭCi-rj L(;qnyJ;U_jQ8,HQdTRʁFe/-*uq{s >l@75Oi$0؏2_ٓMsTu`K؛4H'Wxw|`^Oc_ 5rʲpcV;.uϽd]/ϲA3:QD-,ܯ\Sj9w.`gsjuZC4QeITl7dffrX5"]mo~)6S^qzo~ı6R]@p8+[si~sMeεzD(uxn'p'B;4Cu:e&Ն?b׌m9^y(-\;aG Hk66CRiX6mY=d`)sg[`$4h8A9y]c$Fve aeKMVVtUҵQv' Z1ƚhv_!ncPPpTٲ:[زGӑn0vM |0~Bܳj4H IrAĹЈӣn2k4h8q9^auKԍ$Ed1QvN`bECkÁ Np{49VQ- <Z&Nh8#;.kcz6WÁ 6(ةyc6qdb4>EDa<ig#@Ŝx^W>IOQ +s׻< |ַ57]t7+P[8#p@nw !@e[bGQ tf7Ngov@A{˂:GͮU'>NXk kSԛfk}y,eIQ`,'(x2 r M3UC#w+4Lx35\sgX檊jBL]aP*AH7Z4S@[&燡?LPM,S'8Kvhpid軑a3]H׾v[O~s\Ѓ'zjq'|2H?O?_W}/E?5y3C ||9ANw_Q|s/~ /׿u`:묳O9yȆ={__ _pW]ux_߼"~b_yUD-_r ܵkyG~^?#_뮻ėe|;_G/DKJ^??G{ŋ^'| ^pW}+mc'lݺ>r*-%/y 3.~,-v6 =?x}QU4b}နndܧ//ewz:|[AK4Ybj~Ĝl S7! htw"(&۷o#Q,wǾg![lWzߜ$ٟ"w]%m??Q+^ D2TS 7q'vD!I_&7y[?ǎvQG՗VJx= oxgoogr–$IH+m6=@=Yz}^TRzʸGPawHn/E?-6gXnUӇ=a{/}Kpf~~~mQ,kR]M80!D |%eM -N\?4RHNKVZm/nxpxO=T)&DSozӛ6o[kyB6&]r>W4!=!dDwC}{=R(DȊl0Ǹ?i[VT-2 [Ѽw՗VJx'CsAkcbo~|GͲ .XN}Uzy*A"&ѩv}[$?cw"˿K\_xg?YO} _`7ںXNX*IY25FSe[QJgtB?Ӊ/!eHƲIRvQ`;-w?n Ot<)(;2w(Y2Vf2* >O3!Qo*x]xdȧ(z d܊ 0~1hIT J:Uc"w?P4PpK؛t,X>i0QX\擀HoYSUITQa3c5`^xx'Q׹fg[0R(j%\?KJ7N;4-BknEw)_-w\W|wii tc{O1} CB$O:EX+/2𺸁'PpbQ/&\|#?q}D;ݪta"1Ym`n_QaBvi[&(2EBHэn٭)ե*ꎪrf8hו|Sږsf+Ǝch\0 [:9w&[0X'.RLr݊P{cߍ'jGMUmgQUNXbTzIPC7lUnu!8B;H8m1ToćVlNujg| }̴yZ$s58Q7Mt45hO_T^"0euUtd> _ץbn:>84,n5- wȊ0G/17R^ݻwcW=qc' 4d4q׻ޕhpRt!t3Y'o[PUӖ8/An?dفġcƇZjFfU^\,Ͷ kGX<,86d~Vmm0G[Jlokwl|f6^9tbK%ֻ~wDžmHBm3hmIXO"Զt:#?Zd9 q+AyY1:e`p!vŅ8ї-)gEkEb +f^mTվkwҝؤJt$+J`vs}@ĴZijlGE, e ,c^(UkyL8|5ΠpB&QGa8@U}%QxEnFkJB @"Ad+kMJʼEH:b% 7P" )-*L]p]Io8pPsOz{}w߯ 4VPLL]=8h;2 Gl-/ТdrJKC ,;"OQXC{)"C$BjOaL32阴BfQE5 c?` OhCZ S"ȃXLAP B&WMiͣ*8:$(xqH} mq:ob}8rm]ςV*&^><"$"="i,VڄDjx$pkZxE>(L))" $qLixc2$m}3h#xv r;L>xixh(Ϡb~{wwKa@XR t["" J&7d#qX|cr"ф҇J:DG mã,_&d#dd۳WK~ҡ =x >S"OD<>GB %2$Uդ7Ct̔&(Z=o/ 1m0SQ45#5DZ xoXmYv`KQ(jnhVTS`~Wwۅ%lLMȁÞD*WDOҾ(`ua_ 9.\d7. daK &f*X uaP-<[7pڽuX7ִNwmj8p9[V[vI/UM8L@鉲 1 VE!@Ɉgx.3)jEỺ"M@ [*Iϰǭ8Kl"fbM5? tk7 J T5lÀ%Nk҄#t=i~bbpݏBpQ0 fD`P>aIeIS8q8^^P&hKb'>f0v߀Ig9ӀEĉ痿e;Eg:*<,&&2aِlJfDe[58;Z{C"( Ēn'<:f73ÁE@3]"D  paTܽu/!"'B. (P&n(lBă>9HK>ԧ,4.@H $!(&pw]հ9! EsҁC>NGJ뭡p5<-VęqԣLut0 /x@PN ?kg8N5&Ͷ,@r^ 'ž"PAUN?v`~nh@H=> ^T' CqB"˟h UQx=NQoD‚4v` ą$-U`焬$4Z* p1 P'#vi54nø)r}n(qKg8=v>R31F ?"V#`j?/XI;J&C00T E,EA;rڂ (? ]62Pxhy/hy ?Wp \U,/Cs$z44Ti3Bw.CR !~D)phpw86 <=aۊْ[E9J3PATERq'"Q$R2%̀"4J6k"H kKɫ*!RŇ&@Q 陰IdāVS}C8D{^ (\ضufP?x)Uj6% a1aZz 9ŜG;#,J L?q=o%|d2Nl&Vk;L!GZ}y@Z G1dw~.":*ҀBt(?(HE@#*Ld1G!.o}[E:V6R^J4[E1 7n7O4iq~xZ)#vkw\NJ(]TQdŊlE{q=ˍDHZKvPʘ8O"(jq+d!;0!g*a" 2p!( ׾TD0/&'q? qW1'9/r" BPO˦?&Ma8S! J"FdU:E򠭴zpUCI?8ꬔ@"yleCę{\B=??4Hul US8onmj>v]J[[Ukc:w3<3ߢ}Ε7Mnl4LhpplfZQw 5EoO ;,,em'%0u}=rv'KD'ts5h8p`sț&4509~ 7tN&Cs5h8p`r@U0<9"6!=-K5CVh^κFlxg0]h a @pJ9eG&}bk:̖1A,)fE s4X$Sژ@4U7h8p`E#Z-ޖ-Nha&(Bi,_#1 эXIuE Lմ4LI7pE6488vET5k9ؐŶg1_KYVP,k;$'Dc/@ÁY䘥a;CtM=pBk[i][ L @Ák>iv,[vE]PIYv`\o˂sjJ~aD2q8ܾpy@Áu{AZɱ^КcYaڎ3vǣ6RN9rhgm*٦j8pn` Qitڪ {Ngδ ?t]ͲV۬ 9#7&5j5t&g4м=.UaʙEtꎍyhr] Et>v-׼5c(C{HOY/A8k9=U5?`ū^*P8 3%9=w3;9H_tGszg*VU~Ue'swK23}.<^" x+zА@Q -*NM^fqzmǾZjvօDUuxoM'Ցw=[bL0,& zB$hG~w1 3E ͅ^\ q$??=˛fPXN:餪txx\b7=Cb Djǣ`4̢(Yo18M8P{s=pںds>pV`b>DBE{/}"@J4#L`yx|sHhLX" d J$1mnC/xӟ N뤠&@ 17 P"镯|%䙺j>i%/yxSO=o;3/(E/zVt KHC@72 C4Ay+j=C6p2N#tDU:žmoc"X0V_| M AR2!egɛS9!`[aaR92}aal *//!Yd Pcݱ;ܵ\e lCB1t/B鑿mf^ J*ߐQ1|3\~ 7111P7HH(K wy `'2PP֘X%?#pzhgr(E6A!Z\_,҉YGX"0mFCrz1.P2e$&" WN*Ӯ?TZ~37$#2Jyaw  (*U^O|"߭bIgt7֧ID)BS"G%آfpx6:mb47u G7Z8|% 9%yהOOdf =?DfȢ^D!HXd EIF@$Ŝ]!㐒񡤿[}5VB﫪@ķ"Lxw+9Ny=.q=$4Hg`ˠXZ(ZZˆN7:N eL$晉w")'y 0fe0HECDDyZWN/ iB6Gu**U5mg!謳–n^? #a#0 ⿆t`W>8] /tnY@EJ쨚K*-idquαi%MWrFbq$@"Az7HDeYļzӞV<AߊĄa!D5|𬁰Xn=aHpb+97jjh L-W? pDT:! IDATD 5 g>+ 7 jr JXA&sU:3HU| PNUU/T$B$;^%.Sjt@KK,"""z+2lD6rV e.7TǜFH<[nm{~P p7xJ{Q&.)Kt?omt ]+ b la ~Q`~. )pEKrD‡_ R\<50 e0(SdQ`LmMTX`#5PXD!X驔 P,F:1 _WC!%C܃Bݛ<3i8U`a>|   T+FV +|ъt֣XgHRVDW_|}d_N- 6hcٝlC(ى}ɷenC4dEoi&*#5I7MMMGa}?kvC+K\RoQiΚD +V IMIsDȿW4W<9jVtmaz Z̹pUcJYpMCqMk1tm\M[-~0WFc3pMa +^V2%rqZƒ7rt 7;T]IŽ(Quw vEGTC| .AfSf$YTipeMv=tlOM;6C-9p-5f4?3wm{)qtfzF7948~a!NV5m.R$=qGu‘7Tw ±kTp@Á9=֞g-pU%#5oCѝ^9S@M*ϙ%XLw >sOϺ`ρtZּјC4m4D9t8,ѭ-ѐ[n}v3ۃ ̂gհ'7jJhzWSN P7f[a& &~3Sb }rP# T[e8qF#:llN÷nk3:m?w`1J2Qf򸲂|LȀE4dADڱcaD* 1T /"^I@P9'@fQ#Ed,M"KWZo>sQ( `KYF³8CY(GJMVJ=\[R.|(@BÁt@a r#4#[w@MYJI*\UDv&F[D&<"%À#'|@2s#Pxw:Ou?KfpÛ0O2Ҙ@r_MeOh4̓HA#RT˴4X'AZ#hQJDT o~t=Cy4Q,^LDlM9[= \vn:6) 8|fRtQ/kj)U#FF@#ePz4 !F sy^@!>t́-kl!N!]L2 q_߈j-;ʁx@4TYWUo- N:HR'ZAtJbyע+U,VMw]mAi..AӋn"}aaNt:F  Dz5e>DH1I$rb"EwJUQ[Xd ">k>}24L Usi`O '̼&*bC7uy1VLgIE_MH^>cUU4#2!!'˳b[Ρ>ub*!D֡hBqϨi4P4b%pil"U#bĢ;|EjII–-q+`)Ɏ; aײv8f"Lsq?q5gU@jcN"P "<͕9 'cI$ jgZoɐ4>+LDk#)$%ӁlI4NiTL_sjPZ1e'U[ D"/5gw.8D ,(vb!-H"nf"[ՏUqǩX8 :ӄ߆]gR߿U%,âeLm0{jZتȉEt0YTZǍHyۄo-a7!xAT" <%s 4jo1QBeכ/ 4gULIR *SH!۔G.Y]lJez510YEC] JżEB0ZW8 1y5NtDKYZnjDg$9N$)Y 7q;~5&l}Sgz&J_M%HĬy<OeCaeȾ''_7L9퍺AteXf~kJIb d"IuBW3|[1M$f>y;ꭢ*$;52WbU{yPEC]ʃ2C 0u¹Qń|H]l=%ȇqD ضIC#WWR aO58T+O8efgkYՔQδ d֩#T/ >ӆ~8'BAvI'a2$U| b\JV8eJUͯ7ʊ4@Q4٪Hb^p6^٧pX@l+t:2XҡOꭢzXcU[b0 $1wg!)0UX~7iQXXvGh[j"}J9X)MGX Tk6|ĸdh"5IEe8SF-DfC,eJID#3Ml6F+d[O /Wqu*(*C]Zoyh/JW  a]@14[.GU$!P0ECtd4Hé  'v"1Qu1(54VSo)t=RwHhdzm4SDn, z) C4_b$%ĨoHd0!F Xrl3֠?mK o\c@YK͛|`{q`OdV?!^CMHmwpr!aŔpi$E\S߲ !MCMHMXKZBkfXNCx|y{R9>C6ZQt+#$*}#8 67Oxl97p_]OG|$&=Ns$\SBgaȧåH~Jaa[tGȫbj8p:/,SMe e%N%Y^xXw~`c@ÁPyi=Џ<ձ0GЊJzA8CW۪Zu;wփ֦oUs6) z[ǚm'0CW Z벹UUc k[M (p>K "45neˋ|zqwGxw DM/ϥ6WÁ 60%B&VjH:M[oSI̒ i@I®rz[u!@ÁC-f3l .9#(e>}0!@ÁMUؤcgov0+Y^G$XEAa{N`T% 3BEm ldd>7\-/d*i fh"8=Gf:3lV55h8p@(n* 73rz]7lĦai8Lk 6:ϵVRbso7;wT8E65LB C$#1q 1wRX tۀEVQUi&1 nAM%gx+1kh< aob,38\h"^D|竌hYDC'S1guV@2&_BֵAIA5芙\ j>zh#l%Z`Uㄨ JpeR0_$^"9(%x.ot2' 0H4D0$GDmxvQ~@x P"fPߘ2W&jj,}O1=!H|VʧF ÙDTJjQqI^3kHzv񝠃ļ`hB9Vl8=𠳐U|bE&\1C+(oRՈ€oF@e{&d0VPCd`'2QDRXAL2^|!1X 2`%YitFd` IRXZNi|]胔< ΂D`>6lIVhaVM"L̑(mj F LePRբ"咪W >5P.)4MJ5/I{HNQKh)raBCeopKrqu{sDak*jl`:$e2 C 'c"P3/cN$N P8Pd0NAg|`H8S>Jل#Q+4KE9Eߒ)H4|d(HyiUD:3rfy@*_|EO!OTڴ*ZU-*R.zj̬E KSXՀ!}b+*_JfKۣaj{wvtN8VaQt(mqFj RVmgU7#װ7b<C*cBSw~9ΐ+|<>N^1$| >FzHg4ĄAk‹5a!bO)[U^բ"2ꕪ1NWQzRű'4PԈ SUH_3ԗ"f3B\'? +ۈYJ4 ' @|'MT {ڐ8cN,JL45/E5cꕪ1NWQHu8Ϸ4OǪ #O+,MiD1;d\5g?Un{=ܸX5M?{z36}"čN_dSu' )a%Se| +Wnw.A,T%V'qwVtL 2&C2YG>"#Dq{ e(AΣ[hpq5lm@ F-2&"(y|HfᏝ"B3kSQ#e(6>;Wb$y4ҢFVW3@a阁Dy)=fpiK9FzՀ!?E|wlA,䇌* "$N%됞m nQ{uz/YDj1M<ݾm !U}Nw)UhstZ"'>1_лnSjkfĩG>Sj[8Z%N5}PJh~n}٥c8dEi 玻'ȗm!jBft-!^j%y- 6Y$DvMnrq#ݚ!>˂فubYeCe6idN8_h[3:-Ǵ}5u|3:{MgVhSh2Qq1o\bz+ `dnOSpđ4&(jlsa0Fib2\_j*98}*VZ7e88^Tò-#5=]Ew(qtzݺoHh8p@%2M {h=%9cF?9-AANVIA&V%c l\I 3;h['(-!VvFqbBou7D"4h8P4Db 7@0䵾lr(S8s &@Ául\g\F$Q1N0x(q  ݹ^dէ)ͳ 1:!L2 Y@M㴄n`j״~=D"SBG>Ѣ# 9B8/JCIHy} ܐ7AYbV\Ջzא219 ?2^pVLϗr&*7!;q˱fzm_su\; C@j"(Yնs/͝?72Ktlm;v>rP9΢7`C5w_<)uma곅OF!{PT `<ʰ|B̤->YsTu&ˑ:C"[h 8o @LD,8"~[? `"Rk9sg'B%!xj7g)k&=q#09s Io^MSaDBԷ|`$Mx" h>f@-14݄+tJv#A-C (r.QEN'< ŀ9kb ( /}*m ]Sڸ !]5!LͥPLl HDBQ)P˗ ">L'& TC JAOgRJbB"t&bY{?,)63P&t7Qۊuɶ)ۭ-J8RtF\RTĸr2D`-F~irD9"Hp`gMS#4 O%Ƞ2H^".hU*2D"7FTFwEG|"l]p s霨U]za 6KʲtCe.Ka;l;RNfHql[k& :3iL<>LK˜cMD$Z(C"QQDtIP^Cy$ +UCDtҦIQ"-Ƹ|{@ٖU; n覡A(ADh&$(`?38o6y2{#bD FWY͂!!&`R||az_xHo |40jHiZgpipצ;\ꅫ9,WzZg(^ԝlw9^LVN@UWcb8GqR 6vyp8Hx&C'3* k|(>< h%DTvtc->Aנn ;$D +W^Yoٴ֏}&lVq0a OMcYe}|R?'=Vg Erfe_zӯ"U^?HEb+3\!ԅ+s{~l."=Ci9/Ʋ0+ 20~|ڗl1mԨzֲU׫Rs ԭE+yyê:5F9.XWle;:V8V - #XǶ|S(ؐfeCG<5Φ^`kMO^6X $Z9Rԧ>]$嵣#$x^X=IdFST BD2Yǚ<.e ~q';RQӟt6Z {3,U b pFM 9!c:=Nwka d@2Z`U׫>D sؚzі;{sّx\v\;U_x/,C n_hk [(O,/| oxC<_h1Y:>GzEݦC YT#h~2ˋ^<˳.${݀ }S䟩[$%yx3T@`:cuL?̄~xk".G)lP2tX&jٖ"BX||eePj70Bf:Mv)tP3-kV \E唪Pka媎5,-l[쐻 \w$ RMH%+uI>h|3'c"+x^I_1 T~>Ĩu~|DL?{\_˦ͪ'lhPIj0J Cѐ4!PLX%yW4n~j p@q9|Q7ֲz% W|n _5(,U!dBE-(,χQt^?ԽM`a2db0"d7|Nt. T!/ ~ZZ6Dym ?-[&"󙔩&`B9]Oq+wf0q_=<J,.$ dR7eiY@S:ii׊e/STE$$+aru6%郥F ŞX*?L /zXӬA@V~7@M"%#83ʼ45'N)yen7ZR&  Z(nʅ.É+~L@ BRCM\19] ]Ml6e󁴡b೬Yb ^CTi"T] Gt0MgIWp8[yAm ho=rA`CV V1WK4@{҅Z5]9YCpB(2 N.k~Ѯs@7I6; ,Ym5HAԦ, SUR À84lRUki&Z|T  +dA*!P1eI:"~-RhdSܫZ<$48@TużIO4NlM!Sq޶$eEL,QQkbIrĎpM8kof@ࢇ50Dgj] M 4-Z]&\RPJ/%N)T!kj/ EnN3m뜽w1; 汁k)r`Ad&!ykHc2 nY&ŰrԱ^j\8w<.7x:-l8=m@W u77^^C\S"mۮ؝mdjr +**=R4J@w,v8m@`?@VGq;$~4[( M!!RihV)>,3-bSM)p3#w5.ت40Uky\E &T(P ㄠefXrU BH22aP .RH11hHF\dN86T$mlvvc$P:nf@a 6mu@R5ndag΂ ) *69lJA{>IZn331rj*v^t*MLs`[v5AD3 ."S7:7C_Qh昽(Ȫ2GU*qYR#tϴ K;hL z`NtZȊD`Sڦ Yw*\Vu[A8^Xۆc_3D=iO_峂q EK˖E$G*5#MoTfEܴU|dUpW`yN/Ac;+5 @ݨ$7bi0PΪJ-FL`=NS+)I(bblhkVE= Ҭq?B\ 8A8VL]O 4\ajV@8LDwˎS<!!6/`5^WS6w ?Z¤JӑewE: QZ=#.np~8tt_EVg_c0C%w,u+\+~o|^n;~pa0@ZV9J;7rDwrL7̢,:;9TpORT8 q@t<0TҨOਗ_#e XӲW `NU*˹ե*5Saa{p\˭~FP^W3 (4=)D"Xze/X+ENT`tD("@Z:1u۶EN'cp>.u4Cs0T\G$e97o}+uNΩ'H6I:s[/+kDѿn喙~xn7nmfRpV3{?*^3LD'N }TKBNͭ-JVC}/D}CAL~ޞy枂 IDATvs1C$ʶXt8utݑI}"㎪ Rގ4@2'r!"7:Oz}Uǚy2`(5G"+ o| ak{eJKuo;a6VU}e*qxS 'zֈR|A\K3螵|D U{Q:a0<'G"22 W]u&E.#K~>'OV48T,*lJ+( 7Γ mEe!Y,ʰ7bL;]bf96$ IQ}BDzmjJrmŴPMmښiv@t =a"qj&Vw,!EJȠ yni#,OT_RV(&?ͦ  w{%,R@*0Oz7sUfO %D6rGIY@|_2@@ JQ;j:"J3b $$jDUiRNKǟP/4I7חEHϥ6j @A@]{IDa17Uil˜ިmҗ>WGq]f X}h vjt l廪UuЏ$TJr|4h o!**35k) G4t2j(@ҧR@v]4h LE Y(6<1+r[om<jcqrЋC2^z$Sp@XjSUA 5 RdY˰)iJ UDLՋMUVo;yQ5k @CPu JV8=Mdk!^/ 8,ʢ QԬȻkC@iٺQĉc۱NԴ4% xIi0'þfr =%ftePfJ^yz7ݻsYUy)R[DvH5s<5T| 4Q6"'ֱQ k5D^GYDvɮ95<5!Мnڗ~dioVG QIt09uQݵmP𠊌b[e$&Q&YQ u46n @PA j*J ]AeѫNkiU(h6WW Rb48p0Ӭ"1uRՊ KAYqv$ Ҹk{5ExVYzVL@X,J#6V% 1r*Y'({d4ِI4FDaO~Yk ,pV%)!hJ!A[kBjRek( @_2WL;?˗v$//\{=!:lO3?3/煿%/4|˺C!ī^G?9) oٟهd*\X)}j?_UO~򓩼C9r}Sz++_$җ9Pf}|OK>q[KDgߩí_,P=]=)BlUւLE#Wk6`<΋b0t^{̋0oo~q. T%6OI' %B<~8\رc>-bC^!9ZL<3я~4X&7x#0^3w]u|KF_W>FGb??7aad SH/~__Z?>pBտ2Uz,I3?34??/w*poox?o}[9ɓ!Bx;>%{RCo+2i]AѨJ&̝*糶i/w; -+aw?$/JM,F曡7 dŴImz.l'Ě } _rKL=$Wt5HaAk*(ҔEЖ%t5'nllY??|~#Sww7h"w4uKi߃"{W~7p;NX4.bÅ3$;`e` /noo]8+U<h0-l9間a9Xw}wگqN ؿ9¯ 9)No}߇fGoP=A3Jq^.Le ZXB]ԍ!laW8$u!V Ɠ'ONzv@#ϱy{PZ8eC&2/ߏ=B V6ZO|ɻmo{ӟt`V1 䯿˿\8Lo5KwjB3+믿>Ї3燀]?\8C[Ӆk/ag Q@a6qVh~ϔ_-'" ɿ馛y˖>HXGOȆ,,(z':y^C/|qB%^tCZAn!R@'h<_̘~W~-Cpˆeɯ`5Ofuyd,cM\ 5e sX聁|9;_WlHV*QhA7]5ZdQKUR.T`a_cϰ&aϤ#CUlTMs!T:+ꯖ-OQϊu/(RJh t|0?M 37v3?B2+ :|=3=@NΔm<κ5ǒ30{ =C9 Si 3(РfTO!X5W8|e[lW_җMfzRBsuoo[ҩrŸ?g*Ѿ)ar677 FsNBxa)qQ~.B\n»V70C,|p$;/hfV12HUcXPyaKIl(de3a!Y8=$dߎ݀9Q'-Q Jo,y/R*4嫖9PD! pЛdbb -oi/%rFM{M&FC;.^qNZB'zl+N`=&Dw^TicPpnVZwHUR4,'HѿΣ\ RrA+#"l3 ߣ%X®Мlp<C:X8‡ gO~h'vCeJ Z6ՅQ̀ n9l8־taלZa\6e#:G?w#y_8UAi|%`q7&<`qBWX Xا[1*z{AU 1 !Ʋi/rGv̑l% 7zߏ>^.F|0Y{/^;pV<\+^9X?ej6 $yS4N2--UFCLof!A`A 8E39A3=W ⲣ!y J|&QKommAxF 6?"6?C扁 -xQ'B>׵1?$Uisf?u''j3Qpi `Q*6=i$N3_ Zg3CrCh+U}a {  >:m2e^8BgBI8` s2\T5m͜y­<[AT[d54UM+cC7ԗ|fzIb\aiOk3Px/h:q/ @d9s^ _ ȿW;=ql "IQlGѨ@Q,N|3t=O2]^QZΡ&/M9/~&q9AB&(#ӻMsNZhr Wf o (paYb2Fȟ= Vx8P:|a{SP?^{vt,~  Dkzt#- B 55PnęOBK7-6v1FJ?5@>bG+tDڭ(uQrŞh<"6D"|݈q HLatښi4h p 򗽔%e/+KoqFIzӱyMrkԪ:Ajy ͧ@yV(-ۢQa_ s K/L  Ke;ounm3T'%DeX饚0u} (@$!.T'F;DxP6+m @@@M]M2ICMˠԲ}PEIR pirVUm{0b6Ys3  Ҝܲ]efiQY\i-r*q\ͳ #KrR}}Z/u@z_kaه_JI>%>g=;~寳4bpa%/n/ }e³?Lpj5[ŗZ-l<ˡzx;dEO-g˽M=ׅ~Ega%g/']wX쏳4zxQswwd#,oZZwDgԴ) fUk6U 3nqR2m04AuKyLsI uTebR4Ȣm+YzeC(!;7LˌYFv:sQ8Dd yYUT&AAe|Q4^u0"b ̒29q]דw04YoB eC} ,Y`q1u "A{VfJUm]D mͮ4DmUY~i4-FB +iя#wgbSp="„CS-8K:(v_/6csl )Sk֭yfV<-%VvGvTd x48cQTꅒgXW52-8s*ŝIR4r[q!eB`5T}Y+"FVdTɕPKT(K<9ƙC}]ǣx0D%0[dX(5=V{Ɩ.L@)Yf&l!1UwRެJ[ܚYȕ*WKj r4S#)rpIٯdOgm2&:-цc.I(MפP|4 *հȨK$)lKQtd->25A8KNMHdC*->k]UWLPTR5,s{4mЌ0έYF2ZYZbD@~M3b>wp`fG58v}~`6u[m FxAȃP1T2KL&-q܌5%)!N}Ɨ Y'l9c`4p98M8K`M<ANGHiG;FhH\̇992xlj]},u+ȉQ <XSm<.]Wj]lWMnJ.k>/#Ccق-ѴdKK@j1OI`z*ZEk9# @X,=9t paEYU;(ڡ+*FIAa䆤VUI?Ԏ2%D! vE@tI5k (("eT@ey~k?X,&&M)8FV( ڊIDATʢ1QT!w?3 [vhptSލ N}cL> *eZQq :vhi\?< v@ynSb;:l$OO\,dͣiv7|˱qan#4YL*jZ\gũFj?(S .5t8#VV&YWGX'ppᮤIS99.v#+܏ uFs37! ЁxcXN!zE M[T@!{;IH-3%Ga )*Ni0`HTԜs gHϥӻ'^%itt%ssT9(JGL}t%(6w [0vao0)(Wzi_鯯-OZDn#0 Js˲$\ݏ,r!|V TUVQ|/~ӅʶD\zcÇ"oUY$yy8ܨ_鍡G6(+T%/eT23MU8ny>I3۸ .#kDIžA@n^]aqF #X(h;~$EieWs*UJƧG[ww[g ])LR;w( ]#Άh)BM]GŒNQ+Ѳa4+\fu t\%jG&1l)5a_eq<8ѰiiPFHBrC$"{ږF &a |,ax_> d;X%%Z T҂b( nm9LKM^ }(dB:Â@v; =anWURR=# "hp+t - U -bd $emyGB/P1*,Hxi9[IjFe6"GSZm_r.BЬʎK DRL$]%JY {e0ǶG9Q8Q EEmlQdN,5e*pd<StpfDa;`GqL:POqX j 7X^j&P|TlZo mPY*'5EPso -Z*qa@-5g\^6U1B -TUeBgz6"dۏ[5r?c9&L \Ђ1;PΣġay")-DiCﺚj!tw-ܑ,$'%I(!>cJqLx1L"Zۚmn2Y=KPJExd vw,7 QrcH=XIq@o685ddH4p$K@J' ܛmF bYi ;Eޛ9<f1++mӲt9)>R-EP| dAG1C5w51#!Q*s̀Hn?qD()`&.,"sy r%Z=%gqf#_aØע,KݓY+s9sMGVͧO@gao`"}/0m4-6! cqC됴Q0v"(̘$C^2̈N4ԑ=%l£y< =.v0QT%M1fZ=!4zJ=c֣A挱,[P&YGFb՚He肉R깞Z(fh2Wg1+j [ St :~ ơ2@аL‘:)gs s,4YЗ CE5E1iBc,i"&G>  `d`aU }>:Y) dvƛ<]oy!*M2SVMR.K |"XX]DjE \hE}g7| !6!uiԊq,b!`z""%Juٚ1.)5,WM UI\0Q8Ɨk.w; 8h;.dA  B``!IbdjC#|c͂X`uݹi$lnkBP5AXm3)6k'Á0\ ]`ݵ +8 盭 zڻQL-nQÔS/b:B(g CH)B@1%0l*hw{4#TaBA mTcX?f\n =\ayu#jpıfff-1Œuc65zDBA5\o`qғ-LKDf:(FVEP0EATTpN$x<`c`@x#슍.˓ӭc _[7li+|@ WIK)S) dRf':V""ӞuRv,# f`dzq*ⲫY5jNˇ@aC|HH1&5`g4#Qn9 l%:L7C},;j`dmsCQ@pɓui@@Q- D,AAB+띈Q8>`Gց 6" DGks`8,`]H5HJm1#`?4̓$YSM5`LX* ͇`XNV1_ýe܃W]ӕ!T j6LBwT$]`@0 k^53.ii 碐mdO1[@!mOe>"?{08u?hT`+I0o,*4XcHTB M5ȓ m֦KJ5F%o .ր~A4P1T[ZEt5RK0E5,t>8 G65:mKW6,S_f0rz_mk?+'jY],:{a0oh:]q6Y$t| O^vS"SݰH6(P\БM%/ǒ24A0/IUQ!HSW^zi+ 6!N^)8$,>b Kk(NlEEy.:ra!Rr2z "HKeRy\%j8&.L<igl<xSRZ޹u+Sx )\$N2tqlvĜ` p X5-+ 㝃1 . L ,uL e.*Z [BbRY7T8ڣC- GVo7MIq;Yp 3ö QX#CdpMG4?YBюj4)-XUnbhC{N5iB.3>J5r% :=L/'#J $/;[)iRpJj2Q T¥ O%4lg%mYk*E?JC^+h5۠Oh HC cQcp_Uy %EBcgI]= iT>T A/]נ8[-fΖ$AؗV+0XB[ͥnx]Δl/اDڠ *uٝB# }q%IxDLH+*UpU+#TN)[ R'G˳ŵ0vvCU[H*.)% VZv`ǘSHW2=3+HGjP$ܗ(K!A@OOC)F$irai*;~#ۡTj쮘kncW~yCx0cG&j6Jaݦn$ƿ HWvh /R`V4z ._4 K9Y&ǤWd(+pJx*RiO$Q@;*JXL@4E;XV[FґL06B2O^Kѷr@q*r2]h'=Χu1!pd`AȤQ9@$KL*lǃΰO `V robupISKGe'C)= rjX zЃ'?}^Y 1`C3p6"Ђ [VR#E؁M.D6˗3drvseJm)UIiGNUOFaqܸ؞`(.H?Nu/5Fu_U&BIl`tv{ `+O)M6SаT%K^s|%H-4]^رu;m ,d 4eK C綽qb8vIȽ0>T$i[AıK" %J"4Vm$W Z,&DF D#6:!2!9mޖ 줽!4T|{ǹpLA$o 7A-h9ҷ(,hR%Yo_[kXs6]wvO1v@0ZS| #rcz Xd<c\nMmۧȒ#E:,&O1o} ykǂ 1qIK yÀ`9"ɢeCn ɋ UPakIlgRǬ67KT >F^4܆kB vp D#:F BW7lm8j0Hx {KU7Af4~zⶣ;~E/ D9@40Cɐ2p5ͅ2)*&- g(EL1xm`=@ U 9lW[P2u )7>SF_z{`p"@eK]ҐNһtɈ- (Z؃iX@}N[4J:Ve8DYI2d\j6#K&! xAtEŃ,U1&='̈́A@.YЖ'Lj SUj#8Em [p<6LﳾP'IUKRu-{&-ȨXMTE +ЖL"hIo$b*ec>/5dccIS1g'M*1[|~b@_w)`ߥɢP&(tD8h3+_\!NDC8"оjNr:\ƙ0Ȉ )9Hi6g#;:3-H $d;aѰ+h@^eш"kؽR#h^N:*荤`;95ؾ NFV >>iㇰy\I 81.0?`4V^EÂ!-+0')Q^ݤe]:( `pS1WM[-)άdȈ gDױJY3INxKX!NyD| ؝^ec)[ Agb ޤŗ k\IbtFCEŴ"jDa䐿$X5} VjNo|'ȪyDƲ@t=\.([cA@)Vqe$&뭶 e0B5yIENDB`slop-7.7/src/000077500000000000000000000000001503006136600131335ustar00rootroot00000000000000slop-7.7/src/cxxopts.hpp000066400000000000000000000675121503006136600153670ustar00rootroot00000000000000/* Copyright (c) 2014, 2015, 2016 Jarryd Beck Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef CXX_OPTS_HPP #define CXX_OPTS_HPP #if defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wnon-virtual-dtor" #endif #include #include #include #include #include #include #include #include #include #include //when we ask cxxopts to use Unicode, help strings are processed using ICU, //which results in the correct lengths being computed for strings when they //are formatted for the help output //it is necessary to make sure that can be found by the //compiler, and that icu-uc is linked in to the binary. #ifdef CXXOPTS_USE_UNICODE #include namespace cxxopts { typedef icu::UnicodeString String; inline String toLocalString(std::string s) { return icu::UnicodeString::fromUTF8(s); } class UnicodeStringIterator : public std::iterator { public: UnicodeStringIterator(const icu::UnicodeString* s, int32_t pos) : s(s) , i(pos) { } value_type operator*() const { return s->char32At(i); } bool operator==(const UnicodeStringIterator& rhs) const { return s == rhs.s && i == rhs.i; } bool operator!=(const UnicodeStringIterator& rhs) const { return !(*this == rhs); } UnicodeStringIterator& operator++() { ++i; return *this; } UnicodeStringIterator operator+(int32_t v) { return UnicodeStringIterator(s, i + v); } private: const icu::UnicodeString* s; int32_t i; }; inline String& stringAppend(String&s, String a) { return s.append(std::move(a)); } inline String& stringAppend(String& s, int n, UChar32 c) { for (int i = 0; i != n; ++i) { s.append(c); } return s; } template String& stringAppend(String& s, Iterator begin, Iterator end) { while (begin != end) { s.append(*begin); ++begin; } return s; } inline size_t stringLength(const String& s) { return s.length(); } inline std::string toUTF8String(const String& s) { std::string result; s.toUTF8String(result); return result; } inline bool empty(const String& s) { return s.isEmpty(); } } namespace std { cxxopts::UnicodeStringIterator begin(const icu::UnicodeString& s) { return cxxopts::UnicodeStringIterator(&s, 0); } cxxopts::UnicodeStringIterator end(const icu::UnicodeString& s) { return cxxopts::UnicodeStringIterator(&s, s.length()); } } //ifdef CXXOPTS_USE_UNICODE #else namespace cxxopts { typedef std::string String; template T toLocalString(T&& t) { return t; } inline size_t stringLength(const String& s) { return s.length(); } inline String& stringAppend(String&s, String a) { return s.append(std::move(a)); } inline String& stringAppend(String& s, size_t n, char c) { return s.append(n, c); } template String& stringAppend(String& s, Iterator begin, Iterator end) { return s.append(begin, end); } template std::string toUTF8String(T&& t) { return std::forward(t); } inline bool empty(const std::string& s) { return s.empty(); } } //ifdef CXXOPTS_USE_UNICODE #endif namespace cxxopts { class Value : public std::enable_shared_from_this { public: virtual void parse(const std::string& text) const = 0; virtual void parse() const = 0; virtual bool has_arg() const = 0; virtual bool has_default() const = 0; virtual bool is_container() const = 0; virtual bool has_implicit() const = 0; virtual std::string get_default_value() const = 0; virtual std::string get_implicit_value() const = 0; virtual std::shared_ptr default_value(const std::string& value) = 0; virtual std::shared_ptr implicit_value(const std::string& value) = 0; }; class OptionException : public std::exception { public: OptionException(const std::string& message) : m_message(message) { } virtual const char* what() const noexcept { return m_message.c_str(); } private: std::string m_message; }; class OptionSpecException : public OptionException { public: OptionSpecException(const std::string& message) : OptionException(message) { } }; class OptionParseException : public OptionException { public: OptionParseException(const std::string& message) : OptionException(message) { } }; class option_exists_error : public OptionSpecException { public: option_exists_error(const std::string& option) : OptionSpecException(u8"Option ‘" + option + u8"’ already exists") { } }; class invalid_option_format_error : public OptionSpecException { public: invalid_option_format_error(const std::string& format) : OptionSpecException(u8"Invalid option format ‘" + format + u8"’") { } }; class option_not_exists_exception : public OptionParseException { public: option_not_exists_exception(const std::string& option) : OptionParseException(u8"Option ‘" + option + u8"’ does not exist") { } }; class missing_argument_exception : public OptionParseException { public: missing_argument_exception(const std::string& option) : OptionParseException(u8"Option ‘" + option + u8"’ is missing an argument") { } }; class option_requires_argument_exception : public OptionParseException { public: option_requires_argument_exception(const std::string& option) : OptionParseException(u8"Option ‘" + option + u8"’ requires an argument") { } }; class option_not_has_argument_exception : public OptionParseException { public: option_not_has_argument_exception ( const std::string& option, const std::string& arg ) : OptionParseException( u8"Option ‘" + option + u8"’ does not take an argument, but argument‘" + arg + "’ given") { } }; class option_not_present_exception : public OptionParseException { public: option_not_present_exception(const std::string& option) : OptionParseException(u8"Option ‘" + option + u8"’ not present") { } }; class argument_incorrect_type : public OptionParseException { public: argument_incorrect_type ( const std::string& arg ) : OptionParseException( u8"Argument ‘" + arg + u8"’ failed to parse" ) { } }; namespace values { template void parse_value(const std::string& text, T& value) { std::istringstream is(text); if (!(is >> value)) { throw argument_incorrect_type(text); } if (is.rdbuf()->in_avail() != 0) { throw argument_incorrect_type(text); } } inline void parse_value(const std::string& /*text*/, bool& value) { //TODO recognise on, off, yes, no, enable, disable //so that we can write --long=yes explicitly value = true; } inline void parse_value(const std::string& text, std::string& value) { value = text; } template void parse_value(const std::string& text, std::vector& value) { T v; parse_value(text, v); value.push_back(v); } template struct value_has_arg { static constexpr bool value = true; }; template <> struct value_has_arg { static constexpr bool value = false; }; template struct type_is_container { static constexpr bool value = false; }; template struct type_is_container> { static constexpr bool value = true; }; template class standard_value : public Value { public: standard_value() : m_result(std::make_shared()) , m_store(m_result.get()) { } standard_value(T* t) : m_store(t) { } void parse(const std::string& text) const { parse_value(text, *m_store); } bool is_container() const { return type_is_container::value; } void parse() const { parse_value(m_default_value, *m_store); } bool has_arg() const { return value_has_arg::value; } bool has_default() const { return m_default; } bool has_implicit() const { return m_implicit; } virtual std::shared_ptr default_value(const std::string& value){ m_default = true; m_default_value = value; return shared_from_this(); } virtual std::shared_ptr implicit_value(const std::string& value){ m_implicit = true; m_implicit_value = value; return shared_from_this(); } std::string get_default_value() const { return m_default_value; } std::string get_implicit_value() const { return m_implicit_value; } const T& get() const { if (m_store == nullptr) { return *m_result; } else { return *m_store; } } protected: std::shared_ptr m_result; T* m_store; bool m_default = false; std::string m_default_value; bool m_implicit = false; std::string m_implicit_value; }; } template std::shared_ptr value() { return std::make_shared>(); } template std::shared_ptr value(T& t) { return std::make_shared>(&t); } class OptionAdder; class OptionDetails { public: OptionDetails ( const String& description, std::shared_ptr value ) : m_desc(description) , m_value(value) , m_count(0) { } const String& description() const { return m_desc; } bool has_arg() const { return m_value->has_arg(); } void parse(const std::string& text) { m_value->parse(text); ++m_count; } void parse_default() { m_value->parse(); } int count() const { return m_count; } const Value& value() const { return *m_value; } template const T& as() const { #ifdef CXXOPTS_NO_RTTI return static_cast&>(*m_value).get(); #else return dynamic_cast&>(*m_value).get(); #endif } private: String m_desc; std::shared_ptr m_value; int m_count; }; struct HelpOptionDetails { std::string s; std::string l; String desc; bool has_arg; bool has_default; std::string default_value; bool has_implicit; std::string implicit_value; std::string arg_help; bool is_container; }; struct HelpGroupDetails { std::string name; std::string description; std::vector options; }; class Options { public: Options(std::string program, std::string help_string = "") : m_program(std::move(program)) , m_help_string(toLocalString(std::move(help_string))) , m_positional_help("positional parameters") , m_next_positional(m_positional.end()) { } inline Options& positional_help(const std::string& help_text) { m_positional_help = std::move(help_text); return *this; } inline void parse(int& argc, char**& argv); inline OptionAdder add_options(std::string group = ""); inline void add_option ( const std::string& group, const std::string& s, const std::string& l, std::string desc, std::shared_ptr value, std::string arg_help ); int count(const std::string& o) const { auto iter = m_options.find(o); if (iter == m_options.end()) { return 0; } return iter->second->count(); } const OptionDetails& operator[](const std::string& option) const { auto iter = m_options.find(option); if (iter == m_options.end()) { throw option_not_present_exception(option); } return *iter->second; } //parse positional arguments into the given option inline void parse_positional(std::string option); inline void parse_positional(std::vector options); inline std::string help(const std::vector& groups = {""}) const; inline const std::vector groups() const; inline const HelpGroupDetails& group_help(const std::string& group) const; private: inline void add_one_option ( const std::string& option, std::shared_ptr details ); inline bool consume_positional(std::string a); inline void add_to_option(const std::string& option, const std::string& arg); inline void parse_option ( std::shared_ptr value, const std::string& name, const std::string& arg = "" ); inline void checked_parse_arg ( int argc, char* argv[], int& current, std::shared_ptr value, const std::string& name ); inline String help_one_group(const std::string& group) const; inline void generate_group_help(String& result, const std::vector& groups) const; inline void generate_all_groups_help(String& result) const; std::string m_program; String m_help_string; std::string m_positional_help; std::map> m_options; std::vector m_positional; std::vector::iterator m_next_positional; std::unordered_set m_positional_set; //mapping from groups to help options std::map m_help; }; class OptionAdder { public: OptionAdder(Options& options, std::string group) : m_options(options), m_group(std::move(group)) { } inline OptionAdder& operator() ( const std::string& opts, const std::string& desc, std::shared_ptr value = ::cxxopts::value(), std::string arg_help = "" ); private: Options& m_options; std::string m_group; }; } namespace cxxopts { namespace { constexpr int OPTION_LONGEST = 30; constexpr int OPTION_DESC_GAP = 2; std::basic_regex option_matcher ("--([[:alnum:]][-_[:alnum:]]+)(=(.*))?|-([[:alnum:]]+)"); std::basic_regex option_specifier ("(([[:alnum:]]),)?([[:alnum:]][-_[:alnum:]]+)"); String format_option ( const HelpOptionDetails& o ) { auto& s = o.s; auto& l = o.l; String result = " "; if (s.size() > 0) { result += "-" + toLocalString(s) + ","; } else { result += " "; } if (l.size() > 0) { result += " --" + toLocalString(l); } if (o.has_arg) { auto arg = o.arg_help.size() > 0 ? toLocalString(o.arg_help) : "arg"; if (o.has_implicit) { result += " [=" + arg + "(=" + toLocalString(o.implicit_value) + ")]"; } else { result += " " + arg; } } return result; } String format_description ( const HelpOptionDetails& o, size_t start, size_t width ) { auto desc = o.desc; if (o.has_default) { desc += toLocalString(" (default: " + o.default_value + ")"); } String result; auto current = std::begin(desc); auto startLine = current; auto lastSpace = current; auto size = size_t{}; while (current != std::end(desc)) { if (*current == ' ') { lastSpace = current; } if (size > width) { if (lastSpace == startLine) { stringAppend(result, startLine, current + 1); stringAppend(result, "\n"); stringAppend(result, start, ' '); startLine = current + 1; lastSpace = startLine; } else { stringAppend(result, startLine, lastSpace); stringAppend(result, "\n"); stringAppend(result, start, ' '); startLine = lastSpace + 1; } size = 0; } else { ++size; } ++current; } //append whatever is left stringAppend(result, startLine, current); return result; } } OptionAdder Options::add_options(std::string group) { return OptionAdder(*this, std::move(group)); } OptionAdder& OptionAdder::operator() ( const std::string& opts, const std::string& desc, std::shared_ptr value, std::string arg_help ) { std::match_results result; std::regex_match(opts.c_str(), result, option_specifier); if (result.empty()) { throw invalid_option_format_error(opts); } const auto& s = result[2]; const auto& l = result[3]; m_options.add_option(m_group, s.str(), l.str(), desc, value, std::move(arg_help)); return *this; } void Options::parse_option ( std::shared_ptr value, const std::string& /*name*/, const std::string& arg ) { value->parse(arg); } void Options::checked_parse_arg ( int argc, char* argv[], int& current, std::shared_ptr value, const std::string& name ) { if (current + 1 >= argc) { if (value->value().has_implicit()) { parse_option(value, name, value->value().get_implicit_value()); } else { throw missing_argument_exception(name); } } else { if (argv[current + 1][0] == '-' && value->value().has_implicit()) { parse_option(value, name, value->value().get_implicit_value()); } else { parse_option(value, name, argv[current + 1]); ++current; } } } void Options::add_to_option(const std::string& option, const std::string& arg) { auto iter = m_options.find(option); if (iter == m_options.end()) { throw option_not_exists_exception(option); } parse_option(iter->second, option, arg); } bool Options::consume_positional(std::string a) { while (m_next_positional != m_positional.end()) { auto iter = m_options.find(*m_next_positional); if (iter != m_options.end()) { if (!iter->second->value().is_container()) { if (iter->second->count() == 0) { add_to_option(*m_next_positional, a); ++m_next_positional; return true; } else { ++m_next_positional; continue; } } else { add_to_option(*m_next_positional, a); return true; } } ++m_next_positional; } return false; } void Options::parse_positional(std::string option) { parse_positional(std::vector{option}); } void Options::parse_positional(std::vector options) { m_positional = std::move(options); m_next_positional = m_positional.begin(); m_positional_set.insert(m_positional.begin(), m_positional.end()); } void Options::parse(int& argc, char**& argv) { int current = 1; int nextKeep = 1; bool consume_remaining = false; while (current != argc) { if (strcmp(argv[current], "--") == 0) { consume_remaining = true; ++current; break; } std::match_results result; std::regex_match(argv[current], result, option_matcher); if (result.empty()) { //not a flag //if true is returned here then it was consumed, otherwise it is //ignored if (consume_positional(argv[current])) { } else { argv[nextKeep] = argv[current]; ++nextKeep; } //if we return from here then it was parsed successfully, so continue } else { //short or long option? if (result[4].length() != 0) { const std::string& s = result[4]; for (std::size_t i = 0; i != s.size(); ++i) { std::string name(1, s[i]); auto iter = m_options.find(name); if (iter == m_options.end()) { throw option_not_exists_exception(name); } auto value = iter->second; //if no argument then just add it if (!value->has_arg()) { parse_option(value, name); } else { //it must be the last argument if (i + 1 == s.size()) { checked_parse_arg(argc, argv, current, value, name); } else if (value->value().has_implicit()) { parse_option(value, name, value->value().get_implicit_value()); } else { //error throw option_requires_argument_exception(name); } } } } else if (result[1].length() != 0) { const std::string& name = result[1]; auto iter = m_options.find(name); if (iter == m_options.end()) { throw option_not_exists_exception(name); } auto opt = iter->second; //equals provided for long option? if (result[3].length() != 0) { //parse the option given //but if it doesn't take an argument, this is an error if (!opt->has_arg()) { throw option_not_has_argument_exception(name, result[3]); } parse_option(opt, name, result[3]); } else { if (opt->has_arg()) { //parse the next argument checked_parse_arg(argc, argv, current, opt, name); } else { //parse with empty argument parse_option(opt, name); } } } } ++current; } for (auto& opt : m_options) { auto& detail = opt.second; auto& value = detail->value(); if(!detail->count() && value.has_default()){ detail->parse_default(); } } if (consume_remaining) { while (current < argc) { if (!consume_positional(argv[current])) { break; } ++current; } //adjust argv for any that couldn't be swallowed while (current != argc) { argv[nextKeep] = argv[current]; ++nextKeep; ++current; } } argc = nextKeep; } void Options::add_option ( const std::string& group, const std::string& s, const std::string& l, std::string desc, std::shared_ptr value, std::string arg_help ) { auto stringDesc = toLocalString(std::move(desc)); auto option = std::make_shared(stringDesc, value); if (s.size() > 0) { add_one_option(s, option); } if (l.size() > 0) { add_one_option(l, option); } //add the help details auto& options = m_help[group]; options.options.emplace_back(HelpOptionDetails{s, l, stringDesc, value->has_arg(), value->has_default(), value->get_default_value(), value->has_implicit(), value->get_implicit_value(), std::move(arg_help), value->is_container()}); } void Options::add_one_option ( const std::string& option, std::shared_ptr details ) { auto in = m_options.emplace(option, details); if (!in.second) { throw option_exists_error(option); } } String Options::help_one_group(const std::string& g) const { typedef std::vector> OptionHelp; auto group = m_help.find(g); if (group == m_help.end()) { return ""; } OptionHelp format; size_t longest = 0; String result; if (!g.empty()) { result += toLocalString(" " + g + " options:\n"); } for (const auto& o : group->second.options) { if (o.is_container && m_positional_set.find(o.l) != m_positional_set.end()) { continue; } auto s = format_option(o); longest = std::max(longest, stringLength(s)); format.push_back(std::make_pair(s, String())); } longest = std::min(longest, static_cast(OPTION_LONGEST)); //widest allowed description auto allowed = size_t{76} - longest - OPTION_DESC_GAP; auto fiter = format.begin(); for (const auto& o : group->second.options) { if (o.is_container && m_positional_set.find(o.l) != m_positional_set.end()) { continue; } auto d = format_description(o, longest + OPTION_DESC_GAP, allowed); result += fiter->first; if (stringLength(fiter->first) > longest) { result += '\n'; result += toLocalString(std::string(longest + OPTION_DESC_GAP, ' ')); } else { result += toLocalString(std::string(longest + OPTION_DESC_GAP - stringLength(fiter->first), ' ')); } result += d; result += '\n'; ++fiter; } return result; } void Options::generate_group_help(String& result, const std::vector& groups) const { for (std::size_t i = 0; i < groups.size(); ++i) { String const& group_help = help_one_group(groups[i]); if (empty(group_help)) continue; result += group_help; if (i < groups.size() - 1) { result += '\n'; } } } void Options::generate_all_groups_help(String& result) const { std::vector groups; groups.reserve(m_help.size()); for (auto& group : m_help) { groups.push_back(group.first); } generate_group_help(result, groups); } std::string Options::help(const std::vector& groups) const { String result = m_help_string + "\nUsage:\n " + toLocalString(m_program) + " [OPTION...]"; if (m_positional.size() > 0) { result += " " + toLocalString(m_positional_help); } result += "\n\n"; if (groups.size() == 0) { generate_all_groups_help(result); } else { generate_group_help(result, groups); } return toUTF8String(result); } const std::vector Options::groups() const { std::vector g; std::transform( m_help.begin(), m_help.end(), std::back_inserter(g), [] (const std::map::value_type& pair) { return pair.first; } ); return g; } const HelpGroupDetails& Options::group_help(const std::string& group) const { return m_help.at(group); } } #if defined(__GNU__) #pragma GCC diagnostic pop #endif #endif //CXX_OPTS_HPP slop-7.7/src/framebuffer.cpp000066400000000000000000000113551503006136600161300ustar00rootroot00000000000000#include #include "framebuffer.hpp" slop::Framebuffer::Framebuffer( int w, int h ) { glGenFramebuffers( 1, &fbuffer ); glBindFramebuffer( GL_FRAMEBUFFER, fbuffer ); glGenTextures( 1, &image ); glBindTexture( GL_TEXTURE_2D, image ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0 ); glBindFramebuffer( GL_FRAMEBUFFER, 0 ); // generate our vertex and uv buffers std::vector verts; std::vector uvs; verts.push_back( glm::vec2(1,1) ); uvs.push_back( glm::vec2( 1, 1 ) ); verts.push_back( glm::vec2(-1,-1) ); uvs.push_back( glm::vec2( 0, 0 ) ); verts.push_back( glm::vec2(-1,1) ); uvs.push_back( glm::vec2( 0, 1 ) ); verts.push_back( glm::vec2(-1,-1) ); uvs.push_back( glm::vec2( 0, 0 ) ); verts.push_back( glm::vec2(1,1) ); uvs.push_back( glm::vec2( 1, 1 ) ); verts.push_back( glm::vec2(1,-1) ); uvs.push_back( glm::vec2( 1, 0 ) ); glGenBuffers( 2, buffers ); glBindBuffer( GL_ARRAY_BUFFER, buffers[0] ); glBufferData( GL_ARRAY_BUFFER, verts.size() * sizeof( glm::vec2 ), &verts[0], GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, buffers[1] ); glBufferData( GL_ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], GL_STATIC_DRAW ); vertCount = verts.size(); generatedDesktopImage = false; } void slop::Framebuffer::setShader( slop::Shader* shader ) { this->shader = shader; if ( shader->hasParameter( "desktop" ) && !generatedDesktopImage ) { // Try to keep the image from being changed under our feet. XGrabServer(x11->display); XImage* image = XGetImage( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0xffffffff, ZPixmap ); XUngrabServer(x11->display); glEnable(GL_TEXTURE_2D); glGenTextures(1, &desktopImage); glBindTexture(GL_TEXTURE_2D, desktopImage); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)(&(image->data[0]))); XDestroyImage( image ); generatedDesktopImage = true; } } slop::Framebuffer::~Framebuffer() { glDeleteTextures(1, &image); glDeleteFramebuffers(1,&fbuffer); glDeleteBuffers(2,buffers); } void slop::Framebuffer::resize( int w, int h ) { // Regenerate the image glDeleteTextures(1, &image); glBindTexture(GL_TEXTURE_2D, image); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Re-bind it to the framebuffer glBindFramebuffer( GL_FRAMEBUFFER, fbuffer ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); } void slop::Framebuffer::bind() { glBindFramebuffer( GL_FRAMEBUFFER, fbuffer ); } void slop::Framebuffer::unbind() { glBindFramebuffer( GL_FRAMEBUFFER, 0 ); } void slop::Framebuffer::draw(glm::vec2 mouse, float time, glm::vec4 color){ shader->bind(); shader->setParameter( "texture", 0 ); shader->setAttribute( "position", buffers[0], 2 ); shader->setAttribute( "uv", buffers[1], 2 ); if ( shader->hasParameter( "mouse" ) ) { shader->setParameter( "mouse", mouse ); } if ( shader->hasParameter( "color" ) ) { shader->setParameter( "color", color ); } if ( shader->hasParameter( "screenSize" ) ) { shader->setParameter( "screenSize", glm::vec2( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) )); } if ( shader->hasParameter( "time" ) ) { shader->setParameter( "time", time ); } glActiveTexture(GL_TEXTURE0); glBindTexture( GL_TEXTURE_2D, image ); if ( shader->hasParameter( "desktop" ) ) { shader->setParameter( "desktop", 1 ); glActiveTexture(GL_TEXTURE0 + 1); glBindTexture( GL_TEXTURE_2D, desktopImage ); } glEnable( GL_TEXTURE_2D ); glDrawArrays( GL_TRIANGLES, 0, vertCount ); glDisable( GL_TEXTURE_2D ); shader->unbind(); } slop-7.7/src/framebuffer.hpp000066400000000000000000000027751503006136600161430ustar00rootroot00000000000000/* framebuffer.hpp: Creates and manages an off-screen framebuffer. Uses supplied shader to draw it to the screen. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_FRAMEBUFFER_H_ #define N_FRAMEBUFFER_H_ #include #include #include #include #include "shader.hpp" namespace slop { class Framebuffer { private: unsigned int fbuffer; unsigned int image; unsigned int buffers[2]; unsigned int vertCount; unsigned int desktopImage; bool generatedDesktopImage; Shader* shader; public: Framebuffer( int w, int h ); ~Framebuffer(); void setShader( slop::Shader* shader ); void draw(glm::vec2 mouse, float time, glm::vec4 color); void resize( int w, int h ); void bind(); void unbind(); }; } #endif slop-7.7/src/glrectangle.cpp000066400000000000000000000243611503006136600161340ustar00rootroot00000000000000#include "glrectangle.hpp" slop::GLRectangle::GLRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) { this->color = color; this->border = border; this->padding = padding; this->highlight = highlight; // Find each corner of the rectangle ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; // Offset the inner corners by the padding. ul = ul + glm::vec2(-padding,padding); bl = bl + glm::vec2(-padding,-padding); ur = ur + glm::vec2(padding,padding); br = br + glm::vec2(padding,-padding); // Create the outer corners by offsetting the inner by the bordersize oul = ul + glm::vec2(-border,border); obl = bl + glm::vec2(-border,-border); our = ur + glm::vec2(border,border); obr = br + glm::vec2(border,-border); generateBuffers(); std::string vert = "#version 120\nattribute vec2 position;\nuniform mat4 projection;\nvoid main() {\ngl_Position = projection*vec4(position,0,1);\n}"; std::string frag = "#version 120\nuniform vec4 color;\nvoid main() {\ngl_FragColor = color;\n}"; shader = new Shader( vert, frag, false ); } void slop::GLRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) { // Find each corner of the rectangle ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; // Offset the inner corners by the padding. ul = ul + glm::vec2(-padding,padding); bl = bl + glm::vec2(-padding,-padding); ur = ur + glm::vec2(padding,padding); br = br + glm::vec2(padding,-padding); // Create the outer corners by offsetting the inner by the bordersize oul = ul + glm::vec2(-border,border); obl = bl + glm::vec2(-border,-border); our = ur + glm::vec2(border,border); obr = br + glm::vec2(border,-border); generateBuffers(); } void slop::GLRectangle::generateBuffers() { std::vector rectangle_verts; std::vector rectangle_uvs; std::vector corner_verts; std::vector corner_uvs; std::vector center_verts; std::vector center_uvs; // Top left corner corner_verts.push_back( oul ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( ul ); corner_uvs.push_back( glm::vec2(1, 0) ); corner_verts.push_back( ul + glm::vec2( -border, 0 ) ); corner_uvs.push_back( glm::vec2(0, 0) ); corner_verts.push_back( oul ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( ul + glm::vec2( 0, border ) ); corner_uvs.push_back( glm::vec2(1, 1) ); corner_verts.push_back( ul ); corner_uvs.push_back( glm::vec2(1, 0) ); // Top right corner corner_verts.push_back( ur + glm::vec2( 0, border ) ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( ur + glm::vec2( border, 0 ) ); corner_uvs.push_back( glm::vec2(1, 0) ); corner_verts.push_back( ur ); corner_uvs.push_back( glm::vec2(0, 0) ); corner_verts.push_back( ur + glm::vec2( 0, border ) ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( our ); corner_uvs.push_back( glm::vec2(1, 1) ); corner_verts.push_back( ur + glm::vec2( border, 0 ) ); corner_uvs.push_back( glm::vec2(1, 0) ); // Bottom left corner corner_verts.push_back( bl + glm::vec2( -border, 0 ) ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( obl + glm::vec2( border, 0 ) ); corner_uvs.push_back( glm::vec2(1, 0) ); corner_verts.push_back( obl ); corner_uvs.push_back( glm::vec2(0, 0) ); corner_verts.push_back( bl + glm::vec2( -border, 0 ) ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( bl ); corner_uvs.push_back( glm::vec2(1, 1) ); corner_verts.push_back( bl + glm::vec2( 0, -border ) ); corner_uvs.push_back( glm::vec2(1, 0) ); // Bottom right corner corner_verts.push_back( br ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( obr ); corner_uvs.push_back( glm::vec2(1, 0) ); corner_verts.push_back( br + glm::vec2( 0, -border ) ); corner_uvs.push_back( glm::vec2(0, 0) ); corner_verts.push_back( br ); corner_uvs.push_back( glm::vec2(0, 1) ); corner_verts.push_back( br + glm::vec2( border, 0 ) ); corner_uvs.push_back( glm::vec2(1, 1) ); corner_verts.push_back( obr ); corner_uvs.push_back( glm::vec2(1, 0) ); // Left GLRectangle rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( bl ); rectangle_uvs.push_back( glm::vec2(1, 0) ); rectangle_verts.push_back( bl + glm::vec2( -border, 0 ) ); rectangle_uvs.push_back( glm::vec2(0, 0) ); rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( ul ); rectangle_uvs.push_back( glm::vec2(1, 1) ); rectangle_verts.push_back( bl ); rectangle_uvs.push_back( glm::vec2(1, 0) ); // Right GLRectangle rectangle_verts.push_back( ur ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( br + glm::vec2( border, 0 ) ); rectangle_uvs.push_back( glm::vec2(1, 0) ); rectangle_verts.push_back( br ); rectangle_uvs.push_back( glm::vec2(0, 0) ); rectangle_verts.push_back( ur ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( ur + glm::vec2( border, 0 ) ); rectangle_uvs.push_back( glm::vec2(1, 1) ); rectangle_verts.push_back( br + glm::vec2( border, 0 ) ); rectangle_uvs.push_back( glm::vec2(1, 0) ); // Top GLRectangle rectangle_verts.push_back( ul + glm::vec2( 0, border ) ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( ur ); rectangle_uvs.push_back( glm::vec2(1, 0) ); rectangle_verts.push_back( ul ); rectangle_uvs.push_back( glm::vec2(0, 0) ); rectangle_verts.push_back( ul + glm::vec2( 0, border ) ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( ur + glm::vec2( 0, border ) ); rectangle_uvs.push_back( glm::vec2(1, 1) ); rectangle_verts.push_back( ur ); rectangle_uvs.push_back( glm::vec2(1, 0) ); // Bot GLRectangle rectangle_verts.push_back( bl ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( br + glm::vec2( 0, -border ) ); rectangle_uvs.push_back( glm::vec2(1, 0) ); rectangle_verts.push_back( bl + glm::vec2( 0, -border ) ); rectangle_uvs.push_back( glm::vec2(0, 0) ); rectangle_verts.push_back( bl ); rectangle_uvs.push_back( glm::vec2(0, 1) ); rectangle_verts.push_back( br ); rectangle_uvs.push_back( glm::vec2(1, 1) ); rectangle_verts.push_back( br + glm::vec2( 0, -border ) ); rectangle_uvs.push_back( glm::vec2(1, 0) ); center_verts.push_back( ul ); center_uvs.push_back( glm::vec2(0, 1) ); center_verts.push_back( br ); center_uvs.push_back( glm::vec2(1, 0) ); center_verts.push_back( bl ); center_uvs.push_back( glm::vec2(0, 0) ); center_verts.push_back( ul ); center_uvs.push_back( glm::vec2(0, 1) ); center_verts.push_back( ur ); center_uvs.push_back( glm::vec2(1, 1) ); center_verts.push_back( br ); center_uvs.push_back( glm::vec2(1, 0) ); glGenBuffers( 6, (GLuint*)&buffer ); glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_verts ); glBufferData( GL_ARRAY_BUFFER, corner_verts.size() * sizeof( glm::vec2 ), &corner_verts[0], GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_uvs ); glBufferData( GL_ARRAY_BUFFER, corner_uvs.size() * sizeof( glm::vec2 ), &corner_uvs[0], GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_verts ); glBufferData( GL_ARRAY_BUFFER, rectangle_verts.size() * sizeof( glm::vec2 ), &rectangle_verts[0], GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs ); glBufferData( GL_ARRAY_BUFFER, rectangle_uvs.size() * sizeof( glm::vec2 ), &rectangle_uvs[0], GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, buffer.center_verts ); glBufferData( GL_ARRAY_BUFFER, center_verts.size() * sizeof( glm::vec2 ), ¢er_verts[0], GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs ); glBufferData( GL_ARRAY_BUFFER, center_uvs.size() * sizeof( glm::vec2 ), ¢er_uvs[0], GL_STATIC_DRAW ); corner_vertCount = corner_verts.size(); rectangle_vertCount = rectangle_verts.size(); center_vertCount = center_verts.size(); } slop::GLRectangle::~GLRectangle() { delete shader; glDeleteBuffers( 6, (GLuint*)&buffer ); } void slop::GLRectangle::draw( glm::mat4& matrix ) { glEnable( GL_BLEND ); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); shader->bind(); shader->setParameter( "projection", matrix ); if ( highlight ) { // Draw the center of the highlight shader->setParameter( "color", color ); shader->setAttribute( "position", buffer.center_verts, 2 ); glDrawArrays(GL_TRIANGLES, 0, center_vertCount ); // Set the color to have no alpha, then draw the borders. glm::vec4 fullAlpha = glm::vec4(color.r,color.g,color.b,1); shader->setParameter( "color", fullAlpha ); shader->setAttribute( "position", buffer.corner_verts, 2 ); glDrawArrays(GL_TRIANGLES, 0, corner_vertCount ); shader->setAttribute( "position", buffer.rectangle_verts, 2 ); glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount ); } else { shader->setParameter( "color", color ); shader->setAttribute( "position", buffer.corner_verts, 2 ); glDrawArrays(GL_TRIANGLES, 0, corner_vertCount ); shader->setAttribute( "position", buffer.rectangle_verts, 2 ); glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount ); } shader->unbind(); glDisable( GL_BLEND ); } glm::vec4 slop::GLRectangle::getRect() { return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y ); } slop-7.7/src/glrectangle.hpp000066400000000000000000000036771503006136600161500ustar00rootroot00000000000000/* rectangle.hpp: generates a vertex mesh and draws it. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_GLRECTANGLE_H_ #define N_GLRECTANGLE_H_ #include #include #include #include #include #include "shader.hpp" #include "rectangle.hpp" namespace slop { struct RectangleBuffer { unsigned int corner_verts; unsigned int corner_uvs; unsigned int rectangle_verts; unsigned int rectangle_uvs; unsigned int center_verts; unsigned int center_uvs; }; class GLRectangle : public Rectangle { private: glm::vec2 ul, oul; glm::vec2 bl, obl; glm::vec2 ur, our; glm::vec2 br, obr; bool highlight; void generateBuffers(); RectangleBuffer buffer; unsigned int corner_vertCount; unsigned int rectangle_vertCount; unsigned int center_vertCount; float border; float padding; Shader* shader; glm::vec4 color; public: glm::vec4 getRect(); GLRectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false ); ~GLRectangle(); void setPoints( glm::vec2 p1, glm::vec2 p2 ); void draw(glm::mat4& matrix); }; } #endif // N_RECTANGLE_H_ slop-7.7/src/keyboard.cpp000066400000000000000000000053151503006136600154430ustar00rootroot00000000000000#include #include #include "keyboard.hpp" bool slop::Keyboard::getKey( KeySym key ) { KeyCode keycode = XKeysymToKeycode( x11->display, key ); if ( keycode != 0 ) { // Get the whole keyboard state char keys[32]; XQueryKeymap( x11->display, keys ); // Check our keycode return ( keys[ keycode / 8 ] & ( 1 << ( keycode % 8 ) ) ) != 0; } else { return false; } } // This returns if a key is currently pressed. // Ignores arrow key presses specifically so users can // adjust their selection. bool slop::Keyboard::anyKeyDown() { return keyDown; } void slop::Keyboard::update() { char keys[32]; XQueryKeymap( x11->display, keys ); // We first delete the arrow key buttons from the mapping. // This allows the user to press the arrow keys without triggering anyKeyDown KeyCode keycode = XKeysymToKeycode( x11->display, XK_Left ); keys[ keycode / 8 ] = keys[ keycode / 8 ] & ~( 1 << ( keycode % 8 ) ); keycode = XKeysymToKeycode( x11->display, XK_Right ); keys[ keycode / 8 ] = keys[ keycode / 8 ] & ~( 1 << ( keycode % 8 ) ); keycode = XKeysymToKeycode( x11->display, XK_Up ); keys[ keycode / 8 ] = keys[ keycode / 8 ] & ~( 1 << ( keycode % 8 ) ); keycode = XKeysymToKeycode( x11->display, XK_Down ); keys[ keycode / 8 ] = keys[ keycode / 8 ] & ~( 1 << ( keycode % 8 ) ); // Also deleting Space for move operation keycode = XKeysymToKeycode( x11->display, XK_space ); keys[ keycode / 8 ] = keys[ keycode / 8 ] & ~( 1 << ( keycode % 8 ) ); keyDown = false; for ( int i=0;i<32;i++ ) { if ( deltaState[i] == keys[i] ) { continue; } // Found a key in a group of 4 that's different char a = deltaState[i]; char b = keys[i]; // Find the "different" bits char c = a^b; // A new key was pressed since the last update. if ( c && b&c ) { keyDown = true; } deltaState[i] = keys[i]; } } slop::Keyboard::Keyboard( X11* x11 ) { this->x11 = x11; int err = XGrabKeyboard( x11->display, x11->root, False, GrabModeAsync, GrabModeAsync, CurrentTime ); int tries = 0; while( err != GrabSuccess && tries < 5 ) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); err = XGrabKeyboard( x11->display, x11->root, False, GrabModeAsync, GrabModeAsync, CurrentTime ); tries++; } // Non-fatal. if ( err != GrabSuccess ) { //throw std::runtime_error( "Couldn't grab the keyboard after 10 tries." ); } XQueryKeymap( x11->display, deltaState ); keyDown = false; } slop::Keyboard::~Keyboard() { XUngrabKeyboard( x11->display, CurrentTime ); } slop-7.7/src/keyboard.hpp000066400000000000000000000023741503006136600154520ustar00rootroot00000000000000/* keyboard.hpp: Interfaces with x11 to grab key press information. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_KEYBOARD_H_ #define N_KEYBOARD_H_ #define XK_MISCELLANY #define XK_LATIN1 // for XK_space #include #include "x.hpp" namespace slop { class Keyboard { private: char deltaState[32]; X11* x11; bool keyDown; public: Keyboard( X11* x11 ); ~Keyboard(); void update(); bool getKey( KeySym key ); bool anyKeyDown(); }; extern Keyboard* keyboard; } #endif // N_KEYBOARD_H_ slop-7.7/src/main.cpp000066400000000000000000000372231503006136600145720ustar00rootroot00000000000000/* main.cpp: parses options, runs slop, prints results. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #include #include #include #include #include #include "slop.hpp" #include "cxxopts.hpp" using namespace slop; glm::vec4 parseColor( std::string value ) { std::string valuecopy = value; glm::vec4 found; std::string::size_type sz; try { found[0] = std::stof(value,&sz); value = value.substr(sz+1); found[1] = std::stof(value,&sz); value = value.substr(sz+1); found[2] = std::stof(value,&sz); if ( value.size() != sz ) { value = value.substr(sz+1); found[3] = std::stof(value,&sz); if ( value.size() != sz ) { throw std::runtime_error("dur"); } } else { found[3] = 1; } } catch ( ... ) { throw std::invalid_argument("Unable to parse value `" + valuecopy + "` as a color. Should be in the format r,g,b or r,g,b,a. Like 1,1,1,1."); } return found; } SlopOptions* getOptions( cxxopts::Options& options ) { slop::SlopOptions* foo = new slop::SlopOptions(); if ( options.count( "bordersize" ) > 0 ) { foo->border = options["bordersize"].as(); } if ( options.count( "padding" ) > 0 ) { foo->padding = options["padding"].as(); } if ( options.count( "tolerance" ) > 0 ) { foo->tolerance = options["tolerance"].as(); } glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a ); if ( options.count( "color" ) > 0 ) { color = parseColor( options["color"].as() ); } foo->r = color.r; foo->g = color.g; foo->b = color.b; foo->a = color.a; if ( options.count( "nokeyboard" ) > 0 ) { foo->nokeyboard = options["nokeyboard"].as(); } if ( options.count( "xdisplay" ) > 0 ) { std::string xdisplay = options["xdisplay"].as(); char* cxdisplay = new char[xdisplay.length()+1]; memcpy( cxdisplay, xdisplay.c_str(), xdisplay.length() ); cxdisplay[xdisplay.length()]='\0'; foo->xdisplay = cxdisplay; } if ( options.count( "shader" ) > 0 ) { std::string shaders = options["shader"].as(); char* cshaders = new char[shaders.length()+1]; memcpy( cshaders, shaders.c_str(), shaders.length() ); cshaders[shaders.length()]='\0'; foo->shaders = cshaders; } if ( options.count( "noopengl" ) > 0 ) { foo->noopengl = options["noopengl"].as(); } if ( options.count( "highlight" ) > 0 ) { foo->highlight = options["highlight"].as(); } if ( options.count( "nodrag" ) > 0 ) { foo->nodrag = options["nodrag"].as(); } if ( options.count( "quiet" ) > 0 ) { foo->quiet = options["quiet"].as(); } if ( options.count( "nodecorations" ) > 0 ) { foo->nodecorations = options["nodecorations"].as(); if ( foo->nodecorations < 0 || foo->nodecorations > 2 ) { throw std::invalid_argument( "--nodecorations must be between 0 and 2. Or be used as a flag." ); } } return foo; } std::string formatOutput( std::string input, SlopSelection selection ) { std::stringstream output; for( unsigned int i=0;i()) ("f,format", "Sets the output format for slop. Format specifiers are %x, %y, %w, %h, %i, %c, and %g. If actual percentage signs are desired in output, use a double percentage sign like so `%%`.", cxxopts::value()) ("b,bordersize", "Sets the selection rectangle's thickness.", cxxopts::value()) ("p,padding", "Sets the padding size for the selection, this can be negative.", cxxopts::value()) ("t,tolerance", "How far in pixels the mouse can move after clicking, and still be detected as a normal click instead of a click-and-drag. Setting this to 0 will disable window selections. Alternatively setting it to 9999999 would force a window selection.", cxxopts::value()) ("D,nodrag", "Select region with two clicks instead of click and drag") ("c,color", "Sets the selection rectangle's color. Supports RGB or RGBA input. Depending on the system's window manager/OpenGL support, the opacity may be ignored.", cxxopts::value()) ("r,shader", "This sets the vertex shader, and fragment shader combo to use when drawing the final framebuffer to the screen. This obviously only works when OpenGL is enabled. The shaders are loaded from ~/.config/maim. See https://github.com/naelstrof/slop for more information on how to create your own shaders.", cxxopts::value()) ("n,nodecorations", "Sets the level of aggressiveness when trying to remove window decorations. `0' is off, `1' will try lightly to remove decorations, and `2' will recursively descend into the root tree until it gets the deepest available visible child under the mouse. Defaults to `0'.", cxxopts::value()->implicit_value("1")) ("l,highlight", "Instead of outlining a selection, maim will highlight it instead. This is particularly useful if the color is set to an opacity lower than 1.") ("q,quiet", "Disable any unnecessary cerr output. Any warnings or info simply won't print.") ("k,nokeyboard", "Disables the ability to cancel selections with the keyboard.") ("o,noopengl", "Disables graphics hardware acceleration.") ("positional", "Positional parameters", cxxopts::value>()) ; options.parse_positional("positional"); options.parse(argc, argv); // Options just validates all of our input from argv auto& positional = options["positional"].as>(); if ( positional.size() > 0 ) { throw std::invalid_argument("Unexpected positional argument: " + positional[0]); } bool help = false; if ( options.count( "help" ) > 0 ) { help = options["help"].as(); } if ( help ) { printHelp(); return 0; } bool version = false; if ( options.count( "version" ) > 0 ) { version = options["version"].as(); } if ( version ) { std::cout << SLOP_VERSION << "\n"; return 0; } // We then parse the options into something slop can understand. SlopOptions* parsedOptions = getOptions( options ); // We want to validate our format option if we got one, we do that by just doing a dry run // on a fake selection. SlopSelection selection(0,0,0,0,0,true); std::string format; bool gotFormat = options.count( "format" ) > 0; if ( gotFormat ) { format = options["format"].as(); formatOutput( format, selection ); } // Finally we do the real selection. selection = SlopSelect(parsedOptions); bool quiet = parsedOptions->quiet; // Here we're done with the parsed option data. delete parsedOptions; // We know if we cancelled or not if ( selection.cancelled ) { if ( !quiet ) { std::cerr << "Selection was cancelled by keystroke or right-click.\n"; } return 1; } // If we recieved a format option, we output the specified output. if ( gotFormat ) { std::cout << formatOutput( format, selection ); return 0; } std::cout << formatOutput( "%g\n", selection ); return 0; } int main( int argc, char** argv ) { try { return app( argc, argv ); } catch( std::exception& e ) { std::cerr << "Slop encountered an error:\n" << e.what() << "\n"; return 1; } // let the operating system handle any other kind of exception. return 1; } slop-7.7/src/mouse.cpp000066400000000000000000000114151503006136600147710ustar00rootroot00000000000000#include #include #include "mouse.hpp" void slop::Mouse::setButton( int button, int state ) { for (unsigned int i=0;idisplay, x11->root, &root, &child, &mx, &my, &wx, &wy, &mask ); return glm::vec2( mx, my ); } void slop::Mouse::setCursor( int cursor ) { if ( currentCursor == cursor ) { return; } XFreeCursor( x11->display, xcursor ); xcursor = XCreateFontCursor( x11->display, cursor ); XChangeActivePointerGrab( x11->display, PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask, xcursor, CurrentTime ); } slop::Mouse::Mouse(X11* x11, int nodecorations, Window ignoreWindow ) { this->x11 = x11; currentCursor = XC_cross; xcursor = XCreateFontCursor( x11->display, XC_cross ); hoverWindow = None; int err = XGrabPointer( x11->display, x11->root, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask, GrabModeAsync, GrabModeAsync, None, xcursor, CurrentTime ); int tries = 0; while( err != GrabSuccess && tries < 5 ) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); err = XGrabPointer( x11->display, x11->root, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask, GrabModeAsync, GrabModeAsync, None, xcursor, CurrentTime ); tries++; } if ( err != GrabSuccess ) { throw std::runtime_error( "Couldn't grab the mouse after 10 tries." ); } this->nodecorations = nodecorations; this->ignoreWindow = ignoreWindow; hoverWindow = findWindow(x11->root); } slop::Mouse::~Mouse() { XUngrabPointer( x11->display, CurrentTime ); } void slop::Mouse::update() { XEvent event; while ( XCheckTypedEvent( x11->display, ButtonPress, &event ) ) { setButton( event.xbutton.button, 1 ); } bool findNewWindow = false; while ( XCheckTypedEvent( x11->display, MotionNotify, &event ) ) { findNewWindow = true; } if ( findNewWindow ) { hoverWindow = findWindow(x11->root); } while ( XCheckTypedEvent( x11->display, ButtonRelease, &event ) ) { setButton( event.xbutton.button, 0 ); } while ( XCheckTypedEvent( x11->display, EnterNotify, &event ) ) { hoverWindow = event.xcrossing.window; } } Window slop::Mouse::findWindow( Window foo ) { glm::vec2 pos = getMousePos(); Window root, parent; Window* children; unsigned int nchildren; Window selectedWindow; XQueryTree( x11->display, foo, &root, &parent, &children, &nchildren ); if ( !children || nchildren <= 0 ) { return foo; } // The children are ordered, so we traverse backwards. for( int i=nchildren-1;i>=0;i-- ) { if ( children[i] == ignoreWindow ) { continue; } // We need to make sure the window is mapped. XWindowAttributes attr; XGetWindowAttributes( x11->display, children[i], &attr ); if ( attr.map_state != IsViewable ) { continue; } // We need to make sure we can get pixel data from it as well if ( attr.c_class == InputOnly ) { continue; } glm::vec4 rect = getWindowGeometry(children[i], false); float a = pos.x - rect.x; float b = pos.y - rect.y; if ( a <= rect.z && a >= 0 ) { if ( b <= rect.w && b >= 0 ) { selectedWindow = children[i]; switch( nodecorations ) { case 0: XFree(children); return selectedWindow; case 1: XFree(children); //return findWindow( selectedWindow ); XQueryTree( x11->display, selectedWindow, &root, &parent, &children, &nchildren ); if ( !children || nchildren <= 0 ) { return selectedWindow; } return children[nchildren-1]; case 2: return findWindow( selectedWindow ); } } } } return foo; } slop-7.7/src/mouse.hpp000066400000000000000000000027641503006136600150050ustar00rootroot00000000000000/* mouse.hpp: Interfaces with x11 to grab mouse information. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_MOUSE_H_ #define N_MOUSE_H_ #include #include #include #include #include "x.hpp" namespace slop { class Mouse { private: X11* x11; std::vector buttons; Cursor xcursor; int currentCursor; Window findWindow( Window foo ); int nodecorations; Window ignoreWindow; public: Window hoverWindow; void update(); Mouse( X11* x11, int nodecorations, Window ignoreWindow ); ~Mouse(); void setCursor( int cursor ); glm::vec2 getMousePos(); void setButton( int button, int state ); int getButton( int button ); }; extern Mouse* mouse; } #endif // N_MOUSE_H_ slop-7.7/src/rectangle.cpp000066400000000000000000000004221503006136600156010ustar00rootroot00000000000000#include "rectangle.hpp" slop::Rectangle::Rectangle() { } slop::Rectangle::~Rectangle() { } void slop::Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) { } void slop::Rectangle::draw(glm::mat4& matrix) { } glm::vec4 slop::Rectangle::getRect() { return glm::vec4(); } slop-7.7/src/rectangle.hpp000066400000000000000000000021601503006136600156070ustar00rootroot00000000000000/* rectangle.hpp: Rectangle generic * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_RECTANGLE_H_ #define N_RECTANGLE_H_ #include namespace slop { class Rectangle { public: Rectangle(); virtual glm::vec4 getRect(); virtual ~Rectangle(); virtual void setPoints( glm::vec2 p1, glm::vec2 p2 ); virtual void draw(glm::mat4& matrix); }; } #endif // N_RECTANGLE_H_ slop-7.7/src/resource.cpp000066400000000000000000000040641503006136600154720ustar00rootroot00000000000000/* resource.cpp: Handles converting local paths to full paths. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #include "resource.hpp" slop::Resource::Resource() { // Find the configuration directory. // usually ~/.config/slop and /usr/share/slop char* config = getenv( "XDG_CONFIG_HOME" ); if ( config == NULL ) { char* home = getpwuid(getuid())->pw_dir; usrconfig += home; usrconfig += "/.config/slop/"; return; } usrconfig += config; usrconfig += "/slop/"; } std::string slop::Resource::getRealPath( const std::string& localpath ) { if (localpath[0] == '/' && validatePath(dirname(localpath))) { return localpath; } if ( validatePath( usrconfig + localpath ) ) { return usrconfig + localpath; } std::string err = "The file or folder " + localpath + " was not found in " + usrconfig + "\n"; throw std::runtime_error(err); return localpath; } std::string slop::Resource::dirname(const std::string& localpath) { size_t i = localpath.find_last_of("/"); return (i != std::string::npos ? localpath.substr(0, i) : localpath); } bool slop::Resource::validatePath( const std::string& path ) { struct stat st; const char* dirname = path.c_str(); if ( stat( dirname, &st ) != 0 ) { return false; } // Lookin' good! return true; } slop-7.7/src/resource.hpp000066400000000000000000000026341503006136600155000ustar00rootroot00000000000000/* resource.hpp: Handles getting resources like textures and stuff. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_RESOURCE_H_ #define N_RESOURCE_H_ #include #include #include #include #include #include #include #include #include #include #include namespace slop { class Resource { public: Resource(); std::string getRealPath( const std::string& localpath ); private: std::string dirname(const std::string& localpath); bool validatePath( const std::string& path ); std::string usrconfig; }; extern Resource* resource; } #endif // IS_RESOURCE_H_ slop-7.7/src/shader.cpp000066400000000000000000000133361503006136600151130ustar00rootroot00000000000000#include "shader.hpp" slop::Shader::Shader( std::string vert, std::string frag, bool file ) { std::string vert_contents; std::string frag_contents; if ( file ) { vert = resource->getRealPath(vert); frag = resource->getRealPath(frag); std::ifstream v( vert.c_str() ); if (!v.is_open()) { throw std::runtime_error( "Failed to open " + vert ); } vert_contents = std::string((std::istreambuf_iterator(v)), std::istreambuf_iterator()); std::ifstream f( frag.c_str() ); if (!f.is_open()) { throw std::runtime_error( "Failed to open " + frag ); } frag_contents = std::string((std::istreambuf_iterator(f)), std::istreambuf_iterator()); } else { vert_contents = vert; frag_contents = frag; } const char* vertsrc = vert_contents.c_str(); const char* fragsrc = frag_contents.c_str(); // Create the program to link to. program = glCreateProgram(); if ( vert_contents.length() <= 0 ) { std::string errstring = "Failed to open file (or is empty) `" + vert + "`.\n"; throw std::runtime_error(errstring); } if ( frag_contents.length() <= 0 ) { std::string errstring = "Failed to open file (or is empty) `" + frag + "`.\n"; throw std::runtime_error(errstring); } // Compile both shaders. unsigned int vertShader = glCreateShader( GL_VERTEX_SHADER ); glShaderSource( vertShader, 1, &vertsrc , NULL ); std::string errortxt; int err = compile( vertShader, errortxt ); if ( err ) { std::string errstring = "Failed to compile shader `" + vert + "`:\n" + errortxt; throw std::runtime_error(errstring); glDeleteShader( vertShader ); return; } unsigned int fragShader = glCreateShader( GL_FRAGMENT_SHADER ); glShaderSource( fragShader, 1, &fragsrc, NULL ); err = compile( fragShader, errortxt ); if ( err ) { std::string errstring = "Failed to compile shader `" + frag + "`:\n" + errortxt; throw std::runtime_error(errstring); glDeleteShader( vertShader ); glDeleteShader( fragShader ); return; } // Then attempt to link them to this shader. err = link( vertShader, fragShader, errortxt ); if ( err ) { std::string errstring = "Failed to link shader `" + vert + "` and `" + frag + "`:\n" + errortxt; throw std::runtime_error(errstring); glDeleteShader( vertShader ); glDeleteShader( fragShader ); return; } // Clean up :) glDeleteShader( vertShader ); glDeleteShader( fragShader ); glUseProgram( 0 ); } slop::Shader::~Shader() { glDeleteProgram( program ); } unsigned int slop::Shader::getProgram() { return program; } void slop::Shader::bind() { glUseProgram( program ); } int slop::Shader::compile( unsigned int shader, std::string& error ) { glCompileShader( shader ); // Compiling the shader is the easy part, all this junk down here is for printing the error it might generate. int result; int logLength; glGetShaderiv( shader, GL_COMPILE_STATUS, &result ); glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logLength ); if ( result == false ) { char* errormsg = new char[ logLength ]; glGetShaderInfoLog( shader, logLength, NULL, errormsg ); error = errormsg; delete[] errormsg; return 1; } return 0; } int slop::Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) { glAttachShader( program, vertshader ); glAttachShader( program, fragshader ); glLinkProgram( program ); // Linking the shader is the easy part, all this junk down here is for printing the error it might generate. int result = false; int logLength; glGetProgramiv( program, GL_LINK_STATUS, &result); glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logLength); if ( result == false ) { char* errormsg = new char[ logLength ]; glGetProgramInfoLog( program, logLength, NULL, errormsg ); error = errormsg; delete[] errormsg; return 1; } return 0; } unsigned int slop::Shader::getUniformLocation( std::string name ) { glUseProgram( program ); return glGetUniformLocation( program, name.c_str() ); } bool slop::Shader::hasParameter( std::string name ) { glUseProgram( program ); return glGetUniformLocation( program, name.c_str() ) != -1; } void slop::Shader::setParameter( std::string name, int foo ) { glUniform1i( getUniformLocation( name ), foo ); } void slop::Shader::setParameter( std::string name, float foo ) { glUniform1f( getUniformLocation( name ), foo ); } void slop::Shader::setParameter( std::string name, glm::mat4& foo ) { glUniformMatrix4fv( getUniformLocation( name ), 1, false, glm::value_ptr( foo ) ); } void slop::Shader::setParameter( std::string name, glm::vec4 foo ) { glUniform4f( getUniformLocation( name ), foo.x, foo.y, foo.z, foo.w ); } void slop::Shader::setParameter( std::string name, glm::vec2 foo ) { glUniform2f( getUniformLocation( name ), foo.x, foo.y ); } void slop::Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) { unsigned int a = glGetAttribLocation( program, name.c_str() ); glEnableVertexAttribArray( a ); glBindBuffer( GL_ARRAY_BUFFER, buffer ); glVertexAttribPointer( a, stepsize, GL_FLOAT, false, 0, NULL ); activeAttributes.push_back( a ); } void slop::Shader::unbind() { for ( unsigned int i=0; i. */ #ifndef N_SHADER_H_ #define N_SHADER_H_ #include #include #include #include #include #include #include #include #include #include "resource.hpp" #include "x.hpp" namespace slop { class Shader { public: Shader( std::string vert, std::string frag, bool file = true ); ~Shader(); unsigned int getProgram(); void bind(); void unbind(); bool hasParameter( std::string name ); void setParameter( std::string name, int foo ); void setParameter( std::string name, float foo ); void setParameter( std::string name, glm::mat4& foo ); void setParameter( std::string name, glm::vec4 foo ); void setParameter( std::string name, glm::vec2 foo ); void setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ); private: std::vector activeAttributes; unsigned int getUniformLocation( std::string ); int compile( unsigned int shader, std::string& error ); int link( unsigned int vert, unsigned int frag, std::string& error ); unsigned int program; }; } #endif // N_SHADER_H_ slop-7.7/src/slop.cpp000066400000000000000000000331531503006136600146210ustar00rootroot00000000000000#ifdef SLOP_OPENGL #include #include #endif #include #include #include #include #include #include "slopstates.hpp" #include "mouse.hpp" #include "resource.hpp" #include "keyboard.hpp" #ifdef SLOP_OPENGL #include "window.hpp" #include "shader.hpp" #include "framebuffer.hpp" #include "glrectangle.hpp" #endif #include "xshaperectangle.hpp" #include "slop.hpp" namespace slop { X11* x11; Mouse* mouse; Keyboard* keyboard; Resource* resource; #ifdef SLOP_OPENGL SlopSelection GLSlopSelect( slop::SlopOptions* options, slop::SlopWindow* window ); #endif SlopSelection XShapeSlopSelect( slop::SlopOptions* options ); static int TmpXError(Display * d, XErrorEvent * ev) { return 0; } } template static void split(const std::string &s, char delim, Out result) { std::stringstream ss; ss.str(s); std::string item; while (std::getline(ss, item, delim)) { *(result++) = item; } } static std::vector split(const std::string &s, char delim) { std::vector elems; split(s, delim, std::back_inserter(elems)); return elems; } using namespace slop; char slop_default_xdisplay[] = ":0"; char slop_default_shaders[] = "textured"; // Defaults! slop::SlopOptions::SlopOptions() { border = 1; nokeyboard = false; noopengl = false; nodrag = false; nodecorations = false; tolerance = 2; padding = 0; shaders = slop_default_shaders; highlight = false; r = 0.5; g = 0.5; b = 0.5; a = 1; quiet = false; char* envdisplay = getenv("DISPLAY"); if (envdisplay == NULL) { xdisplay = slop_default_xdisplay; } else { xdisplay = envdisplay; } } slop::SlopSelection::SlopSelection( float x, float y, float w, float h, int id, bool cancelled ) { this->x = x; this->y = y; this->w = w; this->h = h; this->id = id; this->cancelled = cancelled; } slop::SlopSelection slop::SlopSelect( slop::SlopOptions* options ) { slop::SlopSelection returnval(0,0,0,0,0,true); bool deleteOptions = false; if ( !options ) { deleteOptions = true; options = new slop::SlopOptions(); } resource = new Resource(); // Set up x11 temporarily x11 = new X11(options->xdisplay); if ( !options->nokeyboard ) { XErrorHandler ph = XSetErrorHandler(slop::TmpXError); keyboard = new Keyboard( x11 ); XSetErrorHandler(ph); } #ifdef SLOP_OPENGL bool success = false; std::string errorstring = ""; SlopWindow* window; // First we check if we have a compositor available if ( x11->hasCompositor() && !options->noopengl ) { // If we have a compositor, we try using OpenGL try { window = new SlopWindow(); if (!GLEW_VERSION_3_0) { delete window; throw std::runtime_error( "OpenGL version is not high enough, slop requires OpenGL 3.0!\nOpenGL acceleration is disabled. Use -o or -q to suppress this message." ); } success = true; } catch( std::exception& e ) { errorstring += std::string(e.what()) + "\n"; success = false; } catch (...) { success = false; } } else { errorstring += "Failed to detect a compositor, OpenGL hardware-acceleration disabled...\n"; } if ( !success ) { // If we fail, we launch the XShape version of slop. if ( !options->quiet && !options->noopengl ) { if ( errorstring.length() <= 0 ) { errorstring += "Failed to launch OpenGL context, --shader parameter will be ignored.\n"; std::cerr << errorstring; } else { std::cerr << errorstring; } } #endif // SLOP_OPENGL returnval = slop::XShapeSlopSelect( options ); #ifdef SLOP_OPENGL } else { returnval = slop::GLSlopSelect( options, window ); } #endif delete x11; delete slop::resource; if ( deleteOptions ) { delete options; } return returnval; } slop::SlopSelection slop::XShapeSlopSelect( slop::SlopOptions* options ) { // Init our little state machine, memory is a tad of a misnomer bool cancelled = false; slop::SlopMemory* memory = new slop::SlopMemory( options, new XShapeRectangle(glm::vec2(0,0), glm::vec2(0,0), options->border, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) ); slop::mouse = new slop::Mouse( x11, options->nodecorations, ((XShapeRectangle*)memory->rectangle)->window ); // We have no GL context, so the matrix is useless... glm::mat4 fake; // This is where we'll run through all of our stuffs auto last = std::chrono::high_resolution_clock::now(); while( memory->running ) { slop::mouse->update(); if ( !options->nokeyboard ) { slop::keyboard->update(); } // We move our statemachine forward. auto current = std::chrono::high_resolution_clock::now(); std::chrono::duration frametime = current-last; last = current; memory->update( frametime.count()/1000.f ); // We don't actually draw anything, but the state machine uses // this to know when to spawn the window. memory->draw( fake ); // X11 explodes if we update as fast as possible, here's a tiny sleep. XSync(x11->display, False); // Then we draw the framebuffer to the screen if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) { memory->running = false; cancelled = true; } } // Now we should have a selection! We parse everything we know about it here. glm::vec4 output = memory->rectangle->getRect(); // Lets now clear both front and back buffers before closing. // hopefully it'll be completely transparent while closing! // Then we clean up. delete slop::mouse; Window selectedWindow = memory->selectedWindow; delete memory; // Try to detect the window dying. int tries = 0; while( tries < 50 ) { XEvent event; if ( XCheckTypedEvent( x11->display, UnmapNotify, &event ) ) { break; } if ( XCheckTypedEvent( x11->display, DestroyNotify, &event ) ) { break; } std::this_thread::sleep_for(std::chrono::milliseconds(10)); tries++; } // Finally return the data. return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow, cancelled ); } #ifdef SLOP_OPENGL slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, SlopWindow* window ) { bool cancelled = false; slop::mouse = new slop::Mouse( x11, options->nodecorations, window->window ); std::string vert = "#version 120\nattribute vec2 position;\nattribute vec2 uv;\nvarying vec2 uvCoord;\nvoid main()\n{\nuvCoord = uv;\ngl_Position = vec4(position,0,1);\n}\n"; std::string frag = "#version 120\nuniform sampler2D texture;\nvarying vec2 uvCoord;\nvoid main()\n {\ngl_FragColor = texture2D( texture, uvCoord );\n}\n"; slop::Shader* textured = new slop::Shader( vert, frag, false ); std::vector shaders; std::vector stringShaders = split( options->shaders, ',' ); for( int i=0;iborder, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) ); slop::Framebuffer *ball = new slop::Framebuffer(WidthOfScreen(x11->screen), HeightOfScreen(x11->screen)); slop::Framebuffer *ping, *pong; // This is where we'll run through all of our stuffs auto start = std::chrono::high_resolution_clock::now(); auto last = start; while( memory->running ) { slop::mouse->update(); if ( !options->nokeyboard ) { slop::keyboard->update(); } // We move our statemachine forward. auto current = std::chrono::high_resolution_clock::now(); std::chrono::duration frametime = current-last; last = current; memory->update( frametime.count()/1000.f ); // Then we draw our junk to a framebuffer. window->framebuffer->setShader( textured ); window->framebuffer->bind(); glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT); memory->draw( window->camera ); window->framebuffer->unbind(); std::chrono::duration elapsed = current-start; ping=ball; pong=window->framebuffer; // We have our clean buffer, now to slather it with some juicy shader chains. glEnable( GL_BLEND ); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); for (int i=0; i < shaders.size() - 1; i++) { ping->bind(); glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT); pong->setShader( shaders[i] ); pong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) ); ping->unbind(); std::swap(ping, pong); } glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT); pong->setShader( shaders[shaders.size() - 1] ); pong->draw(slop::mouse->getMousePos(), elapsed.count()/1000.f, glm::vec4( options->r, options->g, options->b, options->a ) ); glDisable( GL_BLEND ); window->display(); // Here we sleep just to prevent our CPU usage from going to 100%. std::this_thread::sleep_for(std::chrono::milliseconds(10)); GLenum err = glGetError(); if ( err != GL_NO_ERROR ) { std::string error; switch(err) { case GL_INVALID_OPERATION: error="INVALID_OPERATION"; break; case GL_INVALID_ENUM: error="INVALID_ENUM"; break; case GL_INVALID_VALUE: error="INVALID_VALUE"; break; case GL_OUT_OF_MEMORY: error="OUT_OF_MEMORY"; break; case GL_INVALID_FRAMEBUFFER_OPERATION: error="INVALID_FRAMEBUFFER_OPERATION"; break; } throw std::runtime_error( "OpenGL threw an error: " + error ); } if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) { memory->running = false; cancelled = true; } } // Now we should have a selection! We parse everything we know about it here. glm::vec4 output = memory->rectangle->getRect(); // Lets now clear both front and back buffers before closing. // hopefully it'll be completely transparent while closing! glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT); window->display(); glClear (GL_COLOR_BUFFER_BIT); window->display(); // Then we clean up. for( int i=0;iselectedWindow; delete memory; // Try to detect the window dying. int tries = 0; while( tries < 50 ) { XEvent event; if ( XCheckTypedEvent( x11->display, UnmapNotify, &event ) ) { break; } if ( XCheckTypedEvent( x11->display, DestroyNotify, &event ) ) { break; } std::this_thread::sleep_for(std::chrono::milliseconds(10)); tries++; } // Finally return the data. return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow, cancelled ); } #endif extern "C" struct slop_options slop_options_default() { struct slop_options options; options.border = 1; options.nokeyboard = false; options.noopengl = false; options.nodecorations = false; options.tolerance = 2; options.padding = 0; options.shaders = slop_default_shaders; options.highlight = false; options.r = 0.5; options.g = 0.5; options.b = 0.5; options.a = 1; options.quiet = false; char* envdisplay = getenv("DISPLAY"); if (envdisplay == NULL) { options.xdisplay = slop_default_xdisplay; } else { options.xdisplay = envdisplay; } return options; } extern "C" struct slop_selection slop_select( struct slop_options* options ) { slop::SlopOptions realOptions = slop::SlopOptions(); if ( options != NULL ) { realOptions.border = options->border; realOptions.nokeyboard = options->nokeyboard; realOptions.noopengl = options->noopengl; realOptions.nodecorations = options->nodecorations; realOptions.tolerance = options->tolerance; realOptions.padding = options->padding; realOptions.shaders = options->shaders; realOptions.highlight = options->highlight; realOptions.r = options->r; realOptions.g = options->g; realOptions.b = options->b; realOptions.a = options->a; realOptions.quiet = options->quiet; realOptions.xdisplay = options->xdisplay; } slop::SlopSelection select = SlopSelect( &realOptions ); slop_selection realSelect; realSelect.x = select.x; realSelect.y = select.y; realSelect.w = select.w; realSelect.h = select.h; realSelect.id = select.id; realSelect.cancelled = select.cancelled; return realSelect; } slop-7.7/src/slop.hpp000066400000000000000000000046011503006136600146220ustar00rootroot00000000000000/* slop.hpp: exposes a selection interface * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_SLOP_H_ #define N_SLOP_H_ // Here we make some C-styled structs and function definitions, // allows other people to have a pure C interface to slop. struct slop_options { //SlopOptions(); int quiet; float border; float padding; float tolerance; int highlight; int noopengl; int nokeyboard; int nodecorations; char* shaders; float r; float g; float b; float a; char* xdisplay; }; struct slop_selection { //SlopSelection( float x, float y, float w, float h, int id, bool cancelled ); int cancelled; float x; float y; float w; float h; // This is an X11 Window ID int id; }; #ifdef __cplusplus namespace slop { class SlopOptions { public: SlopOptions(); bool quiet; float border; float padding; float tolerance; bool nodrag; bool highlight; bool noopengl; bool nokeyboard; bool nodecorations; char* shaders; float r; float g; float b; float a; char* xdisplay; }; class SlopSelection { public: SlopSelection( float x, float y, float w, float h, int id, bool cancelled ); bool cancelled; float x; float y; float w; float h; // This is an X11 Window ID int id; }; SlopSelection SlopSelect( SlopOptions* options = NULL ); } extern "C" struct slop_options slop_options_default(); extern "C" struct slop_selection slop_select( struct slop_options* options ); #else // __cplusplus struct slop_options slop_options_default(); struct slop_selection slop_select( struct slop_options* options ); #endif #endif // N_SLOP_H_ slop-7.7/src/slopstates.cpp000066400000000000000000000145531503006136600160500ustar00rootroot00000000000000#include "slopstates.hpp" using namespace slop; slop::SlopMemory::SlopMemory( SlopOptions* options, Rectangle* rect ) { up = false; running = true; state = (SlopState*)new SlopStart(); nextState = NULL; tolerance = options->tolerance; nodrag = options->nodrag; nodecorations = options->nodecorations; rectangle = rect; selectedWindow = x11->root; state->onEnter( *this ); } slop::SlopMemory::~SlopMemory() { delete state; if ( nextState ) { delete nextState; } delete rectangle; } void slop::SlopMemory::update( double dt ) { state->update( *this, dt ); if ( nextState ) { state->onExit( *this ); delete state; state = nextState; state->onEnter( *this ); nextState = NULL; } } void slop::SlopMemory::setState( SlopState* state ) { if ( nextState ) { delete nextState; } nextState = state; } void slop::SlopMemory::draw( glm::mat4& matrix ) { state->draw( *this, matrix ); } slop::SlopState::~SlopState() { } void slop::SlopState::onEnter( SlopMemory& memory ) { } void slop::SlopState::onExit( SlopMemory& memory ) { } void slop::SlopState::update( SlopMemory& memory, double dt ) { } void slop::SlopState::draw( SlopMemory& memory, glm::mat4 matrix ) { memory.rectangle->draw( matrix ); } void slop::SlopStart::onEnter( SlopMemory& memory ) { setStartPos = false; } void slop::SlopStart::update( SlopMemory& memory, double dt ) { if ( mouse->getButton( 1 ) && !setStartPos ) { startPoint = mouse->getMousePos(); setStartPos = true; } if ( setStartPos && glm::distance( startPoint, mouse->getMousePos() ) >= memory.tolerance ) { memory.setState( (SlopState*)new SlopStartDrag( startPoint ) ); } if ( mouse->hoverWindow != None ) { glm::vec4 rect = getWindowGeometry( mouse->hoverWindow, memory.nodecorations ); memory.rectangle->setPoints( glm::vec2( (float)rect.x, (float)rect.y ), glm::vec2( (float)rect.x+rect.z, (float)rect.y+rect.w ) ); } if ( (setStartPos && !mouse->getButton( 1 ) && !memory.nodrag) || (setStartPos && memory.nodrag && memory.up && mouse->getButton( 1 ) ) ) { memory.selectedWindow = mouse->hoverWindow; memory.setState( (SlopState*)new SlopEndDrag() ); } if ( setStartPos && memory.nodrag && !mouse->getButton( 1 )) { memory.up = true; } } void slop::SlopStart::draw( SlopMemory& memory, glm::mat4 matrix ) { if ( memory.tolerance > 0 ) { memory.rectangle->draw( matrix ); } } slop::SlopStartDrag::SlopStartDrag( glm::vec2 point ) { startPoint = point; } void slop::SlopStartDrag::onEnter( SlopMemory& memory ) { // redundant because it happens in upate() anyway //compensation comp = determineCompensation(); //setPoints( memory, comp ); } void slop::SlopStartDrag::update( SlopMemory& memory, double dt ) { if ( memory.nodrag && !memory.up && !mouse->getButton( 1 ) ) { memory.up = true; } if ( memory.nodrag && memory.up && mouse->getButton( 1 ) ) { memory.setState( (SlopState*)new SlopEndDrag() ); } // Determine which cursor to use char a = startPoint.y > mouse->getMousePos().y; char b = startPoint.x > mouse->getMousePos().x; char c = (a << 1) | b; switch ( c ) { case 0: mouse->setCursor( XC_lr_angle ); break; case 1: mouse->setCursor( XC_ll_angle ); break; case 2: mouse->setCursor( XC_ur_angle ); break; case 3: mouse->setCursor( XC_ul_angle ); break; } // Compensate for edges of screen, depending on the mouse position in relation to the start point. int lx = mouse->getMousePos().x < startPoint.x; int ly = mouse->getMousePos().y < startPoint.y; memory.rectangle->setPoints(startPoint+glm::vec2(1*lx,1*ly), mouse->getMousePos()+glm::vec2(1*(!lx), 1*(!ly))); if ( !memory.nodrag && !mouse->getButton( 1 ) ) { memory.setState( (SlopState*)new SlopEndDrag() ); return; } if ( keyboard ) { if ( keyboard->getKey(XK_space) ) { memory.setState( (SlopState*)new SlopStartMove( startPoint, mouse->getMousePos() ) ); return; } int arrows[2]; arrows[0] = keyboard->getKey(XK_Down)-keyboard->getKey(XK_Up); arrows[1] = keyboard->getKey(XK_Right)-keyboard->getKey(XK_Left); if ( arrows[0] || arrows[1] ) { if ( repeatTimer == 0 || repeatTimer > .4 ) { startPoint.y += arrows[0]*multiplier; startPoint.x += arrows[1]*multiplier; } if ( repeatTimer > 1 ) { multiplier += dt*2; } repeatTimer += dt; } else { repeatTimer = 0; multiplier = 1; } } } void slop::SlopEndDrag::onEnter( SlopMemory& memory ) { memory.running = false; } slop::SlopStartMove::SlopStartMove( glm::vec2 oldPoint, glm::vec2 newPoint ) { // oldPoint is where drag was started and newPoint where move was startPoint = oldPoint; // This vector is the diagonal of the rectangle // it will be used to move the startPoint along with mousePos diagonal = newPoint - oldPoint; } void slop::SlopStartMove::onEnter( SlopMemory& memory ) { // redundant because of update() //compensation comp = determineCompensation(); //setPoints( memory, comp ); mouse->setCursor( XC_fleur ); } void slop::SlopStartMove::update( SlopMemory& memory, double dt ) { // Unclear why it has to be - and not + startPoint = mouse->getMousePos() - diagonal; int lx = mouse->getMousePos().x < startPoint.x; int ly = mouse->getMousePos().y < startPoint.y; memory.rectangle->setPoints(startPoint+glm::vec2(1*lx,1*ly), mouse->getMousePos()+glm::vec2(1*(!lx), 1*(!ly))); // space or mouse1 released, return to drag // if mouse1 is released then drag will end also if ( !keyboard->getKey(XK_space) or (!mouse->getButton( 1 ) && !memory.nodrag) ) { // clip rectangle on edges of screen. startPoint.x = glm::min((int)startPoint.x, WidthOfScreen(x11->screen)); startPoint.x = glm::max((int)startPoint.x, 0); startPoint.y = glm::min((int)startPoint.y, HeightOfScreen(x11->screen)); startPoint.y = glm::max((int)startPoint.y, 0); memory.setState( (SlopState*) new SlopStartDrag(startPoint) ); } } slop-7.7/src/slopstates.hpp000066400000000000000000000050401503006136600160440ustar00rootroot00000000000000/* slopstates.hpp: State machine stuffs. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_SLOPSTATES_H_ #define N_SLOPSTATES_H_ #include "mouse.hpp" #include "keyboard.hpp" #include "slop.hpp" #include "rectangle.hpp" namespace slop { class SlopMemory; class SlopOptions; class SlopState { protected: glm::vec2 startPoint; public: virtual void onEnter( SlopMemory& memory ); virtual void onExit( SlopMemory& memory ); virtual void update( SlopMemory& memory, double dt ); virtual void draw( SlopMemory& memory, glm::mat4 matrix ); virtual ~SlopState(); }; class SlopStart : SlopState { private: bool setStartPos; public: virtual void onEnter( SlopMemory& memory ); virtual void update( SlopMemory& memory, double dt ); virtual void draw( SlopMemory& memory, glm::mat4 matrix ); }; class SlopStartDrag : SlopState { private: float repeatTimer; float multiplier; public: SlopStartDrag( glm::vec2 point ); virtual void onEnter( SlopMemory& memory ); virtual void update( SlopMemory& memory, double dt ); }; class SlopEndDrag : SlopState { public: virtual void onEnter( SlopMemory& memory ); }; class SlopStartMove : SlopState { private: glm::vec2 diagonal; public: SlopStartMove( glm::vec2 oldPoint, glm::vec2 newPoint ); virtual void onEnter( SlopMemory& memory ); virtual void update( SlopMemory& memory, double dt ); }; class SlopMemory { private: SlopState* state; SlopState* nextState; public: SlopMemory( SlopOptions* options, Rectangle* rect ); ~SlopMemory(); Window selectedWindow; bool running; float tolerance; bool nodecorations; bool nodrag; bool up; Rectangle* rectangle; void setState( SlopState* state ); void update( double dt ); void draw( glm::mat4& matrix ); }; } #endif // N_SLOPSTATES_H_ slop-7.7/src/window.cpp000066400000000000000000000121501503006136600151450ustar00rootroot00000000000000#include "window.hpp" using namespace slop; slop::SlopWindow::SlopWindow() { // Load up a opengl context static int attributeList[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, GLX_DOUBLEBUFFER, True, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_ALPHA_SIZE, 1, None }; int nelements; int render_event_base, render_error_base; if(!XRenderQueryExtension(x11->display, &render_event_base, &render_error_base)) { throw std::runtime_error("No XRENDER extension found\n"); } GLXFBConfig* fbc = glXChooseFBConfig(x11->display, DefaultScreen(x11->display), attributeList, &nelements); GLXFBConfig fbconfig; if ( !fbc ) { throw std::runtime_error("No matching visuals available.\n"); } XVisualInfo* vi ; XRenderPictFormat *pictFormat; int i; for (i=0; idisplay, fbc[i]); if (!vi) { continue; } pictFormat = XRenderFindVisualFormat(x11->display, vi->visual); if (!pictFormat) { XFree( vi ); continue; } if(pictFormat->direct.alphaMask > 0) { fbconfig = fbc[i]; break; } else { XFree( vi ); } } if (i == nelements ) { throw std::runtime_error( "No matching visuals available" ); } XFree( fbc ); XSetWindowAttributes attributes; attributes.colormap = XCreateColormap(x11->display, RootWindow(x11->display, vi->screen), vi->visual, AllocNone); attributes.background_pixmap = None; attributes.border_pixel = 0; // Disable window decorations. attributes.override_redirect = True; // Make sure we know when we've been successfully destroyed later! attributes.event_mask = StructureNotifyMask; unsigned long valueMask = CWOverrideRedirect | CWColormap | CWBackPixmap | CWBorderPixel | CWEventMask; // Create the window window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0, vi->depth, InputOutput, vi->visual, valueMask, &attributes ); XFree( vi ); if ( !window ) { throw std::runtime_error( "Couldn't create a GL window!" ); } // Prep some hints for the window static char title[] = "slop"; XWMHints* startup_state = XAllocWMHints(); startup_state->initial_state = NormalState; startup_state->flags = StateHint; XTextProperty textprop; textprop.value = (unsigned char*)title; textprop.encoding = XA_STRING; textprop.format = 8; textprop.nitems = strlen( title ); XSizeHints sizehints; sizehints.x = 0; sizehints.y = 0; sizehints.width = WidthOfScreen( x11->screen ); sizehints.height = HeightOfScreen( x11->screen ); sizehints.flags = USPosition | USSize; XClassHint classhints; char name[] = "slop"; classhints.res_name = name; classhints.res_class = name; // Finally send it all over... XSetClassHint( x11->display, window, &classhints ); XSetWMProperties( x11->display, window, &textprop, &textprop, NULL, 0, &sizehints, startup_state, NULL ); XFree( startup_state ); // Keep the window on top of all other windows. Atom stateAbove = XInternAtom(x11->display, "_NET_WM_STATE_ABOVE", False); XChangeProperty(x11->display, window, XInternAtom(x11->display, "_NET_WM_STATE", False), XA_ATOM, 32, PropModeReplace, (unsigned char *) &stateAbove, 1); context = glXCreateNewContext( x11->display, fbconfig, GLX_RGBA_TYPE, 0, True ); if ( !context ) { throw std::runtime_error( "Failed to create an OpenGL context." ); } setCurrent(); // Finally we grab some OpenGL 3.3 stuffs. GLenum err = glewInit(); if (GLEW_OK != err) { throw std::runtime_error((char*)glewGetErrorString(err)); } framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) ); glViewport( 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) ); camera = glm::ortho( 0.0f, (float)WidthOfScreen( x11->screen ), (float)HeightOfScreen( x11->screen ), 0.0f, -1.0f, 1.0f); // Last, we actually display the window <:o) XMapWindow( x11->display, window ); } slop::SlopWindow::~SlopWindow() { delete framebuffer; // Try to erase the window before destroying it. glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); display(); glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); display(); glXDestroyContext( x11->display, context ); XUnmapWindow( x11->display, window ); XDestroyWindow( x11->display, window ); glXMakeCurrent( x11->display, None, NULL ); } void slop::SlopWindow::display() { glXSwapBuffers( x11->display, window ); glXWaitGL(); } void slop::SlopWindow::setCurrent() { glXMakeCurrent( x11->display, window, context ); } slop-7.7/src/window.hpp000066400000000000000000000030241503006136600151520ustar00rootroot00000000000000/* window.hpp: Spawns and manages windows. By default it creates an OpenGL context with them. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_WINDOW_H_ #define N_WINDOW_H_ #include #include #include #include #include #define GL_GLEXT_PROTOTYPES #define GLX_GLXEXT_PROTOTYPES #include #include #include #include #include #include #include "x.hpp" #include "framebuffer.hpp" namespace slop { class SlopWindow { public: Framebuffer* framebuffer; int width, height; glm::mat4 camera; GLXWindow window; GLXContext context; SlopWindow(); ~SlopWindow(); void setCurrent(); void display(); }; } #endif // N_WINDOW_H_ slop-7.7/src/x.cpp000066400000000000000000000105721503006136600141130ustar00rootroot00000000000000#include "x.hpp" using namespace slop; glm::vec4 slop::getWindowGeometry( Window win, bool removeDecoration ) { // First lets check for if we're a window manager frame. Window root, parent; Window* children; unsigned int num_children; XQueryTree( x11->display, win, &root, &parent, &children, &num_children); // To do that, we check if our top level child happens to have the _NET_FRAME_EXTENTS atom. unsigned char *data; Atom type_return; unsigned long nitems_return; unsigned long bytes_after_return; int format_return; bool window_frame = false; Window actualWindow = win; if ( num_children > 0 && XGetWindowProperty( x11->display, children[num_children-1], XInternAtom( x11->display, "_NET_FRAME_EXTENTS", False), 0, LONG_MAX, False, XA_CARDINAL, &type_return, &format_return, &nitems_return, &bytes_after_return, &data) == Success ) { if ((type_return == XA_CARDINAL) && (format_return == 32) && (nitems_return == 4) && (data)) { actualWindow = children[num_children-1]; window_frame = true; } } // If we actually don't want the window frame (decoration), we just actually grab the decoration's innards. // And ignore all of the _NET_FRAME_EXTENTS information. if ( actualWindow != win && removeDecoration ) { win = actualWindow; window_frame = false; } // If we're a window frame, we actually get the dimensions of the child window, then add the _NET_FRAME_EXTENTS to it. // (then add the border width of the window frame after that.) if ( window_frame ) { // First lets grab the border width. XWindowAttributes frameattr; XGetWindowAttributes( x11->display, win, &frameattr ); // Then lets grab the dims of the child window. XWindowAttributes attr; XGetWindowAttributes( x11->display, actualWindow, &attr ); unsigned int width = attr.width; unsigned int height = attr.height; // We combine both border widths. unsigned int border = attr.border_width+frameattr.border_width; int x, y; // Gotta translate them into root coords, we can adjust for the border width here. Window junk; XTranslateCoordinates( x11->display, actualWindow, attr.root, -border, -border, &x, &y, &junk ); width += border*2; height += border*2; // Now uh, remember that _NET_FRAME_EXTENTS stuff? That's the window frame information. // We HAVE to do this because mutter likes to mess with window sizes with shadows and stuff. unsigned long* ldata = (unsigned long*)data; width += ldata[0] + ldata[1]; height += ldata[2] + ldata[3]; x -= ldata[0]; y -= ldata[2]; XFree( data ); return glm::vec4( x, y, width, height ); } else { // Either the WM is malfunctioning, or the window specified isn't a window manager frame. // so we just rely on X to give a decent geometry. XWindowAttributes attr; XGetWindowAttributes( x11->display, win, &attr ); unsigned int width = attr.width; unsigned int height = attr.height; // We combine both border widths. unsigned int border = attr.border_width; int x, y; // Gotta translate them into root coords, we can adjust for the border width here. Window junk; XTranslateCoordinates( x11->display, win, attr.root, -border, -border, &x, &y, &junk ); width += border*2; height += border*2; return glm::vec4( x, y, width, height ); } } bool X11::hasCompositor() { std::stringstream prop_name; prop_name << "_NET_WM_CM_S" << XScreenNumberOfScreen( screen ); Atom prop_atom = XInternAtom(display, prop_name.str().c_str(), False); return XGetSelectionOwner(display, prop_atom) != None; } X11::X11( std::string displayName ) { // Initialize display display = XOpenDisplay( displayName.c_str() ); if ( !display ) { throw std::runtime_error(std::string("Error: Failed to open X display: ") + displayName ); } screen = ScreenOfDisplay( display, DefaultScreen( display ) ); visual = DefaultVisual( display, XScreenNumberOfScreen( screen ) ); root = DefaultRootWindow( display ); } X11::~X11() { XCloseDisplay( display ); } slop-7.7/src/x.hpp000066400000000000000000000024161503006136600141160ustar00rootroot00000000000000/* x.hpp: initializes x11 * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_X_H_ #define N_X_H_ #include #include #include #include #include #include #include #include namespace slop { glm::vec4 getWindowGeometry( Window win, bool removeDecoration ); class X11 { public: bool hasCompositor(); X11( std::string displayName ); ~X11(); Display* display; Visual* visual; Screen* screen; Window root; }; extern X11* x11; } #endif slop-7.7/src/xshaperectangle.cpp000066400000000000000000000126621503006136600170230ustar00rootroot00000000000000#include "xshaperectangle.hpp" slop::XShapeRectangle::XShapeRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) { this->color = convertColor( color ); this->border = border; this->padding = padding; this->highlight = highlight; this->alpha = color.a; // Find each corner of the rectangle ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; // Offset the inner corners by the padding. ul = ul + glm::vec2(-padding,padding); bl = bl + glm::vec2(-padding,-padding); ur = ur + glm::vec2(padding,padding); br = br + glm::vec2(padding,-padding); // Create the outer corners by offsetting the inner by the bordersize oul = ul + glm::vec2(-border,border); obl = bl + glm::vec2(-border,-border); our = ur + glm::vec2(border,border); obr = br + glm::vec2(border,-border); XSetWindowAttributes attributes; // Set up the window so it's our color attributes.background_pixel = this->color.pixel; // Disable window decorations. attributes.override_redirect = True; // Make sure we know when we've been successfully destroyed later! attributes.event_mask = StructureNotifyMask; unsigned long valueMask = CWBackPixel | CWOverrideRedirect | CWEventMask; // Create the window window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ), 0, CopyFromParent, InputOutput, CopyFromParent, valueMask, &attributes ); if ( alpha < 1 ) { // Change the window opacity unsigned int cardinal_alpha = (unsigned int) (alpha * (unsigned int)-1) ; XChangeProperty( x11->display, window, XInternAtom( x11->display, "_NET_WM_WINDOW_OPACITY", 0), XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&cardinal_alpha, 1 ); } // Set the class hint, and title to "slop" XClassHint classhints; char name[] = "slop"; classhints.res_name = name; classhints.res_class = name; XSetClassHint( x11->display, window, &classhints ); // Now punch a hole into it so it looks like a selection rectangle, but only if we're not highlighting. generateHoles(); createdWindow = false; } void slop::XShapeRectangle::createWindow() { if ( createdWindow ) { return; } XMapWindow( x11->display, window ); createdWindow = true; } void slop::XShapeRectangle::generateHoles() { if ( !highlight ) { XRectangle rects[4]; // Left rects[0].x = oul.x; rects[0].y = obl.y; rects[0].width = border; rects[0].height = oul.y-obl.y; // Top rects[1].x = ul.x; rects[1].y = obl.y; rects[1].width = ur.x-ul.x; rects[1].height = border; // Right rects[2].x = ur.x; rects[2].y = obr.y; rects[2].width = border; rects[2].height = our.y - obr.y; // Bottom rects[3].x = bl.x; rects[3].y = ul.y; rects[3].width = br.x-bl.x; rects[3].height = border; XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, rects, 4, ShapeSet, 0); return; } XRectangle rect; rect.x = oul.x; rect.y = obl.y; rect.width = our.x-oul.x; rect.height = oul.y-obl.y; XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0); } void slop::XShapeRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) { // Find each corner of the rectangle ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ; br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ; // Offset the inner corners by the padding. ul = ul + glm::vec2(-padding,padding); bl = bl + glm::vec2(-padding,-padding); ur = ur + glm::vec2(padding,padding); br = br + glm::vec2(padding,-padding); // Create the outer corners by offsetting the inner by the bordersize oul = ul + glm::vec2(-border,border); obl = bl + glm::vec2(-border,-border); our = ur + glm::vec2(border,border); obr = br + glm::vec2(border,-border); generateHoles(); } slop::XShapeRectangle::~XShapeRectangle() { XUnmapWindow( x11->display, window ); XDestroyWindow( x11->display, window ); } void slop::XShapeRectangle::draw( glm::mat4& matrix ) { // We don't want to be visible until we're asked to draw. createWindow(); } glm::vec4 slop::XShapeRectangle::getRect() { return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y ); } XColor slop::XShapeRectangle::convertColor( glm::vec4 color ) { // Convert float colors to shorts. short red = short( floor( color.r * 65535.f ) ); short green = short( floor( color.g * 65535.f ) ); short blue = short( floor( color.b * 65535.f ) ); XColor xc; xc.red = red; xc.green = green; xc.blue = blue; int err = XAllocColor( x11->display, DefaultColormap( x11->display, XScreenNumberOfScreen( x11->screen ) ), &xc ); if ( err == BadColor ) { throw std::runtime_error(std::string("Couldn't allocate a color")); } return xc; } slop-7.7/src/xshaperectangle.hpp000066400000000000000000000034541503006136600170270ustar00rootroot00000000000000/* xshaperectangle.hpp: A rectangle that doesn't use OpenGL to function. * * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors). * * This file is part of Slop. * * Slop 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. * * Slop 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 Slop. If not, see . */ #ifndef N_XSHAPERECTANGLE_H_ #define N_XSHAPERECTANGLE_H_ #include #include #include #include #include #include #include #include "x.hpp" #include "rectangle.hpp" namespace slop { class XShapeRectangle : public Rectangle { private: glm::vec2 ul, oul; glm::vec2 bl, obl; glm::vec2 ur, our; glm::vec2 br, obr; bool createdWindow; bool highlight; float border; float padding; XColor color; float alpha; XColor convertColor( glm::vec4 color ); void generateHoles(); void createWindow(); public: Window window; glm::vec4 getRect(); XShapeRectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false ); ~XShapeRectangle(); void setPoints( glm::vec2 p1, glm::vec2 p2 ); void draw(glm::mat4& matrix); }; } #endif // N_XSHAPERECTANGLE_H_