---

charlayout.c

Go to the documentation of this file.

/*
 *  charlayout.c - Character-based layout algorithm.
 *                 This file is part of the FreeLCD package.
 *  
 *  $Id: charlayout_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 <[email protected]>
 */


#include <stdio.h>
#include <string.h>
#include <assert.h>

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

/*------------------------------------------------------------------------*/
/* XML dictionaries */
 
typedef enum
{
  ROW = 1, COL, FIELD
} 
tag_t;

static tag_t cl_tagindex_[] =
{
  ROW, COL, FIELD
};

static dict_pair cl_tags_d[] = 
{
  { "col",   &(cl_tagindex_[1]) },
  { "field", &(cl_tagindex_[2]) },
  { "row",   &(cl_tagindex_[0]) }
};  

static dictionary cd_tags = 
                       { cl_tags_d, sizeof (cl_tags_d) / sizeof (dict_pair) };


typedef enum
{
  TYPE, ID, NAME, VALIGN, HALIGN, EXPAND
}
attr_t;

static attr_t cl_attrindex_[] =
{
  TYPE, ID, NAME, VALIGN, HALIGN, EXPAND
};

static dict_pair cl_attr_d[] =
{
  { "expand", &(cl_attrindex_[5])  },
  { "halign", &(cl_attrindex_[4])  },
  { "id",     &(cl_attrindex_[1])  },
  { "name",   &(cl_attrindex_[2])  },
  { "type",   &(cl_attrindex_[0])  },
  { "valign", &(cl_attrindex_[3])  }
};

static dictionary cd_attrs = 
                     { cl_attr_d, sizeof (cl_attr_d) / sizeof (dict_pair) };


/*------------------------------------------------------------------------
 * Layout data structure type definitions
 *------------------------------------------------------------------------
 */

typedef enum
{
  ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTERED
}
align_hor_t;

typedef enum
{
  ALIGN_TOP, ALIGN_BOTTOM, ALIGN_MIDDLE
}
align_ver_t;

/*------------------------------------------------------------------------
 * Widget data structure                                                  
 *------------------------------------------------------------------------
 */

typedef enum
{
  CROW,     
  CCOL,     
  CFIELD    
} 
widget_class_t;

typedef struct _widget_size_hint
{
  int width;  
  int height; 
  int penalty; 
  struct _widget_size_hint **children_layout;
}
widget_size_hint;

typedef struct
{
  widget_class_t type; 
  slist children;      
  slist layout_hints;  
  int expand_x;
  int expand_y; 
  align_hor_t align_hor;
  align_ver_t align_ver;  
  void *data;
}
cl_widget;


typedef struct
{
  slist      *list;
  slist_iter iter;
}
list_iter_pair;

void _widget_calc_hints (void *widget_, void *dummy);

/*-------------------------------------------------------- _widget_init --*/
static void
_widget_init (cl_widget *widget, widget_class_t type)
{
  widget->type = type;
  slist_init (&widget->children);
  slist_init (&widget->layout_hints);
  widget->expand_x = 0;
  widget->expand_y = 0;
  widget->data = 0;
}

static int
_compare_hints (const void* _data, const void* _compare)
{
  widget_size_hint *data    = (widget_size_hint*)_data;
  widget_size_hint *compare = (widget_size_hint*)_compare;

  return (data->width == compare->width && data->height == compare->height);
}

static void
_hint_init (widget_size_hint *hint)
{
  hint->width = 0;
  hint->height = 0;
  hint->penalty = 0;
  hint->children_layout = 0;
}

static widget_size_hint *
_hint_dup (widget_size_hint *hint)
{
  widget_size_hint *new_hint = xmalloc (sizeof (widget_size_hint));

  new_hint->width = hint->width;
  new_hint->height = hint->height;
  new_hint->penalty = hint->penalty;
  new_hint->children_layout = 0;
  
  return new_hint;
}

