mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-01 17:53:38 +00:00
![Paul Gofman](/assets/img/avatar_default.png)
Signed-off-by: Paul Gofman <gofmanp@gmail.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
1111 lines
33 KiB
C
1111 lines
33 KiB
C
/* PostScript Printer Description (PPD) file parser
|
|
*
|
|
* See http://www.adobe.com/supportservice/devrelations/PDFS/TN/5003.PPD_Spec_v4.3.pdf
|
|
*
|
|
* Copyright 1998 Huw D M Davies
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <locale.h>
|
|
#include <assert.h>
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winternl.h"
|
|
#include "wine/debug.h"
|
|
#include "psdrv.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
|
|
|
|
typedef struct {
|
|
char *key;
|
|
char *option;
|
|
char *opttrans;
|
|
char *value;
|
|
char *valtrans;
|
|
} PPDTuple;
|
|
|
|
struct map_context
|
|
{
|
|
const char *ptr, *pos, *end;
|
|
};
|
|
|
|
/* map of page names in ppd file to Windows paper constants */
|
|
|
|
static const struct {
|
|
const char *PSName;
|
|
WORD WinPage;
|
|
} PageTrans[] = {
|
|
{"10x11", DMPAPER_10X11},
|
|
{"10x14", DMPAPER_10X14},
|
|
{"11x17", DMPAPER_11X17}, /* not in Adobe PPD file spec */
|
|
{"12x11", DMPAPER_12X11},
|
|
{"15x11", DMPAPER_15X11},
|
|
{"9x11", DMPAPER_9X11},
|
|
{"A2", DMPAPER_A2},
|
|
{"A3", DMPAPER_A3},
|
|
{"A3.Transverse", DMPAPER_A3_TRANSVERSE},
|
|
{"A3Extra", DMPAPER_A3_EXTRA},
|
|
{"A3Extra.Transverse", DMPAPER_A3_EXTRA_TRANSVERSE},
|
|
{"A3Rotated", DMPAPER_A3_ROTATED},
|
|
{"A4", DMPAPER_A4},
|
|
{"A4.Transverse", DMPAPER_A4_TRANSVERSE},
|
|
{"A4Extra", DMPAPER_A4_EXTRA},
|
|
{"A4Plus", DMPAPER_A4_PLUS},
|
|
{"A4Rotated", DMPAPER_A4_ROTATED},
|
|
{"A4Small", DMPAPER_A4SMALL},
|
|
{"A5", DMPAPER_A5},
|
|
{"A5.Transverse", DMPAPER_A5_TRANSVERSE},
|
|
{"A5Extra", DMPAPER_A5_EXTRA},
|
|
{"A5Rotated", DMPAPER_A5_ROTATED},
|
|
{"A6", DMPAPER_A6},
|
|
{"A6Rotated", DMPAPER_A6_ROTATED},
|
|
{"ARCHC", DMPAPER_CSHEET},
|
|
{"ARCHD", DMPAPER_DSHEET},
|
|
{"ARCHE", DMPAPER_ESHEET},
|
|
{"B4", DMPAPER_B4},
|
|
{"B4Rotated", DMPAPER_B4_JIS_ROTATED},
|
|
{"B5", DMPAPER_B5},
|
|
{"B5.Transverse", DMPAPER_B5_TRANSVERSE},
|
|
{"B5Rotated", DMPAPER_B5_JIS_ROTATED},
|
|
{"B6", DMPAPER_B6_JIS},
|
|
{"B6Rotated", DMPAPER_B6_JIS_ROTATED},
|
|
{"C4", DMPAPER_ENV_C4}, /* use EnvC4 */
|
|
{"C5", DMPAPER_ENV_C5}, /* use EnvC5 */
|
|
{"C6", DMPAPER_ENV_C6}, /* use EnvC6 */
|
|
{"Comm10", DMPAPER_ENV_10}, /* use Env10 */
|
|
{"DL", DMPAPER_ENV_DL}, /* use EnvDL */
|
|
{"DoublePostcard", DMPAPER_DBL_JAPANESE_POSTCARD},
|
|
{"DoublePostcardRotated", DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED},
|
|
{"Env10", DMPAPER_ENV_10},
|
|
{"Env11", DMPAPER_ENV_11},
|
|
{"Env12", DMPAPER_ENV_12},
|
|
{"Env14", DMPAPER_ENV_14},
|
|
{"Env9", DMPAPER_ENV_9},
|
|
{"EnvC3", DMPAPER_ENV_C3},
|
|
{"EnvC4", DMPAPER_ENV_C4},
|
|
{"EnvC5", DMPAPER_ENV_C5},
|
|
{"EnvC6", DMPAPER_ENV_C6},
|
|
{"EnvC65", DMPAPER_ENV_C65},
|
|
{"EnvChou3", DMPAPER_JENV_CHOU3},
|
|
{"EnvChou3Rotated", DMPAPER_JENV_CHOU3_ROTATED},
|
|
{"EnvChou4", DMPAPER_JENV_CHOU4},
|
|
{"EnvChou4Rotated", DMPAPER_JENV_CHOU4_ROTATED},
|
|
{"EnvDL", DMPAPER_ENV_DL},
|
|
{"EnvISOB4", DMPAPER_ENV_B4},
|
|
{"EnvISOB5", DMPAPER_ENV_B5},
|
|
{"EnvISOB6", DMPAPER_ENV_B6},
|
|
{"EnvInvite", DMPAPER_ENV_INVITE},
|
|
{"EnvItalian", DMPAPER_ENV_ITALY},
|
|
{"EnvKaku2", DMPAPER_JENV_KAKU2},
|
|
{"EnvKaku2Rotated", DMPAPER_JENV_KAKU2_ROTATED},
|
|
{"EnvKaku3", DMPAPER_JENV_KAKU3},
|
|
{"EnvKaku3Rotated", DMPAPER_JENV_KAKU3_ROTATED},
|
|
{"EnvMonarch", DMPAPER_ENV_MONARCH},
|
|
{"EnvPRC1", DMPAPER_PENV_1},
|
|
{"EnvPRC10", DMPAPER_PENV_10},
|
|
{"EnvPRC10Rotated", DMPAPER_PENV_10_ROTATED},
|
|
{"EnvPRC1Rotated", DMPAPER_PENV_1_ROTATED},
|
|
{"EnvPRC2", DMPAPER_PENV_2},
|
|
{"EnvPRC2Rotated", DMPAPER_PENV_2_ROTATED},
|
|
{"EnvPRC3", DMPAPER_PENV_3},
|
|
{"EnvPRC3Rotated", DMPAPER_PENV_3_ROTATED},
|
|
{"EnvPRC4", DMPAPER_PENV_4},
|
|
{"EnvPRC4Rotated", DMPAPER_PENV_4_ROTATED},
|
|
{"EnvPRC5", DMPAPER_PENV_5},
|
|
{"EnvPRC5Rotated", DMPAPER_PENV_5_ROTATED},
|
|
{"EnvPRC6", DMPAPER_PENV_6},
|
|
{"EnvPRC6Rotated", DMPAPER_PENV_6_ROTATED},
|
|
{"EnvPRC7", DMPAPER_PENV_7},
|
|
{"EnvPRC7Rotated", DMPAPER_PENV_7_ROTATED},
|
|
{"EnvPRC8", DMPAPER_PENV_8},
|
|
{"EnvPRC8Rotated", DMPAPER_PENV_8_ROTATED},
|
|
{"EnvPRC9", DMPAPER_PENV_9},
|
|
{"EnvPRC9Rotated", DMPAPER_PENV_9_ROTATED},
|
|
{"EnvPersonal", DMPAPER_ENV_PERSONAL},
|
|
{"EnvYou4", DMPAPER_JENV_YOU4},
|
|
{"EnvYou4Rotated", DMPAPER_JENV_YOU4_ROTATED},
|
|
{"Executive", DMPAPER_EXECUTIVE},
|
|
{"FanFoldGerman", DMPAPER_FANFOLD_STD_GERMAN},
|
|
{"FanFoldGermanLegal", DMPAPER_FANFOLD_LGL_GERMAN},
|
|
{"FanFoldUS", DMPAPER_FANFOLD_US},
|
|
{"Folio", DMPAPER_FOLIO},
|
|
{"ISOB4", DMPAPER_ISO_B4},
|
|
{"ISOB5Extra", DMPAPER_B5_EXTRA},
|
|
{"Ledger", DMPAPER_LEDGER},
|
|
{"Legal", DMPAPER_LEGAL},
|
|
{"LegalExtra", DMPAPER_LEGAL_EXTRA},
|
|
{"Letter", DMPAPER_LETTER},
|
|
{"Letter.Transverse", DMPAPER_LETTER_TRANSVERSE},
|
|
{"LetterExtra", DMPAPER_LETTER_EXTRA},
|
|
{"LetterExtra.Transverse", DMPAPER_LETTER_EXTRA_TRANSVERSE},
|
|
{"LetterPlus", DMPAPER_LETTER_PLUS},
|
|
{"LetterRotated", DMPAPER_LETTER_ROTATED},
|
|
{"LetterSmall", DMPAPER_LETTERSMALL},
|
|
{"Monarch", DMPAPER_ENV_MONARCH}, /* use EnvMonarch */
|
|
{"Note", DMPAPER_NOTE},
|
|
{"PRC16K", DMPAPER_P16K},
|
|
{"PRC16KRotated", DMPAPER_P16K_ROTATED},
|
|
{"PRC32K", DMPAPER_P32K},
|
|
{"PRC32KBig", DMPAPER_P32KBIG},
|
|
{"PRC32KBigRotated", DMPAPER_P32KBIG_ROTATED},
|
|
{"PRC32KRotated", DMPAPER_P32K_ROTATED},
|
|
{"Postcard", DMPAPER_JAPANESE_POSTCARD},
|
|
{"PostcardRotated", DMPAPER_JAPANESE_POSTCARD_ROTATED},
|
|
{"Quarto", DMPAPER_QUARTO},
|
|
{"Statement", DMPAPER_STATEMENT},
|
|
{"SuperA", DMPAPER_A_PLUS},
|
|
{"SuperB", DMPAPER_B_PLUS},
|
|
{"Tabloid", DMPAPER_TABLOID},
|
|
{"TabloidExtra", DMPAPER_TABLOID_EXTRA},
|
|
{NULL, 0}
|
|
};
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_PPDDecodeHex
|
|
*
|
|
* Copies str into a newly allocated string from the process heap substituting
|
|
* hex strings enclosed in '<' and '>' for their byte codes.
|
|
*
|
|
*/
|
|
static char *PSDRV_PPDDecodeHex(char *str)
|
|
{
|
|
char *buf, *in, *out;
|
|
BOOL inhex = FALSE;
|
|
|
|
buf = HeapAlloc(PSDRV_Heap, 0, strlen(str) + 1);
|
|
if(!buf)
|
|
return NULL;
|
|
|
|
for(in = str, out = buf; *in; in++) {
|
|
if(!inhex) {
|
|
if(*in != '<')
|
|
*out++ = *in;
|
|
else
|
|
inhex = TRUE;
|
|
} else {
|
|
if(*in == '>') {
|
|
inhex = FALSE;
|
|
continue;
|
|
}
|
|
else if(isspace(*in))
|
|
continue;
|
|
else {
|
|
int i;
|
|
if(!isxdigit(*in) || !isxdigit(*(in + 1))) {
|
|
ERR("Invalid hex char in hex string\n");
|
|
HeapFree(PSDRV_Heap, 0, buf);
|
|
return NULL;
|
|
}
|
|
*out = 0;
|
|
for(i = 0; i < 2; i++) {
|
|
if(isdigit(*(in + i)))
|
|
*out |= (*(in + i) - '0') << ((1-i) * 4);
|
|
else
|
|
*out |= (toupper(*(in + i)) - 'A' + 10) << ((1-i) * 4);
|
|
}
|
|
out++;
|
|
in++;
|
|
}
|
|
}
|
|
}
|
|
*out = '\0';
|
|
return buf;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_PPDGetTransValue
|
|
*
|
|
*/
|
|
static BOOL PSDRV_PPDGetTransValue(const char *start, PPDTuple *tuple)
|
|
{
|
|
char *buf;
|
|
const char *end;
|
|
|
|
end = strpbrk(start, "\r\n");
|
|
if(end == start) return FALSE;
|
|
if(!end) end = start + strlen(start);
|
|
buf = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
|
|
memcpy(buf, start, end - start);
|
|
*(buf + (end - start)) = '\0';
|
|
tuple->valtrans = PSDRV_PPDDecodeHex(buf);
|
|
HeapFree( PSDRV_Heap, 0, buf );
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL get_line( char *buf, int size, struct map_context *ctx )
|
|
{
|
|
int i;
|
|
if (ctx->pos > ctx->end) return FALSE;
|
|
|
|
for (i = 0; i < size - 1; i++)
|
|
{
|
|
if (ctx->pos > ctx->end) break;
|
|
buf[i] = *ctx->pos++;
|
|
|
|
/* \r\n -> \n */
|
|
if (buf[i] == '\r' && ctx->pos <= ctx->end && *ctx->pos == '\n')
|
|
{
|
|
ctx->pos++;
|
|
buf[i] = '\n';
|
|
}
|
|
|
|
if (buf[i] == '\n' || buf[i] == '\r')
|
|
{
|
|
i++;
|
|
break;
|
|
}
|
|
}
|
|
buf[i] = '\0';
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_PPDGetInvocationValue
|
|
*
|
|
* Passed string that should be surrounded by `"'s, return string allocated
|
|
* from process heap.
|
|
*/
|
|
static BOOL PSDRV_PPDGetInvocationValue(struct map_context *ctx, PPDTuple *tuple)
|
|
{
|
|
const char *start;
|
|
char *buf, line[257];
|
|
|
|
assert( *ctx->pos == '"' );
|
|
|
|
ctx->pos++;
|
|
for (start = ctx->pos; ctx->pos <= ctx->end; ctx->pos++)
|
|
if (*ctx->pos == '"') break;
|
|
if (ctx->pos > ctx->end) return FALSE;
|
|
ctx->pos++;
|
|
|
|
buf = HeapAlloc( PSDRV_Heap, 0, ctx->pos - start );
|
|
memcpy( buf, start, ctx->pos - start - 1 );
|
|
buf[ctx->pos - start - 1] = '\0';
|
|
tuple->value = buf;
|
|
|
|
if (get_line( line, sizeof(line), ctx ))
|
|
{
|
|
start = strchr( line, '/' );
|
|
if (start) return PSDRV_PPDGetTransValue( start + 1, tuple );
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_PPDGetQuotedValue
|
|
*
|
|
* Passed string that should be surrounded by `"'s. Expand <xx> as hex
|
|
* return string allocated from process heap.
|
|
*/
|
|
static BOOL PSDRV_PPDGetQuotedValue(struct map_context *ctx, PPDTuple *tuple)
|
|
{
|
|
char *buf;
|
|
|
|
if(!PSDRV_PPDGetInvocationValue(ctx, tuple))
|
|
return FALSE;
|
|
buf = PSDRV_PPDDecodeHex(tuple->value);
|
|
HeapFree(PSDRV_Heap, 0, tuple->value);
|
|
tuple->value = buf;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_PPDGetStringValue
|
|
*
|
|
* Just strip leading white space.
|
|
*/
|
|
static BOOL PSDRV_PPDGetStringValue(char *str, PPDTuple *tuple)
|
|
{
|
|
char *start = str, *end;
|
|
|
|
while(*start != '\0' && isspace(*start))
|
|
start++;
|
|
|
|
end = strpbrk(start, "/\r\n");
|
|
if(!end) end = start + strlen(start);
|
|
tuple->value = HeapAlloc( PSDRV_Heap, 0, (end - start) + 1 );
|
|
memcpy(tuple->value, start, end - start);
|
|
*(tuple->value + (end - start)) = '\0';
|
|
if(*end == '/')
|
|
PSDRV_PPDGetTransValue(end + 1, tuple);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_PPDSymbolValue
|
|
*
|
|
* Not implemented yet.
|
|
*/
|
|
static BOOL PSDRV_PPDGetSymbolValue(char *pos, PPDTuple *tuple)
|
|
{
|
|
FIXME("Stub\n");
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
*
|
|
* PSDRV_PPDGetNextTuple
|
|
*
|
|
* Gets the next Keyword Option Value tuple from the file. Allocs space off
|
|
* the process heap which should be free()ed by the caller if not needed.
|
|
*/
|
|
static BOOL PSDRV_PPDGetNextTuple(struct map_context *ctx, PPDTuple *tuple)
|
|
{
|
|
char line[257], *opt, *cp, *trans, *endkey;
|
|
BOOL gotoption;
|
|
struct map_context save;
|
|
|
|
start:
|
|
|
|
gotoption = TRUE;
|
|
opt = NULL;
|
|
memset(tuple, 0, sizeof(*tuple));
|
|
|
|
do {
|
|
save = *ctx;
|
|
if(!get_line(line, sizeof(line), ctx))
|
|
return FALSE;
|
|
if(line[0] == '*' && line[1] != '%' && strncmp(line, "*End", 4))
|
|
break;
|
|
} while(1);
|
|
|
|
cp = line + strlen(line) - 1;
|
|
if (*cp != '\n' && *cp != '\r')
|
|
{
|
|
ERR("Line too long.\n");
|
|
goto start;
|
|
}
|
|
|
|
for(cp = line; !isspace(*cp) && *cp != ':'; cp++)
|
|
;
|
|
|
|
endkey = cp;
|
|
while (isspace(*cp)) cp++;
|
|
if (*cp == ':') /* <key>: */
|
|
gotoption = FALSE;
|
|
else /* <key> <option> */
|
|
opt = cp;
|
|
|
|
tuple->key = HeapAlloc( PSDRV_Heap, 0, endkey - line + 1 );
|
|
if(!tuple->key) return FALSE;
|
|
|
|
memcpy(tuple->key, line, endkey - line);
|
|
tuple->key[endkey - line] = '\0';
|
|
|
|
if(gotoption) { /* opt points to 1st non-space character of the option */
|
|
cp = strpbrk(opt, ":/");
|
|
if(!cp) {
|
|
ERR("Error in line '%s'?\n", line);
|
|
HeapFree(GetProcessHeap(), 0, tuple->key);
|
|
goto start;
|
|
}
|
|
tuple->option = HeapAlloc( PSDRV_Heap, 0, cp - opt + 1 );
|
|
if(!tuple->option) return FALSE;
|
|
memcpy(tuple->option, opt, cp - opt);
|
|
tuple->option[cp - opt] = '\0';
|
|
if(*cp == '/') {
|
|
char *buf;
|
|
trans = cp + 1;
|
|
cp = strchr(trans, ':');
|
|
if(!cp) {
|
|
ERR("Error in line '%s'?\n", line);
|
|
HeapFree(GetProcessHeap(), 0, tuple->option);
|
|
HeapFree(GetProcessHeap(), 0, tuple->key);
|
|
goto start;
|
|
}
|
|
buf = HeapAlloc( PSDRV_Heap, 0, cp - trans + 1 );
|
|
if(!buf) return FALSE;
|
|
memcpy(buf, trans, cp - trans);
|
|
buf[cp - trans] = '\0';
|
|
tuple->opttrans = PSDRV_PPDDecodeHex(buf);
|
|
HeapFree( PSDRV_Heap, 0, buf );
|
|
}
|
|
}
|
|
|
|
/* cp should point to a ':', so we increment past it */
|
|
cp++;
|
|
|
|
while(isspace(*cp))
|
|
cp++;
|
|
|
|
switch(*cp) {
|
|
case '"':
|
|
/* update the context pos so that it points to the opening quote */
|
|
ctx->pos = save.pos + (cp - line);
|
|
if( (!gotoption && strncmp(tuple->key, "*?", 2) ) ||
|
|
!strncmp(tuple->key, "*JCL", 4))
|
|
PSDRV_PPDGetQuotedValue(ctx, tuple);
|
|
else
|
|
PSDRV_PPDGetInvocationValue(ctx, tuple);
|
|
break;
|
|
|
|
case '^':
|
|
PSDRV_PPDGetSymbolValue(cp, tuple);
|
|
break;
|
|
|
|
default:
|
|
PSDRV_PPDGetStringValue(cp, tuple);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* get_pagesize
|
|
*
|
|
* Searches ppd PageSize list to return entry matching name or optionally creates new
|
|
* entry which is appended to the list if name is not found.
|
|
*/
|
|
static PAGESIZE *get_pagesize( PPD *ppd, char *name, BOOL create )
|
|
{
|
|
PAGESIZE *page;
|
|
|
|
LIST_FOR_EACH_ENTRY(page, &ppd->PageSizes, PAGESIZE, entry)
|
|
{
|
|
if(!strcmp(page->Name, name))
|
|
return page;
|
|
}
|
|
|
|
if (!create) return NULL;
|
|
|
|
page = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*page) );
|
|
list_add_tail(&ppd->PageSizes, &page->entry);
|
|
return page;
|
|
}
|
|
|
|
static DUPLEX *get_duplex( PPD *ppd, const char *name )
|
|
{
|
|
DUPLEX *duplex;
|
|
|
|
LIST_FOR_EACH_ENTRY( duplex, &ppd->Duplexes, DUPLEX, entry )
|
|
{
|
|
if (!strcmp( duplex->Name, name ))
|
|
return duplex;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**********************************************************************
|
|
*
|
|
* PSDRV_PPDGetWord
|
|
*
|
|
* Returns ptr allocated from heap to first word in str. Strips leading spaces.
|
|
* Puts ptr to next word in next
|
|
*/
|
|
static char *PSDRV_PPDGetWord(char *str, char **next)
|
|
{
|
|
char *start, *end, *ret;
|
|
|
|
start = str;
|
|
while(start && *start && isspace(*start))
|
|
start++;
|
|
if(!start || !*start) return FALSE;
|
|
|
|
end = start;
|
|
while(*end && !isspace(*end))
|
|
end++;
|
|
|
|
ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
|
|
memcpy(ret, start, end - start );
|
|
*(ret + (end - start)) = '\0';
|
|
|
|
while(*end && isspace(*end))
|
|
end++;
|
|
if(*end)
|
|
*next = end;
|
|
else
|
|
*next = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/************************************************************
|
|
* parse_resolution
|
|
*
|
|
* Helper to extract x and y resolutions from a resolution entry.
|
|
* Returns TRUE on successful parsing, otherwise FALSE.
|
|
*
|
|
* The ppd spec says that entries can either be:
|
|
* "nnndpi"
|
|
* or
|
|
* "nnnxmmmdpi"
|
|
* in the former case return sz.cx == cx.cy == nnn.
|
|
*
|
|
* There are broken ppd files out there (notably from Samsung) that
|
|
* use the form "nnnmmmdpi", so we have to work harder to spot these.
|
|
* We use a transition from a zero to a non-zero digit as separator
|
|
* (and fail if we find more than one of these). We also don't bother
|
|
* trying to parse "dpi" in case that's missing.
|
|
*/
|
|
static BOOL parse_resolution(const char *str, SIZE *sz)
|
|
{
|
|
int tmp[2];
|
|
int *cur;
|
|
BOOL had_zero;
|
|
const char *c;
|
|
|
|
if(sscanf(str, "%dx%d", tmp, tmp + 1) == 2)
|
|
{
|
|
sz->cx = tmp[0];
|
|
sz->cy = tmp[1];
|
|
return TRUE;
|
|
}
|
|
|
|
tmp[0] = 0;
|
|
tmp[1] = -1;
|
|
cur = tmp;
|
|
had_zero = FALSE;
|
|
for(c = str; isdigit(*c); c++)
|
|
{
|
|
if(!had_zero || *c == '0')
|
|
{
|
|
*cur *= 10;
|
|
*cur += *c - '0';
|
|
if(*c == '0')
|
|
had_zero = TRUE;
|
|
}
|
|
else if(cur != tmp)
|
|
return FALSE;
|
|
else
|
|
{
|
|
cur++;
|
|
*cur = *c - '0';
|
|
had_zero = FALSE;
|
|
}
|
|
}
|
|
if(tmp[0] == 0) return FALSE;
|
|
|
|
sz->cx = tmp[0];
|
|
if(tmp[1] != -1)
|
|
sz->cy = tmp[1];
|
|
else
|
|
sz->cy = sz->cx;
|
|
return TRUE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* PSDRV_AddSlot
|
|
*
|
|
*/
|
|
static BOOL PSDRV_AddSlot(PPD *ppd, LPCSTR szName, LPCSTR szFullName,
|
|
LPSTR szInvocationString, WORD wWinBin)
|
|
{
|
|
INPUTSLOT *slot = HeapAlloc( PSDRV_Heap, 0, sizeof(INPUTSLOT) );
|
|
if (!slot) return FALSE;
|
|
|
|
slot->Name = szName;
|
|
slot->FullName = szFullName;
|
|
slot->InvocationString = szInvocationString;
|
|
slot->WinBin = wWinBin;
|
|
|
|
list_add_tail( &ppd->InputSlots, &slot->entry );
|
|
return TRUE;
|
|
}
|
|
|
|
static char *get_ppd_override( HANDLE printer, const char *value )
|
|
{
|
|
DWORD err, type, needed;
|
|
char *data;
|
|
|
|
err = GetPrinterDataExA( printer, "PPD Overrides", value, &type, NULL, 0, &needed );
|
|
if (err != ERROR_MORE_DATA || type != REG_SZ || needed == 0) return NULL;
|
|
|
|
data = HeapAlloc( PSDRV_Heap, 0, needed );
|
|
if (data)
|
|
{
|
|
GetPrinterDataExA( printer, "PPD Overrides", value, &type, (BYTE*)data, needed, &needed );
|
|
TRACE( "got override %s: %s\n", value, data );
|
|
}
|
|
return data;
|
|
}
|
|
|
|
static BOOL map_file( const WCHAR *filename, struct map_context *c )
|
|
{
|
|
HANDLE file, mapping;
|
|
LARGE_INTEGER size;
|
|
|
|
file = CreateFileW( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
if (file == INVALID_HANDLE_VALUE) return FALSE;
|
|
|
|
if (!GetFileSizeEx( file, &size ) || size.u.HighPart)
|
|
{
|
|
CloseHandle( file );
|
|
return FALSE;
|
|
}
|
|
|
|
mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
|
|
CloseHandle( file );
|
|
if (!mapping) return FALSE;
|
|
|
|
c->pos = c->ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
|
|
c->end = c->ptr + size.u.LowPart - 1;
|
|
CloseHandle( mapping );
|
|
return TRUE;
|
|
}
|
|
|
|
static void unmap_file( struct map_context *c )
|
|
{
|
|
UnmapViewOfFile( c->ptr );
|
|
}
|
|
|
|
/***********************************************************************
|
|
*
|
|
* PSDRV_ParsePPD
|
|
*
|
|
*
|
|
*/
|
|
PPD *PSDRV_ParsePPD( const WCHAR *fname, HANDLE printer )
|
|
{
|
|
PPD *ppd;
|
|
PPDTuple tuple;
|
|
char *default_pagesize = NULL, *default_duplex = NULL;
|
|
char *def_pagesize_override = NULL, *def_duplex_override = NULL;
|
|
PAGESIZE *page, *page_cursor2;
|
|
struct map_context c;
|
|
WORD UserPageType = DMPAPER_USER;
|
|
WORD UserBinType = DMBIN_USER;
|
|
|
|
TRACE("file %s\n", debugstr_w(fname));
|
|
|
|
if (!map_file( fname, &c ))
|
|
{
|
|
WARN("Couldn't open ppd file %s\n", debugstr_w(fname));
|
|
return NULL;
|
|
}
|
|
|
|
ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
|
|
if(!ppd) {
|
|
ERR("Unable to allocate memory for ppd\n");
|
|
unmap_file( &c );
|
|
return NULL;
|
|
}
|
|
|
|
ppd->ColorDevice = CD_NotSpecified;
|
|
|
|
list_init( &ppd->Resolutions );
|
|
list_init( &ppd->InstalledFonts );
|
|
list_init( &ppd->PageSizes );
|
|
list_init( &ppd->Constraints );
|
|
list_init( &ppd->InputSlots );
|
|
list_init( &ppd->Duplexes );
|
|
|
|
/* Some gimp-print ppd files don't contain a DefaultResolution line
|
|
so default to 300 */
|
|
ppd->DefaultResolution = 300;
|
|
|
|
/*
|
|
* The Windows PostScript drivers create the following "virtual bin" for
|
|
* every PostScript printer
|
|
*/
|
|
if (!PSDRV_AddSlot( ppd, NULL, "Automatically Select", NULL, DMBIN_FORMSOURCE ))
|
|
{
|
|
HeapFree (PSDRV_Heap, 0, ppd);
|
|
unmap_file( &c );
|
|
return NULL;
|
|
}
|
|
|
|
while (PSDRV_PPDGetNextTuple( &c, &tuple ))
|
|
{
|
|
if(!strcmp("*NickName", tuple.key)) {
|
|
ppd->NickName = tuple.value;
|
|
tuple.value = NULL;
|
|
TRACE("NickName = '%s'\n", ppd->NickName);
|
|
}
|
|
|
|
else if(!strcmp("*LanguageLevel", tuple.key)) {
|
|
sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
|
|
TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
|
|
}
|
|
|
|
else if(!strcmp("*ColorDevice", tuple.key)) {
|
|
if(!stricmp(tuple.value, "true"))
|
|
ppd->ColorDevice = CD_True;
|
|
else
|
|
ppd->ColorDevice = CD_False;
|
|
TRACE("ColorDevice = %s\n", ppd->ColorDevice == CD_True ? "True" : "False");
|
|
}
|
|
|
|
else if((!strcmp("*DefaultResolution", tuple.key)) ||
|
|
(!strcmp("*DefaultJCLResolution", tuple.key))) {
|
|
SIZE sz;
|
|
if(parse_resolution(tuple.value, &sz))
|
|
{
|
|
TRACE("DefaultResolution %dx%d\n", sz.cx, sz.cy);
|
|
ppd->DefaultResolution = sz.cx;
|
|
}
|
|
else
|
|
WARN("failed to parse DefaultResolution %s\n", debugstr_a(tuple.value));
|
|
}
|
|
|
|
else if(!strcmp("*Resolution", tuple.key))
|
|
{
|
|
SIZE sz;
|
|
if (parse_resolution(tuple.option, &sz))
|
|
{
|
|
RESOLUTION *res;
|
|
|
|
TRACE("Resolution %dx%d, invocation %s\n", sz.cx, sz.cy, tuple.value);
|
|
|
|
res = HeapAlloc( GetProcessHeap(), 0, sizeof(*res) );
|
|
res->resx = sz.cx;
|
|
res->resy = sz.cy;
|
|
res->InvocationString = tuple.value;
|
|
tuple.value = NULL;
|
|
list_add_tail( &ppd->Resolutions, &res->entry );
|
|
}
|
|
else
|
|
WARN("failed to parse Resolution %s\n", debugstr_a(tuple.option));
|
|
}
|
|
|
|
else if(!strcmp("*Font", tuple.key))
|
|
{
|
|
FONTNAME *fn = HeapAlloc( PSDRV_Heap, 0, sizeof(*fn) );
|
|
fn->Name = tuple.option;
|
|
tuple.option = NULL;
|
|
list_add_tail( &ppd->InstalledFonts, &fn->entry );
|
|
}
|
|
|
|
else if(!strcmp("*DefaultFont", tuple.key)) {
|
|
ppd->DefaultFont = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
|
|
else if(!strcmp("*JCLBegin", tuple.key)) {
|
|
ppd->JCLBegin = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
|
|
else if(!strcmp("*JCLToPSInterpreter", tuple.key)) {
|
|
ppd->JCLToPSInterpreter = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
|
|
else if(!strcmp("*JCLEnd", tuple.key)) {
|
|
ppd->JCLEnd = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
|
|
else if(!strcmp("*PageSize", tuple.key))
|
|
{
|
|
page = get_pagesize( ppd, tuple.option, TRUE );
|
|
|
|
if(!page->Name) {
|
|
page->Name = tuple.option;
|
|
tuple.option = NULL;
|
|
}
|
|
if(!page->FullName) {
|
|
if(tuple.opttrans) {
|
|
page->FullName = tuple.opttrans;
|
|
tuple.opttrans = NULL;
|
|
} else
|
|
{
|
|
page->FullName = HeapAlloc( PSDRV_Heap, 0, strlen(page->Name)+1 );
|
|
strcpy( page->FullName, page->Name );
|
|
}
|
|
}
|
|
if(!page->InvocationString) {
|
|
page->InvocationString = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
if (!page->WinPage)
|
|
{
|
|
int i;
|
|
for (i = 0; PageTrans[i].PSName; i++)
|
|
{
|
|
if (!strcmp( PageTrans[i].PSName, page->Name ))
|
|
{
|
|
page->WinPage = PageTrans[i].WinPage;
|
|
break;
|
|
}
|
|
}
|
|
if (!page->WinPage)
|
|
{
|
|
TRACE( "Can't find Windows page type for %s - using %u\n", debugstr_a(page->Name), UserPageType );
|
|
page->WinPage = UserPageType++;
|
|
}
|
|
}
|
|
}
|
|
|
|
else if(!strcmp("*DefaultPageSize", tuple.key))
|
|
{
|
|
if (!default_pagesize)
|
|
{
|
|
default_pagesize = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
}
|
|
|
|
else if(!strcmp("*ImageableArea", tuple.key)) {
|
|
page = get_pagesize( ppd, tuple.option, TRUE );
|
|
|
|
if(!page->Name) {
|
|
page->Name = tuple.option;
|
|
tuple.option = NULL;
|
|
}
|
|
if(!page->FullName) {
|
|
page->FullName = tuple.opttrans;
|
|
tuple.opttrans = NULL;
|
|
}
|
|
|
|
#define PIA page->ImageableArea
|
|
if(!PIA) {
|
|
PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
|
|
push_lc_numeric("C");
|
|
sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
|
|
&PIA->urx, &PIA->ury);
|
|
pop_lc_numeric();
|
|
}
|
|
#undef PIA
|
|
}
|
|
|
|
else if(!strcmp("*PaperDimension", tuple.key)) {
|
|
page = get_pagesize( ppd, tuple.option, TRUE );
|
|
|
|
if(!page->Name) {
|
|
page->Name = tuple.option;
|
|
tuple.option = NULL;
|
|
}
|
|
if(!page->FullName) {
|
|
page->FullName = tuple.opttrans;
|
|
tuple.opttrans = NULL;
|
|
}
|
|
|
|
#define PD page->PaperDimension
|
|
if(!PD) {
|
|
PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
|
|
push_lc_numeric("C");
|
|
sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
|
|
pop_lc_numeric();
|
|
}
|
|
#undef PD
|
|
}
|
|
|
|
else if(!strcmp("*LandscapeOrientation", tuple.key)) {
|
|
if(!strcmp(tuple.value, "Plus90"))
|
|
ppd->LandscapeOrientation = 90;
|
|
else if(!strcmp(tuple.value, "Minus90"))
|
|
ppd->LandscapeOrientation = -90;
|
|
|
|
/* anything else, namely 'any', leaves value at 0 */
|
|
|
|
TRACE("LandscapeOrientation = %d\n",
|
|
ppd->LandscapeOrientation);
|
|
}
|
|
|
|
else if(!strcmp("*UIConstraints", tuple.key))
|
|
{
|
|
char *start;
|
|
CONSTRAINT *con = HeapAlloc( PSDRV_Heap, 0, sizeof(*con) );
|
|
|
|
start = tuple.value;
|
|
con->Feature1 = PSDRV_PPDGetWord(start, &start);
|
|
con->Value1 = PSDRV_PPDGetWord(start, &start);
|
|
con->Feature2 = PSDRV_PPDGetWord(start, &start);
|
|
con->Value2 = PSDRV_PPDGetWord(start, &start);
|
|
|
|
list_add_tail( &ppd->Constraints, &con->entry );
|
|
}
|
|
|
|
else if (!strcmp("*InputSlot", tuple.key))
|
|
{
|
|
|
|
if (!tuple.opttrans)
|
|
tuple.opttrans = tuple.option;
|
|
|
|
TRACE("Using Windows bin type %u for '%s'\n", UserBinType,
|
|
tuple.option);
|
|
|
|
/* FIXME - should check for failure */
|
|
PSDRV_AddSlot(ppd, tuple.option, tuple.opttrans, tuple.value,
|
|
UserBinType++);
|
|
|
|
tuple.option = tuple.opttrans = tuple.value = NULL;
|
|
}
|
|
|
|
/*
|
|
* Windows treats "manual feed" as another paper source. Most PPD
|
|
* files, however, treat it as a separate option which is either on or
|
|
* off.
|
|
*/
|
|
else if (!strcmp("*ManualFeed", tuple.key) && tuple.option &&
|
|
!strcmp ("True", tuple.option))
|
|
{
|
|
/* FIXME - should check for failure */
|
|
PSDRV_AddSlot(ppd, "Manual Feed", "Manual Feed", tuple.value, DMBIN_MANUAL);
|
|
tuple.value = NULL;
|
|
}
|
|
|
|
else if(!strcmp("*TTRasterizer", tuple.key)) {
|
|
if(!stricmp("None", tuple.value))
|
|
ppd->TTRasterizer = RO_None;
|
|
else if(!stricmp("Accept68K", tuple.value))
|
|
ppd->TTRasterizer = RO_Accept68K;
|
|
else if(!stricmp("Type42", tuple.value))
|
|
ppd->TTRasterizer = RO_Type42;
|
|
else if(!stricmp("TrueImage", tuple.value))
|
|
ppd->TTRasterizer = RO_TrueImage;
|
|
else {
|
|
FIXME("Unknown option %s for *TTRasterizer\n",
|
|
tuple.value);
|
|
ppd->TTRasterizer = RO_None;
|
|
}
|
|
TRACE("*TTRasterizer = %d\n", ppd->TTRasterizer);
|
|
}
|
|
|
|
else if(!strcmp("*Duplex", tuple.key))
|
|
{
|
|
DUPLEX *duplex = HeapAlloc( GetProcessHeap(), 0, sizeof(*duplex) );
|
|
duplex->Name = tuple.option;
|
|
duplex->FullName = tuple.opttrans;
|
|
duplex->InvocationString = tuple.value;
|
|
if(!stricmp("None", tuple.option) || !stricmp("False", tuple.option)
|
|
|| !stricmp("Simplex", tuple.option))
|
|
duplex->WinDuplex = DMDUP_SIMPLEX;
|
|
else if(!stricmp("DuplexNoTumble", tuple.option))
|
|
duplex->WinDuplex = DMDUP_VERTICAL;
|
|
else if(!stricmp("DuplexTumble", tuple.option))
|
|
duplex->WinDuplex = DMDUP_HORIZONTAL;
|
|
else if(!stricmp("Notcapable", tuple.option))
|
|
duplex->WinDuplex = 0;
|
|
else {
|
|
FIXME("Unknown option %s for *Duplex defaulting to simplex\n", tuple.option);
|
|
duplex->WinDuplex = DMDUP_SIMPLEX;
|
|
}
|
|
tuple.option = tuple.opttrans = tuple.value = NULL;
|
|
list_add_tail( &ppd->Duplexes, &duplex->entry );
|
|
}
|
|
|
|
else if (!strcmp("*DefaultDuplex", tuple.key))
|
|
{
|
|
if (!default_duplex)
|
|
{
|
|
default_duplex = tuple.value;
|
|
tuple.value = NULL;
|
|
}
|
|
}
|
|
|
|
HeapFree(PSDRV_Heap, 0, tuple.key);
|
|
HeapFree(PSDRV_Heap, 0, tuple.option);
|
|
HeapFree(PSDRV_Heap, 0, tuple.value);
|
|
HeapFree(PSDRV_Heap, 0, tuple.opttrans);
|
|
HeapFree(PSDRV_Heap, 0, tuple.valtrans);
|
|
|
|
}
|
|
|
|
/* Remove any partial page size entries, that is any without a PageSize or a PaperDimension (we can
|
|
cope with a missing ImageableArea). */
|
|
LIST_FOR_EACH_ENTRY_SAFE(page, page_cursor2, &ppd->PageSizes, PAGESIZE, entry)
|
|
{
|
|
if(!page->InvocationString || !page->PaperDimension)
|
|
{
|
|
WARN("Removing page %s since it has a missing %s entry\n", debugstr_a(page->FullName),
|
|
page->InvocationString ? "PaperDimension" : "InvocationString");
|
|
HeapFree(PSDRV_Heap, 0, page->Name);
|
|
HeapFree(PSDRV_Heap, 0, page->FullName);
|
|
HeapFree(PSDRV_Heap, 0, page->InvocationString);
|
|
HeapFree(PSDRV_Heap, 0, page->ImageableArea);
|
|
HeapFree(PSDRV_Heap, 0, page->PaperDimension);
|
|
list_remove(&page->entry);
|
|
}
|
|
}
|
|
|
|
ppd->DefaultPageSize = NULL;
|
|
def_pagesize_override = get_ppd_override( printer, "DefaultPageSize" );
|
|
if (def_pagesize_override)
|
|
ppd->DefaultPageSize = get_pagesize( ppd, def_pagesize_override, FALSE );
|
|
if (!ppd->DefaultPageSize && default_pagesize)
|
|
ppd->DefaultPageSize = get_pagesize( ppd, default_pagesize, FALSE );
|
|
|
|
if (!ppd->DefaultPageSize)
|
|
{
|
|
struct list *head = list_head( &ppd->PageSizes );
|
|
if (head) ppd->DefaultPageSize = LIST_ENTRY( head, PAGESIZE, entry );
|
|
TRACE("Setting DefaultPageSize to first in list\n");
|
|
}
|
|
TRACE( "DefaultPageSize: %s\n", ppd->DefaultPageSize ? ppd->DefaultPageSize->Name : "<not set>" );
|
|
|
|
HeapFree( PSDRV_Heap, 0, def_pagesize_override );
|
|
HeapFree( PSDRV_Heap, 0, default_pagesize );
|
|
|
|
ppd->DefaultDuplex = NULL;
|
|
def_duplex_override = get_ppd_override( printer, "DefaultDuplex" );
|
|
if (def_duplex_override)
|
|
ppd->DefaultDuplex = get_duplex( ppd, def_duplex_override );
|
|
if (!ppd->DefaultDuplex && default_duplex)
|
|
ppd->DefaultDuplex = get_duplex( ppd, default_duplex );
|
|
|
|
if (!ppd->DefaultDuplex)
|
|
{
|
|
struct list *head = list_head( &ppd->Duplexes );
|
|
if (head) ppd->DefaultDuplex = LIST_ENTRY( head, DUPLEX, entry );
|
|
TRACE("Setting DefaultDuplex to first in list\n");
|
|
}
|
|
TRACE( "DefaultDuplex: %s\n", ppd->DefaultDuplex ? ppd->DefaultDuplex->Name : "<not set>" );
|
|
|
|
HeapFree( PSDRV_Heap, 0, def_duplex_override );
|
|
HeapFree( PSDRV_Heap, 0, default_duplex );
|
|
|
|
|
|
{
|
|
FONTNAME *fn;
|
|
PAGESIZE *page;
|
|
CONSTRAINT *con;
|
|
INPUTSLOT *slot;
|
|
|
|
LIST_FOR_EACH_ENTRY( fn, &ppd->InstalledFonts, FONTNAME, entry )
|
|
TRACE("'%s'\n", fn->Name);
|
|
|
|
LIST_FOR_EACH_ENTRY(page, &ppd->PageSizes, PAGESIZE, entry) {
|
|
TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
|
|
page->FullName, page->WinPage, page->InvocationString);
|
|
if(page->ImageableArea)
|
|
TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
|
|
page->ImageableArea->llx, page->ImageableArea->lly,
|
|
page->ImageableArea->urx, page->ImageableArea->ury);
|
|
if(page->PaperDimension)
|
|
TRACE("Dimension = %.2f x %.2f\n",
|
|
page->PaperDimension->x, page->PaperDimension->y);
|
|
}
|
|
|
|
LIST_FOR_EACH_ENTRY( con, &ppd->Constraints, CONSTRAINT, entry )
|
|
TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
|
|
con->Value1, con->Feature2, con->Value2);
|
|
|
|
LIST_FOR_EACH_ENTRY( slot, &ppd->InputSlots, INPUTSLOT, entry )
|
|
TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
|
|
debugstr_a(slot->Name), slot->FullName, slot->WinBin,
|
|
debugstr_a(slot->InvocationString));
|
|
}
|
|
|
|
unmap_file( &c );
|
|
return ppd;
|
|
}
|