%%	options

copyright owner	=	Dirk Krause
copyright year	=	2012-2014
license		=	bsd



%%	header

#ifdef __cplusplus
extern "C" {
#endif

/**	Check whether or not an object is a background rectangle.
	A background rectangle is not drawn to output, it is only
	used to calculate the bounding box of the drawing.
	@param	obj	Object to check.
	@param	objno	Object number in storage.
	@return	1 for background rectangle, 0 for normal object.
*/
int
dk3fig_tool_is_bgrect(dk3_fig_obj_t const *obj, unsigned long objno);

/**	Find line width for object.
	@param	drw	Drawing to which the object belongs.
	@param	obj	Object to find line width for.
	@param	ec	Pointer to error code variable, may be NULL.
	@return	Positive line width in Fig units on success, 0.0 on error.
*/
double
dk3fig_tool_get_lw(
  dk3_fig_drawing_t const	*drw,
  dk3_fig_obj_t	const		*obj,
  int				*ec
);

/**	Get object line width in bp.
	@param	drw	Drawing to which the object belongs.
	@param	obj	Object to find line width for.
	@param	ec	Pointer to error code variable, may be NULL.
	@return	Positive line width in Fig units on success, 0.0 on error.
*/
double
dk3fig_tool_get_lw_in_bp(
  dk3_fig_drawing_t const	*drw,
  dk3_fig_obj_t const		*obj,
  int				*ec
);

/**	Calculate kappa value for arc.
	To approximate arcs using Bezier spline segments we calculate
	the control points as xcs = xstart + kappa * x'(0) and
	xce = xend - kappa * x'(1). Using a kappa depending on the
	angle alpha results in a better approximation than using the
	fixed constant 1/3.
	@param	alpha	Arc angle.
	@param	ec	Pointer to error code variable, may be NULL.
	@return	Non-negative value on success, -1.0 on error.
*/
double
dk3fig_tool_arc_kappa(double alpha, int *ec);

/**	Find number of Bezier segments per X-spline segment.
	@param	drw	Drawing.
	@param	primobj	Flag: Primary object (1=object, 0=arrowhead).
	@return	Number of Bezier segments per X-spline segment.
*/
size_t
dk3fig_tool_xssbs(dk3_fig_drawing_t *drw, int primobj);

/**	Calculate distance between two points.
	@param	p1	Point 1.
	@param	p2	Point 2.
	@param	ec	Pointer to error code variable, may be NULL.
	@return	Distance value.
*/
double
dk3fig_tool_point_distance(
  dk3_fig_poly_point_t const	*p1,
  dk3_fig_poly_point_t const	*p2,
  int				*ec
);

/**	Move polyline points to the left to skip first segment.
	@param	dst	Destination pointer (address of element 0).
	@param	src	Source pointer (address of element 1).
	@param	np	Number of elements to shift.
*/
void
dk3fig_tool_poly_point_move_left(
  dk3_fig_poly_point_t		*dst,
  dk3_fig_poly_point_t		*src,
  size_t			 np
);

/**	Shorten a line segment.
	@param	endpoint	Endpoint of the polyline.
	@param	innerpoint	Inner point of the polyline.
	@param	distance	Distance to cut.
	@param	ec		Pointer to error code variable, may be NULL.
	@return	1 on success, 0 on error (point distance too short).
*/
int
dk3fig_tool_cut_segment(
  dk3_fig_poly_point_t		*endpoint,
  dk3_fig_poly_point_t const	*innerpoint,
  double			 distance,
  int				*ec
);

/**	Find operations necessary to draw an object.
	@param	drw	Drawing.
	@param	obj	Object.
	@return	Drawing operations combination, see @ref dk3figoperations.
*/
int
dk3fig_tool_get_operation(dk3_fig_drawing_t *drw, dk3_fig_obj_t *obj);

/**	Find RGB color (double values).
	@param	rgb	Color structure to set up.
	@param	drw	Drawing to find color for.
	@param	colno	Color number.
	@param	fs	Fill style.
*/
void
dk3fig_tool_find_color(
  dk3_rgb_color_t	*rgb,
  dk3_fig_drawing_t	*drw,
  int			 colno,
  int			 fs
);

/**	Find RGB color (int values).
	@param	dst	Color structure to set up.
	@param	drw	Drawing to find color for.
	@param	colno	Color number.
	@param	fs	Fill style.
*/
void
dk3fig_tool_find_int_color(
  dk3_fig_color_t	*dst,
  dk3_fig_drawing_t	*drw,
  int			 colno,
  int			 fs
);

/**	Rotate a point.
	@param	point	Point to rotate.
	@param	angle	Rotation angle in radians.
	@param	ec	Pointer to error code variable, may be NULL.
*/
void
dk3fig_tool_rotate_point(
  dk3_fig_poly_point_t	*point,
  double		 angle,
  int			*ec
);

/**	Rotate a spline point.
	@param	point	Point to rotate.
	@param	angle	Rotation angle in radians.
	@param	ec	Pointer to error code variable, may be NULL.
*/
void
dk3fig_tool_rotate_spoint(
  dk3_fig_spline_point_t	*point,
  double			 angle,
  int				*ec
);

/**	Shift a point.
	@param	point	Point to shift.
	@param	x	X shift.
	@param	y	Y shift.
	@param	ec	Pointer to error code variable, may be NULL.
*/
void
dk3fig_tool_shift_point(
  dk3_fig_poly_point_t	*point,
  double		 x,
  double		 y,
  int			*ec
);

/**	Shift a spline point.
	@param	point	Point to shift.
	@param	x	X shift.
	@param	y	Y shift.
	@param	ec	Pointer to error code variable, may be NULL.
*/
void
dk3fig_tool_shift_spoint(
  dk3_fig_spline_point_t	*point,
  double			 x,
  double			 y,
  int				*ec
);

/**	Compare two font structures.
	Comparison by font number first, font size later.
	@param	l	Left font structure.
	@param	r	Right font structure.
	@param	cr	Comparison criteria, ignored.
	@return	Comparison result.
*/
int
dk3fig_tool_font_compare(void const *l, void const *r, int cr);

/**	Find PS font number for text object.
	@param	obj	Text object.
	@return	Non-negative font number on success
	(PS font suitable for this text object),
	-1 on error (not a text object or hidden or special text).
*/
int
dk3fig_tool_ps_font_number(dk3_fig_obj_t *obj);

/**	Check whether a new color must be set.
	@param	hc1	Flag: Old color configured.
	@param	r1	Old red.
	@param	g1	Old green.
	@param	b1	Old blue.
	@param	r2	New red.
	@param	g2	New green.
	@param	b2	New blue.
	@return	1 if the color must be set, 0 otherwise.
*/
int
dk3fig_tool_must_set_color(
  int		hc1,
  double	r1,
  double	g1,
  double	b1,
  double	r2,
  double	g2,
  double	b2
);

/**	Check whether we must set up a new font.
	@param	hfn	Flag: Have old font number and size.
	@param	ofn	Old font number.
	@param	ofs	Old font size.
	@param	nfn	New font number.
	@param	nfs	New font size.
	@return	1 if we must install the new font, 0 otherwise.
*/
int
dk3fig_tool_must_set_font(
  int		hfn,
  int		ofn,
  double	ofs,
  int		nfn,
  double	nfs
);

/**	Obtain short output file name as 8-bit character string.
	The result of this function is used as argument to an
	includegraphics LaTeX instruction.
	@param	fullName	Full name of output file.
	@param	app		Application structure.
	@return	Pointer to 8-bit character string on success, NULL on error.
*/
char const *
dk3fig_tool_short_output_file_name(
  dkChar const		*fullName,
  dk3_app_t		*app
);

/**	Compare two text handling entries.
	@param	l	Left pointer.
	@param	r	Right pointer.
	@param	cr	Comparison criteria.
	@return	Comparison result.
*/
int
dk3fig_tool_text_handling_compare(void const *l, void const *r, int cr);

#ifdef __cplusplus
}
#endif

