/* gltext, Copyright (c) 2001-2021 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
 * 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.
 */

#define DEFAULTS	"*delay:	20000        \n" \
			"*showFPS:      False        \n" \
			"*wireframe:    False        \n" \
			"*usePty:       False        \n" \

# define release_text 0
#define SMOOTH_TUBE       /* whether to have smooth or faceted tubes */

#ifdef SMOOTH_TUBE
# define TUBE_FACES  12   /* how densely to render tubes */
#else
# define TUBE_FACES  8
#endif


#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       "xscreensaver-text --date --cols 20 --lines 3"
#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"

#include "glutstroke.h"
#include "glut_roman.h"
#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;
  rotator *rot, *rot2;
  trackball_state *trackball;
  Bool button_down_p;
  Bool spinx, spiny, spinz;

  GLuint text_list;

  int ncolors;
  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_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 },
  { "-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[] = {
  {&text_fmt,      "text",         "Text",         DEF_TEXT,          t_String},
  /* This happens to be what utils/textclient.c reads */
  {&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},
};

ENTRYPOINT ModeSpecOpt text_opts = {countof(opts), opts, countof(vars), vars, NULL};


/* Window management, etc
 */
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, y, (GLint) width, (GLint) height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective (30.0, 1/h, 1.0, 100.0);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt( 0.0, 0.0, 30.0,
             0.0, 0.0, 0.0,
             0.0, 1.0, 0.0);

  {
    GLfloat s = (MI_WIDTH(mi) < MI_HEIGHT(mi)
                 ? (MI_WIDTH(mi) / (GLfloat) MI_HEIGHT(mi))
                 : 1);
    glScalef (s, s, s);
  }

  glClear(GL_COLOR_BUFFER_BIT);
}


static void
gl_init (ModeInfo *mi)
{
  text_configuration *tp = &tps[MI_SCREEN(mi)];
  int wire = MI_IS_WIREFRAME(mi);

  static const GLfloat pos[4] = {5.0, 5.0, 10.0, 1.0};

  if (!wire)
    {
      glLightfv(GL_LIGHT0, GL_POSITION, pos);
      glEnable(GL_CULL_FACE);
      glEnable(GL_LIGHTING);
      glEnable(GL_LIGHT0);
      glEnable(GL_DEPTH_TEST);
    }

  tp->text_list = glGenLists (1);
  glNewList (tp->text_list, GL_COMPILE);
  glEndList ();
}


