navitProxy.h

Go to the documentation of this file.

#ifndef NAVIT_GUI_QML_NAVIT_H
#define NAVIT_GUI_QML_NAVIT_H
 
void __setNewPoint(struct gui_priv *this_, struct coord *c, NGQPointTypes type);
 
class NGQProxyNavit : public NGQProxy {
    Q_OBJECT;
 
  public:
    NGQProxyNavit(struct gui_priv *object, QObject *parent) : NGQProxy(object, parent) {};
 
  public slots:
    void quit() {
        struct attr navit;
        navit.type = attr_navit;
        navit.u.navit = this->object->nav;
        navit_destroy(navit.u.navit);
        event_main_loop_quit();
    }
    void setObjectByName(const QString &attr_name, const QString &attr_value) {
        if (attr_name == "layout") {
            navit_set_layout_by_name(this->object->nav, attr_value.toStdString().c_str());
        }
        if (attr_name == "vehicle") {
            navit_set_vehicle_by_name(this->object->nav, attr_value.toStdString().c_str());
        }
        return;
    }
    QString getAttrList(const QString &attr_name) {
        struct attr attr;
        struct attr_iter *iter;
        int counter = 0;
        QString currentValue;
        QDomDocument retDoc;
        QDomElement entries;
 
        entries = retDoc.createElement("attributes");
        retDoc.appendChild(entries);
 
        // Find current value
        getAttrFunc(attr_from_name(attr_name.toStdString().c_str()), &attr, NULL);
        if (attr.type == attr_layout) {
            currentValue = attr.u.layout->name;
        }
 
        // Fill da list
        iter = getIterFunc();
        if (iter == NULL) {
            return QString();
        }
 
        while (getAttrFunc(attr_from_name(attr_name.toStdString().c_str()), &attr, iter)) {
            QStandardItem *curItem = new QStandardItem();
            // Listed attributes are usualy have very complex structure
            if (attr.type == attr_layout) {
                curItem->setData(QVariant(counter), NGQStandardItemModel::ItemId);
                curItem->setData(QVariant(attr.u.layout->name), NGQStandardItemModel::ItemName);
                curItem->setData(QVariant(attr.u.layout->name), NGQStandardItemModel::ItemValue);
                if (currentValue == attr.u.layout->name) {
                    this->_itemId = counter;
                }
            }
            if (attr.type == attr_vehicle) {
                QStandardItem *curItem = new QStandardItem();
                QDomElement entry = retDoc.createElement("vehicle");
                entries.appendChild(entry);
 
                this->object->currVehicle = attr.u.vehicle;
                curItem->setData(QVariant(this->object->vehicleProxy->getAttr("name")), NGQStandardItemModel::ItemName);
                entry.appendChild(this->_fieldValueHelper(retDoc, QString("id"), QString::number(counter)));
                entry.appendChild(this->_fieldValueHelper(retDoc, QString("name"),
                                                          QString(this->object->vehicleProxy->getAttr("name"))));
 
                // Detecting current vehicle
                struct attr vehicle_attr;
                navit_get_attr(this->object->nav, attr_vehicle, &vehicle_attr, NULL);
                if (vehicle_attr.u.vehicle == attr.u.vehicle) {
                    this->_itemId = counter;
                }
            }
            counter++;
        }
 
        dropIterFunc(iter);
 
        dbg(lvl_debug, QString::number(_itemId).toStdString().c_str(), NULL);
 
        return retDoc.toString();
    }
    QString getDestination() {
        struct attr attr;
        struct coord c;
 
        if (getAttrFunc(attr_destination, &attr, NULL)) {
            c.x = attr.u.pcoord->x;
            c.y = attr.u.pcoord->y;
            __setNewPoint(this->object, &c, Destination);
            return this->object->currentPoint->pointName();
        }
        return QString();
    }
    void setDestination() {
        navit_set_destination(this->object->nav, this->object->currentPoint->pc(),
                              this->object->currentPoint->coordString().toStdString().c_str(), 1);
    }
    void stopNavigation() {
        navit_set_destination(this->object->nav, NULL, NULL, 0);
    }
    QString getPosition() {
        struct attr attr;
        struct pcoord pc;
        struct coord c;
        struct transformation *trans;
 
        trans = navit_get_trans(this->object->nav);
 
        getAttrFunc(attr_vehicle, &attr, NULL);
        this->object->currVehicle = attr.u.vehicle;
 
        if (vehicle_get_attr(this->object->currVehicle, attr_position_coord_geo, &attr, NULL)) {
            pc.pro = transform_get_projection(trans);
            transform_from_geo(pc.pro, attr.u.coord_geo, &c);
            __setNewPoint(this->object, &c, Position);
            return this->object->currentPoint->pointName();
        }
        return QString();
    }
    void setPosition() {
        navit_set_position(this->object->nav, this->object->currentPoint->pc());
    }
    void setCenter() {
        navit_set_center(this->object->nav, this->object->currentPoint->pc(), 1);
    }
    void command(QString command) {
        struct attr navit;
        navit.type = attr_navit;
        navit.u.navit = this->object->nav;
        command_evaluate(&navit, command.toLocal8Bit().constData());
    }
 
  protected:
    int getAttrFunc(enum attr_type type, struct attr *attr, struct attr_iter *iter) {
        return navit_get_attr(this->object->nav, type, attr, iter);
    }
    int setAttrFunc(struct attr *attr) {
        return navit_set_attr(this->object->nav, attr);
    }
    struct attr_iter *getIterFunc() {
        return navit_attr_iter_new(NULL);
    };
    void dropIterFunc(struct attr_iter *iter) {
        navit_attr_iter_destroy(iter);
    };
 
  private:
};
 
#include "navitProxy.moc"
 
#endif /* NAVIT_GUI_QML_NAVITPROXY_H */