pax_global_header00006660000000000000000000000064121727722050014517gustar00rootroot0000000000000052 comment=f18de96fb92096988c63e2b9cac20d65a13a0545 boats-201307/000077500000000000000000000000001217277220500127255ustar00rootroot00000000000000boats-201307/.gitignore000066400000000000000000000002771217277220500147230ustar00rootroot00000000000000# kdevelop *kdev* # qt-creator qtc-* # windows *.dll # qt .moc qrc_* *qm #products Makefile* Doxyfile doxygen/* tags .obj # release Changelog* diffstat* # project boats boats.exe *xbs boats-201307/COPYING000066400000000000000000001043741217277220500137710ustar00rootroot00000000000000 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 . boats-201307/Info.plist000066400000000000000000000017141217277220500147000ustar00rootroot00000000000000 CFBundleDocumentTypes CFBundleTypeExtensions xbs CFBundleTypeIconFile xbs.icns CFBundleTypeName Boat Scenario document CFBundleTypeRole Editor CFBundleExecutable boats CFBundleGetInfoString Created by Thibaut GRIDEL CFBundleIconFile boats.icns CFBundleName Boat Scenario CFBundlePackageType APPL CFBundleShortVersionString 201307.0.0 CFBundleSignature boat boats-201307/TODO000066400000000000000000000006611217277220500134200ustar00rootroot00000000000000Important: - fix printing document - statechart Normal: - toggle number display - arrows - more boat shapes - open in new tab - more flags - fix shortcut clashes - save default series - save default mark color - spin trim Wishlist: - gpx import - backtrack edit - insert between boats - starting a boat at a later number - timing for the start boat - animate spin hoist and drop - create track in a series different from scenario boats-201307/animation/000077500000000000000000000000001217277220500147045ustar00rootroot00000000000000boats-201307/animation/angleanimation.cpp000066400000000000000000000033171217277220500204020ustar00rootroot00000000000000// // C++ Implementation: AngleAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include "angleanimation.h" AngleAnimation::AngleAnimation(QObject *target, const QByteArray &propertyName, QObject *parent) : PropertyAnimation(target, propertyName, parent) { } QVariant AngleAnimation::interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const { qreal valueBefore = from.toReal(); qreal valueAfter = to.toReal(); qreal minValue = qMin(valueBefore,valueAfter); qreal maxValue = qMax(valueBefore,valueAfter); if (maxValue - minValue <= 360 + minValue - maxValue) { // Do a simple linear interpolation. return valueBefore + (valueAfter - valueBefore) * progress; } else { // Do a reverse linear interpolation. if (valueBefore > valueAfter) return valueBefore + (360 + valueAfter - valueBefore) * progress; else return valueBefore + (valueAfter - valueBefore - 360) * progress; } } boats-201307/animation/angleanimation.h000066400000000000000000000030521217277220500200430ustar00rootroot00000000000000// // C++ Interface: AngleAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef ANGLEANIMATION_H #define ANGLEANIMATION_H #include "propertyanimation.h" /** \class AngleAnimation \brief Animation for angles with correct rotation The class is the animation helper for an angle, according to the Animation Framework. It inherits QVariantAnimation and provides proper angle animation to BoatGraphicsItem elements, like heading or sail position, so that the shortest angle is taken between two options \sa BoatGraphicsItem */ class AngleAnimation : public PropertyAnimation { public: AngleAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0); virtual QVariant interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const; }; #endif // ANGLEANIMATION_H boats-201307/animation/animation.pri000066400000000000000000000007631217277220500174050ustar00rootroot00000000000000INCLUDEPATH += $$PWD DEPENDPATH += $$PWD HEADERS += \ $$PWD/angleanimation.h \ $$PWD/boatanimation.h \ $$PWD/headinganimation.h \ $$PWD/propertyanimation.h \ $$PWD/splineanimation.h \ $$PWD/scenarioanimation.h \ $$PWD/trackanimation.h SOURCES += \ $$PWD/angleanimation.cpp \ $$PWD/boatanimation.cpp \ $$PWD/headinganimation.cpp \ $$PWD/propertyanimation.cpp \ $$PWD/splineanimation.cpp \ $$PWD/scenarioanimation.cpp \ $$PWD/trackanimation.cpp boats-201307/animation/boatanimation.cpp000066400000000000000000000141741217277220500202440ustar00rootroot00000000000000// // C++ Implementation: BoatAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include "boatanimation.h" #include "boats.h" #include "angleanimation.h" #include "headinganimation.h" #include "situationmodel.h" #include "splineanimation.h" #include "trackmodel.h" #include "boatmodel.h" /** Populates the animation items for position, Headings and other attributes. This method parses the path of the \a track, does some stalling analysis and determines specific position animation. */ BoatAnimation::BoatAnimation(TrackModel *track, BoatModel *boat, int index, QObject *parent) : QParallelAnimationGroup(parent), m_track(track), m_boat(boat) { BoatModel *model = track->boats()[index]; QPainterPath curve = model->path(); QPointF point = curve.elementAt(0); QPointF c1 = curve.elementAt(1); QPointF c2 = curve.elementAt(2); QPointF end = curve.elementAt(3); bool stalled = ((point == c1) || (c2 == end)); // position SplineAnimation *splineAnimation = new SplineAnimation(m_boat, "pos", model->path()); splineAnimation->setDuration(2000); splineAnimation->setStartValue(point); splineAnimation->setEndValue(end); addAnimation(splineAnimation); // text PropertyAnimation *textAnimation = new PropertyAnimation(boat, "text"); textAnimation->setDuration(2000); textAnimation->setStartValue(model->text()); textAnimation->setEndValue(model->text()); addAnimation(textAnimation); // text position PropertyAnimation *textPosAnimation = new PropertyAnimation(boat, "textPos"); textPosAnimation->setDuration(2000); textPosAnimation->setStartValue(model->textPosition()); textPosAnimation->setEndValue(model->textPosition()); addAnimation(textPosAnimation); // laylines PropertyAnimation *laylinesAnimation = new PropertyAnimation(boat, "laylines"); laylinesAnimation->setDuration(2000); laylinesAnimation->setStartValue(model->laylines()); laylinesAnimation->setEndValue(model->laylines()); addAnimation(laylinesAnimation); // heading QVariantAnimation *headingAnimation; if (stalled) { headingAnimation = new AngleAnimation(boat, "heading"); } else { headingAnimation = new HeadingAnimation(boat, "heading", model->path()); } headingAnimation->setDuration(2000); headingAnimation->setStartValue(model->heading()); addAnimation(headingAnimation); AngleAnimation *windAnimation = new AngleAnimation(boat, "wind"); windAnimation->setDuration(2000); windAnimation->setStartValue(model->wind()); addAnimation(windAnimation); // sail angle AngleAnimation *sailAngleAnimation = new AngleAnimation(boat, "trimSailAngle"); sailAngleAnimation->setDuration(2000); sailAngleAnimation->setStartValue(model->trimmedSailAngle()); addAnimation(sailAngleAnimation); // jib angle AngleAnimation *jibAngleAnimation = new AngleAnimation(boat, "trimJibAngle"); jibAngleAnimation->setDuration(2000); jibAngleAnimation->setStartValue(model->trimmedJibAngle()); addAnimation(jibAngleAnimation); // spin PropertyAnimation *spinAnimation = new PropertyAnimation(boat, "spin"); spinAnimation->setDuration(2000); spinAnimation->setStartValue(model->spin()); addAnimation(spinAnimation); // spin angle AngleAnimation *spinAngleAnimation = new AngleAnimation(boat, "trimSpinAngle"); spinAngleAnimation->setDuration(2000); spinAngleAnimation->setStartValue(model->trimmedSpinAngle()); addAnimation(spinAngleAnimation); // gen angle AngleAnimation *genAngleAnimation = new AngleAnimation(boat, "trimGennAngle"); genAngleAnimation->setDuration(2000); genAngleAnimation->setStartValue(model->trimmedGennAngle()); addAnimation(genAngleAnimation); // overlap PropertyAnimation *overlapAnimation = new PropertyAnimation(boat, "overlap"); overlapAnimation->setDuration(2000); overlapAnimation->setStartValue(QVariant(model->overlap())); overlapAnimation->setEndValue(QVariant(model->overlap())); addAnimation(overlapAnimation); // flag PropertyAnimation *flagAnimation = new PropertyAnimation(boat, "flag"); flagAnimation->setDuration(2000); flagAnimation->setStartValue(model->flag()); flagAnimation->setEndValue(model->flag()); addAnimation(flagAnimation); // acceleration switch(model->acceleration()) { case Boats::accelerating: setEasingCurve(QEasingCurve::InSine); break; case Boats::decelerating: setEasingCurve(QEasingCurve::OutSine); break; default: break; } // end values that need next boat position model = m_track->boats()[index+1]; headingAnimation->setEndValue(model->heading()); windAnimation->setEndValue(model->wind()); sailAngleAnimation->setEndValue(model->trimmedSailAngle()); jibAngleAnimation->setEndValue(model->trimmedJibAngle()); spinAnimation->setEndValue(model->spin()); spinAngleAnimation->setEndValue(model->trimmedSpinAngle()); genAngleAnimation->setEndValue(model->trimmedGennAngle()); } BoatAnimation::~BoatAnimation() { } void BoatAnimation::setEasingCurve(const QEasingCurve &easing) { for (int i=0; i< animationCount(); ++i) { QVariantAnimation *animation = dynamic_cast(animationAt(i)); if(animation) { animation->setEasingCurve(easing); } } } boats-201307/animation/boatanimation.h000066400000000000000000000033711217277220500177060ustar00rootroot00000000000000// // C++ Interface: BoatAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef BOATANIMATION_H #define BOATANIMATION_H #include #include class TrackModel; class BoatModel; /** \class BoatAnimation \brief The animation Item for a boat in its track The class is the animation group for a boat, according to the Animation Framework. It inherits QParallelAnimationGroup and provides all animation features, like position and heading given a time step. \sa SituationScene, SituationModel */ class BoatAnimation : public QParallelAnimationGroup { public: BoatAnimation(TrackModel *track, BoatModel *boat, int index, QObject *parent = 0); ~BoatAnimation(); BoatModel *boat() const {return m_boat; } void setEasingCurve ( const QEasingCurve & easing ); private: /// \a m_track holds the reference to the track TrackModel *m_track; /// \a m_boat holds the reference to the boat BoatModel *m_boat; }; #endif boats-201307/animation/headinganimation.cpp000066400000000000000000000025771217277220500207220ustar00rootroot00000000000000// // C++ Implementation: HeadingAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include "headinganimation.h" #include "angleanimation.h" HeadingAnimation::HeadingAnimation(QObject *target, const QByteArray &propertyName, const QPainterPath &path, QObject *parent) : PropertyAnimation(target, propertyName, parent), m_path(path) { } QVariant HeadingAnimation::interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const { Q_UNUSED(from) Q_UNUSED(to) qreal length = m_path.length(); qreal percent = m_path.percentAtLength(length * progress); return fmod(360+90-m_path.angleAtPercent(percent),360.0); } boats-201307/animation/headinganimation.h000066400000000000000000000032031217277220500203520ustar00rootroot00000000000000// // C++ Interface: HeadingAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef HEADINGANIMATION_H #define HEADINGANIMATION_H #include #include "propertyanimation.h" /** \class HeadingAnimation \brief Animation for angles with correct rotation The class is the animation helper for an angle, according to the Animation Framework. It inherits QVariantAnimation and provides proper animation to BoatGraphicsItem elements along a QPainterPath, like the boat heading, so that the heading follows the path \sa BoatGraphicsItem */ class HeadingAnimation : public PropertyAnimation { public: HeadingAnimation(QObject *target, const QByteArray &propertyName, const QPainterPath &path, QObject *parent = 0); virtual QVariant interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const; private: QPainterPath m_path; }; #endif // HEADINGANIMATION_H boats-201307/animation/propertyanimation.cpp000066400000000000000000000042221217277220500211740ustar00rootroot00000000000000// // C++ Implementation: PropertyAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include "propertyanimation.h" #include "boats.h" PropertyAnimation::PropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent) : QPropertyAnimation(target, propertyName, parent) { } void PropertyAnimation::updateCurrentValue ( const QVariant & value ) { // doesn't work because QPropertyAnimationPrivate::updateProperty checks for not Stopped // QPropertyAnimation::updateCurrentValue(value); targetObject()->setProperty(propertyName(), value); } QVariant boolInterpolator(const bool &start, const bool &end, qreal progress) { Q_UNUSED(end) Q_UNUSED(progress) return start; } //qRegisterAnimationInterpolator(boolInterpolator); QVariant qstringInterpolator(const QString &start, const QString &end, qreal progress) { Q_UNUSED(end) Q_UNUSED(progress) return start; } //qRegisterAnimationInterpolator( qstringInterpolator ); QVariant PropertyAnimation::interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const { if (strcmp(from.typeName(), "bool") == 0) { return boolInterpolator(from.toBool(), to.toBool(), progress); } else if (strcmp(from.typeName(), "QString") == 0) { return qstringInterpolator(from.toString(), to.toString(), progress); } return QVariantAnimation::interpolated(from, to, progress); } boats-201307/animation/propertyanimation.h000066400000000000000000000031321217277220500206400ustar00rootroot00000000000000// // C++ Interface: PropertyAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef PROPERTYANIMATION_H #define PROPERTYANIMATION_H #include /** \class PropertyAnimation \brief Animation for properties irrelevant of state The class is the animation helper for a property, according to the Animation Framework. It inherits QVariantAnimation and provides proper property animation so that the property is updated whatever the state, unlike QPropertyAnimation \sa QPropertyAnimation */ class PropertyAnimation : public QPropertyAnimation { public: PropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0); virtual void updateCurrentValue ( const QVariant & value ); virtual QVariant interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const; }; #endif // PROPERTYANIMATION_H boats-201307/animation/scenarioanimation.cpp000066400000000000000000000017741217277220500211240ustar00rootroot00000000000000// // C++ Implementation: ScenarioAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include "scenarioanimation.h" void ScenarioAnimation::updateCurrentTime(int currentTime) { QParallelAnimationGroup::updateCurrentTime(currentTime); emit timeChanged(currentTime); } boats-201307/animation/scenarioanimation.h000066400000000000000000000026371217277220500205700ustar00rootroot00000000000000// // C++ Interface: ScenarioAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef SCENARIOANIMATION_H #define SCENARIOANIMATION_H #include /** \class ScenarioAnimation \brief Animation for the whole scenario The class is the animation group for a scenario, according to the Animation Framework. It inherits QParallelAnimationGroup and contains TrackAnimations for the different tracks of the scenario \sa TrackAnimation */ class ScenarioAnimation: public QParallelAnimationGroup { Q_OBJECT public: virtual void updateCurrentTime(int currentTime); signals: void timeChanged(int time); }; #endif // SCENARIOANIMATION_H boats-201307/animation/splineanimation.cpp000066400000000000000000000025271217277220500206100ustar00rootroot00000000000000// // C++ Implementation: SplineAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include "splineanimation.h" SplineAnimation::SplineAnimation(QObject *target, const QByteArray &propertyName, const QPainterPath &path, QObject *parent) : PropertyAnimation(target, propertyName, parent), m_path(path) { } QVariant SplineAnimation::interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const { Q_UNUSED(from) Q_UNUSED(to) qreal length = m_path.length(); qreal percent = m_path.percentAtLength(length * progress); return m_path.pointAtPercent(percent); } boats-201307/animation/splineanimation.h000066400000000000000000000032361217277220500202530ustar00rootroot00000000000000// // C++ Interface: SplineAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef SPLINEANIMATION_H #define SPLINEANIMATION_H #include #include "propertyanimation.h" /** \class SplineAnimation \brief Animation for the position along a spline The class is the animation helper for a position along a spline, according to the Animation Framework. It inherits QPropertyAnimation and provides animation for a QPointF to BoatGraphicsItem elements, like boat position along its track, so that the boat moves on its track \sa BoatGraphicsItem */ class SplineAnimation : public PropertyAnimation { public: SplineAnimation(QObject *target, const QByteArray &propertyName, const QPainterPath &path, QObject *parent = 0); virtual QVariant interpolated ( const QVariant & from, const QVariant & to, qreal progress ) const; private: QPainterPath m_path; }; #endif // SPLINEANIMATION_H boats-201307/animation/trackanimation.cpp000066400000000000000000000053611217277220500204210ustar00rootroot00000000000000// // C++ Implementation: TrackAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include #include "trackanimation.h" #include "boatmodel.h" #include "trackmodel.h" #include "boatanimation.h" #include "propertyanimation.h" TrackAnimation::TrackAnimation(TrackModel *track, BoatModel *boat, QObject *parent) : QParallelAnimationGroup(parent), m_track(track), m_boat(boat) { int size = m_track->size(); if (size < 0) { return; } QSequentialAnimationGroup *boatsAnimation = new QSequentialAnimationGroup(this); // through all boats of the track for (int i=0; i< size; i++) { if (iaddAnimation(boatAnimation); } QSequentialAnimationGroup *visibilityAnimation = new QSequentialAnimationGroup(this); PropertyAnimation *invisibletAnimation = new PropertyAnimation(m_track->boats()[i],"dim", this); invisibletAnimation->setDuration(2000*i); invisibletAnimation->setStartValue(0); invisibletAnimation->setEndValue(0); visibilityAnimation->addAnimation(invisibletAnimation); PropertyAnimation *dimAnimation = new PropertyAnimation(m_track->boats()[i],"dim", this); if (isetDuration(2000); } else { dimAnimation->setDuration(0); } dimAnimation->setStartValue(255); dimAnimation->setEndValue(64); visibilityAnimation->addAnimation(dimAnimation); addAnimation(visibilityAnimation); } addAnimation(boatsAnimation); // dim all track boats foreach(BoatModel *boat, m_track->boats()) { boat->setDim(0); } } /** Resets the color and List of BoatModels in the track */ TrackAnimation::~TrackAnimation() { // undim all track boats foreach(BoatModel *boat, m_track->boats()) { boat->setDim(255); } m_track->changingTrack(m_track); } boats-201307/animation/trackanimation.h000066400000000000000000000032331217277220500200620ustar00rootroot00000000000000// // C++ Interface: TrackAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2010-2011 Thibaut GRIDEL // // 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 . // // #ifndef TRACKANIMATION_H #define TRACKANIMATION_H #include class BoatModel; class TrackModel; /** \class TrackAnimation \brief Animation for the whole track of a boat The class is the animation group for a track, according to the Animation Framework. It inherits QParallelAnimationGroup and contains various animation class for the different properties of a boat to animate along the track \sa BoatAnimation */ class TrackAnimation: public QParallelAnimationGroup { public: TrackAnimation(TrackModel *track, BoatModel *boat, QObject *parent = 0); ~TrackAnimation(); BoatModel *boat() const {return m_boat; } private: /// \a m_track holds the reference to the track TrackModel *m_track; /// \a m_track holds the reference to the animated boat BoatModel *m_boat; }; #endif // TRACKANIMATION_H boats-201307/boatapplication.cpp000066400000000000000000000023241217277220500166030ustar00rootroot00000000000000// // C++ Implementation: BoatApplication // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #include "boatapplication.h" #include "mainwindow.h" bool BoatApplication::event(QEvent *event) { switch (event->type()) { case QEvent::FileOpen: if (m_window) { m_window->openFile(static_cast(event)->file()); return true; } break; default: break; } return QApplication::event(event); } boats-201307/boatapplication.h000066400000000000000000000023571217277220500162560ustar00rootroot00000000000000// // C++ Interface: BoatApplication // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #ifndef BOATAPPLICATION_H #define BOATAPPLICATION_H #include #include class MainWindow; class BoatApplication : public QApplication { Q_OBJECT public: BoatApplication(int & argc, char ** argv) : QApplication(argc, argv) {} ~BoatApplication() {} void setWindow(MainWindow *window) { m_window = window; } protected: bool event(QEvent *event); private: MainWindow *m_window; }; #endif // BOATAPPLICATION_H boats-201307/boats.cpp000066400000000000000000000051061217277220500145430ustar00rootroot00000000000000// // C++ Implementation: boats // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #include "boats.h" QList Boats::m_seriesList; QList Boats::seriesList() { if (!m_seriesList.size()) { for (int i=0; i< ENUM_SIZE(Boats, Series)-1; i++) { m_seriesList << ENUM_NAME(Boats, Series, i); } } // By doing it this way guarantee that labels align correctly with enum tags irrespective of order m_seriesList[keelboat] = QObject::tr("Spin Keelboat"); m_seriesList[keelboatwithgenn] = QObject::tr("Gennaker Keelboat"); m_seriesList[int49er] = QObject::tr("49er"); m_seriesList[int470] = QObject::tr("470"); m_seriesList[int420] = QObject::tr("420"); m_seriesList[int29er] = QObject::tr("29er"); m_seriesList[laser] = QObject::tr("Laser"); m_seriesList[firefly] = QObject::tr("Firefly"); m_seriesList[topper] = QObject::tr("Topper"); m_seriesList[optimist] = QObject::tr("Optimist"); m_seriesList[tornado] = QObject::tr("Tornado"); m_seriesList[startboat] = QObject::tr("Committee boat"); m_seriesList[rib] = QObject::tr("RIB"); return m_seriesList; } QList Boats::m_seriesSizeList; QList Boats::seriesSizeList() { if (!m_seriesSizeList.size()) { for (int i=0; i< ENUM_SIZE(Boats, Series)-1; i++) { m_seriesSizeList << 100; // default size of 100 } m_seriesSizeList[keelboat] = 100; m_seriesSizeList[keelboatwithgenn] = 100; m_seriesSizeList[int49er] = 48; m_seriesSizeList[int470] = 47; m_seriesSizeList[int420] = 42; m_seriesSizeList[int29er] = 41; m_seriesSizeList[laser] = 40; m_seriesSizeList[firefly] = 36.6; m_seriesSizeList[topper] = 34; m_seriesSizeList[optimist] = 23; m_seriesSizeList[tornado] = 61; m_seriesSizeList[rib] = 60; } return m_seriesSizeList; } boats-201307/boats.desktop000066400000000000000000000002521217277220500154270ustar00rootroot00000000000000[Desktop Entry] Type=Application Name=Boat Scenario Comment=Race scenario drawing tool Exec=boats %F Icon=boats.png Categories=Education;Qt; MimeType=application/x-boats boats-201307/boats.h000066400000000000000000000045231217277220500142120ustar00rootroot00000000000000// // C++ Interface: boats // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2011 Thibaut GRIDEL // // 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 . // // #ifndef BOATS_H #define BOATS_H #include #define ENUM_NAME(o,e,v) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).valueToKey((v))) #define ENUM_VALUE(o,e,n) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).keyToValue((n))) #define ENUM_SIZE(o,e) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).keyCount()) #define FLAG_NAME(o,e,v) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).valueToKeys((v))) #define FLAG_VALUE(o,e,n) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).keysToValue((n))) class Boats { Q_GADGET public: enum Series { keelboat, keelboatwithgenn, int49er, int470, int420, int29er, laser, firefly, topper, optimist, tornado, startboat, rib, unknown }; Q_ENUMS (Series); static QList seriesList(); static QList seriesSizeList(); enum Overlap { none = 0x0, starboard = 0x1, port = 0x2 }; Q_FLAGS( Overlap Overlaps) Q_DECLARE_FLAGS(Overlaps, Overlap) enum Flag { noFlag, Y, Red, Green, Yellow, Blue }; Q_ENUMS (Flag); enum Acceleration { constant, accelerating, decelerating }; Q_ENUMS (Acceleration); private: static QList m_seriesList; static QList m_seriesSizeList; }; Q_DECLARE_METATYPE(Boats::Overlaps) #endif boats-201307/boats.icns000066400000000000000000001070241217277220500147170ustar00rootroot00000000000000icnsis32<cߙǃƆ؜    # *!)+'# &33/+'# ;73/+'#UݖǃÆ՛ހ    # *!)+'# &33/+'# ;73/+'#M $+3:AIPW^fm$+3:AIPW^fm$+3:AIPW^eM $+3:AIPWTD$+3:AIP>; $+3:A>.7"+39+9)) %Zw Åրո܁޹ײ㲀欁s8mk`w lU (>ܹ/@>PI``PWil32c>z70Ϛ8{01a9/ĕ44.ȓ*-ʐG>-΍1-ыy6/̑8z//`9/‘44.Ɛ*-ȏG<,ˍ1+΋8?,Έn4-͆25-̃V<+ˁ/,BD,n2          "   &$"   !*(&$"   $.,*(&$"   '20.,*(&$"  $6420.,*(&$" 886420.,*(&$" <:86420.,*(&$" <:86420.,*(&$" "&*-158<@CGJNRUY\`dgko "&*-158<@CGJNRUY\`dgko "&*-158<@CGJNRUY\`dgko "&*-158<@CGJNRUY\`dgko[ "&*-158<@CGJNRUY\`dgkF "&*-158<@CGJNRUY\`dc' "&*-158<@CGJNRUY\`S"&*-158<@CGJNRUY\; "&*-158<@CGJNRUM"&*-158<@CGJNQ,"&*-158<@CGJ<"&*-158<@CD "&*-158<@.  &*-1587 *-15!  -* 3#3296?m4Wˀ7&3ts=77:Dw 6P͇67NΉ}6L͊46Iˌ37Hɍ5l8mkMM:r T 9  $ o9 n ;$*I)l/5<wC>JRit32@IYYWUSQjz6 V{7  W  |7 83."z%*)t,&0n4"6h54b32\10V/.P-,J+*A)~(%'Z&%8$s##O"t!                     " # &  '  ) * , .  0 1  3 !  4!"!!  6"#""!!  8$$##""!!  9%%$$##""!!  ;&&%%$$##""!!  < ''&&%%$$##""!!  > ((''&&%%$$##""!!  ? ))((''&&%%$$##""!!  A "**))((''&&%%$$##""!!  B #++**))((''&&%%$$##""!!  D ",,++**))((''&&%%$$##""!!  E !--,,++**))((''&&%%$$##""!!  G..--,,++**))((''&&%%$$##""!!  H./..--,,++**))((''&&%%$$##""!!  J/0//..--,,++**))((''&&%%$$##""!!  K/100//..--,,++**))((''&&%%$$##""!!  M/21100//..--,,++**))((''&&%%$$##""!!  N03221100//..--,,++**))((''&&%%$$##""!!  P/443221100//..--,,++**))((''&&%%$$##""!!  P.55443221100//..--,,++**))((''&&%%$$##""!!  R '6655443221100//..--,,++**))((''&&%%$$##""!! !6M55443221100//..--,,++**))((''&&%%$$##""!!  5876M55443221100//..--,,++**))((''&&%%$$##""!! 298876L55443221100//..--,,++**))((''&&%%$$##""!!   ,:998876L55443221100//..--,,++**))((''&&%%$$##""!!  %;::998876K55443221100//..--,,++**))((''&&%%$$##""!!  :;;::998876K55443221100//..--,,++**))((''&&%%$$##""!!  7<<;;::998876J55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876J55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876I55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876I55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876H55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876H55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876G55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876G55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876F55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876F55443221100//..--,,++**))((''&&%%$$##""!! XXVTRPiy6 Uz7  V  {7 83."y%*)s+&/m3"5g43a21[0/U.-O,+I**@)}(%'Y&%7$r##߄N"ށs!                     " # &  '  ) * , .  0 1  3 !  4!"!!  6"#""!!  8$$##""!!  9%%$$##""!!  ;&&%%$$##""!!  < ''&&%%$$##""!!  > ((''&&%%$$##""!!  ? ))((''&&%%$$##""!!  A "**))((''&&%%$$##""!!  B #++**))((''&&%%$$##""!!  D ",,++**))((''&&%%$$##""!!  E !--,,++**))((''&&%%$$##""!!  G..--,,++**))((''&&%%$$##""!!  H./..--,,++**))((''&&%%$$##""!!  J/0//..--,,++**))((''&&%%$$##""!!  K/100//..--,,++**))((''&&%%$$##""!!  M/21100//..--,,++**))((''&&%%$$##""!!  N03221100//..--,,++**))((''&&%%$$##""!!  P/443221100//..--,,++**))((''&&%%$$##""!!  P.55443221100//..--,,++**))((''&&%%$$##""!!  R '6655443221100//..--,,++**))((''&&%%$$##""!! !6M55443221100//..--,,++**))((''&&%%$$##""!!  5876M55443221100//..--,,++**))((''&&%%$$##""!! 298876L55443221100//..--,,++**))((''&&%%$$##""!!   ,:998876L55443221100//..--,,++**))((''&&%%$$##""!!  %;::998876K55443221100//..--,,++**))((''&&%%$$##""!!  :;;::998876K55443221100//..--,,++**))((''&&%%$$##""!!  7<<;;::998876J55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876J55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876I55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876I55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876H55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876H55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876G55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876G55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876F55443221100//..--,,++**))((''&&%%$$##""!!  ==<<;;::998876F55443221100//..--,,++**))((''&&%%$$##""!! m  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopm !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopn  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopo  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopo  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopp  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopq  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopq  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopr  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnops  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnops  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopt  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopt  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopu  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopv  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopv  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopw  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopx  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnoix  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnT y  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklk5u  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkk]s  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkCp  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghic$n  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghO l  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefe2i  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdeXg  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcd?d  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``ab]"b  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``aK a  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_`^/^  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_R\  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]]4Y  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\NW  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZZ0T !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYJR !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWV-O !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVFM !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUT)J !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTCH !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRP&E !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQ? C !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOM#@ !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNO; = !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMJ ; !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKL8 8 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJG6 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHI43 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGC1 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEF0. !"#$%&&'()*+,-./00123456789::;<=>?@ABCDE?, !"#$%&&'()*+,-./00123456789::;<=>?@ABCD-) !"#$%&&'()*+,-./00123456789::;<=>?@AB='!"#$%&&'()*+,-./00123456789::;<=>?@A*$"#$%&&'()*+,-./00123456789::;<=>?9"#$%&&'()*+,-./00123456789::;<=>& $%&&'()*+,-./00123456789::;<4!%&&'()*+,-./00123456789::9"&&'()*+,-./00123456789:+ "&'()*+,-./00123456784"'()*+,-./001234567!#()*+,-./0012345, $)*+,-./001232 $*+,-./0012# %+,-./00+?&,-./-xq'-, N$T#w+AMЀo܌a%E h֑>,`ϗ5';@Qƞŀf٠J|π U2G`]Ѩ rju "',28>DJǻ'G̽;+1'-/ {2pd4K,6v8U4; =_?BÀDŀGɀEt8mk@"o$n#l"k!j hi.@8D IZN SX:^c]i"ot={RLF @ :5 /{+u&n!g`ZD( a` `:r>G|>#:H]]Yk5}F^ X{0-RuL+Mk l $7Lbw'.0CX:g nD tzOZd!%o+ #z  th\PD8'oM.xV "#%(icnV boats-201307/boats.pro000066400000000000000000000037141217277220500145640ustar00rootroot00000000000000TEMPLATE = app TARGET = boats CONFIG += qt \ warn_on include(animation/animation.pri) include(graphicsview/graphicsview.pri) include(itemviews/itemviews.pri) include(model/model.pri) include(locale/locale.pri) INCLUDEPATH += $$PWD HEADERS += \ boatapplication.h \ boats.h \ commontypes.h \ mainwindow.h \ situationprint.h \ situationwidget.h \ trace.h \ undocommands.h \ xmlsituationreader.h \ xmlsituationwriter.h SOURCES += \ boatapplication.cpp \ boats.cpp \ main.cpp \ mainwindow.cpp \ situationprint.cpp \ situationwidget.cpp \ trace.cpp \ undocommands.cpp \ xmlsituationreader.cpp \ xmlsituationwriter.cpp unix_deploy:RESOURCES = boats_unix.qrc else:RESOURCES = boats.qrc mac { QMAKE_LFLAGS += -static QMAKE_INFO_PLIST = Info.plist ICON = boats.icns mime.path = boats.app/Contents/Resources mime.files = xbs.icns INSTALLS += mime } contains(GIF_EXPORT,1) { DEFINES += GIF_EXPORT HEADERS += gifwriter.h SOURCES += gifwriter.cpp LIBS += -lgif } unix_deploy { isEmpty(PREFIX):PREFIX = /usr/local target.path = $${PREFIX}/bin INSTALLS += target desktop.path = $${PREFIX}/share/applications desktop.files = boats.desktop INSTALLS += desktop icons.path = $${PREFIX}/share/icons icons.files = images/icons/* INSTALLS += icons mimetype.path = $${PREFIX}/share/mime mimetype.files = boats.xml INSTALLS += mimetype TRANSLATEDIR = $${PREFIX}/share/boats translations.path = $${TRANSLATEDIR} translations.files = locale/boats_*.qm INSTALLS += translations } else:TRANSLATEDIR = ":/locale" DEFINES += TRANSLATEDIR=\\\"$${TRANSLATEDIR}\\\" PRE_TARGETDEPS += compiler_updateqm_make_all MOC_DIR = .moc/ OBJECTS_DIR = .obj/ QMAKE_CFLAGS_RELEASE += -fvisibility=hidden QMAKE_CXXFLAGS_RELEASE += -fvisibility=hidden -fvisibility-inlines-hidden win32:RC_FILE = boats.rc win32:QMAKE_LFLAGS += -static boats-201307/boats.qrc000066400000000000000000000030371217277220500145470ustar00rootroot00000000000000 locale/boats_da.qm locale/boats_de.qm locale/boats_es.qm locale/boats_fr.qm locale/boats_it.qm locale/boats_ja.qm locale/boats_nl.qm locale/boats_pl.qm locale/boats_pt.qm locale/boats_sl.qm locale/boats_sv.qm images/about.png images/animate.png images/addboat.png images/addmark.png images/addpoint.png images/addpoly.png images/addtrack.png images/export.png images/filenew.png images/fileopen.png images/fileprint.png images/filequickprint.png images/filesave.png images/filesaveas.png images/laylines.png images/pdf.png images/player_loop.png images/player_play.png images/player_pause.png images/player_stop.png images/redo.png images/undo.png images/tab_new.png images/tab_remove.png images/video.png images/zone.png images/zoomfit.png images/zoomin.png images/zoomout.png boats-201307/boats.rc000066400000000000000000000001041217277220500143560ustar00rootroot00000000000000IDI_ICON1 ICON DISCARDABLE "images/boats.ico" boats-201307/boats.xml000066400000000000000000000005651217277220500145650ustar00rootroot00000000000000 Boat Scenario file boats-201307/boats_unix.qrc000066400000000000000000000022101217277220500156020ustar00rootroot00000000000000 images/about.png images/animate.png images/addboat.png images/addmark.png images/addpoint.png images/addpoly.png images/addtrack.png images/export.png images/filenew.png images/fileopen.png images/fileprint.png images/filequickprint.png images/filesave.png images/filesaveas.png images/laylines.png images/pdf.png images/player_loop.png images/player_play.png images/player_pause.png images/player_stop.png images/redo.png images/undo.png images/tab_new.png images/tab_remove.png images/video.png images/zone.png images/zoomfit.png images/zoomin.png images/zoomout.png boats-201307/commontypes.h000066400000000000000000000021721217277220500154550ustar00rootroot00000000000000// // C++ Interface: commontypes // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef COMMONTYPES_H #define COMMONTYPES_H enum DebugTraces { MODEL, VIEW, COMMAND, ANIMATION, DELEGATE, XML, EXPORT }; typedef enum { TRACK_COLOR, TRACK_PATH, TRACK_SERIES, TRACK_FOLLOW } TrackTableItem; typedef enum { WIND_INDEX, WIND_DIRECTION, WIND_DELETE } WindTableItem; #endif boats-201307/doc/000077500000000000000000000000001217277220500134725ustar00rootroot00000000000000boats-201307/doc/boats.1000066400000000000000000000007731217277220500146730ustar00rootroot00000000000000.\" Process this file with .\" groff -man -Tascii foo.1 .\" .TH BOATS 1 "APRIL 2009" .SH NAME boats \- a race scenario drawing tool .SH SYNOPSIS .B boats [-debug n] .I file .B ... .SH DESCRIPTION .B boats Boat Scenario is a drawing tool. It is your ideal companion for training sessions, rule learning, strategy explanations and more. All files provided in the command line will be opened on different tabs. .SH OPTIONS .IP -debug Provide debugging output .SH AUTHOR Thibaut GRIDEL boats-201307/gifwriter.cpp000066400000000000000000000054401217277220500154360ustar00rootroot00000000000000// // C++ Implementation: gifwriter // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #include "gifwriter.h" #include #include #include GifWriter::GifWriter() { } int GifWriter::writeData(const GifByteType *bytes, int size) { return device()->write((char *)bytes, size); } static int myOutputFunc(GifFileType * fileType, const GifByteType * bytes, int size) { GifWriter *writer = reinterpret_cast(fileType->UserData); return writer->writeData(bytes, size); } bool GifWriter::write(QList imageList) { GifFileType *fileType; int retrn; QImage *image = imageList.first(); fileType = EGifOpen((void*) this, myOutputFunc); EGifSetGifVersion("89a"); int colors = 256; ColorMapObject * cmap = MakeMapObject(colors, NULL); for (int i = 0; i< qMin(colors, m_colormap.size()); i++) { QRgb color = m_colormap[i]; cmap->Colors[i].Blue = qBlue(color); cmap->Colors[i].Green = qGreen(color); cmap->Colors[i].Red = qRed(color); } retrn = EGifPutScreenDesc(fileType, image->width(), image->height(), 8, 0, cmap); FreeMapObject(cmap); char nameExtension[11] = { 'N','E','T','S','C','A','P','E','2','.','0' }; char loopExtension[3] = { 1, 0, 0 }; retrn = EGifPutExtensionFirst(fileType, 0xFF, 11, &nameExtension); retrn = EGifPutExtensionNext(fileType, 0xFF, 3, &loopExtension); retrn = EGifPutExtensionLast(fileType, 0xFF, 0, NULL); retrn = EGifPutComment(fileType, "Boat Scenario http://boats.berlios.de"); char gifExtension[4] = { 0, 8, 0, 0 }; foreach (image, imageList) { if (image == imageList.last()) { gifExtension[1] = 0; gifExtension[2] = 2; } retrn = EGifPutExtension(fileType, 0xF9, 4, &gifExtension); retrn = EGifPutImageDesc(fileType, 0, 0, image->width(), image->height(), 0, NULL); for (int i = 0; i < image->height(); i++) { retrn &= EGifPutLine(fileType, (GifPixelType*)image->scanLine(i), image->width()); } } retrn = EGifCloseFile(fileType); return true; } boats-201307/gifwriter.h000066400000000000000000000025401217277220500151010ustar00rootroot00000000000000// // C++ Interface: gifwriter // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #ifndef GIFWRITER_H #define GIFWRITER_H #include #include #include class GifWriter { public: GifWriter(); void setDevice (QIODevice *device) { m_device = device; } QIODevice *device() const { return m_device; } void setColorMap(QImage &image) { m_colormap = image.colorTable(); } QVector colormap() const { return m_colormap; } bool write(QList imageList); int writeData(const GifByteType *bytes, int size); private: QIODevice *m_device; QVector m_colormap; }; #endif // GIFWRITER_H boats-201307/graphicsview/000077500000000000000000000000001217277220500154205ustar00rootroot00000000000000boats-201307/graphicsview/arrow.cpp000066400000000000000000000061061217277220500172610ustar00rootroot00000000000000// // C++ Implementation: ArrowGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include #include "arrow.h" #include "commontypes.h" #include "situationscene.h" #include "situationmodel.h" #include "windmodel.h" extern int debugLevel; ArrowGraphicsItem::ArrowGraphicsItem(WindModel *wind, QGraphicsItem *parent) : QGraphicsItem(parent), m_wind(wind) { setFlag(QGraphicsItem::ItemIsMovable); setFlag(QGraphicsItem::ItemIsSelectable); setVisible(wind->visible()); setPosition(wind->position()); setZValue(0); m_path.moveTo(0,30); m_path.lineTo(7,23); m_path.lineTo(2,23); m_path.lineTo(2,-30); m_path.lineTo(-2,-30); m_path.lineTo(-2,23); m_path.lineTo(-7,23); m_path.lineTo(0,30); connect(wind, SIGNAL(windVisibleChanged(bool)), this, SLOT(deleteItem(bool))); connect(wind, SIGNAL(positionChanged(QPointF)), this, SLOT(setPosition(QPointF))); connect(wind, SIGNAL(directionChanged(qreal)), this, SLOT(setHeading(qreal))); connect(wind, SIGNAL(windReset()), this, SLOT(resetArrow())); } ArrowGraphicsItem::~ArrowGraphicsItem() {} void ArrowGraphicsItem::resetArrow() { setHeading(m_wind->windAt(0)); } void ArrowGraphicsItem::setHeading(qreal value) { m_angle = value; prepareGeometryChange(); setRotation(m_angle); update(); } void ArrowGraphicsItem::setPosition(QPointF position) { prepareGeometryChange(); setPos(position); update(); } void ArrowGraphicsItem::deleteItem(bool visible) { if(!visible) { if (debugLevel & 1 << VIEW) std::cout << "deleting ArrowGraphicsItem for model" << m_wind << std::endl; scene()->removeItem(this); delete this; } } QRectF ArrowGraphicsItem::boundingRect() const { return QRectF(-7, -30, 14, 60); } QPainterPath ArrowGraphicsItem::shape() const { return m_path; } void ArrowGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); if (isSelected()) painter->setPen(Qt::red); else painter->setPen(Qt::black); painter->setBrush(Qt::black); painter->drawPath(m_path); } int ArrowGraphicsItem::type() const { return ARROW_TYPE; } boats-201307/graphicsview/arrow.h000066400000000000000000000040741217277220500167300ustar00rootroot00000000000000// // C++ Interface: ArrowGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef ARROW_H #define ARROW_H #include #include #include class WindModel; /** \class ArrowGraphicsItem \brief the QGraphicsItem for a wind Arrow The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the representation of an arrow on a SituationView. \sa SituationView, SituationScene, SituationModel, WindModel */ class ArrowGraphicsItem : public QObject, public QGraphicsItem { Q_OBJECT Q_INTERFACES(QGraphicsItem) public: ArrowGraphicsItem(WindModel *wind = 0, QGraphicsItem *parent = 0); ~ArrowGraphicsItem(); virtual QRectF boundingRect() const; virtual QPainterPath shape() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); virtual int type() const; public slots: void resetArrow(); void setHeading(qreal value); void setPosition(QPointF position); void deleteItem(bool visible); private: WindModel *m_wind; /// \a m_angle holds the angle of the Arrow qreal m_angle; QPainterPath m_path; }; #endif boats-201307/graphicsview/boat.cpp000066400000000000000000000567271217277220500170720ustar00rootroot00000000000000// // C++ Implementation: BoatGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include #include "boat.h" #include "commontypes.h" #include "situationscene.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" extern int debugLevel; BoatGraphicsItem::BoatGraphicsItem(BoatModel *boat, QGraphicsItem *parent) : QGraphicsItem(parent), m_boat(boat), m_angle(0), m_sail(new SailGraphicsItem(boat, this)), m_jib(new SailGraphicsItem(boat, this)), m_spin(new SpinnakerGraphicsItem(boat, this)), m_genn(new GennakerGraphicsItem(boat, this)), m_hasSpin(false), m_hasGenn(false), m_overlap(Boats::none), m_overlapLine(new QGraphicsLineItem(this)), m_color(boat->track()->color()), m_flag(Boats::noFlag), m_flagRect(new FlagGraphicsItem(this)), m_hidden(false), m_bubble(new BubbleGraphicsItem(m_boat, this)), m_series(Boats::unknown), m_selected(false), m_order(0), m_numberPath(new QGraphicsPathItem(this)), m_laylines(new LaylinesGraphicsItem(boat, this)) { setFlag(QGraphicsItem::ItemIsMovable); setFlag(QGraphicsItem::ItemIsSelectable); setBoundingRegionGranularity(1); m_numberPath->setZValue(1); m_flagRect->setZValue(2); m_sail->setZValue(3); m_jib->setZValue(4); m_spin->setZValue(5); m_genn->setZValue(5); // Make this same as for spinnaker on basis that a boat will have one or other of these, not both m_bubble->setZValue(6); m_numberPath->setBrush(QBrush(Qt::black)); QPen dashPen(Qt::CustomDashLine); QVector dashes; dashes << 5 << 5; dashPen.setDashPattern(dashes); m_overlapLine->setPen(dashPen); setSeries(boat->track()->series()); setHeading(boat->heading()); setPos(boat->position()); setOrder(boat->order()); setDim(boat->dim()); m_sail->setSailAngle(m_boat->trimmedSailAngle()); m_jib->setSailAngle(m_boat->trimmedJibAngle()); m_spin->setHeading(m_boat->heading()); m_spin->setSailAngle(m_boat->trimmedSpinAngle()); m_genn->setSailAngle(m_boat->trimmedGennAngle()); // Use spinTrim() for both spinnaker and gennaker setSpin(boat->spin()); setOverlap(boat->overlap()); setDisplayFlag(boat->flag()); setHidden(boat->hidden()); connect(boat, SIGNAL(headingChanged(qreal)), this, SLOT(setHeading(qreal))); connect(boat, SIGNAL(headingChanged(qreal)), m_spin, SLOT(setHeading(qreal))); connect(boat, SIGNAL(positionChanged(QPointF)), this, SLOT(setPosition(QPointF))); connect(boat, SIGNAL(trimmedSailAngleChanged(qreal)), m_sail, SLOT(setSailAngle(qreal))); connect(boat, SIGNAL(trimmedJibAngleChanged(qreal)), m_jib, SLOT(setSailAngle(qreal))); connect(boat, SIGNAL(spinChanged(bool)), this, SLOT(setSpin(bool))); connect(boat, SIGNAL(trimmedSpinAngleChanged(qreal)), m_spin, SLOT(setSailAngle(qreal))); connect(boat, SIGNAL(trimmedGennAngleChanged(qreal)), m_genn, SLOT(setSailAngle(qreal))); connect(boat, SIGNAL(orderChanged(int)), this, SLOT(setOrder(int))); connect(boat, SIGNAL(overlapChanged(Boats::Overlaps)), this, SLOT(setOverlap(Boats::Overlaps))); connect(boat, SIGNAL(flagChanged(Boats::Flag)), this, SLOT(setDisplayFlag(Boats::Flag))); connect(boat, SIGNAL(hiddenChanged(bool)), this, SLOT(setHidden(bool))); connect(boat, SIGNAL(dimChanged(int)), this, SLOT(setDim(int))); connect(boat->track(), SIGNAL(colorChanged(QColor)), this, SLOT(setColor(QColor))); connect(boat->track(), SIGNAL(seriesChanged(Boats::Series)), this, SLOT(setSeries(Boats::Series))); connect(boat->situation(), SIGNAL(boatRemoved(BoatModel*)), this, SLOT(deleteItem(BoatModel*))); connect(boat->track(), SIGNAL(trackSelected(bool)), this, SLOT(setSelected(bool))); } BoatGraphicsItem::~BoatGraphicsItem() {} void BoatGraphicsItem::setHeading(qreal value) { if (m_angle != value) { m_angle = value; QTransform rotation; rotation.rotate(m_angle), setTransform(rotation, false); } } void BoatGraphicsItem::setPosition(QPointF position) { if (pos() != position) { setPos(position); update(); } } void BoatGraphicsItem::setSpin(bool value) { m_spin->setVisible(m_hasSpin && value); m_genn->setVisible(m_hasGenn && value); } void BoatGraphicsItem::setOrder(int value) { m_order = value; if (m_order && m_numberSize) { QString number = QString::number(m_order); QFont numberFont; numberFont.setPointSize(m_numberSize); QFontMetrics fm(numberFont); QPainterPath fpath; fpath.addText(-fm.width(number)/2.0, 0, numberFont, number); m_numberPath->setPath(fpath); setZValue(m_order); } else { m_numberPath->setPath(QPainterPath()); setZValue(boat()->track()->size()+1); } update(); } void BoatGraphicsItem::setOverlap(Boats::Overlaps value) { if (m_overlap != value) { m_overlap = value; setOverlapLine(); } } void BoatGraphicsItem::setOverlapLine() { qreal size = Boats::seriesSizeList()[m_series]; QLineF line; line.setP1(QPointF(m_border, size/2)); line.setP2(QPointF(-m_border, size/2)); if (m_overlap == Boats::none) { m_overlapLine->setVisible(false); } else { if (m_overlap & Boats::starboard) { line.setP2(QPointF(m_border + size, size/2)); } if (m_overlap & Boats::port) { line.setP1(QPointF(-m_border - size, size/2)); } m_overlapLine->setVisible(!m_hidden && true); m_overlapLine->setLine(line); } } void BoatGraphicsItem::setDisplayFlag(Boats::Flag value) { m_flag = value; m_flagRect->setDisplayFlag(m_flag); if (m_flag == Boats::noFlag) { m_flagRect->setVisible(false); } else { m_flagRect->setVisible(!m_hidden && true); } } void BoatGraphicsItem::setHidden(bool value) { prepareGeometryChange(); m_hidden = value; if (m_hidden) { m_sail->setVisible(false); m_jib->setVisible(false); m_spin->setVisible(false); m_genn->setVisible(false); m_overlapLine->setVisible(false); m_flagRect->setVisible(false); m_bubble->setVisible(false); m_numberPath->setVisible(false); m_laylines->setVisible(false); } else { m_sail->setVisible(true); m_jib->setVisible(true); m_spin->setVisible(boat()->spin()); m_genn->setVisible(boat()->spin()); m_overlapLine->setVisible(m_overlap != Boats::none); m_flagRect->setVisible(m_flag != Boats::noFlag); m_bubble->setVisible(!boat()->text().isEmpty()); m_numberPath->setVisible(true); m_laylines->setVisible(boat()->laylines()); } } void BoatGraphicsItem::setColor(QColor value) { if (m_color != value) { int alpha = m_color.alpha(); m_color = value; m_color.setAlpha(alpha); update(); } } void BoatGraphicsItem::setDim(int value) { m_color.setAlpha(value); if (value == 0 ) { setVisible(false); } else { setVisible(true); if (value != 255) { int maxSize = 0; foreach (const TrackModel *track, boat()->situation()->tracks()) { if (track->boats().size() > maxSize) maxSize = track->boats().size() - 1; } setZValue(maxSize+1); } else { setZValue(boat()->order()); } } update(); } void BoatGraphicsItem::setVisible(bool value) { QGraphicsItem::setVisible(value); } void BoatGraphicsItem::setSeries(Boats::Series value) { if (m_series != value) { prepareGeometryChange(); m_series = value; int posY = 0; QRectF flagRect; QPointF mast; qreal sailSize = 0; QPointF jibTackPos; qreal jibSize = 0; qreal spinSize = 0; QPointF gennTackPos; qreal gennPoleLength = 0; qreal gennSize = 0; qreal maxNormalSailAngle = 90; qreal maxNormalJibAngle = 45; qreal maxWithSpinSailAngle = 65; qreal maxWithSpinJibAngle = 35; QPainterPath path; QRectF boundingRect = QRectF(-50, -50, 100, 100); qreal border = 0; switch (m_series) { case Boats::keelboat: case Boats::keelboatwithgenn: m_numberSize = 12; posY = 25; flagRect = QRectF(-7.5, 30 , 15, 10); mast = QPointF(0, -8.7); sailSize = 41.5; jibTackPos = QPointF(0,-50); jibSize = 40; if (m_series == Boats::keelboat) { spinSize = 1.1 * sailSize; } else { spinSize = 0; } if (m_series == Boats::keelboatwithgenn) { gennTackPos = QPointF(0,-80); gennPoleLength = 30; gennSize = 70; maxWithSpinSailAngle = 40; maxWithSpinJibAngle = 35; } else { gennSize = 0; } path.moveTo(0,-50); path.cubicTo(20, 0, 18, 13, 10, 50); path.lineTo(-10, 50); path.cubicTo(-18, 13, -20, 0, 0, -50); boundingRect = QRectF(-20, -50, 40, 100); border = 10; break; case Boats::int49er: m_numberSize = 7; posY = 9; flagRect = QRectF(-3, 13, 6, 4); mast = QPointF(0, -2.5); sailSize = 27.0; jibTackPos = QPointF(0,-22.5); jibSize = 19.0; gennTackPos = QPointF(0,-42.5); gennPoleLength = 18.5; gennSize = 38.0; maxWithSpinSailAngle = 30; maxWithSpinJibAngle = 25; path.moveTo(0,-24.0); path.lineTo(-0.5,-24.0); path.cubicTo(-1.5,-23.0,-6.5,-5.5,-7.5,1.5); path.lineTo(-13.5,2.4); path.quadTo(-14.0,2.5,-14,3.0); path.lineTo(-14.0,24.0); path.lineTo(-13.5,24.0); path.lineTo(-12.5,21.0); path.lineTo(-7.5,19.0); path.lineTo(-5.0,22.0); path.lineTo(5.0,22.0); path.lineTo(7.5,19.0); path.lineTo(12.5,21.0); path.lineTo(13.5,24.0); path.lineTo(14.0,24.0); path.lineTo(14.0,3.0); path.quadTo(14.0,2.5,13.5,2.4); path.lineTo(7.5,1.5); path.cubicTo(6.5,-5.5,1.5,-23,0.5,-24.0); path.lineTo(0,-24.0); boundingRect = QRectF(-14.0, -24.0, 28.0, 48.0); border = 14.5; break; case Boats::int470: m_numberSize = 7; posY = 9; flagRect = QRectF(-3, 13, 6, 4); mast = QPointF(0, -7.5); sailSize = 26.5; jibTackPos = QPointF(0,-23.5); jibSize = 0.6*sailSize; spinSize = 19.0; path.moveTo(0,-23.5); path.cubicTo(0.8, -23.5, 8.5, -15.0, 8.5, 3.5); path.quadTo(8.5, 12.5, 5.8, 23.5); path.lineTo(-5.8,23.5); path.quadTo(-8.5, 12.5, -8.5, 3.5); path.cubicTo(-8.5, -15.0, -0.8, -23.5, 0, -23.5); boundingRect = QRectF(-8.5,-23.5,17.0,47.0); border = 5.8; break; case Boats::int420: m_numberSize = 7; posY = 9; flagRect = QRectF(-3, 13, 6, 4); mast = QPointF(0, -7.1); sailSize = 24.0; jibTackPos = QPointF(0,-21); jibSize = 0.6*sailSize; spinSize = 17.5; path.moveTo(0,-21); path.cubicTo(1.5, -21, 8.15, -12.5, 8.15, 3.3); path.quadTo(8.15, 11.5, 5.7, 20); path.quadTo(2.8, 21, 0, 21); path.quadTo(-2.8, 21, -5.7, 20); path.quadTo(-8.15, 11.5, -8.15, 3.3); path.cubicTo(-8.15, -12.5, -1.5, -21, 0, -21); boundingRect = QRectF(-8.15,-21,16.3,42); border = 5.7; break; case Boats::int29er: m_numberSize = 7; posY = 9; flagRect = QRectF(-3, 13, 6, 4); mast = QPointF(0, -3.4); sailSize = 20.5; jibTackPos = QPointF(0,-20.5); jibSize = 17.0; gennTackPos = QPointF(0,-34.2); gennPoleLength = 13.7; gennSize = 30.8; maxWithSpinSailAngle = 40; maxWithSpinJibAngle = 35; path.moveTo(0,-20.5); path.lineTo(-0.5,-20.5); path.cubicTo(-3.5,-10.25,-6.6,-1.1,-8.3,-0.5); path.lineTo(-8.8,18); path.lineTo(-4.4,20.5); path.lineTo(4.4,20.5); path.lineTo(8.8,18); path.lineTo(8.3,-0.5); path.cubicTo(6.6,-1.1,3.5,-10.25,0.5,-20.5); path.lineTo(0,-20.5); boundingRect = QRectF(-8.8, -20.5, 17.6, 41.0); border = 4.4; break; case Boats::laser: m_numberSize = 7; posY = 10; flagRect = QRectF(-3, 12 , 6, 4); mast = QPointF(0, -8.7); sailSize = 28.5; path.moveTo(0,-20); path.cubicTo(0.3, -19.7, 0.3, -20.0, 0.7, -19.7); path.cubicTo(3.3, -14.3, 6.7, -3.3, 6.7, 4.7); path.cubicTo(6.7, 11.0, 6.7, 14.3, 5.0, 20.0); path.lineTo(-5.0, 20.0); path.cubicTo(-6.7, 14.3, -6.7, 11.0, -6.7, 4.7); path.cubicTo(-6.7, -3.3, -3.3, -14.3, -0.7, -19.7); path.cubicTo(-0.3, -20.0, -0.3, -19.7, 0, -20); boundingRect = QRectF(-6.7, -20, 13.4, 40); border = 5; break; case Boats::firefly: m_numberSize = 7; posY = 10; flagRect = QRectF(-3, 12 , 6, 4); mast = QPointF(0, -6.5); sailSize = 21.8; jibTackPos = QPointF(0, -18.3); jibSize = 14; path.moveTo(0,-18.3); path.cubicTo(3.7, -14.0, 7.6, -8.0, 7.6, 1.8); path.cubicTo(7.6, 4.2, 7.6, 9.2, 4.9, 18.3); path.lineTo(-4.9, 18.3); path.cubicTo(-7.6, 9.2, -7.6, 4.2, -7.6, 1.8); path.cubicTo(-7.6, -8.0, -3.7, -14.0, 0, -18.3); boundingRect = QRectF(-7.6, -18.3, 15.2, 36.6); border = 4.9; break; case Boats::topper: m_numberSize = 7; posY = 8; flagRect = QRectF(-3, 10 , 6, 4); mast = QPointF(0, -6.5); sailSize = 23.5; path.moveTo(0,-17); path.cubicTo(2.4, -17.0, 2.8, -16.0, 3.7, -14.0); path.cubicTo(4.6, -12.0, 5.8, -6.0, 5.8, -1.0); path.cubicTo(5.8, 1.0, 5.8, 8, 4.4, 17.0); path.lineTo(-4.4, 17.0); path.cubicTo(-5.8, 8, -5.8, 1.0, -5.8, -1.0); path.cubicTo(-5.8, -6.0, -4.6, -12.0, -3.7, -14.0); path.cubicTo(-2.8, -16.0, -2.4, -17.0, 0, -17); boundingRect = QRectF(-5.8, -17, 11.6, 34); border = 4.4; break; case Boats::optimist: m_numberSize = 6; posY = 3; flagRect = QRectF(-2.25, 5 , 4.5, 3); mast = QPointF(0,-6.9); sailSize = 16.5; path.moveTo(0,-11.5); path.cubicTo(1.5, -11.5, 1.7, -11.3, 2.9, -11.1); path.cubicTo(3.6, -9.4, 5.6, -4.0, 5.6, 1.5); path.cubicTo(5.6, 5.4, 5.0, 9.0, 4.6, 11.5); path.lineTo(-4.6, 11.5); path.cubicTo(-5.0, 9.0, -5.6, 5.4, -5.6, 1.5); path.cubicTo(-5.6, -4.0, -3.6, -9.4, -2.9, -11.1); path.cubicTo(-1.7, -11.3, -1.5, -11.5, 0, -11.5); boundingRect = QRectF(-5.6, -11.5, 11.2, 23); border = 4.6; break; case Boats::tornado: m_numberSize = 10; posY = 17; flagRect = QRectF(-4.5, 17.5 , 9, 6); mast = QPointF(0,0); sailSize = 25.5; maxNormalSailAngle = 20; gennTackPos = QPointF(0,-40); gennPoleLength = 40; gennSize = 42; maxWithSpinSailAngle = 20; path.moveTo(0,0); path.lineTo(10.7, 0); path.cubicTo(11.2, -11.7, 12.2, -19.8, 13.2, -30.5); path.cubicTo(14.7, -20.3, 15.3, -6.1, 15.3, 6.1); path.cubicTo(15.3, 13.7, 14.7, 20.8, 14.7, 30.0); path.cubicTo(13.7, 30.5, 13.7, 30.5, 12.7, 30.5); path.cubicTo(12.2, 30.5, 12.2, 30.5, 10.7, 30.0); path.lineTo(10.7, 23.9); path.lineTo(-10.7, 23.9); path.lineTo(-10.7, 30.0); path.cubicTo(-12.2, 30.5, -12.2, 30.5, -12.7, 30.5); path.cubicTo(-13.7, 30.5, -13.7, 30.5, -14.7, 30); path.cubicTo(-14.7, 20.8, -15.3, 13.7, -15.3, 6.1); path.cubicTo(-15.3, -6.1, -14.7, -20.3, -13.2, -30.5); path.cubicTo(-12.2, -19.8, -11.2, -11.7, -10.7, 0); path.lineTo(0, 0); boundingRect = QRectF(-15.3, -30.5, 30.6, 61); border = 14.7; break; case Boats::startboat: m_numberSize = 0; flagRect = QRectF(-7.5, 30 , 15, 10); path.moveTo(0,-50); path.cubicTo(30, -20, 20, 30, 17, 50); path.lineTo(-17, 50); path.cubicTo(-20, 30, -30, -20, 0, -50); path.addEllipse(-1, -10, 2, 2); boundingRect = QRectF(-30, -50, 60, 100); border = 17; break; case Boats::rib: m_numberSize = 10; posY = 10; flagRect = QRectF(-5, 15 , 10, 6.7); path.moveTo(0,-30); path.cubicTo(6, -26, 12.1, -22.9, 12.4, -10.3); path.lineTo(12.4, 23.5); path.lineTo(8.9, 30); path.lineTo(5.5, 23.5); path.lineTo(-5.5, 23.5); path.lineTo(-8.9, 30); path.lineTo(-12.4, 23.5); path.lineTo(-12.4, -10.3); path.cubicTo(-12.1, -22.9, -6, -26, 0, -30); boundingRect = QRectF(-12.4, -30, 24.8, 60); border = 8.9; default: break; } m_hullPath = path; m_boundingRect = boundingRect; m_numberPath->setPos(0, posY); m_flagRect->setRect(flagRect); if (sailSize) { m_boat->setMaxNormalSailAngle(maxNormalSailAngle); m_boat->setMaxWithSpinSailAngle(maxWithSpinSailAngle); m_sail->setPosition(mast); m_sail->setSailSize(sailSize); m_sail->setVisible(true); } else { m_sail->setVisible(false); } if (jibSize) { m_boat->setMaxNormalJibAngle(maxNormalJibAngle); m_boat->setMaxWithSpinJibAngle(maxWithSpinJibAngle); m_jib->setPosition(jibTackPos); m_jib->setSailSize(jibSize); m_jib->setVisible(true); } else { m_jib->setVisible(false); } m_hasSpin = false; m_hasGenn = false; if (spinSize) { m_hasSpin = true; m_spin->setPosition(mast); m_spin->setSailSize(spinSize); m_spin->setVisible(m_boat->spin()); } else { m_spin->setVisible(false); } if (gennSize) { m_hasGenn = true; m_genn->setPosition(gennTackPos); m_genn->setPoleLength(gennPoleLength); m_genn->setSailSize(gennSize); m_genn->setVisible(m_boat->spin()); } else { m_genn->setVisible(false); } m_boat->setHasSpin(m_hasSpin || m_hasGenn); // set setHasSpin true irrespective of type of spinnaker (is just used to control whether Toggle Spinnaker menu item is active) m_border = border; setOverlapLine(); setOrder(m_order); update(); } } void BoatGraphicsItem::deleteItem(BoatModel *boat) { if (boat == m_boat) { if (debugLevel & 1 << VIEW) std::cout << "deleting boatGraphics for model" << m_boat << std::endl; scene()->removeItem(this); delete this; } } void BoatGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { static_cast(scene())->setModelPressed(m_boat); m_multiSelect = (event->modifiers() & Qt::ControlModifier) != 0; m_trackSelect = (event->modifiers() & Qt::ShiftModifier) != 0; if (!isSelected()) { if (!m_multiSelect) { scene()->clearSelection(); } if (!m_trackSelect) { setSelected(true); } else { m_boat->track()->setSelected(true); } m_actOnMouseRelease=false; } else { m_actOnMouseRelease=true; if (m_trackSelect) { if (!m_multiSelect) { scene()->clearSelection(); m_actOnMouseRelease=false; } m_boat->track()->setSelected(true); // NB In this case do NOT set m_actOnMouseRelease to false as mouse click should deselect all boats on track } } if ((event->button() & Qt::RightButton) != 0) { m_actOnMouseRelease = false; } update(); } void BoatGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { Q_UNUSED(event); m_actOnMouseRelease=false; } void BoatGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { Q_UNUSED(event); if (m_actOnMouseRelease) { if (!m_multiSelect) { scene()->clearSelection(); if (!m_trackSelect) { setSelected(true); } else { m_boat->track()->setSelected(true); } } else { if(!m_trackSelect) { setSelected(false); } else { m_boat->track()->setSelected(false); } } } } void BoatGraphicsItem::setSelected(bool selected) { QGraphicsItem::setSelected(selected); } QRectF BoatGraphicsItem::boundingRect() const { if (m_hidden) return QRectF(-3, -3, 6, 6); else return m_boundingRect; } QPainterPath BoatGraphicsItem::shape() const { QPainterPath path; path.addRegion(boundingRegion(QTransform())); return path; } void BoatGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); if (isSelected()) painter->setPen(Qt::red); else painter->setPen(Qt::black); painter->setBrush(m_color); if (m_hidden) painter->drawEllipse(-3, -3, 6, 6); else painter->drawPath(m_hullPath); } int BoatGraphicsItem::type() const { return BOAT_TYPE; } boats-201307/graphicsview/boat.h000066400000000000000000000125031217277220500165170ustar00rootroot00000000000000// // C++ Interface: BoatGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef BOAT_H #define BOAT_H #include #include #include #include "boats.h" #include "sail.h" #include "spinnaker.h" #include "gennaker.h" #include "flag.h" #include "bubble.h" #include "laylines.h" class BoatModel; /** \class BoatGraphicsItem \brief the QGraphicsItem for a boat The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the representation of a BoatModel on a SituationView. \sa SituationView, SituationScene, SituationModel, BoatModel */ class BoatGraphicsItem : public QObject, public QGraphicsItem { Q_OBJECT Q_INTERFACES(QGraphicsItem) public: BoatGraphicsItem(BoatModel *boat, QGraphicsItem *parent = 0); virtual ~BoatGraphicsItem(); BoatModel* boat() const { return m_boat; } BubbleGraphicsItem* bubble() const { return m_bubble; } QRectF boundingRect() const; QPainterPath shape() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); virtual int type() const; public slots: void setHeading(qreal value); void setPosition(QPointF position); void setOrder(int value); void setSpin(bool value); void setOverlap(Boats::Overlaps value); void setDisplayFlag(Boats::Flag value); void setHidden(bool value); void setColor(QColor value); void setDim(int value); void setVisible(bool value); void setSeries(Boats::Series value); void deleteItem(BoatModel *boat); void setSelected(bool selected); protected: virtual void mousePressEvent(QGraphicsSceneMouseEvent *event); virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event); virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); private: void setOverlapLine(); /// \a m_boat holds the BoatModel being represented BoatModel *m_boat; /// \a m_hullPath holds the path for the hull QPainterPath m_hullPath; /// \a m_boundingRect holds the bounding rectangle for the boat QRectF m_boundingRect; /// \a m_angle holds the heading of the boat qreal m_angle; /// \a m_sail holds the sail that will be drawn SailGraphicsItem *m_sail; /// \a m_jib holds the jib SailGraphicsItem *m_jib; /// \a m_spin holds the spinnaker SpinnakerGraphicsItem *m_spin; /// \a m_genn holds the gennaker GennakerGraphicsItem *m_genn; /// \a m_hasSpin is true if boat has a spinnaker bool m_hasSpin; /// \a m_hasGenn is true if boat has a gennaker bool m_hasGenn; /// \a m_overlap holds whether an overlap line should be displayed Boats::Overlaps m_overlap; QGraphicsLineItem *m_overlapLine; /// \a m_border holds the half-width of the boat at the transom qreal m_border; /// \a m_color holds the color of the TrackModel QColor m_color; /// \a m_flag holds the flag to display Boats::Flag m_flag; FlagGraphicsItem *m_flagRect; /// \a m_hidden holds whether the hidden symbol should be displayed bool m_hidden; /// \a m_bubble holds the bubble to display BubbleGraphicsItem *m_bubble; /// \a m_series holds the series of the TrackModel Boats::Series m_series; /// \a m_selected holds selection information bool m_selected; /// \a m_order holds the stacking order in the TrackModel int m_order; /// \a m_numberPath holds the number path that will be drawn on the hull QGraphicsPathItem *m_numberPath; /// \a m_numberSize holds the font size of the number int m_numberSize; /// \a m_laylines holds the laylines for the boat LaylinesGraphicsItem *m_laylines; /// \a m_multiSelect is true if Ctrl-modified was in effect when mousePressEvent happened /// Need to save this state until receive mouseReleaseEvent to determine what to do bool m_multiSelect; /// \a if m_actOnMouseRelease is true then need to do something when mouse button is released bool m_actOnMouseRelease; /// \a m_trackSelect is true if mousePressEvent is Shift-modified /// Need to save this state until receive mouseReleaseEvent to determine what to do bool m_trackSelect; }; #endif boats-201307/graphicsview/boatanimation.cpp000066400000000000000000000123771217277220500207630ustar00rootroot00000000000000// // C++ Implementation: BoatAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #include #include #include #include "boatanimation.h" #include "headinganimation.h" #include "situationmodel.h" #include "splineanimation.h" #include "trackmodel.h" #include "boatmodel.h" #include "boat.h" /** Populates the internal lists of Positions and Headings function of time This method parses the path of the \a track, does some stalling analysis and determines position and heading as a function of time. It also gives the pale color to \a track boats, while keeping original color for animation \a boat. */ BoatAnimation::BoatAnimation(TrackModel *track, BoatGraphicsItem *boat, int maxSize, QObject *parent) : QParallelAnimationGroup(parent), m_track(track), m_boat(boat), m_headingAnimation(new HeadingAnimation(boat->boat(), "heading")), m_sailAngleAnimation(new HeadingAnimation(boat->boat(), "trimSailAngle")), m_posAnimation(new QSequentialAnimationGroup), m_maxSize(maxSize), m_time(QTime::currentTime()) { QPainterPath path = m_track->path(); int size = m_track->size() - 1; if (size < 0) { return; } m_boat->setOrder(0); QPointF point = path.elementAt(0); // setPosAt(0,point); BoatModel *model = m_track->boats()[0]; m_headingAnimation->setDuration(2000*m_maxSize); m_headingAnimation->setStartValue(model->heading()); m_sailAngleAnimation->setDuration(2000*m_maxSize); m_sailAngleAnimation->setStartValue(model->trimmedSailAngle()); // through all boats of the track for (int i=0; i< size; i++) { qreal index = 0; QPointF c1 = path.elementAt(i*3+1); QPointF c2 = path.elementAt(i*3+2); QPointF end = path.elementAt(i*3+3); bool stalled = ((point == c1) || (c2 == end)); QPainterPath curve(point); curve.cubicTo(c1,c2,end); qreal length = curve.length(); float e = 8; // through 8 intermediary points between 2 boats for (int j=1; j<=e; j++) { qreal percent = curve.percentAtLength(length*j/e); index = (i*e+j)/(maxSize*e); if (!stalled) { m_headingAnimation->setKeyValueAt(index, fmod(360+90-curve.angleAtPercent(percent),360.0)); } } model = m_track->boats()[i+1]; if (stalled) { m_headingAnimation->setKeyValueAt(index, model->heading()); } m_sailAngleAnimation->setKeyValueAt(index, model->trimmedSailAngle()); SplineAnimation *splineAnimation = new SplineAnimation(m_boat->boat(), "pos", m_track->boats()[i]->path()); splineAnimation->setStartValue(point); splineAnimation->setEndValue(end); splineAnimation->setDuration(2000); m_posAnimation->addAnimation(splineAnimation); point = end; } // dim all track boats foreach(BoatModel *boat, m_track->boats()) { boat->setDim(true); } } /** Resets the color and List of BoatModels in the track */ BoatAnimation::~BoatAnimation() { while (!m_boats.isEmpty()) { m_track->addBoat(m_boats.last()); m_boats.pop_back(); } // undim all track boats foreach(BoatModel *boat, m_track->boats()) { boat->setDim(false); } } /** Updates TrackModel and animation boat position and heading at \a step time, with a rate limit of one refresh every 40ms */ void BoatAnimation::afterAnimationStep(qreal step) { // limit update rate to 40ms if ((m_time.elapsed() < 40) && (step != 0) && (step != 1)) { return; } m_headingAnimation->setCurrentTime(step*2000*m_maxSize); m_sailAngleAnimation->setCurrentTime(step*2000*m_maxSize); m_posAnimation->setCurrentTime(step*2000*m_maxSize); int index = floor(step * m_maxSize); BoatModel *boat; for (int i=m_track->size()-1; i > index; i--) { boat = m_track->boats()[i]; m_boats.push_back(boat); m_track->deleteBoat(boat); } if (!m_boats.isEmpty()) { for (int i = m_track->size()-1; i < index; i++) { m_track->addBoat(m_boats.last()); m_boats.pop_back(); } } if (index > m_track->size() - 1) { return; } boat = m_track->boats()[index]; m_boat->boat()->setOverlap(boat->overlap()); m_boat->boat()->setFlag(boat->flag()); m_boat->boat()->setText(boat->text()); m_boat->boat()->setTextPosition(boat->textPosition()); m_boat->boat()->setSpin(boat->spin()); // trigger next update rate calculation m_time.start(); } boats-201307/graphicsview/boatanimation.h000066400000000000000000000046521217277220500204250ustar00rootroot00000000000000// // C++ Interface: BoatAnimation // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #ifndef BOATANIMATION_H #define BOATANIMATION_H #include #include #include class BoatGraphicsItem; class TrackModel; class BoatModel; class HeadingAnimation; /** \class BoatAnimation \brief The animation Item for a scenario The class is the animation helper for a Scenario, according to the Graphics View Framework. It inherits QGraphicsItemAnimation and provides BoatGraphicsItem specific animation features, like position and heading given a time step. It also does a rate limiting update for drawing as Windows platforms suffer from that. \sa SituationScene, SituationModel */ class BoatAnimation : public QParallelAnimationGroup { public: BoatAnimation(TrackModel *track, BoatGraphicsItem *boat, int maxSize, QObject *parent = 0); ~BoatAnimation(); BoatGraphicsItem *boat() const {return m_boat; } protected: virtual void afterAnimationStep(qreal step); private: /// \a m_track holds the reference to the track TrackModel *m_track; /// \a m_boats holds the List of boats hidden during animation QList m_boats; /// \a m_boat holds the reference to the animation BoatGraphicsItem BoatGraphicsItem *m_boat; HeadingAnimation *m_headingAnimation; HeadingAnimation *m_sailAngleAnimation; QSequentialAnimationGroup *m_posAnimation; /// \a m_maxSize holds the maximum track size of the scenario int m_maxSize; /// \a m_time holds the timer used for movement filtering QTime m_time; }; #endif boats-201307/graphicsview/bubble.cpp000066400000000000000000000125411217277220500173620ustar00rootroot00000000000000// // C++ Implementation: BubbleGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #include #include #include #include #include "bubble.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" #include "undocommands.h" extern int debugLevel; BubbleGraphicsItem::BubbleGraphicsItem(PositionModel *model, QGraphicsItem *parent) : QGraphicsTextItem(parent), m_model(model), m_tail(new QGraphicsPolygonItem(parent)) { setFlag(QGraphicsItem::ItemIsMovable); setFlag(QGraphicsItem::ItemIsSelectable); m_tail->setZValue(0); m_tail->setBrush(Qt::white); updateText(model->text()); setPosition(model->textPosition()); connect(document(), SIGNAL(contentsChanged()), this, SLOT(setText())); if (m_model->inherits("BoatModel")) { BoatModel *boat = static_cast (m_model); connect(boat, SIGNAL(headingChanged(qreal)), this, SLOT(setTail())); } connect(model, SIGNAL(textChanged(QString)), this, SLOT(updateText(QString))); connect(model, SIGNAL(textPositionChanged(QPointF)), this, SLOT(setPosition(QPointF))); } BubbleGraphicsItem::~BubbleGraphicsItem() {} /// update view from model changes void BubbleGraphicsItem::updateText(QString value) { setVisible(!value.isEmpty()); if (document()->toPlainText() != value) setPlainText(value); setTail(); } /// set model from control changes void BubbleGraphicsItem::setText() { if (m_model->situation()) { if (document()->toPlainText() != m_model->text()) { m_model->situation()->undoStack()->push(new SetTextUndoCommand(m_model, document()->toPlainText())); setVisible(!document()->toPlainText().isEmpty()); setTail(); } } } /// update view from model changes void BubbleGraphicsItem::setPosition(QPointF position) { setPos(position); setTail(); update(); } void BubbleGraphicsItem::setTail() { double a = 0; if (BoatModel *boat = dynamic_cast (m_model)) { a = -boat->heading() * M_PI / 180; // set the transform to have horizontal text setTransform(QTransform().rotateRadians(a)); } //centerx,y is half the size of the text double centerx = boundingRect().width()/2; double centery = boundingRect().height()/2; // x,y is the center of the text double x = pos().x() + centerx*cos(a) - centery*sin(a); double y = pos().y() + centerx*sin(a) + centery*cos(a); // t is a factor for the width of the tail double t = boundingRect().height()/5; // q is the angle of the tail double q = atan2(y, x); QPolygonF polygon; polygon << QPointF(x,y) << QPointF(x - t*sin(q), y + t*cos(q)) << QPointF(x/2, y/2) << QPointF(x + t*sin(q), y - t*cos(q)); m_tail->setPolygon(polygon); } QRectF BubbleGraphicsItem::boundingRect() const { return QGraphicsTextItem::boundingRect().adjusted(-4, -4, 4, 4); } void BubbleGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { QPainterPath path; path.addRoundedRect(QGraphicsTextItem::boundingRect().adjusted(-2, -2, 2, 2), 15.0, 15.0, Qt::RelativeSize); painter->save(); painter->setBrush(Qt::white); painter->drawPath(path); painter->restore(); QGraphicsTextItem::paint(painter, option, widget); } void BubbleGraphicsItem::setVisible(bool visible) { QGraphicsItem::setVisible(visible); m_tail->setVisible(visible); } void BubbleGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { m_clickTime.start(); QGraphicsTextItem::mousePressEvent(event); m_fromPosition = m_model->textPosition(); } void BubbleGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { QGraphicsTextItem::mouseMoveEvent(event); setTail(); } void BubbleGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { bool click = (m_clickTime.elapsed() < 250); if (click) { setTextInteractionFlags(Qt::TextEditorInteraction); setFocus(Qt::MouseFocusReason); } else { setTextInteractionFlags(Qt::NoTextInteraction); } QGraphicsTextItem::mouseReleaseEvent(event); if (pos() != m_fromPosition) { m_model->situation()->undoStack()->push(new MoveTextUndoCommand(m_model, pos() - m_fromPosition)); } } void BubbleGraphicsItem::focusOutEvent(QFocusEvent *event) { setTextInteractionFlags(Qt::NoTextInteraction); QGraphicsTextItem::focusOutEvent(event); } boats-201307/graphicsview/bubble.h000066400000000000000000000050431217277220500170260ustar00rootroot00000000000000// // C++ Interface: BubbleGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #ifndef BUBBLE_H #define BUBBLE_H #include #include #include "boats.h" class PositionModel; /** \class BubbleGraphicsItem \brief the QGraphicsItem for a bubble The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the text representation of a PositionModel on a SituationView. \sa SituationView, SituationScene, SituationModel, BoatModel */ class BubbleGraphicsItem : public QGraphicsTextItem { Q_OBJECT public: BubbleGraphicsItem(PositionModel *model, QGraphicsItem *parent = 0); virtual ~BubbleGraphicsItem(); PositionModel* model() const { return m_model; } QRectF boundingRect() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void setVisible(bool visible); public slots: void updateText(QString value); void setText(); void setPosition(QPointF position); void setTail(); protected: virtual void mousePressEvent(QGraphicsSceneMouseEvent *event); virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event); virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); virtual void focusOutEvent (QFocusEvent *event); private: /// \a m_model holds the PositionModel being represented PositionModel *m_model; /// \a m_fromPosition holds the position of the mousePress QPointF m_fromPosition; /// \a m_tail holds the leader line to the boat QGraphicsPolygonItem *m_tail; QTime m_clickTime; }; #endif // BUBBLE_H boats-201307/graphicsview/flag.cpp000066400000000000000000000061471217277220500170450ustar00rootroot00000000000000// // C++ Implementation: FlagGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #include "flag.h" #include "commontypes.h" #include "situationscene.h" FlagGraphicsItem::FlagGraphicsItem(QGraphicsItem *parent) : QGraphicsItem(parent) { } FlagGraphicsItem::~FlagGraphicsItem() {} QRectF FlagGraphicsItem::boundingRect() const { return m_rect; } QPainterPath FlagGraphicsItem::shape() const { QPainterPath path; path.addRect(m_rect); return path; } void FlagGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); switch (m_flag) { case Boats::Y: { painter->setBrush(Qt::red); painter->drawRect(m_rect); painter->translate(m_rect.left(), m_rect.top()); QPolygonF polygon; qreal sixth = m_rect.width() / 6; qreal height = m_rect.height(); polygon << QPointF(0, 0) << QPointF(sixth, 0) << QPointF(-3*sixth, height) << QPointF(-4*sixth, height); painter->setPen(Qt::transparent); painter->setBrush(Qt::yellow); for (int i=0; i<5; i++) { painter->drawPolygon(polygon.intersected(QPolygonF(QRectF(0, 0, m_rect.width(), m_rect.height())))); polygon.translate(2*sixth, 0); } break; } case Boats::Red: painter->setBrush(Qt::red); painter->drawRect(m_rect); break; case Boats::Yellow: painter->setBrush(Qt::yellow); painter->drawRect(m_rect); break; case Boats::Blue: painter->setBrush(Qt::blue); painter->drawRect(m_rect); break; case Boats::Green: { painter->setBrush(Qt::white); painter->drawRect(m_rect); painter->translate(m_rect.left(), m_rect.top()); QPolygonF polygon; qreal halfw = m_rect.width() / 2; qreal halfh = m_rect.height() / 2; polygon << QPointF(0, 0) << QPointF(halfw, 0) << QPointF(halfw, halfh) << QPointF(0, halfh); painter->setBrush(Qt::green); painter->drawPolygon(polygon); polygon.translate(halfw, halfh); painter->drawPolygon(polygon); break; } default: break; } } boats-201307/graphicsview/flag.h000066400000000000000000000034471217277220500165120ustar00rootroot00000000000000// // C++ Interface: FlagGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #ifndef FLAG_H #define FLAG_H #include #include "boats.h" /** \class FlagGraphicsItem \brief the QGraphicsItem for a flag The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework. It displays the representation of a Flag on a SituationView. \sa SituationView, SituationScene, */ class FlagGraphicsItem : public QGraphicsItem { public: FlagGraphicsItem(QGraphicsItem *parent = 0); virtual ~FlagGraphicsItem(); QRectF boundingRect() const; QPainterPath shape() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void setDisplayFlag(Boats::Flag value) {m_flag = value; update();} void setRect(QRectF value) { prepareGeometryChange(); m_rect = value; update();} private: /// \a m_flag holds the flag to display Boats::Flag m_flag; QRectF m_rect; }; #endif // FLAG_H boats-201307/graphicsview/gennaker.cpp000066400000000000000000000075271217277220500177310ustar00rootroot00000000000000// // C++ Implementation: GennakerGraphicsItem // // Description: // // // Author: Graham Louth // // Copyright (c) 2013 Graham Louth // // 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 . // // #include #include #include #include "gennaker.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" extern int debugLevel; GennakerGraphicsItem::GennakerGraphicsItem(BoatModel *boat, QGraphicsItem *parent) : SailGraphicsItem(boat, parent), m_pole(new QGraphicsLineItem(parent)) { //NB boat as parent to avoid need to offset sail rotatation for pole } GennakerGraphicsItem::~GennakerGraphicsItem() {} void GennakerGraphicsItem::setSailSize(qreal sailSize) { m_sailSize = sailSize; QPainterPath sailPathStalled; sailPathStalled.cubicTo(.1 * sailSize, .2 * sailSize, .1 * sailSize, .2 * sailSize, 0, .3 * sailSize); sailPathStalled.cubicTo(-.1 * sailSize, .4 * sailSize, -.1 * sailSize, .4 * sailSize, 0, .5 * sailSize); sailPathStalled.cubicTo(.1 * sailSize, .6 * sailSize, .1 * sailSize, .6 * sailSize, 0, .7 * sailSize); sailPathStalled.cubicTo(-.1 * sailSize, .8 * sailSize, -.1 * sailSize, .8 * sailSize, 0, sailSize); sailPathStalled.lineTo(0, 0); m_sailPathStalled = sailPathStalled; QPainterPath sailPathStarboard; sailPathStarboard.cubicTo(.35 * sailSize, .3 * sailSize, .28 * sailSize, .6 * sailSize, 0, sailSize); sailPathStarboard.cubicTo(.2 * sailSize, .6 * sailSize, .25 * sailSize, .3 * sailSize, 0, 0); m_sailPathStarboard = sailPathStarboard; QPainterPath sailPathPort; sailPathPort.cubicTo(-.35 * sailSize, .3 * sailSize, -.28 * sailSize, .6 * sailSize, 0, sailSize); sailPathPort.cubicTo(-.2 * sailSize, .6 * sailSize, -.25 * sailSize, .3 * sailSize, 0, 0); m_sailPathPort = sailPathPort; setSailAngle(m_sailAngle); } void GennakerGraphicsItem::setPoleLength(qreal length) { m_pole->setLine(0,0,0,length); QPen polePen; polePen.setWidthF(0.5); polePen.setCapStyle(Qt::FlatCap); m_pole->setPen(polePen); } void GennakerGraphicsItem::setPosition(QPointF position) { if (pos() != position) { setPos(position); m_pole->setPos(position); update(); } } void GennakerGraphicsItem::setVisible(bool visibility) { if (isVisible() != visibility) { SailGraphicsItem::setVisible(visibility); m_pole->setVisible(visibility); update(); } } /// calculate a sail incidence angle, corrected with user trimming void GennakerGraphicsItem::setSailAngle(qreal value) { m_sailAngle = value; qreal angle = fmod(m_boat->heading() - m_boat->wind() - m_sailAngle +360, 360); if(angle < 0) angle +=360; if ((angle < 55 || angle > 305 || (angle > 170 && angle < 190)) && path() != m_sailPathStalled) { setPath(m_sailPathStalled); } else if (angle >= 55 && angle <= 170 && path() != m_sailPathStarboard) { setPath(m_sailPathStarboard); } else if (angle >= 190 && angle <= 305 && path() != m_sailPathPort) { setPath(m_sailPathPort); } QTransform transform; transform.rotate(- m_sailAngle); setTransform(transform, false); } boats-201307/graphicsview/gennaker.h000066400000000000000000000035071217277220500173700ustar00rootroot00000000000000// // C++ Interface: GennakerGraphicsItem // // Description: // // // Author: Graham Louth // // Copyright (c) 2013 Graham Louth // // 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 . // // #ifndef GENNAKER_H #define GENNAKER_H #include #include #include "boats.h" #include "sail.h" class BoatModel; /** \class GennakerGraphicsItem \brief the QGraphicsItem for a gennaker The class represents the Item according to the Graphics View Framework. It inherits QGraphicsPathItem for Item framework and QObject for slot and signal framework. It displays the sail representation of a BoatModel on a SituationView. \sa SituationView, SituationScene, SituationModel, BoatModel */ class GennakerGraphicsItem : public SailGraphicsItem { Q_OBJECT public: GennakerGraphicsItem(BoatModel *boat, QGraphicsItem *parent = 0); virtual ~GennakerGraphicsItem(); void setSailSize(qreal size); void setPoleLength(qreal length); void setPosition(QPointF position); void setVisible(bool visibility); public slots: void setSailAngle(qreal value); private: QGraphicsLineItem *m_pole; }; #endif // GENNAKER_H boats-201307/graphicsview/graphicsview.pri000066400000000000000000000013031217277220500206240ustar00rootroot00000000000000INCLUDEPATH += $$PWD DEPENDPATH += $$PWD HEADERS += \ $$PWD/arrow.h \ $$PWD/boat.h \ $$PWD/bubble.h \ $$PWD/flag.h \ $$PWD/laylines.h \ $$PWD/mark.h \ $$PWD/point.h \ $$PWD/polyline.h \ $$PWD/sail.h \ $$PWD/situationscene.h \ $$PWD/situationview.h \ $$PWD/spinnaker.h \ $$PWD/gennaker.h \ $$PWD/track.h SOURCES += \ $$PWD/arrow.cpp \ $$PWD/boat.cpp \ $$PWD/bubble.cpp \ $$PWD/flag.cpp \ $$PWD/laylines.cpp \ $$PWD/mark.cpp \ $$PWD/point.cpp \ $$PWD/polyline.cpp \ $$PWD/sail.cpp \ $$PWD/situationscene.cpp \ $$PWD/situationview.cpp \ $$PWD/spinnaker.cpp \ $$PWD/gennaker.cpp \ $$PWD/track.cpp boats-201307/graphicsview/laylines.cpp000066400000000000000000000073321217277220500177510ustar00rootroot00000000000000// // C++ Implementation: LaylinesGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include "laylines.h" #include "commontypes.h" #include "situationmodel.h" extern int debugLevel; LaylinesGraphicsItem::LaylinesGraphicsItem(PositionModel *model, QGraphicsItem *parent) : QGraphicsPathItem(parent), m_model(model), m_length(model->situation()->situationLength()), m_boatLength(Boats::seriesSizeList()[model->situation()->situationSeries()]), m_laylineAngle(model->situation()->laylineAngle()), m_heading(model->heading()) { setFlag(QGraphicsItem::ItemStacksBehindParent); setPen(Qt::DashLine); updatePath(); setVisible(m_model->laylines()); setWind(model->wind()); connect(m_model, SIGNAL(laylinesChanged(bool)), this, SLOT(setVisible(bool))); connect(m_model, SIGNAL(headingChanged(qreal)), this, SLOT(setHeading(qreal))); connect(m_model, SIGNAL(windChanged(qreal)), this, SLOT(setWind(qreal))); connect(m_model->situation(), SIGNAL(lengthChanged(int)), this, SLOT(setLength(int))); connect(m_model->situation(), SIGNAL(laylineChanged(int)), this, SLOT(setLaylineAngle(int))); connect(m_model->situation(), SIGNAL(seriesChanged(int)), this, SLOT(setSeries(int))); } LaylinesGraphicsItem::~LaylinesGraphicsItem() {} void LaylinesGraphicsItem::setLength(int value) { if (m_length != value) { prepareGeometryChange(); m_length = value; updatePath(); } } void LaylinesGraphicsItem::setSeries(int value) { int boatLength = Boats::seriesSizeList()[value]; if (m_boatLength != boatLength) { m_boatLength = boatLength; updatePath(); } } void LaylinesGraphicsItem::setLaylineAngle(int value) { if (m_laylineAngle != value) { m_laylineAngle = value; updatePath(); } } void LaylinesGraphicsItem::setHeading(qreal value) { if(m_heading != value) { m_heading = value; QTransform transform; transform.rotate(m_wind - m_heading); setTransform(transform, false); } } void LaylinesGraphicsItem::setWind(qreal value) { if(m_wind != value) { m_wind = value; QTransform transform; transform.rotate(m_wind - m_heading); setTransform(transform, false); } } void LaylinesGraphicsItem::setVisible(bool visible) { QGraphicsItem::setVisible(visible); // hack for performance issues. It seems an invisible path costs much if(m_visible != visible) { m_visible = visible; updatePath(); } } void LaylinesGraphicsItem::updatePath() { QPainterPath path; int r = 1.25 * m_length * m_boatLength; qreal theta = m_laylineAngle * M_PI /180; if(m_visible) { path.lineTo(r*sin(theta), r*cos(theta)); // starboard layline path.moveTo(0, 0); path.lineTo(-r*sin(theta), r*cos(theta)); // port layline } setPath(path); } boats-201307/graphicsview/laylines.h000066400000000000000000000044601217277220500174150ustar00rootroot00000000000000// // C++ Interface: LaylinesGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef LAYLINES_H #define LAYLINES_H #include #include #include "boats.h" class PositionModel; /** \class LaylinesGraphicsItem \brief the QGraphicsItem for laylines The class represents the Item according to the Graphics View Framework. It inherits QGraphicsPathItem for Item framework and QObject for slot and signal framework. It displays the laylines of a PositionModel on a SituationView. \sa SituationView, SituationScene, SituationModel, PositionModel */ class LaylinesGraphicsItem : public QObject, public QGraphicsPathItem { Q_OBJECT Q_INTERFACES(QGraphicsItem) public: LaylinesGraphicsItem(PositionModel *model, QGraphicsItem *parent = 0); virtual ~LaylinesGraphicsItem(); void updatePath(); public slots: void setLength(int length); void setSeries(int value); void setLaylineAngle(int value); void setHeading(qreal value); void setWind(qreal value); void setVisible(bool visible); protected: /// \a m_model holds the PositionModel being represented PositionModel *m_model; /// \a m_length holds the number of boat lengths for zone int m_length; /// \a m_boatLength holds the size in scene coordinates for main series int m_boatLength; /// \a m_laylineAngle holds the layline angle int m_laylineAngle; qreal m_heading; qreal m_wind; bool m_visible; }; #endif // LAYLINES_H boats-201307/graphicsview/mark.cpp000066400000000000000000000201201217277220500170510ustar00rootroot00000000000000// // C++ Implementation: MarkGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include "mark.h" #include "commontypes.h" #include "situationscene.h" #include "situationmodel.h" #include "markmodel.h" #include "bubble.h" extern int debugLevel; MarkGraphicsItem::MarkGraphicsItem(MarkModel *mark, QGraphicsItem *parent) : QGraphicsItem(parent), m_mark(mark), m_color(mark->color()), m_zone(mark->zone()), m_length(mark->length()), m_boatLength(Boats::seriesSizeList()[m_mark->situation()->situationSeries()]), m_bubble(new BubbleGraphicsItem(m_mark, this)), m_selected(false), m_order(mark->order()), m_laylines(new LaylinesGraphicsItem(m_mark, this)), m_heading(mark->heading()), m_arrowVisible(mark->arrowVisible()), m_leaveToPort(mark->leaveToPort()), m_labelVisible(mark->labelVisible()), m_labelText(mark->labelText()) { setFlag(QGraphicsItem::ItemIsMovable); setFlag(QGraphicsItem::ItemIsSelectable); setPos(mark->position()); setZValue(m_order); m_bubble->setZValue(1); connect(mark, SIGNAL(positionChanged(QPointF)), this, SLOT(setPosition(QPointF))); connect(mark, SIGNAL(orderChanged(int)), this, SLOT(setOrder(int))); connect(mark, SIGNAL(colorChanged(QColor)), this, SLOT(setColor(QColor))); connect(mark, SIGNAL(zoneChanged(bool)), this, SLOT(setZone(bool))); connect(mark, SIGNAL(lengthChanged(int)), this, SLOT(setLength(int))); connect(mark->situation(), SIGNAL(seriesChanged(int)), this, SLOT(setSeries(int))); connect(mark->situation(), SIGNAL(markRemoved(MarkModel*)), this, SLOT(deleteItem(MarkModel*))); connect(mark, SIGNAL(headingChanged(qreal)), this, SLOT(setHeading(qreal))); connect(mark, SIGNAL(arrowVisibilityChanged(bool)), this, SLOT(setArrowVisible(bool))); connect(mark, SIGNAL(leaveToPortChanged(bool)), this, SLOT(setLeaveToPort(bool))); connect(mark, SIGNAL(labelVisibilityChanged(bool)), this, SLOT(setLabelVisible(bool))); connect(mark, SIGNAL(labelTextChanged(QString)), this, SLOT(setLabelText(QString))); } MarkGraphicsItem::~MarkGraphicsItem() {} void MarkGraphicsItem::setPosition(QPointF position) { if (pos() != position) { setPos(position); update(); } } void MarkGraphicsItem::setOrder(int value) { if (m_order != value) { m_order = value; update(); } } void MarkGraphicsItem::setColor(QColor value) { if (m_color != value) { m_color = value; update(); } } void MarkGraphicsItem::setZone(bool value) { if (m_zone != value) { prepareGeometryChange(); m_zone = value; update(); } } void MarkGraphicsItem::setLength(int value) { if (m_length != value) { prepareGeometryChange(); m_length = value; update(); } } void MarkGraphicsItem::setSeries(int value) { int boatLength = Boats::seriesSizeList()[value]; if (m_boatLength != boatLength) { prepareGeometryChange(); m_boatLength = boatLength; update(); } } void MarkGraphicsItem::deleteItem(MarkModel *mark) { if (mark == m_mark) { if (debugLevel & 1 << VIEW) std::cout << "deleting markGraphics for model" << m_mark << std::endl; scene()->removeItem(this); delete this; } } void MarkGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { static_cast(scene())->setModelPressed(m_mark); m_multiSelect = (event->modifiers() & Qt::ControlModifier) != 0; if (!isSelected()) { if (!m_multiSelect) { scene()->clearSelection(); } setSelected(true); m_actOnMouseRelease=false; } else { m_actOnMouseRelease=true; } if ((event->button() & Qt::RightButton) != 0) { m_actOnMouseRelease = false; } update(); } void MarkGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { Q_UNUSED(event); m_actOnMouseRelease=false; } void MarkGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { Q_UNUSED(event); if (m_actOnMouseRelease) { if (!m_multiSelect) { scene()->clearSelection(); setSelected(true); } else { setSelected(false); } } } void MarkGraphicsItem::setHeading(qreal heading) { if (m_heading != heading) { m_heading = heading; QTransform rotation; rotation.rotate(m_heading), setTransform(rotation, false); } } void MarkGraphicsItem::setArrowVisible(bool visible) { if (m_arrowVisible != visible) { m_arrowVisible = visible; update(); } } void MarkGraphicsItem::setLeaveToPort(bool leaveToPort) { if (m_leaveToPort != leaveToPort) { m_leaveToPort = leaveToPort; update(); } } void MarkGraphicsItem::setLabelVisible(bool visible) { if (m_labelVisible != visible) { m_labelVisible = visible; update(); } } void MarkGraphicsItem::setLabelText(QString text) { if (m_labelText != text) { m_labelText = text; update(); } } QRectF MarkGraphicsItem::boundingRect() const { int r = m_length * m_boatLength; return QRectF(-r, -r, 2*r, 2*r); } QPainterPath MarkGraphicsItem::shape() const { QPainterPath path; // Need to increase size of shape to include mark arrow so that can click on it to rotate path.addEllipse(QPointF(0,0),35,35); return path; } void MarkGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); if (isSelected()) painter->setPen(Qt::red); else painter->setPen(Qt::black); painter->setBrush(m_color); QPointF point(0, 0); painter->drawEllipse(point,10,10); if (m_labelVisible) { painter->rotate(-m_heading); painter->drawText(QRectF(-35,-35,70,70),Qt::AlignCenter,m_labelText); painter->rotate(m_heading); } if (m_zone) { painter->setBrush(Qt::NoBrush); painter->setPen(Qt::DashLine); int r = m_length * m_boatLength; painter->drawEllipse(point, r, r); } // Additional code to draw mark rounding arrow if (m_arrowVisible) { QPainterPath port_path, stbd_path; port_path.moveTo(-25,0); port_path.lineTo(-20,0); port_path.lineTo(-30,10); port_path.lineTo(-40,0); port_path.lineTo(-35,0); port_path.arcTo(-35,-35,70,70,180,-90); port_path.arcTo(-25,-25,50,50,90,90); stbd_path.moveTo(0,-25); stbd_path.lineTo(0,-20); stbd_path.lineTo(10,-30); stbd_path.lineTo(0,-40); stbd_path.lineTo(0,-35); stbd_path.arcTo(-35,-35,70,70,90,90); stbd_path.arcTo(-25,-25,50,50,180,-90); QPen arrowpen; arrowpen.setWidth(2); arrowpen.setColor(Qt::lightGray); painter->setPen(arrowpen); painter->setBrush(Qt::NoBrush); painter->rotate(45.0); if (m_leaveToPort) { painter->drawPath(port_path); } else { painter->drawPath(stbd_path); } } } int MarkGraphicsItem::type() const { return MARK_TYPE; } boats-201307/graphicsview/mark.h000066400000000000000000000101101217277220500165140ustar00rootroot00000000000000// // C++ Interface: MarkGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef MARK_H #define MARK_H #include #include #include #include "commontypes.h" #include "bubble.h" #include "laylines.h" class MarkModel; /** \class MarkGraphicsItem \brief the QGraphicsItem for a mark The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the representation of a MarkModel on a SituationView. \sa SituationView, SituationScene, SituationModel, MarkModel */ class MarkGraphicsItem : public QObject, public QGraphicsItem { Q_OBJECT Q_INTERFACES(QGraphicsItem) public: MarkGraphicsItem(MarkModel *mark = 0, QGraphicsItem *parent = 0); ~MarkGraphicsItem(); MarkModel* mark() const { return m_mark; } BubbleGraphicsItem* bubble() const { return m_bubble; } QRectF boundingRect() const; QPainterPath shape() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); int type() const; public slots: void setPosition(QPointF position); void setOrder(int value); void setColor(QColor value); void setZone(bool zone); void setLength(int length); void setSeries(int value); void deleteItem(MarkModel *mark); void setHeading(qreal heading); void setArrowVisible(bool visible); void setLeaveToPort(bool leaveToPort); void setLabelVisible(bool visible); void setLabelText(QString text); protected: virtual void mousePressEvent(QGraphicsSceneMouseEvent *event); virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event); virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); private: /// \a m_mark holds the MarkModel being represented MarkModel *m_mark; /// \a m_color holds the color of the mark QColor m_color; /// \a m_zone holds wether zone is displayed bool m_zone; /// \a m_length holds the number of boat lengths for zone int m_length; /// \a m_boatLength holds the size in scene coordinates for main series int m_boatLength; /// \a m_bubble holds the bubble to display BubbleGraphicsItem *m_bubble; /// \a m_selected holds selection information bool m_selected; /// \a m_order holds the stacking order in the mark list int m_order; /// \a m_laylines holds the laylines for the mark LaylinesGraphicsItem *m_laylines; /// \a m_heading holds the orientation of the arrow qreal m_heading; /// \a m_arrowVisible holds wether the mark arrow is visible bool m_arrowVisible; /// \a m_leaveToPort holds the orientation of the arrow bool m_leaveToPort; /// \a m_multiSelect is true if Ctrl-modified was in effect when mousePressEvent happened /// Need to save this state until receive mouseReleaseEvent to determine what to do bool m_multiSelect; /// \a if m_actOnMouseRelease is true then need to do something when mouse button is released bool m_actOnMouseRelease; bool m_labelVisible; QString m_labelText; }; #endif boats-201307/graphicsview/point.cpp000066400000000000000000000057021217277220500172610ustar00rootroot00000000000000// // C++ Implementation: PointGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include "point.h" #include "commontypes.h" #include "situationscene.h" #include "situationmodel.h" #include "polylinemodel.h" #include "pointmodel.h" extern int debugLevel; const int size = 3; PointGraphicsItem::PointGraphicsItem(PointModel *point, QGraphicsItem *parent) : QGraphicsItem(parent), m_point(point), m_bubble(new BubbleGraphicsItem(m_point, this)), m_selected(false), m_laylines(new LaylinesGraphicsItem(m_point, this)) { setZValue(1); setFlag(QGraphicsItem::ItemIsMovable); setFlag(QGraphicsItem::ItemIsSelectable); setPos(point->position()); m_bubble->setZValue(1); m_points << QPoint(0, -size) << QPoint(size, 0) << QPoint(0, size) << QPoint(-size, 0) << QPoint(0, -size); connect(point, SIGNAL(positionChanged(QPointF)), this, SLOT(setPosition(QPointF))); connect(point->polyLine()->situation(), SIGNAL(pointRemoved(PointModel *)), this, SLOT(deleteItem(PointModel*))); } PointGraphicsItem::~PointGraphicsItem() {} void PointGraphicsItem::setPosition(QPointF position) { if (pos() != position) { setPos(position); update(); } } void PointGraphicsItem::deleteItem(PointModel *point) { if (point == m_point) { if (debugLevel & 1 << VIEW) std::cout << "deleting pointGraphics for model" << m_point << std::endl; scene()->removeItem(this); delete this; } } QRectF PointGraphicsItem::boundingRect() const { return QRectF(-size, -size, 2*size, 2*size); } QPainterPath PointGraphicsItem::shape() const { QPainterPath path; path.addPolygon(m_points); return path; } void PointGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option); Q_UNUSED(widget); if (isSelected()) painter->setPen(Qt::red); else painter->setPen(Qt::black); painter->setBrush(Qt::black); painter->drawPolygon(m_points); } int PointGraphicsItem::type() const { return POINT_TYPE; } boats-201307/graphicsview/point.h000066400000000000000000000046321217277220500167270ustar00rootroot00000000000000// // C++ Interface: PointGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2011 Thibaut GRIDEL // // 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 . // // #ifndef POINT_H #define POINT_H #include #include #include "commontypes.h" #include "bubble.h" #include "laylines.h" class PointModel; /** \class PointGraphicsItem \brief the QGraphicsItem for a point The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the representation of a PositionModel on a SituationView. \sa SituationView, SituationScene, SituationModel, PositionModel */ class PointGraphicsItem : public QObject, public QGraphicsItem { Q_OBJECT Q_INTERFACES(QGraphicsItem) public: PointGraphicsItem(PointModel *point = 0, QGraphicsItem *parent = 0); ~PointGraphicsItem(); PointModel* point() const { return m_point; } BubbleGraphicsItem* bubble() const { return m_bubble; } QRectF boundingRect() const; QPainterPath shape() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); int type() const; public slots: void setPosition(QPointF position); void deleteItem(PointModel *point); private: /// \a m_point holds the PointModel being represented PointModel *m_point; /// \a m_bubble holds the bubble to display BubbleGraphicsItem *m_bubble; /// \a m_selected holds selection information bool m_selected; QPolygon m_points; /// \a m_laylines holds the laylines for the mark LaylinesGraphicsItem *m_laylines; }; #endif boats-201307/graphicsview/polyline.cpp000066400000000000000000000036061217277220500177640ustar00rootroot00000000000000// // C++ Implementation: PolyLineGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #include #include #include #include #include "polyline.h" #include "commontypes.h" #include "situationmodel.h" #include "polylinemodel.h" extern int debugLevel; PolyLineGraphicsItem::PolyLineGraphicsItem(PolyLineModel *polyline, QGraphicsItem *parent) : QGraphicsPathItem(parent), m_polyline(polyline) { setZValue(0); setPolyLine(); connect(polyline, SIGNAL(polyLineChanged(PolyLineModel*)), this, SLOT(setPolyLine())); connect(polyline->situation(), SIGNAL(polyLineRemoved(PolyLineModel*)), this, SLOT(deleteItem(PolyLineModel*))); } PolyLineGraphicsItem::~PolyLineGraphicsItem() {} void PolyLineGraphicsItem::setPolyLine() { prepareGeometryChange(); setPath(m_polyline->path()); update(); } void PolyLineGraphicsItem::deleteItem(PolyLineModel *polyline) { if (polyline == m_polyline) { if (debugLevel & 1 << VIEW) std::cout << "deleting polylineGraphics for model" << m_polyline << std::endl; scene()->removeItem(this); delete this; } } boats-201307/graphicsview/polyline.h000066400000000000000000000034711217277220500174310ustar00rootroot00000000000000// // C++ Interface: PolyLineGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #ifndef POLYLINE_H #define POLYLINE_H #include #include #include class PolyLineModel; /** \class PolyLineGraphicsItem \brief the QGraphicsItem for a polyline The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the representation of a PolyLineModel on a SituationView. \sa SituationView, SituationScene, SituationModel, PolyLineModel */ class PolyLineGraphicsItem : public QObject, public QGraphicsPathItem { Q_OBJECT public: PolyLineGraphicsItem(PolyLineModel *polyline = 0, QGraphicsItem *parent = 0); ~PolyLineGraphicsItem(); PolyLineModel* polyline() const { return m_polyline; } public slots: void setPolyLine(); void deleteItem(PolyLineModel *polyline); private: /// \a m_polyline holds the PolyLineModel being represented PolyLineModel *m_polyline; }; #endif boats-201307/graphicsview/sail.cpp000066400000000000000000000066141217277220500170630ustar00rootroot00000000000000// // C++ Implementation: SailGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include "sail.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" extern int debugLevel; SailGraphicsItem::SailGraphicsItem(BoatModel *boat, QGraphicsItem *parent) : QGraphicsPathItem(parent), m_boat(boat), m_sailAngle(0) { setZValue(0); setBrush(QBrush(Qt::white)); } SailGraphicsItem::~SailGraphicsItem() {} void SailGraphicsItem::setPosition(QPointF position) { if (pos() != position) { setPos(position); update(); } } void SailGraphicsItem::setSailSize(qreal sailSize) { m_sailSize = sailSize; QPainterPath sailPathStalled; sailPathStalled.cubicTo(.1 * sailSize, .2 * sailSize, .1 * sailSize, .2 * sailSize, 0, .3 * sailSize); sailPathStalled.cubicTo(-.1 * sailSize, .4 * sailSize, -.1 * sailSize, .4 * sailSize, 0, .5 * sailSize); sailPathStalled.cubicTo(.1 * sailSize, .6 * sailSize, .1 * sailSize, .6 * sailSize, 0, .7 * sailSize); sailPathStalled.cubicTo(-.1 * sailSize, .8 * sailSize, -.1 * sailSize, .8 * sailSize, 0, sailSize); sailPathStalled.lineTo(0, 0); m_sailPathStalled = sailPathStalled; QPainterPath sailPathStarboard; sailPathStarboard.cubicTo(.1 * sailSize, .4 * sailSize, .1 * sailSize, .6 * sailSize, 0, sailSize); sailPathStarboard.lineTo(0, 0); m_sailPathStarboard = sailPathStarboard; QPainterPath sailPathPort; sailPathPort.cubicTo(-.1 * sailSize, .4 * sailSize, -.1 * sailSize, .6 * sailSize, 0, sailSize); sailPathPort.lineTo(0, 0); m_sailPathPort = sailPathPort; setSailAngle(m_sailAngle); // Need to call setSailAngle() to update path, but don't want this to be sail specific. But not looking to change sail angle per se, so no need to use anything other than m_sailAngle. } /// calculate a sail incidence angle, corrected with user trimming void SailGraphicsItem::setSailAngle(qreal value) { m_sailAngle = value; qreal angle = fmod(m_boat->heading() - m_boat->wind() - m_sailAngle +360, 360); if(angle < 0) angle +=360; if ((angle < 10 || angle > 350 || (angle > 170 && angle < 190)) && path() != m_sailPathStalled) { setPath(m_sailPathStalled); } else if (angle >= 10 && angle <= 170 && path() != m_sailPathStarboard) { setPath(m_sailPathStarboard); } else if (angle >= 190 && angle <= 350 && path() != m_sailPathPort) { setPath(m_sailPathPort); } QTransform transform; transform.rotate(- m_sailAngle); setTransform(transform, false); } boats-201307/graphicsview/sail.h000066400000000000000000000044631217277220500165300ustar00rootroot00000000000000// // C++ Interface: SailGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #ifndef SAIL_H #define SAIL_H #include #include #include "boats.h" class BoatModel; /** \class SailGraphicsItem \brief the QGraphicsItem for a sail The class represents the Item according to the Graphics View Framework. It inherits QGraphicsPathItem for Item framework and QObject for slot and signal framework. It displays the sail representation of a BoatModel on a SituationView. \sa SituationView, SituationScene, SituationModel, BoatModel */ class SailGraphicsItem : public QObject, public QGraphicsPathItem { Q_OBJECT public: SailGraphicsItem(BoatModel *boat, QGraphicsItem *parent = 0); virtual ~SailGraphicsItem(); BoatModel* boat() const { return m_boat; } void setPosition(QPointF position); void setSailSize(qreal size); public slots: void setSailAngle(qreal value); protected: /// \a m_boat holds the BoatModel being represented BoatModel *m_boat; /// \a m_sailAngle holds the ideal sail trimming angle qreal m_sailAngle; /// \a m_sailSize holds the size of the foot qreal m_sailSize; /// \a m_sailPathPort holds the sail path when on port tack QPainterPath m_sailPathPort; /// \a m_sailPathStarboard holds the sail path when on starboard tack QPainterPath m_sailPathStarboard; /// \a m_sailPathStalled holds the sail path when head to wind QPainterPath m_sailPathStalled; }; #endif // SAIL_H boats-201307/graphicsview/situationscene.cpp000066400000000000000000000623521217277220500211710ustar00rootroot00000000000000// // C++ Implementation: situationscene // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include #include "situationscene.h" #include "commontypes.h" #include "undocommands.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" #include "markmodel.h" #include "polylinemodel.h" #include "pointmodel.h" #include "windmodel.h" #include "boat.h" #include "track.h" #include "mark.h" #include "polyline.h" #include "point.h" #include "arrow.h" #include "trackanimation.h" #include "scenarioanimation.h" #include "angleanimation.h" extern int debugLevel; SituationScene::SituationScene(SituationModel *situation) : QGraphicsScene(situation), m_situation(situation), m_scenarioAnimation(new ScenarioAnimation), m_trackCreated(0), m_state(NO_STATE), m_time(QTime::currentTime()), m_clickTime(QTime::currentTime()), m_clickState(SINGLE), m_defaultPopup(0), m_boatPopup(0), m_markPopup(0), m_pointPopup(0) { setItemIndexMethod(NoIndex); // set a minimum scene rect setSceneRect(-10000, -10000, 20000, 20000); // react to self change of selection connect(this, SIGNAL(selectionChanged()), this, SLOT(setSelectedModels())); // react to model track add connect(situation, SIGNAL(trackAdded(TrackModel*)), this, SLOT(addTrack(TrackModel*))); // react to model boat add connect(situation, SIGNAL(boatAdded(BoatModel*)), this, SLOT(addBoatItem(BoatModel*))); // react to model mark add connect(situation, SIGNAL(markAdded(MarkModel*)), this, SLOT(addMarkItem(MarkModel*))); // react to model line add connect(situation, SIGNAL(polyLineAdded(PolyLineModel*)), this, SLOT(addPolyLine(PolyLineModel*))); // react to model point add connect(situation, SIGNAL(pointAdded(PointModel*)), this, SLOT(addPoint(PointModel*))); // react to layline angle connect(situation, SIGNAL(laylineChanged(const int)), this, SLOT(setLaylines(const int))); connect(&situation->wind(), SIGNAL(windVisibleChanged(bool)), this, SLOT(setWind(bool))); connect(situation, SIGNAL(lookDirectionChanged(qreal)), this, SIGNAL(lookDirectionChanged(qreal))); connect(situation, SIGNAL(tiltChanged(qreal)), this, SIGNAL(tiltChanged(qreal))); setLaylines(situation->laylineAngle()); } void SituationScene::setState(const SceneState& theValue, bool commit) { // undo previous state's settings switch(m_state) { case CREATE_TRACK: case CREATE_BOAT: case CREATE_MARK: case CREATE_LINE: case CREATE_POINT: { m_situation->undoStack()->endMacro(); if (!commit) { m_situation->undoStack()->undo(); } } break; default: break; } switch(theValue) { case CREATE_TRACK: { createTrack(m_curPosition); } break; case CREATE_BOAT: { createBoat(m_curPosition); } break; case CREATE_MARK: { createMark(m_curPosition); } break; case CREATE_LINE: { createLine(m_curPosition); } break; case CREATE_POINT: { createPoint(m_curPosition); } break; default: break; } m_state = theValue; emit stateChanged(m_state); } void SituationScene::addTrack(TrackModel *track) { if (debugLevel & 1 << VIEW) std::cout << "adding track graphics for model " << track << std::endl; TrackGraphicsItem *trackItem = new TrackGraphicsItem(track); addItem(trackItem); } void SituationScene::addBoatItem(BoatModel *boat) { if (debugLevel & 1 << VIEW) std::cout << "adding boat graphics for model " << boat << std::endl; BoatGraphicsItem *boatItem = new BoatGraphicsItem(boat); addItem(boatItem); } void SituationScene::addMarkItem(MarkModel *mark) { if (debugLevel & 1 << VIEW) std::cout << "adding mark graphics for model " << mark << std::endl; MarkGraphicsItem *markItem = new MarkGraphicsItem(mark); addItem(markItem); } void SituationScene::addPolyLine(PolyLineModel *polyline) { if (debugLevel & 1 << VIEW) std::cout << "adding line graphics for model " << polyline << std::endl; PolyLineGraphicsItem *polyLineItem = new PolyLineGraphicsItem(polyline); addItem(polyLineItem); } void SituationScene::addPoint(PointModel *point) { if (debugLevel & 1 << VIEW) std::cout << "adding point graphics for model " << point << std::endl; PointGraphicsItem *pointItem = new PointGraphicsItem(point); addItem(pointItem); } void SituationScene::setWind(bool visible) { if (visible) { if (debugLevel & 1 << VIEW) std::cout << "adding wind graphics" << std::endl; ArrowGraphicsItem *arrow= new ArrowGraphicsItem(&m_situation->wind()); addItem(arrow); } } /** Prepares the Scene for animation mode. This method finds the maximum size of track, and sets the timer length accordingly. It then creates a BoatGraphicsItem for animation purpose, and associates an TrackAnimation. */ void SituationScene::setAnimation() { if (debugLevel & 1 << VIEW) std::cout << "preparing for Animation" << std::endl; int maxSize = 0; foreach (const TrackModel *track, m_situation->tracks()) { if (track->boats().size() > maxSize) maxSize = track->boats().size() - 1; } m_windAnimation = new QSequentialAnimationGroup(this); for (int i = 0; i < m_situation->wind().size()-1; ++i) { AngleAnimation *wind = new AngleAnimation(&m_situation->wind(), "direction"); wind->setDuration(2000); wind->setStartValue(m_situation->wind().windAt(i)); wind->setEndValue(m_situation->wind().windAt(i+1)); m_windAnimation->addAnimation(wind); } m_scenarioAnimation->addAnimation(m_windAnimation); foreach (TrackModel *track, m_situation->tracks()) { BoatModel *boat = track->boats()[0]; BoatGraphicsItem *boatItem = new BoatGraphicsItem(new BoatModel(track)); addItem(boatItem); boatItem->boat()->setOrder(0); boatItem->setPosition(boat->position()); boatItem->setHeading(boat->heading()); boatItem->boat()->setWind(m_situation->wind().windAt(0)); boatItem->boat()->setLaylines(boat->laylines()); connect(&track->situation()->wind(), SIGNAL(directionChanged(qreal)), boatItem->boat(), SLOT(setWind(qreal))); QGraphicsDropShadowEffect *shadow = new QGraphicsDropShadowEffect; shadow->setXOffset(4); shadow->setYOffset(4); shadow->setBlurRadius(4); boatItem->setGraphicsEffect(shadow); TrackAnimation *animation = new TrackAnimation(track, boatItem->boat(), m_scenarioAnimation); m_scenarioAnimation->addAnimation(animation); m_animationItems.push_back(animation); if(track->followTrack()) { connect(boatItem->boat(), SIGNAL(positionChanged(QPointF)), this, SIGNAL(centerChanged(QPointF))); disconnect(m_situation, SIGNAL(lookDirectionChanged(qreal))); connect(boatItem->boat(), SIGNAL(headingChanged(qreal)), this, SIGNAL(lookDirectionChanged(qreal))); } } foreach (MarkModel *mark, m_situation->marks()) { connect(&m_situation->wind(), SIGNAL(directionChanged(qreal)), mark, SLOT(setWind(qreal))); } foreach(PolyLineModel *poly, m_situation->polyLines()) { foreach(PointModel *point, poly->points()) { connect(&m_situation->wind(), SIGNAL(directionChanged(qreal)), point, SLOT(setWind(qreal))); } } } /** Restores the Scene out of animation mode. This method brings the scene back to the normal drawing mode. For this it removes all TrackAnimation objects created in setAnimation(). */ void SituationScene::unSetAnimation() { if (debugLevel & 1 << VIEW) std::cout << "ending Animation" << std::endl; m_situation->wind().setDirection(m_situation->wind().windAt(0)); m_scenarioAnimation->removeAnimation(m_windAnimation); for (int i = 0; i < m_situation->wind().size()-1; ++i) { QAbstractAnimation *animation = m_windAnimation->animationAt(0); m_windAnimation->removeAnimation(animation); delete animation; } delete m_windAnimation; foreach (TrackAnimation *animation, m_animationItems) { // the boat was never really part of the track, we use situation signal // directly to have the graphicsitem removed animation->boat()->track()->situation()->removingBoat(animation->boat()); m_scenarioAnimation->removeAnimation(animation); m_animationItems.removeOne(animation); delete animation->boat(); delete animation; } foreach (MarkModel *mark, m_situation->marks()) { disconnect(mark, SLOT(setWind(qreal))); } } /** Reacts to user keyboard actions in the Scene This method modifies the associated SituationModel through the concerned Undo Framework class. Handled keys are for - heading of selected boats (+,-) - position of selected objects (H (left), L (right), J (down), K (up)) */ void SituationScene::keyPressEvent(QKeyEvent *event) { if (!m_selectedBoatModels.isEmpty()) { // Trim just the jib when ',' or '.' is pressed (TrimJibUndoCommand only trims the jib) // But not when Ctrl is pressed - reserve that for spinTrim if (event->key() == Qt::Key_Comma && !(event->modifiers() & Qt::ControlModifier)) { m_situation->undoStack()->push(new TrimJibUndoCommand(m_selectedBoatModels, m_selectedBoatModels[0]->jibTrim() - 5)); } else if (event->key() == Qt::Key_Period && !(event->modifiers() & Qt::ControlModifier)) { m_situation->undoStack()->push(new TrimJibUndoCommand(m_selectedBoatModels, m_selectedBoatModels[0]->jibTrim() + 5)); // Trim the spin when Ctrl+',' or Ctrl+'.' is pressed }else if (event->key() == Qt::Key_Comma && (event->modifiers() & Qt::ControlModifier)) { m_situation->undoStack()->push(new TrimSpinUndoCommand(m_selectedBoatModels, m_selectedBoatModels[0]->spinTrim() - 5)); } else if (event->key() == Qt::Key_Period && (event->modifiers() & Qt::ControlModifier)) { m_situation->undoStack()->push(new TrimSpinUndoCommand(m_selectedBoatModels, m_selectedBoatModels[0]->spinTrim() + 5)); } } if (!m_selectedModels.isEmpty()) { if (event->key() == Qt::Key_Left) { QPointF pos(-5,0); m_situation->undoStack()->push(new MoveModelUndoCommand(m_selectedModels, pos)); } else if (event->key() == Qt::Key_Right) { QPointF pos(5,0); m_situation->undoStack()->push(new MoveModelUndoCommand(m_selectedModels, pos)); } else if (event->key() == Qt::Key_Up) { QPointF pos(0,-5); m_situation->undoStack()->push(new MoveModelUndoCommand(m_selectedModels, pos)); } else if (event->key() == Qt::Key_Down) { QPointF pos(0,5); m_situation->undoStack()->push(new MoveModelUndoCommand(m_selectedModels, pos)); } else if (event->key() == Qt::Key_Plus) { m_situation->undoStack()->push(new RotateModelsUndoCommand(m_selectedModels, 5.0)); } else if (event->key() == Qt::Key_Minus) { m_situation->undoStack()->push(new RotateModelsUndoCommand(m_selectedModels, -5.0)); } else { QGraphicsScene::keyPressEvent(event); } } else { QGraphicsScene::keyPressEvent(event); } } /** Sets selection depending on modal status. Selection happens with left button in NO_STATE, and right button in CREATE_BOAT and CREATE_MARK modes. */ void SituationScene::mousePressEvent(QGraphicsSceneMouseEvent *event) { switch (m_state) { case NO_STATE: mouseSelectEvent(event); if (!m_selectedBoatModels.isEmpty()) { m_trackCreated = m_selectedBoatModels[0]->track(); } if (!m_selectedPointModels.isEmpty()) { m_polyLineCreated = m_selectedPointModels[0]->polyLine(); } break; case CREATE_TRACK: case CREATE_BOAT: case CREATE_MARK: if (event->buttons() == Qt::RightButton || (event->buttons() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0))) { mouseSelectEvent(event); } break; default: break; } m_clickTime.start(); } /** Handles a timer to limit user interaction This method limits the move processing to one event handled per 40ms. This is very noticeable on Windows platform, and the culprit is the drawing, not the model setting. */ void SituationScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { // limit update rate to 40ms if ((m_time.elapsed() <40) ) { return; } QGraphicsScene::mouseMoveEvent(event); switch (m_state) { case NO_STATE: if (event->buttons() == Qt::LeftButton && (event->modifiers() & Qt::MetaModifier) == 0) { moveModel(event->scenePos()); } if (event->buttons() == Qt::RightButton || (event->buttons() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0))) { headingModel(event->scenePos()); } break; case CREATE_TRACK: if (event->buttons() == Qt::NoButton) { m_trackCreated->boats().last()->setPosition(event->scenePos()); } if (event->buttons() == Qt::RightButton || (event->buttons() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0))) { headingModel(event->scenePos()); } break; case CREATE_BOAT: if (event->buttons() == Qt::NoButton) { qreal heading = m_trackCreated->headingForNext( m_trackCreated->boats().size()-2, event->scenePos()); m_trackCreated->boats().last()->setHeading(heading); m_trackCreated->boats().last()->setPosition(event->scenePos()); } if (event->buttons() == Qt::RightButton || (event->buttons() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0))) { headingModel(event->scenePos()); } break; case CREATE_MARK: if (event->buttons() == Qt::NoButton) { m_markCreated->setPosition(event->scenePos()); } break; case CREATE_LINE: case CREATE_POINT: if (event->buttons() == Qt::NoButton) { m_polyLineCreated->points().last()->setPosition(event->scenePos()); } break; default: break; } // trigger next update rate calculation m_time.start(); m_curPosition = event->scenePos(); } /** Performs action depending of button and mode This method will trigger performing of actions like: - setting position of selected objects - setting heading of selected BoatGraphicsItem - creating new TrackModel, BoatModel or MarkModel according to mode. */ void SituationScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { QGraphicsScene::mouseReleaseEvent(event); if (m_clickState != SINGLE) { m_clickState = SINGLE; return; } mouseClickEvent(event); } void SituationScene::mouseClickEvent(QGraphicsSceneMouseEvent *event) { bool click = (m_clickTime.elapsed() < 250); if (click && (event->button() == Qt::RightButton || (event->button() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0)))) { if (!m_selectedModels.isEmpty()) { switch(selectedItems()[0]->type()) { case BOAT_TYPE: { m_boatPopup->popup(event->screenPos()); return; } break; case MARK_TYPE: { m_markPopup->popup(event->screenPos()); return; } break; case POINT_TYPE: { m_pointPopup->popup(event->screenPos()); return; } break; } } m_defaultPopup->popup(event->screenPos()); return; } switch (m_state) { case NO_STATE: if (event->button() == Qt::LeftButton && (event->modifiers() & Qt::MetaModifier) == 0) { moveModel(event->scenePos()); } if (event->button() == Qt::RightButton || (event->button() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0))) { headingModel(event->scenePos()); } break; case CREATE_TRACK: if (event->button() == Qt::LeftButton) { setState(CREATE_BOAT, true); } break; case CREATE_BOAT: if (event->button() == Qt::LeftButton) { if ((event->modifiers() & Qt::ControlModifier) != 0) { setState(CREATE_BOAT, true); } else if ((event->modifiers() & Qt::MetaModifier) == 0) { createBoat(event->scenePos()); } } if (event->button() == Qt::RightButton || (event->button() == Qt::LeftButton && ((event->modifiers() & Qt::MetaModifier) != 0))) { headingModel(event->scenePos()); } break; case CREATE_MARK: if (event->button() == Qt::LeftButton) { createMark(event->scenePos()); } break; case CREATE_LINE: if (event->button() == Qt::LeftButton) { setState(CREATE_POINT, true); } break; case CREATE_POINT: if (event->button() == Qt::LeftButton) { createPoint(event->scenePos()); } default: break; } } void SituationScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) { Q_UNUSED(event); m_clickState = DOUBLE; setState(NO_STATE); m_situation->undoStack()->undo(); } void SituationScene::mouseSelectEvent(QGraphicsSceneMouseEvent *event) { // propagate mouse event first for selected items QGraphicsScene::mousePressEvent(event); m_fromPosition = event->scenePos(); if (debugLevel & 1 << VIEW) std::cout << "Mouse pressed with " << m_selectedModels.size() << " items selected" << std::endl; } void SituationScene::moveModel(QPointF pos) { if (!m_selectedModels.isEmpty() && pos != m_fromPosition) { m_situation->undoStack()->push(new MoveModelUndoCommand(m_selectedModels,(pos-m_fromPosition))); m_fromPosition = pos; } } void SituationScene::headingModel(QPointF pos) { if (!m_selectedModels.isEmpty() && pos != m_modelPressed->position()) { QPointF point = pos - m_modelPressed->position(); qreal wind = m_modelPressed->wind(); qreal theta = fmod((atan2 (point.x(), -point.y()) * 180 / M_PI) + 360.0, 360.0); qreal delta = fmod(theta - wind + 360, 360); qreal snap = m_situation->laylineAngle(); // face to wind if (fabs(delta)<=5) { theta = wind; // port closehauled } else if (fabs(delta - snap)<=5) { theta = fmod(wind + snap, 360); // port downwind } else if (fabs(delta -(180-snap)) <=5) { theta = fmod(wind + 180-snap, 360); // deadwind } else if (fabs(delta - 180)<=5) { theta = fmod(wind - 180, 360); // starboard downwind } else if (fabs(delta - (180+snap)) <=5) { theta = fmod(wind + 180 + snap, 360); // starboard closehauled } else if (fabs(delta - (360-snap)) <=5) { theta = fmod(wind + 360 - snap, 360); } m_situation->undoStack()->push(new RotateModelsUndoCommand(m_selectedModels, theta-m_modelPressed->heading())); } } void SituationScene::createTrack(QPointF pos) { AddTrackUndoCommand *command = new AddTrackUndoCommand(m_situation); m_situation->undoStack()->push(command); TrackModel *track = command->track(); BoatModel *boat = new BoatModel(track, track); boat->setDim(64); boat->setPosition(pos); track->addBoat(boat); m_trackCreated = track; } void SituationScene::createBoat(QPointF pos) { if (m_trackCreated) { m_situation->undoStack()->endMacro(); m_trackCreated->boats().last()->setDim(255); qreal heading = m_trackCreated->boats().last()->heading(); AddBoatUndoCommand *command = new AddBoatUndoCommand(m_trackCreated, pos, heading); command->boat()->setDim(64); m_situation->undoStack()->beginMacro(""); m_situation->undoStack()->push(command); } } void SituationScene::createMark(QPointF pos) { m_situation->undoStack()->endMacro(); AddMarkUndoCommand *command = new AddMarkUndoCommand(m_situation, pos); m_markCreated = command->mark(); m_situation->undoStack()->beginMacro(""); m_situation->undoStack()->push(command); } void SituationScene::createLine(QPointF pos) { AddPolyLineUndoCommand *command = new AddPolyLineUndoCommand(m_situation); m_situation->undoStack()->push(command); m_polyLineCreated = command->polyLine(); PointModel *point = new PointModel(m_polyLineCreated); point->setPosition(pos); m_polyLineCreated->addPoint(point); } void SituationScene::createPoint(QPointF pos) { if (m_polyLineCreated) { m_situation->undoStack()->endMacro(); AddPointUndoCommand *command = new AddPointUndoCommand( m_polyLineCreated, pos); m_situation->undoStack()->beginMacro(""); m_situation->undoStack()->push(command); } } void SituationScene::setSelectedModels() { m_selectedModels.clear(); m_selectedBoatModels.clear(); m_selectedMarkModels.clear(); m_selectedPointModels.clear(); foreach (QGraphicsItem *item, selectedItems()) { switch(item->type()) { case BOAT_TYPE: { BoatModel *boat = (qgraphicsitem_cast(item))->boat(); m_selectedModels << boat; m_selectedBoatModels << boat; } break; case MARK_TYPE: { MarkModel *mark = (qgraphicsitem_cast(item))->mark(); m_selectedModels << mark; m_selectedMarkModels << mark; } break; case POINT_TYPE: { PointModel *point = (qgraphicsitem_cast(item))->point(); m_selectedModels << point; m_selectedPointModels << point; } break; case ARROW_TYPE: { WindModel *wind = &m_situation->wind(); m_selectedModels << wind; } } } if (debugLevel & 1 << VIEW) std::cout << "SelectedModels update " << m_selectedModels.size() << std::endl; emit selectedModelsChanged(); } void SituationScene::setLaylines(const int angle) { if (!m_situation->showLayline()) { if (debugLevel & 1 << VIEW) std::cout << "reseting empty Background" << std::endl; setBackgroundBrush(Qt::NoBrush); return; } if (debugLevel & 1 << VIEW) std::cout << "creating layline Background for " << angle << std::endl; qreal theta = angle * M_PI /180; int length = Boats::seriesSizeList()[m_situation->situationSeries()]; // draw 4 times as big, then use transform to scale back the brush // gives better precision grid qreal x = 2*length*sin(theta) * 4; qreal y = 2*length*cos(theta) * 4; QPixmap pixmap(x,y); pixmap.fill(Qt::transparent); QPainter painter(&pixmap); QPen pen; pen.setWidth(2); QVector dashes; dashes << length/10.0 << length/5.0; pen.setStyle(Qt::CustomDashLine); pen.setDashPattern(dashes); painter.setPen(pen); painter.setRenderHints(QPainter::Antialiasing); painter.drawLine(QLineF(0,0,x,y)); painter.drawLine(QLineF(0,y,x,0)); QBrush brush; QTransform transform; transform.scale(0.25, 0.25); brush.setTransform(transform); brush.setTexture(pixmap); setBackgroundBrush(brush); } boats-201307/graphicsview/situationscene.h000066400000000000000000000176421217277220500206400ustar00rootroot00000000000000// // C++ Interface: situationscene // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef SITUATIONSCENE_H #define SITUATIONSCENE_H #include class SituationModel; class TrackModel; class PositionModel; class BoatModel; class MarkModel; class PolyLineModel; class PointModel; class TrackAnimation; class ScenarioAnimation; /** \enum SceneState This enum defines the different modal states of the edition. When the user wants to input data to the scenario, he sets the current edition mode. \value NO_STATE No particular mode is set. In this mode item selection and movement is allowed. \value CREATE_TRACK The Create Track mode will create a new TrackModel object in the scenario. This mode is then overriden to CREATE_BOAT as a natural action is to append boat positions. \value CREATE_BOAT The Create Boat will append a BoatModel to the track of the lastly selected boat object. \value CREATE_MARK The Create Mark will create a new MarkModel to the scenario. \value ANIMATE The Animation will be prepared, and no further input will be allowed in this mode. */ typedef enum { NO_STATE, CREATE_TRACK, CREATE_BOAT, CREATE_MARK, CREATE_LINE, CREATE_POINT, ANIMATE } SceneState; enum { BOAT_TYPE = QGraphicsItem::UserType + 1, MARK_TYPE, POINT_TYPE, ARROW_TYPE }; /** \class SituationScene \brief The Scene for a scenario The class represents the Scene for a Scenario, according to the Graphics View Framework. It inherits QGraphicsScene and manages user input. The class handles a modal input status to trigger various actions depending on the mode. Action on Objects is handled by overloading the event methods: keyPressEvent(), mousePressEvent(), mouseReleaseEvent() and mouseMoveEvent(). Specialised methods handle the possible events and generally use Undo Framework classes to modify the ScenarioModel. QGraphicsItem Objects selection is handled through setSelectedModels() slot, and updates the various Lists needed to determine matching Model objects. The class provides slots to react to SituationModel changes and update drawing accordingly. The class prepares the drawing of animation as well, through setAnimation() and unSetAnimation() methods. \sa QGraphicsScene, SituationModel, BoatGraphicsItem, MarkGraphicsItem */ class SituationScene : public QGraphicsScene { Q_OBJECT public: SituationScene(SituationModel* situation); ~SituationScene() {} void setState(const SceneState& theValue, bool commit = false); void setModelPressed(PositionModel *theValue) {m_modelPressed = theValue; } SceneState state() const { return m_state; } QList< PositionModel * > selectedModels() const { return m_selectedModels; } QList< BoatModel * > selectedBoatModels() const { return m_selectedBoatModels; } QList< MarkModel * > selectedMarkModels() const { return m_selectedMarkModels; } QList< PointModel * > selectedPointModels() const { return m_selectedPointModels; } void setDefaultPopup(QMenu *theValue) { m_defaultPopup = theValue; } void setBoatPopup(QMenu *theValue) { m_boatPopup = theValue; } void setMarkPopup(QMenu *theValue) { m_markPopup = theValue; } void setPointPopup(QMenu *theValue) { m_pointPopup = theValue; } ScenarioAnimation *animation() const { return m_scenarioAnimation; } signals: void itemMoved(QList movedItems, const QPointF &movedFromPosition); void stateChanged(SceneState newState); void selectedModelsChanged(); void centerChanged(QPointF position); void lookDirectionChanged( const qreal lookDirection); void tiltChanged( const qreal tilt); public slots: // Slot for selection mechanism void setSelectedModels(); // Slots for SituationModel signals void addTrack(TrackModel *track); void addBoatItem(BoatModel *boat); void addMarkItem(MarkModel *mark); void addPolyLine(PolyLineModel *polyline); void addPoint(PointModel *point); void setLaylines(const int angle); void setWind(bool visible); // Slots for animation signals void setAnimation(); void unSetAnimation(); protected: // Overloaded methods for Events void keyPressEvent(QKeyEvent *event); void mousePressEvent(QGraphicsSceneMouseEvent *event); void mouseMoveEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void mouseClickEvent(QGraphicsSceneMouseEvent *event); void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event); private: // Specialised Event methods void mouseSelectEvent(QGraphicsSceneMouseEvent *event); void createTrack(QPointF pos); void moveModel(QPointF pos); void headingModel(QPointF pos); void createBoat(QPointF pos); void createMark(QPointF pos); void createLine(QPointF pos); void createPoint(QPointF pos); SituationModel *m_situation; // Bookkeeping references to selected models /// \a m_selectedModels holds the list of selected PositionModel QList m_selectedModels; /// \a m_selectedBoatsModels holds the list of selected BoatModel QList m_selectedBoatModels; /// \a m_selectedMarkModels holds the list of selected MarkModel QList m_selectedMarkModels; /// \a m_selectedPointModels holds the list of selected PointModel QList m_selectedPointModels; /// \a m_windAnimation holds the animation for wind QAnimationGroup *m_windAnimation; /// \a m_animationItems holds the list of TrackAnimation items /// created for animation mode QList m_animationItems; /// \a m_scenarioAnimation holds the general AnimationGroup /// manipulated during animation mode ScenarioAnimation* m_scenarioAnimation; /// \a m_modelPressed holds the BoatModel being pressed PositionModel* m_modelPressed; /// \a m_trackCreated holds the last selected TrackModel TrackModel *m_trackCreated; /// \a m_polyLineCreated holds the last selected PolyLineModel PolyLineModel *m_polyLineCreated; /// \a m_markCreated holds the last selected MarkModel MarkModel *m_markCreated; /// \a m_fromPosition holds the QPointF where mouse was pressed QPointF m_fromPosition; /// \a m_curPosition holds the QPointF where mouse was last seen QPointF m_curPosition; /// \a m_state holds the SceneState for the current scenario SceneState m_state; /// \a m_time holds the timer used for movement filtering QTime m_time; /// \a m_clickTime holds the timer used for click/press detection QTime m_clickTime; enum { SINGLE, DOUBLE, NONE } m_clickState; QMenu *m_defaultPopup; QMenu *m_boatPopup; QMenu *m_markPopup; QMenu *m_pointPopup; }; #endif boats-201307/graphicsview/situationview.cpp000066400000000000000000000107261217277220500210440ustar00rootroot00000000000000// // C++ Implementation: situationview // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #include #include "commontypes.h" #include "situationview.h" extern int debugLevel; SituationView::SituationView(QWidget *parent) :QGraphicsView(parent) { } SituationView::SituationView(QGraphicsScene *scene, QWidget *parent) : QGraphicsView(scene, parent), scaleValue(1), lookDirectionValue(0), tiltValue(0) { setRenderHints( QPainter::Antialiasing | QPainter::SmoothPixmapTransform); setViewportUpdateMode(QGraphicsView::SmartViewportUpdate); setResizeAnchor(QGraphicsView::AnchorViewCenter); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); connect( scene, SIGNAL(centerChanged(QPointF)), this, SLOT(setCenter(QPointF))); connect( scene, SIGNAL(lookDirectionChanged(qreal)), this, SLOT(setLookDirection(qreal))); connect( scene, SIGNAL(tiltChanged(qreal)), this, SLOT(setTilt(qreal))); } SituationView::~SituationView() { } /** Takes a picture of the current view and returns it as a QPixmap. This method creates a QPixmap and calls render() on that pixmap before returning it. */ QPixmap SituationView::screenShot() { QPixmap pixmap(size()); pixmap.fill(Qt::white); QPainter painter(&pixmap); painter.setRenderHints( QPainter::Antialiasing | QPainter::SmoothPixmapTransform); render(&painter); return pixmap; } /** Handles mouse wheel event to zoom in or out. This method will call setScale() with rotation side. */ void SituationView::wheelEvent(QWheelEvent *event) { if (debugLevel & 1 << VIEW) std::cout << "wheel event " << event->delta() << std::endl; setScale(event->delta() > 0); } void SituationView::mousePressEvent(QMouseEvent *event) { setDragMode(QGraphicsView::ScrollHandDrag); QGraphicsView::mousePressEvent(event); } void SituationView::mouseReleaseEvent(QMouseEvent *event) { QGraphicsView::mouseReleaseEvent(event); setDragMode(QGraphicsView::NoDrag); } void SituationView::zoomIn() { setScale(true); } void SituationView::zoomOut() { setScale(false); } /** Sets an acceptable scale that fits the whole scenario. This method compares the matrix() before and after fitInView() and possibly adopts the scale, rounded to the nearest .05 */ void SituationView::zoomFit() { QMatrix old = matrix(); fitInView(scene()->itemsBoundingRect(),Qt::KeepAspectRatio); qreal s = matrix().m11(); if (s < 10.0 && s > 0.1) { // adopt scaling scaleValue = (round(s * 20)) / 20.0; } // apply calculated or default scale QMatrix m(scaleValue, old.m21(), old.m21(), scaleValue, old.dx(), old.dy()); setMatrix(m); } void SituationView::setLookDirection(qreal value) { lookDirectionValue = value; emit lookDirectionChanged(qRound(lookDirectionValue)); transformView(); } void SituationView::setTilt(qreal value) { tiltValue = value; emit tiltChanged(qRound(tiltValue)); transformView(); } void SituationView::setCenter(QPointF position) { centerOn(position); } /** Zoom in if \a in otherwise zoom out by .05 increments between 0.1 and 10 */ void SituationView::setScale(bool in) { if (in) { if (scaleValue < 10.0) { scaleValue *= 1.1; } } else if (scaleValue > 0.1) { scaleValue /= 1.1; } if (debugLevel & 1 << VIEW) std::cout << "new scale values " << scaleValue << std::endl; transformView(); } void SituationView::transformView() { QTransform transform; transform.rotate(tiltValue, Qt::XAxis); transform.rotate(-lookDirectionValue, Qt::ZAxis); transform.scale(scaleValue, scaleValue); setTransform(transform, false); } boats-201307/graphicsview/situationview.h000066400000000000000000000041041217277220500205020ustar00rootroot00000000000000// // C++ Interface: situationview // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #ifndef SITUATIONVIEW_H #define SITUATIONVIEW_H #include /** \class SituationView \brief The View for a scenario The class represents the View for a Scenario, according to the Graphics View Framework. It inherits QGraphicsView and manages zoom and screenshot capture. \sa SituationScene, SituationModel */ class SituationView : public QGraphicsView { Q_OBJECT public: SituationView(QWidget *parent = 0); SituationView(QGraphicsScene *scene, QWidget *parent = 0); ~SituationView(); QPixmap screenShot(); protected: void wheelEvent(QWheelEvent *event); void mousePressEvent(QMouseEvent *event); void mouseReleaseEvent(QMouseEvent *event); public slots: void zoomIn(); void zoomOut(); void zoomFit(); void setLookDirection(qreal value); void setTilt(qreal value); void setCenter(QPointF position); signals: void lookDirectionChanged( const int lookDirection); void tiltChanged( const int tilt); private: void setScale(bool in); void transformView(); /// \a scaleValue holds the value for the viewing scale qreal scaleValue; qreal lookDirectionValue; qreal tiltValue; }; #endif boats-201307/graphicsview/spinnaker.cpp000066400000000000000000000132201217277220500201140ustar00rootroot00000000000000// // C++ Implementation: SpinnakerGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2010 Thibaut GRIDEL // // 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 . // // #include #include #include #include "spinnaker.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" extern int debugLevel; SpinnakerGraphicsItem::SpinnakerGraphicsItem(BoatModel *boat, QGraphicsItem *parent) : SailGraphicsItem(boat, parent), m_pole(new QGraphicsLineItem(this)) { setHeading(boat->heading()); } SpinnakerGraphicsItem::~SpinnakerGraphicsItem() {} void SpinnakerGraphicsItem::setSailSize(qreal sailSize) { m_sailSize = sailSize; QPainterPath sailPathStarboard; sailPathStarboard.cubicTo(.4 * sailSize, .2 * sailSize, .6 * sailSize, .2 * sailSize, sailSize, 0); sailPathStarboard.arcTo(-sailSize, -sailSize, 2 * sailSize, 2 * sailSize, 0, -120); sailPathStarboard.cubicTo(-.12 * sailSize, .62 * sailSize, -.03 * sailSize, .44 * sailSize, 0, 0); m_sailPathStarboard = sailPathStarboard; QPainterPath sailPathPort; sailPathPort.cubicTo(-.4 * sailSize, .2 * sailSize, -.6 * sailSize, .2 * sailSize, -sailSize, 0); sailPathPort.arcTo(- sailSize, -sailSize, 2 * sailSize, 2 * sailSize, 180, 120); sailPathPort.cubicTo(.12 * sailSize, .62 * sailSize, .03 * sailSize, .44 * sailSize, 0, 0); m_sailPathPort = sailPathPort; QLineF line; line.setP2(QPointF(0, -sailSize)); m_pole->setLine(line); setSailAngle(m_boat->spinAngle() + m_boat->spinTrim()); } /// calculate a sail incidence angle, corrected with user trimming void SpinnakerGraphicsItem::setSailAngle(qreal value) { m_sailAngle = value; qreal angle = fmod(m_boat->heading() - m_boat->wind() - m_sailAngle, 360); if(angle < 0) angle += 360; if ((angle < 10 || angle > 350 || (angle > 170 && angle < 190)) && path() != m_sailPathStalled) { setPath(m_sailPathStalled); } else if (angle >= 10 && angle <= 170 && path() != m_sailPathStarboard) { setPath(m_sailPathStarboard); } else if (angle >= 190 && angle <= 350 && path() != m_sailPathPort) { setPath(m_sailPathPort); } } void SpinnakerGraphicsItem::setHeading(qreal value) { qreal angle = fmod(value - m_boat->wind(), 360); if (angle < 0) angle += 360; QTransform rotation; rotation.rotate(-angle); setTransform(rotation, false); QTransform poleRotation; if (angle > 90 && angle < 180) { poleRotation.rotate(90); } else if (angle >= 180 && angle < 270) { poleRotation.rotate(-90); } else { poleRotation.rotate(angle); } m_pole->setTransform(poleRotation, false); QPainterPath sailPathStalled; QPointF pole = m_pole->mapToParent(m_pole->line().p2()); double sinx = sin(angle* M_PI/180.0); double cosx = cos(angle* M_PI/180.0); double sign = .1; if (angle>180) { sign = -.1; } sailPathStalled.cubicTo(sign * m_sailSize * cosx + .4 * m_sailSize * sinx, sign * m_sailSize * sinx - .4 * m_sailSize * cosx, sign * m_sailSize * cosx + .6 * m_sailSize * sinx, sign * m_sailSize * sinx - .6 * m_sailSize * cosx, pole.x(), pole.y()); sailPathStalled.cubicTo(pole.x() + sign * m_sailSize, pole.y() + .2 * m_sailSize, pole.x() + sign * m_sailSize, pole.y() + .2 * m_sailSize, pole.x(), pole.y() + .3 * m_sailSize); sailPathStalled.cubicTo(pole.x() - sign * m_sailSize, pole.y() + .4 * m_sailSize, pole.x() - sign * m_sailSize, pole.y() + .4 * m_sailSize, pole.x(), pole.y() + .5 * m_sailSize); sailPathStalled.cubicTo(pole.x() + sign * m_sailSize, pole.y() + .6 * m_sailSize, pole.x() + sign * m_sailSize, pole.y() + .6 * m_sailSize, pole.x(), pole.y() + .7 * m_sailSize); sailPathStalled.cubicTo(pole.x() - sign * m_sailSize, pole.y() + .8 * m_sailSize, pole.x() - sign * m_sailSize, pole.y() + .8 * m_sailSize, pole.x(), pole.y() + m_sailSize); sailPathStalled.cubicTo(.8* pole.x(), pole.y() + m_sailSize, .8 * pole.x(), pole.y() + m_sailSize, .7 * pole.x(), .7 * (pole.y() + m_sailSize)); sailPathStalled.cubicTo(.6 * pole.x(), .4 * (pole.y() + m_sailSize), .6 * pole.x(), .4 * (pole.y() + m_sailSize), .5 * pole.x(), .5 * (pole.y() + m_sailSize)); sailPathStalled.cubicTo(.4 * pole.x(), .6 * (pole.y() + m_sailSize), .4 * pole.x(), .6 * (pole.y() + m_sailSize), .3 * pole.x(), .3 * (pole.y() + m_sailSize)); sailPathStalled.cubicTo(.2 * pole.x(), 0, .2 * pole.x(), 0, 0, 0); m_sailPathStalled = sailPathStalled; } boats-201307/graphicsview/spinnaker.h000066400000000000000000000033771217277220500175750ustar00rootroot00000000000000// // C++ Interface: SpinnakerGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2010 Thibaut GRIDEL // // 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 . // // #ifndef SPINNAKER_H #define SPINNAKER_H #include #include #include "boats.h" #include "sail.h" class BoatModel; /** \class SpinnakerGraphicsItem \brief the QGraphicsItem for a sail The class represents the Item according to the Graphics View Framework. It inherits SailGraphicsItem which provides necessary update framework. It displays the spin representation of a BoatModel on a SituationView. \sa SituationView, SituationScene, SituationModel, BoatModel */ class SpinnakerGraphicsItem : public SailGraphicsItem { Q_OBJECT public: SpinnakerGraphicsItem(BoatModel *boat, QGraphicsItem *parent = 0); virtual ~SpinnakerGraphicsItem(); void setSailSize(qreal size); public slots: void setSailAngle(qreal value); void setHeading(qreal value); private: /// \a m_pole holds the spinnaker pole QGraphicsLineItem *m_pole; }; #endif // SPINNAKER_H boats-201307/graphicsview/track.cpp000066400000000000000000000036551217277220500172410ustar00rootroot00000000000000// // C++ Implementation: TrackGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #include #include #include #include #include "track.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" extern int debugLevel; TrackGraphicsItem::TrackGraphicsItem(TrackModel *track, QGraphicsItem *parent) : QGraphicsPathItem(parent), m_track(track) { setZValue(0); setTrack(); setShowPath(track->showPath()); connect(track, SIGNAL(showPathChanged(bool)), this, SLOT(setShowPath(bool))); connect(track, SIGNAL(trackChanged(TrackModel*)), this, SLOT(setTrack())); connect(track->situation(), SIGNAL(trackRemoved(TrackModel*)), this, SLOT(deleteItem(TrackModel*))); } TrackGraphicsItem::~TrackGraphicsItem() {} void TrackGraphicsItem::setTrack() { prepareGeometryChange(); setPath(m_track->path()); update(); } void TrackGraphicsItem::deleteItem(TrackModel *track) { if (track == m_track) { if (debugLevel & 1 << VIEW) std::cout << "deleting trackGraphics for model" << m_track << std::endl; scene()->removeItem(this); delete this; } } boats-201307/graphicsview/track.h000066400000000000000000000034631217277220500167030ustar00rootroot00000000000000// // C++ Interface: BoatGraphicsItem // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #ifndef TRACK_H #define TRACK_H #include #include #include class TrackModel; /** \class TrackGraphicsItem \brief the QGraphicsItem for a track The class represents the Item according to the Graphics View Framework. It inherits QGraphicsItem for Item framework and QObject for slot and signal framework. It displays the representation of a TrackModel on a SituationView. \sa SituationView, SituationScene, SituationModel, TrackModel */ class TrackGraphicsItem : public QObject, public QGraphicsPathItem { Q_OBJECT public: TrackGraphicsItem(TrackModel *track = 0, QGraphicsItem *parent = 0); ~TrackGraphicsItem(); TrackModel* track() const { return m_track; } public slots: void setTrack(); void setShowPath(bool showPath) {setVisible(showPath);} void deleteItem(TrackModel *track); private: /// \a m_track holds the TrackModel being represented TrackModel *m_track; }; #endif boats-201307/images/000077500000000000000000000000001217277220500141725ustar00rootroot00000000000000boats-201307/images/about.png000066400000000000000000000627601217277220500160250ustar00rootroot00000000000000PNG  IHDRcsRGB pHYs  tIME  ޽>tEXtCommentCreated with GIMPW IDATx|iwYrwnݣѴd[їgd5֌iizZ4 n }}^@88< PyXx"B\\\dYieBRzZe!ZcL$ 4M1RJ"M(5Ar9^ZRcWq ZJ-RyR)!eq !Z|۶ !x4M$<2~)iXR1dQfX:Z4Aa _z2.<~BH#ж![)5~0u2$Ǔlkһ=e;3*54Ήw5?C=Bp1koMeiYfpq2#S%א - ɒԾc>B Xk(ᆥ3GM\.\rND)Z>h\tiY"3; 4g;;ɴɃǷZk#4MZ+)@j-TӴH}^E$) O^gẐ̘XfYf4WP"%C:Ww -\U Y>[s?"Wk~ 5MJ @JEJjT0$DiAQ%m =)r!5ƂQ@ :$X)Z(mL5OJe!Rz$I2Z:5 a\rK/~kY,oa)dHd)gip8s|FB ]:?? q*hzz>14Xժ8=} Q0A !PJ~t7~_TDH1GƱGGб?_L|jlY@H4$嚁; 9@9Zqw غs\Z^]]<>'~EmWNӤټyy֦\YZ۶X4?{1dB,Zi4FO&hT4M=ϫT*qu;e)J,hs׹?Qi `1iUg8 ה"NX,aH[TĽjZE`y?#^3..z]7WWR2  ^7~FF#L&T$QJ%DP]bےY|wqݹx8GHx>I0˖B`lrNHcFb_<βne! o2jB-8>!.`;=\~WwDjUxBrp}ml,"oSBH2 ˬRa8m'jH1Oh!b*|YNW+k5Ri%h$;jZ%hn[`mm-Iϟ?c*t`:κ@w{{\(#<u8:1(kZD!$R\.GQ2 w})R3"$ ŏ"׮ILSKg3 B\.c<Fq|ȵi9K8Ç\.Lax rk@ıLT}]IAx͛$I677YH"r'@O @?Y`!yƚ&Z #Bha2Jlq kkkJnd)>aZ(&'nv7'Z,Lh>kAkX?f_ ~)G2FF>|@QT8}k?8 xL&fY,*zRJJVԾ7pˣQADk\Vlb l"TB/Mӫ/zA=(e-(5{b`cF#Q(͆JiS=r2EӼJd2cR ?G͜w߽ fܻA@{,`2ll!zPR^e61(* ULť.J\.7Nw˟ar,Vr}n7 zI'`bFB Rj4s KJ9N8FOi)d۹3RA$Q.٩jFLJoz\J) (qԫܻ>x RZT@BX)E1 狼La6ZO> ý=nz8p+UҠo.w)1ɹh5 ،8hѭnih4i Ϩ9(L'Jock8@1 _F#@><|arf#!@J<ل=PÊ(X~}i8<>^__onnjpvS I\]]j5/XkPB 5&MDqL+F+D׃s09qr*ܜjER><=:>>hz=Bi^\~cT2$//A܄5\10@.WV||&DDsH!y>I7775:dqm=$I0V!2d^P dkrG\ㅓƘ0 :ɹsMs='F!(QBEgg`mmyDP@a[_e9@kkC "V)<-jkR*B8 0h40і-N9 />T4^6w  62I&G!4Myt7ȘXE$ v;ڕ"qX,Zׯ_w]NׇR"߇Ufv&BtM Z-cx 8;d&])mpV+N@9ts|?:::88@a.y?߽{wrrD^^% c#A7.(FSU##A/VZϻժ<24U1hasnn aupU*c E /Kׯ8/ \~!<?y|ERK̦IDdar3MS:Y}GzM!֦ah8yȲ7 w jSh6}8k!MEf>_@o/4z@Sh4?~j>L\LD,:~l>x:卢("’$Lfmfm{Eĭ>A.l^ !OJzٳVXr2_]VZ-s6R$3 @JL@ P3ys3I1an~ae.B"50 Ga Ϝߡ J)Bb2M!\a&I 3BIq*:Q.?Vuhii)]\\cVVVOϟ #1A@R13:5VP,PBD dD8Ik&^ ygggJVbf4mnwuu5ˑ^>Z+2V2F> ?|r |-{pV] z8Ykn/-%"L TfƏ3/r_d2{}zby^tjNOO?h48JbtN18vz!@{m5/!<P, c8Uzv4>A51`u..`:nnj.ra/b>Vg?"W즅0~#46,6`AV{#Xh^],%J/䆝5]95 ܨps_@x"on߻_^6gnn@JnO07P,Bkk߾ETaLSՌcIU/L#rvDH*2d -0c-,BÏ hazXnO^8FxHc)ƊavdLY6y52APt /!ۅv[EC u+aAaF.իW⫫/_&I:.: I wIDX;t+8B#֡rѦé[a:bT 1 i:;J; p>( ȲR|iiϝb'CؼEȄHa(Jqk┗z;$fʂ5 dƤ&vE`0") ]iLSA0 Jk<,%@-ߜ}GhEסՂ(\E(XfYoG,8HbK*(ӫWOb9 yNYJrggX,~χckWe訬%b` 4p*cNj<H٫AdF)w)`?>x0<+L&p~kkP(¾Y9d!4KV@yy xGsj1kd2vkkkڛ)eX*H_E)X  cv=J:w^kÕ'N q8m.[:hץR,%) 6,l'_%Z;t CtZL!\^rWIrkN¦uMEѧO...=zdc¼eT6̫a(8Va_%I)s:.:4jwbGx>`LfRCբhf09BԨ6f|[@HHtt$M3t:z&$ɧOnzFQ}=5YlX6֦Yeƚ,K4L;a^+@~I: K2%/iO߿&S 0>wցwq  IDATr =z~٬awI z?ףƤ5Xj?k)jЩ#P8TOgy\p9mۜZg- qyߧ("Z|oTd6h0vhU//>n*i?s5ձ۷o}ݥ<<<2BԺ^ŋXHj͛w=~R8ύpSBXe c%yiR$\9OZ8_N: 0f7W?N&-ԁ,EbRT~ 2C<E1*FR) qu? b~CĸzW_}Vs.UT1QbMgTAHadfF;< E0mȩ]m#$*:QĒF qD+1pa#k6L&5`& ai ~*hǧ~)pE"ogM"`@T,53ҎgVVVZfO*VVf|'.DE %!5|xsoj}l)^tDim,DEN8y(^$qkHE\.?~t0 䳸Uy/9Āݟ[2W,ǥB'^E'DF%0믑Z$B⺡b$׆;*Y68>.ݿu8%C|:Z>[%V9 Lpmgb>~̝!||>[K/fh@8S\bt 0Y$43䋢ta4'Oa8jʽ tvDboNLG,R@d2 <R*)h+uxC{18u j{{;ϟ? R#B˾xV@ X7aXR]YYޫT9ֿ6ǾߪTKKj'ٙ<=@|b0CX:;;=??@k䶿wttl6kN'`es8KϙA RF(DNJ6`|a҄es) :1Ňy ^vwwI0JueemeeѣKK~׻j6>˽~lnR^A?Z]+%1RjUDe&0KzuUbɓ'| .y拠(?L"'O]ٕ2JPNRxОop2c|߯bl^^^6 FWWW+++)5x"5~f(N e5j1XA!֬TӴ&tr:M"blj:>63~։ P>{i8u7ǔ@" (JēJ̨PJK4S'Gq: wih41AR;-NR1*[[#)}?kduuϻ/n{R0~2Y&i=wO'Z~)˭<-n|^٤= Xzc4B`ɯИr9#cRYX<s܃XaݻvSF,qA qxt8dTֹ\(pi6gTIr֘{ q nnWVR~۷o,#!Iv_~wJ/xfw:!o8pIET2 Dj'_v$ntzy^Y__G rKKKKw\(VZKT/x<\[NkBRy<_/BSWz?Gg4jXÐ"Bu3 3J` UV آZ'%\=JB\YYAMh2N_L/VN{$BagZ-~tyxxq^meśN''GH !PZaD!5;dȂV;y3)xRkQ.}q7՝t3ꖧvFQJ [_oT|>e?O$Źo䈁[rZq1Gt/oXԧ9x3a21EnLq? BnqkgżMl<fo|ݿkyo(yuX^8"^&Z^/N{%.<[ӂ5V!TByon'_8Ȟ sȞ9Q9c߽{~_^^~᫯9x3/wm+b{V48}h41X ŁUi/Rag< xjav{eY\@ f1M3cl T)U,d2< LUZN3Sg2Qy+M > B~&x}}?9'О (+FZ-zRJ0 FEiח$v/A<ۭqq1jo~zr8l'ǂIvrr+:'[1NE&9j$(uԛwHy_R]?#j!9,+ ϟ?`0 R/&XU~bH *Bq ;/˿|Ǐ[_:@0w[R BDm~.b[/ Fs|,8$n6f#BCB|>'ր 6]9tBiD"驤g(;O0bHyRya˞x<~M^_H#J'xڌ` h%o_]u~ﾋ{GYHќLc1r~%:wOomʞk`VO+cfq4]NIPxRHt8GqPОw 5Ͳ )`,t8nnnR[|CwC3_~=p3|.m?`?ȹu)6R0lX#TJiKǵXcQB*k`:`Bc0~ yaF5&FK Kg{o%:1nЅiZq)+O]Qp޽htqqQ*}~VXE'aijn t*} qܳv 2)sHY>/8|hQ`A)@ RI)k 1"3L)4xs!k*0`!NA>V~fES3*̌Jk"dxǃpf?0BC~Ku ݦX,"LrП< դk1Μ IDAThg~5ժ:;ۛN&I+rYZ&[h޽_ϟgP@8 sa(`FcN0?SÇxZe(e0&Qh @y͍ ]-^ÇnxoO{@X#\bd֚Dz9KxIIJ2I^>&w)y@+|9ݑuss~јq"w&Г-;;;o߾M..RunLz}՟fmyrbV9=7f.E ѯV=W*%TKo6޼y$ɓ'O* ~BJ5GKXc4>}{{{\y16RZR: x4>uZݱltZ}:@ZZE䋥TEv}yyY,ViN+k@BqSs_j=ol[`fytt4tTI,˲ Kwvvxxw\ BIF]L('(whǤ$Z2F#ˍEwMX,mۿ}otAjn.&g"B 6$nvv`uJs).ǏyO :P^* K̜[xr-J Npla{-sȋd;r$.777{ӡ%x040~q /Y;½~tyBrV uH^c:N>pt:+++T(ǷU wVS="1,upp!t gǡ>qEb %vKKK37 ޽{j8vdmmJ&6 4Plwl7=9q7$AeƘN[l.`LJ BZ)p\ X[ڙVC Pĩ:mqizXrˇ8xT΢("k?o^__~׿w~b홅#(ޔ[xfccb*ڠli`.g,vx{{՛Ӫ1zgb?l6d~:N==N+۪p!8a׮|~?V ѸX|fLq I'5?BJ5rPxR*yY$8RJҋ/>nK3ϧz_*p_nGI%oeqW7Θ=;9U{/8ԝ1h]*-]P_񿻻}W\]}K̥tEf.N3M 0 3Eѣ BapSd[k>M>x0`B= ^b䓳Uϝ֚L+y7l/6s=8b;ũ L6|vKKKIpzp$9- 6U(hQJP66V3.Azޛ7oӈ/B6xO/S]_RHk0'OSIgű+.f<(&qE kfzݻwQ5oj۟~B r.< 0hT+?󵵵*Wg ij_~=NqeR) 'm5b EZC&b>w8̶XfXϡv*bfeGGG>|X^^~?O5?Ofn F=y^2Ci.wQw^sRi?}য়~nllCޙ+ ӭYke Ri .'AwQ!ꌮ%?:}^w~|~Zmraa 3!'9wh V*O"j}xq8I 3Ō}#@$Ix66 ]ob ^G~:h}lAz/-s7 /Ō? p7Hy/~Ѩ.N^fF38yss=g jcȓc.γ3Bahϩ. :Al~q0OT}qys ޲Ù"˷w''/mJ=yzBq_$P4g4r8a>8>c,ID,]7}˂&@ Uw̓'Ru# &f( W9 x1pYU/޽kɊjCbˡ|=?R:W}IZ2ya/ZP^.^t֦Ukk.nHW [ָGvwwo߾\ևxdk::d/]֯ns=0f@ ,C`ǫӝoǣr?1߽{w<ϻݮn*j!Yl=ְTU ˫iԸ̧sENrM&IST~fJߓg}BzvxM"'~/RX8΀cπs7oPh,~^M_śag͛7zloof[>՚)k"HʋyBlݒxɋ/>c]}u-Ί.H`(X[k!E̓;w?_/Ko 7X~, v~y(18iٔ5sLcUw\MSUcjL9"VJH ߞ?˓fY ,.53-D@)#gp ࢪw?oHu9h;?phy<$D?|>[B]A38  E?S n)eznYѫ"dGr~\Uo}z]_gf.|^@m}S_ `<7;>ր㯾f?_L&ǟ|iO}Bz~G}ii|s%ڔC%u][d WJf!jړ|kQ%\w#w9(ں[+:_?9??[[[0oEzfGf^@;:QȈ"=9m`<!=u|˗_=|;wnmm蹝g)a鑋ݽxZmDcb-'nT"i}9 ,jGڒ MM_nnS::rwV]7d2qc-]"i4U"I-5n<$xg#_W'ҝyUeן>}zrrËuppw..8`66HulͬZ'Z1f$%a677_tJ[[;7o ~ _׷ƍNGUOOOGUu ܼyٳg/_,S,aW絠U#̂x--03^,ɜ}j@uU<ｼ|q{;TǪ*7ôwb"2f#R"XW fCEO?`;=`0qn[[ ,wwf/_zu֭;Ѧ@;1Y@ 7[I 5hֵ1.5\M@ )4S^l.Vx[eC Bݵ&o?~?szvE@|/u%Q$Z+IU&pdV}jO_~9uk'1x맟*˓wۣW~۷>ֽ{דL[NFl61;c}\z+*{_30hTC^e_J[.|>vy߄92[9zONN޼yuƍ۷o?~zttZ盋VQ|zeQT}xjD5s HH}Q fffM{~:~Uߊkp>]{||xt4}O_?NNNx͜WSvS >eaV/3J\l6;??O^K:Gk%vvsw#x߼9"F{ی~k3ZITjBMB 'ьjYI,w?\7Z]ݻ';;ת{%^~2y{hӅܚ+rO|9<<Fnٲk0ĄTpmMΊ888X,N}Z6y2ӿې7o ^[1v$2{#c}P]]K!(F#p .<9ݻ\"egUUmooZ.iww'ocp9h2ӣdkssyV'7_yRr`\ S7d'%sŋZC^DYI0?ɐr{YL;hX:fzrr6U- 7,dUbLDlDИ3;"]2o׀Uw?K4"))[__؞kb<ލVU(N=<d{{{V50n6< NUUuT)FnwyyOOEx8D>S+R M~EӴikx@B~Z<9CNt{0tbX.''/^1EQGbbTUU <"3NOf^J{c%pj11B>!VuH(:uZr^_׹u6;[.W yAUG__|9mak_B@D4Xr]LiI˻'BMѰ6Rŏ1fGgō{U:Nab;aYY ЕEGDȒyf&u=qDTż;sGne-Troд+ɰdBu~~qzz!RTeud: N餑u1-;j4U$'%]r+5ZBveYe t\e!BǦUiCS}sd^0תݺ^WYUvvp,4+rU;Xe v*ZreSY PQE1??-̔.iy~)H9F3R:q^=DlaULm)}qqqttrr2+`0 Xe~@f p]RE^kRe@"#)^ZBW.A|8\^6PA_'z=ե0;{=Եs")NYVeYnr "R"=?B X EE38e-3lKSΝ;%zyj>3f3;R..%aS20KWZ4V쒸UUHP#g DjF࢐"DK˺6N$Dkkqm!·{PX4&ed\H`)ðX,̴(l^ɑH*V增cQ5b1VU">̰j= B`X(;7{B*K >/c]04T,z:Φs(:^,DWQAШ ..K1R)k*O3HQHYJ ꢮH"KTu꺎2,ۯ$wY :HYc\bT1W|  CPjuQ$X|!#]gipCk")5T(iVҸȺ:QVhI>535fr[-*CC(@A,tIf,^Ǵ0Z4A R X-\ Df^bUU\Vþ{1w9IDATjԈA"HP,PzK)q^@h&, x]yR"-Ơ84j-*beaQcqID 36s 20(Ș AIakE 0X׋RX_)m౽ΓEV Pjd L8͐ FdlPPY.IVUX[K!+lP(V/k eA U(̨¢Rjs! ] %v45323Ħ$xߵ1F 2vENzܰ]k&05!`˿)| 8SCsXVZuQr5kx: bLljpsLBEc !jP`@ jEIY,XhьBW<Ԣ+1Rcpl%F!I00uV,njjbbuiSX}͈ؗԡk2-l5(i cL94n)¸{@A xqڢFhd.L BA cIF,AӥC J V Ȍ4(0V9#  !ڒe'úbTS"bh``b b7k%!EZA6&c?0P}_xľÚ(<ް +mEUIhZ#ǘST5gOa[h0#fVAPH Mѐ;( k 0YUDc=(MUO"H"Q VI yɰl^QW΃PMf/XaE)L8aF#" ɃWE.ejD"V|66O>MG)rG-6E=j)5& N)ܬ(2 YjSjIDMX܂AP4)QS QkRq}$@fT+5jE4 B$DP2%FA,fcbXFqYa~%Zt4Mg]R m&76fXkrg̖ѐpsw%J<ޢ6Z]䩥W  ͬZt-~9Mw rPfp=7LDG-"ֈ`1 P% Gbx`b,JXlTDJ<(S1FQ)H+@!. f1!f llLⅫ6:v9@,B SbJM}21^ O A`H]IENDB`boats-201307/images/addboat.png000066400000000000000000000017571217277220500163100ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYstEXtSoftwarewww.inkscape.org<lIDAT8_L[U-u-kkl"BAAl,S2h6d2|DC2& v#&fB-0taС'%'sNΑd$Iܫ}ۗ_(Jv^J,~P9>˅adNlaY\^M{o(yڿB& Kg;=(=Poػ_uxaѴJjB?i{a#ƘN,e?QG^J'qL$9)b$%4}y+CW/EshV4ξ]-h2s79)Xҗ6i9H}v/ g1݄X(fjIȑ$]G Wv g1AJU5_3z=yy4}PSa#&2 S $^dYB?sz 7 9q-&"B\3fHp(UG˰oֳZ-nJ2o p-Y8hƹP[~D^[A)P[[0 G#X3VR\^;uQ$*u⃮qB Zʚmvt~ojҾsNo;wzt-mSu;ء68zzf2>q3Ohj=*jUxW@kkp`dU>q)zZ-ߟ|WWIe k? ޸IWS>f g8|h򫞞M>ͼB,L6#?ML$_ᡡXE '/_'ҵ%EIENDB`boats-201307/images/addmark.png000066400000000000000000000020051217277220500163000ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYstEXtSoftwarewww.inkscape.org<IDAT8ML]Esw+^Z4@ʇE)hJSC†1,4.nHlL^1aa.ڤ6ib&Xh$0R\w( Or2s&͙3#2|`QeyGoY1|y@SKe ݄QHO &'>wMLiz%ADpK̎-11haQ!L:FZ ǜ~MN*M%=gl]=g@#5/x~g#D!%3S\~ s`I%"!kWIfze$,ÓB/X#@A.pC(0&`aU?yyvuG̓|5A @ gVÐj'Sh🐟`ڂq螀"PJ}Lyt<Lmo=Ѝ?mU5A4ɂ_XhpHug pcE֏ۍE=/fLbѲPᘝ= :յ7 an$T/ ??1۰bt}㋣33'RHKa+r88;&],۷2vt"Ӭ(X6_.tZ.tZ:*/ϲ"ff" pDž1N]g{@?pɐN*Ç=2dHf`HO#U B2twÉpZq=HHcH{7י3CCpF<^6kC(+pdɾ^-W8oqeےmKOKWj9mY{W*.^s. ~cF9.!<@Nk@[b|9#{IENDB`boats-201307/images/addpoint.png000066400000000000000000000012611217277220500165020ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYsvv}ՂtEXtSoftwarewww.inkscape.org<.IDAT8퓿kSQ?H3t)Vt:AqDT8tA. !jH{yM0:]s^b/"l$!/[LNڝR)<ٕ|S@k5llV|S b9 xI8 .*,@!mH$)`n+@'(Zw?޺voWוgvF@?bv1͈Y.-Zl)Bg} tgkrEɘzak6B?iPzH":aDK" Y[uWfT:ӦGQ=u1 \x3X7O^KtRt4gW98~R- 9SGHk6e?&Qɍ%wx(n駖rB8zf%q? ښ3"baTt2;pAjanDHJ<_8eѸcFXwU6;xo+)a_v!rlo{e+-aOJoIENDB`boats-201307/images/addpoly.png000066400000000000000000000013761217277220500163430ustar00rootroot00000000000000PNG  IHDRĴl;sRGBbKGD pHYs cytIME $~IDAT8˥OHQǿogvACE HnZaW( "DeFC0.ѡC]`^lfH{ί쌳.?~}w{`0H @%87 ʳNo+c鹜XhVTy=mr?*θz'94 Rͧep6GJmO gR %$؀ۭ_{o^~uBg܇w uWaHMX) !3[rhk#J~&R|?B  WO)1=Q0 7UlFpS]gDf48Vtxr=)=÷7{p3X> y >߿bU0xj .AąBW/8pwEu֮.*8IMH҇[g\k{_D ؋W67wÜƧJJfEt]Ƕ!d]OϩkEIwR4SK$!E2wwMMs׫,w6-Ԭ&=ؑ5JF (@/pYDEx|>- LGk4sin 4 mH]e=\SJu~YMڊ˒1@`AxVslןnKIj8㙶: 60#4-- >9X@NobȚv_)`:,'|sX)!~b [7S-Gq#{E$`9/?dpމN"DfzV8cK9 PXW,^uz=e}WԊDuH&þ˖\>w`;͎?\8o24[z,97{ժʵ+BR^NI캣,ZQ;RoF?ϣ&:23~-l8GݡCbfk&-_LuWIENDB`boats-201307/images/animate.png000066400000000000000000000022711217277220500163200ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYsaa0UtEXtSoftwarewww.inkscape.org<6IDATxڍT}LeݵWBkSZ(_AA(%d0AYM h$Li?&-2c&벰.j 26h -z5>ɓ_y#B'5. 1/ $3Orv++jش!-B \m. 떖C̓=uZgWWp62 M?<=M CZbJ|@P? I j>2[$w cbKb1=%d2-3g{<#IAeF#t&]6;fk8Euu'ݥ_yNwd_r%z<`fb̌JܘLr{x-p˜Dj{}5'XE<8] +Sk#p8 #]/G᫚MAplo]ǥKV&J PuuPtct?Bkf8 OL0F-nKohh`` N4Aٕ)D.t"_ `WW:ݴ=|$G+Ӻ76^KO):%*)"G%$,c>.n6Ra=TR%,'`/C(HHl覗\;'#:龾Bx 6r{p9E-M!1 :v^ 8aɠILUℜk7fG/}~/)% q:bobqlB2==ǝp8 jw۞ֽxBQ0.މ \._i[|R$BYgRiƙOMM-y[Vwk n>D:6ދ|Tr%+n2eE8VE"w[aјx!\~7Ol]#P8q2Liǟy\`ޭ&@,IENDB`boats-201307/images/boats.ico000066400000000000000000002414461217277220500160110ustar00rootroot00000000000000(F00%n .h>( ====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! E(====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  ====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! G%====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  ====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! D#====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  ====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! B"====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  ====<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! ? _77<<<<;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  ::;;;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! =%%;;::::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  V4 ,,::99998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! ;xU22998888776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  v5588776666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! 8.!!666666665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  M, ''66665555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!! 6oK..5555444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  d//444433222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  4'p0033222211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  8 {//2211110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  2D//110000////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  P//00////....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  /\..//....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  h'....----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  - t1 !!----,,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!   ; "",,,,++++****))))((((''''&&&&%%%%$$$$####""""!!!!  +G ##++++****))))((((''''&&&&%%%%$$$$####""""!!!!  J ""****))))((((''''&&&&%%%%$$$$####""""!!!!  '#D ))))((((''''&&&&%%%%$$$$####""""!!!!  z+> ((((''''&&&&%%%%$$$$####""""!!!!   %8 ''''&&&&%%%%$$$$####""""!!!!  o!2&&&&%%%%$$$$####""""!!!!  ,%%%%$$$$####""""!!!!  d'$$$$####""""!!!!  """##""""!!!!  Z!!""!!!!   z !!  uO t   n r jDg]  XG `:C2 .  U0|  wf  J'bQ L; @7'  $  5`  l>  , M  k+ h  uE  LR% 0o a-{M F^ X+ Ak5w}YT# H]$]!!'-,#:N""&,-./-st|xq>##%+,-./00+NO>G?##$*+,-./0012#r$$$)*+,-./001232rs`:%%#()*+,-./0012345, 78( a` &&"'()*+,-./001234567!''"&'()*+,-./00123456784YZD(("&&'()*+,-./00123456789:+ %%))!%&&'()*+,-./00123456789::9}~Z** $%&&'()*+,-./00123456789::;<4@A*+#$%&&'()*+,-./00123456789::;<=>&`+,"#$%&&'()*+,-./00123456789::;<=>?9IJ,-!"#$%&&'()*+,-./00123456789::;<=>?@A*g-. !"#$%&&'()*+,-./00123456789::;<=>?@AB=OP!./ !"#$%&&'()*+,-./00123456789::;<=>?@ABCD-n/0 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDE?UV&01 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEF0u12 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGC[\+23 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHI4{34 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJGab/ 45 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKL8 56 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMJ gh534 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNO; ""/0 !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOM#mn:+, !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQ? && )) !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRP&st@%% !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTC** "" !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUT)yzF !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVF.. !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWV-L !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYJ33  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZZ0R{  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\N88t  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]]4 =o  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_R77i  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_`^/{|"c   !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``aK ]^   !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``ab]"VWX  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcd? :S  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdeX77N  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefe2z{ I  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghO ZD  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghic$UV @  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkC 8.  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkk]66iij  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklk5yz  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnT hPQ  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnoi  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop   !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopjRS  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop!  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopkTU  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop"  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnoplVW  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop#  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopnXY  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop$  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnopoXY  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop"  !"#$%&&'()*+,-./00123456789::;<=>?@ABCDEEFGHIJKLMNOOPQRSTUVVWXYZ[\]^_``abcdefghijkklmnop???????????????(0` $==;;::99776655332200//..,,++**((''&&$$##"" {==;;::99776655332200//..,,++**((''&&$$##""  #>>;;::99776655332200//..,,++**((''&&$$##"" ++AA::88776655332200//..,,++**((''&&$$##"" *4 22==776655332200//..,,++**((''&&$$##"" yYY559944332200//..,,++**((''&&$$##"" $E66551100//..,,++**((''&&$$##"" t 4422....,,++**((''&&$$##""  622//,,++**((''&&$$##"" u' //,,))((''&&$$##""  31&,,))&&&&$$##""  o=#))''$$##""  P 7''$$!!  d1##"" +  Yp& ~  c  Lf  yJ J_4 CXF  %e .>&TU w> ./ @N EF %%& )W BC ..4  M g NO ++./45XY >,1=> )(,.024AI&[66"%&)+.0258:>::55552200..,,**((&&$$""  tA'';;551100..,,**((&&$$"" : i5 **6600..,,**((&&$$""  r'D ))22,,**((&&$$"" 7   P''..((&&$$""  o T##))$$""  3 N %%  d H   * 8 W$g& !M׃  L1] </ ;{- *^}#11ceNO + !*-09/ **K').149@" &'#&).149:C>45U "&).1493 G?G"C.|{ٲQ(N _s8|$/@W]R-'UHa~74Xףk8omoUѽ&r(ʶk{ چ4"Sw5 "Tj+Pmq=yo' Nw"~w>!vI)lvBЀfwV&wSeuiv;,˒."t%#7 #̂n¾I,// aT*NժNԱs}||G}kڧlW(PxzҼvL6MM4KDtr98xB<~"7ZlŋRt|rZ ̻(2TZ~X?TQ| cJs g:-%F)}>:qg2] ߑ}:`[:'Tkl2tC)hXk Pڕ|gr|sY&O Z"P_, uJinsO˩=5<FZ7ȶzcu#FL7 5\lАR4(n 6W560v$t# 0 oŠ^pJ=(dDF`E2g" wWT| 5ï?;S0 V$`!'nMBtf͆QG(\eY^lw1Z ou"fتghꭼ<}D0#WM;JW/pj]{8tg{8xK/qTyIENDB`boats-201307/images/fileprint.png000066400000000000000000000015601217277220500166760ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYsvv}ՂtEXtSoftwarewww.inkscape.org<IDATxڵ=H[Qߛ{O!Ak%өCpP;wŭ"Y+th5m!b41?{x/|\8s~hJ)i80UE.Fojv'3sjڻT*T* ]7$# 뎊 n\08||rL +@(EpĊ ?|>;9k/* Ny&s[-6-;ܲsF>5MPGIlb-B'p8ihs[T*8u x`Zlmm DB ##~\&auuiNu(&ILNN( C[XGY2-#[g_a\01+++-ax#tw?a5ՏѤX..ED*Qjxv^@uB%hC Xa}Jiڭ  :mEWW9w5^g2)Ӭ(]ɑS7IU0 VAAA^7*0%* >ԥaIENDB`boats-201307/images/filequickprint.png000066400000000000000000000021231217277220500177270ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYsvv}ՂtEXtSoftwarewww.inkscape.org<IDATxڭ]h[e6Km-z1R ND!LaQx!BUŻLLER?֭X4Kٜ|>'vz y<snIt@{1[tˤ% _ҴƱ`qWv6RyebbAӴ}|SW2_ov ],l67aȲTFo<> Yܼ~`X4ϣEEt`:wa6/I/;e.a7@¥R Z6"~ʎ]Axk,/~l6AJ3zbj iRaB"k"i@rmDv;냳,wuaz`w7 8Myr2d Dtߧ?.=r|,fss+++D;&?̓wO᎞ɱh,F_5@~sss(:.<ybUp]c^m A>ߢfSFo B\Myj<ڀdԂBppa3ҟB#]v}P:J;@XXX@ `1v.!d2`8:A `nh:crr.}CȞ.X`I^r*[o&qXJ4gJBXT*Lrk[uo@q ظ$ɗJH< V*>,m ~ NUijjJ,jK},V7_j r+hS?i"=zNo Ns9ޑwx{mYfH9 LGȪey8y`-UrlܫlLZRJ[hig2YJ3NR`st>6>uqݼ09R(DBsA8p<\C097Y+$ƱEKM,qsѕ)d2'qXc:`fI`ݚոڗCqjQ8ma8{ʂ5'wt BPi>9ɍ S;~v\4ĹaV:r#dd̰\fw0:[dp}@VQl4?O!0T8) C<}iZًr^z{{%~!"8ȢvaCpN@XX z S pnh_o4us1c~"IIQQs[,fjoLv}/3 [ kʃHyoRO58@~;Bb4T[woN 8t]`ieUO ȱm}s=N%~C((J 7[عm H`NCC]ݔc~\ ]ะ0b3veeb{#yi:!( Wҭ D.1԰g{W+oM_&<Ӏ?\D$*k]Op,LWC dYú Rlm0XZC$GoX茅g; TmcaS-o9+9_U$` `9=13i?:#&uJ.=qgzV,QXE (3y[lfױs3ޢy&xf*65A!I\Ī-R>EF~&ol%A&+ޱ,sBV^⦪du]2nL0$28"R̚ZH<4iΟ"+/;n~LKNK/OSiڗjG͵YHE D~*Sn1M|guR\m s]_ҥ%0<asBIT|d pHYs22htEXtSoftwarewww.inkscape.org<mIDATxyיfF$abD6qY4"`fhA~n aQ  6[ujazy[s{sU"BPJ PVG~7AVK8r3(@V.KɊ{J)<VT79-)&gĦAJSŊ (,<ۉ*Sx),t?K0pn.ġ怨gӺbzEEǣ~;QuEA9~CQC7g beNo_sBER#)* }n ؅?y ;hNh.ohPJu@BذKqq)Ҷqa`\rS\\?悆x@K.V)+TT9[xoxѫ< q$ s\hZ)Sg9|< r}LW3) 6oʫr.3H`Y\T75;~QS>  pQ,.C!5&sχRR ž}5\1MF^uf,,o'" K`.Ȝ%4z}^T \%"׊h'PD^u#ҘM 1uJ ǶmЭkFy"2 huu0:^Q;c\PHtl }\kkau,X(񏙟9X ڊ._H{@^Re2bbg)ODf7RU\T;:Jn.z}_b+Ex+";rwA W8JhZiXY_V[hsg< pĦMa׹޵fE/)"[;qȃdJsXQd#~;+ۀDdh>3ɡᛕy),ʡGwg}d8|~F}ÂxID'4+"w|0h!>aDBӄj.2C ~Цb dWq [2?O=pTY:`&4>w/'81nZ y*Et R) |4/( ?Z'dX^?_qÏײm[){D6hLR~_e% 5ǎ_YIx/(YKR:ODj>\U೿fDWwӭ2kw$|H1_3Ks˂7[SPiƑFb'~z5+"q+H_ .^X:o\&x]tUOU&\)0ا),̔ncŞ=rF^xq5kcD䳦~d# ˀW֬cА|uf0s[?T?C  ^DJ^-(mΝu)឵"b  s֭cdb欝tUA&| 0_@o*ңE J).nؾ^ښ7D$I0/' M +`<$ Jc+0w0𤈌nLR+LJN,]TNYh`J&T|_qx ]l+Y!^ǣLPAkkN(G#ޙ3kPj&^RBxҀ:}m'X |Kyӝ;F]& Cm%|rLpZ~Zϸf`cPJ'sDqnI a)nru S<_ Dd ΨE$]XcHFCDB<[B)U)8ݑ+.z+pG D֚x:ZC3SB)GYG[띀RoB_15"N0z,{ ^sNwhZ{*Ddp,t PJB[yXjdKo"bXT}kO*z&Y|cdit/xcHo$YY}C(4>p (:fUJV-de݈c5|zOG-hJp I+$k?|Bd)|>8 pNG{djƥh+YD>/aPDzOO7LnQR-gVmg}-x<]&{Ϳ!ƚVR'o~uf,rs3\b@d kgp N#vw 7w"ʱM33/0 ^?#/o2ñv " 昧ȚD@5QYu8%Az{E4 gK8ǂfz77.W7<2BVhoЛHԘ,:R9nV3.eͽ e N9B;"ƿFlhPJ@nw['w#J2>$!C0~fӞ;R&Y(AϘc(0coC wx'Ӫ՝^Rތx+0p_JRMXܭ|L!7Ju7|9)؊R]ˆӖ}CyhX|<~,Mp ST4@`\' 5:c :HL+(}>/ \ uidgjl)=>Rm_VdssϣxYYRN;?F(($n" *DoLJkPRr/YY'[i/x8‡18@ JKgDR}*|z } 3D$bd `΍Go҅'RdgrsN\Bx$‡$1` RZ+ZFM=! >ܛPh=1E21YJ`:9s>_9w-J*]дM<*C@)u1 =0ҩވR>X@8|/Z֟} JaG%%?u[q2{<>дyK >s3ʥɸ-GڻͿUoS@)= S\<6md ;C^!Zm)+"ҙcQ$z7 ~:*gGIENDB`boats-201307/images/icons/hicolor/16x16/000077500000000000000000000000001217277220500175315ustar00rootroot00000000000000boats-201307/images/icons/hicolor/16x16/apps/000077500000000000000000000000001217277220500204745ustar00rootroot00000000000000boats-201307/images/icons/hicolor/16x16/apps/boats.png000066400000000000000000000012071217277220500223120ustar00rootroot00000000000000PNG  IHDRasBIT|d pHYsTTtEXtSoftwarewww.inkscape.org<IDAT8MhagvcnaJJ*Ƃ4 TZiS*xPD;xԊQ""^ JЋTr"Ck[TUt``} dcb<)2nA#FqA( _MpXYvYf %3g><8w~*DCbGV"w=DֵۗteDQJ67cz4"Ʀ: P}Ɇ ݂a:#y= +øBL@D΀~UMB"nfp^ ҄mO>pHcc.\e֤HԣXAfϋ2W[ 5c/&d[IENDB`boats-201307/images/icons/hicolor/16x16/mimetypes/000077500000000000000000000000001217277220500215455ustar00rootroot00000000000000boats-201307/images/icons/hicolor/16x16/mimetypes/application-x-boats.png000066400000000000000000000011641217277220500261330ustar00rootroot00000000000000PNG  IHDRasBIT|d pHYsa(tEXtSoftwarewww.inkscape.org<IDAT8kSamB/6;NmwG[Cg;wkNtIQ(5܆|h$on6px?9bfHXFL)Z UEUYU--:D?ԐIx'h=cj2^_7 T̐D jŹy=ce>2E$T MDS* ՗x7@EvbZkS#oJ8h :rMGdo)5Jꌄ|'>sM"}t3nG1{{mNOK[!Q@D03t:OdloG2q3 h4z3P899B.pbjZ_\ x8l8' EQdq[vRX\n3"]^x<69Rz=;>>df$0f]cIENDB`boats-201307/images/icons/hicolor/32x32/000077500000000000000000000000001217277220500175255ustar00rootroot00000000000000boats-201307/images/icons/hicolor/32x32/apps/000077500000000000000000000000001217277220500204705ustar00rootroot00000000000000boats-201307/images/icons/hicolor/32x32/apps/boats.png000066400000000000000000000023401217277220500223050ustar00rootroot00000000000000PNG  IHDR szzsBIT|d pHYs N tEXtSoftwarewww.inkscape.org<]IDATXmL[Uǟ-( 2+ 0{Q |R?l&fL:(ɒ%f4/!-n蠠L!0憡+M)>~jyo 쟜ܓ<9܋D];ƆVt5~T E1IkX%%bT'\[*`byEn)(`l +-!sy~9|z@8KgQ[AU TVx\GHDӉ [J7j@OOx./HziӕSWժFG~k>/ ?(8G׉ځIxmoЕA20 tIŅ"[꠮;~AOo'ޕ9ԝiҲֳD::&|u4ؼб 0 aeݙBb~ o_&2"Z)O<]*)v"E&R\DH)"R DJ)k)HJJ[wǒ FY=ud \YO[GCpos:5kv+!$)uUR͛Wr} @n p:=S =9z۟C̿ث7%!(=XI |Exj$إcԡD(5pKX!8ժXb!2{vDtjƬ5&z}m&~ߌDOS9Q+vL/⣢hD=/̎<﨓-6+DM[l& w%)<3mKI|AL)J [~h|,->GX<D~дD"7MwddqG [h|"ZD@yf[9z}qDPon](ͥ5 6a#  XqI%^VV=9IJ!niddT~eH+bԻ7FjRH+T(>ߺBR/89_z-Gv uvvcpJUbZ$? Cߧ\~̱!;\BjK@Q, M~'=!&4 N24)mBI8p)RD5g{_b˲|%C?8VaaA}Ζtcf˲h6C& ӆQTYXb֌~dr4u00MӎKxٟ`%MKӾ*nI&BaF#LR*^oy#nK@J~+p0i7.teo4h ZuVVV,m RdE\'u8C0MfӢ^in+@]eIhQ2.q)R^r)o ``M(J[TտZzsFc)[/jF&: jg𶶶, UU._HhE&ʕ~};~tX =fCt eVs"DDAGP}E?i3 ]7 G_g^S'u,Nċ'@ ̼t-a֦pN6nzrKCO{ 2 m1{`47Rۘ_{_ssϏu=T=xB`i|/k 8W0m߮U>J߆6o1 D>DTUNBDes\Uh{,s<=,53|&vW2K&Y33Bf@$?}4b /Q^DQAIV ߤ\U/v+"IiDy^Q\K{a"{S LXB]:y,sa*(E~>(C rz"'oFDDEJW7G6`$1Miw YS/Ng3B(&gD8>Ǵ|aa*Av1[|UuG TiEy;>\31%0K$-E&r?pm% 9s^fh )ʼ3٬#"'45x`f ([A}j}P,*c$a$"7$u\!>A(Xr=; $2َ4#wɚf#h_YRS).*9F8^`36̥hkEeeە3'3 '"FoiO4.m\"I.+ۮ<'3k)x"HueYl?`]yeA%9OHO`{dپ_l߬\^Ma8'#IOL&(UeVз*+-WVPَ?g<HXf.e>ImpnNE/^ ©dSfvʲg]$dυ}W|n]3 o${C^M^$r^d `:E,,\8UUV'_DIL~=˗-;b-+[9cơ MzR-W,-MYc=7F J @< NivH-U*UJEr(Qc|ecڲg/3ۮ7nO^93g~3#M!<_>]&U |]H dBu<_ @BH8Р4B  ֏ܕg'|4U Ď|Ym2&L"D) (ܧ\\M}A| Ͼ T:@z"pD'P_%0MH$RBV NxZb)<~hhw]ƍ$Y[W^=]Oڔ)zk>nin\,G oߞw,>lƲN;vH) ' 8v7j&׮Ν$usnҥ]yp'ePA&&xHi꫋44[+&N3;oc~ncp>mYVWB7 qoH^NkxisL'Ԧ6@7nܸRkRtu=b6GٺwgBR"QD9FQ/uCrQ(41 t~ fd2dYPi4Ȓ5a~ѣ}\Z$aM4MRsssq4M#*M#H0<}>pMk0H^~Oi"Ǐ@u8xSN]c5z +<9 /~8Nd2Yܹs.#wcPt{)=:NWח<_qAf6%JF Dŋ/> 4==[8vloLwy۷o'HǙfaa-jk!{S۟pU{ 1 ˲)MwwwO~ХVh%ituyg x2KJ àD"ę3g~vڔEQ4أ.66Eapp?y/#`H$e(!D"(b޼yӧOL`OR|)+VBfbs[7fe [ < P?7b{UbV xVWŝ8IENDB`boats-201307/images/laylines.png000066400000000000000000000007171217277220500165250ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYstEXtSoftwarewww.inkscape.org<LIDAT8ŕ+Qw%fEb!5 coeckgE)UZRCkkL;iYst:slV+$i%>oǒNA^K?{ .jKjHm;KjDɶ;:PR1dVm($p`9uۻvz#BIDATxmWW0apV{ u[VQ 5 6n)'{Xsfp_ZS,?ˑ27 (I Qk\QDRՉWXa m!q<]L:ʕ_>o4Y̓l5nl,o'Og1g`!!&a:"LAO:u+ ^A |`g}Srj Viڽ 0iky4aw 8}x壇#%T'J RmVa:??Q|[rOȧ=&K ! S(PJ"858{mhuxҞ(t6|t⹒\%J4p X͑h^(V2P~PW;_]t8yh]՝&&7[ qbKZ&?vXk&s[zʬ|]- R*CA2[3MsRD)ɕ%bՍi0 *+r"[0צ密tR^bVB>;urnB3( }Q9,B֦J 6dLGIÔw>jFw슬J,sdH֓&4}q@YWs<2SȻ ]9xn4cxwx=,0UvxZܾmB䄡tХ޳<=|Z J%G' fB69 0`Q,Ւމ]1Uv¡>R䞫ST!~06$lbzodEY:]~Fs`F7z+!#!)ݴVU̅,W7S {۟&lW<`5q8_N  ^>I|DuQZFBPpF ;~VVV[?[#lz6PΤXri=KhR֛ o|t}V_sa-b8Yh3_N;ʌ^ ķVoGs_6"oFflg.\Ǭ6b8e OvBRSnekz?JJyɒJ\G*|ngzl6O_[Vwpa[Re>*%sQeTrHjZϿKka?S_x6$KKK/%P\Rerrd0&)saY]Yȿ_4n#tfs8#Ϧxh { KB ֌[ PTY{7 pk[_dr:/>x5scFfC lPQܮ!//Xyr"u\. p8wOoN(%FNM]M't"1}lZ?ŃAר}\811ZlVKdI!%tCOŀŀ€\4[00GյYX GW3#ܸmNO+9KJ4Z.lWw`!D^˜0p$dגumTx~&Y?b Y juXoKmtzWdo¶AX,hid/B[)wQo!@&RB7M ̶@muc 0^nhɍfn]Ͽ70Q%nbm0qU֒Tګ3tZYgULҎqѭifYW]qP{h囌囏 ^Z+/_V`jjʺjM}f><<-zf]UѰu"CJ|0oeLNZD:!H(ӓuL:|AOx\^= 47.%Ut÷yh4V dm%ql\oz8v(˿rl&'J#m#'iG/ecK`LLmmB`<{n 255% I:$(dSV ǁu&/? ,뻾 ph"Sh)Lԑ7w:|u?$B`IENDB`boats-201307/images/player_play.png000066400000000000000000000023571217277220500172300ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs ?@"tIME $*[S|IDATxڅoEc--",b@݊?QS&1~Ż (rM/#PԊ *n}5Ŗ5Nr2̙'sr+bTZ'AVsrWފ A"![FGIsy}8'&w8a}ԑJfddow==5V_ *W 6.Yeqǂ'&w J4kZ媁Z\BSK fL?{Z;nGo>eOn?RГ1ٷâvQMYJ <>sY֐mIPw^b /PxFkM%rP`^;$ݙpBJE3hAxq 4@ܷ"!&3mm#|N^LM3hq{`}3P؆00E f22qrf͇_.Q-GLeqIjtHEe !d'-h+)< u[a > ;'$2JZ]Vx泔Bt;ni1_]I!4 Ub\Im?2CIt-ԣx+~@#6ZGWXi:LUH$1uۭ=fjf\XNtG7Ʋm0sՆ9.ŦmI.߬cbY,T̕܉ќ,\ljBE0j_[TĔ)@ť:YVT*эhq?ȈRS{8Gր/0FT*4oţ +9* Q()tIU;2PՌeAnZEIENDB`boats-201307/images/player_stop.png000066400000000000000000000021421217277220500172400ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs mtIME  yAIDATxڝۏSE?3ҞnO^,٘B$ QLi ONB|AL4&BE,ݬ-K9gƇ˂o.7CT80m^ *)ЀЪl)rAkCہ="#TBEG )Lo>7=ʮȵIF8V̥Z+ܜ5@E)Kd>r agvn}m.ЬZ?U ͈c?]%TgcpL?Mg2}xEs %R01ټb=wU(Jz ۶ ֮mIz㞢*Fk! 7e?oÝ3uX,H~婡#v*`%z90|kSѝyo3_7 '-ޓHf lbh4ЏThwb,[wWџM`55Y%%y}c?H$-q_&C+z绲 q ayH!)+RH)V4{!@&pNc1\Gktx94An{ЊKH5ĝQD2pVcdtAZei)Lӭ)˼R%ی2\7@qN˭tG*!!RQi:ɓ_}ԙhf}n S'}S4iPwcO@(J;!(oxl aͻۤ}'\j19;3 VѨrMlKb_ oܠ񘒹R]~sfyx'Љx8܄0I\ҋwroI)9 z![Oaݡ"z"0.SuX.azX& '{w N ONT; v !lm XMhDkwǞD\;~D#8`@B TiKqվz]UV dPHA`|2 7aHP@jt4ّHD) lVAF97P/bhM ef ~T?;FU*WtTX$EETP_eM\b֕Rp;Q JFIxG.\.P2U8~] o+>S&"}`H~XȤحmSqip؃dp<Iԕ ZyAUg# yH6O~[;4"WZ_^F'+=Lļ/x=t}qjck*u_ы/ 546U}6! u+#NN3u BGM5:ڵ<@b.$>^<,M& xGkģ݀vlJ)LD+5.`5~c;Owr'o0m3uOnP|IENDB`boats-201307/images/tab_remove.png000066400000000000000000000011501217277220500170200ustar00rootroot00000000000000PNG  IHDRabKGD pHYsvv}ՂtIME '4b"IDATxڥOhA$nL۔VӸ J#xAםi23%IK$\t]Sm1u3@P("+.K ,FŎmf__K '## gغ鯽Kt}DM`+!kϿtw0 p҄v=BH-c ;Ap[+hfٹ۠%\q}nb"tЍP(ts[XI! ZEcGGPUAC/-y4:|HF,L[ Mᴆ׿ O C,֪<=~AE>1R_ժE.ӷgN?>rrq=si.e9MQVe cI8IENDB`boats-201307/images/undo.png000066400000000000000000000023041217277220500156440ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYsvv}ՂtEXtSoftwarewww.inkscape.org<AIDATxڵIh]Usy3uږmmH-B[\R.ąƅ.Vp,hmBC^p{NT|p;?*wuKbG:.qd2A}GGR-J6hZ.e#T.Rb7&Fv3n|LG hhK\qg/Nn v+% %PMDSŸ>5"oA)BC4uaΝ l*A[vT "(% k:/#PQ\zV`|Imh"ճeak({bÖ}7X ԬόR:CBK9Cq) kJ$ WVh#Qb!r وlahWCW;6IW Tp[Y0p"c<7n) d}:|8 #9G+qռR'x[e͎=EX'LFib2_/EJZI fM#sqp476fNc&BJA*'CG- Ȃ$qY [Z[JvWámK';"aUGp&DU*l| aUO r[ :EM7n'AA!ʵۋ~>p#2FZARyUxRX=9An~"@IئtuͼV*s[٤tdl0?.ԁOmGG yIENDB`boats-201307/images/video.png000066400000000000000000000023621217277220500160110ustar00rootroot00000000000000PNG  IHDRĴl;sRGB pHYs cytIME $0bKGDrIDATxڥLuϏ;C…du6ZVdӨemVW[8MkZˁ9t`fpp<>߻cQk}o}~>s'[9ms/tww[s~c~6³jƿjz_tyza>tMs8Ҥ^˲Mٍ{FB*"HԶ;5Mтcǎn!lvnx:;s}zFy|9r;% s/qܳ7lqv.RIR#;;~Uon>䯪r_\~ӧyyXG"Y=mT]^BlƊSߜ `4C?/+kg:bPOO/ C'q㢽^{IVY'^ZeժlZQT)Guu(~ttz555Uݥޛtj6}[RRR*W,$QW4& `$L0 5 I|$uMuhzDO2nEzzS IZ.`9i6x7<;Wz5 Nwa7Ux#STlLLD8NN~v~A(y-֑ F߼ uC "xW%Q aYKAE!Ah(}l(]B9ܤRyQiQ?k۽?L#X:͢[|((Ǚ3d ūG(p?IXUĤ/hK(@(cťe[ttYQ*!c Œ=iXl %1Kl !,VscE?L%A,k:b9DPT|эp&f!28,YT6&IENDB`boats-201307/images/zone.png000066400000000000000000000012051217277220500156510ustar00rootroot00000000000000PNG  IHDRĴl;sBIT|d pHYstEXtSoftwarewww.inkscape.org<IDAT8OQObFIFo$i&)ʊdm[R llldjjAYPveDLcy=}fs='Eas9RJM؁u苈)7@D*i mx ڊ? {͸Rꊈɩ{r3Z Hd](Fߒ5zqC3q, GJOp6"O`ZpKWKs*d!z n9N^nFBsEQMUg lE j(zp$=x80ʆqx+3Bja3KD '}|]05(}$"vŋ,>6<DZK)Z0ku,_#b PV5u_ ^+߂{sFC6!+4F~MImwExԉߍyfIENDB`boats-201307/images/zoomfit.png000066400000000000000000000012611217277220500163670ustar00rootroot00000000000000PNG  IHDRĴl;sRGBbKGD pHYs cytIME w1IDATxڵoPV XXE SFb+kFP3,H€ZCZGrAvEH|OqW|v>RE&Ѭ:ɜ\U3 \.Ȳ4_P(yG)5aR38=xۅzh@Zinx:|\~zX}lE`\@hTJ\1#k*~:\s釵x -JHN໵h i?GbK2b ^S AiMO f?)^ 8$PW/~"VXqf0ׁÃClNR~g5=iBR8]hZ.[Q'Ɔv`J,a^p8hQv:m'./uhw>Ih{ `MLBbL*pM3teM3,\]}o*hU;gaRnS"̈oGIENDB`boats-201307/images/zoomin.png000066400000000000000000000022471217277220500162200ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs cytIME ({O4IDATxڵ_L[U0n-mdtpfMfH&dfK|$A3 &S7l#۔ ʟB<{0!|_N_=s^GFFl-H ALW_0ǒٳSHʂ $:VZp ޜ._&]7yW,[j^R$&wU ⍳ \278 x7gM8Jyzą*"8hN2̪㨡Ϡ}|xÁ8#LrfDI'(T1DZ"$P^5yCYFq.p/ IH̐$"(Oms>fZ.S|';l \KCc=gT#-J91P((հ|AUG H.G\^4 `FX$Z YA}ǧFwV{G￝d^9f @匒*do^YIGi>R e2X1 ~"i{]v2J|AZ ues䉓#eY\XX( Q|>;5R^L5ۖ<]/g~ʧD"W <n::dYYӹ=.]kj(*Bt:---7 Xs@MQzx7㿞*@)1qؼrLpiXm2~r{rrrHD"mAן UN{r->,?h4 ;pjS)3qܦH69@``q0 _D"QBvFնz?%_a2  nIENDB`boats-201307/images/zoomout.png000066400000000000000000000022251217277220500164150ustar00rootroot00000000000000PNG  IHDRĴl;bKGD pHYs cytIME 2:"IDATxڵ_L[UϹz{oKKK٤0 8 523 |%cdMͶɡl&&:`>HT {$>u'|;9tww۽^)e$RUuSt_[{Z̲,zZ? Au M+> P$޺U \ -|}XǬYxC3~]OD _B۷?f*J+ǁAWg1ɗ- V]S@(-L;w8? e6J)oijPܾibSssˍ/Ved:2Hbg4->Zdj<Ѩ$1v»5Fke_ 1 N4>6q":ܾ 9#sv~M{IHqzvT4ѫon @| EM%@tG6Ĺb7EyӉ1 SVƐ2h'4 5r Aɚci'6)%4Ps9̈́h%1لyS27FSNv"B$ĽC-~$(iN@dE bESTq86<22V,ՙٙ&-mM"m8KBPS4eSEoi~oO>1>.Xj!wԒ$4!DIqMyYęlQQ`(ZM  w< H e[ۙLz*k|}ed䅌3eee(ޅ㸭PhWvvLACpd%¿,m6[r$Rr``naaabee< L#FF(yyyxKKKwGGs?f$i3"A{]Áb"jk~=0;;gWnX):U TW+rsllL$ ].)pqq!e=ђQ@ 4M =̆`0xcmmb\ς 0tFFc2IENDB`boats-201307/itemviews/000077500000000000000000000000001217277220500147415ustar00rootroot00000000000000boats-201307/itemviews/colorpickerwidget.cpp000066400000000000000000000026651217277220500211760ustar00rootroot00000000000000// // C++ Implementation: colorpickerwidget // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #include #include "colorpickerwidget.h" #include "commontypes.h" extern int debugLevel; ColorPickerWidget::ColorPickerWidget(QWidget *parent) : QWidget(parent) { } void ColorPickerWidget::setColor(QColor color) { if (color != m_color) { m_color = color; QColorDialog::setCustomColor(0, color.rgb()); pick(); } } void ColorPickerWidget::pick() { if (debugLevel & 1 << DELEGATE) std::cout << "pick" << std::endl; // get the new color from dialog QColor newColor(QColorDialog::getColor(m_color)); if (newColor.isValid()) { m_color = newColor; } emit editingFinished(); } boats-201307/itemviews/colorpickerwidget.h000066400000000000000000000023251217277220500206340ustar00rootroot00000000000000// // C++ Interface: colorpickerwidget // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #ifndef COLORPICKERWIDGET_H #define COLORPICKERWIDGET_H #include class ColorPickerWidget : public QWidget { Q_OBJECT public: ColorPickerWidget(QWidget *parent = 0); ~ColorPickerWidget() {} void setColor(QColor color); const QColor color() const { return m_color; } signals: void editingFinished(); private: void pick(); QColor m_color; }; #endif boats-201307/itemviews/itemviews.pri000066400000000000000000000005601217277220500174720ustar00rootroot00000000000000INCLUDEPATH += $$PWD DEPENDPATH += $$PWD HEADERS += \ $$PWD/colorpickerwidget.h \ $$PWD/trackdelegate.h \ $$PWD/tracktablemodel.h \ $$PWD/winddelegate.h \ $$PWD/windtablemodel.h SOURCES += \ $$PWD/colorpickerwidget.cpp \ $$PWD/trackdelegate.cpp \ $$PWD/tracktablemodel.cpp \ $$PWD/winddelegate.cpp \ $$PWD/windtablemodel.cpp boats-201307/itemviews/trackdelegate.cpp000066400000000000000000000126001217277220500202430ustar00rootroot00000000000000// // C++ Implementation: trackdelegate // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #include #include "trackdelegate.h" #include "colorpickerwidget.h" #include "commontypes.h" #include "boats.h" extern int debugLevel; void TrackDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const { painter->save(); drawBackground(painter, option, index); switch (index.column()) { case TRACK_COLOR: { QColor trackColor = qVariantValue(index.data()); painter->setPen(Qt::NoPen); painter->setBrush(trackColor); qreal height = option.rect.height() / 8.0; qreal width = option.rect.width() / 8.0; QRectF rect(option.rect); rect.adjust(width, height, -width, -height); painter->drawRoundedRect(rect, width, height); } break; case TRACK_SERIES: { int series = qVariantValue(index.data()); drawDisplay(painter, option, option.rect, Boats::seriesList().at(series)); } break; default: QItemDelegate::paint(painter, option, index); break; } drawFocus(painter, option, option.rect); painter->restore(); } QSize TrackDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const { return QItemDelegate::sizeHint(option, index); } QWidget * TrackDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const { if (debugLevel & 1 << DELEGATE) std::cout << "createEditor " << index.column() << std::endl; switch (index.column()) { case TRACK_COLOR: { ColorPickerWidget *editor = new ColorPickerWidget(parent); connect(editor, SIGNAL(editingFinished()), this, SLOT(commitAndCloseColor()), Qt::QueuedConnection); return editor; } break; case TRACK_SERIES: { QComboBox *editor = new QComboBox(parent); editor->addItems(Boats::seriesList()); connect(editor, SIGNAL(activated(int)), this, SLOT(commitAndCloseCombo())); return editor; } break; default: return 0; break; } } void TrackDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const { if (debugLevel & 1 << DELEGATE) std::cout << "setEditorData " << index.column() << std::endl; switch (index.column()) { case TRACK_COLOR: { ColorPickerWidget *colorEditor = getColorEditor(editor); QColor color = qVariantValue(index.data()); colorEditor->setColor(color); } break; case TRACK_SERIES: { QComboBox *seriesEditor = getComboEditor(editor); int series = qVariantValue(index.data()); seriesEditor->setCurrentIndex(series); } break; default: QItemDelegate::setEditorData(editor, index); break; } } void TrackDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const { if (debugLevel & 1 << DELEGATE) std::cout << "setModelData " << index.column() << std::endl; switch (index.column()) { case TRACK_COLOR: { ColorPickerWidget *colorEditor = getColorEditor(editor); QColor color = colorEditor->color(); model->setData(index, qVariantFromValue(color)); } break; case TRACK_SERIES: { QComboBox *seriesEditor = getComboEditor(editor); int series = seriesEditor->currentIndex(); model->setData(index, qVariantFromValue(series)); } break; default: QItemDelegate::setModelData(editor, model, index); break; } } void TrackDelegate::commitAndCloseColor() { if (debugLevel & 1 << DELEGATE) std::cout << "commitAndCloseColor" << std::endl; ColorPickerWidget *colorEditor = getColorEditor(sender()); emit commitData(colorEditor); emit closeEditor(colorEditor); } void TrackDelegate::commitAndCloseCombo() { if (debugLevel & 1 << DELEGATE) std::cout << "commitAndCloseCombo" << std::endl; QComboBox *pathEditor = getComboEditor(sender()); emit commitData(pathEditor); emit closeEditor(pathEditor); } ColorPickerWidget * TrackDelegate::getColorEditor(QObject *editor) const { return qobject_cast(editor); } QComboBox * TrackDelegate::getComboEditor(QObject *editor) const { return qobject_cast(editor); } boats-201307/itemviews/trackdelegate.h000066400000000000000000000034311217277220500177120ustar00rootroot00000000000000// // C++ Interface: trackdelegate // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #ifndef TRACKDELEGATE_H #define TRACKDELEGATE_H #include class ColorPickerWidget; class TrackDelegate : public QItemDelegate { Q_OBJECT public: TrackDelegate(QWidget *parent = 0) : QItemDelegate(parent) {} void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const; QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const; QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const; void setEditorData(QWidget *editor, const QModelIndex &index) const; void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const; private slots: void commitAndCloseColor(); void commitAndCloseCombo(); private: ColorPickerWidget * getColorEditor(QObject *editor) const; QComboBox * getComboEditor(QObject *editor) const; }; #endif boats-201307/itemviews/tracktablemodel.cpp000066400000000000000000000153561217277220500206140ustar00rootroot00000000000000// // C++ Implementation: tracktablemodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #include #include "tracktablemodel.h" #include "commontypes.h" #include "boats.h" #include "situationmodel.h" #include "trackmodel.h" #include "undocommands.h" extern int debugLevel; TrackTableModel::TrackTableModel(SituationModel *situation, QObject *parent) : QAbstractTableModel(parent), m_situation(situation) { if (debugLevel & 1 << MODEL) std::cout << "new tracktable " << this << std::endl; } TrackTableModel::~TrackTableModel() { if (debugLevel & 1 << MODEL) std::cout << "end tracktable " << this << std::endl; } void TrackTableModel::setSituation(SituationModel *situation) { if (m_situation != situation) { m_situation = situation; reset(); } } QVariant TrackTableModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) return QVariant(); if (index.row() >= m_situation->size() || index.row() < 0) return QVariant(); if (role == Qt::DisplayRole) { switch (index.column()) { case TRACK_COLOR: return m_situation->tracks()[index.row()]->color(); break; case TRACK_SERIES: return m_situation->tracks()[index.row()]->series(); break; default: return QVariant(); break; } } else if (role == Qt::CheckStateRole) { switch (index.column()) { case TRACK_PATH: if (m_situation->tracks()[index.row()]->showPath()) { return Qt::Checked; } return Qt::Unchecked; break; case TRACK_FOLLOW: if (m_situation->tracks()[index.row()]->followTrack()) { return Qt::Checked; } return Qt::Unchecked; break; default: return QVariant(); break; } } return QVariant(); } QVariant TrackTableModel::headerData(int section, Qt::Orientation orientation, int role) const { if (role != Qt::DisplayRole) return QVariant(); if (orientation == Qt::Horizontal) { switch (section) { case TRACK_COLOR: return tr("Color"); case TRACK_PATH: return tr("Path"); case TRACK_SERIES: return tr("Series"); case TRACK_FOLLOW: return tr("Follow"); default: return QVariant(); } } return QVariant(); } Qt::ItemFlags TrackTableModel::flags(const QModelIndex &index) const { Q_UNUSED(index); return Qt::ItemIsEnabled|Qt::ItemIsEditable|Qt::ItemIsUserCheckable; } bool TrackTableModel::setData(const QModelIndex &index, const QVariant &value, int role) { Q_UNUSED(role); if (!index.isValid()) return false; if (index.row() >= m_situation->size() || index.row() < 0) return false; switch (index.column()) { case TRACK_COLOR: if (qVariantCanConvert(value)) { QColor newValue = qVariantValue(value); TrackModel *track = m_situation->tracks()[index.row()]; if (newValue != track->color()) { m_situation->undoStack()->push(new SetColorUndoCommand(track, newValue)); } return true; } break; case TRACK_PATH: if (value.isValid()) { bool newValue = (static_cast(value.toInt()) == Qt::Checked); TrackModel *track = m_situation->tracks()[index.row()]; if (newValue != track->showPath()) { m_situation->undoStack()->push(new SetShowPathUndoCommand(track)); } return true; } break; case TRACK_SERIES: if (qVariantCanConvert(value)) { int newValue = qVariantValue(value); if (newValue >= 0 && newValue < Boats::unknown) { Boats::Series seriesValue = (Boats::Series)newValue; TrackModel *track = m_situation->tracks()[index.row()]; if (seriesValue != track->series()) { m_situation->undoStack()->push(new SetSeriesUndoCommand(track, seriesValue)); } return true; } } break; case TRACK_FOLLOW: if (value.isValid()) { bool newValue = (static_cast(value.toInt()) == Qt::Checked); TrackModel *track = m_situation->tracks()[index.row()]; if (newValue != track->followTrack()) { m_situation->undoStack()->push(new SetFollowTrackUndoCommand(track->situation(), track)); } return true; } break; default: return false; break; } return false; } void TrackTableModel::addTrack(TrackModel *track) { int order = track->order(); connect(track, SIGNAL(colorChanged(QColor)), this, SLOT(updateTrack())); connect(track, SIGNAL(seriesChanged(Boats::Series)), this, SLOT(updateTrack())); connect(track, SIGNAL(showPathChanged(bool)), this, SLOT(updateTrack())); connect(track, SIGNAL(followTrackChanged(bool)), this, SLOT(updateTrack())); beginInsertRows(QModelIndex(), order, order); endInsertRows(); } void TrackTableModel::updateTrack() { TrackModel *track = (TrackModel*) sender(); int order = track->order(); for (int i = TRACK_COLOR; i <= TRACK_FOLLOW; i++) { QModelIndex ind = index(i, order); emit dataChanged(ind, ind); } } void TrackTableModel::deleteTrack(TrackModel *track) { int order = track->order(); disconnect(track,0,this,0); beginRemoveRows(QModelIndex(), order, order); endRemoveRows(); } boats-201307/itemviews/tracktablemodel.h000066400000000000000000000035371217277220500202570ustar00rootroot00000000000000// // C++ Interface: tracktablemodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #ifndef TRACKTABLEMODEL_H #define TRACKTABLEMODEL_H #include #include "commontypes.h" #include "situationmodel.h" class TrackModel; class TrackTableModel : public QAbstractTableModel { Q_OBJECT public: TrackTableModel(SituationModel* situation = 0, QObject *parent = 0); ~TrackTableModel(); void setSituation(SituationModel *situation); int rowCount(const QModelIndex &parent) const { Q_UNUSED(parent); return m_situation->size(); } int columnCount(const QModelIndex &parent) const { Q_UNUSED(parent); return 4;} QVariant data(const QModelIndex &index, int role) const; QVariant headerData(int section, Qt::Orientation orientation, int role) const; Qt::ItemFlags flags(const QModelIndex &index) const; bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole); public slots: void addTrack(TrackModel *track); void updateTrack(); void deleteTrack(TrackModel *track); private: SituationModel *m_situation; }; #endif boats-201307/itemviews/winddelegate.cpp000066400000000000000000000040631217277220500201040ustar00rootroot00000000000000// // C++ Implementation: winddelegate // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include "winddelegate.h" #include "commontypes.h" #include "boats.h" extern int debugLevel; QWidget * WindDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const { if (debugLevel & 1 << DELEGATE) std::cout << "createEditor " << index.column() << std::endl; switch (index.column()) { case WIND_DIRECTION: { QDoubleSpinBox *editor = new QDoubleSpinBox(parent); editor->setMinimum(0); editor->setMaximum(359); editor->setDecimals(0); editor->setWrapping(true); return editor; } break; default: return 0; break; } } void WindDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const { if (debugLevel & 1 << DELEGATE) std::cout << "setEditorData " << index.column() << std::endl; switch (index.column()) { case WIND_DIRECTION: { QDoubleSpinBox *spin = static_cast(editor); spin->setValue(qVariantValue(index.data())); } break; default: QItemDelegate::setEditorData(editor, index); break; } } boats-201307/itemviews/winddelegate.h000066400000000000000000000023211217277220500175440ustar00rootroot00000000000000// // C++ Interface: winddelegate // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef WINDDELEGATE_H #define WINDDELEGATE_H #include class WindDelegate : public QItemDelegate { Q_OBJECT public: WindDelegate(QWidget *parent = 0) : QItemDelegate(parent) {} QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const; void setEditorData(QWidget *editor, const QModelIndex &index) const; }; #endif boats-201307/itemviews/windtablemodel.cpp000066400000000000000000000105131217277220500204370ustar00rootroot00000000000000// // C++ Implementation: windtablemodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include "windtablemodel.h" #include "commontypes.h" #include "situationmodel.h" #include "windmodel.h" #include "undocommands.h" extern int debugLevel; WindTableModel::WindTableModel(WindModel *wind, QObject *parent) : QAbstractTableModel(parent), m_wind(wind) { if (debugLevel & 1 << MODEL) std::cout << "new windtable " << this << std::endl; } WindTableModel::~WindTableModel() { if (debugLevel & 1 << MODEL) std::cout << "end windtable " << this << std::endl; } void WindTableModel::setWind(WindModel *wind) { if (m_wind != wind) { m_wind = wind; reset(); } } QVariant WindTableModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) return QVariant(); if (index.row() >= m_wind->size() || index.row() < 0) return QVariant(); if (role == Qt::DisplayRole) { switch (index.column()) { case WIND_INDEX: return index.row()+1; break; case WIND_DIRECTION: return m_wind->windAt(index.row()); break; default: return QVariant(); break; } } else if (role == Qt::CheckStateRole) { switch (index.column()) { case WIND_DELETE: return false; break; default: return QVariant(); break; } } return QVariant(); } QVariant WindTableModel::headerData(int section, Qt::Orientation orientation, int role) const { if (role != Qt::DisplayRole) return QVariant(); if (orientation == Qt::Horizontal) { switch (section) { case WIND_INDEX: return tr("Index"); case WIND_DIRECTION: return tr("Direction"); case WIND_DELETE: return tr("Delete"); default: return QVariant(); } } return QVariant(); } Qt::ItemFlags WindTableModel::flags(const QModelIndex &index) const { Q_UNUSED(index); return Qt::ItemIsEnabled|Qt::ItemIsEditable|Qt::ItemIsUserCheckable; } bool WindTableModel::setData(const QModelIndex &index, const QVariant &value, int role) { Q_UNUSED(role); if (!index.isValid()) return false; if (index.row() > m_wind->size() || index.row() < 0) return false; switch (index.column()) { case WIND_DIRECTION: if (qVariantCanConvert(value)) { qreal newValue = qVariantValue(value); if (debugLevel & 1 << MODEL) std::cout << "setting wind " << newValue; if (index.row() == m_wind->size()) { m_wind->situation()->undoStack()->push(new AddWindUndoCommand(m_wind, newValue)); } else { if (newValue != m_wind->windAt(index.row())) { m_wind->situation()->undoStack()->push(new SetWindUndoCommand(m_wind, index.row(), newValue)); } } return true; } break; case WIND_DELETE: if (debugLevel & 1 << MODEL) std::cout << "deleting index " << index.row(); if (index.row() < m_wind->size()) { m_wind->situation()->undoStack()->push(new DeleteWindUndoCommand(m_wind, index.row())); } return true; break; default: return false; break; } return false; } void WindTableModel::updateWind() { reset(); } boats-201307/itemviews/windtablemodel.h000066400000000000000000000032771217277220500201150ustar00rootroot00000000000000// // C++ Interface: windtablemodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef WINDTABLEMODEL_H #define WINDTABLEMODEL_H #include #include "commontypes.h" #include "windmodel.h" class WindTableModel : public QAbstractTableModel { Q_OBJECT public: WindTableModel(WindModel* wind = 0, QObject *parent = 0); ~WindTableModel(); void setWind(WindModel *wind); int rowCount(const QModelIndex &parent) const { Q_UNUSED(parent); return m_wind->size()+1; } int columnCount(const QModelIndex &parent) const { Q_UNUSED(parent); return 3;} QVariant data(const QModelIndex &index, int role) const; QVariant headerData(int section, Qt::Orientation orientation, int role) const; Qt::ItemFlags flags(const QModelIndex &index) const; bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole); public slots: void updateWind(); private: WindModel *m_wind; }; #endif boats-201307/locale/000077500000000000000000000000001217277220500141645ustar00rootroot00000000000000boats-201307/locale/boats.ts000066400000000000000000000500631217277220500156500ustar00rootroot00000000000000 MainWindow &New File Ctrl+N &Open File... Ctrl+O &Save File Ctrl+S Save &As... Ctrl+Shift+S New &Tab Ctrl+T &Close Tab Ctrl+W &Restore Last Session... &Print... Print P&review... &Export Pdf... Ctrl+E Export &Image... Ctrl+I Export Ani&mation... Ctrl+V E&xit Ctrl+Q Exit the application Create &Track Ctrl+Ins Create &Boat Ins Create &Mark Alt+Ins &Port Overlap Alt+< &Starboard Overlap Alt+> &Text Alt+T Toggle Mark &Zone Delete Track Ctrl+Del &Delete Selection Del &Animate Ctrl+A &Play P &Pause M &Stop Space &Loop L &Undo Ctrl+Z &Redo Ctrl+Y Shift+Ctrl+Z Zoom &In Ctrl++ Zoom &Out Ctrl+- Zoom &Fit Ctrl+F Main Toolbar Animation Toolbar Scenario Dock &About Create Track Create Boat Create Mark Animate %1 - %2 [*] Boat Scenario &Recent &File &Edit &History &Animation &Zoom &View &%1 %2 The document %1 has been modified. Do you want to save your changes? Ctrl+P Ctrl+R &Flag &Help Choose &Language Open Scenario File xmlscenario Files (*.xbs) Cannot read file %1: %2. Open Scenario file Parse error in file %1 at line %2, column %3: %4 File loaded Save Scenario %1 already exists. Do you want to replace it? Cannot write file %1: %2. File saved Print Document Export Image Export Animation Exporting Animation... Abort Protest! About Boat Scenario Create Line Create &PolyLine Ctrl+Alt+Ins Create Poin&t Toggle &Spinnaker Alt+S Alt+Z &Hide Alt+D Trim Sail > Untrim Sail < Auto Trim = &Acceleration Toggle &Laylines Alt+L Set Mark &Color Alt+C Toggle &Mark Side Alt+M Toggle Mark Arro&w Alt+W Toggle Mark &Label &Edit Mark Label Alt+E Edit mark label Label text: QObject The file is not an xmlscenario version 1.0 file. Laser Optimist Tornado Committee boat RIB Spin Keelboat Gennaker Keelboat Topper Firefly 29er 49er 420 470 SituationPrint Rule SituationWidget Options Series Zone Length Tracks Scenario Title Rules Abstract Description Wind Show Wind Show Grid Layline Angle TrackTableModel Color Path Series Follow WindTableModel Index Direction Delete boats-201307/locale/boats_da.ts000066400000000000000000000464741217277220500163270ustar00rootroot00000000000000 MainWindow &New File &Ny fil Ctrl+N Ctrl+N &Open File... &Åbn fil... Ctrl+O Ctrl+O &Save File &Gem fil Ctrl+S Ctrl+S Save &As... Gem &som... Ctrl+Shift+S Ctrl+Shift+S New &Tab Nyt &faneblad Ctrl+T Ctrl+T &Close Tab &Luk faneblad Ctrl+W Ctrl+W &Restore Last Session... &Gendan sidste session... &Print... &Udskriv... Print P&review... &Vis udskrift... &Export Pdf... Eksporter &Pdf... Ctrl+E Ctrl+E Export &Image... Eksporter &billede... Ctrl+I Ctrl+I Export Ani&mation... Eksporter &Animation... Ctrl+V Ctrl+V E&xit Afsl&ut Ctrl+Q Ctrl+Q Exit the application Afslut programmet Create &Track Opret &Spor Ctrl+Ins Ctrl+Ins Create &Boat Opret &Båd Ins Ins Create &Mark Opret &mærke Alt+Ins Alt+Ins &Port Overlap &Bagbord overlap Alt+< Alt+< &Starboard Overlap &Styrbord overlap Alt+> Alt+> &Text &Tekst Alt+T Alt+T Toggle Mark &Zone Vis/skjul mærke&zone Delete Track Slet spor Ctrl+Del Ctrl+Del &Delete Selection Slet &markering Del Del &Animate &Animér Ctrl+A Ctrl+A &Play A&fspil P P &Pause &Pause M M &Stop &Stop Space Space &Loop &Løkke L L &Undo &Fortryd Ctrl+Z Ctrl+Z &Redo &Omgør Ctrl+Y Ctrl+Y Shift+Ctrl+Z Ctrl+Shift+Z Zoom &In Zoom &ind Ctrl++ Ctrl++ Zoom &Out Zoom &ud Ctrl+- Ctrl+- Zoom &Fit Zoo&m tilpas Ctrl+F Ctrl+F Main Toolbar Hovedværktøjslinje Animation Toolbar Værktøjslinjen Animation Scenario Dock Scenarie dock &About &Om Create Track Opret spor Create Boat Opret båd Create Mark Opret mærke Animate Animér %1 - %2 [*] %1 - %2 [*] Boat Scenario Bådsecnarie &Recent N&ylige &File &Fil &Edit &Redigér &History &Historie &Animation &Animation &Zoom &Zoom &View &Vis &%1 %2 &%1 %2 The document %1 has been modified. Do you want to save your changes? Dokumentet %1 er ændret.\n Vil du gemme ændringerne? Ctrl+P Ctrl+P Ctrl+R Ctrl+R &Flag &Flag &Help &Hjælp Choose &Language Væ&lg sprog Open Scenario File Åben senarie-fil xmlscenario Files (*.xbs) xmlscenario filer (*.xbs) Cannot read file %1: %2. Kan ikke læse filen %1: %2. Open Scenario file Åben secnarie-fil Parse error in file %1 at line %2, column %3: %4 Fortolkningsfejl i fil %1 linje %2, kolonne %3: %4 File loaded Fil indlæst Save Scenario Gem scenarie %1 already exists. Do you want to replace it? %1 findes allerede. Vil du overskrive den? Cannot write file %1: %2. Kan ikke skrive fil %1: %2. File saved Fil gemt Print Document Udskriv dokument Export Image Eksportér billede Export Animation Eksportér animation Exporting Animation... Eksporteter animation... Abort Afbryd Protest! Protest! About Boat Scenario Om Boat Scenario Create Line Opret linje Create &PolyLine Opret &polylinje Ctrl+Alt+Ins Ctrl+Alt+Ins Create Poin&t Opret punk&t Toggle &Spinnaker Vis/skjul &spiler Alt+S Alt+Z &Hide Skjul Alt+D Trim Sail Hal hjem < Auto Trim Automatisk skødning = Untrim Sail Slæk ud > &Acceleration Acceleration Toggle &Laylines Vis/skjul laylines Alt+L Set Mark &Color Alt+C Toggle &Mark Side Alt+M Toggle Mark Arro&w Alt+W Toggle Mark &Label &Edit Mark Label Alt+E Edit mark label Label text: QObject The file is not an xmlscenario version 1.0 file. Filen er ikke en xmlscenario version 1.0 fil. Laser Optimist Tornado Committee boat RIB Spin Keelboat Gennaker Keelboat Topper Firefly 29er 49er 420 470 SituationPrint Rule Regel SituationWidget Options Indstillinger Series Bådtype Zone Length Mærkexone længde Tracks Spor Scenario Situation Title Titel Rules Regler Abstract Opsummering Description Beskrivelse Wind Vind Show Wind Vis vind Show Grid Vis gitter Layline Angle Layline vinkel TrackTableModel Color Farve Path Spor Series Bådtype Follow WindTableModel Index Indeks Direction Retning Delete Slet boats-201307/locale/boats_de.ts000066400000000000000000000464621217277220500163300ustar00rootroot00000000000000 MainWindow &New File &Neu Ctrl+N Ctrl+N &Open File... &Öffnen... Ctrl+O Ctrl+O &Save File &Speichern Ctrl+S Ctrl+S Save &As... Speichern &unter... Ctrl+Shift+S Ctrl+Shift+S New &Tab Neuer &Tab Ctrl+T Ctrl+T &Close Tab Tab &schließen Ctrl+W Ctrl+W &Restore Last Session... Letzte &Sitzung wiederherstellen... &Print... &Drucken... Print P&review... Seiten&ansicht zeigen... &Export Pdf... &Exportieren als PDF... Ctrl+E Ctrl+E Export &Image... Exportieren als B&ild... Ctrl+I Ctrl+I Export Ani&mation... Exportieren als &Animation... Ctrl+V Ctrl+V E&xit &Beenden Ctrl+Q Ctrl+Q Exit the application Boat Scenario beenden Create &Track &Kurs erstellen Ctrl+Ins Ctrl+Ins Create &Boat &Boot erstellen Ins Ins Create &Mark Bahn&marke erstellen Alt+Ins Alt+Ins Create &PolyLine &PolyLinie estellen Ctrl+Alt+Ins Create Poin&t Pun&kt erstellen &Port Overlap Überlappung nach &Backbord Alt+< Alt+< &Starboard Overlap Überlappung nach &Steuerbord Alt+> Alt+> &Text Alt+T Toggle &Spinnaker &Spinnaker anzeigen Toggle Mark &Zone Bahnmarkenzone &anzeigen Delete Track Kurs löschen Ctrl+Del Ctrl+Del &Delete Selection &Auswahl löschen Del Del &Animate &Animation Ctrl+A Ctrl+A &Play &Play P P &Pause &Pause M M &Stop &Stop Space Space &Loop &Wiederholung L L &Undo &Rückgängig Ctrl+Z Ctrl+Z &Redo &Wiederherstellen Ctrl+Y Ctrl+Y Shift+Ctrl+Z Shift+Ctrl+Z Zoom &In Ansicht ver&größern Ctrl++ Ctrl++ Zoom &Out Ansicht ver&kleinern Ctrl+- Ctrl+- Zoom &Fit Ansicht an&passen Ctrl+F Ctrl+F Main Toolbar Hauptwerkzeugleiste Animation Toolbar Animationswerkzeugleiste Scenario Dock Scenarienbeschreibung &About &Über Create Track Kurs erstellen Create Boat Boot erstellen Create Mark Bahnmarke erstellen Animate Animieren %1 - %2 [*] %1 - %2 [*] Boat Scenario Boat Scenario &Recent &Zuletzt benutzt &File &Datei &Edit &Editieren &History &Historie &Animation &Animation &Zoom &View &Ansicht &%1 %2 &%1 %2 Create Line Linie erstellen The document %1 has been modified. Do you want to save your changes? Das Dokument %1 wurde verändert. Möchten Sie ihre Änderungen speichern? Ctrl+P Ctrl+R &Flag &Flagge &Help &Hilfe Choose &Language &Sprache wählen Open Scenario File Open Scenario File xmlscenario Files (*.xbs) xmlscenario Dateien (*.xbs) Cannot read file %1: %2. Kann Datei %1: %2 nicht lesen. Open Scenario file Open Scenario file Parse error in file %1 at line %2, column %3: %4 Analysiere Fehler in Datei %1, Zeile %2, Spalte %3: %4 File loaded Datei geladen Save Scenario Speichere Scenario %1 already exists. Do you want to replace it? %1 existiert bereits. Möchten Sie die Datei ersetzen? Cannot write file %1: %2. Kann Datei %1:%2 nicht schreiben. File saved Datei gespeichert Print Document Dokument drucken Export Image Bild exportieren Export Animation Animation exportieren Exporting Animation... Animation exportieren... Abort Abbruch Protest! About Boat Scenario Über Boat Scenario Alt+S Alt+Z &Hide Ausblenden Alt+D Trim Sail Segel dichtholen < Auto Trim Auto Segeltrimm = Untrim Sail Segel auffieren > &Acceleration Beschleunigung Toggle &Laylines Layline anzeigen Alt+L Set Mark &Color Bahnmarkenfarbe setzen Alt+C Toggle &Mark Side Bahnmarkenseite anzeigen Alt+M Toggle Mark Arro&w Bahnmarkenpfeil anzeigen Alt+W Toggle Mark &Label Bahnmarkenschriftung anzeigen &Edit Mark Label Bahnmarkenschriftung bearbeiten Alt+E Edit mark label Bahnmarkenschriftung bearbeiten Label text: Beschriftungstext QObject The file is not an xmlscenario version 1.0 file. Diese Datei ist keine xml-Scenario-Datei Version 1.0. Laser Optimist Tornado Committee boat WFL Boot RIB Schlauchboot Spin Keelboat Drehung Kielboot Gennaker Keelboat Gennacker Kielboot Topper Firefly 29er 49er 420 470 SituationPrint Rule Regel SituationWidget Options Optionen Series Serien Zone Length Größe der Zone Tracks Kurse Scenario Szenario Title Titel Rules Regeln Abstract Kurzbeschreibung Description Beschreibung Wind Wind Show Wind Windrichtung anzeigen Show Grid Raster einlenden Layline Angle Layline Winkel TrackTableModel Color Farbe Path Pfad Series Reihe Follow Folge WindTableModel Index Index Direction Richtung Delete löschen boats-201307/locale/boats_es.ts000066400000000000000000000464171217277220500163470ustar00rootroot00000000000000 MainWindow &New File &Nuevo archivo Ctrl+N &Open File... A&brir archivo... Ctrl+O Ctrl+B &Save File &Guardar archivo Ctrl+S Ctrl+G Save &As... Guardar &como... Ctrl+Shift+S Ctrl+Shift+C New &Tab Nueva &Solapa Ctrl+T Ctrl+S &Close Tab C&errar Solapa Ctrl+W Ctrl+E &Restore Last Session... &Restaurar la última sesión... &Print... &Imprimir... Print P&review... Vista P&revia... &Export Pdf... &Exportar a Pdf... Ctrl+E Export &Image... Exportar Ima&gen... Ctrl+I Ctrl+G Export Ani&mation... Exportar Ani&mación... Ctrl+V Ctrl+V E&xit Sa&lir Ctrl+Q Ctrl+Q Exit the application Salir de la aplicación Create &Track Crear &Trayectoria Ctrl+Ins Ctrl+Ins Create &Boat Crear &Barco Ins Create &Mark Crear &Baliza Alt+Ins Create &PolyLine Crear &PoliLinea Ctrl+Alt+Ins Create Poin&t Crear Pun&to &Port Overlap Comprometido por &Babor Alt+< &Starboard Overlap Comprometido por &Estribor Alt+> &Text &Texto Alt+T Toggle &Spinnaker Sacar &Spi Toggle Mark &Zone &Zona Alrededor de la Baliza Delete Track Eliminar Trayectoria Ctrl+Del &Delete Selection Elimina&r Selección Del &Animate &Animar Ctrl+A &Play &Iniciar P I &Pause &Pausa M P &Stop P&arar Space &Loop &Bucle L B &Undo D&eshacer Ctrl+Z &Redo &Rehacer Ctrl+Y Shift+Ctrl+Z Zoom &In A&cercar Ctrl++ Zoom &Out Ale&jar Ctrl+- Zoom &Fit Aj&ustar Ctrl+F Ctrl+U Main Toolbar Barra Principal Animation Toolbar Barra de Animación Scenario Dock Control de Escenario &About &Acerca de Create Track Crear Trayectoria Create Boat Crear Barco Create Mark Crear Baliza Animate Animar %1 - %2 [*] Boat Scenario &Recent &Reciente &File &Archivo &Edit &Editar &History &Historial &Animation &Animación &Zoom &Zoom &View &Ver &%1 %2 Create Line Crear Linea The document %1 has been modified. Do you want to save your changes? El archivo %1 fué modificado. ¿Quiere guardar sus cambios? Ctrl+P Ctrl+R &Flag &Bandera &Help &Ayuda Choose &Language &Escoge idioma Open Scenario File Abrir Archivo de Escenario xmlscenario Files (*.xbs) Archivos xmlscenario (*.xbs) Cannot read file %1: %2. No puedo leer el archivo %1: %2. Open Scenario file Abrir Archivo de Escenario Parse error in file %1 at line %2, column %3: %4 Analizar error en el archivo %1 en la linea %2, columna %3: %4 File loaded Archivo cargado Save Scenario Guardar Escenario %1 already exists. Do you want to replace it? %1 ya existe. ¿Quiere reemplazarlo? Cannot write file %1: %2. No puedo escribir el archivo %1: %2. File saved Archivo guardado Print Document Imprimir Archivo Export Image Exportar Imagen Export Animation Exportar Animación Exporting Animation... Exportando animación... Abort Abortar Protest! Protesto! About Boat Scenario Acerca de Boat Scenario Alt+S Alt+Z &Hide Esconder Alt+D Trim Sail Cazar < Auto Trim Auto Trimado = Untrim Sail Amollar > &Acceleration Aceleración Toggle &Laylines Mostrar laylines Alt+L Set Mark &Color Alt+C Toggle &Mark Side Alt+M Toggle Mark Arro&w Alt+W Toggle Mark &Label &Edit Mark Label Alt+E Edit mark label Label text: QObject The file is not an xmlscenario version 1.0 file. El archivo no es un archivo xmlscenario versión 1.0. Laser Optimist Tornado Committee boat RIB Spin Keelboat Gennaker Keelboat Topper Firefly 29er 49er 420 470 SituationPrint Rule Regla SituationWidget Options Opciones Series Series Zone Length Zona en Esloras Tracks Trayectorias Scenario Escenario Title Título Rules Reglas Abstract Resumen Description Descripción Wind Viento Show Wind Mostrar Viento Show Grid Mostrar Cuadrícula Layline Angle Ángulo del Layline TrackTableModel Color Color Path Ruta Series Series Follow WindTableModel Index Listado Direction Dirección Delete Borrar boats-201307/locale/boats_fr.ts000066400000000000000000000461351217277220500163440ustar00rootroot00000000000000 MainWindow &New File &Nouveau Ctrl+N &Open File... &Ouvrir... Ctrl+O &Save File &Enregistrer Ctrl+S Save &As... Enregistrer &sous... Ctrl+Shift+S Export &Image... Exporter &Image... Ctrl+E E&xit &Quitter Ctrl+Q Exit the application Quitter le programme Create &Track Ajouter un &Bateau Ctrl+Ins Create &Boat Ajouter une &Position Ins Create &Mark Ajouter une &Marque Alt+Ins Delete Track Supprimer un Bateau Ctrl+Del &Delete Selection &Supprimer la Sélection Del &Animate &Animer Ctrl+A &Play &Lire P &Pause &Pause M &Stop &Stop Space &Loop &Boucle L &Undo &Annuler Ctrl+Z &Redo &Refaire Ctrl+Y Shift+Ctrl+Z &About &A Propos Create Track Ajouter un Bateau Create Boat Ajouter une Position Create Mark Ajouter une Marque Animate Animer &File &Fichier &Edit &Edition &History &Historique &Animation &Animation Open Scenario File Ouvrir un fichier Scénario xmlscenario Files (*.xbs) Fichiers xmlscenario (*.xbs) Cannot read file %1: %2. Ne peut pas lire le Fichier %1: %2. Open Scenario file Ouvrir un fichier Scénario Parse error in file %1 at line %2, column %3: %4 Erreur dans le fichier %1 ligne %2, colonne %3: %4 File loaded Fichier chargé Save Scenario Sauvegarder un Scénario Cannot write file %1: %2. Ne peut pas écrire le fichier %1: %2. File saved Fichier sauvegardé Export Image Exporter une Image %1 - %2 [*] Boat Scenario About Boat Scenario A propos de Boat Scenario Zoom &In Zoom A&vant Ctrl++ Zoom &Out Zoom A&rrière Ctrl+- Zoom &Fit Zoom &Cadrage Ctrl+F &Zoom &Zoom Toggle Mark &Zone &Zone à la marque New &Tab Nouvel &Onglet Ctrl+T &Close Tab &Fermer Onglet Ctrl+W &Print... &Imprimer... Print P&review... &Apercu avant Impression... &Export Pdf... &Exporter Pdf... Ctrl+I Export Ani&mation... Exporter Ani&mation... Ctrl+V &Port Overlap Engagement à &Bâbord Alt+< &Starboard Overlap Engagement à &Tribord Alt+> Main Toolbar Barre d'Outils Animation Toolbar Barre d'Animation Scenario Dock Paramètres du Scénario &Recent &Récent &View &Vues &%1 %2 Print Document Imprimer le Document Export Animation Exporter l'Animation The document %1 has been modified. Do you want to save your changes? Le document %1 a été modifié. Voulez-vous sauver vos modifications? Exporting Animation... Export de l'animation... Abort Annuler &Restore Last Session... &Restaurer la Session précédente... %1 already exists. Do you want to replace it? %1 existe déja. Voulez-vous le remplacer? Ctrl+P Ctrl+R &Text &Texte Alt+T &Flag &Pavillon &Help &Aide Choose &Language Choisir &Langue Protest! Create Line Ajouter une Ligne Create &PolyLine Ajouter une &Polyligne Ctrl+Alt+Ins Create Poin&t Ajouter un Poin&t Toggle &Spinnaker &Spinnaker Alt+S Alt+Z &Hide &Masquer Alt+D Trim Sail Border la Voile < Auto Trim Réglage Auto = Untrim Sail Choquer la Voile > &Acceleration &Accélération Toggle &Laylines Afficher les Laylines Alt+L Set Mark &Color Changer la &Couleur de la Marque Alt+C Toggle &Mark Side &Sens de la Marque Alt+M Toggle Mark Arro&w &Fleche de la marque Alt+W Toggle Mark &Label &Nom de la Marque &Edit Mark Label &Editer la Marque Alt+E Edit mark label Editer la Marque Label text: Nom de la Marque QObject The file is not an xmlscenario version 1.0 file. Le fichier n'est pas un fichier xmlscenario version 1.0. Laser Optimist Tornado Committee boat Bateau Comité RIB Semi-Rigide Spin Keelboat Quillard avec Spi Gennaker Keelboat Quillard avec Gennaker Topper Firefly 29er 49er 420 470 SituationPrint Rule Règle SituationWidget Scenario Scénario Title Titre Rules Règles Series Séries Description Description Abstract Abstract Zone Length Taille de Zone Tracks Pistes Options Wind Vent Show Wind Afficher le Vent Show Grid Afficher la Grille Layline Angle Angle des Laylines TrackTableModel Color Couleur Series Séries Path Chemin Follow Suivre WindTableModel Index Index Direction Direction Delete Supprimer boats-201307/locale/boats_it.ts000066400000000000000000000461511217277220500163470ustar00rootroot00000000000000 MainWindow &New File &Nuovo file Ctrl+N Ctrl+N &Open File... A&pri file... Ctrl+O Ctrl+B &Save File &Salva file Ctrl+S Ctrl+G Save &As... Salva &come... Ctrl+Shift+S Ctrl+Shift+C New &Tab Nuova &Etichetta Ctrl+T Ctrl+S &Close Tab C&hiudi etichetta Ctrl+W Ctrl+E &Restore Last Session... &Ripristina ultima sessione... &Print... &Stampa... Print P&review... Anteprima di S&tampa... &Export Pdf... &Esporta Pdf... Ctrl+E Ctrl+E Export &Image... Esporta Imma&gine... Ctrl+I Ctrl+G Export Ani&mation... Esporta Ani&mazione... Ctrl+V Ctrl+V E&xit Es&ci Ctrl+Q Ctrl+Q Exit the application Esci dall'aplicazione Create &Track Crea &Traccia Ctrl+Ins Ctrl+Ins Create &Boat Crea &Barca Ins Ins Create &Mark Crea &Boa Alt+Ins Alt+Ins Create &PolyLine Crea &linee multiple Ctrl+Alt+Ins Ctrl+Alt+Ins Create Poin&t Crea Pun&to &Port Overlap Ingaggio a &Sinistra Alt+< Alt+< &Starboard Overlap Ingaggio a &Destra Alt+> Alt+> &Text &Testo Alt+T Toggle &Spinnaker Disegna &Spinnaker Toggle Mark &Zone &Disegna Zona Delete Track Cancella traccia Ctrl+Del Ctrl+Del &Delete Selection Cancella&r Selezione Del Del &Animate &Animazione Ctrl+A Ctrl+A &Play &Esegui P I &Pause &Pausa M P &Stop &Stop Space Spazio &Loop &Ciclo L B &Undo &Ripristina Ctrl+Z Ctrl+Z &Redo &Torna indietro Ctrl+Y Ctrl+Y Shift+Ctrl+Z Shift+Ctrl+Z Zoom &In Zoom &avanti Ctrl++ Ctrl++ Zoom &Out Zoom &indietro Ctrl+- Ctrl+- Zoom &Fit Adatta &zoom Ctrl+F Ctrl+U Main Toolbar Barra Principale Animation Toolbar Barra de Animazione Scenario Dock Scenario Dock &About &About Create Track Crear Traccia Create Boat Creaa Barca Create Mark Crea Boa Animate Animazione %1 - %2 [*] %1 - %2 [*] Boat Scenario &Recent &Recenti &File &File &Edit &Modifica &History &Storico &Animation &Animazione &Zoom &Zoom &View &Vedi &%1 %2 &%1 %2 Create Line Crea Linea The document %1 has been modified. Do you want to save your changes? Il documento %1 e stato modificato. Vuoi salvare le modifche? Ctrl+P Ctrl+R &Flag &Bandiera &Help &Aiuto Choose &Language &Scegli lingua Open Scenario File Apri scenario xmlscenario Files (*.xbs) xmlscenario Files(*.xbs) Cannot read file %1: %2. Il file non puo essere letto %1: %2. Open Scenario file Apri scenario Parse error in file %1 at line %2, column %3: %4 Parse errore nel file %1 alla riga %2, columna %3: %4 File loaded File caricato Save Scenario Salva scenario %1 already exists. Do you want to replace it? %1 esiste gia. Vuoi rimpiazzarlo? Cannot write file %1: %2. Non posso escrivere il file %1: %2. File saved File salvato Print Document Stampa documento Export Image Esportare Image Export Animation Esportare Animazione Exporting Animation... Esportando l'animazione... Abort Anulla Protest! Protesto! About Boat Scenario In merito allo scenario della barca Alt+S Alt+Z &Hide Nascondi Alt+D Trim Sail Regola Vele < Auto Trim Auto Regola = Untrim Sail Molla Vele > &Acceleration Accelerazione Toggle &Laylines Mostra Laylines Alt+L Set Mark &Color Imposta &Colore Boa Alt+C Toggle &Mark Side &Inverti lato della boa Alt+M Toggle Mark Arro&w Mostra &Freccia Alt+W Toggle Mark &Label Mostra &Nome boa &Edit Mark Label &Edita nome boa Alt+E Edit mark label Edita nome boa Label text: Casella di testo QObject The file is not an xmlscenario version 1.0 file. Il file non e uno xmlscenario versione 1.0. Laser Optimist Tornado Committee boat Barca Comitato RIB Gommone Spin Keelboat Barcha a chiglia con Spinnaker Gennaker Keelboat Barcha a chiglia con Gennaker Topper Firefly 29er 49er 420 470 SituationPrint Rule Regola SituationWidget Options Opzioni Series Serie Zone Length Lunghezza Zona Tracks Tracce Scenario Scenario Title Ti­tolo Rules Regole Abstract Estratto Description Descrizione Wind Vento Show Wind Mostra Vento Show Grid Mostra Griglia Layline Angle Angolo Layline TrackTableModel Color Colore Path Percorso Series Serie Follow Segue WindTableModel Index Indice Direction Direzione Delete Cancele Linea boats-201307/locale/boats_ja.ts000066400000000000000000000462161217277220500163270ustar00rootroot00000000000000 MainWindow &New File 新規(&N) Ctrl+N &Open File... 開く(&O) Ctrl+O &Save File 上書き保存(&S) Ctrl+S Save &As... 名前を付けて保存(&A) Ctrl+Shift+S New &Tab 新しいタブ(&T) Ctrl+T &Close Tab タブを閉じる(&C) Ctrl+W &Restore Last Session... 最後のセッションを再開(&R) &Print... 印刷(&P) Print P&review... 印刷プレビュー(&R) &Export Pdf... Pdfとして保存(&E) Ctrl+E Export &Image... 画像として保存(&I) Ctrl+I Export Ani&mation... アニメとして保存(&M) Ctrl+V E&xit 終了(&X) Ctrl+Q Exit the application アプリケーションを終了 Create &Track 航跡を作成(&T) Ctrl+Ins Create &Boat 艇を付加(&B) Ins Create &Mark マークを作成(&M) Alt+Ins Create &PolyLine 新しい線(&P) Ctrl+Alt+Ins Create Poin&t 線を延長(&T) &Port Overlap オーバーラップ ポート(&P) Alt+< &Starboard Overlap オーバーラップ スターボ(&S) Alt+> &Text テキスト(&T) Alt+T Toggle &Spinnaker スピネーカー表示/非表示(&S) Toggle Mark &Zone マークゾーン表示/非表示(&Z) Delete Track 航跡を消去 Ctrl+Del &Delete Selection 選択したアイテムを消去(&D) Del &Animate アニメを作成(&A) Ctrl+A &Play 再生(&P) P &Pause 一時停止(&M) M &Stop 停止(&S) Space &Loop 繰り返し(&L) L &Undo 元に戻す(&U) Ctrl+Z &Redo やり直す(&R) Ctrl+Y Shift+Ctrl+Z Zoom &In ズームイン(&I) Ctrl++ Zoom &Out ズームアウト(&O) Ctrl+- Zoom &Fit ウィンドウに合わせる(&F) Ctrl+F Main Toolbar メインツールバー Animation Toolbar アニメツールバー Scenario Dock シナリオドック &About Create Track 航跡を作成 Create Boat 艇を付加 Create Mark マークを作成 Animate アニメを作成 %1 - %2 [*] Boat Scenario &Recent 最近開いたファイル(&R) &File ファイル(&F) &Edit 編集(&E) &History 履歴(&H) &Animation アニメ(&A) &Zoom ズーム(&Z) &View 表示(&V) &%1 %2 Create Line 新しい線 The document %1 has been modified. Do you want to save your changes? Ctrl+P Ctrl+R &Flag 旗(&F) &Help ヘルプ(&H) Choose &Language Open Scenario File xmlscenario Files (*.xbs) Cannot read file %1: %2. Open Scenario file Parse error in file %1 at line %2, column %3: %4 File loaded Save Scenario %1 already exists. Do you want to replace it? Cannot write file %1: %2. File saved 保存されました Print Document 印刷 Export Image 画像として保存 Export Animation アニメとして保存 Exporting Animation... 出力しています Abort Protest! プロテスト! About Boat Scenario BoatScenarioについて Alt+S Alt+Z &Hide 艇を隠す(&H) Alt+D Trim Sail セールを引き込む < Auto Trim セールをトリム（自動） = Untrim Sail セールを緩める > &Acceleration 加速(&A) Toggle &Laylines レイライン表示/非表示(&L) Alt+L Set Mark &Color マーク：色(&C) Alt+C Toggle &Mark Side マーク：ポート/スターボ側(&M) Alt+M Toggle Mark Arro&w 次のマーク(&W) Alt+W Toggle Mark &Label マーク名表示/非表示(&L) &Edit Mark Label マーク名編集(&E) Alt+E Edit mark label マーク名編集 Label text: マーク名： QObject The file is not an xmlscenario version 1.0 file. Laser レーザー Optimist OP Tornado トーネード Committee boat 運営艇 RIB ゴムボート Spin Keelboat キールボート（スピン） Gennaker Keelboat キールボート（ジェネカー） Topper トッパー Firefly ファイヤーフライ 29er 49er 420 470 SituationPrint Rule 規則 SituationWidget Options オプション Series 艇種 Zone Length ゾーンの半径 Tracks 航跡 Scenario シナリオ Title 題名 Rules 規則 Abstract 要約 Description 説明 Wind 風情報 Show Wind 風を表示 Show Grid グリッド表示 Layline Angle レイラインの角度 TrackTableModel Color 色 Path 航跡表示 Series 艇種 Follow 追跡視点 WindTableModel Index 一覧 Direction 風向 Delete 消去 boats-201307/locale/boats_nl.ts000066400000000000000000000463361217277220500163510ustar00rootroot00000000000000 MainWindow &New File &Nieuw Bestand Ctrl+N Ctrl+N &Open File... &Open Bestand... Ctrl+O Ctrl+O &Save File &Bestand Opslaan Ctrl+S Ctrl+S Save &As... Opslaan &Als... Ctrl+Shift+S Ctrl+Shift+S New &Tab Nieuw &Tabblad Ctrl+T Ctrl+T &Close Tab &Sluit Tabblad Ctrl+W Ctrl+W &Restore Last Session... &Laatste Sessie Terughalen... &Print... &Afdrukken... Print P&review... A&fdrukvoorbeeld... &Export Pdf... &Opslaan als Pdf... Ctrl+E Ctrl+E Export &Image... Opslaan als &Afbeelding... Ctrl+I Ctrl+I Export Ani&mation... Opslaan als Ani&matie... Ctrl+V Ctrl+V E&xit A&fsluiten Ctrl+Q Ctrl+Q Exit the application Sluit de toepassing af Create &Track &Koers Ctrl+Ins Ctrl+Ins Create &Boat &Boot Ins Ins Create &Mark &Boei Alt+Ins Alt+Ins Create &PolyLine &Polylijn Ctrl+Alt+Ins Ctrl+Alt+Ins Create Poin&t Pun&t Polyline &Port Overlap &Bakboord Overlap Alt+< Alt+< &Starboard Overlap &Stuurboord Overlap Alt+> Alt+> &Text &Tekst Alt+T Alt+T Toggle &Spinnaker Toggle &Spinnaker Toggle Mark &Zone Toggle Boei &Zone Delete Track Verwijder Koers Ctrl+Del Ctrl+Del &Delete Selection &Verwijder Selectie Del Del &Animate &Animatie Ctrl+A Ctrl+A &Play &AfSpelen P P &Pause &Pauze M M &Stop &Stop Space Afstand &Loop &Continue afspelen L L &Undo &Ongedaan maken Ctrl+Z Ctrl+Z &Redo &Opnieuw maken Ctrl+Y Ctrl+Y Shift+Ctrl+Z Shift+Ctrl+Z Zoom &In Zoom &In Ctrl++ Ctrl++ Zoom &Out Zoom &Uit Ctrl+- Ctrl+- Zoom &Fit Zoom &Passend Ctrl+F Ctrl+F Main Toolbar Hoofd Werkbalk Animation Toolbar Animatie Werkbalk Scenario Dock Scenario Station &About &Over Create Track Koers Create Boat Boot Create Mark Boei Animate Animatie %1 - %2 [*] %1 - %2 [*] Boat Scenario Boot Scenario &Recent &Recent geopend &File &Bestand &Edit &Bewerken &History &Historie &Animation &Animatie &Zoom &Zoom &View &Bekijken &%1 %2 &%1 %2 Create Line Lijn The document %1 has been modified. Do you want to save your changes? Het document %1 is gewijzigd. Wil u de wijzigingen opslaan? Ctrl+P Ctrl+P Ctrl+R Ctrl+R &Flag &Vlag &Help &Help Choose &Language Kies &Taal Open Scenario File Open Scenario Bestand xmlscenario Files (*.xbs) xmlscenario Bestanden (*.xbs) Cannot read file %1: %2. Kan bestand niet openen %1: %2. Open Scenario file Open Scenario bestand Parse error in file %1 at line %2, column %3: %4 Parsing fout in bestand %1 in regel %2, kolom %3: %4 File loaded Bestand geopend Save Scenario Bewaar Scenario %1 already exists. Do you want to replace it? %1 bestaat al. Wilt u het vervangen? Cannot write file %1: %2. Kant het bestand niet opslaan %1: %2. File saved Bestand opgeslagen Print Document Document Afdrukken Export Image Opslaan als Afbeelding Export Animation Opslaan als Animatie Exporting Animation... Opslaan Animatie... Abort Afsluiten Protest! Protest! About Boat Scenario Info Boat Scenario Alt+S Alt+S Alt+Z Alt+Z &Hide &Verberg Alt+D Alt+D Trim Sail Schoot Aan < < Auto Trim Auto Trim = = Untrim Sail Schoot Vieren > > &Acceleration &Versnelling Toggle &Laylines Toggle &Laylines Alt+L Alt+L Set Mark &Color Set Merkteken &Kleur Alt+C Alt+C Toggle &Mark Side Toggle &Merkteken Kant Alt+M Alt+M Toggle Mark Arro&w Toggle Merkteken Pij&l Alt+W Alt+L Toggle Mark &Label Toggle Merkteken &Label &Edit Mark Label Bewerk Merkteken Label Alt+E Alt+B Edit mark label Bewerk merkteken label Label text: Label tekst: QObject The file is not an xmlscenario version 1.0 file. Dit is geen xmlscenario versie 1.0 bestand. Laser Laser Optimist Optimist Tornado Tornado Committee boat Comit\cf1\f1\'e9boot\cf0\f0 RIB Rubberboot Spin Keelboat Spin Kielboot Gennaker Keelboat Gennaker Kielboot Topper Topper Firefly Firefly 29er 29er 49er 49er 420 420 470 470 SituationPrint Rule Regel SituationWidget Options Opties Series Series Zone Length Zone Lengten Tracks Koersen Scenario Scenario Title Titel Rules Regels Abstract Kort overzicht Description Omschrijving Wind Wind Show Wind Toon Wind Show Grid Toon Rooster Layline Angle Layline Hoek TrackTableModel Color Kleur Path Baan Series Serie Follow Volg WindTableModel Index Index Direction Richting Delete Verwijder boats-201307/locale/boats_pl.ts000066400000000000000000000457231217277220500163520ustar00rootroot00000000000000 MainWindow &New File &Nowy plik Ctrl+N &Open File... O&tworz plik... Ctrl+O Ctrl+B &Save File &Zapisz plik Ctrl+S Ctrl+G Save &As... Zapiz &jako... Ctrl+Shift+S Ctrl+Shift+C New &Tab Nowa &zakladka Ctrl+T Ctrl+S &Close Tab Z&amknij zakladke Ctrl+W Ctrl+E &Restore Last Session... &Przywroc poprzednia sesje... &Print... &Drukuj... Print P&review... Podglad w&ydruku... &Export Pdf... &Eksportuj Pdf... Ctrl+E Export &Image... Eksportuj ob&raz... Ctrl+I Ctrl+G Export Ani&mation... Eksportuj Ani&macje... Ctrl+V E&xit Wy&jdz Ctrl+Q Ctrl+Q Exit the application Wydjz z aplikacji Create &Track Utworz &Trase Ctrl+Ins Create &Boat Utworz &lodke Ins Create &Mark Utworz &znak Alt+Ins Create &PolyLine Utworz &linie Ctrl+Alt+Ins Create Poin&t Utworz pun&kt &Port Overlap Krycie na &lewym halsie Alt+< &Starboard Overlap Krycie na &prawym halsie Alt+> &Text &Tekst Alt+T Toggle &Spinnaker Wstaw &spinaker Toggle Mark &Zone &Wstaw strefe przy znaku Delete Track Usun trase Ctrl+Del &Delete Selection Usu&n sesje Del &Animate &Animuj Ctrl+A &Play &Graj P I &Pause &Pauza M P &Stop Z&atrzymaj Space &Loop &Petla L B &Undo C&ofnij Ctrl+Z &Redo &Przywroc Ctrl+Y Shift+Ctrl+Z Zoom &In P&owieksz Ctrl++ Zoom &Out Pom&niejsz Ctrl+- Zoom &Fit Do&pasuj obraz Ctrl+F Ctrl+U Main Toolbar Glowny pasek narzedzi Animation Toolbar Pasek animacji Scenario Dock Miejsce na opis &About &O Create Track Utworz Trase Create Boat Utworz lodke Create Mark Utworz znak Animate Animuj %1 - %2 [*] Boat Scenario &Recent &Ostatni &File &Plik &Edit &Edytuj &History &Historia &Animation &Animacja &Zoom &Zoom &View &Widok &%1 %2 Create Line Utworz linie The document %1 has been modified. Do you want to save your changes? Dokument zostal %1 zsmodyfikowany. Czy chcesz zapisac zmiany? Ctrl+P Ctrl+R &Flag &Flaga &Help &Pomoc Choose &Language &Wybierz jezyk Open Scenario File Otworz scenariusz pliku xmlscenario Files (*.xbs) Pliku xmlscenario (*.xbs) Cannot read file %1: %2. Nie mozna przeczytac pliku %1: %2. Open Scenario file Otworz scenariusz pliku Parse error in file %1 at line %2, column %3: %4 Blad w pliku %1 w linii %2, columna %3: %4 File loaded Plik zaladowany Save Scenario Zapisz scenariusz %1 already exists. Do you want to replace it? %1 Juz istnieje. Czy chcesz go zastapic? Cannot write file %1: %2. Nie mozna zapisac pliku %1: %2. File saved Pilk zapisany Print Document Drukuj dokument Export Image Eksportuj obraz Export Animation Eksportuj animacje Exporting Animation... Eksportuje animacje... Abort Zatrzymanie Protest! Protest! About Boat Scenario O programie Alt+S Alt+Z &Hide &Ukryj Alt+D Trim Sail Wybierz Żagiel < Auto Trim Auto Trym = Untrim Sail Poluzug Żagiel > &Acceleration Przyspieszenie Toggle &Laylines Wyznacz &Laylines Alt+L Set Mark &Color Ustaw &Kolor znaku Alt+C Toggle &Mark Side Przełącz &Stronę znaku Alt+M Toggle Mark Arro&w Przełącz &Strzałkę znaku Alt+W Toggle Mark &Label Przełącz &Etykietę znaku &Edit Mark Label &Edytuj etykietę znaku Alt+E Edit mark label Edytuj etykietę znaku Label text: Tekst etykiety QObject The file is not an xmlscenario version 1.0 file. Plik nie jest plikiem xmlscenario version 1.0. Laser Optimist Tornado Committee boat Tatek komisji RIB Ponton Spin Keelboat Jacht Kilowy ze Spinakerem Gennaker Keelboat Jacht Kilowy ze Genakerem Topper Firefly 29er 49er 420 470 SituationPrint Rule Przepis SituationWidget Options Opcje Series Serie Zone Length Duglosc strefy Tracks Trasy Scenario Scenariusz Title Tytul Rules Przepisy Abstract Podsumowanie Description Opis Wind Wiatr Show Wind Pokaz strzalke wiatru Show Grid Pokaz siatke pola Layline Angle Kat layline TrackTableModel Color Kolor Path Sciezka Series Serie Follow Podążaj WindTableModel Index Index Direction Kierunek Delete Usun boats-201307/locale/boats_pt.ts000066400000000000000000000461361217277220500163610ustar00rootroot00000000000000 MainWindow &New File &Novo ficheiro Ctrl+N &Open File... A&brir ficheiro... Ctrl+O Ctrl+B &Save File &Salvar ficheiro Ctrl+S Ctrl+G Save &As... Salvar &como... Ctrl+Shift+S Ctrl+Shift+C New &Tab Nova &etiqueta Ctrl+T Ctrl+S &Close Tab F&echa etiqueta Ctrl+W Ctrl+E &Restore Last Session... &Restaurar ultima sessao... &Print... &Imprimir... Print P&review... Visualizaçao de &impressao... &Export Pdf... &Exportar Pdf... Ctrl+E Export &Image... Exportar Ima&gem... Ctrl+I Ctrl+G Export Ani&mation... Exportar Ani&maçao... Ctrl+V E&xit Fe&char Ctrl+Q Exit the application Fechar aplicaçao Create &Track Criar &Trajecto Ctrl+Ins Create &Boat Criar &Barco Ins Create &Mark Criar &Baliza Alt+Ins Create &PolyLine Criar &linha multipla Ctrl+Alt+Ins Create Poin&t Criar Pon&to &Port Overlap Sobreladeamento a &Bombordo Alt+< &Starboard Overlap Sobreladeamento a &Estribordo Alt+> &Text &Texto Alt+T Toggle &Spinnaker Activar &Spinnaker Toggle Mark &Zone &Activar area de baliza Delete Track Cancelar trajecto Ctrl+Del &Delete Selection Cancela&r Selecçao Del &Animate &Animaçao Ctrl+A &Play &Executar P I &Pause &Pausa M &Stop &Parar Space &Loop &Volta L B &Undo &Desfazer Ctrl+Z &Redo &Volta a fazer Ctrl+Y Shift+Ctrl+Z Zoom &In A&mpliar Ctrl++ Zoom &Out R&eduzir Ctrl+- Zoom &Fit A&justar Ctrl+F Ctrl+U Main Toolbar Barra de ferramenta principal Animation Toolbar Barra de Animaçao Scenario Dock Controle de cenario &About &Acerca de Create Track Criar Trajecto Create Boat Criar Barco Create Mark Criar Baliza Animate Animaçao %1 - %2 [*] Boat Scenario &Recent &Recente &File &Ficheiro &Edit &Editar &History &Historico &Animation &Animaçao &Zoom &Zoom &View &Vista &%1 %2 Create Line Criar Linha The document %1 has been modified. Do you want to save your changes? Este documento %1 foi alterado. Deseja salvar as alteraçoes? Ctrl+P Ctrl+R &Flag &Bandeira &Help &Ajuda Choose &Language &Escolher idioma Open Scenario File Abrir ficheiro de cenario xmlscenario Files (*.xbs) xmlscenario Files(*.xbs) Cannot read file %1: %2. Nao pode ler ficheiro %1: %2. Open Scenario file Abrir ficheiro de cenario Parse error in file %1 at line %2, column %3: %4 Analisar erro no ficheiro %1 na linha %2, columna %3: %4 File loaded Ficheiro baixado Save Scenario Salvar cenario %1 already exists. Do you want to replace it? %1 Ja existe. Deseja substitui-lo? Cannot write file %1: %2. Nao e possivel escrever o ficheiro %1: %2. File saved Ficheiro salvo Print Document Imprimir documento Export Image Exportar Imagem Export Animation Exportar Animaçao Exporting Animation... Exportando l'animaçao... Abort Abortar Protest! Protesto! About Boat Scenario Acerca do cenario de barco Alt+S Alt+Z &Hide &Occultar Barco Alt+D Trim Sail Caçar Vela < Auto Trim Velas Trimadas = Untrim Sail Folgar Vela > &Acceleration Acelerçao Toggle &Laylines Mostrar Laylines Alt+L Set Mark &Color Escolher &Cor da baliza Alt+C Toggle &Mark Side Activar &Lado da baliza Alt+M Toggle Mark Arro&w Activar &Seta da baliza Alt+W Toggle Mark &Label Activar &Etiqueta da baliza &Edit Mark Label Editar &Etiqueta da baliza Alt+E Edit mark label Editar Etiqueta da baliza Label text: Texto da etiqueta: QObject The file is not an xmlscenario version 1.0 file. Este ficheiro nao e um xmlscenario versao 1.0. Laser Optimist Tornado Committee boat Barco da CR RIB Pneumatico Spin Keelboat Barca con Spi simétrico Gennaker Keelboat Barca con Spi assimétrico Topper Firefly 29er 49er 420 470 SituationPrint Rule Regra SituationWidget Options Opçoes Series Series Zone Length Comprimento da area Tracks Trajectorias Scenario Cenario Title Ti­tulo Rules Regras Abstract Extrato Description Descriçao Wind Vento Show Wind Mostrar Vento Show Grid Mostrar Grelha Layline Angle Angulo Layline TrackTableModel Color Cor Path Percurso Series Series Follow Seguir WindTableModel Index Indice Direction Direcçao Delete Apagar boats-201307/locale/boats_sl.ts000066400000000000000000000461431217277220500163520ustar00rootroot00000000000000 MainWindow &New File &Nova datoteka Ctrl+N &Open File... &Odpri datoteko... Ctrl+O &Save File &Shrani datoteko Ctrl+S Save &As... Shrani &kot... Ctrl+Shift+S New &Tab Nov &zavihek Ctrl+T &Close Tab &Zapri zavihek Ctrl+W &Restore Last Session... &Obnovi zadnjo sejo... &Print... &Natisni... &Export Pdf... &Izvozi PDF... Ctrl+E Export &Image... Izvozi &sliko... Ctrl+I Export Ani&mation... Izvozi &animacijo... Ctrl+V Ctrl+Q Exit the application Izhod iz programa Create &Track Dodaj &sled Ctrl+Ins Create &Boat Dodaj &plovilo Ins Create &Mark Dodaj &oznako Alt+Ins &Port Overlap Prekrivanje na &levi Alt+< &Starboard Overlap Prekrivanje na &desni Alt+> &Text &Besedilo Alt+T Toggle Mark &Zone Prikaži/skrij &cono oznake Delete Track Izbriši sled Ctrl+Del &Delete Selection &Izbriši izbrano Del &Animate &Animacija Ctrl+A &Play &Predvajaj P &Pause &Premor M &Stop &Ustavi Space Presledek &Loop &Neprekinjeno predvajanje L &Undo &Razveljavi Ctrl+Z &Redo &Ponovi Ctrl+Y Shift+Ctrl+Z Zoom &In Po&ečaj Ctrl++ Zoom &Out Po&manjšaj Ctrl+- Zoom &Fit &Prikaži vse Ctrl+F Main Toolbar Glavna orodna vrstica Animation Toolbar Animacijska orodna vrstica Scenario Dock Scenarij &About &Vizitka Create Track Ustvari sled Create Boat Ustvari plovilo Create Mark Ustvari oznako Animate Animiraj %1 - %2 [*] Boat Scenario Boat Scenario &Recent &Nazadnje urejano &File &Datoteka &Edit &Uredi &History &Zgodovina &Animation &Animacija &Zoom Povečava &View &Pogled &%1 %2 The document %1 has been modified. Do you want to save your changes? Datoteka %1 je bila spremenjena. Ali želite shraniti spremembe? Ctrl+P Ctrl+R &Flag &Zastava &Help &Pomoč Choose &Language Izberi &jezik Open Scenario File Odpri datoteko s scenarijem xmlscenario Files (*.xbs) Datoteke xmlscenario (*.xbs) Cannot read file %1: %2. Ne morem prebrati datoteke %1: %2. Open Scenario file Odpri datoteko s scenarijem Parse error in file %1 at line %2, column %3: %4 Napaka pri prebiranju datoteke %1 v vrstici %2, kolona %3: %4 File loaded Datoteka je naložena Save Scenario Shrani scenarij %1 already exists. Do you want to replace it? Datoteka %1 že obstaja. Ali jo želite prepisati? Cannot write file %1: %2. Ne morem shraniti datoteke %1: %2. File saved Datoteka je shranjena Print Document Natisni dokument Export Image Izvozi sliko Export Animation Izvozi animacijo Exporting Animation... Izvažam animacijo... Abort Prekini Protest! About Boat Scenario O programu Boat Scenario Print P&review... Predogled &tiskanja... E&xit &Izhod Create Line Ustvari črto Create &PolyLine Ustvari &črto Ctrl+Alt+Ins Create Poin&t Ustvari &točko Toggle &Spinnaker Prikaži/skrij &špinaker Alt+S Alt+Z &Hide &Skrij Alt+D Trim Sail Nastavi trim jadra < < Auto Trim Samodejno nastavljanje trima = = Untrim Sail Odstrani ročni trim jadra > > &Acceleration &Pospešek Toggle &Laylines Prikaži/skrij layline Alt+L Toggle &Mark Side Prikaži/skrij stran oznake Alt+M Toggle Mark Arro&w Prikaži/skrij puščico Alt+W Set Mark &Color Nastavi barvo oznake Alt+C Toggle Mark &Label Prikaži/skrij opis oznake &Edit Mark Label Uredi opis oznake Alt+E Edit mark label Uredi opis oznake Label text: Opis: QObject The file is not an xmlscenario version 1.0 file. Datoteka ni tipa xmlscenario različice 1.0. Spin Keelboat Jadrnica s špinakerjem Gennaker Keelboat Jadrnica z gennakerjem 49er 49er 470 470 420 420 29er 29er Laser Laser Firefly Firefly Topper Topper Optimist Optimist Tornado tornado Committee boat Regatna barka RIB Gumijast čoln SituationPrint Rule Pravilo SituationWidget Options Možnosti Series Razred Zone Length Velikost cone Tracks Sledi Scenario Scenarij Title Naslov Rules Pravila Abstract Povzetek Description Opis Wind Veter Show Wind Prikaži smer vetra Show Grid Prikaži mrežo Layline Angle Kot za layline TrackTableModel Color Barva Path Sled Series Razred Follow Sledi WindTableModel Index Položaj Direction Smer Delete Izbriši boats-201307/locale/boats_sv.ts000066400000000000000000000464231217277220500163650ustar00rootroot00000000000000 MainWindow &New File &Ny fil Ctrl+N &Open File... &Öppna fil... Ctrl+O &Save File &Spara Ctrl+S Save &As... Spara s&om... Ctrl+Shift+S New &Tab Ny &flik Ctrl+T &Close Tab Stäng fli&k Ctrl+W &Restore Last Session... &Återskapa senaste session... &Print... Skri&v ut... Print P&review... Fö&rhandsgranska utskrift... &Export Pdf... &Exportera PDF... Ctrl+E Export &Image... Exportera b&ild... Ctrl+I Export Ani&mation... Exportera ani&mation... Ctrl+V Ctrl+V E&xit &Avsluta Ctrl+Q Exit the application Avsluta programmet Create &Track Skapa &spår Ctrl+Ins Create &Boat Skapa &båt Ins Create &Mark Skapa &märke Alt+Ins &Port Overlap Överlapp till b&abord Alt+< &Starboard Overlap Överlapp till st&yrbord Alt+> Toggle Mark &Zone Märkes&zonen på och av Delete Track Radera spår Ctrl+Del &Delete Selection Ra&dera markerade Del &Animate &Animera Ctrl+A &Play S&pela upp P &Pause &Paus M &Stop &Stanna Space &Loop S&linga L &Undo &Ångra Ctrl+Z &Redo &Gör om Ctrl+Y Shift+Ctrl+Z Zoom &In Zooma &in Ctrl++ Zoom &Out Zooma &ut Ctrl+- Zoom &Fit &Anpassa zoom Ctrl+F Main Toolbar Huvudverktygsfält Animation Toolbar Animeringsverktygsfält Scenario Dock Scenario fält &About &Om Create Track Skapa spår Create Boat Skapa båt Create Mark Skapa märke Animate Animera %1 - %2 [*] Boat Scenario &Recent N&yligen &File &Fil &Edit R&edigera &History &Historia &Animation &Animering &Zoom &Zoom &View &Visa &%1 %2 The document %1 has been modified. Do you want to save your changes? Dokumentet %1 har ändrats. Vill du spara dina ändringar? Open Scenario File Öppna Scenario-fil xmlscenario Files (*.xbs) xmlscenario filer (*.xbs) Cannot read file %1: %2. Kan inte läsa filen %1: %2. Open Scenario file Öppna Scenario-fil Parse error in file %1 at line %2, column %3: %4 Fel vid parsning av fil %1 på rad %2, kolumn %3:%4 File loaded Filen inläst Save Scenario Spara Scenario %1 already exists. Do you want to replace it? %1 finns redan. Vill du ersätta den? Cannot write file %1: %2. Kan inte skriva filen %1:%2. File saved Filen sparad Print Document Skriv ut dokument Export Image Exportera bild Export Animation Exportera animation Exporting Animation... Exporterar animation... Abort Avbryt About Boat Scenario Om Boat Scenario Ctrl+P Ctrl+R &Text Alt+T &Flag &Flagga &Help &Hjälp Choose &Language Välj &språk Protest! Create Line Skapa linje Create &PolyLine Skapa &polylinje Ctrl+Alt+Ins Create Poin&t Skapa punk&t Toggle &Spinnaker &Spinnaker på och av Alt+S Alt+Z &Hide Could not find a phrase including the letter H. &Göm Alt+D Alt+D Trim Sail Alternatively this could be only Skota, but then we run into trouble with the words for easing the sheet. Skota in < < Auto Trim Auto Trim = = Untrim Sail Skota ut is not really good Swedish, but the correct term "slacka på skotet" is probably too long in this context. Skota ut > > &Acceleration &Acceleration Toggle &Laylines &Laylines på och av Alt+L Alt+L Set Mark &Color Ändra märkets &Färg Alt+C Toggle &Mark Side &Byt märkessida Alt+M Toggle Mark Arro&w Märke&spil på och av Alt+W Toggle Mark &Label Märkes&etikett på och av &Edit Mark Label &Redigera märkesetikett Alt+E Edit mark label Redigera märkesetikett Label text: Etikettext QObject The file is not an xmlscenario version 1.0 file. Den här filen är inte xmlscenario version 1.0. Laser Optimist Tornado Committee boat Startfartyg RIB Spin Keelboat Spinnaker-kölbåt Gennaker Keelboat Gennaker-kölbåt Topper Firefly 29er 49er 420 470 SituationPrint Rule Regel SituationWidget Options Inställningar Series Båttyp Zone Length Zonens storlek Tracks Spår Scenario Scenario Title Titel Rules Regler Abstract Sammanfattning Description Beskrivning Wind Vind Show Wind Visa vinden Show Grid Visa rutnät Layline Angle Kryssvinkel TrackTableModel Color Färg Series Båttyp Path Spår Follow Följ WindTableModel Index Index Direction Riktning Delete Radera boats-201307/locale/locale.pri000066400000000000000000000017351217277220500161450ustar00rootroot00000000000000TRANSLATIONS += \ $$PWD/boats.ts \ $$PWD/boats_da.ts \ $$PWD/boats_de.ts \ $$PWD/boats_es.ts \ $$PWD/boats_fr.ts \ $$PWD/boats_it.ts \ $$PWD/boats_ja.ts \ $$PWD/boats_nl.ts \ $$PWD/boats_pl.ts \ $$PWD/boats_pt.ts \ $$PWD/boats_sl.ts \ $$PWD/boats_sv.ts QM_FILES = $$replace(TRANSLATIONS, "\\.ts", ".qm") isEmpty(QMAKE_LUPDATE) { win32:QMAKE_LUPDATE = $$[QT_INSTALL_BINS]/lupdate.exe else:QMAKE_LUPDATE = $$[QT_INSTALL_BINS]/lupdate } isEmpty(QMAKE_LRELEASE) { win32:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]/lrelease.exe else:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]/lrelease } updatets.commands = $$QMAKE_LUPDATE -locations none -noobsolete boats.pro QMAKE_EXTRA_TARGETS += updatets updateqm.depends = updatets updateqm.input = TRANSLATIONS updateqm.output = locale/${QMAKE_FILE_BASE}.qm updateqm.commands = $$QMAKE_LRELEASE ${QMAKE_FILE_IN} updateqm.CONFIG += no_link QMAKE_EXTRA_COMPILERS += updateqm rcc.depends = $$QM_FILES boats-201307/main.cpp000066400000000000000000000026751217277220500143670ustar00rootroot00000000000000// // C++ Implementation: main // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #include #include #include "boatapplication.h" #include "mainwindow.h" int debugLevel = 0; int main(int argc, char *argv[]) { BoatApplication app(argc, argv); int i; QStringList arguments = QCoreApplication::arguments(); arguments.removeAt(0); if (-1 != (i=arguments.indexOf("-debug"))) { debugLevel = arguments[i+1].toInt(); std::cout << "debug level set to " << debugLevel << std::endl; arguments.removeAt(i+1); arguments.removeAt(i); } // MainWindow MainWindow window; app.setWindow(&window); window.show(); window.openFiles(arguments); return app.exec(); } boats-201307/mainwindow.cpp000066400000000000000000002151171217277220500156140ustar00rootroot00000000000000// // C++ Implementation: mainwindow // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include "mainwindow.h" #include "commontypes.h" #include "boats.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" #include "markmodel.h" #include "polylinemodel.h" #include "pointmodel.h" #include "scenarioanimation.h" #include "undocommands.h" #include "xmlsituationreader.h" #include "xmlsituationwriter.h" #include "situationwidget.h" #include "situationscene.h" #include "situationview.h" #include "colorpickerwidget.h" #ifdef GIF_EXPORT #include "gifwriter.h" #endif #define VERSION "201307" extern int debugLevel; const int MainWindow::maxRecent(5); MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), menubar(new QMenuBar(this)), toolbar(new QToolBar(this)), tabWidget(new QTabWidget(this)), animationBar(new QToolBar(this)), situationDock(new QDockWidget(this)), situationWidget(new SituationWidget(situationDock)), statusbar(new QStatusBar(this)), qtTranslator(new QTranslator(this)), translator(new QTranslator(this)) { // Actions createActions(); // Bars createMenus(); setMenuBar(menubar); addToolBar(toolbar); addToolBar(Qt::BottomToolBarArea, animationBar); setStatusBar(statusbar); // Docks createDocks(); addDockWidget(Qt::LeftDockWidgetArea, situationDock); // View newTabButton = new QPushButton(QIcon(":/images/tab_new.png"),QString(""), this); connect(newTabButton, SIGNAL(clicked()), newTabAction, SLOT(trigger())); tabWidget->setCornerWidget(newTabButton, Qt::TopLeftCorner); removeTabButton = new QPushButton(QIcon(":/images/tab_remove.png"),QString(""), this); removeTabButton->setEnabled(removeTabAction->isEnabled()); connect(removeTabButton, SIGNAL(clicked()), removeTabAction, SLOT(trigger())); tabWidget->setCornerWidget(removeTabButton, Qt::TopRightCorner); connect(tabWidget, SIGNAL(currentChanged(int)), this, SLOT(setTab(int))); newTab(); setCentralWidget(tabWidget); readSettings(); // Locale and translation setup createTranslations(QLocale::system().name()); } MainWindow::~MainWindow() {} void MainWindow::createTranslations(QString locale) { qtTranslator->load("qt_" + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath)); qApp->installTranslator(qtTranslator); if (translator->load(QString("boats_").append(locale).append(".qm"), TRANSLATEDIR)) { qApp->installTranslator(translator); } else { QCoreApplication::postEvent(QCoreApplication::instance(), new QEvent(QEvent::LanguageChange)); } } void MainWindow::createActions() { newFileAction = new QAction(this); newFileAction->setIcon(QIcon(":/images/filenew.png")); connect(newFileAction, SIGNAL(triggered()), this, SLOT(newFile())); openFileAction = new QAction(this); openFileAction->setIcon(QIcon(":/images/fileopen.png")); connect(openFileAction, SIGNAL(triggered()), this, SLOT(openFile())); saveFileAction = new QAction(this); saveFileAction->setIcon(QIcon(":/images/filesave.png")); saveFileAction->setEnabled(false); connect(saveFileAction, SIGNAL(triggered()), this, SLOT(saveFile())); saveAsAction = new QAction(this); saveAsAction->setIcon(QIcon(":/images/filesaveas.png")); saveAsAction->setEnabled(false); connect(saveAsAction, SIGNAL(triggered()), this, SLOT(saveAs())); newTabAction = new QAction(this); newTabAction->setIcon(QIcon(":/images/tab_new.png")); connect(newTabAction, SIGNAL(triggered()), this, SLOT(newTab())); removeTabAction = new QAction(this); removeTabAction->setIcon(QIcon(":/images/tab_remove.png")); removeTabAction->setEnabled(false); connect(removeTabAction, SIGNAL(triggered()), this, SLOT(removeTab())); restoreFilesAction = new QAction(this); connect(restoreFilesAction, SIGNAL(triggered()), this, SLOT(restoreFiles())); printAction = new QAction(this); printAction->setIcon(QIcon(":images/fileprint.png")); connect(printAction, SIGNAL(triggered()), this, SLOT(print())); printPreviewAction = new QAction(this); printPreviewAction->setIcon(QIcon(":images/filequickprint.png")); connect(printPreviewAction, SIGNAL(triggered()), this, SLOT(printPreview())); exportPdfAction = new QAction(this); exportPdfAction->setIcon(QIcon(":/images/pdf.png")); connect(exportPdfAction, SIGNAL(triggered()), this, SLOT(exportPdf())); exportImageAction = new QAction(this); exportImageAction->setIcon(QIcon(":/images/export.png")); connect(exportImageAction, SIGNAL(triggered()), this, SLOT(exportImage())); #ifdef GIF_EXPORT exportAnimationAction = new QAction(this); exportAnimationAction->setIcon(QIcon(":/images/video.png")); connect(exportAnimationAction, SIGNAL(triggered()), this, SLOT(exportAnimation())); #endif exitAction = new QAction(this); connect(exitAction, SIGNAL(triggered()), this, SLOT(close())); addTrackAction = new QAction(this); addTrackAction->setIcon(QIcon(":/images/addtrack.png")); addTrackAction->setCheckable(true); connect(addTrackAction, SIGNAL(triggered()), this, SLOT(addTrack())); addBoatAction = new QAction(this); addBoatAction->setIcon(QIcon(":/images/addboat.png")); addBoatAction->setCheckable(true); connect(addBoatAction, SIGNAL(triggered()), this, SLOT(addBoat())); addMarkAction = new QAction(this); addMarkAction->setIcon(QIcon(":/images/addmark.png")); addMarkAction->setCheckable(true); connect(addMarkAction, SIGNAL(triggered()), this, SLOT(addMark())); addPolyLineAction = new QAction(this); addPolyLineAction->setIcon(QIcon(":/images/addpoly.png")); addPolyLineAction->setCheckable(true); connect(addPolyLineAction, SIGNAL(triggered()), this, SLOT(addPolyLine())); addPointAction = new QAction(this); addPointAction->setIcon(QIcon(":/images/addpoint.png")); addPointAction->setCheckable(true); connect(addPointAction, SIGNAL(triggered()), this, SLOT(addPoint())); trimSailAction = new QAction(this); connect(trimSailAction, SIGNAL(triggered()), this, SLOT(trimSail())); autotrimSailAction = new QAction(this); connect(autotrimSailAction, SIGNAL(triggered()), this, SLOT(autotrimSail())); untrimSailAction = new QAction(this); connect(untrimSailAction, SIGNAL(triggered()), this, SLOT(untrimSail())); togglePortOverlapAction = new QAction(this); togglePortOverlapAction->setCheckable(true); connect(togglePortOverlapAction, SIGNAL(triggered()), this, SLOT(togglePortOverlap())); toggleStarboardOverlapAction = new QAction(this); toggleStarboardOverlapAction->setCheckable(true); connect(toggleStarboardOverlapAction, SIGNAL(triggered()), this, SLOT(toggleStarboardOverlap())); toggleHiddenAction = new QAction(this); toggleHiddenAction->setCheckable(true); connect(toggleHiddenAction, SIGNAL(triggered()), this, SLOT(toggleHidden())); toggleTextAction = new QAction(this); toggleTextAction->setCheckable(true); connect(toggleTextAction, SIGNAL(triggered()), this, SLOT(toggleText())); toggleSpinAction = new QAction(this); toggleSpinAction->setCheckable(true); toggleSpinAction->setEnabled(false); connect(toggleSpinAction, SIGNAL(triggered()), this, SLOT(toggleSpin())); toggleMarkSideAction = new QAction(this); connect(toggleMarkSideAction, SIGNAL(triggered()), this, SLOT(toggleMarkSide())); toggleMarkArrowAction = new QAction(this); toggleMarkArrowAction->setCheckable(true); connect(toggleMarkArrowAction, SIGNAL(triggered()), this, SLOT(toggleMarkArrow())); toggleMarkZoneAction = new QAction(this); toggleMarkZoneAction->setIcon(QIcon(":/images/zone.png")); toggleMarkZoneAction->setCheckable(true); connect(toggleMarkZoneAction, SIGNAL(triggered()), this, SLOT(toggleMarkZone())); setMarkColorAction = new QAction(this); setMarkColorAction->setIcon(QIcon()); connect(setMarkColorAction, SIGNAL(triggered()), this, SLOT(setMarkColor())); toggleLaylinesAction = new QAction(this); toggleLaylinesAction->setIcon(QIcon(":/images/laylines.png")); toggleLaylinesAction->setCheckable(true); connect(toggleLaylinesAction, SIGNAL(triggered()), this, SLOT(toggleLaylines())); toggleMarkLabelAction = new QAction(this); toggleMarkLabelAction->setCheckable(true); connect(toggleMarkLabelAction, SIGNAL(triggered()), this, SLOT(toggleMarkLabel())); editMarkLabelAction = new QAction(this); connect(editMarkLabelAction, SIGNAL(triggered()), this, SLOT(editMarkLabel())); deleteTrackAction = new QAction(this); connect(deleteTrackAction, SIGNAL(triggered()), this, SLOT(deleteTrack())); deleteAction = new QAction(this); connect(deleteAction, SIGNAL(triggered()), this, SLOT(deleteModels())); animateAction = new QAction(this); animateAction->setIcon(QIcon(":/images/animate.png")); animateAction->setCheckable(true); connect(animateAction, SIGNAL(triggered(bool)), this, SLOT(animate(bool))); startAction = new QAction(this); startAction->setIcon(QIcon(":/images/player_play.png")); startAction->setEnabled(false); connect(startAction, SIGNAL(triggered()), this, SLOT(play())); pauseAction = new QAction(this); pauseAction->setIcon(QIcon(":/images/player_pause.png")); pauseAction->setEnabled(false); pauseAction->setCheckable(true); connect(pauseAction, SIGNAL(triggered(bool)), this, SLOT(pause(bool))); stopAction = new QAction(this); stopAction->setIcon(QIcon(":/images/player_stop.png")); stopAction->setEnabled(false); connect(stopAction, SIGNAL(triggered()), this, SLOT(stop())); loopAction = new QAction(this); loopAction->setIcon(QIcon(":/images/player_loop.png")); loopAction->setEnabled(false); loopAction->setCheckable(true); connect(loopAction, SIGNAL(triggered(bool)), this, SLOT(loop(bool))); undoAction = new QAction(this); undoAction->setIcon(QIcon(":/images/undo.png")); undoAction->setEnabled(false); redoAction = new QAction(this); redoAction->setIcon(QIcon(":/images/redo.png")); redoAction->setEnabled(false); zoomInAction = new QAction(this); zoomInAction->setIcon(QIcon(":/images/zoomin.png")); zoomOutAction = new QAction(this); zoomOutAction->setIcon(QIcon(":/images/zoomout.png")); zoomFitAction = new QAction(this); zoomFitAction->setIcon(QIcon(":/images/zoomfit.png")); toggleMainToolbarAction = new QAction(this); toggleMainToolbarAction->setCheckable(true); toggleMainToolbarAction->setChecked(true); connect(toggleMainToolbarAction, SIGNAL(toggled(bool)), toolbar, SLOT(setVisible(bool))); toggleAnimationToolbarAction = new QAction(this); toggleAnimationToolbarAction->setCheckable(true); toggleAnimationToolbarAction->setChecked(true); connect(toggleAnimationToolbarAction, SIGNAL(toggled(bool)), animationBar, SLOT(setVisible(bool))); toggleScenarioDockAction = new QAction(this); toggleScenarioDockAction->setCheckable(true); toggleScenarioDockAction->setChecked(true); connect(toggleScenarioDockAction, SIGNAL(toggled(bool)), situationDock, SLOT(setVisible(bool))); aboutAction = new QAction(this); connect(aboutAction, SIGNAL(triggered()), this, SLOT(about())); } void MainWindow::updateActions() { SituationScene *scene = sceneList.at(currentSituation); bool selectedItems = !scene->selectedItems().isEmpty(); bool selectedBoats = !scene->selectedBoatModels().isEmpty(); bool selectedPoints = !scene->selectedPointModels().isEmpty(); bool selectedMarks = !scene->selectedMarkModels().isEmpty(); addBoatAction->setEnabled(selectedBoats || scene->state() == CREATE_BOAT); addPointAction->setEnabled(selectedPoints || scene->state() == CREATE_POINT); trimSailAction->setEnabled(selectedBoats); autotrimSailAction->setEnabled(selectedBoats); untrimSailAction->setEnabled(selectedBoats); togglePortOverlapAction->setEnabled(selectedBoats); toggleStarboardOverlapAction->setEnabled(selectedBoats); toggleHiddenAction->setEnabled(selectedBoats); toggleTextAction->setEnabled(selectedItems); flagMenu->setEnabled(selectedBoats); accelerationMenu->setEnabled(selectedBoats); toggleMarkSideAction->setEnabled(selectedMarks); toggleMarkArrowAction->setEnabled(selectedMarks); toggleMarkLabelAction->setEnabled(selectedMarks); setMarkColorAction->setEnabled(selectedMarks); editMarkLabelAction->setEnabled(selectedMarks); deleteTrackAction->setEnabled(selectedBoats); deleteAction->setEnabled(selectedItems); bool allPortSet = 1; bool allStarboardSet = 1; bool allHiddenSet = 1; bool allSpinBoat = 1; bool allSpinSet = 1; bool allTextSet = 1; bool allLaylinesSet = 1; bool allMarkArrowSet = 1; bool allMarkLabelSet = 1; int flagSize = ENUM_SIZE(Boats,Flag); bool allFlagSet[flagSize]; for(int i=0; i < flagSize; i++) { allFlagSet[i] = 1; } int accelerationSize = ENUM_SIZE(Boats,Acceleration); bool allAccelerationSet[accelerationSize]; for(int i=0; iselectedBoatModels()) { allPortSet = allPortSet && (boat->overlap() & Boats::port); allStarboardSet = allStarboardSet && (boat->overlap() & Boats::starboard); allHiddenSet = allHiddenSet && boat->hidden(); allSpinBoat = allSpinBoat && (boat->hasSpin()); allSpinSet = allSpinSet && (boat->hasSpin()) && (boat->spin()); for (int i = 0; i < flagSize; i++) { allFlagSet[i] = allFlagSet[i] && (boat->flag() == i); } for (int i=0; iacceleration() == i); } } togglePortOverlapAction->setChecked(selectedBoats && allPortSet); toggleStarboardOverlapAction->setChecked(selectedBoats && allStarboardSet); toggleHiddenAction->setChecked(selectedBoats && allHiddenSet); toggleSpinAction->setChecked(selectedBoats && allSpinSet); toggleSpinAction->setEnabled(selectedBoats && allSpinBoat); foreach(PositionModel *position, scene->selectedModels()) { allTextSet = allTextSet && (!position->text().isEmpty()); allLaylinesSet = allLaylinesSet && position->laylines(); } toggleTextAction->setEnabled(scene->selectedModels().size()==1); toggleTextAction->setChecked(selectedItems && allTextSet); for (int i = 0; i < flagSize; i++) { QAction *flagAction = flagMenu->actions()[i]; flagAction->setChecked(allFlagSet[i]); } for (int i=0; iactions()[i]; accelerationAction->setChecked(allAccelerationSet[i]); } toggleLaylinesAction->setChecked(selectedItems && allLaylinesSet); toggleLaylinesAction->setEnabled(selectedItems); foreach(MarkModel *mark, scene->selectedMarkModels()) { allMarkArrowSet = allMarkArrowSet && mark->arrowVisible(); allMarkLabelSet = allMarkLabelSet && mark->labelVisible(); } toggleMarkArrowAction->setChecked(allMarkArrowSet); toggleMarkLabelAction->setChecked(allMarkLabelSet); } void MainWindow::changeState(SceneState newState) { SituationView *view = viewList.at(currentSituation); switch(newState) { case CREATE_TRACK: view->setCursor(Qt::CrossCursor); statusbar->showMessage(tr("Create Track")); addTrackAction->setChecked(true); addBoatAction->setChecked(false); addMarkAction->setChecked(false); addPolyLineAction->setChecked(false); addPointAction->setChecked(false); animateAction->setChecked(false); break; case CREATE_BOAT: view->setCursor(Qt::CrossCursor); statusbar->showMessage(tr("Create Boat")); addTrackAction->setChecked(false); addBoatAction->setChecked(true); addMarkAction->setChecked(false); addPolyLineAction->setChecked(false); addPointAction->setChecked(false); animateAction->setChecked(false); break; case CREATE_MARK: view->setCursor(Qt::CrossCursor); statusbar->showMessage(tr("Create Mark")); addTrackAction->setChecked(false); addBoatAction->setChecked(false); addMarkAction->setChecked(true); addPolyLineAction->setChecked(false); addPointAction->setChecked(false); animateAction->setChecked(false); break; case CREATE_LINE: view->setCursor(Qt::CrossCursor); statusbar->showMessage(tr("Create Line")); addTrackAction->setChecked(false); addBoatAction->setChecked(false); addMarkAction->setChecked(false); addPolyLineAction->setChecked(true); addPointAction->setChecked(false); animateAction->setChecked(false); break; case CREATE_POINT: view->setCursor(Qt::CrossCursor); statusbar->showMessage(tr("Create Line")); addTrackAction->setChecked(false); addBoatAction->setChecked(false); addMarkAction->setChecked(false); addPolyLineAction->setChecked(false); addPointAction->setChecked(true); animateAction->setChecked(false); break; case ANIMATE: statusbar->showMessage(tr("Animate")); addTrackAction->setChecked(false); addBoatAction->setChecked(false); addMarkAction->setChecked(false); addPolyLineAction->setChecked(false); addPointAction->setChecked(false); animateAction->setChecked(true); break; default: view->unsetCursor(); statusbar->clearMessage(); addTrackAction->setChecked(false); addBoatAction->setChecked(false); addMarkAction->setChecked(false); addPolyLineAction->setChecked(false); addPointAction->setChecked(false); animateAction->setChecked(false); } updateActions(); } void MainWindow::cleanState(bool state) { SituationModel *situation = situationList.at(currentSituation); if (situation->fileName().isEmpty()) saveFileAction->setEnabled(false); else saveFileAction->setEnabled(!state); saveAsAction->setEnabled(!state); QString shownName = QFileInfo(situation->fileName()).fileName(); setWindowTitle(tr("%1 - %2 [*]").arg(tr("Boat Scenario")).arg(shownName)); if (!state) { tabWidget->setTabText(currentSituation,shownName.append(" *")); } else { tabWidget->setTabText(currentSituation,shownName); } setWindowModified(!state); } void MainWindow::createMenus() { recentMenu = new QMenu(this); for (int i = 0; i < maxRecent; ++i) { QAction * recentAction = new QAction(this); recentMenu->addAction(recentAction); connect(recentAction, SIGNAL(triggered()), this, SLOT(openRecent())); } fileMenu = new QMenu(this); menubar->addMenu(fileMenu); fileMenu->addAction(newFileAction); fileMenu->addAction(openFileAction); fileMenu->addMenu(recentMenu); fileMenu->addAction(saveFileAction); fileMenu->addAction(saveAsAction); fileMenu->addSeparator(); fileMenu->addAction(printAction); fileMenu->addAction(printPreviewAction); fileMenu->addAction(exportPdfAction); fileMenu->addAction(exportImageAction); #ifdef GIF_EXPORT fileMenu->addAction(exportAnimationAction); #endif fileMenu->addSeparator(); fileMenu->addAction(newTabAction); fileMenu->addAction(removeTabAction); fileMenu->addAction(restoreFilesAction); fileMenu->addSeparator(); fileMenu->addAction(exitAction); trackMenu = new QMenu(this); menubar->addMenu(trackMenu); trackMenu->addAction(addTrackAction); trackMenu->addAction(addBoatAction); trackMenu->addAction(addMarkAction); trackMenu->addAction(addPolyLineAction); trackMenu->addAction(addPointAction); trackMenu->addSeparator(); trackMenu->addAction(trimSailAction); trackMenu->addAction(autotrimSailAction); trackMenu->addAction(untrimSailAction); trackMenu->addAction(togglePortOverlapAction); trackMenu->addAction(toggleStarboardOverlapAction); trackMenu->addAction(toggleHiddenAction); trackMenu->addAction(toggleTextAction); int flagSize = ENUM_SIZE(Boats, Flag); flagMenu = new QMenu(this); QActionGroup *flagGroup = new QActionGroup(flagMenu); for (int i = 0; i < flagSize; i++) { QAction * flagAction = new QAction(ENUM_NAME(Boats, Flag, i), this); flagAction->setCheckable(true); flagAction->setData(i); flagGroup->addAction(flagAction); flagMenu->addAction(flagAction); connect(flagAction, SIGNAL(triggered()), this, SLOT(toggleFlag())); } trackMenu->addMenu(flagMenu); int accelerationSize = ENUM_SIZE(Boats, Acceleration); accelerationMenu = new QMenu(this); QActionGroup *accelerationGroup = new QActionGroup(accelerationMenu); for (int i = 0; i < accelerationSize; i++) { QAction * accelerationAction = new QAction(ENUM_NAME(Boats, Acceleration, i), this); accelerationAction->setCheckable(true); accelerationAction->setData(i); accelerationGroup->addAction(accelerationAction); accelerationMenu->addAction(accelerationAction); connect(accelerationAction, SIGNAL(triggered()), this, SLOT(toggleAcceleration())); } trackMenu->addMenu(accelerationMenu); trackMenu->addAction(toggleSpinAction); trackMenu->addSeparator(); trackMenu->addAction(toggleMarkSideAction); trackMenu->addAction(toggleMarkArrowAction); trackMenu->addAction(toggleMarkZoneAction); trackMenu->addAction(setMarkColorAction); trackMenu->addAction(toggleLaylinesAction); trackMenu->addAction(toggleMarkLabelAction); trackMenu->addAction(editMarkLabelAction); trackMenu->addSeparator(); trackMenu->addAction(deleteTrackAction); trackMenu->addAction(deleteAction); defaultPopup = new QMenu(this); defaultPopup->addAction(addTrackAction); defaultPopup->addAction(addMarkAction); defaultPopup->addAction(addPolyLineAction); boatPopup = new QMenu(this); boatPopup->addAction(addBoatAction); boatPopup->addSeparator(); boatPopup->addAction(trimSailAction); boatPopup->addAction(autotrimSailAction); boatPopup->addAction(untrimSailAction); boatPopup->addAction(togglePortOverlapAction); boatPopup->addAction(toggleStarboardOverlapAction); boatPopup->addAction(toggleHiddenAction); boatPopup->addAction(toggleTextAction); boatPopup->addMenu(flagMenu); boatPopup->addMenu(accelerationMenu); boatPopup->addAction(toggleSpinAction); boatPopup->addAction(toggleLaylinesAction); boatPopup->addSeparator(); boatPopup->addAction(deleteTrackAction); boatPopup->addAction(deleteAction); markPopup = new QMenu(this); markPopup->addAction(toggleTextAction); markPopup->addAction(toggleMarkSideAction); markPopup->addAction(toggleMarkArrowAction); markPopup->addAction(toggleMarkZoneAction); markPopup->addAction(toggleLaylinesAction); markPopup->addAction(setMarkColorAction); markPopup->addAction(toggleMarkLabelAction); markPopup->addAction(editMarkLabelAction); markPopup->addSeparator(); markPopup->addAction(deleteAction); pointPopup = new QMenu(this); pointPopup->addAction(addPointAction); pointPopup->addSeparator(); pointPopup->addAction(toggleTextAction); pointPopup->addAction(toggleLaylinesAction); pointPopup->addSeparator(); pointPopup->addAction(deleteAction); historyMenu = new QMenu(this); menubar->addMenu(historyMenu); historyMenu->addAction(undoAction); historyMenu->addAction(redoAction); animationMenu = new QMenu(this); menubar->addMenu(animationMenu); animationMenu->addAction(animateAction); animationMenu->addSeparator(); animationMenu->addAction(startAction); animationMenu->addAction(pauseAction); animationMenu->addAction(stopAction); animationMenu->addAction(loopAction); zoomMenu = new QMenu(this); menubar->addMenu(zoomMenu); zoomMenu->addAction(zoomInAction); zoomMenu->addAction(zoomFitAction); zoomMenu->addAction(zoomOutAction); viewMenu = new QMenu(this); menubar->addMenu(viewMenu); viewMenu->addAction(toggleMainToolbarAction); viewMenu->addAction(toggleAnimationToolbarAction); viewMenu->addAction(toggleScenarioDockAction); aboutMenu = new QMenu(this); menubar->addMenu(aboutMenu); langMenu = new QMenu(this); QActionGroup *langGroup = new QActionGroup(langMenu); QDir dir(TRANSLATEDIR); QStringList fileNames = dir.entryList(QStringList("*.qm"), QDir::Files, QDir::Name); fileNames.prepend("boats_en.qm"); QMutableStringListIterator i(fileNames); while (i.hasNext()) { i.next(); QRegExp rx("boats_(.+)\\.qm"); rx.indexIn(i.value()); QLocale locale(rx.cap(1)); QAction *langAction = new QAction( QLocale::languageToString(locale.language()), this); langAction->setCheckable(true); langAction->setData(locale.name()); langGroup->addAction(langAction); langMenu->addAction(langAction); connect(langAction, SIGNAL(triggered()), this, SLOT(toggleLang())); } aboutMenu->addMenu(langMenu); aboutMenu->addAction(aboutAction); toolbar->addAction(newFileAction); toolbar->addAction(openFileAction); toolbar->addAction(saveFileAction); toolbar->addAction(saveAsAction); toolbar->addAction(exportImageAction); #ifdef GIF_EXPORT toolbar->addAction(exportAnimationAction); #endif toolbar->addSeparator(); toolbar->addAction(undoAction); toolbar->addAction(redoAction); toolbar->addSeparator(); toolbar->addAction(addTrackAction); toolbar->addAction(addBoatAction); toolbar->addAction(addMarkAction); toolbar->addAction(addPolyLineAction); toolbar->addAction(addPointAction); toolbar->addSeparator(); toolbar->addAction(animateAction); toolbar->addSeparator(); toolbar->addAction(zoomOutAction); toolbar->addAction(zoomFitAction); toolbar->addAction(zoomInAction); toolbar->addSeparator(); lookDirectionSlider = new QSlider(Qt::Horizontal); lookDirectionSlider->setMaximum(360); lookDirectionSlider->setSingleStep(15); lookDirectionSlider->setTickInterval(15); lookDirectionSlider->setTickPosition(QSlider::TicksBelow); toolbar->addWidget(lookDirectionSlider); tiltSlider = new QSlider(Qt::Horizontal); tiltSlider->setMinimum(0); tiltSlider->setMaximum(90); tiltSlider->setSingleStep(15); tiltSlider->setTickInterval(15); tiltSlider->setTickPosition(QSlider::TicksBelow); toolbar->addWidget(tiltSlider); animationSlider = new QSlider(Qt::Horizontal, this); animationSlider->setTickInterval(2000); animationSlider->setTickPosition(QSlider::TicksBelow); animationSlider->setSingleStep(400); animationSlider->setPageStep(2000); animationSlider->setEnabled(false); animationBar->addAction(startAction); animationBar->addAction(pauseAction); animationBar->addAction(stopAction); animationBar->addAction(loopAction); animationBar->addSeparator(); animationBar->addWidget(animationSlider); } void MainWindow::createDocks() { QScrollArea *area = new QScrollArea(this); area->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); area->setWidgetResizable(true); area->setWidget(situationWidget); situationDock->setWidget(area); situationDock->setFeatures(QDockWidget::NoDockWidgetFeatures); } void MainWindow::newTab() { SituationModel *situation = new SituationModel(this); SituationScene *scene = new SituationScene(situation); SituationView *view =new SituationView(scene); situationList.append(situation); sceneList.append(scene); scene->setDefaultPopup(defaultPopup); scene->setBoatPopup(boatPopup); scene->setMarkPopup(markPopup); scene->setPointPopup(pointPopup); viewList.append(view); tabWidget->addTab(view, ""); tabWidget->setCurrentIndex(situationList.size()-1); view->setFocus(); view->setMouseTracking(true); if (situationList.size() > 1) { removeTabAction->setEnabled(true); removeTabButton->setEnabled(true); } } void MainWindow::unsetTab() { if (situationList.size() == 1) { return; } SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); if (scene->state() == ANIMATE) { scene->setState(NO_STATE); } disconnect(situation->undoStack(), 0, 0, 0); disconnect(scene, 0, this, 0); disconnect(undoAction, 0, 0, 0); disconnect(redoAction, 0, 0, 0); disconnect(zoomInAction, 0, 0, 0); disconnect(zoomOutAction, 0, 0, 0); disconnect(zoomFitAction, 0, 0, 0); disconnect(lookDirectionSlider, 0, 0, 0); disconnect(lookDirectionSlider); disconnect(tiltSlider, 0, 0, 0); disconnect(tiltSlider); situationWidget->unSetSituation(); } void MainWindow::setTab(int index) { unsetTab(); currentSituation = index; SituationModel *situation = situationList.at(index); SituationScene *scene = sceneList.at(index); SituationView *view = viewList.at(index); connect(undoAction, SIGNAL(triggered()), situation->undoStack(), SLOT(undo())); connect(situation->undoStack(), SIGNAL(canUndoChanged(bool)), undoAction, SLOT(setEnabled(bool))); undoAction->setEnabled(situation->undoStack()->canUndo()), connect(redoAction, SIGNAL(triggered()), situation->undoStack(), SLOT(redo())); connect(situation->undoStack(), SIGNAL(canRedoChanged(bool)), redoAction, SLOT(setEnabled(bool))); redoAction->setEnabled(situation->undoStack()->canRedo()); connect(situation->undoStack(), SIGNAL(cleanChanged(bool)), this, SLOT(cleanState(bool))); cleanState(situation->undoStack()->isClean()); connect(zoomInAction, SIGNAL(triggered()), view, SLOT(zoomIn())); connect(zoomOutAction, SIGNAL(triggered()), view, SLOT(zoomOut())); connect(zoomFitAction, SIGNAL(triggered()), view, SLOT(zoomFit())); connect(view, SIGNAL(lookDirectionChanged(int)), lookDirectionSlider, SLOT(setValue(int))); connect(view, SIGNAL(tiltChanged(int)), tiltSlider, SLOT(setValue(int))); lookDirectionSlider->setValue(situation->lookDirection()); tiltSlider->setValue(situation->tilt()); connect(lookDirectionSlider, SIGNAL(valueChanged(int)), this, SLOT(setLookAt())); connect(tiltSlider, SIGNAL(valueChanged(int)), this, SLOT(setLookAt())); situationWidget->setSituation(situation); connect(scene, SIGNAL(stateChanged(SceneState)), this, SLOT(changeState(SceneState))); changeState(scene->state()); connect(scene, SIGNAL(selectedModelsChanged()), this, SLOT(updateActions())); updateActions(); } void MainWindow::removeTab() { int index = tabWidget->currentIndex(); SituationModel *situation = situationList.at(index); SituationScene *scene = sceneList.at(index); SituationView *view = viewList.at(index); if (!maybeSave(situation)) { return; } if (index == situationList.size() - 1) { tabWidget->setCurrentIndex(index - 1); } else if (index != situationList.size() - 2) { tabWidget->setCurrentIndex(index + 1); } situationList.removeAt(index); sceneList.removeAt(index); viewList.removeAt(index); tabWidget->removeTab(index); view->deleteLater(); scene->deleteLater(); situation->deleteLater(); if (situationList.size() == 1) { removeTabAction->setEnabled(false); removeTabButton->setEnabled(false); } } void MainWindow::writeSettings() { QSettings settings("Boats"); settings.beginGroup("MainWindow"); settings.setValue("size", size()); settings.setValue("pos", pos()); settings.setValue("AnimationBar", animationBar->isVisible()); settings.setValue("AnimationBarArea", toolBarArea(animationBar)); settings.setValue("ToolBar", toolbar->isVisible()); settings.setValue("ToolBarArea", toolBarArea(toolbar)); settings.setValue("ScenarioDock", situationDock->isVisible()); QStringList fileList; foreach(SituationModel *situation, situationList) { if (!situation->fileName().isEmpty()) { fileList.append(situation->fileName()); } } settings.setValue("recentList", recentList); settings.setValue("fileList",fileList); settings.setValue("filePath", filePath); settings.endGroup(); } void MainWindow::readSettings() { QSettings settings("Boats"); settings.beginGroup("MainWindow"); QSize size = settings.value("size").toSize(); QPoint pos = settings.value("pos").toPoint(); if ( (size.isValid()) && (!pos.isNull()) ) { resize(size); move(pos); } else { showMaximized(); } toggleAnimationToolbarAction->setChecked(settings.value("AnimationBar", true).toBool()); addToolBar((Qt::ToolBarArea)(settings.value("AnimationBarArea").toInt()), animationBar); toggleMainToolbarAction->setChecked(settings.value("ToolBar", true).toBool()); addToolBar((Qt::ToolBarArea)(settings.value("ToolBarArea").toInt()), toolbar); toggleScenarioDockAction->setChecked(settings.value("ScenarioDock", true).toBool()); recentList = settings.value("recentList").toStringList(); updateRecentList(); fileList = settings.value("fileList").toStringList(); filePath = settings.value("filePath").toString(); settings.endGroup(); } void MainWindow::updateRecentList() { int numRecentFiles = qMin(recentList.size(), maxRecent); for (int i = 0; i < numRecentFiles; ++i) { QString text = tr("&%1 %2").arg(i + 1).arg(QFileInfo(recentList[i]).fileName()); QAction * recentAction = recentMenu->actions()[i]; recentAction->setText(text); recentAction->setData(i); recentAction->setVisible(true); } for (int j = numRecentFiles; j < maxRecent; ++j) { QAction * recentAction = recentMenu->actions()[j]; recentAction->setVisible(false); } } bool MainWindow::maybeSave(SituationModel *situation) { if (!situation->undoStack()->isClean()) { QString shownName = QFileInfo(situation->fileName()).fileName(); QMessageBox::StandardButton ret; ret = QMessageBox::warning(this, shownName, tr("The document %1 has been modified.\n" "Do you want to save your changes?").arg(shownName), QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel); if (ret == QMessageBox::Save) { return saveSituation(situation, ""); } else if (ret == QMessageBox::Cancel) { return false; } } return true; } void MainWindow::closeEvent(QCloseEvent *event) { SituationScene *scene = sceneList.at(currentSituation); bool animated = (scene->state() == ANIMATE); if (animated) { scene->setState(NO_STATE); } foreach(SituationModel *situation, situationList) { if (!maybeSave(situation)) { event->ignore(); return; } } writeSettings(); event->accept(); } void MainWindow::changeEvent(QEvent *event) { if(event->type() == QEvent::LanguageChange) { newFileAction->setText(tr("&New File")); newFileAction->setShortcut(tr("Ctrl+N")); openFileAction->setText(tr("&Open File...")); openFileAction->setShortcut(tr("Ctrl+O")); saveFileAction->setText(tr("&Save File")); saveFileAction->setShortcut(tr("Ctrl+S")); saveAsAction->setText(tr("Save &As...")); saveAsAction->setShortcut(tr("Ctrl+Shift+S")); newTabAction->setText(tr("New &Tab")); newTabAction->setShortcut(tr("Ctrl+T")); removeTabAction->setText(tr("&Close Tab")); removeTabAction->setShortcut(tr("Ctrl+W")); restoreFilesAction->setText(tr("&Restore Last Session...")); printAction->setText(tr("&Print...")); printAction->setShortcut(tr("Ctrl+P")); printPreviewAction->setText(tr("Print P&review...")); printPreviewAction->setShortcut(tr("Ctrl+R")); exportPdfAction->setText(tr("&Export Pdf...")); exportPdfAction->setShortcut(tr("Ctrl+E")); exportImageAction->setText(tr("Export &Image...")); exportImageAction->setShortcut(tr("Ctrl+I")); #ifdef GIF_EXPORT exportAnimationAction->setText(tr("Export Ani&mation...")); exportAnimationAction->setShortcut(tr("Ctrl+V")); #endif exitAction->setText(tr("E&xit")); exitAction->setShortcut(tr("Ctrl+Q")); exitAction->setStatusTip(tr("Exit the application")); addTrackAction->setText(tr("Create &Track")); addTrackAction->setShortcut(tr("Ctrl+Ins")); addBoatAction->setText(tr("Create &Boat")); addBoatAction->setShortcut(tr("Ins")); addMarkAction->setText(tr("Create &Mark")); addMarkAction->setShortcut(tr("Alt+Ins")); addPolyLineAction->setText(tr("Create &PolyLine")); addPolyLineAction->setShortcut(tr("Ctrl+Alt+Ins")); addPointAction->setText(tr("Create Poin&t")); addPointAction->setShortcut(tr("Ctrl+T")); trimSailAction->setText(tr("Trim Sail")); trimSailAction->setShortcut(tr("<")); autotrimSailAction->setText(tr("Auto Trim")); autotrimSailAction->setShortcut(tr("=")); untrimSailAction->setText(tr("Untrim Sail")); untrimSailAction->setShortcut(tr(">")); togglePortOverlapAction->setText(tr("&Port Overlap")); togglePortOverlapAction->setShortcut(tr("Alt+<")); toggleStarboardOverlapAction->setText(tr("&Starboard Overlap")); toggleStarboardOverlapAction->setShortcut(tr("Alt+>")); toggleHiddenAction->setText(tr("&Hide")); toggleHiddenAction->setShortcut(tr("Alt+D")); toggleTextAction->setText(tr("&Text")); toggleTextAction->setShortcut(tr("Alt+T")); toggleSpinAction->setText(tr("Toggle &Spinnaker")); toggleSpinAction->setShortcut(tr("Alt+S")); toggleMarkSideAction->setText(tr("Toggle &Mark Side")); toggleMarkSideAction->setShortcut(tr("Alt+M")); toggleMarkArrowAction->setText(tr("Toggle Mark Arro&w")); toggleMarkArrowAction->setShortcut(tr("Alt+W")); toggleMarkZoneAction->setText(tr("Toggle Mark &Zone")); toggleMarkZoneAction->setShortcut(tr("Alt+Z")); setMarkColorAction->setText(tr("Set Mark &Color")); setMarkColorAction->setShortcut(tr("Alt+C")); toggleLaylinesAction->setText(tr("Toggle &Laylines")); toggleLaylinesAction->setShortcut(tr("Alt+L")); toggleMarkLabelAction->setText(tr("Toggle Mark &Label")); toggleMarkLabelAction->setShortcut(tr("Alt+L")); editMarkLabelAction->setText(tr("&Edit Mark Label")); editMarkLabelAction->setShortcut(tr("Alt+E")); deleteTrackAction->setText(tr("Delete Track")); deleteTrackAction->setShortcut(tr("Ctrl+Del")); deleteAction->setText(tr("&Delete Selection")); deleteAction->setShortcut(tr("Del")); animateAction->setText(tr("&Animate")); animateAction->setShortcut(tr("Ctrl+A")); startAction->setText(tr("&Play")); startAction->setShortcut(tr("P")); pauseAction->setText(tr("&Pause")); pauseAction->setShortcut(tr("M")); stopAction->setText(tr("&Stop")); stopAction->setShortcut(tr("Space")); loopAction->setText(tr("&Loop")); loopAction->setShortcut(tr("L")); undoAction->setText(tr("&Undo")); undoAction->setShortcut(tr("Ctrl+Z")); redoAction->setText(tr("&Redo")); QList redoShortcuts; redoShortcuts << tr("Ctrl+Y") << tr("Shift+Ctrl+Z"); redoAction->setShortcuts(redoShortcuts); zoomInAction->setText(tr("Zoom &In")); zoomInAction->setShortcut(tr("Ctrl++")); zoomOutAction->setText(tr("Zoom &Out")); zoomOutAction->setShortcut(tr("Ctrl+-")); zoomFitAction->setText(tr("Zoom &Fit")); zoomFitAction->setShortcut(tr("Ctrl+F")); toggleMainToolbarAction->setText(tr("Main Toolbar")); toggleAnimationToolbarAction->setText(tr("Animation Toolbar")); toggleScenarioDockAction->setText(tr("Scenario Dock")); aboutAction->setText(tr("&About")); recentMenu->setTitle(tr("&Recent")); fileMenu->setTitle(tr("&File")); trackMenu->setTitle(tr("&Edit")); flagMenu->setTitle(tr("&Flag")); accelerationMenu->setTitle(tr("&Acceleration")); historyMenu->setTitle(tr("&History")); animationMenu->setTitle(tr("&Animation")); zoomMenu->setTitle(tr("&Zoom")); viewMenu->setTitle(tr("&View")); aboutMenu->setTitle(tr("&Help")); langMenu->setTitle(tr("Choose &Language")); } else { QMainWindow::changeEvent(event); } } void MainWindow::newFile() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); SituationView *view = viewList.at(currentSituation); if (maybeSave(situation)) { scene->setState(NO_STATE); situation->undoStack()->setIndex(0); setCurrentFile(situation, ""); situation->undoStack()->clear(); situation->wind().clearWind(); situationWidget->unSetSituation(); situationWidget->setSituation(situation); view->centerOn(0,0); view->resetMatrix(); } } void MainWindow::openFile() { QString fileName = QFileDialog::getOpenFileName(this, tr("Open Scenario File"), filePath, tr("xmlscenario Files (*.xbs)")); if (fileName.isEmpty()) return; filePath = QFileInfo(fileName).absolutePath(); openFile(fileName); } void MainWindow::openRecent() { QAction *action = qobject_cast(sender()); if (action) { int item = action->data().toInt(); if (recentList.size() > item) { openFile(recentList[item]); } } } void MainWindow::restoreFiles() { openFiles(fileList); } void MainWindow::openFiles(QStringList fileList) { foreach (const QString fileName, fileList) { std::cout << "opening " << fileName.toStdString() << std::endl; QFile file(fileName); if (file.open(QFile::ReadOnly | QFile::Text)) { openFile(fileName, fileList.first() != fileName); } } } void MainWindow::openFile(const QString &fileName, bool inNewTab) { if (inNewTab) { // create new tab newTab(); tabWidget->setCurrentIndex(situationList.size() - 1); } else { // delete situation; newFile(); } SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); SituationView *view = viewList.at(currentSituation); QFile file(fileName); if (!file.open(QFile::ReadOnly | QFile::Text)) { QMessageBox::warning(this, tr("Open Scenario File"), tr("Cannot read file %1:\n%2.") .arg(fileName) .arg(file.errorString())); return; } XmlSituationReader reader(situation); if (!reader.read(&file)) { QMessageBox::warning(this, tr("Open Scenario file"), tr("Parse error in file %1 at line %2, column %3:\n%4") .arg(fileName) .arg(reader.lineNumber()) .arg(reader.columnNumber()) .arg(reader.errorString())); return; } situationWidget->update(); setCurrentFile(situation, fileName); view->centerOn(scene->itemsBoundingRect().center()); statusbar->showMessage(tr("File loaded"), 2000); } bool MainWindow::saveSituation(SituationModel *situation, QString fileName) { QString name = fileName; if (name.isEmpty()) { QString defaultFile; if (situation->fileName().isEmpty()) { defaultFile = QDateTime::currentDateTime().toString("yyMMdd") + ".xbs"; } else { defaultFile = situation->fileName(); } name = QFileDialog::getSaveFileName(this, tr("Save Scenario"), defaultFile, tr("xmlscenario Files (*.xbs)"), NULL, QFileDialog::DontConfirmOverwrite); if (name.isEmpty()) { return false; } if (QFileInfo(name).suffix().isEmpty()) name.append(".xbs"); if (QFile::exists(name)) { if (QMessageBox::warning(this, tr("Save Scenario"), tr("%1 already exists.\nDo you want to replace it?") .arg(QFileInfo(name).baseName()), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No) { return false; } } } QFile file(name); if (!file.open(QFile::WriteOnly | QFile::Text)) { QMessageBox::warning(this, tr("Save Scenario"), tr("Cannot write file %1:\n%2.") .arg(fileName) .arg(file.errorString())); return false; } XmlSituationWriter writer(situation); writer.writeFile(&file); setCurrentFile(situation, name); statusbar->showMessage(tr("File saved"), 2000); return true; } bool MainWindow::saveFile() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); bool animated = (scene->state() == ANIMATE); if (animated) { scene->setState(NO_STATE); } bool saved = saveSituation(situation, situation->fileName()); if (animated) { animate(true); } return saved; } bool MainWindow::saveAs() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); bool animated = (scene->state() == ANIMATE); if (animated) { scene->setState(NO_STATE); } bool saved = saveSituation(situation, ""); if (animated) { animate(true); } return saved; } void MainWindow::print() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); SituationView *view = viewList.at(currentSituation); QPrinter printer(QPrinter::HighResolution); QPrintDialog *dialog = new QPrintDialog(&printer, this); dialog->setWindowTitle(tr("Print Document")); if (dialog->exec() != QDialog::Accepted) { return; } scene->clearSelection(); SituationPrint printSituation(situation, view); printSituation.render(printer.paperRect(QPrinter::Millimeter).adjusted(20, 20, -20, -20)); printSituation.print(&printer); } void MainWindow::printPreview() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); SituationView *view = viewList.at(currentSituation); scene->clearSelection(); SituationPrint printSituation(situation, view); QPrinter printer(QPrinter::HighResolution); QPrintPreviewDialog dialog(&printer); printSituation.render(printer.paperRect(QPrinter::Millimeter).adjusted(20, 20, -20, -20)); connect(&dialog, SIGNAL(paintRequested(QPrinter*)), &printSituation, SLOT(print(QPrinter*))); dialog.exec(); } void MainWindow::exportPdf() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); SituationView *view = viewList.at(currentSituation); QString defaultName(situation->fileName()); defaultName.chop(4); QString fileName = QFileDialog::getSaveFileName(this, "Export to PDF", defaultName, "PDF Files (*.pdf)"); if (fileName.isEmpty()) { return; } if (QFileInfo(fileName).suffix().isEmpty()) fileName.append(".pdf"); QPrinter printer(QPrinter::HighResolution); printer.setOutputFormat(QPrinter::PdfFormat); printer.setOutputFileName(fileName); scene->clearSelection(); SituationPrint printSituation(situation, view); printSituation.render(printer.paperRect(QPrinter::Millimeter).adjusted(20, 20, -20, -20)); printSituation.print(&printer); } void MainWindow::exportImage() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); SituationView *view = viewList.at(currentSituation); QString defaultName(situation->fileName()); defaultName.chop(4); QList formatsList = QImageWriter::supportedImageFormats(); #if defined(Q_WS_MAC) QString formats("PNG Image Files (*.png)"); #else QString formats; for (int i=0; iclearSelection(); QPixmap pixmap = view->screenShot(); QFile file(fileName); if (!file.open(QFile::WriteOnly | QFile::Text)) { QMessageBox::warning(this, tr("Export Image"), tr("Cannot write file %1:\n%2.") .arg(fileName) .arg(file.errorString())); return; } pixmap.save(fileName); } #ifdef GIF_EXPORT void MainWindow::exportAnimation() { SituationModel *situation = situationList.at(currentSituation); SituationView *view = viewList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QString defaultName(situation->fileName()); defaultName.chop(4); QString format("GIF Files (*.gif)"); QString ext; QString fileName = QFileDialog::getSaveFileName(this, tr("Export Animation"), defaultName, format, &ext); if (fileName.isEmpty()) { return; } // if no provided extension or incorrect extension, use selected filter int dotIndex = fileName.lastIndexOf("."); QString baseName = fileName.left(dotIndex); QString newExt = fileName.right(fileName.size()-dotIndex-1); if (!newExt.toAscii().contains("gif")) { fileName.append(".gif"); } GifWriter *writer = new GifWriter(); animate(true, false); QProgressDialog progress(tr("Exporting Animation..."), tr("Abort"), 0, scene->animation()->duration(), this); progress.setWindowModality(Qt::WindowModal); statusbar->showMessage("Exporting animation"); scene->animation()->setCurrentTime(scene->animation()->duration()/2); QPixmap pixmap = view->screenShot(); QImage shot = pixmap.toImage().convertToFormat(QImage::Format_Indexed8); writer->setColorMap(shot); QList imageList; for (int i=0; i<=scene->animation()->duration(); i+=80) { scene->animation()->setCurrentTime(i); pixmap = view->screenShot(); QImage *image = new QImage(pixmap.toImage() .convertToFormat(QImage::Format_Indexed8, writer->colormap())); imageList.append(image); progress.setValue(i); if (progress.wasCanceled()) { break; } } if (!progress.wasCanceled()) { QFile file(fileName); if (!file.open(QFile::WriteOnly)) { QMessageBox::warning(this, tr("Export Animation"), tr("Cannot write file %1:\n%2.") .arg(fileName) .arg(file.errorString())); return; } writer->setDevice(&file); writer->write(imageList); } animate(false); } #endif void MainWindow::setCurrentFile(SituationModel *situation, const QString &fileName) { situation->setFileName(fileName); situation->undoStack()->setClean(); if (!fileName.isEmpty()) { recentList.removeAll(fileName); recentList.prepend(fileName); while (recentList.size() > maxRecent) recentList.removeLast(); updateRecentList(); } } void MainWindow::addTrack() { SituationScene *scene = sceneList.at(currentSituation); if(scene->state() == CREATE_TRACK) { scene->setState(NO_STATE); } else { scene->setState(CREATE_TRACK); } } void MainWindow::deleteTrack() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); // TODO trick to delete first selected track if (!scene->selectedBoatModels().isEmpty()) { BoatModel *boat = scene->selectedBoatModels()[0]; TrackModel * track = boat->track(); situation->undoStack()->push(new DeleteTrackUndoCommand(situation, track)); } } void MainWindow::addBoat() { SituationScene *scene = sceneList.at(currentSituation); if (scene->state() == CREATE_BOAT) { scene->setState(NO_STATE); } else { scene->setState(CREATE_BOAT); } } void MainWindow::deleteModels() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); foreach (BoatModel *boat, scene->selectedBoatModels()) { TrackModel* track = boat->track(); if (track->size() > 1) { situation->undoStack()->push(new DeleteBoatUndoCommand(track, boat)); } else { situation->undoStack()->push(new DeleteTrackUndoCommand(situation, track)); } } foreach (MarkModel *mark, scene->selectedMarkModels()) { situation->undoStack()->push(new DeleteMarkUndoCommand(situation, mark)); } foreach (PointModel *point, scene->selectedPointModels()) { PolyLineModel *polyLine = point->polyLine(); if (polyLine->size() > 1) { situation->undoStack()->push(new DeletePointUndoCommand(polyLine, point)); } else { situation->undoStack()->push(new DeletePolyLineUndoCommand(situation, polyLine)); } } } void MainWindow::addMark() { SituationScene *scene = sceneList.at(currentSituation); if (scene->state() == CREATE_MARK) { scene->setState(NO_STATE); } else { scene->setState(CREATE_MARK); } } void MainWindow::addPolyLine() { SituationScene *scene = sceneList.at(currentSituation); if (scene->state() == CREATE_LINE) { scene->setState(NO_STATE); } else { scene->setState(CREATE_LINE); } } void MainWindow::addPoint() { SituationScene *scene = sceneList.at(currentSituation); if (scene->state() == CREATE_POINT) { scene->setState(NO_STATE); } else { scene->setState(CREATE_POINT); } } void MainWindow::trimSail() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { qreal trim = boatList[0]->trim(); qreal heading = fmod(boatList[0]->heading() - boatList[0]->wind() + 360, 360); if(heading < 0) heading +=360; if (heading < 180) { trim -= 5; } else { trim += 5; } situation->undoStack()->push(new TrimBoatUndoCommand(boatList, trim)); } } void MainWindow::autotrimSail() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new TrimBoatUndoCommand(boatList, 0)); } } void MainWindow::untrimSail() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { qreal trim = boatList[0]->trim(); qreal heading = fmod(boatList[0]->heading() - boatList[0]->wind() + 360, 360); if(heading < 0) heading +=360; if (heading < 180) { trim += 5; } else { trim -= 5; } situation->undoStack()->push(new TrimBoatUndoCommand(boatList, trim)); } } void MainWindow::togglePortOverlap() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new OverlapBoatUndoCommand(situation, boatList, Boats::port)); } } void MainWindow::toggleStarboardOverlap() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new OverlapBoatUndoCommand(situation, boatList, Boats::starboard)); } } void MainWindow::toggleHidden() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new HiddenBoatUndoCommand(situation, boatList, !boatList.first()->hidden())); } } void MainWindow::toggleText() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList modelList = scene->selectedModels(); if (! modelList.isEmpty()) { QString text; if (modelList.first()->text().isEmpty()) { text = tr("Protest!"); } situation->undoStack()->push(new SetTextUndoCommand(modelList.first(), text)); } } void MainWindow::toggleFlag() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QAction *action = qobject_cast(sender()); if (action) { Boats::Flag flag = (Boats::Flag)action->data().toInt(); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new FlagBoatUndoCommand(situation, boatList, flag)); } } } void MainWindow::toggleAcceleration() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QAction *action = qobject_cast(sender()); if (action) { Boats::Acceleration acceleration = (Boats::Acceleration)action->data().toInt(); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new AccelerateBoatUndoCommand(situation, boatList, acceleration)); } } } void MainWindow::toggleSpin() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList boatList = scene->selectedBoatModels(); if (! boatList.isEmpty()) { situation->undoStack()->push(new SpinBoatUndoCommand(situation, boatList, !boatList.first()->spin())); } } void MainWindow::toggleMarkSide() { SituationModel *situation = situationList.at(tabWidget->currentIndex()); SituationScene *scene = sceneList.at(tabWidget->currentIndex()); QList markList = scene->selectedMarkModels(); if (! markList.isEmpty()) { situation->undoStack()->push(new ToggleMarkSideUndoCommand(markList)); } else { situation->undoStack()->push(new ToggleMarkSideUndoCommand(situation->marks())); } } void MainWindow::toggleMarkArrow() { SituationModel *situation = situationList.at(tabWidget->currentIndex()); SituationScene *scene = sceneList.at(tabWidget->currentIndex()); QList markList = scene->selectedMarkModels(); if (! markList.isEmpty()) { situation->undoStack()->push(new ToggleMarkArrowUndoCommand(markList)); } else { situation->undoStack()->push(new ToggleMarkArrowUndoCommand(situation->marks())); } } void MainWindow::toggleMarkZone() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList markList = scene->selectedMarkModels(); if (! markList.isEmpty()) { situation->undoStack()->push(new ZoneMarkUndoCommand(situation, markList)); } else { situation->undoStack()->push(new ZoneMarkUndoCommand(situation, situation->marks())); } } void MainWindow::setMarkColor() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList markList = scene->selectedMarkModels(); if (! markList.isEmpty()) { ColorPickerWidget colorEditor; colorEditor.setColor( markList.first()->color()); situation->undoStack()->push(new ColorMarkUndoCommand(situation, markList, colorEditor.color())); } } void MainWindow::toggleMarkLabel() { SituationModel *situation = situationList.at(tabWidget->currentIndex()); SituationScene *scene = sceneList.at(tabWidget->currentIndex()); QList markList = scene->selectedMarkModels(); if (! markList.isEmpty()) { situation->undoStack()->push(new ToggleMarkLabelUndoCommand(markList)); } else { situation->undoStack()->push(new ToggleMarkLabelUndoCommand(situation->marks())); } } void MainWindow::editMarkLabel() { SituationModel *situation = situationList.at(tabWidget->currentIndex()); SituationScene *scene = sceneList.at(tabWidget->currentIndex()); QList markList = scene->selectedMarkModels(); if (! markList.isEmpty()) { QString oldText = markList.first()->labelText(); bool ok; QString newText = QInputDialog::getText(this, tr("Edit mark label"), tr("Label text:"), QLineEdit::Normal, oldText, &ok); if (ok) { situation->undoStack()->push(new SetMarkLabelUndoCommand(markList.first(), newText)); } } } void MainWindow::toggleLaylines() { SituationModel *situation = situationList.at(currentSituation); SituationScene *scene = sceneList.at(currentSituation); QList modelList = scene->selectedModels(); if (! modelList.isEmpty()) { situation->undoStack()->push(new SetLaylinesUndoCommand(modelList, !modelList.first()->laylines())); } } void MainWindow::setLookAt() { SituationModel *situation = situationList.at(currentSituation); situation->undoStack()->push(new SetLookAtUndoCommand(situation, lookDirectionSlider->value(), tiltSlider->value())); } void MainWindow::toggleLang() { QAction *action = qobject_cast(sender()); if (action) { qApp->removeTranslator(qtTranslator); qApp->removeTranslator(translator); createTranslations(action->data().toString()); } } void MainWindow::animate(bool state, bool interactive) { SituationScene *scene = sceneList.at(currentSituation); if (state) { if (scene->state() != ANIMATE) { scene->setState(ANIMATE); scene->clearSelection(); scene->setAnimation(); connect(scene->animation(), SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)), this, SLOT(changeAnimationState(QAbstractAnimation::State, QAbstractAnimation::State))); connect(scene->animation(), SIGNAL(timeChanged(int)), animationSlider, SLOT(setValue(int))); connect(animationSlider, SIGNAL(valueChanged(int)), scene->animation(), SLOT(setCurrentTime(int))); scene->animation()->setCurrentTime(0); if (interactive) { if (!toggleAnimationToolbarAction->isChecked()) { toggleAnimationToolbarAction->setChecked(true); } animationSlider->setRange(0,scene->animation()->duration()); animationSlider->setEnabled(true); startAction->setEnabled(true); loopAction->setEnabled(true); } } } else { if (scene->state() == ANIMATE) { scene->setState(NO_STATE); scene->unSetAnimation(); disconnect(this, SLOT(changeAnimationState(QAbstractAnimation::State,QAbstractAnimation::State))); disconnect(animationSlider, SLOT(setValue(int))); disconnect(scene->animation(), SLOT(setCurrentTime(int))); animationSlider->setEnabled(false); scene->animation()->stop(); startAction->setEnabled(false); stopAction->setEnabled(false); loopAction->setEnabled(false); } } } void MainWindow::play() { if (debugLevel & 1 << ANIMATION) std::cout << "playing" << std::endl; SituationScene *scene = sceneList.at(currentSituation); pauseAction->setChecked(false); scene->animation()->start(); } void MainWindow::pause(bool pause) { SituationScene *scene = sceneList.at(currentSituation); if (pause) { if (debugLevel & 1 << ANIMATION) std::cout << "pausing" << std::endl; scene->animation()->setPaused(true); } else { if (debugLevel & 1 << ANIMATION) std::cout << "resuming" << std::endl; scene->animation()->setPaused(false); } } void MainWindow::stop() { if (debugLevel & 1 << ANIMATION) std::cout << "stopping" << std::endl; SituationScene *scene = sceneList.at(currentSituation); pauseAction->setChecked(false); scene->animation()->stop(); scene->animation()->setCurrentTime(0); } void MainWindow::loop(bool loop) { SituationScene *scene = sceneList.at(currentSituation); if (loop) { if (debugLevel & 1 << ANIMATION) std::cout << "loop play" << std::endl; scene->animation()->setLoopCount(0); } else { if (debugLevel & 1 << ANIMATION) std::cout << "single play" << std::endl; scene->animation()->setLoopCount(1); } } void MainWindow::changeAnimationState(QAbstractAnimation::State newState, QAbstractAnimation::State) { switch(newState) { case QAbstractAnimation::Running: if (debugLevel & 1 << ANIMATION) std::cout << "state running" << std::endl; startAction->setEnabled(false); pauseAction->setEnabled(true); stopAction->setEnabled(true); animationSlider->blockSignals(true); break; case QAbstractAnimation::Paused: if (debugLevel & 1 << ANIMATION) std::cout << "state paused" << std::endl; startAction->setEnabled(true); pauseAction->setEnabled(true); stopAction->setEnabled(true); animationSlider->blockSignals(false); break; case QAbstractAnimation::Stopped: if (debugLevel & 1 << ANIMATION) std::cout << "state not running" << std::endl; startAction->setEnabled(true); pauseAction->setEnabled(false); stopAction->setEnabled(false); animationSlider->blockSignals(false); break; } } void MainWindow::about() { QMessageBox::about(this, tr("About Boat Scenario"), QString("
" "

Boat Scenario - a Race Scenario drawing tool.

" "

Version %1

" "

Copyright (C) 2008-2011 Thibaut GRIDEL

" "

" "

visit http://boats.sf.net

" "

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.

").arg(VERSION)); } boats-201307/mainwindow.h000066400000000000000000000156171217277220500152640ustar00rootroot00000000000000// // C++ Interface: mainwindow // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef MAINWINDOW_H #define MAINWINDOW_H #include #include "situationwidget.h" #include "situationscene.h" #include "situationview.h" #include "situationprint.h" class SituationModel; class TrackWidget; /** \class MainWindow \brief The Main Window This class initialises a lot of objects. They are roughly sorted into three categories: - The GraphicsView objects - The Widgets available from the main window - The QActions triggered in the program There are many slot methods which will be connected to QAction signals */ class MainWindow : public QMainWindow { Q_OBJECT public: MainWindow(QWidget *parent = 0); ~MainWindow(); virtual QMenu *createPopupMenu(){return 0;} public slots: // State management void changeState(SceneState newState); void cleanState(bool state); void updateActions(); // File actions void newTab(); void setTab(int index); void removeTab(); void newFile(); void restoreFiles(); void openFile(); void openFiles(QStringList fileList); void openFile(const QString &fileName, bool inNewTab = false); void openRecent(); bool saveFile(); bool saveAs(); void print(); void printPreview(); void exportPdf(); void exportImage(); #ifdef GIF_EXPORT void exportAnimation(); #endif // Track actions void addTrack(); void addBoat(); void addMark(); void addPolyLine(); void addPoint(); void trimSail(); void autotrimSail(); void untrimSail(); void togglePortOverlap(); void toggleStarboardOverlap(); void toggleFlag(); void toggleAcceleration(); void toggleHidden(); void toggleText(); void toggleSpin(); void toggleMarkSide(); void toggleMarkArrow(); void toggleMarkZone(); void setMarkColor(); void toggleLaylines(); void toggleMarkLabel(); void editMarkLabel(); void deleteTrack(); void deleteModels(); void setLookAt(); // Animation actions void animate(bool state, bool interactive=true); void play(); void pause(bool pause); void stop(); void loop(bool loop); void changeAnimationState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState); // About actions void toggleLang(); void about(); protected: void closeEvent(QCloseEvent *event); void changeEvent(QEvent *event); private: // Initialisation methods void createTranslations(QString locale); void createActions(); void createMenus(); void createDocks(); // Configuration methods void unsetTab(); void writeSettings(); void readSettings(); void updateRecentList(); bool maybeSave(SituationModel *situation); // File methods bool saveSituation(SituationModel *situation, QString name); void setCurrentFile(SituationModel *situation, const QString &fileName); // GraphicsView Framework QList situationList; QList sceneList; QList viewList; int currentSituation; static const int maxRecent; QStringList recentList; QStringList fileList; QString filePath; // Widgets on the window QMenuBar *menubar; QToolBar *toolbar; QTabWidget *tabWidget; QPushButton *newTabButton; QPushButton *removeTabButton; QSlider *lookDirectionSlider; QSlider *tiltSlider; QToolBar *animationBar; QDockWidget *situationDock; SituationWidget *situationWidget; QStatusBar *statusbar; QSlider *animationSlider; QTranslator *qtTranslator; QTranslator *translator; // QActions QAction *newFileAction; QAction *openFileAction; QAction *restoreFilesAction; QAction *saveFileAction; QAction *saveAsAction; QAction *newTabAction; QAction *removeTabAction; QAction *printAction; QAction *printPreviewAction; QAction *exportPdfAction; QAction *exportImageAction; #ifdef GIF_EXPORT QAction *exportAnimationAction; #endif QAction *exitAction; QAction *addTrackAction; QAction *addBoatAction; QAction *addMarkAction; QAction *addPolyLineAction; QAction *addPointAction; QAction *trimSailAction; QAction *autotrimSailAction; QAction *untrimSailAction; QAction *togglePortOverlapAction; QAction *toggleStarboardOverlapAction; QAction *toggleHiddenAction; QAction *toggleTextAction; QAction *toggleSpinAction; QAction *toggleMarkSideAction; QAction *toggleMarkArrowAction; QAction *toggleMarkZoneAction; QAction *setMarkColorAction; QAction *toggleLaylinesAction; QAction *toggleMarkLabelAction; QAction *editMarkLabelAction; QAction *deleteTrackAction; QAction *deleteAction; QAction *animateAction; QAction *startAction; QAction *pauseAction; QAction *stopAction; QAction *loopAction; QAction *undoAction; QAction *redoAction; QAction *zoomInAction; QAction *zoomOutAction; QAction *zoomFitAction; QAction *toggleMainToolbarAction; QAction *toggleAnimationToolbarAction; QAction *toggleScenarioDockAction; QAction *aboutAction; // QMenu QMenu *fileMenu; QMenu *recentMenu; QMenu *trackMenu; QMenu *flagMenu; QMenu *accelerationMenu; QMenu *defaultPopup; QMenu *boatPopup; QMenu *markPopup; QMenu *pointPopup; QMenu *historyMenu; QMenu *zoomMenu; QMenu *animationMenu; QMenu *viewMenu; QMenu *aboutMenu; QMenu *langMenu; }; #endif boats-201307/model/000077500000000000000000000000001217277220500140255ustar00rootroot00000000000000boats-201307/model/boatmodel.cpp000066400000000000000000000236661217277220500165140ustar00rootroot00000000000000// // C++ Implementation: boatmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include "boatmodel.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" extern int debugLevel; BoatModel::BoatModel(TrackModel* track, QObject *parent) : PositionModel(track->situation(), parent), m_trim(0), m_jibTrim(0), m_spin(false), m_spinTrim(0), m_overlap(Boats::none), m_flag(Boats::noFlag), m_hidden(false), m_acceleration(Boats::constant), m_track(track), m_hasSpin(false), m_maxNormalSailAngle(0), m_maxNormalJibAngle(0), m_maxWithSpinSailAngle(0), m_maxWithSpinJibAngle(0), m_dim(255) { if (debugLevel & 1 << MODEL) std::cout << "new Boat " << this << std::endl; setOrder(track->size()+1); } BoatModel::~BoatModel() { if (debugLevel & 1 << MODEL) std::cout << "delete Boat " << this << std::endl; } void BoatModel::setHeading(const qreal& theValue) { if (theValue != m_heading) { if (debugLevel & 1 << MODEL) std::cout << "heading = " << theValue << std::endl; m_heading = fmod(theValue,360.0); // This is always between -360 and +360 if (m_heading < 0) m_heading += 360.0; // This ensures it is between 0 and +360 emit headingChanged(m_heading); setTrimmedSailAngle(trimmedSailAngle()); setTrimmedJibAngle(trimmedJibAngle()); setTrimmedSpinAngle(trimmedSpinAngle()); setTrimmedGennAngle(trimmedGennAngle()); m_track->changingTrack(m_track); } } void BoatModel::setPosition(const QPointF& theValue) { PositionModel::setPosition(theValue); m_track->changingTrack(m_track); } void BoatModel::setTrim(const qreal& theValue) { qreal newAngle = sailAngle() + theValue; if (theValue != m_trim && newAngle < 180 && newAngle > -180) { m_trim = theValue; if (debugLevel & 1 << MODEL) std::cout << "trim = " << theValue << std::endl; setTrimmedSailAngle(trimmedSailAngle()); } } void BoatModel::setTrimmedSailAngle(qreal theValue) { emit trimmedSailAngleChanged(theValue); } void BoatModel::setJibTrim(const qreal& theValue) { qreal newAngle = jibAngle() + theValue; if (theValue != m_jibTrim && newAngle < 180 && newAngle > -180) { m_jibTrim = theValue; if (debugLevel & 1 << MODEL) std::cout << "jibtrim = " << theValue << std::endl; setTrimmedJibAngle(trimmedJibAngle()); } } void BoatModel::setTrimmedJibAngle(qreal theValue) { emit trimmedJibAngleChanged(theValue); } void BoatModel::setHasSpin(const bool theValue) { if (theValue != m_hasSpin) { m_hasSpin = theValue; } } void BoatModel::setSpin(const bool theValue) { if (theValue != m_spin) { m_spin = theValue; emit spinChanged(m_spin); setTrimmedSailAngle(trimmedSailAngle()); setTrimmedJibAngle(trimmedJibAngle()); } } void BoatModel::setSpinTrim(const qreal& theValue) { // Spinnaker graphics code doesn't actually respect spin trim so use this for gennaker trimming qreal sailAngle = gennAngle(); // spinAngle(); qreal newAngle = sailAngle + theValue; if (theValue != m_spinTrim && newAngle < 180 && newAngle > -180) { m_spinTrim = theValue; if (debugLevel & 1 << MODEL) std::cout << "spinTrim = " << theValue << std::endl; setTrimmedSpinAngle(trimmedSpinAngle()); setTrimmedGennAngle(trimmedGennAngle()); } } void BoatModel::setTrimmedSpinAngle(qreal theValue) { emit trimmedSpinAngleChanged(theValue); } void BoatModel::setTrimmedGennAngle(qreal theValue) { emit trimmedGennAngleChanged(theValue); } void BoatModel::setOverlap(const Boats::Overlaps theValue) { if (theValue != m_overlap) { if (debugLevel & 1 << MODEL) std::cout << "overlap = " << theValue << std::endl; m_overlap = theValue; emit overlapChanged(m_overlap); } } void BoatModel::setFlag(const Boats::Flag theValue) { if (theValue != m_flag) { if (debugLevel & 1 << MODEL) std::cout << "flag = " << theValue << std::endl; m_flag = theValue; emit flagChanged(m_flag); } } void BoatModel::setHidden(const bool theValue) { if (theValue != m_hidden) { if (debugLevel & 1 << MODEL) std::cout << "hidden = " << theValue << std::endl; m_hidden = theValue; emit hiddenChanged(m_hidden); } } void BoatModel::setAcceleration(const Boats::Acceleration theValue) { if (theValue != m_acceleration) { if (debugLevel & 1 << MODEL) std::cout << "acceleration = " << theValue << std::endl; m_acceleration = theValue; } } qreal BoatModel::sailAngle(qreal heading) const { qreal layline = situation()->laylineAngle(); qreal sailAngle; if (heading == -1) { heading = fmod(m_heading - wind() + 360, 360); } // within 10° inside layline angle, the sail is headed if (heading < layline-10) { sailAngle = fmin(layline-20,heading); // layline-20 so that sail is at stall angle of 10 degrees when heading = layline-10 } else if (heading > 360 - (layline-10)) { sailAngle = fmax(-(layline-20),heading - 360); } else { qreal maxSailAngle; if (m_hasSpin && m_spin) { maxSailAngle = m_maxWithSpinSailAngle; } else { maxSailAngle = m_maxNormalSailAngle; } // linear incidence variation // incidence is 15° at layline angle and maxWithSpinSailAngle downwind qreal a = (180 - layline) / (maxSailAngle - 15); qreal b = layline / a - 15; if (heading<180) { sailAngle = heading/a - b; } else { sailAngle = heading/a - b - 2*maxSailAngle; } } if (debugLevel & 1 << MODEL) std::cout << "heading = " << heading << " sail = " << sailAngle << std::endl; return sailAngle; } qreal BoatModel::jibAngle(qreal heading) const { qreal layline = situation()->laylineAngle(); qreal sailAngle; if (heading == -1) { heading = fmod(m_heading - wind() + 360, 360); } // within 10° inside layline angle, the sail is headed if (heading < layline-10) { sailAngle = fmin(layline-20,heading); // layline-20 so that sail is at stall angle of 10 degrees when heading = layline-10 } else if (heading > 360 - (layline-10)) { sailAngle = fmax(-(layline-20),heading - 360); } else { qreal maxJibAngle; if (m_hasSpin && m_spin) { maxJibAngle = m_maxWithSpinJibAngle; } else { maxJibAngle = m_maxNormalJibAngle; } // linear incidence variation // incidence is 20° at layline angle and maxWithSpinJibAngle downwind qreal a = (180 - layline) / (maxJibAngle - 20); qreal b = layline / a - 20; if (heading<180) { sailAngle = heading/a - b; } else { sailAngle = heading/a - b - 2*maxJibAngle; } } if (debugLevel & 1 << MODEL) std::cout << "heading = " << heading << " jib = " << sailAngle << std::endl; return sailAngle; } qreal BoatModel::spinAngle(qreal heading) const { qreal sailAngle; if (heading == -1) { heading = fmod(m_heading - wind() + 360, 360); } // within 10° above downwind angle, the sail is headed if (heading < 80) { sailAngle = heading; } else if (heading > 280) { sailAngle = heading - 360; } else { if (heading<180) { sailAngle = heading - 20; } else { sailAngle = heading + 20; } } if (debugLevel & 1 << MODEL) std::cout << "heading = " << heading << " spin = " << sailAngle << std::endl; return sailAngle; } qreal BoatModel::gennAngle(qreal heading) const { qreal sailAngle; if (heading == -1) { heading = fmod(m_heading - wind() + 360, 360); } // within 10° above downwind angle, the sail is headed if (heading < 80) { sailAngle = heading / 80 * 20; } else if (heading > 360 - 80) { sailAngle = - (360 - heading) / 80 * 20; } else { // linear incidence variation // incidence is 20° at 80° heading and 30° downwind qreal a = (180 - 80) / (30 - 20); qreal b = 80 / a - 20; if (heading<180) { sailAngle = heading/a - b; } else { sailAngle = heading/a - b - 2*30; } } if (debugLevel & 1 << MODEL) std::cout << "heading = " << heading << " genn = " << sailAngle << std::endl; return sailAngle; } void BoatModel::setWind(qreal wind) { PositionModel::setWind(wind); emit headingChanged(m_heading); setTrimmedSailAngle(trimmedSailAngle()); setTrimmedJibAngle(trimmedJibAngle()); setTrimmedSpinAngle(trimmedSpinAngle()); setTrimmedGennAngle(trimmedGennAngle()); } void BoatModel::setDim(int dim) { m_dim = dim; emit dimChanged(dim); } void BoatModel::setPath(QPainterPath path) { m_path = path; } boats-201307/model/boatmodel.h000066400000000000000000000160171217277220500161510ustar00rootroot00000000000000// // C++ Interface: boatmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef BOATMODEL_H #define BOATMODEL_H #include #include "boats.h" #include "positionmodel.h" #include "situationmodel.h" class SituationModel; class TrackModel; /** \class BoatModel \brief The Model for a Boat Position The class represents the Model for a Boat, according to an Observer Pattern. BoatModel inherits PositionModel and contains data which represents one boat at a given time, like its position and heading. It shall not be mistaken with TrackModel, which holds the list of all positions where a Boat has navigated. More exactly, a TrackModel will hold a List of BoatModels. \sa SituationModel, TrackModel */ class BoatModel : public PositionModel { Q_OBJECT Q_PROPERTY(qreal trimSailAngle READ trimmedSailAngle WRITE setTrimmedSailAngle) Q_PROPERTY(qreal trimJibAngle READ trimmedJibAngle WRITE setTrimmedJibAngle) Q_PROPERTY(bool spin READ spin WRITE setSpin) Q_PROPERTY(qreal trimSpinAngle READ trimmedSpinAngle WRITE setTrimmedSpinAngle) Q_PROPERTY(qreal trimGennAngle READ trimmedGennAngle WRITE setTrimmedGennAngle) Q_PROPERTY(Boats::Overlaps overlap READ overlap WRITE setOverlap) Q_PROPERTY(Boats::Flag flag READ flag WRITE setFlag) Q_PROPERTY(int dim READ dim WRITE setDim) public: BoatModel(TrackModel *track, QObject *parent = 0); ~BoatModel(); // Setters and Getters for Model Data virtual void setPosition(const QPointF& theValue); void setHeading(const qreal& theValue); qreal trim() const { return m_trim; } void setTrim(const qreal& theValue); qreal trimmedSailAngle() const { return sailAngle() + m_trim; } void setTrimmedSailAngle(qreal theValue); qreal jibTrim() const { return m_jibTrim; } void setJibTrim(const qreal& theValue); qreal trimmedJibAngle() const { return jibAngle() + m_jibTrim; } void setTrimmedJibAngle(qreal theValue); bool hasSpin() const {return m_hasSpin; } void setHasSpin(const bool theValue); bool spin() const { return m_spin; } void setSpin(const bool theValue); qreal spinTrim() const { return m_spinTrim; } void setSpinTrim(const qreal& theValue); qreal trimmedSpinAngle() const { return spinAngle() + m_spinTrim; } void setTrimmedSpinAngle(qreal theValue); qreal trimmedGennAngle() const { return gennAngle() + m_spinTrim; } void setTrimmedGennAngle(qreal theValue); Boats::Overlaps overlap() const {return m_overlap; } void setOverlap(const Boats::Overlaps theValue); Boats::Flag flag() const {return m_flag; } void setFlag(const Boats::Flag theValue); bool hidden() const {return m_hidden; } void setHidden(const bool theValue); Boats::Acceleration acceleration() const {return m_acceleration; } void setAcceleration(const Boats::Acceleration theValue); // Setters and Getters for Non model Data TrackModel* track() const { return m_track; } qreal sailAngle(qreal heading = -1) const; qreal jibAngle(qreal heading = -1) const; qreal spinAngle(qreal heading = -1) const; void setWind(qreal wind); qreal gennAngle(qreal heading = -1) const; qreal maxNormalSailAngle() const {return m_maxNormalSailAngle; } void setMaxNormalSailAngle(const qreal& theValue) { m_maxNormalSailAngle = theValue; } qreal maxNormalJibAngle() const {return m_maxNormalJibAngle; } void setMaxNormalJibAngle(const qreal& theValue) { m_maxNormalJibAngle = theValue; } qreal maxWithSpinSailAngle() const {return m_maxWithSpinSailAngle; } void setMaxWithSpinSailAngle(const qreal& theValue) { m_maxWithSpinSailAngle = theValue; } qreal maxWithSpinJibAngle() const {return m_maxWithSpinJibAngle; } void setMaxWithSpinJibAngle(const qreal& theValue) { m_maxWithSpinJibAngle = theValue; } void setDim(int dim); int dim() const { return m_dim; } void setPath(QPainterPath path); const QPainterPath path() const { return m_path; } signals: void trimmedSailAngleChanged(qreal sailAngle); void trimmedJibAngleChanged(qreal jibAngle); void spinChanged(bool spin); void trimmedSpinAngleChanged(qreal spinAngle); void trimmedGennAngleChanged(qreal gennAngle); void overlapChanged(Boats::Overlaps overlap); void flagChanged(Boats::Flag flag); void hiddenChanged(bool hidden); void dimChanged(int dim); private: // Model Data /// \a m_trim holds the sailing trim of a Boat qreal m_trim; /// \a m_jibTrim holds the jib trim qreal m_jibTrim; /// \a m_spin holds whether a spinnaker (or gennaker) is used bool m_spin; /// \a m_spinTrim holds the spinnaker (or gennaker) trim qreal m_spinTrim; /// \a m_overlap holds whether an overlap line should be displayed Boats::Overlaps m_overlap; /// \a m_flag holds the flag to display Boats::Flag m_flag; /// \a m_hidden holds whether the boat should display the hidden symbol bool m_hidden; /// \a m_acceleration holds how the boat speed should vary for the next period Boats::Acceleration m_acceleration; // Non model Data /// \a m_track keeps a pointer to the TrackModel to which /// it belongs TrackModel *m_track; /// \a m_hasSpin holds whether this type of boat has a spinnaker (or gennaker) bool m_hasSpin; /// \a m_maxNormalSailAngle holds the max sail angle to use when sailing without a spinnaker qreal m_maxNormalSailAngle; /// \a m_maxNormalJibAngle holds the max jib angle to use when sailing without a spinnaker qreal m_maxNormalJibAngle; /// \a m_maxWithSpinSailAngle holds the max sail angle to use when sailing with a spinnaker qreal m_maxWithSpinSailAngle; /// \a m_maxWithSpinJibAngle holds the max jib angle to use when sailing with a spinnaker qreal m_maxWithSpinJibAngle; int m_dim; /// \a m_path holds the QPainterPath to the next boat QPainterPath m_path; }; #endif boats-201307/model/markmodel.cpp000066400000000000000000000065261217277220500165150ustar00rootroot00000000000000// // C++ Implementation: markmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #include #include "markmodel.h" #include "commontypes.h" #include "situationmodel.h" extern int debugLevel; MarkModel::MarkModel(SituationModel* situation, QObject *parent) : PositionModel(situation, parent), m_color(Qt::gray), m_zone(false), m_arrowVisible(false), m_leaveToPort(true), m_labelVisible(true), m_length(situation->situationLength()) { if (debugLevel & 1 << MODEL) std::cout << "new Mark " << this << std::endl; setOrder(situation->markSize()+1); setLabelText(QString::number(order())); } MarkModel::~MarkModel() { if (debugLevel & 1 << MODEL) std::cout << "delete Mark " << this << std::endl; } void MarkModel::setColor(const QColor& theValue) { if (theValue != m_color) { m_color = theValue; emit colorChanged(m_color); } } void MarkModel::setZone(const bool theValue) { if (theValue != m_zone) { if (debugLevel & 1 << MODEL) std::cout << "Mark " << this << " zone " << theValue << std::endl; m_zone = theValue; emit zoneChanged(m_zone); } } void MarkModel::setLength(const int theValue) { if (theValue != m_length) { if (debugLevel & 1 << MODEL) std::cout << "Mark " << this << " length " << theValue << std::endl; m_length = theValue; emit lengthChanged(m_length); } } void MarkModel::setArrowVisible(const bool theValue) { if (theValue != m_arrowVisible) { if (debugLevel & 1 << MODEL) std::cout << "Mark " << this << " arrowVisible " << theValue << std::endl; m_arrowVisible = theValue; emit arrowVisibilityChanged(m_arrowVisible); } } void MarkModel::setLeaveToPort(const bool theValue) { if (theValue != m_leaveToPort) { if (debugLevel & 1 << MODEL) std::cout << "Mark " << this << " leaveToPort " << theValue << std::endl; m_leaveToPort = theValue; emit leaveToPortChanged(m_leaveToPort); } } void MarkModel::setLabelVisible(const bool theValue) { if (theValue != m_labelVisible) { if (debugLevel & 1 << MODEL) std::cout << "Mark " << this << " labelVisible " << theValue << std::endl; m_labelVisible = theValue; emit labelVisibilityChanged(m_labelVisible); } } void MarkModel::setLabelText(const QString theValue) { if (theValue != m_labelText) { if (debugLevel & 1 << MODEL) std::cout << "Mark " << this << " labelText " << theValue.toStdString() << std::endl; m_labelText = theValue; emit labelTextChanged(m_labelText); } } boats-201307/model/markmodel.h000066400000000000000000000063131217277220500161540ustar00rootroot00000000000000// // C++ Interface: markmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #ifndef MARKMODEL_H #define MARKMODEL_H #include #include "positionmodel.h" class SituationModel; /** \class MarkModel \brief The Model for a Mark The class represents the Model for a Mark, according to an Observer Pattern. MarkModel inherits PositionModel and contains data which represents a mark, like its color, and whether the zone is displayed. \sa SituationModel */ class MarkModel : public PositionModel { Q_OBJECT public: MarkModel(SituationModel *situation, QObject *parent = 0); ~MarkModel(); // Setters and Getters for Model Data QColor color() const { return m_color; } void setColor(const QColor& theValue); bool zone() const { return m_zone; } void setZone(const bool theValue); bool arrowVisible() const { return m_arrowVisible; } void setArrowVisible(const bool theValue); bool leaveToPort() const { return m_leaveToPort; } void setLeaveToPort(const bool theValue); bool labelVisible() const { return m_labelVisible; } void setLabelVisible(const bool theValue); QString labelText() const { return m_labelText; } void setLabelText(const QString theValue); // Setters and Getters for Non model Data int length() const { return m_length; } void setLength(const int theValue); signals: void colorChanged(QColor color); void zoneChanged(bool zone); void lengthChanged(int length); void arrowVisibilityChanged(bool visible); void leaveToPortChanged(bool leaveToPort); void labelVisibilityChanged(bool visible); void labelTextChanged(QString text); private: // Model Data /// \a m_color holds the color of the Mark QColor m_color; /// \a m_zone holds whether the zone of the Mark is displayed bool m_zone; /// \a m_arrowVisible is true if the mark rounding arrow should be visible bool m_arrowVisible; /// \a m_leaveToPort is true if the mark should be left to port bool m_leaveToPort; /// \a m_labelVisible is true if the mark label should be visible bool m_labelVisible; /// \a m_labelText holds the text to use for the label QString m_labelText; // Non model Data /// \a m_length keeps the length of Main Series of the Scenario int m_length; }; #endif boats-201307/model/model.pri000066400000000000000000000007571217277220500156520ustar00rootroot00000000000000INCLUDEPATH += $$PWD DEPENDPATH += $$PWD HEADERS += \ $$PWD/boatmodel.h \ $$PWD/markmodel.h \ $$PWD/pointmodel.h \ $$PWD/polylinemodel.h \ $$PWD/positionmodel.h \ $$PWD/situationmodel.h \ $$PWD/trackmodel.h \ $$PWD/windmodel.h SOURCES += \ $$PWD/boatmodel.cpp \ $$PWD/markmodel.cpp \ $$PWD/pointmodel.cpp \ $$PWD/polylinemodel.cpp \ $$PWD/positionmodel.cpp \ $$PWD/situationmodel.cpp \ $$PWD/trackmodel.cpp \ $$PWD/windmodel.cpp boats-201307/model/pointmodel.cpp000066400000000000000000000027411217277220500167070ustar00rootroot00000000000000// // C++ Implementation: pointmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #include #include #include "pointmodel.h" #include "commontypes.h" #include "situationmodel.h" #include "polylinemodel.h" extern int debugLevel; PointModel::PointModel(PolyLineModel* polyline, QObject *parent) : PositionModel(polyline->situation(), parent), m_polyline(polyline) { if (debugLevel & 1 << MODEL) std::cout << "new Point " << this << std::endl; setOrder(polyline->size()+1); } PointModel::~PointModel() { if (debugLevel & 1 << MODEL) std::cout << "delete Point " << this << std::endl; } void PointModel::setPosition(const QPointF& theValue) { PositionModel::setPosition(theValue); m_polyline->changingPolyLine(m_polyline); } boats-201307/model/pointmodel.h000066400000000000000000000034121217277220500163500ustar00rootroot00000000000000// // C++ Interface: pointmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #ifndef POINTMODEL_H #define POINTMODEL_H #include #include "positionmodel.h" class PolyLineModel; /** \class PointModel \brief The Model for a Point Position The class represents the Model for a Point, according to an Observer Pattern. PointModel inherits PositionModel and contains data which represents one point at a given time, as part of a PolyLine. \sa SituationModel, PolyLineModel */ class PointModel : public PositionModel { Q_OBJECT public: PointModel(PolyLineModel *polyline, QObject *parent = 0); ~PointModel(); // Setters and Getters for Model Data virtual void setPosition(const QPointF& theValue); // Setters and Getters for Non model Data PolyLineModel* polyLine() const { return m_polyline; } private: // Non model Data /// \a m_polyline keeps a pointer to the PolyLineModel to which /// it belongs PolyLineModel *m_polyline; }; #endif boats-201307/model/polylinemodel.cpp000066400000000000000000000054741217277220500174170ustar00rootroot00000000000000// // C++ Implementation: polylinemodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #include #include "polylinemodel.h" #include "commontypes.h" #include "situationmodel.h" #include "pointmodel.h" extern int debugLevel; PolyLineModel::PolyLineModel(SituationModel* situation, QObject *parent) : QObject(parent), m_situation(situation) { if (debugLevel & 1 << MODEL) std::cout << "new PolyLine " << this << std::endl; } PolyLineModel::~PolyLineModel() { if (debugLevel & 1 << MODEL) std::cout << "delete PolyLine " << this << std::endl; } void PolyLineModel::appendDiscardedXml(const QString& theValue) { if (!m_discardedXml.contains(theValue)) { m_discardedXml.append(theValue); } } void PolyLineModel::changingPolyLine(PolyLineModel *polyline) { QPainterPath path; if (m_points.size() < 1) { m_path = path; return; } path.moveTo(m_points[0]->position()); foreach(PointModel *point, m_points) { path.lineTo(point->position()); } m_path = path; emit polyLineChanged(polyline); } PointModel* PolyLineModel::addPoint(PointModel *point, int order) { if (order == -1) { order = m_points.size(); } m_points.insert(order, point); m_situation->addingPoint(point); if (debugLevel & 1 << MODEL) std::cout << "Adding Point " << order+1 << std::endl; changingPolyLine(this); return point; } int PolyLineModel::deletePoint(PointModel *point) { int order = m_points.indexOf(point); m_points.removeOne(point); if (debugLevel & 1 << MODEL) std::cout << "Removing Point " << order+1 << std::endl; m_situation->removingPoint(point); changingPolyLine(this); return order; } void PolyLineModel::displayPoints() { if (debugLevel & 1 << MODEL) std::cout << "Displaying points" << std::endl; foreach (PointModel* point, m_points) { m_situation->addingPoint(point); } } void PolyLineModel::hidePoints() { if (debugLevel & 1 << MODEL) std::cout << "Hiding points" << std::endl; foreach (PointModel* point, m_points) { m_situation->removingPoint(point); } } boats-201307/model/polylinemodel.h000066400000000000000000000052421217277220500170550ustar00rootroot00000000000000// // C++ Interface: polylinemodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2010 Thibaut GRIDEL // // 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 . // // #ifndef POLYLINEMODEL_H #define POLYLINEMODEL_H #include #include "boats.h" class SituationModel; class PointModel; /** \class PolyLineModel \brief The Model for a list of Points The class represents the Model for a Line, according to an Observer Pattern. PolyLineModel contains data which describe one line, like the list of points. \sa SituationModel, PointModel */ class PolyLineModel : public QObject { Q_OBJECT public: PolyLineModel(SituationModel* situation = 0, QObject *parent = 0); ~PolyLineModel(); PointModel * addPoint(PointModel *point, int order = -1); int deletePoint(PointModel *point); void displayPoints(); void hidePoints(); // Setters and Getters for Model Data int size() const { return m_points.size();} const QList points() const { return m_points; } const QPainterPath path() const { return m_path; } // Setters and Getters for Non model Data SituationModel* situation() const { return m_situation; } QStringList discardedXml() const { return m_discardedXml; } void appendDiscardedXml(const QString& theValue); void changingPolyLine(PolyLineModel *polyline); signals: // Signals for PolyLineModel parameters void polyLineChanged(PolyLineModel *polyLine); private: // Model Data /// \a m_points holds the List of Point Positions of the PolyLine QList m_points; // Non model Data /// \a m_situation keeps a pointer to the SituationModel to which /// it belongs SituationModel *m_situation; /// \a m_path holds the QPainterPath of the PolyLine QPainterPath m_path; /// \a m_discardedXml keeps all unparsed xml tags QStringList m_discardedXml; }; #endif // POLYLINEMODEL_H boats-201307/model/positionmodel.cpp000066400000000000000000000063651217277220500174300ustar00rootroot00000000000000// // C++ Implementation: positionmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include "positionmodel.h" #include "situationmodel.h" #include "commontypes.h" extern int debugLevel; PositionModel::PositionModel(SituationModel* situation, QObject *parent) : QObject(parent), m_position(), m_heading(0), m_textPosition(10,10), m_laylines(false), m_situation(situation), m_wind(-1) { if (debugLevel & 1 << MODEL) std::cout << "new Position " << this << std::endl; } PositionModel::~PositionModel() { if (debugLevel & 1 << MODEL) std::cout << "delete Position " << this << std::endl; } void PositionModel::setPosition(const QPointF& theValue) { if (theValue != m_position) { if (debugLevel & 1 << MODEL) std::cout << "Position " << this << " position " << theValue.x() << ", " << theValue.y() << std::endl; m_position = theValue; emit positionChanged(m_position); } } void PositionModel::setOrder(const int theValue) { if (theValue != m_order) { if (debugLevel & 1 << MODEL) std::cout << "Position " << this << " order " << theValue << std::endl; m_order = theValue; emit orderChanged(m_order); } } void PositionModel::setHeading(const qreal& theValue) { if (theValue != m_heading) { if (debugLevel & 1 << MODEL) std::cout << "Heading " << this << " heading " << theValue << std::endl; m_heading = theValue; emit headingChanged(m_heading); } } void PositionModel::setText(const QString theValue) { if (theValue != m_text) { if (debugLevel & 1 << MODEL) std::cout << "text = " << theValue.toStdString() << std::endl; m_text = theValue; emit textChanged(m_text); } } void PositionModel::setTextPosition(const QPointF& theValue) { if (theValue != m_textPosition) { m_textPosition = theValue; emit textPositionChanged(m_textPosition); } } void PositionModel::setLaylines(bool theValue) { if(theValue != m_laylines) { m_laylines = theValue; emit laylinesChanged(m_laylines); } } void PositionModel::setWind(qreal wind) { m_wind = wind; emit windChanged(m_wind); } qreal PositionModel::wind() const { if (m_wind == -1) { return m_situation->wind().windAt(m_order-1); } return m_wind; } void PositionModel::appendDiscardedXml(const QString& theValue) { if (!m_discardedXml.contains(theValue)) { m_discardedXml.append(theValue); } } boats-201307/model/positionmodel.h000066400000000000000000000077011217277220500170700ustar00rootroot00000000000000// // C++ Interface: positionmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef POSITIONMODEL_H #define POSITIONMODEL_H #include class SituationModel; /** \class PositionModel \brief The Model for a Position The class represents the Model for a Position, according to an Observer Pattern. PositionModel contains data which represents an object with a position, and a stacking order. It is inherited by BoatModel and PointModel. \sa SituationModel, BoatModel, PointModel */ class PositionModel : public QObject { Q_OBJECT Q_PROPERTY(QPointF pos READ position WRITE setPosition) Q_PROPERTY(qreal heading READ heading WRITE setHeading) Q_PROPERTY(QString text READ text WRITE setText) Q_PROPERTY(QPointF textPos READ textPosition WRITE setTextPosition) Q_PROPERTY(bool laylines READ laylines() WRITE setLaylines) Q_PROPERTY(qreal wind READ wind WRITE setWind) public: PositionModel(SituationModel* situation, QObject *parent = 0); virtual ~PositionModel(); // Setters and Getters for Model Data QPointF position() const { return m_position; } virtual void setPosition(const QPointF& theValue); int order() const { return m_order; } void setOrder(const int theValue); qreal heading() const { return m_heading; } virtual void setHeading(const qreal& theValue); QString text() const {return m_text; } void setText(const QString theValue); QPointF textPosition() const {return m_textPosition; } void setTextPosition(const QPointF& theValue); bool laylines() const {return m_laylines; } void setLaylines(bool theValue); // Setters and Getters for Non model Data SituationModel* situation() const { return m_situation; } virtual qreal wind() const; QStringList discardedXml() const { return m_discardedXml; } void appendDiscardedXml(const QString& theValue); public slots: virtual void setWind(qreal wind); signals: void positionChanged(QPointF position); void orderChanged(int order); void headingChanged(qreal heading); void textChanged(QString text); void textPositionChanged(QPointF textPosition); void windChanged(qreal wind); void laylinesChanged(bool laylines); protected: // Model Data /// \a m_position holds the position of the object QPointF m_position; /// \a m_order holds the stacking order of the object. It starts at 1 for track boat int m_order; /// \a m_heading holds the heading of the object qreal m_heading; /// \a m_text holds the text to display QString m_text; /// \a m_textPosition holds the position of the text to display QPointF m_textPosition; /// \a m_laylines holds wether the object should display laylines bool m_laylines; // Non model Data /// \a m_situation keeps a pointer to the SituationModel to which /// it belongs SituationModel *m_situation; qreal m_wind; /// \a m_discardedXml keeps all unparsed xml tags QStringList m_discardedXml; }; #endif boats-201307/model/situationmodel.cpp000066400000000000000000000163671217277220500176060ustar00rootroot00000000000000// // C++ Implementation: situationmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include "situationmodel.h" #include "commontypes.h" #include "trackmodel.h" #include "boatmodel.h" #include "markmodel.h" #include "polylinemodel.h" extern int debugLevel; SituationModel::SituationModel(QObject *parent) : QObject(parent), m_showLayline(true), m_laylineAngle(40), m_situationSeries(Boats::keelboat), m_situationLength(3), m_lookDirection(0), m_tilt(0), m_wind(this), m_undoStack(new QUndoStack(this)) { if (debugLevel & 1 << MODEL) std::cout << "new situation " << this << std::endl; connect(&m_wind, SIGNAL(windReset()), this, SLOT(resetWind())); } SituationModel::~SituationModel() { if (debugLevel & 1 << MODEL) std::cout << "end situation " << this << std::endl; } void SituationModel::setTitle(const QString theValue) { if (theValue != m_title) { if (debugLevel & 1 << MODEL) std::cout << "Setting Title " << theValue.toStdString() << std::endl; m_title = theValue; emit titleChanged(m_title); } } void SituationModel::setRules(const QString theValue) { if (theValue != m_rules) { if (debugLevel & 1 << MODEL) std::cout << "Setting Rules " << theValue.toStdString() << std::endl; m_rules = theValue; emit rulesChanged(m_rules); } } void SituationModel::setShowLayline(const bool theValue) { if (theValue != m_showLayline) { if (debugLevel & 1 << MODEL) std::cout << "Show Layline " << theValue << std::endl; m_showLayline = theValue; emit showLaylineChanged(m_showLayline); emit laylineChanged(m_laylineAngle); } } void SituationModel::setLaylineAngle(const int theValue) { if (theValue != m_laylineAngle) { if (debugLevel & 1 << MODEL) std::cout << "Situation " << this << " Layline Angle " << theValue << std::endl; m_laylineAngle = theValue; emit laylineChanged(m_laylineAngle); } } void SituationModel::setSituationSeries(const int theValue) { if (theValue != m_situationSeries) { if (debugLevel & 1 << MODEL) std::cout << "Situation " << this << " Series " << ENUM_NAME(Boats, Series, theValue) << std::endl; m_situationSeries = (Boats::Series) theValue; emit seriesChanged(m_situationSeries); emit laylineChanged(m_laylineAngle); } } void SituationModel::setSituationLength(const int theValue) { if (theValue != m_situationLength) { if (debugLevel & 1 << MODEL) std::cout << "Situation " << this << " Length " << theValue << std::endl; m_situationLength = theValue; foreach (MarkModel *mark, m_marks) { mark->setLength(m_situationLength); } emit lengthChanged(m_situationLength); } } void SituationModel::setAbstract(const QString theValue) { if (theValue != m_abstract) { if (debugLevel & 1 << MODEL) std::cout << "Setting Abstract " << theValue.toStdString() << std::endl; m_abstract = theValue; emit abstractChanged(m_abstract); } } void SituationModel::setDescription(const QString theValue) { if (theValue != m_description) { if (debugLevel & 1 << MODEL) std::cout << "Setting Description " << theValue.toStdString() << std::endl; m_description = theValue; emit descriptionChanged(m_description); } } void SituationModel::setLookDirection(qreal theValue) { if (theValue != m_lookDirection) { if (debugLevel & 1 << MODEL) std::cout << "Setting lookDirection " << theValue << std::endl; m_lookDirection = theValue; emit lookDirectionChanged(m_lookDirection); } } void SituationModel::setTilt(qreal theValue) { if (theValue != m_tilt) { if (debugLevel & 1 << MODEL) std::cout << "Setting tilt " << theValue << std::endl; m_tilt = theValue; emit tiltChanged(m_tilt); } } void SituationModel::appendDiscardedXml(const QString& theValue) { if (!m_discardedXml.contains(theValue)) { m_discardedXml.append(theValue); } } void SituationModel::addTrack(TrackModel *track, int order) { if (order == -1) { order = m_tracks.size(); } m_tracks.insert(order,track); if (debugLevel & 1 << MODEL) std::cout << "Adding Track " << order+1 << std::endl; for (int i=order+1; isetOrder(i+1); } track->displayBoats(); emit trackAdded(track); } void SituationModel::deleteTrack(TrackModel *track) { int index = m_tracks.indexOf(track); if (debugLevel & 1 << MODEL) std::cout << "Removing Track " << index+1 << " with " << track->size() << std::endl; track->hideBoats(); m_tracks.removeOne(track); for (int i=index; isetOrder(i+1); } emit trackRemoved(track); } void SituationModel::addMark(MarkModel *mark, int order) { if (order == -1) { order = m_marks.size(); } m_marks.insert(order, mark); if (debugLevel & 1 << MODEL) std::cout << "Adding Mark " << order+1 << std::endl; for (int i=order+1; isetOrder(i+1); } emit markAdded(mark); } int SituationModel::deleteMark(MarkModel *mark) { int index = m_marks.indexOf(mark); if (debugLevel & 1 << MODEL) std::cout << "Removing Mark " << index+1 << std::endl; m_marks.removeOne(mark); for (int i=index; isetOrder(i+1); } emit markRemoved(mark); return index; } void SituationModel::addPolyLine(PolyLineModel *polyline, int order) { if (order == -1) { order = m_lines.size(); } m_lines.insert(order,polyline); if (debugLevel & 1 << MODEL) std::cout << "Adding PolyLine " << order+1 << std::endl; polyline->displayPoints(); emit polyLineAdded(polyline); } void SituationModel::deletePolyLine(PolyLineModel *polyline) { int index = m_lines.indexOf(polyline); if (debugLevel & 1 << MODEL) std::cout << "Removing Line " << index+1 << " with " << polyline->size() << std::endl; polyline->hidePoints(); m_lines.removeOne(polyline); emit polyLineRemoved(polyline); } void SituationModel::resetWind() { if (debugLevel & 1 << MODEL) std::cout << "Resetting Wind " << std::endl; foreach (TrackModel *track, m_tracks) { foreach (BoatModel *boat, track->boats()) { boat->setWind(m_wind.windAt(boat->order()-1)); } } foreach (MarkModel *mark, m_marks) { mark->setWind(m_wind.windAt(0)); } } boats-201307/model/situationmodel.h000066400000000000000000000162411217277220500172420ustar00rootroot00000000000000// // C++ Interface: situationmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef SITUATIONMODEL_H #define SITUATIONMODEL_H #include #include "boats.h" #include "windmodel.h" class TrackModel; class BoatModel; class MarkModel; class PolyLineModel; class PointModel; /** \class SituationModel \brief The main Model for a scenario This Class represents the Model for a Scenario, according to an Observer Pattern. It holds the actual data for the scenario and signals whoever is interested in changes to the model. There are mainly: - description attributes and technical data which define the scenario - a List of TrackModel, which in turn contains a List of BoatModel - a List of MarkModel \sa SituationModel, TrackModel, BoatModel, MarkModel */ class SituationModel : public QObject { Q_OBJECT public: SituationModel(QObject *parent = 0); ~SituationModel(); // Setters and Getters for Model Data QString title() const { return m_title; } void setTitle(const QString theValue); QString rules() const { return m_rules; } void setRules(const QString theValue); bool showLayline() const { return m_showLayline; } void setShowLayline(const bool theValue); int laylineAngle() const { return m_laylineAngle; } void setLaylineAngle(const int theValue); Boats::Series situationSeries() const { return m_situationSeries; } void setSituationSeries(const int theValue); int situationLength() const { return m_situationLength; } void setSituationLength(const int theValue); QString abstract() const { return m_abstract; } void setAbstract(const QString theValue); QString description() const { return m_description; } void setDescription(const QString theValue); qreal lookDirection() const { return m_lookDirection; } qreal tilt() const { return m_tilt; } int size() const { return m_tracks.size();} const QList tracks() const { return m_tracks; } int markSize() const { return m_marks.size();} const QList marks() const { return m_marks; } const QList polyLines() const { return m_lines; } WindModel& wind() { return m_wind; }; // Setters and Getters for Non model Data QUndoStack * undoStack() const { return m_undoStack;} QStringList discardedXml() const { return m_discardedXml; } void appendDiscardedXml(const QString& theValue); QString fileName() const { return m_fileName; } void setFileName(const QString theValue) {m_fileName = theValue; } // Helper to remotely trigger boat signals from elsewhere void addingBoat(BoatModel *boat) {emit boatAdded(boat);} void removingBoat(BoatModel *boat) {emit boatRemoved(boat);} // Helper to remotely trigger point signals from elsewhere void addingPoint(PointModel *point) {emit pointAdded(point);} void removingPoint(PointModel *point) {emit pointRemoved(point);} signals: // Signals for Track void trackAdded(TrackModel *track); void trackRemoved(TrackModel *track); // Signals for Boat void boatAdded(BoatModel *boat); void boatRemoved(BoatModel *boat); // Signals for Scenario Parameters void titleChanged(const QString title); void rulesChanged(const QString rules); void showLaylineChanged(const bool show); void laylineChanged(const int angle); void seriesChanged(const int series); void lengthChanged(const int length); void abstractChanged(const QString abstract); void descriptionChanged(const QString description); void lookDirectionChanged( const qreal lookDirection); void tiltChanged( const qreal tilt); // Signals for Marks void markAdded(MarkModel *mark); void markRemoved(MarkModel *mark); // Signals for Lines void polyLineAdded(PolyLineModel *polyline); void polyLineRemoved(PolyLineModel *polyline); // Signals for Line Points void pointAdded(PointModel *point); void pointRemoved(PointModel *point); public slots: // Slots for Tracks void addTrack(TrackModel *track, int order = -1); void deleteTrack(TrackModel *track); // Slots for Marks void addMark(MarkModel *mark, int order = -1); int deleteMark(MarkModel *mark); // Slots for Lines void addPolyLine(PolyLineModel *polyline, int order = -1); void deletePolyLine(PolyLineModel *polyline); // Slot for Wind void resetWind(); void setLookDirection(qreal theValue); void setTilt(qreal theValue); private: // Model Data /// \a m_title holds the Title of the Scenario QString m_title; /// \a m_rules holds the Rules of the Scenario QString m_rules; /// \a m_abstract holds the Abstract of the Scenario QString m_abstract; /// \a m_description holds the Description of the Scenario QString m_description; /// \a m_showLayline holds whether the Laylines will be displayed bool m_showLayline; /// \a m_laylineAngle holds the Layline Angle of the Scenario int m_laylineAngle; /// \a m_situationSeries holds the Main Series of the Scenario Boats::Series m_situationSeries; /// \a m_situationLength holds the size of the Zone at Marks of /// the Scenario int m_situationLength; /// \a m_lookDirection holds the direction of the view qreal m_lookDirection; /// \a m_tilt holds the tilt of the view qreal m_tilt; /// \a m_wind holds the WindModel of the Scenario WindModel m_wind; /// \a m_tracks holds the List of Tracks of the Scenario QList m_tracks; /// \a m_marks holds the List of Marks of the Scenario QList m_marks; /// \a m_lines holds the List of PolyLines of the Scenario QList m_lines; // Non model Data /// \a m_undoStack maintains the Undo Stack for the Scenario QUndoStack *m_undoStack; /// \a m_discardedXml keeps all unparsed xml tags QStringList m_discardedXml; /// \a m_fileName holds the name of the file on disk QString m_fileName; }; #endif boats-201307/model/trackmodel.cpp000066400000000000000000000147731217277220500166720ustar00rootroot00000000000000// // C++ Implementation: trackmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include "trackmodel.h" #include "commontypes.h" #include "situationmodel.h" #include "boatmodel.h" extern int debugLevel; TrackModel::TrackModel(SituationModel *situation, QObject *parent) : QObject(parent), m_color(), m_series(Boats::unknown), m_showPath(true), m_followTrack(false), m_situation(situation), m_length(0) { m_order = situation->size(); if (debugLevel & 1 << MODEL) std::cout << "new track " << this << std::endl; switch (situation->size() % 6) { case 0: m_color = QColor(Qt::yellow); break; case 1: m_color = QColor(Qt::blue); break; case 2: m_color = QColor(Qt::green); break; case 3: m_color = QColor(Qt::red); break; case 4: m_color = QColor(Qt::cyan); break; case 5: m_color = QColor(Qt::magenta); break; } setSeries(situation->situationSeries()); } TrackModel::~TrackModel() { if (debugLevel & 1 << MODEL) std::cout << "end track " << this << std::endl; } void TrackModel::setOrder(const int theValue) { if (theValue != m_order) { m_order = theValue; emit orderChanged(m_order); } } void TrackModel::setColor(const QColor& theValue) { if (theValue != m_color) { m_color = theValue; emit colorChanged(m_color); } } void TrackModel::setShowPath(const bool theValue) { if (theValue != m_showPath) { m_showPath = theValue; emit showPathChanged(m_showPath); } } void TrackModel::setFollowTrack(bool theValue) { if (theValue != m_followTrack) { m_followTrack = theValue; emit followTrackChanged(m_followTrack); } if (m_followTrack && m_situation) { foreach (TrackModel *model, m_situation->tracks()) { if (model != this) { model->setFollowTrack(false); } } } } void TrackModel::setSeries(const Boats::Series theValue) { if (theValue != m_series) { m_series = theValue; m_length = Boats::seriesSizeList()[m_series]; emit seriesChanged(m_series); } } void TrackModel::appendDiscardedXml(const QString& theValue) { if (!m_discardedXml.contains(theValue)) { m_discardedXml.append(theValue); } } BoatModel * TrackModel::addBoat(BoatModel *boat, int order) { if (order == -1) { order = m_boats.size(); } m_boats.insert(order, boat); if (debugLevel & 1 << MODEL) std::cout << "Adding Boat " << order+1 << std::endl; for (int i=order+1; isetOrder(i+1); } m_situation->addingBoat(boat); changingTrack(this); return boat; } int TrackModel::deleteBoat(BoatModel *boat) { int order = m_boats.indexOf(boat); m_boats.removeOne(boat); if (debugLevel & 1 << MODEL) std::cout << "Removing Boat " << order+1 << std::endl; for (int i=order; isetOrder(i+1); } m_situation->removingBoat(boat); changingTrack(this); return order; } void TrackModel::displayBoats() { if (debugLevel & 1 << MODEL) std::cout << "Displaying boats" << std::endl; foreach (BoatModel* boat, m_boats) { m_situation->addingBoat(boat); } } void TrackModel::hideBoats() { if (debugLevel & 1 << MODEL) std::cout << "Hiding boats" << std::endl; foreach (BoatModel* boat, m_boats) { m_situation->removingBoat(boat); } } // calculate new heading: // from position of head of index boat to new potential position qreal TrackModel::headingForNext(int index, QPointF point) { const BoatModel* boat = m_boats.at(index); qreal length = m_length / 2.0; qreal theta0 = boat->heading() * M_PI /180; QPointF point2 = point - (boat->position() + QPointF(length*sin(theta0),-length*cos(theta0))); return fmod(atan2 (point2.x(), -point2.y()) * 180 / M_PI + 360.0, 360.0); } void TrackModel::changingTrack(TrackModel *track) { QPainterPath path; QPainterPath wholePath; if (m_boats.size() < 1) { m_path = path; return; } QPointF pos0(m_boats[0]->position()); qreal heading0 = m_boats[0]->heading(); wholePath.moveTo(pos0); BoatModel *oldBoat = m_boats[0]; int i = 1; while (i < m_boats.size() && m_boats[i]->dim() ) { path.moveTo(pos0); BoatModel *boat = m_boats[i]; QPointF pos1(boat->position()); qreal heading1 = boat->heading(); // distance and angle between positions QPointF delta = pos1-pos0; qreal dist = sqrt(pow(delta.x(),2) + pow(delta.y(),2)); qreal theta = fmod(atan2 (delta.x(), -delta.y()) *180/M_PI +360, 360); // empirical factor for control point distance qreal factor = dist*2/5; QPointF c1(pos0); // stalled condition when next boat in the back qreal angle0 = fmod(theta - heading0 +360, 360); bool stalled0 = ((angle0 >= 90) && (angle0 <= 270)); if (!stalled0) { c1 += QPointF(factor*sin(heading0 * M_PI /180), -factor*cos(heading0 * M_PI /180)); } QPointF c2(pos1); // stalled condition when previous boat in the back qreal angle1 = fmod(theta- heading1 +360, 360); bool stalled1 = ((angle1 >= 90) && (angle1 <= 270)) ; if (!stalled1) { c2 -= QPointF(factor*sin(heading1 * M_PI /180), -factor*cos(heading1 * M_PI /180)); } path.cubicTo(c1, c2, pos1); oldBoat->setPath(path); oldBoat = boat; wholePath.cubicTo(c1, c2, pos1); pos0 = pos1; heading0 = heading1; path = QPainterPath(); i++; } m_path = wholePath; emit trackChanged(track); } void TrackModel::setSelected(bool selected) { emit trackSelected(selected); } boats-201307/model/trackmodel.h000066400000000000000000000104161217277220500163250ustar00rootroot00000000000000// // C++ Interface: trackmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2010 Thibaut GRIDEL // // 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 . // // #ifndef TRACKMODEL_H #define TRACKMODEL_H #include #include "boats.h" class SituationModel; class BoatModel; /** \class TrackModel \brief The Model for the Track of a Boat The class represents the Model for a Track, according to an Observer Pattern. TrackModel contains data which describe one boat, like the series of the boat, the color it is drawn and the List of Positions where the boat navigates. It shall not be mistaken with BoatModel, which holds one position at a given time. More exactly, a TrackModel will hold a List of BoatModels. \sa SituationModel, BoatModel */ class TrackModel : public QObject { Q_OBJECT public: TrackModel(SituationModel* situation = 0, QObject *parent = 0); ~TrackModel(); BoatModel * addBoat(BoatModel *boat, int order = -1); int deleteBoat(BoatModel *boat); void displayBoats(); void hideBoats(); // Setters and Getters for Model Data int order() const { return m_order; } void setOrder(const int theValue); QColor color() const { return m_color;} void setColor(const QColor& theValue); Boats::Series series() const { return m_series;} void setSeries(const Boats::Series theValue); bool showPath() const { return m_showPath;} void setShowPath(const bool theValue); bool followTrack() const { return m_followTrack; } void setFollowTrack(bool theValue); int size() const { return m_boats.size();} const QList boats() const { return m_boats; } const QPainterPath path() const { return m_path; } // Setters and Getters for Non model Data SituationModel* situation() const { return m_situation; } int length() const { return m_length; } QStringList discardedXml() const { return m_discardedXml; } void appendDiscardedXml(const QString& theValue); qreal headingForNext(int index, QPointF point); void changingTrack(TrackModel *track); void setSelected(bool selected); signals: // Signals for TrackModel parameters void orderChanged(int order); void colorChanged(QColor color); void seriesChanged(Boats::Series series); void showPathChanged(bool showPath); void followTrackChanged(bool followTrack); void trackChanged(TrackModel *track); void trackSelected(bool selected); private: // Model Data /// \a m_order holds the stacking order of the Track int m_order; /// \a m_color holds the color of the Track QColor m_color; /// \a m_series holds the series of the Track Boats::Series m_series; /// \a m_boats holds the List of Boat Positions of the Track QList m_boats; /// \a m_showPath holds whether the track path will be displayed bool m_showPath; /// \a m_followTrack holds whether this track will be followed /// during the animation bool m_followTrack; // Non model Data /// \a m_situation keeps a pointer to the SituationModel to which /// it belongs SituationModel *m_situation; /// \a m_length holds the size of the Boat in World Coordinates int m_length; /// \a m_path holds the QPainterPath of the Track QPainterPath m_path; /// \a m_discardedXml keeps all unparsed xml tags QStringList m_discardedXml; }; #endif boats-201307/model/windmodel.cpp000066400000000000000000000051771217277220500165250ustar00rootroot00000000000000// // C++ Implementation: windmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #include #include "windmodel.h" #include "commontypes.h" extern int debugLevel; WindModel::WindModel(SituationModel *situation, QObject *parent) : PositionModel(situation, parent), m_visible(false) { if (debugLevel & 1 << MODEL) std::cout << "new Wind " << this << std::endl; } WindModel::~WindModel() { if (debugLevel & 1 << MODEL) std::cout << "delete Wind " << this << std::endl; } void WindModel::setVisible(bool visible) { if (m_visible != visible) { m_visible = visible; emit windVisibleChanged(visible); } } void WindModel::addWind(const qreal direction, int order) { if (order == -1) { order = m_directions.size(); } if (debugLevel & 1 << MODEL) std::cout << "Adding Wind " << order+1 << std::endl; m_directions.insert(order, direction); emit windReset(); } void WindModel::deleteWind(int order) { if (debugLevel & 1 << MODEL) std::cout << "Removing Wind " << order+1 << std::endl; m_directions.removeAt(order); emit windReset(); } void WindModel::clearWind() { setVisible(false); setPosition(QPointF()); m_discardedXml.clear(); m_directions.clear(); emit windReset(); } qreal WindModel::windAt(int order) const { if (order == -1 || order >= m_directions.size()) { order = m_directions.size()-1; } else if (order < -1) { order = 0; } if (m_directions.isEmpty()) { return 0; } return m_directions.at(order); } void WindModel::setWindAt(qreal direction, int order) { if (order < 0 || order > m_directions.size()) { return; } m_directions[order] = direction; if (debugLevel & 1 << MODEL) std::cout << "wind for " << order+1 << " " << direction; emit windReset(); } void WindModel::setDirection(qreal direction) { m_direction = direction; emit directionChanged(m_direction); } boats-201307/model/windmodel.h000066400000000000000000000044431217277220500161650ustar00rootroot00000000000000// // C++ Interface: windmodel // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2011 Thibaut GRIDEL // // 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 . // // #ifndef WINDMODEL_H #define WINDMODEL_H #include "positionmodel.h" /** \class PointModel \brief The Model for Wind directions The class represents the Model for Wind, according to an Observer Pattern. WindModel inherits PositionModel and contains data which represents the directions of the wind of the scenario \sa SituationModel */ class WindModel : public PositionModel { Q_OBJECT Q_PROPERTY(qreal direction READ direction WRITE setDirection) public: WindModel(SituationModel* situation, QObject *parent = 0); ~WindModel(); // Setters and Getters for Model Data bool visible() const { return m_visible; }; void setVisible(bool visible); void addWind(const qreal direction, int order = -1); void deleteWind(int order = -1); void clearWind(); int size() const { return m_directions.size(); }; qreal windAt(int order = -1) const; void setWindAt(qreal direction, int order); // Setters and Getters for Non model Data qreal direction() const { return m_direction; } void setDirection(qreal direction); signals: void windVisibleChanged(bool visible); void windReset(); void directionChanged(qreal); private: // Model Data bool m_visible; QList m_directions; // Non model Data /// m_direction holds the current wind, signalling animation qreal m_direction; }; #endif // WINDMODEL_H boats-201307/situationprint.cpp000066400000000000000000000060501217277220500165260ustar00rootroot00000000000000// // C++ Implementation: situationprint // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009-2012 Thibaut GRIDEL // // 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 . // // #include #include "situationprint.h" #include "commontypes.h" #include "situationmodel.h" #include "situationview.h" extern int debugLevel; SituationPrint::SituationPrint(SituationModel *situation, SituationView *view, QWidget *parent) : QTextEdit(parent), m_situation(situation), m_view(view) { setAcceptRichText(true); } void SituationPrint::render(QRectF pageRect) { if (!m_situation) { return; } QTextCursor cursor(document()); QTextBlockFormat headingblock; headingblock.setAlignment(Qt::AlignHCenter); QTextCharFormat headingchar; headingchar.setFontPointSize(20); headingchar.setFontWeight(2); QTextBlockFormat descblock; descblock.setAlignment(Qt::AlignLeading); QTextCharFormat descchar; descchar.setFontPointSize(14); descchar.setFontWeight(2); QTextBlockFormat textblock; textblock.setAlignment(Qt::AlignLeading); textblock.setIndent(1); QTextCharFormat textchar; textchar.setFontPointSize(12); cursor.insertBlock(headingblock); cursor.insertText(m_situation->title(), headingchar); if (!m_situation->rules().isEmpty()) { cursor.insertBlock(); cursor.insertBlock(descblock); cursor.insertText(tr("Rule") + " ", descchar); cursor.insertText(m_situation->rules(), textchar); } if (!m_situation->abstract().isEmpty()) { cursor.insertBlock(); cursor.insertBlock(descblock); cursor.insertBlock(); cursor.insertBlock(textblock); cursor.insertText(m_situation->abstract(), textchar); } cursor.insertBlock(); cursor.insertBlock(headingblock); QPixmap image(rect().size()); image.fill(Qt::white); QPainter painter(&image); painter.setRenderHints( QPainter::Antialiasing | QPainter::SmoothPixmapTransform); m_view->render(&painter); document()->addResource(QTextDocument::ImageResource, QUrl("mydata://image.png"), QVariant(image)); cursor.insertImage("mydata://image.png"); if (!m_situation->description().isEmpty()) { cursor.insertBlock(); cursor.insertBlock(descblock); cursor.insertBlock(); cursor.insertBlock(textblock); cursor.insertText(m_situation->description(), textchar); } } boats-201307/situationprint.h000066400000000000000000000025041217277220500161730ustar00rootroot00000000000000// // C++ Interface: situationprint // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2009 Thibaut GRIDEL // // 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 . // // #ifndef SITUATIONPRINT_H #define SITUATIONPRINT_H #include class SituationModel; class SituationView; class SituationPrint : public QTextEdit { Q_OBJECT public: SituationPrint(SituationModel *situation, SituationView *view, QWidget *parent = 0); ~SituationPrint() {} void render(QRectF pageRect); public slots: void print(QPrinter *printer) const { QTextEdit::print(printer); } private: SituationModel *m_situation; SituationView *m_view; }; #endif // SITUATIONPRINT_H boats-201307/situationwidget.cpp000066400000000000000000000330251217277220500166570ustar00rootroot00000000000000// // C++ Implementation: situationwidget // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include #include "situationwidget.h" #include "trackdelegate.h" #include "winddelegate.h" #include "situationmodel.h" #include "undocommands.h" extern int debugLevel; SituationWidget::SituationWidget(QWidget *parent) : QTabWidget(parent), m_situation(0) { // Scenario layout scenarioFrame = new QFrame(); scenarioLayout = new QVBoxLayout(scenarioFrame); // Options layout optionsGroup = new QGroupBox(scenarioFrame); optionsGroup->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Maximum); optionsForm = new QFormLayout(optionsGroup); seriesCombo = new QComboBox(optionsGroup); seriesLabel = new QLabel(optionsGroup); optionsForm->addRow(seriesLabel, seriesCombo); laylineCheck = new QCheckBox(optionsGroup); laylineCheckLabel = new QLabel(optionsGroup); optionsForm->addRow(laylineCheckLabel, laylineCheck); laylineSpin = new QSpinBox(optionsGroup); laylineSpinLabel = new QLabel(optionsGroup); optionsForm->addRow(laylineSpinLabel, laylineSpin); lengthSpin = new QSpinBox(optionsGroup); lengthSpinLabel = new QLabel(optionsGroup); optionsForm->addRow(lengthSpinLabel, lengthSpin); windCheck = new QCheckBox(optionsGroup); windCheckLabel = new QLabel(optionsGroup); optionsForm->addRow(windCheckLabel, windCheck); // Track layout trackGroup = new QGroupBox(scenarioFrame); trackLayout = new QGridLayout(trackGroup); trackTableModel = new TrackTableModel(m_situation); trackTableView = new QTableView(trackGroup); trackTableView->setItemDelegate(new TrackDelegate); trackTableView->setEditTriggers(QAbstractItemView::CurrentChanged); trackTableView->verticalHeader()->hide(); trackTableView->horizontalHeader()->setResizeMode(QHeaderView::Fixed); trackTableView->horizontalHeader()->setDefaultSectionSize(60); trackTableView->horizontalHeader()->setStretchLastSection(true); trackTableView->horizontalHeader()->setClickable(false); trackLayout->addWidget(trackTableView); // Wind layout windGroup = new QGroupBox(scenarioFrame); windLayout = new QGridLayout(windGroup); windTableModel = new WindTableModel(&m_situation->wind()); windTableView = new QTableView(windGroup); windTableView->setItemDelegate(new WindDelegate); windTableView->setEditTriggers(QAbstractItemView::CurrentChanged); windTableView->verticalHeader()->hide(); windTableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch); windTableView->horizontalHeader()->setClickable(false); windLayout->addWidget(windTableView); // last bricks scenarioLayout->addWidget(optionsGroup); scenarioLayout->addWidget(trackGroup); scenarioLayout->addWidget(windGroup); addTab(scenarioFrame,tr("Scenario")); // description group descriptionFrame = new QFrame(); descriptionGrid = new QGridLayout(descriptionFrame); descriptionForm = new QFormLayout(); descriptionGrid->addLayout(descriptionForm, 0, 0); titleEdit = new QLineEdit(descriptionFrame); titleLabel = new QLabel(descriptionFrame); descriptionForm->addRow(titleLabel, titleEdit); rulesEdit = new QLineEdit(descriptionFrame); rulesLabel = new QLabel(descriptionFrame); descriptionForm->addRow(rulesLabel, rulesEdit); abstractLabel = new QLabel(descriptionFrame); descriptionGrid->addWidget(abstractLabel,1,0); abstractEdit = new QPlainTextEdit(descriptionFrame); abstractEdit->setUndoRedoEnabled(false); abstractEdit->setContextMenuPolicy(Qt::NoContextMenu); descriptionGrid->addWidget(abstractEdit,2,0); descriptionLabel = new QLabel(descriptionFrame); descriptionGrid->addWidget(descriptionLabel,3,0); descriptionEdit = new QPlainTextEdit(descriptionFrame); descriptionEdit->setUndoRedoEnabled(false); descriptionEdit->setContextMenuPolicy(Qt::NoContextMenu); descriptionGrid->addWidget(descriptionEdit,4,0); addTab(descriptionFrame,tr("Description")); } void SituationWidget::changeEvent(QEvent *event) { if(event->type() == QEvent::LanguageChange) { optionsGroup->setTitle(tr("Options")); seriesLabel->setText(tr("Series")); QStringList seriesList = Boats::seriesList(); for (int i=0; isetItemText(i, seriesList[i]); } laylineCheckLabel->setText(tr("Show Grid")); laylineSpinLabel->setText(tr("Layline Angle")); lengthSpinLabel->setText(tr("Zone Length")); windCheckLabel->setText(tr("Show Wind")); trackGroup->setTitle(tr("Tracks")); windGroup->setTitle(tr("Wind")); setTabText(0, tr("Scenario")); titleLabel->setText(tr("Title")); rulesLabel->setText(tr("Rules")); abstractLabel->setText(tr("Abstract")); descriptionLabel->setText(tr("Description")); setTabText(1, tr("Description")); } else { QTabWidget::changeEvent(event); } } void SituationWidget::update() { if (m_situation) { titleEdit->setText(m_situation->title()); rulesEdit->setText(m_situation->rules()); seriesCombo->setCurrentIndex(m_situation->situationSeries()); laylineCheck->setChecked(m_situation->showLayline()); laylineSpin->setValue(m_situation->laylineAngle()); lengthSpin->setValue(m_situation->situationLength()); windCheck->setChecked(m_situation->wind().visible()); windGroup->setVisible(m_situation->wind().visible()); abstractEdit->setPlainText(m_situation->abstract()); descriptionEdit->setPlainText(m_situation->description()); } } void SituationWidget::setSituation(SituationModel *situation) { if (situation != m_situation) { m_situation = situation; update(); // Scenario Group connect (titleEdit, SIGNAL(editingFinished()), this, SLOT(setTitle())); connect (situation, SIGNAL(titleChanged(QString)), titleEdit, SLOT(setText(QString))); connect (rulesEdit, SIGNAL(editingFinished()), this, SLOT(setRules())); connect (situation, SIGNAL(rulesChanged(QString)), rulesEdit, SLOT(setText(QString))); seriesCombo->addItems(Boats::seriesList()); connect (seriesCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(setSeries(int))); connect (situation, SIGNAL(seriesChanged(int)), seriesCombo, SLOT(setCurrentIndex(int))); connect(laylineCheck, SIGNAL(toggled(bool)), this, SLOT(setShowLayline(bool))); connect(situation, SIGNAL(showLaylineChanged(bool)), laylineCheck, SLOT(setChecked(bool))); laylineSpin->setRange(0, 359); laylineSpin->setWrapping(true); connect (laylineSpin, SIGNAL(valueChanged(int)), this, SLOT(setLayline(int))); connect (situation, SIGNAL(laylineChanged(const int)), laylineSpin, SLOT(setValue(int))); lengthSpin->setRange(1,5); connect (lengthSpin, SIGNAL(valueChanged(int)), this, SLOT(setLength(int))); connect (situation, SIGNAL(lengthChanged(const int)), lengthSpin, SLOT(setValue(int))); connect(windCheck, SIGNAL(toggled(bool)), this, SLOT(setShowWind(bool))); connect(&situation->wind(), SIGNAL(windVisibleChanged(bool)), windCheck, SLOT(setChecked(bool))); connect(windCheck, SIGNAL(toggled(bool)), windGroup, SLOT(setVisible(bool))); connect(abstractEdit->document(), SIGNAL(contentsChanged()), this, SLOT(setAbstract())); connect(situation, SIGNAL(abstractChanged(const QString)), this, SLOT(updateAbstract(const QString))); connect(descriptionEdit->document(), SIGNAL(contentsChanged()), this, SLOT(setDescription())); connect(situation, SIGNAL(descriptionChanged(const QString)), this, SLOT(updateDescription(const QString))); // Track group trackTableModel->setSituation(m_situation); connect(situation, SIGNAL(trackAdded(TrackModel*)), trackTableModel, SLOT(addTrack(TrackModel*))); connect(situation, SIGNAL(trackRemoved(TrackModel*)), trackTableModel, SLOT(deleteTrack(TrackModel*))); trackTableView->setModel(trackTableModel); // Wind group windTableModel->setWind(&m_situation->wind()); connect(&m_situation->wind(), SIGNAL(windReset()), windTableModel, SLOT(updateWind())); windTableView->setModel(windTableModel); } } void SituationWidget::unSetSituation() { // Scenario Group disconnect(titleEdit, 0, 0, 0); titleEdit->clear(); disconnect(rulesEdit, 0, 0, 0); rulesEdit->clear(); disconnect(seriesCombo, 0, 0, 0); disconnect(m_situation, 0, seriesCombo, 0); seriesCombo->clear(); seriesCombo->setCurrentIndex(0); disconnect(laylineCheck, 0, 0, 0); disconnect(m_situation, 0, laylineCheck, 0); laylineCheck->setChecked(true); disconnect(laylineSpin, 0, 0, 0); disconnect(m_situation, 0, laylineSpin, 0); laylineSpin->setValue(40); disconnect(lengthSpin, 0, 0, 0); disconnect(m_situation, 0, lengthSpin, 0); lengthSpin->setValue(3); disconnect(windCheck, 0, 0, 0); disconnect(&m_situation->wind(), 0, windCheck, 0); windCheck->setChecked(false); disconnect(m_situation, 0, this, 0); disconnect(abstractEdit->document(), 0, 0, 0); abstractEdit->clear(); disconnect(descriptionEdit->document(), 0, 0, 0); descriptionEdit->clear(); // Track Group disconnect(m_situation, 0, trackTableModel, 0); disconnect(&m_situation->wind(), 0, windTableModel, 0); m_situation = 0; } void SituationWidget::setTitle() { if (m_situation) { if (titleEdit->text() != m_situation->title()) { m_situation->undoStack()->push(new SetTitleUndoCommand(m_situation, titleEdit->text())); } } } void SituationWidget::setRules() { if (m_situation) { if (rulesEdit->text() != m_situation->rules()) { m_situation->undoStack()->push(new SetRulesUndoCommand(m_situation, rulesEdit->text())); } } } void SituationWidget::setShowLayline(bool show) { if (m_situation) { if (show != m_situation->showLayline()) m_situation->undoStack()->push(new SetShowLaylineUndoCommand(m_situation)); } } void SituationWidget::setLayline(int angle) { if (m_situation) { if (angle != m_situation->laylineAngle()) { m_situation->undoStack()->push(new SetLaylineUndoCommand(m_situation, angle)); } } } void SituationWidget::setLength(int length) { if (m_situation) { if (length != m_situation->situationLength()) { m_situation->undoStack()->push(new LengthMarkUndoCommand(m_situation, length)); } } } void SituationWidget::setShowWind(bool show) { if (m_situation) { if (show != m_situation->wind().visible()) m_situation->undoStack()->push(new SetShowWindUndoCommand(&m_situation->wind())); } } void SituationWidget::setSeries(int series) { if (m_situation) { if (series != m_situation->situationSeries()) { m_situation->undoStack()->push(new SetSituationSeriesUndoCommand(m_situation, series)); } } } void SituationWidget::setAbstract() { if (m_situation) { if (abstractEdit->document()->toPlainText() != m_situation->abstract()) { m_situation->undoStack()->push(new SetAbstractUndoCommand(m_situation, abstractEdit->document()->toPlainText())); } } } void SituationWidget::setDescription() { if (m_situation) { if (descriptionEdit->document()->toPlainText() != m_situation->description()) { m_situation->undoStack()->push(new SetDescriptionUndoCommand(m_situation, descriptionEdit->document()->toPlainText())); } } } void SituationWidget::updateAbstract(const QString abstract) { if (m_situation) { if (abstractEdit->document()->toPlainText() != abstract) { disconnect(abstractEdit->document(), 0, 0, 0); abstractEdit->document()->setPlainText(abstract); connect(abstractEdit->document(), SIGNAL(contentsChanged()), this, SLOT(setAbstract())); } } } void SituationWidget::updateDescription(const QString description) { if (m_situation) { if (descriptionEdit->document()->toPlainText() != description) { disconnect(descriptionEdit->document(), 0, 0, 0); descriptionEdit->document()->setPlainText(description); connect(descriptionEdit->document(), SIGNAL(contentsChanged()), this, SLOT(setDescription())); } } } boats-201307/situationwidget.h000066400000000000000000000055721217277220500163320ustar00rootroot00000000000000// // C++ Interface: situationwidget // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef SITUATIONWIDGET_H #define SITUATIONWIDGET_H #include #include "tracktablemodel.h" #include "windtablemodel.h" class SituationModel; class SituationWidget : public QTabWidget { Q_OBJECT public: SituationWidget(QWidget *parent = 0); ~SituationWidget() {} void update(); public slots: void setSituation(SituationModel *situation); void unSetSituation(); // set the model from widgets void setTitle(); void setRules(); void setShowLayline(bool); void setLayline(int angle); void setSeries(int series); void setLength(int length); void setShowWind(bool); void setAbstract(); void setDescription(); // set the widget from the model void updateAbstract(const QString abstract); void updateDescription(const QString description); protected: void changeEvent(QEvent *event); private: SituationModel *m_situation; QFrame *scenarioFrame; QVBoxLayout *scenarioLayout; QGroupBox *optionsGroup; QComboBox *seriesCombo; QLabel *seriesLabel; QCheckBox *laylineCheck; QLabel *laylineCheckLabel; QSpinBox *laylineSpin; QLabel *laylineSpinLabel; QSpinBox *lengthSpin; QLabel *lengthSpinLabel; QCheckBox *windCheck; QLabel *windCheckLabel; QFormLayout *optionsForm; QGroupBox *trackGroup; TrackTableModel *trackTableModel; QTableView *trackTableView; QGridLayout *trackLayout; QGroupBox *windGroup; WindTableModel *windTableModel; QTableView *windTableView; QGridLayout *windLayout; QFrame *descriptionFrame; QLineEdit *titleEdit; QLabel *titleLabel; QLineEdit *rulesEdit; QLabel *rulesLabel; QPlainTextEdit *abstractEdit; QLabel *abstractLabel; QPlainTextEdit *descriptionEdit; QLabel *descriptionLabel; QGridLayout *descriptionGrid; QFormLayout *descriptionForm; }; #endif boats-201307/trace.cpp000066400000000000000000000027331217277220500145340ustar00rootroot00000000000000// // C++ Implementation: Trace // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #include #include #include "trace.h" int TraceBlock::indent = 0; TraceBlock::TraceBlock(bool active, QString value, int *duration) : m_active(active), m_value(value.toStdString()), m_duration(duration) { if (m_active) { indent++; std::cout << std::string(indent,' ') << "enter " << m_value << std::endl; m_time.start(); } } TraceBlock::~TraceBlock() { if (m_active) { int duration = m_time.elapsed(); std::cout << std::string(indent,' ') << "exit " << m_value << " " << duration << std::endl; indent--; if (m_duration) { *m_duration += duration; } } } boats-201307/trace.h000066400000000000000000000021611217277220500141740ustar00rootroot00000000000000// // C++ Interface: Trace // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2009 Thibaut GRIDEL // // 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 . // // #ifndef TRACE_H #define TRACE_H #include #include class TraceBlock { public: TraceBlock(bool active, QString value, int *duration = 0); ~TraceBlock(); private: static int indent; bool m_active; std::string m_value; QTime m_time; int *m_duration; }; #endif boats-201307/undocommands.cpp000066400000000000000000001502071217277220500161250ustar00rootroot00000000000000// // C++ Implementation: undocommands // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include "undocommands.h" #include #include #include "commontypes.h" #include "boats.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" #include "markmodel.h" #include "polylinemodel.h" #include "pointmodel.h" extern int debugLevel; // Set Title SetTitleUndoCommand::SetTitleUndoCommand(SituationModel* situation, QString title, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldTitle(situation->title()), m_newTitle(title) { if (debugLevel & 1 << COMMAND) std::cout << "new settitleundocommand" << std::endl; } SetTitleUndoCommand::~SetTitleUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end settitleundocommand" << std::endl; } void SetTitleUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo settitleundocommand"<< std::endl; m_situation->setTitle(m_oldTitle); } void SetTitleUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo settitleundocommand" << std::endl; m_situation->setTitle(m_newTitle); } bool SetTitleUndoCommand::mergeWith(const QUndoCommand *command) { const SetTitleUndoCommand *settitleCommand = static_cast(command); if (m_situation != settitleCommand->m_situation) return false; m_newTitle = settitleCommand->m_newTitle; return true; } // Set Rules SetRulesUndoCommand::SetRulesUndoCommand(SituationModel* situation, QString rules, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldRules(situation->rules()), m_newRules(rules) { if (debugLevel & 1 << COMMAND) std::cout << "new setrulesundocommand" << std::endl; } SetRulesUndoCommand::~SetRulesUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setrulesundocommand" << std::endl; } void SetRulesUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setrulesundocommand"<< std::endl; m_situation->setRules(m_oldRules); } void SetRulesUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setrulesundocommand" << std::endl; m_situation->setRules(m_newRules); } bool SetRulesUndoCommand::mergeWith(const QUndoCommand *command) { const SetRulesUndoCommand *setrulesCommand = static_cast(command); if (m_situation != setrulesCommand->m_situation) return false; m_newRules = setrulesCommand->m_newRules; return true; } // Show Layline SetShowLaylineUndoCommand::SetShowLaylineUndoCommand(SituationModel *situation, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation) { if (debugLevel & 1 << COMMAND) std::cout << "new showlaylineundocommand" << std::endl; } SetShowLaylineUndoCommand::~SetShowLaylineUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end showlaylineundocommand" << std::endl; } void SetShowLaylineUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo showlaylineundocommand" << std::endl; m_situation->setShowLayline(!m_situation->showLayline()); } void SetShowLaylineUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo showlaylineundocommand" << std::endl; m_situation->setShowLayline(!m_situation->showLayline()); } bool SetShowLaylineUndoCommand::mergeWith(const QUndoCommand *command) { const SetShowLaylineUndoCommand *zoneCommand = static_cast(command); if (m_situation != zoneCommand->m_situation) return false; undo(); m_situation->undoStack()->setIndex(m_situation->undoStack()->index()-1); return true; } // Set Layline SetLaylineUndoCommand::SetLaylineUndoCommand(SituationModel* situation, const int angle, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldAngle(situation->laylineAngle()), m_newAngle(angle) { if (debugLevel & 1 << COMMAND) std::cout << "new setlaylineundocommand" << std::endl; } SetLaylineUndoCommand::~SetLaylineUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setlaylineundocommand" << std::endl; } void SetLaylineUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setlaylineundocommand" << std::endl; m_situation->setLaylineAngle(m_oldAngle); } void SetLaylineUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setlaylineundocommand" << std::endl; m_situation->setLaylineAngle(m_newAngle); } bool SetLaylineUndoCommand::mergeWith(const QUndoCommand *command) { const SetLaylineUndoCommand *setlaylineCommand = static_cast(command); if (m_situation != setlaylineCommand->m_situation) return false; m_newAngle = setlaylineCommand->m_newAngle; return true; } // Set Series SetSituationSeriesUndoCommand::SetSituationSeriesUndoCommand(SituationModel* situation, const int series, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldSeries(situation->situationSeries()), m_newSeries(series) { if (debugLevel & 1 << COMMAND) std::cout << "new SetSituationSeriesUndoCommand" << std::endl; } SetSituationSeriesUndoCommand::~SetSituationSeriesUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end SetSituationSeriesUndoCommand" << std::endl; } void SetSituationSeriesUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo SetSituationSeriesUndoCommand" << std::endl; m_situation->setSituationSeries(m_oldSeries); } void SetSituationSeriesUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo SetSituationSeriesUndoCommand" << std::endl; m_situation->setSituationSeries(m_newSeries); } bool SetSituationSeriesUndoCommand::mergeWith(const QUndoCommand *command) { const SetSituationSeriesUndoCommand *setseriesCommand = static_cast(command); if (m_situation != setseriesCommand->m_situation) return false; m_newSeries = setseriesCommand->m_newSeries; return true; } // Set Abstract SetAbstractUndoCommand::SetAbstractUndoCommand(SituationModel* situation, QString abstract, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldAbstract(situation->abstract()), m_newAbstract(abstract) { if (debugLevel & 1 << COMMAND) std::cout << "new setabstractundocommand" << std::endl; } SetAbstractUndoCommand::~SetAbstractUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setabstractundocommand" << std::endl; } void SetAbstractUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setabstractundocommand"<< std::endl; m_situation->setAbstract(m_oldAbstract); } void SetAbstractUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setabstractundocommand" << std::endl; m_situation->setAbstract(m_newAbstract); } bool SetAbstractUndoCommand::mergeWith(const QUndoCommand *command) { const SetAbstractUndoCommand *setabstractCommand = static_cast(command); if (m_situation != setabstractCommand->m_situation) return false; m_newAbstract = setabstractCommand->m_newAbstract; return true; } // Set Description SetDescriptionUndoCommand::SetDescriptionUndoCommand(SituationModel* situation, QString description, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldDescription(situation->description()), m_newDescription(description) { if (debugLevel & 1 << COMMAND) std::cout << "new setdescriptionundocommand" << std::endl; } SetDescriptionUndoCommand::~SetDescriptionUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setdescriptionundocommand" << std::endl; } void SetDescriptionUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setdescriptionundocommand"<< std::endl; m_situation->setDescription(m_oldDescription); } void SetDescriptionUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setdescriptionundocommand" << std::endl; m_situation->setDescription(m_newDescription); } bool SetDescriptionUndoCommand::mergeWith(const QUndoCommand *command) { const SetDescriptionUndoCommand *setdescriptionCommand = static_cast(command); if (m_situation != setdescriptionCommand->m_situation) return false; m_newDescription = setdescriptionCommand->m_newDescription; return true; } // Add Track AddTrackUndoCommand::AddTrackUndoCommand(SituationModel* situation, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation) { if (debugLevel & 1 << COMMAND) std::cout << "new addtrackundocommand" << std::endl; m_track = new TrackModel(situation); } AddTrackUndoCommand::~AddTrackUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end addtrackundocommand" << std::endl; delete m_track; } void AddTrackUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo addtrackundocommand" << std::endl; m_situation->addTrack(m_track); } void AddTrackUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo addtrackundocommand" << std::endl; m_situation->deleteTrack(m_track); } // Delete Track DeleteTrackUndoCommand::DeleteTrackUndoCommand(SituationModel* situation, TrackModel* track, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_track(track) { if (debugLevel & 1 << COMMAND) std::cout << "new removetrackundocommand" << std::endl; } DeleteTrackUndoCommand::~DeleteTrackUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end removetrackundocommand" << std::endl; } void DeleteTrackUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo removetrackundocommand" << std::endl; m_situation->deleteTrack(m_track); } void DeleteTrackUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo removetrackundocommand" << std::endl; m_situation->addTrack(m_track); } // Set Series SetSeriesUndoCommand::SetSeriesUndoCommand(TrackModel* track, const Boats::Series series, QUndoCommand *parent) : QUndoCommand(parent), m_track(track), m_oldSeries(track->series()), m_newSeries(series) { if (debugLevel & 1 << COMMAND) std::cout << "new setseriesundocommand" << std::endl; } SetSeriesUndoCommand::~SetSeriesUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setseriesundocommand" << std::endl; } void SetSeriesUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setseriesundocommand" << std::endl; m_track->setSeries(m_oldSeries); } void SetSeriesUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setseriesundocommand" << std::endl; m_track->setSeries(m_newSeries); } bool SetSeriesUndoCommand::mergeWith(const QUndoCommand *command) { const SetSeriesUndoCommand *seriesCommand = static_cast(command); if (m_track != seriesCommand->m_track) return false; m_newSeries = seriesCommand->m_newSeries; return true; } // Set Color SetColorUndoCommand::SetColorUndoCommand(TrackModel* track, const QColor color, QUndoCommand *parent) : QUndoCommand(parent), m_track(track), m_oldColor(track->color()), m_newColor(color) { if (debugLevel & 1 << COMMAND) std::cout << "new setcolorundocommand" << std::endl; } SetColorUndoCommand::~SetColorUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setcolorundocommand" << std::endl; } void SetColorUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setcolorundocommand" << std::endl; m_track->setColor(m_oldColor); } void SetColorUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setcolorundocommand" << std::endl; m_track->setColor(m_newColor); } bool SetColorUndoCommand::mergeWith(const QUndoCommand *command) { const SetColorUndoCommand *colorCommand = static_cast(command); if (m_track != colorCommand->m_track) return false; m_newColor = colorCommand->m_newColor; return true; } // Show Path SetShowPathUndoCommand::SetShowPathUndoCommand(TrackModel *track, QUndoCommand *parent) : QUndoCommand(parent), m_track(track) { if (debugLevel & 1 << COMMAND) std::cout << "new showlaylineundocommand" << std::endl; } SetShowPathUndoCommand::~SetShowPathUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end showlaylineundocommand" << std::endl; } void SetShowPathUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo showlaylineundocommand" << std::endl; m_track->setShowPath(!m_track->showPath()); } void SetShowPathUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo showlaylineundocommand" << std::endl; m_track->setShowPath(!m_track->showPath()); } bool SetShowPathUndoCommand::mergeWith(const QUndoCommand *command) { const SetShowPathUndoCommand *showPathCommand = static_cast(command); if (m_track != showPathCommand->m_track) return false; undo(); m_track->situation()->undoStack()->setIndex(m_track->situation()->undoStack()->index()-1); return true; } // Follow Track SetFollowTrackUndoCommand::SetFollowTrackUndoCommand(SituationModel* situation, TrackModel *track, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_track(track) { if (debugLevel & 1 << COMMAND) std::cout << "new followtrackundocommand" << std::endl; foreach (TrackModel *tracks, situation->tracks()) { m_followTrackList.append(tracks->followTrack()); } } SetFollowTrackUndoCommand::~SetFollowTrackUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end followtrackundocommand" << std::endl; } void SetFollowTrackUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo followtrackundocommand" << std::endl; for (int i=0; isize(); ++i) { TrackModel *tracks = m_situation->tracks()[i]; tracks->setFollowTrack(m_followTrackList.at(i)); } } void SetFollowTrackUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo followtrackundocommand" << std::endl; m_track->setFollowTrack(!m_track->followTrack()); } bool SetFollowTrackUndoCommand::mergeWith(const QUndoCommand *command) { return false; } // Lookat SetLookAtUndoCommand::SetLookAtUndoCommand(SituationModel* situation, int lookDirection, int tilt, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldLookDirection(situation->lookDirection()), m_newLookDirection(lookDirection), m_oldTilt(situation->tilt()), m_newTilt(tilt) { if (debugLevel & 1 << COMMAND) std::cout << "new lookatundocommand" << std::endl; } SetLookAtUndoCommand::~SetLookAtUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end lookatundocommand" << std::endl; } void SetLookAtUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo lookatundocommand" << std::endl; m_situation->setLookDirection(m_oldLookDirection); m_situation->setTilt(m_oldTilt); } void SetLookAtUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo lookatundocommand" << std::endl; m_situation->setLookDirection(m_newLookDirection); m_situation->setTilt(m_newTilt); } bool SetLookAtUndoCommand::mergeWith(const QUndoCommand *command) { const SetLookAtUndoCommand *lookatCommand = static_cast(command); if (m_situation != lookatCommand->m_situation) return false; m_newLookDirection = lookatCommand->m_newLookDirection; m_newTilt = lookatCommand->m_newTilt; return true; } // Show Wind SetShowWindUndoCommand::SetShowWindUndoCommand(WindModel *wind, QUndoCommand *parent) : QUndoCommand(parent), m_wind(wind) { if (debugLevel & 1 << COMMAND) std::cout << "new showwindundocommand" << std::endl; } SetShowWindUndoCommand::~SetShowWindUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end showwindundocommand" << std::endl; } void SetShowWindUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo showwindundocommand" << std::endl; m_wind->setVisible(!m_wind->visible()); } void SetShowWindUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo showwindundocommand" << std::endl; m_wind->setVisible(!m_wind->visible()); } bool SetShowWindUndoCommand::mergeWith(const QUndoCommand *command) { const SetShowWindUndoCommand *visibleCommand = static_cast(command); if (m_wind != visibleCommand->m_wind) return false; undo(); m_wind->situation()->undoStack()->setIndex(m_wind->situation()->undoStack()->index()-1); return true; } // Add Wind AddWindUndoCommand::AddWindUndoCommand(WindModel* wind, qreal heading, QUndoCommand *parent) : QUndoCommand(parent), m_wind(wind), m_heading(heading) { if (debugLevel & 1 << COMMAND) std::cout << "new addwindundocommand" << std::endl; } AddWindUndoCommand::~AddWindUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end addwindundocommand" << std::endl; } void AddWindUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo addwindundocommand" << std::endl; m_wind->addWind(m_heading); } void AddWindUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo addwindundocommand" << std::endl; m_wind->deleteWind(m_wind->size()-1); } // Set Wind SetWindUndoCommand::SetWindUndoCommand(WindModel* wind, int index, qreal direction, QUndoCommand *parent) : QUndoCommand(parent), m_wind(wind), m_index(index), m_oldDirection(wind->windAt(index)), m_newDirection(direction) { if (debugLevel & 1 << COMMAND) std::cout << "new setwindundocommand" << std::endl; } SetWindUndoCommand::~SetWindUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setwindundocommand" << std::endl; } void SetWindUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setwindundocommand" << std::endl; m_wind->setWindAt(m_oldDirection, m_index); } void SetWindUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setwindundocommand" << std::endl; m_wind->setWindAt(m_newDirection, m_index); } bool SetWindUndoCommand::mergeWith(const QUndoCommand *command) { const SetWindUndoCommand *setWindCommand = static_cast(command); if (m_index != setWindCommand->m_index) return false; m_newDirection = setWindCommand->m_newDirection; return true; } // Delete Wind DeleteWindUndoCommand::DeleteWindUndoCommand(WindModel* wind, int index, QUndoCommand *parent) : QUndoCommand(parent), m_wind(wind), m_index(index), m_heading(m_wind->windAt(index)) { if (debugLevel & 1 << COMMAND) std::cout << "new deletewindundocommand" << std::endl; } DeleteWindUndoCommand::~DeleteWindUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end deletewindundocommand" << std::endl; } void DeleteWindUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo deletewindundocommand" << std::endl; m_wind->deleteWind(m_index); } void DeleteWindUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo deletewindundocommand" << std::endl; m_wind->addWind(m_heading, m_index); } // Move Model MoveModelUndoCommand::MoveModelUndoCommand(QList &modelList, const QPointF &deltaPosition, QUndoCommand *parent) : QUndoCommand(parent), m_modelList(modelList), m_deltaPosition(deltaPosition) { if (debugLevel & 1 << COMMAND) std::cout << "new movemodelundocommand" << std::endl; } MoveModelUndoCommand::~MoveModelUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end movemodelundocommand" << std::endl; } void MoveModelUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo movemodelundocommand" << std::endl; for(int i=0; i< m_modelList.size(); i++) { PositionModel *model = m_modelList[i]; model->setPosition(model->position() - m_deltaPosition); } } void MoveModelUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo movemodelundocommand" << std::endl; for(int i=0; i< m_modelList.size(); i++) { PositionModel *model = m_modelList[i]; model->setPosition(model->position() + m_deltaPosition); } } bool MoveModelUndoCommand::mergeWith(const QUndoCommand *command) { const MoveModelUndoCommand *moveCommand = static_cast(command); if (m_modelList != moveCommand->m_modelList) return false; m_deltaPosition += moveCommand->m_deltaPosition; return true; } // Laylines Boat SetLaylinesUndoCommand::SetLaylinesUndoCommand(QList &modelList, bool laylines, QUndoCommand *parent) : QUndoCommand(parent), m_modelList(modelList), m_laylines(laylines) { if (debugLevel & 1 << COMMAND) std::cout << "new laylinesboatundocommand" << std::endl; foreach (const PositionModel *model, modelList) { m_laylinesList << model->laylines(); } } SetLaylinesUndoCommand::~SetLaylinesUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end laylinesboatundocommand" << std::endl; } void SetLaylinesUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo laylinesboatundocommand" << std::endl; for(int i=0; i< m_modelList.size(); i++) { PositionModel *model = m_modelList[i]; model->setLaylines(m_laylinesList[i]); } } void SetLaylinesUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo laylinesboatundocommand" << std::endl; for(int i=0; i< m_modelList.size(); i++) { PositionModel *model = m_modelList[i]; model->setLaylines(m_laylines); } } bool SetLaylinesUndoCommand::mergeWith(const QUndoCommand *command) { const SetLaylinesUndoCommand *laylinesCommand = static_cast(command); if (m_modelList != laylinesCommand->m_modelList) return false; m_laylines = laylinesCommand->m_laylines; return true; } // Add Boat AddBoatUndoCommand::AddBoatUndoCommand(TrackModel* track, QPointF& position, qreal heading, QUndoCommand *parent) : QUndoCommand(parent), m_track(track) { if (debugLevel & 1 << COMMAND) std::cout << "new addboatundocommand" << std::endl; m_boat = new BoatModel(track); m_boat->setPosition(position); m_boat->setHeading(heading); } AddBoatUndoCommand::~AddBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end addboatundocommand" << std::endl; delete m_boat; } void AddBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo addboatundocommand" << std::endl; m_track->addBoat(m_boat); } void AddBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo addboatundocommand" << std::endl; m_track->deleteBoat(m_boat); } // Rotate Models RotateModelsUndoCommand::RotateModelsUndoCommand(QList &modelList, const qreal &angle, QUndoCommand *parent) : QUndoCommand(parent), m_modelList(modelList), m_angle(angle) { if (debugLevel & 1 << COMMAND) std::cout << "new rotatemodelsundocommand" << std::endl; foreach (const PositionModel *model, modelList) { m_headingList << model->heading(); } } RotateModelsUndoCommand::~RotateModelsUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end rotatemodelsundocommand" << std::endl; } void RotateModelsUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo rotatemodelsundocommand" << std::endl; for(int i=0; i< m_modelList.size(); i++) { PositionModel *model = m_modelList[i]; model->setHeading(m_headingList[i]); } } void RotateModelsUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo rotatemodelsundocommand" << std::endl; for(int i=0; i< m_modelList.size(); i++) { PositionModel *model = m_modelList[i]; model->setHeading(model->heading() + m_angle); } } bool RotateModelsUndoCommand::mergeWith(const QUndoCommand *command) { const RotateModelsUndoCommand *headingCommand = static_cast(command); if (m_modelList != headingCommand->m_modelList) return false; m_angle += headingCommand->m_angle; return true; } // Overlap Boat OverlapBoatUndoCommand::OverlapBoatUndoCommand(SituationModel* situation, QList &boatList, Boats::Overlaps overlaps, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_boatList(boatList), m_overlaps(overlaps) { if (debugLevel & 1 << COMMAND) std::cout << "new overlapboatundocommand" << std::endl; } OverlapBoatUndoCommand::~OverlapBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end overlapboatundocommand" << std::endl; } void OverlapBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo overlapboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setOverlap(boat->overlap() ^ m_overlaps); } } void OverlapBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo overlapboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setOverlap(boat->overlap() ^ m_overlaps); } } bool OverlapBoatUndoCommand::mergeWith(const QUndoCommand *command) { const OverlapBoatUndoCommand *overlapCommand = static_cast(command); if (m_boatList != overlapCommand->m_boatList) return false; if ((m_overlaps ^ overlapCommand->m_overlaps) == Boats::none) { undo(); m_situation->undoStack()->setIndex(m_situation->undoStack()->index()-1); } else { m_overlaps = m_overlaps ^ overlapCommand->m_overlaps; } return true; } // Flag Boat FlagBoatUndoCommand::FlagBoatUndoCommand(SituationModel* situation, QList &boatList, Boats::Flag flag, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_boatList(boatList), m_flag(flag) { if (debugLevel & 1 << COMMAND) std::cout << "new flagboatundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_flagList << boat->flag(); } } FlagBoatUndoCommand::~FlagBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end flagboatundocommand" << std::endl; } void FlagBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo flagboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setFlag(m_flagList[i]); } } void FlagBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo flagboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setFlag(m_flag); } } bool FlagBoatUndoCommand::mergeWith(const QUndoCommand *command) { const FlagBoatUndoCommand *flagCommand = static_cast(command); if (m_boatList != flagCommand->m_boatList) return false; m_flag = flagCommand->m_flag; return true; } // Trim Boat TrimBoatUndoCommand::TrimBoatUndoCommand(QList &boatList, const qreal &trim, QUndoCommand *parent) : QUndoCommand(parent), m_boatList(boatList), m_trim(trim) { if (debugLevel & 1 << COMMAND) std::cout << "new trimboatundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_trimList << boat->trim(); m_jibTrimList << boat->jibTrim(); } } TrimBoatUndoCommand::~TrimBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end trimboatundocommand" << std::endl; } void TrimBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo trimboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *model = m_boatList[i]; model->setTrim(m_trimList[i]); model->setJibTrim(m_jibTrimList[i]); } } void TrimBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo trimboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *model = m_boatList[i]; model->setTrim(m_trim); model->setJibTrim(m_trim); } } bool TrimBoatUndoCommand::mergeWith(const QUndoCommand *command) { const TrimBoatUndoCommand *trimCommand = static_cast(command); if (m_boatList != trimCommand->m_boatList) return false; m_trim = trimCommand->m_trim; return true; } // Trim Jib TrimJibUndoCommand::TrimJibUndoCommand(QList &boatList, const qreal &trim, QUndoCommand *parent) : QUndoCommand(parent), m_boatList(boatList), m_trim(trim) { if (debugLevel & 1 << COMMAND) std::cout << "new trimjibundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_trimList << boat->jibTrim(); } } TrimJibUndoCommand::~TrimJibUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end trimjibundocommand" << std::endl; } void TrimJibUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo trimjibundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *model = m_boatList[i]; model->setJibTrim(m_trimList[i]); } } void TrimJibUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo trimjibundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *model = m_boatList[i]; model->setJibTrim(m_trim); } } bool TrimJibUndoCommand::mergeWith(const QUndoCommand *command) { const TrimJibUndoCommand *trimCommand = static_cast(command); if (m_boatList != trimCommand->m_boatList) return false; m_trim = trimCommand->m_trim; return true; } // Trim Spin TrimSpinUndoCommand::TrimSpinUndoCommand(QList &boatList, const qreal &trim, QUndoCommand *parent) : QUndoCommand(parent), m_boatList(boatList), m_trim(trim) { if (debugLevel & 1 << COMMAND) std::cout << "new trimspinundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_trimList << boat->spinTrim(); } } TrimSpinUndoCommand::~TrimSpinUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end trimspinundocommand" << std::endl; } void TrimSpinUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo trimspinundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *model = m_boatList[i]; model->setSpinTrim(m_trimList[i]); } } void TrimSpinUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo trimspinundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *model = m_boatList[i]; model->setSpinTrim(m_trim); } } bool TrimSpinUndoCommand::mergeWith(const QUndoCommand *command) { const TrimSpinUndoCommand *trimCommand = static_cast(command); if (m_boatList != trimCommand->m_boatList) return false; m_trim += trimCommand->m_trim; return true; } // Spin Boat SpinBoatUndoCommand::SpinBoatUndoCommand(SituationModel* situation, QList &boatList, bool spin, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_boatList(boatList), m_spin(spin) { if (debugLevel & 1 << COMMAND) std::cout << "new spinboatundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_spinList << boat->spin(); } } SpinBoatUndoCommand::~SpinBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end spinboatundocommand" << std::endl; } void SpinBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo spinboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setSpin(m_spinList[i]); } } void SpinBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo spinboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setSpin(m_spin); } } bool SpinBoatUndoCommand::mergeWith(const QUndoCommand *command) { const SpinBoatUndoCommand *spinCommand = static_cast(command); if (m_boatList != spinCommand->m_boatList) return false; m_spin = spinCommand->m_spin; return true; } // Hidden Boat HiddenBoatUndoCommand::HiddenBoatUndoCommand(SituationModel* situation, QList &boatList, bool hidden, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_boatList(boatList), m_hidden(hidden) { if (debugLevel & 1 << COMMAND) std::cout << "new hiddenboatundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_hiddenList << boat->hidden(); } } HiddenBoatUndoCommand::~HiddenBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end hiddenboatundocommand" << std::endl; } void HiddenBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo hiddenboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setHidden(m_hiddenList[i]); } } void HiddenBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo hiddenboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setHidden(m_hidden); } } bool HiddenBoatUndoCommand::mergeWith(const QUndoCommand *command) { const HiddenBoatUndoCommand *hiddenCommand = static_cast(command); if (m_boatList != hiddenCommand->m_boatList) return false; m_hidden = hiddenCommand->m_hidden; return true; } // Accelerate Boat AccelerateBoatUndoCommand::AccelerateBoatUndoCommand(SituationModel* situation, QList &boatList, Boats::Acceleration acceleration, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_boatList(boatList), m_acceleration(acceleration) { if (debugLevel & 1 << COMMAND) std::cout << "new accelerateboatundocommand" << std::endl; foreach (const BoatModel *boat, boatList) { m_accelerationList << boat->acceleration(); } } AccelerateBoatUndoCommand::~AccelerateBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end accelerateboatundocommand" << std::endl; } void AccelerateBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo accelerateboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setAcceleration(m_accelerationList[i]); } } void AccelerateBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo accelerateboatundocommand" << std::endl; for(int i=0; i< m_boatList.size(); i++) { BoatModel *boat = m_boatList[i]; boat->setAcceleration(m_acceleration); } } bool AccelerateBoatUndoCommand::mergeWith(const QUndoCommand *command) { const AccelerateBoatUndoCommand *accelerationCommand = static_cast(command); if (m_boatList != accelerationCommand->m_boatList) return false; m_acceleration = accelerationCommand->m_acceleration; return true; } // Set Text SetTextUndoCommand::SetTextUndoCommand(PositionModel* model, QString text, QUndoCommand *parent) : QUndoCommand(parent), m_model(model), m_oldText(model->text()), m_newText(text) { if (debugLevel & 1 << COMMAND) std::cout << "new settextundocommand" << std::endl; } SetTextUndoCommand::~SetTextUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end settextundocommand" << std::endl; } void SetTextUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo settextundocommand"<< std::endl; m_model->setText(m_oldText); } void SetTextUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo settextundocommand" << std::endl; m_model->setText(m_newText); } bool SetTextUndoCommand::mergeWith(const QUndoCommand *command) { const SetTextUndoCommand *setTextCommand = static_cast(command); if (m_model != setTextCommand->m_model) return false; m_newText = setTextCommand->m_newText; return true; } // Move Text MoveTextUndoCommand::MoveTextUndoCommand(PositionModel *model, const QPointF &deltaPosition, QUndoCommand *parent) : QUndoCommand(parent), m_model(model), m_deltaPosition(deltaPosition) { if (debugLevel & 1 << COMMAND) std::cout << "new movetextundocommand" << std::endl; } MoveTextUndoCommand::~MoveTextUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end movetextundocommand" << std::endl; } void MoveTextUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo movetextundocommand" << std::endl; m_model->setTextPosition(m_model->textPosition() - m_deltaPosition); } void MoveTextUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo movetextundocommand" << std::endl; m_model->setTextPosition(m_model->textPosition() + m_deltaPosition); } bool MoveTextUndoCommand::mergeWith(const QUndoCommand *command) { const MoveTextUndoCommand *moveCommand = static_cast(command); if (m_model != moveCommand->m_model) return false; m_deltaPosition += moveCommand->m_deltaPosition; return true; } // Delete Boat DeleteBoatUndoCommand::DeleteBoatUndoCommand(TrackModel* track, BoatModel* boat, QUndoCommand *parent) : QUndoCommand(parent), m_track(track), m_boat(boat) { if (debugLevel & 1 << COMMAND) std::cout << "new deleteboatundocommand" << std::endl; } DeleteBoatUndoCommand::~DeleteBoatUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end deletebboatundocommand" << std::endl; } void DeleteBoatUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo deletebboatundocommand" << std::endl; m_order = m_track->deleteBoat(m_boat); } void DeleteBoatUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo deletebboatundocommand" << std::endl; m_track->addBoat(m_boat, m_order); } // Add Mark AddMarkUndoCommand::AddMarkUndoCommand(SituationModel* situation, QPointF& position, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation) { if (debugLevel & 1 << COMMAND) std::cout << "new addmarkundocommand" << std::endl; m_mark = new MarkModel(situation); m_mark->setPosition(position); } AddMarkUndoCommand::~AddMarkUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end addmarkundocommand" << std::endl; delete m_mark; } void AddMarkUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo addmarkundocommand" << std::endl; m_situation->addMark(m_mark); } void AddMarkUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo addmarkundocommand" << std::endl; m_situation->deleteMark(m_mark); } // Zone Mark ZoneMarkUndoCommand::ZoneMarkUndoCommand(SituationModel *situation, const QList &markList, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_markList(markList) { if (debugLevel & 1 << COMMAND) std::cout << "new zonemarkundocommand" << std::endl; } ZoneMarkUndoCommand::~ZoneMarkUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end zonemarkundocommand" << std::endl; } void ZoneMarkUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo zonemarkundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setZone(!mark->zone()); } } void ZoneMarkUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo zonemarkundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setZone(!mark->zone()); } } bool ZoneMarkUndoCommand::mergeWith(const QUndoCommand *command) { const ZoneMarkUndoCommand *zoneCommand = static_cast(command); if (m_markList != zoneCommand->m_markList) return false; undo(); m_situation->undoStack()->setIndex(m_situation->undoStack()->index()-1); return true; } // Color Mark ColorMarkUndoCommand::ColorMarkUndoCommand(SituationModel *situation, const QList &markList, const QColor &color, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_markList(markList), m_newColor(color) { if (debugLevel & 1 << COMMAND) std::cout << "new colormarkundocommand" << std::endl; foreach( MarkModel *mark, markList) { m_oldColors.append(mark->color()); } } ColorMarkUndoCommand::~ColorMarkUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end colormarkundocommand" << std::endl; } void ColorMarkUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo colormarkundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setColor(m_oldColors[i]); } } void ColorMarkUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo colormarkundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setColor(m_newColor); } } bool ColorMarkUndoCommand::mergeWith(const QUndoCommand *command) { const ColorMarkUndoCommand *colorCommand = static_cast(command); if (m_markList != colorCommand->m_markList) return false; m_newColor = colorCommand->m_newColor; return true; } // Set Length LengthMarkUndoCommand::LengthMarkUndoCommand(SituationModel* situation, const int length, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_oldLength(situation->situationLength()), m_newLength(length) { if (debugLevel & 1 << COMMAND) std::cout << "new lengthmarkundocommand" << std::endl; } LengthMarkUndoCommand::~LengthMarkUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end lengthmarkundocommand" << std::endl; } void LengthMarkUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo lengthmarkundocommand" << std::endl; m_situation->setSituationLength(m_oldLength); } void LengthMarkUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo lengthmarkundocommand" << std::endl; m_situation->setSituationLength(m_newLength); } bool LengthMarkUndoCommand::mergeWith(const QUndoCommand *command) { const LengthMarkUndoCommand *lengthmarkCommand = static_cast(command); if (m_situation != lengthmarkCommand->m_situation) return false; m_newLength = lengthmarkCommand->m_newLength; return true; } // Toggle Mark Side ToggleMarkSideUndoCommand::ToggleMarkSideUndoCommand(const QList &markList, QUndoCommand *parent) : QUndoCommand(parent), m_markList(markList) { if (debugLevel & 1 << COMMAND) std::cout << "new togglemarksideundocommand" << std::endl; } ToggleMarkSideUndoCommand::~ToggleMarkSideUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end togglemarksideundocommand" << std::endl; } void ToggleMarkSideUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo togglemarksideundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setLeaveToPort(!mark->leaveToPort()); } } void ToggleMarkSideUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo togglemarksideundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setLeaveToPort(!mark->leaveToPort()); } } // Toggle Mark Arrow ToggleMarkArrowUndoCommand::ToggleMarkArrowUndoCommand(const QList &markList, QUndoCommand *parent) : QUndoCommand(parent), m_markList(markList) { if (debugLevel & 1 << COMMAND) std::cout << "new togglemarkarrowundocommand" << std::endl; } ToggleMarkArrowUndoCommand::~ToggleMarkArrowUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end togglemarkarrowundocommand" << std::endl; } void ToggleMarkArrowUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo togglemarkarrowundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setArrowVisible(!mark->arrowVisible()); } } void ToggleMarkArrowUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo togglemarkarrowundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setArrowVisible(!mark->arrowVisible()); } } // Toggle Mark Label ToggleMarkLabelUndoCommand::ToggleMarkLabelUndoCommand(const QList &markList, QUndoCommand *parent) : QUndoCommand(parent), m_markList(markList) { if (debugLevel & 1 << COMMAND) std::cout << "new togglemarklabelundocommand" << std::endl; } ToggleMarkLabelUndoCommand::~ToggleMarkLabelUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end togglemarklabelundocommand" << std::endl; } void ToggleMarkLabelUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo togglemarklabelundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setLabelVisible(!mark->labelVisible()); } } void ToggleMarkLabelUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo togglemarklabelundocommand" << std::endl; for(int i=0; i< m_markList.size(); i++) { MarkModel *mark = m_markList[i]; mark->setLabelVisible(!mark->labelVisible()); } } // Set Mark Text SetMarkLabelUndoCommand::SetMarkLabelUndoCommand(MarkModel* mark, QString text, QUndoCommand *parent) : QUndoCommand(parent), m_mark(mark), m_oldText(mark->labelText()), m_newText(text) { if (debugLevel & 1 << COMMAND) std::cout << "new setmarklabelundocommand" << std::endl; } SetMarkLabelUndoCommand::~SetMarkLabelUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end setmarklabelundocommand" << std::endl; } void SetMarkLabelUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo setmarklabelundocommand"<< std::endl; m_mark->setLabelText(m_oldText); } void SetMarkLabelUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo setmarklabelundocommand" << std::endl; m_mark->setLabelText(m_newText); } bool SetMarkLabelUndoCommand::mergeWith(const QUndoCommand *command) { const SetMarkLabelUndoCommand *setMarkLabelCommand = static_cast(command); if (m_mark != setMarkLabelCommand->m_mark) return false; m_newText = setMarkLabelCommand->m_newText; return true; } // Delete Mark DeleteMarkUndoCommand::DeleteMarkUndoCommand(SituationModel* situation, MarkModel* mark, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_mark(mark) { if (debugLevel & 1 << COMMAND) std::cout << "new deletemarkundocommand" << std::endl; } DeleteMarkUndoCommand::~DeleteMarkUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end deletebmarkundocommand" << std::endl; } void DeleteMarkUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo deletebmarkundocommand" << std::endl; m_order = m_situation->deleteMark(m_mark); } void DeleteMarkUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo deletebmarkundocommand" << std::endl; m_situation->addMark(m_mark, m_order); } // Add PolyLine AddPolyLineUndoCommand::AddPolyLineUndoCommand(SituationModel* situation, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation) { if (debugLevel & 1 << COMMAND) std::cout << "new addpolylineundocommand" << std::endl; m_polyLine = new PolyLineModel(situation); } AddPolyLineUndoCommand::~AddPolyLineUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end addpolylineundocommand" << std::endl; delete m_polyLine; } void AddPolyLineUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo addpolylineundocommand" << std::endl; m_situation->addPolyLine(m_polyLine); } void AddPolyLineUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo addpolylineundocommand" << std::endl; m_situation->deletePolyLine(m_polyLine); } // Delete PolyLine DeletePolyLineUndoCommand::DeletePolyLineUndoCommand(SituationModel* situation, PolyLineModel* polyLine, QUndoCommand *parent) : QUndoCommand(parent), m_situation(situation), m_polyLine(polyLine) { if (debugLevel & 1 << COMMAND) std::cout << "new removepolylineundocommand" << std::endl; } DeletePolyLineUndoCommand::~DeletePolyLineUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end removepolylineundocommand" << std::endl; } void DeletePolyLineUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo removepolylineundocommand" << std::endl; m_situation->deletePolyLine(m_polyLine); } void DeletePolyLineUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo removepolylineundocommand" << std::endl; m_situation->addPolyLine(m_polyLine); } // Add Point AddPointUndoCommand::AddPointUndoCommand(PolyLineModel* polyLine, QPointF& position, QUndoCommand *parent) : QUndoCommand(parent), m_polyLine(polyLine) { if (debugLevel & 1 << COMMAND) std::cout << "new addpointundocommand" << std::endl; m_point = new PointModel(polyLine); m_point->setPosition(position); } AddPointUndoCommand::~AddPointUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end addpointundocommand" << std::endl; delete m_point; } void AddPointUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo addpointundocommand" << std::endl; m_polyLine->addPoint(m_point); } void AddPointUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo addpointundocommand" << std::endl; m_polyLine->deletePoint(m_point); } // Delete Point DeletePointUndoCommand::DeletePointUndoCommand(PolyLineModel* polyLine, PointModel* point, QUndoCommand *parent) : QUndoCommand(parent), m_polyLine(polyLine), m_point(point) { if (debugLevel & 1 << COMMAND) std::cout << "new deletepointundocommand" << std::endl; } DeletePointUndoCommand::~DeletePointUndoCommand() { if (debugLevel & 1 << COMMAND) std::cout << "end deletepointundocommand" << std::endl; } void DeletePointUndoCommand::redo() { if (debugLevel & 1 << COMMAND) std::cout << "redo deletepointundocommand" << std::endl; m_order = m_polyLine->deletePoint(m_point); } void DeletePointUndoCommand::undo() { if (debugLevel & 1 << COMMAND) std::cout << "undo deletepointundocommand" << std::endl; m_polyLine->addPoint(m_point, m_order); } boats-201307/undocommands.h000066400000000000000000000510141217277220500155660ustar00rootroot00000000000000// // C++ Interface: undocommands // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef UNDOCOMMANDS_H #define UNDOCOMMANDS_H #include #include #include "boats.h" class SituationModel; class TrackModel; class PositionModel; class BoatModel; class MarkModel; class PolyLineModel; class PointModel; class WindModel; enum { SET_TITLE, SET_RULES, SET_SHOWLAYLINE, SET_LAYLINE, SET_SITUATIONSERIES, SET_ABSTRACT, SET_DESCRIPTION, SET_SERIES, SET_COLOR, SET_SHOWPATH, SET_FOLLOWTRACK, SET_LOOKAT, SET_SHOWWIND, SET_WIND, MOVE_MODEL, SET_LAYLINES, ROTATE_BOATS, OVERLAP_BOAT, FLAG_BOAT, TRIM_BOAT, TRIM_JIB, TRIM_SPIN, SPIN_BOAT, HIDE_BOAT, ACCELERATE_BOAT, SET_TEXT, MOVE_TEXT, ZONE_MARK, COLOR_MARK, LENGTH_MARK, LABEL_MARK }; class SetTitleUndoCommand : public QUndoCommand { public: SetTitleUndoCommand(SituationModel* situation, QString title, QUndoCommand *parent = 0); ~SetTitleUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_TITLE; } private: SituationModel *m_situation; QString m_oldTitle; QString m_newTitle; }; class SetRulesUndoCommand : public QUndoCommand { public: SetRulesUndoCommand(SituationModel* situation, QString rules, QUndoCommand *parent = 0); ~SetRulesUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_RULES; } private: SituationModel *m_situation; QString m_oldRules; QString m_newRules; }; class SetShowLaylineUndoCommand : public QUndoCommand { public: SetShowLaylineUndoCommand(SituationModel* situation, QUndoCommand *parent = 0); ~SetShowLaylineUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_SHOWLAYLINE; } private: SituationModel *m_situation; }; class SetLaylineUndoCommand : public QUndoCommand { public: SetLaylineUndoCommand(SituationModel* situation, const int angle, QUndoCommand *parent = 0); ~SetLaylineUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_LAYLINE; } private: SituationModel *m_situation; int m_oldAngle; int m_newAngle; }; class SetSituationSeriesUndoCommand : public QUndoCommand { public: SetSituationSeriesUndoCommand(SituationModel* situation, const int series, QUndoCommand *parent = 0); ~SetSituationSeriesUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_SITUATIONSERIES; } private: SituationModel *m_situation; int m_oldSeries; int m_newSeries; }; class SetAbstractUndoCommand : public QUndoCommand { public: SetAbstractUndoCommand(SituationModel* situation, QString abstract, QUndoCommand *parent = 0); ~SetAbstractUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_ABSTRACT; } private: SituationModel *m_situation; QString m_oldAbstract; QString m_newAbstract; }; class SetDescriptionUndoCommand : public QUndoCommand { public: SetDescriptionUndoCommand(SituationModel* situation, QString description, QUndoCommand *parent = 0); ~SetDescriptionUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_DESCRIPTION; } private: SituationModel *m_situation; QString m_oldDescription; QString m_newDescription; }; class AddTrackUndoCommand : public QUndoCommand { public: AddTrackUndoCommand(SituationModel* situation, QUndoCommand *parent = 0); ~AddTrackUndoCommand(); void undo(); void redo(); TrackModel *track() {return m_track; } private: SituationModel *m_situation; TrackModel *m_track; }; class DeleteTrackUndoCommand : public QUndoCommand { public: DeleteTrackUndoCommand(SituationModel* situation, TrackModel* track, QUndoCommand *parent = 0); ~DeleteTrackUndoCommand(); void undo(); void redo(); private: SituationModel *m_situation; TrackModel *m_track; }; class SetSeriesUndoCommand : public QUndoCommand { public: SetSeriesUndoCommand(TrackModel* track, const Boats::Series series, QUndoCommand *parent = 0); ~SetSeriesUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_SERIES; } private: TrackModel *m_track; Boats::Series m_oldSeries; Boats::Series m_newSeries; }; class SetColorUndoCommand : public QUndoCommand { public: SetColorUndoCommand(TrackModel* track, const QColor color, QUndoCommand *parent = 0); ~SetColorUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_COLOR; } private: TrackModel *m_track; QColor m_oldColor; QColor m_newColor; }; class SetShowPathUndoCommand : public QUndoCommand { public: SetShowPathUndoCommand(TrackModel* track, QUndoCommand *parent = 0); ~SetShowPathUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_SHOWPATH; } private: TrackModel *m_track; }; class SetFollowTrackUndoCommand : public QUndoCommand { public: SetFollowTrackUndoCommand(SituationModel* situation, TrackModel* track, QUndoCommand *parent = 0); ~SetFollowTrackUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_FOLLOWTRACK; } private: SituationModel *m_situation; TrackModel *m_track; QList m_followTrackList; }; class SetLookAtUndoCommand : public QUndoCommand { public: SetLookAtUndoCommand(SituationModel* situation, int lookDirection, int tilt, QUndoCommand *parent = 0); ~SetLookAtUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_LOOKAT; } private: SituationModel *m_situation; int m_oldLookDirection; int m_newLookDirection; int m_oldTilt; int m_newTilt; }; class SetShowWindUndoCommand : public QUndoCommand { public: SetShowWindUndoCommand(WindModel* wind, QUndoCommand *parent = 0); ~SetShowWindUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_SHOWWIND; } private: WindModel *m_wind; }; class AddWindUndoCommand : public QUndoCommand { public: AddWindUndoCommand(WindModel* wind, qreal heading, QUndoCommand *parent = 0); ~AddWindUndoCommand(); void undo(); void redo(); private: WindModel *m_wind; qreal m_heading; }; class SetWindUndoCommand : public QUndoCommand { public: SetWindUndoCommand(WindModel* wind, int index, qreal direction, QUndoCommand *parent = 0); ~SetWindUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_WIND; } private: WindModel *m_wind; int m_index; qreal m_oldDirection; qreal m_newDirection; }; class DeleteWindUndoCommand : public QUndoCommand { public: DeleteWindUndoCommand(WindModel* wind, int index, QUndoCommand *parent = 0); ~DeleteWindUndoCommand(); void undo(); void redo(); private: WindModel *m_wind; int m_index; qreal m_heading; }; class MoveModelUndoCommand : public QUndoCommand { public: MoveModelUndoCommand(QList &modelList, const QPointF &deltaPosition, QUndoCommand *parent = 0); ~MoveModelUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return MOVE_MODEL; } private: QList m_modelList; QPointF m_deltaPosition; }; class SetLaylinesUndoCommand : public QUndoCommand { public: SetLaylinesUndoCommand(QList &modelList, bool laylines, QUndoCommand *parent = 0); ~SetLaylinesUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_LAYLINES; } private: QList m_modelList; QList m_laylinesList; bool m_laylines; }; class AddBoatUndoCommand : public QUndoCommand { public: AddBoatUndoCommand(TrackModel* track, QPointF& position, qreal heading, QUndoCommand *parent = 0); ~AddBoatUndoCommand(); void undo(); void redo(); BoatModel *boat() {return m_boat; } private: TrackModel *m_track; BoatModel *m_boat; }; class RotateModelsUndoCommand : public QUndoCommand { public: RotateModelsUndoCommand(QList &modelList, const qreal &angle, QUndoCommand *parent = 0); ~RotateModelsUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return ROTATE_BOATS; } private: QList m_modelList; QList m_headingList; qreal m_angle; }; class OverlapBoatUndoCommand : public QUndoCommand { public: OverlapBoatUndoCommand(SituationModel* situation, QList &boatList, Boats::Overlaps overlaps, QUndoCommand *parent = 0); ~OverlapBoatUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return OVERLAP_BOAT; } private: SituationModel *m_situation; QList m_boatList; Boats::Overlaps m_overlaps; }; class FlagBoatUndoCommand : public QUndoCommand { public: FlagBoatUndoCommand(SituationModel* situation, QList &boatList, Boats::Flag flag, QUndoCommand *parent = 0); ~FlagBoatUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return FLAG_BOAT; } private: SituationModel *m_situation; QList m_boatList; QList m_flagList; Boats::Flag m_flag; }; class TrimBoatUndoCommand : public QUndoCommand { public: TrimBoatUndoCommand(QList &boatList, const qreal &trim, QUndoCommand *parent = 0); ~TrimBoatUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return TRIM_BOAT; } private: QList m_boatList; QList m_trimList; QList m_jibTrimList; qreal m_trim; }; class TrimJibUndoCommand : public QUndoCommand { public: TrimJibUndoCommand(QList &boatList, const qreal &trim, QUndoCommand *parent = 0); ~TrimJibUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return TRIM_JIB; } private: QList m_boatList; QList m_trimList; qreal m_trim; }; class TrimSpinUndoCommand : public QUndoCommand { public: TrimSpinUndoCommand(QList &boatList, const qreal &trim, QUndoCommand *parent = 0); ~TrimSpinUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return TRIM_SPIN; } private: QList m_boatList; QList m_trimList; qreal m_trim; }; class SpinBoatUndoCommand : public QUndoCommand { public: SpinBoatUndoCommand(SituationModel* situation, QList &boatList, bool spin, QUndoCommand *parent = 0); ~SpinBoatUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SPIN_BOAT; } private: SituationModel *m_situation; QList m_boatList; QList m_spinList; bool m_spin; }; class HiddenBoatUndoCommand : public QUndoCommand { public: HiddenBoatUndoCommand(SituationModel* situation, QList &boatList, bool hidden, QUndoCommand *parent = 0); ~HiddenBoatUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return HIDE_BOAT; } private: SituationModel *m_situation; QList m_boatList; QList m_hiddenList; bool m_hidden; }; class AccelerateBoatUndoCommand : public QUndoCommand { public: AccelerateBoatUndoCommand(SituationModel* situation, QList &boatList, Boats::Acceleration acceleration, QUndoCommand *parent = 0); ~AccelerateBoatUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return ACCELERATE_BOAT; } private: SituationModel *m_situation; QList m_boatList; QList m_accelerationList; Boats::Acceleration m_acceleration; }; class SetTextUndoCommand : public QUndoCommand { public: SetTextUndoCommand(PositionModel *model, QString text, QUndoCommand *parent = 0); ~SetTextUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return SET_TEXT; } private: PositionModel *m_model; QString m_oldText; QString m_newText; }; class MoveTextUndoCommand : public QUndoCommand { public: MoveTextUndoCommand(PositionModel *model, const QPointF &deltaPosition, QUndoCommand *parent = 0); ~MoveTextUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return MOVE_TEXT; } private: PositionModel *m_model; QPointF m_deltaPosition; }; class DeleteBoatUndoCommand : public QUndoCommand { public: DeleteBoatUndoCommand(TrackModel* track, BoatModel* boat, QUndoCommand *parent = 0); ~DeleteBoatUndoCommand(); void undo(); void redo(); private: TrackModel *m_track; BoatModel *m_boat; int m_order; }; class AddMarkUndoCommand : public QUndoCommand { public: AddMarkUndoCommand(SituationModel* situation, QPointF& position, QUndoCommand *parent = 0); ~AddMarkUndoCommand(); void undo(); void redo(); MarkModel *mark() {return m_mark; } private: SituationModel *m_situation; MarkModel *m_mark; }; class ZoneMarkUndoCommand : public QUndoCommand { public: ZoneMarkUndoCommand(SituationModel* situation, const QList &markList, QUndoCommand *parent = 0); ~ZoneMarkUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return ZONE_MARK; } private: SituationModel *m_situation; QList m_markList; }; class ColorMarkUndoCommand : public QUndoCommand { public: ColorMarkUndoCommand(SituationModel* situation, const QList &markList, const QColor &color, QUndoCommand *parent = 0); ~ColorMarkUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return COLOR_MARK; } private: SituationModel *m_situation; QList m_markList; QList m_oldColors; QColor m_newColor; }; class LengthMarkUndoCommand : public QUndoCommand { public: LengthMarkUndoCommand(SituationModel* situation, const int length, QUndoCommand *parent = 0); ~LengthMarkUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return LENGTH_MARK; } private: SituationModel *m_situation; int m_oldLength; int m_newLength; }; class ToggleMarkSideUndoCommand : public QUndoCommand { public: ToggleMarkSideUndoCommand(const QList &markList, QUndoCommand *parent = 0); ~ToggleMarkSideUndoCommand(); void undo(); void redo(); private: QList m_markList; }; class ToggleMarkArrowUndoCommand : public QUndoCommand { public: ToggleMarkArrowUndoCommand(const QList &markList, QUndoCommand *parent = 0); ~ToggleMarkArrowUndoCommand(); void undo(); void redo(); private: QList m_markList; }; class ToggleMarkLabelUndoCommand : public QUndoCommand { public: ToggleMarkLabelUndoCommand(const QList &markList, QUndoCommand *parent = 0); ~ToggleMarkLabelUndoCommand(); void undo(); void redo(); private: QList m_markList; }; class SetMarkLabelUndoCommand : public QUndoCommand { public: SetMarkLabelUndoCommand(MarkModel* mark, QString text, QUndoCommand *parent = 0); ~SetMarkLabelUndoCommand(); void undo(); void redo(); bool mergeWith(const QUndoCommand *command); int id() const { return LABEL_MARK; } private: MarkModel* m_mark; QString m_oldText; QString m_newText; }; class DeleteMarkUndoCommand : public QUndoCommand { public: DeleteMarkUndoCommand(SituationModel* situation, MarkModel* mark, QUndoCommand *parent = 0); ~DeleteMarkUndoCommand(); void undo(); void redo(); private: SituationModel *m_situation; MarkModel *m_mark; int m_order; }; class AddPolyLineUndoCommand : public QUndoCommand { public: AddPolyLineUndoCommand(SituationModel* situation, QUndoCommand *parent = 0); ~AddPolyLineUndoCommand(); void undo(); void redo(); PolyLineModel *polyLine() {return m_polyLine; } private: SituationModel *m_situation; PolyLineModel *m_polyLine; }; class DeletePolyLineUndoCommand : public QUndoCommand { public: DeletePolyLineUndoCommand(SituationModel* situation, PolyLineModel* polyLine, QUndoCommand *parent = 0); ~DeletePolyLineUndoCommand(); void undo(); void redo(); private: SituationModel *m_situation; PolyLineModel *m_polyLine; }; class AddPointUndoCommand : public QUndoCommand { public: AddPointUndoCommand(PolyLineModel* polyLine, QPointF& position, QUndoCommand *parent = 0); ~AddPointUndoCommand(); void undo(); void redo(); PointModel *point() {return m_point; } private: PolyLineModel *m_polyLine; PointModel *m_point; }; class DeletePointUndoCommand : public QUndoCommand { public: DeletePointUndoCommand(PolyLineModel* polyLine, PointModel* point, QUndoCommand *parent = 0); ~DeletePointUndoCommand(); void undo(); void redo(); private: PolyLineModel *m_polyLine; PointModel *m_point; int m_order; }; #endif boats-201307/xbs.icns000066400000000000000000001153171217277220500144070ustar00rootroot00000000000000icnsis32[ _@7ySKpWŽu [ _@7ySKpWŽu [jmLQU3g >Wځ λ@ s8mk    il32 ؀܁Ԃ  ف܁q˃-LP,nK<,OkZK<3̀ }iZK= xiZK\xiZaxjxǀw2V3Ӏ ܁Ԃ  ف܁q˃-LP,nK<,OkZK<3̀ }iZK= xiZK\xiZaxjxǀw2V3Ӏ کڙvkguIWgv:IXhtÁ,:IXh1+:JXzQ+:J}+:#B߃ـ ـ  ـ ǀ2V3Ӏl8mk&((((((((((((((((((((((&:: @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @< @  @, @2  @=  @G @<  @/ <)  <@@@@@@@@@@@@@@:it32IGZᎉڎ̆Ԉ˂˸Հ᠊€сޠᄦۤ֩툾ÄӯƸɒ֖zτɭ萖艉ӊјՠ֎ۆ߃݁ؗԁڂɋۀֈ΂nSO MK ÉH! I E'$  D**($ FC22.*($ B9:62.*($ BO>A>:62.*($ hBIEA>:62.*($ @HNMIEA>:62.+($ fNUQMIEA>:62/+($ >PXXUQMIEA>:63/+($ R_\XUQMIEA>:63/+($ <i]c_\XUQMIEA>:73/+($"]cgc_\XUQMIEA>;73/+($MVkjgc_\XUQMIEA?;73/+(-օTrnjgc_\XUQMIEA?;73/+&lXvrnjgc_\XUQMIEA?;73/+:Zyvrnjgc`\XUQMIEA?;73/*`zzvrnjgc`\XUQMIEA?;73/Ii{}zvrnjgd`\XUQMIEA?;737Ѕq}zvrnjgd`\XUQMIEA?;71b}zvrnjhd`\XUQMIEA?;4bF]}zvrnjhd`\XUQMIEA?;E kt}zvrnkhd`\XUQMIEA?<х)đu}zvrnkhd`\XUQMIEA:(Ƨd}zvrnkhd`\XUQMIEA>:62.*($ hBIEA>:62.*($ @HNMIEA>:62.+($ fNUQMIEA>:62/+($ >PXXUQMIEA>:63/+($ R_\XUQMIEA>:63/+($ <i]c_\XUQMIEA>:73/+($"]cgc_\XUQMIEA>;73/+($MVkjgc_\XUQMIEA?;73/+(-օTrnjgc_\XUQMIEA?;73/+&lXvrnjgc_\XUQMIEA?;73/+:Zyvrnjgc`\XUQMIEA?;73/*`zzvrnjgc`\XUQMIEA?;73/Ii{}zvrnjgd`\XUQMIEA?;737Ѕq}zvrnjgd`\XUQMIEA?;71b}zvrnjhd`\XUQMIEA?;4bF]}zvrnjhd`\XUQMIEA?;E!kt}zvrnkhd`\XUQMIEA?<х)đu}zvrnkhd`\XUQMIEA:(Ƨd}zvrnkhd`\XUQMIE!%)-158<@DHLPSW[^Q؆j!%)-158<@DHLPSWZQ݃!%)-158<@DHLPSUO1 !%)-158<@DHLPK\[ !%)-158<@DHLG !%)-158<@DGHh !%)-158<@?Ub!%)-158<={\!%)-154I‹ Y!%)-17| Y!%)*K҈Y!%4Z"Q㕼f҉Ȉ̉ɂӃņϼ~؄״뇮ޭχdž̵߂څ܇ԪօҫҠF!kׅ)đͫ(Ƨݕߌ(Ƹ}ވ(¿ވ(ƽވ(Ÿ&拂ވ̼ B~Ԍǵ bӂð yݙ͂ѿ }%Ͻ$˹#ȶą$Ų¼򌷁#¾"ͼ¼ ȷ¸Ƴʀ¦Ϳ“ʼÁfC(ʾʲ̚vPt8mk@     '.1334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444331.'  -9BGJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJGB9-  (9II9(  .BUUB. 1G[[G13J^^J34K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K``K44K`_J34K`^I24K`\G04K`WB, 4K`lO:& 4K`yVD04K`ZI7% 4K`\M;)4K`^O>, 4K``Q@/ 4K`dSB1! 4K`iTD3# 4K`oVE4$ 4K`wWG6&4K`XH7'4K`ZJ9( 4K`[K:* 4K`\L;+ 4K`]N=, 4K`^O>- 4K`_P?. 4K`_P@/  4K`^O?/! 4K`]N>/! 4K`[M=.  4K`ZK;, 4K`~XI:+ 4K`uVH8) 4K`mUF6( 4K`fSD4& 4K`bQB3$ 4K`]O@1#4K`[M>/! 3J^XJ;- 1G[vUG8*  .BUhQD5'  (9IU[_`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``^ZSJ>1$  -9BGJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKJHE>6+  '.1334444444444444444444444444444444444444444444444444444444331.)"     icnV boats-201307/xmlsituationreader.cpp000066400000000000000000000345501217277220500173630ustar00rootroot00000000000000// // C++ Implementation: XmlSituationReader // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include #include "xmlsituationreader.h" #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" #include "markmodel.h" #include "polylinemodel.h" #include "pointmodel.h" #include "windmodel.h" #include "undocommands.h" XmlSituationReader::XmlSituationReader(SituationModel *situation) : m_situation(situation) { } XmlSituationReader::~XmlSituationReader() {} bool XmlSituationReader::read(QIODevice *device) { setDevice(device); while (!atEnd()) { readNext(); if (isStartElement()) { if (name() == "xmlscenario" && attributes().value("version") == "1.0") readSituation(); else raiseError(QObject::tr("The file is not an xmlscenario version 1.0 file.")); } } return !error(); } QString XmlSituationReader::readUnknownElement() { QString elem; elem.append("<").append(name()).append(">"); while (!atEnd()) { readNext(); if (isCharacters()) elem.append(text()); else if (isStartElement()) elem.append(readUnknownElement()); else if (isEndElement()) { elem.append(""); break; } } std::cout << "unread data " << elem.toStdString() << std::endl; return elem; } void XmlSituationReader::readSituation() { while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "title") { m_situation->undoStack()->push( new SetTitleUndoCommand(m_situation, readElementText())); } else if (name() == "rules") { m_situation->undoStack()->push( new SetRulesUndoCommand(m_situation, readElementText())); } else if (name() == "abstract") { m_situation->undoStack()->push( new SetAbstractUndoCommand(m_situation, readElementText())); } else if (name() == "description") { m_situation->undoStack()->push( new SetDescriptionUndoCommand(m_situation, readElementText())); } else if (name() == "series") { m_situation->undoStack()->push( new SetSituationSeriesUndoCommand(m_situation, series(readElementText()))); } else if (name() == "showlayline") { if (readElementText() == "0") { m_situation->undoStack()->push( new SetShowLaylineUndoCommand(m_situation)); } } else if (name() == "layline") { m_situation->undoStack()->push( new SetLaylineUndoCommand(m_situation, readElementText().toInt())); } else if (name() == "length") { m_situation->setSituationLength(readElementText().toInt()); } else if (name() == "look_direction") { m_situation->setLookDirection(readElementText().toFloat()); } else if (name() == "tilt") { m_situation->setTilt(readElementText().toFloat()); } else if (name() == "mark") { readMark(m_situation); } else if (name() == "track") { readTrack(m_situation); } else if (name() == "polyline") { readPolyLine(m_situation); } else if (name() == "wind") { readWind(m_situation); } else { m_situation->appendDiscardedXml(readUnknownElement()); } } } } void XmlSituationReader::readTrack(SituationModel *situation) { AddTrackUndoCommand *command = new AddTrackUndoCommand(situation); situation->undoStack()->push(command); TrackModel *track = command->track(); while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "color") track->setColor(QColor(readElementText())); else if (name() == "series") track->setSeries(series(readElementText())); else if (name() == "path") track->setShowPath(readElementText() == "1"); else if (name() == "follow_track") track->setFollowTrack(readElementText() == "1"); else if (name() == "boat") readBoat(situation, track); else track->appendDiscardedXml(readUnknownElement()); } } } void XmlSituationReader::readBoat(SituationModel *situation, TrackModel *track) { QPointF pos; qreal heading = 0; qreal trim = 0; qreal jibTrim = 0; bool spin = false; qreal spinTrim = 0; Boats::Overlaps overlap = Boats::none; Boats::Flag flag = Boats::noFlag; bool hidden = false; Boats::Acceleration acceleration = Boats::constant; QPointF textPos(10,10); QString text; bool laylines = 0; QStringList discarded; while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "x") pos.setX(readElementText().toFloat()); else if (name() == "y") pos.setY(readElementText().toFloat()); else if (name() == "heading") heading = readElementText().toFloat(); else if (name() == "trim") trim = readElementText().toFloat(); else if (name() == "jibtrim") jibTrim = readElementText().toFloat(); else if (name() == "spin") spin = (readElementText() == "1"); else if (name() == "spintrim") spinTrim = readElementText().toFloat(); else if (name() == "overlap") { overlap = (Boats::Overlaps)FLAG_VALUE(Boats, Overlap, readElementText().toStdString().c_str()); } else if (name() == "flag") { flag = (Boats::Flag)ENUM_VALUE(Boats, Flag, readElementText().toStdString().c_str()); } else if (name() == "hidden") { hidden = (readElementText() == "1"); } else if (name() == "acceleration") { acceleration = (Boats::Acceleration)ENUM_VALUE(Boats, Acceleration, readElementText().toStdString().c_str()); } else if (name() == "bubble_x") textPos.setX(readElementText().toFloat()); else if (name() == "bubble_y") textPos.setY(readElementText().toFloat()); else if (name() == "bubble_text") text = readElementText(); else if (name() == "laylines") laylines = (readElementText() == "1"); else discarded.append(readUnknownElement()); } } BoatModel *boat; if (track->size() == 0) { boat = new BoatModel(track); boat->setPosition(pos); boat->setHeading(heading); track->addBoat(boat); } else { AddBoatUndoCommand *command = new AddBoatUndoCommand(track, pos, heading); situation->undoStack()->push(command); boat = command->boat(); } boat->setTrim(trim); boat->setJibTrim(jibTrim); boat->setSpin(spin); boat->setSpinTrim(spinTrim); boat->setOverlap(overlap); boat->setFlag(flag); boat->setHidden(hidden); boat->setAcceleration(acceleration); boat->setTextPosition(textPos); boat->setText(text); boat->setLaylines(laylines); foreach (const QString elem, discarded) { boat->appendDiscardedXml(elem); } } void XmlSituationReader::readMark(SituationModel *situation) { QPointF pos; QColor color; bool zone = false; int length = 0; QPointF textPos(10,10); QString text; bool laylines = 0; qreal heading; bool arrowVisible; bool leaveToPort; bool labelVisible; QString labelText; QStringList discarded; while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "x") pos.setX(readElementText().toFloat()); else if (name() == "y") pos.setY(readElementText().toFloat()); else if (name() == "color") color.setNamedColor(readElementText()); else if (name() == "zone") zone = (readElementText() == "1"); else if (name() == "length") length = (readElementText().toInt()); else if (name() == "bubble_x") textPos.setX(readElementText().toFloat()); else if (name() == "bubble_y") textPos.setY(readElementText().toFloat()); else if (name() == "bubble_text") text = readElementText(); else if (name() == "laylines") laylines = (readElementText() == "1"); else if (name() == "heading") heading = (readElementText().toFloat()); else if (name() == "arrowVisible") arrowVisible = (readElementText() == "1"); else if (name() == "leaveToPort") leaveToPort = (readElementText() == "1"); else if (name() == "labelVisible") labelVisible = (readElementText() == "1"); else if (name() == "labelText") labelText = (readElementText()); else discarded.append(readUnknownElement()); } } AddMarkUndoCommand *command = new AddMarkUndoCommand(situation, pos); situation->undoStack()->push(command); MarkModel *mark = command->mark(); mark->setColor(color); mark->setZone(zone); if (length != 0) { mark->setLength(length); } mark->setTextPosition(textPos); mark->setText(text); mark->setLaylines(laylines); mark->setHeading(heading); mark->setArrowVisible(arrowVisible); mark->setLeaveToPort(leaveToPort); mark->setLabelVisible(labelVisible); mark->setLabelText(labelText); foreach (const QString elem, discarded) { mark->appendDiscardedXml(elem); } } void XmlSituationReader::readPolyLine(SituationModel *situation) { QStringList discarded; AddPolyLineUndoCommand *command = new AddPolyLineUndoCommand(situation); situation->undoStack()->push(command); PolyLineModel *polyLine = command->polyLine(); while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "point") readPoint(situation, polyLine); else polyLine->appendDiscardedXml(readUnknownElement()); } } } void XmlSituationReader::readPoint(SituationModel *situation, PolyLineModel *polyLine) { QPointF pos; QPointF textPos(10,10); QString text; bool laylines = 0; QStringList discarded; while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "x") pos.setX(readElementText().toFloat()); else if (name() == "y") pos.setY(readElementText().toFloat()); else if (name() == "bubble_x") textPos.setX(readElementText().toFloat()); else if (name() == "bubble_y") textPos.setY(readElementText().toFloat()); else if (name() == "bubble_text") text = readElementText(); else if (name() == "laylines") laylines = (readElementText() == "1"); else discarded.append(readUnknownElement()); } } AddPointUndoCommand *command = new AddPointUndoCommand(polyLine, pos); PointModel *point = command->point(); point->setTextPosition(textPos); point->setText(text); point->setLaylines(laylines); foreach (const QString elem, discarded) { point->appendDiscardedXml(elem); } situation->undoStack()->push(command); } void XmlSituationReader::readWind(SituationModel *situation) { bool visible = false; QPointF pos; QList winds; QStringList discarded; while (!atEnd()) { readNext(); if (isEndElement()) break; if (isStartElement()) { if (name() == "visible") visible = (readElementText() == "1"); else if (name() == "x") pos.setX(readElementText().toFloat()); else if (name() == "y") pos.setY(readElementText().toFloat()); else if (name() == "direction") { winds.append(readElementText().toFloat()); } else discarded.append(readUnknownElement()); } } foreach (const QString elem, discarded) { situation->wind().appendDiscardedXml(elem); } situation->wind().setVisible(visible); foreach (qreal heading, winds) { situation->undoStack()->push(new AddWindUndoCommand(&situation->wind(), heading)); } situation->wind().setPosition(pos); } Boats::Series XmlSituationReader::series(const QString series) { int i; i = ENUM_VALUE(Boats, Series, series.toStdString().c_str()); if (i != -1) { return (Boats::Series)i; } else { return Boats::keelboat; } } boats-201307/xmlsituationreader.h000066400000000000000000000032701217277220500170230ustar00rootroot00000000000000// // C++ Interface: XmlSituationReader // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef XMLSITUATIONREADER_H #define XMLSITUATIONREADER_H #include #include "boats.h" class SituationModel; class TrackModel; class BoatModel; class PolyLineModel; class XmlSituationReader : public QXmlStreamReader { public: XmlSituationReader(SituationModel *situation); ~XmlSituationReader(); bool read(QIODevice *device); private: QString readUnknownElement(); void readSituation(); void readTrack(SituationModel *situation); void readBoat(SituationModel *situation, TrackModel *track); void readMark(SituationModel *situation); void readPolyLine(SituationModel *situation); void readPoint(SituationModel *situation, PolyLineModel *polyLine); void readWind(SituationModel *situation); Boats::Series series(const QString series); SituationModel *m_situation; }; #endif boats-201307/xmlsituationwriter.cpp000066400000000000000000000247161217277220500174400ustar00rootroot00000000000000// // C++ Implementation: XmlSituationWriter // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #include "xmlsituationwriter.h" #include #include "commontypes.h" #include "situationmodel.h" #include "trackmodel.h" #include "boatmodel.h" #include "markmodel.h" #include "polylinemodel.h" #include "pointmodel.h" extern int debugLevel; XmlSituationWriter::XmlSituationWriter(SituationModel *situation) : m_situation(situation) { setAutoFormatting(true); if (debugLevel & 1 << XML) std::cout << "new XmlSituationWriter" << std::endl; } XmlSituationWriter::~XmlSituationWriter() {} bool XmlSituationWriter::writeFile(QIODevice *device) { setDevice(device); if (debugLevel & 1 << XML) std::cout << "WriteFile" << std::endl; writeStartDocument(); writeDTD(""); writeStartElement("xmlscenario"); writeAttribute("version", "1.0"); if (!m_situation->title().isEmpty()) { writeTextElement("title", m_situation->title()); } if (!m_situation->rules().isEmpty()) { writeTextElement("rules", m_situation->rules()); } if (!m_situation->abstract().isEmpty()) { writeTextElement("abstract", m_situation->abstract()); } if (!m_situation->description().isEmpty()) { writeTextElement("description", m_situation->description()); } writeTextElement("series",ENUM_NAME(Boats, Series, m_situation->situationSeries())); writeTextElement("showlayline",QString::number(m_situation->showLayline())); writeTextElement("layline",QString::number(m_situation->laylineAngle())); writeTextElement("length",QString::number(m_situation->situationLength())); writeTextElement("look_direction",QString::number(m_situation->lookDirection())); writeTextElement("tilt",QString::number(m_situation->tilt())); writeWind(m_situation->wind()); foreach (const QString discarded, m_situation->discardedXml()) writeUnknownElement(discarded); foreach (const MarkModel *mark, m_situation->marks()) writeMark(mark); foreach (const TrackModel *track, m_situation->tracks()) writeTrack(track); foreach (const PolyLineModel *polyLine, m_situation->polyLines()) writePolyLine(polyLine); writeEndDocument(); if (debugLevel & 1 << XML) std::cout << "done WriteFile" << std::endl; return true; } void XmlSituationWriter::writeTrack(const TrackModel *track) { if (debugLevel & 1 << XML) { std::cout << "WriteTrack" << std::endl; std::cout << " color=" << track->color().name().toStdString() << std::endl; std::cout << " series=" << ENUM_NAME(Boats, Series, track->series()) << std::endl; } writeStartElement("track"); writeTextElement("color",track->color().name()); writeTextElement("series",ENUM_NAME(Boats, Series, track->series())); if (!track->showPath()) { writeTextElement("path",QString::number(track->showPath())); } if (track->followTrack()) { writeTextElement("follow_track",QString::number(track->followTrack())); } foreach (const QString discarded, track->discardedXml()) writeUnknownElement(discarded); foreach (const BoatModel *boat, track->boats()) writeBoat(boat); writeEndElement(); } void XmlSituationWriter::writeBoat(const BoatModel *boat) { if (debugLevel & 1 << XML) { std::cout << "WriteBoat" << std::endl; std::cout << " x=" << boat->position().x() << std::endl; std::cout << " y=" << boat->position().y() << std::endl; std::cout << " heading=" << boat->heading() << std::endl; } writeStartElement("boat"); writeTextElement("x",QString::number(boat->position().x())); writeTextElement("y",QString::number(boat->position().y())); writeTextElement("heading",QString::number(boat->heading())); if (boat->trim() != 0) { writeTextElement("trim",QString::number(boat->trim())); } if (boat->jibTrim() != 0) { writeTextElement("jibtrim",QString::number(boat->jibTrim())); } if (boat->spin()) { writeTextElement("spin",QString::number(boat->spin())); if (boat->spinTrim() != 0) { writeTextElement("spintrim",QString::number(boat->spinTrim())); } } if (boat->overlap() != Boats::none) { writeTextElement("overlap", FLAG_NAME(Boats, Overlap, boat->overlap())); } if (boat->flag() != Boats::noFlag) { writeTextElement("flag", ENUM_NAME(Boats, Flag, boat->flag())); } if (boat->hidden()) { writeTextElement("hidden",QString::number(boat->hidden())); } if (boat->acceleration() != Boats::constant) { writeTextElement("acceleration", ENUM_NAME(Boats, Acceleration, boat->acceleration())); } if (!boat->text().isEmpty()) { writeTextElement("bubble_x",QString::number(boat->textPosition().x())); writeTextElement("bubble_y",QString::number(boat->textPosition().y())); writeTextElement("bubble_text",boat->text()); } if (boat->laylines()) { writeTextElement("laylines", QString::number(boat->laylines())); } foreach (const QString discarded, boat->discardedXml()) writeUnknownElement(discarded); writeEndElement(); } void XmlSituationWriter::writeMark(const MarkModel *mark) { if (debugLevel & 1 << XML) { std::cout << "WriteMark" << std::endl; std::cout << " x=" << mark->position().x() << std::endl; std::cout << " y=" << mark->position().y() << std::endl; std::cout << " color=" << mark->color().name().toStdString() << std::endl; std::cout << " zone=" << mark->zone() << std::endl; std::cout << " length=" << mark->length() << std::endl; std::cout << " heading=" << mark->heading() << std::endl; std::cout << " arrowVisible=" << mark->arrowVisible() << std::endl; std::cout << " leaveToPort=" << mark->leaveToPort() << std::endl; std::cout << " labelVisible=" << mark->labelVisible() << std::endl; std::cout << " labelText=" << mark->labelText().toStdString() << std::endl; } writeStartElement("mark"); writeTextElement("x",QString::number(mark->position().x())); writeTextElement("y",QString::number(mark->position().y())); writeTextElement("color",mark->color().name()); if (mark->zone()) { writeTextElement("zone",QString::number(mark->zone())); } if (mark->length() != mark->situation()->situationLength()) { writeTextElement("length",QString::number(mark->length())); } if (!mark->text().isEmpty()) { writeTextElement("bubble_x",QString::number(mark->textPosition().x())); writeTextElement("bubble_y",QString::number(mark->textPosition().y())); writeTextElement("bubble_text",mark->text()); } if (mark->laylines()) { writeTextElement("laylines", QString::number(mark->laylines())); } writeTextElement("heading",QString::number(mark->heading())); writeTextElement("arrowVisible",QString::number(mark->arrowVisible())); writeTextElement("leaveToPort",QString::number(mark->leaveToPort())); writeTextElement("labelVisible",QString::number(mark->labelVisible())); writeTextElement("labelText",mark->labelText()); foreach (const QString discarded, mark->discardedXml()) writeUnknownElement(discarded); writeEndElement(); } void XmlSituationWriter::writePolyLine(const PolyLineModel *polyLine) { if (debugLevel & 1 << XML) { std::cout << "WritePolyLine" << std::endl; std::cout << " points=" << polyLine->size() << std::endl; } writeStartElement("polyline"); foreach (const QString discarded, polyLine->discardedXml()) writeUnknownElement(discarded); foreach (const PointModel *point, polyLine->points()) { writePoint(point); } writeEndElement(); } void XmlSituationWriter::writePoint(const PointModel *point) { if (debugLevel & 1 << XML) { std::cout << "WritePoint" << std::endl; std::cout << " x=" << point->position().x() << std::endl; std::cout << " y=" << point->position().y() << std::endl; } writeStartElement("point"); foreach (const QString discarded, point->discardedXml()) writeUnknownElement(discarded); writeTextElement("x",QString::number(point->position().x())); writeTextElement("y",QString::number(point->position().y())); if (!point->text().isEmpty()) { writeTextElement("bubble_x",QString::number(point->textPosition().x())); writeTextElement("bubble_y",QString::number(point->textPosition().y())); writeTextElement("bubble_text",point->text()); } if (point->laylines()) { writeTextElement("laylines", QString::number(point->laylines())); } writeEndElement(); } void XmlSituationWriter::writeWind(const WindModel &wind) { if (debugLevel & 1 << XML) { std::cout << "WritePoint" << std::endl; } writeStartElement("wind"); foreach (const QString discarded, wind.discardedXml()) writeUnknownElement(discarded); if (wind.visible()) { writeTextElement("visible",QString::number(wind.visible())); } writeTextElement("x",QString::number(wind.position().x())); writeTextElement("y",QString::number(wind.position().y())); for(int i = 0; i < wind.size(); ++i) { writeTextElement("direction", QString::number(wind.windAt(i))); } writeEndElement(); } void XmlSituationWriter::writeUnknownElement(const QString &discarded) { if (debugLevel & 1 << XML) std::cout << "WriteUnknownElement" << std::endl; if (!discarded.isEmpty()) { QXmlStreamReader reader(discarded); while (!reader.atEnd()) { reader.readNext(); if (reader.isStartElement() || reader.isEndElement() || reader.isCharacters()) { writeCurrentToken(reader); } } } } boats-201307/xmlsituationwriter.h000066400000000000000000000031561217277220500171000ustar00rootroot00000000000000// // C++ Interface: XmlSituationWriter // // Description: // // // Author: Thibaut GRIDEL // // Copyright (c) 2008-2011 Thibaut GRIDEL // // 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 . // // #ifndef XMLSITUATIONWRITER_H #define XMLSITUATIONWRITER_H #include class SituationModel; class TrackModel; class BoatModel; class MarkModel; class PolyLineModel; class PointModel; class WindModel; class XmlSituationWriter : public QXmlStreamWriter { public: XmlSituationWriter(SituationModel *situation); ~XmlSituationWriter(); bool writeFile(QIODevice *device); private: void writeTrack(const TrackModel *track); void writeBoat(const BoatModel *boat); void writeMark(const MarkModel *mark); void writePolyLine(const PolyLineModel *polyLine); void writePoint(const PointModel *point); void writeWind(const WindModel &wind); void writeUnknownElement(const QString &discarded); SituationModel *m_situation; }; #endif