qgsmapcanvas.h

Go to the documentation of this file.

/***************************************************************************
                          qgsmapcanvas.h  -  description
                             -------------------
    begin                : Sun Jun 30 2002
    copyright            : (C) 2002 by Gary E.Sherman
    email                : sherman at mrcc.com
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSMAPCANVAS_H
#define QGSMAPCANVAS_H

#include "qgsconfig.h"

#include <list>
#include <memory>
#include <deque>

#include "qgsrectangle.h"
#include "qgspoint.h"
#include "qgis.h"

#include <QDomDocument>
#include <QGraphicsView>
#include <QtCore>

#ifdef HAVE_TOUCH
#include <QGestureEvent>
#endif

class QWheelEvent;
class QPixmap;
class QPaintEvent;
class QKeyEvent;
class ResizeEvent;

class QColor;
class QDomDocument;
class QPaintDevice;
class QMouseEvent;
class QRubberBand;
class QGraphicsScene;

class QgsMapToPixel;
class QgsMapLayer;
class QgsLegend;
class QgsLegendView;
class QgsHighlight;
class QgsVectorLayer;

class QgsMapRenderer;
class QgsMapCanvasMap;
class QgsMapOverviewCanvas;
class QgsMapTool;

class GUI_EXPORT QgsMapCanvasLayer
{
  public:
    QgsMapCanvasLayer( QgsMapLayer* layer, bool visible = true, bool isInOverview = false )
        : mLayer( layer ), mVisible( visible ), mInOverview( isInOverview ) {}

    void setVisible( bool visible ) { mVisible = visible; }
    void setInOverview( bool isInOverview ) { mInOverview = isInOverview; }

    bool isVisible() const { return mVisible; }
    bool isInOverview() const { return mInOverview; }

    QgsMapLayer* layer() { return mLayer; }
    const QgsMapLayer* layer() const { return mLayer; }

  private:
    QgsMapLayer* mLayer;

    bool mVisible;

    bool mInOverview;
};


class GUI_EXPORT QgsMapCanvas : public QGraphicsView
{
    Q_OBJECT

  public:

    enum WheelAction { WheelZoom, WheelZoomAndRecenter, WheelZoomToMouseCursor, WheelNothing };

    QgsMapCanvas( QWidget * parent = 0, const char *name = 0 );

    ~QgsMapCanvas();

    void setLayerSet( QList<QgsMapCanvasLayer>& layers );

    void setCurrentLayer( QgsMapLayer* layer );

    void updateOverview();

    void enableOverviewMode( QgsMapOverviewCanvas* overview );

    QgsMapCanvasMap* map();

    QgsMapRenderer* mapRenderer();

    QPaintDevice &canvasPaintDevice();

    double scale();

    void clear();

    double mapUnitsPerPixel() const;

    QgsRectangle extent() const;
    QgsRectangle fullExtent() const;

    void setExtent( const QgsRectangle &r );

    void zoomToFullExtent();

    void zoomToPreviousExtent();

    void zoomToNextExtent();

    // ! Clears the list of extents and sets current extent as first item
    void clearExtentHistory();

    void zoomToSelected( QgsVectorLayer* layer = NULL );

    void panToSelected( QgsVectorLayer* layer = NULL );

    void setMapTool( QgsMapTool* mapTool );

    void unsetMapTool( QgsMapTool* mapTool );

    QgsMapTool* mapTool();

    virtual void setCanvasColor( const QColor & _newVal );
    virtual QColor canvasColor() const;

    void updateScale();

    void updateFullExtent();

    QgsMapLayer *layer( int index );

    int layerCount() const;

    QList<QgsMapLayer*> layers() const;

    void freeze( bool frz = true );

    bool isFrozen();

    void setDirty( bool _dirty );

    bool isDirty() const;

    void setMapUnits( QGis::UnitType mapUnits );

    QGis::UnitType mapUnits() const;

    const QgsMapToPixel* getCoordinateTransform();

    bool isDrawing();

    QgsMapLayer* currentLayer();

    void setWheelAction( WheelAction action, double factor = 2 );

    void zoomIn( );

    void zoomOut( );

    // added in 1.5
    void zoomScale( double scale );

    void zoomByFactor( double scaleFactor );

    void zoomWithCenter( int x, int y, bool zoomIn );

    void enableAntiAliasing( bool theFlag );

    bool antiAliasingEnabled() const { return mAntiAliasing; }

    void useImageToRender( bool theFlag );

    // following 2 methods should be moved elsewhere or changed to private
    // currently used by pan map tool
    void panActionEnd( QPoint releasePoint );

    void panAction( QMouseEvent * event );

    QPoint mouseLastXY();

  public slots:

    void refresh();

    void selectionChangedSlot();

    void saveAsImage( QString theFileName, QPixmap * QPixmap = 0, QString = "PNG" );

    void layerStateChange();

    void setRenderFlag( bool theFlag );
    bool renderFlag() {return mRenderFlag;};

    bool hasCrsTransformEnabled();

    void mapUnitsChanged();

    void updateMap();

    void showError( QgsMapLayer * mapLayer );

    void readProject( const QDomDocument & );

    void writeProject( QDomDocument & );

  private slots:
    void mapToolDestroyed();

  signals:
    void setProgress( int, int );

    void xyCoordinates( const QgsPoint &p );

    void scaleChanged( double );

    void extentsChanged();

    void renderComplete( QPainter * );

    void mapCanvasRefreshed();

    void renderStarting();

    void layersChanged();

    void keyPressed( QKeyEvent * e );

    void keyReleased( QKeyEvent * e );

    void mapToolSet( QgsMapTool *tool );

    void selectionChanged( QgsMapLayer * layer );

    void zoomLastStatusChanged( bool );

    void zoomNextStatusChanged( bool );

  protected:
#ifdef HAVE_TOUCH

    bool event( QEvent * e );
#endif

    void keyPressEvent( QKeyEvent * e );

    void keyReleaseEvent( QKeyEvent * e );

    void mouseDoubleClickEvent( QMouseEvent * e );

    void mouseMoveEvent( QMouseEvent * e );

    void mousePressEvent( QMouseEvent * e );

    void mouseReleaseEvent( QMouseEvent * e );

    void wheelEvent( QWheelEvent * e );

    void resizeEvent( QResizeEvent * e );

    void paintEvent( QPaintEvent * e );

    void dragEnterEvent( QDragEnterEvent * e );

    void moveCanvasContents( bool reset = false );

    void updateCanvasItemPositions();

    class CanvasProperties;

    std::auto_ptr<CanvasProperties> mCanvasProperties;

    void connectNotify( const char * signal );

  private slots:
    void crsTransformEnabled( bool );

  private:

    QgsMapCanvas( QgsMapCanvas const & );

    QgsMapRenderer* mMapRenderer;

    QgsMapCanvasMap* mMap;

    QgsMapOverviewCanvas* mMapOverview;

    bool mBackbufferEnabled;
    bool mDrawing;

    bool mFrozen;

    bool mDirty;

    bool mRenderFlag;

    QList< QPair<int, int> > mResizeQueue;

    QgsMapLayer* mCurrentLayer;

    QGraphicsScene* mScene;

    QgsMapTool* mMapTool;

    QgsMapTool* mLastNonZoomMapTool;

    QList <QgsRectangle> mLastExtent;
    int mLastExtentIndex;

    double mWheelZoomFactor;

    WheelAction mWheelAction;

    QSize mNewSize;

    bool mPainting;

    bool mAntiAliasing;
}; // class QgsMapCanvas


#endif