/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/composer/qgscomposerutils.h                                 *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.pl again   *
 ************************************************************************/




class QgsComposerUtils
{
%Docstring
Utilities for compositions.
%End

%TypeHeaderCode
#include "qgscomposerutils.h"
%End
  public:

    static void drawArrowHead( QPainter *p, const double x, const double y, const double angle, const double arrowHeadWidth );
%Docstring
Draws an arrow head on to a QPainter.

:param p: destination painter
:param x: x-coordinate of arrow center
:param y: y-coordinate of arrow center
:param angle: angle in degrees which arrow should point toward, measured
clockwise from pointing vertical upward
:param arrowHeadWidth: size of arrow head
%End

    static double angle( QPointF p1, QPointF p2 );
%Docstring
Calculates the angle of the line from p1 to p2 (counter clockwise,
starting from a line from north to south)

:param p1: start point of line
:param p2: end point of line

:return: angle in degrees, clockwise from south
%End

    static void rotate( const double angle, double &x, double &y );
%Docstring
Rotates a point / vector around the origin.

:param angle: rotation angle in degrees, counterclockwise
:param x: in/out: x coordinate before / after the rotation
:param y: in/out: y cooreinate before / after the rotation
%End

    static double normalizedAngle( const double angle );
%Docstring
Ensures that an angle is in the range 0 <= angle < 360

:param angle: angle in degrees

:return: equivalent angle within the range [0, 360)

.. seealso:: :py:func:`snappedAngle`
%End

    static double snappedAngle( const double angle );
%Docstring
Snaps an angle to its closest 45 degree angle

:param angle: angle in degrees

:return: angle snapped to 0, 45/90/135/180/225/270 or 315 degrees
%End

    static QRectF largestRotatedRectWithinBounds( const QRectF &originalRect, const QRectF &boundsRect, const double rotation );
%Docstring
Calculates the largest scaled version of originalRect which fits within boundsRect, when it is rotated by
a specified amount.

:param originalRect: QRectF to be rotated and scaled
:param boundsRect: QRectF specifying the bounds which the rotated and scaled rectangle must fit within
:param rotation: the rotation in degrees to be applied to the rectangle

:return: largest scaled version of the rectangle possible
%End

    static double pointsToMM( const double pointSize );
%Docstring
Returns the size in mm corresponding to a font point size

:param pointSize: font size in points

.. seealso:: :py:func:`mmToPoints`
%End

    static double mmToPoints( const double mmSize );
%Docstring
Returns the size in mm corresponding to a font point size

:param mmSize: font size in mm

.. seealso:: :py:func:`pointsToMM`
%End

    static void relativeResizeRect( QRectF &rectToResize, const QRectF &boundsBefore, const QRectF &boundsAfter );
%Docstring
Resizes a QRectF relative to a resized bounding rectangle.

:param rectToResize: QRectF to resize, contained within boundsBefore. The
rectangle is linearly scaled to retain its relative position and size within
boundsAfter.
:param boundsBefore: QRectF of bounds before resize
:param boundsAfter: QRectF of bounds after resize
%End

    static double relativePosition( const double position, const double beforeMin, const double beforeMax, const double afterMin, const double afterMax );
%Docstring
Returns a scaled position given a before and after range

:param position: initial position within before range to scale
:param beforeMin: minimum value in before range
:param beforeMax: maximum value in before range
:param afterMin: minimum value in after range
:param afterMax: maximum value in after range

:return: position scaled to range specified by afterMin and afterMax
%End

    static QgsComposition::PaperOrientation decodePaperOrientation( const QString &orientationString, bool &ok );
%Docstring
Decodes a string representing a paper orientation

:param orientationString: string to decode
:param ok: will be true if string could be decoded

:return: decoded paper orientation
%End

    static bool decodePresetPaperSize( const QString &presetString, double &width, double &height );
%Docstring
Decodes a string representing a preset page size

:param presetString: string to decode
:param width: double for decoded paper width
:param height: double for decoded paper height

:return: true if string could be decoded successfully
%End

    static void readOldDataDefinedPropertyMap( const QDomElement &itemElem,
        QgsPropertyCollection &dataDefinedProperties );
%Docstring
Reads all pre 3.0 data defined properties from an XML element.

.. versionadded:: 3.0

.. seealso:: :py:func:`readDataDefinedProperty`

.. seealso:: :py:func:`writeDataDefinedPropertyMap`
%End

    static QgsProperty readOldDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property, const QDomElement &ddElem );
%Docstring
Reads a pre 3.0 data defined property from an XML DOM element.

.. versionadded:: 3.0

.. seealso:: :py:func:`readDataDefinedPropertyMap`
%End

    static QFont scaledFontPixelSize( const QFont &font );
%Docstring
Returns a font where size is set in pixels and the size has been upscaled with FONT_WORKAROUND_SCALE
to workaround QT font rendering bugs

:param font: source font with size set in points

:return: font with size set in pixels

.. versionadded:: 2.5
%End

    static double fontAscentMM( const QFont &font );
%Docstring
Calculate font ascent in millimeters, including workarounds for QT font rendering issues

