Logo Search packages:      
Sourcecode: qgis version File versions

qgsgrassplugin.cpp

/***************************************************************************
    qgsgrassplugin.cpp  -  GRASS menu
                             -------------------
    begin                : March, 2004
    copyright            : (C) 2004 by Radim Blazek
    email                : blazek@itc.it
 ***************************************************************************/
/***************************************************************************
 *                                                                         *
 *   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: qgsgrassplugin.cpp,v 1.9.2.2 2004/12/11 22:59:47 gsherman Exp $ */

// includes
#include "../../src/qgisapp.h"
#include "../../src/qgsmaplayer.h"
#include "../../src/qgsrasterlayer.h"
#include "../../src/qgisiface.h"
#include "../../src/qgsmapcanvas.h"
#include "../../src/qgsmaplayer.h"
#include "../../src/qgsvectorlayer.h"
#include "../../src/qgsdataprovider.h"
#include "../../src/qgsfeatureattribute.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 <qfileinfo.h>
#include <qsettings.h>

//non qt includes
#include <iostream>

extern "C" {
#include <gis.h>
#include <Vect.h>
}

#include "qgsgrassplugin.h"
#include "../../providers/grass/qgsgrass.h"
#include "../../providers/grass/qgsgrassprovider.h"

//the gui subclass
#include "qgsgrassattributes.h"
#include "qgsgrassselect.h"
#include "qgsgrassedit.h"
#include "qgsgrassregion.h"

// xpm for creating the toolbar icon
#include "add_vector.xpm"
#include "add_raster.xpm"
#include "grass_edit.xpm"
#include "grass_region.xpm"
#include "grass_region_edit.xpm"
static const char *pluginVersion = "0.1";

/**
 * 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 theQGisApp Pointer to the QGIS main window
 * @param theQgisInterFace Pointer to the QGIS interface object
 */
00072 QgsGrassPlugin::QgsGrassPlugin(QgisApp * theQGisApp, QgisIface * theQgisInterFace):
          qgisMainWindowPointer(theQGisApp), qGisInterface(theQgisInterFace)
{
  /** Initialize the plugin and set the required attributes */
  pluginNameQString = "GrassVector";
  pluginVersionQString = "0.1";
  pluginDescriptionQString = "GRASS layer";
}

00081 QgsGrassPlugin::~QgsGrassPlugin()
{

}

/* Following functions return name, description, version, and type for the plugin */
00087 QString QgsGrassPlugin::name()
{
  return pluginNameQString;
}

00092 QString QgsGrassPlugin::version()
{
  return pluginVersionQString;

}

00098 QString QgsGrassPlugin::description()
{
  return pluginDescriptionQString;

}

00104 void QgsGrassPlugin::help()
{
    //TODO
}

00109 int QgsGrassPlugin::type()
{
  return QgisPlugin::UI;
}

/*
 * Initialize the GUI interface for the plugin 
 */
