qgscomposer.cpp

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

  for ( myIterator = myFilterMap.begin(); myIterator != myFilterMap.end(); ++myIterator )
  {
    std::cout << myIterator.key().toLocal8Bit().data() << "  :  " << myIterator.data().toLocal8Bit().data() << std::endl;
  }
#endif

  //create a file dialog using the the filter list generated above
  std::auto_ptr < QFileDialog > myQFileDialog(
      new QFileDialog(
        this,
        tr("Choose a filename to save the map image as"),
        file.path(),
        myFilters
        )
      );
  myQFileDialog->selectFile( file.fileName() );

  // allow for selection of more than one file
  myQFileDialog->setMode(QFileDialog::AnyFile);

  // set the filter to the last one used
  myQFileDialog->selectFilter(myLastUsedFilter);

  // set the 'Open' button to something that makes more sense
  myQFileDialog->setAcceptMode(QFileDialog::AcceptSave);

  //prompt the user for a filename
  QString myOutputFileNameQString; // = myQFileDialog->getSaveFileName(); //delete this

  int result = myQFileDialog->exec();
  raise ();
  
  if ( result != QDialog::Accepted) return;

  myOutputFileNameQString = myQFileDialog->selectedFile();
  QString myFilterString = myQFileDialog->selectedFilter();
#ifdef QGISDEBUG
  std::cout << "Selected filter: " << myFilterString.toLocal8Bit().data() << std::endl;
  std::cout << "Image type: " << myFilterMap[myFilterString].toLocal8Bit().data() << std::endl;
#endif

  myQSettings.writeEntry("/UI/lastSaveAsImageFormat" , myFilterMap[myFilterString] );
  myQSettings.writeEntry("/UI/lastSaveAsImageFile", myOutputFileNameQString);

  if ( myOutputFileNameQString == "" ) return;

  double scale = (double) (mComposition->resolution() / 25.4 / mComposition->scale());

  mView->setScene(0);
  mComposition->setPlotStyle ( QgsComposition::Print );

  QPixmap pixmap ( width, height );
  pixmap.fill ( QColor(255,255,255) ) ;
  QPainter p(&pixmap);
  p.scale ( scale, scale);

QRectF renderArea(0,0,(mComposition->paperWidth() * mComposition->scale()),(mComposition->paperHeight() * mComposition->scale()));

  mComposition->canvas()->render(&p, renderArea);
  p.end();

  mComposition->setPlotStyle ( QgsComposition::Preview );
  mView->setScene(mComposition->canvas());

  pixmap.save ( myOutputFileNameQString, myFilterMap[myFilterString].toLocal8Bit().data() );
}


