bitmapex.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_VCL_BITMAPEX_HXX
#define INCLUDED_VCL_BITMAPEX_HXX
 
#include <vcl/dllapi.h>
#include <vcl/alpha.hxx>
#include <vcl/Scanline.hxx>
#include <tools/color.hxx>
#include <tools/degree.hxx>
 
#include <sal/types.h>
 
namespace com::sun::star::rendering {
    class XBitmapCanvas;
}
namespace com::sun::star::uno { template <class interface_type> class Reference; }
namespace basegfx { class BColorModifierStack; }
 
class SAL_WARN_UNUSED VCL_DLLPUBLIC BitmapEx
{
public:
 
                        BitmapEx();
    explicit            BitmapEx( const OUString& rIconName );
                        BitmapEx( const BitmapEx& rBitmapEx );
                        BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize );
                        BitmapEx(Size aSize, vcl::PixelFormat ePixelFormat);
    explicit            BitmapEx( const Bitmap& rBmp );
                        BitmapEx( const Bitmap& rBmp, const Bitmap& rMask );
                        BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask );
                        BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor );
 
    BitmapEx&           operator=( const BitmapEx& rBitmapEx );
    BitmapEx&           operator=( const Bitmap& rBitmap ) { return operator=(BitmapEx(rBitmap)); }
    bool                operator==( const BitmapEx& rBitmapEx ) const;
    bool                operator!=( const BitmapEx& rBitmapEx ) const { return !(*this==rBitmapEx); }
 
    bool                IsEmpty() const;
    void                SetEmpty();
    void                Clear();
    void                ClearAlpha();
 
    void                Draw( OutputDevice* pOutDev,
                              const Point& rDestPt ) const;
    void                Draw( OutputDevice* pOutDev,
                              const Point& rDestPt, const Size& rDestSize ) const;
 
    Bitmap              GetBitmap( Color aTransparentReplaceColor ) const;
    const Bitmap&       GetBitmap() const;
 
    bool                IsAlpha() const;
    const AlphaMask &   GetAlphaMask() const { return maAlphaMask; }
 
    const Size&         GetSizePixel() const { return maBitmapSize; }
    void                SetSizePixel(const Size& rNewSize);
 
    const Size&         GetPrefSize() const { return maBitmap.GetPrefSize(); }
    void                SetPrefSize( const Size& rPrefSize ) { maBitmap.SetPrefSize( rPrefSize ); }
 
    const MapMode&      GetPrefMapMode() const { return maBitmap.GetPrefMapMode(); }
    void                SetPrefMapMode( const MapMode& rPrefMapMode ) { maBitmap.SetPrefMapMode( rPrefMapMode ); }
 
    vcl::PixelFormat getPixelFormat() const
    {
        return maBitmap.getPixelFormat();
    }
 
    sal_Int64           GetSizeBytes() const;
    BitmapChecksum      GetChecksum() const;
 
    bool                Convert( BmpConversion eConversion );
 
    bool                Crop( const tools::Rectangle& rRectPixel );
 
    void                Expand(
                            sal_Int32 nDX, sal_Int32 nDY,
                            bool bExpandTransparent = false );
 
    bool                CopyPixel(
                            const tools::Rectangle& rRectDst,
                            const tools::Rectangle& rRectSrc,
                            const BitmapEx* pBmpExSrc );
 
    bool                Erase( const Color& rFillColor );
 
    bool                Invert();
 
    bool                Mirror( BmpMirrorFlags nMirrorFlags );
 
    bool                Scale(
                            const Size& rNewSize,
                            BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );
 
    bool                Scale(
                            const double& rScaleX,
                            const double& rScaleY,
                            BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );
 
    bool                Rotate(
                            Degree10 nAngle10,
                            const Color& rFillColor );
 
    void                Replace(
                            const Color& rSearchColor,
                            const Color& rReplaceColor );
 
    void                Replace(
                            const Color& rSearchColor,
                            const Color& rReplaceColor,
                            sal_uInt8 nTolerance );
 
    void                Replace(
                            const Color* pSearchColors,
                            const Color* pReplaceColors,
                            size_t nColorCount );
 
    void                Replace(
                            const Color* pSearchColors,
                            const Color* pReplaceColors,
                            size_t nColorCount,
                            sal_uInt8 const * pTols );
 
    void                ReplaceTransparency( const Color& rColor );
 
    tools::Polygon      GetContour( bool bContourEdgeDetect, const tools::Rectangle* pWorkRect );
 
    bool                Adjust(
                            short nLuminancePercent,
                            short nContrastPercent,
                            short nChannelRPercent,
                            short nChannelGPercent,
                            short nChannelBPercent,
                            double fGamma = 1.0,
                            bool bInvert = false,
                            bool msoBrightness = false );
 
    sal_uInt8           GetAlpha(
                            sal_Int32 nX,
                            sal_Int32 nY) const;
 
    ::Color             GetPixelColor(
                            sal_Int32 nX,
                            sal_Int32 nY) const;
 
    [[nodiscard]]
    BitmapEx            TransformBitmapEx(
                            double fWidth,
                            double fHeight,
                            const basegfx::B2DHomMatrix& rTransformation) const;
 
    [[nodiscard]]
    BitmapEx            getTransformed(
                            const basegfx::B2DHomMatrix& rTransformation,
                            const basegfx::B2DRange& rVisibleRange,
                            double fMaximumArea) const;
 
    [[nodiscard]]
    BitmapEx            ModifyBitmapEx( const basegfx::BColorModifierStack& rBColorModifierStack) const;
 
    [[nodiscard]]
    static BitmapEx     AutoScaleBitmap( BitmapEx const & aBitmap, const tools::Long aStandardSize );
 
    bool                Create(
                            const css::uno::Reference< css::rendering::XBitmapCanvas > &xBitmapCanvas,
                            const Size &rSize );
 
    void                ChangeColorAlpha( sal_uInt8 cIndexFrom, sal_Int8 nAlphaTo );
 
    void                AdjustTransparency( sal_uInt8 cTrans );
 
    void                CombineMaskOr(Color maskColor, sal_uInt8 nTol);
 
    void                GetColorModel(css::uno::Sequence< sal_Int32 >& rRGBPalette,
                            sal_uInt32& rnRedMask, sal_uInt32& rnGreenMask, sal_uInt32& rnBlueMask, sal_uInt32& rnAlphaMask, sal_uInt32& rnTransparencyIndex,
                            sal_uInt32& rnWidth, sal_uInt32& rnHeight, sal_uInt8& rnBitCount);
 
    SAL_DLLPRIVATE std::shared_ptr<SalBitmap> const & ImplGetBitmapSalBitmap() const { return maBitmap.ImplGetSalBitmap(); }
 
    void DumpAsPng(const char* pFileName = nullptr) const;
 
private:
    friend class ImpGraphic;
    friend class OutputDevice;
    friend bool VCL_DLLPUBLIC WriteDIBBitmapEx(const BitmapEx& rSource, SvStream& rOStm);
    friend bool VCL_DLLPUBLIC ReadRawDIB(BitmapEx& rTarget, const unsigned char* pBuf,
                                    const ScanlineFormat nFormat,
                                    const int nHeight,
                                    const int nStride);
 
    void  loadFromIconTheme( const OUString& rIconName );
 
    Bitmap              maBitmap;
    AlphaMask           maAlphaMask;
    Size                maBitmapSize;
};
 
 
BitmapEx VCL_DLLPUBLIC createBlendFrame(
    const Size& rSize,
    sal_uInt8 nAlpha,
    Color aColorTopLeft,
    Color aColorBottomRight);
 
 
BitmapEx createBlendFrame(
    const Size& rSize,
    sal_uInt8 nAlpha,
    Color aColorTopLeft,
    Color aColorTopRight,
    Color aColorBottomRight,
    Color aColorBottomLeft);
 
#endif // INCLUDED_VCL_BITMAPEX_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */