Subversion Repositories Projects

/*

*

* This file is part of QMapControl,

* an open-source cross-platform map widget

*

* Copyright (C) 2007 - 2008 Kai Winter

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with QMapControl. If not, see <http://www.gnu.org/licenses/>.

*

* Contact e-mail: kaiwinter@gmx.de

* Program URL   : http://qmapcontrol.sourceforge.net/

*

*/

#include "layer.h"

namespace qmapcontrol

{

    Layer::Layer(QString layername, MapAdapter* mapadapter, enum LayerType layertype, bool takeevents)

        :visible(true), mylayername(layername), mylayertype(layertype), mapAdapter(mapadapter), takeevents(takeevents), myoffscreenViewport(QRect(0,0,0,0))

    {

        //qDebug() << "creating new Layer: " << layername << ", type: " << contents;

        //qDebug() << this->layertype;

    }

    Layer::~Layer()

    {

        delete mapAdapter;

    }

    void Layer::setSize(QSize size)

    {

        this->size = size;

        screenmiddle = QPoint(size.width()/2, size.height()/2);

        //QMatrix mat;

        //mat.translate(480/2, 640/2);

        //mat.rotate(45);

        //mat.translate(-480/2,-640/2);

        //screenmiddle = mat.map(screenmiddle);

    }

    QString Layer::layername() const

    {

        return mylayername;

    }

    const MapAdapter* Layer::mapadapter() const

    {

        return mapAdapter;

    }

    void Layer::setVisible(bool visible)

    {

        this->visible = visible;

        emit(updateRequest());

    }

    void Layer::addGeometry(Geometry* geom)

    {

        //qDebug() << geom->getName() << ", " << geom->getPoints().at(0)->getWidget();

        geometries.append(geom);

        emit(updateRequest(geom->boundingBox()));

        //a geometry can request a redraw, e.g. when its position has been changed

        connect(geom, SIGNAL(updateRequest(QRectF)),

                this, SIGNAL(updateRequest(QRectF)));

    }

    void Layer::removeGeometry(Geometry* geometry)

    {

        for (int i=0; i<geometries.count(); i++)

        {

            if (geometry == geometries.at(i))

            {

                disconnect(geometry);

                geometries.removeAt(i);

                //delete geometry;

            }

        }

    }

    void Layer::clearGeometries()

    {

        foreach(Geometry *geometry, geometries){

            disconnect(geometry);

        }

        geometries.clear();

    }

    bool Layer::isVisible() const

    {

        return visible;

    }

    void Layer::zoomIn() const

    {

        mapAdapter->zoom_in();

    }

    void Layer::zoomOut() const

    {

        mapAdapter->zoom_out();

    }

    void Layer::mouseEvent(const QMouseEvent* evnt, const QPoint mapmiddle_px)

    {

        if (takesMouseEvents())

        {

            if (evnt->button() == Qt::LeftButton && evnt->type() == QEvent::MouseButtonPress)

            {

                // check for collision

                QPointF c = mapAdapter->displayToCoordinate(QPoint(evnt->x()-screenmiddle.x()+mapmiddle_px.x(),

                                                                   evnt->y()-screenmiddle.y()+mapmiddle_px.y()));

                Point* tmppoint = new Point(c.x(), c.y());

                for (int i=0; i<geometries.count(); i++)

                {

                    if (geometries.at(i)->isVisible() && geometries.at(i)->Touches(tmppoint, mapAdapter))

                        //if (geometries.at(i)->Touches(c, mapAdapter))

                    {

                        emit(geometryClicked(geometries.at(i), QPoint(evnt->x(), evnt->y())));

                    }

                }

                delete tmppoint;

            }

        }

    }

    bool Layer::takesMouseEvents() const

    {

        return takeevents;

    }

    void Layer::drawYourImage(QPainter* painter, const QPoint mapmiddle_px) const

    {

        if (mylayertype == MapLayer)

        {

            //qDebug() << ":: " << mapmiddle_px;

            //QMatrix mat;

            //mat.translate(480/2, 640/2);

            //mat.rotate(45);

            //mat.translate(-480/2,-640/2);

            //mapmiddle_px = mat.map(mapmiddle_px);

            //qDebug() << ":: " << mapmiddle_px;

            _draw(painter, mapmiddle_px);

        }

        drawYourGeometries(painter, QPoint(mapmiddle_px.x()-screenmiddle.x(), mapmiddle_px.y()-screenmiddle.y()), myoffscreenViewport);

    }

    void Layer::drawYourGeometries(QPainter* painter, const QPoint mapmiddle_px, QRect viewport) const

    {

        QPoint offset;

        if (mylayertype == MapLayer)

            offset = mapmiddle_px;

        else

            offset = mapmiddle_px-screenmiddle;

        painter->translate(-mapmiddle_px+screenmiddle);

        for (int i=0; i<geometries.count(); i++)

        {

            geometries.at(i)->draw(painter, mapAdapter, viewport, offset);

        }

        painter->translate(mapmiddle_px-screenmiddle);

    }

