QGIS » QGIS Application

#include <QBitmap>

#include <QCheckBox>

#include <QDockWidget>

#include <QLineEdit>

#include <QMenu>

#include <QMenuBar>

#include <QMessageBox>

#include <QProgressBar>

#include <QStatusBar>

#include <QToolButton>

#include "qgisapp.h"

#include "qgsapplication.h"

#include "qgscursors.h"

#include "qgslegend.h"

#include "qgsmapcanvas.h"

#include "qgsmaplayerregistry.h"

#include "qgsmapoverviewcanvas.h"

#include "qgsmaptip.h"

#include "qgsproject.h"

// map tools

#include "qgsmaptooladdfeature.h"

#include "qgsmaptooladdisland.h"

#include "qgsmaptooladdring.h"

#include "qgsmaptooladdvertex.h"

#include "qgsmaptooldeletering.h"

#include "qgsmaptooldeletepart.h"

#include "qgsmaptooldeletevertex.h"

#include "qgsmaptoolidentify.h"

#include "qgsmaptoolmovefeature.h"

#include "qgsmaptoolmovevertex.h"

#include "qgsmaptoolnodetool.h"

#include "qgsmaptoolpan.h"

#include "qgsmaptoolselect.h"

#include "qgsmaptoolsplitfeatures.h"

#include "qgsmaptoolvertexedit.h"

#include "qgsmaptoolzoom.h"

#include "qgsmaptoolsimplify.h"

#include "qgsmeasuretool.h"

#include "tabs/qgsdesktabwidget.h"

#include "qgsframewidget.h"

QgsFrameWidget::QgsFrameWidget( QgisApp *qgis )

    : mQgis(qgis)

{

  setObjectName( "theFrameWidget" );

  createStatusBar();

  createCanvas();

  createLegend();

  createOverview();

  createMapTips();

  mMapTipsVisible = false;

  mQgisMenuBar = qgis->menuBar();

}

QgsFrameWidget::~QgsFrameWidget()

{

  delete mMapOverviewCanvas;

  delete mLegend;

  delete mTools;

  delete mMapCanvas;

}

// ------------------------------- public ---------------------------------- //

void QgsFrameWidget::setupConnections()

{

  // connect map layer registry signals to legend

  connect( QgsMapLayerRegistry::instance(), SIGNAL( layerWillBeRemoved( QString ) ),

           mLegend, SLOT( removeLayer( QString ) ) );

  connect( QgsMapLayerRegistry::instance(), SIGNAL( removedAll() ),

           mLegend, SLOT( removeAll() ) );

  connect( QgsMapLayerRegistry::instance(), SIGNAL( layerWasAdded( QgsMapLayer* ) ),

           mLegend, SLOT( addLayer( QgsMapLayer * ) ) );

  connect( mLegend, SIGNAL( currentLayerChanged( QgsMapLayer* ) ),

           mQgis, SLOT( activateDeactivateLayerRelatedActions( QgsMapLayer* ) ) );

  connect( QgsMapLayerRegistry::instance(), SIGNAL( layerWasAdded( QgsMapLayer* ) ),

           this, SLOT( layerWasAdded( QgsMapLayer * ) ) );

  //signal when mouse moved over window ( coords display in status bar )

  connect( mMapCanvas, SIGNAL( xyCoordinates( const QgsPoint & ) ), this, SLOT( showMouseCoordinate( const QgsPoint & ) ) );

  connect( mMapCanvas->mapRenderer(), SIGNAL( drawingProgress( int, int ) ), this, SLOT( showProgress( int, int ) ) );

  connect( mMapCanvas->mapRenderer(), SIGNAL( hasCrsTransformEnabled( bool ) ), this, SLOT( hasCrsTransformEnabled( bool ) ) );

  connect( mMapCanvas->mapRenderer(), SIGNAL( destinationSrsChanged() ), this, SLOT( destinationSrsChanged() ) );

  connect( mMapCanvas, SIGNAL( extentsChanged() ), this, SLOT( showExtents() ) );

  connect( mMapCanvas, SIGNAL( scaleChanged( double ) ), this, SLOT( showScale( double ) ) );

  connect( mMapCanvas, SIGNAL( scaleChanged( double ) ), this, SLOT( updateMouseCoordinatePrecision() ) );

  connect( mMapCanvas, SIGNAL( mapToolSet( QgsMapTool * ) ), this, SLOT( mapToolChanged( QgsMapTool * ) ) );

  connect( mMapCanvas, SIGNAL( selectionChanged( QgsMapLayer * ) ),

           mQgis, SLOT( activateDeactivateLayerRelatedActions( QgsMapLayer * ) ) );

  connect( mRenderSuppressionCBox, SIGNAL( toggled( bool ) ), mMapCanvas, SLOT( setRenderFlag( bool ) ) );

  connect( mStopRenderButton, SIGNAL( clicked() ), mQgis, SLOT( stopRendering() ) );

  connect( QgsProject::instance(), SIGNAL( layerLoaded( int, int ) ), this, SLOT( showProgress( int, int ) ) );

} // setupConnections

void QgsFrameWidget::removeConnections()

