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; }