void ResizeLayer(Layer *l, int wi, int he, Display *norefdisp)
{
Window *p;
Canvas *cv;
Layer *oldflayer = flayer;
Display *d, *olddisplay = display;
if (l->l_width == wi && l->l_height == he)
return;
p = Layer2Window(l);
/* If 'flayer' and 'l' are for the same window, then we will not
* restore 'flayer'. */
if (oldflayer && (l == oldflayer || Layer2Window(oldflayer) == p))
oldflayer = NULL;
flayer = l;
if (p) {
/* It's a window layer. Kill the overlays on it in all displays. */
for (d = displays; d; d = d->d_next)
for (cv = d->d_cvlist; cv; cv = cv->c_next) {
if (p == Layer2Window(cv->c_layer)) {
/* Canvas 'cv' on display 'd' shows this window. Remove any non-resizable
* layers over it. */
RESIZE_OR_KILL_LAYERS(cv->c_layer, wi, he);
}
}
} else {
/* It's a Blank layer. Just kill the non-resizable overlays over it. */
RESIZE_OR_KILL_LAYERS(flayer, wi, he);
}
for (display = displays; display; display = display->d_next) {
if (display == norefdisp)
continue;
for (cv = D_cvlist; cv; cv = cv->c_next)
if (Layer2Window(cv->c_layer) == p) {
CV_CALL(cv, LayRedisplayLine(-1, -1, -1, 0));
RefreshArea(cv->c_xs, cv->c_ys, cv->c_xe, cv->c_ye, 0);
}
if (D_kaablamm) {
kaablamm();
D_kaablamm = 0;
}
}
/* If we started resizing a non-flayer layer, then restore the flayer.
* Otherwise, flayer should already be updated to the topmost foreground layer. */
if (oldflayer)
flayer = oldflayer;
display = olddisplay;
}
void
UpdateLayoutCanvas(struct canvas *cv, struct win *wi)
{
for (; cv; cv = cv->c_slnext)
{
if (cv->c_layer && Layer2Window(cv->c_layer) == wi)
{
/* A simplistic version of SetCanvasWindow(cv, 0) */
struct layer *l = cv->c_layer;
cv->c_layer = 0;
if (l->l_cvlist == 0 && (wi == 0 || l != wi->w_savelayer))
KillLayerChain(l);
l = &cv->c_blank;
l->l_data = 0;
if (l->l_cvlist != cv)
{
cv->c_lnext = l->l_cvlist;
l->l_cvlist = cv;
}
cv->c_layer = l;
/* Do not end here. Multiple canvases can have the same window */
}
if (cv->c_slperp)
UpdateLayoutCanvas(cv->c_slperp, wi);
}
}
void ExitOverlayPage(void)
{
Layer *oldlay;
Window *p;
int doredisplay = 0;
Canvas *cv, *ocv;
Layout *lay;
oldlay = flayer;
if (oldlay->l_data) {
if (oldlay->l_layfn->lf_LayFree)
LayFree(oldlay->l_data);
free(oldlay->l_data);
}
p = Layer2Window(flayer);
flayer = oldlay->l_next;
if (flayer->l_layfn == &WinLf) {
if (oldlay->l_blocking) {
p->w_blocked--;
}
/* don't warp dead layers: check cvlist */
if (p->w_blocked && p->w_savelayer && p->w_savelayer != flayer && oldlay->l_cvlist) {
/* warp ourself into savelayer */
flayer = p->w_savelayer;
doredisplay = 1;
}
}
if (p && p->w_savelayer == oldlay)
p->w_savelayer = flayer;
if (p && oldlay == p->w_paster.pa_pastelayer)
p->w_paster.pa_pastelayer = NULL;
for (lay = layouts; lay; lay = lay->lay_next)
for (cv = lay->lay_cvlist; cv; cv = cv->c_next)
if (cv->c_layer == oldlay)
cv->c_layer = flayer;
/* add all canvases back into next layer's canvas list */
for (ocv = NULL, cv = oldlay->l_cvlist; cv; cv = cv->c_lnext) {
cv->c_layer = flayer;
ocv = cv;
}
if (ocv) {
cv = flayer->l_cvlist;
ocv->c_lnext = NULL;
flayer->l_cvlist = oldlay->l_cvlist;
/* redisplay only the warped cvs */
if (doredisplay)
LRefreshAll(flayer, 0);
ocv->c_lnext = cv;
}
oldlay->l_cvlist = NULL;
LayerCleanupMemory(oldlay);
free((char *)oldlay);
LayRestore();
LaySetCursor();
}
void
ChangeScreenSize(int wi, int he, int change_fore)
{
struct win *p;
struct canvas *cv;
int wwi;
debug2("ChangeScreenSize from (%d,%d) ", D_width, D_height);
debug3("to (%d,%d) (change_fore: %d)\n",wi, he, change_fore);
cv = &D_canvas;
cv->c_xe = wi - 1;
cv->c_ys = (D_has_hstatus == HSTATUS_FIRSTLINE);
cv->c_ye = he - 1 - ((cv->c_slperp && cv->c_slperp->c_slnext) || captionalways) - (D_has_hstatus == HSTATUS_LASTLINE);
cv->c_blank.l_height = cv->c_ye - cv->c_ys + 1;
if (cv->c_slperp)
{
ResizeCanvas(cv);
RecreateCanvasChain();
RethinkDisplayViewports();
}
if (D_forecv == 0)
D_forecv = D_cvlist;
if (D_forecv)
D_fore = Layer2Window(D_forecv->c_layer);
D_width = wi;
D_height = he;
CheckMaxSize(wi);
if (D_CWS)
{
D_defwidth = D_CO;
D_defheight = D_LI;
}
else
{
if (D_CZ0 && (wi == Z0width || wi == Z1width) &&
(D_CO == Z0width || D_CO == Z1width))
D_defwidth = D_CO;
else
D_defwidth = wi;
D_defheight = he;
}
debug2("Default size: (%d,%d)\n", D_defwidth, D_defheight);
if (change_fore)
ResizeLayersToCanvases();
if (change_fore == 2 && D_CWS == NULL && displays->d_next == 0)
{
/* adapt all windows - to be removed ? */
for (p = windows; p; p = p->w_next)
{
debug1("Trying to change window %d.\n", p->w_number);
wwi = wi;
if (p->w_savelayer && p->w_savelayer->l_cvlist == 0)
ResizeLayer(p->w_savelayer, wwi, he, 0);
}
}
}
void MakePaster(struct paster *pa, char *buf, int len, int bufiscopy)
{
FreePaster(pa);
pa->pa_pasteptr = buf;
pa->pa_pastelen = len;
if (bufiscopy)
pa->pa_pastebuf = buf;
pa->pa_pastelayer = flayer;
DoProcess(Layer2Window(flayer), &pa->pa_pasteptr, &pa->pa_pastelen, pa);
}
void RemCanvas()
{
int ye;
struct canvas *cv;
debug("RemCanvas\n");
cv = D_forecv;
if (cv->c_slorient == SLICE_UNKN)
return;
while (cv->c_slprev)
cv = cv->c_slprev;
if (!cv->c_slnext)
return;
if (!cv->c_slnext->c_slnext && cv->c_slback->c_slback) {
/* two canvases in slice, kill perp node */
cv = D_forecv;
debug("deleting perp node\n");
FreePerp(cv->c_slprev ? cv->c_slprev : cv->c_slnext);
FreePerp(cv->c_slback);
}
ye = cv->c_slback->c_ye;
/* free canvas */
cv = D_forecv;
D_forecv = cv->c_slprev;
if (!D_forecv)
D_forecv = cv->c_slnext;
FreeCanvas(cv);
cv = D_forecv;
while (D_forecv->c_slperp)
D_forecv = D_forecv->c_slperp;
/* if only one canvas left, set orient back to unknown */
if (!cv->c_slnext && !cv->c_slprev && !cv->c_slback->c_slback && !cv->c_slperp) {
cv->c_slorient = SLICE_UNKN;
if (!captionalways)
cv->c_slback->c_ye = ++ye; /* caption line no longer needed */
}
cv = cv->c_slback;
EqualizeCanvas(cv->c_slperp, 0);
ResizeCanvas(cv);
D_fore = Layer2Window(D_forecv->c_layer);
flayer = D_forecv->c_layer;
RecreateCanvasChain();
RethinkDisplayViewports();
ResizeLayersToCanvases();
}
void FreeCanvas(struct canvas *cv)
{
struct viewport *vp, *nvp;
struct canvas **cvp;
struct win *p;
if (cv->c_slprev)
cv->c_slprev->c_slnext = cv->c_slnext;
if (cv->c_slnext)
cv->c_slnext->c_slprev = cv->c_slprev;
if (cv->c_slback && cv->c_slback->c_slperp == cv)
cv->c_slback->c_slperp = cv->c_slnext ? cv->c_slnext : cv->c_slprev;
if (cv->c_slperp) {
while (cv->c_slperp)
FreeCanvas(cv->c_slperp);
LayerCleanupMemory(&cv->c_blank);
free(cv);
return;
}
if (display) {
if (D_forecv == cv)
D_forecv = 0;
/* remove from canvas chain as SetCanvasWindow might call
* some layer function */
for (cvp = &D_cvlist; *cvp; cvp = &(*cvp)->c_next)
if (*cvp == cv) {
*cvp = cv->c_next;
break;
}
}
p = cv->c_layer ? Layer2Window(cv->c_layer) : 0;
SetCanvasWindow(cv, 0);
if (p)
WindowChanged(p, 'u');
if (flayer == cv->c_layer)
flayer = 0;
for (vp = cv->c_vplist; vp; vp = nvp) {
vp->v_canvas = 0;
nvp = vp->v_next;
vp->v_next = 0;
free(vp);
}
evdeq(&cv->c_captev);
LayerCleanupMemory(&cv->c_blank);
free(cv);
}
void ChangeScreenSize(int wi, int he, int change_fore)
{
Window *p;
Canvas *cv;
int wwi;
cv = &D_canvas;
cv->c_xe = wi - 1;
cv->c_ys = ((cv->c_slperp && cv->c_slperp->c_slnext) || captionalways) * captiontop + (D_has_hstatus == HSTATUS_FIRSTLINE);
cv->c_ye = he - 1 - ((cv->c_slperp && cv->c_slperp->c_slnext)
|| captionalways) * !captiontop - (D_has_hstatus == HSTATUS_LASTLINE);
cv->c_blank.l_height = cv->c_ye - cv->c_ys + 1;
if (cv->c_slperp) {
ResizeCanvas(cv);
RecreateCanvasChain();
RethinkDisplayViewports();
}
if (D_forecv == 0)
D_forecv = D_cvlist;
if (D_forecv)
D_fore = Layer2Window(D_forecv->c_layer);
D_width = wi;
D_height = he;
CheckMaxSize(wi);
if (D_CWS) {
D_defwidth = D_CO;
D_defheight = D_LI;
} else {
if (D_CZ0 && (wi == Z0width || wi == Z1width) && (D_CO == Z0width || D_CO == Z1width))
D_defwidth = D_CO;
else
D_defwidth = wi;
D_defheight = he;
}
if (change_fore)
ResizeLayersToCanvases();
if (change_fore == 2 && D_CWS == NULL && displays->d_next == 0) {
/* adapt all windows - to be removed ? */
for (p = windows; p; p = p->w_next) {
wwi = wi;
if (p->w_savelayer && p->w_savelayer->l_cvlist == 0)
ResizeLayer(p->w_savelayer, wwi, he, 0);
}
}
}
void DupLayoutCv(struct canvas *cvf, struct canvas *cvt, int save)
{
while (cvf) {
cvt->c_slorient = cvf->c_slorient;
cvt->c_slweight = cvf->c_slweight;
if (cvf == D_forecv)
D_forecv = cvt;
if (!save) {
cvt->c_display = display;
if (!cvf->c_slperp) {
cvt->c_captev.type = EV_TIMEOUT;
cvt->c_captev.data = (char *)cvt;
cvt->c_captev.handler = NULL;
cvt->c_blank.l_cvlist = 0;
cvt->c_blank.l_layfn = &BlankLf;
cvt->c_blank.l_bottom = &cvt->c_blank;
}
cvt->c_layer = cvf->c_layer;
} else {
struct win *p = cvf->c_layer ? Layer2Window(cvf->c_layer) : 0;
cvt->c_layer = p ? &p->w_layer : 0;
}
if (cvf->c_slperp) {
cvt->c_slperp = calloc(1, sizeof(struct canvas));
cvt->c_slperp->c_slback = cvt;
CanvasInitBlank(cvt->c_slperp);
DupLayoutCv(cvf->c_slperp, cvt->c_slperp, save);
}
if (cvf->c_slnext) {
cvt->c_slnext = calloc(1, sizeof(struct canvas));
cvt->c_slnext->c_slprev = cvt;
cvt->c_slnext->c_slback = cvt->c_slback;
CanvasInitBlank(cvt->c_slnext);
}
cvf = cvf->c_slnext;
cvt = cvt->c_slnext;
}
}
void SetCanvasWindow(struct canvas *cv, struct win *win)
{
struct win *p = 0, **pp;
struct layer *l;
struct canvas *cvp, **cvpp;
l = cv->c_layer;
display = cv->c_display;
if (l) {
/* remove old layer */
for (cvpp = &l->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
if (cvp == cv)
break;
ASSERT(cvp);
*cvpp = cvp->c_lnext;
p = Layer2Window(l);
l = cv->c_layer;
cv->c_layer = 0;
if (p && cv == D_forecv) {
if (p->w_silence) {
SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
evenq(&p->w_silenceev);
}
D_other = fore;
D_fore = 0;
}
if (l->l_cvlist == 0 && (p == 0 || l != p->w_savelayer))
KillLayerChain(l);
}
/* find right layer to display on canvas */
if (win && win->w_type != W_TYPE_GROUP) {
l = &win->w_layer;
if (win->w_savelayer && (win->w_blocked || win->w_savelayer->l_cvlist == 0))
l = win->w_savelayer;
} else {
l = &cv->c_blank;
if (win)
l->l_data = (char *)win;
else
l->l_data = 0;
}
/* add our canvas to the layer's canvaslist */
ASSERT(l->l_cvlist != cv);
cv->c_lnext = l->l_cvlist;
l->l_cvlist = cv;
cv->c_layer = l;
cv->c_xoff = cv->c_xs;
cv->c_yoff = cv->c_ys;
RethinkViewportOffsets(cv);
if (flayer == 0)
flayer = l;
if (win && win->w_type == W_TYPE_GROUP) {
/* auto-start windowlist on groups */
struct display *d = display;
struct layer *oldflayer = flayer;
flayer = l;
display_windows(0, 0, win);
flayer = oldflayer;
display = d;
}
if (win && D_other == win)
D_other = win->w_next; /* Might be 0, but that's OK. */
if (cv == D_forecv) {
D_fore = win;
fore = D_fore; /* XXX ? */
if (win) {
/*
* Place the window at the head of the most-recently-used list
*/
if (windows != win) {
for (pp = &windows; (p = *pp); pp = &p->w_next)
if (p == win)
break;
ASSERT(p);
*pp = p->w_next;
p->w_next = windows;
windows = p;
WListLinkChanged();
}
}
}
}
int InitOverlayPage(int datasize, const struct LayFuncs *lf, int block)
{
char *data;
Layer *newlay;
Canvas *cv, *cvp, **cvpp;
Window *win;
cv = NULL;
if (display && D_forecv->c_layer == flayer)
cv = D_forecv; /* work only on this cv! */
if ((newlay = calloc(1, sizeof(Layer))) == NULL) {
Msg(0, "No memory for layer struct");
return -1;
}
data = NULL;
if (datasize) {
if ((data = calloc(1, datasize)) == NULL) {
free((char *)newlay);
Msg(0, "No memory for layer data");
return -1;
}
}
win = Layer2Window(flayer);
if (win && (win->w_savelayer == flayer || (block && flayer->l_next == NULL))) {
if (win->w_savelayer && win->w_savelayer != flayer && win->w_savelayer->l_cvlist == NULL)
KillLayerChain(win->w_savelayer);
win->w_savelayer = newlay;
}
if (cv && flayer->l_next == NULL && !block) {
Display *olddisplay = display;
display = cv->c_display;
RemoveStatus();
display = olddisplay;
/* new branch -> just get canvas vps */
for (cvpp = &flayer->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
if (cvp == cv)
break;
*cvpp = cv->c_lnext;
newlay->l_cvlist = cv;
cv->c_lnext = NULL;
cv->c_layer = newlay;
} else {
LAY_DISPLAYS(flayer, RemoveStatus());
if (block && flayer->l_layfn == &WinLf) {
if (win)
win->w_blocked++;
newlay->l_blocking = 1;
}
/* change all canvases */
newlay->l_cvlist = flayer->l_cvlist;
for (cvp = newlay->l_cvlist; cvp; cvp = cvp->c_lnext)
cvp->c_layer = newlay;
flayer->l_cvlist = NULL;
}
newlay->l_width = flayer->l_width;
newlay->l_height = flayer->l_height;
newlay->l_encoding = 0;
newlay->l_layfn = lf;
newlay->l_data = data;
newlay->l_next = flayer;
newlay->l_bottom = flayer->l_bottom;
flayer = newlay;
LayRestore();
return 0;
}
