/* -*-C-*-
-$Id: os2pm.c,v 1.1 1994/12/02 20:44:26 cph Exp $
+$Id: os2pm.c,v 1.2 1994/12/19 22:31:36 cph Exp $
Copyright (c) 1994 Massachusetts Institute of Technology
HWND frame; /* frame window handle */
HWND client; /* client window handle */
HPS hps; /* presentation space for client window */
- unsigned short char_width; /* char width (max increment) */
- unsigned short char_ascender; /* char ascender (max height above base) */
- unsigned short char_descender; /* char descender (max height below base) */
- unsigned short width; /* width in characters */
- unsigned short height; /* height in characters */
- char * charmap; /* character array */
+ unsigned short grid_x; /* x dimension of resizing grid */
+ unsigned short grid_y; /* y dimension of resizing grid */
unsigned short cursor_x; /* x coordinate of the cursor */
unsigned short cursor_y; /* y coordinate of the cursor */
+ unsigned short cursor_width; /* width of the cursor */
+ unsigned short cursor_height; /* height of the cursor */
+ unsigned short cursor_style; /* style of the cursor */
+ qid_t qid; /* qid to send commands to */
qid_t event_qid; /* qid to send input events to */
- twid_t twid; /* twid for this twindow */
+ wid_t wid; /* wid for this window */
+ COLOR foreground_color;
+ COLOR background_color;
unsigned int cursor_shownp : 1; /* nonzero if cursor is visible */
unsigned int minimizingp : 1; /* nonzero if window being minimized */
unsigned int minimizedp : 1; /* nonzero if window is minimized */
-} twindow_t;
-#define TWINDOW_FRAME(twindow) ((twindow) -> frame)
-#define TWINDOW_CLIENT(twindow) ((twindow) -> client)
-#define TWINDOW_HPS(twindow) ((twindow) -> hps)
-#define TWINDOW_CHAR_WIDTH(twindow) ((twindow) -> char_width)
-#define TWINDOW_CHAR_ASCENDER(twindow) ((twindow) -> char_ascender)
-#define TWINDOW_CHAR_DESCENDER(twindow) ((twindow) -> char_descender)
-#define TWINDOW_WIDTH(twindow) ((twindow) -> width)
-#define TWINDOW_HEIGHT(twindow) ((twindow) -> height)
-#define TWINDOW_CHARMAP(twindow) ((twindow) -> charmap)
-#define TWINDOW_CURSOR_X(twindow) ((twindow) -> cursor_x)
-#define TWINDOW_CURSOR_Y(twindow) ((twindow) -> cursor_y)
-#define TWINDOW_CURSOR_SHOWNP(twindow) ((twindow) -> cursor_shownp)
-#define TWINDOW_EVENT_QID(twindow) ((twindow) -> event_qid)
-#define TWINDOW_TWID(twindow) ((twindow) -> twid)
-#define TWINDOW_MINIMIZINGP(twindow) ((twindow) -> minimizingp)
-#define TWINDOW_MINIMIZEDP(twindow) ((twindow) -> minimizedp)
-
-#define TWINDOW_CHAR_HEIGHT(twindow) \
- ((TWINDOW_CHAR_ASCENDER (twindow)) + (TWINDOW_CHAR_DESCENDER (twindow)))
-
-#define TWINDOW_CHAR_LOC(twindow, x, y) \
- (& ((TWINDOW_CHARMAP (twindow)) [((y) * (TWINDOW_WIDTH (twindow))) + (x)]))
+ unsigned int permanentp : 1; /* nonzero means don't close on reload */
+} window_t;
+#define WINDOW_FRAME(window) ((window) -> frame)
+#define WINDOW_CLIENT(window) ((window) -> client)
+#define WINDOW_HPS(window) ((window) -> hps)
+#define WINDOW_GRID_X(window) ((window) -> grid_x)
+#define WINDOW_GRID_Y(window) ((window) -> grid_y)
+#define WINDOW_CURSOR_X(window) ((window) -> cursor_x)
+#define WINDOW_CURSOR_Y(window) ((window) -> cursor_y)
+#define WINDOW_CURSOR_WIDTH(window) ((window) -> cursor_width)
+#define WINDOW_CURSOR_HEIGHT(window) ((window) -> cursor_height)
+#define WINDOW_CURSOR_STYLE(window) ((window) -> cursor_style)
+#define WINDOW_QID(window) ((window) -> qid)
+#define WINDOW_EVENT_QID(window) ((window) -> event_qid)
+#define WINDOW_WID(window) ((window) -> wid)
+#define WINDOW_FOREGROUND_COLOR(window) ((window) -> foreground_color)
+#define WINDOW_BACKGROUND_COLOR(window) ((window) -> background_color)
+#define WINDOW_CURSOR_SHOWNP(window) ((window) -> cursor_shownp)
+#define WINDOW_MINIMIZINGP(window) ((window) -> minimizingp)
+#define WINDOW_MINIMIZEDP(window) ((window) -> minimizedp)
+#define WINDOW_PERMANENTP(window) ((window) -> permanentp)
typedef struct
{
} pm_tqueue_t;
#define PM_TQUEUE_HWND(q) (((pm_tqueue_t *) (q)) -> hwnd)
\f
-static void simple_transaction (qid_t, msg_t *);
-static void simple_reply (qid_t);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ qid_t qid;
+ qid_t event_qid;
+ const char * title;
+} sm_open_request_t;
+#define SM_OPEN_REQUEST_QID(m) (((sm_open_request_t *) (m)) -> qid)
+#define SM_OPEN_REQUEST_EVENT_QID(m) (((sm_open_request_t *) (m)) -> event_qid)
+#define SM_OPEN_REQUEST_TITLE(m) (((sm_open_request_t *) (m)) -> title)
-static void pm_thread_procedure (void *);
-static tqueue_t * make_pm_tqueue (HWND);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ wid_t wid;
+} sm_open_reply_t;
+#define SM_OPEN_REPLY_WID(m) (((sm_open_reply_t *) (m)) -> wid)
-static unsigned short cx2x (twindow_t *, unsigned short);
-static unsigned short cy2y (twindow_t *, unsigned short, int);
-static unsigned short x2cx (twindow_t *, unsigned short, int);
-static unsigned short y2cy (twindow_t *, unsigned short, int);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+} sm_close_t;
+#define SM_CLOSE_WINDOW(m) (((sm_close_t *) (m)) -> window)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ char showp;
+} sm_show_t;
+#define SM_SHOW_WINDOW(m) (((sm_show_t *) (m)) -> window)
+#define SM_SHOW_SHOWP(m) (((sm_show_t *) (m)) -> showp)
-static void initialize_twid_table (void);
-static twid_t allocate_twid (twindow_t *);
-static void deallocate_twid (twid_t);
-static twindow_t * twid_to_twindow (twid_t);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short x;
+ unsigned short y;
+ unsigned short size;
+ const char * data;
+} sm_write_t;
+#define SM_WRITE_WINDOW(m) (((sm_write_t *) (m)) -> window)
+#define SM_WRITE_X(m) (((sm_write_t *) (m)) -> x)
+#define SM_WRITE_Y(m) (((sm_write_t *) (m)) -> y)
+#define SM_WRITE_SIZE(m) (((sm_write_t *) (m)) -> size)
+#define SM_WRITE_DATA(m) (((sm_write_t *) (m)) -> data)
-static MRESULT EXPENTRY object_window_procedure (HWND, ULONG, MPARAM, MPARAM);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short x;
+ unsigned short y;
+} sm_move_cursor_t;
+#define SM_MOVE_CURSOR_WINDOW(m) (((sm_move_cursor_t *) (m)) -> window)
+#define SM_MOVE_CURSOR_X(m) (((sm_move_cursor_t *) (m)) -> x)
+#define SM_MOVE_CURSOR_Y(m) (((sm_move_cursor_t *) (m)) -> y)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short width;
+ unsigned short height;
+ unsigned short style;
+} sm_shape_cursor_t;
+#define SM_SHAPE_CURSOR_WINDOW(m) (((sm_shape_cursor_t *) (m)) -> window)
+#define SM_SHAPE_CURSOR_WIDTH(m) (((sm_shape_cursor_t *) (m)) -> width)
+#define SM_SHAPE_CURSOR_HEIGHT(m) (((sm_shape_cursor_t *) (m)) -> height)
+#define SM_SHAPE_CURSOR_STYLE(m) (((sm_shape_cursor_t *) (m)) -> style)
-static msg_t * make_twindow_open_request (qid_t, const char *);
-static void handle_twindow_open_request (msg_t *);
-static msg_t * make_twindow_open_reply (twid_t);
-
-static msg_t * make_twindow_close_request (twid_t);
-static void handle_twindow_close_request (msg_t *);
-
-static msg_t * make_twindow_write_request
- (twid_t, unsigned short, unsigned short, const char *, unsigned short);
-static void handle_twindow_write_request (msg_t *);
-
-static msg_t * make_twindow_move_cursor_request
- (twid_t, unsigned short, unsigned short);
-static void handle_twindow_move_cursor_request (msg_t *);
-
-static void handle_twindow_clear_request (msg_t *);
-static msg_t * make_twindow_clear_request (twid_t);
-
-static msg_t * make_twindow_clear_eol_request
- (twid_t, unsigned short, unsigned short);
-static void handle_twindow_clear_eol_request (msg_t *);
-
-static msg_t * make_twindow_scroll_request
- (twid_t, unsigned short, unsigned short, unsigned short, unsigned short,
- short, short);
-static void handle_twindow_scroll_request (msg_t *);
-
-static twindow_t * twindow_open (qid_t, const char *);
-static twindow_t * make_twindow (qid_t);
-static void twindow_close (twindow_t *);
-static msg_t * make_close_event (twid_t);
-static void twindow_write
- (twindow_t *, unsigned short, unsigned short, const char *, unsigned short);
-static void twindow_clear (twindow_t *);
-static void twindow_clear_eol (twindow_t *, unsigned short, unsigned short);
-static void invalidate_partial_line
- (twindow_t *, unsigned short, unsigned short, unsigned short);
-static void twindow_scroll
- (twindow_t *, unsigned short, unsigned short, unsigned short, unsigned short,
- short, short);
-static void twindow_move_cursor (twindow_t *, unsigned short, unsigned short);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ char showp;
+} sm_show_cursor_t;
+#define SM_SHOW_CURSOR_WINDOW(m) (((sm_show_cursor_t *) (m)) -> window)
+#define SM_SHOW_CURSOR_SHOWP(m) (((sm_show_cursor_t *) (m)) -> showp)
-static MRESULT EXPENTRY frame_window_procedure (HWND, ULONG, MPARAM, MPARAM);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short xl;
+ unsigned short xh;
+ unsigned short yl;
+ unsigned short yh;
+} sm_clear_t;
+#define SM_CLEAR_WINDOW(m) (((sm_clear_t *) (m)) -> window)
+#define SM_CLEAR_XL(m) (((sm_clear_t *) (m)) -> xl)
+#define SM_CLEAR_XH(m) (((sm_clear_t *) (m)) -> xh)
+#define SM_CLEAR_YL(m) (((sm_clear_t *) (m)) -> yl)
+#define SM_CLEAR_YH(m) (((sm_clear_t *) (m)) -> yh)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short xl;
+ unsigned short xh;
+ unsigned short yl;
+ unsigned short yh;
+ short x_delta;
+ short y_delta;
+} sm_scroll_t;
+#define SM_SCROLL_WINDOW(m) (((sm_scroll_t *) (m)) -> window)
+#define SM_SCROLL_XL(m) (((sm_scroll_t *) (m)) -> xl)
+#define SM_SCROLL_XH(m) (((sm_scroll_t *) (m)) -> xh)
+#define SM_SCROLL_YL(m) (((sm_scroll_t *) (m)) -> yl)
+#define SM_SCROLL_YH(m) (((sm_scroll_t *) (m)) -> yh)
+#define SM_SCROLL_X_DELTA(m) (((sm_scroll_t *) (m)) -> x_delta)
+#define SM_SCROLL_Y_DELTA(m) (((sm_scroll_t *) (m)) -> y_delta)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short xl;
+ unsigned short xh;
+ unsigned short yl;
+ unsigned short yh;
+} sm_invalidate_t;
+#define SM_INVALIDATE_WINDOW(m) (((sm_invalidate_t *) (m)) -> window)
+#define SM_INVALIDATE_XL(m) (((sm_invalidate_t *) (m)) -> xl)
+#define SM_INVALIDATE_XH(m) (((sm_invalidate_t *) (m)) -> xh)
+#define SM_INVALIDATE_YL(m) (((sm_invalidate_t *) (m)) -> yl)
+#define SM_INVALIDATE_YH(m) (((sm_invalidate_t *) (m)) -> yh)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short id;
+ const char * spec;
+} sm_set_font_request_t;
+#define SM_SET_FONT_REQUEST_WINDOW(m) \
+ (((sm_set_font_request_t *) (m)) -> window)
+#define SM_SET_FONT_REQUEST_ID(m) (((sm_set_font_request_t *) (m)) -> id)
+#define SM_SET_FONT_REQUEST_SPEC(m) (((sm_set_font_request_t *) (m)) -> spec)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ font_metrics_t * metrics;
+} sm_set_font_reply_t;
+#define SM_SET_FONT_REPLY_WINDOW(m) (((sm_set_font_reply_t *) (m)) -> window)
+#define SM_SET_FONT_REPLY_METRICS(m) (((sm_set_font_reply_t *) (m)) -> metrics)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short x;
+ unsigned short y;
+} sm_set_grid_t;
+#define SM_SET_GRID_WINDOW(m) (((sm_set_grid_t *) (m)) -> window)
+#define SM_SET_GRID_X(m) (((sm_set_grid_t *) (m)) -> x)
+#define SM_SET_GRID_Y(m) (((sm_set_grid_t *) (m)) -> y)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+} sm_activate_t;
+#define SM_ACTIVATE_WINDOW(m) (((sm_activate_t *) (m)) -> window)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+} sm_pos_request_t;
+#define SM_POS_REQUEST_WINDOW(m) (((sm_pos_request_t *) (m)) -> window)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ unsigned short x;
+ unsigned short y;
+} sm_pos_reply_t;
+#define SM_POS_REPLY_X(m) (((sm_pos_reply_t *) (m)) -> x)
+#define SM_POS_REPLY_Y(m) (((sm_pos_reply_t *) (m)) -> y)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short x;
+ unsigned short y;
+} sm_set_pos_t;
+#define SM_SET_POS_WINDOW(m) (((sm_set_pos_t *) (m)) -> window)
+#define SM_SET_POS_X(m) (((sm_set_pos_t *) (m)) -> x)
+#define SM_SET_POS_Y(m) (((sm_set_pos_t *) (m)) -> y)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+} sm_size_request_t;
+#define SM_SIZE_REQUEST_WINDOW(m) (((sm_size_request_t *) (m)) -> window)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ unsigned short width;
+ unsigned short height;
+} sm_size_reply_t;
+#define SM_SIZE_REPLY_WIDTH(m) (((sm_size_reply_t *) (m)) -> width)
+#define SM_SIZE_REPLY_HEIGHT(m) (((sm_size_reply_t *) (m)) -> height)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ unsigned short width;
+ unsigned short height;
+} sm_set_size_t;
+#define SM_SET_SIZE_WINDOW(m) (((sm_set_size_t *) (m)) -> window)
+#define SM_SET_SIZE_WIDTH(m) (((sm_set_size_t *) (m)) -> width)
+#define SM_SET_SIZE_HEIGHT(m) (((sm_set_size_t *) (m)) -> height)
+
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+} sm_focusp_request_t;
+#define SM_FOCUSP_REQUEST_WINDOW(m) (((sm_focusp_request_t *) (m)) -> window)
-static MRESULT EXPENTRY twindow_procedure (HWND, ULONG, MPARAM, MPARAM);
-static twindow_t * hwnd_to_twindow (HWND);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ char focusp;
+} sm_focusp_reply_t;
+#define SM_FOCUSP_REPLY_FOCUSP(m) (((sm_focusp_reply_t *) (m)) -> focusp)
-static void twindow_initialize (twindow_t *);
-static void initialize_default_font (twindow_t *, PSZ, LONG, LONG);
-static void initialize_attributes (twindow_t *);
-static void set_twindow_char_dimensions (twindow_t *);
-static void initialize_charmap (twindow_t *);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ window_state_t state;
+} sm_set_state_t;
+#define SM_SET_STATE_WINDOW(m) (((sm_set_state_t *) (m)) -> window)
+#define SM_SET_STATE_STATE(m) (((sm_set_state_t *) (m)) -> state)
-static int set_font_1 (HPS, PSZ, LONG, LONG);
-static int use_font (HPS, PFONTMETRICS, LONG);
+typedef struct
+{
+ DECLARE_MSG_HEADER_FIELDS;
+ window_t * window;
+ COLOR foreground;
+ COLOR background;
+} sm_set_colors_t;
+#define SM_SET_COLORS_WINDOW(m) (((sm_set_colors_t *) (m)) -> window)
+#define SM_SET_COLORS_FOREGROUND(m) (((sm_set_colors_t *) (m)) -> foreground)
+#define SM_SET_COLORS_BACKGROUND(m) (((sm_set_colors_t *) (m)) -> background)
+\f
+static void simple_transaction (qid_t, msg_t *);
+static void simple_reply (qid_t);
-static void twindow_paint (twindow_t *);
-static void draw_partial_line
- (twindow_t *, unsigned short, unsigned short, unsigned short);
-static void activate_cursor (twindow_t *);
-static void deactivate_cursor (twindow_t *);
-static void show_cursor (twindow_t *);
-static void hide_cursor (twindow_t *);
-static int twindow_focusp (twindow_t *);
+static void pm_thread_procedure (void *);
+static tqueue_t * make_pm_tqueue (HWND);
-static void twindow_resize (twindow_t *, unsigned short, unsigned short);
-static msg_t * make_resize_event (twid_t, unsigned short, unsigned short);
+static void initialize_wid_table (void);
+static wid_t allocate_wid (window_t *);
+static void deallocate_wid (wid_t);
+static window_t * wid_to_window (wid_t);
+static void close_all_windows (void);
-static int twindow_process_keychar
- (twindow_t *, unsigned short, unsigned char, unsigned char, unsigned short,
+static MRESULT EXPENTRY object_window_procedure (HWND, ULONG, MPARAM, MPARAM);
+static MRESULT EXPENTRY frame_window_procedure (HWND, ULONG, MPARAM, MPARAM);
+static MRESULT EXPENTRY window_procedure (HWND, ULONG, MPARAM, MPARAM);
+
+static wid_t open_window (qid_t, qid_t, const char *);
+static window_t * hwnd_to_window (HWND);
+static void close_window (window_t *);
+static void show_window (window_t *, int);
+static void move_cursor (window_t *, unsigned short, unsigned short);
+static void shape_cursor
+ (window_t *, unsigned short, unsigned short, unsigned short);
+static void show_cursor (window_t *, int);
+static void recreate_cursor (window_t *);
+static void activate_cursor (window_t *);
+static void deactivate_cursor (window_t *);
+static void clear_rectangle (window_t *, PRECTL);
+static font_metrics_t * set_font (window_t *, unsigned short, const char *);
+static void get_window_pos (window_t *, unsigned short *, unsigned short *);
+static void set_window_pos (window_t *, unsigned short, unsigned short);
+static void get_window_size (window_t *, unsigned short *, unsigned short *);
+static void set_window_size (window_t *, unsigned short, unsigned short);
+static int window_focusp (window_t *);
+static void set_window_state (window_t *, window_state_t);
+static void set_window_colors (window_t *, COLOR, COLOR);
+
+static msg_t * make_button_event
+ (wid_t, unsigned char, unsigned char, unsigned short, unsigned short,
unsigned short);
-static void send_key_event
- (twindow_t *, unsigned short, unsigned short, unsigned short);
+static msg_t * make_close_event (wid_t);
+static msg_t * make_focus_event (wid_t, int);
static msg_t * make_key_event
- (twid_t, unsigned short, unsigned short, unsigned short);
+ (wid_t, unsigned short, unsigned short, unsigned short);
+static msg_t * make_paint_event
+ (wid_t, unsigned short, unsigned short, unsigned short, unsigned short);
+static msg_t * make_resize_event (wid_t, unsigned short, unsigned short);
+static msg_t * make_visibility_event (wid_t, int);
\f
#define ID_RESOURCES 1
#define ID_FRAME 1
#define UWM_ENCAPSULATION WM_USER
-#define QWP_TWINDOW QWL_USER
+#define QWP_WINDOW QWL_USER
/* These should have been defined by PM header file. */
#define MRVOID MRFROMP (0)
#define MRTRUE MRFROMLONG (TRUE)
#define MRFALSE MRFROMLONG (FALSE)
-static qid_t pm_qid_local; /* PM thread side */
-static qid_t pm_qid_remote; /* other thread side */
+static qid_t pm_init_qid;
static TID pm_tid;
static HAB pm_hab;
static HMQ pm_hmq;
static HWND pm_object_window;
+static tqueue_t * pm_tqueue;
static PFNWP original_frame_window_procedure;
static const char object_class [] = "mit-scheme.object";
-static const char twindow_class [] = "mit-scheme.twindow";
-
-#define SEND_EVENT(twindow, message) \
-{ \
- if ((TWINDOW_EVENT_QID (twindow)) != QID_NONE) \
- OS2_send_message ((TWINDOW_EVENT_QID (twindow)), (message)); \
-}
+static const char window_class [] = "mit-scheme.window";
-#define FASTFILL(p, n, c) \
+#define SEND_EVENT(window, message) \
{ \
- char * FASTFILL_scan = (p); \
- char * FASTFILL_end = (FASTFILL_scan + (n)); \
- while (FASTFILL_scan < FASTFILL_end) \
- (*FASTFILL_scan++) = (c); \
+ if ((WINDOW_EVENT_QID (window)) != QID_NONE) \
+ OS2_send_message ((WINDOW_EVENT_QID (window)), (message)); \
}
#define window_error(name) OS2_logic_error (#name)
void
OS2_initialize_pm_thread (void)
{
- SET_MSG_TYPE_LENGTH (mt_twindow_open_request, sm_twindow_open_request_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_open_reply, sm_twindow_open_reply_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_close_request, sm_twindow_close_request_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_write_request, sm_twindow_write_request_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_move_cursor_request,
- sm_twindow_move_cursor_request_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_clear_request, sm_twindow_clear_request_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_clear_eol_request,
- sm_twindow_clear_eol_request_t);
- SET_MSG_TYPE_LENGTH (mt_twindow_scroll_request, sm_twindow_scroll_request_t);
- SET_MSG_TYPE_LENGTH (mt_key_event, sm_key_event_t);
+ SET_MSG_TYPE_LENGTH (mt_window_open_request, sm_open_request_t);
+ SET_MSG_TYPE_LENGTH (mt_window_open_reply, sm_open_reply_t);
+ SET_MSG_TYPE_LENGTH (mt_window_close, sm_close_t);
+ SET_MSG_TYPE_LENGTH (mt_window_show, sm_show_t);
+ SET_MSG_TYPE_LENGTH (mt_window_write, sm_write_t);
+ SET_MSG_TYPE_LENGTH (mt_window_move_cursor, sm_move_cursor_t);
+ SET_MSG_TYPE_LENGTH (mt_window_shape_cursor, sm_shape_cursor_t);
+ SET_MSG_TYPE_LENGTH (mt_window_show_cursor, sm_show_cursor_t);
+ SET_MSG_TYPE_LENGTH (mt_window_clear, sm_clear_t);
+ SET_MSG_TYPE_LENGTH (mt_window_scroll, sm_scroll_t);
+ SET_MSG_TYPE_LENGTH (mt_window_invalidate, sm_invalidate_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_font_request, sm_set_font_request_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_font_reply, sm_set_font_reply_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_grid, sm_set_grid_t);
+ SET_MSG_TYPE_LENGTH (mt_window_activate, sm_activate_t);
+ SET_MSG_TYPE_LENGTH (mt_window_pos_request, sm_pos_request_t);
+ SET_MSG_TYPE_LENGTH (mt_window_pos_reply, sm_pos_reply_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_pos, sm_set_pos_t);
+ SET_MSG_TYPE_LENGTH (mt_window_size_request, sm_size_request_t);
+ SET_MSG_TYPE_LENGTH (mt_window_size_reply, sm_size_reply_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_size, sm_set_size_t);
+ SET_MSG_TYPE_LENGTH (mt_window_focusp_request, sm_focusp_request_t);
+ SET_MSG_TYPE_LENGTH (mt_window_focusp_reply, sm_focusp_reply_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_state, sm_set_state_t);
+ SET_MSG_TYPE_LENGTH (mt_window_set_colors, sm_set_colors_t);
SET_MSG_TYPE_LENGTH (mt_button_event, sm_button_event_t);
SET_MSG_TYPE_LENGTH (mt_close_event, sm_close_event_t);
- SET_MSG_TYPE_LENGTH (mt_visibility_event, sm_visibility_event_t);
+ SET_MSG_TYPE_LENGTH (mt_focus_event, sm_focus_event_t);
+ SET_MSG_TYPE_LENGTH (mt_key_event, sm_key_event_t);
+ SET_MSG_TYPE_LENGTH (mt_paint_event, sm_paint_event_t);
SET_MSG_TYPE_LENGTH (mt_resize_event, sm_resize_event_t);
- initialize_twid_table ();
+ SET_MSG_TYPE_LENGTH (mt_visibility_event, sm_visibility_event_t);
+ initialize_wid_table ();
original_frame_window_procedure = 0;
- OS2_make_qid_pair ((&pm_qid_local), (&pm_qid_remote));
- OS2_open_qid (pm_qid_remote, OS2_scheme_tqueue);
- pm_tid = (OS2_beginthread (pm_thread_procedure, 0, 0x4000));
- /* Wait for init message from PM thread. This message tells us that
- the other end of the connection is established and that it is
- safe to send messages on the connection. */
- OS2_destroy_message (OS2_wait_for_message (pm_qid_remote, mt_init));
+ {
+ qid_t qid;
+ OS2_make_qid_pair ((&pm_init_qid), (&qid));
+ OS2_open_qid (qid, OS2_scheme_tqueue);
+ pm_tid = (OS2_beginthread (pm_thread_procedure, 0, 0x4000));
+ /* Wait for init message from PM thread. This message tells us
+ that the other end of the connection is established and that it
+ is safe to send messages on the connection. */
+ OS2_destroy_message (OS2_wait_for_message (qid, mt_init));
+ OS2_close_qid (qid);
+ }
+ add_reload_cleanup (close_all_windows);
}
+/* Define this to cause a calling thread to wait for the PM thread to
+ finish requests that have trivial replies. Otherwise, the calling
+ thread waits only when the request has a non-trivial reply.
+ Usually there is no good reason to wait for trivial replies. */
+/* #define WAIT_FOR_ACTIONS */
+
static void
simple_transaction (qid_t qid, msg_t * message)
{
+#ifdef WAIT_FOR_ACTIONS
OS2_destroy_message
(OS2_message_transaction (qid, message, mt_generic_reply));
+#else
+ OS2_send_message (qid, message);
+#endif
}
static void
simple_reply (qid_t qid)
{
+#ifdef WAIT_FOR_ACTIONS
OS2_send_message (qid, (OS2_create_message (mt_generic_reply)));
+#endif
}
\f
static void
{
QMSG qmsg;
- if ((OS2_thread_initialize (pm_qid_local)) != 0)
+ if ((OS2_thread_initialize (QID_NONE)) != 0)
OS2_logic_error ("Error signalled within PM thread.");
pm_hab = (WinInitialize (0));
if (pm_hab == NULLHANDLE)
window_error (WinInitialize);
- pm_hmq = (WinCreateMsgQueue (pm_hab, 0));
+ pm_hmq = (WinCreateMsgQueue (pm_hab, 1000));
if (pm_hmq == NULLHANDLE)
window_error (WinCreateMsgQueue);
if (!WinRegisterClass (pm_hab,
0))
window_error (WinRegisterClass);
if (!WinRegisterClass (pm_hab,
- ((PSZ) twindow_class),
- twindow_procedure,
+ ((PSZ) window_class),
+ window_procedure,
0, /* class style */
(sizeof (void *))))
window_error (WinRegisterClass);
));
if (pm_object_window == NULLHANDLE)
window_error (WinCreateWindow);
- OS2_open_qid (pm_qid_local, (make_pm_tqueue (pm_object_window)));
- OS2_send_message (pm_qid_local, (OS2_create_message (mt_init)));
+ pm_tqueue = (make_pm_tqueue (pm_object_window));
+ OS2_send_message (pm_init_qid, (OS2_create_message (mt_init)));
while (WinGetMsg (pm_hab, (&qmsg), 0, 0, 0))
WinDispatchMsg (pm_hab, (&qmsg));
if (!WinDestroyWindow (pm_object_window))
WinDestroyMsgQueue (pm_hmq);
WinTerminate (pm_hab);
}
-\f
+
static tqueue_t *
make_pm_tqueue (HWND hwnd)
{
return (tqueue);
}
-int
+msg_t *
OS2_read_pm_tqueue (tqueue_t * tqueue, int blockp)
{
OS2_logic_error ("Read from PM tqueue.");
MPVOID))
window_error (WinPostMsg);
}
-
-static unsigned short
-cx2x (twindow_t * twindow, unsigned short x)
-{
- return (x * (TWINDOW_CHAR_WIDTH (twindow)));
-}
-
-static unsigned short
-cy2y (twindow_t * twindow, unsigned short y, int lowerp)
-{
- /* lowerp => result is bottommost pel of cell. Otherwise result is
- bottommost pel of cell above. */
- unsigned short height = (TWINDOW_HEIGHT (twindow));
- unsigned short limit = (lowerp ? (height - 1) : height);
- return (((y <= limit) ? (limit - y) : 0) * (TWINDOW_CHAR_HEIGHT (twindow)));
-}
-
-static unsigned short
-x2cx (twindow_t * twindow, unsigned short x, int lowerp)
-{
- /* lowerp => `x' is inclusive lower bound, and result is cell it
- falls in. Otherwise, `x' is exclusive upper bound, and result is
- cell to its right, unless it falls on leftmost edge of cell. If
- the argument is inclusive-lower, then the result is also;
- likewise for exclusive-upper. */
- unsigned short cwidth = (TWINDOW_CHAR_WIDTH (twindow));
- unsigned short cx = (x / cwidth);
- return ((lowerp || ((x % cwidth) == 0)) ? cx : (cx + 1));
-}
-
-static unsigned short
-y2cy (twindow_t * twindow, unsigned short y, int lowerp)
-{
- /* lowerp => `y' is inclusive lower bound, and result is cell below
- the one it falls in. Otherwise, `y' is exclusive upper bound,
- and result is cell it falls in, unless it falls on bottommost
- edge of cell, when result is cell below. If the argument is
- inclusive-lower, then the result is exclusive-upper, and
- vice-versa. */
- unsigned short cheight = (TWINDOW_CHAR_HEIGHT (twindow));
- short height = (TWINDOW_HEIGHT (twindow));
- short cy = ((height - 1) - ((short) (y / cheight)));
- if (lowerp || ((y % cheight) == 0))
- cy += 1;
- return ((cy < 0) ? 0 : cy);
-}
\f
-static unsigned int twid_table_length;
-static twindow_t ** twid_table;
+static unsigned int wid_table_length;
+static window_t ** wid_table;
static void
-initialize_twid_table (void)
+initialize_wid_table (void)
{
- twid_table_length = 16;
- twid_table = (OS_malloc ((sizeof (twindow_t *)) * twid_table_length));
+ wid_table_length = 16;
+ wid_table = (OS_malloc ((sizeof (window_t *)) * wid_table_length));
{
- twindow_t ** scan = twid_table;
- twindow_t ** end = (scan + twid_table_length);
+ window_t ** scan = wid_table;
+ window_t ** end = (scan + wid_table_length);
while (scan < end)
(*scan++) = 0;
}
}
-static twid_t
-allocate_twid (twindow_t * twindow)
+static wid_t
+allocate_wid (window_t * window)
{
- twid_t twid = 0;
+ wid_t wid = 0;
while (1)
{
- if (twid == twid_table_length)
+ if (wid == wid_table_length)
{
- twid_table_length *= 2;
- twid_table
- = (OS_realloc (twid_table,
- ((sizeof (twindow_t *)) * twid_table_length)));
+ wid_table_length *= 2;
+ wid_table
+ = (OS_realloc (wid_table,
+ ((sizeof (window_t *)) * wid_table_length)));
{
- twindow_t ** scan = (twid_table + twid + 1);
- twindow_t ** end = (twid_table + twid_table_length);
+ window_t ** scan = (wid_table + wid + 1);
+ window_t ** end = (wid_table + wid_table_length);
while (scan < end)
(*scan++) = 0;
}
break;
}
- if ((twid_table [twid]) == 0)
+ if ((wid_table [wid]) == 0)
break;
- twid += 1;
+ wid += 1;
}
- (twid_table [twid]) = twindow;
- (TWINDOW_TWID (twindow)) = twid;
- return (twid);
+ (wid_table [wid]) = window;
+ (WINDOW_WID (window)) = wid;
+ return (wid);
}
static void
-deallocate_twid (twid_t twid)
+deallocate_wid (wid_t wid)
{
- (twid_table [twid]) = 0;
+ (wid_table [wid]) = 0;
}
-static twindow_t *
-twid_to_twindow (twid_t twid)
+static window_t *
+wid_to_window (wid_t wid)
{
- if ((twid_table [twid]) == 0)
+ if ((wid_table [wid]) == 0)
OS2_logic_error ("Invalid terminal window ID.");
- return (twid_table [twid]);
+ return (wid_table [wid]);
+}
+
+int
+OS2_wid_validp (wid_t wid)
+{
+ return ((wid < wid_table_length) && ((wid_table [wid]) != 0));
+}
+
+static void
+close_all_windows (void)
+{
+ window_t ** scan = wid_table;
+ window_t ** end = (scan + wid_table_length);
+ while (scan < end)
+ {
+ window_t * window = (*scan++);
+ if ((window != 0) && (!WINDOW_PERMANENTP (window)))
+ close_window (window);
+ }
}
\f
/* Implementation of the object window. The object window handles
encapsulated messages sent from the Scheme thread. This defines
the protocol used to communicate with the Scheme thread. */
+static void handle_window_open_request (msg_t *);
+static void handle_window_close_request (msg_t *);
+static void handle_window_show_request (msg_t *);
+static void handle_window_write_request (msg_t *);
+static void handle_window_move_cursor_request (msg_t *);
+static void handle_window_shape_cursor_request (msg_t *);
+static void handle_window_show_cursor_request (msg_t *);
+static void handle_window_clear_request (msg_t *);
+static void handle_window_scroll_request (msg_t *);
+static void handle_window_invalidate_request (msg_t *);
+static void handle_window_set_font_request (msg_t *);
+static void handle_window_set_grid_request (msg_t *);
+static void handle_window_activate_request (msg_t *);
+static void handle_window_pos_request (msg_t *);
+static void handle_window_set_pos_request (msg_t *);
+static void handle_window_size_request (msg_t *);
+static void handle_window_set_size_request (msg_t *);
+static void handle_window_focusp_request (msg_t *);
+static void handle_window_set_state_request (msg_t *);
+static void handle_window_set_colors_request (msg_t *);
+
static MRESULT EXPENTRY
object_window_procedure (HWND window, ULONG msg, MPARAM mp1, MPARAM mp2)
{
msg_t * message = (PVOIDFROMMP (mp1));
switch (MSG_TYPE (message))
{
- case mt_twindow_open_request:
- handle_twindow_open_request (message);
+ case mt_window_open_request:
+ handle_window_open_request (message);
+ break;
+ case mt_window_close:
+ handle_window_close_request (message);
+ break;
+ case mt_window_show:
+ handle_window_show_request (message);
+ break;
+ case mt_window_write:
+ handle_window_write_request (message);
+ break;
+ case mt_window_move_cursor:
+ handle_window_move_cursor_request (message);
+ break;
+ case mt_window_shape_cursor:
+ handle_window_shape_cursor_request (message);
+ break;
+ case mt_window_show_cursor:
+ handle_window_show_cursor_request (message);
+ break;
+ case mt_window_clear:
+ handle_window_clear_request (message);
+ break;
+ case mt_window_scroll:
+ handle_window_scroll_request (message);
+ break;
+ case mt_window_invalidate:
+ handle_window_invalidate_request (message);
+ break;
+ case mt_window_set_font_request:
+ handle_window_set_font_request (message);
+ break;
+ case mt_window_set_grid:
+ handle_window_set_grid_request (message);
+ break;
+ case mt_window_activate:
+ handle_window_activate_request (message);
break;
- case mt_twindow_close_request:
- handle_twindow_close_request (message);
+ case mt_window_pos_request:
+ handle_window_pos_request (message);
break;
- case mt_twindow_write_request:
- handle_twindow_write_request (message);
+ case mt_window_set_pos:
+ handle_window_set_pos_request (message);
break;
- case mt_twindow_move_cursor_request:
- handle_twindow_move_cursor_request (message);
+ case mt_window_size_request:
+ handle_window_size_request (message);
break;
- case mt_twindow_clear_request:
- handle_twindow_clear_request (message);
+ case mt_window_set_size:
+ handle_window_set_size_request (message);
break;
- case mt_twindow_clear_eol_request:
- handle_twindow_clear_eol_request (message);
+ case mt_window_focusp_request:
+ handle_window_focusp_request (message);
break;
- case mt_twindow_scroll_request:
- handle_twindow_scroll_request (message);
+ case mt_window_set_state:
+ handle_window_set_state_request (message);
+ break;
+ case mt_window_set_colors:
+ handle_window_set_colors_request (message);
break;
default:
OS2_logic_error ("Unknown message type sent to PM thread.");
}
return (MRVOID);
}
+\f
+qid_t
+OS2_create_pm_qid (tqueue_t * tqueue)
+{
+ qid_t pm_side;
+ qid_t client_side;
+ OS2_make_qid_pair ((&pm_side), (&client_side));
+ OS2_open_qid (pm_side, pm_tqueue);
+ OS2_open_qid (client_side, tqueue);
+ return (client_side);
+}
+
+wid_t
+OS2_window_open (qid_t qid, qid_t event_qid, const char * title)
+{
+ msg_t * message = (OS2_create_message (mt_window_open_request));
+ wid_t wid;
+ (SM_OPEN_REQUEST_QID (message)) = qid;
+ (SM_OPEN_REQUEST_EVENT_QID (message)) = event_qid;
+ (SM_OPEN_REQUEST_TITLE (message)) = title;
+ message = (OS2_message_transaction (qid, message, mt_window_open_reply));
+ wid = (SM_OPEN_REPLY_WID (message));
+ OS2_destroy_message (message);
+ return (wid);
+}
-twid_t
-OS2_twindow_open (qid_t event_qid, const char * title)
+static void
+handle_window_open_request (msg_t * message)
{
- msg_t * reply
- = (OS2_message_transaction (pm_qid_remote,
- (make_twindow_open_request (event_qid, title)),
- mt_twindow_open_reply));
- twid_t twid = (SM_TWINDOW_OPEN_REPLY_TWID (reply));
- OS2_destroy_message (reply);
- return (twid);
+ qid_t sender = (MSG_SENDER (message));
+ qid_t qid = (SM_OPEN_REQUEST_QID (message));
+ qid_t event_qid = (SM_OPEN_REQUEST_EVENT_QID (message));
+ const char * title = (SM_OPEN_REQUEST_TITLE (message));
+ OS2_destroy_message (message);
+ message = (OS2_create_message (mt_window_open_reply));
+ (SM_OPEN_REPLY_WID (message)) = (open_window (qid, event_qid, title));
+ OS2_send_message (sender, message);
}
-static msg_t *
-make_twindow_open_request (qid_t event_qid, const char * title)
+void
+OS2_window_permanent (wid_t wid)
{
- msg_t * message = (OS2_create_message (mt_twindow_open_request));
- (SM_TWINDOW_OPEN_REQUEST_EVENT_QID (message)) = event_qid;
- (SM_TWINDOW_OPEN_REQUEST_TITLE (message)) = title;
- return (message);
+ (WINDOW_PERMANENTP (wid_to_window (wid))) = 1;
+}
+
+void
+OS2_window_close (wid_t wid)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_close));
+ (SM_CLOSE_WINDOW (message)) = window;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_open_request (msg_t * message)
+handle_window_close_request (msg_t * message)
{
qid_t sender = (MSG_SENDER (message));
- qid_t event_qid = (SM_TWINDOW_OPEN_REQUEST_EVENT_QID (message));
- const char * title = (SM_TWINDOW_OPEN_REQUEST_TITLE (message));
+ window_t * window = (SM_CLOSE_WINDOW (message));
OS2_destroy_message (message);
- OS2_send_message
- (sender,
- (make_twindow_open_reply
- (allocate_twid (twindow_open (event_qid, title)))));
+ close_window (window);
+ simple_reply (sender);
}
-static msg_t *
-make_twindow_open_reply (twid_t twid)
+void
+OS2_window_show (wid_t wid, int showp)
{
- msg_t * message = (OS2_create_message (mt_twindow_open_reply));
- (SM_TWINDOW_OPEN_REPLY_TWID (message)) = twid;
- return (message);
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_show));
+ (SM_SHOW_WINDOW (message)) = window;
+ (SM_SHOW_SHOWP (message)) = showp;
+ simple_transaction ((WINDOW_QID (window)), message);
}
-\f
+
+static void
+handle_window_show_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SHOW_WINDOW (message));
+ int showp = (SM_SHOW_SHOWP (message));
+ OS2_destroy_message (message);
+ show_window (window, showp);
+ simple_reply (sender);
+}
+
void
-OS2_twindow_close (twid_t twid)
+OS2_window_write (wid_t wid, unsigned short x, unsigned short y,
+ const char * data, unsigned short size)
{
- simple_transaction (pm_qid_remote, (make_twindow_close_request (twid)));
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_write));
+ char * copy = (OS_malloc (size));
+ FASTCOPY (data, copy, size);
+ (SM_WRITE_WINDOW (message)) = window;
+ (SM_WRITE_X (message)) = x;
+ (SM_WRITE_Y (message)) = y;
+ (SM_WRITE_DATA (message)) = copy;
+ (SM_WRITE_SIZE (message)) = size;
+ simple_transaction ((WINDOW_QID (window)), message);
}
-static msg_t *
-make_twindow_close_request (twid_t twid)
+static void
+handle_window_write_request (msg_t * message)
{
- msg_t * message = (OS2_create_message (mt_twindow_close_request));
- (SM_TWINDOW_CLOSE_REQUEST_TWID (message)) = twid;
- return (message);
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_WRITE_WINDOW (message));
+ const char * data = (SM_WRITE_DATA (message));
+ unsigned short size = (SM_WRITE_SIZE (message));
+ POINTL ptl;
+ (ptl . x) = (SM_WRITE_X (message));
+ (ptl . y) = (SM_WRITE_Y (message));
+ OS2_destroy_message (message);
+ deactivate_cursor (window);
+ if (size <= 512)
+ GpiCharStringAt ((WINDOW_HPS (window)), (& ptl), size, ((char *) data));
+ else
+ {
+ const char * scan = data;
+ GpiMove ((WINDOW_HPS (window)), (& ptl));
+ while (size > 0)
+ {
+ unsigned short n = ((size > 512) ? 512 : size);
+ GpiCharString ((WINDOW_HPS (window)), n, ((char *) scan));
+ size -= n;
+ scan += n;
+ }
+ }
+ activate_cursor (window);
+ OS_free ((char *) data);
+ simple_reply (sender);
+}
+
+void
+OS2_window_move_cursor (wid_t wid, unsigned short x, unsigned short y)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_move_cursor));
+ (SM_MOVE_CURSOR_WINDOW (message)) = window;
+ (SM_MOVE_CURSOR_X (message)) = x;
+ (SM_MOVE_CURSOR_Y (message)) = y;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_close_request (msg_t * message)
+handle_window_move_cursor_request (msg_t * message)
{
- qid_t qid = (MSG_SENDER (message));
- twid_t twid = (SM_TWINDOW_CLOSE_REQUEST_TWID (message));
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_MOVE_CURSOR_WINDOW (message));
+ (WINDOW_CURSOR_X (window)) = (SM_MOVE_CURSOR_X (message));
+ (WINDOW_CURSOR_Y (window)) = (SM_MOVE_CURSOR_Y (message));
OS2_destroy_message (message);
- twindow_close (twid_to_twindow (twid));
- simple_reply (qid);
+ move_cursor (window, (WINDOW_CURSOR_X (window)), (WINDOW_CURSOR_Y (window)));
+ simple_reply (sender);
}
void
-OS2_twindow_write (twid_t twid, unsigned short x, unsigned short y,
- const char * data, unsigned short size)
+OS2_window_shape_cursor (wid_t wid,
+ unsigned short width, unsigned short height,
+ unsigned short style)
{
- simple_transaction (pm_qid_remote,
- (make_twindow_write_request (twid, x, y, data, size)));
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_shape_cursor));
+ (SM_SHAPE_CURSOR_WINDOW (message)) = window;
+ (SM_SHAPE_CURSOR_WIDTH (message)) = width;
+ (SM_SHAPE_CURSOR_HEIGHT (message)) = height;
+ (SM_SHAPE_CURSOR_STYLE (message)) = style;
+ simple_transaction ((WINDOW_QID (window)), message);
}
-static msg_t *
-make_twindow_write_request (twid_t twid, unsigned short x, unsigned short y,
- const char * data, unsigned short size)
-{
- msg_t * message = (OS2_create_message (mt_twindow_write_request));
- (SM_TWINDOW_WRITE_REQUEST_TWID (message)) = twid;
- (SM_TWINDOW_WRITE_REQUEST_X (message)) = x;
- (SM_TWINDOW_WRITE_REQUEST_Y (message)) = y;
- (SM_TWINDOW_WRITE_REQUEST_DATA (message)) = data;
- (SM_TWINDOW_WRITE_REQUEST_SIZE (message)) = size;
- return (message);
+static void
+handle_window_shape_cursor_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SHAPE_CURSOR_WINDOW (message));
+ unsigned short width = (SM_SHAPE_CURSOR_WIDTH (message));
+ unsigned short height = (SM_SHAPE_CURSOR_HEIGHT (message));
+ unsigned short style = (SM_SHAPE_CURSOR_STYLE (message));
+ OS2_destroy_message (message);
+ shape_cursor (window, width, height, style);
+ simple_reply (sender);
+}
+
+void
+OS2_window_show_cursor (wid_t wid, int showp)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_show_cursor));
+ (SM_SHOW_CURSOR_WINDOW (message)) = window;
+ (SM_SHOW_CURSOR_SHOWP (message)) = showp;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_write_request (msg_t * message)
-{
- qid_t qid = (MSG_SENDER (message));
- twid_t twid = (SM_TWINDOW_WRITE_REQUEST_TWID (message));
- unsigned short x = (SM_TWINDOW_WRITE_REQUEST_X (message));
- unsigned short y = (SM_TWINDOW_WRITE_REQUEST_Y (message));
- const char * data = (SM_TWINDOW_WRITE_REQUEST_DATA (message));
- unsigned short size = (SM_TWINDOW_WRITE_REQUEST_SIZE (message));
+handle_window_show_cursor_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SHOW_CURSOR_WINDOW (message));
+ int showp = ((SM_SHOW_CURSOR_SHOWP (message)) ? 1 : 0);
OS2_destroy_message (message);
- twindow_write ((twid_to_twindow (twid)), x, y, data, size);
- simple_reply (qid);
+ show_cursor (window, showp);
+ simple_reply (sender);
}
-\f
+
void
-OS2_twindow_move_cursor (twid_t twid, unsigned short x, unsigned short y)
+OS2_window_clear (wid_t wid,
+ unsigned short xl, unsigned short xh,
+ unsigned short yl, unsigned short yh)
{
- simple_transaction (pm_qid_remote,
- (make_twindow_move_cursor_request (twid, x, y)));
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_clear));
+ (SM_CLEAR_WINDOW (message)) = window;
+ (SM_CLEAR_XL (message)) = xl;
+ (SM_CLEAR_XH (message)) = xh;
+ (SM_CLEAR_YL (message)) = yl;
+ (SM_CLEAR_YH (message)) = yh;
+ simple_transaction ((WINDOW_QID (window)), message);
}
-static msg_t *
-make_twindow_move_cursor_request (twid_t twid, unsigned short x,
- unsigned short y)
+static void
+handle_window_clear_request (msg_t * message)
{
- msg_t * message = (OS2_create_message (mt_twindow_move_cursor_request));
- (SM_TWINDOW_MOVE_CURSOR_REQUEST_TWID (message)) = twid;
- (SM_TWINDOW_MOVE_CURSOR_REQUEST_X (message)) = x;
- (SM_TWINDOW_MOVE_CURSOR_REQUEST_Y (message)) = y;
- return (message);
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_CLEAR_WINDOW (message));
+ RECTL rectl;
+ (rectl . xLeft) = (SM_CLEAR_XL (message));
+ (rectl . xRight) = (SM_CLEAR_XH (message));
+ (rectl . yBottom) = (SM_CLEAR_YL (message));
+ (rectl . yTop) = (SM_CLEAR_YH (message));
+ OS2_destroy_message (message);
+ clear_rectangle (window, (& rectl));
+ simple_reply (sender);
+}
+
+void
+OS2_window_scroll (wid_t wid,
+ unsigned short xl, unsigned short xh,
+ unsigned short yl, unsigned short yh,
+ short x_delta, short y_delta)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_scroll));
+ (SM_SCROLL_WINDOW (message)) = window;
+ (SM_SCROLL_XL (message)) = xl;
+ (SM_SCROLL_XH (message)) = xh;
+ (SM_SCROLL_YL (message)) = yl;
+ (SM_SCROLL_YH (message)) = yh;
+ (SM_SCROLL_X_DELTA (message)) = x_delta;
+ (SM_SCROLL_Y_DELTA (message)) = y_delta;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_move_cursor_request (msg_t * message)
+handle_window_scroll_request (msg_t * message)
{
- qid_t qid = (MSG_SENDER (message));
- twid_t twid = (SM_TWINDOW_MOVE_CURSOR_REQUEST_TWID (message));
- unsigned short x = (SM_TWINDOW_MOVE_CURSOR_REQUEST_X (message));
- unsigned short y = (SM_TWINDOW_MOVE_CURSOR_REQUEST_Y (message));
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SCROLL_WINDOW (message));
+ short x_delta = (SM_SCROLL_X_DELTA (message));
+ short y_delta = (SM_SCROLL_Y_DELTA (message));
+ RECTL rectl;
+ (rectl . xLeft) = (SM_SCROLL_XL (message));
+ (rectl . xRight) = (SM_SCROLL_XH (message));
+ (rectl . yBottom) = (SM_SCROLL_YL (message));
+ (rectl . yTop) = (SM_SCROLL_YH (message));
OS2_destroy_message (message);
- twindow_move_cursor ((twid_to_twindow (twid)), x, y);
- simple_reply (qid);
+ if ((WinScrollWindow ((WINDOW_CLIENT (window)),
+ x_delta, y_delta, (& rectl), 0, NULLHANDLE, 0, 0))
+ == RGN_ERROR)
+ window_error (WinScrollWindow);
+ simple_reply (sender);
}
-\f
+
void
-OS2_twindow_clear (twid_t twid)
+OS2_window_invalidate (wid_t wid,
+ unsigned short xl, unsigned short xh,
+ unsigned short yl, unsigned short yh)
{
- simple_transaction (pm_qid_remote, (make_twindow_clear_request (twid)));
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_invalidate));
+ (SM_INVALIDATE_WINDOW (message)) = window;
+ (SM_INVALIDATE_XL (message)) = xl;
+ (SM_INVALIDATE_XH (message)) = xh;
+ (SM_INVALIDATE_YL (message)) = yl;
+ (SM_INVALIDATE_YH (message)) = yh;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_clear_request (msg_t * message)
+handle_window_invalidate_request (msg_t * message)
{
- qid_t qid = (MSG_SENDER (message));
- twid_t twid = (SM_TWINDOW_CLEAR_REQUEST_TWID (message));
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_INVALIDATE_WINDOW (message));
+ RECTL rectl;
+ (rectl . xLeft) = (SM_INVALIDATE_XL (message));
+ (rectl . xRight) = (SM_INVALIDATE_XH (message));
+ (rectl . yBottom) = (SM_INVALIDATE_YL (message));
+ (rectl . yTop) = (SM_INVALIDATE_YH (message));
OS2_destroy_message (message);
- twindow_clear (twid_to_twindow (twid));
- simple_reply (qid);
+ if (!WinInvalidateRect ((WINDOW_CLIENT (window)), (& rectl), FALSE))
+ window_error (WinInvalidateRect);
+ simple_reply (sender);
+}
+
+font_metrics_t *
+OS2_window_set_font (wid_t wid, unsigned short id, const char * name)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_set_font_request));
+ font_metrics_t * metrics;
+ (SM_SET_FONT_REQUEST_WINDOW (message)) = window;
+ (SM_SET_FONT_REQUEST_ID (message)) = id;
+ (SM_SET_FONT_REQUEST_SPEC (message)) = name;
+ message
+ = (OS2_message_transaction
+ ((WINDOW_QID (window)), message, mt_window_set_font_reply));
+ metrics = (SM_SET_FONT_REPLY_METRICS (message));
+ OS2_destroy_message (message);
+ return (metrics);
}
-static msg_t *
-make_twindow_clear_request (twid_t twid)
+static void
+handle_window_set_font_request (msg_t * message)
{
- msg_t * message = (OS2_create_message (mt_twindow_clear_request));
- (SM_TWINDOW_CLEAR_REQUEST_TWID (message)) = twid;
- return (message);
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SET_FONT_REQUEST_WINDOW (message));
+ unsigned short id = (SM_SET_FONT_REQUEST_ID (message));
+ const char * spec = (SM_SET_FONT_REQUEST_SPEC (message));
+ OS2_destroy_message (message);
+ message = (OS2_create_message (mt_window_set_font_reply));
+ (SM_SET_FONT_REPLY_METRICS (message)) = (set_font (window, id, spec));
+ OS2_send_message (sender, message);
}
void
-OS2_twindow_clear_eol (twid_t twid, unsigned short x, unsigned short y)
+OS2_window_set_grid (wid_t wid, unsigned short x, unsigned short y)
{
- simple_transaction (pm_qid_remote,
- (make_twindow_clear_eol_request (twid, x, y)));
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_set_grid));
+ (SM_SET_GRID_WINDOW (message)) = window;
+ (SM_SET_GRID_X (message)) = x;
+ (SM_SET_GRID_Y (message)) = y;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_clear_eol_request (msg_t * message)
+handle_window_set_grid_request (msg_t * message)
{
- qid_t qid = (MSG_SENDER (message));
- twid_t twid = (SM_TWINDOW_CLEAR_EOL_REQUEST_TWID (message));
- unsigned short x = (SM_TWINDOW_CLEAR_EOL_REQUEST_X (message));
- unsigned short y = (SM_TWINDOW_CLEAR_EOL_REQUEST_Y (message));
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SET_GRID_WINDOW (message));
+ (WINDOW_GRID_X (window)) = (SM_SET_GRID_X (message));
+ (WINDOW_GRID_Y (window)) = (SM_SET_GRID_Y (message));
OS2_destroy_message (message);
- twindow_clear_eol ((twid_to_twindow (twid)), x, y);
- simple_reply (qid);
+ simple_reply (sender);
}
-static msg_t *
-make_twindow_clear_eol_request (twid_t twid, unsigned short x,
- unsigned short y)
+void
+OS2_window_activate (wid_t wid)
{
- msg_t * message = (OS2_create_message (mt_twindow_clear_eol_request));
- (SM_TWINDOW_CLEAR_EOL_REQUEST_TWID (message)) = twid;
- (SM_TWINDOW_CLEAR_EOL_REQUEST_X (message)) = x;
- (SM_TWINDOW_CLEAR_EOL_REQUEST_Y (message)) = y;
- return (message);
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_activate));
+ (SM_ACTIVATE_WINDOW (message)) = window;
+ simple_transaction ((WINDOW_QID (window)), message);
}
-\f
+
+static void
+handle_window_activate_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_ACTIVATE_WINDOW (message));
+ OS2_destroy_message (message);
+ if (!WinSetActiveWindow (HWND_DESKTOP, (WINDOW_FRAME (window))))
+ window_error (WinSetActiveWindow);
+ simple_reply (sender);
+}
+
void
-OS2_twindow_scroll (twid_t twid,
- unsigned short x_start, unsigned short x_end,
- unsigned short y_start, unsigned short y_end,
- short x_delta, short y_delta)
+OS2_window_pos (wid_t wid, unsigned short * x, unsigned short * y)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_pos_request));
+ (SM_POS_REQUEST_WINDOW (message)) = window;
+ message
+ = (OS2_message_transaction ((WINDOW_QID (window)),
+ message,
+ mt_window_pos_reply));
+ (* x) = (SM_POS_REPLY_X (message));
+ (* y) = (SM_POS_REPLY_Y (message));
+ OS2_destroy_message (message);
+}
+
+static void
+handle_window_pos_request (msg_t * message)
{
- simple_transaction
- (pm_qid_remote,
- (make_twindow_scroll_request
- (twid, x_start, x_end, y_start, y_end, x_delta, y_delta)));
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_POS_REQUEST_WINDOW (message));
+ OS2_destroy_message (message);
+ message = (OS2_create_message (mt_window_pos_reply));
+ get_window_pos (window,
+ (& (SM_POS_REPLY_X (message))),
+ (& (SM_POS_REPLY_Y (message))));
+ OS2_send_message (sender, message);
}
-static msg_t *
-make_twindow_scroll_request (twid_t twid,
- unsigned short x_start, unsigned short x_end,
- unsigned short y_start, unsigned short y_end,
- short x_delta, short y_delta)
-{
- msg_t * message = (OS2_create_message (mt_twindow_scroll_request));
- (SM_TWINDOW_SCROLL_REQUEST_TWID (message)) = twid;
- (SM_TWINDOW_SCROLL_REQUEST_X_START (message)) = x_start;
- (SM_TWINDOW_SCROLL_REQUEST_X_END (message)) = x_end;
- (SM_TWINDOW_SCROLL_REQUEST_Y_START (message)) = y_start;
- (SM_TWINDOW_SCROLL_REQUEST_Y_END (message)) = y_end;
- (SM_TWINDOW_SCROLL_REQUEST_X_DELTA (message)) = x_delta;
- (SM_TWINDOW_SCROLL_REQUEST_Y_DELTA (message)) = y_delta;
- return (message);
+void
+OS2_window_set_pos (wid_t wid, unsigned short x, unsigned short y)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_set_pos));
+ (SM_SET_POS_WINDOW (message)) = window;
+ (SM_SET_POS_X (message)) = x;
+ (SM_SET_POS_Y (message)) = y;
+ simple_transaction ((WINDOW_QID (window)), message);
}
static void
-handle_twindow_scroll_request (msg_t * message)
-{
- qid_t qid = (MSG_SENDER (message));
- twid_t twid = (SM_TWINDOW_SCROLL_REQUEST_TWID (message));
- unsigned short x_start = (SM_TWINDOW_SCROLL_REQUEST_X_START (message));
- unsigned short x_end = (SM_TWINDOW_SCROLL_REQUEST_X_END (message));
- unsigned short y_start = (SM_TWINDOW_SCROLL_REQUEST_Y_START (message));
- unsigned short y_end = (SM_TWINDOW_SCROLL_REQUEST_Y_END (message));
- short x_delta = (SM_TWINDOW_SCROLL_REQUEST_X_DELTA (message));
- short y_delta = (SM_TWINDOW_SCROLL_REQUEST_Y_DELTA (message));
+handle_window_set_pos_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SET_POS_WINDOW (message));
+ unsigned short x = (SM_SET_POS_X (message));
+ unsigned short y = (SM_SET_POS_Y (message));
OS2_destroy_message (message);
- twindow_scroll
- ((twid_to_twindow (twid)),
- x_start, x_end, y_start, y_end, x_delta, y_delta);
- simple_reply (qid);
+ set_window_pos (window, x, y);
+ simple_reply (sender);
}
-\f
-static twindow_t *
-twindow_open (qid_t event_qid, const char * title)
+
+void
+OS2_window_size (wid_t wid, unsigned short * width, unsigned short * height)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_size_request));
+ (SM_SIZE_REQUEST_WINDOW (message)) = window;
+ message
+ = (OS2_message_transaction ((WINDOW_QID (window)),
+ message,
+ mt_window_size_reply));
+ (* width) = (SM_SIZE_REPLY_WIDTH (message));
+ (* height) = (SM_SIZE_REPLY_HEIGHT (message));
+ OS2_destroy_message (message);
+}
+
+static void
+handle_window_size_request (msg_t * message)
{
- twindow_t * twindow = (make_twindow (event_qid));
- FRAMECDATA frame_data;
- HWND frame_window;
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SIZE_REQUEST_WINDOW (message));
+ OS2_destroy_message (message);
+ message = (OS2_create_message (mt_window_size_reply));
+ get_window_size (window,
+ (& (SM_SIZE_REPLY_WIDTH (message))),
+ (& (SM_SIZE_REPLY_HEIGHT (message))));
+ OS2_send_message (sender, message);
+}
- (frame_data . cb) = (sizeof (frame_data));
- (frame_data . flCreateFlags)
- = (FCF_TITLEBAR | FCF_SYSMENU | FCF_SHELLPOSITION | FCF_SIZEBORDER
- | FCF_MINMAX | FCF_TASKLIST);
- (frame_data . hmodResources) = NULLHANDLE;
- (frame_data . idResources) = ID_RESOURCES;
- frame_window
- = (WinCreateWindow (HWND_DESKTOP,
- WC_FRAME,
+void
+OS2_window_set_size (wid_t wid, unsigned short width, unsigned short height)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_set_size));
+ (SM_SET_SIZE_WINDOW (message)) = window;
+ (SM_SET_SIZE_WIDTH (message)) = width;
+ (SM_SET_SIZE_HEIGHT (message)) = height;
+ simple_transaction ((WINDOW_QID (window)), message);
+}
+
+static void
+handle_window_set_size_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SET_SIZE_WINDOW (message));
+ unsigned short width = (SM_SET_SIZE_WIDTH (message));
+ unsigned short height = (SM_SET_SIZE_HEIGHT (message));
+ OS2_destroy_message (message);
+ set_window_size (window, width, height);
+ simple_reply (sender);
+}
+
+int
+OS2_window_focusp (wid_t wid)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_focusp_request));
+ (SM_FOCUSP_REQUEST_WINDOW (message)) = window;
+ message
+ = (OS2_message_transaction ((WINDOW_QID (window)),
+ message,
+ mt_window_focusp_reply));
+ {
+ int result = (SM_FOCUSP_REPLY_FOCUSP (message));
+ OS2_destroy_message (message);
+ return (result);
+ }
+}
+
+static void
+handle_window_focusp_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_FOCUSP_REQUEST_WINDOW (message));
+ OS2_destroy_message (message);
+ message = (OS2_create_message (mt_window_focusp_reply));
+ (SM_FOCUSP_REPLY_FOCUSP (message)) = (window_focusp (window));
+ OS2_send_message (sender, message);
+}
+
+void
+OS2_window_set_state (wid_t wid, window_state_t state)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_set_state));
+ (SM_SET_STATE_WINDOW (message)) = window;
+ (SM_SET_STATE_STATE (message)) = state;
+ simple_transaction ((WINDOW_QID (window)), message);
+}
+
+static void
+handle_window_set_state_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SET_STATE_WINDOW (message));
+ window_state_t state = (SM_SET_STATE_STATE (message));
+ OS2_destroy_message (message);
+ set_window_state (window, state);
+ simple_reply (sender);
+}
+
+void
+OS2_window_set_colors (wid_t wid, COLOR foreground, COLOR background)
+{
+ window_t * window = (wid_to_window (wid));
+ msg_t * message = (OS2_create_message (mt_window_set_colors));
+ (SM_SET_COLORS_WINDOW (message)) = window;
+ (SM_SET_COLORS_FOREGROUND (message)) = foreground;
+ (SM_SET_COLORS_BACKGROUND (message)) = background;
+ simple_transaction ((WINDOW_QID (window)), message);
+}
+
+static void
+handle_window_set_colors_request (msg_t * message)
+{
+ qid_t sender = (MSG_SENDER (message));
+ window_t * window = (SM_SET_COLORS_WINDOW (message));
+ COLOR foreground = (SM_SET_COLORS_FOREGROUND (message));
+ COLOR background = (SM_SET_COLORS_BACKGROUND (message));
+ OS2_destroy_message (message);
+ set_window_colors (window, foreground, background);
+ simple_reply (sender);
+}
+\f
+static window_t * make_window (qid_t, qid_t);
+
+static wid_t
+open_window (qid_t qid, qid_t event_qid, const char * title)
+{
+ window_t * window = (make_window (qid, event_qid));
+ FRAMECDATA frame_data;
+ HWND frame_window;
+
+ (frame_data . cb) = (sizeof (frame_data));
+ (frame_data . flCreateFlags)
+ = (FCF_TITLEBAR | FCF_SYSMENU | FCF_SHELLPOSITION | FCF_SIZEBORDER
+ | FCF_MINMAX | FCF_TASKLIST);
+ (frame_data . hmodResources) = NULLHANDLE;
+ (frame_data . idResources) = ID_RESOURCES;
+ frame_window
+ = (WinCreateWindow (HWND_DESKTOP,
+ WC_FRAME,
((PSZ) title), /* title string */
0, /* window style */
0, 0, 0, 0, /* size and position */
0));
if (frame_window == NULLHANDLE)
window_error (WinCreateWindow);
- (TWINDOW_FRAME (twindow)) = frame_window;
+ (WINDOW_FRAME (window)) = frame_window;
{
PFNWP procedure
= (WinSubclassWindow (frame_window, frame_window_procedure));
OS2_logic_error ("WinSubclassWindow returned two different answers.");
}
if ((WinCreateWindow (frame_window,
- ((PSZ) twindow_class),
+ ((PSZ) window_class),
0, /* window text (class-specific) */
0, /* window style */
0, 0, 0, 0, /* size and position */
frame_window, /* owner window */
HWND_BOTTOM,
FID_CLIENT, /* window ID */
- twindow,
+ window,
0))
== NULLHANDLE)
window_error (WinCreateWindow);
- if (!WinShowWindow ((TWINDOW_FRAME (twindow)), TRUE))
- window_error (WinShowWindow);
- if (!WinShowWindow ((TWINDOW_CLIENT (twindow)), TRUE))
+ return (allocate_wid (window));
+}
+
+static window_t *
+make_window (qid_t qid, qid_t event_qid)
+{
+ window_t * window = (OS_malloc (sizeof (window_t)));
+ (WINDOW_FRAME (window)) = NULLHANDLE;
+ (WINDOW_CLIENT (window)) = NULLHANDLE;
+ (WINDOW_HPS (window)) = NULLHANDLE;
+ (WINDOW_CURSOR_X (window)) = 0;
+ (WINDOW_CURSOR_Y (window)) = 0;
+ (WINDOW_CURSOR_WIDTH (window)) = 0;
+ (WINDOW_CURSOR_HEIGHT (window)) = 0;
+ (WINDOW_CURSOR_STYLE (window)) = (CURSOR_SOLID | CURSOR_FLASH);
+ (WINDOW_CURSOR_SHOWNP (window)) = 0;
+ (WINDOW_QID (window)) = qid;
+ (WINDOW_EVENT_QID (window)) = event_qid;
+ (WINDOW_MINIMIZINGP (window)) = 0;
+ (WINDOW_MINIMIZEDP (window)) = 0;
+ (WINDOW_PERMANENTP (window)) = 0;
+ return (window);
+}
+
+static void
+close_window (window_t * window)
+{
+ if (!WinDestroyWindow (WINDOW_FRAME (window)))
+ window_error (WinDestroyWindow);
+ deallocate_wid (WINDOW_WID (window));
+ OS_free (window);
+}
+
+static void
+show_window (window_t * window, int showp)
+{
+ if (!WinShowWindow ((WINDOW_FRAME (window)), showp))
window_error (WinShowWindow);
- return (twindow);
}
-static twindow_t *
-make_twindow (qid_t event_qid)
+static void
+move_cursor (window_t * window, unsigned short x, unsigned short y)
{
- twindow_t * twindow = (OS_malloc (sizeof (twindow_t)));
- (TWINDOW_FRAME (twindow)) = NULLHANDLE;
- (TWINDOW_CLIENT (twindow)) = NULLHANDLE;
- (TWINDOW_CHARMAP (twindow)) = 0;
- (TWINDOW_CURSOR_X (twindow)) = 0;
- (TWINDOW_CURSOR_Y (twindow)) = 0;
- (TWINDOW_CURSOR_SHOWNP (twindow)) = 1;
- (TWINDOW_EVENT_QID (twindow)) = event_qid;
- (TWINDOW_MINIMIZINGP (twindow)) = 0;
- (TWINDOW_MINIMIZEDP (twindow)) = 0;
- return (twindow);
+ if (window_focusp (window))
+ if (!WinCreateCursor ((WINDOW_CLIENT (window)),
+ x, y, 0, 0, CURSOR_SETPOS, 0))
+ window_error (WinCreateCursor);
}
-\f
+
static void
-twindow_close (twindow_t * twindow)
+shape_cursor (window_t * window, unsigned short width, unsigned short height,
+ unsigned short style)
{
- OS_free (TWINDOW_CHARMAP (twindow));
- if (!GpiDestroyPS (TWINDOW_HPS (twindow)))
- window_error (GpiDestroyPS);
- if (!WinDestroyWindow (TWINDOW_FRAME (twindow)))
- window_error (WinDestroyWindow);
- deallocate_twid (TWINDOW_TWID (twindow));
+ (WINDOW_CURSOR_WIDTH (window)) = width;
+ (WINDOW_CURSOR_HEIGHT (window)) = height;
+ (WINDOW_CURSOR_STYLE (window)) = style;
+ recreate_cursor (window);
}
-static msg_t *
-make_close_event (twid_t twid)
+static void
+show_cursor (window_t * window, int showp)
{
- msg_t * message = (OS2_create_message (mt_close_event));
- (SM_CLOSE_EVENT_TWID (message)) = twid;
- return (message);
+ if ((window_focusp (window))
+ && (showp != (WINDOW_CURSOR_SHOWNP (window))))
+ if (!WinShowCursor ((WINDOW_CLIENT (window)), showp))
+ window_error (WinShowCursor);
+ (WINDOW_CURSOR_SHOWNP (window)) = showp;
}
static void
-twindow_write (twindow_t * twindow, unsigned short x, unsigned short y,
- const char * data, unsigned short size)
+recreate_cursor (window_t * window)
{
- unsigned short width = (TWINDOW_WIDTH (twindow));
- unsigned short height = (TWINDOW_HEIGHT (twindow));
- if ((y < (TWINDOW_HEIGHT (twindow))) && (x < width))
+ if (window_focusp (window))
{
- char * target = (TWINDOW_CHAR_LOC (twindow, x, y));
- if (size > (width - x))
- size = (width - x);
- FASTCOPY (data, target, size);
- invalidate_partial_line (twindow, x, y, size);
+ if (!WinCreateCursor ((WINDOW_CLIENT (window)),
+ (WINDOW_CURSOR_X (window)),
+ (WINDOW_CURSOR_Y (window)),
+ (WINDOW_CURSOR_WIDTH (window)),
+ (WINDOW_CURSOR_HEIGHT (window)),
+ (WINDOW_CURSOR_STYLE (window)),
+ 0))
+ window_error (WinCreateCursor);
+ if (WINDOW_CURSOR_SHOWNP (window))
+ if (!WinShowCursor ((WINDOW_CLIENT (window)), TRUE))
+ window_error (WinShowCursor);
}
}
static void
-twindow_clear (twindow_t * twindow)
+activate_cursor (window_t * window)
{
- FASTFILL ((TWINDOW_CHARMAP (twindow)),
- ((TWINDOW_WIDTH (twindow)) * (TWINDOW_HEIGHT (twindow))),
- ' ');
- if (!WinInvalidateRect ((TWINDOW_CLIENT (twindow)), 0, FALSE))
- window_error (WinInvalidateRect);
+ if ((WINDOW_CURSOR_SHOWNP (window)) && (window_focusp (window)))
+ if (!WinShowCursor ((WINDOW_CLIENT (window)), TRUE))
+ window_error (WinShowCursor);
+}
+
+static void
+deactivate_cursor (window_t * window)
+{
+ if ((WINDOW_CURSOR_SHOWNP (window)) && (window_focusp (window)))
+ if (!WinShowCursor ((WINDOW_CLIENT (window)), FALSE))
+ window_error (WinShowCursor);
}
static void
-twindow_clear_eol (twindow_t * twindow, unsigned short x, unsigned short y)
+clear_rectangle (window_t * window, PRECTL rectl)
+{
+ deactivate_cursor (window);
+ if (!WinFillRect ((WINDOW_HPS (window)),
+ rectl,
+ (WINDOW_BACKGROUND_COLOR (window))))
+ window_error (WinFillRect);
+ activate_cursor (window);
+}
+
+static int parse_font_spec (const char *, PSZ *, LONG *, USHORT *);
+static int set_font_1 (HPS, PSZ, LONG, USHORT, LONG);
+
+static font_metrics_t *
+set_font (window_t * window, unsigned short id, const char * spec)
{
- unsigned short width = (TWINDOW_WIDTH (twindow));
- if ((y < (TWINDOW_HEIGHT (twindow))) && (x < width))
+ PSZ name = 0;
+ LONG size;
+ USHORT selection;
+ if (!parse_font_spec (spec, (& name), (& size), (& selection)))
+ return (0);
+ if (!set_font_1 ((WINDOW_HPS (window)), name, size, selection, id))
+ {
+ OS_free (name);
+ return (0);
+ }
+ {
+ font_metrics_t * metrics = (OS_malloc (sizeof (font_metrics_t)));
+ FONTMETRICS fm;
+ if (!GpiQueryFontMetrics
+ ((WINDOW_HPS (window)), (sizeof (fm)), (& fm)))
+ window_error (GpiQueryFontMetrics);
+ (FONT_METRICS_WIDTH (metrics)) = (fm . lMaxCharInc);
+ (FONT_METRICS_HEIGHT (metrics)) = (fm . lMaxBaselineExt);
+ (FONT_METRICS_DESCENDER (metrics)) = (fm . lMaxDescender);
+ return (metrics);
+ }
+}
+
+static int
+parse_font_spec (const char * spec,
+ PSZ * pname, LONG * psize, USHORT * pselection)
+{
+ const char * scan = spec;
+ unsigned int size = 0;
+ unsigned int selection = 0;
+ while (('0' <= (*scan)) && ((*scan) <= '9'))
+ size = ((size * 10) + ((*scan++) - '0'));
+ if (size == 0)
+ return (0);
+ while (1)
{
- unsigned short size = (width - x);
- FASTFILL ((TWINDOW_CHAR_LOC (twindow, x, y)), size, ' ');
- invalidate_partial_line (twindow, x, y, size);
+ if ((strncmp (scan, ".bold", 5)) == 0)
+ {
+ selection |= FATTR_SEL_BOLD;
+ scan += 5;
+ }
+ else if ((strncmp (scan, ".italic", 7)) == 0)
+ {
+ selection |= FATTR_SEL_ITALIC;
+ scan += 7;
+ }
+ else
+ break;
}
+ if ((*scan++) != '.')
+ return (0);
+ (*pname) = (OS_malloc ((strlen (scan)) + 1));
+ strcpy ((*pname), scan);
+ (*psize) = (size * 10);
+ (*pselection) = selection;
+ return (1);
+}
+
+static int create_font (HPS, LONG, PFONTMETRICS, USHORT);
+
+static int
+set_font_1 (HPS hps, PSZ name, LONG size, USHORT selection, LONG id)
+{
+ LONG nfonts;
+ ULONG index;
+ PFONTMETRICS pfm;
+
+ nfonts = 0;
+ nfonts = (GpiQueryFonts (hps,
+ (QF_PUBLIC | QF_PRIVATE),
+ name,
+ (& nfonts),
+ (sizeof (FONTMETRICS)),
+ 0));
+ if (nfonts == GPI_ALTERROR)
+ window_error (GpiQueryFonts);
+ if (nfonts == 0)
+ return (0);
+ pfm = (OS_malloc (nfonts * (sizeof (FONTMETRICS))));
+ if ((GpiQueryFonts (hps,
+ (QF_PUBLIC | QF_PRIVATE),
+ name,
+ (& nfonts),
+ (sizeof (FONTMETRICS)),
+ pfm))
+ == GPI_ALTERROR)
+ window_error (GpiQueryFonts);
+ for (index = 0; (index < nfonts); index += 1)
+ if (((((pfm [index]) . fsType) & FM_TYPE_FIXED) != 0)
+ && ((((pfm [index]) . fsDefn) & FM_DEFN_OUTLINE) == 0)
+ && (((pfm [index]) . sNominalPointSize) == size)
+ && (create_font (hps, id, (& (pfm [index])), selection)))
+ {
+ GpiSetCharSet (hps, id);
+ OS_free (pfm);
+ return (1);
+ }
+ OS_free (pfm);
+ return (0);
+}
+
+static int
+create_font (HPS hps, LONG font_id, PFONTMETRICS pfm, USHORT selection)
+{
+ FATTRS font_attrs;
+
+ (font_attrs . usRecordLength) = (sizeof (font_attrs));
+ (font_attrs . fsSelection) = selection;
+ (font_attrs . lMatch) = (pfm -> lMatch);
+ strcpy ((font_attrs . szFacename), (pfm -> szFacename));
+ (font_attrs . idRegistry) = 0;
+ (font_attrs . usCodePage) = (WinQueryCp (pm_hmq));
+ if ((font_attrs . usCodePage) == 0)
+ window_error (WinQueryCp);
+ (font_attrs . lMaxBaselineExt) = 0;
+ (font_attrs . lAveCharWidth) = 0;
+ (font_attrs . fsType) = 0;
+ (font_attrs . fsFontUse) = 0;
+ return ((GpiCreateLogFont (hps, 0, font_id, (& font_attrs))) == FONT_MATCH);
}
static void
-invalidate_partial_line (twindow_t * twindow, unsigned short x,
- unsigned short y, unsigned short size)
+get_window_pos (window_t * window, unsigned short * x, unsigned short * y)
{
- RECTL rectl;
- (rectl . xLeft) = (cx2x (twindow, x));
- (rectl . xRight) = (cx2x (twindow, (x + size)));
- (rectl . yBottom) = (cy2y (twindow, y, 1));
- (rectl . yTop) = (cy2y (twindow, y, 0));
- if (!WinInvalidateRect ((TWINDOW_CLIENT (twindow)), (& rectl), FALSE))
- window_error (WinInvalidateRect);
+ SWP swp;
+ if (!WinQueryWindowPos ((WINDOW_FRAME (window)), (& swp)))
+ window_error (WinQueryWindowPos);
+ (* x) = (swp . x);
+ (* y) = (swp . y);
}
-\f
+
static void
-twindow_scroll (twindow_t * twindow,
- unsigned short x_start, unsigned short x_end,
- unsigned short y_start, unsigned short y_end,
- short x_delta, short y_delta)
+set_window_pos (window_t * window, unsigned short x, unsigned short y)
{
- RECTL rectl;
- (rectl . xLeft) = (cx2x (twindow, x_start));
- (rectl . xRight) = (cx2x (twindow, x_end));
- (rectl . yBottom) = (cy2y (twindow, y_end, 1));
- (rectl . yTop) = (cy2y (twindow, y_start, 0));
- if ((WinScrollWindow ((TWINDOW_CLIENT (twindow)),
- (x_delta * (TWINDOW_CHAR_WIDTH (twindow))),
- (y_delta * (TWINDOW_CHAR_HEIGHT (twindow))),
- (& rectl),
- 0,
- NULLHANDLE,
- 0,
- 0))
- == RGN_ERROR)
- window_error (WinScrollWindow);
+ if (!WinSetWindowPos ((WINDOW_FRAME (window)), NULLHANDLE, x, y,
+ 0, 0, SWP_MOVE))
+ window_error (WinSetWindowPos);
}
static void
-twindow_move_cursor (twindow_t * twindow, unsigned short x, unsigned short y)
+get_window_size (window_t * window,
+ unsigned short * width, unsigned short * height)
{
- if ((x < (TWINDOW_WIDTH (twindow))) && (y < (TWINDOW_HEIGHT (twindow))))
+ SWP swp;
+ if (!WinQueryWindowPos ((WINDOW_CLIENT (window)), (& swp)))
+ window_error (WinQueryWindowPos);
+ (* width) = (swp . cx);
+ (* height) = (swp . cy);
+}
+
+static void
+set_window_size (window_t * window,
+ unsigned short width, unsigned short height)
+{
+ SWP swp;
+ POINTL ptl;
+ RECTL rcl;
+ if (!WinQueryWindowPos ((WINDOW_CLIENT (window)), (& swp)))
+ window_error (WinQueryWindowPos);
+ (ptl . x) = (swp . x);
+ (ptl . y) = (swp . y);
+ if (!WinMapWindowPoints ((WINDOW_FRAME (window)), HWND_DESKTOP, (& ptl), 1))
+ window_error (WinMapWindowPoints);
+ (rcl . xLeft) = (ptl . x);
+ (rcl . xRight) = ((ptl . x) + width);
+ (rcl . yBottom) = (ptl . y);
+ (rcl . yTop) = ((ptl . y) + height);
+ if (!WinCalcFrameRect ((WINDOW_FRAME (window)), (& rcl), FALSE))
+ window_error (WinCalcFrameRect);
+ deactivate_cursor (window);
+ if (!WinSetWindowPos ((WINDOW_FRAME (window)),
+ NULLHANDLE, 0, 0,
+ ((rcl . xRight) - (rcl . xLeft)),
+ ((rcl . yTop) - (rcl . yBottom)),
+ SWP_SIZE))
+ window_error (WinSetWindowPos);
+ activate_cursor (window);
+}
+
+static int
+window_focusp (window_t * window)
+{
+ return ((WINDOW_CLIENT (window)) == (WinQueryFocus (HWND_DESKTOP)));
+}
+
+static void
+set_window_state (window_t * window, window_state_t state)
+{
+ ULONG op = 0;
+ HWND behind = NULLHANDLE;
+ switch (state)
{
- (TWINDOW_CURSOR_X (twindow)) = x;
- (TWINDOW_CURSOR_Y (twindow)) = y;
- if (twindow_focusp (twindow))
- if (!WinCreateCursor ((TWINDOW_CLIENT (twindow)),
- (cx2x (twindow, x)),
- (cy2y (twindow, y, 1)),
- 0,
- 0,
- CURSOR_SETPOS,
- 0))
- window_error (WinCreateCursor);
+ case state_top:
+ op = SWP_ZORDER;
+ behind = HWND_TOP;
+ break;
+ case state_bottom:
+ op = SWP_ZORDER;
+ behind = HWND_BOTTOM;
+ break;
+ case state_show:
+ op = SWP_SHOW;
+ break;
+ case state_hide:
+ op = SWP_HIDE;
+ break;
+ case state_activate:
+ op = SWP_ACTIVATE;
+ break;
+ case state_deactivate:
+ op = SWP_DEACTIVATE;
+ break;
+ case state_minimize:
+ op = SWP_MINIMIZE;
+ break;
+ case state_maximize:
+ op = SWP_MAXIMIZE;
+ break;
+ case state_restore:
+ op = SWP_RESTORE;
+ break;
}
+ if (!WinSetWindowPos ((WINDOW_FRAME (window)), behind, 0, 0, 0, 0, op))
+ window_error (WinSetWindowPos);
+}
+
+static void
+set_window_colors (window_t * window, COLOR foreground, COLOR background)
+{
+ if (!GpiSetColor ((WINDOW_HPS (window)), foreground))
+ window_error (GpiSetColor);
+ if (!GpiSetMix ((WINDOW_HPS (window)), FM_OVERPAINT))
+ window_error (GpiSetMix);
+ if (!GpiSetBackColor ((WINDOW_HPS (window)), background))
+ window_error (GpiSetBackColor);
+ if (!GpiSetBackMix ((WINDOW_HPS (window)), BM_OVERPAINT))
+ window_error (GpiSetBackMix);
+ (WINDOW_FOREGROUND_COLOR (window)) = foreground;
+ (WINDOW_BACKGROUND_COLOR (window)) = background;
}
\f
static MRESULT EXPENTRY
frame_window_procedure (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
- twindow_t * twindow = (hwnd_to_twindow (WinWindowFromID (hwnd, FID_CLIENT)));
+ window_t * window = (hwnd_to_window (WinWindowFromID (hwnd, FID_CLIENT)));
switch (msg)
{
case WM_QUERYTRACKINFO:
|| (((pti -> fs) & TF_SETPOINTERPOS) != 0)))
{
(pti -> fs) |= TF_GRID;
- (pti -> cxGrid) = (TWINDOW_CHAR_WIDTH (twindow));
- (pti -> cyGrid) = (TWINDOW_CHAR_HEIGHT (twindow));
- (pti -> cxKeyboard) = (TWINDOW_CHAR_WIDTH (twindow));
- (pti -> cyKeyboard) = (TWINDOW_CHAR_HEIGHT (twindow));
+ (pti -> cxGrid) = (WINDOW_GRID_X (window));
+ (pti -> cyGrid) = (WINDOW_GRID_Y (window));
+ (pti -> cxKeyboard) = (WINDOW_GRID_X (window));
+ (pti -> cyKeyboard) = (WINDOW_GRID_Y (window));
}
}
return (mr);
minimization has completed. */
{
PSWP pswp = (PVOIDFROMMP (mp1));
- if ((!TWINDOW_MINIMIZEDP (twindow))
+ if ((!WINDOW_MINIMIZEDP (window))
&& (((pswp -> fl) & SWP_MINIMIZE) != 0))
{
- (TWINDOW_MINIMIZINGP (twindow)) = 1;
- (TWINDOW_MINIMIZEDP (twindow)) = 1;
+ (WINDOW_MINIMIZINGP (window)) = 1;
+ (WINDOW_MINIMIZEDP (window)) = 1;
}
- else if ((TWINDOW_MINIMIZEDP (twindow))
+ else if ((WINDOW_MINIMIZEDP (window))
&& (((pswp -> fl) & (SWP_RESTORE | SWP_MAXIMIZE)) != 0))
- (TWINDOW_MINIMIZEDP (twindow)) = 0;
+ (WINDOW_MINIMIZEDP (window)) = 0;
}
break;
}
return ((* original_frame_window_procedure) (hwnd, msg, mp1, mp2));
}
\f
+static int process_button (HWND, MPARAM, MPARAM, unsigned char, unsigned char);
+static int process_keychar
+ (window_t *, unsigned short, unsigned char, unsigned char, unsigned short,
+ unsigned short);
+
static MRESULT EXPENTRY
-twindow_procedure (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
+window_procedure (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch (msg)
{
case WM_CREATE:
{
- twindow_t * twindow = (PVOIDFROMMP (mp1));
- (TWINDOW_CLIENT (twindow)) = hwnd;
- if (!WinSetWindowPtr (hwnd, QWP_TWINDOW, twindow))
+ window_t * window = (PVOIDFROMMP (mp1));
+ SIZEL sizel;
+ (WINDOW_CLIENT (window)) = hwnd;
+ if (!WinSetWindowPtr (hwnd, QWP_WINDOW, window))
window_error (WinSetWindowPtr);
- twindow_initialize (twindow);
+ (sizel . cx) = 0;
+ (sizel . cy) = 0;
+ (WINDOW_HPS (window))
+ = (GpiCreatePS (pm_hab,
+ (WinOpenWindowDC (WINDOW_CLIENT (window))),
+ (& sizel),
+ (PU_PELS | GPIF_DEFAULT | GPIT_MICRO
+ | GPIA_ASSOC)));
+ if ((WINDOW_HPS (window)) == 0)
+ window_error (GpiCreatePS);
+ if (!GpiSetBackMix ((WINDOW_HPS (window)), BM_OVERPAINT))
+ window_error (GpiSetBackMix);
+ /* Put color table in RGB mode so we can specify colors
+ directly in RGB values rather than as indices. */
+ if (!GpiCreateLogColorTable ((WINDOW_HPS (window)), LCOL_PURECOLOR,
+ LCOLF_RGB, 0, 0, 0))
+ window_error (GpiCreateLogColorTable);
+ (WINDOW_FOREGROUND_COLOR (window))
+ = (GpiQueryColor (WINDOW_HPS (window)));
+ (WINDOW_BACKGROUND_COLOR (window))
+ = (GpiQueryBackColor (WINDOW_HPS (window)));
return (MRFALSE);
}
case WM_PAINT:
{
- twindow_t * twindow = (hwnd_to_twindow (hwnd));
- if (((WinQueryWindowULong ((TWINDOW_FRAME (twindow)), QWL_STYLE))
+ window_t * window = (hwnd_to_window (hwnd));
+ if (((WinQueryWindowULong ((WINDOW_FRAME (window)), QWL_STYLE))
& WS_MINIMIZED)
!= 0)
break;
- twindow_paint (twindow);
+ {
+ RECTL rectl;
+ if ((WinBeginPaint ((WINDOW_CLIENT (window)),
+ (WINDOW_HPS (window)),
+ (& rectl)))
+ == NULLHANDLE)
+ window_error (WinBeginPaint);
+ clear_rectangle (window, (& rectl));
+ if (!WinEndPaint (WINDOW_HPS (window)))
+ window_error (WinEndPaint);
+ SEND_EVENT (window,
+ (make_paint_event ((WINDOW_WID (window)),
+ (rectl . xLeft),
+ (rectl . xRight),
+ (rectl . yBottom),
+ (rectl . yTop))));
+ }
return (MRVOID);
}
case WM_SETFOCUS:
{
- twindow_t * twindow = (hwnd_to_twindow (hwnd));
+ window_t * window = (hwnd_to_window (hwnd));
if (SHORT1FROMMP (mp2))
- activate_cursor (twindow);
+ recreate_cursor (window);
else
- deactivate_cursor (twindow);
+ {
+ if (!WinDestroyCursor (WINDOW_CLIENT (window)))
+ window_error (WinDestroyCursor);
+ }
+ SEND_EVENT (window,
+ (make_focus_event ((WINDOW_WID (window)),
+ (SHORT1FROMMP (mp2)))));
return (MRVOID);
}
case WM_CHAR:
return
- ((twindow_process_keychar ((hwnd_to_twindow (hwnd)),
- (SHORT1FROMMP (mp1)),
- (CHAR3FROMMP (mp1)),
- (CHAR4FROMMP (mp1)),
- (SHORT1FROMMP (mp2)),
- (SHORT2FROMMP (mp2))))
+ ((process_keychar ((hwnd_to_window (hwnd)),
+ (SHORT1FROMMP (mp1)),
+ (CHAR3FROMMP (mp1)),
+ (CHAR4FROMMP (mp1)),
+ (SHORT1FROMMP (mp2)),
+ (SHORT2FROMMP (mp2))))
? MRTRUE
: MRFALSE);
+
+ case WM_TRANSLATEACCEL:
+ {
+ PQMSG qmsg = (PVOIDFROMMP (mp1));
+ USHORT flags = (SHORT1FROMMP (qmsg -> mp1));
+ USHORT char_code = (SHORT1FROMMP (qmsg -> mp2));
+ USHORT virtual_key = (SHORT2FROMMP (qmsg -> mp2));
+ /* Disable specific default accelerator keys. */
+ if ((flags & KC_VIRTUALKEY) != 0)
+ switch (virtual_key)
+ {
+ case VK_ALT:
+ case VK_ALTGRAF:
+ /* Disable "Alt" keys, which normally pop up the system
+ menu. These keys are used often in Edwin and the
+ default behavior is unacceptable. */
+ return (MRFALSE);
+ case VK_SPACE:
+ case VK_ESC:
+ case VK_TAB:
+ /* Disable "Alt-SPC", "Alt-ESC", and "Alt-TAB", which
+ have standard key bindings in Edwin. */
+ if ((flags & KC_ALT) != 0)
+ return (MRFALSE);
+ }
+ else if ((flags & KC_CHAR) != 0)
+ switch (char_code)
+ {
+ case ' ':
+ case '\033':
+ case '\t':
+ /* Disable "Alt-SPC", "Alt-ESC", and "Alt-TAB", if for
+ some reason they are reported as ASCII characters
+ rather than as virtual keys. */
+ if ((flags & KC_ALT) != 0)
+ return (MRFALSE);
+ }
+ break;
+ }
case WM_CLOSE:
{
- twindow_t * twindow = (hwnd_to_twindow (hwnd));
- SEND_EVENT (twindow, (make_close_event (TWINDOW_TWID (twindow))));
+ window_t * window = (hwnd_to_window (hwnd));
+ SEND_EVENT (window, (make_close_event (WINDOW_WID (window))));
return (MRVOID);
}
+ case WM_DESTROY:
+ if (!GpiDestroyPS (WINDOW_HPS (hwnd_to_window (hwnd))))
+ window_error (GpiDestroyPS);
+ return (MRVOID);
case WM_SIZE:
{
- twindow_t * twindow = (hwnd_to_twindow (hwnd));
+ window_t * window = (hwnd_to_window (hwnd));
/* If this message is part of a minimization, ignore it. */
- if (TWINDOW_MINIMIZINGP (twindow))
+ if (WINDOW_MINIMIZINGP (window))
{
- (TWINDOW_MINIMIZINGP (twindow)) = 0;
- (TWINDOW_MINIMIZEDP (twindow)) = 1;
+ (WINDOW_MINIMIZINGP (window)) = 0;
+ (WINDOW_MINIMIZEDP (window)) = 1;
break;
}
- twindow_resize (twindow, (SHORT1FROMMP (mp2)), (SHORT2FROMMP (mp2)));
+ SEND_EVENT (window,
+ (make_resize_event ((WINDOW_WID (window)),
+ (SHORT1FROMMP (mp2)),
+ (SHORT2FROMMP (mp2)))));
return (MRVOID);
}
case WM_SHOW:
- case WM_BUTTON1CLICK:
+ {
+ window_t * window = (hwnd_to_window (hwnd));
+ SEND_EVENT (window,
+ (make_visibility_event ((WINDOW_WID (window)),
+ (SHORT1FROMMP (mp1)))));
+ return (MRVOID);
+ }
case WM_BUTTON1DOWN:
+ if (process_button (hwnd, mp1, mp2, 0, BUTTON_EVENT_DOWN))
+ return (MRTRUE);
+ break;
case WM_BUTTON1UP:
+ if (process_button (hwnd, mp1, mp2, 0, BUTTON_EVENT_UP))
+ return (MRTRUE);
+ break;
+ case WM_BUTTON1CLICK:
+ if (process_button (hwnd, mp1, mp2, 0, BUTTON_EVENT_CLICK))
+ return (MRTRUE);
+ break;
case WM_BUTTON1DBLCLK:
- case WM_BUTTON2CLICK:
+ if (process_button (hwnd, mp1, mp2, 0, BUTTON_EVENT_DBLCLK))
+ return (MRTRUE);
+ break;
case WM_BUTTON2DOWN:
+ if (process_button (hwnd, mp1, mp2, 1, BUTTON_EVENT_DOWN))
+ return (MRTRUE);
+ break;
case WM_BUTTON2UP:
+ if (process_button (hwnd, mp1, mp2, 1, BUTTON_EVENT_UP))
+ return (MRTRUE);
+ break;
+ case WM_BUTTON2CLICK:
+ if (process_button (hwnd, mp1, mp2, 1, BUTTON_EVENT_CLICK))
+ return (MRTRUE);
+ break;
case WM_BUTTON2DBLCLK:
- case WM_BUTTON3CLICK:
+ if (process_button (hwnd, mp1, mp2, 1, BUTTON_EVENT_DBLCLK))
+ return (MRTRUE);
+ break;
case WM_BUTTON3DOWN:
+ if (process_button (hwnd, mp1, mp2, 2, BUTTON_EVENT_DOWN))
+ return (MRTRUE);
+ break;
case WM_BUTTON3UP:
+ if (process_button (hwnd, mp1, mp2, 2, BUTTON_EVENT_UP))
+ return (MRTRUE);
+ break;
+ case WM_BUTTON3CLICK:
+ if (process_button (hwnd, mp1, mp2, 2, BUTTON_EVENT_CLICK))
+ return (MRTRUE);
+ break;
case WM_BUTTON3DBLCLK:
- case WM_MOUSEMOVE:
+ if (process_button (hwnd, mp1, mp2, 2, BUTTON_EVENT_DBLCLK))
+ return (MRTRUE);
+ break;
default:
break;
}
return (WinDefWindowProc (hwnd, msg, mp1, mp2));
}
-static twindow_t *
-hwnd_to_twindow (HWND hwnd)
+static window_t *
+hwnd_to_window (HWND hwnd)
{
- twindow_t * twindow = (WinQueryWindowPtr (hwnd, QWP_TWINDOW));
- if (twindow == 0)
+ window_t * window = (WinQueryWindowPtr (hwnd, QWP_WINDOW));
+ if (window == 0)
window_error (WinQueryWindowPtr);
- return (twindow);
-}
-\f
-static void
-twindow_initialize (twindow_t * twindow)
-{
- SIZEL sizel;
- (sizel . cx) = 0;
- (sizel . cy) = 0;
- (TWINDOW_HPS (twindow))
- = (GpiCreatePS (pm_hab,
- (WinOpenWindowDC (TWINDOW_CLIENT (twindow))),
- (& sizel),
- (PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC)));
- if ((TWINDOW_HPS (twindow)) == 0)
- window_error (GpiCreatePS);
- initialize_default_font (twindow, "System VIO", 40, 1);
- initialize_attributes (twindow);
- set_twindow_char_dimensions (twindow);
- initialize_charmap (twindow);
-}
-
-static void
-initialize_default_font (twindow_t * twindow, PSZ font_name, LONG font_size,
- LONG font_id)
-{
- HPS hps = (TWINDOW_HPS (twindow));
- if ((!set_font_1 (hps, font_name, font_size, font_id))
- && (!set_font_1 (hps, "Courier", 100, font_id)))
- OS2_logic_error ("Unable to initialize default font.");
- {
- FONTMETRICS fm;
- if (!GpiQueryFontMetrics (hps, (sizeof (fm)), (& fm)))
- window_error (GpiQueryFontMetrics);
- (TWINDOW_CHAR_WIDTH (twindow)) = (fm . lMaxCharInc);
- (TWINDOW_CHAR_ASCENDER (twindow)) = (fm . lMaxBaselineExt);
- (TWINDOW_CHAR_DESCENDER (twindow)) = (fm . lMaxDescender);
- }
-}
-
-static void
-initialize_attributes (twindow_t * twindow)
-{
- CHARBUNDLE attrs;
-#if 0
- LONG default_mask
- = (GpiQueryAttrs ((TWINDOW_HPS (twindow)),
- PRIM_CHAR,
- (CBB_COLOR | CBB_BACK_COLOR | CBB_MIX_MODE
- | CBB_BACK_MIX_MODE | CBB_BOX | CBB_SET | CBB_MODE
- | CBB_ANGLE | CBB_SHEAR | CBB_DIRECTION
- | CBB_TEXT_ALIGN | CBB_EXTRA | CBB_BREAK_EXTRA),
- (& attrs)));
- if (default_mask == GPI_ALTERROR)
- window_error (GpiQueryAttrs);
-#endif
-#if 0
- (attrs . lColor) = CLR_NEUTRAL;
- (attrs . lBackColor) = CLR_BACKGROUND;
- (attrs . usMixMode) = FM_OVERPAINT;
- (attrs . usBackMixMode) = BM_LEAVEALONE;
- if (!GpiSetAttrs ((TWINDOW_HPS (twindow)),
- PRIM_CHAR,
- (CBB_COLOR | CBB_BACK_COLOR | CBB_MIX_MODE
- | CBB_BACK_MIX_MODE),
- 0,
- (& attrs)))
- window_error (GpiSetAttrs);
-#endif
-}
-
-static void
-set_twindow_char_dimensions (twindow_t * twindow)
-{
- SWP swp;
- if (!WinQueryWindowPos ((TWINDOW_CLIENT (twindow)), (& swp)))
- window_error (WinQueryWindowPos);
- (TWINDOW_WIDTH (twindow)) = ((swp . cx) / (TWINDOW_CHAR_WIDTH (twindow)));
- (TWINDOW_HEIGHT (twindow)) = ((swp . cy) / (TWINDOW_CHAR_HEIGHT (twindow)));
-}
-
-static void
-initialize_charmap (twindow_t * twindow)
-{
- unsigned short n = ((TWINDOW_WIDTH (twindow)) * (TWINDOW_HEIGHT (twindow)));
- if ((TWINDOW_CHARMAP (twindow)) != 0)
- OS_free (TWINDOW_CHARMAP (twindow));
- if (n == 0)
- (TWINDOW_CHARMAP (twindow)) = 0;
- else
- {
- (TWINDOW_CHARMAP (twindow)) = (OS_malloc (n));
- FASTFILL ((TWINDOW_CHARMAP (twindow)), n, ' ');
- }
+ return (window);
}
\f
static int
-set_font_1 (HPS hps, PSZ font_name, LONG font_size, LONG font_id)
+process_keychar (window_t * window, unsigned short flags,
+ unsigned char repeat, unsigned char scan_code,
+ unsigned short char_code, unsigned short virtual_key)
{
- LONG nfonts;
- ULONG index;
- PFONTMETRICS pfm;
-
- nfonts = 0;
- nfonts = (GpiQueryFonts (hps,
- (QF_PUBLIC | QF_PRIVATE),
- font_name,
- (& nfonts),
- (sizeof (FONTMETRICS)),
- 0));
- if (nfonts == GPI_ALTERROR)
- window_error (GpiQueryFonts);
- if (nfonts == 0)
+ unsigned short code;
+ /* Ignore compound keys for now. */
+ if ((flags & (KC_DEADKEY | KC_COMPOSITE | KC_INVALIDCOMP | KC_KEYUP)) != 0)
return (0);
- pfm = (OS_malloc (nfonts * (sizeof (FONTMETRICS))));
- if ((GpiQueryFonts (hps,
- (QF_PUBLIC | QF_PRIVATE),
- font_name,
- (& nfonts),
- (sizeof (FONTMETRICS)),
- pfm))
- == GPI_ALTERROR)
- window_error (GpiQueryFonts);
- for (index = 0; (index < nfonts); index += 1)
- if (((((pfm [index]) . fsType) & FM_TYPE_FIXED) != 0)
- && ((((pfm [index]) . fsDefn) & FM_DEFN_OUTLINE) == 0)
- && (((pfm [index]) . sNominalPointSize) == font_size)
- && (use_font (hps, (& (pfm [index])), font_id)))
- {
- OS_free (pfm);
- return (1);
- }
- OS_free (pfm);
- return (0);
+ else if ((flags & KC_VIRTUALKEY) != 0)
+ code = virtual_key;
+ else if ((flags & (KC_CHAR | KC_CTRL | KC_ALT)) != 0)
+ code = char_code;
+ else
+ return (0);
+ SEND_EVENT
+ (window,
+ (make_key_event ((WINDOW_WID (window)), code, flags, repeat)));
}
static int
-use_font (HPS hps, PFONTMETRICS pfm, LONG font_id)
-{
- FATTRS font_attrs;
-
- (font_attrs . usRecordLength) = (sizeof (font_attrs));
- (font_attrs . fsSelection) = 0;
- (font_attrs . lMatch) = (pfm -> lMatch);
- strcpy ((font_attrs . szFacename), (pfm -> szFacename));
- (font_attrs . idRegistry) = 0;
- (font_attrs . usCodePage) = (WinQueryCp (pm_hmq));
- if ((font_attrs . usCodePage) == 0)
- window_error (WinQueryCp);
- (font_attrs . lMaxBaselineExt) = 0;
- (font_attrs . lAveCharWidth) = 0;
- (font_attrs . fsType) = 0;
- (font_attrs . fsFontUse) = 0;
- if ((GpiCreateLogFont (hps, 0, font_id, (& font_attrs))) != FONT_MATCH)
- return (0);
- GpiSetCharSet (hps, font_id);
+process_button (HWND hwnd, MPARAM mp1, MPARAM mp2,
+ unsigned char number, unsigned char type)
+{
+ window_t * window = (hwnd_to_window (hwnd));
+ SEND_EVENT (window,
+ (make_button_event ((WINDOW_WID (window)),
+ number,
+ type,
+ (SHORT1FROMMP (mp1)),
+ (SHORT2FROMMP (mp1)),
+ ((SHORT2FROMMP (mp2))
+ & (KC_SHIFT | KC_CTRL | KC_ALT)))));
return (1);
}
\f
-static void
-twindow_paint (twindow_t * twindow)
-{
- RECTL rectl;
- HPS hps =
- (WinBeginPaint ((TWINDOW_CLIENT (twindow)),
- (TWINDOW_HPS (twindow)),
- (& rectl)));
- if (hps == NULLHANDLE)
- window_error (WinBeginPaint);
- if (!WinFillRect ((TWINDOW_HPS (twindow)), (& rectl), CLR_BACKGROUND))
- window_error (WinFillRect);
- {
- unsigned short xl = (x2cx (twindow, (rectl . xLeft), 1));
- unsigned short xh = (x2cx (twindow, (rectl . xRight), 0));
- unsigned short yl = (y2cy (twindow, (rectl . yTop), 0));
- unsigned short yh = (y2cy (twindow, (rectl . yBottom), 1));
- unsigned short size = (xh - xl);
- while (yl < yh)
- draw_partial_line (twindow, xl, (yl++), size);
- }
- if (!WinEndPaint (hps))
- window_error (WinEndPaint);
-}
-
-static void
-draw_partial_line (twindow_t * twindow, unsigned short x, unsigned short y,
- unsigned short size)
-{
- HPS hps = (TWINDOW_HPS (twindow));
- char * target = (TWINDOW_CHAR_LOC (twindow, x, y));
- POINTL ptl;
- (ptl . x) = (cx2x (twindow, x));
- (ptl . y) = ((cy2y (twindow, y, 1)) + (TWINDOW_CHAR_DESCENDER (twindow)));
- if (size <= 512)
- GpiCharStringAt (hps, (& ptl), size, target);
- else
- {
- GpiMove (hps, (& ptl));
- while (size > 0)
- {
- unsigned short n = ((size > 512) ? 512 : size);
- GpiCharString (hps, n, target);
- size -= n;
- target += n;
- }
- }
-}
-\f
-static void
-activate_cursor (twindow_t * twindow)
-{
- if (!WinCreateCursor ((TWINDOW_CLIENT (twindow)),
- (cx2x (twindow, (TWINDOW_CURSOR_X (twindow)))),
- (cy2y (twindow, (TWINDOW_CURSOR_Y (twindow)), 1)),
- (TWINDOW_CHAR_WIDTH (twindow)),
- (TWINDOW_CHAR_HEIGHT (twindow)),
- (CURSOR_SOLID | CURSOR_FLASH),
- 0))
- window_error (WinCreateCursor);
- if (TWINDOW_CURSOR_SHOWNP (twindow))
- if (!WinShowCursor ((TWINDOW_CLIENT (twindow)), TRUE))
- window_error (WinShowCursor);
-}
-
-static void
-deactivate_cursor (twindow_t * twindow)
-{
- if (!WinDestroyCursor (TWINDOW_CLIENT (twindow)))
- window_error (WinDestroyCursor);
+static msg_t *
+make_button_event (wid_t wid, unsigned char number, unsigned char type,
+ unsigned short x, unsigned short y, unsigned short flags)
+{
+ msg_t * message = (OS2_create_message (mt_button_event));
+ (SM_BUTTON_EVENT_WID (message)) = wid;
+ (SM_BUTTON_EVENT_TYPE (message)) = (number | (type << 4));
+ (SM_BUTTON_EVENT_X (message)) = x;
+ (SM_BUTTON_EVENT_Y (message)) = y;
+ (SM_BUTTON_EVENT_FLAGS (message)) = flags;
+ return (message);
}
-static void
-show_cursor (twindow_t * twindow)
+static msg_t *
+make_close_event (wid_t wid)
{
- if (!TWINDOW_CURSOR_SHOWNP (twindow))
- {
- if (twindow_focusp (twindow))
- if (!WinShowCursor ((TWINDOW_CLIENT (twindow)), TRUE))
- window_error (WinShowCursor);
- (TWINDOW_CURSOR_SHOWNP (twindow)) = 1;
- }
+ msg_t * message = (OS2_create_message (mt_close_event));
+ (SM_CLOSE_EVENT_WID (message)) = wid;
+ return (message);
}
-static void
-hide_cursor (twindow_t * twindow)
+static msg_t *
+make_focus_event (wid_t wid, int gainedp)
{
- if (TWINDOW_CURSOR_SHOWNP (twindow))
- {
- if (twindow_focusp (twindow))
- if (!WinShowCursor ((TWINDOW_CLIENT (twindow)), FALSE))
- window_error (WinShowCursor);
- (TWINDOW_CURSOR_SHOWNP (twindow)) = 0;
- }
+ msg_t * message = (OS2_create_message (mt_focus_event));
+ (SM_FOCUS_EVENT_WID (message)) = wid;
+ (SM_FOCUS_EVENT_GAINEDP (message)) = gainedp;
+ return (message);
}
-static int
-twindow_focusp (twindow_t * twindow)
+static msg_t *
+make_key_event (wid_t wid, unsigned short code,
+ unsigned short flags, unsigned short repeat)
{
- return ((TWINDOW_CLIENT (twindow)) == (WinQueryFocus (HWND_DESKTOP)));
+ msg_t * message = (OS2_create_message (mt_key_event));
+ (SM_KEY_EVENT_WID (message)) = wid;
+ (SM_KEY_EVENT_CODE (message)) = code;
+ (SM_KEY_EVENT_FLAGS (message)) = flags;
+ (SM_KEY_EVENT_REPEAT (message)) = repeat;
+ return (message);
}
-static void
-twindow_resize (twindow_t * twindow, unsigned short width,
- unsigned short height)
-{
- unsigned short cx = (width / (TWINDOW_CHAR_WIDTH (twindow)));
- unsigned short cy = (height / (TWINDOW_CHAR_HEIGHT (twindow)));
- if ((cx == (TWINDOW_WIDTH (twindow))) && (cy == (TWINDOW_HEIGHT (twindow))))
- return;
- (TWINDOW_WIDTH (twindow)) = cx;
- (TWINDOW_HEIGHT (twindow)) = cy;
- initialize_charmap (twindow);
- SEND_EVENT (twindow, (make_resize_event ((TWINDOW_TWID (twindow)), cx, cy)));
+static msg_t *
+make_paint_event (wid_t wid,
+ unsigned short xl, unsigned short xh,
+ unsigned short yl, unsigned short yh)
+{
+ msg_t * message = (OS2_create_message (mt_paint_event));
+ (SM_PAINT_EVENT_WID (message)) = wid;
+ (SM_PAINT_EVENT_XL (message)) = xl;
+ (SM_PAINT_EVENT_XH (message)) = xh;
+ (SM_PAINT_EVENT_YL (message)) = yl;
+ (SM_PAINT_EVENT_YH (message)) = yh;
+ return (message);
}
static msg_t *
-make_resize_event (twid_t twid, unsigned short width, unsigned short height)
+make_resize_event (wid_t wid, unsigned short width, unsigned short height)
{
msg_t * message = (OS2_create_message (mt_resize_event));
- (SM_RESIZE_EVENT_TWID (message)) = twid;
+ (SM_RESIZE_EVENT_WID (message)) = wid;
(SM_RESIZE_EVENT_WIDTH (message)) = width;
(SM_RESIZE_EVENT_HEIGHT (message)) = height;
return (message);
}
-\f
-static int
-twindow_process_keychar (twindow_t * twindow, unsigned short flags,
- unsigned char repeat, unsigned char scan_code,
- unsigned short char_code, unsigned short virtual_key)
-{
- /* Ignore compound keys for now. */
- if ((flags & (KC_DEADKEY | KC_COMPOSITE | KC_INVALIDCOMP | KC_KEYUP)) != 0)
- return (0);
- else if ((flags & KC_VIRTUALKEY) != 0)
- {
- send_key_event (twindow, virtual_key, flags, repeat);
- return (1);
- }
- else if ((flags & (KC_CHAR | KC_CTRL | KC_ALT)) != 0)
- {
- send_key_event (twindow, char_code, flags, repeat);
- return (1);
- }
- else
- return (0);
-}
-
-static void
-send_key_event (twindow_t * twindow, unsigned short code,
- unsigned short flags, unsigned short repeat)
-{
- SEND_EVENT
- (twindow,
- (make_key_event ((TWINDOW_TWID (twindow)), code, flags, repeat)));
-}
static msg_t *
-make_key_event (twid_t twid, unsigned short code,
- unsigned short flags, unsigned short repeat)
+make_visibility_event (wid_t wid, int shownp)
{
- msg_t * message = (OS2_create_message (mt_key_event));
- (SM_KEY_EVENT_TWID (message)) = twid;
- (SM_KEY_EVENT_CODE (message)) = code;
- (SM_KEY_EVENT_FLAGS (message)) = flags;
- (SM_KEY_EVENT_REPEAT (message)) = repeat;
+ msg_t * message = (OS2_create_message (mt_visibility_event));
+ (SM_VISIBILITY_EVENT_WID (message)) = wid;
+ (SM_VISIBILITY_EVENT_SHOWNP (message)) = shownp;
return (message);
}
/* -*-C-*-
-$Id: os2top.c,v 1.3 1994/12/02 20:40:20 cph Exp $
+$Id: os2top.c,v 1.4 1994/12/19 22:31:44 cph Exp $
Copyright (c) 1994 Massachusetts Institute of Technology
extern void OS2_initialize_console (void);
extern void OS2_initialize_directory_reader (void);
extern void OS2_initialize_environment (void);
+extern void OS2_initialize_exception_handling (void);
extern void OS2_initialize_keyboard_interrupts (void);
extern void OS2_initialize_message_queues (void);
extern void OS2_initialize_pm_thread (void);
extern void OS2_initialize_scheme_thread (void);
extern void OS2_initialize_tty (void);
+extern void OS2_initialize_window_primitives (void);
extern const char * OS_Name;
extern const char * OS_Variant;
static const char * OS2_version_string (void);
static void initialize_locks (void);
+static HAB scheme_hab;
+static HMQ scheme_hmq;
\f
int
OS_under_emacs_p (void)
OS_initialize (void)
{
initialize_locks ();
+ /* Create a PM message queue. This allows us to use message boxes
+ to report fatal errors. */
+ scheme_hab = (WinInitialize (0));
+ if (scheme_hab == NULLHANDLE)
+ OS2_logic_error ("Unable to initialize anchor block.");
+ scheme_hmq = (WinCreateMsgQueue (scheme_hab, 0));
+ if (scheme_hmq == NULLHANDLE)
+ OS2_logic_error ("Unable to create PM message queue.");
+ OS2_initialize_exception_handling ();
OS2_initialize_message_queues ();
OS2_initialize_scheme_thread ();
OS2_initialize_pm_thread ();
OS2_initialize_environment ();
OS2_initialize_directory_reader ();
OS2_initialize_tty ();
+ OS2_initialize_window_primitives ();
OS_Name = "OS/2";
{
const char * version = (OS2_version_string ());
{
}
-long
-OS_set_trap_state (long arg)
-{
- return (arg);
-}
-
#ifdef __IBMC__
void
bcopy (const char * from, char * to, unsigned int n)
static void
initialize_locks (void)
{
- interrupt_registers_lock = (OS2_create_mutex_semaphore ());
+ interrupt_registers_lock = (OS2_create_mutex_semaphore (0, 0));
}
void
}
}
\f
+/* Machine-generated procedure, do not edit: */
+static APIRET
+syserr_to_error_code (enum syserr_names syserr)
+{
+ switch (syserr)
+ {
+ case syserr_invalid_function: return (ERROR_INVALID_FUNCTION);
+ case syserr_file_not_found: return (ERROR_FILE_NOT_FOUND);
+ case syserr_path_not_found: return (ERROR_PATH_NOT_FOUND);
+ case syserr_too_many_open_files: return (ERROR_TOO_MANY_OPEN_FILES);
+ case syserr_access_denied: return (ERROR_ACCESS_DENIED);
+ case syserr_invalid_handle: return (ERROR_INVALID_HANDLE);
+ case syserr_arena_trashed: return (ERROR_ARENA_TRASHED);
+ case syserr_not_enough_memory: return (ERROR_NOT_ENOUGH_MEMORY);
+ case syserr_invalid_block: return (ERROR_INVALID_BLOCK);
+ case syserr_bad_environment: return (ERROR_BAD_ENVIRONMENT);
+ case syserr_bad_format: return (ERROR_BAD_FORMAT);
+ case syserr_invalid_access: return (ERROR_INVALID_ACCESS);
+ case syserr_invalid_data: return (ERROR_INVALID_DATA);
+ case syserr_invalid_drive: return (ERROR_INVALID_DRIVE);
+ case syserr_current_directory: return (ERROR_CURRENT_DIRECTORY);
+ case syserr_not_same_device: return (ERROR_NOT_SAME_DEVICE);
+ case syserr_no_more_files: return (ERROR_NO_MORE_FILES);
+ case syserr_write_protect: return (ERROR_WRITE_PROTECT);
+ case syserr_bad_unit: return (ERROR_BAD_UNIT);
+ case syserr_not_ready: return (ERROR_NOT_READY);
+ case syserr_bad_command: return (ERROR_BAD_COMMAND);
+ case syserr_crc: return (ERROR_CRC);
+ case syserr_bad_length: return (ERROR_BAD_LENGTH);
+ case syserr_seek: return (ERROR_SEEK);
+ case syserr_not_dos_disk: return (ERROR_NOT_DOS_DISK);
+ case syserr_sector_not_found: return (ERROR_SECTOR_NOT_FOUND);
+ case syserr_out_of_paper: return (ERROR_OUT_OF_PAPER);
+ case syserr_write_fault: return (ERROR_WRITE_FAULT);
+ case syserr_read_fault: return (ERROR_READ_FAULT);
+ case syserr_gen_failure: return (ERROR_GEN_FAILURE);
+ case syserr_sharing_violation: return (ERROR_SHARING_VIOLATION);
+ case syserr_lock_violation: return (ERROR_LOCK_VIOLATION);
+ case syserr_wrong_disk: return (ERROR_WRONG_DISK);
+ case syserr_fcb_unavailable: return (ERROR_FCB_UNAVAILABLE);
+ case syserr_sharing_buffer_exceeded: return (ERROR_SHARING_BUFFER_EXCEEDED);
+ case syserr_code_page_mismatched: return (ERROR_CODE_PAGE_MISMATCHED);
+ case syserr_handle_eof: return (ERROR_HANDLE_EOF);
+ case syserr_handle_disk_full: return (ERROR_HANDLE_DISK_FULL);
+ case syserr_not_supported: return (ERROR_NOT_SUPPORTED);
+ case syserr_rem_not_list: return (ERROR_REM_NOT_LIST);
+ case syserr_dup_name: return (ERROR_DUP_NAME);
+ case syserr_bad_netpath: return (ERROR_BAD_NETPATH);
+ case syserr_network_busy: return (ERROR_NETWORK_BUSY);
+ case syserr_dev_not_exist: return (ERROR_DEV_NOT_EXIST);
+ case syserr_too_many_cmds: return (ERROR_TOO_MANY_CMDS);
+ case syserr_adap_hdw_err: return (ERROR_ADAP_HDW_ERR);
+ case syserr_bad_net_resp: return (ERROR_BAD_NET_RESP);
+ case syserr_unexp_net_err: return (ERROR_UNEXP_NET_ERR);
+ case syserr_bad_rem_adap: return (ERROR_BAD_REM_ADAP);
+ case syserr_printq_full: return (ERROR_PRINTQ_FULL);
+ case syserr_no_spool_space: return (ERROR_NO_SPOOL_SPACE);
+ case syserr_print_cancelled: return (ERROR_PRINT_CANCELLED);
+ case syserr_netname_deleted: return (ERROR_NETNAME_DELETED);
+ case syserr_network_access_denied: return (ERROR_NETWORK_ACCESS_DENIED);
+ case syserr_bad_dev_type: return (ERROR_BAD_DEV_TYPE);
+ case syserr_bad_net_name: return (ERROR_BAD_NET_NAME);
+ case syserr_too_many_names: return (ERROR_TOO_MANY_NAMES);
+ case syserr_too_many_sess: return (ERROR_TOO_MANY_SESS);
+ case syserr_sharing_paused: return (ERROR_SHARING_PAUSED);
+ case syserr_req_not_accep: return (ERROR_REQ_NOT_ACCEP);
+ case syserr_redir_paused: return (ERROR_REDIR_PAUSED);
+ case syserr_sbcs_att_write_prot: return (ERROR_SBCS_ATT_WRITE_PROT);
+ case syserr_sbcs_general_failure: return (ERROR_SBCS_GENERAL_FAILURE);
+ case syserr_xga_out_memory: return (ERROR_XGA_OUT_MEMORY);
+ case syserr_file_exists: return (ERROR_FILE_EXISTS);
+ case syserr_dup_fcb: return (ERROR_DUP_FCB);
+ case syserr_cannot_make: return (ERROR_CANNOT_MAKE);
+ case syserr_fail_i24: return (ERROR_FAIL_I24);
+ case syserr_out_of_structures: return (ERROR_OUT_OF_STRUCTURES);
+ case syserr_already_assigned: return (ERROR_ALREADY_ASSIGNED);
+ case syserr_invalid_password: return (ERROR_INVALID_PASSWORD);
+ case syserr_invalid_parameter: return (ERROR_INVALID_PARAMETER);
+ case syserr_net_write_fault: return (ERROR_NET_WRITE_FAULT);
+ case syserr_no_proc_slots: return (ERROR_NO_PROC_SLOTS);
+ case syserr_not_frozen: return (ERROR_NOT_FROZEN);
+ case syserr_tstovfl: return (ERR_TSTOVFL);
+ case syserr_tstdup: return (ERR_TSTDUP);
+ case syserr_no_items: return (ERROR_NO_ITEMS);
+ case syserr_interrupt: return (ERROR_INTERRUPT);
+ case syserr_device_in_use: return (ERROR_DEVICE_IN_USE);
+ case syserr_too_many_semaphores: return (ERROR_TOO_MANY_SEMAPHORES);
+ case syserr_excl_sem_already_owned: return (ERROR_EXCL_SEM_ALREADY_OWNED);
+ case syserr_sem_is_set: return (ERROR_SEM_IS_SET);
+ case syserr_too_many_sem_requests: return (ERROR_TOO_MANY_SEM_REQUESTS);
+ case syserr_invalid_at_interrupt_time: return (ERROR_INVALID_AT_INTERRUPT_TIME);
+ case syserr_sem_owner_died: return (ERROR_SEM_OWNER_DIED);
+ case syserr_sem_user_limit: return (ERROR_SEM_USER_LIMIT);
+ case syserr_disk_change: return (ERROR_DISK_CHANGE);
+ case syserr_drive_locked: return (ERROR_DRIVE_LOCKED);
+ case syserr_broken_pipe: return (ERROR_BROKEN_PIPE);
+ case syserr_open_failed: return (ERROR_OPEN_FAILED);
+ case syserr_buffer_overflow: return (ERROR_BUFFER_OVERFLOW);
+ case syserr_disk_full: return (ERROR_DISK_FULL);
+ case syserr_no_more_search_handles: return (ERROR_NO_MORE_SEARCH_HANDLES);
+ case syserr_invalid_target_handle: return (ERROR_INVALID_TARGET_HANDLE);
+ case syserr_protection_violation: return (ERROR_PROTECTION_VIOLATION);
+ case syserr_viokbd_request: return (ERROR_VIOKBD_REQUEST);
+ case syserr_invalid_category: return (ERROR_INVALID_CATEGORY);
+ case syserr_invalid_verify_switch: return (ERROR_INVALID_VERIFY_SWITCH);
+ case syserr_bad_driver_level: return (ERROR_BAD_DRIVER_LEVEL);
+ case syserr_call_not_implemented: return (ERROR_CALL_NOT_IMPLEMENTED);
+ case syserr_sem_timeout: return (ERROR_SEM_TIMEOUT);
+ case syserr_insufficient_buffer: return (ERROR_INSUFFICIENT_BUFFER);
+ case syserr_invalid_name: return (ERROR_INVALID_NAME);
+ case syserr_invalid_level: return (ERROR_INVALID_LEVEL);
+ case syserr_no_volume_label: return (ERROR_NO_VOLUME_LABEL);
+ case syserr_mod_not_found: return (ERROR_MOD_NOT_FOUND);
+ case syserr_proc_not_found: return (ERROR_PROC_NOT_FOUND);
+ case syserr_wait_no_children: return (ERROR_WAIT_NO_CHILDREN);
+ case syserr_child_not_complete: return (ERROR_CHILD_NOT_COMPLETE);
+ case syserr_direct_access_handle: return (ERROR_DIRECT_ACCESS_HANDLE);
+ case syserr_negative_seek: return (ERROR_NEGATIVE_SEEK);
+ case syserr_seek_on_device: return (ERROR_SEEK_ON_DEVICE);
+ case syserr_is_join_target: return (ERROR_IS_JOIN_TARGET);
+ case syserr_is_joined: return (ERROR_IS_JOINED);
+ case syserr_is_substed: return (ERROR_IS_SUBSTED);
+ case syserr_not_joined: return (ERROR_NOT_JOINED);
+ case syserr_not_substed: return (ERROR_NOT_SUBSTED);
+ case syserr_join_to_join: return (ERROR_JOIN_TO_JOIN);
+ case syserr_subst_to_subst: return (ERROR_SUBST_TO_SUBST);
+ case syserr_join_to_subst: return (ERROR_JOIN_TO_SUBST);
+ case syserr_subst_to_join: return (ERROR_SUBST_TO_JOIN);
+ case syserr_busy_drive: return (ERROR_BUSY_DRIVE);
+ case syserr_same_drive: return (ERROR_SAME_DRIVE);
+ case syserr_dir_not_root: return (ERROR_DIR_NOT_ROOT);
+ case syserr_dir_not_empty: return (ERROR_DIR_NOT_EMPTY);
+ case syserr_is_subst_path: return (ERROR_IS_SUBST_PATH);
+ case syserr_is_join_path: return (ERROR_IS_JOIN_PATH);
+ case syserr_path_busy: return (ERROR_PATH_BUSY);
+ case syserr_is_subst_target: return (ERROR_IS_SUBST_TARGET);
+ case syserr_system_trace: return (ERROR_SYSTEM_TRACE);
+ case syserr_invalid_event_count: return (ERROR_INVALID_EVENT_COUNT);
+ case syserr_too_many_muxwaiters: return (ERROR_TOO_MANY_MUXWAITERS);
+ case syserr_invalid_list_format: return (ERROR_INVALID_LIST_FORMAT);
+ case syserr_label_too_long: return (ERROR_LABEL_TOO_LONG);
+ case syserr_too_many_tcbs: return (ERROR_TOO_MANY_TCBS);
+ case syserr_signal_refused: return (ERROR_SIGNAL_REFUSED);
+ case syserr_discarded: return (ERROR_DISCARDED);
+ case syserr_not_locked: return (ERROR_NOT_LOCKED);
+ case syserr_bad_threadid_addr: return (ERROR_BAD_THREADID_ADDR);
+ case syserr_bad_arguments: return (ERROR_BAD_ARGUMENTS);
+ case syserr_bad_pathname: return (ERROR_BAD_PATHNAME);
+ case syserr_signal_pending: return (ERROR_SIGNAL_PENDING);
+ case syserr_uncertain_media: return (ERROR_UNCERTAIN_MEDIA);
+ case syserr_max_thrds_reached: return (ERROR_MAX_THRDS_REACHED);
+ case syserr_monitors_not_supported: return (ERROR_MONITORS_NOT_SUPPORTED);
+ case syserr_unc_driver_not_installed: return (ERROR_UNC_DRIVER_NOT_INSTALLED);
+ case syserr_lock_failed: return (ERROR_LOCK_FAILED);
+ case syserr_swapio_failed: return (ERROR_SWAPIO_FAILED);
+ case syserr_swapin_failed: return (ERROR_SWAPIN_FAILED);
+ case syserr_busy: return (ERROR_BUSY);
+ case syserr_cancel_violation: return (ERROR_CANCEL_VIOLATION);
+ case syserr_atomic_lock_not_supported: return (ERROR_ATOMIC_LOCK_NOT_SUPPORTED);
+ case syserr_read_locks_not_supported: return (ERROR_READ_LOCKS_NOT_SUPPORTED);
+ case syserr_invalid_segment_number: return (ERROR_INVALID_SEGMENT_NUMBER);
+ case syserr_invalid_callgate: return (ERROR_INVALID_CALLGATE);
+ case syserr_invalid_ordinal: return (ERROR_INVALID_ORDINAL);
+ case syserr_already_exists: return (ERROR_ALREADY_EXISTS);
+ case syserr_no_child_process: return (ERROR_NO_CHILD_PROCESS);
+ case syserr_child_alive_nowait: return (ERROR_CHILD_ALIVE_NOWAIT);
+ case syserr_invalid_flag_number: return (ERROR_INVALID_FLAG_NUMBER);
+ case syserr_sem_not_found: return (ERROR_SEM_NOT_FOUND);
+ case syserr_invalid_starting_codeseg: return (ERROR_INVALID_STARTING_CODESEG);
+ case syserr_invalid_stackseg: return (ERROR_INVALID_STACKSEG);
+ case syserr_invalid_moduletype: return (ERROR_INVALID_MODULETYPE);
+ case syserr_invalid_exe_signature: return (ERROR_INVALID_EXE_SIGNATURE);
+ case syserr_exe_marked_invalid: return (ERROR_EXE_MARKED_INVALID);
+ case syserr_bad_exe_format: return (ERROR_BAD_EXE_FORMAT);
+ case syserr_iterated_data_exceeds_64k: return (ERROR_ITERATED_DATA_EXCEEDS_64k);
+ case syserr_invalid_minallocsize: return (ERROR_INVALID_MINALLOCSIZE);
+ case syserr_dynlink_from_invalid_ring: return (ERROR_DYNLINK_FROM_INVALID_RING);
+ case syserr_iopl_not_enabled: return (ERROR_IOPL_NOT_ENABLED);
+ case syserr_invalid_segdpl: return (ERROR_INVALID_SEGDPL);
+ case syserr_autodataseg_exceeds_64k: return (ERROR_AUTODATASEG_EXCEEDS_64k);
+ case syserr_ring2seg_must_be_movable: return (ERROR_RING2SEG_MUST_BE_MOVABLE);
+ case syserr_reloc_chain_xeeds_seglim: return (ERROR_RELOC_CHAIN_XEEDS_SEGLIM);
+ case syserr_infloop_in_reloc_chain: return (ERROR_INFLOOP_IN_RELOC_CHAIN);
+ case syserr_envvar_not_found: return (ERROR_ENVVAR_NOT_FOUND);
+ case syserr_not_current_ctry: return (ERROR_NOT_CURRENT_CTRY);
+ case syserr_no_signal_sent: return (ERROR_NO_SIGNAL_SENT);
+ case syserr_filename_exced_range: return (ERROR_FILENAME_EXCED_RANGE);
+ case syserr_ring2_stack_in_use: return (ERROR_RING2_STACK_IN_USE);
+ case syserr_meta_expansion_too_long: return (ERROR_META_EXPANSION_TOO_LONG);
+ case syserr_invalid_signal_number: return (ERROR_INVALID_SIGNAL_NUMBER);
+ case syserr_thread_1_inactive: return (ERROR_THREAD_1_INACTIVE);
+ case syserr_info_not_avail: return (ERROR_INFO_NOT_AVAIL);
+ case syserr_locked: return (ERROR_LOCKED);
+ case syserr_bad_dynalink: return (ERROR_BAD_DYNALINK);
+ case syserr_too_many_modules: return (ERROR_TOO_MANY_MODULES);
+ case syserr_nesting_not_allowed: return (ERROR_NESTING_NOT_ALLOWED);
+ case syserr_cannot_shrink: return (ERROR_CANNOT_SHRINK);
+ case syserr_zombie_process: return (ERROR_ZOMBIE_PROCESS);
+ case syserr_stack_in_high_memory: return (ERROR_STACK_IN_HIGH_MEMORY);
+ case syserr_invalid_exitroutine_ring: return (ERROR_INVALID_EXITROUTINE_RING);
+ case syserr_getbuf_failed: return (ERROR_GETBUF_FAILED);
+ case syserr_flushbuf_failed: return (ERROR_FLUSHBUF_FAILED);
+ case syserr_transfer_too_long: return (ERROR_TRANSFER_TOO_LONG);
+ case syserr_forcenoswap_failed: return (ERROR_FORCENOSWAP_FAILED);
+ case syserr_smg_no_target_window: return (ERROR_SMG_NO_TARGET_WINDOW);
+ case syserr_no_children: return (ERROR_NO_CHILDREN);
+ case syserr_invalid_screen_group: return (ERROR_INVALID_SCREEN_GROUP);
+ case syserr_bad_pipe: return (ERROR_BAD_PIPE);
+ case syserr_pipe_busy: return (ERROR_PIPE_BUSY);
+ case syserr_no_data: return (ERROR_NO_DATA);
+ case syserr_pipe_not_connected: return (ERROR_PIPE_NOT_CONNECTED);
+ case syserr_more_data: return (ERROR_MORE_DATA);
+ case syserr_vc_disconnected: return (ERROR_VC_DISCONNECTED);
+ case syserr_circularity_requested: return (ERROR_CIRCULARITY_REQUESTED);
+ case syserr_directory_in_cds: return (ERROR_DIRECTORY_IN_CDS);
+ case syserr_invalid_fsd_name: return (ERROR_INVALID_FSD_NAME);
+ case syserr_invalid_path: return (ERROR_INVALID_PATH);
+ case syserr_invalid_ea_name: return (ERROR_INVALID_EA_NAME);
+ case syserr_ea_list_inconsistent: return (ERROR_EA_LIST_INCONSISTENT);
+ case syserr_ea_list_too_long: return (ERROR_EA_LIST_TOO_LONG);
+ case syserr_no_meta_match: return (ERROR_NO_META_MATCH);
+ case syserr_findnotify_timeout: return (ERROR_FINDNOTIFY_TIMEOUT);
+ case syserr_no_more_items: return (ERROR_NO_MORE_ITEMS);
+ case syserr_search_struc_reused: return (ERROR_SEARCH_STRUC_REUSED);
+ case syserr_char_not_found: return (ERROR_CHAR_NOT_FOUND);
+ case syserr_too_much_stack: return (ERROR_TOO_MUCH_STACK);
+ case syserr_invalid_attr: return (ERROR_INVALID_ATTR);
+ case syserr_invalid_starting_ring: return (ERROR_INVALID_STARTING_RING);
+ case syserr_invalid_dll_init_ring: return (ERROR_INVALID_DLL_INIT_RING);
+ case syserr_cannot_copy: return (ERROR_CANNOT_COPY);
+ case syserr_directory: return (ERROR_DIRECTORY);
+ case syserr_oplocked_file: return (ERROR_OPLOCKED_FILE);
+ case syserr_oplock_thread_exists: return (ERROR_OPLOCK_THREAD_EXISTS);
+ case syserr_volume_changed: return (ERROR_VOLUME_CHANGED);
+ case syserr_findnotify_handle_in_use: return (ERROR_FINDNOTIFY_HANDLE_IN_USE);
+ case syserr_findnotify_handle_closed: return (ERROR_FINDNOTIFY_HANDLE_CLOSED);
+ case syserr_notify_object_removed: return (ERROR_NOTIFY_OBJECT_REMOVED);
+ case syserr_already_shutdown: return (ERROR_ALREADY_SHUTDOWN);
+ case syserr_eas_didnt_fit: return (ERROR_EAS_DIDNT_FIT);
+ case syserr_ea_file_corrupt: return (ERROR_EA_FILE_CORRUPT);
+ case syserr_ea_table_full: return (ERROR_EA_TABLE_FULL);
+ case syserr_invalid_ea_handle: return (ERROR_INVALID_EA_HANDLE);
+ case syserr_no_cluster: return (ERROR_NO_CLUSTER);
+ case syserr_create_ea_file: return (ERROR_CREATE_EA_FILE);
+ case syserr_cannot_open_ea_file: return (ERROR_CANNOT_OPEN_EA_FILE);
+ case syserr_eas_not_supported: return (ERROR_EAS_NOT_SUPPORTED);
+ case syserr_need_eas_found: return (ERROR_NEED_EAS_FOUND);
+ case syserr_duplicate_handle: return (ERROR_DUPLICATE_HANDLE);
+ case syserr_duplicate_name: return (ERROR_DUPLICATE_NAME);
+ case syserr_empty_muxwait: return (ERROR_EMPTY_MUXWAIT);
+ case syserr_mutex_owned: return (ERROR_MUTEX_OWNED);
+ case syserr_not_owner: return (ERROR_NOT_OWNER);
+ case syserr_param_too_small: return (ERROR_PARAM_TOO_SMALL);
+ case syserr_too_many_handles: return (ERROR_TOO_MANY_HANDLES);
+ case syserr_too_many_opens: return (ERROR_TOO_MANY_OPENS);
+ case syserr_wrong_type: return (ERROR_WRONG_TYPE);
+ case syserr_unused_code: return (ERROR_UNUSED_CODE);
+ case syserr_thread_not_terminated: return (ERROR_THREAD_NOT_TERMINATED);
+ case syserr_init_routine_failed: return (ERROR_INIT_ROUTINE_FAILED);
+ case syserr_module_in_use: return (ERROR_MODULE_IN_USE);
+ case syserr_not_enough_watchpoints: return (ERROR_NOT_ENOUGH_WATCHPOINTS);
+ case syserr_too_many_posts: return (ERROR_TOO_MANY_POSTS);
+ case syserr_already_posted: return (ERROR_ALREADY_POSTED);
+ case syserr_already_reset: return (ERROR_ALREADY_RESET);
+ case syserr_sem_busy: return (ERROR_SEM_BUSY);
+ case syserr_invalid_procid: return (ERROR_INVALID_PROCID);
+ case syserr_invalid_pdelta: return (ERROR_INVALID_PDELTA);
+ case syserr_not_descendant: return (ERROR_NOT_DESCENDANT);
+ case syserr_not_session_manager: return (ERROR_NOT_SESSION_MANAGER);
+ case syserr_invalid_pclass: return (ERROR_INVALID_PCLASS);
+ case syserr_invalid_scope: return (ERROR_INVALID_SCOPE);
+ case syserr_invalid_threadid: return (ERROR_INVALID_THREADID);
+ case syserr_dossub_shrink: return (ERROR_DOSSUB_SHRINK);
+ case syserr_dossub_nomem: return (ERROR_DOSSUB_NOMEM);
+ case syserr_dossub_overlap: return (ERROR_DOSSUB_OVERLAP);
+ case syserr_dossub_badsize: return (ERROR_DOSSUB_BADSIZE);
+ case syserr_dossub_badflag: return (ERROR_DOSSUB_BADFLAG);
+ case syserr_dossub_badselector: return (ERROR_DOSSUB_BADSELECTOR);
+ case syserr_mr_msg_too_long: return (ERROR_MR_MSG_TOO_LONG);
+ case syserr_mr_mid_not_found: return (ERROR_MR_MID_NOT_FOUND);
+ case syserr_mr_un_acc_msgf: return (ERROR_MR_UN_ACC_MSGF);
+ case syserr_mr_inv_msgf_format: return (ERROR_MR_INV_MSGF_FORMAT);
+ case syserr_mr_inv_ivcount: return (ERROR_MR_INV_IVCOUNT);
+ case syserr_mr_un_perform: return (ERROR_MR_UN_PERFORM);
+ case syserr_ts_wakeup: return (ERROR_TS_WAKEUP);
+ case syserr_ts_semhandle: return (ERROR_TS_SEMHANDLE);
+ case syserr_ts_notimer: return (ERROR_TS_NOTIMER);
+ case syserr_ts_handle: return (ERROR_TS_HANDLE);
+ case syserr_ts_datetime: return (ERROR_TS_DATETIME);
+ case syserr_sys_internal: return (ERROR_SYS_INTERNAL);
+ case syserr_que_current_name: return (ERROR_QUE_CURRENT_NAME);
+ case syserr_que_proc_not_owned: return (ERROR_QUE_PROC_NOT_OWNED);
+ case syserr_que_proc_owned: return (ERROR_QUE_PROC_OWNED);
+ case syserr_que_duplicate: return (ERROR_QUE_DUPLICATE);
+ case syserr_que_element_not_exist: return (ERROR_QUE_ELEMENT_NOT_EXIST);
+ case syserr_que_no_memory: return (ERROR_QUE_NO_MEMORY);
+ case syserr_que_invalid_name: return (ERROR_QUE_INVALID_NAME);
+ case syserr_que_invalid_priority: return (ERROR_QUE_INVALID_PRIORITY);
+ case syserr_que_invalid_handle: return (ERROR_QUE_INVALID_HANDLE);
+ case syserr_que_link_not_found: return (ERROR_QUE_LINK_NOT_FOUND);
+ case syserr_que_memory_error: return (ERROR_QUE_MEMORY_ERROR);
+ case syserr_que_prev_at_end: return (ERROR_QUE_PREV_AT_END);
+ case syserr_que_proc_no_access: return (ERROR_QUE_PROC_NO_ACCESS);
+ case syserr_que_empty: return (ERROR_QUE_EMPTY);
+ case syserr_que_name_not_exist: return (ERROR_QUE_NAME_NOT_EXIST);
+ case syserr_que_not_initialized: return (ERROR_QUE_NOT_INITIALIZED);
+ case syserr_que_unable_to_access: return (ERROR_QUE_UNABLE_TO_ACCESS);
+ case syserr_que_unable_to_add: return (ERROR_QUE_UNABLE_TO_ADD);
+ case syserr_que_unable_to_init: return (ERROR_QUE_UNABLE_TO_INIT);
+ case syserr_vio_invalid_mask: return (ERROR_VIO_INVALID_MASK);
+ case syserr_vio_ptr: return (ERROR_VIO_PTR);
+ case syserr_vio_aptr: return (ERROR_VIO_APTR);
+ case syserr_vio_rptr: return (ERROR_VIO_RPTR);
+ case syserr_vio_cptr: return (ERROR_VIO_CPTR);
+ case syserr_vio_lptr: return (ERROR_VIO_LPTR);
+ case syserr_vio_mode: return (ERROR_VIO_MODE);
+ case syserr_vio_width: return (ERROR_VIO_WIDTH);
+ case syserr_vio_attr: return (ERROR_VIO_ATTR);
+ case syserr_vio_row: return (ERROR_VIO_ROW);
+ case syserr_vio_col: return (ERROR_VIO_COL);
+ case syserr_vio_toprow: return (ERROR_VIO_TOPROW);
+ case syserr_vio_botrow: return (ERROR_VIO_BOTROW);
+ case syserr_vio_rightcol: return (ERROR_VIO_RIGHTCOL);
+ case syserr_vio_leftcol: return (ERROR_VIO_LEFTCOL);
+ case syserr_scs_call: return (ERROR_SCS_CALL);
+ case syserr_scs_value: return (ERROR_SCS_VALUE);
+ case syserr_vio_wait_flag: return (ERROR_VIO_WAIT_FLAG);
+ case syserr_vio_unlock: return (ERROR_VIO_UNLOCK);
+ case syserr_sgs_not_session_mgr: return (ERROR_SGS_NOT_SESSION_MGR);
+ case syserr_smg_invalid_session_id: return (ERROR_SMG_INVALID_SESSION_ID);
+ case syserr_smg_no_sessions: return (ERROR_SMG_NO_SESSIONS);
+ case syserr_smg_session_not_found: return (ERROR_SMG_SESSION_NOT_FOUND);
+ case syserr_smg_set_title: return (ERROR_SMG_SET_TITLE);
+ case syserr_kbd_parameter: return (ERROR_KBD_PARAMETER);
+ case syserr_kbd_no_device: return (ERROR_KBD_NO_DEVICE);
+ case syserr_kbd_invalid_iowait: return (ERROR_KBD_INVALID_IOWAIT);
+ case syserr_kbd_invalid_length: return (ERROR_KBD_INVALID_LENGTH);
+ case syserr_kbd_invalid_echo_mask: return (ERROR_KBD_INVALID_ECHO_MASK);
+ case syserr_kbd_invalid_input_mask: return (ERROR_KBD_INVALID_INPUT_MASK);
+ case syserr_mon_invalid_parms: return (ERROR_MON_INVALID_PARMS);
+ case syserr_mon_invalid_devname: return (ERROR_MON_INVALID_DEVNAME);
+ case syserr_mon_invalid_handle: return (ERROR_MON_INVALID_HANDLE);
+ case syserr_mon_buffer_too_small: return (ERROR_MON_BUFFER_TOO_SMALL);
+ case syserr_mon_buffer_empty: return (ERROR_MON_BUFFER_EMPTY);
+ case syserr_mon_data_too_large: return (ERROR_MON_DATA_TOO_LARGE);
+ case syserr_mouse_no_device: return (ERROR_MOUSE_NO_DEVICE);
+ case syserr_mouse_inv_handle: return (ERROR_MOUSE_INV_HANDLE);
+ case syserr_mouse_inv_parms: return (ERROR_MOUSE_INV_PARMS);
+ case syserr_mouse_cant_reset: return (ERROR_MOUSE_CANT_RESET);
+ case syserr_mouse_display_parms: return (ERROR_MOUSE_DISPLAY_PARMS);
+ case syserr_mouse_inv_module: return (ERROR_MOUSE_INV_MODULE);
+ case syserr_mouse_inv_entry_pt: return (ERROR_MOUSE_INV_ENTRY_PT);
+ case syserr_mouse_inv_mask: return (ERROR_MOUSE_INV_MASK);
+ case syserr_mouse_no_data: return (NO_ERROR_MOUSE_NO_DATA);
+ case syserr_mouse_ptr_drawn: return (NO_ERROR_MOUSE_PTR_DRAWN);
+ case syserr_invalid_frequency: return (ERROR_INVALID_FREQUENCY);
+ case syserr_nls_no_country_file: return (ERROR_NLS_NO_COUNTRY_FILE);
+ case syserr_nls_open_failed: return (ERROR_NLS_OPEN_FAILED);
+ case syserr_no_country_or_codepage: return (ERROR_NO_COUNTRY_OR_CODEPAGE);
+ case syserr_nls_table_truncated: return (ERROR_NLS_TABLE_TRUNCATED);
+ case syserr_nls_bad_type: return (ERROR_NLS_BAD_TYPE);
+ case syserr_nls_type_not_found: return (ERROR_NLS_TYPE_NOT_FOUND);
+ case syserr_vio_smg_only: return (ERROR_VIO_SMG_ONLY);
+ case syserr_vio_invalid_asciiz: return (ERROR_VIO_INVALID_ASCIIZ);
+ case syserr_vio_deregister: return (ERROR_VIO_DEREGISTER);
+ case syserr_vio_no_popup: return (ERROR_VIO_NO_POPUP);
+ case syserr_vio_existing_popup: return (ERROR_VIO_EXISTING_POPUP);
+ case syserr_kbd_smg_only: return (ERROR_KBD_SMG_ONLY);
+ case syserr_kbd_invalid_asciiz: return (ERROR_KBD_INVALID_ASCIIZ);
+ case syserr_kbd_invalid_mask: return (ERROR_KBD_INVALID_MASK);
+ case syserr_kbd_register: return (ERROR_KBD_REGISTER);
+ case syserr_kbd_deregister: return (ERROR_KBD_DEREGISTER);
+ case syserr_mouse_smg_only: return (ERROR_MOUSE_SMG_ONLY);
+ case syserr_mouse_invalid_asciiz: return (ERROR_MOUSE_INVALID_ASCIIZ);
+ case syserr_mouse_invalid_mask: return (ERROR_MOUSE_INVALID_MASK);
+ case syserr_mouse_register: return (ERROR_MOUSE_REGISTER);
+ case syserr_mouse_deregister: return (ERROR_MOUSE_DEREGISTER);
+ case syserr_smg_bad_action: return (ERROR_SMG_BAD_ACTION);
+ case syserr_smg_invalid_call: return (ERROR_SMG_INVALID_CALL);
+ case syserr_scs_sg_notfound: return (ERROR_SCS_SG_NOTFOUND);
+ case syserr_scs_not_shell: return (ERROR_SCS_NOT_SHELL);
+ case syserr_vio_invalid_parms: return (ERROR_VIO_INVALID_PARMS);
+ case syserr_vio_function_owned: return (ERROR_VIO_FUNCTION_OWNED);
+ case syserr_vio_return: return (ERROR_VIO_RETURN);
+ case syserr_scs_invalid_function: return (ERROR_SCS_INVALID_FUNCTION);
+ case syserr_scs_not_session_mgr: return (ERROR_SCS_NOT_SESSION_MGR);
+ case syserr_vio_register: return (ERROR_VIO_REGISTER);
+ case syserr_vio_no_mode_thread: return (ERROR_VIO_NO_MODE_THREAD);
+ case syserr_vio_no_save_restore_thd: return (ERROR_VIO_NO_SAVE_RESTORE_THD);
+ case syserr_vio_in_bg: return (ERROR_VIO_IN_BG);
+ case syserr_vio_illegal_during_popup: return (ERROR_VIO_ILLEGAL_DURING_POPUP);
+ case syserr_smg_not_baseshell: return (ERROR_SMG_NOT_BASESHELL);
+ case syserr_smg_bad_statusreq: return (ERROR_SMG_BAD_STATUSREQ);
+ case syserr_que_invalid_wait: return (ERROR_QUE_INVALID_WAIT);
+ case syserr_vio_lock: return (ERROR_VIO_LOCK);
+ case syserr_mouse_invalid_iowait: return (ERROR_MOUSE_INVALID_IOWAIT);
+ case syserr_vio_invalid_handle: return (ERROR_VIO_INVALID_HANDLE);
+ case syserr_vio_illegal_during_lock: return (ERROR_VIO_ILLEGAL_DURING_LOCK);
+ case syserr_vio_invalid_length: return (ERROR_VIO_INVALID_LENGTH);
+ case syserr_kbd_invalid_handle: return (ERROR_KBD_INVALID_HANDLE);
+ case syserr_kbd_no_more_handle: return (ERROR_KBD_NO_MORE_HANDLE);
+ case syserr_kbd_cannot_create_kcb: return (ERROR_KBD_CANNOT_CREATE_KCB);
+ case syserr_kbd_codepage_load_incompl: return (ERROR_KBD_CODEPAGE_LOAD_INCOMPL);
+ case syserr_kbd_invalid_codepage_id: return (ERROR_KBD_INVALID_CODEPAGE_ID);
+ case syserr_kbd_no_codepage_support: return (ERROR_KBD_NO_CODEPAGE_SUPPORT);
+ case syserr_kbd_focus_required: return (ERROR_KBD_FOCUS_REQUIRED);
+ case syserr_kbd_focus_already_active: return (ERROR_KBD_FOCUS_ALREADY_ACTIVE);
+ case syserr_kbd_keyboard_busy: return (ERROR_KBD_KEYBOARD_BUSY);
+ case syserr_kbd_invalid_codepage: return (ERROR_KBD_INVALID_CODEPAGE);
+ case syserr_kbd_unable_to_focus: return (ERROR_KBD_UNABLE_TO_FOCUS);
+ case syserr_smg_session_non_select: return (ERROR_SMG_SESSION_NON_SELECT);
+ case syserr_smg_session_not_foregrnd: return (ERROR_SMG_SESSION_NOT_FOREGRND);
+ case syserr_smg_session_not_parent: return (ERROR_SMG_SESSION_NOT_PARENT);
+ case syserr_smg_invalid_start_mode: return (ERROR_SMG_INVALID_START_MODE);
+ case syserr_smg_invalid_related_opt: return (ERROR_SMG_INVALID_RELATED_OPT);
+ case syserr_smg_invalid_bond_option: return (ERROR_SMG_INVALID_BOND_OPTION);
+ case syserr_smg_invalid_select_opt: return (ERROR_SMG_INVALID_SELECT_OPT);
+ case syserr_smg_start_in_background: return (ERROR_SMG_START_IN_BACKGROUND);
+ case syserr_smg_invalid_stop_option: return (ERROR_SMG_INVALID_STOP_OPTION);
+ case syserr_smg_bad_reserve: return (ERROR_SMG_BAD_RESERVE);
+ case syserr_smg_process_not_parent: return (ERROR_SMG_PROCESS_NOT_PARENT);
+ case syserr_smg_invalid_data_length: return (ERROR_SMG_INVALID_DATA_LENGTH);
+ case syserr_smg_not_bound: return (ERROR_SMG_NOT_BOUND);
+ case syserr_smg_retry_sub_alloc: return (ERROR_SMG_RETRY_SUB_ALLOC);
+ case syserr_kbd_detached: return (ERROR_KBD_DETACHED);
+ case syserr_vio_detached: return (ERROR_VIO_DETACHED);
+ case syserr_mou_detached: return (ERROR_MOU_DETACHED);
+ case syserr_vio_font: return (ERROR_VIO_FONT);
+ case syserr_vio_user_font: return (ERROR_VIO_USER_FONT);
+ case syserr_vio_bad_cp: return (ERROR_VIO_BAD_CP);
+ case syserr_vio_no_cp: return (ERROR_VIO_NO_CP);
+ case syserr_vio_na_cp: return (ERROR_VIO_NA_CP);
+ case syserr_invalid_code_page: return (ERROR_INVALID_CODE_PAGE);
+ case syserr_cplist_too_small: return (ERROR_CPLIST_TOO_SMALL);
+ case syserr_cp_not_moved: return (ERROR_CP_NOT_MOVED);
+ case syserr_mode_switch_init: return (ERROR_MODE_SWITCH_INIT);
+ case syserr_code_page_not_found: return (ERROR_CODE_PAGE_NOT_FOUND);
+ case syserr_unexpected_slot_returned: return (ERROR_UNEXPECTED_SLOT_RETURNED);
+ case syserr_smg_invalid_trace_option: return (ERROR_SMG_INVALID_TRACE_OPTION);
+ case syserr_vio_internal_resource: return (ERROR_VIO_INTERNAL_RESOURCE);
+ case syserr_vio_shell_init: return (ERROR_VIO_SHELL_INIT);
+ case syserr_smg_no_hard_errors: return (ERROR_SMG_NO_HARD_ERRORS);
+ case syserr_cp_switch_incomplete: return (ERROR_CP_SWITCH_INCOMPLETE);
+ case syserr_vio_transparent_popup: return (ERROR_VIO_TRANSPARENT_POPUP);
+ case syserr_critsec_overflow: return (ERROR_CRITSEC_OVERFLOW);
+ case syserr_critsec_underflow: return (ERROR_CRITSEC_UNDERFLOW);
+ case syserr_vio_bad_reserve: return (ERROR_VIO_BAD_RESERVE);
+ case syserr_invalid_address: return (ERROR_INVALID_ADDRESS);
+ case syserr_zero_selectors_requested: return (ERROR_ZERO_SELECTORS_REQUESTED);
+ case syserr_not_enough_selectors_ava: return (ERROR_NOT_ENOUGH_SELECTORS_AVA);
+ case syserr_invalid_selector: return (ERROR_INVALID_SELECTOR);
+ case syserr_smg_invalid_program_type: return (ERROR_SMG_INVALID_PROGRAM_TYPE);
+ case syserr_smg_invalid_pgm_control: return (ERROR_SMG_INVALID_PGM_CONTROL);
+ case syserr_smg_invalid_inherit_opt: return (ERROR_SMG_INVALID_INHERIT_OPT);
+ case syserr_vio_extended_sg: return (ERROR_VIO_EXTENDED_SG);
+ case syserr_vio_not_pres_mgr_sg: return (ERROR_VIO_NOT_PRES_MGR_SG);
+ case syserr_vio_shield_owned: return (ERROR_VIO_SHIELD_OWNED);
+ case syserr_vio_no_more_handles: return (ERROR_VIO_NO_MORE_HANDLES);
+ case syserr_vio_see_error_log: return (ERROR_VIO_SEE_ERROR_LOG);
+ case syserr_vio_associated_dc: return (ERROR_VIO_ASSOCIATED_DC);
+ case syserr_kbd_no_console: return (ERROR_KBD_NO_CONSOLE);
+ case syserr_mouse_no_console: return (ERROR_MOUSE_NO_CONSOLE);
+ case syserr_mouse_invalid_handle: return (ERROR_MOUSE_INVALID_HANDLE);
+ case syserr_smg_invalid_debug_parms: return (ERROR_SMG_INVALID_DEBUG_PARMS);
+ case syserr_kbd_extended_sg: return (ERROR_KBD_EXTENDED_SG);
+ case syserr_mou_extended_sg: return (ERROR_MOU_EXTENDED_SG);
+ case syserr_smg_invalid_icon_file: return (ERROR_SMG_INVALID_ICON_FILE);
+ case syserr_trc_pid_non_existent: return (ERROR_TRC_PID_NON_EXISTENT);
+ case syserr_trc_count_active: return (ERROR_TRC_COUNT_ACTIVE);
+ case syserr_trc_suspended_by_count: return (ERROR_TRC_SUSPENDED_BY_COUNT);
+ case syserr_trc_count_inactive: return (ERROR_TRC_COUNT_INACTIVE);
+ case syserr_trc_count_reached: return (ERROR_TRC_COUNT_REACHED);
+ case syserr_no_mc_trace: return (ERROR_NO_MC_TRACE);
+ case syserr_mc_trace: return (ERROR_MC_TRACE);
+ case syserr_trc_count_zero: return (ERROR_TRC_COUNT_ZERO);
+ case syserr_smg_too_many_dds: return (ERROR_SMG_TOO_MANY_DDS);
+ case syserr_smg_invalid_notification: return (ERROR_SMG_INVALID_NOTIFICATION);
+ case syserr_lf_invalid_function: return (ERROR_LF_INVALID_FUNCTION);
+ case syserr_lf_not_avail: return (ERROR_LF_NOT_AVAIL);
+ case syserr_lf_suspended: return (ERROR_LF_SUSPENDED);
+ case syserr_lf_buf_too_small: return (ERROR_LF_BUF_TOO_SMALL);
+ case syserr_lf_buffer_full: return (ERROR_LF_BUFFER_FULL);
+ case syserr_lf_invalid_record: return (ERROR_LF_INVALID_RECORD);
+ case syserr_lf_invalid_service: return (ERROR_LF_INVALID_SERVICE);
+ case syserr_lf_general_failure: return (ERROR_LF_GENERAL_FAILURE);
+ case syserr_lf_invalid_id: return (ERROR_LF_INVALID_ID);
+ case syserr_lf_invalid_handle: return (ERROR_LF_INVALID_HANDLE);
+ case syserr_lf_no_id_avail: return (ERROR_LF_NO_ID_AVAIL);
+ case syserr_lf_template_area_full: return (ERROR_LF_TEMPLATE_AREA_FULL);
+ case syserr_lf_id_in_use: return (ERROR_LF_ID_IN_USE);
+ case syserr_mou_not_initialized: return (ERROR_MOU_NOT_INITIALIZED);
+ case syserr_mouinitreal_done: return (ERROR_MOUINITREAL_DONE);
+ case syserr_dossub_corrupted: return (ERROR_DOSSUB_CORRUPTED);
+ case syserr_mouse_caller_not_subsys: return (ERROR_MOUSE_CALLER_NOT_SUBSYS);
+ case syserr_arithmetic_overflow: return (ERROR_ARITHMETIC_OVERFLOW);
+ case syserr_tmr_no_device: return (ERROR_TMR_NO_DEVICE);
+ case syserr_tmr_invalid_time: return (ERROR_TMR_INVALID_TIME);
+ case syserr_pvw_invalid_entity: return (ERROR_PVW_INVALID_ENTITY);
+ case syserr_pvw_invalid_entity_type: return (ERROR_PVW_INVALID_ENTITY_TYPE);
+ case syserr_pvw_invalid_spec: return (ERROR_PVW_INVALID_SPEC);
+ case syserr_pvw_invalid_range_type: return (ERROR_PVW_INVALID_RANGE_TYPE);
+ case syserr_pvw_invalid_counter_blk: return (ERROR_PVW_INVALID_COUNTER_BLK);
+ case syserr_pvw_invalid_text_blk: return (ERROR_PVW_INVALID_TEXT_BLK);
+ case syserr_prf_not_initialized: return (ERROR_PRF_NOT_INITIALIZED);
+ case syserr_prf_already_initialized: return (ERROR_PRF_ALREADY_INITIALIZED);
+ case syserr_prf_not_started: return (ERROR_PRF_NOT_STARTED);
+ case syserr_prf_already_started: return (ERROR_PRF_ALREADY_STARTED);
+ case syserr_prf_timer_out_of_range: return (ERROR_PRF_TIMER_OUT_OF_RANGE);
+ case syserr_prf_timer_reset: return (ERROR_PRF_TIMER_RESET);
+ case syserr_vdd_lock_useage_denied: return (ERROR_VDD_LOCK_USEAGE_DENIED);
+ case syserr_timeout: return (ERROR_TIMEOUT);
+ case syserr_vdm_down: return (ERROR_VDM_DOWN);
+ case syserr_vdm_limit: return (ERROR_VDM_LIMIT);
+ case syserr_vdd_not_found: return (ERROR_VDD_NOT_FOUND);
+ case syserr_invalid_caller: return (ERROR_INVALID_CALLER);
+ case syserr_pid_mismatch: return (ERROR_PID_MISMATCH);
+ case syserr_invalid_vdd_handle: return (ERROR_INVALID_VDD_HANDLE);
+ case syserr_vlpt_no_spooler: return (ERROR_VLPT_NO_SPOOLER);
+ case syserr_vcom_device_busy: return (ERROR_VCOM_DEVICE_BUSY);
+ case syserr_vlpt_device_busy: return (ERROR_VLPT_DEVICE_BUSY);
+ case syserr_nesting_too_deep: return (ERROR_NESTING_TOO_DEEP);
+ case syserr_vdd_missing: return (ERROR_VDD_MISSING);
+ case syserr_bidi_invalid_length: return (ERROR_BIDI_INVALID_LENGTH);
+ case syserr_bidi_invalid_increment: return (ERROR_BIDI_INVALID_INCREMENT);
+ case syserr_bidi_invalid_combination: return (ERROR_BIDI_INVALID_COMBINATION);
+ case syserr_bidi_invalid_reserved: return (ERROR_BIDI_INVALID_RESERVED);
+ case syserr_bidi_invalid_effect: return (ERROR_BIDI_INVALID_EFFECT);
+ case syserr_bidi_invalid_csdrec: return (ERROR_BIDI_INVALID_CSDREC);
+ case syserr_bidi_invalid_csdstate: return (ERROR_BIDI_INVALID_CSDSTATE);
+ case syserr_bidi_invalid_level: return (ERROR_BIDI_INVALID_LEVEL);
+ case syserr_bidi_invalid_type_support: return (ERROR_BIDI_INVALID_TYPE_SUPPORT);
+ case syserr_bidi_invalid_orientation: return (ERROR_BIDI_INVALID_ORIENTATION);
+ case syserr_bidi_invalid_num_shape: return (ERROR_BIDI_INVALID_NUM_SHAPE);
+ case syserr_bidi_invalid_csd: return (ERROR_BIDI_INVALID_CSD);
+ case syserr_bidi_no_support: return (ERROR_BIDI_NO_SUPPORT);
+ case syserr_bidi_rw_incomplete: return (NO_ERROR_BIDI_RW_INCOMPLETE);
+ case syserr_imp_invalid_parm: return (ERROR_IMP_INVALID_PARM);
+ case syserr_imp_invalid_length: return (ERROR_IMP_INVALID_LENGTH);
+ case syserr_hpfs_disk_error_warn: return (MSG_HPFS_DISK_ERROR_WARN);
+ case syserr_mon_bad_buffer: return (ERROR_MON_BAD_BUFFER);
+ case syserr_module_corrupted: return (ERROR_MODULE_CORRUPTED);
+ case syserr_sm_outof_swapfile: return (ERROR_SM_OUTOF_SWAPFILE);
+ case syserr_lf_timeout: return (ERROR_LF_TIMEOUT);
+ case syserr_lf_suspend_success: return (ERROR_LF_SUSPEND_SUCCESS);
+ case syserr_lf_resume_success: return (ERROR_LF_RESUME_SUCCESS);
+ case syserr_lf_redirect_success: return (ERROR_LF_REDIRECT_SUCCESS);
+ case syserr_lf_redirect_failure: return (ERROR_LF_REDIRECT_FAILURE);
+ case syserr_swapper_not_active: return (ERROR_SWAPPER_NOT_ACTIVE);
+ case syserr_invalid_swapid: return (ERROR_INVALID_SWAPID);
+ case syserr_ioerr_swap_file: return (ERROR_IOERR_SWAP_FILE);
+ case syserr_swap_table_full: return (ERROR_SWAP_TABLE_FULL);
+ case syserr_swap_file_full: return (ERROR_SWAP_FILE_FULL);
+ case syserr_cant_init_swapper: return (ERROR_CANT_INIT_SWAPPER);
+ case syserr_swapper_already_init: return (ERROR_SWAPPER_ALREADY_INIT);
+ case syserr_pmm_insufficient_memory: return (ERROR_PMM_INSUFFICIENT_MEMORY);
+ case syserr_pmm_invalid_flags: return (ERROR_PMM_INVALID_FLAGS);
+ case syserr_pmm_invalid_address: return (ERROR_PMM_INVALID_ADDRESS);
+ case syserr_pmm_lock_failed: return (ERROR_PMM_LOCK_FAILED);
+ case syserr_pmm_unlock_failed: return (ERROR_PMM_UNLOCK_FAILED);
+ case syserr_pmm_move_incomplete: return (ERROR_PMM_MOVE_INCOMPLETE);
+ case syserr_ucom_drive_renamed: return (ERROR_UCOM_DRIVE_RENAMED);
+ case syserr_ucom_filename_truncated: return (ERROR_UCOM_FILENAME_TRUNCATED);
+ case syserr_ucom_buffer_length: return (ERROR_UCOM_BUFFER_LENGTH);
+ case syserr_mon_chain_handle: return (ERROR_MON_CHAIN_HANDLE);
+ case syserr_mon_not_registered: return (ERROR_MON_NOT_REGISTERED);
+ case syserr_smg_already_top: return (ERROR_SMG_ALREADY_TOP);
+ case syserr_pmm_arena_modified: return (ERROR_PMM_ARENA_MODIFIED);
+ case syserr_smg_printer_open: return (ERROR_SMG_PRINTER_OPEN);
+ case syserr_pmm_set_flags_failed: return (ERROR_PMM_SET_FLAGS_FAILED);
+ case syserr_invalid_dos_dd: return (ERROR_INVALID_DOS_DD);
+ case syserr_blocked: return (ERROR_BLOCKED);
+ case syserr_noblock: return (ERROR_NOBLOCK);
+ case syserr_instance_shared: return (ERROR_INSTANCE_SHARED);
+ case syserr_no_object: return (ERROR_NO_OBJECT);
+ case syserr_partial_attach: return (ERROR_PARTIAL_ATTACH);
+ case syserr_incache: return (ERROR_INCACHE);
+ case syserr_swap_io_problems: return (ERROR_SWAP_IO_PROBLEMS);
+ case syserr_crosses_object_boundary: return (ERROR_CROSSES_OBJECT_BOUNDARY);
+ case syserr_longlock: return (ERROR_LONGLOCK);
+ case syserr_shortlock: return (ERROR_SHORTLOCK);
+ case syserr_uvirtlock: return (ERROR_UVIRTLOCK);
+ case syserr_aliaslock: return (ERROR_ALIASLOCK);
+ case syserr_alias: return (ERROR_ALIAS);
+ case syserr_no_more_handles: return (ERROR_NO_MORE_HANDLES);
+ case syserr_scan_terminated: return (ERROR_SCAN_TERMINATED);
+ case syserr_terminator_not_found: return (ERROR_TERMINATOR_NOT_FOUND);
+ case syserr_not_direct_child: return (ERROR_NOT_DIRECT_CHILD);
+ case syserr_delay_free: return (ERROR_DELAY_FREE);
+ case syserr_guardpage: return (ERROR_GUARDPAGE);
+ case syserr_swaperror: return (ERROR_SWAPERROR);
+ case syserr_ldrerror: return (ERROR_LDRERROR);
+ case syserr_nomemory: return (ERROR_NOMEMORY);
+ case syserr_noaccess: return (ERROR_NOACCESS);
+ case syserr_no_dll_term: return (ERROR_NO_DLL_TERM);
+ case syserr_cpsio_code_page_invalid: return (ERROR_CPSIO_CODE_PAGE_INVALID);
+ case syserr_cpsio_no_spooler: return (ERROR_CPSIO_NO_SPOOLER);
+ case syserr_cpsio_font_id_invalid: return (ERROR_CPSIO_FONT_ID_INVALID);
+ case syserr_cpsio_internal_error: return (ERROR_CPSIO_INTERNAL_ERROR);
+ case syserr_cpsio_invalid_ptr_name: return (ERROR_CPSIO_INVALID_PTR_NAME);
+ case syserr_cpsio_not_active: return (ERROR_CPSIO_NOT_ACTIVE);
+ case syserr_cpsio_pid_full: return (ERROR_CPSIO_PID_FULL);
+ case syserr_cpsio_pid_not_found: return (ERROR_CPSIO_PID_NOT_FOUND);
+ case syserr_cpsio_read_ctl_seq: return (ERROR_CPSIO_READ_CTL_SEQ);
+ case syserr_cpsio_read_fnt_def: return (ERROR_CPSIO_READ_FNT_DEF);
+ case syserr_cpsio_write_error: return (ERROR_CPSIO_WRITE_ERROR);
+ case syserr_cpsio_write_full_error: return (ERROR_CPSIO_WRITE_FULL_ERROR);
+ case syserr_cpsio_write_handle_bad: return (ERROR_CPSIO_WRITE_HANDLE_BAD);
+ case syserr_cpsio_swit_load: return (ERROR_CPSIO_SWIT_LOAD);
+ case syserr_cpsio_inv_command: return (ERROR_CPSIO_INV_COMMAND);
+ case syserr_cpsio_no_font_swit: return (ERROR_CPSIO_NO_FONT_SWIT);
+ case syserr_entry_is_callgate: return (ERROR_ENTRY_IS_CALLGATE);
+ default: return (NO_ERROR);
+ }
+}
+\f
#ifdef __GCC2__
/* Grumble... stupid linking bug. */
#define dos_error_message(rc) 0
OS_error_code_to_message (unsigned int syserr)
{
static const char * last_message = 0;
+ APIRET code = (syserr_to_error_code ((enum syserr_names) syserr));
+ if (code == NO_ERROR)
+ return (0);
if (last_message != 0)
free ((void *) last_message);
- last_message = (dos_error_message (syserr));
+ last_message = (dos_error_message (code));
return (last_message);
}
\f
"dos-query-current-dir",
"dos-query-current-disk",
"dos-query-file-info",
+ "dos-query-fs-attach",
+ "dos-query-fs-info",
"dos-query-h-type",
"dos-query-n-p-h-state",
"dos-query-path-info",
"NET-WRITE-FAULT",
"NO-PROC-SLOTS",
"NOT-FROZEN",
- "SYS-COMP-NOT-LOADED",
"TSTOVFL",
"TSTDUP",
"NO-ITEMS",
projects / mit-scheme.git / commitdiff