Stop pretending to use an explicit printing origin.

[geda-gaf/berndj.git] / libgeda / src / o_path_basic.c

/* gEDA - GPL Electronic Design Automation
 * libgeda - gEDA's library
 * Copyright (C) 1998-2007 Ales Hvezda
 * Copyright (C) 1998-2008 gEDA Contributors (see ChangeLog for details)
 *
 * 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 USA
 */
#include <config.h>

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

#include "libgeda_priv.h"

#ifdef HAVE_LIBDMALLOC
#include <dmalloc.h>
#endif

static OBJECT *o_path_copy(TOPLEVEL *toplevel, OBJECT *o_current);
static void o_path_recalc(OBJECT *o_current);
void o_path_grip_foreach(OBJECT *o,
                         gboolean (*fn)(OBJECT *o,
                                        int grip_x, int grip_y,
                                        enum grip_t whichone,
                                        void *userdata),
                         void *userdata);
static int o_path_grip_move(OBJECT *o, int whichone, int x, int y);

/*! Default setting for path draw function. */
void (*path_draw_func)() = NULL;

typedef void (*DRAW_FUNC) (FILE *fp, PATH *path,
                           int line_width, int length, int space);

typedef void (*FILL_FUNC) (FILE *fp, PATH *path,
                           int fill_width,
                           int angle1, int pitch1, int angle2, int pitch2);

/*! \brief Create and add path OBJECT to list.
 *  \par Function Description
 *  This function creates a new object representing a path.
 *  This object is added to the end of the list <B>object_list</B>
 *  pointed object belongs to.
 *  The path is described by its two ends - <B>x1</B>,<B>y1</B> and
 *  <B>x2</B>,<B>y2</B>.
 *  The <B>type</B> parameter must be equal to #OBJ_PATH.
 *  The <B>color</B> parameter corresponds to the color the path
 *  will be drawn with.
 *
 *  The #OBJECT structure is allocated with the
 *  #s_basic_init_object() function. The structure describing
 *  the path is allocated and initialized with the parameters given
 *  to the function.
 *
 *  Both the path type and the filling type are set to default
 *  values : solid path type with a width of 0, and no filling.
 *  It can be changed after with the #o_set_line_options() and
 *  #o_set_fill_options().
 *
 *  The object is added to the end of the list described by the
 *  <B>object_list</B> parameter by the #s_basic_link_object().
 *
 *  \param [in]     toplevel     The TOPLEVEL object.
 *  \param [in]     type         Must be OBJ_PATH.
 *  \param [in]     color        The path color.
 *  \param [in]     path_string  The string representation of the path
 *  \return A pointer to the new end of the object list.
 */
OBJECT *o_path_new (TOPLEVEL *toplevel,
                    char type, int color, const char *path_string)
{
  OBJECT *new_node;

  /* create the object */
  new_node = s_toplevel_new_object(toplevel, type, "path");
  new_node->color = color;

  new_node->path  = s_path_parse (path_string);

  new_node->copy_func = &o_path_copy;
  new_node->bounds_recalc_func = o_path_recalc;
  new_node->draw_func = path_draw_func;
  new_node->grip_foreach_func = &o_path_grip_foreach;
  new_node->grip_move_func = &o_path_grip_move;

  /* path type and filling initialized to default */
  o_set_line_options (new_node, END_NONE, TYPE_SOLID, 0, -1, -1);
  o_set_fill_options (new_node, FILLING_HOLLOW, -1, -1, -1, -1, -1);

  /* compute bounding box */
  o_path_recalc(new_node);

  return new_node;
}


/*! \brief Create a copy of a path.
 *  \par Function Description
 *  This function creates a verbatim copy of the
 *  object pointed by <B>o_current</B> describing a path. The new object
 *  is added at the end of the list following the <B>list_tail</B>
 *  parameter.
 *
 *  \param [in]  toplevel  The TOPLEVEL object.
 *  \param [in]  o_current  Line OBJECT to copy.
 *  \return A new pointer to the end of the object list.
 */
static OBJECT *o_path_copy(TOPLEVEL *toplevel, OBJECT *o_current)
{
  OBJECT *new_obj;
  char *path_string;
  int color;

  if (o_current->saved_color == -1) {
    color = o_current->color;
  } else {
    color = o_current->saved_color;
  }

  path_string = s_path_string_from_path (o_current->path);
  new_obj = o_path_new (toplevel, OBJ_PATH, color, path_string);
  g_free (path_string);

  /* copy the path type and filling options */
  o_set_line_options (new_obj, o_current->line_end,
                      o_current->line_type, o_current->line_width,
                      o_current->line_length, o_current->line_space);
  o_set_fill_options (new_obj,
                      o_current->fill_type, o_current->fill_width,
                      o_current->fill_pitch1, o_current->fill_angle1,
                      o_current->fill_pitch2, o_current->fill_angle2);

  /* calc the bounding box */
  o_path_recalc(o_current);

  /* return the new tail of the object list */
  return new_obj;
}


/*! \brief Create path OBJECT from character string.
 *  \par Function Description
 *  This function creates a path OBJECT from the character string
 *  <B>*buf</B> and a number of lines following that describing the
 *  path, read from <B>*tb</B>. The new path is added to the
 *  list of objects of which <B>*object_list</B> is the last element
 *  before the call.
 *  The function returns the new path object.
 *
 *  Depending on <B>*version</B>, the correct file format is considered.
 *  Currently two file format revisions are supported :
 *  <DL>
 *    <DT>*</DT><DD>the file format used until 20010704 release.
 *    <DT>*</DT><DD>the file format used for the releases after 20010704.
 *  </DL>
 *
 *  \param [in]  toplevel       The TOPLEVEL object.
 *  \param [in]  first_line      Character string with path description.
 *  \param [in]  tb              Text buffer containing the path string.
 *  \param [in]  release_ver     libgeda release version number.
 *  \param [in]  fileformat_ver  libgeda file format version number.
 *  \return A pointer to the new path object.
 */
OBJECT *o_path_read (TOPLEVEL *toplevel,
                     const char *first_line, TextBuffer *tb,
                     unsigned int release_ver, unsigned int fileformat_ver)
{
  OBJECT *new_obj;
  char type;
  int color;
  int line_width, line_space, line_length;
  int line_end;
  int line_type;
  int fill_type, fill_width, angle1, pitch1, angle2, pitch2;
  int num_lines = 0;
  int i;
  char *string;
  GString *pathstr;

  /*
   * The current path format to describe a line is a space separated
   * list of characters and numbers in plain ASCII on a single path.
   * The meaning of each item is described in the file format documentation.
   */
  /* Allocate enough space */
  sscanf (first_line, "%c %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
          &type, &color, &line_width, &line_end, &line_type,
          &line_length, &line_space, &fill_type, &fill_width, &angle1,
          &pitch1, &angle2, &pitch2, &num_lines);

  /*
   * Checks if the required color is valid.
   */
  if (color < 0 || color > MAX_COLORS) {
    s_log_message (_("Found an invalid color [ %s ]\n"), first_line);
    s_log_message (_("Setting color to WHITE\n"));
    color = WHITE;
  }

  /*
   * A path is internally described by its two ends. A new object is
   * allocated, initialized and added to the list of objects. Its path
   * type is set according to the values of the fields on the path.
   */

  pathstr = g_string_new ("");
  for (i = 0; i < num_lines; i++) {
    gchar *line;

    line = s_textbuffer_next_line (tb);

    if (line != NULL) {
      pathstr = g_string_append (pathstr, line);
    }
  }

  /* retrieve the character string from the GString */
  string = g_string_free (pathstr, FALSE);
  string = remove_last_nl (string);

  /* create a new path */
  new_obj = o_path_new (toplevel, type, color, string);
  g_free (string);

  /* set its line options */
  o_set_line_options (new_obj,
                      line_end, line_type, line_width, line_length, line_space);
  /* set its fill options */
  o_set_fill_options (new_obj,
                      fill_type, fill_width, pitch1, angle1, pitch2, angle2);

  return new_obj;
}


/*! \brief Create a character string representation of a path OBJECT.
 *  \par Function Description
 *  The function formats a string in the buffer <B>*buff</B> to describe
 *  the path object <B>*object</B>.
 *
 *  \param [in] object  path OBJECT to create string from.
 *  \return A pointer to the path OBJECT character string.
 *
 *  \note
 *  Caller must g_free returned character string.
 *
 */
