int /* O - Number of conflicting options */
cupsGetConflicts(
ppd_file_t *ppd, /* I - PPD file */
const char *option, /* I - Option to test */
const char *choice, /* I - Choice to test */
cups_option_t **options) /* O - Conflicting options */
{
int i, /* Looping var */
num_options; /* Number of conflicting options */
cups_array_t *active; /* Active conflicts */
_ppd_cups_uiconsts_t *c; /* Current constraints */
_ppd_cups_uiconst_t *cptr; /* Current constraint */
ppd_choice_t *marked; /* Marked choice */
/*
* Range check input...
*/
if (options)
*options = NULL;
if (!ppd || !option || !choice || !options)
return (0);
/*
* Test for conflicts...
*/
active = ppd_test_constraints(ppd, option, choice, 0, NULL,
_PPD_ALL_CONSTRAINTS);
/*
* Loop through all of the UI constraints and add any options that conflict...
*/
for (num_options = 0, c = (_ppd_cups_uiconsts_t *)cupsArrayFirst(active);
c;
c = (_ppd_cups_uiconsts_t *)cupsArrayNext(active))
{
for (i = c->num_constraints, cptr = c->constraints;
i > 0;
i --, cptr ++)
if (_cups_strcasecmp(cptr->option->keyword, option))
{
if (cptr->choice)
num_options = cupsAddOption(cptr->option->keyword,
cptr->choice->choice, num_options,
options);
else if ((marked = ppdFindMarkedChoice(ppd,
cptr->option->keyword)) != NULL)
num_options = cupsAddOption(cptr->option->keyword, marked->choice,
num_options, options);
}
}
cupsArrayDelete(active);
return (num_options);
}
int GetPrinterSettings( cups_option_t *p_cups_opt, int num_opt, ParamList **p_list, int *listNum )
{
char *p_ppd_name = getenv("PPD");
ppd_file_t *p_ppd;
ppd_choice_t *p_choice;
int result = -1;
PpdToOptKey *p_opt_key_table = alloc_opt_key_table(p_ppd_name);
PpdToOptKey *p_table = p_opt_key_table;
int numCnt = 0;
char choice[BUF_SIZE];
ParamList *local_p_list = NULL;
static const char *libpath;
if ( (p_cups_opt == NULL) || (listNum == NULL) ) goto onErr;
*listNum = 0;
DEBUG_PRINT2( "DEBUG:[rastertocanonij] PPD Path(%s)\n", p_ppd_name );
if ( (p_ppd = ppdOpenFile( p_ppd_name )) == NULL ) goto onErr;
ppdMarkDefaults(p_ppd);
cupsMarkOptions(p_ppd, num_opt, p_cups_opt);
/* add libpath */
libpath = GetExecProgPath();
if ( libpath != NULL ){
param_list_add( &local_p_list, "--filterpath", libpath, strlen(libpath) + 1 );
}
while( p_table->ppd_key != NULL ){
p_choice = ppdFindMarkedChoice( p_ppd, p_table->ppd_key );
if ( p_choice ) {
DEBUG_PRINT3( "DEBUG:[rastertocanonij] OPTION(%s) / VALUE(%s)\n", p_table->ppd_key, p_choice->choice );
}
else {
DEBUG_PRINT2( "DEBUG:[rastertocanonij] OPTION(%s) / VALUE(novalue)\n", p_table->ppd_key );
}
if ( p_choice != NULL ){
strcpy( choice, p_choice->choice );
//to_lower_except_size_X(choice);
param_list_add( &local_p_list, p_table->opt_key, choice, strlen(choice) + 1 );
numCnt++;
}
p_table++;
}
*listNum = numCnt;
*p_list = local_p_list;
result = 0;
onErr:
return result;
}
QPageSize QPpdPrintDevice::defaultPageSize() const
{
ppd_choice_t *defaultChoice = ppdFindMarkedChoice(m_ppd, "PageSize");
if (defaultChoice) {
ppd_size_t *ppdSize = ppdPageSize(m_ppd, defaultChoice->choice);
if (ppdSize) {
// Returned size is in points
QString key = QString::fromUtf8(ppdSize->name);
QSize size = QSize(qRound(ppdSize->width), qRound(ppdSize->length));
QString name = QString::fromUtf8(defaultChoice->text);
return createPageSize(key, size, name);
}
}
return QPageSize();
}
int initializeBidirectional(ppd_file_t *ppd, printerRef prn) {
char ls[64];
ppd_choice_t *temp;
if ((temp = ppdFindMarkedChoice(ppd, "Bidirectional"))) {
if (!strcmp(temp->choice, "True"))
return prnSetBidirectionalMode(prn, IMWAPI_BIDIRECTIONAL);
else
return prnSetBidirectionalMode(prn, IMWAPI_LEFTTORIGHT);
} else {
prnSetBidirectionalMode(prn, IMWAPI_LEFTTORIGHT);
l10nGetString("Bidirectional option not found!", ls, sizeof(ls));
fprintf(stderr, "%s\n", ls);
return -1;
}
return 0;
}
/*
* Obtention d'une donnée du fichier PPD
* Get a string from the PPD file
*/
PPDValue PPDFile::get(const char *name, const char *opt)
{
ppd_attr_t *attr;
PPDValue val;
if (!_ppd) {
ERRORMSG(_("Trying to read a PPD file which wasn't opened"));
return val;
}
if (!opt)
attr = ppdFindAttr(_ppd, name, NULL);
else
attr = ppdFindAttr(_ppd, opt, name);
if (!attr) {
ppd_choice_t *choice;
choice = ppdFindMarkedChoice(_ppd, name);
if (!choice)
return val;
val.set(choice->choice);
} else
val.set(attr->value);
return val;
}
int /* O - 1 on success, 0 on failure */
cupsResolveConflicts(
ppd_file_t *ppd, /* I - PPD file */
const char *option, /* I - Newly selected option or @code NULL@ for none */
const char *choice, /* I - Newly selected choice or @code NULL@ for none */
int *num_options, /* IO - Number of additional selected options */
cups_option_t **options) /* IO - Additional selected options */
{
int i, /* Looping var */
tries, /* Number of tries */
num_newopts; /* Number of new options */
cups_option_t *newopts; /* New options */
cups_array_t *active = NULL, /* Active constraints */
*pass, /* Resolvers for this pass */
*resolvers, /* Resolvers we have used */
*test; /* Test array for conflicts */
_ppd_cups_uiconsts_t *consts; /* Current constraints */
_ppd_cups_uiconst_t *constptr; /* Current constraint */
ppd_attr_t *resolver; /* Current resolver */
const char *resval; /* Pointer into resolver value */
char resoption[PPD_MAX_NAME],
/* Current resolver option */
reschoice[PPD_MAX_NAME],
/* Current resolver choice */
*resptr, /* Pointer into option/choice */
firstpage[255]; /* AP_FIRSTPAGE_Keyword string */
const char *value; /* Selected option value */
int changed; /* Did we change anything? */
ppd_choice_t *marked; /* Marked choice */
/*
* Range check input...
*/
if (!ppd || !num_options || !options || (option == NULL) != (choice == NULL))
return (0);
/*
* Build a shadow option array...
*/
num_newopts = 0;
newopts = NULL;
for (i = 0; i < *num_options; i ++)
num_newopts = cupsAddOption((*options)[i].name, (*options)[i].value,
num_newopts, &newopts);
if (option && _cups_strcasecmp(option, "Collate"))
num_newopts = cupsAddOption(option, choice, num_newopts, &newopts);
/*
* Loop until we have no conflicts...
*/
cupsArraySave(ppd->sorted_attrs);
resolvers = NULL;
pass = cupsArrayNew((cups_array_func_t)_cups_strcasecmp, NULL);
tries = 0;
while (tries < 100 &&
(active = ppd_test_constraints(ppd, NULL, NULL, num_newopts, newopts,
_PPD_ALL_CONSTRAINTS)) != NULL)
{
tries ++;
if (!resolvers)
resolvers = cupsArrayNew((cups_array_func_t)_cups_strcasecmp, NULL);
for (consts = (_ppd_cups_uiconsts_t *)cupsArrayFirst(active), changed = 0;
consts;
consts = (_ppd_cups_uiconsts_t *)cupsArrayNext(active))
{
if (consts->resolver[0])
{
/*
* Look up the resolver...
*/
if (cupsArrayFind(pass, consts->resolver))
continue; /* Already applied this resolver... */
if (cupsArrayFind(resolvers, consts->resolver))
{
/*
* Resolver loop!
*/
DEBUG_printf(("1cupsResolveConflicts: Resolver loop with %s!",
consts->resolver));
goto error;
}
if ((resolver = ppdFindAttr(ppd, "cupsUIResolver",
consts->resolver)) == NULL)
{
DEBUG_printf(("1cupsResolveConflicts: Resolver %s not found!",
consts->resolver));
goto error;
}
if (!resolver->value)
{
DEBUG_printf(("1cupsResolveConflicts: Resolver %s has no value!",
consts->resolver));
goto error;
}
/*
* Add the options from the resolver...
*/
cupsArrayAdd(pass, consts->resolver);
cupsArrayAdd(resolvers, consts->resolver);
for (resval = resolver->value; *resval && !changed;)
{
while (_cups_isspace(*resval))
resval ++;
if (*resval != '*')
break;
for (resval ++, resptr = resoption;
*resval && !_cups_isspace(*resval);
resval ++)
if (resptr < (resoption + sizeof(resoption) - 1))
*resptr++ = *resval;
*resptr = '\0';
while (_cups_isspace(*resval))
resval ++;
for (resptr = reschoice;
*resval && !_cups_isspace(*resval);
resval ++)
if (resptr < (reschoice + sizeof(reschoice) - 1))
*resptr++ = *resval;
*resptr = '\0';
if (!resoption[0] || !reschoice[0])
break;
/*
* Is this the option we are changing?
*/
snprintf(firstpage, sizeof(firstpage), "AP_FIRSTPAGE_%s", resoption);
if (option &&
(!_cups_strcasecmp(resoption, option) ||
!_cups_strcasecmp(firstpage, option) ||
(!_cups_strcasecmp(option, "PageSize") &&
!_cups_strcasecmp(resoption, "PageRegion")) ||
(!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageSize") &&
!_cups_strcasecmp(resoption, "PageSize")) ||
(!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageSize") &&
!_cups_strcasecmp(resoption, "PageRegion")) ||
(!_cups_strcasecmp(option, "PageRegion") &&
!_cups_strcasecmp(resoption, "PageSize")) ||
(!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageRegion") &&
!_cups_strcasecmp(resoption, "PageSize")) ||
(!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageRegion") &&
!_cups_strcasecmp(resoption, "PageRegion"))))
continue;
/*
* Try this choice...
*/
if ((test = ppd_test_constraints(ppd, resoption, reschoice,
num_newopts, newopts,
_PPD_ALL_CONSTRAINTS)) == NULL)
{
/*
* That worked...
*/
changed = 1;
}
else
cupsArrayDelete(test);
/*
* Add the option/choice from the resolver regardless of whether it
* worked; this makes sure that we can cascade several changes to
* make things resolve...
*/
num_newopts = cupsAddOption(resoption, reschoice, num_newopts,
&newopts);
}
}
else
{
/*
* Try resolving by choosing the default values for non-installable
* options, then by iterating through the possible choices...
*/
int j; /* Looping var */
ppd_choice_t *cptr; /* Current choice */
ppd_size_t *size; /* Current page size */
for (i = consts->num_constraints, constptr = consts->constraints;
i > 0 && !changed;
i --, constptr ++)
{
/*
* Can't resolve by changing an installable option...
*/
if (constptr->installable)
continue;
/*
* Is this the option we are changing?
*/
if (option &&
(!_cups_strcasecmp(constptr->option->keyword, option) ||
(!_cups_strcasecmp(option, "PageSize") &&
!_cups_strcasecmp(constptr->option->keyword, "PageRegion")) ||
(!_cups_strcasecmp(option, "PageRegion") &&
!_cups_strcasecmp(constptr->option->keyword, "PageSize"))))
continue;
/*
* Get the current option choice...
*/
if ((value = cupsGetOption(constptr->option->keyword, num_newopts,
newopts)) == NULL)
{
if (!_cups_strcasecmp(constptr->option->keyword, "PageSize") ||
!_cups_strcasecmp(constptr->option->keyword, "PageRegion"))
{
if ((value = cupsGetOption("PageSize", num_newopts,
newopts)) == NULL)
value = cupsGetOption("PageRegion", num_newopts, newopts);
if (!value)
{
if ((size = ppdPageSize(ppd, NULL)) != NULL)
value = size->name;
else
value = "";
}
}
else
{
marked = ppdFindMarkedChoice(ppd, constptr->option->keyword);
value = marked ? marked->choice : "";
}
}
if (!_cups_strncasecmp(value, "Custom.", 7))
value = "Custom";
/*
* Try the default choice...
*/
test = NULL;
if (_cups_strcasecmp(value, constptr->option->defchoice) &&
(test = ppd_test_constraints(ppd, constptr->option->keyword,
constptr->option->defchoice,
num_newopts, newopts,
_PPD_OPTION_CONSTRAINTS)) == NULL)
{
/*
* That worked...
*/
num_newopts = cupsAddOption(constptr->option->keyword,
constptr->option->defchoice,
num_newopts, &newopts);
changed = 1;
}
else
{
/*
* Try each choice instead...
*/
for (j = constptr->option->num_choices,
cptr = constptr->option->choices;
j > 0;
j --, cptr ++)
{
cupsArrayDelete(test);
test = NULL;
if (_cups_strcasecmp(value, cptr->choice) &&
_cups_strcasecmp(constptr->option->defchoice, cptr->choice) &&
_cups_strcasecmp("Custom", cptr->choice) &&
(test = ppd_test_constraints(ppd, constptr->option->keyword,
cptr->choice, num_newopts,
newopts,
_PPD_OPTION_CONSTRAINTS)) == NULL)
{
/*
* This choice works...
*/
num_newopts = cupsAddOption(constptr->option->keyword,
cptr->choice, num_newopts,
&newopts);
changed = 1;
break;
}
}
cupsArrayDelete(test);
}
}
}
}
if (!changed)
{
DEBUG_puts("1cupsResolveConflicts: Unable to automatically resolve "
"constraint!");
goto error;
}
cupsArrayClear(pass);
cupsArrayDelete(active);
active = NULL;
}
if (tries >= 100)
goto error;
/*
* Free the caller's option array...
*/
cupsFreeOptions(*num_options, *options);
/*
* If Collate is the option we are testing, add it here. Otherwise, remove
* any Collate option from the resolve list since the filters automatically
* handle manual collation...
*/
if (option && !_cups_strcasecmp(option, "Collate"))
num_newopts = cupsAddOption(option, choice, num_newopts, &newopts);
else
num_newopts = cupsRemoveOption("Collate", num_newopts, &newopts);
/*
* Return the new list of options to the caller...
*/
*num_options = num_newopts;
*options = newopts;
cupsArrayDelete(pass);
cupsArrayDelete(resolvers);
cupsArrayRestore(ppd->sorted_attrs);
DEBUG_printf(("1cupsResolveConflicts: Returning %d options:", num_newopts));
#ifdef DEBUG
for (i = 0; i < num_newopts; i ++)
DEBUG_printf(("1cupsResolveConflicts: options[%d]: %s=%s", i,
newopts[i].name, newopts[i].value));
#endif /* DEBUG */
return (1);
/*
* If we get here, we failed to resolve...
*/
error:
cupsFreeOptions(num_newopts, newopts);
cupsArrayDelete(active);
cupsArrayDelete(pass);
cupsArrayDelete(resolvers);
cupsArrayRestore(ppd->sorted_attrs);
DEBUG_puts("1cupsResolveConflicts: Unable to resolve conflicts!");
return (0);
}
static void
ppd_handle_media(ppd_file_t *ppd) /* I - PPD file */
{
ppd_choice_t *manual_feed, /* ManualFeed choice, if any */
*input_slot; /* InputSlot choice, if any */
ppd_size_t *size; /* Current media size */
ppd_attr_t *rpr; /* RequiresPageRegion value */
/*
* This function determines what page size code to use, if any, for the
* current media size, InputSlot, and ManualFeed selections.
*
* We use the PageSize code if:
*
* 1. A custom media size is selected.
* 2. ManualFeed and InputSlot are not selected (or do not exist).
* 3. ManualFeed is selected but is False and InputSlot is not selected or
* the selection has no code - the latter check done to support "auto" or
* "printer default" InputSlot options.
*
* We use the PageRegion code if:
*
* 4. RequiresPageRegion does not exist and the PPD contains cupsFilter
* keywords, indicating this is a CUPS-based driver.
* 5. RequiresPageRegion exists for the selected InputSlot (or "All" for any
* InputSlot or ManualFeed selection) and is True.
*
* If none of the 5 conditions are true, no page size code is used and we
* unmark any existing PageSize or PageRegion choices.
*/
if ((size = ppdPageSize(ppd, NULL)) == NULL)
return;
manual_feed = ppdFindMarkedChoice(ppd, "ManualFeed");
input_slot = ppdFindMarkedChoice(ppd, "InputSlot");
if (input_slot != NULL)
rpr = ppdFindAttr(ppd, "RequiresPageRegion", input_slot->choice);
else
rpr = NULL;
if (!rpr)
rpr = ppdFindAttr(ppd, "RequiresPageRegion", "All");
if (!_cups_strcasecmp(size->name, "Custom") ||
(!manual_feed && !input_slot) ||
(manual_feed && !_cups_strcasecmp(manual_feed->choice, "False") &&
(!input_slot || (input_slot->code && !input_slot->code[0]))) ||
(!rpr && ppd->num_filters > 0))
{
/*
* Use PageSize code...
*/
ppdMarkOption(ppd, "PageSize", size->name);
}
else if (rpr && rpr->value && !_cups_strcasecmp(rpr->value, "True"))
{
/*
* Use PageRegion code...
*/
ppdMarkOption(ppd, "PageRegion", size->name);
}
else
{
/*
* Do not use PageSize or PageRegion code...
*/
ppd_choice_t *page; /* PageSize/Region choice, if any */
if ((page = ppdFindMarkedChoice(ppd, "PageSize")) != NULL)
{
/*
* Unmark PageSize...
*/
page->marked = 0;
cupsArrayRemove(ppd->marked, page);
}
if ((page = ppdFindMarkedChoice(ppd, "PageRegion")) != NULL)
{
/*
* Unmark PageRegion...
*/
page->marked = 0;
cupsArrayRemove(ppd->marked, page);
}
}
}
int /* O - 1 if custom sizes are supported, 0 otherwise */
ppdPageSizeLimits(ppd_file_t *ppd, /* I - PPD file record */
ppd_size_t *minimum, /* O - Minimum custom size */
ppd_size_t *maximum) /* O - Maximum custom size */
{
ppd_choice_t *qualifier2, /* Second media qualifier */
*qualifier3; /* Third media qualifier */
ppd_attr_t *attr; /* Attribute */
float width, /* Min/max width */
length; /* Min/max length */
char spec[PPD_MAX_NAME]; /* Selector for min/max */
/*
* Range check input...
*/
if (!ppd || !ppd->variable_sizes || !minimum || !maximum)
{
if (minimum)
memset(minimum, 0, sizeof(ppd_size_t));
if (maximum)
memset(maximum, 0, sizeof(ppd_size_t));
return (0);
}
/*
* See if we have the cupsMediaQualifier2 and cupsMediaQualifier3 attributes...
*/
cupsArraySave(ppd->sorted_attrs);
if ((attr = ppdFindAttr(ppd, "cupsMediaQualifier2", NULL)) != NULL &&
attr->value)
qualifier2 = ppdFindMarkedChoice(ppd, attr->value);
else
qualifier2 = NULL;
if ((attr = ppdFindAttr(ppd, "cupsMediaQualifier3", NULL)) != NULL &&
attr->value)
qualifier3 = ppdFindMarkedChoice(ppd, attr->value);
else
qualifier3 = NULL;
/*
* Figure out the current minimum width and length...
*/
width = ppd->custom_min[0];
length = ppd->custom_min[1];
if (qualifier2)
{
/*
* Try getting cupsMinSize...
*/
if (qualifier3)
{
snprintf(spec, sizeof(spec), ".%s.%s", qualifier2->choice,
qualifier3->choice);
attr = ppdFindAttr(ppd, "cupsMinSize", spec);
}
else
attr = NULL;
if (!attr)
{
snprintf(spec, sizeof(spec), ".%s.", qualifier2->choice);
attr = ppdFindAttr(ppd, "cupsMinSize", spec);
}
if (!attr && qualifier3)
{
snprintf(spec, sizeof(spec), "..%s", qualifier3->choice);
attr = ppdFindAttr(ppd, "cupsMinSize", spec);
}
if ((attr && attr->value &&
sscanf(attr->value, "%f%f", &width, &length) != 2) || !attr)
{
width = ppd->custom_min[0];
length = ppd->custom_min[1];
}
}
minimum->width = width;
minimum->length = length;
minimum->left = ppd->custom_margins[0];
minimum->bottom = ppd->custom_margins[1];
minimum->right = width - ppd->custom_margins[2];
minimum->top = length - ppd->custom_margins[3];
/*
* Figure out the current maximum width and length...
*/
width = ppd->custom_max[0];
length = ppd->custom_max[1];
if (qualifier2)
{
/*
* Try getting cupsMaxSize...
*/
if (qualifier3)
{
snprintf(spec, sizeof(spec), ".%s.%s", qualifier2->choice,
qualifier3->choice);
attr = ppdFindAttr(ppd, "cupsMaxSize", spec);
}
else
attr = NULL;
if (!attr)
{
snprintf(spec, sizeof(spec), ".%s.", qualifier2->choice);
attr = ppdFindAttr(ppd, "cupsMaxSize", spec);
}
if (!attr && qualifier3)
{
snprintf(spec, sizeof(spec), "..%s", qualifier3->choice);
attr = ppdFindAttr(ppd, "cupsMaxSize", spec);
}
if (!attr ||
(attr->value && sscanf(attr->value, "%f%f", &width, &length) != 2))
{
width = ppd->custom_max[0];
length = ppd->custom_max[1];
}
}
maximum->width = width;
maximum->length = length;
maximum->left = ppd->custom_margins[0];
maximum->bottom = ppd->custom_margins[1];
maximum->right = width - ppd->custom_margins[2];
maximum->top = length - ppd->custom_margins[3];
/*
* Return the min and max...
*/
cupsArrayRestore(ppd->sorted_attrs);
return (1);
}
void
EndPage(ppd_file_t *ppd, /* I - PPD file */
cups_page_header2_t *header) /* I - Page header */
{
int val; /* Option value */
ppd_choice_t *choice; /* Marked choice */
switch (ModelNumber)
{
case DYMO_3x0 :
/*
* Eject the current page...
*/
fputs("\033E", stdout);
break;
case ZEBRA_EPL_LINE :
/*
* End buffered output, eject the label...
*/
fputs("\033E\014", stdout);
break;
case ZEBRA_EPL_PAGE :
/*
* Print the label...
*/
puts("P1");
break;
case ZEBRA_ZPL :
if (Canceled)
{
/*
* Cancel bitmap download...
*/
puts("~DN");
break;
}
/*
* Start label...
*/
puts("^XA");
/*
* Set print rate...
*/
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
{
val = atoi(choice->choice);
printf("^PR%d,%d,%d\n", val, val, val);
}
/*
* Put label home in default position (0,0)...
*/
printf("^LH0,0\n");
/*
* Set media tracking...
*/
if (ppdIsMarked(ppd, "zeMediaTracking", "Continuous"))
{
/*
* Add label length command for continuous...
*/
printf("^LL%d\n", header->cupsHeight);
printf("^MNN\n");
}
else if (ppdIsMarked(ppd, "zeMediaTracking", "Web"))
printf("^MNY\n");
else if (ppdIsMarked(ppd, "zeMediaTracking", "Mark"))
printf("^MNM\n");
/*
* Set label top
*/
if (header->cupsRowStep != 200)
printf("^LT%d\n", header->cupsRowStep);
/*
* Set media type...
*/
if (!strcmp(header->MediaType, "Thermal"))
printf("^MTT\n");
else if (!strcmp(header->MediaType, "Direct"))
printf("^MTD\n");
/*
* Set print mode...
*/
if ((choice = ppdFindMarkedChoice(ppd, "zePrintMode")) != NULL &&
strcmp(choice->choice, "Saved"))
{
printf("^MM");
if (!strcmp(choice->choice, "Tear"))
printf("T,Y\n");
else if (!strcmp(choice->choice, "Peel"))
printf("P,Y\n");
else if (!strcmp(choice->choice, "Rewind"))
printf("R,Y\n");
else if (!strcmp(choice->choice, "Applicator"))
printf("A,Y\n");
else
printf("C,Y\n");
}
/*
* Set tear-off adjust position...
*/
if (header->AdvanceDistance != 1000)
{
if ((int)header->AdvanceDistance < 0)
printf("~TA%04d\n", (int)header->AdvanceDistance);
else
printf("~TA%03d\n", (int)header->AdvanceDistance);
}
/*
* Allow for reprinting after an error...
*/
if (ppdIsMarked(ppd, "zeErrorReprint", "Always"))
printf("^JZY\n");
else if (ppdIsMarked(ppd, "zeErrorReprint", "Never"))
printf("^JZN\n");
/*
* Print multiple copies
*/
if (header->NumCopies > 1)
printf("^PQ%d, 0, 0, N\n", header->NumCopies);
/*
* Display the label image...
*/
puts("^FO0,0^XGR:CUPS.GRF,1,1^FS");
/*
* End the label and eject...
*/
puts("^IDR:CUPS.GRF^FS");
puts("^XZ");
break;
case ZEBRA_CPCL :
/*
* Set tear-off adjust position...
*/
if (header->AdvanceDistance != 1000)
printf("PRESENT-AT %d 1\r\n", (int)header->AdvanceDistance);
/*
* Allow for reprinting after an error...
*/
if (ppdIsMarked(ppd, "zeErrorReprint", "Always"))
puts("ON-OUT-OF-PAPER WAIT\r");
else if (ppdIsMarked(ppd, "zeErrorReprint", "Never"))
puts("ON-OUT-OF-PAPER PURGE\r");
/*
* Cut label?
*/
if (header->CutMedia)
puts("CUT\r");
/*
* Set darkness...
*/
if (header->cupsCompression > 0)
printf("TONE %u\r\n", 2 * header->cupsCompression);
/*
* Set print rate...
*/
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
{
val = atoi(choice->choice);
printf("SPEED %d\r\n", val);
}
/*
* Print the label...
*/
if ((choice = ppdFindMarkedChoice(ppd, "zeMediaTracking")) == NULL ||
strcmp(choice->choice, "Continuous"))
puts("FORM\r");
puts("PRINT\r");
break;
case INTELLITECH_PCL :
printf("\033*rB"); /* End GFX */
printf("\014"); /* Eject current page */
break;
}
fflush(stdout);
/*
* Free memory...
*/
free(Buffer);
if (CompBuffer)
{
free(CompBuffer);
CompBuffer = NULL;
}
if (LastBuffer)
{
free(LastBuffer);
LastBuffer = NULL;
}
}
void
StartPage(ppd_file_t *ppd, /* I - PPD file */
cups_page_header2_t *header) /* I - Page header */
{
ppd_choice_t *choice; /* Marked choice */
unsigned length; /* Actual label length */
/*
* Show page device dictionary...
*/
fprintf(stderr, "DEBUG: StartPage...\n");
fprintf(stderr, "DEBUG: MediaClass = \"%s\"\n", header->MediaClass);
fprintf(stderr, "DEBUG: MediaColor = \"%s\"\n", header->MediaColor);
fprintf(stderr, "DEBUG: MediaType = \"%s\"\n", header->MediaType);
fprintf(stderr, "DEBUG: OutputType = \"%s\"\n", header->OutputType);
fprintf(stderr, "DEBUG: AdvanceDistance = %d\n", header->AdvanceDistance);
fprintf(stderr, "DEBUG: AdvanceMedia = %d\n", header->AdvanceMedia);
fprintf(stderr, "DEBUG: Collate = %d\n", header->Collate);
fprintf(stderr, "DEBUG: CutMedia = %d\n", header->CutMedia);
fprintf(stderr, "DEBUG: Duplex = %d\n", header->Duplex);
fprintf(stderr, "DEBUG: HWResolution = [ %d %d ]\n", header->HWResolution[0],
header->HWResolution[1]);
fprintf(stderr, "DEBUG: ImagingBoundingBox = [ %d %d %d %d ]\n",
header->ImagingBoundingBox[0], header->ImagingBoundingBox[1],
header->ImagingBoundingBox[2], header->ImagingBoundingBox[3]);
fprintf(stderr, "DEBUG: InsertSheet = %d\n", header->InsertSheet);
fprintf(stderr, "DEBUG: Jog = %d\n", header->Jog);
fprintf(stderr, "DEBUG: LeadingEdge = %d\n", header->LeadingEdge);
fprintf(stderr, "DEBUG: Margins = [ %d %d ]\n", header->Margins[0],
header->Margins[1]);
fprintf(stderr, "DEBUG: ManualFeed = %d\n", header->ManualFeed);
fprintf(stderr, "DEBUG: MediaPosition = %d\n", header->MediaPosition);
fprintf(stderr, "DEBUG: MediaWeight = %d\n", header->MediaWeight);
fprintf(stderr, "DEBUG: MirrorPrint = %d\n", header->MirrorPrint);
fprintf(stderr, "DEBUG: NegativePrint = %d\n", header->NegativePrint);
fprintf(stderr, "DEBUG: NumCopies = %d\n", header->NumCopies);
fprintf(stderr, "DEBUG: Orientation = %d\n", header->Orientation);
fprintf(stderr, "DEBUG: OutputFaceUp = %d\n", header->OutputFaceUp);
fprintf(stderr, "DEBUG: PageSize = [ %d %d ]\n", header->PageSize[0],
header->PageSize[1]);
fprintf(stderr, "DEBUG: Separations = %d\n", header->Separations);
fprintf(stderr, "DEBUG: TraySwitch = %d\n", header->TraySwitch);
fprintf(stderr, "DEBUG: Tumble = %d\n", header->Tumble);
fprintf(stderr, "DEBUG: cupsWidth = %d\n", header->cupsWidth);
fprintf(stderr, "DEBUG: cupsHeight = %d\n", header->cupsHeight);
fprintf(stderr, "DEBUG: cupsMediaType = %d\n", header->cupsMediaType);
fprintf(stderr, "DEBUG: cupsBitsPerColor = %d\n", header->cupsBitsPerColor);
fprintf(stderr, "DEBUG: cupsBitsPerPixel = %d\n", header->cupsBitsPerPixel);
fprintf(stderr, "DEBUG: cupsBytesPerLine = %d\n", header->cupsBytesPerLine);
fprintf(stderr, "DEBUG: cupsColorOrder = %d\n", header->cupsColorOrder);
fprintf(stderr, "DEBUG: cupsColorSpace = %d\n", header->cupsColorSpace);
fprintf(stderr, "DEBUG: cupsCompression = %d\n", header->cupsCompression);
fprintf(stderr, "DEBUG: cupsRowCount = %d\n", header->cupsRowCount);
fprintf(stderr, "DEBUG: cupsRowFeed = %d\n", header->cupsRowFeed);
fprintf(stderr, "DEBUG: cupsRowStep = %d\n", header->cupsRowStep);
switch (ModelNumber)
{
case DYMO_3x0 :
/*
* Setup printer/job attributes...
*/
length = header->PageSize[1] * header->HWResolution[1] / 72;
printf("\033L%c%c", length >> 8, length);
printf("\033D%c", header->cupsBytesPerLine);
printf("\033%c", header->cupsCompression + 'c'); /* Darkness */
break;
case ZEBRA_EPL_LINE :
/*
* Set print rate...
*/
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
printf("\033S%.0f", atof(choice->choice) * 2.0 - 2.0);
/*
* Set darkness...
*/
if (header->cupsCompression > 0 && header->cupsCompression <= 100)
printf("\033D%d", 7 * header->cupsCompression / 100);
/*
* Set left margin to 0...
*/
fputs("\033M01", stdout);
/*
* Start buffered output...
*/
fputs("\033B", stdout);
break;
case ZEBRA_EPL_PAGE :
/*
* Start a new label...
*/
puts("");
puts("N");
/*
* Set hardware options...
*/
if (!strcmp(header->MediaType, "Direct"))
puts("OD");
/*
* Set print rate...
*/
if ((choice = ppdFindMarkedChoice(ppd, "zePrintRate")) != NULL &&
strcmp(choice->choice, "Default"))
{
double val = atof(choice->choice);
if (val >= 3.0)
printf("S%.0f\n", val);
else
printf("S%.0f\n", val * 2.0 - 2.0);
}
/*
* Set darkness...
*/
if (header->cupsCompression > 0 && header->cupsCompression <= 100)
printf("D%u\n", 15 * header->cupsCompression / 100);
/*
* Set label size...
*/
printf("q%u\n", (header->cupsWidth + 7) & ~7U);
break;
case ZEBRA_ZPL :
/*
* Set darkness...
*/
if (header->cupsCompression > 0 && header->cupsCompression <= 100)
printf("~SD%02u\n", 30 * header->cupsCompression / 100);
/*
* Start bitmap graphics...
*/
printf("~DGR:CUPS.GRF,%u,%u,\n",
header->cupsHeight * header->cupsBytesPerLine,
header->cupsBytesPerLine);
/*
* Allocate compression buffers...
*/
CompBuffer = malloc(2 * header->cupsBytesPerLine + 1);
LastBuffer = malloc(header->cupsBytesPerLine);
LastSet = 0;
break;
case ZEBRA_CPCL :
/*
* Start label...
*/
printf("! 0 %u %u %u %u\r\n", header->HWResolution[0],
header->HWResolution[1], header->cupsHeight,
header->NumCopies);
printf("PAGE-WIDTH %u\r\n", header->cupsWidth);
printf("PAGE-HEIGHT %u\r\n", header->cupsWidth);
break;
case INTELLITECH_PCL :
/*
* Set the media size...
*/
printf("\033&l6D\033&k12H"); /* Set 6 LPI, 10 CPI */
printf("\033&l0O"); /* Set portrait orientation */
switch (header->PageSize[1])
{
case 540 : /* Monarch Envelope */
printf("\033&l80A"); /* Set page size */
break;
case 624 : /* DL Envelope */
printf("\033&l90A"); /* Set page size */
break;
case 649 : /* C5 Envelope */
printf("\033&l91A"); /* Set page size */
break;
case 684 : /* COM-10 Envelope */
printf("\033&l81A"); /* Set page size */
break;
case 756 : /* Executive */
printf("\033&l1A"); /* Set page size */
break;
case 792 : /* Letter */
printf("\033&l2A"); /* Set page size */
break;
case 842 : /* A4 */
printf("\033&l26A"); /* Set page size */
break;
case 1008 : /* Legal */
printf("\033&l3A"); /* Set page size */
break;
default : /* Custom size */
printf("\033!f%uZ", header->PageSize[1] * 300 / 72);
break;
}
printf("\033&l%uP", /* Set page length */
header->PageSize[1] / 12);
printf("\033&l0E"); /* Set top margin to 0 */
if (header->NumCopies)
printf("\033&l%uX", header->NumCopies);
/* Set number copies */
printf("\033&l0L"); /* Turn off perforation skip */
/*
* Print settings...
*/
if (Page == 1)
{
if (header->cupsRowFeed) /* inPrintRate */
printf("\033!p%uS", header->cupsRowFeed);
if (header->cupsCompression != ~0U)
/* inPrintDensity */
printf("\033&d%uA", 30 * header->cupsCompression / 100 - 15);
if ((choice = ppdFindMarkedChoice(ppd, "inPrintMode")) != NULL)
{
if (!strcmp(choice->choice, "Standard"))
fputs("\033!p0M", stdout);
else if (!strcmp(choice->choice, "Tear"))
{
fputs("\033!p1M", stdout);
if (header->cupsRowCount) /* inTearInterval */
printf("\033!n%uT", header->cupsRowCount);
}
else
{
fputs("\033!p2M", stdout);
if (header->cupsRowStep) /* inCutInterval */
printf("\033!n%uC", header->cupsRowStep);
}
}
}
/*
* Setup graphics...
*/
printf("\033*t%uR", header->HWResolution[0]);
/* Set resolution */
printf("\033*r%uS", header->cupsWidth);
/* Set width */
printf("\033*r%uT", header->cupsHeight);
/* Set height */
printf("\033&a0H"); /* Set horizontal position */
printf("\033&a0V"); /* Set vertical position */
printf("\033*r1A"); /* Start graphics */
printf("\033*b3M"); /* Set compression */
/*
* Allocate compression buffers...
*/
CompBuffer = malloc(2 * header->cupsBytesPerLine + 1);
LastBuffer = malloc(header->cupsBytesPerLine);
LastSet = 0;
break;
}
/*
* Allocate memory for a line of graphics...
*/
Buffer = malloc(header->cupsBytesPerLine);
Feed = 0;
}
int /* O - Exit status */
imagetops_main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
cups_image_t *img; /* Image to print */
float xprint, /* Printable area */
yprint,
xinches, /* Total size in inches */
yinches;
float xsize, /* Total size in points */
ysize,
xsize2,
ysize2;
float aspect; /* Aspect ratio */
int xpages, /* # x pages */
ypages, /* # y pages */
xpage, /* Current x page */
ypage, /* Current y page */
page; /* Current page number */
int xc0, yc0, /* Corners of the page in image coords */
xc1, yc1;
cups_ib_t *row; /* Current row */
int y; /* Current Y coordinate in image */
int colorspace; /* Output colorspace */
int out_offset, /* Offset into output buffer */
out_length; /* Length of output buffer */
ppd_file_t *ppd; /* PPD file */
ppd_choice_t *choice; /* PPD option choice */
int num_options; /* Number of print options */
cups_option_t *options; /* Print options */
const char *val; /* Option value */
int slowcollate; /* Collate copies the slow way */
float g; /* Gamma correction value */
float b; /* Brightness factor */
float zoom; /* Zoom facter */
int xppi, yppi; /* Pixels-per-inch */
int hue, sat; /* Hue and saturation adjustment */
int realcopies, /* Real copies being printed */
emit_jcl; /* Emit JCL? */
float left, top; /* Left and top of image */
char filename[1024]; /* Name of file to print */
time_t curtime; /* Current time */
struct tm *curtm; /* Current date */
char curdate[255]; /* Current date string */
int psFileMode = 0; //0:CREATE New ; 1: Append
int outColorDevice = 1; //0 : monochrome print , 1:color print
int count = 0,numFiles=1;
int defout,outfd;
/*
* Make sure status messages are not buffered...
*/
int ii=0;
for(;ii<argc;ii++)
LOGI("imagetops : argv:%s",argv[ii]);
fflush(stdout);
Copies = 1;
setbuf(stderr, NULL);
/*
* Ignore broken pipe signals...
*/
signal(SIGPIPE, SIG_IGN);
/*
* Process command-line options and write the prolog...
*/
zoom = 0.0;
xppi = 0;
yppi = 0;
hue = 0;
sat = 100;
g = 1.0;
b = 1.0;
Copies = atoi(argv[4]);
options = NULL;
num_options = cupsParseOptions(argv[5], 0, &options);
ppdFilePath = argv[6];
ContentType= argv[7];
psFilePath = argv[8];
outColorDevice = atoi(argv[9]);
numFiles = argc - 10;
LOGI("imagetops : numFiles=%d",numFiles);
ppd = SetCommonOptions(num_options, options, 0);
if ((val = cupsGetOption("multiple-document-handling", num_options, options)) != NULL)
{
/*
* This IPP attribute is unnecessarily complicated...
*
* single-document, separate-documents-collated-copies, and
* single-document-new-sheet all require collated copies.
*
* separate-documents-uncollated-copies allows for uncollated copies.
*/
Collate = _cups_strcasecmp(val, "separate-documents-uncollated-copies") != 0;
}
if ((val = cupsGetOption("Collate", num_options, options)) != NULL &&
_cups_strcasecmp(val, "True") == 0)
Collate = 1;
if ((val = cupsGetOption("gamma", num_options, options)) != NULL)
{
/*
* Get gamma value from 1 to 10000...
*/
g = atoi(val) * 0.001f;
if (g < 0.001f)
g = 0.001f;
else if (g > 10.0f)
g = 10.0f;
}
if ((val = cupsGetOption("brightness", num_options, options)) != NULL)
{
/*
* Get brightness value from 10 to 1000.
*/
b = atoi(val) * 0.01f;
if (b < 0.1f)
b = 0.1f;
else if (b > 10.0f)
b = 10.0f;
}
if ((val = cupsGetOption("scaling", num_options, options)) != NULL)
zoom = atoi(val) * 0.01;
else if ((val = cupsGetOption("fitplot", num_options, options)) != NULL &&
!_cups_strcasecmp(val, "true"))
zoom = 1.0;
else if ((val = cupsGetOption("fit-to-page", num_options, options)) != NULL &&
!_cups_strcasecmp(val, "true"))
zoom = 1.0;
if ((val = cupsGetOption("ppi", num_options, options)) != NULL)
if (sscanf(val, "%dx%d", &xppi, &yppi) < 2)
yppi = xppi;
if ((val = cupsGetOption("position", num_options, options)) != NULL)
{
if (_cups_strcasecmp(val, "center") == 0)
{
XPosition = 0;
YPosition = 0;
}
else if (_cups_strcasecmp(val, "top") == 0)
{
XPosition = 0;
YPosition = 1;
}
else if (_cups_strcasecmp(val, "left") == 0)
{
XPosition = -1;
YPosition = 0;
}
else if (_cups_strcasecmp(val, "right") == 0)
{
XPosition = 1;
YPosition = 0;
}
else if (_cups_strcasecmp(val, "top-left") == 0)
{
XPosition = -1;
YPosition = 1;
}
else if (_cups_strcasecmp(val, "top-right") == 0)
{
XPosition = 1;
YPosition = 1;
}
else if (_cups_strcasecmp(val, "bottom") == 0)
{
XPosition = 0;
YPosition = -1;
}
else if (_cups_strcasecmp(val, "bottom-left") == 0)
{
XPosition = -1;
YPosition = -1;
}
else if (_cups_strcasecmp(val, "bottom-right") == 0)
{
XPosition = 1;
YPosition = -1;
}
}
if ((val = cupsGetOption("saturation", num_options, options)) != NULL)
sat = atoi(val);
if ((val = cupsGetOption("hue", num_options, options)) != NULL)
hue = atoi(val);
if ((choice = ppdFindMarkedChoice(ppd, "MirrorPrint")) != NULL)
{
val = choice->choice;
choice->marked = 0;
}
else
val = cupsGetOption("mirror", num_options, options);
if (val && (!_cups_strcasecmp(val, "true") || !_cups_strcasecmp(val, "on") ||
!_cups_strcasecmp(val, "yes")))
Flip = 1;
if ((val = cupsGetOption("emit-jcl", num_options, options)) != NULL &&
(!_cups_strcasecmp(val, "false") || !_cups_strcasecmp(val, "off") ||
!_cups_strcasecmp(val, "no") || !strcmp(val, "0")))
emit_jcl = 0;
else
emit_jcl = 1;
LOGI("imagetops/Copies=%d , Collate=%d, gamma=%f, brightness=%f, zoom=%f",Copies,Collate,g,b,zoom);
LOGI("imagetops/xppi=%d,yppi=%d,XPosition=%d,YPosition=%d,sat=%d,hue=%d,flip=%d,emit_jcl=%d",xppi,yppi,XPosition,YPosition,sat,hue,Flip,emit_jcl);
/*
* Open the input image to print...
*/
if(outColorDevice == 1) //added @ grv
colorspace = CUPS_IMAGE_RGB_CMYK;
else
colorspace = CUPS_IMAGE_WHITE;
LOGI("imagetops/ colorspace = %d",colorspace);
for(count=0;count<numFiles;count++){
Copies = atoi(argv[4]);
//do everything for both image files
strlcpy(filename, argv[(10 + count)], sizeof(filename));
LOGI("imagetops : count=%d , filename=%s",count,filename);
img = cupsImageOpen(filename, colorspace, CUPS_IMAGE_WHITE, sat, hue, NULL);
if (img == NULL)
{
LOGI("imagetops:error:The print file could not be opened.");
_cupsLangPrintFilter(stderr, "ERROR",
_("The print file could not be opened."));
ppdClose(ppd);
return (1);
}
colorspace = cupsImageGetColorSpace(img);
LOGI("imagetops: cupsImageGetColorSpace finished : colorspace :%d",colorspace);
/*
* Scale as necessary...
*/
if (zoom == 0.0 && xppi == 0)
{
xppi = cupsImageGetXPPI(img);
yppi = cupsImageGetYPPI(img);
}
LOGI("imagetops:xppi=%d",xppi);
LOGI("imagetops:yppi=%d",yppi);
if (yppi == 0)
yppi = xppi;
fprintf(stderr, "DEBUG: Before scaling: xppi=%d, yppi=%d, zoom=%.2f\n",
xppi, yppi, zoom);
if (xppi > 0)
{
/*
* Scale the image as neccesary to match the desired pixels-per-inch.
*/
if (Orientation & 1)
{
xprint = (PageTop - PageBottom) / 72.0;
yprint = (PageRight - PageLeft) / 72.0;
}
else
{
xprint = (PageRight - PageLeft) / 72.0;
yprint = (PageTop - PageBottom) / 72.0;
}
fprintf(stderr, "DEBUG: Before scaling: xprint=%.1f, yprint=%.1f\n",
xprint, yprint);
xinches = (float)cupsImageGetWidth(img) / (float)xppi;
yinches = (float)cupsImageGetHeight(img) / (float)yppi;
fprintf(stderr, "DEBUG: Image size is %.1f x %.1f inches...\n",
xinches, yinches);
if ((val = cupsGetOption("natural-scaling", num_options, options)) != NULL)
{
xinches = xinches * atoi(val) / 100;
yinches = yinches * atoi(val) / 100;
}
if (cupsGetOption("orientation-requested", num_options, options) == NULL &&
cupsGetOption("landscape", num_options, options) == NULL)
{
/*
* Rotate the image if it will fit landscape but not portrait...
*/
fputs("DEBUG: Auto orientation...\n", stderr);
LOGI("imagetops.c : Auto orientation...");
if ((xinches > xprint || yinches > yprint) && xinches <= yprint && yinches <= xprint)
{
/*
* Rotate the image as needed...
*/
fputs("DEBUG: Using landscape orientation...\n", stderr);
LOGI("imagetops.c : Auto orientation : Using landscape orientation");
Orientation = (Orientation + 1) & 3;
xsize = yprint;
yprint = xprint;
xprint = xsize;
}
}
}else{
/*
* Scale percentage of page size...
*/
xprint = (PageRight - PageLeft) / 72.0;
yprint = (PageTop - PageBottom) / 72.0;
aspect = (float)cupsImageGetYPPI(img) / (float)cupsImageGetXPPI(img);
fprintf(stderr, "DEBUG: Before scaling: xprint=%.1f, yprint=%.1f\n",
xprint, yprint);
fprintf(stderr, "DEBUG: cupsImageGetXPPI(img) = %d, cupsImageGetYPPI(img) = %d, aspect = %f\n",
cupsImageGetXPPI(img), cupsImageGetYPPI(img), aspect);
xsize = xprint * zoom;
ysize = xsize * cupsImageGetHeight(img) / cupsImageGetWidth(img) / aspect;
if (ysize > (yprint * zoom))
{
ysize = yprint * zoom;
xsize = ysize * cupsImageGetWidth(img) * aspect / cupsImageGetHeight(img);
}
xsize2 = yprint * zoom;
ysize2 = xsize2 * cupsImageGetHeight(img) / cupsImageGetWidth(img) / aspect;
if (ysize2 > (xprint * zoom))
{
ysize2 = xprint * zoom;
xsize2 = ysize2 * cupsImageGetWidth(img) * aspect / cupsImageGetHeight(img);
}
fprintf(stderr, "DEBUG: Portrait size is %.2f x %.2f inches\n", xsize, ysize);
fprintf(stderr, "DEBUG: Landscape size is %.2f x %.2f inches\n", xsize2, ysize2);
if (cupsGetOption("orientation-requested", num_options, options) == NULL && cupsGetOption("landscape", num_options, options) == NULL)
{
/*
* Choose the rotation with the largest area, but prefer
* portrait if they are equal...
*/
fputs("DEBUG: Auto orientation...\n", stderr);
if ((xsize * ysize) < (xsize2 * xsize2))
{
/*
* Do landscape orientation...
*/
fputs("DEBUG: Using landscape orientation...\n", stderr);
Orientation = 1;
xinches = xsize2;
yinches = ysize2;
xprint = (PageTop - PageBottom) / 72.0;
yprint = (PageRight - PageLeft) / 72.0;
}
else
{
/*
* Do portrait orientation...
*/
fputs("DEBUG: Using portrait orientation...\n", stderr);
Orientation = 0;
xinches = xsize;
yinches = ysize;
}
}
else if (Orientation & 1)
{
fputs("DEBUG: Using landscape orientation...\n", stderr);
xinches = xsize2;
yinches = ysize2;
xprint = (PageTop - PageBottom) / 72.0;
yprint = (PageRight - PageLeft) / 72.0;
}
else
{
fputs("DEBUG: Using portrait orientation...\n", stderr);
xinches = xsize;
yinches = ysize;
xprint = (PageRight - PageLeft) / 72.0;
yprint = (PageTop - PageBottom) / 72.0;
}
}
/*
* Compute the number of pages to print and the size of the image on each
* page...
*/
xpages = ceil(xinches / xprint);
ypages = ceil(yinches / yprint);
xprint = xinches / xpages;
yprint = yinches / ypages;
fprintf(stderr, "DEBUG: xpages = %dx%.2fin, ypages = %dx%.2fin\n",xpages, xprint, ypages, yprint);
/*
* Update the page size for custom sizes...
*/
if ((choice = ppdFindMarkedChoice(ppd, "PageSize")) != NULL && _cups_strcasecmp(choice->choice, "Custom") == 0)
{
float width, /* New width in points */
length; /* New length in points */
char s[255]; /* New custom page size... */
/*
* Use the correct width and length for the current orientation...
*/
if (Orientation & 1)
{
width = yprint * 72.0;
length = xprint * 72.0;
}
else
{
width = xprint * 72.0;
length = yprint * 72.0;
}
/*
* Add margins to page size...
*/
width += ppd->custom_margins[0] + ppd->custom_margins[2];
length += ppd->custom_margins[1] + ppd->custom_margins[3];
/*
* Enforce minimums...
*/
if (width < ppd->custom_min[0])
width = ppd->custom_min[0];
if (length < ppd->custom_min[1])
length = ppd->custom_min[1];
fprintf(stderr, "DEBUG: Updated custom page size to %.2f x %.2f inches...\n",width / 72.0, length / 72.0);
/*
* Set the new custom size...
*/
sprintf(s, "Custom.%.0fx%.0f", width, length);
ppdMarkOption(ppd, "PageSize", s);
/*
* Update page variables...
*/
PageWidth = width;
PageLength = length;
PageLeft = ppd->custom_margins[0];
PageRight = width - ppd->custom_margins[2];
PageBottom = ppd->custom_margins[1];
PageTop = length - ppd->custom_margins[3];
}
/*
* See if we need to collate, and if so how we need to do it...
*/
if (xpages == 1 && ypages == 1)
Collate = 0;
slowcollate = Collate && ppdFindOption(ppd, "Collate") == NULL;
if (Copies > 1 && !slowcollate)
{
realcopies = Copies;
Copies = 1;
}
else
realcopies = 1;
/*
* Write any "exit server" options that have been selected...
*/
//Changes to create ps file -- start
if(count == 0){//single side print
defout = dup(1);
outfd = open(psFilePath,O_RDWR | O_CREAT,S_IRWXU |S_IRWXG | S_IRWXO);
dup2(outfd,1);
}
//Changes to create ps file -- end
ppdEmit(ppd, stdout, PPD_ORDER_EXIT);
/*
* Write any JCL commands that are needed to print PostScript code...
*/
if (emit_jcl)
ppdEmitJCL(ppd, stdout, atoi(argv[1]), argv[2], argv[3]);
/*
* Start sending the document with any commands needed...
*/
curtime = time(NULL);
curtm = localtime(&curtime);
//////////////////
if(count == 0){
puts("%!PS-Adobe-3.0");
printf("%%%%BoundingBox: %.0f %.0f %.0f %.0f\n", PageLeft, PageBottom,PageRight, PageTop);
printf("%%%%LanguageLevel: %d\n", LanguageLevel);
printf("%%%%Pages: %d\n", xpages * ypages * Copies * numFiles);
puts("%%DocumentData: Clean7Bit");
puts("%%DocumentNeededResources: font Helvetica-Bold");
puts("%%Creator: imagetops/" CUPS_SVERSION);
strftime(curdate, sizeof(curdate), "%c", curtm);
printf("%%%%CreationDate: %s\n", curdate);
WriteTextComment("Title", argv[3]);
WriteTextComment("For", argv[2]);
if (Orientation & 1)
puts("%%Orientation: Landscape");
else
puts("%%Orientation: Portrait");
puts("%%EndComments");
puts("%%BeginProlog");
if (ppd != NULL && ppd->patches != NULL)
puts(ppd->patches);
ppdEmit(ppd, stdout, PPD_ORDER_DOCUMENT);
ppdEmit(ppd, stdout, PPD_ORDER_ANY);
ppdEmit(ppd, stdout, PPD_ORDER_PROLOG);
if (g != 1.0 || b != 1.0)
printf("{ neg 1 add dup 0 lt { pop 1 } { %.3f exp neg 1 add } "
"ifelse %.3f mul } bind settransfer\n", g, b);
WriteCommon();
switch (Orientation)
{
case 0 :
WriteLabelProlog(cupsGetOption("page-label", num_options, options),
PageBottom, PageTop, PageWidth);
break;
case 1 :
WriteLabelProlog(cupsGetOption("page-label", num_options, options),
PageLeft, PageRight, PageLength);
break;
case 2 :
WriteLabelProlog(cupsGetOption("page-label", num_options, options),
PageLength - PageTop, PageLength - PageBottom, PageWidth);
break;
case 3 :
WriteLabelProlog(cupsGetOption("page-label", num_options, options),
PageWidth - PageRight, PageWidth - PageLeft,PageLength);
break;
}
if (realcopies > 1)
{
if (ppd == NULL || ppd->language_level == 1)
printf("/#copies %d def\n", realcopies);
else
printf("<</NumCopies %d>>setpagedevice\n", realcopies);
}
puts("%%EndProlog");
}
/*
* Output the pages...
*/
row = malloc(cupsImageGetWidth(img) * abs(colorspace) + 3);
fprintf(stderr, "DEBUG: XPosition=%d, YPosition=%d, Orientation=%d\n",XPosition, YPosition, Orientation);
fprintf(stderr, "DEBUG: xprint=%.0f, yprint=%.0f\n", xprint, yprint);
fprintf(stderr, "DEBUG: PageLeft=%.0f, PageRight=%.0f, PageWidth=%.0f\n",PageLeft, PageRight, PageWidth);
fprintf(stderr, "DEBUG: PageBottom=%.0f, PageTop=%.0f, PageLength=%.0f\n",PageBottom, PageTop, PageLength);
switch (Orientation)
{
default :
switch (XPosition)
{
case -1 :
left = PageLeft;
break;
default :
left = (PageRight + PageLeft - xprint * 72) / 2;
break;
case 1 :
left = PageRight - xprint * 72;
break;
}
switch (YPosition)
{
case -1 :
top = PageBottom + yprint * 72;
break;
default :
top = (PageTop + PageBottom + yprint * 72) / 2;
break;
case 1 :
top = PageTop;
break;
}
break;
case 1 :
switch (XPosition)
{
case -1 :
left = PageBottom;
break;
default :
left = (PageTop + PageBottom - xprint * 72) / 2;
break;
case 1 :
left = PageTop - xprint * 72;
break;
}
switch (YPosition)
{
case -1 :
top = PageLeft + yprint * 72;
break;
default :
top = (PageRight + PageLeft + yprint * 72) / 2;
break;
case 1 :
top = PageRight;
break;
}
break;
case 2 :
switch (XPosition)
{
case 1 :
left = PageLeft;
break;
default :
left = (PageRight + PageLeft - xprint * 72) / 2;
break;
case -1 :
left = PageRight - xprint * 72;
break;
}
switch (YPosition)
{
case 1 :
top = PageBottom + yprint * 72;
break;
default :
top = (PageTop + PageBottom + yprint * 72) / 2;
break;
case -1 :
top = PageTop;
break;
}
break;
case 3 :
switch (XPosition)
{
case 1 :
left = PageBottom;
break;
default :
left = (PageTop + PageBottom - xprint * 72) / 2;
break;
case -1 :
left = PageTop - xprint * 72;
break;
}
switch (YPosition)
{
case 1 :
top = PageLeft + yprint * 72;
break;
default :
top = (PageRight + PageLeft + yprint * 72) / 2;
break;
case -1 :
top = PageRight;
break;
}
break;
}
fprintf(stderr, "DEBUG: left=%.2f, top=%.2f\n", left, top);
for (page = 1; Copies > 0; Copies --)
for (xpage = 0; xpage < xpages; xpage ++)
for (ypage = 0; ypage < ypages; ypage ++, page ++)
{
if (ppd && ppd->num_filters == 0)
fprintf(stderr, "PAGE: %d %d\n", page, realcopies);
_cupsLangPrintFilter(stderr, "INFO", _("Printing page %d."), page);
printf("%%%%Page: %d %d\n", (page * (count+1)), (page*(count+1)));
//TEST_TODO
if(count>=1){
puts("%%BeginPageSetup");
if (Orientation & 1)
puts("%%PageOrientation: Landscape");
else
puts("%%PageOrientation: Portrait");
puts("%%EndPageSetup");
}
ppdEmit(ppd, stdout, PPD_ORDER_PAGE);
puts("gsave");
if (Flip)
printf("%.0f 0 translate -1 1 scale\n", PageWidth);
switch (Orientation)
{
case 1 : /* Landscape */
printf("%.0f 0 translate 90 rotate\n", PageWidth);
break;
case 2 : /* Reverse Portrait */
printf("%.0f %.0f translate 180 rotate\n", PageWidth, PageLength);
break;
case 3 : /* Reverse Landscape */
printf("0 %.0f translate -90 rotate\n", PageLength);
break;
}
puts("gsave");
xc0 = cupsImageGetWidth(img) * xpage / xpages;
xc1 = cupsImageGetWidth(img) * (xpage + 1) / xpages - 1;
yc0 = cupsImageGetHeight(img) * ypage / ypages;
yc1 = cupsImageGetHeight(img) * (ypage + 1) / ypages - 1;
printf("%.1f %.1f translate\n", left, top);
printf("%.3f %.3f scale\n\n",xprint * 72.0 / (xc1 - xc0 + 1),yprint * 72.0 / (yc1 - yc0 + 1));
if (LanguageLevel == 1)
{
printf("/picture %d string def\n", (xc1 - xc0 + 1) * abs(colorspace));
printf("%d %d 8[1 0 0 -1 0 1]", (xc1 - xc0 + 1), (yc1 - yc0 + 1));
if (colorspace == CUPS_IMAGE_WHITE)
puts("{currentfile picture readhexstring pop} image");
else
printf("{currentfile picture readhexstring pop} false %d colorimage\n",abs(colorspace));
for (y = yc0; y <= yc1; y ++)
{
cupsImageGetRow(img, xc0, y, xc1 - xc0 + 1, row);
ps_hex(row, (xc1 - xc0 + 1) * abs(colorspace), y == yc1);
}
}
else
{
switch (colorspace)
{
case CUPS_IMAGE_WHITE :
puts("/DeviceGray setcolorspace");
break;
case CUPS_IMAGE_RGB :
puts("/DeviceRGB setcolorspace");
break;
case CUPS_IMAGE_CMYK :
puts("/DeviceCMYK setcolorspace");
break;
}
printf("<<"
"/ImageType 1"
"/Width %d"
"/Height %d"
"/BitsPerComponent 8",
xc1 - xc0 + 1, yc1 - yc0 + 1);
switch (colorspace)
{
case CUPS_IMAGE_WHITE :
fputs("/Decode[0 1]", stdout);
break;
case CUPS_IMAGE_RGB :
fputs("/Decode[0 1 0 1 0 1]", stdout);
break;
case CUPS_IMAGE_CMYK :
fputs("/Decode[0 1 0 1 0 1 0 1]", stdout);
break;
}
fputs("\n/DataSource currentfile/ASCII85Decode filter", stdout);
if (((xc1 - xc0 + 1) / xprint) < 100.0)
fputs("/Interpolate true", stdout);
puts("/ImageMatrix[1 0 0 -1 0 1]>>image");
for (y = yc0, out_offset = 0; y <= yc1; y ++)
{
cupsImageGetRow(img, xc0, y, xc1 - xc0 + 1, row + out_offset);
out_length = (xc1 - xc0 + 1) * abs(colorspace) + out_offset;
out_offset = out_length & 3;
ps_ascii85(row, out_length, y == yc1);
if (out_offset > 0)
memcpy(row, row + out_length - out_offset, out_offset);
}
}
if(count==1){
puts("grestore");
WriteLabels(0);
puts("grestore");
}
puts("showpage");
puts("%%PageTrailer");
}
} //end of big for loop
puts("%%EOF");
/*
* End the job with the appropriate JCL command or CTRL-D otherwise.
*/
if (emit_jcl)
{
if (ppd && ppd->jcl_end)
ppdEmitJCLEnd(ppd, stdout);
else
putchar(0x04);
}
fflush(stdout);
dup2(defout,1);
close(outfd);
close(defout);
/*
* Close files...
*/
LOGI("imagetops:Close files");
cupsImageClose(img);
ppdClose(ppd);
return (0);
}
int DeviceAttributes_ ( ppd_file_t * ppd,
oyOptions_s * options,
oyConfig_s * device,
const char * ppd_file_location )
{
oyOption_s * o = 0;
int error = !device;
oyOption_s * value3 = oyOptions_Find( options, "device_context", oyNAME_PATTERN );
const char * device_name = oyConfig_FindString( device, "device_name", 0 );
if(!error)
{
char * manufacturer= 0,
* model=0,
* serial=0,
* device_settings = 0;
const char * system_port = 0,
* host = 0;
const char * keyword = 0;
ppd_attr_t * attrs = 0;
int attr_n, i, j;
char ** color_key_words = 0,
* tmp = 0;
int color_key_words_n = 0;
if(!device_name && !value3 && !ppd_file_location && !ppd)
{
message(oyMSG_WARN, (oyStruct_s*)options, _DBG_FORMAT_
"The \"device_name\" and \"device_context\" is\n"
" missed to select a appropriate device.", _DBG_ARGS_ );
error = 1;
return error;
}
if(!ppd)
{
message( oyMSG_DBG, (oyStruct_s*)0, _DBG_FORMAT_ "\n"
"No PPD obtained for ", _DBG_ARGS_, device_name );
error = -1;
return error;
}
manufacturer = ppd->manufacturer;
model = ppd->modelname;
serial = 0; /* Not known at this time. */
system_port = device_name;
host = cupsServer();
attrs = ppdFindAttr(ppd, "cupsICCProfile", 0);
if(attrs && attrs->text)
device_settings = attrs->text;
if(error <= 0)
{
size_t size = 0;
char * data = 0;
oyConfig_s * d = device;
oyRankMap * rank_map = oyRankMapCopy( oyConfig_GetRankMap( device ), oyAllocateFunc_ );
if(!rank_map)
rank_map = oyRankMapCopy( _api8.rank_map, oyAllocateFunc_ );
OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), manufacturer )
OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), model )
OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), serial )
OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), system_port )
OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), host )
OPTIONS_ADD( oyConfig_GetOptions(d,"backend_core"), device_settings )
if (value3)
{
/* open the PPD data */
if(ppd_file_location)
{
FILE * fp = fopen( ppd_file_location, "r" );
size_t lsize = 0;
/* Find the total size. */
fseek(fp , 0, SEEK_END);
lsize = ftell(fp);
rewind (fp);
/* Create buffer to read contents into a profile. */
data = (char*) malloc (sizeof(char)*lsize + 1);
if (data == NULL) fputs ("Unable to open PPD size.",stderr);
size = fread( data, 1, lsize, fp);
data[size] = 0;
}
if(!error && data && size)
{
o = oyOption_FromRegistration(
CMM_BASE_REG OY_SLASH "device_context.PPD.text", 0 );
error = !o;
if(!error)
error = oyOption_SetFromData( o, data, size );
if(!error)
oyOptions_MoveIn( *oyConfig_GetOptions(device,"data"), &o, -1 );
}
}
/* Collect all ColorKeyWords. */
attr_n = ppd->num_attrs;
for(i = 0; i < attr_n; i++)
{
char key[16];
keyword = ppd->attrs[i]->name;
/* we support keys beginning with ColorKeyWords, e.g.
"ColorKeyWords" "ColorKeyWords" ... */
snprintf( &key[0], 16, "%s", keyword );
key[14] = 0;
if (strcmp(key, "ColorKeyWords") == 0)
{
if( tmp && tmp[oyStrlen_(tmp) - 1] != ';' )
STRING_ADD( tmp, ";" );
STRING_ADD( tmp, ppd->attrs[i]->value );
}
}
if(tmp)
{
color_key_words = oyStringSplit( tmp, ';', &color_key_words_n,
oyAllocateFunc_);
oyDeAllocateFunc_( tmp ); tmp = 0;
}
/* add the key/value pairs to the devices backend_core options. */
for(j = 0; j < color_key_words_n; ++j)
{
const char * keyword = color_key_words[j],
* value = NULL;
ppd_choice_t * c = ppdFindMarkedChoice( ppd, keyword );
ppd_option_t * o = ppdFindOption( ppd, keyword );
char * reg_name = 0;
/* take the marked choice */
if(c)
value = c->choice;
/* fall back to a default */
else if(o)
value = o->defchoice;
else
/* Scan PPD attributes for matching the ColorKeyWords and */
for(i = 0; i < attr_n; i++)
if(oyStrcmp_( ppd->attrs[i]->name, keyword ) == 0)
value = ppd->attrs[i]->value;
STRING_ADD( reg_name, CMM_BASE_REG OY_SLASH );
STRING_ADD( reg_name, keyword );
if(value)
{
error= oyOptions_SetFromText( oyConfig_GetOptions(d,"backend_core"),
reg_name,
value,
OY_CREATE_NEW );
oyRankMapAppend( &rank_map, reg_name, 2, -2, 0, 0,0 );
}
if(reg_name) oyDeAllocateFunc_( reg_name ); reg_name = 0;
}
if( color_key_words && color_key_words_n)
oyStringListRelease_( &color_key_words, color_key_words_n,
oyDeAllocateFunc_ );
else
{
ppd_option_t * o;
while((o = ppdNextOption(ppd)) != 0)
{
const char * value = 0;
char * reg_name = 0;
keyword = o->keyword;
STRING_ADD( reg_name, CMM_BASE_REG OY_SLASH );
STRING_ADD( reg_name, keyword );
/* take the marked choice */
for(i = 0; i < o->num_choices; ++i)
if(o->choices[i].marked)
{
value = o->choices[i].choice;
break;
}
if(!value)
value = o->defchoice;
if(value)
{
error = oyOptions_SetFromText( oyConfig_GetOptions(d,"backend_core"),
reg_name,
value,
OY_CREATE_NEW );
oyRankMapAppend( &rank_map, reg_name, 2, -2, 0, 0,0 );
}
if(reg_name) oyDeAllocateFunc_( reg_name ); reg_name = 0;
}
}
oyConfig_SetRankMap( device, rank_map );
oyRankMapRelease( &rank_map, oyDeAllocateFunc_ );
}
static int /* O - 0 on success, 1 on fail */
set_printer_options(
http_t *http, /* I - Server connection */
char *printer, /* I - Printer */
int num_options, /* I - Number of options */
cups_option_t *options, /* I - Options */
char *file) /* I - PPD file/interface script */
{
ipp_t *request; /* IPP Request */
const char *ppdfile; /* PPD filename */
int ppdchanged; /* PPD changed? */
ppd_file_t *ppd; /* PPD file */
ppd_choice_t *choice; /* Marked choice */
char uri[HTTP_MAX_URI], /* URI for printer/class */
line[1024], /* Line from PPD file */
keyword[1024], /* Keyword from Default line */
*keyptr, /* Pointer into keyword... */
tempfile[1024]; /* Temporary filename */
cups_file_t *in, /* PPD file */
*out; /* Temporary file */
const char *protocol, /* Old protocol option */
*customval, /* Custom option value */
*boolval; /* Boolean value */
int wrote_ipp_supplies = 0, /* Wrote cupsIPPSupplies keyword? */
wrote_snmp_supplies = 0;/* Wrote cupsSNMPSupplies keyword? */
DEBUG_printf(("set_printer_options(http=%p, printer=\"%s\", num_options=%d, "
"options=%p, file=\"%s\")\n", http, printer, num_options,
options, file));
/*
* Build a CUPS_ADD_MODIFY_PRINTER or CUPS_ADD_MODIFY_CLASS request, which
* requires the following attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* other options
*/
if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
request = ippNewRequest(CUPS_ADD_MODIFY_CLASS);
else
request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser());
/*
* Add the options...
*/
cupsEncodeOptions2(request, num_options, options, IPP_TAG_PRINTER);
if ((protocol = cupsGetOption("protocol", num_options, options)) != NULL)
{
if (!_cups_strcasecmp(protocol, "bcp"))
ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
NULL, "bcp");
else if (!_cups_strcasecmp(protocol, "tbcp"))
ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
NULL, "tbcp");
}
if (file)
ppdfile = file;
else if (request->request.op.operation_id == CUPS_ADD_MODIFY_PRINTER)
ppdfile = cupsGetPPD(printer);
else
ppdfile = NULL;
if (ppdfile != NULL)
{
/*
* Set default options in the PPD file...
*/
ppd = ppdOpenFile(ppdfile);
ppdMarkDefaults(ppd);
cupsMarkOptions(ppd, num_options, options);
if ((out = cupsTempFile2(tempfile, sizeof(tempfile))) == NULL)
{
_cupsLangPrintError(NULL, _("lpadmin: Unable to create temporary file"));
ippDelete(request);
if (ppdfile != file)
unlink(ppdfile);
return (1);
}
if ((in = cupsFileOpen(ppdfile, "r")) == NULL)
{
_cupsLangPrintf(stderr,
_("lpadmin: Unable to open PPD file \"%s\" - %s"),
ppdfile, strerror(errno));
ippDelete(request);
if (ppdfile != file)
unlink(ppdfile);
cupsFileClose(out);
unlink(tempfile);
return (1);
}
ppdchanged = 0;
while (cupsFileGets(in, line, sizeof(line)))
{
if (!strncmp(line, "*cupsIPPSupplies:", 17) &&
(boolval = cupsGetOption("cupsIPPSupplies", num_options,
options)) != NULL)
{
wrote_ipp_supplies = 1;
cupsFilePrintf(out, "*cupsIPPSupplies: %s\n",
(!_cups_strcasecmp(boolval, "true") ||
!_cups_strcasecmp(boolval, "yes") ||
!_cups_strcasecmp(boolval, "on")) ? "True" : "False");
}
else if (!strncmp(line, "*cupsSNMPSupplies:", 18) &&
(boolval = cupsGetOption("cupsSNMPSupplies", num_options,
options)) != NULL)
{
wrote_snmp_supplies = 1;
cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n",
(!_cups_strcasecmp(boolval, "true") ||
!_cups_strcasecmp(boolval, "yes") ||
!_cups_strcasecmp(boolval, "on")) ? "True" : "False");
}
else if (strncmp(line, "*Default", 8))
cupsFilePrintf(out, "%s\n", line);
else
{
/*
* Get default option name...
*/
strlcpy(keyword, line + 8, sizeof(keyword));
for (keyptr = keyword; *keyptr; keyptr ++)
if (*keyptr == ':' || isspace(*keyptr & 255))
break;
*keyptr++ = '\0';
while (isspace(*keyptr & 255))
keyptr ++;
if (!strcmp(keyword, "PageRegion") ||
!strcmp(keyword, "PageSize") ||
!strcmp(keyword, "PaperDimension") ||
!strcmp(keyword, "ImageableArea"))
{
if ((choice = ppdFindMarkedChoice(ppd, "PageSize")) == NULL)
choice = ppdFindMarkedChoice(ppd, "PageRegion");
}
else
choice = ppdFindMarkedChoice(ppd, keyword);
if (choice && strcmp(choice->choice, keyptr))
{
if (strcmp(choice->choice, "Custom"))
{
cupsFilePrintf(out, "*Default%s: %s\n", keyword, choice->choice);
ppdchanged = 1;
}
else if ((customval = cupsGetOption(keyword, num_options,
options)) != NULL)
{
cupsFilePrintf(out, "*Default%s: %s\n", keyword, customval);
ppdchanged = 1;
}
else
cupsFilePrintf(out, "%s\n", line);
}
else
cupsFilePrintf(out, "%s\n", line);
}
}
if (!wrote_ipp_supplies &&
(boolval = cupsGetOption("cupsIPPSupplies", num_options,
options)) != NULL)
{
cupsFilePrintf(out, "*cupsIPPSupplies: %s\n",
(!_cups_strcasecmp(boolval, "true") ||
!_cups_strcasecmp(boolval, "yes") ||
!_cups_strcasecmp(boolval, "on")) ? "True" : "False");
}
if (!wrote_snmp_supplies &&
(boolval = cupsGetOption("cupsSNMPSupplies", num_options,
options)) != NULL)
{
cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n",
(!_cups_strcasecmp(boolval, "true") ||
!_cups_strcasecmp(boolval, "yes") ||
!_cups_strcasecmp(boolval, "on")) ? "True" : "False");
}
cupsFileClose(in);
cupsFileClose(out);
ppdClose(ppd);
/*
* Do the request...
*/
ippDelete(cupsDoFileRequest(http, request, "/admin/",
ppdchanged ? tempfile : file));
/*
* Clean up temp files... (TODO: catch signals in case we CTRL-C during
* lpadmin)
*/
if (ppdfile != file)
unlink(ppdfile);
unlink(tempfile);
}
else
{
/*
* No PPD file - just set the options...
*/
ippDelete(cupsDoRequest(http, request, "/admin/"));
}
/*
* Check the response...
*/
if (cupsLastError() > IPP_OK_CONFLICT)
{
_cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
return (1);
}
else
return (0);
}
static
char* make_cmd_param(cups_option_t *p_cups_opt, int num_opt,
ParamList *p_param, char *p_product, int len)
{
#ifdef DEBUG_PPD
char *p_ppd_name = "debug.ppd";
#else
char *p_ppd_name = getenv("PPD");
#endif
ppd_file_t *p_ppd;
char *cmd_buf = NULL;
ppd_choice_t *p_choice;
ppd_size_t *p_size;
ppd_size_t *p_default_size;
int reso;
char gs_exec_buf[256];
char gs_cmd_buf[1024];
char *flt_cmd_buf = NULL;
//For InkJet
long minw_mm, maxw_mm;
long minl_mm, maxl_mm;
PpdToOptKey *p_opt_key_table = alloc_opt_key_table(p_ppd_name);
PpdToOptKey *p_table = p_opt_key_table;
ParamList *p_list = NULL;
if( (p_ppd = ppdOpenFile(p_ppd_name)) == NULL )
return NULL;
if( p_opt_key_table == NULL)
return NULL;
ppdMarkDefaults(p_ppd);
// Obtain default page size setting.
p_choice = ppdFindMarkedChoice(p_ppd, "PageSize");
p_default_size = ppdPageSize(p_ppd, p_choice->choice);
mark_ps_param_options(p_ppd, p_param);
cupsMarkOptions(p_ppd, num_opt, p_cups_opt);
// Obtain page size setting.
p_choice = ppdFindMarkedChoice(p_ppd, "PageSize");
p_size = ppdPageSize(p_ppd, p_choice->choice);
if (!p_size || ((int)(p_size->width == 0)) || ((int)(p_size->length == 0))) {
p_size = p_default_size;
}
// Obtain resolution setting.
p_choice = ppdFindMarkedChoice(p_ppd, "Resolution");
reso = atoi(p_choice->choice);
//Obtain product name.
parse_product_name(p_ppd->product, p_product, len);
get_min_max_width_length(p_opt_key_table, p_cups_opt, num_opt,
&minw_mm, &maxw_mm, &minl_mm, &maxl_mm);
// gs command
strncpy(gs_exec_buf, GS_PATH, 256);
strncat(gs_exec_buf, "/", 1);
strncat(gs_exec_buf, GS_BIN, strlen(GS_BIN));
snprintf(gs_cmd_buf, 1023,
"%s -r%d -g%dx%d -q -dNOPROMPT -dSAFER -sDEVICE=ppmraw -sOutputFile=- -| ",
gs_exec_buf, reso, (int)(p_size->width * (float)reso / 72.0),
(int)(p_size->length * (float)reso / 72.0));
// For InkJet bjfilter Command
while( p_table->ppd_key != NULL )
{
p_choice = ppdFindMarkedChoice(p_ppd, p_table->ppd_key);
if( p_choice != NULL )
{
char choice[256];
strncpy(choice, p_choice->choice, 256);
if( !strcmp(p_table->ppd_key, "PageSize")
&& !strcmp(choice, "Custom") )
{
char pw[256];
char pl[256];
long pw_mm, pl_mm;
pw_mm = (long)((double)p_size->width * 2540.0 / 72.0);
pl_mm = (long)((double)p_size->length * 2540.0 / 72.0);
if( minw_mm != -1 && pw_mm < minw_mm )
pw_mm = minw_mm;
if( maxw_mm != -1 && pw_mm > maxw_mm )
pw_mm = maxw_mm;
if( minl_mm != -1 && pl_mm < minl_mm )
pl_mm = minl_mm;
if( maxl_mm != -1 && pl_mm > maxl_mm )
pl_mm = maxw_mm;
snprintf(pw, 255, "%ld", pw_mm);
snprintf(pl, 255, "%ld", pl_mm);
param_list_add(&p_list, p_table->opt_key, "user", 5);
param_list_add(&p_list,
"--paperwidth", pw, strlen(pw) + 1);
param_list_add(&p_list,
"--paperheight", pl, strlen(pl) + 1);
}
else
{
if( !strcmp(p_table->ppd_key, "PageSize")
&& is_borderless(choice) )
{
param_list_add(&p_list, "--borderless", "", 1);
}
param_list_add(&p_list, p_table->opt_key,
choice, strlen(choice) + 1);
}
}
p_table++;
}
while( num_opt-- > 0 )
{
char *opt_key = ppd_to_opt_key(p_opt_key_table, p_cups_opt->name);
if( opt_key != NULL )
{
char *value = p_cups_opt->value;
param_list_add(&p_list, opt_key, value, strlen(value) + 1);
}
p_cups_opt++;
}
{
char bbox_buf[256];
float dd = 1.0 - 36.0 / (float)reso;
int left = (int)p_size->left;
int top = (int)(p_size->top + dd);
int right = left + (int)(p_size->right - p_size->left + dd);
int bottom = top - (int)(p_size->top - p_size->bottom + dd);
snprintf(bbox_buf, 255, "%-d,%-d,%-d,%-d", left, bottom, right, top);
param_list_add(&p_list, "--bbox",
bbox_buf, strlen(bbox_buf) + 1);
}
flt_cmd_buf = make_filter_param_line(p_product, reso, p_list);
if( p_list != NULL ){
param_list_free(p_list);
free_opt_key_table(p_opt_key_table);
}
ppdClose(p_ppd);
if( flt_cmd_buf )
{
int buf_len;
buf_len = strlen(gs_cmd_buf) + strlen(flt_cmd_buf) + 1;
if( (cmd_buf = (char*)malloc(buf_len)) != NULL )
{
strcpy(cmd_buf, gs_cmd_buf);
strcat(cmd_buf, flt_cmd_buf);
}
free(flt_cmd_buf);
fprintf(stderr, "pstocanonbj: %s\n", cmd_buf);
return cmd_buf;
}
else
return NULL;
}
