/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: rtfgrf.cxx,v $
 * $Revision: 1.13 $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
#include <osl/endian.h>
#include <tools/cachestr.hxx>
#include <vcl/graph.hxx>
#include <vcl/svapp.hxx>
#include <svtools/rtfkeywd.hxx>
#include <svtools/rtftoken.h>
#include <svtools/filter.hxx>

#include "impgrf.hxx"
#include "svxrtf.hxx"


#ifdef PRODUCT
#undef DEBUG_JP
#endif

#ifdef DEBUG_JP

#include <tools/fsys.hxx>

class GrfWindow : public WorkWindow
{
	Graphic aGrf;
public:
	GrfWindow( const Graphic& rGrf );
	virtual void    Paint( const Rectangle& rRect );
};

GrfWindow::GrfWindow( const Graphic& rGrf )
	: WorkWindow( NULL ),
	aGrf( rGrf )
{
	SetPosSizePixel( Point( 100, 0 ), Size( 300, 300 ));
	Show();
	Invalidate();
	Update();
}

void GrfWindow::Paint( const Rectangle& )
{
	aGrf.Draw( this, Point(0,0), GetSizePixel() );
}
#endif

static BYTE __FAR_DATA aPal1[ 2 * 4 ] = {
		0x00, 0x00, 0x00, 0x00,				// Schwarz
		0xFF, 0xFF, 0xFF, 0x00				// Weiss
};

static BYTE __FAR_DATA aPal4[ 16 * 4 ] = {
		0x00, 0x00, 0x00, 0x00,
		0x80, 0x00, 0x00, 0x00,
		0x00, 0x80, 0x00, 0x00,
		0x80, 0x80, 0x00, 0x00,
		0x00, 0x00, 0x80, 0x00,
		0x80, 0x00, 0x80, 0x00,
		0x00, 0x80, 0x80, 0x00,
		0x80, 0x80, 0x80, 0x00,
		0xC0, 0xC0, 0xC0, 0x00,
		0xFF, 0x00, 0x00, 0x00,
		0x00, 0xFF, 0x00, 0x00,
		0xFF, 0xFF, 0x00, 0x00,
		0x00, 0x00, 0xFF, 0x00,
		0xFF, 0x00, 0xFF, 0x00,
		0x00, 0xFF, 0xFF, 0x00,
		0xFF, 0xFF, 0xFF, 0x00
};

