tioga 1.6 → 1.7

data/split/Tioga/{pdftext.c → shared/pdftext.c}

@@ -26,7 +26,7 @@ void Init_Font_Dictionary(void) {
    int i, num_fonts = num_pdf_standard_fonts;
    Font_Dictionary *font_info;
    for (i = 0; i < num_fonts; i++) {
-      font_info = ALLOC(Font_Dictionary);
+      font_info = (Font_Dictionary *)calloc(1,sizeof(Font_Dictionary));
       font_info->afm = &afm_array[i];
       font_info->font_num = font_info->afm->font_num;
       font_info->in_use = false;
@@ -104,7 +104,7 @@ static void Record_Font_In_Use(Font_Dictionary *font_info, int font_number)
 
 #define DEBUG 0
 #define MAXSTR 100
-static Font_Dictionary *GetFontDict(char *font_name, int font_number) {
+static Font_Dictionary *GetFontDict(char *font_name, int font_number, int *ierr) {
    Font_Dictionary *font_info;
    for (font_info = font_dictionaries; font_info != NULL; font_info = font_info->next) {
       if (strcmp(font_name, font_info->afm->font_name) == 0) {
@@ -112,23 +112,22 @@ static Font_Dictionary *GetFontDict(char *font_name, int font_number) {
          return font_info;
       }
    }
-   rb_raise(rb_eArgError, "Sorry: invalid font name (%s)", font_name);
+   RAISE_ERROR_s("Sorry: invalid font name (%s)", font_name, ierr);
    return NULL;
 }
 
-static Font_Dictionary *GetFontInfo(int font_number)
+static Font_Dictionary *GetFontInfo(int font_number, int *ierr)
 {
    Font_Dictionary *f;
    for (f = font_dictionaries; f != NULL; f = f->next) {
       if (f->font_num == font_number) { Record_Font_In_Use(f, font_number); return f; }
    }
    if (font_number > 0 && font_number <= num_predefined_fonts)
-      return GetFontDict(predefined_Fonts[font_number], font_number);
+      return GetFontDict(predefined_Fonts[font_number], font_number, ierr);
    return NULL;
 }
 
-static int c_register_font(char *font_name)
-{
+OBJ_PTR c_register_font(OBJ_PTR fmkr, FM *p, char *font_name, int *ierr) {
    Font_Dictionary *f;
    int i;
    for (f = font_dictionaries; f != NULL; f = f->next) {
@@ -136,22 +135,17 @@ static int c_register_font(char *font_name)
    }
    for (i = 1; i <= num_predefined_fonts; i++) {
       if (strcmp(predefined_Fonts[i], font_name)==0) {
-         f = GetFontDict(font_name, i);
-         if (f == NULL) rb_raise(rb_eArgError, "Error in reading font metrics for %s", font_name);
+         f = GetFontDict(font_name, i, ierr);
+         if (f == NULL) RAISE_ERROR_s("Error in reading font metrics for %s", font_name, ierr);
          return i;
       }
    }
-   f = GetFontDict(font_name, next_available_font_number);
-   if (f == NULL) rb_raise(rb_eArgError, "Error in reading font metrics for %s", font_name);
-   return next_available_font_number++;
+   f = GetFontDict(font_name, next_available_font_number, ierr);
+   if (f == NULL) RAISE_ERROR_s("Error in reading font metrics for %s", font_name, ierr);
+   next_available_font_number++;
+   return Integer_New(next_available_font_number); 
 }
 
-VALUE FM_register_font(VALUE fmkr, VALUE font_name)
-{
-   font_name = rb_String(font_name);
-   int font_num = c_register_font(RSTRING_PTR(font_name));
-   return INT2FIX(font_num); 
-}
 
 bool Used_Any_Fonts(void)
 {
@@ -221,10 +215,11 @@ void Write_Font_Dictionaries(void)
 }
 
 static void GetStringInfo(FM *p, int font_number, unsigned char *text, double ft_ht,
-      double *llx_ptr, double *lly_ptr, double *urx_ptr, double *ury_ptr, double *width_ptr) {
-   Font_Dictionary *fontinfo = GetFontInfo(font_number);
-   if (fontinfo == NULL)
-      rb_raise(rb_eArgError, "Sorry: invalid font number (%i): must register font before use it.", font_number);
+      double *llx_ptr, double *lly_ptr, double *urx_ptr, double *ury_ptr, double *width_ptr, int *ierr) {
+   Font_Dictionary *fontinfo = GetFontInfo(font_number, ierr);
+   if (*ierr != 0) return;
+   if (fontinfo == NULL) {
+      RAISE_ERROR_i("Sorry: invalid font number (%i): must register font before use it.", font_number, ierr); return; }
    unsigned char *c_ptr = text, c;
    double width = 0, llx, lly, urx, ury;
    if (fontinfo == NULL || text == NULL || text[0] == '\0') {
@@ -242,52 +237,50 @@ static void GetStringInfo(FM *p, int font_number, unsigned char *text, double ft
    }
    urx = llx + width;
    *width_ptr = width * ft_ht * 1e-3;
-   *llx_ptr = llx * ft_ht * 1e-3;
-   *lly_ptr = lly * ft_ht * 1e-3;
-   *urx_ptr = urx * ft_ht * 1e-3;
-   *ury_ptr = ury * ft_ht * 1e-3;
+   *llx_ptr = ft_ht * 1e-3 * llx;
+   *lly_ptr = ft_ht * 1e-3 * lly;
+   *ury_ptr = ft_ht * 1e-3 * ury;
+   *urx_ptr = ft_ht * 1e-3 * (urx-70.0); // adjust for extra white space on right
 }
 
-VALUE FM_marker_string_info(VALUE fmkr, VALUE font_number, VALUE string, VALUE scale)
-{ // [ width, llx, lly, urx, ury ] in figure coords
-   FM *p = Get_FM(fmkr);
-   font_number = rb_Integer(font_number);
-   string = rb_String(string);
-   unsigned char *text = (unsigned char *)(RSTRING_PTR(string));
-   scale = rb_Float(scale);
-   double ft_ht = p->default_text_scale * NUM2DBL(scale) * p->default_font_size * ENLARGE;
+OBJ_PTR c_marker_string_info(OBJ_PTR fmkr, FM *p, int fnt, unsigned char *text, double scale, int *ierr) {
+   double ft_ht = p->default_text_scale * scale * p->default_font_size * ENLARGE;
    int ft_height = ROUND(ft_ht);
    ft_ht = ft_height;
    double llx, lly, urx, ury, width;
-   int fnt = NUM2INT(font_number);
-   GetStringInfo(p, fnt, text, ft_ht, &llx, &lly, &urx, &ury, &width);
-   VALUE result = rb_ary_new2(5);
+   GetStringInfo(p, fnt, text, ft_ht, &llx, &lly, &urx, &ury, &width, ierr);
+   if (*ierr != 0) RETURN_NIL;
+   OBJ_PTR result = Array_New(5);
    width = convert_output_to_figure_dx(p,width);
    llx = convert_output_to_figure_dx(p,llx);
    urx = convert_output_to_figure_dx(p,urx);
    lly = convert_output_to_figure_dy(p,lly);
    ury = convert_output_to_figure_dy(p,ury);
-   rb_ary_store(result, 0, rb_float_new(width));
-   rb_ary_store(result, 1, rb_float_new(llx));
-   rb_ary_store(result, 2, rb_float_new(lly));
-   rb_ary_store(result, 3, rb_float_new(urx));
-   rb_ary_store(result, 4, rb_float_new(ury));
+   Array_Store(result, 0, Float_New(width), ierr);
+   Array_Store(result, 1, Float_New(llx), ierr);
+   Array_Store(result, 2, Float_New(lly), ierr);
+   Array_Store(result, 3, Float_New(urx), ierr);
+   Array_Store(result, 4, Float_New(ury), ierr);
+   
    return result; 
 }
 
 #define TRANSFORM_VEC(dx,dy) tmp = dx; dx = (dx) * a + (dy) * c; dy = tmp * b + (dy) * d;
 
-void c_rotated_string_at_points(FM *p, double rotation, int font_number, unsigned char *text, double scale,
-   int n, double *xs, double *ys, int alignment, int justification, double horizontal_scaling, double vertical_scaling,
-   double italic_angle, double ascent_angle)
+static void c_rotated_string_at_points(
+   OBJ_PTR fmkr, FM *p, double rotation, int font_number, unsigned char *text, double scale,
+   int n, double *xs, double *ys, int alignment, int just, 
+   double horizontal_scaling, double vertical_scaling,
+   double italic_angle, double ascent_angle, int *ierr)
 {
    double ft_ht = p->default_text_scale * scale * p->default_font_size * ENLARGE;
-   int i, ft_height = ROUND(ft_ht);
+   int i, ft_height = ROUND(ft_ht), justification = just-1;
    ft_ht = ft_height;
-   if (constructing_path) rb_raise(rb_eArgError, "Sorry: must not be constructing a path when show marker");
+   if (constructing_path) { RAISE_ERROR("Sorry: must not be constructing a path when show marker", ierr); return; }
    double llx, lly, urx, ury, width, shiftx, shifty, tmp;
    double a=horizontal_scaling, b=0.0, c=0.0, d=vertical_scaling; // the initial transform
-   GetStringInfo(p, font_number, text, ft_ht, &llx, &lly, &urx, &ury, &width);
+   GetStringInfo(p, font_number, text, ft_ht, &llx, &lly, &urx, &ury, &width, ierr);
+   if (*ierr != 0) return;
    // translate according to justification and alignment
    // note that we use the bbox to calculate shifts so 'center' means center of bbox
    if (italic_angle != 0) {
@@ -315,14 +308,18 @@ void c_rotated_string_at_points(FM *p, double rotation, int font_number, unsigne
             shiftx *= 0.9;
          }
          break;
-      default: rb_raise(rb_eArgError, "Sorry: invalid setting for marker justification (%i)", justification);
+      default: 
+         RAISE_ERROR_i("Sorry: invalid setting for marker justification (%i)", justification, ierr);
+         return;
    }
    switch (alignment) {
       case ALIGNED_AT_TOP: shifty = -ury; break;
       case ALIGNED_AT_MIDHEIGHT: shifty = -(ury+lly)/2; break;
       case ALIGNED_AT_BASELINE: shifty = 0; break;
       case ALIGNED_AT_BOTTOM: shifty = -lly; break;
-      default: rb_raise(rb_eArgError, "Sorry: invalid setting for marker alignment (%i)", alignment);
+      default: 
+         RAISE_ERROR_i("Sorry: invalid setting for marker alignment (%i)", alignment, ierr);
+         return;
    }
    // transform the bbox
    double llx2 = llx, lly2 = lly, urx2 = urx, ury2 = ury; // if we're rotated we'll need all 4 corners of bbox
@@ -350,12 +347,14 @@ void c_rotated_string_at_points(FM *p, double rotation, int font_number, unsigne
       update_bbox(p,x+llx2, y+ury2);
       update_bbox(p,x+urx2, y+lly2);
       dx = x - prev_x; dy = y - prev_y;
-      idx = ROUND(dx); idy = ROUND(dy);
-      prev_x = prev_x + idx; prev_y = prev_y + idy;
+      //idx = ROUND(dx); idy = ROUND(dy);
+      //prev_x = prev_x + idx; prev_y = prev_y + idy;
+      prev_x = prev_x + dx; prev_y = prev_y + dy;
       if (b == 0 && c == 0 && a == 1 && d == 1) {
-         fprintf(TF, "%i %i Td (", idx, idy);
+         //fprintf(TF, "%i %i Td (", idx, idy);
+         fprintf(TF, "%0.6f %0.6f Td (", dx, dy);
       } else { // need high precision when doing rotations
-         fprintf(TF, "%0.6f %0.6f %0.6f %0.6f %0.6f %0.6f Tm (", a, b, c, d, dx, dy);
+         fprintf(TF, "%0.6f %0.6f %0.6f %0.6f %0.6f %0.6f Tm (", a, b, c, d, x, y);
       }
       while ((char_code = *cp++) != '\0') {
          if (char_code == '\\')
@@ -370,71 +369,94 @@ void c_rotated_string_at_points(FM *p, double rotation, int font_number, unsigne
    fprintf(TF, "ET\n");
 }
 
-VALUE FM_private_show_marker(VALUE fmkr, VALUE integer_args, VALUE stroke_width, VALUE string,
-   VALUE x, VALUE y, VALUE x_vec, VALUE y_vec,
-   VALUE h_scale, VALUE v_scale, VALUE scale, VALUE it_angle, VALUE ascent_angle, VALUE angle,
-   VALUE fill_color, VALUE stroke_color)
-{
-   FM *p = Get_FM(fmkr);
-   int int_args, c, alignment, justification, fnt_num, n, mode;
+void c_private_show_marker(
+   OBJ_PTR fmkr, FM *p, int int_args, OBJ_PTR stroke_width, OBJ_PTR string,
+   OBJ_PTR x, OBJ_PTR y, OBJ_PTR x_vec, OBJ_PTR y_vec,
+   double h_scale, double v_scale, double scale, double it_angle, double ascent_angle, double angle,
+   OBJ_PTR fill_color, OBJ_PTR stroke_color, int *ierr) {
+   int c, alignment, justification, fnt_num, n, mode;
    unsigned char *text = NULL, buff[2];
    double *xs, *ys, xloc, yloc, prev_line_width = -1;
    bool restore_fill_color = false, restore_stroke_color = false;
-   VALUE prev_fill_color = Qnil, prev_stroke_color = Qnil;
-   integer_args = rb_Integer(integer_args);
-   int_args = NUM2INT(integer_args);
+   double stroke_color_R=0.0, stroke_color_G=0.0, stroke_color_B=0.0;
+   double prev_stroke_color_R, prev_stroke_color_G, prev_stroke_color_B;
+   double fill_color_R=0.0, fill_color_G=0.0, fill_color_B=0.0;
+   double prev_fill_color_R, prev_fill_color_G, prev_fill_color_B;
    c = int_args / 100000; int_args -= c * 100000;
    fnt_num = int_args / 1000; int_args -= fnt_num * 1000;
    mode = int_args / 100; int_args -= mode * 100;
    alignment = int_args / 10; int_args -= alignment * 10;
    justification = int_args;
-   if (string == Qnil) {
-      if (c < 0 || c > 255)
-         rb_raise(rb_eArgError, "Sorry: invalid character code (%i) : must be between 0 and 255", c);
+   if (string == OBJ_NIL) {
+      if (c < 0 || c > 255) {
+         RAISE_ERROR_i("Sorry: invalid character code (%i) : must be between 0 and 255", c, ierr);
+         return;
+      }
       text = buff; text[0] = c;  text[1] = '\0';
-      if (stroke_width != Qnil) {
-         stroke_width = rb_Float(stroke_width);
-         double width = NUM2DBL(stroke_width);
+      if (stroke_width != OBJ_NIL) {
+         double width = Number_to_double(stroke_width, ierr);
+         if (*ierr != 0) return;
          prev_line_width = p->line_width; // restore it later
          fprintf(TF, "%0.6f w\n", width * ENLARGE);
       }
    } else {
-      string = rb_String(string);
-      text = (unsigned char *)(RSTRING_PTR(string));
+      text = (unsigned char *)(String_Ptr(string,ierr));
+      if (*ierr != 0) return;
    }
    fprintf(TF, "%d Tr\n", mode);
-   if (stroke_color != Qnil && stroke_color != p->stroke_color &&
-         (mode == STROKE || mode == FILL_AND_STROKE || mode == STROKE_AND_CLIP || mode == FILL_STROKE_AND_CLIP)) {
-      prev_stroke_color = p->stroke_color; restore_stroke_color = true;
-      FM_stroke_color_set(fmkr, stroke_color);
+   if (stroke_color != OBJ_NIL &&
+         (mode == STROKE || mode == FILL_AND_STROKE || 
+            mode == STROKE_AND_CLIP || mode == FILL_STROKE_AND_CLIP)) {
+       Unpack_RGB(stroke_color, &stroke_color_R, &stroke_color_G, &stroke_color_B, ierr);
+       if (*ierr != 0) return;
+       if (stroke_color_R != p->stroke_color_R ||
+           stroke_color_G != p->stroke_color_G ||
+           stroke_color_B != p->stroke_color_B) {
+          prev_stroke_color_R = p->stroke_color_R;
+          prev_stroke_color_G = p->stroke_color_G;
+          prev_stroke_color_B = p->stroke_color_B;
+          restore_stroke_color = true;
+          c_stroke_color_set_RGB(fmkr, p, stroke_color_R, stroke_color_G, stroke_color_B, ierr);
+          if (*ierr != 0) return;
+       }
    }
-   if (fill_color != Qnil && fill_color != p->fill_color && 
-         (mode == FILL || mode == FILL_AND_STROKE || mode == FILL_AND_CLIP || mode == FILL_STROKE_AND_CLIP)) {
-      prev_fill_color = p->fill_color; restore_fill_color = true;
-      FM_fill_color_set(fmkr, fill_color);
+   if (fill_color != OBJ_NIL &&
+         (mode == FILL || mode == FILL_AND_STROKE || 
+            mode == FILL_AND_CLIP || mode == FILL_STROKE_AND_CLIP)) {
+       Unpack_RGB(fill_color, &fill_color_R, &fill_color_G, &fill_color_B, ierr);
+       if (*ierr != 0) return;
+       if (fill_color_R != p->fill_color_R ||
+           fill_color_G != p->fill_color_G ||
+           fill_color_B != p->fill_color_B) {
+          prev_fill_color_R = p->fill_color_R;
+          prev_fill_color_G = p->fill_color_G;
+          prev_fill_color_B = p->fill_color_B;
+          restore_fill_color = true;
+          c_fill_color_set_RGB(fmkr, p, fill_color_R, fill_color_G, fill_color_B, ierr);
+          if (*ierr != 0) return;
+       }
    }
-   h_scale = rb_Float(h_scale);
-   v_scale = rb_Float(v_scale);
-   scale = rb_Float(scale);
-   it_angle = rb_Float(it_angle);
-   ascent_angle = rb_Float(ascent_angle);
-   angle = rb_Float(angle);
-   if (x == Qnil) {
+   if (x == OBJ_NIL) {
       long xlen, ylen;
-      xs = Dvector_Data_for_Read(x_vec, &xlen);
-      ys = Dvector_Data_for_Read(y_vec, &ylen);
-      if (xlen != ylen) rb_raise(rb_eArgError, "Sorry: must have same number xs and ys for showing markers");
-      if (xlen <= 0) return fmkr;
+      xs = Vector_Data_for_Read(x_vec, &xlen, ierr);
+      if (*ierr != 0) return;
+      ys = Vector_Data_for_Read(y_vec, &ylen, ierr);
+      if (*ierr != 0) return;
+      if (xlen != ylen) { 
+         RAISE_ERROR("Sorry: must have same number xs and ys for showing markers", ierr); return; }
+      if (xlen <= 0) return;
       n = xlen;
    } else {
-      x = rb_Float(x); xloc = NUM2DBL(x); xs = &xloc;
-      y = rb_Float(y); yloc = NUM2DBL(y); ys = &yloc;
+      xloc = Number_to_double(x, ierr); xs = &xloc;
+      yloc = Number_to_double(y, ierr); ys = &yloc;
+      if (*ierr != 0) return;
       n = 1;
    }
-   c_rotated_string_at_points(p, NUM2DBL(angle), fnt_num, text, NUM2DBL(scale), n, xs, ys,
-      alignment, justification, NUM2DBL(h_scale), NUM2DBL(v_scale), NUM2DBL(it_angle), NUM2DBL(ascent_angle));
-   if (prev_line_width >= 0) c_line_width_set(p, prev_line_width);
-   if (restore_fill_color) FM_fill_color_set(fmkr, prev_fill_color);
-   if (restore_stroke_color) FM_stroke_color_set(fmkr, prev_stroke_color);
-   return fmkr;
+   c_rotated_string_at_points(fmkr, p, angle, fnt_num, text, scale, n, xs, ys,
+      alignment, justification, h_scale, v_scale, it_angle, ascent_angle, ierr);
+   if (prev_line_width >= 0) c_line_width_set(fmkr, p, prev_line_width, ierr);
+   if (restore_fill_color)
+       c_fill_color_set_RGB(fmkr, p, prev_fill_color_R, prev_fill_color_G, prev_fill_color_B, ierr);
+   if (restore_stroke_color) 
+       c_stroke_color_set_RGB(fmkr, p, prev_stroke_color_R, prev_stroke_color_G, prev_stroke_color_B, ierr);
 }

data/split/Tioga/shared/texout.c

@@ -0,0 +1,524 @@
+/* texout.c */
+/*
+   Copyright (C) 2005  Bill Paxton
+
+   This file is part of Tioga.
+
+   Tioga is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Tioga 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 Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with Tioga; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "figures.h"
+
+#define RADIANS_TO_DEGREES (180.0 / PI)
+
+static FILE *fp; // for the TeX file
+
+/* TeX text */
+
+void c_rescale_text(OBJ_PTR fmkr, FM *p, double scaling_factor, int *ierr) {
+   double scale = scaling_factor * p->default_text_scale;
+   if (scaling_factor <= 0) { RAISE_ERROR("Sorry: text scaling must be positive", ierr); return; }
+   p->default_text_height_dx *= scaling_factor;
+   p->default_text_height_dy *= scaling_factor;
+   p->default_text_scale = scale;
+}
+
+static int String_Is_Blank(char  *str) {
+   char c;
+   if (str == NULL) return 1;
+   while (1) {
+      c = *str++;
+      if (c == '\0') return 1;
+      if (!isspace(c)) break;
+      }
+   return 0;
+   }
+
+static OBJ_PTR Get_Measure_Hash(OBJ_PTR fmkr, OBJ_PTR measure_name)
+{
+  OBJ_PTR value;
+  int i;
+  OBJ_PTR measures_info = Obj_Attr_Get(fmkr, measures_info_ID, &i);
+  if(measure_name == OBJ_NIL) {
+    return OBJ_NIL;
+  }
+  if(! Hash_Has_Key_Obj(measures_info, measure_name)) {
+    value = Hash_New();
+    Hash_Set_Obj_Obj(measures_info, measure_name, value);
+  }
+  else 
+    value = Hash_Get_Obj_Obj(measures_info, measure_name);
+  return value;
+}
+
+
+static void tex_show_rotated_text(OBJ_PTR fmkr, FM *p, char *text, 
+				  double x, double y, double scale, 
+				  double angle, int justification, 
+				  int alignment, OBJ_PTR measure_name)
+{  // x and y are the device coords for the reference point of the text
+   char ref, jst;
+   double ft_ht, sz;
+   int dummy;
+   OBJ_PTR measures = Get_Measure_Hash(fmkr, measure_name);
+   if (String_Is_Blank(text)) return; /* blank strings break TeX! */
+   scale *= p->default_text_scale;
+   ft_ht = scale * p->default_font_size;
+   sz = ft_ht * ENLARGE;
+   ref = (alignment == ALIGNED_AT_BASELINE)? 'B' : 
+         (alignment == ALIGNED_AT_BOTTOM)? 'b' :
+         (alignment == ALIGNED_AT_TOP)? 't' : 'c';
+   if (justification == 0) jst = 'c';
+   else if (justification > 0) jst = 'r';
+   else jst = 'l';
+   bbox_llx = MIN(bbox_llx, x - sz);
+   bbox_lly = MIN(bbox_lly, y - sz);
+   bbox_urx = MAX(bbox_urx, x + sz);
+   bbox_ury = MAX(bbox_ury, y + sz);
+   if (angle != 0.0)
+      fprintf(fp,"\\put(%d,%d){\\rotatebox{%.1f}{\\scalebox{%.2f}{\\makebox(0,0)[%c%c]{",
+            ROUND(x), ROUND(y), angle, scale, jst, ref);
+   else
+      fprintf(fp,"\\put(%d,%d){\\scalebox{%.2f}{\\makebox(0,0)[%c%c]{",
+            ROUND(x), ROUND(y), scale, jst, ref);
+   if(measure_name != OBJ_NIL)
+     fprintf(fp, "{\\tiogameasure{%s}{\\tiogasetfont{}", 
+	     CString_Ptr(measure_name,&dummy));
+   else
+     fprintf(fp, "{{\\tiogasetfont{}");
+
+   /* Moving the \BS out of the potential \tiogameasure input, so it does
+      not disturb the measure.
+   */
+   fprintf(fp, (alignment == ALIGNED_AT_BASELINE)? "%s}\\BS" : "%s}", text);
+   fprintf(fp, angle != 0? "}}}}}\n" : "}}}}\n");
+
+   /* Now, we save measures informations if applicable*/
+   if(measures != OBJ_NIL) {
+     Hash_Set_Double(measures, "scale", scale);
+     /* [xy]anchor are saved in postscript points */
+     Hash_Set_Double(measures, "xanchor", ROUND(x) / ENLARGE);
+     Hash_Set_Double(measures, "yanchor", ROUND(y) / ENLARGE);
+     Hash_Set_Double(measures, "angle", angle);
+     Hash_Set_Double(measures, "just", justification);
+     Hash_Set_Double(measures, "align", alignment);
+   }
+}
+
+static void Convert_Frame_Text_Position_To_Output_Location(FM *p, int frame_side, double offset, 
+   double fraction, double *xp, double *yp, double *base_angle, char *text, int *ierr)
+{
+   double page_x, page_y;
+   switch (frame_side) {
+      case LEFT:
+         page_x = p->page_width * p->frame_left - offset;
+         page_y = p->page_height * (p->frame_bottom + fraction * p->frame_height);
+         *base_angle = 90;
+         break;
+      case RIGHT:
+         page_x = p->page_width * p->frame_right + offset;
+         page_y = p->page_height * (p->frame_bottom + fraction * p->frame_height);
+         *base_angle = 90;
+         break;
+      case AT_X_ORIGIN:
+         if (0.0 > p->bounds_xmax || 0.0 < p->bounds_xmin) {
+            RAISE_ERROR_s("Sorry: x origin is not part of plot for (%s)", text, ierr); return; }
+         page_x = convert_figure_to_output_x(p, 0.0);
+         if (p->xaxis_reversed) offset = -offset;
+         page_x += offset;
+         page_y = p->page_height * (p->frame_bottom + fraction * p->frame_height);
+         *base_angle = 90;
+         break;
+      case TOP:
+         page_y = p->page_height * p->frame_top + offset;
+         page_x = p->page_width * (p->frame_left + fraction * p->frame_width);
+         *base_angle = 0;
+         break;
+      case BOTTOM:
+         page_y = p->page_height * p->frame_bottom - offset;
+         page_x = p->page_width * (p->frame_left + fraction * p->frame_width);
+         *base_angle = 0;
+         break;
+      case AT_Y_ORIGIN:
+         if (0.0 > p->bounds_ymax || 0.0 < p->bounds_ymin) {
+            RAISE_ERROR_s("Sorry: y origin is not part of plot for (%s)", text, ierr); return; }
+         page_y = convert_figure_to_output_y(p, 0.0);
+         if (p->yaxis_reversed) offset = -offset;
+         page_y += offset;
+         page_x = p->page_width * (p->frame_left + fraction * p->frame_width);
+         *base_angle = 0;
+         break;
+      default: 
+         RAISE_ERROR_s("Sorry: invalid parameter for frame side in show text (%s)", text, ierr); 
+         return;
+   }
+   *xp = p->page_left + page_x; *yp = p->page_bottom + page_y;
+}
+       
+void c_show_rotated_text(OBJ_PTR fmkr, FM *p, char *text, int frame_side, double shift, double fraction,
+			 double scale, double angle, int justification, int alignment, OBJ_PTR measure_name, int *ierr) {
+   double x, y, base_angle, ft_ht = p->default_text_scale * scale * p->default_font_size;
+   Convert_Frame_Text_Position_To_Output_Location(p, frame_side, shift*ft_ht*ENLARGE, fraction, &x, &y, &base_angle, text, ierr);
+   tex_show_rotated_text(fmkr, p, text, x, y, scale, angle + base_angle, justification, alignment, measure_name);
+}
+
+         
+void c_show_rotated_label(OBJ_PTR fmkr, FM *p, char *text, 
+   double xloc, double yloc, double scale, double angle, int justification, int alignment, OBJ_PTR measure_name, int *ierr) {
+   tex_show_rotated_text(fmkr, p, text, convert_figure_to_output_x(p, xloc), convert_figure_to_output_y(p, yloc),
+			 scale, angle, justification, alignment, measure_name);
+}
+   
+OBJ_PTR c_check_label_clip(OBJ_PTR fmkr, FM *p, double x, double y, int *ierr) {
+   x = convert_figure_to_frame_x(p,x);
+   y = convert_figure_to_frame_y(p,y);
+   if (x < p->label_left_margin || y < p->label_bottom_margin ||
+         1.0 - x < p->label_right_margin || 1.0 - y < p->label_top_margin) RETURN_FALSE;
+   RETURN_TRUE;
+}
+
+/* TeX File Management */
+
+static long cur_pos;
+
+static void Get_tex_name(char *ofile, char *filename, int maxlen)
+{
+   char *dot;
+   strncpy(ofile, filename, maxlen);
+   dot = strrchr(ofile,'.');
+   if (dot != NULL) dot[0] = '\0';
+   strcat(ofile, "_figure.txt");
+}
+
+void Open_tex(OBJ_PTR fmkr, char *filename, bool quiet_mode, int *ierr) 
+{
+   char ofile[300];
+   Get_tex_name(ofile, filename, 300);
+   fp = fopen(ofile, "w");
+   fprintf(fp,"\\setlength{\\unitlength}{%fbp}%%\n", 1.0/ENLARGE);
+   cur_pos = ftell(fp);
+   fprintf(fp,"\\begin{picture}(xxxxxx,xxxxxx)            %% (width,height)(xoffset,yoffset) -- Adjust the 2nd pair for registration adjustments\n"); /* this line is rewritten at the end */
+   fprintf(fp,"\\def\\BS{\\phantom{\\Huge\\scalebox{0}[2]{\\hbox{\\rotatebox{180}{O}O}}}}\n"); 
+      // graphicx seems to vertically align baseline (B) like center (c), 
+      // so we add BS (Big Strut) to make them look the same
+}
+
+void Close_tex(OBJ_PTR fmkr, bool quiet_mode, int *ierr)
+{
+   double x, y, xoff, yoff;
+   x = bbox_urx - bbox_llx; if (x < 0) x = bbox_urx = bbox_llx = 0;
+   y = bbox_ury - bbox_lly; if (y < 0) y = bbox_ury = bbox_lly = 0;
+   xoff = bbox_llx + Get_tex_xoffset(fmkr,ierr)*ENLARGE;
+   yoff = bbox_lly + Get_tex_yoffset(fmkr,ierr)*ENLARGE;
+   fprintf(fp,"\\end{picture}");
+   fseek(fp, cur_pos, SEEK_SET);
+   fprintf(fp,"\\begin{picture}(%03d,%03d)(%02d,%d)", ROUND(x), ROUND(y), ROUND(xoff), ROUND(yoff));
+   fclose(fp);
+}   
+
+
+static void Write_preview_header(OBJ_PTR fmkr, FILE *file, int *ierr) {
+   fprintf(file, "\\documentclass{%s}\n\n", Get_tex_preview_documentclass(fmkr,ierr));   
+   /* we print out the preamble generated from tioga.sty.in */
+   fprintf(file, "%% Tioga preamble generated from tioga.sty.in\n");
+   fprintf(file, "%s\n", Get_tex_preview_generated_preamble(fmkr,ierr));
+   fprintf(file, "%% User-specified preamble\n");
+   fprintf(file, "%s\n\n", Get_tex_preamble(fmkr,ierr));
+   fprintf(file, "%% Command to format numeric labels on xaxis\n");
+   fprintf(file, "\\newcommand{\\tiogaxaxisnumericlabel}[1]{%s}\n\n", Get_xaxis_numeric_label_tex(fmkr,ierr));
+   fprintf(file, "%% Command to format numeric labels on yaxis\n");
+   fprintf(file, "\\newcommand{\\tiogayaxisnumericlabel}[1]{%s}\n\n", Get_yaxis_numeric_label_tex(fmkr,ierr));
+   fprintf(file, "%% Color constants definitions\n");
+   fprintf(file, "%s\n\n", CString_Ptr(COLOR_PREAMBLE(fmkr,ierr),ierr)); 
+   fprintf(file, "%% Set page margins, page size and orientation.\n");
+   fprintf(file, "\t\\usepackage[pdftex,tmargin=0pt,lmargin=0pt,"
+	   "rmargin=0pt,bmargin=0pt,\n");
+   fprintf(file, "\tpaperwidth=%s,paperheight=%s,\n", 
+	   Get_tex_preview_paper_width(fmkr,ierr),
+	   Get_tex_preview_paper_height(fmkr,ierr));
+   fprintf(file, "\thoffset=%s,voffset=%s\n", 
+	   Get_tex_preview_hoffset(fmkr,ierr),
+	   Get_tex_preview_voffset(fmkr,ierr));
+   fprintf(file, "\t]{geometry}\n");
+
+   fprintf(file, "\n%% We need the graphicx package and the calc package.\n");
+   fprintf(file, "\t\\usepackage{graphicx}\n");
+   fprintf(file, "\t\\usepackage{calc}\n\n");
+   fprintf(file, "\t%% This is necessary to avoid getting the picture on the second page\n");
+   fprintf(file, "\t\\topskip=0pt\n\n");
+
+   /* now, the commands to customize the font used */
+   fprintf(file, "\\settiogafontsize[10pt]{%s}\n", Get_tex_fontsize(fmkr,ierr));
+   fprintf(file, "\\settiogafontfamily{\\%s}\n", Get_tex_fontfamily(fmkr,ierr));
+   fprintf(file, "\\settiogafontseries{\\%s}\n", Get_tex_fontseries(fmkr,ierr));
+   fprintf(file, "\\settiogafontshape{\\%s}\n", Get_tex_fontshape(fmkr,ierr));
+}
+
+
+static void Write_figure_command(OBJ_PTR fmkr, char *simple_name, FILE *file, int *ierr) {
+   char *minwhitespace;
+   
+   if (Get_tex_preview_fullpage(fmkr,ierr)) {
+        minwhitespace = Get_tex_preview_minwhitespace(fmkr,ierr);
+        if (minwhitespace == NULL) {
+            fprintf(file, "\\tiogafigurefullpage{%s}\n", simple_name); 
+        } else {
+            fprintf(file, "\\tiogafigurefullpage[%s]{%s}\n", minwhitespace, simple_name); 
+        }
+   } else {
+       const char * command = Get_tex_preview_tiogafigure_command(fmkr,ierr);
+       if(strcmp(command, "tiogafigureshow")) {
+        fprintf(file, "\\%s{%s}{%s}{%s}\n", Get_tex_preview_tiogafigure_command(fmkr,ierr), simple_name, 
+            Get_tex_preview_figure_width(fmkr,ierr), Get_tex_preview_figure_height(fmkr,ierr)); 
+       } else { /* no need for extra arguments for tiogafigureshow */
+        fprintf(file, "\\%s{%s}\n", Get_tex_preview_tiogafigure_command(fmkr,ierr), simple_name); 
+       }
+   }
+}
+
+   
+void Create_wrapper(OBJ_PTR fmkr, char *fname, bool quiet_mode, int *ierr)
+{  // create the wrapper TeX file to combine the text and graphics to make a figure
+   char *dot;
+   char tex_fname[100], base_name[100], simple_name[100];
+   FILE *file;
+   if ((dot=strrchr(fname,'.')) != NULL) {
+      strncpy(base_name, fname, dot-fname); base_name[dot-fname] = '\0';
+      snprintf(tex_fname, sizeof(tex_fname), "%s.tex", base_name);
+      }
+   else {
+      strcpy(base_name, fname);
+      snprintf(tex_fname, sizeof(tex_fname), "%s.tex", fname);
+      }
+   if ((dot=strrchr(base_name,'/')) != NULL) {
+      strcpy(simple_name, dot+1);
+      }
+   else {
+      strcpy(simple_name, base_name);
+      }
+   file = fopen(tex_fname, "w");
+   fprintf(file, "%% Tioga preview LaTeX file for %s_figure.pdf and %s_figure.txt\n\n", base_name, base_name);
+
+   Write_preview_header(fmkr, file, ierr);
+
+   fprintf(file, "\n%% Here's the page with the figure.\n");
+   fprintf(file, "\\begin{document}\n");
+   fprintf(file, "\\pagestyle{%s}\n", Get_tex_preview_pagestyle(fmkr,ierr));
+   /* necessary to get the position right */
+   fprintf(file, "\\noindent");
+   Write_figure_command(fmkr, simple_name, file, ierr);
+   fprintf(file, "\\end{document}\n");
+   fclose(file);
+}
+
+void Init_tex(int *ierr)
+{
+}
+
+void Rename_tex(char *oldname, char *newname, int *ierr)
+{
+   char old_ofile[300], new_ofile[300];
+   Get_tex_name(old_ofile, oldname, 300);
+   Get_tex_name(new_ofile, newname, 300);
+   rename(old_ofile, new_ofile); // from stdio.h
+}
+
+void private_make_portfolio(char *name, OBJ_PTR fignums, OBJ_PTR fignames, int *ierr)
+{
+    FILE *file;
+    int i, len, numfigs, j;
+    char tex_fname[256];
+    snprintf(tex_fname, sizeof(tex_fname), "%s.tex", name);
+    file = fopen(tex_fname, "w");
+    if (file == NULL) {
+       RAISE_ERROR_s("Sorry: can't open %s.\n", tex_fname, ierr); return; }
+    fprintf(file, "%% Tioga Portfolio %s\n\n", name);
+    fprintf(file, "\\documentclass{article}\n");
+    fprintf(file, "\\usepackage{pdfpages}\n");
+    fprintf(file, "\\begin{document}\n");
+    fprintf(file, "%% Start of figures, one per page\n\n");
+    len = Array_Len(fignames,ierr);
+    if (fignums == OBJ_NIL) {
+        for (i=0; i < len; i++) {
+            fprintf(file, "\\includepdf{%s.pdf}\n", Get_String(fignames, i, ierr));
+            if (*ierr != 0) return;
+        }
+    } else {
+        numfigs = Array_Len(fignums,ierr);
+        if (*ierr != 0) return;
+        for (i=0; i < numfigs; i++) {
+            OBJ_PTR n = Array_Entry(fignums,i,ierr);
+            if (*ierr != 0) return;
+            j = Number_to_int(n,ierr);
+            if (j >= 0 && j < len) {
+               fprintf(file, "\\includepdf{%s.pdf}\n", Get_String(fignames, j, ierr));
+               if (*ierr != 0) return;
+            }
+            else {
+                fclose(file);
+                RAISE_ERROR("Requested figure numbers must be >= 0 and < num_figures.", ierr);
+                return;
+            }
+        }
+    }
+    fprintf(file, "\n\\end{document}\n");
+    fclose(file);
+}
+
+
+/* 
+   Stores and transforms measures as printed by pdflatex.
+
+   Takes sizes in bp.
+
+*/
+void c_save_measure(OBJ_PTR fmkr, OBJ_PTR measure_name, 
+		    double width, double height, double depth)
+{
+  double angle, scale;
+  int just, align;
+  /* Page coordinates in bp before applying rotation ! */
+  double xl,xr,yt,yb;
+  double xa,ya;
+  OBJ_PTR measures = Get_Measure_Hash(fmkr, measure_name);
+  int dummy;
+
+  /* The following really should not happen */
+  if(measures == OBJ_NIL) {
+    fprintf(stderr, "Warning: got hash = OBJ_NIL in %s, line %d\n",
+	    __FILE__, __LINE__);
+    return;
+  }
+
+  /* Storing measured sizes  */
+  Hash_Set_Double(measures, "tex_measured_width", width);
+  Hash_Set_Double(measures, "tex_measured_height", height);
+  Hash_Set_Double(measures, "tex_measured_depth", depth);
+
+  angle = Hash_Get_Double(measures, "angle");
+  scale = Hash_Get_Double(measures, "scale");
+  just = Hash_Get_Double(measures, "just");
+  align = Hash_Get_Double(measures, "align");
+  
+  /* Setting the appropriate scale */
+  width *= scale;
+  height *= scale;
+  depth *= scale;
+  /* Now setting the width and height in  */
+  Hash_Set_Double(measures, "width", width);
+  Hash_Set_Double(measures, "height", height);
+  Hash_Set_Double(measures, "depth", depth);
+
+  xa = Hash_Get_Double(measures, "xanchor");
+  ya = Hash_Get_Double(measures, "yanchor");
+  
+  /* Now, we try to compute the precise position of
+     the points of the box surrounding the text.
+  */
+
+  /* First, before rotation: */
+  switch(just) {
+  case 1:			/* Right-justified */
+    xr = xa;
+    xl = xa - width;
+    break;
+  case 0:			/* Centered */
+    xr = xa + width/2;
+    xl = xa - width/2;
+    break;
+  case -1:			/* Left-justified */
+    xl = xa;
+    xr = xa + width;
+    break;
+  default:
+    fprintf(stderr, "Invalid justification = %d at %s, line %d\n",
+	    just, __FILE__, __LINE__);
+    xl = xa;
+    xr = xa + width/2;
+  }
+
+  /* First, before rotation: */
+  switch(align) {
+  case ALIGNED_AT_BASELINE:
+    yt = ya + height;
+    yb = ya - depth;
+    break;
+  case ALIGNED_AT_BOTTOM:
+    yt = ya + height + depth;
+    yb = ya;
+    break;
+  case ALIGNED_AT_TOP:
+    yb = ya - height - depth;
+    yt = ya;
+    break;
+  default:			/* Centered */
+    yb = ya - 0.5*(height + depth);
+    yt = ya + 0.5*(height + depth);
+  }
+
+  /* Now, rotation */
+  if(angle == 0.0) {
+    /* xbl = x of 'bottom left' */
+    Hash_Set_Double(measures, "xbl", xl);
+    Hash_Set_Double(measures, "ybl", yb);
+    Hash_Set_Double(measures, "xtl", xl);
+    Hash_Set_Double(measures, "ytl", yt);
+    Hash_Set_Double(measures, "xbr", xr);
+    Hash_Set_Double(measures, "ybr", yb);
+    Hash_Set_Double(measures, "xtr", xr);
+    Hash_Set_Double(measures, "ytr", yt);
+  }
+  else {
+    double s = - sin(angle * PI/180);
+    double c = cos(angle * PI/180);
+    Hash_Set_Double(measures, "xbl", 
+		    xa + (xl-xa)*c + (yb - ya) * s);
+    Hash_Set_Double(measures, "ybl",
+		    ya - (xl-xa)*s + (yb - ya) * c);
+    Hash_Set_Double(measures, "xtl", 
+		    xa + (xl-xa)*c + (yt - ya) * s);
+    Hash_Set_Double(measures, "ytl",
+		    ya - (xl-xa)*s + (yt - ya) * c);
+    Hash_Set_Double(measures, "xbr", 
+		    xa + (xr-xa)*c + (yb - ya) * s);
+    Hash_Set_Double(measures, "ybr",
+		    ya - (xr-xa)*s + (yb - ya) * c);
+    Hash_Set_Double(measures, "xtr", 
+		    xa + (xr-xa)*c + (yt - ya) * s);
+    Hash_Set_Double(measures, "ytr",
+		    ya - (xr-xa)*s + (yt - ya) * c);
+  }
+  
+  /* We transform coordinates into an array 
+     (topleft, topright,  botright, botleft)
+     of arrays (xy) of doubles 
+  */
+  OBJ_PTR points = Array_New(0);
+  OBJ_PTR current_point;
+  int i;
+  for(i = 0; i < 8; i++) {
+    char buf[4];
+    if(! (i % 2)) {
+      current_point = Array_New(0);
+      Array_Push(points, current_point, &dummy);
+    }
+    snprintf(buf, sizeof(buf), "%c%c%c", 
+	     (i%2 ? 'y' : 'x'),
+	     (i/4 ? 't' : 'b'),
+	     ((i >= 2) && (i < 6) ? 'r' : 'l'));
+    Array_Push(current_point, Hash_Get_Obj(measures, buf), &dummy);
+  }
+  Hash_Set_Obj(measures, "points", points);
+}