char *o_path_save (OBJECT *object)
{
  int color;
  int line_width, line_space, line_length;
  char *buf;
  int num_lines;
  OBJECT_END line_end;
  OBJECT_TYPE line_type;
  OBJECT_FILLING fill_type;
  int fill_width, angle1, pitch1, angle2, pitch2;
  char *path_string;

  /* description of the line type */
  line_width  = object->line_width;
  line_end    = object->line_end;
  line_type   = object->line_type;
  line_length = object->line_length;
  line_space  = object->line_space;

  /* filling parameters */
  fill_type    = object->fill_type;
  fill_width   = object->fill_width;
  angle1       = object->fill_angle1;
  pitch1       = object->fill_pitch1;
  angle2       = object->fill_angle2;
  pitch2       = object->fill_pitch2;

  /* Use the right color */
  if (object->saved_color == -1) {
    color = object->color;
  } else {
    color = object->saved_color;
  }

  path_string = s_path_string_from_path (object->path);
  num_lines = o_text_num_lines (path_string);
  buf = g_strdup_printf ("%c %d %d %d %d %d %d %d %d %d %d %d %d %d\n%s",
                         object->type, color, line_width, line_end,
                         line_type, line_length, line_space, fill_type,
                         fill_width, angle1, pitch1, angle2, pitch2,
                         num_lines, path_string);
  g_free (path_string);

  return buf;
}

/*! \brief Translate a path position in WORLD coordinates by a delta.
 *  \par Function Description
 *  This function applies a translation of (<B>x1</B>,<B>y1</B>) to the path
 *  described by <B>*object</B>. <B>x1</B> and <B>y1</B> are in world unit.
 *
 *  \param [in]     dx         x distance to move.
 *  \param [in]     dy         y distance to move.
 *  \param [in,out] object     Line OBJECT to translate.
 */
void o_path_translate_world (int dx, int dy, OBJECT *object)
{
  PATH_SECTION *section;
  int i;

  for (i = 0; i < object->path->num_sections; i++) {
    section = &object->path->sections[i];

    switch (section->code) {
    case PATH_CURVETO:
      section->x1 += dx;
      section->y1 += dy;
      section->x2 += dx;
      section->y2 += dy;
      /* Fall through */
    case PATH_MOVETO:
    case PATH_MOVETO_OPEN:
    case PATH_LINETO:
      section->x3 += dx;
      section->y3 += dy;
      break;
    case PATH_END:
      break;
    }
  }

  /* Update bounding box */
  o_path_recalc(object);
}


/*! \brief Rotate Line OBJECT using WORLD coordinates.
 *  \par Function Description
 *  This function rotates the path described by
 *  <B>*object</B> around the (<B>world_centerx</B>,<B>world_centery</B>)
 *  point by <B>angle</B> degrees.
 *  The center of rotation is in world units.
 *
 *  \param [in]      world_centerx  Rotation center x coordinate in WORLD units.
 *  \param [in]      world_centery  Rotation center y coordinate in WORLD units.
 *  \param [in]      angle          Rotation angle in degrees (See note below).
 *  \param [in,out]  object         Line OBJECT to rotate.
 */
void o_path_rotate_world (int world_centerx, int world_centery, int angle,
                          OBJECT *object)
{
  PATH_SECTION *section;
  int i;

  for (i = 0; i < object->path->num_sections; i++) {
    section = &object->path->sections[i];

    switch (section->code) {
    case PATH_CURVETO:
      /* Two control point grips */
      section->x1 -= world_centerx; section->y1 -= world_centery;
      section->x2 -= world_centerx; section->y2 -= world_centery;
      rotate_point_90 (section->x1, section->y1, angle, &section->x1, &section->y1);
      rotate_point_90 (section->x2, section->y2, angle, &section->x2, &section->y2);
      section->x1 += world_centerx; section->y1 += world_centery;
      section->x2 += world_centerx; section->y2 += world_centery;
      /* Fall through */
    case PATH_MOVETO:
    case PATH_MOVETO_OPEN:
    case PATH_LINETO:
      /* Destination point grip */
      section->x3 -= world_centerx; section->y3 -= world_centery;
      rotate_point_90 (section->x3, section->y3, angle, &section->x3, &section->y3);
      section->x3 += world_centerx; section->y3 += world_centery;
      break;
    case PATH_END:
      break;
    }
  }
  o_path_recalc(object);
}


/*! \brief Mirror a path using WORLD coordinates.
 *  \par Function Description
 *  This function mirrors the path from the point
 *  (<B>world_centerx</B>,<B>world_centery</B>) in world unit.
 *
 *  \param [in]     world_centerx  Origin x coordinate in WORLD units.
 *  \param [in]     world_centery  Origin y coordinate in WORLD units.
 *  \param [in,out] object         Line OBJECT to mirror.
 */
void o_path_mirror_world (int world_centerx, int world_centery, OBJECT *object)
{
  PATH_SECTION *section;
  int i;

  for (i = 0; i < object->path->num_sections; i++) {
    section = &object->path->sections[i];

    switch (section->code) {
    case PATH_CURVETO:
      /* Two control point grips */
      section->x1 = 2 * world_centerx - section->x1;
      section->x2 = 2 * world_centerx - section->x2;
      /* Fall through */
    case PATH_MOVETO:
    case PATH_MOVETO_OPEN:
    case PATH_LINETO:
      /* Destination point grip */
      section->x3 = 2 * world_centerx - section->x3;
      break;
    case PATH_END:
      break;
    }
  }

  o_path_recalc(object);
}


/*! \brief Recalculate path coordinates in SCREEN units.
 *  \par Function Description
 *  This function recalculate the bounding box of the <B>o_current</B>
 *
 *  \param [in,out] o_current  Line OBJECT to be recalculated.
 */
static void o_path_recalc(OBJECT *o_current)
{
  int left, right, top, bottom;

  if (o_current->path == NULL) {
    return;
  }

  /* Update the bounding box */
  world_get_path_bounds(o_current, &left, &top, &right, &bottom);
  o_current->w_left   = left;
  o_current->w_top    = top;
  o_current->w_right  = right;
  o_current->w_bottom = bottom;
  o_current->w_bounds_valid = TRUE;
}


/*! \brief Get path bounding rectangle in WORLD coordinates.
 *  \par Function Description
 *  This function sets the <B>left</B>, <B>top</B>, <B>right</B> and
 *  <B>bottom</B> parameters to the boundings of the path object described
 *  in <B>*path</B> in world units.
 *
 *  \note Bounding box for bezier curves is loose because we just consider
 *        the convex hull of the curve control and end-points.
 *
 *  \param [in]  object     Line OBJECT to read coordinates from.
 *  \param [out] left       Left path coordinate in WORLD units.
 *  \param [out] top        Top path coordinate in WORLD units.
 *  \param [out] right      Right path coordinate in WORLD units.
 *  \param [out] bottom     Bottom path coordinate in WORLD units.
 */
void world_get_path_bounds (OBJECT *object,
                            int *left, int *top, int *right, int *bottom)
{
  PATH_SECTION *section;
  int halfwidth;
  int i;
  int found_bound = FALSE;

  /* Find the bounds of the path region */
  for (i = 0; i < object->path->num_sections; i++) {
    section = &object->path->sections[i];
    switch (section->code) {
      case PATH_CURVETO:
        /* Bezier curves with this construction of control points will lie
         * within the convex hull of the control and curve end points */
        *left   = (found_bound) ? MIN (*left,   section->x1) : section->x1;
        *top    = (found_bound) ? MIN (*top,    section->y1) : section->y1;
        *right  = (found_bound) ? MAX (*right,  section->x1) : section->x1;
        *bottom = (found_bound) ? MAX (*bottom, section->y1) : section->y1;
        found_bound = TRUE;
        *left   = MIN (*left,   section->x2);
        *top    = MIN (*top,    section->y2);
        *right  = MAX (*right,  section->x2);
        *bottom = MAX (*bottom, section->y2);
        /* Fall through */
      case PATH_MOVETO:
      case PATH_MOVETO_OPEN:
      case PATH_LINETO:
        *left   = (found_bound) ? MIN (*left,   section->x3) : section->x3;
        *top    = (found_bound) ? MIN (*top,    section->y3) : section->y3;
        *right  = (found_bound) ? MAX (*right,  section->x3) : section->x3;
        *bottom = (found_bound) ? MAX (*bottom, section->y3) : section->y3;
        found_bound = TRUE;
        break;
      case PATH_END:
        break;
    }
  }

  if (found_bound) {
    /* This isn't strictly correct, but a 1st order approximation */
    halfwidth = object->line_width / 2;
    *left   -= halfwidth;
    *top    -= halfwidth;
    *right  += halfwidth;
    *bottom += halfwidth;
  }
}

void o_path_grip_foreach(OBJECT *o,
                         gboolean (*fn)(OBJECT *o,
                                        int grip_x, int grip_y,
                                        enum grip_t whichone,
                                        void *userdata),
                         void *userdata)
{
  int i;

  /* Find the bounds of the path region */
  for (i = 0; i < o->path->num_sections; i++) {
    PATH_SECTION *section = &o->path->sections[i];
    int whichone;

    /* Encode the section in the grip number. */
    whichone = GRIP_FIRST_OPAQUE + i*3;

    switch (section->code) {
    case PATH_CURVETO:
      if ((*fn)(o, section->x1, section->y1, whichone + 0, userdata)) return;
      if ((*fn)(o, section->x2, section->y2, whichone + 1, userdata)) return;
      /* Fall through */
    case PATH_MOVETO:
    case PATH_MOVETO_OPEN:
    case PATH_LINETO:
      if ((*fn)(o, section->x3, section->y3, whichone + 2, userdata)) return;
      break;
    case PATH_END:
      break;
    }
  }
}

/*! \brief Modify control point location
 *
 *  \par Function Description
 *  This function modifies a control point location of the path object
 *  *object. The control point being modified is selected according to
 *  the whichone parameter.
 *
 *  The new position is given by <B>x</B> and <B>y</B>.
 *
 *  \param [in,out] o         The path OBJECT
 *  \param [in]     whichone  Which control point is being modified
 *  \param [in]     x         New x coordinate for the control point
 *  \param [in]     y         New y coordinate for the control point
 */
static int o_path_grip_move(OBJECT *o, int whichone, int x, int y)
{
  int retval = GRIP_NONE;

  switch (whichone) {
    PATH_SECTION *section;
    int i, sub;

  case GRIP_NONE:
    s_path_moveto(o->path, x, y);
    retval = GRIP_PATH_NEXT_SECTION;
    break;

  case GRIP_PATH_NEXT_SECTION:
    s_path_lineto(o->path, x, y);
    retval = GRIP_PATH_NEXT_SECTION;
    break;

  case GRIP_PATH_LAST_SECTION:
    i = o->path->num_sections - 1;
    g_return_val_if_fail(i >= 0, GRIP_NONE);
    switch (i) {
    case 0:
      /* Degenerate path: add a new section instead of moving the path origin. */
      return o_path_grip_move(o, GRIP_PATH_NEXT_SECTION, x, y);
    default:
      return o_path_grip_move(o, GRIP_FIRST_OPAQUE + i*3 + 2, x, y);
    }

  case GRIP_PATH_CONTROL_1:
  case GRIP_PATH_CONTROL_2:
    g_return_val_if_fail(o->path->num_sections >= 2, GRIP_NONE);
    s_path_mutate(o->path, PATH_CURVETO);
    i = o->path->num_sections - 1;
    section = &o->path->sections[i];
    switch (whichone) {
    case GRIP_PATH_CONTROL_1:
      section->x1 = x;
      section->y1 = y;
      retval = GRIP_PATH_CONTROL_2;
      break;
    case GRIP_PATH_CONTROL_2:
      section->x2 = x;
      section->y2 = y;
      retval = GRIP_PATH_NEXT_SECTION;
      break;
    }
    break;

  default:
    i = (whichone - GRIP_FIRST_OPAQUE) / 3;
    sub = (whichone - GRIP_FIRST_OPAQUE) % 3;
    g_return_val_if_fail(i < o->path->num_sections, GRIP_NONE);
    section = &o->path->sections[i];
    switch (sub) {
    case 0:
      section->x1 = x;
      section->y1 = y;
      break;
    case 1:
      section->x2 = x;
      section->y2 = y;
      break;
    case 2:
      section->x3 = x;
      section->y3 = y;
      break;
    }
    switch (section->code) {
    case PATH_CURVETO:
      retval = whichone + 1;
      break;
    case PATH_MOVETO:
    case PATH_MOVETO_OPEN:
    case PATH_LINETO:
      /* The next grip is just the first grip of the next section. */
      retval = GRIP_FIRST_OPAQUE + (i+1)*3;
      break;
    case PATH_END:
      retval = GRIP_NONE;
      break;
    }
    if (retval >= GRIP_FIRST_OPAQUE + o->path->num_sections*3) {
      /* We fell off the end of the path. */
      retval = GRIP_NONE;
    }
    break;
  }

  o_path_recalc(o);

  return retval;
}

/*! \brief Print a solid PATH to Postscript document.
 *  \par Function Description
 *  This function prints the outline of a path when a solid line type is
 *  required. The postscript file is defined by the file pointer <B>fp</B>.
 *  The parameters <B>length</B> and <B>space</B> are ignored.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document.
 *  \param [in] path        The PATH object ot print
 *  \param [in] line_width  PATH Line width.
 *  \param [in] length      Dashed line length.
 *  \param [in] space       Amount of space between dashes.
 */
