XLSheetBase.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLSHEETBASE_HPP
#define OPENXLSX_XLSHEETBASE_HPP
 
#include "OpenXLSX-Exports.hpp"
#include "XLColor.hpp"
#include "XLCommandQuery.hpp"
#include "XLDocument.hpp"
#include "XLXmlFile.hpp"
#include <cstdint>
#include <mutex>
#include <shared_mutex>
#include <string>
#include <type_traits>
 
namespace OpenXLSX
{
    class XLWorksheet;
    class XLChartsheet;
 
    constexpr const bool XLEmptyHiddenCells = true;    // readability constant for XLWorksheet::mergeCells parameter emptyHiddenCells
 
    enum class XLSheetState : uint8_t { Visible, Hidden, VeryHidden };
 
    enum class XLPaneState : uint8_t { Split, Frozen, FrozenSplit };
 
    enum class XLPane : uint8_t { BottomRight, TopRight, BottomLeft, TopLeft };
 
    OPENXLSX_EXPORT std::string XLPaneStateToString(XLPaneState state);
    OPENXLSX_EXPORT XLPaneState XLPaneStateFromString(std::string const& stateString);
    OPENXLSX_EXPORT std::string XLPaneToString(XLPane pane);
    OPENXLSX_EXPORT XLPane      XLPaneFromString(std::string const& paneString);
 
    OPENXLSX_EXPORT void setTabColor(const XMLDocument& xmlDocument, const XLColor& color);
    OPENXLSX_EXPORT void setTabSelected(const XMLDocument& xmlDocument, bool selected);
    OPENXLSX_EXPORT bool tabIsSelected(const XMLDocument& xmlDocument);
 
    template<typename T, typename = std::enable_if_t<std::is_same_v<T, XLWorksheet> or std::is_same_v<T, XLChartsheet>>>
    class OPENXLSX_EXPORT XLSheetBase : public XLXmlFile
    {
    public:
        XLSheetBase() : XLXmlFile(nullptr) {};
 
        explicit XLSheetBase(XLXmlData* xmlData) : XLXmlFile(xmlData) {}
 
        XLSheetBase(const XLSheetBase& other) = default;
 
        XLSheetBase(XLSheetBase&& other) noexcept = default;
 
        ~XLSheetBase() = default;
 
        XLSheetBase& operator=(const XLSheetBase&) = default;
 
        XLSheetBase& operator=(XLSheetBase&& other) noexcept = default;
 
        XLSheetState visibility() const
        {
            XLQuery query(XLQueryType::QuerySheetVisibility);
            query.setParam("sheetID", relationshipID());
            const auto state  = parentDoc().execQuery(query).template result<std::string>();
            auto       result = XLSheetState::Visible;
 
            if (state == "visible" or state.empty()) { result = XLSheetState::Visible; }
            else if (state == "hidden") {
                result = XLSheetState::Hidden;
            }
            else if (state == "veryHidden") {
                result = XLSheetState::VeryHidden;
            }
 
            return result;
        }
 
        void setVisibility(XLSheetState state)
        {
            std::unique_lock<std::shared_mutex> lock(parentDoc().mutex());
            auto                                stateString = std::string();
            switch (state) {
                case XLSheetState::Visible:
                    stateString = "visible";
                    break;
 
                case XLSheetState::Hidden:
                    stateString = "hidden";
                    break;
 
                case XLSheetState::VeryHidden:
                    stateString = "veryHidden";
                    break;
            }
 
            parentDoc().execCommand(XLCommand(XLCommandType::SetSheetVisibility)
                                        .setParam("sheetID", relationshipID())
                                        .setParam("sheetVisibility", stateString));
        }
 
        XLColor color() const { return static_cast<const T&>(*this).getColor_impl(); }
 
        void setColor(const XLColor& color) { static_cast<T&>(*this).setColor_impl(color); }
 
        uint16_t index() const
        {
            XLQuery query(XLQueryType::QuerySheetIndex);
            query.setParam("sheetID", relationshipID());
            return static_cast<uint16_t>(std::stoi(parentDoc().execQuery(query).template result<std::string>()));
        }
 
        void setIndex(uint16_t index)
        {
            std::unique_lock<std::shared_mutex> lock(parentDoc().mutex());
            parentDoc().execCommand(
                XLCommand(XLCommandType::SetSheetIndex).setParam("sheetID", relationshipID()).setParam("sheetIndex", index));
        }
 
        std::string name() const
        {
            XLQuery query(XLQueryType::QuerySheetName);
            query.setParam("sheetID", relationshipID());
            return parentDoc().execQuery(query).template result<std::string>();
        }
 
        void setName(const std::string& sheetName)
        {
            std::unique_lock<std::shared_mutex> lock(parentDoc().mutex());
            parentDoc().execCommand(XLCommand(XLCommandType::SetSheetName)
                                        .setParam("sheetID", relationshipID())
                                        .setParam("sheetName", name())
                                        .setParam("newName", sheetName));
        }
 
        bool isSelected() const { return static_cast<const T&>(*this).isSelected_impl(); }
 
        void setSelected(bool selected) { static_cast<T&>(*this).setSelected_impl(selected); }
 
        bool isActive() const { return static_cast<const T&>(*this).isActive_impl(); }
 
        bool setActive() { return static_cast<T&>(*this).setActive_impl(); }
 
        void clone(const std::string& newName)
        {
            parentDoc().execCommand(
                XLCommand(XLCommandType::CloneSheet).setParam("sheetID", relationshipID()).setParam("cloneName", newName));
        }
 
    private:    // ---------- Private Member Variables ---------- //
    };
}    // namespace OpenXLSX
 
#endif