LegendSpecs.hpp

// sciplot - a modern C++ scientific plotting library powered by gnuplot
// https://github.com/sciplot/sciplot
//
// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
//
// Copyright (c) 2018-2021 Allan Leal
//
// 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.
 
#pragma once
 
// sciplot includes
#include <sciplot/Default.hpp>
#include <sciplot/specs/FrameSpecsOf.hpp>
#include <sciplot/specs/ShowSpecsOf.hpp>
#include <sciplot/specs/TextSpecsOf.hpp>
#include <sciplot/specs/TitleSpecsOf.hpp>
#include <sciplot/Utils.hpp>
 
namespace sciplot {
 
class LegendSpecs : public TextSpecsOf<LegendSpecs>, public ShowSpecsOf<LegendSpecs>, public TitleSpecsOf<LegendSpecs>, public FrameSpecsOf<LegendSpecs>
{
  public:
    LegendSpecs();
 
    auto opaque() -> LegendSpecs&;
 
    auto transparent() -> LegendSpecs&;
 
    auto atLeft() -> LegendSpecs&;
 
    auto atRight() -> LegendSpecs&;
 
    auto atCenter() -> LegendSpecs&;
 
    auto atTop() -> LegendSpecs&;
 
    auto atTopLeft() -> LegendSpecs&;
 
    auto atTopRight() -> LegendSpecs&;
 
    auto atBottom() -> LegendSpecs&;
 
    auto atBottomLeft() -> LegendSpecs&;
 
    auto atBottomRight() -> LegendSpecs&;
 
    auto atOutsideLeft() -> LegendSpecs&;
 
    auto atOutsideLeftTop() -> LegendSpecs&;
 
    auto atOutsideLeftBottom() -> LegendSpecs&;
 
    auto atOutsideRight() -> LegendSpecs&;
 
    auto atOutsideRightTop() -> LegendSpecs&;
 
    auto atOutsideRightBottom() -> LegendSpecs&;
 
    auto atOutsideBottom() -> LegendSpecs&;
 
    auto atOutsideBottomLeft() -> LegendSpecs&;
 
    auto atOutsideBottomRight() -> LegendSpecs&;
 
    auto atOutsideTop() -> LegendSpecs&;
 
    auto atOutsideTopLeft() -> LegendSpecs&;
 
    auto atOutsideTopRight() -> LegendSpecs&;
 
    auto titleLeft() -> LegendSpecs&;
 
    auto titleCenter() -> LegendSpecs&;
 
    auto titleRight() -> LegendSpecs&;
 
    auto displayVertical() -> LegendSpecs&;
 
    auto displayVerticalMaxRows(int value) -> LegendSpecs&;
 
    auto displayHorizontal() -> LegendSpecs&;
 
    auto displayHorizontalMaxCols(int value) -> LegendSpecs&;
 
    auto displayLabelsBeforeSymbols() -> LegendSpecs&;
 
    auto displayLabelsAfterSymbols() -> LegendSpecs&;
 
    auto displayJustifyLeft() -> LegendSpecs&;
 
    auto displayJustifyRight() -> LegendSpecs&;
 
    auto displayStartFromFirst() -> LegendSpecs&;
 
    auto displayStartFromLast() -> LegendSpecs&;
 
    auto displaySpacing(int value) -> LegendSpecs&;
 
    auto displayExpandWidthBy(int value) -> LegendSpecs&;
 
    auto displayExpandHeightBy(int value) -> LegendSpecs&;
 
    auto displaySymbolLength(int value) -> LegendSpecs&;
 
    auto repr() const -> std::string;
 
  private:
    std::string m_placement;
 
    std::string m_opaque;
 
    std::string m_alignment;
 
    std::string m_reverse;
 
    std::string m_invert;
 
    std::string m_justification;
 
    std::string m_title_loc = "left";
 
    int m_width_increment;
 
    int m_height_increment;
 
    int m_samplen;
 
    int m_spacing;
 
    std::string m_maxrows = "auto";
 
    std::string m_maxcols = "auto";
};
 
inline LegendSpecs::LegendSpecs()
{
    atTopRight();
    title("");
    displayExpandWidthBy(internal::DEFAULT_LEGEND_FRAME_EXTRA_WIDTH);
    displayExpandHeightBy(internal::DEFAULT_LEGEND_FRAME_EXTRA_HEIGHT);
    displaySymbolLength(internal::DEFAULT_LEGEND_SAMPLE_LENGTH);
    displaySpacing(internal::DEFAULT_LEGEND_SPACING);
    displayVertical();
    displayLabelsAfterSymbols();
    displayJustifyLeft();
    displayStartFromFirst();
    opaque();
}
 
inline auto LegendSpecs::opaque() -> LegendSpecs&
{
    m_opaque = "opaque";
    return *this;
}
 
inline auto LegendSpecs::transparent() -> LegendSpecs&
{
    m_opaque = "noopaque";
    return *this;
}
 
inline auto LegendSpecs::atLeft() -> LegendSpecs&
{
    m_placement = "inside left";
    return *this;
}
 
inline auto LegendSpecs::atRight() -> LegendSpecs&
{
    m_placement = "inside right";
    return *this;
}
 
inline auto LegendSpecs::atCenter() -> LegendSpecs&
{
    m_placement = "inside center";
    return *this;
}
 
inline auto LegendSpecs::atTop() -> LegendSpecs&
{
    m_placement = "inside center top";
    return *this;
}
 
inline auto LegendSpecs::atTopLeft() -> LegendSpecs&
{
    m_placement = "inside left top";
    return *this;
}
 
inline auto LegendSpecs::atTopRight() -> LegendSpecs&
{
    m_placement = "inside right top";
    return *this;
}
 
inline auto LegendSpecs::atBottom() -> LegendSpecs&
{
    m_placement = "inside center bottom";
    return *this;
}
 
inline auto LegendSpecs::atBottomLeft() -> LegendSpecs&
{
    m_placement = "inside left bottom";
    return *this;
}
 
inline auto LegendSpecs::atBottomRight() -> LegendSpecs&
{
    m_placement = "inside right bottom";
    return *this;
}
 
inline auto LegendSpecs::atOutsideLeft() -> LegendSpecs&
{
    m_placement = "lmargin center";
    return *this;
}
 
inline auto LegendSpecs::atOutsideLeftTop() -> LegendSpecs&
{
    m_placement = "lmargin top";
    return *this;
}
 
inline auto LegendSpecs::atOutsideLeftBottom() -> LegendSpecs&
{
    m_placement = "lmargin bottom";
    return *this;
}
 
inline auto LegendSpecs::atOutsideRight() -> LegendSpecs&
{
    m_placement = "rmargin center";
    return *this;
}
 
inline auto LegendSpecs::atOutsideRightTop() -> LegendSpecs&
{
    m_placement = "rmargin top";
    return *this;
}
 
inline auto LegendSpecs::atOutsideRightBottom() -> LegendSpecs&
{
    m_placement = "rmargin bottom";
    return *this;
}
 
inline auto LegendSpecs::atOutsideBottom() -> LegendSpecs&
{
    m_placement = "bmargin center";
    return *this;
}
 
inline auto LegendSpecs::atOutsideBottomLeft() -> LegendSpecs&
{
    m_placement = "bmargin left";
    return *this;
}
 
inline auto LegendSpecs::atOutsideBottomRight() -> LegendSpecs&
{
    m_placement = "bmargin right";
    return *this;
}
 
inline auto LegendSpecs::atOutsideTop() -> LegendSpecs&
{
    m_placement = "tmargin center";
    return *this;
}
 
inline auto LegendSpecs::atOutsideTopLeft() -> LegendSpecs&
{
    m_placement = "tmargin left";
    return *this;
}
 
inline auto LegendSpecs::atOutsideTopRight() -> LegendSpecs&
{
    m_placement = "tmargin right";
    return *this;
}
 
inline auto LegendSpecs::titleLeft() -> LegendSpecs&
{
    m_title_loc = "left";
    return *this;
}
 
inline auto LegendSpecs::titleCenter() -> LegendSpecs&
{
    m_title_loc = "center";
    return *this;
}
 
inline auto LegendSpecs::titleRight() -> LegendSpecs&
{
    m_title_loc = "right";
    return *this;
}
 
inline auto LegendSpecs::displayVertical() -> LegendSpecs&
{
    m_alignment = "vertical";
    return *this;
}
 
inline auto LegendSpecs::displayVerticalMaxRows(int value) -> LegendSpecs&
{
    m_maxrows = internal::str(value);
    return *this;
}
 
inline auto LegendSpecs::displayHorizontal() -> LegendSpecs&
{
    m_alignment = "horizontal";
    return *this;
}
 
inline auto LegendSpecs::displayHorizontalMaxCols(int value) -> LegendSpecs&
{
    m_maxcols = internal::str(value);
    return *this;
}
 
inline auto LegendSpecs::displayLabelsBeforeSymbols() -> LegendSpecs&
{
    m_reverse = "noreverse";
    return *this;
}
 
inline auto LegendSpecs::displayLabelsAfterSymbols() -> LegendSpecs&
{
    m_reverse = "reverse";
    return *this;
}
 
inline auto LegendSpecs::displayJustifyLeft() -> LegendSpecs&
{
    m_justification = "Left";
    return *this;
}
 
inline auto LegendSpecs::displayJustifyRight() -> LegendSpecs&
{
    m_justification = "Right";
    return *this;
}
 
inline auto LegendSpecs::displayStartFromFirst() -> LegendSpecs&
{
    m_invert = "noinvert";
    return *this;
}
 
inline auto LegendSpecs::displayStartFromLast() -> LegendSpecs&
{
    m_invert = "invert";
    return *this;
}
 
inline auto LegendSpecs::displaySpacing(int value) -> LegendSpecs&
{
    m_spacing = value;
    return *this;
}
 
inline auto LegendSpecs::displayExpandWidthBy(int value) -> LegendSpecs&
{
    m_width_increment = value;
    return *this;
}
 
inline auto LegendSpecs::displayExpandHeightBy(int value) -> LegendSpecs&
{
    m_height_increment = value;
    return *this;
}
 
inline auto LegendSpecs::displaySymbolLength(int value) -> LegendSpecs&
{
    m_samplen = value;
    return *this;
}
 
inline auto LegendSpecs::repr() const -> std::string
{
    const auto show = ShowSpecsOf<LegendSpecs>::repr();
    if(show == "no")
        return "unset key";
 
    auto titlespecs = TitleSpecsOf<LegendSpecs>::repr();
    if(titlespecs.size())
        titlespecs += " " + m_title_loc; // attach left|center|right to title (e.g. title 'Legend' right)
 
    std::stringstream ss;
    ss << "set key ";
    ss << m_placement << " " << m_opaque << " ";
    ss << m_alignment << " ";
    ss << m_justification << " ";
    ss << m_invert << " ";
    ss << m_reverse << " ";
    ss << "width " << m_width_increment << " ";
    ss << "height " << m_height_increment << " ";
    ss << "samplen " << m_samplen << " ";
    ss << "spacing " << m_spacing << " ";
    ss << TextSpecsOf<LegendSpecs>::repr() << " ";
    ss << titlespecs << " ";
    ss << FrameSpecsOf<LegendSpecs>::repr() << " ";
    ss << "maxrows " << m_maxrows << " ";
    ss << "maxcols " << m_maxcols << " ";
    return internal::removeExtraWhitespaces(ss.str());
}
 
} // namespace sciplot