static BYTE __FAR_DATA aPal8[ 256 * 4 ] =
{
0x00, 0x00, 0x00, 0x00,   0x80, 0x00, 0x00, 0x00,   0x00, 0x92, 0x00, 0x00,
0x80, 0x92, 0x00, 0x00,   0x00, 0x00, 0xAA, 0x00,   0x80, 0x00, 0xAA, 0x00,
0x00, 0x92, 0xAA, 0x00,   0xC1, 0xC1, 0xC1, 0x00,   0xC9, 0xC9, 0xC9, 0x00,
0xAA, 0xDB, 0xFF, 0x00,   0x00, 0x49, 0xAA, 0x00,   0x00, 0x49, 0xFF, 0x00,
0x00, 0x6D, 0x00, 0x00,   0x00, 0x6D, 0x55, 0x00,   0x00, 0x6D, 0xAA, 0x00,
0x00, 0x6D, 0xFF, 0x00,   0x00, 0x24, 0x00, 0x00,   0x00, 0x92, 0x55, 0x00,
0x00, 0x24, 0xAA, 0x00,   0x00, 0x92, 0xFF, 0x00,   0x00, 0xB6, 0x00, 0x00,
0x00, 0xB6, 0x55, 0x00,   0x00, 0xB6, 0xAA, 0x00,   0x00, 0xB6, 0xFF, 0x00,
0x00, 0xDB, 0x00, 0x00,   0x00, 0xDB, 0x55, 0x00,   0x00, 0xDB, 0xAA, 0x00,
0x00, 0xDB, 0xFF, 0x00,   0xFF, 0xDB, 0xAA, 0x00,   0x00, 0xFF, 0x55, 0x00,
0x00, 0xFF, 0xAA, 0x00,   0xFF, 0xFF, 0xAA, 0x00,   0x2B, 0x00, 0x00, 0x00,
0x2B, 0x00, 0x55, 0x00,   0x2B, 0x00, 0xAA, 0x00,   0x2B, 0x00, 0xFF, 0x00,
0x2B, 0x24, 0x00, 0x00,   0x2B, 0x24, 0x55, 0x00,   0x2B, 0x24, 0xAA, 0x00,
0x2B, 0x24, 0xFF, 0x00,   0x2B, 0x49, 0x00, 0x00,   0x2B, 0x49, 0x55, 0x00,
0x2B, 0x49, 0xAA, 0x00,   0x2B, 0x49, 0xFF, 0x00,   0x2B, 0x6D, 0x00, 0x00,
0x2B, 0x6D, 0x55, 0x00,   0x2B, 0x6D, 0xAA, 0x00,   0x2B, 0x6D, 0xFF, 0x00,
0x2B, 0x92, 0x00, 0x00,   0x2B, 0x92, 0x55, 0x00,   0x2B, 0x92, 0xAA, 0x00,
0x2B, 0x92, 0xFF, 0x00,   0x2B, 0xB6, 0x00, 0x00,   0x2B, 0xB6, 0x55, 0x00,
0x2B, 0xB6, 0xAA, 0x00,   0x2B, 0xB6, 0xFF, 0x00,   0x2B, 0xDB, 0x00, 0x00,
0x2B, 0xDB, 0x55, 0x00,   0x2B, 0xDB, 0xAA, 0x00,   0x2B, 0xDB, 0xFF, 0x00,
0x2B, 0xFF, 0x00, 0x00,   0x2B, 0xFF, 0x55, 0x00,   0x2B, 0xFF, 0xAA, 0x00,
0x2B, 0xFF, 0xFF, 0x00,   0x55, 0x00, 0x00, 0x00,   0x55, 0x00, 0x55, 0x00,
0x55, 0x00, 0xAA, 0x00,   0x55, 0x00, 0xFF, 0x00,   0x55, 0x24, 0x00, 0x00,
0x55, 0x24, 0x55, 0x00,   0x55, 0x24, 0xAA, 0x00,   0x55, 0x24, 0xFF, 0x00,
0x55, 0x49, 0x00, 0x00,   0x55, 0x49, 0x55, 0x00,   0x55, 0x49, 0xAA, 0x00,
0x55, 0x49, 0xFF, 0x00,   0x55, 0x6D, 0x00, 0x00,   0x55, 0x6D, 0x55, 0x00,
0x55, 0x6D, 0xAA, 0x00,   0x55, 0x6D, 0xFF, 0x00,   0x55, 0x92, 0x00, 0x00,
0x55, 0x92, 0x55, 0x00,   0x55, 0x92, 0xAA, 0x00,   0x55, 0x92, 0xFF, 0x00,
0x55, 0xB6, 0x00, 0x00,   0x55, 0xB6, 0x55, 0x00,   0x55, 0xB6, 0xAA, 0x00,
0x55, 0xB6, 0xFF, 0x00,   0x55, 0xDB, 0x00, 0x00,   0x55, 0xDB, 0x55, 0x00,
0x55, 0xDB, 0xAA, 0x00,   0x55, 0xDB, 0xFF, 0x00,   0x55, 0xFF, 0x00, 0x00,
0x55, 0xFF, 0x55, 0x00,   0x55, 0xFF, 0xAA, 0x00,   0x55, 0xFF, 0xFF, 0x00,
0x00, 0x00, 0x55, 0x00,   0x80, 0x00, 0x55, 0x00,   0x00, 0x24, 0x55, 0x00,
0x80, 0x00, 0xFF, 0x00,   0x80, 0x24, 0x00, 0x00,   0x80, 0x24, 0x55, 0x00,
0x80, 0x24, 0xAA, 0x00,   0x80, 0x24, 0xFF, 0x00,   0x80, 0x49, 0x00, 0x00,
0x80, 0x49, 0x55, 0x00,   0x80, 0x49, 0xAA, 0x00,   0x80, 0x49, 0xFF, 0x00,
0x80, 0x6D, 0x00, 0x00,   0x80, 0x6D, 0x55, 0x00,   0x80, 0x6D, 0xAA, 0x00,
0x80, 0x6D, 0xFF, 0x00,   0x08, 0x08, 0x08, 0x00,   0x0F, 0x0F, 0x0F, 0x00,
0x17, 0x17, 0x17, 0x00,   0x1F, 0x1F, 0x1F, 0x00,   0x27, 0x27, 0x27, 0x00,
0x2E, 0x2E, 0x2E, 0x00,   0x36, 0x36, 0x36, 0x00,   0x3E, 0x3E, 0x3E, 0x00,
0x46, 0x46, 0x46, 0x00,   0x4D, 0x4D, 0x4D, 0x00,   0x55, 0x55, 0x55, 0x00,
0x5D, 0x5D, 0x5D, 0x00,   0x64, 0x64, 0x64, 0x00,   0x6C, 0x6C, 0x6C, 0x00,
0x74, 0x74, 0x74, 0x00,   0x7C, 0x7C, 0x7C, 0x00,   0xFF, 0xDB, 0x00, 0x00,
0x8B, 0x8B, 0x8B, 0x00,   0x93, 0x93, 0x93, 0x00,   0x9B, 0x9B, 0x9B, 0x00,
0xFF, 0xB6, 0xFF, 0x00,   0xAA, 0xAA, 0xAA, 0x00,   0xB2, 0xB2, 0xB2, 0x00,
0xB9, 0xB9, 0xB9, 0x00,   0x00, 0x24, 0xFF, 0x00,   0x00, 0x49, 0x00, 0x00,
0xD1, 0xD1, 0xD1, 0x00,   0xD8, 0xD8, 0xD8, 0x00,   0xE0, 0xE0, 0xE0, 0x00,
0xE8, 0xE8, 0xE8, 0x00,   0xF0, 0xF0, 0xF0, 0x00,   0xFF, 0xB6, 0xAA, 0x00,
0xFF, 0xDB, 0xFF, 0x00,   0x80, 0x92, 0x55, 0x00,   0x80, 0x92, 0xAA, 0x00,
0x80, 0x92, 0xFF, 0x00,   0x80, 0xB6, 0x00, 0x00,   0x80, 0xB6, 0x55, 0x00,
0x80, 0xB6, 0xAA, 0x00,   0x80, 0xB6, 0xFF, 0x00,   0x80, 0xDB, 0x00, 0x00,
0x80, 0xDB, 0x55, 0x00,   0x80, 0xDB, 0xAA, 0x00,   0x80, 0xDB, 0xFF, 0x00,
0x80, 0xFF, 0x00, 0x00,   0x80, 0xFF, 0x55, 0x00,   0x80, 0xFF, 0xAA, 0x00,
0x80, 0xFF, 0xFF, 0x00,   0xAA, 0x00, 0x00, 0x00,   0xAA, 0x00, 0x55, 0x00,
0xAA, 0x00, 0xAA, 0x00,   0xAA, 0x00, 0xFF, 0x00,   0xAA, 0x24, 0x00, 0x00,
0xAA, 0x24, 0x55, 0x00,   0xAA, 0x24, 0xAA, 0x00,   0xAA, 0x24, 0xFF, 0x00,
0xAA, 0x49, 0x00, 0x00,   0xAA, 0x49, 0x55, 0x00,   0xAA, 0x49, 0xAA, 0x00,
0xAA, 0x49, 0xFF, 0x00,   0xAA, 0x6D, 0x00, 0x00,   0xAA, 0x6D, 0x55, 0x00,
0xAA, 0x6D, 0xAA, 0x00,   0xAA, 0x6D, 0xFF, 0x00,   0xAA, 0x92, 0x00, 0x00,
0xAA, 0x92, 0x55, 0x00,   0xAA, 0x92, 0xAA, 0x00,   0xAA, 0x92, 0xFF, 0x00,
0xAA, 0xB6, 0x00, 0x00,   0xAA, 0xB6, 0x55, 0x00,   0xAA, 0xB6, 0xAA, 0x00,
0xAA, 0xB6, 0xFF, 0x00,   0xAA, 0xDB, 0x00, 0x00,   0xAA, 0xDB, 0x55, 0x00,
0xAA, 0xDB, 0xAA, 0x00,   0x00, 0x49, 0x55, 0x00,   0xAA, 0xFF, 0x00, 0x00,
0xAA, 0xFF, 0x55, 0x00,   0xAA, 0xFF, 0xAA, 0x00,   0xAA, 0xFF, 0xFF, 0x00,
0xD5, 0x00, 0x00, 0x00,   0xD5, 0x00, 0x55, 0x00,   0xD5, 0x00, 0xAA, 0x00,
0xD5, 0x00, 0xFF, 0x00,   0xD5, 0x24, 0x00, 0x00,   0xD5, 0x24, 0x55, 0x00,
0xD5, 0x24, 0xAA, 0x00,   0xD5, 0x24, 0xFF, 0x00,   0xD5, 0x49, 0x00, 0x00,
0xD5, 0x49, 0x55, 0x00,   0xD5, 0x49, 0xAA, 0x00,   0xD5, 0x49, 0xFF, 0x00,
0xD5, 0x6D, 0x00, 0x00,   0xD5, 0x6D, 0x55, 0x00,   0xD5, 0x6D, 0xAA, 0x00,
0xD5, 0x6D, 0xFF, 0x00,   0xD5, 0x92, 0x00, 0x00,   0xD5, 0x92, 0x55, 0x00,
0xD5, 0x92, 0xAA, 0x00,   0xD5, 0x92, 0xFF, 0x00,   0xD5, 0xB6, 0x00, 0x00,
0xD5, 0xB6, 0x55, 0x00,   0xD5, 0xB6, 0xAA, 0x00,   0xD5, 0xB6, 0xFF, 0x00,
0xD5, 0xDB, 0x00, 0x00,   0xD5, 0xDB, 0x55, 0x00,   0xD5, 0xDB, 0xAA, 0x00,
0xD5, 0xDB, 0xFF, 0x00,   0xD5, 0xFF, 0x00, 0x00,   0xD5, 0xFF, 0x55, 0x00,
0xD5, 0xFF, 0xAA, 0x00,   0xD5, 0xFF, 0xFF, 0x00,   0xFF, 0xDB, 0x55, 0x00,
0xFF, 0x00, 0x55, 0x00,   0xFF, 0x00, 0xAA, 0x00,   0xFF, 0xFF, 0x55, 0x00,
0xFF, 0x24, 0x00, 0x00,   0xFF, 0x24, 0x55, 0x00,   0xFF, 0x24, 0xAA, 0x00,
0xFF, 0x24, 0xFF, 0x00,   0xFF, 0x49, 0x00, 0x00,   0xFF, 0x49, 0x55, 0x00,
0xFF, 0x49, 0xAA, 0x00,   0xFF, 0x49, 0xFF, 0x00,   0xFF, 0x6D, 0x00, 0x00,
0xFF, 0x6D, 0x55, 0x00,   0xFF, 0x6D, 0xAA, 0x00,   0xFF, 0x6D, 0xFF, 0x00,
0xFF, 0x92, 0x00, 0x00,   0xFF, 0x92, 0x55, 0x00,   0xFF, 0x92, 0xAA, 0x00,
0xFF, 0x92, 0xFF, 0x00,   0xFF, 0xB6, 0x00, 0x00,   0xFF, 0xB6, 0x55, 0x00,
0xF7, 0xF7, 0xF7, 0x00,   0xA2, 0xA2, 0xA2, 0x00,   0x83, 0x83, 0x83, 0x00,
0xFF, 0x00, 0x00, 0x00,   0x00, 0xFF, 0x00, 0x00,   0xFF, 0xFF, 0x00, 0x00,
0x00, 0x00, 0xFF, 0x00,   0xFF, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00
};


