/*
Copyright (c) 2004-2005, Dirk Krause
All rights reserved.

Redistribution and use in source and binary forms,
with or without modification, are permitted provided
that the following conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.
* Redistributions in binary form must reproduce the above 
  opyright notice, this list of conditions and the following
  disclaimer in the documentation and/or other materials
  provided with the distribution.
* Neither the name of the Dirk Krause nor the names of
  its contributors may be used to endorse or promote
  products derived from this software without specific
  prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
*/

#define DKFIGOPT_C	1
#include "dkfig.h"


#line 41 "dkfigopt.ctr"




typedef char *PCHAR;



/* {{{ Option line analysis */

static char *cmd00[] = { "tex",		"command",	NULL };
static char *cmd01[] = { "embed",	"fonts",	NULL };
static char *cmd02[] = { "normal",	"text",		NULL };
static char *cmd03[] = { "special",	"text",		NULL };
static char *cmd04[] = { "latex",	"font",		"setup", NULL };
static char *cmd05[] = { "web",		"palette",	NULL };
static char *cmd06[] = { "spline",	"segments",	NULL };
static char *cmd07[] = { "preamble",	"file",		NULL };
static char *cmd08[] = { "use",		"cs",		"setting", NULL };
static char *cmd09[] = { "lighten",	"look",		NULL };
static char *cmd10[] = { "verbose",	"output",	NULL};
static char *cmd11[] = { "pattern",	"line",		"width", NULL};
static char *cmd12[] = { "pattern",	"repeat",	NULL};
static char *cmd13[] = { "remove",	"zero",		"borders", NULL };
static char *cmd14[] = { "arrowhead",	"linejoin",	NULL};
static char *cmd15[] = { "use",		"metapost",	"arrowheads",	NULL};
static char *cmd16[] = { "min",		"iteration",	"steps",	NULL};
static char *cmd17[] = { "max",		"iteration",	"steps",	NULL};
static char *cmd18[] = { "fill",	"patterns",	NULL };
static char *cmd19[] = { "ps",		"level",	NULL };
static char *cmd20[] = { "dsc",		"comments",	NULL };
static char *cmd21[] = { "enable",	"write18",	NULL };
static char *cmd22[] = { "ps",		"showpage",	NULL };
static char *cmd23[] = { "keep",	"tex",		"files",	NULL };
static char *cmd24[] = { "font",	"scale",	"factor",	NULL };
static char *cmd25[] = { "ps",		"run-length",	"encoding",	NULL };
static char *cmd26[] = { "separated",	"rgb",		"channels",	NULL};
static char *cmd27[] = { "remove",	"bitmap",	"border",	NULL};
static char *cmd28[] = { "fill",	"bitmap",	"background",	NULL};
static char *cmd29[] = { "keep", "bitmap", "aspect", "ratio",	NULL };
static char *cmd30[] = { "bitmap",	"image",	"dictionary",	NULL };
static char *cmd31[] = { "force",	"garbage",	"collection",	NULL };
static char *cmd32[] = { "svg",		"version",	NULL };
static char *cmd33[] = { "use",		"css",		NULL };
static char *cmd34[] = { "wh",		"specification",	NULL };
static char *cmd35[] = { "embedded",	"svg",		"fragment",	NULL };
static char *cmd36[] = { "repeat",	"error",	"messages",	NULL };
static char *cmd37[] = { "accept",	"unknown",	"paper",	"size",	NULL};
static char *cmd38[] = { "prepare",	"for",	"modifications",	NULL};
static char *cmd39[] = { "dashpattern",	"dot",	"length",	NULL };
static char *cmd40[] = { "write",	"tex",	"command",	NULL };
static char *cmd41[] = { "remove",	"background",	"rectangle",	NULL };
static char *cmd42[] = { "skip",	"all",	"texts",	NULL };
static char *cmd43[] = { "plain",	"text",	"streams",	NULL };
static char *cmd44[] = { "full",	"screen",	NULL};
static char *cmd45[] = { "position",	"digits",	NULL };
static char *cmd46[] = { "additional",	"trigonometric","digits", NULL };
static char *cmd47[] = { "color",	"digits",	NULL };
static char *cmd48[] = { "arc", "bezier", "steps", NULL };
static char *cmd49[] = { "tiled",	"patterns",	NULL };
static char *cmd50[] = { "flip",	"direction",	NULL };
static char *cmd51[] = { "interpolate",	"images",	NULL };
static char *cmd52[] = { "full",	"tex",	"file",	NULL };
static char *cmd53[] = { "background",	"rectangle",	"color",	NULL };
static char *cmd54[] = { "ps",		"setpagedevice",	NULL };
static char *cmd55[] = { "svg",		"fontsize",	"unit",	NULL };
static char *cmd56[] = { "font",	"configuration",	"file",	NULL };
static char *cmd57[] = { "utf-8",	NULL };

