tioga 1.6 → 1.7

data/split/Tioga/lib/Legends.rb

@@ -44,7 +44,7 @@ Dictionary Entries
     'line_color'    => a_color       # defaults to self.line_color
     'line_width'    => a_float       # defaults to self.line_width
     'line_cap'      => a_line_cap    # defaults to self.line_cap
-    'line_type'     => a_line_type   # defaults to self.line_type
+    'line_type'     => a_line_type or 'None'   # defaults to self.line_type
     'dy'            => a_float       # defaults to self.legend_text_dy
     'marker'        => a_marker      # defaults to nil
     'marker_color'  => a_color       # defaults to self.line_color
@@ -55,7 +55,9 @@ The dictionary holding the information is appended to the legend_info array.  If
 then the marker with the given 'marker_color' and 'marker_scale' will be shown in the middle of the
 legend line.  If the 'marker_dict' entry is present, it will have the values for 'x' and 'y' set to the location
 of the middle of the legend line and then it will be passed to the show_marker method.  This gives you the option of using
-the full range of marker functionality in legends -- perhaps you'd like to use a line marker that is rotated, stretched, filled in one color, and stroked in another!
+the full range of marker functionality in legends -- perhaps you'd like to use a line marker that is rotated, 
+stretched, filled in one color, and stroked in another!  Sometimes you just want to have a marker in
+the legend without a line; do this by setting line_type to 'None'.
 
 =end
     def save_legend_info(arg)

data/split/Tioga/lib/Markers.rb

@@ -28,7 +28,7 @@ Computer Modern fonts which are likely to be around since they come with TeX.  T
 in the FigureConstants module.  Any character (or string of characters) from any of these fonts can be used as a marker.
 
 Because markers are sent to PDF rather than TeX, they are limited typographically but powerful graphically.
-In addition to specifying color, scale, and rotatation, as you can for TeX text, you can also stretch
+In addition to specifying color, scale, and rotation, as you can for TeX text, you can also stretch
 the characters either along the baseline ('horizontal_scale') or perpendicular to it ('vertical_scale').
 You can slant the individual characters ('italic_angle') or shift the baseline along the text ('ascent_angle').
 Finally, you can specify the 'rendering_mode' for the marker to be any combination of #fill, #stroke, and #clip.
@@ -64,6 +64,7 @@ Dictionary Entries
     'rendering_mode'    => a_rendering_mode      # see below
     'stroke_width'      => a_float               # to be used for stroked markers
     'mode'                                       # alias for 'rendering_mode'
+    'legend'            => a_dict or a_string    # for adding marker to legend
 
 
 Examples
@@ -109,7 +110,7 @@ link:images/Marker_Shadow_Effect.png
     def show_marker(dict)
     end
 
-# Returns an array with [_width_, <i>dx_left</i>, <i>dx_right</i>, <i>dy_down</i>, <i>dy_up</i>] given in
+# Returns an array with [_width_, <i>dx_left</i>, <i>dy_down</i>, <i>dx_right</i>, <i>dy_up</i>] given in
 # figure coordinates.  The first is the width in figure x coordinates, the remainder is the bounding box
 # relative to the reference point for showing the string.
    def marker_string_info(font_number, string, scale)

data/split/Tioga/lib/Special_Paths.rb

