QSizeF QgsHistogramDiagram::diagramSize( const QgsAttributes& attributes, const QgsRenderContext& c, const QgsDiagramSettings& s )
{
Q_UNUSED( c );
QSizeF size;
if ( attributes.isEmpty() )
{
return QSizeF(); //zero size if no attributes
}
double maxValue = attributes.at( 0 ).toDouble();
for ( int i = 0; i < attributes.count(); ++i )
{
maxValue = qMax( attributes.at( i ).toDouble(), maxValue );
}
switch ( s.diagramOrientation )
{
case QgsDiagramSettings::Up:
case QgsDiagramSettings::Down:
mScaleFactor = maxValue / s.size.height();
size.scale( s.barWidth * s.categoryColors.size(), s.size.height(), Qt::IgnoreAspectRatio );
break;
case QgsDiagramSettings::Right:
case QgsDiagramSettings::Left:
default: // just in case...
mScaleFactor = maxValue / s.size.width();
size.scale( s.size.width(), s.barWidth * s.categoryColors.size(), Qt::IgnoreAspectRatio );
break;
}
return size;
}
void QGraphicsVideoItemPrivate::updateRects()
{
q_ptr->prepareGeometryChange();
if (nativeSize.isEmpty()) {
//this is necessary for item to receive the
//first paint event and configure video surface.
boundingRect = rect;
} else if (aspectRatioMode == Qt::IgnoreAspectRatio) {
boundingRect = rect;
sourceRect = QRectF(0, 0, 1, 1);
} else if (aspectRatioMode == Qt::KeepAspectRatio) {
QSizeF size = nativeSize;
size.scale(rect.size(), Qt::KeepAspectRatio);
boundingRect = QRectF(0, 0, size.width(), size.height());
boundingRect.moveCenter(rect.center());
sourceRect = QRectF(0, 0, 1, 1);
} else if (aspectRatioMode == Qt::KeepAspectRatioByExpanding) {
boundingRect = rect;
QSizeF size = rect.size();
size.scale(nativeSize, Qt::KeepAspectRatio);
sourceRect = QRectF(
0, 0, size.width() / nativeSize.width(), size.height() / nativeSize.height());
sourceRect.moveCenter(QPointF(0.5, 0.5));
}
}
void ContentWindowController::adjustSize( const SizeState state )
{
switch( state )
{
case SIZE_1TO1:
resize( _contentWindow->getContent()->getPreferredDimensions(), CENTER);
break;
case SIZE_LARGE:
{
const QSizeF wallSize = _displayGroup->getCoordinates().size();
resize( LARGE_SIZE_SCALE * wallSize, CENTER );
} break;
case SIZE_FULLSCREEN:
{
QSizeF size = _contentWindow->getContent()->getDimensions();
size.scale( _displayGroup->getCoordinates().size(),
Qt::KeepAspectRatio );
constrainSize( size );
_contentWindow->setCoordinates( _getCenteredCoordinates( size ));
} break;
default:
return;
}
}
void AMCrosshairOverlayVideoWidget::reviewCrosshairLinePositions()
{
QSizeF viewSize = videoItem_->size();
// first we need to find out the native size of the video. (Well, actually just the aspect ratio, but...)
QSizeF videoSize = videoItem_->nativeSize();
// scale the video size to the view size, obeying the transformation mode
QSizeF scaledSize = videoSize;
scaledSize.scale(viewSize, videoItem_->aspectRatioMode());
// now, scaledSize will either be:
// same as viewSize, if view and video have same aspect ratio, or the video is being stretched with Qt::IgnoreAspectRatio
// One dimension the same, other dimension smaller than viewSize, if Qt::KeepAspectRatio
// or One dimension the same, other dimension LARGER than viewSize, if Qt::KeepAspectRatioByExpanding
QRectF activeRect = QRectF(QPointF((viewSize.width()-scaledSize.width())/2,
(viewSize.height()-scaledSize.height())/2),
scaledSize);
// activeRect is now a rectangle in scene coordinates that covers the actual area of the video [not the area of the videoWidget, which may be smaller or larger depending on the aspect ratio mode and aspect ratio of the actual video feed]
qreal xSceneCoord = activeRect.left() + crosshairX_*activeRect.width();
qreal ySceneCoord = activeRect.top() + crosshairY_*activeRect.height();
crosshairXLine_->setLine(xSceneCoord, activeRect.top(), xSceneCoord, activeRect.bottom());
crosshairYLine_->setLine(activeRect.left(), ySceneCoord, activeRect.right(), ySceneCoord);
}
void QRendererVideoWidgetBackend::updateRects()
{
QRect rect = m_widget->rect();
if (m_nativeSize.isEmpty()) {
m_boundingRect = QRect();
} else if (m_aspectRatioMode == Qt::IgnoreAspectRatio) {
m_boundingRect = rect;
m_sourceRect = QRectF(0, 0, 1, 1);
} else if (m_aspectRatioMode == Qt::KeepAspectRatio) {
QSize size = m_nativeSize;
size.scale(rect.size(), Qt::KeepAspectRatio);
m_boundingRect = QRect(0, 0, size.width(), size.height());
m_boundingRect.moveCenter(rect.center());
m_sourceRect = QRectF(0, 0, 1, 1);
} else if (m_aspectRatioMode == Qt::KeepAspectRatioByExpanding) {
m_boundingRect = rect;
QSizeF size = rect.size();
size.scale(m_nativeSize, Qt::KeepAspectRatio);
m_sourceRect = QRectF(
0, 0, size.width() / m_nativeSize.width(), size.height() / m_nativeSize.height());
m_sourceRect.moveCenter(QPointF(0.5, 0.5));
}
}
QRectF QtSvgDialGauge::availableRect(QSvgRenderer * renderObject) const
{
// Calculating the layout:
QSizeF svgSize = renderObject->defaultSize();
svgSize.scale(size(), Qt::KeepAspectRatio);
return QRectF(QPointF(0.0, 0.0), svgSize);
}
QSizeF QgsHistogramDiagram::diagramSize( const QgsFeature& feature, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
QSizeF size;
if ( feature.attributes().isEmpty() )
{
return size; //zero size if no attributes
}
if ( qgsDoubleNear( is.upperValue, is.lowerValue ) )
return size; // invalid value range => zero size
double maxValue = 0;
QgsExpressionContext expressionContext = c.expressionContext();
expressionContext.setFeature( feature );
if ( !feature.fields().isEmpty() )
expressionContext.setFields( feature.fields() );
Q_FOREACH ( const QString& cat, s.categoryAttributes )
{
QgsExpression* expression = getExpression( cat, expressionContext );
maxValue = qMax( expression->evaluate( &expressionContext ).toDouble(), maxValue );
}
// Scale, if extension is smaller than the specified minimum
if ( maxValue < s.minimumSize )
{
maxValue = s.minimumSize;
}
switch ( s.diagramOrientation )
{
case QgsDiagramSettings::Up:
case QgsDiagramSettings::Down:
mScaleFactor = (( is.upperSize.width() - is.lowerSize.height() ) / ( is.upperValue - is.lowerValue ) );
size.scale( s.barWidth * s.categoryAttributes.size(), maxValue * mScaleFactor, Qt::IgnoreAspectRatio );
break;
case QgsDiagramSettings::Right:
case QgsDiagramSettings::Left:
mScaleFactor = (( is.upperSize.width() - is.lowerSize.width() ) / ( is.upperValue - is.lowerValue ) );
size.scale( maxValue * mScaleFactor, s.barWidth * s.categoryAttributes.size(), Qt::IgnoreAspectRatio );
break;
}
return size;
}
void VlcQmlVideoObject::updateBoundingRect()
{
_boundingRect = QRectF(0, 0, _frameSize.width(), _frameSize.height());
updateAspectRatio();
QSizeF scaledFrameSize = _boundingRect.size();
if (_aspectRatio == Vlc::Ignore) {
scaledFrameSize.scale(_geometry.size(), Qt::IgnoreAspectRatio);
} else {
scaledFrameSize.scale(_geometry.size(), Qt::KeepAspectRatio);
}
_boundingRect.setSize( scaledFrameSize );
updateCropRatio();
_boundingRect.moveCenter(_geometry.center());
}
void ContentWindowController::scale( const QPointF& center,
const double pixelDelta )
{
QSizeF newSize = _contentWindow->getCoordinates().size();
newSize.scale( newSize.width() + pixelDelta,
newSize.height() + pixelDelta,
pixelDelta < 0 ? Qt::KeepAspectRatio
: Qt::KeepAspectRatioByExpanding );
_resize( center, newSize );
}
void DisplayGroupController::adjustWindowsAspectRatioToContent()
{
for (ContentWindowPtr window : _group.getContentWindows())
{
QSizeF exactSize = window->getContent().getDimensions();
exactSize.scale(window->getCoordinates().size(), Qt::KeepAspectRatio);
window->setWidth(exactSize.width());
window->setHeight(exactSize.height());
}
}
static PyObject *meth_QSizeF_scale(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
const QSizeF * a0;
Qt::AspectRatioMode a1;
QSizeF *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ9E", &sipSelf, sipType_QSizeF, &sipCpp, sipType_QSizeF, &a0, sipType_Qt_AspectRatioMode, &a1))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->scale(*a0,a1);
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
}
{
qreal a0;
qreal a1;
Qt::AspectRatioMode a2;
QSizeF *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BddE", &sipSelf, sipType_QSizeF, &sipCpp, &a0, &a1, sipType_Qt_AspectRatioMode, &a2))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->scale(a0,a1,a2);
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QSizeF, sipName_scale, NULL);
return NULL;
}
QSizeF QgsTextDiagram::diagramSize( const QgsFeature& feature, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
Q_UNUSED( c );
QVariant attrVal;
if ( is.classificationAttributeIsExpression )
{
QgsExpression* expression = getExpression( is.classificationAttributeExpression, feature.fields() );
attrVal = expression->evaluate( feature );
}
else
{
attrVal = feature.attributes()[is.classificationAttribute];
}
if ( !attrVal.isValid() )
{
return QSizeF(); //zero size if attribute is missing
}
double scaledValue = attrVal.toDouble();
double scaledLowerValue = is.lowerValue;
double scaledUpperValue = is.upperValue;
double scaledLowerSizeWidth = is.lowerSize.width();
double scaledLowerSizeHeight = is.lowerSize.height();
double scaledUpperSizeWidth = is.upperSize.width();
double scaledUpperSizeHeight = is.upperSize.height();
// interpolate the squared value if scale by area
if ( s.scaleByArea )
{
scaledValue = sqrt( scaledValue );
scaledLowerValue = sqrt( scaledLowerValue );
scaledUpperValue = sqrt( scaledUpperValue );
scaledLowerSizeWidth = sqrt( scaledLowerSizeWidth );
scaledLowerSizeHeight = sqrt( scaledLowerSizeHeight );
scaledUpperSizeWidth = sqrt( scaledUpperSizeWidth );
scaledUpperSizeHeight = sqrt( scaledUpperSizeHeight );
}
//interpolate size
double scaledRatio = ( scaledValue - scaledLowerValue ) / ( scaledUpperValue - scaledLowerValue );
QSizeF size = QSizeF( is.upperSize.width() * scaledRatio + is.lowerSize.width() * ( 1 - scaledRatio ),
is.upperSize.height() * scaledRatio + is.lowerSize.height() * ( 1 - scaledRatio ) );
// Scale, if extension is smaller than the specified minimum
if ( size.width() <= s.minimumSize && size.height() <= s.minimumSize )
{
size.scale( s.minimumSize, s.minimumSize, Qt::KeepAspectRatio );
}
return size;
}
// calculates outer(image) and inner(view area) squares
void MapOverlay::updateMap(const QSizeF& windowSz, const QRectF& drawingRect)
{
if(windowSz.height() < drawingRect.height()
|| windowSz.width() < drawingRect.width()) {
this->show();
d->outerRect.setX(0);
d->outerRect.setY(0);
QSizeF outerSz = drawingRect.size();
outerSz.scale(d->mapSz, d->mapSz, Qt::KeepAspectRatio);
d->outerRect.setSize(outerSz);
float widthDiff = (float) windowSz.width() / drawingRect.width();
float heightDiff = (float) windowSz.height() / drawingRect.height();
if (widthDiff > 1)
widthDiff = 1;
if (heightDiff > 1)
heightDiff = 1;
float width = outerSz.width() * widthDiff;
float height = outerSz.height() * heightDiff;
QSizeF innerSz(width, height);
d->innerRect.setSize(innerSz);
float xSpeedDiff = (float) innerSz.width() / windowSz.width();
float ySpeedDiff = (float) innerSz.height() / windowSz.height();
float x = (float) -drawingRect.left() * xSpeedDiff;
float y = (float) -drawingRect.top() * ySpeedDiff;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
d->innerRect.moveTo(QPointF(x, y));
//move to bottom left border
d->outerRect.translate(d->mapSz - d->outerRect.width(),
d->mapSz - d->outerRect.height());
d->innerRect.translate(d->mapSz - d->outerRect.width(),
d->mapSz - d->outerRect.height());
update();
}
else {
this->hide();
}
}
void ContentWindowController::constrainSize( QSizeF& windowSize ) const
{
const QSizeF& maxSize = getMaxSize();
if( windowSize > maxSize )
{
windowSize.scale( maxSize, Qt::KeepAspectRatio );
return;
}
const QSizeF& minSize = getMinSize();
if( windowSize < minSize )
windowSize = _contentWindow->getCoordinates().size();
}
QSizeF QgsPieDiagram::diagramSize( const QgsAttributes& attributes, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
Q_UNUSED( c );
QVariant attrVal = attributes[is.classificationAttribute];
if ( !attrVal.isValid() )
{
return QSizeF(); //zero size if attribute is missing
}
double scaledValue = attrVal.toDouble();
double scaledLowerValue = is.lowerValue;
double scaledUpperValue = is.upperValue;
double scaledLowerSizeWidth = is.lowerSize.width();
double scaledLowerSizeHeight = is.lowerSize.height();
double scaledUpperSizeWidth = is.upperSize.width();
double scaledUpperSizeHeight = is.upperSize.height();
// interpolate the squared value if scale by area
if ( s.scaleByArea )
{
scaledValue = sqrt( scaledValue );
scaledLowerValue = sqrt( scaledLowerValue );
scaledUpperValue = sqrt( scaledUpperValue );
scaledLowerSizeWidth = sqrt( scaledLowerSizeWidth );
scaledLowerSizeHeight = sqrt( scaledLowerSizeHeight );
scaledUpperSizeWidth = sqrt( scaledUpperSizeWidth );
scaledUpperSizeHeight = sqrt( scaledUpperSizeHeight );
}
//interpolate size
double scaledRatio = ( scaledValue - scaledLowerValue ) / ( scaledUpperValue - scaledLowerValue );
QSizeF size = QSizeF( is.upperSize.width() * scaledRatio + is.lowerSize.width() * ( 1 - scaledRatio ),
is.upperSize.height() * scaledRatio + is.lowerSize.height() * ( 1 - scaledRatio ) );
// Scale, if extension is smaller than the specified minimum
if ( size.width() <= s.minimumSize && size.height() <= s.minimumSize )
{
bool p = false; // preserve height == width
if ( size.width() == size.height() )
p = true;
size.scale( s.minimumSize, s.minimumSize, Qt::KeepAspectRatio );
// If height == width, recover here (overwrite floating point errors)
if ( p )
size.setWidth( size.height() );
}
return size;
}
void QGraphicsVideoItemPrivate::updateRects()
{
q_ptr->prepareGeometryChange();
QSizeF videoSize;
if (nativeSize.isEmpty()) {
videoSize = rect.size();
} else if (aspectRatioMode == Qt::IgnoreAspectRatio) {
videoSize = rect.size();
} else {
// KeepAspectRatio or KeepAspectRatioByExpanding
videoSize = nativeSize;
videoSize.scale(rect.size(), aspectRatioMode);
}
displayRect = QRectF(QPointF(0, 0), videoSize);
displayRect.moveCenter(rect.center());
boundingRect = displayRect.intersected(rect);
}
void CAPresentationHandler::resizeCanvas (const QSizeF& canvasSize)
{
QSizeF pageSize = d->paView->activePage()->boundingRect().size();
QGraphicsWidget* canvasItem = canvas()->canvasItem();
QSizeF newSize (pageSize);
newSize.scale (canvasSize, Qt::KeepAspectRatio);
if (canvasSize.width() < canvasSize.height()) {
canvasItem->setGeometry (0, (canvasSize.height() - newSize.height()) / 2,
newSize.width(), newSize.height());
documentController()->canvasController()->zoomHandler()->setZoom (canvasSize.width() / pageSize.width() * 0.75);
} else {
canvasItem->setGeometry ( (canvasSize.width() - newSize.width()) / 2, 0,
newSize.width(), newSize.height());
documentController()->canvasController()->zoomHandler()->setZoom (canvasSize.height() / pageSize.height() * 0.75);
}
}
QPointF AMCrosshairOverlayVideoWidget::mapSceneToVideo(const QPointF &sceneCoordinate) const
{
// for more comments, see the more verbose implementation in reviewCrosshairLinePostions()
QSizeF viewSize = videoItem_->size();
QSizeF scaledSize = videoItem_->nativeSize();
scaledSize.scale(viewSize, videoItem_->aspectRatioMode());
QRectF activeRect = QRectF(QPointF((viewSize.width()-scaledSize.width())/2,
(viewSize.height()-scaledSize.height())/2),
scaledSize);
// activeRect is now a rectangle in scene coordinates that covers the actual area of the video [not the area of the videoWidget, which may be smaller or larger depending on the aspect ratio mode and aspect ratio of the actual video feed]
qreal yScene = (sceneCoordinate.y() - activeRect.top())/activeRect.height();
qreal xScene = (sceneCoordinate.x() - activeRect.left())/activeRect.width();
return QPointF(xScene, yScene);
}
QSizeF QgsPieDiagram::diagramSize( const QgsAttributeMap& attributes, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
Q_UNUSED( c );
QgsAttributeMap::const_iterator attIt = attributes.find( is.classificationAttribute );
if ( attIt == attributes.constEnd() )
{
return QSizeF(); //zero size if attribute is missing
}
double scaledValue = attIt.value().toDouble();
double scaledLowerValue = is.lowerValue;
double scaledUpperValue = is.upperValue;
double scaledLowerSizeWidth = is.lowerSize.width();
double scaledLowerSizeHeight = is.lowerSize.height();
double scaledUpperSizeWidth = is.upperSize.width();
double scaledUpperSizeHeight = is.upperSize.height();
// interpolate the squared value if scale by area
if ( s.scaleByArea )
{
scaledValue = sqrt( scaledValue );
scaledLowerValue = sqrt( scaledLowerValue );
scaledUpperValue = sqrt( scaledUpperValue );
scaledLowerSizeWidth = sqrt( scaledLowerSizeWidth );
scaledLowerSizeHeight = sqrt( scaledLowerSizeHeight );
scaledUpperSizeWidth = sqrt( scaledUpperSizeWidth );
scaledUpperSizeHeight = sqrt( scaledUpperSizeHeight );
}
//interpolate size
double scaledRatio = ( scaledValue - scaledLowerValue ) / ( scaledUpperValue - scaledLowerValue );
QSizeF size = QSizeF( is.upperSize.width() * scaledRatio + is.lowerSize.width() * ( 1 - scaledRatio ),
is.upperSize.height() * scaledRatio + is.lowerSize.height() * ( 1 - scaledRatio ) );
// Scale, if extension is smaller than the specified minimum
if ( size.width() <= s.minimumSize && size.height() <= s.minimumSize )
{
size.scale( s.minimumSize, s.minimumSize, Qt::KeepAspectRatio );
}
return size;
}
void VlcQmlVideoObject::updateCropRatio()
{
QSizeF ar = Vlc::ratioSize( _cropRatio );
if( ar.width() != 0 && ar.height() != 0)
{
QRectF cropRect = _boundingRect;
qreal ratio = qMin( cropRect.width() / ar.width() , cropRect.height() / ar.height() );
cropRect.setWidth( (qreal) ratio * ar.width() );
cropRect.setHeight( (qreal) ratio * ar.height() );
QSizeF scaledFrameSize = cropRect.size();
scaledFrameSize.scale(_geometry.size(), Qt::KeepAspectRatio);
_boundingRect.setWidth( _boundingRect.width() * ( scaledFrameSize.width() / cropRect.width() ) );
_boundingRect.setHeight( _boundingRect.height() * ( scaledFrameSize.height() / cropRect.height() ) );
}
}
inline static QImage renderedLessonIcon(const QString &iconId, int buttonVariation, QSize *size, const QSize &requestedSize)
{
QImage result(requestedSize, QImage::Format_ARGB32);
result.fill(Qt::transparent);
QPainter p(&result);
QSvgRenderer *renderer = lessonIconsRenderer();
const QRectF iconRectOriginal = renderer->boundsOnElement(idPrefix + iconId);
QSizeF iconSize = iconRectOriginal.size();
iconSize.scale(requestedSize, Qt::KeepAspectRatio);
QRectF iconRect(QPointF(), iconSize);
if (requestedSize.height() > requestedSize.width())
iconRect.moveBottom(requestedSize.height());
else
iconRect.moveTop((requestedSize.height() - iconSize.height()) / 2);
renderer->render(&p, idPrefix + iconId, iconRect);
const QImage button = renderedDesignElement(DesignElementTypeButton, buttonVariation, size, requestedSize);
p.drawImage(QPointF(), button);
return result;
}
QSizeF QgsDiagram::sizeForValue( double value, const QgsDiagramSettings &s, const QgsDiagramInterpolationSettings &is ) const
{
double scaledValue = value;
double scaledLowerValue = is.lowerValue;
double scaledUpperValue = is.upperValue;
// interpolate the squared value if scale by area
if ( s.scaleByArea )
{
scaledValue = sqrt( scaledValue );
scaledLowerValue = sqrt( scaledLowerValue );
scaledUpperValue = sqrt( scaledUpperValue );
}
//interpolate size
double scaledRatio = ( scaledValue - scaledLowerValue ) / ( scaledUpperValue - scaledLowerValue );
QSizeF size = QSizeF( is.upperSize.width() * scaledRatio + is.lowerSize.width() * ( 1 - scaledRatio ),
is.upperSize.height() * scaledRatio + is.lowerSize.height() * ( 1 - scaledRatio ) );
// Scale, if extension is smaller than the specified minimum
if ( size.width() <= s.minimumSize && size.height() <= s.minimumSize )
{
bool p = false; // preserve height == width
if ( qgsDoubleNear( size.width(), size.height() ) )
p = true;
size.scale( s.minimumSize, s.minimumSize, Qt::KeepAspectRatio );
// If height == width, recover here (overwrite floating point errors)
if ( p )
size.setWidth( size.height() );
}
return size;
}
//------------------------------------------------------------------------
//
// ThumbnailContext
//
//------------------------------------------------------------------------
bool ThumbnailContext::load(const QString &pixPath, int pixelSize)
{
mImage = QImage();
mNeedCaching = true;
Orientation orientation = NORMAL;
QImageReader reader(pixPath);
if (!reader.canRead()) {
reader.setDecideFormatFromContent(true);
// Set filename again, otherwise QImageReader won't restart from scratch
reader.setFileName(pixPath);
}
// If it's a Jpeg, try to load an embedded thumbnail, if available.
// If applyExifOrientation is not set, don't use the
// embedded thumbnail since it might be rotated differently
// than the actual image
if (reader.format() == "jpeg" && GwenviewConfig::applyExifOrientation()) {
JpegContent content;
content.load(pixPath);
QImage thumbnail = content.thumbnail();
orientation = content.orientation();
if (qMax(thumbnail.width(), thumbnail.height()) >= pixelSize) {
mImage = thumbnail;
if (orientation != NORMAL && orientation != NOT_AVAILABLE) {
QMatrix matrix = ImageUtils::transformMatrix(orientation);
mImage = mImage.transformed(matrix);
}
mOriginalWidth = content.size().width();
mOriginalHeight = content.size().height();
return true;
}
}
// Generate thumbnail from full image
QSize originalSize = reader.size();
if (originalSize.isValid() && reader.supportsOption(QImageIOHandler::ScaledSize)) {
QSizeF scaledSize = originalSize;
scaledSize.scale(pixelSize, pixelSize, Qt::KeepAspectRatio);
if (!scaledSize.isEmpty()) {
reader.setScaledSize(scaledSize.toSize());
}
}
QImage originalImage;
// format() is empty after QImageReader::read() is called
QByteArray format = reader.format();
if (!reader.read(&originalImage)) {
return false;
}
if (!originalSize.isValid()) {
originalSize = originalImage.size();
}
mOriginalWidth = originalSize.width();
mOriginalHeight = originalSize.height();
if (qMax(mOriginalWidth, mOriginalHeight) <= pixelSize) {
mImage = originalImage;
mNeedCaching = format != "png";
} else {
mImage = originalImage.scaled(pixelSize, pixelSize, Qt::KeepAspectRatio);
}
// Rotate if necessary
if (orientation != NORMAL && orientation != NOT_AVAILABLE && GwenviewConfig::applyExifOrientation()) {
QMatrix matrix = ImageUtils::transformMatrix(orientation);
mImage = mImage.transformed(matrix);
switch (orientation) {
case TRANSPOSE:
case ROT_90:
case TRANSVERSE:
case ROT_270:
qSwap(mOriginalWidth, mOriginalHeight);
break;
default:
break;
}
}
return true;
}
/*!
\brief Draw the symbol into a rectangle
The symbol is painted centered and scaled into the target rectangle.
It is always painted uncached and the pin point is ignored.
This method is primarily intended for drawing a symbol to
the legend.
\param painter Painter
\param rect Target rectangle for the symbol
*/
void QwtSymbol::drawSymbol( QPainter *painter, const QRectF &rect ) const
{
if ( d_data->style == QwtSymbol::NoSymbol )
return;
if ( d_data->style == QwtSymbol::Graphic )
{
d_data->graphic.graphic.render(
painter, rect, Qt::KeepAspectRatio );
}
else if ( d_data->style == QwtSymbol::Path )
{
if ( d_data->path.graphic.isNull() )
{
d_data->path.graphic = qwtPathGraphic(
d_data->path.path, d_data->pen, d_data->brush );
}
d_data->path.graphic.render(
painter, rect, Qt::KeepAspectRatio );
return;
}
else if ( d_data->style == QwtSymbol::SvgDocument )
{
#ifndef QWT_NO_SVG
if ( d_data->svg.renderer )
{
QRectF scaledRect;
QSizeF sz = d_data->svg.renderer->viewBoxF().size();
if ( !sz.isEmpty() )
{
sz.scale( rect.size(), Qt::KeepAspectRatio );
scaledRect.setSize( sz );
scaledRect.moveCenter( rect.center() );
}
else
{
scaledRect = rect;
}
d_data->svg.renderer->render(
painter, scaledRect );
}
#endif
}
else
{
const QRect br = boundingRect();
// scale the symbol size to fit into rect.
const double ratio = qMin( rect.width() / br.width(),
rect.height() / br.height() );
painter->save();
painter->translate( rect.center() );
painter->scale( ratio, ratio );
const bool isPinPointEnabled = d_data->isPinPointEnabled;
d_data->isPinPointEnabled = false;
const QPointF pos;
renderSymbols( painter, &pos, 1 );
d_data->isPinPointEnabled = isPinPointEnabled;
painter->restore();
}
}
