[composer] Remove use of runtime_error for providing feedback from atlas

nyalldawson · nyalldawson · commit c38d3e12af08 · 2014-05-29T22:49:58.000+10:00
diff --git a/python/core/composer/qgsatlascomposition.sip b/python/core/composer/qgsatlascomposition.sip
@@ -74,17 +74,27 @@ public:
      * atlas page.
      * @returns filename pattern
      * @see setFilenamePattern
+     * @see filenamePatternErrorString
      * @note This property has no effect when exporting to PDF if singleFile() is true
      */
     QString filenamePattern() const;
 
     /**Sets the filename expression used for generating output filenames for each
      * atlas page.
+     * @returns true if filename expression could be successful set, false if expression is invalid
      * @param pattern expression to use for output filenames
      * @see filenamePattern
+     * @see filenamePatternErrorString
      * @note This method has no effect when exporting to PDF if singleFile() is true
      */
-    void setFilenamePattern( const QString& pattern );
+    bool setFilenamePattern( const QString& pattern );
+    
+    /**Returns an error string from parsing the filename expression.
+     * @returns filename pattern parser error
+     * @see setFilenamePattern
+     * @see filenamePattern
+     */
+    QString filenamePatternErrorString() const;
 
     /**Returns the coverage layer used for the atlas features
      * @returns atlas coverage layer
@@ -125,6 +135,13 @@ public:
 
     QString featureFilter() const;
     void setFeatureFilter( const QString& expression );
+    
+    /**Returns an error string from parsing the feature filter expression.
+     * @returns filename pattern parser error
+     * @see setFilenamePattern
+     * @see filenamePattern
+     */
+    QString featureFilterErrorString() const;
 
     QString sortKeyAttributeName() const;
     void setSortKeyAttributeName( QString fieldName );
@@ -157,11 +174,15 @@ public:
     /** Returns the number of features in the coverage layer */
     int numFeatures() const;
 
-    /** Prepare the atlas map for the given feature. Sets the extent and context variables */
-    void prepareForFeature( int i );
+    /**Prepare the atlas map for the given feature. Sets the extent and context variables
+     * @returns true if feature was successfully prepared
+    */
+    bool prepareForFeature( int i );
 
-    /** Prepare the atlas map for the given feature. Sets the extent and context variables */
-    void prepareForFeature( QgsFeature * feat );
+    /**Prepare the atlas map for the given feature. Sets the extent and context variables
+     * @returns true if feature was successfully prepared
+    */
+    bool prepareForFeature( QgsFeature * feat );
 
     /** Returns the current filename. Must be called after prepareForFeature( i ) */
     const QString& currentFilename() const;
diff --git a/src/app/composer/qgsatlascompositionwidget.cpp b/src/app/composer/qgsatlascompositionwidget.cpp
@@ -88,15 +88,24 @@ void QgsAtlasCompositionWidget::changeCoverageLayer( QgsMapLayer *layer )
   }
 }
 
-void QgsAtlasCompositionWidget::on_mAtlasFilenamePatternEdit_textChanged( const QString& text )
+void QgsAtlasCompositionWidget::on_mAtlasFilenamePatternEdit_editingFinished()
 {
   QgsAtlasComposition* atlasMap = &mComposition->atlasComposition();
   if ( !atlasMap )
   {
     return;
   }
 
-  atlasMap->setFilenamePattern( text );
+  if ( ! atlasMap->setFilenamePattern( mAtlasFilenamePatternEdit->text() ) )
+  {
+    //expression could not be set
+    QMessageBox::warning( this
+                          , tr( "Could not evaluate filename pattern" )
+                          , tr( "Could not set filename pattern as '%1'.\nParser error:\n%2" )
+                          .arg( mAtlasFilenamePatternEdit->text() )
+                          .arg( atlasMap->filenamePatternErrorString() )
+                        );
+  }
 }
 
 void QgsAtlasCompositionWidget::on_mAtlasFilenameExpressionButton_clicked()
diff --git a/src/app/composer/qgsatlascompositionwidget.h b/src/app/composer/qgsatlascompositionwidget.h
@@ -37,7 +37,7 @@ class QgsAtlasCompositionWidget:
   public slots:
     void on_mUseAtlasCheckBox_stateChanged( int state );
     void changeCoverageLayer( QgsMapLayer* layer );
