diff --git a/src/add-ons/print/drivers/pcl6/Jamfile b/src/add-ons/print/drivers/pcl6/Jamfile index e1b9319431..2a4f0bc0d0 100644 --- a/src/add-ons/print/drivers/pcl6/Jamfile +++ b/src/add-ons/print/drivers/pcl6/Jamfile @@ -9,7 +9,7 @@ Addon PCL6\ Compatible : Print : PCL6Entry.cpp PCL6.cpp PCL6Cap.cpp - jetlib.cpp + PCL6Writer.cpp ; ObjectC++Flags [ FGristFiles jetlib.o ] : -w ; diff --git a/src/add-ons/print/drivers/pcl6/PCL6.cpp b/src/add-ons/print/drivers/pcl6/PCL6.cpp index 758af29cd8..48bccbb7e1 100644 --- a/src/add-ons/print/drivers/pcl6/PCL6.cpp +++ b/src/add-ons/print/drivers/pcl6/PCL6.cpp @@ -34,42 +34,41 @@ using namespace std; #define ENABLE_RLE_COMPRESSION 0 // Delta Row Compression -#define ENABLE_DELTA_ROW_COMPRESSION 1 +#define ENABLE_DELTA_ROW_COMPRESSION 0 // DeltaRowStreamCompressor writes the delta row directly to the // in the contructor specified stream. class DeltaRowStreamCompressor : public AbstractDeltaRowCompressor { public: - DeltaRowStreamCompressor(int rowSize, uchar initialSeed, HP_StreamHandleType stream) + DeltaRowStreamCompressor(int rowSize, uchar initialSeed, PCL6Writer *writer) : AbstractDeltaRowCompressor(rowSize, initialSeed) - , fStream(stream) + , fWriter(writer) { // nothing to do } protected: void AppendByteToDeltaRow(uchar byte) { - HP_RawUByte(fStream, byte); + fWriter->Append(byte); } private: - HP_StreamHandleType fStream; + PCL6Writer *fWriter; }; PCL6Driver::PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap) : GraphicsDriver(msg, printer_data, printer_cap) { fHalftone = NULL; - fStream = NULL; + fWriter = NULL; } -void PCL6Driver::FlushOutBuffer(HP_StreamHandleType pStream, unsigned long cookie, HP_pUByte pOutBuffer, HP_SInt32 currentBufferLen) +void PCL6Driver::writeData(const uint8 *data, uint32 size) { - writeSpoolData(pOutBuffer, currentBufferLen); + writeSpoolData(data, size); } - bool PCL6Driver::startDoc() { try { @@ -252,12 +251,12 @@ bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset) void PCL6Driver::writeBitmap(const uchar* buffer, int outSize, int rowSize, int x, int y, int width, int height, int deltaRowSize) { // choose the best compression method - int compressionMethod = HP_eNoCompression; + PCL6Writer::Compression compressionMethod = PCL6Writer::kNoCompression; int dataSize = outSize; #if ENABLE_DELTA_ROW_COMPRESSION if (deltaRowSize < dataSize) { - compressionMethod = HP_eDeltaRowCompression; + compressionMethod = PCL6Writer::kDeltaRowCompression; dataSize = deltaRowSize; } #endif @@ -266,7 +265,7 @@ void PCL6Driver::writeBitmap(const uchar* buffer, int outSize, int rowSize, int HP_UInt32 compressedSize = 0; HP_M2TIFF_CalcCompression((HP_pCharHuge)buffer, outSize, &compressedSize); if (compressedSize < (uint32)dataSize) { - compressionMethod = HP_eRLECompression; + compressionMethod = PCL6Writer::kRLECompression; dataSize = compressedSize; } #endif @@ -303,29 +302,31 @@ void PCL6Driver::jobStart() "Comment Copyright (c) 2003, 2004 Haiku\n", getJobData()->getXres()); // PCL6 begin - fStream = HP_NewStream(16 * 1024, this); - HP_BeginSession_2(fStream, getJobData()->getXres(), getJobData()->getYres(), HP_eInch, HP_eBackChAndErrPage); - HP_OpenDataSource_1(fStream, HP_eDefaultDataSource, HP_eBinaryLowByteFirst); - fMediaSide = HP_eFrontMediaSide; + fWriter = new PCL6Writer(this); + fWriter->BeginSession(getJobData()->getXres(), getJobData()->getYres(), PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage); + fWriter->OpenDataSource(); + fMediaSide = PCL6Writer::kFrontMediaSide; } bool PCL6Driver::startPage(int) { - HP_UByte orientation = HP_ePortraitOrientation; + PCL6Writer::Orientation orientation = PCL6Writer::kPortrait; if (getJobData()->getOrientation() == JobData::kLandscape) { - orientation = HP_eLandscapeOrientation; + orientation = PCL6Writer::kLandscape; } - HP_UByte mediaSize = PCL6Driver::mediaSize(getJobData()->getPaper()); + PCL6Writer::MediaSize mediaSize = PCL6Driver::mediaSize(getJobData()->getPaper()); + PCL6Writer::MediaSource mediaSource = PCL6Driver::mediaSource(getJobData()->getPaperSource()); if (getJobData()->getPrintStyle() == JobData::kSimplex) { - HP_BeginPage_3(fStream, orientation, mediaSize, PCL6Driver::mediaSource(getJobData()->getPaperSource())); + fWriter->BeginPage(orientation, mediaSize, mediaSource); } else if (getJobData()->getPrintStyle() == JobData::kDuplex) { - HP_BeginPage_5(fStream, orientation, mediaSize, HP_DuplexPageMode, fMediaSide); + fWriter->BeginPage(orientation, mediaSize, mediaSource, + PCL6Writer::kDuplexHorizontalBinding, fMediaSide); - if (fMediaSide == HP_eFrontMediaSide) { - fMediaSide = HP_eBackMediaSide; + if (fMediaSide == PCL6Writer::kFrontMediaSide) { + fMediaSide = PCL6Writer::kBackMediaSide; } else { - fMediaSide = HP_eFrontMediaSide; + fMediaSide = PCL6Writer::kFrontMediaSide; } } else { return false; @@ -335,24 +336,24 @@ bool PCL6Driver::startPage(int) int x = 142 * getJobData()->getXres() / 600; int y = 100 * getJobData()->getYres() / 600; bool color = getJobData()->getColor() == JobData::kColor; - HP_SetPageOrigin_1(fStream, x, y); - HP_SetColorSpace_1(fStream, color ? HP_eRGB : HP_eGray); - HP_SetPaintTxMode_1(fStream, HP_eOpaque); - HP_SetSourceTxMode_1(fStream, HP_eOpaque); - HP_SetROP_1(fStream, 204); + fWriter->SetPageOrigin(x, y); + fWriter->SetColorSpace(color ? PCL6Writer::kRGB : PCL6Writer::kGray); + fWriter->SetPaintTxMode(PCL6Writer::kOpaque); + fWriter->SetSourceTxMode(PCL6Writer::kOpaque); + fWriter->SetROP(204); return true; } -void PCL6Driver::startRasterGraphics(int x, int y, int width, int height, int compressionMethod) +void PCL6Driver::startRasterGraphics(int x, int y, int width, int height, PCL6Writer::Compression compressionMethod) { bool color = getJobData()->getColor() == JobData::kColor; - HP_BeginImage_1(fStream, HP_eDirectPixel, color ? HP_e8Bit : HP_e1Bit, width, height, width, height); - HP_ReadImage_1(fStream, 0, height, compressionMethod); + fWriter->BeginImage(PCL6Writer::kDirectPixel, color ? PCL6Writer::k8Bit : PCL6Writer::k1Bit, width, height, width, height); + fWriter->ReadImage(compressionMethod, 0, height); } void PCL6Driver::endRasterGraphics() { - HP_EndImage_1(fStream); + fWriter->EndImage(); } void PCL6Driver::rasterGraphics( @@ -365,25 +366,26 @@ void PCL6Driver::rasterGraphics( ) { // write bitmap byte size - HP_EmbeddedDataPrefix32(fStream, dataSize); + fWriter->EmbeddedDataPrefix32(dataSize); // write data - if (compressionMethod == HP_eRLECompression) { + if (compressionMethod == PCL6Writer::kRLECompression) { // use RLE compression - HP_UInt32 compressedSize = 0; - HP_M2TIFF_Compress(fStream, 0, (HP_pCharHuge)buffer, bufferSize, &compressedSize); - } else if (compressionMethod == HP_eDeltaRowCompression) { + // uint32 compressedSize = 0; + // HP_M2TIFF_Compress(fStream, 0, (HP_pCharHuge)buffer, bufferSize, &compressedSize); + return; + } else if (compressionMethod == PCL6Writer::kDeltaRowCompression) { // use delta row compression - DeltaRowStreamCompressor compressor(rowSize, 0, fStream); + DeltaRowStreamCompressor compressor(rowSize, 0, fWriter); if (compressor.InitCheck() != B_OK) { return; } - const uchar* row = buffer; + const uint8* row = buffer; for (int i = 0; i < height; i ++) { // write row byte count - int size = compressor.CalculateSize(row); - HP_RawUInt16(fStream, size); + int32 size = compressor.CalculateSize(row); + fWriter->Append((uint16)size); if (size > 0) { // write delta row @@ -394,14 +396,14 @@ void PCL6Driver::rasterGraphics( } } else { // write raw data - HP_RawUByteArray(fStream, (uchar*)buffer, bufferSize); + fWriter->Append(buffer, bufferSize); } } bool PCL6Driver::endPage(int) { try { - HP_EndPage_2(fStream, getJobData()->getCopies()); + fWriter->EndPage(getJobData()->getCopies()); return true; } catch (TransportException &err) { @@ -411,9 +413,11 @@ bool PCL6Driver::endPage(int) void PCL6Driver::jobEnd() { - HP_CloseDataSource_1(fStream); - HP_EndSession_1(fStream); - HP_FinishStream(fStream); + fWriter->CloseDataSource(); + fWriter->EndSession(); + fWriter->Flush(); + delete fWriter; + fWriter = NULL; // PJL footer writeSpoolString("\033%%-12345X@PJL EOJ\n" "\033%%-12345X"); @@ -421,55 +425,55 @@ void PCL6Driver::jobEnd() void PCL6Driver::move(int x, int y) { - HP_SetCursor_1(fStream, x, y); + fWriter->SetCursor(x, y); } -HP_UByte PCL6Driver::mediaSize(JobData::Paper paper) +PCL6Writer::MediaSize PCL6Driver::mediaSize(JobData::Paper paper) { switch (paper) { - case JobData::kLetter: return HP_eLetterPaper; - case JobData::kLegal: return HP_eLegalPaper; - case JobData::kA4: return HP_eA4Paper; - case JobData::kExecutive: return HP_eExecPaper; - case JobData::kLedger: return HP_eLedgerPaper; - case JobData::kA3: return HP_eA3Paper; + case JobData::kLetter: return PCL6Writer::kLetterPaper; + case JobData::kLegal: return PCL6Writer::kLegalPaper; + case JobData::kA4: return PCL6Writer::kA4Paper; + case JobData::kExecutive: return PCL6Writer::kExecPaper; + case JobData::kLedger: return PCL6Writer::kLedgerPaper; + case JobData::kA3: return PCL6Writer::kA3Paper; /* - case : return HP_eCOM10Envelope; - case : return HP_eMonarchEnvelope; - case : return HP_eC5Envelope; - case : return HP_eDLEnvelope; - case : return HP_eJB4Paper; - case : return HP_eJB5Paper; - case : return HP_eB5Envelope; - case : return HP_eB5Paper; - case : return HP_eJPostcard; - case : return HP_eJDoublePostcard; - case : return HP_eA5Paper; - case : return HP_eA6Paper; - case : return HP_eJB6Paper; - case : return HP_eJIS8KPaper; - case : return HP_eJIS16KPaper; - case : return HP_eJISExecPaper; + case : return PCL6Writer::kCOM10Envelope; + case : return PCL6Writer::kMonarchEnvelope; + case : return PCL6Writer::kC5Envelope; + case : return PCL6Writer::kDLEnvelope; + case : return PCL6Writer::kJB4Paper; + case : return PCL6Writer::kJB5Paper; + case : return PCL6Writer::kB5Envelope; + case : return PCL6Writer::kB5Paper; + case : return PCL6Writer::kJPostcard; + case : return PCL6Writer::kJDoublePostcard; + case : return PCL6Writer::kA5Paper; + case : return PCL6Writer::kA6Paper; + case : return PCL6Writer::kJB6Paper; + case : return PCL6Writer::kJIS8KPaper; + case : return PCL6Writer::kJIS16KPaper; + case : return PCL6Writer::kJISExecPaper; */ default: - return HP_eLegalPaper; + return PCL6Writer::kLegalPaper; } } -HP_UByte PCL6Driver::mediaSource(JobData::PaperSource source) +PCL6Writer::MediaSource PCL6Driver::mediaSource(JobData::PaperSource source) { switch (source) { - case JobData::kAuto: return HP_eAutoSelect; - case JobData::kCassette1: return HP_eDefaultSource; - case JobData::kCassette2: return HP_eEnvelopeTray; - case JobData::kLower: return HP_eLowerCassette; - case JobData::kUpper: return HP_eUpperCassette; - case JobData::kMiddle: return HP_eThirdCassette; - case JobData::kManual: return HP_eManualFeed; - case JobData::kCassette3: return HP_eMultiPurposeTray; + case JobData::kAuto: return PCL6Writer::kAutoSelect; + case JobData::kCassette1: return PCL6Writer::kDefaultSource; + case JobData::kCassette2: return PCL6Writer::kEnvelopeTray; + case JobData::kLower: return PCL6Writer::kLowerCassette; + case JobData::kUpper: return PCL6Writer::kUpperCassette; + case JobData::kMiddle: return PCL6Writer::kThirdCassette; + case JobData::kManual: return PCL6Writer::kManualFeed; + case JobData::kCassette3: return PCL6Writer::kMultiPurposeTray; default: - return HP_eAutoSelect; + return PCL6Writer::kAutoSelect; } } diff --git a/src/add-ons/print/drivers/pcl6/PCL6.h b/src/add-ons/print/drivers/pcl6/PCL6.h index 6a1b14c4e3..7b518e1bb2 100644 --- a/src/add-ons/print/drivers/pcl6/PCL6.h +++ b/src/add-ons/print/drivers/pcl6/PCL6.h @@ -7,19 +7,18 @@ #ifndef __PCL6_H #define __PCL6_H + #include "GraphicsDriver.h" -#include "jetlib.h" +#include "PCL6Writer.h" class Halftone; -class PCL6Driver : public GraphicsDriver, private MJetlibClient { +class PCL6Driver : public GraphicsDriver +{ public: PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap); - virtual void FlushOutBuffer(HP_StreamHandleType pStream, - unsigned long cookie, - HP_pUByte pOutBuffer, - HP_SInt32 currentBufferLen); + void writeData(const uint8 *data, uint32 size); protected: virtual bool startDoc(); @@ -29,12 +28,12 @@ protected: virtual bool endDoc(bool success); private: - HP_UByte mediaSize(JobData::Paper paper); - HP_UByte mediaSource(JobData::PaperSource source); + PCL6Writer::MediaSize mediaSize(JobData::Paper paper); + PCL6Writer::MediaSource mediaSource(JobData::PaperSource source); void move(int x, int y); void jobStart(); void writeBitmap(const uchar* buffer, int outSize, int rowSize, int x, int y, int width, int height, int deltaRowSize); - void startRasterGraphics(int x, int y, int width, int height, int compressionMethod); + void startRasterGraphics(int x, int y, int width, int height, PCL6Writer::Compression compressionMethod); void endRasterGraphics(); void rasterGraphics( const uchar *buffer, @@ -45,9 +44,9 @@ private: int compression_method); void jobEnd(); - HP_StreamHandleType fStream; - Halftone *fHalftone; - HP_UByte fMediaSide; // side if in duplex mode + PCL6Writer *fWriter; + PCL6Writer::MediaSide fMediaSide; // side if in duplex mode + Halftone *fHalftone; }; #endif /* __PCL6_H */ diff --git a/src/add-ons/print/drivers/pcl6/PCL6Cap.cpp b/src/add-ons/print/drivers/pcl6/PCL6Cap.cpp index 3c7bd2779d..b7f67d0713 100644 --- a/src/add-ons/print/drivers/pcl6/PCL6Cap.cpp +++ b/src/add-ons/print/drivers/pcl6/PCL6Cap.cpp @@ -73,6 +73,7 @@ const PaperSourceCap thridCassette("Thrid Cassette", false, JobData::kMiddle); const PaperSourceCap manualFeed("Manual Feed", false, JobData::kManual); const PaperSourceCap multiPurposeTray("Multi Purpose Tray", false, JobData::kCassette3); +const ResolutionCap dpi150("150dpi", true, 150, 150); const ResolutionCap dpi300("300dpi", true, 300, 300); const ResolutionCap dpi600("600dpi", false, 600, 600); const ResolutionCap dpi1200("1200dpi", false, 1200, 1200); @@ -87,7 +88,8 @@ const PaperCap *papers[] = { &b4, &b5, &letter, - &legal + &legal, + &japanese_postcard }; const PaperSourceCap *papersources[] = { @@ -102,6 +104,7 @@ const PaperSourceCap *papersources[] = { }; const ResolutionCap *resolutions[] = { + &dpi150, &dpi300, &dpi600, &dpi1200, diff --git a/src/add-ons/print/drivers/pcl6/PCL6Writer.cpp b/src/add-ons/print/drivers/pcl6/PCL6Writer.cpp new file mode 100644 index 0000000000..27a47d6da0 --- /dev/null +++ b/src/add-ons/print/drivers/pcl6/PCL6Writer.cpp @@ -0,0 +1,336 @@ +/* +** PCL6Writer.cpp +** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net. All rights reserved. +** Distributed under the terms of the OpenBeOS License. +*/ +#include "PCL6Writer.h" +#include "PCL6.h" + +#include + +#define BYTE_AT(lvalue, index) (((uint8*)(&lvalue))[index]) + +PCL6Writer::PCL6Writer(PCL6Driver *driver, uint32 bufferSize) + : fDriver(driver), + fBuffer(new uint8[bufferSize]), + fSize(bufferSize), + fIndex(0) +{ +} + +PCL6Writer::~PCL6Writer() { + delete fBuffer; + fBuffer = NULL; +} + +// throws TransportException +void PCL6Writer::Append(uint8 value) { + if (fIndex == fSize) { + Flush(); + } + fBuffer[fIndex] = value; + fIndex ++; +} + +void PCL6Writer::Flush() { + if (fIndex > 0) { + fDriver->writeData(fBuffer, fIndex); + fIndex = 0; + } +} + +void PCL6Writer::Append(int16 value) { + int16 v = B_HOST_TO_LENDIAN_INT16(value); + Append(BYTE_AT(v, 0)); + Append(BYTE_AT(v, 1)); +} + +void PCL6Writer::Append(uint16 value) { + int16 v = B_HOST_TO_LENDIAN_INT16(value); + Append(BYTE_AT(v, 0)); + Append(BYTE_AT(v, 1)); +} + +void PCL6Writer::Append(int32 value) { + int32 v = B_HOST_TO_LENDIAN_INT32(value); + Append(BYTE_AT(v, 0)); + Append(BYTE_AT(v, 1)); + Append(BYTE_AT(v, 2)); + Append(BYTE_AT(v, 3)); +} + +void PCL6Writer::Append(uint32 value) { + int32 v = B_HOST_TO_LENDIAN_INT32(value); + Append(BYTE_AT(v, 0)); + Append(BYTE_AT(v, 1)); + Append(BYTE_AT(v, 2)); + Append(BYTE_AT(v, 3)); +} + +void PCL6Writer::Append(float value) { + float v = B_HOST_TO_LENDIAN_FLOAT(value); + Append(BYTE_AT(v, 0)); + Append(BYTE_AT(v, 1)); + Append(BYTE_AT(v, 2)); + Append(BYTE_AT(v, 3)); +} + +void PCL6Writer::Append(const uint8* data, uint32 size) { + for (uint32 i = 0; i < size; i++) { + Append(data[i]); + } +} + +void PCL6Writer::AppendOperator(Operator op) { + Append((uint8)op); +} + +void PCL6Writer::AppendAttribute(Attribute attr) { + AppendDataTag(k8BitAttrId); + Append((uint8)attr); +} + +void PCL6Writer::AppendDataTag(DataTag tag) { + Append((uint8)tag); +} + +void PCL6Writer::AppendData(uint8 value) { + AppendDataTag(kUByteData); + Append(value); +} + +void PCL6Writer::AppendData(int16 value) { + AppendDataTag(kSInt16Data); + Append(value); +} + +void PCL6Writer::AppendData(uint16 value) { + AppendDataTag(kUInt16Data); + Append(value); +} + +void PCL6Writer::AppendData(int32 value) { + AppendDataTag(kSInt32Data); + Append(value); +} + +void PCL6Writer::AppendData(uint32 value) { + AppendDataTag(kUInt32Data); + Append(value); +} + +void PCL6Writer::AppendData(float value) { + AppendDataTag(kReal32Data); + Append(value); +} + +void PCL6Writer::EmbeddedDataPrefix(uint32 size) { + if (size < 256) { + AppendDataTag(kEmbeddedDataByte); + Append((uint8)size); + } else { + AppendDataTag(kEmbeddedData); + Append(size); + } +} + +void PCL6Writer::EmbeddedDataPrefix32(uint32 size) { + AppendDataTag(kEmbeddedData); + Append(size); +} + +void PCL6Writer::AppendDataXY(uint8 x, uint8 y) { + AppendDataTag(kUByteXY); + Append(x); Append(y); +} + +void PCL6Writer::AppendDataXY(int16 x, int16 y) { + AppendDataTag(kSInt16XY); + Append(x); Append(y); +} + +void PCL6Writer::AppendDataXY(uint16 x, uint16 y) { + AppendDataTag(kUInt16XY); + Append(x); Append(y); +} + +void PCL6Writer::AppendDataXY(int32 x, int32 y) { + AppendDataTag(kSInt32XY); + Append(x); Append(y); +} + +void PCL6Writer::AppendDataXY(uint32 x, uint32 y) { + AppendDataTag(kUInt32XY); + Append(x); Append(y); +} + +void PCL6Writer::AppendDataXY(float x, float y) { + AppendDataTag(kReal32XY); + Append(x); Append(y); +} + + + +void PCL6Writer::BeginSession(uint16 xres, uint16 yres, UnitOfMeasure unitOfMeasure, ErrorReporting errorReporting) { + AppendDataXY(xres, yres); + AppendAttribute(kUnitsPerMeasure); + + AppendData((uint8)unitOfMeasure); + AppendAttribute(kMeasure); + + AppendData((uint8)errorReporting); + AppendAttribute(kErrorReport); + + AppendOperator(kBeginSession); +} + +void PCL6Writer::EndSession() { + AppendOperator(kEndSession); +} + +void PCL6Writer::OpenDataSource() { + AppendData((uint8)kDefaultDataSource); + AppendAttribute(kSourceType); + + AppendData((uint8)kBinaryLowByteFirst); + AppendAttribute(kDataOrg); + + AppendOperator(kOpenDataSource); +} + +void PCL6Writer::CloseDataSource() { + AppendOperator(kCloseDataSource); +} + + +void PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource) { + AppendData((uint8)orientation); + AppendAttribute(kOrientation); + + AppendData((uint8)mediaSize); + AppendAttribute(kMediaSize); + + AppendData((uint8)mediaSource); + AppendAttribute(kMediaSource); + + AppendOperator(kBeginPage); +} + +void PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource, DuplexPageMode duplexPageMode, MediaSide mediaSide) { + AppendData((uint8)orientation); + AppendAttribute(kOrientation); + + AppendData((uint8)mediaSize); + AppendAttribute(kMediaSize); + + AppendData((uint8)mediaSource); + AppendAttribute(kMediaSource); + + AppendData((uint8)duplexPageMode); + AppendAttribute(kDuplexPageMode); + + AppendData((uint8)mediaSide); + AppendAttribute(kDuplexPageSide); + + AppendOperator(kBeginPage); +} + +void PCL6Writer::EndPage(uint16 copies) { +// if (copies != 1) { + AppendData(copies); + AppendAttribute(kPageCopies); +// } + + AppendOperator(kEndPage); +} + + +void PCL6Writer::SetPageOrigin(int16 x, int16 y) { + AppendDataXY(x, y); + AppendAttribute(kPageOrigin); + + AppendOperator(kSetPageOrigin); +} + +void PCL6Writer::SetColorSpace(ColorSpace colorSpace) { + AppendData((uint8)colorSpace); + AppendAttribute(kColorSpace); + + AppendOperator(kSetColorSpace); +} + +void PCL6Writer::SetPaintTxMode(Transparency transparency) { + AppendData((uint8)transparency); + AppendAttribute(kTxMode); + + AppendOperator(kSetPaintTxMode); +} + +void PCL6Writer::SetSourceTxMode(Transparency transparency) { + AppendData((uint8)transparency); + AppendAttribute(kTxMode); + + AppendOperator(kSetSourceTxMode); +} + +void PCL6Writer::SetROP(uint8 rop) { + AppendData((uint8)rop); + AppendAttribute(kROP3); + + AppendOperator(kSetROP); +} + +void PCL6Writer::SetCursor(int16 x, int16 y) { + AppendDataXY(x, y); + AppendAttribute(kPoint); + + AppendOperator(kSetCursor); +} + + +void PCL6Writer::BeginImage(ColorMapping colorMapping, ColorDepth colorDepth, uint16 sourceWidth, uint16 sourceHeight, uint16 destWidth, uint16 destHeight) { + AppendData((uint8)colorMapping); + AppendAttribute(kColorMapping); + + AppendData((uint8)colorDepth); + AppendAttribute(kColorDepth); + + AppendData(sourceWidth); + AppendAttribute(kSourceWidth); + + AppendData(sourceHeight); + AppendAttribute(kSourceHeight); + + AppendDataXY(destWidth, destHeight); + AppendAttribute(kDestinationSize); + + AppendOperator(kBeginImage); +} + +void PCL6Writer::ReadImage(Compression compression, uint16 startLine, uint16 blockHeight, uint8 padBytes) { + AppendData(startLine); + AppendAttribute(kStartLine); + + AppendData(blockHeight); + AppendAttribute(kBlockHeight); + + AppendData((uint8)compression); + AppendAttribute(kCompressMode); + + if (padBytes < 1 || padBytes > 4) { + // XXX throw exception + return; + } + if (padBytes != 4) { + AppendData((uint8)padBytes); + AppendAttribute(kPadBytesMultiple); + } + + AppendOperator(kReadImage); +} + +void PCL6Writer::EndImage() { + AppendOperator(kEndImage); +} + + diff --git a/src/add-ons/print/drivers/pcl6/PCL6Writer.h b/src/add-ons/print/drivers/pcl6/PCL6Writer.h new file mode 100644 index 0000000000..904206bafb --- /dev/null +++ b/src/add-ons/print/drivers/pcl6/PCL6Writer.h @@ -0,0 +1,344 @@ +/* +** PCL6Writer.h +** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net. All rights reserved. +** Distributed under the terms of the OpenBeOS License. +*/ +#ifndef _PCL6_WRITER_H +#define _PCL6_WRITER_H + +#include + +class PCL6Driver; + +class PCL6Writer { +public: + // DO NOT change this enumerations the order is important!!! + enum Orientation { + kPortrait, + kLandscape, + kReversePortrait, + kReverseLandscape + }; + + enum MediaSize { + kLetterPaper, + kLegalPaper, + kA4Paper, + kExecPaper, + kLedgerPaper, + kA3Paper, + kCOM10Envelope, + kMonarchEnvelope, + kC5Envelope, + kDLEnvelope, + kJB4Paper, + kJB5Paper, + kB5Envelope, + kB5Paper, + kJPostcard, + kJDoublePostcard, + kA5Paper, + kA6Paper, + kJB6Paper, + kJIS8KPaper, + kJIS16KPaper, + kJISExecPaper + }; + + enum MediaSource { + kDefaultSource, + kAutoSelect, + kManualFeed, + kMultiPurposeTray, + kUpperCassette, + kLowerCassette, + kEnvelopeTray, + kThirdCassette + }; + + enum Compression { + kNoCompression, + kRLECompression, + kJPEGCompression, + kDeltaRowCompression + }; + + enum ColorSpace { + kBiLevel, + kGray, + kRGB, + kCMY, + kCIELab, + kCRGB, + kSRGB + }; + + enum ColorDepth { + k1Bit, + k4Bit, + k8Bit + }; + + enum ColorMapping { + kDirectPixel, + kIndexedPixel, + kDirectPlane + }; + + enum Transparency { + kOpaque, + kTransparent + }; + + enum DuplexPageMode { + kDuplexHorizontalBinding, + kDuplexVerticalBinding + }; + + enum MediaSide { + kFrontMediaSide, + kBackMediaSide + }; + + enum SimplexPageMode { + kSimplexFrontSide + }; + + enum UnitOfMeasure { + kInch, + kMillimeter, + kTenthsOfAMillimeter + }; + + enum ErrorReporting { + kNoReporting, + kBackChannel, + kErrorPage, + kBackChAndErrPage, + kNWBackChannel, + kNWErrorPage, + kNWBackChAndErrPage + }; + + enum Enable { + kOn, + kOff + }; + + enum Boolean { + kFalse, + kTrue + }; + + PCL6Writer(PCL6Driver* driver, uint32 bufferSize = 16 * 1024); + virtual ~PCL6Writer(); + + // these methods throw TransportException if data could not + // be written + void Flush(); + + void BeginSession(uint16 xres, uint16 yres, UnitOfMeasure unitOfMeasure, ErrorReporting errorReporting); + void EndSession(); + + void OpenDataSource(); + void CloseDataSource(); + + void BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource); + void BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource, DuplexPageMode duplexPageMode, MediaSide mediaSide); + void EndPage(uint16 copies); + + void SetPageOrigin(int16 x, int16 y); + void SetColorSpace(ColorSpace colorSpace); + void SetPaintTxMode(Transparency transparency); + void SetSourceTxMode(Transparency transparency); + void SetROP(uint8 rop); + void SetCursor(int16 x, int16 y); + + void BeginImage(ColorMapping colorMapping, ColorDepth colorDepth, uint16 sourceWidth, uint16 sourceHeight, uint16 destWidth, uint16 destHeight); + void ReadImage(Compression compression, uint16 startLine, uint16 blockHeight, uint8 padBytes = 4); + void EndImage(); + void EmbeddedDataPrefix(uint32 size); + void EmbeddedDataPrefix32(uint32 size); + + void Append(uint8 value); + void Append(int16 value); + void Append(uint16 value); + void Append(int32 value); + void Append(uint32 value); + void Append(float value); + void Append(const uint8* data, uint32 size); + + void AppendData(uint8 value); + void AppendData(int16 value); + void AppendData(uint16 value); + void AppendData(int32 value); + void AppendData(uint32 value); + void AppendData(float value); + + void AppendDataXY(uint8 x, uint8 y); + void AppendDataXY(int16 x, int16 y); + void AppendDataXY(uint16 x, uint16 y); + void AppendDataXY(int32 x, int32 y); + void AppendDataXY(uint32 x, uint32 y); + void AppendDataXY(float x, float y); + +private: + enum Operator { + kBeginSession = 0x41, + kEndSession, + kBeginPage, + kEndPage, + + kVendorUnique = 0x46, + kComment, + kOpenDataSource, + kCloseDataSource, + kEchoComment, + kQuery, + kDiagnostic3, + + kBeginStream = 0x5b, + kReadStream, + kEndStream, + + kSetColorSpace = 0x6a, + kSetCursor, + + kSetPageOrigin = 0x75, + kSetPageRotation, + kSetPageScale, + kSetPaintTxMode, + kSetPenSource, + kSetPenWidth, + kSetROP, + kSetSourceTxMode, + + kBeginImage = 0xb0, + kReadImage, + kEndImage, + }; + + enum DataTag { + kUByteData = 0xc0, + kUInt16Data, + kUInt32Data, + kSInt16Data, + kSInt32Data, + kReal32Data, + + kString = 0xc7, + kUByteArray, + kUInt16Array, + kUInt32Array, + kSInt16Array, + kSInt32Array, + kReal32Array, + + kUByteXY = 0xd0, + kUInt16XY, + kUInt32XY, + kSInt16XY, + kSInt32XY, + kReal32XY, + + kUByteBox = 0xe0, + kUInt16Box, + kUInt32Box, + kSInt16Box, + kSInt32Box, + kReal32Box, + + k8BitAttrId = 0xf8, + + kEmbeddedData = 0xfa, + kEmbeddedDataByte, + }; + + enum DataType { + kUByte, + kSByte, + kUInt16, + kSInt16, + kReal32 + }; + + enum Attribute { + kCMYColor = 1, + kPaletteDepth, + kColorSpace, + + kRGBColor = 11, + + kMediaDest = 36, + kMediaSize, + kMediaSource, + kMediaType, + kOrientation, + kPageAngle, + kPageOrigin, + kPageScale, + kROP3, + kTxMode, + + kCustomMediaSize = 47, + kCustomMediaSizeUnits, + kPageCopies, + kDitherMatrixSize, + kDitherMatrixDepth, + kSimplexPageMode, + kDuplexPageMode, + kDuplexPageSide, + + kPoint = 76, + + kColorDepth = 98, + kBlockHeight, + kColorMapping, + kCompressMode, + kDestinationBox, + kDestinationSize, + + kSourceHeight = 107, + kSourceWidth, + kStartLine, + kPadBytesMultiple, + kBlockByteLength, + + kNumberOfScanLines = 115, + + kDataOrg = 130, + kMeasure = 134, + + kSourceType = 136, + kUnitsPerMeasure, + kQueryKey, + kStreamName, + kStreamDataLength, + + kErrorReport = 143, + kIOReadTimeOut, + + kWritingMode = 173 + }; + + enum DataSource { + kDefaultDataSource + }; + + enum DataOrganization { + kBinaryHighByteFirst, + kBinaryLowByteFirst + }; + + void AppendOperator(Operator op); + void AppendAttribute(Attribute attr); + void AppendDataTag(DataTag tag); + + PCL6Driver *fDriver; // the driver used for writing the generated PCL6 data + uint8 *fBuffer; // the buffer + uint32 fSize; // the size of the buffer + uint32 fIndex; // the index of the next byte to be written +}; + +#endif +