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; }

enum class TransparentType
{
    NONE = 0,
    // Color = 1, Never actually used in BitmapEx, only present for backwards compat with existing SVM files
    Bitmap = 2
};

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                Draw( OutputDevice* pOutDev,
                              const Point& rDestPt ) const;
    void                Draw( OutputDevice* pOutDev,
                              const Point& rDestPt, const Size& rDestSize ) const;

    bool                IsTransparent() const;
    TransparentType     GetTransparentType() const { return meTransparent; }

    Bitmap              GetBitmap( Color aTransparentReplaceColor ) const;
    const Bitmap&       GetBitmap() const;
    Bitmap              GetMask() const;

    bool                IsAlpha() const;
    AlphaMask           GetAlpha() const;

    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_uLong           GetSizeBytes() const;
    BitmapChecksum      GetChecksum() const;

    bool                Convert( BmpConversion eConversion );

    bool                Crop( const tools::Rectangle& rRectPixel );

    void                Expand(
                            sal_uLong nDX, sal_uLong 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                setAlphaFrom( 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(); }
    SAL_DLLPRIVATE std::shared_ptr<SalBitmap> const & ImplGetMaskSalBitmap() const { return maMask.ImplGetSalBitmap(); }


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;
    Bitmap              maMask;
    Size                maBitmapSize;
    TransparentType     meTransparent;
    bool                mbAlpha;

};


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: */