int /* O - Number of conflicts found */
ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
{
int i, /* Looping variable */
conflicts; /* Number of conflicts */
cups_array_t *active; /* Active conflicts */
_ppd_cups_uiconsts_t *c; /* Current constraints */
_ppd_cups_uiconst_t *cptr; /* Current constraint */
ppd_option_t *o; /* Current option */
if (!ppd)
return (0);
/*
* Clear all conflicts...
*/
cupsArraySave(ppd->options);
for (o = ppdFirstOption(ppd); o; o = ppdNextOption(ppd))
o->conflicted = 0;
cupsArrayRestore(ppd->options);
/*
* Test for conflicts...
*/
active = ppd_test_constraints(ppd, NULL, NULL, 0, NULL,
_PPD_ALL_CONSTRAINTS);
conflicts = cupsArrayCount(active);
/*
* Loop through all of the UI constraints and flag any options
* that conflict...
*/
for (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 ++)
cptr->option->conflicted = 1;
}
cupsArrayDelete(active);
/*
* Return the number of conflicts found...
*/
return (conflicts);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
cups_array_t *array, /* Test array */
*dup_array; /* Duplicate array */
int status; /* Exit status */
char *text; /* Text from array */
char word[256]; /* Word from file */
double start, /* Start time */
end; /* End time */
cups_dir_t *dir; /* Current directory */
cups_dentry_t *dent; /* Directory entry */
char *saved[32]; /* Saved entries */
void *data; /* User data for arrays */
/*
* No errors so far...
*/
status = 0;
/*
* cupsArrayNew()
*/
fputs("cupsArrayNew: ", stdout);
data = (void *)"testarray";
array = cupsArrayNew((cups_array_func_t)strcmp, data);
if (array)
puts("PASS");
else
{
puts("FAIL (returned NULL, expected pointer)");
status ++;
}
/*
* cupsArrayUserData()
*/
fputs("cupsArrayUserData: ", stdout);
if (cupsArrayUserData(array) == data)
puts("PASS");
else
{
printf("FAIL (returned %p instead of %p!)\n", cupsArrayUserData(array),
data);
status ++;
}
/*
* cupsArrayAdd()
*/
fputs("cupsArrayAdd: ", stdout);
if (!cupsArrayAdd(array, strdup("One Fish")))
{
puts("FAIL (\"One Fish\")");
status ++;
}
else
{
if (!cupsArrayAdd(array, strdup("Two Fish")))
{
puts("FAIL (\"Two Fish\")");
status ++;
}
else
{
if (!cupsArrayAdd(array, strdup("Red Fish")))
{
puts("FAIL (\"Red Fish\")");
status ++;
}
else
{
if (!cupsArrayAdd(array, strdup("Blue Fish")))
{
puts("FAIL (\"Blue Fish\")");
status ++;
}
else
puts("PASS");
}
}
}
/*
* cupsArrayCount()
*/
fputs("cupsArrayCount: ", stdout);
if (cupsArrayCount(array) == 4)
puts("PASS");
else
{
printf("FAIL (returned %d, expected 4)\n", cupsArrayCount(array));
status ++;
}
/*
* cupsArrayFirst()
*/
fputs("cupsArrayFirst: ", stdout);
if ((text = (char *)cupsArrayFirst(array)) != NULL &&
!strcmp(text, "Blue Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"Blue Fish\")\n", text);
status ++;
}
/*
* cupsArrayNext()
*/
fputs("cupsArrayNext: ", stdout);
if ((text = (char *)cupsArrayNext(array)) != NULL &&
!strcmp(text, "One Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
status ++;
}
/*
* cupsArrayLast()
*/
fputs("cupsArrayLast: ", stdout);
if ((text = (char *)cupsArrayLast(array)) != NULL &&
!strcmp(text, "Two Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"Two Fish\")\n", text);
status ++;
}
/*
* cupsArrayPrev()
*/
fputs("cupsArrayPrev: ", stdout);
if ((text = (char *)cupsArrayPrev(array)) != NULL &&
!strcmp(text, "Red Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"Red Fish\")\n", text);
status ++;
}
/*
* cupsArrayFind()
*/
fputs("cupsArrayFind: ", stdout);
if ((text = (char *)cupsArrayFind(array, (void *)"One Fish")) != NULL &&
!strcmp(text, "One Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
status ++;
}
/*
* cupsArrayCurrent()
*/
fputs("cupsArrayCurrent: ", stdout);
if ((text = (char *)cupsArrayCurrent(array)) != NULL &&
!strcmp(text, "One Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
status ++;
}
/*
* cupsArrayDup()
*/
fputs("cupsArrayDup: ", stdout);
if ((dup_array = cupsArrayDup(array)) != NULL &&
cupsArrayCount(dup_array) == 4)
puts("PASS");
else
{
printf("FAIL (returned %p with %d elements, expected pointer with 4 elements)\n",
dup_array, cupsArrayCount(dup_array));
status ++;
}
/*
* cupsArrayRemove()
*/
fputs("cupsArrayRemove: ", stdout);
if (cupsArrayRemove(array, (void *)"One Fish") &&
cupsArrayCount(array) == 3)
puts("PASS");
else
{
printf("FAIL (returned 0 with %d elements, expected 1 with 4 elements)\n",
cupsArrayCount(array));
status ++;
}
/*
* cupsArrayClear()
*/
fputs("cupsArrayClear: ", stdout);
cupsArrayClear(array);
if (cupsArrayCount(array) == 0)
puts("PASS");
else
{
printf("FAIL (%d elements, expected 0 elements)\n",
cupsArrayCount(array));
status ++;
}
/*
* Now load this source file and grab all of the unique words...
*/
fputs("Load unique words: ", stdout);
fflush(stdout);
start = get_seconds();
if ((dir = cupsDirOpen(".")) == NULL)
{
puts("FAIL (cupsDirOpen failed)");
status ++;
}
else
{
while ((dent = cupsDirRead(dir)) != NULL)
{
i = strlen(dent->filename) - 2;
if (i > 0 && dent->filename[i] == '.' &&
(dent->filename[i + 1] == 'c' ||
dent->filename[i + 1] == 'h'))
load_words(dent->filename, array);
}
cupsDirClose(dir);
end = get_seconds();
printf("%d words in %.3f seconds (%.0f words/sec), ", cupsArrayCount(array),
end - start, cupsArrayCount(array) / (end - start));
fflush(stdout);
for (text = (char *)cupsArrayFirst(array); text;)
{
/*
* Copy this word to the word buffer (safe because we strdup'd from
* the same buffer in the first place... :)
*/
strlcpy(word, text, sizeof(word));
/*
* Grab the next word and compare...
*/
if ((text = (char *)cupsArrayNext(array)) == NULL)
break;
if (strcmp(word, text) >= 0)
break;
}
if (text)
{
printf("FAIL (\"%s\" >= \"%s\"!)\n", word, text);
status ++;
}
else
puts("PASS");
}
/*
* Test deleting with iteration...
*/
fputs("Delete While Iterating: ", stdout);
text = (char *)cupsArrayFirst(array);
cupsArrayRemove(array, text);
free(text);
text = (char *)cupsArrayNext(array);
if (!text)
{
puts("FAIL (cupsArrayNext returned NULL!)");
status ++;
}
else
puts("PASS");
/*
* Test save/restore...
*/
fputs("cupsArraySave: ", stdout);
for (i = 0, text = (char *)cupsArrayFirst(array);
i < 32;
i ++, text = (char *)cupsArrayNext(array))
{
saved[i] = text;
if (!cupsArraySave(array))
break;
}
if (i < 32)
printf("FAIL (depth = %d)\n", i);
else
puts("PASS");
fputs("cupsArrayRestore: ", stdout);
while (i > 0)
{
i --;
text = cupsArrayRestore(array);
if (text != saved[i])
break;
}
if (i)
printf("FAIL (depth = %d)\n", i);
else
puts("PASS");
/*
* Delete the arrays...
*/
cupsArrayDelete(array);
cupsArrayDelete(dup_array);
/*
* Test the array with string functions...
*/
fputs("_cupsArrayNewStrings(\" \\t\\nfoo bar\\tboo\\nfar\", ' '): ", stdout);
array = _cupsArrayNewStrings(" \t\nfoo bar\tboo\nfar", ' ');
if (!array)
{
status = 1;
puts("FAIL (unable to create array)");
}
else if (cupsArrayCount(array) != 4)
{
status = 1;
printf("FAIL (got %d elements, expected 4)\n", cupsArrayCount(array));
}
else if (strcmp(text = (char *)cupsArrayFirst(array), "bar"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"bar\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "boo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"boo\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "far"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"far\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "foo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"foo\")\n", text);
}
else
puts("PASS");
fputs("_cupsArrayAddStrings(array, \"foo2,bar2\", ','): ", stdout);
_cupsArrayAddStrings(array, "foo2,bar2", ',');
if (cupsArrayCount(array) != 6)
{
status = 1;
printf("FAIL (got %d elements, expected 6)\n", cupsArrayCount(array));
}
else if (strcmp(text = (char *)cupsArrayFirst(array), "bar"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"bar\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "bar2"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"bar2\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "boo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"boo\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "far"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"far\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "foo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"foo\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "foo2"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"foo2\")\n", text);
}
else
puts("PASS");
cupsArrayDelete(array);
/*
* Summarize the results and return...
*/
if (!status)
puts("\nALL TESTS PASSED!");
else
printf("\n%d TEST(S) FAILED!\n", status);
return (status);
}
static void
ppd_mark_option(ppd_file_t *ppd, /* I - PPD file */
const char *option, /* I - Option name */
const char *choice) /* I - Choice name */
{
int i, j; /* Looping vars */
ppd_option_t *o; /* Option pointer */
ppd_choice_t *c, /* Choice pointer */
*oldc, /* Old choice pointer */
key; /* Search key for choice */
struct lconv *loc; /* Locale data */
DEBUG_printf(("7ppd_mark_option(ppd=%p, option=\"%s\", choice=\"%s\")",
ppd, option, choice));
/*
* AP_D_InputSlot is the "default input slot" on MacOS X, and setting
* it clears the regular InputSlot choices...
*/
if (!_cups_strcasecmp(option, "AP_D_InputSlot"))
{
cupsArraySave(ppd->options);
if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
{
key.option = o;
if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL)
{
oldc->marked = 0;
cupsArrayRemove(ppd->marked, oldc);
}
}
cupsArrayRestore(ppd->options);
}
/*
* Check for custom options...
*/
cupsArraySave(ppd->options);
o = ppdFindOption(ppd, option);
cupsArrayRestore(ppd->options);
if (!o)
return;
loc = localeconv();
if (!_cups_strncasecmp(choice, "Custom.", 7))
{
/*
* Handle a custom option...
*/
if ((c = ppdFindChoice(o, "Custom")) == NULL)
return;
if (!_cups_strcasecmp(option, "PageSize"))
{
/*
* Handle custom page sizes...
*/
ppdPageSize(ppd, choice);
}
else
{
/*
* Handle other custom options...
*/
ppd_coption_t *coption; /* Custom option */
ppd_cparam_t *cparam; /* Custom parameter */
char *units; /* Custom points units */
if ((coption = ppdFindCustomOption(ppd, option)) != NULL)
{
if ((cparam = (ppd_cparam_t *)cupsArrayFirst(coption->params)) == NULL)
return;
switch (cparam->type)
{
case PPD_CUSTOM_CURVE :
case PPD_CUSTOM_INVCURVE :
case PPD_CUSTOM_REAL :
cparam->current.custom_real = (float)_cupsStrScand(choice + 7,
NULL, loc);
break;
case PPD_CUSTOM_POINTS :
cparam->current.custom_points = (float)_cupsStrScand(choice + 7,
&units,
loc);
if (units)
{
if (!_cups_strcasecmp(units, "cm"))
cparam->current.custom_points *= 72.0f / 2.54f;
else if (!_cups_strcasecmp(units, "mm"))
cparam->current.custom_points *= 72.0f / 25.4f;
else if (!_cups_strcasecmp(units, "m"))
cparam->current.custom_points *= 72.0f / 0.0254f;
else if (!_cups_strcasecmp(units, "in"))
cparam->current.custom_points *= 72.0f;
else if (!_cups_strcasecmp(units, "ft"))
cparam->current.custom_points *= 12.0f * 72.0f;
}
break;
case PPD_CUSTOM_INT :
cparam->current.custom_int = atoi(choice + 7);
break;
case PPD_CUSTOM_PASSCODE :
case PPD_CUSTOM_PASSWORD :
case PPD_CUSTOM_STRING :
if (cparam->current.custom_string)
_cupsStrFree(cparam->current.custom_string);
cparam->current.custom_string = _cupsStrAlloc(choice + 7);
break;
}
}
}
/*
* Make sure that we keep the option marked below...
*/
choice = "Custom";
}
else if (choice[0] == '{')
{
/*
* Handle multi-value custom options...
*/
ppd_coption_t *coption; /* Custom option */
ppd_cparam_t *cparam; /* Custom parameter */
char *units; /* Custom points units */
int num_vals; /* Number of values */
cups_option_t *vals, /* Values */
*val; /* Value */
if ((c = ppdFindChoice(o, "Custom")) == NULL)
return;
if ((coption = ppdFindCustomOption(ppd, option)) != NULL)
{
num_vals = cupsParseOptions(choice, 0, &vals);
for (i = 0, val = vals; i < num_vals; i ++, val ++)
{
if ((cparam = ppdFindCustomParam(coption, val->name)) == NULL)
continue;
switch (cparam->type)
{
case PPD_CUSTOM_CURVE :
case PPD_CUSTOM_INVCURVE :
case PPD_CUSTOM_REAL :
cparam->current.custom_real = (float)_cupsStrScand(val->value,
NULL, loc);
break;
case PPD_CUSTOM_POINTS :
cparam->current.custom_points = (float)_cupsStrScand(val->value,
&units,
loc);
if (units)
{
if (!_cups_strcasecmp(units, "cm"))
cparam->current.custom_points *= 72.0f / 2.54f;
else if (!_cups_strcasecmp(units, "mm"))
cparam->current.custom_points *= 72.0f / 25.4f;
else if (!_cups_strcasecmp(units, "m"))
cparam->current.custom_points *= 72.0f / 0.0254f;
else if (!_cups_strcasecmp(units, "in"))
cparam->current.custom_points *= 72.0f;
else if (!_cups_strcasecmp(units, "ft"))
cparam->current.custom_points *= 12.0f * 72.0f;
}
break;
case PPD_CUSTOM_INT :
cparam->current.custom_int = atoi(val->value);
break;
case PPD_CUSTOM_PASSCODE :
case PPD_CUSTOM_PASSWORD :
case PPD_CUSTOM_STRING :
if (cparam->current.custom_string)
_cupsStrFree(cparam->current.custom_string);
cparam->current.custom_string = _cupsStrRetain(val->value);
break;
}
}
cupsFreeOptions(num_vals, vals);
}
}
else
{
for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
if (!_cups_strcasecmp(c->choice, choice))
break;
if (!i)
return;
}
/*
* Option found; mark it and then handle unmarking any other options.
*/
if (o->ui != PPD_UI_PICKMANY)
{
/*
* Unmark all other choices...
*/
if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, c)) != NULL)
{
oldc->marked = 0;
cupsArrayRemove(ppd->marked, oldc);
}
if (!_cups_strcasecmp(option, "PageSize") || !_cups_strcasecmp(option, "PageRegion"))
{
/*
* Mark current page size...
*/
for (j = 0; j < ppd->num_sizes; j ++)
ppd->sizes[j].marked = !_cups_strcasecmp(ppd->sizes[j].name,
choice);
/*
* Unmark the current PageSize or PageRegion setting, as
* appropriate...
*/
cupsArraySave(ppd->options);
if (!_cups_strcasecmp(option, "PageSize"))
{
if ((o = ppdFindOption(ppd, "PageRegion")) != NULL)
{
key.option = o;
if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL)
{
oldc->marked = 0;
cupsArrayRemove(ppd->marked, oldc);
}
}
}
else
{
if ((o = ppdFindOption(ppd, "PageSize")) != NULL)
{
key.option = o;
if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL)
{
oldc->marked = 0;
cupsArrayRemove(ppd->marked, oldc);
}
}
}
cupsArrayRestore(ppd->options);
}
else if (!_cups_strcasecmp(option, "InputSlot"))
{
/*
* Unmark ManualFeed option...
*/
cupsArraySave(ppd->options);
if ((o = ppdFindOption(ppd, "ManualFeed")) != NULL)
{
key.option = o;
if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL)
{
oldc->marked = 0;
cupsArrayRemove(ppd->marked, oldc);
}
}
cupsArrayRestore(ppd->options);
}
else if (!_cups_strcasecmp(option, "ManualFeed") &&
!_cups_strcasecmp(choice, "True"))
{
/*
* Unmark InputSlot option...
*/
cupsArraySave(ppd->options);
if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
{
key.option = o;
if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL)
{
oldc->marked = 0;
cupsArrayRemove(ppd->marked, oldc);
}
}
cupsArrayRestore(ppd->options);
}
}
c->marked = 1;
cupsArrayAdd(ppd->marked, c);
}
int /* O - 0 on success, -1 on error */
ppdLocalize(ppd_file_t *ppd) /* I - PPD file */
{
int i, j, k; /* Looping vars */
ppd_group_t *group; /* Current group */
ppd_option_t *option; /* Current option */
ppd_choice_t *choice; /* Current choice */
ppd_coption_t *coption; /* Current custom option */
ppd_cparam_t *cparam; /* Current custom parameter */
ppd_attr_t *attr, /* Current attribute */
*locattr; /* Localized attribute */
char ckeyword[PPD_MAX_NAME], /* Custom keyword */
ll_CC[6]; /* Language + country locale */
/*
* Range check input...
*/
DEBUG_printf(("ppdLocalize(ppd=%p)", ppd));
if (!ppd)
return (-1);
/*
* Get the default language...
*/
ppd_ll_CC(ll_CC, sizeof(ll_CC));
/*
* Now lookup all of the groups, options, choices, etc.
*/
for (i = ppd->num_groups, group = ppd->groups; i > 0; i --, group ++)
{
if ((locattr = _ppdLocalizedAttr(ppd, "Translation", group->name,
ll_CC)) != NULL)
strlcpy(group->text, locattr->text, sizeof(group->text));
for (j = group->num_options, option = group->options; j > 0; j --, option ++)
{
if ((locattr = _ppdLocalizedAttr(ppd, "Translation", option->keyword,
ll_CC)) != NULL)
strlcpy(option->text, locattr->text, sizeof(option->text));
for (k = option->num_choices, choice = option->choices;
k > 0;
k --, choice ++)
{
if (strcmp(choice->choice, "Custom") ||
!ppdFindCustomOption(ppd, option->keyword))
locattr = _ppdLocalizedAttr(ppd, option->keyword, choice->choice,
ll_CC);
else
{
snprintf(ckeyword, sizeof(ckeyword), "Custom%s", option->keyword);
locattr = _ppdLocalizedAttr(ppd, ckeyword, "True", ll_CC);
}
if (locattr)
strlcpy(choice->text, locattr->text, sizeof(choice->text));
}
}
}
/*
* Translate any custom parameters...
*/
for (coption = (ppd_coption_t *)cupsArrayFirst(ppd->coptions);
coption;
coption = (ppd_coption_t *)cupsArrayNext(ppd->coptions))
{
for (cparam = (ppd_cparam_t *)cupsArrayFirst(coption->params);
cparam;
cparam = (ppd_cparam_t *)cupsArrayNext(coption->params))
{
snprintf(ckeyword, sizeof(ckeyword), "ParamCustom%s", coption->keyword);
if ((locattr = _ppdLocalizedAttr(ppd, ckeyword, cparam->name,
ll_CC)) != NULL)
strlcpy(cparam->text, locattr->text, sizeof(cparam->text));
}
}
/*
* Translate ICC profile names...
*/
if ((attr = ppdFindAttr(ppd, "APCustomColorMatchingName", NULL)) != NULL)
{
if ((locattr = _ppdLocalizedAttr(ppd, "APCustomColorMatchingName",
attr->spec, ll_CC)) != NULL)
strlcpy(attr->text, locattr->text, sizeof(attr->text));
}
for (attr = ppdFindAttr(ppd, "cupsICCProfile", NULL);
attr;
attr = ppdFindNextAttr(ppd, "cupsICCProfile", NULL))
{
cupsArraySave(ppd->sorted_attrs);
if ((locattr = _ppdLocalizedAttr(ppd, "cupsICCProfile", attr->spec,
ll_CC)) != NULL)
strlcpy(attr->text, locattr->text, sizeof(attr->text));
cupsArrayRestore(ppd->sorted_attrs);
}
/*
* Translate printer presets...
*/
for (attr = ppdFindAttr(ppd, "APPrinterPreset", NULL);
attr;
attr = ppdFindNextAttr(ppd, "APPrinterPreset", NULL))
{
cupsArraySave(ppd->sorted_attrs);
if ((locattr = _ppdLocalizedAttr(ppd, "APPrinterPreset", attr->spec,
ll_CC)) != NULL)
strlcpy(attr->text, locattr->text, sizeof(attr->text));
cupsArrayRestore(ppd->sorted_attrs);
}
return (0);
}
static void
apple_register_profiles(
cupsd_printer_t *p) /* I - Printer */
{
int i; /* Looping var */
char ppdfile[1024], /* PPD filename */
iccfile[1024], /* ICC filename */
selector[PPD_MAX_NAME];
/* Profile selection string */
ppd_file_t *ppd; /* PPD file */
ppd_attr_t *attr, /* Profile attributes */
*profileid_attr,/* cupsProfileID attribute */
*q1_attr, /* ColorModel (or other) qualifier */
*q2_attr, /* MediaType (or other) qualifier */
*q3_attr; /* Resolution (or other) qualifier */
char q_keyword[PPD_MAX_NAME];
/* Qualifier keyword */
const char *q1_choice, /* ColorModel (or other) choice */
*q2_choice, /* MediaType (or other) choice */
*q3_choice; /* Resolution (or other) choice */
ppd_option_t *cm_option; /* Color model option */
ppd_choice_t *cm_choice; /* Color model choice */
int num_profiles; /* Number of profiles */
OSStatus error = 0; /* Last error */
unsigned device_id, /* Printer device ID */
profile_id = 0, /* Profile ID */
default_profile_id = 0;
/* Default profile ID */
CFMutableDictionaryRef device_name; /* Printer device name dictionary */
CFStringRef printer_name; /* Printer name string */
cups_array_t *languages; /* Languages array */
CFMutableDictionaryRef profiles, /* Dictionary of profiles */
profile; /* Current profile info dictionary */
CFStringRef dict_key; /* Key in factory profile dictionary */
/*
* Make sure ColorSync is available...
*/
if (&ColorSyncRegisterDevice == NULL)
return;
/*
* Try opening the PPD file for this printer...
*/
snprintf(ppdfile, sizeof(ppdfile), "%s/ppd/%s.ppd", ServerRoot, p->name);
if ((ppd = _ppdOpenFile(ppdfile, _PPD_LOCALIZATION_ICC_PROFILES)) == NULL)
return;
/*
* See if we have any profiles...
*/
for (num_profiles = 0, attr = ppdFindAttr(ppd, "cupsICCProfile", NULL);
attr;
attr = ppdFindNextAttr(ppd, "cupsICCProfile", NULL))
if (attr->spec[0] && attr->value && attr->value[0])
{
if (attr->value[0] != '/')
snprintf(iccfile, sizeof(iccfile), "%s/profiles/%s", DataDir,
attr->value);
else
strlcpy(iccfile, attr->value, sizeof(iccfile));
if (access(iccfile, 0))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"%s: ICC Profile \"%s\" does not exist.", p->name,
iccfile);
cupsdSetPrinterReasons(p, "+cups-missing-filter-warning");
continue;
}
num_profiles ++;
}
/*
* Create a dictionary for the factory profiles...
*/
profiles = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profiles)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for factory profiles.");
ppdClose(ppd);
return;
}
/*
* If we have profiles, add them...
*/
if (num_profiles > 0)
{
/*
* For CUPS PPDs, figure out the default profile selector values...
*/
if ((attr = ppdFindAttr(ppd, "cupsICCQualifier1", NULL)) != NULL &&
attr->value && attr->value[0])
{
snprintf(q_keyword, sizeof(q_keyword), "Default%s", attr->value);
q1_attr = ppdFindAttr(ppd, q_keyword, NULL);
}
else if ((q1_attr = ppdFindAttr(ppd, "DefaultColorModel", NULL)) == NULL)
q1_attr = ppdFindAttr(ppd, "DefaultColorSpace", NULL);
if (q1_attr && q1_attr->value && q1_attr->value[0])
q1_choice = q1_attr->value;
else
q1_choice = "";
if ((attr = ppdFindAttr(ppd, "cupsICCQualifier2", NULL)) != NULL &&
attr->value && attr->value[0])
{
snprintf(q_keyword, sizeof(q_keyword), "Default%s", attr->value);
q2_attr = ppdFindAttr(ppd, q_keyword, NULL);
}
else
q2_attr = ppdFindAttr(ppd, "DefaultMediaType", NULL);
if (q2_attr && q2_attr->value && q2_attr->value[0])
q2_choice = q2_attr->value;
else
q2_choice = NULL;
if ((attr = ppdFindAttr(ppd, "cupsICCQualifier3", NULL)) != NULL &&
attr->value && attr->value[0])
{
snprintf(q_keyword, sizeof(q_keyword), "Default%s", attr->value);
q3_attr = ppdFindAttr(ppd, q_keyword, NULL);
}
else
q3_attr = ppdFindAttr(ppd, "DefaultResolution", NULL);
if (q3_attr && q3_attr->value && q3_attr->value[0])
q3_choice = q3_attr->value;
else
q3_choice = NULL;
/*
* Loop through the profiles listed in the PPD...
*/
languages = _ppdGetLanguages(ppd);
for (attr = ppdFindAttr(ppd, "cupsICCProfile", NULL);
attr;
attr = ppdFindNextAttr(ppd, "cupsICCProfile", NULL))
if (attr->spec[0] && attr->value && attr->value[0])
{
/*
* Add this profile...
*/
if (attr->value[0] != '/')
snprintf(iccfile, sizeof(iccfile), "%s/profiles/%s", DataDir,
attr->value);
else
strlcpy(iccfile, attr->value, sizeof(iccfile));
if (_cupsFileCheck(iccfile, _CUPS_FILE_CHECK_FILE, !RunUser,
cupsdLogFCMessage, p))
iccfile[0] = '\0';
cupsArraySave(ppd->sorted_attrs);
if ((profileid_attr = ppdFindAttr(ppd, "cupsProfileID",
attr->spec)) != NULL &&
profileid_attr->value && isdigit(profileid_attr->value[0] & 255))
profile_id = (unsigned)strtoul(profileid_attr->value, NULL, 10);
else
profile_id = _ppdHashName(attr->spec);
cupsArrayRestore(ppd->sorted_attrs);
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
apple_init_profile(ppd, languages, profile, profile_id, attr->spec,
attr->text[0] ? attr->text : attr->spec, iccfile);
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%u"), profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
CFRelease(profile);
/*
* See if this is the default profile...
*/
if (!default_profile_id && q1_choice && q2_choice && q3_choice)
{
snprintf(selector, sizeof(selector), "%s.%s.%s", q1_choice, q2_choice,
q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q1_choice && q2_choice)
{
snprintf(selector, sizeof(selector), "%s.%s.", q1_choice, q2_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q1_choice && q3_choice)
{
snprintf(selector, sizeof(selector), "%s..%s", q1_choice, q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q1_choice)
{
snprintf(selector, sizeof(selector), "%s..", q1_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q2_choice && q3_choice)
{
snprintf(selector, sizeof(selector), ".%s.%s", q2_choice, q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q2_choice)
{
snprintf(selector, sizeof(selector), ".%s.", q2_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
if (!default_profile_id && q3_choice)
{
snprintf(selector, sizeof(selector), "..%s", q3_choice);
if (!strcmp(selector, attr->spec))
default_profile_id = profile_id;
}
}
_ppdFreeLanguages(languages);
}
else if ((cm_option = ppdFindOption(ppd, "ColorModel")) != NULL)
{
/*
* Extract profiles from ColorModel option...
*/
const char *profile_name; /* Name of generic profile */
num_profiles = cm_option->num_choices;
for (i = cm_option->num_choices, cm_choice = cm_option->choices;
i > 0;
i --, cm_choice ++)
{
if (!strcmp(cm_choice->choice, "Gray") ||
!strcmp(cm_choice->choice, "Black"))
profile_name = "Gray";
else if (!strcmp(cm_choice->choice, "RGB") ||
!strcmp(cm_choice->choice, "CMY"))
profile_name = "RGB";
else if (!strcmp(cm_choice->choice, "CMYK") ||
!strcmp(cm_choice->choice, "KCMY"))
profile_name = "CMYK";
else
profile_name = "DeviceN";
snprintf(selector, sizeof(selector), "%s..", profile_name);
profile_id = _ppdHashName(selector);
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
apple_init_profile(ppd, NULL, profile, profile_id, cm_choice->choice,
cm_choice->text, NULL);
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%u"), profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
CFRelease(profile);
if (cm_choice->marked)
default_profile_id = profile_id;
}
}
else
{
/*
* Use the default colorspace...
*/
attr = ppdFindAttr(ppd, "DefaultColorSpace", NULL);
num_profiles = (attr && ppd->colorspace == PPD_CS_GRAY) ? 1 : 2;
/*
* Add the grayscale profile first. We always have a grayscale profile.
*/
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
profile_id = _ppdHashName("Gray..");
apple_init_profile(ppd, NULL, profile, profile_id, "Gray", "Gray", NULL);
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%u"),
profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
CFRelease(profile);
/*
* Then add the RGB/CMYK/DeviceN color profile...
*/
profile = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!profile)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to allocate memory for color profile.");
CFRelease(profiles);
ppdClose(ppd);
return;
}
switch (ppd->colorspace)
{
default :
case PPD_CS_RGB :
case PPD_CS_CMY :
profile_id = _ppdHashName("RGB..");
apple_init_profile(ppd, NULL, profile, profile_id, "RGB", "RGB",
NULL);
break;
case PPD_CS_RGBK :
case PPD_CS_CMYK :
profile_id = _ppdHashName("CMYK..");
apple_init_profile(ppd, NULL, profile, profile_id, "CMYK", "CMYK",
NULL);
break;
case PPD_CS_GRAY :
if (attr)
break;
case PPD_CS_N :
profile_id = _ppdHashName("DeviceN..");
apple_init_profile(ppd, NULL, profile, profile_id, "DeviceN",
"DeviceN", NULL);
break;
}
if (CFDictionaryGetCount(profile) > 0)
{
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%u"), profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, dict_key, profile);
CFRelease(dict_key);
}
}
CFRelease(profile);
}
if (num_profiles > 0)
{
/*
* Make sure we have a default profile ID...
*/
if (!default_profile_id)
default_profile_id = profile_id; /* Last profile */
dict_key = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%u"),
default_profile_id);
if (dict_key)
{
CFDictionarySetValue(profiles, kColorSyncDeviceDefaultProfileID,
dict_key);
CFRelease(dict_key);
}
/*
* Get the device ID hash and pathelogical name dictionary.
*/
cupsdLogMessage(CUPSD_LOG_INFO, "Registering ICC color profiles for \"%s\"",
p->name);
device_id = _ppdHashName(p->name);
device_name = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
printer_name = CFStringCreateWithCString(kCFAllocatorDefault,
p->name, kCFStringEncodingUTF8);
if (device_name && printer_name)
{
/*
* Register the device with ColorSync...
*/
CFTypeRef deviceDictKeys[] =
{ /* Device keys */
kColorSyncDeviceDescriptions,
kColorSyncFactoryProfiles,
kColorSyncDeviceUserScope,
kColorSyncDeviceHostScope
};
CFTypeRef deviceDictVals[] =
{ /* Device values */
device_name,
profiles,
kCFPreferencesAnyUser,
kCFPreferencesCurrentHost
};
CFDictionaryRef deviceDict; /* Device dictionary */
CFUUIDRef deviceUUID; /* Device UUID */
CFDictionarySetValue(device_name, CFSTR("en_US"), printer_name);
deviceDict = CFDictionaryCreate(kCFAllocatorDefault,
(const void **)deviceDictKeys,
(const void **)deviceDictVals,
sizeof(deviceDictKeys) /
sizeof(deviceDictKeys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
deviceUUID = ColorSyncCreateUUIDFromUInt32(device_id);
if (!deviceDict || !deviceUUID ||
!ColorSyncRegisterDevice(kColorSyncPrinterDeviceClass, deviceUUID,
deviceDict))
error = 1001;
if (deviceUUID)
CFRelease(deviceUUID);
if (deviceDict)
CFRelease(deviceDict);
}
else
error = 1000;
/*
* Clean up...
*/
if (error != noErr)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to register ICC color profiles for \"%s\": %d",
p->name, (int)error);
if (printer_name)
CFRelease(printer_name);
if (device_name)
CFRelease(device_name);
}
/*
* Free any memory we used...
*/
CFRelease(profiles);
ppdClose(ppd);
}
static void
apple_init_profile(
ppd_file_t *ppd, /* I - PPD file */
cups_array_t *languages, /* I - Languages in the PPD file */
CFMutableDictionaryRef profile, /* I - Profile dictionary */
unsigned id, /* I - Profile ID */
const char *name, /* I - Profile name */
const char *text, /* I - Profile UI text */
const char *iccfile) /* I - ICC filename */
{
CFURLRef url; /* URL for profile filename */
CFMutableDictionaryRef dict; /* Dictionary for name */
char *language; /* Current language */
ppd_attr_t *attr; /* Profile attribute */
CFStringRef cflang, /* Language string */
cftext; /* Localized text */
(void)id;
/*
* Build the profile name dictionary...
*/
dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (!dict)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to initialize profile \"%s\".",
iccfile);
return;
}
cftext = CFStringCreateWithCString(kCFAllocatorDefault, text,
kCFStringEncodingUTF8);
if (cftext)
{
CFDictionarySetValue(dict, CFSTR("en_US"), cftext);
CFRelease(cftext);
}
if (languages)
{
/*
* Find localized names for the color profiles...
*/
cupsArraySave(ppd->sorted_attrs);
for (language = (char *)cupsArrayFirst(languages);
language;
language = (char *)cupsArrayNext(languages))
{
if (iccfile)
{
if ((attr = _ppdLocalizedAttr(ppd, "cupsICCProfile", name,
language)) == NULL)
attr = _ppdLocalizedAttr(ppd, "APTiogaProfile", name, language);
}
else
attr = _ppdLocalizedAttr(ppd, "ColorModel", name, language);
if (attr && attr->text[0])
{
cflang = CFStringCreateWithCString(kCFAllocatorDefault, language,
kCFStringEncodingUTF8);
cftext = CFStringCreateWithCString(kCFAllocatorDefault, attr->text,
kCFStringEncodingUTF8);
if (cflang && cftext)
CFDictionarySetValue(dict, cflang, cftext);
if (cflang)
CFRelease(cflang);
if (cftext)
CFRelease(cftext);
}
}
cupsArrayRestore(ppd->sorted_attrs);
}
/*
* Fill in the profile data...
*/
if (iccfile && *iccfile)
{
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8 *)iccfile, (CFIndex)strlen(iccfile), false);
if (url)
{
CFDictionarySetValue(profile, kColorSyncDeviceProfileURL, url);
CFRelease(url);
}
}
CFDictionarySetValue(profile, kColorSyncDeviceModeDescriptions, dict);
CFRelease(dict);
}
static cups_array_t * /* O - Array of active constraints */
ppd_test_constraints(
ppd_file_t *ppd, /* I - PPD file */
const char *option, /* I - Current option */
const char *choice, /* I - Current choice */
int num_options, /* I - Number of additional options */
cups_option_t *options, /* I - Additional options */
int which) /* I - Which constraints to test */
{
int i; /* Looping var */
_ppd_cups_uiconsts_t *consts; /* Current constraints */
_ppd_cups_uiconst_t *constptr; /* Current constraint */
ppd_choice_t key, /* Search key */
*marked; /* Marked choice */
cups_array_t *active = NULL; /* Active constraints */
const char *value, /* Current value */
*firstvalue; /* AP_FIRSTPAGE_Keyword value */
char firstpage[255]; /* AP_FIRSTPAGE_Keyword string */
DEBUG_printf(("7ppd_test_constraints(ppd=%p, option=\"%s\", choice=\"%s\", "
"num_options=%d, options=%p, which=%d)", ppd, option, choice,
num_options, options, which));
if (!ppd->cups_uiconstraints)
ppd_load_constraints(ppd);
DEBUG_printf(("9ppd_test_constraints: %d constraints!",
cupsArrayCount(ppd->cups_uiconstraints)));
cupsArraySave(ppd->marked);
for (consts = (_ppd_cups_uiconsts_t *)cupsArrayFirst(ppd->cups_uiconstraints);
consts;
consts = (_ppd_cups_uiconsts_t *)cupsArrayNext(ppd->cups_uiconstraints))
{
DEBUG_printf(("9ppd_test_constraints: installable=%d, resolver=\"%s\", "
"num_constraints=%d option1=\"%s\", choice1=\"%s\", "
"option2=\"%s\", choice2=\"%s\", ...",
consts->installable, consts->resolver, consts->num_constraints,
consts->constraints[0].option->keyword,
consts->constraints[0].choice ?
consts->constraints[0].choice->choice : "",
consts->constraints[1].option->keyword,
consts->constraints[1].choice ?
consts->constraints[1].choice->choice : ""));
if (consts->installable && which < _PPD_INSTALLABLE_CONSTRAINTS)
continue; /* Skip installable option constraint */
if (!consts->installable && which == _PPD_INSTALLABLE_CONSTRAINTS)
continue; /* Skip non-installable option constraint */
if (which == _PPD_OPTION_CONSTRAINTS && option)
{
/*
* Skip constraints that do not involve the current option...
*/
for (i = consts->num_constraints, constptr = consts->constraints;
i > 0;
i --, constptr ++)
{
if (!_cups_strcasecmp(constptr->option->keyword, option))
break;
if (!_cups_strncasecmp(option, "AP_FIRSTPAGE_", 13) &&
!_cups_strcasecmp(constptr->option->keyword, option + 13))
break;
}
if (!i)
continue;
}
DEBUG_puts("9ppd_test_constraints: Testing...");
for (i = consts->num_constraints, constptr = consts->constraints;
i > 0;
i --, constptr ++)
{
DEBUG_printf(("9ppd_test_constraints: %s=%s?", constptr->option->keyword,
constptr->choice ? constptr->choice->choice : ""));
if (constptr->choice &&
(!_cups_strcasecmp(constptr->option->keyword, "PageSize") ||
!_cups_strcasecmp(constptr->option->keyword, "PageRegion")))
{
/*
* PageSize and PageRegion are used depending on the selected input slot
* and manual feed mode. Validate against the selected page size instead
* of an individual option...
*/
if (option && choice &&
(!_cups_strcasecmp(option, "PageSize") ||
!_cups_strcasecmp(option, "PageRegion")))
{
value = choice;
}
else if ((value = cupsGetOption("PageSize", num_options,
options)) == NULL)
if ((value = cupsGetOption("PageRegion", num_options,
options)) == NULL)
if ((value = cupsGetOption("media", num_options, options)) == NULL)
{
ppd_size_t *size = ppdPageSize(ppd, NULL);
if (size)
value = size->name;
}
if (value && !_cups_strncasecmp(value, "Custom.", 7))
value = "Custom";
if (option && choice &&
(!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageSize") ||
!_cups_strcasecmp(option, "AP_FIRSTPAGE_PageRegion")))
{
firstvalue = choice;
}
else if ((firstvalue = cupsGetOption("AP_FIRSTPAGE_PageSize",
num_options, options)) == NULL)
firstvalue = cupsGetOption("AP_FIRSTPAGE_PageRegion", num_options,
options);
if (firstvalue && !_cups_strncasecmp(firstvalue, "Custom.", 7))
firstvalue = "Custom";
if ((!value || _cups_strcasecmp(value, constptr->choice->choice)) &&
(!firstvalue || _cups_strcasecmp(firstvalue, constptr->choice->choice)))
{
DEBUG_puts("9ppd_test_constraints: NO");
break;
}
}
else if (constptr->choice)
{
/*
* Compare against the constrained choice...
*/
if (option && choice && !_cups_strcasecmp(option, constptr->option->keyword))
{
if (!_cups_strncasecmp(choice, "Custom.", 7))
value = "Custom";
else
value = choice;
}
else if ((value = cupsGetOption(constptr->option->keyword, num_options,
options)) != NULL)
{
if (!_cups_strncasecmp(value, "Custom.", 7))
value = "Custom";
}
else if (constptr->choice->marked)
value = constptr->choice->choice;
else
value = NULL;
/*
* Now check AP_FIRSTPAGE_option...
*/
snprintf(firstpage, sizeof(firstpage), "AP_FIRSTPAGE_%s",
constptr->option->keyword);
if (option && choice && !_cups_strcasecmp(option, firstpage))
{
if (!_cups_strncasecmp(choice, "Custom.", 7))
firstvalue = "Custom";
else
firstvalue = choice;
}
else if ((firstvalue = cupsGetOption(firstpage, num_options,
options)) != NULL)
{
if (!_cups_strncasecmp(firstvalue, "Custom.", 7))
firstvalue = "Custom";
}
else
firstvalue = NULL;
DEBUG_printf(("9ppd_test_constraints: value=%s, firstvalue=%s", value,
firstvalue));
if ((!value || _cups_strcasecmp(value, constptr->choice->choice)) &&
(!firstvalue || _cups_strcasecmp(firstvalue, constptr->choice->choice)))
{
DEBUG_puts("9ppd_test_constraints: NO");
break;
}
}
else if (option && choice &&
!_cups_strcasecmp(option, constptr->option->keyword))
{
if (!_cups_strcasecmp(choice, "None") || !_cups_strcasecmp(choice, "Off") ||
!_cups_strcasecmp(choice, "False"))
{
DEBUG_puts("9ppd_test_constraints: NO");
break;
}
}
else if ((value = cupsGetOption(constptr->option->keyword, num_options,
options)) != NULL)
{
if (!_cups_strcasecmp(value, "None") || !_cups_strcasecmp(value, "Off") ||
!_cups_strcasecmp(value, "False"))
{
DEBUG_puts("9ppd_test_constraints: NO");
break;
}
}
else
{
key.option = constptr->option;
if ((marked = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key))
== NULL ||
(!_cups_strcasecmp(marked->choice, "None") ||
!_cups_strcasecmp(marked->choice, "Off") ||
!_cups_strcasecmp(marked->choice, "False")))
{
DEBUG_puts("9ppd_test_constraints: NO");
break;
}
}
}
if (i <= 0)
{
if (!active)
active = cupsArrayNew(NULL, NULL);
cupsArrayAdd(active, consts);
DEBUG_puts("9ppd_test_constraints: Added...");
}
}
cupsArrayRestore(ppd->marked);
DEBUG_printf(("8ppd_test_constraints: Found %d active constraints!",
cupsArrayCount(active)));
return (active);
}
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);
}
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);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
help_index_t *hi, /* Help index */
*si; /* Search index */
help_node_t *n; /* Current help node */
int i; /* Looping var */
const char *query; /* Search query */
const char *cache_dir; /* CUPS_CACHEDIR environment variable */
const char *docroot; /* CUPS_DOCROOT environment variable */
const char *helpfile, /* Current help file */
*helptitle = NULL; /* Current help title */
const char *topic; /* Current topic */
char topic_data[1024]; /* Topic form data */
const char *section; /* Current section */
char filename[1024], /* Filename */
directory[1024]; /* Directory */
cups_file_t *fp; /* Help file */
char line[1024]; /* Line from file */
int printable; /* Show printable version? */
/*
* Get any form variables...
*/
cgiInitialize();
printable = cgiGetVariable("PRINTABLE") != NULL;
/*
* Set the web interface section...
*/
cgiSetVariable("SECTION", "help");
cgiSetVariable("REFRESH_PAGE", "");
/*
* Load the help index...
*/
if ((cache_dir = getenv("CUPS_CACHEDIR")) == NULL)
cache_dir = CUPS_CACHEDIR;
snprintf(filename, sizeof(filename), "%s/help.index", cache_dir);
if ((docroot = getenv("CUPS_DOCROOT")) == NULL)
docroot = CUPS_DOCROOT;
snprintf(directory, sizeof(directory), "%s/help", docroot);
fprintf(stderr, "DEBUG: helpLoadIndex(filename=\"%s\", directory=\"%s\")\n",
filename, directory);
hi = helpLoadIndex(filename, directory);
if (!hi)
{
perror(filename);
cgiStartHTML(cgiText(_("Online Help")));
cgiSetVariable("ERROR", cgiText(_("Unable to load help index.")));
cgiCopyTemplateLang("error.tmpl");
cgiEndHTML();
return (1);
}
fprintf(stderr, "DEBUG: %d nodes in help index...\n",
cupsArrayCount(hi->nodes));
/*
* See if we are viewing a file...
*/
for (i = 0; i < argc; i ++)
fprintf(stderr, "DEBUG: argv[%d]=\"%s\"\n", i, argv[i]);
if ((helpfile = getenv("PATH_INFO")) != NULL)
{
helpfile ++;
if (!*helpfile)
helpfile = NULL;
}
if (helpfile)
{
/*
* Verify that the help file exists and is part of the index...
*/
snprintf(filename, sizeof(filename), "%s/help/%s", docroot, helpfile);
fprintf(stderr, "DEBUG: helpfile=\"%s\", filename=\"%s\"\n",
helpfile, filename);
if (access(filename, R_OK))
{
perror(filename);
cgiStartHTML(cgiText(_("Online Help")));
cgiSetVariable("ERROR", cgiText(_("Unable to access help file.")));
cgiCopyTemplateLang("error.tmpl");
cgiEndHTML();
return (1);
}
if ((n = helpFindNode(hi, helpfile, NULL)) == NULL)
{
cgiStartHTML(cgiText(_("Online Help")));
cgiSetVariable("ERROR", cgiText(_("Help file not in index.")));
cgiCopyTemplateLang("error.tmpl");
cgiEndHTML();
return (1);
}
/*
* Save the page title and help file...
*/
helptitle = n->text;
topic = n->section;
/*
* Send a standard page header...
*/
if (printable)
puts("Content-Type: text/html;charset=utf-8\n");
else
cgiStartHTML(n->text);
}
else
{
/*
* Send a standard page header...
*/
cgiStartHTML(cgiText(_("Online Help")));
topic = cgiGetVariable("TOPIC");
}
/*
* Do a search as needed...
*/
if (cgiGetVariable("CLEAR"))
cgiSetVariable("QUERY", "");
query = cgiGetVariable("QUERY");
si = helpSearchIndex(hi, query, topic, helpfile);
cgiClearVariables();
if (query)
cgiSetVariable("QUERY", query);
if (topic)
cgiSetVariable("TOPIC", topic);
if (helpfile)
cgiSetVariable("HELPFILE", helpfile);
if (helptitle)
cgiSetVariable("HELPTITLE", helptitle);
fprintf(stderr, "DEBUG: query=\"%s\", topic=\"%s\"\n",
query ? query : "(null)", topic ? topic : "(null)");
if (si)
{
help_node_t *nn; /* Parent node */
fprintf(stderr,
"DEBUG: si=%p, si->sorted=%p, cupsArrayCount(si->sorted)=%d\n", si,
si->sorted, cupsArrayCount(si->sorted));
for (i = 0, n = (help_node_t *)cupsArrayFirst(si->sorted);
n;
i ++, n = (help_node_t *)cupsArrayNext(si->sorted))
{
if (helpfile && n->anchor)
snprintf(line, sizeof(line), "#%s", n->anchor);
else if (n->anchor)
snprintf(line, sizeof(line), "/help/%s?QUERY=%s#%s", n->filename,
query ? query : "", n->anchor);
else
snprintf(line, sizeof(line), "/help/%s?QUERY=%s", n->filename,
query ? query : "");
cgiSetArray("QTEXT", i, n->text);
cgiSetArray("QLINK", i, line);
if (!helpfile && n->anchor)
{
nn = helpFindNode(hi, n->filename, NULL);
snprintf(line, sizeof(line), "/help/%s?QUERY=%s", nn->filename,
query ? query : "");
cgiSetArray("QPTEXT", i, nn->text);
cgiSetArray("QPLINK", i, line);
}
else
{
cgiSetArray("QPTEXT", i, "");
cgiSetArray("QPLINK", i, "");
}
fprintf(stderr, "DEBUG: [%d] = \"%s\" @ \"%s\"\n", i, n->text, line);
}
helpDeleteIndex(si);
}
/*
* OK, now list the bookmarks within the index...
*/
for (i = 0, section = NULL, n = (help_node_t *)cupsArrayFirst(hi->sorted);
n;
n = (help_node_t *)cupsArrayNext(hi->sorted))
{
if (n->anchor)
continue;
/*
* Add a section link as needed...
*/
if (n->section &&
(!section || strcmp(n->section, section)))
{
/*
* Add a link for this node...
*/
snprintf(line, sizeof(line), "/help/?TOPIC=%s&QUERY=%s",
cgiFormEncode(topic_data, n->section, sizeof(topic_data)),
query ? query : "");
cgiSetArray("BMLINK", i, line);
cgiSetArray("BMTEXT", i, n->section);
cgiSetArray("BMINDENT", i, "0");
i ++;
section = n->section;
}
if (!topic || strcmp(n->section, topic))
continue;
/*
* Add a link for this node...
*/
snprintf(line, sizeof(line), "/help/%s?TOPIC=%s&QUERY=%s", n->filename,
cgiFormEncode(topic_data, n->section, sizeof(topic_data)),
query ? query : "");
cgiSetArray("BMLINK", i, line);
cgiSetArray("BMTEXT", i, n->text);
cgiSetArray("BMINDENT", i, "1");
i ++;
if (helpfile && !strcmp(helpfile, n->filename))
{
help_node_t *nn; /* Pointer to sub-node */
cupsArraySave(hi->sorted);
for (nn = (help_node_t *)cupsArrayFirst(hi->sorted);
nn;
nn = (help_node_t *)cupsArrayNext(hi->sorted))
if (nn->anchor && !strcmp(helpfile, nn->filename))
{
/*
* Add a link for this node...
*/
snprintf(line, sizeof(line), "#%s", nn->anchor);
cgiSetArray("BMLINK", i, line);
cgiSetArray("BMTEXT", i, nn->text);
cgiSetArray("BMINDENT", i, "2");
i ++;
}
cupsArrayRestore(hi->sorted);
}
}
/*
* Show the search and bookmark content...
*/
if (!helpfile || !printable)
cgiCopyTemplateLang("help-header.tmpl");
else
cgiCopyTemplateLang("help-printable.tmpl");
/*
* If we are viewing a file, copy it in now...
*/
if (helpfile)
{
if ((fp = cupsFileOpen(filename, "r")) != NULL)
{
int inbody; /* Are we inside the body? */
inbody = 0;
while (cupsFileGets(fp, line, sizeof(line)))
{
if (inbody)
{
if (!_cups_strncasecmp(line, "</BODY>", 7))
break;
printf("%s\n", line);
}
else if (!_cups_strncasecmp(line, "<BODY", 5))
inbody = 1;
}
cupsFileClose(fp);
}
else
{
perror(filename);
cgiSetVariable("ERROR", cgiText(_("Unable to open help file.")));
cgiCopyTemplateLang("error.tmpl");
}
}
/*
* Send a standard trailer...
*/
if (!printable)
{
cgiCopyTemplateLang("help-trailer.tmpl");
cgiEndHTML();
}
else
puts("</BODY>\n</HTML>");
/*
* Delete the index...
*/
helpDeleteIndex(hi);
/*
* Return with no errors...
*/
return (0);
}
static cups_array_t * /* O - Array of filters to run */
mime_find_filters(
mime_t *mime, /* I - MIME database */
mime_type_t *src, /* I - Source file type */
size_t srcsize, /* I - Size of source file */
mime_type_t *dst, /* I - Destination file type */
int *cost, /* O - Cost of filters */
_mime_typelist_t *list) /* I - Source types we've used */
{
int tempcost, /* Temporary cost */
mincost; /* Current minimum */
cups_array_t *temp, /* Temporary filter */
*mintemp; /* Current minimum */
mime_filter_t *current, /* Current filter */
srckey; /* Source type key */
_mime_typelist_t listnode, /* New list node */
*listptr; /* Pointer in list */
DEBUG_printf(("2mime_find_filters(mime=%p, src=%p(%s/%s), srcsize=" CUPS_LLFMT
", dst=%p(%s/%s), cost=%p, list=%p)", mime, src, src->super,
src->type, CUPS_LLCAST srcsize, dst, dst->super, dst->type,
cost, list));
/*
* See if there is a filter that can convert the files directly...
*/
if ((current = mimeFilterLookup(mime, src, dst)) != NULL &&
(current->maxsize == 0 || srcsize <= current->maxsize))
{
/*
* Got a direct filter!
*/
DEBUG_puts("3mime_find_filters: Direct filter found.");
if ((mintemp = cupsArrayNew(NULL, NULL)) == NULL)
{
DEBUG_puts("3mime_find_filters: Returning NULL (out of memory).");
return (NULL);
}
cupsArrayAdd(mintemp, current);
mincost = current->cost;
if (!cost)
{
DEBUG_printf(("3mime_find_filters: Returning 1 filter, cost %d:",
mincost));
DEBUG_printf(("3mime_find_filters: %s/%s %s/%s %d %s",
current->src->super, current->src->type,
current->dst->super, current->dst->type,
current->cost, current->filter));
return (mintemp);
}
}
else
{
/*
* No direct filter...
*/
mintemp = NULL;
mincost = 9999999;
}
/*
* Initialize this node in the type list...
*/
listnode.next = list;
/*
* OK, now look for filters from the source type to any other type...
*/
srckey.src = src;
for (current = (mime_filter_t *)cupsArrayFind(mime->srcs, &srckey);
current && current->src == src;
current = (mime_filter_t *)cupsArrayNext(mime->srcs))
{
/*
* See if we have already tried the destination type as a source
* type (this avoids extra filter looping...)
*/
mime_type_t *current_dst; /* Current destination type */
if (current->maxsize > 0 && srcsize > current->maxsize)
continue;
for (listptr = list, current_dst = current->dst;
listptr;
listptr = listptr->next)
if (current_dst == listptr->src)
break;
if (listptr)
continue;
/*
* See if we have any filters that can convert from the destination type
* of this filter to the final type...
*/
listnode.src = current->src;
cupsArraySave(mime->srcs);
temp = mime_find_filters(mime, current->dst, srcsize, dst, &tempcost,
&listnode);
cupsArrayRestore(mime->srcs);
if (!temp)
continue;
if (!cost)
{
DEBUG_printf(("3mime_find_filters: Returning %d filter(s), cost %d:",
cupsArrayCount(temp), tempcost));
#ifdef DEBUG
for (current = (mime_filter_t *)cupsArrayFirst(temp);
current;
current = (mime_filter_t *)cupsArrayNext(temp))
DEBUG_printf(("3mime_find_filters: %s/%s %s/%s %d %s",
current->src->super, current->src->type,
current->dst->super, current->dst->type,
current->cost, current->filter));
#endif /* DEBUG */
return (temp);
}
/*
* Found a match; see if this one is less costly than the last (if
* any...)
*/
tempcost += current->cost;
if (tempcost < mincost)
{
cupsArrayDelete(mintemp);
/*
* Hey, we got a match! Add the current filter to the beginning of the
* filter list...
*/
mintemp = temp;
mincost = tempcost;
cupsArrayInsert(mintemp, current);
}
else
cupsArrayDelete(temp);
}
if (mintemp)
{
/*
* Hey, we got a match!
*/
DEBUG_printf(("3mime_find_filters: Returning %d filter(s), cost %d:",
cupsArrayCount(mintemp), mincost));
#ifdef DEBUG
for (current = (mime_filter_t *)cupsArrayFirst(mintemp);
current;
current = (mime_filter_t *)cupsArrayNext(mintemp))
DEBUG_printf(("3mime_find_filters: %s/%s %s/%s %d %s",
current->src->super, current->src->type,
current->dst->super, current->dst->type,
current->cost, current->filter));
#endif /* DEBUG */
if (cost)
*cost = mincost;
return (mintemp);
}
DEBUG_puts("3mime_find_filters: Returning NULL (no matches).");
return (NULL);
}
static void
sysUpdate(void)
{
int i; /* Looping var */
cupsd_sysevent_t sysevent; /* The system event */
cupsd_printer_t *p; /* Printer information */
/*
* Drain the event pipe...
*/
while (read((int)SysEventPipes[0], &sysevent, sizeof(sysevent))
== sizeof(sysevent))
{
if (sysevent.event & SYSEVENT_CANSLEEP)
{
/*
* If there are active printers that don't have the connecting-to-device
* printer-state-reason then cancel the sleep request (i.e. this reason
* indicates a job that is not yet connected to the printer)...
*/
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
{
if (p->job)
{
for (i = 0; i < p->num_reasons; i ++)
if (!strcmp(p->reasons[i], "connecting-to-device"))
break;
if (!p->num_reasons || i >= p->num_reasons)
break;
}
}
if (p)
{
cupsdLogMessage(CUPSD_LOG_INFO,
"System sleep canceled because printer %s is active",
p->name);
IOCancelPowerChange(sysevent.powerKernelPort,
sysevent.powerNotificationID);
}
else
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "System wants to sleep");
IOAllowPowerChange(sysevent.powerKernelPort,
sysevent.powerNotificationID);
}
}
if (sysevent.event & SYSEVENT_WILLSLEEP)
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "System going to sleep");
Sleeping = 1;
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
{
if (p->type & CUPS_PRINTER_DISCOVERED)
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Deleting remote destination \"%s\"", p->name);
cupsArraySave(Printers);
cupsdDeletePrinter(p, 0);
cupsArrayRestore(Printers);
}
else
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Deregistering local printer \"%s\"", p->name);
cupsdDeregisterPrinter(p, 0);
}
}
cupsdCleanDirty();
/*
* If we have no printing jobs, allow the power change immediately.
* Otherwise set the SleepJobs time to 15 seconds in the future when
* we'll take more drastic measures...
*/
if (cupsArrayCount(PrintingJobs) == 0)
IOAllowPowerChange(sysevent.powerKernelPort,
sysevent.powerNotificationID);
else
{
LastSysEvent = sysevent;
SleepJobs = time(NULL) + 15;
}
}
if (sysevent.event & SYSEVENT_WOKE)
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "System woke from sleep");
IOAllowPowerChange(sysevent.powerKernelPort,
sysevent.powerNotificationID);
Sleeping = 0;
cupsdCheckJobs();
}
if (sysevent.event & SYSEVENT_NETCHANGED)
{
if (!Sleeping)
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"System network configuration changed");
/*
* Resetting browse_time before calling cupsdSendBrowseList causes
* browse packets to be sent for local shared printers.
*/
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
p->browse_time = 0;
cupsdSendBrowseList();
cupsdRestartPolling();
}
else
cupsdLogMessage(CUPSD_LOG_DEBUG,
"System network configuration changed; "
"ignored while sleeping");
}
if (sysevent.event & SYSEVENT_NAMECHANGED)
{
if (!Sleeping)
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Computer name or BTMM domains changed");
/*
* De-register the individual printers...
*/
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
cupsdDeregisterPrinter(p, 1);
/*
* Update the computer name and BTMM domain list...
*/
cupsdUpdateDNSSDName();
/*
* Now re-register them...
*/
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
{
p->browse_time = 0;
cupsdRegisterPrinter(p);
}
}
else
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Computer name or BTMM domains changed; ignored while "
"sleeping");
}
}
}