%%	module


#include "dk3all.h"
#include "dk3fig.h"
#include "dk3figto.h"
#include "fig2lat.h"



$!trace-include



/**	Color palette for colors 0...31 as calculated from the floating point
	numbers.
*/
static dk3_fig_color_t	dk3fig_tool_low_rgb[] = {
  /*  0: black */        {  0,   0,   0,   0 },
  /*  1: blue */         {  1,   0,   0, 255 },
  /*  2: green */        {  2,   0, 255,   0 },
  /*  3: cyan */         {  3,   0, 255, 255 },
  /*  4: red */          {  4, 255,   0,   0 },
  /*  5: magenta */      {  5, 255,   0, 255 },
  /*  6: yellow */       {  6, 255, 255,   0 },
  /*  7: white */        {  7, 255, 255, 255 },
  /*  8: dark blue */    {  8,   0,   0, 143 },
  /*  9: blue */         {  9,   0,   0, 176 },
  /* 10: blue */         { 10,   0,   0, 209 },
  /* 11: blue */         { 11, 135, 207, 255 },
  /* 12: dark green */   { 12,   0, 143,   0 },
  /* 13: green */        { 13,   0, 176,   0 },
  /* 14: green */        { 14,   0, 209,   0 },
  /* 15: dark cyan */    { 15,   0, 143, 143 },
  /* 16: cyan */         { 16,   0, 176, 176 },
  /* 17: cyan */         { 17,   0, 209, 209 },
  /* 18: dark red */     { 18, 143,   0,   0 },
  /* 19: red */          { 19, 176,   0,   0 },
  /* 20: red */          { 20, 209,   0,   0 },
  /* 21: dark magenta */ { 21, 143,   0, 143 },
  /* 22: magenta */      { 22, 176,   0, 176 },
  /* 23: magenta */      { 23, 209,   0, 209 },
  /* 24: dark brown */   { 24, 127,  48,   0 },
  /* 25: brown */        { 25, 160,  63,   0 },
  /* 26: brown */        { 26, 191,  97,   0 },
  /* 27: dark pink */    { 27, 255, 127, 127 },
  /* 28: pink */         { 28, 255, 160, 160 },
  /* 29: pink */         { 29, 255, 191, 191 },
  /* 30: pink */         { 30, 255, 224, 224 },
  /* 31: gold */         { 31, 255, 214,   0 }
};



