plotutils-graph-patches-lloda/libplot/g_retrieve.c

/* This file is part of the GNU plotutils package.  Copyright (C) 1995,
   1996, 1997, 1998, 1999, 2000, 2005, 2008, Free Software Foundation, Inc.

   The GNU plotutils package is free software.  You may 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, or (at your
   option) any later version.

   The GNU plotutils package 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 the GNU plotutils package; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin St., Fifth Floor,
   Boston, MA 02110-1301, USA. */

/* This file contains the internal _pl_g_set_font method, which is called
   when the font_name, font_size, and textangle fields of the current
   drawing state have been filled in.  It retrieves the specified font, and
   fills in the true_font_name, true_font_size, font_type, typeface_index,
   font_index, font_is_iso8858_1, font_ascent, font_descent, and
   font_cap_height fields of the drawing state.

   _pl_g_set_font is invoked by _API_alabel() and _API_flabelwidth(), and
   also by _API_fontname(), _API_fontsize(), and _API_textangle() (only
   because those three functions in the API must return a font size).

   _pl_g_set_font does the following, in order:

   1. If font_name is the name of a supported Hershey font, i.e., one in
   libplot's database, it fills in the fields itself.

   2. If the font name is the name of a supported font of a non-Hershey
   type (i.e. PS/PCL/Stick), it _tentatively_ fills in the fields.  If the
   font name doesn't appear in libplot's internal database, it simply sets
   the font_type to `PL_F_OTHER'.

   3a. If the font name isn't the name of a supported Hershey font, it
   invokes the Plotter-specific `retrieve_font' method.  In most Plotters
   this simply returns true.  (See the stub _pl_g_retrieve_font() below.)
   But in principle it may modify the fields arbitrarily, perhaps consult
   an external database, etc.

   3b. If retrieve_font returns false, a default Hershey font is
   substituted, and the fields are filled in.  This feature is used e.g. by
   Fig Plotters, which support any of the 35 PS fonts in libplot's
   database, except when the user frame -> device frame map is anisotropic
   (i.e. non-uniform).  It is also used by X Drawable Plotters, which may
   or may not have a PS font available, and in fact may or may not have any
   given font of type `PL_F_OTHER' (see above) available. */

#include "sys-defines.h"
#include "extern.h"
#include "g_her_metr.h"

#define MAP_HERSHEY_UNITS_TO_USER_UNITS(size, drawstate) \
	((size)*(drawstate->true_font_size)/(HERSHEY_EM))

/* forward references */
static bool _match_hershey_font (plDrawState *drawstate);
static bool _match_ps_font (plDrawState *drawstate);
static bool _match_pcl_font (plDrawState *drawstate);
static bool _match_stick_font (plDrawState *drawstate, bool have_extra_stick_fonts);

