[screensavers] / reference / greynetic.c

/* xscreensaver, Copyright (c) 1992-2008 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

#include "screenhack.h"

#ifndef HAVE_JWXYZ
# define DO_STIPPLE
#endif

#define NBITS 12

/* On some systems (notably MacOS X) these files are messed up.
 * They're tiny, so we might as well just inline them here.
 *
 * # include <X11/bitmaps/stipple>
 * # include <X11/bitmaps/cross_weave>
 * # include <X11/bitmaps/dimple1>
 * # include <X11/bitmaps/dimple3>
 * # include <X11/bitmaps/flipped_gray>
 * # include <X11/bitmaps/gray1>
 * # include <X11/bitmaps/gray3>
 * # include <X11/bitmaps/hlines2>
 * # include <X11/bitmaps/light_gray>
 * # include <X11/bitmaps/root_weave>
 * # include <X11/bitmaps/vlines2>
 * # include <X11/bitmaps/vlines3>
*/

#ifdef DO_STIPPLE
#define stipple_width  16
#define stipple_height 4
static unsigned char stipple_bits[] = {
  0x55, 0x55, 0xee, 0xee, 0x55, 0x55, 0xba, 0xbb};

#define cross_weave_width  16
#define cross_weave_height 16
static unsigned char cross_weave_bits[] = {
   0x55, 0x55, 0x88, 0x88, 0x55, 0x55, 0x22, 0x22, 0x55, 0x55, 0x88, 0x88,
   0x55, 0x55, 0x22, 0x22, 0x55, 0x55, 0x88, 0x88, 0x55, 0x55, 0x22, 0x22,
   0x55, 0x55, 0x88, 0x88, 0x55, 0x55, 0x22, 0x22};

#define dimple1_width 16
#define dimple1_height 16
static unsigned char dimple1_bits[] = {
   0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00,
   0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00,
   0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00};

