modelmapproxy.cpp

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/>
 */

#include "modelmapproxy.h"
#include "../pathplanner/waypointdialog.h"

ModelMapProxy::ModelMapProxy(QObject *parent, TLMapWidget *map, FlightDataModel *model,
                             QItemSelectionModel *selectionModel)
    : QObject(parent)
    , myMap(map)
    , model(model)
    , selection(selectionModel)
{
    connect(model, &QAbstractItemModel::rowsInserted, this, &ModelMapProxy::rowsInserted);
    connect(model, &QAbstractItemModel::rowsRemoved, this, &ModelMapProxy::rowsRemoved);
    connect(selection, &QItemSelectionModel::currentRowChanged, this,
            &ModelMapProxy::currentRowChanged);
    connect(model, &QAbstractItemModel::dataChanged, this, &ModelMapProxy::dataChanged);
    connect(myMap, &mapcontrol::TLMapWidget::selectedWPChanged, this,
            &ModelMapProxy::selectedWPChanged);
    connect(myMap, &mapcontrol::TLMapWidget::WPManualCoordChange, this,
            &ModelMapProxy::WPValuesChanged);
}

void ModelMapProxy::WPValuesChanged(WayPointItem *wp)
{
    QModelIndex index;
    index = model->index(wp->Number(), FlightDataModel::LATPOSITION);
    if (!index.isValid())
        return;
    model->setData(index, wp->Coord().Lat(), Qt::EditRole);
    index = model->index(wp->Number(), FlightDataModel::LNGPOSITION);
    model->setData(index, wp->Coord().Lng(), Qt::EditRole);

    index = model->index(wp->Number(), FlightDataModel::ALTITUDE);
    model->setData(index, wp->Altitude(), Qt::EditRole);
}

void ModelMapProxy::currentRowChanged(QModelIndex current, QModelIndex previous)
{
    Q_UNUSED(previous);

    QList<WayPointItem *> list;
    WayPointItem *wp = findWayPointNumber(current.row());
    if (!wp)
        return;
    list.append(wp);
    myMap->setSelectedWP(list);
}

void ModelMapProxy::selectedWPChanged(QList<WayPointItem *> list)
{
    selection->clearSelection();
    foreach (WayPointItem *wp, list) {
        QModelIndex index = model->index(wp->Number(), 0);
        selection->setCurrentIndex(index, QItemSelectionModel::Select | QItemSelectionModel::Rows);
    }
}

ModelMapProxy::overlayType ModelMapProxy::overlayTranslate(int type)
{
    switch (type) {
    case Waypoint::MODE_ENDPOINT:
    case Waypoint::MODE_VECTOR:
        return OVERLAY_LINE;
        break;
    case Waypoint::MODE_CIRCLERIGHT:
        return OVERLAY_CURVE_RIGHT;
        break;
    case Waypoint::MODE_CIRCLELEFT:
        return OVERLAY_CURVE_LEFT;
        break;
    default:
        break;
    }

    // Default value
    return OVERLAY_LINE;
}

void ModelMapProxy::createOverlay(WayPointItem *from, WayPointItem *to,
                                  ModelMapProxy::overlayType type, QColor color, double radius = 0)
{
    if (from == NULL || to == NULL || from == to)
        return;
    switch (type) {
    case OVERLAY_LINE:
        myMap->WPLineCreate(from, to, color);
        break;
    case OVERLAY_CIRCLE_RIGHT:
        myMap->WPCircleCreate(to, from, true, color);
        break;
    case OVERLAY_CIRCLE_LEFT:
        myMap->WPCircleCreate(to, from, false, color);
        break;
    case OVERLAY_CURVE_RIGHT:
        myMap->WPCurveCreate(to, from, radius, true, color);
        break;
    case OVERLAY_CURVE_LEFT:
        myMap->WPCurveCreate(to, from, radius, false, color);
        break;
    default:
        break;
    }
}

void ModelMapProxy::createOverlay(WayPointItem *from, HomeItem *to, ModelMapProxy::overlayType type,
                                  QColor color)
{
    if (from == NULL || to == NULL)
        return;
    switch (type) {
    case OVERLAY_LINE:
        myMap->WPLineCreate(to, from, color);
        break;
    case OVERLAY_CIRCLE_RIGHT:
        myMap->WPCircleCreate(to, from, true, color);
        break;
    case OVERLAY_CIRCLE_LEFT:
        myMap->WPCircleCreate(to, from, false, color);
        break;
    default:
        break;
    }
}

