qgscomposition.cpp

一个非常好的GIS开源新版本

          mItems.push_back(m);
          m->setSelected ( true );//do we need this twice?

          if ( mSelectedItem ) {
            QgsComposerItem *coi = dynamic_cast <QgsComposerItem *> (mSelectedItem);
            coi->setSelected ( false );
          }

          m->setSelected ( true );
          mComposer->showItemOptions ( m->options() );
          mSelectedItem = dynamic_cast <QGraphicsItem *> (m);
        } else {
          mToolStep = 0;
        }
        mCanvas->update();
      }
      break;

    case AddPicture:
      {
        double w = mRectangleItem->rect().width();
        double h = mRectangleItem->rect().height();
        delete mRectangleItem;
        mRectangleItem = 0;

        QgsComposerPicture *pi = dynamic_cast <QgsComposerPicture*> (mNewCanvasItem);

        if ( w > 0 && h > 0 )
        {
	      mNewCanvasItem = 0; // !!! Must be before mComposer->selectItem()
	      mComposer->selectItem(); // usually just one ???

          pi->writeSettings();
          mItems.push_back(pi);

          pi->setSelected ( true );
          mComposer->showItemOptions ( pi->options() );
          mSelectedItem = dynamic_cast <QGraphicsItem*> (pi);

          mCanvas->update();

        } else {
            mToolStep = 0;
        }
      }
      break;

    case Select:
      if ( mSelectedItem ) {
        // the object was probably moved
        QgsComposerItem *ci = dynamic_cast <QgsComposerItem *> (mSelectedItem);
        ci->writeSettings();
      }
      break;

    //We don't do anything special for labels, scalebars, or vector legends
    case AddLabel:
    case AddScalebar:
    case AddVectorLegend:
      break;

  }
}

void QgsComposition::keyPressEvent ( QKeyEvent * e )
{
#ifdef QGISDEBUG
  std::cout << "QgsComposition::keyPressEvent() key = " << e->key() << std::endl;
#endif

  if ( e->key() == Qt::Key_Delete && mSelectedItem ) { // delete

    QgsComposerItem *coi = dynamic_cast <QgsComposerItem *> (mSelectedItem);
    coi->setSelected ( false );
    coi->removeSettings();
    for (std::list < QgsComposerItem * >::iterator it = mItems.begin(); 
        it != mItems.end(); ++it) 
    {
      if ( (*it) == coi ) {
        mItems.erase ( it );
        break;
      }
    }
    delete (mSelectedItem);
    mSelectedItem = 0;
    mCanvas->update();
  }
}

void QgsComposition::paperSizeChanged ( void )
{
#ifdef QGISDEBUG
  std::cout << "QgsComposition::paperSizeChanged" << std::endl;
#endif

  mPaper = mPaperSizeComboBox->currentItem();
  mPaperOrientation = mPaperOrientationComboBox->currentItem();
#ifdef QGISDEBUG
  std::cout << "custom = " << mPapers[mPaper].mCustom << std::endl;
  std::cout << "orientation = " << mPaperOrientation << std::endl;
#endif
  if ( mPapers[mPaper].mCustom ) {
    mUserPaperWidth = mPaperWidthLineEdit->text().toDouble();
    mUserPaperHeight = mPaperHeightLineEdit->text().toDouble();
    mPaperWidthLineEdit->setEnabled( TRUE );
    mPaperHeightLineEdit->setEnabled( TRUE );
  } else {
    mUserPaperWidth = mPapers[mPaper].mWidth;
    mUserPaperHeight = mPapers[mPaper].mHeight;
    mPaperWidthLineEdit->setEnabled( FALSE );
    mPaperHeightLineEdit->setEnabled( FALSE );
    setOptions();
  }

  try
  {
    recalculate();
  }
  catch (std::bad_alloc& ba)
  {
    UNUSED(ba);
    // A better solution here would be to set the canvas back to the
    // original size and carry on, but for the moment this will
    // prevent a crash due to an uncaught exception.
    QMessageBox::critical( 0, tr("Out of memory"),
                           tr("Qgis is unable to resize the paper size due to "
                              "insufficient memory.\n It is best that you avoid "
                              "using the map composer until you restart qgis.\n") );
  }

//  mView->repaintContents(); //just repaint();?
  writeSettings();
}

