diff options
| -rw-r--r-- | sc/source/core/data/stlsheet.cxx | 8 | ||||
| -rw-r--r-- | sc/source/filter/excel/biffdump.cxx | 9864 | ||||
| -rw-r--r-- | sc/source/filter/excel/xlpage.cxx | 206 | ||||
| -rw-r--r-- | sc/source/filter/html/htmlimp.cxx | 4 | ||||
| -rw-r--r-- | sc/source/ui/app/transobj.cxx | 2 | ||||
| -rw-r--r-- | sc/source/ui/inc/printfun.hxx | 2 | ||||
| -rw-r--r-- | sc/source/ui/view/printfun.cxx | 4 |
7 files changed, 9982 insertions, 108 deletions
diff --git a/sc/source/core/data/stlsheet.cxx b/sc/source/core/data/stlsheet.cxx index 37dce231cbaf..bad2c664cc4d 100644 --- a/sc/source/core/data/stlsheet.cxx +++ b/sc/source/core/data/stlsheet.cxx @@ -176,14 +176,8 @@ SfxItemSet& __EXPORT ScStyleSheet::GetItemSet() if ( pDoc && pDoc->IsLoadingDone() ) { // Setzen von sinnvollen Default-Werten: - // SfxPrinter* pPrinter = pDoc->GetPrinter(); SvxPageItem aPageItem( ATTR_PAGE ); - // #50536# PaperBin auf Default lassen, - // nicht auf aktuelle Drucker-Einstellung umsetzen - // SvxSizeItem aPaperSizeItem(ATTR_PAGE_SIZE,SvxPaperInfo::GetPaperSize(pPrinter) ); - - SvxPaper aDefaultPaper = SvxPaperInfo::GetDefaultSvxPaper( Application::GetSettings().GetLanguage() ); - SvxSizeItem aPaperSizeItem( ATTR_PAGE_SIZE, SvxPaperInfo::GetPaperSize(aDefaultPaper) ); + SvxSizeItem aPaperSizeItem( ATTR_PAGE_SIZE, SvxPaperInfo::GetDefaultPaperSize() ); SvxSetItem aHFSetItem( (const SvxSetItem&) diff --git a/sc/source/filter/excel/biffdump.cxx b/sc/source/filter/excel/biffdump.cxx new file mode 100644 index 000000000000..c3478cf8cb50 --- /dev/null +++ b/sc/source/filter/excel/biffdump.cxx @@ -0,0 +1,9864 @@ +/************************************************************************* + * + * 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: biffdump.cxx,v $ + * $Revision: 1.91 $ + * + * 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_sc.hxx" +#include "biffdump.hxx" + +#if EXC_INCL_DUMPER +#include <tools/stream.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/objsh.hxx> +#include <sot/storinfo.hxx> + +#include <string.h> +#include <stdlib.h> +#include <stdio.h> + +#include <rtl/math.hxx> +#include "document.hxx" +#include "global.hxx" +#include "fprogressbar.hxx" +#include "xlpivot.hxx" +#include "xicontent.hxx" +#include "imp_op.hxx" + +#define GETSTR(s) ByteString( s, RTL_TEXTENCODING_MS_1252 ) + +static const sal_Char* __pHexPrefix = "0x"; +static const sal_Char* __pBinPrefix = "0b"; +static const sal_Char* pU = "UNKNOWN "; + +const sal_Char* Biff8RecDumper::pLevelPreString = " "; +const sal_Char* Biff8RecDumper::pLevelPreStringNT = pLevelPreString + strlen( pLevelPreString ); +UINT32 Biff8RecDumper::nInstances = 0; +sal_Char* Biff8RecDumper::pBlankLine = NULL; +const UINT16 Biff8RecDumper::nLenBlankLine = 255; +const UINT16 Biff8RecDumper::nRecCnt = 0x2020; +UINT8* Biff8RecDumper::pCharType = NULL; +UINT8* Biff8RecDumper::pCharVal = NULL; + +static const UINT16 nLevelInc = 1; + +static UINT16 nXFCount = 0; + +static UINT16 nSXLISize[2] = {0, 0}; // array size for SXLI records [rows/cols] +static UINT16 nSXLIIndex = 0; // current index for SXLI records + +// ============================================================================ + +namespace { + +// decimal -------------------------------------------------------------------- + +inline void lclAppendDec( ByteString& rStr, sal_uInt8 nData ) +{ + rStr.Append( ByteString::CreateFromInt32( nData ) ); +} + +inline void lclAppendDec( ByteString& rStr, sal_Int8 nData ) +{ + rStr.Append( ByteString::CreateFromInt32( nData ) ); +} + +inline void lclAppendDec( ByteString& rStr, sal_uInt16 nData ) +{ + rStr.Append( ByteString::CreateFromInt32( nData ) ); +} + +inline void lclAppendDec( ByteString& rStr, sal_Int16 nData ) +{ + rStr.Append( ByteString::CreateFromInt32( nData ) ); +} + +inline void lclAppendDec( ByteString& rStr, sal_uInt32 nData ) +{ + rStr.Append( ByteString::CreateFromInt64( nData ) ); +} + +inline void lclAppendDec( ByteString& rStr, sal_Int32 nData ) +{ + rStr.Append( ByteString::CreateFromInt32( nData ) ); +} + +inline void lclAppendDec( ByteString& rStr, float fData ) +{ + rStr.Append( ByteString( ::rtl::math::doubleToString( fData, rtl_math_StringFormat_G, 15, '.', true ) ) ); +} + +inline void lclAppendDec( ByteString& rStr, double fData ) +{ + rStr.Append( ByteString( ::rtl::math::doubleToString( fData, rtl_math_StringFormat_G, 15, '.', true ) ) ); +} + +// hexadecimal ---------------------------------------------------------------- + +void lclAppendHex( ByteString& rStr, sal_uInt8 nData, bool bPrefix = true ) +{ + static const sal_Char spcHexDigits[] = "0123456789ABCDEF"; + static const ByteString saPrefix( "0x" ); + + if( bPrefix ) + rStr.Append( saPrefix ); + rStr.Append( spcHexDigits[ (nData >> 4) & 0x0F ] ).Append( spcHexDigits[ nData & 0x0F ] ); +} + +inline void lclAppendHex( ByteString& rStr, sal_Int8 nData, bool bPrefix = true ) +{ + lclAppendHex( rStr, static_cast< sal_uInt8 >( nData ), bPrefix ); +} + +void lclAppendHex( ByteString& rStr, sal_uInt16 nData, bool bPrefix = true ) +{ + lclAppendHex( rStr, static_cast< sal_uInt8 >( nData >> 8 ), bPrefix ); + lclAppendHex( rStr, static_cast< sal_uInt8 >( nData ), false ); +} + +inline void lclAppendHex( ByteString& rStr, sal_Int16 nData, bool bPrefix = true ) +{ + lclAppendHex( rStr, static_cast< sal_uInt16 >( nData ), bPrefix ); +} + +void lclAppendHex( ByteString& rStr, sal_uInt32 nData, bool bPrefix = true ) +{ + lclAppendHex( rStr, static_cast< sal_uInt16 >( nData >> 16 ), bPrefix ); + lclAppendHex( rStr, static_cast< sal_uInt16 >( nData ), false ); +} + +inline void lclAppendHex( ByteString& rStr, sal_Int32 nData, bool bPrefix = true ) +{ + lclAppendHex( rStr, static_cast< sal_uInt32 >( nData ), bPrefix ); +} + +inline void lclAppendHex( ByteString& rStr, double fData, bool bPrefix = true ) +{ + const sal_uInt32* pnData = reinterpret_cast< const sal_uInt32* >( &fData ); + lclAppendHex( rStr, pnData[ 0 ], bPrefix ); + lclAppendHex( rStr, pnData[ 1 ], false ); +} + +// others --------------------------------------------------------------------- + +void lclAppendGuid( ByteString& rStr, const XclGuid& rGuid ) +{ + lclAppendHex( rStr, SVBT32ToUInt32( rGuid.mpnData ), false ); + rStr.Append( '-' ); + lclAppendHex( rStr, SVBT16ToShort( rGuid.mpnData + 4 ), false ); + rStr.Append( '-' ); + lclAppendHex( rStr, SVBT16ToShort( rGuid.mpnData + 6 ), false ); + rStr.Append( '-' ); + lclAppendHex( rStr, rGuid.mpnData[ 8 ], false ); + lclAppendHex( rStr, rGuid.mpnData[ 9 ], false ); + rStr.Append( '-' ); + lclAppendHex( rStr, rGuid.mpnData[ 10 ], false ); + lclAppendHex( rStr, rGuid.mpnData[ 11 ], false ); + lclAppendHex( rStr, rGuid.mpnData[ 12 ], false ); + lclAppendHex( rStr, rGuid.mpnData[ 13 ], false ); + lclAppendHex( rStr, rGuid.mpnData[ 14 ], false ); + lclAppendHex( rStr, rGuid.mpnData[ 15 ], false ); +} + +} // namespace + +// ============================================================================ + +static void __AddHexNibble( ByteString& r, UINT8 nVal ) +{ + const sal_Char pH[] = "0123456789ABCDEF"; + + nVal &= 0x0F; + + r += pH[ nVal ]; +} + + +static void __AddPureHex( ByteString& r, UINT8 nVal ) +{ + __AddHexNibble( r, nVal >> 4 ); + __AddHexNibble( r, nVal ); +} + + +static void __AddHex( ByteString& r, UINT8 nVal ) +{ + r += __pHexPrefix; + __AddHexNibble( r, nVal >> 4 ); + __AddHexNibble( r, nVal ); +} + + +static void __AddPureHex( ByteString& r, UINT16 nVal ) +{ + __AddHexNibble( r, ( UINT8 ) ( nVal >> 12 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 8 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 4 ) ); + __AddHexNibble( r, ( UINT8 ) nVal ); +} + + +static void __AddHex( ByteString& r, UINT16 nVal ) +{ + r += __pHexPrefix; + __AddHexNibble( r, ( UINT8 ) ( nVal >> 12 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 8 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 4 ) ); + __AddHexNibble( r, ( UINT8 ) nVal ); +} + + +static void __AddPureHex( ByteString& r, UINT32 nVal ) +{ + __AddHexNibble( r, ( UINT8 ) ( nVal >> 28 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 24 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 20 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 16 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 12 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 8 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 4 ) ); + __AddHexNibble( r, ( UINT8 ) nVal ); +} + + +static void __AddHex( ByteString& r, UINT32 nVal ) +{ + r += __pHexPrefix; + __AddHexNibble( r, ( UINT8 ) ( nVal >> 28 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 24 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 20 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 16 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 12 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 8 ) ); + __AddHexNibble( r, ( UINT8 ) ( nVal >> 4 ) ); + __AddHexNibble( r, ( UINT8 ) nVal ); +} + + +static void __AddHex( ByteString& r, INT32 nVal ) +{ + __AddHex( r, (UINT32) nVal ); +} + + +static void __AddPureBinNibble( ByteString& r, UINT8 nVal ) +{ + nVal <<= 4; + for( int n = 4 ; n ; n-- ) + { + r += ( nVal & 0x80 )? "1" : "0"; + nVal <<= 1; + } +} + + +static void __AddPureBin( ByteString& r, UINT8 nVal ) +{ + __AddPureBinNibble( r, nVal >> 4 ); + r += " "; + __AddPureBinNibble( r, nVal ); +} + + +static void __AddPureBin( ByteString& r, UINT16 nVal ) +{ + const sal_Char* pIn = " "; + __AddPureBin( r, ( UINT8 ) ( nVal >> 8 ) ); + r += pIn; + __AddPureBin( r, ( UINT8 ) nVal ); +} + + +static void __AddPureBin( ByteString& r, UINT32 nVal ) +{ + const sal_Char* pIn = " "; + __AddPureBin( r, ( UINT8 ) ( nVal >> 24 ) ); + r += pIn; + __AddPureBin( r, ( UINT8 ) ( nVal >> 16 ) ); + r += pIn; + __AddPureBin( r, ( UINT8 ) ( nVal >> 8 ) ); + r += pIn; + __AddPureBin( r, ( UINT8 ) nVal ); +} + + +inline static void __AddDec( ByteString& r, UINT32 n ) +{ + sal_Char p[ 32 ]; + sprintf( p, "%u", n ); // #100211# - checked + r += p; +} + + +inline static void __AddDec( ByteString& r, UINT16 n ) +{ + __AddDec( r, ( UINT32 ) n ); +} + + +inline static void __AddDec( ByteString& r, UINT8 n ) +{ + __AddDec( r, ( UINT32 ) n ); +} + + +inline static void __AddDec( ByteString& r, INT32 n ) +{ + sal_Char p[ 32 ]; + sprintf( p, "%d", n ); // #100211# - checked + r += p; +} + + +inline static void __AddDec( ByteString& r, INT16 n ) +{ + __AddDec( r, ( INT32 ) n ); +} + +inline static void __AddDec( ByteString& r, sal_Int8 n ) +{ + __AddDec( r, ( INT32 ) n ); +} + + +static void __AddDec( ByteString& r, UINT32 nVal, UINT16 nNumOfDig, sal_Char c = ' ' ) +{ + ByteString t; + ByteString aVal; + __AddDec( aVal, nVal ); + if( nNumOfDig > (UINT16) aVal.Len() ) + t.Fill( nNumOfDig - (UINT16) aVal.Len(), c ); + r += t; + r += aVal; +} + + +inline static void __AddDec1616( ByteString& r, UINT32 n ) +{ + __AddDec( r, (UINT16)(n >> 16) ); + r += '.'; + __AddDec( r, (UINT16)(n & 0xFFFF) ); +} + + +static void __AddDouble( ByteString& r, const double f ) +{ + r += ByteString( ::rtl::math::doubleToString( f, rtl_math_StringFormat_G, 15, '.', TRUE ) ); +} + + +static inline void __AddRK( ByteString& rString, sal_Int32 nRKValue ) +{ + __AddDouble( rString, XclTools::GetDoubleFromRK( nRKValue ) ); +} + + +inline static void __Add16p16( ByteString& r, UINT32 n ) +{ + __AddDouble( r, double(n) / 65536.0 ); +} + + +static void lcl_AddRef( ByteString& rStr, sal_uInt16 nCol, sal_uInt16 nRow ) +{ + ScAddress aRef( static_cast< SCCOL >( nCol ), static_cast< SCROW >( nRow ), 0 ); + rStr.Append( GETSTR( aRef.GetColRowString() ) ); +} + + +static void lcl_AddRangeRef( ByteString& rStr, sal_uInt16 nCol1, sal_uInt16 nRow1, sal_uInt16 nCol2, sal_uInt16 nRow2 ) +{ + lcl_AddRef( rStr, nCol1, nRow1 ); + if( (nCol1 != nCol2) || (nRow1 != nRow2) ) + { + rStr.Append( ':' ); + lcl_AddRef( rStr, nCol2, nRow2 ); + } +} + + +static void __AddCellHead( ByteString& r, const UINT16 nC, const UINT16 nR, const UINT16 nXF ) +{ + lcl_AddRef( r, (UINT8) nC, nR ); + r += " (XF="; + __AddDec( r, nXF ); + r += ')'; +} + + +inline static void lcl_AddFlag( + ByteString& rString, bool bFlag, const sal_Char* pcTrue = "true", const sal_Char* pcFalse = "false" ) +{ + rString += (bFlag ? pcTrue : pcFalse); +} + +inline static void lcl_AddOnOff( ByteString& rString, bool bFlag ) +{ + lcl_AddFlag( rString, bFlag, "on", "off" ); +} + + +static void lcl_AddEnum( + ByteString& rString, long nValue, const sal_Char* const ppcEnums[], long nSize, + const sal_Char* pcDefault = 0, long nOffset = 0 ) +{ + nValue -= nOffset; + const sal_Char* pcText = "!unknown!"; + if( (0 <= nValue) && (nValue < nSize) && ppcEnums[ nValue ] ) + pcText = ppcEnums[ nValue ]; + else if( pcDefault ) + pcText = pcDefault; + if( *pcText ) // nonempty string + rString.Append( " (" ).Append( pcText ).Append( ')' ); +} + + +namespace { + +void lclDumpString( SvStream& rOutStrm, const ByteString& rData ) +{ + ByteString aOutStr; + xub_StrLen nIdx = 0; + for( ; (nIdx < rData.Len()) && (aOutStr.Len() < 80); ++nIdx ) + { + sal_Char cChar = rData.GetChar( nIdx ); + if( 32 <= cChar ) + aOutStr.Append( cChar ); + else + { + aOutStr.Append( '<' ); + __AddHex( aOutStr, static_cast< sal_uInt8 >( cChar ) ); + aOutStr.Append( '>' ); + } + } + rOutStrm << aOutStr.GetBuffer(); + if( nIdx < rData.Len() ) + rOutStrm << "<...>"; +} + +void lclDumpStringValue( SvStream& rOutStrm, const ByteString& rName, const ByteString& rData ) +{ + rOutStrm << rName.GetBuffer() << "='"; + lclDumpString( rOutStrm, rData ); + rOutStrm << '\''; +} + +void lclDumpString( SvStream& rOutStrm, const String& rData ) +{ + ByteString aOutStr; + xub_StrLen nIdx = 0; + for( ; (nIdx < rData.Len()) && (aOutStr.Len() < 80); ++nIdx ) + { + sal_Unicode cChar = rData.GetChar( nIdx ); + if( (32 <= cChar) && (cChar <= 255) ) + aOutStr.Append( static_cast< sal_Char >( cChar ) ); + else + { + aOutStr.Append( '<' ); + if( cChar < 256 ) + __AddHex( aOutStr, static_cast< sal_uInt8 >( cChar ) ); + else + __AddHex( aOutStr, static_cast< sal_uInt16 >( cChar ) ); + aOutStr.Append( '>' ); + } + } + rOutStrm << aOutStr.GetBuffer(); + if( nIdx < rData.Len() ) + rOutStrm << "<...>"; +} + +void lclDumpStringValue( SvStream& rOutStrm, const ByteString& rName, const String& rData ) +{ + rOutStrm << rName.GetBuffer() << "='"; + lclDumpString( rOutStrm, rData ); + rOutStrm << '\''; +} + +} // namespace + + +IdRangeList::~IdRangeList() +{ + Clear(); +} + + +void IdRangeList::Clear( void ) +{ + IdRange* p = ( IdRange* ) First(); + + while( p ) + { + delete p; + p = ( IdRange* ) Next(); + } + + List::Clear(); +} + +// ============================================================================ +// +// H E L P E R O B J E C T S +// +// ============================================================================ + +namespace { + +// ---------------------------------------------------------------------------- + +class XclDumpStreamHeader +{ +public: + explicit XclDumpStreamHeader( SvStream& rInStrm, SvStream& rOutStrm, const String& rStrmName, const String& rStrmPath ); + ~XclDumpStreamHeader(); + inline ULONG GetStreamLen() const { return mnStrmLen; } + +private: + SvStream& mrOutStrm; + String maStrmName; + String maStrmPath; + ByteString maSeparator; + ULONG mnStrmLen; +}; + +XclDumpStreamHeader::XclDumpStreamHeader( SvStream& rInStrm, SvStream& rOutStrm, const String& rStrmName, const String& rStrmPath ) : + mrOutStrm( rOutStrm ), + maStrmName( rStrmName ), + maStrmPath( rStrmPath ), + mnStrmLen( 0 ) +{ + maSeparator.Assign( '+' ).Expand( 78, '-' ); + + rInStrm.Seek( STREAM_SEEK_TO_END ); + mnStrmLen = rInStrm.Tell(); + rInStrm.Seek( STREAM_SEEK_TO_BEGIN ); + + ByteString aLine; + lclAppendDec( aLine, mnStrmLen ); + + mrOutStrm << maSeparator.GetBuffer() << "\n"; + mrOutStrm << "| STREAM-BEGIN\n"; + mrOutStrm << "| "; + lclDumpStringValue( mrOutStrm, "stream-name", maStrmName ); + mrOutStrm << "\n| "; + lclDumpStringValue( mrOutStrm, "stream-path", maStrmPath ); + mrOutStrm << "\n| stream-len=" << aLine.GetBuffer() << "\n"; + mrOutStrm << "|\n\n"; +} + +XclDumpStreamHeader::~XclDumpStreamHeader() +{ + mrOutStrm << "|\n"; + mrOutStrm << "| "; + lclDumpStringValue( mrOutStrm, "stream-name", maStrmName ); + mrOutStrm << "\n| "; + lclDumpStringValue( mrOutStrm, "stream-path", maStrmPath ); + mrOutStrm << "\n"; + mrOutStrm << "| STREAM-END\n"; + mrOutStrm << maSeparator.GetBuffer() << "\n\n"; +} + +// ---------------------------------------------------------------------------- + +class XclDumpStorageHeader +{ +public: + explicit XclDumpStorageHeader( SotStorage& rInStrg, SvStream& rOutStrm, const String& rStrgPath ); + ~XclDumpStorageHeader(); + +private: + SvStream& mrOutStrm; + String maStrgName; + String maStrgPath; + ByteString maSeparator; +}; + +XclDumpStorageHeader::XclDumpStorageHeader( SotStorage& rInStrg, SvStream& rOutStrm, const String& rStrgPath ) : + mrOutStrm( rOutStrm ), + maStrgName( rInStrg.GetName() ), + maStrgPath( rStrgPath ) +{ + maSeparator.Assign( "++" ).Expand( 78, '=' ); + + mrOutStrm << maSeparator.GetBuffer() << "\n"; + mrOutStrm << "|| STORAGE-BEGIN\n"; + mrOutStrm << "|| "; + lclDumpStringValue( mrOutStrm, "storage-name", maStrgName ); + mrOutStrm << "\n|| "; + lclDumpStringValue( mrOutStrm, "storage-path", maStrgPath ); + mrOutStrm << "\n"; + + SvStorageInfoList aInfoList; + rInStrg.FillInfoList( &aInfoList ); + ByteString aLine; + lclAppendDec( aLine, aInfoList.Count() ); + mrOutStrm << "|| directory-size=" << aLine.GetBuffer() << "\n"; + + for( ULONG nInfo = 0; nInfo < aInfoList.Count(); ++nInfo ) + { + SvStorageInfo& rInfo = aInfoList.GetObject( nInfo ); + mrOutStrm << "|| type="; + if( rInfo.IsStream() ) + mrOutStrm << "stream "; + else if( rInfo.IsStorage() ) + mrOutStrm << "storage "; + else + mrOutStrm << "unknown "; + lclDumpStringValue( mrOutStrm, "name", rInfo.GetName() ); + mrOutStrm << "\n"; + } + + mrOutStrm << "||\n\n"; +} + +XclDumpStorageHeader::~XclDumpStorageHeader() +{ + mrOutStrm << "||\n"; + mrOutStrm << "|| "; + lclDumpStringValue( mrOutStrm, "storage-name", maStrgName ); + mrOutStrm << "\n|| "; + lclDumpStringValue( mrOutStrm, "storage-path", maStrgPath ); + mrOutStrm << "\n"; + mrOutStrm << "|| STORAGE-END\n"; + mrOutStrm << maSeparator.GetBuffer() << "\n\n"; +} + +// ---------------------------------------------------------------------------- + +} + +// ============================================================================ +// +// ============================================================================ + +void Biff8RecDumper::Print( const ByteString& r ) +{ + DBG_ASSERT( pDumpStream, "-Biff8RecDumper::Print(): Stream is wech!" ); + *pDumpStream << '\n' << pLevelPre; + pDumpStream->Write( r.GetBuffer(), r.Len() ); +} + + +void Biff8RecDumper::Print( const sal_Char* p ) +{ + DBG_ASSERT( pDumpStream, "-Biff8RecDumper::Print(): Stream is wech!" ); + DBG_ASSERT( p, "-Biff8RecDumper::Print(): ByteString is wech!" ); + + *pDumpStream << '\n' << pLevelPre << p; +} + + +static const sal_Char* GetSeriesType( const UINT16 n ) +{ + const sal_Char* p; + + switch( n ) + { + case 0: p = "(date) "; break; + case 1: p = "(numeric) "; break; + case 2: p = "(sequence)"; break; + case 3: p = "(text) "; break; + default: p = "(unknown) "; + } + + return p; +} + + +static const sal_Char* GetLineType( const UINT16 n ) +{ + const sal_Char* p; + + switch( n ) + { + case 0: p = "solid"; break; + case 1: p = "dash"; break; + case 2: p = "dot"; break; + case 3: p = "dash-dot"; break; + case 4: p = "dash-dot-dot"; break; + case 5: p = "none"; break; + case 6: p = "dark gray pattern"; break; + case 7: p = "medium gray pattern"; break; + case 8: p = "light gray pattern"; break; + default: p = pU; + } + + return p; +} + + +static ByteString GetRGB( const UINT32 n ) +{ + ByteString s; + + s += "R"; + __AddDec( s, ( UINT8 ) n ); + s += " G"; + __AddDec( s, ( UINT8 ) ( n >> 8 ) ); + s += " B"; + __AddDec( s, ( UINT8 ) ( n >> 16 ) ); + + return s; +} + + +static void AddRef( ByteString& t, UINT16 nRow, UINT16 nC, BOOL bName, UINT16 nTab = 0xFFFF ) +{ + BOOL bColRel = ( nC & 0x4000 ) != 0; + BOOL bRowRel = ( nC & 0x8000 ) != 0; + UINT8 nCol = (UINT8) nC; + INT8 nRelCol = (INT8) nCol; + INT16 nRelRow = (INT16) nRow; + + if( nTab < 0xFFFF ) + { + t += "XTI("; + __AddDec( t, nTab ); + t += ")!"; + } + + if( bName ) + { + // dump relative: [Column|Row] + // [C-1,R-1] = one column left, one row up + // [C+1,R+1] = one column right, one row down + // [C,R] = same column/row + // [C=B,R=2] = absolute column B/row 2 + t += "[C"; + if( bColRel ) + { + if( nRelCol > 0 ) + t += '+'; + if( nRelCol != 0 ) + __AddDec( t, (INT16)nRelCol ); + } + else + { + t += '='; + t += GETSTR( ::ScScColToAlpha( nCol ) ); + } + + t += ",R"; + if( bRowRel ) + { + if( nRelRow > 0 ) + t += "+"; + if( nRelRow != 0 ) + __AddDec( t, nRelRow ); + } + else + { + t += '='; + __AddDec( t, (INT32)nRow + 1 ); + } + t += ']'; + } + else + { + if( !bColRel ) + t += '$'; + t += GETSTR( ::ScColToAlpha( nCol ) ); + if( !bRowRel ) + t += '$'; + __AddDec( t, (UINT16)(nRow + 1) ); + } +} + +static void AddRangeRef( ByteString& t, UINT16 nRow1, UINT16 nC1, UINT16 nRow2, UINT16 nC2, BOOL bName, UINT16 nTab = 0xFFFF ) +{ + AddRef( t, nRow1, nC1, bName, nTab ); + if( (nRow1 != nRow2) || (nC1 != nC2) ) + { + t += ':'; + AddRef( t, nRow2, nC2, bName ); + } +} + + + +static BOOL AddUNICODEString( ByteString& rStr, XclImpStream& rStrm, const BOOL b16BitLen = TRUE, UINT16 nLen = 0, ByteString* pRawName = 0 ) +{ + BOOL bRet = TRUE; + + if( !nLen ) + nLen = b16BitLen ? rStrm.ReaduInt16() : rStrm.ReaduInt8(); + UINT8 nGrbit = rStrm.ReaduInt8(); + + UINT32 nExtLen; + UINT16 nCrun; + bool b16Bit, bFarEast, bRichString; + rStrm.ReadUniStringExtHeader( b16Bit, bRichString, bFarEast, nCrun, nExtLen, nGrbit ); + + rStr += "(l="; + __AddDec( rStr, nLen ); + rStr += " f="; + __AddHex( rStr, nGrbit ); + rStr += " "; + rStr += b16Bit ? "16-Bit" : "8-Bit"; + + if( bRichString && bFarEast ) + rStr += " rich far-east"; + else if( bRichString && !bFarEast ) + rStr += " rich"; + else if ( !bRichString && bFarEast ) + rStr += " far-east"; + rStr += ") '"; + + ByteString aData( rStrm.ReadRawUniString( nLen, b16Bit ), RTL_TEXTENCODING_MS_1252 ); + if( pRawName ) *pRawName = aData; + + xub_StrLen nIndex = 0; + while( (nIndex < aData.Len()) && (nIndex < 255) ) + { + UINT8 nChar = (UINT8)aData.GetChar( nIndex ); + if( nChar < ' ' ) + { + ByteString aIns( '<' ); + __AddHex( aIns, nChar ); + aIns += '>'; + aData.Erase( nIndex, 1 ).Insert( aIns, nIndex ); + nIndex += 5; + } + nIndex++; + } + + rStr += aData.Copy( 0, 255 ); + rStr += '\''; + if( aData.Len() > 255 ) + rStr += "..."; + + if( nCrun ) + { + rStr += " + "; + __AddDec( rStr, nCrun ); + rStr += " format blocks ("; + nCrun *= 4; + __AddDec( rStr, nCrun ); + rStr += " bytes)"; + rStrm.Ignore( nCrun ); + } + if( nExtLen ) + { + rStr += " + "; + __AddDec( rStr, nExtLen ); + rStr += " byte extended:"; + for( sal_uInt32 nIdx = 0; rStrm.IsValid() && (nIdx < nExtLen); ++nIdx ) + { + rStr.Append( ' ' ); + __AddPureHex( rStr, rStrm.ReaduInt8() ); + } + } + + return bRet; +} + + +DUMP_ERR::~DUMP_ERR() +{ + if( pHint ) + delete pHint; +} + + + + +#define Read1(rIn) (rIn).ReaduInt8() +#define Read2(rIn) (rIn).ReaduInt16() +#define Read4(rIn) (rIn).ReaduInt32() +#define Read8(rIn) (rIn).ReadDouble() +#define LINESTART() {t.Erase();t+=pPre;} +#define IGNORE(n) rIn.Ignore(n) +#define ADDBIN(n) __AddBin( t, Read##n( rIn ) ) +#define ADDHEX(n) __AddHex( t, Read##n( rIn ) ) +#define ADDDEC(n) __AddDec( t, Read##n( rIn ) ) +#define ADDDOUBLE() __AddDouble( t, rIn.ReadDouble() ) +#define ADD16P16() __Add16p16( t, Read4( rIn ) ) +#define ADDTEXT(T) t += T +#define PRINT() Print( t ) +#define PreDump(LEN) {rIn.PushPosition();ContDump(LEN);rIn.PopPosition();} +#define ADDCELLHEAD() {UINT16 nR,nC,nX;rIn>>nR>>nC>>nX;__AddCellHead(t,nC,nR,nX);} +#define STARTFLAG() {ADDTEXT( "flags=" ); __AddHex( t, __nFlags ); ADDTEXT( " " );} +#define ADDFLAG(mask,text) {if( __nFlags & mask ) t.Append( ' ' ).Append( text );} +#define ADDRESERVED(mask) ADDFLAG(mask,"!RESERVED!") + + +UINT16 Biff8RecDumper::DumpXF( XclImpStream& rStrm, const sal_Char* pPre ) +{ + ByteString t; // "t" needed by macros + + sal_uInt32 nBorder1, nBorder2; + sal_uInt16 nFont, nNumFmt, nTypeProt, nAlign, nMiscAttrib, nArea, __nFlags, nTmp; + rStrm >> nFont >> nNumFmt >> nTypeProt >> nAlign >> nMiscAttrib >> nBorder1 >> nBorder2 >> nArea; + bool bCell = !::get_flag( nTypeProt, EXC_XF_STYLE ); + + // XF type/parent + LINESTART(); + ::extract_value( nTmp, nTypeProt, 4, 12 ); + ADDTEXT( "index=#" ); __AddDec( t, nXFCount++ ); + ADDTEXT( " type=" ); lcl_AddFlag( t, bCell, "cell", "style" ); + ADDTEXT( " parent-xf=#" ); __AddDec( t, nTmp ); + PRINT(); + + // attribute used flags + LINESTART(); + ::extract_value( __nFlags, nMiscAttrib, 10, 6 ); + if( !bCell ) __nFlags ^= 0x3F; // in style XFs a 0 means used + ADDTEXT( "used " ); STARTFLAG(); + ADDFLAG( EXC_XF_DIFF_VALFMT, "numfmt" ); + ADDFLAG( EXC_XF_DIFF_FONT, "font" ); + ADDFLAG( EXC_XF_DIFF_ALIGN, "align" ); + ADDFLAG( EXC_XF_DIFF_BORDER, "border" ); + ADDFLAG( EXC_XF_DIFF_AREA, "area" ); + ADDFLAG( EXC_XF_DIFF_PROT, "prot" ); + PRINT(); + + // cell protection/font/number format + LINESTART(); + ADDTEXT( "cell-lock=" ); lcl_AddOnOff( t, ::get_flag( nTypeProt, EXC_XF_LOCKED ) ); + ADDTEXT( " hidden=" ); lcl_AddOnOff( t, ::get_flag( nTypeProt, EXC_XF_HIDDEN ) ); + ADDTEXT( " font=" ); __AddDec( t, nFont ); + ADDTEXT( " num-fmt=" ); __AddDec( t, nNumFmt ); + PRINT(); + + // alignment + LINESTART(); + ::extract_value( nTmp, nAlign, 0, 3 ); + ADDTEXT( "hor-align=" ); __AddDec( t, nTmp ); + ADDTEXT( " (" ); + switch( nTmp ) + { + case EXC_XF_HOR_GENERAL: ADDTEXT( "general" ); break; + case EXC_XF_HOR_LEFT: ADDTEXT( "left" ); break; + case EXC_XF_HOR_CENTER: ADDTEXT( "center" ); break; + case EXC_XF_HOR_RIGHT: ADDTEXT( "right" ); break; + case EXC_XF_HOR_FILL: ADDTEXT( "fill" ); break; + case EXC_XF_HOR_JUSTIFY: ADDTEXT( "justify" ); break; + case EXC_XF_HOR_CENTER_AS: ADDTEXT( "center-as" ); break; + case EXC_XF_HOR_DISTRIB: ADDTEXT( "distrib" ); break; + default: ADDTEXT( "!unknown!" ); + }; + ::extract_value( nTmp, nAlign, 4, 3 ); + ADDTEXT( ") ver-align=" ); __AddDec( t, nTmp ); + ADDTEXT( " (" ); + switch( nTmp ) + { + case EXC_XF_VER_TOP: ADDTEXT( "top" ); break; + case EXC_XF_VER_CENTER: ADDTEXT( "center" ); break; + case EXC_XF_VER_BOTTOM: ADDTEXT( "bottom" ); break; + case EXC_XF_VER_JUSTIFY: ADDTEXT( "justify" ); break; + case EXC_XF_VER_DISTRIB: ADDTEXT( "distrib" ); break; + default: ADDTEXT( "!unknown!" ); + }; + ADDTEXT( ") text-wrap=" ); lcl_AddOnOff( t, ::get_flag( nAlign, EXC_XF_LINEBREAK ) ); + PRINT(); + + LINESTART(); + ::extract_value( nTmp, nAlign, 8, 8 ); + ADDTEXT( "rotation=" ); __AddDec( t, nTmp ); + ADDTEXT( " (" ); + if( nTmp < 91 ) + { __AddDec( t, nTmp ); ADDTEXT( "\xB0" ); } + else if( nTmp < 181 ) + { __AddDec( t, static_cast< sal_Int32 >( 90 - nTmp ) ); ADDTEXT( "\xB0" ); } + else if( nTmp == EXC_ROT_STACKED ) + { ADDTEXT( "stacked" ); } + else + { ADDTEXT( "!unknown!" ); } + ::extract_value( nTmp, nMiscAttrib, 0, 4 ); + ADDTEXT( ") indent=" ); __AddDec( t, nTmp ); + ADDTEXT( " shrink=" ); lcl_AddOnOff( t, ::get_flag( nMiscAttrib, EXC_XF8_SHRINK ) ); + ::extract_value( nTmp, nMiscAttrib, 6, 2 ); + ADDTEXT( " text-dir=" ); __AddDec( t, nTmp ); + ADDTEXT( " (" ); + switch( nTmp ) + { + case EXC_XF_TEXTDIR_CONTEXT: ADDTEXT( "context" ); break; + case EXC_XF_TEXTDIR_LTR: ADDTEXT( "ltr" ); break; + case EXC_XF_TEXTDIR_RTL: ADDTEXT( "rtl" ); break; + default: ADDTEXT( "!unknown!" ); + }; + ADDTEXT( ")" ); + PRINT(); + + // border/area + LINESTART(); + ::extract_value( nTmp, nBorder1, 0, 4 ); + ADDTEXT( "left-line=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder1, 16, 7 ); + ADDTEXT( " color=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder1, 4, 4 ); + ADDTEXT( " right-line =" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder1, 23, 7 ); + ADDTEXT( " color=" ); __AddDec( t, nTmp ); + PRINT(); + LINESTART(); + ::extract_value( nTmp, nBorder1, 8, 4 ); + ADDTEXT( "top-line =" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder2, 0, 7 ); + ADDTEXT( " color=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder1, 12, 4 ); + ADDTEXT( " bottom-line=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder2, 7, 7 ); + ADDTEXT( " color=" ); __AddDec( t, nTmp ); + PRINT(); + LINESTART(); + ::extract_value( nTmp, nBorder2, 21, 4 ); + ADDTEXT( "diag-line=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nBorder2, 14, 7 ); + ADDTEXT( " color=" ); __AddDec( t, nTmp ); + ADDTEXT( " diag-tl-to-br=" ); lcl_AddOnOff( t, ::get_flag( nBorder1, 0x40000000UL ) ); + ADDTEXT( " diag-bl-to-tr=" ); lcl_AddOnOff( t, ::get_flag( nBorder1, 0x80000000UL ) ); + PRINT(); + LINESTART(); + ::extract_value( nTmp, nBorder2, 26, 6 ); + ADDTEXT( "area-pattern=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nArea, 0, 7 ); + ADDTEXT( " fore-color=" ); __AddDec( t, nTmp ); + ::extract_value( nTmp, nArea, 7, 7 ); + ADDTEXT( " back-color=" ); __AddDec( t, nTmp ); + PRINT(); + + return 0; +} + +void Biff8RecDumper::DumpValidPassword( XclImpStream& rIn, const sal_Char* pPre ) +{ + ByteString t; + UINT16 nHash; + rIn >> nHash; + LINESTART(); + ADDTEXT( "hash=" ); + __AddHex( t, nHash ); + if( nHash ) + { + ByteString sPasswd; + ByteString sDummy; + UINT16 nLen = 9; + UINT16 nDummy; + UINT16 nNewChar; + + nHash ^= 0xCE4B; + nDummy = nHash; + ADDTEXT( " without-mask=" ); + __AddHex( t, nHash ); + while( !(nDummy & 0x8000) && nLen ) + { + nLen--; + nDummy <<= 1; + } + if( !nLen ) nLen = 2; + if( (nLen ^ nHash) & 0x0001 ) nLen++; + if( nLen == 9 ) + { + nLen = 10; + nHash ^= 0x8001; + } + nHash ^= nLen; + if( nLen < 9 ) nHash <<= (8 - nLen); + for( UINT16 iChar = nLen; iChar > 0; iChar-- ) + { + switch( iChar ) + { + case 10: + nNewChar = (nHash & 0xC000) | 0x0400; + nHash ^= nNewChar; + nNewChar >>= 2; + break; + case 9: + nNewChar = 0x4200; + nHash ^= nNewChar; + nNewChar >>= 1; + break; + case 1: + nNewChar = nHash & 0xFF00; + break; + default: + nNewChar = (nHash & 0xE000) ^ 0x2000; + if( !nNewChar ) nNewChar = (nHash & 0xF000) ^ 0x1800; + if( nNewChar == 0x6000 ) nNewChar = 0x6100; + nHash ^= nNewChar; + nHash <<= 1; + break; + } + nNewChar >>= 8; + nNewChar &= 0x00FF; + sDummy = sPasswd; + sPasswd = (sal_Char) nNewChar; + sPasswd += sDummy; + } + ADDTEXT( " valid-password='" ); + t += sPasswd; + ADDTEXT( "'" ); + } + PRINT(); +} + + +void __AddGUID( ByteString& rStr, XclImpStream& rIn ) +{ + UINT16 nIndex; + __AddPureHex( rStr, Read4( rIn ) ); + rStr += "-"; + __AddPureHex( rStr, Read2( rIn ) ); + rStr += "-"; + __AddPureHex( rStr, Read2( rIn ) ); + rStr += "-"; + // last 2 parts byte for byte + for( nIndex = 0; nIndex < 2; nIndex++ ) + __AddPureHex( rStr, Read1( rIn ) ); + rStr += "-"; + for( nIndex = 0; nIndex < 6; nIndex++ ) + __AddPureHex( rStr, Read1( rIn ) ); +} + + +void Biff8RecDumper::PreDumpDecrypted( ULONG nL ) +{ + if( !nL ) return; + + ByteString t; + const sal_Char* pPre = (pLevelPre > pLevelPreString) ? pLevelPre - 1 : pLevelPre; + + LINESTART(); + ADDTEXT( "*** encrypted ***" ); + PRINT(); + pIn->DisableDecryption(); + pIn->Seek( EXC_REC_SEEK_TO_BEGIN ); + ContDump( nL ); + + if( pIn->HasValidDecrypter() ) + { + LINESTART(); + ADDTEXT( "*** decrypted ***" ); + PRINT(); + pIn->EnableDecryption(); + pIn->Seek( EXC_REC_SEEK_TO_BEGIN ); + ContDump( nL ); + } +} + + +void Biff8RecDumper::RecDump( BOOL bSubStream ) +{ + const sal_Char* p; + BOOL bDec = FALSE; + ByteString aTmp; + UINT16 __nFlags; + const UINT16 nR = pIn->GetRecId(); + const ByteString* pName = GetName( nR ); + + // set CONTINUE handling mode + switch( nR ) + { + case 0x000A: // EOF + case 0x003C: // CONT + case 0x005D: // OBJ + case 0x00EC: // MSODRAWING + case 0x01B6: // TXO + pIn->ResetRecord( false ); + break; + case 0x1066: // CHGELFRAME + pIn->ResetRecord( bReadContRecs, 0x1066 ); + break; + default: + pIn->ResetRecord( bReadContRecs ); + } + const ULONG nL = pIn->GetRecSize(); + + switch( nR ) + { + case 0x0009: + case 0x0209: + case 0x0409: + case 0x0809: + nLevelCnt = 0; + break; + case 0x1033: + if( pName ) + aTmp = *pName; + else + aTmp = "BEGIN "; + bDec = ( pLevelPre + nLevelInc ) >= pLevelPreString; + nLevelCnt++; + aTmp.Append( ByteString::CreateFromInt32( nLevelCnt ) ); + pName = &aTmp; + break; + case 0x1034: + if( pName ) + aTmp = *pName; + else + aTmp = "END "; + if( ( pLevelPre + nLevelInc ) <= pLevelPreStringNT ) + pLevelPre += nLevelInc; + if( nLevelCnt ) + { + aTmp.Append( ByteString::CreateFromInt32( nLevelCnt ) ); + nLevelCnt--; + } + else + aTmp += "#LEVEL ERROR#"; + pName = &aTmp; + break; + } + + ByteString aT; + ByteString& t = aT; + const sal_Char* pPre = (pLevelPre > pLevelPreString) ? pLevelPre - 1 : pLevelPre; + + if( nR || nL ) // skip dummy-zero DIMENSIONS at eof + { + if( bBlankLine ) + *pDumpStream << '\n'; + + aT += pLevelPre; + __AddHex( aT, nR ); + + if( pName ) + { + aT += " ("; + aT += *pName; + aT += ") ["; + } + else + aT += " ["; + + if( bReadContRecs ) + __AddHex( aT, nL ); + else + __AddHex( aT, (UINT16)nL ); + aT += "]"; + if( !bSkipOffset ) + { + aT += " :"; + __AddHex( aT, UINT32(pIn->GetSvStreamPos() - 2 * sizeof(UINT16)) ); + aT += ':'; + } + + Print( aT ); + } + + if( HasModeNameOnly( nR ) ) + ; + else if( HasModeHex( nR ) || !bBIFF8 ) + { + if( bEncrypted ) + PreDumpDecrypted( nL ); + else + ContDump( nL ); + } + else if( nMaxBodyLines && nL ) + { + XclImpStream& rIn = *pIn; + + if( bEncrypted ) + { + PreDumpDecrypted( nL ); + LINESTART(); + ADDTEXT( "*** contents ***" ); + PRINT(); + pIn->Seek( EXC_REC_SEEK_TO_BEGIN ); + } + + LINESTART(); + + switch( nR ) + { + case 0x0000: // DIMENSIONS - used area + case 0x0200: + { + LINESTART(); + UINT32 nR1, nR2; + UINT16 nC1, nC2; + rIn >> nR1 >> nR2 >> nC1 >> nC2; + ADDTEXT( "first row: " ); __AddHex( t, nR1 ); + ADDTEXT( " last row+1: " ); __AddHex( t, nR2 ); + ADDTEXT( " first col: " ); __AddHex( t, nC1 ); + ADDTEXT( " last col+1: " ); __AddHex( t, nC2 ); + ADDTEXT( " (" ); lcl_AddRangeRef( t, nC1, (UINT16)nR1, nC2-1, (UINT16)nR2-1 ); + ADDTEXT( ")" ); + PRINT(); + } + break; + case 0x06: + { + ADDCELLHEAD(); + PRINT(); + LINESTART(); + ADDTEXT( "val = " ); + ADDDOUBLE(); + rIn >> __nFlags; + if( __nFlags ) + { + ADDTEXT( " " ); + STARTFLAG(); + ADDFLAG( 0x01, "fAlwaysCalc" ); + ADDFLAG( 0x02, "fCalcOnLoad" ); + ADDFLAG( 0x08, "fShrFmla" ); + } + PRINT(); + LINESTART(); + UINT16 n; + ADDTEXT( "chn = " ); + ADDHEX( 4 ); + rIn >> n; + ADDTEXT( " cce = " ); + __AddDec( t, n ); + PRINT(); + FormulaDump( n, FT_CellFormula ); + if( rIn.GetRecLeft() > 0 ) + { + LINESTART(); + ADDTEXT( "additional formula data" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + } + break; + case 0x0013: // PASSWORD + DumpValidPassword( rIn, pPre ); + break; + case 0x0014: // HEADER + case 0x0015: // FOOTER + if( rIn.GetRecLeft() ) + AddUNICODEString( t, rIn ); + PRINT(); + break; + case 0x17: + { + if( mnSubstream == EXC_BOF_WORKSPACE ) + { + ADDTEXT( "filename=" ); + AddUNICODEString( t, rIn ); + PRINT(); + } + else + { + UINT16 n; + rIn >> n; + ADDTEXT( "# of XTI: " ); + __AddDec( t, n ); + PRINT(); + UINT16 nSB, nF, nL; + while( n && rIn.IsValid() ) + { + LINESTART(); + rIn >> nSB >> nF >> nL; + ADDTEXT( "Supbook = " ); + __AddDec( t, nSB ); + ADDTEXT( " Tab = " ); + __AddDec( t, nF ); + ADDTEXT( " ... " ); + __AddDec( t, nL ); + PRINT(); + n--; + } + } + } + break; + case 0x0018: + case 0x0218: // NAME + { + sal_uInt8 nKey, nNameLen, nMenuLen, nDescrLen, nHelpLen, nStatusLen; + sal_uInt16 nFmlaSize, nRes, nTab; + + rIn >> __nFlags >> nKey >> nNameLen >> nFmlaSize >> nRes >> nTab >> nMenuLen >> nDescrLen >> nHelpLen >> nStatusLen; + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fHidden" ); + ADDFLAG( 0x0002, "fFunc" ); + ADDFLAG( 0x0004, "fVBProc" ); + ADDFLAG( 0x0008, "fProc" ); + ADDFLAG( 0x0010, "fCalcExp" ); + ADDFLAG( 0x0020, "fBuiltIn" ); + ADDFLAG( 0x1000, "fBig" ); + ADDRESERVED( 0xE000 ); + ADDTEXT( " func-group-idx=" ); + __AddDec( t, (UINT16)((__nFlags & 0x0FC0) >> 6) ); + ADDTEXT( " shortcut=" ); __AddHex( t, nKey ); + PRINT(); + + LINESTART(); + ADDTEXT( "fmla-size=" ); __AddDec( t, nFmlaSize ); + ADDTEXT( " reserved=" ); __AddHex( t, nRes ); + ADDTEXT( " tab=" ); __AddDec( t, nTab ); + if( !nTab ) ADDTEXT( " (global)" ); + PRINT(); + + LINESTART(); + sal_uInt16 nBuiltIn = 0; + bool bBuiltIn = (nNameLen == 1) && (__nFlags & 0x0020); + if( bBuiltIn ) + { + rIn.PushPosition(); + sal_uInt8 nStrFlags; + rIn >> nStrFlags; + nBuiltIn = (nStrFlags & 1) ? rIn.ReaduInt16() : rIn.ReaduInt8(); + rIn.PopPosition(); + } + ADDTEXT( "name=" ); + ByteString aName; + AddUNICODEString( t, rIn, false, nNameLen, &aName ); + if( bBuiltIn ) + { + static const sal_Char* const ppcNames[] = { + "Consolidate_Area", "Auto_Open", "Auto_Close", "Extract", "Database", + "Criteria", "Print_Area", "Print_Titles", "Recorder", "Data_Form", + "Auto_Activate", "Auto_Deactivate", "Sheet_Title", "_FilterDatabase" }; + lcl_AddEnum( t, nBuiltIn, ppcNames, STATIC_TABLE_SIZE( ppcNames ) ); + if( (0 <= nBuiltIn) && (nBuiltIn < STATIC_TABLE_SIZE( ppcNames )) ) + aName.Assign( ppcNames[ nBuiltIn ] ); + } + maNames.push_back( aName ); + PRINT(); + + if( nFmlaSize && (rIn.GetRecLeft() > 0) ) + { + LINESTART(); + ADDTEXT( "name-definition=" ); + PRINT(); + FormulaDump( nFmlaSize, FT_RangeName ); + } + if( nMenuLen ) + { + LINESTART(); + ADDTEXT( "menu-text=" ); + AddUNICODEString( t, rIn, false, nMenuLen ); + PRINT(); + } + if( nDescrLen ) + { + LINESTART(); + ADDTEXT( "descr-text=" ); + AddUNICODEString( t, rIn, false, nDescrLen ); + PRINT(); + } + if( nHelpLen ) + { + LINESTART(); + ADDTEXT( "help-text=" ); + AddUNICODEString( t, rIn, false, nHelpLen ); + PRINT(); + } + if( nStatusLen ) + { + LINESTART(); + ADDTEXT( "status-text=" ); + AddUNICODEString( t, rIn, false, nStatusLen ); + PRINT(); + } + } + break; + case 0x001D: // SELECTION - list of selections + { + ADDTEXT( "pane: " ); ADDDEC( 1 ); + ADDTEXT( " active cell: " ); + UINT16 nR, nC; + rIn >> nR >> nC; + lcl_AddRef( t, nC, nR ); + ADDTEXT( " active index: " ); ADDDEC( 2 ); + ADDTEXT( " ref count: " ); + UINT16 nCount; + rIn >> nCount; + __AddDec( t, nCount ); + PRINT(); + for( UINT16 nIndex = 0; nIndex < nCount && rIn.IsValid(); nIndex++ ) + { + LINESTART(); + UINT16 nR1, nR2; + UINT8 nC1, nC2; + rIn >> nR1 >> nR2 >> nC1 >> nC2; + ADDTEXT( "ref#" ); __AddDec( t, nIndex, 3 ); + ADDTEXT( ": " ); lcl_AddRangeRef( t, nC1, nR1, nC2, nR2 ); + PRINT(); + } + } + break; + case 0x0023: // EXTERNNAME + { + PreDump( rIn.GetRecSize() ); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "builtin" ); + ADDFLAG( 0x0002, "automatic" ); + ADDFLAG( 0x0004, "wantcliprepr" ); + ADDFLAG( 0x0008, "DDEstddocname" ); + ADDFLAG( 0x0010, "OLE" ); + ADDRESERVED( 0x8000 ); + sal_uInt16 nClip = (__nFlags & 0x7FE0) >> 5; + ADDTEXT( " clip-format=" ); __AddHex( t, nClip ); + PRINT(); LINESTART(); + bool bFormula = false, bArray = false; + if( (__nFlags & 0x0001) || !(__nFlags & 0x7FFE) ) + { + ADDTEXT( "type=external name" ); + ADDTEXT( " table=" ); ADDDEC( 2 ); + ADDTEXT( " reserved=" ); ADDHEX( 2 ); + bFormula = true; + } + else if( __nFlags & 0x0010 ) + { + ADDTEXT( "type=OLE" ); + ADDTEXT( " stream-id=" ); ADDHEX( 4 ); + } + else + { + ADDTEXT( "type=DDE" ); + ADDTEXT( " reserved=" ); ADDHEX( 4 ); + bArray = true; + } + PRINT(); LINESTART(); + ADDTEXT( "name=" ); AddUNICODEString( t, rIn, FALSE ); + PRINT(); + if( rIn.GetRecLeft() > 0 ) + { + LINESTART(); + if( bFormula ) + { + sal_uInt16 nSize = rIn.ReaduInt16(); + ADDTEXT( "formula (size=" ); __AddDec( t, nSize ); + ADDTEXT( "):" ); + PRINT(); + FormulaDump( nSize, FT_RangeName ); + } + else if( bArray && (rIn.GetRecLeft() >= 3) ) + { + LINESTART(); + ADDTEXT( "constant array width=" ); ADDDEC( 1 ); + ADDTEXT( " height=" ); ADDDEC( 2 ); + PRINT(); + while( rIn.GetRecLeft() > 0 ) + { + sal_uInt8 nType = rIn.ReaduInt8(); + LINESTART(); + ADDTEXT( "type=" ); __AddHex( t, nType ); + ADDTEXT( " (" ); + switch( nType ) + { + case 0x00: + ADDTEXT( "empty) reserved=" ); ADDHEX( 4 ); + ADDTEXT( " " ); ADDHEX( 4 ); + break; + case 0x01: + ADDTEXT( "double) value=" ); ADDDOUBLE(); + break; + case 0x02: + ADDTEXT( "string) text=" ); AddUNICODEString( t, rIn ); + break; + case 0x04: + ADDTEXT( "bool) value=" ); lcl_AddFlag( t, rIn.ReaduInt8() ); + ADDTEXT( " reserved=" ); ADDHEX( 1 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 4 ); + break; + case 0x10: + ADDTEXT( "error) code=" ); ADDHEX( 1 ); + ADDTEXT( " reserved=" ); ADDHEX( 1 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 4 ); + break; + default: + ADDTEXT( "!unknown!)" ); + rIn.Ignore( 8 ); + } + PRINT(); + } + } + if( rIn.GetRecLeft() > 0 ) + { + LINESTART(); + ADDTEXT( "additional data:" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + } + } + break; + case 0x0026: + case 0x0027: + case 0x0028: + case 0x0029: + LINESTART(); + ADDDOUBLE(); + PRINT(); + break; + case 0x002F: // FILEPASS + { + LINESTART(); + sal_uInt16 nType; + rIn >> nType; + ADDTEXT( "encrypt-type=" ); __AddHex( t, nType ); + ADDTEXT( " (" ); + switch( nType ) + { + case 0x0000: + { + ADDTEXT( "BIFF2-BIFF7 XOR) key=" ); + ADDHEX( 2 ); + ADDTEXT( " hash=" ); + ADDHEX( 2 ); + PRINT(); + } + break; + + case 0x0001: + { + ADDTEXT( "BIFF8 standard/strong)" ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved=" ); ADDHEX( 2 ); + sal_uInt16 nMode; + rIn >> nMode; + ADDTEXT( " mode=" ); __AddHex( t, nMode ); + ADDTEXT( " (" ); + switch( nMode ) + { + case 0x0001: + { + ADDTEXT( "BIFF8 standard)" ); + PRINT(); + LINESTART(); + ADDTEXT( "document-id=..." ); + PRINT(); + ContDump( 16 ); + LINESTART(); + ADDTEXT( "salt-data=..." ); + PRINT(); + ContDump( 16 ); + LINESTART(); + ADDTEXT( "salt-hash=..." ); + PRINT(); + ContDump( 16 ); + } + break; + case 0x0002: + { + ADDTEXT( "BIFF8X strong) flags=" ); + ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "info-size=" ); ADDHEX( 4 ); + ADDTEXT( " flags=" ); ADDHEX( 4 ); + ADDTEXT( " unknown=" ); ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "stream-crypt-id=" ); ADDHEX( 4 ); + ADDTEXT( " hash-algo-id=" ); ADDHEX( 4 ); + ADDTEXT( " hash-key-len=" ); ADDDEC( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "crypt-prov-type=" ); ADDHEX( 4 ); + ADDTEXT( " unknown=" ); ADDHEX( 4 ); + ADDTEXT( " unknown=" ); ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "crypt-provider-name='" ); + sal_uInt16 nChar; + do + { + rIn >> nChar; + if( nChar ) + t += (sal_Char)(((32 <= nChar) && (nChar <=127)) ? nChar : '.'); + } + while( nChar ); + ADDTEXT( "'" ); + PRINT(); + LINESTART(); + sal_uInt32 nLen; + rIn >> nLen; + ADDTEXT( "*** document-id *** len=" ); __AddHex( t, nLen ); + PRINT(); + ContDump( nLen ); + LINESTART(); + ADDTEXT( "*** salt-data *** len=" ); __AddHex( t, nLen ); + PRINT(); + ContDump( nLen ); + LINESTART(); + rIn >> nLen; + ADDTEXT( "*** salt-hash *** len=" ); __AddHex( t, nLen ); + PRINT(); + ContDump( nLen ); + } + break; + default: + { + ADDTEXT( "!unknown!)" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + } + } + break; + + default: + { + ADDTEXT( "!unknown!)" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + } + } + break; + case 0x0031: // FONT + case 0x0231: + { + LINESTART(); + ADDTEXT( "(index=" ); __AddDec( t, nFontIndex ); + ADDTEXT( ") " ); + nFontIndex++; if( nFontIndex == 4 ) nFontIndex++; + ADDTEXT( "height: " ); ADDDEC( 2 ); + ADDTEXT( "/20pt " ); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0002, "fItalic" ); + ADDFLAG( 0x0008, "fStrikeout" ); + ADDFLAG( 0x0010, "fOutline" ); + ADDFLAG( 0x0020, "fShadow" ); + ADDRESERVED( 0xFFC5 ); + PRINT(); + LINESTART(); + ADDTEXT( "color: " ); ADDDEC( 2 ); + ADDTEXT( " boldness: " ); ADDDEC( 2 ); + ADDTEXT( " sub/sup: " ); ADDDEC( 2 ); + ADDTEXT( " underline: " ); ADDHEX( 1 ); + PRINT(); + LINESTART(); + ADDTEXT( "family: " ); ADDDEC( 1 ); + ADDTEXT( " charset: " ); ADDDEC( 1 ); +// ADDTEXT( " reserved: " ); ADDHEX( 1 ); + rIn.Ignore( 1 ); + ADDTEXT( " " ); + AddUNICODEString( t, rIn, FALSE ); + PRINT(); + } + break; + case 0x003D: // WINDOW1 + { + LINESTART(); + ADDTEXT( "pos-x=" ); ADDDEC( 2 ); + ADDTEXT( " pos-y=" ); ADDDEC( 2 ); + ADDTEXT( " width=" ); ADDDEC( 2 ); + ADDTEXT( " height=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "hide-window" ); + ADDFLAG( 0x0002, "min-window" ); + ADDFLAG( 0x0008, "show-hscroll" ); + ADDFLAG( 0x0010, "show-vscroll" ); + ADDFLAG( 0x0020, "show-tabbar" ); + ADDRESERVED( 0xFFC4 ); + PRINT(); + LINESTART(); + ADDTEXT( "active-tab=" ); ADDDEC( 2 ); + ADDTEXT( " first-vis-tab=" ); ADDDEC( 2 ); + ADDTEXT( " selected-tabs=" ); ADDDEC( 2 ); + ADDTEXT( " tabbar-width=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x0041: // PANE + { + LINESTART(); + ADDTEXT( "vert-split-pos=" ); ADDDEC( 2 ); + ADDTEXT( " hor-split-pos=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "first-row=" ); ADDDEC( 2 ); + ADDTEXT( " first-col=" ); ADDDEC( 2 ); + ADDTEXT( " active-pane=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x0042: // CODEPAGE + { + LINESTART(); + sal_uInt16 nCodePage = rIn.ReaduInt16(); + ADDTEXT( "codepage=" ); __AddHex( t, nCodePage ); + ADDTEXT( " (" ); __AddDec( t, nCodePage ); + ADDTEXT( ")" ); + PRINT(); + } + break; + case 0x004D: // PLS + { + LINESTART(); + static const sal_Char* const ppcTypes[] = { "Win", "Mac" }; + sal_uInt16 nType = rIn.ReaduInt16(); + ADDTEXT( "environment=" ); + lcl_AddEnum( t, nType, ppcTypes, STATIC_TABLE_SIZE( ppcTypes ) ); + PRINT(); + if( nType == 0 ) + { + String aData; + sal_uInt32 __nFlags; + LINESTART(); + rIn.SetNulSubstChar( '\0' ); + aData = rIn.ReadRawUniString( 32, true ); + ADDTEXT( "device-name='" ); ADDTEXT( GETSTR( aData ) ); + ADDTEXT( "'" ); + PRINT(); LINESTART(); + ADDTEXT( "spec-version=" ); ADDDEC( 2 ); + ADDTEXT( " driver-version=" ); ADDDEC( 2 ); + sal_uInt16 nOwnSize, nPrvSize; + rIn >> nOwnSize >> nPrvSize; + ADDTEXT( " own-size=" ); __AddDec( t, nOwnSize ); + ADDTEXT( " prv-size=" ); __AddDec( t, nPrvSize ); + PRINT(); LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x00000001, "orient" ); + ADDFLAG( 0x00000002, "paper-size" ); + ADDFLAG( 0x00000004, "paper-height" ); + ADDFLAG( 0x00000008, "paper-width" ); + ADDFLAG( 0x00000010, "scale" ); + ADDFLAG( 0x00000100, "copies" ); + ADDRESERVED( 0xE0000080 ); + PRINT(); LINESTART(); + static const sal_Char* const ppcOrient[] = { 0, "portrait", "landsc" }; + sal_uInt16 nOrient = rIn.ReaduInt16(); + ADDTEXT( "orientation=" ); + lcl_AddEnum( t, nOrient, ppcOrient, STATIC_TABLE_SIZE( ppcOrient ) ); + ADDTEXT( " paper-size=" ); ADDDEC( 2 ); + ADDTEXT( " paper-width=" ); ADDDEC( 2 ); + ADDTEXT( " paper-height=" ); ADDDEC( 2 ); + PRINT(); LINESTART(); + ADDTEXT( "scale=" ); ADDDEC( 2 ); + ADDTEXT( " copies=" ); ADDDEC( 2 ); + PRINT(); + if( nOwnSize > 88 ) + { + LINESTART(); ADDTEXT( "additional data:" ); PRINT(); + ContDump( nOwnSize - 88 ); + } + if( nPrvSize > 0 ) + { + LINESTART(); ADDTEXT( "private data:" ); PRINT(); + ContDump( nPrvSize ); + } + } + if( rIn.GetRecLeft() > 0 ) + { + LINESTART(); ADDTEXT( "unknown data:" ); PRINT(); + ContDump( rIn.GetRecLeft() ); + } + } + break; + case 0x51: + { + UINT16 nR1, nR2; + UINT8 nC1, nC2; + rIn >> nR1 >> nR2 >> nC1 >> nC2; + lcl_AddRangeRef( t, nC1, nR1, nC2, nR2 ); + PRINT(); + LINESTART(); + ADDTEXT( "workbook: " ); + AddUNICODEString( t, rIn, TRUE ); + PRINT(); + } + break; + case 0x0052: // DCONNAME + { + ADDTEXT( "name=" ); + AddUNICODEString( t, rIn, TRUE ); + PRINT(); + LINESTART(); + ADDTEXT( "sheet=" ); + AddUNICODEString( t, rIn, TRUE ); + PRINT(); + } + break; + case 0x5B: // FILESHARING + { + PreDump( nL ); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fReadOnlyRec" ); + PRINT(); + } + DumpValidPassword( rIn, pPre ); + } + break; + case 0x5D: + ObjDump( nL ); + break; + case 0x007D: // COLINFO - col range info + { + LINESTART(); + ADDTEXT( "col range: " ); + ADDDEC( 2 ); + ADDTEXT( "-" ); + ADDDEC( 2 ); + ADDTEXT( " width: " ); + ADDDEC( 2 ); + ADDTEXT( "/256 charwidth ix to XF: " ); + ADDDEC( 2 ); + PRINT(); + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fHidden" ); + ADDTEXT( " outlnlev=" ); + __AddDec( t, (UINT16)((__nFlags & 0x0700) >> 8) ); + ADDFLAG( 0x1000, "fCollapsed" ); + ADDRESERVED( 0xE8FE ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved: " ); + ADDHEX( 1 ); + PRINT(); + } + break; + case 0x7E: + { +// LINESTART(); + ADDCELLHEAD(); + ADDTEXT( " val = " ); + __AddRK( t, rIn.ReadInt32() ); + PRINT(); + } + break; + case 0x0080: // GUTS - row & col gutters for outlines + { + LINESTART(); + ADDTEXT( "size row gutter: " ); + __AddDec( t, Read2( rIn ), 5 ); + ADDTEXT( " | size col gutter: " ); + __AddDec( t, Read2( rIn ), 5 ); + PRINT(); + LINESTART(); + ADDTEXT( "max outline lev: " ); + __AddDec( t, Read2( rIn ), 5 ); + ADDTEXT( " | max outline lev: " ); + __AddDec( t, Read2( rIn ), 5 ); + PRINT(); + } + break; + case 0x0081: // WSBOOL - additional workspace info + { + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + if( __nFlags & 0x00F1 ) + { + ADDFLAG( 0x0001, "fShowAutoBreaks" ); + ADDFLAG( 0x0010, "fDialog" ); + ADDFLAG( 0x0020, "fApplyStyles" ); + ADDFLAG( 0x0040, "fRowSumsBelow" ); + ADDFLAG( 0x0080, "fColSumsBelow" ); + PRINT(); + LINESTART(); + } + if( __nFlags & (0xCD00 | 0x320E) ) + { + ADDTEXT( " " ); + ADDFLAG( 0x0100, "fFitToPage" ); + ADDFLAG( 0x0400, "fDispRowGuts" ); + ADDFLAG( 0x0800, "fDispColGuts" ); + ADDFLAG( 0x4000, "fAee" ); + ADDFLAG( 0x8000, "fAfe" ); + ADDRESERVED( 0x320E ); + PRINT(); + } + if( !__nFlags ) + PRINT(); + } + break; + case 0x008C: // COUNTRY + { + LINESTART(); + ADDTEXT( "ui-country=" ); ADDDEC( 2 ); + ADDTEXT( " doc-country=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x92: // PALETTE + { + UINT16 nColCnt; + rIn >> nColCnt; + LINESTART(); + ADDTEXT( "count: " ); + __AddDec( t, nColCnt ); + PRINT(); + LINESTART(); + for( UINT16 nCol = 0; nCol < nColCnt; nCol++ ) + { + __AddDec( t, nCol, 2 ); + ADDTEXT( "=" ); + ADDHEX( 4 ); + ADDTEXT( " " ); + if( (nCol % 5 == 4) || (nCol == nColCnt - 1) ) + { + PRINT(); + LINESTART(); + } + } + } + break; + case 0x9D: // AUTOFILTERINFO -- count of drop-down arrows + { + LINESTART(); + ADDTEXT( "count of drop-down arrows: " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x9E: // AUTOFILTER -- autofilter settings + { + UINT8 nType; + UINT8 nCompare; + ByteString sTemp[ 2 ]; + UINT16 nLen[ 2 ] = { 0, 0 }; + UINT8 nF; + LINESTART(); + ADDTEXT( "count: " ); + ADDDEC( 2 ); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0003, "fJoin" ); + ADDFLAG( 0x0004, "fSimpleEq1" ); + ADDFLAG( 0x0008, "fSimpleEq2" ); + ADDFLAG( 0x0010, "fTop10" ); + ADDFLAG( 0x0020, "fTop" ); + ADDFLAG( 0x0040, "fPercent" ); + PRINT(); + LINESTART(); + if( __nFlags & 0x0003 ) + ADDTEXT( "(custom conditions are OR-ed" ); + else + ADDTEXT( "(custom conditions are AND-ed" ); + if( __nFlags & 0x0010 ) + { + if( __nFlags & 0x0020 ) + ADDTEXT( "; show top " ); + else + ADDTEXT( "; show bottom " ); + __AddDec( t, (UINT16)(__nFlags >> 7) ); + if( __nFlags & 0x0040 ) + ADDTEXT( " percent" ); + else + ADDTEXT( " items" ); + } + ADDTEXT( ")" ); + PRINT(); + for( nF = 0; nF < 2; nF++ ) + { + LINESTART(); + __AddDec( t, (UINT16)(nF + 1) ); + ADDTEXT( ". Filter: " ); + rIn >> nType >> nCompare; + switch( nType ) + { + case 0x00: ADDTEXT( "not used " ); break; + case 0x02: ADDTEXT( "RK " ); break; + case 0x04: ADDTEXT( "double " ); break; + case 0x06: ADDTEXT( "string " ); break; + case 0x08: ADDTEXT( "bool/err " ); break; + case 0x0A: ADDTEXT( "show nothing " ); break; + case 0x0C: ADDTEXT( "all blanks " ); break; + case 0x0E: ADDTEXT( "all non-blanks " ); break; + default: + ADDTEXT( "unknown (" ); + __AddHex( t, nType ); + ADDTEXT( ") " ); + } + switch( nCompare ) + { + case 0x01: ADDTEXT( "< " ); break; + case 0x02: ADDTEXT( "= " ); break; + case 0x03: ADDTEXT( "<= " ); break; + case 0x04: ADDTEXT( "> " ); break; + case 0x05: ADDTEXT( "<> " ); break; + case 0x06: ADDTEXT( ">= " ); break; + default: if( nCompare ) __AddHex( t, nCompare ); + } + sTemp[ nF ] = t; + switch( nType ) + { + case 0x02: + __AddRK( sTemp[ nF ], rIn.ReadInt32() ); + IGNORE( 4 ); + break; + case 0x04: + __AddDouble( sTemp[ nF ], Read8( rIn ) ); + break; + case 0x06: + IGNORE( 4 ); + nLen[ nF ] = Read1( rIn ); + IGNORE( 3 ); + break; + case 0x08: + __AddHex( sTemp[ nF ], Read1( rIn ) ); + sTemp[ nF ] += " "; + __AddHex( sTemp[ nF ], Read1( rIn ) ); + IGNORE( 6 ); + break; + default: + IGNORE( 8 ); + } + } + for( nF = 0; nF < 2; nF++ ) + { + t = sTemp[ nF ]; + if( nLen[ nF ] ) + AddUNICODEString( t, rIn, TRUE, nLen[ nF ] ); + PRINT(); + } + } + break; + case 0xA0: + { + UINT16 nN, nD; + rIn >> nN >> nD; + LINESTART(); + ADDTEXT( "Window Zoom Magnification = " ); + __AddDec( t, nN ); + ADDTEXT( "/" ); + __AddDec( t, nD ); + PRINT(); + } + break; + case 0x00A1: // SETUP + { + LINESTART(); + ADDTEXT( "paper size: " ); ADDDEC( 2 ); + ADDTEXT( " scaling: " ); ADDDEC( 2 ); + ADDTEXT( " start page: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "fit to width: " ); ADDDEC( 2 ); + ADDTEXT( " fit to height: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "fLeftRight" ); + ADDFLAG( 0x0002, "fPortrait" ); + ADDFLAG( 0x0004, "fNoPrintSettings" ); + ADDFLAG( 0x0008, "fMonochrom" ); + ADDFLAG( 0x0010, "fDraft" ); + ADDFLAG( 0x0020, "fNotes" ); + ADDFLAG( 0x0040, "fNoOrientation" ); + ADDFLAG( 0x0080, "fCustomNumber" ); + PRINT(); + LINESTART(); + ADDTEXT( "Print res: " ); ADDDEC( 2 ); + ADDTEXT( " vert print res: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "header margin: " ); ADDDOUBLE(); + ADDTEXT( " footer margin: " ); ADDDOUBLE(); + ADDTEXT( " copies: " ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0xAF: + { + UINT16 nCref; + UINT8 nLocked, nHidden, nName, nComment, nNameUser; + rIn >> nCref >> nLocked >> nHidden >> nName >> nComment >> nNameUser; + LINESTART(); + ADDTEXT( "Changing Cells = " ); + __AddDec( t, nCref ); + if( nLocked ) + ADDTEXT( " fLocked" ); + if( nHidden ) + ADDTEXT( " fHidden" ); + PRINT(); + LINESTART(); + ADDTEXT( "Name = " ); + __AddDec( t, nName ); + ADDTEXT( " Comment = " ); + __AddDec( t, nComment ); + ADDTEXT( " Name User = " ); + __AddDec( t, nNameUser ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + break; + case 0xB0: // SXVIEW + { + UINT16 nColFirst, nColLast, nRowFirst, nRowLast; + rIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast; + nSXLIIndex = 0; // new pivot table + LINESTART(); + ADDTEXT( "PivotTable: " ); __AddDec( t, nColFirst ); + ADDTEXT( " / " ); __AddDec( t, nRowFirst ); + ADDTEXT( " - " ); __AddDec( t, nColLast ); + ADDTEXT( " / " ); __AddDec( t, nRowLast ); + PRINT(); + LINESTART(); + ADDTEXT( "1st Head: " ); ADDDEC( 2 ); + rIn >> nRowFirst; + ADDTEXT( " First Data: " ); ADDDEC( 2 ); + ADDTEXT( " / " ); __AddDec( t, nRowFirst ); + PRINT(); + LINESTART(); + ADDTEXT( "Cache index: " ); ADDDEC( 2 ); + ADDTEXT( " reserved: " ); ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "axis 4 data: " ); ADDDEC( 2 ); + ADDTEXT( " pos 4 Data: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "num of fields: " ); ADDDEC( 2 ); + rIn >> nSXLISize[0] >> nSXLISize[1]; + ADDTEXT( " ...row fields: " ); __AddDec( t, nSXLISize[0] ); + ADDTEXT( " ...col fields: " ); __AddDec( t, nSXLISize[1] ); + PRINT(); + LINESTART(); + ADDTEXT( "num of page fields: " ); ADDDEC( 2 ); + ADDTEXT( " ...data fields: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "data rows: " ); ADDDEC( 2 ); + ADDTEXT( " data cols: " ); ADDDEC( 2 ); + rIn >> __nFlags; + PRINT(); + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fRowGrand" ); + ADDFLAG( 0x0002, "fColGrand" ); + ADDFLAG( 0x0008, "fAutoFormat" ); + ADDFLAG( 0x0010, "fWidthHeightAuto" ); + ADDFLAG( 0x0020, "fFontAuto" ); + ADDFLAG( 0x0040, "fAlignAuto" ); + ADDFLAG( 0x0080, "fBorderAuto" ); + ADDFLAG( 0x0100, "fPatternAuto" ); + ADDFLAG( 0x0200, "fNumberAuto" ); + PRINT(); + } + LINESTART(); + ADDTEXT( "index 2 PivotTable autoform: " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + UINT16 nTableLen = Read2( rIn ); + UINT16 nDataLen = Read2( rIn ); + ADDTEXT( "PivotTable name: " ); + if( nTableLen ) + AddUNICODEString( t, rIn, TRUE, nTableLen ); + else + ADDTEXT( "-/-" ); + PRINT(); + LINESTART(); + ADDTEXT( "data field name: " ); + if( nDataLen ) + AddUNICODEString( t, rIn, TRUE, nDataLen ); + else + ADDTEXT( "-/-" ); + PRINT(); + } + break; + case 0xB1: // SXVD + { + rIn >> __nFlags; + LINESTART(); + ADDTEXT( "Axis (" ); + __AddHex( t, __nFlags ); + ADDTEXT( "):" ); + if( __nFlags ) + { + ADDFLAG( 0x0001, "row" ); + ADDFLAG( 0x0002, "col" ); + ADDFLAG( 0x0004, "page" ); + ADDFLAG( 0x0008, "data" ); + } + else + ADDTEXT( " no axis" ); + ADDTEXT( " num of att. subtotals: " ); + ADDDEC( 2 ); + PRINT(); + rIn >> __nFlags; + LINESTART(); + ADDTEXT( "subtotal type(" ); + __AddHex( t, __nFlags ); + ADDTEXT( "):" ); + if( __nFlags ) + { + ADDFLAG( 0x0001, "Default" ); + ADDFLAG( 0x0002, "Sum" ); + ADDFLAG( 0x0004, "Counta" ); + ADDFLAG( 0x0008, "Average" ); + ADDFLAG( 0x0010, "Max" ); + ADDFLAG( 0x0020, "Min" ); + ADDFLAG( 0x0040, "Product" ); + ADDFLAG( 0x0080, "Count" ); + ADDFLAG( 0x0100, "Stdev" ); + ADDFLAG( 0x0200, "Stddevp" ); + ADDFLAG( 0x0400, "Var" ); + ADDFLAG( 0x0800, "Varp" ); + } + else + ADDTEXT( " none" ); + PRINT(); + LINESTART(); + ADDTEXT( "num of items: " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "Name: " ); + UINT16 nLen = Read2( rIn ); + if( nLen == 0xFFFF ) + ADDTEXT( "<name in cache>" ); + else if( nLen ) + AddUNICODEString( t, rIn, TRUE, nLen ); + PRINT(); + } + break; + case 0xB2: // SXVI + { + UINT16 nType, nCache; + rIn >> nType >> __nFlags >> nCache; + LINESTART(); + switch( nType ) + { + case 0xFE: p = "Page"; break; + case 0xFF: p = "Null"; break; + case 0x00: p = "Data"; break; + case 0x01: p = "Default"; break; + case 0x02: p = "SUM"; break; + case 0x03: p = "COUNT"; break; + case 0x04: p = "AVERAGE"; break; + case 0x05: p = "MAX"; break; + case 0x06: p = "MIN"; break; + case 0x07: p = "PRODUCT"; break; + case 0x08: p = "COUNTA"; break; + case 0x09: p = "STDEV"; break; + case 0x0A: p = "STDEVP"; break; + case 0x0B: p = "VAR"; break; + case 0x0C: p = "VARP"; break; + case 0x0D: p = "Grand total"; break; + default: p = pU; + } + ADDTEXT( "Type (" ); + __AddHex( t, nType ); + ADDTEXT( "): " ); + ADDTEXT( p ); + ADDTEXT( " iCache: " ); + __AddDec( t, nCache ); + PRINT(); + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x01, "fHidden" ); + ADDFLAG( 0x02, "fHideDetail" ); + ADDFLAG( 0x04, "fFormula" ); + ADDFLAG( 0x08, "fMissing" ); + PRINT(); + } + LINESTART(); + ADDTEXT( "Name: " ); + UINT16 nCch = Read2( rIn ); + if( nCch == 0xFFFF ) + ADDTEXT( "<name in cache>" ); + else if( nCch ) + AddUNICODEString( t, rIn, TRUE, nCch ); + else + ADDTEXT( "<empty string>" ); + PRINT(); + } + break; + case 0xB4: // SXIVD + { + const UINT16 nBrkNum = 5; + UINT16 nBrk = nBrkNum; + UINT16 nSize = (UINT16)(nL / 2); + LINESTART(); + for( UINT16 i = 0; i < nSize; i++ ) + { + ADDHEX( 2 ); + nBrk--; + if( nBrk ) + ADDTEXT( " " ); + else + { + PRINT(); + LINESTART(); + nBrk = nBrkNum; + } + } + if( nBrk < nBrkNum ) PRINT(); + } + break; + case 0xB5: // SXLI - pivot table line item array + { + UINT16 nIdent; + UINT16 nType; + UINT16 nMaxInd; + const sal_Char* pInd = " "; + const sal_Char* pType[] = { + "Data", "Default", "SUM", "COUNT","AVERAGE", + "MAX", "MIN", "PRODUCT", "COUNTA", "STDEV", + "STDEVP", "VAR", "VARP", "Grand total", + "Blank line" }; // undocumented + while( rIn.GetRecLeft() > 0 ) + { + rIn >> nIdent >> nType >> nMaxInd >> __nFlags; + LINESTART(); + ADDTEXT( "# of ident. items: " ); + __AddDec( t, nIdent ); + ADDTEXT( " Type (" ); + __AddHex( t, nType ); + ADDTEXT( "): " ); + if( nType > 0x0E ) + p = pU; + else + p = pType[ nType ]; + ADDTEXT( p ); + ADDTEXT( " relevant indexes: " ); + __AddDec( t, nMaxInd ); + PRINT(); + LINESTART(); + ADDTEXT( pInd ); + STARTFLAG(); + ADDFLAG( 0x0001, "fMultiDataName" ); + ADDFLAG( 0x0200, "fSub" ); + ADDFLAG( 0x0400, "fBlock" ); + ADDFLAG( 0x0800, "fGrand" ); + ADDFLAG( 0x1000, "fMultiDataOnAxis" ); + ADDFLAG( 0x2000, "fBlankLine" ); // undocumented + ADDFLAG( 0x4000, "fHideDetail" ); // undocumented + ADDRESERVED( 0x8000 ); + PRINT(); + LINESTART(); + ADDTEXT( pInd ); + ADDTEXT( "index to data field: " ); + __AddDec( t, (UINT16) ( (__nFlags & 0x01FE) >> 1 ) ); + PRINT(); + LINESTART(); + ADDTEXT( pInd ); + ADDTEXT( "array of " ); + __AddDec( t, nSXLISize[nSXLIIndex] ); + ADDTEXT( " indexes (^ are ident., * are irrelevant):" ); + PRINT(); + LINESTART(); + ADDTEXT( pInd ); + ADDTEXT( " " ); + const UINT16 nBrkNum = 5; + UINT16 nBrk = nBrkNum; + for( UINT16 i = 0; i < nSXLISize[nSXLIIndex]; i++ ) + { + __AddDec( t, Read2( rIn ), 7 ); + if( i < nIdent ) + ADDTEXT( "^" ); + else if( i < nMaxInd ) + ADDTEXT( " " ); + else + ADDTEXT( "*" ); + nBrk--; + if( !nBrk ) + { + PRINT(); + LINESTART(); + ADDTEXT( pInd ); + ADDTEXT( " " ); + nBrk = nBrkNum; + } + } + if( nBrk < nBrkNum ) + PRINT(); + } + nSXLIIndex = 1 - nSXLIIndex; + } + break; + case 0xB6: // SXPI - pivot table page item(s) + { + UINT16 nArrayCnt = (UINT16)(nL / 6); + LINESTART(); + __AddDec( t, nArrayCnt ); + ADDTEXT( " page items:" ); + PRINT(); + for( UINT16 iArray = 0; iArray < nArrayCnt; iArray++ ) + { + LINESTART(); + ADDTEXT( "index SXVD: " ); + __AddDec( t, Read2( rIn ), 3 ); + ADDTEXT( " index SXVI: " ); + UINT16 nSXVIInd; + rIn >> nSXVIInd; + __AddDec( t, nSXVIInd, 5 ); + if( nSXVIInd == 32765 ) + ADDTEXT( " (All items) Obj ID: " ); + else + ADDTEXT( " Obj ID: " ); + ADDHEX( 2 ); + PRINT(); + } + } + break; + case 0xBD: + { + UINT16 nC, nR, nXF; + INT32 nRK; + UINT16 n = (UINT16)((nL - 4) / 6); + + rIn >> nR >> nC; + while( n ) + { + rIn >> nXF >> nRK; + LINESTART(); + __AddCellHead( t, nC, nR, nXF ); + ADDTEXT( " val = " ); + __AddRK( t, nRK ); + PRINT(); + nC++; + n--; + } + } + break; + case 0xBE: + { + LINESTART(); + ADDCELLHEAD(); + PRINT(); + LINESTART(); + ADDTEXT( "next XFs: " ); + UINT16 n = (UINT16)((nL - 6) / 2); + while( n ) + { + __AddDec( t, Read2( rIn ) ); + n--; + if( n ) + ADDTEXT( ' ' ); + } + PRINT(); + } + break; + case 0x00C5: // SXDI + { + LINESTART(); + ADDTEXT( "Field: " ); + ADDDEC( 2 ); + UINT16 nFunc = Read2( rIn ); + ADDTEXT( " aggregation func (" ); + __AddHex( t, nFunc ); + ADDTEXT( "): " ); + const sal_Char* pFunc[] = { "Sum", "Count", "Average", "Max", "Min", + "Product", "Count Nums", "StdDev", "StdDevp", "Var", + "Varp" }; + p = (nFunc > 0x0A) ? pU : pFunc[ nFunc ]; + ADDTEXT( p ); + ADDTEXT( " display format (" ); + const sal_Char* pDispl[] = { + "Normal", "Difference", "Percentage of", "Percentage difference from", "Running total in", + "Percentage of row", "Percentage of column", "Percentage of total", "Index" }; + UINT16 nDispl = Read2( rIn ); + __AddHex( t, nDispl ); + ADDTEXT( "): " ); + p = (nDispl > 0x08) ? pU : pDispl[ nDispl ]; + ADDTEXT( p ); + PRINT(); + LINESTART(); + ADDTEXT( "ind. to SXVD: " ); ADDDEC( 2 ); + ADDTEXT( " ind. to SXVI: " ); ADDDEC( 2 ); + ADDTEXT( " num format: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "name: " ); + UINT16 nCch = Read2( rIn ); + if( nCch == 0xFFFF ) + ADDTEXT( "<name in cache>" ); + else if( nCch ) + AddUNICODEString( t, rIn, TRUE, nCch ); + else + ADDTEXT( "<empty string>" ); + PRINT(); + } + break; + case 0x00C6: // SXDB - cache info + { + ADDTEXT( "number of recs: " ); ADDDEC( 4 ); + ADDTEXT( " stream id: " ); ADDHEX( 2 ); + ADDTEXT( " flags: " ); ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "DB block recs: " ); ADDDEC( 2 ); + ADDTEXT( " base fields: " ); ADDDEC( 2 ); + ADDTEXT( " all fields: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved: " ); ADDHEX( 2 ); + ADDTEXT( " type: " ); ADDHEX( 2 ); + ADDTEXT( " changed by:" ); + PRINT(); + LINESTART(); + AddUNICODEString( t, rIn ); + PRINT(); + } + break; + case 0x00C7: // SXFIELD - Pivot Field + { + nItemCnt = 0; + + ADDTEXT( "#" ); + __AddDec( t, nFieldCnt, 3 ); + nFieldCnt++; + ADDTEXT( " (pivot field): " ); + if( rIn.GetRecLeft() < 14 ) + { + ADDTEXT( "<break in pivot field start>" ); + PRINT(); + } + else + { + PRINT(); + LINESTART(); + ADDTEXT( pPre ); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "fOrigItems" ); + ADDFLAG( 0x0002, "fPostponed" ); + ADDFLAG( 0x0004, "fCalculated" ); + ADDFLAG( 0x0008, "fGroupChild" ); + ADDFLAG( 0x0010, "fNumGroup" ); + ADDFLAG( 0x0200, "fLongIndex" ); + ADDFLAG( 0x1000, "f1000?" ); + ADDFLAG( 0x8000, "f8000?" ); + ADDRESERVED( 0x6000 ); + ADDTEXT( " data-type=" ); + __AddHex( t, static_cast< sal_uInt16 >( __nFlags & 0x0DE0 ) ); + ADDTEXT( "=" ); + switch( __nFlags & 0x0DE0 ) + { + case 0x0000: ADDTEXT( "spc" ); break; + case 0x0480: ADDTEXT( "str" ); break; + case 0x0520: ADDTEXT( "int[+dbl]" ); break; + case 0x0560: ADDTEXT( "dbl" ); break; + case 0x05A0: ADDTEXT( "str+int[+dbl]" ); break; + case 0x05E0: ADDTEXT( "str+dbl" ); break; + case 0x0900: ADDTEXT( "dat" ); break; + case 0x0D00: ADDTEXT( "dat+int/dbl" ); break; + case 0x0D80: ADDTEXT( "dat+str[+int/dbl]" ); break; + default: ADDTEXT( pU ); + } + PRINT(); + LINESTART(); + ADDTEXT( pPre ); + ADDTEXT( "group-subfield=" ); ADDDEC( 2 ); + ADDTEXT( " group-basefield=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( pPre ); + ADDTEXT( "item-count=" ); ADDDEC( 2 ); + ADDTEXT( " group-item-count=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( pPre ); + ADDTEXT( "base-item-count=" ); ADDDEC( 2 ); + ADDTEXT( " source-item-count=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( pPre ); + if( rIn.GetRecLeft() < 3 ) + { + ADDTEXT( "<break in pivot field name>" ); + PRINT(); + } + else + { + ADDTEXT( "name=" ); + AddUNICODEString( t, rIn ); + PRINT(); + } + } + } + break; + case 0x00C8: // SXINDEXLIST - indexes to source data + { + ADDTEXT( "#" ); + __AddDec( t, nTabIndexCnt, 3 ); + nTabIndexCnt++; + ADDTEXT( " (index list):" ); + for( UINT16 iIndex = 0; iIndex < rIn.GetRecSize(); iIndex++ ) + { + ADDTEXT( " " ); + ADDHEX( 1 ); + } + PRINT(); + } + break; + case 0x00C9: // SXDOUBLE - cache entry: double value + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (double): " ); + nItemCnt++; + ADDTEXT( " " ); + ADDDOUBLE(); + PRINT(); + } + break; + case 0x00CA: // SXBOOLEAN - cache entry: boolean value + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (boolean): " ); + nItemCnt++; + ADDTEXT( " " ); + lcl_AddFlag( t, rIn.ReaduInt16() != 0 ); + PRINT(); + } + break; + case 0x00CB: // SXERROR - cache entry: error code + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (error): " ); + nItemCnt++; + ADDTEXT( " " ); + ADDHEX( 2 ); + PRINT(); + } + break; + case 0x00CC: // SXINTEGER - signed 16bit integer + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (integer): " ); + nItemCnt++; + ADDTEXT( " " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x00CD: // SXSTRING - String + { + if( bSubStream ) + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (string): " ); + nItemCnt++; + } + AddUNICODEString( t, rIn ); + PRINT(); + } + break; + case 0x00CE: // SXDATETIME - date & time special format + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (date/time): " ); + nItemCnt++; + UINT8 nDay, nHour, nMin, nSec; + UINT16 nYear, nMonth; + rIn >> nYear >> nMonth >> nDay >> nHour >> nMin >> nSec; + if( nDay ) + { + __AddDec( t, nDay ); + ADDTEXT( "." ); + __AddDec( t, nMonth ); + ADDTEXT( "." ); + __AddDec( t, nYear ); + ADDTEXT( " " ); + } + __AddDec( t, nHour, 2, '0' ); + ADDTEXT( ":" ); + __AddDec( t, nMin, 2, '0' ); + ADDTEXT( ":" ); + __AddDec( t, nSec, 2, '0' ); + PRINT(); + } + break; + case 0x00CF: // SXEMPTY - cache entry: empty + { + ADDTEXT( "#" ); + __AddDec( t, nItemCnt, 3 ); + ADDTEXT( " (empty): " ); + nItemCnt++; + PRINT(); + } + break; + case 0x00D5: // SXIDSTM - pivot table cache stream id + { + LINESTART(); + UINT16 nStrId = Read2( rIn ); + ADDTEXT( "Stream ID: " ); + __AddHex( t, nStrId ); + PRINT(); + DumpRecordStream( OpenStorage( EXC_STORAGE_PTCACHE ), ScfTools::GetHexStr( nStrId ), EMPTY_STRING ); + } + break; + case 0x00D8: // SXNUMGROUP - numerical grouping in pivot cache field + { + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "fAutoMin" ); + ADDFLAG( 0x0002, "fAutoMax" ); + ADDTEXT( " data-type=" ); + switch( (__nFlags & 0x003C) >> 2 ) + { + case 0x0001: ADDTEXT( "seconds" ); break; + case 0x0002: ADDTEXT( "minutes" ); break; + case 0x0003: ADDTEXT( "hours" ); break; + case 0x0004: ADDTEXT( "days" ); break; + case 0x0005: ADDTEXT( "months" ); break; + case 0x0006: ADDTEXT( "quarters" ); break; + case 0x0007: ADDTEXT( "years" ); break; + case 0x0008: ADDTEXT( "numeric" ); break; + default: ADDTEXT( pU ); + } + (__nFlags &= 0xFFC0) >>= 6; + ADDTEXT( " remaining=" ); __AddHex( t, __nFlags ); + ADDTEXT( "=" ); __AddDec( t, __nFlags ); + PRINT(); + } + break; + case 0xE0: + DumpXF( rIn, pPre ); + break; + case 0xE3: + { + LINESTART(); + ADDTEXT( "view source (" ); + UINT16 n = Read2( rIn ); + __AddHex( t, n ); + ADDTEXT( "): " ); + switch( n ) + { + case 0x01: p = "M$ Excel list or database"; break; + case 0x02: p = "external data source"; break; + case 0x04: p = "multiple consolidation ranges"; break; + case 0x08: p = "pivot table"; break; + case 0x10: p = "scenario manager summary report"; break; + default: p = pU; + } + ADDTEXT( p ); + PRINT(); + } + break; + case 0x00E5: // CELLMERGING + { + UINT16 nCount, nInd; + UINT16 nRow1, nRow2, nCol1, nCol2; + rIn >> nCount; + LINESTART(); + ADDTEXT( "Count: " ); + __AddDec( t, nCount ); + PRINT(); + LINESTART(); + for( nInd = 0; nInd < 3; nInd++ ) + ADDTEXT( " row - row / col-col | " ); + PRINT(); + LINESTART(); + if( (ULONG)(nCount * 8 + 2) == nL ) + { + for( nInd = 0; nInd < nCount; nInd++ ) + { + rIn >> nRow1 >> nRow2 >> nCol1 >> nCol2; + __AddDec( t, nRow1, 5 ); + ADDTEXT( "-" ); + __AddDec( t, nRow2, 5 ); + ADDTEXT( " / " ); + __AddDec( t, nCol1, 3 ); + ADDTEXT( "-" ); + __AddDec( t, nCol2, 3 ); + ADDTEXT( " | " ); + if( (nInd % 3 == 2) || (nInd == nCount - 1) ) + { + PRINT(); + LINESTART(); + } + } + } + else + { + LINESTART(); + ADDTEXT( "<Wrong record length!>" ); + PRINT(); + } + } + break; + case 0xEB: + case 0xEC: + case 0xED: + EscherDump( nL, true ); + break; + case 0x00F6: // SXNAME + { + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0002, "fNameErr" ); + ADDRESERVED( 0xFFFD ); + ADDTEXT( " field=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + sal_Int16 nFunc; + rIn >> nFunc; + ADDTEXT( "function=" ); __AddHex( t, (INT32)nFunc ); + static const sal_Char* const ppcFuncs[] = { + "none", 0, "sum", "counta", "count", "average", "max", "min", + "product", "stdev", "stdevp", "var", "varp" }; + lcl_AddEnum( t, nFunc, ppcFuncs, STATIC_TABLE_SIZE( ppcFuncs ), 0, -1 ); + ADDTEXT( " SXPAIR-count=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x00F9: // SXFMLA + { + LINESTART(); + sal_uInt16 nSize; + rIn >> nSize; + ADDTEXT( "formula-size=" ); __AddDec( t, nSize ); + ADDTEXT( " SXNAME-count=" ); ADDDEC( 2 ); + PRINT(); + FormulaDump( nSize, FT_RangeName ); + } + break; + case 0xFC: + { + UINT16 nCnt = 0; + BOOL bOK = TRUE; + ContDump( 8 ); + + while( bOK && (rIn.GetRecLeft() > 0) ) + { + LINESTART(); + __AddDec( t, nCnt ); + ADDTEXT( ": " ); + bOK = AddUNICODEString( t, rIn ); + PRINT(); + nCnt++; + } + } + break; + case 0xFD: + { + LINESTART(); + ADDCELLHEAD(); + ADDTEXT( " sst = " ); + ADDDEC(4); + PRINT(); + } + break; + case 0x0100: // SXVDEX + { + LINESTART(); + sal_uInt32 __nFlags = Read4( rIn ); + STARTFLAG(); + if( __nFlags & 0x0000009F ) + { + ADDFLAG( 0x00000001, "fShowAllItems" ); + ADDFLAG( 0x00000002, "fDragToRow" ); + ADDFLAG( 0x00000004, "fDragToColumn" ); + ADDFLAG( 0x00000008, "fDragToPage" ); + ADDFLAG( 0x00000010, "fDragToHide" ); + ADDFLAG( 0x00000080, "fServerBased" ); + PRINT(); + LINESTART(); + } + if( __nFlags & 0x00007E00 ) + { + ADDTEXT( " " ); + ADDFLAG( 0x00000200, "fAutoSort" ); + ADDFLAG( 0x00000400, "fAscendSort" ); + ADDFLAG( 0x00000800, "fAutoShow" ); + ADDFLAG( 0x00001000, "fAscendShow" ); + ADDFLAG( 0x00002000, "fCalculatedField" ); + ADDFLAG( 0x00004000, "fLONewPage" ); // undocumented + PRINT(); + LINESTART(); + } + if( __nFlags & 0xFFE00000 ) + { + ADDTEXT( " " ); // Layout flags: + ADDFLAG( 0x00200000, "fLOReport" ); // undocumented + ADDFLAG( 0x00400000, "fLOBlankLine" ); // undocumented + ADDFLAG( 0x00800000, "fLOSubTotalTop" ); // undocumented + ADDTEXT( " show-items=" ); __AddDec( t, sal_uInt32( __nFlags >> 24 ) ); + PRINT(); + LINESTART(); + } + if( __nFlags & 0x001F8160 ) + { + ADDTEXT( " !RESERVED!" ); + PRINT(); + } + if( !__nFlags ) + PRINT(); + LINESTART(); + ADDTEXT( " sort-field=" ); + ADDDEC( 2 ); + ADDTEXT( " show-field=" ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "format=" ); + UINT16 n = Read2( rIn ); + if( n ) + __AddDec( t, n ); + else + ADDTEXT( "none" ); + PRINT(); + } + break; + case 0x0122: // SXDBEX - ext. cache info + { + ADDTEXT( "last changed: " ); ADDDOUBLE(); + ADDTEXT( " SXFORMULA recs: " ); ADDDEC( 4 ); + PRINT(); + } + break; + case 0x0138: // CHTRINFO - change tracking info + { + rIn.DisableDecryption(); + ADDTEXT( "14 bytes of unknown data..." ); + PRINT(); + ContDump( 14 ); + LINESTART(); + ADDTEXT( "16 bytes unknown identification:" ); + PRINT(); + ContDump( 16 ); + LINESTART(); + ADDTEXT( "unknown: " ); ADDHEX( 2 ); + ADDTEXT( " user: " ); + if( rIn.GetRecLeft() > 3 ) + AddUNICODEString( t, rIn ); + PRINT(); + LINESTART(); + __AddDec( t, (UINT16)(rIn.GetRecLeft() - 10) ); + ADDTEXT( " bytes of unknown data..." ); + PRINT(); + ContDump( rIn.GetRecLeft() - 10 ); + LINESTART(); + ADDTEXT( "date/time: " ); ADDDEC( 2 ); + ADDTEXT( "-" ); ADDDEC( 1 ); + ADDTEXT( "-" ); ADDDEC( 1 ); + ADDTEXT( " " ); ADDDEC( 1 ); + ADDTEXT( ":" ); ADDDEC( 1 ); + ADDTEXT( ":" ); ADDDEC( 1 ); + ADDTEXT( " unknown: " ); ADDHEX( 1 ); + ADDTEXT( " " ); ADDHEX( 2 ); + PRINT(); + } + break; + case 0x0137: // CHTRINSERT - change tracking: insert/remove + { + ADDTEXT( "len: " ); ADDDEC( 4 ); + ADDTEXT( " index: " ); ADDDEC( 4 ); + ADDTEXT( " op: " ); + UINT16 nOp; + rIn >> nOp; + switch( nOp ) + { + case 0x0000: ADDTEXT( "insert row" ); break; + case 0x0001: ADDTEXT( "insert column" ); break; + case 0x0002: ADDTEXT( "delete row" ); break; + case 0x0003: ADDTEXT( "delete column" ); break; + default: + __AddHex( t, nOp ); + ADDTEXT( " *UNKNOWN*" ); + } + ADDTEXT( " accept: " ); ADDHEX( 2 ); + ADDTEXT( " tab: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + UINT16 __nFlags = Read2( rIn ); + STARTFLAG(); + ADDFLAG( 0x0001, "fAuto" ); + ADDRESERVED( 0xFFFE ); + UINT16 nCol1, nRow1, nCol2, nRow2; + rIn >> nRow1 >> nRow2 >> nCol1 >> nCol2; + ADDTEXT( " range: " ); lcl_AddRangeRef( t, nCol1, nRow1, nCol2, nRow2 ); + ADDTEXT( " unknown: " ); ADDHEX( 4 ); + PRINT(); + } + break; + case 0x013B: // CHTRCELLCONTENT: change tracking: changed cell + { + PreDump( nL ); + ADDTEXT( "len: " ); ADDDEC( 4 ); + ADDTEXT( " index: " ); ADDDEC( 4 ); + ADDTEXT( " opcode: " ); ADDHEX( 2 ); + ADDTEXT( " accept: " ); ADDHEX( 2 ); + ADDTEXT( " tab: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + UINT16 nChg, nOldType, nNewType; + rIn >> nChg; + nOldType = (nChg & 0x0038) >> 3; + nNewType = nChg & 0x0007; + ADDTEXT( "change (" ); __AddHex( t, nChg ); + ADDTEXT( "): " ); + switch( nOldType ) + { + case 0x0000: ADDTEXT( "empty->" ); break; + case 0x0001: ADDTEXT( "RK->" ); break; + case 0x0002: ADDTEXT( "double->" ); break; + case 0x0003: ADDTEXT( "string->" ); break; + case 0x0004: ADDTEXT( "bool->" ); break; + case 0x0005: ADDTEXT( "formula->" ); break; + default: ADDTEXT( "*UNKNOWN*->" ); + } + switch( nNewType ) + { + case 0x0000: ADDTEXT( "empty" ); break; + case 0x0001: ADDTEXT( "RK" ); break; + case 0x0002: ADDTEXT( "double" ); break; + case 0x0003: ADDTEXT( "string" ); break; + case 0x0004: ADDTEXT( "bool" ); break; + case 0x0005: ADDTEXT( "formula" ); break; + default: ADDTEXT( "*UNKNOWN*" ); + } + UINT16 nFormatData = (nChg & 0xFF00); + if( (nFormatData == 0x1100) || (nFormatData == 0x1300) ) + ADDTEXT( "; contains add. data" ); + ADDTEXT( " format: " ); ADDHEX( 2 ); + UINT16 nCol, nRow; + rIn >> nRow >> nCol; + ADDTEXT( " address: " ); lcl_AddRef( t, nCol, nRow ); + PRINT(); + LINESTART(); + UINT16 nOldLen; + rIn >> nOldLen; + ADDTEXT( "old value len: " ); __AddHex( t, nOldLen ); + if( nOldType == 0x0003 ) + nOldLen >>= 1; + ADDTEXT( " unknown: " ); ADDHEX( 4 ); + PRINT(); + UINT16 nCount = 0; + switch( nFormatData ) + { + case 0x1100: nCount = 8; break; + case 0x1300: nCount = 4; break; + } + if( nCount ) + { + LINESTART(); + ADDTEXT( "additional format data:" ); + for( UINT16 nIndex = 0; nIndex < nCount; nIndex ++ ) + { + ADDTEXT( " " ); + ADDHEX( 2 ); + } + PRINT(); + } + if( nOldType ) + { + LINESTART(); + ADDTEXT( "old value: " ); + switch( nOldType ) + { + case 0x0001: + __AddRK( t, rIn.ReadInt32() ); + PRINT(); + break; + case 0x0002: + ADDDOUBLE(); + PRINT(); + break; + case 0x0003: + AddUNICODEString( t, rIn ); + PRINT(); + break; + case 0x0004: + if( Read2( rIn ) ) + ADDTEXT( "true" ); + else + ADDTEXT( "false" ); + PRINT(); + break; + case 0x0005: + { + PRINT(); + UINT16 nLen; + rIn >> nLen; + FormulaDump( nLen, FT_CellFormula ); + IGNORE( 1 ); + } + break; + } + } + if( nNewType ) + { + LINESTART(); + ADDTEXT( "new value: " ); + switch( nNewType ) + { + case 0x0001: + __AddRK( t, rIn.ReadInt32() ); + PRINT(); + break; + case 0x0002: + ADDDOUBLE(); + PRINT(); + break; + case 0x0003: + AddUNICODEString( t, rIn ); + PRINT(); + break; + case 0x0004: + if( Read2( rIn ) ) + ADDTEXT( "true" ); + else + ADDTEXT( "false" ); + PRINT(); + break; + case 0x0005: + { + PRINT(); + UINT16 nLen; + rIn >> nLen; + FormulaDump( nLen, FT_CellFormula ); + IGNORE( 1 ); + } + break; + } + } + if( rIn.GetRecLeft() > 0 ) + { + LINESTART(); + ADDTEXT( "*UNKNOWN* data:" ); + PRINT(); + PreDump( rIn.GetRecLeft() ); + } + } + break; + case 0x013D: // TABID + { + ADDTEXT( "tab ids:" ); + while( rIn.GetRecLeft() ) + { + ADDTEXT( " " ); + ADDDEC( 2 ); + } + PRINT(); + } + break; + case 0x0140: // CHTRMOVE - change tracking: moved range + { + ADDTEXT( "len: " ); ADDDEC( 4 ); + ADDTEXT( " index: " ); ADDDEC( 4 ); + ADDTEXT( " opcode: " ); ADDHEX( 2 ); + ADDTEXT( " accept: " ); ADDHEX( 2 ); + PRINT(); + UINT16 nTab1, nTab2; + UINT16 nCol11, nCol12, nCol21, nCol22; + UINT16 nRow11, nRow12, nRow21, nRow22; + rIn >> nTab2 >> nRow11 >> nRow12 >> nCol11 >> nCol12 >> nRow21 >> nRow22 >> nCol21 >> nCol22 >> nTab1; + LINESTART(); + ADDTEXT( "move range from: tab=" ); __AddDec( t, nTab1 ); + ADDTEXT( " " ); lcl_AddRangeRef( t, nCol11, nRow11, nCol12, nRow12 ); + ADDTEXT( " to: tab=" ); __AddDec( t, nTab2 ); + ADDTEXT( " " ); lcl_AddRangeRef( t, nCol21, nRow21, nCol22, nRow22 ); + ADDTEXT( " unknown: " ); ADDHEX( 4 ); + PRINT(); + } + break; + case 0x014D: // CHTRINSERTTAB - change tracking: insert tab + { + ADDTEXT( "len: " ); ADDDEC( 4 ); + ADDTEXT( " index: " ); ADDDEC( 4 ); + ADDTEXT( " opcode: " ); ADDHEX( 2 ); + ADDTEXT( " accept: " ); ADDHEX( 2 ); + ADDTEXT( " tab: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "unknown: " ); ADDHEX( 4 ); + ADDTEXT( " table name: " ); + AddUNICODEString( t, rIn ); + PRINT(); + LINESTART(); + __AddDec( t, (sal_uInt32)rIn.GetRecLeft() ); + ADDTEXT( " bytes of unknown data:" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + break; + case 0x015F: // LABELRANGES + { + UINT16 nCnt, nR1, nR2, nC1, nC2; + rIn >> nCnt; + ADDTEXT( "row headers: " ); __AddDec( t, nCnt ); + PRINT(); + while( nCnt-- ) + { + rIn >> nR1 >> nR2 >> nC1 >> nC2; + LINESTART(); + AddRangeRef( t, nR1, nC1 | 0xC000, nR2, nC2 | 0xC000, FALSE ); + PRINT(); + } + rIn >> nCnt; + LINESTART(); + ADDTEXT( "column headers: " ); __AddDec( t, nCnt ); + PRINT(); + while( nCnt-- ) + { + rIn >> nR1 >> nR2 >> nC1 >> nC2; + LINESTART(); + AddRangeRef( t, nR1, nC1 | 0xC000, nR2, nC2 | 0xC000, FALSE ); + PRINT(); + } + } + break; + case 0x0193: + { + ADDTEXT( "unknown: " ); ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "16 bytes unknown identification:" ); + PRINT(); + ContDump( 16 ); + LINESTART(); + ADDTEXT( "date/time: " ); ADDDEC( 2 ); + ADDTEXT( "-" ); ADDDEC( 1 ); + ADDTEXT( "-" ); ADDDEC( 1 ); + ADDTEXT( " " ); ADDDEC( 1 ); + ADDTEXT( ":" ); ADDDEC( 1 ); + ADDTEXT( ":" ); ADDDEC( 1 ); + ADDTEXT( " unknown: " ); ADDHEX( 1 ); + PRINT(); + LINESTART(); + ADDTEXT( "user: " ); + if( rIn.GetRecLeft() > 3 ) + AddUNICODEString( t, rIn ); + PRINT(); + } + break; + case 0x0194: + { + rIn.DisableDecryption(); + ADDTEXT( "unknown: " ); ADDHEX( 4 ); + ADDTEXT( " date/time: " ); ADDDEC( 2 ); + ADDTEXT( "-" ); ADDDEC( 1 ); + ADDTEXT( "-" ); ADDDEC( 1 ); + ADDTEXT( " " ); ADDDEC( 1 ); + ADDTEXT( ":" ); ADDDEC( 1 ); + ADDTEXT( ":" ); ADDDEC( 1 ); + ADDTEXT( " unknown: " ); ADDHEX( 1 ); + PRINT(); + LINESTART(); + ADDTEXT( "user: " ); + if( rIn.GetRecLeft() > 3 ) + AddUNICODEString( t, rIn ); + PRINT(); + LINESTART(); + __AddDec( t, (sal_uInt32)rIn.GetRecLeft() ); + ADDTEXT( " bytes of unknown data:" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + break; + case 0x0195: + rIn.DisableDecryption(); + ContDump( nL ); + break; + case 0x0196: + { + rIn.DisableDecryption(); + ADDTEXT( "unknown: " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "16 bytes unknown identification:" ); + PRINT(); + ContDump( 16 ); + LINESTART(); + ADDTEXT( "16 bytes unknown identification:" ); + PRINT(); + ContDump( 16 ); + LINESTART(); + ADDTEXT( "count of changes: " ); ADDDEC( 2 ); + ADDTEXT( " " ); + __AddDec( t, (sal_uInt32)rIn.GetRecLeft() ); + ADDTEXT( " bytes of unknown data:" ); + PRINT(); + ContDump( rIn.GetRecLeft() ); + } + break; + case 0x01A9: // USERBVIEW + { + LINESTART(); + ADDTEXT( "view id: " ); ADDHEX( 4 ); + ADDTEXT( " tab id: " ); ADDDEC( 4 ); + ADDTEXT( " guid: " ); __AddGUID( t, rIn ); + PRINT(); + LINESTART(); + ADDTEXT( "window x: " ); ADDDEC( 4 ); + ADDTEXT( " y: " ); ADDDEC( 4 ); + ADDTEXT( " width: " ); ADDDEC( 4 ); + ADDTEXT( " height: " ); ADDDEC( 4 ); + ADDTEXT( " ratio: " ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + UINT16 __nFlags = Read2( rIn ); + STARTFLAG(); + ADDFLAG( 0x0001, "fDsplFormulaBar" ); + ADDFLAG( 0x0002, "fDsplStatus" ); + ADDFLAG( 0x0004, "fNoteOff" ); + ADDFLAG( 0x0008, "fDsplHScroll" ); + ADDFLAG( 0x0010, "fDsplVScroll" ); + ADDFLAG( 0x0020, "fBotAdornment" ); + ADDFLAG( 0x0040, "fZoom" ); + ADDFLAG( 0x0080, "fShowPlaceHld" ); + ADDFLAG( 0x0100, "fHideAll" ); + if( !(__nFlags & 0x0180) ) + ADDTEXT( " fShowAll" ); + PRINT(); + LINESTART(); + ADDTEXT( "flags2: " ); ADDHEX( 2 ); + ADDTEXT( " merge int: " ); ADDDEC( 2 ); + ADDTEXT( " reserved: " ); ADDHEX( 2 ); + PRINT(); + if( rIn.GetRecLeft() > 3 ) + { + LINESTART(); + ADDTEXT( "name: " ); + AddUNICODEString( t, rIn ); + PRINT(); + } + } + break; + case 0x01AA: // USERSVIEWBEGIN + { + LINESTART(); + ADDTEXT( "guid: " ); __AddGUID( t, rIn ); + ADDTEXT( " tab id: " ); ADDDEC( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "wscale: " ); ADDDEC( 4 ); + ADDTEXT( " icolor: " ); ADDDEC( 4 ); + ADDTEXT( " pane: " ); ADDDEC( 4 ); + PRINT(); + LINESTART(); + UINT32 __nFlags = Read4( rIn ); + STARTFLAG(); + if( __nFlags & 0x000000FF ) + { + ADDFLAG( 0x00000001, "fShowPgBrk" ); + ADDFLAG( 0x00000002, "fDsplForml" ); + ADDFLAG( 0x00000004, "fDsplGrid" ); + ADDFLAG( 0x00000008, "fDsplRCHead" ); + ADDFLAG( 0x00000010, "fDsplGuts" ); + ADDFLAG( 0x00000020, "fDsplZeros" ); + ADDFLAG( 0x00000040, "fPrintHorC" ); + ADDFLAG( 0x00000080, "fPrintVerC" ); + PRINT(); + LINESTART(); + } + if( __nFlags & 0x00007F00 ) + { + ADDTEXT( " " ); + ADDFLAG( 0x00000100, "fPrintRCHead" ); + ADDFLAG( 0x00000200, "fPrintGrid" ); + ADDFLAG( 0x00000400, "fFitToPage" ); + ADDFLAG( 0x00000800, "fPrintArea" ); + ADDFLAG( 0x00001000, "fOnePrintArea" ); + ADDFLAG( 0x00002000, "fFilter" ); + ADDFLAG( 0x00004000, "fAutoFilter" ); + PRINT(); + LINESTART(); + } + if( __nFlags & 0xFFF80000 ) + { + ADDTEXT( " " ); + ADDFLAG( 0x00020000, "fSplitV" ); + ADDFLAG( 0x00040000, "fSplitH" ); + ADDFLAG( 0x00180000, "fHiddenRow" ); + ADDFLAG( 0x00200000, "fHiddenCol" ); + ADDFLAG( 0x01000000, "fChartSize" ); + ADDFLAG( 0x02000000, "fFilterUnique" ); + ADDFLAG( 0x04000000, "fLayoutView" ); + ADDRESERVED( 0xF8C18000 ); + PRINT(); + LINESTART(); + } + if( !__nFlags ) + PRINT(); + ADDTEXT( "visible: " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "pane pos vert: " ); ADDDOUBLE(); + ADDTEXT( " hor: " ); ADDDOUBLE(); + ADDTEXT( " 1st vis right: " ); ADDDEC( 2 ); + ADDTEXT( " bott: " ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x01AB: // USERSVIEWEND + { + LINESTART(); + ADDTEXT( "settings are valid: " ); ADDHEX( 2 ); + PRINT(); + } + break; + case 0x01AD: // QSI - web query range + { + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "fTitles" ); + ADDFLAG( 0x0002, "fRowNums" ); + ADDFLAG( 0x0004, "fDisRefr" ); + ADDFLAG( 0x0080, "fFill" ); + ADDFLAG( 0x0100, "fAutoFmt" ); + ADDFLAG( 0x0400, "fDisEdit" ); + ADDRESERVED( 0xFA78 ); + PRINT(); + LINESTART(); + ADDTEXT( "AutoFmt: " ); ADDDEC( 2 ); + ADDTEXT( " AutoFmtAttr: " ); ADDHEX( 2 ); + ADDTEXT( " reserved: " ); ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "name: " ); + AddUNICODEString( t, rIn ); + PRINT(); + } + break; + case 0x01AE: + { + LINESTART(); + ADDTEXT( "# of tabs: " ); + UINT16 nTabs; + rIn >> nTabs; + __AddDec( t, nTabs ); + rIn.PushPosition(); + PRINT(); + LINESTART(); + if( nL <= (ULONG)(2 + 2 * nTabs) ) + { + ADDTEXT( "----- shortened record -----" ); + PRINT(); + + rIn.PopPosition(); + ContDump( nL - 2 ); + } + else + { + rIn.RejectPosition(); + ADDTEXT( "file name: " ); + AddUNICODEString( t, rIn ); + PRINT(); + while( nTabs ) + { + LINESTART(); + ADDTEXT( " " ); + AddUNICODEString( t, rIn ); + PRINT(); + nTabs--; + } + } + + } + break; + case 0x01B0: // CONDFMT + { + LINESTART(); + ADDTEXT( "cf-count=" ); ADDDEC( 2 ); + rIn >> __nFlags; + ADDTEXT( " " ); + STARTFLAG(); + ADDFLAG( 0x0001, "tough-recalc" ); + ADDRESERVED( 0xFFFE ); + PRINT(); + LINESTART(); + sal_uInt16 nR1, nR2, nC1, nC2, nCount; + rIn >> nR1 >> nR2 >> nC1 >> nC2 >> nCount; + ADDTEXT( "max-range=" ); lcl_AddRangeRef( t, nC1, nR1, nC2, nR2 ); + ADDTEXT( " range-count=" ); __AddDec( t, nCount ); + PRINT(); + + for( sal_uInt16 nRange = 0; rIn.IsValid() && (nRange < nCount); ++nRange ) + { + if( !(nRange % 4) ) + { + LINESTART(); + ADDTEXT( pPre ); + } + rIn >> nR1 >> nR2 >> nC1 >> nC2; + ByteString aRef; + lcl_AddRangeRef( aRef, nC1, nR1, nC2, nR2 ); + aRef.Expand( 16, ' ' ); + ADDTEXT( aRef ); + if( (nRange % 4 == 3) || (nRange + 1 == nCount) ) + PRINT(); + } + } + break; + case 0x01B1: // CF - conditional format + { + sal_uInt8 nType, nOp; + sal_uInt16 nSize1, nSize2; + sal_uInt32 nFlags; + rIn >> nType >> nOp >> nSize1 >> nSize2 >> nFlags; + LINESTART(); + ADDTEXT( "type=" ); __AddHex( t, nType ); + ADDTEXT( " (" ); + switch( nType ) + { + case 0x01: ADDTEXT( "compare" ); break; + case 0x02: ADDTEXT( "formula" ); break; + default: ADDTEXT( "!unknown!" ); + } + ADDTEXT( ") operator=" ); __AddHex( t, nOp ); + ADDTEXT( " (" ); + switch( nOp ) + { + case 0x00: ADDTEXT( "none" ); break; + case 0x01: ADDTEXT( "between" ); break; + case 0x02: ADDTEXT( "not-between" ); break; + case 0x03: ADDTEXT( "equal" ); break; + case 0x04: ADDTEXT( "not-equal" ); break; + case 0x05: ADDTEXT( "greater" ); break; + case 0x06: ADDTEXT( "less" ); break; + case 0x07: ADDTEXT( "greater-eq" ); break; + case 0x08: ADDTEXT( "less-eq" ); break; + default: ADDTEXT( "!unknown!" ); + } + ADDTEXT( ")" ); + PRINT(); + LINESTART(); + ADDTEXT( "formula-size-1=" ); __AddDec( t, nSize1 ); + ADDTEXT( " formula-size-2=" ); __AddDec( t, nSize2 ); + PRINT(); + LINESTART(); + sal_uInt32 __nFlags = nFlags; + STARTFLAG(); + __nFlags = ~__nFlags; + ADDFLAG( 0x00000400, "bord-lft" ); + ADDFLAG( 0x00000800, "bord-rgt" ); + ADDFLAG( 0x00001000, "bord-top" ); + ADDFLAG( 0x00002000, "bord-bot" ); + ADDFLAG( 0x00010000, "patt-style" ); + ADDFLAG( 0x00020000, "patt-fgcol" ); + ADDFLAG( 0x00040000, "patt-bgcol" ); + __nFlags = ~__nFlags; + ADDFLAG( 0x04000000, "font" ); + ADDFLAG( 0x10000000, "bord" ); + ADDFLAG( 0x20000000, "patt" ); + ADDRESERVED( 0xCBC00000 ); + PRINT(); + LINESTART(); + ADDTEXT( "unknown=" ); ADDHEX( 2 ); + PRINT(); + if( nFlags & 0x04000000 ) + { + LINESTART(); ADDTEXT( "*** FONT ***" ); PRINT(); + ContDump( 64 ); + LINESTART(); + ADDTEXT( "height=" ); ADDHEX( 4 ); + rIn >> __nFlags; + ADDTEXT( " style-" ); + STARTFLAG(); + ADDFLAG( 0x00000002, "italic" ); + ADDFLAG( 0x00000080, "strikeout" ); + ADDRESERVED( 0xFFFFFF7D ); + ADDTEXT( " weight=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + sal_uInt16 nEsc; + rIn >> nEsc; + ADDTEXT( "escapement=" ); __AddDec( t, nEsc ); + ADDTEXT( " (" ); + switch( nEsc ) + { + case 0x0000: ADDTEXT( "none" ); break; + case 0x0001: ADDTEXT( "super" ); break; + case 0x0002: ADDTEXT( "sub" ); break; + default: ADDTEXT( "!unknown!" ); + } + sal_uInt8 nUnd; + rIn >> nUnd; + ADDTEXT( ") underline=" ); __AddDec( t, nUnd ); + ADDTEXT( " (" ); + switch( nUnd ) + { + case 0x00: ADDTEXT( "none" ); break; + case 0x01: ADDTEXT( "single" ); break; + case 0x02: ADDTEXT( "double" ); break; + default: ADDTEXT( "!unknown!" ); + } + ADDTEXT( ") unknown=" ); ADDHEX( 1 ); + ADDTEXT( " " ); ADDHEX( 1 ); + ADDTEXT( " " ); ADDHEX( 1 ); + PRINT(); + LINESTART(); + ADDTEXT( "color=" ); ADDHEX( 4 ); + ADDTEXT( " unknown=" ); ADDHEX( 4 ); + rIn >> __nFlags; + ADDTEXT( " used-" ); + STARTFLAG(); + __nFlags = ~__nFlags; + ADDFLAG( 0x00000002, "italic" ); + ADDFLAG( 0x00000080, "strikeout" ); + __nFlags = ~__nFlags; + ADDRESERVED( 0xFFFFFF65 ); + PRINT(); + LINESTART(); + ADDTEXT( "escape-def=" ); ADDHEX( 4 ); + ADDTEXT( " underl-def=" ); ADDHEX( 4 ); + PRINT(); + ContDump( 18 ); + } + if( nFlags & 0x10000000 ) + { + LINESTART(); ADDTEXT( "*** BORDER ***" ); PRINT(); + sal_uInt16 nLine; + sal_uInt32 nColor; + rIn >> nLine >> nColor; + LINESTART(); + ADDTEXT( "line-style=" ); __AddHex( t, nLine ); + ADDTEXT( " (lft=" ); __AddDec( t, (sal_uInt16)(nLine & 0x000F) ); + ADDTEXT( " rgt=" ); __AddDec( t, (sal_uInt16)((nLine & 0x00F0) >> 4) ); + ADDTEXT( " top=" ); __AddDec( t, (sal_uInt16)((nLine & 0x0F00) >> 8) ); + ADDTEXT( " bot=" ); __AddDec( t, (sal_uInt16)((nLine & 0xF000) >> 12) ); + ADDTEXT( ")" ); + PRINT(); + LINESTART(); + ADDTEXT( "line-color=" ); __AddHex( t, nColor ); + ADDTEXT( " (lft=" ); __AddDec( t, (sal_uInt16)(nColor & 0x0000007F) ); + ADDTEXT( " rgt=" ); __AddDec( t, (sal_uInt16)((nColor & 0x00003F80) >> 7) ); + ADDTEXT( " top=" ); __AddDec( t, (sal_uInt16)((nColor & 0x007F0000) >> 16) ); + ADDTEXT( " bot=" ); __AddDec( t, (sal_uInt16)((nColor & 0x3F800000) >> 23) ); + ADDTEXT( ") unknown=" ); ADDHEX( 2 ); + PRINT(); + } + if( nFlags & 0x20000000 ) + { + LINESTART(); ADDTEXT( "*** AREA ***" ); PRINT(); + sal_uInt16 nPatt, nColor; + rIn >> nPatt >> nColor; + LINESTART(); + ADDTEXT( "pattern=" ); __AddHex( t, nPatt ); + ADDTEXT( " (" ); __AddDec( t, (sal_uInt16)((nPatt & 0xFC00) >> 10) ); + ADDTEXT( ") color=" ); __AddHex( t, nColor ); + ADDTEXT( " (fg=" ); __AddDec( t, (sal_uInt16)(nColor & 0x007F) ); + ADDTEXT( " bg=" ); __AddDec( t, (sal_uInt16)((nColor & 0x3F80) >> 7) ); + ADDTEXT( ")" ); + PRINT(); + } + if( rIn.IsValid() && nSize1 && (rIn.GetRecLeft() >= nSize1) ) + { + LINESTART(); ADDTEXT( "*** FORMULA 1 ***" ); PRINT(); + FormulaDump( nSize1, FT_RangeName ); + } + if( rIn.IsValid() && nSize2 && (rIn.GetRecLeft() >= nSize2) ) + { + LINESTART(); ADDTEXT( "*** FORMULA 2 ***" ); PRINT(); + FormulaDump( nSize2, FT_RangeName ); + } + } + break; + case 0x01B2: // DVAL - header of DV recs + { + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDTEXT( " (" ); + __AddPureBin( t, __nFlags ); + ADDTEXT( ")" ); + ADDTEXT( "):" ); + ADDFLAG( 0x0001, "fWnClosed" ); + ADDFLAG( 0x0002, "fWnPinned" ); + ADDFLAG( 0x0004, "fCached" ); + PRINT(); + LINESTART(); + ADDTEXT( "input window: " ); + ADDHEX( 4 ); + ADDTEXT( " / " ); + ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "object id: " ); + ADDHEX( 4 ); + PRINT(); + LINESTART(); + ADDTEXT( "num of DV recs: " ); + ADDDEC( 4 ); + PRINT(); + } + break; + case 0x01B6: // TXO - text box + { + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + switch( __nFlags & 0x000E ) + { + case 0x0002: ADDTEXT( " h-left" ); break; + case 0x0004: ADDTEXT( " h-center" ); break; + case 0x0006: ADDTEXT( " h-right" ); break; + case 0x0008: ADDTEXT( " h-block" ); break; + default: ADDTEXT( " *h-unknown*" ); + } + switch( __nFlags & 0x0070 ) + { + case 0x0010: ADDTEXT( " v-top" ); break; + case 0x0020: ADDTEXT( " v-center" ); break; + case 0x0030: ADDTEXT( " v-bottom" ); break; + case 0x0040: ADDTEXT( " v-block" ); break; + default: ADDTEXT( " *v-unknown*" ); + } + ADDFLAG( 0x0200, "lock-text" ); + ADDRESERVED( 0xFD81 ); + ADDTEXT( " orient=" ); + sal_uInt16 nOrient = rIn.ReaduInt16(); + __AddDec( t, nOrient ); + ADDTEXT( " (" ); + switch( nOrient ) + { + case 0: ADDTEXT( "no-rot" ); break; + case 1: ADDTEXT( "stacked" ); break; + case 2: ADDTEXT( "90\xB0 ccw" ); break; + case 3: ADDTEXT( "90\xB0 cw" ); break; + default: ADDTEXT( "!unknown!" ); + } + ADDTEXT( ")" ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved=" ); + ADDHEX( 2 ); ADDTEXT( " " ); ADDHEX( 2 ); ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " text-len=" ); ADDDEC( 2 ); + ADDTEXT( " format-size=" ); ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved=" ); ADDHEX( 2 ); + sal_uInt16 nLinkSize = rIn.ReaduInt16(); + ADDTEXT( " link-size=" ); __AddDec( t, nLinkSize ); + PRINT(); + if( nLinkSize > 0 ) + { + LINESTART(); + sal_uInt16 nFmlaSize = rIn.ReaduInt16(); + ADDTEXT( "fmla-size=" ); __AddDec( t, nFmlaSize ); + ADDTEXT( " reserved=" ); ADDHEX( 4 ); + PRINT(); + FormulaDump( nFmlaSize, FT_CellFormula ); + } + } + break; + case 0x01BE: // DV - data validation record + { + UINT32 __nFlags; + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDTEXT( " (" ); + __AddPureBin( t, __nFlags ); + ADDTEXT( ")" ); + PRINT(); + LINESTART(); + if( __nFlags ) + { + ADDTEXT( " " ); + ADDFLAG( 0x00000080, "fStrLookup" ); + ADDFLAG( 0x00000100, "fAllowBlank" ); + ADDFLAG( 0x00000200, "fSuppressCombo" ); + ADDFLAG( 0x00040000, "fShowInputMsg" ); + ADDFLAG( 0x00080000, "fShowErrorMsg" ); + } + PRINT(); + LINESTART(); + ADDTEXT( "error style: " ); + const char* pErrStyle[] = { "stop", "warning", "info", "4" }; + ADDTEXT( pErrStyle[ ( __nFlags >> 4 ) & 0x03 ] ); + PRINT(); + LINESTART(); + const char* pValType[] = + { + "all", "integer", "decimal", "list", "date", "time", "text len", "user", + "8", "9", "A", "B", "C", "D", "E", "F" + }; + LINESTART(); + ADDTEXT( "validation type: " ); + ADDTEXT( pValType[ __nFlags & 0x0000000F ] ); + PRINT(); + + const char* pOpType[] = + { + "between", "not between", "equal", "not equal", + "greater", "less", "greater or equal", "less or equal", + "8", "9", "A", "B", "C", "D", "E", "F" + }; + LINESTART(); + ADDTEXT( "operator type: " ); + ADDTEXT( pOpType[ ( __nFlags >> 20 ) & 0x0000000F ] ); + PRINT(); + + LINESTART(); + ADDTEXT( "Prompt Title: " ); + AddUNICODEString( t, rIn ); + PRINT(); + LINESTART(); + ADDTEXT( "Error Title: " ); + AddUNICODEString( t, rIn ); + PRINT(); + LINESTART(); + ADDTEXT( "Prompt Message: " ); + AddUNICODEString( t, rIn ); + PRINT(); + LINESTART(); + ADDTEXT( "Error Message: " ); + AddUNICODEString( t, rIn ); + PRINT(); + if( rIn.GetRecLeft() > 8 ) + { + UINT16 nLen; + rIn >> nLen; + LINESTART(); + ADDTEXT( "Len1: " ); + __AddDec( t, nLen ); + ADDTEXT( " (unknown1: " ); + ADDHEX( 2 ); + ADDTEXT( ")" ); + PRINT(); + FormulaDump( nLen, FT_RangeName ); + + rIn >> nLen; + LINESTART(); + ADDTEXT( "Len2: " ); + __AddDec( t, nLen ); + ADDTEXT( " (unknown2: " ); + ADDHEX( 2 ); + ADDTEXT( ")" ); + PRINT(); + FormulaDump( nLen, FT_RangeName ); + + LINESTART(); + ADDTEXT( "range count: " ); + ADDHEX( 2 ); + PRINT(); + } + + while( rIn.GetRecLeft() >= 8 ) + { + // Row-Row / Col-Col + UINT16 nR1, nR2, nC1, nC2; + rIn >> nR1 >> nR2 >> nC1 >> nC2; + LINESTART(); + AddRangeRef( t, nR1, nC1 | 0xC000, nR2, nC2 | 0xC000, FALSE ); + PRINT(); + } + } + break; + case 0x01B8: // HLINK + { + PreDump( nL ); + + UINT32 n1, n2; + LINESTART(); + PRINT(); + UINT16 nR1, nR2, nC1, nC2; + rIn >> nR1 >> nR2 >> nC1 >> nC2; + ADDTEXT( "Cellrange=" ); + lcl_AddRangeRef( t, nC1, nR1, nC2, nR2 ); + PRINT(); + LINESTART(); + ADDTEXT( "GUID StdLink=" ); __AddGUID( t, rIn ); + PRINT(); + LINESTART(); + ADDTEXT( " must=79EAC9D0-BAF9-11CE-8C82-00AA004BA90B" ); + PRINT(); + LINESTART(); + ADDTEXT( "unknown=" ); ADDHEX( 4 ); + PRINT(); + UINT32 __nFlags = Read4( rIn ); + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x00000001, "fBody" ); + ADDFLAG( 0x00000002, "fAbs" ); + ADDFLAG( 0x00000014, "fDescr" ); + ADDFLAG( 0x00000008, "fMark" ); + ADDFLAG( 0x00000080, "fFrame" ); + ADDFLAG( 0x00000100, "fUNC" ); + ADDRESERVED( 0xFFFFFE60 ); + PRINT(); + + //description + String aData; + if( __nFlags & 0x00000014 ) + { + LINESTART(); + rIn >> n1; + ADDTEXT( "## Description ## [l=" ); + __AddDec( t, n1 ); + ADDTEXT( "]: '" ); + aData = rIn.ReadRawUniString( (USHORT)(n1 - 1), TRUE ); + t += GETSTR( aData ); + ADDTEXT( "<" ); ADDHEX( 2 ); ADDTEXT( ">'" ); // trailing zero + PRINT(); + } + + // frame name + if( __nFlags & 0x00000080 ) + { + LINESTART(); + rIn >> n1; + ADDTEXT( "## Frame ## [l=" ); + __AddDec( t, n1 ); + ADDTEXT( "]: '" ); + aData = rIn.ReadRawUniString( (USHORT)(n1 - 1), TRUE ); + t += GETSTR( aData ); + ADDTEXT( "<" ); ADDHEX( 2 ); ADDTEXT( ">'" ); // trailing zero + PRINT(); + } + + // network path + if( __nFlags & 0x00000100 ) + { + LINESTART(); + rIn >> n1; + ADDTEXT( "## UNC ## [l=" ); + __AddDec( t, n1 ); + ADDTEXT( "]: '" ); + aData = rIn.ReadRawUniString( (USHORT)(n1 - 1), TRUE ); + t += GETSTR( aData ); + ADDTEXT( "<" ); ADDHEX( 2 ); ADDTEXT( ">'" ); // trailing zero + PRINT(); + } + + // file link or URL + else if( __nFlags & 0x00000001 ) + { + rIn.PushPosition(); + rIn >> n1; + rIn.PopPosition(); + LINESTART(); + ADDTEXT( "## Content GUID ## " ); + __AddGUID( t, rIn ); + switch( n1 ) + { + case 0x00000303: // file + { + ADDTEXT( " File Moniker" ); + PRINT(); + LINESTART(); + ADDTEXT( " must=00000303-0000-0000-C000-000000000046" ); + PRINT(); + LINESTART(); + ADDTEXT( "## File link ## up level=" ); + ADDDEC( 2 ); + rIn >> n2; + ADDTEXT( " [l=" ); __AddDec( t, n2 ); + ADDTEXT( ", 8-Bit]: '" ); + aData = rIn.ReadRawByteString( (USHORT)(n2 - 1) ); + t += GETSTR( aData ); + ADDTEXT( "<" ); ADDHEX( 1 ); ADDTEXT( ">'" ); // trailing zero + PRINT(); + ContDump( 24 ); + rIn >> n2; + LINESTART(); + ADDTEXT( "bytes left=" ); __AddDec( t, n2 ); + if( n2 ) + { + rIn >> n2; + LINESTART(); + ADDTEXT( " string byte count=" ); + __AddDec( t, n2 ); + ADDTEXT( " unknown=" ); + ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "[l=" ); + __AddDec( t, n2 / 2 ); + ADDTEXT( "]: '" ); + aData = rIn.ReadRawUniString( (USHORT)n2, TRUE ); + t += GETSTR( aData ); + ADDTEXT( "'" ); + } + PRINT(); + } + break; + case 0x79EAC9E0: // URL + { + ADDTEXT( " URL Moniker" ); + PRINT(); + LINESTART(); + ADDTEXT( " must=79EAC9E0-BAF9-11CE-8C82-00AA004BA90B" ); + PRINT(); + rIn >> n2; + LINESTART(); + ADDTEXT( "## URL ## string byte count=" ); + __AddDec( t, n2 ); + PRINT(); + LINESTART(); + ADDTEXT( "[l=" ); + __AddDec( t, n2 / 2 ); + ADDTEXT( "]: '" ); + aData = rIn.ReadRawUniString( (USHORT)(n2 / 2 - 1), TRUE ); + t += GETSTR( aData ); + ADDTEXT( "<" ); ADDHEX( 2 ); ADDTEXT( ">'" ); // trailing zero + PRINT(); + } + break; + default: + { + ADDTEXT( " (!!UNKNOWN!!)" ); + PRINT(); + } + break; + } + } + + // text mark + if( __nFlags & 0x00000008 ) + { + LINESTART(); + rIn >> n1; + ADDTEXT( "## Text mark ## [l=" ); + __AddDec( t, n1 ); + ADDTEXT( "]: '" ); + aData = rIn.ReadRawUniString( (USHORT)(n1 - 1), TRUE ); + t += GETSTR( aData ); + ADDTEXT( "<" ); ADDHEX( 2 ); ADDTEXT( ">'" ); // trailing zero + PRINT(); + } + } + break; + case 0x01BB: // SXFDBTYPE - SQL data type + { + ADDTEXT( "SQL data type: " ); ADDHEX( 2 ); + PRINT(); + } + break; + case 0x0201: + { + LINESTART(); + ADDCELLHEAD(); + PRINT(); + } + break; + case 0x0203: + { + LINESTART(); + ADDCELLHEAD(); + ADDTEXT( " val = " ); + ADDDOUBLE(); + PRINT(); + } + break; + case 0x0205: + { + LINESTART(); + ADDCELLHEAD(); + ADDTEXT( " val = " ); ADDHEX( 1 ); + ADDTEXT( " type = " ); ADDDEC( 1 ); + PRINT(); + } + break; + case 0x0208: // ROW - row info + { + LINESTART(); + ADDTEXT( "row #: " ); ADDDEC( 2 ); + ADDTEXT( " def. cols: " ); ADDDEC( 2 ); + ADDTEXT( "-" ); ADDDEC( 2 ); + ADDTEXT( " ht: " ); ADDDEC( 2 ); + ADDTEXT( " reserved: " ); ADDHEX( 4 ); + PRINT(); + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDTEXT( " outlnlev=" ); + __AddDec( t, (UINT16)(__nFlags & 0x0007) ); + ADDFLAG( 0x0010, "fCollapsed" ); + ADDFLAG( 0x0020, "fRowHeightZero" ); + ADDFLAG( 0x0040, "fUnsynced" ); + ADDFLAG( 0x0080, "fGhostDirty" ); + ADDRESERVED( 0xFF08 ); + PRINT(); + UINT16 nXF; + rIn >> nXF; + LINESTART(); + ADDTEXT( "ix to XF: " ); __AddDec( t, (UINT16)(nXF & 0x0FFF) ); + ADDTEXT( " add. flags(" ); __AddHex( t, nXF ); + ADDTEXT( "):" ); + ADDFLAG( 0x1000, "fExAsc" ); + ADDFLAG( 0x2000, "fExDsc" ); + ADDRESERVED( 0xC000 ); + PRINT(); + } + break; + case 0x0021: // ARRAY + case 0x0221: + { + UINT16 nR1, nR2; + UINT8 nC1, nC2; + rIn >> nR1 >> nR2 >> nC1 >> nC2 >> __nFlags; + LINESTART(); + ADDTEXT( "range: " ); + lcl_AddRangeRef( t, nC1, nR1, nC2, nR2 ); + PRINT(); + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAlwaysCalc" ); + ADDFLAG( 0x0002, "fCalcOnLoad" ); + ADDRESERVED( 0xFFFC ); + PRINT(); + LINESTART(); + ADDTEXT( "chn = " ); + ADDHEX( 4 ); + UINT16 n; + rIn >> n; + ADDTEXT( " cce = " ); + __AddDec( t, n ); + PRINT(); + FormulaDump( n, FT_SharedFormula ); + } + break; + case 0x0225: // DEFAULTROWHEIGHT - height & flags + { + rIn >> __nFlags; + LINESTART(); + ADDTEXT( "default row " ); + STARTFLAG(); + ADDFLAG( 0x0001, "fUnsynced" ); + ADDFLAG( 0x0002, "fRowHtZero" ); + ADDFLAG( 0x0004, "fExAsc" ); + ADDFLAG( 0x0008, "fExDsc" ); + ADDRESERVED( 0xFFF0 ); + PRINT(); + LINESTART(); + ADDTEXT( "default row height: " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x023E: // WINDOW2 + { + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "show-formulas" ); + ADDFLAG( 0x0002, "show-grid" ); + ADDFLAG( 0x0004, "show-headers" ); + ADDFLAG( 0x0008, "frozen" ); + ADDFLAG( 0x0010, "show-zero" ); + ADDFLAG( 0x0020, "auto-grid-color" ); + ADDFLAG( 0x0040, "right-to-left" ); + ADDFLAG( 0x0080, "show-outline" ); + ADDFLAG( 0x0100, "remove-splits" ); + ADDFLAG( 0x0200, "sheet-selected" ); + ADDFLAG( 0x0400, "sheet-visible" ); + ADDFLAG( 0x0800, "show-pagebreak" ); + ADDRESERVED( 0xF000 ); + PRINT(); + LINESTART(); + ADDTEXT( "first-row=" ); ADDDEC( 2 ); + ADDTEXT( " first-col=" ); ADDDEC( 2 ); + ADDTEXT( " grid-color=" ); ADDDEC( 2 ); + ADDTEXT( " reserved=" ); ADDHEX( 2 ); + PRINT(); + // reallife: WINDOW2 in charts do not have teh following fields + if( rIn.GetRecLeft() >= 8 ) + { + LINESTART(); + ADDTEXT( "pagebreak-zoom=" ); ADDDEC( 2 ); + ADDTEXT( "% view-zoom=" ); ADDDEC( 2 ); + ADDTEXT( "% reserved=" ); ADDHEX( 4 ); + PRINT(); + } + } + break; + case 0x027E: + { + ADDCELLHEAD(); + ADDTEXT( " val = " ); + __AddRK( t, rIn.ReadInt32() ); + PRINT(); + } + break; + case 0x0293: // STYLE + { + LINESTART(); + sal_uInt16 nXF; + rIn >> nXF; + ADDTEXT( "xf-ref=" ); __AddHex( t, nXF ); + ADDTEXT( " (xf=#" ); __AddDec( t, static_cast< sal_uInt16 >( nXF & EXC_STYLE_XFMASK ) ); + if( ::get_flag( nXF, EXC_STYLE_BUILTIN ) ) + { + sal_uInt8 nStyleId, nLevel; + rIn >> nStyleId >> nLevel; + ADDTEXT( " builtin) style-id=" ); __AddDec( t, nStyleId ); + ADDTEXT( " (" ); + static const sal_Char* ppcStyles[] = { + "Normal", "RowLevel", "ColLevel", "Comma", "Currency", + "Percent", "Comma_0", "Currency_0", + "Hyperlink", "Followed_Hyperlink" }; + if( nStyleId < STATIC_TABLE_SIZE( ppcStyles ) ) + ADDTEXT( ppcStyles[ nStyleId ] ); + else + ADDTEXT( "!unknown!" ); + ADDTEXT( ") outline-level=" ); __AddDec( t, nLevel ); + } + else + { + ADDTEXT( ") name=" ); + AddUNICODEString( t, rIn ); + } + PRINT(); + } + break; + case 0x041E: + { + LINESTART(); + ADDTEXT( "Index: " ); ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "Format: " ); AddUNICODEString( t, rIn ); + PRINT(); + } + break; + case 0x04BC: + { + UINT16 nR1, nR2; + UINT8 nC1, nC2; + LINESTART(); + rIn >> nR1 >> nR2 >> nC1 >> nC2; + lcl_AddRangeRef( t, nC1, nR1, nC2, nR2 ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved = " ); + __AddPureHex( t, Read2( rIn ) ); + UINT16 n; + rIn >> n; + ADDTEXT( " cce = " ); + __AddDec( t, n ); + PRINT(); + FormulaDump( n, FT_SharedFormula ); + } + break; + case 0x0803: // WEBQRYSETTINGS - web query: options + { + UINT16 nCnt; + LINESTART(); + ADDTEXT( "repeated recnum: " ); + ADDHEX( 2 ); + ADDTEXT( " unknown:" ); + for( nCnt = 0; nCnt < 3; nCnt++ ) + { + ADDTEXT( " " ); + ADDHEX( 2 ); + } + PRINT(); + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0001, "fImportPRE" ); + ADDFLAG( 0x0002, "fIgnoreSep" ); + ADDFLAG( 0x0004, "fUseSetting" ); + ADDFLAG( 0x0010, "fIgnoreDate" ); + ADDFLAG( 0x0020, "fWhatIsIt?" ); + ADDRESERVED( 0xFFC8 ); + PRINT(); + LINESTART(); + rIn >> __nFlags; + STARTFLAG(); + ADDFLAG( 0x0002, "fTables" ); + ADDRESERVED( 0xFFFD ); + PRINT(); + LINESTART(); + ADDTEXT( "unknown: " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "refresh: " ); ADDDEC( 2 ); + ADDTEXT( " unknown: " ); ADDHEX( 2 ); + ADDTEXT( " " ); ADDHEX( 2 ); + PRINT(); + } + break; + case 0x0804: // WEBQRYTABLES - web query: selected tables + { + LINESTART(); + ADDTEXT( "repeated recnum: " ); ADDHEX( 2 ); + ADDTEXT( " unknown: " ); ADDHEX( 2 ); + PRINT(); + if( nL > 6 ) + { + LINESTART(); + ADDTEXT( "text: " ); + AddUNICODEString( t, rIn ); + PRINT(); + } + } + break; + case 0x0809: // BOF + { + rIn.DisableDecryption(); + LINESTART(); + ADDTEXT( "version number: " ); + ADDHEX( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "substream type: " ); + rIn >> mnSubstream; + __AddHex( t, mnSubstream ); + ADDTEXT( " (" ); + switch( mnSubstream ) + { + case 0x0005: p = "Workbook globals"; break; + case 0x0006: p = "Visual Basic module"; break; + case 0x0010: p = "Worksheet or dialog sheet"; break; + case 0x0020: p = "Chart"; break; + case 0x0040: p = "MS 4.0 Macro"; break; + case 0x0100: p = "Workspace file"; break; + default: p = pU; + } + ADDTEXT( p ); + ADDTEXT( ")" ); + PRINT(); + LINESTART(); + UINT16 n; + rIn >> n; + ADDTEXT( "build identifier: "); + __AddHex( t, n ); + ADDTEXT( " (=" ); + __AddDec( t, n ); + ADDTEXT( ")" ); + PRINT(); + + LINESTART(); + rIn >> n; + ADDTEXT( "build year: "); + __AddHex( t, n ); + ADDTEXT( " (=" ); + __AddDec( t, n ); + ADDTEXT( ")" ); + PRINT(); + + UINT32 __nFlags; + rIn >> __nFlags; + LINESTART(); + ADDTEXT( "file history " ); + STARTFLAG(); + if( __nFlags ) + { + ADDFLAG( 0x00000001, "fWin" ); + ADDFLAG( 0x00000002, "fRisc" ); + ADDFLAG( 0x00000004, "fBeta" ); + ADDFLAG( 0x00000008, "fWinAny" ); + ADDFLAG( 0x00000010, "fMacAny" ); + ADDFLAG( 0x00000020, "fBetaAny" ); + ADDFLAG( 0x00000100, "fRiscAny" ); + ADDRESERVED( 0xFFFFE0C0 ); + } + PRINT(); + + LINESTART(); + ADDTEXT( "lowest BIFF version: "); + ADDHEX( 4 ); + PRINT(); + } + break; + case 0x1002: // ChartChart + { + LINESTART(); + ADDTEXT( "Pos = " ); + ADD16P16(); + ADDTEXT( " / " ); + ADD16P16(); + ADDTEXT( " Size = " ); + ADD16P16(); + ADDTEXT( " / " ); + ADD16P16(); + PRINT(); + } + break; + case 0x1003: // ChartSeries + { + sal_uInt16 nCatType, nValType, nCatCnt, nValCnt, nBubType, nBubCnt; + rIn >> nCatType >> nValType >> nCatCnt >> nValCnt >> nBubType >> nBubCnt; + LINESTART(); + ADDTEXT( "category-type=" ); __AddDec( t, nCatType ); + ADDTEXT( " " ); ADDTEXT( GetSeriesType( nCatType ) ); + ADDTEXT( " count=" ); __AddDec( t, nCatCnt ); + PRINT(); + LINESTART(); + ADDTEXT( " value-type=" ); __AddDec( t, nValType ); + ADDTEXT( " " ); ADDTEXT( GetSeriesType( nValType ) ); + ADDTEXT( " count=" ); __AddDec( t, nValCnt ); + PRINT(); + LINESTART(); + ADDTEXT( " bubble-type=" ); __AddDec( t, nBubType ); + ADDTEXT( " " ); ADDTEXT( GetSeriesType( nBubType ) ); + ADDTEXT( " count=" ); __AddDec( t, nBubCnt ); + PRINT(); + } + break; + case 0x1006: // ChartDataformat + { + INT16 n; + LINESTART(); + rIn >> n; + ADDTEXT( "Point number = " ); + __AddDec( t, n ); + if( n == -1 ) + ADDTEXT( " (entire series)" ); + PRINT(); + LINESTART(); + ADDTEXT( "Series index = " ); + ADDDEC( 2 ); + ADDTEXT( " Series number = " ); + ADDDEC( 2 ); + if( Read2( rIn ) & 0x01 ) + ADDTEXT( " (fXL4iss)" ); + PRINT(); + } + break; + case 0x1007: // ChartLineform + { + LINESTART(); + ADDTEXT( "Color = " ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + ADDTEXT( " Pattern : " ); + ADDTEXT( GetLineType( Read2( rIn ) ) ); + switch( ( INT16 ) Read2( rIn ) ) + { + case -1: p = "hairline"; break; + case 0: p = "narrow (single)"; break; + case 1: p = "medium (double)"; break; + case 2: p = "wide (triple)"; break; + default: p = pU; + } + ADDTEXT( ", " ); + ADDTEXT( p ); + PRINT(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAuto" ); + ADDFLAG( 0x0004, "fDrawTick" ); + PRINT(); + } + LINESTART(); + ADDTEXT( "color index = " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x1009: // ChartMarkerformat + { + UINT16 n; + LINESTART(); + ADDTEXT( "Fore = " ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + ADDTEXT( " Back = " ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + rIn >> n; + switch( n ) + { + case 0: p = "no marker"; break; + case 1: p = "square"; break; + case 2: p = "diamond"; break; + case 3: p = "triangle"; break; + case 4: p = "X"; break; + case 5: p = "star"; break; + case 6: p = "Dow-Jones"; break; + case 7: p = "std deviation"; break; + case 8: p = "circle"; break; + case 9: p = "plus sign"; break; + default: p = pU; + } + ADDTEXT( " Type = " ); + ADDTEXT( p ); + PRINT(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAuto" ); + ADDFLAG( 0x0010, "fNoBackg" ); + ADDFLAG( 0x0020, "fNoFore" ); + ADDRESERVED( 0xFFCE ); + PRINT(); + } + LINESTART(); + ADDTEXT( "border color = " ); + ADDDEC( 2 ); + ADDTEXT( " fill color = " ); + ADDDEC( 2 ); + ADDTEXT( " size = " ); + ADDDEC(4); + PRINT(); + } + break; + case 0x100A: // ChartAreaformat + { + LINESTART(); + ADDTEXT( "Fore = " ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + ADDTEXT( " Back = " ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + ADDTEXT( " Pattern = " ); + UINT16 n; + rIn >> n >> __nFlags; + __AddDec( t, n ); + ADDTEXT( " (" ); + __AddHex( t, n ); + ADDTEXT( ")" ); + PRINT(); + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x01, "fAuto" ); + ADDFLAG( 0x02, "fInvertNeg" ); + PRINT(); + } + } + LINESTART(); + ADDTEXT( "color index fore = " ); + ADDDEC( 2 ); + ADDTEXT( ", back = " ); + ADDDEC( 2 ); + PRINT(); + break; + case 0x100B: // ChartPieformat + LINESTART(); + ADDDEC( 2 ); + ADDTEXT( "%" ); + PRINT(); + break; + case 0x100C: // ChartAttachedlabel + ContDump( nL ); + break; + case 0x100D: // ChartSeriestext + ContDump( nL ); + break; + case 0x1014: // ChartChartformat + { + ContDump( 16 ); + LINESTART(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fVaried" ); + PRINT(); + } + LINESTART(); + ADDTEXT( "drawing order = " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x1015: // ChartLegend + { + UINT32 nX, nY, nDx, nDy; + UINT8 nWType, nWSpacing; + rIn >> nX >> nY >> nDx >> nDy >> nWType >> nWSpacing >> __nFlags; + LINESTART(); + __AddDec( t, nX ); + ADDTEXT( " / " ); + __AddDec( t, nY ); + ADDTEXT( " [" ); + __AddDec( t, nDx ); + ADDTEXT( " / " ); + __AddDec( t, nDy ); + ADDTEXT( "]" ); + PRINT(); + LINESTART(); + ADDTEXT( " Type: " ); + switch( nWType ) + { + case 0: p = "bottom"; break; + case 1: p = "corner"; break; + case 2: p = "top"; break; + case 3: p = "right"; break; + case 4: p = "left"; break; + case 7: p = "not docked or inside the plot area"; break; + default: p = pU; + } + ADDTEXT( p ); + ADDTEXT( " Spacing: " ); + switch( nWSpacing ) + { + case 0: p = "close"; break; + case 1: p = "medium"; break; + case 2: p = "open"; break; + default: p = pU; + } + ADDTEXT( p ); + PRINT(); + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x01, "fAutoPosition" ); + ADDFLAG( 0x02, "fAutoSeries" ); + ADDFLAG( 0x04, "fAutoPosX" ); + ADDFLAG( 0x08, "fAutoPosY" ); + ADDFLAG( 0x10, "fVert" ); + ADDFLAG( 0x20, "fWasDataTable" ); + PRINT(); + } + } + break; + case 0x1016: // ChartSerieslist + ContDump( nL ); + break; + case 0x1017: // ChartBar + { + LINESTART(); + ADDTEXT( "space betw. bars = " ); + ADDDEC( 2 ); + ADDTEXT( " space betw. cat = " ); + ADDDEC( 2 ); + PRINT(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fTranspose" ); + ADDFLAG( 0x0002, "fStacked" ); + ADDFLAG( 0x0004, "f100" ); + ADDFLAG( 0x0008, "fHasShadow" ); + PRINT(); + } + } + break; + case 0x1018: // ChartLine + ContDump( nL ); + break; + case 0x1019: // ChartPie + ContDump( nL ); + break; + case 0x101A: // ChartArea + ContDump( nL ); + break; + case 0x101C: // ChartLine + ContDump( nL ); + break; + case 0x101D: // ChartAxis + { + static const sal_Char* const ppcIds[] = { "x-axis", "y-axis", "z-axis" }; + LINESTART(); + sal_uInt16 nAxisId = rIn.ReaduInt16(); + ADDTEXT( "axis-id=" ); __AddDec( t, nAxisId ); + lcl_AddEnum( t, nAxisId, ppcIds, STATIC_TABLE_SIZE( ppcIds ) ); + PRINT(); + ContDump( 16 ); + } + break; + case 0x101E: // CHTICK + { + static const sal_Char* const ppcTickMode[] = { "off", "inside", "outside", "cross" }; + static const sal_Char* const ppcTickPos[] = { "off", "low", "high", "next-to-axis" }; + static const sal_Char* const ppcText[] = { "transparent", "opaque" }; + LINESTART(); + sal_uInt8 nMajor, nMinor, nPos, nText; + rIn >> nMajor >> nMinor >> nPos >> nText; + ADDTEXT( "major=" ); __AddDec( t, nMajor ); + lcl_AddEnum( t, nMajor, ppcTickMode, STATIC_TABLE_SIZE( ppcTickMode ) ); + ADDTEXT( " minor=" ); __AddDec( t, nMinor ); + lcl_AddEnum( t, nMinor, ppcTickMode, STATIC_TABLE_SIZE( ppcTickMode ) ); + PRINT(); + LINESTART(); + ADDTEXT( "position=" ); __AddDec( t, nPos ); + lcl_AddEnum( t, nPos, ppcTickPos, STATIC_TABLE_SIZE( ppcTickPos ) ); + ADDTEXT( " text-mode=" ); __AddDec( t, nText ); + lcl_AddEnum( t, nText, ppcText, STATIC_TABLE_SIZE( ppcText ) ); + ADDTEXT( " text-color=" ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved=" ); ADDHEX( 4 ); + ADDTEXT( "," ); ADDHEX( 4 ); + ADDTEXT( "," ); ADDHEX( 4 ); + ADDTEXT( "," ); ADDHEX( 4 ); + PRINT(); + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAutoCol" ); + ADDFLAG( 0x0002, "fAutoBack" ); + ADDFLAG( 0x0020, "fAutoRot" ); + ADDRESERVED( 0xFFDC ); + PRINT(); + LINESTART(); + ADDTEXT( "color=" ); ADDDEC( 2 ); + ADDTEXT( " rotation=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x101F: // CHVALUERANGE + { + LINESTART(); + ADDTEXT( "min=" ); ADDDOUBLE(); + ADDTEXT( " max=" ); ADDDOUBLE(); + ADDTEXT( " major=" ); ADDDOUBLE(); + ADDTEXT( " minor=" ); ADDDOUBLE(); + ADDTEXT( " axis-cross=" ); ADDDOUBLE(); + PRINT(); + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAutoMin" ); + ADDFLAG( 0x0002, "fAutoMax" ); + ADDFLAG( 0x0004, "fAutoMajor" ); + ADDFLAG( 0x0008, "fAutoMinor" ); + ADDFLAG( 0x0010, "fAutoCross" ); + ADDFLAG( 0x0020, "fLogScale" ); + ADDFLAG( 0x0040, "fReverse" ); + ADDFLAG( 0x0080, "fMaxCross" ); + ADDRESERVED( 0xFF00 ); + PRINT(); + } + break; + case 0x1020: // CHEXTRANGE + { + LINESTART(); + ADDTEXT( "axis-cross=" ); ADDDEC( 2 ); + ADDTEXT( " label-freq=" ); ADDDEC( 2 ); + ADDTEXT( " mark-freq=" ); ADDDEC( 2 ); + PRINT(); + rIn >> __nFlags; + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fBetween" ); + ADDFLAG( 0x0002, "fMaxCross" ); + ADDFLAG( 0x0004, "fReverse" ); + ADDRESERVED( 0xFFF8 ); + PRINT(); + } + break; + case 0x1021: // ChartAxislineformat + { + LINESTART(); + switch( Read2( rIn ) ) + { + case 0: p = "axis line itself"; break; + case 1: p = "major grid line"; break; + case 2: p = "minor grid line"; break; + case 3: p = "walls or floor"; break; + default: p = pU; + } + ADDTEXT( p ); + PRINT(); + } + break; + case 0x1022: // CHARTFORMATLINK + ContDump( nL ); + break; + case 0x1024: // ChartDefaulttext + ContDump( nL ); + break; + case 0x1025: // ChartText + { + LINESTART(); + UINT8 nAt, nVat; + UINT16 nBkgMode; + INT32 nX, nY, nDx, nDy; + UINT16 nGrbit2, nIcvText; + INT16 nTrot; + rIn >> nAt >> nVat >> nBkgMode; + ADDTEXT( "h = " ); + switch( nAt ) + { + case 1: p = "left"; break; + case 2: p = "center"; break; + case 3: p = "right"; break; + case 4: p = "justify"; break; + case 5: p = "distribute"; break; + default: p = pU; + } + ADDTEXT( p ); + ADDTEXT( " v = " ); + switch( nVat ) + { + case 1: p = "top"; break; + case 2: p = "center"; break; + case 3: p = "bottom"; break; + case 4: p = "justify"; break; + case 5: p = "distribute"; break; + default: p = pU; + } + ADDTEXT( p ); + ADDTEXT( " mode = " ); + if( nBkgMode == 1 ) + ADDTEXT( "transparent" ); + else if( nBkgMode == 2 ) + ADDTEXT( "opaque" ); + else + ADDTEXT( pU ); + PRINT(); + LINESTART(); + ADDTEXT( "color = " ); + ADDTEXT( GetRGB( Read4( rIn ) ) ); + rIn >> nX >> nY >> nDx >> nDy >> __nFlags >> nIcvText >> nGrbit2 >> nTrot; + ADDTEXT( " pos[size] = " ); + __AddDec( t, nX ); + ADDTEXT( " / " ); + __AddDec( t, nY ); + ADDTEXT( " [" ); + __AddDec( t, nDx ); + ADDTEXT( " / " ); + __AddDec( t, nDy ); + ADDTEXT( "]" ); + PRINT(); + LINESTART(); + ADDTEXT( " (pos[size] = " ); + __AddHex( t, nX ); + ADDTEXT( " / " ); + __AddHex( t, nY ); + ADDTEXT( " [" ); + __AddHex( t, nDx ); + ADDTEXT( " / " ); + __AddHex( t, nDy ); + ADDTEXT( "])" ); + PRINT(); + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAutoColor" ); + ADDFLAG( 0x0002, "fShowKey" ); + ADDFLAG( 0x0004, "fShowValue" ); + ADDFLAG( 0x0008, "fVert" ); + ADDFLAG( 0x0010, "fAutoText" ); + ADDFLAG( 0x0020, "fGenerated" ); + ADDFLAG( 0x0040, "fDeleted" ); + ADDFLAG( 0x0080, "fAutoMode" ); + ADDFLAG( 0x0800, "fShLabPct" ); + ADDFLAG( 0x1000, "fShowPct" ); + ADDFLAG( 0x2000, "fShowBubbleSizes" ); + ADDFLAG( 0x4000, "fShowLabel" ); + PRINT(); + } + LINESTART(); + ADDTEXT( "rot = " ); + switch( __nFlags & 0x0700 ) + { + case 0x0000: p = "no rotation"; break; + case 0x0100: p = "top to bottom, upright"; break; + case 0x0200: p = "90 deg counterclockwise"; break; + case 0x0300: p = "90 deg clockwise"; break; + default: p = pU; + } + ADDTEXT( p ); + ADDTEXT( " trot = " ); + __AddDec( t, nTrot ); + PRINT(); + LINESTART(); + ADDTEXT( "text color = " ); + __AddDec( t, nIcvText ); + PRINT(); + LINESTART(); + ADDTEXT( "placement: " ); + switch( nGrbit2 & 0x000F ) + { + case 0: p = "0 default"; break; + case 1: p = "outside"; break; + case 2: p = "inside"; break; + case 3: p = "center"; break; + case 4: p = "axis"; break; + case 5: p = "above"; break; + case 6: p = "below"; break; + case 7: p = "left"; break; + case 8: p = "right"; break; + case 9: p = "auto"; break; + case 10: p = "moved"; break; + default: p = pU; + } + ADDTEXT( p ); + PRINT(); + } + break; + case 0x1026: // ChartFontx + ContDump( nL ); + break; + case 0x1027: // CHOBJECTLINK + { + static const sal_Char* const ppcObjLink[] = { 0, "title", "y-axis", "x-axis", "data", "legend", "none", "z-axis" }; + LINESTART(); + sal_uInt16 nObjLink; + rIn >> nObjLink; + ADDTEXT( "link=" ); __AddDec( t, nObjLink ); + lcl_AddEnum( t, nObjLink, ppcObjLink, STATIC_TABLE_SIZE( ppcObjLink ) ); + ADDTEXT( " series=" ); ADDDEC( 2 ); + ADDTEXT( " point=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x1032: // ChartFrame + { + LINESTART(); + switch( Read2( rIn ) ) + { + case 0: p = "no border"; break; + case 1: + case 2: + case 3: p = "reserved"; break; + case 4: p = "with shadow"; break; + default: p = pU; + } + ADDTEXT( "Frame type: " ); + ADDTEXT( p ); + PRINT(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x01, "fAutoSize" ); + ADDFLAG( 0x02, "fAutoPosition" ); + PRINT(); + } + } + break; + case 0x1035: // ChartPlotarea + ContDump( nL ); + break; + case 0x103A: // Chart3D + ContDump( nL ); + break; + case 0x103C: // ChartPicf + LINESTART(); + ADDTEXT( "bmp-mode=" ); ADDDEC( 2 ); + ADDTEXT( " format=" ); ADDDEC( 2 ); + ADDTEXT( " flags=" ); ADDHEX( 2 ); + ADDTEXT( " scale=" ); ADDDOUBLE(); + PRINT(); + break; + case 0x103D: // ChartDropbar + ContDump( nL ); + break; + case 0x103E: // ChartRadar + ContDump( nL ); + break; + case 0x103F: // ChartSurface + ContDump( nL ); + break; + case 0x1040: // ChartRadararea + ContDump( nL ); + break; + case 0x1041: // ChartAxisparent + { + LINESTART(); + switch( Read2( rIn ) ) + { + case 0: p = "main"; break; + case 1: p = "secondary"; break; + default: p = pU; + } + ADDTEXT( "Index: " ); + ADDTEXT( p ); + ADDTEXT( " " ); + ADDDEC(4); + ADDTEXT( '/' ); + ADDDEC(4); + ADDTEXT( " [" ); + ADDDEC(4); + ADDTEXT( '/' ); + ADDDEC(4); + ADDTEXT( ']' ); + PRINT(); + } + break; + case 0x1043: // ChartLegendxn + ContDump( nL ); + break; + case 0x1044: // ChartShtprops + ContDump( nL ); + break; + case 0x1045: // ChartSertocrt + ContDump( nL ); + break; + case 0x1046: // ChartAxesused + { + LINESTART(); + ADDTEXT( "Used : " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x1048: // ChartSbaseref + ContDump( nL ); + break; + case 0x104A: // CHSERPARENT + LINESTART(); + ADDTEXT( "parent-index=" ); ADDDEC( 2 ); + ADDTEXT( " (one-based)" ); + PRINT(); + break; + case 0x104B: // CHSERTRENDLINE + { + static const sal_Char* const ppcType[] = + { "poynomial", "exponential", "logarithmic", "power", "moving-avg" }; + sal_uInt8 nType; + rIn >> nType; + LINESTART(); + ADDTEXT( "line-type=" ); __AddDec( t, nType ); + lcl_AddEnum( t, nType, ppcType, STATIC_TABLE_SIZE( ppcType ) ); + ADDTEXT( " order=" ); ADDDEC( 1 ); + ADDTEXT( " intercept=" ); ADDDOUBLE(); + PRINT(); + LINESTART(); + ADDTEXT( "show-equation=" ); ADDDEC( 1 ); + ADDTEXT( " show-r-sqr=" ); ADDDEC( 1 ); + PRINT(); + LINESTART(); + ADDTEXT( "forecast-for=" ); ADDDOUBLE(); + ADDTEXT( " forecast-back=" ); ADDDOUBLE(); + PRINT(); + } + break; + case 0x104E: // ChartIfmt + ContDump( nL ); + break; + case 0x104F: // ChartPos + { + LINESTART(); + UINT16 nMdTopLt, nMdBotRt; + INT32 nX, nY, nDx, nDy; + rIn >> nMdTopLt >> nMdBotRt >> nX >> nY >> nDx >> nDy; + ADDTEXT( "TopLr = " ); + __AddDec( t, nMdTopLt ); + ADDTEXT( " BotRt = " ); + __AddDec( t, nMdBotRt ); + PRINT(); + LINESTART(); + __AddDec( t, nX ); + ADDTEXT( " / " ); + __AddDec( t, nY ); + ADDTEXT( " [" ); + __AddDec( t, nDx ); + ADDTEXT( " / " ); + __AddDec( t, nDy ); + ADDTEXT( "]" ); + PRINT(); + } + break; + case 0x1050: // ChartAlruns + ContDump( nL ); + break; + case 0x1051: // AI + { + LINESTART(); + UINT8 n8 = Read1( rIn ); + switch( n8 ) + { + case 0: p = "title or text"; break; + case 1: p = "values"; break; + case 2: p = "categories"; break; + case 3: p = "bubble sizes"; break; + default: p = pU; + } + ADDTEXT( "Link index identifier: " ); + ADDTEXT( p ); + if ( p == pU ) + __AddHex( t, n8 ); + PRINT(); + LINESTART(); + switch( Read1( rIn ) ) + { + case 0: p = "default categories"; break; + case 1: p = "text or value"; break; + case 2: p = "linked to worksheet"; break; + case 3: p = "not used (HaHaHa...)"; break; + case 4: p = "error reported"; break; + default: p = pU; + } + ADDTEXT( "Refernce type: " ); + ADDTEXT( p ); + PRINT(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x01, "fCustomIfmt" ); + PRINT(); + } + LINESTART(); + ADDTEXT( "Numberformat = " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + UINT16 n; + rIn >> n; + ADDTEXT( "Formula [" ); + __AddDec( t, n ); + ADDTEXT( "]: ---------------- " ); + PRINT(); + FormulaDump( n, FT_CellFormula ); + } + break; + case 0x105B: // CHSERERRORBAR + { + static const sal_Char* const ppcType[] = { 0, "x-plus", "x-minus", "y-plus", "y-minus" }; + static const sal_Char* const ppcSource[] = { 0, "percent", "fixed", "std-dev", "custom", "std-error" }; + static const sal_Char* const ppcLineEnd[] = { "blank", "t-shape" }; + sal_uInt8 nType, nSource, nLineEnd; + rIn >> nType >> nSource >> nLineEnd; + LINESTART(); + ADDTEXT( "bar-type=" ); __AddDec( t, nType ); + lcl_AddEnum( t, nType, ppcType, STATIC_TABLE_SIZE( ppcType ) ); + ADDTEXT( " value-source=" ); __AddDec( t, nSource ); + lcl_AddEnum( t, nSource, ppcSource, STATIC_TABLE_SIZE( ppcSource ) ); + ADDTEXT( " line-end=" ); __AddDec( t, nLineEnd ); + lcl_AddEnum( t, nLineEnd, ppcLineEnd, STATIC_TABLE_SIZE( ppcLineEnd ) ); + PRINT(); + LINESTART(); + ADDTEXT( "reserved=" ); ADDHEX( 1 ); + ADDTEXT( " value=" ); ADDDOUBLE(); + ADDTEXT( " ref-count=" ); ADDDEC( 2 ); + PRINT(); + } + break; + case 0x105D: // ChartSerfmt + ContDump( nL ); + break; + case 0x105F: // Chart3DDataForm + { + UINT8 nGround, nTop; + nGround = Read1( rIn ); + nTop = Read1( rIn ); + UINT16 nStyle = ((UINT16)nGround << 8) | nTop; + LINESTART(); + ADDTEXT( "3D - format (" ); + __AddHex( t, nGround ); + ADDTEXT( " " ); + __AddHex( t, nTop ); + ADDTEXT( "): " ); + switch( nStyle ) + { + case 0x0000: ADDTEXT( "bar" ); break; + case 0x0001: ADDTEXT( "pyramid" ); break; + case 0x0002: ADDTEXT( "pyramid, cut" ); break; + case 0x0100: ADDTEXT( "cylinder" ); break; + case 0x0101: ADDTEXT( "cone" ); break; + case 0x0102: ADDTEXT( "cone, cut" ); break; + default: ADDTEXT( pU ); + } + PRINT(); + } + break; + case 0x1060: // ChartFbi + { + LINESTART(); + ADDTEXT( "dmixBasis = " ); + ADDDEC( 2 ); + ADDTEXT( " dmiyBasis = " ); + ADDDEC( 2 ); + ADDTEXT( " twpHeightBasis = " ); + ADDDEC( 2 ); + ADDTEXT( " scab = " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "ifnt = " ); + ADDDEC( 2 ); + PRINT(); + } + break; + case 0x1061: // ChartBoppop + ContDump( nL ); + break; + case 0x1062: // ChartAxcext + { + LINESTART(); + ADDTEXT( "cat on axis: " ); + ADDDEC( 2 ); + ADDTEXT( " ... " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "major unit: val = " ); + ADDDEC( 2 ); + ADDTEXT( " units = " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "minor unit: val = " ); + ADDDEC( 2 ); + ADDTEXT( " units = " ); + ADDDEC( 2 ); + PRINT(); + LINESTART(); + ADDTEXT( "base unit = " ); + ADDDEC( 2 ); + ADDTEXT( " crossing point of val axis = " ); + ADDDEC( 2 ); + PRINT(); + rIn >> __nFlags; + if( __nFlags ) + { + LINESTART(); + STARTFLAG(); + ADDFLAG( 0x0001, "fAutoMin" ); + ADDFLAG( 0x0002, "fAutoMax" ); + ADDFLAG( 0x0004, "fAutoMajor" ); + ADDFLAG( 0x0008, "fAutoMinor" ); + ADDFLAG( 0x0010, "fDateAxis" ); + ADDFLAG( 0x0020, "fAutoBase" ); + ADDFLAG( 0x0040, "fAutoCross" ); + ADDFLAG( 0x0080, "fAutoDate" ); + PRINT(); + } + } + break; + case 0x1063: // ChartDat + ContDump( nL ); + break; + case 0x1064: // ChartPlotgrowth + { + UINT32 nDx, nDy; + rIn >> nDx >> nDy; + LINESTART(); + ADDTEXT( "dxPlotGrowth = " ); + __Add16p16( t, nDx ); + ADDTEXT( " (" ); + __AddHex( t, nDx ); + ADDTEXT( ") dyPlotGrowth = " ); + __Add16p16( t, nDy ); + ADDTEXT( " (" ); + __AddHex( t, nDy ); + ADDTEXT( ")" ); + PRINT(); + } + break; + case 0x1065: // ChartSiindex + ContDump( nL ); + break; + case 0x1066: // ChartGelframe + EscherDump( nL, false ); + break; + case 0x1067: // ChartBoppcustom + ContDump( nL ); + break; + default: + if( !bEncrypted ) + ContDump( nL ); + } + + } + + if( nR == EXC_ID_FILEPASS ) + { + bEncrypted = true; + pIn->Seek( EXC_REC_SEEK_TO_BEGIN ); + bool bValid = (XclImpDecryptHelper::ReadFilepass( *pIn ) == ERRCODE_NONE); + LINESTART(); + ADDTEXT( "decrypter=" ); lcl_AddOnOff( t, bValid ); + PRINT(); + bBIFF8 = bBIFF8 && bValid; // dump BIFF8 hex only on invalid decrypter + } + + if( bDec ) + pLevelPre -= nLevelInc; +} + + +static const sal_Char* GetBlipType( UINT8 n ) +{ + switch ( n ) + { + case 0 : + return " ERROR"; + break; + case 1 : + return " UNKNOWN"; + break; + case 2 : + return " EMF"; + break; + case 3 : + return " WMF"; + break; + case 4 : + return " PICT"; + break; + case 5 : + return " JPEG"; + break; + case 6 : + return " PNG"; + break; + case 7 : + return " DIB"; + break; + default: + if ( n < 32 ) + return " NotKnown"; + else + return " Client"; + } +} + +void Biff8RecDumper::EscherDump( const ULONG nMaxLen, bool bDumpOffset ) +{ + ULONG n = nMaxLen; + UINT16 nPre, nR; + UINT32 nL; + const sal_Char* p; + ByteString aT; + UINT16 nDumpSize; + + aT += pLevelPre; + + ULONG nStartPos = pIn->GetSvStreamPos(); + while( pIn->IsValid() && (n > 0) ) + { + ULONG nCurrPos = pIn->GetSvStreamPos(); + *pIn >> nPre >> nR >> nL; + n -= sizeof( nPre ) + sizeof( nR ) + sizeof( nL ); + + switch( nR ) + { + case 0xF000: p = "MsofbtDggContainer"; break; + case 0xF006: p = "MsofbtDgg"; break; + case 0xF016: p = "MsofbtCLSID"; break; + case 0xF00B: p = "MsofbtOPT"; break; + case 0xF11A: p = "MsofbtColorMRU"; break; + case 0xF11E: p = "MsofbtSplitMenuColors"; break; + case 0xF001: p = "MsofbtBstoreContainer"; break; + case 0xF007: p = "MsofbtBSE"; break; + case 0xF002: p = "MsofbtDgContainer"; break; + case 0xF008: p = "MsofbtDg"; break; + case 0xF118: p = "MsofbtRegroupItem"; break; + case 0xF120: p = "MsofbtColorScheme"; break; + case 0xF003: p = "MsofbtSpgrContainer"; break; + case 0xF004: p = "MsofbtSpContainer"; break; + case 0xF009: p = "MsofbtSpgr"; break; + case 0xF00A: p = "MsofbtSp"; break; + case 0xF00C: p = "MsofbtTextbox"; break; + case 0xF00D: p = "MsofbtClientTextbox"; break; + case 0xF00E: p = "MsofbtAnchor"; break; + case 0xF00F: p = "MsofbtChildAnchor"; break; + case 0xF010: p = "MsofbtClientAnchor"; break; + case 0xF011: p = "MsofbtClientData"; break; + case 0xF11F: p = "MsofbtOleObject"; break; + case 0xF11D: p = "MsofbtDeletedPspl"; break; + case 0xF005: p = "MsofbtSolverContainer"; break; + case 0xF012: p = "MsofbtConnectorRule"; break; + case 0xF013: p = "MsofbtAlignRule"; break; + case 0xF014: p = "MsofbtArcRule"; break; + case 0xF015: p = "MsofbtClientRule"; break; + case 0xF017: p = "MsofbtCalloutRule"; break; + case 0xF119: p = "MsofbtSelection"; break; + case 0xF122: p = "MsofbtUDefProp"; break; + default: + if( nR >= 0xF018 && nR <= 0xF117 ) + p = "MsofbtBLIP"; + else if ( ( nPre & 0x000F ) == 0x000F ) + p = "UNKNOWN container"; + else + p = "UNKNOWN ID"; + } + + aT += " "; + __AddHex( aT, nR ); + ((aT += " ") += p) += " ["; + __AddHex( aT, nPre ); + aT += ','; + __AddHex( aT, nL ); + aT += "] instance: "; + __AddDec( aT, (UINT16)(nPre >> 4) ); + if( bDumpOffset ) + { + aT.Append( " pos=" ); + __AddHex( aT, static_cast< sal_uInt32 >( mnEscherPos + nCurrPos - nStartPos ) ); + } + Print( aT ); + + if ( nR == 0xF007 && 36 <= n && 36 <= nL ) + { // BSE, FBSE + ULONG nP = pIn->GetRecPos(); + UINT8 n8; + UINT16 n16; + UINT32 n32; + + aT = " btWin32: "; + *pIn >> n8; + __AddHex( aT, n8 ); + aT += GetBlipType( n8 ); + aT += " btMacOS: "; + *pIn >> n8; + __AddHex( aT, n8 ); + aT += GetBlipType( n8 ); + Print( aT ); + + aT = " rgbUid:"; + Print( aT ); + ContDump( 16 ); + + aT = " tag: "; + *pIn >> n16; + __AddHex( aT, n16 ); + Print( aT ); + + aT = " size: "; + *pIn >> n32; + __AddHex( aT, n32 ); + Print( aT ); + + aT = " cRef: "; + *pIn >> n32; + __AddHex( aT, n32 ); + Print( aT ); + + aT = " offs: "; + *pIn >> n32; + __AddHex( aT, n32 ); + Print( aT ); + + aT = " usage: "; + *pIn >> n8; + __AddHex( aT, n8 ); + aT += " cbName: "; + *pIn >> n8; + __AddHex( aT, n8 ); + aT += " unused2: "; + *pIn >> n8; + __AddHex( aT, n8 ); + aT += " unused3: "; + *pIn >> n8; + __AddHex( aT, n8 ); + Print( aT ); + + n -= pIn->GetRecPos() - nP; + nL = 0; // loop to MsofbtBLIP + } + else if ( nR == 0xF00F && 0x10 <= n && 0x10 <= nL ) + { // ChildAnchor + ULONG nP = pIn->GetRecPos(); + sal_Int32 n32; + + aT.Assign( " pos1=" ); + *pIn >> n32; lclAppendDec( aT, n32 ); + aT.Append( " pos2=" ); + *pIn >> n32; lclAppendDec( aT, n32 ); + aT.Append( " pos3=" ); + *pIn >> n32; lclAppendDec( aT, n32 ); + aT.Append( " pos4=" ); + *pIn >> n32; lclAppendDec( aT, n32 ); + Print( aT ); + + ULONG nC = pIn->GetRecPos() - nP; + n -= nC; + nL -= nC; + } + else if ( nR == 0xF010 && 0x12 <= n && 0x12 <= nL ) + { // ClientAnchor + ULONG nP = pIn->GetRecPos(); + UINT16 n16; + + aT = " Flag: "; + *pIn >> n16; + __AddHex( aT, n16 ); + if( n16 & 0x0001 ) aT += " -fixedpos"; + if( n16 & 0x0002 ) aT += " -fixedsize"; + Print( aT ); + + aT = " Col1: "; + *pIn >> n16; + __AddHex( aT, n16 ); + aT += " dX1: "; + *pIn >> n16; + __AddHex( aT, n16 ); + aT += " Row1: "; + *pIn >> n16; + __AddHex( aT, n16 ); + aT += " dY1: "; + *pIn >> n16; + __AddHex( aT, n16 ); + Print( aT ); + + aT = " Col2: "; + *pIn >> n16; + __AddHex( aT, n16 ); + aT += " dX2: "; + *pIn >> n16; + __AddHex( aT, n16 ); + aT += " Row2: "; + *pIn >> n16; + __AddHex( aT, n16 ); + aT += " dY2: "; + *pIn >> n16; + __AddHex( aT, n16 ); + Print( aT ); + + ULONG nC = pIn->GetRecPos() - nP; + n -= nC; + nL -= nC; + } + else if ( nR == 0xF00A ) + { + sal_uInt32 nId, nFlags; + *pIn >> nId >> nFlags; + aT.Assign( " shape-id=" ); + __AddHex( aT, nId ); + aT.Append( " flags=" ); + __AddHex( aT, nFlags ); + Print( aT ); + nL -= 8; n -= 8; + } + else if ( nR == 0xF00B || nR == 0xF122 ) + { // OPT + sal_uInt32 nComplex = 0; + while ( nL >= 6 + nComplex && n >= 6 + nComplex ) + { + UINT16 n16; + UINT32 n32; + *pIn >> n16 >> n32; + nL -= 6; n -= 6; + aT = " "; + __AddHex( aT, n16 ); + aT += " ("; + __AddDec( aT, n16 & 0x3FFF, 5 ); + if ( (n16 & 0x8000) == 0 ) + { + if ( n16 & 0x4000 ) + aT += ", fBlipID"; + aT += ") "; + __AddHex( aT, n32 ); + if ( (n16 & 0x4000) == 0 ) + { + aT += " ("; + __AddDec1616( aT, n32 ); + aT += ')'; + } + Print( aT ); + } + else + { + aT += ", fComplex) "; + __AddHex( aT, n32 ); + Print( aT ); + nComplex += n32; + } + } + // complex property data + while ( nComplex && n > 0 ) + { + sal_uInt32 nDumpSize = (nComplex > n) ? n : nComplex; + ContDump( nDumpSize ); + nComplex -= nDumpSize; + nL -= nDumpSize; + n -= nDumpSize; + } + } + else if ( nR == 0xF012 ) + { + aT = " Connector rule: "; __AddDec( aT, pIn->ReaduInt32() ); + aT += " ShapeID A: "; __AddHex( aT, pIn->ReaduInt32() ); + aT += " ShapeID B: "; __AddHex( aT, pIn->ReaduInt32() ); + Print( aT ); + aT = " ShapeID connector: "; __AddHex( aT, pIn->ReaduInt32() ); + aT += " Connect pt A: "; __AddHex( aT, pIn->ReaduInt32() ); + aT += " Connect pt B: "; __AddHex( aT, pIn->ReaduInt32() ); + Print( aT ); + nL -= 24; n -= 24; + } + + if( ( nPre & 0x000F ) == 0x000F ) + { // Container + if ( nL <= (UINT32) n ) + Print( " completed within" ); + else + Print( " continued elsewhere" ); + } + else + // -> 0x0000 ... 0x0FFF + { + nDumpSize = ( ( UINT32 ) nL > ( UINT32 ) n )? ( UINT16 ) n : ( UINT16 ) nL; + + if( nDumpSize ) + { + ContDump( nDumpSize ); + n -= nDumpSize; + } + } + + aT.Erase(); + } + if( bDumpOffset ) + mnEscherPos += nMaxLen; +} + + +void Biff8RecDumper::ObjDump( const ULONG nMaxLen ) +{ +#if 0 +// if an entire hex block is needed + pIn->PushPosition(); + ContDump( nMaxLen ); + pIn->PopPosition(); +#endif + + ULONG n = nMaxLen; + UINT16 nR, nL; + const sal_Char* p; + ByteString t; + XclImpStream& rIn = *pIn; + UINT16 nDumpSize; + sal_uInt16 nObjFlags = 0; + + t += pLevelPre; + + while( n > 0 ) + { + rIn >> nR >> nL; + n -= sizeof( nR ) + sizeof( nL ); + + BOOL bDetails = FALSE; + switch( nR ) + { + case 0x0000: p = "ftEnd"; break; + case 0x0001: p = "(Reserved)"; break; + case 0x0002: p = "(Reserved)"; break; + case 0x0003: p = "(Reserved)"; break; + case 0x0004: p = "ftMacro"; break; + case 0x0005: p = "ftButton"; break; + case 0x0006: p = "ftGmo"; break; + case 0x0007: p = "ftCf"; break; + case 0x0008: p = "ftPioGrbit"; bDetails = TRUE; break; + case 0x0009: p = "ftPictFmla"; bDetails = TRUE; break; + case 0x000A: p = "ftCbls"; break; + case 0x000B: p = "ftRbo"; break; + case 0x000C: p = "ftSbs"; break; + case 0x000D: p = "ftNts"; break; + case 0x000E: p = "ftSbsFmla"; break; + case 0x000F: p = "ftGboData"; break; + case 0x0010: p = "ftEdoData"; break; + case 0x0011: p = "ftRboData"; break; + case 0x0012: p = "ftCblsData"; break; + case 0x0013: p = "ftLbsData"; break; + case 0x0014: p = "ftCblsFmla"; break; + case 0x0015: p = "ftCmo"; bDetails = TRUE; break; + default: + p = "UNKNOWN ID"; + } + + t += " "; + __AddHex( t, nR ); + t += " ["; + __AddHex( t, nL ); + (t += "] ") += p; + Print( t ); + + nDumpSize = ( ( UINT32 ) nL > ( UINT32 ) n )? ( UINT16 ) n : ( UINT16 ) nL; + + if( nDumpSize ) + { + ULONG nPos1 = (bDetails ? rIn.GetRecPos() : 0); + ContDump( nDumpSize ); + n -= nDumpSize; + if ( bDetails ) + { + ULONG nPos2 = rIn.GetRecPos(); + rIn.Seek( nPos1 ); + t.Erase(); + switch ( nR ) + { + case 0x0008 : // ftPioGrbit + { + rIn >> nObjFlags; + UINT16 __nFlags = nObjFlags; + if ( __nFlags ) + { + ADDTEXT( " " ); + STARTFLAG(); + ADDFLAG( 0x0001, "man-size" ); + ADDFLAG( 0x0002, "linked" ); + ADDFLAG( 0x0008, "symbol" ); + ADDFLAG( 0x0010, "control" ); + ADDFLAG( 0x0020, "ctls-stream" ); + ADDFLAG( 0x0200, "autoload" ); + ADDRESERVED( 0xFDC4 ); + } + } + break; + case 0x0009 : // ftPictFmla + { + ADDTEXT( " Document type " ); + UINT16 nFmlaLen; + rIn >> nFmlaLen; + if( nObjFlags & 0x0002 ) + { + ADDTEXT( "linked\n OLE stream: LNK??? (from EXTERNNAME) " ); + rIn >> nFmlaLen; + ADDTEXT( " unknown=" ); ADDHEX( 4 ); + PRINT(); + t.Erase(); + FormulaDump( nFmlaLen, FT_CellFormula ); + } + else + { + ADDTEXT( "embedded " ); + const UINT16 nStringOffset = 14; // MAY be right + rIn.Seek( nPos1 + nStringOffset ); + INT32 nBytesLeft = nL - nStringOffset; + UINT16 nStrLen = rIn.ReaduInt16(); + ULONG nPos3 = rIn.GetRecPos(); + if( nStrLen ) + AddUNICODEString( t, rIn, TRUE, nStrLen ); + nBytesLeft -= (rIn.GetRecPos() - nPos3); + ADDTEXT( '\n' ); + if ( nBytesLeft < 4 ) + ADDTEXT( " >> ByteString OVERRUN <<\n" ); + + rIn.Seek( nPos1 + sizeof(nFmlaLen) + nFmlaLen ); + if( nObjFlags & 0x0020 ) + { + sal_uInt32 nStrmStart, nStrmLen; + rIn >> nStrmStart >> nStrmLen; + ADDTEXT( " 'Ctls' stream start=" ); + __AddHex( t, nStrmStart ); + ADDTEXT( " size=" ); + __AddHex( t, nStrmLen ); + maCtlsPosMap[ nStrmStart ] = nStrmLen; + } + else + { + ADDTEXT( " OLE storage name: MBD" ); + __AddPureHex( t, rIn.ReaduInt32() ); + } + } + } + break; + case 0x0015 : // ftCmo + { + UINT16 nType, nId; + rIn >> nType >> nId; + ADDTEXT( " Object ID " ); + __AddHex( t, nId ); + switch ( nType ) + { + case 0x0000 : p = "Group"; break; + case 0x0001 : p = "Line"; break; + case 0x0002 : p = "Rectangle"; break; + case 0x0003 : p = "Oval"; break; + case 0x0004 : p = "Arc"; break; + case 0x0005 : p = "Chart"; break; + case 0x0006 : p = "Text"; break; + case 0x0007 : p = "Button"; break; + case 0x0008 : p = "Picture"; break; + case 0x0009 : p = "Polygon"; break; + case 0x000a : p = "(Reserved)"; break; + case 0x000b : p = "Check box"; break; + case 0x000c : p = "Option button";break; + case 0x000d : p = "Edit box"; break; + case 0x000e : p = "Label"; break; + case 0x000f : p = "Dialog box"; break; + case 0x0010 : p = "Spinner"; break; + case 0x0011 : p = "Scroll bar"; break; + case 0x0012 : p = "List box"; break; + case 0x0013 : p = "Group box"; break; + case 0x0014 : p = "Combo box"; break; + case 0x0015 : p = "(Reserved)"; break; + case 0x0016 : p = "(Reserved)"; break; + case 0x0017 : p = "(Reserved)"; break; + case 0x0018 : p = "(Reserved)"; break; + case 0x0019 : p = "Comment"; break; + case 0x001a : p = "(Reserved)"; break; + case 0x001b : p = "(Reserved)"; break; + case 0x001c : p = "(Reserved)"; break; + case 0x001d : p = "(Reserved)"; break; + case 0x001e : p = "Microsoft Office drawing"; break; + default: + p = "UNKNOWN"; + } + ADDTEXT( ", type " ); + __AddHex( t, nType ); + ADDTEXT( ' ' ); + ADDTEXT( p ); + } + break; + } + if ( t.Len() ) + PRINT(); + rIn.Seek( nPos2 ); + } + } + + t.Erase(); + } +} + + +#undef LINESTART +#undef IGNORE +#undef ADDHEX +#undef ADDDEC +#undef PRINT +#undef PreDump +#undef ADDCELLHEAD + +void Biff8RecDumper::ContDump( const ULONG nL ) +{ + UINT32 nC = nMaxBodyLines; + UINT32 n = nL; + UINT32 nInL, nTmp; + UINT8* pB = new UINT8[ nL ]; + UINT8* p; + const UINT16 nLineLen = 16; + UINT16 nCharCnt; + BOOL bPart; + ByteString aT; + + aT += pLevelPre; + + while( n && nC ) + { + bPart = n < nLineLen; + nInL = bPart? n : nLineLen; + n -= nInL; + + pIn->Read( pB, nInL ); + + // als Hex-Codes + nTmp = nInL; + p = pB; + nCharCnt = 0; + while( nTmp ) + { + if( nCharCnt == nLineLen / 2 ) + aT += ' '; + + nCharCnt++; + + aT += ' '; + __AddPureHex( aT, *p ); + p++; + + nTmp--; + } + + if( bPart ) + aT += GetBlanks( ( UINT16 ) ( ( nLineLen - nInL ) * 3 ) ); + + // als chars + + aT += " "; + if( nInL < 9 ) + aT += ' '; + + nTmp = nInL; + p = pB; + nCharCnt = 0; + while( nTmp ) + { + if( nCharCnt == nLineLen / 2 ) + aT += ' '; + + nCharCnt++; + + if( IsPrintable( *p ) ) + aT += static_cast< sal_Char >( *p ); + else + aT += '.'; + + p++; + + nTmp--; + } + + Print( aT ); + aT.Erase(); + aT += pLevelPre; + + nC--; + } + + delete[] pB; +} + + +// Formula dumper ============================================================= + +/** Name and parameter count of an Excel function. */ +struct XclDumpFunc +{ + const sal_Char* pName; /// Name of the function. + sal_uInt16 nParam; /// Parameter count for fixed functions. +}; + +static const XclDumpFunc pFuncData[] = +{ +/* 0*/ { "COUNT", 0 }, + { "IF", 0 }, + { "ISNA", 1 }, + { "ISERROR", 1 }, + { "SUM", 0 }, +/* 5*/ { "AVERAGE", 0 }, + { "MIN", 0 }, + { "MAX", 0 }, + { "ROW", 0 }, + { "COLUMN", 0 }, +/* 10*/ { "NA", 0 }, + { "NPV", 0 }, + { "STDEV", 0 }, + { "DOLLAR", 0 }, + { "FIXED", 0 }, +/* 15*/ { "SIN", 1 }, + { "COS", 1 }, + { "TAN", 1 }, + { "ATAN", 1 }, + { "PI", 0 }, +/* 20*/ { "SQRT", 1 }, + { "EXP", 1 }, + { "LN", 1 }, + { "LOG10", 1 }, + { "ABS", 1 }, +/* 25*/ { "INT", 1 }, + { "SIGN", 1 }, + { "ROUND", 2 }, + { "LOOKUP", 0 }, + { "INDEX", 0 }, +/* 30*/ { "REPT", 2 }, + { "MID", 3 }, + { "LEN", 1 }, + { "VALUE", 1 }, + { "TRUE", 0 }, +/* 35*/ { "FALSE", 0 }, + { "AND", 0 }, + { "OR", 0 }, + { "NOT", 1 }, + { "MOD", 2 }, +/* 40*/ { "DCOUNT", 3 }, + { "DSUM", 3 }, + { "DAVERAGE", 3 }, + { "DMIN", 3 }, + { "DMAX", 3 }, +/* 45*/ { "DSTDEV", 3 }, + { "VAR", 0 }, + { "DVAR", 3 }, + { "TEXT", 2 }, + { "LINEST", 0 }, +/* 50*/ { "TREND", 0 }, + { "LOGEST", 0 }, + { "GROWTH", 0 }, + { "GOTO" }, // macro/internal + { "HALT" }, // macro/internal +/* 55*/ { "RETURN" }, // macro/internal + { "PV", 0 }, + { "FV", 0 }, + { "NPER", 0 }, + { "PMT", 0 }, +/* 60*/ { "RATE", 0 }, + { "MIRR", 3 }, + { "IRR", 0 }, + { "RAND", 0 }, + { "MATCH", 0 }, +/* 65*/ { "DATE", 3 }, + { "TIME", 3 }, + { "DAY", 1 }, + { "MONTH", 1 }, + { "YEAR", 1 }, +/* 70*/ { "WEEKDAY", 0 }, + { "HOUR", 1 }, + { "MINUTE", 1 }, + { "SECOND", 1 }, + { "NOW", 0 }, +/* 75*/ { "AREAS", 1 }, + { "ROWS", 1 }, + { "COLUMNS", 1 }, + { "OFFSET", 0 }, + { "ABSREF" }, // macro/internal +/* 80*/ { "RELREF" }, // macro/internal + { "ARGUMENT" }, // macro/internal + { "SEARCH", 0 }, + { "TRANSPOSE", 1 }, + { "ERROR" }, // macro/internal +/* 85*/ { "STEP" }, // macro/internal + { "TYPE", 1 }, + { "ECHO" }, // macro/internal + { "SET.NAME" }, // macro/internal + { "CALLER" }, // macro/internal +/* 90*/ { "DEREF" }, // macro/internal + { "WINDOWS" }, // macro/internal + { "SERIES" }, // macro/internal + { "DOCUMENTS" }, // macro/internal + { "ACTIVE.CELL" }, // macro/internal +/* 95*/ { "SELECTION" }, // macro/internal + { "RESULT" }, // macro/internal + { "ATAN2", 2 }, + { "ASIN", 1 }, + { "ACOS", 1 }, +/*100*/ { "CHOOSE", 0 }, + { "HLOOKUP", 0 }, + { "VLOOKUP", 0 }, + { "LINKS" }, // macro/internal + { "INPUT" }, // macro/internal +/*105*/ { "ISREF", 1 }, + { "GET.FORMULA" }, // macro/internal + { "GET.NAME" }, // macro/internal + { "SET.VALUE", 2 }, // macro/internal + { "LOG", 0 }, +/*110*/ { "EXEC" }, // macro/internal + { "CHAR", 1 }, + { "LOWER", 1 }, + { "UPPER", 1 }, + { "PROPER", 1 }, +/*115*/ { "LEFT", 0 }, + { "RIGHT", 0 }, + { "EXACT", 2 }, + { "TRIM", 1 }, + { "REPLACE", 4 }, +/*120*/ { "SUBSTITUTE", 0 }, + { "CODE", 1 }, + { "NAMES" }, // macro/internal + { "DIRECTORY" }, // macro/internal + { "FIND", 0 }, +/*125*/ { "CELL", 0 }, + { "ISERR", 1 }, + { "ISTEXT", 1 }, + { "ISNUMBER", 1 }, + { "ISBLANK", 1 }, +/*130*/ { "T", 1 }, + { "N", 1 }, + { "FOPEN" }, // macro/internal + { "FCLOSE" }, // macro/internal + { "FSIZE" }, // macro/internal +/*135*/ { "FREADLN" }, // macro/internal + { "FREAD" }, // macro/internal + { "FWRITELN" }, // macro/internal + { "FWRITE" }, // macro/internal + { "FPOS" }, // macro/internal +/*140*/ { "DATEVALUE", 1 }, + { "TIMEVALUE", 1 }, + { "SLN", 3 }, + { "SYD", 4 }, + { "DDB", 0 }, +/*145*/ { "GET.DEF" }, // macro/internal + { "REFTEXT" }, // macro/internal + { "TEXTREF" }, // macro/internal + { "INDIRECT", 0 }, + { "REGISTER" }, // macro/internal +/*150*/ { "CALL" }, + { "ADD.BAR" }, // macro/internal + { "ADD.MENU" }, // macro/internal + { "ADD.COMMAND" }, // macro/internal + { "ENABLE.COMMAND" }, // macro/internal +/*155*/ { "CHECK.COMMAND" }, // macro/internal + { "RENAME.COMMAND" }, // macro/internal + { "SHOW.BAR" }, // macro/internal + { "DELETE.MENU" }, // macro/internal + { "DELETE.COMMAND" }, // macro/internal +/*160*/ { "GET.CHART.ITEM" }, // macro/internal + { "DIALOG.BOX" }, // macro/internal + { "CLEAN", 1 }, + { "MDETERM", 1 }, + { "MINVERSE", 1 }, +/*165*/ { "MMULT", 2 }, + { "FILES" }, // macro/internal + { "IPMT", 0 }, + { "PPMT", 0 }, + { "COUNTA", 0 }, +/*170*/ { "CANCEL.KEY" }, // macro/internal + { "FOR" }, // macro/internal + { "WHILE" }, // macro/internal + { "BREAK" }, // macro/internal + { "NEXT" }, // macro/internal +/*175*/ { "INITIATE" }, // macro/internal + { "REQUEST" }, // macro/internal + { "POKE" }, // macro/internal + { "EXECUTE" }, // macro/internal + { "TERMINATE" }, // macro/internal +/*180*/ { "RESTART" }, // macro/internal + { "HELP" }, // macro/internal + { "GET.BAR" }, // macro/internal + { "PRODUCT", 0 }, + { "FACT", 1 }, +/*185*/ { "GET.CELL" }, // macro/internal + { "GET.WORKSPACE" }, // macro/internal + { "GET.WINDOW" }, // macro/internal + { "GET.DOCUMENT" }, // macro/internal + { "DPRODUCT", 3 }, +/*190*/ { "ISNONTEXT", 1 }, + { "GET.NOTE" }, // macro/internal + { "NOTE" }, // macro/internal + { "STDEVP", 0 }, + { "VARP", 0 }, +/*195*/ { "DSTDDEVP", 3 }, + { "DVARP", 3 }, + { "TRUNC", 0 }, + { "ISLOGICAL", 1 }, + { "DBCOUNTA", 3 }, +/*200*/ { "DELETE.BAR" }, // macro/internal + { "UNREGISTER" }, // macro/internal + { "202" }, // not used + { "203" }, // not used + { "USDOLLAR" }, +/*205*/ { "FINDB" }, + { "SEARCHB" }, + { "REPLACEB", 4 }, + { "LEFTB" }, + { "RIGHTB" }, +/*210*/ { "MIDB", 3 }, + { "LENB", 1 }, + { "ROUNDUP", 2 }, + { "ROUNDDOWN", 2 }, + { "ASC", 1 }, +/*215*/ { "DBSC", 1 }, + { "RANK", 0 }, + { "217" }, // not used + { "218" }, // not used + { "ADDRESS", 0 }, +/*220*/ { "DAYS360", 0 }, + { "TODAY", 0 }, + { "VDB", 0 }, + { "ELSE" }, // macro/internal + { "ELSE.IF" }, // macro/internal +/*225*/ { "END.IF" }, // macro/internal + { "FOR.CELL" }, // macro/internal + { "MEDIAN", 0 }, + { "SUMPRODUCT", 0 }, + { "SINH", 1 }, +/*230*/ { "COSH", 1 }, + { "TANH", 1 }, + { "ASINH", 1 }, + { "ACOSH", 1 }, + { "ATANH", 1 }, +/*235*/ { "DGET", 3 }, + { "CREATE.OBJECT" }, // macro/internal + { "VOLATILE" }, // macro/internal + { "LAST.ERROR" }, // macro/internal + { "CUSTOM.UNDO" }, // macro/internal +/*240*/ { "CUSTOM.REPEAT" }, // macro/internal + { "FORMULA.CONVERT" }, // macro/internal + { "GET.LINK.INFO" }, // macro/internal + { "TEXT.BOX" }, // macro/internal + { "INFO", 1 }, +/*245*/ { "GROUP" }, // macro/internal + { "GET.OBJECT" }, // macro/internal + { "DB", 0 }, + { "PAUSE" }, // macro/internal + { "249" }, // not used +/*250*/ { "250" }, // not used + { "RESUME" }, // macro/internal + { "FREQUENCY", 2 }, + { "ADD.TOOLBAR" }, // macro/internal + { "DELETE.TOOLBAR" }, // macro/internal +/*255*/ { "EXTERN.CALL" }, // macro/internal + { "RESET.TOOLBAR" }, // macro/internal + { "EVALUATE" }, // macro/internal + { "GET.TOOLBAR" }, // macro/internal + { "GET.TOOL" }, // macro/internal +/*260*/ { "SPELLING.CHECK" }, // macro/internal + { "ERROR.TYPE", 1 }, + { "APP.TITLE" }, // macro/internal + { "WINDOW.TITLE" }, // macro/internal + { "SAVE.TOOLBAR" }, // macro/internal +/*265*/ { "ENABLE.TOOL" }, // macro/internal + { "PRESS.TOOL" }, // macro/internal + { "REGISTER.ID" }, // macro/internal + { "GET.WORKBOOK" }, // macro/internal + { "AVEDEV", 0 }, +/*270*/ { "BETADIST", 0 }, + { "GAMMALN", 1 }, + { "BETAINV", 0 }, + { "BINOMDIST", 4 }, + { "CHIDIST", 2 }, +/*275*/ { "CHIINV", 2 }, + { "COMBIN", 2 }, + { "CONFIDENCE", 3 }, + { "CRITBINOM", 3 }, + { "EVEN", 1 }, +/*280*/ { "EXPONDIST", 3 }, + { "FDIST", 3 }, + { "FINV", 3 }, + { "FISHER", 1 }, + { "FISHERINV", 1 }, +/*285*/ { "FLOOR", 2 }, + { "GAMMADIST", 4 }, + { "GAMMAINV", 3 }, + { "CEILING", 2 }, + { "HYPGEOMDIST", 4 }, +/*290*/ { "LOGNORMDIST", 3 }, + { "LOGINV", 3 }, + { "NEGBINOMDIST", 3 }, + { "NORMDIST", 4 }, + { "NORMSDIST", 1 }, +/*295*/ { "NORMINV", 3 }, + { "NORMSINV", 1 }, + { "STANDARDIZE", 3 }, + { "ODD", 1 }, + { "PERMUT", 2 }, +/*300*/ { "POISSON", 3 }, + { "TDIST", 3 }, + { "WEIBULL", 4 }, + { "SUMXMY2", 2 }, + { "SUMX2MY2", 2 }, +/*305*/ { "SUMX2PY2", 2 }, + { "CHITEST", 2 }, + { "CORREL", 2 }, + { "COVAR", 2 }, + { "FORECAST", 3 }, +/*310*/ { "FTEST", 2 }, + { "INTERCEPT", 2 }, + { "PEARSON", 2 }, + { "RSQ", 2 }, + { "STEYX", 2 }, +/*315*/ { "SLOPE", 2 }, + { "TTEST", 4 }, + { "PROB", 0 }, + { "DEVSQ", 0 }, + { "GEOMEAN", 0 }, +/*320*/ { "HARMEAN", 0 }, + { "SUMSQ", 0 }, + { "KURT", 0 }, + { "SKEW", 0 }, + { "ZTEST", 0 }, +/*325*/ { "LARGE", 2 }, + { "SMALL", 2 }, + { "QUARTILE", 2 }, + { "PERCENTILE", 2 }, + { "PERCENTRANK", 0 }, +/*330*/ { "MODE", 0 }, + { "TRIMMEAN", 2 }, + { "TINV", 2 }, + { "333" }, // not used + { "MOVIE.COMMAND" }, // macro/internal +/*335*/ { "GET.MOVIE" }, // macro/internal + { "CONCATENATE", 0 }, + { "POWER", 2 }, + { "PIVOT.ADD.DATA" }, // macro/internal + { "GET.PIVOT.TABLE" }, // macro/internal +/*340*/ { "GET.PIVOT.FIELD" }, // macro/internal + { "GET.PIVOT.ITEM" }, // macro/internal + { "RADIANS", 1 }, + { "DEGREES", 1 }, + { "SUBTOTAL", 0 }, +/*345*/ { "SUMIF", 0 }, + { "COUNTIF", 2 }, + { "COUNTBLANK", 1 }, + { "SCENARIO.GET" }, // macro/internal + { "OPTIONS.LISTS.GET" }, // macro/internal +/*350*/ { "ISPMT", 4 }, + { "DATEDIF", 3 }, + { "DATESTRING", 1 }, + { "NUMBERSTRING", 2 }, + { "ROMAN", 0 }, +/*355*/ { "OPEN.DIALOG" }, // macro/internal + { "SAVE.DIALOG" }, // macro/internal + { "VIEW.GET" }, // macro/internal + { "GETPIVOTDATA", 0 }, + { "HYPERLINK", 2 }, +/*360*/ { "PHONETIC", 1 }, + { "AVERAGEA", 0 }, + { "MAXA", 0 }, + { "MINA", 0 }, + { "STDEVPA", 0 }, +/*365*/ { "VARPA", 0 }, + { "STDEVA", 0 }, + { "VARA", 0 }, + { "BAHTTEXT", 1 }, + { "THAIDAYOFWEEK", 1 }, +/*370*/ { "THAIDIGIT", 1 }, + { "THAIMONTHOFYEAR", 1 }, + { "THAINUMSOUND", 1 }, + { "THAINUMSTRING", 1 }, + { "THAISTRINGLENGTH", 1 }, +/*375*/ { "ISTHAIDIGIT", 1 }, + { "ROUNDBAHTDOWN", 1 }, + { "ROUNDBAHTUP", 1 }, + { "THAIYEAR", 1 }, + { "RTD" }, +/*380*/ { "ISHYPERLINK", 1 } +}; + +const XclDumpFunc* lcl_GetFuncData( sal_uInt16 nIndex ) +{ + return (nIndex < STATIC_TABLE_SIZE( pFuncData )) ? (pFuncData + nIndex) : NULL; +} + +// ---------------------------------------------------------------------------- + +/** Stack helper to create a human readable formula string from UPN. */ +class XclDumpFormulaStackImpl : private ScfDelStack< ByteString > +{ +public: + void PushOperand( const ByteString& rOperand ); + void PushUnary( const ByteString& rOperator, bool bInFront ); + void PushBinary( const ByteString& rOperator ); + void PushFunction( const ByteString& rFuncName, sal_uInt16 nParamCount ); + inline ByteString GetString() const { return Top() ? *Top() : ByteString(); } +}; + +void XclDumpFormulaStackImpl::PushOperand( const ByteString& rOperand ) +{ + Push( new ByteString( rOperand ) ); +} + +void XclDumpFormulaStackImpl::PushUnary( const ByteString& rOperator, bool bInFront ) +{ + if( !Count() ) return; + ByteString* pOp = Top(); + pOp->Insert( rOperator, bInFront ? 0 : pOp->Len() ); +} + +void XclDumpFormulaStackImpl::PushBinary( const ByteString& rOperator ) +{ + if( Count() < 2 ) return; + // second operand is on top + ByteString* pSecond = Pop(); + ByteString* pFirst = Top(); + *pFirst += rOperator; + *pFirst += *pSecond; + delete pSecond; +} + +void XclDumpFormulaStackImpl::PushFunction( const ByteString& rFuncName, sal_uInt16 nParamCount ) +{ + if( Count() < nParamCount ) return; + ByteString* pNew = new ByteString( ')' ); + for( sal_uInt16 nIndex = 0; nIndex < nParamCount; ++nIndex ) + { + if( nIndex ) pNew->Insert( ';', 0 ); + ByteString* pOp = Pop(); + pNew->Insert( *pOp, 0 ); + delete pOp; + } + pNew->Insert( '(', 0 ); + pNew->Insert( rFuncName, 0 ); + Push( pNew ); +} + +// ---------------------------------------------------------------------------- + +/** Stack to create a human readable formula and token class overview from UPN. */ +class XclDumpFormulaStack +{ +public: + void PushOperand( const ByteString& rOperand, sal_uInt8 nToken ); + inline void PushOperand( const sal_Char* pcOperand, sal_uInt8 nToken ) + { PushOperand( ByteString( pcOperand ), nToken ); } + + void PushUnary( const ByteString& rOperator, bool bInFront = true ); + inline void PushUnary( const sal_Char* pcOperator, bool bInFront = true ) + { PushUnary( ByteString( pcOperator ), bInFront ); } + + void PushBinary( const ByteString& rOperator ); + inline void PushBinary( const sal_Char* pcOperator ) + { PushBinary( ByteString( pcOperator ) ); } + + void PushFunction( const ByteString& rFuncName, sal_uInt16 nParamCount, sal_uInt8 nToken ); + inline void PushFunction( const sal_Char* pcFuncName, sal_uInt16 nParamCount, sal_uInt8 nToken ) + { PushFunction( ByteString( pcFuncName ), nParamCount, nToken ); } + + inline ByteString GetFormula() const { return maFmla.GetString(); } + inline ByteString GetTokenClasses() const { return maClass.GetString(); } + + static ByteString GetTokenClass( sal_uInt8 nToken ); + +private: + void PushTokenClass( sal_uInt8 nToken ); + + XclDumpFormulaStackImpl maFmla; + XclDumpFormulaStackImpl maClass; +}; + +void XclDumpFormulaStack::PushOperand( const ByteString& rOperand, sal_uInt8 nToken ) +{ + maFmla.PushOperand( rOperand ); + maClass.PushOperand( GetTokenClass( nToken ) ); +} + +void XclDumpFormulaStack::PushUnary( const ByteString& rOperator, bool bInFront ) +{ + maFmla.PushUnary( rOperator, bInFront ); + maClass.PushUnary( rOperator, bInFront ); +} + +void XclDumpFormulaStack::PushBinary( const ByteString& rOperator ) +{ + maFmla.PushBinary( rOperator ); + maClass.PushBinary( rOperator ); +} + +void XclDumpFormulaStack::PushFunction( const ByteString& rFuncName, sal_uInt16 nParamCount, sal_uInt8 nToken ) +{ + maFmla.PushFunction( rFuncName, nParamCount ); + maClass.PushFunction( GetTokenClass( nToken ), nParamCount ); +} + +ByteString XclDumpFormulaStack::GetTokenClass( sal_uInt8 nToken ) +{ + sal_Char cClass = 'B'; + switch( nToken & 0xE0 ) + { + case 0x20: cClass = 'R'; break; + case 0x40: cClass = 'V'; break; + case 0x60: cClass = 'A'; break; + } + return ByteString( cClass ); +} + +// ---------------------------------------------------------------------------- + +const sal_Char* lcl_GetErrorString( sal_uInt8 nErr ) +{ + switch( nErr ) + { + case 0x00: return "#NULL!"; + case 0x07: return "#DIV/0!"; + case 0x0F: return "#VALUE!"; + case 0x17: return "#REF!"; + case 0x1D: return "#NAME?"; + case 0x24: return "#NUM!"; + case 0x2A: return "#N/A!"; + } + return "!unknown!"; +} + + + +void lcl_StartToken( ByteString& rString, sal_uInt16 nPos, sal_uInt8 nToken, const sal_Char* pTokenName ) +{ + rString.Erase(); + rString.Append( " " ); + __AddHex( rString, nPos ); + rString.Append( " " ); + __AddHex( rString, nToken ); + rString.Append( " t" ).Append( pTokenName ).Expand( 33, ' ' ); +} + +void lcl_StartTokenClass( ByteString& rString, sal_uInt16 nPos, sal_uInt8 nToken, const sal_Char* pTokenName ) +{ + ByteString aToken( pTokenName ); + aToken.Append( XclDumpFormulaStack::GetTokenClass( nToken ) ); + lcl_StartToken( rString, nPos, nToken, aToken.GetBuffer() ); +} + +void Biff8RecDumper::FormulaDump( const UINT16 nL, const FORMULA_TYPE eFT ) +{ + if( !nL ) + return; + + sal_uInt32 nStartPos = pIn->GetRecPos(); + const sal_uInt32 nAfterPos = nStartPos + nL; + + BYTE nOp; + ByteString t, aOperand; + BOOL bError = FALSE; + const BOOL bRangeName = eFT == FT_RangeName; + const BOOL bSharedFormula = eFT == FT_SharedFormula; + const BOOL bRNorSF = bRangeName || bSharedFormula; + + XclDumpFormulaStack aStack; + sal_Bool bPrinted = sal_True; + +#define PRINTTOKEN() { if( !bPrinted ) Print( t ); bPrinted = sal_True; } +#define STARTTOKEN( name ) lcl_StartToken( t, static_cast< sal_uInt16 >( pIn->GetRecPos() - nStartPos - 1 ), nOp, name ) +#define STARTTOKENCLASS( name ) lcl_StartTokenClass( t, static_cast< sal_uInt16 >( pIn->GetRecPos() - nStartPos - 1 ), nOp, name ) + + while( pIn->IsValid() && ( pIn->GetRecPos() < nAfterPos ) && !bError ) + { + *pIn >> nOp; + bPrinted = sal_False; + aOperand.Erase(); + + switch( nOp ) // Buch Seite: + { // SDK4 SDK5 + case 0x01: // Array Formula [325 ] + { + STARTTOKEN( "Exp" ); + sal_uInt16 nRow, nCol; + *pIn >> nRow >> nCol; + t += "array formula or shared formula, base-address="; + lcl_AddRef( t, nCol, nRow ); + aStack.PushFunction( "ARRAY", 0, nOp ); + } + break; + case 0x02: // Data Table [325 277] + { + STARTTOKEN( "Tbl" ); + sal_uInt16 nRow, nCol; + *pIn >> nRow >> nCol; + t += "multiple operation, base-address="; + lcl_AddRef( t, nCol, nRow ); + aStack.PushFunction( "MULTIPLE.OPERATIONS", 0, nOp ); + } + break; + case 0x03: // Addition [312 264] + STARTTOKEN( "Add" ); + aStack.PushBinary( "+" ); + break; + case 0x04: // Subtraction [313 264] + STARTTOKEN( "Sub" ); + aStack.PushBinary( "-" ); + break; + case 0x05: // Multiplication [313 264] + STARTTOKEN( "Mul" ); + aStack.PushBinary( "*" ); + break; + case 0x06: // Division [313 264] + STARTTOKEN( "Div" ); + aStack.PushBinary( "/" ); + break; + case 0x07: // Exponetiation [313 265] + STARTTOKEN( "Power" ); + aStack.PushBinary( "^" ); + break; + case 0x08: // Concatenation [313 265] + STARTTOKEN( "Concat" ); + aStack.PushBinary( "&" ); + break; + case 0x09: // Less Than [313 265] + STARTTOKEN( "LT" ); + aStack.PushBinary( "<" ); + break; + case 0x0A: // Less Than or Equal [313 265] + STARTTOKEN( "LE" ); + aStack.PushBinary( "<=" ); + break; + case 0x0B: // Equal [313 265] + STARTTOKEN( "EQ" ); + aStack.PushBinary( "=" ); + break; + case 0x0C: // Greater Than or Equal [313 265] + STARTTOKEN( "GE" ); + aStack.PushBinary( ">=" ); + break; + case 0x0D: // Greater Than [313 265] + STARTTOKEN( "GT" ); + aStack.PushBinary( ">" ); + break; + case 0x0E: // Not Equal [313 265] + STARTTOKEN( "NE" ); + aStack.PushBinary( "<>" ); + break; + case 0x0F: // Intersection [314 265] + STARTTOKEN( "Isect" ); + aStack.PushBinary( " " ); + break; + case 0x10: // List [314 265] + STARTTOKEN( "List" ); + aStack.PushBinary( ";" ); + break; + case 0x11: // Range [314 265] + STARTTOKEN( "Range" ); + aStack.PushBinary( ":" ); + break; + case 0x12: // Unary Plus [312 264] + STARTTOKEN( "Uplus" ); + aStack.PushUnary( "+" ); + break; + case 0x13: // Unary Minus [312 264] + STARTTOKEN( "Uminus" ); + aStack.PushUnary( "-" ); + break; + case 0x14: // Percent Sign [312 264] + STARTTOKEN( "Percent" ); + aStack.PushUnary( "%", false ); + break; + case 0x15: // Parenthesis [326 278] + STARTTOKEN( "Paren" ); + // simulate two unary operators to enclose operand + aStack.PushUnary( "(" ); + aStack.PushUnary( ")", false ); + break; + case 0x16: // Missing Argument [314 266] + STARTTOKEN( "MissArg" ); + aStack.PushOperand( "~", nOp ); + break; + case 0x17: // ByteString Constant [314 266] + { + STARTTOKEN( "Str" ); + + UINT8 nLen; + *pIn >> nLen; + + t += "string [len="; + __AddDec( t, nLen ); + t += "] "; + + aOperand += '"'; + if( nLen ) + aOperand += GETSTR( pIn->ReadUniString( nLen ) ); + else + pIn->Ignore( 1 ); + aOperand += '"'; + t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x18: + { + STARTTOKEN( "Extended" ); + UINT8 nEptg; + *pIn >> nEptg; + +#define D(name,size,ext,type) {t+="eptg ";__AddDec(t,(UINT16)nEptg);t+=": "; \ + t+=name;t+=" [";__AddDec(t,(UINT16)size);t+="] ";t+=type; \ + if(ext)t+=" + ext";PRINTTOKEN();ContDump(size);aStack.PushOperand(name,nOp);} + switch( nEptg ) + { // name size ext type + case 0x00: // res + D( "res", 0, 0, "" ); + break; + case 0x01: // Lel 4 - err + D( "Lel", 4, 0, "err" ); + break; + case 0x02: // Rw 4 - ref + D( "Rw", 4, 0, "ref" ); + break; + case 0x03: // Col 4 - ref + D( "Col", 4, 0, "ref" ); + break; + case 0x04: // res + case 0x05: // res + D( "res", 0, 0, "" ); + break; + case 0x06: // RwV 4 - val + D( "RwV", 4, 0, "val" ); + break; + case 0x07: // ColV 4 - val + D( "ColV", 4, 0, "val" ); + break; + case 0x08: // res + case 0x09: // res + D( "res", 0, 0, "" ); + break; + case 0x0A: // Radical 13 - ref + D( "Radical", 13, 0, "ref" ); + break; + case 0x0B: // RadicalS 13 x ref + D( "RadicalS", 13, 1, "ref" ); + break; + case 0x0C: // RwS 4 x ref + D( "RwS", 4, 1, "ref" ); + break; + case 0x0D: // ColS 4 x ref + D( "ColS", 4, 1, "ref" ); + break; + case 0x0E: // RwSV 4 x val + D( "RwSV", 4, 1, "val" ); + break; + case 0x0F: // ColSV 4 x val + D( "ColSV", 4, 1, "val" ); + break; + case 0x10: // RadicalLel 4 - err + D( "RadicalLel", 4, 0, "err" ); + break; + case 0x11: // res + case 0x12: // res + case 0x13: // res + case 0x14: // res + case 0x15: // res + case 0x16: // res + case 0x17: // res + case 0x18: // res + D( "res", 0, 0, "" ); + break; + case 0x19: // invalid values + case 0x1A: // invalid values + D( "invalid vals", 0, 0, "" ); + break; + case 0x1B: // res + case 0x1C: // res + D( "res", 0, 0, "" ); + break; + case 0x1D: // SxName 4 - val + D( "SxName", 4, 0, "val" ); + break; + case 0x1E: // res + D( "res", 0, 0, "" ); + break; + default: + D( "!unknown!", 0, 0, "" ); + } +#undef D + } + break; + case 0x19: // Special Attribute [327 279] + { + STARTTOKEN( "Attr" ); + UINT16 nData, nFakt; + BYTE nOpt; + + *pIn >> nOpt >> nData; + nFakt = 2; + + t += "flags="; __AddHex( t, nOpt ); + + if( nOpt & 0x01 ) t += " volatile"; + if( nOpt & 0x02 ) t += " if"; + if( nOpt & 0x04 ) t += " choose"; + if( nOpt & 0x08 ) t += " skip"; + if( nOpt & 0x10 ) t += " sum"; + if( nOpt & 0x20 ) t += " assignment"; + if( nOpt & 0x40 ) t += " space"; + if( nOpt & 0x80 ) t += " unknown"; + + if( nOpt & 0x02 ) + { + t += " skip-to-false="; + __AddHex( t, nData ); + } + if( nOpt & 0x04 ) + { + t += " count="; + __AddDec( t, nData ); + t += " skip="; + for( sal_uInt16 nIdx = 0; nIdx <= nData; ++nIdx ) + { + if( nIdx ) t += ','; + __AddDec( t, pIn->ReaduInt16() ); + } + } + if( nOpt & 0x08 ) + { + t += " skip="; + __AddHex( t, nData ); + t += " ("; + __AddDec( t, sal_uInt8( nData + 1 ) ); + t += " bytes)"; + } + if( nOpt & 0x10 ) + aStack.PushFunction( "ATTRSUM", 1, nOp ); + if( nOpt & 0x40 ) + { + t += " type="; + __AddDec( t, static_cast< sal_uInt8 >( nData ) ); + t += " count="; + __AddDec( t, static_cast< sal_uInt8 >( nData >> 8 ) ); + } + } + break; + case 0x1C: // Error Value [314 266] + { + STARTTOKEN( "Err" ); + sal_uInt8 nErr = pIn->ReaduInt8(); + t += "error value ("; __AddHex( t, nErr ); + t += ") "; + t += lcl_GetErrorString( nErr ); + aStack.PushOperand( lcl_GetErrorString( nErr ), nOp ); + } + break; + case 0x1D: // Boolean [315 266] + STARTTOKEN( "Bool" ); + aOperand += pIn->ReaduInt8() ? "TRUE" : "FALSE"; + t += aOperand; + aStack.PushOperand( aOperand, nOp ); + break; + case 0x1E: // Integer [315 266] + STARTTOKEN( "Int" ); + __AddDec( aOperand, pIn->ReaduInt16() ); + t += aOperand; + aStack.PushOperand( aOperand, nOp ); + break; + case 0x1F: // Number [315 266] + STARTTOKEN( "Num" ); + __AddDouble( aOperand, pIn->ReadDouble() ); + t += aOperand; + aStack.PushOperand( aOperand, nOp ); + break; + case 0x20: // Array Constant [317 268] + case 0x40: + case 0x60: + STARTTOKENCLASS( "Array" ); + pIn->Ignore( 7 ); + aStack.PushOperand( "{ConstArray}", nOp ); + break; + case 0x21: // Function, Fixed Number of Arguments [333 282] + case 0x41: + case 0x61: + { + STARTTOKENCLASS( "Func" ); + UINT16 nInd = pIn->ReaduInt16(); + const XclDumpFunc* pFunc = lcl_GetFuncData( nInd ); + aOperand += pFunc ? pFunc->pName : "!unknown!"; + + t += "fix function: index="; __AddHex( t, nInd ); + t += " ("; t += aOperand; + t += ')'; + aStack.PushFunction( aOperand, pFunc ? pFunc->nParam : 0, nOp ); + } + break; + case 0x22: // Function, Variable Number of Arg. [333 283] + case 0x42: + case 0x62: + { + STARTTOKENCLASS( "FuncVar" ); + BYTE nAnz; + UINT16 nInd; + *pIn >> nAnz >> nInd; + const XclDumpFunc* pFunc = lcl_GetFuncData( nInd & 0x7FFF ); + aOperand += pFunc ? pFunc->pName : "!unknown!"; + + t += "var function: index="; __AddHex( t, nInd ); + t += " ("; t += aOperand; + t += ") param count="; __AddHex( t, nAnz ); + t += " ("; __AddDec( t, (UINT8)(nAnz & 0x7F) ); + t += ')'; + if( nAnz & 0x8000 ) + t += " cmd-equiv."; + aStack.PushFunction( aOperand, nAnz & 0x7F, nOp ); + } + break; + case 0x23: // Name [318 269] + case 0x43: + case 0x63: + { + STARTTOKENCLASS( "Name" ); + sal_uInt16 nNameIdx = pIn->ReaduInt16(); + __AddDec( aOperand, nNameIdx ); + t += "internal name: index="; + t += aOperand; + pIn->Ignore( 2 ); + if( (0 < nNameIdx) && (nNameIdx <= maNames.size()) ) + aOperand = maNames[ nNameIdx - 1 ]; + else + aOperand.Insert( "NAME(", 0 ).Append( ')' ); + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x24: // Cell Reference [319 270] + case 0x44: + case 0x64: + case 0x2A: // Deleted Cell Reference [323 273] + case 0x4A: + case 0x6A: + { + if( (nOp & 0x1F) == 0x04 ) + STARTTOKENCLASS( "Ref" ); + else + STARTTOKENCLASS( "RefErr" ); + + UINT16 nCol, nRow; + *pIn >> nRow >> nCol; + AddRef( aOperand, nRow, nCol, bRangeName ); + t += "2D cell ref C/R="; __AddHex( t, nCol ); + t += '/'; __AddHex( t, nRow ); + t += ' '; t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x25: // Area Reference [320 270] + case 0x45: + case 0x65: + case 0x2B: // Deleted Area Refernce [323 273] + case 0x4B: + case 0x6B: + { + if( (nOp & 0x1F) == 0x05 ) + STARTTOKENCLASS( "Area" ); + else + STARTTOKENCLASS( "AreaErr" ); + + UINT16 nRowFirst, nRowLast, nColFirst, nColLast; + *pIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast; + AddRangeRef( aOperand, nRowFirst, nColFirst, nRowLast, nColLast, bRangeName ); + t += "2D area ref C/R:C/R="; __AddHex( t, nColFirst ); + t += '/'; __AddHex( t, nRowFirst ); + t += ':'; __AddHex( t, nColLast ); + t += '/'; __AddHex( t, nRowLast ); + t += ' '; t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x26: // Constant Reference Subexpression [321 271] + case 0x46: + case 0x66: + { + STARTTOKENCLASS( "MemArea" ); + sal_uInt32 nRes; + sal_uInt16 nSize; + *pIn >> nRes >> nSize; + t += "reserved="; __AddHex( t, nRes ); + t += " size="; __AddDec( t, nSize ); + } + break; + case 0x27: // Erroneous Constant Reference Subexpr. [322 272] + case 0x47: + case 0x67: + { + STARTTOKENCLASS( "MemErr" ); + sal_uInt32 nRes; + sal_uInt16 nSize; + *pIn >> nRes >> nSize; + t += "reserved="; __AddHex( t, nRes ); + t += " size="; __AddDec( t, nSize ); + } + break; + case 0x28: // Incomplete Constant Reference Subexpr.[331 281] + case 0x48: + case 0x68: + { + STARTTOKENCLASS( "MemNoMem" ); + sal_uInt32 nRes; + sal_uInt16 nSize; + *pIn >> nRes >> nSize; + t += "reserved="; __AddHex( t, nRes ); + t += " size="; __AddDec( t, nSize ); + } + break; + case 0x29: // Variable Reference Subexpression [331 281] + case 0x49: + case 0x69: + { + STARTTOKENCLASS( "MemFunc" ); + sal_uInt16 nSize; + *pIn >> nSize; + t += "size="; __AddDec( t, nSize ); + } + break; + case 0x2C: // Cell Reference Within a Name/ShrdFmla [323 273] + case 0x4C: + case 0x6C: + { + STARTTOKENCLASS( "RefN" ); + UINT16 nRow, nCol; + *pIn >> nRow >> nCol; + AddRef( aOperand, nRow, nCol, bRNorSF ); + t += "2D cell ref in name C/R="; __AddHex( t, nCol ); + t += '/'; __AddHex( t, nRow ); + t += ' '; t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x2D: // Area Reference Within a Name/ShrdFmla [324 274] + case 0x4D: + case 0x6D: + { + STARTTOKENCLASS( "AreaN" ); + UINT16 nRowFirst, nRowLast, nColFirst, nColLast; + *pIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast; + AddRangeRef( aOperand, nRowFirst, nColFirst, nRowLast, nColLast, bRNorSF ); + t += "2D area ref in name C/R:C/R"; __AddHex( t, nColFirst ); + t += '/'; __AddHex( t, nRowFirst ); + t += ':'; __AddHex( t, nColLast ); + t += '/'; __AddHex( t, nRowLast ); + t += ' '; t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x2E: // Reference Subexpression Within a Name [332 282] + case 0x4E: + case 0x6E: + { + STARTTOKENCLASS( "MemAreaN" ); + sal_uInt16 nSize; + *pIn >> nSize; + t += "size="; __AddDec( t, nSize ); + } + break; + case 0x2F: // Incomplete Reference Subexpression... [332 282] + case 0x4F: + case 0x6F: + { + STARTTOKENCLASS( "MemNoMemN" ); + sal_uInt16 nSize; + *pIn >> nSize; + t += "size="; __AddDec( t, nSize ); + } + break; + case 0x39: // Name or External Name [ 275] + case 0x59: + case 0x79: + { + STARTTOKENCLASS( "NameX" ); + UINT16 nXti, nName; + *pIn >> nXti >> nName; + pIn->Ignore( 2 ); + t += "external name: XTI="; __AddDec( t, nXti ); + t += " name index="; __AddDec( t, nName ); + aOperand += "EXTNAME(XTI("; + __AddDec( aOperand, nXti ); + aOperand += "),"; + __AddDec( aOperand, nName ); + aOperand += ')'; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x3A: // 3-D Cell Reference [ 275] + case 0x5A: + case 0x7A: + case 0x3C: // Deleted 3-D Cell Reference [ 277] + case 0x5C: + case 0x7C: + { + if( (nOp & 0x1F) == 0x1A ) + STARTTOKENCLASS( "Ref3d" ); + else + STARTTOKENCLASS( "Ref3dErr" ); + + UINT16 nXti, nRow, nCol; + *pIn >> nXti >> nRow >> nCol; + AddRef( aOperand, nRow, nCol, bRangeName, nXti ); + t += "3D cell ref Xti!C/R="; __AddHex( t, nXti ); + t += '!'; __AddHex( t, nCol ); + t += '/'; __AddHex( t, nRow ); + t += ' '; t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + case 0x3B: // 3-D Area Reference [ 276] + case 0x5B: + case 0x7B: + case 0x3D: // Deleted 3-D Area Reference [ 277] + case 0x5D: + case 0x7D: + { + if( (nOp & 0x1F) == 0x1B ) + STARTTOKENCLASS( "Area3d" ); + else + STARTTOKENCLASS( "Area3dErr" ); + + UINT16 nXti, nRow1, nCol1, nRow2, nCol2; + *pIn >> nXti >> nRow1 >> nRow2 >> nCol1 >> nCol2; + AddRangeRef( aOperand, nRow1, nCol1, nRow2, nCol2, bRangeName, nXti ); + t += "3D area ref Xti!C/R:C/R="; __AddHex( t, nXti ); + t += '!'; __AddHex( t, nCol1 ); + t += '/'; __AddHex( t, nRow1 ); + t += ':'; __AddHex( t, nCol2 ); + t += '/'; __AddHex( t, nRow2 ); + t += ' '; t += aOperand; + aStack.PushOperand( aOperand, nOp ); + } + break; + default: + STARTTOKEN( "unknown" ); + bError = TRUE; + } + PRINTTOKEN(); + } + t.Assign( " Formula = " ); + if( aStack.GetFormula().Len() ) t += aStack.GetFormula(); else t += "ERROR IN STACK"; + Print( t ); + t.Assign( " Tokencl = " ).Append( aStack.GetTokenClasses() ); + Print( t ); + pIn->Seek( nAfterPos ); +} + + +// ============================================================================ +// +// S T R E A M C O N T E N T S +// +// ============================================================================ + +void Biff8RecDumper::DumpBinary( SvStream& rInStrm, ULONG nSize ) +{ + ULONG nStrmPos = rInStrm.Tell(); + rInStrm.Seek( STREAM_SEEK_TO_END ); + ULONG nStrmLen = rInStrm.Tell(); + rInStrm.Seek( nStrmPos ); + ULONG nDumpEnd = (nSize == STREAM_SEEK_TO_END) ? nStrmLen : ::std::min( nStrmPos + nSize, nStrmLen ); + + const ULONG LINE_SIZE = 16; + sal_uInt8 pnData[ LINE_SIZE ]; + + while( rInStrm.Tell() < nDumpEnd ) + { + ByteString aBinLine; + ByteString aTextLine; + + ULONG nLineLen = ::std::min( nDumpEnd - rInStrm.Tell(), LINE_SIZE ); + rInStrm.Read( pnData, nLineLen ); + + for( sal_uInt8 *pnByte = pnData, *pnEnd = pnData + nLineLen; pnByte != pnEnd; ++pnByte ) + { + if( pnByte - pnData == LINE_SIZE / 2 ) + { + aBinLine.Append( ' ' ); + aTextLine.Append( ' ' ); + } + __AddPureHex( aBinLine, *pnByte ); + aBinLine.Append( ' ' ); + aTextLine.Append( static_cast< sal_Char >( IsPrintable( *pnByte ) ? *pnByte : '.' ) ); + } + + aBinLine.Expand( LINE_SIZE * 3 + 3, ' ' ); + (*pDumpStream) << aBinLine.GetBuffer() << aTextLine.GetBuffer() << "\n"; + } +} + +// ============================================================================ +// +// F O R M C O N T R O L S +// +// ============================================================================ + +namespace { + +// little helpers ------------------------------------------------------------- + +/** Import from bytestream. */ +SvStream& operator>>( SvStream& rStrm, XclGuid& rGuid ) +{ + rStrm.Read( rGuid.mpnData, 16 ); + return rStrm; +} + +/** Output guid into text stream. */ +SvStream& operator<<( SvStream& rStrm, const XclGuid& rGuid ) +{ + ByteString aOut; + lclAppendGuid( aOut, rGuid ); + return rStrm << aOut.GetBuffer(); +} + +void lclAlignStream( SvStream& rInStrm, ULONG nStartPos, ULONG nDataWidth ) +{ + rInStrm.SeekRel( nDataWidth - 1 - (rInStrm.Tell() - nStartPos + nDataWidth - 1) % nDataWidth ); +} + +// control types -------------------------------------------------------------- + +const sal_uInt16 EXC_CTRL_PAGE = 0x0007; +const sal_uInt16 EXC_CTRL_IMAGE = 0x000C; +const sal_uInt16 EXC_CTRL_FRAME = 0x000E; +const sal_uInt16 EXC_CTRL_SPINBUTTON = 0x0010; +const sal_uInt16 EXC_CTRL_PUSHBUTTON = 0x0011; +const sal_uInt16 EXC_CTRL_TABSTRIP = 0x0012; +const sal_uInt16 EXC_CTRL_LABEL = 0x0015; +const sal_uInt16 EXC_CTRL_TEXTBOX = 0x0017; +const sal_uInt16 EXC_CTRL_LISTBOX = 0x0018; +const sal_uInt16 EXC_CTRL_COMBOBOX = 0x0019; +const sal_uInt16 EXC_CTRL_CHECKBOX = 0x001A; +const sal_uInt16 EXC_CTRL_OPTIONBUTTON = 0x001B; +const sal_uInt16 EXC_CTRL_TOGGLEBUTTON = 0x001C; +const sal_uInt16 EXC_CTRL_SCROLLBAR = 0x002F; +const sal_uInt16 EXC_CTRL_MULTIPAGE = 0x0039; +const sal_uInt16 EXC_CTRL_REFEDIT = 0x8000; +const sal_uInt16 EXC_CTRL_FONTDATA = 0xFFF0; // internal use only +const sal_uInt16 EXC_CTRL_USERFORM = 0xFFF1; // internal use only +const sal_uInt16 EXC_CTRL_ADDDATA = 0xFFF2; // internal use only +const sal_uInt16 EXC_CTRL_FRAMECHILD = 0xFFF3; // internal use only +const sal_uInt16 EXC_CTRL_PROGRESSBAR = 0xFFF4; // internal use only +const sal_uInt16 EXC_CTRL_UNKNOWN = 0xFFFF; // internal use only + +const sal_uInt16 EXC_CTRL_RECORD_ID = 0x0000; +const sal_uInt16 EXC_CTRL_CLIENT_ID = 0x0200; +const sal_uInt16 EXC_CTRL_CONTAINER_ID = 0x0400; + +// control names -------------------------------------------------------------- + +struct XclDumpControlInfo +{ + sal_uInt16 mnType; + const sal_Char* mpcName; + sal_uInt16 mnId; +}; + +static const XclDumpControlInfo spControlInfos[] = +{ + { EXC_CTRL_PAGE, "Page", EXC_CTRL_CONTAINER_ID }, + { EXC_CTRL_IMAGE, "Image", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_FRAME, "Frame", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_SPINBUTTON, "Spin", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_PUSHBUTTON, "PushButton", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_TABSTRIP, "TabStrip", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_LABEL, "Label", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_TEXTBOX, "TextBox", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_LISTBOX, "ListBox", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_COMBOBOX, "ComboBox", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_CHECKBOX, "CheckBox", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_OPTIONBUTTON, "OptionButton", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_TOGGLEBUTTON, "ToggleButton", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_SCROLLBAR, "ScrollBar", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_MULTIPAGE, "MultiPage", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_REFEDIT, "RefEdit", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_FONTDATA, "FontData", EXC_CTRL_CLIENT_ID }, + { EXC_CTRL_USERFORM, "UserForm", EXC_CTRL_CONTAINER_ID }, + { EXC_CTRL_ADDDATA, "AddData", EXC_CTRL_RECORD_ID }, + { EXC_CTRL_FRAMECHILD, "FrameChild", EXC_CTRL_RECORD_ID }, + { EXC_CTRL_PROGRESSBAR, "ProgressBar", EXC_CTRL_RECORD_ID } +}; + +typedef ::std::map< sal_uInt16, const XclDumpControlInfo* > XclDumpControlInfoMap; +typedef ScfRef< XclDumpControlInfoMap > XclDumpControlInfoMapRef; + +XclDumpControlInfoMapRef lclCreateControlInfoMap() +{ + XclDumpControlInfoMapRef xMap( new XclDumpControlInfoMap ); + for( const XclDumpControlInfo *pIt = spControlInfos, *pEnd = STATIC_TABLE_END( spControlInfos ); pIt != pEnd; ++pIt ) + (*xMap)[ pIt->mnType ] = pIt; + return xMap; +} + +const XclDumpControlInfoMap& lclGetControlInfoMap() +{ + static const XclDumpControlInfoMapRef sxMap = lclCreateControlInfoMap(); + return *sxMap; +} + +void lclAppendControlType( ByteString& rStr, sal_uInt16 nCtrlType ) +{ + const XclDumpControlInfoMap& rMap = lclGetControlInfoMap(); + XclDumpControlInfoMap::const_iterator aIt = rMap.find( nCtrlType ); + rStr.Append( (aIt == rMap.end()) ? "*UNKNOWN*" : aIt->second->mpcName ); +} + +void lclDumpControlType( SvStream& rOutStrm, sal_uInt16 nCtrlType ) +{ + ByteString aTitle( "type=" ); + lclAppendHex( aTitle, nCtrlType ); + aTitle.Append( " (" ); + lclAppendControlType( aTitle, nCtrlType ); + aTitle.Append( ')' ); + rOutStrm << aTitle.GetBuffer(); +} + +sal_uInt16 lclDumpControlHeader( SvStream& rInStrm, SvStream& rOutStrm, sal_uInt16 nCtrlType ) +{ + lclDumpControlType( rOutStrm, nCtrlType ); + sal_uInt16 nId, nSize; + rInStrm >> nId >> nSize; + ByteString aLine( " id=" ); lclAppendHex( aLine, nId ); + const XclDumpControlInfoMap& rMap = lclGetControlInfoMap(); + XclDumpControlInfoMap::const_iterator aIt = rMap.find( nCtrlType ); + bool bValid = (aIt != rMap.end()) && (aIt->second->mnId == nId); + aLine.Append( bValid ? " (valid)" : " (invalid)" ); + aLine.Append( " size=" ); lclAppendHex( aLine, nSize ); + rOutStrm << aLine.GetBuffer() << "\n"; + return nSize; +} + +// control GUIDs -------------------------------------------------------------- + +struct XclDumpControlGuid +{ + sal_uInt16 mnType; + sal_uInt32 mnGuidData1; + sal_uInt16 mnGuidData2; + sal_uInt16 mnGuidData3; + sal_uInt8 mnGuidData41; + sal_uInt8 mnGuidData42; + sal_uInt8 mnGuidData43; + sal_uInt8 mnGuidData44; + sal_uInt8 mnGuidData45; + sal_uInt8 mnGuidData46; + sal_uInt8 mnGuidData47; + sal_uInt8 mnGuidData48; +}; + +static const XclDumpControlGuid spControlGuids[] = +{ + { EXC_CTRL_PUSHBUTTON, 0xD7053240, 0xCE69, 0x11CD, 0xA7, 0x77, 0x00, 0xDD, 0x01, 0x14, 0x3C, 0x57 }, + { EXC_CTRL_TOGGLEBUTTON, 0x8BD21D60, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 }, + { EXC_CTRL_CHECKBOX, 0x8BD21D40, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 }, + { EXC_CTRL_OPTIONBUTTON, 0x8BD21D50, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 }, + { EXC_CTRL_LABEL, 0x978C9E23, 0xD4B0, 0x11CE, 0xBF, 0x2D, 0x00, 0xAA, 0x00, 0x3F, 0x40, 0xD0 }, + { EXC_CTRL_TEXTBOX, 0x8BD21D10, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 }, + { EXC_CTRL_LISTBOX, 0x8BD21D20, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 }, + { EXC_CTRL_COMBOBOX, 0x8BD21D30, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 }, + { EXC_CTRL_SPINBUTTON, 0x79176FB0, 0xB7F2, 0x11CE, 0x97, 0xEF, 0x00, 0xAA, 0x00, 0x6D, 0x27, 0x76 }, + { EXC_CTRL_SCROLLBAR, 0xDFD181E0, 0x5E2F, 0x11CE, 0xA4, 0x49, 0x00, 0xAA, 0x00, 0x4A, 0x80, 0x3D }, + { EXC_CTRL_IMAGE, 0x4C599241, 0x6926, 0x101B, 0x99, 0x92, 0x00, 0x00, 0x0B, 0x65, 0xC6, 0xF9 }, + { EXC_CTRL_PROGRESSBAR, 0x35053A22, 0x8589, 0x11D1, 0xB1, 0x6A, 0x00, 0xC0, 0xF0, 0x28, 0x36, 0x28 } +}; + +typedef ::std::map< XclGuid, sal_uInt16 > XclDumpControlGuidMap; +typedef ScfRef< XclDumpControlGuidMap > XclDumpControlGuidMapRef; + +XclDumpControlGuidMapRef lclCreateControlGuidMap() +{ + XclDumpControlGuidMapRef xMap( new XclDumpControlGuidMap ); + for( const XclDumpControlGuid *pIt = spControlGuids, *pEnd = STATIC_TABLE_END( spControlGuids ); pIt != pEnd; ++pIt ) + { + XclGuid aGuid( pIt->mnGuidData1, pIt->mnGuidData2, pIt->mnGuidData3, + pIt->mnGuidData41, pIt->mnGuidData42, pIt->mnGuidData43, pIt->mnGuidData44, + pIt->mnGuidData45, pIt->mnGuidData46, pIt->mnGuidData47, pIt->mnGuidData48 ); + (*xMap)[ aGuid ] = pIt->mnType; + } + return xMap; +} + +const XclDumpControlGuidMap& lclGetControlGuidMap() +{ + static const XclDumpControlGuidMapRef sxMap = lclCreateControlGuidMap(); + return *sxMap; +} + +sal_uInt16 lclDumpControlGuid( SvStream& rInStrm, SvStream& rOutStrm ) +{ + XclGuid aGuid; + rInStrm >> aGuid; + const XclDumpControlGuidMap& rMap = lclGetControlGuidMap(); + XclDumpControlGuidMap::const_iterator aIt = rMap.find( aGuid ); + sal_uInt16 nCtrlType = (aIt == rMap.end()) ? EXC_CTRL_UNKNOWN : aIt->second; + rOutStrm << "guid=" << aGuid; + return nCtrlType; +}; + +// other guids ---------------------------------------------------------------- + +static const XclGuid saStdFontGuid( 0x0BE35203, 0x8F91, 0x11CE, 0x9D, 0xE3, 0x00, 0xAA, 0x00, 0x4B, 0xB8, 0x51 ); +static const XclGuid saStdPicGuid( 0x0BE35204, 0x8F91, 0x11CE, 0x9D, 0xE3, 0x00, 0xAA, 0x00, 0x4B, 0xB8, 0x51 );\ + +// ---------------------------------------------------------------------------- + +} // namespace + +// *** yet some other ugly macros for the specials of form control dumping *** + +// align the instream +#define EXC_CTRLDUMP_ALIGN_INSTRM( val ) lclAlignStream( rInStrm, nStartPos, val ) +// push the string to outstream +#define EXC_CTRLDUMP_PRINT() { if( t.Len() ) { rOutStrm << t.GetBuffer() << '\n'; t.Erase(); } } + +// implementation, don't use +#define IMPL_EXC_CTRLDUMP_PLAIN_VALUE( type, func, text ) { type n; rInStrm >> n; t.Append( " " text "=" ); func( t, n ); EXC_CTRLDUMP_PRINT(); } +#define IMPL_EXC_CTRLDUMP_VALUE( type, func, text ) { EXC_CTRLDUMP_ALIGN_INSTRM( sizeof( type ) ); IMPL_EXC_CTRLDUMP_PLAIN_VALUE( type, func, text ); } +#define IMPL_EXC_CTRLDUMP_PLAIN_VAR( var, mask, func, text ) { rInStrm >> var; var &= (mask); t.Append( " " text "=" ); func( t, var ); EXC_CTRLDUMP_PRINT(); } +#define IMPL_EXC_CTRLDUMP_VAR( var, mask, func, text ) { EXC_CTRLDUMP_ALIGN_INSTRM( sizeof( var ) ); IMPL_EXC_CTRLDUMP_PLAIN_VAR( var, mask, func, text ); } + +// read a value from stream (no stream alignment) +#define EXC_CTRLDUMP_PLAIN_HEX4( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( sal_uInt32, lclAppendHex, text ) +#define EXC_CTRLDUMP_PLAIN_DEC4( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( sal_Int32, lclAppendDec, text ) +#define EXC_CTRLDUMP_PLAIN_HEX2( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( sal_uInt16, lclAppendHex, text ) +#define EXC_CTRLDUMP_PLAIN_DEC2( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( sal_Int16, lclAppendDec, text ) +#define EXC_CTRLDUMP_PLAIN_HEX1( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( sal_uInt8, lclAppendHex, text ) +#define EXC_CTRLDUMP_PLAIN_DEC1( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( sal_Int8, lclAppendDec, text ) +#define EXC_CTRLDUMP_PLAIN_DECF( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( float, lclAppendDec, text ) +// read a value from stream (with stream alignment) +#define EXC_CTRLDUMP_HEX4( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_uInt32, lclAppendHex, text ) +#define EXC_CTRLDUMP_DEC4( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_Int32, lclAppendDec, text ) +#define EXC_CTRLDUMP_HEX2( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_uInt16, lclAppendHex, text ) +#define EXC_CTRLDUMP_DEC2( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_Int16, lclAppendDec, text ) +#define EXC_CTRLDUMP_HEX1( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_uInt8, lclAppendHex, text ) +#define EXC_CTRLDUMP_DEC1( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_Int8, lclAppendDec, text ) +// read a value from stream into existing variable (no stream alignment) +#define EXC_CTRLDUMP_PLAIN_HEXVAR( var, text ) IMPL_EXC_CTRLDUMP_PLAIN_VAR( var, ~0, lclAppendHex, text ) +#define EXC_CTRLDUMP_PLAIN_DECVAR( var, text ) IMPL_EXC_CTRLDUMP_PLAIN_VAR( var, ~0, lclAppendDec, text ) +#define EXC_CTRLDUMP_PLAIN_HEXVARMASK( var, mask, text ) IMPL_EXC_CTRLDUMP_PLAIN_VAR( var, mask, lclAppendHex, text ) +#define EXC_CTRLDUMP_PLAIN_DECVARMASK( var, mask, text ) IMPL_EXC_CTRLDUMP_PLAIN_VAR( var, mask, lclAppendDec, text ) +// read a value from stream into existing variable (with stream alignment) +#define EXC_CTRLDUMP_HEXVAR( var, text ) IMPL_EXC_CTRLDUMP_VAR( var, ~0, lclAppendHex, text ) +#define EXC_CTRLDUMP_DECVAR( var, text ) IMPL_EXC_CTRLDUMP_VAR( var, ~0, lclAppendDec, text ) +#define EXC_CTRLDUMP_HEXVARMASK( var, mask, text ) IMPL_EXC_CTRLDUMP_VAR( var, mask, lclAppendHex, text ) +#define EXC_CTRLDUMP_DECVARMASK( var, mask, text ) IMPL_EXC_CTRLDUMP_VAR( var, mask, lclAppendDec, text ) +// read flag fields +#define EXC_CTRLDUMP_PLAIN_STARTOPTFLAG( text, doread, defaults )\ +{ \ + nFlags = defaults; \ + t.Append( " " text ); \ + if( doread ) \ + rInStrm >> nFlags; \ + else \ + t.Append( "-defaulted" ); \ + t.Append( '=' ); \ + lclAppendHex( t, nFlags ); \ +} +#define EXC_CTRLDUMP_STARTOPTFLAG( text, doread, defaults ) { if( doread ) { EXC_CTRLDUMP_ALIGN_INSTRM( sizeof( nFlags ) ); } EXC_CTRLDUMP_PLAIN_STARTOPTFLAG( text, doread, defaults ) } +#define EXC_CTRLDUMP_PLAIN_STARTFLAG( text ) EXC_CTRLDUMP_PLAIN_STARTOPTFLAG( text, true, 0 ) +#define EXC_CTRLDUMP_STARTFLAG( text ) EXC_CTRLDUMP_STARTOPTFLAG( text, true, 0 ) +#define EXC_CTRLDUMP_ADDFLAG( flag, text ) { if( nFlags & (flag) ) t.Append( " " text ); } +#define EXC_CTRLDUMP_ADDFLAGVALUE( start, width, text ) { sal_uInt32 nValue; ::extract_value( nValue, nFlags, start, width ); t.Append( " " text "=" ); lclAppendDec( t, nValue ); } +#define EXC_CTRLDUMP_ENDFLAG( reserved ) { if( nFlags & (reserved) ) { t.Append( " ?" ); lclAppendHex( t, static_cast< sal_uInt32 >( nFlags & (reserved) ) ); } EXC_CTRLDUMP_PRINT(); } +// read coordinates +#define EXC_CTRLDUMP_COORD2( text ) { EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); EXC_CTRLDUMP_DEC2( text "-x" ); EXC_CTRLDUMP_DEC2( text "-y" ); } +#define EXC_CTRLDUMP_COORD4( text ) { EXC_CTRLDUMP_DEC4( text "-x" ); EXC_CTRLDUMP_DEC4( text "-y" ); } +#define EXC_CTRLDUMP_SIZE4( text ) { EXC_CTRLDUMP_DEC4( text "-width" ); EXC_CTRLDUMP_DEC4( text "-height" ); } +// read guid +#define EXC_CTRLDUMP_PLAIN_GUID( text ) IMPL_EXC_CTRLDUMP_PLAIN_VALUE( XclGuid, lclAppendGuid, text ) +#define EXC_CTRLDUMP_GUID( text ) { EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); EXC_CTRLDUMP_PLAIN_GUID( text ); } +// read control type +#define EXC_CTRLDUMP_CTRLTYPE( var, text ) \ +{ \ + EXC_CTRLDUMP_ALIGN_INSTRM( 2 ); \ + rInStrm >> var; \ + t.Assign( " " text "=" ); lclAppendHex( t, var ); \ + t.Append( " (" ); lclAppendControlType( t, var ); \ + t.Append( ')' ); \ + EXC_CTRLDUMP_PRINT(); \ +} +// read character array, add to string, but do not print +#define EXC_CTRLDUMP_RAWSTRING( var ) \ +{ \ + t.Append( "='" ); \ + if( var ) \ + { \ + EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); \ + ULONG nNextPos = rInStrm.Tell() + (var); \ + if( var > 128 ) var = 128; \ + sal_Char pc[ 129 ]; \ + rInStrm.Read( pc, var ); pc[ var ] = '\0'; \ + t.Append( pc ); \ + rInStrm.Seek( nNextPos ); \ + } \ + t.Append( '\'' ); \ +} +// read a string +#define EXC_CTRLDUMP_STRING( var, text ) \ +{ \ + t.Append( " " text ); \ + EXC_CTRLDUMP_RAWSTRING( var ); \ + EXC_CTRLDUMP_PRINT(); \ +} +// read an array of strings +#define EXC_CTRLDUMP_STRINGARRAY( total, count, text ) \ +{ \ + ULONG nNextPos = rInStrm.Tell() + (total); \ + for( sal_uInt32 nIdx = 0; (nIdx < (count)) && (rInStrm.Tell() < nNextPos); ++nIdx )\ + { \ + EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); \ + sal_uInt32 nLen; \ + rInStrm >> nLen; \ + nLen &= 0x7FFFFFFF; \ + t.Append( " " text "[" ); \ + lclAppendDec( t, nIdx + 1 ); \ + t.Append( ']' ); \ + EXC_CTRLDUMP_RAWSTRING( nLen ); \ + } \ + EXC_CTRLDUMP_PRINT(); \ + rInStrm.Seek( nNextPos ); \ +} +// read embedded font data +#define EXC_CTRLDUMP_FONT( var, text ) \ +if( var ) \ +{ \ + EXC_CTRLDUMP_PRINT(); \ + XclGuid aGuid; rInStrm >> aGuid; \ + rOutStrm << "embedded-font-guid=" << aGuid; \ + if( aGuid == saStdFontGuid ) \ + { \ + rOutStrm << " (StdFont)\n"; \ + EXC_CTRLDUMP_PLAIN_HEX1( "unknown1" ); \ + EXC_CTRLDUMP_PLAIN_DEC1( "script-type" ); \ + EXC_CTRLDUMP_PLAIN_HEX1( "unknown2" ); \ + sal_uInt8 nFlags; \ + EXC_CTRLDUMP_PLAIN_STARTFLAG( "font-style-flags" ); \ + EXC_CTRLDUMP_ADDFLAG( 0x02, "italic" ); \ + EXC_CTRLDUMP_ADDFLAG( 0x04, "underline" ); \ + EXC_CTRLDUMP_ADDFLAG( 0x08, "strikeout" ); \ + EXC_CTRLDUMP_ENDFLAG( 0xF1 ); \ + EXC_CTRLDUMP_PLAIN_DEC2( "font-weight" ); \ + EXC_CTRLDUMP_PLAIN_DEC4( "font-size" ); \ +/* font-size := pt*10000 + (1-((pt+1)%3))*2500 */ \ + sal_uInt8 nLen; \ + EXC_CTRLDUMP_PLAIN_DECVAR( nLen, "font-name-len" ); \ + sal_Char* p = new sal_Char[ nLen + 1 ]; \ + rInStrm.Read( p, nLen ); p[ nLen ] = '\0'; \ + t.Append( " font-name='" ).Append( p ).Append( '\'' );\ + delete [] p; \ + EXC_CTRLDUMP_PRINT(); \ + } \ + else \ + rOutStrm << " (*UNKNOWN*)\n"; \ +} +// read image data +#define EXC_CTRLDUMP_IMAGE( var, text ) \ +if( var ) \ +{ \ + EXC_CTRLDUMP_PRINT(); \ + XclGuid aGuid; rInStrm >> aGuid; \ + rOutStrm << "embedded-" text "-guid=" << aGuid; \ + if( aGuid == saStdPicGuid ) \ + { \ + rOutStrm << " (StdPict)\n"; \ + EXC_CTRLDUMP_PLAIN_HEX2( "u1" ); \ + EXC_CTRLDUMP_PLAIN_HEX2( "u2" ); \ + sal_uInt32 nLen; \ + EXC_CTRLDUMP_PLAIN_DECVAR( nLen, text "-len" ); \ + rInStrm.SeekRel( nLen ); \ + } \ + else \ + rOutStrm << " (*UNKNOWN*)\n"; \ +} +// hex dump remaining or unknown data +#define EXC_CTRLDUMP_REMAINING( nextpos ) \ +{ \ + EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); \ + if( rInStrm.Tell() < (nextpos) ) \ + { \ + rOutStrm << " unknown-data=\n"; \ + DumpBinary( rInStrm, ::std::min< ULONG >( (nextpos) - rInStrm.Tell(), 1024 ) );\ + } \ + rInStrm.Seek( nextpos ); \ +} + +// *** macros end *** + +void Biff8RecDumper::DumpControlContents( SvStream& rInStrm, sal_uInt16 nCtrlType ) +{ + SvStream& rOutStrm = *pDumpStream; + + if( nCtrlType == EXC_CTRL_PROGRESSBAR ) + { + lclDumpControlType( rOutStrm, nCtrlType ); + rOutStrm << '\n'; + + ByteString t; // "t" needed for macros + sal_uInt32 nFlags = 0; // "nFlags" needed for macros + + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_DEC4( "width" ); + EXC_CTRLDUMP_PLAIN_DEC4( "height" ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_DECF( "min" ); + EXC_CTRLDUMP_PLAIN_DECF( "max" ); + EXC_CTRLDUMP_PLAIN_STARTFLAG( "flags1" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000001, "vertical" ); + EXC_CTRLDUMP_ADDFLAG( 0x00010000, "smooth-scroll" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFEFFFE ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_HEX4( "unknown" ); + EXC_CTRLDUMP_PLAIN_STARTFLAG( "flags2" ); + EXC_CTRLDUMP_ADDFLAG( 0x0001, "border-single" ); + EXC_CTRLDUMP_ADDFLAG( 0x0002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x0004, "3d-style" ); + EXC_CTRLDUMP_ADDFLAGVALUE( 3, 8, "mouse-icon" ); + EXC_CTRLDUMP_ADDFLAG( 0x2000, "ole-drop-manual" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFD800 ); + return; + } + + sal_uInt16 nSize = lclDumpControlHeader( rInStrm, rOutStrm, nCtrlType ); + if( nSize > 0 ) + { + ULONG nStartPos = rInStrm.Tell(); // for stream alignment macro + ByteString t; // "t" needed for macros + sal_uInt32 nFlags = 0; // "nFlags" needed for macros + + bool bHasFontData = false; + sal_uInt32 nNameLen = 0; + sal_uInt32 nCaptionLen = 0; + sal_uInt32 nValueLen = 0; + sal_uInt32 nGroupNameLen = 0; + sal_uInt32 nTagLen = 0; + sal_uInt32 nTipLen = 0; + sal_uInt32 nCtrlIdLen = 0; + sal_uInt32 nCtrlSrcLen = 0; + sal_uInt32 nRowSrcLen = 0; + sal_uInt16 nPic = 0; + sal_uInt16 nIcon = 0; + sal_uInt16 nFont = 0; + + switch( nCtrlType ) + { + case EXC_CTRL_PUSHBUTTON: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x0001, "forecolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0002, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0004, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x0008, "caption" ); + EXC_CTRLDUMP_ADDFLAG( 0x0010, "picpos" ); + EXC_CTRLDUMP_ADDFLAG( 0x0020, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x0040, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x0080, "pic" ); + EXC_CTRLDUMP_ADDFLAG( 0x0100, "accel" ); + EXC_CTRLDUMP_ADDFLAG( 0x0200, "notakefocus" ); + EXC_CTRLDUMP_ADDFLAG( 0x0400, "icon" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFF800 ); + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x0004, 0x0000001B ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "opaque" ); + EXC_CTRLDUMP_ADDFLAG( 0x00800000, "wordwrap" ); + EXC_CTRLDUMP_ADDFLAG( 0x10000000, "autosize" ); + EXC_CTRLDUMP_ENDFLAG( 0xEF7FFFF1 ); + + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_DECVARMASK( nCaptionLen, 0x7FFFFFFF, "caption-len" ); + if( nCtrlFlags & 0x0010 ) EXC_CTRLDUMP_COORD2( "picpos" ); + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_HEXVAR( nPic, "pic" ); + if( nCtrlFlags & 0x0100 ) EXC_CTRLDUMP_HEX2( "accel" ); + if( nCtrlFlags & 0x0400 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + if( nCtrlFlags & 0x0020 ) EXC_CTRLDUMP_SIZE4( "size" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_IMAGE( nPic, "pic" ); + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + bHasFontData = true; + } + break; + + case EXC_CTRL_TOGGLEBUTTON: + case EXC_CTRL_CHECKBOX: + case EXC_CTRL_OPTIONBUTTON: + case EXC_CTRL_TEXTBOX: + case EXC_CTRL_LISTBOX: + case EXC_CTRL_COMBOBOX: + case EXC_CTRL_REFEDIT: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000001, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "forecolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "maxlen" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000010, "borderstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000020, "scrollbars" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000040, "style" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000080, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000100, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000200, "passwordchar" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000400, "listwidth" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000800, "boundcol" ); + EXC_CTRLDUMP_ADDFLAG( 0x00001000, "textcol" ); + EXC_CTRLDUMP_ADDFLAG( 0x00002000, "colcount" ); + EXC_CTRLDUMP_ADDFLAG( 0x00004000, "listrows" ); + EXC_CTRLDUMP_ADDFLAG( 0x00008000, "colwidth?" ); + EXC_CTRLDUMP_ADDFLAG( 0x00010000, "matchentry" ); + EXC_CTRLDUMP_ADDFLAG( 0x00020000, "liststyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00040000, "showdropbtn" ); + EXC_CTRLDUMP_ADDFLAG( 0x00100000, "dropbtnstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00200000, "multistate" ); + EXC_CTRLDUMP_ADDFLAG( 0x00400000, "value" ); + EXC_CTRLDUMP_ADDFLAG( 0x00800000, "caption" ); + EXC_CTRLDUMP_ADDFLAG( 0x01000000, "picpos" ); + EXC_CTRLDUMP_ADDFLAG( 0x02000000, "bordercolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x04000000, "specialeff" ); + EXC_CTRLDUMP_ADDFLAG( 0x08000000, "icon" ); + EXC_CTRLDUMP_ADDFLAG( 0x10000000, "pic" ); + EXC_CTRLDUMP_ADDFLAG( 0x20000000, "accel" ); + EXC_CTRLDUMP_ENDFLAG( 0x40080000 ); // 0x80000000 always set? + sal_uInt32 nCtrlFlags = nFlags; + + EXC_CTRLDUMP_STARTFLAG( "2nd-content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000001, "groupname" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFFFE ); + sal_uInt32 nCtrlFlags2 = nFlags; + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x00000001, 0x2C80081B ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "opaque" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000400, "colheads" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000800, "intheight" ); + EXC_CTRLDUMP_ADDFLAG( 0x00001000, "matchreq" ); + EXC_CTRLDUMP_ADDFLAG( 0x00002000, "align" ); + EXC_CTRLDUMP_ADDFLAGVALUE( 15, 4, "ime-mode" ); + EXC_CTRLDUMP_ADDFLAG( 0x00080000, "dragbehav" ); + EXC_CTRLDUMP_ADDFLAG( 0x00100000, "enterkeybehav" ); + EXC_CTRLDUMP_ADDFLAG( 0x00200000, "enterfieldbehav" ); + EXC_CTRLDUMP_ADDFLAG( 0x00400000, "tabkeybehav" ); + EXC_CTRLDUMP_ADDFLAG( 0x00800000, "wordwrap" ); + EXC_CTRLDUMP_ADDFLAG( 0x04000000, "selmargin" ); + EXC_CTRLDUMP_ADDFLAG( 0x08000000, "autowordsel" ); + EXC_CTRLDUMP_ADDFLAG( 0x10000000, "autosize" ); + EXC_CTRLDUMP_ADDFLAG( 0x20000000, "hidesel" ); + EXC_CTRLDUMP_ADDFLAG( 0x40000000, "autotab" ); + EXC_CTRLDUMP_ADDFLAG( 0x80000000, "multiline" ); + EXC_CTRLDUMP_ENDFLAG( 0x030043F1 ); + + if( nCtrlFlags & 0x00000002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + if( nCtrlFlags & 0x00000004 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x00000008 ) EXC_CTRLDUMP_DEC4( "maxlen" ); + if( nCtrlFlags & 0x00000010 ) EXC_CTRLDUMP_DEC1( "borderstyle" ); + if( nCtrlFlags & 0x00000020 ) EXC_CTRLDUMP_DEC1( "scrollbars" ); + if( nCtrlFlags & 0x00000040 ) EXC_CTRLDUMP_DEC1( "style" ); + if( nCtrlFlags & 0x00000080 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); + if( nCtrlFlags & 0x00000200 ) EXC_CTRLDUMP_HEX2( "passwordchar" ); + if( nCtrlFlags & 0x00000400 ) EXC_CTRLDUMP_DEC4( "listwidth" ); + if( nCtrlFlags & 0x00000800 ) EXC_CTRLDUMP_DEC2( "boundcol" ); + if( nCtrlFlags & 0x00001000 ) EXC_CTRLDUMP_DEC2( "textcol" ); + if( nCtrlFlags & 0x00002000 ) EXC_CTRLDUMP_DEC2( "colcount" ); + if( nCtrlFlags & 0x00004000 ) EXC_CTRLDUMP_DEC2( "listrows" ); + if( nCtrlFlags & 0x00008000 ) EXC_CTRLDUMP_DEC2( "colwidth?" ); + if( nCtrlFlags & 0x00010000 ) EXC_CTRLDUMP_DEC1( "matchentry" ); + if( nCtrlFlags & 0x00020000 ) EXC_CTRLDUMP_DEC1( "liststyle" ); + if( nCtrlFlags & 0x00040000 ) EXC_CTRLDUMP_DEC1( "showdropbtn" ); + if( nCtrlFlags & 0x00100000 ) EXC_CTRLDUMP_DEC1( "dropbtnstyle" ); + if( nCtrlFlags & 0x00200000 ) EXC_CTRLDUMP_DEC1( "multistate" ); + if( nCtrlFlags & 0x00400000 ) EXC_CTRLDUMP_DECVARMASK( nValueLen, 0x7FFFFFFF, "value-len" ); + if( nCtrlFlags & 0x00800000 ) EXC_CTRLDUMP_DECVARMASK( nCaptionLen, 0x7FFFFFFF, "caption-len" ); + if( nCtrlFlags & 0x01000000 ) EXC_CTRLDUMP_COORD2( "picpos" ); + if( nCtrlFlags & 0x02000000 ) EXC_CTRLDUMP_HEX4( "bordercolor" ); + if( nCtrlFlags & 0x04000000 ) EXC_CTRLDUMP_DEC4( "specialeff" ); + if( nCtrlFlags & 0x08000000 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + if( nCtrlFlags & 0x10000000 ) EXC_CTRLDUMP_HEXVAR( nPic, "pic" ); + if( nCtrlFlags & 0x20000000 ) EXC_CTRLDUMP_HEX1( "accel" ); + if( nCtrlFlags2 & 0x00000001 ) EXC_CTRLDUMP_DECVARMASK( nGroupNameLen, 0x7FFFFFFF, "groupname-len" ); + + if( nCtrlFlags & 0x00000100 ) EXC_CTRLDUMP_SIZE4( "size" ); + if( nCtrlFlags & 0x00400000 ) EXC_CTRLDUMP_STRING( nValueLen, "value" ); + if( nCtrlFlags & 0x00800000 ) EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + if( nCtrlFlags2 & 0x00000001 ) EXC_CTRLDUMP_STRING( nGroupNameLen, "groupname" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + EXC_CTRLDUMP_IMAGE( nPic, "pic" ); + bHasFontData = true; + } + break; + + case EXC_CTRL_LABEL: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x0001, "forecolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0002, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0004, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x0008, "caption" ); + EXC_CTRLDUMP_ADDFLAG( 0x0010, "picpos" ); + EXC_CTRLDUMP_ADDFLAG( 0x0020, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x0040, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x0080, "bordercolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0100, "borderstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x0200, "specialeff" ); + EXC_CTRLDUMP_ADDFLAG( 0x0400, "pic" ); + EXC_CTRLDUMP_ADDFLAG( 0x0800, "accel" ); + EXC_CTRLDUMP_ADDFLAG( 0x1000, "icon" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFE000 ); + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x0004, 0x0080001B ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "opaque" ); + EXC_CTRLDUMP_ADDFLAG( 0x00800000, "wordwrap" ); + EXC_CTRLDUMP_ADDFLAG( 0x10000000, "autosize" ); + EXC_CTRLDUMP_ENDFLAG( 0xEF7FFFF0 ); // 0x00000001 always set? + + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_DECVARMASK( nCaptionLen, 0x7FFFFFFF, "caption-len" ); + if( nCtrlFlags & 0x0010 ) EXC_CTRLDUMP_COORD2( "picpos" ); + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_HEX4( "bordercolor" ); + if( nCtrlFlags & 0x0100 ) EXC_CTRLDUMP_HEX2( "borderstyle" ); + if( nCtrlFlags & 0x0200 ) EXC_CTRLDUMP_HEX2( "specialeff" ); + if( nCtrlFlags & 0x0400 ) EXC_CTRLDUMP_HEXVAR( nPic, "pic" ); + if( nCtrlFlags & 0x0800 ) EXC_CTRLDUMP_HEX2( "accel" ); + if( nCtrlFlags & 0x1000 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + if( nCtrlFlags & 0x0020 ) EXC_CTRLDUMP_SIZE4( "size" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_IMAGE( nPic, "pic" ); + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + bHasFontData = true; + } + break; + + case EXC_CTRL_SPINBUTTON: + case EXC_CTRL_SCROLLBAR: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000001, "forecolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000010, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000100, "unknown1" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000200, "unknown2" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000400, "unknown3" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000020, "min" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000040, "max" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000080, "value" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000800, "step" ); + EXC_CTRLDUMP_ADDFLAG( 0x00001000, "page-step" ); + EXC_CTRLDUMP_ADDFLAG( 0x00002000, "orient" ); + EXC_CTRLDUMP_ADDFLAG( 0x00004000, "prop-thumb" ); + EXC_CTRLDUMP_ADDFLAG( 0x00008000, "delay" ); + EXC_CTRLDUMP_ADDFLAG( 0x00010000, "icon" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFE0000 ); + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x00000001 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x00000002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x00000004, 0x0000001B ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "opaque" ); + EXC_CTRLDUMP_ADDFLAG( 0x10000000, "autosize" ); + EXC_CTRLDUMP_ENDFLAG( 0xEFFFFFF1 ); + + if( nCtrlFlags & 0x00000010 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); + if( nCtrlFlags & 0x00000020 ) EXC_CTRLDUMP_DEC4( "min" ); + if( nCtrlFlags & 0x00000040 ) EXC_CTRLDUMP_DEC4( "max" ); + if( nCtrlFlags & 0x00000080 ) EXC_CTRLDUMP_DEC4( "value" ); + if( nCtrlFlags & 0x00000100 ) EXC_CTRLDUMP_HEX4( "unknown1" ); + if( nCtrlFlags & 0x00000200 ) EXC_CTRLDUMP_HEX4( "unknown2" ); + if( nCtrlFlags & 0x00000400 ) EXC_CTRLDUMP_HEX4( "unknown3" ); + if( nCtrlFlags & 0x00000800 ) EXC_CTRLDUMP_DEC4( "step" ); + if( nCtrlFlags & 0x00001000 ) EXC_CTRLDUMP_DEC4( "page-step" ); + if( nCtrlFlags & 0x00002000 ) EXC_CTRLDUMP_DEC4( "orient" ); + if( nCtrlFlags & 0x00004000 ) EXC_CTRLDUMP_DEC4( "prop-thumb" ); + if( nCtrlFlags & 0x00008000 ) EXC_CTRLDUMP_DEC4( "delay" ); + if( nCtrlFlags & 0x00010000 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + + if( nCtrlFlags & 0x00000008 ) EXC_CTRLDUMP_SIZE4( "size" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + } + break; + + case EXC_CTRL_IMAGE: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x0004, "autosize" ); + EXC_CTRLDUMP_ADDFLAG( 0x0008, "bordercolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0010, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x0020, "borderstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x0040, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x0080, "picsizemode" ); + EXC_CTRLDUMP_ADDFLAG( 0x0100, "speceffect" ); + EXC_CTRLDUMP_ADDFLAG( 0x0200, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x0400, "pic" ); + EXC_CTRLDUMP_ADDFLAG( 0x0800, "picalign" ); + EXC_CTRLDUMP_ADDFLAG( 0x1000, "pictiling" ); + EXC_CTRLDUMP_ADDFLAG( 0x2000, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x4000, "icon" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFF8003 ); + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_HEX4( "bordercolor" ); + if( nCtrlFlags & 0x0010 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + if( nCtrlFlags & 0x0020 ) EXC_CTRLDUMP_HEX1( "borderstyle" ); + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_DEC1( "picsizemode" ); + if( nCtrlFlags & 0x0100 ) EXC_CTRLDUMP_HEX1( "speceffect" ); + if( nCtrlFlags & 0x0400 ) EXC_CTRLDUMP_HEXVAR( nPic, "pic" ); + if( nCtrlFlags & 0x0800 ) EXC_CTRLDUMP_HEX1( "picalign" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x2000, 0x0000001B ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "opaque" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFFF5 ); + + if( nCtrlFlags & 0x4000 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + + if( nCtrlFlags & 0x0200 ) EXC_CTRLDUMP_SIZE4( "size" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_IMAGE( nPic, "pic" ); + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + } + break; + + case EXC_CTRL_TABSTRIP: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000001, "selected-tab" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "forecolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000010, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000020, "caption-arr-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000040, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000100, "taborientation" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000200, "tabstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000400, "multirow" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000800, "fixed-width" ); + EXC_CTRLDUMP_ADDFLAG( 0x00001000, "fixed-height" ); + EXC_CTRLDUMP_ADDFLAG( 0x00008000, "infotip-arr-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x00020000, "id-arr-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x00040000, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x00080000, "last-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x00200000, "unknown-arr-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x00400000, "tab-count" ); + EXC_CTRLDUMP_ADDFLAG( 0x00800000, "shortcut-arr-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x01000000, "icon" ); + EXC_CTRLDUMP_ENDFLAG( 0xFE116088 ); + sal_uInt32 nCtrlFlags = nFlags; + + sal_uInt32 nTabCount = 0; + sal_uInt32 nIdArrLen = 0; + sal_uInt32 nUnknownArrLen = 0; + sal_uInt32 nShortArrLen = 0; + + if( nCtrlFlags & 0x00000001 ) EXC_CTRLDUMP_DEC4( "selected-tab" ); // size ok? + if( nCtrlFlags & 0x00000002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + if( nCtrlFlags & 0x00000004 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x00000020 ) EXC_CTRLDUMP_HEXVAR( nCaptionLen, "caption-arr-len" ); + if( nCtrlFlags & 0x00000040 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); // size ok? + if( nCtrlFlags & 0x00000100 ) EXC_CTRLDUMP_DEC4( "taborientation" ); // size ok? + if( nCtrlFlags & 0x00000200 ) EXC_CTRLDUMP_DEC4( "tabstyle" ); // size ok? + if( nCtrlFlags & 0x00000800 ) EXC_CTRLDUMP_DEC4( "fixed-width" ); + if( nCtrlFlags & 0x00001000 ) EXC_CTRLDUMP_DEC4( "fixed-height" ); + if( nCtrlFlags & 0x00008000 ) EXC_CTRLDUMP_HEXVAR( nTipLen, "infotip-arr-len" ); + if( nCtrlFlags & 0x00020000 ) EXC_CTRLDUMP_HEXVAR( nIdArrLen, "id-arr-len" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x00040000, 0x0000001B ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFFFD ); + + if( nCtrlFlags & 0x00080000 ) EXC_CTRLDUMP_DEC4( "last-id" ); + if( nCtrlFlags & 0x00200000 ) EXC_CTRLDUMP_HEXVAR( nUnknownArrLen, "unknown-arr-len" ); + if( nCtrlFlags & 0x00400000 ) EXC_CTRLDUMP_DECVAR( nTabCount, "tab-count" ); + if( nCtrlFlags & 0x00800000 ) EXC_CTRLDUMP_HEXVAR( nShortArrLen, "shortcut-arr-len" ); + if( nCtrlFlags & 0x01000000 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + + if( nCtrlFlags & 0x00000010 ) EXC_CTRLDUMP_SIZE4( "size" ); + if( nCtrlFlags & 0x00000020 ) EXC_CTRLDUMP_STRINGARRAY( nCaptionLen, nTabCount, "caption" ); + if( nCtrlFlags & 0x00008000 ) EXC_CTRLDUMP_STRINGARRAY( nTipLen, nTabCount, "infotip" ); + if( nCtrlFlags & 0x00020000 ) EXC_CTRLDUMP_STRINGARRAY( nIdArrLen, nTabCount, "id" ); + if( nCtrlFlags & 0x00200000 ) EXC_CTRLDUMP_STRINGARRAY( nUnknownArrLen, nTabCount, "unknown" ); + if( nCtrlFlags & 0x00800000 ) EXC_CTRLDUMP_STRINGARRAY( nShortArrLen, nTabCount, "shortcut" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + bHasFontData = true; + } + break; + + case EXC_CTRL_USERFORM: + case EXC_CTRL_FRAME: + case EXC_CTRL_MULTIPAGE: + case EXC_CTRL_PAGE: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "backcolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "forecolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "last-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000040, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000080, "borderstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000100, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000200, "scrollbars" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000400, "size" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000800, "scrollsize" ); + EXC_CTRLDUMP_ADDFLAG( 0x00001000, "scrollpos" ); + EXC_CTRLDUMP_ADDFLAG( 0x00008000, "icon" ); + EXC_CTRLDUMP_ADDFLAG( 0x00010000, "cycle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00020000, "speceffect" ); + EXC_CTRLDUMP_ADDFLAG( 0x00040000, "bordercolor" ); + EXC_CTRLDUMP_ADDFLAG( 0x00080000, "caption" ); + EXC_CTRLDUMP_ADDFLAG( 0x00100000, "font" ); + EXC_CTRLDUMP_ADDFLAG( 0x00200000, "pic" ); + EXC_CTRLDUMP_ADDFLAG( 0x00400000, "zoom" ); + EXC_CTRLDUMP_ADDFLAG( 0x00800000, "picalign" ); + EXC_CTRLDUMP_ADDFLAG( 0x01000000, "pictiling" ); + EXC_CTRLDUMP_ADDFLAG( 0x02000000, "picsizemode" ); + EXC_CTRLDUMP_ADDFLAG( 0x04000000, "typeinfover" ); + EXC_CTRLDUMP_ADDFLAG( 0x08000000, "drawbuffer" ); + EXC_CTRLDUMP_ENDFLAG( 0xF0006031 ); + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x00000002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + if( nCtrlFlags & 0x00000004 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x00000008 ) EXC_CTRLDUMP_DEC4( "last-id" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x00000040, 0x00000002 ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFFFD ); + + if( nCtrlFlags & 0x00000080 ) EXC_CTRLDUMP_HEX1( "borderstyle" ); + if( nCtrlFlags & 0x00000100 ) EXC_CTRLDUMP_DEC1( "mouseptr" ); + if( nCtrlFlags & 0x00000200 ) EXC_CTRLDUMP_HEX1( "scrollbars" ); + if( nCtrlFlags & 0x00008000 ) EXC_CTRLDUMP_HEXVAR( nIcon, "icon" ); + if( nCtrlFlags & 0x00010000 ) EXC_CTRLDUMP_DEC1( "cycle" ); + if( nCtrlFlags & 0x00020000 ) EXC_CTRLDUMP_HEX1( "speceffect" ); + if( nCtrlFlags & 0x00040000 ) EXC_CTRLDUMP_HEX4( "bordercolor" ); + if( nCtrlFlags & 0x00080000 ) EXC_CTRLDUMP_DECVARMASK( nCaptionLen, 0x7FFFFFFF, "caption-len" ); + if( nCtrlFlags & 0x00100000 ) EXC_CTRLDUMP_HEXVAR( nFont, "font" ); + if( nCtrlFlags & 0x00200000 ) EXC_CTRLDUMP_HEXVAR( nPic, "pic" ); + if( nCtrlFlags & 0x00400000 ) EXC_CTRLDUMP_DEC4( "zoom" ); + if( nCtrlFlags & 0x00800000 ) EXC_CTRLDUMP_HEX1( "picalign" ); + if( nCtrlFlags & 0x02000000 ) EXC_CTRLDUMP_DEC1( "picsizemode" ); + if( nCtrlFlags & 0x04000000 ) EXC_CTRLDUMP_DEC4( "typeinfover" ); + if( nCtrlFlags & 0x08000000 ) EXC_CTRLDUMP_DEC4( "drawbuffer" ); + + if( nCtrlFlags & 0x00000400 ) EXC_CTRLDUMP_SIZE4( "size" ); + if( nCtrlFlags & 0x00000800 ) EXC_CTRLDUMP_SIZE4( "scrollsize" ); + if( nCtrlFlags & 0x00001000 ) EXC_CTRLDUMP_COORD4( "scrollpos" ); + if( nCtrlFlags & 0x00080000 ) EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + EXC_CTRLDUMP_FONT( nFont, "font" ); + EXC_CTRLDUMP_IMAGE( nIcon, "icon" ); + EXC_CTRLDUMP_IMAGE( nPic, "pic" ); + } + break; + + case EXC_CTRL_FONTDATA: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x01, "font-name" ); + EXC_CTRLDUMP_ADDFLAG( 0x02, "font-style" ); + EXC_CTRLDUMP_ADDFLAG( 0x04, "font-size" ); + EXC_CTRLDUMP_ADDFLAG( 0x10, "language-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x40, "align" ); + EXC_CTRLDUMP_ADDFLAG( 0x80, "font-weight" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFF08 ); // 0x20 always set? + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_DECVARMASK( nNameLen, 0x7FFFFFFF, "font-name-len" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "font-style-flags", nCtrlFlags & 0x0002, 0x40000000 ); + EXC_CTRLDUMP_ADDFLAG( 0x0001, "bold" ); + EXC_CTRLDUMP_ADDFLAG( 0x0002, "italic" ); + EXC_CTRLDUMP_ADDFLAG( 0x0004, "underline" ); + EXC_CTRLDUMP_ADDFLAG( 0x0008, "strikeout" ); + EXC_CTRLDUMP_ADDFLAG( 0x2000, "sunken" ); + EXC_CTRLDUMP_ENDFLAG( 0xBFFFDFF0 ); // 0x40000000 always set? + + if( nCtrlFlags & 0x0004 ) EXC_CTRLDUMP_DEC4( "font-size" ); + if( nCtrlFlags & 0x0010 ) EXC_CTRLDUMP_HEX2( "language-id" ); + if( nCtrlFlags & 0x0040 ) + { + EXC_CTRLDUMP_ALIGN_INSTRM( 2 ); + sal_uInt16 nAlign; rInStrm >> nAlign; + t += " align="; lclAppendDec( t, nAlign ); + switch( nAlign ) + { + case 1: t += "=left"; break; + case 2: t += "=right"; break; + case 3: t += "=center"; break; + default: t += "=!unknown!"; + } + EXC_CTRLDUMP_PRINT(); + } + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_DEC2( "font-weight" ); + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_STRING( nNameLen, "font-name" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + } + break; + + case EXC_CTRL_ADDDATA: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x0001, "guid1" ); + EXC_CTRLDUMP_ADDFLAG( 0x0002, "guid2" ); + EXC_CTRLDUMP_ADDFLAG( 0x0008, "guid4" ); + EXC_CTRLDUMP_ADDFLAG( 0x0040, "unknown1" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFFB4 ); + sal_uInt32 nCtrlFlags = nFlags; + + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_HEX4( "unknown1" ); + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_GUID( "guid1" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_GUID( "guid2" ); + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_GUID( "guid4" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + } + break; + + case EXC_CTRL_FRAMECHILD: + { + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x0001, "name-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x0002, "tag-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x0004, "storage-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x0008, "helpcontext-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x0010, "option" ); + EXC_CTRLDUMP_ADDFLAG( 0x0020, "substream-len" ); + EXC_CTRLDUMP_ADDFLAG( 0x0040, "tabpos" ); + EXC_CTRLDUMP_ADDFLAG( 0x0080, "type" ); + EXC_CTRLDUMP_ADDFLAG( 0x0100, "pos" ); + EXC_CTRLDUMP_ADDFLAG( 0x0800, "tiptext" ); + EXC_CTRLDUMP_ADDFLAG( 0x1000, "ctrl-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x2000, "ctrl-source" ); + EXC_CTRLDUMP_ADDFLAG( 0x4000, "row-source" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFF8600 ); + sal_uInt32 nCtrlFlags = nFlags; + + sal_uInt32 nStorageId = 0; + sal_uInt32 nSubStrmLen = 0; + sal_uInt16 nChildType = EXC_CTRL_UNKNOWN; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_DECVARMASK( nNameLen, 0x7FFFFFFF, "name-len" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_DECVARMASK( nTagLen, 0x7FFFFFFF, "tag-len" ); + if( nCtrlFlags & 0x0004 ) EXC_CTRLDUMP_PLAIN_DECVAR( nStorageId, "storage-id" ); + if( nCtrlFlags & 0x0008 ) EXC_CTRLDUMP_PLAIN_DEC4( "helpcontext-id" ); + + EXC_CTRLDUMP_STARTOPTFLAG( "option-flags", nCtrlFlags & 0x0010, 0x00000033 ); + EXC_CTRLDUMP_ADDFLAG( 0x00000001, "tabstop" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "visible" ); + EXC_CTRLDUMP_ADDFLAG( 0x00040000, "container" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFBFFFC ); + + if( nCtrlFlags & 0x0020 ) EXC_CTRLDUMP_HEXVAR( nSubStrmLen, "substream-len" ); + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_DEC2( "tabpos" ); + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_CTRLTYPE( nChildType, "type" ); + if( nCtrlFlags & 0x0800 ) EXC_CTRLDUMP_DECVARMASK( nTipLen, 0x7FFFFFFF, "infotip-len" ); + if( nCtrlFlags & 0x1000 ) EXC_CTRLDUMP_DECVARMASK( nCtrlIdLen, 0x7FFFFFFF, "ctrl-id-len" ); + if( nCtrlFlags & 0x2000 ) EXC_CTRLDUMP_DECVARMASK( nCtrlSrcLen, 0x7FFFFFFF, "ctrl-source-len" ); + if( nCtrlFlags & 0x4000 ) EXC_CTRLDUMP_DECVARMASK( nRowSrcLen, 0x7FFFFFFF, "row-source-len" ); + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_STRING( nNameLen, "name" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_STRING( nTagLen, "tag" ); + if( nCtrlFlags & 0x0100 ) EXC_CTRLDUMP_COORD4( "pos" ); + if( nCtrlFlags & 0x0800 ) EXC_CTRLDUMP_STRING( nTipLen, "infotip" ); + if( nCtrlFlags & 0x1000 ) EXC_CTRLDUMP_STRING( nCtrlIdLen, "ctrl-id" ); + if( nCtrlFlags & 0x2000 ) EXC_CTRLDUMP_STRING( nCtrlSrcLen, "ctrl-source" ); + if( nCtrlFlags & 0x4000 ) EXC_CTRLDUMP_STRING( nRowSrcLen, "row-source" ); + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + + if( (nCtrlFlags & 0x0080) && (nChildType != EXC_CTRL_UNKNOWN) ) + { + if( (nFlags & 0x00040000) && (nStorageId > 0) ) + maCtrlStorages.push_back( XclDumpCtrlPortion( nStorageId, nChildType ) ); + if( (nCtrlFlags & 0x0020) && (nSubStrmLen > 0) ) + maCtrlPortions.push_back( XclDumpCtrlPortion( nSubStrmLen, nChildType ) ); + } + } + break; + + default: + EXC_CTRLDUMP_REMAINING( nStartPos + nSize ); + } + + // font data + if( bHasFontData ) + DumpControlContents( rInStrm, EXC_CTRL_FONTDATA ); + } +} + +// ============================================================================ +// +// S T R E A M S +// +// ============================================================================ + +void Biff8RecDumper::DumpBinaryStream( SotStorageRef xStrg, const String& rStrmName, const String& rStrgPath ) +{ + SotStorageStreamRef xInStrm = OpenStream( xStrg, rStrmName ); + if( !xInStrm || !pDumpStream ) return; + + XclDumpStreamHeader aStrmHeader( *xInStrm, *pDumpStream, rStrmName, rStrgPath ); + DumpBinary( *xInStrm ); + (*pDumpStream) << "\n"; +} + +void Biff8RecDumper::DumpTextStream( SotStorageRef xStrg, const String& rStrmName, const String& rStrgPath ) +{ + SotStorageStreamRef xInStrm = OpenStream( xStrg, rStrmName ); + if( !xInStrm || !pDumpStream ) return; + + XclDumpStreamHeader aStrmHeader( *xInStrm, *pDumpStream, rStrmName, rStrgPath ); + while( xInStrm->Tell() < aStrmHeader.GetStreamLen() ) + { + ByteString aLine; + xInStrm->ReadLine( aLine ); + lclDumpString( *pDumpStream, aLine ); + (*pDumpStream) << "\n"; + } + (*pDumpStream) << "\n"; +} + +void Biff8RecDumper::DumpRecordStream( SotStorageRef xStrg, const String& rStrmName, const String& rStrgPath ) +{ + SotStorageStreamRef xInStrm = OpenStream( xStrg, rStrmName ); + if( !xInStrm || !pDumpStream ) return; + + XclDumpStreamHeader aStrmHeader( *xInStrm, *pDumpStream, rStrmName, rStrgPath ); + + XclImpStream* pOldStream = pIn; + pIn = new XclImpStream( *xInStrm, GetRoot() ); + XclImpStream& rIn = *pIn; + if( pOldStream ) + rIn.CopyDecrypterFrom( *pOldStream ); + + // -- dump from here -- + UINT16 nId; + BOOL bLoop = TRUE; + + while( bLoop && rIn.StartNextRecord() ) + { + nId = rIn.GetRecId(); + if( HasModeDump( nId ) ) + RecDump( TRUE ); + + bLoop = (nId != 0x000A); + } + + delete pIn; + pIn = pOldStream; +} + +void Biff8RecDumper::DumpCtlsStream() +{ + SotStorageStreamRef xInStrm = OpenStream( EXC_STREAM_CTLS ); + if( !xInStrm || !pDumpStream ) return; + + SvStream& rInStrm = *xInStrm; + SvStream& rOutStrm = *pDumpStream; + XclDumpStreamHeader aStrmHeader( rInStrm, rOutStrm, EXC_STREAM_CTLS, EMPTY_STRING ); + + for( StrmPortionMap::const_iterator aIt = maCtlsPosMap.begin(), aEnd = maCtlsPosMap.end(); aIt != aEnd; ++aIt ) + { + ULONG nCtrlPos = static_cast< ULONG >( aIt->first ); + ULONG nCtrlEnd = nCtrlPos + static_cast< ULONG >( aIt->second ); + if( nCtrlEnd <= aStrmHeader.GetStreamLen() ) + { + // stream position + ULONG nStartPos = nCtrlPos; // for stream alignment macro + rInStrm.Seek( nStartPos ); + + ByteString t( "\npos=" ); __AddHex( t, aIt->first ); + t.Append( " len=" ); __AddHex( t, aIt->second ); + rOutStrm << t.GetBuffer() << " "; + + // control type + sal_uInt16 nCtrlType = lclDumpControlGuid( rInStrm, rOutStrm ); + rOutStrm << "\n"; + + // control contents + if( nCtrlType != EXC_CTRL_UNKNOWN ) + DumpControlContents( rInStrm, nCtrlType ); + + // remaining unknown data + EXC_CTRLDUMP_REMAINING( nCtrlEnd ); + rOutStrm << "\n"; + } + } +} + +void Biff8RecDumper::DumpControlFrameStream( SotStorageRef xInStrg, sal_uInt16 nCtrlType, const String& rStrgPath ) +{ + static const String saStrmName( sal_Unicode( 'f' ) ); + + SotStorageStreamRef xInStrm = OpenStream( xInStrg, saStrmName ); + if( !xInStrm || !pDumpStream ) return; + + SvStream& rInStrm = *xInStrm; + SvStream& rOutStrm = *pDumpStream; + XclDumpStreamHeader aStrmHeader( rInStrm, rOutStrm, saStrmName, rStrgPath ); + + if( aStrmHeader.GetStreamLen() > 0 ) + { + ByteString t; // "t" needed for macros + + rOutStrm << "header-record\n"; + DumpControlContents( rInStrm, nCtrlType ); + rOutStrm << "\n"; + + if( nCtrlType == EXC_CTRL_USERFORM ) + { + rOutStrm << "add-records\n"; + sal_uInt16 nAddCount; + EXC_CTRLDUMP_PLAIN_DECVAR( nAddCount, "count" ); + EXC_CTRLDUMP_PRINT(); + rOutStrm << "\n"; + + for( sal_uInt16 nAdd = 0; (nAdd < nAddCount) && (rInStrm.Tell() < aStrmHeader.GetStreamLen()); ++nAdd ) + { + DumpControlContents( rInStrm, EXC_CTRL_ADDDATA ); + rOutStrm << "\n"; + } + } + + rOutStrm << "children-records\n"; + sal_uInt32 nRecCount, nTotalSize; + EXC_CTRLDUMP_PLAIN_DECVAR( nRecCount, "count" ); + EXC_CTRLDUMP_PLAIN_HEXVAR( nTotalSize, "total-size" ); + if( nTotalSize > 0 ) + { + EXC_CTRLDUMP_PLAIN_HEX4( "header-unknown" ); + rOutStrm << "\n"; + + for( sal_uInt32 nRec = 0; (nRec < nRecCount) && (rInStrm.Tell() < aStrmHeader.GetStreamLen()); ++nRec ) + { + DumpControlContents( rInStrm, EXC_CTRL_FRAMECHILD ); + rOutStrm << "\n"; + } + } + else + rOutStrm << "\n"; + + if( rInStrm.Tell() < aStrmHeader.GetStreamLen() ) + { + rOutStrm << "remaining=\n"; + DumpBinary( rInStrm ); + rOutStrm << "\n"; + } + } +} + +void Biff8RecDumper::DumpControlObjectsStream( SotStorageRef xInStrg, const String& rStrgPath ) +{ + static const String saStrmName( sal_Unicode( 'o' ) ); + + SotStorageStreamRef xInStrm = OpenStream( xInStrg, saStrmName ); + if( !xInStrm || !pDumpStream ) return; + + SvStream& rInStrm = *xInStrm; + SvStream& rOutStrm = *pDumpStream; + XclDumpStreamHeader aStrmHeader( rInStrm, rOutStrm, saStrmName, rStrgPath ); + + if( aStrmHeader.GetStreamLen() > 0 ) + { + ULONG nStrmPos = 0; + for( XclDumpCtrlPortionVec::const_iterator aIt = maCtrlPortions.begin(), aEnd = maCtrlPortions.end(); aIt != aEnd; ++aIt ) + { + rInStrm.Seek( nStrmPos ); + DumpControlContents( rInStrm, aIt->second ); + rOutStrm << "\n"; + nStrmPos += aIt->first; + } + + if( rInStrm.Tell() < aStrmHeader.GetStreamLen() ) + { + rOutStrm << "remaining=\n"; + DumpBinary( rInStrm ); + rOutStrm << "\n"; + } + } +} + +// ============================================================================ +// +// S T O R A G E S +// +// ============================================================================ + +void Biff8RecDumper::DumpAnyStorage( SotStorageRef xParentStrg, const String& rStrgName, const String& rStrgPath ) +{ + SotStorageRef xInStrg = OpenStorage( xParentStrg, rStrgName ); + if( !xInStrg || !pDumpStream ) return; + + XclDumpStorageHeader aStrgHeader( *xInStrg, *pDumpStream, rStrgPath ); +} + +void Biff8RecDumper::DumpUserFormStorage( SotStorageRef xParentStrg, const String& rStrgName, sal_uInt16 nCtrlType, const String& rStrgPath ) +{ + SotStorageRef xInStrg = OpenStorage( xParentStrg, rStrgName ); + if( !xInStrg || !pDumpStream ) return; + + XclDumpStorageHeader aStrgHeader( *xInStrg, *pDumpStream, rStrgPath ); + + // streams + maCtrlStorages.clear(); + maCtrlPortions.clear(); + DumpControlFrameStream( xInStrg, nCtrlType, rStrgPath ); + DumpControlObjectsStream( xInStrg, rStrgPath ); + DumpTextStream( xInStrg, CREATE_STRING( "\003VBFrame" ), rStrgPath ); + + // frame substorages + XclDumpCtrlPortionVec aCtrlStorages( maCtrlStorages ); // make local copy, maCtrlStorages is reused in loop + for( XclDumpCtrlPortionVec::const_iterator aIt = aCtrlStorages.begin(), aEnd = aCtrlStorages.end(); aIt != aEnd; ++aIt ) + { + sal_uInt32 nStorageId = aIt->first; + String aSubName( sal_Unicode( 'i' ) ); + if( nStorageId < 10 ) + aSubName.Append( sal_Unicode( '0' ) ); + aSubName.Append( String::CreateFromInt32( static_cast< sal_Int32 >( nStorageId ) ) ); + + String aPath( rStrgPath ); + aPath.Append( sal_Unicode( '/' ) ).Append( rStrgName ); + + DumpUserFormStorage( xInStrg, aSubName, aIt->second, aPath ); + } +} + +void Biff8RecDumper::DumpVbaProjectStorage() +{ + SotStorageRef xInStrg = OpenStorage( EXC_STORAGE_VBA_PROJECT ); + if( !xInStrg || !pDumpStream ) return; + + XclDumpStorageHeader aStrgHeader( *xInStrg, *pDumpStream, EMPTY_STRING ); + // PROJECT substream + DumpTextStream( xInStrg, CREATE_STRING( "PROJECT" ), EXC_STORAGE_VBA_PROJECT ); + // VBA storage + DumpAnyStorage( xInStrg, EXC_STORAGE_VBA, EXC_STORAGE_VBA_PROJECT ); + // user forms + SvStorageInfoList aInfoList; + xInStrg->FillInfoList( &aInfoList ); + for( ULONG nInfo = 0; nInfo < aInfoList.Count(); ++nInfo ) + { + SvStorageInfo& rInfo = aInfoList.GetObject( nInfo ); + if( rInfo.IsStorage() && (rInfo.GetName() != EXC_STORAGE_VBA) ) + DumpUserFormStorage( xInStrg, rInfo.GetName(), EXC_CTRL_USERFORM, EXC_STORAGE_VBA_PROJECT ); + } +} + +// ============================================================================ +// +// ============================================================================ + +const sal_Char* Biff8RecDumper::GetBlanks( const UINT16 nNumOfBlanks ) +{ + DBG_ASSERT( pBlankLine, "-Biff8RecDumper::GetBlanks(): nicht so schnell mein Freund!" ); + DBG_ASSERT( nNumOfBlanks <= nLenBlankLine, + "+Biff8RecDumper::GetBlanks(): So viel kannst Du nicht von mir verlangen!" ); + + return pBlankLine + ( ( nNumOfBlanks <= nLenBlankLine )? ( nLenBlankLine - nNumOfBlanks ) : 0 ); +} + + +BOOL Biff8RecDumper::IsLineEnd( const sal_Char c, sal_Char& rNext, SvStream& rIn, INT32& rLeft ) +{ + static const sal_Char cNL = '\n'; + static const sal_Char cRET = '\r'; + + if( IsEndOfLine( c ) ) + { + sal_Char cDouble = ( c == cNL )? cRET : cNL; + + if( rNext == cDouble ) + { + rIn >> rNext; + rLeft--; + } + + return TRUE; + } + else + return FALSE; +} + + +_KEYWORD Biff8RecDumper::GetKeyType( const ByteString& r ) +{ + ByteString t( r ); + _KEYWORD e; + + t.ToUpperAscii(); + + if( t == "SKIPDUMP" ) + e = Skipdump; + else if( t == "SKIPOFFSET" ) + e = SkipOffset; + else if( t == "READCONTRECS" ) + e = ReadContRecs; + else if( t == "NOWARNINGS" ) + e = NoWarnings; + else if( t == "CONTLOAD" ) + e = Contload; + else if( t == "BLANKLINE" ) + e = BlankLine; + else if( t == "EXPORTBOOKSTREAM" ) + e = ExportBookStream; + else if( t == "PARSEP" ) + e = Parsep; + else if( t == "MAXBODYLINES" ) + e = Maxbodylines; + else if( t == "INCLUDE" || t == "+" ) + e = Include; + else if( t == "EXCLUDE" || t == "-" ) + e = Exclude; + else if( t == "HEX" || t == "H" ) + e = Hex; + else if( t == "BODY" || t == "B" ) + e = Body; + else if( t == "NAMEONLY" || t =="N" ) + e = NameOnly; + else if( t == "COMMENT" ) + e = Comment; + else if( t == "OUTPUT" ) + e = Output; + else if( t == "TITLE" ) + e = Title; + else if( t == "CLEARFILE" ) + e = ClearFile; + else + e = KW_Unknown; + + return e; +} + + +void Biff8RecDumper::Init( void ) +{ + bClearFile = FALSE; + + if( pDumpModes || ppRecNames ) + return; + + const sal_Char* pDefName = "biffrecdumper.ini"; + const sal_Char* pIniKey = "BIFFRECDUMPERINI"; + const sal_Char pPathSep[] = { SAL_PATHDELIMITER, '\0' }; + ByteString aIniName; + + SvFileStream* pIn = NULL; + + // first try: search for biffrecdumper.ini in dir, specified in %HOME% + const sal_Char* pHome = getenv( "HOME" ); + if( pHome ) + { + aIniName = pHome; + aIniName.EraseTrailingChars( *pPathSep ); + aIniName += pPathSep; + aIniName += pDefName; + + pIn = CreateInStream( aIniName.GetBuffer() ); + } + + if( !pIn ) + { // %HOME% not set or %HOME%\biffrecdumper.ini could not be opened + const sal_Char* pIni = getenv( pIniKey ); + if( pIni ) + { + pIn = CreateInStream( pIni ); + if( !pIn ) + { + AddError( 0, "Could not open ini file", ByteString( pIni ) ); + bEndLoading = TRUE; // zur Sicherheit.... + } + } + } + + if( pIn ) + { + pIn->Seek( STREAM_SEEK_TO_END ); + + const UINT32 nStreamLen = pIn->Tell(); + + if( nStreamLen <= 1 ) + { + pIn->Close(); + delete pIn; + return; + } + + pIn->Seek( STREAM_SEEK_TO_BEGIN ); + + pDumpModes = new UINT16[ nRecCnt ]; + ppRecNames = new ByteString*[ nRecCnt ]; + + memset( pDumpModes, 0x00, sizeof( UINT16 ) * nRecCnt ); + memset( ppRecNames, 0x00, sizeof( ByteString* )* nRecCnt ); + + enum STATE { PreLine, InCommand, PostCommand, InId, PostEqu, + InVal, InName, InInExClude, InBodyMode, PostSepIEC, + PostSepBM, InComment }; + + STATE eAct = PreLine; + sal_Char c; + sal_Char cNext; + INT32 n = ( INT32 ) nStreamLen; + ByteString aCommand; + ByteString aVal; + ByteString aInExClude; + ByteString aHexBody; + UINT32 nLine = 1; + BOOL bCommand = FALSE; + + *pIn >> c >> cNext; + + while( n > 0 ) + { + n--; + + switch( eAct ) + { + case PreLine: + if( IsAlphaNum( c ) ) + { + if( IsNum( c ) ) + { + eAct = InId; + bCommand = FALSE; + } + else + { + eAct = InCommand; + bCommand = TRUE; + } + aCommand.Erase(); + aCommand += c; + } + else if( c == cComm1 && cNext == cComm2 ) + eAct = InComment; + else if( IsLineEnd( c, cNext, *pIn, n ) ) + nLine++; + else if( !IsBlank( c ) ) + { + AddError( nLine, "Unexpected command or id" ); + n = 0; + } + break; + case InCommand: + if( c == '=' ) + { + eAct = PostEqu; + aVal.Erase(); + } + else if( IsAlpha( c ) ) + aCommand += c; + else if( IsBlank( c ) ) + eAct = PostCommand; + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecCommand( nLine, aCommand ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecCommand( nLine, aCommand ) ) + eAct = InComment; + else + { + AddError( nLine, "Invalid command before comment", aCommand ); + n = 0; + } + } + else + { + aCommand += '>'; + aCommand += c; + aCommand += '<'; + AddError( nLine, "Invalid character in command or id", aCommand ); + n = 0; + } + break; + case PostCommand: + if( c == '=' ) + { + eAct = PostEqu; + aVal.Erase(); + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecCommand( nLine, aCommand ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecCommand( nLine, aCommand ) ) + eAct = InComment; + else + { + AddError( nLine, "Invalid command before comment", aCommand ); + n = 0; + } + } + else if( !IsBlank( c ) ) + { + AddError( nLine, "Expecting blank or \'=\' following the command", aCommand ); + n = 0; + } + break; + case InId: + if( c == '=' ) + { + eAct = PostEqu; + aVal.Erase(); + } + else if( IsAlphaNum( c ) ) + aCommand += c; + else if( IsBlank( c ) ) + eAct = PostCommand; + else if( ( c == cComm1 && cNext == cComm2 ) || IsLineEnd( c, cNext, *pIn, n ) ) + { + AddError( nLine, "Unexpected end of record id", aCommand ); + eAct = InComment; + } + else + { + AddError( nLine, "Unexpected sal_Char in record id", aCommand ); + n = 0; + } + break; + case PostEqu: + if( bCommand ) + { // Command + if( c == cComm1 && cNext == cComm2 ) + { + if( ExecCommand( nLine, aCommand ) ) + eAct = InComment; + else + { + AddError( nLine, "Unknown command", aCommand ); + n = 0; + } + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecCommand( nLine, aCommand ) ) + { + eAct = PreLine; + nLine++; + } + else + { + AddError( nLine, "Unknown command", aCommand ); + n = 0; + } + } + else if( !bCommand && c == cParSep ) + eAct = PostSepIEC; + else if( !IsBlank( c ) ) + { + aVal.Erase(); + aVal += c; + eAct = InVal; + } + } + else + { // Set + if( ( c == cComm1 && cNext == cComm2 ) || IsLineEnd( c, cNext, *pIn, n ) ) + { + AddError( nLine, "No mode set for record", aCommand ); + n = 0; + } + else if( !bCommand && c == cParSep ) + eAct = PostSepIEC; + else + { + aVal.Erase(); + aVal += c; + eAct = InName; + aInExClude.Erase(); + aHexBody.Erase(); + } + } + break; + case InVal: + if( c == cComm1 && cNext == cComm2 ) + { + if( ExecCommand( nLine, aCommand, &aVal ) ) + eAct = InComment; + else + { + AddError( nLine, "Unknown command", aCommand ); + n = 0; + } + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecCommand( nLine, aCommand, &aVal ) ) + { + eAct = PreLine; + nLine++; + } + else + { + AddError( nLine, "Unknown command", aCommand ); + n = 0; + } + } + else + aVal += c; + break; + case InName: + if( c == cParSep ) + eAct = PostSepIEC; + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecSetVal( nLine, aCommand, &aVal, NULL, NULL ) ) + eAct = InComment; + else + n = 0; + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecSetVal( nLine, aCommand, &aVal, NULL, NULL ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else + aVal += c; + break; + case InInExClude: + if( c == cParSep ) + eAct = PostSepBM; + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecSetVal( nLine, aCommand, &aVal, &aInExClude, NULL ) ) + eAct = InComment; + else + n = 0; + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecSetVal( nLine, aCommand, &aVal, &aInExClude, NULL ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else + aInExClude += c; + break; + case InBodyMode: + if( c == cParSep ) + { + AddError( nLine, "Only 3 parameter possible" ); + n = 0; + } + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecSetVal( nLine, aCommand, &aVal, &aInExClude, &aHexBody ) ) + eAct = InComment; + else + n = 0; + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecSetVal( nLine, aCommand, &aVal, &aInExClude, &aHexBody ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else + aInExClude += c; + break; + case PostSepIEC: + if( c == cParSep ) + eAct = PostSepBM; + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecSetVal( nLine, aCommand, &aVal, NULL, NULL ) ) + eAct = InComment; + else + n = 0; + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecSetVal( nLine, aCommand, &aVal, NULL, NULL ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else if( !IsBlank( c ) ) + { + aInExClude += c; + eAct = InInExClude; + } + break; + case PostSepBM: + if( c == cParSep ) + eAct = PostSepBM; + else if( c == cComm1 && cNext == cComm2 ) + { + if( ExecSetVal( nLine, aCommand, &aVal, &aInExClude, NULL ) ) + eAct = InComment; + else + n = 0; + } + else if( IsLineEnd( c, cNext, *pIn, n ) ) + { + if( ExecSetVal( nLine, aCommand, &aVal, &aInExClude, NULL ) ) + { + eAct = PreLine; + nLine++; + } + else + n = 0; + } + else if( !IsBlank( c ) ) + { + aHexBody += c; + eAct = InBodyMode; + } + break; + case InComment: + if( IsLineEnd( c, cNext, *pIn, n ) ) + { + eAct = PreLine; + nLine++; + } + break; + default: + n = 0; + } + + c = cNext; + *pIn >> cNext; + } + + pIn->Close(); + delete pIn; + } +} + + +BOOL Biff8RecDumper::ExecCommand( const UINT32 nL, const ByteString& r, const ByteString* pVal ) +{ + _KEYWORD e = GetKeyType( r ); + BOOL b = TRUE; + const UINT32 nValLen = ( pVal )? pVal->Len() : 0; + BOOL bSet; + UINT16 nMode; + + switch( e ) + { + case Skipdump: bSkip = TRUE; break; + case SkipOffset: bSkipOffset = TRUE; break; + case ReadContRecs: bReadContRecs = TRUE; break; + case NoWarnings: bWarnings = FALSE; break; + case Contload: bEndLoading = TRUE; break; + case BlankLine: bBlankLine = TRUE; break; + case ExportBookStream: bExportBookStream = TRUE; break; + case Parsep: + if( nValLen == 0 ) + { + AddError( nL, "No separator found" ); + b = FALSE; + } + else if( nValLen == 1 ) + cParSep = *( pVal->GetBuffer() ); + else + { + AddError( nL, "More than 1 sal_Char is not valid for separator", *pVal ); + b = FALSE; + } + break; + case Maxbodylines: + if( nValLen ) + { + UINT32 n = GetVal( *pVal ); + + if( n == 0xFFFFFFFF ) + { + AddError( nL, "Syntax error in value of body lines" ); + b = FALSE; + } + else + nMaxBodyLines = n; + } + else + { + AddError( nL, "No value specified for number of body lines" ); + b = FALSE; + } + break; + case Include: + bSet = FALSE; + nMode = MODE_SKIP; + goto _common; + case Exclude: + bSet = TRUE; + nMode = MODE_SKIP; + goto _common; + case Hex: + bSet = TRUE; + nMode = MODE_HEX; + goto _common; + case Body: + bSet = FALSE; + nMode = MODE_HEX; + goto _common; + case NameOnly: + bSet = TRUE; + nMode = MODE_NAMEONLY; + goto _common; +_common: + if( pVal ) + { + IdRangeList aRL; + if( FillIdRangeList( nL, aRL, *pVal ) ) + { + const IdRange* p = aRL.First(); + if( bSet ) + { + while( p ) + { SetFlag( p->nFirst, p->nLast, nMode ); p = aRL.Next(); } + } + else + { + while( p ) + { ClrFlag( p->nFirst, p->nLast, nMode ); p = aRL.Next(); } + } + } + else + b = FALSE; + } + break; + case Comment: + if( pVal && pVal->Len() >= 2 ) + { + cComm1 = pVal->GetChar( 0 ); + cComm2 = pVal->GetChar( 1 ); + } + break; + case Output: + CopyStrpOnStrp( pOutName, pVal ); + if( pOutName ) + { + if( *pOutName == "*" ) + { + ByteString aDefault( "DefaultDumpName.txt" ); + SfxObjectShell* pShell = GetDocShell(); + if( pShell ) + { + SfxMedium* pMedium = pShell->GetMedium(); + if( pMedium ) + { + const ByteString aTextExtension( ".txt" ); + aDefault = GETSTR( pMedium->GetPhysicalName() ); + xub_StrLen nStrLen = aDefault.Len(); + if( nStrLen >= 4 ) + { + ByteString aTmp( aDefault ); + aTmp.ToLowerAscii(); + if( aTmp.Copy( nStrLen -4 ) == ".xls" ) + aDefault.Replace( nStrLen - 4, aTextExtension.Len(), aTextExtension ); + else + aDefault += aTextExtension; + } + else + aDefault += aTextExtension; + } + } + + *pOutName = aDefault; + } + CreateOutStream(); + } + else if( pDumpStream ) + { + pDumpStream->Close(); + DELANDNULL( pDumpStream ); + } + break; + case Title: + CopyStrpOnStrp( pTitle, pVal ); + break; + case ClearFile: + bClearFile = TRUE; + break; + default: + AddError( nL, "Unknown command", r ); + b = FALSE; + } + + return b; +} + + +BOOL Biff8RecDumper::ExecSetVal( const UINT32 nL, const ByteString& rId, const ByteString* pName, + const ByteString* pIEC, const ByteString* pHB ) +{ + UINT32 _nId = GetVal( rId ); + + if( _nId == 0xFFFFFFFF ) + { + AddError( nL, "Syntax error in record id", rId ); + return FALSE; + } + else if( _nId >= ( UINT32 ) nRecCnt ) + { + AddError( nL, "Record id to high", rId ); + return FALSE; + } + + UINT16 nId = ( UINT16 ) _nId; + + if( pName && pName->Len() ) + SetName( nId, *pName ); + + _KEYWORD e; + UINT16 n = GetMode( nId ); + + if( pIEC && pIEC->Len() ) + { + e = GetKeyType( *pIEC ); + + if( e == Include ) + n &= ~MODE_SKIP; + else if( e == Exclude ) + n |= MODE_SKIP; + else + { + AddError( nL, "Invalid key for in-/exclude", *pIEC ); + return FALSE; + } + } + + if( pHB && pHB->Len() ) + { + e = GetKeyType( *pHB ); + + if( e == NameOnly ) + n |= MODE_NAMEONLY; + else + { + n &= ~MODE_NAMEONLY; + if( e == Hex ) + n |= MODE_HEX; + else if( e == Body ) + n &= ~MODE_HEX; + else + { + AddError( nL, "Invalid key for hex/body/name only", *pIEC ); + return FALSE; + } + } + } + + SetMode( nId, n ); + return TRUE; +} + + +void Biff8RecDumper::SetFlag( const UINT16 nF, const UINT16 nL, const UINT16 nFl ) +{ + UINT16 n = ( nF < nL )? nF : nL; + UINT16 nLast = ( nF < nL )? nL : nF; + + if( nLast >= nRecCnt ) + nLast = nRecCnt - 1; + + while( n <= nLast ) + { + pDumpModes[ n ] |= nFl; + n++; + } +} + + +void Biff8RecDumper::ClrFlag( const UINT16 nF, const UINT16 nL, const UINT16 nFlags ) +{ + UINT16 n = ( nF < nL )? nF : nL; + UINT16 nLast = ( nF < nL )? nL : nF; + UINT16 nFl = ~nFlags; + + if( nLast >= nRecCnt ) + nLast = nRecCnt - 1; + + while( n <= nLast ) + { + pDumpModes[ n ] &= nFl; + n++; + } +} + + +void Biff8RecDumper::SetName( const UINT16 n, ByteString* p ) +{ + if( n < nRecCnt ) + CopyStrpOnStrp( ppRecNames[ n ], p ); +} + + +UINT32 Biff8RecDumper::GetVal( const ByteString& r ) +{ + const sal_Char* p = r.GetBuffer(); + sal_Char c = *p; + UINT32 n = 0; + const UINT32 nLimitDec = 0xFFFFFFFF / 10; + const UINT32 nLimitHex = 0xFFFFFFFF / 16; + BOOL bError = FALSE; + + enum STATE { First, Dec, MaybeHex, Hex }; + + STATE e = First; + + while( c ) + { + switch( e ) + { + case First: + if( IsNum( c ) ) + { + if( c == '0' ) + e = MaybeHex; + else + { + e = Dec; + n = GetVal( c ); + } + } + else + bError = TRUE; + break; + case Dec: + if( n < nLimitDec && IsNum( c ) ) + { + n *= 10; + n += GetVal( c ); + } + else + bError = TRUE; + break; + case MaybeHex: + if( c == 'x' || c == 'X' ) + { + e = Hex; + n = 0; + } + else if( IsNum( c ) ) + { + n = GetVal( c ); + e = Dec; + } + else + bError = TRUE; + break; + case Hex: + if( n < nLimitHex && IsHex( c ) ) + { + n *= 16; + n += GetVal( c ); + } + else + bError = TRUE; + break; + } + + if( bError ) + c = 0x00; + else + { + p++; + c = *p; + } + } + + if( bError ) + return 0xFFFFFFFF; + else + return n; +} + + +BOOL Biff8RecDumper::FillIdRangeList( const UINT32 nL, IdRangeList& rRL, const ByteString& rV ) +{ + rRL.Clear(); + + const sal_Char* pSyntErr = "Syntax error in number (list)"; + +#define SYNTERR(ch) AddError( ((UINT32)(b=FALSE))+nL, pSyntErr, ch? ((((t+=">")+=ByteString::CreateFromInt32(ch))+="<")) : t ) +#define NEWVAL(_n) _n=(n>=(UINT32)nRecCnt)?nRecCnt-1:(UINT16)n +#define ORDERN() {if(n1>n2){UINT16 nT=n1;n1=n2;n2=nT;}} + + const sal_Char* p = rV.GetBuffer(); + sal_Char c = *p; + const sal_Char cSep = cParSep; + const sal_Char cCont = '.'; + const sal_Char cAll = '*'; + ByteString t; + UINT16 n1 = 0, n2 = 0; + UINT32 n; + BOOL b = TRUE; + BOOL bExp2 = FALSE; + + enum STATE { PreFirst, InFirst, PostFirst, InCont, PreLast, InLast, PostLast }; + STATE e = PreFirst; + + while( c ) + { + switch( e ) + { + case PreFirst: + if( IsAlphaNum( c ) ) + { + t += c; + e = InFirst; + } + else if( c == cAll ) + { + rRL.Append( 0, nRecCnt - 1 ); + e = PostLast; + } + else if( !IsBlank( c ) ) + SYNTERR( c ); + break; + case InFirst: + if( c == cSep || c == cCont || IsBlank( c ) ) + { + n = GetVal( t ); + if( n == 0xFFFFFFFF ) + SYNTERR( 0 ); + else + NEWVAL( n1 ); + + t.Erase(); + + if( c == cSep ) + { + rRL.Append( n1, n1 ); + e = PreFirst; + } + else if( c == cCont ) + { + bExp2 = TRUE; + e = InCont; + } + else + e = PostFirst; + } + else if( IsAlphaNum( c ) ) + t += c; + else + SYNTERR( c ); + break; + case PostFirst: + if( c == cCont ) + { + e = InCont; + bExp2 = TRUE; + } + else if( c == cSep ) + { + n = GetVal( t ); + if( n == 0xFFFFFFFF ) + SYNTERR( 0 ); + else + NEWVAL( n1 ); + + e = PreFirst; + } + else if( !IsBlank( c ) ) + SYNTERR( c ); + break; + case InCont: + if( IsAlphaNum( c ) ) + { + t += c; + e = InLast; + } + else if( IsBlank( c ) ) + e = PreLast; + else if( c == cSep || c == cAll ) + { + rRL.Append( n1, nRecCnt - 1 ); + bExp2 = FALSE; + e = PreFirst; + } + else if( c != cCont ) + SYNTERR( c ); + break; + case PreLast: + if( IsAlphaNum( c ) ) + { + t += c; + e = InLast; + } + else if( !IsBlank( c ) ) + SYNTERR( c ); + break; + break; + case InLast: + if( c == cSep || IsBlank( c ) ) + { + n = GetVal( t ); + if( n == 0xFFFFFFFF ) + SYNTERR( 0 ); + else + NEWVAL( n2 ); + + t.Erase(); + ORDERN(); + rRL.Append( n1, n2 ); + bExp2 = FALSE; + e = ( c == cSep )? PreFirst : PostLast; + } + else if( IsAlphaNum( c ) ) + t += c; + else + SYNTERR( c ); + break; + case PostLast: + if( c == cSep ) + { + e = PreFirst; + bExp2 = FALSE; + } + else if( !IsBlank( c ) ) + SYNTERR( c ); + break; + } + + if( b ) + { + p++; + c = *p; + } + else + c = 0x00; + } + + if( bExp2 ) + { + if( t.Len() ) + { + n = GetVal( t ); + if( n == 0xFFFFFFFF ) + SYNTERR( 0 ); + else + NEWVAL( n2 ); + ORDERN(); + } + else + n2 = nRecCnt - 1; + + if( b ) + rRL.Append( n1, n2 ); + } + +#undef SYNTERR +#undef NEWVAL +#undef ORDERN + + return b; +} + + +BOOL Biff8RecDumper::CreateOutStream() +{ + if( pDumpStream ) + { + pDumpStream->Close(); + DELANDNULL( pDumpStream ); + } + + if( !bSkip && pOutName ) + { + pOutName->EraseLeadingChars( ' ' ); + pOutName->EraseTrailingChars( ' ' ); + pOutName->EraseLeadingChars( '\t' ); + pOutName->EraseTrailingChars( '\t' ); + + pDumpStream = new SvFileStream( String::CreateFromAscii( pOutName->GetBuffer() ), STREAM_WRITE|STREAM_SHARE_DENYWRITE|(bClearFile?STREAM_TRUNC:0) ); + + if( pDumpStream->IsOpen() ) + { + pDumpStream->Seek( bClearFile? STREAM_SEEK_TO_BEGIN : STREAM_SEEK_TO_END ); + return TRUE; + } + else + { + DELANDNULL( pDumpStream ); + } + } + + return FALSE; +} + + +SvFileStream* Biff8RecDumper::CreateInStream( const sal_Char* pN ) +{ + SvFileStream* p = new SvFileStream( String::CreateFromAscii( pN ), STREAM_READ|STREAM_SHARE_DENYWRITE ); + + if( p->IsOpen() ) + return p; + else + { + delete p; + return NULL; + } +} + + +SvFileStream* Biff8RecDumper::CreateInStream( const sal_Char* pP, const sal_Char* pN ) +{ + ByteString t( pP ); + const sal_Char c = t.GetChar( t.Len() - 1 ); + + if( c != '\\' ) + t += '\\'; + else if( c != '/' ) + t += '/'; + + t += pN; + + return CreateInStream( t.GetBuffer() ); +} + + +void Biff8RecDumper::AddError( const UINT32 n, const ByteString& rT, const ByteString& rH ) +{ + DUMP_ERR* p = new DUMP_ERR( n, rT, rH ); + + if( pFirst ) + pLast->pNext = p; + else + pFirst = p; + + pLast = p; +} + + +Biff8RecDumper::Biff8RecDumper( const XclImpRoot& rRoot, BOOL _bBIFF8 ) : + XclImpRoot( rRoot ), + bBIFF8( _bBIFF8 ), + bEncrypted( false ), + mnEscherPos( 0 ) +{ + nXFCount = 0; + nFontIndex = 0; + nInstances++; + mnSubstream = EXC_BOF_UNKNOWN; + + if( !pCharType ) + { + pCharType = new UINT8[ 256 ]; + memset( pCharType, 0x00, 256 ); + + pCharVal = new UINT8[ 256 ]; + memset( pCharVal, 0x00, 256 ); + + sal_Char c; + UINT8 n; + +#define __TYPE(n) pCharType[(UINT8)n] +#define __VAL(n) pCharVal[(UINT8)n] + + __TYPE( '\n' ) = CT_EOL; + __TYPE( '\r' ) = CT_EOL; + + __TYPE( ' ' ) = CT_BLANK; + __TYPE( '\t' ) = CT_BLANK; + + for( c = '0', n = 0 ; c <= '9' ; c++, n++ ) + { + __TYPE( c ) = CT_NUM|CT_HEX|CT_ALPHANUM; + __VAL( c ) = n; + } + for( c = 'a', n = 10 ; c <= 'f' ; c++, n++ ) + { + __TYPE( c ) = CT_HEX|CT_ALPHA|CT_ALPHANUM|CT_LOWERALPHA; + __VAL( c ) = n; + } + for( c = 'g' ; c <= 'z' ; c++ ) + __TYPE( c ) = CT_ALPHA|CT_ALPHANUM|CT_LOWERALPHA; + for( c = 'A', n = 10 ; c <= 'F' ; c++, n++ ) + { + __TYPE( c ) = CT_HEX|CT_ALPHA|CT_ALPHANUM|CT_UPPERALPHA; + __VAL( c ) = n; + } + for( c = 'G' ; c <= 'Z' ; c++ ) + __TYPE( c ) = CT_ALPHA|CT_ALPHANUM|CT_UPPERALPHA; + +#undef __TYPE +#undef __VAL + } + + pDumpStream = NULL; + + if( !pBlankLine ) + { + pBlankLine = new sal_Char[ nLenBlankLine + 1 ]; + memset( pBlankLine, ' ', nLenBlankLine ); + pBlankLine[ nLenBlankLine ] = 0x00; + } + + pTitle = NULL; + pOutName = NULL; + pLevelPre = pLevelPreStringNT; + + nMaxBodyLines = 1024; + bEndLoading = bSkip = bSkipOffset = bReadContRecs = bBlankLine = bExportBookStream = FALSE; + bWarnings = TRUE; + + pDumpModes = NULL; + ppRecNames = NULL; + + pFirst = pLast = pAct = NULL; + + cParSep = ','; + cComm1 = cComm2 = '/'; + + nFieldCnt = nItemCnt = nTabIndexCnt = 0; + + Init(); +} + + +Biff8RecDumper::~Biff8RecDumper() +{ + if( pDumpStream ) + { + pDumpStream->Close(); + delete pDumpStream; + } + + if( nInstances ) + { + nInstances--; + if( !nInstances ) + { + delete[] pBlankLine; + pBlankLine = NULL; + + delete[] pCharType; + pCharType = NULL; + + delete[] pCharVal; + pCharVal = NULL; + } + } + + if( pDumpModes ) + delete[] pDumpModes; + + if( ppRecNames ) + { + ByteString** pp = ppRecNames; + UINT16 n = nRecCnt; + while( n ) + { + if( *pp ) + delete *pp; + pp++; + n--; + } + delete[] ppRecNames; + } + + if( pTitle ) + delete pTitle; + + if( pOutName ) + delete pOutName; + + DUMP_ERR* p = pFirst; + DUMP_ERR* pD; + if( p ) + { + pD = p; + p = p->pNext; + delete pD; + } +} + + +BOOL Biff8RecDumper::Dump( XclImpStream& r ) +{ + const DUMP_ERR* pErr = FirstErr(); + + if( pErr ) + { + if( pDumpStream ) + { + SvFileStream& rOut = *pDumpStream; + while( pErr ) + { + rOut << "\nError"; + if( pErr->nLine ) + { + ByteString t; + t += ByteString::CreateFromInt32( pErr->nLine ); + rOut << " at line " << t.GetBuffer(); + } + + rOut << ": " << pErr->aText.GetBuffer(); + + if( pErr->pHint ) + rOut << " (" << pErr->pHint->GetBuffer() << ')'; + pErr = NextErr(); + } + rOut << '\n'; + } + } + else if( pDumpStream && !bSkip ) + { + SvStream& rOutStrm = *pDumpStream; + + if( bExportBookStream && pOutName ) + { + ByteString aBookOutName( *pOutName, 0, pOutName->Len() - 4 ); + aBookOutName.Append( "_book.xls" ); + SvFileStream aBook( String::CreateFromAscii( aBookOutName.GetBuffer() ), STREAM_WRITE|STREAM_SHARE_DENYWRITE|STREAM_TRUNC ); + if( aBook.IsOpen() ) + { + const sal_uInt32 nBufLen = 0xFFFF; + sal_uInt8 pBuffer[ nBufLen ]; + r.StoreGlobalPosition(); + while( r.StartNextRecord() ) + { + r.ResetRecord( false ); + sal_uInt16 nRecSize = (sal_uInt16) Min( r.GetRecSize(), nBufLen ); + aBook << r.GetRecId() << nRecSize; + r.Read( pBuffer, nRecSize ); + aBook.Write( pBuffer, nRecSize ); + } + r.SeekGlobalPosition(); + } + } + + if( pTitle ) + rOutStrm << pTitle->GetBuffer(); + + pIn = &r; + r.StoreGlobalPosition(); + + ::std::auto_ptr< XclDumpStorageHeader > xStrgHerader; + SotStorageRef xRootStrg = GetRootStorage(); + if( xRootStrg.Is() ) + xStrgHerader.reset( new XclDumpStorageHeader( *xRootStrg, rOutStrm, EMPTY_STRING ) ); + + ::std::auto_ptr< ScfProgressBar > xProgress( new ScfProgressBar( + GetDocShell(), String( RTL_CONSTASCII_USTRINGPARAM( "Dumper" ) ) ) ); + sal_Int32 nStreamSeg = xProgress->AddSegment( r.GetSvStreamSize() ); + xProgress->ActivateSegment( nStreamSeg ); + + while( r.StartNextRecord() ) + { + xProgress->ProgressAbs( r.GetSvStreamPos() ); + if( HasModeDump( r.GetRecId() ) ) + RecDump(); + } + + rOutStrm << "\n\n"; + + pIn = NULL; + xProgress.reset(); + + r.SeekGlobalPosition(); + + // dump substreams + if( xRootStrg.Is() ) + { + pIn = NULL; + bool bOldEncr = bEncrypted; + bEncrypted = false; + DumpRecordStream( xRootStrg, EXC_STREAM_USERNAMES, EMPTY_STRING ); + + pIn = &r; + bEncrypted = bOldEncr; + DumpRecordStream( xRootStrg, EXC_STREAM_REVLOG, EMPTY_STRING ); + + pIn = NULL; + + DumpCtlsStream(); + DumpVbaProjectStorage(); + } + } + + return !bEndLoading; +} + +#undef Read1 +#undef Read2 +#undef Read4 +#undef Read8 + +#endif + diff --git a/sc/source/filter/excel/xlpage.cxx b/sc/source/filter/excel/xlpage.cxx index 56ef285228b2..d1bea1addcec 100644 --- a/sc/source/filter/excel/xlpage.cxx +++ b/sc/source/filter/excel/xlpage.cxx @@ -44,7 +44,7 @@ struct XclPaperSize { - SvxPaper mePaper; /// SVX paper size identifier. + Paper mePaper; /// SVX paper size identifier. long mnWidth; /// Paper width in twips. long mnHeight; /// Paper height in twips. }; @@ -54,97 +54,114 @@ struct XclPaperSize static const XclPaperSize pPaperSizeTable[] = { -/* 0*/ { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_LETTER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Letter - { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Letter Small - { SVX_PAPER_TABLOID, IN2TWIPS( 11 ), IN2TWIPS( 17 ) }, // Tabloid - { SVX_PAPER_USER, IN2TWIPS( 17 ), IN2TWIPS( 11 ) }, // Ledger -/* 5*/ { SVX_PAPER_LEGAL, IN2TWIPS( 8.5 ), IN2TWIPS( 14 ) }, // Legal - { SVX_PAPER_USER, IN2TWIPS( 5.5 ), IN2TWIPS( 8.5 ) }, // Statement - { SVX_PAPER_USER, IN2TWIPS( 7.25 ), IN2TWIPS( 10.5 ) }, // Executive - { SVX_PAPER_A3, MM2TWIPS( 297 ), MM2TWIPS( 420 ) }, // A3 - { SVX_PAPER_A4, MM2TWIPS( 210 ), MM2TWIPS( 297 ) }, // A4 -/* 10*/ { SVX_PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 297 ) }, // A4 Small - { SVX_PAPER_A5, MM2TWIPS( 148 ), MM2TWIPS( 210 ) }, // A5 - { SVX_PAPER_B4_JIS, MM2TWIPS( 257 ), MM2TWIPS( 364 ) }, // B4 (JIS) - { SVX_PAPER_B5_JIS, MM2TWIPS( 182 ), MM2TWIPS( 257 ) }, // B5 (JIS) - { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 13 ) }, // Folio -/* 15*/ { SVX_PAPER_USER, MM2TWIPS( 215 ), MM2TWIPS( 275 ) }, // Quarto - { SVX_PAPER_USER, IN2TWIPS( 10 ), IN2TWIPS( 14 ) }, // 10x14 - { SVX_PAPER_USER, IN2TWIPS( 11 ), IN2TWIPS( 17 ) }, // 11x17 - { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Note - { SVX_PAPER_COM9, IN2TWIPS( 3.875 ), IN2TWIPS( 8.875 ) }, // Envelope #9 -/* 20*/ { SVX_PAPER_COM10, IN2TWIPS( 4.125 ), IN2TWIPS( 9.5 ) }, // Envelope #10 - { SVX_PAPER_COM11, IN2TWIPS( 4.5 ), IN2TWIPS( 10.375 ) }, // Envelope #11 - { SVX_PAPER_COM12, IN2TWIPS( 4.75 ), IN2TWIPS( 11 ) }, // Envelope #12 - { SVX_PAPER_USER, IN2TWIPS( 5 ), IN2TWIPS( 11.5 ) }, // Envelope #14 - { SVX_PAPER_C, IN2TWIPS( 17 ), IN2TWIPS( 22 ) }, // ANSI-C -/* 25*/ { SVX_PAPER_D, IN2TWIPS( 22 ), IN2TWIPS( 34 ) }, // ANSI-D - { SVX_PAPER_E, IN2TWIPS( 34 ), IN2TWIPS( 44 ) }, // ANSI-E - { SVX_PAPER_DL, MM2TWIPS( 110 ), MM2TWIPS( 220 ) }, // Envelope DL - { SVX_PAPER_C5, MM2TWIPS( 162 ), MM2TWIPS( 229 ) }, // Envelope C5 - { SVX_PAPER_USER, MM2TWIPS( 324 ), MM2TWIPS( 458 ) }, // Envelope C3 -/* 30*/ { SVX_PAPER_C4, MM2TWIPS( 229 ), MM2TWIPS( 324 ) }, // Envelope C4 - { SVX_PAPER_C6, MM2TWIPS( 114 ), MM2TWIPS( 162 ) }, // Envelope C6 - { SVX_PAPER_C65, MM2TWIPS( 114 ), MM2TWIPS( 229 ) }, // Envelope C65 - { SVX_PAPER_B4, MM2TWIPS( 250 ), MM2TWIPS( 353 ) }, // B4 (ISO) - { SVX_PAPER_B5, MM2TWIPS( 176 ), MM2TWIPS( 250 ) }, // B5 (ISO) -/* 35*/ { SVX_PAPER_B6, MM2TWIPS( 125 ), MM2TWIPS( 176 ) }, // B6 (ISO) - { SVX_PAPER_USER, MM2TWIPS( 110 ), MM2TWIPS( 230 ) }, // Envelope Italy - { SVX_PAPER_MONARCH, IN2TWIPS( 3.875 ), IN2TWIPS( 7.5 ) }, // Envelope Monarch - { SVX_PAPER_COM675, IN2TWIPS( 3.625 ), IN2TWIPS( 6.5 ) }, // 6 3/4 Envelope - { SVX_PAPER_USER, IN2TWIPS( 14.875 ), IN2TWIPS( 11 ) }, // US Std Fanfold -/* 40*/ { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 12 ) }, // German Std Fanfold - { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 13 ) }, // German Legal Fanfold - { SVX_PAPER_B4, MM2TWIPS( 250 ), MM2TWIPS( 353 ) }, // B4 (ISO) - { SVX_PAPER_USER, MM2TWIPS( 100 ), MM2TWIPS( 148 ) }, // Japanese Postcard - { SVX_PAPER_USER, IN2TWIPS( 9 ), IN2TWIPS( 11 ) }, // 9x11 -/* 45*/ { SVX_PAPER_USER, IN2TWIPS( 10 ), IN2TWIPS( 11 ) }, // 10x11 - { SVX_PAPER_USER, IN2TWIPS( 15 ), IN2TWIPS( 11 ) }, // 15x11 - { SVX_PAPER_USER, MM2TWIPS( 220 ), MM2TWIPS( 220 ) }, // Envelope Invite - { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_USER, 0, 0 }, // undefined -/* 50*/ { SVX_PAPER_USER, IN2TWIPS( 9.5 ), IN2TWIPS( 12 ) }, // Letter Extra - { SVX_PAPER_USER, IN2TWIPS( 9.5 ), IN2TWIPS( 15 ) }, // Legal Extra - { SVX_PAPER_USER, IN2TWIPS( 11.69 ), IN2TWIPS( 18 ) }, // Tabloid Extra - { SVX_PAPER_USER, MM2TWIPS( 235 ), MM2TWIPS( 322 ) }, // A4 Extra - { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Letter Transverse -/* 55*/ { SVX_PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 297 ) }, // A4 Transverse - { SVX_PAPER_USER, IN2TWIPS( 9.5 ), IN2TWIPS( 12 ) }, // Letter Extra Transverse - { SVX_PAPER_USER, MM2TWIPS( 227 ), MM2TWIPS( 356 ) }, // Super A/A4 - { SVX_PAPER_USER, MM2TWIPS( 305 ), MM2TWIPS( 487 ) }, // Super B/A3 - { SVX_PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 12.69 ) }, // Letter Plus -/* 60*/ { SVX_PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 330 ) }, // A4 Plus - { SVX_PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 210 ) }, // A5 Transverse - { SVX_PAPER_USER, MM2TWIPS( 182 ), MM2TWIPS( 257 ) }, // B5 (JIS) Transverse - { SVX_PAPER_USER, MM2TWIPS( 322 ), MM2TWIPS( 445 ) }, // A3 Extra - { SVX_PAPER_USER, MM2TWIPS( 174 ), MM2TWIPS( 235 ) }, // A5 Extra -/* 65*/ { SVX_PAPER_USER, MM2TWIPS( 201 ), MM2TWIPS( 276 ) }, // B5 (ISO) Extra - { SVX_PAPER_A2, MM2TWIPS( 420 ), MM2TWIPS( 594 ) }, // A2 - { SVX_PAPER_USER, MM2TWIPS( 297 ), MM2TWIPS( 420 ) }, // A3 Transverse - { SVX_PAPER_USER, MM2TWIPS( 322 ), MM2TWIPS( 445 ) }, // A3 Extra Transverse - { SVX_PAPER_USER, MM2TWIPS( 200 ), MM2TWIPS( 148 ) }, // Double Japanese Postcard -/* 70*/ { SVX_PAPER_USER, MM2TWIPS( 105 ), MM2TWIPS( 148 ) }, // A6 - { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_USER, 0, 0 }, // undefined -/* 75*/ { SVX_PAPER_USER, IN2TWIPS( 11 ), IN2TWIPS( 8.5 ) }, // Letter Rotated - { SVX_PAPER_USER, MM2TWIPS( 420 ), MM2TWIPS( 297 ) }, // A3 Rotated - { SVX_PAPER_USER, MM2TWIPS( 297 ), MM2TWIPS( 210 ) }, // A4 Rotated - { SVX_PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 148 ) }, // A5 Rotated - { SVX_PAPER_USER, MM2TWIPS( 364 ), MM2TWIPS( 257 ) }, // B4 (JIS) Rotated -/* 80*/ { SVX_PAPER_USER, MM2TWIPS( 257 ), MM2TWIPS( 182 ) }, // B5 (JIS) Rotated - { SVX_PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 100 ) }, // Japanese Postcard Rotated - { SVX_PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 200 ) }, // Double Japanese Postcard Rotated - { SVX_PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 105 ) }, // A6 Rotated - { SVX_PAPER_USER, 0, 0 }, // undefined -/* 85*/ { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_USER, 0, 0 }, // undefined - { SVX_PAPER_B6_JIS, MM2TWIPS( 128 ), MM2TWIPS( 182 ) }, // B6 (JIS) - { SVX_PAPER_USER, MM2TWIPS( 182 ), MM2TWIPS( 128 ) }, // B6 (JIS) Rotated -/* 90*/ { SVX_PAPER_USER, IN2TWIPS( 12 ), IN2TWIPS( 11 ) } // 12x11 +/* 0*/ { PAPER_USER, 0, 0 }, // undefined + { PAPER_LETTER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Letter + { PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Letter Small + { PAPER_TABLOID, IN2TWIPS( 11 ), IN2TWIPS( 17 ) }, // Tabloid + { PAPER_LEDGER, IN2TWIPS( 17 ), IN2TWIPS( 11 ) }, // Ledger +/* 5*/ { PAPER_LEGAL, IN2TWIPS( 8.5 ), IN2TWIPS( 14 ) }, // Legal + { PAPER_STATEMENT, IN2TWIPS( 5.5 ), IN2TWIPS( 8.5 ) }, // Statement + { PAPER_EXECUTIVE, IN2TWIPS( 7.25 ), IN2TWIPS( 10.5 ) }, // Executive + { PAPER_A3, MM2TWIPS( 297 ), MM2TWIPS( 420 ) }, // A3 + { PAPER_A4, MM2TWIPS( 210 ), MM2TWIPS( 297 ) }, // A4 +/* 10*/ { PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 297 ) }, // A4 Small + { PAPER_A5, MM2TWIPS( 148 ), MM2TWIPS( 210 ) }, // A5 + //See: http://wiki.services.openoffice.org/wiki/DefaultPaperSize comments + //near DMPAPER_B4 in vcl + //i.e. + //http://msdn.microsoft.com/en-us/library/bb241398.aspx makes the claim: + //xlPaperB4 12 B4 (250 mm x 354 mm) + //xlPaperB5 13 A5 (148 mm x 210 mm) + //but, a paper enum called B5 is surely not actually "A5", and furthermore + //the XlPaperSize enumeration otherwise follows the DMPAPER values + //http://msdn.microsoft.com/en-us/library/ms776398(VS.85).aspx + //which has + //DMPAPER_B4 12 B4 (JIS) 250 x 354 + //DMPAPER_B5 13 B5 (JIS) 182 x 257 mm + //which claim them to be the JIS sizes. Though that document then gives + //"B4 (JIS)" an *ISO* B4 size in the text, but + //http://partners.adobe.com/public/developer/en/ps/5003.PPD_Spec_v4.3.pdf + //claims that the MS DMPAPER_B4 and DMPAPER_B5 truly are the JIS sizes + //which at least makes some sort of sense. (cmc) + { PAPER_B4_JIS, MM2TWIPS( 257 ), MM2TWIPS( 364 ) }, // B4 (JIS) + { PAPER_B5_JIS, MM2TWIPS( 182 ), MM2TWIPS( 257 ) }, // B5 (JIS) + { PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 13 ) }, // Folio +/* 15*/ { PAPER_QUARTO, MM2TWIPS( 215 ), MM2TWIPS( 275 ) }, // Quarto + { PAPER_10x14, IN2TWIPS( 10 ), IN2TWIPS( 14 ) }, // 10x14 + { PAPER_USER, IN2TWIPS( 11 ), IN2TWIPS( 17 ) }, // 11x17 + { PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Note + { PAPER_ENV_9, IN2TWIPS( 3.875 ), IN2TWIPS( 8.875 ) }, // Envelope #9 +/* 20*/ { PAPER_ENV_10, IN2TWIPS( 4.125 ), IN2TWIPS( 9.5 ) }, // Envelope #10 + { PAPER_ENV_11, IN2TWIPS( 4.5 ), IN2TWIPS( 10.375 ) }, // Envelope #11 + { PAPER_ENV_12, IN2TWIPS( 4.75 ), IN2TWIPS( 11 ) }, // Envelope #12 + { PAPER_ENV_14, IN2TWIPS( 5 ), IN2TWIPS( 11.5 ) }, // Envelope #14 + { PAPER_C, IN2TWIPS( 17 ), IN2TWIPS( 22 ) }, // ANSI-C +/* 25*/ { PAPER_D, IN2TWIPS( 22 ), IN2TWIPS( 34 ) }, // ANSI-D + { PAPER_E, IN2TWIPS( 34 ), IN2TWIPS( 44 ) }, // ANSI-E + { PAPER_ENV_DL, MM2TWIPS( 110 ), MM2TWIPS( 220 ) }, // Envelope DL + { PAPER_ENV_C5, MM2TWIPS( 162 ), MM2TWIPS( 229 ) }, // Envelope C5 + { PAPER_ENV_C3, MM2TWIPS( 324 ), MM2TWIPS( 458 ) }, // Envelope C3 +/* 30*/ { PAPER_ENV_C4, MM2TWIPS( 229 ), MM2TWIPS( 324 ) }, // Envelope C4 + { PAPER_ENV_C6, MM2TWIPS( 114 ), MM2TWIPS( 162 ) }, // Envelope C6 + { PAPER_ENV_C65, MM2TWIPS( 114 ), MM2TWIPS( 229 ) }, // Envelope C65 + { PAPER_B4_ISO, MM2TWIPS( 250 ), MM2TWIPS( 353 ) }, // B4 (ISO) + { PAPER_B5_ISO, MM2TWIPS( 176 ), MM2TWIPS( 250 ) }, // B5 (ISO) +/* 35*/ { PAPER_B6_ISO, MM2TWIPS( 125 ), MM2TWIPS( 176 ) }, // B6 (ISO) + { PAPER_ENV_ITALY, MM2TWIPS( 110 ), MM2TWIPS( 230 ) }, // Envelope Italy + { PAPER_ENV_MONARCH, IN2TWIPS( 3.875 ), IN2TWIPS( 7.5 ) }, // Envelope Monarch + { PAPER_ENV_PERSONAL, IN2TWIPS( 3.625 ), IN2TWIPS( 6.5 ) }, // 6 3/4 Envelope + { PAPER_FANFOLD_US, IN2TWIPS( 14.875 ), IN2TWIPS( 11 ) }, // US Std Fanfold +/* 40*/ { PAPER_FANFOLD_DE, IN2TWIPS( 8.5 ), IN2TWIPS( 12 ) }, // German Std Fanfold + { PAPER_FANFOLD_LEGAL_DE, IN2TWIPS( 8.5 ), IN2TWIPS( 13 ) }, // German Legal Fanfold + { PAPER_B4_ISO, MM2TWIPS( 250 ), MM2TWIPS( 353 ) }, // B4 (ISO) + { PAPER_POSTCARD_JP,MM2TWIPS( 100 ), MM2TWIPS( 148 ) }, // Japanese Postcard + { PAPER_9x11, IN2TWIPS( 9 ), IN2TWIPS( 11 ) }, // 9x11 +/* 45*/ { PAPER_10x11, IN2TWIPS( 10 ), IN2TWIPS( 11 ) }, // 10x11 + { PAPER_15x11, IN2TWIPS( 15 ), IN2TWIPS( 11 ) }, // 15x11 + { PAPER_ENV_INVITE, MM2TWIPS( 220 ), MM2TWIPS( 220 ) }, // Envelope Invite + { PAPER_USER, 0, 0 }, // undefined + { PAPER_USER, 0, 0 }, // undefined +/* 50*/ { PAPER_USER, IN2TWIPS( 9.5 ), IN2TWIPS( 12 ) }, // Letter Extra + { PAPER_USER, IN2TWIPS( 9.5 ), IN2TWIPS( 15 ) }, // Legal Extra + { PAPER_USER, IN2TWIPS( 11.69 ), IN2TWIPS( 18 ) }, // Tabloid Extra + { PAPER_USER, MM2TWIPS( 235 ), MM2TWIPS( 322 ) }, // A4 Extra + { PAPER_USER, IN2TWIPS( 8.5 ), IN2TWIPS( 11 ) }, // Letter Transverse +/* 55*/ { PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 297 ) }, // A4 Transverse + { PAPER_USER, IN2TWIPS( 9.5 ), IN2TWIPS( 12 ) }, // Letter Extra Transverse + { PAPER_A_PLUS, MM2TWIPS( 227 ), MM2TWIPS( 356 ) }, // Super A/A4 + { PAPER_B_PLUS, MM2TWIPS( 305 ), MM2TWIPS( 487 ) }, // Super B/A3 + { PAPER_LETTER_PLUS,IN2TWIPS( 8.5 ), IN2TWIPS( 12.69 ) }, // Letter Plus +/* 60*/ { PAPER_A4_PLUS, MM2TWIPS( 210 ), MM2TWIPS( 330 ) }, // A4 Plus + { PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 210 ) }, // A5 Transverse + { PAPER_USER, MM2TWIPS( 182 ), MM2TWIPS( 257 ) }, // B5 (JIS) Transverse + { PAPER_USER, MM2TWIPS( 322 ), MM2TWIPS( 445 ) }, // A3 Extra + { PAPER_USER, MM2TWIPS( 174 ), MM2TWIPS( 235 ) }, // A5 Extra +/* 65*/ { PAPER_USER, MM2TWIPS( 201 ), MM2TWIPS( 276 ) }, // B5 (ISO) Extra + { PAPER_A2, MM2TWIPS( 420 ), MM2TWIPS( 594 ) }, // A2 + { PAPER_USER, MM2TWIPS( 297 ), MM2TWIPS( 420 ) }, // A3 Transverse + { PAPER_USER, MM2TWIPS( 322 ), MM2TWIPS( 445 ) }, // A3 Extra Transverse + { PAPER_DOUBLEPOSTCARD_JP, MM2TWIPS( 200 ), MM2TWIPS( 148 ) }, // Double Japanese Postcard +/* 70*/ { PAPER_A6, MM2TWIPS( 105 ), MM2TWIPS( 148 ) }, // A6 + { PAPER_USER, 0, 0 }, // undefined + { PAPER_USER, 0, 0 }, // undefined + { PAPER_USER, 0, 0 }, // undefined + { PAPER_USER, 0, 0 }, // undefined +/* 75*/ { PAPER_USER, IN2TWIPS( 11 ), IN2TWIPS( 8.5 ) }, // Letter Rotated + { PAPER_USER, MM2TWIPS( 420 ), MM2TWIPS( 297 ) }, // A3 Rotated + { PAPER_USER, MM2TWIPS( 297 ), MM2TWIPS( 210 ) }, // A4 Rotated + { PAPER_USER, MM2TWIPS( 210 ), MM2TWIPS( 148 ) }, // A5 Rotated + { PAPER_USER, MM2TWIPS( 364 ), MM2TWIPS( 257 ) }, // B4 (JIS) Rotated +/* 80*/ { PAPER_USER, MM2TWIPS( 257 ), MM2TWIPS( 182 ) }, // B5 (JIS) Rotated + { PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 100 ) }, // Japanese Postcard Rotated + { PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 200 ) }, // Double Japanese Postcard Rotated + { PAPER_USER, MM2TWIPS( 148 ), MM2TWIPS( 105 ) }, // A6 Rotated + { PAPER_USER, 0, 0 }, // undefined +/* 85*/ { PAPER_USER, 0, 0 }, // undefined + { PAPER_USER, 0, 0 }, // undefined + { PAPER_USER, 0, 0 }, // undefined + { PAPER_B6_JIS, MM2TWIPS( 128 ), MM2TWIPS( 182 ) }, // B6 (JIS) + { PAPER_USER, MM2TWIPS( 182 ), MM2TWIPS( 128 ) }, // B6 (JIS) Rotated +/* 90*/ { PAPER_12x11, IN2TWIPS( 12 ), IN2TWIPS( 11 ) } // 12x11 }; #undef IN2TWIPS @@ -193,15 +210,14 @@ Size XclPageData::GetScPaperSize() const pEntry += mnPaperSize; Size aSize; - if( pEntry->mePaper == SVX_PAPER_USER ) + if( pEntry->mePaper == PAPER_USER ) aSize = Size( pEntry->mnWidth, pEntry->mnHeight ); else aSize = SvxPaperInfo::GetPaperSize( pEntry->mePaper ); // invalid size -> back to default if( !aSize.Width() || !aSize.Height() ) - aSize = SvxPaperInfo::GetPaperSize( SvxPaperInfo::GetDefaultSvxPaper( - Application::GetSettings().GetLanguage() ) ); + aSize = SvxPaperInfo::GetDefaultPaperSize(); if( !mbPortrait ) ::std::swap( aSize.Width(), aSize.Height() ); diff --git a/sc/source/filter/html/htmlimp.cxx b/sc/source/filter/html/htmlimp.cxx index abc7d2b21392..5591e8ec993e 100644 --- a/sc/source/filter/html/htmlimp.cxx +++ b/sc/source/filter/html/htmlimp.cxx @@ -99,7 +99,7 @@ ScHTMLImport::ScHTMLImport( ScDocument* pDocP, const String& rBaseURL, const ScR if ( !aPageSize.Width() || !aPageSize.Height() ) { DBG_ERRORFILE("PageSize Null ?!?!?"); - aPageSize = SvxPaperInfo::GetPaperSize( SVX_PAPER_A4 ); + aPageSize = SvxPaperInfo::GetPaperSize( PAPER_A4 ); } aPageSize.Width() -= nLeftMargin + nRightMargin; aPageSize.Height() -= nTopMargin + nBottomMargin; @@ -109,7 +109,7 @@ ScHTMLImport::ScHTMLImport( ScDocument* pDocP, const String& rBaseURL, const ScR { DBG_ERRORFILE("kein StyleSheet?!?"); aPageSize = pDefaultDev->LogicToPixel( - SvxPaperInfo::GetPaperSize( SVX_PAPER_A4 ), MapMode( MAP_TWIP ) ); + SvxPaperInfo::GetPaperSize( PAPER_A4 ), MapMode( MAP_TWIP ) ); } if( bCalcWidthHeight ) mpParser = new ScHTMLLayoutParser( mpEngine, rBaseURL, aPageSize, pDocP ); diff --git a/sc/source/ui/app/transobj.cxx b/sc/source/ui/app/transobj.cxx index 076cd3581d26..94a2cdfc3324 100644 --- a/sc/source/ui/app/transobj.cxx +++ b/sc/source/ui/app/transobj.cxx @@ -658,7 +658,7 @@ void ScTransferObj::InitDocShell() // page format (grid etc) and page size (maximum size for ole object) - Size aPaperSize = SvxPaperInfo::GetPaperSize( SVX_PAPER_A4 ); // Twips + Size aPaperSize = SvxPaperInfo::GetPaperSize( PAPER_A4 ); // Twips ScStyleSheetPool* pStylePool = pDoc->GetStyleSheetPool(); String aStyleName = pDoc->GetPageStyle( aBlock.aStart.Tab() ); SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName, SFX_STYLE_FAMILY_PAGE ); diff --git a/sc/source/ui/inc/printfun.hxx b/sc/source/ui/inc/printfun.hxx index 6a8e43fb2e7c..fd607975ff47 100644 --- a/sc/source/ui/inc/printfun.hxx +++ b/sc/source/ui/inc/printfun.hxx @@ -92,7 +92,7 @@ public: Size aUserSize; MapMode aUserMapMode; - Paper ePaper; + Paper ePaper; Orientation eOrientation; USHORT nPaperBin; }; diff --git a/sc/source/ui/view/printfun.cxx b/sc/source/ui/view/printfun.cxx index 4324b610dd0b..d14a87ffe783 100644 --- a/sc/source/ui/view/printfun.cxx +++ b/sc/source/ui/view/printfun.cxx @@ -886,7 +886,7 @@ void ScPrintFunc::InitParam( const ScPrintOptions* pOptions ) if ( !aPageSize.Width() || !aPageSize.Height() ) { DBG_ERROR("PageSize Null ?!?!?"); - aPageSize = SvxPaperInfo::GetPaperSize( SVX_PAPER_A4 ); + aPageSize = SvxPaperInfo::GetPaperSize( PAPER_A4 ); } pBorderItem = (const SvxBoxItem*) &pParamSet->Get(ATTR_BORDER); @@ -2677,7 +2677,7 @@ void ScPrintFunc::ApplyPrintSettings() aEnumSize.Width() = aEnumSize.Height(); aEnumSize.Height() = nTemp; } - Paper ePaper = SvxPaperInfo::GetSvPaper( aEnumSize, MAP_TWIP, TRUE ); + Paper ePaper = SvxPaperInfo::GetSvxPaper( aEnumSize, MAP_TWIP, TRUE ); USHORT nPaperBin = ((const SvxPaperBinItem&)pParamSet->Get(ATTR_PAGE_PAPERBIN)).GetValue(); pPrinter->SetPaper( ePaper ); |