void QgsComposer::on_mActionExportAsSVG_activated(void)
{

  QString myQSettingsLabel = "/UI/displaySVGWarning";
  QSettings myQSettings;

  bool displaySVGWarning = myQSettings.value(myQSettingsLabel, true).toBool();

  if (displaySVGWarning)
  {
    QgsMessageViewer* m = new QgsMessageViewer(this);
    m->setWindowTitle(tr("SVG warning"));
    m->setCheckBoxText(tr("Don't show this message again"));
    m->setCheckBoxState(Qt::Unchecked);
    m->setCheckBoxVisible(true);
    m->setCheckBoxQSettingsLabel(myQSettingsLabel);
    m->setMessageAsHtml(tr("<p>The SVG export function in Qgis has several "
                           "problems due to bugs and deficiencies in the "
#if QT_VERSION < 0x040300
                           "Qt4 svg code. Of note, text does not "
                           "appear in the SVG file and there are problems "
                           "with the map bounding box clipping other items "
                           "such as the legend or scale bar.</p>"
#else
                           "Qt4 svg code. In particular, there are problems "
                           "with layers not being clipped to the map"
                           "bounding box.</p>"
#endif
                           "If you require a vector-based output file from "
                           "Qgis it is suggested that you try printing "
                           "to PostScript if the SVG output is not "
                           "satisfactory."
                           "</p>"));
    m->exec();
  }
  QString myLastUsedFile = myQSettings.readEntry("/UI/lastSaveAsSvgFile","qgis.svg");
  QFileInfo file(myLastUsedFile);
  QFileDialog *myQFileDialog = new QFileDialog( this, tr("Choose a filename to save the map as"),
                                                file.path(), tr("SVG Format") + " (*.svg *SVG)" );
  myQFileDialog->selectFile( file.fileName() );
  myQFileDialog->setMode(QFileDialog::AnyFile);
  myQFileDialog->setAcceptMode(QFileDialog::AcceptSave);

  int result = myQFileDialog->exec();
  raise ();
  if ( result != QDialog::Accepted) return;

  QString myOutputFileNameQString = myQFileDialog->selectedFile();
  if ( myOutputFileNameQString == "" ) return;

  myQSettings.writeEntry("/UI/lastSaveAsSvgFile", myOutputFileNameQString);

  mView->setScene(0);//don't redraw the scene on the display while we render
  mComposition->setPlotStyle ( QgsComposition::Print );

#if QT_VERSION < 0x040300
  Q3Picture pic;
  QPainter p(&pic);
  QRectF renderArea(0,0, (mComposition->paperWidth() * mComposition->scale()), (mComposition->paperHeight() * mComposition->scale()) );
#else
  QSvgGenerator generator;
  generator.setFileName(myOutputFileNameQString);
  generator.setSize(QSize( (int)mComposition->paperWidth(), (int)mComposition->paperHeight() ));
  generator.setResolution((int)(mComposition->resolution() / 25.4)); //because the rendering is done in mm, convert the dpi
 
  QPainter p(&generator);
  QRectF renderArea(0,0, mComposition->paperWidth(), mComposition->paperHeight());
#endif
  mComposition->canvas()->render(&p, renderArea);
  p.end();

  mComposition->setPlotStyle ( QgsComposition::Preview );
  mView->setScene(mComposition->canvas()); //now that we're done, set the view to show the scene again

#if QT_VERSION < 0x040300
  QRect br = pic.boundingRect();

  pic.save ( myOutputFileNameQString, "svg" );
#endif
}


void QgsComposer::setToolActionsOff(void)
{
  mActionOpenTemplate->setOn ( false );
  mActionSaveTemplateAs->setOn ( false );
  mActionExportAsImage->setOn ( false );
  mActionExportAsSVG->setOn ( false );
  mActionPrint->setOn ( false );
  mActionZoomAll->setOn ( false );
  mActionZoomIn->setOn ( false );
  mActionZoomOut->setOn ( false );
  mActionRefreshView->setOn ( false );
  mActionAddNewMap->setOn ( false );
  mActionAddImage->setOn ( false );
  mActionAddNewLabel->setOn ( false );
  mActionAddNewVectLegend->setOn ( false );
  mActionAddNewScalebar->setOn ( false );
  mActionSelectMoveItem->setOn ( false );
}

void QgsComposer::selectItem(void)
{
  mComposition->setTool ( QgsComposition::Select );
  setToolActionsOff();
  mActionSelectMoveItem->setOn ( true );
}

void QgsComposer::on_mActionSelectMoveItem_activated(void)
{
  selectItem();
}

void QgsComposer::on_mActionAddNewMap_activated(void)
{
  mComposition->setTool ( QgsComposition::AddMap );
  setToolActionsOff();
  mActionAddNewMap->setOn ( true );
}

void QgsComposer::on_mActionAddNewVectLegend_activated(void)
{
  mComposition->setTool ( QgsComposition::AddVectorLegend );
  setToolActionsOff();
  mActionAddNewVectLegend->setOn ( true );
}

void QgsComposer::on_mActionAddNewLabel_activated(void)
{
  mComposition->setTool ( QgsComposition::AddLabel );
  setToolActionsOff();
  mActionAddNewLabel->setOn ( true );
}