void
_layout_strategy_row (widget_size_hint *hint, widget_size_hint *new_hint)
{
  if (hint->height > new_hint->height) 
    new_hint->height = hint->height;
  
  new_hint->width += hint->width;
}

void
_layout_strategy_col (widget_size_hint *hint, widget_size_hint *new_hint)
{
  if (hint->width > new_hint->width) 
    new_hint->width = hint->width;
  
  new_hint->height += hint->height;
}

void
_widget_calc_penalties (cl_widget *widget, 
                        void(*strategy)(widget_size_hint*,
                                        widget_size_hint*))
{
  slist_iter     iter;
  list_iter_pair *pairs;
  int            index_; /* "index" was already taken by string.h */
  int            array_size;
  
  /* All children are instructed to gather their own layout hints. */
  slist_for_each (&widget->children, _widget_calc_hints, 0);

  /* Reserve enough memory for storing the iterators to the children's
   * lists of layout hints, and store them in the pairs array. */
  array_size = slist_length (&widget->children);
  pairs = xmalloc (sizeof (list_iter_pair) * array_size);
  
  iter = slist_begin_iter (&widget->children);
  index_ = 0;
  while (!slist_iter_at_end (iter))
    {
      cl_widget *child = (cl_widget*)slist_iter_and_next (&iter);
      pairs[index_].list = &child->layout_hints;
      pairs[index_].iter = slist_begin_iter (&child->layout_hints);
      ++index_;
    }

  /* Loop until we have exhausted all layout combinations. */
  for (;;) 
    {
      widget_size_hint new_hint;
      slist_iter found;

      _hint_init (&new_hint);
      
      /* Try the current combination and see what turns up. */
      for (index_ = 0; index_ < array_size; ++index_)
        {
          widget_size_hint *hint;
          hint = (widget_size_hint*)slist_at_iter (pairs[index_].iter);
          strategy (hint, &new_hint);
          new_hint.penalty += hint->penalty;
        }

      /* See if the final dimensions were already in the list. */
      found = slist_find_if (&widget->layout_hints, 
                             &new_hint, _compare_hints);

      if (slist_iter_at_end (found))
        {
          widget_size_hint *copy = _hint_dup (&new_hint);
          widget_size_hint **array;

          array = xmalloc (sizeof (widget_size_hint*) * array_size);
          for (index_ = 0; index_ < array_size; ++index_)
            array[index_] = slist_at_iter (pairs[index_].iter);
          
          copy->children_layout = array;
          slist_append (&widget->layout_hints, copy);
        }
      else
        {
          widget_size_hint *found_hint = slist_at_iter (found);

          if (found_hint->penalty > new_hint.penalty)
            {
              widget_size_hint **array = found_hint->children_layout;

              found_hint->penalty = new_hint.penalty;
              for (index_ = 0; index_ < array_size; ++index_)
                array[index_] = slist_at_iter (pairs[index_].iter);
            }
        }
      
      /* Find the next combination of children layouts. */
      for (index_ = 0; index_ < array_size; ++index_)
        {
          slist_iter_and_next (&pairs[index_].iter);
          
          if (slist_iter_at_end (pairs[index_].iter))
              pairs[index_].iter = slist_begin_iter (pairs[index_].list);
          else
              break;
        }

      /* Exit the loop if the possibilities are exhausted. */
      if (index_ == array_size)
        break;
    }
}

/*-------------------------------------------------- _widget_calc_hints --*/
void
_widget_calc_hints (void *widget_, void *dummy)
{
  cl_widget *widget = (cl_widget*)widget_;
  (void)dummy;
  
  switch (widget->type)
    {
    case CROW:
      _widget_calc_penalties (widget, _layout_strategy_row);
      break;

    case CCOL:
      _widget_calc_penalties (widget, _layout_strategy_col);
      break;

    case CFIELD:
      {
        widget_size_hint *new_hint = xmalloc (sizeof (widget_size_hint));
        new_hint->width   = strlen ((char*)(widget->data));
        new_hint->height  = 1;
        new_hint->penalty = 0;
        slist_append (&widget->layout_hints, new_hint);

        new_hint = xmalloc (sizeof (widget_size_hint));
        new_hint->width   = strlen ((char*)(widget->data)) / 2;
        new_hint->height  = 1;
        new_hint->penalty = 1;
        slist_append (&widget->layout_hints, new_hint);

        new_hint = xmalloc (sizeof (widget_size_hint));
        new_hint->width   = 0;
        new_hint->height  = 0;
        new_hint->penalty = 3;
        slist_append (&widget->layout_hints, new_hint);
      }
      break;

    default:
      assert (0);
    }
}

