void win_pair_redraw(window_t *win) { window_pair_t *dwin; if (!win) return; dwin = win->data; gli_window_redraw(dwin->child1); gli_window_redraw(dwin->child2); }
void gli_windows_redraw() { int ix, jx; if (gli_rootwin) { /* We could draw a border around content_box, if we wanted. */ gli_window_redraw(gli_rootwin); } else { /* There are no windows at all. */ clear(); ix = (content_box.left+content_box.right) / 2 - 7; if (ix < 0) ix = 0; jx = (content_box.top+content_box.bottom) / 2; move(jx, ix); addstr("Please wait..."); } }
void glk_window_close(window_t *win, stream_result_t *result) { if (!win) { gli_strict_warning("window_close: invalid ref"); return; } if (win == gli_rootwin || win->parent == NULL) { /* close the root window, which means all windows. */ gli_rootwin = 0; /* begin (simpler) closation */ gli_stream_fill_result(win->str, result); gli_window_close(win, TRUE); /* redraw everything */ gli_windows_redraw(); } else { /* have to jigger parent */ grect_t box; window_t *pairwin, *sibwin, *grandparwin, *wx; window_pair_t *dpairwin, *dgrandparwin, *dwx; int keydamage_flag; pairwin = win->parent; dpairwin = pairwin->data; if (win == dpairwin->child1) { sibwin = dpairwin->child2; } else if (win == dpairwin->child2) { sibwin = dpairwin->child1; } else { gli_strict_warning("window_close: window tree is corrupted"); return; } box = pairwin->bbox; grandparwin = pairwin->parent; if (!grandparwin) { gli_rootwin = sibwin; sibwin->parent = NULL; } else { dgrandparwin = grandparwin->data; if (dgrandparwin->child1 == pairwin) dgrandparwin->child1 = sibwin; else dgrandparwin->child2 = sibwin; sibwin->parent = grandparwin; } /* Begin closation */ gli_stream_fill_result(win->str, result); /* Close the child window (and descendants), so that key-deletion can crawl up the tree to the root window. */ gli_window_close(win, TRUE); /* This probably isn't necessary, but the child *is* gone, so just in case. */ if (win == dpairwin->child1) { dpairwin->child1 = NULL; } else if (win == dpairwin->child2) { dpairwin->child2 = NULL; } /* Now we can delete the parent pair. */ gli_window_close(pairwin, FALSE); keydamage_flag = FALSE; for (wx=sibwin; wx; wx=wx->parent) { if (wx->type == wintype_Pair) { window_pair_t *dwx = wx->data; if (dwx->keydamage) { keydamage_flag = TRUE; dwx->keydamage = FALSE; } } } if (keydamage_flag) { box = content_box; gli_window_rearrange(gli_rootwin, &box); gli_windows_redraw(); } else { gli_window_rearrange(sibwin, &box); gli_window_redraw(sibwin); } } }
void glk_window_set_arrangement(window_t *win, glui32 method, glui32 size, winid_t key) { window_pair_t *dwin; glui32 newdir; grect_t box; int newvertical, newbackward; if (!win) { gli_strict_warning("window_set_arrangement: invalid ref"); return; } if (win->type != wintype_Pair) { gli_strict_warning("window_set_arrangement: not a Pair window"); return; } if (key) { window_t *wx; if (key->type == wintype_Pair) { gli_strict_warning("window_set_arrangement: keywin cannot be a Pair"); return; } for (wx=key; wx; wx=wx->parent) { if (wx == win) break; } if (wx == NULL) { gli_strict_warning("window_set_arrangement: keywin must be a descendant"); return; } } dwin = win->data; box = win->bbox; newdir = method & winmethod_DirMask; newvertical = (newdir == winmethod_Left || newdir == winmethod_Right); newbackward = (newdir == winmethod_Left || newdir == winmethod_Above); if (!key) key = dwin->key; if ((newvertical && !dwin->vertical) || (!newvertical && dwin->vertical)) { if (!dwin->vertical) gli_strict_warning("window_set_arrangement: split must stay horizontal"); else gli_strict_warning("window_set_arrangement: split must stay vertical"); return; } if (key && key->type == wintype_Blank && (method & winmethod_DivisionMask) == winmethod_Fixed) { gli_strict_warning("window_set_arrangement: a Blank window cannot have a fixed size"); return; } if ((newbackward && !dwin->backward) || (!newbackward && dwin->backward)) { /* switch the children */ window_t *tmpwin = dwin->child1; dwin->child1 = dwin->child2; dwin->child2 = tmpwin; } /* set up everything else */ dwin->dir = newdir; dwin->division = method & winmethod_DivisionMask; dwin->key = key; dwin->size = size; dwin->hasborder = ((method & winmethod_BorderMask) == winmethod_Border); dwin->vertical = (dwin->dir == winmethod_Left || dwin->dir == winmethod_Right); dwin->backward = (dwin->dir == winmethod_Left || dwin->dir == winmethod_Above); gli_window_rearrange(win, &box); gli_window_redraw(win); }
winid_t glk_window_open(winid_t splitwin, glui32 method, glui32 size, glui32 wintype, glui32 rock) { window_t *newwin, *pairwin, *oldparent; window_pair_t *dpairwin; grect_t box; glui32 val; if (!gli_rootwin) { if (splitwin) { gli_strict_warning("window_open: ref must be NULL"); return 0; } /* ignore method and size now */ oldparent = NULL; box = content_box; } else { if (!splitwin) { gli_strict_warning("window_open: ref must not be NULL"); return 0; } val = (method & winmethod_DivisionMask); if (val != winmethod_Fixed && val != winmethod_Proportional) { gli_strict_warning("window_open: invalid method (not fixed or proportional)"); return 0; } val = (method & winmethod_DirMask); if (val != winmethod_Above && val != winmethod_Below && val != winmethod_Left && val != winmethod_Right) { gli_strict_warning("window_open: invalid method (bad direction)"); return 0; } box = splitwin->bbox; oldparent = splitwin->parent; if (oldparent && oldparent->type != wintype_Pair) { gli_strict_warning("window_open: parent window is not Pair"); return 0; } } newwin = gli_new_window(wintype, rock); if (!newwin) { gli_strict_warning("window_open: unable to create window"); return 0; } switch (wintype) { case wintype_Blank: newwin->data = win_blank_create(newwin); break; case wintype_TextGrid: newwin->data = win_textgrid_create(newwin); break; case wintype_TextBuffer: newwin->data = win_textbuffer_create(newwin); break; case wintype_Pair: gli_strict_warning("window_open: cannot open pair window directly"); gli_delete_window(newwin); return 0; default: /* Unknown window type -- do not print a warning, just return 0 to indicate that it's not possible. */ gli_delete_window(newwin); return 0; } if (!newwin->data) { gli_strict_warning("window_open: unable to create window"); return 0; } if (!splitwin) { gli_rootwin = newwin; gli_window_rearrange(newwin, &box); /* redraw everything, which is just the new first window */ gli_windows_redraw(); } else { /* create pairwin, with newwin as the key */ pairwin = gli_new_window(wintype_Pair, 0); dpairwin = win_pair_create(pairwin, method, newwin, size); pairwin->data = dpairwin; dpairwin->child1 = splitwin; dpairwin->child2 = newwin; splitwin->parent = pairwin; newwin->parent = pairwin; pairwin->parent = oldparent; if (oldparent) { window_pair_t *dparentwin = oldparent->data; if (dparentwin->child1 == splitwin) dparentwin->child1 = pairwin; else dparentwin->child2 = pairwin; } else { gli_rootwin = pairwin; } gli_window_rearrange(pairwin, &box); /* redraw the new pairwin and all its contents */ gli_window_redraw(pairwin); } return newwin; }