void
_pl_g_set_font (S___(Plotter *_plotter))
{
  plDrawState *drawstate = _plotter->drawstate;
  plPlotterData *data = _plotter->data;
  const char *default_font_name;
  bool matched;

  /* try to match font name in our database */

  if (_match_hershey_font (drawstate))
    /* Matched a Hershey font name in our database, and all fields filled
       in definitively, so return without invoking Plotter-specific
       `retrieve_font', which knows nothing about Hershey fonts anyway */
    return;

  matched = false;

  /* Try to match the font name with the name of a PCL font or a PS font in
     the database, and tentatively fill in fields.  But there is a
     namespace collision: "Courier" etc. and "Symbol" occur on both lists.
     Which list we search first depends on what type of Plotter this is. */

  if (data->pcl_before_ps)
    {
      /* search PCL font list first */      
      if ((data->have_pcl_fonts 
	   && _match_pcl_font (drawstate))
	  ||
          (data->have_ps_fonts 
	   && _match_ps_font (drawstate)))
	matched = true;
    }
  else
    {
      /* search PS font list first */
      if ((data->have_ps_fonts 
	   && _match_ps_font (drawstate))
	  ||
	  (data->have_pcl_fonts 
	   && _match_pcl_font (drawstate)))
	matched = true;
    }

  /* if unmatched, search through Stick font list too */
  if (matched == false && data->have_stick_fonts
      && _match_stick_font (drawstate, 
			    data->have_extra_stick_fonts ? true : false))
    matched = true;

  if (matched == false)
    /* fill in the only fields we can */
    {
      free ((char *)drawstate->true_font_name);
      drawstate->true_font_name = 
	(const char *)_pl_xmalloc (strlen (drawstate->font_name) + 1);
      strcpy ((char *)drawstate->true_font_name, drawstate->font_name);
      drawstate->true_font_size = drawstate->font_size;

      drawstate->font_type = PL_F_OTHER;
      drawstate->typeface_index = 0;
      drawstate->font_index = 1;

      /* NOT filled in yet: font_is_iso8859_1, font_ascent, font_descent,
	 and font_cap_height; they're left to Plotter-specific retrieval
	 routine, if it can supply them (in the case of a Metafile Plotter,
	 it surely can't). */
    }

  /* If we got here, font name isn't that of a Hershey font, and `matched'
     indicates whether or not it's listed in our font name database, as one
     of the types of font this Plotter can handle.  So invoke low-level
     Plotter-specific retrieval routine.  Do it even if we haven't matched
     the font, if this Plotter claims to be able to handle `other' fonts,
     i.e., ones not listed in our database. */

  if (matched || (!matched && data->have_other_fonts))
    /* try to invoke low-level Plotter-specific routine to finish the job
       of filling in fields, including Plotter-specific ones */
    {
      if (_plotter->retrieve_font (S___(_plotter)))
	/* all finished... */
	return;
    }

  /* Plotter-specific retrieval failed: it doesn't like the font name or
     other drawstate parameters (size, textangle, transformation matrix?)  */

  /* Via a recursive call, try to retrieve default font for this Plotter
     type (if it's different from the one we just failed to retrieve;
     otherwise retrieve the default Hershey font).  */

  switch (data->default_font_type)
    {
    case PL_F_POSTSCRIPT:
      default_font_name = PL_DEFAULT_POSTSCRIPT_FONT;
      break;
    case PL_F_PCL:
      default_font_name = PL_DEFAULT_PCL_FONT;
      break;
    case PL_F_STICK:
      default_font_name = PL_DEFAULT_STICK_FONT;
      break;
    case PL_F_HERSHEY:		/* Hershey shouldn't happen */
    default:
      default_font_name = PL_DEFAULT_HERSHEY_FONT;
      break;

      /* N.B. No support yet for a Plotter-specific default font that is of
	 PL_F_OTHER type, i.e., isn't listed in the libplot font database. */
    }

  if (strcmp (drawstate->font_name, default_font_name) == 0
      || strcmp (drawstate->true_font_name, default_font_name) == 0)
    /* default font is the one we just failed to retrieve: so use Hershey:
       internal and guaranteed to be available */
    default_font_name = PL_DEFAULT_HERSHEY_FONT;
  
  /* stash fontname we failed to retrieve; then do recursive call, turning
     off font warnings for the duration; restore fontname field */
  {
    const char *saved_font_name;
    bool saved_font_warning_issued;

    saved_font_name = drawstate->font_name;
    drawstate->font_name = default_font_name;
    saved_font_warning_issued = _plotter->data->font_warning_issued;
    _plotter->data->font_warning_issued = true;	/* turn off warnings */
    _pl_g_set_font (S___(_plotter));
    _plotter->data->font_warning_issued = saved_font_warning_issued;
    drawstate->font_name = saved_font_name;
  }

  if (data->issue_font_warning && !_plotter->data->font_warning_issued)
    /* squawk */
    {
      char *buf;
      
      buf = (char *)_pl_xmalloc (strlen (drawstate->font_name) + strlen (drawstate->true_font_name) + 100);
      sprintf (buf, "cannot retrieve font \"%s\", using default \"%s\"", 
	       drawstate->font_name, drawstate->true_font_name);
      _plotter->warning (R___(_plotter) buf);
      free (buf);
      _plotter->data->font_warning_issued = true;
    }
}