char **cmds[] = {
  /*  0 */	cmd00,
  /*  1 */	cmd01,
  /*  2 */	cmd02,
  /*  3 */	cmd03,
  /*  4 */	cmd04,
  /*  5 */	cmd05,
  /*  6 */	cmd06,
  /*  7 */	cmd07,
  /*  8 */	cmd08,
  /*  9 */	cmd09,
  /* 10 */	cmd10,
  /* 11 */	cmd11,
  /* 12 */	cmd12,
  /* 13 */	cmd13,
  /* 14 */	cmd14,
  /* 15 */	cmd15,
  /* 16 */	cmd16,
  /* 17 */	cmd17,
  /* 18 */	cmd18,
  /* 19 */	cmd19,
  /* 20 */	cmd20,
  /* 21 */	cmd21,
  /* 22 */	cmd22,
  /* 23 */	cmd23,
  /* 24 */	cmd24,
  /* 25 */	cmd25,
  /* 26 */	cmd26,
  /* 27 */	cmd27,
  /* 28 */	cmd28,
  /* 29 */	cmd29,
  /* 30 */	cmd30,
  /* 31 */	cmd31,
  /* 32 */	cmd32,
  /* 33 */	cmd33,
  /* 34 */	cmd34,
  /* 35 */	cmd35,
  /* 36 */	cmd36,
  /* 37 */	cmd37,
  /* 38 */	cmd38,
  /* 39 */	cmd39,
  /* 40 */	cmd40,
  /* 41 */	cmd41,
  /* 42 */	cmd42,
  /* 43 */	cmd43,
  /* 44 */	cmd44,
  /* 45 */	cmd45,
  /* 46 */	cmd46,
  /* 47 */	cmd47,
  /* 48 */	cmd48,
  /* 49 */	cmd49,
  /* 50 */	cmd50,
  /* 51 */	cmd51,
  /* 52 */	cmd52,
  /* 53 */	cmd53,
  /* 54 */	cmd54,
  /* 54 */	cmd55,
  /* 56 */	cmd56,
  /* 57 */	cmd57,
  NULL
};

/* }}} Option line analysis */



/* {{{ Arrowhead line join */

static char *ahlj_kw[] = {
  "m$itered", "r$ounded", "b$eveled",
  NULL
};

/* }}} Arrowhead line join */



/* {{{ Contigous fill patterns */

static char cont_kw[] = { "c$ontiguous" };

/* }}} Contigous fill patterns */



/* {{{ ignore keyword for enable write18 */

static char ignore_kw[] = { "i$gnore" };

/* }}} */



/* {{{ choose TeX/LaTeX command */

static char *tex_commands[] = { "latex", "tex", NULL };

/* }}} choose TeX/LaTeX command */



/* {{{ Font setup */

static char *font_setup_keywords[] = {
  /*  0 */ "handling",
  /*  1 */ "font",
  /*  2 */ "size",
  /*  3 */ "mbox",
  NULL
};

static char *font_setup_value_keywords[] = {
  /*  0 */ "none",
  /*  1 */ "tex",
  /*  2 */ "fig",
  /*  3 */ "similar",
  NULL
};

static char *latex_font_setup_keywords[] = {
  /*  0 */ "ams",
  /*  1 */ "pdf",
  /*  2 */ "newcent",
  /*  3 */ "ams12",
  /*  4 */ "pdf12",
  /*  5 */ "newcent12",
  NULL
};

/* }}} Font setup */


/* string component separator {{{ */
static char str_comma[] = { "," };
static char exploder_pattern[] = { " \t\r\n." };
/* }}}  */



/* {{{ known SVG versions */
static char *known_svg_versions[] = {
  "1.0", "1.1", "1.2",
  NULL
};
/* }}} */



/* {{{ how to specify SVG viewport */
static char *svg_viewport_specifications[] = {
  "po$ints",
  "pi$xels",
  "i$nches",
};
/* }}} */



/* {{{ how long must we make dots in dash-dotted lines */
static char *dp_dot_length[] = {
  "0", "linewidth", NULL
}; /* }}} */



/* {{{ flipping dirction */
static char *flip_styles[] = {
  "h$orizontal", "d$iagonal", NULL
}; /* }}} */



/* {{{ which colors do background rectangles have */
static char *bgcolordefs[] = {
  "d$efault",
  "w$hite",
  NULL
}; /* }}} */



/* {{{ dkfig_opt_compare

  Compare 2 options by line number.
  This function is used to build the sorted storage.

*/

int
dkfig_opt_compare DK_P3(void *,p1,void *,p2,int,cr)
{
  int back = 0;
  unsigned long ul, *ulptr;
  dk_fig_opt *fip1, *fip2;
  
  if (p1) {
    if (p2) {
      fip1 = (dk_fig_opt *)p1;
      fip2 = (dk_fig_opt *)p2;
      ulptr = (unsigned long *)p2;
      switch (cr) {
        case 1: {
	  ul = *ulptr;
	  if ( (fip1->number) > ul ) {
	    back = 1;
	  } else {
	    if ( (fip1->number) < ul ) {
	      back = -1;
	    }
	  }
	} break;
	default: {
	  if ( (fip1->number) > (fip2->number) ) {
	    back = 1;
	  } else {
	    if ( (fip1->number) < (fip2->number) ) {
	      back = -1;
	    }
	  }
	} break;
      }
    } else {
      back = 1;
    }
  } else {
    if (p2) {
      back = -1;
    }
  }
  
  return back;
}
/* }}} dkfig_opt_compare */



/* {{{ dkfig_opt_delete

  Destroy option data, release memory.

*/
void
dkfig_opt_delete DK_P1(dk_fig_opt *,o)
{
  char *cptr;
  
  if (o) {	
    cptr = o->name;
    if (cptr) { dk_delete(cptr); }
    o->name = NULL; o->number = 0UL;
    dk_delete(o);
  }
  
}
/* }}} dkfig_opt_delete */



/* {{{ dkfig_opt_new

  Create option data.

*/
dk_fig_opt *
dkfig_opt_new DK_P2(unsigned long,number,char *,text)
{
  dk_fig_opt *back = NULL;
  
  if (text) {
    back = dk_new(dk_fig_opt,1);
    if (back) {
      back->name = dkstr_dup(text);
      if (back->name) {
        back->number = number;
	back->used   = 0x00;
      } else {
        dk_delete(back); back = NULL;
      }
    }
  }
  
  return back;
}
/* }}} dkfig_opt_new */



