Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 390 → Rev 391

/QMK-Groundstation/branches/own_com_lib/Classes/QMapControl/circlepoint.cpp
0,0 → 1,72
/*
*
* 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 "circlepoint.h"
namespace qmapcontrol
{
CirclePoint::CirclePoint(qreal x, qreal y, int radius, QString name, Alignment alignment, QPen* pen)
: Point(x, y, name, alignment)
{
size = QSize(radius, radius);
mypixmap = new QPixmap(radius+1, radius+1);
mypixmap->fill(Qt::transparent);
QPainter painter(mypixmap);
if (pen != 0)
{
painter.setPen(*pen);
}
painter.drawEllipse(0,0,radius, radius);
}
 
CirclePoint::CirclePoint(qreal x, qreal y, QString name, Alignment alignment, QPen* pen)
: Point(x, y, name, alignment)
{
int radius = 10;
size = QSize(radius, radius);
mypixmap = new QPixmap(radius+1, radius+1);
mypixmap->fill(Qt::transparent);
QPainter painter(mypixmap);
if (pen != 0)
{
painter.setPen(*pen);
}
painter.drawEllipse(0,0,radius, radius);
}
 
CirclePoint::~CirclePoint()
{
delete mypixmap;
}
 
void CirclePoint::setPen(QPen* pen)
{
mypen = pen;
mypixmap = new QPixmap(size.width()+1, size.height()+1);
mypixmap->fill(Qt::transparent);
QPainter painter(mypixmap);
painter.setPen(*pen);
painter.drawEllipse(0,0, size.width(), size.height());
}
}
/QMK-Groundstation/branches/own_com_lib/Classes/QMapControl/circlepoint.h
0,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/branches/own_com_lib/Classes/QMapControl/curve.cpp
0,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/branches/own_com_lib/Classes/QMapControl/curve.h
0,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/branches/own_com_lib/Classes/QMapControl/geometry.cpp
0,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/branches/own_com_lib/Classes/QMapControl/geometry.h
0,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/branches/own_com_lib/Classes/QMapControl/geometrylayer.cpp
0,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/branches/own_com_lib/Classes/QMapControl/geometrylayer.h
0,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/branches/own_com_lib/Classes/QMapControl/googlemapadapter.cpp
0,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/branches/own_com_lib/Classes/QMapControl/googlemapadapter.h
0,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/branches/own_com_lib/Classes/QMapControl/googlesatmapadapter.cpp
0,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()
: MapAdapter("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,
90-(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/branches/own_com_lib/Classes/QMapControl/googlesatmapadapter.h
0,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 "mapadapter.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 MapAdapter
{
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/branches/own_com_lib/Classes/QMapControl/gps_position.cpp
0,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/branches/own_com_lib/Classes/QMapControl/gps_position.h
0,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/branches/own_com_lib/Classes/QMapControl/imagemanager.cpp
0,0 → 1,178
/*
*
* 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()
{
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/branches/own_com_lib/Classes/QMapControl/imagemanager.h
0,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/branches/own_com_lib/Classes/QMapControl/imagepoint.cpp
0,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/branches/own_com_lib/Classes/QMapControl/imagepoint.h
0,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/branches/own_com_lib/Classes/QMapControl/layer.cpp
0,0 → 1,301
/*
*
* 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);
 
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/branches/own_com_lib/Classes/QMapControl/layer.h
0,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/branches/own_com_lib/Classes/QMapControl/layermanager.cpp
0,0 → 1,458
/*
*
* 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.save();
painter.translate(screenmiddle);
painter.scale(2, 2);
painter.translate(-screenmiddle);
 
painter.drawPixmap(0,0,tmpImg);
painter.restore();
 
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.5,0.5);
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/branches/own_com_lib/Classes/QMapControl/layermanager.h
0,0 → 1,213
/*
*
* 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
 
QMutex scrollMutex;
QPoint whilenewscroll;
mutable QMutex refreshMutex;
 
public slots:
void updateRequest(QRectF rect);
void updateRequest();
void resize(QSize newSize);
};
}
#endif
/QMK-Groundstation/branches/own_com_lib/Classes/QMapControl/linestring.cpp
0,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/branches/own_com_lib/Classes/QMapControl/linestring.h
0,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/branches/own_com_lib/Classes/QMapControl/mapadapter.cpp
0,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/branches/own_com_lib/Classes/QMapControl/mapadapter.h
0,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/branches/own_com_lib/Classes/QMapControl/mapcontrol.cpp
0,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/branches/own_com_lib/Classes/QMapControl/mapcontrol.h
0,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/branches/own_com_lib/Classes/QMapControl/maplayer.cpp
0,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/branches/own_com_lib/Classes/QMapControl/maplayer.h
0,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/branches/own_com_lib/Classes/QMapControl/mapnetwork.cpp
0,0 → 1,137
/*
*
* 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();
// http->abort();
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/branches/own_com_lib/Classes/QMapControl/mapnetwork.h
0,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/branches/own_com_lib/Classes/QMapControl/osmmapadapter.cpp
0,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 "osmmapadapter.h"
namespace qmapcontrol
{
OSMMapAdapter::OSMMapAdapter()
: TileMapAdapter("tile.openstreetmap.org", "/%1/%2/%3.png", 256, 0, 17)
// : TileMapAdapter("192.168.8.1", "/img/img_cache.php/%1/%2/%3.png", 256, 0, 17)
{
}
 
OSMMapAdapter::~OSMMapAdapter()
{
}
}
/QMK-Groundstation/branches/own_com_lib/Classes/QMapControl/osmmapadapter.h
0,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/branches/own_com_lib/Classes/QMapControl/point.cpp
0,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/branches/own_com_lib/Classes/QMapControl/point.h
0,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/branches/own_com_lib/Classes/QMapControl/src.pro
0,0 → 1,52
######################################################################
# Automatically generated by qmake (2.01a) Fri Feb 22 23:43:21 2008
######################################################################
 
TEMPLATE = app
TARGET =
DEPENDPATH += .
INCLUDEPATH += .
 
# Input
HEADERS += circlepoint.h \
curve.h \
geometry.h \
geometrylayer.h \
googlemapadapter.h \
gps_position.h \
imagemanager.h \
imagepoint.h \
layer.h \
layermanager.h \
linestring.h \
mapadapter.h \
mapcontrol.h \
maplayer.h \
mapnetwork.h \
osmmapadapter.h \
point.h \
tilemapadapter.h \
wmsmapadapter.h \
yahoomapadapter.h \
yahooapimapadapter.h
SOURCES += circlepoint.cpp \
curve.cpp \
geometry.cpp \
geometrylayer.cpp \
googlemapadapter.cpp \
gps_position.cpp \
imagemanager.cpp \
imagepoint.cpp \
layer.cpp \
layermanager.cpp \
linestring.cpp \
mapadapter.cpp \
mapcontrol.cpp \
maplayer.cpp \
mapnetwork.cpp \
osmmapadapter.cpp \
point.cpp \
tilemapadapter.cpp \
wmsmapadapter.cpp \
yahoomapadapter.cpp \
yahooapimapadapter.cpp
/QMK-Groundstation/branches/own_com_lib/Classes/QMapControl/tilemapadapter.cpp
0,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/branches/own_com_lib/Classes/QMapControl/tilemapadapter.h
0,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/branches/own_com_lib/Classes/QMapControl/wmsmapadapter.cpp
0,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,
90-(j+1)*coord_per_y_tile,
-180+i*coord_per_x_tile+coord_per_x_tile,
90-(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/branches/own_com_lib/Classes/QMapControl/wmsmapadapter.h
0,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/branches/own_com_lib/Classes/QMapControl/yahoomapadapter.cpp
0,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/branches/own_com_lib/Classes/QMapControl/yahoomapadapter.h
0,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/branches/own_com_lib/Classes/ToolBox.cpp
0,0 → 1,64
/***************************************************************************
* 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 "ToolBox.h"
 
/**
* specific data for QT
*/
 
//FIXME: search for something else than sleep
void ToolBox::wait(int Time)
{
#ifndef _WIN32_
usleep(Time);
#else
//FIXME: implement sleep for win_32
//(or kick this function completely)
// sleep(Time);
#endif
}
 
QString ToolBox::get_Float(long 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;
}
 
// Datensatz nach QString
QString ToolBox::dataToQString(int Data[150], int Start, int End)
{
return QString(Parser::dataToString(Data, Start, End));
}
 