{

  // disconnect map layer registry signals to legend

  disconnect( QgsMapLayerRegistry::instance(), SIGNAL( layerWillBeRemoved( QString ) ),

              mLegend, SLOT( removeLayer( QString ) ) );

  disconnect( QgsMapLayerRegistry::instance(), SIGNAL( removedAll() ),

              mLegend, SLOT( removeAll() ) );

  disconnect( QgsMapLayerRegistry::instance(), SIGNAL( layerWasAdded( QgsMapLayer* ) ),

              mLegend, SLOT( addLayer( QgsMapLayer * ) ) );

  disconnect( mLegend, SIGNAL( currentLayerChanged( QgsMapLayer* ) ),

              mQgis, SLOT( activateDeactivateLayerRelatedActions( QgsMapLayer* ) ) );

  disconnect( QgsMapLayerRegistry::instance(), SIGNAL( layerWasAdded( QgsMapLayer* ) ),

              this, SLOT( layerWasAdded( QgsMapLayer * ) ) );

  //signal when mouse moved over window ( coords display in status bar )

  disconnect( mMapCanvas, SIGNAL( xyCoordinates( const QgsPoint & ) ), this, SLOT( showMouseCoordinate( const QgsPoint & ) ) );

  disconnect( mMapCanvas->mapRenderer(), SIGNAL( drawingProgress( int, int ) ), this, SLOT( showProgress( int, int ) ) );

  disconnect( mMapCanvas->mapRenderer(), SIGNAL( hasCrsTransformEnabled( bool ) ), this, SLOT( hasCrsTransformEnabled( bool ) ) );

  disconnect( mMapCanvas->mapRenderer(), SIGNAL( destinationSrsChanged() ), this, SLOT( destinationSrsChanged() ) );

  disconnect( mMapCanvas, SIGNAL( extentsChanged() ), this, SLOT( showExtents() ) );

  disconnect( mMapCanvas, SIGNAL( scaleChanged( double ) ), this, SLOT( showScale( double ) ) );

  disconnect( mMapCanvas, SIGNAL( scaleChanged( double ) ), this, SLOT( updateMouseCoordinatePrecision() ) );

  disconnect( mMapCanvas, SIGNAL( mapToolSet( QgsMapTool * ) ), this, SLOT( mapToolChanged( QgsMapTool * ) ) );

  disconnect( mMapCanvas, SIGNAL( selectionChanged( QgsMapLayer * ) ),

              mQgis, SLOT( activateDeactivateLayerRelatedActions( QgsMapLayer * ) ) );

  disconnect( mRenderSuppressionCBox, SIGNAL( toggled( bool ) ), mMapCanvas, SLOT( setRenderFlag( bool ) ) );

  disconnect( mStopRenderButton, SIGNAL( clicked() ), mQgis, SLOT( stopRendering() ) );

  disconnect( QgsProject::instance(), SIGNAL( layerLoaded( int, int ) ), this, SLOT( showProgress( int, int ) ) );

} // removeConnections

void QgsFrameWidget::saveState()

{

  mQgisState = mQgis->saveState();

  if (mQgisMenuBar->isVisible())

  {

    mQgisMenuBar->close();

    mQgisMenuBar->setParent(0);

  }

}

void QgsFrameWidget::restoreState()

{

  QList< QToolBar * > tbs = mQgis->findChildren< QToolBar * >();

  foreach( QToolBar *tb, tbs)

    tb->hide();

  if (mQgisMenuBar->isHidden())

  {

    mQgis->menuBar()->close();

    mQgis->menuBar()->setParent(0);

    mQgis->setMenuBar(mQgisMenuBar);

    mQgis->menuBar()->show();

  }

  mQgis->restoreState(mQgisState);

}

// ----------------------------- private slots ----------------------------- //

void QgsFrameWidget::destinationSrsChanged()

{

  // save this information to project

  long srsid = mMapCanvas->mapRenderer()->destinationSrs().srsid();

  QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCRSID", ( int )srsid );

}

// slot to update the progress bar in the status bar

void QgsFrameWidget::hasCrsTransformEnabled( bool theFlag )

{

  // save this information to project

  QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectionsEnabled", ( theFlag ? 1 : 0 ) );

  // update icon

  if ( theFlag )

  {

    mOnTheFlyProjectionStatusButton->setIcon(

        mQgis->getThemeIcon( "mIconProjectionEnabled.png" ) );

  }

  else

  {

    mOnTheFlyProjectionStatusButton->setIcon(

        mQgis->getThemeIcon( "mIconProjectionDisabled.png" ) );

  }

}

void QgsFrameWidget::mapToolChanged( QgsMapTool *tool )

{

  if ( tool )

  {

    if ( !tool->isEditTool() )

    {

      mQgis->mNonEditMapTool = tool;

    }

    mTools->mCurrentTool = tool;

  }

}

void QgsFrameWidget::projectPropertiesProjections()

{

  // Driver to display the project props dialog and switch to the

  // projections tab

  mQgis->mShowProjectionTab = true;

  mQgis->projectProperties();

}

void QgsFrameWidget::showProgress( int theProgress, int theTotalSteps )

{

  if ( theProgress == theTotalSteps )

  {

    mProgressBar->reset();

    mProgressBar->hide();

  }

  else

  {

    //only call show if not already hidden to reduce flicker

    if ( !mProgressBar->isVisible() )

    {

      mProgressBar->show();

    }

    mProgressBar->setMaximum( theTotalSteps );

    mProgressBar->setValue( theProgress );

  }

}

void QgsFrameWidget::showMouseCoordinate( const QgsPoint & p )

{

  if ( mMapTipsVisible )

  {

    // store the point, we need it for when the maptips timer fires

    mLastMapPosition = p;

    // we use this slot to control the timer for maptips since it is fired each time

    // the mouse moves.

    if ( mMapCanvas->underMouse() )

    {

      // Clear the maptip (this is done conditionally)

      mpMaptip->clear( mMapCanvas );

      // don't start the timer if the mouse is not over the map canvas

      mpMapTipsTimer->start();

      //QgsDebugMsg("Started maptips timer");

    }

  }

  if ( mToggleExtentsViewButton->isChecked() )

  {

    //we are in show extents mode so no need to do anything

    return;

  }

  else

  {

    mCoordsLabel->setText( p.toString( mMousePrecisionDecimalPlaces ) );

    // Set minimum necessary width

    if ( mCoordsLabel->width() > mCoordsLabel->minimumWidth() )

    {

      mCoordsLabel->setMinimumWidth( mCoordsLabel->width() );

    }

  }

}

void QgsFrameWidget::showScale( double theScale )