void QgsComposer::on_mActionAddNewScalebar_activated(void)
{
  mComposition->setTool ( QgsComposition::AddScalebar );
  setToolActionsOff();
  mActionAddNewScalebar->setOn ( true );
}

void QgsComposer::on_mActionAddImage_activated(void)
{
  mComposition->setTool ( QgsComposition::AddPicture );
  setToolActionsOff();
  mActionAddImage->setOn ( true );
}

void QgsComposer::moveEvent ( QMoveEvent *e ) { saveWindowState(); }

void QgsComposer::resizeEvent ( QResizeEvent *e )
{
  // Move size grip when window is resized
  mSizeGrip->move(rect().bottomRight() - mSizeGrip->rect().bottomRight());

  saveWindowState();
}

void QgsComposer::saveWindowState()
{
  QSettings settings;
  settings.setValue("/Composer/geometry", saveGeometry());
  settings.setValue("/Composer/splitterState", mSplitter->saveState());
}

void QgsComposer::restoreWindowState()
{
  QSettings settings;
  restoreGeometry(settings.value("/Composer/geometry").toByteArray());
  QVariant splitterState = settings.value("/Composer/splitterState");
  if (splitterState != QVariant::QVariant())
    mSplitter->restoreState(settings.value("/Composer/splitterState").toByteArray());
  else
  {
    QList<int> defaultSize;
    defaultSize << 300 << 100; // page display 300 pixels, details pane 100 pixels
    mSplitter->setSizes(defaultSize);
  }
}

void QgsComposer::on_helpPButton_clicked()
{
  QgsContextHelp::run(context_id);
}

void QgsComposer::on_closePButton_clicked()
{
  close();
}

void QgsComposer::projectRead(void)
{
#ifdef QGISDEBUG
  std::cout << "QgsComposer::projectRead" << std::endl;
#endif
  if ( mComposition ) delete mComposition;
  mComposition  = new QgsComposition( this, 1 );

  // Read composition if it is defined in project
  QStringList l = QgsProject::instance()->subkeyList ( "Compositions", "" );

  bool found = false;
  for ( QStringList::iterator it = l.begin(); it != l.end(); ++it ) {
    std::cout << "key: " << (*it).toLocal8Bit().data() << std::endl;
    if ( (*it).compare ( "composition_1" ) == 0 ) {
      found = true;
      break;
    }
  }

  if ( found ) {
    mComposition->readSettings ( );
    mFirstTime = false;
  } else { 
    if ( isVisible() ) {
      mComposition->createDefault();
      mFirstTime = false;
    } else {
      mFirstTime = true;
    }
  }

  mComposition->setActive ( true );
}

void QgsComposer::newProject(void)
{
#ifdef QGISDEBUG
  std::cout << "QgsComposer::newProject" << std::endl;
#endif
  if ( mComposition ) delete mComposition;

  mComposition  = new QgsComposition( this, 1 );
  mComposition->setActive ( true );

  // If composer is visible, create default immediately, otherwise wait for the first open()
  if ( isVisible() ) {
    mComposition->createDefault();
    mFirstTime = false;
  } else {
    mFirstTime = true;
  }
}

bool QgsComposer::writeSettings ( void )
{
#ifdef WIN32
  bool ok = true;
#else
  bool ok = false;
#endif
  return ok;
}

bool QgsComposer::readSettings ( void )
{
#ifdef WIN32
  bool ok = true;
#else
  bool ok = false;
#endif
  return ok;
}

bool QgsComposer::writeXML( QDomNode & node, QDomDocument & doc )
{
#ifdef QGISDEBUG
  std::cout << "QgsComposer::writeXML" << std::endl;
#endif
  QDomElement compositionsNode = doc.createElement("compositions");

  node.appendChild( compositionsNode );

  return true;
}

bool QgsComposer::readXML( QDomNode & node )
{
#ifdef QGISDEBUG
  std::cout << "QgsComposer::readXML" << std::endl;
#endif
  return true;
}