LCOV - code coverage report
Current view: top level - include/basebmp - bitmapdevice.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 2 0.0 %
Date: 2014-04-14 Functions: 0 2 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #ifndef INCLUDED_BASEBMP_BITMAPDEVICE_HXX
      21             : #define INCLUDED_BASEBMP_BITMAPDEVICE_HXX
      22             : 
      23             : #include <sal/types.h>
      24             : #include <basebmp/drawmodes.hxx>
      25             : #include <basebmp/scanlineformats.hxx>
      26             : #include <basebmp/basebmpdllapi.h>
      27             : 
      28             : #include <boost/scoped_ptr.hpp>
      29             : #include <boost/shared_ptr.hpp>
      30             : #include <boost/shared_array.hpp>
      31             : #include <boost/enable_shared_from_this.hpp>
      32             : #include <boost/noncopyable.hpp>
      33             : #include <vector>
      34             : 
      35             : namespace basegfx
      36             : {
      37             :     class B2IPoint;
      38             :     class B2DPoint;
      39             :     class B2IVector;
      40             :     class B2IBox;
      41             :     class B2DPolygon;
      42             :     class B2DPolyPolygon;
      43             : }
      44             : 
      45             : namespace basebmp
      46             : {
      47             : 
      48             : // Temporary. Use like the tools color object
      49             : class Color;
      50             : typedef boost::shared_ptr< class BitmapDevice >                BitmapDeviceSharedPtr;
      51             : typedef boost::shared_ptr< struct IBitmapDeviceDamageTracker > IBitmapDeviceDamageTrackerSharedPtr;
      52             : typedef boost::shared_array< sal_uInt8 >                       RawMemorySharedArray;
      53             : typedef boost::shared_ptr< const std::vector<Color> >          PaletteMemorySharedVector;
      54             : 
      55             : struct ImplBitmapDevice;
      56             : 
      57             : /// Interface for getting damage tracking events
      58           0 : struct IBitmapDeviceDamageTracker
      59             : {
      60             :     /// gets called when said region is clobbered
      61             :     virtual void damaged(const basegfx::B2IBox& rDamageRect) const = 0;
      62             : 
      63             : protected:
      64           0 :     ~IBitmapDeviceDamageTracker() {}
      65             : };
      66             : 
      67             : /** Definition of BitmapDevice interface
      68             : 
      69             :     Use the createBitmapDevice() function to create instances.
      70             : 
      71             :     Implementation note: the clip mask and bitmap parameter instances
      72             :     of BitmapDevice that are passed to individual BitmapDevice
      73             :     instances work best with 1 bit grey masks for the clip and a
      74             :     format matching that of the target BitmapDevice for the other
      75             :     parameters. The alpha mask passed to the drawMaskedColor() methods
      76             :     works best when given as an eight bit grey bitmap. Everything else
      77             :     is accepted, but potentially slow.
      78             :  */
      79             : class BASEBMP_DLLPUBLIC BitmapDevice : public boost::enable_shared_from_this<BitmapDevice>,
      80             :                                        private boost::noncopyable
      81             : {
      82             : public:
      83             :     /** Query size of device in pixel columns (X) and rows (Y, "scanlines")
      84             :      */
      85             :     basegfx::B2IVector getSize() const;
      86             : 
      87             :     /** Query whether buffer starts with 0th scanline
      88             : 
      89             :         @return true, if the buffer memory starts with the 0th
      90             :         scanline, and false if it starts with the last one. The latter
      91             :         is e.g. the typical scan line ordering for the Windows BMP
      92             :         format.
      93             :      */
      94             :     bool isTopDown() const;
      95             : 
      96             :     /** Query the size of the whole frame buffer
      97             : 
      98             :         @ return the size of the whole frame buffer, the same as
      99             :         getSize() unless this is a "subset" device.
     100             :     */
     101             :     basegfx::B2IVector getBufferSize() const;
     102             : 
     103             :     /** Query type of scanline memory format
     104             :      */
     105             :     Format getScanlineFormat() const;
     106             : 
     107             :     /** Query byte offset to get from scanline n to scanline n+1
     108             : 
     109             :         @return the scanline stride in bytes.
     110             :      */
     111             :     sal_Int32 getScanlineStride() const;
     112             : 
     113             :     /** Get pointer to frame buffer
     114             : 
     115             :         @return a shared ptr to the bitmap buffer memory. As this is a
     116             :         shared ptr, you can freely store and use the pointer, even
     117             :         after this object has been deleted.
     118             :      */
     119             :     RawMemorySharedArray getBuffer() const;
     120             : 
     121             :     /// Query current damage tracking object (if any)
     122             :     IBitmapDeviceDamageTrackerSharedPtr getDamageTracker() const;
     123             : 
     124             :     /** Set new damage tracking object
     125             : 
     126             :         @param rDamage
     127             :         Object implementing the IBitmapDeviceDamageTracker interface -
     128             :         everytime some area of the surface gets clobbered, that object
     129             :         gets notified.
     130             :      */
     131             :     void  setDamageTracker( const IBitmapDeviceDamageTrackerSharedPtr& rDamage );
     132             : 
     133             :     /** Get pointer to palette
     134             : 
     135             :         The returned pointer is const on purpose, since the
     136             :         BitmapDevice might internally cache lookup information. Don't
     137             :         modify the returned data, unless you want to enter the realm
     138             :         of completely undefined behaviour.
     139             : 
     140             :         @return shared pointer to vector of Color entries.
     141             :      */
     142             :     PaletteMemorySharedVector getPalette() const;
     143             : 
     144             :     /// Check if this and the other BitmapDevice share a buffer
     145             :     bool isSharedBuffer( const BitmapDeviceSharedPtr& rOther ) const;
     146             : 
     147             :     /** Clear whole device with given color
     148             : 
     149             :         This method works like a fill with the given color value,
     150             :         resulting in a bitmap uniformly colored in fillColor.
     151             :      */
     152             :     void clear( Color fillColor );
     153             : 
     154             :     /** Set given pixel to specified color
     155             : 
     156             :         @param rPt
     157             :         Pixel to set
     158             : 
     159             :         @param pixelColor
     160             :         Color value to set the pixel to
     161             : 
     162             :         @param drawMode
     163             :         Draw mode to use when changing the pixel value
     164             :      */
     165             :     void setPixel( const basegfx::B2IPoint& rPt,
     166             :                    Color                    pixelColor,
     167             :                    DrawMode                 drawMode );
     168             : 
     169             :     /** Set given pixel to specified color
     170             : 
     171             :         @param rPt
     172             :         Pixel to set
     173             : 
     174             :         @param pixelColor
     175             :         Color value to set the pixel to
     176             : 
     177             :         @param drawMode
     178             :         Draw mode to use when changing the pixel value
     179             : 
     180             :         @param rClip
     181             :         Clip mask to use. If the clip mask is 1 at the given pixel
     182             :         position, no change will take place.
     183             :      */
     184             :     void setPixel( const basegfx::B2IPoint&     rPt,
     185             :                    Color                        pixelColor,
     186             :                    DrawMode                     drawMode,
     187             :                    const BitmapDeviceSharedPtr& rClip );
     188             : 
     189             :     /** Get color value at given pixel
     190             :      */
     191             :     Color getPixel( const basegfx::B2IPoint& rPt );
     192             : 
     193             :     /** Get underlying pixel data value at given position
     194             : 
     195             :         This method returns the raw pixel data. In the case of
     196             :         paletted bitmaps, this is the palette index, not the final
     197             :         color value.
     198             :      */
     199             :     sal_uInt32 getPixelData( const basegfx::B2IPoint& rPt );
     200             : 
     201             :     /** Draw a line
     202             : 
     203             :         @param rPt1
     204             :         Start point of the line
     205             : 
     206             :         @param rPt2
     207             :         End point of the line. If the analytical line from rP1 to rPt2
     208             :         (with the actual pixel positions assumed to be the center of
     209             :         the pixel) is exactly in the middle between two pixel, this
     210             :         method always selects the pixel closer to rPt1.
     211             : 
     212             :         @param lineColor
     213             :         Color value to draw the line with
     214             : 
     215             :         @param drawMode
     216             :         Draw mode to use when changing the pixel value
     217             :      */
     218             :     void drawLine( const basegfx::B2IPoint& rPt1,
     219             :                    const basegfx::B2IPoint& rPt2,
     220             :                    Color                    lineColor,
     221             :                    DrawMode                 drawMode );
     222             : 
     223             :     /** Draw a line
     224             : 
     225             :         @param rPt1
     226             :         Start point of the line
     227             : 
     228             :         @param rPt2
     229             :         End point of the line. If the analytical line from rP1 to rPt2
     230             :         (with the actual pixel positions assumed to be the center of
     231             :         the pixel) is exactly in the middle between two pixel, this
     232             :         method always selects the pixel closer to rPt1.
     233             : 
     234             :         @param lineColor
     235             :         Color value to draw the line with
     236             : 
     237             :         @param drawMode
     238             :         Draw mode to use when changing the pixel value
     239             : 
     240             :         @param rClip
     241             :         Clip mask to use. Pixel where the corresponding clip mask
     242             :         pixel is 1 will not be modified.
     243             :      */
     244             :     void drawLine( const basegfx::B2IPoint&     rPt1,
     245             :                    const basegfx::B2IPoint&     rPt2,
     246             :                    Color                        lineColor,
     247             :                    DrawMode                     drawMode,
     248             :                    const BitmapDeviceSharedPtr& rClip );
     249             : 
     250             :     /** Draw a polygon
     251             : 
     252             :         @param rPoly
     253             :         Polygon to draw. Depending on the value returned by rPoly's
     254             :         isClosed() method, the resulting line polygon will be drawn
     255             :         closed or not.
     256             : 
     257             :         @param lineColor
     258             :         Color value to draw the polygon with
     259             : 
     260             :         @param drawMode
     261             :         Draw mode to use when changing pixel values
     262             :      */
     263             :     void drawPolygon( const basegfx::B2DPolygon& rPoly,
     264             :                       Color                      lineColor,
     265             :                       DrawMode                   drawMode );
     266             : 
     267             :     /** Draw a polygon
     268             : 
     269             :         @param rPoly
     270             :         Polygon to draw. Depending on the value returned by rPoly's
     271             :         isClosed() method, the resulting line polygon will be drawn
     272             :         closed or not.
     273             : 
     274             :         @param lineColor
     275             :         Color value to draw the polygon with
     276             : 
     277             :         @param drawMode
     278             :         Draw mode to use when changing pixel values
     279             : 
     280             :         @param rClip
     281             :         Clip mask to use. Pixel where the corresponding clip mask
     282             :         pixel is 1 will not be modified.
     283             :      */
     284             :     void drawPolygon( const basegfx::B2DPolygon&   rPoly,
     285             :                       Color                        lineColor,
     286             :                       DrawMode                     drawMode,
     287             :                       const BitmapDeviceSharedPtr& rClip );
     288             : 
     289             :     /** Fill a poly-polygon
     290             : 
     291             :         @param rPoly
     292             :         Poly-polygon to fill. Regardless of the value returned by
     293             :         rPoly's isClosed() method, the resulting filled poly-polygon
     294             :         is always considered closed. As usual, when filling a shape,
     295             :         the rightmost and bottommost pixel are not filled, compared to
     296             :         the drawPolygon() method. For example, the rectangle
     297             :         (0,0),(1,1) will have four pixel set, when drawn via
     298             :         drawPolygon(), and only one pixel, when filled via
     299             :         fillPolyPolygon().
     300             : 
     301             :         @param fillColor
     302             :         Color value to fill the poly-polygon with
     303             : 
     304             :         @param drawMode
     305             :         Draw mode to use when changing pixel values
     306             :      */
     307             :     void fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly,
     308             :                           Color                          fillColor,
     309             :                           DrawMode                       drawMode );
     310             : 
     311             :     /** Fill a poly-polygon
     312             : 
     313             :         @param rPoly
     314             :         Poly-polygon to fill. Regardless of the value returned by
     315             :         rPoly's isClosed() method, the resulting filled poly-polygon
     316             :         is always considered closed. As usual, when filling a shape,
     317             :         the rightmost and bottommost pixel are not filled, compared to
     318             :         the drawPolygon() method. For example, the rectangle
     319             :         (0,0),(1,1) will have four pixel set, when drawn via
     320             :         drawPolygon(), and only one pixel, when filled via
     321             :         fillPolyPolygon().
     322             : 
     323             :         @param fillColor
     324             :         Color value to fill the poly-polygon with
     325             : 
     326             :         @param drawMode
     327             :         Draw mode to use when changing pixel values
     328             : 
     329             :         @param rClip
     330             :         Clip mask to use. Pixel where the corresponding clip mask
     331             :         pixel is 1 will not be modified.
     332             :      */
     333             :     void fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly,
     334             :                           Color                          fillColor,
     335             :                           DrawMode                       drawMode,
     336             :                           const BitmapDeviceSharedPtr&   rClip );
     337             : 
     338             :     /** Draw another bitmap into this device
     339             : 
     340             :         @param rSrcBitmap
     341             :         Bitmap to render into this one. It is permitted that source
     342             :         and destination bitmap are the same.
     343             : 
     344             :         @param rSrcRect
     345             :         Rectangle within the source bitmap to take the pixel from.
     346             : 
     347             :         @param rDstRect
     348             :         Rectangle in the destination bitmap to put the pixel
     349             :         into. Source and destination rectangle are permitted to have
     350             :         differing sizes; this method will scale the source pixel
     351             :         accordingly. Please note that both source and destination
     352             :         rectangle are interpreted excluding the rightmost pixel column
     353             :         and the bottommost pixel row, this is much like polygon
     354             :         filling. As a result, filling a given rectangle with
     355             :         fillPolyPolygon(), and using the same rectangle as the
     356             :         destination rectangle of this method, will affect exactly the
     357             :         same set of pixel.
     358             : 
     359             :         @param drawMode
     360             :         Draw mode to use when changing pixel values
     361             :      */
     362             :     void drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
     363             :                      const basegfx::B2IBox&       rSrcRect,
     364             :                      const basegfx::B2IBox&       rDstRect,
     365             :                      DrawMode                     drawMode );
     366             : 
     367             :     /** Draw another bitmap into this device
     368             : 
     369             :         @param rSrcBitmap
     370             :         Bitmap to render into this one. It is permitted that source
     371             :         and destination bitmap are the same.
     372             : 
     373             :         @param rSrcRect
     374             :         Rectangle within the source bitmap to take the pixel from.
     375             : 
     376             :         @param rDstRect
     377             :         Rectangle in the destination bitmap to put the pixel
     378             :         into. Source and destination rectangle are permitted to have
     379             :         differing sizes; this method will scale the source pixel
     380             :         accordingly. Please note that both source and destination
     381             :         rectangle are interpreted excluding the rightmost pixel column
     382             :         and the bottommost pixel row, this is much like polygon
     383             :         filling. As a result, filling a given rectangle with
     384             :         fillPolyPolygon(), and using the same rectangle as the
     385             :         destination rectangle of this method, will affect exactly the
     386             :         same set of pixel.
     387             : 
     388             :         @param drawMode
     389             :         Draw mode to use when changing pixel values
     390             : 
     391             :         @param rClip
     392             :         Clip mask to use. Pixel where the corresponding clip mask
     393             :         pixel is 1 will not be modified.
     394             :      */
     395             :     void drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
     396             :                      const basegfx::B2IBox&       rSrcRect,
     397             :                      const basegfx::B2IBox&       rDstRect,
     398             :                      DrawMode                     drawMode,
     399             :                      const BitmapDeviceSharedPtr& rClip );
     400             : 
     401             :     /** Draw a color with an alpha-modulation bitmap into this device
     402             : 
     403             :         This method takes a fixed color value, and an alpha mask. For
     404             :         each pixel in the alpha mask, the given color value is blended
     405             :         with the corresponding alpha value against the content of this
     406             :         object.
     407             : 
     408             :         @param aSrcColor
     409             :         Color value to use for blending
     410             : 
     411             :         @param rAlphaMask
     412             :         Alpha mask to use for blending. It is permitted that alpha
     413             :         mask and this bitmap are the same object.
     414             : 
     415             :         @param rSrcRect
     416             :         Rectangle within the alpha mask to take the pixel from.
     417             :         Please note that the destination rectangle is interpreted
     418             :         excluding the rightmost pixel column and the bottommost pixel
     419             :         row, this is much like polygon filling. As a result, filling a
     420             :         given rectangle with fillPolyPolygon(), and using the same
     421             :         rectangle as the source rectangle of this method, will affect
     422             :         exactly the same set of pixel.
     423             : 
     424             :         @param rDstPoint
     425             :         Destination point, where to start placing the pixel from the
     426             :         source rectangle
     427             :      */
     428             :     void drawMaskedColor( Color                        aSrcColor,
     429             :                           const BitmapDeviceSharedPtr& rAlphaMask,
     430             :                           const basegfx::B2IBox&       rSrcRect,
     431             :                           const basegfx::B2IPoint&     rDstPoint );
     432             : 
     433             :     /** Draw a color with an alpha-modulation bitmap into this device
     434             : 
     435             :         This method takes a fixed color value, and an alpha mask. For
     436             :         each pixel in the alpha mask, the given color value is blended
     437             :         with the corresponding alpha value against the content of this
     438             :         object.
     439             : 
     440             :         @param aSrcColor
     441             :         Color value to use for blending
     442             : 
     443             :         @param rAlphaMask
     444             :         Alpha mask to use for blending. It is permitted that alpha
     445             :         mask and this bitmap are the same object.
     446             : 
     447             :         @param rSrcRect
     448             :         Rectangle within the alpha mask to take the pixel from.
     449             :         Please note that the destination rectangle is interpreted
     450             :         excluding the rightmost pixel column and the bottommost pixel
     451             :         row, this is much like polygon filling. As a result, filling a
     452             :         given rectangle with fillPolyPolygon(), and using the same
     453             :         rectangle as the source rectangle of this method, will affect
     454             :         exactly the same set of pixel.
     455             : 
     456             :         @param rDstPoint
     457             :         Destination point, where to start placing the pixel from the
     458             :         source rectangle
     459             : 
     460             :         @param rClip
     461             :         Clip mask to use. Pixel where the corresponding clip mask
     462             :         pixel is 1 will not be modified.
     463             :      */
     464             :     void drawMaskedColor( Color                        aSrcColor,
     465             :                           const BitmapDeviceSharedPtr& rAlphaMask,
     466             :                           const basegfx::B2IBox&       rSrcRect,
     467             :                           const basegfx::B2IPoint&     rDstPoint,
     468             :                           const BitmapDeviceSharedPtr& rClip );
     469             : 
     470             :     /** Draw another bitmap through a mask into this device
     471             : 
     472             :         This method renders a source bitmap into this device, much
     473             :         like the drawBitmap() method. The only difference is the
     474             :         additional mask parameter, which operates much like an
     475             :         additional clip mask: pixel with value zero in this mask
     476             :         result in destination pixel not being modified.
     477             : 
     478             :         @param rSrcBitmap
     479             :         Bitmap to render into this one. It is permitted that source
     480             :         and destination bitmap are the same.
     481             : 
     482             :         @param rMask
     483             :         Bitmap to use as a mask. Pixel with value != zero in this mask
     484             :         will result in destination pixel not being affected by the
     485             :         blit operation.
     486             : 
     487             :         @param rSrcRect
     488             :         Rectangle within the source bitmap to take the pixel from.
     489             : 
     490             :         @param rDstRect
     491             :         Rectangle in the destination bitmap to put the pixel
     492             :         into. Source and destination rectangle are permitted to have
     493             :         differing sizes; this method will scale the source pixel
     494             :         accordingly. Please note that both source and destination
     495             :         rectangle are interpreted excluding the rightmost pixel column
     496             :         and the bottommost pixel row, this is much like polygon
     497             :         filling. As a result, filling a given rectangle with
     498             :         fillPolyPolygon(), and using the same rectangle as the
     499             :         destination rectangle of this method, will affect exactly the
     500             :         same set of pixel.
     501             : 
     502             :         @param drawMode
     503             :         Draw mode to use when changing pixel values
     504             :      */
     505             :     void drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
     506             :                            const BitmapDeviceSharedPtr& rMask,
     507             :                            const basegfx::B2IBox&       rSrcRect,
     508             :                            const basegfx::B2IBox&       rDstRect,
     509             :                            DrawMode                     drawMode );
     510             : 
     511             :     /** Draw another bitmap through a mask into this device
     512             : 
     513             :         This method renders a source bitmap into this device, much
     514             :         like the drawBitmap() method. The only difference is the
     515             :         additional mask parameter, which operates much like an
     516             :         additional clip mask: pixel with value != zero in this mask
     517             :         result in destination pixel not being modified.
     518             : 
     519             :         @param rSrcBitmap
     520             :         Bitmap to render into this one. It is permitted that source
     521             :         and destination bitmap are the same.
     522             : 
     523             :         @param rMask
     524             :         Bitmap to use as a mask. Pixel with value != zero in this mask
     525             :         will result in destination pixel not being affected by the
     526             :         blit operation.
     527             : 
     528             :         @param rSrcRect
     529             :         Rectangle within the source bitmap to take the pixel from.
     530             : 
     531             :         @param rDstRect
     532             :         Rectangle in the destination bitmap to put the pixel
     533             :         into. Source and destination rectangle are permitted to have
     534             :         differing sizes; this method will scale the source pixel
     535             :         accordingly. Please note that both source and destination
     536             :         rectangle are interpreted excluding the rightmost pixel column
     537             :         and the bottommost pixel row, this is much like polygon
     538             :         filling. As a result, filling a given rectangle with
     539             :         fillPolyPolygon(), and using the same rectangle as the
     540             :         destination rectangle of this method, will affect exactly the
     541             :         same set of pixel.
     542             : 
     543             :         @param drawMode
     544             :         Draw mode to use when changing pixel values
     545             : 
     546             :         @param rClip
     547             :         Clip mask to use. Pixel where the corresponding clip mask
     548             :         pixel is 1 will not be modified.
     549             :      */
     550             :     void drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
     551             :                            const BitmapDeviceSharedPtr& rMask,
     552             :                            const basegfx::B2IBox&       rSrcRect,
     553             :                            const basegfx::B2IBox&       rDstRect,
     554             :                            DrawMode                     drawMode,
     555             :                            const BitmapDeviceSharedPtr& rClip );
     556             : 
     557             : protected:
     558             :     BASEBMP_DLLPRIVATE BitmapDevice( const basegfx::B2IBox&           rBounds,
     559             :                                      const basegfx::B2IVector&        rBufferSize,
     560             :                                      Format                           nScanlineFormat,
     561             :                                      sal_Int32                        nScanlineStride,
     562             :                                      sal_uInt8*                       pFirstScanline,
     563             :                                      const RawMemorySharedArray&      rMem,
     564             :                                      const PaletteMemorySharedVector& rPalette );
     565             :     BASEBMP_DLLPRIVATE virtual ~BitmapDevice();
     566             : 
     567             : private:
     568             :     BASEBMP_DLLPRIVATE virtual bool isCompatibleBitmap( const BitmapDeviceSharedPtr& bmp ) const = 0;
     569             :     BASEBMP_DLLPRIVATE virtual bool isCompatibleClipMask( const BitmapDeviceSharedPtr& bmp ) const = 0;
     570             :     BASEBMP_DLLPRIVATE virtual bool isCompatibleAlphaMask( const BitmapDeviceSharedPtr& bmp ) const = 0;
     571             : 
     572             :     BASEBMP_DLLPRIVATE virtual void clear_i( Color                  fillColor,
     573             :                                              const basegfx::B2IBox& rBounds ) = 0;
     574             : 
     575             :     BASEBMP_DLLPRIVATE virtual void setPixel_i( const basegfx::B2IPoint& rPt,
     576             :                                                Color                    lineColor,
     577             :                                                DrawMode                 drawMode ) = 0;
     578             :     BASEBMP_DLLPRIVATE virtual void setPixel_i( const basegfx::B2IPoint&     rPt,
     579             :                                                 Color                        lineColor,
     580             :                                                 DrawMode                     drawMode,
     581             :                                                 const BitmapDeviceSharedPtr& rClip ) = 0;
     582             : 
     583             :     BASEBMP_DLLPRIVATE virtual Color getPixel_i( const basegfx::B2IPoint& rPt ) = 0;
     584             : 
     585             :     BASEBMP_DLLPRIVATE virtual sal_uInt32 getPixelData_i( const basegfx::B2IPoint& rPt ) = 0;
     586             : 
     587             :     BASEBMP_DLLPRIVATE virtual void drawLine_i( const basegfx::B2IPoint& rPt1,
     588             :                                                 const basegfx::B2IPoint& rPt2,
     589             :                                                 const basegfx::B2IBox&   rBounds,
     590             :                                                 Color                    lineColor,
     591             :                                                 DrawMode                 drawMode ) = 0;
     592             :     BASEBMP_DLLPRIVATE virtual void drawLine_i( const basegfx::B2IPoint&     rPt1,
     593             :                                                 const basegfx::B2IPoint&     rPt2,
     594             :                                                 const basegfx::B2IBox&       rBounds,
     595             :                                                 Color                        lineColor,
     596             :                                                 DrawMode                     drawMode,
     597             :                                                 const BitmapDeviceSharedPtr& rClip ) = 0;
     598             : 
     599             :     BASEBMP_DLLPRIVATE virtual void drawPolygon_i( const basegfx::B2DPolygon& rPoly,
     600             :                                                    const basegfx::B2IBox&     rBounds,
     601             :                                                    Color                      lineColor,
     602             :                                                    DrawMode                   drawMode ) = 0;
     603             :     BASEBMP_DLLPRIVATE virtual void drawPolygon_i( const basegfx::B2DPolygon&   rPoly,
     604             :                                                    const basegfx::B2IBox&       rBounds,
     605             :                                                    Color                        lineColor,
     606             :                                                    DrawMode                     drawMode,
     607             :                                                    const BitmapDeviceSharedPtr& rClip ) = 0;
     608             : 
     609             :     BASEBMP_DLLPRIVATE virtual void fillPolyPolygon_i( const basegfx::B2DPolyPolygon& rPoly,
     610             :                                                        Color                          fillColor,
     611             :                                                        DrawMode                       drawMode,
     612             :                                                        const basegfx::B2IBox&         rBounds ) = 0;
     613             :     BASEBMP_DLLPRIVATE virtual void fillPolyPolygon_i( const basegfx::B2DPolyPolygon& rPoly,
     614             :                                                        Color                          fillColor,
     615             :                                                        DrawMode                       drawMode,
     616             :                                                        const basegfx::B2IBox&         rBounds,
     617             :                                                        const BitmapDeviceSharedPtr&   rClip ) = 0;
     618             : 
     619             :     // must work with *this == rSrcBitmap!
     620             :     BASEBMP_DLLPRIVATE virtual void drawBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
     621             :                                                   const basegfx::B2IBox&       rSrcRect,
     622             :                                                   const basegfx::B2IBox&       rDstRect,
     623             :                                                   DrawMode                     drawMode ) = 0;
     624             :     BASEBMP_DLLPRIVATE virtual void drawBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
     625             :                                                   const basegfx::B2IBox&       rSrcRect,
     626             :                                                   const basegfx::B2IBox&       rDstRect,
     627             :                                                   DrawMode                     drawMode,
     628             :                                                   const BitmapDeviceSharedPtr& rClip ) = 0;
     629             : 
     630             :     // must work with *this == rSrcBitmap!
     631             :     BASEBMP_DLLPRIVATE virtual void drawMaskedColor_i( Color                        rSrcColor,
     632             :                                                        const BitmapDeviceSharedPtr& rAlphaMask,
     633             :                                                        const basegfx::B2IBox&       rSrcRect,
     634             :                                                        const basegfx::B2IPoint&     rDstPoint ) = 0;
     635             :     BASEBMP_DLLPRIVATE virtual void drawMaskedColor_i( Color                        rSrcColor,
     636             :                                                        const BitmapDeviceSharedPtr& rAlphaMask,
     637             :                                                        const basegfx::B2IBox&       rSrcRect,
     638             :                                                        const basegfx::B2IPoint&     rDstPoint,
     639             :                                                        const BitmapDeviceSharedPtr& rClip ) = 0;
     640             : 
     641             :     // must work with *this == rSrcBitmap!
     642             :     BASEBMP_DLLPRIVATE virtual void drawMaskedBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
     643             :                                                         const BitmapDeviceSharedPtr& rMask,
     644             :                                                         const basegfx::B2IBox&       rSrcRect,
     645             :                                                         const basegfx::B2IBox&       rDstRect,
     646             :                                                         DrawMode                     drawMode ) = 0;
     647             :     BASEBMP_DLLPRIVATE virtual void drawMaskedBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
     648             :                                                         const BitmapDeviceSharedPtr& rMask,
     649             :                                                         const basegfx::B2IBox&       rSrcRect,
     650             :                                                         const basegfx::B2IBox&       rDstRect,
     651             :                                                         DrawMode                     drawMode,
     652             :                                                         const BitmapDeviceSharedPtr& rClip ) = 0;
     653             : 
     654             :     BASEBMP_DLLPRIVATE virtual IBitmapDeviceDamageTrackerSharedPtr getDamageTracker_i() const = 0;
     655             :     BASEBMP_DLLPRIVATE virtual void setDamageTracker_i( const IBitmapDeviceDamageTrackerSharedPtr& rDamage ) = 0;
     656             : 
     657             :     BitmapDeviceSharedPtr getGenericRenderer() const;
     658             : 
     659             :     boost::scoped_ptr< ImplBitmapDevice > mpImpl;
     660             : };
     661             : 
     662             : /** Function to create a BitmapDevice for given scanline format
     663             :  */
     664             : BitmapDeviceSharedPtr BASEBMP_DLLPUBLIC createBitmapDevice( const basegfx::B2IVector& rSize,
     665             :                                                             bool                      bTopDown,
     666             :                                                             Format                    nScanlineFormat );
     667             : 
     668             : /** Function to create a BitmapDevice for given scanline format
     669             :     with the given palette
     670             : 
     671             :     Note: the provided palette must have sufficient size, to satisfy
     672             :     lookups for the whole range of pixel values from the specified
     673             :     format.
     674             :  */
     675             : BitmapDeviceSharedPtr BASEBMP_DLLPUBLIC createBitmapDevice( const basegfx::B2IVector&        rSize,
     676             :                                                             bool                             bTopDown,
     677             :                                                             Format                           nScanlineFormat,
     678             :                                                             const PaletteMemorySharedVector& rPalette );
     679             : 
     680             : /** Function to create a BitmapDevice for given scanline format
     681             :     from the given piece of raw memory and palette
     682             : 
     683             :     Note: the provided memory must have sufficient size, to store the
     684             :     image of the specified area and format.
     685             :  */
     686             : BitmapDeviceSharedPtr BASEBMP_DLLPUBLIC createBitmapDevice( const basegfx::B2IVector&        rSize,
     687             :                                                             bool                             bTopDown,
     688             :                                                             Format                           nScanlineFormat,
     689             :                                                             const RawMemorySharedArray&      rMem,
     690             :                                                             const PaletteMemorySharedVector& rPalette );
     691             : 
     692             : 
     693             : /** Function to retrieve a subsetted BitmapDevice to the same
     694             :     memory.
     695             : 
     696             :     Note that there is no coordinate system translation or offsetting
     697             :     involved.
     698             : 
     699             :     This method creates a second bitmap device instance, which renders
     700             :     to the same memory as the original, with the same pixel coordinate
     701             :     pairs refering to the same pixels in the memory buffer, but with
     702             :     rendering clipped to a rectangular area. Useful to implement
     703             :     rectangular clips (usually faster than setting up a 1bpp clip
     704             :     mask).
     705             : 
     706             :  */
     707             : BitmapDeviceSharedPtr BASEBMP_DLLPUBLIC subsetBitmapDevice( const BitmapDeviceSharedPtr& rProto,
     708             :                                                             const basegfx::B2IBox&       rSubset );
     709             : 
     710             : /** Function to clone a BitmapDevice from a given prototype.
     711             : 
     712             :     All attributes (like scanline format and top-down state) are
     713             :     copied, only the size can be varied. Note that the prototype's
     714             :     bitmap content is <em>not</em> copied, only a palette (if any).
     715             :  */
     716             : BitmapDeviceSharedPtr BASEBMP_DLLPUBLIC cloneBitmapDevice( const basegfx::B2IVector&    rSize,
     717             :                                                            const BitmapDeviceSharedPtr& rProto );
     718             : 
     719             : }
     720             : 
     721             : #endif /* INCLUDED_BASEBMP_BITMAPDEVICE_HXX */
     722             : 
     723             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10