int
dk3fig_tool_is_bgrect(dk3_fig_obj_t const *obj, unsigned long objno)
{
  int 		 back = 0;
  if(obj) {
    if(0UL == objno) {
      if(DK3_FIG_OBJ_POLYLINE == obj->ot) {
        if(2 == obj->st) {
          if(999 == obj->la) {
	    if(0 == obj->lw) {
	      if(-1 == obj->fi) {
	        if((-1 == obj->pc) || (7 == obj->pc)) {
	          back = 1;
	        }
	      }
	    }
	  }
        }
      }
    }
  }
  return back;
}



double
dk3fig_tool_get_lw(
  dk3_fig_drawing_t const	*drw,
  dk3_fig_obj_t const		*obj,
  int				*ec
)
{
  int			 mec = 0;	/* Mathematical error code. */
#if VERSION_BEFORE_20140330
  double		 lw;		/* Line width. */
#endif
  double		 back = 0.0;
  $? "+ dk3fig_tool_get_lw"
#if VERSION_BEFORE_20140330
  if((drw) && (obj)) {
    lw = (double)(obj->lw); $? ". lw=%lg res=%lg", lw, drw->res
    back = dk3ma_d_mul_ok(lw, drw->res, &mec) / 80.0;	$? ". back = %lg", back
    if(drw->lighten) { back = back / 2.0; }		$? ". back = %lg", back
    if(mec) {
      back = 0.0;
      if(ec) { *ec = mec; }
    }
  }
#else
  if ((drw) && (obj)) {
    /* back = obj->lw * drw->lwbp * drw->res / 72 */
    back = dk3ma_d_mul_ok(
      dk3ma_d_mul_ok(obj->lw, drw->lwbp, &mec),
      drw->res,
      &mec
    ) / 72.0;
    if (mec) {
      back = 0.0;
      if (ec) { *ec = mec; }
    }
  }
#endif
  $? "- dk3fig_tool_get_lw %lg", back
  return back;
}



double
dk3fig_tool_get_lw_in_bp(
  dk3_fig_drawing_t const	*drw,
  dk3_fig_obj_t const		*obj,
  int				*ec
)
{
  double		 back	= 0.0;
  int			 mec	= 0;
  if ((drw) && (obj)) {
    back = dk3ma_d_mul_ok(obj->lw, drw->lwbp, &mec);
    if (mec) {
      back = 0.0;
      if (ec) { *ec = mec; }
    }
  }
  return back;
}