/*  */


inline long SwapLong( long n )
{
#ifndef OSL_LITENDIAN
	return SWAPLONG( n );
#else
	return n;
#endif
}

inline short SwapShort( short n )
{
#ifndef OSL_LITENDIAN
	return SWAPSHORT( n );
#else
	return n;
#endif
}


static void WriteBMPHeader( SvStream& rStream,
							const SvxRTFPictureType& rPicType )
{
	ULONG n4Width = rPicType.nWidth;
	ULONG n4Height = rPicType.nHeight;
	USHORT n4ColBits = rPicType.nBitsPerPixel;

	USHORT nColors = (1 << n4ColBits);	// Anzahl der Farben ( 1, 16, 256 )
	USHORT nWdtOut = rPicType.nWidthBytes;
	if( !nWdtOut )
		nWdtOut = (USHORT)((( n4Width * n4ColBits + 31 ) / 32 ) * 4 );

	long nOffset = 14 + 40; 	// BMP_FILE_HD_SIZ + sizeof(*pBmpInfo);
	if( 256 >= nColors )
		nOffset += nColors * 4;
	long nSize = nOffset + nWdtOut * n4Height;
	rStream << "BM"						// = "BM"
			<< SwapLong(nSize)          // Filesize in Bytes
			<< SwapShort(0)             // Reserviert
			<< SwapShort(0)             // Reserviert
			<< SwapLong(nOffset);       // Offset?

	rStream	<< SwapLong(40)				// sizeof( BmpInfo )
			<< SwapLong(n4Width)
			<< SwapLong(n4Height)
			<< (USHORT)1
			<< n4ColBits
			<< SwapLong(0)
			<< SwapLong(0)
			<< SwapLong( rPicType.nGoalWidth
						? rPicType.nGoalWidth * 1000L / 254L
						: 0 )	      // DPI in Pixel per Meter
			<< SwapLong( rPicType.nGoalHeight
						? rPicType.nGoalHeight * 1000L / 254L      // dito
						: 0 )
			<< SwapLong(0)
			<< SwapLong(0);


	switch( rPicType.nBitsPerPixel )
	{
	case 1:		rStream.Write( aPal1, sizeof( aPal1 ));	break;
	case 4:		rStream.Write( aPal4, sizeof( aPal4 ));	break;
	case 8:		rStream.Write( aPal8, sizeof( aPal8 ));	break;
	}
}