void QgsComposition::recalculate ( void ) 
{
  if ( (mPaperOrientation == Portrait &&  mUserPaperWidth < mUserPaperHeight) ||
      (mPaperOrientation == Landscape &&  mUserPaperWidth > mUserPaperHeight) ) 
  {
    mPaperWidth = mUserPaperWidth;
    mPaperHeight = mUserPaperHeight;
  } else {
    mPaperWidth = mUserPaperHeight;
    mPaperHeight = mUserPaperWidth;
  }
#ifdef QGISDEBUG
  std::cout << "mPaperWidth = " << mPaperWidth << " mPaperHeight = " << mPaperHeight << std::endl;
#endif
  resizeCanvas();
  mComposer->zoomFull();
}

void QgsComposition::resolutionChanged ( void )
{
  mResolution = mResolutionLineEdit->text().toInt();
  writeSettings();
}

void QgsComposition::setOptions ( void )
{
  mPaperSizeComboBox->setCurrentItem(mPaper);
  mPaperOrientationComboBox->setCurrentItem(mPaperOrientation);
  mPaperWidthLineEdit->setText ( QString("%1").arg(mUserPaperWidth,0,'g') );
  mPaperHeightLineEdit->setText ( QString("%1").arg(mUserPaperHeight,0,'g') );
  mResolutionLineEdit->setText ( QString("%1").arg(mResolution) );
}

void QgsComposition::setPlotStyle (  PlotStyle p )
{
  mPlotStyle = p;

  // Set all items
  for (std::list < QgsComposerItem * >::iterator it = mItems.begin(); it != mItems.end(); ++it) {
    (*it)->setPlotStyle( p ) ;
  }

  // Remove paper if Print, reset if Preview
  if ( mPlotStyle == Print ) {
//    mPaperItem->setScene(0);
//    mCanvas->setBackgroundColor( Qt::white );
  } else { 
//    mPaperItem->setScene(mCanvas);
//    mCanvas->setBackgroundColor( QColor(180,180,180) );

  }
}

double QgsComposition::viewScale ( void ) 
{
  double scale = mView->matrix().m11();
  return scale; 
}

//does this even work?
void QgsComposition::refresh()
{
  // TODO add signals to map canvas
  for (std::list < QgsComposerItem * >::iterator it = mItems.begin(); it != mItems.end(); ++it)    {
    QgsComposerItem *ci = (*it);
    if (  typeid (*ci) == typeid(QgsComposerMap) ) {
      QgsComposerMap *cm = dynamic_cast<QgsComposerMap*>(ci);
      cm->setCacheUpdated(false);
    } else if (  typeid (*ci) == typeid(QgsComposerVectorLegend) ) {
      QgsComposerVectorLegend *vl = dynamic_cast<QgsComposerVectorLegend*>(ci);
      vl->recalculate();
    }
  }
  mCanvas->update();
}

int QgsComposition::id ( void ) { return mId; }

QgsComposer *QgsComposition::composer(void) { return mComposer; }

QGraphicsScene *QgsComposition::canvas(void) { return mCanvas; }

double QgsComposition::paperWidth ( void ) { return mPaperWidth; }

double QgsComposition::paperHeight ( void ) { return mPaperHeight; }

int QgsComposition::paperOrientation ( void ) { return mPaperOrientation; }

int QgsComposition::resolution ( void ) { return mResolution; }

int QgsComposition::scale( void ) { return mScale; }

double QgsComposition::toMM ( int v ) { return v/mScale ; }

int QgsComposition::fromMM ( double v ) { return (int) (v * mScale); }

