423 lines
8.8 KiB
C++
423 lines
8.8 KiB
C++
/**
|
|
******************************************************************************
|
|
*
|
|
* @file core.h
|
|
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012.
|
|
* @brief
|
|
* @see The GNU Public License (GPL) Version 3
|
|
* @defgroup OPMapWidget
|
|
* @{
|
|
*
|
|
*****************************************************************************/
|
|
/*
|
|
* 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 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 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 CORE_H
|
|
#define CORE_H
|
|
|
|
#include "debugheader.h"
|
|
|
|
#include "pointlatlng.h"
|
|
#include "mousewheelzoomtype.h"
|
|
#include "size.h"
|
|
#include "point.h"
|
|
|
|
#include "maptype.h"
|
|
#include "rectangle.h"
|
|
#include "QThreadPool"
|
|
#include "tilematrix.h"
|
|
#include <QQueue>
|
|
#include "loadtask.h"
|
|
#include "copyrightstrings.h"
|
|
#include "rectlatlng.h"
|
|
#include "projections/lks94projection.h"
|
|
#include "projections/mercatorprojection.h"
|
|
#include "projections/mercatorprojectionyandex.h"
|
|
#include "projections/platecarreeprojection.h"
|
|
#include "projections/platecarreeprojectionpergo.h"
|
|
#include "geodecoderstatus.h"
|
|
#include "opmaps.h"
|
|
#include "diagnostics.h"
|
|
|
|
#include <QSemaphore>
|
|
#include <QThread>
|
|
#include <QDateTime>
|
|
|
|
#include <QObject>
|
|
|
|
namespace mapcontrol {
|
|
|
|
#ifdef QtOpmapInternals
|
|
#include <internalglobal.h>
|
|
class OPMAPINTERNALSHARED_EXPORT OPMapControl;
|
|
class OPMAPINTERNALSHARED_EXPORT MapGraphicItem;
|
|
#else
|
|
class OPMapControl;
|
|
class MapGraphicItem;
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
namespace internals {
|
|
|
|
#ifdef QtOpmapInternals
|
|
#include <internalglobal.h>
|
|
class OPMAPINTERNALSHARED_EXPORT Core : public QObject, public QRunnable {
|
|
#else
|
|
class Core : public QObject, public QRunnable {
|
|
#endif
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
#ifdef QtOpmapInternals
|
|
#include <internalglobal.h>
|
|
friend class OPMAPINTERNALSHARED_EXPORT mapcontrol::OPMapControl;
|
|
friend class OPMAPINTERNALSHARED_EXPORT mapcontrol::MapGraphicItem;
|
|
#else
|
|
friend class mapcontrol::OPMapControl;
|
|
friend class mapcontrol::MapGraphicItem;
|
|
#endif
|
|
|
|
|
|
|
|
public:
|
|
Core();
|
|
~Core();
|
|
void run();
|
|
PointLatLng CurrentPosition() const
|
|
{
|
|
return currentPosition;
|
|
}
|
|
|
|
void SetCurrentPosition(const PointLatLng &value);
|
|
|
|
core::Point GetcurrentPositionGPixel()
|
|
{
|
|
return currentPositionPixel;
|
|
}
|
|
void SetcurrentPositionGPixel(const core::Point &value)
|
|
{
|
|
currentPositionPixel = value;
|
|
}
|
|
|
|
core::Point GetrenderOffset()
|
|
{
|
|
return renderOffset;
|
|
}
|
|
void SetrenderOffset(const core::Point &value)
|
|
{
|
|
renderOffset = value;
|
|
}
|
|
|
|
core::Point GetcenterTileXYLocation()
|
|
{
|
|
return centerTileXYLocation;
|
|
}
|
|
void SetcenterTileXYLocation(const core::Point &value)
|
|
{
|
|
centerTileXYLocation = value;
|
|
}
|
|
|
|
core::Point GetcenterTileXYLocationLast()
|
|
{
|
|
return centerTileXYLocationLast;
|
|
}
|
|
void SetcenterTileXYLocationLast(const core::Point &value)
|
|
{
|
|
centerTileXYLocationLast = value;
|
|
}
|
|
|
|
core::Point GetdragPoint()
|
|
{
|
|
return dragPoint;
|
|
}
|
|
void SetdragPoint(const core::Point &value)
|
|
{
|
|
dragPoint = value;
|
|
}
|
|
|
|
core::Point GetmouseDown()
|
|
{
|
|
return mouseDown;
|
|
}
|
|
void SetmouseDown(const core::Point &value)
|
|
{
|
|
mouseDown = value;
|
|
}
|
|
|
|
core::Point GetmouseCurrent()
|
|
{
|
|
return mouseCurrent;
|
|
}
|
|
void SetmouseCurrent(const core::Point &value)
|
|
{
|
|
mouseCurrent = value;
|
|
}
|
|
|
|
core::Point GetmouseLastZoom()
|
|
{
|
|
return mouseLastZoom;
|
|
}
|
|
void SetmouseLastZoom(const core::Point &value)
|
|
{
|
|
mouseLastZoom = value;
|
|
}
|
|
|
|
MouseWheelZoomType::Types GetMouseWheelZoomType()
|
|
{
|
|
return mousewheelzoomtype;
|
|
}
|
|
void SetMouseWheelZoomType(const MouseWheelZoomType::Types &value)
|
|
{
|
|
mousewheelzoomtype = value;
|
|
}
|
|
|
|
PointLatLng GetLastLocationInBounds()
|
|
{
|
|
return LastLocationInBounds;
|
|
}
|
|
void SetLastLocationInBounds(const PointLatLng &value)
|
|
{
|
|
LastLocationInBounds = value;
|
|
}
|
|
|
|
Size GetsizeOfMapArea()
|
|
{
|
|
return sizeOfMapArea;
|
|
}
|
|
void SetsizeOfMapArea(const Size &value)
|
|
{
|
|
sizeOfMapArea = value;
|
|
}
|
|
|
|
Size GetminOfTiles()
|
|
{
|
|
return minOfTiles;
|
|
}
|
|
void SetminOfTiles(const Size &value)
|
|
{
|
|
minOfTiles = value;
|
|
}
|
|
|
|
Size GetmaxOfTiles()
|
|
{
|
|
return maxOfTiles;
|
|
}
|
|
void SetmaxOfTiles(const Size &value)
|
|
{
|
|
maxOfTiles = value;
|
|
}
|
|
|
|
Rectangle GettileRect()
|
|
{
|
|
return tileRect;
|
|
}
|
|
void SettileRect(const Rectangle &value)
|
|
{
|
|
tileRect = value;
|
|
}
|
|
|
|
core::Point GettilePoint()
|
|
{
|
|
return tilePoint;
|
|
}
|
|
void SettilePoint(const core::Point &value)
|
|
{
|
|
tilePoint = value;
|
|
}
|
|
|
|
Rectangle GetCurrentRegion()
|
|
{
|
|
return CurrentRegion;
|
|
}
|
|
void SetCurrentRegion(const Rectangle &value)
|
|
{
|
|
CurrentRegion = value;
|
|
}
|
|
|
|
QList<core::Point> tileDrawingList;
|
|
|
|
PureProjection *Projection()
|
|
{
|
|
return projection;
|
|
}
|
|
void SetProjection(PureProjection *value)
|
|
{
|
|
projection = value;
|
|
tileRect = Rectangle(core::Point(0, 0), value->TileSize());
|
|
}
|
|
bool IsDragging() const
|
|
{
|
|
return isDragging;
|
|
}
|
|
|
|
int Zoom() const
|
|
{
|
|
return zoom;
|
|
}
|
|
void SetZoom(int const & value);
|
|
|
|
int MaxZoom() const
|
|
{
|
|
return maxzoom;
|
|
}
|
|
|
|
void UpdateBounds();
|
|
|
|
MapType::Types GetMapType()
|
|
{
|
|
return mapType;
|
|
}
|
|
void SetMapType(MapType::Types const & value);
|
|
|
|
void StartSystem();
|
|
|
|
void UpdateCenterTileXYLocation();
|
|
|
|
void OnMapSizeChanged(int const & width, int const & height); // TODO had as slot
|
|
|
|
void OnMapClose(); // TODO had as slot
|
|
|
|
GeoCoderStatusCode::Types SetCurrentPositionByKeywords(QString const & keys);
|
|
|
|
RectLatLng CurrentViewArea();
|
|
|
|
PointLatLng FromLocalToLatLng(int const & x, int const & y);
|
|
|
|
Point FromLatLngToLocal(PointLatLng const & latlng);
|
|
|
|
int GetMaxZoomToFitRect(RectLatLng const & rect);
|
|
|
|
void BeginDrag(core::Point const & pt);
|
|
|
|
void EndDrag();
|
|
|
|
void ReloadMap();
|
|
|
|
void GoToCurrentPosition();
|
|
|
|
bool MouseWheelZooming;
|
|
|
|
void DragOffset(core::Point const & offset);
|
|
|
|
void Drag(core::Point const & pt);
|
|
|
|
void CancelAsyncTasks();
|
|
|
|
void FindTilesAround(QList<core::Point> &list);
|
|
|
|
void UpdateGroundResolution();
|
|
|
|
TileMatrix Matrix;
|
|
|
|
bool isStarted()
|
|
{
|
|
return started;
|
|
}
|
|
|
|
diagnostics GetDiagnostics();
|
|
|
|
signals:
|
|
void OnCurrentPositionChanged(internals::PointLatLng point);
|
|
void OnTileLoadComplete();
|
|
void OnTilesStillToLoad(int number);
|
|
void OnTileLoadStart();
|
|
void OnMapDrag();
|
|
void OnMapZoomChanged();
|
|
void OnMapTypeChanged(MapType::Types type);
|
|
void OnEmptyTileError(int zoom, core::Point pos);
|
|
void OnNeedInvalidation();
|
|
|
|
private:
|
|
|
|
void keepInBounds();
|
|
PointLatLng currentPosition;
|
|
core::Point currentPositionPixel;
|
|
core::Point renderOffset;
|
|
core::Point centerTileXYLocation;
|
|
core::Point centerTileXYLocationLast;
|
|
core::Point dragPoint;
|
|
Rectangle tileRect;
|
|
core::Point mouseDown;
|
|
bool CanDragMap;
|
|
core::Point mouseCurrent;
|
|
PointLatLng LastLocationInBounds;
|
|
core::Point mouseLastZoom;
|
|
|
|
MouseWheelZoomType::Types mousewheelzoomtype;
|
|
|
|
|
|
Size sizeOfMapArea;
|
|
Size minOfTiles;
|
|
Size maxOfTiles;
|
|
|
|
core::Point tilePoint;
|
|
|
|
Rectangle CurrentRegion;
|
|
|
|
QQueue<LoadTask> tileLoadQueue;
|
|
|
|
int zoom;
|
|
|
|
PureProjection *projection;
|
|
|
|
bool isDragging;
|
|
|
|
QMutex MtileLoadQueue;
|
|
|
|
QMutex Moverlays;
|
|
|
|
QMutex MtileDrawingList;
|
|
#ifdef DEBUG_CORE
|
|
QMutex Mdebug;
|
|
static qlonglong debugcounter;
|
|
#endif
|
|
Size TooltipTextPadding;
|
|
|
|
MapType::Types mapType;
|
|
|
|
QSemaphore loaderLimit;
|
|
|
|
QThreadPool ProcessLoadTaskCallback;
|
|
QMutex MtileToload;
|
|
int tilesToload;
|
|
|
|
int maxzoom;
|
|
QMutex MrunningThreads;
|
|
int runningThreads;
|
|
diagnostics diag;
|
|
|
|
protected:
|
|
bool started;
|
|
|
|
int Width;
|
|
int Height;
|
|
int pxRes100m; // 100 meters
|
|
int pxRes1000m; // 1km
|
|
int pxRes10km; // 10km
|
|
int pxRes100km; // 100km
|
|
int pxRes1000km; // 1000km
|
|
int pxRes5000km; // 5000km
|
|
void SetCurrentPositionGPixel(core::Point const & value)
|
|
{
|
|
currentPositionPixel = value;
|
|
}
|
|
void GoToCurrentPositionOnZoom();
|
|
};
|
|
}
|
|
#endif // CORE_H
|