#define dimple3_width 16
#define dimple3_height 16
static unsigned char dimple3_bits[] = {
   0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

#define flipped_gray_width  4
#define flipped_gray_height 2
static char flipped_gray_bits[] = { 0x07, 0x0d};
#define gray1_width  2
#define gray1_height 2
static char gray1_bits[] = { 0x01, 0x02};
#define gray3_width  4
#define gray3_height 4
static char gray3_bits[] = { 0x01, 0x00, 0x04, 0x00};
#define hlines2_width  1
#define hlines2_height 2
static char hlines2_bits[] = { 0x01, 0x00};
#define light_gray_width  4
#define light_gray_height 2
static char light_gray_bits[] = { 0x08, 0x02};
#define root_weave_width  4
#define root_weave_height 4
static char root_weave_bits[] = { 0x07, 0x0d, 0x0b, 0x0e};
#define vlines2_width  2
#define vlines2_height 1
static char vlines2_bits[] = { 0x01};
#define vlines3_width  3
#define vlines3_height 1
static char vlines3_bits[] = { 0x02};

#endif /* DO_STIPPLE */

struct state {
  Display *dpy;
  Window window;

  Pixmap pixmaps [NBITS];

  GC gc;
  int delay;
  unsigned long fg, bg, pixels [512];
  int npixels;
  int xlim, ylim;
  Bool grey_p;
  Colormap cmap;
};


static void *
greynetic_init (Display *dpy, Window window)
{
  struct state *st = (struct state *) calloc (1, sizeof(*st));
# ifdef DO_STIPPLE
  int i;
# endif /* DO_STIPPLE */
  XGCValues gcv;
  XWindowAttributes xgwa;
  st->dpy = dpy;
  st->window = window;

  XGetWindowAttributes (st->dpy, st->window, &xgwa);
  st->xlim = xgwa.width;
  st->ylim = xgwa.height;
  st->cmap = xgwa.colormap;
  st->npixels = 0;
  st->grey_p = get_boolean_resource(st->dpy, "grey", "Boolean");
  gcv.foreground= st->fg= get_pixel_resource(st->dpy, st->cmap, "foreground","Foreground");
  gcv.background= st->bg= get_pixel_resource(st->dpy, st->cmap, "background","Background");

  st->delay = get_integer_resource (st->dpy, "delay", "Integer");
  if (st->delay < 0) st->delay = 0;

# ifndef DO_STIPPLE
  st->gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
#  ifdef HAVE_JWXYZ /* allow non-opaque alpha components in pixel values */
  jwxyz_XSetAlphaAllowed (st->dpy, st->gc, True);
#  endif /* HAVE_JWXYZ */
# else /* DO_STIPPLE */
  gcv.fill_style= FillOpaqueStippled;
  st->gc = XCreateGC (st->dpy, st->window, GCForeground|GCBackground|GCFillStyle, &gcv);
  
  i = 0;
# define BITS(n,w,h) \
  st->pixmaps [i++] = \
    XCreatePixmapFromBitmapData (st->dpy, st->window, (char *) n, w, h, 1, 0, 1)

  BITS (stipple_bits, stipple_width, stipple_height);
  BITS (cross_weave_bits, cross_weave_width, cross_weave_height);
  BITS (dimple1_bits, dimple1_width, dimple1_height);
  BITS (dimple3_bits, dimple3_width, dimple3_height);
  BITS (flipped_gray_bits, flipped_gray_width, flipped_gray_height);
  BITS (gray1_bits, gray1_width, gray1_height);
  BITS (gray3_bits, gray3_width, gray3_height);
  BITS (hlines2_bits, hlines2_width, hlines2_height);
  BITS (light_gray_bits, light_gray_width, light_gray_height);
  BITS (root_weave_bits, root_weave_width, root_weave_height);
  BITS (vlines2_bits, vlines2_width, vlines2_height);
  BITS (vlines3_bits, vlines3_width, vlines3_height);
# endif /* DO_STIPPLE */
  return st;
}

static unsigned long
greynetic_draw (Display *dpy, Window window, void *closure)
{
  struct state *st = (struct state *) closure;
  int x, y, w=0, h=0, i;
  XGCValues gcv;

  for (i = 0; i < 10; i++) /* minimize area, but don't try too hard */
    {
      w = 50 + random () % (st->xlim - 50);
      h = 50 + random () % (st->ylim - 50);
      if (w + h < st->xlim && w + h < st->ylim)
	break;
    }
  x = random () % (st->xlim - w);
  y = random () % (st->ylim - h);
# ifdef DO_STIPPLE
  gcv.stipple = st->pixmaps [random () % NBITS];
# endif /* !DO_STIPPLE */
  if (mono_p)
    {
    MONO:
      if (random () & 1)
	gcv.foreground = st->fg, gcv.background = st->bg;
      else
	gcv.foreground = st->bg, gcv.background = st->fg;
    }
  else
    {
      XColor fgc, bgc;
      if (st->npixels == sizeof (st->pixels) / sizeof (unsigned long))
	goto REUSE;
      fgc.flags = bgc.flags = DoRed|DoGreen|DoBlue;
      fgc.red = random ();
      fgc.green = random ();
      fgc.blue = random ();
# ifdef DO_STIPPLE
      bgc.red = random ();
      bgc.green = random ();
      bgc.blue = random ();
# endif /* DO_STIPPLE */

      if (st->grey_p)
        {
          fgc.green = fgc.blue = fgc.red;
          bgc.green = bgc.blue = bgc.red;
        }

      if (! XAllocColor (st->dpy, st->cmap, &fgc))
	goto REUSE;
      st->pixels [st->npixels++] = fgc.pixel;
      gcv.foreground = fgc.pixel;
# ifdef DO_STIPPLE
      if (! XAllocColor (st->dpy, st->cmap, &bgc))
	goto REUSE;
      st->pixels [st->npixels++] = bgc.pixel;
      gcv.background = bgc.pixel;
# endif /* DO_STIPPLE */
      goto DONE;
    REUSE:
      if (st->npixels <= 0)
	{
	  mono_p = 1;
	  goto MONO;
	}
      gcv.foreground = st->pixels [random () % st->npixels];
# ifdef DO_STIPPLE
      gcv.background = st->pixels [random () % st->npixels];
# endif /* DO_STIPPLE */
    DONE:
      ;

# ifdef HAVE_JWXYZ
      {
        /* give a non-opaque alpha to the color */
        unsigned long pixel = gcv.foreground;
        unsigned long amask = BlackPixel (dpy,0);
        unsigned long a = (random() & amask);
        pixel = (pixel & (~amask)) | a;
        gcv.foreground = pixel;
      }
# endif /* !HAVE_JWXYZ */
    }
# ifndef DO_STIPPLE
  XChangeGC (st->dpy, st->gc, GCForeground, &gcv);
# else  /* DO_STIPPLE */
  XChangeGC (st->dpy, st->gc, GCStipple|GCForeground|GCBackground, &gcv);
# endif /* DO_STIPPLE */
  XFillRectangle (st->dpy, st->window, st->gc, x, y, w, h);
  return st->delay;
}

\f
static const char *greynetic_defaults [] = {
  ".background:	black",
  ".foreground:	white",
  "*fpsSolid:	true",
  "*delay:	10000",
  "*grey:	false",
#ifdef HAVE_MOBILE
  "*ignoreRotation: True",
#endif
  0
};

static XrmOptionDescRec greynetic_options [] = {
  { "-delay",		".delay",	XrmoptionSepArg, 0 },
  { "-grey",		".grey",	XrmoptionNoArg, "True" },
  { 0, 0, 0, 0 }
};

static void
greynetic_reshape (Display *dpy, Window window, void *closure, 
                 unsigned int w, unsigned int h)
{
  struct state *st = (struct state *) closure;
  st->xlim = w;
  st->ylim = h;
}

static Bool
greynetic_event (Display *dpy, Window window, void *closure, XEvent *event)
{
  return False;
}

static void
greynetic_free (Display *dpy, Window window, void *closure)
{
  struct state *st = (struct state *) closure;
  XFreeGC (st->dpy, st->gc);
  free (st);
}

XSCREENSAVER_MODULE ("Greynetic", greynetic)
Commit	Line	Data
6881658b AT	1	/* xscreensaver, Copyright (c) 1992-2008 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
	12	#include "screenhack.h"
	13
	14	#ifndef HAVE_JWXYZ
	15	# define DO_STIPPLE
	16	#endif
	17
	18	#define NBITS 12
	19
	20	/* On some systems (notably MacOS X) these files are messed up.
	21	* They're tiny, so we might as well just inline them here.
	22	*
	23	* # include <X11/bitmaps/stipple>
	24	* # include <X11/bitmaps/cross_weave>
	25	* # include <X11/bitmaps/dimple1>
	26	* # include <X11/bitmaps/dimple3>
	27	* # include <X11/bitmaps/flipped_gray>
	28	* # include <X11/bitmaps/gray1>
	29	* # include <X11/bitmaps/gray3>
	30	* # include <X11/bitmaps/hlines2>
	31	* # include <X11/bitmaps/light_gray>
	32	* # include <X11/bitmaps/root_weave>
	33	* # include <X11/bitmaps/vlines2>
	34	* # include <X11/bitmaps/vlines3>
	35	*/
	36
	37	#ifdef DO_STIPPLE
	38	#define stipple_width 16
	39	#define stipple_height 4
	40	static unsigned char stipple_bits[] = {
	41	0x55, 0x55, 0xee, 0xee, 0x55, 0x55, 0xba, 0xbb};
	42
	43	#define cross_weave_width 16
	44	#define cross_weave_height 16
	45	static unsigned char cross_weave_bits[] = {
	46	0x55, 0x55, 0x88, 0x88, 0x55, 0x55, 0x22, 0x22, 0x55, 0x55, 0x88, 0x88,
	47	0x55, 0x55, 0x22, 0x22, 0x55, 0x55, 0x88, 0x88, 0x55, 0x55, 0x22, 0x22,
	48	0x55, 0x55, 0x88, 0x88, 0x55, 0x55, 0x22, 0x22};
	49
	50	#define dimple1_width 16
	51	#define dimple1_height 16
	52	static unsigned char dimple1_bits[] = {
	53	0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00,
	54	0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00,
	55	0x55, 0x55, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00};
	56
	57	#define dimple3_width 16
	58	#define dimple3_height 16
	59	static unsigned char dimple3_bits[] = {
	60	0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00,
	61	0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	62	0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	63
	64	#define flipped_gray_width 4
65	#define flipped_gray_height 2
66	static char flipped_gray_bits[] = { 0x07, 0x0d};
67	#define gray1_width 2
68	#define gray1_height 2
69	static char gray1_bits[] = { 0x01, 0x02};
70	#define gray3_width 4
71	#define gray3_height 4
72	static char gray3_bits[] = { 0x01, 0x00, 0x04, 0x00};
73	#define hlines2_width 1
74	#define hlines2_height 2
75	static char hlines2_bits[] = { 0x01, 0x00};
76	#define light_gray_width 4
77	#define light_gray_height 2
78	static char light_gray_bits[] = { 0x08, 0x02};
79	#define root_weave_width 4
80	#define root_weave_height 4
81	static char root_weave_bits[] = { 0x07, 0x0d, 0x0b, 0x0e};
82	#define vlines2_width 2
83	#define vlines2_height 1
84	static char vlines2_bits[] = { 0x01};
85	#define vlines3_width 3
86	#define vlines3_height 1
87	static char vlines3_bits[] = { 0x02};
88
89	#endif /* DO_STIPPLE */
90
91	struct state {
92	Display *dpy;
93	Window window;
94
95	Pixmap pixmaps [NBITS];
96
97	GC gc;
98	int delay;
99	unsigned long fg, bg, pixels [512];
100	int npixels;
101	int xlim, ylim;
102	Bool grey_p;
103	Colormap cmap;
104	};
105
106
107	static void *
108	greynetic_init (Display *dpy, Window window)
109	{
110	struct state st = (struct state ) calloc (1, sizeof(*st));
111	# ifdef DO_STIPPLE
112	int i;
113	# endif /* DO_STIPPLE */
114	XGCValues gcv;
115	XWindowAttributes xgwa;
116	st->dpy = dpy;
117	st->window = window;
118
119	XGetWindowAttributes (st->dpy, st->window, &xgwa);
120	st->xlim = xgwa.width;
121	st->ylim = xgwa.height;
122	st->cmap = xgwa.colormap;
123	st->npixels = 0;
124	st->grey_p = get_boolean_resource(st->dpy, "grey", "Boolean");
125	gcv.foreground= st->fg= get_pixel_resource(st->dpy, st->cmap, "foreground","Foreground");
126	gcv.background= st->bg= get_pixel_resource(st->dpy, st->cmap, "background","Background");
127
128	st->delay = get_integer_resource (st->dpy, "delay", "Integer");
129	if (st->delay < 0) st->delay = 0;
130
131	# ifndef DO_STIPPLE
132	st->gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv);
133	# ifdef HAVE_JWXYZ /* allow non-opaque alpha components in pixel values */
134	jwxyz_XSetAlphaAllowed (st->dpy, st->gc, True);
135	# endif /* HAVE_JWXYZ */
136	# else /* DO_STIPPLE */
137	gcv.fill_style= FillOpaqueStippled;
138	st->gc = XCreateGC (st->dpy, st->window, GCForeground\|GCBackground\|GCFillStyle, &gcv);
139
140	i = 0;
141	# define BITS(n,w,h) \
142	st->pixmaps [i++] = \
143	XCreatePixmapFromBitmapData (st->dpy, st->window, (char *) n, w, h, 1, 0, 1)
144
145	BITS (stipple_bits, stipple_width, stipple_height);
146	BITS (cross_weave_bits, cross_weave_width, cross_weave_height);
147	BITS (dimple1_bits, dimple1_width, dimple1_height);
148	BITS (dimple3_bits, dimple3_width, dimple3_height);
149	BITS (flipped_gray_bits, flipped_gray_width, flipped_gray_height);
150	BITS (gray1_bits, gray1_width, gray1_height);
151	BITS (gray3_bits, gray3_width, gray3_height);
152	BITS (hlines2_bits, hlines2_width, hlines2_height);
153	BITS (light_gray_bits, light_gray_width, light_gray_height);
154	BITS (root_weave_bits, root_weave_width, root_weave_height);
155	BITS (vlines2_bits, vlines2_width, vlines2_height);
156	BITS (vlines3_bits, vlines3_width, vlines3_height);
157	# endif /* DO_STIPPLE */
158	return st;
159	}
160
161	static unsigned long
162	greynetic_draw (Display dpy, Window window, void closure)
163	{
164	struct state st = (struct state ) closure;
165	int x, y, w=0, h=0, i;
166	XGCValues gcv;
167
168	for (i = 0; i < 10; i++) /* minimize area, but don't try too hard */
169	{
170	w = 50 + random () % (st->xlim - 50);
171	h = 50 + random () % (st->ylim - 50);
172	if (w + h < st->xlim && w + h < st->ylim)
173	break;
174	}
175	x = random () % (st->xlim - w);
176	y = random () % (st->ylim - h);
177	# ifdef DO_STIPPLE
178	gcv.stipple = st->pixmaps [random () % NBITS];
179	# endif /* !DO_STIPPLE */
180	if (mono_p)
181	{
182	MONO:
183	if (random () & 1)
184	gcv.foreground = st->fg, gcv.background = st->bg;
185	else
186	gcv.foreground = st->bg, gcv.background = st->fg;
187	}
188	else
189	{
190	XColor fgc, bgc;
191	if (st->npixels == sizeof (st->pixels) / sizeof (unsigned long))
192	goto REUSE;
193	fgc.flags = bgc.flags = DoRed\|DoGreen\|DoBlue;
194	fgc.red = random ();
195	fgc.green = random ();
196	fgc.blue = random ();
197	# ifdef DO_STIPPLE
198	bgc.red = random ();
199	bgc.green = random ();
200	bgc.blue = random ();
201	# endif /* DO_STIPPLE */
202
203	if (st->grey_p)
204	{
205	fgc.green = fgc.blue = fgc.red;
206	bgc.green = bgc.blue = bgc.red;
207	}
208
209	if (! XAllocColor (st->dpy, st->cmap, &fgc))
210	goto REUSE;
211	st->pixels [st->npixels++] = fgc.pixel;
212	gcv.foreground = fgc.pixel;
213	# ifdef DO_STIPPLE
214	if (! XAllocColor (st->dpy, st->cmap, &bgc))
215	goto REUSE;
216	st->pixels [st->npixels++] = bgc.pixel;
217	gcv.background = bgc.pixel;
218	# endif /* DO_STIPPLE */
219	goto DONE;
220	REUSE:
221	if (st->npixels <= 0)
222	{
223	mono_p = 1;
224	goto MONO;
225	}
226	gcv.foreground = st->pixels [random () % st->npixels];
227	# ifdef DO_STIPPLE
228	gcv.background = st->pixels [random () % st->npixels];
229	# endif /* DO_STIPPLE */
230	DONE:
231	;
232
233	# ifdef HAVE_JWXYZ
234	{
235	/* give a non-opaque alpha to the color */
236	unsigned long pixel = gcv.foreground;
237	unsigned long amask = BlackPixel (dpy,0);
238	unsigned long a = (random() & amask);
239	pixel = (pixel & (~amask)) \| a;
240	gcv.foreground = pixel;
241	}
242	# endif /* !HAVE_JWXYZ */
243	}
244	# ifndef DO_STIPPLE
245	XChangeGC (st->dpy, st->gc, GCForeground, &gcv);
246	# else /* DO_STIPPLE */
247	XChangeGC (st->dpy, st->gc, GCStipple\|GCForeground\|GCBackground, &gcv);
248	# endif /* DO_STIPPLE */
249	XFillRectangle (st->dpy, st->window, st->gc, x, y, w, h);
250	return st->delay;
251	}
252
253	\f
254	static const char *greynetic_defaults [] = {
255	".background: black",
256	".foreground: white",
257	"*fpsSolid: true",
258	"*delay: 10000",
259	"*grey: false",
260	#ifdef HAVE_MOBILE
261	"*ignoreRotation: True",
262	#endif
263	0
264	};
265
266	static XrmOptionDescRec greynetic_options [] = {
267	{ "-delay", ".delay", XrmoptionSepArg, 0 },
268	{ "-grey", ".grey", XrmoptionNoArg, "True" },
269	{ 0, 0, 0, 0 }
270	};
271
272	static void
273	greynetic_reshape (Display dpy, Window window, void closure,
274	unsigned int w, unsigned int h)
275	{
276	struct state st = (struct state ) closure;
277	st->xlim = w;
278	st->ylim = h;
279	}
280
281	static Bool
282	greynetic_event (Display dpy, Window window, void closure, XEvent *event)
283	{
284	return False;
285	}
286
287	static void
288	greynetic_free (Display dpy, Window window, void closure)
289	{
290	struct state st = (struct state ) closure;
291	XFreeGC (st->dpy, st->gc);
292	free (st);
293	}
294
295	XSCREENSAVER_MODULE ("Greynetic", greynetic)
296