win_ioctl.h

操作系统SunOS 4.1.3版本的源码

#define	WINDONEDAMAGED	_IOW(g, 33, int)
	/* Call after finished fixing up for WINGETDAMAGEDRL. 
	Call even if chose to ignore fixup list.  int is users notion of
	his current clipping id. */
#define	WINSHAREQUEUE _IO(g, 80)
	/* Convert the event queue for this window to circular form and
	place in shared memory.  If not already sharing winlock, or if
	another window's queue is already shared, will fail.  For X. */

struct	winlock {
	int	wl_clipid;	/* clipping ID that must match current held */
	struct	rect wl_rect;	/* window coordinates of area that may write */
};

struct winclip {
	int	wc_blockbytes;		/* size of wc_block */
	int	wc_clipid;		/* Current clip id of clipping */
	struct	rect	wc_screenrect;	/* Screen relatived (used when paint) */
	char	*wc_block;		/* Block where RectList is copied. */
};

/*
 * Colormap sharing mechanism
 */
#define	WINSETCMS	_IOWR(g, 34, struct cmschange)
	/* Tell the kernel that window is using cc_cms.cms_name color map
	segment, its a cc_cms.cms_size segment and that cc_map.* are the
	values that you are using.  The kernel returns the offset of the
	segment in cc_cms.cms_addr.  If your named segment exists then
	you will share it with other windows.  Otherwise, your requested
	portion of the color map will be loaded ONLY when input is being
	directed to your window. */
#define	WINGETCMS	_IOWR(g, 35, struct cmschange)
	/* Get the color map data for the calling window. */

struct	cmschange {
	struct	colormapseg cc_cms;
	struct	cms_map cc_map;
};

/*
 * Plane group utilization mechanism
 */
#define WINSETPLANEGROUP      _IOW(g, 63, int)
	/* This ioctl records the plane group uses by the given window */
#define WINGETPLANEGROUP      _IOR(g, 64, int)
	/* This ioctl divulges the plane group uses by the given window */

#define	WIN_MAX_PLANE_GROUPS	20	/* 20 is arbitrary */
struct	win_plane_groups_available {
	char	plane_groups_available[WIN_MAX_PLANE_GROUPS];
};

#define WINSETAVAILPLANEGROUPS _IOW(g, 65, struct win_plane_groups_available)
	/* This ioctl records the plane groups used by the screen */
#define WINGETAVAILPLANEGROUPS _IOR(g, 66, struct win_plane_groups_available)
	/* This ioctl divulges the plane groups used by the screen */

/*
 * Screen creation, inquiry and deletion.
 */
struct	usrdesktop {
	struct	screen udt_scr;
	int	udt_fbfd;	/* fd of frame buffer */
	int	udt_kbdfd;	/* fd of keyboard */
	int	udt_msfd;	/* fd of mouse */
};
#define	WIN_NODEV	-1	/* special fd meaning no device */
#define	WINSCREENNEW	_IOW(g, 40, struct usrdesktop)
	/* Copies in usrdesktop and installs the calling window as its root.
	The root window is opened before making this call (obviously).
	Udt_scr.scr_name is made available to other window processes via
	WINSCREENGET so that they can pass it to pr_open during pixrect
	creation.  The root's rect size is set to the size of scr_rect. */
#define	WINSCREENGET	_IOR(g, 41, struct screen)
	/* Copies out screen of the calling window. */
#define	WINSCREENDESTROY _IO(g, 42)
	/* Deallocates the screen of the calling window and does other
	appropriate cleanup tasks.  This is permitted only
	if the calling window is the root window of the screen. */
struct  winscreenposdummy {int  a, b, c, d};
#define	WINSCREENPOSITIONS _IOW(g, 43, struct winscreenposdummy)
	/* Copy in *neighbors to screen occupied by calling window.
	This call specifies the relationship of the calling window's screen to
	other screens by naming the screens which are above/left/etc
	of this screen.  This allows the mouse to be moved from screen
	to screen.  The values of the array passed to the kernel are window
	numbers.  The screen on which each window sits is the neighbor.
	Use WIN_NULLLINK (-1) if there is no neighbor at that slot. */
#define	WINGETSCREENPOSITIONS _IOR(g, 45, struct winscreenposdummy)
	/* Copy out neighbors of calling window's desktop.
	(See WINSCREENPOSITIONS). */
