cppcanvas/source/mtfrenderer/mtftools.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: mtftools.hxx,v $
  10  * $Revision: 1.9.16.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef _CPPCANVAS_RENDERER_MTFTOOLS_HXX
  32 #define _CPPCANVAS_RENDERER_MTFTOOLS_HXX
  33
  34 #include <action.hxx>
  35 #include <cppcanvas/canvas.hxx>
  36
  37
  38 class VirtualDevice;
  39 class Point;
  40 class Size;
  41
  42 namespace basegfx
  43 {
  44     class B2DVector;
  45     class B2DPoint;
  46 }
  47 namespace com { namespace sun { namespace star { namespace rendering
  48 {
  49     struct RenderState;
  50 } } } }
  51
  52
  53 namespace cppcanvas
  54 {
  55     namespace internal
  56     {
  57         struct OutDevState;
  58     }
  59
  60     namespace tools
  61     {
  62         /** Init render state from OutDevState
  63
  64             This method initializes the given render state object,
  65             sets up the transformation and the clip from the
  66             OutDevState.
  67          */
  68         void initRenderState( ::com::sun::star::rendering::RenderState& renderState,
  69                               const ::cppcanvas::internal::OutDevState&                 outdevState );
  70
  71         /** Calc output offset relative to baseline
  72
  73             The XCanvas API always renders text relative to its
  74             baseline. This method calculates an offset in logical
  75             coordinates, depending on the OutDevState's
  76             textReferencePoint and the font currently set, to offset
  77             the text from the baseline.
  78
  79             @param outdevState
  80             State to take textReferencePoint from
  81
  82             @param rVDev
  83             VDev to obtain font metrics from.
  84          */
  85         ::Size getBaselineOffset( const ::cppcanvas::internal::OutDevState&     outdevState,
  86                                   const VirtualDevice&                                          rVDev );
  87
  88         /** Construct a matrix that converts from logical to pixel
  89             coordinate system.
  90
  91             This method calculates a matrix that approximates the
  92             VirtualDevice's LogicToPixel conversion (disregarding any
  93             offset components, thus the 'linear' in the method name -
  94             the returned matrix is guaranteed to be linear).
  95
  96             @param o_rMatrix
  97             This matrix will receive the calculated transform, and is
  98             also returned from this method.
  99
 100             @return the calculated transformation matrix.
 101          */
 102         ::basegfx::B2DHomMatrix& calcLogic2PixelLinearTransform( ::basegfx::B2DHomMatrix&       o_rMatrix,
 103                                                                  const VirtualDevice&           rVDev );
 104
 105         /** Construct a matrix that converts from logical to pixel
 106             coordinate system.
 107
 108             This method calculates a matrix that approximates the
 109             VirtualDevice's LogicToPixel conversion.
 110
 111             @param o_rMatrix
 112             This matrix will receive the calculated transform, and is
 113             also returned from this method.
 114
 115             @return the calculated transformation matrix.
 116          */
 117         ::basegfx::B2DHomMatrix& calcLogic2PixelAffineTransform( ::basegfx::B2DHomMatrix&       o_rMatrix,
 118                                                                  const VirtualDevice&           rVDev );
 119
 120         /** This method modifies the clip, to cancel the given
 121             transformation.
 122
 123             As the clip is relative to the render state
 124             transformation, offsetting or scaling the render state
 125             must modify the clip, to keep it at the same position
 126             relative to the primitive at hand
 127
 128             @param o_rRenderState
 129             Render state to change the clip in
 130
 131             @param rOutdevState
 132             Input state. Is used to retrieve the original clip from
 133
 134             @param rOffset
 135             The clip is offsetted by the negative of this value.
 136
 137             @param pScaling
 138             The clip is inversely scaled by this value (if given)
 139
 140             @param pRotation
 141             The clip is inversely rotated by this value (if given)
 142
 143             @return true, if the clip has changed, false if not
 144          */
 145         bool modifyClip( ::com::sun::star::rendering::RenderState&                      o_rRenderState,
 146                          const struct ::cppcanvas::internal::OutDevState&       rOutdevState,
 147                          const CanvasSharedPtr&                                                         rCanvas,
 148                          const ::Point&                                                                         rOffset,
 149                          const ::basegfx::B2DVector*                                            pScaling,
 150                          const double*                                      pRotation );
 151
 152         /** This method modifies the clip, to cancel the given
 153             transformation.
 154
 155             As the clip is relative to the render state
 156             transformation, offsetting or scaling the render state
 157             must modify the clip, to keep it at the same position
 158             relative to the primitive at hand
 159
 160             @param o_rRenderState
 161             Render state to change the clip in
 162
 163             @param rOutdevState
 164             Input state. Is used to retrieve the original clip from
 165
 166             @param rOffset
 167             The clip is offsetted by the negative of this value.
 168
 169             @param pScaling
 170             The clip is inversely scaled by this value (if given)
 171
 172             @param pRotation
 173             The clip is inversely rotated by this value (if given)
 174
 175             @return true, if the clip has changed, false if not
 176          */
 177         bool modifyClip( ::com::sun::star::rendering::RenderState&                      o_rRenderState,
 178                          const struct ::cppcanvas::internal::OutDevState&       rOutdevState,
 179                          const CanvasSharedPtr&                                                         rCanvas,
 180                          const ::basegfx::B2DPoint&                                                     rOffset,
 181                          const ::basegfx::B2DVector*                                            pScaling,
 182                          const double*                                      pRotation );
 183
 184         /** This method modifies the clip, to cancel the given
 185             transformation.
 186
 187             As the clip is relative to the render state
 188             transformation, transforming the render state further must
 189             modify the clip, to keep it at the same position relative
 190             to the primitive at hand
 191
 192             @param o_rRenderState
 193             Render state to change the clip in
 194
 195             @param rOutdevState
 196             Input state. Is used to retrieve the original clip from
 197
 198             @param rTransform
 199             The clip is transformed by the inverse of this value.
 200
 201             @return true, if the clip has changed, false if not
 202          */
 203         bool modifyClip( ::com::sun::star::rendering::RenderState&                      o_rRenderState,
 204                          const struct ::cppcanvas::internal::OutDevState&       rOutdevState,
 205                          const CanvasSharedPtr&                                                         rCanvas,
 206                          const ::basegfx::B2DHomMatrix&                                         rTransform );
 207
 208         struct TextLineInfo
 209         {
 210             TextLineInfo( const double& rLineHeight,
 211                           const double& rOverlineHeight,
 212                           const double& rOverlineOffset,
 213                           const double& rUnderlineOffset,
 214                           const double& rStrikeoutOffset,
 215                           sal_Int8              nOverlineStyle,
 216                           sal_Int8              nUnderlineStyle,
 217                           sal_Int8              nStrikeoutStyle ) :
 218                 mnLineHeight( rLineHeight ),
 219                 mnOverlineHeight( rOverlineHeight ),
 220                 mnOverlineOffset( rOverlineOffset ),
 221                 mnUnderlineOffset( rUnderlineOffset ),
 222                 mnStrikeoutOffset( rStrikeoutOffset ),
 223                 mnOverlineStyle( nOverlineStyle ),
 224                 mnUnderlineStyle( nUnderlineStyle ),
 225                 mnStrikeoutStyle( nStrikeoutStyle )
 226             {
 227             }
 228
 229             double              mnLineHeight;
 230             double              mnOverlineHeight;
 231             double              mnOverlineOffset;
 232             double              mnUnderlineOffset;
 233             double              mnStrikeoutOffset;
 234             sal_Int8    mnOverlineStyle;
 235             sal_Int8    mnUnderlineStyle;
 236             sal_Int8    mnStrikeoutStyle;
 237         };
 238
 239         /** Transform given bounds to device coordinate system.
 240          */
 241         ::basegfx::B2DRange calcDevicePixelBounds( const ::basegfx::B2DRange&                                           rBounds,
 242                                                    const ::com::sun::star::rendering::ViewState&        viewState,
 243                                                    const ::com::sun::star::rendering::RenderState&      renderState );
 244
 245         /** Generate text underline/strikeout info struct from OutDev
 246             state.
 247          */
 248         TextLineInfo createTextLineInfo( const ::VirtualDevice&                                         rVDev,
 249                                          const ::cppcanvas::internal::OutDevState&      rState );
 250
 251         /** Create a poly-polygon representing the given combination
 252             of overline, strikeout and underline.
 253
 254             @param rStartOffset
 255             Offset in X direction, where the underline starts
 256
 257             @param rLineWidth
 258             Width of the line of text to overline/strikeout/underline
 259
 260             @param rTextLineInfo
 261             Common info needed for overline/strikeout/underline generation
 262          */
 263         ::basegfx::B2DPolyPolygon createTextLinesPolyPolygon( const double&                     rStartOffset,
 264                                                               const double&                     rLineWidth,
 265                                                               const TextLineInfo&       rTextLineInfo );
 266
 267         ::basegfx::B2DPolyPolygon createTextLinesPolyPolygon( const ::basegfx::B2DPoint rStartPos,
 268                                                               const double&                             rLineWidth,
 269                                                               const TextLineInfo&               rTextLineInfo );
 270     }
 271 }
 272
 273 #endif /* _CPPCANVAS_RENDERER_MTFTOOLS_HXX */