X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=hacks%2Fglx%2Fgltext.c;h=276c44898293dbe175e3286106b3d944eb480ebf;hb=39809ded547bdbb08207d3e514950425215b4410;hp=07608ee4b7729dbaa2b70cae7ad8f44ad9bcb62e;hpb=3d9140a05b5272fed0883a0af0a71e30ef44d47f;p=xscreensaver

diff --git a/hacks/glx/gltext.c b/hacks/glx/gltext.c
index 07608ee4..276c4489 100644
--- a/hacks/glx/gltext.c
+++ b/hacks/glx/gltext.c
@@ -1,4 +1,4 @@
-/* gltext, Copyright (c) 2001 Jamie Zawinski <jwz@jwz.org>
+/* gltext, Copyright (c) 2001-2017 Jamie Zawinski <jwz@jwz.orgq2
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -9,49 +9,65 @@
  * implied warranty.
  */
 
-#include <X11/Intrinsic.h>
+#define DEFAULTS	"*delay:	20000        \n" \
+			"*showFPS:      False        \n" \
+			"*wireframe:    False        \n" \
+			"*usePty:       False        \n" \
 
-extern XtAppContext app;
+# define release_text 0
+#define SMOOTH_TUBE       /* whether to have smooth or faceted tubes */
 
-#define PROGCLASS	"GLText"
-#define HACK_INIT	init_text
-#define HACK_DRAW	draw_text
-#define HACK_RESHAPE	reshape_text
-#define sws_opts	xlockmore_opts
+#ifdef SMOOTH_TUBE
+# define TUBE_FACES  12   /* how densely to render tubes */
+#else
+# define TUBE_FACES  8
+#endif
 
-#define DEF_TEXT        "(default)"
-
-#define DEFAULTS	"*delay:	10000     \n" \
-			"*showFPS:      False     \n" \
-			"*wireframe:    False     \n" \
-			"*text:       " DEF_TEXT "\n"
 
 #undef countof
 #define countof(x) (sizeof((x))/sizeof((*x)))
 
 #include "xlockmore.h"
 #include "colors.h"
+#include "tube.h"
+#include "sphere.h"
+#include "rotator.h"
+#include "gltrackball.h"
+#include "textclient.h"
+#include "utf8wc.h"
+
+#include <ctype.h>
 
 #ifdef USE_GL /* whole file */
 
+#define DEF_TEXT          "(default)"
+#define DEF_PROGRAM       "(default)"
+#define DEF_SCALE_FACTOR  "0.01"
+#define DEF_WANDER_SPEED  "0.02"
+#define DEF_MAX_LINES     "8"
+#define DEF_SPIN          "XYZ"
+#define DEF_WANDER        "True"
+#define DEF_FACE_FRONT    "True"
+#define DEF_USE_MONOSPACE "False"
+
 #ifdef HAVE_UNAME
 # include <sys/utsname.h>
 #endif /* HAVE_UNAME */
 
-
-#include <GL/glu.h>
 #include "glutstroke.h"
 #include "glut_roman.h"
-#define GLUT_FONT (&glutStrokeRoman)
+#include "glut_mroman.h"
+#define GLUT_VARI_FONT (&glutStrokeRoman)
+#define GLUT_MONO_FONT (&glutStrokeMonoRoman)
+#define GLUT_FONT ((use_monospace) ? GLUT_MONO_FONT : GLUT_VARI_FONT)
 
 
 typedef struct {
   GLXContext *glx_context;
-
-  GLfloat rotx, roty, rotz;	   /* current object rotation */
-  GLfloat dx, dy, dz;		   /* current rotational velocity */
-  GLfloat ddx, ddy, ddz;	   /* current rotational acceleration */
-  GLfloat d_max;		   /* max velocity */
+  rotator *rot, *rot2;
+  trackball_state *trackball;
+  Bool button_down_p;
+  Bool spinx, spiny, spinz;
 
   GLuint text_list;
 
@@ -59,42 +75,90 @@ typedef struct {
   XColor *colors;
   int ccolor;
 
+  char *text;
+  int reload;
+
+  time_t last_update;
+  text_data *tc;
+
 } text_configuration;
 
 static text_configuration *tps = NULL;
 
-static char *text;
+static char   *text_fmt;
+static char   *program_str;
+static float  scale_factor;
+static int    max_no_lines;
+static float  wander_speed;
+static char   *do_spin;
+static Bool   do_wander;
+static Bool   face_front_p;
+static Bool   use_monospace;
 
 static XrmOptionDescRec opts[] = {
-  { "-text",   ".text",   XrmoptionSepArg, 0 }
+  { "-text",         ".text",         XrmoptionSepArg, 0 },
+  { "-program",      ".program",      XrmoptionSepArg, 0 },
+  { "-scale",        ".scaleFactor",  XrmoptionSepArg, 0 },
+  { "-maxlines",     ".maxLines",     XrmoptionSepArg, 0 },
+  { "-wander-speed", ".wanderSpeed",  XrmoptionSepArg, 0 },
+  { "-spin",         ".spin",         XrmoptionSepArg, 0 },
+  { "+spin",         ".spin",         XrmoptionNoArg, "" },
+  { "-wander",       ".wander",       XrmoptionNoArg, "True" },
+  { "+wander",       ".wander",       XrmoptionNoArg, "False" },
+  { "-front",        ".faceFront",    XrmoptionNoArg, "True" },
+  { "+front",        ".faceFront",    XrmoptionNoArg, "False" },
+  { "-mono",         ".useMonoSpace", XrmoptionNoArg, "True" },
+  { "+mono",         ".useMonoSpace", XrmoptionNoArg, "False" }
 };
 
 static argtype vars[] = {
-  {(caddr_t *) &text, "text", "Text", DEF_TEXT, t_String},
+  {&text_fmt,      "text",         "Text",         DEF_TEXT,          t_String},
+  {&program_str,   "program",      "Program",      DEF_PROGRAM,       t_String},
+  {&do_spin,       "spin",         "Spin",         DEF_SPIN,          t_String},
+  {&scale_factor,  "scaleFactor",  "ScaleFactor",  DEF_SCALE_FACTOR,  t_Float},
+  {&max_no_lines,  "maxLines",     "MaxLines",     DEF_MAX_LINES,     t_Int},
+  {&wander_speed,  "wanderSpeed",  "WanderSpeed",  DEF_WANDER_SPEED,  t_Float},
+  {&do_wander,     "wander",       "Wander",       DEF_WANDER,        t_Bool},
+  {&face_front_p,  "faceFront",    "FaceFront",    DEF_FACE_FRONT,    t_Bool},
+  {&use_monospace, "useMonoSpace", "UseMonoSpace", DEF_USE_MONOSPACE, t_Bool},
 };
 
-ModeSpecOpt sws_opts = {countof(opts), opts, countof(vars), vars, NULL};
+ENTRYPOINT ModeSpecOpt text_opts = {countof(opts), opts, countof(vars), vars, NULL};
 
 
 /* Window management, etc
  */
-void
+ENTRYPOINT void
 reshape_text (ModeInfo *mi, int width, int height)
 {
   GLfloat h = (GLfloat) height / (GLfloat) width;
+  int y = 0;
+
+  if (width > height * 5) {   /* tiny window: show middle */
+    height = width * 9/16;
+    y = -height/2;
+    h = height / (GLfloat) width;
+  }
 
-  glViewport (0, 0, (GLint) width, (GLint) height);
+  glViewport (0, y, (GLint) width, (GLint) height);
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
+  gluPerspective (30.0, 1/h, 1.0, 100.0);
 
-  gluPerspective( 30.0, 1/h, 1.0, 100.0 );
-  gluLookAt( 0.0, 0.0, 15.0,
-             0.0, 0.0, 0.0,
-             0.0, 1.0, 0.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
-  glTranslatef(0.0, 0.0, -15.0);
+  gluLookAt( 0.0, 0.0, 30.0,
+             0.0, 0.0, 0.0,
+             0.0, 1.0, 0.0);
+
+# ifdef HAVE_MOBILE	/* Keep it the same relative size when rotated. */
+  {
+    int o = (int) current_device_rotation();
+    if (o != 0 && o != 180 && o != -180)
+      glScalef (1/h, 1/h, 1/h);
+  }
+# endif
 
   glClear(GL_COLOR_BUFFER_BIT);
 }
@@ -106,7 +170,7 @@ gl_init (ModeInfo *mi)
   text_configuration *tp = &tps[MI_SCREEN(mi)];
   int wire = MI_IS_WIREFRAME(mi);
 
-  static GLfloat pos[4] = {5.0, 5.0, 10.0, 1.0};
+  static const GLfloat pos[4] = {5.0, 5.0, 10.0, 1.0};
 
   if (!wire)
     {
@@ -123,258 +187,235 @@ gl_init (ModeInfo *mi)
 }
 
 
-/* lifted from lament.c */
-#define RAND(n) ((long) ((random() & 0x7fffffff) % ((long) (n))))
-#define RANDSIGN() ((random() & 1) ? 1 : -1)
-
 static void
-rotate(GLfloat *pos, GLfloat *v, GLfloat *dv, GLfloat max_v)
+parse_text (ModeInfo *mi)
 {
-  double ppos = *pos;
-
-  /* tick position */
-  if (ppos < 0)
-    ppos = -(ppos + *v);
-  else
-    ppos += *v;
-
-  if (ppos > 1.0)
-    ppos -= 1.0;
-  else if (ppos < 0)
-    ppos += 1.0;
-
-  if (ppos < 0) abort();
-  if (ppos > 1.0) abort();
-  *pos = (*pos > 0 ? ppos : -ppos);
-
-  /* accelerate */
-  *v += *dv;
+  text_configuration *tp = &tps[MI_SCREEN(mi)];
+  char *old = tp->text;
 
-  /* clamp velocity */
-  if (*v > max_v || *v < -max_v)
+  if (program_str && *program_str && !!strcmp(program_str, "(default)"))
     {
-      *dv = -*dv;
-    }
-  /* If it stops, start it going in the other direction. */
-  else if (*v < 0)
-    {
-      if (random() % 4)
-	{
-	  *v = 0;
-
-	  /* keep going in the same direction */
-	  if (random() % 2)
-	    *dv = 0;
-	  else if (*dv < 0)
-	    *dv = -*dv;
-	}
-      else
-	{
-	  /* reverse gears */
-	  *v = -*v;
-	  *dv = -*dv;
-	  *pos = -*pos;
-	}
-    }
+      int max_lines = max_no_lines;
+      char buf[4096];
+      char *p = buf;
+      int lines = 0;
 
-  /* Alter direction of rotational acceleration randomly. */
-  if (! (random() % 120))
-    *dv = -*dv;
+      if (! tp->tc)
+        tp->tc = textclient_open (mi->dpy);
 
-  /* Change acceleration very occasionally. */
-  if (! (random() % 200))
-    {
-      if (*dv == 0)
-	*dv = 0.00001;
-      else if (random() & 1)
-	*dv *= 1.2;
-      else
-	*dv *= 0.8;
-    }
-}
+      while (p < buf + sizeof(buf) - 1 &&
+             lines < max_lines)
+        {
+          int c = textclient_getc (tp->tc);
+          if (c == '\n')
+            lines++;
+          if (c > 0)
+            *p++ = (char) c;
+          else
+            break;
+        }
+      *p = 0;
+      if (lines == 0 && buf[0])
+        lines++;
 
+      tp->text = strdup (buf);
+      
+      tp->reload = 7;  /* Let this one linger for a few seconds */
+      if (!*tp->text)
+        tp->reload = 1;
 
-void 
-init_text (ModeInfo *mi)
-{
-  text_configuration *tp;
-
-  if (!tps) {
-    tps = (text_configuration *)
-      calloc (MI_NUM_SCREENS(mi), sizeof (text_configuration));
-    if (!tps) {
-      fprintf(stderr, "%s: out of memory\n", progname);
-      exit(1);
     }
-
-    tp = &tps[MI_SCREEN(mi)];
-  }
-
-  tp = &tps[MI_SCREEN(mi)];
-
-  if ((tp->glx_context = init_GL(mi)) != NULL) {
-    gl_init(mi);
-    reshape_text (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
-  }
-
-  tp->rotx = frand(1.0) * RANDSIGN();
-  tp->roty = frand(1.0) * RANDSIGN();
-  tp->rotz = frand(1.0) * RANDSIGN();
-
-  /* bell curve from 0-6 degrees, avg 3 */
-  tp->dx = (frand(1) + frand(1) + frand(1)) / (360/2);
-  tp->dy = (frand(1) + frand(1) + frand(1)) / (360/2);
-  tp->dz = (frand(1) + frand(1) + frand(1)) / (360/2);
-
-  tp->d_max = tp->dx * 2;
-
-  tp->ddx = 0.00006 + frand(0.00003);
-  tp->ddy = 0.00006 + frand(0.00003);
-  tp->ddz = 0.00006 + frand(0.00003);
-
-  tp->ddx = 0.00001;
-  tp->ddy = 0.00001;
-  tp->ddz = 0.00001;
-
-  if (!text || !*text || !strcmp(text, "(default)"))
+  else if (!text_fmt || !*text_fmt || !strcmp(text_fmt, "(default)"))
     {
 # ifdef HAVE_UNAME
       struct utsname uts;
 
       if (uname (&uts) < 0)
         {
-          text = strdup("uname() failed");
+          tp->text = strdup("uname() failed");
         }
       else
         {
           char *s;
           if ((s = strchr(uts.nodename, '.')))
             *s = 0;
-          text = (char *) malloc(strlen(uts.nodename) +
-                                 strlen(uts.sysname) +
-                                 strlen(uts.version) +
-                                 strlen(uts.release) + 10);
-#  ifdef _AIX
-          sprintf(text, "%s\n%s %s.%s",
+          tp->text = (char *) malloc(strlen(uts.nodename) +
+                                     strlen(uts.sysname) +
+                                     strlen(uts.version) +
+                                     strlen(uts.release) + 10);
+#  if defined(_AIX)
+          sprintf(tp->text, "%s\n%s %s.%s",
                   uts.nodename, uts.sysname, uts.version, uts.release);
-#  else  /* !_AIX */
-          sprintf(text, "%s\n%s %s",
+#  elif defined(USE_IPHONE)
+          /* "My iPhone\n iPhone4,1\n Darwin 11.0.0" */
+          sprintf(tp->text, "%s\n%s\n%s %s",
+                  uts.nodename, uts.machine, uts.sysname, uts.release);
+#  elif defined(__APPLE__)  /* MacOS X + XDarwin */
+          {
+            const char *file = 
+              "/System/Library/CoreServices/SystemVersion.plist";
+            FILE *f = fopen (file, "r");
+            char *pbv = 0, *pn = 0, *puvv = 0;
+            if (f) {
+              char *s, buf[255];
+
+              while (fgets (buf, sizeof(buf)-1, f)) {
+#               define GRAB(S,V)					\
+                if (strstr(buf, S)) {					\
+                  fgets (buf, sizeof(buf)-1, f);			\
+                  if ((s = strchr (buf, '>'))) V = strdup(s+1); 	\
+                  if ((s = strchr (V, '<'))) *s = 0;		 	\
+                }
+                GRAB ("ProductName", pn)
+                GRAB ("ProductBuildVersion", pbv)
+                GRAB ("ProductUserVisibleVersion", puvv)
+#               undef GRAB
+              }
+            }
+            if (pbv)
+              sprintf (tp->text, "%s\n%s\n%s\n%s", 
+                       uts.nodename, pn, puvv, uts.machine);
+            else
+              sprintf(tp->text, "%s\n%s %s\n%s",
+                      uts.nodename, uts.sysname, uts.release, uts.machine);
+          }
+#  else
+          sprintf(tp->text, "%s\n%s %s",
                   uts.nodename, uts.sysname, uts.release);
-#  endif /* !_AIX */
+#  endif /* special system types */
         }
 # else	/* !HAVE_UNAME */
 #  ifdef VMS
-      text = strdup(getenv("SYS$NODE"));
+      tp->text = strdup(getenv("SYS$NODE"));
 #  else
-      text = strdup("*  *\n*  *  *\nxscreensaver\n*  *  *\n*  *");
+      tp->text = strdup("*  *\n*  *  *\nxscreensaver\n*  *  *\n*  *");
 #  endif
 # endif	/* !HAVE_UNAME */
     }
+  else if (!strchr (text_fmt, '%'))
+    {
+      tp->text = strdup (text_fmt);
+    }
+  else
+    {
+      time_t now = time ((time_t *) 0);
+      struct tm *tm = localtime (&now);
+      int L = strlen(text_fmt) + 100;
+      tp->text = (char *) malloc (L);
+      *tp->text = 0;
+      strftime (tp->text, L-1, text_fmt, tm);
+      if (!*tp->text)
+        sprintf (tp->text, "strftime error:\n%s", text_fmt);
+      tp->reload = 1;
+    }
 
+  {
+    /* The GLUT font only has ASCII characters. */
+    char *s1 = utf8_to_latin1 (tp->text, True);
+    free (tp->text);
+    tp->text = s1;
+  }
 
-  tp->ncolors = 255;
-  tp->colors = (XColor *) calloc(tp->ncolors, sizeof(XColor));
-  make_smooth_colormap (0, 0, 0,
-                        tp->colors, &tp->ncolors,
-                        False, 0, False);
+  /* If we had text before but got no text this time, hold on to the
+     old one, to avoid flickering.
+   */
+  if (old && *old && !*tp->text)
+    {
+      free (tp->text);
+      tp->text = old;
+    }
+  else if (old)
+    free (old);
 }
 
 
-static void
-unit_tube (Bool wire)
+ENTRYPOINT Bool
+text_handle_event (ModeInfo *mi, XEvent *event)
 {
-  int i;
-  GLfloat d3 = 0.2075;
-
-  glPushMatrix();
-
-  if (!wire)
-    glShadeModel(GL_SMOOTH);
-
-  glFrontFace(GL_CCW);
-
-  for (i = 0; i < 8; i++)
-    {
-      glNormal3f(1, 0, 0);
-      glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
-      glVertex3f(0.5, 0.0, -d3); glVertex3f(0.5, 1.0, -d3);
-      glVertex3f(0.5, 1.0,  d3); glVertex3f(0.5, 0.0,  d3);
-      glEnd();
-      glRotatef(45, 0, 1, 0);
-    }
+  text_configuration *tp = &tps[MI_SCREEN(mi)];
 
-  if (! wire)
-    {
-      glNormal3f(0, -1, 0);
-      glBegin(GL_TRIANGLE_FAN);
-      glVertex3f(0, 0, 0);
-      glVertex3f(-d3,  0, -0.5); glVertex3f( d3,  0, -0.5);
-      glVertex3f( 0.5, 0, -d3);  glVertex3f( 0.5, 0,  d3);
-      glVertex3f( d3,  0,  0.5); glVertex3f(-d3,  0,  0.5);
-      glVertex3f(-0.5, 0,  d3);  glVertex3f(-0.5, 0, -d3);
-      glVertex3f(-d3,  0, -0.5); glVertex3f( d3,  0, -0.5);
-
-      glEnd();
-
-      glTranslatef(0, 1, 0);
-
-      glNormal3f(0, 1, 0);
-      glBegin(GL_TRIANGLE_FAN);
-      glVertex3f(0, 0, 0);
-      glVertex3f(-0.5, 0, -d3);  glVertex3f(-0.5, 0,  d3); 
-      glVertex3f(-d3,  0,  0.5); glVertex3f( d3,  0,  0.5); 
-      glVertex3f( 0.5, 0,  d3);  glVertex3f( 0.5, 0, -d3); 
-      glVertex3f( d3,  0, -0.5); glVertex3f(-d3,  0, -0.5); 
-      glVertex3f(-0.5, 0, -d3);  glVertex3f(-0.5, 0,  d3); 
-      glEnd();
-    }
+  if (gltrackball_event_handler (event, tp->trackball,
+                                 MI_WIDTH (mi), MI_HEIGHT (mi),
+                                 &tp->button_down_p))
+    return True;
 
-  glPopMatrix();
+  return False;
 }
 
 
-static void
-tube (GLfloat x1, GLfloat y1, 
-      GLfloat x2, GLfloat y2,
-      GLfloat z,
-      GLfloat diameter,
-      Bool wire)
+ENTRYPOINT void 
+init_text (ModeInfo *mi)
 {
-  GLfloat length, rot;
+  text_configuration *tp;
+  int i;
 
-  if (y1 == y2) y2 += 0.01;  /* waah... */
+  MI_INIT (mi, tps);
 
-  length = sqrt(((x2-x1)*(x2-x1)) +
-                ((y2-y1)*(y2-y1)));
+  tp = &tps[MI_SCREEN(mi)];
 
-  rot = (acos((x2-x1)/length)
-         / (M_PI / 180));
+  if ((tp->glx_context = init_GL(mi)) != NULL) {
+    gl_init(mi);
+    reshape_text (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
+  }
 
-  if (rot < 0 || rot > 180) abort();
-  if (y1 <= y2) rot = -rot;
+  {
+    double spin_speed   = 0.5;
+    double wander_speed = 0.02;
+    double tilt_speed   = 0.03;
+    double spin_accel   = 0.5;
 
-  rot = 180-rot;
+    char *s = do_spin;
+    while (*s)
+      {
+        if      (*s == 'x' || *s == 'X') tp->spinx = True;
+        else if (*s == 'y' || *s == 'Y') tp->spiny = True;
+        else if (*s == 'z' || *s == 'Z') tp->spinz = True;
+        else if (*s == '0') ;
+        else
+          {
+            fprintf (stderr,
+         "%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n",
+                     progname, do_spin);
+            exit (1);
+          }
+        s++;
+      }
 
-  if (diameter < 0) abort();
-  if (length < 0) abort();
+    tp->rot = make_rotator (tp->spinx ? spin_speed : 0,
+                            tp->spiny ? spin_speed : 0,
+                            tp->spinz ? spin_speed : 0,
+                            spin_accel,
+                            do_wander ? wander_speed : 0,
+                            False);
+    tp->rot2 = (face_front_p
+                ? make_rotator (0, 0, 0, 0, tilt_speed, True)
+                : 0);
+    tp->trackball = gltrackball_init (False);
+  }
 
-  glPushMatrix();
+  tp->ncolors = 255;
+  tp->colors = (XColor *) calloc(tp->ncolors, sizeof(XColor));
+  make_smooth_colormap (0, 0, 0,
+                        tp->colors, &tp->ncolors,
+                        False, 0, False);
 
-  glTranslatef(x1, y1, z);
-  glRotatef(rot+90, 0, 0, 1);
-  glTranslatef(0, -diameter/8, 0);
-  glScalef (diameter, length+diameter/4, diameter);
-  unit_tube (wire);
-  glPopMatrix();
-  
-}
+  /* brighter colors, please... */
+  for (i = 0; i < tp->ncolors; i++)
+    {
+      tp->colors[i].red   = (tp->colors[i].red   / 2) + 32767;
+      tp->colors[i].green = (tp->colors[i].green / 2) + 32767;
+      tp->colors[i].blue  = (tp->colors[i].blue  / 2) + 32767;
+    }
 
+  parse_text (mi);
+
+}
 
 
 static int
-fill_character (GLUTstrokeFont font, int c, Bool wire)
+fill_character (GLUTstrokeFont font, int c, Bool wire, int *polysP)
 {
-  int tube_width = 20;
+  GLfloat tube_width = 10;
 
   const StrokeCharRec *ch;
   const StrokeRec *stroke;
@@ -389,19 +430,40 @@ fill_character (GLUTstrokeFont font, int c, Bool wire)
   ch = &(fontinfo->ch[c]);
   if (ch)
     {
-      GLfloat lx, ly;
+      GLfloat lx=0, ly=0;
       for (i = ch->num_strokes, stroke = ch->stroke;
            i > 0; i--, stroke++) {
         for (j = stroke->num_coords, coord = stroke->coord;
              j > 0; j--, coord++)
           {
+# ifdef SMOOTH_TUBE
+            int smooth = True;
+# else
+            int smooth = False;
+# endif
+
             if (j != stroke->num_coords)
-              tube (lx, ly, coord->x, coord->y, 0, tube_width, wire);
+              *polysP += tube (lx,       ly,       0,
+                               coord->x, coord->y, 0,
+                               tube_width,
+                               tube_width * 0.15,
+                               TUBE_FACES, smooth, False, wire);
             lx = coord->x;
             ly = coord->y;
+
+            /* Put a sphere at the endpoint of every line segment.  Wasteful
+               on curves like "0" but necessary on corners like "4". */
+            if (! wire)
+              {
+                glPushMatrix();
+                glTranslatef (lx, ly, 0);
+                glScalef (tube_width, tube_width, tube_width);
+                *polysP += unit_sphere (TUBE_FACES, TUBE_FACES, wire);
+                glPopMatrix();
+              }
           }
       }
-      return (int) (ch->right + tube_width/2);
+      return (int) (ch->right + tube_width);
     }
   return 0;
 }
@@ -430,9 +492,9 @@ text_extents (const char *string, int *wP, int *hP)
 
         if (w > *wP) *wP = w;
         *hP += line_height;
-        s++;
         lines++;
         if (*s == 0) break;
+        s++;
       }
     else
       s++;
@@ -441,17 +503,17 @@ text_extents (const char *string, int *wP, int *hP)
 }
 
 
-static void
+static unsigned long
 fill_string (const char *string, Bool wire)
 {
+  int polys = 0;
   const char *s, *start;
   int line_height = GLUT_FONT->top - GLUT_FONT->bottom;
   int off;
   GLfloat x = 0, y = 0;
-  int lines;
 
   int ow, oh;
-  lines = text_extents (string, &ow, &oh);
+  text_extents (string, &ow, &oh);
 
   y = oh / 2 - line_height;
 
@@ -462,32 +524,42 @@ fill_string (const char *string, Bool wire)
       {
         int line_w = 0;
         const char *s2;
+        const char *lstart = start;
+        const char *lend = s;
+
+        /* strip off whitespace at beginning and end of line
+           (since we're centering.) */
+        while (lend > lstart && isspace(lend[-1]))
+          lend--;
+        while (lstart < lend && isspace(*lstart))
+          lstart++;
 
-        for (s2 = start; s2 < s; s2++)
+        for (s2 = lstart; s2 < lend; s2++)
           line_w += glutStrokeWidth (GLUT_FONT, *s2);
 
         x = (-ow/2) + ((ow-line_w)/2);
-        while (start < s)
+        for (s2 = lstart; s2 < lend; s2++)
           {
             glPushMatrix();
             glTranslatef(x, y, 0);
-            off = fill_character (GLUT_FONT, *start, wire);
+            off = fill_character (GLUT_FONT, *s2, wire, &polys);
             x += off;
             glPopMatrix();
-            start++;
           }
+
         start = s+1;
 
         y -= line_height;
-        s++;
         if (*s == 0) break;
+        s++;
       }
     else
       s++;
+  return polys;
 }
 
 
-void
+ENTRYPOINT void
 draw_text (ModeInfo *mi)
 {
   text_configuration *tp = &tps[MI_SCREEN(mi)];
@@ -495,52 +567,63 @@ draw_text (ModeInfo *mi)
   Window window = MI_WINDOW(mi);
   int wire = MI_IS_WIREFRAME(mi);
 
-  static GLfloat color[4] = {0.0, 0.0, 0.0, 1.0};
-  static GLfloat white[4] = {1.0, 1.0, 1.0, 1.0};
+  GLfloat white[4] = {1.0, 1.0, 1.0, 1.0};
+  GLfloat color[4] = {0.0, 0.0, 0.0, 1.0};
 
   if (!tp->glx_context)
     return;
 
+  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(tp->glx_context));
+
+  if (tp->reload)
+    {
+      if (time ((time_t *) 0) >= tp->last_update + tp->reload)
+        {
+          parse_text (mi);
+          tp->last_update = time ((time_t *) 0);
+        }
+    }
+
   glShadeModel(GL_SMOOTH);
 
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_NORMALIZE);
   glEnable(GL_CULL_FACE);
 
+
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
   glPushMatrix ();
-
   glScalef(1.1, 1.1, 1.1);
+  glRotatef(current_device_rotation(), 0, 0, 1);
 
   {
-    static int frame = 0;
-    GLfloat x, y, z;
-
-#   define SINOID(SCALE,SIZE) \
-      ((((1 + sin((frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2)
-    x = SINOID(0.031, 9.0);
-    y = SINOID(0.023, 9.0);
-    z = SINOID(0.017, 9.0);
-    frame++;
-    glTranslatef(x, y, z);
-
-    x = tp->rotx;
-    y = tp->roty;
-    z = tp->rotz;
-    if (x < 0) x = 1 - (x + 1);
-    if (y < 0) y = 1 - (y + 1);
-    if (z < 0) z = 1 - (z + 1);
-
-    glRotatef(x * 360, 1.0, 0.0, 0.0);
-    glRotatef(y * 360, 0.0, 1.0, 0.0);
-    glRotatef(z * 360, 0.0, 0.0, 1.0);
-
-    rotate(&tp->rotx, &tp->dx, &tp->ddx, tp->d_max);
-    rotate(&tp->roty, &tp->dy, &tp->ddy, tp->d_max);
-    rotate(&tp->rotz, &tp->dz, &tp->ddz, tp->d_max);
+    double x, y, z;
+    get_position (tp->rot, &x, &y, &z, !tp->button_down_p);
+    glTranslatef((x - 0.5) * 8,
+                 (y - 0.5) * 8,
+                 (z - 0.5) * 8);
+
+    gltrackball_rotate (tp->trackball);
+
+    if (face_front_p)
+      {
+        double max = 90;
+        get_position (tp->rot2, &x, &y, &z, !tp->button_down_p);
+        if (tp->spinx) glRotatef (max/2 - x*max, 1, 0, 0);
+        if (tp->spiny) glRotatef (max/2 - y*max, 0, 1, 0);
+        if (tp->spinz) glRotatef (max/2 - z*max, 0, 0, 1);
+      }
+    else
+      {
+        get_rotation (tp->rot, &x, &y, &z, !tp->button_down_p);
+        glRotatef (x * 360, 1, 0, 0);
+        glRotatef (y * 360, 0, 1, 0);
+        glRotatef (z * 360, 0, 0, 1);
+      }
   }
 
+
   glColor4fv (white);
 
   color[0] = tp->colors[tp->ccolor].red   / 65536.0;
@@ -551,8 +634,9 @@ draw_text (ModeInfo *mi)
 
   glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
 
-  glScalef(0.01, 0.01, 0.01);
-  fill_string(text, wire);
+  glScalef(scale_factor, scale_factor, scale_factor);
+
+  mi->polygon_count = fill_string(tp->text, wire);
 
   glPopMatrix ();
 
@@ -562,4 +646,15 @@ draw_text (ModeInfo *mi)
   glXSwapBuffers(dpy, window);
 }
 
+ENTRYPOINT void
+free_text(ModeInfo * mi)
+{
+  text_configuration *tp = &tps[MI_SCREEN(mi)];
+  if (tp->tc)
+    textclient_close (tp->tc);
+}
+
+
+XSCREENSAVER_MODULE_2 ("GLText", gltext, text)
+
 #endif /* USE_GL */