backend/dvi/mdvi-lib/sp-epsf.c

   1 /*
   2  * Copyright (C) 2000, Matias Atria
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 /* postscript specials */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25
  26 #include "mdvi.h"
  27 #include "private.h"
  28
  29 typedef struct {
  30         double  ox;
  31         double  oy;
  32         double  bw;
  33         double  bh;
  34         double  angle;
  35 } EpsfBox;
  36
  37 #define LLX     0
  38 #define LLY     1
  39 #define URX     2
  40 #define URY     3
  41 #define RWI     4
  42 #define RHI     5
  43 #define HOFF    6
  44 #define VOFF    7
  45 #define HSIZE   8
  46 #define VSIZE   9
  47 #define HSCALE  10
  48 #define VSCALE  11
  49 #define ANGLE   12
  50 #define CLIP    13
  51
  52 void    epsf_special __PROTO((DviContext *dvi, char *prefix, char *arg));
  53
  54 /* Note: the given strings are modified in place */
  55 static char *parse_epsf_special(EpsfBox *box, char **ret,
  56         char *prefix, char *arg)
  57 {
  58         static struct {
  59                 char *name;
  60                 int  has_arg;
  61                 char *value;
  62         } keys[] = {
  63                 {"llx", 1, "0"},
  64                 {"lly", 1, "0"},
  65                 {"urx", 1, "0"},
  66                 {"ury", 1, "0"},
  67                 {"rwi", 1, "0"},
  68                 {"rhi", 1, "0"},
  69                 {"hoffset", 1, "0"},
  70                 {"voffset", 1, "0"},
  71                 {"hsize", 1, "612"},
  72                 {"vsize", 1, "792"},
  73                 {"hscale", 1, "100"},
  74                 {"vscale", 1, "100"},
  75                 {"angle", 1, "0"},
  76                 {"clip", 0, "0"}
  77         };
  78 #define NKEYS   (sizeof(keys) / sizeof(keys[0]))
  79         char    *ptr;
  80         char    *filename;
  81         int     quoted;
  82         double  value[NKEYS];
  83         Uchar   present[NKEYS];
  84         Buffer  buffer;
  85         char    *name;
  86         int     i;
  87         double  originx;
  88         double  originy;
  89         double  hsize;
  90         double  vsize;
  91         double  hscale;
  92         double  vscale;
  93
  94         /* this special has the form
  95          *   ["]file.ps["] [key=valye]*
  96          */
  97
  98         /* scan the filename */
  99         while(*arg == ' ' || *arg == '\t')
 100                 arg++;
 101
 102         /* make a copy of the string */
 103         ptr = arg;
 104
 105         if(*ptr == '"')
 106                 for(name = ++ptr; *ptr && *ptr != '"'; ptr++);
 107         else
 108                 for(name = ptr; *ptr && *ptr != ' ' && *ptr != '\t'; ptr++);
 109         if(ptr == name)
 110                 return NULL;
 111         *ptr++ = 0;
 112         filename = name;
 113
 114         /* reset values to defaults */
 115         for(i = 0; i < NKEYS; i++) {
 116                 value[i] = atof(keys[i].value);
 117                 present[i] = 0;
 118         }
 119
 120         buff_init(&buffer);
 121         buff_add(&buffer, "@beginspecial ", 0);
 122
 123         quoted = 0;
 124         while(*ptr) {
 125                 const char *keyname;
 126                 char    *val;
 127                 char    *p;
 128
 129                 while(*ptr == ' ' || *ptr == '\t')
 130                         ptr++;
 131                 keyname = ptr;
 132
 133                 /* get the whole key=value pair */
 134                 for(; *ptr && *ptr != ' ' && *ptr != '\t'; ptr++);
 135
 136                 if(*ptr) *ptr++ = 0;
 137                 /* now we shouldn't touch `ptr' anymore */
 138
 139                 /* now work on this pair */
 140                 p = strchr(keyname, '=');
 141                 if(p == NULL)
 142                         val = NULL;
 143                 else {
 144                         *p++ = 0;
 145                         if(*p == '"') {
 146                                 val = ++p;
 147                                 /* skip until closing quote */
 148                                 while(*p && *p != '"')
 149                                         p++;
 150                                 if(*p != '"')
 151                                         warning(
 152                                         _("%s: malformed value for key `%s'\n"),
 153                                                 filename, keyname);
 154                         } else
 155                                 val = p;
 156                 }
 157
 158                 /* lookup the key */
 159                 for(i = 0; i < NKEYS; i++)
 160                         if(STRCEQ(keys[i].name, keyname))
 161                                 break;
 162                 if(i == NKEYS) {
 163                         warning(_("%s: unknown key `%s' ignored\n"),
 164                                 filename, keyname);
 165                         continue;
 166                 }
 167                 if(keys[i].has_arg && val == NULL) {
 168                         warning(_("%s: no argument for key `%s', using defaults\n"),
 169                                 filename, keyname);
 170                         val = keys[i].value;
 171                 } else if(!keys[i].has_arg && val) {
 172                         warning(_("%s: argument `%s' ignored for key `%s'\n"),
 173                                 filename, val, keyname);
 174                         val = NULL;
 175                 }
 176                 if(val)
 177                         value[i] = atof(val);
 178
 179                 /* put the argument */
 180                 buff_add(&buffer, val, 0);
 181                 buff_add(&buffer, " @", 2);
 182                 buff_add(&buffer, keyname, 0);
 183                 buff_add(&buffer, " ", 1);
 184
 185                 /* remember that this option was given */
 186                 present[i] = 0xff;
 187         }
 188         buff_add(&buffer, " @setspecial", 0);
 189
 190         /* now compute the bounding box (code comes from dvips) */
 191         originx = 0;
 192         originy = 0;
 193         hscale = 1;
 194         vscale = 1;
 195         hsize = 0;
 196         vsize = 0;
 197
 198         if(present[HSIZE])
 199                 hsize = value[HSIZE];
 200         if(present[VSIZE])
 201                 vsize = value[VSIZE];
 202         if(present[HOFF])
 203                 originx = value[HOFF];
 204         if(present[VOFF])
 205                 originy = value[VOFF];
 206         if(present[HSCALE])
 207                 hscale = value[HSCALE] / 100.0;
 208         if(present[VSCALE])
 209                 vscale = value[VSCALE] / 100.0;
 210         if(present[URX] && present[LLX])
 211                 hsize = value[URX] - value[LLX];
 212         if(present[URY] && present[LLY])
 213                 vsize = value[URY] - value[LLY];
 214         if(present[RWI] || present[RHI]) {
 215                 if(present[RWI] && !present[RHI])
 216                         hscale = vscale = value[RWI] / (10.0 * hsize);
 217                 else if(present[RHI] && !present[RWI])
 218                         hscale = vscale = value[RHI] / (10.0 * vsize);
 219                 else {
 220                         hscale = value[RWI] / (10.0 * hsize);
 221                         vscale = value[RHI] / (10.0 * vsize);
 222                 }
 223         }
 224
 225         box->ox = originx;
 226         box->oy = originy;
 227         box->bw = hsize * hscale;
 228         box->bh = vsize * vscale;
 229         box->angle = value[ANGLE];
 230
 231         *ret = buffer.data;
 232
 233         return filename;
 234 }
 235
 236 void    epsf_special(DviContext *dvi, char *prefix, char *arg)
 237 {
 238         char    *file;
 239         char    *special;
 240         char    *psfile;
 241         char    *tmp;
 242         EpsfBox box = {0, 0, 0, 0};
 243         int     x, y;
 244         int     w, h;
 245         double  xf, vf;
 246         struct stat buf;
 247
 248         file = parse_epsf_special(&box, &special, prefix, arg);
 249         if (file != NULL)
 250                 mdvi_free (special);
 251
 252         xf = dvi->params.dpi * dvi->params.mag / (72.0 * dvi->params.hshrink);
 253         vf = dvi->params.vdpi * dvi->params.mag / (72.0 * dvi->params.vshrink);
 254         w = FROUND(box.bw * xf);
 255         h = FROUND(box.bh * vf);
 256         x = FROUND(box.ox * xf) + dvi->pos.hh;
 257         y = FROUND(box.oy * vf) + dvi->pos.vv - h + 1;
 258
 259         if (!file || !dvi->device.draw_ps) {
 260                 dvi->device.draw_rule (dvi, x, y, w, h, 0);
 261                 return;
 262         }
 263
 264         if (file[0] == '/') { /* Absolute path */
 265                 if (stat (file, &buf) == 0)
 266                         dvi->device.draw_ps (dvi, file, x, y, w, h);
 267                 else
 268                         dvi->device.draw_rule (dvi, x, y, w, h, 0);
 269                 return;
 270         }
 271
 272         tmp = mdvi_strrstr (dvi->filename, "/");
 273         if (tmp) { /* Document directory */
 274                 int path_len = strlen (dvi->filename) - strlen (tmp + 1);
 275                 int file_len = strlen (file);
 276
 277                 psfile = mdvi_malloc (path_len + file_len + 1);
 278                 psfile[0] = '\0';
 279                 strncat (psfile, dvi->filename, path_len);
 280                 strncat (psfile, file, file_len);
 281
 282                 if (stat (psfile, &buf) == 0) {
 283                         dvi->device.draw_ps (dvi, psfile, x, y, w, h);
 284                         mdvi_free (psfile);
 285
 286                         return;
 287                 }
 288
 289                 mdvi_free (psfile);
 290         }
 291
 292         psfile = mdvi_build_path_from_cwd (file);
 293         if (stat (psfile, &buf) == 0) { /* Current working dir */
 294                 dvi->device.draw_ps (dvi, psfile, x, y, w, h);
 295                 mdvi_free (psfile);
 296
 297                 return;
 298         }
 299
 300         mdvi_free (psfile);
 301
 302         psfile = kpse_find_pict (file);
 303         if (psfile) { /* kpse */
 304                 dvi->device.draw_ps (dvi, psfile, x, y, w, h);
 305         } else {
 306                 dvi->device.draw_rule(dvi, x, y, w, h, 0);
 307         }
 308
 309         free (psfile);
 310 }