---

text.c

/*
 *  text.c - Text handling routinges
 *           This file is part of the FreeLCD package.
 *
 *  $Id: text_8c-source.html,v 1.1 2003/02/16 22:50:41 unicorn Exp $
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 2 of the License, or (at your
 *  option) any later version.
 * 
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *  Copyright (c) 2002, 2003, Jeroen van den Berg <unicorn@hippie.nu>
 */

#include <stdlib.h>
#include <string.h>

#include <common/xmalloc.h>
#include "text.h"

static char *
_find_position (text_buf * b, int x, int y)
{
  return b->buf + y * b->width + x;
}

static const char *
_find_position_const (const text_buf * b, int x, int y)
{
  return b->buf + y * b->width + x;
}

/*-------------------------------------------------- _check_expand_buf --*/
static void
_check_expand_buf (text_buf * b, int ypos)
{
  ++ypos;

  if (b->reserved_h < ypos)
    {
      b->reserved_h = ypos * 1.5;
      b->buf = xrealloc (b->buf, b->width * b->reserved_h);
    }

  if (b->height < ypos)
    b->height = ypos;
}

/*-------------------------------------------------------- _cursor_ptr --*/
static char *
_cursor_ptr (text_buf * b)
{
  int x = b->cursor_x;

  if (x < 0)
    x = 0;

  _check_expand_buf (b, b->cursor_y);

  return _find_position (b, x, b->cursor_y);
}

/*----------------------------------------------------------- _newline --*/
static void
_newline (text_buf * b)
{
  if (b->cursor_x == 0)
    return;

  b->cursor_x = 0;
  ++b->cursor_y;
  _check_expand_buf (b, b->cursor_y);
  memset (_cursor_ptr (b), ' ', b->width);
}

/*------------------------------------------ _find_next_word_delimiter --*/
static const char *
_find_next_word_delimiter (const char *text)
{
  while (*text && *text != ' ')
    ++text;

  return text;
}

/*----------------------------------------------------- _is_whitespace --*/
static int
_is_whitespace (const char *p, int step, int count)
{
  for (; count; --count, p += step)
    {
      if (*p != ' ')
        return 0;
    }

  return 1;
}

/*---------------------------------------------------- text_buf_malloc --*/
text_buf *
text_buf_malloc (int width, int height)
{
  text_buf *new = xmalloc (sizeof (text_buf));

  new->width = width;
  new->height = height;
  new->reserved_h = height;
  new->cursor_x = 0;
  new->cursor_y = 0;
  new->buf = xmalloc (width * height);
  memset (new->buf, ' ', width * height);

  return new;
}

/*------------------------------------------------------ text_buf_free --*/
void
text_buf_free (text_buf * b)
{
  free (b->buf);
  free (b);
}

/*--------------------------------------------------------- text_print --*/
void
text_print (text_buf * b, const char *text)
{
  int startpos = b->cursor_x < 0 ? -(b->cursor_x) : 0;
  int chars = b->width - startpos;
  int len = strlen (text);

  if (b->cursor_y < 0 || b->cursor_x >= b->width || b->cursor_x + len <= 0)
    {
      /*  The text being printed will never show up inside the buffer,
       *  so we can just move the cursor and ignore everything else.
       */
      b->cursor_x += len;
      return;
    }

  memcpy (_cursor_ptr (b), text + startpos, chars);
}

/*---------------------------------------------------- text_print_wrap --*/
void
text_print_wrap (text_buf * b, const char *text)
{
  char add_hyphen;
  const char *pos;
  const char *brk;
  int wordlen;

  while (*text)
    {
      pos = _find_next_word_delimiter (text);
      wordlen = pos - text;
      add_hyphen = 0;

      /*  If the current word does not fit on this line, consider moving
       *  to the next line. This might not be necessary in case the word 
       *  is too long to fit on a single line, in that case it will be
       *  hyphenated. If it contains a hyphen already, use that one. If
       *  not, break it right before the end.
       */
      if (b->cursor_x + wordlen >= b->width)
        {
          brk = text + b->width - b->cursor_x - 1;
          while (brk > text && *brk != '-')
            --brk;

          if (brk > text)
            wordlen = brk - text + 1;
          else
            {
              if (wordlen > b->width)
                {
                  wordlen = (b->width - b->cursor_x - 1);
                  if (wordlen < 4)      /* Don't bother with one or two chars */
                    wordlen = 0;
                  else
                    add_hyphen = 1;

                }
              else
                {
                  wordlen = 0;
                }
            }
        }

      if (wordlen == 0)         /* If nothing fits, move to the next line */
        {
          _newline (b);
        }
      else
        {
          memcpy (_cursor_ptr (b), text, wordlen);
          b->cursor_x += wordlen;
          if (b->cursor_x < b->width)
            {
              *(_cursor_ptr (b)) = ' ';
              ++b->cursor_x;
            }
          text += wordlen;
          while (*text && *text == ' ') /* Go to beginning of next word */
            ++text;
        }
    }
}

