← Back to branch summary

~ubuntu-branches/ubuntu/saucy/merkaartor/saucy

« back to all changes in this revision

Viewing changes to src/QMapControl/mapcontrol.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Bernd Zeimetz
  • Date: 2009-09-13 00:52:12 UTC
  • mto: (1.2.7 upstream) (0.1.3 upstream) (3.1.7 sid)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20090913005212-pjecal8zxm07x0fj
Import upstream version 0.14+svnfixes~20090912

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/QMapControl/mapcontrol.cpp
 
1
/***************************************************************************
 
2
 *   Copyright (C) 2007 by Kai Winter   *
 
3
 *   kaiwinter@gmx.de   *
 
4
 *                                                                         *
 
5
 *   This program is free software; you can redistribute it and/or modify  *
 
6
 *   it under the terms of the GNU General Public License as published by  *
 
7
 *   the Free Software Foundation; either version 2 of the License, or     *
 
8
 *   (at your option) any later version.                                   *
 
9
 *                                                                         *
 
10
 *   This program is distributed in the hope that it will be useful,       *
 
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 
13
 *   GNU General Public License for more details.                          *
 
14
 *                                                                         *
 
15
 *   You should have received a copy of the GNU General Public License     *
 
16
 *   along with this program; if not, write to the                         *
 
17
 *   Free Software Foundation, Inc.,                                       *
 
18
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 
19
 ***************************************************************************/
 
20
#include "mapcontrol.h"
 
21
 
 
22
MapControl::MapControl(QSize size, MouseMode mousemode)
 
23
        : size(size), mousemode(mousemode)
 
24
{
 
25
        layermanager = new LayerManager(this, size);
 
26
        screen_middle = QPoint(size.width()/2, size.height()/2);
 
27
        
 
28
        mousepressed = false;
 
29
        
 
30
        connect(ImageManager::instance(), SIGNAL(imageReceived()),
 
31
                          this, SLOT(updateRequestNew()));
 
32
        
 
33
        connect(ImageManager::instance(), SIGNAL(loadingFinished()),
 
34
                          this, SLOT(loadingFinished()));
 
35
        
 
36
        this->setMaximumSize(size.width()+1, size.height()+1);
 
37
}
 
38
 
 
39
MapControl::~MapControl()
 
40
{
 
41
        delete layermanager;    
 
42
}
 
43
 
 
44
QPointF MapControl::getCurrentCoordinate() const
 
45
{
 
46
        return layermanager->getCurrentCoordinate();
 
47
}
 
48
 
 
49
Layer* MapControl::getLayer(const QString& layername) const
 
50
{
 
51
        return layermanager->getLayer(layername);
 
52
}
 
53
 
 
54
QList<QString> MapControl::getLayers() const
 
55
{
 
56
        return layermanager->getLayers();
 
57
}
 
58
 
 
59
int MapControl::getNumberOfLayers() const
 
60
{
 
61
        return layermanager->getLayers().size();
 
62
}
 
63
 
 
64
void MapControl::followGeometry(const Geometry* geom) const
 
65
{
 
66
        connect(geom, SIGNAL(positionChanged(Geometry*)),
 
67
                          this, SLOT(positionChanged(Geometry*)));
 
68
}
 
69
 
 
70
void MapControl::positionChanged(Geometry* geom)
 
71
{
 
72
        QPoint start = layermanager->getLayer()->getMapAdapter()->coordinateToDisplay(getCurrentCoordinate());
 
73
        QPoint dest = layermanager->getLayer()->getMapAdapter()->coordinateToDisplay(((Point*)geom)->getCoordinate());
 
74
 
 
75
        QPoint step = (dest-start);
 
76
 
 
77
        layermanager->scrollView(step);
 
78
        
 
79
//      setView(geom);
 
80
        update();
 
81
}
 
82
 
 
83
void MapControl::moveTo(QPointF coordinate)
 
84
{
 
85
        target = coordinate;
 
86
        steps = 25;
 
87
        if (moveMutex.tryLock())
 
88
        {
 
89
                QTimer::singleShot(40, this, SLOT(tick()));     
 
90
        }
 
91
        else
 
92
        {
 
93
//              stopMove(coordinate);
 
94
        }
 
95
}
 
96
void MapControl::tick()
 
97
{
 
98
        QPoint start = layermanager->getLayer()->getMapAdapter()->coordinateToDisplay(getCurrentCoordinate());
 
99
        QPoint dest = layermanager->getLayer()->getMapAdapter()->coordinateToDisplay(target);
 
100
        
 
101
        QPoint step = (dest-start)/steps;
 
102
        QPointF next = getCurrentCoordinate()- step;
 
103
 
 
104
//      setView(Coordinate(next.x(), next.y()));
 
105
        layermanager->scrollView(step);
 
106
        
 
107
        update();
 
108
        steps--;
 
109
        if (steps>0)
 
110
        {
 
111
                QTimer::singleShot(40, this, SLOT(tick()));
 
112
        }
 
113
        else
 
114
        {
 
115
                moveMutex.unlock();
 
116
        }
 
117
}
 