static void o_path_print_solid (FILE *fp, PATH *path,
                                int line_width, int length, int space)
{
  int i;

  for (i = 0; i < path->num_sections; i++) {
    PATH_SECTION *section = &path->sections[i];

    if (i > 0)
      fprintf (fp, " ");

    switch (section->code) {
      case PATH_MOVETO:
        fprintf (fp, "closepath ");
        /* Fall through */
      case PATH_MOVETO_OPEN:
        fprintf(fp, "%i %i moveto", section->x3, section->y3);
        break;
      case PATH_CURVETO:
        fprintf (fp, "%i %i %i %i %i %i curveto",
                     section->x1, section->y1,
                     section->x2, section->y2,
                     section->x3, section->y3);
        break;
      case PATH_LINETO:
        fprintf(fp, "%i %i lineto", section->x3, section->y3);
        break;
      case PATH_END:
        fprintf (fp, "closepath ");
        break;
    }
  }

  fprintf (fp, "stroke\n");
}


/*! \brief Print a dotted PATH to Postscript document.
 *  \par Function Description
 *  This function prints the outline of a path when a dotted line type is
 *  required. The postscript file is defined by the file pointer <B>fp</B>.
 *  The parameter <B>length</B> is ignored.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document
 *  \param [in] path        The PATH object to print
 *  \param [in] line_width  PATH Line width
 *  \param [in] length      Dashed line length
 *  \param [in] space       Amount of space between dashes
 */
static void o_path_print_dotted (FILE *fp, PATH *path,
                                 int line_width, int length, int space)
{
  o_path_print_solid(fp, path, line_width, length, space);
}


/*! \brief Print a dashed PATH to Postscript document.
 *  \par Function Description
 *  This function prints the outline of a path when a dashed line type is
 *  required. The postscript file is defined by the file pointer <B>fp</B>.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document.
 *  \param [in] path        The PATH object to print.
 *  \param [in] line_width  PATH Line width.
 *  \param [in] length      Dashed line length.
 *  \param [in] space       Amount of space between dashes.
 */
static void o_path_print_dashed (FILE *fp, PATH *path,
                                 int line_width, int length, int space)
{
  o_path_print_solid(fp, path, line_width, length, space);
}


/*! \brief Print centered line type PATH to Postscript document.
 *  \par Function Description
 *  This function prints the outline of a path when a centered line type is
 *  required. The postscript file is defined by the file pointer <B>fp</B>.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document
 *  \param [in] path        The PATH object to print
 *  \param [in] line_width  PATH Line width
 *  \param [in] length      Dashed line length
 *  \param [in] space       Amount of space between dashes
 */
static void o_path_print_center (FILE *fp, PATH *path,
                                 int line_width, int length,
                                 int space)
{
  o_path_print_solid(fp, path, line_width, length, space);
}


/*! \brief Print phantom line type PATH to Postscript document.
 *  \par Function Description
 *  This function prints the outline of a path when a phantom line type is
 *  required. The postscript file is defined by the file pointer <B>fp</B>.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document
 *  \param [in] path        The PATH object to print
 *  \param [in] line_width  PATH Line width
 *  \param [in] length      Dashed line length
 *  \param [in] space       Amount of space between dashes
 */
static void o_path_print_phantom (FILE *fp, PATH *path,
                                  int line_width, int length,
                                  int space)
{
  o_path_print_solid(fp, path, line_width, length, space);
}


/*! \brief Print a solid pattern PATH to Postscript document.
 *  \par Function Description
 *  The function prints a filled path with a solid pattern. No outline is
 *  printed. The postscript file is defined by the file pointer <B>fp</B>.
 *  <B>fill_width</B>, <B>angle1</B> and <B>pitch1</B>, <B>angle2</B> and <B>pitch2</B>
 *  parameters are ignored in this functions but kept for compatibility
 *  with other fill functions.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document
 *  \param [in] path        The PATH object to print
 *  \param [in] fill_width  PATH fill width (unused)
 *  \param [in] angle1      (unused)
 *  \param [in] pitch1      (unused)
 *  \param [in] angle2      (unused)
 *  \param [in] pitch2      (unused)
 */
static void o_path_print_filled (FILE *fp, PATH *path,
                                 int fill_width,
                                 int angle1, int pitch1, int angle2, int pitch2)
{
  int i;

  for (i = 0; i < path->num_sections; i++) {
    PATH_SECTION *section = &path->sections[i];

    if (i > 0)
      fprintf (fp, " ");

    switch (section->code) {
      case PATH_MOVETO:
        fprintf (fp, "closepath ");
        /* Fall through */
      case PATH_MOVETO_OPEN:
        fprintf(fp, "%i %i moveto", section->x3, section->y3);
        break;
      case PATH_CURVETO:
        fprintf (fp, "%i %i %i %i %i %i curveto",
                     section->x1, section->y1,
                     section->x2, section->y2,
                     section->x3, section->y3);
        break;
      case PATH_LINETO:
        fprintf(fp, "%i %i lineto", section->x3, section->y3);
        break;
      case PATH_END:
        fprintf (fp, "closepath ");
        break;
    }
  }

  fprintf (fp, "fill\n");
}


