indentation update

jef · jef · commit 731c1b8fd13d · 2009-06-01T21:18:16.000Z
git-svn-id: http://svn.osgeo.org/qgis/trunk/qgis@10872 c8812cc2-4d05-0410-92ff-de0c093fc19c
diff --git a/src/core/composer/qgscomposeritem.cpp b/src/core/composer/qgscomposeritem.cpp
@@ -34,7 +34,7 @@
 #define FONT_WORKAROUND_SCALE 10 //scale factor for upscaling fontsize and downscaling painter
 
 QgsComposerItem::QgsComposerItem( QgsComposition* composition, bool manageZValue ): QGraphicsRectItem( 0 ), mComposition( composition ), mBoundingResizeRectangle( 0 ), \
-        mFrame( true ), mItemPositionLocked(false)
+    mFrame( true ), mItemPositionLocked( false )
 {
   setFlag( QGraphicsItem::ItemIsSelectable, true );
   setAcceptsHoverEvents( true );
@@ -125,13 +125,13 @@ bool QgsComposerItem::_writeXML( QDomElement& itemElem, QDomDocument& doc ) cons
   composerItemElem.setAttribute( "outlineWidth", QString::number( pen().widthF() ) );
 
   //position lock for mouse moves/resizes
-  if(mItemPositionLocked)
+  if ( mItemPositionLocked )
   {
-    composerItemElem.setAttribute( "positionLock", "true");
+    composerItemElem.setAttribute( "positionLock", "true" );
   }
   else
   {
-    composerItemElem.setAttribute( "positionLock", "false");
+    composerItemElem.setAttribute( "positionLock", "false" );
   }
 
 
@@ -177,14 +177,14 @@ bool QgsComposerItem::_readXML( const QDomElement& itemElem, const QDomDocument&
   }
 
   //position lock for mouse moves/resizes
-  QString positionLock = itemElem.attribute("positionLock");
-  if(positionLock.compare("true", Qt::CaseInsensitive) == 0)
+  QString positionLock = itemElem.attribute( "positionLock" );
+  if ( positionLock.compare( "true", Qt::CaseInsensitive ) == 0 )
   {
-      mItemPositionLocked = true;
+    mItemPositionLocked = true;
   }
   else
   {
-      mItemPositionLocked = false;
+    mItemPositionLocked = false;
   }
 
   //position
@@ -246,10 +246,10 @@ bool QgsComposerItem::_readXML( const QDomElement& itemElem, const QDomDocument&
 
 void QgsComposerItem::mouseMoveEvent( QGraphicsSceneMouseEvent * event )
 {
-    if(mItemPositionLocked)
-    {
-        return;
-    }
+  if ( mItemPositionLocked )
+  {
+    return;
+  }
 
   if ( mBoundingResizeRectangle )
   {
@@ -263,10 +263,10 @@ void QgsComposerItem::mouseMoveEvent( QGraphicsSceneMouseEvent * event )
 
 void QgsComposerItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
 {
-    if(mItemPositionLocked)
-    {
-        return;
-    }
+  if ( mItemPositionLocked )
+  {
+    return;
+  }
 
   //set current position and type of mouse move action
   mMouseMoveStartPos = event->lastScenePos();
@@ -297,10 +297,10 @@ void QgsComposerItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
 void QgsComposerItem::mouseReleaseEvent( QGraphicsSceneMouseEvent * event )
 {
 
-    if(mItemPositionLocked)
-    {
-        return;
-    }
+  if ( mItemPositionLocked )
+  {
+    return;
+  }
 
   //delete frame rectangle
   if ( mBoundingResizeRectangle )
@@ -331,9 +331,9 @@ Qt::CursorShape QgsComposerItem::cursorForPosition( const QPointF& itemCoordPos
 {
   QgsComposerItem::MouseMoveAction mouseAction = mouseMoveActionForPosition( itemCoordPos );
 
-  if( mouseAction == QgsComposerItem::NoAction)
+  if ( mouseAction == QgsComposerItem::NoAction )
   {
-      return Qt::ForbiddenCursor;
+    return Qt::ForbiddenCursor;
   }
   if ( mouseAction == QgsComposerItem::MoveItem )
   {
@@ -361,9 +361,9 @@ QgsComposerItem::MouseMoveAction QgsComposerItem::mouseMoveActionForPosition( co
 {
 
   //no action at all if item position is locked for mouse
-  if(mItemPositionLocked)
+  if ( mItemPositionLocked )
   {
-      return QgsComposerItem::NoAction;
+    return QgsComposerItem::NoAction;
   }
 
   bool nearLeftBorder = false;
@@ -434,7 +434,7 @@ void QgsComposerItem::changeItemRectangle( const QPointF& currentPosition, const
   }
 
   //test if change item is a composer item. If so, prefer call to  setSceneRect() instead of setTransform() and setRect()
-  QgsComposerItem* changeComposerItem = dynamic_cast<QgsComposerItem*>(changeItem);
+  QgsComposerItem* changeComposerItem = dynamic_cast<QgsComposerItem*>( changeItem );
 
   double mx = 0.0, my = 0.0, rx = 0.0, ry = 0.0;
   QPointF snappedPosition = mComposition->snapPointToGrid( currentPosition );
@@ -504,22 +504,22 @@ void QgsComposerItem::changeItemRectangle( const QPointF& currentPosition, const
       double moveRectX = snappedLeftPoint.x() - originalItem->transform().dx();
       double moveRectY = snappedLeftPoint.y() - originalItem->transform().dy();
 
-      if(!changeComposerItem)
+      if ( !changeComposerItem )
       {
         QTransform moveTransform;
         moveTransform.translate( originalItem->transform().dx() + moveRectX, originalItem->transform().dy() + moveRectY );
         changeItem->setTransform( moveTransform );
       }
       else  //for composer items, we prefer setSceneRect as subclasses can implement custom behaviour (e.g. item group)
       {
-        changeComposerItem->setSceneRect(QRectF(originalItem->transform().dx() + moveRectX, \
-                                                originalItem->transform().dy() + moveRectY, \
-                                                originalItem->rect().width(), originalItem->rect().height()));
+        changeComposerItem->setSceneRect( QRectF( originalItem->transform().dx() + moveRectX, \
+                                          originalItem->transform().dy() + moveRectY, \
+                                          originalItem->rect().width(), originalItem->rect().height() ) );
       }
       return;
   }
 
-  if(!changeComposerItem)
+  if ( !changeComposerItem )
   {
     QTransform itemTransform;
     itemTransform.translate( originalItem->transform().dx() + mx, originalItem->transform().dy() + my );
@@ -529,8 +529,8 @@ void QgsComposerItem::changeItemRectangle( const QPointF& currentPosition, const
   }
   else //for composer items, we prefer setSceneRect as subclasses can implement custom behaviour (e.g. item group)
   {
-    changeComposerItem->setSceneRect( QRectF(originalItem->transform().dx() + mx, originalItem->transform().dy() + my, \
-      originalItem->rect().width() + rx, originalItem->rect().height() + ry) );
+    changeComposerItem->setSceneRect( QRectF( originalItem->transform().dx() + mx, originalItem->transform().dy() + my, \
+                                      originalItem->rect().width() + rx, originalItem->rect().height() + ry ) );
   }
 }
 
@@ -548,29 +548,29 @@ void QgsComposerItem::drawSelectionBoxes( QPainter* p )
     double rectHandlerSize = rectHandlerBorderTolerance();
     double sizeLockSymbol = lockSymbolSize();
 
-    if(mItemPositionLocked)
+    if ( mItemPositionLocked )
     {
-        //draw lock symbol at upper left edge. Use QImage to be independant of the graphic system
-        QString lockIconPath = QgsApplication::activeThemePath() + "/mIconLock.png";
-        if(!QFile::exists(lockIconPath))
-        {
-            lockIconPath = QgsApplication::defaultThemePath() + "/mIconLock.png";
-        }
-
-        QImage lockImage(lockIconPath);
-        if(!lockImage.isNull())
-        {
-            p->drawImage(QRectF(0, 0, sizeLockSymbol, sizeLockSymbol), lockImage, QRectF(0, 0, lockImage.width(), lockImage.height()));
-        }
+      //draw lock symbol at upper left edge. Use QImage to be independant of the graphic system
+      QString lockIconPath = QgsApplication::activeThemePath() + "/mIconLock.png";
+      if ( !QFile::exists( lockIconPath ) )
+      {
+        lockIconPath = QgsApplication::defaultThemePath() + "/mIconLock.png";
+      }
+
+      QImage lockImage( lockIconPath );
+      if ( !lockImage.isNull() )
+      {
+        p->drawImage( QRectF( 0, 0, sizeLockSymbol, sizeLockSymbol ), lockImage, QRectF( 0, 0, lockImage.width(), lockImage.height() ) );
+      }
     }
     else //draw blue squares
     {
-        p->setPen( QPen( QColor( 0, 0, 255 ) ) );
-        p->setBrush( QBrush( QColor( 0, 0, 255 ) ) );
-        p->drawRect( QRectF( 0, 0, rectHandlerSize, rectHandlerSize ) );
-        p->drawRect( QRectF( rect().width() - rectHandlerSize, 0, rectHandlerSize, rectHandlerSize ) );
-        p->drawRect( QRectF( rect().width() - rectHandlerSize, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );
-        p->drawRect( QRectF( 0, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );
+      p->setPen( QPen( QColor( 0, 0, 255 ) ) );
+      p->setBrush( QBrush( QColor( 0, 0, 255 ) ) );
+      p->drawRect( QRectF( 0, 0, rectHandlerSize, rectHandlerSize ) );
+      p->drawRect( QRectF( rect().width() - rectHandlerSize, 0, rectHandlerSize, rectHandlerSize ) );
+      p->drawRect( QRectF( rect().width() - rectHandlerSize, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );
+      p->drawRect( QRectF( 0, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );
     }
   }
 }
@@ -749,38 +749,38 @@ double QgsComposerItem::horizontalViewScaleFactor() const
 
 double QgsComposerItem::rectHandlerBorderTolerance() const
 {
-     //size of symbol boxes depends on zoom level in composer view
-    double viewScaleFactor = horizontalViewScaleFactor();
-    double rectHandlerSize = 10.0 / viewScaleFactor;
+  //size of symbol boxes depends on zoom level in composer view
+  double viewScaleFactor = horizontalViewScaleFactor();
+  double rectHandlerSize = 10.0 / viewScaleFactor;
 
-    //make sure the boxes don't get too large
-    if(rectHandlerSize > (rect().width() / 3))
-    {
-        rectHandlerSize = rect().width() / 3;
-    }
-    if(rectHandlerSize > (rect().height() / 3))
-    {
-        rectHandlerSize = rect().height() / 3;
-    }
-    return rectHandlerSize;
+  //make sure the boxes don't get too large
+  if ( rectHandlerSize > ( rect().width() / 3 ) )
+  {
+    rectHandlerSize = rect().width() / 3;
+  }
+  if ( rectHandlerSize > ( rect().height() / 3 ) )
+  {
+    rectHandlerSize = rect().height() / 3;
+  }
+  return rectHandlerSize;
 }
 
 double QgsComposerItem::lockSymbolSize() const
 {
   double lockSymbolSize = 20.0 / horizontalViewScaleFactor();
 
-  if(lockSymbolSize > (rect().width() / 3))
+  if ( lockSymbolSize > ( rect().width() / 3 ) )
   {
     lockSymbolSize = rect().width() / 3;
   }
-  if(lockSymbolSize > (rect().height() / 3))
+  if ( lockSymbolSize > ( rect().height() / 3 ) )
   {
     lockSymbolSize = rect().height() / 3;
   }
   return lockSymbolSize;
 }
 
-void QgsComposerItem::updateCursor(const QPointF& itemPos)
+void QgsComposerItem::updateCursor( const QPointF& itemPos )
 {
-    setCursor( cursorForPosition(itemPos) );
+  setCursor( cursorForPosition( itemPos ) );
 }
diff --git a/src/gui/qgscomposerview.cpp b/src/gui/qgscomposerview.cpp
@@ -46,19 +46,19 @@ void QgsComposerView::mousePressEvent( QMouseEvent* e )
   QPointF snappedScenePoint = composition()->snapPointToGrid( scenePoint );
 
   //lock/unlock position of item with right click
-  if(e->button() == Qt::RightButton)
+  if ( e->button() == Qt::RightButton )
   {
-     QgsComposerItem* selectedItem = composition()->composerItemAt( scenePoint );
-     if(selectedItem)
-     {
-         bool lock = selectedItem->positionLock() ? false : true;
-         selectedItem->setPositionLock(lock);
-         selectedItem->update();
-         //make sure the new cursor is correct
-         QPointF itemPoint = selectedItem->mapFromScene( scenePoint );
-         selectedItem->updateCursor(itemPoint);
-     }
-     return;
+    QgsComposerItem* selectedItem = composition()->composerItemAt( scenePoint );
+    if ( selectedItem )
+    {
+      bool lock = selectedItem->positionLock() ? false : true;
+      selectedItem->setPositionLock( lock );
+      selectedItem->update();
+      //make sure the new cursor is correct
+      QPointF itemPoint = selectedItem->mapFromScene( scenePoint );
+      selectedItem->updateCursor( itemPoint );
+    }
+    return;
   }
 
   switch ( mCurrentTool )
@@ -101,7 +101,7 @@ void QgsComposerView::mousePressEvent( QMouseEvent* e )
     {
       QTransform t;
       mRubberBandItem = new QGraphicsRectItem( 0, 0, 0, 0 );
-      mRubberBandStartPos = QPointF(snappedScenePoint.x(), snappedScenePoint.y());
+      mRubberBandStartPos = QPointF( snappedScenePoint.x(), snappedScenePoint.y() );
       t.translate( snappedScenePoint.x(), snappedScenePoint.y() );
       mRubberBandItem->setTransform( t );
       mRubberBandItem->setZValue( 100 );
@@ -236,44 +236,44 @@ void QgsComposerView::mouseMoveEvent( QMouseEvent* e )
 
       case AddMap:
         //adjust rubber band item
+      {
+        double x = 0;
+        double y = 0;
+        double width = 0;
+        double height = 0;
+
+        double dx = scenePoint.x() - mRubberBandStartPos.x();
+        double dy = scenePoint.y() - mRubberBandStartPos.y();
+
+        if ( dx < 0 )
+        {
+          x = scenePoint.x();
+          width = -dx;
+        }
+        else
         {
-          double x = 0;
-          double y = 0;
-          double width = 0;
-          double height = 0;
-
-          double dx = scenePoint.x() - mRubberBandStartPos.x();
-          double dy = scenePoint.y() - mRubberBandStartPos.y();
-
-          if(dx < 0)
-          {
-            x = scenePoint.x();
-            width = -dx;
-          }
-          else
-          {
-            x = mRubberBandStartPos.x();
-            width = dx;
-          }
-
-          if(dy < 0)
-          {
-            y = scenePoint.y();
-            height = -dy;
-          }
-          else
-          {
-            y = mRubberBandStartPos.y();
-            height = dy;
-          }
-
-          mRubberBandItem->setRect( 0, 0, width, height );
-          QTransform t;
-          t.translate(x, y);
-          mRubberBandItem->setTransform(t);
-          break;
+          x = mRubberBandStartPos.x();
+          width = dx;
         }
 
+        if ( dy < 0 )
+        {
+          y = scenePoint.y();
+          height = -dy;
+        }
+        else
+        {
+          y = mRubberBandStartPos.y();
+          height = dy;
+        }
+
+        mRubberBandItem->setRect( 0, 0, width, height );
+        QTransform t;
+        t.translate( x, y );
+        mRubberBandItem->setTransform( t );
+        break;
+      }
+
       case MoveItemContent:
       {
         //update map preview if composer map
diff --git a/src/plugins/diagram_overlay/qgsdiagramoverlay.cpp b/src/plugins/diagram_overlay/qgsdiagramoverlay.cpp

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@`
`34`	`34`	`#define FONT_WORKAROUND_SCALE 10 //scale factor for upscaling fontsize and downscaling painter`
`35`	`35`
`36`	`36`	`QgsComposerItem::QgsComposerItem( QgsComposition* composition, bool manageZValue ): QGraphicsRectItem( 0 ), mComposition( composition ), mBoundingResizeRectangle( 0 ), \`
`37`		`- mFrame( true ), mItemPositionLocked(false)`
	`37`	`+ mFrame( true ), mItemPositionLocked( false )`
`38`	`38`	`{`
`39`	`39`	`setFlag( QGraphicsItem::ItemIsSelectable, true );`
`40`	`40`	`setAcceptsHoverEvents( true );`
`@@ -125,13 +125,13 @@ bool QgsComposerItem::_writeXML( QDomElement& itemElem, QDomDocument& doc ) cons`
`125`	`125`	`composerItemElem.setAttribute( "outlineWidth", QString::number( pen().widthF() ) );`
`126`	`126`
`127`	`127`	`//position lock for mouse moves/resizes`
`128`		`- if(mItemPositionLocked)`
	`128`	`+ if ( mItemPositionLocked )`
`129`	`129`	`{`
`130`		`- composerItemElem.setAttribute( "positionLock", "true");`
	`130`	`+ composerItemElem.setAttribute( "positionLock", "true" );`
`131`	`131`	`}`
`132`	`132`	`else`
`133`	`133`	`{`
`134`		`- composerItemElem.setAttribute( "positionLock", "false");`
	`134`	`+ composerItemElem.setAttribute( "positionLock", "false" );`
`135`	`135`	`}`
`136`	`136`
`137`	`137`
`@@ -177,14 +177,14 @@ bool QgsComposerItem::_readXML( const QDomElement& itemElem, const QDomDocument&`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`//position lock for mouse moves/resizes`
`180`		`- QString positionLock = itemElem.attribute("positionLock");`
`181`		`- if(positionLock.compare("true", Qt::CaseInsensitive) == 0)`
	`180`	`+ QString positionLock = itemElem.attribute( "positionLock" );`
	`181`	`+ if ( positionLock.compare( "true", Qt::CaseInsensitive ) == 0 )`
`182`	`182`	`{`
`183`		`- mItemPositionLocked = true;`
	`183`	`+ mItemPositionLocked = true;`
`184`	`184`	`}`
`185`	`185`	`else`
`186`	`186`	`{`
`187`		`- mItemPositionLocked = false;`
	`187`	`+ mItemPositionLocked = false;`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`//position`
`@@ -246,10 +246,10 @@ bool QgsComposerItem::_readXML( const QDomElement& itemElem, const QDomDocument&`
`246`	`246`
`247`	`247`	`void QgsComposerItem::mouseMoveEvent( QGraphicsSceneMouseEvent * event )`
`248`	`248`	`{`
`249`		`- if(mItemPositionLocked)`
`250`		`- {`
`251`		`- return;`
`252`		`- }`
	`249`	`+ if ( mItemPositionLocked )`
	`250`	`+ {`
	`251`	`+ return;`
	`252`	`+ }`
`253`	`253`
`254`	`254`	`if ( mBoundingResizeRectangle )`
`255`	`255`	`{`
`@@ -263,10 +263,10 @@ void QgsComposerItem::mouseMoveEvent( QGraphicsSceneMouseEvent * event )`
`263`	`263`
`264`	`264`	`void QgsComposerItem::mousePressEvent( QGraphicsSceneMouseEvent * event )`
`265`	`265`	`{`
`266`		`- if(mItemPositionLocked)`
`267`		`- {`
`268`		`- return;`
`269`		`- }`
	`266`	`+ if ( mItemPositionLocked )`
	`267`	`+ {`
	`268`	`+ return;`
	`269`	`+ }`
`270`	`270`
`271`	`271`	`//set current position and type of mouse move action`
`272`	`272`	`mMouseMoveStartPos = event->lastScenePos();`
`@@ -297,10 +297,10 @@ void QgsComposerItem::mousePressEvent( QGraphicsSceneMouseEvent * event )`
`297`	`297`	`void QgsComposerItem::mouseReleaseEvent( QGraphicsSceneMouseEvent * event )`
`298`	`298`	`{`
`299`	`299`
`300`		`- if(mItemPositionLocked)`
`301`		`- {`
`302`		`- return;`
`303`		`- }`
	`300`	`+ if ( mItemPositionLocked )`
	`301`	`+ {`
	`302`	`+ return;`
	`303`	`+ }`
`304`	`304`
`305`	`305`	`//delete frame rectangle`
`306`	`306`	`if ( mBoundingResizeRectangle )`
`@@ -331,9 +331,9 @@ Qt::CursorShape QgsComposerItem::cursorForPosition( const QPointF& itemCoordPos`
`331`	`331`	`{`
`332`	`332`	`QgsComposerItem::MouseMoveAction mouseAction = mouseMoveActionForPosition( itemCoordPos );`
`333`	`333`
`334`		`- if( mouseAction == QgsComposerItem::NoAction)`
	`334`	`+ if ( mouseAction == QgsComposerItem::NoAction )`
`335`	`335`	`{`
`336`		`- return Qt::ForbiddenCursor;`
	`336`	`+ return Qt::ForbiddenCursor;`
`337`	`337`	`}`
`338`	`338`	`if ( mouseAction == QgsComposerItem::MoveItem )`
`339`	`339`	`{`
`@@ -361,9 +361,9 @@ QgsComposerItem::MouseMoveAction QgsComposerItem::mouseMoveActionForPosition( co`
`361`	`361`	`{`
`362`	`362`
`363`	`363`	`//no action at all if item position is locked for mouse`
`364`		`- if(mItemPositionLocked)`
	`364`	`+ if ( mItemPositionLocked )`
`365`	`365`	`{`
`366`		`- return QgsComposerItem::NoAction;`
	`366`	`+ return QgsComposerItem::NoAction;`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`bool nearLeftBorder = false;`
`@@ -434,7 +434,7 @@ void QgsComposerItem::changeItemRectangle( const QPointF& currentPosition, const`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`//test if change item is a composer item. If so, prefer call to setSceneRect() instead of setTransform() and setRect()`
`437`		`- QgsComposerItem* changeComposerItem = dynamic_cast<QgsComposerItem*>(changeItem);`
	`437`	`+ QgsComposerItem* changeComposerItem = dynamic_cast<QgsComposerItem*>( changeItem );`
`438`	`438`
`439`	`439`	`double mx = 0.0, my = 0.0, rx = 0.0, ry = 0.0;`
`440`	`440`	`QPointF snappedPosition = mComposition->snapPointToGrid( currentPosition );`
`@@ -504,22 +504,22 @@ void QgsComposerItem::changeItemRectangle( const QPointF& currentPosition, const`
`504`	`504`	`double moveRectX = snappedLeftPoint.x() - originalItem->transform().dx();`
`505`	`505`	`double moveRectY = snappedLeftPoint.y() - originalItem->transform().dy();`
`506`	`506`
`507`		`- if(!changeComposerItem)`
	`507`	`+ if ( !changeComposerItem )`
`508`	`508`	`{`
`509`	`509`	`QTransform moveTransform;`
`510`	`510`	`moveTransform.translate( originalItem->transform().dx() + moveRectX, originalItem->transform().dy() + moveRectY );`
`511`	`511`	`changeItem->setTransform( moveTransform );`
`512`	`512`	`}`
`513`	`513`	`else //for composer items, we prefer setSceneRect as subclasses can implement custom behaviour (e.g. item group)`
`514`	`514`	`{`
`515`		`- changeComposerItem->setSceneRect(QRectF(originalItem->transform().dx() + moveRectX, \`
`516`		`- originalItem->transform().dy() + moveRectY, \`
`517`		`- originalItem->rect().width(), originalItem->rect().height()));`
	`515`	`+ changeComposerItem->setSceneRect( QRectF( originalItem->transform().dx() + moveRectX, \`
	`516`	`+ originalItem->transform().dy() + moveRectY, \`
	`517`	`+ originalItem->rect().width(), originalItem->rect().height() ) );`
`518`	`518`	`}`
`519`	`519`	`return;`
`520`	`520`	`}`
`521`	`521`
`522`		`- if(!changeComposerItem)`
	`522`	`+ if ( !changeComposerItem )`
`523`	`523`	`{`
`524`	`524`	`QTransform itemTransform;`
`525`	`525`	`itemTransform.translate( originalItem->transform().dx() + mx, originalItem->transform().dy() + my );`
`@@ -529,8 +529,8 @@ void QgsComposerItem::changeItemRectangle( const QPointF& currentPosition, const`
`529`	`529`	`}`
`530`	`530`	`else //for composer items, we prefer setSceneRect as subclasses can implement custom behaviour (e.g. item group)`
`531`	`531`	`{`
`532`		`- changeComposerItem->setSceneRect( QRectF(originalItem->transform().dx() + mx, originalItem->transform().dy() + my, \`
`533`		`- originalItem->rect().width() + rx, originalItem->rect().height() + ry) );`
	`532`	`+ changeComposerItem->setSceneRect( QRectF( originalItem->transform().dx() + mx, originalItem->transform().dy() + my, \`
	`533`	`+ originalItem->rect().width() + rx, originalItem->rect().height() + ry ) );`
`534`	`534`	`}`
`535`	`535`	`}`
`536`	`536`
`@@ -548,29 +548,29 @@ void QgsComposerItem::drawSelectionBoxes( QPainter* p )`
`548`	`548`	`double rectHandlerSize = rectHandlerBorderTolerance();`
`549`	`549`	`double sizeLockSymbol = lockSymbolSize();`
`550`	`550`
`551`		`- if(mItemPositionLocked)`
	`551`	`+ if ( mItemPositionLocked )`
`552`	`552`	`{`
`553`		`- //draw lock symbol at upper left edge. Use QImage to be independant of the graphic system`
`554`		`- QString lockIconPath = QgsApplication::activeThemePath() + "/mIconLock.png";`
`555`		`- if(!QFile::exists(lockIconPath))`
`556`		`- {`
`557`		`- lockIconPath = QgsApplication::defaultThemePath() + "/mIconLock.png";`
`558`		`- }`
`559`		`-`
`560`		`- QImage lockImage(lockIconPath);`
`561`		`- if(!lockImage.isNull())`
`562`		`- {`
`563`		`- p->drawImage(QRectF(0, 0, sizeLockSymbol, sizeLockSymbol), lockImage, QRectF(0, 0, lockImage.width(), lockImage.height()));`
`564`		`- }`
	`553`	`+ //draw lock symbol at upper left edge. Use QImage to be independant of the graphic system`
	`554`	`+ QString lockIconPath = QgsApplication::activeThemePath() + "/mIconLock.png";`
	`555`	`+ if ( !QFile::exists( lockIconPath ) )`
	`556`	`+ {`
	`557`	`+ lockIconPath = QgsApplication::defaultThemePath() + "/mIconLock.png";`
	`558`	`+ }`
	`559`	`+`
	`560`	`+ QImage lockImage( lockIconPath );`
	`561`	`+ if ( !lockImage.isNull() )`
	`562`	`+ {`
	`563`	`+ p->drawImage( QRectF( 0, 0, sizeLockSymbol, sizeLockSymbol ), lockImage, QRectF( 0, 0, lockImage.width(), lockImage.height() ) );`
	`564`	`+ }`
`565`	`565`	`}`
`566`	`566`	`else //draw blue squares`
`567`	`567`	`{`
`568`		`- p->setPen( QPen( QColor( 0, 0, 255 ) ) );`
`569`		`- p->setBrush( QBrush( QColor( 0, 0, 255 ) ) );`
`570`		`- p->drawRect( QRectF( 0, 0, rectHandlerSize, rectHandlerSize ) );`
`571`		`- p->drawRect( QRectF( rect().width() - rectHandlerSize, 0, rectHandlerSize, rectHandlerSize ) );`
`572`		`- p->drawRect( QRectF( rect().width() - rectHandlerSize, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );`
`573`		`- p->drawRect( QRectF( 0, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );`
	`568`	`+ p->setPen( QPen( QColor( 0, 0, 255 ) ) );`
	`569`	`+ p->setBrush( QBrush( QColor( 0, 0, 255 ) ) );`
	`570`	`+ p->drawRect( QRectF( 0, 0, rectHandlerSize, rectHandlerSize ) );`
	`571`	`+ p->drawRect( QRectF( rect().width() - rectHandlerSize, 0, rectHandlerSize, rectHandlerSize ) );`
	`572`	`+ p->drawRect( QRectF( rect().width() - rectHandlerSize, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );`
	`573`	`+ p->drawRect( QRectF( 0, rect().height() - rectHandlerSize, rectHandlerSize, rectHandlerSize ) );`
`574`	`574`	`}`
`575`	`575`	`}`
`576`	`576`	`}`
`@@ -749,38 +749,38 @@ double QgsComposerItem::horizontalViewScaleFactor() const`
`749`	`749`
`750`	`750`	`double QgsComposerItem::rectHandlerBorderTolerance() const`
`751`	`751`	`{`
`752`		`- //size of symbol boxes depends on zoom level in composer view`
`753`		`- double viewScaleFactor = horizontalViewScaleFactor();`
`754`		`- double rectHandlerSize = 10.0 / viewScaleFactor;`
	`752`	`+ //size of symbol boxes depends on zoom level in composer view`
	`753`	`+ double viewScaleFactor = horizontalViewScaleFactor();`
	`754`	`+ double rectHandlerSize = 10.0 / viewScaleFactor;`
`755`	`755`
`756`		`- //make sure the boxes don't get too large`
`757`		`- if(rectHandlerSize > (rect().width() / 3))`
`758`		`- {`
`759`		`- rectHandlerSize = rect().width() / 3;`
`760`		`- }`
`761`		`- if(rectHandlerSize > (rect().height() / 3))`
`762`		`- {`
`763`		`- rectHandlerSize = rect().height() / 3;`
`764`		`- }`
`765`		`- return rectHandlerSize;`
	`756`	`+ //make sure the boxes don't get too large`
	`757`	`+ if ( rectHandlerSize > ( rect().width() / 3 ) )`
	`758`	`+ {`
	`759`	`+ rectHandlerSize = rect().width() / 3;`
	`760`	`+ }`
	`761`	`+ if ( rectHandlerSize > ( rect().height() / 3 ) )`
	`762`	`+ {`
	`763`	`+ rectHandlerSize = rect().height() / 3;`
	`764`	`+ }`
	`765`	`+ return rectHandlerSize;`
`766`	`766`	`}`
`767`	`767`
`768`	`768`	`double QgsComposerItem::lockSymbolSize() const`
`769`	`769`	`{`
`770`	`770`	`double lockSymbolSize = 20.0 / horizontalViewScaleFactor();`
`771`	`771`
`772`		`- if(lockSymbolSize > (rect().width() / 3))`
	`772`	`+ if ( lockSymbolSize > ( rect().width() / 3 ) )`
`773`	`773`	`{`
`774`	`774`	`lockSymbolSize = rect().width() / 3;`
`775`	`775`	`}`
`776`		`- if(lockSymbolSize > (rect().height() / 3))`
	`776`	`+ if ( lockSymbolSize > ( rect().height() / 3 ) )`
`777`	`777`	`{`
`778`	`778`	`lockSymbolSize = rect().height() / 3;`
`779`	`779`	`}`
`780`	`780`	`return lockSymbolSize;`
`781`	`781`	`}`
`782`	`782`
`783`		`-void QgsComposerItem::updateCursor(const QPointF& itemPos)`
	`783`	`+void QgsComposerItem::updateCursor( const QPointF& itemPos )`
`784`	`784`	`{`
`785`		`- setCursor( cursorForPosition(itemPos) );`
	`785`	`+ setCursor( cursorForPosition( itemPos ) );`
`786`	`786`	`}`