-    void on_mAtlasFilenamePatternEdit_textChanged( const QString& text );
+    void on_mAtlasFilenamePatternEdit_editingFinished();
     void on_mAtlasFilenameExpressionButton_clicked();
     void on_mAtlasHideCoverageCheckBox_stateChanged( int state );
     void on_mAtlasSingleFileCheckBox_stateChanged( int state );
diff --git a/src/app/composer/qgscomposer.cpp b/src/app/composer/qgscomposer.cpp
@@ -1336,15 +1336,11 @@ void QgsComposer::exportCompositionAsPDF( QgsComposer::OutputMode mode )
 
     QPainter painter;
 
-    try
-    {
-      loadAtlasPredefinedScalesFromProject();
-      atlasMap->beginRender();
-    }
-    catch ( std::exception& e )
+    loadAtlasPredefinedScalesFromProject();
+    if ( ! atlasMap->beginRender() && !atlasMap->featureFilterErrorString().isEmpty() )
     {
       QMessageBox::warning( this, tr( "Atlas processing error" ),
-                            e.what(),
+                            tr( "Feature filter parser error: %1" ).arg( atlasMap->featureFilterErrorString() ),
                             QMessageBox::Ok,
                             QMessageBox::Ok );
       mView->setPaintingEnabled( true );
@@ -1371,14 +1367,10 @@ void QgsComposer::exportCompositionAsPDF( QgsComposer::OutputMode mode )
         atlasMap->endRender();
         break;
       }
