You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1366 lines
35 KiB
C++
1366 lines
35 KiB
C++
#ifndef __NCPP_PLANE_HH
|
|
#define __NCPP_PLANE_HH
|
|
|
|
#include <exception>
|
|
#include <cstdarg>
|
|
#include <ctime>
|
|
#include <map>
|
|
#include <mutex>
|
|
#include <notcurses/notcurses.h>
|
|
|
|
#include "Root.hh"
|
|
#include "Cell.hh"
|
|
#include "CellStyle.hh"
|
|
#include "NCAlign.hh"
|
|
#include "NCBox.hh"
|
|
|
|
namespace ncpp
|
|
{
|
|
class NcReel;
|
|
|
|
class NCPP_API_EXPORT Plane : public Root
|
|
{
|
|
public:
|
|
Plane (Plane&& other)
|
|
: Root (nullptr)
|
|
{
|
|
unmap_plane (&other);
|
|
|
|
plane = other.plane;
|
|
is_stdplane = other.is_stdplane;
|
|
|
|
map_plane (plane, this);
|
|
|
|
other.plane = nullptr;
|
|
other.is_stdplane = false;
|
|
}
|
|
|
|
Plane (Plane const& other)
|
|
: Root (nullptr)
|
|
{
|
|
plane = duplicate_plane (other, nullptr);
|
|
}
|
|
|
|
explicit Plane (Plane const& other, void *opaque)
|
|
: Root (nullptr)
|
|
{
|
|
plane = duplicate_plane (other, opaque);
|
|
}
|
|
|
|
explicit Plane (Plane *n, int rows, int cols, int yoff, int xoff, void *opaque = nullptr)
|
|
: Plane (static_cast<const Plane*>(n), rows, cols, yoff, xoff, opaque)
|
|
{}
|
|
|
|
explicit Plane (const Plane *n, int rows, int cols, int yoff, int xoff, void *opaque = nullptr)
|
|
: Root (nullptr)
|
|
{
|
|
if (n == nullptr)
|
|
throw invalid_argument ("'n' must be a valid pointer");
|
|
|
|
plane = create_plane (*n, rows, cols, yoff, xoff, opaque);
|
|
}
|
|
|
|
explicit Plane (Plane *n, ncplane_options const& nopts, NotCurses *ncinst = nullptr)
|
|
: Plane (static_cast<const Plane*>(n), nopts, ncinst)
|
|
{}
|
|
|
|
explicit Plane (const Plane *n, ncplane_options const& nopts, NotCurses *ncinst = nullptr)
|
|
: Root (ncinst)
|
|
{
|
|
if (n == nullptr) {
|
|
throw invalid_argument ("'n' must be a valid pointer");
|
|
}
|
|
|
|
plane = create_plane (*n, nopts);
|
|
}
|
|
|
|
explicit Plane (const Plane &n, int rows, int cols, int yoff, int xoff, void *opaque = nullptr)
|
|
: Root (nullptr)
|
|
{
|
|
plane = create_plane (n, rows, cols, yoff, xoff, opaque);
|
|
}
|
|
|
|
explicit Plane (unsigned rows, unsigned cols, int yoff, int xoff, void *opaque = nullptr, NotCurses *ncinst = nullptr)
|
|
: Root (ncinst)
|
|
{
|
|
ncplane_options nopts = {
|
|
.y = yoff,
|
|
.x = xoff,
|
|
.rows = rows,
|
|
.cols = cols,
|
|
.userptr = opaque,
|
|
.name = nullptr,
|
|
.resizecb = nullptr,
|
|
.flags = 0,
|
|
.margin_b = 0,
|
|
.margin_r = 0,
|
|
};
|
|
plane = ncplane_create (
|
|
notcurses_stdplane(get_notcurses ()),
|
|
&nopts
|
|
);
|
|
|
|
if (plane == nullptr)
|
|
throw init_error ("Notcurses failed to create a new plane");
|
|
|
|
map_plane (plane, this);
|
|
}
|
|
|
|
explicit Plane (Plane &n, int rows, int cols, int yoff, NCAlign align, void *opaque = nullptr)
|
|
: Root (nullptr)
|
|
{
|
|
plane = create_plane (n, rows, cols, yoff, align, opaque);
|
|
}
|
|
|
|
explicit Plane (Plane const& n, int rows, int cols, int yoff, NCAlign align, void *opaque = nullptr)
|
|
: Root (nullptr)
|
|
{
|
|
plane = create_plane (const_cast<Plane&>(n), rows, cols, yoff, align, opaque);
|
|
}
|
|
|
|
explicit Plane (Plane &n, ncplane_options const& nopts, NotCurses *ncinst = nullptr)
|
|
: Plane (static_cast<Plane const&>(n), nopts, ncinst)
|
|
{}
|
|
|
|
explicit Plane (Plane const& n, ncplane_options const& nopts, NotCurses *ncinst = nullptr)
|
|
: Root (ncinst)
|
|
{
|
|
plane = create_plane (n, nopts);
|
|
}
|
|
|
|
explicit Plane (Plane *n, int rows, int cols, int yoff, NCAlign align, void *opaque = nullptr)
|
|
: Root (nullptr)
|
|
{
|
|
if (n == nullptr)
|
|
throw invalid_argument ("'n' must be a valid pointer");
|
|
|
|
plane = create_plane (*n, rows, cols, yoff, align, opaque);
|
|
}
|
|
|
|
explicit Plane (Plane const* n, int rows, int cols, int yoff, NCAlign align, void *opaque = nullptr)
|
|
: Root (nullptr)
|
|
{
|
|
if (n == nullptr)
|
|
throw invalid_argument ("'n' must be a valid pointer");
|
|
|
|
plane = create_plane (const_cast<Plane&>(*n), rows, cols, yoff, align, opaque);
|
|
}
|
|
|
|
explicit Plane (ncplane *_plane) noexcept
|
|
: Root (nullptr),
|
|
plane (_plane)
|
|
{}
|
|
|
|
~Plane () noexcept
|
|
{
|
|
if (is_stdplane || plane == nullptr)
|
|
return;
|
|
|
|
if (!is_notcurses_stopped ())
|
|
ncplane_destroy (plane);
|
|
unmap_plane (this);
|
|
}
|
|
|
|
operator ncplane* () noexcept
|
|
{
|
|
return plane;
|
|
}
|
|
|
|
operator ncplane const* () const noexcept
|
|
{
|
|
return plane;
|
|
}
|
|
|
|
void center_abs (int *y, int *x) const noexcept
|
|
{
|
|
ncplane_center_abs (plane, y, x);
|
|
}
|
|
|
|
ncplane* to_ncplane () const noexcept
|
|
{
|
|
return plane;
|
|
}
|
|
|
|
bool resize_maximize () const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_resize_maximize (plane), -1);
|
|
}
|
|
|
|
bool resize_realign () const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_resize_realign (plane), -1);
|
|
}
|
|
|
|
bool resize (int keepy, int keepx, int keepleny, int keeplenx, int yoff, int xoff, int ylen, int xlen) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret = ncplane_resize (
|
|
plane,
|
|
keepy,
|
|
keepx,
|
|
keepleny,
|
|
keeplenx,
|
|
yoff,
|
|
xoff,
|
|
ylen,
|
|
xlen
|
|
);
|
|
|
|
return error_guard (ret, -1);
|
|
}
|
|
|
|
bool pulse (const timespec* ts, fadecb fader, void* curry) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_pulse (plane, ts, fader, curry), -1);
|
|
}
|
|
|
|
int gradient (int y, int x, unsigned ylen, unsigned xlen, const char* egc, uint16_t stylemask, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_gradient (plane, y, x, ylen, xlen, egc, stylemask, ul, ur, ll, lr), -1);
|
|
}
|
|
|
|
int gradient2x1 (int y, int x, unsigned ylen, unsigned xlen, uint32_t ul, uint32_t ur, uint32_t ll, uint32_t lr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_gradient2x1 (plane, y, x, ylen, xlen, ul, ur, ll, lr), -1);
|
|
}
|
|
|
|
void greyscale () const noexcept
|
|
{
|
|
ncplane_greyscale (plane);
|
|
}
|
|
|
|
bool resize (int ylen, int xlen) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_resize_simple (plane, ylen, xlen), -1);
|
|
}
|
|
|
|
bool fadeout (timespec *ts, fadecb fader = nullptr, void *curry = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return fadeout (static_cast<const timespec*>(ts), fader, curry);
|
|
}
|
|
|
|
bool fadeout (timespec &ts, fadecb fader = nullptr, void *curry = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return fadeout (&ts, fader, curry);
|
|
}
|
|
|
|
bool fadeout (timespec const& ts, fadecb fader = nullptr, void *curry = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return fadeout (&ts, fader, curry);
|
|
}
|
|
|
|
bool fadeout (const timespec *ts, fadecb fader = nullptr, void *curry = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_fadeout (plane, ts, fader, curry), -1);
|
|
}
|
|
|
|
bool fadein (timespec *ts, fadecb fader = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return fadein (static_cast<const timespec*>(ts), fader);
|
|
}
|
|
|
|
bool fadein (timespec &ts, fadecb fader = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return fadein (&ts, fader);
|
|
}
|
|
|
|
bool fadein (timespec const& ts, fadecb fader = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return fadein (&ts, fader);
|
|
}
|
|
|
|
bool fadein (const timespec *ts, fadecb fader = nullptr, void *curry = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_fadein (plane, ts, fader, curry), -1);
|
|
}
|
|
|
|
void erase () const noexcept
|
|
{
|
|
ncplane_erase (plane);
|
|
}
|
|
|
|
int get_abs_x () const noexcept
|
|
{
|
|
return ncplane_abs_x (plane);
|
|
}
|
|
|
|
int get_abs_y () const noexcept
|
|
{
|
|
return ncplane_abs_y (plane);
|
|
}
|
|
|
|
int get_x () const noexcept
|
|
{
|
|
return ncplane_x (plane);
|
|
}
|
|
|
|
int get_y () const noexcept
|
|
{
|
|
return ncplane_y (plane);
|
|
}
|
|
|
|
int get_align (NCAlign align, int c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_halign (plane, static_cast<ncalign_e>(align), c), INT_MAX);
|
|
}
|
|
|
|
int get_halign (NCAlign align, int c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_halign (plane, static_cast<ncalign_e>(align), c), INT_MAX);
|
|
}
|
|
|
|
int get_valign (NCAlign align, int r) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_valign (plane, static_cast<ncalign_e>(align), r), INT_MAX);
|
|
}
|
|
|
|
void get_dim (unsigned *rows, unsigned *cols) const noexcept
|
|
{
|
|
ncplane_dim_yx (plane, rows, cols);
|
|
}
|
|
|
|
void get_dim (unsigned &rows, unsigned &cols) const noexcept
|
|
{
|
|
get_dim (&rows, &cols);
|
|
}
|
|
|
|
unsigned get_dim_x () const noexcept
|
|
{
|
|
return ncplane_dim_x (plane);
|
|
}
|
|
|
|
unsigned get_dim_y () const noexcept
|
|
{
|
|
return ncplane_dim_y (plane);
|
|
}
|
|
|
|
void get_abs_yx (int* y, int* x) const noexcept
|
|
{
|
|
ncplane_abs_yx (plane, y, x);
|
|
}
|
|
|
|
void get_yx (int *y, int *x) const noexcept
|
|
{
|
|
ncplane_yx (plane, y, x);
|
|
}
|
|
|
|
void get_yx (int &y, int &x) const noexcept
|
|
{
|
|
get_yx (&y, &x);
|
|
}
|
|
|
|
Plane* get_parent () const noexcept
|
|
{
|
|
ncplane *ret = ncplane_parent (plane);
|
|
if (ret == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
return map_plane (ret);
|
|
}
|
|
|
|
Plane* reparent (Plane *newparent = nullptr) const noexcept
|
|
{
|
|
ncplane *ret = ncplane_reparent (plane, newparent == nullptr ? plane : newparent->plane);
|
|
if (ret == nullptr)
|
|
return nullptr;
|
|
|
|
return map_plane (ret);
|
|
}
|
|
|
|
Plane* reparent (const Plane *newparent) const noexcept
|
|
{
|
|
return reparent (const_cast<Plane*>(newparent));
|
|
}
|
|
|
|
Plane* reparent (const Plane &newparent) const noexcept
|
|
{
|
|
return reparent (const_cast<Plane*>(&newparent));
|
|
}
|
|
|
|
Plane* reparent_family (Plane *newparent = nullptr) const noexcept
|
|
{
|
|
ncplane *ret = ncplane_reparent_family (plane, newparent == nullptr ? plane : newparent->plane);
|
|
if (ret == nullptr)
|
|
return nullptr;
|
|
|
|
return map_plane (ret);
|
|
}
|
|
|
|
Plane* reparent_family (const Plane *newparent) const noexcept
|
|
{
|
|
return reparent_family (const_cast<Plane*>(newparent));
|
|
}
|
|
|
|
Plane* reparent_family (const Plane &newparent) const noexcept
|
|
{
|
|
return reparent_family (const_cast<Plane*>(&newparent));
|
|
}
|
|
|
|
void home () const noexcept
|
|
{
|
|
ncplane_home (plane);
|
|
}
|
|
|
|
bool move (int y, int x) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_move_yx (plane, y, x), -1);
|
|
}
|
|
|
|
void move_top () noexcept
|
|
{
|
|
ncplane_move_top (plane);
|
|
}
|
|
|
|
void move_bottom () noexcept
|
|
{
|
|
ncplane_move_bottom (plane);
|
|
}
|
|
|
|
bool move_below (Plane &below) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_move_below (plane, below.plane), -1);
|
|
}
|
|
|
|
bool move_below (Plane *below) const
|
|
{
|
|
if (below == nullptr)
|
|
throw invalid_argument ("'below' must be a valid pointer");
|
|
|
|
return move_below (*below);
|
|
}
|
|
|
|
bool move_above (Plane &above) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_move_above (plane, above.plane), -1);
|
|
}
|
|
|
|
bool move_above (Plane *above) const
|
|
{
|
|
if (above == nullptr)
|
|
throw invalid_argument ("'above' must be a valid pointer");
|
|
|
|
return move_above (*above);
|
|
}
|
|
|
|
bool mergedown (Plane &dst, unsigned begsrcy, unsigned begsrcx, unsigned leny, unsigned lenx, unsigned dsty, unsigned dstx) const
|
|
{
|
|
return mergedown (&dst, begsrcy, begsrcx, leny, lenx, dsty, dstx);
|
|
}
|
|
|
|
bool mergedown (Plane *dst, int begsrcy, int begsrcx, unsigned leny, unsigned lenx, int dsty, int dstx) const
|
|
{
|
|
if (plane == dst->plane)
|
|
throw invalid_argument ("'dst' must refer to a different plane than the one this method is called on");
|
|
|
|
return error_guard (ncplane_mergedown (plane, dst->plane, begsrcy, begsrcx, leny, lenx, dsty, dstx), -1);
|
|
}
|
|
|
|
bool mergedown_simple (Plane &dst) const
|
|
{
|
|
return mergedown_simple (&dst);
|
|
}
|
|
|
|
bool mergedown_simple (Plane *dst) const
|
|
{
|
|
if (plane == dst->plane)
|
|
throw invalid_argument ("'dst' must refer to a different plane than the one this method is called on");
|
|
|
|
return error_guard (ncplane_mergedown_simple (plane, dst->plane), -1);
|
|
}
|
|
|
|
bool cursor_move (int y, int x) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_cursor_move_yx (plane, y, x), -1);
|
|
}
|
|
|
|
void get_cursor_yx (unsigned *y, unsigned *x) const noexcept
|
|
{
|
|
ncplane_cursor_yx (plane, y, x);
|
|
}
|
|
|
|
void get_cursor_yx (unsigned &y, unsigned &x) const noexcept
|
|
{
|
|
get_cursor_yx (&y, &x);
|
|
}
|
|
|
|
unsigned cursor_y() const noexcept
|
|
{
|
|
return ncplane_cursor_y(plane);
|
|
}
|
|
|
|
unsigned cursor_x() const noexcept
|
|
{
|
|
return ncplane_cursor_x(plane);
|
|
}
|
|
|
|
int putc (const Cell &c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putc (plane, c), -1);
|
|
}
|
|
|
|
int putc (const Cell *c) const
|
|
{
|
|
if (c == nullptr)
|
|
throw invalid_argument ("'c' must be a valid pointer");
|
|
|
|
return putc (*c);
|
|
}
|
|
|
|
int putc (int y, int x, Cell const& c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putc_yx (plane, y, x, c), -1);
|
|
}
|
|
|
|
int putc (int y, int x, Cell const* c) const NOEXCEPT_MAYBE
|
|
{
|
|
if (c == nullptr)
|
|
return -1;
|
|
|
|
return putc (y, x, *c);
|
|
}
|
|
|
|
int putc (char c, bool retain_styling = false) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret;
|
|
if (retain_styling) {
|
|
ret = ncplane_putchar_stained (plane, c);
|
|
} else {
|
|
ret = ncplane_putchar (plane, c);
|
|
}
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int putc (int y, int x, char c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putchar_yx (plane, y, x, c), -1);
|
|
}
|
|
|
|
int putc (const char *gclust, size_t *sbytes = nullptr, bool retain_styling = false) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret;
|
|
if (retain_styling) {
|
|
ret = ncplane_putegc_stained (plane, gclust, sbytes);
|
|
} else {
|
|
ret = ncplane_putegc (plane, gclust, sbytes);
|
|
}
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int putc (int y, int x, const char *gclust, size_t *sbytes = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putegc_yx (plane, y, x, gclust, sbytes), -1);
|
|
}
|
|
|
|
int putc (const wchar_t *gclust, size_t *sbytes = nullptr, bool retain_styling = false) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret;
|
|
if (retain_styling) {
|
|
ret = ncplane_putwegc_stained (plane, gclust, sbytes);
|
|
} else {
|
|
ret = ncplane_putwegc (plane, gclust, sbytes);
|
|
}
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int putc (int y, int x, const wchar_t *gclust, size_t *sbytes = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwegc_yx (plane, y, x, gclust, sbytes), -1);
|
|
}
|
|
|
|
// OK, this is ugly, but we need to rename this overload or calls similar to n->putc (0, 0, '0') will be
|
|
// considered ambiguous with the above `putc (int, int, char)` overload.
|
|
int putwch (int y, int x, wchar_t w) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwc_yx (plane, y, x, w), -1);
|
|
}
|
|
|
|
// Ditto
|
|
int putwch (wchar_t w) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwc (plane, w), -1);
|
|
}
|
|
|
|
int putwc_stained (wchar_t w) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwc_stained (plane, w), -1);
|
|
}
|
|
|
|
int putstr (const char *gclustarr) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret = ncplane_putstr (plane, gclustarr);
|
|
return error_guard_cond<int> (ret, ret < 0);
|
|
}
|
|
|
|
int putstr (int y, int x, const char *gclustarr) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret = ncplane_putstr_yx (plane, y, x, gclustarr);
|
|
return error_guard_cond<int> (ret, ret < 0);
|
|
}
|
|
|
|
int putstr (int y, NCAlign atype, const char *s) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putstr_aligned (plane, y, static_cast<ncalign_e>(atype), s), -1);
|
|
}
|
|
|
|
int putstr (const wchar_t *gclustarr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwstr (plane, gclustarr), -1);
|
|
}
|
|
|
|
int putstr (int y, int x, const wchar_t *gclustarr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwstr_yx (plane, y, x, gclustarr), -1);
|
|
}
|
|
|
|
int putstr (int y, NCAlign atype, const wchar_t *gcluststyles) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwstr_aligned (plane, y, static_cast<ncalign_e>(atype), gcluststyles), -1);
|
|
}
|
|
|
|
int putstr_stained (const wchar_t* gclustarr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_putwstr_stained (plane, gclustarr), -1);
|
|
}
|
|
|
|
int putstr_stained (const char* s) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret = ncplane_putstr_stained (plane, s);
|
|
return error_guard_cond<int> (ret, ret < 0);
|
|
}
|
|
|
|
int printf_stained (const char* format, ...) const NOEXCEPT_MAYBE
|
|
__attribute__ ((format (printf, 2, 3)))
|
|
{
|
|
va_list va;
|
|
|
|
va_start (va, format);
|
|
int ret = ncplane_vprintf_stained (plane, format, va);
|
|
va_end (va);
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int printf (const char* format, ...) const NOEXCEPT_MAYBE
|
|
__attribute__ ((format (printf, 2, 3)))
|
|
{
|
|
va_list va;
|
|
|
|
va_start (va, format);
|
|
int ret = ncplane_vprintf (plane, format, va);
|
|
va_end (va);
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int printf (int y, int x, const char *format, ...) const NOEXCEPT_MAYBE
|
|
__attribute__ ((format (printf, 4, 5)))
|
|
{
|
|
va_list va;
|
|
|
|
va_start (va, format);
|
|
int ret = ncplane_vprintf_yx (plane, y, x, format, va);
|
|
va_end (va);
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int printf (int y, NCAlign align, const char *format, ...) const NOEXCEPT_MAYBE
|
|
__attribute__ ((format (printf, 4, 5)))
|
|
{
|
|
va_list va;
|
|
|
|
va_start (va, format);
|
|
int ret = vprintf (y, align, format, va);
|
|
va_end (va);
|
|
|
|
return error_guard<int> (ret, -1);
|
|
}
|
|
|
|
int vprintf_stained (const char* format, va_list ap) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_vprintf_stained (plane, format, ap), -1);
|
|
}
|
|
|
|
int vprintf (const char* format, va_list ap) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_vprintf (plane, format, ap), -1);
|
|
}
|
|
|
|
int vprintf (int y, int x, const char* format, va_list ap) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_vprintf_yx (plane, y, x, format, ap), -1);
|
|
}
|
|
|
|
int vprintf (int y, NCAlign align, const char *format, va_list ap) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_vprintf_aligned (plane, y, static_cast<ncalign_e>(align), format, ap), -1);
|
|
}
|
|
|
|
int hline (const Cell &c, unsigned len) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_hline (plane, c, len), -1);
|
|
}
|
|
|
|
int hline (const Cell &c, unsigned len, uint64_t c1, uint64_t c2) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_hline_interp (plane, c, len, c1, c2), -1);
|
|
}
|
|
|
|
int vline (const Cell &c, unsigned len) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_vline (plane, c, len), -1);
|
|
}
|
|
|
|
int vline (const Cell &c, unsigned len, uint64_t c1, uint64_t c2) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_vline_interp (plane, c, len, c1, c2), -1);
|
|
}
|
|
|
|
bool load_box (uint16_t styles, uint64_t channels, Cell &ul, Cell &ur, Cell &ll, Cell &lr, Cell &hl, Cell &vl, const char *gclusters) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (nccells_load_box (plane, styles, channels, ul, ur, ll, lr, hl, vl, gclusters), -1);
|
|
}
|
|
|
|
bool load_box (CellStyle style, uint64_t channels, Cell &ul, Cell &ur, Cell &ll, Cell &lr, Cell &hl, Cell &vl, const char *gclusters) const NOEXCEPT_MAYBE
|
|
{
|
|
return load_box (static_cast<uint16_t>(style), channels, ul, ur, ll, lr, hl, vl, gclusters);
|
|
}
|
|
|
|
bool load_rounded_box (uint16_t styles, uint64_t channels, Cell &ul, Cell &ur, Cell &ll, Cell &lr, Cell &hl, Cell &vl) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (nccells_rounded_box (plane, styles, channels, ul, ur, ll, lr, hl, vl), -1);
|
|
}
|
|
|
|
bool load_rounded_box (CellStyle style, uint64_t channels, Cell &ul, Cell &ur, Cell &ll, Cell &lr, Cell &hl, Cell &vl) const NOEXCEPT_MAYBE
|
|
{
|
|
return load_rounded_box (static_cast<uint16_t>(style), channels, ul, ur, ll, lr, hl, vl);
|
|
}
|
|
|
|
bool load_double_box (uint16_t styles, uint64_t channels, Cell &ul, Cell &ur, Cell &ll, Cell &lr, Cell &hl, Cell &vl) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (nccells_double_box (plane, styles, channels, ul, ur, ll, lr, hl, vl), -1);
|
|
}
|
|
|
|
bool load_double_box (CellStyle style, uint64_t channels, Cell &ul, Cell &ur, Cell &ll, Cell &lr, Cell &hl, Cell &vl) const NOEXCEPT_MAYBE
|
|
{
|
|
return load_double_box (static_cast<uint16_t>(style), channels, ul, ur, ll, lr, hl, vl);
|
|
}
|
|
|
|
bool box (const Cell &ul, const Cell &ur, const Cell &ll, const Cell &lr,
|
|
const Cell &hline, const Cell &vline, int ystop, int xstop,
|
|
unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_box (plane, ul, ur, ll, lr, hline, vline, ystop, xstop, ctlword), -1);
|
|
}
|
|
|
|
bool box_sized (const Cell &ul, const Cell &ur, const Cell &ll, const Cell &lr,
|
|
const Cell &hline, const Cell &vline, int ylen, int xlen,
|
|
unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_box_sized (plane, ul, ur, ll, lr, hline, vline, ylen, xlen, ctlword), -1);
|
|
}
|
|
|
|
bool rounded_box (uint16_t styles, uint64_t channels, int ystop, int xstop, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_rounded_box (plane, styles, channels, ystop, xstop, ctlword), -1);
|
|
}
|
|
|
|
bool rounded_box_sized (uint16_t styles, uint64_t channels, int ylen, int xlen, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_rounded_box_sized (plane, styles, channels, ylen, xlen, ctlword), -1);
|
|
}
|
|
|
|
bool double_box (uint16_t styles, uint64_t channels, int ystop, int xstop, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_double_box (plane, styles, channels, ystop, xstop, ctlword), -1);
|
|
}
|
|
|
|
bool double_box_sized (uint16_t styles, uint64_t channels, int ylen, int xlen, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_double_box_sized (plane, styles, channels, ylen, xlen, ctlword), -1);
|
|
}
|
|
|
|
bool perimeter (const Cell &ul, const Cell &ur, const Cell &ll, const Cell &lr, const Cell &hline, const Cell &vline, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_perimeter (plane, ul, ur, ll, lr, hline, vline, ctlword), -1);
|
|
}
|
|
|
|
bool perimeter_rounded (uint16_t stylemask, uint64_t channels, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_perimeter_rounded (plane, stylemask, channels, ctlword), -1);
|
|
}
|
|
|
|
bool perimeter_double (uint16_t stylemask, uint64_t channels, unsigned ctlword) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_perimeter_double (plane, stylemask, channels, ctlword), -1);
|
|
}
|
|
|
|
int polyfill (int y, int x, const Cell& c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_polyfill_yx (plane, y, x, c), -1);
|
|
}
|
|
|
|
uint32_t* rgba(ncblitter_e blit, unsigned begy, unsigned begx, unsigned leny, unsigned lenx) const noexcept
|
|
{
|
|
return ncplane_as_rgba (plane, blit, begy, begx, leny, lenx, nullptr, nullptr);
|
|
}
|
|
|
|
char* content(unsigned begy, unsigned begx, unsigned leny, unsigned lenx) const noexcept
|
|
{
|
|
return ncplane_contents (plane, begy, begx, leny, lenx);
|
|
}
|
|
|
|
uint64_t get_channels () const noexcept
|
|
{
|
|
return ncplane_channels (plane);
|
|
}
|
|
|
|
unsigned get_bchannel () const noexcept
|
|
{
|
|
return ncplane_bchannel (plane);
|
|
}
|
|
|
|
unsigned get_fchannel () const noexcept
|
|
{
|
|
return ncplane_fchannel (plane);
|
|
}
|
|
|
|
unsigned get_fg_rgb () const noexcept
|
|
{
|
|
return ncplane_fg_rgb (plane);
|
|
}
|
|
|
|
unsigned get_bg_rgb () const noexcept
|
|
{
|
|
return ncplane_bg_rgb (plane);
|
|
}
|
|
|
|
unsigned get_fg_alpha () const noexcept
|
|
{
|
|
return ncplane_fg_alpha (plane);
|
|
}
|
|
|
|
void set_channels (uint64_t channels) const noexcept
|
|
{
|
|
ncplane_set_channels (plane, channels);
|
|
}
|
|
|
|
bool set_fg_alpha (unsigned alpha) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_set_fg_alpha (plane, alpha), -1);
|
|
}
|
|
|
|
unsigned get_bg_alpha () const noexcept
|
|
{
|
|
return ncplane_bg_alpha (plane);
|
|
}
|
|
|
|
bool set_bg_alpha (unsigned alpha) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_set_bg_alpha (plane, alpha), -1);
|
|
}
|
|
|
|
unsigned get_fg_rgb8 (unsigned *r, unsigned *g, unsigned *b) const noexcept
|
|
{
|
|
return ncplane_fg_rgb8 (plane, r, g, b);
|
|
}
|
|
|
|
bool set_fg_rgb8 (int r, int g, int b, bool clipped = false) const NOEXCEPT_MAYBE
|
|
{
|
|
if (clipped) {
|
|
ncplane_set_fg_rgb8_clipped (plane, r, g, b);
|
|
return true;
|
|
}
|
|
|
|
return error_guard (ncplane_set_fg_rgb8 (plane, r, g, b), -1);
|
|
}
|
|
|
|
bool set_fg_palindex (int idx) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_set_fg_palindex (plane, idx), -1);
|
|
}
|
|
|
|
bool set_fg_rgb (uint32_t channel) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_set_fg_rgb (plane, channel), -1);
|
|
}
|
|
|
|
void set_fg_default () const noexcept
|
|
{
|
|
ncplane_set_fg_default (plane);
|
|
}
|
|
|
|
unsigned get_bg_rgb8 (unsigned *r, unsigned *g, unsigned *b) const noexcept
|
|
{
|
|
return ncplane_bg_rgb8 (plane, r, g, b);
|
|
}
|
|
|
|
bool set_bg_rgb8 (int r, int g, int b, bool clipped = false) const NOEXCEPT_MAYBE
|
|
{
|
|
if (clipped) {
|
|
ncplane_set_bg_rgb8_clipped (plane, r, g, b);
|
|
return true;
|
|
}
|
|
|
|
return error_guard (ncplane_set_bg_rgb8 (plane, r, g, b), -1);
|
|
}
|
|
|
|
bool set_bg_palindex (int idx) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_set_bg_alpha (plane, idx), -1);
|
|
}
|
|
|
|
bool set_bg_rgb (uint32_t channel) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_set_bg_rgb (plane, channel), -1);
|
|
}
|
|
|
|
void set_bg_default () const noexcept
|
|
{
|
|
ncplane_set_bg_default (plane);
|
|
}
|
|
|
|
bool set_scrolling (bool scrollp) const noexcept
|
|
{
|
|
return ncplane_set_scrolling (plane, scrollp);
|
|
}
|
|
|
|
unsigned get_styles () const noexcept
|
|
{
|
|
return ncplane_styles (plane);
|
|
}
|
|
|
|
void styles_set (CellStyle styles) const noexcept
|
|
{
|
|
ncplane_set_styles (plane, static_cast<unsigned>(styles));
|
|
}
|
|
|
|
void styles_on (CellStyle styles) const noexcept
|
|
{
|
|
ncplane_on_styles (plane, static_cast<unsigned>(styles));
|
|
}
|
|
|
|
void styles_off (CellStyle styles) const noexcept
|
|
{
|
|
ncplane_off_styles (plane, static_cast<unsigned>(styles));
|
|
}
|
|
|
|
int format (int y, int x, unsigned ylen, unsigned xlen, uint16_t stylemask) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_format (plane, y, x, ylen, xlen, stylemask), -1);
|
|
}
|
|
|
|
int stain (int y, int x, unsigned ylen, unsigned xlen, uint64_t ul, uint64_t ur, uint64_t ll, uint64_t lr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_stain (plane, y, x, ylen, xlen, ul, ur, ll, lr), -1);
|
|
}
|
|
|
|
Plane* get_below () const noexcept
|
|
{
|
|
return map_plane (ncplane_below (plane));
|
|
}
|
|
|
|
Plane* get_above () const noexcept
|
|
{
|
|
return map_plane (ncplane_above (plane));
|
|
}
|
|
|
|
bool set_base_cell (Cell &c) const NOEXCEPT_MAYBE
|
|
{
|
|
bool ret = ncplane_set_base_cell (plane, c) < 0;
|
|
return error_guard_cond<bool, bool> (ret, ret);
|
|
}
|
|
|
|
bool set_base (const char* egc, uint16_t stylemask, uint64_t channels) const NOEXCEPT_MAYBE
|
|
{
|
|
bool ret = ncplane_set_base (plane, egc, stylemask, channels) < 0;
|
|
return error_guard_cond<bool, bool> (ret, ret);
|
|
}
|
|
|
|
bool get_base (Cell &c) const NOEXCEPT_MAYBE
|
|
{
|
|
bool ret = ncplane_base (plane, c) < 0;
|
|
return error_guard_cond<bool, bool> (ret, ret);
|
|
}
|
|
|
|
int at_cursor (Cell &c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int>(ncplane_at_cursor_cell (plane, c), -1);
|
|
}
|
|
|
|
int at_cursor (Cell *c) const noexcept
|
|
{
|
|
if (c == nullptr)
|
|
return false;
|
|
|
|
return at_cursor (*c);
|
|
}
|
|
|
|
char* at_cursor (uint16_t* stylemask, uint64_t* channels) const
|
|
{
|
|
if (stylemask == nullptr || channels == nullptr)
|
|
return nullptr;
|
|
|
|
return ncplane_at_cursor (plane, stylemask, channels);
|
|
}
|
|
|
|
int get_at (int y, int x, Cell &c) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (ncplane_at_yx_cell (plane, y, x, c), -1);
|
|
}
|
|
|
|
int get_at (int y, int x, Cell *c) const
|
|
{
|
|
if (c == nullptr)
|
|
return -1;
|
|
|
|
return get_at (y, x, *c);
|
|
}
|
|
|
|
char* get_at (int y, int x, uint16_t* stylemask, uint64_t* channels) const
|
|
{
|
|
if (stylemask == nullptr || channels == nullptr)
|
|
return nullptr;
|
|
|
|
return ncplane_at_yx (plane, y, x, stylemask, channels);
|
|
}
|
|
|
|
void* set_userptr (void *opaque) const noexcept
|
|
{
|
|
return ncplane_set_userptr (plane, opaque);
|
|
}
|
|
|
|
template<typename T>
|
|
T* set_userptr (T *opaque) const noexcept
|
|
{
|
|
return static_cast<T*>(set_userptr (static_cast<void*>(opaque)));
|
|
}
|
|
|
|
void* get_userptr () const noexcept
|
|
{
|
|
return ncplane_userptr (plane);
|
|
}
|
|
|
|
template<typename T>
|
|
T* get_userptr () const noexcept
|
|
{
|
|
return static_cast<T*>(get_userptr ());
|
|
}
|
|
|
|
NcReel* ncreel_create (const ncreel_options *popts = nullptr);
|
|
|
|
// Some Cell APIs go here since they act on individual panels even though it may seem weird at points (e.g.
|
|
// release)
|
|
|
|
int load_egc32 (Cell &cell, uint32_t egc) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret = nccell_load_egc32 (plane, cell, egc);
|
|
return error_guard_cond<int> (ret, ret != 1);
|
|
}
|
|
|
|
int load (Cell &cell, const char *gcluster) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (nccell_load (plane, cell, gcluster), -1);
|
|
}
|
|
|
|
bool load (Cell &cell, char ch) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (nccell_load_char (plane, cell, ch), -1);
|
|
}
|
|
|
|
int prime (Cell &cell, const char *gcluster, uint16_t styles, uint64_t channels) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (nccell_prime (plane, cell, gcluster, styles, channels), -1);
|
|
}
|
|
|
|
void release (Cell &cell) const noexcept
|
|
{
|
|
nccell_release (plane, cell);
|
|
}
|
|
|
|
int duplicate (Cell &target, Cell &source) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (nccell_duplicate (plane, target, source), -1);
|
|
}
|
|
|
|
int duplicate (Cell &target, Cell const& source) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<int> (nccell_duplicate (plane, target, source), -1);
|
|
}
|
|
|
|
int duplicate (Cell &target, Cell *source) const
|
|
{
|
|
if (source == nullptr)
|
|
throw invalid_argument ("'source' must be a valid pointer");
|
|
|
|
return duplicate (target, *source);
|
|
}
|
|
|
|
int duplicate (Cell &target, Cell const* source) const
|
|
{
|
|
if (source == nullptr)
|
|
throw invalid_argument ("'source' must be a valid pointer");
|
|
|
|
return duplicate (target, *source);
|
|
}
|
|
|
|
int duplicate (Cell *target, Cell *source) const
|
|
{
|
|
if (target == nullptr)
|
|
throw invalid_argument ("'target' must be a valid pointer");
|
|
if (source == nullptr)
|
|
throw invalid_argument ("'source' must be a valid pointer");
|
|
|
|
return duplicate (*target, *source);
|
|
}
|
|
|
|
int duplicate (Cell *target, Cell const* source) const
|
|
{
|
|
if (target == nullptr)
|
|
throw invalid_argument ("'target' must be a valid pointer");
|
|
if (source == nullptr)
|
|
throw invalid_argument ("'source' must be a valid pointer");
|
|
|
|
return duplicate (*target, *source);
|
|
}
|
|
|
|
int duplicate (Cell *target, Cell &source) const
|
|
{
|
|
if (target == nullptr)
|
|
throw invalid_argument ("'target' must be a valid pointer");
|
|
|
|
return duplicate (*target, source);
|
|
}
|
|
|
|
int duplicate (Cell *target, Cell const& source) const
|
|
{
|
|
if (target == nullptr)
|
|
throw invalid_argument ("'target' must be a valid pointer");
|
|
|
|
return duplicate (*target, source);
|
|
}
|
|
|
|
void translate (const Plane *dst, int *y = nullptr, int *x = nullptr) const noexcept
|
|
{
|
|
ncplane_translate (*this, dst ? dst->plane: nullptr, y, x);
|
|
}
|
|
|
|
void translate (const Plane &dst, int *y = nullptr, int *x = nullptr) const noexcept
|
|
{
|
|
translate (*this, dst, y, x);
|
|
}
|
|
|
|
static void translate (const Plane *src, const Plane *dst, int *y = nullptr, int *x = nullptr)
|
|
{
|
|
if (src == nullptr)
|
|
throw invalid_argument ("'src' must be a valid pointer");
|
|
|
|
ncplane_translate (*src, dst ? dst->plane : nullptr, y, x);
|
|
}
|
|
|
|
static void translate (const Plane &src, const Plane &dst, int *y = nullptr, int *x = nullptr) noexcept
|
|
{
|
|
ncplane_translate (src.plane, dst.plane, y, x);
|
|
}
|
|
|
|
bool translate_abs (int *y = nullptr, int *x = nullptr) const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard<bool, bool> (ncplane_translate_abs (plane, y, x), false);
|
|
}
|
|
|
|
bool rotate_cw () const NOEXCEPT_MAYBE
|
|
{
|
|
return error_guard (ncplane_rotate_cw (plane), -1);
|
|
}
|
|
|
|
bool rotate_ccw () const noexcept
|
|
{
|
|
return error_guard (ncplane_rotate_ccw (plane), -1);
|
|
}
|
|
|
|
char* strdup (Cell const& cell) const noexcept
|
|
{
|
|
return nccell_strdup (plane, cell);
|
|
}
|
|
|
|
char* extract (Cell const& cell, uint16_t *stylemask = nullptr, uint64_t *channels = nullptr)
|
|
{
|
|
return nccell_extract (plane, cell, stylemask, channels);
|
|
}
|
|
|
|
const char* get_extended_gcluster (Cell &cell) const noexcept
|
|
{
|
|
return nccell_extended_gcluster (plane, cell);
|
|
}
|
|
|
|
const char* get_extended_gcluster (Cell const& cell) const noexcept
|
|
{
|
|
return nccell_extended_gcluster (plane, cell);
|
|
}
|
|
|
|
static Plane* map_plane (ncplane *ncp, Plane *associated_plane = nullptr) noexcept;
|
|
|
|
bool blit_bgrx (const void* data, int linesize, const struct ncvisual_options *vopts) const NOEXCEPT_MAYBE
|
|
{
|
|
bool ret = ncblit_bgrx (data, linesize, vopts) < 0;
|
|
return error_guard_cond<bool, bool> (ret, ret);
|
|
}
|
|
|
|
bool blit_rgba (const void* data, int linesize, const struct ncvisual_options *vopts) const NOEXCEPT_MAYBE
|
|
{
|
|
bool ret = ncblit_rgba (data, linesize, vopts) < 0;
|
|
return error_guard_cond<bool, bool> (ret, ret);
|
|
}
|
|
|
|
int qrcode (unsigned* ymax, unsigned* xmax, const void *data, size_t len) const NOEXCEPT_MAYBE
|
|
{
|
|
int ret = ncplane_qrcode (plane, ymax, xmax, data, len);
|
|
return error_guard_cond<int> (ret, ret < 0);
|
|
}
|
|
|
|
bool is_descendant_of (const Plane& ancestor) const noexcept
|
|
{
|
|
return ncplane_descendant_p (plane, ancestor) != 0;
|
|
}
|
|
|
|
bool is_fg_default () const noexcept
|
|
{
|
|
return ncplane_fg_default_p (plane);
|
|
}
|
|
|
|
bool is_bg_default () const noexcept
|
|
{
|
|
return ncplane_bg_default_p (plane);
|
|
}
|
|
|
|
bool is_valid () const noexcept
|
|
{
|
|
return plane != nullptr;
|
|
}
|
|
|
|
void set_resizecb (int(*resizecb)(struct ncplane*)) const noexcept
|
|
{
|
|
ncplane_set_resizecb (plane, resizecb);
|
|
}
|
|
|
|
protected:
|
|
explicit Plane (ncplane *_plane, bool _is_stdplane)
|
|
: Root (nullptr),
|
|
plane (_plane),
|
|
is_stdplane (_is_stdplane)
|
|
{
|
|
if (_plane == nullptr)
|
|
throw invalid_argument ("_plane must be a valid pointer");
|
|
}
|
|
|
|
// This is used by child classes which cannot provide a valid ncplane* in their constructor when initializing
|
|
// the parent class (e.g. Pile)
|
|
Plane (NotCurses *ncinst = nullptr)
|
|
: Root (ncinst),
|
|
plane (nullptr)
|
|
{}
|
|
|
|
// Can be used only once and only if plane == nullptr. Meant to be used by child classes which cannot provide a
|
|
// valid ncplane* in their constructor when initializing the parent class (e.g. Pile)
|
|
void set_plane (ncplane *_plane)
|
|
{
|
|
if (_plane == nullptr) {
|
|
throw invalid_argument ("_plane must be a valid pointer");
|
|
}
|
|
|
|
if (plane != nullptr) {
|
|
throw invalid_state_error ("Plane::set_plane can be called only once");
|
|
}
|
|
|
|
plane = _plane;
|
|
map_plane (plane, this);
|
|
}
|
|
|
|
void release_native_plane () noexcept
|
|
{
|
|
if (plane == nullptr)
|
|
return;
|
|
|
|
unmap_plane (this);
|
|
plane = nullptr;
|
|
}
|
|
|
|
static void unmap_plane (Plane *p) noexcept;
|
|
|
|
private:
|
|
ncplane* create_plane (const Plane &n, unsigned rows, unsigned cols, int yoff, int xoff, void *opaque)
|
|
{
|
|
ncplane_options nopts = {
|
|
.y = yoff,
|
|
.x = xoff,
|
|
.rows = rows,
|
|
.cols = cols,
|
|
.userptr = opaque,
|
|
.name = nullptr,
|
|
.resizecb = nullptr,
|
|
.flags = 0,
|
|
.margin_b = 0,
|
|
.margin_r = 0,
|
|
};
|
|
return create_plane (n, nopts);
|
|
}
|
|
|
|
ncplane* create_plane (Plane &n, unsigned rows, unsigned cols, int yoff, NCAlign align, void *opaque)
|
|
{
|
|
ncplane_options nopts = {
|
|
yoff,
|
|
static_cast<ncalign_e>(align),
|
|
rows,
|
|
cols,
|
|
opaque,
|
|
nullptr,
|
|
nullptr,
|
|
0,
|
|
0,
|
|
0,
|
|
};
|
|
return create_plane (n, nopts);
|
|
}
|
|
|
|
ncplane* create_plane (const Plane &n, ncplane_options const& nopts)
|
|
{
|
|
ncplane *ret = ncplane_create (
|
|
n.plane,
|
|
&nopts
|
|
);
|
|
|
|
if (ret == nullptr) {
|
|
throw init_error ("Notcurses failed to create an aligned plane");
|
|
}
|
|
|
|
map_plane (plane, this);
|
|
return ret;
|
|
}
|
|
|
|
ncplane* duplicate_plane (const Plane &other, void *opaque)
|
|
{
|
|
ncplane *ret = ncplane_dup (other.plane, opaque);
|
|
if (ret == nullptr)
|
|
throw init_error ("Notcurses failed to duplicate plane");
|
|
|
|
return ret;
|
|
}
|
|
|
|
private:
|
|
ncplane *plane = nullptr;
|
|
bool is_stdplane = false;
|
|
static std::map<ncplane*,Plane*> *plane_map;
|
|
static std::mutex plane_map_mutex;
|
|
|
|
friend class NotCurses;
|
|
friend class NcReel;
|
|
friend class Tablet;
|
|
friend class Widget;
|
|
template<typename TPlot, typename TCoord> friend class PlotBase;
|
|
};
|
|
}
|
|
#endif
|