%% options copyright owner = Dirk Krause copyright year = 2017-xxxx SPDX-License-Identifier: BSD-3-Clause %% module #include "dk4conf.h" #if DK4_HAVE_MATH_H #ifndef MATH_H_INCLUDED #if DK4_ON_WINDOWS #ifndef _USE_MATH_DEFINES #define _USE_MATH_DEFINES 1 #endif #endif #include #define MATH_H_INCLUDED 1 #endif #endif #ifndef DK4MEM_H_INCLUDED #include "dk4mem.h" #endif #ifndef DK4ENC_H_INCLUDED #include "dk4enc.h" #endif #ifndef DK4REC25_H_INCLUDED #include "dk4rec25.h" #endif #ifndef DK4GRA_H_INCLUDED #include "dk4gra.h" #endif #ifndef GRA_H_INCLUDED #include "gra.h" #endif #ifndef DK4BIF_H_INCLUDED #include "dk4bif.h" #endif #ifndef DK4UFIC_H_INCLUDED #include "dk4ufic.h" #endif #ifndef DK4STRD_H_INCLUDED #include "dk4strd.h" #endif #ifndef DK4STRMF_H_INCLUDED #include "dk4strmf.h" #endif #ifndef DK4UNUSED_H_INCLUDED #include "dk4unused.h" #endif #ifndef DK4UFI_H_INCLUDED #include "dk4ufi.h" #endif #ifndef DK4MAO8D_H_INCLUDED #include "dk4mao8d.h" #endif #ifndef DK4LOC_H_INCLUDED #include "dk4loc.h" #endif #ifndef DK4MPL_H_INCLUDED #include "dk4mpl.h" #endif #ifndef DK4FONTC_H_INCLUDED #include "dk4fontc.h" #endif #if DK4_HAVE_ASSERT_H #ifndef ASSERT_H_INCLUDED #include #define ASSERT_H_INCLUDED 1 #endif #endif $!trace-include /** Constant text fragments for PGF output. */ static const char * const dk4gra_pgf_kw[] = { $!string-table # # 0 Simple newline # \n # # 1 2 Begin and end PGF scope # \\begin{pgfscope}\n \\end{pgfscope}\n # # 3 Comma # , # # 4 11 Color definitions # \\definecolor{PPPTcs}{gray}{ \\definecolor{PPPTcn}{gray}{ \\definecolor{PPPTcs}{rgb}{ \\definecolor{PPPTcn}{rgb}{ \\definecolor{PPPTcs}{cmyk}{ \\definecolor{PPPTcn}{cmyk}{ }\\pgfsetstrokecolor{PPPTcs}\n }\\pgfsetfillcolor{PPPTcn}\n # # 12 13 Line width # \\pgfsetlinewidth{ bp}\n # # 14 17 Dash # \\pgfsetdash{ }{ { bp} # # 18 20 Line cap # \\pgfsetbuttcap\n \\pgfsetroundcap\n \\pgfsetrectcap\n # # 21 25 Line join # \\pgfsetroundjoin\n \\pgfsetbeveljoin\n \\pgfsetmiterjoin\n \\pgfsetmiterlimit{ }\n # # 26 30 Path usage # \\pgfusepath{fill}\n \\pgfusepath{stroke}\n \\pgfusepath{fill,stroke}\n \\pgfusepath{clip}\n \\pgfusepath{use as bounding box}\n # # 31 34 Path operations # \\pgfpathmoveto{\\pgfpoint{ \\pgfpathlineto{\\pgfpoint{ bp}{ bp}}\n # # 35 36 Curves # \\pgfpathcurveto{\\pgfpoint{ bp}}{\\pgfpoint{ # # 37 Closepath # \\pgfpathclose\n # # 38 39 Circle # \\pgfpathcircle{\\pgfpoint{ bp}}{ # # 40 Open TeX scope # {\n # # 41 Arced corners # \\pgfsetcornersarced{\\pgfpoint{ # # 42 Rectangle by corners # \\pgfpathrectanglecorners{\\pgfpoint{ # # 43 clearpage # \\clearpage\n # # 44-45 begin and end picture # \\begin{pgfpicture}\n \\end{pgfpicture}%\n # # 46 Path rectangle # \\pgfpathrectangle{\\pgfpointorigin}{\\pgfpoint{ # # 47-48 Filling ruls # \\pgfseteorule\n \\pgfsetnonzerorule\n # # 49-60 pgftext instructions with alignment # \\pgftext[top,at={\\pgfpoint{ \\pgftext[top,right,at={\\pgfpoint{ \\pgftext[top,left,at={\\pgfpoint{ \\pgftext[at={\\pgfpoint{ \\pgftext[right,at={\\pgfpoint{ \\pgftext[left,at={\\pgfpoint{ \\pgftext[bottom,at={\\pgfpoint{ \\pgftext[bottom,right,at={\\pgfpoint{ \\pgftext[bottom,left,at={\\pgfpoint{ \\pgftext[base,at={\\pgfpoint{ \\pgftext[base,right,at={\\pgfpoint{ \\pgftext[base,left,at={\\pgfpoint{ # # 61-65 # bp}} \\smash{ } }} { # # 66-70 Image declaration # \\pgfdeclareimage[width=1bp,height=1bp ,interpolate=true ]{PPPTim }{ }%\n # # 71 Set fill color for background filling # \\definecolor{PPPTcn}{gray}{1}\\pgfsetfillcolor{PPPTcn}\n # # 72 Start font name # \\PPPTfo # # 73 Mark font as command # {} # # 74 Open white colorbox # \\colorbox{white}{ # # 75 Open oval box # \\ovalbox{ # # 76 (formerly end of 61) # ]{ # # 77 Rotation # ,rotate= $!end }; /** Compare page structures by number or a page against a number. @param l Left page object. @param r Right page object or page number. @param cr Comparison criteria (0=page/page, 1=page/number). @return Comparison result. */ static int dk4gra_pgf_compare_pages_by_number(const void *l, const void *r, int cr) { const dk4_gra_pgf_page_t *pl; const dk4_gra_pgf_page_t *pr; const size_t *ppno; int back = 0; if (NULL != l) { if (NULL != r) { pl = (const dk4_gra_pgf_page_t *)l; switch (cr) { case 1: { ppno = (const size_t *)r; if (pl->pageno > *ppno) { back = 1; } else { if (pl->pageno < *ppno) { back = -1; } } } break; default : { pr = (const dk4_gra_pgf_page_t *)r; if (pl->pageno > pr->pageno) { back = 1; } else { if (pl->pageno < pr->pageno) { back = -1; } } } break; } } else { back = 1; } } else { if (NULL != r) { back = -1; } } return back; } /** Compare images by UFI (if available) or name. @param l Left image record. @param r Right image record. @param cr Comparison criteria (ignored). */ static int dk4gra_pgf_compare_images_by_ufi_and_name( const void *l, const void *r, int DK4_ARG_UNUSED(cr) ) { const dk4_gra_pgf_img_no_t *pl; const dk4_gra_pgf_img_no_t *pr; int back = 0; DK4_UNUSED_ARG(cr) if (NULL != l) { if (NULL != r) { pl = (const dk4_gra_pgf_img_no_t *)l; pr = (const dk4_gra_pgf_img_no_t *)r; if (0 != pl->hufi) { if (0 != pr->hufi) { back = dk4ufi_compare(&(pl->ufi), &(pr->ufi)); } else { back = 1; } } else { if (0 != pr->hufi) { back = -1; } else { if (NULL != pl->fn) { if (NULL != pr->fn) { back = dk4str_pathcmp(pl->fn, pr->fn); } else { back = 1; } } else { if (NULL != pr->fn) { back = -1; } } } } } else { back = 1; } } else { if (NULL != r) { back = -1; } } return back; } /** Compare images by image number. @param l Left image record. @param r Right image record. @param cr Comparison criteria (ignored). */ static int dk4gra_pgf_compare_images_by_number( const void *l, const void *r, int DK4_ARG_UNUSED(cr) ) { const dk4_gra_pgf_img_no_t *pl; const dk4_gra_pgf_img_no_t *pr; int back = 0; DK4_UNUSED_ARG(cr) if (NULL != l) { if (NULL != r) { pl = (const dk4_gra_pgf_img_no_t *)l; pr = (const dk4_gra_pgf_img_no_t *)r; if (pl->imgno > pr->imgno) { back = 1; } else { if (pl->imgno < pr->imgno) { back = -1; } } } else { back = 1; } } else { if (NULL != r) { back = -1; } } return back; } /** Issue one keyword to stream. @param os Output stream to write to. @param kwi Keyword index in dk4gra_pgf_kw array. @param backptr Address of success variable, reset to 0 on error. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if str is NULL or the stream is not opened for writing, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed. */ static void dk4gra_pgf_stream_kw( dk4_stream_t *os, size_t kwi, int *backptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != os); #endif dk4gratool_stream_string(os, dk4gra_pgf_kw[kwi], backptr, erp); } /** Issue one keyword to the page memory stream. @param bptr Current page. @param kwi Keyword index in dk4gra_pgf_kw array. @param backptr Address of success variable, reset to 0 on error. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if str is NULL or the stream is not opened for writing, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed. */ static void dk4gra_pgf_page_kw( dk4_gra_pgf_page_t *bptr, size_t kwi, int *backptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != bptr); #endif dk4gra_pgf_stream_kw(bptr->memstrm, kwi, backptr, erp); } /** Change stroking or non-stroking color. @param os Output stream to write to. @param cactive Active color. @param crequested Requested color. @param fi Flag: Change fill (non-stroking) color. @param ptrback Address of success variable, reset to 0 on error. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if str is NULL or the stream is not opened for writing, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed, - DK4_E_MATH_OVERFLOW
if the exponent is out of range for integer values,
- DK4_E_SYNTAX
if input contains invalid characters. */ static void dk4gra_pgf_set_color_if_necessary( dk4_stream_t *os, dk4gra_col_t *cactive, dk4gra_col_t *crequested, int fi, int *ptrback, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != os); assert(NULL != cactive); assert(NULL != crequested); #endif if (dk4gratool_colors_differ(cactive, crequested)) { switch (crequested->what) { case DK4_GRA_COL_SPEC_GRAY : { dk4gra_pgf_stream_kw(os, ((0 != fi) ? 5 : 4), ptrback, erp); dk4gratool_stream_double( os, crequested->data.gray, ptrback, erp ); dk4gra_pgf_stream_kw(os, ((0 != fi) ? 11 : 10), ptrback, erp); } break; case DK4_GRA_COL_SPEC_CMYK : { dk4gra_pgf_stream_kw(os, ((0 != fi) ? 9 : 8), ptrback, erp); dk4gratool_stream_double( os, crequested->data.cmyk.c, ptrback, erp ); dk4gra_pgf_stream_kw(os, 3, ptrback, erp); dk4gratool_stream_double( os, crequested->data.cmyk.m, ptrback, erp ); dk4gra_pgf_stream_kw(os, 3, ptrback, erp); dk4gratool_stream_double( os, crequested->data.cmyk.y, ptrback, erp ); dk4gra_pgf_stream_kw(os, 3, ptrback, erp); dk4gratool_stream_double( os, crequested->data.cmyk.k, ptrback, erp ); dk4gra_pgf_stream_kw(os, ((0 != fi) ? 11 : 10), ptrback, erp); } break; default : { dk4gra_pgf_stream_kw(os, ((0 != fi) ? 7 : 6), ptrback, erp); dk4gratool_stream_double( os, crequested->data.rgb.r, ptrback, erp ); dk4gra_pgf_stream_kw(os, 3, ptrback, erp); dk4gratool_stream_double( os, crequested->data.rgb.g, ptrback, erp ); dk4gra_pgf_stream_kw(os, 3, ptrback, erp); dk4gratool_stream_double( os, crequested->data.rgb.b, ptrback, erp ); dk4gra_pgf_stream_kw(os, ((0 != fi) ? 11 : 10), ptrback, erp); } break; } dk4mem_cpy(cactive, crequested, sizeof(dk4gra_col_t), erp); } } /** Write set dash instruction. @param bptr Current page. @param da Array containing the dash length values. @param szda Number of elements in da. @param offs Initial dash offset. @param ptrback Address of success variable to reset on error. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if str is NULL or the stream is not opened for writing, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed, - DK4_E_MATH_OVERFLOW
if the exponent is out of range for integer values,
- DK4_E_SYNTAX
if input contains invalid characters. */ static void dk4gra_pgf_dash_out( dk4_gra_pgf_page_t *bptr, const double *da, size_t szda, double offs, int *ptrback, dk4_er_t *erp ) { size_t i; #if DK4_USE_ASSERT assert(NULL != bptr); assert(NULL != da); assert(0 < szda); #endif /* setdash{ */ dk4gra_pgf_page_kw(bptr, 14, ptrback, erp); for (i = 0; i < szda; i++) { /* { */ dk4gra_pgf_page_kw(bptr, 16, ptrback, erp); /* One dash length */ dk4gratool_stream_double(bptr->memstrm, da[i], ptrback, erp); /* bp} */ dk4gra_pgf_page_kw(bptr, 17, ptrback, erp); } /* }{ */ dk4gra_pgf_page_kw(bptr, 15, ptrback, erp); /* Initial dash offset */ dk4gratool_stream_double(bptr->memstrm, offs, ptrback, erp); /* bp} */ dk4gra_pgf_page_kw(bptr, 13, ptrback, erp); } /** Initialize image record. @param imgptr Image record to initialize. @param fn File name, may be NULL. @param imgno Image number. @param ii Flag: Allow image interpolation. @param erp Error report, may be NULL. @return 1 on success, 0 on error. Error codes: - DK4_E_INVALID_ARGUMENTS
if src is a NULL pointer, - DK4_E_MATH_OVERFLOW
on mathematical overflow in size calculation, - DK4_E_MEMORY_ALLOCATION_FAILED
with mem.elsize and mem.nelem set if no memory is available. */ static int dk4gra_pgf_img_init( dk4_gra_pgf_img_no_t *imgptr, const dkChar *fn, size_t imgno, int ii, dk4_er_t *erp ) { int back = 0; #if DK4_USE_ASSERT assert(NULL != imgptr); assert(NULL != fn); #endif /* Default values for all components */ DK4_MEMRES(imgptr,sizeof(dk4_gra_pgf_img_no_t)); imgptr->fn = NULL; imgptr->imgno = imgno; imgptr->hufi = 0; imgptr->intp = ii; /* Retrieve unique file identifier and other setup for file. */ if (NULL != fn) { imgptr->hufi = dk4ufi_get(&(imgptr->ufi), fn, NULL); imgptr->fn = dk4str_dup(fn, erp); if (NULL != imgptr->fn) { back = 1; } } return back; } void dk4gra_pgf_img_close(dk4_gra_pgf_img_no_t *imgptr) { #if DK4_USE_ASSERT assert(NULL != imgptr); #endif if (NULL != imgptr) { dk4mem_release(imgptr->fn); dk4mem_free(imgptr); } } dk4_gra_pgf_img_no_t * dk4gra_pgf_img_open(const dkChar *fn, size_t imgno, int ii, dk4_er_t *erp) { dk4_gra_pgf_img_no_t *back = NULL; int ok = 0; $? "+ dk4gra_pgf_img_open %!ds", TR_STR(fn) #if DK4_USE_ASSERT assert(NULL != fn); #endif /* Check arguments */ if (NULL == fn) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } /* Allocate memory */ back = dk4mem_new(dk4_gra_pgf_img_no_t,1,erp); if (NULL == back) { goto finished; } /* Initialize record components */ if (0 == dk4gra_pgf_img_init(back, fn, imgno, ii, erp)) { goto finished; } ok = 1; finished: if ((NULL != back) && (0 == ok)) { dk4gra_pgf_img_close(back); back = NULL; } $? "- dk4gra_pgf_img_open %d", TR_IPTR(back) return back; } /** Write keyword to stream, reset success variable on errors. @param ostrm Stream to write to. @param kwi Keyword index in array. @param bptr Address of success variable. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if str is NULL or the stream is not opened for writing, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed. */ static void dk4gra_pgf_kw_to_stream( dk4_stream_t *ostrm, size_t kwi, int *bptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != ostrm); #endif dk4gratool_stream_string(ostrm, dk4gra_pgf_kw[kwi], bptr, erp); } /** Write the font definitions. @param ostrm Output stream. @param gra Graphics structure. @param backptr Address of success variable to reset on error. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if str is NULL or the stream is not opened for writing, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed, - DK4_E_MATH_OVERFLOW
if the exponent is out of range for integer values,
- DK4_E_SYNTAX
if input contains invalid characters. */ static void dk4gra_pgf_font_definitions( dk4_stream_t *ostrm, dk4_gra_t *gra, int *backptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != ostrm); #endif dk4gratool_font_definitions(ostrm, gra->out.pgf.fc, backptr, erp); } /** Write the image definitions. @param ostrm Output stream. @param gra Graphics structure. @param backptr Address of success variable to reset on error. @param erp Error report, may be NULL. Error codes: - DK4_E_INVALID_ARGUMENTS
if any argument is insufficient, - DK4_E_BUFFER_TOO_SMALL
if one of the buffers to read locale settings is too small, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed. */ static void dk4gra_pgf_image_definitions( dk4_stream_t *ostrm, dk4_gra_t *gra, int *backptr, dk4_er_t *erp ) { #if DK4_CHAR_SIZE > 1 char buf[DK4_MAX_PATH]; #endif dkChar lang[16]; dkChar reg[16]; dk4_gra_pgf_img_no_t *tptr; #if DK4_CHAR_SIZE > 1 char *bufptr; #endif int enc; int res; #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != ostrm); #endif res = dk4loc_get_settings( lang, DK4_SIZEOF(lang,dkChar), reg, DK4_SIZEOF(reg,dkChar), &enc, erp ); if (0 == res) { #if DK4_ON_WINDOWS enc = DK4_FILE_ENCODING_WIN1252; #else enc = DK4_FILE_ENCODING_PLAIN; #endif } dk4sto_it_reset(gra->out.pgf.i_imagno); do { tptr = (dk4_gra_pgf_img_no_t *)dk4sto_it_next(gra->out.pgf.i_imagno); if (NULL != tptr) { dk4gra_pgf_kw_to_stream(ostrm, 66, backptr, erp); if (0 != tptr->intp) { dk4gra_pgf_kw_to_stream(ostrm, 67, backptr, erp); } dk4gra_pgf_kw_to_stream(ostrm, 68, backptr, erp); /* NUMBER */ dk4gratool_stream_num_alpha(ostrm, tptr->imgno, backptr, erp); dk4gra_pgf_kw_to_stream(ostrm, 69, backptr, erp); /* FILE NAME */ #if DK4_CHAR_SIZE > 1 #if DK4_CHAR_SIZE > 2 res = dk4recode_dk_to_any( buf, sizeof(buf), DK4_FILE_ENCODING_WIN1252, tptr->fn, DK4_ENCODING_32, erp ); #else res = dk4recode_dk_to_any( buf, sizeof(buf), DK4_FILE_ENCODING_WIN1252, tptr->fn, DK4_ENCODING_UTF16, erp ); #endif if (0 != res) { bufptr = buf; while ('\0' != *bufptr) { if ('\\' == *bufptr) { *bufptr = '/'; } bufptr++; } dk4gratool_stream_string(ostrm, buf, backptr, erp); } #else dk4gratool_stream_string(ostrm, tptr->fn, backptr, erp); #endif dk4gra_pgf_kw_to_stream(ostrm, 70, backptr, erp); } } while (NULL != tptr); } /** Write one page to output stream. @param ostrm Output stream. @param gra Graphics the page is from. @param page Page to write. @param erp Error report, may be NULL. @return 1 on success, 0 on error. Error codes: - DK4_E_INVALID_ARGUMENTS
if any argument is insufficient, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed, - DK4_E_CLOSE_FAILED
if closing downward data failed, - DK4_E_MATH_OVERFLOW
if the exponent is out of range for integer values,
- DK4_E_SYNTAX
if input contains invalid characters, - DK4_E_BUFFER_TOO_SMALL
if the destination buffer size is too small for the result, - DK4_E_BUG
if an internal buffer is too small (should not happen). */ static int dk4gra_pgf_one_page( dk4_stream_t *ostrm, dk4_gra_t *gra, dk4_gra_pgf_page_t *page, dk4_er_t *erp ) { int back = 0; #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != ostrm); assert(NULL != page); #endif if (NULL != page->memstrm) { back = 1; if (0 == dk4stream_close(page->memstrm, erp)) { back = 0; } page->memstrm = NULL; /* begin{pgfpicture} */ dk4gra_pgf_kw_to_stream(ostrm, 44, &back, erp); /* Font and image definitions */ if (0 == gra->out.pgf.sa) { dk4gra_pgf_font_definitions(ostrm, gra, &back, erp); dk4gra_pgf_image_definitions(ostrm, gra, &back, erp); } /* Bounding box path */ dk4gra_pgf_kw_to_stream(ostrm, 46, &back, erp); dk4gratool_stream_uint(ostrm, gra->w, 0, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 33, &back, erp); dk4gratool_stream_uint(ostrm, gra->h, 0, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 34, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 30, &back, erp); /* Clip path */ if (0 == ((page->flags) & DK4_GRA_PAGE_FLAG_NO_CLIP)) { dk4gra_pgf_kw_to_stream(ostrm, 1, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 46, &back, erp); dk4gratool_stream_uint(ostrm, gra->w, 0, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 33, &back, erp); dk4gratool_stream_uint(ostrm, gra->h, 0, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 34, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 29, &back, erp); } /* White background */ if (0 == ((page->flags) & DK4_GRA_PAGE_FLAG_NO_BG)) { dk4gra_pgf_kw_to_stream(ostrm, 71, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 46, &back, erp); dk4gratool_stream_uint(ostrm, gra->w, 0, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 33, &back, erp); dk4gratool_stream_uint(ostrm, gra->h, 0, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 34, &back, erp); dk4gra_pgf_kw_to_stream(ostrm, 26, &back, erp); } /* Contents */ if (NULL != page->membuf) { if (0 == dk4membuf_to_stream(ostrm, page->membuf, erp)) { back = 0; } } else { back = 0; } /* End clipping */ if (0 == ((page->flags) & DK4_GRA_PAGE_FLAG_NO_CLIP)) { dk4gra_pgf_kw_to_stream(ostrm, 2, &back, erp); } /* end{pgfpicture} */ dk4gra_pgf_kw_to_stream(ostrm, 45, &back, erp); } else { /* ERROR: No memstream */ } return back; } /** Write output file. @param fout Output file to write. @param gra Graphics to write to file. @param erp Error report, may be NULL. @return 1 on success, 0 on error. Error codes: - DK4_E_INVALID_ARGUMENTS
if any argument is insufficient, - DK4_E_WRITE_FAILED
if writing one ore multiple bytes to the stream failed, - DK4_E_FLUSH_FAILED
if flushing data downwards failed, - DK4_E_CLOSE_FAILED
if closing downward data failed, - DK4_E_MATH_OVERFLOW
if the exponent is out of range for integer values,
- DK4_E_SYNTAX
if input contains invalid characters, - DK4_E_BUFFER_TOO_SMALL
if the destination buffer size is too small for the result, - DK4_E_BUG
if an internal buffer is too small (should not happen). */ static int dk4gra_pgf_file( FILE *fout, dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr = NULL; dk4_stream_t *ostrm = NULL; int back = 0; int hadpage = 0; #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != fout); #endif ostrm = dk4stream_open_for_file(fout, DK4_STREAM_WRITE, 0, 0, erp); if (NULL != ostrm) { back = 1; /* Start of standalone document */ if (0 != gra->out.pgf.sa) { dk4gratool_start_standalone_document( ostrm, gra, 1, gra->out.pgf.dfs, gra->out.pgf.s_prelfo, gra->out.pgf.i_prelfo, gra->out.pgf.s_prelpa, gra->out.pgf.i_prelpa, gra->out.pgf.s_prelot, gra->out.pgf.i_prelot, &back, erp ); dk4gra_pgf_font_definitions(ostrm, gra, &back, erp); dk4gra_pgf_image_definitions(ostrm, gra, &back, erp); } /* Page contents */ dk4sto_it_reset(gra->i_pages); do { bptr = (dk4_gra_pgf_page_t *)dk4sto_it_next(gra->i_pages); if (NULL != bptr) { if (0 != hadpage) { dk4gra_pgf_page_kw(bptr, 43, &back, erp); } if (0 == dk4gra_pgf_one_page(ostrm, gra, bptr, erp)) { back = 0; } hadpage = 1; } } while (NULL != bptr); /* End of standalone document */ if (0 != gra->out.pgf.sa) { dk4gratool_end_standalone_document(ostrm, &back, erp); } } if (NULL != ostrm) { if (0 == dk4stream_close(ostrm, erp)) { back = 0; } } return back; } /** Delete PGF page structure, release resources. @param pageptr Page to release. */ static void dk4gra_pgf_page_delete(dk4_gra_pgf_page_t *pageptr) { #if DK4_USE_ASSERT assert(NULL != pageptr); #endif if (NULL != pageptr) { if (NULL != pageptr->memstrm) { dk4stream_close(pageptr->memstrm, NULL); } pageptr->memstrm = NULL; if (NULL != pageptr->membuf) { dk4membuf_close(pageptr->membuf); } pageptr->membuf = NULL; dk4mem_free(pageptr); } } /** Create PGF page structure, allocate resources. @param pageno Page number. @param flags Flags. @param erp Error report. @return Valid pointer to new structure on success, NULL on error. Error codes: - DK4_E_INVALID_ARGUMENTS
if any argument is insufficient, - DK4_E_MATH_OVERFLOW
on numeric overflow when calculating a memory allocation size, - DK4_E_MEMORY_ALLOCATION_FAILED
with mem.elsize and mem.nelem set if there is not enough memory available. */ static dk4_gra_pgf_page_t * dk4gra_pgf_page_new( size_t pageno, int flags, dk4_er_t *erp ) { dk4_gra_pgf_page_t *back = NULL; int ok = 0; $? "+ dk4gra_pgf_page_new" /* Allocate structure */ back = dk4mem_new(dk4_gra_pgf_page_t,1,erp); if (NULL == back) { goto finished; } /* Initialize components to defaults */ DK4_MEMRES(back,sizeof(dk4_gra_pgf_page_t)); dk4gratool_initialize_attributes(&(back->attr)); dk4gratool_initialize_attributes(&(back->catt)); back->membuf = NULL; back->memstrm = NULL; back->pageno = pageno; back->flags = flags; /* Allocate memory buffer and stream */ back->membuf = dk4membuf_open(erp); if (NULL == back->membuf) { goto finished; } back->memstrm = dk4stream_open_membuf_writer(back->membuf, erp); if (NULL == back->memstrm) { goto finished; } /* Indicate success */ ok = 1; /* Clean up if neccessary, return */ finished: if ((NULL != back) && (0 == ok)) { dk4gra_pgf_page_delete(back); back = NULL; } $? "- dk4gra_pgf_page_new %d", TR_IPTR(back) return back; } /** Delete all preamble lines from a storage/iterator pair. @param pot Address of storage pointer. @param pit Address of iterator pointer. */ static void dk4gra_pgf_doc_preamble_close( dk4_sto_t **pot, dk4_sto_it_t **pit ) { dk4_gra_preamble_line_t *pl; if (NULL != *pot) { if (NULL != *pit) { dk4sto_it_reset(*pit); do { pl = (dk4_gra_preamble_line_t *)dk4sto_it_next(*pit); if (NULL != pl) { dk4gratool_preamble_delete(pl); } } while (NULL != pl); dk4sto_it_close(*pit); *pit = NULL; } dk4sto_close(*pot); *pot = NULL; } *pot = NULL; *pit = NULL; } void dk4gra_pgf_close( dk4_gra_t *gra ) { dk4_gra_pgf_img_no_t *imgptr; $? "+ dk4gra_pgf_close" #if DK4_USE_ASSERT assert(NULL != gra); #endif if (NULL == gra) { goto finished; } if (NULL != gra->out.pgf.fc) { dk4fontc_close(gra->out.pgf.fc); gra->out.pgf.fc = NULL; } if (NULL != gra->out.pgf.s_imagno) { if (NULL != gra->out.pgf.i_imagno) { dk4sto_it_close(gra->out.pgf.i_imagno); } dk4sto_close(gra->out.pgf.s_imagno); gra->out.pgf.s_imagno = NULL; } if (NULL != gra->out.pgf.s_images) { if (NULL != gra->out.pgf.i_images) { dk4sto_it_reset(gra->out.pgf.i_images); do { imgptr = (dk4_gra_pgf_img_no_t *)dk4sto_it_next( gra->out.pgf.i_images ); if (NULL != imgptr) { dk4gra_pgf_img_close(imgptr); } } while (NULL != imgptr); dk4sto_it_close(gra->out.pgf.i_images); } dk4sto_close(gra->out.pgf.s_images); gra->out.pgf.s_images = NULL; } dk4gra_pgf_doc_preamble_close( &(gra->out.pgf.s_prelfo), &(gra->out.pgf.i_prelfo) ); dk4gra_pgf_doc_preamble_close( &(gra->out.pgf.s_prelpa), &(gra->out.pgf.i_prelpa) ); dk4gra_pgf_doc_preamble_close( &(gra->out.pgf.s_prelot), &(gra->out.pgf.i_prelot) ); dk4gratool_close(gra); finished: $? "- dk4gra_pgf_close" return; } dk4_gra_t * dk4gra_pgf_open( const dkChar *fn, size_t w, size_t h, int docfl, int sa, dk4_er_t *erp ) { dk4_gra_t *back = NULL; int ok = 0; $? "+ dk4gra_pgf_open" #if DK4_USE_ASSERT assert(NULL != fn); assert(0 < w); assert(0 < h); #endif $? ". sa = %d", sa /* Generic initialization */ back = dk4gratool_open(fn, w, h, docfl, erp); if (NULL == back) { goto finished; } /* PGF-specific default initialization */ back->dr = DK4_GRA_DRIVER_PGF; back->out.pgf.fc = NULL; back->out.pgf.s_imagno = NULL; back->out.pgf.i_imagno = NULL; back->out.pgf.s_images = NULL; back->out.pgf.i_images = NULL; back->out.pgf.s_prelfo = NULL; back->out.pgf.i_prelfo = NULL; back->out.pgf.s_prelpa = NULL; back->out.pgf.i_prelpa = NULL; back->out.pgf.s_prelot = NULL; back->out.pgf.i_prelot = NULL; back->out.pgf.dfs = -1.0; back->out.pgf.n_images = 0; back->out.pgf.n_prelfo = 0; back->out.pgf.n_prelpa = 0; back->out.pgf.n_prelot = 0; back->out.pgf.sa = sa; /* Pages storage and iterator. */ back->s_pages = dk4sto_open(erp); if (NULL == back->s_pages) { $? "! s_pages" goto finished; } (void)dk4sto_set_comp(back->s_pages, dk4gra_pgf_compare_pages_by_number, 0); back->i_pages = dk4sto_it_open(back->s_pages, erp); if (NULL == back->i_pages) { $? "! i_pages" goto finished; } /* Allocate resources */ back->out.pgf.fc = dk4fontc_open(erp); if (NULL == back->out.pgf.fc) { goto finished; } back->out.pgf.s_imagno = dk4sto_open(erp); if (NULL == back->out.pgf.s_imagno) { goto finished; } back->out.pgf.s_images = dk4sto_open(erp); if (NULL == back->out.pgf.s_images) { goto finished; } dk4sto_set_comp( back->out.pgf.s_imagno, dk4gra_pgf_compare_images_by_number, 0 ); dk4sto_set_comp( back->out.pgf.s_images, dk4gra_pgf_compare_images_by_ufi_and_name, 0 ); back->out.pgf.i_imagno = dk4sto_it_open(back->out.pgf.s_imagno, erp); if (NULL == back->out.pgf.i_imagno) { goto finished; } back->out.pgf.i_images = dk4sto_it_open(back->out.pgf.s_images, erp); if (NULL == back->out.pgf.i_images) { goto finished; } /* Finally indicate success */ ok = 1; /* Cleanup section, destroy object if not completely initialized */ finished: if ((NULL != back) && (0 == ok)) { dk4gra_pgf_close(back); back = NULL; } $? "- dk4gra_pgf_open %d", TR_IPTR(back) return back; } int dk4gra_pgf_write_file_and_close( FILE *fout, dk4_gra_t *gra, dk4_er_t *erp ) { int back = 0; $? "+ dk4gra_pgf_write_file_and_close" #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != fout); #endif back = dk4gra_pgf_file(fout, gra, erp); dk4gra_pgf_close(gra); $? "- dk4gra_pgf_write_file_and_close %d", back return back; } int dk4gra_pgf_page( dk4_gra_t *gra, int flags, dk4_er_t *erp ) { dk4_gra_pgf_page_t *newpage = NULL; int back = 0; $? "+ dk4gra_pgf_page" #if DK4_USE_ASSERT assert(NULL != gra); #endif /* Check for page number overflow */ if (SIZE_MAX == gra->pages) { dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW); goto finished; } /* Allocate resources for new page */ newpage = dk4gra_pgf_page_new(gra->pages, flags, erp); if (NULL == newpage) { goto finished; } /* Save new page in pages storage. */ if (0 == dk4sto_add(gra->s_pages, newpage, erp)) { dk4gra_pgf_page_delete(newpage); goto finished; } /* Update pages number */ gra->pages += 1; gra->curpg = newpage; back = 1; finished: $? "- dk4gra_pgf_page %d", back return back; } int dk4gra_pgf_gsave( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_gsave" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 1, &back, erp); finished: $? "- dk4gra_pgf_gsave %d", back return back; } int dk4gra_pgf_grestore( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_grestore" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 2, &back, erp); finished: $? "- dk4gra_pgf_grestore %d", back return back; } int dk4gra_pgf_set_line_width( dk4_gra_t *gra, double lw, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_line_width" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.lw_requested = lw; finished: $? "- dk4gra_pgf_set_line_width %d", back return back; } int dk4gra_pgf_set_line_style( dk4_gra_t *gra, int ls, double sv, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_line_style" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.ls_requested = ls; bptr->attr.sv_requested = sv; finished: $? "- dk4gra_pgf_set_line_style %d", back return back; } int dk4gra_pgf_set_line_cap( dk4_gra_t *gra, int lc, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_line_cap" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.lc_requested = lc; finished: $? "- dk4gra_pgf_set_line_cap %d", back return back; } int dk4gra_pgf_set_line_join( dk4_gra_t *gra, int lj, double ml, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_line_join" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.lj_requested = lj; bptr->attr.ml_requested = ml; if (1.0 > bptr->attr.ml_requested) { bptr->attr.ml_requested = 1.0; back = 0; dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); } finished: $? "- dk4gra_pgf_set_line_join %d", back return back; } int dk4gra_pgf_set_fill_gray( dk4_gra_t *gra, double g, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_fill_gray" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.col_fill_requested.what = DK4_GRA_COL_SPEC_GRAY; bptr->attr.col_fill_requested.data.gray = g; finished: $? "- dk4gra_pgf_set_fill_gray %d", back return back; } int dk4gra_pgf_set_fill_rgb( dk4_gra_t *gra, double r, double g, double b, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_fill_rgb" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.col_fill_requested.what = DK4_GRA_COL_SPEC_RGB; bptr->attr.col_fill_requested.data.rgb.r = r; bptr->attr.col_fill_requested.data.rgb.g = g; bptr->attr.col_fill_requested.data.rgb.b = b; finished: $? "- dk4gra_pgf_set_fill_rgb %d", back return back; } int dk4gra_pgf_set_fill_cmyk( dk4_gra_t *gra, double c, double m, double y, double k, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_fill_cmyk" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.col_fill_requested.what = DK4_GRA_COL_SPEC_CMYK; bptr->attr.col_fill_requested.data.cmyk.c = c; bptr->attr.col_fill_requested.data.cmyk.m = m; bptr->attr.col_fill_requested.data.cmyk.y = y; bptr->attr.col_fill_requested.data.cmyk.k = k; finished: $? "- dk4gra_pgf_set_fill_cmyk" return back; } int dk4gra_pgf_set_stroke_gray( dk4_gra_t *gra, double g, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_stroke_gray" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.col_stroke_requested.what = DK4_GRA_COL_SPEC_GRAY; bptr->attr.col_stroke_requested.data.gray = g; finished: $? "- dk4gra_pgf_set_stroke_gray %d", back return back; } int dk4gra_pgf_set_stroke_rgb( dk4_gra_t *gra, double r, double g, double b, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_set_stroke_rgb" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.col_stroke_requested.what = DK4_GRA_COL_SPEC_RGB; bptr->attr.col_stroke_requested.data.rgb.r = r; bptr->attr.col_stroke_requested.data.rgb.g = g; bptr->attr.col_stroke_requested.data.rgb.b = b; finished: $? "- dk4gra_pgf_set_stroke_rgb %d", back return back; } int dk4gra_pgf_set_stroke_cmyk( dk4_gra_t *gra, double c, double m, double y, double k, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "- dk4gra_pgf_set_stroke_cmyk" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; bptr->attr.col_stroke_requested.what = DK4_GRA_COL_SPEC_CMYK; bptr->attr.col_stroke_requested.data.cmyk.c = c; bptr->attr.col_stroke_requested.data.cmyk.m = m; bptr->attr.col_stroke_requested.data.cmyk.y = y; bptr->attr.col_stroke_requested.data.cmyk.k = k; finished: $? "- dk4gra_pgf_set_stroke_cmyk %d", back return back; } int dk4gra_pgf_prepare_fill( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; int back = 0; $? "+ dk4gra_pgf_prepare_fill" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_set_color_if_necessary( bptr->memstrm, &(bptr->attr.col_fill_active), &(bptr->attr.col_fill_requested), 1, &back, erp ); if (gra->eor != bptr->attr.eor_active) { dk4gratool_stream_string( bptr->memstrm, dk4gra_pgf_kw[(0 != gra->eor) ? (47) : (48)], &back, erp ); bptr->attr.eor_active = gra->eor; } finished: $? "- dk4gra_pgf_prepare_fill %d", back return back; } int dk4gra_pgf_prepare_stroke( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ double da[16]; /* Dash array */ double gw = 0.0; /* Gap width in dash pattern */ int back = 0; /* Function result */ int lwc = 0; /* Flag line width or style changed */ $? "+ dk4gra_pgf_prepare_stroke" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; /* Stroke color */ dk4gra_pgf_set_color_if_necessary( bptr->memstrm, &(bptr->attr.col_stroke_active), &(bptr->attr.col_stroke_requested), 0, &back, erp ); /* Line width */ if ( DK4_GRA_EPSILON_LINEWIDTH < fabs(bptr->attr.lw_active - bptr->attr.lw_requested) ) { dk4gra_pgf_page_kw(bptr, 12, &back, erp); dk4gratool_stream_double( bptr->memstrm, bptr->attr.lw_requested, &back, erp ); dk4gra_pgf_page_kw(bptr, 13, &back, erp); bptr->attr.lw_active = bptr->attr.lw_requested; lwc = 1; } /* Line style */ lwc = dk4gratool_line_style_differs( bptr->attr.ls_active, bptr->attr.ls_requested, bptr->attr.sv_active, bptr->attr.sv_requested, lwc ); if (0 != lwc) { gw = (bptr->attr.sv_requested + bptr->attr.lw_requested) / 2.0; if ((2.0 * bptr->attr.lw_requested) < gw) { gw = 2.0 * bptr->attr.lw_requested; } switch (bptr->attr.lc_requested) { case DK4_GRA_LC_ROUNDED : case DK4_GRA_LC_PROJECTING : { gw += bptr->attr.lw_requested; } break; } switch (bptr->attr.ls_requested) { case DK4_GRA_LS_DASH : { da[0] = bptr->attr.sv_requested; da[1] = gw; dk4gra_pgf_dash_out(bptr, da, 2, (da[0] / 2.0), &back, erp); } break; case DK4_GRA_LS_DOT : { da[0] = da[1] = bptr->attr.lw_requested; dk4gra_pgf_dash_out(bptr, da, 2, (da[0] / 2.0), &back, erp); } break; case DK4_GRA_LS_DASH_DOT : { da[0] = bptr->attr.sv_requested; da[1] = gw; da[2] = bptr->attr.lw_requested; da[3] = gw; dk4gra_pgf_dash_out(bptr, da, 4, (da[0] / 2.0), &back, erp); } break; case DK4_GRA_LS_DASH_DOT_DOT : { da[0] = bptr->attr.sv_requested; da[1] = gw; da[2] = bptr->attr.lw_requested; da[3] = gw; da[4] = bptr->attr.lw_requested; da[5] = gw; dk4gra_pgf_dash_out(bptr, da, 6, (da[0] / 2.0), &back, erp); } break; case DK4_GRA_LS_DASH_DOT_DOT_DOT : { da[0] = bptr->attr.sv_requested; da[1] = gw; da[2] = bptr->attr.lw_requested; da[3] = gw; da[4] = bptr->attr.lw_requested; da[5] = gw; da[6] = bptr->attr.lw_requested; da[7] = gw; dk4gra_pgf_dash_out(bptr, da, 8, (da[0] / 2.0), &back, erp); } break; default : { dk4gra_pgf_dash_out(bptr, da, 0, 0.0, &back, erp); } break; } bptr->attr.ls_active = bptr->attr.ls_requested; bptr->attr.sv_active = bptr->attr.sv_requested; } /* Line cap */ if (bptr->attr.lc_active != bptr->attr.lc_requested) { switch (bptr->attr.lc_requested) { case DK4_GRA_LC_ROUNDED : { dk4gra_pgf_page_kw(bptr, 19, &back, erp); } break; case DK4_GRA_LC_PROJECTING : { dk4gra_pgf_page_kw(bptr, 20, &back, erp); } break; default : { dk4gra_pgf_page_kw(bptr, 18, &back, erp); } break; } bptr->attr.lc_active = bptr->attr.lc_requested; } /* Line join */ if (bptr->attr.lj_active != bptr->attr.lj_requested) { switch (bptr->attr.lj_requested) { case DK4_GRA_LJ_ROUNDED : { dk4gra_pgf_page_kw(bptr, 21, &back, erp); } break; case DK4_GRA_LJ_BEVELED : { dk4gra_pgf_page_kw(bptr, 22, &back, erp); } break; default : { dk4gra_pgf_page_kw(bptr, 23, &back, erp); } break; } bptr->attr.lj_active = bptr->attr.lj_requested; } if (DK4_GRA_LJ_MITERED == bptr->attr.lj_active) { if ( DK4_GRA_EPSILON_MITERLIMIT < fabs(bptr->attr.ml_active - bptr->attr.ml_requested) ) { dk4gra_pgf_page_kw(bptr, 24, &back, erp); dk4gratool_stream_double( bptr->memstrm, bptr->attr.ml_requested, &back, erp ); dk4gra_pgf_page_kw(bptr, 25, &back, erp); bptr->attr.ml_active = bptr->attr.ml_requested; } } finished: $? "- dk4gra_pgf_prepare_stroke %d", back return back; } int dk4gra_pgf_prepare_fill_and_stroke( dk4_gra_t *gra, dk4_er_t *erp ) { int back; $? "+ dk4gra_pgf_prepare_fill_and_stroke" #if DK4_USE_ASSERT assert(NULL != gra); #endif back = dk4gra_pgf_prepare_fill(gra, erp); if (0 == dk4gra_pgf_prepare_stroke(gra, erp)) { back = 0; } $? "- dk4gra_pgf_prepare_fill_and_stroke %d", back return back; } int dk4gra_pgf_fill( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_fill" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 26, &back, erp); finished: $? "- dk4gra_pgf_fill %d", back return back; } int dk4gra_pgf_stroke( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_stroke" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 27, &back, erp); finished: $? "- dk4gra_pgf_stroke %d", back return back; } int dk4gra_pgf_fill_and_stroke( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_fill_and_stroke" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 28, &back, erp); finished: $? "- dk4gra_pgf_fill_and_stroke %d", back return back; } int dk4gra_pgf_clip( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_clip" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 29, &back, erp); finished: $? "- dk4gra_pgf_clip %d", back return back; } int dk4gra_pgf_newpath_moveto( dk4_gra_t *gra, double x, double y, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_newpath_moveto" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 31, &back, erp); dk4gratool_stream_double(bptr->memstrm, x, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, y, &back, erp); dk4gra_pgf_page_kw(bptr, 34, &back, erp); $? "- dk4gra_pgf_newpath_moveto %d", back finished: return back; } int dk4gra_pgf_lineto( dk4_gra_t *gra, double x, double y, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_newpath_moveto" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 32, &back, erp); dk4gratool_stream_double(bptr->memstrm, x, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, y, &back, erp); dk4gra_pgf_page_kw(bptr, 34, &back, erp); $? "- dk4gra_pgf_newpath_moveto %d", back finished: return back; } int dk4gra_pgf_curveto( dk4_gra_t *gra, double xc1, double yc1, double xc2, double yc2, double x, double y, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_curveto" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 35, &back, erp); dk4gratool_stream_double(bptr->memstrm, xc1, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, yc1, &back, erp); dk4gra_pgf_page_kw(bptr, 36, &back, erp); dk4gratool_stream_double(bptr->memstrm, xc2, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, yc2, &back, erp); dk4gra_pgf_page_kw(bptr, 36, &back, erp); dk4gratool_stream_double(bptr->memstrm, x, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, y, &back, erp); dk4gra_pgf_page_kw(bptr, 34, &back, erp); finished: $? "- dk4gra_pgf_curveto %d", back return back; } int dk4gra_pgf_closepath( dk4_gra_t *gra, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_closepath" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 37, &back, erp); finished: $? "- dk4gra_pgf_closepath" return back; } int dk4gra_pgf_circle( dk4_gra_t *gra, double xc, double yc, double r, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_circle" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; dk4gra_pgf_page_kw(bptr, 38, &back, erp); dk4gratool_stream_double(bptr->memstrm, xc, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, yc, &back, erp); dk4gra_pgf_page_kw(bptr, 39, &back, erp); dk4gratool_stream_double(bptr->memstrm, r, &back, erp); dk4gra_pgf_page_kw(bptr, 25, &back, erp); finished: $? "- dk4gra_pgf_circle %d", back return back; } int dk4gra_pgf_rectangle( dk4_gra_t *gra, double xl, double xr, double yb, double yt, double r, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ int back = 0; $? "+ dk4gra_pgf_rectangle" #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } back = 1; if (0.0 < r) { /* Open TeX scope */ dk4gra_pgf_page_kw(bptr, 40, &back, erp); /* Set corner radius */ dk4gra_pgf_page_kw(bptr, 41, &back, erp); dk4gratool_stream_double(bptr->memstrm, r, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, r, &back, erp); dk4gra_pgf_page_kw(bptr, 34, &back, erp); } /* Draw rectangle by two corners */ dk4gra_pgf_page_kw(bptr, 42, &back, erp); dk4gratool_stream_double(bptr->memstrm, xl, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, yb, &back, erp); dk4gra_pgf_page_kw(bptr, 36, &back, erp); dk4gratool_stream_double(bptr->memstrm, xr, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, yt, &back, erp); dk4gra_pgf_page_kw(bptr, 34, &back, erp); if (0.0 < r) { /* Close Tex scope */ dk4gra_pgf_page_kw(bptr, 25, &back, erp); } finished: $? "- dk4gra_pgf_rectangle %d", back return back; } /** Handle text. @param gra Graphics structure. @param x X position of text. @param y Y position of text. @param rot Rotation counterclockwise in degree. @param txt Text to write. @param colspec Color specification, may be NULL to use fill color. @param ie Text encoding for simple text specified as char. @param ha Horizontal alignment of text origin. @param va Vertical alignment of text origin. @param isnt Flag: Is normal text, no special text. @param fno Font number, DK4_FONT_TIMES_ROMAN and others. @param fsz Font size in pt. @param fex Exactness of font, DK4_GRA_TF_EXACT_SIZE and others. @param uc2l Unicode to LaTeX converter to use for normal text. @param flags Flags. @param backptr Address of suuccess variable to reset on error. @param erp Error report, may be NULL. */ static void dk4gra_pgf_i_text( dk4_gra_t *gra, double x, double y, double rot, const void *txt, const char *colspec, int ie, dk4_text_align_h_t ha, dk4_text_align_v_t va, int isnt, int fno, double fsz, dk4_gra_tf_t fex, dk4_uc2l_t *uc2l, int flags, int *backptr, dk4_er_t *erp ) { dk4_gra_pgf_page_t *bptr; /* Current page */ size_t fontno = 0; size_t kwi = 60; int back = 0; int dorot = 0; $? "+ dk4gra_pgf_i_text" if ((NULL == gra) || (NULL == txt)) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } if (DK4_GRA_DRIVER_PGF != gra->dr) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } if (1.0e-8 < fabs(rot)) { dorot = 1; } bptr = (dk4_gra_pgf_page_t *)(gra->curpg); if (NULL == bptr->memstrm) { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } if (0 != isnt) { if (0 == dk4fontc_add_font(&fontno, gra->out.pgf.fc, fno, fsz, fex, erp)) { goto finished; } } switch (va) { case DK4_TEXT_ALIGN_V_TOP : { switch (ha) { case DK4_TEXT_ALIGN_H_CENTERED : { kwi = 49; } break; case DK4_TEXT_ALIGN_H_RIGHT : { kwi = 50; } break; default : { /* left */ kwi = 51; } break; } } break; case DK4_TEXT_ALIGN_V_CENTERED : { switch (ha) { case DK4_TEXT_ALIGN_H_CENTERED : { kwi = 52; } break; case DK4_TEXT_ALIGN_H_RIGHT : { kwi = 53; } break; default : { /* left */ kwi = 54; } break; } } break; case DK4_TEXT_ALIGN_V_BOTTOM : { switch (ha) { case DK4_TEXT_ALIGN_H_CENTERED : { kwi = 55; } break; case DK4_TEXT_ALIGN_H_RIGHT : { kwi = 56; } break; default : { /* left */ kwi = 57; } break; } } break; default : { /* base */ switch (ha) { case DK4_TEXT_ALIGN_H_CENTERED : { kwi = 58; } break; case DK4_TEXT_ALIGN_H_RIGHT : { kwi = 59; } break; default : { /* left */ kwi = 60; } break; } } break; } back = 1; dk4gra_pgf_page_kw(bptr, kwi, &back, erp); dk4gratool_stream_double(bptr->memstrm, x, &back, erp); dk4gra_pgf_page_kw(bptr, 33, &back, erp); dk4gratool_stream_double(bptr->memstrm, y, &back, erp); dk4gra_pgf_page_kw(bptr, 61, &back, erp); if (0 != dorot) { dk4gra_pgf_page_kw(bptr, 77, &back, erp); dk4gratool_stream_double(bptr->memstrm, rot, &back, erp); } dk4gra_pgf_page_kw(bptr, 76, &back, erp); dk4gra_pgf_page_kw(bptr, 65, &back, erp); /* White box if required */ if (0 != (DK4_GRA_TEXT_FLAG_WHITE_BOX & flags)) { dk4gra_pgf_page_kw(bptr, 65, &back, erp); } /* Use either specified color from colspec or fill color */ if (NULL != colspec) { if (0 == dk4stream_write_char_string(bptr->memstrm, colspec, erp)) { back = 0; } } else { dk4gratool_stream_color( bptr->memstrm, &(bptr->attr.col_fill_requested), &back, erp ); } /* Open oval box if required */ if (0 != (DK4_GRA_TEXT_FLAG_OVAL_BOX & flags)) { dk4gra_pgf_page_kw(bptr, 75, &back, erp); } /* Switch font */ if (0 != isnt) { dk4gra_pgf_page_kw(bptr, 72, &back, erp); dk4gratool_stream_num_alpha(bptr->memstrm, fontno, &back, erp); dk4gra_pgf_page_kw(bptr, 73, &back, erp); } /* Write text */ if (0 != isnt) { if ( 0 == dk4uc2l_string_dk(bptr->memstrm, uc2l, (const dkChar *)txt, ie, erp) ) { back = 0; } } else { if ( 0 == dk4stream_write_char_string(bptr->memstrm, (const char *)txt, erp) ) { back = 0; } } /* Close oval box if required */ if (0 != (DK4_GRA_TEXT_FLAG_OVAL_BOX & flags)) { dk4gra_pgf_page_kw(bptr, 63, &back, erp); } /* Close white box if required */ if (0 != (DK4_GRA_TEXT_FLAG_WHITE_BOX & flags)) { dk4gra_pgf_page_kw(bptr, 63, &back, erp); } dk4gra_pgf_page_kw(bptr, 64, &back, erp); #if 0 if (0 != dorot) { } #endif dk4gra_pgf_page_kw(bptr, 0, &back, erp); finished: $? "- dk4gra_pgf_i_text %d", back if ((NULL != backptr) && (0 == back)) { *backptr = 0; } } void dk4gra_pgf_simple_text( dk4_gra_t *gra, double x, double y, double rot, const dkChar *txt, const char *colspec, int ie, dk4_text_align_h_t ha, dk4_text_align_v_t va, int fno, double fsz, dk4_gra_tf_t fex, dk4_uc2l_t *uc2l, int flags, int *backptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != txt); #endif dk4gra_pgf_i_text( gra, x, y, rot, txt, colspec, ie, ha, va, 1, fno, fsz, fex, uc2l, flags, backptr, erp ); } void dk4gra_pgf_simple_utf8_text( dk4_gra_t *gra, double x, double y, double rot, const char *txt, const char *colspec, dk4_text_align_h_t ha, dk4_text_align_v_t va, int fno, double fsz, dk4_gra_tf_t fex, dk4_uc2l_t *uc2l, int flags, int *backptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != txt); #endif dk4gra_pgf_i_text( gra, x, y, rot, txt, colspec, DK4_ENCODING_UTF8, ha, va, 1, fno, fsz, fex, uc2l, flags, backptr, erp ); } void dk4gra_pgf_special_text( dk4_gra_t *gra, double x, double y, double rot, const char *txt, const char *colspec, dk4_text_align_h_t ha, dk4_text_align_v_t va, int fno, double fsz, dk4_gra_tf_t fex, int flags, int *backptr, dk4_er_t *erp ) { #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != txt); #endif dk4gra_pgf_i_text( gra, x, y, rot, txt, colspec, #if DK4_ON_WINDOWS DK4_FILE_ENCODING_WIN1252, #else DK4_FILE_ENCODING_PLAIN, #endif ha, va, 0, fno, fsz, fex, NULL, flags, backptr, erp ); } void dk4gra_pgf_save_attributes( dk4_gra_t *gra ) { dk4_gra_pgf_page_t *bptr; #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); dk4mem_cpy( &(bptr->catt), &(bptr->attr), sizeof(dk4gra_attributes_t), NULL ); } void dk4gra_pgf_restore_attributes( dk4_gra_t *gra ) { dk4_gra_pgf_page_t *bptr; #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); dk4mem_cpy( &(bptr->attr), &(bptr->catt), sizeof(dk4gra_attributes_t), NULL ); } void dk4gra_pgf_reset_attributes( dk4_gra_t *gra ) { dk4_gra_pgf_page_t *bptr; #if DK4_USE_ASSERT assert(NULL != gra); #endif bptr = (dk4_gra_pgf_page_t *)(gra->curpg); dk4gratool_reset_active_attributes(&(bptr->attr)); } void dk4gra_pgf_doc_font_size( dk4_gra_t *gra, double fs, int *backptr, dk4_er_t *erp ) { $? "+ dk4gra_pgf_doc_font_size" #if DK4_USE_ASSERT assert(NULL != gra); assert(0.0 < fs); assert(DK4_GRA_DRIVER_PGF == gra->dr); #endif if ((NULL != gra) && (0.0 < fs) && (DK4_GRA_DRIVER_PGF == gra->dr)) { if (0 != gra->out.pgf.sa) { gra->out.pgf.dfs = fs; } else { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); if (NULL != backptr) { *backptr = 0; } } } else { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); if (NULL != backptr) { *backptr = 0; } } $? "- dk4gra_pgf_doc_font_size" } /** Add one configuration line to storage. @param psto Address of container. @param pit Address of container iterator. @param pnum Address of variable storing number of lines. @param textline Text line to add. @param backptr Address of success variable to reset on error. @param erp Error report, may be NULL. */ static void dk4gra_pgf_i_preamble_line( dk4_sto_t **psto, dk4_sto_it_t **pit, size_t *pnum, char const *textline, int *backptr, dk4_er_t *erp ) { dk4_gra_preamble_line_t *pl; int back = 0; $? "+ dk4gra_pgf_i_preamble_line" if (SIZE_MAX > *pnum) { $? ". number ok" if (NULL == *psto) { $? ". no storage yet" *psto = dk4sto_open(erp); if (NULL != *psto) { $? ". have storage" dk4sto_set_comp(*psto, dk4gratool_compare_preamble_lines, 0); } #if TRACE_DEBUG else { $? "! storage" } #endif } if (NULL != *psto) { if (NULL == *pit) { $? ". no iterator yet" *pit = dk4sto_it_open(*psto, erp); } if (NULL != *pit) { $? ". iterator ok" pl = dk4gratool_preamble_new(textline, *pnum, erp); if (NULL != pl) { $? ". structure ok" if (0 != dk4sto_add(*psto, pl, erp)) { back = 1; $? ". added ok" } else { $? "! add" dk4gratool_preamble_delete(pl); } } #if TRACE_DEBUG else { $? "! structure" } #endif } #if TRACE_DEBUG else { $? "! iterator" } #endif } } else { $? "! number" dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); } if (0 == back) { if (NULL != backptr) { *backptr = 0; } } $? "- dk4gra_pgf_i_preamble_line %d", back } void dk4gra_pgf_doc_preamble_line( dk4_gra_t *gra, const char *line, int tp, int *backptr, dk4_er_t *erp ) { $? "+ dk4gra_pgf_doc_preamble_line" #if DK4_USE_ASSERT assert(NULL != gra); assert(NULL != line); assert(DK4_GRA_DRIVER_PGF == gra->dr); #endif if ((NULL != gra) && (NULL != line) && (DK4_GRA_DRIVER_PGF == gra->dr)) { if (0 != gra->out.pgf.sa) { switch (tp) { case DK4_GRA_PREAMBLE_FONT : { $? ". font" dk4gra_pgf_i_preamble_line( &(gra->out.pgf.s_prelfo), &(gra->out.pgf.i_prelfo), &(gra->out.pgf.n_prelfo), line, backptr, erp ); } break; case DK4_GRA_PREAMBLE_PACKAGE : { $? ". package" dk4gra_pgf_i_preamble_line( &(gra->out.pgf.s_prelpa), &(gra->out.pgf.i_prelpa), &(gra->out.pgf.n_prelpa), line, backptr, erp ); } break; case DK4_GRA_PREAMBLE_OTHER : { $? ". other" dk4gra_pgf_i_preamble_line( &(gra->out.pgf.s_prelot), &(gra->out.pgf.i_prelot), &(gra->out.pgf.n_prelot), line, backptr, erp ); } break; default : { $? "! type" dk4error_set_simple_error_code(erp,DK4_E_INVALID_ARGUMENTS); if (NULL != backptr) { *backptr = 0; } } break; } } else { $? "! not a document" dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); if (NULL != backptr) { *backptr = 0; } } } else { $? "! args" dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); if (NULL != backptr) { *backptr = 0; } } $? "- dk4gra_pgf_doc_preamble_line" } /* vim: set ai sw=4 ts=4 : */