static bool
_match_hershey_font (plDrawState *drawstate)
{
  int i;

  /* is font a Hershey font? */
  i = -1;
  while (_pl_g_hershey_font_info[++i].name)
    {
      if (_pl_g_hershey_font_info[i].visible) /* i.e. font not internal-only */
	if (strcasecmp (_pl_g_hershey_font_info[i].name, 
			drawstate->font_name) == 0
	    || (_pl_g_hershey_font_info[i].othername
		&& strcasecmp (_pl_g_hershey_font_info[i].othername, 
			       drawstate->font_name) == 0))
	  /* fill in fields */
	  {
	    free ((char *)drawstate->true_font_name);
	    drawstate->true_font_name = 
	      (const char *)_pl_xmalloc (strlen (_pl_g_hershey_font_info[i].name) + 1);
	    strcpy ((char *)drawstate->true_font_name, _pl_g_hershey_font_info[i].name);
	    drawstate->true_font_size = drawstate->font_size;

	    drawstate->font_type = PL_F_HERSHEY;
	    drawstate->typeface_index = _pl_g_hershey_font_info[i].typeface_index;
	    drawstate->font_index = _pl_g_hershey_font_info[i].font_index;
	    drawstate->font_is_iso8859_1 = _pl_g_hershey_font_info[i].iso8859_1;

	    /* N.B. this macro uses true_font_size */
	    drawstate->font_cap_height = 
	      MAP_HERSHEY_UNITS_TO_USER_UNITS(HERSHEY_CAPHEIGHT, drawstate);
	    drawstate->font_ascent = 
	      MAP_HERSHEY_UNITS_TO_USER_UNITS(HERSHEY_ASCENT, drawstate);
	    drawstate->font_descent = 
	      MAP_HERSHEY_UNITS_TO_USER_UNITS(HERSHEY_DESCENT, drawstate);
	    
	    return true;
	  }
    }
  return false;
}

static bool
_match_pcl_font (plDrawState *drawstate)
{
  int i = -1;

  /* is font a PCL font in libplot's database? */
  while (_pl_g_pcl_font_info[++i].ps_name)
    {
      if (strcasecmp (_pl_g_pcl_font_info[i].ps_name, 
		      drawstate->font_name) == 0
	  /* try alternative PS font name if any */
	  || (_pl_g_pcl_font_info[i].ps_name_alt != NULL
	      && strcasecmp (_pl_g_pcl_font_info[i].ps_name_alt, 
			     drawstate->font_name) == 0)
	  /* try X font name too */
	  || strcasecmp (_pl_g_pcl_font_info[i].x_name, 
			 drawstate->font_name) == 0)
	{
	  free ((char *)drawstate->true_font_name);
	  drawstate->true_font_name = 
	    (const char *)_pl_xmalloc (strlen (_pl_g_pcl_font_info[i].ps_name) + 1);
	  strcpy ((char *)drawstate->true_font_name, _pl_g_pcl_font_info[i].ps_name);
	  drawstate->true_font_size = drawstate->font_size;

	  drawstate->font_type = PL_F_PCL;
	  drawstate->typeface_index = _pl_g_pcl_font_info[i].typeface_index;
	  drawstate->font_index = _pl_g_pcl_font_info[i].font_index;
	  drawstate->font_is_iso8859_1 = _pl_g_pcl_font_info[i].iso8859_1;

	  drawstate->font_ascent 
	    = drawstate->true_font_size
	      * (double)(_pl_g_pcl_font_info[i].font_ascent)/1000.0;
	  drawstate->font_descent 
	    = drawstate->true_font_size
	      * (double)(_pl_g_pcl_font_info[i].font_descent)/1000.0;
	  drawstate->font_cap_height 
	    = drawstate->true_font_size
	      * (double)(_pl_g_pcl_font_info[i].font_cap_height)/1000.0;
	  return true;
	}
    }
  return false;
}