void ModelMapProxy::refreshOverlays()
{
    myMap->deleteAllOverlays();
    if (model->rowCount() < 1)
        return;
    WayPointItem *wp_current = NULL;
    WayPointItem *wp_next = NULL;
    overlayType wp_next_overlay;

    // Get first waypoint type before stepping through path
    wp_current = findWayPointNumber(0);
    overlayType wp_current_overlay =
        overlayTranslate(model->data(model->index(0, FlightDataModel::MODE), Qt::UserRole).toInt());
    createOverlay(wp_current, myMap->Home, wp_current_overlay, Qt::green);

    for (int x = 0; x < model->rowCount(); ++x) {
        wp_current = findWayPointNumber(x);

        wp_next_overlay = overlayTranslate(
            model->data(model->index(x + 1, FlightDataModel::MODE), Qt::UserRole).toInt());

        wp_next = findWayPointNumber(x + 1);
        createOverlay(wp_current, wp_next, wp_next_overlay, Qt::green,
                      model->data(model->index(x + 1, FlightDataModel::MODE_PARAMS)).toFloat());
    }
}

WayPointItem *ModelMapProxy::findWayPointNumber(int number)
{
    if (number < 0)
        return NULL;
    return myMap->WPFind(number);
}

void ModelMapProxy::rowsRemoved(const QModelIndex &parent, int first, int last)
{
    Q_UNUSED(parent);

    for (int x = last; x > first - 1; x--) {
        myMap->WPDelete(x);
    }
    refreshOverlays();
}

void ModelMapProxy::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
    Q_UNUSED(bottomRight);

    // Abort if no corresponding graphical item
    WayPointItem *item = findWayPointNumber(topLeft.row());
    if (!item)
        return;

    internals::PointLatLng latlng;
    double altitude;
    QModelIndex index;
    QString desc;

    for (int x = topLeft.row(); x <= bottomRight.row(); x++) {
        for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
            // Action depends on which columns were modified
            switch (column) {
            case FlightDataModel::MODE:
                refreshOverlays();
                break;
            case FlightDataModel::WPDESCRIPTION:
                index = model->index(x, FlightDataModel::WPDESCRIPTION);
                desc = index.data(Qt::DisplayRole).toString();
                item->SetDescription(desc);
                break;
            case FlightDataModel::LATPOSITION:
                latlng = item->Coord();
                index = model->index(x, FlightDataModel::LATPOSITION);
                latlng.SetLat(index.data(Qt::DisplayRole).toDouble());
                item->SetCoord(latlng);
                break;
            case FlightDataModel::LNGPOSITION:
                latlng = item->Coord();
                index = model->index(x, FlightDataModel::LNGPOSITION);
                latlng.SetLng(index.data(Qt::DisplayRole).toDouble());
                item->SetCoord(latlng);
                break;
            case FlightDataModel::ALTITUDE:
                index = model->index(x, FlightDataModel::ALTITUDE);
                altitude = index.data(Qt::DisplayRole).toDouble();
                item->SetAltitude(altitude);
                break;
            case FlightDataModel::MODE_PARAMS:
                // Make sure to update radius of arcs
                refreshOverlays();
                break;
            case FlightDataModel::LOCKED:
                index = model->index(x, FlightDataModel::LOCKED);
                item->setFlag(QGraphicsItem::ItemIsMovable, !index.data(Qt::DisplayRole).toBool());
                break;
            }
        }
    }
}

void ModelMapProxy::rowsInserted(const QModelIndex &parent, int first, int last)
{
    Q_UNUSED(parent);
    for (int x = first; x < last + 1; x++) {
        QModelIndex index;
        internals::PointLatLng latlng;
        double altitude;
        index = model->index(x, FlightDataModel::WPDESCRIPTION);
        QString desc = index.data(Qt::DisplayRole).toString();
        index = model->index(x, FlightDataModel::LATPOSITION);
        latlng.SetLat(index.data(Qt::DisplayRole).toDouble());
        index = model->index(x, FlightDataModel::LNGPOSITION);
        latlng.SetLng(index.data(Qt::DisplayRole).toDouble());
        index = model->index(x, FlightDataModel::ALTITUDE);
        altitude = index.data(Qt::DisplayRole).toDouble();
        myMap->WPInsert(latlng, altitude, desc, x);
    }
    refreshOverlays();
}

void ModelMapProxy::deleteWayPoint(int number)
{
    model->removeRow(number, QModelIndex());
}

void ModelMapProxy::createWayPoint(internals::PointLatLng coord)
{
    model->insertRow(model->rowCount(), QModelIndex());
    QModelIndex index =
        model->index(model->rowCount() - 1, FlightDataModel::LATPOSITION, QModelIndex());
    model->setData(index, coord.Lat(), Qt::EditRole);
    index = model->index(model->rowCount() - 1, FlightDataModel::LNGPOSITION, QModelIndex());
    model->setData(index, coord.Lng(), Qt::EditRole);
}

void ModelMapProxy::deleteAll()
{
    model->removeRows(0, model->rowCount(), QModelIndex());
}