00117 void QgsGrassPlugin::initGui()
{
    menuBarPointer = 0;
    toolBarPointer = 0;
    // Check GISBASE
    char *gb = getenv("GISBASE");
    if ( !gb ) {
  QMessageBox::warning( 0, "Warning", "Enviroment variable 'GISBASE' is not set,\nGRASS data "
    "cannot be used.\nSet 'GISBASE' and restart QGIS.\nGISBASE is full path to the\n"
          "directory where GRASS is installed." );
  return;
    }

    QString gbs ( gb );
    QFileInfo gbi ( gbs );
    if ( !gbi.exists() ) {
  QMessageBox::warning( 0, "Warning", "GISBASE:\n'" + gbs + "'\ndoes not exist,\n"
    "GRASS data cannot be used." );
  return;
    }

    mCanvas = qGisInterface->getMapCanvas();
    
    QPopupMenu *pluginMenu = new QPopupMenu(qgisMainWindowPointer);

    int menuId = pluginMenu->insertItem(QIconSet(icon_add_vector),"Add Grass &Vector", this,
                                        SLOT(addVector()));
    pluginMenu->setWhatsThis(menuId, "Add a GRASS vector layer to the map canvas.");
    menuId = pluginMenu->insertItem(QIconSet(icon_add_raster),"Add Grass &Raster", this, SLOT(addRaster()));
    pluginMenu->setWhatsThis(menuId, "Add a GRASS raster layer to the map canvas.");
    menuId = pluginMenu->insertItem(QIconSet(icon_grass_edit),"&Edit Grass Vector", this, SLOT(edit()));
    pluginMenu->setWhatsThis(menuId, "Edit a GRASS vector layer");

    menuBarPointer = ((QMainWindow *) qgisMainWindowPointer)->menuBar();

    menuIdInt = qGisInterface->addMenu("&GRASS", pluginMenu);

    // Create the action for tool
    QAction *addVectorAction = new QAction("Add GRASS vector layer", QIconSet(icon_add_vector), 
                                     "Add GRASS vector layer",0, this, "addVector");
    addVectorAction->setWhatsThis("Adds a GRASS vector layer to the map canvas");
    QAction *addRasterAction = new QAction("Add GRASS raster layer", QIconSet(icon_add_raster), 
                                     "Add GRASS raster layer",0, this, "addRaster");
    addRasterAction->setWhatsThis("Adds a GRASS raster layer to the map canvas");
    mRegionAction = new QAction("Display Current Grass Region", QIconSet(icon_grass_region), 
                          "Display Current Grass Region",0, this, "region", true);
    mRegionAction->setWhatsThis("Displays the current GRASS region as a rectangle on the map canvas");
    QAction *editRegionAction = new QAction("Edit Current Grass Region", QIconSet(icon_grass_region_edit), 
                          "Edit Current Grass Region",0, this, "editRegion");
    editRegionAction->setWhatsThis("Edit the current GRASS region");
    QAction *editAction = new QAction("Edit Grass Vector layer", QIconSet(icon_grass_edit), 
                          "Edit Grass Vector layer",0, this, "edit");
    editAction->setWhatsThis("Edit the currently selected GRASS vector layer.");
    if ( !QgsGrass::activeMode() )  {
  mRegionAction->setEnabled(false);
  editRegionAction->setEnabled(false);
    } else {
  mRegionAction->setOn(true);
    }

    // Connect the action 
    connect(addVectorAction, SIGNAL(activated()), this, SLOT(addVector()));
    connect(addRasterAction, SIGNAL(activated()), this, SLOT(addRaster()));
    connect(editAction, SIGNAL(activated()), this, SLOT(edit()));
    connect(editRegionAction, SIGNAL(activated()), this, SLOT(changeRegion()));

    // Add the toolbar
    toolBarPointer = new QToolBar((QMainWindow *) qgisMainWindowPointer, "GRASS");
    toolBarPointer->setLabel("Add GRASS layer");

    // Add to the toolbar
    addVectorAction->addTo(toolBarPointer);
    addRasterAction->addTo(toolBarPointer);
    mRegionAction->addTo(toolBarPointer);
    editRegionAction->addTo(toolBarPointer);
    editAction->addTo(toolBarPointer);
  
    // Connect display region
    connect( mCanvas, SIGNAL(renderComplete(QPainter *)), this, SLOT(displayRegion(QPainter *)));

    // Init Region symbology
    QSettings settings;
    mRegionPen.setColor( QColor ( settings.readEntry ("/qgis/grass/region/color", "#ff0000" ) ) );
    mRegionPen.setWidth( settings.readNumEntry ("/qgis/grass/region/width", 0 ) );
}

// Slot called when the "Add GRASS vector layer" menu item is activated
00204 void QgsGrassPlugin::addVector()
{
    QString uri;

    QgsGrassSelect *sel = new QgsGrassSelect(QgsGrassSelect::VECTOR );
    if ( sel->exec() ) {
  uri = sel->gisdbase + "/" + sel->location + "/" + sel->mapset + "/" + sel->map + "/" + sel->layer;
    }
    #ifdef QGISDEBUG
    std::cerr << "plugin URI: " << uri << std::endl;
    #endif
    if ( uri.length() == 0 ) {
  std::cerr << "Nothing was selected" << std::endl;
  return;
    } else {
        #ifdef QGISDEBUG
  std::cout << "Add new vector layer" << std::endl;
        #endif
  // create vector name: vector layer
  int pos = uri.findRev('/');
  pos = uri.findRev('/', pos-1);
  QString name = uri.right( uri.length() - pos - 1 );
  name.replace('/', ' ');

        qGisInterface->addVectorLayer( uri, name, "grass");
    }
}

// Slot called when the "Add GRASS raster layer" menu item is activated
00233 void QgsGrassPlugin::addRaster()
{
    QString uri;

    std::cerr << "QgsGrassPlugin::addRaster" << std::endl;

    QgsGrassSelect *sel = new QgsGrassSelect(QgsGrassSelect::RASTER );
    if ( sel->exec() ) {
  QString element;
  if ( sel->selectedType == QgsGrassSelect::RASTER ) {
      element = "cellhd";
  } else { // GROUP
      element = "group";
  }
      
  uri = sel->gisdbase + "/" + sel->location + "/" + sel->mapset + "/" + element + "/" + sel->map;
    }
    #ifdef QGISDEBUG
    std::cerr << "plugin URI: " << uri << std::endl;
    #endif
    if ( uri.length() == 0 ) {
  std::cerr << "Nothing was selected" << std::endl;
  return;
    } else {
        #ifdef QGISDEBUG
  std::cout << "Add new raster layer" << std::endl;
        #endif
  // create raster name
  int pos = uri.findRev('/');
  pos = uri.findRev('/', pos-1);
  QString name = uri.right( uri.length() - pos - 1 );
  name.replace('/', ' ');

        qGisInterface->addRasterLayer( uri );
    }
}