{

  if ( theScale >= 1.0 )

    mScaleEdit->setText( "1:" + QString::number( theScale, 'f', 0 ) );

  else if ( theScale > 0.0 )

    mScaleEdit->setText( QString::number( 1.0 / theScale, 'f', 0 ) + ":1" );

  else

    mScaleEdit->setText( tr( "Invalid scale" ) );

  // Set minimum necessary width

  if ( mScaleEdit->width() > mScaleEdit->minimumWidth() )

  {

    mScaleEdit->setMinimumWidth( mScaleEdit->width() );

  }

}

void QgsFrameWidget::showExtents()

{

  if ( !mToggleExtentsViewButton->isChecked() )

  {

    //we are in show coords mode so no need to do anything

    return;

  }

  // update the statusbar with the current extents.

  QgsRectangle myExtents = mMapCanvas->extent();

  mCoordsLabel->setText( tr( "Extents: %1" ).arg( myExtents.toString( true ) ) );

  //ensure the label is big enough

  if ( mCoordsLabel->width() > mCoordsLabel->minimumWidth() )

  {

    mCoordsLabel->setMinimumWidth( mCoordsLabel->width() );

  }

}

void QgsFrameWidget::showMapTip()

{

  /* Show the maptip using tooltip */

  // Stop the timer while we look for a maptip

  mpMapTipsTimer->stop();

  // Only show tooltip if the mouse is over the canvas

  if ( mMapCanvas->underMouse() )

  {

    QPoint myPointerPos = mMapCanvas->mouseLastXY();

    //  Make sure there is an active layer before proceeding

    QgsMapLayer* mypLayer = mMapCanvas->currentLayer();

    if ( mypLayer )

    {

      //QgsDebugMsg("Current layer for maptip display is: " + mypLayer->source());

      // only process vector layers

      if ( mypLayer->type() == QgsMapLayer::VectorLayer )

      {

        // Show the maptip if the maptips button is depressed

        if ( mMapTipsVisible )

        {

          mpMaptip->showMapTip( mypLayer, mLastMapPosition, myPointerPos, mMapCanvas );

        }

      }

    }

    else

    {

      mStatusBar->showMessage( tr( "Maptips require an active layer" ) );

    }

  }

}

void QgsFrameWidget::extentsViewToggled( bool theFlag )

{

  if ( theFlag )

  {

    //extents view mode!

    mToggleExtentsViewButton->setIcon( mQgis->getThemeIcon( "extents.png" ) );

    mCoordsLabel->setToolTip( tr( "Map coordinates for the current view extents" ) );

    showExtents();

  }

  else

  {

    //mouse cursor pos view mode!

    mToggleExtentsViewButton->setIcon( mQgis->getThemeIcon( "tracking.png" ) );

    mCoordsLabel->setToolTip( tr( "Map coordinates at mouse cursor position" ) );

  }

}

void QgsFrameWidget::updateMouseCoordinatePrecision()

{

  // Work out what mouse display precision to use. This only needs to

  // be when the settings change or the zoom level changes. This

  // function needs to be called every time one of the above happens.

  // Get the display precision from the project settings

  bool automatic = QgsProject::instance()->readBoolEntry( "PositionPrecision", "/Automatic" );

  int dp = 0;

  if ( automatic )

  {

    // Work out a suitable number of decimal places for the mouse

    // coordinates with the aim of always having enough decimal places

    // to show the difference in position between adjacent pixels.

    // Also avoid taking the log of 0.

    if ( mMapCanvas->mapUnitsPerPixel() != 0.0 )

      dp = static_cast<int>( ceil( -1.0 * log10( mMapCanvas->mapUnitsPerPixel() ) ) );

  }

  else

    dp = QgsProject::instance()->readNumEntry( "PositionPrecision", "/DecimalPlaces" );

  // Keep dp sensible

  if ( dp < 0 ) dp = 0;

  mMousePrecisionDecimalPlaces = dp;

}

void QgsFrameWidget::userScale()

{

  double currentScale = mMapCanvas->scale();

  QStringList parts = mScaleEdit->text().split( ':' );

  if ( parts.size() == 2 )

  {

    bool leftOk, rightOk;

    double leftSide = parts.at( 0 ).toDouble( &leftOk );

    double rightSide = parts.at( 1 ).toDouble( &rightOk );

    if ( leftSide > 0.0 && leftOk && rightOk )

    {

      double wantedScale = rightSide / leftSide;

      mMapCanvas->zoomByFactor( wantedScale / currentScale );

    }

  }

}

void QgsFrameWidget::userCenter()

{

  QStringList parts = mCoordsEdit->text().split( ',' );

  if ( parts.size() != 2 )

    return;

  bool xOk;

  double x = parts.at( 0 ).toDouble( &xOk );

  if ( !xOk )

    return;

  bool yOk;

  double y = parts.at( 1 ).toDouble( &yOk );

  if ( !yOk )

    return;

  QgsRectangle r = mMapCanvas->extent();

  mMapCanvas->setExtent(

      QgsRectangle(

          x - r.width() / 2.0,  y - r.height() / 2.0,

          x + r.width() / 2.0, y + r.height() / 2.0

          )

      );

  mMapCanvas->refresh();

}

void QgsFrameWidget::layerWasAdded( QgsMapLayer *layer )

{

  if ( layer->type() == QgsMapLayer::RasterLayer )

  {

    QObject::connect( layer,

                      SIGNAL( drawingProgress( int, int ) ),

                      this,

                      SLOT( showProgress( int, int ) ) );

    // connect up any request the raster may make to update the statusbar message

    QObject::connect( layer,

                      SIGNAL( statusChanged( QString ) ),

                      mStatusBar,

                      SLOT( showMessage( QString ) ) );

  }

}

// ------------------------------- private --------------------------------- //

void QgsFrameWidget::createCanvas()