double
dk3fig_tool_arc_kappa(double alpha, int *ec)
{
  double	 back;
  double	 emcosa;	/* 1 - cos(alpha). */
  int		 mec = 0;	/* Mathematical error code. */
  $? "+ dk3fig_tool_arc_kappa alpha=%lg", alpha
  emcosa = 1.0 - cos(alpha);
  back = dk3ma_d_div_ok(
    ((2.0 * sqrt(8.0 * emcosa)) - (4.0 * sin(alpha))),
    dk3ma_d_mul_ok(alpha, (3.0 * emcosa), &mec),
    &mec
  );
  if(mec) {
    back = -1.0;
    if(ec) { *ec = mec; }
  } $? "- dk3fig_tool_arc_kappa %lg", back
  return back;
}



size_t
dk3fig_tool_xssbs(dk3_fig_drawing_t *drw, int primobj)
{
  size_t	 back = 8;
  $? "+ dk3fig_tool_xssbs"
  if(drw)		{ back = drw->xssbs; }
  if(!(primobj))	{ back = back / 2; }
  if(back < 2)		{ back = 2; }
  $? "- dk3fig_tool_xssbs %u", (unsigned)back
  return back;
}



double
dk3fig_tool_point_distance(
  dk3_fig_poly_point_t	const	*p1,
  dk3_fig_poly_point_t	const	*p2,
  int				*ec
)
{
  double	 back = 0.0;
  $? "+ dk3fig_tool_point_distance"
  if((p1) && (p2)) {
    back = sqrt(
      dk3ma_d_add_ok(
        dk3ma_d_square_ok(
          dk3ma_d_sub_ok(p2->x, p1->x, ec),
	  ec
        ),
        dk3ma_d_square_ok(
          dk3ma_d_sub_ok(p2->y, p1->y, ec),
	  ec
        ),
        ec
      )
    );
  } $? "- dk3fig_tool_point_distance %lg", back
  return back;
}



void
dk3fig_tool_poly_point_move_left(
  dk3_fig_poly_point_t		*dst,
  dk3_fig_poly_point_t		*src,
  size_t			 np
)
{
  dk3_fig_poly_point_t		*dptr;	/* Destination buffer pointer. */
  dk3_fig_poly_point_t		*sptr;	/* Source buffer pointer. */
  size_t			 i;	/* Index to traverse all elements. */
  $? "+ dk3fig_tool_poly_point_move_left"
  if((dst) && (src) && (np)) {
    dptr = dst; sptr = src; i = np;
    while(i--) { *(dptr++) = *(sptr++); }
  } $? "- dk3fig_tool_poly_point_move_left"
}



int
dk3fig_tool_cut_segment(
  dk3_fig_poly_point_t		*endpoint,
  dk3_fig_poly_point_t const	*innerpoint,
  double			 distance,
  int				*ec
)
{
  double	 delta;		/* Segment length. */
  double	 q;		/* Cut factor. */
  double	 newx;		/* New x of end point. */
  double	 newy;		/* New y of end point. */
  int		 back = 0;
  int		 mec = 0;	/* Mathematical error code. */
  $? "+ dk3fig_tool_cut_segment"
  if((endpoint) && (innerpoint)) {		$? ". points ok"
    $? ". (%lg,%lg) (%lg,%lg)", endpoint->x, endpoint->y, innerpoint->x, innerpoint->y
    if(0.0 < distance) {			$? ". distance %lg ok", distance
      delta = sqrt(
        dk3ma_d_add_ok(
	  dk3ma_d_square_ok(
	    dk3ma_d_sub_ok(innerpoint->x, endpoint->x, &mec),
	    &mec
	  ),
	  dk3ma_d_square_ok(
	    dk3ma_d_sub_ok(innerpoint->y, endpoint->y, &mec),
	    &mec
	  ),
	  &mec
	)
      );	$? ". delta=%lg distance=%lg", delta, distance
      if(delta > distance) {			$? ". delta ok"
        q = dk3ma_d_div_ok(distance, delta, &mec);	$? ". q=%lg", q
	newx = dk3ma_d_add_ok(
	  endpoint->x,
	  dk3ma_d_mul_ok(
	    q,
	    dk3ma_d_sub_ok(innerpoint->x, endpoint->x, &mec),
	    &mec
	  ),
	  &mec
	);
	newy = dk3ma_d_add_ok(
	  endpoint->y,
	  dk3ma_d_mul_ok(
	    q,
	    dk3ma_d_sub_ok(innerpoint->y, endpoint->y, &mec),
	    &mec
	  ),
	  &mec
	);
	if(0 == mec) {		$? ". (%lg,%lg)", newx, newy
	  endpoint->x = newx; endpoint->y = newy;
	  back = 1;
	}
      } else {				$? "! segment too short"
      }
    } else {				$? "! distance"
    }
  } else {				$? "! points"
  }
  if(mec) { if(ec) { *ec = mec; } } $? "- dk3fig_tool_cut_segment %d", back
  return back;
}



