From ee47c0603344cb127b7c0971dac774abe6f2d146 Mon Sep 17 00:00:00 2001 From: Michael Pfeiffer Date: Thu, 9 Feb 2006 21:22:15 +0000 Subject: [PATCH] Set protocol class in PCL6 header correctly (untested; hopefully this does not break anything). Rewrote description of protocol classes. Set 300 DPI as default resolution. Uncommented protocol class 3.0 as driver does not support any new features of it. Removed second enumeration ProtocolClass from PCL6Cap.h; it is already declared in PCL6Writer.h. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@16318 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/add-ons/print/drivers/pcl6/PCL6.cpp | 823 +++++++++++---------- src/add-ons/print/drivers/pcl6/PCL6.h | 107 +-- src/add-ons/print/drivers/pcl6/PCL6.rsrc | Bin 4161 -> 4161 bytes src/add-ons/print/drivers/pcl6/PCL6Cap.cpp | 58 +- src/add-ons/print/drivers/pcl6/PCL6Cap.h | 7 - 5 files changed, 502 insertions(+), 493 deletions(-) diff --git a/src/add-ons/print/drivers/pcl6/PCL6.cpp b/src/add-ons/print/drivers/pcl6/PCL6.cpp index 68d2bdf222..03f753e91a 100644 --- a/src/add-ons/print/drivers/pcl6/PCL6.cpp +++ b/src/add-ons/print/drivers/pcl6/PCL6.cpp @@ -1,411 +1,412 @@ -/* - * PCL6.cpp - * Copyright 1999-2000 Y.Takagi. All Rights Reserved. - * Copyright 2003 Michael Pfeiffer. - */ - -#include -#include -#include -#include - - -#include "DbgMsg.h" -#include "DeltaRowCompression.h" -#include "Halftone.h" -#include "JobData.h" -#include "PackBits.h" -#include "PCL6.h" -#include "PCL6Cap.h" -#include "PCL6Config.h" -#include "PrinterData.h" -#include "PCL6Rasterizer.h" -#include "UIDriver.h" -#include "ValidRect.h" - -#if (!__MWERKS__ || defined(MSIPL_USING_NAMESPACE)) -using namespace std; -#else -#define std -#endif - -// DeltaRowStreamCompressor writes the delta row directly to the -// in the contructor specified stream. -class DeltaRowStreamCompressor : public AbstractDeltaRowCompressor -{ -public: - DeltaRowStreamCompressor(int rowSize, uchar initialSeed, PCL6Writer *writer) - : AbstractDeltaRowCompressor(rowSize, initialSeed) - , fWriter(writer) - { - // nothing to do - } - -protected: - void AppendByteToDeltaRow(uchar byte) { - fWriter->Append(byte); - } - -private: - PCL6Writer *fWriter; -}; - - -PCL6Driver::PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap) - : GraphicsDriver(msg, printer_data, printer_cap) -{ - fHalftone = NULL; - fWriter = NULL; -} - -void PCL6Driver::write(const uint8 *data, uint32 size) -{ - writeSpoolData(data, size); -} - -bool PCL6Driver::startDoc() -{ - try { - jobStart(); - fHalftone = new Halftone(getJobData()->getSurfaceType(), getJobData()->getGamma(), getJobData()->getInkDensity(), getJobData()->getDitherType()); - return true; - } - catch (TransportException &err) { - return false; - } -} - -bool PCL6Driver::endDoc(bool) -{ - try { - if (fHalftone) { - delete fHalftone; - } - jobEnd(); - return true; - } - catch (TransportException &err) { - return false; - } -} - -bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset) -{ - DBGMSG(("> nextBand\n")); - - try { - int y = (int)offset->y; - - PCL6Rasterizer *rasterizer; - if (getJobData()->getColor() == JobData::kColor) { - #if COLOR_DEPTH == 8 - rasterizer = new ColorRGBRasterizer(fHalftone); - #elif COLOR_DEPTH == 1 - rasterizer = new ColorRasterizer(fHalftone); - #else - #error COLOR_DEPTH must be either 1 or 8! - #endif - } else { - rasterizer = new MonochromeRasterizer(fHalftone); - } - auto_ptr _rasterizer(rasterizer); - bool valid = rasterizer->SetBitmap((int)offset->x, (int)offset->y, bitmap, getPageHeight()); - - if (valid) { - rasterizer->InitializeBuffer(); - - // Use compressor to calculate delta row size - DeltaRowCompressor *deltaRowCompressor = NULL; - if (supportsDeltaRowCompression()) { - deltaRowCompressor = new DeltaRowCompressor(rasterizer->GetOutRowSize(), 0); - if (deltaRowCompressor->InitCheck() != B_OK) { - delete deltaRowCompressor; - return false; - } - } - auto_ptr _deltaRowCompressor(deltaRowCompressor); - int deltaRowSize = 0; - - // remember position - int xPage = rasterizer->GetX(); - int yPage = rasterizer->GetY(); - - while (rasterizer->HasNextLine()) { - const uchar *rowBuffer = (uchar*)rasterizer->RasterizeNextLine(); - - if (deltaRowCompressor != NULL) { - int size = deltaRowCompressor->CalculateSize(rowBuffer, true); - deltaRowSize += size + 2; // two bytes for the row byte count - } - } - - y = rasterizer->GetY(); - - uchar *outBuffer = rasterizer->GetOutBuffer(); - int outBufferSize = rasterizer->GetOutBufferSize(); - int outRowSize = rasterizer->GetOutRowSize(); - int width = rasterizer->GetWidth(); - int height = rasterizer->GetHeight(); - writeBitmap(outBuffer, outBufferSize, outRowSize, xPage, yPage, width, height, deltaRowSize); - } - - if (y >= getPageHeight()) { - offset->x = -1.0; - offset->y = -1.0; - } else { - offset->y += bitmap->Bounds().IntegerHeight()+1; - } - - return true; - } - catch (TransportException &err) { - BAlert *alert = new BAlert("", err.what(), "OK"); - alert->Go(); - return false; - } -} - -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 - PCL6Writer::Compression compressionMethod = PCL6Writer::kNoCompression; - int dataSize = outSize; - -#if ENABLE_DELTA_ROW_COMPRESSION - if (supportsDeltaRowCompression() && deltaRowSize < dataSize) { - compressionMethod = PCL6Writer::kDeltaRowCompression; - dataSize = deltaRowSize; - } -#endif - -#if ENABLE_RLE_COMPRESSION - int rleSize = pack_bits_size(buffer, outSize); - if (rleSize < dataSize) { - compressionMethod = PCL6Writer::kRLECompression; - dataSize = rleSize; - } -#endif - - // write bitmap - move(x, y); - - startRasterGraphics(x, y, width, height, compressionMethod); - - rasterGraphics(buffer, outSize, dataSize, rowSize, height, compressionMethod); - - endRasterGraphics(); - -#if DISPLAY_COMPRESSION_STATISTICS - fprintf(stderr, "Out Size %d %2.2f\n", (int)outSize, 100.0); -#if ENABLE_RLE_COMPRESSION - fprintf(stderr, "RLE Size %d %2.2f\n", (int)rleSize, 100.0 * rleSize / outSize); -#endif -#if ENABLE_DELTA_ROW_COMPRESSION - fprintf(stderr, "Delta Row Size %d %2.2f\n", (int)deltaRowSize, 100.0 * deltaRowSize / outSize); -#endif - fprintf(stderr, "Data Size %d %2.2f\n", (int)dataSize, 100.0 * dataSize / outSize); -#endif -} - - -void PCL6Driver::jobStart() -{ - // PCL6 begin - fWriter = new PCL6Writer(this); - fWriter->PJLHeader(PCL6Writer::kProtocolClass1_1, getJobData()->getXres(), "Copyright (c) 2003, 2004 Haiku"); - fWriter->BeginSession(getJobData()->getXres(), getJobData()->getYres(), PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage); - fWriter->OpenDataSource(); - fMediaSide = PCL6Writer::kFrontMediaSide; -} - -bool PCL6Driver::startPage(int) -{ - PCL6Writer::Orientation orientation = PCL6Writer::kPortrait; - if (getJobData()->getOrientation() == JobData::kLandscape) { - orientation = PCL6Writer::kLandscape; - } - - PCL6Writer::MediaSize mediaSize = PCL6Driver::mediaSize(getJobData()->getPaper()); - PCL6Writer::MediaSource mediaSource = PCL6Driver::mediaSource(getJobData()->getPaperSource()); - if (getJobData()->getPrintStyle() == JobData::kSimplex) { - fWriter->BeginPage(orientation, mediaSize, mediaSource); - } else if (getJobData()->getPrintStyle() == JobData::kDuplex) { - fWriter->BeginPage(orientation, mediaSize, mediaSource, - PCL6Writer::kDuplexHorizontalBinding, fMediaSide); - - if (fMediaSide == PCL6Writer::kFrontMediaSide) { - fMediaSide = PCL6Writer::kBackMediaSide; - } else { - fMediaSide = PCL6Writer::kFrontMediaSide; - } - } else { - return false; - } - - // PageOrigin from Windows NT printer driver - int x = 142 * getJobData()->getXres() / 600; - int y = 100 * getJobData()->getYres() / 600; - bool color = getJobData()->getColor() == JobData::kColor; - 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, PCL6Writer::Compression compressionMethod) -{ - bool color = getJobData()->getColor() == JobData::kColor; - PCL6Writer::ColorDepth colorDepth; - if (color) { - #if COLOR_DEPTH == 8 - colorDepth = PCL6Writer::k8Bit; - #elif COLOR_DEPTH == 1 - colorDepth = PCL6Writer::k1Bit; - #else - #error COLOR_DEPTH must be either 1 or 8! - #endif - } else { - colorDepth = PCL6Writer::k1Bit; - } - fWriter->BeginImage(PCL6Writer::kDirectPixel, colorDepth, width, height, width, height); - fWriter->ReadImage(compressionMethod, 0, height); -} - -void PCL6Driver::endRasterGraphics() -{ - fWriter->EndImage(); -} - -void PCL6Driver::rasterGraphics( - const uchar *buffer, - int bufferSize, - int dataSize, - int rowSize, - int height, - int compressionMethod -) -{ - // write bitmap byte size - fWriter->EmbeddedDataPrefix32(dataSize); - - // write data - if (compressionMethod == PCL6Writer::kRLECompression) { - // use RLE compression - uchar *outBuffer = new uchar[dataSize]; - pack_bits(outBuffer, buffer, bufferSize); - fWriter->Append(outBuffer, dataSize); - delete outBuffer; - return; - } else if (compressionMethod == PCL6Writer::kDeltaRowCompression) { - // use delta row compression - DeltaRowStreamCompressor compressor(rowSize, 0, fWriter); - if (compressor.InitCheck() != B_OK) { - return; - } - - const uint8* row = buffer; - for (int i = 0; i < height; i ++) { - // write row byte count - int32 size = compressor.CalculateSize(row); - fWriter->Append((uint16)size); - - if (size > 0) { - // write delta row - compressor.Compress(row); - } - - row += rowSize; - } - } else { - // write raw data - fWriter->Append(buffer, bufferSize); - } -} - -bool PCL6Driver::endPage(int) -{ - try { - fWriter->EndPage(getJobData()->getCopies()); - return true; - } - catch (TransportException &err) { - return false; - } -} - -void PCL6Driver::jobEnd() -{ - fWriter->CloseDataSource(); - fWriter->EndSession(); - fWriter->PJLFooter(); - fWriter->Flush(); - delete fWriter; - fWriter = NULL; -} - -void PCL6Driver::move(int x, int y) -{ - fWriter->SetCursor(x, y); -} - -bool -PCL6Driver::supportsDeltaRowCompression() -{ - return getProtocolClass() >= kProtocolClass2_1; -} - -PCL6Writer::MediaSize PCL6Driver::mediaSize(JobData::Paper paper) -{ - switch (paper) { - 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 JobData::kB5: return PCL6Writer::kB5Paper; - case JobData::kJapanesePostcard: - return PCL6Writer::kJPostcard; - case JobData::kA5: return PCL6Writer::kA5Paper; - case JobData::kB4: return PCL6Writer::kJB4Paper; -/* - 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::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 PCL6Writer::kLegalPaper; - } -} - -PCL6Writer::MediaSource PCL6Driver::mediaSource(JobData::PaperSource source) -{ - switch (source) { - 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 PCL6Writer::kAutoSelect; - } -} - +/* + * PCL6.cpp + * Copyright 1999-2000 Y.Takagi. All Rights Reserved. + * Copyright 2003 Michael Pfeiffer. + */ + +#include +#include +#include +#include + + +#include "DbgMsg.h" +#include "DeltaRowCompression.h" +#include "Halftone.h" +#include "JobData.h" +#include "PackBits.h" +#include "PCL6.h" +#include "PCL6Cap.h" +#include "PCL6Config.h" +#include "PrinterData.h" +#include "PCL6Rasterizer.h" +#include "UIDriver.h" +#include "ValidRect.h" + +#if (!__MWERKS__ || defined(MSIPL_USING_NAMESPACE)) +using namespace std; +#else +#define std +#endif + +// DeltaRowStreamCompressor writes the delta row directly to the +// in the contructor specified stream. +class DeltaRowStreamCompressor : public AbstractDeltaRowCompressor +{ +public: + DeltaRowStreamCompressor(int rowSize, uchar initialSeed, PCL6Writer *writer) + : AbstractDeltaRowCompressor(rowSize, initialSeed) + , fWriter(writer) + { + // nothing to do + } + +protected: + void AppendByteToDeltaRow(uchar byte) { + fWriter->Append(byte); + } + +private: + PCL6Writer *fWriter; +}; + + +PCL6Driver::PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap) + : GraphicsDriver(msg, printer_data, printer_cap) +{ + fHalftone = NULL; + fWriter = NULL; +} + +void PCL6Driver::write(const uint8 *data, uint32 size) +{ + writeSpoolData(data, size); +} + +bool PCL6Driver::startDoc() +{ + try { + jobStart(); + fHalftone = new Halftone(getJobData()->getSurfaceType(), getJobData()->getGamma(), getJobData()->getInkDensity(), getJobData()->getDitherType()); + return true; + } + catch (TransportException &err) { + return false; + } +} + +bool PCL6Driver::endDoc(bool) +{ + try { + if (fHalftone) { + delete fHalftone; + } + jobEnd(); + return true; + } + catch (TransportException &err) { + return false; + } +} + +bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset) +{ + DBGMSG(("> nextBand\n")); + + try { + int y = (int)offset->y; + + PCL6Rasterizer *rasterizer; + if (getJobData()->getColor() == JobData::kColor) { + #if COLOR_DEPTH == 8 + rasterizer = new ColorRGBRasterizer(fHalftone); + #elif COLOR_DEPTH == 1 + rasterizer = new ColorRasterizer(fHalftone); + #else + #error COLOR_DEPTH must be either 1 or 8! + #endif + } else { + rasterizer = new MonochromeRasterizer(fHalftone); + } + auto_ptr _rasterizer(rasterizer); + bool valid = rasterizer->SetBitmap((int)offset->x, (int)offset->y, bitmap, getPageHeight()); + + if (valid) { + rasterizer->InitializeBuffer(); + + // Use compressor to calculate delta row size + DeltaRowCompressor *deltaRowCompressor = NULL; + if (supportsDeltaRowCompression()) { + deltaRowCompressor = new DeltaRowCompressor(rasterizer->GetOutRowSize(), 0); + if (deltaRowCompressor->InitCheck() != B_OK) { + delete deltaRowCompressor; + return false; + } + } + auto_ptr _deltaRowCompressor(deltaRowCompressor); + int deltaRowSize = 0; + + // remember position + int xPage = rasterizer->GetX(); + int yPage = rasterizer->GetY(); + + while (rasterizer->HasNextLine()) { + const uchar *rowBuffer = (uchar*)rasterizer->RasterizeNextLine(); + + if (deltaRowCompressor != NULL) { + int size = deltaRowCompressor->CalculateSize(rowBuffer, true); + deltaRowSize += size + 2; // two bytes for the row byte count + } + } + + y = rasterizer->GetY(); + + uchar *outBuffer = rasterizer->GetOutBuffer(); + int outBufferSize = rasterizer->GetOutBufferSize(); + int outRowSize = rasterizer->GetOutRowSize(); + int width = rasterizer->GetWidth(); + int height = rasterizer->GetHeight(); + writeBitmap(outBuffer, outBufferSize, outRowSize, xPage, yPage, width, height, deltaRowSize); + } + + if (y >= getPageHeight()) { + offset->x = -1.0; + offset->y = -1.0; + } else { + offset->y += bitmap->Bounds().IntegerHeight()+1; + } + + return true; + } + catch (TransportException &err) { + BAlert *alert = new BAlert("", err.what(), "OK"); + alert->Go(); + return false; + } +} + +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 + PCL6Writer::Compression compressionMethod = PCL6Writer::kNoCompression; + int dataSize = outSize; + +#if ENABLE_DELTA_ROW_COMPRESSION + if (supportsDeltaRowCompression() && deltaRowSize < dataSize) { + compressionMethod = PCL6Writer::kDeltaRowCompression; + dataSize = deltaRowSize; + } +#endif + +#if ENABLE_RLE_COMPRESSION + int rleSize = pack_bits_size(buffer, outSize); + if (rleSize < dataSize) { + compressionMethod = PCL6Writer::kRLECompression; + dataSize = rleSize; + } +#endif + + // write bitmap + move(x, y); + + startRasterGraphics(x, y, width, height, compressionMethod); + + rasterGraphics(buffer, outSize, dataSize, rowSize, height, compressionMethod); + + endRasterGraphics(); + +#if DISPLAY_COMPRESSION_STATISTICS + fprintf(stderr, "Out Size %d %2.2f\n", (int)outSize, 100.0); +#if ENABLE_RLE_COMPRESSION + fprintf(stderr, "RLE Size %d %2.2f\n", (int)rleSize, 100.0 * rleSize / outSize); +#endif +#if ENABLE_DELTA_ROW_COMPRESSION + fprintf(stderr, "Delta Row Size %d %2.2f\n", (int)deltaRowSize, 100.0 * deltaRowSize / outSize); +#endif + fprintf(stderr, "Data Size %d %2.2f\n", (int)dataSize, 100.0 * dataSize / outSize); +#endif +} + + +void PCL6Driver::jobStart() +{ + // PCL6 begin + fWriter = new PCL6Writer(this); + PCL6Writer::ProtocolClass pc = (PCL6Writer::ProtocolClass)getProtocolClass(); + fWriter->PJLHeader(pc, getJobData()->getXres(), "Copyright (c) 2003, 2004 Haiku"); + fWriter->BeginSession(getJobData()->getXres(), getJobData()->getYres(), PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage); + fWriter->OpenDataSource(); + fMediaSide = PCL6Writer::kFrontMediaSide; +} + +bool PCL6Driver::startPage(int) +{ + PCL6Writer::Orientation orientation = PCL6Writer::kPortrait; + if (getJobData()->getOrientation() == JobData::kLandscape) { + orientation = PCL6Writer::kLandscape; + } + + PCL6Writer::MediaSize mediaSize = PCL6Driver::mediaSize(getJobData()->getPaper()); + PCL6Writer::MediaSource mediaSource = PCL6Driver::mediaSource(getJobData()->getPaperSource()); + if (getJobData()->getPrintStyle() == JobData::kSimplex) { + fWriter->BeginPage(orientation, mediaSize, mediaSource); + } else if (getJobData()->getPrintStyle() == JobData::kDuplex) { + fWriter->BeginPage(orientation, mediaSize, mediaSource, + PCL6Writer::kDuplexHorizontalBinding, fMediaSide); + + if (fMediaSide == PCL6Writer::kFrontMediaSide) { + fMediaSide = PCL6Writer::kBackMediaSide; + } else { + fMediaSide = PCL6Writer::kFrontMediaSide; + } + } else { + return false; + } + + // PageOrigin from Windows NT printer driver + int x = 142 * getJobData()->getXres() / 600; + int y = 100 * getJobData()->getYres() / 600; + bool color = getJobData()->getColor() == JobData::kColor; + 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, PCL6Writer::Compression compressionMethod) +{ + bool color = getJobData()->getColor() == JobData::kColor; + PCL6Writer::ColorDepth colorDepth; + if (color) { + #if COLOR_DEPTH == 8 + colorDepth = PCL6Writer::k8Bit; + #elif COLOR_DEPTH == 1 + colorDepth = PCL6Writer::k1Bit; + #else + #error COLOR_DEPTH must be either 1 or 8! + #endif + } else { + colorDepth = PCL6Writer::k1Bit; + } + fWriter->BeginImage(PCL6Writer::kDirectPixel, colorDepth, width, height, width, height); + fWriter->ReadImage(compressionMethod, 0, height); +} + +void PCL6Driver::endRasterGraphics() +{ + fWriter->EndImage(); +} + +void PCL6Driver::rasterGraphics( + const uchar *buffer, + int bufferSize, + int dataSize, + int rowSize, + int height, + int compressionMethod +) +{ + // write bitmap byte size + fWriter->EmbeddedDataPrefix32(dataSize); + + // write data + if (compressionMethod == PCL6Writer::kRLECompression) { + // use RLE compression + uchar *outBuffer = new uchar[dataSize]; + pack_bits(outBuffer, buffer, bufferSize); + fWriter->Append(outBuffer, dataSize); + delete outBuffer; + return; + } else if (compressionMethod == PCL6Writer::kDeltaRowCompression) { + // use delta row compression + DeltaRowStreamCompressor compressor(rowSize, 0, fWriter); + if (compressor.InitCheck() != B_OK) { + return; + } + + const uint8* row = buffer; + for (int i = 0; i < height; i ++) { + // write row byte count + int32 size = compressor.CalculateSize(row); + fWriter->Append((uint16)size); + + if (size > 0) { + // write delta row + compressor.Compress(row); + } + + row += rowSize; + } + } else { + // write raw data + fWriter->Append(buffer, bufferSize); + } +} + +bool PCL6Driver::endPage(int) +{ + try { + fWriter->EndPage(getJobData()->getCopies()); + return true; + } + catch (TransportException &err) { + return false; + } +} + +void PCL6Driver::jobEnd() +{ + fWriter->CloseDataSource(); + fWriter->EndSession(); + fWriter->PJLFooter(); + fWriter->Flush(); + delete fWriter; + fWriter = NULL; +} + +void PCL6Driver::move(int x, int y) +{ + fWriter->SetCursor(x, y); +} + +bool +PCL6Driver::supportsDeltaRowCompression() +{ + return getProtocolClass() >= PCL6Writer::kProtocolClass2_1; +} + +PCL6Writer::MediaSize PCL6Driver::mediaSize(JobData::Paper paper) +{ + switch (paper) { + 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 JobData::kB5: return PCL6Writer::kB5Paper; + case JobData::kJapanesePostcard: + return PCL6Writer::kJPostcard; + case JobData::kA5: return PCL6Writer::kA5Paper; + case JobData::kB4: return PCL6Writer::kJB4Paper; +/* + 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::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 PCL6Writer::kLegalPaper; + } +} + +PCL6Writer::MediaSource PCL6Driver::mediaSource(JobData::PaperSource source) +{ + switch (source) { + 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 PCL6Writer::kAutoSelect; + } +} + diff --git a/src/add-ons/print/drivers/pcl6/PCL6.h b/src/add-ons/print/drivers/pcl6/PCL6.h index 149fddc29a..8230ac286f 100644 --- a/src/add-ons/print/drivers/pcl6/PCL6.h +++ b/src/add-ons/print/drivers/pcl6/PCL6.h @@ -1,53 +1,54 @@ -/* - * PCL6.h - * Copyright 1999-2000 Y.Takagi. All Rights Reserved. - * Copyright 2003 Michael Pfeiffer. - */ - -#ifndef __PCL6_H -#define __PCL6_H - - -#include "GraphicsDriver.h" -#include "PCL6Writer.h" - -class Halftone; - -class PCL6Driver : public GraphicsDriver, public PCL6WriterStream -{ -public: - PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap); - - void write(const uint8 *data, uint32 size); - -protected: - virtual bool startDoc(); - virtual bool startPage(int page); - virtual bool nextBand(BBitmap *bitmap, BPoint *offset); - virtual bool endPage(int page); - virtual bool endDoc(bool success); - -private: - bool supportsDeltaRowCompression(); - 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, PCL6Writer::Compression compressionMethod); - void endRasterGraphics(); - void rasterGraphics( - const uchar *buffer, - int bufferSize, - int dataSize, - int rowSize, - int height, - int compression_method); - void jobEnd(); - - PCL6Writer *fWriter; - PCL6Writer::MediaSide fMediaSide; // side if in duplex mode - Halftone *fHalftone; -}; - -#endif /* __PCL6_H */ +/* + * PCL6.h + * Copyright 1999-2000 Y.Takagi. All Rights Reserved. + * Copyright 2003 Michael Pfeiffer. + */ + +#ifndef __PCL6_H +#define __PCL6_H + + +#include "GraphicsDriver.h" +#include "PCL6Cap.h" +#include "PCL6Writer.h" + +class Halftone; + +class PCL6Driver : public GraphicsDriver, public PCL6WriterStream +{ +public: + PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap); + + void write(const uint8 *data, uint32 size); + +protected: + virtual bool startDoc(); + virtual bool startPage(int page); + virtual bool nextBand(BBitmap *bitmap, BPoint *offset); + virtual bool endPage(int page); + virtual bool endDoc(bool success); + +private: + bool supportsDeltaRowCompression(); + 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, PCL6Writer::Compression compressionMethod); + void endRasterGraphics(); + void rasterGraphics( + const uchar *buffer, + int bufferSize, + int dataSize, + int rowSize, + int height, + int compression_method); + void jobEnd(); + + PCL6Writer *fWriter; + PCL6Writer::MediaSide fMediaSide; // side if in duplex mode + Halftone *fHalftone; +}; + +#endif /* __PCL6_H */ diff --git a/src/add-ons/print/drivers/pcl6/PCL6.rsrc b/src/add-ons/print/drivers/pcl6/PCL6.rsrc index dd910ab4a4d4af28f12cabf81a0dde91992f6a46..12efc0bdbfc12bb9c6f2f3a94b59f4cdf479ab81 100644 GIT binary patch delta 298 zcmX@8a8O~xJsw7;$@h6=wF4X(7(|>H7$!I>FfuTBFfcH10I>iNgV-R<0_C$zR_B$i zS8&cRs4U7%&nQtaw6wHTh|~*7%uYb^E?B@77Z`R@yX957s C_&b*X delta 114 zcmX@8a8O~xJsw8J$@h6=Cm-Qcn`po>S&LW7g3CF-pt2}4J)=ay(9+UUAyO|SF*`9m v6G`02z`$6+H#0dSF*QdaAT2dBEiJWZ@= kProtocolClass2_1) { + if (getProtocolClass() >= PCL6Writer::kProtocolClass2_1) { return sizeof(papers2_1) / sizeof(papers2_1[0]); } return sizeof(papers1_1) / sizeof(papers1_1[0]); case kPaperSource: - if (getProtocolClass() >= kProtocolClass2_0) { + if (getProtocolClass() >= PCL6Writer::kProtocolClass2_0) { return sizeof(paperSources2_0) / sizeof(paperSources2_0[0]); } return sizeof(paperSources1_1) / sizeof(paperSources1_1[0]); @@ -275,12 +289,12 @@ const BaseCap **PCL6Cap::enumCap(CapID capid) const { switch (capid) { case kPaper: - if (getProtocolClass() >= kProtocolClass2_1) { + if (getProtocolClass() >= PCL6Writer::kProtocolClass2_1) { return (const BaseCap **)papers2_1; } return (const BaseCap **)papers1_1; case kPaperSource: - if (getProtocolClass() >= kProtocolClass2_0) { + if (getProtocolClass() >= PCL6Writer::kProtocolClass2_0) { return (const BaseCap **)paperSources2_0; } return (const BaseCap **)paperSources1_1; diff --git a/src/add-ons/print/drivers/pcl6/PCL6Cap.h b/src/add-ons/print/drivers/pcl6/PCL6Cap.h index 3fd91c0a0f..667ee03a79 100644 --- a/src/add-ons/print/drivers/pcl6/PCL6Cap.h +++ b/src/add-ons/print/drivers/pcl6/PCL6Cap.h @@ -8,13 +8,6 @@ #include "PrinterCap.h" -enum ProtocolClass { - kProtocolClass1_1, - kProtocolClass2_0, - kProtocolClass2_1, - kProtocolClass3_0, -}; - class PCL6Cap : public PrinterCap { public: PCL6Cap(const PrinterData *printer_data);