@@ -11,7 +11,8 @@ Creates a path following a contour in a two dimensional table of data using an a
 Gri[http://gri.sourceforge.net/] done by Dan Kelley.
 (There is also an option to use the
 CONREC[http://local.wasp.uwa.edu.au/~pbourke/papers/conrec/] algorithm of Paul D. Bourke.)
-See show_contour.
+The results are returned in 2-element array with first element a vector of the x values for
+the contour and second element a vector of the y values.  See show_contour.
 
 Dictionary Entries
     'zs'        => a_dtable    # The data table
@@ -19,8 +20,8 @@ Dictionary Entries
     'xs'        => a_dvector   # The x figure coordinates for the columns of data
     'ys'        => a_dvector   # The y figure coordinates for the rows of data
     'legit'     => a_dtable    # Optional table, same size as zs, non-zero means corresponding data is okay.
-    'dest_xs'   => a_dvector   # The contour x values will be placed in this Dvector.
-    'dest_ys'   => a_dvector   # The contour y values will be placed in this Dvector.
+    'dest_xs'   => a_dvector   # The contour x values will be placed in this vector (optional).
+    'dest_ys'   => a_dvector   # The contour y values will be placed in this vector (optional).
     'gaps'      => an_array    # Indices for gaps will be placed in this Array.
     'z_level'   => a_float     # The contour level
     'z'                        # Alias for 'z_level'
@@ -34,14 +35,11 @@ Example
         clip_press_image
         t.stroke_color = SlateGray
         t.line_width = 1
-        dest_xs = Dvector.new; dest_ys = Dvector.new; gaps = Array.new
-        dict = { 'dest_xs' => dest_xs, 'dest_ys' => dest_ys, 'gaps' => gaps,
-                'xs' => @eos_logRHOs, 'ys' => @eos_logTs,
-                'data' => @pres_data }
+        dict = { 'gaps' => gaps, 'xs' => @eos_logRHOs, 'ys' => @eos_logTs, 'data' => @pres_data }
         levels.each do |level|
             dict['level'] = level
-            t.make_contour(dict)
-            t.append_points_with_gaps_to_path(dest_xs, dest_ys, gaps, true)
+            pts_array = t.make_contour(dict)
+            t.append_points_with_gaps_to_path(pts_array[0], pts_array[1], gaps, true)
             t.stroke
         end
     end
@@ -53,7 +51,9 @@ link:images/Contours.png
     end
     
 =begin rdoc
-Creates a 'staircase' path with steps matching the given data points.  
+Creates a 'staircase' path with steps matching the given data points;
+returns 2-element array with first element a vector of the x values for
+the steps and second element a vector of the y values.
 
 Dictionary Entries
     'xfirst'        => a_float    # x location for the start of the steps
@@ -66,12 +66,13 @@ Dictionary Entries
     'y_last'                      # Alias for 'ylast'
     'xs'            => a_dvector  # The data x in figure coordinates
     'ys'            => a_dvector  # The data y in figure coordinates
-    'dest_xs'       => a_dvector  # The x values for the steps will go here.
-    'dest_ys'       => a_dvector  # The y values for the steps will go here.
+    'dest_xs'       => a_dvector  # The x values for the steps will go here (optional).
+    'dest_ys'       => a_dvector  # The y values for the steps will go here (optional).
 
 The widths of steps are determined by 'xfirst', 'xs', and 'xlast'; the heights of steps are
 determined by 'yfirst', 'ys', and 'ylast'.   The steps up and down occur at the midpoints between
-the given x locations.
+the given x locations.  If 'dest_xs' are given in the dictionary, that vector will be set to
+the x values for the steps.  Similarly for 'dest_ys'.
 
 Example
 
@@ -83,16 +84,15 @@ Example
         x_first = 0.0; x_last = 18.0; y_first = y_last = 2.5
         x_results = Dvector[]
         y_results = Dvector[]
-        t.make_steps(
+        stps = t.make_steps(
             'xs' => xs, 'ys' => ys,
-            'dest_xs' => x_results, 'dest_ys' => y_results,
             'x_first' => x_first, 'y_first' => y_first,
             'x_last' => x_last, 'y_last' => y_last)
         t.show_plot('boundaries' => [-1, 19, 8, 2]) do
             t.fill_color = FloralWhite
             t.fill_frame
             t.stroke_color = Blue
-            t.append_points_to_path(x_results, y_results)
+            t.append_points_to_path(stps[0], stps[1])
             t.stroke
             t.show_marker('Xs' => xs, 'Ys' => ys, 'marker' => Bullet,
                 'scale' => 0.6, 'color' => Red);
@@ -108,6 +108,7 @@ link:images/Steps.png
 Creates an interpolated series of points smoothly connecting the given data points.  
 See also append_interpolant_to_path for creating smooth paths based on
 Bezier curves rather than on sampled points joined by straight line segments.
+Returns a vector of the y values corresponding to the requested 'sample_ys'.
 
 Dictionary Entries
     'start_slope'      => a_float    # optional
@@ -115,12 +116,12 @@ Dictionary Entries
     'xs'               => a_dvector  # The data x in figure coordinates
     'ys'               => a_dvector  # The data y in figure coordinates
     'sample_xs'        => a_dvector  # The x values where will interpolate
-    'result_ys'        => a_dvector  # The y values will be placed here.
+    'result_ys'        => a_dvector  # The y values will be placed here (optional).
 
 A cubic spline interpolant is created (see make_interpolant) using 'start_slope', 'end_slope', 'xs', and
 'ys'.  At each x location in 'sample_xs', the interpolant is used to find the corresponding y location
-which is then placed in the 'result_ys' vector.  The results can passed to routines such as 
-append_points_to_path or show_polyline.
+which is then returned as the value (and optionally also placed in the 'result_ys' vector).  
+The results can passed to routines such as append_points_to_path or show_polyline.
 
 Example
 
@@ -143,10 +144,8 @@ Example
             smooth_pts = 4*(data_pts-1) + 1
             dx = (xs[data_pts-1] - xs[0])/(smooth_pts-1)
             sample_xs = Dvector.new(smooth_pts) { |i| i*dx + xs[0] }
-            result_ys = Dvector.new
-            t.make_spline_interpolated_points(
-                'sample_xs' => sample_xs, 'result_ys' => result_ys,
-                'xs' => xs, 'ys' => ys,
+            result_ys = t.make_spline_interpolated_points(
+                'sample_xs' => sample_xs, 'xs' => xs, 'ys' => ys,
                 'start_slope' => 2.5*(ys[1]-ys[0])/(xs[1]-xs[0]))
             t.stroke_color = Blue
             t.append_points_to_path(sample_xs, result_ys)

data/split/Tioga/lib/TeX_Text.rb

@@ -61,6 +61,10 @@ With double quotes, Ruby uses backslash for a variety of escape characters such
 so the backslashes for TeX need to be entered as \\ pairs to be safe.
 Compare '$\nu\sim\tau$' to the equivalent form "$\\\\nu\\\\sim\\\\tau$" and the incorrect form "$\nu\sim\tau$".
 
+Starting from Tioga 1.7, Tioga can measure the TeX text it typesets. For
+that purpose, provide #show_text with a 'measure' dictionnary entry that
+serves as a key to retrieve the information using #get_text_size.   
+
 Dictionary Entries
     'text'            => a_string        # to be processed by TeX
     'side'            => a_side          # TOP, BOTTOM, LEFT, or RIGHT
@@ -77,7 +81,8 @@ Dictionary Entries
     'angle'           => a_float         # degrees to rotate.  default 0
     'alignment'       => an_alignment    # see discussion of alignment
     'justification'   => a_justification # see discussion of justification
-
+    'measure'         => a_string        # the name of the measure
+     
 Examples
 
     def math_typesetting
@@ -204,6 +209,79 @@ link:images/Framebox.png
     def show_text(dict)
     end
 
+=begin rdoc
+Returns information about the text measure named _name_. It returns a hash
+with the following information:
+
+ * _[xy][tb][lr]_ the X/Y coordinates of the Top/Bottom Left/Right point of the
+   box around the text (top, left, right and bottom are relative to the text
+   natural orientation)
+ * _just_ the text justification
+ * _angle_ the text's angle, in degrees
+ * _tex_measured_depth_, _tex_measured_height_, tex_measured_width_, the
+   text's depth, width and height as measured by TeX,
+  (does not take scaling into accound)
+ * _xanchor_, _yanchor_: the page coordinates of the position of the text
+   (the ones that were given to #show_text)
+ * _points_ an array of (x,y) coordinates of the points that make the box,
+   in the order bottom left, bottom right, top right, top left.
+ * _depth_, _width_, _height_ : the size of the text.
+ * _align_ the alignment of the text
+
+All the measures are given in postscript points, which means you need
+to multiply by 10 before using the with 
+Page_Frame_Bounds#convert_output_to_figure_x 
+Page_Frame_Bounds#convert_output_to_figure_y. See the example
+
+Please make sure you test the presence of one key before using it, as
+any code using measures has to run *twice*: one first time to typeset the
+text and ask LaTeX for information about its size, and the second time to
+actually use the information. You don't need to call the code twice as it
+is done automatically, but keep in mind that in the first run, the returned
+hash will be empty.
+
+    def text_size_with_rotation
+      t.stroke_rect(0,0,1,1)
+      t.rescale(0.5)
+
+      equation = '\int_{-\infty}^{\infty} \! e^{-x^{2}}\, \! dx = \sqrt{\pi}'
+      text = "\\fbox{$\\displaystyle #{equation}$}"
+
+      nb = 5
+      nb.times do |i|
+        scale = 0.5 + i * 0.2
+        angle = i * 37
+        x = (i+1)/(nb+1.0)
+        y = x
+        color = [1.0 - i * 0.2, i*0.2, 0]
+        t.show_text('text' => text, 'color' => color, 'x' => x, 
+                    'y' => x,
+                    'alignment' => ALIGNED_AT_MIDHEIGHT,
+                    'scale' => scale , 'measure' => "box#{i}", 
+                    'angle' => angle )
+        size = t.get_text_size("box#{i}")
+        if size.key? 'points'
+          xs = Dvector.new
+          ys = Dvector.new
+          for x,y in size['points']
+            xs << t.convert_output_to_figure_x(x)
+            ys << t.convert_output_to_figure_y(y)
+          end
+          t.stroke_color = color
+          t.line_type = Line_Type_Dashes
+          t.stroke_rect(xs.min, ys.min,
+                        (xs.max - xs.min),(ys.max - ys.min))
+        end
+      end
+    end
+
+link:images/Text_size_with_rotation.png
+
+=end
+
+    def get_text_size(name)
+    end
+
 # Changes the default_text_scale attribute by multiplying it times _scale_.
 # This also updates the default_text_height_dx and default_text_height_dy
 # attributes to match the new setting for default_text_scale.

data/split/Tioga/lib/TexPreamble.rb

@@ -152,6 +152,20 @@ module Tioga
 % personnaly doubt it would really come in useful ;-)...
 \newcommand\tiogasetfont{\reset@font\SetTiogaFontInfo%
 \selectfont}%
+
+
+% This commands typesets its second argument while sending to the
+% standard output successively the width, height and depth of the
+% box produced.
+%
+% These informations are collected when Tioga runs pdflatex.
+\newlength{\tiogatempdim}
+\newcommand{\tiogameasure}[2]{%
+\settowidth{\tiogatempdim}{#2}\typeout{#1[0]=\the\tiogatempdim}%
+\settoheight{\tiogatempdim}{#2}\typeout{#1[1]=\the\tiogatempdim}%
+\settodepth{\tiogatempdim}{#2}\typeout{#1[2]=\the\tiogatempdim}%
+{#2}}
+
 \makeatother
 End_of_preamble
     COLOR_PREAMBLE = <<'End_of_preamble'

data/split/Tioga/lib/Utils.rb

@@ -54,7 +54,7 @@ module Tioga
     }
 
     # Returns the value of the given TeX dimension in postscript points.
-    def tex_dimension_to_bp(dim)
+    def self.tex_dimension_to_bp(dim)
       for unit, val in DIMENSION_CONVERSION
         if dim =~ /^\s*([\d.]+)\s*#{unit}$/
           return $1.to_f * val
@@ -69,6 +69,10 @@ module Tioga
       raise "'#{dim}' is not a valid TeX dimension"
     end
 
+    def tex_dimension_to_bp(dim)
+      return Utils::tex_dimension_to_bp(dim)
+    end
+
 
   end
 end

data/split/Tioga/pdfs.h

@@ -24,18 +24,9 @@
 
 #include <namespace.h>
 
-#include "flate.h"
-
-extern VALUE rb_Integer_class, rb_Numeric_class;
-extern ID save_dir_ID, model_number_ID, add_model_number_ID, quiet_mode_ID;
-extern ID tex_preview_documentclass_ID, tex_preview_preamble_ID, tex_preview_pagestyle_ID;
-extern ID tex_preview_left_margin_ID, tex_preview_right_margin_ID, tex_preview_top_margin_ID;
-extern ID tex_preview_bottom_margin_ID, tex_preview_left_fudge_ID, tex_preview_top_fudge_ID;
-extern ID do_cmd_ID, data_dir_ID, initialized_ID, tex_xoffset_ID, tex_yoffset_ID;
-
-extern long int *obj_offsets, capacity_obj_offsets, stream_start, stream_end, length_offset, xref_offset;
-extern int num_objects, next_available_object_number, next_available_gs_number, next_available_xo_number;
-extern int next_available_shade_number, next_available_font_number;
+extern long *obj_offsets, capacity_obj_offsets, stream_start, stream_end, length_offset, xref_offset;
+extern long num_objects, next_available_object_number, next_available_gs_number, next_available_xo_number;
+extern long next_available_shade_number, next_available_font_number;
 extern void Record_Object_Offset(int obj_number);
 extern char *predefined_Fonts[];
 extern int num_pdf_standard_fonts, num_predefined_fonts;
@@ -75,6 +66,8 @@ typedef struct jpg_info {
    int mask_obj_num;
    char *filename;
 } JPG_Info;
+extern void Write_JPG(JPG_Info *xo, int *ierr);
+extern void Free_JPG(JPG_Info *xo);
 
 typedef struct sampled_info {
    // start must match start of xobj_info
@@ -96,6 +89,8 @@ typedef struct sampled_info {
    int lookup_len;
    unsigned char *lookup;
 } Sampled_Info;
+extern void Write_Sampled(Sampled_Info *xo, int *ierr);
+extern void Free_Sampled(Sampled_Info *xo);
 
 #define JPG_SUBTYPE 1
 #define SAMPLED_SUBTYPE 2
@@ -186,44 +181,11 @@ extern Old_Font_Dictionary *old_font_dictionaries;
 
 #define RADIANS_TO_DEGREES (180.0 / PI)
 
-extern bool Used_Any_Fonts(void);
-extern void Clear_Fonts_In_Use_Flags(void);
-extern void Write_Font_Dictionaries(void);
-extern void Write_Font_Descriptors(void);
-extern void Write_Font_Widths(void);
-extern void Write_Functions(void);
-extern void Write_Stroke_Opacity_Objects(void);
-extern void Write_Fill_Opacity_Objects(void);
-extern void Write_Shadings(void);
-extern void Write_JPG(JPG_Info *xo);
-extern void Write_Sampled(Sampled_Info *xo);
-extern void Free_Stroke_Opacities(void);
-extern void Free_Shadings();
-extern void Free_Functions();
-extern void Free_JPG(JPG_Info *xo);
-extern void Free_Sampled(Sampled_Info *xo);
-extern void Free_Fill_Opacities(void);
-
-extern void c_append_rect(FM *p, double x, double y, double width, double height);
-extern void c_clip(FM *p);
-
 extern bool have_current_point, constructing_path, writing_file;
-extern double bbox_llx, bbox_lly, bbox_urx, bbox_ury;
 
 extern FILE *OF; // for the PDF file
 extern FILE *TF; // for the temp file holding the uncompressed stream
 
-extern void Unpack_RGB(VALUE rgb, double *rp, double *gp, double *bp);
-
-extern void Start_Axis_Standard_State(FM *p, VALUE color, double line_width);
-extern void End_Axis_Standard_State(void);
-
-extern void Write_gsave(void);
-extern void Write_grestore(void);
-
-extern void c_private_set_default_font_size(FM *p, double size);
-
-void Init_Font_Dictionary(void);
 
 #endif   /* __pdfs_H__ */
 

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

@@ -25,22 +25,24 @@ typedef struct {
    int type;
    int other_axis_type;
    double line_width;
-   VALUE stroke_color;
+   double stroke_color_R;
+   double stroke_color_G;
+   double stroke_color_B;
    double major_tick_width; // same units as line_width
    double minor_tick_width; // same units as line_width
    double major_tick_length; // in units of numeric label char heights
    double minor_tick_length; // in units of numeric label char heights
-   bool log_values;
+   bool log_vals;
    bool ticks_inside; // inside frame or toward larger x or y value for specific location
    bool ticks_outside; // inside frame or toward smaller x or y value for specific location
    double tick_interval; // set to 0 to use default
    double min_between_major_ticks; // in units of numeric label char heights
    int number_of_minor_intervals; // set to 0 to use default
-   VALUE locations_for_major_ticks; // set to nil to use defaults
-   VALUE locations_for_minor_ticks; // set to nil to use defaults
+   OBJ_PTR locations_for_major_ticks; // set to nil to use defaults
+   OBJ_PTR locations_for_minor_ticks; // set to nil to use defaults
    bool use_fixed_pt;
    int digits_max;
-   VALUE tick_labels; // set to nil to use defaults
+   OBJ_PTR tick_labels; // set to nil to use defaults
    double numeric_label_scale;
    double numeric_label_shift; // in char heights, positive for out from edge (or toward larger x or y value)
    double numeric_label_angle;
@@ -65,62 +67,62 @@ typedef struct {
    int location;
 } PlotAxis;
 
-static void Init_PlotAxis_struct(PlotAxis *s) {
-   s->free_majors = s->free_strings_for_labels = false;
-   s->stroke_color = s->locations_for_major_ticks = s->locations_for_minor_ticks = s->tick_labels = Qnil;
-   s->majors = NULL;
-   s->labels = NULL;
-}
-
-static void axis_stroke(FM *p);
-void figure_moveto(FM *p, double x, double y) // figure coords
+static void figure_moveto(OBJ_PTR fmkr, FM *p, double x, double y, int *ierr) // figure coords
 {
-   c_moveto(p, convert_figure_to_output_x(p,x), convert_figure_to_output_y(p,y));
+   c_moveto(fmkr, p, convert_figure_to_output_x(p,x), convert_figure_to_output_y(p,y), ierr);
 }
 
-void figure_lineto(FM *p, double x, double y) // figure coords
+static void figure_lineto(OBJ_PTR fmkr, FM *p, double x, double y, int *ierr) // figure coords
 {
-   c_lineto(p, convert_figure_to_output_x(p,x), convert_figure_to_output_y(p,y));
+   c_lineto(fmkr, p, convert_figure_to_output_x(p,x), convert_figure_to_output_y(p,y), ierr);
 }
 
-void figure_join(FM *p, double x0, double y0, double x1, double y1) // figure coords
+static void figure_join(OBJ_PTR fmkr, FM *p, 
+   double x0, double y0, double x1, double y1, int *ierr) // figure coords
 {
-   figure_moveto(p, x0, y0);
-   figure_lineto(p, x1, y1);
+   figure_moveto(fmkr, p, x0, y0, ierr);
+   figure_lineto(fmkr, p, x1, y1, ierr);
 }
 
-static void axis_stroke(FM *p)
+static void axis_stroke(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM_stroke(p->fm);
+   c_stroke(fmkr,p, ierr);
 }
 
-void figure_join_and_stroke(FM *p, double x0, double y0, double x1, double y1) // figure coords
+static void figure_join_and_stroke(OBJ_PTR fmkr, FM *p, 
+   double x0, double y0, double x1, double y1, int *ierr) // figure coords
 {
-   figure_join(p, x0, y0, x1, y1);
-   FM_stroke(p->fm);
+   figure_join(fmkr, p, x0, y0, x1, y1, ierr);
+   c_stroke(fmkr,p, ierr);
 }
 
-static void Get_xaxis_Specs(FM *p, PlotAxis *s)
+static void Get_xaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 {
+   s->free_majors = s->free_strings_for_labels = false;
+   s->stroke_color_R = 0.0; s->stroke_color_G = 0.0; s->stroke_color_B = 0.0; 
+   s->majors = NULL;
+   s->labels = NULL;
    s->type = p->xaxis_type;
    s->other_axis_type = p->yaxis_type;
    s->line_width = p->xaxis_line_width; // for axis line
-   s->stroke_color = p->xaxis_stroke_color; // for axis line and tick marks
+   s->stroke_color_R = p->xaxis_stroke_color_R; // for axis line and tick marks
+   s->stroke_color_G = p->xaxis_stroke_color_G;
+   s->stroke_color_B = p->xaxis_stroke_color_B;
    s->major_tick_width = p->xaxis_major_tick_width; // same units as line_width
    s->minor_tick_width = p->xaxis_minor_tick_width; // same units as line_width
    s->major_tick_length = p->xaxis_major_tick_length; // in units of numeric label char heights
    s->minor_tick_length = p->xaxis_minor_tick_length; // in units of numeric label char heights
-   s->log_values = p->xaxis_log_values;
+   s->log_vals = p->xaxis_log_values;
    s->ticks_inside = p->xaxis_ticks_inside; // inside frame or toward larger x or y value for specific location
    s->ticks_outside = p->xaxis_ticks_outside; // inside frame or toward smaller x or y value for specific location
    s->tick_interval = p->xaxis_tick_interval; // set to 0 to use default
    s->min_between_major_ticks = p->xaxis_min_between_major_ticks; // in units of numeric label char heights
-   s->number_of_minor_intervals = p->xaxis_number_of_minor_intervals; // set to 0 to use default
-   s->locations_for_major_ticks = p->xaxis_locations_for_major_ticks; // set to nil to use defaults
-   s->locations_for_minor_ticks = p->xaxis_locations_for_minor_ticks; // set to nil to use defaults
+   s->number_of_minor_intervals = p->xaxis_number_of_minor_intervals; // set to 0 to use default   
+   s->locations_for_major_ticks = Get_xaxis_locations_for_major_ticks(fmkr, ierr);
+   s->locations_for_minor_ticks = Get_xaxis_locations_for_minor_ticks(fmkr, ierr);
    s->use_fixed_pt = p->xaxis_use_fixed_pt;
    s->digits_max = p->xaxis_digits_max;
-   s->tick_labels = p->xaxis_tick_labels; // set to nil to use defaults. else must have a label for each major tick
+   s->tick_labels = Get_xaxis_tick_labels(fmkr, ierr);
    s->numeric_label_decimal_digits = p->xaxis_numeric_label_decimal_digits; // set to negative to use default
    s->numeric_label_scale = p->xaxis_numeric_label_scale;
    s->numeric_label_shift = p->xaxis_numeric_label_shift; // in char heights, positive for out from edge (or toward larger x or y value)
@@ -131,27 +133,33 @@ static void Get_xaxis_Specs(FM *p, PlotAxis *s)
    s->numeric_label_phase = p->xaxis_numeric_label_phase;
 }
 
-static void Get_yaxis_Specs(FM *p, PlotAxis *s)
+static void Get_yaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 {
+   s->free_majors = s->free_strings_for_labels = false;
+   s->stroke_color_R = 0.0; s->stroke_color_G = 0.0; s->stroke_color_B = 0.0; 
+   s->majors = NULL;
+   s->labels = NULL;
    s->type = p->yaxis_type;
    s->other_axis_type = p->xaxis_type;
    s->line_width = p->yaxis_line_width; // for axis line
-   s->stroke_color = p->yaxis_stroke_color; // for axis line and tick marks
+   s->stroke_color_R = p->yaxis_stroke_color_R; // for axis line and tick marks
+   s->stroke_color_G = p->yaxis_stroke_color_G;
+   s->stroke_color_B = p->yaxis_stroke_color_B;
    s->major_tick_width = p->yaxis_major_tick_width; // same units as line_width
    s->minor_tick_width = p->yaxis_minor_tick_width; // same units as line_width
    s->major_tick_length = p->yaxis_major_tick_length; // in units of numeric label char heights
    s->minor_tick_length = p->yaxis_minor_tick_length; // in units of numeric label char heights
-   s->log_values = p->yaxis_log_values;
+   s->log_vals = p->yaxis_log_values;
    s->ticks_inside = p->yaxis_ticks_inside; // inside frame or toward larger x or y value for specific location
    s->ticks_outside = p->yaxis_ticks_outside; // inside frame or toward smaller x or y value for specific location
    s->tick_interval = p->yaxis_tick_interval; // set to 0 to use default
    s->min_between_major_ticks = p->yaxis_min_between_major_ticks; // in units of numeric label char heights
-   s->number_of_minor_intervals = p->yaxis_number_of_minor_intervals; // set to 0 to use default
-   s->locations_for_major_ticks = p->yaxis_locations_for_major_ticks; // set to nil to use defaults
-   s->locations_for_minor_ticks = p->yaxis_locations_for_minor_ticks; // set to nil to use defaults
+   s->number_of_minor_intervals = p->yaxis_number_of_minor_intervals; // set to 0 to use default   
+   s->locations_for_major_ticks = Get_yaxis_locations_for_major_ticks(fmkr, ierr);
+   s->locations_for_minor_ticks = Get_yaxis_locations_for_minor_ticks(fmkr, ierr);
+   s->tick_labels = Get_yaxis_tick_labels(fmkr, ierr);   
    s->use_fixed_pt = p->yaxis_use_fixed_pt;
    s->digits_max = p->yaxis_digits_max;
-   s->tick_labels = p->yaxis_tick_labels; // set to nil to use defaults. else must have a label for each major tick
    s->numeric_label_decimal_digits = p->yaxis_numeric_label_decimal_digits; // set to negative to use default
    s->numeric_label_scale = p->yaxis_numeric_label_scale;
    s->numeric_label_shift = p->yaxis_numeric_label_shift; // in char heights, positive for out from edge (or toward larger x or y value)
@@ -164,7 +172,7 @@ static void Get_yaxis_Specs(FM *p, PlotAxis *s)
 
 /*======================================================================*/
 
-static void draw_axis_line(FM *p, int location, PlotAxis *s)
+static void draw_axis_line(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s, int *ierr)
 {
    switch (location) {
       case LEFT:
@@ -246,58 +254,58 @@ static void draw_axis_line(FM *p, int location, PlotAxis *s)
          s->top_or_right = false;
          break;
    }
-   c_line_width_set(p, s->line_width);
-   figure_join_and_stroke(p, s->x0, s->y0, s->x1, s->y1);
+   c_line_width_set(fmkr, p, s->line_width, ierr);
+   figure_join_and_stroke(fmkr, p, s->x0, s->y0, s->x1, s->y1, ierr);
 }
 
-static char *Create_Label(double value, int scale, int prec, bool log_values, bool use_fixed_pt, char *postfix, PlotAxis *s)
-{ // value in figure coords
-   char buff[100], *string;
-   int exponent = ROUND(value);
+static char *Create_Label(double val, int scale, int prec, 
+   bool log_vals, bool use_fixed_pt, char *postfix, PlotAxis *s, int *ierr)
+{ // val in figure coords
+   char buff[100], form[100], *string;
+   int exponent = ROUND(val);
    buff[0] = 0;
-   if (log_values && use_fixed_pt) {   /* Logarithmic */
-     double sav_val = value, pow_val;
-     value = pow(10.0, exponent);
+   if (log_vals && use_fixed_pt) {   /* Logarithmic */
+     double sav_val = val, pow_val;
+     val = pow(10.0, exponent);
      pow_val = pow(10.0, sav_val);
      if (exponent < 0) {
-        char form[60];
         int numdig = ABS(exponent)+1; 
-        sprintf(form, (s->vertical)? "\\tiogayaxisnumericlabel{%%.%df}" : "\\tiogaxaxisnumericlabel{%%.%df}", numdig);
-        sprintf(buff, form, pow_val);
-     } else if (abs(value - pow_val) > 0.1) {
-        sprintf(buff, (s->vertical)? "\\tiogayaxisnumericlabel{%0.2f}" : "\\tiogaxaxisnumericlabel{%0.2f}", pow_val);
+        snprintf(form, sizeof(form), (s->vertical)? "\\tiogayaxisnumericlabel{%%.%df}" : "\\tiogaxaxisnumericlabel{%%.%df}", numdig);
+        snprintf(buff, sizeof(buff), form, pow_val);
+     } else if (abs(val - pow_val) > 0.1) {
+        snprintf(buff, sizeof(buff), (s->vertical)? "\\tiogayaxisnumericlabel{%0.2f}" : "\\tiogaxaxisnumericlabel{%0.2f}", pow_val);
      } else {
-        sprintf(buff,  (s->vertical)? "\\tiogayaxisnumericlabel{%d}" : "\\tiogaxaxisnumericlabel{%d}", (int) value);
+        snprintf(buff, sizeof(buff), (s->vertical)? "\\tiogayaxisnumericlabel{%d}" : "\\tiogaxaxisnumericlabel{%d}", (int) val);
      }
-   } else if (log_values) {
+   } else if (log_vals) {
      /* Exponential, i.e. 10^-1, 1, 10, 10^2, etc */
-     double abs_diff = fabs(value - exponent);
-     if (abs_diff > 0.1) sprintf(buff,  (s->vertical)? "\\tiogayaxisnumericlabel{10^{%0.1f}}" : "\\tiogaxaxisnumericlabel{10^{%0.1f}}", value);
+     double abs_diff = fabs(val - exponent);
+     if (abs_diff > 0.1) snprintf(buff, sizeof(buff), (s->vertical)? "\\tiogayaxisnumericlabel{10^{%0.1f}}" : "\\tiogaxaxisnumericlabel{10^{%0.1f}}", val);
      else if (exponent == 0) strcpy(buff, "1");
      else if (exponent == 1) strcpy(buff, "10");
-     else sprintf(buff,  (s->vertical)? "\\tiogayaxisnumericlabel{10^{%d}}" : "\\tiogaxaxisnumericlabel{10^{%d}}", exponent);
+     else snprintf(buff, sizeof(buff),  (s->vertical)? "\\tiogayaxisnumericlabel{10^{%d}}" : "\\tiogaxaxisnumericlabel{10^{%d}}", exponent);
    } else {   /* Linear */
-      char form[10];
       double scale2;
       int precis = s->numeric_label_decimal_digits; //  use this precision if it is >= 0
       if (precis >= 0) prec = precis;
-      if (scale) value /= pow(10.,(double)scale);
+      if (scale) val /= pow(10.,(double)scale);
       /* This is necessary to prevent labels like "-0.0" on some systems */
       scale2 = pow(10., prec);
-      value = floor((value * scale2) + .5) / scale2;
-      sprintf(form, (s->vertical)?  "\\tiogayaxisnumericlabel{%%.%df}" : "\\tiogaxaxisnumericlabel{%%.%df}", (int) prec);
-      sprintf(buff, form, value);
+      val = floor((val * scale2) + .5) / scale2;
+      snprintf(form, sizeof(form), (s->vertical)?  "\\tiogayaxisnumericlabel{%%.%df}" : "\\tiogaxaxisnumericlabel{%%.%df}", (int) prec);
+      snprintf(buff, sizeof(buff), form, val);
    }
    int len = strlen(buff);
    if (postfix != NULL) { strcpy(buff+len, postfix); len = strlen(buff); }
-   string = ALLOC_N(char, len+1);
+   string = ALLOC_N_char(len+1);
    strcpy(string, buff);
    return string;
 }
 
-char *Get_String(VALUE ary, int index) {
-   VALUE string = rb_ary_entry(ary, index);
-   return StringValuePtr(string);
+char *Get_String(OBJ_PTR ary, int index, int *ierr) {
+   OBJ_PTR s = Array_Entry(ary,index,ierr);
+   if (*ierr != 0) return NULL;
+   return String_Ptr(s,ierr);
 }
 
 #define MAX_FIXDIG_POS  6
@@ -305,7 +313,7 @@ char *Get_String(VALUE ary, int index) {
 #define DIGMAX_DEF   6
 
 static void Pick_Label_Precision(double vmin, double vmax, double tick, bool use_fixed_pt,
-   int *mode, int *prec, int digmax, int *scale) {
+   int *mode, int *prec, int digmax, int *scale, int *ierr) {
    double chosen, notchosen, vmod, t0, shifted;
    int msd, notmsd, np, digmin, digfix;
    *mode = *scale = 0;
@@ -383,23 +391,25 @@ static void Pick_Label_Precision(double vmin, double vmax, double tick, bool use
    
 }
 
-static char **Get_Labels(FM *p, PlotAxis *s)
+static char **Get_Labels(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 {
-   char **labels = (char **)ALLOC_N(char *, s->nmajors);
+   char **labels = (char **)ALLOC_N_pointer(s->nmajors);
    char postfix[50], *ps;
    int i, k, j;
    k = s->numeric_label_frequency;
    j = s->numeric_label_phase;
-   if (s->tick_labels==Qnil) { // create label strings
+   if (s->tick_labels==OBJ_NIL) { // create label strings
       int mode, prec, scale;
-      Pick_Label_Precision(s->axis_min, s->axis_max, s->interval, s->use_fixed_pt, &mode, &prec, s->digits_max, &scale);
+      Pick_Label_Precision(s->axis_min, s->axis_max, s->interval, 
+         s->use_fixed_pt, &mode, &prec, s->digits_max, &scale, ierr);
+      if (*ierr != 0) return NULL;
       int i;
       int upper_right = (s->reversed)? 0 : s->nmajors-1;
       int lower_left = (s->reversed)? s->nmajors-1 : 0;
       for (i = 0; i < s->nmajors; i++) {
          ps = NULL;
-         if (i == upper_right && !s->log_values && mode && scale)
-            sprintf(ps = postfix, 
+         if (i == upper_right && !s->log_vals && mode && scale)
+	   snprintf(ps = postfix, sizeof(postfix), 
                 (s->vertical)? "$\\times$\\tiogayaxisnumericlabel{10^{%d}}" : "$\\times$\\tiogaxaxisnumericlabel{10^{%d}}", 
                 scale);
          if ((i+j) % k != 0) {
@@ -410,23 +420,29 @@ static char **Get_Labels(FM *p, PlotAxis *s)
                  s->other_axis_type == AXIS_WITH_TICKS_AND_NUMERIC_LABELS)) {
             labels[i] = NULL;
          } else {
-            labels[i] = Create_Label(s->majors[i], scale, prec, s->log_values, s->use_fixed_pt, ps, s);
+            labels[i] = Create_Label(s->majors[i], scale, prec, s->log_vals, s->use_fixed_pt, ps, s, ierr);
+            if (*ierr != 0) return NULL;
         }
       }
       s->free_strings_for_labels = true;
    } else { // use the given label strings
-      VALUE ary = rb_Array(s->tick_labels);
-      if (RARRAY(ary)->len != s->nmajors)
-         rb_raise(rb_eArgError, "Sorry: must have same number of labels as major ticks");
+      int len = Array_Len(s->tick_labels,ierr);
+      if (*ierr != 0) return NULL;
+      if (len != s->nmajors) {
+         RAISE_ERROR("Sorry: must have same number of labels as major ticks", ierr);
+         return NULL;
+      }
       for (i = 0; i < s->nmajors; i++) {
-         labels[i] = Get_String(ary, i);
+         labels[i] = Get_String(s->tick_labels, i, ierr);
+         if (*ierr != 0) return NULL;
       }
       s->free_strings_for_labels = false;
    }
    return labels;
 }
          
-static double *Pick_Locations_for_Major_Ticks(double interval, double axis_min, double axis_max, int *num_locations)
+static double *Pick_Locations_for_Major_Ticks(double interval, 
+   double axis_min, double axis_max, int *num_locations, int *ierr)
 {
    double next_tick, prev_tick, starting_tick;
    double *majors;
@@ -445,7 +461,7 @@ static double *Pick_Locations_for_Major_Ticks(double interval, double axis_min,
        if (nmajors > 1) break;
        interval *= 0.5;
    }
-   majors = ALLOC_N(double, nmajors);
+   majors = ALLOC_N_double(nmajors);
    prev_tick = starting_tick;
    for (i=0; i < nmajors; i++) {
       majors[i] = prev_tick += interval;
@@ -454,7 +470,7 @@ static double *Pick_Locations_for_Major_Ticks(double interval, double axis_min,
    return majors;
 }
 
-static int Pick_Number_of_Minor_Intervals(double length)
+static int Pick_Number_of_Minor_Intervals(double length, int *ierr)
 {
    double t1, fuzz, newlen;
    int np, num_subintervals, inewlen;
@@ -482,7 +498,8 @@ static int Pick_Number_of_Minor_Intervals(double length)
    return num_subintervals;
 }
 
-static void Pick_Major_Tick_Interval(FM *p, double tick_min, double tick_gap, double length, bool log_values, double *tick)
+static void Pick_Major_Tick_Interval(OBJ_PTR fmkr, FM *p, 
+      double tick_min, double tick_gap, double length, bool log_vals, double *tick, int *ierr)
 {
    double t1, t2, tick_reasonable, base_interval;
    int np, i;
@@ -497,7 +514,7 @@ static void Pick_Major_Tick_Interval(FM *p, double tick_min, double tick_gap, do
    else if (t1 > 1.5) { t2 = 5.0; np--; }
    else { t2 = 2.0; np--; }
    /* Now compute reasonable tick spacing */
-   if (log_values) {
+   if (log_vals) {
     tick_reasonable = 1.0; 
    } else {
        base_interval = pow(10.0, (double) np);
@@ -513,17 +530,19 @@ static void Pick_Major_Tick_Interval(FM *p, double tick_min, double tick_gap, do
    else { // check the given interval compared to the default
       *tick = ABS(*tick);
       if(*tick < 1.e-4*tick_reasonable) {
-         rb_raise(rb_eArgError, "Sorry: magnitude of specified tick interval (%g) is too small", *tick);
+         RAISE_ERROR_g("Sorry: magnitude of specified tick interval (%g) is too small", *tick, ierr);
+         return;
       }
    }
 }
 
-static void draw_major_ticks(FM *p, PlotAxis *s)
+static void draw_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 {
    s->num_minors = s->number_of_minor_intervals; 
-   if (s->locations_for_major_ticks != Qnil) {
+   if (s->locations_for_major_ticks != OBJ_NIL) {
       long len;
-      s->majors = Dvector_Data_for_Read(s->locations_for_major_ticks, &len);
+      s->majors = Vector_Data_for_Read(s->locations_for_major_ticks, &len, ierr);
+      if (*ierr != 0) return;
       s->nmajors = len;
       if (len > 1) {
         s->interval = s->majors[1] - s->majors[0];
@@ -534,8 +553,10 @@ static void draw_major_ticks(FM *p, PlotAxis *s)
       double height = ((s->vertical)? p->default_text_height_dy : p->default_text_height_dx);
       double tick_min = s->min_between_major_ticks * height;
       double tick_gap = 10.0 * height;
-      Pick_Major_Tick_Interval(p, tick_min, tick_gap, s->length, s->log_values, &s->interval);
-      s->majors = Pick_Locations_for_Major_Ticks(s->interval, s->axis_min, s->axis_max, &s->nmajors);
+      Pick_Major_Tick_Interval(fmkr, p, tick_min, tick_gap, s->length, s->log_vals, &s->interval, ierr);
+      if (*ierr != 0) return;
+      s->majors = Pick_Locations_for_Major_Ticks(s->interval, s->axis_min, s->axis_max, &s->nmajors, ierr);
+      if (*ierr != 0) return;
       s->free_majors = true;
    }
    int i;
@@ -545,51 +566,64 @@ static void draw_major_ticks(FM *p, PlotAxis *s)
    if (s->ticks_inside) inside = length;
    if (s->ticks_outside) outside = length;
    if (s->top_or_right) { inside = -inside; outside = -outside; }
-   if (s->line_width != s->major_tick_width)
-      c_line_width_set(p, s->line_width = s->major_tick_width);
+   if (s->line_width != s->major_tick_width) {
+      c_line_width_set(fmkr, p, s->line_width = s->major_tick_width, ierr);
+      if (*ierr != 0) return;
+   }
    for (i=0; i < s->nmajors; i++) {
       if (s->vertical)
-         figure_join(p, s->x0+inside, s->majors[i], s->x0+outside, s->majors[i]);
+         figure_join(fmkr, p, s->x0+inside, s->majors[i], s->x0+outside, s->majors[i], ierr);
       else
-         figure_join(p, s->majors[i], s->y0+inside, s->majors[i], s->y0+outside);
+         figure_join(fmkr, p, s->majors[i], s->y0+inside, s->majors[i], s->y0+outside, ierr);
       did_line = true;
+      if (*ierr != 0) return;
    }
-   if (did_line) axis_stroke(p);
+   if (did_line) axis_stroke(fmkr,p, ierr);
 }
 
-static double log_subintervals[8] =
-{
-    0.301030, 0.477121, 0.602060, 0.698970,
-    0.778151, 0.845098, 0.903090, 0.954243
-};
-
-static void draw_minor_ticks(FM *p, PlotAxis *s)
+static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 {
    if (s->number_of_minor_intervals <= 0) {
-      if (s->log_values) {
+      if (s->log_vals) {
          double interval = s->majors[1] - s->majors[0];
          s->number_of_minor_intervals = (abs(interval) != 1.0 || s->nmajors > 10)? 1 : 9; 
-      }  else s->number_of_minor_intervals = Pick_Number_of_Minor_Intervals(s->interval);
+      }  else {
+         s->number_of_minor_intervals = Pick_Number_of_Minor_Intervals(s->interval, ierr);
+         if (*ierr != 0) return;
+      }
    }
    int i, j, nsub = s->number_of_minor_intervals;
    double inside=0.0, outside=0.0, length;
    bool did_line = false;
-   if (s->log_values && nsub > 9) nsub = 9;
+   double log_subintervals[8];
+   log_subintervals[0] = 0.301030;
+   log_subintervals[1] = 0.477121;
+   log_subintervals[2] = 0.602060;
+   log_subintervals[3] = 0.698970;
+   log_subintervals[4] = 0.778151;
+   log_subintervals[5] = 0.845098;
+   log_subintervals[6] = 0.903090;
+   log_subintervals[7] = 0.954243;
+   if (s->log_vals && nsub > 9) nsub = 9;
    length = s->minor_tick_length * ((s->vertical)? p->default_text_height_dx : p->default_text_height_dy);
    if (s->ticks_inside) inside = length;
    if (s->ticks_outside) outside = length;
    if (s->top_or_right) { inside = -inside; outside = -outside; }
-   if (s->line_width != s->minor_tick_width)
-      c_line_width_set(p, s->line_width = s->minor_tick_width);
-   if (s->locations_for_minor_ticks != Qnil) {
+   if (s->line_width != s->minor_tick_width) {
+      c_line_width_set(fmkr, p, s->line_width = s->minor_tick_width, ierr);
+      if (*ierr != 0) return;
+   }
+   if (s->locations_for_minor_ticks != OBJ_NIL) {
       long cnt;
-      double *locs = Dvector_Data_for_Read(s->locations_for_minor_ticks, &cnt);
+      double *locs = Vector_Data_for_Read(s->locations_for_minor_ticks, &cnt, ierr);
+      if (*ierr != 0) return;
       for (i=0; i < cnt; i++) {
          if (s->vertical)
-            figure_join(p, s->x0+inside, locs[i], s->x0+outside, locs[i]);
+            figure_join(fmkr, p, s->x0+inside, locs[i], s->x0+outside, locs[i], ierr);
          else
-            figure_join(p, locs[i], s->y0+inside, locs[i], s->y0+outside);
+            figure_join(fmkr, p, locs[i], s->y0+inside, locs[i], s->y0+outside, ierr);
          did_line = true;
+         if (*ierr != 0) return;
       }
    } else {
       for (i=0; i <= s->nmajors; i++) {
@@ -598,54 +632,66 @@ static void draw_minor_ticks(FM *p, PlotAxis *s)
          double subinterval = (next_loc - loc) / nsub;
          if (subinterval <= 0.0) continue;
          for (j = 1; j < nsub; j++) {
-            double subloc = loc + ((!s->log_values) ? (j * subinterval) : log_subintervals[j-1]);
+            double subloc = loc + ((!s->log_vals) ? (j * subinterval) : log_subintervals[j-1]);
             if (subloc >= next_loc) break;
             if (subloc <= s->axis_min || subloc >= s->axis_max) continue;
             if (s->vertical)
-               figure_join(p, s->x0+inside, subloc, s->x0+outside, subloc);
+               figure_join(fmkr, p, s->x0+inside, subloc, s->x0+outside, subloc, ierr);
             else
-               figure_join(p, subloc, s->y0+inside, subloc, s->y0+outside);
+               figure_join(fmkr, p, subloc, s->y0+inside, subloc, s->y0+outside, ierr);
             did_line = true;
+            if (*ierr != 0) return;
          }
       }
    }
-   if (did_line) axis_stroke(p);
+   if (did_line) axis_stroke(fmkr,p, ierr);
 }
 
-static void show_numeric_label(FM *p , VALUE fmkr, PlotAxis *s, char *text, int location, double position, double shift)
+static void show_numeric_label(OBJ_PTR fmkr, FM *p, PlotAxis *s, 
+   char *text, int location, double position, double shift, int *ierr)
 { // position is in figure coords and must be converted to frame coords
    double pos = ((!s->reversed)? (position - s->axis_min) : (s->axis_max - position)) / s->length;
-   c_show_rotated_text(p, text, location, shift, pos, 
-      s->numeric_label_scale, s->numeric_label_angle, s->numeric_label_justification, s->numeric_label_alignment);
+   c_show_rotated_text(fmkr, p, text, location, shift, pos, 
+		       s->numeric_label_scale, s->numeric_label_angle, s->numeric_label_justification, s->numeric_label_alignment, OBJ_NIL, ierr);
 }
 
-static void draw_numeric_labels(FM *p , VALUE fmkr, int location, PlotAxis *s)
+static void draw_numeric_labels(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s, int *ierr)
 {
    int i;
    double shift = (s->ticks_outside) ? s->major_tick_length : 0.5; // default shift
    shift += s->numeric_label_shift;
-   s->labels = Get_Labels(p, s);
+   s->labels = Get_Labels(fmkr, p, s, ierr);
    for (i=0; i < s->nmajors; i++) {
-      if (s->labels[i] != NULL) show_numeric_label(p, fmkr, s, s->labels[i], location, s->majors[i], shift);
+      if (s->labels[i] != NULL) {
+         show_numeric_label(fmkr, p, s, s->labels[i], location, s->majors[i], shift, ierr);
+         if (*ierr != 0) return;
+      }
    }
 }
 
-static void c_show_side(VALUE fmkr, FM *p, PlotAxis *s) {
+static void c_show_side(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr) {
    int i;
    if (s->type == AXIS_HIDDEN) return;
-   Start_Axis_Standard_State(p, s->stroke_color, s->line_width * p->default_line_scale);
-      // gsave, set line type and stroke color
-   draw_axis_line(p, s->location, s);
+   Start_Axis_Standard_State(fmkr, p, 
+      s->stroke_color_R, s->stroke_color_G, s->stroke_color_B, 
+      s->line_width * p->default_line_scale, ierr);
+   if (*ierr != 0) return;
+   draw_axis_line(fmkr, p, s->location, s, ierr);
+   if (*ierr != 0) return;
    if (s->type == AXIS_LINE_ONLY) goto done;
-   draw_major_ticks(p, s);
+   draw_major_ticks(fmkr, p, s, ierr);
+   if (*ierr != 0) return;
    if (s->type == AXIS_WITH_MAJOR_TICKS_ONLY) goto done;
    if (s->type == AXIS_WITH_MAJOR_TICKS_AND_NUMERIC_LABELS) {
-      draw_numeric_labels(p, fmkr, s->location, s);
+      draw_numeric_labels(fmkr, p, s->location, s, ierr);
+      if (*ierr != 0) return;
       goto done;
    }
-   draw_minor_ticks(p, s);
+   draw_minor_ticks(fmkr, p, s, ierr);
+   if (*ierr != 0) return;
    if (s->type == AXIS_WITH_TICKS_ONLY) goto done;
-   draw_numeric_labels(p, fmkr, s->location, s);
+   draw_numeric_labels(fmkr, p, s->location, s, ierr);
+   if (*ierr != 0) return;
  done:
    End_Axis_Standard_State(); // grestore
    if (s->free_majors) free(s->majors);
@@ -658,128 +704,95 @@ static void c_show_side(VALUE fmkr, FM *p, PlotAxis *s) {
    }
 }
 
-VALUE FM_show_axis(VALUE fmkr, VALUE loc)
+
+void c_show_axis(OBJ_PTR fmkr, FM *p, int location, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    PlotAxis axis;
-   int location;
-   Init_PlotAxis_struct(&axis);
-   loc = rb_Integer(loc);
-   location = NUM2INT(loc);
    if (location == LEFT || location == RIGHT || location == AT_X_ORIGIN) {
-      if (!p->yaxis_visible) goto done;
-      Get_yaxis_Specs(p, &axis);
+      if (!p->yaxis_visible) return;
+      Get_yaxis_Specs(fmkr, p, &axis, ierr);
    } else if (location == TOP || location == BOTTOM || location == AT_Y_ORIGIN) {
-      if (!p->xaxis_visible) goto done;
-      Get_xaxis_Specs(p, &axis);
-   } else rb_raise(rb_eArgError,
-         "Sorry: invalid 'loc' for axis: must be one of LEFT, RIGHT, TOP, BOTTOM, AT_X_ORIGIN, or AT_Y_ORIGIN: is (%i)", location);
+      if (!p->xaxis_visible) return;
+      Get_xaxis_Specs(fmkr, p, &axis, ierr);
+   } else RAISE_ERROR_i(
+         "Sorry: invalid 'loc' for axis: must be one of LEFT, RIGHT, TOP, BOTTOM, AT_X_ORIGIN, or AT_Y_ORIGIN: is (%i)", location, ierr);
+   if (*ierr != 0) return;
    axis.location = location;
-   c_show_side(fmkr, p, &axis);
- done:
-   return fmkr;
+   c_show_side(fmkr, p, &axis, ierr);
 }
       
-VALUE FM_show_edge(VALUE fmkr, VALUE loc) {
-   FM *p = Get_FM(fmkr);
+void c_show_edge(OBJ_PTR fmkr, FM *p, int location, int *ierr)
+{
    PlotAxis axis;
-   int location;
-   Init_PlotAxis_struct(&axis);
-   loc = rb_Integer(loc);
-   location = NUM2INT(loc);
    switch (location) {
       case LEFT:
-         if (!p->left_edge_visible) goto done;
-         Get_yaxis_Specs(p, &axis); axis.type = p->left_edge_type;
+         if (!p->left_edge_visible) return;
+         Get_yaxis_Specs(fmkr, p, &axis, ierr); axis.type = p->left_edge_type;
          break;
       case RIGHT:
-         if (!p->right_edge_visible) goto done;
-         Get_yaxis_Specs(p, &axis); axis.type = p->right_edge_type;
+         if (!p->right_edge_visible) return;
+         Get_yaxis_Specs(fmkr, p, &axis, ierr); axis.type = p->right_edge_type;
          break;
       case BOTTOM:
-         if (!p->bottom_edge_visible) goto done;
-         Get_xaxis_Specs(p, &axis); axis.type = p->bottom_edge_type;
+         if (!p->bottom_edge_visible) return;
+         Get_xaxis_Specs(fmkr, p, &axis, ierr); axis.type = p->bottom_edge_type;
          break;
       case TOP:
-         if (!p->top_edge_visible) goto done;
-         Get_xaxis_Specs(p, &axis); axis.type = p->top_edge_type;
+         if (!p->top_edge_visible) return;
+         Get_xaxis_Specs(fmkr, p, &axis, ierr); axis.type = p->top_edge_type;
          break;
-      default: rb_raise(rb_eArgError,
-         "Sorry: invalid 'loc' for edge: must be one of LEFT, RIGHT, TOP, or BOTTOM: is (%i)", location);
+      default: 
+         RAISE_ERROR_i(
+            "Sorry: invalid 'loc' for edge: must be one of LEFT, RIGHT, TOP, or BOTTOM: is (%i)", location, ierr);
    }
+   if (*ierr != 0) return;
    axis.location = location;
-   c_show_side(fmkr, p, &axis);
- done:
-   return fmkr;
+   c_show_side(fmkr, p, &axis, ierr);
 }
 
 
-VALUE FM_no_title(VALUE fmkr)
+void c_no_title(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->title_visible = false;
-   return fmkr;
 }
 
-VALUE FM_no_xlabel(VALUE fmkr)
+void c_no_xlabel(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->xlabel_visible = false;
-   return fmkr;
 }
 
-
-VALUE FM_no_ylabel(VALUE fmkr)
+void c_no_ylabel(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->ylabel_visible = false;
-   return fmkr;
 }
 
-
-VALUE FM_no_xaxis(VALUE fmkr)
+void c_no_xaxis(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->xaxis_visible = false;
-   return fmkr;
 }
 
-
-VALUE FM_no_yaxis(VALUE fmkr)
+void c_no_yaxis(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->yaxis_visible = false;
-   return fmkr;
 }
 
-
-VALUE FM_no_left_edge(VALUE fmkr)
+void c_no_left_edge(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->left_edge_visible = false;
-   return fmkr;
 }
 
-
-VALUE FM_no_right_edge(VALUE fmkr)
+void c_no_right_edge(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->right_edge_visible = false;
-   return fmkr;
 }
 
-
-VALUE FM_no_top_edge(VALUE fmkr)
+void c_no_top_edge(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->top_edge_visible = false;
-   return fmkr;
 }
 
-VALUE FM_no_bottom_edge(VALUE fmkr)
+void c_no_bottom_edge(OBJ_PTR fmkr, FM *p, int *ierr)
 {
-   FM *p = Get_FM(fmkr);
    p->bottom_edge_visible = false;
-   return fmkr;
 }