tlmapwidget.h

Go to the documentation of this file.

/*
* 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, see <http://www.gnu.org/licenses/>
*/
#ifndef TLMAPWIDGET_H
#define TLMAPWIDGET_H

#include "../mapwidget/mapgraphicitem.h"
#include "../core/geodecoderstatus.h"
#include "../core/maptype.h"
#include "../core/languagetype.h"
#include "../core/diagnostics.h"
#include "configuration.h"
#include <QObject>
#include "waypointitem.h"
#include "QtSvg/QGraphicsSvgItem"
#include "uavitem.h"
#include "gpsitem.h"
#include "homeitem.h"
#include "mapripper.h"
#include "mapline.h"
#include "mapcircle.h"
#include "waypointcurve.h"
#include "waypointitem.h"
#include "../core/corecommon.h"
#include <QGraphicsView>

namespace mapcontrol
{
    class UAVItem;
    class GPSItem;
    class HomeItem;
    class Helper
    {
    public:
        static MapType::Types MapTypeFromString(QString const& value){return MapType::TypeByStr(value);}
        static QString StrFromMapType(MapType::Types const& value){return MapType::StrByType(value);}
        static QStringList MapTypes(){return MapType::TypesList();}

        static GeoCoderStatusCode::Types GeoCoderStatusCodeFromString(QString const& value){return GeoCoderStatusCode::TypeByStr(value);}
        static QString StrFromGeoCoderStatusCode(GeoCoderStatusCode::Types const& value){return GeoCoderStatusCode::StrByType(value);}
        static QStringList GeoCoderTypes(){return GeoCoderStatusCode::TypesList();}

        static internals::MouseWheelZoomType::Types MouseWheelZoomTypeFromString(QString const& value){return internals::MouseWheelZoomType::TypeByStr(value);}
        static QString StrFromMouseWheelZoomType(internals::MouseWheelZoomType::Types const& value){return internals::MouseWheelZoomType::StrByType(value);}
        static QStringList MouseWheelZoomTypes(){return internals::MouseWheelZoomType::TypesList();}
        static core::LanguageType::Types LanguageTypeFromString(QString const& value){return core::LanguageType::TypeByStr(value);}
        static QString StrFromLanguageType(core::LanguageType::Types const& value){return core::LanguageType::StrByType(value);}
        static QStringList LanguageTypes(){return core::LanguageType::TypesList();}
        static core::AccessMode::Types AccessModeFromString(QString const& value){return core::AccessMode::TypeByStr(value);}
        static QString StrFromAccessMode(core::AccessMode::Types const& value){return core::AccessMode::StrByType(value);}
        static QStringList AccessModeTypes(){return core::AccessMode::TypesList();}

        static UAVMapFollowType::Types UAVMapFollowFromString(QString const& value){return UAVMapFollowType::TypeByStr(value);}
        static QString StrFromUAVMapFollow(UAVMapFollowType::Types const& value){return UAVMapFollowType::StrByType(value);}
        static QStringList UAVMapFollowTypes(){return UAVMapFollowType::TypesList();}
        static UAVTrailType::Types UAVTrailTypeFromString(QString const& value){return UAVTrailType::TypeByStr(value);}
        static QString StrFromUAVTrailType(UAVTrailType::Types const& value){return UAVTrailType::StrByType(value);}
        static QStringList UAVTrailTypes(){return UAVTrailType::TypesList();}
    };

    class TLMAPWIDGET_EXPORT TLMapWidget:public QGraphicsView
    {
        Q_OBJECT

        Q_PROPERTY(int MinZoom READ MinZoom WRITE SetMinZoom)
        Q_PROPERTY(bool ShowTileGridLines READ ShowTileGridLines WRITE SetShowTileGridLines)
        Q_PROPERTY(double Zoom READ ZoomTotal WRITE SetZoom)
        Q_PROPERTY(qreal Rotate READ Rotate WRITE SetRotate)
        Q_ENUMS(internals::MouseWheelZoomType::Types)
        Q_ENUMS(core::GeoCoderStatusCode::Types)