/*  */

		// wandel die ASCII-HexCodes in binaere Zeichen um. Werden
		// ungueltige Daten gefunden (Zeichen ausser 0-9|a-f|A-F, so
		// wird USHRT_MAX returnt, ansonsten die Anzahl der umgewandelten Ze.
xub_StrLen SvxRTFParser::HexToBin( String& rToken )
{
	// dann mache aus den Hex-Werten mal "Binare Daten"
	// (missbrauche den String als temp Buffer)
	if( rToken.Len() & 1 )		// ungerade Anzahl, mit 0 auffuellen
		rToken += '0';

	xub_StrLen n, nLen;
	sal_Unicode nVal;
	BOOL bValidData = TRUE;
	const sal_Unicode* pStr = rToken.GetBufferAccess();
	sal_Char* pData = (sal_Char*)pStr;
	for( n = 0, nLen = rToken.Len(); n < nLen; ++n, ++pStr )
	{
		if( ((nVal = *pStr) >= '0') && ( nVal <= '9') )
			nVal -= '0';
		else if( (nVal >= 'A') && (nVal <= 'F') )
			nVal -= 'A' - 10;
		else if( (nVal >= 'a') && (nVal <= 'f') )
			nVal -= 'a' - 10;
		else
		{
			DBG_ASSERT( !this, "ungueltiger Hex-Wert" );
			bValidData = FALSE;
			break;
		}

		if( n & 1 )
			*(pData++) |= nVal & 0x0f;
		else
			*(pData) = sal::static_int_cast< char >( ( nVal << 4 ) & 0xf0 );
	}
	// the len div 2, because 2 character are one byte
	return bValidData ? nLen / 2  : STRING_NOTFOUND;
}