/*! \brief Print a hatch pattern PATH to Postscript document.
 *  \par Function Description
 *  The function prints a hatched path. No outline is printed.
 *  The postscript file is defined by the file pointer <B>fp</B>.
 *  <B>fill_width</B>, <B>angle1</B>, <B>pitch1</B> parameters define the way the path
 *  has to be hatched.
 *  <B>angle2</B> and <B>pitch2</B> parameters are unused but kept for compatibility
 *  with other fill functions.
 *
 *  Negative or zero values for <B>pitch1</B> are not allowed.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document
 *  \param [in] path        The PATH object to print
 *  \param [in] fill_width  PATH fill width
 *  \param [in] angle1      Angle of hatch pattern
 *  \param [in] pitch1      Pitch of hatch pattern
 *  \param [in] angle2      (unused)
 *  \param [in] pitch2      (unused)
 */
static void o_path_print_hatch (FILE *fp, PATH *path,
                                int fill_width,
                                int angle1, int pitch1, int angle2, int pitch2)
{
  GArray *lines;

  g_return_if_fail (fp != NULL);

  /* Avoid printing line widths too small */
  if (fill_width <= 1) fill_width = 2;

  lines = m_hatch_new();
  m_hatch_path (path, angle1, pitch1, lines);
  m_hatch_print(lines, fp, fill_width);
  g_array_free (lines, TRUE);
}


/*! \brief Print a mesh pattern PATH to Postscript document.
 *  \par Function Description
 *  This function prints a meshed path. No outline is printed.
 *  The postscript file is defined by the file pointer <B>fp</B>.
 *
 *  Negative or zero values for <B>pitch1</B> and/or <B>pitch2</B> are
 *  not allowed.
 *
 *  All dimensions are in mils.
 *
 *  \param [in] fp          FILE pointer to Postscript document
 *  \param [in] path        The PATH object to print
 *  \param [in] fill_width  PATH fill width
 *  \param [in] angle1      1st angle for mesh pattern
 *  \param [in] pitch1      1st pitch for mesh pattern
 *  \param [in] angle2      2nd angle for mesh pattern
 *  \param [in] pitch2      2nd pitch for mesh pattern
 */
static void o_path_print_mesh (FILE *fp, PATH *path,
                               int fill_width,
                               int angle1, int pitch1, int angle2, int pitch2)
{
  o_path_print_hatch(fp, path, fill_width, angle1, pitch1, -1, -1);
  o_path_print_hatch(fp, path, fill_width, angle2, pitch2, -1, -1);
}


/*! \brief Print PATH to Postscript document.
 *  \par Function Description
 *  This function prints the path described by the <B>o_current</B>
 *  parameter to a Postscript document.
 *  The Postscript document is described by the file pointer <B>fp</B>.
 *
 *  \param [in] toplevel  The TOPLEVEL object.
 *  \param [in] fp         FILE pointer to Postscript document.
 *  \param [in] o_current  PATH OBJECT to write to document.
 */
