* Copyright 2010, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Pfeiffer
*/
#include "GPCapabilityExtractor.h"
#include "PrinterCap.h"
const char* kInputSlot = "InputSlot";
#if 1
#define GP_PRINT(...) \
fprintf(stderr, __VA_ARGS__)
#else
#define GP_PRINT(...) \
{}
#endif
GPCapabilityExtractor::GPCapabilityExtractor(GPCapabilities* capabilities)
:
fState(kIgnoreParameter),
fCapabilities(capabilities),
fIndex(0),
fNextDriverSpecificCategoryID(PrinterCap::kDriverSpecificCapabilitiesBegin)
{
}
bool
GPCapabilityExtractor::BeginParameter(const char* name, const char* displayName,
stp_parameter_class_t parameterClass)
{
fState = kIgnoreParameter;
if (strcmp(kPageSize, name) == 0) {
GP_PRINT("Supported parameter: %s\n", name);
fState = kExtractPageSizeParameter;
} else if (strcmp(kResolution, name) == 0) {
GP_PRINT("Supported parameter: %s\n", name);
fState = kExtractResolutionParameter;
} else if (strcmp(kInputSlot, name) == 0) {
GP_PRINT("Supported parameter: %s\n", name);
fState = kExtractInputSlotParameter;
} else if (strcmp(kPrintingMode, name) == 0) {
GP_PRINT("Supported parameter: %s\n", name);
fState = kExtractPrintingModeParameter;
} else {
GP_PRINT("Parameter: %s - %s\n", name, displayName);
if (!Supportsed(parameterClass))
return false;
fState = kExtractParameter;
DriverSpecificCap* capability = new DriverSpecificCap(displayName,
fNextDriverSpecificCategoryID, DriverSpecificCap::kList);
capability->fKey = name;
fDriverSpecificCategories.push_back(capability);
}
return true;
}
void
GPCapabilityExtractor::DefaultStringParameter(const char* name,
const char* key)
{
if (key == NULL)
fDefaultKey = "";
else
fDefaultKey = key;
}
void
GPCapabilityExtractor::StringParameterSize(const char* name, int size)
{
fIndex = 0;
switch (fState) {
case kExtractPageSizeParameter:
fCapabilities->fPageSizes.SetSize(size);
break;
case kExtractResolutionParameter:
fCapabilities->fResolutions.SetSize(size);
break;
case kExtractInputSlotParameter:
fCapabilities->fInputSlots.SetSize(size);
break;
case kExtractPrintingModeParameter:
fCapabilities->fPrintingModes.SetSize(size);
break;
case kExtractParameter:
fState = kExtractListParameter;
fCapabilities->fDriverSpecificCapabilities[
fNextDriverSpecificCategoryID].SetSize(size);
break;
default:
break;
}
}
void
GPCapabilityExtractor::StringParameter(const char* name, const char* key,
const char* displayName)
{
bool isDefault = fDefaultKey == key;
EnumCap* capability;
switch (fState) {
case kExtractResolutionParameter:
GP_PRINT("GPCapabilityExtractor: ResolutionParameter expected\n");
break;
case kExtractInputSlotParameter:
capability = new PaperSourceCap(displayName, isDefault,
static_cast<JobData::PaperSource>(fIndex));
AddCapability(fCapabilities->fInputSlots, capability, key);
break;
case kExtractPrintingModeParameter:
capability = new ColorCap(displayName, isDefault,
static_cast<JobData::Color>(fIndex));
AddCapability(fCapabilities->fPrintingModes, capability, key);
break;
case kExtractListParameter:
capability = new ListItemCap(displayName, isDefault, fIndex);
AddCapability(fCapabilities->fDriverSpecificCapabilities[
fNextDriverSpecificCategoryID], capability, key);
break;
default:
break;
}
}
void
GPCapabilityExtractor::ResolutionParameter(const char* name, const char* key,
const char* displayName, int x, int y)
{
bool isDefault = fDefaultKey == key;
EnumCap* capability;
int resolution;
switch (fState) {
case kExtractResolutionParameter:
if (x <= 0 || y <= 0) {
fCapabilities->fResolutions.DecreaseSize();
break;
}
resolution = max_c(x, y);
capability = new ResolutionCap(displayName, isDefault, fIndex,
resolution, resolution);
AddCapability(fCapabilities->fResolutions, capability, key);
break;
default:
break;
}
}
void
GPCapabilityExtractor::PageSizeParameter(const char* name, const char* key,
const char* displayName, BSize pageSize, BRect imageableArea)
{
bool isDefault = fDefaultKey == key;
EnumCap* capability;
switch (fState) {
case kExtractPageSizeParameter:
capability = new PaperCap(displayName, isDefault,
static_cast<JobData::Paper>(fIndex),
BRect(0, 0, pageSize.width, pageSize.height),
imageableArea);
AddCapability(fCapabilities->fPageSizes, capability, key);
break;
default:
break;
}
}
void
GPCapabilityExtractor::EndParameter(const char* name)
{
if (fState == kExtractListParameter) {
fNextDriverSpecificCategoryID ++;
}
}
void
GPCapabilityExtractor::BooleanParameter(const char* name,
const char* displayName, bool defaultValue,
stp_parameter_class_t parameterClass)
{
if (!Supportsed(parameterClass))
return;
BooleanCap* capability = new BooleanCap(displayName, defaultValue);
AddDriverSpecificCapability(name, displayName, DriverSpecificCap::kBoolean,
capability);
}
void
GPCapabilityExtractor::DoubleParameter(const char* name,
const char* displayName, double lower, double upper, double defaultValue,
stp_parameter_class_t parameterClass)
{
if (!Supportsed(parameterClass))
return;
DoubleRangeCap* capability = new DoubleRangeCap(displayName, lower, upper,
defaultValue);
AddDriverSpecificCapability(name, displayName,
DriverSpecificCap::kDoubleRange, capability);
}
void
GPCapabilityExtractor::IntParameter(const char* name, const char* displayName,
int lower, int upper, int defaultValue,
stp_parameter_class_t parameterClass)
{
if (!Supportsed(parameterClass))
return;
IntRangeCap* capability = new IntRangeCap(displayName, lower, upper,
defaultValue);
AddDriverSpecificCapability(name, displayName, DriverSpecificCap::kIntRange,
capability);
}
void
GPCapabilityExtractor::DimensionParameter(const char* name,
const char* displayName, int lower, int upper, int defaultValue,
stp_parameter_class_t parameterClass)
{
if (!Supportsed(parameterClass))
return;
IntRangeCap* capability = new IntRangeCap(displayName, lower, upper,
defaultValue);
AddDriverSpecificCapability(name, displayName,
DriverSpecificCap::kIntDimension, capability);
}
void
GPCapabilityExtractor::EndVisit()
{
if (fCapabilities->fInputSlots.Size() == 0)
AddDefaultInputSlot();
SetDriverSpecificCategories();
}
bool
GPCapabilityExtractor::Supportsed(stp_parameter_class_t parameterClass)
{
return parameterClass == STP_PARAMETER_CLASS_FEATURE
|| parameterClass == STP_PARAMETER_CLASS_OUTPUT;
}
void
GPCapabilityExtractor::AddDefaultInputSlot()
{
BeginParameter(kInputSlot, "Input Slot", STP_PARAMETER_CLASS_FEATURE);
DefaultStringParameter(kInputSlot, "");
StringParameterSize(kInputSlot, 1);
StringParameter(kInputSlot, "", "Default");
EndParameter(kInputSlot);
}
void
GPCapabilityExtractor::SetDriverSpecificCategories()
{
int size = fDriverSpecificCategories.size();
if (size == 0)
return;
fCapabilities->fDriverSpecificCategories.SetSize(size);
struct BaseCap** array = fCapabilities->fDriverSpecificCategories.Array();
list<DriverSpecificCap*>::iterator it = fDriverSpecificCategories.begin();
for (int index = 0; it != fDriverSpecificCategories.end(); it ++,
index ++) {
array[index] = *it;
}
}
void
GPCapabilityExtractor::AddCapability(GPArray<struct BaseCap>& array,
EnumCap* capability, const char* key)
{
capability->fKey = key;
array.Array()[fIndex] = capability;
fIndex ++;
}
void
GPCapabilityExtractor::AddDriverSpecificCapability(const char* name,
const char* displayName, DriverSpecificCap::Type type, BaseCap* capability)
{
DriverSpecificCap* parent = new DriverSpecificCap(displayName,
fNextDriverSpecificCategoryID, type);
parent->fKey = name;
fDriverSpecificCategories.push_back(parent);
GPArray<struct BaseCap>& array = fCapabilities->fDriverSpecificCapabilities
[fNextDriverSpecificCategoryID];
array.SetSize(1);
array.Array()[0] = capability;
fNextDriverSpecificCategoryID++;
}