#define	WINSETKBD	_IOW(g, 46, struct usrdesktop)
	/* Like WINSCREENNEW but only use kbd stuff.
	The keyboard is set to the new device. */
#define	WINSETMS	_IOW(g, 47, struct usrdesktop)
	/* Like WINSCREENNEW but only use ms stuff.
	The mouse is set to the new device. */

struct	input_device {
	int	id;			/* fd (or number) of input device
					   or -1 */
	char	name[SCR_NAMESIZE];	/* name of input device */
};
#define	WINSETINPUTDEV	_IOW(g, 50, struct input_device)
	/* Copies in input_device which identifies the input device.
	The kernel sends an ioctl to make it send firm events.
	The device's unread input is flushed.  SunWindows starts
	reading from the device.  The input device is opened before
	making this call (obviously) and the id field is set to the
	file descriptor.  The name is used to identify the device
	on subsequent calls to SunWindows.  If id is -1 then the
	device indicated by name is reset (to firm events or native
	mode, flush unread input) and no longer read by SunWindows. */
#define	WINGETINPUTDEV	_IOWR(g, 51, struct input_device)
	/* Copies in input_device and (depending on id) returns some
	information about an input device.  If id is -1 then the
	device indicated by name is checked for existence (as far as
	SunWindows is concerned).  If it exists then ioctl returns 0,
	but if it doesn't then errno is set to ENODEV.  If id is some
	small positive decimal then the idth input device's name is
	returned in name.  This is used for enumerated the input devices
	being used.  errno is set to ENODEV if id doesn't correspond
	to an open input device. */

/*
 * Debugging utilities
 */
#define	WINPRINT	_IO(g, 44)
	/* Print the calling window's data structure on the console.*/

#endif	sunwindow_win_ioctl_DEFINED



/* 
* pw_dbl_set struct to be  sent to WINDBLSET call
*/
struct pwset {
	int 	attribute;		/* Attribute PR_DBL_ */
	int	value;			/* Value foreground, background etc. */
};

/*
 *	Double buffering IOCTL's (71 thru 79)
 */
#define  WINDBLACCESS	_IO(g, 71)
	/* Allow Window to be double buffered */

#define WINDBLFLIP	_IO(g, 72)
	/* Flip the double buffer */

#define WINDBLABSORB	_IO(g, 73)

#define WINDBLRLSE	_IO(g, 74)
        /* release the double buffer */

#define WINDBLSET	_IOW(g, 75, struct pwset)

#define WINDBLGET	_IOWR(g, 76, struct pwset)

#define WINDBLCURRENT	_IOR(g, 77, struct rect)
        /* get the rect of the current window doing double buffering
	   in relation to the current window */

#include <sun/fbio.h>
/* Window id information for multiple window double buffering states. */
#define WINWIDSET	_IOWR(g, 78, struct fb_wid_dbl_info)
#define WINWIDGET	_IOWR(g, 79, struct fb_wid_dbl_info)

/* Cursor planes clearing during re-display */
#define WINCLEARCURSORPLANES	_IOWR(g, 83, struct rect)
/*
 *  New Genesis Window Driver Ioctls (150 thru 156)
 */
#define WINSETCPCURSOR  _IOW(g, 150, struct cursor)
	/* Set cursor processor cursor attributes. The cursor data
	   structure has been expanded to accomodate new cursor
	   processor specific attributes. */

#define WINGETCPCURSOR  _IOWR(g, 151, struct cursor)
	/* Get cursor processor cursor attributes. The cursor data
	   structure has been expanded to accomodate new cursor
	   processor specific attributes.*/

#define WINDISCONNECT  _IO(g, 152)
        /* Disconnect locator from cursor position update; this allows the
	   locator to function as a raw input device and not as a cursor
	   positioning device */ 

#define WINRECONNECT  _IO(g, 153)
        /* Reconnect locator to cursor position update; this restores the
	   locator to its usual task of driving the cursor */ 

#define WINGETROOTWIN  _IOWR(g, 154, struct input_device)
        /* Given the name of a frame buffer device, returns the
           window number of the root window for the desktop
           running on this frame buffer.  input_device.name 
           should be set to the frame buffer device name, and
           the root window number is returned in input_device.id.
           This is done to avoid creating a new structure for
           this ioctl, since a structure already exists which
           will do the job */

#define WINGETVALIDVALUES  _IOR(g, 155, struct valid_values_table)
        /* Get list of valid cursor processor parameter values so that
	   the user's attribute values can be range checked */