void o_path_print(TOPLEVEL *toplevel, FILE *fp, OBJECT *o_current)
{
  int line_width, length, space;
  int fill_width, angle1, pitch1, angle2, pitch2;
  DRAW_FUNC outl_func = NULL;
  FILL_FUNC fill_func = NULL;

  /*! \note
   *  Depending on the type of the line for this particular path, the
   *  appropriate function is chosen among #o_path_print_solid(),
   *  #o_path_print_dotted(), #o_path_print_dashed(),
   *  #o_path_print_center() and #o_path_print_phantom().
   *
   *  The needed parameters for each of these type is extracted from the
   *  <B>o_current</B> object. Depending on the type, unused parameters are
   *  set to -1.
   *
   *  In the eventuality of a length and/or space null, the line is printed
   *  solid to avoid and endless loop produced by other functions in such a
   *  case.
   */
  line_width = o_current->line_width;

  if (line_width <= 2) {
    if (toplevel->line_style == THICK) {
      line_width = LINE_WIDTH;
    } else {
      line_width=2;
    }
  }
  length = o_current->line_length;
  space  = o_current->line_space;

  switch(o_current->line_type) {
    case TYPE_SOLID:
      length = -1; space  = -1;
      outl_func = o_path_print_solid;
      break;

    case TYPE_DOTTED:
      length = -1;
      outl_func = o_path_print_dotted;
      break;

    case TYPE_DASHED:
      outl_func = o_path_print_dashed;
      break;

    case TYPE_CENTER:
      outl_func = o_path_print_center;
      break;

    case TYPE_PHANTOM:
      outl_func = o_path_print_phantom;
      break;

    case TYPE_ERASE:
      /* Unused for now, print it solid */
      length = -1; space  = -1;
      outl_func = o_path_print_solid;
      break;
  }

  if((length == 0) || (space == 0)) {
    length = -1; space  = -1;
    outl_func = o_path_print_solid;
  }

  if (toplevel->print_color)
    f_print_set_color (fp, o_current->color);

  f_print_set_line_width (fp, line_width);

  (*outl_func)(fp, o_current->path, line_width, length, space);

  /*! \note
   *  If the filling type of the path is not <B>HOLLOW</B>, the appropriate
   *  function is chosen among #o_path_print_filled(), #o_path_print_mesh()
   *  and #o_path_print_hatch(). The corresponding parameters are extracted
   *  from the <B>o_current</B> object and corrected afterward.
   *
   *  The case where <B>pitch1</B> and <B>pitch2</B> are null or negative is
   *  avoided as it leads to an endless loop in most of the called functions.
   *  In such a case, the path is printed filled. Unused parameters for each of
   *  these functions are set to -1 or any passive value.
   */
  if(o_current->fill_type != FILLING_HOLLOW) {
    fill_width = o_current->fill_width;
    angle1     = o_current->fill_angle1;
    pitch1     = o_current->fill_pitch1;
    angle2     = o_current->fill_angle2;
    pitch2     = o_current->fill_pitch2;

    switch(o_current->fill_type) {
      case FILLING_FILL:
        angle1 = -1; pitch1 = 1;
        angle2 = -1; pitch2 = 1;
        fill_width = -1;
        fill_func = o_path_print_filled;
        break;

      case FILLING_MESH:
        fill_func = o_path_print_mesh;
        break;

      case FILLING_HATCH:
        angle2 = -1; pitch2 = 1;
        fill_func = o_path_print_hatch;
        break;

      case FILLING_VOID:
        /* Unused for now, print it filled */
        angle1 = -1; pitch1 = 1;
        angle2 = -1; pitch2 = 1;
        fill_width = -1;
        fill_func = o_path_print_filled;
        break;

      case FILLING_HOLLOW:
        /* nop */
        break;

    }

    if((pitch1 <= 0) || (pitch2 <= 0)) {
      angle1 = -1; pitch1 = 1;
      angle2 = -1; pitch2 = 1;
      fill_func = o_path_print_filled;
    }

    (*fill_func) (fp, o_current->path, fill_width,
                  angle1, pitch1, angle2, pitch2);
  }
}


/*! \brief Calculates the distance between the given point and the closest
 *  point on the given path segment.
 *
 *  \todo Support for bezier path segments.
 *
 *  \param [in] object The path OBJECT
 *  \param [in] x The x coordinate of the given point.
 *  \param [in] y The y coordinate of the given point.
 *  \return The shortest distance from the object to the point.  With an
 *  invalid parameter, this function returns G_MAXDOUBLE.
 */
gdouble o_path_shortest_distance (OBJECT const *object, gint x, gint y)
{
  PATH_SECTION const *section;
  gdouble shortest = G_MAXDOUBLE;
  int last_x = 0, last_y = 0;
  int i;

  for (i = 0; i < object->path->num_sections; i++) {
    section = &object->path->sections[i];
    switch (section->code) {

      case PATH_CURVETO:
        /* TODO: Shortest distance to a besier section of the path.
         *       For now, pretend it is a straight line. */
        /* Fall through */
      case PATH_LINETO:
        shortest = MIN(shortest,
                       o_line_shortest_distance_raw(last_x, last_y,
                                                    section->x3, section->y3,
                                                    x, y));
        last_x = section->x3;
        last_y = section->y3;
        break;

      case PATH_MOVETO:
      case PATH_MOVETO_OPEN:
        last_x = section->x3;
        last_y = section->y3;
        break;

      case PATH_END:
        /* Need to consider the line back to the first point in the path */
        shortest = MIN(shortest,
                       o_line_shortest_distance_raw(last_x, last_y,
                                                    object->path->sections[0].x3,
                                                    object->path->sections[0].y3,
                                                    x, y));
        last_x = object->path->sections[0].x3;
        last_y = object->path->sections[0].y3;
        break;
    }
  }

  return shortest;
}