static void
parse_text (ModeInfo *mi)
{
  text_configuration *tp = &tps[MI_SCREEN(mi)];
  char *old = tp->text;

  const char *tt =
    (text_fmt && *text_fmt && !!strcmp(text_fmt, "(default)")
     ? text_fmt : 0);
  const char *pr =
    (program_str && *program_str && !!strcmp(program_str, "(default)")
     ? program_str : 0);

  /* We used to do some "#ifdef HAVE_UNAME" stuff in here, but 
     "xscreensaver-text --date" does a much better job of that
     by reading random files from /etc/ and such.
   */

  if (tt && !strchr (tt, '%'))		/* Static text with no formatting */
    {
      tp->text = strdup (tt);
      tp->reload = 0;
    }
  else if (tt)				/* Format string */
    {
      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;			/* Clock ticks every second */
    }
  else if (pr)
    {
      int max_lines = max_no_lines;
      char buf[4096];
      char *p = buf;
      int lines = 0;

      if (! tp->tc)
        /* This runs 'pr' because it reads the same "program" resource. */
        tp->tc = textclient_open (mi->dpy);

      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);
      
      if (!*tp->text)
        tp->reload = 1;		/* No output, try again right away */
      else if (!strncmp (pr, "xscreensaver-text --date", 24))
        {
          /* If it's the default, and we have results, there's no need
             to ever reload. */
          tp->reload = 0;
        }
      else
        tp->reload = 7;		/* Linger a bit */
    }
  else
    abort();

  {
    /* The GLUT font only has ASCII characters. */
    char *s1 = utf8_to_latin1 (tp->text, True);
    free (tp->text);
    tp->text = s1;
  }

  /* 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);
}


ENTRYPOINT Bool
text_handle_event (ModeInfo *mi, XEvent *event)
{
  text_configuration *tp = &tps[MI_SCREEN(mi)];

  if (gltrackball_event_handler (event, tp->trackball,
                                 MI_WIDTH (mi), MI_HEIGHT (mi),
                                 &tp->button_down_p))
    return True;

  return False;
}


ENTRYPOINT void 
init_text (ModeInfo *mi)
{
  text_configuration *tp;
  int i;

  MI_INIT (mi, tps);

  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));
  }

  {
    double spin_speed   = 0.5;
    double wander_speed = 0.02;
    double tilt_speed   = 0.03;
    double spin_accel   = 0.5;

    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++;
      }

    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);
  }

  tp->ncolors = 255;
  tp->colors = (XColor *) calloc(tp->ncolors, sizeof(XColor));
  make_smooth_colormap (0, 0, 0,
                        tp->colors, &tp->ncolors,
                        False, 0, False);

  /* 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, int *polysP)
{
  GLfloat tube_width = 10;

  const StrokeCharRec *ch;
  const StrokeRec *stroke;
  const CoordRec *coord;
  StrokeFontPtr fontinfo;
  int i, j;

  fontinfo = (StrokeFontPtr) font;

  if (c < 0 || c >= fontinfo->num_chars)
    return 0;
  ch = &(fontinfo->ch[c]);
  if (ch)
    {
      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)
              *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);
    }
  return 0;
}


static int
text_extents (const char *string, int *wP, int *hP)
{
  const char *s, *start;
  int line_height = GLUT_FONT->top - GLUT_FONT->bottom;
  int lines = 0;
  *wP = 0;
  *hP = 0;
  start = string;
  s = start;
  while (1)
    if (*s == '\n' || *s == 0)
      {
        int w = 0;
        while (start < s)
          {
            w += glutStrokeWidth(GLUT_FONT, *start);
            start++;
          }
        start = s+1;

        if (w > *wP) *wP = w;
        *hP += line_height;
        lines++;
        if (*s == 0) break;
        s++;
      }
    else
      s++;

  return lines;
}


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 ow, oh;
  text_extents (string, &ow, &oh);

  y = oh / 2 - line_height;

  start = string;
  s = start;
  while (1)
    if (*s == '\n' || *s == 0)
      {
        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 = lstart; s2 < lend; s2++)
          line_w += glutStrokeWidth (GLUT_FONT, *s2);

        x = (-ow/2) + ((ow-line_w)/2);
        for (s2 = lstart; s2 < lend; s2++)
          {
            glPushMatrix();
            glTranslatef(x, y, 0);
            off = fill_character (GLUT_FONT, *s2, wire, &polys);
            x += off;
            glPopMatrix();
          }

        start = s+1;

        y -= line_height;
        if (*s == 0) break;
        s++;
      }
    else
      s++;
  return polys;
}


ENTRYPOINT void
draw_text (ModeInfo *mi)
{
  text_configuration *tp = &tps[MI_SCREEN(mi)];
  Display *dpy = MI_DISPLAY(mi);
  Window window = MI_WINDOW(mi);
  int wire = MI_IS_WIREFRAME(mi);

  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);

  {
    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;
  color[1] = tp->colors[tp->ccolor].green / 65536.0;
  color[2] = tp->colors[tp->ccolor].blue  / 65536.0;
  tp->ccolor++;
  if (tp->ccolor >= tp->ncolors) tp->ccolor = 0;

  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);

  glScalef(scale_factor, scale_factor, scale_factor);

  mi->polygon_count = fill_string(tp->text, wire);

  glPopMatrix ();

  if (mi->fps_p) do_fps (mi);
  glFinish();

  glXSwapBuffers(dpy, window);
}

ENTRYPOINT void
free_text(ModeInfo * mi)
{
  text_configuration *tp = &tps[MI_SCREEN(mi)];

  if (!tp->glx_context) return;
  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *tp->glx_context);

  if (tp->tc)
    textclient_close (tp->tc);
  if (tp->text) free (tp->text);
  if (tp->trackball) gltrackball_free (tp->trackball);
  if (tp->rot) free_rotator (tp->rot);
  if (tp->rot2) free_rotator (tp->rot2);
  if (tp->colors) free (tp->colors);
  if (glIsList(tp->text_list)) glDeleteLists(tp->text_list, 1);
}


XSCREENSAVER_MODULE_2 ("GLText", gltext, text)

#endif /* USE_GL */