/*--------------------------------------------- text_add_centered_line --*/
void
text_add_centered_line (text_buf * b, const char *text,
                        char filler, char left_end, char right_end)
{
  int len = strlen (text);
  int space;
  int i;
  char *p;

  if (len > b->width)
    {
      text += len / 2;
      len = b->width;
    }

  space = (b->width - len) / 2;
  _newline (b);
  p = _cursor_ptr (b);

  for (i = 0; i < space - 1; ++i)
    *p++ = filler;
  for (; i < space; ++i)
    *p++ = left_end;
  for (; i < b->width - space; ++i)
    *p++ = *text ? *text++ : ' ';
  for (; i < b->width - (space - 1); ++i)
    *p++ = right_end;
  for (; i < b->width; ++i)
    *p++ = filler;

  ++b->cursor_x;
  _newline (b);
}

/*--------------------------------------------------- text_copy_region --*/
text_buf *
text_copy_region (const text_buf * b, int x, int y, int w, int h)
{
  /* TODO: add extra checks for regions outside buffer bounds */

  text_buf *newbuf = text_buf_malloc (w, h);
  const char *src = _find_position_const (b, x, y);
  char *dest = newbuf->buf;
  int i;

  for (i = 0; i < h; ++i)
    {
      memcpy (dest, src, w);
      dest += w;
      src += b->width;
    }

  return newbuf;
}

/*-------------------------------------------------- text_paste_region --*/
void
text_paste_region (text_buf * dest, const text_buf * source, int x, int y)
{
  /* TODO: add extra checks for regions outside buffer bounds */

  const char *sbuf = source->buf;
  char *dbuf = _find_position (dest, x, y);
  int i;

  for (i = 0; i < source->height; ++i)
    {
      memcpy (dbuf, sbuf, source->width);
      sbuf += source->width;
      dbuf += dest->width;
    }
}

/*---------------------------------------------------------- text_crop --*/
void
text_crop (text_buf * b, int top, int bottom, int left, int right)
{
  char *src = _find_position (b, top, left);
  char *dest = b->buf;
  int new_width = b->width - (left + right);
  int new_height = b->height - (top + bottom);
  int i;

  for (i = 0; i < new_height; ++i)
    {
      memcpy (dest, src, new_width);
      src += new_width;
      dest += b->width;
    }

  b->buf = xrealloc (b->buf, new_width * new_height);
  b->width = new_width;
  b->height = new_height;
  b->reserved_h = new_height;
  b->cursor_x = 0;
  b->cursor_y = 0;
}

/*------------------------------------------------------ text_autocrop --*/
void
text_autocrop (text_buf * b)
{
  int top = 0;
  int bottom = 0;
  int left = 0;
  int right = 0;
  int size = b->width * b->height;

  if (size == 0)
    return;

  /*  Use the _is_whitespace helper function to find horizontal lines
   *  of whitespace at the top and bottom of the buffer. Move down (or
   *  up in the case of "bottom") until a non-whitespace line is found.
   */
  while (top < b->height
         && _is_whitespace (_find_position_const (b, top, 0), 1, b->width))
    {
      ++top;
    }

  while (bottom < b->height - top
         &&
         _is_whitespace (_find_position_const (b, b->height - bottom - 1, 0),
                         1, b->width))
    {
      ++bottom;
    }

  /*  Same thing, but for left and right sides. Instead of the value 1,
   *  the buffer width is now passed as the step size to _is_whitespace,
   *  so a vertical line is checked. Also, the previously found top and
   *  bottom values are used here to restrict the searched area.
   */
  while (left < b->width
         && _is_whitespace (_find_position_const (b, top, left), b->width,
                            b->height - (top + bottom)))
    {
      ++left;
    }

  while (right < b->width - left
         && _is_whitespace (_find_position_const (b, top + 1, -right + 1),
                            b->width, b->height - (top + bottom)))
    {
      ++right;
    }

  text_crop (b, top, bottom, left, right);
}

---