int
dk3fig_tool_get_operation(dk3_fig_drawing_t *drw, dk3_fig_obj_t *obj)
{
  int		 back = 0;
  $? "+ dk3fig_tool_get_operation"
  if((drw) && (obj)) {
    if(0 < obj->lw) {
      if(obj->pc != drw->transcol) {
        back |= DK3_FIG_OP_STROKE;
      }
    }
    if(obj->cl) {
      if(-1 != obj->fi) {
        if(obj->fc != drw->transcol) {
          back |= DK3_FIG_OP_FILL;
        }
        if(40 < obj->fi) {
          if(63 > obj->fi) {
	    back |= DK3_FIG_OP_PATTERN;
	  }
        }
      }
    }
  } $? "- dk3fig_tool_get_operation %d", back
  return back;
}



/**	Mix a color component against black or white.
	@param	x	Color component to mix.
	@param	y	Black (0) or white (1).
	@param	alpha	Ratio of x in 1/20.
	@param	ec	Pointer to error code variable, may be NULL.
	@return	Mix result.
*/
static
double
dk3fig_tool_color_alpha(double x, double y, double alpha, int *ec)
{
  double	 back;
  $? "+ dk3fig_tool_color_alpha x=%lg y=%lg, alpha=%lg", x, y, alpha
  back = dk3ma_d_add_ok(
    dk3ma_d_mul_ok(x, alpha, ec),
    dk3ma_d_mul_ok(y, dk3ma_d_sub_ok(20.0, alpha, ec), ec),
    ec
  ) / 20.0; $? "- dk3fig_tool_color_alpha %lg", back
  return  back;
}



/**	Modify color depending on the fill style.
	@param	rgb	Destination and source pointer.
	@param	endval	Value to mix against.
	@param	twe	Coeffiecient for rgb, 1/20.
*/
static
void
dk3fig_tool_mix_color(
  dk3_rgb_color_t	*rgb,
  double		 endval,
  int			 twe
)
{
  dk3_rgb_color_t	myrgb;	/* Intermediate result buffer. */
  double		alpha;	/* Factor for mixing. */
  int			ec = 0;	/* Mathematical error code. */
  $? "+ dk3fig_tool_mix_color"
  myrgb.r = rgb->r;
  myrgb.g = rgb->g;
  myrgb.b = rgb->b;
  alpha = (double)twe;
  myrgb.r = dk3fig_tool_color_alpha(rgb->r, endval, alpha, &ec);
  myrgb.g = dk3fig_tool_color_alpha(rgb->g, endval, alpha, &ec);
  myrgb.b = dk3fig_tool_color_alpha(rgb->b, endval, alpha, &ec);
  if(0 == ec) {
    rgb->r = myrgb.r; rgb->g = myrgb.g; rgb->b = myrgb.b;
  } $? "- dk3fig_tool_mix_color"
}



/**	Mix one color value against another value.
	@param	cv	Primary color.
	@param	ov	Other color (background color) to mix against.
	@param	twe	Weight of cv, multiples of 1/20.
	@return	Color mixing result.
*/
static
int
dk3fig_tool_mix_one_int_color(int cv, int ov, int twe)
{
  int			 back;
  back = ((twe * cv) + ((20 - twe) * ov)) / 20;
  return back;
}



