git.hungrycats.org Git - xscreensaver/blob - hacks/noseguy.c

   1 /* xscreensaver, Copyright (c) 1992-2012 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 /* Make a little guy with a big nose and a hat wanter around the screen,
  13    spewing out messages.  Derived from xnlock by
  14    Dan Heller <argv@danheller.com>.
  15  */
  16
  17 #include "screenhack.h"
  18 #include "xpm-pixmap.h"
  19 #include "textclient.h"
  20
  21 #ifdef HAVE_COCOA
  22 # define HAVE_XPM
  23 #endif
  24
  25 #define font_height(font) (font->ascent + font->descent)
  26
  27
  28 struct state {
  29   Display *dpy;
  30   Window window;
  31   int Width, Height;
  32   GC fg_gc, bg_gc, text_fg_gc, text_bg_gc;
  33   int x, y;
  34   XFontStruct *font;
  35
  36   unsigned long interval;
  37   Pixmap left1, left2, right1, right2;
  38   Pixmap left_front, right_front, front, down;
  39
  40   char *program;
  41   text_data *tc;
  42
  43   int state;    /* indicates states: walking or getting passwd */
  44   int first_time;
  45
  46   void (*next_fn) (struct state *);
  47
  48   int move_length, move_dir;
  49
  50   int      walk_lastdir;
  51   int      walk_up;
  52   Pixmap   walk_frame;
  53
  54   int X, Y, talking;
  55
  56   struct {
  57     int x, y, width, height;
  58   } s_rect;
  59
  60   char words[10240];
  61   int lines;
  62 };
  63
  64 static void fill_words (struct state *);
  65 static void walk (struct state *, int dir);
  66 static void talk (struct state *, int erase);
  67 static void talk_1 (struct state *);
  68 static int think (struct state *);
  69 static unsigned long look (struct state *);
  70
  71 #define IS_MOVING  1
  72
  73 #if defined(HAVE_GDK_PIXBUF) || defined(HAVE_XPM)
  74 # include "images/noseguy/nose-f1.xpm"
  75 # include "images/noseguy/nose-f2.xpm"
  76 # include "images/noseguy/nose-f3.xpm"
  77 # include "images/noseguy/nose-f4.xpm"
  78 # include "images/noseguy/nose-l1.xpm"
  79 # include "images/noseguy/nose-l2.xpm"
  80 # include "images/noseguy/nose-r1.xpm"
  81 # include "images/noseguy/nose-r2.xpm"
  82 #else
  83 # include "images/noseguy/nose-f1.xbm"
  84 # include "images/noseguy/nose-f2.xbm"
  85 # include "images/noseguy/nose-f3.xbm"
  86 # include "images/noseguy/nose-f4.xbm"
  87 # include "images/noseguy/nose-l1.xbm"
  88 # include "images/noseguy/nose-l2.xbm"
  89 # include "images/noseguy/nose-r1.xbm"
  90 # include "images/noseguy/nose-r2.xbm"
  91 #endif
  92
  93 static void
  94 init_images (struct state *st)
  95 {
  96   Pixmap *images[8];
  97 #if defined(HAVE_GDK_PIXBUF) || defined(HAVE_XPM)
  98   char **bits[8];
  99 #else
 100   unsigned char *bits[8];
 101 #endif
 102
 103   int i = 0;
 104   images[i++] = &st->left1;
 105   images[i++] = &st->left2;
 106   images[i++] = &st->right1;
 107   images[i++] = &st->right2;
 108   images[i++] = &st->left_front;
 109   images[i++] = &st->right_front;
 110   images[i++] = &st->front;
 111   images[i]   = &st->down;
 112
 113 #if defined(HAVE_GDK_PIXBUF) || defined(HAVE_XPM)
 114
 115   i = 0;
 116   bits[i++] = nose_l1_xpm;
 117   bits[i++] = nose_l2_xpm;
 118   bits[i++] = nose_r1_xpm;
 119   bits[i++] = nose_r2_xpm;
 120   bits[i++] = nose_f2_xpm;
 121   bits[i++] = nose_f3_xpm;
 122   bits[i++] = nose_f1_xpm;
 123   bits[i]   = nose_f4_xpm;
 124
 125   for (i = 0; i < sizeof (images) / sizeof(*images); i++)
 126     {
 127       Pixmap pixmap = xpm_data_to_pixmap (st->dpy, st->window, bits[i],
 128                                           0, 0, 0);
 129       if (!pixmap)
 130         {
 131           fprintf (stderr, "%s: Can't load nose images\n", progname);
 132           exit (1);
 133         }
 134       *images[i] = pixmap;
 135     }
 136 #else
 137   i = 0;
 138   bits[i++] = nose_l1_bits;
 139   bits[i++] = nose_l2_bits;
 140   bits[i++] = nose_r1_bits;
 141   bits[i++] = nose_r2_bits;
 142   bits[i++] = nose_f2_bits;
 143   bits[i++] = nose_f3_bits;
 144   bits[i++] = nose_f1_bits;
 145   bits[i++] = nose_f4_bits;
 146
 147   for (i = 0; i < sizeof (images) / sizeof(*images); i++)
 148     if (!(*images[i] =
 149           XCreatePixmapFromBitmapData(st->dpy, st->window,
 150                                       (char *) bits[i], 64, 64, 1, 0, 1)))
 151       {
 152         fprintf (stderr, "%s: Can't load nose images\n", progname);
 153         exit (1);
 154       }
 155 #endif
 156 }
 157
 158 #define LEFT    001
 159 #define RIGHT   002
 160 #define DOWN    004
 161 #define UP      010
 162 #define FRONT   020
 163 #define X_INCR 3
 164 #define Y_INCR 2
 165
 166 static void
 167 move (struct state *st)
 168 {
 169     if (!st->move_length)
 170     {
 171         register int    tries = 0;
 172         st->move_dir = 0;
 173         if ((random() & 1) && think(st))
 174         {
 175             talk(st, 0);                /* sets timeout to itself */
 176             return;
 177         }
 178         if (!(random() % 3) && (st->interval = look(st)))
 179         {
 180             st->next_fn = move;
 181             return;
 182         }
 183         st->interval = 20 + random() % 100;
 184         do
 185         {
 186             if (!tries)
 187                 st->move_length = st->Width / 100 + random() % 90, tries = 8;
 188             else
 189                 tries--;
 190             /* There maybe the case that we won't be able to exit from
 191                this routine (especially when the geometry is too small)!!
 192
 193                Ensure that we can exit from this routine.
 194              */
 195 #if 1
 196             if (!tries && (st->move_length <= 1)) {
 197               st->move_length = 1;
 198               break;
 199             }
 200 #endif
 201             switch (random() % 8)
 202             {
 203             case 0:
 204                 if (st->x - X_INCR * st->move_length >= 5)
 205                     st->move_dir = LEFT;
 206                 break;
 207             case 1:
 208                 if (st->x + X_INCR * st->move_length <= st->Width - 70)
 209                     st->move_dir = RIGHT;
 210                 break;
 211             case 2:
 212                 if (st->y - (Y_INCR * st->move_length) >= 5)
 213                     st->move_dir = UP, st->interval = 40;
 214                 break;
 215             case 3:
 216                 if (st->y + Y_INCR * st->move_length <= st->Height - 70)
 217                     st->move_dir = DOWN, st->interval = 20;
 218                 break;
 219             case 4:
 220                 if (st->x - X_INCR * st->move_length >= 5 && st->y - (Y_INCR * st->move_length) >= 5)
 221                     st->move_dir = (LEFT | UP);
 222                 break;
 223             case 5:
 224                 if (st->x + X_INCR * st->move_length <= st->Width - 70 &&
 225                     st->y - Y_INCR * st->move_length >= 5)
 226                     st->move_dir = (RIGHT | UP);
 227                 break;
 228             case 6:
 229                 if (st->x - X_INCR * st->move_length >= 5 &&
 230                     st->y + Y_INCR * st->move_length <= st->Height - 70)
 231                     st->move_dir = (LEFT | DOWN);
 232                 break;
 233             case 7:
 234                 if (st->x + X_INCR * st->move_length <= st->Width - 70 &&
 235                     st->y + Y_INCR * st->move_length <= st->Height - 70)
 236                     st->move_dir = (RIGHT | DOWN);
 237                 break;
 238             default:
 239                 /* No Defaults */
 240                 break;
 241             }
 242         } while (!st->move_dir);
 243     }
 244     if (st->move_dir)
 245       walk(st, st->move_dir);
 246     --st->move_length;
 247     st->next_fn = move;
 248 }
 249
 250 #ifdef HAVE_XPM
 251 # define COPY(dpy,frame,window,gc,x,y,w,h,x2,y2) \
 252   XCopyArea (dpy,frame,window,gc,x,y,w,h,x2,y2)
 253 #else
 254 # define COPY(dpy,frame,window,gc,x,y,w,h,x2,y2) \
 255   XCopyPlane(dpy,frame,window,gc,x,y,w,h,x2,y2,1L)
 256 #endif
 257
 258 static void
 259 walk (struct state *st, int dir)
 260 {
 261     register int    incr = 0;
 262
 263     if (dir & (LEFT | RIGHT))
 264     {                           /* left/right movement (mabye up/st->down too) */
 265         st->walk_up = -st->walk_up;             /* bouncing effect (even if hit a wall) */
 266         if (dir & LEFT)
 267         {
 268             incr = X_INCR;
 269             st->walk_frame = (st->walk_up < 0) ? st->left1 : st->left2;
 270         }
 271         else
 272         {
 273             incr = -X_INCR;
 274             st->walk_frame = (st->walk_up < 0) ? st->right1 : st->right2;
 275         }
 276         if ((st->walk_lastdir == FRONT || st->walk_lastdir == DOWN) && dir & UP)
 277         {
 278
 279             /*
 280              * workaround silly bug that leaves screen dust when guy is
 281              * facing forward or st->down and moves up-left/right.
 282              */
 283             COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y);
 284         }
 285         /* note that maybe neither UP nor DOWN is set! */
 286         if (dir & UP && st->y > Y_INCR)
 287             st->y -= Y_INCR;
 288         else if (dir & DOWN && st->y < st->Height - 64)
 289             st->y += Y_INCR;
 290     }
 291     /* Explicit up/st->down movement only (no left/right) */
 292     else if (dir == UP)
 293         COPY(st->dpy, st->front, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y -= Y_INCR);
 294     else if (dir == DOWN)
 295         COPY(st->dpy, st->down, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y += Y_INCR);
 296     else if (dir == FRONT && st->walk_frame != st->front)
 297     {
 298         if (st->walk_up > 0)
 299             st->walk_up = -st->walk_up;
 300         if (st->walk_lastdir & LEFT)
 301             st->walk_frame = st->left_front;
 302         else if (st->walk_lastdir & RIGHT)
 303             st->walk_frame = st->right_front;
 304         else
 305             st->walk_frame = st->front;
 306         COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y);
 307     }
 308     if (dir & LEFT)
 309         while (--incr >= 0)
 310         {
 311             COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, --st->x, st->y + st->walk_up);
 312         }
 313     else if (dir & RIGHT)
 314         while (++incr <= 0)
 315         {
 316             COPY(st->dpy, st->walk_frame, st->window, st->fg_gc, 0, 0, 64, 64, ++st->x, st->y + st->walk_up);
 317         }
 318     st->walk_lastdir = dir;
 319 }
 320
 321 static int
 322 think (struct state *st)
 323 {
 324     if (random() & 1)
 325         walk(st, FRONT);
 326     if (random() & 1)
 327       return 1;
 328     return 0;
 329 }
 330
 331 #define MAXLINES 10
 332
 333 static void
 334 talk (struct state *st, int force_erase)
 335 {
 336     int             width = 0,
 337                     height,
 338                     Z,
 339                     total = 0;
 340     register char  *p,
 341                    *p2;
 342     char            args[MAXLINES][256];
 343
 344     /* clear what we've written */
 345     if (st->talking || force_erase)
 346     {
 347         if (!st->talking)
 348             return;
 349         XFillRectangle(st->dpy, st->window, st->bg_gc, st->s_rect.x - 5, st->s_rect.y - 5,
 350                        st->s_rect.width + 10, st->s_rect.height + 10);
 351         st->talking = 0;
 352         if (!force_erase)
 353           st->next_fn = move;
 354         st->interval = 0;
 355         {
 356           /* might as well check the st->window for size changes now... */
 357           XWindowAttributes xgwa;
 358           XGetWindowAttributes (st->dpy, st->window, &xgwa);
 359           st->Width = xgwa.width + 2;
 360           st->Height = xgwa.height + 2;
 361         }
 362         return;
 363     }
 364     st->talking = 1;
 365     walk(st, FRONT);
 366     p = st->words;
 367
 368     for (p2 = p; *p2; p2++)
 369       if (*p2 == '\t') *p2 = ' ';
 370
 371     if (!(p2 = strchr(p, '\n')) || !p2[1])
 372       {
 373         total = strlen (st->words);
 374         strcpy (args[0], st->words);
 375         width = XTextWidth(st->font, st->words, total);
 376         height = 0;
 377       }
 378     else
 379       /* p2 now points to the first '\n' */
 380       for (height = 0; p; height++)
 381         {
 382           int             w;
 383           *p2 = 0;
 384           if ((w = XTextWidth(st->font, p, p2 - p)) > width)
 385             width = w;
 386           total += p2 - p;      /* total chars; count to determine reading
 387                                  * time */
 388           (void) strcpy(args[height], p);
 389           if (height == MAXLINES - 1)
 390             {
 391               /* puts("Message too long!"); */
 392               break;
 393             }
 394           p = p2 + 1;
 395           if (!(p2 = strchr(p, '\n')))
 396             break;
 397         }
 398     height++;
 399
 400     /*
 401      * Figure out the height and width in pixels (height, width) extend the
 402      * new box by 15 pixels on the sides (30 total) top and bottom.
 403      */
 404     st->s_rect.width = width + 30;
 405     st->s_rect.height = height * font_height(st->font) + 30;
 406     if (st->x - st->s_rect.width - 10 < 5)
 407         st->s_rect.x = 5;
 408     else if ((st->s_rect.x = st->x + 32 - (st->s_rect.width + 15) / 2)
 409              + st->s_rect.width + 15 > st->Width - 5)
 410         st->s_rect.x = st->Width - 15 - st->s_rect.width;
 411     if (st->y - st->s_rect.height - 10 < 5)
 412         st->s_rect.y = st->y + 64 + 5;
 413     else
 414         st->s_rect.y = st->y - 5 - st->s_rect.height;
 415
 416     XFillRectangle(st->dpy, st->window, st->text_bg_gc,
 417          st->s_rect.x, st->s_rect.y, st->s_rect.width, st->s_rect.height);
 418
 419     /* make a box that's 5 pixels thick. Then add a thin box inside it */
 420     XSetLineAttributes(st->dpy, st->text_fg_gc, 5, 0, 0, 0);
 421     XDrawRectangle(st->dpy, st->window, st->text_fg_gc,
 422                    st->s_rect.x, st->s_rect.y, st->s_rect.width - 1, st->s_rect.height - 1);
 423     XSetLineAttributes(st->dpy, st->text_fg_gc, 0, 0, 0, 0);
 424     XDrawRectangle(st->dpy, st->window, st->text_fg_gc,
 425          st->s_rect.x + 7, st->s_rect.y + 7, st->s_rect.width - 15, st->s_rect.height - 15);
 426
 427     st->X = 15;
 428     st->Y = 15 + font_height(st->font);
 429
 430     /* now print each string in reverse order (start at bottom of box) */
 431     for (Z = 0; Z < height; Z++)
 432     {
 433         int L = strlen(args[Z]);
 434         if (args[Z][L-1] == '\r' || args[Z][L-1] == '\n')
 435           args[Z][--L] = 0;
 436         XDrawString(st->dpy, st->window, st->text_fg_gc, st->s_rect.x + st->X, st->s_rect.y + st->Y,
 437                     args[Z], L);
 438         st->Y += font_height(st->font);
 439     }
 440     st->interval = (total / 15) * 1000;
 441     if (st->interval < 2000) st->interval = 2000;
 442     st->next_fn = talk_1;
 443     *st->words = 0;
 444     st->lines = 0;
 445 }
 446
 447 static void
 448 talk_1 (struct state *st)
 449 {
 450   talk(st, 0);
 451 }
 452
 453
 454 static unsigned long
 455 look (struct state *st)
 456 {
 457     if (random() % 3)
 458     {
 459         COPY(st->dpy, (random() & 1) ? st->down : st->front, st->window, st->fg_gc,
 460              0, 0, 64, 64, st->x, st->y);
 461         return 1000L;
 462     }
 463     if (!(random() % 5))
 464         return 0;
 465     if (random() % 3)
 466     {
 467         COPY(st->dpy, (random() & 1) ? st->left_front : st->right_front,
 468              st->window, st->fg_gc, 0, 0, 64, 64, st->x, st->y);
 469         return 1000L;
 470     }
 471     if (!(random() % 5))
 472         return 0;
 473     COPY(st->dpy, (random() & 1) ? st->left1 : st->right1, st->window, st->fg_gc,
 474          0, 0, 64, 64, st->x, st->y);
 475     return 1000L;
 476 }
 477
 478
 479 static void
 480 fill_words (struct state *st)
 481 {
 482   char *p = st->words + strlen(st->words);
 483   while (p < st->words + sizeof(st->words) - 1 &&
 484          st->lines < MAXLINES)
 485     {
 486       char c = textclient_getc (st->tc);
 487       if (c == '\n')
 488         st->lines++;
 489       if (c > 0)
 490         *p++ = c;
 491       else
 492         break;
 493     }
 494   *p = 0;
 495 }
 496
 497
 498 \f
 499 static const char *noseguy_defaults [] = {
 500   ".background:     black",
 501   ".foreground:     #CCCCCC",
 502   "*textForeground: black",
 503   "*textBackground: #CCCCCC",
 504   "*fpsSolid:    true",
 505   "*program:     xscreensaver-text --cols 40 | head -n15",
 506   "*usePty:      False",
 507   ".font:        -*-new century schoolbook-*-r-*-*-*-180-*-*-*-*-*-*",
 508   0
 509 };
 510
 511 static XrmOptionDescRec noseguy_options [] = {
 512   { "-program",         ".program",             XrmoptionSepArg, 0 },
 513   { "-font",            ".font",                XrmoptionSepArg, 0 },
 514   { "-text-foreground", ".textForeground",      XrmoptionSepArg, 0 },
 515   { "-text-background", ".textBackground",      XrmoptionSepArg, 0 },
 516   { 0, 0, 0, 0 }
 517 };
 518
 519
 520 static void *
 521 noseguy_init (Display *d, Window w)
 522 {
 523   struct state *st = (struct state *) calloc (1, sizeof(*st));
 524   unsigned long fg, bg, text_fg, text_bg;
 525   XWindowAttributes xgwa;
 526   Colormap cmap;
 527   char *fontname;
 528   XGCValues gcvalues;
 529   st->dpy = d;
 530   st->window = w;
 531   st->first_time = 1;
 532
 533   fontname = get_string_resource (st->dpy, "font", "Font");
 534   XGetWindowAttributes (st->dpy, st->window, &xgwa);
 535   st->Width = xgwa.width + 2;
 536   st->Height = xgwa.height + 2;
 537   cmap = xgwa.colormap;
 538
 539   st->program = get_string_resource (st->dpy, "program", "Program");
 540   st->tc = textclient_open (st->dpy);
 541   init_images(st);
 542
 543   if (!fontname || !*fontname)
 544     fprintf (stderr, "%s: no font specified.\n", progname);
 545   st->font = XLoadQueryFont(st->dpy, fontname);
 546   if (!st->font) {
 547     fprintf (stderr, "%s: could not load font %s.\n", progname, fontname);
 548     exit(1);
 549   }
 550
 551   fg = get_pixel_resource (st->dpy, cmap, "foreground", "Foreground");
 552   bg = get_pixel_resource (st->dpy, cmap, "background", "Background");
 553   text_fg = get_pixel_resource (st->dpy, cmap, "textForeground", "Foreground");
 554   text_bg = get_pixel_resource (st->dpy, cmap, "textBackground", "Background");
 555   /* notice when unspecified */
 556   if (! get_string_resource (st->dpy, "textForeground", "Foreground"))
 557     text_fg = bg;
 558   if (! get_string_resource (st->dpy, "textBackground", "Background"))
 559     text_bg = fg;
 560
 561   gcvalues.font = st->font->fid;
 562   gcvalues.foreground = fg;
 563   gcvalues.background = bg;
 564   st->fg_gc = XCreateGC (st->dpy, st->window,
 565                          GCForeground|GCBackground|GCFont,
 566                      &gcvalues);
 567   gcvalues.foreground = bg;
 568   gcvalues.background = fg;
 569   st->bg_gc = XCreateGC (st->dpy, st->window,
 570                          GCForeground|GCBackground|GCFont,
 571                      &gcvalues);
 572   gcvalues.foreground = text_fg;
 573   gcvalues.background = text_bg;
 574   st->text_fg_gc = XCreateGC (st->dpy, st->window,
 575                               GCForeground|GCBackground|GCFont,
 576                           &gcvalues);
 577   gcvalues.foreground = text_bg;
 578   gcvalues.background = text_fg;
 579   st->text_bg_gc = XCreateGC (st->dpy, st->window,
 580                               GCForeground|GCBackground|GCFont,
 581                           &gcvalues);
 582   st->x = st->Width / 2;
 583   st->y = st->Height / 2;
 584   st->state = IS_MOVING;
 585   st->next_fn = move;
 586   st->walk_up = 1;
 587   return st;
 588 }
 589
 590 static unsigned long
 591 noseguy_draw (Display *dpy, Window window, void *closure)
 592 {
 593   struct state *st = (struct state *) closure;
 594   fill_words(st);
 595   st->next_fn(st);
 596   return (st->interval * 1000);
 597 }
 598
 599 static void
 600 noseguy_reshape (Display *dpy, Window window, void *closure,
 601                  unsigned int w, unsigned int h)
 602 {
 603   struct state *st = (struct state *) closure;
 604   st->Width = w + 2;
 605   st->Height = h + 2;
 606 }
 607
 608 static Bool
 609 noseguy_event (Display *dpy, Window window, void *closure, XEvent *event)
 610 {
 611   return False;
 612 }
 613
 614 static void
 615 noseguy_free (Display *dpy, Window window, void *closure)
 616 {
 617   struct state *st = (struct state *) closure;
 618   textclient_close (st->tc);
 619   free (st);
 620 }
 621
 622 XSCREENSAVER_MODULE ("NoseGuy", noseguy)