118
 
 
119
void MapControl::paintEvent(QPaintEvent* evnt)
 
120
{
 
121
        QWidget::paintEvent(evnt);
 
122
        QPainter painter(this);
 
123
        
 
124
//      painter.translate(150,190);
 
125
//      painter.scale(0.5,0.5);
 
126
        
 
127
//      painter.setClipRect(0,0, size.width(), size.height());
 
128
        
 
129
//      painter.setViewport(10000000000,0,size.width(),size.height());
 
130
        
 
131
        /*
 
132
        // rotating
 
133
        rotation = 45;
 
134
        painter.translate(256,256);
 
135
        painter.rotate(rotation);
 
136
        painter.translate(-256,-256);
 
137
        */
 
138
 
 
139
        layermanager->drawImage(&painter);
 
140
        layermanager->drawGeoms(&painter);
 
141
        
 
142
        painter.drawLine(screen_middle.x(), screen_middle.y()-10,
 
143
                                                  screen_middle.x(), screen_middle.y()+10); // |
 
144
        painter.drawLine(screen_middle.x()-10, screen_middle.y(),
 
145
                                                  screen_middle.x()+10, screen_middle.y()); // -
 
146
        
 
147
//      int cross_x = int(layermanager->getMapmiddle_px().x())%256;
 
148
//      int cross_y = int(layermanager->getMapmiddle_px().y())%256;
 
149
//      painter.drawLine(screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+0,
 
150
//                                                screen_middle.x()-cross_x+cross_x, screen_middle.y()-cross_y+256); // |
 
151
//      painter.drawLine(screen_middle.x()-cross_x+0, screen_middle.y()-cross_y+cross_y,
 
152
//                                                screen_middle.x()-cross_x+256, screen_middle.y()-cross_y+cross_y); // -
 
153
        
 
154
        painter.drawRect(0,0, size.width(), size.height());
 
155
        /*
 
156
        // rotating
 
157
        painter.setMatrix(painter.matrix().inverted());
 
158
        //qt = painter.transform();
 
159
        qm = painter.combinedMatrix();
 
160
        */
 
161
 
 
162
        if (mousepressed && mousemode == Dragging)
 
163
        {
 
164
                QRect rect = QRect(pre_click_px, current_mouse_pos);
 
165
                painter.drawRect(rect);
 
166
        }
 
167
}
 
168
 
 
169
// mouse events
 
170
void MapControl::mousePressEvent(QMouseEvent* evnt)
 
171
{
 
172
        //rotating
 
173
        
 
174
//      QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
 
175
//      evnt = me;
 
176
//      qDebug() << "evnt: " << evnt->x() << ", " << evnt->y() << ", " << evnt->pos();
 
177
 
 
178
        
 
179
        layermanager->mouseEvent(evnt);
 
180
        
 
181
        if (layermanager->getLayers().size()>0)
 
182
        {
 
183
                if (evnt->button() == 1)
 
184
                {
 
185
                        mousepressed = true;
 
186
                        pre_click_px = QPoint(evnt->x(), evnt->y());
 
187
                }
 
188
                else if (evnt->button() == 2 && mousemode != None)      // zoom in
 
189
                {
 
190
                        zoomIn();
 
191
                } else if  (evnt->button() == 4 && mousemode != None)   // zoom out
 
192
                {
 
193
                        zoomOut();
 
194
                }
 
195
        }
 
196
        
 
197
//      emit(mouseEvent(evnt));
 
198
        emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
 
199
}
 
200
 
 
201
void MapControl::mouseReleaseEvent(QMouseEvent* evnt)
 
202
{
 
203
        mousepressed = false;
 
204
        if (mousemode == Dragging)
 
205
        {
 
206
                QPointF ulCoord = clickToWorldCoordinate(pre_click_px);
 
207
                QPointF lrCoord = clickToWorldCoordinate(current_mouse_pos);
 
208
                
 
209
                QRectF coordinateBB = QRectF(ulCoord, QSizeF( (lrCoord-ulCoord).x(), (lrCoord-ulCoord).y()));
 
210
 
 
211
                emit(draggedRect(coordinateBB));
 
212
        }
 
213
        
 
214
        emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
 
215
}
 
216
 
 
217
void MapControl::mouseMoveEvent(QMouseEvent* evnt)
 