BOOL SvxRTFParser::ReadBmpData( Graphic& rGrf, SvxRTFPictureType& rPicType )
{
	// die alten Daten loeschen
	rGrf.Clear();
//	ULONG nBmpSize = 0;

	rtl_TextEncoding eOldEnc = GetSrcEncoding();
	SetSrcEncoding( RTL_TEXTENCODING_MS_1252 );

	const sal_Char* pFilterNm = 0;
	SvCacheStream* pTmpFile = 0;

	int nToken = 0; 
    bool bValidBmp = true, bFirstTextToken = true;
	int _nOpenBrakets = 1,		// die erste wurde schon vorher erkannt !!
		nValidDataBraket = 1;

	if( RTF_SHPPICT == GetStackPtr(0)->nTokenId )
		++nValidDataBraket;

	while( _nOpenBrakets && IsParserWorking() && bValidBmp )
	{
		nToken = GetNextToken();
		USHORT nVal = USHORT( nTokenValue );
		switch( nToken )
		{
		case '}':		--_nOpenBrakets;	break;
		case '{':
			{
				if( RTF_IGNOREFLAG != GetNextToken() )
					nToken = SkipToken( -1 );
				else if( RTF_UNKNOWNCONTROL != GetNextToken() )
					nToken = SkipToken( -2 );
				else
				{
					// gleich herausfiltern
					ReadUnknownData();
					nToken = GetNextToken();
					if( '}' != nToken )
						eState = SVPAR_ERROR;
					break;
				}
				++_nOpenBrakets;
			}
			break;

		case RTF_MACPICT:
			{
				rPicType.eStyle = SvxRTFPictureType::MAC_QUICKDRAW;
				// Mac-Pict bekommt einen leeren Header voran
				pTmpFile = new SvCacheStream;
				ByteString aStr;
				aStr.Fill( 512, '\0' );
				pTmpFile->Write( aStr.GetBuffer(), aStr.Len() );
				pFilterNm = "PCT";
			}
			break;

		case RTF_EMFBLIP:
		case RTF_WMETAFILE:
		case RTF_PNGBLIP:
		case RTF_JPEGBLIP:
		case RTF_WBITMAP:
		case RTF_OSMETAFILE:
		case RTF_DIBITMAP:
			{
				switch( nToken )
				{
				case RTF_EMFBLIP:
					rPicType.eStyle = SvxRTFPictureType::ENHANCED_MF;
					pFilterNm = "EMF";
					break;
				case RTF_WMETAFILE:
					rPicType.eStyle = SvxRTFPictureType::WIN_METAFILE;
					pFilterNm = "WMF";
					break;
				case RTF_PNGBLIP:
					rPicType.eStyle = SvxRTFPictureType::RTF_PNG;
					pFilterNm = "PNG";
					break;
				case RTF_JPEGBLIP:
					rPicType.eStyle = SvxRTFPictureType::RTF_JPG;
					pFilterNm = "JPG";
					break;

				case RTF_WBITMAP:
					rPicType.eStyle = SvxRTFPictureType::RTF_BITMAP;
					break;
				case RTF_OSMETAFILE:
					rPicType.eStyle = SvxRTFPictureType::OS2_METAFILE;
					break;
				case RTF_DIBITMAP:
					rPicType.eStyle = SvxRTFPictureType::RTF_DI_BMP;
					break;
				}

				rPicType.nType = nVal;
				pTmpFile = new SvCacheStream;
			}
			break;

		case RTF_PICW:				rPicType.nWidth = nVal; break;
		case RTF_PICH:				rPicType.nHeight = nVal; break;
		case RTF_WBMBITSPIXEL:		rPicType.nBitsPerPixel = nVal; break;
		case RTF_WBMPLANES: 		rPicType.nPlanes = nVal; break;
		case RTF_WBMWIDTHBYTES:		rPicType.nWidthBytes = nVal; break;
		case RTF_PICWGOAL:			rPicType.nGoalWidth = nVal; break;
		case RTF_PICHGOAL:			rPicType.nGoalHeight = nVal; break;
		case RTF_BIN:
            rPicType.nMode = SvxRTFPictureType::BINARY_MODE;
			rPicType.uPicLen = nTokenValue;
            if (rPicType.uPicLen)
            {
                ULONG nPos = rStrm.Tell();
                nPos = nPos;
                rStrm.SeekRel(-1);
                sal_uInt8 aData[4096];
                ULONG nSize = sizeof(aData);

                while (rPicType.uPicLen > 0)
                {
                    if (rPicType.uPicLen < nSize)
                        nSize = rPicType.uPicLen;
                    
                    rStrm.Read(aData, nSize);
                    pTmpFile->Write(aData, nSize);
                    rPicType.uPicLen -= nSize;
                }
                nNextCh = GetNextChar();
                bValidBmp = !pTmpFile->GetError();
                nPos = rStrm.Tell();
                nPos = nPos;
            }
            break;
		case RTF_PICSCALEX:			rPicType.nScalX = nVal; break;
		case RTF_PICSCALEY:			rPicType.nScalY = nVal; break;
		case RTF_PICSCALED: 		break;

		case RTF_PICCROPT:			rPicType.nCropT = (short)nTokenValue; break;
		case RTF_PICCROPB:			rPicType.nCropB = (short)nTokenValue; break;
		case RTF_PICCROPL:			rPicType.nCropL = (short)nTokenValue; break;
		case RTF_PICCROPR:			rPicType.nCropR = (short)nTokenValue; break;

		case RTF_TEXTTOKEN:
			// JP 26.06.98: Bug #51719# - nur TextToken auf 1. Ebene
			//				auswerten. Alle anderen sind irgendwelche
			//				nicht auszuwertende Daten
			if( nValidDataBraket != _nOpenBrakets )
				break;

			if( bFirstTextToken )
			{
				switch( rPicType.eStyle )
				{
				case SvxRTFPictureType::RTF_BITMAP:
					// erstmal die Header und Info-Struktur schreiben
					if( pTmpFile )
						::WriteBMPHeader( *pTmpFile, rPicType );
					break;
				default:
					break;
				}
				bFirstTextToken = FALSE;
			}

			if( pTmpFile && SvxRTFPictureType::HEX_MODE == rPicType.nMode )
			{
				xub_StrLen nTokenLen = HexToBin( aToken );
				if( STRING_NOTFOUND == nTokenLen )
					bValidBmp = FALSE;
				else
				{
					pTmpFile->Write( (sal_Char*)aToken.GetBuffer(),
										nTokenLen );
					bValidBmp = 0 == pTmpFile->GetError();
				}
			}
			break;
		}
	}

	if (pTmpFile)
	{
        //#i20775#
        if (pTmpFile->Tell() == 0)
            bValidBmp = false;

		if( bValidBmp )
		{
			GraphicFilter* pGF = ::GetGrfFilter();
			USHORT nImportFilter = GRFILTER_FORMAT_DONTKNOW;

			if( pFilterNm )
			{
				String sTmp;
				for( USHORT n = pGF->GetImportFormatCount(); n; )
				{
					sTmp = pGF->GetImportFormatShortName( --n );
					if( sTmp.EqualsAscii( pFilterNm ))
					{
						nImportFilter = n;
						break;
					}
				}
			}

			String sTmpStr;
			pTmpFile->Seek( STREAM_SEEK_TO_BEGIN );
			bValidBmp = 0 == pGF->ImportGraphic( rGrf, sTmpStr, *pTmpFile,
												nImportFilter );
		}
		delete pTmpFile;
	}

	if( !bValidBmp )
	{
		rGrf.Clear();
        //TODO  If nToken were not initialized to 0 above, it would potentially
        // be used uninitialized here (if IsParserWorking() is false at the
        // start of the while loop above):
		if( '}' != nToken )
			SkipGroup();
	}
	else
	{
		switch( rPicType.eStyle )
		{
//??		ENHANCED_MF,		// in den Pict.Daten steht ein Enhanced-Metafile
		case SvxRTFPictureType::RTF_PNG:
		case SvxRTFPictureType::RTF_JPG:
			{
				const MapMode aMap( MAP_100TH_MM );
			 	Size aSize( rGrf.GetPrefSize() );
				if( MAP_PIXEL == rGrf.GetPrefMapMode().GetMapUnit() )
					aSize = Application::GetDefaultDevice()->PixelToLogic(
										aSize, aMap );
				else
					aSize = OutputDevice::LogicToLogic( aSize,
										rGrf.GetPrefMapMode(), aMap );
				rPicType.nWidth = sal::static_int_cast< USHORT >(aSize.Width());
				rPicType.nHeight = sal::static_int_cast< USHORT >(
                    aSize.Height());
			}
			break;
		default:
			break;
		}

#ifdef DEBUG_JP
		new GrfWindow( rGrf );
#endif
	}
	SetSrcEncoding( eOldEnc );

	SkipToken( -1 );		// die schliesende Klammer wird "oben" ausgewertet
	return bValidBmp;
}

	// alle Werte auf default; wird nach einlesen der Bitmap aufgerufen !
void SvxRTFPictureType::ResetValues()
{	// setze alle Werte RTF-Defaults
	eStyle = RTF_BITMAP;
	nMode = HEX_MODE;
	nType = nGoalWidth = nGoalHeight = 0;
	nWidth = nHeight = nWidthBytes = 0;
	uPicLen = 0;
	nBitsPerPixel = nPlanes = 1;
	nScalX = nScalY = 100;		// Skalierung in Prozent
	nCropT = nCropB = nCropL = nCropR = 0;
}

/* vi:set tabstop=4 shiftwidth=4 expandtab: */