int
_widget_allocate_space (cl_widget *widget, int w, int h, int x, int y, 
                        cl_layout* layout)
{
  widget_size_hint *best_hint = 0;
  unsigned int index_;
  
  slist_iter iter = slist_begin_iter (&widget->layout_hints);
  while (!slist_iter_at_end (iter))
    {
      widget_size_hint *hint = slist_iter_and_next (&iter);
      if (hint->width > w || hint->height > h)
        continue;
      
      if (best_hint == 0 || best_hint->penalty > hint->penalty)
        best_hint = hint;
    }

  if (best_hint == 0)
    return 0;
  
  index_ = 0;
  iter = slist_begin_iter (&widget->children);
  while (!slist_iter_at_end (iter))
    {
      cl_widget* child = slist_iter_and_next (&iter);
      widget_size_hint *best_layout = best_hint->children_layout[index_];
      _widget_allocate_space (child, best_layout->width, best_layout->height,
                              x, y, layout);

      switch (widget->type)
        {
        case CROW:
          x += best_layout->width; break;
        case CCOL:
          y += best_layout->height; break;
        case CFIELD:
          break;
        }
      
      ++index_;
    }

  if (widget->type == CFIELD)
    {
      cl_layout_elem *elem = layout->layout_data + layout->layout_data_size++;
      elem->x = x;
      elem->y = y;
      elem->width = w;
      elem->height = h;
      elem->utf8_data = strdup (widget->data);
    }
  
  return 1;
}
 
/*------------------------------------------------- _is_layout_or_field --*/
static int
_is_layout_or_field (xml_node *node)
{
  int tag = node->tag;
  return tag == ROW || tag == COL || tag == FIELD;
}

/*------------------------------------------------------- _parse_widget --*/
static cl_widget *
_parse_widget (xml_node *node)
{
  cl_widget   *result = xmalloc (sizeof (cl_widget));
  xml_node    *iter   = 0;

  switch (node->tag)
    {
    case ROW:
      _widget_init (result, CROW); break;
    case COL:
      _widget_init (result, CCOL); break;
    case FIELD:
      _widget_init (result, CFIELD); 
      result->data = strdup("Test"); 
      break;
    default:
      return 0;
    }

  if (node->tag != FIELD)
    {
      while ((iter = xmlt_find_if (node, iter, _is_layout_or_field)) != 0)
        slist_append (&result->children, (void *)_parse_widget (iter));
    }
  return result; 
}

/*------------------------------------------------------ cl_make_layout --*/
cl_layout *
cl_make_layout (xml_node *layout)
{
  cl_widget *widgets = 0;
  cl_layout *result = xmalloc (sizeof (cl_layout)); 
  xml_node  *node = 0;
  
  assert (layout);

  result->layout_data_size = 0;
  result->layout_data = xmalloc (sizeof (cl_layout_elem) * 20 * 4);

  /* The XML data is not scanned for our namespace yet. */
  xmlt_rescan_document (layout, &cd_tags, &cd_attrs);

  /* Make a preliminary layout */
  node = xmlt_find_if (layout, node, _is_layout_or_field);
  if (!node)
    return 0;

  widgets = _parse_widget (node);
  _widget_calc_hints (widgets, 0);
  if (!_widget_allocate_space (widgets, 20, 4, 0, 0, result))
    printf ("Cannot fit elements.\n");
  
  return result;
}

---