    public:
                QSize sizeHint() const;
        TLMapWidget(QWidget *parent=nullptr,Configuration *config=new Configuration);
        ~TLMapWidget();
        bool ShowTileGridLines()const {return map->showTileGridLines;}

        void SetShowTileGridLines(bool const& value){map->showTileGridLines=value;map->update();}

        int MaxZoom()const{return map->MaxZoom();}

        //  void SetMaxZoom(int const& value){map->maxZoom = value;}

        int MinZoom()const{return map->minZoom;}
        void SetMinZoom(int const& value){map->minZoom = value;}

        internals::MouseWheelZoomType::Types GetMouseWheelZoomType(){return  map->core->GetMouseWheelZoomType();}
        void SetMouseWheelZoomType(internals::MouseWheelZoomType::Types const& value){map->core->SetMouseWheelZoomType(value);}
        //  void SetMouseWheelZoomTypeByStr(const QString &value){map->core->SetMouseWheelZoomType(internals::MouseWheelZoomType::TypeByStr(value));}
        //  QString GetMouseWheelZoomTypeStr(){return map->GetMouseWheelZoomTypeStr();}

        internals::RectLatLng SelectedArea()const{return  map->selectedArea;}
        void SetSelectedArea(internals::RectLatLng const& value){ map->selectedArea = value;this->update();}

        bool CanDragMap()const{return map->CanDragMap();}
        void SetCanDragMap(bool const& value){map->SetCanDragMap(value);}

        internals::PointLatLng CurrentPosition()const{return map->core->CurrentPosition();}
        void SetCurrentPosition(internals::PointLatLng const& value){map->core->SetCurrentPosition(value);}

        double ZoomReal(){return map->Zoom();}
        double ZoomDigi(){return map->ZoomDigi();}
        double ZoomTotal(){return map->ZoomTotal();}
        void SetZoom(double const& value){map->SetZoom(value);}

        qreal Rotate(){return map->rotation;}
        void SetRotate(qreal const& value);

        void ReloadMap(){map->ReloadMap(); map->resize();}

        GeoCoderStatusCode::Types SetCurrentPositionByKeywords(QString const& keys){return map->SetCurrentPositionByKeywords(keys);}

        MapType::Types GetMapType(){return map->core->GetMapType();}
        void SetMapType(MapType::Types const& value){map->lastimage=QImage(); map->core->SetMapType(value);}
        void SetUserImageHorizontalScale(double hScale){map->core->SetUserImageHorizontalScale(hScale);}
        void SetUserImageVerticalScale(double vScale){map->core->SetUserImageVerticalScale(vScale);}
        void SetUserImageLocation(QString location){map->core->SetUserImageLocation(location);}

        bool isStarted(){return map->core->isStarted();}

        Configuration* configuration;

        internals::PointLatLng currentMousePosition();

        void SetFollowMouse(bool const& value){followmouse=value;this->setMouseTracking(followmouse);}
        bool FollowMouse(){return followmouse;}

        internals::PointLatLng GetFromLocalToLatLng(QPointF p) {return map->FromLocalToLatLng(p.x(),p.y());}

        WayPointItem* WPCreate();
        void WPCreate(WayPointItem* item);
        WayPointItem* WPCreate(internals::PointLatLng const& coord,int const& altitude);
        WayPointItem* WPCreate(internals::PointLatLng const& coord,int const& altitude, QString const& description);
        WayPointItem *WPCreate(const distBearingAltitude &relativeCoord, const QString &description);
        WayPointItem* WPInsert(int const& position);
        void WPInsert(WayPointItem* item,int const& position);
        WayPointItem* WPInsert(internals::PointLatLng const& coord,int const& altitude,int const& position);
        WayPointItem* WPInsert(internals::PointLatLng const& coord,int const& altitude, QString const& description,int const& position);
        WayPointItem *WPInsert(const distBearingAltitude &relative, const QString &description, const int &position);