// Start vector editing
00271 void QgsGrassPlugin::edit()
{
    if ( QgsGrassEdit::isRunning() ) {
  QMessageBox::warning( 0, "Warning", "GRASS Edit is already running." );
  return;
    }

    QgsGrassEdit *ed = new QgsGrassEdit( qgisMainWindowPointer, qGisInterface, qgisMainWindowPointer, 0, Qt::WType_Dialog );

    if ( ed->isValid() ) {
        ed->show();
  mCanvas->refresh();
    } else {
  delete ed;
    }
}

00288 void QgsGrassPlugin::displayRegion(QPainter *painter)
{
    #ifdef QGISDEBUG
    std::cout << "QgsGrassPlugin::displayRegion()" << std::endl;
    #endif
    
    if ( !mRegionAction->isEnabled() || !mRegionAction->isOn() ) return;

    // Display region of current mapset if in active mode
    if ( !QgsGrass::activeMode() ) return;

    QString gisdbase = QgsGrass::getDefaultGisdbase();
    QString location = QgsGrass::getDefaultLocation();
    QString mapset   = QgsGrass::getDefaultMapset();

    if ( gisdbase.isEmpty() || location.isEmpty() || mapset.isEmpty() ) {
  QMessageBox::warning( 0, "Warning", "GISDBASE, LOCATION_NAME or MAPSET is not set, "
                     "cannot display current region." );
  return;
    }

    QgsGrass::setLocation ( gisdbase, location );
    
    struct Cell_head window;
    char *err = G__get_window ( &window, "", "WIND", (char *) mapset.latin1() );

    if ( err ) {
  QMessageBox::warning( 0, "Warning", "Cannot read current region: " + QString(err) );
  return;
    }

    std::vector<QgsPoint> points;
    points.resize(5);
    
    points[0].setX(window.west); points[0].setY(window.south);
    points[1].setX(window.east); points[1].setY(window.south);
    points[2].setX(window.east); points[2].setY(window.north);
    points[3].setX(window.west); points[3].setY(window.north);
    points[4].setX(window.west); points[4].setY(window.south);

    QgsCoordinateTransform *transform = mCanvas->getCoordinateTransform();
    QPointArray pointArray(5);

    for ( int i = 0; i < 5; i++ ) {
        transform->transform( &(points[i]) );
        pointArray.setPoint( i, 
                             static_cast<int>(points[i].x()), 
                             static_cast<int>(points[i].y()) );
    }

    painter->setPen ( mRegionPen );
    painter->drawPolyline ( pointArray );
}

00342 void QgsGrassPlugin::changeRegion(void)
{
    #ifdef QGISDEBUG
    std::cout << "QgsGrassPlugin::changeRegion()" << std::endl;
    #endif

    if ( QgsGrassRegion::isRunning() ) {
  QMessageBox::warning( 0, "Warning", "The Region tool is already running." );
  return;
    }

    QgsGrassRegion *reg = new QgsGrassRegion(this, qgisMainWindowPointer, qGisInterface, 
                           qgisMainWindowPointer, 0, 
         Qt::WType_Dialog );

    reg->show();
}

00360 QPen & QgsGrassPlugin::regionPen()
{
    return mRegionPen;
}

00365 void QgsGrassPlugin::setRegionPen(QPen & pen)
{
    mRegionPen = pen;
    
    QSettings settings;
    settings.writeEntry ("/qgis/grass/region/color", mRegionPen.color().name() );
    settings.writeEntry ("/qgis/grass/region/width", (int) mRegionPen.width() );
}

// Unload the plugin by cleaning up the GUI
00375 void QgsGrassPlugin::unload()
{
    // remove the GUI
    if ( menuBarPointer )
        menuBarPointer->removeItem(menuIdInt);

    if ( toolBarPointer )
        delete toolBarPointer;
}
/** 
 * 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
extern "C" QgisPlugin * classFactory(QgisApp * theQGisAppPointer, QgisIface * theQgisInterfacePointer)
{
    return new QgsGrassPlugin(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.
extern "C" QString name()
{
    return QString("GRASS");
}

// Return the description
extern "C" QString description()
{
    return QString("GRASS layer");
}

// Return the type (either UI or MapLayer plugin)
extern "C" int type()
{
    return QgisPlugin::UI;
}

// Return the version number for the plugin
extern "C" QString version()
{
    return pluginVersion;
}

// Delete ourself
extern "C" void unload(QgisPlugin * thePluginPointer)
{
    delete thePluginPointer;
}

Generated by  Doxygen 1.6.0   Back to index