/**	Mix color against background color value (white or black).
	@param	col	Color to mix, input and output.
	@param	val	Value to mix against (background color 0=black, 255=white).
	@param	twe	Weight of input color, multiples of 1/20.
*/
static
void
dk3fig_tool_mix_int_color(
  dk3_fig_color_t		*col,
  int				 val,
  int				 twe
)
{
  col->r = dk3fig_tool_mix_one_int_color(col->r, val, twe);
  col->g = dk3fig_tool_mix_one_int_color(col->g, val, twe);
  col->b = dk3fig_tool_mix_one_int_color(col->b, val, twe);
}



void
dk3fig_tool_find_color(
  dk3_rgb_color_t	*rgb,
  dk3_fig_drawing_t	*drw,
  int			 colno,
  int			 fs
)
{
  dk3_fig_color_t	*pfc;		/* Pointer to already defined color. */
  int			 mycolno;	/* Color number. */
  $? "+ dk3fig_tool_find_color %d", colno
  mycolno = 0;
  if(rgb) {
    rgb->r = rgb->g = rgb->b = 0.0;
    if(drw) {						$? ". drw"
      if(drw->scol) {					$? ". scol"
        if(drw->icol) {					$? ". icol"
	  if((0 <= colno) && (colno <= 31)) {		$? ". built-in color"
	    pfc = &(dk3fig_tool_low_rgb[colno]);
	  } else {					$? ". defined color"
	    pfc = (dk3_fig_color_t *)dk3sto_it_find_like(
	      drw->icol, (void *)(&colno), 1
	    );
	  }
	  if(pfc) {
	    rgb->r = (double)(pfc->r) / 255.0;
	    rgb->g = (double)(pfc->g) / 255.0;
	    rgb->b = (double)(pfc->b) / 255.0;
	    mycolno = colno;
	  } else {			$? "! color not found %d", colno
	    if(-1 != colno) {
	      /* ERROR: Color not found, using black as default! */
	      dk3app_log_1(drw->app, DK3_LL_WARNING, drw->msg, 7);
	    }
	  }
	} else {					$? "! icol"
	}
      } else {						$? "! scol"
      }
    } else {						$? "! drw"
    }
    if(-1 < fs) {
      if(20 > fs) {		$? ". mix against black"
        switch(mycolno) {
          case 0: {
	    dk3fig_tool_mix_color(rgb, 1.0, fs);
	  } break;
	  case 7: {
	    dk3fig_tool_mix_color(rgb, 0.0, fs);
	  } break;
	  default: {
	    dk3fig_tool_mix_color(rgb, 0.0, fs);
	  } break;
        }
      } else {
        if(41 > fs) {
          if(20 < fs) {		$? ". mix against white"
	    switch(mycolno) {
	      case 0: {
	      } break;
	      case 7: {
	      } break;
	      default: {
	        dk3fig_tool_mix_color(rgb, 1.0, (40 - fs));
	      } break;
	    }
	  }
        }
      }
    }
    if(drw->codi) {
      rgb->r = dk3ma_d_restrict_digits(rgb->r, drw->codi);
      rgb->g = dk3ma_d_restrict_digits(rgb->g, drw->codi);
      rgb->b = dk3ma_d_restrict_digits(rgb->b, drw->codi);
    }
  } $? "- dk3fig_tool_find_color"
}



void
dk3fig_tool_find_int_color(
  dk3_fig_color_t	*dst,
  dk3_fig_drawing_t	*drw,
  int			 colno,
  int			 fs
)
{
  dk3_fig_color_t	*pfc = NULL;
  int			 mycolno;

  mycolno = 0;
  if(dst) {
    dst->r = dst->g = dst->b = 0;
    if(drw) {
      if((0 <= colno) && (colno <= 31)) {
        pfc = &(dk3fig_tool_low_rgb[colno]);
      } else {
        if(drw->scol) {
	  if(drw->icol) {
	    pfc = (dk3_fig_color_t *)dk3sto_it_find_like(
	      drw->icol, (void *)(&colno), 1
	    );
	  }
	}
      }
      if(pfc) {
        mycolno = colno;
        dst->r = pfc->r; dst->g = pfc->g; dst->b = pfc->b;
      } else {
        if(-1 != colno) {
	  /* ERROR: Color not found, using black as default! */
	  dk3app_log_1(drw->app, DK3_LL_WARNING, drw->msg, 7);
	}
      }
    }
    if(-1 < fs) {
      if(20 > fs) {			$? ". mix against black"
        switch(mycolno) {
	  case 0: {
	    dk3fig_tool_mix_int_color(dst, 255, fs);
	  } break;
	  case 7: {
	    dk3fig_tool_mix_int_color(dst, 0, fs);
	  } break;
	  default: {
	    dk3fig_tool_mix_int_color(dst, 0, fs);
	  } break;
	}
      } else {
        if((20 < fs) && (41 > fs)) {	$? ". mix against white"
	  switch(mycolno) {
	    case 0: {
	    } break;
	    case 7: {
	    } break;
	    default: {
	      dk3fig_tool_mix_int_color(dst, 255, (40 - fs));
	    } break;
	  }
	}
      }
    }
  }
}