static bool
_match_ps_font (plDrawState *drawstate)
{
  int i = -1;

  /* is font a PS font in libplot's database ? */
  while (_pl_g_ps_font_info[++i].ps_name)
    {
      if (strcasecmp (_pl_g_ps_font_info[i].ps_name, 
		      drawstate->font_name) == 0
	  /* try alternative PS font name if any */
	  || (_pl_g_ps_font_info[i].ps_name_alt != NULL
	      && strcasecmp (_pl_g_ps_font_info[i].ps_name_alt, 
			     drawstate->font_name) == 0)
	  /* try 2nd alternative PS font name if any */
	  || (_pl_g_ps_font_info[i].ps_name_alt2 != NULL
	      && strcasecmp (_pl_g_ps_font_info[i].ps_name_alt2, 
			     drawstate->font_name) == 0)
	  /* try X font name too */
	  || strcasecmp (_pl_g_ps_font_info[i].x_name, 
			 drawstate->font_name) == 0
	  /* try alternative X font name if any */
	  || (_pl_g_ps_font_info[i].x_name_alt != NULL
	      && strcasecmp (_pl_g_ps_font_info[i].x_name_alt,
			     drawstate->font_name) == 0))
	{
	  free ((char *)drawstate->true_font_name);
	  drawstate->true_font_name = 
	    (const char *)_pl_xmalloc (strlen (_pl_g_ps_font_info[i].ps_name) + 1);
	  strcpy ((char *)drawstate->true_font_name, _pl_g_ps_font_info[i].ps_name);

	  drawstate->true_font_size = drawstate->font_size;

	  drawstate->font_type = PL_F_POSTSCRIPT;
	  drawstate->typeface_index = _pl_g_ps_font_info[i].typeface_index;
	  drawstate->font_index = _pl_g_ps_font_info[i].font_index;
	  drawstate->font_is_iso8859_1 = _pl_g_ps_font_info[i].iso8859_1;

	  drawstate->font_ascent 
	    = drawstate->true_font_size
	      * (double)(_pl_g_ps_font_info[i].font_ascent)/1000.0;
	  drawstate->font_descent 
	    = drawstate->true_font_size
	      * (double)(_pl_g_ps_font_info[i].font_descent)/1000.0;
	  drawstate->font_cap_height
	    = drawstate->true_font_size
	      * (double)(_pl_g_ps_font_info[i].font_cap_height)/1000.0;
	  return true;
	}
    }
  return false;
}

static bool
_match_stick_font (plDrawState *drawstate, bool have_extra_stick_fonts)
{
  int i = -1;

  /* is font a PCL font in libplot's database? */
  while (_pl_g_stick_font_info[++i].ps_name)
    {
      if (_pl_g_stick_font_info[i].basic == false
	  && !have_extra_stick_fonts)
	/* not a basic Stick font, and this Plotter supports only the basic
	   ones */
	continue;
      
      if (strcasecmp (_pl_g_stick_font_info[i].ps_name, 
		      drawstate->font_name) == 0)
	/* fill in fields */
	{
	  free ((char *)drawstate->true_font_name);
	  drawstate->true_font_name = 
	    (const char *)_pl_xmalloc (strlen (_pl_g_stick_font_info[i].ps_name) + 1);
	  strcpy ((char *)drawstate->true_font_name, _pl_g_stick_font_info[i].ps_name);
	  drawstate->true_font_size = drawstate->font_size;
	  drawstate->true_font_size = drawstate->font_size;
	  drawstate->true_font_size = drawstate->font_size;

	  drawstate->font_type = PL_F_STICK;
	  drawstate->typeface_index = _pl_g_stick_font_info[i].typeface_index;
	  drawstate->font_index = _pl_g_stick_font_info[i].font_index;
	  drawstate->font_is_iso8859_1 = _pl_g_stick_font_info[i].iso8859_1;

	  drawstate->font_ascent 
	    = drawstate->true_font_size
	    * (double)(_pl_g_stick_font_info[i].font_ascent)/1000.0;
	  drawstate->font_descent 
	    = drawstate->true_font_size
	    * (double)(_pl_g_stick_font_info[i].font_descent)/1000.0;
	  drawstate->font_cap_height
	    /* The `0.7' is undocumented HP magic; see comments in
	       h_font.c and g_fontd2.c */
	    = 0.7 * drawstate->true_font_size;
	  
	  return true;
	}
    }
  return false;
}

/* This is the generic version of the _retrieve_font method, which does
   nothing.  Many types of Plotter use this, but some, e.g., FigPlotters
   and XDrawablePlotters (and X Plotters) override it.  See
   _pl_f_retrieve_font() and _pl_x_retrieve_font(). */

bool
_pl_g_retrieve_font (S___(Plotter *_plotter))
{
  return true;
}