/* {{{ dkfig_opt_get_text

  Retrieve option text.

*/
char *
dkfig_opt_get_text DK_P1(dk_fig_opt *,o)
{
  char *back = NULL;
  
  if (o) {
    back = o->name;
  }
  
  return back;
}
/* }}} dkfig_opt_get_text */



/* {{{ set_tex_command

  Select the TeX command (tex or latex).

*/
static
void
set_tex_command DK_P2(dk_fig_conversion *,c,char *,v)
{
  int p;
  char *cptr;
  
  if(v) {
    cptr = dkstr_start(v, NULL);
    if(cptr) {
      dkstr_chomp(cptr, NULL);
      p = dkstr_array_index(tex_commands, cptr, 0);
      if(p > 0) {
        c->opt1 |= DKFIG_OPT_OLD_TEX;
      } else {
        c->opt1 &= (~(DKFIG_OPT_OLD_TEX));
      }
    }
  }
  
}
/* }}} set_tex_command */



/* {{{ set_embed_fonts

  Check whether or not to embed fonts in output.

*/
static
void
set_embed_fonts DK_P2(dk_fig_conversion *,c,char *,v)
{
  int do_embed = 0; char *cptr;
  
  if(v) {
    cptr = dkstr_start(v, NULL);
    if(cptr) {
      dkstr_chomp(cptr, NULL);
      if(dkstr_is_bool(cptr)) {
        do_embed = dkstr_is_on(cptr); 
	if(do_embed) {
	  
	  c->opt1 &= (~(DKFIG_OPT_NO_EMBEDDED_FONTS));
	} else {
	  
	  c->opt1 |= DKFIG_OPT_NO_EMBEDDED_FONTS;
	}
      }
    }
  }
  
}
/* }}} set_embed_fonts */



/* {{{ scan_th

  Scan a string containing text handling configuration.

*/
static
int
scan_th DK_P3(dk_fig_conversion *,c,char *,v,int,old)
{
  int back = 0;
  int have_error = 0;
  char *cptr, *vptr, *nptr;
  int ck, cv;
  
  cptr = dkstr_start(v, NULL);
  have_error = 0;
  if(cptr) {
    dkstr_chomp(cptr, NULL);
    while(cptr) {
      ck = cv = -1;
      nptr = dkstr_next(cptr, str_comma);
      cptr = dkstr_start(cptr, NULL);
      if(cptr) {
        dkstr_chomp(cptr, NULL);
	vptr = dkstr_chr(cptr, ':');
	if(vptr) {
	  *(vptr++) = '\0';
	  dkstr_chomp(cptr, NULL);
	  vptr = dkstr_start(vptr, NULL);
	  if(vptr) {
	    dkstr_chomp(vptr, NULL);
	    cv = dkstr_array_index(font_setup_value_keywords,vptr,0);
	  }
	}
	ck = dkstr_array_index(font_setup_keywords,cptr,0);
	switch(ck) {
	  /* handling */
	  case 0: {
	    switch(cv) {
	      case 0: {
	        back &= (~(DKFIG_TH_HANDLING));
	      } break;
	      case 1: {
	        back |= DKFIG_TH_HANDLING;
	      } break;
	      default: {
	        have_error = 1; 
		/* Warning: Invalid text handling */
		dkfig_tool2_msg3(c, DK_LOG_LEVEL_WARNING, 32, 33, vptr);
	      } break;
	    }
	  } break;
	  /* font */
	  case 1: {
	    switch(cv) {
	      case 1: {
	        back =
		(back & (~(DKFIG_TH_FONT_MASK))) | DKFIG_TH_FONT_TEX;
	      } break;
	      case 2: {
	        back =
		(back & (~(DKFIG_TH_FONT_MASK))) | DKFIG_TH_FONT_FIG;
	      } break;
	      case 3: {
	        back =
		(back & (~(DKFIG_TH_FONT_MASK))) | DKFIG_TH_FONT_SIMILAR;
	      } break;
	      default: {
	        have_error = 1; 
		/* Warning: Invalid font */
		dkfig_tool2_msg3(c, DK_LOG_LEVEL_WARNING, 34, 35, vptr);
	      } break; 
	    }
	  } break;
	  /* size */
	  case 2: {
	    switch(cv) {
	      case 1: {
	        back &= (~(DKFIG_TH_SIZE_FIG));
	      } break;
	      case 2: {
	        back |= DKFIG_TH_SIZE_FIG;
	      } break;
	      default: {
	        have_error = 1; 
		/* Warning: Invalid text size handling */
		dkfig_tool2_msg3(c, DK_LOG_LEVEL_WARNING, 36, 37, vptr);
	      } break;
	    }
	  } break;
	  /* mbox */
	  case 3: {
	    switch(cv) {
	      case -1: {
	        back |= DKFIG_TH_MBOX;
	      } break;
	      case 0: {
	        back &= (~(DKFIG_TH_MBOX));
	      } break;
	      default: {
	        have_error = 1; 
		/* Warning: Invalid mbox specification */
		dkfig_tool2_msg1(c, DK_LOG_LEVEL_WARNING, 38);
	      } break;
	    }
	  } break;
	  default: {
	    have_error = 1; 
	    /* Warning: Invalid keyword in text handling */
	    dkfig_tool2_msg3(c, DK_LOG_LEVEL_WARNING, 39, 40, cptr);
	  } break;
	}
      }
      cptr = nptr;
    }
  }
  
  return back;
}
/* }}} */



/* {{{ Various functions used in setup
*/



static
unsigned long
set_bool DK_P3(unsigned long,old, char *,vptr, unsigned long,flag)
{
  unsigned long back;
  back = old;
  if(vptr) {
    if(dkstr_is_bool(vptr)) {
      if(dkstr_is_on(vptr)) {
        back |= flag;
      } else {
        back &= (~flag);
      }
    } else {
      back |= flag;
    }
  } else {
    back |= flag;
  }
  return back;
}



