searchProxy.h

Go to the documentation of this file.

#ifndef NAVIT_GUI_QML_SEARCHPROXY_H
#define NAVIT_GUI_QML_SEARCHPROXY_H
 
void __setNewPoint(struct gui_priv *this_, struct pcoord *pc, NGQPointTypes type);
 
class NGQProxySearch : public NGQProxy {
    Q_OBJECT;
 
    Q_PROPERTY(QString countryName READ countryName WRITE setCountryName NOTIFY countryNameSignal);
    Q_PROPERTY(QString countryISO2 READ countryISO2 WRITE setCountryISO2 NOTIFY countryISO2Signal);
    Q_PROPERTY(QString townName READ townName WRITE setTownName NOTIFY townNameSignal);
    Q_PROPERTY(QString streetName READ streetName WRITE setStreetName NOTIFY streetNameSignal);
 
    Q_PROPERTY(QString searchContext READ searchContext WRITE setSearchContext);
 
  public:
    NGQProxySearch(struct gui_priv *this_, QObject *parent) : NGQProxy(this_, parent) {
        struct attr search_attr, country_name, country_iso2, *country_attr;
        struct item *item;
        struct country_search *cs;
        struct tracking *tracking;
        struct search_list_result *res;
 
        this->sl = search_list_new(navit_get_mapset(this->object->nav));
        this->search_context = "country";
 
        country_attr = country_default();
        tracking = navit_get_tracking(this->object->nav);
        if (tracking && tracking_get_attr(tracking, attr_country_id, &search_attr, NULL))
            country_attr = &search_attr;
        if (country_attr) {
            cs = country_search_new(country_attr, 0);
            item = country_search_get_item(cs);
            if (item && item_attr_get(item, attr_country_name, &country_name)) {
                search_attr.type = attr_country_all;
                dbg(lvl_debug, "country %s", country_name.u.str);
                this->country_name = QString::fromLocal8Bit(country_name.u.str);
                search_attr.u.str = country_name.u.str;
                search_list_search(this->sl, &search_attr, 0);
                while ((res = search_list_get_result(this->sl)))
                    ;
                if (item_attr_get(item, attr_country_iso2, &country_iso2)) {
                    this->country_iso2 = QString::fromLocal8Bit(country_iso2.u.str);
                }
            }
            country_search_destroy(cs);
        } else {
            dbg(lvl_error, "warning: no default country found");
            if (!this->country_iso2.isEmpty()) {
                dbg(lvl_debug, "attempting to use country '%s'", this->country_iso2.toStdString().c_str());
                search_attr.type = attr_country_iso2;
                search_attr.u.str = (char *)this->country_iso2.toStdString().c_str();
                search_list_search(this->sl, &search_attr, 0);
                while ((res = search_list_get_result(this->sl)))
                    ;
            }
        }
    }
    ~NGQProxySearch() {
        search_list_destroy(this->sl);
    }
 
  signals:
    void countryNameSignal(QString);
    void countryISO2Signal(QString);
    void townNameSignal(QString);
    void streetNameSignal(QString);
 