// Alle Icons
QIcon ToolBox::Icon(int ID)
{
QIcon Icons[5] ;
Icons[0].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledred.png")), QIcon::Normal, QIcon::Off);
Icons[1].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);
Icons[3].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledyellow.png")), QIcon::Normal, QIcon::Off);
Icons[4].addPixmap(QPixmap(QString::fromUtf8(":/LED/Images/16X16/ledoff.png")), QIcon::Normal, QIcon::Off);
return Icons[ID];
}
/QMK-Groundstation/branches/own_com_lib/Classes/ToolBox.h
0,0 → 1,36
/***************************************************************************
* 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 TOOLBOX_H
#define TOOLBOX_H
 
#include <QString>
#include <QIcon>
#include "../global.h"
#include "../com/Kopter.h"
 
class ToolBox
{
public :
static QString dataToQString(int Data[150], int Start = 0, int End = 150);
static QIcon Icon(int ID);
static QString get_Float(long Wert, int Count);
static void wait(int Time);
};
 
#endif // TOOLBOX_H
/QMK-Groundstation/branches/own_com_lib/Classes/cAttitude.cpp
0,0 → 1,136
#include <qevent.h>
#include <qpainter.h>
#include <qwt_math.h>
#include <qwt_polygon.h>
#include "cAttitude.h"
 
AttitudeIndicatorNeedle::AttitudeIndicatorNeedle(const QColor &c)
{
QPalette palette;
for ( int i = 0; i < QPalette::NColorGroups; i++ )
{
palette.setColor((QPalette::ColorGroup)i, QPalette::Text, c);
}
setPalette(palette);
}
 
void AttitudeIndicatorNeedle::draw(QPainter *painter, const QPoint &center, int length, double direction, QPalette::ColorGroup cg) const
{
direction *= M_PI / 180.0;
int triangleSize = qRound(length * 0.1);
 
painter->save();
 
// Verschiebung von Pfeil und Linie
const QPoint p0(QPoint(center.x() + 1, center.y() + 1));
const QPoint p01(QPoint(center.x() + 1, center.y() + 10));
const QPoint p02(QPoint(center.x() + 1, center.y() - 11));
const QPoint p03(QPoint(center.x() + 1, center.y() + 20));
const QPoint p04(QPoint(center.x() + 1, center.y() - 21));
 
// Der kleine Pfeil
const QPoint p1 = qwtPolar2Pos(p0, length - 2 * triangleSize - 2, direction);
 
QwtPolygon pa(3);
pa.setPoint(0, qwtPolar2Pos(p1, 2 * triangleSize, direction));
pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction + M_PI_2));
pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction - M_PI_2));
 
const QColor color = palette().color(cg, QPalette::Text);
 
painter->setBrush(color);
painter->drawPolygon(pa);
 
painter->setPen(QPen(color, 3));
painter->drawLine(qwtPolar2Pos(p0, length - 2, direction + M_PI_2), qwtPolar2Pos(p0, length - 2, direction - M_PI_2));
 
painter->setPen(QPen(QColor(255,255,255), 1));
painter->drawLine(qwtPolar2Pos(p01, length - 40, direction + M_PI_2), qwtPolar2Pos(p01, length - 40, direction - M_PI_2));
painter->drawLine(qwtPolar2Pos(p02, length - 40, direction + M_PI_2), qwtPolar2Pos(p02, length - 40, direction - M_PI_2));
painter->drawLine(qwtPolar2Pos(p03, length - 30, direction + M_PI_2), qwtPolar2Pos(p03, length - 30, direction - M_PI_2));
painter->drawLine(qwtPolar2Pos(p04, length - 30, direction + M_PI_2), qwtPolar2Pos(p04, length - 30, direction - M_PI_2));
 
painter->restore();
}
 
AttitudeIndicator::AttitudeIndicator(QWidget *parent): QwtDial(parent), d_gradient(0.0)
{
setMode(RotateScale);
setWrapping(true);
 
setOrigin(270.0);
setScaleOptions(ScaleTicks);
setScale(0, 0, 30.0);
 
const QColor color = palette().color(QPalette::Text);
 
setNeedle(new AttitudeIndicatorNeedle(color));
}
 
void AttitudeIndicator::setGradient(double gradient)
{
if ( gradient < -1.0 )
gradient = -1.0;
else if ( gradient > 1.0 )
gradient = 1.0;
 
if ( d_gradient != gradient )
{
d_gradient = gradient;
update();
}
}
 
void AttitudeIndicator::drawScale(QPainter *painter, const QPoint &center, int radius, double origin, double minArc, double maxArc) const
{
double dir = (360.0 - origin) * M_PI / 180.0; // counter clockwise, radian
 
int offset = 4;
const QPoint p0 = qwtPolar2Pos(center, offset, dir + M_PI);
 
const int w = contentsRect().width();
 
QwtPolygon pa(4);
pa.setPoint(0, qwtPolar2Pos(p0, w, dir - M_PI_2));
pa.setPoint(1, qwtPolar2Pos(pa.point(0), 2 * w, dir + M_PI_2));
pa.setPoint(2, qwtPolar2Pos(pa.point(1), w, dir));
pa.setPoint(3, qwtPolar2Pos(pa.point(2), 2 * w, dir - M_PI_2));
 
painter->save();
painter->setClipRegion(pa); // swallow 180 - 360 degrees
 
QwtDial::drawScale(painter, center, radius, origin, minArc, maxArc);
 
painter->restore();
}
 
void AttitudeIndicator::drawScaleContents(QPainter *painter, const QPoint &, int) const
{
int dir = 360 - qRound(origin() - value()); // counter clockwise
int arc = 90 + qRound(gradient() * 90);
 
const QColor skyColor(38, 151, 221);
 
painter->save();
painter->setBrush(skyColor);
painter->drawChord(scaleContentsRect(), (dir - arc) * 16, 2 * arc * 16 );
painter->restore();
}
 
void AttitudeIndicator::keyPressEvent(QKeyEvent *e)
{
switch(e->key())
{
case Qt::Key_Plus:
setGradient(gradient() + 0.05);
break;
case Qt::Key_Minus:
setGradient(gradient() - 0.05);
break;
 
default:
QwtDial::keyPressEvent(e);
}
}
/QMK-Groundstation/branches/own_com_lib/Classes/cAttitude.h
0,0 → 1,37
#include <QObject>
#include <qwt_dial.h>
#include <qwt_dial_needle.h>
 
class AttitudeIndicatorNeedle: public QwtDialNeedle
{
public:
AttitudeIndicatorNeedle(const QColor &);
 
virtual void draw(QPainter *, const QPoint &, int length,
double direction, QPalette::ColorGroup) const;
};
 
class AttitudeIndicator: public QwtDial
{
Q_OBJECT
 
public:
AttitudeIndicator(QWidget *parent = NULL);
 
double angle() const { return value(); }
double gradient() const { return d_gradient; }
 
public slots:
void setGradient(double);
void setAngle(double angle) { setValue(angle); }
 
protected:
virtual void keyPressEvent(QKeyEvent *);
 
virtual void drawScale(QPainter *, const QPoint &center, int radius, double origin, double arcMin, double arcMax) const;
 
virtual void drawScaleContents(QPainter *painter, const QPoint &center, int radius) const;
 
private:
double d_gradient;
};
/QMK-Groundstation/branches/own_com_lib/Classes/cConnection.cpp
0,0 → 1,264
/***************************************************************************
* 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 "cConnection.h"
 
cConnection::cConnection()
{
i_Type = 0;
 
TTY = new ManageSerialPort();
o_Timer = new QTimer(this);
 
connect(o_Timer, SIGNAL(timeout()), SLOT(slot_Timer()));
 
TTY->setBaudRate(BAUD57600); //BaudRate
TTY->setDataBits(DATA_8); //DataBits
TTY->setParity(PAR_NONE); //Parity
TTY->setStopBits(STOP_1); //StopBits
TTY->setFlowControl(FLOW_OFF); //FlowControl
 
TTY->setTimeout(0, 10);
TTY->enableSending();
TTY->enableReceiving();
 
b_isOpen = false;
}
 
void cConnection::new_Data(QString Data)
{
Data = Data;
 
while ((RxData.String.length() > 1) && (RxData.String.at(1) == '#'))
{
RxData.String.remove(0,1);
}
 
if (ToolBox::check_CRC(RxData.String))
{
RxData.Input = RxData.String.toLatin1().data();
emit(newData(RxData));
}
else
{
emit(showTerminal(2, RxData.String));
}
 
}
 
void cConnection::slot_newDataReceived(const QByteArray &dataReceived)
{
const char *RXt;
RXt = dataReceived.data();
int a = 0;
 
while (RXt[a] != '\0')
{
if (RXt[a] == '\r')
{
new_Data(QString(""));
RxData.String = QString("");
}
else
{
RxData.String = RxData.String + QString(RXt[a]);
}
a++;
}
}
 
bool cConnection::isOpen()
{
return b_isOpen;
}
 
bool cConnection::Close()
{
switch(i_Type)
{
case C_TTY :
{
TTY->close();
 
disconnect(TTY, SIGNAL(newDataReceived(const QByteArray &)), this, 0);
 
b_isOpen = false;
}
break;
case C_IP :
{
TcpSocket->disconnectFromHost();
disconnect(TcpSocket, SIGNAL(connected()), 0, 0);
disconnect(TcpSocket, SIGNAL(readyRead()), 0, 0);
disconnect(TcpSocket, SIGNAL(disconnected()), 0, 0);
 
b_isOpen = false;
}
break;
}
 
return b_isOpen;
}
 
bool cConnection::Open(int Typ, QString Address)
{
switch(Typ)
{
case C_TTY :
{
TTY->setPort(Address); //Port
TTY->open();
 
ToolBox::Wait(1000);
 
if (TTY->isOpen())
{
connect(TTY, SIGNAL(newDataReceived(const QByteArray &)), this, SLOT(slot_newDataReceived(const QByteArray &)));
 
TTY->receiveData();
b_isOpen = true;
i_Type = C_TTY;
}
}
break;
case C_IP :
{
QStringList Host = Address.split(":");
 
TcpSocket = new(QTcpSocket);
TcpSocket->connectToHost (Host[1], Host[2].toInt());
 
connect(TcpSocket, SIGNAL(connected()), this, SLOT(slot_IP_Connected()) );
// connect(TcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slot_Error(QAbstractSocket::SocketError)));
b_isOpen = true;
i_Type = C_IP;
}
break;
}
 
return b_isOpen;
}
 
void cConnection::slot_IP_Connected()
{
connect(TcpSocket, SIGNAL(readyRead()), SLOT(slot_IP_ReadLine()));
connect(TcpSocket, SIGNAL(disconnected()),TcpSocket, SLOT(deleteLater()));
connect(TcpSocket, SIGNAL(disconnected()),this, SLOT(slot_IP_Disconnect()));
 
// emit sig_Connected();
}
 
void cConnection::slot_IP_Disconnect()
{
disconnect(TcpSocket, SIGNAL(disconnected()), 0, 0);
disconnect(TcpSocket, SIGNAL(readyRead()), 0, 0);
// emit sig_Disconnected(1);
}
 
void cConnection::slot_IP_ReadLine()
{
QString Input = QString(TcpSocket->readLine(TcpSocket->bytesAvailable())).remove(QChar(' '));
 
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];
}
}
}
 
bool cConnection::send_Cmd(char CMD, int Address, char Data[150],unsigned int Length, bool Resend)
{
if (b_isOpen)
{
QByteArray Temp;
QString TX_Data;
 
if (CMD != '#')
{
TX_Data = ToolBox::Encode64(Data, Length);
 
TX_Data = QString("#") + (QString('a' + Address)) + QString(CMD) + TX_Data;
TX_Data = ToolBox::add_CRC(TX_Data) + '\r';
 
Temp = QByteArray(TX_Data.toUtf8());
 
if (Resend)
{
o_Timer->start(2000);
s_ReSend = Temp;
}
}
else
{
for (unsigned int a = 0; a < Length; a++)
{
Temp[a] = Data[a];
}
}
 
switch(i_Type)
{
case C_TTY :
{
TTY->sendData(Temp);
}
break;
case C_IP :
{
TcpSocket->write(Temp);
}
break;
}
 
emit(showTerminal(3, TX_Data));
}
return true;
}
 
void cConnection::stop_ReSend()
{
o_Timer->stop();
}
 
void cConnection::slot_Timer()
{
switch(i_Type)
{
case C_TTY :
{
TTY->sendData(s_ReSend);
}
break;
case C_IP :
{
TcpSocket->write(s_ReSend);
}
break;
}
 
emit(showTerminal(3, QString(s_ReSend)));
}
/QMK-Groundstation/branches/own_com_lib/Classes/cConnection.h
0,0 → 1,73
/***************************************************************************
* 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 CCONNECTION_H
#define CCONNECTION_H
 
#include <QObject>
#include <QTcpSocket>
#include <QTimer>
 
#include "ToolBox.h"
#include "../global.h"
#include "../SerialPort/ManageSerialPort.h"
#include "../com/Parser.h"
 
#define C_TTY 1
#define C_IP 2
 
class cConnection : public QObject
{
Q_OBJECT
 
public:
cConnection();
bool isOpen();
bool Open(int Typ, QString Address);
bool Close();
bool send_Cmd(char CMD, int Address, char Data[150],unsigned int Length, bool Resend = true);
void stop_ReSend();
 
private:
ManageSerialPort *TTY;
QTcpSocket *TcpSocket;
QTimer *o_Timer;
 
QByteArray s_ReSend;
 
bool b_isOpen;
int i_Type;
sRxData RxData;
 
void new_Data(QString Data);
 
private slots:
void slot_newDataReceived(const QByteArray &dataReceived);
void slot_IP_Connected();
void slot_IP_Disconnect();
void slot_IP_ReadLine();
 
void slot_Timer();
// void slot_Error(QAbstractSocket::SocketError Error);
 
signals:
void newData(sRxData RxData);
void showTerminal(int Typ, QString Text);
};
 
#endif // CCONNECTION_H
/QMK-Groundstation/branches/own_com_lib/Classes/cKML_Server.cpp
0,0 → 1,136
/***************************************************************************
* 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 <QStringList>
 
#include "cKML_Server.h"
 
cKML_Server::cKML_Server()
{
NaviCount = 0;
}
 
void cKML_Server::start_Server(int Port, cSettings *Set)
{
Settings = Set;
 
TcpServer = new QTcpServer();
if (!TcpServer->listen(QHostAddress::Any, qint16(Port)))
{
qDebug("Kann Serversocket nicht Einrichten..!!");
}
else
{
connect(TcpServer, SIGNAL(newConnection()), this, SLOT(slot_NewConnection()));
}
}
 
void cKML_Server::stop_Server()
{
delete TcpServer;
}
 
void cKML_Server::store_NaviString(sNaviString Navi)
{
Route[NaviCount] = Navi;
NaviCount++;
}
 
void cKML_Server::slot_ReadData()
{
if (TcpSocket->canReadLine())
{
QStringList tokens = QString(TcpSocket->readLine()).split(QRegExp("[ \r\n][ \r\n]*"));
 
qDebug() << "QStringList ---------";
for (QList<QString>::iterator i = tokens.begin(); i != tokens.end(); ++i)
qDebug() << (*i);
}
 
TcpSocket->close();
}
 
void cKML_Server::slot_NewConnection()
{
TcpSocket = TcpServer->nextPendingConnection();
connect(TcpSocket, SIGNAL(readyRead ()),this, SLOT(slot_ReadData()));
 
QByteArray block;
 
block = "HTTP/1.0 200 OK\nContent-Type: application/vnd.google-earth.kml+xml; charset=iso-8859-1\nConnection: close\n\n";
// block = "HTTP/1.0 200 OK\nContent-Type: text/xml; charset=utf-8\nConnection: close\n\n";
 
TcpSocket->write(block);
 
TcpSocket->write(get_KML());
 
TcpSocket->close();
}
 
QByteArray cKML_Server::get_KML()
{
QByteArray block;
 
block = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<kml xmlns=\"http://earth.google.com/kml/2.2\">\n"
" <Document>\n"
" <name>Online Mikrokopter GPS Position</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";
if (Settings->Server.ToGround)
{
block = block + " <extrude>1</extrude>\n";
}
 
block = block +
" <tessellate>1</tessellate>\n"
" <altitudeMode>relativeToGround</altitudeMode>\n"
" <coordinates>\n";
 
for (int a = 0; a < NaviCount; a++)
{
block = block + Route[a].Longitude.toLatin1() + "," + Route[a].Latitude.toLatin1() + "," + Route[a].Altitude.toLatin1() + " " ;
block = block + "\n";
}
 
block = block +
" </coordinates>\n"
" </LineString>\n"
" </Placemark>\n"
" </Document>\n"
" </kml>\n";
 
return block;
}
 
cKML_Server::~cKML_Server()
{
}
/QMK-Groundstation/branches/own_com_lib/Classes/cKML_Server.h
0,0 → 1,57
/***************************************************************************
* 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 CKML_SERVER_H
#define CKML_SERVER_H
 
#include <QTcpServer>
#include <QTcpSocket>
 
//#include "../global.h"
#include "../Classes/cSettings.h"
 
class cKML_Server : public QObject
{
Q_OBJECT
 
public:
cKML_Server();
~cKML_Server();
 
void start_Server(int Port, cSettings *Set);
 
void stop_Server();
void store_NaviString(sNaviString Navi);
 
 
private:
QTcpServer *TcpServer;
QTcpSocket *TcpSocket;
 
cSettings *Settings;
 
QByteArray get_KML();
sNaviString Route[MaxNaviPos];
int NaviCount;
 
private slots:
void slot_NewConnection();
void slot_ReadData();
};
 
#endif // CSERVER_H
/QMK-Groundstation/branches/own_com_lib/Classes/cQMK_Server.cpp
0,0 → 1,143
/***************************************************************************
* Copyright (C) 2008-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 "cQMK_Server.h"
#include "ToolBox.h"
 
cQMK_Server::cQMK_Server()
{
}
 
void cQMK_Server::Connect(QString IP, int Port, QString User, QString Pass)
{
Username = User;
Password = Pass;
 
TcpSocket = new(QTcpSocket);
TcpSocket->connectToHost (IP, Port);
 
connect(TcpSocket, SIGNAL(connected()), this, SLOT(slot_Connected()) );
connect(TcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slot_Error(QAbstractSocket::SocketError)));
}
 
void cQMK_Server::Disconnect()
{
TcpSocket->disconnectFromHost();
disconnect(TcpSocket, SIGNAL(connected()), 0, 0);
disconnect(TcpSocket, SIGNAL(readyRead()), 0, 0);
disconnect(TcpSocket, SIGNAL(disconnected()), 0, 0);
}
 
void cQMK_Server::SendData(int CMD, QString Data)
{
QString SendString = QString(QString("%1").arg(CMD) + ":" + Data + ":");
 
int CRC = qChecksum(SendString.toLatin1().data(), SendString.length());
QString sCRC = QString("%1").arg(CRC);
 
SendString = SendString + sCRC + "\n";
 
QByteArray SendText = SendString.toAscii();
 
TcpSocket->write(SendText);
}
 
void cQMK_Server::NewPosition(sNaviString Pos)
{
if (1==1)
{
SendData(100, QString(Pos.Longitude + ":" + Pos.Latitude + ":" + Pos.Altitude));
}
}
 
void cQMK_Server::send_RawData(QString Data)
{
Data = Data + "\n";
 
QByteArray SendText = Data.toAscii();
 
TcpSocket->write(SendText);
}
 
void cQMK_Server::slot_Connected()
{
connect(TcpSocket, SIGNAL(readyRead()), SLOT(slot_ReadLine()));
connect(TcpSocket, SIGNAL(disconnected()),TcpSocket, SLOT(deleteLater()));
connect(TcpSocket, SIGNAL(disconnected()),this, SLOT(slot_Disconnect()));
 
emit sig_Connected();
}
 
void cQMK_Server::slot_Disconnect()
{
disconnect(TcpSocket, SIGNAL(disconnected()), 0, 0);
emit sig_Disconnected(1);
}
 
void cQMK_Server::slot_Error(QAbstractSocket::SocketError Error)
{
switch (Error)
{
case QAbstractSocket::ConnectionRefusedError:
emit sig_Disconnected(2);
break;
case QAbstractSocket::RemoteHostClosedError:
emit sig_Disconnected(1);
break;
default:
emit sig_Disconnected(0);
break;
}
 
disconnect(TcpSocket, SIGNAL(disconnected()), 0, 0);
emit sig_Disconnected(2);
}
 
void cQMK_Server::slot_ReadLine()
{
QString Input = QString(TcpSocket->readLine(TcpSocket->bytesAvailable())).remove(QChar('\n'));
 
QStringList Data = Input.split(":");
 
if (Data.count() > 1)
{
int CMD = Data[0].toInt();
 
switch(CMD)
{
case 1 :
{
SendData(1, QString(QA_NAME + " " + QA_VERSION + " [" + QA_OS + "]:" + Username + ":" + Password + ":"));
}
break;
case 2 :
{
// qDebug("Login OK");
}
break;
case 3 :
{
emit sig_Disconnected(3);
}
break;
}
}
}
 
 
 
/QMK-Groundstation/branches/own_com_lib/Classes/cQMK_Server.h
0,0 → 1,58
 
/***************************************************************************
* Copyright (C) 2008-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 CQMK_SERVER_H
#define CQMK_SERVER_H
 
#include <QString>
#include <QTcpSocket>
#include <QStringList>
 
#include "../global.h"
 
class cQMK_Server : public QObject
{
Q_OBJECT
 
public:
cQMK_Server();
void Connect(QString IP, int Port, QString User, QString Pass);
void Disconnect();
void NewPosition(sNaviString Pos);
void send_RawData(QString Data);
 
private:
//TCP-Socket
QTcpSocket *TcpSocket;
QString Username;
QString Password;
void SendData(int CMD, QString Data);
 
private slots:
void slot_Connected();
void slot_Disconnect();
void slot_ReadLine();
void slot_Error(QAbstractSocket::SocketError Error);
 
signals:
void sig_Connected();
void sig_Disconnected(int Error);
};
 
#endif // CQMK_SERVER_H
/QMK-Groundstation/branches/own_com_lib/Classes/cSettings.cpp
0,0 → 1,284
/***************************************************************************
* 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 <QCoreApplication>
#include <QSettings>
#include <QDir>
 
#include "cSettings.h"
 
cSettings::cSettings()
{
read_SettingsID();
 
if (Settings_ID < 3)
{
QBitArray Def_TabViews;
Def_TabViews.fill(true, 6);
 
qDebug("Konvertiere Einstellungen Version 1+2 -> 3");
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("GUI");
GUI.TabViews = Setting.value("TabViews", QBitArray(Def_TabViews)).value<QBitArray>();
 
GUI.TabViews.resize(10);
GUI.TabViews[6] = true;
 
Setting.setValue("TabViews", QBitArray(GUI.TabViews));
Setting.endGroup();
}
 
read_Settings();
 
Analog1.LogView.resize(MaxAnalog);
Analog1.PlotView.resize(MaxAnalog);
 
// Alte Settingsstruktur Löschen.
if (Settings_ID < 2)
{
qDebug("Konvertiere Einstellungen Version 1 -> 2");
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("AnalogWerte");
for (int a = 0; a < MaxAnalog; a++)
{
Analog1.LogView.setBit(a, Setting.value(("Analog_" + QString("%1").arg(a) + "_Log"), Def_Log[a]).toBool());
Analog1.PlotView.setBit(a, Setting.value(("Analog_" + QString("%1").arg(a) + "_Plot"), Def_Plot_Show[a]).toBool());
Analog1.Label[a] = Setting.value(("Analog_" + QString("%1").arg(a)), Def_AnalogNames[a]).toString();
}
Setting.endGroup();
 
Setting.remove("AnalogWerte-FC");
Setting.remove("AnalogWerte");
 
write_Settings_Analog();
write_Settings_AnalogLabels();
}
else
{
read_Settings_Analog();
read_Settings_AnalogLabels();
}
 
Settings_ID = 3;
}
 
// Config der Analogwert-Anzeige (Plotter / CVS)
void cSettings::write_Settings_Analog(int ID)
{
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Analog-Werte");
Setting.setValue(Hardware + "-LogView", QBitArray(Analog1.LogView));
Setting.setValue(Hardware + "-PlotView", QBitArray(Analog1.PlotView));
Setting.endGroup();
}
 
void cSettings::read_Settings_Analog(int ID)
{
QBitArray Def_View;
Def_View.fill(true,MaxAnalog);
 
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Analog-Werte");
Analog1.LogView = Setting.value(Hardware + "-LogView", QBitArray(Def_View)).value<QBitArray>();
Analog1.PlotView = Setting.value(Hardware + "-PlotView", QBitArray(Def_View)).value<QBitArray>();
Setting.endGroup();
}
 
// Labels der Analogwerte.
void cSettings::write_Settings_AnalogLabels(int ID)
{
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation-Labels");
 
Setting.beginGroup("Analog-Labels-" + Hardware);
Setting.setValue("Version", Analog1.Version);
for (int a=0; a<MaxAnalog; a++)
{
Setting.setValue("Label_" + QString("%1").arg(a), Analog1.Label[a]);
}
Setting.endGroup();
}
 
void cSettings::read_Settings_AnalogLabels(int ID)
{
QString Hardware = HardwareType[ID];
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation-Labels");
 
Setting.beginGroup("Analog-Labels-" + Hardware);
Analog1.Version = Setting.value(("Version"), "0").toString();
for (int a=0; a<MaxAnalog; a++)
{
Analog1.Label[a] = Setting.value(("Label_" + QString("%1").arg(a)), Def_AnalogNames[a]).toString();
}
Setting.endGroup();
}
 
// Programmeinstellungen
void cSettings::read_SettingsID()
{
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Global");
Settings_ID = Setting.value("Settings ID", 1).toInt();
Setting.endGroup();
}
 
// Programmeinstellungen
void cSettings::read_Settings()
{
QBitArray Def_BitArray;
Def_BitArray.fill(true, 10);
 
QDir Dir;
 
QString HomeDir = (QString(Dir.homePath() + "/"));
 
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Global");
Settings_ID = Setting.value("Settings ID", 1).toInt();
Setting.endGroup();
 
Setting.beginGroup("Port");
TTY.Port = Setting.value("TTY", QString(OS_PORT)).toString();
Setting.endGroup();
 
Setting.beginGroup("GUI");
GUI.isMax = Setting.value("IsMax",false).toBool();
GUI.Size = Setting.value("Size", QSize(700, 300)).toSize();
GUI.Point = Setting.value("Point",QPoint(1,1)).toPoint();
GUI.TabViews = Setting.value("TabViews", QBitArray(Def_BitArray)).value<QBitArray>();
GUI.ToolViews = Setting.value("ToolViews", QBitArray(Def_BitArray)).value<QBitArray>();
GUI.Term_Info = Setting.value("Terminal_Info",false).toBool();
GUI.Term_Data = Setting.value("Terminal_Data",true).toBool();
GUI.Term_Always = Setting.value("Terminal_Always",false).toBool();
GUI.Term_Send = Setting.value("Terminal_Send",true).toBool();
Setting.endGroup();
 
Setting.beginGroup("Map");
Map.GotoPosition = Setting.value("Goto_Position",true).toBool();
Map.ShowTrack = Setting.value("Show_Track",true).toBool();
Setting.endGroup();
 
Setting.beginGroup("Dirs");
DIR.Logging = Setting.value("LogDir", HomeDir).toString();
DIR.Parameter = Setting.value("ParDir", HomeDir).toString();
DIR.Cache = Setting.value("Dir_MapCache", HomeDir + ".QMK-Cache").toString();
DIR.AVRDUDE = Setting.value("Path_AVRDUDE", "avrdude").toString();
Setting.endGroup();
 
Setting.beginGroup("MKData");
Data.Plotter_Count = Setting.value("Plotter_Count", 100).toInt();
Data.Debug_Fast = Setting.value("Debug_Fast", 100).toInt();
Data.Debug_Slow = Setting.value("Debug_Slow", 500).toInt();
Data.Debug_Off = Setting.value("Debug_Off", 1000).toInt();
Data.Navi_Fast = Setting.value("Navi_Fast", 100).toInt();
Data.Navi_Slow = Setting.value("Navi_Slow", 500).toInt();
Data.Navi_Off = Setting.value("Navi_Off", 1000).toInt();
Setting.endGroup();
 
Setting.beginGroup("GoogleEarth-Server");
Server.Port = Setting.value("Port", 10664).toString();
Server.StartServer = Setting.value("StartServer", false).toBool();
Server.ToGround = Setting.value("ToGround", false).toBool();
Setting.endGroup();
 
Setting.beginGroup("QMK-Server");
Server.QMKS_Login = Setting.value("Login", "").toString();
Server.QMKS_Password = Setting.value("Password", "").toString();
Server.QMKS_Host = Setting.value("Host", "nimari.de").toString();
Server.QMKS_Port = Setting.value("Port", "16441").toString();
Setting.endGroup();
 
}
 
void cSettings::write_Settings()
{
QSettings Setting("KeyOz-Net", "QMK-Groundstation");
 
Setting.beginGroup("Global");
Setting.setValue("Settings ID", Settings_ID);
Setting.endGroup();
 
Setting.beginGroup("Port");
Setting.setValue("TTY", TTY.Port);
Setting.endGroup();
 
Setting.beginGroup("Dirs");
Setting.setValue("LogDir", DIR.Logging);
Setting.setValue("ParDir", DIR.Parameter);
Setting.setValue("Dir_MapCache", DIR.Cache);
Setting.setValue("Path_AVRDUDE", DIR.AVRDUDE);
Setting.endGroup();
 
Setting.beginGroup("GUI");
Setting.setValue("IsMax", GUI.isMax);
Setting.setValue("Size", GUI.Size);
Setting.setValue("Point", GUI.Point);
Setting.setValue("TabViews", QBitArray(GUI.TabViews));
Setting.setValue("ToolViews", QBitArray(GUI.ToolViews));
Setting.setValue("Terminal_Info", GUI.Term_Info);
Setting.setValue("Terminal_Data", GUI.Term_Data);
Setting.setValue("Terminal_Always", GUI.Term_Always);
Setting.setValue("Terminal_Send", GUI.Term_Send);
Setting.endGroup();
 
Setting.beginGroup("Map");
Setting.setValue("Goto_Position", Map.GotoPosition);
Setting.setValue("Show_Track", Map.ShowTrack);
Setting.endGroup();
 
Setting.beginGroup("MKData");
Setting.setValue("Plotter_Count", Data.Plotter_Count);
Setting.setValue("Debug_Fast", Data.Debug_Fast);
Setting.setValue("Debug_Slow", Data.Debug_Slow);
Setting.setValue("Debug_Off", Data.Debug_Off);
Setting.setValue("Navi_Fast", Data.Navi_Fast);
Setting.setValue("Navi_Slow", Data.Navi_Slow);
Setting.setValue("Navi_Off", Data.Navi_Off);
Setting.endGroup();
 
Setting.beginGroup("GoogleEarth-Server");
Setting.setValue("Port", Server.Port);
Setting.setValue("StartServer", Server.StartServer);
Setting.setValue("ToGround", Server.ToGround);
Setting.endGroup();
 
Setting.beginGroup("QMK-Server");
Setting.setValue("Login", Server.QMKS_Login);
Setting.setValue("Password", Server.QMKS_Password);
Setting.setValue("Host", Server.QMKS_Host);
Setting.setValue("Port", Server.QMKS_Port);
Setting.endGroup();
}
 
cSettings::~cSettings()
{
}
 
 
/QMK-Groundstation/branches/own_com_lib/Classes/cSettings.h
0,0 → 1,113
/***************************************************************************
* 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 CSETTINGS_H
#define CSETTINGS_H
 
//#include "../global.h"
#include "../com/Kopter.h"
 
struct set_TTY
{
QString Port;
};
 
struct set_GUI
{
bool isMax;
QSize Size;
QPoint Point;
QBitArray TabViews;
QBitArray ToolViews;
bool Term_Info;
bool Term_Data;
bool Term_Always;
bool Term_Send;
};
 
struct set_Map
{
bool GotoPosition;
bool ShowTrack;
};
 
struct set_Data
{
int Plotter_Count;
int Debug_Fast;
int Debug_Slow;
int Debug_Off;
int Navi_Fast;
int Navi_Slow;
int Navi_Off;
};
 
struct set_DIR
{
QString Logging;
QString Parameter;
QString Cache;
QString AVRDUDE;
};
 
struct set_Server
{
QString Port;
bool StartServer;
bool ToGround;
QString QMKS_Login;
QString QMKS_Password;
QString QMKS_Host;
QString QMKS_Port;
};
 
 
struct set_Analog
{
QString Version;
QString Label[MaxAnalog];
QBitArray PlotView;
QBitArray LogView;
};
 
class cSettings
{
public:
cSettings();
~cSettings();
 
int Settings_ID;
 
set_GUI GUI;
set_DIR DIR;
set_TTY TTY;
set_Analog Analog1;
set_Data Data;
set_Server Server;
set_Map Map;
 
void read_Settings();
void read_SettingsID();
void write_Settings();
void write_Settings_Analog(int ID = 0);
void read_Settings_Analog(int ID = 0);
void write_Settings_AnalogLabels(int ID = 0);
void read_Settings_AnalogLabels(int ID = 0);
};
 
#endif
/QMK-Groundstation/branches/own_com_lib/Classes/cSpeedMeter.cpp
0,0 → 1,44
#include <qpainter.h>
#include <qwt_dial_needle.h>
#include "cSpeedMeter.h"
 
cSpeedMeter::cSpeedMeter(QWidget *parent): QwtDial(parent), d_label("m/s")
{
setWrapping(false);
setReadOnly(true);
 
setOrigin(125.0);
setScaleArc(0.0, 270.0);
scaleDraw()->setSpacing(8);
 
QwtDialSimpleNeedle *needle = new QwtDialSimpleNeedle(QwtDialSimpleNeedle::Arrow, true, Qt::red, QColor(Qt::gray).light(130));
setNeedle(needle);
 
setScaleOptions(ScaleTicks | ScaleLabel);
setScaleTicks(0, 4, 8);
}
 
void cSpeedMeter::setLabel(const QString &label)
{
d_label = label;
update();
}
 
QString cSpeedMeter::label() const
{
return d_label;
}
 
void cSpeedMeter::drawScaleContents(QPainter *painter, const QPoint &center, int radius) const
{
QRect rect(0, 0, 2 * radius, 2 * radius - 10);
rect.moveCenter(center);
 
const QColor color =
 
palette().color(QPalette::Text);
painter->setPen(color);
 
const int flags = Qt::AlignBottom | Qt::AlignHCenter;
painter->drawText(rect, flags, d_label);
}
/QMK-Groundstation/branches/own_com_lib/Classes/cSpeedMeter.h
0,0 → 1,17
#include <qstring.h>
#include <qwt_dial.h>
 
class cSpeedMeter: public QwtDial
{
public:
cSpeedMeter(QWidget *parent = NULL);
 
void setLabel(const QString &);
QString label() const;
 
protected:
virtual void drawScaleContents(QPainter *painter, const QPoint &center, int radius) const;
 
private:
QString d_label;
};
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Config.cpp
0,0 → 1,127
/***************************************************************************
* 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 "dlg_Config.h"
 
dlg_Config::dlg_Config(QWidget *parent) : QDialog(parent)
{
setupUi(this);
 
cb_Plot[0] = cb_Plot_0;
cb_Plot[1] = cb_Plot_1;
cb_Plot[2] = cb_Plot_2;
cb_Plot[3] = cb_Plot_3;
cb_Plot[4] = cb_Plot_4;
cb_Plot[5] = cb_Plot_5;
cb_Plot[6] = cb_Plot_6;
cb_Plot[7] = cb_Plot_7;
cb_Plot[8] = cb_Plot_8;
cb_Plot[9] = cb_Plot_9;
cb_Plot[10] = cb_Plot_10;
cb_Plot[11] = cb_Plot_11;
cb_Plot[12] = cb_Plot_12;
cb_Plot[13] = cb_Plot_13;
cb_Plot[14] = cb_Plot_14;
cb_Plot[15] = cb_Plot_15;
cb_Plot[16] = cb_Plot_16;
cb_Plot[17] = cb_Plot_17;
cb_Plot[18] = cb_Plot_18;
cb_Plot[19] = cb_Plot_19;
cb_Plot[20] = cb_Plot_20;
cb_Plot[21] = cb_Plot_21;
cb_Plot[22] = cb_Plot_22;
cb_Plot[23] = cb_Plot_23;
cb_Plot[24] = cb_Plot_24;
cb_Plot[25] = cb_Plot_25;
cb_Plot[26] = cb_Plot_26;
cb_Plot[27] = cb_Plot_27;
cb_Plot[28] = cb_Plot_28;
cb_Plot[29] = cb_Plot_29;
cb_Plot[30] = cb_Plot_30;
cb_Plot[31] = cb_Plot_31;
 
cb_Log[0] = cb_Log_0;
cb_Log[1] = cb_Log_1;
cb_Log[2] = cb_Log_2;
cb_Log[3] = cb_Log_3;
cb_Log[4] = cb_Log_4;
cb_Log[5] = cb_Log_5;
cb_Log[6] = cb_Log_6;
cb_Log[7] = cb_Log_7;
cb_Log[8] = cb_Log_8;
cb_Log[9] = cb_Log_9;
cb_Log[10] = cb_Log_10;
cb_Log[11] = cb_Log_11;
cb_Log[12] = cb_Log_12;
cb_Log[13] = cb_Log_13;
cb_Log[14] = cb_Log_14;
cb_Log[15] = cb_Log_15;
cb_Log[16] = cb_Log_16;
cb_Log[17] = cb_Log_17;
cb_Log[18] = cb_Log_18;
cb_Log[19] = cb_Log_19;
cb_Log[20] = cb_Log_20;
cb_Log[21] = cb_Log_21;
cb_Log[22] = cb_Log_22;
cb_Log[23] = cb_Log_23;
cb_Log[24] = cb_Log_24;
cb_Log[25] = cb_Log_25;
cb_Log[26] = cb_Log_26;
cb_Log[27] = cb_Log_27;
cb_Log[28] = cb_Log_28;
cb_Log[29] = cb_Log_29;
cb_Log[30] = cb_Log_30;
cb_Log[31] = cb_Log_31;
 
}
 
void dlg_Config::set_Settings(cSettings *Set, int ID)
{
Settings = Set;
 
lb_Hardware->setText(HardwareType[ID]);
 
for (int a = 0; a < MaxAnalog; a++)
{
cb_Plot[a]->setText(Settings->Analog1.Label[a]);
cb_Plot[a]->setChecked(Settings->Analog1.PlotView[a]);
cb_Log[a]->setText(Settings->Analog1.Label[a]);
cb_Log[a]->setChecked(Settings->Analog1.LogView[a]);
}
}
 
cSettings *dlg_Config::get_Settings()
{
for (int a = 0; a < MaxAnalog; a++)
{
Settings->Analog1.PlotView.setBit(a,cb_Plot[a]->isChecked());
}
 
for (int a = 0; a < MaxAnalog; a++)
{
Settings->Analog1.LogView.setBit(a,cb_Log[a]->isChecked());
}
 
return Settings;
}
 
dlg_Config::~dlg_Config()
{
}
 
 
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Config.h
0,0 → 1,45
/***************************************************************************
* 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 DLG_CONFIG_H
#define DLG_CONFIG_H
 
#include <QCheckBox>
 
#include "ui_dlg_Config.h"
#include "../Classes/cSettings.h"
//#include "../global.h"
 
class dlg_Config : public QDialog, public Ui::dlg_Config_UI
{
public:
dlg_Config(QWidget *parent = 0);
 
~dlg_Config();
 
void set_Settings(cSettings *Set, int ID = 0);
cSettings *get_Settings();
 
private:
cSettings *Settings;
QCheckBox *cb_Plot[MaxAnalog];
QCheckBox *cb_Log[MaxAnalog];
 
};
 
#endif
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Config.ui
0,0 → 1,690
<ui version="4.0" >
<class>dlg_Config_UI</class>
<widget class="QDialog" name="dlg_Config_UI" >
<property name="geometry" >
<rect>
<x>0</x>
<y>0</y>
<width>528</width>
<height>335</height>
</rect>
</property>
<property name="windowTitle" >
<string>Auswahl Datenfelder</string>
</property>
<layout class="QGridLayout" name="gridLayout" >
<item row="1" column="0" >
<layout class="QHBoxLayout" >
<property name="spacing" >
<number>6</number>
</property>
<property name="margin" >
<number>0</number>
</property>
<item>
<widget class="QLabel" name="label_3" >
<property name="text" >
<string>Datenfelder für: </string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="lb_Hardware" >
<property name="font" >
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text" >
<string>Default</string>
</property>
</widget>
</item>
<item>
<spacer>
<property name="orientation" >
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0" >
<size>
<width>131</width>
<height>31</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="okButton" >
<property name="text" >
<string>OK</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="cancelButton" >
<property name="text" >
<string>Cancel</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="0" column="0" >
<widget class="QTabWidget" name="tabWidget" >
<property name="currentIndex" >
<number>0</number>
</property>
<widget class="QWidget" name="ct_3" >
<attribute name="title" >
<string>Auswahl Plotter </string>
</attribute>
<layout class="QGridLayout" name="gridLayout_6" >
<item row="1" column="0" >
<widget class="QFrame" name="frame" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_2" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Plot_0" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Plot_1" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Plot_2" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Plot_3" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Plot_4" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Plot_5" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Plot_6" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Plot_7" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="1" >
<widget class="QFrame" name="frame_2" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_3" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Plot_8" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Plot_9" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Plot_10" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Plot_11" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Plot_12" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Plot_13" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Plot_14" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Plot_15" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="2" >
<widget class="QFrame" name="frame_3" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_4" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Plot_16" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Plot_17" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Plot_18" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Plot_19" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Plot_20" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Plot_21" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Plot_22" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Plot_23" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="3" >
<widget class="QFrame" name="frame_4" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_5" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Plot_24" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Plot_25" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Plot_26" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Plot_27" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Plot_28" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Plot_29" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Plot_30" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Plot_31" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="0" column="0" colspan="4" >
<widget class="QLabel" name="label" >
<property name="text" >
<string>Auswahl der Analogwerte, die im Plotter angezeigt werden.</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="ct_2" >
<attribute name="title" >
<string>Auswahl CSV-Record </string>
</attribute>
<layout class="QGridLayout" name="gridLayout_11" >
<item row="1" column="0" >
<widget class="QFrame" name="frame_5" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_7" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Log_0" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Log_1" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Log_2" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Log_3" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Log_4" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Log_5" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Log_6" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Log_7" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="1" >
<widget class="QFrame" name="frame_6" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_8" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Log_8" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Log_9" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Log_10" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Log_11" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Log_12" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Log_13" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Log_14" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Log_15" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="2" >
<widget class="QFrame" name="frame_7" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_9" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Log_16" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Log_17" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Log_18" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Log_19" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Log_20" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Log_21" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Log_22" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Log_23" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="3" >
<widget class="QFrame" name="frame_8" >
<property name="frameShape" >
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow" >
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_10" >
<item row="0" column="0" >
<widget class="QCheckBox" name="cb_Log_24" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="1" column="0" >
<widget class="QCheckBox" name="cb_Log_25" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="2" column="0" >
<widget class="QCheckBox" name="cb_Log_26" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="3" column="0" >
<widget class="QCheckBox" name="cb_Log_27" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_Log_28" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="5" column="0" >
<widget class="QCheckBox" name="cb_Log_29" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="6" column="0" >
<widget class="QCheckBox" name="cb_Log_30" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
<item row="7" column="0" >
<widget class="QCheckBox" name="cb_Log_31" >
<property name="text" >
<string>CheckBox</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="0" column="0" colspan="4" >
<widget class="QLabel" name="label_2" >
<property name="text" >
<string>Auswahl der Analogwerte, die ins Log-File geschrieben werden.</string>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>okButton</sender>
<signal>clicked()</signal>
<receiver>dlg_Config_UI</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel" >
<x>278</x>
<y>253</y>
</hint>
<hint type="destinationlabel" >
<x>96</x>
<y>254</y>
</hint>
</hints>
</connection>
<connection>
<sender>cancelButton</sender>
<signal>clicked()</signal>
<receiver>dlg_Config_UI</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel" >
<x>369</x>
<y>253</y>
</hint>
<hint type="destinationlabel" >
<x>179</x>
<y>282</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_LCD.cpp
0,0 → 1,32
/***************************************************************************
* 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 "dlg_LCD.h"
 
dlg_LCD::dlg_LCD(QWidget *parent) : QDialog(parent)
{
setupUi(this);
}
 
void dlg_LCD::show_Data(int *Data)
{
le_LCD0->setText(ToolBox::Data2QString(Data,2,22));
le_LCD1->setText(ToolBox::Data2QString(Data,22,42));
le_LCD2->setText(ToolBox::Data2QString(Data,42,62));
le_LCD3->setText(ToolBox::Data2QString(Data,62,82));
}
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_LCD.h
0,0 → 1,36
/***************************************************************************
* 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 DLG_LCD_H
#define DLG_LCD_H
 
#include <QObject>
 
#include "ui_dlg_LCD.h"
#include "../Classes/ToolBox.h"
 
class dlg_LCD : public QDialog, public Ui::dlg_LCD_UI
{
Q_OBJECT
 
public:
dlg_LCD(QWidget *parent = 0);
void show_Data(int *Data);
};
 
#endif // DLG_LCD_H
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_LCD.ui
0,0 → 1,208
<ui version="4.0" >
<class>dlg_LCD_UI</class>
<widget class="QDialog" name="dlg_LCD_UI" >
<property name="geometry" >
<rect>
<x>0</x>
<y>0</y>
<width>250</width>
<height>205</height>
</rect>
</property>
<property name="windowTitle" >
<string>LCD-Display</string>
</property>
<layout class="QGridLayout" name="gridLayout" >
<item row="0" column="0" >
<layout class="QGridLayout" name="gridLayout_41" >
<item row="0" column="0" colspan="3" >
<widget class="QLineEdit" name="le_LCD0" >
<property name="sizePolicy" >
<sizepolicy vsizetype="Minimum" hsizetype="Minimum" >
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize" >
<size>
<width>240</width>
<height>0</height>
</size>
</property>
<property name="font" >
<font>
<family>Courier 10 Pitch</family>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text" >
<string/>
</property>
<property name="maxLength" >
<number>22</number>
</property>
<property name="alignment" >
<set>Qt::AlignCenter</set>
</property>
<property name="readOnly" >
<bool>true</bool>
</property>
</widget>
</item>
<item row="1" column="0" colspan="3" >
<widget class="QLineEdit" name="le_LCD1" >
<property name="minimumSize" >
<size>
<width>240</width>
<height>0</height>
</size>
</property>
<property name="font" >
<font>
<family>Courier 10 Pitch</family>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text" >
<string/>
</property>
<property name="maxLength" >
<number>22</number>
</property>
<property name="alignment" >
<set>Qt::AlignCenter</set>
</property>
<property name="readOnly" >
<bool>false</bool>
</property>
</widget>
</item>
<item row="2" column="0" colspan="3" >
<widget class="QLineEdit" name="le_LCD2" >
<property name="minimumSize" >
<size>
<width>240</width>
<height>0</height>
</size>
</property>
<property name="font" >
<font>
<family>Courier 10 Pitch</family>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text" >
<string/>
</property>
<property name="maxLength" >
<number>22</number>
</property>
<property name="alignment" >
<set>Qt::AlignCenter</set>
</property>
<property name="readOnly" >
<bool>false</bool>
</property>
</widget>
</item>
<item row="3" column="0" colspan="3" >
<widget class="QLineEdit" name="le_LCD3" >
<property name="minimumSize" >
<size>
<width>240</width>
<height>0</height>
</size>
</property>
<property name="font" >
<font>
<family>Courier 10 Pitch</family>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text" >
<string/>
</property>
<property name="maxLength" >
<number>22</number>
</property>
<property name="alignment" >
<set>Qt::AlignCenter</set>
</property>
<property name="readOnly" >
<bool>true</bool>
</property>
</widget>
</item>
<item row="4" column="0" >
<widget class="QCheckBox" name="cb_LCD" >
<property name="text" >
<string>Auto-Refresh </string>
</property>
<property name="checked" >
<bool>true</bool>
</property>
</widget>
</item>
<item row="4" column="1" >
<widget class="QPushButton" name="pb_LCDdown" >
<property name="text" >
<string/>
</property>
<property name="icon" >
<iconset resource="../MKTool.qrc" >
<normaloff>:/Arrows/Images/Arrows/Left-1.png</normaloff>:/Arrows/Images/Arrows/Left-1.png</iconset>
</property>
</widget>
</item>
<item row="4" column="2" >
<widget class="QPushButton" name="pb_LCDup" >
<property name="text" >
<string/>
</property>
<property name="icon" >
<iconset resource="../MKTool.qrc" >
<normaloff>:/Arrows/Images/Arrows/Right-1.png</normaloff>:/Arrows/Images/Arrows/Right-1.png</iconset>
</property>
</widget>
</item>
</layout>
</item>
<item row="1" column="0" >
<widget class="QPushButton" name="pushButton" >
<property name="text" >
<string>Schließen</string>
</property>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="../MKTool.qrc" />
</resources>
<connections>
<connection>
<sender>pushButton</sender>
<signal>clicked()</signal>
<receiver>dlg_LCD_UI</receiver>
<slot>close()</slot>
<hints>
<hint type="sourcelabel" >
<x>124</x>
<y>187</y>
</hint>
<hint type="destinationlabel" >
<x>124</x>
<y>102</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Map.cpp
0,0 → 1,493
/***************************************************************************
* 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 "dlg_Map.h"
#include <QDomDocument>
#include <QFile>
 
dlg_Map::dlg_Map(QWidget *parent) : QDialog(parent)
{
setupUi(this);
 
cb_Maps->removeItem(5);
cb_Maps->removeItem(4);
cb_Maps->removeItem(3);
cb_Maps->removeItem(2);
 
pb_Add->setEnabled(false);
pb_Goto->setEnabled(false);
}
 
// Karte erstellen und anzeigen
void dlg_Map::create_Map(cSettings *t_Settings)
{
o_Settings = t_Settings;
 
cb_CenterPos->setChecked(o_Settings->Map.GotoPosition);
cb_ShowRoute->setChecked(o_Settings->Map.ShowTrack);
 
connect(sl_Zoom, SIGNAL(valueChanged(int)), this, SLOT(slot_Zoom(int)));
connect(pb_Add, SIGNAL(clicked()), this, SLOT(slot_AddWayPoint()));
connect(pb_Delete, SIGNAL(clicked()), this, SLOT(slot_DeleteWayPoints()));
connect(pb_Goto, SIGNAL(clicked()), this, SLOT(slot_GotoTarget()));
connect(pb_SendWaypoints, SIGNAL(clicked()), this, SLOT(slot_SendWayPoints()));
 
connect(pb_Load, SIGNAL(clicked()), this, SLOT(slot_LoadWayPoints()));
connect(pb_Save, SIGNAL(clicked()), this, SLOT(slot_SaveWayPoints()));
 
connect(cb_Maps, SIGNAL(currentIndexChanged(int)), this, SLOT(slot_ChangeMap(int)));
connect(cb_ShowWPs, SIGNAL(toggled(bool)), this, SLOT(slot_ShowWayPoints(bool)));
 
connect(this, SIGNAL(rejected()), this, SLOT(slot_Close()));
 
o_Map = new MapControl(w_Map->size());
o_Map->enablePersistentCache(o_Settings->DIR.Cache);
o_Map->showScale(true);
 
o_Adapter = new OSMMapAdapter();
 
o_Layer = new MapLayer("MapLayer", o_Adapter);
o_Click = new GeometryLayer("Click", o_Adapter);
o_Route = new GeometryLayer("Poute", o_Adapter);
 
o_Map->addLayer(o_Layer);
o_Map->addLayer(o_Click);
o_Map->addLayer(o_Route);
 
o_Map->setZoom(17);
o_Map->setView(QPointF(13.5,52.5));
 
connect(o_Map, SIGNAL(mouseEventCoordinate(const QMouseEvent*, const QPointF)), this, SLOT(slot_Click(const QMouseEvent*, const QPointF)));
 
l_Map->addWidget(o_Map);
 
sl_Zoom->setValue(17);
 
Pen[0] = new QPen(QColor(0,0,255,255));
Pen[0]->setWidth(2);
Pen[1] = new QPen(QColor(255,0,0,255));
Pen[1]->setWidth(2);
}
 
QList<sWayPoint> dlg_Map::parse_WayPointKML(QString s_File)
{
QList<sWayPoint> tmp_WayPoints;
sWayPoint tmp_WayPoint;
 
QFile f_KML(s_File);
f_KML.open(QIODevice::ReadOnly | QIODevice::Text);
 
QByteArray s_KML;
 
while (!f_KML.atEnd())
{
s_KML.append(f_KML.readLine());
}
 
f_KML.close();
 
QDomDocument *UserXML;
UserXML = new QDomDocument;
 
UserXML->setContent(s_KML);
 
QDomElement Root = UserXML->firstChildElement("kml");
QDomElement Document = Root.firstChildElement("Document");
QDomElement Placemark = Document.firstChildElement("Placemark");
QDomElement Linestring = Placemark.firstChildElement("LineString");
 
QString Name = Placemark.firstChildElement("name").toElement().text();
 
QString Route = Linestring.firstChildElement("coordinates").toElement().text();
 
QStringList s_Points = Route.split(" ");
 
QStringList Position;
 
for (int z = 0; z < s_Points.count() - 1; z++)
{
if (z != 20)
{
Position = s_Points[z].split(",");
tmp_WayPoint.Longitude = Position[0].toDouble();
tmp_WayPoint.Latitude = Position[1].toDouble();
tmp_WayPoint.Altitude = Position[2].toDouble();
tmp_WayPoint.Time = sb_Time->value();
 
tmp_WayPoints.append(tmp_WayPoint);
}
else
{
QMessageBox::warning(this, QA_NAME,trUtf8("Die Wegpunkt-Liste umfasst mehr als 20 Einträge. Es werden nur die ersten 20 Einträge übernommen."), QMessageBox::Ok);
 
pb_Add->setEnabled(false);
 
z = s_Points.count();
}
}
return tmp_WayPoints;
}
 
QList<sWayPoint> dlg_Map::parse_WayPointMKW(QString s_File)
{
QList<sWayPoint> tmp_WayPoints;
sWayPoint tmp_WayPoint;
 
QFile f_MKW(s_File);
f_MKW.open(QIODevice::ReadOnly | QIODevice::Text);
 
QString s_MKW;
 
while (!f_MKW.atEnd())
{
s_MKW.append(f_MKW.readLine());
}
 
f_MKW.close();
 
QStringList s_Points = s_MKW.split(" ");
 
QStringList Position;
 
for (int z = 0; z < s_Points.count() - 1; z++)
{
if (z != 20)
{
Position = s_Points[z].split(",");
tmp_WayPoint.Longitude = Position[0].toDouble();
tmp_WayPoint.Latitude = Position[1].toDouble();
tmp_WayPoint.Altitude = Position[2].toDouble();
tmp_WayPoint.Time = Position[3].toInt();
 
tmp_WayPoints.append(tmp_WayPoint);
}
else
{
QMessageBox::warning(this, QA_NAME,trUtf8("Die Wegpunkt-Liste umfasst mehr als 20 Einträge. Es werden nur die ersten 20 Einträge übernommen."), QMessageBox::Ok);
 
pb_Add->setEnabled(false);
 
z = s_Points.count();
}
}
return tmp_WayPoints;
}
 
void dlg_Map::show_WayPoints(QList<sWayPoint> WayPoints)
{
Point* p_Point;
 
o_Route->removeGeometry(l_RouteWP);
p_RouteWP.clear();
l_WayPoints.clear();
 
l_WayPoints = WayPoints;
 
for (int z = 0; z < WayPoints.count(); z++)
{
p_Point = new Point(WayPoints[z].Longitude, WayPoints[z].Latitude);
 
p_RouteWP.append(p_Point);
}
 
l_RouteWP = new LineString(p_RouteWP, "", Pen[0]);
o_Route->addGeometry(l_RouteWP);
 
o_Map->setView(p_Point);
 
o_Map->updateRequestNew();
}
 
void dlg_Map::save_WayPointsMKW(QString s_File)
{
QFile *f_MKW = new QFile(s_File);
 
f_MKW->open(QIODevice::ReadWrite | QIODevice::Text);
 
QTextStream out(f_MKW);
 
out.setRealNumberPrecision(9);
 
for (int z = 0; z < l_WayPoints.count(); z++)
{
out << l_WayPoints[z].Longitude << "," << l_WayPoints[z].Latitude << "," << l_WayPoints[z].Altitude << "," << l_WayPoints[z].Time << " \n";
}
 
f_MKW->close();
}
 
void dlg_Map::slot_LoadWayPoints()
{
QString Filename = QFileDialog::getOpenFileName(this, "WayPoint-Route laden", o_Settings->DIR.Logging, "Mikrokopter WayPoints(*.mkw);;KML-Datei(*.kml);;Alle Dateien (*)");
 
if (!Filename.isEmpty())
{
if (Filename.endsWith(".kml", Qt::CaseInsensitive))
{
cb_ShowWPs->setChecked(true);
pb_SendWaypoints->setEnabled(true);
 
show_WayPoints(parse_WayPointKML(Filename));
}
if (Filename.endsWith(".mkw", Qt::CaseInsensitive))
{
cb_ShowWPs->setChecked(true);
pb_SendWaypoints->setEnabled(true);
 
show_WayPoints(parse_WayPointMKW(Filename));
}
}
}
 
void dlg_Map::slot_SaveWayPoints()
{
QString Filename = QFileDialog::getSaveFileName(this, "WayPoint-Route speichern", o_Settings->DIR.Logging, "Mikrokopter WayPoints(*.mkw);;Alle Dateien (*)");
 
if (!Filename.isEmpty())
{
if (!(Filename.endsWith(".mkw", Qt::CaseInsensitive)))
{
Filename = Filename + QString(".mkw");
}
 
save_WayPointsMKW(Filename);
}
}
 
void dlg_Map::slot_ShowWayPoints(bool Show)
{
if (Show == true)
{
qDebug("An");
o_Route->addGeometry(l_RouteWP);
o_Map->updateRequestNew();
}
else
{
qDebug("Aus");
o_Route->removeGeometry(l_RouteWP);
o_Map->updateRequestNew();
}
}
 
// Position zum Flug-Track hinzufügen
void dlg_Map::add_Position(double x, double y)
{
sWayPoint WayPoint;
 
WayPoint.Longitude = x;
WayPoint.Latitude = y;
// WayPoint.Time = sb_Time->value();
 
l_Track.append(WayPoint);
 
o_Route->removeGeometry(l_RouteFL);
p_RouteFL.append(new Point(x,y));
 
o_Click->removeGeometry(LastPos);
 
Point* P = new CirclePoint(x, y, "P1", Point::Middle, Pen[0]);
LastPos = P;
P->setBaselevel(17);
o_Click->addGeometry(P);
 
if (cb_CenterPos->isChecked())
{
o_Map->setView(QPointF(x, y));
}
 
if (cb_ShowRoute->isChecked())
{
l_RouteFL = new LineString(p_RouteFL, "", Pen[1]);
 
o_Route->addGeometry(l_RouteFL);
}
o_Map->updateRequestNew();
}
 
// Zoom der Karte ändern
void dlg_Map::slot_Zoom(int t_Zoom)
{
o_Map->setZoom(t_Zoom);
}
 
// Waypoint zur Liste hinzufügen
void dlg_Map::slot_AddWayPoint()
{
cb_ShowWPs->setChecked(true);
 
sWayPoint WayPoint;
 
WayPoint.Longitude = LastClick->longitude();
WayPoint.Latitude = LastClick->latitude();
WayPoint.Time = sb_Time->value();
 
l_WayPoints.append(WayPoint);
 
o_Route->removeGeometry(l_RouteWP);
 
p_RouteWP.append(LastClick);
l_RouteWP = new LineString(p_RouteWP, "", Pen[0]);
 
o_Route->addGeometry(l_RouteWP);
o_Map->updateRequestNew();
 
pb_SendWaypoints->setEnabled(true);
 
if (l_WayPoints.count() == 20)
{
QMessageBox::warning(this, QA_NAME,trUtf8("Wegpunkt-Liste ist voll. Es können maximal 20 Wegpunkte benutzt werden."), QMessageBox::Ok);
pb_Add->setEnabled(false);
}
 
}
 
// Waypoint-Liste löschen
void dlg_Map::slot_DeleteWayPoints()
{
o_Route->removeGeometry(l_RouteWP);
p_RouteWP.clear();
l_WayPoints.clear();
o_Map->updateRequestNew();
 
pb_Add->setEnabled(pb_Goto->isEnabled());
}
 
void dlg_Map::slot_SendWayPoints()
{
emit(set_WayPoints(l_WayPoints));
}
 
// Zum Zielpunkt fliegen
void dlg_Map::slot_GotoTarget()
{
sWayPoint Target;
 
Target.Longitude = LastClick->longitude();
Target.Latitude = LastClick->latitude();
Target.Time = sb_Time->value();
 
emit(set_Target(Target));
}
 
// Click in der Karte
void dlg_Map::slot_Click(const QMouseEvent* Event, const QPointF Coord)
{
if ((Event->type() == QEvent::MouseButtonPress) && ((Event->button() == Qt::RightButton) || (Event->button() == Qt::MidButton)))
{
sl_Zoom->setValue(o_Adapter->adaptedZoom());
}
 
// Überwachen ob Karte verschoben wird
if ((Event->type() == QEvent::MouseButtonPress) && (Event->button() == Qt::LeftButton))
{
MapCenter = o_Map->currentCoordinate();
}
 
// Nur wenn nicht Verschoben dann einen Punkt setzen
if ((Event->type() == QEvent::MouseButtonRelease) && (Event->button() == Qt::LeftButton))
{
if (o_Map->currentCoordinate() == MapCenter)
{
if (l_WayPoints.count() < 20)
{
pb_Add->setEnabled(true);
}
pb_Goto->setEnabled(true);
 
o_Click->removeGeometry(ClickPoint);
 
ClickPoint = new CirclePoint(Coord.x(), Coord.y(), 6, "P1", Point::Middle, Pen[1]);
 
LastClick = new Point(Coord.x(), Coord.y());
 
ClickPoint->setBaselevel(o_Adapter->adaptedZoom());
o_Click->addGeometry(ClickPoint);
}
}
 
o_Map->updateRequestNew();
// qDebug(QString("%1").arg(Coord.x()).toLatin1().data());
// qDebug(QString("%1").arg(Coord.y()).toLatin1().data());
}
 
// auf Veränderung der Fenstergröße reagieren
void dlg_Map::resizeEvent ( QResizeEvent * event )
{
event = event;
o_Map->resize(w_Map->size() - QSize(20,20));
}
 
// Karte wechseln
void dlg_Map::slot_ChangeMap(int t_Set)
{
int zoom = o_Adapter->adaptedZoom();
QPointF a = o_Map->currentCoordinate();
 
o_Map->setZoom(0);
 
switch(t_Set)
{
case 0 : // OpenStreetMap
{
o_Adapter = new OSMMapAdapter();
}
break;
case 1 : // Yahoo Sat
{
o_Adapter = new TileMapAdapter("tile.openaerialmap.org", "/tiles/1.0.0/openaerialmap-900913/%1/%2/%3.png", 256, 0, 17);
}
break;
case 2 : // Google Maps
{
o_Adapter = new GoogleMapAdapter();
}
break;
case 3 : // Google Sat
{
o_Adapter = new GoogleSatMapAdapter();
}
break;
case 4 : // Yahoo Maps
{
o_Adapter = new YahooMapAdapter();
}
break;
case 5 : // Yahoo Sat
{
o_Adapter = new YahooMapAdapter("us.maps3.yimg.com", "/aerial.maps.yimg.com/png?v=1.7&t=a&s=256&x=%2&y=%3&z=%1");
}
break;
}
 
o_Layer->setMapAdapter(o_Adapter);
o_Click->setMapAdapter(o_Adapter);
o_Route->setMapAdapter(o_Adapter);
 
o_Map->updateRequestNew();
o_Map->setZoom(zoom);
}
 
// Fenster wird geschlossen.
void dlg_Map::slot_Close()
{
o_Settings->Map.GotoPosition = cb_CenterPos->isChecked();
o_Settings->Map.ShowTrack = cb_ShowRoute->isChecked();
emit set_Settings(o_Settings);
}
 
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Map.h
0,0 → 1,103
/***************************************************************************
* 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 DLG_MAP_H
#define DLG_MAP_H
 
#include <QDialog>
#include <QList>
 
#include "ui_dlg_Map.h"
 
#include "../Classes/cSettings.h"
#include "../qmapcontrol.h"
#include "../global.h"
 
using namespace qmapcontrol;
 
class dlg_Map : public QDialog, public Ui::dlg_Map_UI
{
Q_OBJECT
 
public:
dlg_Map(QWidget *parent = 0);
void add_Position(double x, double y);
void create_Map(cSettings *t_Settings);
 
private:
QPen* Pen[3];
 
cSettings *o_Settings;
 
MapControl *o_Map;
MapAdapter *o_Adapter;
 
Layer *o_Layer;
Layer *o_Click;
Layer *o_Route;
 
QList<Point*> p_RouteWP;
LineString* l_RouteWP;
 
QList<Point*> p_RouteFL;
LineString* l_RouteFL;
 
Point* LastPos;
// Point* LastPoint;
Point* LastClick;
 
Point *ClickPoint;
QPointF MapCenter;
 
QList<sWayPoint> l_WayPoints;
QList<sWayPoint> l_Track;
 
QList<sWayPoint> parse_WayPointKML(QString s_File);
QList<sWayPoint> parse_WayPointMKW(QString s_File);
 
void show_WayPoints(QList<sWayPoint> WayPoints);
 
void save_WayPointsMKW(QString s_File);
 
private slots:
void slot_Zoom(int t_Zoom);
void slot_ChangeMap(int);
void slot_Click(const QMouseEvent*, const QPointF);
 
void slot_AddWayPoint();
void slot_DeleteWayPoints();
void slot_SendWayPoints();
void slot_ShowWayPoints(bool);
 
void slot_GotoTarget();
void slot_Close();
 
void slot_LoadWayPoints();
void slot_SaveWayPoints();
 
protected:
virtual void resizeEvent ( QResizeEvent * event );
 
signals:
void set_Target(sWayPoint Target);
void set_WayPoints(QList<sWayPoint>);
void set_Settings(cSettings *t_Settings);
 
};
 
#endif // DLG_MAP_H
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Map.ui
0,0 → 1,336
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>dlg_Map_UI</class>
<widget class="QDialog" name="dlg_Map_UI">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>600</width>
<height>345</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>600</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>Flug-Karte</string>
</property>
<layout class="QGridLayout" name="gridLayout_3">
<item row="0" column="1">
<widget class="QFrame" name="w_Map">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_4">
<item row="0" column="1">
<layout class="QHBoxLayout" name="l_Map"/>
</item>
</layout>
</widget>
</item>
<item row="0" column="2">
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>2</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="3" rowspan="6">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Route</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="2" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QSpinBox" name="sb_Time">
<property name="maximum">
<number>300</number>
</property>
<property name="value">
<number>60</number>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Sek.</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="3" column="0">
<widget class="QPushButton" name="pb_Add">
<property name="text">
<string>hinzufügen</string>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QPushButton" name="pb_SendWaypoints">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>abfliegen</string>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QPushButton" name="pb_Delete">
<property name="text">
<string>löschen</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Verweilzeit</string>
</property>
</widget>
</item>
<item row="7" column="0">
<widget class="QPushButton" name="pb_Load">
<property name="text">
<string>Route laden</string>
</property>
</widget>
</item>
<item row="8" column="0">
<widget class="QPushButton" name="pb_Save">
<property name="text">
<string>Route speichern</string>
</property>
</widget>
</item>
<item row="6" column="0">
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Position</string>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QPushButton" name="pb_Goto">
<property name="text">
<string>Anfliegen</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="pb_Close">
<property name="text">
<string>Schließen</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="3" column="1">
<widget class="QFrame" name="More">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_5">
<item row="0" column="3">
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>428</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QCheckBox" name="cb_ShowRoute">
<property name="text">
<string>geflogene
Route anzeigen</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QCheckBox" name="cb_ShowWPs">
<property name="text">
<string>ausgewählte
Route anzeigen</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item row="0" column="4">
<widget class="QCheckBox" name="cb_CenterPos">
<property name="text">
<string>auf IST-Position
zentrieren</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="5" column="1">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string>Zoom:</string>
</property>
</widget>
</item>
<item>
<widget class="QSlider" name="sl_Zoom">
<property name="maximum">
<number>18</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="tickPosition">
<enum>QSlider::NoTicks</enum>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QLabel" name="lb_Maps">
<property name="text">
<string>Karten:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="cb_Maps">
<property name="enabled">
<bool>true</bool>
</property>
<item>
<property name="text">
<string>OpenStreetMap</string>
</property>
</item>
<item>
<property name="text">
<string>OpenAerialMap</string>
</property>
</item>
<item>
<property name="text">
<string>Google: Map</string>
</property>
</item>
<item>
<property name="text">
<string>Google: Satellit</string>
</property>
</item>
<item>
<property name="text">
<string>Yahoo: Map </string>
</property>
</item>
<item>
<property name="text">
<string>Yahoo: Satellit</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>pb_Close</sender>
<signal>clicked()</signal>
<receiver>dlg_Map_UI</receiver>
<slot>close()</slot>
<hints>
<hint type="sourcelabel">
<x>529</x>
<y>328</y>
</hint>
<hint type="destinationlabel">
<x>299</x>
<y>174</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_MotorMixer.cpp
0,0 → 1,406
/***************************************************************************
* 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 "dlg_MotorMixer.h"
 
dlg_MotorMixer::dlg_MotorMixer(QWidget *parent) : QDialog(parent)
{
setupUi(this);
connect(pb_READ, SIGNAL(clicked()), this, SLOT(slot_pb_READ()));
connect(pb_LOAD, SIGNAL(clicked()), this, SLOT(slot_pb_LOAD()));
connect(pb_SAVE, SIGNAL(clicked()), this, SLOT(slot_pb_SAVE()));
connect(pb_WRITE, SIGNAL(clicked()), this, SLOT(slot_pb_WRITE()));
 
connect(sb_NICK_1, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_2, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_3, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_4, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_5, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_6, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_7, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_8, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_9, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_10, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_11, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_NICK_12, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
 
connect(sb_ROLL_1, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_2, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_3, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_4, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_5, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_6, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_7, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_8, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_9, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_10, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_11, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_ROLL_12, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
 
connect(sb_GIER_1, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_2, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_3, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_4, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_5, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_6, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_7, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_8, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_9, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_10, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_11, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
connect(sb_GIER_12, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
 
}
 
// Connection-Object übergeben.
void dlg_MotorMixer::set_Objects(cConnection *t_Connection, cSettings *t_Settings)
{
o_Connection = t_Connection;
o_Settings = t_Settings;
}
 
// Motordaten übernehmen.
void dlg_MotorMixer::set_MotorConfig(sRxData RX)
{
int Pos = 0;
 
MixerName = ToolBox::Data2QString(RX.Decode, 1, 12);
 
Pos = 13;
 
for (int z = 0; z < 16; z++)
{
for (int y = 0; y < 4; y++)
{
Motor[z][y] = ToolBox::Data2Char(RX.Decode,Pos);
Pos++;
}
}
 
set_MotorData();
}
 
// Motordaten aus GUI übernehmen
void dlg_MotorMixer::get_MotorData()
{
MixerName = le_NAME->text();
 
Motor[0][0] = sb_GAS_1->value();
Motor[1][0] = sb_GAS_2->value();
Motor[2][0] = sb_GAS_3->value();
Motor[3][0] = sb_GAS_4->value();
Motor[4][0] = sb_GAS_5->value();
Motor[5][0] = sb_GAS_6->value();
Motor[6][0] = sb_GAS_7->value();
Motor[7][0] = sb_GAS_8->value();
Motor[8][0] = sb_GAS_9->value();
Motor[9][0] = sb_GAS_10->value();
Motor[10][0] = sb_GAS_11->value();
Motor[11][0] = sb_GAS_12->value();
 
Motor[0][1] = sb_NICK_1->value();
Motor[1][1] = sb_NICK_2->value();
Motor[2][1] = sb_NICK_3->value();
Motor[3][1] = sb_NICK_4->value();
Motor[4][1] = sb_NICK_5->value();
Motor[5][1] = sb_NICK_6->value();
Motor[6][1] = sb_NICK_7->value();
Motor[7][1] = sb_NICK_8->value();
Motor[8][1] = sb_NICK_9->value();
Motor[9][1] = sb_NICK_10->value();
Motor[10][1] = sb_NICK_11->value();
Motor[11][1] = sb_NICK_12->value();
 
Motor[0][2] = sb_ROLL_1->value();
Motor[1][2] = sb_ROLL_2->value();
Motor[2][2] = sb_ROLL_3->value();
Motor[3][2] = sb_ROLL_4->value();
Motor[4][2] = sb_ROLL_5->value();
Motor[5][2] = sb_ROLL_6->value();
Motor[6][2] = sb_ROLL_7->value();
Motor[7][2] = sb_ROLL_8->value();
Motor[8][2] = sb_ROLL_9->value();
Motor[9][2] = sb_ROLL_10->value();
Motor[10][2] = sb_ROLL_11->value();
Motor[11][2] = sb_ROLL_12->value();
 
Motor[0][3] = sb_GIER_1->value();
Motor[1][3] = sb_GIER_2->value();
Motor[2][3] = sb_GIER_3->value();
Motor[3][3] = sb_GIER_4->value();
Motor[4][3] = sb_GIER_5->value();
Motor[5][3] = sb_GIER_6->value();
Motor[6][3] = sb_GIER_7->value();
Motor[7][3] = sb_GIER_8->value();
Motor[8][3] = sb_GIER_9->value();
Motor[9][3] = sb_GIER_10->value();
Motor[10][3] = sb_GIER_11->value();
Motor[11][3] = sb_GIER_12->value();
}
 
// Motordaten anzeigen
void dlg_MotorMixer::set_MotorData()
{
le_NAME->setText(MixerName);
 
sb_GAS_1->setValue(Motor[0][0]);
sb_GAS_2->setValue(Motor[1][0]);
sb_GAS_3->setValue(Motor[2][0]);
sb_GAS_4->setValue(Motor[3][0]);
sb_GAS_5->setValue(Motor[4][0]);
sb_GAS_6->setValue(Motor[5][0]);
sb_GAS_7->setValue(Motor[6][0]);
sb_GAS_8->setValue(Motor[7][0]);
sb_GAS_9->setValue(Motor[8][0]);
sb_GAS_10->setValue(Motor[9][0]);
sb_GAS_11->setValue(Motor[10][0]);
sb_GAS_12->setValue(Motor[11][0]);
 
sb_NICK_1->setValue(Motor[0][1]);
sb_NICK_2->setValue(Motor[1][1]);
sb_NICK_3->setValue(Motor[2][1]);
sb_NICK_4->setValue(Motor[3][1]);
sb_NICK_5->setValue(Motor[4][1]);
sb_NICK_6->setValue(Motor[5][1]);
sb_NICK_7->setValue(Motor[6][1]);
sb_NICK_8->setValue(Motor[7][1]);
sb_NICK_9->setValue(Motor[8][1]);
sb_NICK_10->setValue(Motor[9][1]);
sb_NICK_11->setValue(Motor[10][1]);
sb_NICK_12->setValue(Motor[11][1]);
 
sb_ROLL_1->setValue(Motor[0][2]);
sb_ROLL_2->setValue(Motor[1][2]);
sb_ROLL_3->setValue(Motor[2][2]);
sb_ROLL_4->setValue(Motor[3][2]);
sb_ROLL_5->setValue(Motor[4][2]);
sb_ROLL_6->setValue(Motor[5][2]);
sb_ROLL_7->setValue(Motor[6][2]);
sb_ROLL_8->setValue(Motor[7][2]);
sb_ROLL_9->setValue(Motor[8][2]);
sb_ROLL_10->setValue(Motor[9][2]);
sb_ROLL_11->setValue(Motor[10][2]);
sb_ROLL_12->setValue(Motor[11][2]);
 
sb_GIER_1->setValue(Motor[0][3]);
sb_GIER_2->setValue(Motor[1][3]);
sb_GIER_3->setValue(Motor[2][3]);
sb_GIER_4->setValue(Motor[3][3]);
sb_GIER_5->setValue(Motor[4][3]);
sb_GIER_6->setValue(Motor[5][3]);
sb_GIER_7->setValue(Motor[6][3]);
sb_GIER_8->setValue(Motor[7][3]);
sb_GIER_9->setValue(Motor[8][3]);
sb_GIER_10->setValue(Motor[9][3]);
sb_GIER_11->setValue(Motor[10][3]);
sb_GIER_12->setValue(Motor[11][3]);
}
 
// Prüfen auf vollstaändigkeit
void dlg_MotorMixer::slot_CheckValue(int Wert)
{
Wert = Wert;
 
int NICK = sb_NICK_1->value() + sb_NICK_2->value() + sb_NICK_3->value() + sb_NICK_4->value() + sb_NICK_5->value() + sb_NICK_6->value() +
sb_NICK_7->value() + sb_NICK_8->value() + sb_NICK_9->value() + sb_NICK_10->value() + sb_NICK_11->value() + sb_NICK_12->value();
 
int ROLL = sb_ROLL_1->value() + sb_ROLL_2->value() + sb_ROLL_3->value() + sb_ROLL_4->value() + sb_ROLL_5->value() + sb_ROLL_6->value() +
sb_ROLL_7->value() + sb_ROLL_8->value() + sb_ROLL_9->value() + sb_ROLL_10->value() + sb_ROLL_11->value() + sb_ROLL_12->value();
 
int GIER = sb_GIER_1->value() + sb_GIER_2->value() + sb_GIER_3->value() + sb_GIER_4->value() + sb_GIER_5->value() + sb_GIER_6->value() +
sb_GIER_7->value() + sb_GIER_8->value() + sb_GIER_9->value() + sb_GIER_10->value() + sb_GIER_11->value() + sb_GIER_12->value();
 
if (NICK == 0)
{
lb_NICK->setEnabled(true);
}
else
{
lb_NICK->setEnabled(false);
}
 
if (ROLL == 0)
{
lb_ROLL->setEnabled(true);
}
else
{
lb_ROLL->setEnabled(false);
}
 
if (GIER == 0)
{
lb_GIER->setEnabled(true);
}
else
{
lb_GIER->setEnabled(false);
}
}
 
int dlg_MotorMixer::get_MotorConfig()
{
get_MotorData();
 
TX_Data[0] = VERSION_MIXER;
 
char *Name = MixerName.toLatin1().data();
 
int a;
 
for (a = 0; a < MixerName.length(); a++)
{
TX_Data[1+a] = Name[a];
}
 
while(a < 12)
{
TX_Data[1+a] = 0;
a++;
}
 
int Pos = 13;
 
for (int z = 0; z < 16; z++)
{
for (int y = 0; y < 4; y++)
{
TX_Data[Pos] = ToolBox::Char2Data(Motor[z][y]);
Pos++;
}
}
 
return Pos - 1;
}
 
void dlg_MotorMixer::read_Mixer()
{
TX_Data[0] = 0;
o_Connection->send_Cmd('n', ADDRESS_FC, TX_Data, 1, true);
}
 
// Motordaten auslesen
void dlg_MotorMixer::slot_pb_READ()
{
TX_Data[0] = 0;
o_Connection->send_Cmd('n', ADDRESS_FC, TX_Data, 1, true);
}
 
void dlg_MotorMixer::slot_pb_WRITE()
{
int Length = get_MotorConfig();
o_Connection->send_Cmd('m', ADDRESS_FC, TX_Data, Length, true);
}
 
void dlg_MotorMixer::slot_pb_LOAD()
{
QString Filename = QFileDialog::getOpenFileName(this, tr("Mikrokopter MotorMixer laden"), o_Settings->DIR.Parameter + "", tr("MK MotorMixer(*.mkm);;Alle Dateien (*)"));
 
if (!Filename.isEmpty())
{
QSettings Setting(Filename, QSettings::IniFormat);
 
Setting.beginGroup("Info");
MixerName = Setting.value("Name", QString("--noname--")).toString();
MixerVersion = Setting.value("Version", 0).toInt();
Setting.endGroup();
 
Setting.beginGroup("Gas");
for (int z = 0; z < MAXMOTOR; z++)
{
Motor[z][0] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
}
Setting.endGroup();
 
Setting.beginGroup("Nick");
for (int z = 0; z < MAXMOTOR; z++)
{
Motor[z][1] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
}
Setting.endGroup();
 
Setting.beginGroup("Roll");
for (int z = 0; z < MAXMOTOR; z++)
{
Motor[z][2] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
}
Setting.endGroup();
 
Setting.beginGroup("Yaw");
for (int z = 0; z < MAXMOTOR; z++)
{
Motor[z][3] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
}
Setting.endGroup();
 
if (MixerVersion == VERSION_MIXER)
{
set_MotorData();
}
}
}
 
void dlg_MotorMixer::slot_pb_SAVE()
{
QString Filename = QFileDialog::getSaveFileName(this, tr("Mikrokopter MotorMixer speichern"), o_Settings->DIR.Parameter + "/" + le_NAME->text(), tr("MK MotorMixer(*.mkm);;Alle Dateien (*)"));
 
if (!Filename.isEmpty())
{
if (!(Filename.endsWith(".mkm", Qt::CaseInsensitive)))
{
Filename = Filename + QString(".mkm");
}
 
get_MotorData();
 
QSettings Setting(Filename, QSettings::IniFormat);
 
Setting.beginGroup("Info");
Setting.setValue("Name", MixerName);
Setting.setValue("Version", VERSION_MIXER);
Setting.endGroup();
 
Setting.beginGroup("Gas");
for (int z = 0; z < MAXMOTOR; z++)
{
Setting.setValue(QString("Motor%1").arg(z+1), Motor[z][0]);
}
Setting.endGroup();
 
Setting.beginGroup("Nick");
for (int z = 0; z < MAXMOTOR; z++)
{
Setting.setValue(QString("Motor%1").arg(z+1), Motor[z][1]);
}
Setting.endGroup();
 
Setting.beginGroup("Roll");
for (int z = 0; z < MAXMOTOR; z++)
{
Setting.setValue(QString("Motor%1").arg(z+1), Motor[z][2]);
}
Setting.endGroup();
 
Setting.beginGroup("Yaw");
for (int z = 0; z < MAXMOTOR; z++)
{
Setting.setValue(QString("Motor%1").arg(z+1), Motor[z][3]);
}
Setting.endGroup();
}
}
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_MotorMixer.h
0,0 → 1,67
/***************************************************************************
* 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 DLG_MOTORMIXER_H
#define DLG_MOTORMIXER_H
 
#include <QObject>
#include <QFileDialog>
#include <QSettings>
 
#include "ui_dlg_MotorMixer.h"
#include "../Classes/cSettings.h"
#include "../Classes/cConnection.h"
#include "../typedefs.h"
//#include "../Classes/ToolBox.h"
#include "../global.h"
 
class dlg_MotorMixer : public QDialog, public Ui::dlg_MotorMixer_UI
{
Q_OBJECT
 
public:
dlg_MotorMixer(QWidget *parent = 0);
void set_Objects(cConnection *t_Connection, cSettings *t_Settings);
void set_MotorConfig(sRxData RX);
void read_Mixer();
 
private:
// Object für Kopter-Verbindung
cConnection *o_Connection;
 
cSettings *o_Settings;
 
char TX_Data[150];
 
int Motor[16][4];
QString MixerName;
int MixerVersion;
 
void set_MotorData();
void get_MotorData();
int get_MotorConfig();
 
private slots:
void slot_pb_READ();
void slot_pb_WRITE();
void slot_pb_LOAD();
void slot_pb_SAVE();
void slot_CheckValue(int Wert);
};
 
#endif // DLG_MOTORMIXER_H
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_MotorMixer.ui
0,0 → 1,1733
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>dlg_MotorMixer_UI</class>
<widget class="QDialog" name="dlg_MotorMixer_UI">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>470</width>
<height>414</height>
</rect>
</property>
<property name="windowTitle">
<string>MotorMixer-Einstellungen</string>
</property>
<layout class="QGridLayout" name="gridLayout_3">
<item row="0" column="0">
<widget class="QWidget" name="widget" native="true">
<layout class="QGridLayout" name="gridLayout">
<property name="margin">
<number>2</number>
</property>
<item row="2" column="0">
<widget class="QLabel" name="label">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 1:</string>
</property>
</widget>
</item>
<item row="2" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_1">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="2" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_1">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="2" column="5">
<widget class="QSpinBox" name="sb_ROLL_1">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="2" column="6">
<widget class="QSpinBox" name="sb_GIER_1">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 2:</string>
</property>
</widget>
</item>
<item row="3" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_2">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="3" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_2">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="3" column="5">
<widget class="QSpinBox" name="sb_ROLL_2">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="3" column="6">
<widget class="QSpinBox" name="sb_GIER_2">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="label_3">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 3:</string>
</property>
</widget>
</item>
<item row="4" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_3">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="4" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_3">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="4" column="5">
<widget class="QSpinBox" name="sb_ROLL_3">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="4" column="6">
<widget class="QSpinBox" name="sb_GIER_3">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QLabel" name="label_4">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 4:</string>
</property>
</widget>
</item>
<item row="5" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_4">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="5" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_4">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="5" column="5">
<widget class="QSpinBox" name="sb_ROLL_4">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="5" column="6">
<widget class="QSpinBox" name="sb_GIER_4">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="6" column="0">
<widget class="QLabel" name="label_5">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 5:</string>
</property>
</widget>
</item>
<item row="6" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_5">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="6" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_5">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="6" column="5">
<widget class="QSpinBox" name="sb_ROLL_5">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="6" column="6">
<widget class="QSpinBox" name="sb_GIER_5">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="7" column="0">
<widget class="QLabel" name="label_6">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 6:</string>
</property>
</widget>
</item>
<item row="7" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_6">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="7" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_6">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="7" column="5">
<widget class="QSpinBox" name="sb_ROLL_6">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="7" column="6">
<widget class="QSpinBox" name="sb_GIER_6">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="8" column="0">
<widget class="QLabel" name="label_7">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 7:</string>
</property>
</widget>
</item>
<item row="8" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_7">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="8" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_7">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="8" column="5">
<widget class="QSpinBox" name="sb_ROLL_7">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="8" column="6">
<widget class="QSpinBox" name="sb_GIER_7">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="9" column="0">
<widget class="QLabel" name="label_8">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 8:</string>
</property>
</widget>
</item>
<item row="9" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_8">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="9" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_8">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="9" column="5">
<widget class="QSpinBox" name="sb_ROLL_8">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="9" column="6">
<widget class="QSpinBox" name="sb_GIER_8">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="10" column="0">
<widget class="QLabel" name="label_9">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 9:</string>
</property>
</widget>
</item>
<item row="10" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_9">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="10" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_9">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="10" column="5">
<widget class="QSpinBox" name="sb_ROLL_9">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="10" column="6">
<widget class="QSpinBox" name="sb_GIER_9">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="11" column="0">
<widget class="QLabel" name="label_10">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 10:</string>
</property>
</widget>
</item>
<item row="11" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_10">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="11" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_10">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="11" column="5">
<widget class="QSpinBox" name="sb_ROLL_10">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="11" column="6">
<widget class="QSpinBox" name="sb_GIER_10">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="12" column="0">
<widget class="QLabel" name="label_11">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 11:</string>
</property>
</widget>
</item>
<item row="12" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_11">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="12" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_11">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="12" column="5">
<widget class="QSpinBox" name="sb_ROLL_11">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="12" column="6">
<widget class="QSpinBox" name="sb_GIER_11">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="13" column="0">
<widget class="QLabel" name="label_12">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Motor 12:</string>
</property>
</widget>
</item>
<item row="13" column="1" colspan="2">
<widget class="QSpinBox" name="sb_GAS_12">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="13" column="3" colspan="2">
<widget class="QSpinBox" name="sb_NICK_12">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="13" column="5">
<widget class="QSpinBox" name="sb_ROLL_12">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="13" column="6">
<widget class="QSpinBox" name="sb_GIER_12">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="minimum">
<number>-128</number>
</property>
<property name="maximum">
<number>128</number>
</property>
<property name="value">
<number>0</number>
</property>
</widget>
</item>
<item row="1" column="5">
<widget class="QLabel" name="lb_ROLL">
<property name="palette">
<palette>
<active>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>62</red>
<green>207</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
</active>
<inactive>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>62</red>
<green>207</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
</inactive>
<disabled>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
</disabled>
</palette>
</property>
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>ROLL</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="1" column="1" colspan="2">
<widget class="QLabel" name="label_13">
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>GAS</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="1" column="6">
<widget class="QLabel" name="lb_GIER">
<property name="palette">
<palette>
<active>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>62</red>
<green>207</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
</active>
<inactive>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>62</red>
<green>207</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
</inactive>
<disabled>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
</disabled>
</palette>
</property>
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>GIER</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
<item row="1" column="3" colspan="2">
<widget class="QLabel" name="lb_NICK">
<property name="palette">
<palette>
<active>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>62</red>
<green>207</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
</active>
<inactive>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>62</red>
<green>207</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>20</red>
<green>19</green>
<blue>18</blue>
</color>
</brush>
</colorrole>
</inactive>
<disabled>
<colorrole role="WindowText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Dark">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
<colorrole role="ButtonText">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>179</red>
<green>14</green>
<blue>17</blue>
</color>
</brush>
</colorrole>
</disabled>
</palette>
</property>
<property name="font">
<font>
<family>Courier 10 Pitch</family>
<pointsize>11</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>NICK</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="0" column="1">
<widget class="QFrame" name="frame">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Raised</enum>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<item row="2" column="0">
<widget class="QLineEdit" name="le_NAME"/>
</item>
<item row="3" column="0">
<widget class="QPushButton" name="pb_READ">
<property name="text">
<string>Lesen</string>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QPushButton" name="pb_WRITE">
<property name="text">
<string>Schreiben</string>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QPushButton" name="pb_LOAD">
<property name="text">
<string>Laden</string>
</property>
</widget>
</item>
<item row="6" column="0">
<widget class="QPushButton" name="pb_SAVE">
<property name="text">
<string>Speichern</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_17">
<property name="text">
<string>Name:</string>
</property>
</widget>
</item>
<item row="7" column="0">
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="8" column="0">
<widget class="QPushButton" name="pb_Close">
<property name="text">
<string>Schließen</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="../MKTool.qrc"/>
</resources>
<connections>
<connection>
<sender>pb_Close</sender>
<signal>clicked()</signal>
<receiver>dlg_MotorMixer_UI</receiver>
<slot>close()</slot>
<hints>
<hint type="sourcelabel">
<x>414</x>
<y>390</y>
</hint>
<hint type="destinationlabel">
<x>234</x>
<y>206</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Motortest.cpp
0,0 → 1,68
/***************************************************************************
* 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 "dlg_Motortest.h"
 
dlg_Motortest::dlg_Motortest(QWidget *parent) : QDialog(parent)
{
setupUi(this);
connect(sl_Speed, SIGNAL(valueChanged(int)), this, SLOT(slot_Motortest(int)));
}
 
void dlg_Motortest::slot_Motortest(int Wert)
{
sMotor Motor;
 
for (int z = 0; z < 12; z++)
{
Motor.Speed[z] = 0;
}
 
if (cb_1->isChecked())
Motor.Speed[0] = Wert;
if (cb_2->isChecked())
Motor.Speed[1] = Wert;
if (cb_3->isChecked())
Motor.Speed[2] = Wert;
if (cb_4->isChecked())
Motor.Speed[3] = Wert;
if (cb_5->isChecked())
Motor.Speed[4] = Wert;
if (cb_6->isChecked())
Motor.Speed[5] = Wert;
if (cb_7->isChecked())
Motor.Speed[6] = Wert;
if (cb_8->isChecked())
Motor.Speed[7] = Wert;
if (cb_9->isChecked())
Motor.Speed[8] = Wert;
if (cb_10->isChecked())
Motor.Speed[9] = Wert;
if (cb_11->isChecked())
Motor.Speed[10] = Wert;
if (cb_12->isChecked())
Motor.Speed[11] = Wert;
 
emit updateMotor(Motor);
}
 
dlg_Motortest::~dlg_Motortest()
{
}
 
 
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Motortest.h
0,0 → 1,42
/***************************************************************************
* 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 DLG_MOTORTEST_H
#define DLG_MOTORTEST_H
 
#include <QObject>
 
#include "ui_dlg_Motortest.h"
#include "../global.h"
 
class dlg_Motortest : public QDialog, public Ui::dlg_Motortest_UI
{
Q_OBJECT
 
public:
dlg_Motortest(QWidget *parent = 0);
~dlg_Motortest();
 
private slots:
void slot_Motortest(int Wert);
 
signals:
void updateMotor(sMotor Motor);
};
 
#endif
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Motortest.ui
0,0 → 1,350
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>dlg_Motortest_UI</class>
<widget class="QDialog" name="dlg_Motortest_UI">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>194</width>
<height>208</height>
</rect>
</property>
<property name="windowTitle">
<string>Motortest</string>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Motoren</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QCheckBox" name="cb_1">
<property name="text">
<string>1</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QCheckBox" name="cb_2">
<property name="text">
<string>2</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QCheckBox" name="cb_3">
<property name="text">
<string>3</string>
</property>
</widget>
</item>
<item row="0" column="3">
<widget class="QCheckBox" name="cb_4">
<property name="text">
<string>4</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QCheckBox" name="cb_5">
<property name="text">
<string>5</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QCheckBox" name="cb_6">
<property name="text">
<string>6</string>
</property>
</widget>
</item>
<item row="1" column="2">
<widget class="QCheckBox" name="cb_7">
<property name="text">
<string>7</string>
</property>
</widget>
</item>
<item row="1" column="3">
<widget class="QCheckBox" name="cb_8">
<property name="text">
<string>8</string>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QCheckBox" name="cb_9">
<property name="text">
<string>9</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QCheckBox" name="cb_10">
<property name="text">
<string>10</string>
</property>
</widget>
</item>
<item row="2" column="2">
<widget class="QCheckBox" name="cb_11">
<property name="text">
<string>11</string>
</property>
</widget>
</item>
<item row="2" column="3">
<widget class="QCheckBox" name="cb_12">
<property name="text">
<string>12</string>
</property>
</widget>
</item>
<item row="3" column="0" colspan="4">
<widget class="QCheckBox" name="cb_ALL">
<property name="text">
<string>Alle auswählen</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="1" column="0">
<widget class="QSlider" name="sl_Speed">
<property name="maximum">
<number>255</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QPushButton" name="pb_OK">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>pb_OK</sender>
<signal>clicked()</signal>
<receiver>dlg_Motortest_UI</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>63</x>
<y>174</y>
</hint>
<hint type="destinationlabel">
<x>29</x>
<y>177</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_1</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>29</x>
<y>47</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_2</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>71</x>
<y>47</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_3</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>115</x>
<y>47</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_4</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>160</x>
<y>47</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_5</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>29</x>
<y>74</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_6</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>71</x>
<y>74</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_7</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>115</x>
<y>74</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_8</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>160</x>
<y>74</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_9</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>29</x>
<y>101</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_10</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>71</x>
<y>101</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_11</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>115</x>
<y>101</y>
</hint>
</hints>
</connection>
<connection>
<sender>cb_ALL</sender>
<signal>toggled(bool)</signal>
<receiver>cb_12</receiver>
<slot>setChecked(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>96</x>
<y>128</y>
</hint>
<hint type="destinationlabel">
<x>160</x>
<y>101</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Preferences.cpp
0,0 → 1,127
/***************************************************************************
* 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 "dlg_Preferences.h"
 
dlg_Preferences::dlg_Preferences(QWidget *parent) : QDialog(parent)
{
setupUi(this);
connect(pb_DIR_CVS, SIGNAL(clicked()), this, SLOT(slot_DIR_CVS()));
connect(pb_DIR_SET, SIGNAL(clicked()), this, SLOT(slot_DIR_SET()));
connect(pb_DIR_CACHE, SIGNAL(clicked()), this, SLOT(slot_DIR_CACHE()));
connect(pb_PATH_AVRDUDE, SIGNAL(clicked()), this, SLOT(slot_PATH_AVRDUDE()));
}
 
void dlg_Preferences::set_Settings(cSettings *Set)
{
Settings = Set;
 
le_DIR_CVS->setText(Settings->DIR.Logging);
le_DIR_SET->setText(Settings->DIR.Parameter);
le_DIR_CACHE->setText(Settings->DIR.Cache);
le_PATH_AVRDUDE->setText(Settings->DIR.AVRDUDE);
le_TTY->setText(Settings->TTY.Port);
sp_Plotter_Count->setValue(Settings->Data.Plotter_Count);
sp_Debug_Fast->setValue(Settings->Data.Debug_Fast);
sp_Debug_Slow->setValue(Settings->Data.Debug_Slow);
sp_Debug_Off->setValue(Settings->Data.Debug_Off);
sp_Navi_Fast->setValue(Settings->Data.Navi_Fast);
sp_Navi_Slow->setValue(Settings->Data.Navi_Slow);
sp_Navi_Off->setValue(Settings->Data.Navi_Off);
le_ServerPort->setText(Settings->Server.Port);
cb_StartServer->setChecked(Settings->Server.StartServer);
cb_ToGround->setChecked(Settings->Server.ToGround);
le_Login->setText(Settings->Server.QMKS_Login);
le_Password->setText(Settings->Server.QMKS_Password);
le_QMKS_Host->setText(Settings->Server.QMKS_Host);
le_QMKS_Port->setText(Settings->Server.QMKS_Port);
}
 
cSettings *dlg_Preferences::get_Settings()
{
Settings->TTY.Port = le_TTY->text();
Settings->Data.Plotter_Count = sp_Plotter_Count->value();
Settings->Data.Debug_Fast = sp_Debug_Fast->value();
Settings->Data.Debug_Slow = sp_Debug_Slow->value();
Settings->Data.Debug_Off = sp_Debug_Off->value();
Settings->Data.Navi_Fast = sp_Navi_Fast->value();
Settings->Data.Navi_Slow = sp_Navi_Slow->value();
Settings->Data.Navi_Off = sp_Navi_Off->value();
Settings->Server.Port = le_ServerPort->text();
Settings->Server.StartServer = cb_StartServer->isChecked();
Settings->Server.ToGround = cb_ToGround->isChecked();
Settings->Server.QMKS_Login = le_Login->text();
Settings->Server.QMKS_Password = le_Password->text();
Settings->Server.QMKS_Host = le_QMKS_Host->text();
Settings->Server.QMKS_Port = le_QMKS_Port->text();
 
return Settings;
}
 
// Configuration -> Verzeichnisse
/////////////////////////////////
void dlg_Preferences::slot_DIR_CVS()
{
QString directory = QFileDialog::getExistingDirectory(this, trUtf8("Verzeichniss für Daten"), Settings->DIR.Logging, QFileDialog::DontResolveSymlinks | QFileDialog::ShowDirsOnly);
 
if ((!directory.isEmpty()) && (Settings->DIR.Logging != directory))
{
Settings->DIR.Logging = directory;
le_DIR_CVS->setText(Settings->DIR.Logging);
}
}
 
void dlg_Preferences::slot_DIR_SET()
{
QString directory = QFileDialog::getExistingDirectory(this, trUtf8("Verzeichniss für Settings-Dateien"), Settings->DIR.Parameter, QFileDialog::DontResolveSymlinks | QFileDialog::ShowDirsOnly);
 
if ((!directory.isEmpty()) && (Settings->DIR.Parameter != directory))
{
Settings->DIR.Parameter = directory;
le_DIR_SET->setText(Settings->DIR.Parameter);
}
 
}
void dlg_Preferences::slot_DIR_CACHE()
{
QString directory = QFileDialog::getExistingDirectory(this, trUtf8("Verzeichniss für Karten-Cache"), Settings->DIR.Cache, QFileDialog::DontResolveSymlinks | QFileDialog::ShowDirsOnly);
 
if ((!directory.isEmpty()) && (Settings->DIR.Cache != directory))
{
Settings->DIR.Cache = directory;
le_DIR_CACHE->setText(Settings->DIR.Cache);
}
}
 
void dlg_Preferences::slot_PATH_AVRDUDE()
{
QString directory = QFileDialog::getOpenFileName(this, trUtf8("Pfad zu AVRDUDE"), Settings->DIR.AVRDUDE, tr("AVRDUDE (*)"));
 
 
if ((!directory.isEmpty()) && (Settings->DIR.AVRDUDE != directory))
{
Settings->DIR.AVRDUDE = directory;
le_PATH_AVRDUDE->setText(Settings->DIR.AVRDUDE);
}
}
 
dlg_Preferences::~dlg_Preferences()
{
}
 
 
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Preferences.h
0,0 → 1,51
/***************************************************************************
* 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 DLG_PREFERENCES_H
#define DLG_PREFERENCES_H
 
#include <QCheckBox>
#include <QFileDialog>
 
#include "ui_dlg_Preferences.h"
#include "../Classes/cSettings.h"
//#include "../global.h"
 
class dlg_Preferences : public QDialog, public Ui::dlg_Preferences_UI
{
Q_OBJECT
 
public:
dlg_Preferences(QWidget *parent = 0);
 
~dlg_Preferences();
 
void set_Settings(cSettings *Set);
cSettings *get_Settings();
 
private:
cSettings *Settings;
 
private slots:
void slot_DIR_CVS();
void slot_DIR_SET();
void slot_DIR_CACHE();
void slot_PATH_AVRDUDE();
};
 
#endif
/QMK-Groundstation/branches/own_com_lib/Forms/dlg_Preferences.ui
0,0 → 1,973
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>dlg_Preferences_UI</class>
<widget class="QDialog" name="dlg_Preferences_UI">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>589</width>
<height>272</height>
</rect>
</property>
<property name="windowTitle">
<string>Einstellungen</string>
</property>
<layout class="QGridLayout" name="gridLayout_16">
<item row="0" column="0">
<widget class="QListWidget" name="listWidget">
<property name="minimumSize">
<size>
<width>150</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>150</width>
<height>16777215</height>
</size>
</property>
<item>
<property name="text">
<string>Verbindung</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>Debug-Daten</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>Navi-Daten</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>Plotter</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>Verzeichnisse</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>KML-Server</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>QMK-Datenserver</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
<item>
<property name="text">
<string>Flash &amp; Update</string>
</property>
<property name="flags">
<set>ItemIsSelectable|ItemIsUserCheckable|ItemIsEnabled</set>
</property>
</item>
</widget>
</item>
<item row="1" column="0" colspan="3">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<spacer>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>131</width>
<height>31</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="okButton">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="cancelButton">
<property name="text">
<string>Cancel</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="0" column="1">
<widget class="QStackedWidget" name="stackedWidget">
<property name="frameShape">
<enum>QFrame::Box</enum>
</property>
<property name="currentIndex">
<number>4</number>
</property>
<widget class="QWidget" name="page">
<layout class="QGridLayout" name="gridLayout_4">
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_5">
<property name="title">
<string>Serieller Port für Verbindung zum MK.</string>
</property>
<layout class="QGridLayout" name="gridLayout_6">
<item row="0" column="0">
<widget class="QLabel" name="label_6">
<property name="text">
<string>Device: </string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="le_TTY">
<property name="text">
<string>/dev/ttyS0</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<spacer name="verticalSpacer_6">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_16">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Verbindung zum Kopter</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_2">
<layout class="QGridLayout" name="gridLayout_3">
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Debug-Daten intervall</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="1" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Intervall langsam :</string>
</property>
</widget>
</item>
<item row="1" column="3">
<widget class="QSpinBox" name="sp_Debug_Slow">
<property name="suffix">
<string> ms</string>
</property>
<property name="minimum">
<number>10</number>
</property>
<property name="maximum">
<number>2550</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>500</number>
</property>
</widget>
</item>
<item row="2" column="0" rowspan="2">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Intervall schnell :</string>
</property>
</widget>
</item>
<item row="2" column="3" rowspan="2">
<widget class="QSpinBox" name="sp_Debug_Fast">
<property name="suffix">
<string> ms</string>
</property>
<property name="prefix">
<string/>
</property>
<property name="minimum">
<number>10</number>
</property>
<property name="maximum">
<number>2550</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>100</number>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="label_10">
<property name="text">
<string>Intervall offline :</string>
</property>
</widget>
</item>
<item row="4" column="3">
<widget class="QSpinBox" name="sp_Debug_Off">
<property name="suffix">
<string> ms</string>
</property>
<property name="prefix">
<string/>
</property>
<property name="minimum">
<number>10</number>
</property>
<property name="maximum">
<number>2550</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>1000</number>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<spacer name="verticalSpacer_7">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_17">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Debug-Daten</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="Seite_3">
<layout class="QGridLayout" name="gridLayout_7">
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_9">
<property name="title">
<string>Navi-Daten Intervall</string>
</property>
<layout class="QGridLayout" name="gridLayout_10">
<item row="0" column="0">
<widget class="QLabel" name="label_8">
<property name="text">
<string>Intervall langsam :</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="sp_Navi_Slow">
<property name="suffix">
<string> ms</string>
</property>
<property name="minimum">
<number>10</number>
</property>
<property name="maximum">
<number>2550</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>500</number>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_9">
<property name="text">
<string>Intervall schnell :</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QSpinBox" name="sp_Navi_Fast">
<property name="suffix">
<string> ms</string>
</property>
<property name="prefix">
<string/>
</property>
<property name="minimum">
<number>10</number>
</property>
<property name="maximum">
<number>2550</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>100</number>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_11">
<property name="text">
<string>Intervall offline :</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QSpinBox" name="sp_Navi_Off">
<property name="suffix">
<string> ms</string>
</property>
<property name="prefix">
<string/>
</property>
<property name="minimum">
<number>10</number>
</property>
<property name="maximum">
<number>2550</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>250</number>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<spacer name="verticalSpacer_8">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_18">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Navigations-Daten</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="Seite_4">
<layout class="QGridLayout" name="gridLayout_15">
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Plotter</string>
</property>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Angezeigte Datensätze :</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="sp_Plotter_Count">
<property name="minimum">
<number>50</number>
</property>
<property name="maximum">
<number>250</number>
</property>
<property name="singleStep">
<number>5</number>
</property>
<property name="value">
<number>100</number>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<spacer name="verticalSpacer_9">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_19">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Plotter-Einstellungen</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="Seite_5">
<layout class="QGridLayout" name="gridLayout_14">
<item row="0" column="0">
<widget class="QLabel" name="label_23">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Verzeichnisse</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_12">
<property name="title">
<string/>
</property>
<layout class="QGridLayout" name="gridLayout_11">
<item row="0" column="0">
<widget class="QLabel" name="label_24">
<property name="text">
<string>Verzeichniss für Dateien (Datenrecorder, WayPoints ect.)</string>
</property>
</widget>
</item>
<item row="1" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QPushButton" name="pb_DIR_CVS">
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../MKTool.qrc">
<normaloff>:/Actions/Images/Actions/Folder-Open.png</normaloff>:/Actions/Images/Actions/Folder-Open.png</iconset>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="le_DIR_CVS"/>
</item>
</layout>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_25">
<property name="text">
<string>Verzeichniss für Setting-Dateien</string>
</property>
</widget>
</item>
<item row="3" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QPushButton" name="pb_DIR_SET">
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../MKTool.qrc">
<normaloff>:/Actions/Images/Actions/Folder-Open.png</normaloff>:/Actions/Images/Actions/Folder-Open.png</iconset>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="le_DIR_SET"/>
</item>
</layout>
</item>
<item row="4" column="0">
<widget class="QLabel" name="label_26">
<property name="text">
<string>Verzeichniss für Karten-Cache</string>
</property>
</widget>
</item>
<item row="5" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QPushButton" name="pb_DIR_CACHE">
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../MKTool.qrc">
<normaloff>:/Actions/Images/Actions/Folder-Open.png</normaloff>:/Actions/Images/Actions/Folder-Open.png</iconset>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="le_DIR_CACHE"/>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="Seite_6">
<layout class="QGridLayout" name="gridLayout_18">
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_7">
<property name="title">
<string>Server</string>
</property>
<layout class="QGridLayout" name="gridLayout_8">
<item row="0" column="0">
<widget class="QLabel" name="label_7">
<property name="text">
<string>Serverport: </string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="le_ServerPort">
<property name="text">
<string>10664</string>
</property>
</widget>
</item>
<item row="1" column="0" colspan="2">
<widget class="QCheckBox" name="cb_StartServer">
<property name="text">
<string>KML-Server automatisch starten</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<widget class="QGroupBox" name="groupBox_8">
<property name="title">
<string>Datenanzeige</string>
</property>
<layout class="QGridLayout" name="gridLayout_9">
<item row="0" column="0">
<widget class="QCheckBox" name="cb_ToGround">
<property name="text">
<string>Höhe bis zum Boden verlängern</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0">
<spacer name="verticalSpacer_11">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>290</width>
<height>54</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_22">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>KML-Datenserver</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="Seite_7">
<layout class="QGridLayout" name="gridLayout_17">
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_10">
<property name="enabled">
<bool>true</bool>
</property>
<property name="title">
<string>Server</string>
</property>
<layout class="QGridLayout" name="gridLayout_12">
<item row="0" column="0">
<widget class="QLabel" name="label_12">
<property name="text">
<string>Server:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="le_QMKS_Host">
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_13">
<property name="text">
<string>Port:</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="le_QMKS_Port">
<property name="text">
<string/>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<widget class="QGroupBox" name="groupBox_11">
<property name="enabled">
<bool>true</bool>
</property>
<property name="title">
<string>Logindaten</string>
</property>
<layout class="QGridLayout" name="gridLayout_13">
<item row="0" column="0">
<widget class="QLabel" name="label_14">
<property name="text">
<string>Loginname:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="le_Login"/>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_15">
<property name="text">
<string>Password:</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="le_Password">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0">
<spacer name="verticalSpacer_12">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>290</width>
<height>21</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_21">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>QMK-Datenserver Verbindung &amp; Login</string>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="Seite_8">
<layout class="QGridLayout" name="gridLayout_20">
<item row="0" column="0">
<widget class="QLabel" name="label_20">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Firmware Flash &amp; Update</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
<string>Pfad zu AVRDUDE </string>
</property>
<layout class="QGridLayout" name="gridLayout_19">
<item row="0" column="0">
<widget class="QPushButton" name="pb_PATH_AVRDUDE">
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../MKTool.qrc">
<normaloff>:/Actions/Images/Actions/Folder-Open.png</normaloff>:/Actions/Images/Actions/Folder-Open.png</iconset>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="le_PATH_AVRDUDE"/>
</item>
</layout>
</widget>
</item>
<item row="2" column="0">
<widget class="QGroupBox" name="groupBox_6">
<property name="enabled">
<bool>false</bool>
</property>
<property name="title">
<string>ISP-Adapter (Flash AVR)</string>
</property>
<layout class="QGridLayout" name="gridLayout_5">
<item row="0" column="0">
<widget class="QLabel" name="label_4">
<property name="text">
<string>ISP-Adapter: </string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QComboBox" name="comboBox">
<item>
<property name="text">
<string>Sercon</string>
</property>
</item>
<item>
<property name="text">
<string>STK200</string>
</property>
</item>
<item>
<property name="text">
<string>USBProg</string>
</property>
</item>
<item>
<property name="text">
<string>Atmel AVR ISP (STK500)</string>
</property>
</item>
<item>
<property name="text">
<string>Atmel AVR ISP mkII (STK500v1)</string>
</property>
</item>
<item>
<property name="text">
<string>Atmel AVR ISP mkII (STK500v2)</string>
</property>
</item>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_5">
<property name="text">
<string>Device: </string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="lineEdit_2"/>
</item>
<item row="2" column="0" colspan="2">
<widget class="QCheckBox" name="checkBox_2">
<property name="text">
<string>Serielle Firmeware-Updates mit AVRDUDE</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item row="3" column="0">
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<resources>
<include location="../MKTool.qrc"/>
</resources>
<connections>
<connection>
<sender>okButton</sender>
<signal>clicked()</signal>
<receiver>dlg_Preferences_UI</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>278</x>
<y>253</y>
</hint>
<hint type="destinationlabel">
<x>96</x>
<y>254</y>
</hint>
</hints>
</connection>
<connection>
<sender>cancelButton</sender>
<signal>clicked()</signal>
<receiver>dlg_Preferences_UI</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>369</x>
<y>253</y>
</hint>
<hint type="destinationlabel">
<x>179</x>
<y>282</y>
</hint>
</hints>
</connection>
<connection>
<sender>listWidget</sender>
<signal>currentRowChanged(int)</signal>
<receiver>stackedWidget</receiver>
<slot>setCurrentIndex(int)</slot>
<hints>
<hint type="sourcelabel">
<x>90</x>
<y>265</y>
</hint>
<hint type="destinationlabel">
<x>439</x>
<y>369</y>
</hint>
</hints>
</connection>
</connections>
</ui>
/QMK-Groundstation/branches/own_com_lib/Forms/mktool.cpp
0,0 → 1,1854
/***************************************************************************
* 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. *
***************************************************************************/
 