{

  // create map canvas and tools

  mMapCanvas = new QgsMapCanvas( this );

  mTools = new QgisApp::Tools();

  setToolsForMapCanvas( mMapCanvas, mTools );

  mMapCanvas->setObjectName( "theMapCanvas" );

  // set canvas color in map canvas

  int  redInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorRedPart", 255 );

  int  greenInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorGreenPart", 255 );

  int  blueInt = QgsProject::instance()->readNumEntry( "Gui", "/CanvasColorBluePart", 255 );

  QColor color = QColor( redInt, greenInt, blueInt );

  mMapCanvas->setCanvasColor( color ); // this is fill colour before rendering onto canvas

  // set initial extent for map canvas

  QRect tabRect = mQgis->deskTabWidget()->rect();

  QgsRectangle initExtent(tabRect.x(), tabRect.y(), tabRect.width(), tabRect.height());

  mMapCanvas->setExtent(initExtent);

}

void QgsFrameWidget::createLegend()

{

  // create map legend for map canvas

  mLegend = new QgsLegend( NULL, "theMapLegend" );

  mLegend->setObjectName( "theMapLegend" );

  mLegend->setMapCanvas( mMapCanvas );

  // add the toggle editing action also to legend such that right click menu and button show the same state

  mLegend->setToggleEditingAction( mQgis->actionToggleEditing() );

  mLegend->setWhatsThis( tr( "Map legend that displays all the layers currently on the map canvas."

                                "Click on the check box to turn a layer on or off. Double click on a layer"

                                "in the legend to customize its appearance and set other properties." ) );

}

void QgsFrameWidget::createOverview()

{

  // create overview canvas

  mMapOverviewCanvas = new QgsMapOverviewCanvas( NULL, mMapCanvas );

  mMapOverviewCanvas->setWhatsThis( tr( "Map overview canvas. This canvas can be used to display a locator map"

                                        "that shows the current extent of the map canvas. The current extent is shown as"

                                        "a red rectangle. Any layer on the map can be added to the overview canvas." ) );

  QBitmap overviewPanBmp = QBitmap::fromData( QSize( 16, 16 ), pan_bits );

  QBitmap overviewPanBmpMask = QBitmap::fromData( QSize( 16, 16 ), pan_mask_bits );

  //set upper left corner as hot spot - this is better when extent marker is small; hand won't cover the marker

  mQgis->mOverviewMapCursor = new QCursor( overviewPanBmp, overviewPanBmpMask, 0, 0 );

  mMapOverviewCanvas->setCursor( *mQgis->mOverviewMapCursor );

  mMapCanvas->enableOverviewMode( mMapOverviewCanvas );

  // moved here to set anti aliasing to both map canvas and overview

  QSettings mySettings;

  mMapCanvas->enableAntiAliasing( mySettings.value( "/qgis/enable_anti_aliasing", false ).toBool() );

  mMapCanvas->useImageToRender( mySettings.value( "/qgis/use_qimage_to_render", false ).toBool() );

  int action = mySettings.value( "/qgis/wheel_action", 0 ).toInt();

  double zoomFactor = mySettings.value( "/qgis/zoom_factor", 2 ).toDouble();

  mMapCanvas->setWheelAction(( QgsMapCanvas::WheelAction ) action, zoomFactor );

}

void QgsFrameWidget::createMapTips()

{

  // Set up the timer for maptips. The timer is reset everytime the mouse is moved

  mpMapTipsTimer = new QTimer( mMapCanvas );

  // connect the timer to the maptips slot

  connect( mpMapTipsTimer, SIGNAL( timeout() ), this, SLOT( showMapTip() ) );

  // set the interval to 0.850 seconds - timer will be started next time the mouse moves

  mpMapTipsTimer->setInterval( 850 );

  // Create the maptips object

  mpMaptip = new QgsMapTip();

}

void QgsFrameWidget::createStatusBar()