static
void
set_normal_text DK_P2(dk_fig_conversion *,c,char *,v)
{
  
  if(v) { c->normal_text = scan_th(c,v,c->normal_text); }
  
}



static
void
set_special_text DK_P2(dk_fig_conversion *,c,char *,v)
{
  
  if(v) { c->special_text = scan_th(c,v,c->special_text); }
  
}



static
void
set_latex_font_setup DK_P2(dk_fig_conversion *,c,char *,v)
{
  char *cptr;
  
  if(v) {
    cptr = dkstr_start(v, NULL);
    if(cptr) {
      dkstr_chomp(cptr, NULL);
      c->latfs = dkstr_array_index(latex_font_setup_keywords, cptr, 0);
    }
  }
  
}



static void
set_pattern_line_width DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  if(vptr) {
    long l;
    if(sscanf(vptr, "%ld", &l) == 1) {
      if(l < 0L) l = 0L - l;
      if(l < 1L) l = 1L;
      c->patlw = l;
    }
  }
}



static void
set_pattern_period DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  if(vptr) {
    long l;
    if(sscanf(vptr, "%ld", &l) == 1) {
      if(l < 0L) l = 0L - l;
      if(l < 1L) l = 1L;
      c->patrp = l;
    }
  }
}



static void
set_arrowhead_linejoin DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  c->ahlj = 0;
  if(vptr) {
    c->ahlj = dkstr_array_abbr(ahlj_kw, vptr, '$', 0);
    if(c->ahlj < 0) { c->ahlj = 0; }
  }
}




static void
set_min_iteration_steps DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  unsigned long val = 1UL;
  if(vptr) {
    if(sscanf(vptr, "%lu", &val) == 1) {
      c->minitsteps = val;
    }
  }
}



static void
set_max_iteration_steps DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  unsigned long val = 1UL;
  if(vptr) {
    if(sscanf(vptr, "%lu", &val) == 1) {
      c->maxitsteps = val;
    }
  }
}



static void
set_fill_patterns DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  unsigned long newfp = 0UL;
  unsigned long maskfp;
  if(vptr) {
    if(dkstr_is_bool(vptr)) {
      if(dkstr_is_on(vptr)) {
        newfp = DKFIG_OPT_FILL_PATTERNS;
	
      }
    } else {
      if(dkstr_is_abbr(vptr, cont_kw, '$', 0)) {
        newfp = DKFIG_OPT_FILL_PATTERNS | DKFIG_OPT_FILL_CONTIGOUS;
	
      } else {	
      }
    }
  } else {
    
    newfp = DKFIG_OPT_FILL_PATTERNS | DKFIG_OPT_FILL_CONTIGOUS;
  }
  maskfp = DKFIG_OPT_FILL_PATTERNS | DKFIG_OPT_FILL_CONTIGOUS;
  maskfp = (~maskfp);
  c->opt1 = (c->opt1 & maskfp) | newfp;
}



static void
set_ps_level DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  int found = 0;
  unsigned psl = 2;
  /* ps level */
  if(vptr) {
    if(sscanf(vptr, "%u", &psl) == 1) {
      if(psl < 1) psl = 1;
      if(psl > 3) psl = 3;
      c->psl = psl; found = 1;
    }
  }
  if(!found) {
    c->psl = 2;
  }
}



static void
set_dsc_level DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  unsigned u;
  if(vptr) {
    if(sscanf(vptr, "%u", &u) == 1) {
      c->dscl = u;
    } else {
      if(dkstr_is_bool(vptr)) {
        if(dkstr_is_on(vptr)) {
	  c->dscl = 255;
	} else {
	  c->dscl = 0;
	}
      } else {
        c->dscl = 1;
      }
    }
  } else {
    c->dscl = 1;
  }
}



static void
set_enable_write18 DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  if(vptr) {
    if(dkstr_is_bool(vptr)) {
      c->opt1 |= DKFIG_OPT_SPECIFY_WRITE18;
      if(dkstr_is_on(vptr)) {
        c->opt1 |= DKFIG_OPT_ENABLE_WRITE18;
      } else {
        c->opt1 &= (~DKFIG_OPT_ENABLE_WRITE18);
      }
    } else {
      if(dkstr_is_abbr(vptr, ignore_kw, '$', 0)) {
        c->opt1 &= (~DKFIG_OPT_SPECIFY_WRITE18);
      } else {
        /* ERROR: Unknown keyword */
	c->opt1 &= (~DKFIG_OPT_ENABLE_WRITE18);
      }
    }
  } else {
    c->opt1 |= DKFIG_OPT_SPECIFY_WRITE18;
    c->opt1 |= DKFIG_OPT_ENABLE_WRITE18;
  }
}




static void
set_font_scale_factor DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  if(vptr) {
    double x;
    if(sscanf(vptr, "%lg", &x) == 1) {
      c->fsf = fabs(x);
    } else {
      c->fsf = 1.0;
    }
  } else {
    c->fsf = 1.0;
  }
}




static
void
set_dashpattern_dot_length DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  if(vptr) {
    switch(dkstr_array_index(dp_dot_length, vptr, 0)) {
      case 0: {
        c->opt1 &= (~(DKFIG_OPT_DP_DOT_LW));
      } break;
      default: {
        c->opt1 |= DKFIG_OPT_DP_DOT_LW;
      } break;
    }
  }
}




static void
set_preamble_file DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  if(vptr) {
    char *newptr, *cp;
    newptr = dkstr_dup(vptr);
    if(newptr) {
      if(c->tpfn) {
        cp = c->tpfn; dk_delete(cp); c->tpfn = NULL;
      }
      c->tpfn = newptr;
    } else { 
    }
  }
}