// TODO: Wiederholungssenden wieder einbauen
 
#include <QtGui>
 
#include <QLineEdit>
#include <QString>
#include <QTimer>
#include <QIcon>
#include <QToolButton>
#include <QSpinBox>
#include <QAction>
#include <QPalette>
 
#include "mktool.h"
#include "dlg_Config.h"
#include "dlg_Motortest.h"
#include "dlg_Preferences.h"
#include "../global.h"
#include "../Classes/ToolBox.h"
#include "../com/Parser.h"
 
#include <stdlib.h>
 
MKTool::MKTool()
{
setupUi(this);
 
Settings = new cSettings;
 
init_Arrays();
init_GUI();
init_Cockpit();
 
init_Objects();
init_Connections();
 
init_Plot();
}
 
void MKTool::init_GUI()
{
setWindowTitle(QA_NAME + " v" + QA_VERSION);
 
// Tab mit Debug-Elementen verbergen
tab_Main->removeTab(6);
// Develop - Nicht gebrauchte sachen abschalten.
pb_SettingsReset->hide();
pb_Flash->hide();
rb_NC->hide();
 
// Beta-Sachen einschalten.
#ifdef _BETA_
ac_QMKServer->setEnabled(true);
#endif
 
// Settings-Tab hinzufügen.
f_Settings = new wdg_Settings( this );
f_Settings->set_Config(Settings);
tab_Main->insertTab ( 2, f_Settings, ac_View2->icon(), tr("FC-Settings"));
tab_Main->widget(2)->setObjectName("Tab_2");
 
// Zusätzliche Widgets in die Toolbar.
tb_TTY->addWidget(lb_Port);
tb_TTY->addWidget(le_Port);
 
tb_Hardware->addWidget(rb_SelFC);
tb_Hardware->addWidget(rb_SelNC);
tb_Hardware->addWidget(rb_SelMag);
 
tb_Allgemein->setVisible(Settings->GUI.ToolViews[0]);
tb_Werkzeuge->setVisible(Settings->GUI.ToolViews[1]);
tb_Debug->setVisible(Settings->GUI.ToolViews[2]);
tb_TTY->setVisible(Settings->GUI.ToolViews[3]);
tb_Hardware->setVisible(Settings->GUI.ToolViews[4]);
 
#ifdef _EEEPC_
lb_Status->hide();
#endif
 
lb_Status->setText(tr("Hallo bei QMK-Groundstation...!!!"));
 
resize(Settings->GUI.Size);
move(Settings->GUI.Point);
 
if (Settings->GUI.isMax)
{
showMaximized();
}
 
// Analoglabels anzeigen
for (int a = 0; a < MaxAnalog; a++)
{
lb_Analog[a]->setText(Settings->Analog1.Label[a]);
}
 
// Kopie der Tabs anlegen
for (int b = 0; b < 7; b++)
{
TabWidgets[b] = tab_Main->widget(b);
}
 
// Ausgeblendete Tabs ausblenden
for (int c = 0; c < 7; c++)
{
if (Settings->GUI.TabViews[c] == false)
{
QString TabName = QString("Tab_%1").arg(c);
 
for (int d = 0; d < tab_Main->count(); d++)
{
if (tab_Main->widget(d)->objectName() == TabName)
{
tab_Main->removeTab(d);
}
}
}
}
 
ac_View0->setChecked(Settings->GUI.TabViews[0]);
ac_View1->setChecked(Settings->GUI.TabViews[1]);
ac_View2->setChecked(Settings->GUI.TabViews[2]);
ac_View3->setChecked(Settings->GUI.TabViews[3]);
ac_View4->setChecked(Settings->