/*
* XpGetContentOrientation determines the content-orientation as
* determined by the passed context. The page and document pools are
* queried in turn for a specified content-orientation attribute. If none
* is found the first content-orientation in the
* content-orientations-supported printer attribute is taken as the
* default.
*
* Note: This routine assumes the values found in the passed context's
* attributes pools have been validated.
*/
XpOid
XpGetContentOrientation(
XpContextPtr pContext)
{
XpOid orientation;
orientation = XpGetOidAttr(pContext, XPPageAttr,
xpoid_att_content_orientation,
(XpOidList*)NULL);
if(xpoid_none == orientation)
orientation = XpGetOidAttr(pContext, XPDocAttr,
xpoid_att_content_orientation,
(XpOidList*)NULL);
if(xpoid_none == orientation)
{
XpOidList* content_orientations_supported;
content_orientations_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_content_orientations_supported,
(XpOidList*)NULL);
orientation = XpOidListGetOid(content_orientations_supported, 0);
XpOidListDelete(content_orientations_supported);
}
return orientation;
}
/*
* XpGetAvailableCompression determines the available-compression as
* determined by the passed context. The page and document pools are
* queried in turn for a specified content-orientation attribute. If none
* is found the first available-compression in the
* avaiable-compressions-supported printer attribute is taken as the
* default.
*
* Note: This routine assumes the values found in the passed context's
* attributes pools have been validated.
*/
XpOid
XpGetAvailableCompression(
XpContextPtr pContext)
{
XpOid compression;
compression = XpGetOidAttr(pContext, XPPageAttr,
xpoid_att_available_compression,
(XpOidList*)NULL);
if(xpoid_none == compression)
compression = XpGetOidAttr(pContext, XPDocAttr,
xpoid_att_available_compression,
(XpOidList*)NULL);
if(xpoid_none == compression)
{
XpOidList* available_compressions_supported;
available_compressions_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_available_compressions_supported,
(XpOidList*)NULL);
compression = XpOidListGetOid(available_compressions_supported, 0);
XpOidListDelete(available_compressions_supported);
}
return compression;
}
void
XpValidateJobPool(XpContextPtr pContext,
const XpValidatePoolsRec* vpr)
{
/*
* Note: the 'vpr' argument is unused in this
* implementation; it is reserved for future use
*/
XpOidList* job_attrs_supported;
/*
* only validate attributes found in job-attributes-supported
*/
job_attrs_supported = XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_job_attributes_supported,
(const XpOidList*)NULL);
/*
* notification-profile
*/
if(XpOidListHasOid(job_attrs_supported, xpoid_att_notification_profile))
{
XpValidateNotificationProfile(pContext);
}
/*
* clean up
*/
XpOidListDelete(job_attrs_supported);
}
void
XpValidateListAttr(XpContextPtr pContext,
XPAttributes pool,
XpOid oid,
const XpOidList* valid_oids,
const XpOidList* default_oids)
{
XpOidList* list = XpGetListAttr(pContext, pool, oid, valid_oids);
if(XpOidListCount(list) == 0)
XpPutListAttr(pContext, pool, oid, default_oids);
else
XpPutListAttr(pContext, pool, oid, list);
XpOidListDelete(list);
}
void
XpValidatePagePool(XpContextPtr pContext,
const XpValidatePoolsRec* vpr)
{
XpOidList* page_attrs_supported;
/*
* only validate attributes found in xp-page-attributes-supported
*/
page_attrs_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_xp_page_attributes_supported,
(const XpOidList*)NULL);
/*
* validate
*/
XpValidateDocOrPagePool(pContext, XPPageAttr,
page_attrs_supported, vpr);
/*
* clean up
*/
XpOidListDelete(page_attrs_supported);
}
void
XpValidateDocumentPool(XpContextPtr pContext,
const XpValidatePoolsRec* vpr)
{
XpOidList* document_attrs_supported;
/*
* only validate attributes found in document-attributes-supported
*/
document_attrs_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_document_attributes_supported,
(const XpOidList*)NULL);
/*
* validate
*/
XpValidateDocOrPagePool(pContext, XPDocAttr,
document_attrs_supported, vpr);
/*
* clean up
*/
XpOidListDelete(document_attrs_supported);
}
/*
* XpGetPlex determines the plex as determined by the passed context. The page
* and document pools are queried in turn for a specified plex attribute. If
* none is found the first plex in the plexes-supported printer attribute is
* taken as the default.
*
* Note: This routine assumes the values found in the passed context's
* attributes pools have been validated.
*/
XpOid
XpGetPlex(
XpContextPtr pContext)
{
XpOid plex;
plex = XpGetOidAttr(pContext, XPPageAttr, xpoid_att_plex,
(XpOidList*)NULL);
if(xpoid_none == plex)
plex = XpGetOidAttr(pContext, XPDocAttr, xpoid_att_plex,
(XpOidList*)NULL);
if(xpoid_none == plex)
{
XpOidList* plexes_supported;
plexes_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_plexes_supported,
(XpOidList*)NULL);
plex = XpOidListGetOid(plexes_supported, 0);
XpOidListDelete(plexes_supported);
}
return plex;
}
static void
XpValidateDocOrPagePool(XpContextPtr pContext,
XPAttributes pool, /* XPDocAttr or XPPageAttr */
const XpOidList* attrs_supported,
const XpValidatePoolsRec* vpr)
{
/*
* content-orientation
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_content_orientation))
{
XpOidList* content_orientations_supported;
content_orientations_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_content_orientations_supported,
vpr->valid_content_orientations_supported);
XpValidateOidAttr(pContext, pool, xpoid_att_content_orientation,
content_orientations_supported, xpoid_none);
XpOidListDelete(content_orientations_supported);
}
/*
* copy-count
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_copy_count))
XpValidateCardAttr(pContext, pool, xpoid_att_copy_count,
(const XpOidCardList*)NULL, 0);
/*
* default-printer-resolution
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_default_printer_resolution))
{
XpOidCardList* printer_resolutions_supported;
printer_resolutions_supported =
XpGetCardListAttr(pContext, XPPrinterAttr,
xpoid_att_printer_resolutions_supported,
vpr->valid_printer_resolutions_supported);
XpValidateCardAttr(pContext, pool,
xpoid_att_default_printer_resolution,
printer_resolutions_supported, 0);
XpOidCardListDelete(printer_resolutions_supported);
}
/*
* default-input-tray
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_default_input_tray))
{
XpOidTrayMediumList* input_trays_medium;
const char* value_in;
XpOid value_tray;
input_trays_medium =
XpGetTrayMediumListAttr(pContext, XPPrinterAttr,
xpoid_att_input_trays_medium,
(const XpOidList*)NULL,
(const XpOidMediumSS*)NULL);
value_in =
XpGetStringAttr(pContext, pool, xpoid_att_default_input_tray);
value_tray = XpOidFromString(value_in);
if(!XpOidTrayMediumListHasTray(input_trays_medium, value_tray))
value_tray = xpoid_none;
XpPutOidAttr(pContext, pool, xpoid_att_default_input_tray, value_tray);
XpOidTrayMediumListDelete(input_trays_medium);
}
/*
* default-medium
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_default_medium))
{
XpOidMediumSS* msss;
const char* value_in;
XpOid value_size;
msss = XpGetMediumSSAttr(pContext, XPPrinterAttr,
xpoid_att_medium_source_sizes_supported,
(const XpOidList*)NULL,
(const XpOidList*)NULL);
value_in = XpGetStringAttr(pContext, pool, xpoid_att_default_medium);
value_size = XpOidFromString(value_in);
if(!XpOidMediumSSHasSize(msss, value_size))
value_size = xpoid_none;
XpPutOidAttr(pContext, pool, xpoid_att_default_medium, value_size);
XpOidMediumSSDelete(msss);
}
/*
* document-format
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_document_format))
{
XpOidDocFmtList* document_formats_supported;
const char* value_in;
XpOidDocFmt* document_format;
const char* value_out;
document_formats_supported =
XpGetDocFmtListAttr(pContext, XPPrinterAttr,
xpoid_att_document_formats_supported,
vpr->valid_document_formats_supported);
value_in = XpGetStringAttr(pContext, pool, xpoid_att_document_format);
document_format = XpOidDocFmtNew(value_in);
if(XpOidDocFmtListHasFmt(document_formats_supported, document_format))
value_out = XpOidDocFmtString(document_format);
else
value_out = XpOidDocFmtString(vpr->default_document_format);
XpOidDocFmtListDelete(document_formats_supported);
XpOidDocFmtDelete(document_format);
XpPutStringAttr(pContext, pool, xpoid_att_document_format, value_out);
XpOidFree(value_out);
}
/*
* plex
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_plex))
{
XpOidList* plexes_supported;
plexes_supported =
XpGetListAttr(pContext, XPPrinterAttr, xpoid_att_plexes_supported,
vpr->valid_plexes_supported);
XpValidateOidAttr(pContext, pool, xpoid_att_plex,
plexes_supported, xpoid_none);
XpOidListDelete(plexes_supported);
}
/*
* xp-listfonts-modes
*/
if(XpOidListHasOid(attrs_supported, xpoid_att_xp_listfonts_modes))
{
XpOidList* xp_listfonts_modes_supported;
xp_listfonts_modes_supported =
XpGetListAttr(pContext, XPPrinterAttr,
xpoid_att_xp_listfonts_modes_supported,
vpr->valid_xp_listfonts_modes_supported);
XpValidateListAttr(pContext, pool, xpoid_att_xp_listfonts_modes,
xp_listfonts_modes_supported,
(const XpOidList*)NULL);
XpOidListDelete(xp_listfonts_modes_supported);
}
}