static void
set_spline_subsegments DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  unsigned u;
  if(vptr) {
    if(sscanf(vptr, "%u", &u) == 1) {
      if(u < 1) { u = 1; }
      c->spseg = (size_t)u;
      
    }
  }
}



static
void
set_svg_version DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  int x;
  
  if(vptr) {
    x = dkstr_array_index(known_svg_versions, vptr, 0);
    if(x > -1) {
      c->svgv = x;
    }
  }
}




static
void
set_svg_viewport_specification DK_P2(\
  dk_fig_conversion *,c, char *,vptr\
)
{
  int i;
  
  if(vptr) {
    i = dkstr_array_abbr(
      svg_viewport_specifications, vptr, '$', 0
    );
    if(i > -1) {
      c->svgs = i;
    }
  }
  
}



static
void
set_flip_style DK_P2(dk_fig_conversion *,c, char *,vptr)
{
  int x;
  x = dkstr_array_abbr(flip_styles, vptr, '$', 0);
  if(x > 0) {
    c->opt2 |= DKFIG_OPT_FLIP_DIAGONAL;
    
  } else {
    c->opt2 &= (~(DKFIG_OPT_FLIP_DIAGONAL));
    
  }
}



static
unsigned long
set_bg_rect_color DK_P2(unsigned long,old, char *,vptr)
{
  unsigned long back; int on = 0;
  back = old;
  
  if(vptr) {
    on = dkstr_array_abbr(bgcolordefs, vptr, '$', 0);
    if(on == -1) on = 0;
  }
  if(on) {
    back = back | DKFIG_OPT_WHITE_BGRECT;
  } else {
    back &= (~(DKFIG_OPT_WHITE_BGRECT));
  } 
  return back;
}



/* }}} */



char *
dkfig_opt_special_comment_contents DK_P2(char *,line, char *,dr)
{
  char *back = NULL, *c, *n;
  int found = 0;
  
  back = dkstr_chr(line, ':');
  if(back) {
    *(back++) = '\0';
    back = dkstr_start(back, NULL);
    if(back) {
      c = dkstr_start(line, NULL);
      while(c) {
        n = dkstr_next(c, NULL);
	if(strcmp(c, dr) == 0) {
	  found = 1;
	} else {
	  if(strcmp(c, "*") == 0) {
	    found = 1;
	  }
	}
	c = n;
      }
    }
  }
  if(!found) {
    back = NULL;
  } 
  return back;
}



