qgis_rendercachepatch_v7_23Oct2009.diff

         /** Return pointer to layer's undo stack */
         QUndoStack* undoStack();
         /** Get the QImage used for caching render operations
          * @note This method was added in QGIS 1.4 **/
         QImage * cacheImage() { return mpCacheImage; }
         /** Set the QImage used for caching render operations
          * @note This method was added in QGIS 1.4 **/
         void setCacheImage( QImage * thepImage );
     public slots:
         /** Event handler for when a coordinate transform fails due to bad vertex error */

      */
      void removeAllMapLayers();
      /* Clears all layer caches, resetting them to zero and
      * freeing up any memory they may have been using. Layer
      * caches are used to speed up rendering in certain situations
      * see ticket #1974 for more details.
      * @note this method was added in QGIS 1.4
      */
      void clearAllLayerCaches();
     signals:
         /** emitted when a layer is removed from the registry

       //set the state of the checkboxes
       chkAntiAliasing->setChecked( settings.value( "/qgis/enable_anti_aliasing", false ).toBool() );
       chkUseRenderCaching->setChecked( settings.value( "/qgis/enable_render_caching", false ).toBool() );
       // Slightly awkard here at the settings value is true to use QImage,
       // but the checkbox is true to use QPixmap
-...
       settings.setValue( "/qgis/addPostgisDC", cbxAddPostgisDC->isChecked() );
       settings.setValue( "/qgis/new_layers_visible", chkAddedVisibility->isChecked() );
       settings.setValue( "/qgis/enable_anti_aliasing", chkAntiAliasing->isChecked() );
       settings.setValue( "/qgis/enable_render_caching", chkUseRenderCaching->isChecked() );
       settings.setValue( "/qgis/use_qimage_to_render", !( chkUseQPixmap->isChecked() ) );
       settings.setValue( "qgis/capitaliseLayerName", capitaliseCheckBox->isChecked() );
       settings.setValue( "qgis/askToSaveProjectChanges", chbAskToSaveProjectChanges->isChecked() );
-...
       // used (we we can. but it then doesn't do anti-aliasing, and this
       // will confuse people).
       if ( chkAntiAliasing->isChecked() )
+      {
         chkUseQPixmap->setChecked( false );
+      }
+    }
-...
       // used (we we can. but it then doesn't do anti-aliasing, and this
       // will confuse people).
       if ( chkUseQPixmap->isChecked() )
+      {
         chkAntiAliasing->setChecked( false );
+      }
+    }

       // update symbology
       emit refreshLegend( layer->getLayerID(), false );
       if ( layer->cacheImage() )
+      {
         //no need to delete the old one, maplayer will do it if needed
         layer->setCacheImage( 0 );
+      }
       layer->triggerRepaint();
       // notify the project we've made a change
       QgsProject::instance()->dirty( true );

src/app/qgisapp.cpp (working copy)
4476	4476
4477	4477	void QgisApp::refreshMapCanvas()
4478	4478	{
	4479	//clear all caches first
	4480	QgsMapLayerRegistry::instance()->clearAllLayerCaches();
	4481	//then refresh
4479	4482	mMapCanvas->refresh();
4480	4483	}
4481	4484

     bool QgsVectorLayer::commitChanges()
+    {
       bool success = true;
       //clear the cache image so markers dont appear anymore on next draw
       setCacheImage( 0 );
       mCommitErrors.clear();

         //! current extent to be drawn
         QgsRectangle mExtent;
         //
         /** Last extent to we drew so we know if we can
             used layer render caching or not. Note there are no
             accessors for this as it is intended to internal
             use only.
             @note added in QGIS 1.4 */
         QgsRectangle mLastExtent;
         //! indicates whether it's map image for overview
         bool mOverview;

       mMinScale = 0;
       mMaxScale = 100000000;
       mScaleBasedVisibility = false;
       mpCacheImage = 0;
+    }
-...
     QgsMapLayer::~QgsMapLayer()
+    {
       delete mCRS;
       if ( mpCacheImage )
+      {
         delete mpCacheImage;
+      }
+    }
     QgsMapLayer::LayerType QgsMapLayer::type() const
-...
+    {
       return &mUndoStack;
+    }
     void QgsMapLayer::setCacheImage( QImage * thepImage )
+    {
       QgsDebugMsg( "cache Image set!" );
       if ( mpCacheImage )
+      {
         delete mpCacheImage;
+      }
       mpCacheImage = thepImage;
+    }

     bool QgsMapRenderer::setExtent( const QgsRectangle& extent )
