bcolormodifier.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 .
 */
 
#pragma once
 
#include <config_options.h>
#include <basegfx/basegfxdllapi.h>
#include <basegfx/matrix/b3dhommatrix.hxx>
#include <basegfx/color/bcolor.hxx>
#include <rtl/ustring.hxx>
 
#include <osl/diagnose.h>
 
#include <memory>
#include <vector>
 
namespace basegfx
{
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier
    {
    private:
        BColorModifier(const BColorModifier&) = delete;
        BColorModifier& operator=(const BColorModifier&) = delete;
    protected:
        // no one is allowed to incarnate the abstract base class
        // except derivations
        BColorModifier() {}
 
    public:
        // no one should directly destroy it; all incarnations should be
        // handled in a std::shared_ptr of type BColorModifierSharedPtr
        virtual ~BColorModifier();
 
        // compare operator
        virtual bool operator==(const BColorModifier& rCompare) const = 0;
        bool operator!=(const BColorModifier& rCompare) const
        {
            return !(operator==(rCompare));
        }
 
        // compute modified color
        virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const = 0;
 
        virtual OUString getModifierName() const = 0;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_gray final : public BColorModifier
    {
    public:
        BColorModifier_gray()
        {
        }
 
        virtual ~BColorModifier_gray() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_invert final : public BColorModifier
    {
    public:
        BColorModifier_invert()
        {
        }
 
        virtual ~BColorModifier_invert() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_luminance_to_alpha final : public BColorModifier
    {
    public:
        BColorModifier_luminance_to_alpha()
        {
        }
 
        virtual ~BColorModifier_luminance_to_alpha() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_replace final : public BColorModifier
    {
    private:
        ::basegfx::BColor           maBColor;
 
    public:
        BColorModifier_replace(const ::basegfx::BColor& rBColor)
        :   maBColor(rBColor)
        {
        }
 
        virtual ~BColorModifier_replace() override;
 
        // data access
        const ::basegfx::BColor& getBColor() const { return maBColor; }
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_interpolate final : public BColorModifier
    {
    private:
        ::basegfx::BColor           maBColor;
        double                      mfValue;
 
    public:
        BColorModifier_interpolate(const ::basegfx::BColor& rBColor, double fValue)
        :   maBColor(rBColor),
            mfValue(fValue)
        {
        }
 
        virtual ~BColorModifier_interpolate() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_saturate final : public BColorModifier
    {
    private:
        basegfx::B3DHomMatrix       maSatMatrix;
 
    public:
        BColorModifier_saturate(double fValue);
 
        virtual ~BColorModifier_saturate() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_matrix final : public BColorModifier
    {
    private:
        std::vector<double>       maVector;
 
    public:
        BColorModifier_matrix(std::vector<double> aVector)
        :   maVector(aVector)
        {
        }
 
        virtual ~BColorModifier_matrix() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_hueRotate final : public BColorModifier
    {
    private:
        basegfx::B3DHomMatrix       maHueMatrix;
 
    public:
        BColorModifier_hueRotate(double fRad);
 
        virtual ~BColorModifier_hueRotate() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_black_and_white final : public BColorModifier
    {
    private:
        double                      mfValue;
 
    public:
        BColorModifier_black_and_white(double fValue)
        :   mfValue(fValue)
        {
        }
 
        virtual ~BColorModifier_black_and_white() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED UNLESS_MERGELIBS(BASEGFX_DLLPUBLIC) BColorModifier_gamma final : public BColorModifier
    {
    private:
        double                      mfValue;
        double                      mfInvValue;
 
        bool                        mbUseIt : 1;
 
    public:
        BColorModifier_gamma(double fValue);
 
        virtual ~BColorModifier_gamma() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED UNLESS_MERGELIBS(BASEGFX_DLLPUBLIC) BColorModifier_RGBLuminanceContrast final : public BColorModifier
    {
    private:
        double                      mfRed;
        double                      mfGreen;
        double                      mfBlue;
        double                      mfLuminance;
        double                      mfContrast;
 
        double                      mfContrastOff;
        double                      mfRedOff;
        double                      mfGreenOff;
        double                      mfBlueOff;
 
        bool                        mbUseIt : 1;
 
    public:
        BColorModifier_RGBLuminanceContrast(double fRed, double fGreen, double fBlue, double fLuminance, double fContrast);
 
        virtual ~BColorModifier_RGBLuminanceContrast() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC BColorModifier_randomize final : public BColorModifier
    {
    private:
        // [0.0 .. 1.0] where 0.0 is no randomize, 1.0 is all random and in-between
        // describes the mixed part. Default is 0.1 which means to mix with 10% random color
        double                      mfRandomPart;
 
    public:
        BColorModifier_randomize(double fRandomPart = 0.1);
 
        virtual ~BColorModifier_randomize() override;
 
        // compare operator
        SAL_DLLPRIVATE virtual bool operator==(const BColorModifier& rCompare) const override;
 
        // compute modified color
        SAL_DLLPRIVATE virtual ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& aSourceColor) const override;
        SAL_DLLPRIVATE virtual OUString getModifierName() const override;
    };
 
    typedef std::shared_ptr< BColorModifier > BColorModifierSharedPtr;
 
    class BASEGFX_DLLPUBLIC BColorModifierStack final
    {
        ::std::vector< BColorModifierSharedPtr >        maBColorModifiers;
 
    public:
        sal_uInt32 count() const
        {
            return maBColorModifiers.size();
        }
 
        const BColorModifierSharedPtr& getBColorModifier(sal_uInt32 nIndex) const
        {
            OSL_ENSURE(nIndex < count(), "BColorModifierStack: Access out of range (!)");
            return maBColorModifiers[nIndex];
        }
 
        // get the color in its modified form by applying all existing BColorModifiers,
        // from back to front (the newest first)
        ::basegfx::BColor getModifiedColor(const ::basegfx::BColor& rSource) const;
 
        void push(const BColorModifierSharedPtr& rNew)
        {
            maBColorModifiers.push_back(rNew);
        }
 
        void pop()
        {
            maBColorModifiers.pop_back();
        }
    };
} // end of namespace basegfx
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */