ngqpoint.h

Go to the documentation of this file.

#ifndef NAVIT_GUI_QML_POINT_H
#define NAVIT_GUI_QML_POINT_H
 
static void
get_direction(char *buffer, int angle, int mode)
{
        angle=angle%360;
        switch (mode) {
        case 0:
                sprintf(buffer,"%d",angle);
                break;
        case 1:
                if (angle < 69 || angle > 291)
                        *buffer++='N';
                if (angle > 111 && angle < 249)
                        *buffer++='S';
                if (angle > 22 && angle < 158)
                        *buffer++='E';
                if (angle > 202 && angle < 338)
                        *buffer++='W';
                *buffer++='\0';
                break;
        case 2:
                angle=(angle+15)/30;
                if (! angle)
                        angle=12;
                sprintf(buffer,"%d H", angle);
                break;
        }
}
 
enum NGQPointTypes {MapPoint,Bookmark,Position,Destination,PointOfInterest};
 
class NGQPoint : public QObject {
        Q_OBJECT;
 
    Q_PROPERTY(QString coordString READ coordString CONSTANT);
    Q_PROPERTY(QString pointName READ pointName CONSTANT);
    Q_PROPERTY(QString pointType READ pointType CONSTANT);
    Q_PROPERTY(QUrl pointUrl READ pointUrl CONSTANT);
public:
    NGQPoint(struct gui_priv* this_,struct point* p,NGQPointTypes type=MapPoint,QObject *parent=NULL) : QObject(parent) {
        this->object=this_;
        this->item.map=0;
        transform_reverse(navit_get_trans(this->object->nav), p, &co);
        transform_to_geo(transform_get_projection(navit_get_trans(this->object->nav)), &co, &g);
        c.pro = transform_get_projection(navit_get_trans(this->object->nav));
        c.x = co.x;
        c.y = co.y;
        this->p.x=p->x;
        this->p.y=p->y;
        this->type=type;
 
        this->name=this->_coordName();
        this->coord=this->_coordString();
    }
    NGQPoint(struct gui_priv* this_,struct coord* c,NGQPointTypes type=Bookmark,QObject *parent=NULL) : QObject(parent) {
        this->object=this_;
        this->item.map=0;
        this->co.x=c->x;
        this->co.y=c->y;
        transform_to_geo(transform_get_projection(navit_get_trans(this->object->nav)), &co, &g);
        this->c.pro = transform_get_projection(navit_get_trans(this->object->nav));
        this->c.x = c->x;
        this->c.y = c->y;
        this->type=type;
 
        this->name=this->_coordName();
        this->coord=this->_coordString();
    }
 
    NGQPoint(struct gui_priv* this_,struct pcoord* pc,NGQPointTypes type=Bookmark,QObject *parent=NULL) : QObject(parent) {
        this->object=this_;
        this->item.map=0;
        this->c.pro = pc->pro;
        this->c.x = pc->x;
        this->c.y = pc->y;
        this->co.x=pc->x;
        this->co.y=pc->y;
        transform_to_geo(this->c.pro, &co, &g);
        this->type=type;
 
        this->name=this->_coordName();
        this->coord=this->_coordString();
    }
 
    NGQPoint(struct gui_priv* this_,struct coord* c,QString name,NGQPointTypes type=Bookmark,QObject *parent=NULL) : QObject(parent) {
        this->object=this_;
        this->item.map=0;
        this->co.x=c->x;
        this->co.y=c->y;
        transform_to_geo(transform_get_projection(navit_get_trans(this->object->nav)), &co, &g);
        this->c.pro = transform_get_projection(navit_get_trans(this->object->nav));
        this->c.x = c->x;
        this->c.y = c->y;
        this->type=type;
 
        this->name=name;
        this->coord=this->_coordString();
    }
 
    struct pcoord* pc() { return &c; }
public slots:
    void setNewPoint(QString coord,NGQPointTypes type=PointOfInterest) {
            this->item.map=0;
            QStringList coordSplit=coord.split(" ",QString::SkipEmptyParts);
            this->co.x=coordSplit[0].toInt();
            this->co.y=coordSplit[1].toInt();
            transform_to_geo(transform_get_projection(navit_get_trans(this->object->nav)), &co, &g);
            this->c.pro = transform_get_projection(navit_get_trans(this->object->nav));
            this->c.x = coordSplit[0].toInt();
            this->c.y = coordSplit[1].toInt();
            this->type=type;
 
            this->name=this->_coordName();
            this->coord=this->_coordString();
    }
    QString pointName() {
            return this->name;
    }
    QString coordString() {
            return this->coord;
    }
    QString pointType() {
            switch(this->type) {
            case MapPoint:
                    return QString("MapPoint");
            case Bookmark:
                    return QString("Bookmark");
            case Position:
                    return QString("Position");
            case Destination:
                    return QString("Destination");
            case PointOfInterest:
                    return QString("PointOfInterest");
            }
            return QString("");
    }
    QUrl pointUrl() {
            return this->url;
    }
    QString getInformation() {
            struct map_rect *mr;
            struct item* item;
            struct attr attr;
 
            QDomDocument retDoc;
            QDomElement entries;
            entries=retDoc.createElement("point");
            retDoc.appendChild(entries);
 
            if (this->type!=Bookmark and this->item.map) {
                    mr=map_rect_new(this->item.map, NULL);
                    item = map_rect_get_item_byid(mr, this->item.id_hi, this->item.id_lo);
                    if (item) {
                            while(item_attr_get(item, attr_any, &attr)) {
                                     entries.appendChild(this->_fieldValueHelper(retDoc,QString::fromLocal8Bit(attr_to_name(attr.type)), QString::fromLocal8Bit(attr_to_text(&attr,this->item.map, 1))));
                            }
                    }
                    map_rect_destroy(mr);
            }
            return retDoc.toString();
    }
    QString getPOI(const QString &attr_name) {
            struct attr attr;
            struct item* item;
            struct mapset_handle *h;
            struct map_selection *sel,*selm;
            struct map_rect *mr;
            struct map *m;
            int idist,dist;
            struct coord center;
            QDomDocument retDoc(attr_name);
            QDomElement entries;
            char dirbuf[32];
 
            if (!gui_get_attr(this->object->gui,attr_radius,&attr,NULL)) {
                    return QString();
            }
 
            dist=attr.u.num*1000;
 
            sel=map_selection_rect_new(&this->c, dist, 18);
            center.x=this->c.x;
            center.y=this->c.y;
            h=mapset_open(navit_get_mapset(this->object->nav));
 
            entries=retDoc.createElement(attr_name);
            retDoc.appendChild(entries);
 
            while ((m=mapset_next(h, 1))) {
                    selm=map_selection_dup_pro(sel, this->c.pro, map_projection(m));
                    mr=map_rect_new(m, selm);
                    if (mr) {
                            while ((item=map_rect_get_item(mr))) {
                                    struct coord c;
                                    if ( item_coord_get_pro(item, &c, 1, this->c.pro) && coord_rect_contains(&sel->u.c_rect, &c) && (idist=transform_distance(this->c.pro, &center, &c)) < dist && item->type<type_line) {
                                            char* label;
                                            QString rs;
                                            if (item_attr_get(item, attr_label, &attr)) {
                                                    label=map_convert_string(m, attr.u.str);
                                                     if (QString(item_to_name(item->type)).startsWith(QString("poi_"))) {
                                                             rs=QString::fromLocal8Bit(item_to_name(item->type));
                                                             rs=rs.remove(QString("poi_"));
                                                             rs+=QString(" ")+QString::fromLocal8Bit(label);
 
                                                     } else if (QString(item_to_name(item->type)).startsWith(QString("poly_"))) {
                                                             rs=QString::fromLocal8Bit(item_to_name(item->type));
                                                             rs=rs.remove(QString("poly_"));
                                                             rs+=QString(" ")+QString::fromLocal8Bit(label);
 
                                                     } else if (QString(item_to_name(item->type)).startsWith(QString("street_"))) {
                                                             rs="Street ";
                                                             rs+=QString::fromLocal8Bit(label);
                                                     }
                                                     map_convert_free(label);
                                            } else
                                                    rs=item_to_name(item->type);
                                            get_direction(dirbuf, transform_get_angle_delta(&center, &c, 0), 1);
                                            if (rs.length()>0) {
                                                    QDomElement entry=retDoc.createElement("point");
                                                    QDomElement nameTag=retDoc.createElement("name");
                                                    QDomElement typeTag=retDoc.createElement("type");
                                                    QDomElement distTag=retDoc.createElement("distance");
                                                    QDomElement directTag=retDoc.createElement("direction");
                                                    QDomElement coordsTag=retDoc.createElement("coords");
                                                    QDomText nameT=retDoc.createTextNode(rs);
                                                    QDomText typeT=retDoc.createTextNode(QString(item_to_name(item->type)));
                                                    QDomText distT=retDoc.createTextNode(QString::number(idist/1000));
                                                    QDomText directT=retDoc.createTextNode(dirbuf);
                                                    QDomText coordsT=retDoc.createTextNode(QString("%1 %2").arg(c.x).arg(c.y));
                                                    nameTag.appendChild(nameT);
                                                    typeTag.appendChild(typeT);
                                                    distTag.appendChild(distT);
                                                    directTag.appendChild(directT);
                                                    coordsTag.appendChild(coordsT);
                                                    entry.appendChild(nameTag);
                                                    entry.appendChild(typeTag);
                                                    entry.appendChild(distTag);
                                                    entry.appendChild(directTag);
                                                    entry.appendChild(coordsTag);
                                                    entries.appendChild(entry);
                                            }
                                    }
                            }
                    }
                    map_selection_destroy(selm);
            }
            map_selection_destroy(sel);
            mapset_close(h);
            dbg(lvl_info,"%s",retDoc.toString().toLocal8Bit().constData());
            return retDoc.toString();
    }
protected:
        QDomElement _fieldValueHelper(QDomDocument doc, QString field,QString value) {
                QDomElement fieldTag=doc.createElement(field);
                QDomText valueText=doc.createTextNode(value);
                fieldTag.appendChild(valueText);
                return fieldTag;
        }
        QString _coordString() {
                char latc='N',lngc='E';
                int lat_deg,lat_min,lat_sec;
                int lng_deg,lng_min,lng_sec;
                struct coord_geo g=this->g;
 
                if (g.lat < 0) {
                        g.lat=-g.lat;
                        latc='S';
                }
                if (g.lng < 0) {
                        g.lng=-g.lng;
                        lngc='W';
                }
                lat_deg=g.lat;
                lat_min=fmod(g.lat*60,60);
                lat_sec=fmod(g.lat*3600,60);
                lng_deg=g.lng;
                lng_min=fmod(g.lng*60,60);
                lng_sec=fmod(g.lng*3600,60);
                return QString(QString::fromLocal8Bit("%1°%2'%3\" %4%5%6°%7'%8\" %9")).arg(lat_deg).arg(lat_min).arg(lat_sec).arg(latc).arg(' ').arg(lng_deg).arg(lng_min).arg(lng_sec).arg(lngc);
        }
        QString _coordName() {
                int dist=10;
                struct mapset *ms;
                struct mapset_handle *h;
                struct map_rect *mr;
                struct map *m;
                struct item *item;
                struct street_data *data;
                struct map_selection sel;
                struct transformation *trans;
                enum projection pro;
                struct attr attr;
                char *label;
                QString ret;
 
                trans=navit_get_trans(this->object->nav);
                pro=transform_get_projection(trans);
                transform_from_geo(pro, &g, &co);
                ms=navit_get_mapset(this->object->nav);
                sel.next=NULL;
                sel.u.c_rect.lu.x=c.x-dist;
                sel.u.c_rect.lu.y=c.y+dist;
                sel.u.c_rect.rl.x=c.x+dist;
                sel.u.c_rect.rl.y=c.y-dist;
                sel.order=18;
                sel.range=item_range_all;
                h=mapset_open(ms);
                while ((m=mapset_next(h,1))) {
                        mr=map_rect_new(m, &sel);
                        if (! mr)
                                continue;
                        while ((item=map_rect_get_item(mr))) {
                                data=street_get_data(item);
                                if (transform_within_dist_item(&co, item->type, data->c, data->count, dist)) {
                                        if (item_attr_get(item, attr_label, &attr)) {
                                                label=map_convert_string(m, attr.u.str);
                                                this->item=*item;
                                                this->_setUrl(item);
                                                 if (QString(item_to_name(item->type)).startsWith(QString("poi_"))) {
                                                         ret=QString::fromLocal8Bit(item_to_name(item->type));
                                                         ret=ret.remove(QString("poi_"));
                                                         ret+=QString(" ")+QString::fromLocal8Bit(label);
                                                 }
                                                 if (QString(item_to_name(item->type)).startsWith(QString("poly_"))) {
                                                         ret=QString::fromLocal8Bit(item_to_name(item->type));
                                                         ret=ret.remove(QString("poly_"));
                                                         ret+=QString(" ")+QString::fromLocal8Bit(label);
                                                 }
                                                 if (QString(item_to_name(item->type)).startsWith(QString("street_"))) {
                                                         ret="Street ";
                                                         ret+=QString::fromLocal8Bit(label);
                                                 }
                                                 map_convert_free(label);
                                                 street_data_free(data);
                                                 map_rect_destroy(mr);
                                                 mapset_close(h);
                                                 return ret;
                                        } else
                                                this->item=*item;
                                                this->_setUrl(item);
                                                ret=item_to_name(item->type);
                                }
                                street_data_free(data);
                        }
                        map_rect_destroy(mr);
                }
                mapset_close(h);
                return ret;
        }
        void _setUrl(struct item *item) {
                struct attr attr;
                if (item_attr_get(item,attr_osm_nodeid,&attr)) {
                        url.setUrl(QString("http://www.openstreetmap.org/browse/node/%1").arg(*attr.u.num64));
                } else if (item_attr_get(item,attr_osm_wayid,&attr)) {
                        url.setUrl(QString("http://www.openstreetmap.org/browse/way/%1").arg(*attr.u.num64));
                } else if (item_attr_get(item,attr_osm_relationid,&attr)) {
                        url.setUrl(QString("http://www.openstreetmap.org/browse/relation/%1").arg(*attr.u.num64));
                } else {
                        url.clear();
                }
        }
private:
    struct gui_priv* object;
 
    NGQPointTypes type;
    struct coord_geo g;
    struct coord co;
    struct pcoord c;
    struct point p;
 
    struct item item;
 
    QString name;
    QString coord;
    QUrl url;
};
 
#include "ngqpoint.moc"
 
#endif /* NAVIT_GUI_QML_POINT_H */