{

  mStatusBar = new QStatusBar;

  //

  // Add a panel to the status bar for the scale, coords and progress

  // And also rendering suppression checkbox

  //

  mProgressBar = new QProgressBar( mStatusBar );

  mProgressBar->setMaximumWidth( 100 );

  mProgressBar->hide();

  mProgressBar->setWhatsThis( tr( "Progress bar that displays the status "

                                  "of rendering layers and other time-intensive operations" ) );

  mStatusBar->addPermanentWidget( mProgressBar, 1 );

  // Bumped the font up one point size since 8 was too

  // small on some platforms. A point size of 9 still provides

  // plenty of display space on 1024x768 resolutions

  QFont myFont( "Arial", 9 );

  mStatusBar->setFont( myFont );

  //toggle to switch between mouse pos and extents display in status bar widget

  mToggleExtentsViewButton = new QToolButton( mStatusBar );

  mToggleExtentsViewButton->setMaximumWidth( 20 );

  mToggleExtentsViewButton->setMaximumHeight( 20 );

  mToggleExtentsViewButton->setIcon( mQgis->getThemeIcon( "tracking.png" ) );

  mToggleExtentsViewButton->setToolTip( tr( "Toggle extents and mouse position display" ) );

  mToggleExtentsViewButton->setCheckable( true );

  connect( mToggleExtentsViewButton, SIGNAL( toggled( bool ) ), this, SLOT( extentsViewToggled( bool ) ) );

  mStatusBar->addPermanentWidget( mToggleExtentsViewButton, 0 );

  // add a label to show current scale

  mCoordsLabel = new QLabel( QString(), mStatusBar );

  mCoordsLabel->setFont( myFont );

  mCoordsLabel->setMinimumWidth( 10 );

  mCoordsLabel->setMaximumHeight( 20 );

  mCoordsLabel->setMargin( 3 );

  mCoordsLabel->setAlignment( Qt::AlignCenter );

  mCoordsLabel->setFrameStyle( QFrame::NoFrame );

  mCoordsLabel->setText( tr( "Coordinate:" ) );

  mCoordsLabel->setToolTip( tr( "Current map coordinate" ) );

  mStatusBar->addPermanentWidget( mCoordsLabel, 0 );

  //coords status bar widget

  mCoordsEdit = new QLineEdit( QString(), mStatusBar );

  mCoordsEdit->setFont( myFont );

  mCoordsEdit->setMinimumWidth( 10 );

  mCoordsEdit->setMaximumWidth( 200 );

  mCoordsEdit->setMaximumHeight( 20 );

  mCoordsEdit->setContentsMargins( 0, 0, 0, 0 );

  mCoordsEdit->setAlignment( Qt::AlignCenter );

  mCoordsEdit->setAlignment( Qt::AlignCenter );

  QRegExp coordValidator( "[+-]?\\d+\\.?\\d*\\s*,\\s*[+-]?\\d+\\.?\\d*" );

  mCoordsEditValidator = new QRegExpValidator( coordValidator, mCoordsEdit );

  mCoordsEdit->setWhatsThis( tr( "Shows the map coordinates at the "

                                 "current cursor position. The display is continuously updated "

                                 "as the mouse is moved. It also allows editing to set the canvas "

                                 "center to a given position." ) );

  mCoordsEdit->setToolTip( tr( "Current map coordinate (formatted as x,y)" ) );

  mStatusBar->addPermanentWidget( mCoordsEdit, 0 );

  connect( mCoordsEdit, SIGNAL( editingFinished() ), this, SLOT( userCenter() ) );

  // add a label to show current scale

  mScaleLabel = new QLabel( QString(), mStatusBar );

  mScaleLabel->setFont( myFont );

  mScaleLabel->setMinimumWidth( 10 );

  mScaleLabel->setMaximumHeight( 20 );

  mScaleLabel->setMargin( 3 );

  mScaleLabel->setAlignment( Qt::AlignCenter );

  mScaleLabel->setFrameStyle( QFrame::NoFrame );

  mScaleLabel->setText( tr( "Scale " ) );

  mScaleLabel->setToolTip( tr( "Current map scale" ) );

  mStatusBar->addPermanentWidget( mScaleLabel, 0 );

  mScaleEdit = new QLineEdit( QString(), mStatusBar );

  mScaleEdit->setFont( myFont );

  mScaleEdit->setMinimumWidth( 10 );

  mScaleEdit->setMaximumWidth( 100 );

  mScaleEdit->setMaximumHeight( 20 );

  mScaleEdit->setContentsMargins( 0, 0, 0, 0 );

  mScaleEdit->setAlignment( Qt::AlignLeft );

  QRegExp validator( "\\d+\\.?\\d*:\\d+\\.?\\d*" );

  mScaleEditValidator = new QRegExpValidator( validator, mScaleEdit );

  mScaleEdit->setValidator( mScaleEditValidator );

  mScaleEdit->setWhatsThis( tr( "Displays the current map scale" ) );

  mScaleEdit->setToolTip( tr( "Current map scale (formatted as x:y)" ) );

  mStatusBar->addPermanentWidget( mScaleEdit, 0 );

  connect( mScaleEdit, SIGNAL( editingFinished() ), this, SLOT( userScale() ) );

  //stop rendering status bar widget

  mStopRenderButton = new QToolButton( mStatusBar );

  mStopRenderButton->setMaximumWidth( 20 );

  mStopRenderButton->setMaximumHeight( 20 );

  mStopRenderButton->setIcon( mQgis->getThemeIcon( "mIconDelete.png" ) );

  mStopRenderButton->setToolTip( tr( "Stop map rendering" ) );

  mStatusBar->addPermanentWidget( mStopRenderButton, 0 );

  // render suppression status bar widget

  mRenderSuppressionCBox = new QCheckBox( tr( "Render" ), mStatusBar );

  mRenderSuppressionCBox->setChecked( true );

  mRenderSuppressionCBox->setFont( myFont );

  mRenderSuppressionCBox->setWhatsThis( tr( "When checked, the map layers "

                                            "are rendered in response to map navigation commands and other "

                                            "events. When not checked, no rendering is done. This allows you "

                                            "to add a large number of layers and symbolize them before rendering." ) );

  mRenderSuppressionCBox->setToolTip( tr( "Toggle map rendering" ) );

  mStatusBar->addPermanentWidget( mRenderSuppressionCBox, 0 );

  // On the fly projection status bar icon

  // Changed this to a tool button since a QPushButton is

  // sculpted on OS X and the icon is never displayed [gsherman]

  mOnTheFlyProjectionStatusButton = new QToolButton( mStatusBar );

  mOnTheFlyProjectionStatusButton->setMaximumWidth( 20 );

  // Maintain uniform widget height in status bar by setting button height same as labels

  // For Qt/Mac 3.3, the default toolbutton height is 30 and labels were expanding to match

  mOnTheFlyProjectionStatusButton->setMaximumHeight( mScaleLabel->height() );

  mOnTheFlyProjectionStatusButton->setIcon( mQgis->getThemeIcon( "mIconProjectionDisabled.png" ) );

  if ( !QFile::exists( QgsApplication::defaultThemePath() + "/mIconProjectionDisabled.png" ) )

  {

    QMessageBox::critical( this, tr( "Resource Location Error" ),

                           tr( "Error reading icon resources from: \n %1\n Quitting..." ).arg(

                               QgsApplication::defaultThemePath() + "/mIconProjectionDisabled.png"

                               ) );

    exit( 0 );

  }

  mOnTheFlyProjectionStatusButton->setWhatsThis( tr( "This icon shows whether "

                                                     "on the fly coordinate reference system transformation is enabled or not. "

                                                     "Click the icon to bring up "

                                                     "the project properties dialog to alter this behaviour." ) );

  mOnTheFlyProjectionStatusButton->setToolTip( tr( "CRS status - Click "

                                                   "to open coordinate reference system dialog" ) );

  connect( mOnTheFlyProjectionStatusButton, SIGNAL( clicked() ),

           this, SLOT( projectPropertiesProjections() ) );//bring up the project props dialog when clicked

  mStatusBar->addPermanentWidget( mOnTheFlyProjectionStatusButton, 0 );

  mStatusBar->showMessage( tr( "Ready" ) );

}