+    {
       //remember the previous extent
       mLastExtent = mExtent;
       // Don't allow zooms where the current extent is so small that it
       // can't be accurately represented using a double (which is what
-...
     void QgsMapRenderer::render( QPainter* painter )
+    {
       //flag to see if the render context has changed
       //since the last time we rendered. If it hasnt changed we can
       //take some shortcuts with rendering
       bool mySameAsLastFlag = true;
       QgsDebugMsg( "========== Rendering ==========" );
       if ( mExtent.isEmpty() )
-...
+      }
       if ( mDrawing )
+      {
         return;
+      }
       QPaintDevice* thePaintDevice = painter->device();
       if ( !thePaintDevice )
-...
         scaleFactor = sceneDpi / 25.4;
+      }
       double rasterScaleFactor = ( thePaintDevice->logicalDpiX() + thePaintDevice->logicalDpiY() ) / 2.0 / sceneDpi;
       mRenderContext.setScaleFactor( scaleFactor );
       mRenderContext.setRasterScaleFactor( rasterScaleFactor );
       mRenderContext.setRendererScale( mScale );
       if ( mRenderContext.rasterScaleFactor() != rasterScaleFactor )
+      {
         mRenderContext.setRasterScaleFactor( rasterScaleFactor );
         mySameAsLastFlag = false;
+      }
       if ( mRenderContext.scaleFactor() != scaleFactor )
+      {
         mRenderContext.setScaleFactor( scaleFactor );
         mySameAsLastFlag = false;
+      }
       if ( mRenderContext.rendererScale() != mScale )
+      {
         //add map scale to render context
         mRenderContext.setRendererScale( mScale );
         mySameAsLastFlag = false;
+      }
       if ( mLastExtent != mExtent )
+      {
         mLastExtent = mExtent;
         mySameAsLastFlag = false;
+      }
       // know we know if this render is just a repeat of the last time, we
       // can clear caches if it has changed
       if ( !mySameAsLastFlag )
+      {
           //clear the cache pixmap if we changed resolution / extent
           QSettings mySettings;
           if ( mySettings.value ( "/qgis/enable_render_caching", false ).toBool() )
+          {
             QgsMapLayerRegistry::instance()->clearAllLayerCaches();
+          }
+      }
       bool placeOverlays = false;
       QgsOverlayObjectPositionManager* overlayManager = overlayManagerFromSettings();
       QList<QgsVectorOverlay*> allOverlayList; //list of all overlays, used to draw them after layers have been rendered
-...
         placeOverlays = true;
+      }
       //add map scale to render context
       mRenderContext.setRendererScale( mScale );
       // render all layers in the stack, starting at the base
       QListIterator<QString> li( mLayerSet );
       li.toBack();
-...
           break;
+        }
         // Store the painter in case we need to swap it out for the
         // cache painter
         QPainter * mypContextPainter = mRenderContext.painter();
         QString layerId = li.previous();
         QgsDebugMsg( "Rendering at layer item " + layerId );
-...
+          }
           if ( scaleRaster )
+          {
             bk_mapToPixel = mRenderContext.mapToPixel();
             rasterMapToPixel = mRenderContext.mapToPixel();
             rasterMapToPixel.setMapUnitsPerPixel( mRenderContext.mapToPixel().mapUnitsPerPixel() / rasterScaleFactor );
             rasterMapToPixel.setYMaximum( mSize.height() * rasterScaleFactor );
             mRenderContext.setMapToPixel( rasterMapToPixel );
             mRenderContext.painter()->save();
             mRenderContext.painter()->scale( 1.0 / rasterScaleFactor, 1.0 / rasterScaleFactor );
+          }
           //create overlay objects for features within the view extent
           if ( ml->type() == QgsMapLayer::VectorLayer && overlayManager )
+          {
-...
+            }
+          }
           // Force render of layers that are being edited
           if ( ml->type() == QgsMapLayer::VectorLayer )
+          {
             QgsVectorLayer* vl = qobject_cast<QgsVectorLayer *>( ml );
             if ( vl->isEditable() )
+            {
               ml->setCacheImage( 0 );
+            }
+          }
           QSettings mySettings;
           if ( ! split )//render caching does not yet cater for split extents
