* JobData.cpp
* Copyright 1999-2000 Y.Takagi. All Rights Reserved.
*/
#include "JobData.h"
#include <Debug.h>
#include <InterfaceDefs.h>
#include <Message.h>
#include <sstream>
#include "PrinterCap.h"
#include "DbgMsg.h"
static const char *kJDXRes = "xres";
static const char *kJDYRes = "yres";
static const char *kJDCopies = "copies";
static const char *kJDOrientation = "orientation";
static const char *kJDScaling = "scale";
static const char *kJDScaledPaperRect = "paper_rect";
static const char *kJDScaledPrintableRect = "printable_rect";
static const char *kJDFirstPage = "first_page";
static const char *kJDLastPage = "last_page";
static const char *kJDShowPreview = "JJJJ_showPreview";
static const char *kJDPaper = "JJJJ_paper";
static const char *kJDNup = "JJJJ_nup";
static const char *kJDGamma = "JJJJ_gamma";
static const char *kJDInkDensity = "JJJJ_ink_density";
static const char *kJDPaperSource = "JJJJ_paper_source";
static const char *kJDCollate = "JJJJ_collate";
static const char *kJDReverse = "JJJJ_reverse";
static const char *kJDPrintStyle = "JJJJ_print_style";
static const char *kJDBindingLocation = "JJJJ_binding_location";
static const char *kJDPageOrder = "JJJJ_page_order";
static const char *kJDColor = "JJJJ_color";
static const char *kJDDitherType = "JJJJ_dither_type";
static const char *kJDPaperRect = "JJJJ_paper_rect";
static const char* kJDPrintableRect = "JJJJ_printable_rect";
static const char* kJDPageSelection = "JJJJ_page_selection";
static const char* kJDMarginUnit = "JJJJ_margin_unit";
static const char* kJDPhysicalRect = "JJJJ_physical_rect";
static const char* kJDScaledPhysicalRect = "JJJJ_scaled_physical_rect";
static const char* kJDResolution = "JJJJ_resolution";
static const char* kJDDriverSpecificSettings = "JJJJ_driverSpecificSettings";
DriverSpecificSettings::DriverSpecificSettings()
{
}
DriverSpecificSettings::DriverSpecificSettings(
const DriverSpecificSettings& settings)
:
fSettings(settings.fSettings)
{
}
DriverSpecificSettings &
DriverSpecificSettings::operator=(const DriverSpecificSettings &settings)
{
fSettings = settings.fSettings;
return *this;
}
void
DriverSpecificSettings::MakeEmpty()
{
fSettings.MakeEmpty();
}
bool
DriverSpecificSettings::HasString(const char* key) const
{
const char* value;
return fSettings.FindString(key, &value) == B_OK;
}
const char*
DriverSpecificSettings::GetString(const char* key) const
{
ASSERT(HasString(key));
const char* value = NULL;
fSettings.FindString(key, &value);
return value;
}
void
DriverSpecificSettings::SetString(const char* key, const char* value)
{
if (HasString(key))
fSettings.ReplaceString(key, value);
else
fSettings.AddString(key, value);
}
bool
DriverSpecificSettings::HasBoolean(const char* key) const
{
bool value;
return fSettings.FindBool(key, &value) == B_OK;
}
bool
DriverSpecificSettings::GetBoolean(const char* key) const
{
ASSERT(HasBoolean(key));
bool value;
fSettings.FindBool(key, &value);
return value;
}
void
DriverSpecificSettings::SetBoolean(const char* key, bool value)
{
if (HasBoolean(key))
fSettings.ReplaceBool(key, value);
else
fSettings.AddBool(key, value);
}
bool
DriverSpecificSettings::HasInt(const char* key) const
{
int32 value;
return fSettings.FindInt32(key, &value) == B_OK;
}
int32
DriverSpecificSettings::GetInt(const char* key) const
{
ASSERT(HasInt(key));
int32 value;
fSettings.FindInt32(key, &value);
return value;
}
void
DriverSpecificSettings::SetInt(const char* key, int32 value)
{
if (HasInt(key))
fSettings.ReplaceInt32(key, value);
else
fSettings.AddInt32(key, value);
}
bool
DriverSpecificSettings::HasDouble(const char* key) const
{
double value;
return fSettings.FindDouble(key, &value) == B_OK;
}
double
DriverSpecificSettings::GetDouble(const char* key) const
{
ASSERT(HasDouble(key));
double value;
fSettings.FindDouble(key, &value);
return value;
}
void
DriverSpecificSettings::SetDouble(const char* key, double value)
{
if (HasDouble(key))
fSettings.ReplaceDouble(key, value);
else
fSettings.AddDouble(key, value);
}
BMessage&
DriverSpecificSettings::Message()
{
return fSettings;
}
JobData::JobData(BMessage *message, const PrinterCap *printerCap, SettingType settingType)
{
Load(message, printerCap, settingType);
}
JobData::~JobData()
{
}
JobData::JobData(const JobData &jobData)
{
*this = jobData;
}
JobData&
JobData::operator=(const JobData &jobData)
{
fShowPreview = jobData.fShowPreview;
fPaper = jobData.fPaper;
fResolutionID = jobData.fResolutionID;
fXRes = jobData.fXRes;
fYRes = jobData.fYRes;
fOrientation = jobData.fOrientation;
fScaling = jobData.fScaling;
fPaperRect = jobData.fPaperRect;
fScaledPaperRect = jobData.fScaledPaperRect;
fPrintableRect = jobData.fPrintableRect;
fScaledPrintableRect = jobData.fScaledPrintableRect;
fNup = jobData.fNup;
fFirstPage = jobData.fFirstPage;
fLastPage = jobData.fLastPage;
fGamma = jobData.fGamma;
fInkDensity = jobData.fInkDensity;
fPaperSource = jobData.fPaperSource;
fCopies = jobData.fCopies;
fCollate = jobData.fCollate;
fReverse = jobData.fReverse;
fPrintStyle = jobData.fPrintStyle;
fBindingLocation = jobData.fBindingLocation;
fPageOrder = jobData.fPageOrder;
fSettingType = jobData.fSettingType;
fMsg = jobData.fMsg;
fColor = jobData.fColor;
fDitherType = jobData.fDitherType;
fPageSelection = jobData.fPageSelection;
fMarginUnit = jobData.fMarginUnit;
fPhysicalRect = jobData.fPhysicalRect;
fScaledPhysicalRect = jobData.fScaledPhysicalRect;
fDriverSpecificSettings = jobData.fDriverSpecificSettings;
return *this;
}
void
JobData::Load(BMessage* message, const PrinterCap* printerCap,
SettingType settingType)
{
fMsg = message;
fSettingType = settingType;
const PaperCap *paperCap = NULL;
if (message->HasBool(kJDShowPreview))
fShowPreview = message->FindBool(kJDShowPreview);
else
fShowPreview = false;
if (message->HasInt32(kJDPaper))
fPaper = (Paper)message->FindInt32(kJDPaper);
else if (printerCap->Supports(PrinterCap::kPaper)) {
paperCap = (const PaperCap *)printerCap->GetDefaultCap(
PrinterCap::kPaper);
fPaper = paperCap->fPaper;
} else
fPaper = kA4;
if (message->HasInt32(kJDResolution)) {
message->FindInt32(kJDResolution, &fResolutionID);
} else if (printerCap->Supports(PrinterCap::kResolution)) {
fResolutionID = printerCap->GetDefaultCap(PrinterCap::kResolution)
->ID();
} else {
fResolutionID = 0;
}
if (message->HasInt64(kJDXRes)) {
int64 xres64;
message->FindInt64(kJDXRes, &xres64);
fXRes = xres64;
} else if (printerCap->Supports(PrinterCap::kResolution)) {
fXRes = ((const ResolutionCap *)printerCap->GetDefaultCap(
PrinterCap::kResolution))->fXResolution;
} else {
fXRes = 300;
}
if (message->HasInt64(kJDYRes)) {
int64 yres64;
message->FindInt64(kJDYRes, &yres64);
fYRes = yres64;
} else if (printerCap->Supports(PrinterCap::kResolution)) {
fYRes = ((const ResolutionCap *)printerCap->GetDefaultCap(
PrinterCap::kResolution))->fYResolution;
} else {
fYRes = 300;
}
if (message->HasInt32(kJDOrientation))
fOrientation = (Orientation)message->FindInt32(kJDOrientation);
else if (printerCap->Supports(PrinterCap::kOrientation))
fOrientation = ((const OrientationCap *)printerCap->GetDefaultCap(
PrinterCap::kOrientation))->fOrientation;
else
fOrientation = kPortrait;
if (message->HasFloat(kJDScaling))
fScaling = message->FindFloat(kJDScaling);
else
fScaling = 100.0f;
if (message->HasRect(kJDPaperRect)) {
fPaperRect = message->FindRect(kJDPaperRect);
} else if (paperCap != NULL) {
fPaperRect = paperCap->fPaperRect;
}
if (message->HasRect(kJDScaledPaperRect)) {
fScaledPaperRect = message->FindRect(kJDScaledPaperRect);
} else {
fScaledPaperRect = fPaperRect;
}
if (message->HasRect(kJDPrintableRect)) {
fPrintableRect = message->FindRect(kJDPrintableRect);
} else if (paperCap != NULL) {
fPrintableRect = paperCap->fPhysicalRect;
}
if (message->HasRect(kJDScaledPrintableRect)) {
fScaledPrintableRect = message->FindRect(kJDScaledPrintableRect);
} else {
fScaledPrintableRect = fPrintableRect;
}
if (message->HasRect(kJDPhysicalRect)) {
fPhysicalRect = message->FindRect(kJDPhysicalRect);
} else if (paperCap != NULL) {
fPhysicalRect = paperCap->fPhysicalRect;
}
if (message->HasRect(kJDScaledPhysicalRect)) {
fScaledPhysicalRect = message->FindRect(kJDScaledPhysicalRect);
} else {
fScaledPhysicalRect = fPhysicalRect;
}
if (message->HasInt32(kJDFirstPage))
fFirstPage = message->FindInt32(kJDFirstPage);
else
fFirstPage = 1;
if (message->HasInt32(kJDLastPage))
fLastPage = message->FindInt32(kJDLastPage);
else
fLastPage = -1;
if (message->HasInt32(kJDNup))
fNup = message->FindInt32(kJDNup);
else
fNup = 1;
if (message->HasFloat(kJDGamma))
fGamma = fMsg->FindFloat(kJDGamma);
else
fGamma = 0.25f;
if (message->HasFloat(kJDInkDensity))
fInkDensity = fMsg->FindFloat(kJDInkDensity);
else
fInkDensity = 0.0f;
if (message->HasInt32(kJDPaperSource))
fPaperSource = (PaperSource)fMsg->FindInt32(kJDPaperSource);
else if (printerCap->Supports(PrinterCap::kPaperSource))
fPaperSource = ((const PaperSourceCap *)printerCap->GetDefaultCap(
PrinterCap::kPaperSource))->fPaperSource;
else
fPaperSource = kAuto;
if (message->HasInt32(kJDCopies))
fCopies = message->FindInt32(kJDCopies);
else
fCopies = 1;
if (message->HasBool(kJDCollate))
fCollate = message->FindBool(kJDCollate);
else
fCollate = false;
if (message->HasBool(kJDReverse))
fReverse = message->FindBool(kJDReverse);
else
fReverse = false;
if (message->HasInt32(kJDPrintStyle))
fPrintStyle = (PrintStyle)message->FindInt32(kJDPrintStyle);
else if (printerCap->Supports(PrinterCap::kPrintStyle))
fPrintStyle = ((const PrintStyleCap *)printerCap->GetDefaultCap(
PrinterCap::kPrintStyle))->fPrintStyle;
else
fPrintStyle = kSimplex;
if (message->HasInt32(kJDBindingLocation))
fBindingLocation = (BindingLocation)message->FindInt32(
kJDBindingLocation);
else if (printerCap->Supports(PrinterCap::kBindingLocation))
fBindingLocation = ((const BindingLocationCap *)printerCap->
GetDefaultCap(PrinterCap::kBindingLocation))->fBindingLocation;
else
fBindingLocation = kLongEdgeLeft;
if (message->HasInt32(kJDPageOrder))
fPageOrder = (PageOrder)message->FindInt32(kJDPageOrder);
else
fPageOrder = kAcrossFromLeft;
if (message->HasInt32(kJDColor))
fColor = (Color)message->FindInt32(kJDColor);
else if (printerCap->Supports(PrinterCap::kColor))
fColor = ((const ColorCap *)printerCap->GetDefaultCap(
PrinterCap::kColor))->fColor;
else
fColor = kMonochrome;
if (message->HasInt32(kJDDitherType))
fDitherType = (Halftone::DitherType)message->FindInt32(kJDDitherType);
else
fDitherType = Halftone::kTypeFloydSteinberg;
if (message->HasInt32(kJDPageSelection))
fPageSelection = (PageSelection)message->FindInt32(kJDPageSelection);
else
fPageSelection = kAllPages;
if (message->HasInt32(kJDMarginUnit))
fMarginUnit = (MarginUnit)message->FindInt32(kJDMarginUnit);
else
fMarginUnit = kUnitInch;
if (message->HasMessage(kJDDriverSpecificSettings))
message->FindMessage(kJDDriverSpecificSettings,
&fDriverSpecificSettings.Message());
}
void
JobData::Save(BMessage* message)
{
if (message == NULL) {
message = fMsg;
}
message->RemoveName(kJDPaper);
message->AddInt32(kJDPaper, fPaper);
message->RemoveName(kJDResolution);
message->AddInt32(kJDResolution, fResolutionID);
message->RemoveName(kJDXRes);
message->AddInt64(kJDXRes, fXRes);
message->RemoveName(kJDYRes);
message->AddInt64(kJDYRes, fYRes);
message->RemoveName(kJDOrientation);
message->AddInt32(kJDOrientation, fOrientation);
message->RemoveName(kJDScaling);
message->AddFloat(kJDScaling, fScaling);
message->RemoveName(kJDPaperRect);
message->AddRect(kJDPaperRect, fPaperRect);
message->RemoveName(kJDScaledPaperRect);
message->AddRect(kJDScaledPaperRect, fScaledPaperRect);
message->RemoveName(kJDPrintableRect);
message->AddRect(kJDPrintableRect, fPrintableRect);
message->RemoveName(kJDScaledPrintableRect);
message->AddRect(kJDScaledPrintableRect, fScaledPrintableRect);
message->RemoveName(kJDPhysicalRect);
message->AddRect(kJDPhysicalRect, fPhysicalRect);
message->RemoveName(kJDScaledPhysicalRect);
message->AddRect(kJDScaledPhysicalRect, fScaledPhysicalRect);
message->RemoveName(kJDMarginUnit);
message->AddInt32(kJDMarginUnit, fMarginUnit);
message->RemoveName(kJDShowPreview);
if (fSettingType == kJobSettings)
message->AddBool(kJDShowPreview, fShowPreview);
message->RemoveName(kJDNup);
if (fSettingType == kJobSettings)
message->AddInt32(kJDNup, fNup);
message->RemoveName(kJDFirstPage);
if (fSettingType == kJobSettings)
message->AddInt32(kJDFirstPage, fFirstPage);
message->RemoveName(kJDLastPage);
if (fSettingType == kJobSettings)
message->AddInt32(kJDLastPage, fLastPage);
message->RemoveName(kJDGamma);
if (fSettingType == kJobSettings)
message->AddFloat(kJDGamma, fGamma);
message->RemoveName(kJDInkDensity);
if (fSettingType == kJobSettings)
message->AddFloat(kJDInkDensity, fInkDensity);
message->RemoveName(kJDPaperSource);
if (fSettingType == kJobSettings)
message->AddInt32(kJDPaperSource, fPaperSource);
message->RemoveName(kJDCopies);
if (fSettingType == kJobSettings)
message->AddInt32(kJDCopies, fCopies);
message->RemoveName(kJDCollate);
if (fSettingType == kJobSettings)
message->AddBool(kJDCollate, fCollate);
message->RemoveName(kJDReverse);
if (fSettingType == kJobSettings)
message->AddBool(kJDReverse, fReverse);
message->RemoveName(kJDPrintStyle);
if (fSettingType == kJobSettings)
message->AddInt32(kJDPrintStyle, fPrintStyle);
message->RemoveName(kJDBindingLocation);
if (fSettingType == kJobSettings)
message->AddInt32(kJDBindingLocation, fBindingLocation);
message->RemoveName(kJDPageOrder);
if (fSettingType == kJobSettings)
message->AddInt32(kJDPageOrder, fPageOrder);
message->RemoveName(kJDColor);
if (fSettingType == kJobSettings)
message->AddInt32(kJDColor, fColor);
message->RemoveName(kJDDitherType);
if (fSettingType == kJobSettings)
message->AddInt32(kJDDitherType, fDitherType);
message->RemoveName(kJDPageSelection);
if (fSettingType == kJobSettings)
message->AddInt32(kJDPageSelection, fPageSelection);
message->RemoveName(kJDDriverSpecificSettings);
if (fSettingType == kJobSettings)
{
message->AddMessage(kJDDriverSpecificSettings,
&fDriverSpecificSettings.Message());
}
}
DriverSpecificSettings&
JobData::Settings()
{
return fDriverSpecificSettings;
}
const DriverSpecificSettings&
JobData::Settings() const
{
return fDriverSpecificSettings;
}