#define WINTUNINGVALUE  _IOWR(g, 156, struct tuning_pair)
	/* Allow a user to get/set the window driver tuning parameters
	   such as polling rate and queue size */

/*
 * Input event recording and synthesis (playback) functionality.
 */

#define	WINSETRECQUE	_IOW(g, 200, struct winrecq_setup)
	/* Recording Queue setup function */

typedef struct winrecq_setup {
	short	recq_cmd;		/* Setup command request */
#define WIN_RECQ_CRE	1		/* Create recording queue */
#define WIN_RECQ_DEL	0		/* Delete recording queue */
	short	recq_size;		/* Recording queue size in events */
#define WIN_RECQ_DEF	512		/* Recording queue default size */
} Winrecq_setup;

#define	WINSETRECORD	_IOW(g, 201, int)
	/* Recording mode function */
#define	WIN_SETREC_ON	1		/* Turn on recording */
#define WIN_SETREC_OFF	0		/* Turn off recording */

#define	WINREADRECQ	_IOWR(g, 202, struct winrecq_readbuf)
	/* Read an event from the event recording queue */

typedef struct winrecq_readbuf {
	short		trans;		/* Number events to read (transfer) */
	short		total;		/* Number events read */
	Firm_event	*fe;		/* Buffered events read */
} Winrecq_readbuf;

#define	WINSETPLAYBACK	_IOW(g, 203, int)
	/* Playback mode function */
#define	WIN_SETPLAY_ON	1		/* Turn on playback */
#define	WIN_SETPLAY_OFF	0		/* Turn off playback */

#define WINSETPLAYINTR	_IOW(g, 204, struct winplay_intr)
	/* Playback user event input termination event definition */

typedef struct winplay_intr {
	int	intr_flags;		/* Playback interrupt flags */
#define	WIN_PLAY_INTR_NONE	0x00	/* No interrupts allowed */
#define	WIN_PLAY_INTR_DEF	0x01	/* Default interrupts */
#define WIN_PLAY_INTR_USER	0x02	/* User defined interrupt event */
#define WIN_PLAY_INTR_SYNC	0x04	/* On Interrupt Generate Sync Pt */
	u_short	intr_feid;		/* User defined interrupt event id */
} Winplay_intr;

#define	WINSYNCIDDEF	0xff
	/* Default Sync Event Id Number */

#define	WINSETSYNCPT _IOW(g, 205, struct winrecplay_syncbuf)
	/* Record/Playback a user sync point */

typedef struct winrecplay_syncbuf {
	int	sync_cmd;		/* Set Sync Command */
#define	WINSETSYNCID	1		/* Set The Global Sync Event Id */
	/* Next are for setting a sync point/event */
#define WINSYNCDEFAULT	2		/* Use defaults type, pair, value */
#define	WINSYNCUSRSTD	3		/* Use user supplied type and value */
#define WINSYNCUSRDFN	4		/* Use all user supplied data */
	int	sync_type;		/* Sync Event Pair Type Value */
#define	WIN_SYNC_SET	1		/* Normal (expected) Sync Point */
#define	WIN_SYNC_INTR	2		/* Playback Interrupt Sync Point */
#define	WIN_SYNC_ERR	3		/* Sync Error Sync Point */
#define WIN_SYNC_MENU	4		/* SunView menu map sync point */
#define WIN_SYNC_TTY	5		/* SunView tty ready sync pt */
#define WIN_SYNC_TEXT	6		/* SunView text ready sync pt */
#define WIN_SYNC_WARPX  7               /* Set Mouse Warp x position */
#define WIN_SYNC_WARPY  8               /* Set Mouse Warp y position */
#define WIN_SYNC_ALERT  9               /* Alerts windowing sync pt */
#define WIN_SYNC_STACK  10              /* Stacking Menu map sync pt */
#define WIN_SYNC_PROMPT 11              /* Prompt box sync pt */
#define WIN_SYNC_USER1	128             /* First User defined sync type */
	int	sync_pair;		/* Sync Event Win Device Id (pair) */
	int	sync_value;		/* Sync point global id or value */
	int	sync_flag;		/* Syncing flag to sync on rec/play */
#define	WINSYNCREC	0x01		/* Set sync on record only */
#define	WINSYNCPLAY	0x02		/* Set sync on playback only */
} Winrecplay_syncbuf;