/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* Copyright (c) 1988 AT&T */ /* All Rights Reserved */ /* * Copyright (c) 1997, by Sun Microsystems, Inc. * All rights reserved. */ /* A panels subsystem built on curses--Miscellaneous routines */ #pragma ident "%Z%%M% %I% %E% SMI" /* SVr4.0 1.4 */ /*LINTLIBRARY*/ #include <sys/types.h> #include <stdlib.h> #include <curses.h> #include "private.h" PANEL *_Bottom_panel; PANEL *_Top_panel; int _Panel_cnt; static _obscured_list *_Free_list; static int _Free_list_cnt; /* panel_window - Return the window pointer */ WINDOW * panel_window(PANEL *panel) { return (panel ? panel -> win : 0); } /* panel_userptr - Return the user pointer */ char * panel_userptr(PANEL *panel) { return (panel ? panel -> user : 0); } /* set_panel_userptr - set the user pointer */ int set_panel_userptr(PANEL *panel, char *ptr) { if (panel) { panel -> user = ptr; return (OK); } else return (ERR); } /* * panel_above - Return the panel above the * given panel (or the bottom panel in 0) */ PANEL * panel_above(PANEL *panel) { if (!panel) return (_Bottom_panel); return ((panel == panel -> below) ? ((PANEL *) 0) : panel -> above); } /* * panel_below - Return the panel below the * given panel (or the top panel in 0) */ PANEL * panel_below(PANEL *panel) { if (!panel) return (_Top_panel); return ((panel == panel -> below) ? ((PANEL *) 0) : panel -> below); } /* panel_hidden - Return TRUE if the panel is hidden, FALSE if not. */ int panel_hidden(PANEL *panel) { return ((!panel || (panel != panel -> below)) ? FALSE : TRUE); } /* _get_overlap - Get an overlap node from the free list. */ static _obscured_list * _get_overlap(void) { _obscured_list *overlap; if (_Free_list_cnt-- > 0) { overlap = _Free_list; _Free_list = _Free_list -> next; } else { _Free_list_cnt = 0; overlap = 0; } return (overlap); } /* * _unlink_obs - Find the obscured node, if any, * in the first panel which refers the second panel. */ _obscured_list * _unlink_obs(PANEL *pnl, PANEL *panel) { _obscured_list *obs; _obscured_list *prev_obs; if (!pnl -> obscured || !_panels_intersect(pnl, panel)) return ((_obscured_list *) 0); obs = pnl -> obscured; do { prev_obs = obs; obs = obs -> next; } while (obs->panel_p != panel && obs != pnl->obscured); if (obs -> panel_p != panel) { #ifdef DEBUG fprintf(stderr, "_unlink_obs: Obscured panel lost\n"); #endif return ((_obscured_list *) 0); } if (obs == prev_obs) pnl -> obscured = 0; else { prev_obs -> next = obs -> next; if (obs == pnl -> obscured) pnl -> obscured = prev_obs; } return (obs); } /* * add_obs - Add an obscured node to a panel, ensuring * that the obscured list is ordered from top to bottom. */ static void add_obs(PANEL *panel, _obscured_list *obs) { PANEL *pnl; _obscured_list *curr_obs; _obscured_list *prev_obs; if ((prev_obs = panel -> obscured) == 0) { panel -> obscured = obs -> next = obs; return; } curr_obs = prev_obs -> next; for (pnl = _Top_panel; pnl != panel; pnl = pnl->below) { if (curr_obs -> panel_p == pnl) { prev_obs = curr_obs; curr_obs = curr_obs -> next; if (prev_obs == panel -> obscured) { panel -> obscured = obs; break; } } } obs -> next = curr_obs; prev_obs -> next = obs; } /* * _intersect_panel * Create an obscured node for each panel that the given panel intersects. * The overlap record is always attached to the panel which is covered up. * * This routine assumes that _alloc_overlap() has been called to ensure * that there are enough overlap nodes to satisfy the requests. */ void _intersect_panel(PANEL *panel) { PANEL *pnl; _obscured_list *obs; int above_panel; above_panel = FALSE; for (pnl = _Bottom_panel; pnl; pnl = pnl -> above) { if (pnl == panel) { above_panel = TRUE; continue; } if (!_panels_intersect(pnl, panel)) continue; /* no overlap */ obs = _get_overlap(); obs->start = (panel->wstarty >= pnl->wstarty) ? panel->wstarty : pnl->wstarty; obs->end = (panel->wendy <= pnl->wendy) ? panel->wendy : pnl->wendy; if (above_panel) { obs -> panel_p = pnl; if (panel -> obscured) { obs -> next = panel -> obscured -> next; panel -> obscured -> next = obs; } else obs -> next = panel -> obscured = obs; } else { obs -> panel_p = panel; add_obs(pnl, obs); } } } /* * _alloc_overlap * Create enough obscured nodes to record all overlaps of a given * panel. The obscured nodes must be pre-allocated by this routine * to preserve the integrity of the pile during move. * If the move operation fails, the pile is supposed to remain * unchanged. If the obscured nodes are not allocated in advance, * then an allocation failure in the middle of a move could * leave the pile in a corrupted state with possibly no way to * restore the pile to its original state. * * The cnt parameter is the(worst case) number of overlap nodes which * are required to satisfy any request. Return 0 on error, else non-zero */ int _alloc_overlap(int cnt) { _obscured_list *overlap; int i; for (i = cnt-_Free_list_cnt; i > 0; i--) { if (!(overlap = (_obscured_list *) malloc(sizeof (_obscured_list)))) return (0); overlap -> next = _Free_list; _Free_list = overlap; _Free_list_cnt++; } return (1); } /* * _free_overlap - Free a single overlap node. Don't * really free it; just save it on a list. */ void _free_overlap(_obscured_list *overlap) { overlap -> next = _Free_list; _Free_list = overlap; _Free_list_cnt++; }