        void WPDelete(WayPointItem* item);
        void WPDeleteAll();
        QList<WayPointItem*> WPSelected();

        void WPRenumber(WayPointItem* item,int const& newnumber);

        void SetShowCompassRose(bool const& value);
        void SetShowWindCompass(bool const& value);

        void setOverlayOpacity(qreal value);

        UAVItem* UAV;
        GPSItem* GPS;
        HomeItem* Home;
        void SetShowUAV(bool const& value);
        bool ShowUAV()const{return showuav;}
        void SetShowHome(bool const& value);
        bool ShowHome()const{return showhome;}
        void SetShowDiagnostics(bool const& value);
        void SetUavPic(QString UAVPic);

        MapLine *WPLineCreate(WayPointItem *from,WayPointItem *to, QColor color);
        MapLine *WPLineCreate(HomeItem *from,WayPointItem *to, QColor color);
        WayPointCurve *WPCurveCreate(WayPointItem *start, WayPointItem *dest, double radius, bool clockwise, QColor color);
        MapCircle *WPCircleCreate(WayPointItem *center, WayPointItem *radius,bool clockwise,QColor color);
        MapCircle *WPCircleCreate(HomeItem *center, WayPointItem *radius,bool clockwise,QColor color);

        void deleteAllOverlays();
        void WPSetVisibleAll(bool value);
        WayPointItem *magicWPCreate();
        bool WPPresent();
        void WPDelete(int number);
        WayPointItem *WPFind(int number);
        void setSelectedWP(QList<WayPointItem *> list);

        void setWindVelocity(double windVelocity_NED[3]);
      private:
        internals::Core *core;
        MapGraphicItem *map;
        GeoCoderStatusCode x;
        MapType y;
        core::AccessMode xx;
        internals::PointLatLng currentmouseposition;
        bool followmouse;
        void ConnectWP(WayPointItem* item);
        QGraphicsSvgItem *compassRose;
        QGraphicsSvgItem *windCompass;
        bool showuav;
        bool showhome;
        QTimer * diagTimer;
        QGraphicsTextItem * diagGraphItem;
        bool showDiag;
        qreal overlayOpacity;

        QGraphicsTextItem *windspeedTxt;

    private slots:
        void diagRefresh();
        //   WayPointItem* item;//apagar
    protected:
        void resizeEvent(QResizeEvent *event);
        void showEvent ( QShowEvent * event );
        void closeEvent(QCloseEvent *event);
        void mouseMoveEvent ( QMouseEvent * event );
        //    private slots:
    signals:
        void zoomChanged(double zoomt,double zoom, double zoomd);
        void WPNumberChanged(int const& oldnumber,int const& newnumber,WayPointItem* waypoint);
        void WPValuesChanged(WayPointItem* waypoint);
        void WPReached(WayPointItem* waypoint);

        void WPCreated(int const& number,WayPointItem* waypoint);

        void WPInserted(int const& number,WayPointItem* waypoint);
        void WPDeleted(int const& number,WayPointItem* waypoint);

        void WPManualCoordChange(WayPointItem*);
        void UAVReachedWayPoint(int const& waypointnumber,WayPointItem* waypoint);
        void UAVLeftSafetyBouble(internals::PointLatLng const& position);

        void OnCurrentPositionChanged(internals::PointLatLng point);
        void OnTileLoadComplete();
        void OnTileLoadStart();
        void OnMapDrag();
        void OnMapZoomChanged();
        void OnMapTypeChanged(MapType::Types type);
        void OnEmptyTileError(int zoom, core::Point pos);
        void OnTilesStillToLoad(int number);
        void OnWayPointDoubleClicked(WayPointItem * waypoint);
        void selectedWPChanged(QList<WayPointItem*>);
    public slots:
        void RipMap();
        void OnSelectionChanged();

    };
}
#endif // TLMAPWIDGET_H