void QgsFrameWidget::setToolsForMapCanvas( QgsMapCanvas *theMapCanvas, QgisApp::Tools *theMapTools )

{

  // "theMapCanvas" used to find this canonical instance later

  theMapCanvas->setWhatsThis( tr( "Map canvas. This is where raster and vector "

                                  "layers are displayed when added to the map" ) );

  // set the focus to the map canvas

  theMapCanvas->setFocus();

  // create tools

  theMapTools->mZoomIn = new QgsMapToolZoom( theMapCanvas, false /* zoomIn */ );

  theMapTools->mZoomIn->setAction( mQgis->actionZoomIn() );

  theMapTools->mZoomOut = new QgsMapToolZoom( theMapCanvas, true /* zoomOut */ );

  theMapTools->mZoomOut->setAction( mQgis->actionZoomOut() );

  theMapTools->mPan = new QgsMapToolPan( theMapCanvas );

  theMapTools->mPan->setAction( mQgis->actionPan() );

  theMapTools->mIdentify = new QgsMapToolIdentify( theMapCanvas );

  theMapTools->mIdentify->setAction( mQgis->actionIdentify() );

  theMapTools->mMeasureDist = new QgsMeasureTool( theMapCanvas, false /* area */ );

  theMapTools->mMeasureDist->setAction( mQgis->actionMeasure() );

  theMapTools->mMeasureArea = new QgsMeasureTool( theMapCanvas, true /* area */ );

  theMapTools->mMeasureArea->setAction( mQgis->actionMeasureArea() );

  theMapTools->mCapturePoint = new QgsMapToolAddFeature( theMapCanvas, QgsMapToolCapture::CapturePoint );

  theMapTools->mCapturePoint->setAction( mQgis->actionCapturePoint() );

  mQgis->actionCapturePoint()->setVisible( false );

  theMapTools->mCaptureLine = new QgsMapToolAddFeature( theMapCanvas, QgsMapToolCapture::CaptureLine );

  theMapTools->mCaptureLine->setAction( mQgis->actionCaptureLine() );

  mQgis->actionCaptureLine()->setVisible( false );

  theMapTools->mCapturePolygon = new QgsMapToolAddFeature( theMapCanvas, QgsMapToolCapture::CapturePolygon );

  theMapTools->mCapturePolygon->setAction( mQgis->actionCapturePolygon() );

  mQgis->actionCapturePolygon()->setVisible( false );

  theMapTools->mMoveFeature = new QgsMapToolMoveFeature( theMapCanvas );

  theMapTools->mMoveFeature->setAction( mQgis->actionMoveFeature() );

  theMapTools->mSplitFeatures = new QgsMapToolSplitFeatures( theMapCanvas );

  theMapTools->mSplitFeatures->setAction( mQgis->actionSplitFeatures() );

  theMapTools->mSelect = new QgsMapToolSelect( theMapCanvas );

  theMapTools->mSelect->setAction( mQgis->actionSelect() );

  theMapTools->mVertexAdd = new QgsMapToolAddVertex( theMapCanvas );

  theMapTools->mVertexAdd->setAction( mQgis->actionAddVertex() );

  theMapTools->mVertexMove = new QgsMapToolMoveVertex( theMapCanvas );

  theMapTools->mVertexMove->setAction( mQgis->actionMoveVertex() );

  theMapTools->mVertexDelete = new QgsMapToolDeleteVertex( theMapCanvas );

  theMapTools->mVertexDelete->setAction( mQgis->actionDeleteVertex() );

  theMapTools->mAddRing = new QgsMapToolAddRing( theMapCanvas );

  theMapTools->mAddRing->setAction( mQgis->actionAddRing() );

  theMapTools->mAddIsland = new QgsMapToolAddIsland( theMapCanvas );

  theMapTools->mSimplifyFeature = new QgsMapToolSimplify( theMapCanvas );

  theMapTools->mSimplifyFeature->setAction( mQgis->actionSimplifyFeature() );

  theMapTools->mDeleteRing = new QgsMapToolDeleteRing( theMapCanvas );

  theMapTools->mDeleteRing->setAction( mQgis->actionDeleteRing() );

  theMapTools->mDeletePart = new QgsMapToolDeletePart( theMapCanvas );

  theMapTools->mDeletePart->setAction( mQgis->actionDeletePart() );

  theMapTools->mNodeTool = new QgsMapToolNodeTool( theMapCanvas );

  theMapTools->mNodeTool->setAction( mQgis->actionNodeTool() );

  // set a current map tool

  theMapTools->mCurrentTool = theMapTools->mPan;

  //ensure that non edit tool is initialised or we will get crashes in some situations

  mQgis->mNonEditMapTool = theMapTools->mPan;

} // setToolsForMapCanvas

#ifdef HAVE_TABS

    /** Return a pointer to the main tab widget that containing map canvas */

    QgsDeskTabWidgetInterface * deskTabWidget();

#endif

#ifdef HAVE_TABS

#include "tabs/qgswidgetregistry.h"

#endif

#ifdef HAVE_TABS

#include <QDockWidget>

#include <QStatusBar>

#endif

#ifdef HAVE_TABS

void QgsComposer::prepareTabbing()

{

  QList< QToolBar * > tbs = mQgis->findChildren< QToolBar * >();

  foreach ( QToolBar *tb, tbs )

    tb->hide();

  QSize iconSize = mQgis->mapNavToolToolBar()->iconSize();

  toolBar->setIconSize(iconSize);

  mQgis->addToolBar( toolBar );

  toolBar->show();

  statusBar()->close();

  statusBar()->setParent(0);

  buttonBox->close();

  mComposerMenuBar = menuBar();

  mQgisStateByteArray = mQgis->saveState();

}