  public slots:
    void setPointToResult() {
        struct attr attr;
        struct search_list_result *res;
 
        if (this->street_name.length() > 0) {
            attr.type = attr_street_name;
            attr.u.str = this->street_name.toLocal8Bit().data();
        } else if (this->town_name.length() > 0) {
            attr.type = attr_town_or_district_name;
            attr.u.str = this->town_name.toLocal8Bit().data();
        } else if (this->country_name.length() > 0) {
            attr.type = attr_country_name;
            attr.u.str = this->country_name.toLocal8Bit().data();
        }
        search_list_search(this->sl, &attr, 0);
        if ((res = search_list_get_result(this->sl))) {
            __setNewPoint(this->object, res->c, PointOfInterest);
        }
        return;
    }
    QString searchXml() {
        NGQStandardItemModel *ret = new NGQStandardItemModel(this);
        struct attr attr;
        struct search_list_result *res;
        int counter = 0;
        QDomDocument retDoc;
        QDomElement entries;
 
        entries = retDoc.createElement("search");
        retDoc.appendChild(entries);
 
        if (this->search_context == "country") {
            attr.type = attr_country_name;
            attr.u.str = this->country_name.toLocal8Bit().data();
        }
        if (this->search_context == "town") {
            if (this->town_name.length() < 3) {
                return retDoc.toString();
            }
            attr.type = attr_town_or_district_name;
            attr.u.str = this->town_name.toLocal8Bit().data();
        }
        if (this->search_context == "street") {
            attr.type = attr_street_name;
            attr.u.str = this->street_name.toLocal8Bit().data();
        }
 
        search_list_search(this->sl, &attr, 1);
 
        while ((res = search_list_get_result(this->sl))) {
            QStandardItem *curItem = new QStandardItem();
            QDomElement entry = retDoc.createElement("item");
            entries.appendChild(entry);
            // Result processing depends on search type
            if (this->search_context == "country") {
                entry.appendChild(this->_fieldValueHelper(retDoc, QString("id"), QString::number(counter)));
                entry.appendChild(
                    this->_fieldValueHelper(retDoc, QString("name"), QString::fromLocal8Bit(res->country->name)));
                entry.appendChild(this->_fieldValueHelper(
                    retDoc, QString("icon"), QString("country_%1%2").arg(res->country->iso2).arg(".svgz")));
            }
            if (this->search_context == "town") {
                entry.appendChild(this->_fieldValueHelper(retDoc, QString("id"), QString::number(counter)));
                if (res->town->common.town_name) {
                    entry.appendChild(this->_fieldValueHelper(retDoc, QString("name"),
                                                              QString::fromLocal8Bit(res->town->common.town_name)));
                }
                if (res->town->common.district_name) {
                    entry.appendChild(this->_fieldValueHelper(retDoc, QString("name"),
                                                              QString::fromLocal8Bit(res->town->common.district_name)));
                }
            }
            if (this->search_context == "street") {
                entry.appendChild(this->_fieldValueHelper(retDoc, QString("id"), QString::number(counter)));
                entry.appendChild(
                    this->_fieldValueHelper(retDoc, QString("name"), QString::fromLocal8Bit(res->street->name)));
            }
            counter++;
            ret->appendRow(curItem);
        }
 
        return retDoc.toString();
    }
    QString countryName() {
        return this->country_name;
    }
    void setCountryName(QString countryName) {
        this->country_name = countryName;
        struct attr attr;
        struct search_list_result *res;
 
        // We need to update ISO2
        attr.type = attr_country_name;
        attr.u.str = countryName.toLocal8Bit().data();
        search_list_search(this->sl, &attr, 0);
        while ((res = search_list_get_result(this->sl))) {
            this->setCountryISO2(QString::fromLocal8Bit(res->country->iso2));
        }
        //...and current town
        this->town_name = "";
        this->street_name = "";
 
        countryNameSignal(countryName);
    }
    QString countryISO2() {
        return this->country_iso2;
    }
    void setCountryISO2(QString countryISO2) {
        this->country_iso2 = countryISO2;
        countryISO2Signal(countryISO2);
    }
    QString townName() {
        return this->town_name;
    }
    void setTownName(QString townName) {
        struct attr attr;
 
        this->town_name = townName;
 
        // Specialize search
        attr.type = attr_town_or_district_name;
        attr.u.str = townName.toLocal8Bit().data();
        search_list_search(this->sl, &attr, 0);
 
        //...and street
        this->street_name = "";
 
        townNameSignal(townName);
    }
    QString streetName() {
        return this->street_name;
    }
    void setStreetName(QString streetName) {
        struct attr attr;
 
        this->street_name = streetName;
 
        // Specialize search
        attr.type = attr_street_name;
        attr.u.str = streetName.toLocal8Bit().data();
        search_list_search(this->sl, &attr, 0);
 
        streetNameSignal(streetName);
    }
    QString searchContext() {
        return this->search_context;
    }
    void setSearchContext(QString searchContext) {
        this->search_context = searchContext;
    }
 
  protected:
    virtual int getAttrFunc(enum attr_type type, struct attr *attr, struct attr_iter *iter) {
        return 0;
    }
    virtual int setAttrFunc(struct attr *attr) {
        return 0;
    }
 
  private:
    struct search_list *sl;
    QString search_context;
    QString country_iso2, country_name, town_name, street_name;
};
 
#include "searchProxy.moc"
 
#endif /* NAVIT_GUI_QML_SEARCHPROXY_H */