/* {{{ dkfig_opt_process_special_comment

   Process one special comment.
    1 ... processing succeeded
    0 ... key not found
   -1 ... comment not for this driver
   -2 ... not configurable per instance.
   -3 ... error
   -4 ... driver name not in list

*/
int
dkfig_opt_process_special_comment DK_P4(\
  dk_fig_conversion *,c, char *,line, char *,dr, int,atdoclevel\
)
{
  int back = -1;
  char mybuffer[128], *myline, *parts[32], *lptr, *vptr, *cptr;
  int i;
  size_t xsz;
  
  myline = NULL;
  if((c) && (line) && (dr)) {
    
    if(strlen(line) >= sizeof(mybuffer)) {
      
      myline = dkstr_dup(line); lptr = myline;
    } else {
      
      strcpy(mybuffer, line); lptr = mybuffer;
    }
  }
  if(lptr) {	
    cptr = dkfig_opt_special_comment_contents(lptr, dr);
    if(cptr) {	
      back = 0;
      vptr = dkstr_chr(cptr, '=');
      if(vptr) { *(vptr++) = '\0'; }
      vptr = dkstr_start(vptr, NULL);
      if(vptr) { dkstr_chomp(vptr, NULL); }
      cptr = dkstr_start(cptr, NULL);
      if(cptr) {
        dkstr_chomp(cptr, NULL);
	xsz = sizeof(parts)/sizeof(PCHAR);
	if(dkstr_explode(parts, (xsz), cptr, exploder_pattern)) {
	  i = dkstr_find_multi_part_abbr(parts, cmds, '$', 1);
	  switch(i) {
	    case 0: {
	      if(atdoclevel) {
	        set_tex_command(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 1: {
	      if(atdoclevel) {
	        set_embed_fonts(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 2: {
	      if(atdoclevel) {
	        set_normal_text(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 3: {
	      if(atdoclevel) {
	        set_special_text(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 4: {
	      if(atdoclevel) {
	        set_latex_font_setup(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 5: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_WEB_PALETTE);
	      } else { back = -2; }
	    } break;
	    case 6: {
	      if(atdoclevel) {
	        set_spline_subsegments(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 7: {
	      if(atdoclevel) {
	        set_preamble_file(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 8: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_USE_CS_SETTING);
	      } else { back = -2; }
	    } break;
	    case 9: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_ENLIGHTEN_LOOK);
	      back = 1;
	    } break;
	    case 10: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_VERBOSE_OUTPUT);
	      back = 1;
	    } break;
	    case 11: {
	      set_pattern_line_width(c, vptr);
	      back = 1;
	    } break;
	    case 12: {
	      set_pattern_period(c, vptr);
	      back = 1;
	    } break;
	    case 13: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REMOVE_THIN_BORDERS);
	      back = 1;
	    } break;
	    case 14: {
	      set_arrowhead_linejoin(c, vptr);
	      back = 1;
	    } break;
	    case 15: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_METAPOST_ARROWHEADS);
	      back = 1;
	    } break;
	    case 16: {
	      if(atdoclevel) {
	        set_min_iteration_steps(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 17: {
	      if(atdoclevel) {
	        set_max_iteration_steps(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 18: {
	      set_fill_patterns(c, vptr);
	      back = 1;
	    } break;
	    case 19: {
	      if(atdoclevel) {
	        set_ps_level(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 20: {
	      if(atdoclevel) {
	        set_dsc_level(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 21: {
	      if(atdoclevel) {
	        set_enable_write18(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 22: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_USE_PS_SHOWPAGE);
	      } else { back = -2; }
	    } break;
	    case 23: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_KEEP_TEX_FILES);
	      } else { back = -2; }
	    } break;
	    case 24: {
	      set_font_scale_factor(c, vptr);
	      back = 1;
	    } break;
	    case 25: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_ALLOW_PSRL);
	      } else { back = -2; }
	    } break;
	    case 26: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_SEPARATED_RGB);
	      back = 1;
	    } break;
	    case 27: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REMOVE_BITMAP_BORDER);
	      back = 1;
	    } break;
	    case 28: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_FILL_BITMAP_AREA);
	      back = 1;
	    } break;
	    case 29: {
              c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_KEEP_BITMAP_WH_RATIO);
	      back = 1;
	    } break;
	    case 30: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_BITMAP_DICTIONARY);
	      } else { back = -2; }
	    } break;
	    case 31: {
	      if(atdoclevel) {
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_GARBAGE_COLLECTION);
		back = 1;
	      } else { back = -2; }
	    } break;
	    case 32: {
	      if(atdoclevel) {
	        set_svg_version(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 33: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_USE_CSS);
	      } else { back = -2; }
	    } break;
	    case 34: {
	      if(atdoclevel) {
	        set_svg_viewport_specification(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 35: {
	      if(atdoclevel) {
	        back = 1;
		c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_SVG_EMBEDDED);
	      } else { back = -2; }
	    } break;
	    case 36: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REPORT_MULTIPLE);
	      } else { back = -2; }
	    } break;
	    case 37: {
	      if(atdoclevel) {
	        back = 1;
		c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_IGNORE_UNKNOWN_PAPER);
	      } else { back = -2; }
	    } break;
	    case 38: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_PREPARE_FOR_MODS);
	      } else { back = -2; }
	    } break;
	    case 39: {
	      if(atdoclevel) {
	        set_dashpattern_dot_length(c, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 40: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_WR_TEX_COMMAND);
	      } else { back = -2; }
	    } break;
	    case 41: {
	      if(atdoclevel) {
	        back = 1;
                c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REMOVE_BG_RECTANGLE);
	      } else { back = -2; }
	    } break;
	    case 42: {
	      if(atdoclevel) {
	        back = 1;
                c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_SKIP_ALL_TEXTS);
	      } else { back = -2; }
	    } break;
	    case 43: {
	      if(atdoclevel) {
	        back = 1;
                c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_PLAIN_TEXT_STREAMS);
	      } else { back = -2; }
	    } break;
	    case 44: {
	      if(atdoclevel) {
	        back = 1;
                c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_FULL_SCREEN);
	      } else { back = -2; }
	    } break;
	    case 45: {
	      if(atdoclevel) {
	        unsigned u;
		if(vptr) {
		  if(sscanf(vptr, "%u", &u) == 1) {
		    if(u < 1) u = 1;
		    c->nodcoord = u; back = 1;
		  }
		}
	      } else { back = -2; }
	    } break;
	    case 46: {
	      if(atdoclevel) {
	        unsigned u;
		if(vptr) {
		  if(sscanf(vptr, "%u", &u) == 1) {
		    c->nodtrigo = u; back = 1;
		  }
		}
	      } else { back = -2; }
	    } break;
	    case 47: {
	      if(atdoclevel) {
	        unsigned u;
		if(vptr) {
		  if(sscanf(vptr, "%u", &u) == 1) {
		    if(u < 1) u = 1;
		    c->nodcolor = u; back = 1;
		  }
		}
	      } else { back = -2; }
	    } break;
	    case 48: {
	      if(atdoclevel) {
	        unsigned u;
		if(vptr) {
		  if(sscanf(vptr, "%u", &u) == 1) {
		    if(u < 1) u = 1;
		    c->circlesteps = u; back = 1;
		  }
		}
	      } else { back = -2; }
	    } break;
	    case 49: {
	      c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_PDF_PATTERN_TILE);
	      
	      back = 1;
	    } break;
	    case 50: {
	      if(vptr) {
	        set_flip_style(c, vptr);
		back = 1;
	      }
	    } break;
	    case 51: {
	      if(vptr) {
                c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_INTERPOLATE_IMAGES);
		back = 1;
	      }
	    } break;
	    case 52: {
	      if(atdoclevel) {
	        c->opt2 = set_bool(c->opt2,vptr,DKFIG_OPT_FULL_TEX_FILE);
		back = 1;
	      } else { back = -2; }
	    } break;
	    case 53: {
	      if(atdoclevel) {
	        c->opt2 = set_bg_rect_color(c->opt2, vptr); back = 1;
	      } else { back = -2; }
	    } break;
	    case 54: {
	      if(atdoclevel) {
	        back = 1;
                c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_SETPAGEDEVICE);
	      } else { back = -2; }
	    } break;
	    case 55: {
	      c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_SVG_FONTSIZE_UNIT);
	    } break;
	    case 56: {
	      if(atdoclevel) {
	        if(vptr) {
		  char *newptr, *cp;
		  newptr = dkstr_dup(vptr);
		  if(newptr) {
		    back = 1;
		    if(c->fcfg) {
		      cp = c->fcfg; dk_delete(cp);
		      c->fcfg = NULL;
		    }
		    c->fcfg = newptr;
		  }
		}
	      } else { back = -2; }
	    } break;
	    case 57: {	/* utf-8 */
	      if(vptr) {
	        back = dkfig_tool2_set_utf8(c, vptr, 0);
	      }
	    } break;
	  }
	}
      }
    } else {
      back = -4;
    }
  } else {	
    /* ERROR: Memory */
    back = -3;
    if(c->app) {
      dkapp_err_memory(c->app, 1, 1+strlen(line));
    }
  }
  if(myline) {
    
    dk_delete(myline); myline = NULL;
  } 
  return back;
}


