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; |
} |
} |