-      try
-      {
-        atlasMap->prepareForFeature( featureI );
-      }
-      catch ( std::runtime_error& e )
+      if ( !atlasMap->prepareForFeature( featureI ) )
       {
         QMessageBox::warning( this, tr( "Atlas processing error" ),
-                              e.what(),
+                              tr( "Atlas processing error" ),
                               QMessageBox::Ok,
                               QMessageBox::Ok );
         mView->setPaintingEnabled( true );
@@ -1491,15 +1483,12 @@ void QgsComposer::printComposition( QgsComposer::OutputMode mode )
 
     mComposition->beginPrint( mPrinter );
     QPainter painter( &mPrinter );
-    try
-    {
-      loadAtlasPredefinedScalesFromProject();
-      atlasMap->beginRender();
-    }
-    catch ( std::exception& e )
+
+    loadAtlasPredefinedScalesFromProject();
+    if ( ! atlasMap->beginRender() && !atlasMap->featureFilterErrorString().isEmpty() )
     {
       QMessageBox::warning( this, tr( "Atlas processing error" ),
-                            e.what(),
+                            tr( "Feature filter parser error: %1" ).arg( atlasMap->featureFilterErrorString() ),
                             QMessageBox::Ok,
                             QMessageBox::Ok );
       mView->setPaintingEnabled( true );
@@ -1518,21 +1507,16 @@ void QgsComposer::printComposition( QgsComposer::OutputMode mode )
         atlasMap->endRender();
         break;
       }
-      try
-      {
-        atlasMap->prepareForFeature( i );
-      }
-      catch ( std::runtime_error& e )
+      if ( !atlasMap->prepareForFeature( i ) )
       {
         QMessageBox::warning( this, tr( "Atlas processing error" ),
-                              e.what(),
+                              tr( "Atlas processing error" ),
                               QMessageBox::Ok,
                               QMessageBox::Ok );
         mView->setPaintingEnabled( true );
         return;
       }
 
-
       if ( i > 0 )
       {
         mPrinter.newPage();
@@ -1753,15 +1737,11 @@ void QgsComposer::exportCompositionAsImage( QgsComposer::OutputMode mode )
     mView->setPaintingEnabled( false );
     QApplication::setOverrideCursor( Qt::BusyCursor );
 
-    try
-    {
-      loadAtlasPredefinedScalesFromProject();
-      atlasMap->beginRender();
-    }
-    catch ( std::exception& e )
+    loadAtlasPredefinedScalesFromProject();
+    if ( ! atlasMap->beginRender() && !atlasMap->featureFilterErrorString().isEmpty() )
     {
       QMessageBox::warning( this, tr( "Atlas processing error" ),
-                            e.what(),
+                            tr( "Feature filter parser error: %1" ).arg( atlasMap->featureFilterErrorString() ),
                             QMessageBox::Ok,
                             QMessageBox::Ok );
       mView->setPaintingEnabled( true );
@@ -1781,14 +1761,10 @@ void QgsComposer::exportCompositionAsImage( QgsComposer::OutputMode mode )
         atlasMap->endRender();
         break;
       }
-      try
-      {
-        atlasMap->prepareForFeature( feature );
-      }
-      catch ( std::runtime_error& e )
+      if ( ! atlasMap->prepareForFeature( feature ) )
       {
         QMessageBox::warning( this, tr( "Atlas processing error" ),
-                              e.what(),
+                              tr( "Atlas processing error" ),
                               QMessageBox::Ok,
                               QMessageBox::Ok );
         mView->setPaintingEnabled( true );
@@ -2021,15 +1997,11 @@ void QgsComposer::exportCompositionAsSVG( QgsComposer::OutputMode mode )
   int featureI = 0;
   if ( mode == QgsComposer::Atlas )
   {
-    try
-    {
-      loadAtlasPredefinedScalesFromProject();
-      atlasMap->beginRender();
-    }
-    catch ( std::exception& e )
+    loadAtlasPredefinedScalesFromProject();
+    if ( ! atlasMap->beginRender() && !atlasMap->featureFilterErrorString().isEmpty() )
     {
       QMessageBox::warning( this, tr( "Atlas processing error" ),
-                            e.what(),
+                            tr( "Feature filter parser error: %1" ).arg( atlasMap->featureFilterErrorString() ),
                             QMessageBox::Ok,
                             QMessageBox::Ok );
       mView->setPaintingEnabled( true );
@@ -2053,14 +2025,10 @@ void QgsComposer::exportCompositionAsSVG( QgsComposer::OutputMode mode )
         atlasMap->endRender();
         break;
       }
-      try
-      {
-        atlasMap->prepareForFeature( featureI );
-      }
-      catch ( std::runtime_error& e )
+      if ( !atlasMap->prepareForFeature( featureI ) )
       {
         QMessageBox::warning( this, tr( "Atlas processing error" ),
-                              e.what(),
+                              tr( "Atlas processing error" ),
                               QMessageBox::Ok,
                               QMessageBox::Ok );
         mView->setPaintingEnabled( true );
diff --git a/src/core/composer/qgsatlascomposition.cpp b/src/core/composer/qgsatlascomposition.cpp
diff --git a/src/core/composer/qgsatlascomposition.h b/src/core/composer/qgsatlascomposition.h

Original file line number	Diff line number	Diff line change
`@@ -88,15 +88,24 @@ void QgsAtlasCompositionWidget::changeCoverageLayer( QgsMapLayer *layer )`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`-void QgsAtlasCompositionWidget::on_mAtlasFilenamePatternEdit_textChanged( const QString& text )`
	`91`	`+void QgsAtlasCompositionWidget::on_mAtlasFilenamePatternEdit_editingFinished()`
`92`	`92`	`{`
`93`	`93`	`QgsAtlasComposition* atlasMap = &mComposition->atlasComposition();`
`94`	`94`	`if ( !atlasMap )`
`95`	`95`	`{`
`96`	`96`	`return;`
`97`	`97`	`}`
`98`	`98`
`99`		`- atlasMap->setFilenamePattern( text );`
	`99`	`+ if ( ! atlasMap->setFilenamePattern( mAtlasFilenamePatternEdit->text() ) )`
	`100`	`+ {`
	`101`	`+ //expression could not be set`
	`102`	`+ QMessageBox::warning( this`
	`103`	`+ , tr( "Could not evaluate filename pattern" )`
	`104`	`+ , tr( "Could not set filename pattern as '%1'.\nParser error:\n%2" )`
	`105`	`+ .arg( mAtlasFilenamePatternEdit->text() )`
	`106`	`+ .arg( atlasMap->filenamePatternErrorString() )`
	`107`	`+ );`
	`108`	`+ }`
`100`	`109`	`}`
`101`	`110`
`102`	`111`	`void QgsAtlasCompositionWidget::on_mAtlasFilenameExpressionButton_clicked()`
Original file line number	Diff line number	Diff line change
`@@ -26,14 +26,17 @@`
`26`	`26`	`#include "qgsgeometry.h"`
`27`	`27`	`#include "qgsmaplayerregistry.h"`
`28`	`28`	`#include "qgsproject.h"`
	`29`	`+#include "qgsmessagelog.h"`
`29`	`30`
`30`	`31`	`QgsAtlasComposition::QgsAtlasComposition( QgsComposition* composition ) :`
`31`	`32`	`mComposition( composition ),`
`32`	`33`	`mEnabled( false ),`
`33`	`34`	`mHideCoverage( false ), mFilenamePattern( "'output_'\|\|$feature" ),`
`34`	`35`	`mCoverageLayer( 0 ), mSingleFile( false ),`
`35`	`36`	`mSortFeatures( false ), mSortAscending( true ), mCurrentFeatureNo( 0 ),`
`36`		`- mFilterFeatures( false ), mFeatureFilter( "" )`
	`37`	`+ mFilterFeatures( false ), mFeatureFilter( "" ),`
	`38`	`+ mFilenameParserError( QString() ),`
	`39`	`+ mFilterParserError( QString() )`
`37`	`40`	`{`
`38`	`41`
`39`	`42`	`// declare special columns with a default value`
`@@ -181,9 +184,11 @@ int QgsAtlasComposition::updateFeatures()`
`181`	`184`	`filterExpression = std::auto_ptr<QgsExpression>( new QgsExpression( mFeatureFilter ) );`
`182`	`185`	`if ( filterExpression->hasParserError() )`
`183`	`186`	`{`
`184`		`- throw std::runtime_error( tr( "Feature filter parser error: %1" ).arg( filterExpression->parserErrorString() ).toLocal8Bit().data() );`
	`187`	`+ mFilterParserError = filterExpression->parserErrorString();`
	`188`	`+ return 0;`
`185`	`189`	`}`
`186`	`190`	`}`
	`191`	`+ mFilterParserError = QString();`
`187`	`192`
`188`	`193`	`// We cannot use nextFeature() directly since the feature pointer is rewinded by the rendering process`
`189`	`194`	`// We thus store the feature ids for future extraction`
`@@ -198,7 +203,7 @@ int QgsAtlasComposition::updateFeatures()`
`198`	`203`	`QVariant result = filterExpression->evaluate( &feat, mCoverageLayer->pendingFields() );`
`199`	`204`	`if ( filterExpression->hasEvalError() )`
`200`	`205`	`{`
`201`		`- throw std::runtime_error( tr( "Feature filter eval error: %1" ).arg( filterExpression->evalErrorString() ).toLocal8Bit().data() );`
	`206`	`+ QgsMessageLog::logMessage( tr( "Atlas filter eval error: %1" ).arg( filterExpression->evalErrorString() ), tr( "Composer" ) );`
`202`	`207`	`}`
`203`	`208`
`204`	`209`	`// skip this feature if the filter evaluation if false`
`@@ -326,23 +331,23 @@ void QgsAtlasComposition::lastFeature()`
`326`	`331`	`prepareForFeature( mFeatureIds.size() - 1 );`
`327`	`332`	`}`
`328`	`333`
`329`		`-void QgsAtlasComposition::prepareForFeature( QgsFeature * feat )`
	`334`	`+bool QgsAtlasComposition::prepareForFeature( QgsFeature * feat )`
`330`	`335`	`{`
`331`	`336`	`int featureI = mFeatureIds.indexOf( feat->id() );`
`332`		`- prepareForFeature( featureI );`
	`337`	`+ return prepareForFeature( featureI );`
`333`	`338`	`}`
`334`	`339`
`335`		`-void QgsAtlasComposition::prepareForFeature( int featureI )`
	`340`	`+bool QgsAtlasComposition::prepareForFeature( int featureI )`
`336`	`341`	`{`
`337`	`342`	`if ( !mCoverageLayer )`
`338`	`343`	`{`
`339`		`- return;`
	`344`	`+ return false;`
`340`	`345`	`}`
`341`	`346`
`342`	`347`	`if ( mFeatureIds.size() == 0 )`
`343`	`348`	`{`
`344`	`349`	`emit statusMsgChanged( tr( "No matching atlas features" ) );`
`345`		`- return;`
	`350`	`+ return false;`
`346`	`351`	`}`
`347`	`352`
`348`	`353`	`mCurrentFeatureNo = featureI;`
`@@ -355,7 +360,11 @@ void QgsAtlasComposition::prepareForFeature( int featureI )`
`355`	`360`	`QgsExpression::setSpecialColumn( "$feature", QVariant(( int )featureI + 1 ) );`
`356`	`361`
`357`	`362`	`// generate filename for current feature`
`358`		`- evalFeatureFilename();`
	`363`	`+ if ( !evalFeatureFilename() )`
	`364`	`+ {`
	`365`	`+ //error evaluating filename`
	`366`	`+ return false;`
	`367`	`+ }`
`359`	`368`
`360`	`369`	`emit featureChanged( &mCurrentFeature );`
`361`	`370`	`emit statusMsgChanged( QString( tr( "Atlas feature %1 of %2" ) ).arg( featureI + 1 ).arg( mFeatureIds.size() ) );`
`@@ -382,7 +391,7 @@ void QgsAtlasComposition::prepareForFeature( int featureI )`
`382`	`391`	`if ( atlasMaps.isEmpty() )`
`383`	`392`	`{`
`384`	`393`	`//no atlas enabled maps`
`385`		`- return;`
	`394`	`+ return true;`
`386`	`395`	`}`
`387`	`396`
`388`	`397`	`// compute extent of current feature in the map CRS. This should be set on a per-atlas map basis,`
`@@ -395,6 +404,8 @@ void QgsAtlasComposition::prepareForFeature( int featureI )`
`395`	`404`	`{`
`396`	`405`	`prepareMap( *mit );`
`397`	`406`	`}`
	`407`	`+`
	`408`	`+ return true;`
`398`	`409`	`}`
`399`	`410`
`400`	`411`	`void QgsAtlasComposition::computeExtent( QgsComposerMap* map )`
`@@ -670,16 +681,18 @@ void QgsAtlasComposition::setHideCoverage( bool hide )`
`670`	`681`
`671`	`682`	`}`
`672`	`683`
`673`		`-void QgsAtlasComposition::setFilenamePattern( const QString& pattern )`
	`684`	`+bool QgsAtlasComposition::setFilenamePattern( const QString& pattern )`
`674`	`685`	`{`
`675`	`686`	`mFilenamePattern = pattern;`
`676`		`- updateFilenameExpression();`
	`687`	`+ return updateFilenameExpression();`
`677`	`688`	`}`
`678`	`689`
`679`		`-void QgsAtlasComposition::updateFilenameExpression()`
	`690`	`+bool QgsAtlasComposition::updateFilenameExpression()`
`680`	`691`	`{`
`681`	`692`	`if ( !mCoverageLayer )`
`682`		`- return;`
	`693`	`+ {`
	`694`	`+ return false;`
	`695`	`+ }`
`683`	`696`
`684`	`697`	`const QgsFields& fields = mCoverageLayer->pendingFields();`
`685`	`698`
`@@ -690,7 +703,8 @@ void QgsAtlasComposition::updateFilenameExpression()`
`690`	`703`	`// test for evaluation errors`
`691`	`704`	`if ( mFilenameExpr->hasParserError() )`
`692`	`705`	`{`
`693`		`- throw std::runtime_error( tr( "Filename parsing error: %1" ).arg( mFilenameExpr->parserErrorString() ).toLocal8Bit().data() );`
	`706`	`+ mFilenameParserError = mFilenameExpr->parserErrorString();`
	`707`	`+ return false;`
`694`	`708`	`}`
`695`	`709`
`696`	`710`	`// prepare the filename expression`
`@@ -702,22 +716,24 @@ void QgsAtlasComposition::updateFilenameExpression()`
`702`	`716`	`{`
`703`	`717`	`evalFeatureFilename();`
`704`	`718`	`}`
`705`		`-`
	`719`	`+ return true;`
`706`	`720`	`}`
`707`	`721`
`708`		`-void QgsAtlasComposition::evalFeatureFilename()`
	`722`	`+bool QgsAtlasComposition::evalFeatureFilename()`
`709`	`723`	`{`
`710`	`724`	`//generate filename for current atlas feature`
`711`	`725`	`if ( mFilenamePattern.size() > 0 )`
`712`	`726`	`{`
`713`	`727`	`QVariant filenameRes = mFilenameExpr->evaluate( &mCurrentFeature, mCoverageLayer->pendingFields() );`
`714`	`728`	`if ( mFilenameExpr->hasEvalError() )`
`715`	`729`	`{`
`716`		`- throw std::runtime_error( tr( "Filename eval error: %1" ).arg( mFilenameExpr->evalErrorString() ).toLocal8Bit().data() );`
	`730`	`+ QgsMessageLog::logMessage( tr( "Atlas filename evaluation error: %1" ).arg( mFilenameExpr->evalErrorString() ), tr( "Composer" ) );`
	`731`	`+ return false;`
`717`	`732`	`}`
`718`	`733`
`719`	`734`	`mCurrentFilename = filenameRes.toString();`
`720`	`735`	`}`
	`736`	`+ return true;`
`721`	`737`	`}`
`722`	`738`
`723`	`739`	`void QgsAtlasComposition::setPredefinedScales( const QVector<double>& scales )`