void
dk3fig_tool_rotate_point(
  dk3_fig_poly_point_t	*point,
  double			 angle,
  int				*ec
)
{
  double	r;		/* Radius from origin to point. */
  double	alpha;		/* angle of point. */

  if(point) {
    r = sqrt(
      dk3ma_d_add_ok(
        dk3ma_d_square_ok(point->x, ec),
        dk3ma_d_square_ok(point->y, ec),
        ec
      )
    );
    alpha = dk3ma_d_atan2(point->y, point->x);
    alpha = dk3ma_d_add_ok(alpha, angle, ec);
    point->x = r * cos(alpha);
    point->y = r * sin(alpha);
  }
}



void
dk3fig_tool_rotate_spoint(
  dk3_fig_spline_point_t	*point,
  double			 angle,
  int				*ec
)
{
  double	r;		/* Radius origin to point. */
  double	alpha;		/* Angle of point. */

  if(point) {
    r = sqrt(
      dk3ma_d_add_ok(
        dk3ma_d_square_ok(point->x, ec),
        dk3ma_d_square_ok(point->y, ec),
        ec
      )
    );
    alpha = dk3ma_d_atan2(point->y, point->x);
    alpha = dk3ma_d_add_ok(alpha, angle, ec);
    point->x = r * cos(alpha);
    point->y = r * sin(alpha);
  }
}


void
dk3fig_tool_shift_point(
  dk3_fig_poly_point_t	*point,
  double		 x,
  double		 y,
  int			*ec
)
{
  if(point) {
    point->x = dk3ma_d_add_ok(point->x, x, ec);
    point->y = dk3ma_d_add_ok(point->y, y, ec);
  }
}



void
dk3fig_tool_shift_spoint(
  dk3_fig_spline_point_t	*point,
  double			 x,
  double			 y,
  int				*ec
)
{
  if(point) {
    point->x = dk3ma_d_add_ok(point->x, x, ec);
    point->y = dk3ma_d_add_ok(point->y, y, ec);
  }
}



int
dk3fig_tool_font_compare(void const *l, void const *r, int cr)
{
  int		 	 back = 0;
  dk3_fig_font_t const	*pl;		/* Left pointer. */
  dk3_fig_font_t const	*pr;		/* Right pointer. */
  if(l) {
    if(r) {
    } else {
      pl = (dk3_fig_font_t const *)l;
      pr = (dk3_fig_font_t const *)r;
      if(pl->psfont > pr->psfont) {
        back = 1;
      } else {
        if(pl->psfont < pr->psfont) {
	  back = -1;
	} else {
          if(pl->fontno > pr->fontno) {
            back = 1;
          } else {
            if(pl->fontno < pr->fontno) {
	      back = -1;
	    } else {
	      if(pl->fontsz > (pr->fontsz + 1.0e-6)) {
	        back = 1;
	      } else {
	        if(pl->fontsz < (pr->fontsz - 1.0e-6)) {
	          back = -1;
	        }
	      }
	    }
          }
	}
      }
      back = 1;
    }
  } else {
    if(r) {
      back = -1;
    }
  }
  return back;
}



int
dk3fig_tool_ps_font_number(dk3_fig_obj_t *obj)
{
  int		 back = -1;
  int		 ff;		/* Font flags. */

  if(obj) {
    if(DK3_FIG_OBJ_TEXT == obj->ot) {
      ff = (obj->dt).txt.ff;
      if(!(ff & DK3_FIG_FONT_FLAG_HIDDEN)) {
        if(!(ff & DK3_FIG_FONT_FLAG_SPECIAL)) {
          if(ff & DK3_FIG_FONT_FLAG_PS) {
            back = (obj->dt).txt.fo;
	  } else {
	    switch((obj->dt).txt.fo) {
	      case DK3_FIG_FONT_LATEX_BOLD: { back = 2; } break;
	      case DK3_FIG_FONT_LATEX_ITALIC: { back = 1; } break;
	      case DK3_FIG_FONT_LATEX_SANS_SERIF: { back = 16; } break;
	      case DK3_FIG_FONT_LATEX_TYPEWRITER: { back = 12; } break;
	      default: { back = 0; } break;
	    }
	  }
        }
      }
    }
  }
  return back;
}



