github.com/Arquivotheca.SunOS-4.1.4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
ff309bfe1c8e554728af4b8a4e9cee4d026a7e35
Arquivotheca.SunOS-4.1.4/sys/sunwindowdev/wintree.h
seta75D ff309bfe1c Init
2021-10-11 18:37:13 -03:00

685 lines
29 KiB
C
Raw Blame History

/* @(#)wintree.h 1.1 94/10/31 SMI */
/*
* This header file defines the SunWindows related kernel data structures,
* including the Workstation (input control), Desktop (screen managment),
* Window (rectangular region on a screen).
*/
#ifndef _sunwindowdev_wintree_h
#define _sunwindowdev_wintree_h
#include "win.h"
#include "dtop.h"
#include <sys/param.h> /* has machine/param h/types h/signal */
#include <sys/dir.h>
#include <sys/user.h> /* has machine/pcb h/dmap h/time h/resource */
#include <sys/proc.h>
#include <sys/termios.h>
#include <sys/filio.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/vnode.h>
#include <sys/map.h>
#include <sys/clist.h>
#include <pixrect/pixrect.h>
#include <pixrect/memvar.h>
#include <sunwindow/rect.h>
#include <sunwindow/rectlist.h>
#include <sunwindow/win_screen.h>
#include <sunwindow/win_cursor.h>
#include <sunwindow/win_input.h>
#include <sunwindow/cms.h>
#include <sunwindow/win_lock.h>
#include <sundev/vuid_state.h>
#include <sundev/vuid_queue.h>
#include <sun/fbio.h>
/*
* Flag used during open of window device when it is supposed to be the
* first time opened (exclusive open). O_EXCL in file.h currently has wrong
* mapping to FEXLOCK. Need a FEXCLOPEN in file.h.
*/
#define WIN_EXCLOPEN 0x10000
/*
* The following structure is used to provide exclusive locks to
* workstation (input & display lock access) and desktop (screen
* access and clipping data change) resources [see below]. It
* works on a process granularity although clients often think
* that it is on a window file descriptor granularity.
*/
typedef struct windowlock { /* "winlock" name collides in win_ioctl.h */
int lok_options; /* lock control options */
#define WLOK_SILENT 0x01 /* don't print messages about lock */
int lok_pid; /* pid that holds lock */
int *lok_count; /* reference count on lock */
int lok_count_storage; /* default lock count storage */
int lok_time; /* timeout on lock */
int lok_max_time; /* max. time for lok_time */
int lok_nice; /* remembered nice before boosted */
struct proc *lok_proc; /* proc struct holding lock */
char *lok_pad1; /* used to hold struct user pointer.
* Renaming and keeping so that may
* have option of sending a single
* file patch out to field */
long lok_pad2; /* used to hold a mem man handle on
* lok_pad1. Keep for same reason
* as lok_pad1 */
struct timeval lok_utime; /* user time when acquired lock */
struct timeval lok_stime; /* system time when acquired lock */
struct timeval lok_limit; /* elapsed time when will break lock */
int lok_bit; /* mask bit in lok_flags of interest */
#define WLOK_SHAREDLOCK_BITS 0xFFFFFFFF /* A bit pattern that should be used
* if the lock is to be actively set
* from a user process utilizing the
* shared memory mechanism. This
* set of bits shouldn't be used if
* more than two locks are sharing
* the same flags work. This pattern
* accomodates different test-and-set
* technologies on a flag word. */
int *lok_flags; /* flags associate with passed around */
/* lockbit */
/* The following fields are set after calling wlok_setlock (each */
/* pointer could be null, except lok_string): */
caddr_t lok_client; /* interpreted by actions */
void (*lok_unlock_action)(); /* called on unlock */
void (*lok_timeout_action)();/* called when lock timedout, no */
/* timeout detection if null */
void (*lok_force_action)(); /* called on force unlock */
char *lok_string; /* describes lock type for error msgs */
int (*lok_other_check)(); /* called to check for other locks */
caddr_t lok_wakeup; /* who to wakeup when unlocked */
int lok_id; /* lock id from shared lock */
} Winlock;
/*
* The workstation input device structure is used to describe a
* physical input device that the kernel is polling for input.
* The input device is opened in a user process and reopened by
* the kernel so as to have the device's reference count bumped.
* Input device drivers should talk in vuid (virtual user input
* device format) although ascii will be accepted.
*/
typedef struct wsindev {
int wsid_flags;
#define WSID_TREAT_AS_ASCII 0x01 /* Should expect ascii from this dev */
#define WSID_DIRECT_VALID 0x02 /* "direct" flag is valid */
long wsid_iflag; /* Remembered struct tios.c_iflag */
long wsid_oflag; /* Remembered struct tios.c_oflag */
long wsid_cflag; /* Remembered struct tios.c_cflag */
long wsid_lflag; /* Remembered struct tios.c_lflag */
struct file *wsid_fp; /* File ptr to open input device */
dev_t wsid_dev; /* Input device */
struct vnode *wsid_vp; /* Vnode ptr of open input device */
int *wsid_direct_flag; /* Direct flag saved (/dev/kbd) */
char wsid_name[SCR_NAMESIZE];/* Device name */
struct wsindev *wsid_next; /* Next node (when put as list) */
int wsid_previous_mode; /* Result of VUIDGFORMAT */
} Wsindev;
#define WSINDEV_NULL ((Wsindev *)0)
#define WSID_DEVNONE -1
/*
* Ws_usr_async is used to help detect real time user specified
* interrupt actions.
*/
typedef struct ws_usr_async {
short flags;
#define WUA_1ST_HAPPENED 0x01 /* 1st event happened */
#define WUA_IGNORE_2ND 0x02 /* don't bother waiting for 2nd event */
short first_id; /* id of the first event */
int first_value; /* value of the first event */
short second_id; /* id of the second event */
int second_value; /* value of the second event */
void (*action)(); /* called to handle interrupt */
} Ws_usr_async;
/*
* States of focus transition state machine.
*/
typedef enum win_focus_state {
SEND_Q_TOP=0, /* Try pull event off top of input q */
SEND_EXIT=1, /* Send LOC_WINEXIT */
SEND_ENTER=2, /* Send LOC_WINENTER */
SEND_REQUEST=3, /* Request kbd focus change veto */
REQUEST_WAIT=4, /* Wait for kbd focus change veto reply */
SEND_DONE=5, /* Send KBD_DONE */
SEND_USE=6, /* Send KBD_USE */
SEND_FOCUS_EVENT=7, /* Send event that provoked kbd focus change */
SEND_DIRECT_REQUEST=8, /* Explicit kbd focus change request */
} Win_focus_state;
/*
* Ws_focus_match is used to describe a focus change event.
*/
typedef struct ws_focus_set {
short id; /* id of event that changes ws_kbdfocus */
int value; /* value of event that changes ws_kbdfocus */
int shifts; /* ws_shiftmask required to change ws_kbdfocus*/
#define WS_FOCUS_ANY_SHIFT -1 /* don't care value for shifts */
} Ws_focus_set;
/*
* The workstation is defined to be some number of screens and some
* number of input devices with which a single user interacts. A single
* workstation shares a single extant cursor among all its screens.
* One can acquire an i/o lock that applies to all input devices and all
* screens of the workstation.
*
* Here is how the input focus mechanism works. The pick focus follows
* the primary locator position around and the kbd focus is set either
* programmatically or via some explicit user action (could be locator
* motion). Setting the kbd focus via some explicit user action
* generates a KBD_REQUEST event for windows whose pick mask asks for it,
* otherwise the kernel silently sets the kbd focus to the current pick
* focus. A receiver of a KBD_REQUEST can refuse the kbd focus via an ioctl.
*
* Any event is first compared with the kbd focus' kbd mask
* and sent to the kbd focus if there is a match. If unsend, the event
* is then compared with the pick focus' pick mask and sent to the pick
* focus if there is a match. Unmatched events travel up the pick focus'
* input next link being compared with pick masks on the way.
*/
typedef struct workstation {
int ws_flags;
#define WSF_PRESENT 0x01 /* the screen exists */
#define WSF_LOCKED_IO 0x02 /* i/o access rights locked */
#define WSF_LOCKED_EVENT 0x04 /* wait for ws_event_consumer to finish
(set when read event, cleared when
read/select/input_release) */
#define WSF_ALL_LOCKS (WSF_LOCKED_IO | WSF_LOCKED_EVENT )
#define WSF_UNUSED 0x08 /* unused bit */
#define WSF_LOC_UPDATED 0x10 /* changed locator position when read */
#define WSF_BREAK_PUSHED 0x20 /* event lock break event detected */
#define WSF_STOP_PUSHED 0x40 /* stop event detected */
#define WSF_LOC_IN_TRANSIT 0x80 /* avoiding waking up win with motion */
#define WSF_KBD_REQUEST_PENDING 0x100 /* waiting for answer about kbd focus */
#define WSF_SEND_FOCUS_EVENT 0x200 /* send ws_focus_event soon */
#define WSF_EXITING 0x400 /* in middle of ws_close */
#define WSF_LATEST_WAS_MOTION 0x800 /* user time level motion vs still */
#define WSF_SWALLOW_FOCUS_EVENT 0x1000 /* no send focus event if request OKed*/
#define WSF_RECORD_QUEUE 0x2000 /* event record queue established */
#define WSF_RECORD_EVENT 0x4000 /* duplicate events to record queue */
#define WSF_PLAY_BACK 0x8000 /* playback mode is on */
/*
* Device management:
*/
struct desktop *ws_dtop; /* list of desktops for workstation */
struct wsindev *ws_indev; /* input devices */
/*
* Input queue management (linked list):
*/
Vuid_queue ws_q; /* window input q */
caddr_t ws_qdata; /* address of ws_q data block */
u_int ws_qbytes; /* number of bytes used for ws_qdata */
/*
* Input queue synchronized management:
*/
struct window *ws_event_consumer;/* window that is processing event */
struct windowlock ws_eventlock;/* event access lock */
struct timeval ws_eventtimeout;/* time when will break ws_eventlock */
/*
* Real time user specified asynchronous interrupt management:
*/
struct ws_usr_async ws_break; /* break ws_eventlock */
struct ws_usr_async ws_stop; /* send stop to real time pick focus */
/*
* Virtual user input device state management:
*/
Vuid_state ws_instate; /* virtual input device state that */
/* user processes see (locator pos */
/* data relative to ws_pickfocus's */
/* dtop) */
int ws_shiftmask; /* usertime shiftmask */
struct inputmask ws_surpress_mask;
/* when send escape sequence, turn on */
/* func key bit here so don't send up */
/*
* Input consumer management:
*/
struct window *ws_kbdfocus; /* win to which w_kbdmask events go */
struct window *ws_pickfocus; /* win to which w_pickmask events go */
struct window *ws_kbdfocus_next; /* win to be next kbd focus */
struct window *ws_pickfocus_next; /* win to be next pick focus */
/* Only state machine moves values */
/* between * and *_next fields. Only */
/* ws_set_focus sets values to fields.*/
/* winclose may clear the * field */
Win_focus_state ws_focus_state; /* state of focus transitions */
struct desktop *ws_pick_dtop; /* desktop pick focus currently on */
Firm_event ws_focus_event; /* event that prompted focus change */
/*
* Focus control parameters. Can have separate events for both
* pass thru (_pt) the focus event and swallow (_sw) the focus
* event. These affect ws_kbdfocus.
*/
Ws_focus_set ws_kbd_focus_pt; /* pass thru focus event */
Ws_focus_set ws_kbd_focus_sw; /* swallowed focus event */
/*
* Grabio management:
*/
struct window *ws_inputgrabber;/* window that is hogging events */
struct window *ws_pre_grab_kbd_focus; /* kbd focus pre-iolock */
struct window *ws_pre_grab_kbd_focus_next;
/* next kbd focus pre-iolock */
struct window *ws_pre_grab_pick_focus; /* pick focus pre-iolock */
struct window *ws_pre_grab_pick_focus_next;
/* next pick focus pre-iolock */
struct windowlock ws_iolock; /* input & display lock access lock */
/*
* Cursor management:
*/
Vuid_state ws_rtstate; /* real time vuid state (locator pos */
/* data relative to ws_loc_ dtop) */
struct desktop *ws_loc_dtop; /* desktop locator currently on */
int ws_quietticks; /* # of ticks since no input received */
int ws_loc_stillticks; /* # of ticks locator has been still */
int ws_favor_pid; /* current interactive pid */
/*
* event recording queue
*/
Vuid_queue ws_rec_q; /* recording queue */
caddr_t ws_rec_qdata; /* address of ws_rec_q data block */
u_int ws_rec_qbytes; /* # of bytes used for ws_rec_qdata */} Workstation;
#define WORKSTATION_NULL ((Workstation *)0)
/*
* The desktop cursor structure describes the current cursor and/or
* xhairs displayed on a screen. It includes the image under the cursor/
* cross hairs as well as clipping data for the xhairs.
*/
#define DTOP_PRMAXDEPTH 32
#define cursor_x(dtop) ((dtop)->shared_info->cursor_info.x)
#define cursor_y(dtop) ((dtop)->shared_info->cursor_info.y)
#define cursor_screen_width(dtop) \
((dtop)->shared_info->cursor_info.screen_pr.pr_width)
#define cursor_screen_height(dtop) \
((dtop)->shared_info->cursor_info.screen_pr.pr_height)
#define cursor_up(dtop) ((dtop)->shared_info->cursor_info.cursor_is_up)
#define horiz_hair_up(dtop) ((dtop)->dt_cursor.horiz_hair_is_up)
#define vert_hair_up(dtop) ((dtop)->dt_cursor.vert_hair_is_up)
#define enable_plane_cursor_up(dtop) ((dtop)->dt_cursor.enable_cursor_is_up)
#ifndef PRE_FLAMINGO
#define videnb_plane_cursor_up(dtop) ((dtop)->dt_cursor.videnb_cursor_is_up)
#endif PRE_FLAMINGO
#define cursor_set_up(dtop, is_up) cursor_up(dtop) = (is_up);
#define horiz_hair_set_up(dtop, is_up) horiz_hair_up(dtop) = (is_up);
#define vert_hair_set_up(dtop, is_up) vert_hair_up(dtop) = (is_up);
#define enable_plane_cursor_set_up(dtop, is_up) \
enable_plane_cursor_up(dtop) = (is_up);
#ifndef PRE_FLAMINGO
#define videnb_plane_cursor_set_up(dtop, is_up) \
videnb_plane_cursor_up(dtop) = (is_up);
#endif PRE_FLAMINGO
#define show_enable_plane_cursor(dtop) ((dtop)->dt_cursor.enable_cursor_active)
#define enable_plane_cursor_set_active(dtop, is_active) \
((dtop)->dt_cursor.enable_cursor_active) = (is_active);
#ifndef PRE_FLAMINGO
#define show_videnb_plane_cursor(dtop) \
((dtop)->dt_cursor.videnb_cursor_active)
#define videnb_plane_cursor_set_active(dtop, is_active) \
((dtop)->dt_cursor.videnb_cursor_active) = (is_active)
#endif PRE_FLAMINGO
struct dtopcursor {
int hair_x; /* x-coordinate of vertical hair */
int hair_y; /* y-coordinate of horizontal hair */
int horiz_hair_size;/* horizontal hair kmem_alloc size */
int vert_hair_size; /* vertical hair kmem_alloc size */
int enable_color; /* enable cursor color (0 or 1) */
/* crosshair flags */
unsigned int horiz_hair_is_up : 1; /* hair has been drawn */
unsigned int vert_hair_is_up : 1; /* hair has been drawn */
unsigned int enable_cursor_is_up : 1;/* enable cursor drawn */
unsigned int enable_cursor_active :1;/* enable cursor active */
#ifndef PRE_FLAMINGO
unsigned int videnb_cursor_is_up : 1;/* video enable cursor drawn */
unsigned int videnb_cursor_active :1;/* video enable cursor active
*/
#endif PRE_FLAMINGO
struct rectlist horiz_hair_rectlist; /* list of clobbered area */
struct rectlist vert_hair_rectlist; /* list of clobbered area */
struct pixrect horiz_hair_mpr; /* horizontal x-hair */
struct mpr_data horiz_hair_data; /* data underneath it */
struct pixrect vert_hair_mpr; /* vertical x-hair */
struct mpr_data vert_hair_data; /* data underneath it */
struct pixrect enable_mpr; /* enable cursor */
struct mpr_data enable_data; /* data underneath it */
short enable_image[CUR_MAXIMAGEBYTES/2];/* enable plane image */
#ifndef PRE_FLAMINGO
struct pixrect videnb_mpr; /* video enable cursor */
struct mpr_data videnb_data; /* video data underneath it */
short videnb_image[CUR_MAXIMAGEBYTES/2];/* video enable plane image */
#endif PRE_FLAMINGO
#ifdef PRE_FLAMINGO
#define dtopcursorfixup(dc) /* Make screen mpr fields reference each other*/\
{ extern struct pixrectops mem_ops;\
(dc)->horiz_hair_mpr.pr_ops = &mem_ops;\
(dc)->horiz_hair_mpr.pr_depth = DTOP_PRMAXDEPTH;\
(dc)->horiz_hair_mpr.pr_data = (caddr_t) &(dc)->horiz_hair_data;\
(dc)->vert_hair_mpr.pr_ops = &mem_ops;\
(dc)->vert_hair_mpr.pr_depth = DTOP_PRMAXDEPTH;\
(dc)->vert_hair_mpr.pr_data = (caddr_t) &(dc)->vert_hair_data;\
(dc)->enable_mpr.pr_ops = &mem_ops;\
(dc)->enable_mpr.pr_depth = 1;\
(dc)->enable_mpr.pr_width = 16;\
(dc)->enable_mpr.pr_height = 16;\
(dc)->enable_mpr.pr_data = (caddr_t) &(dc)->enable_data;\
(dc)->enable_data.md_image = (dc)->enable_image;\
(dc)->enable_data.md_linebytes = mpr_linebytes( \
(dc)->enable_mpr.pr_width, (dc)->enable_mpr.pr_depth);\
}
#else
#define dtopcursorfixup(dc) /* Make screen mpr fields reference each other*/\
{ extern struct pixrectops mem_ops;\
(dc)->horiz_hair_mpr.pr_ops = &mem_ops;\
(dc)->horiz_hair_mpr.pr_depth = DTOP_PRMAXDEPTH;\
(dc)->horiz_hair_mpr.pr_data = (caddr_t) &(dc)->horiz_hair_data;\
(dc)->vert_hair_mpr.pr_ops = &mem_ops;\
(dc)->vert_hair_mpr.pr_depth = DTOP_PRMAXDEPTH;\
(dc)->vert_hair_mpr.pr_data = (caddr_t) &(dc)->vert_hair_data;\
(dc)->enable_mpr.pr_ops = &mem_ops;\
(dc)->enable_mpr.pr_depth = 1;\
(dc)->enable_mpr.pr_width = 16;\
(dc)->enable_mpr.pr_height = 16;\
(dc)->enable_mpr.pr_data = (caddr_t) &(dc)->enable_data;\
(dc)->enable_data.md_image = (dc)->enable_image;\
(dc)->enable_data.md_linebytes = mpr_linebytes( \
(dc)->enable_mpr.pr_width, (dc)->enable_mpr.pr_depth);\
(dc)->videnb_mpr.pr_ops = &mem_ops; \
(dc)->videnb_mpr.pr_depth = 1; \
(dc)->videnb_mpr.pr_width = 16; \
(dc)->videnb_mpr.pr_height = 16; \
(dc)->videnb_mpr.pr_data = (caddr_t) &(dc)->videnb_data; \
(dc)->videnb_data.md_image = (dc)->videnb_image; \
(dc)->videnb_data.md_linebytes = mpr_linebytes( \
(dc)->videnb_mpr.pr_width, (dc)->videnb_mpr.pr_depth); \
}
#endif PRE_FLAMINGO
};
/*
* The desktop is a per-screen structure.
*
* This structure records physical attributes: whether the device
* for the surface is present, its type (color, b/w, etc),
* the physical addresses of the device, and the location of the
* other screens in the system relative to this one (for use by its
* workstation for multiplexing a single mouse among several screens.)
*
* Each screen has an associated window tree for clipping, attached
* to the screen starting at a root window. Colormap multiplexing
* is handled thru the desktop.
*
* Locator x/y deltas are held in ws_rtstate and ws_utstate
* There are a variety of places that locator x/y positions are held.
* They are alway relative to a particular desktop since we don't support
* adjacent screen locator access. The ws_instate values are not defined.
* A window that wants the user time locator position goes to its desktop
* and uses the dt_ut_* values, these are the latest locator positions from
* the last time that the locator was on that desktop. The ws_rtstate
* values are defined to be those that are associate with the desktop
* that currently has the cursor. A desktop that wants the latest real
* time locator position for itself goes to its dt_rt_* values.
* A desktop's current cursor image position is in dt_cursor.
*/
typedef struct desktop {
int dt_flags;
#define DTF_PRESENT 0x01 /* the screen exists */
#define DTF_NEWCURSOR 0x08 /* set if should change current cursor*/
#define DTF_NEWCMAP 0x10 /* set if should change cur color map*/
#define DTF_EXITING 0x20 /* process of destroying desktop */
#define DTF_MULTI_PLANE_GROUPS 0x40 /* pixrect has mulitple plane groups */
#define DTF_DBLBUFFER 0x80 /* Double buffer capablity */
#define DTF_DBL_FOUND 0x100 /* Found the double bufferer yet */
#define DTF_HWCURSORAVAILABLE 0x200 /* Hardware cursor capability */
#define DTF_HWCURNOTSHOWN 0x400 /* Hw cursor backward compatibility
* (see winshared.c) */
struct workstation *dt_ws; /* workstation tyed to */
struct desktop *dt_next; /* desktop list starting at dt_ws */
struct screen dt_screen; /* external screen description */
struct pixrect *dt_pixrect; /* pixel device used for screen access*/
struct file *dt_fbfp; /* file ptr to framebuffer device */
struct window *dt_displaygrabber;/* only window that can lock display*/
struct window *dt_rootwin; /* root window for screen */
struct window *dt_parentinvalidwin; /* rlInvalid is relative to this */
/* Note: both the display and mutex locks are shared locks.
* the contents of these structs should not be considered
* valid unless dtop_validate_shared_lock() is called first.
*/
struct windowlock dt_mutexlock; /* shared memory mutual exclusion */
struct windowlock dt_displaylock; /* display lock */
struct windowlock dt_datalock; /* data lock */
struct rectlist dt_rlinvalid; /* Accumulated damaged rl */
struct desktop *dt_neighbors[SCR_POSITIONS]; /* where are other dts? */
struct dtopcursor dt_cursor; /* cursor/xhairs for desktop */
struct window *dt_cursorwin; /* window from with next cursor gotten*/
int dt_rt_x; /* realtime x for this desktop */
int dt_rt_y; /* realtime y for this desktop */
int dt_ut_x; /* usertime x for this desktop */
int dt_ut_y; /* usertime y for this desktop */
struct cms_map dt_cmap; /* colormap data ptrs into cmapdata */
int dt_cmsize; /* number of entries in colormap */
caddr_t dt_cmapdata; /* & of colormap data block */
struct mapent *dt_rmp; /* colormap resource allocator data */
int dt_exit_seconds; /* count of secs blocked on destroy */
Win_lock_block *shared_info; /* shared memory for faster locking */
struct inputevent *dt_sharedq; /* shared window input q */
struct window *dt_sharedq_owner; /* win whose q is sharedq */
int dt_sharedq_size; /* shared_info->shared_eventq.size */
int display_waiting; /* count of waiters for display lock */
#define DTOP_MAX_PLANE_GROUPS 20 /* 20 is arbitrary */
char dt_plane_groups_available[DTOP_MAX_PLANE_GROUPS];
/* framebuffer capabilities */
struct singlecolor dt_bkgnd_cache; /* Fullscreen access color cache */
struct singlecolor dt_frgnd_cache; /* Fullscreen access color cache */
int dt_dblcount; /* Number of double bufferes */
char dt_dbl_bkgnd; /* Background for double buffer */
char dt_dbl_frgnd; /* Foreground for double buffer */
struct window *dt_curdbl; /* Current double bufferer */
} Desktop;
#define DESKTOP_NULL ((Desktop *)0)
/*
* Window data structure defines the characteristics of a window psuedo
* device that are not shared among all the windows on a desktop or
* workstation. A window is the smallest granularity about which the
* kernel manages input distribution or display image mangement.
* (See Workstation comment about input mask usage).
*/
typedef struct window {
int w_flags;
#define WF_OPEN 0x01 /* device is open */
#define WF_INSTALLED 0x02 /* installed in a tree */
#define WF_SIZECHANGED 0x08 /* size changed */
#define WF_DTOPPOSCHANGED 0x10 /* dtop relative position changed */
#define WF_RCOLL 0x20 /* select collided */
#define WF_NBIO 0x40 /* non-blocking i/o wanted */
#define WF_ROOTWINDOW 0x80 /* root window of screen */
#define WF_PREVIOUSDAMAGED 0x100 /* non-null rlfixup last time clipped*/
#define WF_WANTINPUT 0x200 /* currently waiting on input */
#define WF_CMSHOG 0x400 /* override std color map when active */
#define WF_ASYNC 0x800 /* use asyncronous input */
#define WF_KBD_MASK_SET 0x1000 /* kbd mask has been set explicitly */
#define WF_UNSYNCHRONIZED 0x2000 /* Broke event lock so run this guy
* unsynchronized (don't give event
* lock) until his input queue empty */
#define WF_PLANE_GROUP_SET 0x4000 /* plane group set explicitly */
#define WF_DBLBUF_ACCESS 0x8000 /* Double buffer Accessed */
#ifndef PRE_FLAMINGO
#define WF_NOTIFYALLCHANGES 0x10000 /* Send SIGWINCH if clipping changes */
#define WF_CLIPPINGCHANGED 0x20000 /* Clipping changed */
#endif PRE_FLAMINGO
#define WIN_LINKS 5
struct window *w_link[WIN_LINKS];
#define WL_PARENT 0
#define WL_OLDERSIB 1
#define WL_YOUNGERSIB 2
#define WL_OLDESTCHILD 3
#define WL_YOUNGESTCHILD 4
#define WL_ENCLOSING w_link[WL_PARENT]
#define WL_COVERED w_link[WL_OLDERSIB]
#define WL_COVERING w_link[WL_YOUNGERSIB]
#define WL_BOTTOMCHILD w_link[WL_OLDESTCHILD]
#define WL_TOPCHILD w_link[WL_YOUNGESTCHILD]
#define WIN_NULLLINK -1
#define WT_TOPTOBOTTOM 1
#define WT_BOTTOMTOTOP 2
struct desktop *w_desktop; /* desktop on which window lies */
struct workstation *w_ws; /* workstation that drives window */
struct rect w_rect; /* parent relative...
used when computing rlExposed */
struct rect w_rectsaved; /* used for icon/normal toggle */
coord w_screenx; /* screen relative (used when paint) */
coord w_screeny; /* screen relative (used when paint) */
int w_pid; /* pid that will be signalled */
int w_userflags; /* flags available to user process */
int w_clippingid; /* version of clipping information */
/* All rectlist's are self relative; use screenOffset's when paint */
struct rectlist w_rlexposed; /* for normal clipping */
struct rectlist w_rlexposedold;/* for saving bits (wmgr) */
struct rectlist w_rlfixup; /* for fixing damage (user) */
struct inputmask w_kbdmask; /* kbd focus input mask */
struct inputmask w_pickmask; /* pick focus input mask */
struct window *w_inputnext; /* if !in *mask (above), passed here */
struct clist w_input; /* input queue for this window */
struct proc *w_rsel; /* process selecting */
struct cursor w_cursor; /* per-window cursor */
struct pixrect w_cursormpr; /* w_cursor.cur_shape */
struct mpr_data w_cursordata; /* w_cursormpr.pr_data */
short w_cursorimage[CUR_MAXIMAGEBYTES/2];/* w_cursordata.md_image */
struct colormapseg w_cms; /* colormap segment */
struct cms_map w_cmap; /* colormap data ptrs into w_cmapdata */
caddr_t w_cmapdata; /* address of colormap data block */
int w_plane_group; /* Plane group that window is using */
struct proc *w_aproc; /* proc for FIOASYNC */
int w_apid; /* pid for FIOASYNC */
#define winfixupcursor(w) /* Make cursor components in w reference each other*/\
{ extern struct pixrectops mem_ops;\
(w)->w_cursor.cur_shape = &(w)->w_cursormpr;\
(w)->w_cursormpr.pr_ops = &mem_ops;\
(w)->w_cursormpr.pr_data = (caddr_t)&(w)->w_cursordata;\
(w)->w_cursordata.md_image = (w)->w_cursorimage;\
}
char w_dbl_rdstate; /*Read control bit foregr/backgr state*/
char w_dbl_wrstate; /*Write control bit foregr/backgr st*/
struct fb_wid_dbl_info w_wid_dbl_info;
} Window;
#define WINDOW_NULL ((Window *)0)
Desktop desktops[NDTOP];
#define NWORKSTATION NDTOP
Workstation workstations[NWORKSTATION];
#define WINALLOC_INC ((8192)/(sizeof(struct window)))
#define WINBUFS ((NWIN/WINALLOC_INC)+1)
extern struct window *winbufs[NWIN];
struct window *winfromdev(),
*winfromopendev();
/*
* Colormap Resource Map macros/constants
*/
#define CRM_ADDROFFSET 1
#define CRM_SLOTSIZE 8
#define CRM_NSLOTS(size) ((size)/CRM_SLOTSIZE)
#define CRM_SIZE(size) (CRM_NSLOTS((size))+2)
extern win_errno;
int ws_close_indev();
Window *wt_intersected();
#define LOCKPRI 28
#define spl_timeout() spl1()
/*
* Flags to the ws_set_focus call.
* FF_PICK_CHANGE means that the locator (or windows) may have changed,
* set pick focus from locator. If LOC_WINENTER then change kbd focus too.
* FF_KBD_EVENT mean to use ws_focus_event to change the kbd focus. Will
* set WSF_KBD_REQUEST_PENDING.
*/
void ws_set_focus();
#define FF_PICK_CHANGE 0x1
#define FF_KBD_EVENT 0x2
void win_shared_update_cursor();
void win_shared_update_cursor_active();
void win_shared_update_mouse_xy();
void win_shared_update();
/*
* window notify queue
*/
struct winnotify {
struct winnotify *wn_next;
struct window *wn_window;
};
extern int win_nwindows;
extern int ndesktops;
extern int nworkstations;
/*
* Support hardware cursor options of:
* 1) Default is hardware cursor on framebuffers that support it for
* all windows.
* 2) If the kernel int win_do_hw_cursor is set to 0 then no
* hardware cursor features are available at all.
* 3) A window may surpress usage of the hardware cursor via the
* NOT_IN_HW cursor flag. This is used in cases where the application
* doesn't agree with SunWindows choice of how it translates the
* software cursor into hardware.
* 4) A window may surpress any setting of the hardware cursor's image
* via the CLIENT_OWNS_IMAGE cursor flag for that window. This is used
* in cases where the app wants to control the image to a greater extent
* than the SunWindows interface provides, e.g., interesting usage of a
* cursor mask.
*
* The application should check the hardware_cursor flag in the
* window lock block to see that SunWindows is actually providing
* the tracking (in case it is not available in the kernel being
* used or the user has shut it off via win_do_hw_cursor) when the
* mouse enters the window. When SunWindows is not, then the app
* should assume complete control of the hardware cursor including:
* enabling it and disabling it as it enters and exits the window,
* disabling it when the window closes and the window is the root
* (as with xnews).
*/
extern int win_do_hw_cursor; /* Enables real time cursor feature */
extern int dtop_cursor_ioctl();/* (fp, cmd, data), use when no u area */
extern int dtop_cursor_ok_for_hw(); /* (dtop) Check op and size for hw
* suitability */
extern int dtop_load_hw_cursor(); /* (dtop) Load hw with image and pos */
extern void dtop_remove_hw_cursor();/* (dtop) Remove hw cursor from screen */
#endif /*!_sunwindowdev_wintree_h*/
Reference in New Issue View Git Blame Copy Permalink