/* }}} */



/* {{{ process_sto

  Process one option storage.

*/
static
void
process_sto DK_P4(dk_fig_conversion *,c,char *,b,size_t,sz,int,i)
{
  dk_storage_t *sto = NULL; dk_storage_iterator_t *it = NULL;
  dk_fig_opt *o;
  char *sptr, *vptr, *parts[32];
  
  switch(i) {
    case 0: {
      sto = c->optg; it = c->optgi;
    } break;
    case 1: {
      sto = c->optb; it = c->optbi;
    } break;
    case 2: {
      sto = c->optd; it = c->optdi;
    } break;
    case 3: {
      sto = c->opt;  it = c->opti ;
    } break;
  }
  if((sto) && (it)) {
    dksto_it_reset(it);
    while((o = (dk_fig_opt *)dksto_it_next(it)) != NULL) {
      if(o->name) {
        if(strlen(o->name) < sz) {
	  strcpy(b, o->name);
	  sptr = vptr = NULL;
	  vptr = dkstr_chr(b, '=');
	  if(vptr) {
	    *(vptr++) = '\0';
	    vptr = dkstr_start(vptr, NULL);
	  }
	  if(vptr) { dkstr_chomp(vptr, NULL); }
	  sptr = dkstr_start(b, NULL);
	  
	  if(sptr) {
	    size_t xsz;
	    xsz = sizeof(parts)/sizeof(PCHAR);
	    dkstr_chomp(sptr, NULL);
	    if(dkstr_explode(parts, (xsz), sptr, exploder_pattern)) {
	      i = dkstr_find_multi_part_abbr(parts, cmds, '$', 1);
	      
	      switch(i) {
	        case 0: { /* tex command */
		  set_tex_command(c, vptr);
		  o->used = 0x01;
		} break;
		case 1: { /* embed fonts */
		  set_embed_fonts(c, vptr);
		  o->used = 0x01;
		} break;
		case 2: { /* normal text */
		  set_normal_text(c, vptr);
		  o->used = 0x01;
		} break;
		case 3: { /* special text */
		  set_special_text(c, vptr);
		  o->used = 0x01;
		} break;
		case 4: { /* latex font setup */
		  set_latex_font_setup(c, vptr);
		  o->used = 0x01;
		} break;
		case 5: { /* web palette */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_WEB_PALETTE);
		  o->used = 0x01;
		} break;
		case 6: { /* spline segments */
		  set_spline_subsegments(c, vptr);
		  o->used = 0x01;
		} break;
		case 7: { /* preamble file */
		  set_preamble_file(c, vptr);
		  o->used = 0x01;
		} break;
		case 8: { /* use cs setting */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_USE_CS_SETTING);
		  o->used = 0x01;
		} break;
		case 9: { /* enlighten look */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_ENLIGHTEN_LOOK);
		  o->used = 0x01;
		} break;
		case 10: { /* verbose output */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_VERBOSE_OUTPUT);
		  o->used = 0x01;
		} break;
		case 11: { /* pattern line width */
		  set_pattern_line_width(c, vptr);
		  o->used = 0x01;
		} break;
		case 12: { /* pattern period */
		  set_pattern_period(c, vptr);
		  o->used = 0x01;
		} break;
		case 13: { /* remove zero borders */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REMOVE_THIN_BORDERS);
		  o->used = 0x01;
		} break;
		case 14: { /* arrowhead linejoin */
		  set_arrowhead_linejoin(c, vptr);
		  o->used = 0x01;
		} break;
		case 15: { /* use metapost arrowheads */
                  c->opt1 = set_bool(c->opt1,vptr,DKFIG_OPT_METAPOST_ARROWHEADS);
		  o->used = 0x01;
		} break;
		case 16: { /* min iteration steps */
		  set_min_iteration_steps(c, vptr);
		  o->used = 0x01;
		} break;
		case 17: { /* maximum iteration steps */
		  set_max_iteration_steps(c, vptr);
		  o->used = 0x01;
		} break;
		case 18: { /* fill patterns */
		  set_fill_patterns(c, vptr);
		  o->used = 0x01;
		} break;
		case 19: { /* PS level */
		  set_ps_level(c, vptr);
		  o->used = 0x01;
		} break;
		case 20: { /* DSC comment level */
		  set_dsc_level(c, vptr);
		  o->used = 0x01;
		} break;
		case 21: { /* enable write18 */
		  set_enable_write18(c, vptr);
		  o->used = 0x01;
		} break;
		case 22: { /* ps showpage */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_USE_PS_SHOWPAGE);
		  o->used = 0x01;
		} break;
		case 23: { /* keep tex files */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_KEEP_TEX_FILES);
		  o->used = 0x01;
		} break;
		case 24: { /* font scale factor */
		  set_font_scale_factor(c, vptr);
		  o->used = 0x01;
		} break;
		case 25: { /* PS run-length encoding */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_ALLOW_PSRL);
		  o->used = 0x01;
		} break;
		case 26: { /* separated RGB channels */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_SEPARATED_RGB);
		  o->used = 0x01;
		} break;
		case 27: { /* remove bitmap border */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REMOVE_BITMAP_BORDER);
		  o->used = 0x01;
		} break;
		case 28: {	/* fill bitmap background */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_FILL_BITMAP_AREA);
		  o->used = 0x01;
		} break;
		case 29: {	/* keep w-h-ratio */
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_KEEP_BITMAP_WH_RATIO);
		  o->used = 0x01;
		} break;
		case 30: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_BITMAP_DICTIONARY);
		  o->used = 0x01;
		} break;
		case 31: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_GARBAGE_COLLECTION);
		  o->used = 0x01;
		} break;
		case 32: {
		  set_svg_version(c, vptr);
		  o->used = 0x01;
		} break;
		case 33: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_USE_CSS);
		  o->used = 0x01;
		} break;
		case 34: {
		  set_svg_viewport_specification(c, vptr);
		  o->used = 0x01;
		} break;
		case 35: {
		  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_SVG_EMBEDDED);
		  o->used = 0x01;
		} break;
		case 36: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REPORT_MULTIPLE);
		  o->used = 0x01;
		} break;
		case 37: {
		  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_IGNORE_UNKNOWN_PAPER);
		  o->used = 0x01;
		} break;
		case 38: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_PREPARE_FOR_MODS);
		  o->used = 0x01;
		} break;
		case 39: {
		  set_dashpattern_dot_length(c, vptr);
		  o->used = 0x01;
		} break;
		case 40: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_WR_TEX_COMMAND);
		  o->used = 0x01;
		} break;
		case 41: {
                  c->opt1 = set_bool(c->opt1, vptr, DKFIG_OPT_REMOVE_BG_RECTANGLE);
		  o->used = 0x01;
		} break;
	        case 42: {
                  c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_SKIP_ALL_TEXTS);
		  o->used = 0x01;
	        } break;
		case 43: {
                  c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_PLAIN_TEXT_STREAMS);
		  o->used = 0x01;
		} break;
		case 44: {
                  c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_FULL_SCREEN);
		  o->used = 0x01;
		} break;
		case 45: {	/* nodcoord */
		  if(vptr) {
		    unsigned u;
		    if(sscanf(vptr, "%u", &u) == 1) {
		      c->nodcoord = u;
		      o->used = 0x01;
		    }
		  }
		} break;
		case 46: {	/* nodtrigo */
		  if(vptr) {
		    unsigned u;
		    if(sscanf(vptr, "%u", &u) == 1) {
		      c->nodtrigo = u;
		      o->used = 0x01;
		    }
		  }
		} break;
		case 47: {	/* nodcolor */
		  if(vptr) {
		    unsigned u;
		    if(sscanf(vptr, "%u", &u) == 1) {
		      if(u < 1) u = 1;
		      c->nodcolor = u;
		      o->used = 0x01;
		    }
		  }
		} break;
		case 48: {	/* circlesteps */
		  if(vptr) {
		    unsigned u;
		    if(sscanf(vptr, "%u", &u) == 1) {
		      if(u < 1) u = 1;
		      c->circlesteps = u;
		      o->used = 0x01;
		    }
		  }
		} break;
		case 49: {
	          c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_PDF_PATTERN_TILE);
	          
		  o->used = 0x01;
		} break;
		case 50: {
		  if(vptr) {
		    set_flip_style(c, vptr);
		    o->used = 0x01;
		  }
		} break;
		case 51: {
		  if(vptr) {
                    c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_INTERPOLATE_IMAGES);
		    o->used = 0x01;
		  }
		} break;
		case 52: {
		  if(vptr) {
                    c->opt2 = set_bool( c->opt2, vptr, DKFIG_OPT_FULL_TEX_FILE);
		    o->used = 0x01;
		  }
		} break;
		case 53: {
		  if(vptr) {
		    c->opt2 = set_bg_rect_color(c->opt2, vptr);
		  }
		  o->used = 0x01;
		} break;
		case 54: {
                  c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_SETPAGEDEVICE);
		  o->used = 0x01;
		} break;
		case 55: {
		  c->opt2 = set_bool(c->opt2, vptr, DKFIG_OPT_SVG_FONTSIZE_UNIT);
		  o->used = 0x01;
		} break;
		case 56: {
	          if(vptr) {
		    char *newptr, *cp;
		    newptr = dkstr_dup(vptr);
		    o->used = 0x01;
		    if(newptr) {
		      if(c->fcfg) {
		        cp = c->fcfg; dk_delete(cp);
		        c->fcfg = NULL;
		      }
		      c->fcfg = newptr;
		    }
		  }
		} break;
		case 57: {	/* utf-8 */
		  if(vptr) {
		    (void)dkfig_tool2_set_utf8(c, vptr, 1);
		    o->used = 0x01;
		  }
		} break;
	      }
	    }
	  }
	} else {	
	  /* ERROR: Internal error, option too long */
	  dkfig_tool2_msg3(c, DK_LOG_LEVEL_WARNING, 41, 42, o->name);
	}
      }
    }
  }
  
}
/* }}} process_sto */



/* {{{ dkfig_opt_process_all

  Traverse the four option storages (general defaults,
  base driver options, exact configuration options,
  command line arguments).

*/
int
dkfig_opt_process_all DK_P1(dk_fig_conversion *,c)
{
  int back = 1;
  size_t sz;
  char *buffer = NULL;
  int i;
  
  if(c) {
  if(c->lcfge) {
    sz = 1 + c->lcfge;
    buffer = dk_new(char,sz);
    if(buffer) {
      for(i = 0; i < 4; i++) {
        process_sto(c, buffer, sz, i);
      }
      dk_delete(buffer); buffer = NULL;
      if(c->dscl > c->psl) { c->dscl = c->psl; }
    } else {
      back = 0;
      if(c->app) {
        dkapp_err_memory(c->app, sizeof(char), sz);
      }
    }
  }
  }
  
  return back;
}
/* }}} dkfig_opt_process_all */




/* {{{ SCCS ID */
#ifndef LINT
static char sccs_id[] = {
"@(#)dkfigopt.ctr 1.113 05/29/07\t(krause) - fig2vect"
};
#endif
/* }}} */