![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to initial.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libsun|
Return to initial.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libsun |
1.1 root 1: #ifndef lint
2: static char *rcsid = "$Header: initial.c,v 10.6 86/12/17 20:34:22 swick Exp $";
3: #endif lint
4: #ifdef sun
5: /*
6: * The Sun X drivers are a product of Sun Microsystems, Inc. and are provided
7: * for unrestricted use provided that this legend is included on all tape
8: * media and as a part of the software program in whole or part. Users
9: * may copy or modify these drivers without charge, but are not authorized
10: * to license or distribute them to anyone else except as part of a product or
11: * program developed by the user.
12: *
13: * THE SUN X DRIVERS ARE PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND
14: * INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A
15: * PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE
16: * PRACTICE.
17: *
18: * The Sun X Drivers are provided with no support and without any obligation
19: * on the part of Sun Microsystems, Inc. to assist in their use, correction,
20: * modification or enhancement.
21: *
22: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
23: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THE SUN X
24: * DRIVERS OR ANY PART THEREOF.
25: *
26: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
27: * or profits or other special, indirect and consequential damages, even if
28: * Sun has been advised of the possibility of such damages.
29: *
30: * Sun Microsystems, Inc.
31: * 2550 Garcia Avenue
32: * Mountain View, California 94043
33: */
34:
35: #ifndef lint
36: static char sccsid[] = "@(#)initial.c 1.2 86/08/26 Copyright 1986 Sun Micro";
37: #endif
38:
39: /*-
40: * Copyright 1985, Massachusetts Institute of Technology
41: * Copyright (c) 1986 by Sun Microsystems, Inc.
42: */
43:
44: /* initial.c Routines to open & close display
45: *
46: * OpenDisplay Open it
47: * InitDisplay Download it
48: * DisplayDead Check if dead
49: * Allocate_space Allocate some temporary storage
50: *
51: */
52:
53: /*
54: * ToDo:
55: * Look in environment/defaults for programs to start
56: */
57:
58:
59: #include <stdio.h>
60: #include <fcntl.h>
61: #include <errno.h>
62: #include <sys/time.h>
63: #include <sys/ioctl.h>
64: #include <sys/signal.h>
65: #include <sun/fbio.h>
66: #include "Xsun.h"
67: #include <pixrect/pixrect_hs.h>
68: #include <sunwindow/rect.h>
69: #include <sunwindow/rectlist.h>
70: #include <sunwindow/pixwin.h>
71: #include <sunwindow/win_screen.h>
72: #include <sunwindow/win_struct.h>
73: #include <sunwindow/win_input.h>
74: #include <sundev/kbd.h>
75: #include <sundev/kbio.h>
76:
77: extern int InputReader();
78:
79: struct pixwin *Display;
80: struct pixrect *PixRect;
81: u_char InvPix[256];
82:
83: short Sun_From_X_Op[] = {
84: PIX_CLR, /* GXclear */
85: PIX_SRC&PIX_DST, /* GXand */
86: PIX_SRC&PIX_NOT(PIX_DST), /* GXandReverse */
87: PIX_SRC, /* GXcopy */
88: PIX_NOT(PIX_SRC)&PIX_DST, /* GXandInverted */
89: PIX_DST, /* GXnoop */
90: PIX_SRC^PIX_DST, /* GXxor */
91: PIX_SRC|PIX_DST, /* GXor */
92: PIX_NOT(PIX_SRC)&PIX_NOT(PIX_DST), /* GXnor */
93: PIX_NOT(PIX_SRC)^PIX_DST, /* GXequiv */
94: PIX_NOT(PIX_DST), /* GXinvert */
95: PIX_SRC|PIX_NOT(PIX_DST), /* GXorReverse */
96: PIX_NOT(PIX_SRC), /* GXcopyInverted */
97: PIX_NOT(PIX_SRC)|PIX_DST, /* GXorInverted */
98: PIX_NOT(PIX_SRC)|PIX_NOT(PIX_DST), /* GXnand */
99: PIX_SET, /* GXset */
100: };
101:
102: int vsdev = -1;
103: extern int errno;
104: DEVICE *CurrentDevice;
105:
106: #define PARENT "WINDOW_GFX"
107: /* Open the display */
108: static char *parent;
109:
110: #ifdef RAW_KBD
111: struct kiockey sunkeymap[128*5];
112: #endif
113:
114: /*ARGSUSED*/
115: OpenDisplay (devname)
116: char *devname;
117: {
118: struct screen sc;
119: extern char *getenv();
120:
121: signal (SIGWINCH, SIG_IGN);
122: parent = getenv(PARENT);
123: bzero((caddr_t) & sc, sizeof sc);
124: if (*devname != '/')
125: devname = "/dev/fb";
126: strncpy(sc.scr_fbname, devname, SCR_NAMESIZE);
127: if (parent) {
128: /* Running under "overview" */
129: int pfd;
130:
131: if ((pfd = open(parent, 2, 0)) < 0) {
132: fprintf(stderr, "Can't open parent %s\n", parent);
133: return (-1);
134: }
135: vsdev = win_getnewwindow();
136: win_setlink(vsdev, WL_PARENT, win_fdtonumber(pfd));
137: win_insert(vsdev);
138: close(pfd);
139: }
140: else {
141: /* Running alone */
142: vsdev = win_screennew(&sc);
143: }
144: return (vsdev);
145: }
146:
147: /* Do sun specific initialization */
148: #ifdef notdef
149: static int pid;
150: #define XTERM "xterm"
151: static char *args[] = {
152: XTERM,
153: "=80x24+30+30",
154: "-C",
155: "-n",
156: "console",
157: 0,
158: };
159:
160: #include <sys/wait.h>
161:
162: static SigChildHandler()
163: {
164: register int dead;
165: union wait status;
166:
167: while ((dead = wait3(&status, WNOHANG, NULL)) > 0) {
168: if (dead == pid) {
169: exit(0);
170: }
171: }
172: }
173:
174: static StartShell()
175: {
176: signal(SIGCHLD, SigChildHandler);
177: if ((pid = fork()) == 0) {
178: {
179: register int i = getdtablesize();
180:
181: while (--i >= 0) {
182: close(i);
183: }
184: }
185: open("/dev/null", 2, 0);
186: dup(0);
187: dup(0);
188: {
189: /* Copy the environment for Setenv */
190: extern char **environ;
191: register int i = 0;
192: char **envnew;
193:
194: while (environ[i] != NULL)
195: i++;
196:
197: envnew = (char **) malloc(sizeof(char *) * (i + 1));
198: for (; i >= 0; i--)
199: envnew[i] = environ[i];
200: environ = envnew;
201: }
202: {
203: #define HOSTNAMESIZE 128
204: char DisplayName[HOSTNAMESIZE];
205:
206: gethostname(DisplayName, HOSTNAMESIZE);
207: strcat(DisplayName, ":0");
208: Setenv("DISPLAY=", DisplayName);
209: #undef HOSTNAMESIZE
210: }
211: execvp(XTERM, args);
212: _exit(1);
213: }
214: }
215: #endif
216:
217: InitDisplay (info)
218: register DEVICE *info;
219: {
220: register int i;
221: static vsCursor vsc;
222: static vsBox vsm;
223: static vsEventQueue vsq = {
224: NULL,
225: 0,
226: 0,
227: 0,
228: };
229: struct screen sc;
230:
231: win_screenget(vsdev, &sc);
232: info->height = sc.scr_rect.r_height;
233: info->width = sc.scr_rect.r_width;
234: if (parent) {
235: /* running under "overview" */
236: win_setrect(vsdev, &sc.scr_rect);
237: }
238: {
239: struct fbtype fbt;
240: int fd = open(sc.scr_fbname, O_RDWR, 0);
241:
242: if (fd < 0 || ioctl(fd, FBIOGTYPE, &fbt) < 0) {
243: if (fd < 0)
244: fprintf(stderr, "Can't open fb %s\n", sc.scr_fbname);
245: else
246: fprintf(stderr, "Can't FBIOGTYPE on %s\n", sc.scr_fbname);
247: return (-1);
248: }
249: close(fd);
250: info->id = fbt.fb_type + SUN_BASE;
251: info->planes = fbt.fb_depth;
252: info->entries = fbt.fb_cmsize;
253: }
254: Display = pw_open(vsdev);
255: PixRect = Display->pw_pixrect;
256: pw_reversevideo(Display,0,1);
257: {
258: struct inputmask im;
259: struct kiockey kk;
260: int kbfd, i = 0;
261:
262: if ((kbfd = open("/dev/kbd", O_RDWR, 0)) >= 0) {
263: #ifdef RAW_KBD
264: struct kiockey ok;
265:
266: for (i = 0; i < 0200; ++i) {
267: ok.kio_station =
268: kk.kio_station = kk.kio_entry = i;
269:
270: ok.kio_tablemask = kk.kio_tablemask = 0;
271: ioctl(kbfd, KIOCGETKEY, &ok);
272: sunkeymap[i] = ok;
273: /*
274: * If I am a shift key then remap past what
275: * kbd.c knows about so no mapping is done
276: * Only shift keys can be used the with UPMASK
277: * due to assumptions in sun's kernel
278: */
279: if ((ok.kio_entry & 0xf0) == SHIFTKEYS) {
280: switch (ok.kio_entry) {
281: default:
282: case SHIFTKEYS+CAPSLOCK:
283: kk.kio_entry = SHIFTKEYS+10;
284: break;
285: case SHIFTKEYS+SHIFTLOCK:
286: kk.kio_entry = SHIFTKEYS+13;
287: break;
288: case SHIFTKEYS+LEFTSHIFT:
289: kk.kio_entry = SHIFTKEYS+11;
290: break;
291: case SHIFTKEYS+RIGHTSHIFT:
292: kk.kio_entry = SHIFTKEYS+14;
293: break;
294: case SHIFTKEYS+LEFTCTRL:
295: kk.kio_entry = SHIFTKEYS+12;
296: break;
297: case SHIFTKEYS+RIGHTCTRL:
298: kk.kio_entry = SHIFTKEYS+15;
299: break;
300: }
301: } else if (ok.kio_entry == BUCKYBITS+METABIT)
302: kk.kio_entry = SHIFTKEYS+09;
303: else if (ok.kio_entry == BUCKYBITS+SYSTEMBIT)
304: kk.kio_entry = ok.kio_entry;
305: ioctl(kbfd, KIOCSETKEY, &kk);
306:
307: ok.kio_tablemask = kk.kio_tablemask = CTRLMASK;
308: ioctl(kbfd, KIOCGETKEY, &ok);
309: sunkeymap[i+00200] = ok;
310:
311: ok.kio_tablemask = kk.kio_tablemask = CAPSMASK;
312: ioctl(kbfd, KIOCGETKEY, &ok);
313: sunkeymap[i+00400] = ok;
314:
315: ok.kio_tablemask = kk.kio_tablemask = SHIFTMASK;
316: ioctl(kbfd, KIOCGETKEY, &ok);
317: sunkeymap[i+00600] = ok;
318:
319: ok.kio_tablemask = kk.kio_tablemask = UPMASK;
320: ioctl(kbfd, KIOCGETKEY, &ok);
321: sunkeymap[i+01000] = ok;
322: if ((kk.kio_entry & 0xf0) == SHIFTKEYS)
323: ioctl(kbfd, KIOCSETKEY, &kk);
324: }
325: #else
326: kk.kio_tablemask = 0;
327: kk.kio_entry = ~(SHIFTKEYS+CAPSLOCK);
328: do {
329: kk.kio_station = i++;
330: ioctl(kbfd, KIOCGETKEY, &kk);
331: } while ( i < 128 && kk.kio_entry != SHIFTKEYS+CAPSLOCK);
332: if (kk.kio_entry == SHIFTKEYS+CAPSLOCK) {
333: kk.kio_tablemask = UPMASK;
334: ioctl(kbfd, KIOCSETKEY, &kk);
335: kk.kio_tablemask = CTRLMASK;
336: ioctl(kbfd, KIOCSETKEY, &kk);
337: kk.kio_tablemask = CAPSMASK;
338: ioctl(kbfd, KIOCSETKEY, &kk);
339: kk.kio_tablemask = SHIFTMASK;
340: ioctl(kbfd, KIOCSETKEY, &kk);
341: }
342: #endif
343: close(kbfd);
344: }
345: input_imnull(&im);
346: im.im_flags = IM_ASCII | IM_META | IM_NEGEVENT;
347: win_setinputcodebit(&im, LOC_MOVE);
348: win_setinputcodebit(&im, MS_LEFT);
349: win_setinputcodebit(&im, MS_MIDDLE);
350: win_setinputcodebit(&im, MS_RIGHT);
351: #ifdef RAW_KBD
352: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+9);
353: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+10);
354: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+11);
355: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+12);
356: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+13);
357: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+14);
358: win_setinputcodebit(&im, VKEY_FIRSTSHIFT+15);
359: #else
360: win_setinputcodebit(&im, SHIFT_CAPSLOCK);
361: #endif
362: win_setinputmask(vsdev, &im, NULL, WIN_NULLLINK);
363: }
364: if (fcntl(vsdev, F_SETFL, O_NDELAY) < 0)
365: return (-1);
366: {
367: /* Following struct cannot be included from win_cursor.h */
368: struct cursor {
369: short cur_xhot, cur_yhot; /* offset of mouse position from shape*/
370: int cur_function; /* relationship of shape to screen */
371: struct pixrect *cur_shape; /* memory image to use */
372: int flags; /* various options */
373:
374: short horiz_hair_thickness; /* horizontal crosshair height */
375: int horiz_hair_op; /* drawing op */
376: int horiz_hair_color; /* color */
377: short horiz_hair_length; /* width */
378: short horiz_hair_gap; /* gap */
379:
380: short vert_hair_thickness; /* vertical crosshair width */
381: int vert_hair_op; /* drawing op */
382: int vert_hair_color; /* color */
383: short vert_hair_length; /* height */
384: short vert_hair_gap; /* gap */
385: } cs;
386: static struct pixrect pr;
387:
388: cs.cur_xhot = cs.cur_yhot = cs.cur_function = 0;
389: cs.flags = 0;
390: cs.cur_shape = ≺
391: pr.pr_size.x = pr.pr_size.y = 0;
392: win_setcursor(vsdev, &cs);
393: win_setmouseposition(vsdev, info->width >> 1, info->height >> 1);
394: }
395: info->mouse = &vsc;
396: info->mbox = &vsm;
397: info->queue = &vsq;
398: Define_input_handler(InputReader);
399: SetUpInvPix();
400: CurrentDevice = info;
401: #ifdef notdef
402: StartShell();
403: #endif
404: return (0);
405: }
406:
407: /* Check if display is dead */
408:
409: DisplayDead ()
410: {
411: #ifdef RAW_KBD
412: int i;
413: int kbfd = open("/dev/kbd", O_RDWR, 0);
414: for (i = 0; i < 0200; ++i) {
415: ioctl(kbfd, KIOCSETKEY, &sunkeymap[i]);
416: if ((sunkeymap[i].kio_entry & 0xf0) == SHIFTKEYS)
417: ioctl(kbfd, KIOCSETKEY, &sunkeymap[i+01000]);
418: else if (sunkeymap[i].kio_entry == BUCKYBITS+METABIT)
419: ioctl(kbfd, KIOCSETKEY, &sunkeymap[i+01000]);
420: }
421: close(kbfd);
422: #endif
423: return(0);
424: }
425:
426: /* the presumption here is that only one Allocate_space call is made/request */
427:
428: #define ABUFSIZE 3072
429: static char ABuffer[3072]; /* random size buffer for allocate space */
430: caddr_t AllocateSpace (size)
431: register int size;
432: {
433: if (size < ABUFSIZE) return(ABuffer);
434: errno = ENOMEM;
435: return (NULL);
436: }
437:
438: /* XXX - should be static data */
439: SetUpInvPix()
440: {
441: register int i;
442:
443: for (i = 255; i >= 0; i--) {
444: register int j = 1, k = 128, l = 8;
445:
446: while (l--) {
447: if ((i & j) != 0)
448: InvPix[i] |= k;
449: j <<= 1;
450: k >>= 1;
451: }
452: }
453: }
454:
455: #ifdef notdef
456: Setenv (var, value)
457: /*
458: sets the value of var to be arg in the Unix 4.2 BSD environment env.
459: Var should end with '='.
460: (bindings are of the form "var=value")
461: This procedure assumes the memory for the first level of environ
462: was allocated using malloc.
463: */
464: register char *var, *value;
465: {
466: extern char **environ;
467: register int index = 0;
468:
469: while (environ[index] != NULL) {
470: if (strncmp(environ[index], var, strlen(var)) == 0) {
471: /* found it */
472: environ[index] = (char *) malloc(strlen(var) + strlen(value));
473: strcpy(environ[index], var);
474: strcat(environ[index], value);
475: return;
476: }
477: index++;
478: }
479:
480: if ((environ = (char **) realloc(environ, sizeof(char *) *
481: (index + 2))) == NULL) {
482: fprintf(stderr, "Setenv: malloc out of memory\n");
483: exit(1);
484: }
485:
486: environ[index] = (char *) malloc(strlen(var) + strlen(value));
487: strcpy(environ[index], var);
488: strcat(environ[index], value);
489: environ[++index] = NULL;
490: }
491: #endif
492: #endif sun
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.