![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to console.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / conio|
Return to console.c CVS log | Up to [Synchronet] / sbbs / conio |
1.1 root 1: /*
2: * Copyright (c) 1992, 1993, 1996
3: * Berkeley Software Design, Inc. All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by Berkeley Software
16: * Design, Inc.
17: *
18: * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: *
30: * July 22, 1999
31: *
32: * To All Licensees, Distributors of Any Version of BSD:
33: *
34: * As you know, certain of the Berkeley Software Distribution ("BSD") source
35: * code files require that further distributions of products containing all or
36: * portions of the software, acknowledge within their advertising materials
37: * that such products contain software developed by UC Berkeley and its
38: * contributors.
39: *
40: * Specifically, the provision reads:
41: *
42: * " * 3. All advertising materials mentioning features or use of this software
43: * * must display the following acknowledgement:
44: * * This product includes software developed by the University of
45: * * California, Berkeley and its contributors."
46: *
47: * Effective immediately, licensees and distributors are no longer required to
48: * include the acknowledgement within advertising materials. Accordingly, the
49: * foregoing paragraph of those BSD Unix files containing it is hereby deleted
50: * in its entirety.
51: *
52: * William Hoskins
53: * Director, Office of Technology Licensing
54: * University of California, Berkeley
55: *
56: *
57: */
58:
59: /* $Id: console.c,v 1.25 2004/09/22 05:06:59 deuce Exp $ */
60:
61: /****************************************************************************
62: * @format.tab-size 4 (Plain Text/Source Code File Header) *
63: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
64: * *
65: * Copyright 2004 Rob Swindell - http://www.synchro.net/copyright.html *
66: * *
67: * This library is free software; you can redistribute it and/or *
68: * modify it under the terms of the GNU Lesser General Public License *
69: * as published by the Free Software Foundation; either version 2 *
70: * of the License, or (at your option) any later version. *
71: * See the GNU Lesser General Public License for more details: lgpl.txt or *
72: * http://www.fsf.org/copyleft/lesser.html *
73: * *
74: * Anonymous FTP access to the most recent released source is available at *
75: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
76: * *
77: * Anonymous CVS access to the development source and modification history *
78: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
79: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
80: * (just hit return, no password is necessary) *
81: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
82: * *
83: * For Synchronet coding style and modification guidelines, see *
84: * http://www.synchro.net/source.html *
85: * *
86: * You are encouraged to submit any modifications (preferably in Unix diff *
87: * format) via e-mail to [email protected] *
88: * *
89: * Note: If this box doesn't appear square, then you need to fix your tabs. *
90: ****************************************************************************/
91:
92: #include <sys/param.h>
93: #include <sys/time.h>
94: #include <sys/types.h>
95: #include <sys/user.h>
96:
97: #include <dlfcn.h>
98: #include <fcntl.h>
99: #include <limits.h>
100: #include <paths.h>
101: #include <stdio.h>
102: #include <unistd.h> /* sysconf() */
103:
104: #include <X11/Xlib.h>
105: #include <X11/Xutil.h>
106: #include <X11/keysym.h>
107:
108: #include <genwrap.h>
109:
110: #include "console.h"
111: #include "vidmodes.h"
112:
113: #include "keys.h"
114: #include "mouse.h"
115: #include "vgafont.h"
116:
117: /* Console definition variables */
118: int console_new_mode=NO_NEW_MODE;
119: int CurrMode;
120: sem_t console_mode_changed;
121: sem_t x11_beep;
122: sem_t x11_title;
123: int InitCS;
124: int InitCE;
125: int FW, FH;
126: WORD DpyCols;
127: BYTE DpyRows;
128: BYTE *palette;
129: BYTE CursStart;
130: BYTE CursEnd;
131: WORD *vmem=NULL;
132: static int show = 1;
133: BYTE CursRow=0;
134: BYTE CursCol=0;
135: typedef struct TextLine {
136: WORD *data;
137: u_char max_length; /* Not used, but here for future use */
138: u_char changed:1;
139: } TextLine;
140: TextLine *lines = NULL;
141:
142: /* X Variables */
143: Display *dpy=NULL;
144: Window win;
145: XImage *xi = 0;
146: Pixmap pfnt=0;
147: Visual *visual;
148: unsigned int depth;
149: unsigned long black;
150: unsigned long white;
151: GC gc;
152: GC cgc;
153: int xfd;
154: char window_title[81];
155:
156: /* X functions */
157: struct x11 {
158: int (*XChangeGC) (Display*, GC, unsigned long, XGCValues*);
159: int (*XCopyPlane) (Display*, Drawable, Drawable, GC, int, int, unsigned int, unsigned int, int, int, unsigned long);
160: int (*XFillRectangle) (Display*, Drawable, GC, int, int, unsigned int, unsigned int);
161: int (*XFlush) (Display*);
162: int (*XBell) (Display*, int);
163: int (*XLookupString)(XKeyEvent*, char*, int, KeySym*, XComposeStatus*);
164: int (*XNextEvent) (Display*, XEvent *);
165: XSizeHints* (*XAllocSizeHints)(void);
166: void (*XSetWMNormalHints) (Display*, Window, XSizeHints*);
167: int (*XResizeWindow)(Display*, Window, unsigned int, unsigned int);
168: int (*XMapWindow) (Display*, Window);
169: int (*XFree) (void *data);
170: int (*XFreePixmap) (Display*, Pixmap);
171: int (*XCreateBitmapFromData) (Display*, Drawable, _Xconst char*, unsigned int, unsigned int);
172: Status (*XAllocColor) (Display*, Colormap, XColor*);
173: Display*(*XOpenDisplay) (_Xconst char*);
174: Window (*XCreateSimpleWindow) (Display*, Window, int, int, unsigned int, unsigned int, unsigned int, unsigned long, unsigned long);
175: GC (*XCreateGC) (Display*, Drawable, unsigned long, XGCValues*);
176: int (*XSelectInput) (Display*, Window, long);
177: int (*XStoreName) (Display*, Window, _Xconst char*);
178: };
179: struct x11 x11;
180:
181: /* X pixel values for the RGB triples */
182: DWORD pixels[16];
183:
184: static fd_set fdset; /* File Descriptors to select on */
185:
186: /* Keyboard stuff */
187: WORD keybuf[0x25];
188: #define K_NEXT keybuf[0x21] /* *(WORD *)0x41a */
189: #define K_FREE keybuf[0x22] /* *(WORD *)0x41c */
190: #define K_BUFSTARTP keybuf[0x23] /* *(WORD *)0x480 */
191: #define K_BUFENDP keybuf[0x24] /* *(WORD *)0x482 */
192: #define K_BUFSTART (&keybuf[K_BUFSTARTP]) /* ((WORD *)(0x400 + K_BUFSTARTP)) */
193: #define K_BUFEND (&keybuf[K_BUFENDP]) /* ((WORD *)(0x400 + keybuf[3])) */
194: #define K_BUF(i) keybuf[i] /* *((WORD *)((u_char *)0x400 + (i))) */
195:
196: BYTE K1_STATUS;
197: #define K1_RSHIFT 0x01
198: #define K1_LSHIFT 0x02
199: #define K1_SHIFT 0x03
200: #define K1_CTRL 0x04
201: #define K1_ALT 0x08
202: #define K1_SLOCK 0x10 /* Active */
203: #define K1_NLOCK 0x20 /* Active */
204: #define K1_CLOCK 0x40 /* Active */
205: #define K1_INSERT 0x80 /* Active */
206:
207: BYTE K2_STATUS;
208: #define K2_LCTRL 0x01
209: #define K2_LALT 0x02
210: #define K2_SYSREQ 0x04
211: #define K2_PAUSE 0x08
212: #define K2_SLOCK 0x10 /* Actually held down */
213: #define K2_NLOCK 0x20 /* Actually held down */
214: #define K2_CLOCK 0x40 /* Actually held down */
215: #define K2_INSERT 0x80 /* Actually held down */
216:
217: BYTE K3_STATUS;
218: #define K3_E1 0x01 /* Last code read was e1 */
219: #define K3_E2 0x02 /* Last code read was e2 */
220: #define K3_RCTRL 0x04
221: #define K3_RALT 0x08
222: #define K3_ENHANCED 0x10
223: #define K3_FORCENLOCK 0x20
224: #define K3_TWOBYTE 0x40 /* last code was first of 2 */
225: #define K3_READID 0x80 /* read ID in progress */
226:
227: BYTE K4_STATUS;
228: #define K4_SLOCK_LED 0x01
229: #define K4_NLOCK_LED 0x02
230: #define K4_CLOCK_LED 0x04
231: #define K4_ACK 0x10 /* ACK recieved from keyboard */
232: #define K4_RESEND 0x20 /* RESEND recieved from keyboard */
233: #define K4_LED 0x40 /* LED update in progress */
234: #define K4_ERROR 0x80
235:
236: int flipdelete = 0; /* Flip meaning of delete and backspace */
237: static WORD break_code = 0x00;
238:
239: static WORD Ascii2Scan[] = {
240: 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
241: 0x000e, 0x000f, 0xffff, 0xffff, 0xffff, 0x001c, 0xffff, 0xffff,
242: 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
243: 0xffff, 0xffff, 0xffff, 0x0001, 0xffff, 0xffff, 0xffff, 0xffff,
244: 0x0039, 0x0102, 0x0128, 0x0104, 0x0105, 0x0106, 0x0108, 0x0028,
245: 0x010a, 0x010b, 0x0109, 0x010d, 0x0033, 0x000c, 0x0034, 0x0035,
246: 0x000b, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
247: 0x0009, 0x000a, 0x0127, 0x0027, 0x0133, 0x000d, 0x0134, 0x0135,
248: 0x0103, 0x011e, 0x0130, 0x012e, 0x0120, 0x0112, 0x0121, 0x0122,
249: 0x0123, 0x0117, 0x0124, 0x0125, 0x0126, 0x0132, 0x0131, 0x0118,
250: 0x0119, 0x0110, 0x0113, 0x011f, 0x0114, 0x0116, 0x012f, 0x0111,
251: 0x012d, 0x0115, 0x012c, 0x001a, 0x002b, 0x001b, 0x0107, 0x010c,
252: 0x0029, 0x001e, 0x0030, 0x002e, 0x0020, 0x0012, 0x0021, 0x0022,
253: 0x0023, 0x0017, 0x0024, 0x0025, 0x0026, 0x0032, 0x0031, 0x0018,
254: 0x0019, 0x0010, 0x0013, 0x001f, 0x0014, 0x0016, 0x002f, 0x0011,
255: 0x002d, 0x0015, 0x002c, 0x011a, 0x012b, 0x011b, 0x0129, 0xffff,
256: };
257:
258: struct {
259: WORD base;
260: WORD shift;
261: WORD ctrl;
262: WORD alt;
263: } ScanCodes[] = {
264: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 0 */
265: { 0x011b, 0x011b, 0x011b, 0xffff }, /* key 1 - Escape key */
266: { 0x0231, 0x0221, 0xffff, 0x7800 }, /* key 2 - '1' */
267: { 0x0332, 0x0340, 0x0300, 0x7900 }, /* key 3 - '2' - special handling */
268: { 0x0433, 0x0423, 0xffff, 0x7a00 }, /* key 4 - '3' */
269: { 0x0534, 0x0524, 0xffff, 0x7b00 }, /* key 5 - '4' */
270: { 0x0635, 0x0625, 0xffff, 0x7c00 }, /* key 6 - '5' */
271: { 0x0736, 0x075e, 0x071e, 0x7d00 }, /* key 7 - '6' */
272: { 0x0837, 0x0826, 0xffff, 0x7e00 }, /* key 8 - '7' */
273: { 0x0938, 0x092a, 0xffff, 0x7f00 }, /* key 9 - '8' */
274: { 0x0a39, 0x0a28, 0xffff, 0x8000 }, /* key 10 - '9' */
275: { 0x0b30, 0x0b29, 0xffff, 0x8100 }, /* key 11 - '0' */
276: { 0x0c2d, 0x0c5f, 0x0c1f, 0x8200 }, /* key 12 - '-' */
277: { 0x0d3d, 0x0d2b, 0xffff, 0x8300 }, /* key 13 - '=' */
278: { 0x0e08, 0x0e08, 0x0e7f, 0xffff }, /* key 14 - backspace */
279: { 0x0f09, 0x0f00, 0xffff, 0xffff }, /* key 15 - tab */
280: { 0x1071, 0x1051, 0x1011, 0x1000 }, /* key 16 - 'Q' */
281: { 0x1177, 0x1157, 0x1117, 0x1100 }, /* key 17 - 'W' */
282: { 0x1265, 0x1245, 0x1205, 0x1200 }, /* key 18 - 'E' */
283: { 0x1372, 0x1352, 0x1312, 0x1300 }, /* key 19 - 'R' */
284: { 0x1474, 0x1454, 0x1414, 0x1400 }, /* key 20 - 'T' */
285: { 0x1579, 0x1559, 0x1519, 0x1500 }, /* key 21 - 'Y' */
286: { 0x1675, 0x1655, 0x1615, 0x1600 }, /* key 22 - 'U' */
287: { 0x1769, 0x1749, 0x1709, 0x1700 }, /* key 23 - 'I' */
288: { 0x186f, 0x184f, 0x180f, 0x1800 }, /* key 24 - 'O' */
289: { 0x1970, 0x1950, 0x1910, 0x1900 }, /* key 25 - 'P' */
290: { 0x1a5b, 0x1a7b, 0x1a1b, 0xffff }, /* key 26 - '[' */
291: { 0x1b5d, 0x1b7d, 0x1b1d, 0xffff }, /* key 27 - ']' */
292: { 0x1c0d, 0x1c0d, 0x1c0a, 0xffff }, /* key 28 - CR */
293: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 29 - control */
294: { 0x1e61, 0x1e41, 0x1e01, 0x1e00 }, /* key 30 - 'A' */
295: { 0x1f73, 0x1f53, 0x1f13, 0x1f00 }, /* key 31 - 'S' */
296: { 0x2064, 0x2044, 0x2004, 0x2000 }, /* key 32 - 'D' */
297: { 0x2166, 0x2146, 0x2106, 0x2100 }, /* key 33 - 'F' */
298: { 0x2267, 0x2247, 0x2207, 0x2200 }, /* key 34 - 'G' */
299: { 0x2368, 0x2348, 0x2308, 0x2300 }, /* key 35 - 'H' */
300: { 0x246a, 0x244a, 0x240a, 0x2400 }, /* key 36 - 'J' */
301: { 0x256b, 0x254b, 0x250b, 0x2500 }, /* key 37 - 'K' */
302: { 0x266c, 0x264c, 0x260c, 0x2600 }, /* key 38 - 'L' */
303: { 0x273b, 0x273a, 0xffff, 0xffff }, /* key 39 - ';' */
304: { 0x2827, 0x2822, 0xffff, 0xffff }, /* key 40 - ''' */
305: { 0x2960, 0x297e, 0xffff, 0xffff }, /* key 41 - '`' */
306: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 42 - left shift */
307: { 0x2b5c, 0x2b7c, 0x2b1c, 0xffff }, /* key 43 - '' */
308: { 0x2c7a, 0x2c5a, 0x2c1a, 0x2c00 }, /* key 44 - 'Z' */
309: { 0x2d78, 0x2d58, 0x2d18, 0x2d00 }, /* key 45 - 'X' */
310: { 0x2e63, 0x2e43, 0x2e03, 0x2e00 }, /* key 46 - 'C' */
311: { 0x2f76, 0x2f56, 0x2f16, 0x2f00 }, /* key 47 - 'V' */
312: { 0x3062, 0x3042, 0x3002, 0x3000 }, /* key 48 - 'B' */
313: { 0x316e, 0x314e, 0x310e, 0x3100 }, /* key 49 - 'N' */
314: { 0x326d, 0x324d, 0x320d, 0x3200 }, /* key 50 - 'M' */
315: { 0x332c, 0x333c, 0xffff, 0xffff }, /* key 51 - ',' */
316: { 0x342e, 0x343e, 0xffff, 0xffff }, /* key 52 - '.' */
317: { 0x352f, 0x353f, 0xffff, 0xffff }, /* key 53 - '/' */
318: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 54 - right shift - */
319: { 0x372a, 0xffff, 0x3772, 0xffff }, /* key 55 - prt-scr - */
320: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 56 - Alt - */
321: { 0x3920, 0x3920, 0x3920, 0x3920 }, /* key 57 - space bar */
322: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 58 - caps-lock - */
323: { 0x3b00, 0x5400, 0x5e00, 0x6800 }, /* key 59 - F1 */
324: { 0x3c00, 0x5500, 0x5f00, 0x6900 }, /* key 60 - F2 */
325: { 0x3d00, 0x5600, 0x6000, 0x6a00 }, /* key 61 - F3 */
326: { 0x3e00, 0x5700, 0x6100, 0x6b00 }, /* key 62 - F4 */
327: { 0x3f00, 0x5800, 0x6200, 0x6c00 }, /* key 63 - F5 */
328: { 0x4000, 0x5900, 0x6300, 0x6d00 }, /* key 64 - F6 */
329: { 0x4100, 0x5a00, 0x6400, 0x6e00 }, /* key 65 - F7 */
330: { 0x4200, 0x5b00, 0x6500, 0x6f00 }, /* key 66 - F8 */
331: { 0x4300, 0x5c00, 0x6600, 0x7000 }, /* key 67 - F9 */
332: { 0x4400, 0x5d00, 0x6700, 0x7100 }, /* key 68 - F10 */
333: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 69 - num-lock - */
334: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 70 - scroll-lock - */
335: { 0x4700, 0x4737, 0x7700, 0xffff }, /* key 71 - home */
336: { 0x4800, 0x4838, 0xffff, 0xffff }, /* key 72 - cursor up */
337: { 0x4900, 0x4939, 0x8400, 0xffff }, /* key 73 - page up */
338: { 0x4a2d, 0x4a2d, 0xffff, 0xffff }, /* key 74 - minus sign */
339: { 0x4b00, 0x4b34, 0x7300, 0xffff }, /* key 75 - cursor left */
340: { 0xffff, 0x4c35, 0xffff, 0xffff }, /* key 76 - center key */
341: { 0x4d00, 0x4d36, 0x7400, 0xffff }, /* key 77 - cursor right */
342: { 0x4e2b, 0x4e2b, 0xffff, 0xffff }, /* key 78 - plus sign */
343: { 0x4f00, 0x4f31, 0x7500, 0xffff }, /* key 79 - end */
344: { 0x5000, 0x5032, 0xffff, 0xffff }, /* key 80 - cursor down */
345: { 0x5100, 0x5133, 0x7600, 0xffff }, /* key 81 - page down */
346: { 0x5200, 0x5230, 0xffff, 0xffff }, /* key 82 - insert */
347: { 0x5300, 0x532e, 0xffff, 0xffff }, /* key 83 - delete */
348: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 84 - sys key */
349: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 85 */
350: { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 86 */
351: { 0x8500, 0x5787, 0x8900, 0x8b00 }, /* key 87 - F11 */
352: { 0x8600, 0x5888, 0x8a00, 0x8c00 }, /* key 88 - F12 */
353: };
354:
355: #define HWM 16
356:
357: void tty_pause()
358: {
359: usleep(1000);
360: }
361:
362: volatile int poll_cnt = 0;
363:
364: void
365: wakeup_poll(void)
366: {
367: if (poll_cnt <= 0)
368: poll_cnt = HWM;
369: }
370:
371: void
372: reset_poll(void)
373: {
374: poll_cnt = HWM;
375: }
376:
377: void
378: sleep_poll(void)
379: {
380: if (--poll_cnt <= 0) {
381: poll_cnt = 0;
382: while (KbdEmpty() && poll_cnt <= 0) {
383: if (KbdEmpty() && poll_cnt <= 0)
384: tty_pause();
385: }
386: }
387: }
388:
389: static void
390: setgc(WORD attr)
391: {
392: XGCValues v;
393:
394: v.background = pixels[(attr >> 12) & 0x07];
395: if ((!show) && (attr & 0x8000))
396: v.foreground = v.background;
397: else
398: v.foreground = pixels[(attr >> 8) & 0x0f];
399:
400: x11.XChangeGC(dpy, gc, GCForeground|GCBackground, &v);
401: }
402:
403: static void
404: video_update_text()
405: {
406: static int or = -1;
407: static int oc = -1;
408: static int os = -1;
409:
410: static char buf[256];
411: int r, c;
412: int attr = vmem[0] & 0xff00;
413: XGCValues v;
414:
415: wakeup_poll(); /* Wake up anyone waiting on kbd poll */
416:
417: setgc(attr);
418:
419: for (r = 0; r < (DpyRows+1); ++r) {
420: int cc = 0;
421:
422: if (!lines[r].changed) {
423: if ((r == or || r == CursRow) && (or != CursRow || oc !=CursCol))
424: lines[r].changed=1;
425: else {
426: for (c = 0; c < DpyCols; ++c) {
427: if (lines[r].data[c] != vmem[r * DpyCols + c]) {
428: lines[r].changed = 1;
429: break;
430: }
431: if (lines[r].data[c] & 0x8000 && show != os) {
432: lines[r].changed = 1;
433: break;
434: }
435: }
436: }
437: }
438:
439: if (!lines[r].changed)
440: continue;
441:
442: reset_poll();
443: lines[r].changed = 0;
444: memcpy(lines[r].data,
445: &vmem[r * DpyCols], sizeof(WORD) * DpyCols);
446:
447: for (c = 0; c < DpyCols; ++c) {
448: setgc(vmem[r * DpyCols + c] & 0xff00);
449: x11.XCopyPlane(dpy,pfnt,win,gc,0,FH*(vmem[r * DpyCols + c]&0xff),FW,FH,c*FW+2,r*FH+2,1);
450: }
451: }
452:
453: if (CursStart <= CursEnd && CursEnd <= FH &&
454: (show != os) && CursRow < (DpyRows+1) &&CursCol < DpyCols) {
455:
456: attr = vmem[CursRow * DpyCols +CursCol] & 0xff00;
457: v.foreground = pixels[(attr >> 8) & 0x0f] ^
458: pixels[(attr >> 12) & 0x07];
459: if (v.foreground) {
460: v.function = GXxor;
461: } else {
462: v.foreground = pixels[7];
463: v.function = GXcopy;
464: }
465: x11.XChangeGC(dpy, cgc, GCForeground | GCFunction, &v);
466: x11.XFillRectangle(dpy, win, cgc,
467: 2 +CursCol * FW,
468: 2 + CursRow * FH + CursStart,
469: FW, CursEnd + 1 - CursStart);
470: }
471:
472: or =CursRow;
473: oc =CursCol;
474: os =show;
475:
476: x11.XFlush(dpy);
477: }
478:
479: void
480: video_update()
481: {
482: static clock_t lastupd=-1;
483: static clock_started=0;
484: clock_t upd;
485:
486: upd=msclock();
487: if(!clock_started) {
488: lastupd=upd;
489: clock_started=1;
490: }
491: if(upd-lastupd>(MSCLOCKS_PER_SEC/2)) {
492: show ^= 1;
493: lastupd=upd;
494: }
495:
496: /* quick and dirty */
497: video_update_text();
498: }
499:
500: /* Get memory for the text line buffer. */
501: void
502: get_lines()
503: {
504: int i;
505:
506: if (lines == NULL) {
507: lines = (TextLine *)malloc(sizeof(TextLine) * (DpyRows+1));
508: if (lines == NULL)
509: err(1, "Could not allocate data structure for text lines\n");
510:
511: for (i = 0; i < (DpyRows+1); ++i) {
512: lines[i].max_length = DpyCols;
513: lines[i].data = (WORD *)malloc(DpyCols * sizeof(WORD));
514: if (lines[i].data == NULL)
515: err(1, "Could not allocate data structure for text lines\n");
516: lines[i].changed = 1;
517: }
518: } else {
519: lines = (TextLine *)realloc(lines, sizeof(TextLine) * (DpyRows+1));
520: if (lines == NULL)
521: err(1, "Could not allocate data structure for text lines\n");
522:
523: for (i = 0; i < (DpyRows+1); ++i) {
524: lines[i].max_length = DpyCols;
525: lines[i].data = (WORD *)realloc(lines[i].data,
526: DpyCols * sizeof(WORD));
527: if (lines[i].data == NULL)
528: err(1, "Could not allocate data structure for text lines\n");
529: lines[i].changed = 1;
530: }
531: }
532: }
533:
534: void
535: KbdWrite(WORD code)
536: {
537: int kf;
538:
539: kf = K_FREE + 2;
540: if (kf == K_BUFENDP)
541: kf = K_BUFSTARTP;
542:
543: if (kf == K_NEXT) {
544: x11.XBell(dpy, 0);
545: return;
546: }
547: K_BUF(K_FREE) = code;
548: K_FREE = kf;
549: }
550:
551: void tty_beep(void)
552: {
553: sem_post(&x11_beep);
554: }
555:
556: static int
557: video_event(XEvent *ev)
558: {
559: switch (ev->type) {
560: case MotionNotify: {
561: XMotionEvent *me = (XMotionEvent *)ev;
562: me->x -= 2;
563: me->y -= 2;
564: me->x/=FW;
565: me->y/=FH;
566: me->x++;
567: me->y++;
568: if(me->x<1)
569: me->x=1;
570: if(me->y<1)
571: me->y=1;
572: if(me->x>DpyCols)
573: me->x=DpyCols;
574: if(me->y>DpyRows+1)
575: me->y=DpyRows+1;
576: ciomouse_gotevent(CIOLIB_MOUSE_MOVE,me->x,me->y);
577: break;
578: }
579: case ButtonRelease: {
580: XButtonEvent *be = (XButtonEvent *)ev;
581: be->x -= 2;
582: be->y -= 2;
583: be->x/=FW;
584: be->y/=FH;
585: be->x++;
586: be->y++;
587: if(be->x<1)
588: be->x=1;
589: if(be->y<1)
590: be->y=1;
591: if(be->x>DpyCols)
592: be->x=DpyCols;
593: if(be->y>DpyRows+1)
594: be->y=DpyRows+1;
595: if (be->button <= 3) {
596: ciomouse_gotevent(CIOLIB_BUTTON_RELEASE(be->button),be->x,be->y);
597: }
598: break;
599: }
600: case ButtonPress: {
601: XButtonEvent *be = (XButtonEvent *)ev;
602: be->x -= 2;
603: be->y -= 2;
604: be->x/=FW;
605: be->y/=FH;
606: be->x++;
607: be->y++;
608: if(be->x<1)
609: be->x=1;
610: if(be->y<1)
611: be->y=1;
612: if(be->x>DpyCols)
613: be->x=DpyCols;
614: if(be->y>DpyRows+1)
615: be->y=DpyRows+1;
616: if (be->button <= 3) {
617: ciomouse_gotevent(CIOLIB_BUTTON_PRESS(be->button),be->x,be->y);
618: }
619: break;
620: }
621: case NoExpose:
622: break;
623: case GraphicsExpose:
624: case Expose: {
625: int r;
626: for (r = 0; r < (DpyRows+1); ++r)
627: lines[r].changed = 1;
628: break;
629: }
630: case KeyRelease: {
631: static char buf[128];
632: KeySym ks;
633:
634: break_code |= 0x80;
635:
636: if (!(ev->xkey.state & ShiftMask)) {
637: K1_STATUS &= ~K1_LSHIFT;
638: K1_STATUS &= ~K1_RSHIFT;
639: }
640: if (!(ev->xkey.state & ControlMask)) {
641: K1_STATUS &= ~K1_CTRL;
642: K2_STATUS &= ~K2_LCTRL;
643: K3_STATUS &= ~K3_RCTRL;
644: }
645: if (!(ev->xkey.state & Mod1Mask)) {
646: K1_STATUS &= ~K1_ALT;
647: K2_STATUS &= ~K2_LALT;
648: K3_STATUS &= ~K3_RALT;
649: }
650: if (!(ev->xkey.state & LockMask)) {
651: K2_STATUS &= ~K2_CLOCK;
652: }
653:
654: x11.XLookupString((XKeyEvent *)ev, buf, sizeof(buf), &ks, 0);
655: switch (ks) {
656: case XK_Shift_L:
657: K1_STATUS &= ~K1_LSHIFT;
658: break;
659: case XK_Shift_R:
660: K1_STATUS &= ~K1_RSHIFT;
661: break;
662: case XK_Control_L:
663: K1_STATUS &= ~K1_CTRL;
664: K2_STATUS &= ~K2_LCTRL;
665: break;
666: case XK_Control_R:
667: K1_STATUS &= ~K1_CTRL;
668: K3_STATUS &= ~K3_RCTRL;
669: break;
670: case XK_Alt_L:
671: K1_STATUS &= ~K1_ALT;
672: K2_STATUS &= ~K2_LALT;
673: break;
674: case XK_Alt_R:
675: K1_STATUS &= ~K1_ALT;
676: K3_STATUS &= ~K3_RALT;
677: break;
678: case XK_Scroll_Lock:
679: K2_STATUS &= ~K2_SLOCK;
680: break;
681: case XK_Num_Lock:
682: K2_STATUS &= ~K2_NLOCK;
683: break;
684: case XK_Caps_Lock:
685: K2_STATUS &= ~K2_CLOCK;
686: break;
687: case XK_Insert:
688: K2_STATUS &= ~K2_INSERT;
689: break;
690: }
691: return(1);
692: }
693: case KeyPress: {
694: static char buf[128];
695: KeySym ks;
696: int n;
697: int nlock = 0;
698: WORD scan = 0xffff;
699:
700: if (!(ev->xkey.state & ShiftMask)) {
701: K1_STATUS &= ~K1_LSHIFT;
702: K1_STATUS &= ~K1_RSHIFT;
703: }
704: if (!(ev->xkey.state & ControlMask)) {
705: K1_STATUS &= ~K1_CTRL;
706: K2_STATUS &= ~K2_LCTRL;
707: K3_STATUS &= ~K3_RCTRL;
708: }
709: if (!(ev->xkey.state & Mod1Mask)) {
710: K1_STATUS &= ~K1_ALT;
711: K2_STATUS &= ~K2_LALT;
712: K3_STATUS &= ~K3_RALT;
713: }
714: if (!(ev->xkey.state & LockMask)) {
715: K2_STATUS &= ~K2_CLOCK;
716: }
717:
718: n = x11.XLookupString((XKeyEvent *)ev, buf, sizeof(buf), &ks, 0);
719:
720: switch (ks) {
721: case XK_Shift_L:
722: K1_STATUS |= K1_LSHIFT;
723: break;
724: case XK_Shift_R:
725: K1_STATUS |= K1_RSHIFT;
726: break;
727: case XK_Control_L:
728: K1_STATUS |= K1_CTRL;
729: K2_STATUS |= K2_LCTRL;
730: break;
731: case XK_Control_R:
732: K1_STATUS |= K1_CTRL;
733: K3_STATUS |= K3_RCTRL;
734: break;
735: case XK_Alt_L:
736: K1_STATUS |= K1_ALT;
737: K2_STATUS |= K2_LALT;
738: break;
739: case XK_Alt_R:
740: K1_STATUS |= K1_ALT;
741: K3_STATUS |= K3_RALT;
742: break;
743: case XK_Scroll_Lock:
744: K1_STATUS ^= K1_SLOCK;
745: K2_STATUS |= K2_SLOCK;
746: break;
747: case XK_Num_Lock:
748: K1_STATUS ^= K1_NLOCK;
749: K2_STATUS |= K2_NLOCK;
750: break;
751: case XK_Caps_Lock:
752: K1_STATUS ^= K1_CLOCK;
753: K2_STATUS |= K2_CLOCK;
754: break;
755: case XK_Insert:
756: case XK_KP_Insert:
757: K1_STATUS ^= K1_INSERT;
758: K2_STATUS |= K2_INSERT;
759: scan = 82;
760: goto docode;
761:
762: case XK_Escape:
763: scan = 1;
764: goto docode;
765:
766: case XK_Tab:
767: case XK_ISO_Left_Tab:
768: scan = 15;
769: goto docode;
770:
771: case XK_Return:
772: case XK_KP_Enter:
773: scan = 28;
774: goto docode;
775:
776: case XK_Print:
777: scan = 55;
778: goto docode;
779:
780: case XK_F1:
781: case XK_F2:
782: case XK_F3:
783: case XK_F4:
784: case XK_F5:
785: case XK_F6:
786: case XK_F7:
787: case XK_F8:
788: case XK_F9:
789: case XK_F10:
790: scan = ks - XK_F1 + 59;
791: goto docode;
792:
793: case XK_KP_7:
794: nlock = 1;
795: case XK_Home:
796: case XK_KP_Home:
797: scan = 71;
798: goto docode;
799: case XK_KP_8:
800: nlock = 1;
801: case XK_Up:
802: case XK_KP_Up:
803: scan = 72;
804: goto docode;
805: case XK_KP_9:
806: nlock = 1;
807: case XK_Prior:
808: case XK_KP_Prior:
809: scan = 73;
810: goto docode;
811: case XK_KP_Subtract:
812: scan = 74;
813: goto docode;
814: case XK_KP_4:
815: nlock = 1;
816: case XK_Left:
817: case XK_KP_Left:
818: scan = 75;
819: goto docode;
820: case XK_KP_5:
821: nlock = 1;
822: case XK_Begin:
823: case XK_KP_Begin:
824: scan = 76;
825: goto docode;
826: case XK_KP_6:
827: nlock = 1;
828: case XK_Right:
829: case XK_KP_Right:
830: scan = 77;
831: goto docode;
832: case XK_KP_Add:
833: scan = 78;
834: goto docode;
835: case XK_KP_1:
836: nlock = 1;
837: case XK_End:
838: case XK_KP_End:
839: scan = 79;
840: goto docode;
841: case XK_KP_2:
842: nlock = 1;
843: case XK_Down:
844: case XK_KP_Down:
845: scan = 80;
846: goto docode;
847: case XK_KP_3:
848: nlock = 1;
849: case XK_Next:
850: case XK_KP_Next:
851: scan = 81;
852: goto docode;
853: case XK_KP_0:
854: nlock = 1;
855: /* case XK_Insert: This is above */
856: scan = 82;
857: goto docode;
858:
859: case XK_KP_Decimal:
860: nlock = 1;
861: scan = 83;
862: goto docode;
863:
864: case XK_Delete:
865: case XK_KP_Delete:
866: scan = flipdelete ? 14 : 83;
867: goto docode;
868:
869: case XK_BackSpace:
870: scan = flipdelete ? 83 : 14;
871: goto docode;
872:
873: case XK_F11:
874: scan = 87;
875: goto docode;
876: case XK_F12:
877: scan = 88;
878: goto docode;
879:
880:
881: case XK_KP_Divide:
882: scan = Ascii2Scan['/'];
883: goto docode;
884:
885: case XK_KP_Multiply:
886: scan = Ascii2Scan['*'];
887: goto docode;
888:
889: default:
890: if (ks < ' ' || ks > '~')
891: break;
892: scan = Ascii2Scan[ks];
893: docode:
894: if (nlock)
895: scan |= 0x100;
896:
897: if ((scan & ~0x100) > 88) {
898: scan = 0xffff;
899: break;
900: }
901:
902: if ((K1_STATUS & K1_SHIFT) || (scan & 0x100)) {
903: scan = ScanCodes[scan & 0xff].shift;
904: } else if (K1_STATUS & K1_CTRL) {
905: scan = ScanCodes[scan & 0xff].ctrl;
906: } else if (K1_STATUS & K1_ALT) {
907: scan = ScanCodes[scan & 0xff].alt;
908: } else
909: scan = ScanCodes[scan & 0xff].base;
910:
911: break;
912: }
913: if (scan != 0xffff) {
914: break_code = scan >> 8;
915: KbdWrite(scan);
916: }
917: return(1);
918: }
919:
920: default:
921: break;
922: }
923: return(0);
924: }
925:
926: void
927: video_async_event(void *crap)
928: {
929: int x;
930: fd_set fdset;
931: XEvent ev;
932: static struct timeval tv;
933:
934: for (;;) {
935: video_update();
936:
937: if(console_new_mode!=NO_NEW_MODE)
938: init_mode(console_new_mode);
939: while(!sem_trywait(&x11_beep))
940: x11.XBell(dpy, 0);
941: if(!sem_trywait(&x11_title))
942: x11.XStoreName(dpy, win, window_title);
943:
944: tv.tv_sec=0;
945: tv.tv_usec=54925;
946: /*
947: * Handle any events just sitting around...
948: */
949: while (QLength(dpy) > 0) {
950: x11.XNextEvent(dpy, &ev);
951: video_event(&ev);
952: }
953:
954: FD_ZERO(&fdset);
955: FD_SET(xfd, &fdset);
956:
957: x = select(xfd+1, &fdset, 0, 0, &tv);
958:
959: switch (x) {
960: case -1:
961: /*
962: * Errno might be wrong, so we just select again.
963: * This could cause a problem is something really
964: * was wrong with select....
965: */
966:
967: perror("select");
968: break;
969: case 0:
970: break;
971: default:
972: if (FD_ISSET(xfd, &fdset)) {
973: do {
974: x11.XNextEvent(dpy, &ev);
975: video_event(&ev);
976: } while (QLength(dpy));
977: }
978: }
979: }
980: }
981:
982: /* Resize the window, using information from 'vga_status[]'. This function is
983: called after a mode change. */
984: void
985: resize_window()
986: {
987: XSizeHints *sh;
988:
989: sh = x11.XAllocSizeHints();
990: if (sh == NULL)
991: err(1, "Could not get XSizeHints structure");
992:
993: sh->base_width = FW * DpyCols + 4;
994: sh->base_height = FH * (DpyRows+1) + 4;
995:
996: sh->min_width = sh->max_width = sh->base_width;
997: sh->min_height = sh->max_height = sh->base_height;
998: sh->flags = USSize | PMinSize | PMaxSize | PSize;
999:
1000: x11.XSetWMNormalHints(dpy, win, sh);
1001: x11.XResizeWindow(dpy, win, sh->base_width, sh->base_height);
1002: x11.XMapWindow(dpy, win);
1003: x11.XFlush(dpy);
1004:
1005: x11.XFree(sh);
1006:
1007: return;
1008: }
1009:
1010: /* No longer uses X fonts - pass NULL to use VGA 8x16 font */
1011: int
1012: load_font(char *filename, int width, int height)
1013: {
1014: XGCValues gcv;
1015: char *font;
1016:
1017: /* I don't actually do this yet! */
1018: if(filename != NULL) {
1019: return(1);
1020: }
1021:
1022: switch(width) {
1023: case 8:
1024: switch(height) {
1025: case 8:
1026: font=vga_font_bitmap8;
1027: break;
1028: case 14:
1029: font=vga_font_bitmap14;
1030: break;
1031: case 16:
1032: font=vga_font_bitmap;
1033: break;
1034: default:
1035: return(1);
1036: }
1037: break;
1038: default:
1039: return(1);
1040: }
1041: FW = width;
1042: FH = height;
1043:
1044: if(pfnt!=0)
1045: x11.XFreePixmap(dpy,pfnt);
1046: pfnt=x11.XCreateBitmapFromData(dpy, win, font, FW, FH*256);
1047:
1048: return(0);
1049: }
1050:
1051: /* Calculate 'pixels[]' from the current DAC table and palette.
1052:
1053: To do: do not use 'pixels[]', use an array of 'XColor's which we can
1054: allocate and free on demand. Install a private colormap if necessary. */
1055: void
1056: update_pixels()
1057: {
1058: int i;
1059: Colormap cm;
1060:
1061: /* We support only 16 colors for now. */
1062: for (i = 0; i < 16; i++) {
1063: XColor color;
1064:
1065: color.red = dac_default16[palette[i]].red << 10;
1066: color.green = dac_default16[palette[i]].green << 10;
1067: color.blue = dac_default16[palette[i]].blue << 10;
1068: if (x11.XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &color)) {
1069: pixels[i] = color.pixel;
1070: } else if (i < 7)
1071: pixels[i] = BlackPixel(dpy, DefaultScreen(dpy));
1072: else
1073: pixels[i] = WhitePixel(dpy, DefaultScreen(dpy));
1074: }
1075: }
1076:
1077: int
1078: init_mode(int mode)
1079: {
1080: struct video_params vmode;
1081: int idx; /* Index into vmode */
1082: int i;
1083:
1084: idx = find_vmode(mode);
1085: if (idx == -1) {
1086: console_new_mode=NO_NEW_MODE;
1087: sem_post(&console_mode_changed);
1088: return(-1);
1089: }
1090: vmode = vparams[idx];
1091:
1092: DpyCols = vmode.cols;
1093: CursStart = vmode.curs_start;
1094: CursEnd = vmode.curs_end;
1095: DpyRows = vmode.rows-1;
1096: InitCS = CursStart;
1097: InitCE = CursEnd;
1098:
1099: vmem = (WORD *)realloc(vmem,vmode.cols*vmode.rows*sizeof(WORD));
1100:
1101: /* Point 'palette[]' to the Attribute Controller space. We will only use
1102: the first 16 slots. */
1103: palette = palettes[vmode.palette];
1104:
1105: /* Load 'pixels[]' from default DAC values. */
1106: update_pixels();
1107:
1108: /* Update font. */
1109: if(load_font(NULL,vmode.charwidth,vmode.charheight)) {
1110: sem_post(&console_mode_changed);
1111: return(-1);
1112: }
1113:
1114: /* Resize window if necessary. */
1115: resize_window();
1116:
1117: get_lines();
1118:
1119: /* Initialize video memory with black background, white foreground */
1120: for (i = 0; i < DpyCols*DpyRows; ++i)
1121: vmem[i] = 0x0700;
1122:
1123: CurrMode=mode;
1124: console_new_mode=NO_NEW_MODE;
1125: sem_post(&console_mode_changed);
1126: return(0);
1127: }
1128:
1129: /* Get a connection to the X server and create the window. */
1130: int
1131: init_window()
1132: {
1133: XGCValues gcv;
1134: int i;
1135:
1136: dpy = x11.XOpenDisplay(NULL);
1137: if (dpy == NULL) {
1138: return(-1);
1139: }
1140: xfd = ConnectionNumber(dpy);
1141:
1142: /* Create window, but defer setting a size and GC. */
1143: win = x11.XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0,
1144: 1, 1, 2, black, black);
1145:
1146: gcv.foreground = white;
1147: gcv.background = black;
1148: gc = x11.XCreateGC(dpy, win, GCForeground | GCBackground, &gcv);
1149:
1150: gcv.foreground = 1;
1151: gcv.background = 0;
1152: gcv.function = GXxor;
1153: cgc = x11.XCreateGC(dpy, win, GCForeground|GCBackground|GCFunction, &gcv);
1154:
1155: x11.XSelectInput(dpy, win, KeyReleaseMask | KeyPressMask |
1156: ExposureMask | ButtonPressMask
1157: | ButtonReleaseMask | PointerMotionMask );
1158:
1159: SAFECOPY(window_title,"SyncConsole");
1160: x11.XStoreName(dpy, win, window_title);
1161:
1162: /* Get the default visual and depth for later use. */
1163: depth = DefaultDepth(dpy, DefaultScreen(dpy));
1164: visual = DefaultVisual(dpy, DefaultScreen(dpy));
1165:
1166: return(0);
1167: }
1168:
1169: int
1170: kbd_init()
1171: {
1172: K_BUFSTARTP = 0x0000; /* Start of keyboard buffer */
1173: K_BUFENDP = 0x20; /* End of keyboard buffer */
1174: K_NEXT = K_FREE = K_BUFSTARTP;
1175:
1176: return(0);
1177: }
1178:
1179: int
1180: console_init()
1181: {
1182: int fd;
1183: int i;
1184: void *dl;
1185:
1186: if((dl=dlopen("libX11.so",RTLD_LAZY))==NULL)
1187: return(-1);
1188: if((x11.XChangeGC=dlsym(dl,"XChangeGC"))==NULL) {
1189: dlclose(dl);
1190: return(-1);
1191: }
1192: if((x11.XCopyPlane=dlsym(dl,"XCopyPlane"))==NULL) {
1193: dlclose(dl);
1194: return(-1);
1195: }
1196: if((x11.XFillRectangle=dlsym(dl,"XFillRectangle"))==NULL) {
1197: dlclose(dl);
1198: return(-1);
1199: }
1200: if((x11.XFlush=dlsym(dl,"XFlush"))==NULL) {
1201: dlclose(dl);
1202: return(-1);
1203: }
1204: if((x11.XBell=dlsym(dl,"XBell"))==NULL) {
1205: dlclose(dl);
1206: return(-1);
1207: }
1208: if((x11.XLookupString=dlsym(dl,"XLookupString"))==NULL) {
1209: dlclose(dl);
1210: return(-1);
1211: }
1212: if((x11.XNextEvent=dlsym(dl,"XNextEvent"))==NULL) {
1213: dlclose(dl);
1214: return(-1);
1215: }
1216: if((x11.XAllocSizeHints=dlsym(dl,"XAllocSizeHints"))==NULL) {
1217: dlclose(dl);
1218: return(-1);
1219: }
1220: if((x11.XSetWMNormalHints=dlsym(dl,"XSetWMNormalHints"))==NULL) {
1221: dlclose(dl);
1222: return(-1);
1223: }
1224: if((x11.XResizeWindow=dlsym(dl,"XResizeWindow"))==NULL) {
1225: dlclose(dl);
1226: return(-1);
1227: }
1228: if((x11.XMapWindow=dlsym(dl,"XMapWindow"))==NULL) {
1229: dlclose(dl);
1230: return(-1);
1231: }
1232: if((x11.XFree=dlsym(dl,"XFree"))==NULL) {
1233: dlclose(dl);
1234: return(-1);
1235: }
1236: if((x11.XFreePixmap=dlsym(dl,"XFreePixmap"))==NULL) {
1237: dlclose(dl);
1238: return(-1);
1239: }
1240: if((x11.XCreateBitmapFromData=dlsym(dl,"XCreateBitmapFromData"))==NULL) {
1241: dlclose(dl);
1242: return(-1);
1243: }
1244: if((x11.XAllocColor=dlsym(dl,"XAllocColor"))==NULL) {
1245: dlclose(dl);
1246: return(-1);
1247: }
1248: if((x11.XOpenDisplay=dlsym(dl,"XOpenDisplay"))==NULL) {
1249: dlclose(dl);
1250: return(-1);
1251: }
1252: if((x11.XCreateSimpleWindow=dlsym(dl,"XCreateSimpleWindow"))==NULL) {
1253: dlclose(dl);
1254: return(-1);
1255: }
1256: if((x11.XCreateGC=dlsym(dl,"XCreateGC"))==NULL) {
1257: dlclose(dl);
1258: return(-1);
1259: }
1260: if((x11.XSelectInput=dlsym(dl,"XSelectInput"))==NULL) {
1261: dlclose(dl);
1262: return(-1);
1263: }
1264: if((x11.XStoreName=dlsym(dl,"XStoreName"))==NULL) {
1265: dlclose(dl);
1266: return(-1);
1267: }
1268:
1269: if(dpy!=NULL)
1270: return(0);
1271:
1272: sem_init(&console_mode_changed,0,0);
1273: sem_init(&x11_beep,0,0);
1274: sem_init(&x11_title,0,0);
1275:
1276: if(kbd_init()) {
1277: return(-1);
1278: }
1279:
1280: if(video_init()) {
1281: return(-1);
1282: }
1283:
1284: _beginthread(video_async_event,1<<16,NULL);
1285: return(0);
1286: }
1287:
1288: int
1289: video_init()
1290: {
1291: /* If we are running under X, get a connection to the X server and create
1292: an empty window of size (1, 1). It makes a couple of init functions a
1293: lot easier. */
1294: if(init_window())
1295: return(-1);
1296:
1297: /* Initialize mode 3 (text, 80x25, 16 colors) */
1298: if(init_mode(3)) {
1299: return(-1);
1300: }
1301: sem_wait(&console_mode_changed);
1302:
1303: return(0);
1304: }
1305:
1306: WORD
1307: KbdPeek()
1308: {
1309: return(K_BUF(K_NEXT));
1310: }
1311:
1312: WORD
1313: KbdRead()
1314: {
1315: int kf = K_NEXT;
1316:
1317: K_NEXT = K_NEXT + 2;
1318: if (K_NEXT == K_BUFENDP)
1319: K_NEXT = K_BUFSTARTP;
1320:
1321: return(K_BUF(kf));
1322: }
1323:
1324: int
1325: KbdEmpty()
1326: {
1327: return(K_NEXT == K_FREE);
1328: }
1329:
1330: int x_nextchar = 0;
1331:
1332: int
1333: tty_read(int flag)
1334: {
1335: int r;
1336:
1337: if ((r = x_nextchar) != 0) {
1338: x_nextchar = 0;
1339: return(r & 0xff);
1340: }
1341:
1342: if (KbdEmpty() && !mouse_pending()) {
1343: if (flag & TTYF_BLOCK) {
1344: while (KbdEmpty() && !mouse_pending())
1345: tty_pause();
1346: } else {
1347: return(-1);
1348: }
1349: }
1350:
1351: if(mouse_pending()) {
1352: x_nextchar=CIO_KEY_MOUSE>>8;
1353: return(CIO_KEY_MOUSE&0xff);
1354: }
1355: else {
1356: r = KbdRead();
1357: if ((r & 0xff) == 0)
1358: x_nextchar = r >> 8;
1359: r &= 0xff;
1360: return(r & 0xff);
1361: }
1362: }
1363:
1364: int
1365: tty_peek(int flag)
1366: {
1367: int c;
1368:
1369: if (c == x_nextchar)
1370: return(x_nextchar & 0xff);
1371:
1372: if (KbdEmpty()) {
1373: if (flag & TTYF_POLL) {
1374: sleep_poll();
1375: if (KbdEmpty())
1376: return(0);
1377: } else if (flag & TTYF_BLOCK) {
1378: while (KbdEmpty())
1379: tty_pause();
1380: } else
1381: return(0);
1382: }
1383: c = KbdPeek();
1384: return(0xff);
1385: }
1386:
1387: int
1388: tty_kbhit(void)
1389: {
1390: if(x_nextchar || !KbdEmpty())
1391: return(1);
1392: return(0);
1393: }
1394:
1395: void x_win_title(const char *title)
1396: {
1397: SAFECOPY(window_title,title);
1398: sem_post(&x11_title);
1399: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.