/* 
** PCL6Writer.cpp
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the MIT License.
*/


#include "PCL6Writer.h"

#include <ByteOrder.h>
#include <String.h>

#define BYTE_AT(lvalue, index) (((uint8*)(&lvalue))[index])


PCL6Writer::PCL6Writer(PCL6WriterStream* stream, uint32 bufferSize)
        :
        fStream(stream),
        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) {
                fStream->Write(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::AppendString(const char* string)
{
        uint8 ch = *string;
        while (ch != 0) {
                Append(ch);
                string ++;
                ch = *string;
        }
}


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::PJLHeader(ProtocolClass protocolClass, int dpi, const char* comment)
{
        BString string;
        AppendString("\033%-12345X@PJL JOB\n@PJL SET RESOLUTION=");
        string << dpi;
        AppendString(string.String());
        AppendString("\n@PJL ENTER LANGUAGE=PCLXL\n) HP-PCL XL;");

        const char* pc = "";
        switch (protocolClass) {
                case kProtocolClass1_1:
                        pc = "1;1;";
                        break;
                case kProtocolClass2_0:
                        pc = "2;0;";
                        break;
                case kProtocolClass2_1:
                        pc = "2;1;";
                        break;
                case kProtocolClass3_0:
                        pc = "3;0;";
                        break;
        }
        AppendString(pc);
        
        if (comment != NULL) {
                AppendString("Comment ");
                AppendString(comment);
        }
        
        AppendString("\n");
}


void
PCL6Writer::PJLFooter()
{
        AppendString("\033%-12345X@PJL EOJ\n\033%-12345X");
}


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);
}