Archives/notcurses
2
0
Fork 0
mirror of https://github.com/dankamongmen/notcurses.git synced 2024-11-18 03:25:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

ncplane_box: accept ctlword (#42)

Browse Source
This commit is contained in:
nick black 2019-12-04 00:46:38 -05:00 committed by Nick Black
parent eb53f420b1
commit a55e02836b
11 changed files with 91 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/notcurses.h
View File

@ -331,9 +331,31 @@ API int ncplane_vline(struct ncplane* n, const cell* c, int len);
// Draw a box with its upper-left corner at the current cursor position, and its
// lower-right corner at 'ystop'x'xstop'. The 6 cells provided are used to draw the
// upper-left, ur, ll, and lr corners, then the horizontal and vertical lines.
// 'ctlword' is defined in the least significant byte, where bits [7, 4] are a
// gradient mask, and [3, 0] are a border mask:
// * 7, 3: top
// * 6, 2: right
// * 5, 1: bottom
// * 4, 0: left
// if the gradient bit is not set, the styling from the hl/vl cells is used for
// the horizontal and vertical lines, respectively. if the gradient bit is set,
// the color is linearly interpolated between the two relevant corner cells. if
// the bordermask bit is set, that side of the box is not drawn. iff either edge
// connecting to a corner is drawn, the corner is drawn.
#define NCBOXMASK_TOP 0x01
#define NCBOXMASK_RIGHT 0x02
#define NCBOXMASK_BOTTOM 0x04
#define NCBOXMASK_LEFT 0x08
#define NCBOXGRAD_TOP 0x10
#define NCBOXGRAD_RIGHT 0x20
#define NCBOXGRAD_BOTTOM 0x40
#define NCBOXGRAD_LEFT 0x80
API int ncplane_box(struct ncplane* n, const cell* ul, const cell* ur,
const cell* ll, const cell* lr, const cell* hline,
const cell* vline, int ystop, int xstop);
const cell* vline, int ystop, int xstop,
unsigned ctlword);
// Draw a box with its upper-left corner at the current cursor position, having
// dimensions 'ylen'x'xlen'. See ncplane_box() for more information. The
@ -341,10 +363,11 @@ API int ncplane_box(struct ncplane* n, const cell* ul, const cell* ur,
static inline int
ncplane_box_sized(struct ncplane* n, const cell* ul, const cell* ur,
const cell* ll, const cell* lr, const cell* hline,
const cell* vline, int ylen, int xlen){
const cell* vline, int ylen, int xlen, unsigned ctlword){
int y, x;
ncplane_cursor_yx(n, &y, &x);
return ncplane_box(n, ul, ur, ll, lr, hline, vline, y + ylen - 1, x + xlen - 1);
return ncplane_box(n, ul, ur, ll, lr, hline, vline, y + ylen - 1,
x + xlen - 1, ctlword);
}
// Erase every cell in the ncplane, resetting all attributes to normal, all
@ -663,13 +686,13 @@ cells_rounded_box(struct ncplane* n, uint32_t attr, uint64_t channels,
static inline int
ncplane_rounded_box(struct ncplane* n, uint32_t attr, uint64_t channels,
int ystop, int xstop){
int ystop, int xstop, unsigned ctlword){
int ret = 0;
cell ul = CELL_TRIVIAL_INITIALIZER, ur = CELL_TRIVIAL_INITIALIZER;
cell ll = CELL_TRIVIAL_INITIALIZER, lr = CELL_TRIVIAL_INITIALIZER;
cell hl = CELL_TRIVIAL_INITIALIZER, vl = CELL_TRIVIAL_INITIALIZER;
if((ret = cells_rounded_box(n, attr, channels, &ul, &ur, &ll, &lr, &hl, &vl)) == 0){
ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop);
ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop, ctlword);
}
cell_release(n, &ul);
cell_release(n, &ur);
@ -682,10 +705,11 @@ ncplane_rounded_box(struct ncplane* n, uint32_t attr, uint64_t channels,
static inline int
ncplane_rounded_box_sized(struct ncplane* n, uint32_t attr, uint64_t channels,
int ylen, int xlen){
int ylen, int xlen, unsigned ctlword){
int y, x;
ncplane_cursor_yx(n, &y, &x);
return ncplane_rounded_box(n, attr, channels, y + ylen - 1, x + xlen - 1);
return ncplane_rounded_box(n, attr, channels, y + ylen - 1,
x + xlen - 1, ctlword);
}
static inline int
@ -696,13 +720,13 @@ cells_double_box(struct ncplane* n, uint32_t attr, uint64_t channels,
static inline int
ncplane_double_box(struct ncplane* n, uint32_t attr, uint64_t channels,
int ystop, int xstop){
int ystop, int xstop, unsigned ctlword){
int ret = 0;
cell ul = CELL_TRIVIAL_INITIALIZER, ur = CELL_TRIVIAL_INITIALIZER;
cell ll = CELL_TRIVIAL_INITIALIZER, lr = CELL_TRIVIAL_INITIALIZER;
cell hl = CELL_TRIVIAL_INITIALIZER, vl = CELL_TRIVIAL_INITIALIZER;
if((ret = cells_double_box(n, attr, channels, &ul, &ur, &ll, &lr, &hl, &vl)) == 0){
ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop);
ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop, ctlword);
}
cell_release(n, &ul);
cell_release(n, &ur);
@ -715,10 +739,11 @@ ncplane_double_box(struct ncplane* n, uint32_t attr, uint64_t channels,
static inline int
ncplane_double_box_sized(struct ncplane* n, uint32_t attr, uint64_t channels,
int ylen, int xlen){
int ylen, int xlen, unsigned ctlword){
int y, x;
ncplane_cursor_yx(n, &y, &x);
return ncplane_double_box(n, attr, channels, y + ylen - 1, x + xlen - 1);
return ncplane_double_box(n, attr, channels, y + ylen - 1,
x + xlen - 1, ctlword);
}
// multimedia functionality
@ -757,13 +782,6 @@ API int ncvisual_stream(struct notcurses* nc, struct ncvisual* ncv, int* averr);
// This structure is amenable to line- and page-based navigation via keystrokes,
// scrolling gestures, trackballs, scrollwheels, touchpads, and verbal commands.
enum bordermaskbits {
BORDERMASK_TOP = 0x1,
BORDERMASK_RIGHT = 0x2,
BORDERMASK_BOTTOM = 0x4,
BORDERMASK_LEFT = 0x8,
};
typedef struct panelreel_options {
// require this many rows and columns (including borders). otherwise, a
// message will be displayed stating that a larger terminal is necessary, and

2
src/demo/boxdemo.c
View File

@ -32,7 +32,7 @@ int box_demo(struct notcurses* nc){
if(ncplane_cursor_move_yx(n, y, x)){
return -1;
}
if(ncplane_box_sized(n, &ul, &ur, &ll, &lr, &hl, &vl, ylen, xlen)){
if(ncplane_box_sized(n, &ul, &ur, &ll, &lr, &hl, &vl, ylen, xlen, 0)){
return -1;
}
ylen -= 2;

2
src/demo/demo.c
View File

@ -142,7 +142,7 @@ intro(struct notcurses* nc){
if(ncplane_cursor_move_yx(ncp, 4, 4)){
return -1;
}
if(ncplane_rounded_box(ncp, 0, channels, rows - 6, cols - 6)){
if(ncplane_rounded_box(ncp, 0, channels, rows - 6, cols - 6, 0)){
return -1;
}
const char s1[] = " Die Welt ist alles, was der Fall ist. ";

2
src/demo/maxcolor.c
View File

@ -38,7 +38,7 @@ int maxcolor_demo(struct notcurses* nc){
notcurses_bg_prep(&channels, 90, 0, 90);
int y = 0, x = 0;
ncplane_cursor_move_yx(n, y, x);
if(ncplane_rounded_box_sized(n, 0, channels, maxy, maxx)){
if(ncplane_rounded_box_sized(n, 0, channels, maxy, maxx, 0)){
return -1;
}
uint32_t rgb = 0;

4
src/demo/sliding.c
View File

@ -102,7 +102,7 @@ fill_chunk(struct ncplane* n, int idx){
uint64_t channels = 0;
int r = random() % 256, g = random() % 256, b = random() % 256;
notcurses_fg_prep(&channels, r, g, b);
if(ncplane_double_box(n, 0, channels, maxy - 1, maxx - 1)){
if(ncplane_double_box(n, 0, channels, maxy - 1, maxx - 1, 0)){
return -1;
}
if(maxx >= 5 && maxy >= 3){
@ -131,7 +131,7 @@ draw_bounding_box(struct ncplane* n, int yoff, int xoff, int chunky, int chunkx)
ncplane_cursor_move_yx(n, yoff, xoff);
ret = ncplane_rounded_box(n, 0, channels,
CHUNKS_VERT * chunky + yoff + 1,
CHUNKS_HORZ * chunkx + xoff + 1);
CHUNKS_HORZ * chunkx + xoff + 1, 0);
return ret;
}

2
src/demo/unicodeblocks.c
View File

@ -109,7 +109,7 @@ int unicodeblocks_demo(struct notcurses* nc){
return -1;
}
++xstart;
if(ncplane_rounded_box_sized(n, 0, 0, BLOCKSIZE / CHUNKSIZE + 2, (CHUNKSIZE * 2) + 2)){
if(ncplane_rounded_box_sized(n, 0, 0, BLOCKSIZE / CHUNKSIZE + 2, (CHUNKSIZE * 2) + 2, 0)){
return -1;
}
for(chunk = 0 ; chunk < BLOCKSIZE / CHUNKSIZE ; ++chunk){

2
src/demo/widecolor.c
View File

@ -13,7 +13,7 @@ message(struct ncplane* n, int maxy, int maxx, int num, int total){
ncplane_fg_rgb8(n, 0, 0, 0);
ncplane_bg_rgb8(n, 255, 255, 255);
ncplane_styles_on(n, CELL_STYLE_BOLD);
if(ncplane_rounded_box(n, 0, 0, 5, 57)){
if(ncplane_rounded_box(n, 0, 0, 5, 57, 0)){
return -1;
}
ncplane_cursor_move_yx(n, 3, 4);

3
src/lib/notcurses.c
View File

@ -1436,7 +1436,8 @@ int ncplane_vline(ncplane* n, const cell* c, int len){
int ncplane_box(ncplane* n, const cell* ul, const cell* ur,
const cell* ll, const cell* lr, const cell* hl,
const cell* vl, int ystop, int xstop){
const cell* vl, int ystop, int xstop,
unsigned ctlword){
int yoff, xoff, ymax, xmax;
ncplane_cursor_yx(n, &yoff, &xoff);
if(ystop < yoff + 1){

56
src/lib/panelreel.c
View File

@ -81,17 +81,17 @@ draw_borders(ncplane* w, unsigned nobordermask, const cell* attr,
if(!cliphead){
// lenx - begx + 1 is the number of columns we have, but drop 2 due to
// corners. we thus want lenx - begx - 1 horizontal lines.
if(!(nobordermask & BORDERMASK_TOP)){
if(!(nobordermask & NCBOXMASK_TOP)){
ret |= ncplane_cursor_move_yx(w, begy, begx);
ncplane_putc(w, &ul);
ncplane_hline(w, &hl, lenx - 2);
ncplane_putc(w, &ur);
}else{
if(!(nobordermask & BORDERMASK_LEFT)){
if(!(nobordermask & NCBOXMASK_LEFT)){
ret |= ncplane_cursor_move_yx(w, begy, begx);
ncplane_putc(w, &ul);
}
if(!(nobordermask & BORDERMASK_RIGHT)){
if(!(nobordermask & NCBOXMASK_RIGHT)){
ret |= ncplane_cursor_move_yx(w, begy, maxx);
ncplane_putc(w, &ur);
}
@ -99,27 +99,27 @@ draw_borders(ncplane* w, unsigned nobordermask, const cell* attr,
}
int y;
for(y = begy + !cliphead ; y < maxy + !!clipfoot ; ++y){
if(!(nobordermask & BORDERMASK_LEFT)){
if(!(nobordermask & NCBOXMASK_LEFT)){
ret |= ncplane_cursor_move_yx(w, y, begx);
ncplane_putc(w, &vl);
}
if(!(nobordermask & BORDERMASK_RIGHT)){
if(!(nobordermask & NCBOXMASK_RIGHT)){
ret |= ncplane_cursor_move_yx(w, y, maxx);
ncplane_putc(w, &vl);
}
}
if(!clipfoot){
if(!(nobordermask & BORDERMASK_BOTTOM)){
if(!(nobordermask & NCBOXMASK_BOTTOM)){
ret |= ncplane_cursor_move_yx(w, maxy, begx);
ncplane_putc(w, &ll);
ncplane_hline(w, &hl, lenx - 2);
ncplane_putc(w, &lr);
}else{
if(!(nobordermask & BORDERMASK_LEFT)){
if(!(nobordermask & NCBOXMASK_LEFT)){
ret |= ncplane_cursor_move_yx(w, maxy, begx);
ret |= ncplane_putc(w, &ll);
}
if(!(nobordermask & BORDERMASK_RIGHT)){
if(!(nobordermask & NCBOXMASK_RIGHT)){
// mvwadd_wch returns error if we print to the lowermost+rightmost
// character cell. maybe we can make this go away with scrolling controls
// at setup? until then, don't check for error here FIXME.
@ -164,9 +164,9 @@ tablet_columns(const panelreel* pr, int* begx, int* begy, int* lenx, int* leny,
int frontiery, int direction){
window_coordinates(pr->p, begy, begx, leny, lenx);
int maxy = *leny + *begy - 1;
int begindraw = *begy + !(pr->popts.bordermask & BORDERMASK_TOP);
int begindraw = *begy + !(pr->popts.bordermask & NCBOXMASK_TOP);
// FIXME i think this fails to account for an absent panelreel bottom?
int enddraw = maxy - !(pr->popts.bordermask & BORDERMASK_TOP);
int enddraw = maxy - !(pr->popts.bordermask & NCBOXMASK_TOP);
if(direction){
if(frontiery < begindraw){
return -1;
@ -177,18 +177,18 @@ tablet_columns(const panelreel* pr, int* begx, int* begy, int* lenx, int* leny,
}
}
// account for the panelreel borders
if(direction <= 0 && !(pr->popts.bordermask & BORDERMASK_TOP)){
if(direction <= 0 && !(pr->popts.bordermask & NCBOXMASK_TOP)){
++*begy;
--*leny;
}
if(direction >= 0 && !(pr->popts.bordermask & BORDERMASK_BOTTOM)){
if(direction >= 0 && !(pr->popts.bordermask & NCBOXMASK_BOTTOM)){
--*leny;
}
if(!(pr->popts.bordermask & BORDERMASK_LEFT)){
if(!(pr->popts.bordermask & NCBOXMASK_LEFT)){
++*begx;
--*lenx;
}
if(!(pr->popts.bordermask & BORDERMASK_RIGHT)){
if(!(pr->popts.bordermask & NCBOXMASK_RIGHT)){
--*lenx;
}
// at this point, our coordinates describe the largest possible tablet for
@ -265,16 +265,16 @@ panelreel_draw_tablet(const panelreel* pr, tablet* t, int frontiery,
--cbmaxy;
--cbmaxx;
// If we're drawing up, we'll always have a bottom border unless it's masked
if(direction < 0 && !(pr->popts.tabletmask & BORDERMASK_BOTTOM)){
if(direction < 0 && !(pr->popts.tabletmask & NCBOXMASK_BOTTOM)){
--cbmaxy;
}
// If we're drawing down, we'll always have a top border unless it's masked
if(direction >= 0 && !(pr->popts.tabletmask & BORDERMASK_TOP)){
if(direction >= 0 && !(pr->popts.tabletmask & NCBOXMASK_TOP)){
++cby;
}
// Adjust the x-bounds for side borders, which we always have if unmasked
cbmaxx -= !(pr->popts.tabletmask & BORDERMASK_RIGHT);
cbx += !(pr->popts.tabletmask & BORDERMASK_LEFT);
cbmaxx -= !(pr->popts.tabletmask & NCBOXMASK_RIGHT);
cbx += !(pr->popts.tabletmask & NCBOXMASK_LEFT);
bool cbdir = direction < 0 ? true : false;
// fprintf(stderr, "calling! lenx/leny: %d/%d cbx/cby: %d/%d cbmaxx/cbmaxy: %d/%d dir: %d\n",
// lenx, leny, cbx, cby, cbmaxx, cbmaxy, direction);
@ -331,9 +331,9 @@ draw_focused_tablet(const panelreel* pr){
int fulcrum;
if(pr->tablets->p == NULL){
if(pr->last_traveled_direction >= 0){
fulcrum = pleny + pbegy - !(pr->popts.bordermask & BORDERMASK_BOTTOM);
fulcrum = pleny + pbegy - !(pr->popts.bordermask & NCBOXMASK_BOTTOM);
}else{
fulcrum = pbegy + !(pr->popts.bordermask & BORDERMASK_TOP);
fulcrum = pbegy + !(pr->popts.bordermask & NCBOXMASK_TOP);
}
}else{ // focused was already present. want to stay where we are, if possible
int dontcarex;
@ -344,7 +344,7 @@ draw_focused_tablet(const panelreel* pr){
int prevfulcrum;
ncplane_yx(pr->tablets->prev->p, &prevfulcrum, &dontcarex);
if(fulcrum < prevfulcrum){
fulcrum = pleny + pbegy - !(pr->popts.bordermask & BORDERMASK_BOTTOM);
fulcrum = pleny + pbegy - !(pr->popts.bordermask & NCBOXMASK_BOTTOM);
}
}
}else if(pr->last_traveled_direction < 0){
@ -352,7 +352,7 @@ draw_focused_tablet(const panelreel* pr){
int nextfulcrum;
ncplane_yx(pr->tablets->next->p, &nextfulcrum, &dontcarex);
if(fulcrum > nextfulcrum){
fulcrum = pbegy + !(pr->popts.bordermask & BORDERMASK_TOP);
fulcrum = pbegy + !(pr->popts.bordermask & NCBOXMASK_TOP);
}
}
}
@ -452,7 +452,7 @@ panelreel_arrange_denormalized(panelreel* pr){
tablet* topmost = find_topmost(pr);
int wbegy, wbegx, wleny, wlenx;
window_coordinates(pr->p, &wbegy, &wbegx, &wleny, &wlenx);
int frontiery = wbegy + !(pr->popts.bordermask & BORDERMASK_TOP);
int frontiery = wbegy + !(pr->popts.bordermask & NCBOXMASK_TOP);
if(pr->last_traveled_direction >= 0){
ncplane_yx(pr->tablets->prev->p, &fromline, NULL);
if(fromline > nowline){ // keep the order we had
@ -538,10 +538,10 @@ validate_panelreel_opts(ncplane* w, const panelreel_options* popts){
return false; // can't set circular without infinitescroll
}
}
const unsigned fullmask = BORDERMASK_LEFT |
BORDERMASK_RIGHT |
BORDERMASK_TOP |
BORDERMASK_BOTTOM;
const unsigned fullmask = NCBOXMASK_LEFT |
NCBOXMASK_RIGHT |
NCBOXMASK_TOP |
NCBOXMASK_BOTTOM;
if(popts->bordermask > fullmask){
return false;
}
@ -617,7 +617,7 @@ insert_new_panel(struct notcurses* nc, panelreel* pr, tablet* t){
// are we the only tablet?
int begx, begy, lenx, leny, frontiery;
if(t->prev == t){
frontiery = wbegy + !(pr->popts.bordermask & BORDERMASK_TOP);
frontiery = wbegy + !(pr->popts.bordermask & NCBOXMASK_TOP);
if(tablet_columns(pr, &begx, &begy, &lenx, &leny, frontiery, 1)){
pr->all_visible = false;
return t;

20
tests/ncplane.cpp
View File

@ -176,17 +176,17 @@ TEST_F(NcplaneTest, BadlyPlacedBoxen) {
ASSERT_LT(2, x);
cell ul{}, ll{}, lr{}, ur{}, hl{}, vl{};
ASSERT_EQ(0, cells_rounded_box(n_, 0, 0, &ul, &ur, &ll, &lr, &hl, &vl));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, y + 1, x + 1));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, y + 1, x + 1, 0));
EXPECT_EQ(0, ncplane_cursor_move_yx(n_, 1, 0));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, y, x));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, y, x, 0));
EXPECT_EQ(0, ncplane_cursor_move_yx(n_, 0, 1));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, y, x));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, y, x, 0));
EXPECT_EQ(0, ncplane_cursor_move_yx(n_, y - 1, x - 1));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, 2, 2));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, 2, 2, 0));
EXPECT_EQ(0, ncplane_cursor_move_yx(n_, y - 2, x - 1));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, 2, 2));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, 2, 2, 0));
EXPECT_EQ(0, ncplane_cursor_move_yx(n_, y - 1, x - 2));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, 2, 2));
EXPECT_GT(0, ncplane_box(n_, &ul, &ur, &ll, &lr, &hl, &vl, 2, 2, 0));
EXPECT_EQ(0, notcurses_render(nc_));
}
@ -196,7 +196,7 @@ TEST_F(NcplaneTest, PerimeterRoundedBox) {
ASSERT_LT(2, y);
ASSERT_LT(2, x);
ASSERT_EQ(0, ncplane_cursor_move_yx(n_, 0, 0));
EXPECT_EQ(0, ncplane_rounded_box(n_, 0, 0, y - 1, x - 1));
EXPECT_EQ(0, ncplane_rounded_box(n_, 0, 0, y - 1, x - 1, 0));
EXPECT_EQ(0, notcurses_render(nc_));
}
@ -206,7 +206,7 @@ TEST_F(NcplaneTest, PerimeterRoundedBoxSized) {
ASSERT_LT(2, y);
ASSERT_LT(2, x);
ASSERT_EQ(0, ncplane_cursor_move_yx(n_, 0, 0));
EXPECT_EQ(0, ncplane_rounded_box_sized(n_, 0, 0, y, x));
EXPECT_EQ(0, ncplane_rounded_box_sized(n_, 0, 0, y, x, 0));
EXPECT_EQ(0, notcurses_render(nc_));
}
@ -216,7 +216,7 @@ TEST_F(NcplaneTest, PerimeterDoubleBox) {
ASSERT_LT(2, y);
ASSERT_LT(2, x);
ASSERT_EQ(0, ncplane_cursor_move_yx(n_, 0, 0));
EXPECT_EQ(0, ncplane_double_box(n_, 0, 0, y - 1, x - 1));
EXPECT_EQ(0, ncplane_double_box(n_, 0, 0, y - 1, x - 1, 0));
EXPECT_EQ(0, notcurses_render(nc_));
}
@ -226,7 +226,7 @@ TEST_F(NcplaneTest, PerimeterDoubleBoxSized) {
ASSERT_LT(2, y);
ASSERT_LT(2, x);
ASSERT_EQ(0, ncplane_cursor_move_yx(n_, 0, 0));
EXPECT_EQ(0, ncplane_double_box_sized(n_, 0, 0, y, x));
EXPECT_EQ(0, ncplane_double_box_sized(n_, 0, 0, y, x, 0));
EXPECT_EQ(0, notcurses_render(nc_));
}

16
tests/panelreel.cpp
View File

@ -126,30 +126,30 @@ TEST_F(PanelReelTest, DeleteActiveTablet) {
TEST_F(PanelReelTest, NoBorder) {
panelreel_options p{};
p.bordermask = BORDERMASK_LEFT | BORDERMASK_RIGHT |
BORDERMASK_TOP | BORDERMASK_BOTTOM;
p.bordermask = NCBOXMASK_LEFT | NCBOXMASK_RIGHT |
NCBOXMASK_TOP | NCBOXMASK_BOTTOM;
struct panelreel* pr = panelreel_create(n_, &p, -1);
ASSERT_NE(nullptr, pr);
}
TEST_F(PanelReelTest, BadBorderBitsRejected) {
panelreel_options p{};
p.bordermask = BORDERMASK_LEFT * 2;
p.bordermask = NCBOXMASK_LEFT * 2;
struct panelreel* pr = panelreel_create(n_, &p, -1);
ASSERT_EQ(nullptr, pr);
}
TEST_F(PanelReelTest, NoTabletBorder) {
panelreel_options p{};
p.tabletmask = BORDERMASK_LEFT | BORDERMASK_RIGHT |
BORDERMASK_TOP | BORDERMASK_BOTTOM;
p.tabletmask = NCBOXMASK_LEFT | NCBOXMASK_RIGHT |
NCBOXMASK_TOP | NCBOXMASK_BOTTOM;
struct panelreel* pr = panelreel_create(n_, &p, -1);
ASSERT_NE(nullptr, pr);
}
TEST_F(PanelReelTest, BadTabletBorderBitsRejected) {
panelreel_options p{};
p.tabletmask = BORDERMASK_LEFT * 2;
p.tabletmask = NCBOXMASK_LEFT * 2;
struct panelreel* pr = panelreel_create(n_, &p, -1);
ASSERT_EQ(nullptr, pr);
}
@ -201,8 +201,8 @@ TEST_F(PanelReelTest, SubwinNoPanelreelBorders) {
p.roff = 1;
p.toff = 1;
p.boff = 1;
p.bordermask = BORDERMASK_LEFT | BORDERMASK_RIGHT |
BORDERMASK_TOP | BORDERMASK_BOTTOM;
p.bordermask = NCBOXMASK_LEFT | NCBOXMASK_RIGHT |
NCBOXMASK_TOP | NCBOXMASK_BOTTOM;
EXPECT_EQ(0, clear());
PANEL* base = make_targwin(n_);
ASSERT_NE(nullptr, base);