WebSVN - Projects - Path Comparison - /QMK-Groundstation/ Rev 673 and /QMK-Groundstation/ Rev 674

Ignore whitespace Rev 673 → Rev 674

/QMK-Groundstation/README.TXT
File deleted

/QMK-Groundstation/ChangeLog.txt
File deleted

/QMK-Groundstation/INSTALL.TXT
File deleted

/QMK-Groundstation/VERSION.TXT
File deleted

/QMK-Groundstation/Release/TODO.TXT
File deleted

Property changes:
Deleted: svn:mergeinfo

/QMK-Groundstation/Release/QMK-Tools-v1.1.0.tgz
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /QMK-Groundstation/tags/V1.0.1/COPYING
 ,0 → 1,340
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+                            Preamble
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  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.
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+  The precise terms and conditions for copying, distribution and
+modification follow.
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+and 2 above on a medium customarily used for software interchange; or,
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+                            NO WARRANTY
+. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+                     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
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 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, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Also add information on how to contact you by electronic and paper mail.
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+This 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 Library General
+Public License instead of this License.

/QMK-Groundstation/tags/V1.0.1/Images/16X16/ledoff.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/16X16/ledred.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/16X16/ledyellow.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/CVS-Record.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/CVS-Stop.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Cockpit.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Debug.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Exit.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/FC-Settings.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Fast-Data.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Firmware.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Folder-Open.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Google-NO.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Google-OK.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Icons.xcf
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/LCD.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/MotorMixer.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Motortest.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Network-NO.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Network-OK.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Plotter-NO.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Plotter-OK.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Preferences-Data.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Preferences.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Seriell-NO.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Seriell-OK.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Terminal.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Actions/Waypoints.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Down-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Down-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Left-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Left-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Right-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Right-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Up-1.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/Arrows/Up-2.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/QMK-Groundstation/tags/V1.0.1/Images/QMK-Groundstation.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /QMK-Groundstation/tags/V1.0.1/Logger/CSVLogger.cpp
 ,0 → 1,109
+/***************************************************************************
+ *   Copyright (C) 2008 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *   and Andreas Bresser bresser@informatik.uni-bremen.de                  *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "CSVLogger.h"
+CSVLogger::CSVLogger(cSettings * settings, sMode * mode)
+{
+    // QFile-Instanz (Log-Datei)
+    csvfile = new QFile("");
+    this->settings = settings;
+    this->mode = mode;
+}
+CSVLogger::~CSVLogger()
+{
+    close();
+}
+//datei ist geöffnet bedeutet wir sind soweit und können schreiben
+bool CSVLogger::ready()
+{
+    return csvfile->isOpen();
+}
+//Datei schließen
+void CSVLogger::close()
+{
+    if (csvfile->isOpen())
+        csvfile->close();
+}
+//neuen Log erstellen
+void CSVLogger::newLog()
+{
+    if (!csvfile->isOpen())
+    {
+        QString mode_name = mode->Hardware;
+        if (mode_name.size() == 0)
+        {
+            mode_name = QString("groundstation_log");
+        }
+        QString filename = settings->DIR.Logging + mode_name + "_" +
+                           QDate::currentDate().toString(("yyyy-MM-dd")) + "_" +
+                           QTime::currentTime().toString("hh-mm") + ".csv";
+        csvfile = new QFile(filename);
+        if (!csvfile->exists())
+        {
+            csvfile->open(QIODevice::Append | QIODevice::Text);
+            QTextStream Out(csvfile);
+            for (int a = 0; a < MaxAnalog; a++)
+            {
+                if (settings->Analog1.LogView[a])
+                {
+                    Out << settings->Analog1.Label[a];
+                    if (a < MaxAnalog - 1)
+                        Out << ';';
+                }
+            }
+            Out << "\n";
+        }
+        else
+        {
+            csvfile->open(QIODevice::Append | QIODevice::Text);
+        }
+    }
+}
+//daten schreiben
+void CSVLogger::write(int * analogData)
+{
+    if (csvfile->isOpen())
+    {
+        QTextStream out(csvfile);
+        for (int a=0; a<MaxAnalog; a++)
+        {
+            if (settings->Analog1.LogView[a])
+            {
+                out << analogData[a];
+                if (a < MaxAnalog - 1)
+                    out << ';';
+            }
+        }
+        out << "\n";
+    }
+}

 /QMK-Groundstation/tags/V1.0.1/Logger/CSVLogger.h
 ,0 → 1,57
+/***************************************************************************
+ *   Copyright (C) 2008 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *   and Andreas Bresser bresser@informatik.uni-bremen.de                  *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef CSVLOGGER_H
+#define CSVLOGGER_H
+#include <QString>
+#include <QTextStream>
+#include <QFile>
+#include <QDate>
+#include <QTime>
+#include "../global.h"
+#include "../Classes/cSettings.h"
+#include "DefaultLogger.h"
+class CSVLogger : public DefaultLogger
+{
+private:
+    // Object für das Datenfile;
+    QFile * csvfile;
+    cSettings * settings;
+    sMode * mode;
+public:
+    CSVLogger(cSettings * settings, sMode * mode);
+    ~CSVLogger();
+    //schreibe log
+    void write(int * analogData);
+    //erzeuge neue Log-Datei/neuen Datensatz
+    void newLog();
+    //alles bereit zum schreiben?
+    bool ready();
+    //alles schließen
+    void close();
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/Logger/DefaultLogger.h
 ,0 → 1,46
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *   and Andreas Bresser bresser@informatik.uni-bremen.de                  *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef DEFAULTLOGGER_H
+#define DEFAULTLOGGER_H
+#include <QString>
+#include "../Classes/cSettings.h"
+//Interface für einen Logger
+class DefaultLogger
+{
+public:
+    //schreibe log
+    virtual void write(int *) {  };
+    //erzeuge neue Log-Datei/neuen Datensatz
+    virtual void newLog() {  };
+    //alles bereit zum schreiben?
+    virtual bool ready() { return false; };
+    //alles schließen
+    virtual void close() {};
+    virtual ~DefaultLogger() {};
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/Logger/Logger.cpp
 ,0 → 1,64
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *   and Andreas Bresser bresser@informatik.uni-bremen.de                  *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "Logger.h"
+Logger::Logger(cSettings * settings, sMode * mode)
+{
+    csv = new CSVLogger(settings, mode);
+    logger << csv;
+    active = false;
+}
+Logger::~Logger()
+{
+    close();
+}
+//schreibe log
+void Logger::write(int * analogData)
+{
+    if (active == true)
+        foreach (DefaultLogger * log, logger)
+            if (log->ready())
+                log->write(analogData);
+}
+//starte Logging
+void Logger::start_Log()
+{
+    active = true;
+    foreach (DefaultLogger * log, logger)
+        log->newLog();
+}
+//soll geloggt werden?
+bool Logger::is_active()
+{
+    return active;
+}
+//alles schließen
+void Logger::close()
+{
+    active = false;
+    foreach (DefaultLogger * log, logger)
+        log->close();
+}

 /QMK-Groundstation/tags/V1.0.1/Logger/Logger.h
 ,0 → 1,58
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *   and Andreas Bresser bresser@informatik.uni-bremen.de                  *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef LOGGER_H
+#define LOGGER_H
+#include <QLinkedList>
+#include <QString>
+#include "DefaultLogger.h"
+#include "../global.h"
+#include "../Classes/cSettings.h"
+//Die verschiedenen header der einzelnen Logger
+//TODO: MySQLLogger, SQLiteLogger und/oder PostGreSQLLogger
+#include "CSVLogger.h"
+class Logger
+{
+private:
+    CSVLogger * csv;
+    //Liste aller bekannten Logger
+    QLinkedList<DefaultLogger *> logger;
+    bool active;
+public:
+    Logger(cSettings * settings, sMode * mode);
+    ~Logger();
+    void start_Log();
+    //soll geloggt werden?
+    bool is_active();
+    //schreibe log
+    void write(int * analogData);
+    //alles schließen
+    void close();
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/MKTool.qrc
 ,0 → 1,46
+<RCC>
+  <qresource prefix="LED" >
+    <file>Images/16X16/ledred.png</file>
+    <file>Images/16X16/ledyellow.png</file>
+    <file>Images/16X16/ledoff.png</file>
+  </qresource>
+  <qresource prefix="Arrows" >
+    <file>Images/Arrows/Down-1.png</file>
+    <file>Images/Arrows/Down-2.png</file>
+    <file>Images/Arrows/Left-1.png</file>
+    <file>Images/Arrows/Left-2.png</file>
+    <file>Images/Arrows/Right-1.png</file>
+    <file>Images/Arrows/Right-2.png</file>
+    <file>Images/Arrows/Up-1.png</file>
+    <file>Images/Arrows/Up-2.png</file>
+  </qresource>
+  <qresource prefix="Actions" >
+    <file>Images/Actions/MotorMixer.png</file>
+    <file>Images/Actions/Folder-Open.png</file>
+    <file>Images/Actions/Preferences-Data.png</file>
+    <file>Images/Actions/Preferences.png</file>
+    <file>Images/Actions/Exit.png</file>
+    <file>Images/Actions/Fast-Data.png</file>
+    <file>Images/Actions/Motortest.png</file>
+    <file>Images/Actions/LCD.png</file>
+    <file>Images/Actions/Waypoints.png</file>
+    <file>Images/Actions/FC-Settings.png</file>
+    <file>Images/Actions/CVS-Record.png</file>
+    <file>Images/Actions/CVS-Stop.png</file>
+    <file>Images/Actions/Debug.png</file>
+    <file>Images/Actions/Cockpit.png</file>
+    <file>Images/Actions/Firmware.png</file>
+    <file>Images/Actions/Terminal.png</file>
+    <file>Images/Actions/Google-NO.png</file>
+    <file>Images/Actions/Google-OK.png</file>
+    <file>Images/Actions/Plotter-NO.png</file>
+    <file>Images/Actions/Plotter-OK.png</file>
+    <file>Images/Actions/Seriell-NO.png</file>
+    <file>Images/Actions/Seriell-OK.png</file>
+    <file>Images/Actions/Network-NO.png</file>
+    <file>Images/Actions/Network-OK.png</file>
+  </qresource>
+  <qresource prefix="Icon" >
+    <file>Images/QMK-Groundstation.png</file>
+  </qresource>
+</RCC>

 /QMK-Groundstation/tags/V1.0.1/Parameter_Positions.h
 ,0 → 1,175
+/***************************************************************************
+ *   Copyright (C) 2008 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef PARAMETER_POSITIONS_H
+#define PARAMETER_POSITIONS_H
+// Positionen der Navidaten im OSD-Datensatz
+////////////////////////////////////////////
+static const int N_VERSION          = 0;
+static const int N_CUR_LONGITUDE    = 1;
+static const int N_CUR_LATITUDE     = 5;
+static const int N_CUR_ALTITUDE     = 9;
+static const int N_CUR_STATUS       = 13;
+static const int N_TAR_LONGITUDE    = 14; //16
+static const int N_TAR_LATITUDE     = 18; //20
+static const int N_TAR_ALTITUDE     = 22; //24
+static const int N_TAR_STATUS       = 26; //28
+static const int N_TAR_DISTANCE     = 27; //32
+static const int N_TAR_ANGLE        = 29; //34
+static const int N_HOME_LONGITUDE   = 31; //36
+static const int N_HOME_LATITUDE    = 35; //40
+static const int N_HOME_ALTITUDE    = 39; //44
+static const int N_HOME_STATUS      = 43; //48
+static const int N_HOME_DISTANCE    = 44; //52
+static const int N_HOME_ANGLE       = 46; //54
+static const int N_WP_INDEX         = 48; //56
+static const int N_WP_NUMBER        = 49; //57
+static const int N_SATS_IN_USER     = 50; //58
+static const int N_ALTIMETER        = 51; //59
+static const int N_VARIOMETER       = 53; //61
+static const int N_FLYING_TIME      = 55; //63
+static const int N_UBAT             = 57; //65
+static const int N_GROUND_SPEED     = 58; //66
+static const int N_HEADING          = 60; //68
+static const int N_COMAPSS_HEADING  = 62; //70
+static const int N_ANGLE_NICK       = 64; //72
+static const int N_ANGLE_ROLL       = 65; //73
+static const int N_RC_QUALITY       = 66; //74
+static const int N_MK_FLAGS         = 67; //75
+static const int N_NC_FLAGS         = 68; //76
+static const int N_ERRORCODE        = 69; //77
+static const int N_OP_RADIUS        = 70; //77
+static const int N_TOP_SPEED        = 71; //77
+static const int N_HOLD_TIME        = 73; //77
+// Positionen der Setting-Parameter
+///////////////////////////////////
+#ifdef _BETA_
+static const int VERSION_SETTINGS = 76;
+static const int VERSION_OSD      = 1;
+static const int VERSION_MIXER    = 1;
+#else
+static const int VERSION_SETTINGS = 76;
+static const int VERSION_OSD      = 1;
+static const int VERSION_MIXER    = 1;
+#endif
+static const int MAXMOTOR = 12;
+static const int MaxParameter = 98;
+static const int P_KANAL_GAS   = 0;
+static const int P_KANAL_GIER  = 1;
+static const int P_KANAL_NICK  = 2;
+static const int P_KANAL_ROLL  = 3;
+static const int P_KANAL_POTI1 = 4;
+static const int P_KANAL_POTI2 = 5;
+static const int P_KANAL_POTI3 = 6;
+static const int P_KANAL_POTI4 = 7;
+static const int P_GLOBAL_CONF = 8;
+static const int P_MIN_GAS     = 9;
+static const int P_DRUCK_D       = 10;
+static const int P_MAXHOEHE      = 11;
+static const int P_HOEHE_P       = 12;
+static const int P_HOEHE_GAIN    = 13;
+static const int P_HOEHE_ACC     = 14;
+static const int P_STICK_P       = 15;
+static const int P_STICK_D       = 16;
+static const int P_GIER_P        = 17;
+static const int P_GAS_MIN       = 18;
+static const int P_GAS_MAX       = 19;
+static const int P_GYRO_ACC_FAKTOR = 20;
+static const int P_KOMPASS_WIRKUNG = 21;
+static const int P_GYRO_P          = 22;
+static const int P_GYRO_I          = 23;
+static const int P_GYRO_D          = 24;
+static const int P_UNTERSPANNUNG   = 25;
+static const int P_NOTGAS          = 26;
+static const int P_NOTGASZEIT      = 27;
+static const int P_AUSRICHTUNG     = 28;
+static const int P_FAKTOR_I        = 29;
+static const int P_USER_1          = 30;
+static const int P_USER_2          = 31;
+static const int P_USER_3          = 32;
+static const int P_USER_4          = 33;
+static const int P_SERVO_NICK_CONT = 34;
+static const int P_SERVO_NICK_COMP = 35;
+static const int P_SERVO_NICK_MIN  = 36;
+static const int P_SERVO_NICK_MAX  = 37;
+static const int P_SERVO_ROLL_CONT = 38;
+static const int P_SERVO_ROLL_COMP = 39;
+static const int P_SERVO_ROLL_MIN  = 40;
+static const int P_SERVO_ROLL_MAX  = 41;
+static const int P_SERVO_REFR      = 42;
+static const int P_LOOP_GAS_LIMIT  = 43;
+static const int P_LOOP_THRESHOLD  = 44;
+static const int P_LOOP_HYSTERESE  = 45;
+static const int P_ACHS_KOPPLUNG1  = 46;
+static const int P_ACHS_KOPPLUNG2  = 47;
+static const int P_ACHS_GKOPPLUNG  = 48;
+static const int P_WINKEL_NICK     = 49;
+static const int P_WINKEL_ROLL     = 50;
+static const int P_GYRO_ACC_ABGL   = 51;
+static const int P_DRIFT_KOMP      = 52;
+static const int P_DYNAMIC_STAB    = 53;
+static const int P_USER_5          = 54;
+static const int P_USER_6          = 55;
+static const int P_USER_7          = 56;
+static const int P_USER_8          = 57;
+static const int P_J16_BITMASK     = 58;
+static const int P_J16_TIMING      = 59;
+static const int P_J17_BITMASK      = 60;
+static const int P_J17_TIMING       = 61;
+static const int P_NAV_GPS_MODE     = 62;
+static const int P_NAV_GPS_GAIN     = 63;
+static const int P_NAV_GPS_P        = 64;
+static const int P_NAV_GPS_I        = 65;
+static const int P_NAV_GPS_D        = 66;
+static const int P_NAV_GPS_P_LIMIT  = 67;
+static const int P_NAV_GPS_I_LIMIT  = 68;
+static const int P_NAV_GPS_D_LIMIT  = 69;
+static const int P_NAV_GPS_ACC      = 70;
+static const int P_NAV_GPS_MIN      = 71;
+static const int P_NAV_STICK_THRE   = 72;
+static const int P_NAV_WIND_CORR    = 73;
+static const int P_NAV_SPEED_COMP   = 74;
+static const int P_NAV_RADIUS       = 75;
+static const int P_NAV_ANGLE_LIMIT  = 76;
+static const int P_NAV_PH_LOGINTIME = 77;
+static const int P_EXTERNAL         = 78;
+static const int P_LOOP_CONFIG      = 79;
+static const int P_SERVO_COMPI      = 80;
+static const int P_RESERVED         = 81;
+static const int P_NAME             = 85;
+#endif

 /QMK-Groundstation/tags/V1.0.1/QMapControl.pri
 ,0 → 1,54
+DEPENDPATH += Classes/QMapControl
+INCLUDEPATH += Classes/QMapControl
+MOC_DIR = tmp
+OBJECTS_DIR = obj
+# Input
+HEADERS += curve.h \
+           geometry.h \
+           imagemanager.h \
+           layer.h \
+           layermanager.h \
+           linestring.h \
+           mapadapter.h \
+           mapcontrol.h \
+           mapnetwork.h \
+           point.h \
+           tilemapadapter.h \
+           wmsmapadapter.h \
+           circlepoint.h \
+           imagepoint.h \
+           gps_position.h \
+           osmmapadapter.h \
+           maplayer.h \
+           geometrylayer.h \
+           yahoomapadapter.h \
+           googlemapadapter.h \
+           googlesatmapadapter.h \
+           openaerialmapadapter.h \
+           fixedimageoverlay.h
+SOURCES += curve.cpp \
+           geometry.cpp \
+           imagemanager.cpp \
+           layer.cpp \
+           layermanager.cpp \
+           linestring.cpp \
+           mapadapter.cpp \
+           mapcontrol.cpp \
+           mapnetwork.cpp \
+           point.cpp \
+           tilemapadapter.cpp \
+           wmsmapadapter.cpp \
+           circlepoint.cpp \
+           imagepoint.cpp \
+           gps_position.cpp \
+           osmmapadapter.cpp \
+           maplayer.cpp \
+           geometrylayer.cpp \
+           yahoomapadapter.cpp \
+           googlemapadapter.cpp \
+           googlesatmapadapter.cpp \
+           openaerialmapadapter.cpp \
+           fixedimageoverlay.cpp
+QT += network

 /QMK-Groundstation/tags/V1.0.1/SerialPort/ManageSerialPort.cpp
 ,0 → 1,577
+/********************************************************************************************************
+                * PROGRAM      : QSerialPortTerminal
+                * DATE - TIME  : vendredi 03 octobre 2008 - 11h15
+                * AUTHOR       : VIANNEY-LIAUD Philippe ( philippe.vianney.liaud gmail.com )
+                        * FILENAME     : ManageSerialPort.cpp
+                        * LICENSE      : GPL
+                        * COMMENTARY   :
+********************************************************************************************************/
+#include <QtDebug>
+#include "ManageSerialPort.h"
+/********************************************************************************************************
+                * Classe ManageSerialPort
+                *****************************************************************************************************/
+//Constructeur
+ManageSerialPort::ManageSerialPort()
+{
+        //Init pointeur a NULL
+        threadSend = NULL;
+        threadReceive = NULL;
+        //Init des bool
+        sendingEnabled = false;
+        receivingEnabled = false;
+        closeCalled = false;
+        saveStateSendEnabled = false;
+        saveStateReceivedEnabled = false;
+        saveStateReceiveData = false;
+}
+ManageSerialPort::ManageSerialPort(const QString &name, const BaudRateType baudRate, \
+                const DataBitsType dataBits, const ParityType parity, \
+                const StopBitsType stopBits, const FlowType flowControl, \
+                ulong seconds, ulong milliseconds)
+{
+        //Init pointeur a NULL
+        threadSend = NULL;
+        threadReceive = NULL;
+        //Init des bool
+        sendingEnabled = false;
+        receivingEnabled = false;
+        closeCalled = false;
+        saveStateSendEnabled = false;
+        saveStateReceivedEnabled = false;
+        saveStateReceiveData = false;
+        setPort(name);
+        setBaudRate(baudRate);
+        setDataBits(dataBits);
+        setParity(parity);
+        setStopBits(stopBits);
+        setFlowControl(flowControl);
+        setTimeout(seconds, milliseconds);
+}
+//Destructeur
+ManageSerialPort::~ManageSerialPort()
+{
+        if (threadSend != NULL)
+        {
+                delete threadSend;
+                threadSend = NULL;
+        }
+        if (threadReceive != NULL)
+        {
+                delete threadReceive;
+                threadReceive = NULL;
+        }
+        if (isOpen())
+                extSerialPort.close();
+}
+bool ManageSerialPort::open()
+{
+        bool res = extSerialPort.open(QIODevice::ReadWrite);
+        if (closeCalled)
+        {
+                if (saveStateSendEnabled)
+                        enableSending();
+                if (saveStateReceivedEnabled)
+                        enableReceiving();
+                if (saveStateReceiveData)
+                        receiveData();
+                closeCalled = false;
+        }
+        return res;
+}
+bool ManageSerialPort::open(const QString &name, const BaudRateType baudRate, \
+                const DataBitsType dataBits,const ParityType parity, \
+                const StopBitsType stopBits, const FlowType flowControl, \
+                ulong seconds, ulong milliseconds)
+{
+        setPort(name);
+        setBaudRate(baudRate);
+        setDataBits(dataBits);
+        setParity(parity);
+        setStopBits(stopBits);
+        setFlowControl(flowControl);
+        setTimeout(seconds, milliseconds);
+        bool res = extSerialPort.open(QIODevice::ReadWrite);
+        return res;
+}
+bool ManageSerialPort::isOpen()
+{
+        return extSerialPort.isOpen();
+}
+void ManageSerialPort::close()
+{
+        closeCalled = true;
+        saveStateSendEnabled = isSendingEnabled();
+        saveStateReceivedEnabled = isReceivingEnabled();
+        disableSending();
+        disableReceiving();
+        extSerialPort.close();
+}
+void ManageSerialPort::setPort(const QString &name)
+{
+        extSerialPort.setPortName(name);
+}
+QString ManageSerialPort::getPort()
+{
+        return extSerialPort.portName();
+}
+void ManageSerialPort::setBaudRate(const BaudRateType baudRate)
+{
+        extSerialPort.setBaudRate(baudRate);
+}
+QString ManageSerialPort::getBaudRate()
+{
+        switch (extSerialPort.baudRate())
+        {
+                case BAUD50:
+                        return QString("50");
+                case BAUD75:
+                        return QString("75");
+                case BAUD110:
+                        return QString("110");
+                case BAUD134:
+                        return QString("134");
+                case BAUD150:
+                        return QString("150");
+                case BAUD200:
+                        return QString("200");
+                case BAUD300:
+                        return QString("300");
+                case BAUD600:
+                        return QString("600");
+                case BAUD1200:
+                        return QString("1200");
+                case BAUD1800:
+                        return QString("1800");
+                case BAUD2400:
+                        return QString("2400");
+                case BAUD4800:
+                        return QString("4800");
+                case BAUD9600:
+                        return QString("9600");
+                case BAUD14400:
+                        return QString("14400");
+                case BAUD19200:
+                        return QString("19200");
+                case BAUD38400:
+                        return QString("38400");
+                case BAUD56000:
+                        return QString("56000");
+                case BAUD57600:
+                        return QString("57600");
+                case BAUD76800:
+                        return QString("76800");
+                case BAUD115200:
+                        return QString("115200");
+                case BAUD128000:
+                        return QString("128000");
+                case BAUD256000:
+                        return QString("256000");
+        }
+        return 0;
+}
+void ManageSerialPort::setDataBits(const DataBitsType dataBits)
+{
+        extSerialPort.setDataBits(dataBits);
+}
+QChar ManageSerialPort::getDataBits()
+{
+        switch (extSerialPort.dataBits())
+        {
+                case DATA_5:
+                        return QChar('5');
+                case DATA_6:
+                        return QChar('6');
+                case DATA_7:
+                        return QChar('7');
+                case DATA_8:
+                        return QChar('8');
+                }
+                return 0;
+}
+void ManageSerialPort::setParity(const ParityType parity)
+{
+        extSerialPort.setParity(parity);
+}
+QString ManageSerialPort::getParity()
+{
+        switch (extSerialPort.parity())
+        {
+                case PAR_NONE:
+                        return QString(tr("None"));
+                case PAR_ODD:
+                        return QString(tr("Odd"));
+                case PAR_EVEN:
+                        return QString(tr("Even"));
+                case PAR_MARK:
+                        return QString(tr("Mark"));
+                case PAR_SPACE:
+                        return QString(tr("Space"));
+                }
+                return 0;
+}
+void ManageSerialPort::setStopBits(const StopBitsType stopBits)
+{
+        extSerialPort.setStopBits(stopBits);
+}
+QString ManageSerialPort::getStopBit()
+{
+        switch (extSerialPort.stopBits())
+        {
+                case STOP_1:
+                        return QString("1");
+                case STOP_1_5:
+                        return QString("1.5");
+                case STOP_2:
+                        return QString("2");
+                }
+                return 0;
+}
+void ManageSerialPort::setFlowControl(const FlowType flowControl)
+{
+        extSerialPort.setFlowControl(flowControl);
+}
+QString ManageSerialPort::getFlowControl()
+{
+        switch (extSerialPort.flowControl())
+        {
+                case FLOW_OFF:
+                        return QString(tr("None"));
+                case FLOW_HARDWARE      :
+                        return QString(tr("Hardware"));
+                case FLOW_XONXOFF :
+                        return QString(tr("Xon/Xoff"));
+                }
+                return 0;
+}
+void ManageSerialPort::setTimeout(ulong seconds, ulong milliseconds)
+{
+        extSerialPort.setTimeout(seconds,milliseconds);
+}
+/*
+QString ManageSerialPort::getLastErrorToString()
+{
+        ulong res = extSerialPort.lastError();
+        switch (res)
+        {
+                case E_NO_ERROR:
+                        return QString(tr("No Error has occured"));
+                case E_INVALID_FD:
+                        return QString(tr("Invalid file descriptor (port was not opened correctly)"));
+                case E_NO_MEMORY:
+                        return QString(tr("Unable to allocate memory tables (POSIX)"));
+                case E_CAUGHT_NON_BLOCKED_SIGNAL:
+                        return QString(tr("Caught a non-blocked signal (POSIX)"));
+                case E_PORT_TIMEOUT:
+                        return QString(tr("Operation timed out (POSIX)"));
+                case E_INVALID_DEVICE:
+                        return QString(tr("The file opened by the port is not a character device (POSIX)"));
+                case E_BREAK_CONDITION:
+                        return QString(tr("The port detected a break condition"));
+                case E_FRAMING_ERROR:
+                        return QString(tr("The port detected a framing error (usually caused by incorrect baud rate settings)"));
+                case E_IO_ERROR:
+                        return QString(tr("There was an I/O error while communicating with the port"));
+                case E_BUFFER_OVERRUN:
+                        return QString(tr("Character buffer overrun"));
+                case E_RECEIVE_OVERFLOW:
+                        return QString(tr("Receive buffer overflow"));
+                case E_RECEIVE_PARITY_ERROR:
+                        return QString(tr("The port detected a parity error in the received data"));
+                case E_TRANSMIT_OVERFLOW:
+                        return QString(tr("Transmit buffer overflow"));
+                case E_READ_FAILED:
+                        return QString(tr("General read operation failure"));
+                case E_WRITE_FAILED:
+                        return QString(tr("General write operation failure"));
+                }
+                return 0;
+}*/
+/*
+ulong ManageSerialPort::getLastError()
+{
+        return extSerialPort.lastError();
+}
+*/
+void ManageSerialPort::enableSending()
+{
+        if (!sendingEnabled && threadSend == NULL) //Si l'envoi n'est pas active && si threadSend n'est pas alloue
+        {
+                threadSend = new ThreadSend(extSerialPort);
+                sendingEnabled = true;
+        }
+}
+void ManageSerialPort::disableSending()
+{
+        if (sendingEnabled && threadSend != NULL) //Si l'envoi est active && si threadSend est alloue
+        {
+                delete (threadSend);
+                threadSend = NULL;
+                sendingEnabled = false;
+        }
+}
+bool ManageSerialPort::isSendingEnabled()
+{
+        return sendingEnabled;
+}
+uchar ManageSerialPort::sendData(QByteArray &dataToSend)
+{
+        if (!isOpen()) //Si le port n'est pas ouvert
+                return 2;
+        if (!sendingEnabled || threadSend == NULL) //Si l'envoi n'est pas active || si threadSend n'est pas alloue
+                return 3;
+        threadSend->addDataToSend(dataToSend); //Ajout des donnees a envoyer
+        return 1;
+}
+void ManageSerialPort::stopSending()
+{
+        if (!sendingEnabled || threadSend == NULL) //Si l'envoi n'est pas active || si threadSend n'est pas été alloue
+                return;
+        if (threadSend->isRunning()) //si un envoi est en cour
+        {
+                threadSend->stopSending(); //on donne l'ordre d'arreter l'envoi
+        long tmp = ULONG_MAX;
+                threadSend->wait(tmp); //on attend l'arret
+        }
+}
+void ManageSerialPort::enableReceiving()
+{
+        if (!receivingEnabled && threadReceive == NULL) //Si la reception n'est pas active && si threadReceive n'est pas alloue
+        {
+                threadReceive = new ThreadReceive(extSerialPort);
+                connect(threadReceive, SIGNAL(newDataReceived(const QByteArray &)), this, SIGNAL(newDataReceived(const QByteArray &)));
+                receivingEnabled = true;
+        }
+}
+void ManageSerialPort::disableReceiving()
+{
+        if (receivingEnabled && threadReceive != NULL) //Si la reception est pas active && si threadReceive est alloue
+        {
+                delete (threadReceive);
+                threadReceive = NULL;
+                receivingEnabled = false;
+        }
+}
+bool ManageSerialPort::isReceivingEnabled()
+{
+        return receivingEnabled;
+}
+uchar ManageSerialPort::receiveData()
+{
+        if (!isOpen()) //Si le port n'est pas ouvert
+                return 2;
+        if (!receivingEnabled || threadReceive == NULL) //Si la reception n'est pas active || si threadReceive n'est pas été alloue
+                return 3;
+        if (!threadReceive->isRunning())
+        {
+                saveStateReceiveData = true;
+                threadReceive->start(); //Demarrage du thread de reception
+        }
+        return 1;
+}
+void ManageSerialPort::stopReceiving()
+{
+        if (!receivingEnabled || threadReceive == NULL) //Si la reception n'est pas active || si threadReceive n'est pas alloue
+                return;
+        if (threadReceive->isRunning()) //Si le thread de reception est en fonctionnement
+        {
+                saveStateReceiveData = false;
+                threadReceive->stopReceiving(); //on donne l'ordre d'arreter la reception
+        long tmp = ULONG_MAX;
+                threadReceive->wait(tmp); //on attend l'arret
+        }
+}
+/********************************************************************************************************
+                * Classe ThreadSend
+                *****************************************************************************************************/
+ThreadSend::ThreadSend(QextSerialPort &addressSerialPort) : extSerialPort(addressSerialPort)
+{
+        dataToSend.clear();
+        stopped=false;
+}
+ThreadSend::~ThreadSend()
+{
+        if (isRunning())
+        {
+                stopSending();
+                wait();
+        }
+}
+void ThreadSend::addDataToSend(QByteArray &dataToAdd)
+{
+        QMutexLocker locker(&mutexSend);
+        for (int i=0; i<dataToAdd.size(); i++)
+                dataToSend.enqueue(QByteArray(1,dataToAdd.at(i)));
+        if (!isRunning())
+                start();
+}
+void ThreadSend::stopSending()
+{
+        stopped=true;
+}
+void ThreadSend::run()
+{
+        QByteArray byteArray;
+        forever
+        {
+                if (dataToSend.isEmpty() || stopped)
+                {
+                        stopped = false;
+                        break;
+                }
+                mutexSend.lock();
+                byteArray = dataToSend.dequeue();
+                mutexSend.unlock();
+                extSerialPort.write(byteArray, 1);
+        }
+}
+/********************************************************************************************************
+                * Classe ThreadReceive - A TERMINER
+                *****************************************************************************************************/
+ThreadReceive::ThreadReceive(QextSerialPort &addressSerialPort) : extSerialPort(addressSerialPort)
+{
+        stopped=false;
+}
+ThreadReceive::~ThreadReceive()
+{
+        if (isRunning())
+        {
+                stopReceiving();
+                wait();
+        }
+}
+void ThreadReceive::stopReceiving()
+{
+        stopped = true;
+}
+void ThreadReceive::run()
+{
+        int numBytes=0;
+        char data[1024];
+        QByteArray dataReceived;
+        forever
+        {
+                if (stopped)
+                {
+                        stopped = false;
+                        break;
+                }
+                mutexReceive.lock();
+                numBytes = extSerialPort.bytesAvailable();
+                if (numBytes > 0)
+                {
+                        extSerialPort.read(data, numBytes);
+                    for (int xy=1; xy < numBytes; xy++)
+                    {
+                        if (data[xy] == 0)
+                        {
+                                data[xy] = 'a';
+                        }
+            }
+                        data[numBytes]='\0';
+                        dataReceived = data;
+                        emit newDataReceived(dataReceived);
+                }
+                        mutexReceive.unlock();
+        }
+}

 /QMK-Groundstation/tags/V1.0.1/SerialPort/ManageSerialPort.h
 ,0 → 1,322
+/********************************************************************************************************
+* PROGRAM      : QSerialPortTerminal
+* DATE - TIME  : vendredi 03 octobre 2008 - 11h15
+* AUTHOR       : VIANNEY-LIAUD Philippe ( philippe.vianney.liaud gmail.com )
+* FILENAME     : ManageSerialPort.h
+* LICENSE      : GPL
+* COMMENTARY   : Manage qExtSerialPort
+********************************************************************************************************/
+#ifndef MANAGESERIALPORT_H
+#define MANAGESERIALPORT_H
+#include <QThread>
+#include <QQueue>
+#include <QMetaType>
+#include <QMutex>
+#include "qextserialport.h"
+Q_DECLARE_METATYPE(BaudRateType);
+Q_DECLARE_METATYPE(DataBitsType);
+Q_DECLARE_METATYPE(ParityType);
+Q_DECLARE_METATYPE(StopBitsType);
+Q_DECLARE_METATYPE(FlowType);
+class ThreadSend;
+class ThreadReceive;
+class ManageSerialPort : public QObject
+{
+    Q_OBJECT
+public:
+//Constructeurs + destructeur
+    ManageSerialPort();
+    ManageSerialPort(const QString &name, const BaudRateType baudRate, const DataBitsType dataBits,\
+                     const ParityType parity, const StopBitsType stopBits, \
+                     const FlowType flowControl, ulong seconds, ulong milliseconds);
+    ~ManageSerialPort();
+//General
+    bool open();
+    bool open(const QString &name, const BaudRateType baudRate, const DataBitsType dataBits,\
+              const ParityType parity, const StopBitsType stopBits, \
+              const FlowType flowControl, ulong seconds, ulong milliseconds);
+    bool isOpen();
+    void close();
+    //Sets the name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0"
+    void setPort(const QString &name);
+    QString getPort();
+    /*Most used : '*' (POSTX & Windows)
+    RATE          Windows Speed   POSIX Speed
+    -----------   -------------   -----------
+     enum BaudRateType{
+        BAUD50                 110          50          //POSIX ONLY
+        BAUD75                 110          75          //POSIX ONLY
+       *BAUD110                110         110
+        BAUD134                110         134.5        //POSIX ONLY
+        BAUD150                110         150          //POSIX ONLY
+        BAUD200                110         200          //POSIX ONLY
+       *BAUD300                300         300
+       *BAUD600                600         600
+       *BAUD1200              1200        1200
+        BAUD1800              1200        1800          //POSIX ONLY
+       *BAUD2400              2400        2400
+       *BAUD4800              4800        4800
+       *BAUD9600              9600        9600
+        BAUD14400            14400        9600          //WINDOWS ONLY
+       *BAUD19200            19200       19200
+       *BAUD38400            38400       38400
+        BAUD56000            56000       38400          //WINDOWS ONLY
+       *BAUD57600            57600       57600
+        BAUD76800            57600       76800          //POSIX ONLY
+       *BAUD115200          115200      115200
+        BAUD128000          128000      115200          //WINDOWS ONLY
+        BAUD256000          256000      115200          //WINDOWS ONLY
+    }*/
+    void setBaudRate(const BaudRateType baudRate);
+    /*getBaudRate
+        return "50";
+        return "75";
+        return "110";
+        return "134";
+        return "150";
+        return "200";
+        return "300";
+        return "600";
+        return "1200";
+        return "1800";
+        return "2400";
+        return "4800";
+        return "9600";
+        return "14400";
+        return "19200";
+        return "38400";
+        return "56000";
+        return "57600";
+        return "76800";
+        return "115200";
+        return "128000";
+        return "256000";*/
+    QString getBaudRate();
+    /*enum DataBitsType {
+        DATA_5
+        DATA_6
+        DATA_7
+        DATA_8
+    };*/
+    void setDataBits(const DataBitsType dataBits);
+    /*getDataBits
+        return '5';
+        return '6';
+        return '7';
+        return '8';*/
+    QChar getDataBits();
+    /*enum ParityType {
+        PAR_NONE        //None means that no parity bit is sent at all
+        PAR_ODD         //Odd
+        PAR_EVEN        //Even
+        PAR_MARK        //Windows only : Mark parity means that the parity bit is always set to the mark signal condition (logical 1)
+        PAR_SPACE       //Space parity always sends the parity bit in the space signal condition
+    };*/
+    void setParity(const ParityType parity);
+    /*getParity
+        return "None";
+        return "Odd";
+        return "Even";
+        return "Mark";  Windows only
+        return "Space";*/
+    QString getParity();
+    /*enum StopBitsType {
+        STOP_1
+        STOP_1_5        //WINDOWS ONLY
+        STOP_2
+    };*/
+    void setStopBits(const StopBitsType stopBits);
+    /*getStopBit
+        return "1"
+        return "1.5"
+        return "2"*/
+    QString getStopBit();
+    /*enum FlowType {
+        FLOW_OFF
+        FLOW_HARDWARE
+        FLOW_XONXOFF
+    };*/
+    void setFlowControl(const FlowType flowControl);
+    /*getFlowControl
+        return "None"
+        return "Hardware"
+        return "Xon/Xoff"*/
+    QString getFlowControl();
+    void setTimeout(ulong seconds, ulong milliseconds);
+    /*getLastErrorToString
+        return "No Error has occured"
+        return "Invalid file descriptor (port was not opened correctly)"
+        return "Unable to allocate memory tables (POSIX)"
+        return "Caught a non-blocked signal (POSIX)"
+        return "Operation timed out (POSIX)"
+        return "The file opened by the port is not a character device (POSIX)"
+        return "The port detected a break condition"
+        return "The port detected a framing error (usually caused by incorrect baud rate settings)"
+        return "There was an I/O error while communicating with the port"
+        return "Character buffer overrun"
+        return "Receive buffer overflow"
+        return "The port detected a parity error in the received data"
+        return "Transmit buffer overflow"
+        return "General read operation failure"
+        return "General write operation failure"*/
+    /*QString getLastErrorToString();*/
+    /*getLastError
+        return 0 : No Error has occured
+        return 1 : Invalid file descriptor (port was not opened correctly)
+        return 2 : Unable to allocate memory tables (POSIX)
+        return 3 : Caught a non-blocked signal (POSIX)
+        return 4 : Operation timed out (POSIX)
+        return 5 : The file opened by the port is not a character device (POSIX)
+        return 6 : The port detected a break condition"
+        return 7 : The port detected a framing error (usually caused by incorrect baud rate settings)
+        return 8 : There was an I/O error while communicating with the port
+        return 9 : Character buffer overrun
+        return 10 : Receive buffer overflow
+        return 11 : The port detected a parity error in the received data
+        return 12 : Transmit buffer overflow
+        return 13 : General read operation failure
+        return 14 : General write operation failure*/
+    /*ulong getLastError();*/
+    //Emission
+    void enableSending();
+    void disableSending();
+    /*isSendingEnabled
+        return 0 : sending is not enable
+        return 1 : sending is enable*/
+    bool isSendingEnabled();
+    /*sendData
+        return 1 : add OK
+        return 2 : port is not open
+        return 3 : sending is not enable*/
+    uchar sendData(QByteArray &dataToSend);
+    void stopSending();
+//Reception
+    void enableReceiving();
+    void disableReceiving();
+    /*isReceivingEnabled
+        return 0 : receiving is not enable
+        return 1 : receiving is enable*/
+    bool isReceivingEnabled();
+    /*receiveData
+        return 1 : start thread OK
+        return 2 : port is not open
+        return 3 : receiving is not enable*/
+    uchar receiveData();
+    void stopReceiving();
+signals:
+    void newDataReceived(const QByteArray &dataReceived);
+private:
+    //Variables privees
+    QextSerialPort extSerialPort;
+    ThreadSend *threadSend;
+    ThreadReceive *threadReceive;
+    bool sendingEnabled;
+    bool receivingEnabled;
+    bool closeCalled;
+    bool saveStateSendEnabled;
+    bool saveStateReceivedEnabled;
+    bool saveStateReceiveData;
+};
+#endif // MANAGESERIALPORT_H
+class ThreadSend : public QThread
+{
+    Q_OBJECT
+public:
+    ThreadSend(QextSerialPort &addressSerialPort);
+    ~ThreadSend();
+    void addDataToSend(QByteArray &dataToAdd);
+    void stopSending();
+protected:
+    void run();
+private:
+    QMutex mutexSend;
+    QextSerialPort &extSerialPort;
+    QQueue<QByteArray> dataToSend;
+    bool stopped;
+};
+class ThreadReceive : public QThread
+{
+    Q_OBJECT
+public:
+    ThreadReceive(QextSerialPort &addressSerialPort);
+    ~ThreadReceive();
+    void stopReceiving();
+protected:
+    void run();
+private :
+    QMutex mutexReceive;
+    QextSerialPort &extSerialPort;
+    bool stopped;
+signals:
+    void newDataReceived(const QByteArray &dataReceived);
+};

 /QMK-Groundstation/tags/V1.0.1/SerialPort/posix_qextserialport.cpp
 ,0 → 1,1114
+/*!
+                \class Posix_QextSerialPort
+                \version 1.0.0
+                \author Stefan Sander
+A cross-platform serial port class.
+                This class encapsulates the POSIX portion of QextSerialPort.  The user will be notified of errors
+                and possible portability conflicts at run-time by default - this behavior can be turned off by
+                defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off portability
+                warnings) in the project.  Note that _TTY_NOWARN_ will also turn off portability warnings.
+*/
+#include <stdio.h>
+#include "posix_qextserialport.h"
+/*!
+                \fn Posix_QextSerialPort::Posix_QextSerialPort()
+                        Default constructor.  Note that the name of the device used by a QextSerialPort constructed with
+                        this constructor will be determined by #defined constants, or lack thereof - the default behavior
+                        is the same as _TTY_LINUX_.  Possible naming conventions and their associated constants are:
+\verbatim
+Constant         Used By         Naming Convention
+                ----------       -------------   ------------------------
+                _TTY_WIN_        Windows         COM1, COM2
+                _TTY_IRIX_       SGI/IRIX        /dev/ttyf1, /dev/ttyf2
+                _TTY_HPUX_       HP-UX           /dev/tty1p0, /dev/tty2p0
+                _TTY_SUN_        SunOS/Solaris   /dev/ttya, /dev/ttyb
+                _TTY_DIGITAL_    Digital UNIX    /dev/tty01, /dev/tty02
+                _TTY_FREEBSD_    FreeBSD         /dev/ttyd0, /dev/ttyd1
+                _TTY_LINUX_      Linux           /dev/ttyS0, /dev/ttyS1
+                <none>           Linux           /dev/ttyS0, /dev/ttyS1
+                \endverbatim
+This constructor assigns the device name to the name of the first port on the specified system.
+                See the other constructors if you need to open a different port.
+*/
+Posix_QextSerialPort::Posix_QextSerialPort()
+        : QextSerialBase()
+{
+        Posix_File=new QFile();
+}
+/*!
+                \fn Posix_QextSerialPort::Posix_QextSerialPort(const Posix_QextSerialPort&)
+                        Copy constructor.
+*/
+Posix_QextSerialPort::Posix_QextSerialPort(const Posix_QextSerialPort& s)
+        : QextSerialBase(s.port)
+{
+        setOpenMode(s.openMode());
+        port = s.port;
+        Settings.BaudRate=s.Settings.BaudRate;
+        Settings.DataBits=s.Settings.DataBits;
+        Settings.Parity=s.Settings.Parity;
+        Settings.StopBits=s.Settings.StopBits;
+        Settings.FlowControl=s.Settings.FlowControl;
+        lastErr=s.lastErr;
+        Posix_File=new QFile();
+        Posix_File=s.Posix_File;
+        memcpy(&Posix_Timeout, &s.Posix_Timeout, sizeof(struct timeval));
+        memcpy(&Posix_Copy_Timeout, &s.Posix_Copy_Timeout, sizeof(struct timeval));
+        memcpy(&Posix_CommConfig, &s.Posix_CommConfig, sizeof(struct termios));
+}
+/*!
+                \fn Posix_QextSerialPort::Posix_QextSerialPort(const QString & name)
+                        Constructs a serial port attached to the port specified by name.
+                        name is the name of the device, which is windowsystem-specific,
+                        e.g."COM1" or "/dev/ttyS0".
+*/
+Posix_QextSerialPort::Posix_QextSerialPort(const QString & name)
+        : QextSerialBase(name)
+{
+        Posix_File=new QFile();
+}
+/*!
+                \fn Posix_QextSerialPort::Posix_QextSerialPort(const PortSettings& settings)
+                        Constructs a port with default name and specified settings.
+*/
+Posix_QextSerialPort::Posix_QextSerialPort(const PortSettings& settings)
+        : QextSerialBase()
+{
+        setBaudRate(settings.BaudRate);
+        setDataBits(settings.DataBits);
+        setParity(settings.Parity);
+        setStopBits(settings.StopBits);
+        setFlowControl(settings.FlowControl);
+        Posix_File=new QFile();
+        setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
+}
+/*!
+                \fn Posix_QextSerialPort::Posix_QextSerialPort(const QString & name, const PortSettings& settings)
+                        Constructs a port with specified name and settings.
+*/
+Posix_QextSerialPort::Posix_QextSerialPort(const QString & name, const PortSettings& settings)
+        : QextSerialBase(name)
+{
+        setBaudRate(settings.BaudRate);
+        setDataBits(settings.DataBits);
+        setParity(settings.Parity);
+        setStopBits(settings.StopBits);
+        setFlowControl(settings.FlowControl);
+        Posix_File=new QFile();
+        setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
+}
+/*!
+                \fn Posix_QextSerialPort& Posix_QextSerialPort::operator=(const Posix_QextSerialPort& s)
+                        Override the = operator.
+*/
+Posix_QextSerialPort& Posix_QextSerialPort::operator=(const Posix_QextSerialPort& s)
+{
+        setOpenMode(s.openMode());
+        port = s.port;
+        Settings.BaudRate=s.Settings.BaudRate;
+        Settings.DataBits=s.Settings.DataBits;
+        Settings.Parity=s.Settings.Parity;
+        Settings.StopBits=s.Settings.StopBits;
+        Settings.FlowControl=s.Settings.FlowControl;
+        lastErr=s.lastErr;
+        Posix_File=s.Posix_File;
+        memcpy(&Posix_Timeout, &(s.Posix_Timeout), sizeof(struct timeval));
+        memcpy(&Posix_Copy_Timeout, &(s.Posix_Copy_Timeout), sizeof(struct timeval));
+        memcpy(&Posix_CommConfig, &(s.Posix_CommConfig), sizeof(struct termios));
+        return *this;
+}
+/*!
+                \fn Posix_QextSerialPort::~Posix_QextSerialPort()
+                        Standard destructor.
+*/
+Posix_QextSerialPort::~Posix_QextSerialPort()
+{
+        if (isOpen()) {
+                close();
+        }
+        Posix_File->close();
+        delete Posix_File;
+}
+/*!
+                \fn void Posix_QextSerialPort::setBaudRate(BaudRateType baudRate)
+                        Sets the baud rate of the serial port.  Note that not all rates are applicable on
+                        all platforms.  The following table shows translations of the various baud rate
+                        constants on Windows(including NT/2000) and POSIX platforms.  Speeds marked with an *
+                        are speeds that are usable on both Windows and POSIX.
+\note
+                BAUD76800 may not be supported on all POSIX systems.  SGI/IRIX systems do not support
+                BAUD1800.
+\verbatim
+RATE          Windows Speed   POSIX Speed
+                -----------   -------------   -----------
+                BAUD50                 110          50
+                BAUD75                 110          75
+                *BAUD110                110         110
+                BAUD134                110         134.5
+                BAUD150                110         150
+                BAUD200                110         200
+                *BAUD300                300         300
+                *BAUD600                600         600
+                *BAUD1200              1200        1200
+                BAUD1800              1200        1800
+                *BAUD2400              2400        2400
+                *BAUD4800              4800        4800
+                *BAUD9600              9600        9600
+                BAUD14400            14400        9600
+                *BAUD19200            19200       19200
+                *BAUD38400            38400       38400
+                BAUD56000            56000       38400
+                *BAUD57600            57600       57600
+                BAUD76800            57600       76800
+                *BAUD115200          115200      115200
+                BAUD128000          128000      115200
+                BAUD256000          256000      115200
+                \endverbatim
+*/
+void Posix_QextSerialPort::setBaudRate(BaudRateType baudRate)
+{
+        LOCK_MUTEX();
+        if (Settings.BaudRate!=baudRate) {
+                switch (baudRate) {
+                        case BAUD14400:
+                                Settings.BaudRate=BAUD9600;
+                                break;
+                        case BAUD56000:
+                                Settings.BaudRate=BAUD38400;
+                                break;
+                        case BAUD76800:
+                                #ifndef B76800
+                                                        Settings.BaudRate=BAUD57600;
+                                #else
+                                Settings.BaudRate=baudRate;
+                                #endif
+                                                        break;
+                        case BAUD128000:
+                        case BAUD256000:
+                                Settings.BaudRate=BAUD115200;
+                                break;
+                        default:
+                                Settings.BaudRate=baudRate;
+                                break;
+                }
+        }
+        if (isOpen()) {
+                switch (baudRate) {
+                                /*50 baud*/
+                        case BAUD50:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 50 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B50;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B50);
+                                cfsetospeed(&Posix_CommConfig, B50);
+                                #endif
+                                                        break;
+                                /*75 baud*/
+                        case BAUD75:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 75 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B75;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B75);
+                                cfsetospeed(&Posix_CommConfig, B75);
+                                #endif
+                                                        break;
+                                /*110 baud*/
+                        case BAUD110:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B110;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B110);
+                                cfsetospeed(&Posix_CommConfig, B110);
+                                #endif
+                                                        break;
+                                /*134.5 baud*/
+                        case BAUD134:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 134.5 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B134;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B134);
+                                cfsetospeed(&Posix_CommConfig, B134);
+                                #endif
+                                                        break;
+                                /*150 baud*/
+                        case BAUD150:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 150 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B150;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B150);
+                                cfsetospeed(&Posix_CommConfig, B150);
+                                #endif
+                                                        break;
+                                /*200 baud*/
+                        case BAUD200:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows does not support 200 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B200;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B200);
+                                cfsetospeed(&Posix_CommConfig, B200);
+                                #endif
+                                                        break;
+                                /*300 baud*/
+                        case BAUD300:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B300;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B300);
+                                cfsetospeed(&Posix_CommConfig, B300);
+                                #endif
+                                                        break;
+                                /*600 baud*/
+                        case BAUD600:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B600;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B600);
+                                cfsetospeed(&Posix_CommConfig, B600);
+                                #endif
+                                                        break;
+                                /*1200 baud*/
+                        case BAUD1200:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B1200;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B1200);
+                                cfsetospeed(&Posix_CommConfig, B1200);
+                                #endif
+                                                        break;
+                                /*1800 baud*/
+                        case BAUD1800:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows and IRIX do not support 1800 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B1800;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B1800);
+                                cfsetospeed(&Posix_CommConfig, B1800);
+                                #endif
+                                                        break;
+                                /*2400 baud*/
+                        case BAUD2400:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B2400;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B2400);
+                                cfsetospeed(&Posix_CommConfig, B2400);
+                                #endif
+                                                        break;
+                                /*4800 baud*/
+                        case BAUD4800:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B4800;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B4800);
+                                cfsetospeed(&Posix_CommConfig, B4800);
+                                #endif
+                                                        break;
+                                /*9600 baud*/
+                        case BAUD9600:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B9600;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B9600);
+                                cfsetospeed(&Posix_CommConfig, B9600);
+                                #endif
+                                                        break;
+                                /*14400 baud*/
+                        case BAUD14400:
+                                TTY_WARNING("Posix_QextSerialPort: POSIX does not support 14400 baud operation.  Switching to 9600 baud.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B9600;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B9600);
+                                cfsetospeed(&Posix_CommConfig, B9600);
+                                #endif
+                                                        break;
+                                /*19200 baud*/
+                        case BAUD19200:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B19200;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B19200);
+                                cfsetospeed(&Posix_CommConfig, B19200);
+                                #endif
+                                                        break;
+                                /*38400 baud*/
+                        case BAUD38400:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B38400;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B38400);
+                                cfsetospeed(&Posix_CommConfig, B38400);
+                                #endif
+                                                        break;
+                                /*56000 baud*/
+                        case BAUD56000:
+                                TTY_WARNING("Posix_QextSerialPort: POSIX does not support 56000 baud operation.  Switching to 38400 baud.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B38400;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B38400);
+                                cfsetospeed(&Posix_CommConfig, B38400);
+                                #endif
+                                                        break;
+                                /*57600 baud*/
+                        case BAUD57600:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B57600;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B57600);
+                                cfsetospeed(&Posix_CommConfig, B57600);
+                                #endif
+                                                        break;
+                                /*76800 baud*/
+                        case BAUD76800:
+                                TTY_PORTABILITY_WARNING("Posix_QextSerialPort Portability Warning: Windows and some POSIX systems do not support 76800 baud operation.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                #ifdef B76800
+                                                        Posix_CommConfig.c_cflag|=B76800;
+                                #else
+                                TTY_WARNING("Posix_QextSerialPort: Posix_QextSerialPort was compiled without 76800 baud support.  Switching to 57600 baud.");
+                                Posix_CommConfig.c_cflag|=B57600;
+                                #endif //B76800
+                                #else  //CBAUD
+                                #ifdef B76800
+                                                        cfsetispeed(&Posix_CommConfig, B76800);
+                                cfsetospeed(&Posix_CommConfig, B76800);
+                                #else
+                                TTY_WARNING("Posix_QextSerialPort: Posix_QextSerialPort was compiled without 76800 baud support.  Switching to 57600 baud.");
+                                cfsetispeed(&Posix_CommConfig, B57600);
+                                cfsetospeed(&Posix_CommConfig, B57600);
+                                #endif //B76800
+                                #endif //CBAUD
+                                                        break;
+                                /*115200 baud*/
+                        case BAUD115200:
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B115200;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B115200);
+                                cfsetospeed(&Posix_CommConfig, B115200);
+                                #endif
+                                                        break;
+                                /*128000 baud*/
+                        case BAUD128000:
+                                TTY_WARNING("Posix_QextSerialPort: POSIX does not support 128000 baud operation.  Switching to 115200 baud.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B115200;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B115200);
+                                cfsetospeed(&Posix_CommConfig, B115200);
+                                #endif
+                                                        break;
+                                /*256000 baud*/
+                        case BAUD256000:
+                                TTY_WARNING("Posix_QextSerialPort: POSIX does not support 256000 baud operation.  Switching to 115200 baud.");
+                                #ifdef CBAUD
+                                                        Posix_CommConfig.c_cflag&=(~CBAUD);
+                                Posix_CommConfig.c_cflag|=B115200;
+                                #else
+                                cfsetispeed(&Posix_CommConfig, B115200);
+                                cfsetospeed(&Posix_CommConfig, B115200);
+                                #endif
+                                                        break;
+                        }
+                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::setDataBits(DataBitsType dataBits)
+                        Sets the number of data bits used by the serial port.  Possible values of dataBits are:
+\verbatim
+                DATA_5      5 data bits
+                DATA_6      6 data bits
+                DATA_7      7 data bits
+                DATA_8      8 data bits
+                \endverbatim
+\note
+                This function is subject to the following restrictions:
+\par
+data bits cannot be used with 2 stop bits.
+                \par
+data bits cannot be used with space parity on POSIX systems.
+*/
+void Posix_QextSerialPort::setDataBits(DataBitsType dataBits)
+{
+        LOCK_MUTEX();
+        if (Settings.DataBits!=dataBits) {
+                if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) ||
+                                (Settings.StopBits==STOP_1_5 && dataBits!=DATA_5) ||
+                                (Settings.Parity==PAR_SPACE && dataBits==DATA_8)) {
+                                }
+                else {
+                        Settings.DataBits=dataBits;
+                }
+        }
+        if (isOpen()) {
+                switch(dataBits) {
+                                /*5 data bits*/
+                        case DATA_5:
+                                if (Settings.StopBits==STOP_2) {
+                                        TTY_WARNING("Posix_QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
+                                }
+                                else {
+                                        Settings.DataBits=dataBits;
+                                        Posix_CommConfig.c_cflag&=(~CSIZE);
+                                        Posix_CommConfig.c_cflag|=CS5;
+                                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                }
+                                break;
+                                /*6 data bits*/
+                        case DATA_6:
+                                if (Settings.StopBits==STOP_1_5) {
+                                        TTY_WARNING("Posix_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
+                                }
+                                else {
+                                        Settings.DataBits=dataBits;
+                                        Posix_CommConfig.c_cflag&=(~CSIZE);
+                                        Posix_CommConfig.c_cflag|=CS6;
+                                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                }
+                                break;
+                                /*7 data bits*/
+                        case DATA_7:
+                                if (Settings.StopBits==STOP_1_5) {
+                                        TTY_WARNING("Posix_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
+                                }
+                                else {
+                                        Settings.DataBits=dataBits;
+                                        Posix_CommConfig.c_cflag&=(~CSIZE);
+                                        Posix_CommConfig.c_cflag|=CS7;
+                                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                }
+                                break;
+                                /*8 data bits*/
+                        case DATA_8:
+                                if (Settings.StopBits==STOP_1_5) {
+                                        TTY_WARNING("Posix_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
+                                }
+                                else {
+                                        Settings.DataBits=dataBits;
+                                        Posix_CommConfig.c_cflag&=(~CSIZE);
+                                        Posix_CommConfig.c_cflag|=CS8;
+                                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                }
+                                break;
+                        }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::setParity(ParityType parity)
+                        Sets the parity associated with the serial port.  The possible values of parity are:
+\verbatim
+                PAR_SPACE       Space Parity
+                PAR_MARK        Mark Parity
+                PAR_NONE        No Parity
+                PAR_EVEN        Even Parity
+                PAR_ODD         Odd Parity
+                \endverbatim
+\note
+                This function is subject to the following limitations:
+\par
+                POSIX systems do not support mark parity.
+                \par
+                POSIX systems support space parity only if tricked into doing so, and only with
+                fewer than 8 data bits.  Use space parity very carefully with POSIX systems.
+*/
+void Posix_QextSerialPort::setParity(ParityType parity)
+{
+        LOCK_MUTEX();
+        if (Settings.Parity!=parity) {
+                if (parity==PAR_MARK || (parity==PAR_SPACE && Settings.DataBits==DATA_8)) {
+                }
+                else {
+                        Settings.Parity=parity;
+                }
+        }
+        if (isOpen()) {
+                switch (parity) {
+                                /*space parity*/
+                        case PAR_SPACE:
+                                if (Settings.DataBits==DATA_8) {
+                                        TTY_PORTABILITY_WARNING("Posix_QextSerialPort:  Space parity is only supported in POSIX with 7 or fewer data bits");
+                                }
+                                else {
+                                        /*space parity not directly supported - add an extra data bit to simulate it*/
+                                        Posix_CommConfig.c_cflag&=~(PARENB|CSIZE);
+                                switch(Settings.DataBits) {
+                                        case DATA_5:
+                                                Settings.DataBits=DATA_6;
+                                                Posix_CommConfig.c_cflag|=CS6;
+                                                break;
+                                        case DATA_6:
+                                                Settings.DataBits=DATA_7;
+                                                Posix_CommConfig.c_cflag|=CS7;
+                                                break;
+                                        case DATA_7:
+                                                Settings.DataBits=DATA_8;
+                                                Posix_CommConfig.c_cflag|=CS8;
+                                                break;
+                                        case DATA_8:
+                                                break;
+                                        }
+                                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                }
+                                break;
+                                /*mark parity - WINDOWS ONLY*/
+                        case PAR_MARK:
+                                TTY_WARNING("Posix_QextSerialPort: Mark parity is not supported by POSIX.");
+                                break;
+                                /*no parity*/
+                        case PAR_NONE:
+                                Posix_CommConfig.c_cflag&=(~PARENB);
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                                /*even parity*/
+                        case PAR_EVEN:
+                                Posix_CommConfig.c_cflag&=(~PARODD);
+                                Posix_CommConfig.c_cflag|=PARENB;
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                                /*odd parity*/
+                        case PAR_ODD:
+                                Posix_CommConfig.c_cflag|=(PARENB|PARODD);
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                        }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::setStopBits(StopBitsType stopBits)
+                        Sets the number of stop bits used by the serial port.  Possible values of stopBits are:
+\verbatim
+                STOP_1      1 stop bit
+                STOP_1_5    1.5 stop bits
+                STOP_2      2 stop bits
+                \endverbatim
+                \note
+                This function is subject to the following restrictions:
+\par
+stop bits cannot be used with 5 data bits.
+                \par
+                POSIX does not support 1.5 stop bits.
+*/
+void Posix_QextSerialPort::setStopBits(StopBitsType stopBits)
+{
+        LOCK_MUTEX();
+        if (Settings.StopBits!=stopBits) {
+                if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) || stopBits==STOP_1_5) {}
+                else {
+                        Settings.StopBits=stopBits;
+                }
+        }
+        if (isOpen()) {
+                switch (stopBits) {
+                                /*one stop bit*/
+                        case STOP_1:
+                                Settings.StopBits=stopBits;
+                                Posix_CommConfig.c_cflag&=(~CSTOPB);
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                                /*1.5 stop bits*/
+                        case STOP_1_5:
+                                TTY_WARNING("Posix_QextSerialPort: 1.5 stop bit operation is not supported by POSIX.");
+                                break;
+                                /*two stop bits*/
+                        case STOP_2:
+                                if (Settings.DataBits==DATA_5) {
+                                        TTY_WARNING("Posix_QextSerialPort: 2 stop bits cannot be used with 5 data bits");
+                                }
+                                else {
+                                        Settings.StopBits=stopBits;
+                                        Posix_CommConfig.c_cflag|=CSTOPB;
+                                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                }
+                                break;
+                        }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::setFlowControl(FlowType flow)
+                        Sets the flow control used by the port.  Possible values of flow are:
+\verbatim
+                FLOW_OFF            No flow control
+                FLOW_HARDWARE       Hardware (RTS/CTS) flow control
+                FLOW_XONXOFF        Software (XON/XOFF) flow control
+                \endverbatim
+                \note
+                FLOW_HARDWARE may not be supported on all versions of UNIX.  In cases where it is
+                unsupported, FLOW_HARDWARE is the same as FLOW_OFF.
+*/
+void Posix_QextSerialPort::setFlowControl(FlowType flow)
+{
+        LOCK_MUTEX();
+        if (Settings.FlowControl!=flow) {
+                Settings.FlowControl=flow;
+        }
+        if (isOpen()) {
+                switch(flow) {
+                                /*no flow control*/
+                        case FLOW_OFF:
+                                Posix_CommConfig.c_cflag&=(~CRTSCTS);
+                                Posix_CommConfig.c_iflag&=(~(IXON|IXOFF|IXANY));
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                                /*software (XON/XOFF) flow control*/
+                        case FLOW_XONXOFF:
+                                Posix_CommConfig.c_cflag&=(~CRTSCTS);
+                                Posix_CommConfig.c_iflag|=(IXON|IXOFF|IXANY);
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                        case FLOW_HARDWARE:
+                                Posix_CommConfig.c_cflag|=CRTSCTS;
+                                Posix_CommConfig.c_iflag&=(~(IXON|IXOFF|IXANY));
+                                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                                break;
+                        }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::setTimeout(ulong sec, ulong millisec);
+Sets the read and write timeouts for the port to sec seconds and millisec milliseconds.
+                Note that this is a per-character timeout, i.e. the port will wait this long for each
+                individual character, not for the whole read operation.  This timeout also applies to the
+                bytesWaiting() function.
+\note
+                POSIX does not support millisecond-level control for I/O timeout values.  Any
+                timeout set using this function will be set to the next lowest tenth of a second for
+                the purposes of detecting read or write timeouts.  For example a timeout of 550 milliseconds
+                will be seen by the class as a timeout of 500 milliseconds for the purposes of reading and
+                writing the port.  However millisecond-level control is allowed by the select() system call,
+                so for example a 550-millisecond timeout will be seen as 550 milliseconds on POSIX systems for
+                the purpose of detecting available bytes in the read buffer.
+*/
+void Posix_QextSerialPort::setTimeout(ulong sec, ulong millisec)
+{
+        LOCK_MUTEX();
+        Settings.Timeout_Sec=sec;
+        Settings.Timeout_Millisec=millisec;
+        Posix_Copy_Timeout.tv_sec=sec;
+        Posix_Copy_Timeout.tv_usec=millisec;
+        if (isOpen()) {
+                tcgetattr(Posix_File->handle(), &Posix_CommConfig);
+                Posix_CommConfig.c_cc[VTIME]=sec*10+millisec/100;
+                tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn bool Posix_QextSerialPort::open(OpenMode mode)
+                        Opens the serial port associated to this class.
+                        This function has no effect if the port associated with the class is already open.
+                        The port is also configured to the current settings, as stored in the Settings structure.
+*/
+bool Posix_QextSerialPort::open(OpenMode mode)
+{
+        LOCK_MUTEX();
+        if (mode == QIODevice::NotOpen)
+                return isOpen();
+        if (!isOpen()) {
+                /*open the port*/
+                Posix_File->setFileName(port);
+                if (Posix_File->open(QIODevice::ReadWrite|QIODevice::Unbuffered)) {
+                        /*set open mode*/
+                        QIODevice::open(mode);
+                        /*configure port settings*/
+                        tcgetattr(Posix_File->handle(), &Posix_CommConfig);
+                        /*set up other port settings*/
+                        Posix_CommConfig.c_cflag|=CREAD|CLOCAL;
+                        Posix_CommConfig.c_lflag&=(~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|ISIG));
+                        Posix_CommConfig.c_iflag&=(~(INPCK|IGNPAR|PARMRK|ISTRIP|ICRNL|IXANY));
+                        Posix_CommConfig.c_oflag&=(~OPOST);
+                        Posix_CommConfig.c_cc[VMIN]=0;
+                        Posix_CommConfig.c_cc[VINTR] = _POSIX_VDISABLE;
+                        Posix_CommConfig.c_cc[VQUIT] = _POSIX_VDISABLE;
+                        Posix_CommConfig.c_cc[VSTART] = _POSIX_VDISABLE;
+                        Posix_CommConfig.c_cc[VSTOP] = _POSIX_VDISABLE;
+                        Posix_CommConfig.c_cc[VSUSP] = _POSIX_VDISABLE;
+                        setBaudRate(Settings.BaudRate);
+                        setDataBits(Settings.DataBits);
+                        setParity(Settings.Parity);
+                        setStopBits(Settings.StopBits);
+                        setFlowControl(Settings.FlowControl);
+                        setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec);
+                        tcsetattr(Posix_File->handle(), TCSAFLUSH, &Posix_CommConfig);
+                } else {
+                }
+        }
+        UNLOCK_MUTEX();
+        return isOpen();
+}
+/*!
+                \fn void Posix_QextSerialPort::close()
+                        Closes a serial port.  This function has no effect if the serial port associated with the class
+                        is not currently open.
+*/
+void Posix_QextSerialPort::close()
+{
+        LOCK_MUTEX();
+        Posix_File->close();
+        QIODevice::close();
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::flush()
+                        Flushes all pending I/O to the serial port.  This function has no effect if the serial port
+                        associated with the class is not currently open.
+*/
+void Posix_QextSerialPort::flush()
+{
+        LOCK_MUTEX();
+        if (isOpen()) {
+                Posix_File->flush();
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn qint64 Posix_QextSerialPort::size() const
+This function will return the number of bytes waiting in the receive queue of the serial port.
+                It is included primarily to provide a complete QIODevice interface, and will not record errors
+                in the lastErr member (because it is const).  This function is also not thread-safe - in
+                multithreading situations, use Posix_QextSerialPort::bytesWaiting() instead.
+*/
+qint64 Posix_QextSerialPort::size() const
+{
+        int numBytes;
+        if (ioctl(Posix_File->handle(), FIONREAD, &numBytes)<0) {
+                numBytes=0;
+        }
+        return (qint64)numBytes;
+}
+/*!
+                \fn qint64 Posix_QextSerialPort::bytesAvailable()
+                        Returns the number of bytes waiting in the port's receive queue.  This function will return 0 if
+                        the port is not currently open, or -1 on error.  Error information can be retrieved by calling
+                        Posix_QextSerialPort::getLastError().
+*/
+qint64 Posix_QextSerialPort::bytesAvailable()
+{
+        LOCK_MUTEX();
+        if (isOpen()) {
+                int bytesQueued;
+                fd_set fileSet;
+                FD_ZERO(&fileSet);
+                FD_SET(Posix_File->handle(), &fileSet);
+                /*on Linux systems the Posix_Timeout structure will be altered by the select() call.
+                                Make sure we use the right timeout values*/
+                //memcpy(&Posix_Timeout, &Posix_Copy_Timeout, sizeof(struct timeval));
+                Posix_Timeout = Posix_Copy_Timeout;
+                int n=select(Posix_File->handle()+1, &fileSet, NULL, &fileSet, &Posix_Timeout);
+                if (!n) {
+                        lastErr=E_PORT_TIMEOUT;
+                        UNLOCK_MUTEX();
+                        return -1;
+                }
+                if (n==-1 || ioctl(Posix_File->handle(), FIONREAD, &bytesQueued)==-1) {
+                        translateError(errno);
+                        UNLOCK_MUTEX();
+                        return -1;
+                }
+                lastErr=E_NO_ERROR;
+                UNLOCK_MUTEX();
+                return bytesQueued + QIODevice::bytesAvailable();
+        }
+        UNLOCK_MUTEX();
+        return 0;
+}
+/*!
+                \fn void Posix_QextSerialPort::ungetChar(char)
+                        This function is included to implement the full QIODevice interface, and currently has no
+                        purpose within this class.  This function is meaningless on an unbuffered device and currently
+                        only prints a warning message to that effect.
+*/
+void Posix_QextSerialPort::ungetChar(char)
+{
+        /*meaningless on unbuffered sequential device - return error and print a warning*/
+        TTY_WARNING("Posix_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless");
+}
+/*!
+                \fn void Posix_QextSerialPort::translateError(ulong error)
+                        Translates a system-specific error code to a QextSerialPort error code.  Used internally.
+*/
+void Posix_QextSerialPort::translateError(ulong error)
+{
+        switch (error) {
+                case EBADF:
+                case ENOTTY:
+                        lastErr=E_INVALID_FD;
+                        break;
+                case EINTR:
+                        lastErr=E_CAUGHT_NON_BLOCKED_SIGNAL;
+                        break;
+                case ENOMEM:
+                        lastErr=E_NO_MEMORY;
+                        break;
+                }
+}
+/*!
+                \fn void Posix_QextSerialPort::setDtr(bool set)
+                        Sets DTR line to the requested state (high by default).  This function will have no effect if
+                        the port associated with the class is not currently open.
+*/
+void Posix_QextSerialPort::setDtr(bool set)
+{
+        LOCK_MUTEX();
+        if (isOpen()) {
+                int status;
+                ioctl(Posix_File->handle(), TIOCMGET, &status);
+                if (set) {
+                        status|=TIOCM_DTR;
+                }
+                else {
+                        status&=~TIOCM_DTR;
+                }
+                ioctl(Posix_File->handle(), TIOCMSET, &status);
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Posix_QextSerialPort::setRts(bool set)
+                        Sets RTS line to the requested state (high by default).  This function will have no effect if
+                        the port associated with the class is not currently open.
+*/
+void Posix_QextSerialPort::setRts(bool set)
+{
+        LOCK_MUTEX();
+        if (isOpen()) {
+                int status;
+                ioctl(Posix_File->handle(), TIOCMGET, &status);
+                if (set) {
+                        status|=TIOCM_RTS;
+                }
+                else {
+                        status&=~TIOCM_RTS;
+                }
+                ioctl(Posix_File->handle(), TIOCMSET, &status);
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn unsigned long Posix_QextSerialPort::lineStatus()
+                        returns the line status as stored by the port function.  This function will retrieve the states
+                        of the following lines: DCD, CTS, DSR, and RI.  On POSIX systems, the following additional lines
+                        can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD.  The value returned is an unsigned
+                        long with specific bits indicating which lines are high.  The following constants should be used
+                        to examine the states of individual lines:
+\verbatim
+                Mask        Line
+                ------      ----
+                LS_CTS      CTS
+                LS_DSR      DSR
+                LS_DCD      DCD
+                LS_RI       RI
+                LS_RTS      RTS (POSIX only)
+                        LS_DTR      DTR (POSIX only)
+                                LS_ST       Secondary TXD (POSIX only)
+                                        LS_SR       Secondary RXD (POSIX only)
+                                                \endverbatim
+This function will return 0 if the port associated with the class is not currently open.
+*/
+unsigned long Posix_QextSerialPort::lineStatus()
+{
+        unsigned long Status=0, Temp=0;
+        LOCK_MUTEX();
+        if (isOpen()) {
+                ioctl(Posix_File->handle(), TIOCMGET, &Temp);
+                if (Temp&TIOCM_CTS) {
+                        Status|=LS_CTS;
+                }
+                if (Temp&TIOCM_DSR) {
+                        Status|=LS_DSR;
+                }
+                if (Temp&TIOCM_RI) {
+                        Status|=LS_RI;
+                }
+                if (Temp&TIOCM_CD) {
+                        Status|=LS_DCD;
+                }
+                if (Temp&TIOCM_DTR) {
+                        Status|=LS_DTR;
+                }
+                if (Temp&TIOCM_RTS) {
+                        Status|=LS_RTS;
+                }
+                if (Temp&TIOCM_ST) {
+                        Status|=LS_ST;
+                }
+                if (Temp&TIOCM_SR) {
+                        Status|=LS_SR;
+                }
+        }
+        UNLOCK_MUTEX();
+        return Status;
+}
+/*!
+                \fn qint64 Posix_QextSerialPort::readData(char * data, qint64 maxSize)
+                        Reads a block of data from the serial port.  This function will read at most maxSize bytes from
+                        the serial port and place them in the buffer pointed to by data.  Return value is the number of
+                        bytes actually read, or -1 on error.
+\warning before calling this function ensure that serial port associated with this class
+                is currently open (use isOpen() function to check if port is open).
+*/
+qint64 Posix_QextSerialPort::readData(char * data, qint64 maxSize)
+{
+        LOCK_MUTEX();
+        int retVal=0;
+        retVal=Posix_File->read(data, maxSize);
+        if (retVal==-1)
+                lastErr=E_READ_FAILED;
+        UNLOCK_MUTEX();
+        return retVal;
+}
+/*!
+                \fn qint64 Posix_QextSerialPort::writeData(const char * data, qint64 maxSize)
+                        Writes a block of data to the serial port.  This function will write maxSize bytes
+                        from the buffer pointed to by data to the serial port.  Return value is the number
+                        of bytes actually written, or -1 on error.
+\warning before calling this function ensure that serial port associated with this class
+                is currently open (use isOpen() function to check if port is open).
+*/
+qint64 Posix_QextSerialPort::writeData(const char * data, qint64 maxSize)
+{
+        LOCK_MUTEX();
+        int retVal=0;
+        retVal=Posix_File->write(data, maxSize);
+        if (retVal==-1)
+                lastErr=E_WRITE_FAILED;
+        UNLOCK_MUTEX();
+        flush();
+        return retVal;
+}

 /QMK-Groundstation/tags/V1.0.1/SerialPort/posix_qextserialport.h
 ,0 → 1,56
+#ifndef _POSIX_QEXTSERIALPORT_H_
+#define _POSIX_QEXTSERIALPORT_H_
+#include <stdio.h>
+#include <termios.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include "qextserialbase.h"
+class Posix_QextSerialPort:public QextSerialBase {
+public:
+        Posix_QextSerialPort();
+        Posix_QextSerialPort(const Posix_QextSerialPort& s);
+        Posix_QextSerialPort(const QString & name);
+        Posix_QextSerialPort(const PortSettings& settings);
+        Posix_QextSerialPort(const QString & name, const PortSettings& settings);
+        Posix_QextSerialPort& operator=(const Posix_QextSerialPort& s);
+        virtual ~Posix_QextSerialPort();
+        virtual void setBaudRate(BaudRateType);
+        virtual void setDataBits(DataBitsType);
+        virtual void setParity(ParityType);
+        virtual void setStopBits(StopBitsType);
+        virtual void setFlowControl(FlowType);
+        virtual void setTimeout(ulong, ulong);
+        virtual bool open(OpenMode mode=0);
+        virtual void close();
+        virtual void flush();
+        virtual qint64 size() const;
+        virtual qint64 bytesAvailable();
+        virtual void ungetChar(char c);
+        virtual void translateError(ulong error);
+        virtual void setDtr(bool set=true);
+        virtual void setRts(bool set=true);
+        virtual ulong lineStatus();
+protected:
+        QFile* Posix_File;
+        struct termios Posix_CommConfig;
+        struct timeval Posix_Timeout;
+        struct timeval Posix_Copy_Timeout;
+        virtual qint64 readData(char * data, qint64 maxSize);
+        virtual qint64 writeData(const char * data, qint64 maxSize);
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/SerialPort/qextserialbase.cpp
 ,0 → 1,250
+#include "qextserialbase.h"
+/*!
+\class QextSerialBase
+\version 1.0.0
+\author Stefan Sander
+A common base class for Win_QextSerialBase, Posix_QextSerialBase and QextSerialPort.
+*/
+#ifdef QT_THREAD_SUPPORT
+QMutex* QextSerialBase::mutex=NULL;
+unsigned long QextSerialBase::refCount=0;
+#endif
+/*!
+\fn QextSerialBase::QextSerialBase()
+Default constructor.
+*/
+QextSerialBase::QextSerialBase()
+ : QIODevice()
+{
+#ifdef _TTY_WIN_
+    setPortName("COM1");
+#elif defined(_TTY_IRIX_)
+    setPortName("/dev/ttyf1");
+#elif defined(_TTY_HPUX_)
+    setPortName("/dev/tty1p0");
+#elif defined(_TTY_SUN_)
+    setPortName("/dev/ttya");
+#elif defined(_TTY_DIGITAL_)
+    setPortName("/dev/tty01");
+#elif defined(_TTY_FREEBSD_)
+    setPortName("/dev/ttyd1");
+#else
+    setPortName("/dev/ttyS0");
+#endif
+    construct();
+}
+/*!
+\fn QextSerialBase::QextSerialBase(const QString & name)
+Construct a port and assign it to the device specified by the name parameter.
+*/
+QextSerialBase::QextSerialBase(const QString & name)
+ : QIODevice()
+{
+    setPortName(name);
+    construct();
+}
+/*!
+\fn QextSerialBase::~QextSerialBase()
+Standard destructor.
+*/
+QextSerialBase::~QextSerialBase()
+{
+#ifdef QT_THREAD_SUPPORT
+    refCount--;
+    if (mutex && refCount==0) {
+        delete mutex;
+        mutex=NULL;
+    }
+#endif
+}
+/*!
+\fn void QextSerialBase::construct()
+Common constructor function for setting up default port settings.
+(9600 Baud, 8N1, no flow control where supported, otherwise no flow control, and 20 ms timeout).
+*/
+void QextSerialBase::construct()
+{
+    Settings.BaudRate=BAUD9600;
+    Settings.DataBits=DATA_8;
+    Settings.Parity=PAR_NONE;
+    Settings.StopBits=STOP_1;
+    Settings.FlowControl=FLOW_OFF;
+    Settings.Timeout_Sec=0;
+    Settings.Timeout_Millisec=20;
+#ifdef QT_THREAD_SUPPORT
+    if (!mutex) {
+        mutex=new QMutex( QMutex::Recursive );
+    }
+    refCount++;
+#endif
+        setOpenMode(QIODevice::NotOpen);
+}
+/*!
+\fn void QextSerialBase::setPortName(const QString & name)
+Sets the name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0".
+*/
+void QextSerialBase::setPortName(const QString & name)
+{
+    port = name;
+}
+/*!
+\fn QString QextSerialBase::portName() const
+Returns the name set by setPortName().
+*/
+QString QextSerialBase::portName() const
+{
+    return port;
+}
+/*!
+\fn BaudRateType QextSerialBase::baudRate(void) const
+Returns the baud rate of the serial port.  For a list of possible return values see
+the definition of the enum BaudRateType.
+*/
+BaudRateType QextSerialBase::baudRate(void) const
+{
+    return Settings.BaudRate;
+}
+/*!
+\fn DataBitsType QextSerialBase::dataBits() const
+Returns the number of data bits used by the port.  For a list of possible values returned by
+this function, see the definition of the enum DataBitsType.
+*/
+DataBitsType QextSerialBase::dataBits() const
+{
+    return Settings.DataBits;
+}
+/*!
+\fn ParityType QextSerialBase::parity() const
+Returns the type of parity used by the port.  For a list of possible values returned by
+this function, see the definition of the enum ParityType.
+*/
+ParityType QextSerialBase::parity() const
+{
+    return Settings.Parity;
+}
+/*!
+\fn StopBitsType QextSerialBase::stopBits() const
+Returns the number of stop bits used by the port.  For a list of possible return values, see
+the definition of the enum StopBitsType.
+*/
+StopBitsType QextSerialBase::stopBits() const
+{
+    return Settings.StopBits;
+}
+/*!
+\fn FlowType QextSerialBase::flowControl() const
+Returns the type of flow control used by the port.  For a list of possible values returned
+by this function, see the definition of the enum FlowType.
+*/
+FlowType QextSerialBase::flowControl() const
+{
+    return Settings.FlowControl;
+}
+/*!
+\fn bool QextSerialBase::isSequential() const
+Returns true if device is sequential, otherwise returns false. Serial port is sequential device
+so this function always returns true. Check QIODevice::isSequential() documentation for more
+information.
+*/
+bool QextSerialBase::isSequential() const
+{
+        return true;
+}
+/*!
+\fn bool QextSerialBase::atEnd() const
+This function will return true if the input buffer is empty (or on error), and false otherwise.
+Call QextSerialBase::lastError() for error information.
+*/
+bool QextSerialBase::atEnd() const
+{
+    if (size()) {
+        return true;
+    }
+    return false;
+}
+/*!
+\fn qint64 QextSerialBase::readLine(char * data, qint64 maxSize)
+This function will read a line of buffered input from the port, stopping when either maxSize bytes
+have been read, the port has no more data available, or a newline is encountered.
+The value returned is the length of the string that was read.
+*/
+qint64 QextSerialBase::readLine(char * data, qint64 maxSize)
+{
+    qint64 numBytes = bytesAvailable();
+    char* pData = data;
+        if (maxSize < 2)        //maxSize must be larger than 1
+                return -1;
+    /*read a byte at a time for MIN(bytesAvail, maxSize - 1) iterations, or until a newline*/
+    while (pData<(data+numBytes) && --maxSize) {
+        readData(pData, 1);
+        if (*pData++ == '\n') {
+            break;
+        }
+    }
+    *pData='\0';
+    /*return size of data read*/
+    return (pData-data);
+}
+/*!
+\fn ulong QextSerialBase::lastError() const
+Returns the code for the last error encountered by the port, or E_NO_ERROR if the last port
+operation was successful.  Possible error codes are:
+\verbatim
+Error                           Explanation
+---------------------------     -------------------------------------------------------------
+E_NO_ERROR                      No Error has occured
+E_INVALID_FD                    Invalid file descriptor (port was not opened correctly)
+E_NO_MEMORY                     Unable to allocate memory tables (POSIX)
+E_CAUGHT_NON_BLOCKED_SIGNAL     Caught a non-blocked signal (POSIX)
+E_PORT_TIMEOUT                  Operation timed out (POSIX)
+E_INVALID_DEVICE                The file opened by the port is not a character device (POSIX)
+E_BREAK_CONDITION               The port detected a break condition
+E_FRAMING_ERROR                 The port detected a framing error
+                                (usually caused by incorrect baud rate settings)
+E_IO_ERROR                      There was an I/O error while communicating with the port
+E_BUFFER_OVERRUN                Character buffer overrun
+E_RECEIVE_OVERFLOW              Receive buffer overflow
+E_RECEIVE_PARITY_ERROR          The port detected a parity error in the received data
+E_TRANSMIT_OVERFLOW             Transmit buffer overflow
+E_READ_FAILED                   General read operation failure
+E_WRITE_FAILED                  General write operation failure
+\endverbatim
+*/
+ulong QextSerialBase::lastError() const
+{
+    return lastErr;
+}

 /QMK-Groundstation/tags/V1.0.1/SerialPort/qextserialbase.h
 ,0 → 1,196
+#ifndef _QEXTSERIALBASE_H_
+#define _QEXTSERIALBASE_H_
+#include <QIODevice>
+#include <QFile>
+#ifdef QT_THREAD_SUPPORT
+#include <QThread>
+#include <QMutex>
+#endif
+/*if all warning messages are turned off, flag portability warnings to be turned off as well*/
+#ifdef _TTY_NOWARN_
+#define _TTY_NOWARN_PORT_
+#endif
+/*macros for thread support*/
+#ifdef QT_THREAD_SUPPORT
+#define LOCK_MUTEX() mutex->lock()
+#define UNLOCK_MUTEX() mutex->unlock()
+#else
+#define LOCK_MUTEX()
+#define UNLOCK_MUTEX()
+#endif
+/*macros for warning messages*/
+#ifdef _TTY_NOWARN_PORT_
+#define TTY_PORTABILITY_WARNING(s)
+#else
+#define TTY_PORTABILITY_WARNING(s) qWarning(s)
+#endif
+#ifdef _TTY_NOWARN_
+#define TTY_WARNING(s)
+#else
+#define TTY_WARNING(s) qWarning(s)
+#endif
+/*line status constants*/
+#define LS_CTS  0x01
+#define LS_DSR  0x02
+#define LS_DCD  0x04
+#define LS_RI   0x08
+#define LS_RTS  0x10
+#define LS_DTR  0x20
+#define LS_ST   0x40
+#define LS_SR   0x80
+/*error constants*/
+#define E_NO_ERROR                   0
+#define E_INVALID_FD                 1
+#define E_NO_MEMORY                  2
+#define E_CAUGHT_NON_BLOCKED_SIGNAL  3
+#define E_PORT_TIMEOUT               4
+#define E_INVALID_DEVICE             5
+#define E_BREAK_CONDITION            6
+#define E_FRAMING_ERROR              7
+#define E_IO_ERROR                   8
+#define E_BUFFER_OVERRUN             9
+#define E_RECEIVE_OVERFLOW          10
+#define E_RECEIVE_PARITY_ERROR      11
+#define E_TRANSMIT_OVERFLOW         12
+#define E_READ_FAILED               13
+#define E_WRITE_FAILED              14
+/*enums for port settings*/
+enum NamingConvention {
+    WIN_NAMES,
+    IRIX_NAMES,
+    HPUX_NAMES,
+    SUN_NAMES,
+    DIGITAL_NAMES,
+    FREEBSD_NAMES,
+    LINUX_NAMES
+};
+enum BaudRateType {
+    BAUD50,                //POSIX ONLY
+    BAUD75,                //POSIX ONLY
+    BAUD110,
+    BAUD134,               //POSIX ONLY
+    BAUD150,               //POSIX ONLY
+    BAUD200,               //POSIX ONLY
+    BAUD300,
+    BAUD600,
+    BAUD1200,
+    BAUD1800,              //POSIX ONLY
+    BAUD2400,
+    BAUD4800,
+    BAUD9600,
+    BAUD14400,             //WINDOWS ONLY
+    BAUD19200,
+    BAUD38400,
+    BAUD56000,             //WINDOWS ONLY
+    BAUD57600,
+    BAUD76800,             //POSIX ONLY
+    BAUD115200,
+    BAUD128000,            //WINDOWS ONLY
+    BAUD256000             //WINDOWS ONLY
+};
+enum DataBitsType {
+    DATA_5,
+    DATA_6,
+    DATA_7,
+    DATA_8
+};
+enum ParityType {
+    PAR_NONE,
+    PAR_ODD,
+    PAR_EVEN,
+    PAR_MARK,               //WINDOWS ONLY
+    PAR_SPACE
+};
+enum StopBitsType {
+    STOP_1,
+    STOP_1_5,               //WINDOWS ONLY
+    STOP_2
+};
+enum FlowType {
+    FLOW_OFF,
+    FLOW_HARDWARE,
+    FLOW_XONXOFF
+};
+/*structure to contain port settings*/
+struct PortSettings {
+    BaudRateType BaudRate;
+    DataBitsType DataBits;
+    ParityType Parity;
+    StopBitsType StopBits;
+    FlowType FlowControl;
+    ulong Timeout_Sec;
+    ulong Timeout_Millisec;
+};
+class QextSerialBase : public QIODevice {
+public:
+    QextSerialBase();
+    QextSerialBase(const QString & name);
+    virtual ~QextSerialBase();
+    virtual void construct();
+    virtual void setPortName(const QString & name);
+    virtual QString portName() const;
+    virtual void setBaudRate(BaudRateType)=0;
+    virtual BaudRateType baudRate() const;
+    virtual void setDataBits(DataBitsType)=0;
+    virtual DataBitsType dataBits() const;
+    virtual void setParity(ParityType)=0;
+    virtual ParityType parity() const;
+    virtual void setStopBits(StopBitsType)=0;
+    virtual StopBitsType stopBits() const;
+    virtual void setFlowControl(FlowType)=0;
+    virtual FlowType flowControl() const;
+    virtual void setTimeout(ulong, ulong)=0;
+    virtual bool open(OpenMode mode=0)=0;
+    virtual bool isSequential() const;
+    virtual void close()=0;
+    virtual void flush()=0;
+    virtual qint64 size() const=0;
+    virtual qint64 bytesAvailable()=0;
+    virtual bool atEnd() const;
+    virtual void ungetChar(char c)=0;
+    virtual qint64 readLine(char * data, qint64 maxSize);
+    virtual ulong lastError() const;
+    virtual void translateError(ulong error)=0;
+    virtual void setDtr(bool set=true)=0;
+    virtual void setRts(bool set=true)=0;
+    virtual ulong lineStatus()=0;
+protected:
+    QString port;
+    PortSettings Settings;
+    ulong lastErr;
+#ifdef QT_THREAD_SUPPORT
+    static QMutex* mutex;
+    static ulong refCount;
+#endif
+    virtual qint64 readData(char * data, qint64 maxSize)=0;
+    virtual qint64 writeData(const char * data, qint64 maxSize)=0;
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/SerialPort/qextserialport.cpp
 ,0 → 1,98
+/*!
+\class QextSerialPort
+\version 1.0.0
+\author Stefan Sander
+A cross-platform serial port class.
+This class encapsulates a serial port on both POSIX and Windows systems.  The user will be
+notified of errors and possible portability conflicts at run-time by default - this behavior can
+be turned off by defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn
+off portability warnings) in the project.
+\note
+On Windows NT/2000/XP this class uses Win32 serial port functions by default.  The user may
+select POSIX behavior under NT, 2000, or XP ONLY by defining _TTY_POSIX_ in the project. I can
+make no guarantees as to the quality of POSIX support under NT/2000 however.
+*/
+#include <stdio.h>
+#include "qextserialport.h"
+/*!
+\fn QextSerialPort::QextSerialPort()
+Default constructor.  Note that the naming convention used by a QextSerialPort constructed with
+this constructor will be determined by #defined constants, or lack thereof - the default behavior
+is the same as _TTY_LINUX_.  Possible naming conventions and their associated constants are:
+\verbatim
+Constant         Used By         Naming Convention
+----------       -------------   ------------------------
+_TTY_WIN_        Windows         COM1, COM2
+_TTY_IRIX_       SGI/IRIX        /dev/ttyf1, /dev/ttyf2
+_TTY_HPUX_       HP-UX           /dev/tty1p0, /dev/tty2p0
+_TTY_SUN_        SunOS/Solaris   /dev/ttya, /dev/ttyb
+_TTY_DIGITAL_    Digital UNIX    /dev/tty01, /dev/tty02
+_TTY_FREEBSD_    FreeBSD         /dev/ttyd0, /dev/ttyd1
+_TTY_LINUX_      Linux           /dev/ttyS0, /dev/ttyS1
+<none>           Linux           /dev/ttyS0, /dev/ttyS1
+\endverbatim
+The object will be associated with the first port in the system, e.g. COM1 on Windows systems.
+See the other constructors if you need to use a port other than the first.
+*/
+QextSerialPort::QextSerialPort()
+ : QextBaseType()
+{}
+/*!
+\fn QextSerialPort::QextSerialPort(const QString & name)
+Constructs a serial port attached to the port specified by name.
+name is the name of the device, which is windowsystem-specific,
+e.g."COM1" or "/dev/ttyS0".
+*/
+QextSerialPort::QextSerialPort(const QString & name)
+ : QextBaseType(name)
+{}
+/*!
+\fn QextSerialPort::QextSerialPort(PortSettings const& settings)
+Constructs a port with default name and settings specified by the settings parameter.
+*/
+QextSerialPort::QextSerialPort(PortSettings const& settings)
+ : QextBaseType(settings)
+{}
+/*!
+\fn QextSerialPort::QextSerialPort(const QString & name, PortSettings const& settings)
+Constructs a port with the name and settings specified.
+*/
+QextSerialPort::QextSerialPort(const QString & name, PortSettings const& settings)
+ : QextBaseType(name, settings)
+{}
+/*!
+\fn QextSerialPort::QextSerialPort(const QextSerialPort& s)
+Copy constructor.
+*/
+QextSerialPort::QextSerialPort(const QextSerialPort& s)
+ : QextBaseType(s)
+{}
+/*!
+\fn QextSerialPort& QextSerialPort::operator=(const QextSerialPort& s)
+Overrides the = operator.
+*/
+QextSerialPort& QextSerialPort::operator=(const QextSerialPort& s)
+{
+    return (QextSerialPort&)QextBaseType::operator=(s);
+}
+/*!
+\fn QextSerialPort::~QextSerialPort()
+Standard destructor.
+*/
+QextSerialPort::~QextSerialPort()
+{}

 /QMK-Groundstation/tags/V1.0.1/SerialPort/qextserialport.h
 ,0 → 1,27
+#ifndef _QEXTSERIALPORT_H_
+#define _QEXTSERIALPORT_H_
+/*POSIX CODE*/
+#ifdef _TTY_POSIX_
+#include "posix_qextserialport.h"
+#define QextBaseType Posix_QextSerialPort
+/*MS WINDOWS CODE*/
+#else
+#include "win_qextserialport.h"
+#define QextBaseType Win_QextSerialPort
+#endif
+class QextSerialPort: public QextBaseType {
+public:
+    QextSerialPort();
+    QextSerialPort(const QString & name);
+    QextSerialPort(PortSettings const& s);
+    QextSerialPort(const QString & name, PortSettings const& s);
+    QextSerialPort(const QextSerialPort& s);
+    QextSerialPort& operator=(const QextSerialPort&);
+    virtual ~QextSerialPort();
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/SerialPort/win_qextserialport.cpp
 ,0 → 1,877
+/*!
+                \class Win_QextSerialPort
+                \version 1.0.0
+                \author Stefan Sander
+A cross-platform serial port class.
+                This class encapsulates the Windows portion of QextSerialPort.  The user will be notified of
+                errors and possible portability conflicts at run-time by default - this behavior can be turned
+                off by defining _TTY_NOWARN_ (to turn off all warnings) or _TTY_NOWARN_PORT_ (to turn off
+                portability warnings) in the project.  Note that defining _TTY_NOWARN_ also defines
+                _TTY_NOWARN_PORT_.
+\note
+                On Windows NT/2000/XP this class uses Win32 serial port functions by default.  The user may
+                select POSIX behavior under NT, 2000, or XP ONLY by defining _TTY_POSIX_ in the project. I can
+                make no guarantees as to the quality of POSIX support under NT/2000 however.
+*/
+#include <stdio.h>
+#include "win_qextserialport.h"
+/*!
+                \fn Win_QextSerialPort::Win_QextSerialPort()
+                        Default constructor.  Note that the name of the device used by a Win_QextSerialPort constructed
+                        with this constructor will be determined by #defined constants, or lack thereof - the default
+                        behavior is the same as _TTY_LINUX_.  Possible naming conventions and their associated constants
+                        are:
+\verbatim
+Constant         Used By         Naming Convention
+                ----------       -------------   ------------------------
+                _TTY_WIN_        Windows         COM1, COM2
+                _TTY_IRIX_       SGI/IRIX        /dev/ttyf1, /dev/ttyf2
+                _TTY_HPUX_       HP-UX           /dev/tty1p0, /dev/tty2p0
+                _TTY_SUN_        SunOS/Solaris   /dev/ttya, /dev/ttyb
+                _TTY_DIGITAL_    Digital UNIX    /dev/tty01, /dev/tty02
+                _TTY_FREEBSD_    FreeBSD         /dev/ttyd0, /dev/ttyd1
+                _TTY_LINUX_      Linux           /dev/ttyS0, /dev/ttyS1
+                <none>           Linux           /dev/ttyS0, /dev/ttyS1
+                \endverbatim
+This constructor associates the object with the first port on the system, e.g. COM1 for Windows
+                platforms.  See the other constructor if you need a port other than the first.
+*/
+Win_QextSerialPort::Win_QextSerialPort():QextSerialBase() {
+        Win_Handle=INVALID_HANDLE_VALUE;
+}
+/*!Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort&)
+        Copy constructor.
+*/
+Win_QextSerialPort::Win_QextSerialPort(const Win_QextSerialPort& s):QextSerialBase(s.port) {
+        Win_Handle=INVALID_HANDLE_VALUE;
+        setOpenMode(s.openMode());
+        lastErr=s.lastErr;
+        port = s.port;
+        Settings.FlowControl=s.Settings.FlowControl;
+        Settings.Parity=s.Settings.Parity;
+        Settings.DataBits=s.Settings.DataBits;
+        Settings.StopBits=s.Settings.StopBits;
+        Settings.BaudRate=s.Settings.BaudRate;
+        Win_Handle=s.Win_Handle;
+        memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
+        memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
+}
+/*!
+                \fn Win_QextSerialPort::Win_QextSerialPort(const QString & name)
+                        Constructs a serial port attached to the port specified by devName.
+                        devName is the name of the device, which is windowsystem-specific,
+                        e.g."COM2" or "/dev/ttyS0".
+*/
+Win_QextSerialPort::Win_QextSerialPort(const QString & name):QextSerialBase(name) {
+        Win_Handle=INVALID_HANDLE_VALUE;
+}
+/*!
+                \fn Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings)
+                        Constructs a port with default name and specified settings.
+*/
+Win_QextSerialPort::Win_QextSerialPort(const PortSettings& settings) {
+        Win_Handle=INVALID_HANDLE_VALUE;
+        setBaudRate(settings.BaudRate);
+        setDataBits(settings.DataBits);
+        setStopBits(settings.StopBits);
+        setParity(settings.Parity);
+        setFlowControl(settings.FlowControl);
+        setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
+}
+/*!
+                \fn Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings)
+                        Constructs a port with specified name and settings.
+*/
+Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings) {
+        Win_Handle=INVALID_HANDLE_VALUE;
+        setPortName(name);
+        setBaudRate(settings.BaudRate);
+        setDataBits(settings.DataBits);
+        setStopBits(settings.StopBits);
+        setParity(settings.Parity);
+        setFlowControl(settings.FlowControl);
+        setTimeout(settings.Timeout_Sec, settings.Timeout_Millisec);
+}
+/*!
+                \fn Win_QextSerialPort::~Win_QextSerialPort()
+                        Standard destructor.
+*/
+Win_QextSerialPort::~Win_QextSerialPort() {
+        if (isOpen()) {
+                close();
+        }
+}
+/*!
+                \fn Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s)
+                        overrides the = operator
+*/
+Win_QextSerialPort& Win_QextSerialPort::operator=(const Win_QextSerialPort& s) {
+        setOpenMode(s.openMode());
+        lastErr=s.lastErr;
+        port = s.port;
+        Settings.FlowControl=s.Settings.FlowControl;
+        Settings.Parity=s.Settings.Parity;
+        Settings.DataBits=s.Settings.DataBits;
+        Settings.StopBits=s.Settings.StopBits;
+        Settings.BaudRate=s.Settings.BaudRate;
+        Win_Handle=s.Win_Handle;
+        memcpy(&Win_CommConfig, &s.Win_CommConfig, sizeof(COMMCONFIG));
+        memcpy(&Win_CommTimeouts, &s.Win_CommTimeouts, sizeof(COMMTIMEOUTS));
+        return *this;
+}
+/*!
+                \fn bool Win_QextSerialPort::open(OpenMode mode)
+                        Opens a serial port.  Note that this function does not specify which device to open.  If you need
+                        to open a device by name, see Win_QextSerialPort::open(const char*).  This function has no effect
+                        if the port associated with the class is already open.  The port is also configured to the current
+                        settings, as stored in the Settings structure.
+*/
+bool Win_QextSerialPort::open(OpenMode mode) {
+        unsigned long confSize = sizeof(COMMCONFIG);
+        Win_CommConfig.dwSize = confSize;
+        LOCK_MUTEX();
+        if (mode == QIODevice::NotOpen)
+                return isOpen();
+        if (!isOpen()) {
+                /*open the port*/
+                Win_Handle=CreateFileA(port.toAscii(), GENERIC_READ|GENERIC_WRITE,
+                                FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
+                if (Win_Handle!=INVALID_HANDLE_VALUE) {
+                        /*set open mode*/
+                        QIODevice::open(mode);
+                        /*configure port settings*/
+                        GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
+                        GetCommState(Win_Handle, &(Win_CommConfig.dcb));
+                        /*set up parameters*/
+                        Win_CommConfig.dcb.fBinary=TRUE;
+                        Win_CommConfig.dcb.fInX=FALSE;
+                        Win_CommConfig.dcb.fOutX=FALSE;
+                        Win_CommConfig.dcb.fAbortOnError=FALSE;
+                        Win_CommConfig.dcb.fNull=FALSE;
+                        setBaudRate(Settings.BaudRate);
+                        setDataBits(Settings.DataBits);
+                        setStopBits(Settings.StopBits);
+                        setParity(Settings.Parity);
+                        setFlowControl(Settings.FlowControl);
+                        setTimeout(Settings.Timeout_Sec, Settings.Timeout_Millisec);
+                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                }
+        }
+        UNLOCK_MUTEX();
+        return isOpen();
+}
+/*!
+                \fn void Win_QextSerialPort::close()
+                        Closes a serial port.  This function has no effect if the serial port associated with the class
+                        is not currently open.
+*/
+void Win_QextSerialPort::close() {
+        LOCK_MUTEX();
+        CloseHandle(Win_Handle);
+        QIODevice::close();
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::flush()
+                        Flushes all pending I/O to the serial port.  This function has no effect if the serial port
+                        associated with the class is not currently open.
+*/
+void Win_QextSerialPort::flush() {
+        LOCK_MUTEX();
+        if (isOpen()) {
+                FlushFileBuffers(Win_Handle);
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn qint64 Win_QextSerialPort::size() const
+This function will return the number of bytes waiting in the receive queue of the serial port.
+                It is included primarily to provide a complete QIODevice interface, and will not record errors
+                in the lastErr member (because it is const).  This function is also not thread-safe - in
+                multithreading situations, use Win_QextSerialPort::bytesAvailable() instead.
+*/
+qint64 Win_QextSerialPort::size() const {
+        int availBytes;
+        COMSTAT Win_ComStat;
+        DWORD Win_ErrorMask=0;
+        ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
+        availBytes = Win_ComStat.cbInQue;
+        return (qint64)availBytes;
+}
+/*!
+                \fn qint64 Win_QextSerialPort::bytesAvailable()
+                        Returns the number of bytes waiting in the port's receive queue.  This function will return 0 if
+                        the port is not currently open, or -1 on error.  Error information can be retrieved by calling
+                        Win_QextSerialPort::getLastError().
+*/
+qint64 Win_QextSerialPort::bytesAvailable() {
+        LOCK_MUTEX();
+        if (isOpen()) {
+                DWORD Errors;
+                COMSTAT Status;
+                bool success=ClearCommError(Win_Handle, &Errors, &Status);
+                translateError(Errors);
+                if (success) {
+                        lastErr=E_NO_ERROR;
+                        UNLOCK_MUTEX();
+                        return Status.cbInQue + QIODevice::bytesAvailable();
+                }
+                UNLOCK_MUTEX();
+                return (unsigned int)-1;
+        }
+        UNLOCK_MUTEX();
+        return 0;
+}
+/*!
+                \fn void Win_QextSerialPort::translateError(ulong error)
+                        Translates a system-specific error code to a QextSerialPort error code.  Used internally.
+*/
+void Win_QextSerialPort::translateError(ulong error) {
+        if (error&CE_BREAK) {
+                lastErr=E_BREAK_CONDITION;
+        }
+        else if (error&CE_FRAME) {
+                lastErr=E_FRAMING_ERROR;
+        }
+        else if (error&CE_IOE) {
+                lastErr=E_IO_ERROR;
+        }
+        else if (error&CE_MODE) {
+                lastErr=E_INVALID_FD;
+        }
+        else if (error&CE_OVERRUN) {
+                lastErr=E_BUFFER_OVERRUN;
+        }
+        else if (error&CE_RXPARITY) {
+                lastErr=E_RECEIVE_PARITY_ERROR;
+        }
+        else if (error&CE_RXOVER) {
+                lastErr=E_RECEIVE_OVERFLOW;
+        }
+        else if (error&CE_TXFULL) {
+                lastErr=E_TRANSMIT_OVERFLOW;
+        }
+}
+/*!
+                \fn qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize)
+                        Reads a block of data from the serial port.  This function will read at most maxlen bytes from
+                        the serial port and place them in the buffer pointed to by data.  Return value is the number of
+                        bytes actually read, or -1 on error.
+\warning before calling this function ensure that serial port associated with this class
+                is currently open (use isOpen() function to check if port is open).
+*/
+qint64 Win_QextSerialPort::readData(char *data, qint64 maxSize)
+{
+        LOCK_MUTEX();
+        int retVal=0;
+        COMSTAT Win_ComStat;
+        DWORD Win_BytesRead=0;
+        DWORD Win_ErrorMask=0;
+        ClearCommError(Win_Handle, &Win_ErrorMask, &Win_ComStat);
+        if (Win_ComStat.cbInQue &&
+                        (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesRead, NULL)
+                        || Win_BytesRead==0)) {
+                                lastErr=E_READ_FAILED;
+                retVal=-1;
+        }
+        else {
+                retVal=((int)Win_BytesRead);
+        }
+        UNLOCK_MUTEX();
+        return retVal;
+}
+/*!
+                \fn qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize)
+                        Writes a block of data to the serial port.  This function will write len bytes
+                        from the buffer pointed to by data to the serial port.  Return value is the number
+                        of bytes actually written, or -1 on error.
+\warning before calling this function ensure that serial port associated with this class
+                is currently open (use isOpen() function to check if port is open).
+*/
+qint64 Win_QextSerialPort::writeData(const char *data, qint64 maxSize)
+{
+        LOCK_MUTEX();
+        int retVal=0;
+        DWORD Win_BytesWritten;
+        if (!WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, &Win_BytesWritten, NULL)) {
+                lastErr=E_WRITE_FAILED;
+                retVal=-1;
+        }
+        else {
+                retVal=((int)Win_BytesWritten);
+        }
+        UNLOCK_MUTEX();
+        flush();
+        return retVal;
+}
+/*!
+                \fn void Win_QextSerialPort::ungetChar(char c)
+                        This function is included to implement the full QIODevice interface, and currently has no
+                        purpose within this class.  This function is meaningless on an unbuffered device and currently
+                        only prints a warning message to that effect.
+*/
+void Win_QextSerialPort::ungetChar(char c) {
+        /*meaningless on unbuffered sequential device - return error and print a warning*/
+        TTY_WARNING("Win_QextSerialPort: ungetChar() called on an unbuffered sequential device - operation is meaningless");
+}
+/*!
+                \fn void Win_QextSerialPort::setFlowControl(FlowType flow)
+                        Sets the flow control used by the port.  Possible values of flow are:
+\verbatim
+                FLOW_OFF            No flow control
+                FLOW_HARDWARE       Hardware (RTS/CTS) flow control
+                FLOW_XONXOFF        Software (XON/XOFF) flow control
+                \endverbatim
+*/
+void Win_QextSerialPort::setFlowControl(FlowType flow) {
+        LOCK_MUTEX();
+        if (Settings.FlowControl!=flow) {
+                Settings.FlowControl=flow;
+        }
+        if (isOpen()) {
+                switch(flow) {
+                                /*no flow control*/
+                        case FLOW_OFF:
+                                Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
+                                Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
+                                Win_CommConfig.dcb.fInX=FALSE;
+                                Win_CommConfig.dcb.fOutX=FALSE;
+                                SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                break;
+                                /*software (XON/XOFF) flow control*/
+                        case FLOW_XONXOFF:
+                                Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
+                                Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
+                                Win_CommConfig.dcb.fInX=TRUE;
+                                Win_CommConfig.dcb.fOutX=TRUE;
+                                SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                break;
+                        case FLOW_HARDWARE:
+                                Win_CommConfig.dcb.fOutxCtsFlow=TRUE;
+                                Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
+                                Win_CommConfig.dcb.fInX=FALSE;
+                                Win_CommConfig.dcb.fOutX=FALSE;
+                                SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                break;
+                }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::setParity(ParityType parity)
+                        Sets the parity associated with the serial port.  The possible values of parity are:
+\verbatim
+                PAR_SPACE       Space Parity
+                PAR_MARK        Mark Parity
+                PAR_NONE        No Parity
+                PAR_EVEN        Even Parity
+                PAR_ODD         Odd Parity
+                \endverbatim
+*/
+void Win_QextSerialPort::setParity(ParityType parity) {
+        LOCK_MUTEX();
+        if (Settings.Parity!=parity) {
+                Settings.Parity=parity;
+        }
+        if (isOpen()) {
+                Win_CommConfig.dcb.Parity=(unsigned char)parity;
+                switch (parity) {
+                                /*space parity*/
+                        case PAR_SPACE:
+                                if (Settings.DataBits==DATA_8) {
+                                        TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: Space parity with 8 data bits is not supported by POSIX systems.");
+                                }
+                                Win_CommConfig.dcb.fParity=TRUE;
+                                break;
+                                /*mark parity - WINDOWS ONLY*/
+                        case PAR_MARK:
+                                TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning:  Mark parity is not supported by POSIX systems");
+                                Win_CommConfig.dcb.fParity=TRUE;
+                                break;
+                                /*no parity*/
+                        case PAR_NONE:
+                                Win_CommConfig.dcb.fParity=FALSE;
+                                break;
+                                /*even parity*/
+                        case PAR_EVEN:
+                                Win_CommConfig.dcb.fParity=TRUE;
+                                break;
+                                /*odd parity*/
+                        case PAR_ODD:
+                                Win_CommConfig.dcb.fParity=TRUE;
+                                break;
+                        }
+                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::setDataBits(DataBitsType dataBits)
+                        Sets the number of data bits used by the serial port.  Possible values of dataBits are:
+\verbatim
+                DATA_5      5 data bits
+                DATA_6      6 data bits
+                DATA_7      7 data bits
+                DATA_8      8 data bits
+                \endverbatim
+\note
+                This function is subject to the following restrictions:
+\par
+data bits cannot be used with 2 stop bits.
+                \par
+.5 stop bits can only be used with 5 data bits.
+                \par
+data bits cannot be used with space parity on POSIX systems.
+*/
+void Win_QextSerialPort::setDataBits(DataBitsType dataBits) {
+        LOCK_MUTEX();
+        if (Settings.DataBits!=dataBits) {
+                if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) ||
+                                (Settings.StopBits==STOP_1_5 && dataBits!=DATA_5)) {
+                                }
+                else {
+                        Settings.DataBits=dataBits;
+                }
+        }
+        if (isOpen()) {
+                switch(dataBits) {
+                                /*5 data bits*/
+                        case DATA_5:
+                                if (Settings.StopBits==STOP_2) {
+                                        TTY_WARNING("Win_QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
+                                }
+                                else {
+                                        Win_CommConfig.dcb.ByteSize=5;
+                                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                }
+                                break;
+                                /*6 data bits*/
+                        case DATA_6:
+                                if (Settings.StopBits==STOP_1_5) {
+                                        TTY_WARNING("Win_QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
+                                }
+                                else {
+                                        Win_CommConfig.dcb.ByteSize=6;
+                                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                }
+                                break;
+                                /*7 data bits*/
+                        case DATA_7:
+                                if (Settings.StopBits==STOP_1_5) {
+                                        TTY_WARNING("Win_QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
+                                }
+                                else {
+                                        Win_CommConfig.dcb.ByteSize=7;
+                                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                }
+                                break;
+                                /*8 data bits*/
+                        case DATA_8:
+                                if (Settings.StopBits==STOP_1_5) {
+                                        TTY_WARNING("Win_QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
+                                }
+                                else {
+                                        Win_CommConfig.dcb.ByteSize=8;
+                                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                }
+                                break;
+                        }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::setStopBits(StopBitsType stopBits)
+                        Sets the number of stop bits used by the serial port.  Possible values of stopBits are:
+\verbatim
+                STOP_1      1 stop bit
+                STOP_1_5    1.5 stop bits
+                STOP_2      2 stop bits
+                \endverbatim
+\note
+                This function is subject to the following restrictions:
+\par
+stop bits cannot be used with 5 data bits.
+                \par
+.5 stop bits cannot be used with 6 or more data bits.
+                \par
+                POSIX does not support 1.5 stop bits.
+*/
+void Win_QextSerialPort::setStopBits(StopBitsType stopBits) {
+        LOCK_MUTEX();
+        if (Settings.StopBits!=stopBits) {
+                if ((Settings.DataBits==DATA_5 && stopBits==STOP_2) ||
+                                (stopBits==STOP_1_5 && Settings.DataBits!=DATA_5)) {
+                                }
+                else {
+                        Settings.StopBits=stopBits;
+                }
+        }
+        if (isOpen()) {
+                switch (stopBits) {
+                                /*one stop bit*/
+                        case STOP_1:
+                                Win_CommConfig.dcb.StopBits=ONESTOPBIT;
+                                SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                break;
+                                /*1.5 stop bits*/
+                        case STOP_1_5:
+                                TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: 1.5 stop bit operation is not supported by POSIX.");
+                                if (Settings.DataBits!=DATA_5) {
+                                        TTY_WARNING("Win_QextSerialPort: 1.5 stop bits can only be used with 5 data bits");
+                                }
+                                else {
+                                        Win_CommConfig.dcb.StopBits=ONE5STOPBITS;
+                                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                }
+                                break;
+                                /*two stop bits*/
+                        case STOP_2:
+                                if (Settings.DataBits==DATA_5) {
+                                        TTY_WARNING("Win_QextSerialPort: 2 stop bits cannot be used with 5 data bits");
+                                }
+                                else {
+                                        Win_CommConfig.dcb.StopBits=TWOSTOPBITS;
+                                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+                                }
+                                break;
+                        }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::setBaudRate(BaudRateType baudRate)
+                        Sets the baud rate of the serial port.  Note that not all rates are applicable on
+                        all platforms.  The following table shows translations of the various baud rate
+                        constants on Windows(including NT/2000) and POSIX platforms.  Speeds marked with an *
+                        are speeds that are usable on both Windows and POSIX.
+                        \verbatim
+RATE          Windows Speed   POSIX Speed
+                -----------   -------------   -----------
+                BAUD50                 110          50
+                BAUD75                 110          75
+                *BAUD110                110         110
+                BAUD134                110         134.5
+                BAUD150                110         150
+                BAUD200                110         200
+                *BAUD300                300         300
+                *BAUD600                600         600
+                *BAUD1200              1200        1200
+                BAUD1800              1200        1800
+                *BAUD2400              2400        2400
+                *BAUD4800              4800        4800
+                *BAUD9600              9600        9600
+                BAUD14400            14400        9600
+                *BAUD19200            19200       19200
+                *BAUD38400            38400       38400
+                BAUD56000            56000       38400
+                *BAUD57600            57600       57600
+                BAUD76800            57600       76800
+                *BAUD115200          115200      115200
+                BAUD128000          128000      115200
+                BAUD256000          256000      115200
+                \endverbatim
+*/
+void Win_QextSerialPort::setBaudRate(BaudRateType baudRate) {
+        LOCK_MUTEX();
+        if (Settings.BaudRate!=baudRate) {
+                switch (baudRate) {
+                        case BAUD50:
+                        case BAUD75:
+                        case BAUD134:
+                        case BAUD150:
+                        case BAUD200:
+                                Settings.BaudRate=BAUD110;
+                                break;
+                        case BAUD1800:
+                                Settings.BaudRate=BAUD1200;
+                                break;
+                        case BAUD76800:
+                                Settings.BaudRate=BAUD57600;
+                                break;
+                        default:
+                                Settings.BaudRate=baudRate;
+                                break;
+                        }
+        }
+        if (isOpen()) {
+                switch (baudRate) {
+                                /*50 baud*/
+                        case BAUD50:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 50 baud operation.  Switching to 110 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_110;
+                                break;
+                                /*75 baud*/
+                        case BAUD75:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 75 baud operation.  Switching to 110 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_110;
+                                break;
+                                /*110 baud*/
+                        case BAUD110:
+                                Win_CommConfig.dcb.BaudRate=CBR_110;
+                                break;
+                                /*134.5 baud*/
+                        case BAUD134:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 134.5 baud operation.  Switching to 110 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_110;
+                                break;
+                                /*150 baud*/
+                        case BAUD150:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 150 baud operation.  Switching to 110 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_110;
+                                break;
+                                /*200 baud*/
+                        case BAUD200:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 200 baud operation.  Switching to 110 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_110;
+                                break;
+                                /*300 baud*/
+                        case BAUD300:
+                                Win_CommConfig.dcb.BaudRate=CBR_300;
+                                break;
+                                /*600 baud*/
+                        case BAUD600:
+                                Win_CommConfig.dcb.BaudRate=CBR_600;
+                                break;
+                                /*1200 baud*/
+                        case BAUD1200:
+                                Win_CommConfig.dcb.BaudRate=CBR_1200;
+                                break;
+                                /*1800 baud*/
+                        case BAUD1800:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 1800 baud operation.  Switching to 1200 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_1200;
+                                break;
+                                /*2400 baud*/
+                        case BAUD2400:
+                                Win_CommConfig.dcb.BaudRate=CBR_2400;
+                                break;
+                                /*4800 baud*/
+                        case BAUD4800:
+                                Win_CommConfig.dcb.BaudRate=CBR_4800;
+                                break;
+                                /*9600 baud*/
+                        case BAUD9600:
+                                Win_CommConfig.dcb.BaudRate=CBR_9600;
+                                break;
+                                /*14400 baud*/
+                        case BAUD14400:
+                                TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 14400 baud operation.");
+                                Win_CommConfig.dcb.BaudRate=CBR_14400;
+                                break;
+                                /*19200 baud*/
+                        case BAUD19200:
+                                Win_CommConfig.dcb.BaudRate=CBR_19200;
+                                break;
+                                /*38400 baud*/
+                        case BAUD38400:
+                                Win_CommConfig.dcb.BaudRate=CBR_38400;
+                                break;
+                                /*56000 baud*/
+                        case BAUD56000:
+                                TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 56000 baud operation.");
+                                Win_CommConfig.dcb.BaudRate=CBR_56000;
+                                break;
+                                /*57600 baud*/
+                        case BAUD57600:
+                                Win_CommConfig.dcb.BaudRate=CBR_57600;
+                                break;
+                                /*76800 baud*/
+                        case BAUD76800:
+                                TTY_WARNING("Win_QextSerialPort: Windows does not support 76800 baud operation.  Switching to 57600 baud.");
+                                Win_CommConfig.dcb.BaudRate=CBR_57600;
+                                break;
+                                /*115200 baud*/
+                        case BAUD115200:
+                                Win_CommConfig.dcb.BaudRate=CBR_115200;
+                                break;
+                                /*128000 baud*/
+                        case BAUD128000:
+                                TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 128000 baud operation.");
+                                Win_CommConfig.dcb.BaudRate=CBR_128000;
+                                break;
+                                /*256000 baud*/
+                        case BAUD256000:
+                                TTY_PORTABILITY_WARNING("Win_QextSerialPort Portability Warning: POSIX does not support 256000 baud operation.");
+                                Win_CommConfig.dcb.BaudRate=CBR_256000;
+                                break;
+                        }
+                        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::setDtr(bool set)
+                        Sets DTR line to the requested state (high by default).  This function will have no effect if
+                        the port associated with the class is not currently open.
+*/
+void Win_QextSerialPort::setDtr(bool set) {
+        LOCK_MUTEX();
+        if (isOpen()) {
+                if (set) {
+                        EscapeCommFunction(Win_Handle, SETDTR);
+                }
+                else {
+                        EscapeCommFunction(Win_Handle, CLRDTR);
+                }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn void Win_QextSerialPort::setRts(bool set)
+                        Sets RTS line to the requested state (high by default).  This function will have no effect if
+                        the port associated with the class is not currently open.
+*/
+void Win_QextSerialPort::setRts(bool set) {
+        LOCK_MUTEX();
+        if (isOpen()) {
+                if (set) {
+                        EscapeCommFunction(Win_Handle, SETRTS);
+                }
+                else {
+                        EscapeCommFunction(Win_Handle, CLRRTS);
+                }
+        }
+        UNLOCK_MUTEX();
+}
+/*!
+                \fn ulong Win_QextSerialPort::lineStatus(void)
+                        returns the line status as stored by the port function.  This function will retrieve the states
+                        of the following lines: DCD, CTS, DSR, and RI.  On POSIX systems, the following additional lines
+                        can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD.  The value returned is an unsigned
+                        long with specific bits indicating which lines are high.  The following constants should be used
+                        to examine the states of individual lines:
+\verbatim
+                Mask        Line
+                ------      ----
+                LS_CTS      CTS
+                LS_DSR      DSR
+                LS_DCD      DCD
+                LS_RI       RI
+                \endverbatim
+This function will return 0 if the port associated with the class is not currently open.
+*/
+ulong Win_QextSerialPort::lineStatus(void) {
+        unsigned long Status=0, Temp=0;
+        LOCK_MUTEX();
+        if (isOpen()) {
+                GetCommModemStatus(Win_Handle, &Temp);
+                if (Temp&MS_CTS_ON) {
+                        Status|=LS_CTS;
+                }
+                if (Temp&MS_DSR_ON) {
+                        Status|=LS_DSR;
+                }
+                if (Temp&MS_RING_ON) {
+                        Status|=LS_RI;
+                }
+                if (Temp&MS_RLSD_ON) {
+                        Status|=LS_DCD;
+                }
+        }
+        UNLOCK_MUTEX();
+        return Status;
+}
+/*!
+                \fn void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec);
+Sets the read and write timeouts for the port to sec seconds and millisec milliseconds.
+*/
+void Win_QextSerialPort::setTimeout(ulong sec, ulong millisec) {
+        LOCK_MUTEX();
+        Settings.Timeout_Sec=sec;
+        Settings.Timeout_Millisec=millisec;
+        if(isOpen()) {
+                Win_CommTimeouts.ReadIntervalTimeout = sec*1000+millisec;
+                Win_CommTimeouts.ReadTotalTimeoutMultiplier = sec*1000+millisec;
+                Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
+                Win_CommTimeouts.WriteTotalTimeoutMultiplier = sec*1000+millisec;
+                Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
+                SetCommTimeouts(Win_Handle, &Win_CommTimeouts);
+        }
+        UNLOCK_MUTEX();
+}

 /QMK-Groundstation/tags/V1.0.1/SerialPort/win_qextserialport.h
 ,0 → 1,48
+#ifndef _WIN_QEXTSERIALPORT_H_
+#define _WIN_QEXTSERIALPORT_H_
+#include "qextserialbase.h"
+/*if all warning messages are turned off, flag portability warnings to be turned off as well*/
+#ifdef _TTY_NOWARN_
+#define _TTY_NOWARN_PORT_
+#endif
+#include <windows.h>
+class Win_QextSerialPort:public QextSerialBase {
+public:
+        Win_QextSerialPort();
+        Win_QextSerialPort(Win_QextSerialPort const& s);
+        Win_QextSerialPort(const QString & name);
+        Win_QextSerialPort(const PortSettings& settings);
+        Win_QextSerialPort(const QString & name, const PortSettings& settings);
+        Win_QextSerialPort& operator=(const Win_QextSerialPort& s);
+        virtual ~Win_QextSerialPort();
+        virtual bool open(OpenMode mode=0);
+        virtual void close();
+        virtual void flush();
+        virtual qint64 size() const;
+        virtual void ungetChar(char c);
+        virtual void setFlowControl(FlowType);
+        virtual void setParity(ParityType);
+        virtual void setDataBits(DataBitsType);
+        virtual void setStopBits(StopBitsType);
+        virtual void setBaudRate(BaudRateType);
+        virtual void setDtr(bool set=true);
+        virtual void setRts(bool set=true);
+        virtual ulong lineStatus(void);
+        virtual qint64 bytesAvailable();
+        virtual void translateError(ulong);
+        virtual void setTimeout(ulong, ulong);
+protected:
+        HANDLE Win_Handle;
+        COMMCONFIG Win_CommConfig;
+        COMMTIMEOUTS Win_CommTimeouts;
+        virtual qint64 readData(char *data, qint64 maxSize);
+        virtual qint64 writeData(const char *data, qint64 maxSize);
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/debian.pro
 ,0 → 1,8
+include(QMapControl.pri)
+DEFINES += _TTY_POSIX_
+LIBS += -lqwt-qt4
+INCLUDEPATH += $(HOME)/include /usr/include/qwt-qt4
+include(global.pri)

 /QMK-Groundstation/tags/V1.0.1/eeepc.pro
 ,0 → 1,9
+include(QMapControl.pri)
+DEFINES += _TTY_POSIX_ _EEEPC_
+LIBS += -lqwt-qt4
+INCLUDEPATH += $(HOME)/include /usr/include/qwt-qt4
+include(global.pri)

 /QMK-Groundstation/tags/V1.0.1/gentoo.pro
 ,0 → 1,8
+include(QMapControl.pri)
+DEFINES += _TTY_POSIX_
+LIBS += -lqwt
+INCLUDEPATH += $(HOME)/include /usr/include/qwt5
+include(global.pri)

 /QMK-Groundstation/tags/V1.0.1/global.h
 ,0 → 1,179
+/***************************************************************************
+ *   Copyright (C) 2008 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef GLOBAL_H
+#define GLOBAL_H
+#include <QString>
+#include <QSize>
+#include <QPoint>
+#include <QColor>
+#include <QBitArray>
+#include "Parameter_Positions.h"
+#ifdef _WIN32_
+static const QString OS_PORT = "COM1";
+#else
+static const QString OS_PORT = "/dev/ttyUSB0";
+#endif
+//#define _EEEPC_
+// Version des Seriellen Protokoll
+static const int VERSION_SERIAL_MAJOR = 10;
+static const int VERSION_SERIAL_MINOR = 0;
+// Basis-Addressen der verschiedenen Hardware
+static const int ADDRESS_ALL    = 0;
+static const int ADDRESS_FC     = 1;
+static const int ADDRESS_NC     = 2;
+static const int ADDRESS_MK3MAG = 3;
+static const int SETTINGS_ID = 2;
+static const int SLEEP = 500000;
+#ifdef _EEEPC_
+    static const int MeterSize = 125;
+    static const int TICKER = 5000;
+#else
+    static const int MeterSize = 160;
+    static const int TICKER = 2000;
+#endif
+static const QString QA_NAME = "QMK-Groundstation";
+static const QString QA_VERSION_NR = "1.0.1";
+#ifdef _BETA_
+    static const QString QA_VERSION = QA_VERSION_NR + " (BETA)";
+    static const QString QA_HWVERSION = "FlightCtrl v0.75a & NaviCtrl v0.15c";
+#else
+    static const QString QA_VERSION = QA_VERSION_NR;
+    static const QString QA_HWVERSION = "FlightCtrl v0.75a & NaviCtrl v0.15c";
+#endif
+#ifdef Q_OS_LINUX
+    static const QString QA_OS = "Linux";
+#else
+    #ifdef Q_OS_DARWIN
+        static const QString QA_OS = "OSX";
+    #else
+        #ifdef Q_OS_WIN32
+            static const QString QA_OS = "Windows";
+        #else
+            static const QString QA_OS = "n/a";
+        #endif
+    #endif
+#endif
+static const QString QA_DATE = "19.07.2009";
+static const QString QA_YEAR = "2008-2009";
+static const QString QA_AUTHOR = "Manuel Schrape";
+static const QString QA_EMAIL  = "manuel.schrape@gmx.de";
+static const QString QA_ABOUT =
+    "<HTML>"
+    "<p><b><font size=8>" + QA_NAME + "</font></b></p>"
+    "<br />"
+    "Version " + QA_VERSION + " - " + QA_DATE + " on " + QA_OS + ""
+    "<br /><br /><b>kompatibel zu " + QA_HWVERSION + "</b>"
+    "<br /><br />"
+    "(C) " + QA_YEAR + " by " + QA_AUTHOR + " - "
+    "<a href=\"mailto:" + QA_EMAIL + "\">" + QA_EMAIL + "</a> <br /><br />"
+    "Groundstation-Programm f&uuml;r den Mikrokopter zum <br>Parametrieren und Debug-Werte anzeigen, aufzeichnen & Visualisieren."
+    "<br /><br /> Dieses Programm wird unter den Bedingungen der GPL v2 ver&ouml;ffentlicht."
+    "</HTML>";
+static const QString Def_AnalogNames[] = {"Integral Nick", "Integral Roll", "ACC Nick", "ACC Roll", "Gyro Gier", "Hoehen-Wert", "ACC Z", "GAS", "Kompass-Value", "Spannung", "Empfang", "Ersatzkompass", "Motor Vorne", "Motor Hinten", "Motor Links", "Motor Rechts", "Analog 16", "Distance", "OSD-Bar", "MK3Mag", "Servo", "Nick", "Roll", "Analog 23", "Analog 24",  "Analog 25",  "Analog 26",  "Kalman Max",  "Analog 28",  "Kalman K", "GPS Nick", "GPS Roll"};
+static const QRgb Def_Colors[] = {0x00FF0000, 0x0000FF00, 0x00FFFF00, 0x000000FF, 0x00FF00FF, 0x0000FFFF, 0x00FFFFFF, 0x00660000, 0x00006600, 0x00666600, 0x00000066, 0x00660066, 0x000066, 0x00666666, 0x00990000, 0x00009900, 0x00999900, 0x00000099, 0x00990099, 0x00009999, 0x00999999, 0x00CC0000, 0x0000CC00, 0x00CCCC00, 0x000000CC, 0x00CC00CC, 0x0000CCCC, 0x00CCCCCC, 0x0066FF99, 0x009966FF, 0x00FF9966, 0x0099FF66};
+static const bool Def_Plot_Show[] = {1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0};
+static const bool Def_Log[]       = {1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0};
+static const QString HardwareType[] = {"Default", "FlightCtrl", "NaviCtrl", "MK3Mag"};
+static const int MaxTickerEvents = 5;
+static const int MaxAnalog    = 32;
+static const int MaxPlot      = 50000;
+static const int MaxNaviPos   = 2000;
+struct sMotor
+{
+    int Speed[12];
+};
+struct sMode
+{
+    int ID;
+    int VERSION_MAJOR;
+    int VERSION_MINOR;
+    int VERSION_PATCH;
+    int VERSION_SERIAL_MAJOR;
+    int VERSION_SERIAL_MINOR;
+    QString Hardware;
+    QString Version;
+};
+struct sRxData
+{
+    char *Input;
+    QString String;
+    int Decode[150];
+    int DecLen;
+};
+struct sGPS_Pos
+{
+    long Longitude;
+    long Latitude;
+    long Altitude;
+};
+struct sNaviData
+{
+    sGPS_Pos Current;
+    sGPS_Pos Target;
+    sGPS_Pos Home;
+    long Longitude;
+    long Latitude;
+    long Altitude;
+};
+struct sNaviString
+{
+    QString Longitude;
+    QString Latitude;
+    QString Altitude;
+};
+struct sWayPoint
+{
+    double Longitude;
+    double Latitude;
+    double Altitude;
+    int Time;
+};
+#endif

 /QMK-Groundstation/tags/V1.0.1/global.pri
 ,0 → 1,82
+TEMPLATE = app
+OBJECTS_DIR = build/.o_unix
+UI_DIR      = build/.ui
+MOC_DIR     = build/.moc
+RCC_DIR     = build/.rcc
+DESTDIR     = build/bin
+QT *= gui core network xml
+CONFIG += warn_on thread qt
+TARGET = QMK-Groundstation
+RESOURCES += MKTool.qrc
+SOURCES += \
+    main.cpp \
+    SerialPort/qextserialbase.cpp \
+    SerialPort/qextserialport.cpp \
+    SerialPort/ManageSerialPort.cpp \
+    Forms/mktool.cpp \
+    Forms/dlg_Config.cpp \
+    Forms/dlg_Motortest.cpp \
+    Forms/dlg_Preferences.cpp \
+    Forms/wdg_Settings.cpp \
+    Classes/cSettings.cpp \
+    Classes/cKML_Server.cpp \
+    Classes/ToolBox.cpp \
+    Classes/cAttitude.cpp \
+    Classes/cSpeedMeter.cpp \
+    Classes/cQMK_Server.cpp \
+    Logger/Logger.cpp \
+    Logger/CSVLogger.cpp \
+    Forms/dlg_LCD.cpp \
+    Classes/cConnection.cpp \
+    Forms/dlg_Map.cpp \
+    Forms/dlg_MapPos.cpp \
+    Forms/dlg_MotorMixer.cpp
+win32:SOURCES += SerialPort/win_qextserialport.cpp
+unix:SOURCES  += SerialPort/posix_qextserialport.cpp
+HEADERS += \
+    global.h \
+    Parameter_Positions.h \
+    SerialPort/qextserialbase.h \
+    SerialPort/qextserialport.h \
+    SerialPort/ManageSerialPort.h \
+    Forms/mktool.h \
+    Forms/dlg_Config.h \
+    Forms/dlg_Motortest.h \
+    Forms/dlg_Preferences.h \
+    Forms/wdg_Settings.h \
+    Classes/cSettings.h \
+    Classes/cKML_Server.h \
+    Classes/ToolBox.h \
+    Classes/cAttitude.h \
+    Classes/cSpeedMeter.h \
+    Classes/cQMK_Server.h \
+    Logger/Logger.h \
+    Logger/CSVLogger.h \
+    Logger/DefaultLogger.h \
+    Forms/dlg_LCD.h \
+    Classes/cConnection.h \
+    typedefs.h \
+    Forms/dlg_Map.h \
+    Forms/dlg_MapPos.h \
+    Forms/dlg_MotorMixer.h
+win32:HEADERS += SerialPort/win_qextserialport.h
+unix:HEADERS  += SerialPort/posix_qextserialport.h
+FORMS += \
+    Forms/mktool.ui \
+    Forms/dlg_Config.ui \
+    Forms/dlg_Preferences.ui \
+    Forms/dlg_Motortest.ui \
+    Forms/wdg_Settings.ui \
+    Forms/dlg_LCD.ui \
+    Forms/dlg_Map.ui \
+    Forms/dlg_MapPos.ui \
+    Forms/dlg_MotorMixer.ui

 /QMK-Groundstation/tags/V1.0.1/main.cpp
 ,0 → 1,38
+/***************************************************************************
+ *   Copyright (C) 2008 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include <QApplication>
+#include "Forms/mktool.h"
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    MKTool * mw = new MKTool();
+    mw->show();
+    int iRet = app.exec();
+    delete mw;
+    return iRet;
+}

 /QMK-Groundstation/tags/V1.0.1/osx.pro
 ,0 → 1,8
+include(QMapControl.pri)
+DEFINES += _TTY_POSIX_
+LIBS += -L/opt/local/lib -lqwt
+INCLUDEPATH += /opt/local/include
+include(global.pri)

 /QMK-Groundstation/tags/V1.0.1/qmapcontrol.h
 ,0 → 1,17
+#include "Classes/QMapControl/mapcontrol.h"
+#include "Classes/QMapControl/gps_position.h"
+#include "Classes/QMapControl/wmsmapadapter.h"
+#include "Classes/QMapControl/geometry.h"
+#include "Classes/QMapControl/point.h"
+#include "Classes/QMapControl/imagepoint.h"
+#include "Classes/QMapControl/circlepoint.h"
+#include "Classes/QMapControl/linestring.h"
+#include "Classes/QMapControl/gps_position.h"
+#include "Classes/QMapControl/osmmapadapter.h"
+#include "Classes/QMapControl/maplayer.h"
+#include "Classes/QMapControl/geometrylayer.h"
+#include "Classes/QMapControl/yahoomapadapter.h"
+#include "Classes/QMapControl/googlemapadapter.h"
+#include "Classes/QMapControl/googlesatmapadapter.h"
+#include "Classes/QMapControl//openaerialmapadapter.h"
+#include "Classes/QMapControl//fixedimageoverlay.h"

 /QMK-Groundstation/tags/V1.0.1/suse.pro
 ,0 → 1,8
+include(QMapControl.pri)
+DEFINES += _TTY_POSIX_
+LIBS += -lqwt
+INCLUDEPATH += $(HOME)/include /usr/include/qwt
+include(global.pri)

 /QMK-Groundstation/tags/V1.0.1/typedefs.h
 ,0 → 1,34
+#ifndef TYPEDEFS_H
+#define TYPEDEFS_H
+#define INVALID 0x00
+#define NEWDATA 0x01
+#define PROCESSED       0x02
+typedef struct
+{
+    int32_t Longitude;  // in 1E-7 deg
+    int32_t Latitude;   // in 1E-7 deg
+    int32_t Altitude;   // in mm
+    uint8_t Status;    // validity of data
+} __attribute__((packed)) GPS_Pos_t;
+typedef struct
+{
+    GPS_Pos_t Position;          // the gps position of the waypoint, see ubx.h for details
+    int16_t   Heading;           // orientation, future implementation
+    uint8_t   ToleranceRadius;   // in meters, if the MK is within that range around the target, then the next target is triggered
+    uint8_t   HoldTime;          // in seconds, if the was once in the tolerance area around a WP, this time defies the delay before the next WP is triggered
+    uint8_t   Event_Flag;        // future emplementation
+    uint8_t   reserve[12];       // reserve
+} __attribute__((packed)) Waypoint_t;
+typedef struct
+  {
+    char Revision;
+    char Name[12];
+    signed char Motor[16][4];
+  } Mixer_t;
+#endif // TYPEDEFS_H

 /QMK-Groundstation/tags/V1.0.1/win.pro
 ,0 → 1,36
+include( ../examples.pri )
+include(QMapControl.pri)
+QWT_ROOT = ../qwt-5.1.1
+include( $${QWT_ROOT}/qwtconfig.pri )
+SUFFIX_STR = $${RELEASE_SUFFIX}
+INCLUDEPATH += $${QWT_ROOT}/src
+DEPENDPATH  += $${QWT_ROOT}/src
+QWTLIB       = qwt$${SUFFIX_STR}
+contains(CONFIG, QwtDll)
+{
+    DEFINES    += QT_DLL QWT_DLL
+    QWTLIB = $${QWTLIB}$${VER_MAJ}
+}
+win32-msvc:LIBS  += $${QWT_ROOT}/lib/$${QWTLIB}.lib
+win32-msvc.net:LIBS  += $${QWT_ROOT}/lib/$${QWTLIB}.lib
+win32-msvc2005:LIBS += $${QWT_ROOT}/lib/$${QWTLIB}.lib
+win32-g++:LIBS   += -L$${QWT_ROOT}/lib -l$${QWTLIB}
+TEMPLATE     = app
+OBJECTS_DIR = build/.o_win32
+UI_DIR      = build/.ui
+MOC_DIR     = build/.moc
+RCC_DIR     = build/.rcc
+DESTDIR     = build/bin
+DEFINES += _TTY_WIN_ QWT_DLL QT_DLL _WIN32_
+include(global.pri)

 /QMK-Groundstation/trunk/Global/Class_HandlerIP/HandlerIP.cpp
 ,0 → 1,30
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "HandlerIP.h"
+HandlerIP::HandlerIP()
+{
+}
+// IP-Datenpacket zusammenbauen
+// todo: CRC einbauen
+QString HandlerIP::make_Frame(int t_ID, int t_CMD, QString t_Data)
+{
+    return QString(QString("$:%1").arg(t_ID) + QString(":%1:").arg(t_CMD) + t_Data + ":0\r");
+}

 /QMK-Groundstation/trunk/Global/Class_HandlerIP/HandlerIP.h
 ,0 → 1,35
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef HANDLERIP_H
+#define HANDLERIP_H
+#include <QString>
+static const int ID_COMMUNICATOR = 1;
+static const int ID_SCOPE        = 11;
+static const int ID_SETTINGS     = 12;
+class HandlerIP
+{
+    public:
+        HandlerIP();
+        static QString make_Frame(int t_ID, int t_CMD, QString t_Data);
+};
+#endif // HANDLERIP_H

 /QMK-Groundstation/trunk/Global/Class_HandlerKML/HandlerKML.cpp
 ,0 → 1,65
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "HandlerKML.h"
+HandlerKML::HandlerKML()
+{
+}
+QString HandlerKML::get_Header(QString Name)
+{
+    QString block;
+    block = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+            "<kml xmlns=\"http://earth.google.com/kml/2.2\">\n"
+            "  <Document>\n"
+            "    <name>" + Name + "</name>\n"
+            "    <Style id=\"MK_gps-style\">\n"
+            "      <LineStyle>\n"
+            "        <color>ff0000ff</color>\n"
+            "        <width>2</width>\n"
+            "      </LineStyle>\n"
+            "    </Style>\n"
+            "    <Placemark>\n"
+            "      <LookAt>\n"
+            "        <range>400</range>\n"
+            "        <tilt>45</tilt>\n"
+            "      </LookAt>\n"
+            "      <name>Flight</name>\n"
+            "      <styleUrl>#MK_gps-style</styleUrl>\n"
+            "      <LineString>\n"
+            "        <extrude>1</extrude>\n"
+            "        <tessellate>1</tessellate>\n"
+            "        <altitudeMode>absolute</altitudeMode>\n"
+            "        <coordinates>\n";
+    return block;
+}
+QString HandlerKML::get_Footer()
+{
+    QString block;
+    block = "        </coordinates>\n"
+            "      </LineString>\n"
+            "    </Placemark>\n"
+            "  </Document>\n"
+            "</kml>\n";
+    return block;
+}

 /QMK-Groundstation/trunk/Global/Class_HandlerKML/HandlerKML.h
 ,0 → 1,34
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef HANDLERKML_H
+#define HANDLERKML_H
+#include <QString>
+class HandlerKML
+{
+public:
+    HandlerKML();
+    static QString get_Header(QString Name = "Mikrokopter");
+    static QString get_Footer();
+};
+#endif // HANDLERKML_H

 /QMK-Groundstation/trunk/Global/Class_HandlerMK/HandlerMK.cpp
 ,0 → 1,232
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "HandlerMK.h"
+HandlerMK::HandlerMK()
+{
+}
+// Datensatz nach 16bit Integer
+int HandlerMK::Data2Int(unsigned char Data[150] , int Start, bool is_signed)
+{
+    int Out = (Data[Start+1]<<8) | (Data[Start+0]);
+    if ((Out > 32767) && (is_signed))
+      Out = Out - 65536;
+    return Out;
+}
+// Datensatz nach QString
+QString HandlerMK::Data2QString(unsigned char Data[150], int Start, int End)
+{
+    char String[150];
+    for (int a = Start; a < End; a++)
+    {
+        String[a - Start] = Data[a];
+    }
+    String[End - Start] = '\0';
+    return QString(String);
+}
+double HandlerMK::Int2Double(int32_t Wert, int Count)
+{
+    QString Temp, s_Wert;
+    s_Wert = QString("%1").arg(Wert);
+    Temp = s_Wert.left(s_Wert.length() - Count) + QString(".") + s_Wert.right(Count);
+    return Temp.toDouble();
+}
+QString HandlerMK::add_CRC(QString TXString)
+{
+    unsigned int tmpCRC = 0;
+    char *TXBuff;
+    char CRC[2];
+    TXBuff = TXString.toLatin1().data();
+    for(int i = 0; i < TXString.length(); i++)
+    {
+        tmpCRC += TXBuff[i];
+    }
+    tmpCRC %= 4096;
+    CRC[0] = '=' + tmpCRC / 64;
+    CRC[1] = '=' + tmpCRC % 64;
+    CRC[2] = '\0';
+    QString Return = TXString + QString(CRC);
+    return Return;
+}
+bool HandlerMK::Check_CRC(char *t_InData, int Length)
+{
+    int CRC = 0;
+    if (t_InData[1] == 127)
+        t_InData[1] = 0;
+    for(int i=0; i < Length-2; i++)
+        CRC+=t_InData[i];
+    CRC = CRC % 4096;
+    if(t_InData[Length - 2] != ('=' + (CRC / 64)))
+        return false;
+    if(t_InData[Length - 1] != ('=' + CRC % 64))
+        return false;
+    return true;
+}
+int HandlerMK::Decode_64(char *t_InData, int Length, unsigned char *t_OutData)
+{
+    unsigned char a,b,c,d;
+    unsigned char ptr = 0;
+    unsigned char x,y,z;
+    int Offset = 3;
+    if (t_InData[Offset] == 0)
+    {
+        return 0;
+    }
+    while(Length != 0)
+    {
+        a = t_InData[Offset++] - '=';
+        b = t_InData[Offset++] - '=';
+        c = t_InData[Offset++] - '=';
+        d = t_InData[Offset++] - '=';
+//        if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden
+        x = (a << 2) | (b >> 4);
+        y = ((b & 0x0f) << 4) | (c >> 2);
+        z = ((c & 0x03) << 6) | d;
+        if(Length--) t_OutData[ptr++] = x; else break;
+        if(Length--) t_OutData[ptr++] = y; else break;
+        if(Length--) t_OutData[ptr++] = z; else break;
+    }
+    return ptr;
+}
+// Base64 Encoder
+QString HandlerMK::Encode64(char Data[150],unsigned int Length)
+{
+    unsigned int pt = 0;
+    unsigned char a,b,c;
+    unsigned char ptr = 0;
+    char TX_Buff[150];
+    while(Length > 0)
+    {
+        if(Length) { a = Data[ptr++]; Length--;} else a = 0;
+        if(Length) { b = Data[ptr++]; Length--;} else b = 0;
+        if(Length) { c = Data[ptr++]; Length--;} else c = 0;
+        TX_Buff[pt++] = '=' + (a >> 2);
+        TX_Buff[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
+        TX_Buff[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
+        TX_Buff[pt++] = '=' + ( c & 0x3f);
+    }
+    TX_Buff[pt] = 0;
+    return QString(TX_Buff);
+}
+QString HandlerMK::make_Frame(char t_CMD, int t_Adress, char t_Data[150], unsigned int t_Length)
+{
+    QString tx_Data = Encode64(t_Data, t_Length);
+    tx_Data = add_CRC(QString("#" + QString('a' + t_Adress) + QString(t_CMD) + tx_Data)) + "\r";
+    return tx_Data;
+}
+QString HandlerMK::get_SelectNC()
+{
+    char t_Data[6];
+    t_Data[0] = 0x1B;
+    t_Data[1] = 0x1B;
+    t_Data[2] = 0x55;
+    t_Data[3] = 0xAA;
+    t_Data[4] = 0x00;
+    t_Data[5] = '\r';
+    QString tx_Data = QString(t_Data);
+    return tx_Data;
+}
+QString HandlerMK::get_SelectFC()
+{
+    char t_Data[1];
+    t_Data[0] = 0;
+    QString tx_Data = Encode64(t_Data, 1);
+    tx_Data = add_CRC(QString("#" + QString('a' + ADDRESS_NC) + QString("u") + tx_Data)) + "\r";
+    return tx_Data;
+}
+QString HandlerMK::get_SelectMK3MAG()
+{
+    char t_Data[1];
+    t_Data[0] = 1;
+    QString tx_Data = Encode64(t_Data, 1);
+    tx_Data = add_CRC(QString("#" + QString('a' + ADDRESS_NC) + QString("u") + tx_Data)) + "\r";
+    return tx_Data;
+}
+s_Hardware HandlerMK::parse_Version(unsigned char *t_Data, int Adress)
+{
+    s_Hardware t_Hardware;
+    t_Hardware.ID                   = Adress;
+    t_Hardware.VERSION_MAJOR        = t_Data[0];
+    t_Hardware.VERSION_MINOR        = t_Data[1];
+    t_Hardware.VERSION_PATCH        = t_Data[4];
+    t_Hardware.VERSION_SERIAL_MAJOR = t_Data[2];
+    t_Hardware.VERSION_SERIAL_MINOR = t_Data[3];
+    t_Hardware.Hardware             = HardwareType[t_Hardware.ID];
+    t_Hardware.Version              = QString("%1").arg(t_Data[0]) + "." + QString("%1").arg(t_Data[1]) + QString(t_Data[4] + 'a');
+    t_Hardware.VersionShort         = QString("%1").arg(t_Data[0]) + QString("%1").arg(t_Data[1]) + QString(t_Data[4] + 'a');
+    return t_Hardware;
+}

 /QMK-Groundstation/trunk/Global/Class_HandlerMK/HandlerMK.h
 ,0 → 1,65
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef HANDLERMK_H
+#define HANDLERMK_H
+#include <QString>
+#include "../Kopter.h"
+#include "../MK_Datatypes.h"
+struct s_Hardware
+{
+    int ID;
+    int VERSION_MAJOR;
+    int VERSION_MINOR;
+    int VERSION_PATCH;
+    int VERSION_SERIAL_MAJOR;
+    int VERSION_SERIAL_MINOR;
+    QString Hardware;
+    QString Version;
+    QString VersionShort;
+};
+class HandlerMK
+{
+    public:
+        HandlerMK();
+        static int Data2Int(unsigned char Data[150], int Start, bool is_signed = true);
+        static QString Data2QString(unsigned char Data[150], int Start, int End);
+        static QString add_CRC(QString TXString);
+        static bool Check_CRC(char *t_InData, int Length);
+        static int Decode_64(char *t_InData, int Length, unsigned char *t_OutData);
+        static QString Encode64(char Data[150],unsigned int Length);
+        static QString make_Frame(char t_CMD, int t_Adress, char t_Data[150], unsigned int t_Length);
+        static QString get_SelectFC();
+        static QString get_SelectNC();
+        static QString get_SelectMK3MAG();
+        static s_Hardware parse_Version(unsigned char *t_Data, int Adress);
+        static double Int2Double(int32_t Wert, int Count);
+};
+#endif // HANDLERMK_H

 /QMK-Groundstation/trunk/Global/Class_Input/Input.cpp
 ,0 → 1,60
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "Input.h"
+void Input::Init()
+{
+}
+bool Input::Open(set_Input s_Input)
+{
+    s_Input = s_Input;
+    return false;
+}
+bool Input::IsOpen()
+{
+    return false;
+}
+bool Input::Close()
+{
+    return false;
+}
+void Input::send_Data(QString t_Data, int ID)
+{
+    t_Data = t_Data;
+    ID = ID;
+}
+void Input::send_RawData(char *t_Data)
+{
+    t_Data = t_Data;
+}
+void Input::stop_Resend(int ID)
+{
+    ID = ID;
+}
+eMode Input::Mode()
+{
+    return NONE;
+}

 /QMK-Groundstation/trunk/Global/Class_Input/Input.h
 ,0 → 1,65
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef INPUT_H
+#define INPUT_H
+#include <QObject>
+enum eMode {NONE, TCP, TTY};
+struct set_Input
+{
+    QString Main;
+    QString Sub;
+};
+struct s_Resend
+{
+    bool ID;
+    QString Data;
+};
+static const int CLOSED       = 0;
+static const int REFUSED      = 1;
+static const int REMOTECLOSED = 2;
+static const int MAX_Confirm = 11;
+class Input : public QObject
+{
+    Q_OBJECT
+    public:
+        virtual void Init();
+        virtual bool Open(set_Input s_Input);
+        virtual bool IsOpen();
+        virtual bool Close();
+        virtual void send_Data(QString t_Data, int ID = 0);
+        virtual void send_RawData(char *t_Data);
+        virtual void stop_Resend(int ID);
+        virtual eMode Mode();
+    signals:
+        virtual void sig_NewData(QString Data);
+//    private:
+};
+#endif // INPUT_H

 /QMK-Groundstation/trunk/Global/Class_Input/Input_TCP.cpp
 ,0 → 1,198
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "Input_TCP.h"
+void Input_TCP::Init()
+{
+    b_Open = false;
+    Timer = new QTimer();
+    connect(Timer, SIGNAL(timeout()), this, SLOT(slot_Timer()));
+    for (int z = 0; z < MAX_Confirm; z++)
+    {
+        Confirm[z].ID = false;
+    }
+}
+bool Input_TCP::Open(set_Input s_Input)
+{
+    TCP_Socket = new(QTcpSocket);
+    TCP_Socket->connectToHost (s_Input.Main, s_Input.Sub.toInt());
+    connect(TCP_Socket, SIGNAL(connected()), this, SLOT(slot_TCP_Connected()) );
+    connect(TCP_Socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slot_TCP_Error(QAbstractSocket::SocketError)));
+    return true;
+}
+bool Input_TCP::IsOpen()
+{
+    return b_Open;
+}
+bool Input_TCP::Close()
+{
+    TCP_Socket->disconnectFromHost();
+    disconnect(TCP_Socket, SIGNAL(connected()), 0, 0);
+    disconnect(TCP_Socket, SIGNAL(readyRead()), 0, 0);
+    disconnect(TCP_Socket, SIGNAL(disconnected()), 0, 0);
+    b_Open = false;
+    Timer->stop();
+    return true;
+}
+void Input_TCP::send_Data(QString t_Data, int ID)
+{
+    if ((ID > 0) && (ID < MAX_Confirm))
+    {
+        Timer->start(2500);
+        Confirm[ID].ID = true;
+        Confirm[ID].Data = t_Data;
+    }
+    if (b_Open)
+    {
+        usleep(50000);
+        if (t_Data[t_Data.length() - 1] != '\r')
+        {
+            t_Data = t_Data + "\r";
+        }
+        QByteArray Temp;
+        Temp = QByteArray(t_Data.toAscii());
+        TCP_Socket->write(Temp);
+//        qDebug(t_Data.toLatin1().data());
+    }
+}
+void Input_TCP::send_RawData(char *t_Data)
+{
+    t_Data = t_Data;
+}
+void Input_TCP::stop_Resend(int ID)
+{
+    if ((ID > 0) && (ID < MAX_Confirm))
+    {
+        Confirm[ID].ID = false;
+        Confirm[ID].Data = "";
+    }
+}
+void Input_TCP::slot_Timer()
+{
+    bool Active = false;
+    for (int x = 0; x < MAX_Confirm; x++)
+    {
+        if (Confirm[x].ID)
+        {
+            Active = true;
+            send_Data(Confirm[x].Data);
+        }
+    }
+    if (Active == false)
+    {
+        Timer->stop();
+    }
+}
+void Input_TCP::slot_TCP_Connected()
+{
+    b_Open = true;
+    connect(TCP_Socket, SIGNAL(readyRead()), SLOT(slot_TCP_ReadLine()));
+    connect(TCP_Socket, SIGNAL(disconnected()),TCP_Socket, SLOT(deleteLater()));
+    connect(TCP_Socket, SIGNAL(disconnected()),this, SLOT(slot_TCP_Disconnect()));
+    emit sig_Connected();
+}
+void Input_TCP::slot_TCP_Disconnect()
+{
+    disconnect(TCP_Socket, SIGNAL(disconnected()), 0, 0);
+    disconnect(TCP_Socket, SIGNAL(readyRead()), 0, 0);
+//    emit sig_Disconnected(1);
+}
+void Input_TCP::slot_TCP_ReadLine()
+{
+//    if (TCP_Socket->canReadLine())
+    {
+        QString t_Data = QString(TCP_Socket->readLine(TCP_Socket->bytesAvailable())).remove(QChar('\n'));
+        if ((t_Data.length() > 3) && (t_Data[t_Data.length() - 1] == '\r'))
+        {
+            emit(sig_NewData(t_Data));
+        }
+    }
+/*    int Len = Input.length();
+    for (int z = 0; z < Len; z++)
+    {
+        if (Input[z] == '\r')
+        {
+            new_Data(QString(""));
+            RxData.String = QString("");
+        }
+        else
+        {
+            RxData.String = RxData.String + Input[z];
+        }
+    }
+    */
+}
+void Input_TCP::slot_TCP_Error(QAbstractSocket::SocketError Error)
+{
+    b_Open = false;
+    disconnect(TCP_Socket, SIGNAL(disconnected()), 0, 0);
+    disconnect(TCP_Socket, SIGNAL(error(QAbstractSocket::SocketError)), 0, 0);
+    disconnect(TCP_Socket, SIGNAL(connected()), 0, 0);
+    disconnect(TCP_Socket, SIGNAL(readyRead()), 0, 0);
+//    qDebug("Error");
+    switch (Error)
+    {
+        case QAbstractSocket::ConnectionRefusedError:
+            emit sig_Disconnected(REFUSED);
+        break;
+        case QAbstractSocket::RemoteHostClosedError:
+            emit sig_Disconnected(REMOTECLOSED);
+        break;
+        default:
+            emit sig_Disconnected(CLOSED);
+        break;
+    }
+//    emit sig_Disconnected(CLOSED);
+}
+eMode Input_TCP::Mode()
+{
+    return TCP;
+}

 /QMK-Groundstation/trunk/Global/Class_Input/Input_TCP.h
 ,0 → 1,65
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef INPUT_TCP_H
+#define INPUT_TCP_H
+#include <QObject>
+#include <QTcpServer>
+#include <QTcpSocket>
+#include <QTimer>
+#include "Input.h"
+class Input_TCP : public Input
+{
+    Q_OBJECT
+    public:
+        void Init();
+        bool Open(set_Input s_Input);
+        bool IsOpen();
+        bool Close();
+        void send_Data(QString t_Data, int ID = 0);
+        void send_RawData(char *t_Data);
+        void stop_Resend(int ID);
+        eMode Mode();
+    private:
+        // TCP Server und Socket.
+        QTcpServer *TCP_Server;
+        QTcpSocket *TCP_Socket;
+        QTimer     *Timer;
+        bool b_Open;
+        s_Resend Confirm[MAX_Confirm];
+   private slots:
+//        void slot_newDataReceived(const QByteArray &dataReceived);
+        void slot_TCP_Connected();
+        void slot_TCP_Disconnect();
+        void slot_TCP_ReadLine();
+        void slot_TCP_Error(QAbstractSocket::SocketError Error);
+        void slot_Timer();
+    signals:
+        void sig_NewData(QString);
+        void sig_Disconnected(int);
+        void sig_Connected();
+};
+#endif // INPUT_TCP_H

 /QMK-Groundstation/trunk/Global/Class_Input/Input_TTY.cpp
 ,0 → 1,160
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#include "Input_TTY.h"
+void Input_TTY::Init()
+{
+    Timer = new QTimer();
+    connect(Timer, SIGNAL(timeout()), this, SLOT(slot_Timer()));
+    for (int z = 0; z < MAX_Confirm; z++)
+    {
+        Confirm[z].ID = false;
+    }
+}
+bool Input_TTY::Open(set_Input s_Input)
+{
+    o_TTY = new ManageSerialPort;
+    o_TTY->setBaudRate(BAUD57600);   //BaudRate
+    o_TTY->setDataBits(DATA_8);      //DataBits
+    o_TTY->setParity(PAR_NONE);      //Parity
+    o_TTY->setStopBits(STOP_1);      //StopBits
+    o_TTY->setFlowControl(FLOW_OFF); //FlowControl
+    o_TTY->setTimeout(0, 10);
+    o_TTY->enableSending();
+    o_TTY->enableReceiving();
+    o_TTY->setPort(s_Input.Main); //Port
+    o_TTY->open();
+    if (o_TTY->isOpen())
+    {
+        connect(o_TTY, SIGNAL(newDataReceived(const QByteArray &)), this, SLOT(slot_Receive(const QByteArray &)));
+        o_TTY->receiveData();
+//        qDebug(QString("Open Input-TTY " + s_Input.Main).toLatin1().data());
+        return true;
+    }
+    return false;
+}
+bool Input_TTY::IsOpen()
+{
+    return o_TTY->isOpen();
+}
+bool Input_TTY::Close()
+{
+    o_TTY->close();
+    disconnect(o_TTY, SIGNAL(newDataReceived(const QByteArray &)), this, 0);
+    Timer->stop();
+    return o_TTY->isOpen();
+}
+void Input_TTY::send_Data(QString t_Data, int ID)
+{
+    if ((ID > 0) && (ID < MAX_Confirm))
+    {
+        Timer->start(2500);
+        Confirm[ID].ID = true;
+        Confirm[ID].Data = t_Data;
+    }
+    if (o_TTY->isOpen())
+    {
+        if (t_Data[t_Data.length() - 1] != '\r')
+        {
+            t_Data = t_Data + "\r";
+        }
+        QByteArray Temp;
+        Temp = QByteArray(t_Data.toAscii());
+        o_TTY->sendData(Temp);
+//        qDebug(t_Data.toLatin1().data());
+    }
+}
+void Input_TTY::send_RawData(char *t_Data)
+{
+    t_Data = t_Data;
+}
+void Input_TTY::slot_Receive(const QByteArray &dataReceived)
+{
+    const char *RX;
+    RX = dataReceived.data();
+    int a = 0;
+    while (RX[a] != '\0')
+    {
+        if (RX[a] == '\r')
+        {
+            emit(sig_NewData(s_RX));
+            s_RX = QString("");
+        }
+        else
+        {
+            s_RX = s_RX + QString(RX[a]);
+        }
+        a++;
+    }
+}
+void Input_TTY::stop_Resend(int ID)
+{
+    if ((ID > 0) && (ID < MAX_Confirm))
+    {
+        Confirm[ID].ID = false;
+        Confirm[ID].Data = "";
+    }
+}
+void Input_TTY::slot_Timer()
+{
+    bool Active = false;
+    for (int x = 0; x < MAX_Confirm; x++)
+    {
+        if (Confirm[x].ID)
+        {
+            Active = true;
+            send_Data(Confirm[x].Data);
+        }
+    }
+    if (Active == false)
+    {
+        Timer->stop();
+    }
+}
+eMode Input_TTY::Mode()
+{
+    return TTY;
+}

 /QMK-Groundstation/trunk/Global/Class_Input/Input_TTY.h
 ,0 → 1,57
+/***************************************************************************
+ *   Copyright (C) 2009 by Manuel Schrape                                  *
+ *   manuel.schrape@gmx.de                                                 *
+ *                                                                         *
+ *   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 2 of the License.        *
+ *                                                                         *
+ *   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, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef INPUT_TTY_H
+#define INPUT_TTY_H
+#include <QObject>
+#include <QTimer>
+#include "Input.h"
+#include "../Class_SerialPort/ManageSerialPort.h"
+class Input_TTY : public Input
+{
+    Q_OBJECT
+    public:
+        void Init();
+        bool Open(set_Input s_Input);
+        bool IsOpen();
+        bool Close();
+        void send_Data(QString t_Data, int ID = 0);
+        void send_RawData(char *t_Data);
+        void stop_Resend(int ID);
+        eMode Mode();
+    private:
+        ManageSerialPort *o_TTY;
+        QString  s_RX;
+        QTimer   *Timer;
+        s_Resend Confirm[MAX_Confirm];
+    private slots:
+        void slot_Receive(const QByteArray &dataReceived);
+        void slot_Timer();
+    signals:
+        void sig_NewData(QString Data);
+};
+#endif // INPUT_TTY_H

 /QMK-Groundstation/trunk/Global/Class_QMapControl/circlepoint.h
 ,0 → 1,77
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef CIRCLEPOINT_H
+#define CIRCLEPOINT_H
+#include "point.h"
+namespace qmapcontrol
+{
+    //! Draws a circle into the map
+    /*! This is a conveniece class for Point.
+     * It configures the pixmap of a Point to draw a circle.
+     * A QPen could be used to change the color or line-width of the circle
+     *
+     * @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class CirclePoint : public Point
+    {
+    public:
+        //!
+        /*!
+         *
+         * @param x longitude
+         * @param y latitude
+         * @param name name of the circle point
+         * @param alignment alignment (Middle or TopLeft)
+         * @param pen QPen for drawing
+         */
+        CirclePoint(qreal x, qreal y, QString name = QString(), Alignment alignment = Middle, QPen* pen=0);
+        //!
+        /*!
+         *
+         * @param x longitude
+         * @param y latitude
+         * @param radius the radius of the circle
+         * @param name name of the circle point
+         * @param alignment alignment (Middle or TopLeft)
+         * @param pen QPen for drawing
+         */
+        CirclePoint(qreal x, qreal y, int radius = 10, QString name = QString(), Alignment alignment = Middle, QPen* pen=0);
+        virtual ~CirclePoint();
+        //! sets the QPen which is used for drawing the circle
+        /*!
+         * A QPen can be used to modify the look of the drawn circle
+         * @param pen the QPen which should be used for drawing
+         * @see http://doc.trolltech.com/4.3/qpen.html
+         */
+        virtual void setPen(QPen* pen);
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/curve.cpp
 ,0 → 1,41
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "curve.h"
+namespace qmapcontrol
+{
+    Curve::Curve(QString name)
+        : Geometry(name)
+    {
+    }
+    Curve::~Curve()
+    {
+    }
+}
+// Geometry Curve::Clone(){}
+// QRectF Curve::GetBoundingBox(){}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/curve.h
 ,0 → 1,65
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef CURVE_H
+#define CURVE_H
+#include "geometry.h"
+#include "point.h"
+namespace qmapcontrol
+{
+    //! A Curve Geometry, implemented to fullfil OGC Spec
+    /*!
+     * The Curve class is used by LineString as parent class.
+     * This class could not be used directly.
+     *
+     * From the OGC Candidate Implementation Specification:
+     * "A Curve is a 1-dimensional geometric object usually stored as a sequence of Points, with the subtype of Curve
+     * specifying the form of the interpolation between Points. This specification defines only one subclass of Curve,
+     * LineString, which uses a linear interpolation between Points."
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class Curve : public Geometry
+    {
+        Q_OBJECT
+    public:
+        virtual ~Curve();
+        double Length;
+        //  virtual Geometry Clone();
+        //  virtual QRectF GetBoundingBox();
+        //  virtual Point EndPoint() = 0;
+        //  virtual Point StartPoint() = 0;
+        //  virtual Point Value() = 0;
+    protected:
+        Curve(QString name = QString());
+        virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset) = 0;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/emptymapadapter.cpp
 ,0 → 1,117
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "emptymapadapter.h"
+namespace qmapcontrol
+{
+    EmptyMapAdapter::EmptyMapAdapter(int tileSize, int minZoom, int maxZoom)
+        :MapAdapter("", "", 256, minZoom, maxZoom)
+    {
+        PI = acos(-1.0);
+        numberOfTiles = tilesonzoomlevel(minZoom);
+    }
+    EmptyMapAdapter::~EmptyMapAdapter()
+    {
+    }
+    void EmptyMapAdapter::zoom_in()
+    {
+        if (current_zoom < max_zoom)
+        {
+            current_zoom = current_zoom + 1;
+        }
+        numberOfTiles = tilesonzoomlevel(current_zoom);
+    }
+    void EmptyMapAdapter::zoom_out()
+    {
+        if (current_zoom > min_zoom)
+        {
+            current_zoom = current_zoom - 1;
+        }
+        numberOfTiles = tilesonzoomlevel(current_zoom);
+    }
+    qreal EmptyMapAdapter::deg_rad(qreal x) const
+    {
+        return x * (PI/180.0);
+    }
+    qreal EmptyMapAdapter::rad_deg(qreal x) const
+    {
+        return x * (180/PI);
+    }
+    QString EmptyMapAdapter::query(int x, int y, int z) const
+    {
+        return "";
+    }
+    QPoint EmptyMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
+    {
+        qreal x = (coordinate.x()+180) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
+        qreal y = (1-(log(tan(PI/4+deg_rad(coordinate.y())/2)) /PI)) /2  * (numberOfTiles*mytilesize);
+        return QPoint(int(x), int(y));
+    }
+    QPointF EmptyMapAdapter::displayToCoordinate(const QPoint& point) const
+    {
+        qreal longitude = (point.x()*(360/(numberOfTiles*mytilesize)))-180;
+        qreal latitude = rad_deg(atan(sinh((1-point.y()*(2/(numberOfTiles*mytilesize)))*PI)));
+        return QPointF(longitude, latitude);
+    }
+    bool EmptyMapAdapter::isValid(int x, int y, int z) const
+    {
+        if (max_zoom < min_zoom)
+        {
+            z= min_zoom - z;
+        }
+        if (x<0 || x>pow(2,z)-1 ||
+            y<0 || y>pow(2,z)-1)
+        {
+            return false;
+        }
+        return true;
+    }
+    int EmptyMapAdapter::tilesonzoomlevel(int zoomlevel) const
+    {
+        return int(pow(2, zoomlevel));
+    }
+    int EmptyMapAdapter::xoffset(int x) const
+    {
+        return x;
+    }
+    int EmptyMapAdapter::yoffset(int y) const
+    {
+        return y;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/emptymapadapter.h
 ,0 → 1,73
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef EMPTYMAPADAPTER_H
+#define EMPTYMAPADAPTER_H
+#include "mapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter which do not load map tiles.
+    /*!
+     * The EmptyMapAdapter can be used if QMapControl should not load any map tiles. This is useful if you
+     * only want to display an image through a FixedImageOverlay e.g.
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class EmptyMapAdapter : public MapAdapter
+    {
+        Q_OBJECT
+    public:
+        //! Constructor.
+        /*!
+         * @param tileSize This parameter seems unnecessary for this type of MapAdaper on first sight. But since
+         * this parameter defines the size of the offscreen image it could be used for a little performance
+         * tuning (larger offscreen-images have to be redrawed less times).
+         * @param minZoom the minimum zoom level
+         * @param maxZoom the maximum zoom level
+         */
+        EmptyMapAdapter(int tileSize = 256, int minZoom = 0, int maxZoom = 17);
+        virtual ~EmptyMapAdapter();
+        virtual QPoint coordinateToDisplay(const QPointF&) const;
+        virtual QPointF displayToCoordinate(const QPoint&) const;
+        qreal PI;
+    protected:
+        qreal rad_deg(qreal) const;
+        qreal deg_rad(qreal) const;
+        virtual bool isValid(int x, int y, int z) const;
+        virtual void zoom_in();
+        virtual void zoom_out();
+        virtual QString query(int x, int y, int z) const;
+        virtual int tilesonzoomlevel(int zoomlevel) const;
+        virtual int xoffset(int x) const;
+        virtual int yoffset(int y) const;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/fixedimageoverlay.cpp
 ,0 → 1,69
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2009 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "fixedimageoverlay.h"
+namespace qmapcontrol
+{
+    FixedImageOverlay::FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QString filename, QString name)
+        : ImagePoint(x_upperleft, y_upperleft, filename, name, TopLeft),
+                     x_lowerright(x_lowerright), y_lowerright(y_lowerright)
+    {
+        //qDebug() << "loading image: " << filename;
+        mypixmap = new QPixmap(filename);
+        size = mypixmap->size();
+        //qDebug() << "image size: " << size;
+    }
+    FixedImageOverlay::FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QPixmap* pixmap, QString name)
+        : ImagePoint(x_upperleft, y_upperleft, pixmap, name, TopLeft),
+                     x_lowerright(x_lowerright), y_lowerright(y_lowerright)
+    {
+        mypixmap = pixmap;
+        size = mypixmap->size();
+    }
+    void FixedImageOverlay::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset)
+    {
+        if (!visible)
+            return;
+        if (mypixmap !=0)
+        {
+            const QPointF c = QPointF(X, Y);
+            QPoint topleft = mapadapter->coordinateToDisplay(c);
+            const QPointF c2 = QPointF(x_lowerright, y_lowerright);
+            QPoint lowerright = mapadapter->coordinateToDisplay(c2);
+            painter->drawPixmap(topleft.x(), topleft.y(), lowerright.x()-topleft.x(), lowerright.y()-topleft.y(), *mypixmap);
+        }
+    }
+    FixedImageOverlay::~FixedImageOverlay()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/fixedimageoverlay.h
 ,0 → 1,80
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2009 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef FIXEDIMAGEOVERLAY_H
+#define FIXEDIMAGEOVERLAY_H
+#include "imagepoint.h"
+namespace qmapcontrol
+{
+    //! Draws a fixed image into the map.
+    /*!
+     * This class draws a image overlay onto a map, whose upper left and lower
+     * right corners lay always on the given coordinates. The methods
+     * setBaselevel, setMaxsize and setMinsize have no effect for this class.
+     *
+     * @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class FixedImageOverlay : public ImagePoint
+    {
+    public:
+       //! Creates an image overlay which loads and displays the given image file
+       /*!
+        * Use this contructor to load the given image file and let the point
+        * display it.
+        * When you want multiple points to display the same image, use the
+        * other contructor and pass a pointer to that image.
+        * @param x_upperleft the coordinate of the upper left corner where the image should be aligned
+        * @param y_upperleft the coordinate of the upper left corner where the image should be aligned
+        * @param x_lowerright the coordinate of the lower right corner where the image should be aligned
+        * @param y_lowerright the coordinate of the lower right corner where the image should be aligned
+        * @param filename the file which should be loaded and displayed
+        * @param name the name of the image point
+        */
+        FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QString filename, QString name = QString());
+       //! Creates an image overlay which displays the given image
+       /*!
+        * Use this contructor to display the given image.
+        * @param x_upperleft the coordinate of the upper left corner where the image should be aligned
+        * @param y_upperleft the coordinate of the upper left corner where the image should be aligned
+        * @param x_lowerright the coordinate of the lower right corner where the image should be aligned
+        * @param y_lowerright the coordinate of the lower right corner where the image should be aligned
+        * @param pixmap pointer to the image pixmap
+        * @param name the name of the image point
+        */
+        FixedImageOverlay(qreal x_upperleft, qreal y_upperleft, qreal x_lowerright, qreal y_lowerright, QPixmap* pixmap, QString name = QString());
+        virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset);
+        virtual ~FixedImageOverlay();
+    private:
+        qreal x_lowerright;
+        qreal y_lowerright;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/geometry.cpp
 ,0 → 1,88
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "geometry.h"
+namespace qmapcontrol
+{
+    Geometry::Geometry(QString name)
+        : GeometryType("Geometry"), myparentGeometry(0), mypen(0), visible(true), myname(name)
+    {
+    }
+    Geometry::~Geometry()
+    {
+    }
+    QString Geometry::name() const
+    {
+        return myname;
+    }
+    Geometry* Geometry::parentGeometry() const
+    {
+        return myparentGeometry;
+    }
+    void Geometry::setParentGeometry(Geometry* geom)
+    {
+        myparentGeometry = geom;
+    }
+    bool Geometry::hasPoints() const
+    {
+        return false;
+    }
+    bool Geometry::hasClickedPoints() const
+    {
+        return false;
+    }
+    QList<Geometry*> Geometry::clickedPoints()
+    {
+        QList<Geometry*> tmp;
+        return tmp;
+    }
+    bool Geometry::isVisible() const
+    {
+        return visible;
+    }
+    void Geometry::setVisible(bool visible)
+    {
+        this->visible = visible;
+        emit(updateRequest(boundingBox()));
+    }
+    void Geometry::setName(QString name)
+    {
+        myname = name;
+    }
+    void Geometry::setPen(QPen* pen)
+    {
+        mypen = pen;
+    }
+    QPen* Geometry::pen() const
+    {
+        return mypen;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/geometry.h
 ,0 → 1,154
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef GEOMETRY_H
+#define GEOMETRY_H
+#include <QObject>
+#include <QPainter>
+#include <QDebug>
+#include "mapadapter.h"
+namespace qmapcontrol
+{
+    class Point;
+    //! Main class for objects that should be painted in maps
+    /*!
+     * Geometry is the root class of the hierarchy. Geometry is an abstract (non-instantiable) class.
+     *
+     * This class and the derived classes Point, Curve and LineString are leant on the Simple
+     * Feature Specification of the Open Geospatial Consortium.
+     * @see www.opengeospatial.com
+     *
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class Geometry : public QObject
+    {
+        friend class LineString;
+        Q_OBJECT
+    public:
+        explicit Geometry(QString name = QString());
+        virtual ~Geometry();
+        QString GeometryType;
+        //!
+        /*! returns true if the given Geometry is equal to this Geometry
+         *  not implemented yet!
+         * @param geom The Geometry to be tested
+         * @return true if the given Geometry is equal to this
+         */
+        bool Equals(Geometry* geom);
+        //! returns a String representation of this Geometry
+        /*!
+         * not implemented yet!
+         * @return a String representation of this Geometry
+         */
+        QString toString();
+        //! returns the name of this Geometry
+        /*!
+         * @return the name of this Geometry
+         */
+        QString name() const;
+        //! returns the parent Geometry of this Geometry
+        /*!
+         * A LineString is a composition of many Points. This methods returns the parent (the LineString) of a Point
+         * @return the parent Geometry of this Geometry
+         */
+        Geometry* parentGeometry() const;
+        //! returns true if this Geometry is visible
+        /*!
+         * @return true if this Geometry is visible
+         */
+        bool isVisible() const;
+        //! sets the name of the geometry
+        /*!
+         * @param name the new name of the geometry
+         */
+        void setName(QString name);
+        //! returns the QPen which is used on drawing
+        /*!
+         * The pen is set depending on the Geometry. A CirclePoint for example takes one with the constructor.
+         * @return the QPen which is used for drawing
+         */
+        QPen* pen() const;
+        //! returns the BoundingBox
+        /*!
+         * The bounding box in world coordinates
+         * @return the BoundingBox
+         */
+        virtual QRectF boundingBox()=0;
+        virtual bool Touches(Point* geom, const MapAdapter* mapadapter)=0;
+        virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset)=0;
+        virtual bool hasPoints() const;
+        virtual bool hasClickedPoints() const;
+        virtual void setPen(QPen* pen);
+        virtual QList<Geometry*> clickedPoints();
+        virtual QList<Point*> points()=0;
+    private:
+        Geometry* myparentGeometry;
+        Geometry(const Geometry& old);
+        Geometry& operator=(const Geometry& rhs);
+    protected:
+        QPen* mypen;
+        bool visible;
+        QString myname;
+        void setParentGeometry(Geometry* geom);
+    signals:
+        void updateRequest(Geometry* geom);
+        void updateRequest(QRectF rect);
+        //! This signal is emitted when a Geometry is clicked
+        /*!
+         * A Geometry is clickable, if the containing layer is clickable.
+         * The objects emits a signal if it gets clicked
+         * @param  geometry The clicked Geometry
+         * @param  point -unused-
+         */
+        void geometryClicked(Geometry* geometry, QPoint point);
+        //! A Geometry emits this signal, when its position gets changed
+        /*!
+         * @param geom the Geometry
+         */
+        void positionChanged(Geometry* geom);
+    public slots:
+        //! if visible is true, the layer is made visible
+        /*!
+         * @param  visible if the layer should be visible
+         */
+        virtual void setVisible(bool visible);
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/geometrylayer.cpp
 ,0 → 1,38
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "geometrylayer.h"
+namespace qmapcontrol
+{
+    GeometryLayer::GeometryLayer(QString layername, MapAdapter* mapadapter, bool takeevents)
+        : Layer(layername, mapadapter, Layer::GeometryLayer, takeevents)
+    {
+    }
+    GeometryLayer::~GeometryLayer()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/geometrylayer.h
 ,0 → 1,65
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef GEOMETRYLAYER_H
+#define GEOMETRYLAYER_H
+#include "layer.h"
+namespace qmapcontrol
+{
+    //! GeometryLayer class
+    /*!
+         * There are two different layer types:
+         *  - MapLayer: Displays Maps, but also Geometries. The configuration for displaying maps have to be done in the MapAdapter
+         *  - GeometryLayer: Only displays Geometry objects.
+         *
+         * MapLayers also can display Geometry objects. The difference to the GeometryLayer is the repainting. Objects that are
+         * added to a MapLayer are "baken" on the map. This means, when you change it´s position for example the changes are
+         * not visible until a new offscreen image has been drawn. If you have "static" Geometries which won´t change their
+         * position this is fine. But if you want to change the objects position or pen you should use a GeometryLayer. Those
+         * are repainted immediately on changes.
+         *
+         *      @author Kai Winter <kaiwinter@gmx.de>
+         */
+    class GeometryLayer : public Layer
+    {
+        Q_OBJECT
+    public:
+        //! GeometryLayer constructor
+        /*!
+         * This is used to construct a map layer.
+         *
+         * @param layername The name of the Layer
+         * @param mapadapter The MapAdapter which does coordinate translation and Query-String-Forming
+         * @param takeevents Should the Layer receive MouseEvents? This is set to true by default. Setting it to false could
+         * be something like a "speed up hint"
+         */
+        GeometryLayer(QString layername, MapAdapter* mapadapter, bool takeevents=true);
+        virtual ~GeometryLayer();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/googlemapadapter.cpp
 ,0 → 1,38
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "googlemapadapter.h"
+namespace qmapcontrol
+{
+    GoogleMapAdapter::GoogleMapAdapter()
+        : TileMapAdapter("mt2.google.com", "/mt?n=404&x=%2&y=%3&zoom=%1", 256, 17, 0)
+        //: TileMapAdapter("tile.openstreetmap.org", "/%1/%2/%3.png", 256, 0, 17)
+    {
+    }
+    GoogleMapAdapter::~GoogleMapAdapter()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/googlemapadapter.h
 ,0 → 1,51
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef GOOGLEMAPADAPTER_H
+#define GOOGLEMAPADAPTER_H
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for Google
+    /*!
+     * This is a conveniece class, which extends and configures a TileMapAdapter
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class GoogleMapAdapter : public TileMapAdapter
+    {
+        Q_OBJECT
+    public:
+        //! constructor
+        /*!
+         * This construct a Google Adapter
+         */
+        GoogleMapAdapter();
+        virtual ~GoogleMapAdapter();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/googlesatmapadapter.cpp
 ,0 → 1,181
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "googlesatmapadapter.h"
+#include <math.h>
+namespace qmapcontrol
+{
+    GoogleSatMapAdapter::GoogleSatMapAdapter()
+            : TileMapAdapter("kh.google.com", "/kh?n=404&v=8&t=trtqtt", 256, 0, 19)
+    {
+        // name = "googlesat";
+        numberOfTiles = pow(2, current_zoom+0.0);
+        coord_per_x_tile = 360. / numberOfTiles;
+        coord_per_y_tile = 180. / numberOfTiles;
+    }
+    GoogleSatMapAdapter::~GoogleSatMapAdapter()
+    {
+    }
+    QString GoogleSatMapAdapter::getHost() const
+    {
+        int random = qrand() % 4;
+        return QString("kh%1.google.com").arg(random);
+    }
+    QPoint GoogleSatMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
+    {
+        //double x = ((coordinate.x()+180)*(tilesize*numberOfTiles/360));
+        //double y = (((coordinate.y()*-1)+90)*(tilesize*numberOfTiles/180));
+        qreal x = (coordinate.x()+180.) * (numberOfTiles*mytilesize)/360.;              // coord to pixel!
+        //double y = -1*(coordinate.y()-90) * (numberOfTiles*tilesize)/180.;    // coord to pixel!
+        qreal y = (getMercatorYCoord(coordinate.y())-M_PI) * -1 * (numberOfTiles*mytilesize)/(2*M_PI);  // coord to pixel!
+        return QPoint(int(x), int(y));
+    }
+    QPointF GoogleSatMapAdapter::displayToCoordinate(const QPoint& point) const
+    {
+        //double lon = ((point.x()/tilesize*numberOfTiles)*360)-180;
+        //double lat = (((point.y()/tilesize*numberOfTiles)*180)-90)*-1;
+        qreal lon = (point.x()*(360./(numberOfTiles*mytilesize)))-180.;
+        //double lat = -(point.y()*(180./(numberOfTiles*tilesize)))+90;
+        //qreal lat = getMercatorLatitude(point.y()*-1*(2*M_PI/(numberOfTiles*tilesize)) + M_PI);
+        qreal lat = lat *180./M_PI;
+        return QPointF(lon, lat);
+    }
+    qreal GoogleSatMapAdapter::getMercatorLatitude(qreal YCoord) const
+    {
+        //http://welcome.warnercnr.colostate.edu/class_info/nr502/lg4/projection_mathematics/converting.html
+        if (YCoord > M_PI) return 9999.;
+        if (YCoord < -M_PI) return -9999.;
+        qreal t = atan(exp(YCoord));
+        qreal res = (2.*(t))-(M_PI/2.);
+        return res;
+    }
+    qreal GoogleSatMapAdapter::getMercatorYCoord(qreal lati) const
+    {
+        qreal lat = lati;
+        // conversion degre=>radians
+        qreal phi = M_PI * lat / 180;
+        qreal res;
+        //double temp = Math.Tan(Math.PI / 4 - phi / 2);
+        //res = Math.Log(temp);
+        res = 0.5 * log((1 + sin(phi)) / (1 - sin(phi)));
+        return res;
+    }
+    void GoogleSatMapAdapter::zoom_in()
+    {
+        current_zoom+=1;
+        numberOfTiles = pow(2, current_zoom+0.0);
+        coord_per_x_tile = 360. / numberOfTiles;
+        coord_per_y_tile = 180. / numberOfTiles;
+    }
+    void GoogleSatMapAdapter::zoom_out()
+    {
+        current_zoom-=1;
+        numberOfTiles = pow(2, current_zoom+0.0);
+        coord_per_x_tile = 360. / numberOfTiles;
+        coord_per_y_tile = 180. / numberOfTiles;
+    }
+    bool GoogleSatMapAdapter::isValid(int x, int y, int z) const
+    {
+        if ((x>=0 && x < numberOfTiles) && (y>=0 && y < numberOfTiles) && z>=0)
+        {
+            return true;
+        }
+        return false;
+    }
+    QString GoogleSatMapAdapter::query(int i, int j, int z) const
+    {
+        return getQ(-180+i*coord_per_x_tile,
+-(j+1)*coord_per_y_tile, z);
+    }
+    QString GoogleSatMapAdapter::getQ(qreal longitude, qreal latitude, int zoom) const
+    {
+        qreal xmin=-180;
+        qreal xmax=180;
+        qreal ymin=-90;
+        qreal ymax=90;
+        qreal xmoy=0;
+        qreal ymoy=0;
+        QString location="t";
+        //Google uses a latitude divided by 2;
+        qreal halflat = latitude;
+        for (int i = 0; i < zoom; i++)
+        {
+            xmoy = (xmax + xmin) / 2;
+            ymoy = (ymax + ymin) / 2;
+            if (halflat >= ymoy) //upper part (q or r)
+            {
+                ymin = ymoy;
+                if (longitude < xmoy)
+                { /*q*/
+                    location+= "q";
+                    xmax = xmoy;
+                }
+                else
+                {/*r*/
+                    location+= "r";
+                    xmin = xmoy;
+                }
+            }
+            else //lower part (t or s)
+            {
+                ymax = ymoy;
+                if (longitude < xmoy)
+                { /*t*/
+                    location+= "t";
+                    xmax = xmoy;
+                }
+                else
+                {/*s*/
+                    location+= "s";
+                    xmin = xmoy;
+                }
+            }
+        }
+        return QString("/kh?n=404&v=24&t=%1").arg(location);
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/googlesatmapadapter.h
 ,0 → 1,74
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef GOOGLESATMAPADAPTER_H
+#define GOOGLESATMAPADAPTER_H
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for Google
+    /*!
+     * This is a conveniece class, which extends and configures a TileMapAdapter
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class GoogleSatMapAdapter : public TileMapAdapter
+    {
+        Q_OBJECT
+    public:
+        //! constructor
+        /*!
+         * This construct a Google Adapter
+         */
+        GoogleSatMapAdapter();
+        virtual ~GoogleSatMapAdapter();
+        virtual QPoint          coordinateToDisplay(const QPointF&) const;
+        virtual QPointF displayToCoordinate(const QPoint&) const;
+        //! returns the host of this MapAdapter
+        /*!
+         * @return  the host of this MapAdapter
+         */
+        QString getHost         () const;
+    protected:
+        virtual void zoom_in();
+        virtual void zoom_out();
+        virtual QString query(int x, int y, int z) const;
+        virtual bool isValid(int x, int y, int z) const;
+    private:
+        virtual QString getQ(qreal longitude, qreal latitude, int zoom) const;
+        qreal getMercatorLatitude(qreal YCoord) const;
+        qreal getMercatorYCoord(qreal lati) const;
+        qreal coord_per_x_tile;
+        qreal coord_per_y_tile;
+        int srvNum;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/gps_position.cpp
 ,0 → 1,33
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "gps_position.h"
+namespace qmapcontrol
+{
+    GPS_Position::GPS_Position(float time, float longitude, QString longitude_dir, float latitude, QString latitude_dir)
+        :time(time), longitude(longitude), latitude(latitude), longitude_dir(longitude_dir), latitude_dir(latitude_dir)
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/gps_position.h
 ,0 → 1,52
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef GPS_POSITION_H
+#define GPS_POSITION_H
+#include <QString>
+namespace qmapcontrol
+{
+    //! Represents a coordinate from a GPS receiver
+    /*!
+     * This class is used to represent a coordinate which has been parsed from a NMEA string.
+     * This is not fully integrated in the API. An example which uses this data type can be found under Samples.
+     * @author Kai Winter
+     */
+    class GPS_Position
+    {
+    public:
+        GPS_Position(float time, float longitude, QString longitude_dir, float latitude, QString latitude_dir);
+        float time; /*!< time of the string*/
+        float longitude; /*!< longitude coordinate*/
+        float latitude; /*!< latitude coordinate*/
+    private:
+        QString longitude_dir;
+        QString latitude_dir;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/imagemanager.cpp
 ,0 → 1,182
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "imagemanager.h"
+namespace qmapcontrol
+{
+    ImageManager* ImageManager::m_Instance = 0;
+    ImageManager::ImageManager(QObject* parent)
+        :QObject(parent), emptyPixmap(QPixmap(1,1)), net(new MapNetwork(this)), doPersistentCaching(false)
+    {
+        emptyPixmap.fill(Qt::transparent);
+        if (QPixmapCache::cacheLimit() <= 20000)
+        {
+            QPixmapCache::setCacheLimit(20000); // in kb
+        }
+    }
+    ImageManager::~ImageManager()
+    {
+        if (ImageManager::m_Instance != 0)
+        {
+            delete ImageManager::m_Instance;
+        }
+        delete net;
+    }
+    QPixmap ImageManager::getImage(const QString& host, const QString& url)
+    {
+        //qDebug() << "ImageManager::getImage";
+        QPixmap pm;
+        //pm.fill(Qt::black);
+        //is image cached (memory) or currently loading?
+        if (!QPixmapCache::find(url, pm) && !net->imageIsLoading(url))
+            //  if (!images.contains(url) && !net->imageIsLoading(url))
+        {
+            //image cached (persistent)?
+            if (doPersistentCaching && tileExist(url))
+            {
+                loadTile(url,pm);
+                QPixmapCache::insert(url.toAscii().toBase64(), pm);
+            }
+            else
+            {
+                //load from net, add empty image
+                net->loadImage(host, url);
+                //QPixmapCache::insert(url, emptyPixmap);
+                return emptyPixmap;
+            }
+        }
+        return pm;
+    }
+    QPixmap ImageManager::prefetchImage(const QString& host, const QString& url)
+    {
+#ifdef Q_WS_QWS
+        // on mobile devices we don´t want the display resfreshing when tiles are received which are
+        // prefetched... This is a performance issue, because mobile devices are very slow in
+        // repainting the screen
+        prefetch.append(url);
+#endif
+        return getImage(host, url);
+    }
+    void ImageManager::receivedImage(const QPixmap pixmap, const QString& url)
+    {
+        //qDebug() << "ImageManager::receivedImage";
+        QPixmapCache::insert(url, pixmap);
+        //images[url] = pixmap;
+        // needed?
+        if (doPersistentCaching && !tileExist(url) )
+            saveTile(url,pixmap);
+        //((Layer*)this->parent())->imageReceived();
+        if (!prefetch.contains(url))
+        {
+            emit(imageReceived());
+        }
+        else
+        {
+#ifdef Q_WS_QWS
+            prefetch.remove(prefetch.indexOf(url));
+#endif
+        }
+    }
+    void ImageManager::loadingQueueEmpty()
+    {
+        emit(loadingFinished());
+        //((Layer*)this->parent())->removeZoomImage();
+        //qDebug() << "size of image-map: " << images.size();
+        //qDebug() << "size: " << QPixmapCache::cacheLimit();
+    }
+    void ImageManager::abortLoading()
+    {
+        net->abortLoading();
+    }
+    void ImageManager::setProxy(QString host, int port)
+    {
+        net->setProxy(host, port);
+    }
+    void ImageManager::setCacheDir(const QDir& path)
+    {
+        doPersistentCaching = true;
+        cacheDir = path;
+        if (!cacheDir.exists())
+        {
+            cacheDir.mkpath(cacheDir.absolutePath());
+        }
+    }
+    bool ImageManager::saveTile(QString tileName,QPixmap tileData)
+    {
+        tileName.replace("/","-");
+        QFile file(cacheDir.absolutePath() + "/" + tileName.toAscii().toBase64());
+        //qDebug() << "writing: " << file.fileName();
+        if (!file.open(QIODevice::ReadWrite )){
+            qDebug()<<"error reading file";
+            return false;
+        }
+        QByteArray bytes;
+        QBuffer buffer(&bytes);
+        buffer.open(QIODevice::WriteOnly);
+        tileData.save(&buffer, "PNG");
+        file.write(bytes);
+        file.close();
+        return true;
+    }
+    bool ImageManager::loadTile(QString tileName,QPixmap &tileData)
+    {
+        tileName.replace("/","-");
+        QFile file(cacheDir.absolutePath() + "/" + tileName.toAscii().toBase64());
+        if (!file.open(QIODevice::ReadOnly )) {
+            return false;
+        }
+        tileData.loadFromData( file.readAll() );
+        file.close();
+        return true;
+    }
+    bool ImageManager::tileExist(QString tileName)
+    {
+        tileName.replace("/","-");
+        QFile file(cacheDir.absolutePath() + "/" + tileName.toAscii().toBase64());
+        if (file.exists())
+            return true;
+        else
+            return false;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/imagemanager.h
 ,0 → 1,125
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef IMAGEMANAGER_H
+#define IMAGEMANAGER_H
+#include <QObject>
+#include <QPixmapCache>
+#include <QDebug>
+#include <QMutex>
+#include <QFile>
+#include <QBuffer>
+#include <QDir>
+#include "mapnetwork.h"
+namespace qmapcontrol
+{
+    class MapNetwork;
+    /**
+    @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class ImageManager : public QObject
+    {
+        Q_OBJECT;
+    public:
+        static ImageManager* instance()
+        {
+            if(!m_Instance)
+            {
+                m_Instance = new ImageManager;
+            }
+            return m_Instance;
+        }
+        ~ImageManager();
+        //! returns a QPixmap of the asked image
+        /*!
+         * If this component doesn´t have the image a network query gets started to load it.
+         * @param host the host of the image
+         * @param path the path to the image
+         * @return the pixmap of the asked image
+         */
+        QPixmap getImage(const QString& host, const QString& path);
+        QPixmap prefetchImage(const QString& host, const QString& path);
+        void receivedImage(const QPixmap pixmap, const QString& url);
+        /*!
+         * This method is called by MapNetwork, after all images in its queue were loaded.
+         * The ImageManager emits a signal, which is used in MapControl to remove the zoom image.
+         * The zoom image should be removed on Tile Images with transparency.
+         * Else the zoom image stay visible behind the newly loaded tiles.
+         */
+        void loadingQueueEmpty();
+        /*!
+         * Aborts all current loading threads.
+         * This is useful when changing the zoom-factor, though newly needed images loads faster
+         */
+        void abortLoading();
+        //! sets the proxy for HTTP connections
+        /*!
+         * This method sets the proxy for HTTP connections.
+         * This is not provided by the current Qtopia version!
+         * @param host the proxy´s hostname or ip
+         * @param port the proxy´s port
+         */
+        void setProxy(QString host, int port);
+        //! sets the cache directory for persistently saving map tiles
+        /*!
+         *
+         * @param path the path where map tiles should be stored
+         * @todo add maximum size
+         */
+        void setCacheDir(const QDir& path);
+    private:
+        ImageManager(QObject* parent = 0);
+        ImageManager(const ImageManager&);
+        ImageManager& operator=(const ImageManager&);
+        QPixmap emptyPixmap;
+        MapNetwork* net;
+        QVector<QString> prefetch;
+        QDir cacheDir;
+        bool doPersistentCaching;
+        static ImageManager* m_Instance;
+        bool saveTile(QString tileName,QPixmap tileData);
+        bool loadTile(QString tileName,QPixmap &tileData);
+        bool tileExist(QString tileName);
+    signals:
+        void imageReceived();
+        void loadingFinished();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/imagepoint.cpp
 ,0 → 1,49
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "imagepoint.h"
+namespace qmapcontrol
+{
+    ImagePoint::ImagePoint(qreal x, qreal y, QString filename, QString name, Alignment alignment)
+        : Point(x, y, name, alignment)
+    {
+        //qDebug() << "loading image: " << filename;
+        mypixmap = new QPixmap(filename);
+        size = mypixmap->size();
+        //qDebug() << "image size: " << size;
+    }
+    ImagePoint::ImagePoint(qreal x, qreal y, QPixmap* pixmap, QString name, Alignment alignment)
+        : Point(x, y, name, alignment)
+    {
+        mypixmap = pixmap;
+        size = mypixmap->size();
+    }
+    ImagePoint::~ImagePoint()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/imagepoint.h
 ,0 → 1,70
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef IMAGEPOINT_H
+#define IMAGEPOINT_H
+#include "point.h"
+namespace qmapcontrol
+{
+    //! Draws an image into the map
+    /*! This is a convenience class for Point.
+     * It configures the pixmap of a Point to draw the given image.
+     * The image will be loaded from the given path and written in the points pixmap.
+     *
+     * @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class ImagePoint : public Point
+    {
+    public:
+        //! Creates a point which loads and displays the given image file
+        /*!
+         * Use this contructor to load the given image file and let the point display it.
+         * When you want multiple points to display the same image, use the other contructor and pass a pointer to that image.
+         * @param x longitude
+         * @param y latitude
+         * @param filename the file which should be loaded and displayed
+         * @param name the name of the image point
+         * @param alignment alignment (Middle or TopLeft)
+         */
+        ImagePoint(qreal x, qreal y, QString filename, QString name = QString(), Alignment alignment = Middle);
+        //! Creates a point which displays the given image
+        /*!
+         * Use this contructor to display the given image.
+         * You have to load that image yourself, but can use it for multiple points.
+         * @param x longitude
+         * @param y latitude
+         * @param pixmap pointer to the image pixmap
+         * @param name the name of the image point
+         * @param alignment alignment (Middle or TopLeft)
+         */
+        ImagePoint(qreal x, qreal y, QPixmap* pixmap, QString name = QString(), Alignment alignment = Middle);
+        virtual ~ImagePoint();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/layer.cpp
 ,0 → 1,307
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "layer.h"
+namespace qmapcontrol
+{
+    Layer::Layer(QString layername, MapAdapter* mapadapter, enum LayerType layertype, bool takeevents)
+        :visible(true), mylayername(layername), mylayertype(layertype), mapAdapter(mapadapter), takeevents(takeevents), myoffscreenViewport(QRect(0,0,0,0))
+    {
+        //qDebug() << "creating new Layer: " << layername << ", type: " << contents;
+        //qDebug() << this->layertype;
+    }
+    Layer::~Layer()
+    {
+        delete mapAdapter;
+    }
+    void Layer::setSize(QSize size)
+    {
+        this->size = size;
+        screenmiddle = QPoint(size.width()/2, size.height()/2);
+        //QMatrix mat;
+        //mat.translate(480/2, 640/2);
+        //mat.rotate(45);
+        //mat.translate(-480/2,-640/2);
+        //screenmiddle = mat.map(screenmiddle);
+    }
+    QString Layer::layername() const
+    {
+        return mylayername;
+    }
+    const MapAdapter* Layer::mapadapter() const
+    {
+        return mapAdapter;
+    }
+    void Layer::setVisible(bool visible)
+    {
+        this->visible = visible;
+        emit(updateRequest());
+    }
+    void Layer::addGeometry(Geometry* geom)
+    {
+        //qDebug() << geom->getName() << ", " << geom->getPoints().at(0)->getWidget();
+        geometries.append(geom);
+        emit(updateRequest(geom->boundingBox()));
+        //a geometry can request a redraw, e.g. when its position has been changed
+        connect(geom, SIGNAL(updateRequest(QRectF)),
+                this, SIGNAL(updateRequest(QRectF)));
+    }
+    void Layer::removeGeometry(Geometry* geometry)
+    {
+        for (int i=0; i<geometries.count(); i++)
+        {
+            if (geometry == geometries.at(i))
+            {
+                disconnect(geometry);
+                geometries.removeAt(i);
+                //delete geometry;
+            }
+        }
+    }
+    void Layer::clearGeometries()
+    {
+        foreach(Geometry *geometry, geometries){
+            disconnect(geometry);
+        }
+        geometries.clear();
+    }
+    bool Layer::isVisible() const
+    {
+        return visible;
+    }
+    void Layer::zoomIn() const
+    {
+        mapAdapter->zoom_in();
+    }
+    void Layer::zoomOut() const
+    {
+        mapAdapter->zoom_out();
+    }
+    void Layer::mouseEvent(const QMouseEvent* evnt, const QPoint mapmiddle_px)
+    {
+        if (takesMouseEvents())
+        {
+            if (evnt->button() == Qt::LeftButton && evnt->type() == QEvent::MouseButtonPress)
+            {
+                // check for collision
+                QPointF c = mapAdapter->displayToCoordinate(QPoint(evnt->x()-screenmiddle.x()+mapmiddle_px.x(),
+                                                                   evnt->y()-screenmiddle.y()+mapmiddle_px.y()));
+                Point* tmppoint = new Point(c.x(), c.y());
+                for (int i=0; i<geometries.count(); i++)
+                {
+                    if (geometries.at(i)->isVisible() && geometries.at(i)->Touches(tmppoint, mapAdapter))
+                        //if (geometries.at(i)->Touches(c, mapAdapter))
+                    {
+                        emit(geometryClicked(geometries.at(i), QPoint(evnt->x(), evnt->y())));
+                    }
+                }
+                delete tmppoint;
+            }
+        }
+    }
+    bool Layer::takesMouseEvents() const
+    {
+        return takeevents;
+    }
+    void Layer::drawYourImage(QPainter* painter, const QPoint mapmiddle_px) const
+    {
+        if (mylayertype == MapLayer)
+        {
+            //qDebug() << ":: " << mapmiddle_px;
+            //QMatrix mat;
+            //mat.translate(480/2, 640/2);
+            //mat.rotate(45);
+            //mat.translate(-480/2,-640/2);
+            //mapmiddle_px = mat.map(mapmiddle_px);
+            //qDebug() << ":: " << mapmiddle_px;
+            _draw(painter, mapmiddle_px);
+        }
+        drawYourGeometries(painter, QPoint(mapmiddle_px.x()-screenmiddle.x(), mapmiddle_px.y()-screenmiddle.y()), myoffscreenViewport);
+    }
+    void Layer::drawYourGeometries(QPainter* painter, const QPoint mapmiddle_px, QRect viewport) const
+    {
+        QPoint offset;
+        if (mylayertype == MapLayer)
+            offset = mapmiddle_px;
+        else
+            offset = mapmiddle_px-screenmiddle;
+        painter->translate(-mapmiddle_px+screenmiddle);
+        for (int i=0; i<geometries.count(); i++)
+        {
+            geometries.at(i)->draw(painter, mapAdapter, viewport, offset);
+        }
+        painter->translate(mapmiddle_px-screenmiddle);
+    }
+    void Layer::_draw(QPainter* painter, const QPoint mapmiddle_px) const
+    {
+        // screen middle rotieren...
+        int tilesize = mapAdapter->tilesize();
+        int cross_x = int(mapmiddle_px.x())%tilesize; // position on middle tile
+        int cross_y = int(mapmiddle_px.y())%tilesize;
+        //qDebug() << screenmiddle << " - " << cross_x << ", " << cross_y;
+        // calculate how many surrounding tiles have to be drawn to fill the display
+        int space_left = screenmiddle.x() - cross_x;
+        int tiles_left = space_left/tilesize;
+        if (space_left>0)
+            tiles_left+=1;
+        int space_above = screenmiddle.y() - cross_y;
+        int tiles_above = space_above/tilesize;
+        if (space_above>0)
+            tiles_above+=1;
+        int space_right = screenmiddle.x() - (tilesize-cross_x);
+        int tiles_right = space_right/tilesize;
+        if (space_right>0)
+            tiles_right+=1;
+        int space_bottom = screenmiddle.y() - (tilesize-cross_y);
+        int tiles_bottom = space_bottom/tilesize;
+        if (space_bottom>0)
+            tiles_bottom+=1;
+        //int tiles_displayed = 0;
+        int mapmiddle_tile_x = mapmiddle_px.x()/tilesize;
+        int mapmiddle_tile_y = mapmiddle_px.y()/tilesize;
+        const QPoint from = QPoint((-tiles_left+mapmiddle_tile_x)*tilesize, (-tiles_above+mapmiddle_tile_y)*tilesize);
+        const QPoint to = QPoint((tiles_right+mapmiddle_tile_x+1)*tilesize, (tiles_bottom+mapmiddle_tile_y+1)*tilesize);
+        myoffscreenViewport = QRect(from, to);
+        // for the EmptyMapAdapter no tiles should be loaded and painted.
+        if (mapAdapter->host() == "")
+        {
+            return;
+        }
+        if (mapAdapter->isValid(mapmiddle_tile_x, mapmiddle_tile_y, mapAdapter->currentZoom()))
+        {
+            painter->drawPixmap(-cross_x+size.width(),
+                                -cross_y+size.height(),
+                                ImageManager::instance()->getImage(mapAdapter->host(), mapAdapter->query(mapmiddle_tile_x, mapmiddle_tile_y, mapAdapter->currentZoom())));
+        }
+        for (int i=-tiles_left+mapmiddle_tile_x; i<=tiles_right+mapmiddle_tile_x; i++)
+        {
+            for (int j=-tiles_above+mapmiddle_tile_y; j<=tiles_bottom+mapmiddle_tile_y; j++)
+            {
+                // check if image is valid
+                if (!(i==mapmiddle_tile_x && j==mapmiddle_tile_y))
+                    if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
+                    {
+                    painter->drawPixmap(((i-mapmiddle_tile_x)*tilesize)-cross_x+size.width(),
+                                        ((j-mapmiddle_tile_y)*tilesize)-cross_y+size.height(),
+                                        ImageManager::instance()->getImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom())));
+                    //if (QCoreApplication::hasPendingEvents())
+                    //  QCoreApplication::processEvents();
+                }
+            }
+        }
+        // PREFETCHING
+        int upper = mapmiddle_tile_y-tiles_above-1;
+        int right = mapmiddle_tile_x+tiles_right+1;
+        int left = mapmiddle_tile_x-tiles_right-1;
+        int lower = mapmiddle_tile_y+tiles_bottom+1;
+        int j = upper;
+        for (int i=left; i<=right; i++)
+        {
+            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
+                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
+        }
+        j = lower;
+        for (int i=left; i<=right; i++)
+        {
+            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
+                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
+        }
+        int i = left;
+        for (int j=upper+1; j<=lower-1; j++)
+        {
+            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
+                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
+        }
+        i = right;
+        for (int j=upper+1; j<=lower-1; j++)
+        {
+            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))
+                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));
+        }
+    }
+    QRect Layer::offscreenViewport() const
+    {
+        return myoffscreenViewport;
+    }
+    void Layer::moveWidgets(const QPoint mapmiddle_px) const
+    {
+        for (int i=0; i<geometries.count(); i++)
+        {
+            const Geometry* geom = geometries.at(i);
+            if (geom->GeometryType == "Point")
+            {
+                if (((Point*)geom)->widget()!=0)
+                {
+                    QPoint topleft_relative = QPoint(mapmiddle_px-screenmiddle);
+                    ((Point*)geom)->drawWidget(mapAdapter, topleft_relative);
+                }
+            }
+        }
+    }
+    Layer::LayerType Layer::layertype() const
+    {
+        return mylayertype;
+    }
+    void Layer::setMapAdapter(MapAdapter* mapadapter)
+    {
+        mapAdapter = mapadapter;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/layer.h
 ,0 → 1,182
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef LAYER_H
+#define LAYER_H
+#include <QObject>
+#include <QDebug>
+#include <QPainter>
+#include <QMouseEvent>
+#include "mapadapter.h"
+#include "layermanager.h"
+#include "geometry.h"
+#include "point.h"
+#include "wmsmapadapter.h"
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    //! Layer class
+    /*!
+     * There are two different layer types:
+     *  - MapLayer: Displays Maps, but also Geometries. The configuration for displaying maps have to be done in the MapAdapter
+     *  - GeometryLayer: Only displays Geometry objects.
+     *
+     * MapLayers also can display Geometry objects. The difference to the GeometryLayer is the repainting. Objects that are
+     * added to a MapLayer are "baken" on the map. This means, when you change it´s position for example the changes are
+     * not visible until a new offscreen image has been drawn. If you have "static" Geometries which won´t change their
+     * position this is fine. But if you want to change the objects position or pen you should use a GeometryLayer. Those
+     * are repainted immediately on changes.
+     * You can either use this class and give a layertype on creation or you can use the classes MapLayer and GeometryLayer.
+     *
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class Layer : public QObject
+    {
+        Q_OBJECT
+    public:
+        friend class LayerManager;
+        //! sets the type of a layer, see Layer class doc for further information
+        enum LayerType
+        {
+            MapLayer, /*!< uses the MapAdapter to display maps, only gets refreshed when a new offscreen image is needed */
+            GeometryLayer /*!< gets refreshed everytime when a geometry changes */
+        };
+        //! Layer constructor
+        /*!
+         * This is used to construct a layer.
+         *
+         * @param layername The name of the Layer
+         * @param mapadapter The MapAdapter which does coordinate translation and Query-String-Forming
+         * @param layertype The above explained LayerType
+         * @param takeevents Should the Layer receive MouseEvents? This is set to true by default. Setting it to false could
+         * be something like a "speed up hint"
+         */
+        Layer(QString layername, MapAdapter* mapadapter, enum LayerType layertype, bool takeevents=true);
+        virtual ~Layer();
+        //! returns the layer's name
+        /*!
+         * @return the name of this layer
+         */
+        QString layername() const;
+        //! returns the layer´s MapAdapter
+        /*!
+         * This method returns the MapAdapter of this Layer, which can be useful
+         * to do coordinate transformations.
+         * @return the MapAdapter which us used by this Layer
+         */
+        const MapAdapter* mapadapter() const;
+        //! adds a Geometry object to this Layer
+        /*!
+         * Please notice the different LayerTypes (MapLayer and GeometryLayer) and the differences
+         * @param  geometry the new Geometry
+         */
+        void addGeometry(Geometry* geometry);
+        //! removes the Geometry object from this Layer
+        /*!
+         * This method removes a Geometry object from this Layer.
+         */
+        void removeGeometry(Geometry* geometry);
+        //! removes all Geometry objects from this Layer
+        /*!
+         * This method removes all Geometry objects from this Layer.
+         */
+        void clearGeometries();
+        //! return true if the layer is visible
+        /*!
+         * @return if the layer is visible
+         */
+        bool isVisible() const;
+        //! returns the LayerType of the Layer
+        /*!
+         * There are two LayerTypes: MapLayer and GeometryLayer
+         * @return the LayerType of this Layer
+         */
+        Layer::LayerType layertype() const;
+        void setMapAdapter(MapAdapter* mapadapter);
+        Layer& operator=(const Layer& rhs);
+        Layer(const Layer& old);
+    private:
+        void moveWidgets(const QPoint mapmiddle_px) const;
+        void drawYourImage(QPainter* painter, const QPoint mapmiddle_px) const;
+        void drawYourGeometries(QPainter* painter, const QPoint mapmiddle_px, QRect viewport) const;
+        void setSize(QSize size);
+        QRect offscreenViewport() const;
+        bool takesMouseEvents() const;
+        void mouseEvent(const QMouseEvent*, const QPoint mapmiddle_px);
+        void zoomIn() const;
+        void zoomOut() const;
+        void _draw(QPainter* painter, const QPoint mapmiddle_px) const;
+        bool visible;
+        QString mylayername;
+        LayerType mylayertype;
+        QSize size;
+        QPoint screenmiddle;
+        QList<Geometry*> geometries;
+        MapAdapter* mapAdapter;
+        bool takeevents;
+        mutable QRect myoffscreenViewport;
+    signals:
+        //! This signal is emitted when a Geometry is clicked
+        /*!
+         * A Geometry is clickable, if the containing layer is clickable.
+         * The layer emits a signal for every clicked geometry
+         * @param  geometry The clicked Geometry
+         * @param  point The coordinate (in widget coordinates) of the click
+         */
+        void geometryClicked(Geometry* geometry, QPoint point);
+        void updateRequest(QRectF rect);
+        void updateRequest();
+    public slots:
+        //! if visible is true, the layer is made visible
+        /*!
+         * @param  visible if the layer should be visible
+         */
+        void setVisible(bool visible);
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/layermanager.cpp
 ,0 → 1,456
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "layermanager.h"
+namespace qmapcontrol
+{
+    LayerManager::LayerManager(MapControl* mapcontrol, QSize size)
+        :mapcontrol(mapcontrol), scroll(QPoint(0,0)), size(size), whilenewscroll(QPoint(0,0))
+    {
+        // genauer berechnen?
+        offSize = size *2;
+        composedOffscreenImage = QPixmap(offSize);
+        composedOffscreenImage2 = QPixmap(offSize);
+        zoomImage = QPixmap(size);
+        zoomImage.fill(Qt::white);
+        screenmiddle = QPoint(size.width()/2, size.height()/2);
+    }
+    LayerManager::~LayerManager()
+    {
+        mylayers.clear();
+    }
+    QPointF LayerManager::currentCoordinate() const
+    {
+        return mapmiddle;
+    }
+    QPixmap LayerManager::getImage() const
+    {
+        return composedOffscreenImage;
+    }
+    Layer* LayerManager::layer() const
+    {
+        Q_ASSERT_X(mylayers.size()>0, "LayerManager::getLayer()", "No layers were added!");
+        return mylayers.first();
+    }
+    Layer* LayerManager::layer(const QString& layername) const
+    {
+        QListIterator<Layer*> layerit(mylayers);
+        while (layerit.hasNext())
+        {
+            Layer* l = layerit.next();
+            if (l->layername() == layername)
+                return l;
+        }
+        return 0;
+    }
+    QList<QString> LayerManager::layers() const
+    {
+        QList<QString> keys;
+        QListIterator<Layer*> layerit(mylayers);
+        while (layerit.hasNext())
+        {
+            keys.append(layerit.next()->layername());
+        }
+        return keys;
+    }
+    void LayerManager::scrollView(const QPoint& point)
+    {
+        scroll += point;
+        zoomImageScroll+=point;
+        mapmiddle_px += point;
+        mapmiddle = layer()->mapadapter()->displayToCoordinate(mapmiddle_px);
+        if (!checkOffscreen())
+        {
+            newOffscreenImage();
+        }
+        else
+        {
+            moveWidgets();
+        }
+    }
+    void LayerManager::moveWidgets()
+    {
+        QListIterator<Layer*> it(mylayers);
+        while (it.hasNext())
+        {
+            it.next()->moveWidgets(mapmiddle_px);
+        }
+    }
+    void LayerManager::setView(const QPointF& coordinate)
+    {
+        mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(coordinate);
+        mapmiddle = coordinate;
+        //TODO: muss wegen moveTo() raus
+        if (!checkOffscreen())
+        {
+            newOffscreenImage();
+        }
+        else
+        {
+            //TODO:
+            // verschiebung ausrechnen
+            // oder immer neues offscreenimage
+            newOffscreenImage();
+        }
+    }
+    void LayerManager::setView(QList<QPointF> coordinates)
+    {
+        setMiddle(coordinates);
+        // mapcontrol->update();
+    }
+    void LayerManager::setViewAndZoomIn(const QList<QPointF> coordinates)
+    {
+        while (containsAll(coordinates))
+        {
+            setMiddle(coordinates);
+            zoomIn();
+        }
+        if (!containsAll(coordinates))
+        {
+            zoomOut();
+        }
+        mapcontrol->update();
+    }
+    void LayerManager::setMiddle(QList<QPointF> coordinates)
+    {
+        int sum_x = 0;
+        int sum_y = 0;
+        for (int i=0; i<coordinates.size(); i++)
+        {
+            // mitte muss in px umgerechnet werden, da aufgrund der projektion die mittebestimmung aus koordinaten ungenau ist
+            QPoint p = layer()->mapadapter()->coordinateToDisplay(coordinates.at(i));
+            sum_x += p.x();
+            sum_y += p.y();
+        }
+        QPointF middle = layer()->mapadapter()->displayToCoordinate(QPoint(sum_x/coordinates.size(), sum_y/coordinates.size()));
+        // middle in px rechnen!
+        setView(middle);
+    }
+    bool LayerManager::containsAll(QList<QPointF> coordinates) const
+    {
+        QRectF bb = getViewport();
+        bool containsall = true;
+        for (int i=0; i<coordinates.size(); i++)
+        {
+            if (!bb.contains(coordinates.at(i)))
+                return false;
+        }
+        return containsall;
+    }
+    QPoint LayerManager::getMapmiddle_px() const
+    {
+        return mapmiddle_px;
+    }
+    QRectF LayerManager::getViewport() const
+    {
+        QPoint upperLeft = QPoint(mapmiddle_px.x()-screenmiddle.x(), mapmiddle_px.y()+screenmiddle.y());
+        QPoint lowerRight = QPoint(mapmiddle_px.x()+screenmiddle.x(), mapmiddle_px.y()-screenmiddle.y());
+        QPointF ulCoord = layer()->mapadapter()->displayToCoordinate(upperLeft);
+        QPointF lrCoord = layer()->mapadapter()->displayToCoordinate(lowerRight);
+        QRectF coordinateBB = QRectF(ulCoord, QSizeF( (lrCoord-ulCoord).x(), (lrCoord-ulCoord).y()));
+        return coordinateBB;
+    }
+    void LayerManager::addLayer(Layer* layer)
+    {
+        mylayers.append(layer);
+        layer->setSize(size);
+        connect(layer, SIGNAL(updateRequest(QRectF)),
+                this, SLOT(updateRequest(QRectF)));
+        connect(layer, SIGNAL(updateRequest()),
+                this, SLOT(updateRequest()));
+        if (mylayers.size()==1)
+        {
+            setView(QPointF(0,0));
+        }
+    }
+    void LayerManager::newOffscreenImage(bool clearImage, bool showZoomImage)
+    {
+        //      qDebug() << "LayerManager::newOffscreenImage()";
+        whilenewscroll = mapmiddle_px;
+        if (clearImage)
+        {
+            composedOffscreenImage2.fill(Qt::white);
+        }
+        QPainter painter(&composedOffscreenImage2);
+        if (showZoomImage)
+        {
+            painter.drawPixmap(screenmiddle.x()-zoomImageScroll.x(), screenmiddle.y()-zoomImageScroll.y(),zoomImage);
+        }
+        //only draw basemaps
+        for (int i=0; i<mylayers.count(); i++)
+        {
+            Layer* l = mylayers.at(i);
+            if (l->isVisible())
+            {
+                if (l->layertype() == Layer::MapLayer)
+                {
+                    l->drawYourImage(&painter, whilenewscroll);
+                }
+            }
+        }
+        composedOffscreenImage = composedOffscreenImage2;
+        scroll = mapmiddle_px-whilenewscroll;
+        mapcontrol->update();
+    }
+    void LayerManager::zoomIn()
+    {
+        QCoreApplication::processEvents();
+        ImageManager::instance()->abortLoading();
+        // layer rendern abbrechen?
+        zoomImageScroll = QPoint(0,0);
+        zoomImage.fill(Qt::white);
+        QPixmap tmpImg = composedOffscreenImage.copy(screenmiddle.x()+scroll.x(),screenmiddle.y()+scroll.y(), size.width(), size.height());
+        QPainter painter(&zoomImage);
+        painter.translate(screenmiddle);
+        painter.scale(2, 2);
+        painter.translate(-screenmiddle);
+        painter.drawPixmap(0,0,tmpImg);
+        QListIterator<Layer*> it(mylayers);
+        //TODO: remove hack, that mapadapters wont get set zoom multiple times
+        QList<const MapAdapter*> doneadapters;
+        while (it.hasNext())
+        {
+            Layer* l = it.next();
+            if (!doneadapters.contains(l->mapadapter()))
+            {
+                l->zoomIn();
+                doneadapters.append(l->mapadapter());
+            }
+        }
+        mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(mapmiddle);
+        whilenewscroll = mapmiddle_px;
+        newOffscreenImage();
+    }
+    bool LayerManager::checkOffscreen() const
+    {
+        // calculate offscreenImage dimension (px)
+        QPoint upperLeft = mapmiddle_px - screenmiddle;
+        QPoint lowerRight = mapmiddle_px + screenmiddle;
+        QRect viewport = QRect(upperLeft, lowerRight);
+        QRect testRect = layer()->offscreenViewport();
+        if (!testRect.contains(viewport))
+        {
+            return false;
+        }
+        return true;
+    }
+    void LayerManager::zoomOut()
+    {
+        QCoreApplication::processEvents();
+        ImageManager::instance()->abortLoading();
+        zoomImageScroll = QPoint(0,0);
+        zoomImage.fill(Qt::white);
+        QPixmap tmpImg = composedOffscreenImage.copy(screenmiddle.x()+scroll.x(),screenmiddle.y()+scroll.y(), size.width(), size.height());
+        QPainter painter(&zoomImage);
+        painter.translate(screenmiddle);
+        painter.scale(0.500001,0.500001);
+        painter.translate(-screenmiddle);
+        painter.drawPixmap(0,0,tmpImg);
+        painter.translate(screenmiddle);
+        painter.scale(2,2);
+        painter.translate(-screenmiddle);
+        QListIterator<Layer*> it(mylayers);
+        //TODO: remove hack, that mapadapters wont get set zoom multiple times
+        QList<const MapAdapter*> doneadapters;
+        while (it.hasNext())
+        {
+            Layer* l = it.next();
+            if (!doneadapters.contains(l->mapadapter()))
+            {
+                l->zoomOut();
+                doneadapters.append(l->mapadapter());
+            }
+        }
+        mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(mapmiddle);
+        whilenewscroll = mapmiddle_px;
+        newOffscreenImage();
+    }
+    void LayerManager::setZoom(int zoomlevel)
+    {
+        int current_zoom;
+        if (layer()->mapadapter()->minZoom() < layer()->mapadapter()->maxZoom())
+        {
+            current_zoom = layer()->mapadapter()->currentZoom();
+        }
+        else
+        {
+            current_zoom = layer()->mapadapter()->minZoom() - layer()->mapadapter()->currentZoom();
+        }
+        if (zoomlevel < current_zoom)
+        {
+            for (int i=current_zoom; i>zoomlevel; i--)
+            {
+                zoomOut();
+            }
+        }
+        else
+        {
+            for (int i=current_zoom; i<zoomlevel; i++)
+            {
+                zoomIn();
+            }
+        }
+    }
+    void LayerManager::mouseEvent(const QMouseEvent* evnt)
+    {
+        QListIterator<Layer*> it(mylayers);
+        while (it.hasNext())
+        {
+            Layer* l = it.next();
+            if (l->isVisible())
+            {
+                l->mouseEvent(evnt, mapmiddle_px);
+            }
+        }
+    }
+    void LayerManager::updateRequest(QRectF rect)
+    {
+        const QPoint topleft = mapmiddle_px - screenmiddle;
+        QPointF c = rect.topLeft();
+        if (getViewport().contains(c) || getViewport().contains(rect.bottomRight()))
+        {
+            // QPoint point = getLayer()->getMapAdapter()->coordinateToDisplay(c);
+            // QPoint finalpoint = point-topleft;
+            // QRect rect_px = QRect(int(finalpoint.x()-(rect.width()-1)/2), int(finalpoint.y()-(rect.height()-1)/2),
+            //  int(rect.width()+1), int(rect.height()+1));
+            //
+            // mapcontrol->updateRequest(rect_px);
+            mapcontrol->update();
+            // newOffscreenImage();
+        }
+    }
+    void LayerManager::updateRequest()
+    {
+        newOffscreenImage();
+    }
+    void LayerManager::forceRedraw()
+    {
+        newOffscreenImage();
+    }
+    void LayerManager::removeZoomImage()
+    {
+        zoomImage.fill(Qt::white);
+        forceRedraw();
+    }
+    void LayerManager::drawGeoms(QPainter* painter)
+    {
+        QListIterator<Layer*> it(mylayers);
+        while (it.hasNext())
+        {
+            Layer* l = it.next();
+            if (l->layertype() == Layer::GeometryLayer && l->isVisible())
+            {
+                l->drawYourGeometries(painter, mapmiddle_px, layer()->offscreenViewport());
+            }
+        }
+    }
+    void LayerManager::drawImage(QPainter* painter)
+    {
+        painter->drawPixmap(-scroll.x()-screenmiddle.x(),
+                            -scroll.y()-screenmiddle.y(),
+                            composedOffscreenImage);
+    }
+    int LayerManager::currentZoom() const
+    {
+        return layer()->mapadapter()->currentZoom();
+    }
+    void LayerManager::resize(QSize newSize)
+    {
+        size = newSize;
+        offSize = newSize *2;
+        composedOffscreenImage = QPixmap(offSize);
+        composedOffscreenImage2 = QPixmap(offSize);
+        zoomImage = QPixmap(newSize);
+        zoomImage.fill(Qt::white);
+        screenmiddle = QPoint(newSize.width()/2, newSize.height()/2);
+        QListIterator<Layer*> it(mylayers);
+        while (it.hasNext())
+        {
+            Layer* l = it.next();
+            l->setSize(newSize);
+        }
+        newOffscreenImage();
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/layermanager.h
 ,0 → 1,211
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef LAYERMANAGER_H
+#define LAYERMANAGER_H
+#include <QObject>
+#include <QMap>
+#include <QListIterator>
+#include "layer.h"
+#include "mapadapter.h"
+#include "mapcontrol.h"
+namespace qmapcontrol
+{
+    class Layer;
+    class MapAdapter;
+    class MapControl;
+    class LayerManager;
+    //! Handles Layers and viewport related settings
+    /*!
+     * This class handles internally all layers which were added to the MapControl.
+     * It also stores values for scrolling.
+     * It initiates the creation of a new offscreen image and on zooming the zoom images gets here created.
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class LayerManager : public QObject
+    {
+        Q_OBJECT
+    public:
+        LayerManager(MapControl*, QSize);
+        ~LayerManager();
+        //! returns the coordinate of the center of the map
+        /*!
+         * @return returns the coordinate of the middle of the screen
+         */
+        QPointF currentCoordinate() const;
+        //! returns the current offscreen image
+        /*!
+         * @return the current offscreen image
+         */
+        QPixmap getImage() const;
+        //! returns the layer with the given name
+        /*!
+         * @param  layername name of the wanted layer
+         * @return the layer with the given name
+         */
+        Layer* layer(const QString&) const;
+        //! returns the base layer
+        /*!
+         * This will return the base layer of the LayerManager.
+         * The base layer is the one which is used to do internal coordinate calculations.
+         * @return the base layer
+         */
+        Layer* layer() const;
+        //! returns the names of all layers
+        /*!
+         * @return returns a QList with the names of all layers
+         */
+        QList<QString> layers() const;
+        //! sets the middle of the map to the given coordinate
+        /*!
+         * @param  coordinate the coordinate which the view´s middle should be set to
+         */
+        void setView(const QPointF& coordinate);
+        //! sets the view, so all coordinates are visible
+        /*!
+         * @param  coordinates the Coorinates which should be visible
+         */
+        void setView(const QList<QPointF> coordinates);
+        //! sets the view and zooms in, so all coordinates are visible
+        /*!
+         * The code of setting the view to multiple coordinates is "brute force" and pretty slow.
+         * Have to be reworked.
+         * @param  coordinates the Coorinates which should be visible
+         */
+        void setViewAndZoomIn (const QList<QPointF> coordinates);
+        //! zooms in one step
+        void zoomIn();
+        //! zooms out one step
+        void zoomOut();
+        //! sets the given zoomlevel
+        /*!
+         * @param zoomlevel the zoomlevel
+         */
+        void setZoom(int zoomlevel);
+        //! The Viewport of the display
+        /*!
+         * Returns the visible viewport in world coordinates
+         * @return the visible viewport in world coordinates
+         */
+        QRectF getViewport() const;
+        //! scrolls the view
+        /*!
+         * Scrolls the view by the given value in pixels and in display coordinates
+         * @param  offset the distance which the view should be scrolled
+         */
+        void scrollView(const QPoint& offset);
+        //! forwards mouseevents to the layers
+        /*!
+         * This method is invoked by the MapControl which receives Mouse Events.
+         * These events are forwarded to the layers, so they can check for clicked geometries.
+         * @param  evnt the mouse event
+         */
+        void mouseEvent(const QMouseEvent* evnt);
+        //! returns the middle of the map in projection coordinates
+        /*!
+         *
+         * @return the middle of the map in projection coordinates
+         */
+        QPoint getMapmiddle_px() const;
+        void forceRedraw();
+        void removeZoomImage();
+        //! adds a layer
+        /*!
+         * If multiple layers are added, they are painted in the added order.
+         * @param layer the layer which should be added
+         */
+        void addLayer(Layer* layer);
+        //! returns the current zoom level
+        /*!
+         * @return returns the current zoom level
+         */
+        int currentZoom() const;
+        void drawGeoms(QPainter* painter);
+        void drawImage(QPainter* painter);
+    private:
+        LayerManager& operator=(const LayerManager& rhs);
+        LayerManager(const LayerManager& old);
+        //! This method have to be invoked to draw a new offscreen image
+        /*!
+         * @param clearImage if the current offscreeen image should be cleared
+         * @param showZoomImage if a zoom image should be painted
+         */
+        void newOffscreenImage(bool clearImage=true, bool showZoomImage=true);
+        inline bool checkOffscreen() const;
+        inline bool containsAll(QList<QPointF> coordinates) const;
+        inline void moveWidgets();
+        inline void setMiddle(QList<QPointF> coordinates);
+        MapControl* mapcontrol;
+        QPoint screenmiddle; // middle of the screen
+        QPoint scroll; // scrollvalue of the offscreen image
+        QPoint zoomImageScroll; // scrollvalue of the zoom image
+        QSize size; // widget size
+        QSize offSize; // size of the offscreen image
+        QPixmap composedOffscreenImage;
+        QPixmap composedOffscreenImage2;
+        QPixmap zoomImage;
+        QList<Layer*>   mylayers;
+        QPoint mapmiddle_px; // projection-display coordinates
+        QPointF mapmiddle; // world coordinate
+        QPoint whilenewscroll;
+    public slots:
+        void updateRequest(QRectF rect);
+        void updateRequest();
+        void resize(QSize newSize);
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/linestring.cpp
 ,0 → 1,170
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "linestring.h"
+namespace qmapcontrol
+{
+    LineString::LineString()
+        : Curve()
+    {
+        GeometryType = "LineString";
+    }
+    LineString::LineString(QList<Point*> const points, QString name, QPen* pen)
+        :Curve(name)
+    {
+        mypen = pen;
+        LineString();
+        setPoints(points);
+    }
+    LineString::~LineString()
+    {
+    }
+    // Geometry LineString::Clone(){}
+    // Point LineString::EndPoint(){}
+    // Point LineString::StartPoint(){}
+    // Point LineString::Value(){}
+    void LineString::addPoint(Point* point)
+    {
+        vertices.append(point);
+    }
+    QList<Point*> LineString::points()
+    {
+        return vertices;
+    }
+    void LineString::setPoints(QList<Point*> points)
+    {
+        for (int i=0; i<points.size(); i++)
+        {
+            points.at(i)->setParentGeometry(this);
+        }
+        vertices = points;
+    }
+    void LineString::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset)
+    {
+        if (!visible)
+            return;
+        QPolygon p = QPolygon();
+        QPointF c;
+        for (int i=0; i<vertices.size(); i++)
+        {
+            c = vertices[i]->coordinate();
+            p.append(mapadapter->coordinateToDisplay(c));
+        }
+        if (mypen != 0)
+        {
+            painter->save();
+            painter->setPen(*mypen);
+        }
+        painter->drawPolyline(p);
+        if (mypen != 0)
+        {
+            painter->restore();
+        }
+        for (int i=0; i<vertices.size(); i++)
+        {
+            vertices[i]->draw(painter, mapadapter, screensize, offset);
+        }
+    }
+    int LineString::numberOfPoints() const
+    {
+        return vertices.count();
+    }
+    bool LineString::Touches(Point* geom, const MapAdapter* mapadapter)
+    {
+        // qDebug() << "LineString::Touches Point";
+        touchedPoints.clear();
+        bool touches = false;
+        for (int i=0; i<vertices.count(); i++)
+        {
+            // use implementation from Point
+            if (vertices.at(i)->Touches(geom, mapadapter))
+            {
+                touchedPoints.append(vertices.at(i));
+                touches = true;
+            }
+        }
+        if (touches)
+        {
+            emit(geometryClicked(this, QPoint(0,0)));
+        }
+        return touches;
+    }
+    bool LineString::Touches(Geometry* /*geom*/, const MapAdapter* /*mapadapter*/)
+    {
+        // qDebug() << "LineString::Touches Geom";
+        touchedPoints.clear();
+        return false;
+    }
+    QList<Geometry*> LineString::clickedPoints()
+    {
+        return touchedPoints;
+    }
+    bool LineString::hasPoints() const
+    {
+        return vertices.size() > 0 ? true : false;
+    }
+    bool LineString::hasClickedPoints() const
+    {
+        return touchedPoints.size() > 0 ? true : false;
+    }
+    QRectF LineString::boundingBox()
+    {
+        qreal minlon=180;
+        qreal maxlon=-180;
+        qreal minlat=90;
+        qreal maxlat=-90;
+        for (int i=0; i<vertices.size(); i++)
+        {
+            Point* tmp = vertices.at(i);
+            if (tmp->longitude() < minlon) minlon = tmp->longitude();
+            if (tmp->longitude() > maxlon) maxlon = tmp->longitude();
+            if (tmp->latitude() < minlat) minlat = tmp->latitude();
+            if (tmp->latitude() > maxlat) maxlat = tmp->latitude();
+        }
+        QPointF min = QPointF(minlon, minlat);
+        QPointF max = QPointF(maxlon, maxlat);
+        QPointF dist = max - min;
+        QSizeF si = QSizeF(dist.x(), dist.y());
+        return QRectF(min, si);
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/linestring.h
 ,0 → 1,120
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef LINESTRING_H
+#define LINESTRING_H
+#include "curve.h"
+namespace qmapcontrol
+{
+    //! A collection of Point objects to describe a line
+    /*!
+     * A LineString is a Curve with linear interpolation between Points. Each consecutive pair of Points defines a Line segment.
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class LineString : public Curve
+    {
+        Q_OBJECT
+    public:
+        LineString();
+        //! constructor
+        /*!
+         * The constructor of a LineString takes a list of Points to form a line.
+         * @param points a list of points
+         * @param name the name of the LineString
+         * @param pen a QPen can be used to modify the look of the line.
+         * @see http://doc.trolltech.com/4.3/qpen.html
+         */
+        LineString ( QList<Point*> const points, QString name = QString(), QPen* pen = 0 );
+        virtual ~LineString();
+        //! returns the points of the LineString
+        /*!
+         * @return  a list with the points of the LineString
+         */
+        QList<Point*>   points();
+        //! adds a point at the end of the LineString
+        /*!
+         * @param point the point which should be added to the LineString
+         */
+        void addPoint ( Point* point );
+        //! sets the given list as points of the LineString
+        /*!
+         * @param points the points which should be set for the LineString
+         */
+        void setPoints ( QList<Point*> points );
+        //! returns the number of Points the LineString consists of
+        /*!
+         * @return the number of the LineStringÂ´s Points
+         */
+        int numberOfPoints() const;
+        // virtual Geometry     Clone();
+        virtual QRectF boundingBox();
+        // virtual Point EndPoint();
+        // virtual Point StartPoint();
+        // virtual Point Value();
+        //! returns true if the LineString has Childs
+        /*!
+         * This is equal to: numberOfPoints() > 0
+         * @return true it the LineString has Childs (=Points)
+         * @see clickedPoints()
+         */
+        virtual bool hasPoints() const;
+        //! returns true if the LineString has clicked Points
+        /*!
+         * @return true if childs of a LineString were clicked
+         * @see clickedPoints()
+         */
+        virtual bool hasClickedPoints() const;
+        //! returns the clicked Points
+        /*!
+         * If a LineString was clicked it could be neccessary to figure out which of its points where clicked.
+         * Do do so the methods hasPoints() and clickedPoints() can be used.
+         * When a point is added to a LineString the Point becomes its child.
+         * It is possible (depending on the zoomfactor) to click more than one Point of a LineString, so this method returns a list.
+         * @return the clicked Points of the LineString
+         */
+        virtual QList<Geometry*> clickedPoints();
+    protected:
+        virtual bool Touches ( Geometry* geom, const MapAdapter* mapadapter );
+        virtual bool Touches ( Point* geom, const MapAdapter* mapadapter );
+        virtual void draw ( QPainter* painter, const MapAdapter* mapadapter, const QRect &screensize, const QPoint offset );
+    private:
+        QList<Point*>   vertices;
+        QList<Geometry*>        touchedPoints;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/mapadapter.cpp
 ,0 → 1,69
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "mapadapter.h"
+namespace qmapcontrol
+{
+    MapAdapter::MapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom, int maxZoom)
+        :myhost(host), serverPath(serverPath), mytilesize(tilesize), min_zoom(minZoom), max_zoom(maxZoom)
+    {
+        current_zoom = min_zoom;
+        loc = QLocale(QLocale::English);
+    }
+    MapAdapter::~MapAdapter()
+    {
+    }
+    QString MapAdapter::host() const
+    {
+        return myhost;
+    }
+    int MapAdapter::tilesize() const
+    {
+        return mytilesize;
+    }
+    int MapAdapter::minZoom() const
+    {
+        return min_zoom;
+    }
+    int MapAdapter::maxZoom() const
+    {
+        return max_zoom;
+    }
+    int MapAdapter::currentZoom() const
+    {
+        return current_zoom;
+    }
+    int MapAdapter::adaptedZoom() const
+    {
+        return max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/mapadapter.h
 ,0 → 1,151
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef MAPADAPTER_H
+#define MAPADAPTER_H
+#include <QObject>
+#include <QSize>
+#include <QPoint>
+#include <QPointF>
+#include <QLocale>
+#include <QDebug>
+#include <cmath>
+namespace qmapcontrol
+{
+    //! Used to fit map servers into QMapControl
+    /*!
+     * MapAdapters are needed to convert between world- and display coordinates.
+     * This calculations depend on the used map projection.
+     * There are two ready-made MapAdapters:
+     *  - TileMapAdapter, which is ready to use for OpenStreetMap or Google (Mercator projection)
+     *  - WMSMapAdapter, which could be used for the most WMS-Server (some servers show errors, because of image ratio)
+     *
+     * MapAdapters are also needed to form the HTTP-Queries to load the map tiles.
+     * The maps from WMS Servers are also divided into tiles, because those can be better cached.
+     *
+     * @see TileMapAdapter, @see WMSMapAdapter
+     *
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class MapAdapter : public QObject
+    {
+        friend class Layer;
+        Q_OBJECT
+    public:
+        virtual ~MapAdapter();
+        //! returns the host of this MapAdapter
+        /*!
+         * @return  the host of this MapAdapter
+         */
+        QString host() const;
+        //! returns the size of the tiles
+        /*!
+         * @return the size of the tiles
+         */
+        int tilesize() const;
+        //! returns the min zoom value
+        /*!
+         * @return the min zoom value
+         */
+        int minZoom() const;
+        //! returns the max zoom value
+        /*!
+         * @return the max zoom value
+         */
+        int maxZoom() const;
+        //! returns the current zoom
+        /*!
+         * @return the current zoom
+         */
+        int currentZoom() const;
+        virtual int adaptedZoom()const;
+        //! translates a world coordinate to display coordinate
+        /*!
+         * The calculations also needs the current zoom. The current zoom is managed by the MapAdapter, so this is no problem.
+         * To divide model from view the current zoom should be moved to the layers.
+         * @param  coordinate the world coordinate
+         * @return the display coordinate (in widget coordinates)
+         */
+        virtual QPoint coordinateToDisplay(const QPointF& coordinate) const = 0;
+        //! translates display coordinate to world coordinate
+        /*!
+         * The calculations also needs the current zoom. The current zoom is managed by the MapAdapter, so this is no problem.
+         * To divide model from view the current zoom should be moved to the layers.
+         * @param  point the display coordinate
+         * @return the world coordinate
+         */
+        virtual QPointF displayToCoordinate(const QPoint& point) const = 0;
+    protected:
+        MapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom = 0, int maxZoom = 0);
+        virtual void zoom_in() = 0;
+        virtual void zoom_out() = 0;
+        virtual bool isValid(int x, int y, int z) const = 0;
+        virtual QString query(int x, int y, int z) const = 0;
+        QSize   size;
+        QString myhost;
+        QString serverPath;
+        int mytilesize;
+        int min_zoom;
+        int max_zoom;
+        int current_zoom;
+        int param1;
+        int param2;
+        int param3;
+        int param4;
+        int param5;
+        int param6;
+        QString sub1;
+        QString sub2;
+        QString sub3;
+        QString sub4;
+        QString sub5;
+        QString sub6;
+        int order[3][2];
+        int middle_x;
+        int middle_y;
+        qreal numberOfTiles;
+        QLocale loc;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/mapcontrol.cpp
 ,0 → 1,414
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "mapcontrol.h"
+namespace qmapcontrol
+{
+    MapControl::MapControl(QSize size, MouseMode mousemode)
+        : size(size), mymousemode(mousemode), scaleVisible(false)
+    {
+        layermanager = new LayerManager(this, size);
+        screen_middle = QPoint(size.width()/2, size.height()/2);
+        mousepressed = false;
+        connect(ImageManager::instance(), SIGNAL(imageReceived()),
+                this, SLOT(updateRequestNew()));
+        connect(ImageManager::instance(), SIGNAL(loadingFinished()),
+                this, SLOT(loadingFinished()));
+        this->setMaximumSize(size.width()+1, size.height()+1);
+    }
+    MapControl::~MapControl()
+    {
+        delete layermanager;
+    }
+    QPointF MapControl::currentCoordinate() const
+    {
+        return layermanager->currentCoordinate();
+    }
+    Layer* MapControl::layer(const QString& layername) const
+    {
+        return layermanager->layer(layername);
+    }
+    QList<QString> MapControl::layers() const
+    {
+        return layermanager->layers();
+    }
+    int MapControl::numberOfLayers() const
+    {
+        return layermanager->layers().size();
+    }
+    void MapControl::followGeometry(const Geometry* geom) const
+    {
+        connect(geom, SIGNAL(positionChanged(Geometry*)),
+                this, SLOT(positionChanged(Geometry*)));
+    }
+    void MapControl::positionChanged(Geometry* geom)
+    {
+        QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
+        QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(((Point*)geom)->coordinate());
+        QPoint step = (dest-start);
+        layermanager->scrollView(step);
+        // setView(geom);
+        update();
+    }
+    void MapControl::moveTo(QPointF coordinate)
+    {
+        target = coordinate;
+        steps = 25;
+        if (moveMutex.tryLock())
+        {
+            QTimer::singleShot(40, this, SLOT(tick()));
+        }
+        else
+        {
+            // stopMove(coordinate);
+        }
+    }
+    void MapControl::tick()
+    {
+        QPoint start = layermanager->layer()->mapadapter()->coordinateToDisplay(currentCoordinate());
+        QPoint dest = layermanager->layer()->mapadapter()->coordinateToDisplay(target);
+        QPoint step = (dest-start)/steps;
+        QPointF next = currentCoordinate()- step;
+        // setView(Coordinate(next.x(), next.y()));
+        layermanager->scrollView(step);
+        update();
+        steps--;
+        if (steps>0)
+        {
+            QTimer::singleShot(40, this, SLOT(tick()));
+        }
+        else
+        {
+            moveMutex.unlock();
+        }
+    }
+    void MapControl::paintEvent(QPaintEvent* evnt)
+    {
+        QWidget::paintEvent(evnt);
+        QPainter painter(this);
+        // painter.translate(150,190);
+        // painter.scale(0.5,0.5);
+        // painter.setClipRect(0,0, size.width(), size.height());
+        // painter.setViewport(10000000000,0,size.width(),size.height());
+        /*
+        // rotating
+            rotation = 45;
+            painter.translate(256,256);
+            painter.rotate(rotation);
+            painter.translate(-256,-256);
+        */
+        layermanager->drawImage(&painter);
+        layermanager->drawGeoms(&painter);
+        // added by wolf
+        // draw scale
+        if (scaleVisible)
+        {
+            QList<double> distanceList;
+            distanceList<<5000000<<2000000<<1000000<<1000000<<1000000<<100000<<100000<<50000<<50000<<10000<<10000<<10000<<1000<<1000<<500<<200<<100<<50<<25;
+            if (currentZoom() >= 0 && distanceList.size() > currentZoom())
+            {
+                double line;
+                line = distanceList.at( currentZoom() ) / pow(2, 18-currentZoom() ) / 0.597164;
+                // draw the scale
+                painter.setPen(Qt::black);
+                QPoint p1(10,size.height()-20);
+                QPoint p2((int)line,size.height()-20);
+                painter.drawLine(p1,p2);
+                painter.drawLine(10,size.height()-15, 10,size.height()-25);
+                painter.drawLine((int)line,size.height()-15, (int)line,size.height()-25);
+                QString distance;
+                if (distanceList.at(currentZoom()) >= 1000)
+                {
+                    distance = QVariant( distanceList.at(currentZoom())/1000 )  .toString()+ " km";
+                }
+                else
+                {
+                    distance = QVariant( distanceList.at(currentZoom()) ).toString() + " m";
+                }
+                painter.drawText(QPoint((int)line+10,size.height()-15), distance);
+            }
+        }
+        painter.drawLine(screen_middle.x(), screen_middle.y()-10,
+                         screen_middle.x(), screen_middle.y()+10); // |
+        painter.drawLine(screen_middle.x()-10, screen_middle.y(),
+                         screen_middle.x()+10, screen_middle.y()); // -
+        // int cross_x = int(layermanager->getMapmiddle_px().x())%256;
+        // int cross_y = int(layermanager->getMapmiddle_px().y())%256;
+        // painter.drawLine(screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+0,
+        //   screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+256); // |
+        // painter.drawLine(screen_middle.x()-cross_x+0, screen_middle.y()-cross_y+cross_y,
+        //   screen_middle.x()-cross_x+256, screen_middle.y()-cross_y+cross_y); // -
+        painter.drawRect(0,0, size.width(), size.height());
+        /*
+        // rotating
+          painter.setMatrix(painter.matrix().inverted());
+        //qt = painter.transform();
+           qm = painter.combinedMatrix();
+        */
+        if (mousepressed && mymousemode == Dragging)
+        {
+            QRect rect = QRect(pre_click_px, current_mouse_pos);
+            painter.drawRect(rect);
+        }
+        emit viewChanged(currentCoordinate(), currentZoom());
+    }
+    // mouse events
+    void MapControl::mousePressEvent(QMouseEvent* evnt)
+    {
+        //rotating (experimental)
+        // QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
+        // evnt = me;
+        // qDebug() << "evnt: " << evnt->x() << ", " << evnt->y() << ", " << evnt->pos();
+        layermanager->mouseEvent(evnt);
+        if (layermanager->layers().size()>0)
+        {
+            if (evnt->button() == 1)
+            {
+                mousepressed = true;
+                pre_click_px = QPoint(evnt->x(), evnt->y());
+            }
+            else if (evnt->button() == 2 && mymousemode != None) // zoom in
+            {
+                zoomIn();
+            } else if  (evnt->button() == 4 && mymousemode != None) // zoom out
+            {
+                zoomOut();
+            }
+        }
+        // emit(mouseEvent(evnt));
+        emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
+    }
+    void MapControl::mouseReleaseEvent(QMouseEvent* evnt)
+    {
+        mousepressed = false;
+        if (mymousemode == Dragging)
+        {
+            QPointF ulCoord = clickToWorldCoordinate(pre_click_px);
+            QPointF lrCoord = clickToWorldCoordinate(current_mouse_pos);
+            QRectF coordinateBB = QRectF(ulCoord, QSizeF( (lrCoord-ulCoord).x(), (lrCoord-ulCoord).y()));
+            emit(boxDragged(coordinateBB));
+        }
+        emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
+    }
+    void MapControl::mouseMoveEvent(QMouseEvent* evnt)
+    {
+        // emit(mouseEvent(evnt));
+        /*
+        // rotating
+           QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
+           evnt = me;
+        */
+        if (mousepressed && mymousemode == Panning)
+        {
+            QPoint offset = pre_click_px - QPoint(evnt->x(), evnt->y());
+            layermanager->scrollView(offset);
+            pre_click_px = QPoint(evnt->x(), evnt->y());
+        }
+        else if (mousepressed && mymousemode == Dragging)
+        {
+            current_mouse_pos = QPoint(evnt->x(), evnt->y());
+        }
+        // emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
+        update();
+        // emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
+    }
+    QPointF MapControl::clickToWorldCoordinate(QPoint click)
+    {
+        // click coordinate to image coordinate
+        QPoint displayToImage= QPoint(click.x()-screen_middle.x()+layermanager->getMapmiddle_px().x(),
+                                      click.y()-screen_middle.y()+layermanager->getMapmiddle_px().y());
+        // image coordinate to world coordinate
+        return layermanager->layer()->mapadapter()->displayToCoordinate(displayToImage);
+    }
+    void MapControl::updateRequest(QRect rect)
+    {
+        update(rect);
+    }
+    void MapControl::updateRequestNew()
+    {
+        // qDebug() << "MapControl::updateRequestNew()";
+        layermanager->forceRedraw();
+        update();
+    }
+    // slots
+    void MapControl::zoomIn()
+    {
+        layermanager->zoomIn();
+        update();
+    }
+    void MapControl::zoomOut()
+    {
+        layermanager->zoomOut();
+        update();
+    }
+    void MapControl::setZoom(int zoomlevel)
+    {
+        layermanager->setZoom(zoomlevel);
+        update();
+    }
+    int MapControl::currentZoom() const
+    {
+        return layermanager->currentZoom();
+    }
+    void MapControl::scrollLeft(int pixel)
+    {
+        layermanager->scrollView(QPoint(-pixel,0));
+        update();
+    }
+    void MapControl::scrollRight(int pixel)
+    {
+        layermanager->scrollView(QPoint(pixel,0));
+        update();
+    }
+    void MapControl::scrollUp(int pixel)
+    {
+        layermanager->scrollView(QPoint(0,-pixel));
+        update();
+    }
+    void MapControl::scrollDown(int pixel)
+    {
+        layermanager->scrollView(QPoint(0,pixel));
+        update();
+    }
+    void MapControl::scroll(const QPoint scroll)
+    {
+        layermanager->scrollView(scroll);
+        update();
+    }
+    void MapControl::setView(const QPointF& coordinate) const
+    {
+        layermanager->setView(coordinate);
+    }
+    void MapControl::setView(const QList<QPointF> coordinates) const
+    {
+        layermanager->setView(coordinates);
+    }
+    void MapControl::setViewAndZoomIn(const QList<QPointF> coordinates) const
+    {
+        layermanager->setViewAndZoomIn(coordinates);
+    }
+    void MapControl::setView(const Point* point) const
+    {
+        layermanager->setView(point->coordinate());
+    }
+    void MapControl::loadingFinished()
+    {
+        // qDebug() << "MapControl::loadingFinished()";
+        layermanager->removeZoomImage();
+    }
+    void MapControl::addLayer(Layer* layer)
+    {
+        layermanager->addLayer(layer);
+    }
+    void MapControl::setMouseMode(MouseMode mousemode)
+    {
+        mymousemode = mousemode;
+    }
+    MapControl::MouseMode MapControl::mouseMode()
+    {
+        return mymousemode;
+    }
+    void MapControl::stopFollowing(Geometry* geom)
+    {
+        geom->disconnect(SIGNAL(positionChanged(Geometry*)));
+    }
+    void MapControl::enablePersistentCache(const QDir& path)
+    {
+        ImageManager::instance()->setCacheDir(path);
+    }
+    void MapControl::setProxy(QString host, int port)
+    {
+        ImageManager::instance()->setProxy(host, port);
+    }
+    void MapControl::showScale(bool show)
+    {
+        scaleVisible = show;
+    }
+    void MapControl::resize(const QSize newSize)
+    {
+        this->size = newSize;
+        screen_middle = QPoint(newSize.width()/2, newSize.height()/2);
+        this->setMaximumSize(newSize.width()+1, newSize.height()+1);
+        layermanager->resize(newSize);
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/mapcontrol.h
 ,0 → 1,333
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef MAPCONTROL_H
+#define MAPCONTROL_H
+#include <QtGui>
+#include "layermanager.h"
+#include "layer.h"
+#include "mapadapter.h"
+#include "geometry.h"
+#include "imagemanager.h"
+//! QMapControl namespace
+namespace qmapcontrol
+{
+    class LayerManager;
+    class MapAdapter;
+    class Layer;
+    //! The control element of the widget and also the widget itself
+    /*!
+     * This is the main widget.
+     * To this control layers can be added.
+     * A MapControl have to be instantiated with a QSize which sets the size the widget takes in a layout.
+     * The given size is also the size, which is asured to be filled with map images.
+     *
+     * @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class MapControl : public QWidget
+    {
+        Q_OBJECT
+    public:
+        //! Declares what actions the mouse move has on the map
+        enum MouseMode
+        {
+            Panning, /*!< The map is moved */
+            Dragging, /*!< A rectangular can be drawn */
+            None, /*!< Mouse move events have no efect to the map */
+        };
+        //! The constructor of MapControl
+        /*!
+         * The MapControl is the widget which displays the maps.
+         * The size describes the area, which gets filled with map data
+         * When you give no MouseMode, the mouse is moving the map.
+         * You can change the MouseMode on runtime, to e.g. Dragging, which lets the user drag a rectangular box.
+         * After the dragging a signal with the size of the box is emitted.
+         * The mousemode ´None´ can be used, to completely define the control of the map yourself.
+         * @param size the size which the widget should fill with map data
+         * @param mousemode the way mouseevents are handled
+         */
+        MapControl ( QSize size, MouseMode mousemode = Panning );
+        ~MapControl();
+        //! adds a layer
+        /*!
+         * If multiple layers are added, they are painted in the added order.
+         * @param layer the layer which should be added
+         */
+        void addLayer ( Layer* layer );
+        //! returns the layer with the given name
+        /*!
+         * @param  layername name of the wanted layer
+         * @return the layer with the given name
+         */
+        Layer* layer ( const QString& layername ) const;
+        //! returns the names of all layers
+        /*!
+         * @return returns a QList with the names of all layers
+         */
+        QList<QString> layers() const;
+        //! returns the number of existing layers
+        /*!
+         * @return returns the number of existing layers
+         */
+        int numberOfLayers() const;
+        //! returns the coordinate of the center of the map
+        /*!
+         * @return returns the coordinate of the middle of the screen
+         */
+        QPointF currentCoordinate() const;
+        //! returns the current zoom level
+        /*!
+         * @return returns the current zoom level
+         */
+        int currentZoom() const;
+        //! sets the middle of the map to the given coordinate
+        /*!
+         * @param  coordinate the coordinate which the view´s middle should be set to
+         */
+        void setView ( const QPointF& coordinate ) const;
+        //! sets the view, so all coordinates are visible
+        /*!
+         * @param  coordinates the Coorinates which should be visible
+         */
+        void setView ( const QList<QPointF> coordinates ) const;
+        //! sets the view and zooms in, so all coordinates are visible
+        /*!
+         * The code of setting the view to multiple coordinates is "brute force" and pretty slow.
+         * Have to be reworked.
+         * @param  coordinates the Coorinates which should be visible
+         */
+        void setViewAndZoomIn ( const QList<QPointF> coordinates ) const;
+        //! sets the view to the given Point
+        /*!
+         *
+         * @param point the geometric point the view should be set to
+         */
+        void setView ( const Point* point ) const;
+        //! Keeps the center of the map on the Geometry, even when it moves
+        /*!
+         * To stop the following the method stopFollowing() have to be called
+         * @param  geometry the Geometry which should stay centered.
+         */
+        void followGeometry ( const Geometry* geometry ) const;
+        //TODO:
+        // void followGeometry(const QList<Geometry*>) const;
+        //! Stops the following of a Geometry
+        /*!
+         * if the view is set to follow a Geometry this method stops the trace.
+         * See followGeometry().
+         * @param geometry the Geometry which should not followed anymore
+         */
+        void stopFollowing ( Geometry* geometry );
+        //! Smoothly moves the center of the view to the given Coordinate
+        /*!
+         * @param  coordinate the Coordinate which the center of the view should moved to
+         */
+        void moveTo     ( QPointF coordinate );
+        //! sets the Mouse Mode of the MapControl
+        /*!
+         * There are three MouseModes declard by an enum.
+         * The MouesMode Dragging draws an rectangular in the map while the MouseButton is pressed.
+         * When the Button is released a boxDragged() signal is emitted.
+         *
+         * The second MouseMode (the default) is Panning, which allows to drag the map around.
+         * @param mousemode the MouseMode
+         */
+        void setMouseMode ( MouseMode mousemode );
+        //! returns the current MouseMode
+        /*!
+         * For a explanation for the MouseModes see setMouseMode()
+         * @return the current MouseMode
+         */
+        MapControl::MouseMode mouseMode();
+        //int rotation;
+        //! Enable persistent caching of map tiles
+        /*!
+         * Call this method to allow the QMapControl widget to save map tiles
+         * persistent (also over application restarts).
+         * Tiles are stored in the subdirectory "QMapControl.cache" within the
+         * user's home directory. This can be changed by giving a path.
+         * @param path the path to the cache directory
+         */
+        void enablePersistentCache ( const QDir& path=QDir::homePath() + "/QMapControl.cache" );
+        //! Sets the proxy for HTTP connections
+        /*!
+         * This method sets the proxy for HTTP connections.
+         * This is not provided by the current Qtopia version!
+         * @param host the proxy´s hostname or ip
+         * @param port the proxy´s port
+         */
+        void setProxy ( QString host, int port );
+        //! Displays the scale within the widget
+        /*!
+         *
+         * @param show true if the scale should be displayed
+         */
+        void showScale ( bool show );
+    private:
+        LayerManager* layermanager;
+        QPoint screen_middle; // middle of the widget (half size)
+        QPoint pre_click_px; // used for scrolling (MouseMode Panning)
+        QPoint current_mouse_pos; // used for scrolling and dragging (MouseMode Panning/Dragging)
+        QSize size; // size of the widget
+        bool mousepressed;
+        MouseMode mymousemode;
+        bool scaleVisible;
+        bool m_loadingFlag;
+        QMutex moveMutex; // used for method moveTo()
+        QPointF target; // used for method moveTo()
+        int steps; // used for method moveTo()
+        QPointF clickToWorldCoordinate ( QPoint click );
+        MapControl& operator= ( const MapControl& rhs );
+        MapControl ( const MapControl& old );
+    protected:
+        void paintEvent ( QPaintEvent* evnt );
+        void mousePressEvent ( QMouseEvent* evnt );
+        void mouseReleaseEvent ( QMouseEvent* evnt );
+        void mouseMoveEvent ( QMouseEvent* evnt );
+    signals:
+        // void mouseEvent(const QMouseEvent* evnt);
+        //! Emitted AFTER a MouseEvent occured
+        /*!
+         * This signals allows to receive click events within the MapWidget together with the world coordinate.
+         * It is emitted on MousePressEvents and MouseReleaseEvents.
+         * The kind of the event can be obtained by checking the events type.
+         * @param  evnt the QMouseEvent that occured
+         * @param  coordinate the corresponding world coordinate
+         */
+        void mouseEventCoordinate ( const QMouseEvent* evnt, const QPointF coordinate );
+        //! Emitted, after a Rectangular is dragged.
+        /*!
+         * It is possible to select a rectangular area in the map, if the MouseMode is set to Dragging.
+         * The coordinates are in world coordinates
+         * @param  QRectF the dragged Rect
+         */
+        void boxDragged ( const QRectF );
+        //! This signal is emitted, when a Geometry is clicked
+        /*!
+         * @param geometry The clicked Geometry object
+         * @param coord_px  The coordinate in pixel coordinates
+         */
+        void geometryClicked ( Geometry* geometry, QPoint coord_px );
+        //! This signal is emitted, after the view have changed
+        /*!
+         * @param coordinate The current coordinate
+         * @param zoom The current zoom
+         */
+        void viewChanged ( const QPointF &coordinate, int zoom );
+    public slots:
+        //! zooms in one step
+        void zoomIn();
+        //! zooms out one step
+        void zoomOut();
+        //! sets the given zoomlevel
+        /*!
+         * @param zoomlevel the zoomlevel
+         */
+        void setZoom ( int zoomlevel );
+        //! scrolls the view to the left
+        void scrollLeft ( int pixel=10 );
+        //! scrolls the view to the right
+        void scrollRight ( int pixel=10 );
+        //! scrolls the view up
+        void scrollUp ( int pixel=10 );
+        //! scrolls the view down
+        void scrollDown ( int pixel=10 );
+        //! scrolls the view by the given point
+        void scroll ( const QPoint scroll );
+        //! updates the map for the given rect
+        /*!
+         * @param rect the area which should be repainted
+         */
+        void updateRequest ( QRect rect );
+        //! updates the hole map by creating a new offscreen image
+        /*!
+         *
+         */
+        void updateRequestNew();
+        //! Resizes the map to the given size
+        /*!
+         * @param newSize The new size
+         */
+        void resize(const QSize newSize);
+    private slots:
+        void tick();
+        void loadingFinished();
+        void positionChanged ( Geometry* geom );
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/maplayer.cpp
 ,0 → 1,38
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "maplayer.h"
+namespace qmapcontrol
+{
+    MapLayer::MapLayer(QString layername, MapAdapter* mapadapter, bool takeevents)
+        : Layer(layername, mapadapter, Layer::MapLayer, takeevents)
+    {
+    }
+    MapLayer::~MapLayer()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/maplayer.h
 ,0 → 1,65
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef MAPLAYER_H
+#define MAPLAYER_H
+#include "layer.h"
+namespace qmapcontrol
+{
+    //! MapLayer class
+    /*!
+     * There are two different layer types:
+     *  - MapLayer: Displays Maps, but also Geometries. The configuration for displaying maps have to be done in the MapAdapter
+     *  - GeometryLayer: Only displays Geometry objects.
+     *
+     * MapLayers also can display Geometry objects. The difference to the GeometryLayer is the repainting. Objects that are
+     * added to a MapLayer are "baken" on the map. This means, when you change it´s position for example the changes are
+     * not visible until a new offscreen image has been drawn. If you have "static" Geometries which won´t change their
+     * position this is fine. But if you want to change the objects position or pen you should use a GeometryLayer. Those
+     * are repainted immediately on changes.
+     *
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class MapLayer : public Layer
+    {
+        Q_OBJECT
+    public:
+        //! MapLayer constructor
+        /*!
+         * This is used to construct a map layer.
+         *
+         * @param layername The name of the Layer
+         * @param mapadapter The MapAdapter which does coordinate translation and Query-String-Forming
+         * @param takeevents Should the Layer receive MouseEvents? This is set to true by default. Setting it to false could
+         * be something like a "speed up hint"
+         */
+        MapLayer(QString layername, MapAdapter* mapadapter, bool takeevents=true);
+        virtual ~MapLayer();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/mapnetwork.cpp
 ,0 → 1,136
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "mapnetwork.h"
+#include <QWaitCondition>
+namespace qmapcontrol
+{
+    MapNetwork::MapNetwork(ImageManager* parent)
+        :parent(parent), http(new QHttp(this)), loaded(0)
+    {
+        connect(http, SIGNAL(requestFinished(int, bool)),
+                this, SLOT(requestFinished(int, bool)));
+    }
+    MapNetwork::~MapNetwork()
+    {
+        http->clearPendingRequests();
+        delete http;
+    }
+    void MapNetwork::loadImage(const QString& host, const QString& url)
+    {
+        // qDebug() << "getting: " << QString(host).append(url);
+        // http->setHost(host);
+        // int getId = http->get(url);
+        http->setHost(host);
+        QHttpRequestHeader header("GET", url);
+        header.setValue("User-Agent", "Mozilla");
+        header.setValue("Host", host);
+        int getId = http->request(header);
+        if (vectorMutex.tryLock())
+        {
+            loadingMap[getId] = url;
+            vectorMutex.unlock();
+        }
+    }
+    void MapNetwork::requestFinished(int id, bool error)
+    {
+        // sleep(1);
+        // qDebug() << "MapNetwork::requestFinished" << http->state() << ", id: " << id;
+        if (error)
+        {
+            qDebug() << "network error: " << http->errorString();
+            //restart query
+        }
+        else if (vectorMutex.tryLock())
+        {
+            // check if id is in map?
+            if (loadingMap.contains(id))
+            {
+                QString url = loadingMap[id];
+                loadingMap.remove(id);
+                vectorMutex.unlock();
+                // qDebug() << "request finished for id: " << id << ", belongs to: " << notifier.url << endl;
+                QByteArray ax;
+                if (http->bytesAvailable()>0)
+                {
+                    QPixmap pm;
+                    ax = http->readAll();
+                    if (pm.loadFromData(ax))
+                    {
+                        loaded += pm.size().width()*pm.size().height()*pm.depth()/8/1024;
+                        // qDebug() << "Network loaded: " << (loaded);
+                        parent->receivedImage(pm, url);
+                    }
+                    else
+                    {
+                        qDebug() << "NETWORK_PIXMAP_ERROR: " << ax;
+                    }
+                }
+            }
+            else
+                vectorMutex.unlock();
+        }
+        if (loadingMap.size() == 0)
+        {
+            // qDebug () << "all loaded";
+            parent->loadingQueueEmpty();
+        }
+    }
+    void MapNetwork::abortLoading()
+    {
+        http->clearPendingRequests();
+        if (vectorMutex.tryLock())
+        {
+            loadingMap.clear();
+            vectorMutex.unlock();
+        }
+    }
+    bool MapNetwork::imageIsLoading(QString url)
+    {
+        return loadingMap.values().contains(url);
+    }
+    void MapNetwork::setProxy(QString host, int port)
+    {
+#ifndef Q_WS_QWS
+        // do not set proxy on qt/extended
+        http->setProxy(host, port);
+#endif
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/mapnetwork.h
 ,0 → 1,78
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef MAPNETWORK_H
+#define MAPNETWORK_H
+#include <QObject>
+#include <QDebug>
+#include <QHttp>
+#include <QVector>
+#include <QPixmap>
+#include "imagemanager.h"
+/**
+        @author Kai Winter <kaiwinter@gmx.de>
+ */
+namespace qmapcontrol
+{
+    class ImageManager;
+    class MapNetwork : QObject
+    {
+        Q_OBJECT
+    public:
+        MapNetwork(ImageManager* parent);
+        ~MapNetwork();
+        void loadImage(const QString& host, const QString& url);
+        /*!
+         * checks if the given url is already loading
+         * @param url the url of the image
+         * @return boolean, if the image is already loading
+         */
+        bool imageIsLoading(QString url);
+        /*!
+         * Aborts all current loading threads.
+         * This is useful when changing the zoom-factor, though newly needed images loads faster
+         */
+        void abortLoading();
+        void setProxy(QString host, int port);
+    private:
+        ImageManager* parent;
+        QHttp* http;
+        QMap<int, QString> loadingMap;
+        qreal loaded;
+        QMutex vectorMutex;
+        MapNetwork& operator=(const MapNetwork& rhs);
+        MapNetwork(const MapNetwork& old);
+    private slots:
+        void requestFinished(int id, bool error);
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/openaerialmapadapter.cpp
 ,0 → 1,37
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2009 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "openaerialmapadapter.h"
+namespace qmapcontrol
+{
+    OpenAerialMapAdapter::OpenAerialMapAdapter()
+        : TileMapAdapter("tile.openaerialmap.org", "/tiles/1.0.0/openaerialmap-900913/%1/%2/%3.png", 256, 0, 17)
+    {
+    }
+    OpenAerialMapAdapter::~OpenAerialMapAdapter()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/openaerialmapadapter.h
 ,0 → 1,49
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2009 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef OPENAERIALMAPADAPTER_H
+#define OPENAERIALMAPADAPTER_H
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for OpenStreetMap
+    /*!
+     * This is a conveniece class, which extends and configures a TileMapAdapter. Source of maps is http://www.openaerialmap.org/
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class OpenAerialMapAdapter : public TileMapAdapter
+    {
+        Q_OBJECT
+                public:
+        //! constructor
+        /*!
+         * This construct a OpenAerialMap Adapter
+         */
+        OpenAerialMapAdapter();
+        virtual ~OpenAerialMapAdapter();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/osmmapadapter.cpp
 ,0 → 1,37
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "osmmapadapter.h"
+namespace qmapcontrol
+{
+    OSMMapAdapter::OSMMapAdapter()
+        : TileMapAdapter("tile.openstreetmap.org", "/%1/%2/%3.png", 256, 0, 17)
+    {
+    }
+    OSMMapAdapter::~OSMMapAdapter()
+    {
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/osmmapadapter.h
 ,0 → 1,49
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef OSMMAPADAPTER_H
+#define OSMMAPADAPTER_H
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for OpenStreetMap
+    /*!
+     * This is a conveniece class, which extends and configures a TileMapAdapter
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class OSMMapAdapter : public TileMapAdapter
+    {
+        Q_OBJECT
+                public:
+        //! constructor
+        /*!
+         * This construct a OpenStreetmap Adapter
+         */
+        OSMMapAdapter();
+        virtual ~OSMMapAdapter();
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/point.cpp
 ,0 → 1,330
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "point.h"
+namespace qmapcontrol
+{
+    Point::Point()
+    {}
+    Point::Point(const Point& point)
+        :Geometry(point.name()), X(point.longitude()), Y(point.latitude())
+    {
+        visible = point.isVisible();
+        mywidget = 0;
+        mypixmap = 0;
+        mypen = point.mypen;
+        homelevel = -1;
+        minsize = QSize(-1,-1);
+        maxsize = QSize(-1,-1);
+    }
+    Point::Point(qreal x, qreal y, QString name, enum Alignment alignment)
+        : Geometry(name), X(x), Y(y), myalignment(alignment)
+    {
+        GeometryType = "Point";
+        mywidget = 0;
+        mypixmap = 0;
+        visible = true;
+        homelevel = -1;
+        minsize = QSize(-1,-1);
+        maxsize = QSize(-1,-1);
+    }
+    Point::Point(qreal x, qreal y, QWidget* widget, QString name, enum Alignment alignment)
+        : Geometry(name), X(x), Y(y), mywidget(widget), myalignment(alignment)
+    {
+        // Point(x, y, name, alignment);
+        GeometryType = "Point";
+        mypixmap = 0;
+        visible = true;
+        size = widget->size();
+        homelevel = -1;
+        minsize = QSize(-1,-1);
+        maxsize = QSize(-1,-1);
+        mywidget->show();
+    }
+    Point::Point(qreal x, qreal y, QPixmap* pixmap, QString name, enum Alignment alignment)
+        : Geometry(name), X(x), Y(y), mypixmap(pixmap), myalignment(alignment)
+    {
+        GeometryType = "Point";
+        mywidget = 0;
+        visible = true;
+        size = pixmap->size();
+        homelevel = -1;
+        minsize = QSize(-1,-1);
+        maxsize = QSize(-1,-1);
+    }
+    /*
+        Point& Point::operator=(const Point& rhs)
+        {
+        if (this == &rhs)
+        return *this;
+        else
+        {
+        X = rhs.X;
+        Y = rhs.Y;
+        size = rhs.size;
+        mywidget = rhs.mywidget;
+        mypixmap = rhs.mypixmap;
+        alignment = rhs.alignment;
+        homelevel = rhs.homelevel;
+        minsize = rhs.minsize;
+        maxsize = rhs.maxsize;
+}
+}
+*/
+    Point::~Point()
+    {
+        delete mywidget;
+        delete mypixmap;
+    }
+    void Point::setVisible(bool visible)
+    {
+        this->visible = visible;
+        if (mywidget !=0)
+        {
+            mywidget->setVisible(visible);
+        }
+    }
+    QRectF Point::boundingBox()
+    {
+        //TODO: have to be calculated in relation to alignment...
+        return QRectF(QPointF(X, Y), displaysize);
+    }
+    qreal Point::longitude() const
+    {
+        return X;
+    }
+    qreal Point::latitude() const
+    {
+        return Y;
+    }
+    QPointF Point::coordinate() const
+    {
+        return QPointF(X, Y);
+    }
+    void Point::draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset)
+    {
+        if (!visible)
+            return;
+        if (homelevel > 0)
+        {
+            int currentzoom = mapadapter->maxZoom() < mapadapter->minZoom() ? mapadapter->minZoom() - mapadapter->currentZoom() : mapadapter->currentZoom();
+            // int currentzoom = mapadapter->getZoom();
+            int diffzoom = homelevel-currentzoom;
+            int viewheight = size.height();
+            int viewwidth = size.width();
+            viewheight = int(viewheight / pow(2, diffzoom));
+            viewwidth = int(viewwidth / pow(2, diffzoom));
+            if (minsize.height()!= -1 && viewheight < minsize.height())
+                viewheight = minsize.height();
+            else if (maxsize.height() != -1 && viewheight > maxsize.height())
+                viewheight = maxsize.height();
+            if (minsize.width()!= -1 && viewwidth < minsize.width())
+                viewwidth = minsize.width();
+            else if (maxsize.width() != -1 && viewwidth > maxsize.width())
+                viewwidth = maxsize.width();
+            displaysize = QSize(viewwidth, viewheight);
+        }
+        else
+        {
+            displaysize = size;
+        }
+        if (mypixmap !=0)
+        {
+            const QPointF c = QPointF(X, Y);
+            QPoint point = mapadapter->coordinateToDisplay(c);
+            if (viewport.contains(point))
+            {
+                QPoint alignedtopleft = alignedPoint(point);
+                painter->drawPixmap(alignedtopleft.x(), alignedtopleft.y(), displaysize.width(), displaysize.height(), *mypixmap);
+            }
+        }
+        else if (mywidget!=0)
+        {
+            drawWidget(mapadapter, offset);
+        }
+    }
+    void Point::drawWidget(const MapAdapter* mapadapter, const QPoint offset)
+    {
+        const QPointF c = QPointF(X, Y);
+        QPoint point = mapadapter->coordinateToDisplay(c);
+        point -= offset;
+        QPoint alignedtopleft = alignedPoint(point);
+        mywidget->setGeometry(alignedtopleft.x(), alignedtopleft.y(), displaysize.width(), displaysize.height());
+    }
+    QPoint Point::alignedPoint(const QPoint point) const
+    {
+        QPoint alignedtopleft;
+        if (myalignment == Middle)
+        {
+            alignedtopleft.setX(point.x()-displaysize.width()/2);
+            alignedtopleft.setY(point.y()-displaysize.height()/2);
+        }
+        else if (myalignment == TopLeft)
+        {
+            alignedtopleft.setX(point.x());
+            alignedtopleft.setY(point.y());
+        }
+        else if (myalignment == TopRight)
+        {
+            alignedtopleft.setX(point.x()-displaysize.width());
+            alignedtopleft.setY(point.y());
+        }
+        else if (myalignment == BottomLeft)
+        {
+            alignedtopleft.setX(point.x());
+            alignedtopleft.setY(point.y()-displaysize.height());
+        }
+        else if (myalignment == BottomRight)
+        {
+            alignedtopleft.setX(point.x()-displaysize.width());
+            alignedtopleft.setY(point.y()-displaysize.height());
+        }
+        return alignedtopleft;
+    }
+    bool Point::Touches(Point* p, const MapAdapter* mapadapter)
+    {
+        if (this->isVisible() == false)
+            return false;
+        if (mypixmap == 0)
+            return false;
+        QPointF c = p->coordinate();
+        // coordinate to pixel
+        QPoint pxOfPoint = mapadapter->coordinateToDisplay(c);
+        // size/2 Pixel toleranz aufaddieren
+        QPoint p1;
+        QPoint p2;
+        switch (myalignment)
+        {
+                        case Middle:
+            p1 = pxOfPoint - QPoint(displaysize.width()/2,displaysize.height()/2);
+            p2 = pxOfPoint + QPoint(displaysize.width()/2,displaysize.height()/2);
+            break;
+                        case TopLeft:
+            p1 = pxOfPoint - QPoint(displaysize.width(),displaysize.height());
+            p2 = pxOfPoint;
+            break;
+                        case TopRight:
+            p1 = pxOfPoint - QPoint(0, displaysize.height());
+            p2 = pxOfPoint + QPoint(displaysize.width(),0);
+            break;
+                        case BottomLeft:
+            p1 = pxOfPoint - QPoint(displaysize.width(), 0);
+            p2 = pxOfPoint + QPoint(0, displaysize.height());
+            break;
+                        case BottomRight:
+            p1 = pxOfPoint;
+            p2 = pxOfPoint + QPoint(displaysize.width(), displaysize.height());
+            break;
+        }
+        // calculate "Bounding Box" in coordinates
+        QPointF c1 = mapadapter->displayToCoordinate(p1);
+        QPointF c2 = mapadapter->displayToCoordinate(p2);
+        if(this->longitude()>=c1.x() && this->longitude()<=c2.x())
+        {
+            if (this->latitude()<=c1.y() && this->latitude()>=c2.y())
+            {
+                emit(geometryClicked(this, QPoint(0,0)));
+                return true;
+            }
+        }
+        return false;
+    }
+    void Point::setCoordinate(QPointF point)
+    {
+        // emit(updateRequest(this));
+        // emit(updateRequest(QRectF(X, Y, size.width(), size.height())));
+        X = point.x();
+        Y = point.y();
+        // emit(updateRequest(this));
+        emit(updateRequest(QRectF(X, Y, size.width(), size.height())));
+        emit(positionChanged(this));
+    }
+    QList<Point*> Point::points()
+    {
+        //TODO: assigning temp?!
+        QList<Point*> points;
+        points.append(this);
+        return points;
+    }
+    QWidget* Point::widget()
+    {
+        return mywidget;
+    }
+    QPixmap* Point::pixmap()
+    {
+        return mypixmap;
+    }
+    void Point::setBaselevel(int zoomlevel)
+    {
+        homelevel = zoomlevel;
+    }
+    void Point::setMinsize(QSize minsize)
+    {
+        this->minsize = minsize;
+    }
+    void Point::setMaxsize(QSize maxsize)
+    {
+        this->maxsize = maxsize;
+    }
+    Point::Alignment Point::alignment() const
+    {
+        return myalignment;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/point.h
 ,0 → 1,215
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef POINT_H
+#define POINT_H
+#include <QWidget>
+#include "geometry.h"
+namespace qmapcontrol
+{
+    //! A geometric point to draw objects into maps
+    /*!
+     * This class can be used to draw your custom QPixmap or other QWidgets into maps.
+     * You can instantiate a Point with any Pixmap you want. The objects cares about collision detection (for clickable objects)
+     *
+     * When drawing a pixmap, take care you are adding the point to a GeometryLayer.
+     * You can also add a point to a MapLayer, but this should only be done, if the point is not changing its position or color etc.
+     * (GeometryLayers are assured to be repainted on any changes at the point. MapLayers only gets repainted, if a new
+     * offscreenImage is painter. This is a performance issue.)
+     *
+     * Points emit click events, if the containing layer receives clickevents (the default)
+     *
+     * You can also add a widget into maps. But keep in mind, that widgets always are drawn on top of all layers.
+     * You also have to handle click events yourself.
+     *
+     * To create "zoomable objects" (objects that increases size on zooming), a base level have to be set.
+     * The base level is the zoom level on which the point´s pixmap gets displayed on full size.
+     * On lower zoom levels it gets displayed smaller and on higher zoom levels larger.
+     * A minimal size can be set as well as a maximum size.
+     * @see setBaselevel, setMinsize, setMaxsize
+     *
+     * @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class Point : public Geometry
+    {
+        Q_OBJECT
+    public:
+        friend class Layer;
+        friend class LineString;
+        //! sets where the point should be aligned
+        enum Alignment
+        {
+            TopLeft, /*!< Align on TopLeft*/
+            TopRight, /*!< Align on TopRight*/
+            BottomLeft, /*!< Align on BottomLeft*/
+            BottomRight,/*!< Align on BottomRight*/
+            Middle /*!< Align on Middle*/
+        };
+        Point();
+        explicit Point(const Point&);
+        //! Copy Constructor
+        /*!
+         * This constructor creates a Point with no image or widget.
+         * @param x longitude
+         * @param y latitude
+         * @param name name of the point
+         * @param alignment allignment of the point (Middle or TopLeft)
+         */
+        Point(qreal x, qreal y, QString name = QString(), enum Alignment alignment=Middle);
+        //! Constructor
+        /*!
+         * This constructor creates a point which will display the given widget.
+         * You can set an alignment on which corner the widget should be aligned to the coordinate.
+         * You have to set the size of the widget, before adding it to
+         * IMPORTANT: You have to set the QMapControl as parent for the widget!
+         * @param x longitude
+         * @param y latitude
+         * @param widget the widget which should be displayed by this point
+         * @param name name of the point
+         * @param alignment allignment of the point (Middle or TopLeft)
+         */
+        Point(qreal x, qreal y, QWidget* widget, QString name = QString(), enum Alignment alignment = Middle);
+        //! Constructor
+        /*!
+         * This constructor creates a point which will display the give pixmap.
+         * You can set an alignment on which corner the pixmap should be aligned to the coordinate.
+         * @param x longitude
+         * @param y latitude
+         * @param pixmap the pixmap which should be displayed by this point
+         * @param name name of the point
+         * @param alignment allignment of the point (Middle or TopLeft)
+         */
+        Point(qreal x, qreal y, QPixmap* pixmap, QString name = QString(), enum Alignment alignment = Middle);
+        virtual ~Point();
+        //! returns the bounding box of the point
+        /*!
+         * The Bounding contains the coordinate of the point and its size.
+         * The size is set, if the point contains a pixmap or a widget
+         * @return the bounding box of the point
+         */
+        virtual QRectF boundingBox();
+        //! returns the longitude of the point
+        /*!
+         * @return the longitude of the point
+         */
+        qreal longitude() const;
+        //! returns the latitude of the point
+        /*!
+         * @return the latitude of the point
+         */
+        qreal latitude() const;
+        //! returns the coordinate of the point
+        /*!
+         * The x component of the returned QPointF is the longitude value,
+         * the y component the latitude
+         * @return the coordinate of a point
+         */
+        QPointF coordinate() const;
+        virtual QList<Point*> points();
+        /*! \brief returns the widget of the point
+        @return the widget of the point
+         */
+        QWidget* widget();
+        //! returns the pixmap of the point
+        /*!
+         * @return the pixmap of the point
+         */
+        QPixmap* pixmap();
+        //! Sets the zoom level on which the point�s pixmap gets displayed on full size
+        /*!
+         * Use this method to set a zoom level on which the pixmap gets displayed with its real size.
+         * On zoomlevels below it will be displayed smaller, and on zoom levels thereover it will be displayed larger
+         * @see setMinsize, setMaxsize
+         * @param zoomlevel the zoomlevel on which the point will be displayed on full size
+         */
+        void setBaselevel(int zoomlevel);
+        //! sets a minimal size for the pixmap
+        /*!
+         * When the point's pixmap should change its size on zooming, this method sets the minimal size.
+         * @see setBaselevel
+         * @param minsize the minimal size which the pixmap should have
+         */
+        void setMinsize(QSize minsize);
+        //! sets a maximal size for the pixmap
+        /*!
+         * When the point´s pixmap should change its size on zooming, this method sets the maximal size.
+         * @see setBaselevel
+         * @param maxsize the maximal size which the pixmap should have
+         */
+        void setMaxsize(QSize maxsize);
+        Point::Alignment alignment() const;
+    protected:
+        qreal X;
+        qreal Y;
+        QSize size;
+        QWidget* mywidget;
+        QPixmap* mypixmap;
+        Alignment myalignment;
+        int homelevel;
+        QSize displaysize;
+        QSize minsize;
+        QSize maxsize;
+        void drawWidget(const MapAdapter* mapadapter, const QPoint offset);
+        // void drawPixmap(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint versch);
+        virtual void draw(QPainter* painter, const MapAdapter* mapadapter, const QRect &viewport, const QPoint offset);
+        QPoint alignedPoint(const QPoint point) const;
+        //! returns true if the given Point touches this Point
+        /*!
+         * The collision detection checks for the bounding rectangulars.
+         * @param geom the other point which should be tested on collision
+         * @param mapadapter the mapadapter which is used for calculations
+         * @return
+         */
+        virtual bool Touches(Point* geom, const MapAdapter* mapadapter);
+    public slots:
+        void setCoordinate(QPointF point);
+        virtual void setVisible(bool visible);
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/tilemapadapter.cpp
 ,0 → 1,185
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    TileMapAdapter::TileMapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom, int maxZoom)
+        :MapAdapter(host, serverPath, tilesize, minZoom, maxZoom)
+    {
+        PI = acos(-1.0);
+        /*
+            Initialize the "substring replace engine". First the string replacement
+            in getQuery was made by QString().arg() but this was very slow. So this
+            splits the servers path into substrings and when calling getQuery the
+            substrings get merged with the parameters of the URL.
+            Pretty complicated, but fast.
+        */
+        param1 = serverPath.indexOf("%1");
+        param2 = serverPath.indexOf("%2");
+        param3 = serverPath.indexOf("%3");
+        int min = param1 < param2 ? param1 : param2;
+        min = param3 < min ? param3 : min;
+        int max = param1 > param2 ? param1 : param2;
+        max = param3 > max ? param3 : max;
+        int middle = param1+param2+param3-min-max;
+        order[0][0] = min;
+        if (min == param1)
+            order[0][1] = 0;
+        else if (min == param2)
+            order[0][1] = 1;
+        else
+            order[0][1] = 2;
+        order[1][0] = middle;
+        if (middle == param1)
+            order[1][1] = 0;
+        else if (middle == param2)
+            order[1][1] = 1;
+        else
+            order[1][1] = 2;
+        order[2][0] = max;
+        if (max == param1)
+            order[2][1] = 0;
+        else if(max == param2)
+            order[2][1] = 1;
+        else
+            order[2][1] = 2;
+        int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+        numberOfTiles = tilesonzoomlevel(zoom);
+        loc.setNumberOptions(QLocale::OmitGroupSeparator);
+    }
+    TileMapAdapter::~TileMapAdapter()
+    {
+    }
+    //TODO: pull out
+    void TileMapAdapter::zoom_in()
+    {
+        if (min_zoom > max_zoom)
+        {
+            //current_zoom = current_zoom-1;
+            current_zoom = current_zoom > max_zoom ? current_zoom-1 : max_zoom;
+        }
+        else if (min_zoom < max_zoom)
+        {
+            //current_zoom = current_zoom+1;
+            current_zoom = current_zoom < max_zoom ? current_zoom+1 : max_zoom;
+        }
+        int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+        numberOfTiles = tilesonzoomlevel(zoom);
+    }
+    void TileMapAdapter::zoom_out()
+    {
+        if (min_zoom > max_zoom)
+        {
+            //current_zoom = current_zoom+1;
+            current_zoom = current_zoom < min_zoom ? current_zoom+1 : min_zoom;
+        }
+        else if (min_zoom < max_zoom)
+        {
+            //current_zoom = current_zoom-1;
+            current_zoom = current_zoom > min_zoom ? current_zoom-1 : min_zoom;
+        }
+        int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+        numberOfTiles = tilesonzoomlevel(zoom);
+    }
+    qreal TileMapAdapter::deg_rad(qreal x) const
+    {
+        return x * (PI/180.0);
+    }
+    qreal TileMapAdapter::rad_deg(qreal x) const
+    {
+        return x * (180/PI);
+    }
+    QString TileMapAdapter::query(int x, int y, int z) const
+    {
+        x = xoffset(x);
+        y = yoffset(y);
+        int a[3] = {z, x, y};
+        return QString(serverPath).replace(order[2][0],2, loc.toString(a[order[2][1]]))
+                .replace(order[1][0],2, loc.toString(a[order[1][1]]))
+                .replace(order[0][0],2, loc.toString(a[order[0][1]]));
+    }
+    QPoint TileMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
+    {
+        qreal x = (coordinate.x()+180) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
+        qreal y = (1-(log(tan(PI/4+deg_rad(coordinate.y())/2)) /PI)) /2  * (numberOfTiles*mytilesize);
+        return QPoint(int(x), int(y));
+    }
+    QPointF TileMapAdapter::displayToCoordinate(const QPoint& point) const
+    {
+        qreal longitude = (point.x()*(360/(numberOfTiles*mytilesize)))-180;
+        qreal latitude = rad_deg(atan(sinh((1-point.y()*(2/(numberOfTiles*mytilesize)))*PI)));
+        return QPointF(longitude, latitude);
+    }
+    bool TileMapAdapter::isValid(int x, int y, int z) const
+    {
+        if (max_zoom < min_zoom)
+        {
+            z= min_zoom - z;
+        }
+        if (x<0 || x>pow(2,z)-1 ||
+            y<0 || y>pow(2,z)-1)
+        {
+            return false;
+        }
+        return true;
+    }
+    int TileMapAdapter::tilesonzoomlevel(int zoomlevel) const
+    {
+        return int(pow(2, zoomlevel));
+    }
+    int TileMapAdapter::xoffset(int x) const
+    {
+        return x;
+    }
+    int TileMapAdapter::yoffset(int y) const
+    {
+        return y;
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/tilemapadapter.h
 ,0 → 1,76
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef TILEMAPADAPTER_H
+#define TILEMAPADAPTER_H
+#include "mapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for servers with image tiles
+    /*!
+     * Use this derived MapAdapter to display maps from OpenStreetMap
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class TileMapAdapter : public MapAdapter
+    {
+        Q_OBJECT
+                public:
+        //! constructor
+        /*!
+         * Sample of a correct initialization of a MapAdapter:<br/>
+         * TileMapAdapter* ta = new TileMapAdapter("192.168.8.1", "/img/img_cache.php/%1/%2/%3.png", 256, 0,17);<br/>
+         * The placeholders %1, %2, %3 stands for x, y, z<br/>
+         * The minZoom is 0 (means the whole world is visible). The maxZoom is 17 (means it is zoomed in to the max)
+         * @param host The servers URL
+         * @param serverPath The path to the tiles with placeholders
+         * @param tilesize the size of the tiles
+         * @param minZoom the minimum zoom level
+         * @param maxZoom the maximum zoom level
+         */
+        TileMapAdapter(const QString& host, const QString& serverPath, int tilesize, int minZoom = 0, int maxZoom = 17);
+        virtual ~TileMapAdapter();
+        virtual QPoint coordinateToDisplay(const QPointF&) const;
+        virtual QPointF displayToCoordinate(const QPoint&) const;
+        qreal PI;
+    protected:
+        qreal rad_deg(qreal) const;
+        qreal deg_rad(qreal) const;
+        virtual bool isValid(int x, int y, int z) const;
+        virtual void zoom_in();
+        virtual void zoom_out();
+        virtual QString query(int x, int y, int z) const;
+        virtual int tilesonzoomlevel(int zoomlevel) const;
+        virtual int xoffset(int x) const;
+        virtual int yoffset(int y) const;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/wmsmapadapter.cpp
 ,0 → 1,110
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "wmsmapadapter.h"
+namespace qmapcontrol
+{
+    WMSMapAdapter::WMSMapAdapter(QString host, QString serverPath, int tilesize)
+        : MapAdapter(host, serverPath, tilesize, 0, 17)
+    {
+        // param1 = serverPath.indexOf("%1");
+        // param2 = serverPath.indexOf("%2");
+        // param3 = serverPath.indexOf("%3");
+        // param4 = serverPath.indexOf("%4");
+        // param5 = serverPath.indexOf("%5");
+        // param6 = serverPath.lastIndexOf("%5");
+        // this->serverPath = serverPath.replace(param6, 2, QString().setNum(tilesize)).replace(param5, 2, QString().setNum(tilesize));
+        // sub1 = serverPath.mid(0, param1);
+        // sub2 = serverPath.mid(param1+2, param2-param1-2);
+        // sub3 = serverPath.mid(param2+2, param3-param2-2);
+        // sub4 = serverPath.mid(param3+2, param4-param3-2);
+        // sub5 = serverPath.mid(param4+2);
+        this->serverPath.append("&WIDTH=").append(loc.toString(tilesize))
+                .append("&HEIGHT=").append(loc.toString(tilesize))
+                .append("&BBOX=");
+        numberOfTiles = pow(2, current_zoom);
+        coord_per_x_tile = 360. / numberOfTiles;
+        coord_per_y_tile = 180. / numberOfTiles;
+    }
+    WMSMapAdapter::~WMSMapAdapter()
+    {
+    }
+    QPoint WMSMapAdapter::coordinateToDisplay(const QPointF& coordinate) const
+    {
+        qreal x = (coordinate.x()+180) * (numberOfTiles*mytilesize)/360.; // coord to pixel!
+        qreal y = -1*(coordinate.y()-90) * (numberOfTiles*mytilesize)/180.; // coord to pixel!
+        return QPoint(int(x), int(y));
+    }
+    QPointF WMSMapAdapter::displayToCoordinate(const QPoint& point) const
+    {
+        qreal lon = (point.x()*(360./(numberOfTiles*mytilesize)))-180;
+        qreal lat = -(point.y()*(180./(numberOfTiles*mytilesize)))+90;
+        return QPointF(lon, lat);
+    }
+    void WMSMapAdapter::zoom_in()
+    {
+        current_zoom+=1;
+        numberOfTiles = pow(2, current_zoom);
+        coord_per_x_tile = 360. / numberOfTiles;
+        coord_per_y_tile = 180. / numberOfTiles;
+    }
+    void WMSMapAdapter::zoom_out()
+    {
+        current_zoom-=1;
+        numberOfTiles = pow(2, current_zoom);
+        coord_per_x_tile = 360. / numberOfTiles;
+        coord_per_y_tile = 180. / numberOfTiles;
+    }
+    bool WMSMapAdapter::isValid(int /*x*/, int /*y*/, int /*z*/) const
+    {
+        // if (x>0 && y>0 && z>0)
+        {
+            return true;
+        }
+        // return false;
+    }
+    QString WMSMapAdapter::query(int i, int j, int /*z*/) const
+    {
+        return getQ(-180+i*coord_per_x_tile,
+-(j+1)*coord_per_y_tile,
+                    -180+i*coord_per_x_tile+coord_per_x_tile,
+-(j+1)*coord_per_y_tile+coord_per_y_tile);
+    }
+    QString WMSMapAdapter::getQ(qreal ux, qreal uy, qreal ox, qreal oy) const
+    {
+        return QString().append(serverPath)
+                .append(loc.toString(ux)).append(",")
+                .append(loc.toString(uy)).append(",")
+                .append(loc.toString(ox)).append(",")
+                .append(loc.toString(oy));
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/wmsmapadapter.h
 ,0 → 1,70
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef WMSMAPADAPTER_H
+#define WMSMAPADAPTER_H
+#include "mapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for WMS servers
+    /*!
+     * Use this derived MapAdapter to display maps from WMS servers
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class WMSMapAdapter : public MapAdapter
+    {
+    public:
+        //! constructor
+        /*!
+         * Sample of a correct initialization of a MapAdapter:<br/>
+         * MapAdapter* mapadapter = new WMSMapAdapter("www2.demis.nl", "/wms/wms.asp?wms=WorldMap[...]&BBOX=%1,%2,%3,%4&WIDTH=%5&HEIGHT=%5&TRANSPARENT=TRUE", 256);<br/>
+         * The placeholders %1, %2, %3, %4 creates the bounding box, %5 is for the tilesize
+         * The minZoom is 0 (means the whole world is visible). The maxZoom is 17 (means it is zoomed in to the max)
+         * @param host The servers URL
+         * @param serverPath The path to the tiles with placeholders
+         * @param tilesize the size of the tiles
+         */
+        WMSMapAdapter(QString host, QString serverPath, int tilesize = 256);
+        virtual ~WMSMapAdapter();
+        virtual QPoint coordinateToDisplay(const QPointF&) const;
+        virtual QPointF displayToCoordinate(const QPoint&) const;
+    protected:
+        virtual void zoom_in();
+        virtual void zoom_out();
+        virtual QString query(int x, int y, int z) const;
+        virtual bool isValid(int x, int y, int z) const;
+    private:
+        virtual QString getQ(qreal ux, qreal uy, qreal ox, qreal oy) const;
+        qreal coord_per_x_tile;
+        qreal coord_per_y_tile;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl/yahoomapadapter.cpp
 ,0 → 1,63
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#include "yahoomapadapter.h"
+namespace qmapcontrol
+{
+    YahooMapAdapter::YahooMapAdapter()
+        : TileMapAdapter("png.maps.yimg.com", "/png?v=3.1.0&x=%2&y=%3&z=%1", 256, 17,0)
+    {
+        int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+        numberOfTiles = pow(2, zoom+1);
+    }
+    YahooMapAdapter::YahooMapAdapter(QString host, QString url)
+        : TileMapAdapter(host, url, 256, 17,0)
+    {
+        int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+        numberOfTiles = pow(2, zoom+1);
+    }
+    YahooMapAdapter::~YahooMapAdapter()
+    {
+    }
+    bool YahooMapAdapter::isValid(int /*x*/, int /*y*/, int /*z*/) const
+    {
+        return true;
+    }
+    int YahooMapAdapter::tilesonzoomlevel(int zoomlevel) const
+    {
+        return int(pow(2, zoomlevel+1));
+    }
+    int YahooMapAdapter::yoffset(int y) const
+    {
+        int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
+        int tiles = int(pow(2, zoom));
+        y = y*(-1)+tiles-1;
+        return int(y);
+    }
+}

 /QMK-Groundstation/trunk/Global/Class_QMapControl/yahoomapadapter.h
 ,0 → 1,56
+/*
+*
+* This file is part of QMapControl,
+* an open-source cross-platform map widget
+*
+* Copyright (C) 2007 - 2008 Kai Winter
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.
+*
+* Contact e-mail: kaiwinter@gmx.de
+* Program URL   : http://qmapcontrol.sourceforge.net/
+*
+*/
+#ifndef YAHOOMAPADAPTER_H
+#define YAHOOMAPADAPTER_H
+#include "tilemapadapter.h"
+namespace qmapcontrol
+{
+    //! MapAdapter for Yahoo Maps
+    /*!
+     *  @author Kai Winter <kaiwinter@gmx.de>
+     */
+    class YahooMapAdapter : public TileMapAdapter
+    {
+        Q_OBJECT
+    public:
+        //! constructor
+        /*!
+         * This construct a Yahoo Adapter
+         */
+        YahooMapAdapter();
+        YahooMapAdapter(QString host, QString url);
+        virtual ~YahooMapAdapter();
+        bool isValid(int x, int y, int z) const;
+    protected:
+        virtual int tilesonzoomlevel(int zoomlevel) const;
+        virtual int yoffset(int y) const;
+    };
+}
+#endif

 /QMK-Groundstation/trunk/Global/Class_QMapControl.h
 ,0 → 1,18
+#include "../../Global/Class_QMapControl/mapcontrol.h"
+#include "../../Global/Class_QMapControl/gps_position.h"
+#include "../../Global/Class_QMapControl/wmsmapadapter.h"
+#include "../../Global/Class_QMapControl/geometry.h"
+#include "../../Global/Class_QMapControl/point.h"
+#include "../../Global/Class_QMapControl/imagepoint.h"
+#include "../../Global/Class_QMapControl/circlepoint.h"
+#include "../../Global/Class_QMapControl/linestring.h"
+#include "../../Global/Class_QMapControl/gps_position.h"
+#include "../../Global/Class_QMapControl/osmmapadapter.h"
+#include "../../Global/Class_QMapControl/maplayer.h"
+#include "../../Global/Class_QMapControl/geometrylayer.h"
+#include "../../Global/Class_QMapControl/yahoomapadapter.h"
+#include "../../Global/Class_QMapControl/googlemapadapter.h"
+#include "../../Global/Class_QMapControl/googlesatmapadapter.h"
+#include "../../Global/Class_QMapControl/openaerialmapadapter.h"
+#include "../../Global/Class_QMapControl/fixedimageoverlay.h"
+#include "../../Global/Class_QMapControl/emptymapadapter.h"

 /QMK-Groundstation/trunk/Global/Class_QMapControl.pri
 ,0 → 1,54
+DEPENDPATH += ../Global/Class_QMapControl
+INCLUDEPATH += ../Global/Class_QMapControl
+# Input
+HEADERS += curve.h \
+           geometry.h \
+           imagemanager.h \
+           layer.h \
+           layermanager.h \
+           linestring.h \
+           mapadapter.h \
+           mapcontrol.h \
+           mapnetwork.h \
+           point.h \
+           tilemapadapter.h \
+           wmsmapadapter.h \
+           circlepoint.h \
+           imagepoint.h \
+           gps_position.h \
+           osmmapadapter.h \
+           maplayer.h \
+           geometrylayer.h \
+           yahoomapadapter.h \
+           googlemapadapter.h \
+           googlesatmapadapter.h \
+           openaerialmapadapter.h \
+           fixedimageoverlay.h \
+           emptymapadapter.h
+SOURCES += curve.cpp \
+           geometry.cpp \
+           imagemanager.cpp \
+           layer.cpp \
+           layermanager.cpp \
+           linestring.cpp \
+           mapadapter.cpp \
+           mapcontrol.cpp \
+           mapnetwork.cpp \
+           point.cpp \
+           tilemapadapter.cpp \
+           wmsmapadapter.cpp \
+           circlepoint.cpp \
+           imagepoint.cpp \
+           gps_position.cpp \
+           osmmapadapter.cpp \
+           maplayer.cpp \
+           geometrylayer.cpp \
+           yahoomapadapter.cpp \
+           googlemapadapter.cpp \
+           googlesatmapadapter.cpp \
+           openaerialmapadapter.cpp \
+           fixedimageoverlay.cpp \
+           emptymapadapter.cpp
+QT += network

 /QMK-Groundstation/trunk/Global/Class_SerialPort/ManageSerialPort.cpp
 ,0 → 1,577
+/********************************************************************************************************
+                * PROGRAM      : QSerialPortTerminal
+                * DATE - TIME  : vendredi 03 octobre 2008 - 11h15
+                * AUTHOR       : VIANNEY-LIAUD Philippe ( philippe.vianney.liaud gmail.com )
+                        * FILENAME     : ManageSerialPort.cpp
+                        * LICENSE      : GPL
+                        * COMMENTARY   :
+********************************************************************************************************/
+#include <QtDebug>
+#include "ManageSerialPort.h"
+/********************************************************************************************************
+                * Classe ManageSerialPort
+                *****************************************************************************************************/
+//Constructeur
+ManageSerialPort::ManageSerialPort()
+{
+        //Init pointeur a NULL
+        threadSend = NULL;
+        threadReceive = NULL;
+        //Init des bool
+        sendingEnabled = false;
+        receivingEnabled = false;
+        closeCalled = false;
+        saveStateSendEnabled = false;
+        saveStateReceivedEnabled = false;
+        saveStateReceiveData = false;
+}
+ManageSerialPort::ManageSerialPort(const QString &name, const BaudRateType baudRate, \
+                const DataBitsType dataBits, const ParityType parity, \
+                const StopBitsType stopBits, const FlowType flowControl, \
+                ulong seconds, ulong milliseconds)
+{
+        //Init pointeur a NULL
+        threadSend = NULL;
+        threadReceive = NULL;
+        //Init des bool
+        sendingEnabled = false;
+        receivingEnabled = false;
+        closeCalled = false;
+        saveStateSendEnabled = false;
+        saveStateReceivedEnabled = false;
+        saveStateReceiveData = false;
+        setPort(name);
+        setBaudRate(baudRate);
+        setDataBits(dataBits);
+        setParity(parity);
+        setStopBits(stopBits);
+        setFlowControl(flowControl);
+        setTimeout(seconds, milliseconds);
+}
+//Destructeur
+ManageSerialPort::~ManageSerialPort()
+{
+        if (threadSend != NULL)
+        {
+                delete threadSend;
+                threadSend = NULL;
+        }
+        if (threadReceive != NULL)
+        {
+                delete threadReceive;
+                threadReceive = NULL;
+        }
+        if (isOpen())
+                extSerialPort.close();
+}
+bool ManageSerialPort::open()
+{
+        bool res = extSerialPort.open(QIODevice::ReadWrite);
+        if (closeCalled)
+        {
+                if (saveStateSendEnabled)
+                        enableSending();
+                if (saveStateReceivedEnabled)
+                        enableReceiving();
+                if (saveStateReceiveData)
+                        receiveData();
+                closeCalled = false;
+        }
+        return res;
+}
+bool ManageSerialPort::open(const QString &name, const BaudRateType baudRate, \
+                const DataBitsType dataBits,const ParityType parity, \
+                const StopBitsType stopBits, const FlowType flowControl, \
+                ulong seconds, ulong milliseconds)
+{
+        setPort(name);
+        setBaudRate(baudRate);
+        setDataBits(dataBits);
+        setParity(parity);
+        setStopBits(stopBits);
+        setFlowControl(flowControl);
+        setTimeout(seconds, milliseconds);
+        bool res = extSerialPort.open(QIODevice::ReadWrite);
+        return res;
+}
+bool ManageSerialPort::isOpen()
+{
+        return extSerialPort.isOpen();
+}
+void ManageSerialPort::close()
+{
+        closeCalled = true;
+        saveStateSendEnabled = isSendingEnabled();
+        saveStateReceivedEnabled = isReceivingEnabled();
+        disableSending();
+        disableReceiving();
+        extSerialPort.close();
+}
+void ManageSerialPort::setPort(const QString &name)
+{
+        extSerialPort.setPortName(name);
+}
+QString ManageSerialPort::getPort()
+{
+        return extSerialPort.portName();
+}
+void ManageSerialPort::setBaudRate(const BaudRateType baudRate)
+{
+        extSerialPort.setBaudRate(baudRate);
+}
+QString ManageSerialPort::getBaudRate()
+{
+        switch (extSerialPort.baudRate())
+        {
+                case BAUD50:
+                        return QString("50");
+                case BAUD75:
+                        return QString("75");
+                case BAUD110:
+                        return QString("110");
+                case BAUD134:
+                        return QString("134");
+                case BAUD150:
+                        return QString("150");
+                case BAUD200:
+                        return QString("200");
+                case BAUD300:
+                        return QString("300");
+                case BAUD600:
+                        return QString("600");
+                case BAUD1200:
+                        return QString("1200");
+                case BAUD1800:
+                        return QString("1800");
+                case BAUD2400:
+                        return QString("2400");
+                case BAUD4800:
+                        return QString("4800");
+                case BAUD9600:
+                        return QString("9600");
+                case BAUD14400:
+                        return QString("14400");
+                case BAUD19200:
+                        return QString("19200");
+                case BAUD38400:
+                        return QString("38400");
+                case BAUD56000:
+                        return QString("56000");
+                case BAUD57600:
+                        return QString("57600");
+                case BAUD76800:
+                        return QString("76800");
+                case BAUD115200:
+                        return QString("115200");
+                case BAUD128000:
+                        return QString("128000");
+                case BAUD256000:
+                        return QString("256000");
+        }
+        return 0;
+}
+void ManageSerialPort::setDataBits(const DataBitsType dataBits)
+{
+        extSerialPort.setDataBits(dataBits);
+}
+QChar ManageSerialPort::getDataBits()
+{
+        switch (extSerialPort.dataBits())
+        {
+                case DATA_5:
+                        return QChar('5');
+                case DATA_6:
+                        return QChar('6');
+                case DATA_7:
+                        return QChar('7');
+                case DATA_8:
+                        return QChar('8');
+                }
+                return 0;
+}
+void ManageSerialPort::setParity(const ParityType parity)
+{
+        extSerialPort.setParity(parity);
+}
+QString ManageSerialPort::getParity()
+{
+        switch (extSerialPort.parity())
+        {
+                case PAR_NONE:
+                        return QString(tr("None"));
+                case PAR_ODD:
+                        return QString(tr("Odd"));
+                case PAR_EVEN:
+                        return QString(tr("Even"));
+                case PAR_MARK:
+                        return QString(tr("Mark"));
+                case PAR_SPACE:
+                        return QString(tr("Space"));
+                }
+                return 0;
+}
+void ManageSerialPort::setStopBits(const StopBitsType stopBits)
+{
+        extSerialPort.setStopBits(stopBits);
+}
+QString ManageSerialPort::getStopBit()
+{
+        switch (extSerialPort.stopBits())
+        {
+                case STOP_1:
+                        return QString("1");
+                case STOP_1_5:
+                        return QString("1.5");
+                case STOP_2:
+                        return QString("2");
+                }
+                return 0;
+}
+void ManageSerialPort::setFlowControl(const FlowType flowControl)
+{
+        extSerialPort.setFlowControl(flowControl);
+}
+QString ManageSerialPort::getFlowControl()
+{
+        switch (extSerialPort.flowControl())
+        {
+                case FLOW_OFF:
+                        return QString(tr("None"));
+                case FLOW_HARDWARE      :
+                        return QString(tr("Hardware"));
+                case FLOW_XONXOFF :
+                        return QString(tr("Xon/Xoff"));
+                }
+                return 0;
+}
+void ManageSerialPort::setTimeout(ulong seconds, ulong milliseconds)
+{
+        extSerialPort.setTimeout(seconds,milliseconds);
+}
+/*
+QString ManageSerialPort::getLastErrorToString()
+{
+        ulong res = extSerialPort.lastError();
+        switch (res)
+        {
+                case E_NO_ERROR:
+                        return QString(tr("No Error has occured"));
+                case E_INVALID_FD:
+                        return QString(tr("Invalid file descriptor (port was not opened correctly)"));
+                case E_NO_MEMORY:
+                        return QString(tr("Unable to allocate memory tables (POSIX)"));
+                case E_CAUGHT_NON_BLOCKED_SIGNAL:
+                        return QString(tr("Caught a non-blocked signal (POSIX)"));
+                case E_PORT_TIMEOUT:
+                        return QString(tr("Operation timed out (POSIX)"));
+                case E_INVALID_DEVICE:
+                        return QString(tr("The file opened by the port is not a character device (POSIX)"));
+                case E_BREAK_CONDITION:
+                        return QString(tr("The port detected a break condition"));
+                case E_FRAMING_ERROR:
+                        return QString(tr("The port detected a framing error (usually caused by incorrect baud rate settings)"));
+                case E_IO_ERROR:
+                        return QString(tr("There was an I/O error while communicating with the port"));
+                case E_BUFFER_OVERRUN:
+                        return QString(tr("Character buffer overrun"));
+                case E_RECEIVE_OVERFLOW:
+                        return QString(tr("Receive buffer overflow"));
+                case E_RECEIVE_PARITY_ERROR:
+                        return QString(tr("The port detected a parity error in the received data"));
+                case E_TRANSMIT_OVERFLOW:
+                        return QString(tr("Transmit buffer overflow"));
+                case E_READ_FAILED:
+                        return QString(tr("General read operation failure"));
+                case E_WRITE_FAILED:
+                        return QString(tr("General write operation failure"));
+                }
+                return 0;
+}*/
+/*
+ulong ManageSerialPort::getLastError()
+{
+        return extSerialPort.lastError();
+}
+*/
+void ManageSerialPort::enableSending()
+{
+        if (!sendingEnabled && threadSend == NULL) //Si l'envoi n'est pas active && si threadSend n'est pas alloue
+        {
+                threadSend = new ThreadSend(extSerialPort);
+                sendingEnabled = true;
+        }
+}
+void ManageSerialPort::disableSending()
+{
+        if (sendingEnabled && threadSend != NULL) //Si l'envoi est active && si threadSend est alloue
+        {
+                delete (threadSend);
+                threadSend = NULL;
+                sendingEnabled = false;
+        }
+}
+bool ManageSerialPort::isSendingEnabled()
+{
+        return sendingEnabled;
+}
+uchar ManageSerialPort::sendData(QByteArray &dataToSend)
+{
+        if (!isOpen()) //Si le port n'est pas ouvert
+                return 2;
+        if (!sendingEnabled || threadSend == NULL) //Si l'envoi n'est pas active || si threadSend n'est pas alloue
+                return 3;
+        threadSend->addDataToSend(dataToSend); //Ajout des donnees a envoyer
+        return 1;
+}
+void ManageSerialPort::stopSending()
+{
+        if (!sendingEnabled || threadSend == NULL) //Si l'envoi n'est pas active || si threadSend n'est pas été alloue
+                return;
+        if (threadSend->isRunning()) //si un envoi est en cour
+        {
+                threadSend->stopSending(); //on donne l'ordre d'arreter l'envoi
+        long tmp = ULONG_MAX;
+                threadSend->wait(tmp); //on attend l'arret
+        }
+}
+void ManageSerialPort::enableReceiving()
+{
+        if (!receivingEnabled && threadReceive == NULL) //Si la reception n'est pas active && si threadReceive n'est pas alloue
+        {
+                threadReceive = new ThreadReceive(extSerialPort);
+                connect(threadReceive, SIGNAL(newDataReceived(const QByteArray &)), this, SIGNAL(newDataReceived(const QByteArray &)));
+                receivingEnabled = true;
+        }
+}
+void ManageSerialPort::disableReceiving()
+{
+        if (receivingEnabled && threadReceive != NULL) //Si la reception est pas active && si threadReceive est alloue
+        {
+                delete (threadReceive);
+                threadReceive = NULL;
+                receivingEnabled = false;
+        }
+}
+bool ManageSerialPort::isReceivingEnabled()
+{
+        return receivingEnabled;
+}
+uchar ManageSerialPort::receiveData()
+{
+        if (!isOpen()) //Si le port n'est pas ouvert
+                return 2;
+        if (!receivingEnabled || threadReceive == NULL) //Si la reception n'est pas active || si threadReceive n'est pas été alloue
+                return 3;
+        if (!threadReceive->isRunning())
+        {
+                saveStateReceiveData = true;
+                threadReceive->start(); //Demarrage du thread de reception
+        }
+        return 1;
+}
+void ManageSerialPort::stopReceiving()
+{
+        if (!receivingEnabled || threadReceive == NULL) //Si la reception n'est pas active || si threadReceive n'est pas alloue
+                return;
+        if (threadReceive->isRunning()) //Si le thread de reception est en fonctionnement
+        {
+                saveStateReceiveData = false;
+                threadReceive->stopReceiving(); //on donne l'ordre d'arreter la reception
+        long tmp = ULONG_MAX;
+                threadReceive->wait(tmp); //on attend l'arret
+        }
+}
+/********************************************************************************************************
+                * Classe ThreadSend
+                *****************************************************************************************************/
+ThreadSend::ThreadSend(QextSerialPort &addressSerialPort) : extSerialPort(addressSerialPort)
+{
+        dataToSend.clear();
+        stopped=false;
+}
+ThreadSend::~ThreadSend()
+{
+        if (isRunning())
+        {
+                stopSending();
+                wait();
+        }
+}
+void ThreadSend::addDataToSend(QByteArray &dataToAdd)
+{
+        QMutexLocker locker(&mutexSend);
+        for (int i=0; i<dataToAdd.size(); i++)
+                dataToSend.enqueue(QByteArray(1,dataToAdd.at(i)));
+        if (!isRunning())
+                start();
+}
+void ThreadSend::stopSending()
+{
+        stopped=true;
+}
+void ThreadSend::run()
+{
+        QByteArray byteArray;
+        forever
+        {
+                if (dataToSend.isEmpty() || stopped)
+                {
+                        stopped = false;
+                        break;
+                }
+                mutexSend.lock();
+                byteArray = dataToSend.dequeue();
+                mutexSend.unlock();
+                extSerialPort.write(byteArray, 1);
+        }
+}
+/********************************************************************************************************
+                * Classe ThreadReceive - A TERMINER
+                *****************************************************************************************************/
+ThreadReceive::ThreadReceive(QextSerialPort &addressSerialPort) : extSerialPort(addressSerialPort)
+{
+        stopped=false;
+}
+ThreadReceive::~ThreadReceive()
+{
+        if (isRunning())
+        {
+                stopReceiving();
+                wait();
+        }
+}
+void ThreadReceive::stopReceiving()
+{
+        stopped = true;
+}
+void ThreadReceive::run()
+{
+        int numBytes=0;
+        char data[1024];
+        QByteArray dataReceived;
+        forever
+        {
+                if (stopped)
+                {
+                        stopped = false;
+                        break;
+                }
+                mutexReceive.lock();
+                numBytes = extSerialPort.bytesAvailable();
+                if (numBytes > 0)
+                {
+                        extSerialPort.read(data, numBytes);
+                    for (int xy=1; xy < numBytes; xy++)
+                    {
+                        if (data[xy] == 0)
+                        {
+                                data[xy] = 'a';
+                        }
+            }
+                        data[numBytes]='\0';
+                        dataReceived = data;
+                        emit newDataReceived(dataReceived);
+                }
+                        mutexReceive.unlock();
+        }
+}

 /QMK-Groundstation/trunk/Global/Class_SerialPort/ManageSerialPort.h
 ,0 → 1,324
+/********************************************************************************************************
+* PROGRAM      : QSerialPortTerminal
+* DATE - TIME  : vendredi 03 octobre 2008 - 11h15
+* AUTHOR       : VIANNEY-LIAUD Philippe ( philippe.vianney.liaud gmail.com )
+* FILENAME     : ManageSerialPort.h
+* LICENSE      : GPL
+* COMMENTARY   : Manage qExtSerialPort
+********************************************************************************************************/
+#ifndef MANAGESERIALPORT_H
+#define MANAGESERIALPORT_H
+#include <QThread>
+#include <QQueue>
+#include <QMetaType>
+#include <QMutex>
+#include "qextserialport.h"
+Q_DECLARE_METATYPE(BaudRateType);
+Q_DECLARE_METATYPE(DataBitsType);
+Q_DECLARE_METATYPE(ParityType);
+Q_DECLARE_METATYPE(StopBitsType);
+Q_DECLARE_METATYPE(FlowType);
+class ThreadSend;
+class ThreadReceive;
+class ManageSerialPort : public QObject
+{
+    Q_OBJECT
+public:
+//Constructeurs + destructeur
+    ManageSerialPort();
+    ManageSerialPort(const QString &name, const BaudRateType baudRate, const DataBitsType dataBits,\
+                     const ParityType parity, const StopBitsType stopBits, \
+                     const FlowType flowControl, ulong seconds, ulong milliseconds);
+    ~ManageSerialPort();
+//General
+    bool open();
+    bool open(const QString &name, const BaudRateType baudRate, const DataBitsType dataBits,\
+              const ParityType parity, const StopBitsType stopBits, \
+              const FlowType flowControl, ulong seconds, ulong milliseconds);
+    bool isOpen();
+    void close();
+    //Sets the name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0"
+    void setPort(const QString &name);
+    QString getPort();
+    /*Most used : '*' (POSTX & Windows)
+    RATE          Windows Speed   POSIX Speed
+    -----------   -------------   -----------
+     enum BaudRateType{
+        BAUD50                 110          50          //POSIX ONLY
+        BAUD75                 110          75          //POSIX ONLY
+       *BAUD110                110         110
+        BAUD134                110         134.5        //POSIX ONLY
+        BAUD150                110         150          //POSIX ONLY
+        BAUD200                110         200          //POSIX ONLY
+       *BAUD300                300         300
+       *BAUD600                600         600
+       *BAUD1200              1200        1200
+        BAUD1800              1200        1800          //POSIX ONLY
+       *BAUD2400              2400        2400
+       *BAUD4800              4800        4800
+       *BAUD9600              9600        9600
+        BAUD14400            14400        9600          //WINDOWS ONLY
+       *BAUD19200            19200       19200
+       *BAUD38400            38400       38400
+        BAUD56000            56000       38400          //WINDOWS ONLY
+       *BAUD57600            57600       57600
+        BAUD76800            57600       76800          //POSIX ONLY
+       *BAUD115200          115200      115200
+        BAUD128000          128000      115200          //WINDOWS ONLY
+        BAUD256000          256000      115200          //WINDOWS ONLY
+    }*/
+    void setBaudRate(const BaudRateType baudRate);
+    /*getBaudRate
+        return "50";
+        return "75";
+        return "110";
+        return "134";
+        return "150";
+        return "200";
+        return "300";
+        return "600";
+        return "1200";
+        return "1800";
+        return "2400";
+        return "4800";
+        return "9600";
+        return "14400";
+        return "19200";
+        return "38400";
+        return "56000";
+        return "57600";
+        return "76800";
+        return "115200";
+        return "128000";
+        return "256000";*/
+    QString getBaudRate();
+    /*enum DataBitsType {
+        DATA_5
+        DATA_6
+        DATA_7
+        DATA_8
+    };*/
+    void setDataBits(const DataBitsType dataBits);

Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 673 → Rev 674