void QgsComposer::restoreState( int tabIndex )

{

  int i = QgsWidgetRegistry::tabIndexOf(this);

  if ( tabIndex == i )

  {

    mQgis->menuBar()->close();

    mQgis->menuBar()->setParent(0);

    mQgis->setMenuBar(mComposerMenuBar);

    mQgis->menuBar()->show();

    mQgis->restoreState(mQgisStateByteArray, tabIndex);

    mQgis->statusBar()->hide();

  }

  else if (mComposerMenuBar->isVisible())

  {

    mComposerMenuBar->close();

    mComposerMenuBar->setParent(0);

  }

}

#endif

#include "qgsconfig.h"

#ifdef HAVE_TABS

    void prepareTabbing();

#endif

#ifdef HAVE_TABS

    void restoreState(int tabIndex);

#endif

    // window state of composer

    QByteArray mQgisStateByteArray;

    // Composer menuBar

    QMenuBar *mComposerMenuBar;

#ifdef HAVE_TABS

class QgsFrameWidget;

class QgsMapOverviewCanvas;

class QgsDeskTabWidget;

class QgsLegendTabWidget;

class QgsAddTabDialog;

#endif

    QgsMapCanvas * mapCanvas() { return mMapCanvas; }

#ifdef HAVE_TABS

    /** Get the main (desk) tabwidget object from the app */

    QgsDeskTabWidget *deskTabWidget() { return mDeskTabWidget; }

    /** Get the legend tabwidget object from the app */

    QgsLegendTabWidget *legendTabWidget() { return mLegendTabWidget; }

    // Create print composer but don't add it in composer map

    QgsComposer *createPrintComposer(QString composerId);

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

    QAction *actionNewTab() { return mActionAddTabDialog; }

    QAction *actionNewCanvasTab() { return mActionCanvasTab; }

    QAction *actionCloseTab() { return mActionCloseTab; }

    QAction *actionRestoreTab() { return mActionRestoreTab; }

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

    void addTabDialog();

    void addCanvasTab();

    void closeTab();

    void restoreTab();

    void nextTab();

    void previousTab();

    void updateFrame( QgsFrameWidget *frame );

#endif

#ifndef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

#ifndef HAVE_TABS

#else

    void createLegendDock();

    void createOverviewDock();

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

    QAction *mActionAddTabDialog;

    QAction *mActionCanvasTab;

    QAction *mActionNextTab;

    QAction *mActionPreviousTab;

    QAction *mActionCloseTab;

    QAction *mActionRestoreTab;

#endif

#ifdef HAVE_TABS

        ~Tools();

#endif

#ifndef HAVE_TABS

#else

        QgsMapTool* mCurrentTool;

    } *mMapTools;

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

    friend class QgsFrameWidget;

    //! Desk (main) tab widget

    QgsDeskTabWidget *mDeskTabWidget;

    //! Map overview canvas

    QgsMapOverviewCanvas *mMapOverviewCanvas;

    //! Legend tab widget

    QgsLegendTabWidget *mLegendTabWidget;

    //! Dialog for adding tab

    QgsAddTabDialog *mAddTabDialog;

#endif

#ifdef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

#ifndef QGSFRAMEWIDGET_H

#define QGSFRAMEWIDGET_H

#include <QWidget>

#include "qgisapp.h"

// this class holds map canvas, map legend, and map overview canvas, map tools and statusbar

// it is used to communicate with class QgisApp

class QgsFrameWidget : public QWidget

{

  Q_OBJECT

public:

  QgsFrameWidget( QgisApp *qgis );

  ~QgsFrameWidget();

  QgsMapCanvas *mapCanvas() { return mMapCanvas; }

  QgsMapOverviewCanvas *mapOverviewCanvas() { return mMapOverviewCanvas; }

  QgsLegend *legend() { return mLegend; }

  QgisApp::Tools *tools() { return mTools; }

  QStatusBar *statusBar() { return mStatusBar; }

  void setupConnections();

  void removeConnections();

  void saveState();

  void restoreState();

private slots:

  void destinationSrsChanged();

  void hasCrsTransformEnabled( bool theFlag );

  void mapToolChanged( QgsMapTool *tool );

  void projectPropertiesProjections();

  void showProgress( int theProgress, int theTotalSteps );

  void showMouseCoordinate( const QgsPoint & p );

  void showScale( double theScale );

  void showExtents();

  void showMapTip();

  void extentsViewToggled( bool theFlag );

  void updateMouseCoordinatePrecision();

  void userScale();

  void userCenter();

  void layerWasAdded( QgsMapLayer *layer );

private:

  void createCanvas();

  void createLegend();

  void createOverview();

  void createMapTips();

  void createStatusBar();

  void setToolsForMapCanvas( QgsMapCanvas *theMapCanvas, QgisApp::Tools *theMapTools );

  QgsMapCanvas *mMapCanvas;

  QgsLegend *mLegend;

  QgsMapOverviewCanvas *mMapOverviewCanvas;

  QgisApp::Tools *mTools;

  QStatusBar *mStatusBar;

  //! Widget that will live in the statusbar to show progress of operations

  QProgressBar * mProgressBar;

  //! A toggle to switch between mouse coords and view extents display

  QToolButton * mToggleExtentsViewButton;

  //! Widget that will live in the statusbar to display coords

  QLabel * mCoordsLabel;

  //! Widget that will live on the statusbar to display "scale 1:"

  QLabel * mScaleLabel;

  //! Widget that will live in the statusbar to display and edit coords

  QLineEdit * mCoordsEdit;

  //! The validator for the mCoordsEdit

  QValidator * mCoordsEditValidator;

  //! Widget that will live on the statusbar to display scale value

  QLineEdit * mScaleEdit;

  //! The validator for the mScaleEdit

  QValidator * mScaleEditValidator;