+          {
             if ( mySettings.value ( "/qgis/enable_render_caching", false ).toBool() )
+            {
               if ( !mySameAsLastFlag || ml->cacheImage() == 0 )
+              {
                 QgsDebugMsg( "\n\n\nCaching enabled but layer redraw forced by extent change or empty cache\n\n\n" );
                 QImage * mypImage = new QImage( mRenderContext.painter()->device()->width(),
                     mRenderContext.painter()->device()->height(), QImage::Format_ARGB32 );
                 mypImage->fill( 0 );
                 ml->setCacheImage( mypImage ); //no need to delete the oldone, maplayer does it for you
                 QPainter * mypPainter = new QPainter( ml->cacheImage() );
                 if ( mySettings.value( "/qgis/enable_anti_aliasing", false ).toBool() )
+                {
                   mypPainter->setRenderHint( QPainter::Antialiasing );
+                }
                 mRenderContext.setPainter( mypPainter  );
+              }
               else if ( mySameAsLastFlag )
+              {
                 //draw from cached image
                 QgsDebugMsg( "\n\n\nCaching enabled --- drawing layer from cached image\n\n\n" );
                 mypContextPainter->drawImage( 0,0, *(ml->cacheImage()) );
                 disconnect( ml, SIGNAL( drawingProgress( int, int ) ), this, SLOT( onDrawingProgress( int, int ) ) );
                 //short circuit as there is nothing else to do...
                 continue;
+              }
+            }
+          }
           if ( scaleRaster )
+          {
             bk_mapToPixel = mRenderContext.mapToPixel();
             rasterMapToPixel = mRenderContext.mapToPixel();
             rasterMapToPixel.setMapUnitsPerPixel( mRenderContext.mapToPixel().mapUnitsPerPixel() / rasterScaleFactor );
             rasterMapToPixel.setYMaximum( mSize.height() * rasterScaleFactor );
             mRenderContext.setMapToPixel( rasterMapToPixel );
             mRenderContext.painter()->save();
             mRenderContext.painter()->scale( 1.0 / rasterScaleFactor, 1.0 / rasterScaleFactor );
+          }
           if ( !ml->draw( mRenderContext ) )
+          {
             emit drawError( ml );
+          }
           else
+          {
                 QgsDebugMsg( "\n\n\nLayer rendered without issues\n\n\n" );
+          }
           if ( split )
+          {
             mRenderContext.setExtent( r2 );
-...
             mRenderContext.painter()->restore();
+          }
           if ( mySettings.value ( "/qgis/enable_render_caching", false ).toBool() )
+          {
             if ( !split )
+            {
               // composite the cached image into our view and then clean up from caching
               // by reinstating the painter as it was swapped out for caching renders
               delete mRenderContext.painter();
               mRenderContext.setPainter( mypContextPainter  );
               //draw from cached image that we created further up
               mypContextPainter->drawImage( 0,0, *(ml->cacheImage()) );
+            }
+          }
           disconnect( ml, SIGNAL( drawingProgress( int, int ) ), this, SLOT( onDrawingProgress( int, int ) ) );
+        }
         else
         else // layer not visible due to scale
+        {
           QgsDebugMsg( "Layer not rendered because it is not within the defined "
                        "visibility scale range" );
               "visibility scale range" );
+        }
       } // while (li.hasPrevious())

     } // QgsMapLayerRegistry::removeAllMapLayers()
     //Added in QGIS 1.4
     void QgsMapLayerRegistry::clearAllLayerCaches()
+    {
       QMap<QString, QgsMapLayer *>::iterator it;
       for ( it = mMapLayers.begin(); it != mMapLayers.end() ; ++it )
+      {
         //the map layer will take care of deleting the QImage
         it.value()->setCacheImage( 0 );
+      }
     } // QgsMapLayerRegistry::clearAllLayerCaches()
     QMap<QString, QgsMapLayer*> & QgsMapLayerRegistry::mapLayers()
+    {

         */
         void removeAllMapLayers();
         /* Clears all layer caches, resetting them to zero and
          * freeing up any memory they may have been using. Layer
          * caches are used to speed up rendering in certain situations
          * see ticket #1974 for more details.
          * @note this method was added in QGIS 1.4
          */
          void clearAllLayerCaches();
       signals:
         /** emitted when a layer is removed from the registry

     #include <QObject>
     #include <QUndoStack>
     #include <QImage>
     #include "qgsrectangle.h"
-...
         /** Return pointer to layer's undo stack */
         QUndoStack* undoStack();
         /** Get the QImage used for caching render operations
          * @note This method was added in QGIS 1.4 **/
         QImage * cacheImage() { return mpCacheImage; }
         /** Set the QImage used for caching render operations
          * @note This method was added in QGIS 1.4 **/
         void setCacheImage( QImage * thepImage );
       public slots:
         /** Event handler for when a coordinate transform fails due to bad vertex error */
-...
         /** A flag that tells us whether to use the above vars to restrict layer visibility */
         bool mScaleBasedVisibility;
         /** Collection of undoable operations for this layer. **/
         QUndoStack mUndoStack;
         /**QImage for caching of rendering operations
          * @note This property was added in QGIS 1.4 **/
         QImage * mpCacheImage;
     };
     #endif

        <string>Options</string>
       </property>
       <property name="windowIcon" >
        <iconset>
         <normaloff/>
        </iconset>
        <iconset/>
       </property>
       <property name="sizeGripEnabled" >
        <bool>true</bool>
