src/GUI/mapview.cpp

   1 #include <QGraphicsView>
   2 #include <QGraphicsScene>
   3 #include <QWheelEvent>
   4 #include <QApplication>
   5 #include <QPixmapCache>
   6 #include <QScrollBar>
   7 #include "data/poi.h"
   8 #include "data/data.h"
   9 #include "map/map.h"
  10 #include "map/pcs.h"
  11 #include "opengl.h"
  12 #include "trackitem.h"
  13 #include "routeitem.h"
  14 #include "waypointitem.h"
  15 #include "areaitem.h"
  16 #include "scaleitem.h"
  17 #include "coordinatesitem.h"
  18 #include "keys.h"
  19 #include "mapview.h"
  20
  21
  22 #define MAX_DIGITAL_ZOOM 2
  23 #define MIN_DIGITAL_ZOOM -3
  24 #define MARGIN           10
  25 #define SCALE_OFFSET     7
  26 #define COORDINATES_OFFSET SCALE_OFFSET
  27
  28
  29 MapView::MapView(Map *map, POI *poi, QWidget *parent)
  30   : QGraphicsView(parent)
  31 {
  32         Q_ASSERT(map != 0);
  33         Q_ASSERT(poi != 0);
  34
  35         _scene = new QGraphicsScene(this);
  36         setScene(_scene);
  37         setDragMode(QGraphicsView::ScrollHandDrag);
  38         setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
  39         setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  40         setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  41         setRenderHint(QPainter::Antialiasing, true);
  42         setResizeAnchor(QGraphicsView::AnchorViewCenter);
  43         setAcceptDrops(false);
  44
  45         _mapScale = new ScaleItem();
  46         _mapScale->setZValue(2.0);
  47         _scene->addItem(_mapScale);
  48         _coordinates = new CoordinatesItem();
  49         _coordinates->setZValue(2.0);
  50         _coordinates->setVisible(false);
  51         _scene->addItem(_coordinates);
  52
  53         _projection = PCS::pcs(3857);
  54         _map = map;
  55         _map->load();
  56         _map->setProjection(_projection);
  57         connect(_map, SIGNAL(loaded()), this, SLOT(reloadMap()));
  58
  59         _poi = poi;
  60         connect(_poi, SIGNAL(pointsChanged()), this, SLOT(updatePOI()));
  61
  62         _units = Metric;
  63         _coordinatesFormat = DecimalDegrees;
  64         _mapOpacity = 1.0;
  65         _backgroundColor = Qt::white;
  66         _markerColor = Qt::red;
  67
  68         _showMap = true;
  69         _showTracks = true;
  70         _showRoutes = true;
  71         _showAreas = true;
  72         _showWaypoints = true;
  73         _showWaypointLabels = true;
  74         _showPOI = true;
  75         _showPOILabels = true;
  76         _overlapPOIs = true;
  77         _showRouteWaypoints = true;
  78         _showMarkers = true;
  79         _showPathTicks = false;
  80         _trackWidth = 3;
  81         _routeWidth = 3;
  82         _trackStyle = Qt::SolidLine;
  83         _routeStyle = Qt::DashLine;
  84         _waypointSize = 8;
  85         _waypointColor = Qt::black;
  86         _poiSize = 8;
  87         _poiColor = Qt::black;
  88
  89 #ifdef ENABLE_HIDPI
  90         _deviceRatio = 1.0;
  91         _mapRatio = 1.0;
  92 #endif // ENABLE_HIDPI
  93         _opengl = false;
  94         _plot = false;
  95         _digitalZoom = 0;
  96
  97         _res = _map->resolution(_map->bounds());
  98         _scene->setSceneRect(_map->bounds());
  99
 100         centerOn(_scene->sceneRect().center());
 101 }
 102
 103 void MapView::centerOn(const QPointF &pos)
 104 {
 105         QGraphicsView::centerOn(pos);
 106         QRectF vr(mapToScene(viewport()->rect()).boundingRect());
 107         _res = _map->resolution(vr);
 108         _mapScale->setResolution(_res);
 109         _coordinates->setCoordinates(Coordinates());
 110 }
 111
 112 PathItem *MapView::addTrack(const Track &track)
 113 {
 114         if (!track.isValid()) {
 115                 skipColor();
 116                 return 0;
 117         }
 118
 119         TrackItem *ti = new TrackItem(track, _map);
 120         _tracks.append(ti);
 121         _tr |= ti->path().boundingRect();
 122         ti->setColor(_palette.nextColor());
 123         ti->setWidth(_trackWidth);
 124         ti->setStyle(_trackStyle);
 125         ti->setUnits(_units);
 126         ti->setVisible(_showTracks);
 127         ti->setDigitalZoom(_digitalZoom);
 128         ti->setMarkerColor(_markerColor);
 129         ti->showMarker(_showMarkers);
 130         ti->showTicks(_showPathTicks);
 131         _scene->addItem(ti);
 132
 133         if (_showTracks)
 134                 addPOI(_poi->points(ti->path()));
 135
 136         return ti;
 137 }
 138
 139 PathItem *MapView::addRoute(const Route &route)
 140 {
 141         if (!route.isValid()) {
 142                 skipColor();
 143                 return 0;
 144         }
 145
 146         RouteItem *ri = new RouteItem(route, _map);
 147         _routes.append(ri);
 148         _rr |= ri->path().boundingRect();
 149         ri->setColor(_palette.nextColor());
 150         ri->setWidth(_routeWidth);
 151         ri->setStyle(_routeStyle);
 152         ri->setUnits(_units);
 153         ri->setCoordinatesFormat(_coordinatesFormat);
 154         ri->setVisible(_showRoutes);
 155         ri->showWaypoints(_showRouteWaypoints);
 156         ri->showWaypointLabels(_showWaypointLabels);
 157         ri->setDigitalZoom(_digitalZoom);
 158         ri->setMarkerColor(_markerColor);
 159         ri->showMarker(_showMarkers);
 160         ri->showTicks(_showPathTicks);
 161         _scene->addItem(ri);
 162
 163         if (_showRoutes)
 164                 addPOI(_poi->points(ri->path()));
 165
 166         return ri;
 167 }
 168
 169 void MapView::addArea(const Area &area)
 170 {
 171         if (!area.isValid()) {
 172                 skipColor();
 173                 return;
 174         }
 175
 176         AreaItem *ai = new AreaItem(area, _map);
 177         _areas.append(ai);
 178         _ar |= ai->area().boundingRect();
 179         ai->setColor(_palette.nextColor());
 180         ai->setWidth(_areaWidth);
 181         ai->setStyle(_areaStyle);
 182         ai->setOpacity(_areaOpacity);
 183         ai->setDigitalZoom(_digitalZoom);
 184         ai->setVisible(_showAreas);
 185         _scene->addItem(ai);
 186
 187         if (_showAreas)
 188                 addPOI(_poi->points(ai->area()));
 189 }
 190
 191 void MapView::addWaypoints(const QVector<Waypoint> &waypoints)
 192 {
 193         for (int i = 0; i < waypoints.count(); i++) {
 194                 const Waypoint &w = waypoints.at(i);
 195
 196                 WaypointItem *wi = new WaypointItem(w, _map);
 197                 _waypoints.append(wi);
 198                 _wr = _wr.united(wi->waypoint().coordinates());
 199                 wi->setZValue(1);
 200                 wi->setSize(_waypointSize);
 201                 wi->setColor(_waypointColor);
 202                 wi->showLabel(_showWaypointLabels);
 203                 wi->setToolTipFormat(_units, _coordinatesFormat);
 204                 wi->setVisible(_showWaypoints);
 205                 wi->setDigitalZoom(_digitalZoom);
 206                 _scene->addItem(wi);
 207
 208                 if (_showWaypoints)
 209                         addPOI(_poi->points(w));
 210         }
 211 }
 212
 213 QList<PathItem *> MapView::loadData(const Data &data)
 214 {
 215         QList<PathItem *> paths;
 216         int zoom = _map->zoom();
 217
 218         for (int i = 0; i < data.tracks().count(); i++)
 219                 paths.append(addTrack(data.tracks().at(i)));
 220         for (int i = 0; i < data.routes().count(); i++)
 221                 paths.append(addRoute(data.routes().at(i)));
 222         for (int i = 0; i < data.areas().count(); i++)
 223                 addArea(data.areas().at(i));
 224         addWaypoints(data.waypoints());
 225
 226         if (_tracks.empty() && _routes.empty() && _waypoints.empty()
 227           && _areas.empty())
 228                 return paths;
 229
 230         if (fitMapZoom() != zoom)
 231                 rescale();
 232         else
 233                 updatePOIVisibility();
 234
 235         centerOn(contentCenter());
 236
 237         return paths;
 238 }
 239
 240 int MapView::fitMapZoom() const
 241 {
 242         RectC br = _tr | _rr | _wr | _ar;
 243
 244         return _map->zoomFit(viewport()->size() - QSize(2*MARGIN, 2*MARGIN),
 245           br.isNull() ? RectC(_map->xy2ll(_map->bounds().topLeft()),
 246           _map->xy2ll(_map->bounds().bottomRight())) : br);
 247 }
 248
 249 QPointF MapView::contentCenter() const
 250 {
 251         RectC br = _tr | _rr | _wr | _ar;
 252
 253         return br.isNull() ? sceneRect().center() : _map->ll2xy(br.center());
 254 }
 255
 256 void MapView::updatePOIVisibility()
 257 {
 258         if (!_showPOI)
 259                 return;
 260
 261         for (POIHash::const_iterator it = _pois.constBegin();
 262           it != _pois.constEnd(); it++)
 263                 it.value()->show();
 264
 265         if (!_overlapPOIs) {
 266                 for (POIHash::const_iterator it = _pois.constBegin();
 267                   it != _pois.constEnd(); it++) {
 268                         for (POIHash::const_iterator jt = _pois.constBegin();
 269                           jt != _pois.constEnd(); jt++) {
 270                                 if (it.value()->isVisible() && jt.value()->isVisible()
 271                                   && it != jt && it.value()->collidesWithItem(jt.value()))
 272                                         jt.value()->hide();
 273                         }
 274                 }
 275         }
 276 }
 277
 278 void MapView::rescale()
 279 {
 280         _scene->setSceneRect(_map->bounds());
 281         reloadMap();
 282
 283         for (int i = 0; i < _tracks.size(); i++)
 284                 _tracks.at(i)->setMap(_map);
 285         for (int i = 0; i < _routes.size(); i++)
 286                 _routes.at(i)->setMap(_map);
 287         for (int i = 0; i < _areas.size(); i++)
 288                 _areas.at(i)->setMap(_map);
 289         for (int i = 0; i < _waypoints.size(); i++)
 290                 _waypoints.at(i)->setMap(_map);
 291
 292         for (POIHash::const_iterator it = _pois.constBegin();
 293           it != _pois.constEnd(); it++)
 294                 it.value()->setMap(_map);
 295
 296         updatePOIVisibility();
 297 }
 298
 299 void MapView::setPalette(const Palette &palette)
 300 {
 301         _palette = palette;
 302         _palette.reset();
 303
 304         for (int i = 0; i < _tracks.count(); i++)
 305                 _tracks.at(i)->setColor(_palette.nextColor());
 306         for (int i = 0; i < _routes.count(); i++)
 307                 _routes.at(i)->setColor(_palette.nextColor());
 308         for (int i = 0; i < _areas.count(); i++)
 309                 _areas.at(i)->setColor(_palette.nextColor());
 310 }
 311
 312 void MapView::setMap(Map *map)
 313 {
 314         QRectF vr(mapToScene(viewport()->rect()).boundingRect()
 315           .intersected(_map->bounds()));
 316         RectC cr(_map->xy2ll(vr.topLeft()), _map->xy2ll(vr.bottomRight()));
 317
 318         _map->unload();
 319         disconnect(_map, SIGNAL(loaded()), this, SLOT(reloadMap()));
 320
 321         _map = map;
 322         _map->load();
 323         _map->setProjection(_projection);
 324 #ifdef ENABLE_HIDPI
 325         _map->setDevicePixelRatio(_deviceRatio, _mapRatio);
 326 #endif // ENABLE_HIDPI
 327         connect(_map, SIGNAL(loaded()), this, SLOT(reloadMap()));
 328
 329         digitalZoom(0);
 330
 331         _map->zoomFit(viewport()->rect().size(), cr);
 332         _scene->setSceneRect(_map->bounds());
 333
 334         for (int i = 0; i < _tracks.size(); i++)
 335                 _tracks.at(i)->setMap(map);
 336         for (int i = 0; i < _routes.size(); i++)
 337                 _routes.at(i)->setMap(map);
 338         for (int i = 0; i < _areas.size(); i++)
 339                 _areas.at(i)->setMap(map);
 340         for (int i = 0; i < _waypoints.size(); i++)
 341                 _waypoints.at(i)->setMap(map);
 342
 343         for (POIHash::const_iterator it = _pois.constBegin();
 344           it != _pois.constEnd(); it++)
 345                 it.value()->setMap(_map);
 346         updatePOIVisibility();
 347
 348         QPointF nc = QRectF(_map->ll2xy(cr.topLeft()),
 349           _map->ll2xy(cr.bottomRight())).center();
 350         centerOn(nc);
 351
 352         reloadMap();
 353         QPixmapCache::clear();
 354 }
 355
 356 void MapView::setPOI(POI *poi)
 357 {
 358         disconnect(_poi, SIGNAL(pointsChanged()), this, SLOT(updatePOI()));
 359         connect(poi, SIGNAL(pointsChanged()), this, SLOT(updatePOI()));
 360
 361         _poi = poi;
 362
 363         updatePOI();
 364 }
 365
 366 void MapView::updatePOI()
 367 {
 368         for (POIHash::const_iterator it = _pois.constBegin();
 369           it != _pois.constEnd(); it++)
 370                 _scene->removeItem(it.value());
 371         qDeleteAll(_pois);
 372         _pois.clear();
 373
 374         if (_showTracks)
 375                 for (int i = 0; i < _tracks.size(); i++)
 376                         addPOI(_poi->points(_tracks.at(i)->path()));
 377         if (_showRoutes)
 378                 for (int i = 0; i < _routes.size(); i++)
 379                         addPOI(_poi->points(_routes.at(i)->path()));
 380         if (_showAreas)
 381                 for (int i = 0; i < _areas.size(); i++)
 382                         addPOI(_poi->points(_areas.at(i)->area()));
 383         if (_showWaypoints)
 384                 for (int i = 0; i< _waypoints.size(); i++)
 385                         addPOI(_poi->points(_waypoints.at(i)->waypoint()));
 386
 387         updatePOIVisibility();
 388 }
 389
 390 void MapView::addPOI(const QList<Waypoint> &waypoints)
 391 {
 392         for (int i = 0; i < waypoints.size(); i++) {
 393                 const Waypoint &w = waypoints.at(i);
 394
 395                 if (_pois.contains(SearchPointer<Waypoint>(&w)))
 396                         continue;
 397
 398                 WaypointItem *pi = new WaypointItem(w, _map);
 399                 pi->setZValue(1);
 400                 pi->setSize(_poiSize);
 401                 pi->setColor(_poiColor);
 402                 pi->showLabel(_showPOILabels);
 403                 pi->setVisible(_showPOI);
 404                 pi->setDigitalZoom(_digitalZoom);
 405                 pi->setToolTipFormat(_units, _coordinatesFormat);
 406                 _scene->addItem(pi);
 407
 408                 _pois.insert(SearchPointer<Waypoint>(&(pi->waypoint())), pi);
 409         }
 410 }
 411
 412 void MapView::setUnits(Units units)
 413 {
 414         if (_units == units)
 415                 return;
 416
 417         _units = units;
 418
 419         _mapScale->setUnits(_units);
 420
 421         for (int i = 0; i < _tracks.count(); i++)
 422                 _tracks[i]->setUnits(_units);
 423         for (int i = 0; i < _routes.count(); i++)
 424                 _routes[i]->setUnits(_units);
 425         for (int i = 0; i < _waypoints.size(); i++)
 426                 _waypoints.at(i)->setToolTipFormat(_units, _coordinatesFormat);
 427
 428         for (POIHash::const_iterator it = _pois.constBegin();
 429           it != _pois.constEnd(); it++)
 430                 it.value()->setToolTipFormat(_units, _coordinatesFormat);
 431 }
 432
 433 void MapView::setCoordinatesFormat(CoordinatesFormat format)
 434 {
 435         if (_coordinatesFormat == format)
 436                 return;
 437
 438         _coordinatesFormat = format;
 439
 440         _coordinates->setFormat(_coordinatesFormat);
 441
 442         for (int i = 0; i < _waypoints.count(); i++)
 443                 _waypoints.at(i)->setToolTipFormat(_units, _coordinatesFormat);
 444         for (int i = 0; i < _routes.count(); i++)
 445                 _routes[i]->setCoordinatesFormat(_coordinatesFormat);
 446
 447         for (POIHash::const_iterator it = _pois.constBegin();
 448           it != _pois.constEnd(); it++)
 449                 it.value()->setToolTipFormat(_units, _coordinatesFormat);
 450 }
 451
 452 void MapView::clearMapCache()
 453 {
 454         _map->clearCache();
 455
 456         fitMapZoom();
 457         rescale();
 458         centerOn(contentCenter());
 459 }
 460
 461 void MapView::digitalZoom(int zoom)
 462 {
 463         if (zoom) {
 464                 _digitalZoom += zoom;
 465                 scale(pow(2, zoom), pow(2, zoom));
 466         } else {
 467                 _digitalZoom = 0;
 468                 resetTransform();
 469         }
 470
 471         for (int i = 0; i < _tracks.size(); i++)
 472                 _tracks.at(i)->setDigitalZoom(_digitalZoom);
 473         for (int i = 0; i < _routes.size(); i++)
 474                 _routes.at(i)->setDigitalZoom(_digitalZoom);
 475         for (int i = 0; i < _areas.size(); i++)
 476                 _areas.at(i)->setDigitalZoom(_digitalZoom);
 477         for (int i = 0; i < _waypoints.size(); i++)
 478                 _waypoints.at(i)->setDigitalZoom(_digitalZoom);
 479         for (POIHash::const_iterator it = _pois.constBegin();
 480           it != _pois.constEnd(); it++)
 481                 it.value()->setDigitalZoom(_digitalZoom);
 482
 483         _mapScale->setDigitalZoom(_digitalZoom);
 484         _coordinates->setDigitalZoom(_digitalZoom);
 485 }
 486
 487 void MapView::zoom(int zoom, const QPoint &pos)
 488 {
 489         bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
 490
 491         if (_digitalZoom) {
 492                 if (((_digitalZoom > 0 && zoom > 0) && (!shift || _digitalZoom
 493                   >= MAX_DIGITAL_ZOOM)) || ((_digitalZoom < 0 && zoom < 0) && (!shift
 494                   || _digitalZoom <= MIN_DIGITAL_ZOOM)))
 495                         return;
 496
 497                 digitalZoom(zoom);
 498         } else {
 499                 Coordinates c = _map->xy2ll(mapToScene(pos));
 500                 int oz = _map->zoom();
 501                 int nz = (zoom > 0) ? _map->zoomIn() : _map->zoomOut();
 502
 503                 if (nz != oz) {
 504                         rescale();
 505                         centerOn(_map->ll2xy(c) - (pos - viewport()->rect().center()));
 506                 } else {
 507                         if (shift)
 508                                 digitalZoom(zoom);
 509                 }
 510         }
 511 }
 512
 513 void MapView::wheelEvent(QWheelEvent *event)
 514 {
 515         static int deg = 0;
 516
 517         deg += event->delta() / 8;
 518         if (qAbs(deg) < 15)
 519                 return;
 520         deg = 0;
 521
 522         zoom((event->delta() > 0) ? 1 : -1, event->pos());
 523 }
 524
 525 void MapView::mouseDoubleClickEvent(QMouseEvent *event)
 526 {
 527         if (event->button() != Qt::LeftButton && event->button() != Qt::RightButton)
 528                 return;
 529
 530         zoom((event->button() == Qt::LeftButton) ? 1 : -1, event->pos());
 531 }
 532
 533 void MapView::keyPressEvent(QKeyEvent *event)
 534 {
 535         int z;
 536
 537         QPoint pos = viewport()->rect().center();
 538
 539         if (event->key() == ZOOM_IN)
 540                 z = 1;
 541         else if (event->key() == ZOOM_OUT)
 542                 z = -1;
 543         else if (_digitalZoom && event->key() == Qt::Key_Escape) {
 544                 digitalZoom(0);
 545                 return;
 546         } else {
 547                 QGraphicsView::keyPressEvent(event);
 548                 return;
 549         }
 550
 551         zoom(z, pos);
 552 }
 553
 554 void MapView::plot(QPainter *painter, const QRectF &target, qreal scale,
 555   bool hires)
 556 {
 557         QRect orig, adj;
 558         qreal ratio, diff, q;
 559         QPointF origScene, origPos;
 560         int zoom;
 561
 562
 563         // Enter plot mode
 564         setUpdatesEnabled(false);
 565         _plot = true;
 566 #ifdef ENABLE_HIDPI
 567         _map->setDevicePixelRatio(_deviceRatio, 1.0);
 568 #endif // ENABLE_HIDPI
 569
 570         // Compute sizes & ratios
 571         orig = viewport()->rect();
 572         origPos = _mapScale->pos();
 573
 574         if (orig.height() * (target.width() / target.height()) - orig.width() < 0) {
 575                 ratio = target.height() / target.width();
 576                 diff = (orig.width() * ratio) - orig.height();
 577                 adj = orig.adjusted(0, -diff/2, 0, diff/2);
 578         } else {
 579                 ratio = target.width() / target.height();
 580                 diff = (orig.height() * ratio) - orig.width();
 581                 adj = orig.adjusted(-diff/2, 0, diff/2, 0);
 582         }
 583         q = (target.width() / scale) / adj.width();
 584
 585         // Adjust the view for printing
 586         if (hires) {
 587                 zoom = _map->zoom();
 588                 QRectF vr(mapToScene(orig).boundingRect());
 589                 origScene = vr.center();
 590
 591                 QPointF s(painter->device()->logicalDpiX()
 592                   / (qreal)metric(QPaintDevice::PdmDpiX),
 593                   painter->device()->logicalDpiY()
 594                   / (qreal)metric(QPaintDevice::PdmDpiY));
 595                 adj = QRect(0, 0, adj.width() * s.x(), adj.height() * s.y());
 596                 _map->zoomFit(adj.size(), _tr | _rr | _wr | _ar);
 597                 rescale();
 598
 599                 QPointF center = contentCenter();
 600                 centerOn(center);
 601                 adj.moveCenter(mapFromScene(center));
 602
 603                 _mapScale->setDigitalZoom(_digitalZoom - log2(s.x() / q));
 604                 _mapScale->setPos(mapToScene(QPoint(adj.bottomRight() + QPoint(
 605                   -(SCALE_OFFSET + _mapScale->boundingRect().width()) * (s.x() / q),
 606                   -(SCALE_OFFSET + _mapScale->boundingRect().height()) * (s.x() / q)))));
 607         } else {
 608                 _mapScale->setDigitalZoom(_digitalZoom - log2(1.0 / q));
 609                 _mapScale->setPos(mapToScene(QPoint(adj.bottomRight() + QPoint(
 610                   -(SCALE_OFFSET + _mapScale->boundingRect().width()) / q ,
 611                   -(SCALE_OFFSET + _mapScale->boundingRect().height()) / q))));
 612         }
 613
 614         // Print the view
 615         render(painter, target, adj);
 616
 617         // Revert view changes to display mode
 618         if (hires) {
 619                 _map->setZoom(zoom);
 620                 rescale();
 621                 centerOn(origScene);
 622         }
 623         _mapScale->setDigitalZoom(_digitalZoom);
 624         _mapScale->setPos(origPos);
 625
 626         // Exit plot mode
 627 #ifdef ENABLE_HIDPI
 628         _map->setDevicePixelRatio(_deviceRatio, _mapRatio);
 629 #endif // ENABLE_HIDPI
 630         _plot = false;
 631         setUpdatesEnabled(true);
 632 }
 633
 634 void MapView::clear()
 635 {
 636         _pois.clear();
 637         _tracks.clear();
 638         _routes.clear();
 639         _areas.clear();
 640         _waypoints.clear();
 641
 642         _scene->removeItem(_mapScale);
 643         _scene->removeItem(_coordinates);
 644         _scene->clear();
 645         _scene->addItem(_mapScale);
 646         _scene->addItem(_coordinates);
 647
 648         _palette.reset();
 649
 650         _tr = RectC();
 651         _rr = RectC();
 652         _wr = RectC();
 653         _ar = RectC();
 654
 655         digitalZoom(0);
 656
 657         // If not reset, causes huge redraw areas (and system memory exhaustion)
 658         resetCachedContent();
 659 }
 660
 661 void MapView::showTracks(bool show)
 662 {
 663         _showTracks = show;
 664
 665         for (int i = 0; i < _tracks.count(); i++)
 666                 _tracks.at(i)->setVisible(show);
 667
 668         updatePOI();
 669 }
 670
 671 void MapView::showRoutes(bool show)
 672 {
 673         _showRoutes = show;
 674
 675         for (int i = 0; i < _routes.count(); i++)
 676                 _routes.at(i)->setVisible(show);
 677
 678         updatePOI();
 679 }
 680
 681 void MapView::showWaypoints(bool show)
 682 {
 683         _showWaypoints = show;
 684
 685         for (int i = 0; i < _waypoints.count(); i++)
 686                 _waypoints.at(i)->setVisible(show);
 687
 688         updatePOI();
 689 }
 690
 691 void MapView::showAreas(bool show)
 692 {
 693         _showAreas = show;
 694
 695         for (int i = 0; i < _areas.count(); i++)
 696                 _areas.at(i)->setVisible(show);
 697
 698         updatePOI();
 699 }
 700
 701 void MapView::showWaypointLabels(bool show)
 702 {
 703         _showWaypointLabels = show;
 704
 705         for (int i = 0; i < _waypoints.size(); i++)
 706                 _waypoints.at(i)->showLabel(show);
 707         for (int i = 0; i < _routes.size(); i++)
 708                 _routes.at(i)->showWaypointLabels(show);
 709 }
 710
 711 void MapView::showRouteWaypoints(bool show)
 712 {
 713         _showRouteWaypoints = show;
 714
 715         for (int i = 0; i < _routes.size(); i++)
 716                 _routes.at(i)->showWaypoints(show);
 717 }
 718
 719 void MapView::showMarkers(bool show)
 720 {
 721         _showMarkers = show;
 722
 723         for (int i = 0; i < _tracks.size(); i++)
 724                 _tracks.at(i)->showMarker(show);
 725         for (int i = 0; i < _routes.size(); i++)
 726                 _routes.at(i)->showMarker(show);
 727 }
 728
 729 void MapView::showTicks(bool show)
 730 {
 731         _showPathTicks = show;
 732         for (int i = 0; i < _tracks.size(); i++)
 733                 _tracks.at(i)->showTicks(show);
 734         for (int i = 0; i < _routes.size(); i++)
 735                 _routes.at(i)->showTicks(show);
 736 }
 737
 738 void MapView::showMap(bool show)
 739 {
 740         _showMap = show;
 741         reloadMap();
 742 }
 743
 744 void MapView::showPOI(bool show)
 745 {
 746         _showPOI = show;
 747
 748         for (POIHash::const_iterator it = _pois.constBegin();
 749           it != _pois.constEnd(); it++)
 750                 it.value()->setVisible(show);
 751
 752         updatePOIVisibility();
 753 }
 754
 755 void MapView::showPOILabels(bool show)
 756 {
 757         _showPOILabels = show;
 758
 759         for (POIHash::const_iterator it = _pois.constBegin();
 760           it != _pois.constEnd(); it++)
 761                 it.value()->showLabel(show);
 762
 763         updatePOIVisibility();
 764 }
 765
 766 void MapView::showCoordinates(bool show)
 767 {
 768         _coordinates->setVisible(show);
 769         setMouseTracking(show);
 770 }
 771
 772 void MapView::setPOIOverlap(bool overlap)
 773 {
 774         _overlapPOIs = overlap;
 775
 776         updatePOIVisibility();
 777 }
 778
 779 void MapView::setTrackWidth(int width)
 780 {
 781         _trackWidth = width;
 782
 783         for (int i = 0; i < _tracks.count(); i++)
 784                 _tracks.at(i)->setWidth(width);
 785 }
 786
 787 void MapView::setRouteWidth(int width)
 788 {
 789         _routeWidth = width;
 790
 791         for (int i = 0; i < _routes.count(); i++)
 792                 _routes.at(i)->setWidth(width);
 793 }
 794
 795 void MapView::setAreaWidth(int width)
 796 {
 797         _areaWidth = width;
 798
 799         for (int i = 0; i < _areas.count(); i++)
 800                 _areas.at(i)->setWidth(width);
 801 }
 802
 803 void MapView::setTrackStyle(Qt::PenStyle style)
 804 {
 805         _trackStyle = style;
 806
 807         for (int i = 0; i < _tracks.count(); i++)
 808                 _tracks.at(i)->setStyle(style);
 809 }
 810
 811 void MapView::setRouteStyle(Qt::PenStyle style)
 812 {
 813         _routeStyle = style;
 814
 815         for (int i = 0; i < _routes.count(); i++)
 816                 _routes.at(i)->setStyle(style);
 817 }
 818
 819 void MapView::setAreaStyle(Qt::PenStyle style)
 820 {
 821         _areaStyle = style;
 822
 823         for (int i = 0; i < _areas.count(); i++)
 824                 _areas.at(i)->setStyle(style);
 825 }
 826
 827 void MapView::setAreaOpacity(int opacity)
 828 {
 829         _areaOpacity = opacity / 100.0;
 830
 831         for (int i = 0; i < _areas.count(); i++)
 832                 _areas.at(i)->setOpacity(_areaOpacity);
 833 }
 834
 835 void MapView::setWaypointSize(int size)
 836 {
 837         _waypointSize = size;
 838
 839         for (int i = 0; i < _waypoints.size(); i++)
 840                 _waypoints.at(i)->setSize(size);
 841 }
 842
 843 void MapView::setWaypointColor(const QColor &color)
 844 {
 845         _waypointColor = color;
 846
 847         for (int i = 0; i < _waypoints.size(); i++)
 848                 _waypoints.at(i)->setColor(color);
 849 }
 850
 851 void MapView::setPOISize(int size)
 852 {
 853         _poiSize = size;
 854
 855         for (POIHash::const_iterator it = _pois.constBegin();
 856           it != _pois.constEnd(); it++)
 857                 it.value()->setSize(size);
 858 }
 859
 860 void MapView::setPOIColor(const QColor &color)
 861 {
 862         _poiColor = color;
 863
 864         for (POIHash::const_iterator it = _pois.constBegin();
 865           it != _pois.constEnd(); it++)
 866                 it.value()->setColor(color);
 867 }
 868
 869 void MapView::setMapOpacity(int opacity)
 870 {
 871         _mapOpacity = opacity / 100.0;
 872         reloadMap();
 873 }
 874
 875 void MapView::setBackgroundColor(const QColor &color)
 876 {
 877         _backgroundColor = color;
 878         reloadMap();
 879 }
 880
 881 void MapView::drawBackground(QPainter *painter, const QRectF &rect)
 882 {
 883         painter->fillRect(rect, _backgroundColor);
 884
 885         if (_showMap) {
 886                 QRectF ir = rect.intersected(_map->bounds());
 887                 Map::Flags flags = Map::NoFlags;
 888
 889                 if (_mapOpacity < 1.0)
 890                         painter->setOpacity(_mapOpacity);
 891
 892                 if (_plot)
 893                         flags = Map::Block;
 894                 else if (_opengl)
 895                         flags = Map::OpenGL;
 896
 897                 _map->draw(painter, ir, flags);
 898         }
 899 }
 900
 901 void MapView::paintEvent(QPaintEvent *event)
 902 {
 903         QPointF scaleScenePos = mapToScene(rect().bottomRight() + QPoint(
 904           -(SCALE_OFFSET + _mapScale->boundingRect().width()),
 905           -(SCALE_OFFSET + _mapScale->boundingRect().height())));
 906         if (_mapScale->pos() != scaleScenePos && !_plot)
 907                 _mapScale->setPos(scaleScenePos);
 908
 909         if (_coordinates->isVisible()) {
 910                 QPointF coordinatesScenePos = mapToScene(rect().bottomLeft()
 911                   + QPoint(COORDINATES_OFFSET, -COORDINATES_OFFSET));
 912                 if (_coordinates->pos() != coordinatesScenePos && !_plot)
 913                         _coordinates->setPos(coordinatesScenePos);
 914         }
 915
 916         QGraphicsView::paintEvent(event);
 917 }
 918
 919 void MapView::scrollContentsBy(int dx, int dy)
 920 {
 921         QGraphicsView::scrollContentsBy(dx, dy);
 922
 923         QRectF sr(mapToScene(viewport()->rect()).boundingRect());
 924         qreal res = _map->resolution(sr);
 925
 926         if (qMax(res, _res) / qMin(res, _res) > 1.1) {
 927                 _mapScale->setResolution(res);
 928                 _res = res;
 929         }
 930 }
 931
 932 void MapView::mouseMoveEvent(QMouseEvent *event)
 933 {
 934         if (_coordinates->isVisible())
 935                 _coordinates->setCoordinates(_map->xy2ll(mapToScene(event->pos())));
 936
 937         QGraphicsView::mouseMoveEvent(event);
 938 }
 939
 940 void MapView::leaveEvent(QEvent *event)
 941 {
 942         _coordinates->setCoordinates(Coordinates());
 943         QGraphicsView::leaveEvent(event);
 944 }
 945
 946 void MapView::useOpenGL(bool use)
 947 {
 948         _opengl = use;
 949
 950         if (use)
 951                 setViewport(new OPENGL_WIDGET);
 952         else
 953                 setViewport(new QWidget);
 954 }
 955
 956 void MapView::useAntiAliasing(bool use)
 957 {
 958         setRenderHint(QPainter::Antialiasing, use);
 959 }
 960
 961 void MapView::setMarkerColor(const QColor &color)
 962 {
 963         _markerColor = color;
 964
 965         for (int i = 0; i < _tracks.size(); i++)
 966                 _tracks.at(i)->setMarkerColor(color);
 967         for (int i = 0; i < _routes.size(); i++)
 968                 _routes.at(i)->setMarkerColor(color);
 969 }
 970
 971 void MapView::reloadMap()
 972 {
 973         _scene->invalidate();
 974 }
 975
 976 void MapView::setDevicePixelRatio(qreal deviceRatio, qreal mapRatio)
 977 {
 978 #ifdef ENABLE_HIDPI
 979         if (_deviceRatio == deviceRatio && _mapRatio == mapRatio)
 980                 return;
 981
 982         _deviceRatio = deviceRatio;
 983         _mapRatio = mapRatio;
 984         QPixmapCache::clear();
 985
 986         QRectF vr(mapToScene(viewport()->rect()).boundingRect()
 987           .intersected(_map->bounds()));
 988         RectC cr(_map->xy2ll(vr.topLeft()), _map->xy2ll(vr.bottomRight()));
 989
 990         _map->setDevicePixelRatio(_deviceRatio, _mapRatio);
 991         _scene->setSceneRect(_map->bounds());
 992
 993         for (int i = 0; i < _tracks.size(); i++)
 994                 _tracks.at(i)->setMap(_map);
 995         for (int i = 0; i < _routes.size(); i++)
 996                 _routes.at(i)->setMap(_map);
 997         for (int i = 0; i < _areas.size(); i++)
 998                 _areas.at(i)->setMap(_map);
 999         for (int i = 0; i < _waypoints.size(); i++)
1000                 _waypoints.at(i)->setMap(_map);
1001
1002         for (POIHash::const_iterator it = _pois.constBegin();
1003           it != _pois.constEnd(); it++)
1004                 it.value()->setMap(_map);
1005         updatePOIVisibility();
1006
1007         QPointF nc = QRectF(_map->ll2xy(cr.topLeft()),
1008           _map->ll2xy(cr.bottomRight())).center();
1009         centerOn(nc);
1010
1011         reloadMap();
1012 #else // ENABLE_HIDPI
1013         Q_UNUSED(deviceRatio);
1014         Q_UNUSED(mapRatio);
1015 #endif // ENABLE_HIDPI
1016 }
1017
1018 void MapView::setProjection(int id)
1019 {
1020         const PCS *pcs;
1021         const GCS *gcs;
1022         Coordinates center = _map->xy2ll(mapToScene(viewport()->rect().center()));
1023
1024         if ((pcs = PCS::pcs(id)))
1025                 _projection = Projection(pcs);
1026         else if ((gcs = GCS::gcs(id)))
1027                 _projection = Projection(gcs);
1028         else
1029                 qWarning("%d: Unknown PCS/GCS id", id);
1030
1031         _map->setProjection(_projection);
1032         rescale();
1033         centerOn(_map->ll2xy(center));
1034 }
1035
1036 void MapView::fitContentToSize()
1037 {
1038         int zoom = _map->zoom();
1039         if (fitMapZoom() != zoom)
1040                 rescale();
1041
1042         centerOn(contentCenter());
1043 }