/*
* Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
* TAGMA's text layout bytecode storage class.
*
*/


#include "TMSTD.H"

void CTmCode::AppendByteL(TUint8 aByte)
	{
	InsertByteL(aByte,Size());
	}

TInt CTmCode::AppendNumberL(TInt aNumber)
	{
	return InsertNumberL(aNumber,Size());
	}

TInt CTmCode::AppendRectL(const TRect& aRect)
	{
	return InsertRectL(aRect,Size());
	}

TInt CTmCode::Size() const
	{
	return iBuffer ? iBuffer->Size() : 0;
	}

void CTmCode::Delete(TInt aPos,TInt aLength)
	{
	if (iBuffer) iBuffer->Delete(aPos,aLength);
	}

void CTmCode::Reset()
	{
	delete iBuffer; iBuffer = NULL;
	}

void CTmCode::CreateBufferL()
	{
	if (!iBuffer) iBuffer = new(ELeave) CTmBufSeg(EExpandSize);
	}

void CTmCode::InsertByteL(TUint8 aByte,TInt aPos)
	{
	iBuffer->InsertL(aPos,&aByte,1);
	}

/*
Write a number in bytecode, using as few bytes as possible. Each byte assigns the low seven bits
to data and uses the high bit as a continuation bit. Return the position after the number.
*/
TInt CTmCode::InsertNumberL(TInt aNumber,TInt aPos)
	{
	TUint8 buffer[5];
	int bytes = WriteNumber(aNumber,buffer);
	iBuffer->InsertL(aPos,buffer,bytes);
	return aPos + bytes;
	}

// Write aNumber to aBuffer and return the number of bytes written (from 1 to 5).
TInt CTmCode::WriteNumber(TInt aNumber,TUint8* aBuffer)
	{
	int bytes;
	if (aNumber >= -64 && aNumber <= 63)
		bytes = 1;
	else if (aNumber >= -8192 && aNumber <= 8191)
		bytes = 2;
	else if (aNumber >= -1048576 && aNumber <= 1048575)
		bytes = 3;
	else if (aNumber >= -134217728 && aNumber <= 134217727)
		bytes = 4;
	else
		bytes = 5;
	int shift = 0;
	for (int i = 0; i < bytes; i++)
		{
		aBuffer[i] = (TUint8)((aNumber >> shift) & 0x7F);
		if (i > 0)
			aBuffer[i - 1] |= 0x80;
		shift += 7;
		}
	return bytes;
	}

// Write a rectangle in bytecode as left, top, width, height. Return the position after the rectangle.
TInt CTmCode::InsertRectL(const TRect& aRect,TInt aPos)
	{
	TUint8 buffer[20];
	int bytes = WriteNumber(aRect.iTl.iX,buffer);
	bytes += WriteNumber(aRect.iTl.iY,buffer + bytes);
	bytes += WriteNumber(aRect.Width(),buffer + bytes);
	bytes += WriteNumber(aRect.Height(),buffer + bytes);
	iBuffer->InsertL(aPos,buffer,bytes);
	return aPos + bytes;
	}

// Delete bytecode from aStart to aEnd and replace it with aNewCode, which is consumed by the operation.
void CTmCode::ChangeL(TInt aStart,TInt aEnd,CTmCode& aNewCode)
	{
	if (aStart <= 0 && aEnd >= Size())
		{
		delete iBuffer;
		iBuffer = aNewCode.iBuffer;
		aNewCode.iBuffer = NULL;
		}
	else
		{
		CreateBufferL();
		if (aEnd > aStart)
			iBuffer->Delete(aStart,aEnd - aStart);
		while (aNewCode.Size() > 0)
			{
			TPtrC8 p = aNewCode.Ptr(0);
			iBuffer->InsertL(aStart,p);
			aStart += p.Length();
			aNewCode.Delete(0,p.Length());
			}
		}
	}

TInt CTmBufSeg::MemoryUsed() const
	{
	TInt bytes = sizeof(*this) + iSize;
	TInt pos = 0;
	while (pos < iSize)
		{
		TPtr8 p = (CONST_CAST(CTmBufSeg*,this))->Ptr(pos);
		bytes += 8;
		pos += p.Length();
		}
	return bytes;
	}

// Return the amount of memory used in bytes, allowing 8 bytes overhead per heap object
TInt CTmCode::MemoryUsed() const
	{
	TInt bytes = sizeof(*this);
	if (iBuffer)
		bytes += iBuffer->MemoryUsed();
	return bytes;
	}

int TTmCodeReader::ReadNumber()
	{
	TUint byte = ReadByte();
	if (!(byte & 0xC0))
		return byte;

	int n = 0;
	int shift = 0;
	do
		{
		if (shift)
			byte = ReadByte();
		n |= ((byte & 0x7F) << shift);
		shift += 7;
		} while (byte & 0x80);
	if ((byte & 0x40) && shift < 32)	// if bit 6 of the last byte is set, the number is negative
		n |= (0xFFFFFFFF << shift);
	return n;
	}


TRect TTmCodeReader::ReadRect()
	{
	TRect r;
	r.iTl.iX = ReadNumber();
	r.iTl.iY = ReadNumber();
	r.iBr.iX = r.iTl.iX + ReadNumber();
	r.iBr.iY = r.iTl.iY + ReadNumber();
	return r;
	}

void TTmCodeReader::SetCodePtr()
	{
	if (iCodePos > iCodeEndPos)
		TmPanic(EBadCodePos);
	TPtrC8 p = CONST_CAST(CTmCode&,iCode).Ptr(iCodePos);
	iCodeSegPtr = p.Ptr();
	iCodeSegEndPtr = p.Ptr() + p.Length();
	}

void TTmCodeReader::SetCodePos(TInt aNewCodePos)
	{
	int bytes_to_skip = aNewCodePos - iCodePos;
	iCodePos = aNewCodePos;
	if (bytes_to_skip >= 0 && bytes_to_skip <= iCodeSegEndPtr - iCodeSegPtr)
		iCodeSegPtr += bytes_to_skip;
	else
		SetCodePtr();
	}