218
{
 
219
//      emit(mouseEvent(evnt));
 
220
        
 
221
        /*
 
222
        // rotating
 
223
        QMouseEvent* me = new QMouseEvent(evnt->type(), qm.map(QPoint(evnt->x(),evnt->y())), evnt->button(), evnt->buttons(), evnt->modifiers());
 
224
        evnt = me;
 
225
        */
 
226
        if (mousepressed && mousemode == Panning)
 
227
        {
 
228
                QPoint offset = pre_click_px - QPoint(evnt->x(), evnt->y());
 
229
                layermanager->scrollView(offset);
 
230
                pre_click_px = QPoint(evnt->x(), evnt->y());
 
231
        }
 
232
        else if (mousepressed && mousemode == Dragging)
 
233
        {
 
234
                current_mouse_pos = QPoint(evnt->x(), evnt->y());
 
235
        }
 
236
//      emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
 
237
 
 
238
        update();
 
239
//      emit(mouseEventCoordinate(evnt, clickToWorldCoordinate(evnt->pos())));
 
240
}
 
241
 
 
242
QPointF MapControl::clickToWorldCoordinate(QPoint click)
 
243
{
 
244
        // click coordinate to image coordinate
 
245
        QPoint displayToImage= QPoint(click.x()-screen_middle.x()+layermanager->getMapmiddle_px().x(),
 
246
                                                                                        click.y()-screen_middle.y()+layermanager->getMapmiddle_px().y());
 
247
        // image coordinate to world coordinate
 
248
        return layermanager->getLayer()->getMapAdapter()->displayToCoordinate(displayToImage);
 
249
}
 
250
 
 
251
void MapControl::updateRequest(QRect rect)
 
252
{
 
253
        update(rect);
 
254
}
 
255
void MapControl::updateRequestNew()
 
256
{
 
257
//      qDebug() << "MapControl::updateRequestNew()";
 
258
        layermanager->forceRedraw();
 
259
        update();
 
260
}
 
261
// slots
 
262
void MapControl::zoomIn()
 
263
{
 
264
        layermanager->zoomIn();
 
265
        update();
 
266
}
 
267
void MapControl::zoomOut()
 
268
{
 
269
        layermanager->zoomOut();
 
270
        update();
 
271
}
 
272
void MapControl::setZoom(int zoomlevel)
 
273
{
 
274
        layermanager->setZoom(zoomlevel);
 
275
        update();
 
276
}
 
277
int MapControl::getCurrentZoom() const
 
278
{
 
279
        return layermanager->getCurrentZoom();
 
280
}
 
281
void MapControl::scrollLeft(int pixel)
 
282
{
 
283
        layermanager->scrollView(QPoint(-pixel,0));
 
284
        update();
 
285
}
 
286
void MapControl::scrollRight(int pixel)
 
287
{
 
288
        layermanager->scrollView(QPoint(pixel,0));
 
289
        update();
 
290
}
 
291
void MapControl::scrollUp(int pixel)
 
292
{
 
293
        layermanager->scrollView(QPoint(0,-pixel));
 
294
        update();
 
295
}
 
296
void MapControl::scrollDown(int pixel)
 
297
{
 
298
        layermanager->scrollView(QPoint(0,pixel));
 
299
        update();
 
300
}
 
301
void MapControl::scroll(const QPoint scroll)
 
302
{
 
303
        layermanager->scrollView(scroll);
 
304
        update();
 
305
}
 
306
 
 
307
void MapControl::setView(const QPointF& coordinate) const
 
308
{
 
309
        layermanager->setView(coordinate);
 
310
}
 
311
 
 
312
void MapControl::setView(const QList<QPointF> coordinates) const
 
313
{
 
314
        layermanager->setView(coordinates);
 
315
}
 
316
 
 
317
void MapControl::setView(const Point* point) const
 
318
{
 
319
        layermanager->setView(point->getCoordinate());
 
320
}
 
321
 
 
322
void MapControl::loadingFinished()
 
323
{
 
324
//      qDebug() << "MapControl::loadingFinished()";
 
325
        layermanager->removeZoomImage();
 
326
}
 
327
void MapControl::addLayer(Layer* layer)
 
328
{
 
329
        layermanager->addLayer(layer);
 
330
}
 
331
 
 
332
void MapControl::setMouseMode(MouseMode mousemode)
 
333
{
 
334
        this->mousemode = mousemode;
 
335
}
 
336
MapControl::MouseMode MapControl::getMouseMode()
 
337
{
 
338
        return mousemode;
 
339
}
 
340
 
 
341
void MapControl::stopFollowing(Geometry* geom)
 
342
{
 
343
        geom->disconnect(SIGNAL(positionChanged(Geometry*)));
 
344
}