\def\MPLIB{MPlib} \def\MP{MetaPost} \def\POSTSCRIPT{PostScript} \def\PS{PostScript} \def\SVG{SVG} \def\PNG{PNG} \def\MNG{MNG} \def\TFM{{\sc tfm}} \def\LUA{Lua} \def\luatex#1{#1} \setupinteraction[state=start] % don't forget this line! \placebookmarks[section,subsection,subsubsection][section] % \setupinteractionscreen[option=bookmark] \definefontsynonym[TitleFont][Sans] \definefontsynonym[SubTitleFont][Sans] \def\StartTitlePage% {\bgroup%\startstandardmakeup \setupalign[middle] \hbox{}\vfil \let\\=\crlf} \def\StopTitlePage% {\vfil \page\egroup%\stopstandardmakeup } \usetypescript[palatino] \switchtobodyfont[palatino,10pt] \nonknuthmode \defineselector[title][max=2,n=2] \def\ctypedef#1#2#3{\subsubsection[#2]{\select{title}{\type{#2}}{\type{#1#2#3}}}\bookmark{#2}} \def\cenumeration#1{\subsubsection{\type{#1}}\bookmark{#1}} \def\cfunction#1#2#3{\subsubsection[#2]{\select{title}{\type{#2}}{\type{#1 #2#3}}}\bookmark{#2}} \starttext \StartTitlePage \centerline{\definedfont[TitleFont at 50pt]{\MPLIB}} \blank[3*line] \centerline{\definedfont[SubTitleFont at 24pt]{API documentation, version 2.00}} \blank[3*line] \centerline{Taco Hoekwater, September 2012 -- Luigi Scarso, February 2018} \StopTitlePage \section{Table of contents} \setupselector[title][n=1] \placecontent[criterium=all,level=subsection] \setupselector[title][n=2] \page \section{Introduction} This document describes the API to \MPLIB, allowing you to use \MPLIB\ in your own applications. One such application is writing bindings to interface with other programming languages. The bindings to the \LUA\ scripting language is part of the \MPLIB\ distribution and also covered by this manual. This is a first draft of both this document as well as the API, so there may be errors or omissions in this document or strangenesses in the API. If you believe something can be improved, please do not hesitate to let us know. The contact email address is {\tt metapost@tug.org}. The C paragraphs in this document assume you understand C code, the Lua paragraphs assume you understand Lua code, and familiarity with \MP\ is assumed throughout. \subsection{Simple \MPLIB\ use} There are two different approaches possible when running \MPLIB. The first method is most suitable for programs that function as a command-line frontend. It uses \quote{normal} \MP\ interface with I/O to and from files, and needs very little setup to run. On the other hand, it also gives almost no chance to control the \MPLIB\ behaviour. Here is a C language example of how to do this: \starttyping #include "mplib.h" int main (int argc, char **argv) { MP mp; MP_options *opt = mp_options(); opt->command_line = argv[1]; mp = mp_initialize(opt); if (mp) { int history = mp_run(mp); mp_finish(mp); exit (history); } else { exit (EXIT_FAILURE); } } \stoptyping This example will run in \quote{inimpost} mode. See below for how to preload a macro package. \subsection{Embedded \MPLIB\ use} The second method does not run a file, but instead repeatedly executes chunks of \MP\ language input that are passed to the library as strings, with the output redirected to internal buffers instead of directly to files. Here is an example of how this second approach works, now using the \LUA\ bindings: \starttyping local mplib = require('mplib') local mp = mplib.new ({ ini_version = false, mem_name = 'plain' }) if mp then local l = mp:execute([[beginfig(1); fill fullcircle scaled 20; endfig; ]]) if l and l.fig and l.fig[1] then print (l.fig[1]:postscript()) end mp:finish(); end \stoptyping This example preloads the \quote{plain} macro file. \section{C API for core \MPLIB} All of the types, structures, enumerations and functions that are described in this section are defined in the header file \type{mplib.h}. \subsection{Structures} \ctypedef{}{MP_options}{} This is a structure that contains the configurable parameters for a new \MPLIB\ instance. Because \MP\ differentiates between \type{-ini} and \type{non-ini} modes, there are three types of settings: Those that apply in both cases, and those that apply in only one of those cases. \starttabulate[|l|l|l|p|] \NC int \NC ini_version \NC 1 \NC set this to zero if you want to load a mem file.\NC \NR \NC int \NC error_line \NC 79 \NC maximal length of error message lines\NC \NR \NC int \NC half_error_line \NC 50 \NC halfway break point for error contexts\NC\NR \NC int \NC max_print_line \NC 100 \NC maximal length of file output\NC \NR \NC void * \NC userdata \NC NULL \NC for your personal use only, not used by the library\NC \NR \NC char * \NC banner \NC NULL \NC string to use instead of default banner\NC \NR \NC int \NC print_found_names\NC 0 \NC controls whether the asked name or the actual found name of the file is used in messages\NC \NR \NC int \NC file_line_error_style\NC 0 \NC when this option is nonzero, the library will use \type{file:line:error} style formatting for error messages that occur while reading from input files\NC \NR \NC char * \NC command_line \NC NULL \NC input file name and rest of command line; only used by \type{mp_run} interface\NC \NR \NC int \NC interaction \NC 0 \NC explicit \type{mp_interaction_mode} (see below)\NC \NR \NC int \NC noninteractive \NC 0 \NC set this nonzero to suppress user interaction, only sensible if you want to use \type{mp_execute}\NC \NR \NC int \NC random_seed \NC 0 \NC set this nonzero to force a specific random seed\NC \NR \NC int \NC troff_mode \NC 0 \NC set this nonzero to initialize \quote{troffmode} \NC \NR \NC char * \NC mem_name \NC NULL \NC explicit mem name to use instead of \type{plain.mem}. ignored in \type{-ini} mode.\NC \NR \NC char * \NC job_name \NC NULL \NC explicit job name to use instead of first input file\NC \NR \NC mp_file_finder \NC find_file \NC NULL \NC function called for finding files \NC \NR \NC mp_editor_cmd \NC run_editor \NC NULL \NC function called after \quote{E} error response\NC \NR \NC mp_makempx_cmd \NC run_make_mpx \NC NULL \NC function called for the creation of mpx files\NC \NR \NC int \NC math_mode \NC 0 \NC set this to \type{mp_math_double_mode} to use doubles instead of scaled (\type{mp_math_scaled_mode}) values\NC \NR \stoptabulate To create an \type{MP_options} structure, you have to use the \type{mp_options()} function. \ctypedef{}{MP}{} This type is an opaque pointer to a \MPLIB\ instance, it is what you have pass along as the first argument to (almost) all the \MPLIB\ functions. The actual C structure it points to has hundreds of fields, but you should not use any of those directly. All configuration is done via the \type{MP_options} structure, and there are accessor functions for the fields that can be read out. \ctypedef{}{mp_run_data}{} When the \MPLIB\ instance is not interactive, any output is redirected to this structure. There are a few string output streams, and a linked list of output images. \starttabulate[|l|l|p|] \NC mp_stream \NC term_out \NC holds the terminal output \NC \NR \NC mp_stream \NC error_out \NC holds error messages \NC \NR \NC mp_stream \NC log_out \NC holds the log output \NC \NR \NC mp_stream \NC ship_out \NC holds the exported EPS, SVG or PNG string \NC \NR \NC mp_edge_object *\NC edges \NC linked list of generated pictures \NC \NR \stoptabulate \type{term_out} is equivalent to \type{stdout} in interactive use, and \type{error_out} is equivalent to \type{stderr}. The \type{error_out} is currently only used for memory allocation errors, the \MP\ error messages are written to \type{term_out} (and are often duplicated to \type{log_out} as well). You need to include at least \type{mplibps.h} to be able to actually make use of this list of images, see the next section for the details on \type{mp_edge_object} lists. See next paragraph for \type{mp_stream}. \ctypedef{}{mp_stream}{} This contains the data for a stream as well as some internal bookkeeping variables. The fields that are of interest to you are: \starttabulate[|l|l|p|] \NC size_t \NC size \NC the internal buffer size\NC \NR \NC char * \NC data \NC the actual data. \NC \NR \stoptabulate There is nothing in the stream unless the \type{size} field is nonzero. There will not be embedded null characters (\type{\0}) in \type{data} except when \type{ship_out} is used for PNG output. If \type{size} is nonzero, \type{strlen(data)} is guaranteed to be less than that, and may be as low as zero (if \MPLIB\ has written an empty string). \subsection{Function prototype typedefs} The following three function prototypes define functions that you can pass to \MPLIB\ inside the \type{MP_options} structure. \ctypedef{char * }{(*mp_file_finder)}{ (MP, const char*, const char*, int)} \MPLIB\ calls this function whenever it needs to find a file. If you do not set up the matching option field (\type{MP_options.find_file}), \MPLIB\ will only be able to find files in the current directory. The three function arguments are the requested file name, the file mode (either \type{"r"} or \type{"w"}), and the file type (an \type{mp_filetype}, see below). The return value is a new string indicating the disk file name to be used, or NULL if the named file can not be found. If the mode is \type{"w"}, it is usually best to simply return a copy of the first argument. \ctypedef{void }{(*mp_editor_cmd)}{(MP, char*, int)} This function is executed when a user has pressed \quote{E} as reply to an \MP\ error, so it will only ever be called when \MPLIB\ in interactive mode. The function arguments are the file name and the line number. When this function is called, any open files are already closed. \ctypedef{int }{(*mp_makempx_cmd)}{(MP, char*, char *)} This function is executed when there is a need to start generating an \type{mpx} file because (the first time a \type{btex} command was encountered in the current input file). The first argument is the input file name. This is the name that was given in the \MP\ language, so it may not be the same as the name of the actual file that is being used, depending on how your \type{mp_file_finder} function behaves. The second argument is the requested output name for mpx commands. A zero return value indicates success, everything else indicates failure to create a proper \type{mpx} file and will result in an \MP\ error. \subsection{Enumerations} \cenumeration{mp_filetype} The \type{mp_file_finder} receives an \type{int} argument that is one of the following types: \starttabulate[|l|p|] \NC mp_filetype_program \NC Metapost language code (r)\NC \NR \NC mp_filetype_log \NC Log output (w)\NC \NR \NC mp_filetype_postscript \NC PostScript or SVG output (w)\NC \NR \NC mp_filetype_bitmap \NC PNG output (w)\NC \NR \NC mp_filetype_metrics \NC \TeX\ font metric file (r+w)\NC \NR \NC mp_filetype_fontmap \NC Font map file (r)\NC \NR \NC mp_filetype_font \NC Font PFB file (r)\NC \NR \NC mp_filetype_encoding \NC Font encoding file (r)\NC \NR \NC mp_filetype_text \NC \type{readfrom} and \type{write} files (r+w)\NC \NR \stoptabulate \cenumeration{mp_interaction_mode} When \type{noninteractive} is zero, \MPLIB\ normally starts in a mode where it reports every error, stops and asks the user for input. This initial mode can be overruled by using one of the following: \starttabulate[|l|p|] \NC mp_batch_mode \NC as with \type{batchmode} \NC \NR \NC mp_nonstop_mode \NC as with \type{nonstopmode} \NC \NR \NC mp_scroll_mode \NC as with \type{scrollmode} \NC \NR \NC mp_error_stop_mode \NC as with \type{errorstopmode} \NC \NR \stoptabulate \cenumeration{mp_math_mode} \starttabulate[|l|p|] \NC mp_math_scaled_mode \NC uses scaled point data for numerical values \NC \NR \NC mp_math_double_mode \NC uses IEEE double floating point data for numerical values \NC \NR \NC mp_math_binary_mode \NC not used yet. \NC \NR \NC mp_math_decimal_mode \NC not used yet. \NC \NR \stoptabulate \cenumeration{mp_history_state} These are set depending on the current state of the interpreter. \starttabulate[|l|p|] \NC mp_spotless \NC still clean as a whistle \NC \NR \NC mp_warning_issued \NC a warning was issued or something was \type{show}-ed \NC \NR \NC mp_error_message_issued \NC an error has been reported \NC \NR \NC mp_fatal_eror_stop \NC termination was premature due to error(s) \NC \NR \NC mp_system_error_stop \NC termination was premature due to disaster (out of system memory) \NC \NR \stoptabulate \cenumeration{mp_color_model} Graphical objects always have a color model attached to them. \starttabulate[|l|p|] \NC mp_no_model \NC as with \type{withoutcolor} \NC \NR \NC mp_grey_model \NC as with \type{withgreycolor} \NC \NR \NC mp_rgb_model \NC as with \type{withrgbcolor} \NC \NR \NC mp_cmyk_model \NC as with \type{withcmykcolor} \NC \NR \stoptabulate \cenumeration{mp_graphical_object_code} There are eight different graphical object types. \starttabulate[|l|p|] \NC mp_fill_code \NC \type{addto contour} \NC \NR \NC mp_stroked_code \NC \type{addto doublepath} \NC \NR \NC mp_text_code \NC \type{addto also} (via \type{infont})\NC \NR \NC mp_start_clip_code \NC \type{clip} \NC \NR \NC mp_start_bounds_code \NC \NC \NR \NC mp_stop_clip_code \NC \type{setbounds} \NC \NR \NC mp_stop_bounds_code \NC \NC \NR \NC mp_special_code \NC \type{special} \NC \NR \stoptabulate \subsection{Functions} \cfunction{char *}{mp_metapost_version}{(void)} Returns a copy of the \MPLIB\ version string. \cfunction{MP_options *}{mp_options}{(void)} Returns a properly initialized option structure, or \type{NULL} in case of allocation errors. \cfunction{MP }{mp_initialize}{(MP_options *opt)} Returns a pointer to a new \MPLIB\ instance, or \type{NULL} if initialisation failed. String options are copied, so you can free any of those (and the \type{opt} structure) immediately after the call to this function. \cfunction{int }{mp_status}{(MP mp)} Returns the current value of the interpreter error state, as a \type{mp_history_state}. This function is useful after \type{mp_initialize}. \cfunction{boolean }{mp_finished}{(MP mp)} Returns the current value of \type{mp->finished}. This function is useful to check if \type{mp_execute} will execute the string, because if \type{mp->finished} is \type{true} it will return after resetting the streams. \cfunction{int }{mp_run}{(MP mp)} Runs the \MPLIB\ instance using the \type{command_line} and other items from the \type{MP_options}. After the call to \type{mp_run}, the \MPLIB\ instance should be closed off by calling \type{mp_finish}. The return value is the current \type{mp_history_state} \cfunction{void *}{mp_userdata}{(MP mp)} Simply returns the pointer that was passed along as \type{userdata} in the \type{MP_options} struct. \cfunction{int }{mp_troff_mode}{(MP mp)} Returns the value of \type{troff_mode} as copied from the \type{MP_options} struct. \cfunction{mp_run_data *}{mp_rundata}{(MP mp)} Returns the information collected during the previous call to \type{mp_execute}. \cfunction{int }{mp_execute}{(MP mp, char *s, size_t l)} Executes string \type{s} with length \type{l} in the \MPLIB\ instance. This call can be repeated as often as is needed. The return value is the current \type{mp_history_state}. To get at the produced results, call \type {mp_rundata}. \cfunction{void }{mp_finish}{(MP mp)} This finishes off the use of the \MPLIB\ instance: it closes all files and frees all the memory allocated by this instance. \cfunction{double }{mp_get_char_dimension}{(MP mp,char*fname,int n,int t)} This is a helper function that returns one of the dimensions of glyph \type{n} in font \type{fname} as a double in PostScript (AFM) units. The requested item \type{t} can be \type{'w'} (width), \type{'h'} (height), or \type{'d'} (depth). \cfunction{int }{mp_memory_usage}{(MP mp)} Returns the current memory usage of this instance. \cfunction{int }{mp_hash_usage}{(MP mp)} Returns the current hash usage of this instance. \cfunction{int }{mp_param_usage}{(MP mp)} Returns the current simultaneous macro parameter usage of this instance. \cfunction{int }{mp_open_usage}{(MP mp)} Returns the current \type{input} levels of this instance. \section{C API for path and knot manipulation} \subsection{Enumerations} \cenumeration{mp_knot_type} Knots can have left and right types depending on their current status. By the time you see them in the output, they are usually either \type{mp_explicit} or \type{mp_endpoint}, but here is the full list: \starttabulate[|l|p|] \NC mp_endpoint \NC \NC \NR \NC mp_explicit \NC \NC \NR \NC mp_given \NC \NC \NR \NC mp_curl \NC \NC \NR \NC mp_open \NC \NC \NR \NC mp_end_cycle \NC \NC \NR \stoptabulate \cenumeration{mp_knot_originator} Knots can originate from two sources: they can be explicitly given by the user, or they can be created by the \MPLIB\ program code (for example as result of the \type{makepath} operator). \starttabulate[|l|p|] \NC mp_program_code \NC \NC \NR \NC mp_metapost_user \NC \NC \NR \stoptabulate \subsection{Structures} \ctypedef {}{mp_number}{} Numerical values are represented by opaque structure pointers named \type{mp_number}. \ctypedef {}{mp_knot}{} Each \MPLIB\ path (a sequence of \MP\ points) is represented as a linked list of structure pointers of the type \type{mp_knot}. \starttabulate[|l|l|p|] \NC mp_knot \NC next \NC the next knot, or NULL\NC \NR \NC mp_knot_type \NC data.types.left_type \NC the \type{mp_knot_type} for the left side \NC \NR \NC mp_knot_type \NC data.types.right_type \NC the \type{mp_knot_type} for the right side \NC \NR \NC mp_number \NC x_coord \NC $x$\NC \NR \NC mp_number \NC y_coord \NC $y$\NC \NR \NC mp_number \NC left_x \NC $x$ of the left (incoming) control point\NC \NR \NC mp_number \NC left_y \NC $y$ of the left (incoming) control point\NC \NR \NC mp_number \NC right_x \NC $x$ of the right (outgoing) control point\NC \NR \NC mp_number \NC right_y \NC $y$ of the right (outgoing) control point\NC \NR \NC mp_knot_originator \NC originator \NC the \type{mp_knot_originator} \NC \NR \stoptabulate Paths are always represented as a circular list. The difference between cyclic and non-cyclic paths is indicated by their \type{mp_knot_type}. While the fields of the knot structure are in fact accessible, it is better to use the access functions below as the internal structure tends to change. \subsection{Functions for accessing knot data} \cfunction{mp_number}{mp_knot_x_coord}{(MP mp,mp_knot p)} Access the $x$ coordinate of the knot. \cfunction{mp_number}{mp_knot_y_coord}{(MP mp,mp_knot p)} Access the $y$ coordinate of the knot. \cfunction{mp_number}{mp_knot_left_x}{(MP mp,mp_knot p)} Access the $x$ coordinate of the left control point of the knot. \cfunction{mp_number}{mp_knot_left_y}{(MP mp,mp_knot p)} Access the $y$ coordinate of the left control point of the knot. \cfunction{mp_number}{mp_knot_right_x}{(MP mp,mp_knot p)} Access the $x$ coordinate of the right control point of the knot. \cfunction{mp_number}{mp_knot_right_y}{(MP mp,mp_knot p)} Access the $y$ coordinate of the right control point of the knot. \cfunction{int}{mp_knot_left_type}{(MP mp,mp_knot p)} Access the type of the knot on the left side. \cfunction{int}{mp_knot_right_type}{(MP mp,mp_knot p)} Access the type of the knot on the right side. \cfunction{mp_knot}{mp_knot_next}{(MP mp,mp_knot p)} Access the pointer to the next knot. \cfunction{mp_number}{mp_knot_left_curl}{(MP mp,mp_knot p)} Access the left curl of the knot (applies to unresolved knots, see below). \cfunction{mp_number}{mp_knot_left_given}{(MP mp,mp_knot p)} Access the left given value of the knot (applies to unresolved knots, see below). \cfunction{mp_number}{mp_knot_left_tension}{(MP mp,mp_knot p)} Access the left tension of the knot (applies to unresolved knots, see below). \cfunction{mp_number}{mp_knot_right_curl}{(MP mp,mp_knot p)} Access the right curl value of the knot (applies to unresolved knots, see below). \cfunction{mp_number}{mp_knot_right_given}{(MP mp,mp_knot p)} Access the right given value of the knot (applies to unresolved knots, see below). \cfunction{mp_number}{mp_knot_right_tension}{(MP mp,mp_knot p)} Access the right tension value of the knot (applies to unresolved knots, see below). \cfunction{double}{mp_number_as_double}{(MP mp,mp_number n)} Converts an \type{mp_number} to \type{double}. \subsection{Functions for creating and modifying knot data} \cfunction{mp_knot}{mp_create_knot}{(MP mp)} Allocates and returns a new knot. Returns \type{NULL} on (malloc) failure. \cfunction{int}{mp_set_knot}{(MP mp,mp_knot p,double x,double y)} Fills in the coordinate of knot \type{p}. \type{x1} and \type{y1} values should be within the proper range for the current numerical mode. Return 1 on success, 0 on failure. \cfunction{int}{mp_close_path}{(MP mp,mp_knot p,mp_knot q)} Connects \type{p} and \type{q} using an \quote{endpoint join}, where \type{p} is the last knot of the path, and \type{q} is the first knot. The right tension of \type{p} and the left tension of \type{q} are (re)set to the default of 1.0. Because all knot list data structures are always circular, this is needed to end the path properly even if the path is not intended cyclic (or use \type{mp_close_path_cycle()}, if it is indeed a cycle). Return 1 on success, 0 on failure. \cfunction{int}{mp_close_path_cycle}{(MP mp,mp_knot p,mp_knot q)} Connects \type{p} and \type{q} using an \quote{open join}, where \type{p} is the last knot of the path, and \type{q} is the first knot. The right tension of \type{p} and the left tension of \type{q} are (re)set to the default of 1.0. This is needed to mimic metapost's \type{cycle}. return 1 on success, 0 on failure. \cfunction{mp_knot}{mp_append_knot}{(MP mp,mp_knot p,double x,double y)} Appends a knot to previous knot \type{q}, and returns the new knot. This is a convenience method combining \type{mp_create_knot()}, \type{mp_set_knot()}, and (if \type{q} is not NULL) \type{mp_close_path_cycle()}. Returns NULL on failure. \cfunction{int}{mp_set_knot_left_curl}{(MP mp,mp_knot q,double value)} Sets the left curl value for a knot. \type{fabs(value)} should be less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knot_right_curl}{(MP mp,mp_knot q,double value)} Sets the right curl value for a knot. \type{fabs(value)} should be less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knot_curl}{(MP mp,mp_knot q,double value)} Sets the curl value for a knot. \type{fabs(value)} should be less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knotpair_curls}{(MP mp,mp_knot p,mp_knot q,double t1,double t2)} A convenience method that calls \type{mp_set_knot_curl(mp,p,t1)} and \type{mp_set_knot_curl(mp,q,t2)} return 1 if both succeed, 0 otherwise. \cfunction{int}{mp_set_knot_direction}{(MP mp,mp_knot q,double x,double y)} Sets the direction \type{{x,y}} value for a knot. \type{fabs(x)} and \type{fabs(y)} should be less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knotpair_directions}{(MP mp,mp_knot p,mp_knot q,double x1,double y1,double x2,double y2)} A convenience method that calls \type{mp_set_knot_direction(mp,p,x1,y1)} and \type{mp_set_knot_direction(mp,p,x2,y2)} return 1 if both succeed, 0 otherwise. \cfunction{int}{mp_set_knotpair_tensions}{(MP mp,mp_knot p,mp_knot q,double t1,double t2)} Sets the tension specifiers for a pair of connected knots. \type{fabs(t1)} and \type{fabs(t2)} should be more than 0.75 and less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knot_left_tension}{(MP mp, mp_knot p, double t1)} Set the left tension of a knot. \type{fabs(t1)} should be more than 0.75 and less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knot_right_tension}{(MP mp, mp_knot p, double t1)} Set the right tension of a knot. \type{fabs(t1)} should be more than 0.75 and less than 4096.0 return 1 on success, 0 on failure. \cfunction{int}{mp_set_knot_left_control}{(MP mp, mp_knot p, double x1, double y1)} \cfunction{int}{mp_set_knot_right_control}{(MP mp, mp_knot p, double x1, double y1)} Sets explicit left or right control for a knot. \type{x1} and \type{y1} values should be within the proper range for the current numerical mode. return 1 on success, 0 on failure. \cfunction{int}{mp_set_knotpair_controls}{(MP mp,mp_knot p,mp_knot q,double x1,double y1,double x2,double y2)} Sets explicit controls for a knot pair. All four \type{x} and \type{y} values should be within the proper range for the current numerical mode. return 1 on success, 0 on failure. \cfunction{int}{mp_solve_path}{(MP mp,mp_knot first)} Finds explicit controls for the knot list at \type{first}, which is changed in-situ. Returns 0 if there was any kind of error, in which case \type{first} is unmodified. There can be quite a set of potential errors, mostly harmless processing errors. However, be aware that it is also possible that there are internal mplib memory allocation errors. A distinction between those can not be made at the moment. Return 1 on success, 0 on failure. \cfunction{void}{mp_free_path}{(MP mp,mp_knot p)} Frees the memory of a path. \subsection{Example usage} Since the above function list is quite dry and not that easy to grasp, here are two examples of how to use it. First a simple example (\type{mp_dump_path()} code is given below). \starttyping #include #include #include #include "mplib.h" int main (int argc, char ** argv) { MP mp ; mp_knot p, first, q; MP_options * opt = mp_options () ; opt -> command_line = NULL; opt -> noninteractive = 1 ; mp = mp_initialize ( opt ) ; if ( ! mp ) exit ( EXIT_FAILURE ) ; /* Equivalent Metapost code: path p; p := (0,0)..(10,10)..(10,-5)..cycle; */ first = p = mp_append_knot(mp,NULL,0,0); if ( ! p ) exit ( EXIT_FAILURE ) ; q = mp_append_knot(mp,p,10,10); if ( ! q ) exit ( EXIT_FAILURE ) ; p = mp_append_knot(mp,q,10,-5); if ( ! p ) exit ( EXIT_FAILURE ) ; mp_close_path_cycle(mp, p, first); /* mp_dump_path(mp, first); */ if (mp_solve_path(mp, first)) { /* mp_dump_path(mp, first); */ } mp_free_path(mp, first); mp_finish ( mp ) ; free(opt); return 0; } \stoptyping For some more challenging path input, here is a more elaborate example of the path processing code: \starttyping /* Equivalent Metapost code: path p; p := (0,0).. (2,20)-- (10, 5)..controls (2,2) and (9,4.5).. (3,10)..tension 3 and atleast 4 .. (1,14){2,0} .. {0,1}(5,-4); */ first = p = mp_append_knot(mp,NULL,0,0); q = mp_append_knot(mp,p,2,20); p = mp_append_knot(mp,q,10,5); if (!mp_set_knotpair_curls(mp, q,p, 1.0, 1.0)) exit ( EXIT_FAILURE ) ; q = mp_append_knot(mp,p,3,10); if (!mp_set_knotpair_controls(mp, p,q, 2.0, 2.0, 9.0, 4.5)) exit ( EXIT_FAILURE ) ; p = mp_append_knot(mp,q,1,14); if (!mp_set_knotpair_tensions(mp,q,p, 3.0, -4.0)) exit ( EXIT_FAILURE ) ; q = mp_append_knot(mp,p,5,-4); if (!mp_set_knotpair_directions(mp, p,q, 2.0, 0.0, 0.0, 1.0)) exit ( EXIT_FAILURE ) ; mp_close_path(mp, q, first); /* mp_dump_path(mp, first); */ if (mp_solve_path(mp, first)) { /* mp_dump_path(mp, first); */ } mp_free_path(mp, first); \stoptyping And here is the source code for the \type{mp_dump_path} function, which produces path output that is similar to Metapost's \type{tracingchoices} report. \starttyping #include #include #include #include #include "mplib.h" #define ROUNDED_ZERO(v) (fabs((v))<0.00001 ? 0 : (v)) #define PI 3.1415926535897932384626433832795028841971 #define RADIANS(a) (mp_number_as_double(mp,(a)) / 16.0) * PI/180.0 void mp_dump_path (MP mp, mp_knot h) { mp_knot p, q; if (h == NULL) return; p = h; do { q=mp_knot_next(mp,p); if ( (p==NULL)||(q==NULL) ) { printf("\n???"); return; /* this won't happen */ } printf ("(%g,%g)", mp_number_as_double(mp,mp_knot_x_coord(mp,p)), mp_number_as_double(mp,mp_knot_y_coord(mp,p))); switch (mp_knot_right_type(mp,p)) { case mp_endpoint: if ( mp_knot_left_type(mp,p)==mp_open ) printf("{open?}"); if ( (mp_knot_left_type(mp,q)!=mp_endpoint)||(q!=h) ) q=NULL; /* force an error */ goto DONE; break; case mp_explicit: printf ("..controls (%g,%g)", mp_number_as_double(mp,mp_knot_right_x(mp,p)), mp_number_as_double(mp,mp_knot_right_y(mp,p))); printf(" and "); if ( mp_knot_left_type(mp,q)!=mp_explicit ) { printf("??"); } else { printf ("(%g,%g)",mp_number_as_double(mp,mp_knot_left_x(mp,q)), mp_number_as_double(mp,mp_knot_left_y(mp,q))); } goto DONE; break; case mp_open: if ( (mp_knot_left_type(mp,p)!=mp_explicit) && (mp_knot_left_type(mp,p)!=mp_open) ) { printf("{open?}"); } break; case mp_curl: case mp_given: if ( mp_knot_left_type(mp,p)==mp_open ) printf("??"); if ( mp_knot_right_type(mp,p)==mp_curl ) { printf("{curl %g}", mp_number_as_double(mp,mp_knot_right_curl(mp,p))); } else { double rad = RADIANS(mp_knot_right_curl(mp,p)); double n_cos = ROUNDED_ZERO(cos(rad)*4096); double n_sin = ROUNDED_ZERO(sin(rad)*4096); printf("{%g,%g}", n_cos, n_sin); } break; } if ( mp_knot_left_type(mp,q)<=mp_explicit ) { printf("..control?"); /* can't happen */ } else if ((mp_number_as_double(mp,mp_knot_right_tension(mp,p))!=(1.0))|| (mp_number_as_double(mp,mp_knot_left_tension(mp,q)) !=(1.0))) { printf("..tension "); if ( mp_number_as_double(mp,mp_knot_right_tension(mp,p))<0.0 ) printf("atleast "); printf("%g", fabs(mp_number_as_double(mp,mp_knot_right_tension(mp,p)))); if (mp_number_as_double(mp,mp_knot_right_tension(mp,p)) != mp_number_as_double(mp,mp_knot_left_tension(mp,q))) { printf(" and "); if (mp_number_as_double(mp,mp_knot_left_tension(mp,q))< 0.0) printf("atleast "); printf("%g", fabs(mp_number_as_double(mp,mp_knot_left_tension(mp,q)))); } } DONE: p=q; if ( p!=h || mp_knot_left_type(mp,h)!=mp_endpoint) { printf ("\n .."); if ( mp_knot_left_type(mp,p) == mp_given ) { double rad = RADIANS(mp_knot_left_curl(mp,p)); double n_cos = ROUNDED_ZERO(cos(rad)*4096); double n_sin = ROUNDED_ZERO(sin(rad)*4096); printf("{%g,%g}", n_cos, n_sin); } else if ( mp_knot_left_type(mp,p) ==mp_curl ){ printf("{curl %g}", mp_number_as_double(mp,mp_knot_left_curl(mp,p))); } } } while (p!=h); if ( mp_knot_left_type(mp,h)!=mp_endpoint ) printf("cycle"); printf (";\n"); } \stoptyping The above function is much complicated because of all the knot type cases that can only happen {\it before} \type{mp_solve_path()} is called. A version that only prints processed paths and is less scared of using direct field access would be much shorter: \starttyping void mp_dump_solved_path (MP mp, mp_knot h) { mp_knot p, q; if (h == NULL) return; p = h; do { q=mp_knot_next(mp,p); printf ("(%g,%g)..controls (%g,%g) and (%g,%g)", mp_number_as_double(mp,p->x_coord), mp_number_as_double(mp,p->y_coord), mp_number_as_double(mp,p->right_x), mp_number_as_double(mp,p->right_y), mp_number_as_double(mp,q->left_x), mp_number_as_double(mp,q->left_y)); p=q; if ( p!=h || h->data.types.left_type!=mp_endpoint) { printf ("\n .."); } } while (p!=h); if ( h->data.types.left_type!=mp_endpoint ) printf("cycle"); printf (";\n"); } \stoptyping \page \section{C API for graphical backend functions} \bookmark{C API for graphical backend functions} These are all defined in \type{mplibps.h} \subsection{Structures} The structures in this section are used by the items in the body of the \type{edges} field of an \type{mp_rundata} structure. They are presented here in a bottom-up manner. \ctypedef {}{mp_gr_knot}{} These are like \type{mp_knot}, except that all \type{mp_number} values have been simplified to \type{double}. \ctypedef {}{mp_color}{} The graphical object that can be colored, have two fields to define the color: one for the color model and one for the color values. The structure for the color values is defined as follows: \starttabulate[|l|l|p|] \NC double \NC a_val \NC see below\NC \NR \NC double \NC b_val \NC --\NC \NR \NC double \NC c_val \NC --\NC \NR \NC double \NC d_val \NC --\NC \NR \stoptabulate All graphical objects that have \type{mp_color} fields also have \type{mp_color_model} fields. The color model decides the meaning of the four data fields: \starttabulate[|l|c|c|c|c|] \NC color model value \NC a_val \NC b_val \NC c_val \NC d_val \NC \FR \NC mp_no_model \NC -- \NC -- \NC -- \NC -- \NC \NR \NC mp_grey_model \NC grey \NC -- \NC -- \NC -- \NC \NR \NC mp_rgb_model \NC red \NC green \NC blue \NC \NC \NR \NC mp_cmyk_model \NC cyan \NC magenta \NC yellow\NC black \NC \NR \stoptabulate \ctypedef {}{mp_dash_object}{} Dash lists are represented like this: \starttabulate[|l|l|p|] \NC double * \NC array \NC an array of dash lengths, terminated by $-1$.\NC \NR \NC double \NC offset\NC the dash array offset (as in PostScript) \NC \NR \stoptabulate \ctypedef {}{mp_graphic_object}{} Now follow the structure definitions of the objects that can appear inside a figure (this is called an \quote{edge structure} in the internal WEB documentation). There are eight different graphical object types, but there are seven different C structures. Type \type{mp_graphic_object} represents the base line of graphical object types. It has only two fields: \starttabulate[|l|l|p|] \NC mp_graphical_object_code \NC type \NC \NC \NR \NC struct mp_graphic_object * \NC next \NC next object or NULL \NC \NR \stoptabulate Because every graphical object has at least these two fields, the body of a picture is represented as a linked list of \type{mp_graphic_object} items. Each object in turn can then be typecast to the proper type depending on its \type{type}. The two \quote{missing} objects in the explanations below are the ones that match \type{mp_stop_clip_code} and \type{mp_stop_bounds_code}: these have no extra fields besides \type{type} and \type{next}. \ctypedef {}{mp_fill_object}{} Contains the following fields on top of the ones defined by \type{mp_graphic_object}: \starttabulate[|l|l|p|] \NC char * \NC pre_script \NC this is the result of \type{withprescript} \NC \NR \NC char * \NC post_script \NC this is the result of \type{withpostscript}\NC \NR \NC mp_color \NC color \NC the color value of this object\NC \NR \NC mp_color_model \NC color_model \NC the color model\NC \NR \NC unsigned char \NC ljoin \NC the line join style; values have the same meaning as in \PS: 0 for mitered, 1 for round, 2 for beveled.\NC \NR \NC mp_gr_knot \NC path_p \NC the (always cyclic) path\NC \NR \NC mp_gr_knot \NC htap_p \NC a possible reversed path (see below)\NC \NR \NC mp_gr_knot \NC pen_p \NC a possible pen (see below)\NC \NR \NC double \NC miterlim \NC the miter limit\NC \NR \stoptabulate Even though this object is called an \type{mp_fill_object}, it can be the result of both \type{fill} and \type{filldraw} in the \MP\ input. This means that there can be a pen involved as well. The final output should behave as follows: \startitemize \item If there is no \type{pen_p}; simply fill \type{path_p}. \item If there is a one-knot pen (\type{pen_p->next} = \type{pen_p}) then fill \type{path_p} and also draw \type{path_p} with the \type{pen_p}. Do not forget to take \type{ljoin} and \type{miterlim} into account when drawing with the pen. \item If there is a more complex pen (\type{pen_p->next} != \type{pen_p}) then its path has already been preprocessed for you: \type{path_p} and \type{htap_p} already incorporate its shape. \stopitemize \ctypedef {}{mp_stroked_object}{} Contains the following fields on top of the ones defined by \type{mp_graphic_object}: \starttabulate[|l|l|p|] \NC char * \NC pre_script \NC this is the result of \type{withprescript} \NC \NR \NC char * \NC post_script \NC this is the result of \type{withpostscript} \NC \NR \NC mp_color \NC color \NC color value \NC \NR \NC mp_color_model \NC color_model \NC color model \NC \NR \NC unsigned char \NC ljoin \NC the line join style \NC \NR \NC unsigned char \NC lcap \NC the line cap style; values have the same meaning as in \PS: 0 for butt ends, 1 for round ends, 2 for projecting ends.\NC \NR \NC mp_gr_knot \NC path_p \NC the path \NC \NR \NC mp_gr_knot \NC pen_p \NC the pen \NC \NR \NC double \NC miterlim \NC miter limit \NC \NR \NC mp_dash_object * \NC dash_p \NC a possible dash list\NC \NR \stoptabulate \ctypedef {}{mp_text_object}{} Contains the following fields on top of the ones defined by \type{mp_graphic_object}: \starttabulate[|l|l|p|] \NC char * \NC pre_script \NC this is the result of \type{withprescript}\NC \NR \NC char * \NC post_script\NC this is the result of \type{withpostscript}\NC \NR \NC mp_color \NC color \NC color value \NC \NR \NC mp_color_model \NC color_model\NC color model \NC \NR \NC char * \NC text_p \NC string to be placed \NC \NR \NC char * \NC font_name \NC the \MP\ font name\NC \NR \NC double \NC font_dsize \NC size of the font\NC \NR \NC double \NC width \NC width of the picture resulting from the string\NC \NR \NC double \NC height \NC height\NC \NR \NC double \NC depth \NC depth\NC \NR \NC double \NC tx \NC transformation component\NC \NR \NC double \NC ty \NC transformation component\NC \NR \NC double \NC txx \NC transformation component\NC \NR \NC double \NC tyx \NC transformation component\NC \NR \NC double \NC txy \NC transformation component\NC \NR \NC double \NC tyy \NC transformation component\NC \NR \stoptabulate All fonts are loaded by \MPLIB\ at the design size (but not all fonts have the same design size). If text is to be scaled, this happens via the transformation components. \ctypedef {}{mp_clip_object}{} Contains the following field on top of the ones defined by \type{mp_graphic_object}: \starttabulate[|l|l|p|] \NC mp_gr_knot \NC path_p \NC defines the clipping path that is in effect until the object with the matching \type{mp_stop_clip_code} is encountered\NC \NR \stoptabulate \ctypedef {}{mp_bounds_object}{} Contains the following field on top of the ones defined by \type{mp_graphic_object}: \starttabulate[|l|l|p|] \NC mp_gr_knot \NC path_p \NC the path that was used for boundary calculation \NC \NR \stoptabulate This object can be ignored when output is generated, it only has effect on the boudingbox of the following objects and that has been taken into account already. \ctypedef {}{mp_special_object}{} This represents the output generated by a \MP\ \type{special} command. It contains the following field on top of the ones defined by \type{mp_graphic_object}: \starttabulate[|l|l|p|] \NC char *\NC pre_script \NC the special string\NC \NR \stoptabulate Each \type{special} command generates one object. All of the relevant \type{mp_special_object}s for a figure are linked together at the start of that figure. \ctypedef {}{mp_edge_object}{} \starttabulate[|l|l|p|] \NC mp_edge_object * \NC next \NC points to the next figure (or NULL)\NC \NR \NC mp_graphic_object * \NC body \NC a linked list of objects in this figure \NC \NR \NC char * \NC filename \NC this would have been the used filename if a \PS\ file would have been generated\NC \NR \NC MP \NC parent \NC a pointer to the instance that created this figure\NC \NR \NC double \NC minx \NC lower-left $x$ of the bounding box\NC \NR \NC double \NC miny \NC lower-left $y$ of the bounding box\NC \NR \NC double \NC maxx \NC upper right $x$ of the bounding box\NC \NR \NC double \NC maxy \NC upper right $y$ of the bounding box\NC \NR \NC double \NC width \NC value of \type{charwd}; this would become the \TFM\ width (but without the potential rounding correction for \TFM\ file format)\NC \NR \NC double \NC height \NC similar for height (\type{charht})\NC \NR \NC double \NC depth \NC similar for depth (\type{chardp})\NC \NR \NC double \NC ital_corr \NC similar for italic correction (\type{charic})\NC \NR \NC int \NC charcode \NC Value of \type{charcode} (rounded, but not modulated for \TFM's 256 values yet)\NC \NR \stoptabulate \subsection{Functions} \cfunction{int }{mp_ps_ship_out}{(mp_edge_object*hh,int prologues,int procset)} If you have an \type{mp_edge_object}, you can call this function. It will generate the \PS\ output for the figure and save it internally. A subsequent call to \type{mp_rundata} will find the generated text in the \type{ship_out} field. Returns zero for success. \cfunction{int }{mp_svg_ship_out}{(mp_edge_object*hh,int prologues)} If you have an \type{mp_edge_object}, you can call this function. It will generate the \SVG\ output for the figure and save it internally. A subsequent call to \type{mp_rundata} will find the generated text in the \type{ship_out} field. Returns zero for success. \cfunction{int }{mp_png_ship_out}{(mp_edge_object*hh, char *options)} If you have an \type{mp_edge_object}, you can call this function. It will generate the \PNG\ bitmap for the figure and save it internally. A subsequent call to \type{mp_rundata} will find the generated data in the \type{ship_out} field. Note: the \type{options} structure follows the same syntax as in the Metapost language, and can be NULL. Returns zero for success. \cfunction{void }{mp_gr_toss_objects}{(mp_edge_object*hh)} This frees a single \type{mp_edge_object} and its \type{mp_graphic_object} contents. \cfunction{void }{mp_gr_toss_object}{(mp_graphic_object*p)} This frees a single \type{mp_graphic_object} object. \cfunction{mp_graphic_object *}{mp_gr_copy_object}{(MP mp,mp_graphic_object*p)} This creates a deep copy of a \type{mp_graphic_object} object. \section{C API for label generation (a.k.a. makempx)} The following are all defined in \type{mpxout.h}. \subsection {Structures} \ctypedef {}{MPX}{} An opaque pointer that is passed on to the file_finder. \ctypedef {}{mpx_options}{} This structure holds the option fields for \type{mpx} generation. You have to fill in all fields except \type{mptexpre}, that one defaults to \type{mptexpre.tex} \starttabulate[|l|l|p|] \NC mpx_modes \NC mode \NC \NC \NR \NC char * \NC cmd \NC the command (or sequence of commands) to run\NC \NR \NC char * \NC mptexpre \NC prepended to the generated \TeX\ file\NC \NR \NC char * \NC mpname \NC input file name \NC \NR \NC char * \NC mpxname \NC output file name\NC \NR \NC char * \NC banner \NC string to be printed to the generated to-be-typeset file\NC \NR \NC int \NC debug \NC When nonzero, \type{mp_makempx} outputs some debug information and do not delete temp files\NC \NR \NC mpx_file_finder \NC find_file \NC \NC \NR \stoptabulate \subsection{Function prototype typedefs} \ctypedef{char * }{(*mpx_file_finder)}{ (MPX, const char*, const char*, int)} The return value is a new string indicating the disk file to be used. The arguments are the file name, the file mode (either \type{"r"} or \type{"w"}), and the file type (an \type{mpx_filetype}, see below). If the mode is \type{"w"}, it is usually best to simply return a copy of the first argument. \subsection{Enumerations} \cenumeration{mpx_modes} \starttabulate[|l|p|] \NC mpx_tex_mode \NC \NC \NR \NC mpx_troff_mode \NC \NC \NR \stoptabulate \cenumeration{mpx_filetype} \starttabulate[|l|p|] \NC mpx_tfm_format \NC \TeX\ or Troff ffont metric file \NC \NR \NC mpx_vf_format \NC \TeX\ virtual font file \NC \NR \NC mpx_trfontmap_format \NC Troff font map \NC \NR \NC mpx_trcharadj_format \NC Troff character shift information \NC \NR \NC mpx_desc_format \NC Troff DESC file \NC \NR \NC mpx_fontdesc_format \NC Troff FONTDESC file \NC \NR \NC mpx_specchar_format \NC Troff special character definition\NC \NR \stoptabulate \subsection{Functions} \cfunction{int }{mpx_makempx}{(mpx_options *mpxopt)} A return value of zero is success, non-zero values indicate errors. \page \section{Lua API} The \MP\ library interface registers itself in the table \type{mplib}. \subsection{\luatex{mplib.version}} Returns the \MPLIB\ version. \starttyping s = mplib.version() \stoptyping \subsection{\luatex{mplib.new}} To create a new metapost instance, call \starttyping mp = mplib.new({...}) \stoptyping This creates the \type{mp} instance object. The \type{mp} instance object always starts out in so|-|called \quote{inimp} mode, there is no support for preload files. The argument hash can have a number of different fields, as follows: \starttabulate[|lT|l|p|p|] \NC \ssbf name \NC \bf type \NC \bf description \NC \bf default \NC\NR \NC error_line \NC number \NC error line width \NC 79 \NC\NR \NC print_line \NC number \NC line length in ps output \NC 100\NC\NR \NC random_seed \NC number \NC the initial random seed \NC variable\NC\NR \NC interaction \NC string \NC the interaction mode, one of \type {batch}, \type {nonstop}, \type {scroll}, \type {errorstop} \NC \type {errorstop}\NC\NR \NC job_name \NC string \NC \type {--jobname} \NC \type {mpout} \NC\NR \NC math_mode \NC string \NC the number system mode, one of \type{scaled} or \type{double} \NC \type {scaled} \NC\NR \NC find_file \NC function \NC a function to find files \NC only local files\NC\NR \stoptabulate The \type{find_file} function should be of this form: \starttyping found = finder ( name, mode, type) \stoptyping with: \starttabulate[|lT|l|p|] \NC name \NC the requested file \NC \NR \NC mode \NC the file mode: \type {r} or \type {w} \NC \NR \NC type \NC the kind of file, one of: \type {mp}, \type {tfm}, \type {map}, \type {pfb}, \type {enc} \NC \NR \stoptabulate Return either the full pathname of the found file, or \type{nil} if the file cannot be found. \subsection{\luatex{mp:statistics}} You can request statistics with: \starttyping stats = mp:statistics() \stoptyping This function returns the allocation statistics for an \MPLIB\ instance. There are four fields, giving the maximum number of used items in each of four object classes: \starttabulate[|lT|l|p|] \NC memory \NC number \NC allocated memory (in bytes)\NC\NR \NC hash \NC number \NC hash size (in entries)\NC\NR \NC params \NC number \NC simultaneous macro parameters\NC\NR \NC open \NC number \NC input file nesting levels\NC\NR \stoptabulate \subsection{\luatex{mp:execute}} You can ask the \METAPOST\ interpreter to run a chunk of code by calling \starttyping local rettable = mp:execute('metapost language chunk') \stoptyping for various bits of Metapost language input. Be sure to check the \type{rettable.status} (see below) because when a fatal \METAPOST\ error occurs the \MPLIB\ instance will become unusable thereafter. Generally speaking, it is best to keep your chunks small, but beware that all chunks have to obey proper syntax, like each of them is a small file. For instance, you cannot split a single statement over multiple chunks. In contrast with the normal standalone \type{mpost} command, there is {\em no\/} implied \quote{input} at the start of the first chunk. \subsection{\luatex{mp:finish}} \starttyping local rettable = mp:finish() \stoptyping If for some reason you want to stop using an \MPLIB\ instance while processing is not yet actually done, you can call \type{mp:finish}. Eventually, used memory will be freed and open files will be closed by the \LUA\ garbage collector, but an explicit \type{mp:finish} is the only way to capture the final part of the output streams. \subsection{Result table} The return value of \type{mp:execute} and \type{mp:finish} is a table with a few possible keys (only \type {status} is always guaranteed to be present). \starttabulate[|l|l|p|] \NC log \NC string \NC output to the \quote {log} stream \NC \NR \NC term \NC string \NC output to the \quote {term} stream \NC \NR \NC error \NC string \NC output to the \quote {error} stream (only used for \quote {out of memory})\NC \NR \NC status \NC number \NC the return value: 0=good, 1=warning, 2=errors, 3=fatal error \NC \NR \NC fig \NC table \NC an array of generated figures (if any)\NC \NR \stoptabulate When \type{status} equals~3, you should stop using this \MPLIB\ instance immediately, it is no longer capable of processing input. If it is present, each of the entries in the \type{fig} array is a userdata representing a figure object, and each of those has a number of object methods you can call: \starttabulate[|l|l|p|] \NC boundingbox \NC function \NC returns the bounding box, as an array of 4 values\NC \NR \NC postscript \NC function \NC return a string that is the ps output of the \type{fig} \NC \NR \NC svg \NC function \NC return a string that is the svg output of the \type{fig} \NC \NR \NC png \NC function \NC return a string that is the png output of the \type{fig} \NC \NR \NC objects \NC function \NC returns the actual array of graphic objects in this \type{fig} \NC \NR \NC copy_objects \NC function \NC returns a deep copy of the array of graphic objects in this \type{fig} \NC \NR \NC filename \NC function \NC the filename this \type{fig}'s \POSTSCRIPT\ output would have written to in standalone mode\NC \NR \NC width \NC function \NC the \type{charwd} value \NC \NR \NC height \NC function \NC the \type{charht} value \NC \NR \NC depth \NC function \NC the \type{chardp} value \NC \NR \NC italcorr \NC function \NC the \type{charic} value \NC \NR \NC charcode \NC function \NC the (rounded) \type{charcode} value \NC \NR \stoptabulate {\bf NOTE:} you can call \type{fig:objects()} only once for any one \type{fig} object! When the boundingbox represents a \quote {negated rectangle}, i.e.\ when the first set of coordinates is larger than the second set, the picture is empty. Graphical objects come in various types that each have a different list of accessible values. The types are: \type{fill}, \type{outline}, \type{text}, \type{start_clip}, \type{stop_clip}, \type{start_bounds}, \type{stop_bounds}, \type{special}. There is helper function (\type{mplib.fields(obj)}) to get the list of accessible values for a particular object, but you can just as easily use the tables given below). All graphical objects have a field \type{type} that gives the object type as a string value, that not explicit mentioned in the tables. In the following, \type{number}s are \POSTSCRIPT\ points represented as a floating point number, unless stated otherwise. Field values that are of \type{table} are explained in the next section. \subsubsection{fill} \starttabulate[|l|l|p|] \NC path \NC table \NC the list of knots \NC \NR \NC htap \NC table \NC the list of knots for the reversed trajectory \NC \NR \NC pen \NC table \NC knots of the pen \NC \NR \NC color \NC table \NC the object's color \NC \NR \NC linejoin \NC number \NC line join style (bare number)\NC \NR \NC miterlimit \NC number \NC miter limit\NC \NR \NC prescript \NC string \NC the prescript text \NC \NR \NC postscript \NC string \NC the postscript text \NC \NR \stoptabulate The entries \type{htap} and \type{pen} are optional. There is helper function (\type{mplib.pen_info(obj)}) that returns a table containing a bunch of vital characteristics of the used pen (all values are floats): \starttabulate[|l|l|p|] \NC width \NC number \NC width of the pen\NC \NR \NC rx \NC number \NC $x$ scale \NC \NR \NC sx \NC number \NC $xy$ multiplier \NC \NR \NC sy \NC number \NC $yx$ multiplier \NC \NR \NC ry \NC number \NC $y$ scale \NC \NR \NC tx \NC number \NC $x$ offset \NC \NR \NC ty \NC number \NC $y$ offset \NC \NR \stoptabulate \subsubsection{outline} \starttabulate[|l|l|p|] \NC path \NC table \NC the list of knots \NC \NR \NC pen \NC table \NC knots of the pen \NC \NR \NC color \NC table \NC the object's color \NC \NR \NC linejoin \NC number \NC line join style (bare number)\NC \NR \NC miterlimit \NC number \NC miter limit \NC \NR \NC linecap \NC number \NC line cap style (bare number)\NC \NR \NC dash \NC table \NC representation of a dash list\NC \NR \NC prescript \NC string \NC the prescript text \NC \NR \NC postscript \NC string \NC the postscript text \NC \NR \stoptabulate The entry \type{dash} is optional. \subsubsection{text} \starttabulate[|l|l|p|] \NC text \NC string \NC the text \NC \NR \NC font \NC string \NC font tfm name \NC \NR \NC dsize \NC number \NC font size\NC \NR \NC color \NC table \NC the object's color \NC \NR \NC width \NC number \NC \NC \NR \NC height \NC number \NC \NC \NR \NC depth \NC number \NC \NC \NR \NC transform \NC table \NC a text transformation \NC \NR \NC prescript \NC string \NC the prescript text \NC \NR \NC postscript \NC string \NC the postscript text \NC \NR \stoptabulate \subsubsection{special} \starttabulate[|l|l|p|] \NC prescript \NC string \NC special text \NC \NR \stoptabulate \subsubsection{start_bounds, start_clip} \starttabulate[|l|l|p|] \NC path \NC table \NC the list of knots \NC \NR \stoptabulate \subsubsection{stop_bounds, stop_clip} Here are no fields available. \subsection{Subsidiary table formats} \subsubsection{Paths and pens} Paths and pens (that are really just a special type of paths as far as \MPLIB\ is concerned) are represented by an array where each entry is a table that represents a knot. \starttabulate[|lT|l|p|] \NC left_type \NC string \NC when present: 'endpoint', but ususally absent \NC \NR \NC right_type \NC string \NC like \type{left_type}\NC \NR \NC x_coord \NC number \NC $x$ coordinate of this knot\NC \NR \NC y_coord \NC number \NC $y$ coordinate of this knot\NC \NR \NC left_x \NC number \NC $x$ coordinate of the precontrol point of this knot\NC \NR \NC left_y \NC number \NC $y$ coordinate of the precontrol point of this knot\NC \NR \NC right_x \NC number \NC $x$ coordinate of the postcontrol point of this knot\NC \NR \NC right_y \NC number \NC $y$ coordinate of the postcontrol point of this knot\NC \NR \stoptabulate There is one special case: pens that are (possibly transformed) ellipses have an extra string-valued key \type{type} with value \type{elliptical} besides the array part containing the knot list. \subsubsection{Colors} A color is an integer array with 0, 1, 3 or 4 values: \starttabulate[|l|l|p|] \NC 0 \NC marking only \NC no values \NC\NR \NC 1 \NC greyscale \NC one value in the range (0,1), \quote {black} is 0 \NC\NR \NC 3 \NC RGB \NC three values in the range (0,1), \quote {black} is 0,0,0 \NC\NR \NC 4 \NC CMYK \NC four values in the range (0,1), \quote {black} is 0,0,0,1 \NC\NR \stoptabulate If the color model of the internal object was \type{unitialized}, then it was initialized to the values representing \quote {black} in the colorspace \type{defaultcolormodel} that was in effect at the time of the \type{shipout}. \subsubsection{Transforms} Each transform is a six-item array. \starttabulate[|l|l|p|] \NC 1 \NC number \NC represents x \NC\NR \NC 2 \NC number \NC represents y \NC\NR \NC 3 \NC number \NC represents xx \NC\NR \NC 4 \NC number \NC represents yx \NC\NR \NC 5 \NC number \NC represents xy \NC\NR \NC 6 \NC number \NC represents yy \NC\NR \stoptabulate Note that the translation (index 1 and 2) comes first. This differs from the ordering in \POSTSCRIPT, where the translation comes last. \subsubsection{Dashes} Each \type{dash} is two-item hash, using the same model as \POSTSCRIPT\ for the representation of the dashlist. \type{dashes} is an array of \quote {on} and \quote {off}, values, and \type{offset} is the phase of the pattern. \starttabulate[|l|l|p|] \NC dashes \NC hash \NC an array of on-off numbers \NC\NR \NC offset \NC number \NC the starting offset value \NC\NR \stoptabulate \subsection{Character size information} These functions find the size of a glyph in a defined font. The \type{fontname} is the same name as the argument to \type{infont}; the \type{char} is a glyph id in the range 0 to 255; the returned \type{w} is in AFM units. \subsubsection{\luatex{mp.char_width}} \starttyping w = mp.char_width( fontname, char) \stoptyping \subsubsection{\luatex{mp.char_height}} \starttyping w = mp.char_height( fontname, char) \stoptyping \subsubsection{\luatex{mp.char_depth}} \starttyping w = mp.char_depth( fontname, char) \stoptyping \subsection{Solving path control points} \starttyping success = mp.solve_path(
knots, cyclic) \stoptyping This modifies the \type{knots} table (which should contain an array of points in a path, with the substructure explained below) by filling in the control points. The boolean \type{cyclic} is used to determine whether the path should be the equivalent of \type{--cycle}. If the return value is \type{false}, there is an extra return argument containing the error string. On entry, the individual knot tables can contain the values mentioned above (but typically the \type{left_{x,y}} and \type{right_{x,y}} will be missing). \type{{x,y}_coord} are both required. Also, some extra values are allowed: \starttabulate[|lT|l|p|] \NC left_tension \NC number \NC A tension specifier \NC \NR \NC right_tension \NC number \NC like \type{left_tension}\NC \NR \NC left_curl \NC number \NC A curl specifier\NC \NR \NC right_curl \NC number \NC like \type{left_curl}\NC \NR \NC direction_x \NC number \NC $x$ displacement of a direction specifier\NC \NR \NC direction_y \NC number \NC $y$ displacement of a direction specifier\NC \NR \stoptabulate Note the following: \startitemize \item A knot has either a direction specifier, or a curl specifier, or a tension specification, or explicit control points, with the note that tensions, curls and control points are split in a left and a right side (directions apply to both sides equally). \item The absolute value of a tension specifier should be more than 0.75 and less than 4096.0, with negative values indicating \quote{\type{atleast}}. \item The absolute value of a direction or curl should be less than 4096.0. \item If a tension, curl, or direction is specified, then existing control points will be replaced by the newly computed value. \item Calling \type{solve_path} does not alter the used mplib instance. \stopitemize \stoptext