void QgsComposerScaleBar::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !mStyle || !painter )
{
return;
}
if ( !shouldDrawItem() )
{
return;
}
drawBackground( painter );
//x-offset is half of first label width because labels are drawn centered
QString firstLabel = firstLabelString();
double firstLabelWidth = QgsComposerUtils::textWidthMM( mFont, firstLabel );
mStyle->draw( painter, firstLabelWidth / 2 );
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerLabel::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
if ( !painter )
{
return;
}
drawBackground( painter );
painter->setPen( QPen( QColor( mFontColor ) ) ); //draw all text black
painter->setFont( mFont );
QFontMetricsF fontSize( mFont );
//support multiline labels
double penWidth = pen().widthF();
QRectF painterRect( penWidth + mMargin, penWidth + mMargin, rect().width() - 2 * penWidth - 2 * mMargin,
rect().height() - 2 * penWidth - 2 * mMargin );
drawText( painter, painterRect, displayText(), mFont, mHAlignment, mVAlignment );
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerLegend::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( mComposition )
mSettings.setUseAdvancedEffects( mComposition->useAdvancedEffects() );
if ( mComposerMap )
mSettings.setMmPerMapUnit( mComposerMap->mapUnitsToMM() );
if ( !painter )
return;
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setPen( QPen( QColor( 0, 0, 0 ) ) );
QgsLegendRenderer legendRenderer( &mLegendModel, mSettings );
legendRenderer.setLegendSize( rect().size() );
legendRenderer.drawLegend( painter );
painter->restore();
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerScaleBar::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !mStyle || !painter )
{
return;
}
drawBackground( painter );
painter->setPen( QPen( QColor( 0, 0, 0 ) ) ); //draw all text black
//x-offset is half of first label width because labels are drawn centered
QString firstLabel = firstLabelString();
double firstLabelWidth = textWidthMillimeters( mFont, firstLabel );
mStyle->draw( painter, firstLabelWidth / 2 );
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsTextAnnotationItem::paint( QPainter * painter )
{
if ( !painter || !mDocument )
{
return;
}
drawFrame( painter );
if ( mMapPositionFixed )
{
drawMarkerSymbol( painter );
}
double frameWidth = mFrameBorderWidth;
mDocument->setTextWidth( mFrameSize.width() );
painter->save();
painter->translate( mOffsetFromReferencePoint.x() + frameWidth / 2.0,
mOffsetFromReferencePoint.y() + frameWidth / 2.0 );
QRectF clipRect = QRectF( 0, 0, mFrameSize.width() - frameWidth / 2.0, mFrameSize.height() - frameWidth / 2.0 );
if ( painter->hasClipping() )
{
//QTextDocument::drawContents will draw text outside of the painter's clip region
//when it is passed a clip rectangle. So, we need to intersect it with the
//painter's clip region to prevent text drawn outside clipped region (eg, outside composer maps, see #10400)
clipRect = clipRect.intersected( painter->clipRegion().boundingRect() );
}
//draw text document
mDocument->drawContents( painter, clipRect );
painter->restore();
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
// =============================================================================
// Nossa função de desenho :-)
// =============================================================================
void DesignerSurface::paintEvent(QPaintEvent* event)
{
QPainter painter(this);
painter.setClipRect(event->rect());
//cout << "Repaint: " << event->rect() << endl;
painter.fillRect(rect(), palette().color(QPalette::Normal, QPalette::Window));
// só desenhamos a grade em modo de edição :P
if (m_editMode && m_showGrid)
drawGrid(painter);
if (m_lowerWidget == this) {
painter.setPen(Qt::red);
painter.drawRect(rect().adjusted(0, 0, -1, -1));
} else {
drawParentBox(m_lowerWidget, painter);
}
// Desenha a caixa de seleção
if (m_mouseState == Selecting)
drawSelectionRect(painter);
drawSelectionBoxes(painter);
event->accept();
}
void QgsComposerItemGroup::paint( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget )
{
Q_UNUSED( option );
Q_UNUSED( widget );
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerPicture::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
{
return;
}
drawBackground( painter );
int newDpi = ( painter->device()->logicalDpiX() + painter->device()->logicalDpiY() ) / 2;
if ( mMode != Unknown )
{
double rectPixelWidth = /*rect().width()*/mPictureWidth * newDpi / 25.4;
double rectPixelHeight = /*rect().height()*/ mPictureHeight * newDpi / 25.4;
QRectF boundRect;
if ( mMode == SVG )
{
boundRect = boundedSVGRect( rectPixelWidth, rectPixelHeight );
}
else if ( mMode == RASTER )
{
boundRect = boundedImageRect( rectPixelWidth, rectPixelHeight );
}
double boundRectWidthMM = boundRect.width() / newDpi * 25.4;
double boundRectHeightMM = boundRect.height() / newDpi * 25.4;
painter->save();
painter->translate( rect().width() / 2.0, rect().height() / 2.0 );
painter->rotate( mRotation );
painter->translate( -boundRectWidthMM / 2.0, -boundRectHeightMM / 2.0 );
if ( mMode == SVG )
{
mSVG.render( painter, QRectF( 0, 0, boundRectWidthMM, boundRectHeightMM ) );
}
else if ( mMode == RASTER )
{
painter->drawImage( QRectF( 0, 0, boundRectWidthMM, boundRectHeightMM ), mImage, QRectF( 0, 0, mImage.width(), mImage.height() ) );
}
painter->restore();
}
//frame and selection boxes
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerLabel::paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
{
return;
}
if ( !shouldDrawItem() )
{
return;
}
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
double penWidth = hasFrame() ? ( pen().widthF() / 2.0 ) : 0;
double xPenAdjust = mMarginX < 0 ? -penWidth : penWidth;
double yPenAdjust = mMarginY < 0 ? -penWidth : penWidth;
QRectF painterRect( xPenAdjust + mMarginX, yPenAdjust + mMarginY, rect().width() - 2 * xPenAdjust - 2 * mMarginX, rect().height() - 2 * yPenAdjust - 2 * mMarginY );
if ( mHtmlState )
{
if ( mFirstRender )
{
contentChanged();
mFirstRender = false;
}
painter->scale( 1.0 / mHtmlUnitsToMM / 10.0, 1.0 / mHtmlUnitsToMM / 10.0 );
mWebPage->setViewportSize( QSize( painterRect.width() * mHtmlUnitsToMM * 10.0, painterRect.height() * mHtmlUnitsToMM * 10.0 ) );
mWebPage->settings()->setUserStyleSheetUrl( createStylesheetUrl() );
mWebPage->mainFrame()->render( painter );
}
else
{
const QString textToDraw = displayText();
painter->setFont( mFont );
//debug
//painter->setPen( QColor( Qt::red ) );
//painter->drawRect( painterRect );
QgsComposerUtils::drawText( painter, painterRect, textToDraw, mFont, mFontColor, mHAlignment, mVAlignment, Qt::TextWordWrap );
}
painter->restore();
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerPicture::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
if ( !painter )
{
return;
}
if ( mMode == SVG )
{
int newDpi = ( painter->device()->logicalDpiX() + painter->device()->logicalDpiY() ) / 2;
if ( newDpi != mCachedDpi )
{
mSvgCacheUpToDate = false;
mCachedDpi = newDpi;
mImage = QImage( rect().width() * newDpi / 25.4, rect().height() * newDpi / 25.4, QImage::Format_ARGB32 );
}
if ( !mSvgCacheUpToDate )
{
updateImageFromSvg();
}
}
painter->save();
painter->rotate( mRotation );
drawBackground( painter );
if ( mMode != Unknown )
{
double widthRatio = mImage.width() / rect().width();
double heightRatio = mImage.height() / rect().height();
double targetWidth, targetHeight;
if ( widthRatio > heightRatio )
{
targetWidth = rect().width();
targetHeight = mImage.height() / widthRatio;
}
else
{
targetHeight = rect().height();
targetWidth = mImage.width() / heightRatio;
}
painter->drawImage( QRectF( 0, 0, targetWidth, targetHeight ), mImage, QRectF( 0, 0, mImage.width(), mImage.height() ) );
}
//frame and selection boxes
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
painter->restore();
}
void QgsComposerShape::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
{
return;
}
drawBackground( painter );
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsMapCanvasAnnotationItem::paint( QPainter *painter )
{
if ( !mAnnotation || !mAnnotation->isVisible() )
return;
QgsRenderContext rc = QgsRenderContext::fromQPainter( painter );
rc.setFlag( QgsRenderContext::Antialiasing, true );
if ( mAnnotation )
mAnnotation->render( rc );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerArrow::paint( QPainter* painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter || !painter->device() )
{
return;
}
if ( !shouldDrawItem() )
{
return;
}
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
//draw line section
drawLine( painter );
//draw arrowhead if required
if ( mMarkerMode != NoMarker )
{
painter->setBrush( mBrush );
painter->setPen( mPen );
if ( mMarkerMode == DefaultMarker )
{
drawHardcodedMarker( painter, EndMarker );
}
else if ( mMarkerMode == SVGMarker )
{
drawSVGMarker( painter, StartMarker, mStartMarkerFile );
drawSVGMarker( painter, EndMarker, mEndMarkerFile );
}
}
painter->restore();
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerLegend::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
return;
int dpi = painter->device()->logicalDpiX();
double dotsPerMM = dpi / 25.4;
if ( mComposition )
{
mSettings.setUseAdvancedEffects( mComposition->useAdvancedEffects() );
mSettings.setDpi( dpi );
}
if ( mComposerMap )
{
mSettings.setMmPerMapUnit( mComposerMap->mapUnitsToMM() );
// use a temporary QgsMapSettings to find out real map scale
QgsMapSettings ms = mComposerMap->composition()->mapSettings();
ms.setOutputSize( QSizeF( mComposerMap->rect().width() * dotsPerMM, mComposerMap->rect().height() * dotsPerMM ).toSize() );
ms.setExtent( *mComposerMap->currentMapExtent() );
ms.setOutputDpi( dpi );
mSettings.setMapScale( ms.scale() );
}
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setPen( QPen( QColor( 0, 0, 0 ) ) );
QgsLegendRenderer legendRenderer( mLegendModel2, mSettings );
legendRenderer.setLegendSize( rect().size() );
legendRenderer.drawLegend( painter );
painter->restore();
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsSvgAnnotationItem::paint( QPainter* painter )
{
if( !painter )
{
return;
}
drawFrame( painter );
if ( mMapPositionFixed )
{
drawMarkerSymbol( painter );
}
//keep width/height ratio of svg
QRect viewBox = mSvgRenderer.viewBox();
if( viewBox.isValid() )
{
double widthRatio = mFrameSize.width() / viewBox.width();
double heightRatio = mFrameSize.height() / viewBox.height();
double renderWidth = 0;
double renderHeight = 0;
if( widthRatio <= heightRatio )
{
renderWidth = mFrameSize.width();
renderHeight = viewBox.height() * mFrameSize.width() / viewBox.width() ;
}
else
{
renderHeight = mFrameSize.height();
renderWidth = viewBox.width() * mFrameSize.height() /viewBox.height() ;
}
mSvgRenderer.render( painter, QRectF( mOffsetFromReferencePoint.x(), mOffsetFromReferencePoint.y(), renderWidth,
renderHeight ) );
}
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerFrame::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
{
return;
}
if ( !shouldDrawItem() )
{
return;
}
bool empty = isEmpty();
if ( !empty || !mHideBackgroundIfEmpty )
{
drawBackground( painter );
}
if ( mMultiFrame )
{
//calculate index of frame
int frameIndex = mMultiFrame->frameIndex( this );
mMultiFrame->render( painter, mSection, frameIndex );
}
if ( !empty || !mHideBackgroundIfEmpty )
{
drawFrame( painter );
}
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerPicture::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
{
return;
}
if ( !shouldDrawItem() )
{
return;
}
drawBackground( painter );
//int newDpi = ( painter->device()->logicalDpiX() + painter->device()->logicalDpiY() ) / 2;
//picture resizing
if ( mMode != Unknown )
{
double boundRectWidthMM;
double boundRectHeightMM;
QRect imageRect;
if ( mResizeMode == QgsComposerPicture::Zoom || mResizeMode == QgsComposerPicture::ZoomResizeFrame )
{
boundRectWidthMM = mPictureWidth;
boundRectHeightMM = mPictureHeight;
imageRect = QRect( 0, 0, mImage.width(), mImage.height() );
}
else if ( mResizeMode == QgsComposerPicture::Stretch )
{
boundRectWidthMM = rect().width();
boundRectHeightMM = rect().height();
imageRect = QRect( 0, 0, mImage.width(), mImage.height() );
}
else if ( mResizeMode == QgsComposerPicture::Clip )
{
boundRectWidthMM = rect().width();
boundRectHeightMM = rect().height();
int imageRectWidthPixels = mImage.width();
int imageRectHeightPixels = mImage.height();
imageRect = clippedImageRect( boundRectWidthMM, boundRectHeightMM,
QSize( imageRectWidthPixels, imageRectHeightPixels ) );
}
else
{
boundRectWidthMM = rect().width();
boundRectHeightMM = rect().height();
imageRect = QRect( 0, 0, rect().width() * mComposition->printResolution() / 25.4,
rect().height() * mComposition->printResolution() / 25.4 );
}
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
//zoom mode - calculate anchor point and rotation
if ( mResizeMode == Zoom )
{
//TODO - allow placement modes with rotation set. for now, setting a rotation
//always places picture in center of frame
if ( !qgsDoubleNear( mPictureRotation, 0.0 ) )
{
painter->translate( rect().width() / 2.0, rect().height() / 2.0 );
painter->rotate( mPictureRotation );
painter->translate( -boundRectWidthMM / 2.0, -boundRectHeightMM / 2.0 );
}
else
{
//shift painter to edge/middle of frame depending on placement
double diffX = rect().width() - boundRectWidthMM;
double diffY = rect().height() - boundRectHeightMM;
double dX = 0;
double dY = 0;
switch ( mPictureAnchor )
{
case UpperLeft:
case MiddleLeft:
case LowerLeft:
//nothing to do
break;
case UpperMiddle:
case Middle:
case LowerMiddle:
dX = diffX / 2.0;
break;
case UpperRight:
case MiddleRight:
case LowerRight:
dX = diffX;
break;
}
switch ( mPictureAnchor )
{
case UpperLeft:
case UpperMiddle:
case UpperRight:
//nothing to do
break;
case MiddleLeft:
case Middle:
case MiddleRight:
dY = diffY / 2.0;
break;
case LowerLeft:
case LowerMiddle:
case LowerRight:
dY = diffY;
break;
}
painter->translate( dX, dY );
}
}
else if ( mResizeMode == ZoomResizeFrame )
{
if ( !qgsDoubleNear( mPictureRotation, 0.0 ) )
{
painter->translate( rect().width() / 2.0, rect().height() / 2.0 );
painter->rotate( mPictureRotation );
painter->translate( -boundRectWidthMM / 2.0, -boundRectHeightMM / 2.0 );
}
}
if ( mMode == SVG )
{
mSVG.render( painter, QRectF( 0, 0, boundRectWidthMM, boundRectHeightMM ) );
}
else if ( mMode == RASTER )
{
painter->drawImage( QRectF( 0, 0, boundRectWidthMM, boundRectHeightMM ), mImage, imageRect );
}
painter->restore();
}
//frame and selection boxes
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsResidualPlotItem::paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( mGCPList.size() < 1 || !painter )
{
return;
}
double widthMM = rect().width();
double heightMM = rect().height();
QPen enabledPen( QColor( 255, 0, 0, 255 ), 0.3, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin );
QPen disabledPen( QColor( 255, 0, 0, 85 ), 0.2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin );
QBrush enabledBrush( QColor( 255, 255, 255, 255 ) );
QBrush disabledBrush( QColor( 255, 255, 255, 127 ) );
//draw all points and collect minimal mm/pixel ratio
double minMMPixelRatio = DBL_MAX;
double mmPixelRatio = 1;
painter->setRenderHint( QPainter::Antialiasing, true );
QgsGCPList::const_iterator gcpIt = mGCPList.constBegin();
for ( ; gcpIt != mGCPList.constEnd(); ++gcpIt )
{
QgsPointXY gcpCoords = ( *gcpIt )->pixelCoords();
double gcpItemMMX = ( gcpCoords.x() - mExtent.xMinimum() ) / mExtent.width() * widthMM;
double gcpItemMMY = ( 1 - ( gcpCoords.y() - mExtent.yMinimum() ) / mExtent.height() ) * heightMM;
if ( ( *gcpIt )->isEnabled() )
{
painter->setPen( enabledPen );
painter->setBrush( enabledBrush );
}
else
{
painter->setPen( disabledPen );
painter->setBrush( disabledBrush );
}
painter->drawRect( QRectF( gcpItemMMX - 0.5, gcpItemMMY - 0.5, 1, 1 ) );
QgsComposerUtils::drawText( painter, QPointF( gcpItemMMX + 2, gcpItemMMY + 2 ), QString::number( ( *gcpIt )->id() ), QFont() );
mmPixelRatio = maxMMToPixelRatioForGCP( *gcpIt, gcpItemMMX, gcpItemMMY );
if ( mmPixelRatio < minMMPixelRatio )
{
minMMPixelRatio = mmPixelRatio;
}
}
//draw residual arrows
gcpIt = mGCPList.constBegin();
for ( ; gcpIt != mGCPList.constEnd(); ++gcpIt )
{
QgsPointXY gcpCoords = ( *gcpIt )->pixelCoords();
double gcpItemMMX = ( gcpCoords.x() - mExtent.xMinimum() ) / mExtent.width() * widthMM;
double gcpItemMMY = ( 1 - ( gcpCoords.y() - mExtent.yMinimum() ) / mExtent.height() ) * heightMM;
if ( ( *gcpIt )->isEnabled() )
{
painter->setPen( enabledPen );
}
else
{
painter->setPen( disabledPen );
}
QPointF p1( gcpItemMMX, gcpItemMMY );
QPointF p2( gcpItemMMX + ( *gcpIt )->residual().x() * minMMPixelRatio, gcpItemMMY + ( *gcpIt )->residual().y() * minMMPixelRatio );
painter->drawLine( p1, p2 );
painter->setBrush( QBrush( painter->pen().color() ) );
QgsComposerUtils::drawArrowHead( painter, p2.x(), p2.y(), QgsComposerUtils::angle( p1, p2 ), 1 );
}
//draw scale bar
double initialScaleBarWidth = rect().width() / 5;
double scaleBarWidthUnits = rect().width() / 5 / minMMPixelRatio;
//a simple method to round to next nice number
int nDecPlaces;
if ( scaleBarWidthUnits < 1 )
{
nDecPlaces = -floor( log10( scaleBarWidthUnits ) );
scaleBarWidthUnits *= pow( 10.0, nDecPlaces );
scaleBarWidthUnits = ( int )( scaleBarWidthUnits + 0.5 );
scaleBarWidthUnits /= pow( 10.0, nDecPlaces );
}
else
{
nDecPlaces = ( int )log10( scaleBarWidthUnits );
scaleBarWidthUnits /= pow( 10.0, nDecPlaces );
scaleBarWidthUnits = ( int )( scaleBarWidthUnits + 0.5 );
scaleBarWidthUnits *= pow( 10.0, nDecPlaces );
}
initialScaleBarWidth = scaleBarWidthUnits * minMMPixelRatio;
painter->setPen( QColor( 0, 0, 0 ) );
painter->drawLine( QPointF( 5, rect().height() - 5 ), QPointF( 5 + initialScaleBarWidth, rect().height() - 5 ) );
painter->drawLine( QPointF( 5, rect().height() - 5 ), QPointF( 5, rect().height() - 7 ) );
painter->drawLine( QPointF( 5 + initialScaleBarWidth, rect().height() - 5 ), QPointF( 5 + initialScaleBarWidth, rect().height() - 7 ) );
QFont scaleBarFont;
scaleBarFont.setPointSize( 9 );
if ( mConvertScaleToMapUnits )
{
QgsComposerUtils::drawText( painter, QPointF( 5, rect().height() - 4 + QgsComposerUtils::fontAscentMM( scaleBarFont ) ), QStringLiteral( "%1 map units" ).arg( scaleBarWidthUnits ), QFont() );
}
else
{
QgsComposerUtils::drawText( painter, QPointF( 5, rect().height() - 4 + QgsComposerUtils::fontAscentMM( scaleBarFont ) ), QStringLiteral( "%1 pixels" ).arg( scaleBarWidthUnits ), QFont() );
}
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerTable::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
{
return;
}
if ( mComposition->plotStyle() == QgsComposition::Print ||
mComposition->plotStyle() == QgsComposition::Postscript )
{
//exporting composition, so force an attribute refresh
//we do this in case vector layer has changed via an external source (eg, another database user)
refreshAttributes();
}
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setPen( Qt::SolidLine );
//now draw the text
double currentX = mGridStrokeWidth;
double currentY;
QList<QgsComposerTableColumn*>::const_iterator columnIt = mColumns.constBegin();
int col = 0;
double cellHeaderHeight = fontAscentMillimeters( mHeaderFont ) + 2 * mLineTextDistance;
double cellBodyHeight = fontAscentMillimeters( mContentFont ) + 2 * mLineTextDistance;
QRectF cell;
for ( ; columnIt != mColumns.constEnd(); ++columnIt )
{
currentY = mGridStrokeWidth;
currentX += mLineTextDistance;
cell = QRectF( currentX, currentY, mMaxColumnWidthMap[col], cellHeaderHeight );
//calculate alignment of header
Qt::AlignmentFlag headerAlign = Qt::AlignLeft;
switch ( mHeaderHAlignment )
{
case FollowColumn:
headerAlign = ( *columnIt )->hAlignment();
break;
case HeaderLeft:
headerAlign = Qt::AlignLeft;
break;
case HeaderCenter:
headerAlign = Qt::AlignHCenter;
break;
case HeaderRight:
headerAlign = Qt::AlignRight;
break;
}
drawText( painter, cell, ( *columnIt )->heading(), mHeaderFont, headerAlign, Qt::AlignVCenter, Qt::TextDontClip );
currentY += cellHeaderHeight;
currentY += mGridStrokeWidth;
//draw the attribute values
QList<QgsAttributeMap>::const_iterator attIt = mAttributeMaps.begin();
for ( ; attIt != mAttributeMaps.end(); ++attIt )
{
cell = QRectF( currentX, currentY, mMaxColumnWidthMap[col], cellBodyHeight );
const QgsAttributeMap ¤tAttributeMap = *attIt;
QString str = currentAttributeMap[ col ].toString();
drawText( painter, cell, str, mContentFont, ( *columnIt )->hAlignment(), Qt::AlignVCenter, Qt::TextDontClip );
currentY += cellBodyHeight;
currentY += mGridStrokeWidth;
}
currentX += mMaxColumnWidthMap[ col ];
currentX += mLineTextDistance;
currentX += mGridStrokeWidth;
col++;
}
//and the borders
if ( mShowGrid )
{
QPen gridPen;
gridPen.setWidthF( mGridStrokeWidth );
gridPen.setColor( mGridColor );
gridPen.setJoinStyle( Qt::MiterJoin );
painter->setPen( gridPen );
drawHorizontalGridLines( painter, mAttributeMaps.size() );
drawVerticalGridLines( painter, mMaxColumnWidthMap );
}
painter->restore();
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
QSizeF QgsComposerLegend::paintAndDetermineSize( QPainter* painter )
{
QSizeF size;
double maxXCoord = 0;
//go through model...
QStandardItem* rootItem = mLegendModel.invisibleRootItem();
if ( !rootItem )
{
return size;
}
if ( painter )
{
painter->save();
drawBackground( painter );
painter->setPen( QPen( QColor( 0, 0, 0 ) ) );
}
int numLayerItems = rootItem->rowCount();
QStandardItem* currentLayerItem = 0;
double currentYCoordinate = mBoxSpace;
//font metrics
//draw title
currentYCoordinate += fontAscentMillimeters( mTitleFont );
if ( painter )
{
painter->setPen( QColor( 0, 0, 0 ) );
drawText( painter, mBoxSpace, currentYCoordinate, mTitle, mTitleFont );
}
maxXCoord = 2 * mBoxSpace + textWidthMillimeters( mTitleFont, mTitle );
double currentItemMaxX = 0; //maximum x-coordinate for current item
for ( int i = 0; i < numLayerItems; ++i )
{
currentLayerItem = rootItem->child( i );
QgsComposerLegendItem* currentLegendItem = dynamic_cast<QgsComposerLegendItem*>( currentLayerItem );
if ( currentLegendItem )
{
QgsComposerLegendItem::ItemType type = currentLegendItem->itemType();
if ( type == QgsComposerLegendItem::GroupItem )
{
drawGroupItem( painter, dynamic_cast<QgsComposerGroupItem*>( currentLegendItem ), currentYCoordinate, currentItemMaxX );
maxXCoord = qMax( maxXCoord, currentItemMaxX );
}
else if ( type == QgsComposerLegendItem::LayerItem )
{
drawLayerItem( painter, dynamic_cast<QgsComposerLayerItem*>( currentLegendItem ), currentYCoordinate, currentItemMaxX );
maxXCoord = qMax( maxXCoord, currentItemMaxX );
}
}
}
currentYCoordinate += mBoxSpace;
size.setHeight( currentYCoordinate );
size.setWidth( maxXCoord );
//adjust box if width or height is to small
if ( painter && currentYCoordinate > rect().height() )
{
setSceneRect( QRectF( transform().dx(), transform().dy(), rect().width(), currentYCoordinate ) );
}
if ( painter && maxXCoord > rect().width() )
{
setSceneRect( QRectF( transform().dx(), transform().dy(), maxXCoord, rect().height() ) );
}
if ( painter )
{
painter->restore();
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
return size;
}
void QgsComposerLegend::paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
return;
if ( !shouldDrawItem() )
{
return;
}
if ( mFilterAskedForUpdate )
{
mFilterAskedForUpdate = false;
doUpdateFilterByMap();
}
int dpi = painter->device()->logicalDpiX();
double dotsPerMM = dpi / 25.4;
if ( mComposition )
{
mSettings.setUseAdvancedEffects( mComposition->useAdvancedEffects() );
mSettings.setDpi( dpi );
}
if ( mComposerMap )
{
mSettings.setMmPerMapUnit( mComposerMap->mapUnitsToMM() );
// use a temporary QgsMapSettings to find out real map scale
QSizeF mapSizePixels = QSizeF( mComposerMap->rect().width() * dotsPerMM, mComposerMap->rect().height() * dotsPerMM );
QgsRectangle mapExtent = *mComposerMap->currentMapExtent();
QgsMapSettings ms = mComposerMap->mapSettings( mapExtent, mapSizePixels, dpi );
mSettings.setMapScale( ms.scale() );
}
mInitialMapScaleCalculated = true;
QgsLegendRenderer legendRenderer( mLegendModel.get(), mSettings );
legendRenderer.setLegendSize( mForceResize && mSizeToContents ? QSize() : rect().size() );
//adjust box if width or height is too small
if ( mSizeToContents )
{
QSizeF size = legendRenderer.minimumSize();
if ( mForceResize )
{
mForceResize = false;
//set new rect, respecting position mode and data defined size/position
QRectF targetRect = QRectF( pos().x(), pos().y(), size.width(), size.height() );
setSceneRect( evalItemRect( targetRect, true ) );
}
else if ( size.height() > rect().height() || size.width() > rect().width() )
{
//need to resize box
QRectF targetRect = QRectF( pos().x(), pos().y(), rect().width(), rect().height() );
if ( size.height() > targetRect.height() )
targetRect.setHeight( size.height() );
if ( size.width() > rect().width() )
targetRect.setWidth( size.width() );
//set new rect, respecting position mode and data defined size/position
setSceneRect( evalItemRect( targetRect, true ) );
}
}
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setPen( QPen( QColor( 0, 0, 0 ) ) );
if ( !mSizeToContents )
{
// set a clip region to crop out parts of legend which don't fit
QRectF thisPaintRect = QRectF( 0, 0, rect().width(), rect().height() );
painter->setClipRect( thisPaintRect );
}
legendRenderer.drawLegend( painter );
painter->restore();
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
void QgsComposerLegend::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter )
return;
if ( !shouldDrawItem() )
{
return;
}
int dpi = painter->device()->logicalDpiX();
double dotsPerMM = dpi / 25.4;
if ( mComposition )
{
mSettings.setUseAdvancedEffects( mComposition->useAdvancedEffects() );
mSettings.setDpi( dpi );
}
if ( mComposerMap )
{
mSettings.setMmPerMapUnit( mComposerMap->mapUnitsToMM() );
// use a temporary QgsMapSettings to find out real map scale
QgsMapSettings ms = mComposerMap->composition()->mapSettings();
ms.setOutputSize( QSizeF( mComposerMap->rect().width() * dotsPerMM, mComposerMap->rect().height() * dotsPerMM ).toSize() );
ms.setExtent( *mComposerMap->currentMapExtent() );
ms.setOutputDpi( dpi );
mSettings.setMapScale( ms.scale() );
}
drawBackground( painter );
painter->save();
//antialiasing on
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setPen( QPen( QColor( 0, 0, 0 ) ) );
QgsLegendRenderer legendRenderer( mLegendModel2, mSettings );
legendRenderer.setLegendSize( rect().size() );
//adjust box if width or height is too small
QSizeF size = legendRenderer.minimumSize();
if ( size.height() > rect().height() || size.width() > rect().width() )
{
//need to resize box
QRectF targetRect = QRectF( pos().x(), pos().y(), rect().width(), rect().height() );
if ( size.height() > targetRect.height() )
targetRect.setHeight( size.height() );
if ( size.width() > rect().width() )
targetRect.setWidth( size.width() );
//set new rect, respecting position mode and data defined size/position
setSceneRect( evalItemRect( targetRect, true ) );
}
legendRenderer.drawLegend( painter );
painter->restore();
//draw frame and selection boxes if necessary
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