  //! Button used to stop rendering

  QToolButton* mStopRenderButton;

  //! Widget used to suppress rendering

  QCheckBox * mRenderSuppressionCBox;

  //! Widget in status bar used to show status of on the fly projection

  QToolButton * mOnTheFlyProjectionStatusButton;

  //! The number of decimal places to use if not automatic

  unsigned int mMousePrecisionDecimalPlaces;

  /** Timer for map tips

     */

  QTimer *mpMapTipsTimer;

  /** Point of last mouse position in map coordinates (used with MapTips)

     */

  QgsPoint mLastMapPosition;

  /* Maptip object

     */

  QgsMapTip *  mpMaptip;

  // Flag to indicate if maptips are on or off

  bool mMapTipsVisible;

  // state of QGis for this frame

  QByteArray mQgisState;

  QgisApp *mQgis;

  // QGis menuBar

  QMenuBar *mQgisMenuBar;

};

#endif // QGSFRAMEWIDGET_H

IF (HAVE_TABS)

  SET (QGIS_APP_SRCS ${QGIS_APP_SRCS}

    qgsframewidget.cpp

  )

ENDIF (HAVE_TABS)

IF (HAVE_TABS)

  SET (QGIS_APP_MOC_HDRS ${QGIS_APP_MOC_HDRS}

    qgsframewidget.h

  )

ENDIF (HAVE_TABS)

#ifdef HAVE_TABS

#include "qgsframewidget.h"

#include "tabs/qgsaddtabdialog.h"

#include "tabs/qgsdesktabwidget.h"

#include "tabs/qgslegendtabwidget.h"

#include "tabs/qgswidgetregistry.h"

#endif

#ifdef HAVE_TABS

    mMapCanvas( 0 ),

    mMapLegend( 0 ),

#endif

#ifdef HAVE_TABS

  setDockOptions(QMainWindow::ForceTabbedDocks);

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

  createOverview();

  createOverviewDock();

#endif

#ifdef HAVE_TABS

  createLegendDock();

#else

#endif

#ifdef HAVE_TABS

  mAddTabDialog = new QgsAddTabDialog(); // Dialog for opening tabs

#endif

#ifndef HAVE_TABS

#endif

#ifndef HAVE_TABS

#endif

  delete mInternalClipboard;

  delete mQgisInterface;

#ifdef HAVE_TABS

  mActionAddTabDialog = new QAction( getThemeIcon( "mActionAddTabDialog.png" ), tr( "New &Tab" ), this );

  shortcuts->registerAction( mActionAddTabDialog, tr( "Ctrl+T", "New Tab" ) );

  //  mActionNewCanvas->setShortcut( QKeySequence::AddTab );

  mActionAddTabDialog->setStatusTip( tr( "New Tab" ) );

  connect( mActionAddTabDialog, SIGNAL( triggered() ), this, SLOT(addTabDialog()) );

  mActionCanvasTab = new QAction( getThemeIcon( "mActionCanvasTab.png" ), tr( "New &canvas" ), this );

//  shortcuts->registerAction( mActionCanvasTab, tr( "Ctrl+T", "New Canvas" ) );

  //  mActionNewCanvas->setShortcut( QKeySequence::AddTab );

  mActionCanvasTab->setStatusTip( tr( "New canvas" ) );

  connect( mActionCanvasTab, SIGNAL( triggered() ), this, SLOT(addCanvasTab()) );

  mActionCloseTab = new QAction( getThemeIcon( "mActionCloseTab.png" ), tr( "&Close Tab" ), this );

  shortcuts->registerAction( mActionCloseTab, tr( "Ctrl+W", "Close Tab" ) );

  //  mActionCloseTab->setShortcut( QKeySequence::Close );

  mActionCloseTab->setStatusTip( tr( "Close Tab" ) );

  connect( mActionCloseTab, SIGNAL( triggered() ), this, SLOT(closeTab()) );

  mActionRestoreTab = new QAction( getThemeIcon( "mActionRestoreTab.png" ), tr( "&Restore Tab" ), this );

  shortcuts->registerAction( mActionRestoreTab, tr( "Ctrl+Shift+T", "Restore Tab" ) );

  mActionRestoreTab->setStatusTip( tr( "Restore Tab" ) );

  mActionRestoreTab->setEnabled( false );

  connect( mActionRestoreTab, SIGNAL( triggered() ), this, SLOT(restoreTab()) );

  // create actions that helps user to navigate in tabs

  mActionNextTab = new QAction(this);

  shortcuts->registerAction( mActionNextTab, tr( "Ctrl+Tab", "Goto next tab" ) );

    mActionNextTab->setShortcut(QKeySequence::NextChild);

  connect(mActionNextTab, SIGNAL(triggered()), this, SLOT(nextTab()));

  addAction(mActionNextTab);

  mActionPreviousTab = new QAction(this);

  shortcuts->registerAction( mActionPreviousTab, tr( "Ctrl+Shift+Tab", "Goto previous tab" ) );

  //  mActionPreviousTab->setShortcut(QKeySequence::PreviousChild);

  connect(mActionPreviousTab, SIGNAL(triggered()), this, SLOT(previousTab()));

  addAction(mActionPreviousTab);

#endif

#ifdef HAVE_TABS

  mFileMenu->addAction( mActionAddTabDialog );

  mFileMenu->addAction( mActionCanvasTab );

#endif

#ifdef HAVE_TABS

  mFileMenu->addAction( mActionRestoreTab );

  mFileMenu->addAction( mActionCloseTab );

#endif

#ifndef HAVE_TABS

#endif

#ifdef HAVE_TABS

  mActionCanvasTab->setIcon( getThemeIcon( "/mActionCanvasTab.png" ) );

#endif

#ifdef HAVE_TABS

  mActionCloseTab->setIcon( getThemeIcon( "/mActionCloseTab.png" ) );

#endif

#ifndef HAVE_TABS