http://www.jwz.org/xscreensaver/xscreensaver-5.10.tar.gz
[xscreensaver] / hacks / phosphor.c
1 /* xscreensaver, Copyright (c) 1999-2009 Jamie Zawinski <jwz@jwz.org>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or 
9  * implied warranty.
10  *
11  * Phosphor -- simulate a glass tty with long-sustain phosphor.
12  * Written by Jamie Zawinski <jwz@jwz.org>
13  * Pty and vt100 emulation by Fredrik Tolf <fredrik@dolda2000.com>
14  */
15
16 #ifdef HAVE_CONFIG_H
17 # include "config.h"
18 #endif /* HAVE_CONFIG_H */
19
20 #include <stdio.h>
21 #include <signal.h>
22 #include <sys/wait.h>
23
24 #ifndef HAVE_COCOA
25 # define XK_MISCELLANY
26 # include <X11/keysymdef.h>
27 # include <X11/Xatom.h>
28 # include <X11/Intrinsic.h>
29 #endif
30
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 # include <fcntl.h>  /* for O_RDWR */
34 #endif
35
36 #ifdef HAVE_FORKPTY
37 # include <sys/ioctl.h>
38 # ifdef HAVE_PTY_H
39 #  include <pty.h>
40 # endif
41 # ifdef HAVE_UTIL_H
42 #  include <util.h>
43 # endif
44 #endif /* HAVE_FORKPTY */
45
46 #include "screenhack.h"
47
48 #define FUZZY_BORDER
49
50 #define MAX(a,b) ((a)>(b)?(a):(b))
51 #define MIN(a,b) ((a)<(b)?(a):(b))
52
53 #define BLANK  0
54 #define FLARE  1
55 #define NORMAL 2
56 #define FADE   3
57 #define STATE_MAX FADE
58
59 #define CURSOR_INDEX 128
60
61 #define NPAR 16
62
63 #define BUILTIN_FONT
64
65 #ifdef BUILTIN_FONT
66 # include "images/6x10font.xbm"
67 #endif /* BUILTIN_FONT */
68
69 typedef struct {
70   unsigned char name;
71   int width, height;
72   Pixmap pixmap;
73 #ifdef FUZZY_BORDER
74   Pixmap pixmap2;
75 #endif /* FUZZY_BORDER */
76   Bool blank_p;
77 } p_char;
78
79 typedef struct {
80   p_char *p_char;
81   int state;
82   Bool changed;
83 } p_cell;
84
85 typedef struct {
86   Display *dpy;
87   Window window;
88   XWindowAttributes xgwa;
89   XFontStruct *font;
90   int grid_width, grid_height;
91   int char_width, char_height;
92   int saved_x, saved_y;
93   int scale;
94   int ticks;
95   int mode;
96   pid_t pid;
97   int escstate;
98   int csiparam[NPAR];
99   int curparam;
100   p_char **chars;
101   p_cell *cells;
102   XGCValues gcv;
103   GC gc0;
104   GC gc1;
105 #ifdef FUZZY_BORDER
106   GC gc2;
107 #endif /* FUZZY_BORDER */
108   GC *gcs;
109   XImage *font_bits;
110
111   int cursor_x, cursor_y;
112   XtIntervalId cursor_timer;
113   XtIntervalId pipe_timer;
114   Time cursor_blink;
115
116   FILE *pipe;
117   XtInputId pipe_id;
118   Bool input_available_p;
119   Time subproc_relaunch_delay;
120   XComposeStatus compose;
121   Bool meta_sends_esc_p;
122   Bool swap_bs_del_p;
123   int delay;
124
125   char last_c;
126   int bk;
127
128   Bool meta_done_once;
129   unsigned int meta_mask;
130
131 } p_state;
132
133
134 static void capture_font_bits (p_state *state);
135 static p_char *make_character (p_state *state, int c);
136 static void drain_input (p_state *state);
137 static void char_to_pixmap (p_state *state, p_char *pc, int c);
138 static void launch_text_generator (p_state *state);
139
140
141 /* About font metrics:
142
143    "lbearing" is the distance from the leftmost pixel of a character to
144    the logical origin of that character.  That is, it is the number of
145    pixels of the character which are to the left of its logical origin.
146
147    "rbearing" is the distance from the logical origin of a character to
148    the rightmost pixel of a character.  That is, it is the number of
149    pixels of the character to the right of its logical origin.
150
151    "descent" is the distance from the bottommost pixel of a character to
152    the logical baseline.  That is, it is the number of pixels of the
153    character which are below the baseline.
154
155    "ascent" is the distance from the logical baseline to the topmost pixel.
156    That is, it is the number of pixels of the character above the baseline.
157
158    Therefore, the bounding box of the "ink" of a character is
159    lbearing + rbearing by ascent + descent;
160
161    "width" is the distance from the logical origin of this character to
162    the position where the logical orgin of the next character should be
163    placed.
164
165    For our purposes, we're only interested in the part of the character
166    lying inside the "width" box.  If the characters have ink outside of
167    that box (the "charcell" box) then we're going to lose it.  Alas.
168  */
169
170
171 static void clear (p_state *);
172 static void set_cursor (p_state *, Bool on);
173
174 static void *
175 phosphor_init (Display *dpy, Window window)
176 {
177   int i;
178   unsigned long flags;
179   p_state *state = (p_state *) calloc (sizeof(*state), 1);
180   char *fontname = get_string_resource (dpy, "font", "Font");
181   XFontStruct *font;
182
183   state->dpy = dpy;
184   state->window = window;
185
186   XGetWindowAttributes (dpy, window, &state->xgwa);
187 /*  XSelectInput (dpy, window, state->xgwa.your_event_mask | ExposureMask);*/
188
189   state->delay = get_integer_resource (dpy, "delay", "Integer");
190   state->meta_sends_esc_p = get_boolean_resource (dpy, "metaSendsESC", "Boolean");
191   state->swap_bs_del_p    = get_boolean_resource (dpy, "swapBSDEL",    "Boolean");
192
193   if (!strcasecmp (fontname, "builtin") ||
194       !strcasecmp (fontname, "(builtin)"))
195     {
196 #ifndef BUILTIN_FONT
197       fprintf (stderr, "%s: no builtin font\n", progname);
198       state->font = XLoadQueryFont (dpy, "fixed");
199 #endif /* !BUILTIN_FONT */
200     }
201   else
202     {
203       state->font = XLoadQueryFont (dpy, fontname);
204
205       if (!state->font)
206         {
207           fprintf(stderr, "couldn't load font \"%s\"\n", fontname);
208           state->font = XLoadQueryFont (dpy, "fixed");
209         }
210       if (!state->font)
211         {
212           fprintf(stderr, "couldn't load font \"fixed\"");
213           exit(1);
214         }
215     }
216
217   font = state->font;
218   state->scale = get_integer_resource (dpy, "scale", "Integer");
219   state->ticks = STATE_MAX + get_integer_resource (dpy, "ticks", "Integer");
220   state->escstate = 0;
221
222   {
223     char *s = get_string_resource (dpy, "mode", "Integer");
224     state->mode = 0;
225     if (!s || !*s || !strcasecmp (s, "pipe"))
226       state->mode = 0;
227     else if (!strcasecmp (s, "pty"))
228       state->mode = 1;
229     else
230       fprintf (stderr, "%s: mode must be either `pipe' or `pty', not `%s'\n",
231                progname, s);
232
233 #ifndef HAVE_FORKPTY
234     fprintf (stderr, "%s: no pty support on this system; using -pipe mode.\n",
235              progname);
236     state->mode = 0;
237 #endif /* HAVE_FORKPTY */
238   }
239
240 #if 0
241   for (i = 0; i < font->n_properties; i++)
242     if (font->properties[i].name == XA_FONT)
243       printf ("font: %s\n", XGetAtomName(dpy, font->properties[i].card32));
244 #endif /* 0 */
245
246   state->cursor_blink = get_integer_resource (dpy, "cursor", "Time");
247   state->subproc_relaunch_delay =
248     (1000 * get_integer_resource (dpy, "relaunch", "Time"));
249
250 # ifdef BUILTIN_FONT
251   if (! font)
252     {
253       state->char_width  = (font6x10_width / 256) - 1;
254       state->char_height = font6x10_height;
255     }
256   else
257 # endif /* BUILTIN_FONT */
258     {
259       state->char_width  = font->max_bounds.width;
260       state->char_height = font->max_bounds.ascent + font->max_bounds.descent;
261     }
262
263   state->grid_width = state->xgwa.width / (state->char_width * state->scale);
264   state->grid_height = state->xgwa.height /(state->char_height * state->scale);
265   state->cells = (p_cell *) calloc (sizeof(p_cell),
266                                     state->grid_width * state->grid_height);
267   state->chars = (p_char **) calloc (sizeof(p_char *), 256);
268
269   state->gcs = (GC *) calloc (sizeof(GC), state->ticks + 1);
270
271   {
272     int ncolors = MAX (0, state->ticks - 3);
273     XColor *colors = (XColor *) calloc (ncolors, sizeof(XColor));
274     int h1, h2;
275     double s1, s2, v1, v2;
276
277     unsigned long fg = get_pixel_resource (state->dpy, state->xgwa.colormap,
278                                            "foreground", "Foreground");
279     unsigned long bg = get_pixel_resource (state->dpy, state->xgwa.colormap,
280                                            "background", "Background");
281     unsigned long flare = get_pixel_resource (state->dpy,state->xgwa.colormap,
282                                               "flareForeground", "Foreground");
283     unsigned long fade = get_pixel_resource (state->dpy,state->xgwa.colormap,
284                                              "fadeForeground", "Foreground");
285
286     XColor start, end;
287
288     start.pixel = fade;
289     XQueryColor (state->dpy, state->xgwa.colormap, &start);
290
291     end.pixel = bg;
292     XQueryColor (state->dpy, state->xgwa.colormap, &end);
293
294     /* Now allocate a ramp of colors from the main color to the background. */
295     rgb_to_hsv (start.red, start.green, start.blue, &h1, &s1, &v1);
296     rgb_to_hsv (end.red, end.green, end.blue, &h2, &s2, &v2);
297     make_color_ramp (state->dpy, state->xgwa.colormap,
298                      h1, s1, v1,
299                      h2, s2, v2,
300                      colors, &ncolors,
301                      False, True, False);
302
303     /* Adjust to the number of colors we actually got. */
304     state->ticks = ncolors + STATE_MAX;
305
306     /* Now, GCs all around.
307      */
308     state->gcv.font = (font ? font->fid : 0);
309     state->gcv.cap_style = CapRound;
310 #ifdef FUZZY_BORDER
311     state->gcv.line_width = (int) (((long) state->scale) * 1.3);
312     if (state->gcv.line_width == state->scale)
313       state->gcv.line_width++;
314 #else /* !FUZZY_BORDER */
315     state->gcv.line_width = (int) (((long) state->scale) * 0.9);
316     if (state->gcv.line_width >= state->scale)
317       state->gcv.line_width = state->scale - 1;
318     if (state->gcv.line_width < 1)
319       state->gcv.line_width = 1;
320 #endif /* !FUZZY_BORDER */
321
322     flags = (GCForeground | GCBackground | GCCapStyle | GCLineWidth);
323
324     state->gcv.background = bg;
325     state->gcv.foreground = bg;
326     state->gcs[BLANK] = XCreateGC (state->dpy, state->window, flags,
327                                    &state->gcv);
328
329     state->gcv.foreground = flare;
330     state->gcs[FLARE] = XCreateGC (state->dpy, state->window, flags,
331                                    &state->gcv);
332
333     state->gcv.foreground = fg;
334     state->gcs[NORMAL] = XCreateGC (state->dpy, state->window, flags,
335                                     &state->gcv);
336
337     for (i = 0; i < ncolors; i++)
338       {
339         state->gcv.foreground = colors[i].pixel;
340         state->gcs[STATE_MAX + i] = XCreateGC (state->dpy, state->window,
341                                                flags, &state->gcv);
342       }
343   }
344
345   capture_font_bits (state);
346
347   set_cursor (state, True);
348
349   launch_text_generator (state);
350 /*  clear (state);*/
351
352   return state;
353 }
354
355
356 /* Re-query the window size and update the internal character grid if changed.
357  */
358 static void
359 resize_grid (p_state *state)
360 {
361   int ow = state->grid_width;
362   int oh = state->grid_height;
363   p_cell *ocells = state->cells;
364   int x, y;
365
366   XGetWindowAttributes (state->dpy, state->window, &state->xgwa);
367
368   state->grid_width = state->xgwa.width   /(state->char_width  * state->scale);
369   state->grid_height = state->xgwa.height /(state->char_height * state->scale);
370
371   if (ow == state->grid_width &&
372       oh == state->grid_height)
373     return;
374
375   state->cells = (p_cell *) calloc (sizeof(p_cell),
376                                     state->grid_width * state->grid_height);
377
378   for (y = 0; y < state->grid_height; y++)
379     {
380       for (x = 0; x < state->grid_width; x++)
381         {
382           p_cell *ncell = &state->cells [state->grid_width * y + x];
383           if (x < ow && y < oh)
384             *ncell = ocells [ow * y + x];
385           ncell->changed = True;
386         }
387     }
388
389   if (state->cursor_x >= state->grid_width)
390     state->cursor_x = state->grid_width-1;
391   if (state->cursor_y >= state->grid_height)
392     state->cursor_y = state->grid_height-1;
393
394   free (ocells);
395 }
396
397
398 static void
399 capture_font_bits (p_state *state)
400 {
401   XFontStruct *font = state->font;
402   int safe_width, height;
403   unsigned char string[257];
404   int i;
405   Pixmap p;
406
407 # ifdef BUILTIN_FONT
408   Pixmap p2 = 0;
409
410   if (!font)
411     {
412       safe_width = state->char_width + 1;
413       height = state->char_height;
414       p2 = XCreatePixmapFromBitmapData (state->dpy, state->window,
415                                         (char *) font6x10_bits,
416                                         font6x10_width,
417                                         font6x10_height,
418                                         1, 0, 1);
419     }
420   else
421 # endif /* BUILTIN_FONT */
422     {
423       safe_width = font->max_bounds.rbearing - font->min_bounds.lbearing;
424       height = state->char_height;
425     }
426
427   p = XCreatePixmap (state->dpy, state->window,
428                      (safe_width * 256), height, 1);
429
430   for (i = 0; i < 256; i++)
431     string[i] = (unsigned char) i;
432   string[256] = 0;
433
434   state->gcv.foreground = 0;
435   state->gcv.background = 0;
436   state->gc0 = XCreateGC (state->dpy, p,
437                           (GCForeground | GCBackground),
438                           &state->gcv);
439
440   state->gcv.foreground = 1;
441   state->gc1 = XCreateGC (state->dpy, p,
442                           ((font ? GCFont : 0) |
443                            GCForeground | GCBackground |
444                            GCCapStyle | GCLineWidth),
445                           &state->gcv);
446
447 #ifdef HAVE_COCOA
448   jwxyz_XSetAntiAliasing (state->dpy, state->gc0, False);
449   jwxyz_XSetAntiAliasing (state->dpy, state->gc1, False);
450 #endif
451
452 #ifdef FUZZY_BORDER
453   {
454     state->gcv.line_width = (int) (((long) state->scale) * 0.8);
455     if (state->gcv.line_width >= state->scale)
456       state->gcv.line_width = state->scale - 1;
457     if (state->gcv.line_width < 1)
458       state->gcv.line_width = 1;
459     state->gc2 = XCreateGC (state->dpy, p,
460                             ((font ? GCFont : 0) |
461                              GCForeground | GCBackground |
462                              GCCapStyle | GCLineWidth),
463                             &state->gcv);
464   }
465 #endif /* FUZZY_BORDER */
466
467   XFillRectangle (state->dpy, p, state->gc0, 0, 0, (safe_width * 256), height);
468
469 # ifdef BUILTIN_FONT
470   if (p2)
471     {
472       XCopyPlane (state->dpy, p2, p, state->gc1,
473                   0, 0, font6x10_width, font6x10_height, 
474                   0, 0, 1);
475       XFreePixmap (state->dpy, p2);
476     }
477   else
478 # endif /* BUILTIN_FONT */
479     {
480       for (i = 0; i < 256; i++)
481         {
482           if (string[i] < font->min_char_or_byte2 ||
483               string[i] > font->max_char_or_byte2)
484             continue;
485           XDrawString (state->dpy, p, state->gc1,
486                        i * safe_width, font->ascent,
487                        (char *) (string + i), 1);
488         }
489     }
490
491   /* Draw the cursor. */
492   XFillRectangle (state->dpy, p, state->gc1,
493                   (CURSOR_INDEX * safe_width), 1,
494                   (font
495                    ? (font->per_char
496                       ? font->per_char['n'-font->min_char_or_byte2].width
497                       : font->max_bounds.width)
498                    : state->char_width),
499                   (font
500                    ? font->ascent - 1
501                    : state->char_height));
502
503   state->font_bits = XGetImage (state->dpy, p, 0, 0,
504                                 (safe_width * 256), height, ~0L, XYPixmap);
505   XFreePixmap (state->dpy, p);
506
507   for (i = 0; i < 256; i++)
508     state->chars[i] = make_character (state, i);
509   state->chars[CURSOR_INDEX] = make_character (state, CURSOR_INDEX);
510 }
511
512
513 static p_char *
514 make_character (p_state *state, int c)
515 {
516   p_char *pc = (p_char *) malloc (sizeof (*pc));
517   pc->name = (unsigned char) c;
518   pc->width =  state->scale * state->char_width;
519   pc->height = state->scale * state->char_height;
520   char_to_pixmap (state, pc, c);
521   return pc;
522 }
523
524
525 static void
526 char_to_pixmap (p_state *state, p_char *pc, int c)
527 {
528   Pixmap p = 0;
529   GC gc;
530 #ifdef FUZZY_BORDER
531   Pixmap p2 = 0;
532   GC gc2;
533 #endif /* FUZZY_BORDER */
534   int from, to;
535   int x1, y;
536
537   XFontStruct *font = state->font;
538   int safe_width = (font 
539                     ? font->max_bounds.rbearing - font->min_bounds.lbearing
540                     : state->char_width + 1);
541
542   int width  = state->scale * state->char_width;
543   int height = state->scale * state->char_height;
544
545   if (font && (c < font->min_char_or_byte2 ||
546                c > font->max_char_or_byte2))
547     goto DONE;
548
549   gc = state->gc1;
550   p = XCreatePixmap (state->dpy, state->window, width, height, 1);
551   XFillRectangle (state->dpy, p, state->gc0, 0, 0, width, height);
552 #ifdef FUZZY_BORDER
553   gc2 = state->gc2;
554   p2 = XCreatePixmap (state->dpy, state->window, width, height, 1);
555   XFillRectangle (state->dpy, p2, state->gc0, 0, 0, width, height);
556 #endif /* FUZZY_BORDER */
557
558   from = safe_width * c;
559   to =   safe_width * (c + 1);
560
561 #if 0
562   if (c > 75 && c < 150)
563     {
564       printf ("\n=========== %d (%c)\n", c, c);
565       for (y = 0; y < state->char_height; y++)
566         {
567           for (x1 = from; x1 < to; x1++)
568             printf (XGetPixel (state->font_bits, x1, y) ? "* " : ". ");
569           printf ("\n");
570         }
571     }
572 #endif
573
574   pc->blank_p = True;
575   for (y = 0; y < state->char_height; y++)
576     for (x1 = from; x1 < to; x1++)
577       if (XGetPixel (state->font_bits, x1, y))
578         {
579           int xoff = state->scale / 2;
580           int x2;
581           for (x2 = x1; x2 < to; x2++)
582             if (!XGetPixel (state->font_bits, x2, y))
583               break;
584           x2--;
585           XDrawLine (state->dpy, p, gc,
586                      (x1 - from) * state->scale + xoff, y * state->scale,
587                      (x2 - from) * state->scale + xoff, y * state->scale);
588 #ifdef FUZZY_BORDER
589           XDrawLine (state->dpy, p2, gc2,
590                      (x1 - from) * state->scale + xoff, y * state->scale,
591                      (x2 - from) * state->scale + xoff, y * state->scale);
592 #endif /* FUZZY_BORDER */
593           x1 = x2;
594           pc->blank_p = False;
595         }
596
597   /*  if (pc->blank_p && c == CURSOR_INDEX)
598     abort();*/
599
600  DONE:
601   pc->pixmap = p;
602 #ifdef FUZZY_BORDER
603   pc->pixmap2 = p2;
604 #endif /* FUZZY_BORDER */
605 }
606
607 \f
608 /* Managing the display. 
609  */
610
611 static void cursor_on_timer (XtPointer closure, XtIntervalId *id);
612 static void cursor_off_timer (XtPointer closure, XtIntervalId *id);
613
614 static Bool
615 set_cursor_1 (p_state *state, Bool on)
616 {
617   p_cell *cell = &state->cells[state->grid_width * state->cursor_y
618                               + state->cursor_x];
619   p_char *cursor = state->chars[CURSOR_INDEX];
620   int new_state = (on ? NORMAL : FADE);
621
622   if (cell->p_char != cursor)
623     cell->changed = True;
624
625   if (cell->state != new_state)
626     cell->changed = True;
627
628   cell->p_char = cursor;
629   cell->state = new_state;
630   return cell->changed;
631 }
632
633 static void
634 set_cursor (p_state *state, Bool on)
635 {
636   if (set_cursor_1 (state, on))
637     {
638       if (state->cursor_timer)
639         XtRemoveTimeOut (state->cursor_timer);
640       state->cursor_timer = 0;
641       cursor_on_timer (state, 0);
642     }
643 }
644
645
646
647
648 static void
649 cursor_off_timer (XtPointer closure, XtIntervalId *id)
650 {
651   p_state *state = (p_state *) closure;
652   XtAppContext app = XtDisplayToApplicationContext (state->dpy);
653   set_cursor_1 (state, False);
654   state->cursor_timer = XtAppAddTimeOut (app, state->cursor_blink,
655                                          cursor_on_timer, closure);
656 }
657
658 static void
659 cursor_on_timer (XtPointer closure, XtIntervalId *id)
660 {
661   p_state *state = (p_state *) closure;
662   XtAppContext app = XtDisplayToApplicationContext (state->dpy);
663   set_cursor_1 (state, True);
664   state->cursor_timer = XtAppAddTimeOut (app, 2 * state->cursor_blink,
665                                          cursor_off_timer, closure);
666 }
667
668
669 static void
670 clear (p_state *state)
671 {
672   int x, y;
673   state->cursor_x = 0;
674   state->cursor_y = 0;
675   for (y = 0; y < state->grid_height; y++)
676     for (x = 0; x < state->grid_width; x++)
677       {
678         p_cell *cell = &state->cells[state->grid_width * y + x];
679         if (cell->state == FLARE || cell->state == NORMAL)
680           {
681             cell->state = FADE;
682             cell->changed = True;
683           }
684       }
685   set_cursor (state, True);
686 }
687
688
689 static void
690 decay (p_state *state)
691 {
692   int x, y;
693   for (y = 0; y < state->grid_height; y++)
694     for (x = 0; x < state->grid_width; x++)
695       {
696         p_cell *cell = &state->cells[state->grid_width * y + x];
697         if (cell->state == FLARE)
698           {
699             cell->state = NORMAL;
700             cell->changed = True;
701           }
702         else if (cell->state >= FADE)
703           {
704             cell->state++;
705             if (cell->state >= state->ticks)
706               cell->state = BLANK;
707             cell->changed = True;
708           }
709       }
710 }
711
712
713 static void
714 scroll (p_state *state)
715 {
716   int x, y;
717
718   for (x = 0; x < state->grid_width; x++)
719     {
720       p_cell *from = 0, *to = 0;
721       for (y = 1; y < state->grid_height; y++)
722         {
723           from = &state->cells[state->grid_width * y     + x];
724           to   = &state->cells[state->grid_width * (y-1) + x];
725
726           if ((from->state == FLARE || from->state == NORMAL) &&
727               !from->p_char->blank_p)
728             {
729               *to = *from;
730               to->state = NORMAL;  /* should be FLARE?  Looks bad... */
731             }
732           else
733             {
734               if (to->state == FLARE || to->state == NORMAL)
735                 to->state = FADE;
736             }
737
738           to->changed = True;
739         }
740
741       to = from;
742       if (to && (to->state == FLARE || to->state == NORMAL))
743         {
744           to->state = FADE;
745           to->changed = True;
746         }
747     }
748   set_cursor (state, True);
749 }
750
751
752 static void
753 print_char (p_state *state, int c)
754 {
755   p_cell *cell = &state->cells[state->grid_width * state->cursor_y
756                                + state->cursor_x];
757   int i, start, end;
758
759   /* Start the cursor fading (in case we don't end up overwriting it.) */
760   if (cell->state == FLARE || cell->state == NORMAL)
761     {
762       cell->state = FADE;
763       cell->changed = True;
764     }
765   
766   if (state->pid)  /* Only interpret VT100 sequences if running in pty-mode.
767                       It would be nice if we could just interpret them all
768                       the time, but that would require subprocesses to send
769                       CRLF line endings instead of bare LF, so that's no good.
770                     */
771     {
772       switch (state->escstate)
773         {
774         case 0:
775           switch (c)
776             {
777             case 7: /* BEL */
778               /* Dummy case - we don't want the screensaver to beep */
779               /* #### But maybe this should flash the screen? */
780               break;
781             case 8: /* BS */
782               if (state->cursor_x > 0)
783                 state->cursor_x--;
784               break;
785             case 9: /* HT */
786               if (state->cursor_x < state->grid_width - 8)
787                 {
788                   state->cursor_x = (state->cursor_x & ~7) + 8;
789                 }
790               else
791                 {
792                   state->cursor_x = 0;
793                   if (state->cursor_y < state->grid_height - 1)
794                     state->cursor_y++;
795                   else
796                     scroll (state);
797                 }
798               break;
799             case 10: /* LF */
800             case 11: /* VT */
801             case 12: /* FF */
802               if(state->last_c == 13)
803                 {
804                   cell->state = NORMAL;
805                   cell->p_char = state->chars[state->bk];
806                   cell->changed = True;
807                 }
808               if (state->cursor_y < state->grid_height - 1)
809                 state->cursor_y++;
810               else
811                 scroll (state);
812               break;
813             case 13: /* CR */
814               state->cursor_x = 0;
815               cell = &state->cells[state->grid_width * state->cursor_y];
816               if((cell->p_char == NULL) || (cell->p_char->name == CURSOR_INDEX))
817                 state->bk = ' ';
818               else
819                 state->bk = cell->p_char->name;
820               break;
821             case 14: /* SO */
822             case 15: /* SI */
823               /* Dummy case - I don't want to load several fonts for
824                  the maybe two programs world-wide that use that */
825               break;
826             case 24: /* CAN */
827             case 26: /* SUB */
828               /* Dummy case - these interrupt escape sequences, so
829                  they don't do anything in this state */
830               break;
831             case 27: /* ESC */
832               state->escstate = 1;
833               break;
834             case 127: /* DEL */
835               /* Dummy case - this is supposed to be ignored */
836               break;
837             case 155: /* CSI */
838               state->escstate = 2;
839               for(i = 0; i < NPAR; i++)
840                 state->csiparam[i] = 0;
841               state->curparam = 0;
842               break;
843             default:
844               cell->state = FLARE;
845               cell->p_char = state->chars[c];
846               cell->changed = True;
847               state->cursor_x++;
848
849               if (c != ' ' && cell->p_char->blank_p)
850                 cell->p_char = state->chars[CURSOR_INDEX];
851
852               if (state->cursor_x >= state->grid_width - 1)
853                 {
854                   state->cursor_x = 0;
855                   if (state->cursor_y >= state->grid_height - 1)
856                     scroll (state);
857                   else
858                     state->cursor_y++;
859                 }
860               break;
861             }
862           break;
863         case 1:
864           switch (c)
865             {
866             case 24: /* CAN */
867             case 26: /* SUB */
868               state->escstate = 0;
869               break;
870             case 'c': /* Reset */
871               clear (state);
872               state->escstate = 0;
873               break;
874             case 'D': /* Linefeed */
875               if (state->cursor_y < state->grid_height - 1)
876                 state->cursor_y++;
877               else
878                 scroll (state);
879               state->escstate = 0;
880               break;
881             case 'E': /* Newline */
882               state->cursor_x = 0;
883               state->escstate = 0;
884               break;
885             case 'M': /* Reverse newline */
886               if (state->cursor_y > 0)
887                 state->cursor_y--;
888               state->escstate = 0;
889               break;
890             case '7': /* Save state */
891               state->saved_x = state->cursor_x;
892               state->saved_y = state->cursor_y;
893               state->escstate = 0;
894               break;
895             case '8': /* Restore state */
896               state->cursor_x = state->saved_x;
897               state->cursor_y = state->saved_y;
898               state->escstate = 0;
899               break;
900             case '[': /* CSI */
901               state->escstate = 2;
902               for(i = 0; i < NPAR; i++)
903                 state->csiparam[i] = 0;
904               state->curparam = 0;
905               break;
906             case '%': /* Select charset */
907               /* No, I don't support UTF-8, since the phosphor font
908                  isn't even Unicode anyway. We must still catch the
909                  last byte, though. */
910             case '(':
911             case ')':
912               /* I don't support different fonts either - see above
913                  for SO and SI */
914               state->escstate = 3;
915               break;
916             default:
917               /* Escape sequences not supported:
918                * 
919                * H - Set tab stop
920                * Z - Terminal identification
921                * > - Keypad change
922                * = - Other keypad change
923                * ] - OS command
924                */
925               state->escstate = 0;
926               break;
927             }
928           break;
929         case 2:
930           switch (c)
931             {
932             case 24: /* CAN */
933             case 26: /* SUB */
934               state->escstate = 0;
935               break;
936             case '0': case '1': case '2': case '3': case '4':
937             case '5': case '6': case '7': case '8': case '9':
938               if (state->curparam < NPAR)
939                 state->csiparam[state->curparam] = (state->csiparam[state->curparam] * 10) + (c - '0');
940               break;
941             case ';':
942               state->csiparam[++state->curparam] = 0;
943               break;
944             case '[':
945               state->escstate = 3;
946               break;
947             case '@':
948               for (i = 0; i < state->csiparam[0]; i++)
949                 {
950                   if(++state->cursor_x > state->grid_width)
951                     {
952                       state->cursor_x = 0;
953                       if (state->cursor_y < state->grid_height - 1)
954                         state->cursor_y++;
955                       else
956                         scroll (state);
957                     }
958                   cell = &state->cells[state->grid_width * state->cursor_y + state->cursor_x];
959                   if (cell->state == FLARE || cell->state == NORMAL)
960                     {
961                       cell->state = FADE;
962                       cell->changed = True;
963                     }
964                 }
965               state->escstate = 0;
966               break;
967             case 'F':
968               state->cursor_x = 0;
969             case 'A':
970               if (state->csiparam[0] == 0)
971                 state->csiparam[0] = 1;
972               if ((state->cursor_y -= state->csiparam[0]) < 0)
973                 state->cursor_y = 0;
974               state->escstate = 0;
975               break;
976             case 'E':
977               state->cursor_x = 0;
978             case 'e':
979             case 'B':
980               if (state->csiparam[0] == 0)
981                 state->csiparam[0] = 1;
982               if ((state->cursor_y += state->csiparam[0]) >= state->grid_height - 1)
983                 state->cursor_y = state->grid_height - 1;
984               state->escstate = 0;
985               break;
986             case 'a':
987             case 'C':
988               if (state->csiparam[0] == 0)
989                 state->csiparam[0] = 1;
990               if ((state->cursor_x += state->csiparam[0]) >= state->grid_width - 1)
991                 state->cursor_x = state->grid_width - 1;
992               state->escstate = 0;
993               break;
994             case 'D':
995               if (state->csiparam[0] == 0)
996                 state->csiparam[0] = 1;
997               if ((state->cursor_x -= state->csiparam[0]) < 0)
998                 state->cursor_x = 0;
999               state->escstate = 0;
1000               break;
1001             case 'd':
1002               if ((state->cursor_y = (state->csiparam[0] - 1)) >= state->grid_height - 1)
1003                 state->cursor_y = state->grid_height - 1;
1004               state->escstate = 0;
1005               break;
1006             case '`':
1007             case 'G':
1008               if ((state->cursor_x = (state->csiparam[0] - 1)) >= state->grid_width - 1)
1009                 state->cursor_x = state->grid_width - 1;
1010               state->escstate = 0;
1011               break;
1012             case 'f':
1013             case 'H':
1014               if ((state->cursor_y = (state->csiparam[0] - 1)) >= state->grid_height - 1)
1015                 state->cursor_y = state->grid_height - 1;
1016               if ((state->cursor_x = (state->csiparam[1] - 1)) >= state->grid_width - 1)
1017                 state->cursor_x = state->grid_width - 1;
1018               if(state->cursor_y < 0)
1019                 state->cursor_y = 0;
1020               if(state->cursor_x < 0)
1021                 state->cursor_x = 0;
1022               state->escstate = 0;
1023               break;
1024             case 'J':
1025               start = 0;
1026               end = state->grid_height * state->grid_width;
1027               if (state->csiparam[0] == 0)
1028                 start = state->grid_width * state->cursor_y + state->cursor_x;
1029               if (state->csiparam[0] == 1)
1030                 end = state->grid_width * state->cursor_y + state->cursor_x;
1031               for (i = start; i < end; i++)
1032                 {
1033                   cell = &state->cells[i];
1034                   if (cell->state == FLARE || cell->state == NORMAL)
1035                     {
1036                       cell->state = FADE;
1037                       cell->changed = True;
1038                     }
1039                 }
1040               set_cursor (state, True);
1041               state->escstate = 0;
1042               break;
1043             case 'K':
1044               start = 0;
1045               end = state->grid_width;
1046               if (state->csiparam[0] == 0)
1047                 start = state->cursor_x;
1048               if (state->csiparam[1] == 1)
1049                 end = state->cursor_x;
1050               for (i = start; i < end; i++)
1051                 {
1052                   if (cell->state == FLARE || cell->state == NORMAL)
1053                     {
1054                       cell->state = FADE;
1055                       cell->changed = True;
1056                     }
1057                   cell++;
1058                 }
1059               state->escstate = 0;
1060               break;
1061             case 's': /* Save position */
1062               state->saved_x = state->cursor_x;
1063               state->saved_y = state->cursor_y;
1064               state->escstate = 0;
1065               break;
1066             case 'u': /* Restore position */
1067               state->cursor_x = state->saved_x;
1068               state->cursor_y = state->saved_y;
1069               state->escstate = 0;
1070               break;
1071             case '?': /* DEC Private modes */
1072               if ((state->curparam != 0) || (state->csiparam[0] != 0))
1073                 state->escstate = 0;
1074               break;
1075             default:
1076               /* Known unsupported CSIs:
1077                *
1078                * L - Insert blank lines
1079                * M - Delete lines (I don't know what this means...)
1080                * P - Delete characters
1081                * X - Erase characters (difference with P being...?)
1082                * c - Terminal identification
1083                * g - Clear tab stop(s)
1084                * h - Set mode (Mainly due to its complexity and lack of good
1085                      docs)
1086                * l - Clear mode
1087                * m - Set mode (Phosphor is, per defenition, green on black)
1088                * n - Status report
1089                * q - Set keyboard LEDs
1090                * r - Set scrolling region (too exhausting - noone uses this,
1091                      right?)
1092                */
1093               state->escstate = 0;
1094               break;
1095             }
1096           break;
1097         case 3:
1098           state->escstate = 0;
1099           break;
1100         }
1101       set_cursor (state, True);
1102     }
1103   else
1104     {
1105       if (c == '\t') c = ' ';   /* blah. */
1106
1107       if (c == '\r' || c == '\n')  /* handle CR, LF, or CRLF as "new line". */
1108         {
1109           if (c == '\n' && state->last_c == '\r')
1110             ;   /* CRLF -- do nothing */
1111           else
1112             {
1113               state->cursor_x = 0;
1114               if (state->cursor_y == state->grid_height - 1)
1115                 scroll (state);
1116               else
1117                 state->cursor_y++;
1118             }
1119         }
1120       else if (c == '\014')
1121         {
1122           clear (state);
1123         }
1124       else
1125         {
1126           cell->state = FLARE;
1127           cell->p_char = state->chars[c];
1128           cell->changed = True;
1129           state->cursor_x++;
1130
1131           if (c != ' ' && cell->p_char->blank_p)
1132             cell->p_char = state->chars[CURSOR_INDEX];
1133
1134           if (state->cursor_x >= state->grid_width - 1)
1135             {
1136               state->cursor_x = 0;
1137               if (state->cursor_y >= state->grid_height - 1)
1138                 scroll (state);
1139               else
1140                 state->cursor_y++;
1141             }
1142         }
1143       set_cursor (state, True);
1144     }
1145
1146   state->last_c = c;
1147 }
1148
1149
1150 static void
1151 update_display (p_state *state, Bool changed_only)
1152 {
1153   int x, y;
1154
1155   for (y = 0; y < state->grid_height; y++)
1156     for (x = 0; x < state->grid_width; x++)
1157       {
1158         p_cell *cell = &state->cells[state->grid_width * y + x];
1159         int width, height, tx, ty;
1160
1161         if (changed_only && !cell->changed)
1162           continue;
1163
1164         width = state->char_width * state->scale;
1165         height = state->char_height * state->scale;
1166         tx = x * width;
1167         ty = y * height;
1168
1169         if (cell->state == BLANK || cell->p_char->blank_p)
1170           {
1171             XFillRectangle (state->dpy, state->window, state->gcs[BLANK],
1172                             tx, ty, width, height);
1173           }
1174         else
1175           {
1176 #ifdef FUZZY_BORDER
1177             GC gc1 = state->gcs[cell->state];
1178             GC gc2 = ((cell->state + 2) < state->ticks
1179                       ? state->gcs[cell->state + 2]
1180                       : 0);
1181             GC gc3 = (gc2 ? gc2 : gc1);
1182             if (gc3)
1183               XCopyPlane (state->dpy, cell->p_char->pixmap, state->window, gc3,
1184                           0, 0, width, height, tx, ty, 1L);
1185             if (gc2)
1186               {
1187                 XSetClipMask (state->dpy, gc1, cell->p_char->pixmap2);
1188                 XSetClipOrigin (state->dpy, gc1, tx, ty);
1189                 XFillRectangle (state->dpy, state->window, gc1,
1190                                 tx, ty, width, height);
1191                 XSetClipMask (state->dpy, gc1, None);
1192               }
1193 #else /* !FUZZY_BORDER */
1194
1195             XCopyPlane (state->dpy,
1196                         cell->p_char->pixmap, state->window,
1197                         state->gcs[cell->state],
1198                         0, 0, width, height, tx, ty, 1L);
1199
1200 #endif /* !FUZZY_BORDER */
1201           }
1202
1203         cell->changed = False;
1204       }
1205 }
1206
1207
1208 static unsigned long
1209 phosphor_draw (Display *dpy, Window window, void *closure)
1210 {
1211   p_state *state = (p_state *) closure;
1212   update_display (state, True);
1213   decay (state);
1214   drain_input (state);
1215   return state->delay;
1216 }
1217
1218 \f
1219 /* Subprocess.
1220  */
1221
1222 static void
1223 subproc_cb (XtPointer closure, int *source, XtInputId *id)
1224 {
1225   p_state *state = (p_state *) closure;
1226   state->input_available_p = True;
1227 }
1228
1229
1230 static void
1231 launch_text_generator (p_state *state)
1232 {
1233   XtAppContext app = XtDisplayToApplicationContext (state->dpy);
1234   Display *dpy = state->dpy;
1235   char buf[255];
1236   char *oprogram = get_string_resource (dpy, "program", "Program");
1237   char *program = (char *) malloc (strlen (oprogram) + 50);
1238
1239   strcpy (program, "( ");
1240   strcat (program, oprogram);
1241
1242   /* Kludge!  Special-case "xscreensaver-text" to tell it how wide
1243      the screen is.  We used to do this by just always feeding
1244      `program' through sprintf() and setting the default value to
1245      "xscreensaver-text --cols %d", but that makes things blow up
1246      if someone ever uses a --program that includes a % anywhere.
1247    */
1248   if (!strcmp (oprogram, "xscreensaver-text"))
1249     sprintf (program + strlen(program), " --cols %d", state->grid_width-1);
1250
1251   strcat (program, " ) 2>&1");
1252
1253 #ifdef HAVE_FORKPTY
1254   if(state->mode == 1)
1255     {
1256       int fd;
1257       struct winsize ws;
1258       
1259       ws.ws_row = state->grid_height - 1;
1260       ws.ws_col = state->grid_width  - 2;
1261       ws.ws_xpixel = state->xgwa.width;
1262       ws.ws_ypixel = state->xgwa.height;
1263       
1264       state->pipe = NULL;
1265       if((state->pid = forkpty(&fd, NULL, NULL, &ws)) < 0)
1266         {
1267           /* Unable to fork */
1268           sprintf (buf, "%.100s: forkpty", progname);
1269           perror(buf);
1270         }
1271       else if(!state->pid)
1272         {
1273           /* This is the child fork. */
1274           char *av[10];
1275           int i = 0;
1276           if (putenv("TERM=vt100"))
1277             abort();
1278           av[i++] = "/bin/sh";
1279           av[i++] = "-c";
1280           av[i++] = program;
1281           av[i] = 0;
1282           execvp (av[0], av);
1283           sprintf (buf, "%.100s: %.100s", progname, oprogram);
1284           perror(buf);
1285           exit(1);
1286         }
1287       else
1288         {
1289           /* This is the parent fork. */
1290           state->pipe = fdopen(fd, "r+");
1291           state->pipe_id =
1292             XtAppAddInput (app, fileno (state->pipe),
1293                            (XtPointer) (XtInputReadMask | XtInputExceptMask),
1294                            subproc_cb, (XtPointer) state);
1295         }
1296     }
1297   else
1298 #endif /* HAVE_FORKPTY */
1299     {
1300       /* don't mess up controlling terminal if someone dumbly does
1301          "-pipe -program tcsh". */
1302       static int protected_stdin_p = 0;
1303       if (! protected_stdin_p) {
1304         fclose (stdin);
1305         open ("/dev/null", O_RDWR); /* re-allocate fd 0 */
1306         protected_stdin_p = 1;
1307       }
1308
1309       if ((state->pipe = popen (program, "r")))
1310         {
1311           state->pipe_id =
1312             XtAppAddInput (app, fileno (state->pipe),
1313                            (XtPointer) (XtInputReadMask | XtInputExceptMask),
1314                            subproc_cb, (XtPointer) state);
1315         }
1316       else
1317         {
1318           sprintf (buf, "%.100s: %.100s", progname, program);
1319           perror (buf);
1320         }
1321     }
1322
1323   free (program);
1324 }
1325
1326
1327 static void
1328 relaunch_generator_timer (XtPointer closure, XtIntervalId *id)
1329 {
1330   p_state *state = (p_state *) closure;
1331   if (!state->pipe_timer) abort();
1332   state->pipe_timer = 0;
1333   launch_text_generator (state);
1334 }
1335
1336
1337 static void
1338 drain_input (p_state *state)
1339 {
1340   XtAppContext app = XtDisplayToApplicationContext (state->dpy);
1341   if (state->input_available_p && state->pipe)
1342     {
1343       unsigned char s[2];
1344       int n = read (fileno (state->pipe), (void *) s, 1);
1345       if (n == 1)
1346         {
1347           print_char (state, s[0]);
1348         }
1349       else
1350         {
1351           XtRemoveInput (state->pipe_id);
1352           state->pipe_id = 0;
1353           if (state->pid)
1354             {
1355               waitpid(state->pid, NULL, 0);
1356               fclose (state->pipe);
1357               state->pid = 0;
1358             }
1359           else
1360             {
1361               pclose (state->pipe);
1362             }
1363           state->pipe = 0;
1364
1365           if (state->cursor_x != 0) {   /* break line if unbroken */
1366             print_char (state, '\r');
1367             print_char (state, '\n');
1368           }
1369           print_char (state, '\r');     /* blank line */
1370           print_char (state, '\n');
1371
1372           /* Set up a timer to re-launch the subproc in a bit. */
1373           state->pipe_timer =
1374             XtAppAddTimeOut (app, state->subproc_relaunch_delay,
1375                              relaunch_generator_timer,
1376                              (XtPointer) state);
1377         }
1378         
1379       state->input_available_p = False;
1380     }
1381 }
1382
1383
1384 /* The interpretation of the ModN modifiers is dependent on what keys
1385    are bound to them: Mod1 does not necessarily mean "meta".  It only
1386    means "meta" if Meta_L or Meta_R are bound to it.  If Meta_L is on
1387    Mod5, then Mod5 is the one that means Meta.  Oh, and Meta and Alt
1388    aren't necessarily the same thing.  Icepicks in my forehead!
1389  */
1390 static unsigned int
1391 do_icccm_meta_key_stupidity (Display *dpy)
1392 {
1393   unsigned int modbits = 0;
1394 # ifndef HAVE_COCOA
1395   int i, j, k;
1396   XModifierKeymap *modmap = XGetModifierMapping (dpy);
1397   for (i = 3; i < 8; i++)
1398     for (j = 0; j < modmap->max_keypermod; j++)
1399       {
1400         int code = modmap->modifiermap[i * modmap->max_keypermod + j];
1401         KeySym *syms;
1402         int nsyms = 0;
1403         if (code == 0) continue;
1404         syms = XGetKeyboardMapping (dpy, code, 1, &nsyms);
1405         for (k = 0; k < nsyms; k++)
1406           if (syms[k] == XK_Meta_L || syms[k] == XK_Meta_R ||
1407               syms[k] == XK_Alt_L  || syms[k] == XK_Alt_R)
1408             modbits |= (1 << i);
1409         XFree (syms);
1410       }
1411   XFreeModifiermap (modmap);
1412 # endif /* HAVE_COCOA */
1413   return modbits;
1414 }
1415
1416 /* Returns a mask of the bit or bits of a KeyPress event that mean "meta". 
1417  */
1418 static unsigned int
1419 meta_modifier (p_state *state)
1420 {
1421   if (!state->meta_done_once)
1422     {
1423       /* Really, we are supposed to recompute this if a KeymapNotify
1424          event comes in, but fuck it. */
1425       state->meta_done_once = True;
1426       state->meta_mask = do_icccm_meta_key_stupidity (state->dpy);
1427     }
1428   return state->meta_mask;
1429 }
1430
1431
1432 static void
1433 phosphor_reshape (Display *dpy, Window window, void *closure, 
1434                  unsigned int w, unsigned int h)
1435 {
1436   p_state *state = (p_state *) closure;
1437   resize_grid (state);
1438
1439 # if defined(HAVE_FORKPTY) && defined(TIOCSWINSZ)
1440   if (state->pid && state->pipe)
1441     {
1442       /* Tell the sub-process that the screen size has changed. */
1443       struct winsize ws;
1444       ws.ws_row = state->grid_height - 1;
1445       ws.ws_col = state->grid_width  - 2;
1446       ws.ws_xpixel = state->xgwa.width;
1447       ws.ws_ypixel = state->xgwa.height;
1448       ioctl (fileno (state->pipe), TIOCSWINSZ, &ws);
1449       kill (state->pid, SIGWINCH);
1450     }
1451 # endif /* HAVE_FORKPTY && TIOCSWINSZ */
1452 }
1453
1454 static Bool
1455 phosphor_event (Display *dpy, Window window, void *closure, XEvent *event)
1456 {
1457   p_state *state = (p_state *) closure;
1458
1459   if (event->xany.type == Expose)
1460     update_display (state, False);
1461   else if (event->xany.type == KeyPress)
1462     {
1463       KeySym keysym;
1464       unsigned char c = 0;
1465       XLookupString (&event->xkey, (char *) &c, 1, &keysym,
1466                      &state->compose);
1467       if (c != 0 && state->pipe)
1468         {
1469           if (!state->swap_bs_del_p) ;
1470           else if (c == 127) c = 8;
1471           else if (c == 8)   c = 127;
1472
1473           /* If meta was held down, send ESC, or turn on the high bit. */
1474           if (event->xkey.state & meta_modifier (state))
1475             {
1476               if (state->meta_sends_esc_p)
1477                 fputc ('\033', state->pipe);
1478               else
1479                 c |= 0x80;
1480             }
1481
1482           fputc (c, state->pipe);
1483           fflush (state->pipe);
1484           event->xany.type = 0;  /* don't interpret this event defaultly. */
1485         }
1486       return True;
1487     }
1488
1489   return False;
1490 }
1491
1492 static void
1493 phosphor_free (Display *dpy, Window window, void *closure)
1494 {
1495   p_state *state = (p_state *) closure;
1496
1497   if (state->pipe_id)
1498     XtRemoveInput (state->pipe_id);
1499   if (state->pipe)
1500     pclose (state->pipe);
1501   if (state->cursor_timer)
1502     XtRemoveTimeOut (state->cursor_timer);
1503   if (state->pipe_timer)
1504     XtRemoveTimeOut (state->pipe_timer);
1505
1506   /* #### there's more to free here */
1507
1508   free (state);
1509 }
1510
1511
1512
1513 static const char *phosphor_defaults [] = {
1514   ".background:            Black",
1515   ".foreground:            #00FF00",
1516   "*fpsSolid:              true",
1517   "*fadeForeground:        #006400",
1518   "*flareForeground:       #FFFFFF",
1519 #if defined(BUILTIN_FONT)
1520   "*font:                  (builtin)",
1521 #elif defined(HAVE_COCOA)
1522   "*font:                  Monaco 15",
1523 #else
1524   "*font:                  fixed",
1525 #endif
1526   "*scale:                 6",
1527   "*ticks:                 20",
1528   "*delay:                 50000",
1529   "*cursor:                333",
1530   "*program:               xscreensaver-text",
1531   "*relaunch:              5",
1532   "*metaSendsESC:          True",
1533   "*swapBSDEL:             True",
1534 #ifdef HAVE_FORKPTY
1535   "*mode:                  pty",
1536 #else  /* !HAVE_FORKPTY */
1537   "*mode:                  pipe",
1538 #endif /* !HAVE_FORKPTY */
1539   0
1540 };
1541
1542 static XrmOptionDescRec phosphor_options [] = {
1543   { "-font",            ".font",                XrmoptionSepArg, 0 },
1544   { "-scale",           ".scale",               XrmoptionSepArg, 0 },
1545   { "-ticks",           ".ticks",               XrmoptionSepArg, 0 },
1546   { "-delay",           ".delay",               XrmoptionSepArg, 0 },
1547   { "-program",         ".program",             XrmoptionSepArg, 0 },
1548   { "-pty",             ".mode",                XrmoptionNoArg, "pty"   },
1549   { "-pipe",            ".mode",                XrmoptionNoArg, "pipe"  },
1550   { "-meta",            ".metaSendsESC",        XrmoptionNoArg, "False" },
1551   { "-esc",             ".metaSendsESC",        XrmoptionNoArg, "True"  },
1552   { "-bs",              ".swapBSDEL",           XrmoptionNoArg, "False" },
1553   { "-del",             ".swapBSDEL",           XrmoptionNoArg, "True"  },
1554   { 0, 0, 0, 0 }
1555 };
1556
1557
1558 XSCREENSAVER_MODULE ("Phosphor", phosphor)