void QgsComposition::setTool ( Tool tool )
{
  // Stop old in progress
  mView->viewport()->setMouseTracking ( false ); // stop mouse tracking
  if ( mSelectedItem ) {
    QgsComposerItem *coi = dynamic_cast <QgsComposerItem *> (mSelectedItem);
    coi->setSelected ( false );
    mCanvas->update();
  }
  mSelectedItem = 0;
  mComposer->showItemOptions ( (QWidget *) 0 );

  if ( mNewCanvasItem ) {
    mNewCanvasItem->setPos(-1000, -1000);
    mCanvas->update();

    delete mNewCanvasItem;
    mNewCanvasItem = 0;
  }

  if ( mRectangleItem ) {
    delete mRectangleItem;
    mRectangleItem = 0;
  }

  // Start new
  if ( tool == AddVectorLegend ) { // Create temporary object
    if ( mNewCanvasItem ) delete mNewCanvasItem;

    // Create new object outside the visible area
    QgsComposerVectorLegend *vl = new QgsComposerVectorLegend ( this, mNextItemId++, -1000, -1000, (int) (mPaperHeight/50));
    mNewCanvasItem = dynamic_cast <QGraphicsItem *> (vl);
    mComposer->showItemOptions ( vl->options() );

    mView->viewport()->setMouseTracking ( true ); // to recieve mouse move

  }
  else if ( tool == AddLabel ) {
    if ( mNewCanvasItem ) delete mNewCanvasItem;

    // Create new object outside the visible area
    QgsComposerLabel *lab = new QgsComposerLabel ( this, mNextItemId++, -1000, -1000, tr("Label"), (int) (mPaperHeight/20));

    mNewCanvasItem = dynamic_cast <QGraphicsItem *> (lab);
    mComposer->showItemOptions ( lab->options() );

    mView->viewport()->setMouseTracking ( true ); // to recieve mouse move
  }
 else if ( tool == AddScalebar ) {
    if ( mNewCanvasItem ) delete mNewCanvasItem;

    // Create new object outside the visible area
    QgsComposerScalebar *sb = new QgsComposerScalebar ( this, mNextItemId++, -1000, -1000);
    mNewCanvasItem = dynamic_cast <QGraphicsItem*> (sb);
    mComposer->showItemOptions ( sb->options() );

    mView->viewport()->setMouseTracking ( true ); // to recieve mouse move
  }
  else if ( tool == AddPicture )
  {
    if ( mNewCanvasItem ) delete mNewCanvasItem;

    while ( 1 ) // keep trying until we get a valid image or the user clicks cancel
    {
	  QString file = QgsComposerPicture::pictureDialog();

      if ( file.isNull() ) //user clicked cancel
	  {
	    // TODO: This is not nice, because selectItem() calls 
            //       this function, do it better
	    mComposer->selectItem();
	    tool = Select;
	    break; //quit the loop
      }

	  // Create new object outside the visible area
	  QgsComposerPicture *pi = new QgsComposerPicture ( this, mNextItemId++, file );

	  if ( pi->pictureValid() )
	  {
#ifdef QGISDEBUG
  	    std::cout << "picture is valid" << std::endl;
#endif
	    mNewCanvasItem = dynamic_cast <QGraphicsItem *> (pi);
	    mComposer->showItemOptions ( pi->options() );

	    mView->viewport()->setMouseTracking ( true ); // start tracking the mouse
        break; //quit the loop
	  }
	  else
      {
	    QMessageBox::warning( this, tr("Warning"),
                         tr("Cannot load picture.") );
	    delete pi;
	  }
    }

  }//END if(tool == AddPicture)*/

  mTool = tool;
  mToolStep = 0;
}

std::vector<QgsComposerMap*> QgsComposition::maps(void) 
{
  std::vector<QgsComposerMap*> v;
  for (std::list < QgsComposerItem * >::iterator it = mItems.begin(); it != mItems.end(); ++it) {
    QgsComposerItem *ci = (*it);
    if (  typeid (*ci) == typeid(QgsComposerMap) ) {
      v.push_back ( dynamic_cast<QgsComposerMap*>(ci) );
    }
  }

  return v;
}

QgsComposerMap* QgsComposition::map ( int id ) 
{ 
  for (std::list < QgsComposerItem * >::iterator it = mItems.begin(); it != mItems.end(); ++it) {
    QgsComposerItem *ci = (*it);
    if (  ci->id() == id ) {
      return ( dynamic_cast<QgsComposerMap*>(ci) );
    }
  }
  return 0;
}

double QgsComposition::selectionBoxSize ( void )
{
  // Scale rectangle based on the zoom level, so we keep the rectangle a fixed size on the screen
  return 7.0/viewScale();
}

QPen QgsComposition::selectionPen ( void ) 
{
  return QPen( QColor(0,0,255), 0) ;
}

QBrush QgsComposition::selectionBrush ( void )
{
  return QBrush ( QBrush(QColor(0,0,255), Qt::SolidPattern) );
}

void QgsComposition::emitMapChanged ( int id )
{
  emit mapChanged ( id );
}

bool QgsComposition::writeSettings ( void )
{
  QString path, val;
  path.sprintf("/composition_%d/", mId );
  QgsProject::instance()->writeEntry( "Compositions", path+"width", mUserPaperWidth );
  QgsProject::instance()->writeEntry( "Compositions", path+"height", mUserPaperHeight );
  QgsProject::instance()->writeEntry( "Compositions", path+"resolution", mResolution );

  if ( mPaperOrientation == Landscape ) {
    val = "landscape";
  } else {
    val = "portrait";
  }
  QgsProject::instance()->writeEntry( "Compositions", path+"orientation", val );


  return true;
}

bool QgsComposition::readSettings ( void )
{
#ifdef QGISDEBUG
  std::cout << "QgsComposition::readSettings" << std::endl;
#endif

  bool ok;

  mPaper = mCustomPaper;

  QString path, val;
  path.sprintf("/composition_%d/", mId );
  mUserPaperWidth = QgsProject::instance()->readDoubleEntry( "Compositions", path+"width", 297, &ok);
  mUserPaperHeight = QgsProject::instance()->readDoubleEntry( "Compositions", path+"height", 210, &ok);
  mResolution = QgsProject::instance()->readNumEntry( "Compositions", path+"resolution", 300, &ok);

  val = QgsProject::instance()->readEntry( "Compositions", path+"orientation", "landscape", &ok);
  if ( val.compare("landscape") == 0 ) {
    mPaperOrientation = Landscape;
  } else {
    mPaperOrientation = Portrait;
  }

  recalculate();
  setOptions();

  // Create objects
  path.sprintf("/composition_%d", mId );
  QStringList el = QgsProject::instance()->subkeyList ( "Compositions", path );

  // First create the map(s) because they are often required by other objects
  for ( QStringList::iterator it = el.begin(); it != el.end(); ++it ) {
#ifdef QGISDEBUG
    std::cout << "key: " << (*it).toLocal8Bit().data() << std::endl;
#endif

    QStringList l = QStringList::split( '_', (*it) );
    if ( l.size() == 2 ) {
      QString name = l.first();
      QString ids = l.last();
      int id = ids.toInt();

      if ( name.compare("map") == 0 ) {
        QgsComposerMap *map = new QgsComposerMap ( this, id );
        mItems.push_back(map);
      }

      if ( id >= mNextItemId ) mNextItemId = id + 1;
    }
  }

  for ( QStringList::iterator it = el.begin(); it != el.end(); ++it ) {
#ifdef QGISDEBUG
    std::cout << "key: " << (*it).toLocal8Bit().data() << std::endl;
#endif

    QStringList l = QStringList::split( '_', (*it) );
    if ( l.size() == 2 ) {
      QString name = l.first();
      QString ids = l.last();
      int id = ids.toInt();

      if ( name.compare("vectorlegend") == 0 ) {
        QgsComposerVectorLegend *vl = new QgsComposerVectorLegend ( this, id );
        mItems.push_back(vl);
      } else if ( name.compare("label") == 0 ) {
        QgsComposerLabel *lab = new QgsComposerLabel ( this, id );
        mItems.push_back(lab);
      } else if ( name.compare("scalebar") == 0 ) {
        QgsComposerScalebar *sb = new QgsComposerScalebar ( this, id );
        mItems.push_back(sb);
      } else if ( name.compare("picture") == 0 ) {
        QgsComposerPicture *pi = new QgsComposerPicture ( this, id );
        mItems.push_back(pi);
      }

      if ( id >= mNextItemId ) mNextItemId = id + 1;
    }
  }


  mCanvas->update();

  return true;
}