QGIS/plugins/scale_bar/plugin.cpp
timlinux 76694f5de7 Apply warnings for unused vars patch from karl
[ 1325870 ] removing trivial warnings (unused variables)


git-svn-id: http://svn.osgeo.org/qgis/trunk@4088 c8812cc2-4d05-0410-92ff-de0c093fc19c
2005-10-16 18:30:07 +00:00

608 lines
20 KiB
C++

/***************************************************************************
plugin.cpp
Plugin to draw scale bar on map
Functions:
-------------------
begin : Jun 1, 2004
copyright : (C) 2004 by Peter Brewer
email : sbr00pwb@users.sourceforge.net
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
/* $Id$ */
// includes
#include <cmath>
#include <qgisapp.h>
#include <qgsmaplayer.h>
#include "plugin.h"
#include "qgsproject.h"
#include "qgsmapcanvas.h"
#include <qtoolbar.h>
#include <qmenubar.h>
#include <qmessagebox.h>
#include <qpopupmenu.h>
#include <qlineedit.h>
#include <qaction.h>
#include <qapplication.h>
#include <qcursor.h>
#include <qpen.h>
#include <qgspoint.h>
#include <qpointarray.h>
#include <qgsmaptopixel.h>
#include <qstring.h>
#include <qfontmetrics.h>
#include <qfont.h>
#include <qpaintdevicemetrics.h>
#include <qspinbox.h>
#include <qcolor.h>
#include <qcolordialog.h>
#include <qglobal.h>
//non qt includes
#include <iostream>
//the gui subclass
#include "plugingui.h"
// xpm for creating the toolbar icon
#include "icon.xpm"
//
#ifdef WIN32
#define QGISEXTERN extern "C" __declspec( dllexport )
#else
#define QGISEXTERN extern "C"
#endif
static const char * const ident_ = "$Id$";
static const char * const name_ = "ScaleBar";
static const char * const description_ = "Plugin to draw scale bar on map";
static const char * const version_ = "Version 0.1";
static const QgisPlugin::PLUGINTYPE type_ = QgisPlugin::UI;
/**
* Constructor for the plugin. The plugin is passed a pointer to the main app
* and an interface object that provides access to exposed functions in QGIS.
* @param qgis Pointer to the QGIS main window
* @param _qI Pointer to the QGIS interface object
*/
QgsScaleBarPlugin::QgsScaleBarPlugin(QgisApp * theQGisApp,
QgisIface * theQgisInterFace):
QgisPlugin(name_,description_,version_,type_),
qgisMainWindowPointer(theQGisApp),
qGisInterface(theQgisInterFace)
{
mPreferredSize = 30;
mPlacement = "Top Left";
mStyle = "Tick Down";
mEnabled = true;
mSnapping = true;
}
QgsScaleBarPlugin::~QgsScaleBarPlugin()
{
}
/*
* Initialize the GUI interface for the plugin
*/
void QgsScaleBarPlugin::initGui()
{
QPopupMenu *pluginMenu = qGisInterface->getPluginMenu("&Decorations");
menuId = pluginMenu->insertItem(QIconSet(icon),"&ScaleBar", this, SLOT(run()));
pluginMenu->setWhatsThis(menuId, "Creates a scale bar that is displayed on the map canvas");
// Create the action for tool
#if QT_VERSION < 0x040000
myQActionPointer = new QAction("Scale Bar", QIconSet(icon), "&Wmi",0, this, "run");
#else
myQActionPointer = new QAction(QIcon(icon), "Scale Bar", this);
#endif
myQActionPointer->setWhatsThis("Creates a scale bar that is displayed on the map canvas");
// Connect the action to the run
connect(myQActionPointer, SIGNAL(activated()), this, SLOT(run()));
//render the scale bar each time the map is rendered
connect(qGisInterface->getMapCanvas(), SIGNAL(renderComplete(QPainter *)), this, SLOT(renderScaleBar(QPainter *)));
//this resets this plugin up if a project is loaded
connect(qgisMainWindowPointer, SIGNAL(projectRead()), this, SLOT(projectRead()));
// Add the icon to the toolbar
qGisInterface->addToolBarIcon(myQActionPointer);
}
void QgsScaleBarPlugin::projectRead()
{
#ifdef QGISDEBUG
std::cout << "+++++++++ scalebar plugin - project read slot called...." << std::endl;
#endif //default text to start with - try to fetch it from qgsproject
mPreferredSize = QgsProject::instance()->readNumEntry("ScaleBar","/PreferredSize",30);
mStyle = QgsProject::instance()->readEntry("ScaleBar","/Style","Tick Down");
mPlacement = QgsProject::instance()->readEntry("ScaleBar","/Placement","Top Left");
mEnabled = QgsProject::instance()->readBoolEntry("ScaleBar","/Enabled",true);
mSnapping = QgsProject::instance()->readBoolEntry("ScaleBar","/Snapping",true);
int myRedInt = QgsProject::instance()->readNumEntry("ScaleBar","/ColorRedPart",0);
int myGreenInt = QgsProject::instance()->readNumEntry("ScaleBar","/ColorGreenPart",0);
int myBlueInt = QgsProject::instance()->readNumEntry("ScaleBar","/ColorBluePart",0);
mColour = QColor(myRedInt,myGreenInt,myBlueInt);
}
//method defined in interface
void QgsScaleBarPlugin::help()
{
//implement me!
}
// Slot called when the menu item is activated
void QgsScaleBarPlugin::run()
{
QgsScaleBarPluginGui *myPluginGui=new QgsScaleBarPluginGui(qgisMainWindowPointer,"Scale Bar",true,0);
myPluginGui->setPreferredSize(mPreferredSize);
myPluginGui->setSnapping(mSnapping);
myPluginGui->setPlacement(mPlacement);
myPluginGui->setEnabled(mEnabled);
myPluginGui->setStyle(mStyle);
myPluginGui->setColour(mColour);
connect(myPluginGui, SIGNAL(changePreferredSize(int)), this, SLOT(setPreferredSize(int)));
connect(myPluginGui, SIGNAL(changeSnapping(bool)), this, SLOT(setSnapping(bool)));
connect(myPluginGui, SIGNAL(changePlacement(QString)), this, SLOT(setPlacement(QString)));
connect(myPluginGui, SIGNAL(changeEnabled(bool)), this, SLOT(setEnabled(bool)));
connect(myPluginGui, SIGNAL(changeStyle(QString)), this, SLOT(setStyle(QString)));
connect(myPluginGui, SIGNAL(changeColour(QColor)), this, SLOT(setColour(QColor)));
connect(myPluginGui, SIGNAL(refreshCanvas()), this, SLOT(refreshCanvas()));
myPluginGui->show();
//set the map units in the spin box
int myUnits=qGisInterface->getMapCanvas()->mapUnits();
switch (myUnits)
{
case 0: myPluginGui->spnSize->setSuffix(tr(" metres/km")); break;
case 1: myPluginGui->spnSize->setSuffix(tr(" feet")); break;
case 2: myPluginGui->spnSize->setSuffix(tr(" degrees")); break;
default: std::cout << "Error: not picked up map units - actual value = " << myUnits << std::endl;
};
}
void QgsScaleBarPlugin::refreshCanvas()
{
qGisInterface->getMapCanvas()->refresh();
}
// Actual drawing of Scale Bar
void QgsScaleBarPlugin::renderScaleBar(QPainter * theQPainter)
{
int myBufferSize=1; //softcode this later
//Get canvas dimensions
QPaintDeviceMetrics myMetrics( theQPainter->device() );
int myCanvasHeight = myMetrics.height();
int myCanvasWidth = myMetrics.width();
//Get map units per pixel. This can be negative at times (to do with
//projections) and that just confuses the rest of the code in this
//function, so force to a positive number.
double myMuppDouble = std::abs(qGisInterface->getMapCanvas()->mupp());
// Exit if the canvas width is 0 or layercount is 0 or QGIS will freeze
int myLayerCount=qGisInterface->getMapCanvas()->layerCount();
if (!myLayerCount || !myCanvasWidth || !myMuppDouble) return;
//Large if statement which determines whether to render the scale bar
if (mEnabled)
{
// Hard coded sizes
int myMajorTickSize=8;
int myTextOffsetX=3;
double myActualSize=mPreferredSize;
int myMargin=20;
//Calculate size of scale bar for preferred number of map units
double myScaleBarWidth = mPreferredSize / myMuppDouble;
//If scale bar is very small reset to 1/4 of the canvas wide
if (myScaleBarWidth < 30)
{
myScaleBarWidth = myCanvasWidth / 4; // pixels
myActualSize = myScaleBarWidth * myMuppDouble; // map units
};
//if scale bar is more than half the canvas wide keep halving until not
while (myScaleBarWidth > myCanvasWidth/3)
{
myScaleBarWidth = myScaleBarWidth /3;
};
myActualSize = myScaleBarWidth * myMuppDouble;
// Work out the exponent for the number - e.g, 1234 will give 3,
// and .001234 will give -3
double myPowerOf10 = floor(log10(myActualSize));
// snap to integer < 10 times power of 10
if (mSnapping)
{
double scaler = pow(10.0, myPowerOf10);
myActualSize = round(myActualSize / scaler) * scaler;
myScaleBarWidth = myActualSize / myMuppDouble;
}
//Get type of map units and set scale bar unit label text
QGis::units myMapUnits=qGisInterface->getMapCanvas()->mapUnits();
QString myScaleBarUnitLabel;
switch (myMapUnits)
{
case QGis::METERS:
if (myActualSize > 1000.0)
{
myScaleBarUnitLabel=tr(" km");
myActualSize = myActualSize/1000;
}
else if (myActualSize < 0.01)
{
myScaleBarUnitLabel=tr(" mm");
myActualSize = myActualSize*1000;
}
else if (myActualSize < 0.1)
{
myScaleBarUnitLabel=tr(" cm");
myActualSize = myActualSize*100;
}
else
myScaleBarUnitLabel=tr(" m");
break;
case QGis::FEET:
if (myActualSize == 1.0)
myScaleBarUnitLabel=tr(" foot");
else
myScaleBarUnitLabel=tr(" feet");
break;
case QGis::DEGREES:
if (myActualSize == 1.0)
myScaleBarUnitLabel=tr(" degree");
else
myScaleBarUnitLabel=tr(" degrees");
break;
case QGis::UNKNOWN:
myScaleBarUnitLabel=tr(" unknown");
default:
std::cout << "Error: not picked up map units - actual value = "
<< myMapUnits << std::endl;
};
//Set font and calculate width of unit label
int myFontSize = 10; //we use this later for buffering
QFont myFont( "helvetica", myFontSize );
theQPainter->setFont(myFont);
QFontMetrics myFontMetrics( myFont );
double myFontWidth = myFontMetrics.width( myScaleBarUnitLabel );
double myFontHeight = myFontMetrics.height();
//Set the maximum label
QString myScaleBarMaxLabel=QString::number(myActualSize);
//Calculate total width of scale bar and label
double myTotalScaleBarWidth = myScaleBarWidth + myFontWidth;
//determine the origin of scale bar depending on placement selected
int myOriginX=myMargin;
int myOriginY=myMargin;
if (mPlacement==tr("Top Left"))
{
myOriginX=myMargin;
myOriginY=myMargin;
}
else if (mPlacement==tr("Bottom Left"))
{
myOriginX=myMargin;
myOriginY=myCanvasHeight - myMargin;
}
else if (mPlacement==tr("Top Right"))
{
myOriginX=myCanvasWidth - ((int) myTotalScaleBarWidth) - myMargin;
myOriginY=myMargin;
}
else if (mPlacement==tr("Bottom Right"))
{
myOriginX=myCanvasWidth - ((int) myTotalScaleBarWidth) - myMargin;
myOriginY=myCanvasHeight - myMargin;
}
else
{
std::cout << "Unable to determine where to put scale bar so defaulting to top left" << std::endl;
}
//Set pen to draw with
QPen myForegroundPen( mColour, 2 );
QPen myBackgroundPen( Qt::white, 4 );
//Cast myScaleBarWidth to int for drawing
int myScaleBarWidthInt = (int) myScaleBarWidth;
//Create array of vertices for scale bar depending on style
if (mStyle==tr("Tick Down"))
{
QPointArray myTickDownArray(4);
//draw a buffer first so bar shows up on dark images
theQPainter->setPen( myBackgroundPen );
myTickDownArray.putPoints(0,4,
myOriginX , (myOriginY + myMajorTickSize) ,
myOriginX , myOriginY ,
(myScaleBarWidthInt + myOriginX), myOriginY ,
(myScaleBarWidthInt + myOriginX), (myOriginY + myMajorTickSize)
);
theQPainter->drawPolyline(myTickDownArray);
//now draw the bar itself in user selected color
theQPainter->setPen( myForegroundPen );
myTickDownArray.putPoints(0,4,
myOriginX , (myOriginY + myMajorTickSize) ,
myOriginX , myOriginY ,
(myScaleBarWidthInt + myOriginX), myOriginY ,
(myScaleBarWidthInt + myOriginX), (myOriginY + myMajorTickSize)
);
theQPainter->drawPolyline(myTickDownArray);
}
else if (mStyle==tr("Tick Up"))
{
QPointArray myTickUpArray(4);
//draw a buffer first so bar shows up on dark images
theQPainter->setPen( myBackgroundPen );
myTickUpArray.putPoints(0,4,
myOriginX , myOriginY ,
myOriginX , myOriginY + myMajorTickSize ,
(myScaleBarWidthInt + myOriginX), myOriginY + myMajorTickSize ,
(myScaleBarWidthInt + myOriginX), myOriginY
);
theQPainter->drawPolyline(myTickUpArray);
//now draw the bar itself in user selected color
theQPainter->setPen( myForegroundPen );
myTickUpArray.putPoints(0,4,
myOriginX , myOriginY ,
myOriginX , myOriginY + myMajorTickSize ,
(myScaleBarWidthInt + myOriginX), myOriginY + myMajorTickSize ,
(myScaleBarWidthInt + myOriginX), myOriginY
);
theQPainter->drawPolyline(myTickUpArray);
}
else if (mStyle==tr("Bar"))
{
QPointArray myBarArray(2);
//draw a buffer first so bar shows up on dark images
theQPainter->setPen( myBackgroundPen );
myBarArray.putPoints(0,2,
myOriginX , (myOriginY + (myMajorTickSize/2)),
(myScaleBarWidthInt + myOriginX), (myOriginY + (myMajorTickSize/2))
);
theQPainter->drawPolyline(myBarArray);
//now draw the bar itself in user selected color
theQPainter->setPen( myForegroundPen );
myBarArray.putPoints(0,2,
myOriginX , (myOriginY + (myMajorTickSize/2)),
(myScaleBarWidthInt + myOriginX), (myOriginY + (myMajorTickSize/2))
);
theQPainter->drawPolyline(myBarArray);
}
else if (mStyle==tr("Box"))
{
QPointArray myBoxArray(5);
//draw a buffer first so bar shows up on dark images
theQPainter->setPen( myBackgroundPen );
myBoxArray.putPoints(0,5,
myOriginX , myOriginY,
(myScaleBarWidthInt + myOriginX), myOriginY,
(myScaleBarWidthInt + myOriginX), (myOriginY+myMajorTickSize),
myOriginX , (myOriginY+myMajorTickSize),
myOriginX , myOriginY
);
theQPainter->drawPolyline(myBoxArray);
//now draw the bar itself in user selected color
theQPainter->setPen( myForegroundPen );
myBoxArray.putPoints(0,5,
myOriginX , myOriginY,
(myScaleBarWidthInt + myOriginX), myOriginY,
(myScaleBarWidthInt + myOriginX), (myOriginY+myMajorTickSize),
myOriginX , (myOriginY+myMajorTickSize),
myOriginX , myOriginY
);
theQPainter->drawPolyline(myBoxArray);
}
//Do actual drawing of scale bar
//
//Do drawing of scale bar text
//
QColor myBackColor = Qt::white;
QColor myForeColor = Qt::black;
//Draw the minimum label buffer
theQPainter->setPen( myBackColor );
myFontWidth = myFontMetrics.width( "0" );
myFontHeight = myFontMetrics.height();
for (int i = 0-myBufferSize; i <= myBufferSize; i++)
{
for (int j = 0-myBufferSize; j <= myBufferSize; j++)
{
theQPainter->drawText( int(i +(myOriginX-(myFontWidth/2))),
int(j + (myOriginY-(myFontHeight/4))),
"0");
}
}
//Draw minimum label
theQPainter->setPen( myForeColor );
theQPainter->drawText(
int(myOriginX-(myFontWidth/2)),
int(myOriginY-(myFontHeight/4)),
"0"
);
//
//Draw maximum label
//
theQPainter->setPen( myBackColor );
myFontWidth = myFontMetrics.width( myScaleBarMaxLabel );
myFontHeight = myFontMetrics.height();
//first the buffer
for (int i = 0-myBufferSize; i <= myBufferSize; i++)
{
for (int j = 0-myBufferSize; j <= myBufferSize; j++)
{
theQPainter->drawText( int(i + (myOriginX+myScaleBarWidthInt-(myFontWidth/2))),
int(j + (myOriginY-(myFontHeight/4))),
myScaleBarMaxLabel);
}
}
//then the text itself
theQPainter->setPen( myForeColor );
theQPainter->drawText(
int(myOriginX+myScaleBarWidthInt-(myFontWidth/2)),
int(myOriginY-(myFontHeight/4)),
myScaleBarMaxLabel
);
//
//Draw unit label
//
theQPainter->setPen( myBackColor );
myFontWidth = myFontMetrics.width( myScaleBarUnitLabel );
myFontHeight = myFontMetrics.height();
//first the buffer
for (int i = 0-myBufferSize; i <= myBufferSize; i++)
{
for (int j = 0-myBufferSize; j <= myBufferSize; j++)
{
theQPainter->drawText( i + (myOriginX+myScaleBarWidthInt+myTextOffsetX),
j + (myOriginY+myMajorTickSize),
myScaleBarUnitLabel);
}
}
//then the text itself
theQPainter->setPen( myForeColor );
theQPainter->drawText(
(myOriginX+myScaleBarWidthInt+myTextOffsetX),(myOriginY+myMajorTickSize),
myScaleBarUnitLabel
);
}
}
// Unload the plugin by cleaning up the GUI
void QgsScaleBarPlugin::unload()
{
// remove the GUI
qGisInterface->removePluginMenuItem("&Decorations",menuId);
qGisInterface->removeToolBarIcon(myQActionPointer);
// remove the northarrow from the canvas
disconnect(qGisInterface->getMapCanvas(), SIGNAL(renderComplete(QPainter *)),
this, SLOT(renderScaleBar(QPainter *)));
refreshCanvas();
delete myQActionPointer;
}
//! set placement of scale bar
void QgsScaleBarPlugin::setPlacement(QString theQString)
{
mPlacement = theQString;
QgsProject::instance()->writeEntry("ScaleBar","/Placement",mPlacement);
}
//! set preferred size of scale bar
void QgsScaleBarPlugin::setPreferredSize(int thePreferredSize)
{
mPreferredSize = thePreferredSize;
QgsProject::instance()->writeEntry("ScaleBar","/PreferredSize",mPreferredSize);
}
//! set whether the scale bar length should snap to the closes A*10^B
void QgsScaleBarPlugin::setSnapping(bool theSnapping)
{
mSnapping = theSnapping;
QgsProject::instance()->writeEntry("ScaleBar","/Snapping",mSnapping);
}
//! set scale bar enable
void QgsScaleBarPlugin::setEnabled(bool theBool)
{
mEnabled = theBool;
QgsProject::instance()->writeEntry("ScaleBar","/Enabled",mEnabled);
}
//! set scale bar enable
void QgsScaleBarPlugin::setStyle(QString theStyleQString)
{
mStyle = theStyleQString;
QgsProject::instance()->writeEntry("ScaleBar","/Style",mStyle);
}
//! set the scale bar colour
void QgsScaleBarPlugin::setColour(QColor theQColor)
{
mColour = theQColor;
QgsProject::instance()->writeEntry("ScaleBar","/ColorRedPart", mColour.red());
QgsProject::instance()->writeEntry("ScaleBar","/ColorGreenPart", mColour.green());
QgsProject::instance()->writeEntry("ScaleBar","/ColorBluePart", mColour.blue());
}
/**
* Required extern functions needed for every plugin
* These functions can be called prior to creating an instance
* of the plugin class
*/
// Class factory to return a new instance of the plugin class
QGISEXTERN QgisPlugin * classFactory(QgisApp * theQGisAppPointer, QgisIface * theQgisInterfacePointer)
{
return new QgsScaleBarPlugin(theQGisAppPointer, theQgisInterfacePointer);
}
// Return the name of the plugin - note that we do not user class members as
// the class may not yet be insantiated when this method is called.
QGISEXTERN QString name()
{
return name_;
}
// Return the description
QGISEXTERN QString description()
{
return description_;
}
// Return the type (either UI or MapLayer plugin)
QGISEXTERN int type()
{
return type_;
}
// Return the version number for the plugin
QGISEXTERN QString version()
{
return version_;
}
// Delete ourself
QGISEXTERN void unload(QgisPlugin * thePluginPointer)
{
delete thePluginPointer;
}