table.hpp

Go to the documentation of this file.

#pragma once

 
#if (defined(_MSVC_LANG) ? _MSVC_LANG : __cplusplus) < 201703L
#error \
    "OpenPine C++ wrapper headers require C++17 (std::optional, std::string_view)."
#endif
 
#include <cstdint>
#include <optional>
#include <string_view>
 
#include "../ffi.hpp"
#include "../string_ref.hpp"
#include "../types.hpp"
 
namespace openpine {
namespace graph {
 
class TableCell {
 private:
  const ffi::TableCell* p_;
 
 public:
  TableCell(const ffi::TableCell* p) : p_(p) {}

  std::string_view text() const {
    ffi::PineStringRef ref;
    ffi::tableCellText(p_, &ref);
    return detail::refToView(ref);
  }

  float width() const { return ffi::tableCellWidth(p_); }

  float height() const { return ffi::tableCellHeight(p_); }

  std::optional<uint32_t> textColor() const {
    uint32_t v;
    if (ffi::tableCellTextColor(p_, &v)) {
      return v;
    } else {
      return std::nullopt;
    }
  }

  HorizontalAlign textHalign() const { return ffi::tableCellTextHalign(p_); }

  VerticalAlign textValign() const { return ffi::tableCellTextValign(p_); }

  uint32_t textSize() const { return ffi::tableCellTextSize(p_); }

  std::optional<uint32_t> backgroundColor() const {
    uint32_t v;
    if (ffi::tableCellBackgroundColor(p_, &v)) {
      return v;
    } else {
      return std::nullopt;
    }
  }

  std::optional<std::string_view> tooltip() const {
    ffi::PineStringRef ref;
    if (ffi::tableCellTooltip(p_, &ref)) {
      return detail::refToView(ref);
    } else {
      return std::nullopt;
    }
  }

  FontFamily textFontFamily() const { return ffi::tableCellTextFontFamily(p_); }

  TextFormatting textFormatting() const {
    return ffi::tableCellTextFormatting(p_);
  }

  uintptr_t colspan() const { return ffi::tableCellColspan(p_); }

  uintptr_t rowspan() const { return ffi::tableCellRowspan(p_); }
};

class Table {
 private:
  const ffi::Table* p_;
 
 public:
  Table(const ffi::Table* p) : p_(p) {}

  TablePosition position() const { return ffi::tablePosition(p_); }

  uintptr_t numColumns() const { return ffi::tableNumColumns(p_); }

  uintptr_t numRows() const { return ffi::tableNumRows(p_); }

  std::optional<uint32_t> backgroundColor() const {
    uint32_t v;
    if (ffi::tableBackgroundColor(p_, &v)) {
      return v;
    } else {
      return std::nullopt;
    }
  }

  std::optional<uint32_t> frameColor() const {
    uint32_t v;
    if (ffi::tableFrameColor(p_, &v)) {
      return v;
    } else {
      return std::nullopt;
    }
  }

  int32_t frameWidth() const { return ffi::tableFrameWidth(p_); }

  std::optional<uint32_t> borderColor() const {
    uint32_t v;
    if (ffi::tableBorderColor(p_, &v)) {
      return v;
    } else {
      return std::nullopt;
    }
  }

  int32_t borderWidth() const { return ffi::tableBorderWidth(p_); }

  bool forceOverlay() const { return ffi::tableForceOverlay(p_); }

  std::optional<TableCell> cell(uintptr_t row, uintptr_t col) const {
    const ffi::TableCell* c = ffi::tableCell(p_, row, col);
    if (c) {
      return TableCell(c);
    } else {
      return std::nullopt;
    }
  }
};
 
}  // namespace graph
}  // namespace openpine