int
dk3fig_tool_must_set_color(
  int		hc1,
  double	r1,
  double	g1,
  double	b1,
  double	r2,
  double	g2,
  double	b2
)
{
  int		 back = 1;
  int		 ec = 0;	/* Mathematical error code. */

  if(hc1) {
    if(1.0e-6 > fabs(dk3ma_d_sub_ok(r1, r2, &ec))) {
      if(1.0e-6 > fabs(dk3ma_d_sub_ok(g1, g2, &ec))) {
        if(1.0e-6 > fabs(dk3ma_d_sub_ok(b1, b2, &ec))) {
	  if(0 == ec) {
	    back = 0;
	  }
	}
      }
    }
  }
  return back;
}



int
dk3fig_tool_must_set_font(
  int		hfn,
  int		ofn,
  double	ofs,
  int		nfn,
  double	nfs
)
{
  int		 back = 1;
  int		 ec = 0;	/* Mathematical error code. */

  if(hfn) {
    if(ofn == nfn) {
      if(1.0e-6 > fabs(dk3ma_d_sub_ok(ofs, nfs, &ec))) {
        if(0 == ec) {
	  back = 0;
	}
      }
    }
  }
  return back;
}



/**	Compare two text handling structures.
	@param	l	Left text handling structure.
	@param	r	Right text handling structure.
	@param	cr	Comparison criteria (ignored).
	@return	Comparison result.
*/
int
dk3fig_tool_text_handling_compare(void const *l, void const *r, int cr)
{
  f2l_text_handling_t const	*pl;		/* Left pointer. */
  f2l_text_handling_t const	*pr;		/* Right pointer. */
  int				 back = 0;

  if(l) {
    if(r) {
      pl = (f2l_text_handling_t const *)l;
      pr = (f2l_text_handling_t const *)r;
      if(pl->psFontNo > pr->psFontNo) {
        back = 1;
      } else {
        if(pl->psFontNo < pr->psFontNo) {
	  back = -1;
	}
      }
      if(0 == back) {
        if(pl->fontSize > (pr->fontSize + 1.0e-6)) {
	  back = 1;
	} else {
	  if(pr->fontSize > (pl->fontSize + 1.0e-6)) {
	    back = -1;
	  }
	}
      }
    } else { back = 1; }
  } else {
    if(r) { back = -1; }
  }
  return back;
}



char const *
dk3fig_tool_short_output_file_name(
  dkChar const		*fullName,
  dk3_app_t		*app
)
{
  char			 buf[DK3_MAX_PATH];	/* Conversion buffer. */
  dkChar const		*snptr;			/* Start of old short name. */
  dkChar const		*ptr;			/* Traverse fullName. */
  char const		*back	= NULL;
  int			 res = 0;		/* Operation result. */
  $? "+ dk3fig_tool_short_output_file_name"
  if(fullName) {
    snptr = NULL; ptr = fullName;
    while(*ptr) {
      if((*ptr == dkT('/')) || (*ptr == dkT('\\'))) {
        snptr = ptr;
      }
      ptr++;
    }
    if(snptr) {
      snptr++;
    } else {
      snptr = fullName;
    }
    if(snptr) {
      switch(dk3app_get_encoding(app)) {
	case DK3_ENCODING_UTF8: {
	  res = dk3str_to_c8u_app(
	    buf, sizeof(buf), snptr, dk3app_get_encoding(app), app
	  );
	} break;
	default: {
	  res = dk3str_to_c8p_app(
	    buf, sizeof(buf), snptr, dk3app_get_encoding(app), app
	  );
	} break;
      }
      if(res) {
        back = dk3str_c8_dup_app(buf, app);
      }
    }
  } $? "- dk3fig_tool_short_output_file_name %s", TR_STR(back)
  return back;
}