    void Layer::_draw(QPainter* painter, const QPoint mapmiddle_px) const

    {

        // screen middle rotieren...

        int tilesize = mapAdapter->tilesize();

        int cross_x = int(mapmiddle_px.x())%tilesize; // position on middle tile

        int cross_y = int(mapmiddle_px.y())%tilesize;

        //qDebug() << screenmiddle << " - " << cross_x << ", " << cross_y;

        // calculate how many surrounding tiles have to be drawn to fill the display

        int space_left = screenmiddle.x() - cross_x;

        int tiles_left = space_left/tilesize;

        if (space_left>0)

            tiles_left+=1;

        int space_above = screenmiddle.y() - cross_y;

        int tiles_above = space_above/tilesize;

        if (space_above>0)

            tiles_above+=1;

        int space_right = screenmiddle.x() - (tilesize-cross_x);

        int tiles_right = space_right/tilesize;

        if (space_right>0)

            tiles_right+=1;

        int space_bottom = screenmiddle.y() - (tilesize-cross_y);

        int tiles_bottom = space_bottom/tilesize;

        if (space_bottom>0)

            tiles_bottom+=1;

        //int tiles_displayed = 0;

        int mapmiddle_tile_x = mapmiddle_px.x()/tilesize;

        int mapmiddle_tile_y = mapmiddle_px.y()/tilesize;

        const QPoint from =     QPoint((-tiles_left+mapmiddle_tile_x)*tilesize, (-tiles_above+mapmiddle_tile_y)*tilesize);

        const QPoint to =               QPoint((tiles_right+mapmiddle_tile_x+1)*tilesize, (tiles_bottom+mapmiddle_tile_y+1)*tilesize);

        myoffscreenViewport = QRect(from, to);

        if (mapAdapter->isValid(mapmiddle_tile_x, mapmiddle_tile_y, mapAdapter->currentZoom()))

        {

            painter->drawPixmap(-cross_x+size.width(),

                                -cross_y+size.height(),

                                ImageManager::instance()->getImage(mapAdapter->host(), mapAdapter->query(mapmiddle_tile_x, mapmiddle_tile_y, mapAdapter->currentZoom())));

        }

        for (int i=-tiles_left+mapmiddle_tile_x; i<=tiles_right+mapmiddle_tile_x; i++)

        {

            for (int j=-tiles_above+mapmiddle_tile_y; j<=tiles_bottom+mapmiddle_tile_y; j++)

            {

                // check if image is valid

                if (!(i==mapmiddle_tile_x && j==mapmiddle_tile_y))

                    if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))

                    {

                    painter->drawPixmap(((i-mapmiddle_tile_x)*tilesize)-cross_x+size.width(),

                                        ((j-mapmiddle_tile_y)*tilesize)-cross_y+size.height(),

                                        ImageManager::instance()->getImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom())));

                    //if (QCoreApplication::hasPendingEvents())

                    //  QCoreApplication::processEvents();

                }

            }

        }

        // PREFETCHING

        int upper = mapmiddle_tile_y-tiles_above-1;

        int right = mapmiddle_tile_x+tiles_right+1;

        int left = mapmiddle_tile_x-tiles_right-1;

        int lower = mapmiddle_tile_y+tiles_bottom+1;

        int j = upper;

        for (int i=left; i<=right; i++)

        {

            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))

                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));

        }

        j = lower;

        for (int i=left; i<=right; i++)

        {

            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))

                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));

        }

        int i = left;

        for (int j=upper+1; j<=lower-1; j++)

        {

            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))

                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));

        }

        i = right;

        for (int j=upper+1; j<=lower-1; j++)

        {

            if (mapAdapter->isValid(i, j, mapAdapter->currentZoom()))

                ImageManager::instance()->prefetchImage(mapAdapter->host(), mapAdapter->query(i, j, mapAdapter->currentZoom()));

        }

    }

    QRect Layer::offscreenViewport() const

    {

        return myoffscreenViewport;

    }

    void Layer::moveWidgets(const QPoint mapmiddle_px) const

    {

        for (int i=0; i<geometries.count(); i++)

        {

            const Geometry* geom = geometries.at(i);

            if (geom->GeometryType == "Point")

            {

                if (((Point*)geom)->widget()!=0)

                {

                    QPoint topleft_relative = QPoint(mapmiddle_px-screenmiddle);

                    ((Point*)geom)->drawWidget(mapAdapter, topleft_relative);

                }

            }

        }

    }

    Layer::LayerType Layer::layertype() const

    {

        return mylayertype;

    }

    void Layer::setMapAdapter(MapAdapter* mapadapter)

    {

        mapAdapter = mapadapter;

    }

}