diff options
Diffstat (limited to 'nx-X11/lib/XprintUtil')
| -rw-r--r-- | nx-X11/lib/XprintUtil/Imakefile | 21 | ||||
| -rw-r--r-- | nx-X11/lib/XprintUtil/xprintutil.c | 2111 | ||||
| -rw-r--r-- | nx-X11/lib/XprintUtil/xprintutil.h | 250 | ||||
| -rw-r--r-- | nx-X11/lib/XprintUtil/xprintutil_printtofile.c | 498 |
4 files changed, 2880 insertions, 0 deletions
diff --git a/nx-X11/lib/XprintUtil/Imakefile b/nx-X11/lib/XprintUtil/Imakefile new file mode 100644 index 000000000..dfbeae63a --- /dev/null +++ b/nx-X11/lib/XprintUtil/Imakefile @@ -0,0 +1,21 @@ +#define DoNormalLib YES +# XprintUtil is not a stable interface yet, therefore avoid shipping it +# as shared lib for now +#define DoSharedLib NO +#define DoDebugLib NO +#define DoProfileLib NO +#define HasSharedData NO +#define LibName XprintUtil +#define SoRev SOZLIBREV +#define IncSubdir X11 +#define IncSubSubdir XprintUtil + + +HEADERS = xprintutil.h + +SRCS = xprintutil.c xprintutil_printtofile.c +OBJS = xprintutil.o xprintutil_printtofile.o + +#include <Library.tmpl> + +DependTarget() diff --git a/nx-X11/lib/XprintUtil/xprintutil.c b/nx-X11/lib/XprintUtil/xprintutil.c new file mode 100644 index 000000000..58fe1386b --- /dev/null +++ b/nx-X11/lib/XprintUtil/xprintutil.c @@ -0,0 +1,2111 @@ +/****************************************************************************** + ****************************************************************************** + ** + ** (c) Copyright 2001-2004 Roland Mainz <roland.mainz@nrubsig.org> + ** + ** Permission is hereby granted, free of charge, to any person obtaining a copy + ** of this software and associated documentation files (the "Software"), to deal + ** in the Software without restriction, including without limitation the rights + ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + ** copies of the Software, and to permit persons to whom the Software is + ** furnished to do so, subject to the following conditions: + ** + ** The above copyright notice and this permission notice shall be included in + ** all copies or substantial portions of the Software. + ** + ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + ** COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + ** IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + ** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + ** + ** Except as contained in this notice, the names of the copyright holders shall + ** not be used in advertising or otherwise to promote the sale, use or other + ** dealings in this Software without prior written authorization from said + ** copyright holders. + ** + ****************************************************************************** + *****************************************************************************/ + +#include "xprintutil.h" + +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <stdio.h> +#include <limits.h> +#include <errno.h> +#include <locale.h> + +#ifdef XPU_USE_NSPR +#include "plstr.h" +#undef strtok_r +#define strtok_r(s1, s2, x) PL_strtok_r((s1), (s2), (x)) +#endif /* XPU_USE_NSPR */ + +/* List of tokens which can be used to separate entries in the + * $XPSERVERLIST env var */ +static const char XPServerListSeparators[] = " \t\v\n\r\f"; + +/* conformace only; X11 API does (currrently) not make use of |const|. + * If Xlib API gets fixed these macros can be turned into empty + * placeholders... (|#define MAKE_STRING_WRITABLE(x)|) :-) + */ +#define MAKE_STRING_WRITABLE(str) (((str)?((str) = strdup(str)):0)) +#define FREE_WRITABLE_STRING(str) free((void *)(str)) +#define STRING_AS_WRITABLE(str) ((char *)(str)) + +/* Local prototypes */ +static const char *XpuGetDefaultXpPrintername(void); +static const char *XpuGetXpServerList( void ); +static const char *XpuEnumerateXpAttributeValue( const char *value, void **vcptr ); +static const char *XpuGetCurrentAttributeGroup( void **vcptr ); +static void XpuDisposeEnumerateXpAttributeValue( void **vc ); +static Bool XpuEnumerateMediumSourceSizes( Display *pdpy, XPContext pcontext, + const char **tray_name, + const char **medium_name, int *mbool, + float *ma1, float *ma2, float *ma3, float *ma4, + void **vcptr ); +static void XpuDisposeEnumerateMediumSourceSizes( void **vc ); + +/* +** XprintUtil functions start with Xpu +** +*/ + +int XpuCheckExtension( Display *pdpy ) +{ + char *display = XDisplayString(pdpy); + short major = 0, + minor = 0; + + if( XpQueryVersion(pdpy, &major, &minor) != 0 ) + { + XPU_DEBUG_ONLY(printf("XpuCheckExtension: XpQueryVersion '%s' %d %d\n", XPU_NULLXSTR(display), (int)major, (int)minor)); + return(1); + } + else + { + XPU_DEBUG_ONLY(printf("XpuCheckExtension: XpQueryVersion '%s' returned 0(=Xprint not supported)\n", XPU_NULLXSTR(display))); + } + + return(0); +} + +/* Get the default printer name from the XPRINTER env var. + * If XPRINTER env var is not present looks for PDPRINTER, LPDEST, and + * PRINTER (in that order) + * See CDE's DtPrintSetupBox(3) manual page, too... + */ +static +const char *XpuGetDefaultXpPrintername(void) +{ + const char *s; + /* BUG/TODO: XpPrinter resource needs to be sourced, too... */ + s = getenv("XPRINTER"); + if( !s ) + { + s = getenv("PDPRINTER"); + if( !s ) + { + s = getenv("LPDEST"); + if( !s ) + { + s = getenv("PRINTER"); + } + } + } + return s; +} + +static +const char *XpuGetXpServerList( void ) +{ + const char *s; + /* BUG/TODO: XpServerList resource needs to be sourced first, then append + * contents of XPSERVERLIST, then remove duplicates... + */ + s = getenv("XPSERVERLIST"); + if( s == NULL ) + s = ""; + + return(s); +} + + +Bool XpuXprintServersAvailable( void ) +{ + const char *s; + int c = 0; + /* BUGs/ToDo: + * - XpServerList resource needs to be sourced, too... + * (see comment for |XpuGetXpServerList|, too) + * - There should be some validation whether the server entries + * are + * a) valid (easy :) + * and + * b) available (hard to implement when XOpenDisplay() should be avoided) + */ + s = getenv("XPSERVERLIST"); + /* Check if serverlist is non-empty */ + if (s) + { + while( *s++ ) + { + if( !isspace(*s) ) + c++; + } + } + /* a valid server name must at least contain the ':'-seperator + * and a number (e.g. ":1") */ + return( c >= 2 ); +} + + +static +int XpuGetPrinter2( char *printer, char *display, Display **pdpyptr, XPContext *pcontextptr ) +{ + Display *pdpy; + XPContext pcontext; + + XPU_DEBUG_ONLY(printf("XpuGetPrinter2: probing display '%s' for '%s'\n", XPU_NULLXSTR(display), XPU_NULLXSTR(printer))); + + if( (pdpy = XOpenDisplay(display)) != NULL ) + { + if( XpuCheckExtension(pdpy) ) + { + XPPrinterList list; + int list_count; + + /* get list of available printers... */ + list = XpGetPrinterList(pdpy, printer, &list_count); + if( list != NULL ) XpFreePrinterList(list); + + /* ...and check if printer exists... */ + if( (list != NULL) && (list_count > 0) ) + { + if( (pcontext = XpCreateContext(pdpy, printer)) != None ) + { + *pdpyptr = pdpy; + *pcontextptr = pcontext; + return(1); + } + + XPU_DEBUG_ONLY(printf("XpuGetPrinter2: could not create print context for '%s'\n", XPU_NULLXSTR(printer))); + } + } + else + { + XPU_DEBUG_ONLY(printf("display '%s' does not support the Xprint extension\n", XPU_NULLXSTR(display))); + } + + XCloseDisplay(pdpy); + return(0); + } + else + { + XPU_DEBUG_ONLY(printf("could not open display '%s'\n", XPU_NULLXSTR(display))); + return(0); + } +} + + +/* acceps "printer" or "printer@display" */ +int XpuGetPrinter( const char *arg_printername, Display **pdpyptr, XPContext *pcontextptr ) +{ + Display *pdpy; + XPContext pcontext; + char *printername; + char *s; + char *tok_lasts; + + *pdpyptr = NULL; + *pcontextptr = None; + + XPU_DEBUG_ONLY(printf("XpuGetPrinter: looking for '%s'\n", XPU_NULLXSTR(arg_printername))); + + /* strtok_r will modify string - duplicate it first... */ + printername = strdup(arg_printername); + if( printername == NULL ) + return(0); + + if( (s = strtok_r(printername, "@", &tok_lasts)) != NULL ) + { + char *name = s; + char *display = strtok_r(NULL, "@", &tok_lasts); + + /* if we have a display - open it and grab printer */ + if( display != NULL ) + { + if( XpuGetPrinter2(name, display, pdpyptr, pcontextptr) ) + { + free(printername); + return(1); + } + } + /* if we did not get a display, travel througth all displays */ + else + { + char *sl = strdup(XpuGetXpServerList()); + + if( sl != NULL ) + { + for( display = strtok_r(sl, XPServerListSeparators, &tok_lasts) ; + display != NULL ; + display = strtok_r(NULL, XPServerListSeparators, &tok_lasts) ) + { + if( XpuGetPrinter2(name, display, pdpyptr, pcontextptr) ) + { + free(sl); + free(printername); + return(1); + } + } + + free(sl); + } + } + } + + free(printername); + XPU_DEBUG_ONLY(printf("XpuGetPrinter: failure\n")); + + return(0); +} + + +void XpuClosePrinterDisplay(Display *pdpy, XPContext pcontext) +{ + if( pdpy ) + { + if( pcontext != None ) + XpDestroyContext(pdpy, pcontext); + + XCloseDisplay(pdpy); + } +} + +void XpuSetOneAttribute( Display *pdpy, XPContext pcontext, + XPAttributes type, const char *attribute_name, const char *value, XPAttrReplacement replacement_rule ) +{ + /* Alloc buffer for sprintf() stuff below */ + char *buffer = (char *)malloc(strlen(attribute_name)+strlen(value)+4); + + if( buffer != NULL ) + { + sprintf(buffer, "%s: %s", attribute_name, value); + XpSetAttributes(pdpy, pcontext, type, buffer, replacement_rule); + free(buffer); + } +} + +void XpuSetOneLongAttribute( Display *pdpy, XPContext pcontext, + XPAttributes type, const char *attribute_name, long value, XPAttrReplacement replacement_rule ) +{ + /* Alloc buffer for sprintf() stuff below */ + char *buffer = (char *)malloc(strlen(attribute_name)+32+4); + + if( buffer != NULL ) + { + sprintf(buffer, "%s: %ld", attribute_name, value); + XpSetAttributes(pdpy, pcontext, type, buffer, replacement_rule); + free(buffer); + } +} + +/* Check if attribute value is supported or not + * Use this function _only_ if XpuGetSupported{Job,Doc,Page}Attributes() + * does not help you... + */ +int XpuCheckSupported( Display *pdpy, XPContext pcontext, XPAttributes type, const char *attribute_name, const char *query ) +{ + char *value; + void *tok_lasts; + + MAKE_STRING_WRITABLE(attribute_name); + if( attribute_name == NULL ) + return(0); + + value = XpGetOneAttribute(pdpy, pcontext, type, STRING_AS_WRITABLE(attribute_name)); + + XPU_DEBUG_ONLY(printf("XpuCheckSupported: XpGetOneAttribute(%s) returned '%s'\n", XPU_NULLXSTR(attribute_name), XPU_NULLXSTR(value))); + + FREE_WRITABLE_STRING(attribute_name); + + if( value != NULL ) + { + const char *s; + + for( s = XpuEnumerateXpAttributeValue(value, &tok_lasts) ; s != NULL ; s = XpuEnumerateXpAttributeValue(NULL, &tok_lasts) ) + { + XPU_DEBUG_ONLY(printf("XpuCheckSupported: probing '%s'=='%s'\n", XPU_NULLXSTR(s), XPU_NULLXSTR(query))); + if( !strcmp(s, query) ) + { + XFree(value); + XpuDisposeEnumerateXpAttributeValue(&tok_lasts); + return(1); + } + } + + XpuDisposeEnumerateXpAttributeValue(&tok_lasts); + XFree(value); + } + + return(0); +} + + +int XpuSetJobTitle( Display *pdpy, XPContext pcontext, const char *title ) +{ + if( XpuGetSupportedJobAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_JOB_NAME ) + { + char *encoded_title; + + encoded_title = XpuResourceEncode(title); + if (!encoded_title) + return(0); + XpuSetOneAttribute(pdpy, pcontext, XPJobAttr, "*job-name", encoded_title, XPAttrMerge); + XpuResourceFreeString(encoded_title); + return(1); + } + else + { + XPU_DEBUG_ONLY(printf("XpuSetJobTitle: XPUATTRIBUTESUPPORTED_JOB_NAME not supported ('%s')\n", XPU_NULLXSTR(title))); + return(0); + } +} + +int XpuGetOneLongAttribute( Display *pdpy, XPContext pcontext, XPAttributes type, const char *attribute_name, long *result ) +{ + char *s; + + MAKE_STRING_WRITABLE(attribute_name); + if( attribute_name == NULL ) + return(0); + s = XpGetOneAttribute(pdpy, pcontext, type, STRING_AS_WRITABLE(attribute_name)); + + if(s && *s) + { + long tmp; + + XPU_DEBUG_ONLY(printf("XpuGetOneLongAttribute: '%s' got '%s'\n", XPU_NULLXSTR(attribute_name), XPU_NULLXSTR(s))); + + tmp = strtol(s, (char **)NULL, 10); + + if( !(((tmp == 0L) || (tmp == LONG_MIN) || (tmp == LONG_MAX)) && + ((errno == ERANGE) || (errno == EINVAL))) ) + { + *result = tmp; + XFree(s); + XPU_DEBUG_ONLY(printf("XpuGetOneLongAttribute: result %ld\n", *result)); + FREE_WRITABLE_STRING(attribute_name); + return(1); + } + } + + if( s != NULL ) + XFree(s); + + FREE_WRITABLE_STRING(attribute_name); + + return(0); +} + + +#ifdef DEBUG +/* debug only */ +void dumpXpAttributes( Display *pdpy, XPContext pcontext ) +{ + char *s; + printf("------------------------------------------------\n"); + printf("--> Job\n%s\n", s=XpuGetJobAttributes(pdpy, pcontext)); XFree(s); + printf("--> Doc\n%s\n", s=XpuGetDocAttributes(pdpy, pcontext)); XFree(s); + printf("--> Page\n%s\n", s=XpuGetPageAttributes(pdpy, pcontext)); XFree(s); + printf("--> Printer\n%s\n", s=XpuGetPrinterAttributes(pdpy, pcontext)); XFree(s); + printf("--> Server\n%s\n", s=XpuGetServerAttributes(pdpy, pcontext)); XFree(s); + printf("image resolution %d\n", (int)XpGetImageResolution(pdpy, pcontext)); + printf("------------------------------------------------\n"); +} +#endif /* DEBUG */ + + +typedef struct XpuIsNotifyEventContext_ +{ + int event_base; + int detail; +} XpuIsNotifyEventContext; + +static +Bool IsXpNotifyEvent( Display *pdpy, XEvent *ev, XPointer arg ) +{ + Bool match; + XpuIsNotifyEventContext *context = (XpuIsNotifyEventContext *)arg; + XPPrintEvent *pev = (XPPrintEvent *)ev; + + match = pev->type == (context->event_base+XPPrintNotify) && + pev->detail == context->detail; + + XPU_DEBUG_ONLY(printf("XpuWaitForPrintNotify: %d=IsXpNotifyEvent(%d,%d)\n", + (int)match, + (int)pev->type, + (int)pev->detail)); + return match; +} + +void XpuWaitForPrintNotify( Display *pdpy, int xp_event_base, int detail ) +{ + XEvent dummy; + XpuIsNotifyEventContext matchcontext; + + matchcontext.event_base = xp_event_base; + matchcontext.detail = detail; + XIfEvent(pdpy, &dummy, IsXpNotifyEvent, (XPointer)&matchcontext); +} + +static +const char *skip_matching_brackets(const char *start) +{ + const char *s = start; + int level = 0; + + if( !start ) + return(NULL); + + do + { + switch(*s++) + { + case '\0': return(NULL); + case '{': level++; break; + case '}': level--; break; + } + } while(level > 0); + + return(s); +} + + +static +const char *search_next_space(const char *start) +{ + const char *s = start; + int level = 0; + + if( !start ) + return(NULL); + + for(;;) + { + if( isspace(*s) ) + return(s); + + if( *s=='\0' ) + return(NULL); + + s++; + } +} + +/* PRIVATE context data for XpuEnumerateXpAttributeValue() */ +typedef struct _XpuAttributeValueEnumeration +{ + char *value; + size_t original_value_len; /* original length of value */ + char *group; + char *start; + char *s; +} XpuAttributeValueEnumeration; + + +/* Hacked parser for Xp values and enumerations */ +static +const char *XpuEnumerateXpAttributeValue( const char *value, void **vcptr ) +{ + XpuAttributeValueEnumeration **cptr = (XpuAttributeValueEnumeration **)vcptr; + XpuAttributeValueEnumeration *context; + const char *tmp; + + if( !cptr ) + return(NULL); + + if( value ) + { + XpuAttributeValueEnumeration *e; + const char *s = value; + Bool isGroup = FALSE; + + e = (XpuAttributeValueEnumeration *)malloc(sizeof(XpuAttributeValueEnumeration)); + if( !e ) + return NULL; + + /* Skip leading '{'. */ + while(*s=='{' && isGroup==FALSE) + { + s++; + isGroup = TRUE; + } + /* Skip leading blanks. */ + while(isspace(*s)) + s++; + + e->group = NULL; + + /* Read group name. */ + if( isGroup ) + { + tmp = s; + while(!isspace(*s)) + s++; + if(strncmp(tmp, "''", s-tmp) != 0) + { + e->group = strdup(tmp); + e->group[s-tmp] = '\0'; + } + } + + e->original_value_len = strlen(s); + e->value = (char *)malloc(e->original_value_len+4); /* We may look up to three bytes beyond the string */ + strcpy(e->value, s); + memset(e->value+e->original_value_len+1, 0, 3); /* quad termination */ + e->start = e->s = e->value; + + *cptr = e; + } + + context = *cptr; + + if( !context || !context->s ) + return(NULL); + + /* Skip leading blanks, '\'' or '}' */ + while(isspace(*(context->s)) || *(context->s)=='\'' /*|| *(context->s)=='}'*/ ) + context->s++; + + if( *(context->s) == '\0' ) + return(NULL); + + context->start = context->s; + if( *(context->start) == '{' ) + context->s = (char *)skip_matching_brackets(context->start); + else + context->s = (char *)search_next_space(context->start); + + /* end of string reached ? */ + if( context->s ) + { + *(context->s) = '\0'; + context->s++; + } + + /* Check if we reached a new attribute group */ + tmp = context->start; + while(isspace(*tmp)) + tmp++; + if( *tmp=='}' ) + { + void *prev_cptr = *vcptr; + + tmp+=2; /* We have 3*'\0' at the end of the string - this is legal! */ + if( *tmp!='\0' ) + { + const char *ret; + + /* Start the parser again */ + *vcptr = NULL; + ret = XpuEnumerateXpAttributeValue(tmp, vcptr); + + /* Free old context */ + XpuDisposeEnumerateXpAttributeValue(&prev_cptr); + + return(ret); + } + else + { + return(NULL); + } + } + + return(context->start); +} + +/* Get enumeration group for last string returned by |XpuEnumerateXpAttributeValue|... */ +static +const char *XpuGetCurrentAttributeGroup( void **vcptr ) +{ + XpuAttributeValueEnumeration **cptr = (XpuAttributeValueEnumeration **)vcptr; + if( !cptr ) + return(NULL); + if( !*cptr ) + return(NULL); + + return((*cptr)->group); +} + + +static +void XpuDisposeEnumerateXpAttributeValue( void **vc ) +{ + if( vc ) + { + XpuAttributeValueEnumeration *context = *((XpuAttributeValueEnumeration **)vc); + free(context->value); + if(context->group) + free(context->group); + free(context); + } +} + +/* parse a paper size string + * (example: '{na-letter False {6.3500 209.5500 6.3500 273.0500}}') */ +static +Bool XpuParseMediumSourceSize( const char *value, + const char **medium_name, int *mbool, + float *ma1, float *ma2, float *ma3, float *ma4 ) +{ + const char *s; + char *d, + *name; + char *boolbuf; + size_t value_len; + int num_input_items; + const char *cur_locale; + + if( value && value[0]!='{' && value[0]!='\0' ) + return(False); + + value_len = strlen(value); + + /* alloc buffer for |medium_name| and |boolbuf| in one step + * (both must be large enougth to hold at least |strlen(value)+1| bytes) */ + name = (char *)malloc(value_len*2 + 4); + boolbuf = name + value_len+2; /* |boolbuf| starts directly after |name| */ + + /* remove '{' && '}' */ + s = value; + d = name; + do + { + *d = tolower(*s); + + if( *s!='{' && *s!='}' ) + d++; + + s++; + } + while(*s); + *d = '\0'; + + /* separate medium name from string */ + d = (char *)search_next_space(name); + if( !d ) + { + free(name); + return(False); + } + *d = '\0'; + *medium_name = name; + + /* ... continue to parse the remaining string... */ + d++; + + + /* Force C/POSIX radix for scanf()-parsing (see bug 131831 ("Printing + * does not work in de_AT@euro locale")), do the parsing and restore + * the original locale. + * XXX: This may affect all threads and not only the calling one... + */ + { +#define CUR_LOCALE_SIZE 256 + char cur_locale[CUR_LOCALE_SIZE+1]; + strncpy(cur_locale, setlocale(LC_NUMERIC, NULL), CUR_LOCALE_SIZE); + cur_locale[CUR_LOCALE_SIZE]='\0'; + setlocale(LC_NUMERIC, "C"); + num_input_items = sscanf(d, "%s %f %f %f %f", boolbuf, ma1, ma2, ma3, ma4); + setlocale(LC_NUMERIC, cur_locale); +#undef CUR_LOCALE_SIZE + } + + if( num_input_items != 5 ) + { + free(name); + return(False); + } + + if( !strcmp(boolbuf, "true") ) + *mbool = True; + else if( !strcmp(boolbuf, "false") ) + *mbool = False; + else + { + free(name); + return(False); + } + return(True); +} + + +/* parse a paper size string + * (example: '{na-letter False {6.3500 209.5500 6.3500 273.0500}}') */ +static +Bool XpuEnumerateMediumSourceSizes( Display *pdpy, XPContext pcontext, + const char **tray_name, + const char **medium_name, int *mbool, + float *ma1, float *ma2, float *ma3, float *ma4, + void **vcptr ) +{ + const char *medium_spec; + const char *value = NULL; + + if( pdpy && pcontext ) + { + value = XpGetOneAttribute(pdpy, pcontext, XPPrinterAttr, "medium-source-sizes-supported"); + if( !value ) + return(False); + } + + while(1) + { + medium_spec = XpuEnumerateXpAttributeValue(value, vcptr); + + if( value ) + { + XFree((void *)value); + value = NULL; + } + + /* enumeration done? */ + if( !medium_spec ) + return(False); + + if (XpuParseMediumSourceSize(medium_spec, + medium_name, mbool, + ma1, ma2, ma3, ma4)) + { + *tray_name = XpuGetCurrentAttributeGroup(vcptr); + return(True); + } + else + { + /* Should never ever happen! */ + fprintf(stderr, "XpuEnumerateMediumSourceSize: error parsing '%s'\n", medium_spec); + } + } + /* not reached */ +} + +static +void XpuDisposeEnumerateMediumSourceSizes( void **vc ) +{ + XpuDisposeEnumerateXpAttributeValue(vc); +} + + +/* future: Migrate this functionality into |XpGetPrinterList| - just do + * not pass a |Display *| to |XpGetPrinterList| + */ +XPPrinterList XpuGetPrinterList( const char *printer, int *res_list_count ) +{ + XPPrinterRec *rec = NULL; + int rec_count = 1; /* Allocate one more |XPPrinterRec| structure + * as terminator */ + char *sl; + const char *default_printer_name = XpuGetDefaultXpPrintername(); + int default_printer_rec_index = -1; + + if( !res_list_count ) + return(NULL); + + sl = strdup(XpuGetXpServerList()); + MAKE_STRING_WRITABLE(printer); + + if( sl != NULL ) + { + char *display; + char *tok_lasts; + + for( display = strtok_r(sl, XPServerListSeparators, &tok_lasts) ; + display != NULL ; + display = strtok_r(NULL, XPServerListSeparators, &tok_lasts) ) + { + Display *pdpy; + + if( (pdpy = XOpenDisplay(display)) != NULL ) + { + XPPrinterList list; + int list_count; + size_t display_len = strlen(display); + + /* get list of available printers... */ + list = XpGetPrinterList(pdpy, STRING_AS_WRITABLE(printer), &list_count); + + if( list && list_count ) + { + int i; + + for( i = 0 ; i < list_count ; i++ ) + { + char *s; + + /* Workaround for http://bugzilla.mozilla.org/show_bug.cgi?id=193499 + * ("Xprint print/print preview crashes Mozilla") where the Solaris + * Xprt may create invalid entries (e.g. |XpGetPrinterList| will + * return |list[i].name==NULL| due to empty lines in the printer list. + */ + if( !list[i].name ) + continue; + + rec_count++; + rec = (XPPrinterRec *)realloc(rec, sizeof(XPPrinterRec)*rec_count); + if( !rec ) /* failure */ + break; + + s = (char *)malloc(strlen(list[i].name)+display_len+4); + sprintf(s, "%s@%s", list[i].name, display); + rec[rec_count-2].name = s; + rec[rec_count-2].desc = (list[i].desc)?(strdup(list[i].desc)):(NULL); + + /* Test for default printer (if the user set one).*/ + if( default_printer_name ) + { + /* Default_printer_name may either contain the FQPN(=full + * qualified printer name ("foo@myhost:5") or just the name + * ("foo")) */ + if( (!strcmp(list[i].name, default_printer_name)) || + (!strcmp(s, default_printer_name)) ) + { + /* Remember index of default printer that we can swap it to + * the head of the array below... */ + default_printer_rec_index = rec_count-2; + } + } + } + + XpFreePrinterList(list); + } + + XCloseDisplay(pdpy); + } + } + + free(sl); + } + + if( rec ) + { + /* users: DO NOT COUNT ON THIS DETAIL + * (this is only to make current impl. of XpuFreePrinterList() easier) + * I may remove this implementation detail in a later revision of + * the library! + */ + rec[rec_count-1].name = NULL; + rec[rec_count-1].desc = NULL; + rec_count--; + } + else + { + rec_count = 0; + } + + /* The default printer is always the first one in the printer list... */ + if( (default_printer_rec_index != -1) && rec ) + { + XPPrinterRec tmp; + tmp = rec[0]; + rec[0] = rec[default_printer_rec_index]; + rec[default_printer_rec_index] = tmp; + } + + *res_list_count = rec_count; + FREE_WRITABLE_STRING(printer); + return(rec); +} + + +void XpuFreePrinterList( XPPrinterList list ) +{ + if( list ) + { + XPPrinterRec *curr = list; + + /* See the warning abouve about using this implementation detail for + * checking for the list's end... */ + while( curr->name != NULL ) + { + free(curr->name); + if(curr->desc) + free(curr->desc); + curr++; + } + + free(list); + } +} + +/* Set number of copies to print from this document */ +int XpuSetDocumentCopies( Display *pdpy, XPContext pcontext, long num_copies ) +{ + if( XpuGetSupportedDocAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_COPY_COUNT) + { + XpuSetOneLongAttribute(pdpy, pcontext, XPDocAttr, "*copy-count", num_copies, XPAttrMerge); + return(1); + } + else + { + XPU_DEBUG_ONLY(printf("XpuSetContentOrientation: XPUATTRIBUTESUPPORTED_COPY_COUNT not supported\n")); + + /* Failure... */ + return(0); + } +} + +XpuMediumSourceSizeList XpuGetMediumSourceSizeList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ) +{ + XpuMediumSourceSizeList list = NULL; + int rec_count = 1; /* allocate one more |XpuMediumSourceSizeRec| structure + * as terminator */ + Bool status; + float ma1, + ma2, + ma3, + ma4; + char *value; + void *tok_lasts; + const char *tray_name, + *medium_name; + int mbool; + const char *default_tray, + *default_medium; + int default_medium_rec_index = -1; + + default_tray = XpGetOneAttribute(pdpy, pcontext, XPDocAttr, "default-input-tray"); + if(!default_tray) + { + fprintf(stderr, "XpuGetMediumSourceSizeList: Internal error, no 'default-input-tray' found.\n"); + return(NULL); + } + default_medium = XpGetOneAttribute(pdpy, pcontext, XPDocAttr, "default-medium"); + if(!default_medium) + { + fprintf(stderr, "XpuGetMediumSourceSizeList: Internal error, no 'default-medium' found.\n"); + XFree((void *)default_tray); + return(NULL); + } + + for( status = XpuEnumerateMediumSourceSizes(pdpy, pcontext, &tray_name, &medium_name, &mbool, + &ma1, &ma2, &ma3, &ma4, &tok_lasts) ; + status != False ; + status = XpuEnumerateMediumSourceSizes(NULL, None, &tray_name, &medium_name, &mbool, + &ma1, &ma2, &ma3, &ma4, &tok_lasts) ) + { + rec_count++; + list = (XpuMediumSourceSizeRec *)realloc(list, sizeof(XpuMediumSourceSizeRec)*rec_count); + if( !list ) + return(NULL); + + list[rec_count-2].tray_name = (tray_name)?(strdup(tray_name)):(NULL); + list[rec_count-2].medium_name = strdup(medium_name); + list[rec_count-2].mbool = mbool; + list[rec_count-2].ma1 = ma1; + list[rec_count-2].ma2 = ma2; + list[rec_count-2].ma3 = ma3; + list[rec_count-2].ma4 = ma4; + + /* Default medium ? */ + if( (!strcmp(medium_name, default_medium)) && + ((tray_name && (*default_tray))?(!strcmp(tray_name, default_tray)):(True)) ) + { + default_medium_rec_index = rec_count-2; + } + } + + XpuDisposeEnumerateMediumSourceSizes(&tok_lasts); + + if( list ) + { + /* users: DO NOT COUNT ON THIS DETAIL + * (this is only to make current impl. of XpuFreeMediumSourceSizeList() easier) + * I may remove this implementation detail in a later revision of + * the library! */ + list[rec_count-1].tray_name = NULL; + list[rec_count-1].medium_name = NULL; + rec_count--; + } + else + { + rec_count = 0; + } + + /* Make the default medium always the first item in the list... */ + if( (default_medium_rec_index != -1) && list ) + { + XpuMediumSourceSizeRec tmp; + tmp = list[0]; + list[0] = list[default_medium_rec_index]; + list[default_medium_rec_index] = tmp; + } + + *numEntriesPtr = rec_count; + return(list); +} + +void XpuFreeMediumSourceSizeList( XpuMediumSourceSizeList list ) +{ + if( list ) + { + XpuMediumSourceSizeRec *curr = list; + + /* See the warning abouve about using this implementation detail for + * checking for the list's end... */ + while( curr->medium_name != NULL ) + { + if( curr->tray_name) + free((void *)curr->tray_name); + free((void *)curr->medium_name); + curr++; + } + + free(list); + } +} + +static +int XpuSetMediumSourceSize( Display *pdpy, XPContext pcontext, XPAttributes type, XpuMediumSourceSizeRec *medium_spec ) +{ + /* Set the "default-medium" and "*default-input-tray" + * (if |XpuEnumerateMediumSourceSizes| returned one) XPDocAttr's + * attribute and return */ + if (medium_spec->tray_name) + { + XpuSetOneAttribute(pdpy, pcontext, type, "*default-input-tray", medium_spec->tray_name, XPAttrMerge); + } + XpuSetOneAttribute(pdpy, pcontext, type, "*default-medium", medium_spec->medium_name, XPAttrMerge); + + return( 1 ); +} + +/* Set document medium size */ +int XpuSetDocMediumSourceSize( Display *pdpy, XPContext pcontext, XpuMediumSourceSizeRec *medium_spec ) +{ + XpuSupportedFlags doc_supported_flags; + + doc_supported_flags = XpuGetSupportedDocAttributes(pdpy, pcontext); + + if( (doc_supported_flags & XPUATTRIBUTESUPPORTED_DEFAULT_MEDIUM) == 0 ) + return( 0 ); + + if (medium_spec->tray_name) + { + if( (doc_supported_flags & XPUATTRIBUTESUPPORTED_DEFAULT_INPUT_TRAY) == 0 ) + return( 0 ); + } + + return XpuSetMediumSourceSize(pdpy, pcontext, XPDocAttr, medium_spec); +} + +/* Set page medium size */ +int XpuSetPageMediumSourceSize( Display *pdpy, XPContext pcontext, XpuMediumSourceSizeRec *medium_spec ) +{ + XpuSupportedFlags page_supported_flags; + + page_supported_flags = XpuGetSupportedPageAttributes(pdpy, pcontext); + + if( (page_supported_flags & XPUATTRIBUTESUPPORTED_DEFAULT_MEDIUM) == 0 ) + return( 0 ); + + if (medium_spec->tray_name) + { + if( (page_supported_flags & XPUATTRIBUTESUPPORTED_DEFAULT_INPUT_TRAY) == 0 ) + return( 0 ); + } + + return XpuSetMediumSourceSize(pdpy, pcontext, XPPageAttr, medium_spec); +} + +#ifndef ABS +#define ABS(x) ((x)<0?-(x):(x)) +#endif /* ABS */ +#define MORE_OR_LESS_EQUAL(a, b, tolerance) (ABS((a) - (b)) <= (tolerance)) + +XpuMediumSourceSizeRec * +XpuFindMediumSourceSizeBySize( XpuMediumSourceSizeList mlist, int mlist_count, + float page_width_mm, float page_height_mm, float tolerance ) +{ + int i; + for( i = 0 ; i < mlist_count ; i++ ) + { + XpuMediumSourceSizeRec *curr = &mlist[i]; + float total_width = curr->ma1 + curr->ma2, + total_height = curr->ma3 + curr->ma4; + + /* Match width/height*/ + if( ((page_width_mm !=-1.f)?(MORE_OR_LESS_EQUAL(total_width, page_width_mm, tolerance)):(True)) && + ((page_height_mm!=-1.f)?(MORE_OR_LESS_EQUAL(total_height, page_height_mm, tolerance)):(True)) ) + { + return(curr); + } + } + + return(NULL); +} + +XpuMediumSourceSizeRec * +XpuFindMediumSourceSizeByBounds( XpuMediumSourceSizeList mlist, int mlist_count, + float m1, float m2, float m3, float m4, float tolerance ) +{ + int i; + for( i = 0 ; i < mlist_count ; i++ ) + { + XpuMediumSourceSizeRec *curr = &mlist[i]; + + /* Match bounds */ + if( ((m1!=-1.f)?(MORE_OR_LESS_EQUAL(curr->ma1, m1, tolerance)):(True)) && + ((m2!=-1.f)?(MORE_OR_LESS_EQUAL(curr->ma2, m2, tolerance)):(True)) && + ((m3!=-1.f)?(MORE_OR_LESS_EQUAL(curr->ma3, m3, tolerance)):(True)) && + ((m4!=-1.f)?(MORE_OR_LESS_EQUAL(curr->ma4, m4, tolerance)):(True)) ) + { + return(curr); + } + } + + return(NULL); +} + +XpuMediumSourceSizeRec * +XpuFindMediumSourceSizeByName( XpuMediumSourceSizeList mlist, int mlist_count, + const char *tray_name, const char *medium_name ) +{ + int i; + for( i = 0 ; i < mlist_count ; i++ ) + { + XpuMediumSourceSizeRec *curr = &mlist[i]; + + /* Match by tray name and/or medium name */ + if( ((tray_name && curr->tray_name)?(!strcasecmp(curr->tray_name, tray_name)):(tray_name==NULL)) && + ((medium_name)?(!strcasecmp(curr->medium_name, medium_name)):(True)) ) + { + return(curr); + } + } + + return(NULL); +} + +XpuResolutionList XpuGetResolutionList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ) +{ + XpuResolutionList list = NULL; + int rec_count = 1; /* Allocate one more |XpuResolutionRec| structure + * as terminator */ + char *value; + char *tok_lasts; + const char *s; + long default_resolution = -1; + int default_resolution_rec_index = -1; + char namebuf[64]; + + /* Get default document resolution */ + if( XpuGetOneLongAttribute(pdpy, pcontext, XPDocAttr, "default-printer-resolution", &default_resolution) != 1 ) + { + default_resolution = -1; + } + + value = XpGetOneAttribute(pdpy, pcontext, XPPrinterAttr, "printer-resolutions-supported"); + if (!value) + { + fprintf(stderr, "XpuGetResolutionList: Internal error, no 'printer-resolutions-supported' XPPrinterAttr found.\n"); + return(NULL); + } + + for( s = strtok_r(value, " ", &tok_lasts) ; + s != NULL ; + s = strtok_r(NULL, " ", &tok_lasts) ) + { + long tmp; + + tmp = strtol(s, (char **)NULL, 10); + + if( ((tmp == 0L) || (tmp == LONG_MIN) || (tmp == LONG_MAX)) && + ((errno == ERANGE) || (errno == EINVAL)) ) + { + fprintf(stderr, "XpuGetResolutionList: Internal parser errror for '%s'.\n", s); + continue; + } + + rec_count++; + list = (XpuResolutionRec *)realloc(list, sizeof(XpuResolutionRec)*rec_count); + if( !list ) + return(NULL); + + sprintf(namebuf, "%lddpi", tmp); + list[rec_count-2].name = strdup(namebuf); + list[rec_count-2].x_dpi = tmp; + list[rec_count-2].y_dpi = tmp; + + if( default_resolution != -1 ) + { + /* Is this the default resolution ? */ + if( (list[rec_count-2].x_dpi == default_resolution) && + (list[rec_count-2].y_dpi == default_resolution) ) + { + default_resolution_rec_index = rec_count-2; + } + } + } + + XFree(value); + + if( list ) + { + /* users: DO NOT COUNT ON THIS DETAIL + * (this is only to make current impl. of XpuGetResolutionList() easier) + * We may remove this implementation detail in a later revision of + * the library! */ + list[rec_count-1].name = NULL; + list[rec_count-1].x_dpi = -1; + list[rec_count-1].y_dpi = -1; + rec_count--; + } + else + { + rec_count = 0; + } + + /* Make the default resolution always the first item in the list... */ + if( (default_resolution_rec_index != -1) && list ) + { + XpuResolutionRec tmp; + tmp = list[0]; + list[0] = list[default_resolution_rec_index]; + list[default_resolution_rec_index] = tmp; + } + + *numEntriesPtr = rec_count; + return(list); +} + +void XpuFreeResolutionList( XpuResolutionList list ) +{ + if( list ) + { + XpuResolutionRec *curr = list; + + /* See the warning abouve about using this implementation detail for + * checking for the list's end... */ + while( curr->name != NULL ) + { + free((void *)curr->name); + curr++; + } + + free(list); + } +} + +/* Find resolution in resolution list. + */ +XpuResolutionRec *XpuFindResolutionByName( XpuResolutionList list, int list_count, const char *name) +{ + int i; + + for( i = 0 ; i < list_count ; i++ ) + { + XpuResolutionRec *curr = &list[i]; + if (!strcasecmp(curr->name, name)) + return curr; + + /* Search by plain DPI value (no "dpi" suffix )*/ + if (curr->x_dpi == curr->x_dpi) + { + char buf[32]; + sprintf(buf, "%ld", curr->x_dpi); + if (!strcasecmp(buf, name)) + return curr; + } + } + + return NULL; +} + +/* Get default page (if defined) or document resolution + * this function may fail in the following conditions: + * - No default resolution set yet + * - X DPI != Y DPI (not yet implemented in Xprt) + */ +Bool XpuGetResolution( Display *pdpy, XPContext pcontext, long *x_dpi_ptr, long *y_dpi_ptr ) +{ + long dpi; + + /* Try to get the current page's resolution (pages may differ in resolution if the DDX supports this) */ + if( XpuGetOneLongAttribute(pdpy, pcontext, XPPageAttr, "default-printer-resolution", &dpi) == 1 ) + { + *x_dpi_ptr = dpi; + *y_dpi_ptr = dpi; + return True; + } + + /* Get document resolution */ + if( XpuGetOneLongAttribute(pdpy, pcontext, XPDocAttr, "default-printer-resolution", &dpi) == 1 ) + { + *x_dpi_ptr = dpi; + *y_dpi_ptr = dpi; + return True; + } + + return False; +} + +static +int XpuSetResolution( Display *pdpy, XPContext pcontext, XPAttributes type, XpuResolutionRec *rec ) +{ + if( rec->x_dpi != rec->y_dpi ) + { + fprintf(stderr, "XpuSetResolution: internal error: x_dpi != y_dpi not supported yet.\n"); + return 0; + } + + XpuSetOneLongAttribute(pdpy, pcontext, type, "*default-printer-resolution", rec->x_dpi, XPAttrMerge); + return( 1 ); +} + +/* Set document resolution + * Retun error if printer does not support setting a resolution + */ +int XpuSetDocResolution( Display *pdpy, XPContext pcontext, XpuResolutionRec *rec ) +{ + if( (XpuGetSupportedDocAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_DEFAULT_PRINTER_RESOLUTION) == 0 ) + return( 0 ); + + return XpuSetResolution(pdpy, pcontext, XPDocAttr, rec); +} + +/* Set page medium size + * Retun error if printer does not support setting a resolution or if per-page + * resolution changes are not allowed. + */ +int XpuSetPageResolution( Display *pdpy, XPContext pcontext, XpuResolutionRec *rec ) +{ + if( (XpuGetSupportedPageAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_DEFAULT_PRINTER_RESOLUTION) == 0 ) + return( 0 ); + + return XpuSetResolution(pdpy, pcontext, XPPageAttr, rec); +} + +XpuOrientationList XpuGetOrientationList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ) +{ + XpuOrientationList list = NULL; + int rec_count = 1; /* Allocate one more |XpuOrientationRec| + * structure as terminator */ + char *value; + char *tok_lasts; + const char *s; + const char *default_orientation = NULL; + int default_orientation_rec_index = -1; + + /* Get default document orientation */ + default_orientation = XpGetOneAttribute(pdpy, pcontext, XPDocAttr, "content-orientation"); + if( !default_orientation ) + { + fprintf(stderr, "XpuGetOrientationList: Internal error, no 'content-orientation' XPDocAttr found.\n"); + return(NULL); + } + + value = XpGetOneAttribute(pdpy, pcontext, XPPrinterAttr, "content-orientations-supported"); + if (!value) + { + fprintf(stderr, "XpuGetOrientationList: Internal error, no 'content-orientations-supported' XPPrinterAttr found.\n"); + return(NULL); + } + + for( s = strtok_r(value, " ", &tok_lasts) ; + s != NULL ; + s = strtok_r(NULL, " ", &tok_lasts) ) + { + rec_count++; + list = (XpuOrientationRec *)realloc(list, sizeof(XpuOrientationRec)*rec_count); + if( !list ) + return(NULL); + + list[rec_count-2].orientation = strdup(s); + + /* Default resolution ? */ + if( !strcmp(list[rec_count-2].orientation, default_orientation) ) + { + default_orientation_rec_index = rec_count-2; + } + } + + XFree(value); + XFree((void *)default_orientation); + + if( list ) + { + /* users: DO NOT COUNT ON THIS DETAIL + * (this is only to make current impl. of XpuFreeOrientationList() easier) + * I may remove this implementation detail in a later revision of + * the library! */ + list[rec_count-1].orientation = NULL; + rec_count--; + } + else + { + rec_count = 0; + } + + /* Make the default orientation always the first item in the list... */ + if( (default_orientation_rec_index != -1) && list ) + { + XpuOrientationRec tmp; + tmp = list[0]; + list[0] = list[default_orientation_rec_index]; + list[default_orientation_rec_index] = tmp; + } + + *numEntriesPtr = rec_count; + return(list); +} + +void XpuFreeOrientationList( XpuOrientationList list ) +{ + if( list ) + { + XpuOrientationRec *curr = list; + + /* See the warning abouve about using this implementation detail for + * checking for the list's end... */ + while( curr->orientation != NULL ) + { + free((void *)curr->orientation); + curr++; + } + free(list); + } +} + +XpuOrientationRec * +XpuFindOrientationByName( XpuOrientationList list, int list_count, const char *orientation ) +{ + int i; + + for( i = 0 ; i < list_count ; i++ ) + { + XpuOrientationRec *curr = &list[i]; + if (!strcasecmp(curr->orientation, orientation)) + return curr; + } + + return(NULL); +} + +static +int XpuSetOrientation( Display *pdpy, XPContext pcontext, XPAttributes type, XpuOrientationRec *rec ) +{ + XpuSetOneAttribute(pdpy, pcontext, type, "*content-orientation", rec->orientation, XPAttrMerge); + return(1); +} + +/* Set document orientation + * Retun error if printer does not support setting an orientation + */ +int XpuSetDocOrientation( Display *pdpy, XPContext pcontext, XpuOrientationRec *rec ) +{ + if( (XpuGetSupportedDocAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_CONTENT_ORIENTATION) == 0 ) + return( 0 ); + + return XpuSetOrientation(pdpy, pcontext, XPDocAttr, rec); +} + +/* Set page orientation + * Retun error if printer does not support setting an orientation or if + * per-page orientations changes are not allowed + */ +int XpuSetPageOrientation( Display *pdpy, XPContext pcontext, XpuOrientationRec *rec ) +{ + if( (XpuGetSupportedPageAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_CONTENT_ORIENTATION) == 0 ) + return( 0 ); + + return XpuSetOrientation(pdpy, pcontext, XPPageAttr, rec); +} + +XpuPlexList XpuGetPlexList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ) +{ + XpuPlexList list = NULL; + int rec_count = 1; /* Allocate one more |XpuPlexList| structure + * as terminator */ + char *value; + char *tok_lasts; + const char *s; + const char *default_plex = NULL; + int default_plex_rec_index = -1; + + /* Get default document plex */ + default_plex = XpGetOneAttribute(pdpy, pcontext, XPDocAttr, "plex"); + if( !default_plex ) + { + fprintf(stderr, "XpuGetPlexList: Internal error, no 'plex' XPDocAttr found.\n"); + return(NULL); + } + + value = XpGetOneAttribute(pdpy, pcontext, XPPrinterAttr, "plexes-supported"); + if (!value) + { + fprintf(stderr, "XpuGetPlexList: Internal error, no 'plexes-supported' XPPrinterAttr found.\n"); + return(NULL); + } + + for( s = strtok_r(value, " ", &tok_lasts) ; + s != NULL ; + s = strtok_r(NULL, " ", &tok_lasts) ) + { + rec_count++; + list = (XpuPlexRec *)realloc(list, sizeof(XpuPlexRec)*rec_count); + if( !list ) + return(NULL); + + list[rec_count-2].plex = strdup(s); + + /* Default plex ? */ + if( !strcmp(list[rec_count-2].plex, default_plex) ) + { + default_plex_rec_index = rec_count-2; + } + } + + XFree(value); + XFree((void *)default_plex); + + if( list ) + { + /* users: DO NOT COUNT ON THIS DETAIL + * (this is only to make current impl. of XpuFreePlexList() easier) + * I may remove this implementation detail in a later revision of + * the library! */ + list[rec_count-1].plex = NULL; + rec_count--; + } + else + { + rec_count = 0; + } + + /* Make the default plex always the first item in the list... */ + if( (default_plex_rec_index != -1) && list ) + { + XpuPlexRec tmp; + tmp = list[0]; + list[0] = list[default_plex_rec_index]; + list[default_plex_rec_index] = tmp; + } + + *numEntriesPtr = rec_count; + return(list); +} + +void XpuFreePlexList( XpuPlexList list ) +{ + if( list ) + { + XpuPlexRec *curr = list; + + /* See the warning abouve about using this implementation detail for + * checking for the list's end... */ + while( curr->plex != NULL ) + { + free((void *)curr->plex); + curr++; + } + free(list); + } +} + +XpuPlexRec * +XpuFindPlexByName( XpuPlexList list, int list_count, const char *plex ) +{ + int i; + + for( i = 0 ; i < list_count ; i++ ) + { + XpuPlexRec *curr = &list[i]; + if (!strcasecmp(curr->plex, plex)) + return curr; + } + + return(NULL); +} + +static +int XpuSetContentPlex( Display *pdpy, XPContext pcontext, XPAttributes type, XpuPlexRec *rec ) +{ + XpuSetOneAttribute(pdpy, pcontext, type, "*plex", rec->plex, XPAttrMerge); + return(1); +} + +/* Set document plex + * Retun error if printer does not support setting an plex + */ +int XpuSetDocPlex( Display *pdpy, XPContext pcontext, XpuPlexRec *rec ) +{ + if( (XpuGetSupportedDocAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_PLEX) == 0 ) + return( 0 ); + + return XpuSetContentPlex(pdpy, pcontext, XPDocAttr, rec); +} + +/* Set page plex + * Retun error if printer does not support setting an plex or if + * per-page plex changes are not allowed + */ +int XpuSetPagePlex( Display *pdpy, XPContext pcontext, XpuPlexRec *rec ) +{ + if( (XpuGetSupportedPageAttributes(pdpy, pcontext) & XPUATTRIBUTESUPPORTED_PLEX) == 0 ) + return( 0 ); + + return XpuSetContentPlex(pdpy, pcontext, XPPageAttr, rec); +} + + +XpuColorspaceList XpuGetColorspaceList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ) +{ + XpuColorspaceList list = NULL; + int rec_count = 1; /* Allocate one more |XpuColorspaceRec| structure + * as terminator */ + char namebuf[256]; /* Temporary name buffer for colorspace names */ + int i; /* Loop counter */ + int nvi; /* Number of visuals */ + Screen *pscreen; /* Print screen */ + XVisualInfo viproto; /* fill in for getting info */ + XVisualInfo *vip; /* retured info */ + + pscreen = XpGetScreenOfContext(pdpy, pcontext); + + nvi = 0; + viproto.screen = XScreenNumberOfScreen(pscreen); + vip = XGetVisualInfo(pdpy, VisualScreenMask, &viproto, &nvi); + if (!vip) + { + fprintf(stderr, "XpuGetColorspaceList: Internal error: vip == NULL\n"); + return NULL; + } + + for( i = 0 ; i < nvi ; i++ ) + { + XVisualInfo *vcurr = vip+i; + char cbuff[64]; + const char *class = NULL; + +#ifdef USE_MOZILLA_TYPES + /* Workaround for the current limitation of the gfx/src/xlibrgb code + * which cannot handle depths > 24bit yet */ + if( vcurr->depth > 24 ) + continue; +#endif /* USE_MOZILLA_TYPES */ + + rec_count++; + list = (XpuColorspaceRec *)realloc(list, sizeof(XpuColorspaceRec)*rec_count); + if( !list ) + return NULL; + + /* ToDO: This needs to be updated for the COLORSPACE X11 extension + * once it is ready and approved by the XOrg arch board. */ + switch (vcurr->class) { + case StaticGray: class = "StaticGray"; break; + case GrayScale: class = "GrayScale"; break; + case StaticColor: class = "StaticColor"; break; + case PseudoColor: class = "PseudoColor"; break; + case TrueColor: class = "TrueColor"; break; + case DirectColor: class = "DirectColor"; break; + default: /* Needed for forward compatibility to the COLORSPACE extension */ + sprintf (cbuff, "unknown_class_%x", vcurr->class); + class = cbuff; + break; + } + + if (vcurr->bits_per_rgb == 8) + { + sprintf(namebuf, "%s/%dbit", class, vcurr->depth); + } + else + { + sprintf(namebuf, "%s/%dbit/%dbpg", class, vcurr->depth, vcurr->bits_per_rgb); + } + list[rec_count-2].name = strdup(namebuf); + list[rec_count-2].visualinfo = *vcurr; + } + + XFree((char *)vip); + + if( list ) + { + /* users: DO NOT COUNT ON THIS DETAIL + * (this is only to make current impl. of XpuGetResolutionList() easier) + * We may remove this implementation detail in a later revision of + * the library! */ + list[rec_count-1].name = NULL; + rec_count--; + } + else + { + rec_count = 0; + } + + *numEntriesPtr = rec_count; + return(list); +} + +void XpuFreeColorspaceList( XpuColorspaceList list ) +{ + if( list ) + { + XpuColorspaceRec *curr = list; + + /* See the warning abouve about using this implementation detail for + * checking for the list's end... */ + while( curr->name != NULL ) + { + free((void *)curr->name); + curr++; + } + + free(list); + } +} + +XpuColorspaceRec * +XpuFindColorspaceByName( XpuColorspaceList list, int list_count, const char *name ) +{ + int i; + + for( i = 0 ; i < list_count ; i++ ) + { + XpuColorspaceRec *curr = &list[i]; + if (!strcmp(curr->name, name)) + return curr; + } + + return(NULL); +} + +Bool XpuGetEnableFontDownload( Display *pdpy, XPContext pcontext ) +{ + Bool enableFontDownload; + char *value; + + value = XpGetOneAttribute(pdpy, pcontext, XPPrinterAttr, "xp-listfonts-modes-supported"); + if( !value ) + { + fprintf(stderr, "XpuGetEnableFontDownload: xp-listfonts-modes-supported printer attribute not found.\n"); + return False; + } + + enableFontDownload = (strstr(value, "xp-list-glyph-fonts") != NULL); + XFree(value); + return enableFontDownload; +} + +int XpuSetEnableFontDownload( Display *pdpy, XPContext pcontext, Bool enableFontDownload ) +{ + char *value, + *newvalue; + + value = XpGetOneAttribute(pdpy, pcontext, XPPrinterAttr, "xp-listfonts-modes-supported"); + if( !value ) + { + fprintf(stderr, "XpuSetEnableFontDownload: xp-listfonts-modes-supported printer attribute not found.\n"); + return 0; /* failure */ + } + + /* Set "xp-list-glyph-fonts" */ + if( enableFontDownload ) + { + /* Return success if "xp-list-glyph-fonts" is already set */ + if( strstr(value, "xp-list-glyph-fonts") != NULL ) + { + XFree(value); + return 1; /* success */ + } + + newvalue = malloc(strlen(value) + 33); + if( !newvalue ) + { + XFree(value); + return 0; /* failure */ + } + + sprintf(newvalue, "%s xp-list-glyph-fonts", value); + XpuSetOneAttribute(pdpy, pcontext, XPDocAttr, "*xp-listfonts-modes", newvalue, XPAttrMerge); + + free(newvalue); + XFree(value); + return 1; /* success */ + } + else + { + char *s, /* copy string "source" */ + *d; /* copy string "destination" */ + + /* Return success if "xp-list-glyph-fonts" not set */ + d = strstr(value, "xp-list-glyph-fonts"); + if( d == NULL ) + { + XFree(value); + return 1; /* success */ + } + + /* strip "xp-list-glyph-fonts" from |value| */ + s = d+19/*strlen("xp-list-glyph-fonts")*/; + while( (*d++ = *s++) != '\0' ) + ; + + XpuSetOneAttribute(pdpy, pcontext, XPDocAttr, "*xp-listfonts-modes", value, XPAttrMerge); + + XFree(value); + return 1; /* success */ + } +} + +/* Return flags to indicate which attributes are supported and which not... */ +static +XpuSupportedFlags XpuGetSupportedAttributes( Display *pdpy, XPContext pcontext, XPAttributes type, const char *attribute_name ) +{ + char *value; + void *tok_lasts; + XpuSupportedFlags flags = 0; + + MAKE_STRING_WRITABLE(attribute_name); + if( attribute_name == NULL ) + return(0); + + value = XpGetOneAttribute(pdpy, pcontext, type, STRING_AS_WRITABLE(attribute_name)); + + FREE_WRITABLE_STRING(attribute_name); + + if( value != NULL ) + { + const char *s; + + for( s = XpuEnumerateXpAttributeValue(value, &tok_lasts) ; s != NULL ; s = XpuEnumerateXpAttributeValue(NULL, &tok_lasts) ) + { + if( !strcmp(s, "job-name") ) flags |= XPUATTRIBUTESUPPORTED_JOB_NAME; + else if( !strcmp(s, "job-owner") ) flags |= XPUATTRIBUTESUPPORTED_JOB_OWNER; + else if( !strcmp(s, "notification-profile") ) flags |= XPUATTRIBUTESUPPORTED_NOTIFICATION_PROFILE; + else if( !strcmp(s, "copy-count") ) flags |= XPUATTRIBUTESUPPORTED_COPY_COUNT; + else if( !strcmp(s, "document-format") ) flags |= XPUATTRIBUTESUPPORTED_DOCUMENT_FORMAT; + else if( !strcmp(s, "content-orientation") ) flags |= XPUATTRIBUTESUPPORTED_CONTENT_ORIENTATION; + else if( !strcmp(s, "default-printer-resolution") ) flags |= XPUATTRIBUTESUPPORTED_DEFAULT_PRINTER_RESOLUTION; + else if( !strcmp(s, "default-input-tray") ) flags |= XPUATTRIBUTESUPPORTED_DEFAULT_INPUT_TRAY; + else if( !strcmp(s, "default-medium") ) flags |= XPUATTRIBUTESUPPORTED_DEFAULT_MEDIUM; + else if( !strcmp(s, "plex") ) flags |= XPUATTRIBUTESUPPORTED_PLEX; + else if( !strcmp(s, "xp-listfonts-modes") ) flags |= XPUATTRIBUTESUPPORTED_LISTFONTS_MODES; + } + + XpuDisposeEnumerateXpAttributeValue(&tok_lasts); + XFree(value); + } + + return(flags); +} + +XpuSupportedFlags XpuGetSupportedJobAttributes(Display *pdpy, XPContext pcontext) +{ + return XpuGetSupportedAttributes(pdpy, pcontext, XPPrinterAttr, "job-attributes-supported"); +} + +XpuSupportedFlags XpuGetSupportedDocAttributes(Display *pdpy, XPContext pcontext) +{ + return XpuGetSupportedAttributes(pdpy, pcontext, XPPrinterAttr, "document-attributes-supported"); +} + +XpuSupportedFlags XpuGetSupportedPageAttributes(Display *pdpy, XPContext pcontext) +{ + return XpuGetSupportedAttributes(pdpy, pcontext, XPPrinterAttr, "xp-page-attributes-supported"); +} + +/* Encode string for usage in a Xrm resource database as + * defined in X(7): [...] To allow a Value to begin + * with whitespace, the two-character sequence ``\space'' + * (backslash followed by space) is recognized and replaced by + * a space character, and the two-character sequence ``\tab'' + * (backslash followed by horizontal tab) is recognized and + * replaced by a horizontal tab character. To allow a Value to + * contain embedded newline characters, the two-character + * sequence ``\n'' is recognized and replaced by a newline + * character. To allow a Value to be broken across multiple + * lines in a text file, the two-character sequence ``\new- + * line'' (backslash followed by newline) is recognized and + * removed from the value. To allow a Value to contain arbi- + * trary character codes, the four-character sequence ``\nnn'', + * where each n is a digit character in the range of + * ``0''-``7'', is recognized and replaced with a single byte + * that contains the octal value specified by the sequence. + * Finally, the two-character sequence ``\\'' is recognized and + * replaced with a single backslash. + */ +char *XpuResourceEncode( const char *s ) +{ + size_t slen; + char *res; + char *d; + int i, + c; + + slen = strlen(s); + res = malloc(slen*4+1); + if (!res) + return NULL; + + d = res; + i = slen; + while (i--) { + c = *s++; + if (c == '\n') { + if (i) { + *d++ = '\\'; + *d++ = 'n'; + *d++ = '\\'; + *d++ = '\n'; + } + else { + *d++ = '\\'; + *d++ = 'n'; + } + } else if (c == '\\') { + *d++ = '\\'; + *d++ = '\\'; + } + else if ((c < ' ' && c != '\t') || + ((unsigned char)c >= 0x7F && (unsigned char)c < 0xA0)) { + sprintf(d, "\\%03o", (unsigned char)c); + d += 4; + } + else { + *d++ = c; + } + } + + *d = '\0'; + + return res; +} + +#ifdef XXXJULIEN_NOTNOW +char *XpuResourceDecode( const char *str ) +{ +} +#endif /* XXXJULIEN_NOTNOW */ + +void XpuResourceFreeString( char *s ) +{ + free(s); +} + +const char *XpuXmbToCompoundText(Display *dpy, const char *xmbtext) +{ + XTextProperty xtp; + int xcr; + char *xtl[2]; + char *ct; + + if (strlen(xmbtext) == 0) + return strdup(xmbtext); + + memset(&xtp, 0, sizeof(xtp)); + xtl[0] = (char *)xmbtext; + xtl[1] = NULL; + + xcr = XmbTextListToTextProperty(dpy, xtl, 1, XCompoundTextStyle, &xtp); + + if (xcr == XNoMemory || xcr == XLocaleNotSupported) + { + fprintf(stderr, "XpuXmbToCompoundText: XmbTextListToTextProperty failure.\n"); + return strdup(xmbtext); + } + + /* Did conversion succeed (some unconvertible characters + * are not a problem) ? */ + if ( !((xcr == Success) || (xcr > 0)) || + (xtp.value == NULL)) + { + fprintf(stderr, "XpuXmbToCompoundText: XmbTextListToTextProperty failure 2.\n"); + return strdup(xmbtext); + } + + ct = malloc(xtp.nitems+1); + if (!ct) + { + XFree(xtp.value); + return NULL; + } + memcpy(ct, xtp.value, xtp.nitems); + ct[xtp.nitems] = '\0'; + + XFree(xtp.value); + + return ct; +} + +void XpuFreeCompundTextString( const char *s ) +{ + free((void *)s); +} + +const char *XpuCompoundTextToXmb(Display *dpy, const char *ct) +{ + XTextProperty xtp; + int xcr; + char **xtl = NULL; + int xtl_count = 0; + char *xmb; + int xmb_len = 0; + int i; + + if (strlen(ct) == 0) + return strdup(ct); + + xtp.value = (unsigned char *)ct; + xtp.nitems = strlen(ct); + xtp.encoding = XInternAtom(dpy, "COMPOUND_TEXT", False); + xtp.format = 8; + + xcr = XmbTextPropertyToTextList(dpy, &xtp, &xtl, &xtl_count); + + if (xcr == XNoMemory || xcr == XLocaleNotSupported) + { + fprintf(stderr, "XpuCompoundTextToXmb: XmbTextPropertyToTextList failure 1.\n"); + return strdup(ct); + } + + /* Did conversion succeed (some unconvertible characters + * are not a problem) ? */ + if ( !((xcr == Success) || (xcr > 0)) || + (xtl == NULL)) + { + fprintf(stderr, "XpuCompoundTextToXmb: XmbTextPropertyToTextList failure 2.\n"); + return strdup(ct); + } + + for (i = 0; i < xtl_count; i++) + { + xmb_len += strlen(xtl[i]); + } + xmb = malloc (xmb_len + 1); + if (!xmb) + { + XFreeStringList(xtl); + return NULL; + } + xmb[0] = '\0'; /* Catch zero-length case */ + for (i = 0; i < xtl_count; i++) + { + strcat(xmb, xtl[i]); + } + + XFreeStringList(xtl); + + return xmb; +} + +void XpuFreeXmbString( const char *s ) +{ + free((void *)s); +} + +/* EOF. */ diff --git a/nx-X11/lib/XprintUtil/xprintutil.h b/nx-X11/lib/XprintUtil/xprintutil.h new file mode 100644 index 000000000..e4cc7c640 --- /dev/null +++ b/nx-X11/lib/XprintUtil/xprintutil.h @@ -0,0 +1,250 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +#ifndef XPRINTUTIL_H +#define XPRINTUTIL_H 1 +/****************************************************************************** + ****************************************************************************** + ** + ** (c) Copyright 2001-2004 Roland Mainz <roland.mainz@nrubsig.org> + ** + ** Permission is hereby granted, free of charge, to any person obtaining a copy + ** of this software and associated documentation files (the "Software"), to deal + ** in the Software without restriction, including without limitation the rights + ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + ** copies of the Software, and to permit persons to whom the Software is + ** furnished to do so, subject to the following conditions: + ** + ** The above copyright notice and this permission notice shall be included in + ** all copies or substantial portions of the Software. + ** + ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + ** COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + ** IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + ** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + ** + ** Except as contained in this notice, the names of the copyright holders shall + ** not be used in advertising or otherwise to promote the sale, use or other + ** dealings in this Software without prior written authorization from said + ** copyright holders. + ** + ****************************************************************************** + *****************************************************************************/ + +/* Force ANSI C prototypes from X11 headers */ +#ifndef FUNCPROTO +#define FUNCPROTO 15 +#endif /* !FUNCPROTO */ + +#include <X11/Xlibint.h> +#include <X11/extensions/Print.h> +#include <X11/Intrinsic.h> + +/* I don't know how to make this "better" yet... ;-( */ +#ifdef USE_MOZILLA_TYPES +#include <prtypes.h> +#include <prmem.h> +#include <prthread.h> +#define XPU_USE_NSPR 1 +/* + * Disabled for now - Threaded codepath does not work properly always. + * See bug 134570 ("Print-to-file not working with threaded XprintUtil") + * #define XPU_USE_THREADS 1 + */ +#endif /* USE_MOZILLA_TYPES */ + +#ifdef DEBUG +/* trace function calls */ +#define XPU_TRACE(EX) (puts(#EX),EX) +/* trace function calls in child */ +#define XPU_TRACE_CHILD(EX) (puts("child: " #EX),EX) +/* execute function EX only in debug mode */ +#define XPU_DEBUG_ONLY(EX) (EX) +#else +#define XPU_TRACE(EX) (EX) +#define XPU_TRACE_CHILD(EX) (EX) +#define XPU_DEBUG_ONLY(EX) +#endif /* DEBUG */ + +/* debug/logging: replace NULLptrs with "<NULL>" string */ +#define XPU_NULLXSTR(s) (((s)!=NULL)?(s):("<NULL>")) + +/* + * Struct for XpuGetMediumSourceSizeList(), XpuFreeMediumSourceSizeList(), + * XpuSetDocMediumSourceSize(), XpuSetPageMediumSourceSize(), + * XpuFindMediumSourceSizeBy*() + */ +typedef struct { + const char *tray_name; + const char *medium_name; + int mbool; + float ma1; + float ma2; + float ma3; + float ma4; +} XpuMediumSourceSizeRec, *XpuMediumSourceSizeList; + +/* + * Struct for XpuGetResolutionList(), XpuFreeResolutionList(), + * XpuGetResolution(), XpuSetPageResolution(), XpuSetDocResolution(), + * XpuFindResolutionByName() + */ +typedef struct { + const char *name; + long x_dpi; + long y_dpi; +} XpuResolutionRec, *XpuResolutionList; + +/* + * Struct for XpuGetOrientationList(), XpuFreeOrientationList(), + * XpuFindOrientationBy*(), XpuSetPageResolution(), + * XpuSetDocOrientation() + */ +typedef struct { + const char *orientation; +} XpuOrientationRec, *XpuOrientationList; + +/* + * Struct for XpuGetPlexList(), XpuFreePlexList(), XpuFindPlexBy*(), + * XpuSetDocPlex(), XpuSetPagePlex() + */ +typedef struct { + const char *plex; +} XpuPlexRec, *XpuPlexList; + +/* + * Struct for XpuGetColorspaceList(), XpuFreeColorspaceList() + */ +typedef struct +{ + const char *name; + XVisualInfo visualinfo; +} XpuColorspaceRec, *XpuColorspaceList; + +/* XPUATTRIBUTESUPPORTED_*: + * Flags which indicate whether it is allowed to set/change a specific attribute + */ +typedef long XpuSupportedFlags; +/* Job attributes */ +#define XPUATTRIBUTESUPPORTED_JOB_NAME (1L<<0) +#define XPUATTRIBUTESUPPORTED_JOB_OWNER (1L<<1) +#define XPUATTRIBUTESUPPORTED_NOTIFICATION_PROFILE (1L<<2) +/* Document/Page attributes */ +#define XPUATTRIBUTESUPPORTED_COPY_COUNT (1L<<3) +#define XPUATTRIBUTESUPPORTED_DOCUMENT_FORMAT (1L<<4) +#define XPUATTRIBUTESUPPORTED_CONTENT_ORIENTATION (1L<<5) +#define XPUATTRIBUTESUPPORTED_DEFAULT_PRINTER_RESOLUTION (1L<<6) +#define XPUATTRIBUTESUPPORTED_DEFAULT_INPUT_TRAY (1L<<7) +#define XPUATTRIBUTESUPPORTED_DEFAULT_MEDIUM (1L<<8) +#define XPUATTRIBUTESUPPORTED_PLEX (1L<<9) +#define XPUATTRIBUTESUPPORTED_LISTFONTS_MODES (1L<<10) + +/* prototypes */ +_XFUNCPROTOBEGIN + +int XpuCheckExtension( Display *pdpy ); + +/* Create/destroy connection to printer */ +Bool XpuXprintServersAvailable( void ); +int XpuGetPrinter( const char *printername, Display **pdpyptr, XPContext *pcontextptr ); +void XpuClosePrinterDisplay(Display *pdpy, XPContext pcontext); + +/* Misc. functions */ +void XpuSetOneAttribute( Display *pdpy, XPContext pcontext, + XPAttributes type, const char *attribute_name, const char *value, XPAttrReplacement replacement_rule ); +void XpuSetOneLongAttribute( Display *pdpy, XPContext pcontext, + XPAttributes type, const char *attribute_name, long value, XPAttrReplacement replacement_rule ); +int XpuCheckSupported( Display *pdpy, XPContext pcontext, XPAttributes type, const char *attribute_name, const char *query ); +int XpuSetJobTitle( Display *pdpy, XPContext pcontext, const char *title ); +int XpuGetOneLongAttribute( Display *pdpy, XPContext pcontext, XPAttributes type, const char *attribute_name, long *result ); +#ifdef DEBUG +void dumpXpAttributes( Display *pdpy, XPContext pcontext ); +#endif /* DEBUG */ +void XpuWaitForPrintNotify( Display *pdpy, int xp_event_base, int detail ); + +/* Get list of printers */ +XPPrinterList XpuGetPrinterList( const char *printer, int *res_list_count ); +void XpuFreePrinterList( XPPrinterList list ); + +/* Set number of document copies */ +int XpuSetDocumentCopies( Display *pdpy, XPContext pcontext, long num_copies ); + +/* Get/Set/Query supported mediums (paper sizes) */ +XpuMediumSourceSizeList XpuGetMediumSourceSizeList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ); +void XpuFreeMediumSourceSizeList( XpuMediumSourceSizeList list ); +int XpuSetDocMediumSourceSize( Display *pdpy, XPContext pcontext, XpuMediumSourceSizeRec *medium_spec ); +int XpuSetPageMediumSourceSize( Display *pdpy, XPContext pcontext, XpuMediumSourceSizeRec *medium_spec ); +XpuMediumSourceSizeRec * +XpuFindMediumSourceSizeBySize( XpuMediumSourceSizeList mlist, int mlist_count, + float page_width_mm, float page_height_mm, float tolerance ); +XpuMediumSourceSizeRec * +XpuFindMediumSourceSizeByBounds( XpuMediumSourceSizeList mlist, int mlist_count, + float m1, float m2, float m3, float m4, float tolerance ); +XpuMediumSourceSizeRec * +XpuFindMediumSourceSizeByName( XpuMediumSourceSizeList mlist, int mlist_count, + const char *tray_name, const char *medium_name ); + +/* Get/Set resolution */ +XpuResolutionList XpuGetResolutionList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ); +void XpuFreeResolutionList( XpuResolutionList list ); +Bool XpuGetResolution( Display *pdpy, XPContext pcontext, long *x_dpi, long *y_dpi ); +Bool XpuSetPageResolution( Display *pdpy, XPContext pcontext, XpuResolutionRec * ); +Bool XpuSetDocResolution( Display *pdpy, XPContext pcontext, XpuResolutionRec * ); +XpuResolutionRec *XpuFindResolutionByName( XpuResolutionList list, int list_count, const char *resolution_name); + +/* Get/Set orientation */ +XpuOrientationList XpuGetOrientationList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ); +void XpuFreeOrientationList( XpuOrientationList list ); +XpuOrientationRec * +XpuFindOrientationByName( XpuOrientationList list, int list_count, const char *orientation ); +int XpuSetDocOrientation( Display *pdpy, XPContext pcontext, XpuOrientationRec *rec ); +int XpuSetPageOrientation( Display *pdpy, XPContext pcontext, XpuOrientationRec *rec ); + +/* Get/set plex modes */ +XpuPlexList XpuGetPlexList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ); +void XpuFreePlexList( XpuPlexList list ); +XpuPlexRec *XpuFindPlexByName( XpuPlexList list, int list_count, const char *plex ); +int XpuSetDocPlex( Display *pdpy, XPContext pcontext, XpuPlexRec *rec ); +int XpuSetPagePlex( Display *pdpy, XPContext pcontext, XpuPlexRec *rec ); + +/* Set/get usage of fonts */ +Bool XpuGetEnableFontDownload( Display *pdpy, XPContext pcontext ); +int XpuSetEnableFontDownload( Display *pdpy, XPContext pcontext, Bool enableFontDownload ); + +/* Get per-printer colorspace information */ +XpuColorspaceList XpuGetColorspaceList( Display *pdpy, XPContext pcontext, int *numEntriesPtr ); +void XpuFreeColorspaceList( XpuColorspaceList list ); +XpuColorspaceRec *XpuFindColorspaceByName( XpuColorspaceList list, int list_count, const char *colorspace ); + +/* Start job to printer (spooler) or file */ +void XpuStartJobToSpooler(Display *pdpy); +void *XpuStartJobToFile( Display *pdpy, XPContext pcontext, const char *filename ); +XPGetDocStatus XpuWaitForPrintFileChild( void *handle ); + +/* Get flags which indicate whether it is allowed to set/change a specific attribute */ +XpuSupportedFlags XpuGetSupportedJobAttributes(Display *pdpy, XPContext pcontext); +XpuSupportedFlags XpuGetSupportedDocAttributes(Display *pdpy, XPContext pcontext); +XpuSupportedFlags XpuGetSupportedPageAttributes(Display *pdpy, XPContext pcontext); + +/* Encode/decode resource strings */ +char *XpuResourceEncode( const char *str ); +char *XpuResourceDecode( const char *str ); +void XpuResourceFreeString( char *s ); + +/* COMPOUND_TEXT <----> local encoding string converters */ +const char *XpuXmbToCompoundText(Display *dpy, const char *xmbtext); +void XpuFreeCompundTextString( const char *s ); +const char *XpuCompoundTextToXmb(Display *dpy, const char *ct); +void XpuFreeXmbString( const char *s ); + + +_XFUNCPROTOEND + +#define XpuGetJobAttributes( pdpy, pcontext ) XpGetAttributes( (pdpy), (pcontext), XPJobAttr ) +#define XpuGetDocAttributes( pdpy, pcontext ) XpGetAttributes( (pdpy), (pcontext), XPDocAttr ) +#define XpuGetPageAttributes( pdpy, pcontext ) XpGetAttributes( (pdpy), (pcontext), XPPageAttr ) +#define XpuGetPrinterAttributes( pdpy, pcontext ) XpGetAttributes( (pdpy), (pcontext), XPPrinterAttr ) +#define XpuGetServerAttributes( pdpy, pcontext ) XpGetAttributes( (pdpy), (pcontext), XPServerAttr ) + +#endif /* !XPRINTUTIL_H */ +/* EOF. */ diff --git a/nx-X11/lib/XprintUtil/xprintutil_printtofile.c b/nx-X11/lib/XprintUtil/xprintutil_printtofile.c new file mode 100644 index 000000000..331e7ad5b --- /dev/null +++ b/nx-X11/lib/XprintUtil/xprintutil_printtofile.c @@ -0,0 +1,498 @@ +/****************************************************************************** + ****************************************************************************** + ** + ** (c) Copyright 2001-2004 Roland Mainz <roland.mainz@nrubsig.org> + ** + ** Permission is hereby granted, free of charge, to any person obtaining a copy + ** of this software and associated documentation files (the "Software"), to deal + ** in the Software without restriction, including without limitation the rights + ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + ** copies of the Software, and to permit persons to whom the Software is + ** furnished to do so, subject to the following conditions: + ** + ** The above copyright notice and this permission notice shall be included in + ** all copies or substantial portions of the Software. + ** + ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + ** COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + ** IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + ** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + ** + ** Except as contained in this notice, the names of the copyright holders shall + ** not be used in advertising or otherwise to promote the sale, use or other + ** dealings in this Software without prior written authorization from said + ** copyright holders. + ** + ****************************************************************************** + *****************************************************************************/ + +#include "xprintutil.h" + +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <limits.h> +#include <errno.h> +#ifdef XPU_USE_THREADS +#include <time.h> +#ifdef XPU_USE_NSPR +#include <prthread.h> +#else +#include <pthread.h> +#endif /* XPU_USE_NSPR */ +#endif /* XPU_USE_THREADS */ +#include <unistd.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/wait.h> + +/* local prototypes */ +#ifdef DEBUG +static void PrintXPGetDocStatus( XPGetDocStatus status ); +#endif +static Bool XNextEventTimeout( Display *display, XEvent *event_return, struct timeval *timeout ); +static void *XpuPrintToFile( Display *pdpy, XPContext pcontext, const char *filename ); +static void MyPrintToFileProc( Display *pdpy, XPContext pcontext, unsigned char *data, unsigned int data_len, XPointer client_data ); +static void MyFinishProc( Display *pdpy, XPContext pcontext, XPGetDocStatus status, XPointer client_data ); +#ifdef XPU_USE_NSPR +static void PrintToFile_Consumer( void *handle ); +#else +static void *PrintToFile_Consumer( void *handle ); +#endif + +void XpuStartJobToSpooler(Display *pdpy) +{ + XpStartJob(pdpy, XPSpool); +} + +void *XpuStartJobToFile( Display *pdpy, XPContext pcontext, const char *filename ) +{ + void *handle; + + XpStartJob(pdpy, XPGetData); + handle = XpuPrintToFile(pdpy, pcontext, filename); + + if (!handle) + { + /* Cancel the print job and discard all events... */ + XpCancelJob(pdpy, True); + } + + return(handle); +} + +#ifdef DEBUG +/* DEBUG: Print XPGetDocStatus */ +static +void PrintXPGetDocStatus( XPGetDocStatus status ) +{ + switch(status) + { + case XPGetDocFinished: puts("PrintXPGetDocStatus: XPGetDocFinished"); break; + case XPGetDocSecondConsumer: puts("PrintXPGetDocStatus: XPGetDocSecondConsumer"); break; + case XPGetDocError: puts("PrintXPGetDocStatus: XPGetDocError"); break; + default: puts("PrintXPGetDocStatus: <unknown value"); break; + } +} +#endif /* DEBUG */ + + +/* XNextEvent() with timeout */ +static +Bool XNextEventTimeout( Display *display, XEvent *event_return, struct timeval *timeout ) +{ + int res; + fd_set readfds; + int display_fd = XConnectionNumber(display); + + /* small shortcut... */ + if( timeout == NULL ) + { + XNextEvent(display, event_return); + return(True); + } + + FD_ZERO(&readfds); + FD_SET(display_fd, &readfds); + + /* Note/bug: In the case of internal X events (like used to trigger callbacks + * registered by XpGetDocumentData()&co.) select() will return with "new info" + * - but XNextEvent() below processes these _internal_ events silently - and + * will block if there are no other non-internal events. + * The workaround here is to check with XEventsQueued() if there are non-internal + * events queued - if not select() will be called again - unfortunately we use + * the old timeout here instead of the "remaining" time... (this only would hurt + * if the timeout would be really long - but for current use with values below + * 1/2 secs it does not hurt... =:-) + */ + while( XEventsQueued(display, QueuedAfterFlush) == 0 ) + { + res = select(display_fd+1, &readfds, NULL, NULL, timeout); + + switch(res) + { + case -1: /* select() error - should not happen */ + perror("XNextEventTimeout: select() failure"); + return(False); + case 0: /* timeout */ + return(False); + } + } + + XNextEvent(display, event_return); + return(True); +} + + +#ifdef XPU_USE_THREADS +/** + ** XpuPrintToFile() - threaded version + ** Create consumer thread which creates it's own display connection to print server + ** (a 2nd display connection/thread is required to avoid deadlocks within Xlib), + ** registers (Xlib-internal) consumer callback (via XpGetDocumentData(3Xp)) and + ** processes/eats all incoming events via MyPrintToFileProc(). A final call to + ** MyPrintToFileProc() cleans-up all stuff and sets the "done" flag. + ** Note that these callbacks are called directly by Xlib while waiting for events in + ** XNextEvent() because XpGetDocumentData() registeres them as "internal" callbacks, + ** e.g. XNextEvent() does _not_ return before/after processing these events !! + ** + ** Usage: + ** XpStartJob(pdpy, XPGetData); + ** handle = XpuPrintToFile(pdpy, pcontext, "myfile"); + ** // render something + ** XpEndJob(); // or XpCancelJob() + ** status = XpuWaitForPrintFileChild(handle); + ** + */ + +typedef struct +{ +#ifdef XPU_USE_NSPR + PRThread *prthread; +#else + pthread_t tid; +#endif + char *displayname; + Display *pdpy; + Display *parent_pdpy; + XPContext pcontext; + const char *file_name; + FILE *file; + XPGetDocStatus status; + Bool done; +} MyPrintFileData; + + +static +void *XpuPrintToFile( Display *pdpy, XPContext pcontext, const char *filename ) +{ + MyPrintFileData *mpfd; /* warning: shared between threads !! */ + + if( (mpfd = malloc(sizeof(MyPrintFileData))) == NULL ) + return(NULL); + + mpfd->parent_pdpy = pdpy; + mpfd->displayname = XDisplayString(pdpy); + mpfd->pdpy = NULL; + mpfd->pcontext = pcontext; + mpfd->file_name = filename; + mpfd->file = NULL; + mpfd->status = XPGetDocError; + + /* make sure we can open the file for writing */ + if( (mpfd->file = fopen(mpfd->file_name, "w")) == NULL ) + { + /* fopen() error */ + free(mpfd); + return(NULL); + } + + /* its important to flush before we start the consumer thread, + * to make sure that the XpStartJob gets through first in the parent + */ + XFlush(pdpy); +#ifdef XPU_USE_NSPR + if( (mpfd->prthread = PR_CreateThread(PR_SYSTEM_THREAD, PrintToFile_Consumer, mpfd, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0)) == NULL ) +#else + if( pthread_create(&(mpfd->tid), NULL, PrintToFile_Consumer, mpfd) != 0 ) +#endif + { + /* pthread_create() error */ + fclose(mpfd->file); + free(mpfd); + return(NULL); + } + + /* we're still in the parent */ + XPU_DEBUG_ONLY(printf("### parent started consumer thread.\n" )); + return(mpfd); +} + + +XPGetDocStatus XpuWaitForPrintFileChild( void *handle ) +{ + MyPrintFileData *mpfd = (MyPrintFileData *)handle; + void *res; + XPGetDocStatus status; + + /* Flush data a last time to make sure we send all data to Xprt and that + * the Xlib internal hooks have called a last time */ + XFlush(mpfd->parent_pdpy); + +#ifdef XPU_USE_NSPR + if( PR_JoinThread(mpfd->prthread) != PR_SUCCESS ) + perror("XpuWaitForPrintFileChild: PR_JoinThread() failure"); /* fixme(later): use NSPR error handling calls... */ +#else + if( XPU_TRACE(pthread_join(mpfd->tid, &res)) != 0 ) + perror("XpuWaitForPrintFileChild: pthread_join() failure"); +#endif + + status = mpfd->status; + free(handle); + + XPU_DEBUG_ONLY(PrintXPGetDocStatus(status)); + return(status); +} + +#else /* XPU_USE_THREADS */ +/** + ** XpuPrintToFile() - fork() version + ** Create consumer thread which creates it's own display connection to print server + ** (a 2nd display connection/process is required to avoid deadlocks within Xlib), + ** registers (Xlib-internal) consumer callback (via XpGetDocumentData(3Xp)) and + ** processes/eats all incoming events via MyPrintToFileProc(). A final call to + ** MyPrintToFileProc() cleans-up all stuff and sets the "done" flag. + ** Note that these callbacks are called directly by Xlib while waiting for events in + ** XNextEvent() because XpGetDocumentData() registeres them as "internal" callbacks, + ** e.g. XNextEvent() does _not_ return before/after processing these events !! + ** + ** Usage: + ** XpStartJob(pdpy, XPGetData); + ** handle = XpuPrintToFile(pdpy, pcontext, "myfile"); + ** // render something + ** XpEndJob(); // or XpCancelJob() + ** status = XpuWaitForPrintFileChild(handle); + ** + */ +typedef struct +{ + pid_t pid; + int pipe[2]; /* child-->parent communication pipe */ + const char *displayname; + Display *pdpy; + Display *parent_pdpy; + XPContext pcontext; + const char *file_name; + FILE *file; + XPGetDocStatus status; + Bool done; +} MyPrintFileData; + + +static +void *XpuPrintToFile( Display *pdpy, XPContext pcontext, const char *filename ) +{ + MyPrintFileData *mpfd; + + if( (mpfd = (MyPrintFileData *)malloc(sizeof(MyPrintFileData))) == NULL ) + return(NULL); + + /* create pipe */ + if( pipe(mpfd->pipe) == -1 ) + { + /* this should never happen, but... */ + perror("XpuPrintToFile: cannot create pipe"); + free(mpfd); + return(NULL); + } + + mpfd->parent_pdpy = pdpy; + mpfd->displayname = XDisplayString(pdpy); + mpfd->pcontext = pcontext; + mpfd->file_name = filename; + mpfd->file = NULL; + mpfd->status = XPGetDocError; + + /* make sure we can open the file for writing */ + if( (mpfd->file = fopen(mpfd->file_name, "w")) == NULL ) + { + /* fopen() error */ + close(mpfd->pipe[1]); + close(mpfd->pipe[0]); + free(mpfd); + return(NULL); + } + + /* its important to flush before we fork, to make sure that the + * XpStartJob gets through first in the parent + */ + XFlush(pdpy); + + mpfd->pid = fork(); + + if( mpfd->pid == 0 ) + { + /* we're now in the fork()'ed child */ + PrintToFile_Consumer(mpfd); + } + else if( mpfd->pid < 0 ) + { + /* fork() error */ + close(mpfd->pipe[1]); + close(mpfd->pipe[0]); + fclose(mpfd->file); + free(mpfd); + return(NULL); + } + + /* we're still in the parent */ + XPU_DEBUG_ONLY(printf("### parent fork()'ed consumer child.\n")); + + /* child will write into file - we don't need it anymore here... :-) */ + fclose(mpfd->file); + close(mpfd->pipe[1]); + return(mpfd); +} + + +XPGetDocStatus XpuWaitForPrintFileChild( void *handle ) +{ + MyPrintFileData *mpfd = (MyPrintFileData *)handle; + int res; + XPGetDocStatus status = XPGetDocError; /* used when read() from pipe fails */ + + /* Flush data a last time to make sure we send all data to Xprt and that + * the Xlib internal hooks have called a last time */ + XFlush(mpfd->parent_pdpy); + + if( XPU_TRACE(waitpid(mpfd->pid, &res, 0)) == -1 ) + perror("XpuWaitForPrintFileChild: waitpid failure"); + + /* read the status from the child */ + if( read(mpfd->pipe[0], &status, sizeof(XPGetDocStatus)) != sizeof(XPGetDocStatus) ) + { + perror("XpuWaitForPrintFileChild: can't read XPGetDocStatus"); + } + close(mpfd->pipe[0]); + + free(handle); + + XPU_DEBUG_ONLY(PrintXPGetDocStatus(status)); + return(status); +} +#endif /* XPU_USE_THREADS */ + + +static +void MyPrintToFileProc( Display *pdpy, + XPContext pcontext, + unsigned char *data, + unsigned int data_len, + XPointer client_data ) +{ + MyPrintFileData *mpfd = (MyPrintFileData *)client_data; + + /* write to the file */ + XPU_TRACE_CHILD((void)fwrite(data, data_len, 1, mpfd->file)); /* what about error handling ? */ +} + + +static +void MyFinishProc( Display *pdpy, + XPContext pcontext, + XPGetDocStatus status, + XPointer client_data ) +{ + MyPrintFileData *mpfd = (MyPrintFileData *)client_data; + + /* remove the file if unsuccessful */ + if( status != XPGetDocFinished ) + { + XPU_DEBUG_ONLY(printf("MyFinishProc: error %d\n", (int)status)); + XPU_TRACE_CHILD(remove(mpfd->file_name)); + } + + XPU_TRACE_CHILD((void)fclose(mpfd->file)); /* what about error handling ? */ + + mpfd->status = status; + mpfd->done = True; +} + + +static +#ifdef XPU_USE_NSPR +void PrintToFile_Consumer( void *handle ) +#else +void *PrintToFile_Consumer( void *handle ) +#endif +{ + MyPrintFileData *mpfd = (MyPrintFileData *)handle; + XEvent dummy; + struct timeval timeout; + + timeout.tv_sec = 0; + timeout.tv_usec = 100000; /* 1/10 s */ + + XPU_DEBUG_ONLY(printf("### child running, getting data from '%s'.\n", mpfd->displayname)); + + /* we cannot reuse fork()'ed display handles - our child needs his own one */ + if( (mpfd->pdpy = XPU_TRACE_CHILD(XOpenDisplay(mpfd->displayname))) == NULL ) + { + perror("child cannot open display"); +#ifdef XPU_USE_NSPR + return; +#else + return(NULL); +#endif + } + + mpfd->done = False; + + /* register "consumer" callbacks */ + if( XPU_TRACE_CHILD(XpGetDocumentData(mpfd->pdpy, mpfd->pcontext, + MyPrintToFileProc, MyFinishProc, + (XPointer)mpfd)) == 0 ) + { + XPU_DEBUG_ONLY(printf("XpGetDocumentData cannot register callbacks\n")); +#ifdef XPU_USE_NSPR + return; +#else + return(NULL); +#endif + } + + /* loop forever - libXp has registered hidden event callbacks for the consumer + * callbacks - the finishCB will call set the "done" boolean after all... + */ + while( mpfd->done != True ) + { + XNextEventTimeout(mpfd->pdpy, &dummy, &timeout); + } + + XCloseDisplay(mpfd->pdpy); + +#ifdef XPU_USE_THREADS +#ifdef XPU_USE_NSPR + return; +#else + return(NULL); +#endif +#else + /* write the status to the parent */ + if( XPU_TRACE_CHILD(write(mpfd->pipe[1], &mpfd->status, sizeof(XPGetDocStatus))) != sizeof(XPGetDocStatus) ) + { + perror("PrintToFile_Consumer: can't write XPGetDocStatus"); + } + + /* we don't do any free's or close's, as we are just + * going to exit, in fact, get out without calling any C++ + * destructors, etc., as we don't want anything funny to happen + * to the parent + */ + XPU_TRACE_CHILD(_exit(EXIT_SUCCESS)); +#endif /* XPU_USE_THREADS */ +} + +/* EOF. */ |