Replaced jetlib.

git-svn-id: file:///srv/svn/repos/haiku/trunk/current@10776 a95241bf-73f2-0310-859d-f6bbb57e9c96

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 ;

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);
+	fWriter = new PCL6Writer(this);
-	HP_BeginSession_2(fStream, getJobData()->getXres(), getJobData()->getYres(), HP_eInch, HP_eBackChAndErrPage);
+	fWriter->BeginSession(getJobData()->getXres(), getJobData()->getYres(), PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage);
-	HP_OpenDataSource_1(fStream, HP_eDefaultDataSource, HP_eBinaryLowByteFirst);
+	fWriter->OpenDataSource();
-	fMediaSide = HP_eFrontMediaSide;
+	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) {
+		if (fMediaSide == PCL6Writer::kFrontMediaSide) {
-			fMediaSide = HP_eBackMediaSide;
+			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);
+	fWriter->SetPageOrigin(x, y);
-	HP_SetColorSpace_1(fStream, color ? HP_eRGB : HP_eGray);
+	fWriter->SetColorSpace(color ? PCL6Writer::kRGB : PCL6Writer::kGray);
-	HP_SetPaintTxMode_1(fStream, HP_eOpaque);
+	fWriter->SetPaintTxMode(PCL6Writer::kOpaque);
-	HP_SetSourceTxMode_1(fStream, HP_eOpaque);
+	fWriter->SetSourceTxMode(PCL6Writer::kOpaque);
-	HP_SetROP_1(fStream, 204);
+	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);
+	fWriter->BeginImage(PCL6Writer::kDirectPixel, color ? PCL6Writer::k8Bit : PCL6Writer::k1Bit, width, height, width, height);
-	HP_ReadImage_1(fStream, 0, height, compressionMethod);
+	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;
+		// uint32 compressedSize = 0;
-		HP_M2TIFF_Compress(fStream, 0, (HP_pCharHuge)buffer, bufferSize, &compressedSize);
+		// HP_M2TIFF_Compress(fStream, 0, (HP_pCharHuge)buffer, bufferSize, &compressedSize);
-	} else if (compressionMethod == HP_eDeltaRowCompression) {
+		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);
+			int32 size = compressor.CalculateSize(row);
-			HP_RawUInt16(fStream, size);
+			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);
+	fWriter->CloseDataSource();
-	HP_EndSession_1(fStream);
+	fWriter->EndSession();
-	HP_FinishStream(fStream);
+	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::kLetter:    return PCL6Writer::kLetterPaper;
-		case JobData::kLegal:     return HP_eLegalPaper;
+		case JobData::kLegal:     return PCL6Writer::kLegalPaper;
-		case JobData::kA4:        return HP_eA4Paper;
+		case JobData::kA4:        return PCL6Writer::kA4Paper;
-		case JobData::kExecutive: return HP_eExecPaper;
+		case JobData::kExecutive: return PCL6Writer::kExecPaper;
-		case JobData::kLedger:    return HP_eLedgerPaper;
+		case JobData::kLedger:    return PCL6Writer::kLedgerPaper;
-		case JobData::kA3:        return HP_eA3Paper;
+		case JobData::kA3:        return PCL6Writer::kA3Paper;
 /*
-		case : return HP_eCOM10Envelope;
+		case : return PCL6Writer::kCOM10Envelope;
-		case : return HP_eMonarchEnvelope;
+		case : return PCL6Writer::kMonarchEnvelope;
-		case : return HP_eC5Envelope;
+		case : return PCL6Writer::kC5Envelope;
-		case : return HP_eDLEnvelope;
+		case : return PCL6Writer::kDLEnvelope;
-		case : return HP_eJB4Paper;
+		case : return PCL6Writer::kJB4Paper;
-		case : return HP_eJB5Paper;
+		case : return PCL6Writer::kJB5Paper;
-		case : return HP_eB5Envelope;
+		case : return PCL6Writer::kB5Envelope;
-		case : return HP_eB5Paper;
+		case : return PCL6Writer::kB5Paper;
-		case : return HP_eJPostcard;
+		case : return PCL6Writer::kJPostcard;
-		case : return HP_eJDoublePostcard;
+		case : return PCL6Writer::kJDoublePostcard;
-		case : return HP_eA5Paper;
+		case : return PCL6Writer::kA5Paper;
-		case : return HP_eA6Paper;
+		case : return PCL6Writer::kA6Paper;
-		case : return HP_eJB6Paper;
+		case : return PCL6Writer::kJB6Paper;
-		case : return HP_eJIS8KPaper;
+		case : return PCL6Writer::kJIS8KPaper;
-		case : return HP_eJIS16KPaper;
+		case : return PCL6Writer::kJIS16KPaper;
-		case : return HP_eJISExecPaper;
+		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::kAuto:       return PCL6Writer::kAutoSelect;
-		case JobData::kCassette1:  return HP_eDefaultSource;
+		case JobData::kCassette1:  return PCL6Writer::kDefaultSource;
-		case JobData::kCassette2:  return HP_eEnvelopeTray;
+		case JobData::kCassette2:  return PCL6Writer::kEnvelopeTray;
-		case JobData::kLower:      return HP_eLowerCassette;
+		case JobData::kLower:      return PCL6Writer::kLowerCassette;
-		case JobData::kUpper:      return HP_eUpperCassette;
+		case JobData::kUpper:      return PCL6Writer::kUpperCassette;
-		case JobData::kMiddle:     return HP_eThirdCassette;
+		case JobData::kMiddle:     return PCL6Writer::kThirdCassette;
-		case JobData::kManual:     return HP_eManualFeed;
+		case JobData::kManual:     return PCL6Writer::kManualFeed;
-		case JobData::kCassette3:  return HP_eMultiPurposeTray;
+		case JobData::kCassette3:  return PCL6Writer::kMultiPurposeTray;
 		
 		default:
-			return HP_eAutoSelect;
+			return PCL6Writer::kAutoSelect;
 	}
 }
 

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,
+	void writeData(const uint8 *data, uint32 size);
-                                unsigned long cookie,
-                                HP_pUByte pOutBuffer,
-                                HP_SInt32 currentBufferLen);
 
 protected:
 	virtual bool startDoc();
@@ -29,12 +28,12 @@ protected:
 	virtual bool endDoc(bool success);
 
 private:
-	HP_UByte mediaSize(JobData::Paper paper);
+	PCL6Writer::MediaSize mediaSize(JobData::Paper paper);
-	HP_UByte mediaSource(JobData::PaperSource source);
+	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;
+	PCL6Writer            *fWriter;
-	Halftone            *fHalftone;
+	PCL6Writer::MediaSide fMediaSide; // side if in duplex mode
-	HP_UByte             fMediaSide; // side if in duplex mode
+	Halftone              *fHalftone;
 };
 
 #endif	/* __PCL6_H */

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,

src/add-ons/print/drivers/pcl6/PCL6Writer.cpp

@@ -0,0 +1,336 @@
+/* 
+** PCL6Writer.cpp
+** Copyright 2005, Michael Pfeiffer, [email protected]. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+#include "PCL6Writer.h"
+#include "PCL6.h"
+
+#include <ByteOrder.h>
+
+#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);
+}
+
+

src/add-ons/print/drivers/pcl6/PCL6Writer.h

@@ -0,0 +1,344 @@
+/* 
+** PCL6Writer.h
+** Copyright 2005, Michael Pfeiffer, [email protected]. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+#ifndef _PCL6_WRITER_H
+#define _PCL6_WRITER_H
+
+#include <SupportDefs.h>
+
+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
+