-...
                </widget>
               </item>
               <item row="1" column="0" colspan="2" >
                <spacer name="verticalSpacer">
                 <property name="orientation">
                <spacer>
                 <property name="orientation" >
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                 <property name="sizeType" >
                  <enum>QSizePolicy::Fixed</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                 <property name="sizeHint" >
                  <size>
                   <width>20</width>
                   <height>10</height>
                  </size>
                 </property>
                </spacer>
               </item>
               </item>
               <item row="2" column="0" colspan="2" >
                <widget class="QCheckBox" name="capitaliseCheckBox" >
                 <property name="text" >
-...
                 </property>
                </widget>
               </item>
               <item row="3" column="0" colspan="2" >
                <widget class="QCheckBox" name="chkUseRenderCaching" >
                 <property name="text" >
                  <string>Use render caching where possible to speed up redraws</string>
                 </property>
                </widget>
               </item>
              </layout>
             </widget>
            </item>
-...
              </property>
              <property name="sizeHint" >
               <size>
                <width>20</width>
                <height>40</height>
                <width>614</width>
                <height>111</height>
               </size>
              </property>
             </spacer>
-...
       </customwidget>
      </customwidgets>
      <tabstops>
       <tabstop>tabWidget</tabstop>
       <tabstop>chbAskToSaveProjectChanges</tabstop>
       <tabstop>chbWarnOldProjectVersion</tabstop>
       <tabstop>pbnSelectionColour</tabstop>
       <tabstop>pbnCanvasColor</tabstop>
       <tabstop>cmbTheme</tabstop>
       <tabstop>capitaliseCheckBox</tabstop>
       <tabstop>cbxLegendClassifiers</tabstop>
       <tabstop>cbxHideSplash</tabstop>
       <tabstop>cbxIdentifyResultsDocked</tabstop>
       <tabstop>cbxAttributeTableDocked</tabstop>
       <tabstop>cbxAddPostgisDC</tabstop>
       <tabstop>chkAddedVisibility</tabstop>
       <tabstop>spinBoxUpdateThreshold</tabstop>
       <tabstop>chkUseRenderCaching</tabstop>
       <tabstop>chkAntiAliasing</tabstop>
       <tabstop>chkUseQPixmap</tabstop>
       <tabstop>cmbIdentifyMode</tabstop>
       <tabstop>spinBoxIdentifyValue</tabstop>
       <tabstop>cmbEllipsoid</tabstop>
       <tabstop>pbnMeasureColour</tabstop>
       <tabstop>radMeters</tabstop>
       <tabstop>radFeet</tabstop>
       <tabstop>cmbWheelAction</tabstop>
       <tabstop>spinZoomFactor</tabstop>
       <tabstop>mOverlayAlgorithmComboBox</tabstop>
       <tabstop>mLineWidthSpinBox</tabstop>
       <tabstop>mLineColourToolButton</tabstop>
       <tabstop>mDefaultSnapModeComboBox</tabstop>
       <tabstop>mDefaultSnappingToleranceSpinBox</tabstop>
       <tabstop>mSearchRadiusVertexEditSpinBox</tabstop>
       <tabstop>mDefaultSnappingToleranceComboBox</tabstop>
       <tabstop>mSearchRadiusVertexEditComboBox</tabstop>
       <tabstop>mMarkersOnlyForSelectedCheckBox</tabstop>
       <tabstop>mMarkerStyleComboBox</tabstop>
       <tabstop>mMarkerSizeSpinBox</tabstop>
       <tabstop>chkDisableAttributeValuesDlg</tabstop>
       <tabstop>radPromptForProjection</tabstop>
       <tabstop>radUseProjectProjection</tabstop>
       <tabstop>radUseGlobalProjection</tabstop>
-...
       <tabstop>pbnSelectProjection</tabstop>
       <tabstop>grpLocale</tabstop>
       <tabstop>cboLocale</tabstop>
       <tabstop>grpProxy</tabstop>
       <tabstop>leProxyHost</tabstop>
       <tabstop>leProxyPort</tabstop>
       <tabstop>leProxyUser</tabstop>
       <tabstop>leProxyPassword</tabstop>
       <tabstop>mProxyTypeComboBox</tabstop>
       <tabstop>mAddUrlPushButton</tabstop>
       <tabstop>mRemoveUrlPushButton</tabstop>
       <tabstop>mExcludeUrlListWidget</tabstop>
       <tabstop>buttonBox</tabstop>
       <tabstop>tabWidget</tabstop>
      </tabstops>
      <resources/>
      <connections/>

QGIS » QGIS Application