fill.hpp

// Copyright (c) 2014-2022 Thomas Fussell
// Copyright (c) 2010-2015 openpyxl
// Copyright (c) 2024 xlnt-community
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
//
// @license: http://www.opensource.org/licenses/mit-license.php
// @author: see AUTHORS file

#pragma once

#include <unordered_map>

#include <xlnt/xlnt_config.hpp>
#include <xlnt/styles/color.hpp>
#include <xlnt/utils/optional.hpp>

namespace xlnt {

enum class XLNT_API pattern_fill_type
{
    none,
    solid,
    mediumgray,
    darkgray,
    lightgray,
    darkhorizontal,
    darkvertical,
    darkdown,
    darkup,
    darkgrid,
    darktrellis,
    lighthorizontal,
    lightvertical,
    lightdown,
    lightup,
    lightgrid,
    lighttrellis,
    gray125,
    gray0625
};

class XLNT_API pattern_fill
{
public:
    pattern_fill();

    pattern_fill_type type() const;

    pattern_fill &type(pattern_fill_type new_type);

    optional<color> foreground() const;

    pattern_fill &foreground(const color &foreground);

    optional<color> background() const;

    pattern_fill &background(const color &background);

    bool operator==(const pattern_fill &other) const;

    bool operator!=(const pattern_fill &other) const;

private:
    pattern_fill_type type_ = pattern_fill_type::none;

    optional<color> foreground_;

    optional<color> background_;
};

enum class XLNT_API gradient_fill_type
{
    linear,
    path
};

class XLNT_API gradient_fill
{
public:
    gradient_fill();

    gradient_fill_type type() const;

    // Type

    gradient_fill &type(gradient_fill_type new_type);

    // Degree

    gradient_fill &degree(double degree);

    double degree() const;

    // Left

    double left() const;

    gradient_fill &left(double value);

    // Right

    double right() const;

    gradient_fill &right(double value);

    // Top

    double top() const;

    gradient_fill &top(double value);

    // Bottom

    double bottom() const;

    gradient_fill &bottom(double value);

    // Stops

    gradient_fill &add_stop(double position, color stop_color);

    gradient_fill &clear_stops();

    std::unordered_map<double, color> stops() const;

    bool operator==(const gradient_fill &other) const;

    bool operator!=(const gradient_fill &right) const;

private:
    gradient_fill_type type_ = gradient_fill_type::linear;

    double degree_ = 0;

    double left_ = 0;

    double right_ = 0;

    double top_ = 0;

    double bottom_ = 0;

    std::unordered_map<double, color> stops_;
};

enum class XLNT_API fill_type
{
    pattern,
    gradient
};

class XLNT_API fill
{
public:
    static fill solid(const color &fill_color);

    fill();

    fill(const pattern_fill &pattern);

    fill(const gradient_fill &gradient);

    fill_type type() const;

    class gradient_fill gradient_fill() const;

    class pattern_fill pattern_fill() const;

    bool operator==(const fill &other) const;

    bool operator!=(const fill &other) const;

private:
    fill_type type_ = fill_type::pattern;

    xlnt::gradient_fill gradient_;

    xlnt::pattern_fill pattern_;
};

} // namespace xlnt