:param font: input font

:return: font ascent in millimeters

.. versionadded:: 2.5

.. seealso:: :py:func:`fontDescentMM`

.. seealso:: :py:func:`fontHeightMM`

.. seealso:: :py:func:`fontHeightCharacterMM`

.. seealso:: :py:func:`textWidthMM`
%End

    static double fontDescentMM( const QFont &font );
%Docstring
Calculate font descent in millimeters, including workarounds for QT font rendering issues

:param font: input font

:return: font descent in millimeters

.. versionadded:: 2.5

.. seealso:: :py:func:`fontAscentMM`

.. seealso:: :py:func:`fontHeightMM`

.. seealso:: :py:func:`fontHeightCharacterMM`

.. seealso:: :py:func:`textWidthMM`
%End

    static double fontHeightMM( const QFont &font );
%Docstring
Calculate font height in millimeters, including workarounds for QT font rendering issues
The font height is the font ascent + descent + 1 (for the baseline).

:param font: input font

:return: font height in millimeters

.. versionadded:: 2.5

.. seealso:: :py:func:`fontAscentMM`

.. seealso:: :py:func:`fontDescentMM`

.. seealso:: :py:func:`fontHeightCharacterMM`

.. seealso:: :py:func:`textWidthMM`
%End

    static double fontHeightCharacterMM( const QFont &font, QChar character );
%Docstring
Calculate font height in millimeters of a single character, including workarounds for QT font
rendering issues

:param font: input font
:param character: character to calculate height for

:return: character height in millimeters

.. versionadded:: 2.5

.. seealso:: :py:func:`fontAscentMM`

.. seealso:: :py:func:`fontDescentMM`

.. seealso:: :py:func:`fontHeightMM`

.. seealso:: :py:func:`textWidthMM`
%End

    static double textWidthMM( const QFont &font, const QString &text );
%Docstring
Calculate font width in millimeters for a string, including workarounds for QT font
rendering issues

:param font: input font
:param text: string to calculate width of

:return: string width in millimeters

.. versionadded:: 2.5

.. seealso:: :py:func:`fontAscentMM`

.. seealso:: :py:func:`fontDescentMM`

.. seealso:: :py:func:`fontHeightMM`

.. seealso:: :py:func:`fontHeightCharacterMM`

.. seealso:: :py:func:`textHeightMM`
%End

    static double textHeightMM( const QFont &font, const QString &text, double multiLineHeight = 1.0 );
%Docstring
Calculate font height in millimeters for a string, including workarounds for QT font
rendering issues. Note that this method uses a non-standard measure of text height,
where only the font ascent is considered for the first line of text.

:param font: input font
:param text: string to calculate height of
:param multiLineHeight: line spacing factor

:return: string height in millimeters

.. versionadded:: 2.12

.. seealso:: :py:func:`textWidthMM`
%End

    static void drawText( QPainter *painter, QPointF pos, const QString &text, const QFont &font, const QColor &color = QColor() );
%Docstring
Draws text on a painter at a specific position, taking care of composer specific issues (calculation to pixel,
scaling of font and painter to work around Qt font bugs)

:param painter: destination QPainter
:param pos: position to draw text
:param text: string to draw
:param font: font to use for drawing text
:param color: color to draw text

.. versionadded:: 2.5
%End

    static void drawText( QPainter *painter, const QRectF &rect, const QString &text, const QFont &font, const QColor &color = QColor(), const Qt::AlignmentFlag halignment = Qt::AlignLeft, const Qt::AlignmentFlag valignment = Qt::AlignTop, const int flags = Qt::TextWordWrap );
%Docstring
Draws text on a painter within a rectangle, taking care of composer specific issues (calculation to pixel,
scaling of font and painter to work around Qt font bugs)

:param painter: destination QPainter
:param rect: rectangle to draw into
:param text: string to draw
:param font: font to use for drawing text
:param color: color to draw text
:param halignment: optional horizontal alignment
:param valignment: optional vertical alignment
:param flags: allows for passing Qt.TextFlags to control appearance of rendered text

.. versionadded:: 2.5
%End

    static QgsRenderContext createRenderContextForMap( QgsComposerMap *map, QPainter *painter, double dpi = -1 );
%Docstring
Creates a render context suitable for the specified composer ``map`` and ``painter`` destination.
This method returns a new QgsRenderContext which matches the scale and settings of the
target map. If the ``dpi`` argument is not specified then the dpi will be taken from the destinatation
painter device.

.. versionadded:: 3.0

.. seealso:: :py:func:`createRenderContextForComposition()`
%End

    static QgsRenderContext createRenderContextForComposition( QgsComposition *composition, QPainter *painter );
%Docstring
Creates a render context suitable for the specified ``composition`` and ``painter`` destination.
This method returns a new QgsRenderContext which matches the scale and settings from the composition's
QgsComposition.referenceMap().

.. versionadded:: 3.0

.. seealso:: :py:func:`createRenderContextForMap()`
%End

};

/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/composer/qgscomposerutils.h                                 *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.pl again   *
 ************************************************************************/