diff options
Diffstat (limited to 'sc/source/filter/excel')
34 files changed, 3177 insertions, 2166 deletions
diff --git a/sc/source/filter/excel/biffdump.cxx b/sc/source/filter/excel/biffdump.cxx index 9b28ff605d7b..e348e4006eeb 100644 --- a/sc/source/filter/excel/biffdump.cxx +++ b/sc/source/filter/excel/biffdump.cxx @@ -2,9 +2,9 @@ * * $RCSfile: biffdump.cxx,v $ * - * $Revision: 1.53 $ + * $Revision: 1.54 $ * - * last change: $Author: dr $ $Date: 2002-12-09 13:43:55 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:28 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -85,7 +85,7 @@ #include <stdlib.h> #include <stdio.h> -#include <tools/solmath.hxx> +#include <rtl/math.hxx> #ifndef SC_DOCUMENT_HXX #include "document.hxx" @@ -93,15 +93,17 @@ #ifndef SC_SCGLOB_HXX #include "global.hxx" #endif + +#ifndef SC_FPROGRESSBAR_HXX +#include "fprogressbar.hxx" +#endif #ifndef SC_XLTOOLS_HXX #include "xltools.hxx" #endif + #ifndef _FLTTOOLS_HXX #include "flttools.hxx" #endif -#ifndef _FLTPRGRS_HXX -#include "fltprgrs.hxx" -#endif #ifndef _IMP_OP_HXX #include "imp_op.hxx" #endif @@ -258,8 +260,7 @@ static void __AddPureBin( ByteString& r, UINT32 nVal ) inline static void __AddDec( ByteString& r, UINT32 n ) { sal_Char p[ 32 ]; - sprintf( p, "%u", n ); - + sprintf( p, "%u", n ); // #100211# - checked r += p; } @@ -279,8 +280,7 @@ inline static void __AddDec( ByteString& r, UINT8 n ) inline static void __AddDec( ByteString& r, INT32 n ) { sal_Char p[ 32 ]; - sprintf( p, "%d", n ); - + sprintf( p, "%d", n ); // #100211# - checked r += p; } @@ -290,6 +290,11 @@ inline static void __AddDec( ByteString& r, INT16 n ) __AddDec( r, ( INT32 ) n ); } +inline static void __AddDec( ByteString& r, INT8 n ) +{ + __AddDec( r, ( INT32 ) n ); +} + static void __AddDec( ByteString& r, UINT32 nVal, UINT16 nNumOfDig, sal_Char c = ' ' ) { @@ -313,9 +318,7 @@ inline static void __AddDec1616( ByteString& r, UINT32 n ) static void __AddDouble( ByteString& r, const double f ) { - String aStr; - SolarMath::DoubleToString( aStr, f, 'G', 15, '.', TRUE ); - r += ByteString( aStr, RTL_TEXTENCODING_ASCII_US ); + r += ByteString( ::rtl::math::doubleToString( f, rtl_math_StringFormat_G, 15, '.', TRUE ) ); } @@ -642,8 +645,8 @@ DUMP_ERR::~DUMP_ERR() #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 += text;} -#define ADDRESERVED(mask) ADDFLAG(mask," !RESERVED!") +#define ADDFLAG(mask,text) {if( __nFlags & mask ) t.Append( ' ' ).Append( text );} +#define ADDRESERVED(mask) ADDFLAG(mask,"!RESERVED!") UINT16 Biff8RecDumper::DumpXF( XclImpStream& rIn, const sal_Char* pPre ) @@ -910,7 +913,7 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) case 0x005D: // OBJ case 0x00EC: // MSODRAWING case 0x01B6: // TXO - pIn->InitializeRecord( FALSE ); + pIn->InitializeRecord( false ); break; default: pIn->InitializeRecord( bReadContRecs ); @@ -1027,9 +1030,9 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { ADDTEXT( " " ); STARTFLAG(); - ADDFLAG( 0x01, " fAlwaysCalc" ); - ADDFLAG( 0x02, " fCalcOnLoad" ); - ADDFLAG( 0x08, " fShrFmla" ); + ADDFLAG( 0x01, "fAlwaysCalc" ); + ADDFLAG( 0x02, "fCalcOnLoad" ); + ADDFLAG( 0x08, "fShrFmla" ); } PRINT(); LINESTART(); @@ -1085,13 +1088,13 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) rIn >> __nFlags >> n8 >> nNameText >> nNameDef >> n16 >> n16 >> n8 >> n8 >> n8 >> n8; LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fHidden" ); - ADDFLAG( 0x0002, " fFunc" ); - ADDFLAG( 0x0004, " fVBProc" ); - ADDFLAG( 0x0008, " fProc" ); - ADDFLAG( 0x0010, " fCalcExp" ); - ADDFLAG( 0x0020, " fBuiltIn" ); - ADDFLAG( 0x1000, " fBig" ); + ADDFLAG( 0x0001, "fHidden" ); + ADDFLAG( 0x0002, "fFunc" ); + ADDFLAG( 0x0004, "fVBProc" ); + ADDFLAG( 0x0008, "fProc" ); + ADDFLAG( 0x0010, "fCalcExp" ); + ADDFLAG( 0x0020, "fBuiltIn" ); + ADDFLAG( 0x1000, "fBig" ); ADDRESERVED( 0xE000 ); ADDTEXT( " Fn grp index: " ); __AddDec( t, (UINT16)((__nFlags & 0x0FC0) >> 6) ); @@ -1192,10 +1195,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) ADDTEXT( "/20pt " ); rIn >> __nFlags; STARTFLAG(); - ADDFLAG( 0x0002, " fItalic" ); - ADDFLAG( 0x0008, " fStrikeout" ); - ADDFLAG( 0x0010, " fOutline" ); - ADDFLAG( 0x0020, " fShadow" ); + ADDFLAG( 0x0002, "fItalic" ); + ADDFLAG( 0x0008, "fStrikeout" ); + ADDFLAG( 0x0010, "fOutline" ); + ADDFLAG( 0x0020, "fShadow" ); ADDRESERVED( 0xFFC5 ); PRINT(); LINESTART(); @@ -1236,7 +1239,7 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fReadOnlyRec" ); + ADDFLAG( 0x0001, "fReadOnlyRec" ); PRINT(); } DumpValidPassword( rIn, pPre ); @@ -1260,10 +1263,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) rIn >> __nFlags; LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fHidden" ); + ADDFLAG( 0x0001, "fHidden" ); ADDTEXT( " outlnlev=" ); __AddDec( t, (UINT16)((__nFlags & 0x0700) >> 8) ); - ADDFLAG( 0x1000, " fCollapsed" ); + ADDFLAG( 0x1000, "fCollapsed" ); ADDRESERVED( 0xE8FE ); PRINT(); LINESTART(); @@ -1304,22 +1307,22 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) STARTFLAG(); if( __nFlags & 0x00F1 ) { - ADDFLAG( 0x0001, " fShowAutoBreaks" ); - ADDFLAG( 0x0010, " fDialog" ); - ADDFLAG( 0x0020, " fApplyStyles" ); - ADDFLAG( 0x0040, " fRowSumsBelow" ); - ADDFLAG( 0x0080, " fColSumsBelow" ); + 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" ); + ADDFLAG( 0x0100, "fFitToPage" ); + ADDFLAG( 0x0400, "fDispRowGuts" ); + ADDFLAG( 0x0800, "fDispColGuts" ); + ADDFLAG( 0x4000, "fAee" ); + ADDFLAG( 0x8000, "fAfe" ); ADDRESERVED( 0x320E ); PRINT(); } @@ -1370,12 +1373,12 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) ADDDEC( 2 ); rIn >> __nFlags; STARTFLAG(); - ADDFLAG( 0x0003, " fJoin" ); - ADDFLAG( 0x0004, " fSimpleEq1" ); - ADDFLAG( 0x0008, " fSimpleEq2" ); - ADDFLAG( 0x0010, " fTop10" ); - ADDFLAG( 0x0020, " fTop" ); - ADDFLAG( 0x0040, " fPercent" ); + ADDFLAG( 0x0003, "fJoin" ); + ADDFLAG( 0x0004, "fSimpleEq1" ); + ADDFLAG( 0x0008, "fSimpleEq2" ); + ADDFLAG( 0x0010, "fTop10" ); + ADDFLAG( 0x0020, "fTop" ); + ADDFLAG( 0x0040, "fPercent" ); PRINT(); LINESTART(); if( __nFlags & 0x0003 ) @@ -1487,14 +1490,14 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) 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" ); + 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 ); @@ -1575,15 +1578,15 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { 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" ); + 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(); @@ -1617,10 +1620,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) ADDTEXT( "):" ); if( __nFlags ) { - ADDFLAG( 0x0001, " row" ); - ADDFLAG( 0x0002, " col" ); - ADDFLAG( 0x0004, " page" ); - ADDFLAG( 0x0008, " data" ); + ADDFLAG( 0x0001, "row" ); + ADDFLAG( 0x0002, "col" ); + ADDFLAG( 0x0004, "page" ); + ADDFLAG( 0x0008, "data" ); } else ADDTEXT( " no axis" ); @@ -1634,18 +1637,18 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) 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" ); + 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" ); @@ -1700,10 +1703,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x01, " fHidden" ); - ADDFLAG( 0x02, " fHideDetail" ); - ADDFLAG( 0x04, " fFormula" ); - ADDFLAG( 0x08, " fMissing" ); + ADDFLAG( 0x01, "fHidden" ); + ADDFLAG( 0x02, "fHideDetail" ); + ADDFLAG( 0x04, "fFormula" ); + ADDFLAG( 0x08, "fMissing" ); PRINT(); } LINESTART(); @@ -1771,13 +1774,13 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) 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 + 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(); @@ -1966,9 +1969,9 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) ADDTEXT( pPre ); rIn >> __nFlags; STARTFLAG(); - ADDFLAG( 0x0001, " fInIndexList" ); - ADDFLAG( 0x0002, " fNotInList" ); - ADDFLAG( 0x0200, " fLongIndex" ); + ADDFLAG( 0x0001, "fInIndexList" ); + ADDFLAG( 0x0002, "fNotInList" ); + ADDFLAG( 0x0200, "fLongIndex" ); ADDTEXT( " data type: " ); __nFlags &= 0x0DFC; switch( __nFlags ) @@ -2189,33 +2192,33 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) STARTFLAG(); if( __nFlags & 0x009F ) { - ADDFLAG( 0x0001, " fShowAllItems" ); - ADDFLAG( 0x0002, " fDragToRow" ); - ADDFLAG( 0x0004, " fDragToColumn" ); - ADDFLAG( 0x0008, " fDragToPage" ); - ADDFLAG( 0x0010, " fDragToHide" ); - ADDFLAG( 0x0080, " fServerBased" ); + ADDFLAG( 0x0001, "fShowAllItems" ); + ADDFLAG( 0x0002, "fDragToRow" ); + ADDFLAG( 0x0004, "fDragToColumn" ); + ADDFLAG( 0x0008, "fDragToPage" ); + ADDFLAG( 0x0010, "fDragToHide" ); + ADDFLAG( 0x0080, "fServerBased" ); PRINT(); LINESTART(); } if( __nFlags & 0xBF00 ) { ADDTEXT( " " ); - ADDFLAG( 0x0200, " fAutoSort" ); - ADDFLAG( 0x0400, " fAscendSort" ); - ADDFLAG( 0x0800, " fAutoShow" ); - ADDFLAG( 0x1000, " fAscendShow" ); - ADDFLAG( 0x2000, " fCalculatedField" ); + ADDFLAG( 0x0200, "fAutoSort" ); + ADDFLAG( 0x0400, "fAscendSort" ); + ADDFLAG( 0x0800, "fAutoShow" ); + ADDFLAG( 0x1000, "fAscendShow" ); + ADDFLAG( 0x2000, "fCalculatedField" ); PRINT(); LINESTART(); } if( __nFlags & 0x00FF4000 ) { ADDTEXT( " " ); // Layout flags: - ADDFLAG( 0x00004000, " fLONewPage" ); // undocumented - ADDFLAG( 0x00200000, " fLOReport" ); // undocumented - ADDFLAG( 0x00400000, " fLOBlankLine" ); // undocumented - ADDFLAG( 0x00800000, " fLOSubTotalTop" ); // undocumented + ADDFLAG( 0x00004000, "fLONewPage" ); // undocumented + ADDFLAG( 0x00200000, "fLOReport" ); // undocumented + ADDFLAG( 0x00400000, "fLOBlankLine" ); // undocumented + ADDFLAG( 0x00800000, "fLOSubTotalTop" ); // undocumented PRINT(); LINESTART(); } @@ -2308,7 +2311,7 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) LINESTART(); UINT16 __nFlags = Read2( rIn ); STARTFLAG(); - ADDFLAG( 0x0001, " fAuto" ); + ADDFLAG( 0x0001, "fAuto" ); ADDRESERVED( 0xFFFE ); UINT16 nCol1, nRow1, nCol2, nRow2; rIn >> nRow1 >> nRow2 >> nCol1 >> nCol2; @@ -2634,15 +2637,15 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) 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" ); + 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(); @@ -2676,40 +2679,40 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) 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" ); + 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" ); + 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" ); + 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(); @@ -2741,12 +2744,12 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) LINESTART(); rIn >> __nFlags; STARTFLAG(); - ADDFLAG( 0x0001, " fTitles" ); - ADDFLAG( 0x0002, " fRowNums" ); - ADDFLAG( 0x0004, " fDisRefr" ); - ADDFLAG( 0x0080, " fFill" ); - ADDFLAG( 0x0100, " fAutoFmt" ); - ADDFLAG( 0x0400, " fDisEdit" ); + ADDFLAG( 0x0001, "fTitles" ); + ADDFLAG( 0x0002, "fRowNums" ); + ADDFLAG( 0x0004, "fDisRefr" ); + ADDFLAG( 0x0080, "fFill" ); + ADDFLAG( 0x0100, "fAutoFmt" ); + ADDFLAG( 0x0400, "fDisEdit" ); ADDRESERVED( 0xFA78 ); PRINT(); LINESTART(); @@ -2809,7 +2812,7 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) rIn >> __nFlags; ADDTEXT( " " ); STARTFLAG(); - ADDFLAG( 0x0001, " fToughRecalc" ); + ADDFLAG( 0x0001, "fToughRecalc" ); ADDRESERVED( 0xFFFE ); PRINT(); LINESTART(); @@ -3017,9 +3020,9 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) __AddPureBin( t, __nFlags ); ADDTEXT( ")" ); ADDTEXT( "):" ); - ADDFLAG( 0x0001, " fWnClosed" ); - ADDFLAG( 0x0002, " fWnPinned" ); - ADDFLAG( 0x0004, " fCached" ); + ADDFLAG( 0x0001, "fWnClosed" ); + ADDFLAG( 0x0002, "fWnPinned" ); + ADDFLAG( 0x0004, "fCached" ); PRINT(); LINESTART(); ADDTEXT( "input window: " ); @@ -3051,11 +3054,11 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) if( __nFlags ) { ADDTEXT( " " ); - ADDFLAG( 0x00000080, " fStrLookup" ); - ADDFLAG( 0x00000100, " fAllowBlank" ); - ADDFLAG( 0x00000200, " fSuppressCombo" ); - ADDFLAG( 0x00040000, " fShowInputMsg" ); - ADDFLAG( 0x00080000, " fShowErrorMsg" ); + ADDFLAG( 0x00000080, "fStrLookup" ); + ADDFLAG( 0x00000100, "fAllowBlank" ); + ADDFLAG( 0x00000200, "fSuppressCombo" ); + ADDFLAG( 0x00040000, "fShowInputMsg" ); + ADDFLAG( 0x00080000, "fShowErrorMsg" ); } PRINT(); LINESTART(); @@ -3170,12 +3173,12 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) UINT32 __nFlags = Read4( rIn ); LINESTART(); STARTFLAG(); - ADDFLAG( 0x00000001, " fBody" ); - ADDFLAG( 0x00000002, " fAbs" ); - ADDFLAG( 0x00000014, " fDescr" ); - ADDFLAG( 0x00000008, " fMark" ); - ADDFLAG( 0x00000080, " fFrame" ); - ADDFLAG( 0x00000100, " fUNC" ); + ADDFLAG( 0x00000001, "fBody" ); + ADDFLAG( 0x00000002, "fAbs" ); + ADDFLAG( 0x00000014, "fDescr" ); + ADDFLAG( 0x00000008, "fMark" ); + ADDFLAG( 0x00000080, "fFrame" ); + ADDFLAG( 0x00000100, "fUNC" ); ADDRESERVED( 0xFFFFFE60 ); PRINT(); @@ -3347,10 +3350,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) STARTFLAG(); ADDTEXT( " outlnlev=" ); __AddDec( t, (UINT16)(__nFlags & 0x0007) ); - ADDFLAG( 0x0010, " fCollapsed" ); - ADDFLAG( 0x0020, " fRowHeightZero" ); - ADDFLAG( 0x0040, " fUnsynced" ); - ADDFLAG( 0x0080, " fGhostDirty" ); + ADDFLAG( 0x0010, "fCollapsed" ); + ADDFLAG( 0x0020, "fRowHeightZero" ); + ADDFLAG( 0x0040, "fUnsynced" ); + ADDFLAG( 0x0080, "fGhostDirty" ); ADDRESERVED( 0xFF08 ); PRINT(); UINT16 nXF; @@ -3359,8 +3362,8 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) ADDTEXT( "ix to XF: " ); __AddDec( t, (UINT16)(nXF & 0x0FFF) ); ADDTEXT( " add. flags(" ); __AddHex( t, nXF ); ADDTEXT( "):" ); - ADDFLAG( 0x1000, " fExAsc" ); - ADDFLAG( 0x2000, " fExDsc" ); + ADDFLAG( 0x1000, "fExAsc" ); + ADDFLAG( 0x2000, "fExDsc" ); ADDRESERVED( 0xC000 ); PRINT(); } @@ -3378,8 +3381,8 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) PRINT(); LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fAlwaysCalc" ); - ADDFLAG( 0x0002, " fCalcOnLoad" ); + ADDFLAG( 0x0001, "fAlwaysCalc" ); + ADDFLAG( 0x0002, "fCalcOnLoad" ); ADDRESERVED( 0xFFFC ); PRINT(); LINESTART(); @@ -3399,10 +3402,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) LINESTART(); ADDTEXT( "default row " ); STARTFLAG(); - ADDFLAG( 0x0001, " fUnsynced" ); - ADDFLAG( 0x0002, " fRowHtZero" ); - ADDFLAG( 0x0004, " fExAsc" ); - ADDFLAG( 0x0008, " fExDsc" ); + ADDFLAG( 0x0001, "fUnsynced" ); + ADDFLAG( 0x0002, "fRowHtZero" ); + ADDFLAG( 0x0004, "fExAsc" ); + ADDFLAG( 0x0008, "fExDsc" ); ADDRESERVED( 0xFFF0 ); PRINT(); LINESTART(); @@ -3466,17 +3469,17 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) LINESTART(); rIn >> __nFlags; STARTFLAG(); - ADDFLAG( 0x0001, " fImportPRE" ); - ADDFLAG( 0x0002, " fIgnoreSep" ); - ADDFLAG( 0x0004, " fUseSetting" ); - ADDFLAG( 0x0010, " fIgnoreDate" ); - ADDFLAG( 0x0020, " fWhatIsIt?" ); + 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" ); + ADDFLAG( 0x0002, "fTables" ); ADDRESERVED( 0xFFFD ); PRINT(); LINESTART(); @@ -3558,14 +3561,14 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) STARTFLAG(); if( __nFlags ) { - ADDFLAG( 0x00000001, " fWin" ); - ADDFLAG( 0x00000002, " fRisc" ); - ADDFLAG( 0x00000004, " fBeta" ); - ADDFLAG( 0x00000008, " fWinAny" ); - ADDFLAG( 0x00000010, " fMacAny" ); - ADDFLAG( 0x00000020, " fBetaAny" ); - ADDFLAG( 0x00000100, " fRiscAny" ); - ADDFLAG( 0xFFFFE0C0, " fXxxxxxx" ); + ADDFLAG( 0x00000001, "fWin" ); + ADDFLAG( 0x00000002, "fRisc" ); + ADDFLAG( 0x00000004, "fBeta" ); + ADDFLAG( 0x00000008, "fWinAny" ); + ADDFLAG( 0x00000010, "fMacAny" ); + ADDFLAG( 0x00000020, "fBetaAny" ); + ADDFLAG( 0x00000100, "fRiscAny" ); + ADDRESERVED( 0xFFFFE0C0 ); } PRINT(); @@ -3659,8 +3662,8 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fAuto" ); - ADDFLAG( 0x0004, " fDrawTick" ); + ADDFLAG( 0x0001, "fAuto" ); + ADDFLAG( 0x0004, "fDrawTick" ); PRINT(); } LINESTART(); @@ -3700,9 +3703,9 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fAuto" ); - ADDFLAG( 0x0010, " fNoBackg" ); - ADDFLAG( 0x0020, " fNoFore" ); + ADDFLAG( 0x0001, "fAuto" ); + ADDFLAG( 0x0010, "fNoBackg" ); + ADDFLAG( 0x0020, "fNoFore" ); ADDRESERVED( 0xFFCE ); PRINT(); } @@ -3735,8 +3738,8 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x01, " fAuto" ); - ADDFLAG( 0x02, " fInvertNeg" ); + ADDFLAG( 0x01, "fAuto" ); + ADDFLAG( 0x02, "fInvertNeg" ); PRINT(); } } @@ -3768,7 +3771,7 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fVaried" ); + ADDFLAG( 0x0001, "fVaried" ); PRINT(); } LINESTART(); @@ -3819,12 +3822,12 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x01, " fAutoPosition" ); - ADDFLAG( 0x02, " fAutoSeries" ); - ADDFLAG( 0x04, " fAutoPosX" ); - ADDFLAG( 0x08, " fAutoPosY" ); - ADDFLAG( 0x10, " fVert" ); - ADDFLAG( 0x20, " fWasDataTable" ); + ADDFLAG( 0x01, "fAutoPosition" ); + ADDFLAG( 0x02, "fAutoSeries" ); + ADDFLAG( 0x04, "fAutoPosX" ); + ADDFLAG( 0x08, "fAutoPosY" ); + ADDFLAG( 0x10, "fVert" ); + ADDFLAG( 0x20, "fWasDataTable" ); PRINT(); } } @@ -3845,10 +3848,10 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fTranspose" ); - ADDFLAG( 0x0002, " fStacked" ); - ADDFLAG( 0x0004, " f100" ); - ADDFLAG( 0x0008, " fHasShadow" ); + ADDFLAG( 0x0001, "fTranspose" ); + ADDFLAG( 0x0002, "fStacked" ); + ADDFLAG( 0x0004, "f100" ); + ADDFLAG( 0x0008, "fHasShadow" ); PRINT(); } } @@ -3938,9 +3941,9 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fAutoCol" ); - ADDFLAG( 0x0002, " fAutoBack" ); - ADDFLAG( 0x0020, " fAutoRot" ); + ADDFLAG( 0x0001, "fAutoCol" ); + ADDFLAG( 0x0002, "fAutoBack" ); + ADDFLAG( 0x0020, "fAutoRot" ); PRINT(); } LINESTART(); @@ -3969,14 +3972,14 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { 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" ); + ADDFLAG( 0x0001, "fAutoMin" ); + ADDFLAG( 0x0002, "fAutoMax" ); + ADDFLAG( 0x0004, "fAutoMajor" ); + ADDFLAG( 0x0008, "fAutoMinor" ); + ADDFLAG( 0x0010, "fAutoCross" ); + ADDFLAG( 0x0020, "fLogScale" ); + ADDFLAG( 0x0040, "fReverse" ); + ADDFLAG( 0x0080, "fMaxCross" ); PRINT(); } } @@ -3998,9 +4001,9 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fBetween" ); - ADDFLAG( 0x0002, " fMaxCross" ); - ADDFLAG( 0x0004, " fReverse" ); + ADDFLAG( 0x0001, "fBetween" ); + ADDFLAG( 0x0002, "fMaxCross" ); + ADDFLAG( 0x0004, "fReverse" ); PRINT(); } } @@ -4092,18 +4095,18 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { 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" ); + 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(); @@ -4171,8 +4174,8 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x01, " fAutoSize" ); - ADDFLAG( 0x02, " fAutoPosition" ); + ADDFLAG( 0x01, "fAutoSize" ); + ADDFLAG( 0x02, "fAutoPosition" ); PRINT(); } } @@ -4310,7 +4313,7 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x01, " fCustomIfmt" ); + ADDFLAG( 0x01, "fCustomIfmt" ); PRINT(); } LINESTART(); @@ -4410,14 +4413,14 @@ void Biff8RecDumper::RecDump( BOOL bSubStream ) { LINESTART(); STARTFLAG(); - ADDFLAG( 0x0001, " fAutiMin" ); - ADDFLAG( 0x0002, " fAutoMax" ); - ADDFLAG( 0x0004, " fAutoMajor" ); - ADDFLAG( 0x0008, " fAutoMinor" ); - ADDFLAG( 0x0010, " fDateAxis" ); - ADDFLAG( 0x0020, " fAutoBase" ); - ADDFLAG( 0x0040, " fAutoCross" ); - ADDFLAG( 0x0080, " fAutoDate" ); + 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(); } } @@ -4911,9 +4914,9 @@ void Biff8RecDumper::ObjDump( const ULONG nMaxLen ) { ADDTEXT( " " ); STARTFLAG(); - ADDFLAG( 0x0008, " fAsSymbol" ); - ADDFLAG( 0x0002, " fLinked" ); - ADDFLAG( 0x0001, " f1???" ); + ADDFLAG( 0x0008, "fAsSymbol" ); + ADDFLAG( 0x0002, "fLinked" ); + ADDFLAG( 0x0001, "f1???" ); } } break; @@ -4924,12 +4927,12 @@ void Biff8RecDumper::ObjDump( const ULONG nMaxLen ) rIn >> nFmlaLen; if ( sizeof(nFmlaLen) + nFmlaLen == nL ) { - ADDTEXT( "linked\n OLE stream: LNK........ (ID in EXTERNNAME of SUPBOOK)\n XTI: " ); - IGNORE(7); - ADDHEX(2); - ADDTEXT( " Externname: " ); - ADDHEX(2); - IGNORE(3); // MAY be right + ADDTEXT( "linked\n OLE stream: LNK??? (from EXTERNNAME) " ); + rIn >> nFmlaLen; + ADDTEXT( " unknown=" ); ADDHEX( 4 ); + PRINT(); + t.Erase(); + FormulaDump( nFmlaLen, FT_CellFormula ); } else { @@ -4945,22 +4948,20 @@ void Biff8RecDumper::ObjDump( const ULONG nMaxLen ) ADDTEXT( '\n' ); if ( nBytesLeft < 4 ) ADDTEXT( " >> ByteString OVERRUN <<\n" ); - else if ( nBytesLeft == 5 ) + + rIn.Seek( nPos1 + sizeof(nFmlaLen) + nFmlaLen ); + if( rIn.GetRecLeft() == 4 ) { - ADDTEXT( " pad byte " ); - ADDHEX(1); - ADDTEXT( '\n' ); + ADDTEXT( " OLE storage name: MBD" ); + __AddPureHex( t, rIn.ReaduInt32() ); } - else if ( nBytesLeft == 4 ) - ADDTEXT( " no pad byte\n" ); else - ADDTEXT( " oops.. bytes left?!?\n" ); - - ADDTEXT( " OLE stream: MBD" ); - rIn.Seek( nPos1 + sizeof(nFmlaLen) + nFmlaLen ); - UINT32 nOleId; - rIn >> nOleId; - __AddPureHex( t, nOleId ); + { + ADDTEXT( " Ctls stream data: start=" ); + ADDHEX( 4 ); + ADDTEXT( " size=" ); + ADDHEX( 4 ); + } } } break; @@ -5027,12 +5028,10 @@ void Biff8RecDumper::ObjDump( const ULONG nMaxLen ) } -#undef ADDFLAG #undef LINESTART #undef IGNORE #undef ADDHEX #undef ADDDEC -#undef ADDTEXT #undef ADDCOLROW #undef PRINT #undef PreDump @@ -5206,409 +5205,396 @@ void Biff8RecDumper::ContDumpStream( SvStream& rStrm, const ULONG nL ) struct XclDumpFunc { const sal_Char* pName; /// Name of the function. - sal_uInt16 nIndex; /// Excel built-in function index. sal_uInt16 nParam; /// Parameter count for fixed functions. }; const XclDumpFunc pFuncData[] = { - { "COUNT", 0, 0 }, - { "IF", 1, 0 }, - { "ISNA", 2, 1 }, - { "ISERROR", 3, 1 }, - { "SUM", 4, 0 }, - { "AVERAGE", 5, 0 }, - { "MIN", 6, 0 }, - { "MAX", 7, 0 }, - { "ROW", 8, 0 }, - { "COLUMN", 9, 0 }, - { "NA", 10, 0 }, - { "NPV", 11, 0 }, - { "STDEV", 12, 0 }, - { "DOLLAR", 13, 0 }, - { "FIXED", 14, 0 }, - { "SIN", 15, 1 }, - { "COS", 16, 1 }, - { "TAN", 17, 1 }, - { "ATAN", 18, 1 }, - { "PI", 19, 0 }, - { "SQRT", 20, 1 }, - { "EXP", 21, 1 }, - { "LN", 22, 1 }, - { "LOG10", 23, 1 }, - { "ABS", 24, 1 }, - { "INT", 25, 1 }, - { "SIGN", 26, 1 }, - { "ROUND", 27, 2 }, - { "LOOKUP", 28, 0 }, - { "INDEX", 29, 0 }, - { "REPT", 30, 2 }, - { "MID", 31, 3 }, - { "LEN", 32, 1 }, - { "VALUE", 33, 1 }, - { "TRUE", 34, 0 }, - { "FALSE", 35, 0 }, - { "AND", 36, 0 }, - { "OR", 37, 0 }, - { "NOT", 38, 1 }, - { "MOD", 39, 2 }, - { "DCOUNT", 40, 3 }, - { "DSUM", 41, 3 }, - { "DAVERAGE", 42, 3 }, - { "DMIN", 43, 3 }, - { "DMAX", 44, 3 }, - { "DSTDEV", 45, 3 }, - { "VAR", 46, 0 }, - { "DVAR", 47, 3 }, - { "TEXT", 48, 2 }, - { "LINEST", 49, 0 }, - { "TREND", 50, 0 }, - { "LOGEST", 51, 0 }, - { "GROWTH", 52, 0 }, - { "GOTO", 53 }, // macro/internal - { "HALT", 54 }, // macro/internal - { "RETURN", 55 }, // macro/internal - { "PV", 56, 0 }, - { "FV", 57, 0 }, - { "NPER", 58, 0 }, - { "PMT", 59, 0 }, - { "RATE", 60, 0 }, - { "MIRR", 61, 3 }, - { "IRR", 62, 0 }, - { "RAND", 63, 0 }, - { "MATCH", 64, 0 }, - { "DATE", 65, 3 }, - { "TIME", 66, 3 }, - { "DAY", 67, 1 }, - { "MONTH", 68, 1 }, - { "YEAR", 69, 1 }, - { "WEEKDAY", 70, 0 }, - { "HOUR", 71, 1 }, - { "MINUTE", 72, 1 }, - { "SECOND", 73, 1 }, - { "NOW", 74, 0 }, - { "AREAS", 75, 1 }, - { "ROWS", 76, 1 }, - { "COLUMNS", 77, 1 }, - { "OFFSET", 78, 0 }, - { "ABSREF", 79 }, // macro/internal - { "RELREF", 80 }, // macro/internal - { "ARGUMENT", 81 }, // macro/internal - { "SEARCH", 82, 0 }, - { "TRANSPOSE", 83, 1 }, - { "ERROR", 84 }, // macro/internal - { "STEP", 85 }, // macro/internal - { "TYPE", 86, 1 }, - { "ECHO", 87 }, // macro/internal - { "SET.NAME", 88 }, // macro/internal - { "CALLER", 89 }, // macro/internal - { "DEREF", 90 }, // macro/internal - { "WINDOWS", 91 }, // macro/internal - { "SERIES", 92 }, // macro/internal - { "DOCUMENTS", 93 }, // macro/internal - { "ACTIVE.CELL", 94 }, // macro/internal - { "SELECTION", 95 }, // macro/internal - { "RESULT", 96 }, // macro/internal - { "ATAN2", 97, 2 }, - { "ASIN", 98, 1 }, - { "ACOS", 99, 1 }, - { "CHOSE", 100, 0 }, - { "HLOOKUP", 101, 0 }, - { "VLOOKUP", 102, 0 }, - { "LINKS", 103 }, // macro/internal - { "INPUT", 104 }, // macro/internal - { "ISREF", 105, 1 }, - { "GET.FORMULA", 106 }, // macro/internal - { "GET.NAME", 107 }, // macro/internal - { "SET.VALUE", 108, 2 }, // macro/internal - { "LOG", 109, 0 }, - { "EXEC", 110 }, // macro/internal - { "CHAR", 111, 1 }, - { "LOWER", 112, 1 }, - { "UPPER", 113, 1 }, - { "PROPER", 114, 1 }, - { "LEFT", 115, 0 }, - { "RIGHT", 116, 0 }, - { "EXACT", 117, 2 }, - { "TRIM", 118, 1 }, - { "REPLACE", 119, 4 }, - { "SUBSTITUTE", 120, 0 }, - { "CODE", 121, 1 }, - { "NAMES", 122 }, // macro/internal - { "DIRECTORY", 123 }, // macro/internal - { "FIND", 124, 0 }, - { "CELL", 125, 0 }, - { "ISERR", 126, 1 }, - { "ISTEXT", 127, 1 }, - { "ISNUMBER", 128, 1 }, - { "ISBLANK", 129, 1 }, - { "T", 130, 1 }, - { "N", 131, 1 }, - { "FOPEN", 132 }, // macro/internal - { "FCLOSE", 133 }, // macro/internal - { "FSIZE", 134 }, // macro/internal - { "FREADLN", 135 }, // macro/internal - { "FREAD", 136 }, // macro/internal - { "FWRITELN", 137 }, // macro/internal - { "FWRITE", 138 }, // macro/internal - { "FPOS", 139 }, // macro/internal - { "DATEVALUE", 140, 1 }, - { "TIMEVALUE", 141, 1 }, - { "SLN", 142, 3 }, - { "SYD", 143, 4 }, - { "DDB", 144, 0 }, - { "GET.DEF", 145 }, // macro/internal - { "REFTEXT", 146 }, // macro/internal - { "TEXTREF", 147 }, // macro/internal - { "INDIRECT", 148, 0 }, - { "REGISTER", 149 }, // macro/internal - { "CALL", 150 }, // macro/internal - { "ADD.BAR", 151 }, // macro/internal - { "ADD.MENU", 152 }, // macro/internal - { "ADD.COMMAND", 153 }, // macro/internal - { "ENABLE.COMMAND", 154 }, // macro/internal - { "CHECK.COMMAND", 155 }, // macro/internal - { "RENAME.COMMAND", 156 }, // macro/internal - { "SHOW.BAR", 157 }, // macro/internal - { "DELETE.MENU", 158 }, // macro/internal - { "DELETE.COMMAND", 159 }, // macro/internal - { "GET.CHART.ITEM", 160 }, // macro/internal - { "DIALOG.BOX", 161 }, // macro/internal - { "CLEAN", 162, 1 }, - { "MDETERM", 163, 1 }, - { "MINVERSE", 164, 1 }, - { "MMULT", 165, 2 }, - { "FILES", 166 }, // macro/internal - { "IPMT", 167, 0 }, - { "PPMT", 168, 0 }, - { "COUNTA", 169, 0 }, - { "CANCEL.KEY", 170 }, // macro/internal - { "FOR", 171 }, // macro/internal - { "WHILE", 172 }, // macro/internal - { "BREAK", 173 }, // macro/internal - { "NEXT", 174 }, // macro/internal - { "INITIATE", 175 }, // macro/internal - { "REQUEST", 176 }, // macro/internal - { "POKE", 177 }, // macro/internal - { "EXECUTE", 178 }, // macro/internal - { "TERMINATE", 179 }, // macro/internal - { "RESTART", 180 }, // macro/internal - { "HELP", 181 }, // macro/internal - { "GET.BAR", 182 }, // macro/internal - { "PRODUCT", 183, 0 }, - { "FACT", 184, 1 }, - { "GET.CELL", 185 }, // macro/internal - { "GET.WORKSPACE", 186 }, // macro/internal - { "GET.WINDOW", 187 }, // macro/internal - { "GET.DOCUMENT", 188 }, // macro/internal - { "DPRODUCT", 189, 3 }, - { "ISNONTEXT", 190, 1 }, - { "GET.NOTE", 191 }, // macro/internal - { "NOTE", 192 }, // macro/internal - { "STDEVP", 193, 0 }, - { "VARP", 194, 0 }, - { "DSTDDEVP", 195, 3 }, - { "DVARP", 196, 3 }, - { "TRUNC", 197, 0 }, - { "ISLOGICAL", 198, 1 }, - { "DBCOUNTA", 199, 3 }, - { "DELETE.BAR", 200 }, // macro/internal - { "UNREGISTER", 201 }, // macro/internal - { "202", 202 }, // not used - { "203", 203 }, // not used - { "USDOLLAR", 204 }, // macro/internal - { "FINDB", 205 }, // macro/internal - { "SEARCHB", 206 }, // macro/internal - { "REPLACEB", 207 }, // macro/internal - { "LEFTB", 208 }, // macro/internal - { "RIGHTB", 209 }, // macro/internal - { "MIDB", 210 }, // macro/internal - { "LENB", 211 }, // macro/internal - { "ROUNDUP", 212, 2 }, - { "ROUNDDOWN", 213, 2 }, - { "ASC", 214 }, // macro/internal - { "DBSC", 215 }, // macro/internal - { "RANK", 216, 0 }, - { "217", 217 }, // not used - { "218", 218 }, // not used - { "ADDRESS", 219, 0 }, - { "DAYS360", 220, 0 }, - { "TODAY", 221, 0 }, - { "VDB", 222, 0 }, - { "ELSE", 223 }, // macro/internal - { "ELSE.IF", 224 }, // macro/internal - { "END.IF", 225 }, // macro/internal - { "FOR.CELL", 226 }, // macro/internal - { "MEDIAN", 227, 0 }, - { "SUMPRODUCT", 228, 0 }, - { "SINH", 229, 1 }, - { "COSH", 230, 1 }, - { "TANH", 231, 1 }, - { "ASINH", 232, 1 }, - { "ACOSH", 233, 1 }, - { "ATANH", 234, 1 }, - { "DGET", 235, 3 }, - { "CREATE.OBJECT", 236 }, // macro/internal - { "VOLATILE", 237 }, // macro/internal - { "LAST.ERROR", 238 }, // macro/internal - { "CUSTOM.UNDO", 239 }, // macro/internal - { "CUSTOM.REPEAT", 240 }, // macro/internal - { "FORMULA.CONVERT", 241 }, // macro/internal - { "GET.LINK.INFO", 242 }, // macro/internal - { "TEXT.BOX", 243 }, // macro/internal - { "INFO", 244 }, // macro/internal - { "GROUP", 245 }, // macro/internal - { "GET.OBJECT", 246 }, // macro/internal - { "DB", 247, 0 }, - { "PAUSE", 248 }, // macro/internal - { "249", 249 }, // not used - { "250", 250 }, // not used - { "RESUME", 251 }, // macro/internal - { "FREQUENCY", 252, 2 }, - { "ADD.TOOLBAR", 253 }, // macro/internal - { "DELETE.TOOLBAR", 254 }, // macro/internal - { "EXTERNCALL", 255 }, // macro/internal - { "RESET.TOOLBAR", 256 }, // macro/internal - { "EVALUATE", 257 }, // macro/internal - { "GET.TOOLBAR", 258 }, // macro/internal - { "GET.TOOL", 259 }, // macro/internal - { "SPELLING.CHECK", 260 }, // macro/internal - { "ERROR.TYPE", 261, 1 }, - { "APP.TITLE", 262 }, // macro/internal - { "WINDOW.TITLE", 263 }, // macro/internal - { "SAVE.TOOLBAR", 264 }, // macro/internal - { "ENABLE.TOOL", 265 }, // macro/internal - { "PRESS.TOOL", 266 }, // macro/internal - { "REGISTER.ID", 267 }, // macro/internal - { "GET.WORKBOOK", 268 }, // macro/internal - { "AVEDEV", 269, 0 }, - { "BETADIST", 270, 0 }, - { "GAMMALN", 271, 1 }, - { "BETAINV", 272, 0 }, - { "BINOMDIST", 273, 4 }, - { "CHIDIST", 274, 2 }, - { "CHIINV", 275, 2 }, - { "COMBIN", 276, 2 }, - { "CONFIDENCE", 277, 3 }, - { "CRITBINOM", 278, 3 }, - { "EVEN", 279, 1 }, - { "EXPONDIST", 280, 3 }, - { "FDIST", 281, 3 }, - { "FINV", 282, 3 }, - { "FISHER", 283, 1 }, - { "FISHERINV", 284, 1 }, - { "FLOOR", 285, 2 }, - { "GAMMADIST", 286, 4 }, - { "GAMMAINV", 287, 3 }, - { "CEILING", 288, 2 }, - { "HYPGEOMDIST", 289, 4 }, - { "LOGNORMDIST", 290, 3 }, - { "LOGINV", 291, 3 }, - { "NEGBINOMDIST", 292, 3 }, - { "NORMDIST", 293, 4 }, - { "NORMSDIST", 294, 1 }, - { "NORMINV", 295, 3 }, - { "NORMSINV", 296, 1 }, - { "STANDARDIZE", 297, 3 }, - { "ODD", 298, 1 }, - { "PERMUT", 299, 2 }, - { "POISSON", 300, 3 }, - { "TDIST", 301, 3 }, - { "WEIBULL", 302, 4 }, - { "SUMXMY2", 303, 2 }, - { "SUMX2MY2", 304, 2 }, - { "SUMX2PY2", 305, 2 }, - { "CHITEST", 306, 2 }, - { "CORREL", 307, 2 }, - { "COVAR", 308, 2 }, - { "FORECAST", 309, 3 }, - { "FTEST", 310, 2 }, - { "INTERCEPT", 311, 2 }, - { "PEARSON", 312, 2 }, - { "RSQ", 313, 2 }, - { "STEYX", 314, 2 }, - { "SLOPE", 315, 2 }, - { "TTEST", 316, 4 }, - { "PROB", 317, 0 }, - { "DEVSQ", 318, 0 }, - { "GEOMEAN", 319, 0 }, - { "HARMEAN", 320, 0 }, - { "SUMSQ", 321, 0 }, - { "KURT", 322, 0 }, - { "SKEW", 323, 0 }, - { "ZTEST", 324, 0 }, - { "LARGE", 325, 2 }, - { "SMALL", 326, 2 }, - { "QUARTILE", 327, 2 }, - { "PERCENTILE", 328, 2 }, - { "PERCENTRANK", 329, 0 }, - { "MODE", 330, 0 }, - { "TRIMMEAN", 331, 2 }, - { "TINV", 332, 2 }, - { "333", 333 }, // not used - { "MOVIE.COMMAND", 334 }, // macro/internal - { "GET.MOVIE", 335 }, // macro/internal - { "CONCATENATE", 336, 0 }, - { "POWER", 337, 2 }, - { "PIVOT.ADD.DATA", 338 }, // macro/internal - { "GET.PIVOT.TABLE", 339 }, // macro/internal - { "GET.PIVOT.FIELD", 340 }, // macro/internal - { "GET.PIVOT.ITEM", 341 }, // macro/internal - { "RADIANS", 342, 1 }, - { "DEGREES", 343, 1 }, - { "SUBTOTAL", 344, 0 }, - { "SUMIF", 345, 0 }, - { "COUNTIF", 346, 2 }, - { "COUNTBLANK", 347, 1 }, - { "SCENARIO.GET", 348 }, // macro/internal - { "OPTIONS.LISTS.GET",349 }, // macro/internal - { "ISPMT", 350, 4 }, - { "DATEDIF", 351 }, // macro/internal - { "DATESTRING", 352 }, // macro/internal - { "NUMBERSTRING", 353 }, // macro/internal - { "ROMAN", 354, 0 }, - { "OPEN.DIALOG", 355 }, // macro/internal - { "SAVE.DIALOG", 356 }, // macro/internal - { "VIEW.GET", 357 }, // macro/internal - { "GETPIVOTDATA", 358, 0 }, - { "HYPERLINK", 359, 2 }, - { "PHONETIC", 360 }, // macro/internal - { "AVERAGEA", 361, 0 }, - { "MAXA", 362, 0 }, - { "MINA", 363, 0 }, - { "STDEVPA", 364, 0 }, - { "VARPA", 365, 0 }, - { "STDEVA", 366, 0 }, - { "VARA", 367, 0 }, - { "BAHTTEXT", 368, 1 }, - { "THAIDAYOFWEEK", 369 }, // macro/internal - { "THAIDIGIT", 370 }, // macro/internal - { "THAIMONTHOFYEAR", 371 }, // macro/internal - { "THAINUMSOUND", 372 }, // macro/internal - { "THAINUMSTRING", 373 }, // macro/internal - { "THAISTRINGLENGTH", 374 }, // macro/internal - { "ISTHAIDIGIT", 375 }, // macro/internal - { "ROUNDBAHTDOWN", 376 }, // macro/internal - { "ROUNDBAHTUP", 377 }, // macro/internal - { "THAIYEAR", 378 }, // macro/internal - { "RTD", 379 } // macro/internal +/* 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*/ { "CHOSE", 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" }, // macro/internal + { "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" }, // macro/internal +/*205*/ { "FINDB" }, // macro/internal + { "SEARCHB" }, // macro/internal + { "REPLACEB" }, // macro/internal + { "LEFTB" }, // macro/internal + { "RIGHTB" }, // macro/internal +/*210*/ { "MIDB" }, // macro/internal + { "LENB" }, // macro/internal + { "ROUNDUP", 2 }, + { "ROUNDDOWN", 2 }, + { "ASC" }, // macro/internal +/*215*/ { "DBSC" }, // macro/internal + { "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" }, // macro/internal +/*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" }, // macro/internal + { "DATESTRING" }, // macro/internal + { "NUMBERSTRING" }, // macro/internal + { "ROMAN", 0 }, +/*355*/ { "OPEN.DIALOG" }, // macro/internal + { "SAVE.DIALOG" }, // macro/internal + { "VIEW.GET" }, // macro/internal + { "GETPIVOTDATA", 0 }, + { "HYPERLINK", 2 }, +/*360*/ { "PHONETIC" }, // macro/internal + { "AVERAGEA", 0 }, + { "MAXA", 0 }, + { "MINA", 0 }, + { "STDEVPA", 0 }, +/*365*/ { "VARPA", 0 }, + { "STDEVA", 0 }, + { "VARA", 0 }, + { "BAHTTEXT", 1 }, + { "THAIDAYOFWEEK" }, // macro/internal +/*370*/ { "THAIDIGIT" }, // macro/internal + { "THAIMONTHOFYEAR" }, // macro/internal + { "THAINUMSOUND" }, // macro/internal + { "THAINUMSTRING" }, // macro/internal + { "THAISTRINGLENGTH" }, // macro/internal +/*375*/ { "ISTHAIDIGIT" }, // macro/internal + { "ROUNDBAHTDOWN" }, // macro/internal + { "ROUNDBAHTUP" }, // macro/internal + { "THAIYEAR" }, // macro/internal + { "RTD" } // macro/internal }; const XclDumpFunc* lcl_GetFuncData( sal_uInt16 nIndex ) { - const XclDumpFunc* pFirst = pFuncData; - const XclDumpFunc* pLast = pFuncData + sizeof( pFuncData ) / sizeof( XclDumpFunc ) - 1; - while( pFirst <= pLast ) - { - const XclDumpFunc* pCurr = pFirst + (pLast - pFirst) / 2; - if( pCurr->nIndex > nIndex ) - pLast = pCurr - 1; - else if( pCurr->nIndex < nIndex ) - pFirst = pCurr + 1; - else - return pCurr; - } - return NULL; + return (nIndex < STATIC_TABLE_SIZE( pFuncData )) ? (pFuncData + nIndex) : NULL; } @@ -5985,7 +5971,7 @@ void Biff8RecDumper::FormulaDump( const UINT16 nL, const FORMULA_TYPE eFT ) break; case 0x1D: // Boolean [315 266] STARTTOKEN( "Bool" ); - aOperand += pIn->ReaduInt8() ? "FALSE" : "TRUE"; + aOperand += pIn->ReaduInt8() ? "TRUE" : "FALSE"; t += aOperand; aStack.PushOperand( aOperand ); break; @@ -6246,26 +6232,438 @@ void Biff8RecDumper::FormulaDump( const UINT16 nL, const FORMULA_TYPE eFT ) } -void Biff8RecDumper::ControlsDump( SvStream& rIn ) + + +/** Import from bytestream. */ +SvStream& operator>>( SvStream& rStrm, XclGuid& rGuid ) { - if( !pDumpStream ) - return; + rStrm.Read( rGuid.mpData, 16 ); + return rStrm; +} - rIn.Seek( STREAM_SEEK_TO_END ); - ULONG nLen = rIn.Tell(); - rIn.Seek( STREAM_SEEK_TO_BEGIN ); +/** Output as text. */ +SvStream& operator<<( SvStream& rStrm, const XclGuid& rGuid ) +{ + ByteString aOut; + __AddPureHex( aOut, SVBT32ToLong( rGuid.mpData ) ); + aOut.Append( '-' ); + __AddPureHex( aOut, SVBT16ToShort( rGuid.mpData + 4 ) ); + aOut.Append( '-' ); + __AddPureHex( aOut, SVBT16ToShort( rGuid.mpData + 6 ) ); + aOut.Append( '-' ); + __AddPureHex( aOut, rGuid.mpData[ 8 ] ); + __AddPureHex( aOut, rGuid.mpData[ 9 ] ); + aOut.Append( '-' ); + __AddPureHex( aOut, rGuid.mpData[ 10 ] ); + __AddPureHex( aOut, rGuid.mpData[ 11 ] ); + __AddPureHex( aOut, rGuid.mpData[ 12 ] ); + __AddPureHex( aOut, rGuid.mpData[ 13 ] ); + __AddPureHex( aOut, rGuid.mpData[ 14 ] ); + __AddPureHex( aOut, rGuid.mpData[ 15 ] ); + return rStrm << aOut.GetBuffer(); +} - if( nLen == ~0UL ) - return; +// *** yet some other ugly macros for the specials of form control dumping *** + +// align the instream +#define EXC_CTRLDUMP_ALIGN_INSTRM( val ) rInStrm.Seek( (rInStrm.Tell()+(val)-1) & ~((val)-1) ) +// push the string to outstream +#define EXC_CTRLDUMP_PRINT() { if( t.Len() ) { rOutStrm << t.GetBuffer() << '\n'; t.Erase(); } } +#define EXC_CTRLDUMP_PRINTC() { if( t.Len() > 60 ) EXC_CTRLDUMP_PRINT(); } + +// implementation, don't use +#define IMPL_EXC_CTRLDUMP_VALUE( type, func, text ) { EXC_CTRLDUMP_ALIGN_INSTRM( sizeof( type ) ); type n; rInStrm >> n; t += " " text "="; func( t, n ); EXC_CTRLDUMP_PRINTC(); } +#define IMPL_EXC_CTRLDUMP_VAR( var, mask, func, text ) { EXC_CTRLDUMP_ALIGN_INSTRM( sizeof( var ) ); rInStrm >> var; var &= (mask); t += " " text "="; func( t, var ); EXC_CTRLDUMP_PRINTC(); } + +// read a value from stream +#define EXC_CTRLDUMP_HEX4( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_uInt32, __AddHex, text ) +#define EXC_CTRLDUMP_DEC4( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_Int32, __AddDec, text ) +#define EXC_CTRLDUMP_HEX2( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_uInt16, __AddHex, text ) +#define EXC_CTRLDUMP_DEC2( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_Int16, __AddDec, text ) +#define EXC_CTRLDUMP_HEX1( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_uInt8, __AddHex, text ) +#define EXC_CTRLDUMP_DEC1( text ) IMPL_EXC_CTRLDUMP_VALUE( sal_Int8, __AddDec, text ) +// read a value from stream into existing variable +#define EXC_CTRLDUMP_HEXVAR( var, text ) IMPL_EXC_CTRLDUMP_VAR( var, ~0, __AddHex, text ) +#define EXC_CTRLDUMP_DECVAR( var, text ) IMPL_EXC_CTRLDUMP_VAR( var, ~0, __AddDec, text ) +#define EXC_CTRLDUMP_HEXVARMASK( var, mask, text ) IMPL_EXC_CTRLDUMP_VAR( var, mask, __AddHex, text ) +#define EXC_CTRLDUMP_DECVARMASK( var, mask, text ) IMPL_EXC_CTRLDUMP_VAR( var, mask, __AddDec, text ) +// read a string +#define EXC_CTRLDUMP_STRING( var, text ) \ +if( var ) \ +{ \ + EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); \ + if( var > 128 ) var = 128; \ + sal_Char* p = new sal_Char[ var + 1 ]; \ + rInStrm.Read( p, var ); p[ var ] = '\0'; \ + t.Append( " " text "='" ).Append( p ).Append( '\'' ); \ + delete [] p; \ + EXC_CTRLDUMP_PRINTC(); \ +} +// read flag fields +#define EXC_CTRLDUMP_STARTFLAG( text ) { EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); rInStrm >> __nFlags; t += " " text "="; __AddHex( t, __nFlags ); } +#define EXC_CTRLDUMP_ADDFLAG( flag, text ) { if( __nFlags & (flag) ) t += " -" text; EXC_CTRLDUMP_PRINTC(); } +#define EXC_CTRLDUMP_ENDFLAG( reserved ) EXC_CTRLDUMP_ADDFLAG( reserved, "!unknown!" ) +// read coordinates +#define EXC_CTRLDUMP_COORD( text ) { EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); EXC_CTRLDUMP_DEC2( text "-x" ); EXC_CTRLDUMP_DEC2( "y" ); } +#define EXC_CTRLDUMP_SIZE() { EXC_CTRLDUMP_DEC4( "width" ); EXC_CTRLDUMP_DEC4( "height" ); } + +// *** macros end *** - *pDumpStream << "### start Ctls stream ###\n"; - while( nLen ) +void Biff8RecDumper::ControlsDump( SvStream& rInStrm ) +{ + static const XclGuid aPushButtonGuid( 0xD7053240, 0xCE69, 0x11CD, 0xA7, 0x77, 0x00, 0xDD, 0x01, 0x14, 0x3C, 0x57 ); + static const XclGuid aToggleButtonGuid( 0x8BD21D60, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 ); + static const XclGuid aCheckBoxGuid( 0x8BD21D40, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 ); + static const XclGuid aRadioButtonGuid( 0x8BD21D50, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 ); + static const XclGuid aLabelGuid( 0x978C9E23, 0xD4B0, 0x11CE, 0xBF, 0x2D, 0x00, 0xAA, 0x00, 0x3F, 0x40, 0xD0 ); + static const XclGuid aEditGuid( 0x8BD21D10, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 ); + static const XclGuid aListBoxGuid( 0x8BD21D20, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 ); + static const XclGuid aComboBoxGuid( 0x8BD21D30, 0xEC42, 0x11CE, 0x9E, 0x0D, 0x00, 0xAA, 0x00, 0x60, 0x02, 0xF3 ); + static const XclGuid aSpinGuid( 0x79176FB0, 0xB7F2, 0x11CE, 0x97, 0xEF, 0x00, 0xAA, 0x00, 0x6D, 0x27, 0x76 ); + static const XclGuid aScrollBarGuid( 0xDFD181E0, 0x5E2F, 0x11CE, 0xA4, 0x49, 0x00, 0xAA, 0x00, 0x4A, 0x80, 0x3D ); + + if( !pDumpStream ) return; + rInStrm.Seek( STREAM_SEEK_TO_END ); + sal_uInt32 nInSize = rInStrm.Tell(); + rInStrm.Seek( STREAM_SEEK_TO_BEGIN ); + if( nInSize == ~0UL ) return; + + SvStream& rOutStrm = *pDumpStream; + rOutStrm << "\n\n\n-- Ctls stream dump --\n"; + + enum { + xlCtrlPushButton, + xlCtrlToggleButton, + xlCtrlCheckBox, + xlCtrlRadioButton, + xlCtrlLabel, + xlCtrlEdit, + xlCtrlListBox, + xlCtrlComboBox, + xlCtrlSpin, + xlCtrlScrollBar, + xlCtrlUnknown + } eCtrlType = xlCtrlUnknown; + + while( rInStrm.Tell() < nInSize ) { - UINT16 nPart = ( nLen >= 1024 )? 1024 : ( UINT16 ) nLen; - ContDumpStream( rIn, nPart ); - nLen -= nPart; + ByteString t; // "t" needed for macros + sal_uInt32 __nFlags; // "__nFlags" needed for macros + sal_uInt16 nId, nSize; + sal_uInt32 nNextPos; + + // stream position + __AddHex( t, rInStrm.Tell() ); + rOutStrm << '\n' << t.GetBuffer() << ": "; + + // control type + XclGuid aGuid; + rInStrm >> aGuid >> nId >> nSize; + nNextPos = rInStrm.Tell() + nSize; + + if( aGuid == aPushButtonGuid ) eCtrlType = xlCtrlPushButton; + else if( aGuid == aToggleButtonGuid ) eCtrlType = xlCtrlToggleButton; + else if( aGuid == aCheckBoxGuid ) eCtrlType = xlCtrlCheckBox; + else if( aGuid == aRadioButtonGuid ) eCtrlType = xlCtrlRadioButton; + else if( aGuid == aLabelGuid ) eCtrlType = xlCtrlLabel; + else if( aGuid == aEditGuid ) eCtrlType = xlCtrlEdit; + else if( aGuid == aListBoxGuid ) eCtrlType = xlCtrlListBox; + else if( aGuid == aComboBoxGuid ) eCtrlType = xlCtrlComboBox; + else if( aGuid == aSpinGuid ) eCtrlType = xlCtrlSpin; + else if( aGuid == aScrollBarGuid ) eCtrlType = xlCtrlScrollBar; + else eCtrlType = xlCtrlUnknown; + + // write control type + rOutStrm << aGuid << " ("; + switch( eCtrlType ) + { + case xlCtrlPushButton: rOutStrm << "PushButton"; break; + case xlCtrlToggleButton: rOutStrm << "ToggleButton"; break; + case xlCtrlCheckBox: rOutStrm << "CheckBox"; break; + case xlCtrlRadioButton: rOutStrm << "RadioButton"; break; + case xlCtrlLabel: rOutStrm << "Label"; break; + case xlCtrlEdit: rOutStrm << "Edit"; break; + case xlCtrlListBox: rOutStrm << "ListBox"; break; + case xlCtrlComboBox: rOutStrm << "ComboBox"; break; + case xlCtrlSpin: rOutStrm << "Spin"; break; + case xlCtrlScrollBar: rOutStrm << "ScrollBar"; break; + default: rOutStrm << "*UNKNOWN*"; + } + rOutStrm << ")\n"; + + // control data + t = "id="; __AddHex( t, nId ); t += " size="; __AddHex( t, nSize ); + rOutStrm << t.GetBuffer() << " (control data)\n"; + t.Erase(); + + switch( eCtrlType ) + { + case xlCtrlPushButton: + { + sal_uInt32 nCaptionLen = 0; + + 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( 0x0040, "mouseptr" ); + EXC_CTRLDUMP_ADDFLAG( 0x0080, "pic" ); + EXC_CTRLDUMP_ADDFLAG( 0x0100, "accel" ); + EXC_CTRLDUMP_ADDFLAG( 0x0400, "icon" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFA00 ); // 0x20 always(?) + sal_uInt32 nCtrlFlags = __nFlags; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + if( nCtrlFlags & 0x0004 ) + { + EXC_CTRLDUMP_STARTFLAG( "option-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "backstyle" ); + 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_COORD( "picpos" ); + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_HEX2( "mouseptr" ); + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_HEX2( "pic-len" ); + if( nCtrlFlags & 0x0100 ) EXC_CTRLDUMP_HEX2( "accel" ); + if( nCtrlFlags & 0x0400 ) EXC_CTRLDUMP_HEX2( "icon-len" ); + EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + EXC_CTRLDUMP_SIZE(); + } + break; + case xlCtrlToggleButton: + case xlCtrlCheckBox: + case xlCtrlRadioButton: + case xlCtrlEdit: + case xlCtrlListBox: + case xlCtrlComboBox: + { + sal_uInt32 nCaptionLen = 0; + sal_uInt32 nValueLen = 0; + sal_uInt32 nGroupNameLen = 0; + + 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( 0x00000200, "password" ); + 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, "pos" ); + 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 ); // 0x80000100 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; + + if( nCtrlFlags & 0x00000001 ) + { + EXC_CTRLDUMP_STARTFLAG( "option-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "backstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000400, "colheads" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000800, "intheight" ); + EXC_CTRLDUMP_ADDFLAG( 0x00001000, "matchreq" ); + EXC_CTRLDUMP_ADDFLAG( 0x00002000, "align" ); + 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( 0x0307C3F1 ); + } + 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_HEX1( "password" ); + 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_COORD( "pos" ); + if( nCtrlFlags & 0x02000000 ) EXC_CTRLDUMP_HEX4( "bordercolor" ); + if( nCtrlFlags & 0x04000000 ) EXC_CTRLDUMP_DEC1( "specialeff" ); + if( nCtrlFlags & 0x08000000 ) EXC_CTRLDUMP_DEC2( "icon-len" ); + if( nCtrlFlags & 0x10000000 ) EXC_CTRLDUMP_DEC2( "pic-len" ); + if( nCtrlFlags & 0x20000000 ) EXC_CTRLDUMP_HEX1( "accel" ); + if( nCtrlFlags2 & 0x00000001 ) EXC_CTRLDUMP_DECVARMASK( nGroupNameLen, 0x7FFFFFFF, "groupname-len" ); + EXC_CTRLDUMP_SIZE(); + EXC_CTRLDUMP_STRING( nValueLen, "value" ); + EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + EXC_CTRLDUMP_STRING( nGroupNameLen, "groupname" ); + } + break; + case xlCtrlLabel: + { + sal_uInt32 nCaptionLen = 0; + + 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, "pos" ); + 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( 0xFFFFE020 ); + sal_uInt32 nCtrlFlags = __nFlags; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_HEX4( "forecolor" ); + if( nCtrlFlags & 0x0002 ) EXC_CTRLDUMP_HEX4( "backcolor" ); + if( nCtrlFlags & 0x0004 ) + { + EXC_CTRLDUMP_STARTFLAG( "option-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000002, "enabled" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000004, "locked" ); + EXC_CTRLDUMP_ADDFLAG( 0x00000008, "backstyle" ); + 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_COORD( "pos" ); + if( nCtrlFlags & 0x0040 ) EXC_CTRLDUMP_HEX2( "mouseptr" ); + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_HEX4( "bordercolor" ); + if( nCtrlFlags & 0x0100 ) EXC_CTRLDUMP_HEX2( "borderstyle" ); + if( nCtrlFlags & 0x0200 ) EXC_CTRLDUMP_HEX2( "specialleff" ); + if( nCtrlFlags & 0x0400 ) EXC_CTRLDUMP_HEX2( "pic-len" ); + if( nCtrlFlags & 0x0800 ) EXC_CTRLDUMP_HEX2( "accel" ); + if( nCtrlFlags & 0x1000 ) EXC_CTRLDUMP_HEX2( "icon-len" ); + EXC_CTRLDUMP_STRING( nCaptionLen, "caption" ); + EXC_CTRLDUMP_SIZE(); + } + break; + } + EXC_CTRLDUMP_PRINT(); + + EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); + if( rInStrm.Tell() < nNextPos ) + { + rOutStrm << " unknown data:"; + ContDumpStream( rInStrm, nNextPos - rInStrm.Tell() ); + rOutStrm << '\n'; + } + rInStrm.Seek( nNextPos ); + + // font data + rInStrm >> nId >> nSize; + if( nId == 0x0200 ) + { + nNextPos = rInStrm.Tell() + nSize; + + t = "id="; __AddHex( t, nId ); t += " size="; __AddHex( t, nSize ); + rOutStrm << t.GetBuffer() << " (font data)\n"; + t.Erase(); + + EXC_CTRLDUMP_STARTFLAG( "content-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x01, "fontname" ); + EXC_CTRLDUMP_ADDFLAG( 0x02, "fontstyle" ); + EXC_CTRLDUMP_ADDFLAG( 0x04, "fontsize" ); + EXC_CTRLDUMP_ADDFLAG( 0x10, "language-id" ); + EXC_CTRLDUMP_ADDFLAG( 0x40, "align" ); + EXC_CTRLDUMP_ADDFLAG( 0x80, "fontweight" ); + EXC_CTRLDUMP_ENDFLAG( 0xFFFFFF08 ); // 0x20 always set? + sal_uInt32 nCtrlFlags = __nFlags; + sal_uInt32 nFontLen = 0; + + if( nCtrlFlags & 0x0001 ) EXC_CTRLDUMP_DECVARMASK( nFontLen, 0x7FFFFFFF, "fontname-len" ); + if( nCtrlFlags & 0x0002 ) + { + EXC_CTRLDUMP_STARTFLAG( "fontstyle-flags" ); + EXC_CTRLDUMP_ADDFLAG( 0x01, "bold" ); + EXC_CTRLDUMP_ADDFLAG( 0x02, "italic" ); + EXC_CTRLDUMP_ADDFLAG( 0x04, "underline" ); + EXC_CTRLDUMP_ADDFLAG( 0x08, "strikeout" ); + EXC_CTRLDUMP_ENDFLAG( 0xBFFFFFF0 ); // 0x40000000 always set? + } + if( nCtrlFlags & 0x0004 ) EXC_CTRLDUMP_DEC4( "fontsize" ); + if( nCtrlFlags & 0x0010 ) EXC_CTRLDUMP_HEX2( "language-id" ); + if( nCtrlFlags & 0x0040 ) + { + EXC_CTRLDUMP_ALIGN_INSTRM( 2 ); + sal_uInt16 nAlign; rInStrm >> nAlign; + t += " align="; __AddDec( t, nAlign ); + switch( nAlign ) + { + case 1: t += "=left"; break; + case 2: t += "=right"; break; + case 3: t += "=center"; break; + default: t += "=!unknown!"; + } + EXC_CTRLDUMP_PRINTC(); + } + if( nCtrlFlags & 0x0080 ) EXC_CTRLDUMP_DEC2( "fontweight" ); + EXC_CTRLDUMP_STRING( nFontLen, "font" ); + EXC_CTRLDUMP_PRINT(); + + EXC_CTRLDUMP_ALIGN_INSTRM( 4 ); + if( rInStrm.Tell() < nNextPos ) + { + rOutStrm << " unknown data:"; + ContDumpStream( rInStrm, nNextPos - rInStrm.Tell() ); + rOutStrm << '\n'; + } + rInStrm.Seek( nNextPos ); + } + else + rInStrm.SeekRel( -4 ); } - *pDumpStream << "\n### end Ctls stream ###\n"; + + rOutStrm << "\n-- end of stream --\n"; } @@ -7582,11 +7980,14 @@ BOOL Biff8RecDumper::Dump( XclImpStream& r ) r.StoreGlobalPosition(); r.SetWarningMode( bWarnings ); - FilterProgressBar* pPrgrsBar = new FilterProgressBar( r ); + ::std::auto_ptr< ScfProgressBar > pProgress( new ScfProgressBar( + pExcRoot->pIR->GetDocShell(), String( RTL_CONSTASCII_USTRINGPARAM( "Dumper" ) ) ) ); + sal_Int32 nStreamSeg = pProgress->AddSegment( r.GetStreamSize() ); + pProgress->ActivateSegment( nStreamSeg ); while( r.StartNextRecord() ) { - pPrgrsBar->Progress(); + pProgress->Progress( r.Tell() ); if( HasModeDump( r.GetRecId() ) ) RecDump(); @@ -7595,7 +7996,7 @@ BOOL Biff8RecDumper::Dump( XclImpStream& r ) *pDumpStream << '\n'; pIn = NULL; - delete pPrgrsBar; + pProgress.reset(); r.SeekGlobalPosition(); r.SetWarningMode( TRUE ); diff --git a/sc/source/filter/excel/biffrecdumper.ini b/sc/source/filter/excel/biffrecdumper.ini index a11b7a5f83da..62629107a08a 100644 --- a/sc/source/filter/excel/biffrecdumper.ini +++ b/sc/source/filter/excel/biffrecdumper.ini @@ -74,6 +74,7 @@ BODY=* // alternativ B 0x0042=CODEPAGE , 0x0043=XF , 0x0044=IXFE , +0x0045=EFONT , 0x004D=PLS , 0x0050=DCON , 0x0051=DCONREF , diff --git a/sc/source/filter/excel/colrowst.cxx b/sc/source/filter/excel/colrowst.cxx index c32eea396f43..b3c95293cb41 100644 --- a/sc/source/filter/excel/colrowst.cxx +++ b/sc/source/filter/excel/colrowst.cxx @@ -2,9 +2,9 @@ * * $RCSfile: colrowst.cxx,v $ * - * $Revision: 1.15 $ + * $Revision: 1.16 $ * - * last change: $Author: jmarmion $ $Date: 2002-12-10 14:07:24 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:29 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -500,7 +500,6 @@ ScExtDocOptions::ScExtDocOptions( void ) pCodenames = NULL; bChanged = TRUE; - fColScale = 0.0; SetWinProtection(false); } @@ -578,8 +577,6 @@ ScExtDocOptions& ScExtDocOptions::operator =( const ScExtDocOptions& rCpy ) bChanged = rCpy.bChanged; - fColScale = rCpy.fColScale; - return *this; } diff --git a/sc/source/filter/excel/excdoc.cxx b/sc/source/filter/excel/excdoc.cxx index b34765178dad..31bc8417150b 100644 --- a/sc/source/filter/excel/excdoc.cxx +++ b/sc/source/filter/excel/excdoc.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excdoc.cxx,v $ * - * $Revision: 1.42 $ + * $Revision: 1.43 $ * - * last change: $Author: dr $ $Date: 2002-12-12 13:13:54 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:29 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -254,8 +254,9 @@ void ExcTable::SetDefRowXF( UINT16 nXF, UINT16 n ) void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) { RootData& rR = *pExcRoot; + const XclExpRoot& rRoot = *rR.pER; ScDocument& rDoc = *rR.pDoc; - XclExpTabIdBuffer& rTabBuffer = rR.pER->GetTabIdBuffer(); + XclExpTabIdBuffer& rTabBuffer = rRoot.GetTabIdBuffer(); if ( rR.eDateiTyp < Biff8 ) Add( new ExcBofW ); @@ -269,31 +270,15 @@ void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) UINT16 nCodenames = rTabBuffer.GetCodenameCount(); ExcNameList* pNameList = rR.pNameList = new ExcNameList( rR ); - UsedAttrList* pXFRecs = rR.pXFRecs = new UsedAttrList( &rR ); rR.pObjRecs = NULL; // per sheet - rR.pNoteRecs = NULL; // per sheet - - pXFRecs->SetBaseIndex( 21 ); if( rR.eDateiTyp < Biff8 ) Add( new ExcDummy_00 ); else { // first create style XFs - SfxStyleSheetIterator aStyleIter( rDoc.GetStyleSheetPool(), SFX_STYLE_FAMILY_PARA ); - SfxStyleSheetBase* pStyle = aStyleIter.First(); - ScPatternAttr* pPatt; - - while( pStyle ) - { - if( pStyle->IsUserDefined() ) - { - pPatt = new ScPatternAttr( &pStyle->GetItemSet() ); - pXFRecs->Find( pPatt, TRUE ); - } - pStyle = aStyleIter.Next(); - } + rRoot.GetXFBuffer().InsertUserStyles(); Add( new ExcDummy8_00a ); rR.pTabId = new XclExpChTrTabId( Max( nExcTabCount, nCodenames ) ); @@ -347,17 +332,12 @@ void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) Add( new ExcDummy_040 ); Add( new Exc1904( rDoc ) ); Add( new ExcDummy_041 ); - // Font - Add( new XclExpRefRecord( rR.pER->GetFontBuffer() ) ); - // Format - Add( new XclExpRefRecord( rR.pER->GetNumFmtBuffer() ) ); - // XF + Style - Add( new ExcDummy_XF ); - Add( pXFRecs ); - // Style - Add( new ExcDummy_Style ); - // Colors - Add( new XclExpRefRecord( rR.pER->GetPalette() ) ); + + // Formatting: FONT, FORMAT, XF, STYLE, PALETTE + Add( new XclExpRefRecord( rRoot.GetFontBuffer() ) ); + Add( new XclExpRefRecord( rRoot.GetNumFmtBuffer() ) ); + Add( new XclExpRefRecord( rRoot.GetXFBuffer() ) ); + Add( new XclExpRefRecord( rRoot.GetPalette() ) ); // Bundlesheet ExcBundlesheetBase* pBS; @@ -380,15 +360,12 @@ void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) Add( new ExcWindow18( rR ) ); Add( new Exc1904( rDoc ) ); Add( new ExcDummy8_041 ); - // Font - Add( new XclExpRefRecord( rR.pER->GetFontBuffer() ) ); - // Format - Add( new XclExpRefRecord( rR.pER->GetNumFmtBuffer() ) ); - // XF + Style - Add( new ExcDummy8_XF ); - Add( pXFRecs ); - // Style - Add( new ExcDummy8_Style ); + + // Formatting: FONT, FORMAT, XF, STYLE, PALETTE + Add( new XclExpRefRecord( rRoot.GetFontBuffer() ) ); + Add( new XclExpRefRecord( rRoot.GetNumFmtBuffer() ) ); + Add( new XclExpRefRecord( rRoot.GetXFBuffer() ) ); + Add( new XclExpRefRecord( rRoot.GetPalette() ) ); // Pivot Cache ScDPCollection* pDPColl = rDoc.GetDPCollection(); @@ -405,9 +382,6 @@ void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) } } - // Colors - Add( new XclExpRefRecord( rR.pER->GetPalette() ) ); - // Change tracking if( rDoc.GetChangeTrack() ) { @@ -438,15 +412,15 @@ void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) // COUNTRY always Germany Add( new ExcDummy8_Country ); - // SUPBOOKs, XCTs, CRNs, EXTERNSHEET - Add( new XclExpRefRecord( rR.pER->GetLinkManager() ) ); - // NAMEs + // SUPBOOK, XCT, CRN, EXTERNNAME, EXTERNSHEET + Add( new XclExpRefRecord( rRoot.GetLinkManager() ) ); + // NAME Add( pNameList ); // MSODRAWINGGROUP per-document data Add( new XclMsodrawinggroup( rR, ESCHER_DggContainer ) ); // SST, EXTSST - Add( new XclExpRefRecord( rR.pER->GetSst() ) ); + Add( new XclExpRefRecord( rRoot.GetSst() ) ); } Add( new ExcEof ); @@ -456,8 +430,10 @@ void ExcTable::FillAsHeader( ExcRecordListRefs& rBSRecList ) void ExcTable::FillAsTable( void ) { RootData& rR = *pExcRoot; - ScDocument& rDoc = *rR.pDoc; - XclExpTabIdBuffer& rTabBuffer = rR.pER->GetTabIdBuffer(); + const XclExpRoot& rRoot = *rR.pER; + ScDocument& rDoc = rRoot.GetDoc(); + XclExpTabIdBuffer& rTabBuffer = rRoot.GetTabIdBuffer(); + XclExpXFBuffer& rXFBuffer = rRoot.GetXFBuffer(); if( nScTab >= rTabBuffer.GetScTabCount() ) { @@ -477,7 +453,6 @@ void ExcTable::FillAsTable( void ) UINT16 nPrevRow = 0; UINT16 nColMin; // fuer aktuelle Zeile // Row-Records - const UINT16 nDefXF = 0x0F; UINT16 nCol = 0; UINT16 nRow = 0; @@ -507,6 +482,10 @@ void ExcTable::FillAsTable( void ) XclExpDval* pRecDval = NULL; // data validation + XclExpNoteList* pNoteList = NULL; // cell notes + + ExcFmlaResultStr* pFormulaResult = NULL; + DBG_ASSERT( (nScTab >= 0L) && (nScTab <= MAXTAB), "-ExcTable::Table(): nScTab - no ordinary table!" ); DBG_ASSERT( (nExcTab >= 0L) && (nExcTab <= MAXTAB), "-ExcTable::Table(): nExcTab - no ordinary table!" ); @@ -642,13 +621,15 @@ void ExcTable::FillAsTable( void ) Add( pExcDefColWidth ); // COLINFO records - ExcColinfo* pLastColInfo = new ExcColinfo( 0, nScTab, nDefXF, rR, aExcOLCol ); + sal_uInt16 nColDefXF = rXFBuffer.Insert( rDoc.GetPattern( 0, MAXROW, nScTab ) ); + ExcColinfo* pLastColInfo = new ExcColinfo( 0, nScTab, nColDefXF, rR, aExcOLCol ); ExcColinfo* pNewColInfo; Add( pLastColInfo ); for( UINT16 iCol = 1; iCol <= MAXCOL; iCol++ ) { - pNewColInfo = new ExcColinfo( iCol, nScTab, nDefXF, rR, aExcOLCol ); + nColDefXF = rXFBuffer.Insert( rDoc.GetPattern( iCol, MAXROW, nScTab ) ); + pNewColInfo = new ExcColinfo( iCol, nScTab, nColDefXF, rR, aExcOLCol ); pLastColInfo->Expand( pNewColInfo ); if( pNewColInfo ) { @@ -670,7 +651,7 @@ void ExcTable::FillAsTable( void ) // AutoFilter Add( new ExcAutoFilterRecs( rR, nScTab ) ); // list of NOTE records - rR.pNoteRecs = new XclNoteList; + pNoteList = new XclExpNoteList; } // NOTE @@ -684,7 +665,7 @@ void ExcTable::FillAsTable( void ) // at least one ROW rec if( !bIter ) - AddRow( new ExcRow( 0, nScTab, 0, 0, nDefXF, rDoc, aExcOLRow, *this ) ); + AddRow( new ExcRow( 0, nScTab, 0, 0, EXC_XF_DEFAULTCELL, rDoc, aExcOLRow, *this ) ); while( bIter ) { @@ -693,12 +674,13 @@ void ExcTable::FillAsTable( void ) pPatt = aIterator.GetPattern(); pAktExcCell = NULL; + pNote = NULL; pTableOpRec = NULL; // add ROW recs from empty rows while( nPrevRow < nRow ) { - ExcRow* pRow = new ExcRow( nPrevRow, nScTab, 0, 0, nDefXF, rDoc, aExcOLRow, *this ); + ExcRow* pRow = new ExcRow( nPrevRow, nScTab, 0, 0, EXC_XF_DEFAULTCELL, rDoc, aExcOLRow, *this ); AddUsedRow( pRow ); nPrevRow++; } @@ -764,47 +746,32 @@ void ExcTable::FillAsTable( void ) case CELLTYPE_FORMULA: { pLastRKMulRK = NULL; - ScFormulaCell* pFormCell = ( ScFormulaCell * ) pAktScCell; - ULONG nCellNumForm = ( pPatt ? - (( const SfxUInt32Item& ) pPatt->GetItem( - ATTR_VALUE_FORMAT )).GetValue() : 0 ); - ULONG nAltNumForm; - BOOL bForceAltNumForm; - if( ( nCellNumForm % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 ) - { - // #73420# Xcl doesn't know boolean number formats, - // we write "TRUE";"TRUE";"FALSE" or "WAHR";"WAHR";"FALSCH" - // or any other language dependent key words instead. - // Don't do it for automatic formula formats, - // because Xcl gets them right. - if( pFormCell->GetFormatType() == NUMBERFORMAT_LOGICAL ) - nAltNumForm = NUMBERFORMAT_ENTRY_NOT_FOUND; - else - nAltNumForm = pFormCell->GetStandardFormat( - rFormatter, nCellNumForm ); - bForceAltNumForm = FALSE; - } - else - { - // #73420# If number format set is boolean and - // automatic format is boolean don't write that ugly - // special format. - if( pFormCell->GetFormatType() == NUMBERFORMAT_LOGICAL - && rFormatter.GetType( nCellNumForm ) == NUMBERFORMAT_LOGICAL ) - { - nAltNumForm = 0; - bForceAltNumForm = TRUE; - } - else - { - nAltNumForm = NUMBERFORMAT_ENTRY_NOT_FOUND; - bForceAltNumForm = FALSE; - } + ScFormulaCell* pFormCell = (ScFormulaCell*) pAktScCell; + + // current cell number format + sal_uInt32 nCellNumFmt = pPatt ? + static_cast< const SfxUInt32Item& >( pPatt->GetItem( ATTR_VALUE_FORMAT ) ).GetValue() : + rR.pER->GetNumFmtBuffer().GetStandardFormat(); + // alternative number format passed to XF buffer + sal_uInt32 nFmlaNumFmt = NUMBERFORMAT_ENTRY_NOT_FOUND; + + /* #73420# Xcl doesn't know boolean number formats, we write + "TRUE";"TRUE";"FALSE" (language dependent). Don't do it for + automatic formula formats, because Xcl gets them right. */ + /* #i8640# Don't set text format, if we have string results */ + if( ((nCellNumFmt % SV_COUNTRY_LANGUAGE_OFFSET) == 0) && + (pFormCell->GetFormatType() != NUMBERFORMAT_LOGICAL) && + (pFormCell->GetFormatType() != NUMBERFORMAT_TEXT) ) + nFmlaNumFmt = pFormCell->GetStandardFormat( rFormatter, nCellNumFmt ); + /* #73420# If cell number format is Boolean and automatic formula + format is Boolean don't write that ugly special format. */ + else if( (pFormCell->GetFormatType() == NUMBERFORMAT_LOGICAL) && + (rFormatter.GetType( nCellNumFmt ) == NUMBERFORMAT_LOGICAL) ) + nFmlaNumFmt = rR.pER->GetNumFmtBuffer().GetStandardFormat(); - } ExcFormula* pFmlaCell = new ExcFormula( - aScPos, pPatt, rR, nAltNumForm, bForceAltNumForm, *pFormCell->GetCode(), - &pLastArray, ( ScMatrixMode ) pFormCell->GetMatrixFlag(), &pShrdFmla, &aShrdFmlaList ); + aScPos, pPatt, rR, nFmlaNumFmt, *pFormCell->GetCode(), + &pLastArray, ( ScMatrixMode ) pFormCell->GetMatrixFlag(), &pShrdFmla, &aShrdFmlaList, pFormCell, &pFormulaResult); pAktExcCell = pFmlaCell; pTableOpRec = aTableOpList.InsertCell( pFormCell->GetCode(), *pFmlaCell ); } @@ -828,6 +795,7 @@ void ExcTable::FillAsTable( void ) break; case CELLTYPE_NOTE: { + pAktScCell = NULL; // #i11733# empty note cell is empty cell pAktExcCell = NULL; pLastRKMulRK = NULL; DBG_ASSERT( pNote, "-ExcTable::Table(): Note-Cell ohne Note!" ); @@ -845,17 +813,16 @@ void ExcTable::FillAsTable( void ) pLastRKMulRK = NULL; } } - else - {// leere Zelle mit Attributierung - pNote = NULL; + // #i11733# not "else" - pAktScCell may be set to NULL above (empty note cell) + if( !pAktScCell ) + {// leere Zelle mit Attributierung UINT16 nColCnt = aIterator.GetEndCol() - aIterator.GetStartCol() + 1; if( pLastBlank && pLastBlank->GetLastCol() + 1 == aIterator.GetStartCol() ) { pLastBlank->Add( aScPos, pPatt, rR, nColCnt, *this ); - - pAktScCell = NULL; // kein NEUER Record! + pAktExcCell = NULL; // kein NEUER Record! } else { @@ -889,26 +856,36 @@ void ExcTable::FillAsTable( void ) if( pTableOpRec ) Add( pTableOpRec ); - // notes - String sNoteText; - String sNoteAuthor; - if( pNote ) + if(pFormulaResult) { - sNoteText = pNote->GetText(); - sNoteAuthor = pNote->GetAuthor(); + Add( pFormulaResult ); + pFormulaResult = NULL; } - if( rR.sAddNoteText.Len() ) + + + // notes + if( rRoot.GetBiff() < xlBiff8 ) { - if( sNoteText.Len() ) - (sNoteText += (sal_Unicode) 0x0A) += (sal_Unicode) 0x0A; - sNoteText += rR.sAddNoteText; + String sNoteText; + String sNoteAuthor; + if( pNote ) + { + sNoteText = pNote->GetText(); + sNoteAuthor = pNote->GetAuthor(); + } + if( rR.sAddNoteText.Len() ) + { + if( sNoteText.Len() ) + (sNoteText += (sal_Unicode) 0x0A) += (sal_Unicode) 0x0A; + sNoteText += rR.sAddNoteText; + } + if( sNoteText.Len() || sNoteAuthor.Len() ) + Add( new ExcNote( aScPos, sNoteText, rR ) ); } - if( sNoteText.Len() || sNoteAuthor.Len() ) + else { - if ( rR.eDateiTyp < Biff8 ) - Add( new ExcNote( aScPos, sNoteText, rR ) ); - else - rR.pNoteRecs->Add( new XclNote( rR, aScPos, sNoteText, sNoteAuthor ) ); + if( pNote || rR.sAddNoteText.Len() ) + pNoteList->Append( new XclExpNote( rRoot, aScPos, pNote, rR.sAddNoteText ) ); } if( pPatt && (rR.eDateiTyp >= Biff8) ) @@ -950,7 +927,7 @@ void ExcTable::FillAsTable( void ) // new row -> add previous ROW rec if( !bIter || (nPrevRow < nRow) ) { - AddRow( new ExcRow( nPrevRow, nScTab, nColMin, nCol, nDefXF, rDoc, aExcOLRow, *this ) ); + AddRow( new ExcRow( nPrevRow, nScTab, nColMin, nCol, EXC_XF_DEFAULTCELL, rDoc, aExcOLRow, *this ) ); nPrevRow++; nColMin = aIterator.GetStartCol(); @@ -964,7 +941,7 @@ void ExcTable::FillAsTable( void ) while( nRow < nMaxFlagRow ) { nRow++; - ExcRow* pRow = new ExcRow( nRow, nScTab, 0, 0, nDefXF, rDoc, aExcOLRow, *this ); + ExcRow* pRow = new ExcRow( nRow, nScTab, 0, 0, EXC_XF_DEFAULTCELL, rDoc, aExcOLRow, *this ); AddUsedRow( pRow ); } @@ -997,7 +974,7 @@ void ExcTable::FillAsTable( void ) // all MSODRAWING and OBJ stuff of this sheet goes here Add( rR.pObjRecs ); // NOTE records - Add( rR.pNoteRecs ); + Add( pNoteList ); // pivot tables ScDPCollection* pDPColl = rDoc.GetDPCollection(); @@ -1156,7 +1133,7 @@ ExcDocument::ExcDocument( const XclExpRoot& rRoot ) : pTabNames = new NameBuffer( 0, 16 ); pPrgrsBar = new ScProgress( - NULL, ScGlobal::GetRscString(STR_SAVE_DOC), + GetDocShell(), ScGlobal::GetRscString(STR_SAVE_DOC), ( UINT32 ) GetDoc().GetCellCount() * 2 ); ExcCell::SetPrgrsBar( *pPrgrsBar ); } diff --git a/sc/source/filter/excel/excel.cxx b/sc/source/filter/excel/excel.cxx index febdc7690b53..a04b41debf8b 100644 --- a/sc/source/filter/excel/excel.cxx +++ b/sc/source/filter/excel/excel.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excel.cxx,v $ * - * $Revision: 1.9 $ + * $Revision: 1.10 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:15:59 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:30 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses diff --git a/sc/source/filter/excel/excform.cxx b/sc/source/filter/excel/excform.cxx index 970a12a0e81e..6ab7ceb0deae 100644 --- a/sc/source/filter/excel/excform.cxx +++ b/sc/source/filter/excel/excform.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excform.cxx,v $ * - * $Revision: 1.19 $ + * $Revision: 1.20 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:15:59 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:30 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -1857,7 +1857,7 @@ DefTokenId ExcelToSc::IndexToToken( UINT16 nIndex ) ocNoName, // XlfScenarioGet ocNoName, // XlfOptionsListsGet ocISPMT, // XlfIspmt - ocGetDiffDate, // XlfDatedif + ocNoName, // XlfDatedif ocNoName, // XlfDatestring ocNoName, // XlfNumberstring ocRoman, // XlfRoman @@ -2270,7 +2270,7 @@ BYTE ExcelToSc::IndexToAnzahl( UINT16 nIndex ) 0, // XlfScenarioGet 0, // XlfOptionsListsGet 4, // XlfIspmt - 0, // XlfDatedif + 3, // XlfDatedif 0, // XlfDatestring 0, // XlfNumberstring 1, // XlfRoman @@ -2380,6 +2380,11 @@ void ExcelToSc::ExcRelToScRel( UINT16 nRow, UINT8 nCol, SingleRefData &rSRD, con rSRD.nRelCol = rSRD.nCol - aEingPos.Col(); if ( rSRD.IsRowRel() ) rSRD.nRelRow = rSRD.nRow - aEingPos.Row(); + + // T A B + // #i10184# abs needed if rel in shared formula for ScCompiler UpdateNameReference + if ( rSRD.IsTabRel() && !rSRD.IsFlag3D() ) + rSRD.nTab = pExcRoot->pIR->GetScTab() + rSRD.nRelTab; } } diff --git a/sc/source/filter/excel/excform8.cxx b/sc/source/filter/excel/excform8.cxx index 65a38494fe16..cb67ac7455cc 100644 --- a/sc/source/filter/excel/excform8.cxx +++ b/sc/source/filter/excel/excform8.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excform8.cxx,v $ * - * $Revision: 1.22 $ + * $Revision: 1.23 $ * - * last change: $Author: dr $ $Date: 2002-12-06 15:17:05 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:31 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -671,6 +671,8 @@ ConvErr ExcelToSc8::Convert( const ScTokenArray*& rpTokArray, UINT32 nFormulaLen pExcRoot->pDoc->CreateDdeLink( aAppl, aExtDoc, pExtName->GetName() ); } + else if( (pExtName->GetType() == xlExtName) && pSupbook->IsAddIn() ) + aStack << aPool.Store( ocNoName, pExtName->GetAddInName() ); else aStack << aPool.Store( ocNoName, pExtName->GetName() ); } @@ -1229,6 +1231,11 @@ void ExcelToSc8::ExcRelToScRel( UINT16 nRow, UINT16 nC, SingleRefData &rSRD, con rSRD.nRelRow = (INT16) nRow - aEingPos.Row(); else rSRD.nRow = nRow; + + // T A B + // #i10184# abs needed if rel in shared formula for ScCompiler UpdateNameReference + if ( rSRD.IsTabRel() && !rSRD.IsFlag3D() ) + rSRD.nTab = pExcRoot->pIR->GetScTab() + rSRD.nRelTab; } } diff --git a/sc/source/filter/excel/excimp8.cxx b/sc/source/filter/excel/excimp8.cxx index 9174fcefbc16..5fd21973a8f4 100644 --- a/sc/source/filter/excel/excimp8.cxx +++ b/sc/source/filter/excel/excimp8.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excimp8.cxx,v $ * - * $Revision: 1.79 $ + * $Revision: 1.80 $ * - * last change: $Author: jmarmion $ $Date: 2002-12-10 14:07:24 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:31 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -96,7 +96,6 @@ #include <svx/flditem.hxx> #include <svx/xflclit.hxx> #include <svx/svxmsbas.hxx> -#include <svx/unoapi.hxx> #include <vcl/graph.hxx> #include <vcl/bmpacc.hxx> @@ -106,7 +105,7 @@ #include <tools/string.hxx> #include <tools/urlobj.hxx> -#include <tools/solmath.hxx> +#include <rtl/math.hxx> #ifndef _UNOTOOLS_LOCALEDATAWRAPPER_HXX #include <unotools/localedatawrapper.hxx> @@ -128,7 +127,13 @@ #include "markdata.hxx" #include "rangenam.hxx" #include "docoptio.hxx" +#ifndef SC_DETFUNC_HXX +#include "detfunc.hxx" +#endif +#ifndef SC_XLOCX_HXX +#include "xlocx.hxx" +#endif #ifndef SC_XILINK_HXX #include "xilink.hxx" #endif @@ -138,11 +143,9 @@ #include "excimp8.hxx" #include "excform.hxx" -#include "fltprgrs.hxx" #include "flttools.hxx" #include "scextopt.hxx" #include "stlpool.hxx" -#include "scmsocximexp.hxx" using namespace com::sun::star; @@ -274,9 +277,10 @@ void ExcCondForm::ReadCf( XclImpStream& rIn, ExcelToSc& rConv ) default: nPosF = 0; nPosL = 0; nPosP = 0; } - SfxItemSet& rStyleItemSet = rDoc.GetStyleSheetPool()->Make( - aStyle, SFX_STYLE_FAMILY_PARA, - SFXSTYLEBIT_USERDEF ).GetItemSet(); + SfxStyleSheetBase* pStyleSheet = rDoc.GetStyleSheetPool()->Find( aStyle, SFX_STYLE_FAMILY_PARA ); + SfxItemSet& rStyleItemSet = pStyleSheet ? pStyleSheet->GetItemSet() : + rDoc.GetStyleSheetPool()->Make( aStyle, SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_USERDEF ).GetItemSet(); + rStyleItemSet.ClearItem(); const XclImpPalette& rPalette = GetPalette(); @@ -340,42 +344,40 @@ void ExcCondForm::ReadCf( XclImpStream& rIn, ExcelToSc& rConv ) if( nPosL ) // line { - UINT8 nLineH, nLineV; - UINT16 nColH, nColV; + sal_uInt16 nLine, nColor1, nColor2; rIn.Seek( nPosL ); - - rIn >> nLineV >> nLineH >> nColV >> nColH; - - UINT8 nLineL = nLineV & 0x0F; - UINT16 nColL = nColV & 0x007F; - UINT8 nLineR = nLineV >> 4; - UINT16 nColR = ( nColV >> 7 ) & 0x007F; - UINT8 nLineT = nLineH & 0x0F; - UINT16 nColT = nColH & 0x007F; - UINT8 nLineB = nLineH >> 4; - UINT16 nColB = ( nColH >> 7 ) & 0x007F; - - XclImpXF::SetBorder( rStyleItemSet, rPalette, - nLineL, nColL, nLineR, nColR, nLineT, nColT, nLineB, nColB ); + rIn >> nLine >> nColor1 >> nColor2; + + XclImpXFBorder aBorder; + ::extract_value( aBorder.mnLeftLine, nLine, 0, 4 ); + ::extract_value( aBorder.mnRightLine, nLine, 4, 4 ); + ::extract_value( aBorder.mnTopLine, nLine, 8, 4 ); + ::extract_value( aBorder.mnBottomLine, nLine, 12, 4 ); + ::extract_value( aBorder.mnLeftColor, nColor1, 0, 7 ); + ::extract_value( aBorder.mnRightColor, nColor1, 7, 7 ); + ::extract_value( aBorder.mnTopColor, nColor2, 0, 7 ); + ::extract_value( aBorder.mnBottomColor, nColor2, 7, 7 ); + XclImpXF::SetBorder( rStyleItemSet, rPalette, aBorder ); } if( nPosP ) // pattern (fill) { - UINT16 nPatt; - UINT16 nCol; - + sal_uInt16 nPattern, nColor; rIn.Seek( nPosP ); - rIn >> nPatt >> nCol; + rIn >> nPattern >> nColor; - UINT8 nF = nCol & 0x007F; - UINT8 nB = ( nCol >> 7 ) & 0x007F; - UINT8 nP = (UINT8)((nPatt >> 10) & 0x003F); - if( nP <= 1 ) + XclImpXFArea aArea; + ::extract_value( aArea.mnForeColor, nColor, 0, 7 ); + ::extract_value( aArea.mnBackColor, nColor, 7, 7 ); + ::extract_value( aArea.mnPattern, nPattern, 10, 6 ); + if( (aArea.mnPattern == EXC_PATT_NONE) || (aArea.mnPattern == EXC_PATT_SOLID) ) { - nP = nB; nB = nF; nF = nP; nP = 1; + // overwrite a cell style with "no fill" + // EXC_PATT_SOLID forces creation of a brush item in SetArea() + ::std::swap( aArea.mnForeColor, aArea.mnBackColor ); + aArea.mnPattern = EXC_PATT_SOLID; } - - XclImpXF::SetArea( rStyleItemSet, rPalette, nP, nF, nB ); + XclImpXF::SetArea( rStyleItemSet, rPalette, aArea ); } // convert formulas @@ -448,7 +450,7 @@ void ExcCondForm::Apply( void ) if( nR2 > MAXROW ) nR2 = MAXROW; - GetDoc().ApplyPatternAreaTab( nC1, nR1, nC2, nR2, GetScTab(), aPat ); + GetDoc().ApplyPatternAreaTab( nC1, nR1, nC2, nR2, p->aStart.Tab(), aPat ); p = pRangeList->Next(); } @@ -484,8 +486,7 @@ void ExcCondFormList::Apply( void ) ImportExcel8::ImportExcel8( SvStorage* pStorage, SvStream& rStream, ScDocument* pDoc, const String& rBasePath, SvStorage* pPivotCache ) : - ImportExcel( rStream, pDoc, rBasePath ), - aObjManager( *pExcRoot ) + ImportExcel( rStream, pDoc, rBasePath ) { delete pFormConv; @@ -597,20 +598,30 @@ void ImportExcel8::Horizontalpagebreaks( void ) void ImportExcel8::Note( void ) { - UINT16 nCol, nRow, nId; + UINT16 nCol, nRow, nFlags, nId; - aIn >> nRow >> nCol; - aIn.Ignore( 2 ); - aIn >> nId; + aIn >> nRow >> nCol >> nFlags >> nId; if( nRow <= MAXROW && nCol <= MAXCOL ) { if( nId ) { - const XclImpEscherNote* pObj = aObjManager.GetObjNote( nId, GetScTab() ); + const XclImpEscherNote* pObj = GetObjectManager().GetObjNote( nId, GetScTab() ); const String* pText = pObj ? pObj->GetText() : NULL; if( pText ) - pD->SetNote( nCol, nRow, GetScTab(), ScPostIt( *pText ) ); + { + bool bVisible = ::get_flag( nFlags, EXC_NOTE_VISIBLE ); + ScPostIt aNote( *pText ); + aNote.SetShown( bVisible ); + GetDoc().SetNote( nCol, nRow, GetScTab(), aNote ); + if( bVisible ) + { + ScDocument *pDoc = GetDocPtr(); + ScDetectiveFunc( pDoc, GetScTab() ).ShowComment( nCol, nRow, TRUE ); + + // ScDetectiveFunc( GetDocPtr(), GetScTab() ).ShowComment( nCol, nRow, TRUE ); + } + } } } else @@ -623,7 +634,7 @@ void ImportExcel8::Note( void ) void ImportExcel8::Cont( void ) { if( bObjSection ) - aObjManager.ReadMsodrawing( aIn ); + GetObjectManager().ReadMsodrawing( aIn ); } @@ -648,14 +659,14 @@ void ImportExcel8::Dconref( void ) aTabName = aUrl; aUrl.Erase(); } - ScfTools::ConvertName( aTabName ); + ScfTools::ConvertToScSheetName( aTabName ); pCurrPivotCache->SetSource( nC1, nR1, nC2, nR2, aUrl, aTabName, bSelf ); } void ImportExcel8::Obj() { - aObjManager.ReadObj( aIn ); + GetObjectManager().ReadObj( maStrm ); } @@ -669,7 +680,7 @@ void ImportExcel8::Boundsheet( void ) String aName( aIn.ReadUniString( nLen ) ); - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScSheetName( aName ); *pExcRoot->pTabNameBuff << aName; if( nBdshtTab > 0 ) @@ -730,19 +741,19 @@ void ImportExcel8::Cellmerging( void ) void ImportExcel8::Msodrawinggroup( void ) { - aObjManager.ReadMsodrawinggroup( aIn ); + GetObjectManager().ReadMsodrawinggroup( maStrm ); } void ImportExcel8::Msodrawing( void ) { - aObjManager.ReadMsodrawing( aIn ); + GetObjectManager().ReadMsodrawing( maStrm ); } void ImportExcel8::Msodrawingselection( void ) { - aObjManager.ReadMsodrawingselection( aIn ); + GetObjectManager().ReadMsodrawingselection( maStrm ); } void ImportExcel8::Condfmt( void ) @@ -842,7 +853,7 @@ void ImportExcel8::Label( void ) void ImportExcel8::Txo( void ) { - aObjManager.ReadTxo( aIn ); + GetObjectManager().ReadTxo( maStrm ); } @@ -923,11 +934,18 @@ void ImportExcel8::Name( void ) const BOOL bExtract = bBuiltIn && ( cFirstChar == EXC_BUILTIN_EXTRACT ); BOOL bAppendTabNum = FALSE; BOOL bSkip = FALSE; + RangeType eNameType = RT_ABSAREA; if( bBuiltIn ) XclTools::GetBuiltInName( aName, cFirstChar, nSheet ); else - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScDefinedName( aName ); + + if(bPrintArea) + eNameType = RT_PRINTAREA; + if(bCriteria) + eNameType = RT_CRITERIA; + pFormConv->Reset(); if( nOpt & (EXC_NAME_VB | EXC_NAME_PROC | EXC_NAME_BIG) ) @@ -962,7 +980,12 @@ void ImportExcel8::Name( void ) else if( bCriteria ) pAutoFilterBuffer->AddAdvancedRange( aRange ); else if( bExtract ) - pAutoFilterBuffer->AddExtractPos( aRange ); + { + if( pErgebnis->IsValidReference( aRange ) ) + pAutoFilterBuffer->AddExtractPos( aRange ); + else + eNameType = RT_NAME; + } } } } @@ -973,7 +996,7 @@ void ImportExcel8::Name( void ) pExcRoot->pRNameBuff->Store( aName, NULL, nSheet ); else // ohne hidden - pExcRoot->pRNameBuff->Store( aName, pErgebnis, nSheet, bPrintArea ); + pExcRoot->pRNameBuff->Store( aName, pErgebnis, nSheet, eNameType ); } @@ -997,28 +1020,18 @@ void ImportExcel8::PostDocLoad( void ) pCondFormList->Apply(); if( pAutoFilterBuffer ) pAutoFilterBuffer->Apply(); - GetWebQueryBuffer().Apply(); + GetWebQueryBuffer().Apply(); //! test if extant UINT32 nChartCnt = 0; - SfxObjectShell* pShell = pD->GetDocumentShell(); - if( aObjManager.HasEscherStream() ) + SfxObjectShell* pShell = GetDocShell(); + XclImpObjectManager& rObjManager = GetObjectManager(); + + if( pShell && rObjManager.HasEscherStream() ) { - Biff8MSDffManager* pDffMan = new Biff8MSDffManager( *pExcRoot, aObjManager, + Biff8MSDffManager* pDffMan = new Biff8MSDffManager( *pExcRoot, rObjManager, 0, 0, pD->GetDrawLayer(), 1440 ); - const String aStrName( _STRING( "Ctls" ) ); - SvStorage& rStrg = *pExcRoot->pRootStorage; - const BOOL bHasCtrls = rStrg.IsContained( aStrName ) && rStrg.IsStream( aStrName ); - ScMSConvertControls* pCtrlConv; - SvStorageStreamRef xStStream; - - if( bHasCtrls && pShell ) - { - pCtrlConv = new ScMSConvertControls( pShell ); - xStStream = pExcRoot->pRootStorage->OpenStream( aStrName, STREAM_READ | STREAM_SHARE_DENYALL ); - } - const XclImpAnchorData* pAnch; const SvxMSDffShapeInfos* pShpInf = pDffMan->GetShapeInfos(); @@ -1045,6 +1058,8 @@ void ImportExcel8::PostDocLoad( void ) nOLEImpFlags |= OLE_POWERPOINT_2_STARIMPRESS; } + XclImpOcxConverter aOcxConverter( *this ); + for( n = 0 ; n < nMax ; n++ ) { p = pShpInf->GetObject( ( UINT16 ) n ); @@ -1052,7 +1067,7 @@ void ImportExcel8::PostDocLoad( void ) nShapeId = p->nShapeId; - XclImpEscherObj* pObj = aObjManager.GetObjFromStream( p->nFilePos ); + XclImpEscherObj* pObj = rObjManager.GetObjFromStream( p->nFilePos ); if( pObj && !pObj->GetSdrObj() ) { pMSDffImportData = new SvxMSDffImportData; @@ -1060,7 +1075,7 @@ void ImportExcel8::PostDocLoad( void ) if( pObj->GetSdrObj() ) { - pAnch = aObjManager.GetAnchorData( p->nFilePos ); + pAnch = rObjManager.GetAnchorData( p->nFilePos ); // *** find all objects to ignore *** bIgnoreObj = false; @@ -1074,7 +1089,7 @@ void ImportExcel8::PostDocLoad( void ) } // other objects if( !bIgnoreObj ) - bIgnoreObj = IsIgnoreObject( pObj->GetId() ); + bIgnoreObj = rObjManager.IsIgnoreObject( pObj->GetId() ); if( bIgnoreObj ) pObj->SetSdrObj( NULL ); // delete SdrObject @@ -1086,17 +1101,7 @@ void ImportExcel8::PostDocLoad( void ) ((XclImpEscherOle*)pObj)->CreateSdrOle( *pDffMan, nOLEImpFlags ); break; case otCtrl: - if( bHasCtrls ) - { - ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > - xShapeRef = GetXShapeForSdrObject( ( SdrObject* ) pObj->GetSdrObj() ); - if( pCtrlConv->ReadOCXExcelKludgeStream( xStStream, &xShapeRef, TRUE ) ) - { - SdrObject* pNewObj = GetSdrObjectFromXShape( xShapeRef ); - if( pNewObj ) - pObj->SetSdrObj( pNewObj ); - } - } + aOcxConverter.ReadControl( static_cast< XclImpEscherOle& >( *pObj ) ); break; } } @@ -1106,25 +1111,11 @@ void ImportExcel8::PostDocLoad( void ) } } - if( bHasCtrls ) - delete pCtrlConv; - delete pDffMan; } - aObjManager.Apply(); + rObjManager.Apply(); - // controls -/* - ScMSConvertControls aCtrlConverter( pShell ); - String aStrName( String::CreateFromAscii( "Ctls" ) ); - com::sun::star::uno::Reference< com::sun::star::drawing::XShape >* pShapeRef = NULL; - - SvStorageStreamRef xStStream = pExcRoot->pRootStorage->OpenStream( - aStrName, STREAM_READ | STREAM_SHARE_DENYALL ); - aCtrlConverter.ReadOCXExcelKludgeStream( xStStream, pShapeRef, TRUE ); - // BOOL bFloatingCtrl -*/ ImportExcel::PostDocLoad(); // Scenarien bemachen! ACHTUNG: Hier wird Tabellen-Anzahl im Dokument erhoeht!! @@ -1175,45 +1166,6 @@ void ImportExcel8::PostDocLoad( void ) -void ImportExcel8::CreateTmpCtrlStorage( void ) -{ -// if( pExcRoot->pCtrlStorage ) - if( pExcRoot->xCtrlStorage.Is() ) - return; // already done - - SvStorageStream* pContrIn = pExcRoot->pRootStorage->OpenStream( _STRINGCONST( "Ctls" ), STREAM_STD_READ ); - if( pContrIn ) - { - SvStorageRef xStrg( new SvStorage( new SvMemoryStream(), TRUE ) ); - pExcRoot->xCtrlStorage = SvStorageRef( new SvStorage( new SvMemoryStream(), TRUE ) ); -// SvStorage* pStrg = new SvStorage( new SvMemoryStream(), TRUE ); - -// SvStorageStreamRef xTemp = pStrg->OpenStream( _STRINGCONST( "contents" ) ); - SvStorageStreamRef xTemp = xStrg->OpenStream( _STRINGCONST( "contents" ) ); - if ( xTemp.Is() && ( xTemp->GetError() == SVSTREAM_OK ) ) - { - pContrIn->Seek( 16 ); // no need for class id at this point - *xTemp << *pContrIn; - - SvGlobalName aName( 0xD7053240, 0xCE69, 0x11CD, 0xA7, 0x77, - 0x00, 0xDD, 0x01, 0x14, 0x3C, 0x57 ); - UINT32 nClip = SotExchange::RegisterFormatName( _STRING( "Embedded Object" ) ); -// pStrg->SetClass( aName, nClip, _STRING( "Microsoft Forms 2.0 CommandButton" ) ); - xStrg->SetClass( aName, nClip, _STRING( "Microsoft Forms 2.0 CommandButton" ) ); - - pExcRoot->xCtrlStorage = xStrg; - } -/* else - { - delete pStrg; - pStrg = NULL; - }*/ - -// pExcRoot->pCtrlStorage = pStrg; - } -} - - void ImportExcel8::EndAllChartObjects( void ) { } @@ -1335,6 +1287,17 @@ void ImportExcel8::SXVdex( void ) void ImportExcel8::FilterMode( void ) { + // The FilterMode record exists: if either the AutoFilter + // record exists or an Advanced Filter is saved and stored + // in the sheet. Thus if the FilterMode records only exists + // then the latter is true.. + if( !pAutoFilterBuffer ) return; + + pAutoFilterBuffer->IncrementActiveAF(); + + XclImpAutoFilterData* pData = pAutoFilterBuffer->GetByTab( GetScTab() ); + if( pData ) + pData->SetAutoOrAdvanced(); } void ImportExcel8::AutoFilterInfo( void ) @@ -1362,10 +1325,14 @@ void ImportExcel8::AutoFilter( void ) XclImpAutoFilterData::XclImpAutoFilterData( RootData* pRoot, const ScRange& rRange, const String& rName ) : ExcRoot( pRoot ), + pCurrDBData(NULL), nFirstEmpty( 0 ), bActive( FALSE ), bHasDropDown( FALSE ), - bHasConflict( FALSE ) + bHasConflict( FALSE ), + bCriteria( FALSE ), + bAutoOrAdvanced(FALSE), + aFilterName(rName) { aParam.nCol1 = rRange.aStart.Col(); aParam.nRow1 = rRange.aStart.Row(); @@ -1373,21 +1340,18 @@ XclImpAutoFilterData::XclImpAutoFilterData( RootData* pRoot, const ScRange& rRan aParam.nCol2 = rRange.aEnd.Col(); aParam.nRow2 = rRange.aEnd.Row(); - ScDBCollection& rColl = *pRoot->pDoc->GetDBCollection(); + // Excel defaults to always in place regardless + // of whether an extract record exists. The user + // must choose to explicity set the Copy To in the UI. + aParam.bInplace = TRUE; - pCurrDBData = rColl.GetDBAtArea( Tab(), StartCol(), StartRow(), EndCol(), EndRow() ); - if( !pCurrDBData ) - { - pCurrDBData = new ScDBData( rName, Tab(), StartCol(), StartRow(), EndCol(), EndRow() ); - if( pCurrDBData ) - rColl.Insert( pCurrDBData ); - } } void XclImpAutoFilterData::CreateFromDouble( String& rStr, double fVal ) { - SolarMath::DoubleToString( rStr, fVal, 'A', INT_MAX, - ScGlobal::pLocaleData->getNumDecimalSep().GetChar(0), TRUE ); + rStr += String( ::rtl::math::doubleToUString( fVal, + rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, + ScGlobal::pLocaleData->getNumDecimalSep().GetChar(0), TRUE)); } void XclImpAutoFilterData::SetCellAttribs() @@ -1563,8 +1527,13 @@ void XclImpAutoFilterData::ReadAutoFilter( XclImpStream& rStrm ) void XclImpAutoFilterData::SetAdvancedRange( const ScRange* pRange ) { - if( pCurrDBData ) - pCurrDBData->SetAdvancedQuerySource( pRange ); + if (pRange) + { + aCriteriaRange = *pRange; + bCriteria = TRUE; + } + else + bCriteria = FALSE; } void XclImpAutoFilterData::SetExtractPos( const ScAddress& rAddr ) @@ -1572,12 +1541,14 @@ void XclImpAutoFilterData::SetExtractPos( const ScAddress& rAddr ) aParam.nDestCol = rAddr.Col(); aParam.nDestRow = rAddr.Row(); aParam.nDestTab = rAddr.Tab(); - aParam.bInplace = FALSE; aParam.bDestPers = TRUE; + } -void XclImpAutoFilterData::Apply() +void XclImpAutoFilterData::Apply( const BOOL bUseUnNamed ) { + CreateScDBData(bUseUnNamed); + if( bActive ) { InsertQueryParam(); @@ -1593,8 +1564,68 @@ void XclImpAutoFilterData::Apply() } } +void XclImpAutoFilterData::CreateScDBData( const BOOL bUseUnNamed ) +{ + + // Create the ScDBData() object if the AutoFilter is activated + // or if we need to create the Advanced Filter. + if( bActive || bCriteria) + { + ScDBCollection& rColl = *pExcRoot->pDoc->GetDBCollection(); + pCurrDBData = rColl.GetDBAtArea( Tab(), StartCol(), StartRow(), EndCol(), EndRow() ); + if( !pCurrDBData ) + { + AmendAFName(bUseUnNamed); + + pCurrDBData = new ScDBData( aFilterName, Tab(), StartCol(), StartRow(), EndCol(), EndRow() ); + + if( pCurrDBData ) + { + if(bCriteria) + { + EnableRemoveFilter(); + + pCurrDBData->SetQueryParam( aParam ); + pCurrDBData->SetAdvancedQuerySource(&aCriteriaRange); + } + else + pCurrDBData->SetAdvancedQuerySource(NULL); + rColl.Insert( pCurrDBData ); + } + } + } + +} + +void XclImpAutoFilterData::EnableRemoveFilter() +{ + // only if this is a saved Advanced filter + if( !bActive && bAutoOrAdvanced ) + { + ScQueryEntry& aEntry = aParam.GetEntry( nFirstEmpty ); + aEntry.bDoQuery = TRUE; + ++nFirstEmpty; + } + // TBD: force the automatic activation of the + // "Remove Filter" by setting a virtual mouse click + // inside the advanced range +} +void XclImpAutoFilterData::AmendAFName(const BOOL bUseUnNamed) +{ + // If-and-only-if we have one AF filter then + // use the Calc "unnamed" range name. Calc + // only supports one in total while Excel + // supports one per sheet. + if( bUseUnNamed && bAutoOrAdvanced ) + aFilterName = ScGlobal::GetRscString(STR_DB_NONAME); +} + +XclImpAutoFilterBuffer::XclImpAutoFilterBuffer() : + nAFActiveCount( 0 ) +{ +} XclImpAutoFilterBuffer::~XclImpAutoFilterBuffer() { @@ -1626,7 +1657,7 @@ void XclImpAutoFilterBuffer::AddExtractPos( const ScRange& rRange ) void XclImpAutoFilterBuffer::Apply() { for( XclImpAutoFilterData* pData = _First(); pData; pData = _Next() ) - pData->Apply(); + pData->Apply(UseUnNamed()); } XclImpAutoFilterData* XclImpAutoFilterBuffer::GetByTab( UINT16 nTab ) diff --git a/sc/source/filter/excel/excobj.cxx b/sc/source/filter/excel/excobj.cxx index cc81bcf16da2..c74da3ec42d6 100644 --- a/sc/source/filter/excel/excobj.cxx +++ b/sc/source/filter/excel/excobj.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excobj.cxx,v $ * - * $Revision: 1.24 $ + * $Revision: 1.25 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:16:00 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:31 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -129,8 +129,6 @@ #include "editutil.hxx" #include "imp_op.hxx" -#include "fltprgrs.hxx" -#include "scmsocximexp.hxx" #ifndef SC_XILINK_HXX #include "xilink.hxx" @@ -544,16 +542,3 @@ void ImportExcel::EndAllChartObjects( void ) #ifdef WNT #pragma optimize("",on) #endif - - - - -using namespace ::com::sun::star; - -BOOL ScMSConvertControls::InsertControl( - const uno::Reference< form::XFormComponent >& rFComp, - const awt::Size& rSize, - uno::Reference< drawing::XShape >* pShape,BOOL bFloatingCtrl ) -{ - return FALSE; -} diff --git a/sc/source/filter/excel/excrecds.cxx b/sc/source/filter/excel/excrecds.cxx index 91df7256f829..797f3de0cf8c 100644 --- a/sc/source/filter/excel/excrecds.cxx +++ b/sc/source/filter/excel/excrecds.cxx @@ -2,9 +2,9 @@ * * $RCSfile: excrecds.cxx,v $ * - * $Revision: 1.58 $ + * $Revision: 1.59 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:23 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:32 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -100,6 +100,7 @@ #include <string.h> #include "global.hxx" +#include "globstr.hrc" #include "docpool.hxx" #include "patattr.hxx" #include "cell.hxx" @@ -176,64 +177,6 @@ const BYTE ExcDummy_041::pMyData[] = { }; const ULONG ExcDummy_041::nMyLen = sizeof( ExcDummy_041::pMyData ); -//--------------------------------------------------------- class ExcDummy_XF - -const BYTE ExcDummy_XF::pMyData[] = { - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0x00, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xff, 0x20, 0xf4, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x05, 0x00, 0x2b, 0x00, 0xf5, 0xff, 0x20, 0xf8, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x05, 0x00, 0x29, 0x00, 0xf5, 0xff, 0x20, 0xf8, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x05, 0x00, 0x09, 0x00, 0xf5, 0xff, 0x20, 0xf8, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x05, 0x00, 0x2c, 0x00, 0xf5, 0xff, 0x20, 0xf8, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xe0, 0x00, 0x10, 0x00, 0x05, 0x00, 0x2a, 0x00, 0xf5, 0xff, 0x20, 0xf8, - 0xc0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 -}; -const ULONG ExcDummy_XF::nMyLen = sizeof( ExcDummy_XF::pMyData ); - -//------------------------------------------------------ class ExcDummy_Style - -const BYTE ExcDummy_Style::pMyData[] = { - 0x93, 0x02, 0x04, 0x00, 0x10, 0x80, 0x03, 0xff, - 0x93, 0x02, 0x04, 0x00, 0x11, 0x80, 0x06, 0xff, - 0x93, 0x02, 0x04, 0x00, 0x12, 0x80, 0x05, 0xff, - 0x93, 0x02, 0x04, 0x00, 0x00, 0x80, 0x00, 0xff, - 0x93, 0x02, 0x04, 0x00, 0x13, 0x80, 0x04, 0xff, - 0x93, 0x02, 0x04, 0x00, 0x14, 0x80, 0x07, 0xff -}; -const ULONG ExcDummy_Style::nMyLen = sizeof( ExcDummy_Style::pMyData ); - //-------------------------------------------------------- class ExcDummy_02a - const BYTE ExcDummy_02a::pMyData[] = { 0x0d, 0x00, 0x02, 0x00, 0x01, 0x00, // CALCMODE @@ -260,14 +203,6 @@ const BYTE ExcDummy_02c::pMyData[] = { const ULONG ExcDummy_02c::nMyLen = sizeof( ExcDummy_02c::pMyData ); -//--------------------------------------------------------- - - -#ifdef DBG_UTIL -UINT16 ExcXf::nObjCnt = 0; -#endif - - //----------------------------------------------------------- class ExcRecord - void ExcRecord::Save( XclExpStream& rStrm ) @@ -525,35 +460,6 @@ UINT16 Exc1904::GetNum( void ) const -//--------------------------------------------------------- class ExcDummy_XF - - -ULONG ExcDummy_XF::GetLen( void ) const -{ - return nMyLen; -} - - -const BYTE* ExcDummy_XF::GetData( void ) const -{ - return pMyData; -} - - - -//------------------------------------------------------ class ExcDummy_Style - - -ULONG ExcDummy_Style::GetLen( void ) const -{ - return nMyLen; -} - - -const BYTE* ExcDummy_Style::GetData( void ) const -{ - return pMyData; -} - - //------------------------------------------------------ class ExcBundlesheet - ExcBundlesheetBase::ExcBundlesheetBase( RootData& rRootData, UINT16 nTab ) : @@ -700,19 +606,17 @@ ExcCell::ExcCell( const ScAddress rPos, const ScPatternAttr* pAttr, RootData& rRootData, - const ULONG nAltNumForm, - BOOL bForceAltNumForm ) : + const ULONG nAltNumForm ) : aPos( rPos ) { if( pPrgrsBar ) pPrgrsBar->SetState( GetCellCount() ); IncCellCount(); - DBG_ASSERT( rRootData.pXFRecs, "ExcCell::ExcCell - missing XF record list" ); DBG_ASSERT( rRootData.pCellMerging, "ExcCell::ExcCell - missing cell merging list" ); if( !rRootData.pCellMerging->FindMergeBaseXF( aPos, nXF ) ) - nXF = rRootData.pXFRecs->Find( pAttr, FALSE, nAltNumForm, bForceAltNumForm ); + nXF = rRootData.pER->GetXFBuffer().Insert( pAttr, nAltNumForm ); #ifdef DBG_UTIL _nRefCount++; @@ -799,7 +703,7 @@ ExcBoolerr::ExcBoolerr( UINT8 nValP, BOOL bIsError ) : // #73420# force to "no number format" if boolean value - ExcCell( rPos, pAttr, rRootData, (bIsError ? NUMBERFORMAT_ENTRY_NOT_FOUND : 0), !bIsError ), + ExcCell( rPos, pAttr, rRootData, bIsError ? NUMBERFORMAT_ENTRY_NOT_FOUND : 0 ), nVal( bIsError ? nValP : (nValP != 0) ), bError( bIsError != 0 ) { @@ -868,7 +772,7 @@ ExcRKMulRK* ExcRKMulRK::Extend( ExcRKMulRKEntry* pNewCont = new ExcRKMulRKEntry; if( !rRootData.pCellMerging->FindMergeBaseXF( rPos, pNewCont->nXF ) ) - pNewCont->nXF = rRootData.pXFRecs->Find( pAttr ); + pNewCont->nXF = rRootData.pER->GetXFBuffer().Insert( pAttr ); pNewCont->nVal = nVal; List::Insert( pNewCont, LIST_APPEND ); return NULL; @@ -1143,7 +1047,7 @@ ExcRichStr::ExcRichStr( ExcCell& rExcCell, String& rText, const ScPatternAttr* p } // XF mit Umbruch auswaehlen? - rExcCell.SetXF( nParCnt <= 1 ? rRoot.pXFRecs->Find( pAttr ) : rRoot.pXFRecs->FindWithLineBreak( pAttr ) ); + rExcCell.SetXF( rRoot.pER->GetXFBuffer().Insert( pAttr, nParCnt > 1 ) ); } else { @@ -1232,13 +1136,16 @@ ExcFormula::ExcFormula( const ScPatternAttr* pAttr, RootData& rRootData, const ULONG nAltNumForm, - BOOL bForceAltNumForm, const ScTokenArray& rTokArray, ExcArray** ppArray, ScMatrixMode eMM, ExcShrdFmla** ppShrdFmla, - ExcArrays* pShrdFmlas ) : - ExcCell( rPos, pAttr, rRootData, nAltNumForm, bForceAltNumForm ) + ExcArrays* pShrdFmlas, + ScFormulaCell* pFormulaCell, + ExcFmlaResultStr** pFormulaResult) : + ExcCell( rPos, pAttr, rRootData, nAltNumForm ) , + pFCell(pFormulaCell) + { bShrdFmla = FALSE; EC_Codetype eCodeType; @@ -1314,6 +1221,30 @@ ExcFormula::ExcFormula( delete pExcUPN; + if(pFCell && (pFCell->GetFormatType() == NUMBERFORMAT_TEXT)) + { + String sText; + pFCell->GetString(sText); + XclExpString aFormulaText; + if ( rRootData.eDateiTyp < Biff8 ) + { + aFormulaText.AssignByte(sText,*rRootData.pCharset); + *pFormulaResult = new ExcFmlaResultStr(aFormulaText); + } + else if(sText.Len()) + { + aFormulaText.Assign(sText); + *pFormulaResult = new ExcFmlaResultStr(aFormulaText); + } + else + *pFormulaResult = NULL; + } + else + { + *pFormulaResult = NULL; + } + + /* if( ppShrdFmla && aExcUPN.GetShrdFmla( pData, nFormLen ) ) { // shared formula ref only if( aExcUPN.IsFirstShrdFmla() ) @@ -1358,12 +1289,68 @@ void ExcFormula::SetTableOp( USHORT nCol, USHORT nRow ) ShortToSVBT16( (UINT16) nCol, (BYTE*) &pData[ 3 ] ); } - void ExcFormula::SaveDiff( XclExpStream& rStrm ) {// grbit chn UINT16 nGrBit = bShrdFmla? 0x000B : 0x0003; - rStrm << ( double ) 0.0 << nGrBit << ( UINT32 ) 0x00000000 - << nFormLen; + double fVal = 0.0; + UINT16 nErrorCode = 0; + String sText; + + + if(pFCell) + { + switch(pFCell->GetFormatType()) + { + case NUMBERFORMAT_NUMBER: + if(!(nErrorCode = pFCell->GetErrCode())) + { + fVal = pFCell->GetValue(); + rStrm << fVal; + } + else + { + BYTE nByte = ScErrorCodeToExc(nErrorCode); + rStrm << (UINT8)0x02 + << (UINT8)0 + << (UINT8)nByte + << (UINT16)0 << (UINT8)0 + << (UINT16)0xFFFF; + } + break; + + case NUMBERFORMAT_TEXT: + pFCell->GetString(sText); + if(sText.Len()) + rStrm << (UINT8)0x00 << (UINT32)0 << (UINT8)0 << (UINT16)0xFFFF; + else + { + if ( rStrm.GetRoot().GetBiff() < xlBiff8 ) + rStrm << (UINT8)0x00 << (UINT32)0 << (UINT8)0 << (UINT16)0xFFFF; + else + { + // empty formula result cells are represented by 0x03 in Biff8 + rStrm << (UINT8)0x03 << (UINT32)0 << (UINT8)0 << (UINT16)0xFFFF; + } + } + break; + + case NUMBERFORMAT_LOGICAL: + fVal = pFCell->GetValue(); + rStrm << (UINT8)0x01 + << (UINT8)0 + << (UINT8)((fVal != 0) ? 0x01 : 0x00) + << (UINT16)0 << (UINT8)0 + << (UINT16)0xFFFF; + break; + + default: + rStrm << fVal; + break; + } + } + + rStrm << nGrBit << (UINT32)0x00000000 << nFormLen; + rStrm.Write( pData, nFormLen ); } @@ -1379,6 +1366,33 @@ ULONG ExcFormula::GetDiffLen( void ) const return 16 + nFormLen; } +BYTE ExcFormula::ScErrorCodeToExc(UINT16 nErrorCode) +{ + BYTE nRetVal; + + switch(nErrorCode) + { + case errIllegalFPOperation: //503 to #DIV/0 + nRetVal = 0x07; + break; + case errNoValue : //519 to #VALUE (wrong argument or operand) + nRetVal = 0x0F; + break; + case errNoCode: //521 to #NULL + nRetVal = 0x00; + break; + case errNoRef: //524 to #REF(cell referral not valid) + nRetVal = 0x17; + break; + case errNoName: //525 to #NAME (does not recognise text) + nRetVal = 0x1D; + break; + default: + nRetVal = 0x0F; // all others to #VALUE + break; + } + return nRetVal; +} //---------------------------------------------------- class ExcBlankMulblank - @@ -1432,7 +1446,7 @@ void ExcBlankMulblank::AddEntries( DBG_ASSERT( rPos.Col() + nCount <= MAXCOL + 1, "ExcBlankMulblank::AddEntries - column overflow" ); ScAddress aCurrPos( rPos ); - UINT16 nCellXF = rRootData.pXFRecs->Find( pAttr ); + UINT16 nCellXF = rRootData.pER->GetXFBuffer().Insert( pAttr ); sal_uInt16 nTmpCount = nCount; while( nTmpCount ) @@ -1577,7 +1591,20 @@ void ExcNameListEntry::SetCode( const ExcUPN& rUPN ) void ExcNameListEntry::SaveCont( XclExpStream& rStrm ) { - rStrm << (UINT16) EXC_NAME_BUILTIN // grbit (built in only) + if(rStrm.GetRoot().GetBiff() < xlBiff8) + { + rStrm << (UINT16) EXC_NAME_BUILTIN // grbit (built in only) + << (UINT8) 0x00 // chKey (keyboard shortcut) + << (UINT8) 0x01 // cch (string len) + << nFormLen // cce (formula len) + << nTabNum // set ixals = itab + << nTabNum // itab (table index, 1-based) + << (UINT32) 0x00000000 // cch + << nBuiltInKey; // string + } + else + { + rStrm << (UINT16) EXC_NAME_BUILTIN // grbit (built in only) << (UINT8) 0x00 // chKey (keyboard shortcut) << (UINT8) 0x01 // cch (string len) << nFormLen // cce (formula len) @@ -1586,6 +1613,7 @@ void ExcNameListEntry::SaveCont( XclExpStream& rStrm ) << (UINT32) 0x00000000 // cch << (UINT8) 0x00 // string grbit << nBuiltInKey; // string + } rStrm.Write( pData, nFormLen ); } @@ -1665,6 +1693,10 @@ ExcName::ExcName( RootData& rRootData, ScDBData* pArea ) : String aRangeName; pArea->GetName( aRangeName ); + + if( IsBuiltInAFName( aRangeName, EXC_BUILTIN_AUTOFILTER )) + return; + SetUniqueName( aRangeName ); ScRange aRange; @@ -1740,6 +1772,16 @@ BOOL ExcName::SetBuiltInName( const String& rName, UINT8 nKey ) return FALSE; } +BOOL ExcName::IsBuiltInAFName( const String& rName, UINT8 nKey ) +{ + if( XclTools::IsBuiltInName( nTabNum, rName, nKey ) || + (rName == ScGlobal::GetRscString( STR_DB_NONAME ))) + { + bDummy = TRUE; + return TRUE; + } + return FALSE; +} void ExcName::SaveCont( XclExpStream& rStrm ) { @@ -1893,8 +1935,15 @@ ExcNameList::ExcNameList( RootData& rRootData ) : DBG_ASSERT( pData, "ExcNameList::ExcNameList - missing db area" ); ExcName* pExcName = new ExcName( rRootData, pData ); - nExpIx = Append( pExcName ); - pData->SetExportIndex( nExpIx ); + if( pExcName->IsDummy() ) + { + delete pExcName; + } + else + { + nExpIx = Append( pExcName ); + pData->SetExportIndex( nExpIx ); + } } maNextInsVec.resize( nScTabCount, Count() ); @@ -2092,7 +2141,7 @@ void ExcEGuts::SaveCont( XclExpStream& rStrm ) rStrm << (UINT16)(nRowLevel ? (12 * nRowLevel + 17) : 0) << (UINT16)(nColLevel ? (12 * nColLevel + 17) : 0) << (UINT16)(nRowLevel + (nRowLevel ? 1 : 0)) - << (UINT16)(nColLevel + (nRowLevel ? 1 : 0)); + << (UINT16)(nColLevel + (nColLevel ? 1 : 0)); } @@ -2279,7 +2328,7 @@ ExcColinfo::ExcColinfo( UINT16 nCol, UINT16 nTab, UINT16 nNewXF, RootData& rRoot nXF = nNewXF; - SetWidth( rDoc.GetColWidth( nCol, nTab ), rRoot.fColScale ); + nColWidth = XclTools::GetXclColumnWidth( rDoc.GetColWidth( nCol, nTab ), rRoot.pER->GetCharWidth() ); BYTE nColFlags = rDoc.GetColFlags( nCol, nTab ); nOptions = 0x0000; @@ -2295,18 +2344,6 @@ ExcColinfo::ExcColinfo( UINT16 nCol, UINT16 nTab, UINT16 nNewXF, RootData& rRoot } -void ExcColinfo::SetWidth( UINT16 nWidth, double fColScale ) -{ - double f = nWidth; - f *= 1328.0 / 25.0; - f += 90.0; - f *= 1.0 / 23.0; - f /= fColScale; - - nColWidth = (UINT16) f; -} - - void ExcColinfo::Expand( ExcColinfo*& rpExp ) { if( !rpExp ) return; @@ -2340,226 +2377,6 @@ ULONG ExcColinfo::GetLen( void ) const -//--------------------------------------------------------------- class ExcXf - - -ExcXf::ExcXf( const XclExpRoot& rRoot, UINT16 nFont, UINT16 nForm, const ScPatternAttr* pPattAttr, BOOL& rbWrap, BOOL bSt ) : - XclExpRoot( rRoot ), - bStyle( bSt ) -{ -#ifdef DBG_UTIL - nObjCnt++; -#endif - - bAtrNum = bAtrFnt = bAtrAlc = bAtrBdr = bAtrPat = bAtrProt = !bSt; // always TRUE for cell xfs - - nIfnt = nFont; - nIfmt = nForm; - - if( pPattAttr ) - { - nOffs8 = 0x0000; - const ScProtectionAttr& rProtAttr = (const ScProtectionAttr&) pPattAttr->GetItem( ATTR_PROTECTION ); - if( rProtAttr.GetProtection() ) - nOffs8 |= EXC_XF_LOCKED; - if( rProtAttr.GetHideFormula() || rProtAttr.GetHideCell() ) - nOffs8 |= EXC_XF_HIDDEN; - - switch( ( SvxCellHorJustify ) - ((const SvxHorJustifyItem&)pPattAttr->GetItem( ATTR_HOR_JUSTIFY )).GetValue() ) - { - case SVX_HOR_JUSTIFY_STANDARD: eAlc = xlHAlignGeneral; break; - case SVX_HOR_JUSTIFY_LEFT: eAlc = xlHAlignLeft; break; - case SVX_HOR_JUSTIFY_CENTER: eAlc = xlHAlignCenter; break; - case SVX_HOR_JUSTIFY_RIGHT: eAlc = xlHAlignRight; break; - case SVX_HOR_JUSTIFY_BLOCK: eAlc = xlHAlignJustify; break; - case SVX_HOR_JUSTIFY_REPEAT: eAlc = xlHAlignFill; break; - default: - DBG_ERROR( "ExcXf::ExcXf(): ATTR_HOR_JUSTIFY unbekannt!" ); - eAlc = xlHAlignGeneral; - } - - switch( ( SvxCellVerJustify ) - ((const SvxVerJustifyItem&)pPattAttr->GetItem( ATTR_VER_JUSTIFY )).GetValue() ) - { - case SVX_VER_JUSTIFY_STANDARD: eAlcV = xlVAlignBottom; break; - case SVX_VER_JUSTIFY_TOP: eAlcV = xlVAlignTop; break; - case SVX_VER_JUSTIFY_CENTER: eAlcV = xlVAlignCenter; break; - case SVX_VER_JUSTIFY_BOTTOM: eAlcV = xlVAlignBottom; break; - default: - DBG_ERROR( "ExcXf::ExcXf(): ATTR_VER_JUSTIFY unbekannt!" ); - eAlcV = xlVAlignBottom; - } - - switch( ( SvxCellOrientation ) - ((const SvxOrientationItem&)pPattAttr->GetItem( ATTR_ORIENTATION )).GetValue() ) - { - case SVX_ORIENTATION_STANDARD: eOri = xlTextOrientNoRot; break; - case SVX_ORIENTATION_TOPBOTTOM: eOri = xlTextOrient90cw; break; - case SVX_ORIENTATION_BOTTOMTOP: eOri = xlTextOrient90ccw; break; - case SVX_ORIENTATION_STACKED: eOri = xlTextOrientTopBottom; break; - default: - DBG_ERROR( "ExcXf::ExcXf(): ATTR_ORIENTATION unbekannt!" ); - eOri = xlTextOrientNoRot; - } - - bFWrap = rbWrap || - ( ( BOOL ) ((const SfxBoolItem&)pPattAttr->GetItem( ATTR_LINEBREAK )).GetValue() ); - - // fore-/background - const SvxBrushItem& rBrushItem = ( const SvxBrushItem& ) pPattAttr->GetItem( ATTR_BACKGROUND ); - Color aCol = rBrushItem.GetColor(); - - nFls = aCol.GetTransparency()? 0x0000 : 0x0001; - - nIcvForeSer = GetPalette().InsertColor( aCol, xlColorCellArea ); - nIcvBackSer = GetPalette().InsertColor( Color( COL_BLACK ), xlColorCellArea ); - - // Umrandung - const SvxBoxItem& rBox = ((const SvxBoxItem&)pPattAttr->GetItem( ATTR_BORDER )); - - ScToExcBorderLine( GetPalette(), rBox.GetTop(), nIcvTopSer, nDgTop ); - ScToExcBorderLine( GetPalette(), rBox.GetLeft(), nIcvLftSer, nDgLeft ); - ScToExcBorderLine( GetPalette(), rBox.GetBottom(), nIcvBotSer, nDgBottom ); - ScToExcBorderLine( GetPalette(), rBox.GetRight(), nIcvRigSer, nDgRight ); - - if( bSt ) - { - static const USHORT pFntChkWichs[] = - { - ATTR_FONT_HEIGHT, - ATTR_FONT_WEIGHT, - ATTR_FONT_POSTURE, - ATTR_FONT_UNDERLINE, - ATTR_FONT_CROSSEDOUT, - ATTR_FONT_CONTOUR, - ATTR_FONT_SHADOWED, - ATTR_FONT_COLOR, - ATTR_FONT_LANGUAGE, - 0 - }; - - const SfxItemSet& rSet = pPattAttr->GetItemSet(); - - bAtrNum = rSet.GetItemState( ATTR_VALUE_FORMAT, FALSE ) == SFX_ITEM_SET; - bAtrFnt = pPattAttr->HasItemsSet( pFntChkWichs ); - bAtrAlc = ( rSet.GetItemState( ATTR_HOR_JUSTIFY, FALSE ) == SFX_ITEM_SET ) || - ( rSet.GetItemState( ATTR_VER_JUSTIFY, FALSE ) == SFX_ITEM_SET ) || - ( rSet.GetItemState( ATTR_LINEBREAK, FALSE ) == SFX_ITEM_SET ); - bAtrBdr = rSet.GetItemState( ATTR_BORDER, FALSE ) == SFX_ITEM_SET; - bAtrPat = rSet.GetItemState( ATTR_BACKGROUND, FALSE ) == SFX_ITEM_SET; - bAtrProt = rSet.GetItemState( ATTR_PROTECTION, FALSE ) == SFX_ITEM_SET; - } - } - else - { - nOffs8 = EXC_XF_LOCKED; - eAlc = xlHAlignGeneral; - eAlcV = xlVAlignBottom; - eOri = xlTextOrientNoRot; - bFWrap = FALSE; - nFls = 0x0000; - nIcvBackSer = GetPalette().InsertIndex( 65 ); - nIcvForeSer = GetPalette().InsertIndex( 64 ); - nIcvTopSer = nIcvBotSer = nIcvLftSer = nIcvRigSer = 0; - nDgTop = nDgLeft = nDgBottom = nDgRight = 0; - } - - rbWrap = bFWrap; - - bFSxButton = FALSE; // XF Record attached PivotTable Button -} - - -#ifdef DBG_UTIL -ExcXf::~ExcXf() -{ - nObjCnt--; -} -#endif - - -void ExcXf::ScToExcBorderLine( XclExpPalette& rPalette, const SvxBorderLine* pLine, UINT32& rIcvSer, UINT16& rDg ) -{ - if( !pLine ) - { - rIcvSer = rPalette.InsertIndex( 0 ); - rDg = 0; - return; - } - - rIcvSer = rPalette.InsertColor( pLine->GetColor(), xlColorCellBorder ); - - if( pLine->GetDistance() ) - // doppelte Linien - rDg = 6; - else - {// einfache Linien - UINT16 nOut = pLine->GetOutWidth(); - - if( nOut <= DEF_LINE_WIDTH_1 ) - rDg = 1; - else if( nOut <= DEF_LINE_WIDTH_2 ) - rDg = 2; - else - rDg = 5; - } -} - - -void ExcXf::SaveCont( XclExpStream& rStrm ) -{ - UINT16 nTmp; - - rStrm << nIfnt << nIfmt // Offs 4 + 6 - << nOffs8; // Offs 8 - - nTmp = ( UINT16 ) eAlc; // Offs 10 - nTmp |= 0x0800; // locked - if( bFWrap ) - nTmp += 0x0008; - nTmp += ( ( UINT16 ) eAlcV ) << 4; - nTmp += ( ( UINT16 ) eOri ) << 8; - rStrm << nTmp; - - UINT16 nForeInd, nBackInd; - GetPalette().GetMixedColors( nForeInd, nBackInd, nFls, nIcvForeSer, nIcvBackSer ); - nTmp = nForeInd; // Offs 12 - nTmp |= nBackInd << 7; - - if ( bFSxButton ) - nTmp |= 0x2000; - rStrm << nTmp; - - nTmp = nFls; // Offs 14 - nTmp += nDgBottom << 6; - nTmp |= GetPalette().GetColorIndex( nIcvBotSer ) << 9; - rStrm << nTmp; - - nTmp = nDgTop; // Offs 16 - nTmp += nDgLeft << 3; - nTmp += nDgRight << 6; - nTmp |= GetPalette().GetColorIndex( nIcvTopSer ) << 9; - rStrm << nTmp; - - nTmp = GetPalette().GetColorIndex( nIcvLftSer ); // Offs 18 - nTmp |= GetPalette().GetColorIndex( nIcvRigSer ) << 7; - rStrm << nTmp; -} - - -UINT16 ExcXf::GetNum( void ) const -{ - return 0x00E0; -} - - -ULONG ExcXf::GetLen( void ) const -{ - return 16; -} - - - //------------------------------------------------------ class ExcExterncount - ExcExterncount::ExcExterncount( RootData* pRD, const BOOL bTableNew ) : @@ -2608,7 +2425,7 @@ ExcExternsheet::ExcExternsheet( RootData* pExcRoot, const UINT16 nNewTabNum ) : void ExcExternsheet::SaveCont( XclExpStream& rStrm ) { - rStrm << ( UINT8 ) Min( (xub_StrLen)(aTabName.Len() + 1), (xub_StrLen) 255 ) << ( UINT8 ) 0x03; + rStrm << ( UINT8 ) Min( (xub_StrLen)(aTabName.Len() ), (xub_StrLen) 255 ) << ( UINT8 ) 0x03; rStrm.WriteByteStringBuffer( ByteString( aTabName, *pExcRoot->pCharset ), 254 ); // max 254 chars (leading 0x03!) } @@ -2721,133 +2538,6 @@ ULONG ExcSelection::GetLen( void ) const } -//------------------------------------------------------------ class UsedList - - -void UsedList::Save( XclExpStream& rStrm ) -{ - for( ExcRecord* pExcRec = (ExcRecord*) First(); pExcRec; pExcRec = (ExcRecord*) Next() ) - pExcRec->Save( rStrm ); -} - - - -//-------------------------------------------------------- class UsedAttrList - - -UsedAttrList::UsedAttrList( RootData* pRD ) : - ExcRoot( pRD ), - rFntLst( pRD->pER->GetFontBuffer() ), - rFrmLst( pRD->pER->GetNumFmtBuffer() ) -{ -} - - -UsedAttrList::~UsedAttrList() -{ - for( ENTRY* pEntry = _First(); pEntry; pEntry = _Next() ) - delete pEntry; -} - - -void UsedAttrList::AddNewXF( const ScPatternAttr* pAttr, const BOOL bStyle, const BOOL bExplLineBreak, - const ULONG nAltNumForm, BOOL bForceAltNumForm ) -{ - // Aufbauen der Excel-Daten - ENTRY* pData = new ENTRY; - pData->pPattAttr = pAttr; - pData->bLineBreak = bExplLineBreak; - pData->nAltNumForm = nAltNumForm; - List::Insert( pData, LIST_APPEND ); - - // Font-Daten - UINT16 nFontIndex; - - // Format-Daten - ULONG nScForm; - - if( pAttr ) - { - nFontIndex = rFntLst.Insert( *pAttr ); - - if ( bForceAltNumForm ) - nScForm = nAltNumForm; - else - { - nScForm = (( SfxUInt32Item& ) pAttr->GetItem( ATTR_VALUE_FORMAT )).GetValue(); - - if( nAltNumForm != NUMBERFORMAT_ENTRY_NOT_FOUND && - ( nScForm % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 ) - nScForm = nAltNumForm; - } - } - else - { - nScForm = nAltNumForm; - nFontIndex = 0; - } - - UINT16 nFormatIndex = rFrmLst.Insert( nScForm ); - - if ( pExcRoot->eDateiTyp < Biff8 ) - pData->pXfRec = new ExcXf( *pExcRoot->pER, nFontIndex, nFormatIndex, pAttr, pData->bLineBreak, bStyle ); - else - pData->pXfRec = new ExcXf8( *pExcRoot->pER, nFontIndex, nFormatIndex, pAttr, pData->bLineBreak, bStyle ); -} - - -UINT16 UsedAttrList::Find( const ScPatternAttr* pAttr, const BOOL bStyle, - const UINT32 nAltNumForm, BOOL bForceAltNumForm ) -{ - if( !pAttr && nAltNumForm == NUMBERFORMAT_ENTRY_NOT_FOUND ) - return 15; // default XF - - DBG_ASSERT( nBaseIndex, "*UsedAttrList::Find(): leer == nichtleer?" ); - - UINT16 nC = nBaseIndex; - for( ENTRY* pCurr = _First(); pCurr; pCurr = _Next() ) - { - if( pCurr->Equal( pAttr, nAltNumForm ) ) - return nC; - nC++; - } - - // neuen ausdenken - - AddNewXF( pAttr, bStyle, FALSE, nAltNumForm, bForceAltNumForm ); - - return nC; -} - - -UINT16 UsedAttrList::FindWithLineBreak( const ScPatternAttr* pAttr ) -{ - DBG_ASSERT( nBaseIndex, - "*UsedAttrList::FindWithLineBreak(): leer == nichtleer?" ); - - UINT16 nC = nBaseIndex; - for( ENTRY* pCurr = _First(); pCurr; pCurr = _Next() ) - { - if( pCurr->pPattAttr == pAttr && pCurr->bLineBreak ) - return nC; - nC++; - } - - // neuen ausdenken - - AddNewXF( pAttr, FALSE, TRUE ); - - return nC; -} - - -void UsedAttrList::Save( XclExpStream& rStrm ) -{ - for( ENTRY* pEntry = _First(); pEntry; pEntry = _Next() ) - if( pEntry->pXfRec ) - pEntry->pXfRec->Save( rStrm ); -} - - - // XclExpWsbool =============================================================== XclExpWsbool::XclExpWsbool( RootData& rRootData ) : @@ -3861,6 +3551,24 @@ ULONG ExcShrdFmla::GetLen() const return 10 + nFormLen; } +//----------------------------------------------------------------- + +void ExcFmlaResultStr::WriteBody( XclExpStream& rStrm ) +{ + rStrm << maResultText; +} + + +ExcFmlaResultStr::ExcFmlaResultStr(const XclExpString& aFmlaText) : + XclExpRecord( EXC_ID_STRING ), + maResultText(aFmlaText) +{ +} + + +ExcFmlaResultStr::~ExcFmlaResultStr() +{ +} //--------------------------- class XclExpTableOp, class XclExpTableOpManager - diff --git a/sc/source/filter/excel/exctools.cxx b/sc/source/filter/excel/exctools.cxx index 7d95fa8f2288..95c4625c73e4 100644 --- a/sc/source/filter/excel/exctools.cxx +++ b/sc/source/filter/excel/exctools.cxx @@ -2,9 +2,9 @@ * * $RCSfile: exctools.cxx,v $ * - * $Revision: 1.39 $ + * $Revision: 1.40 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:23 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:32 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -89,7 +89,6 @@ #include "imp_op.hxx" #include "excimp8.hxx" #include "otlnbuff.hxx" -#include "fltprgrs.hxx" #include "excrecds.hxx" #include "xcl97rec.hxx" @@ -124,7 +123,7 @@ String RootData::GetCondFormStyleName( const UINT16 n ) RootData::RootData( void ) { - fColScale = fRowScale = 1.0; + fRowScale = 1.0; pDoc = NULL; pScRangeName = NULL; @@ -153,12 +152,10 @@ RootData::RootData( void ) pCellMerging = NULL; pNameList = NULL; pScNameList = NULL; - pXFRecs = NULL; pExtSheetCntAndRecs = NULL; nRowMax = 0; pObjRecs = NULL; - pNoteRecs = NULL; pEscher = NULL; pPivotCacheList = NULL; @@ -425,82 +422,6 @@ void OutlineBuffer::Reset( ScOutlineArray *pOArray ) -INT32 FilterProgressBar::nInstances = 0; - - -FilterProgressBar::FilterProgressBar( SvStream& rStream ) : pStr( &rStream ), pXIStr( NULL ) -{ - ULONG nOldPos = rStream.Tell(); - rStream.Seek( STREAM_SEEK_TO_END ); - ULONG nStrmLen = rStream.Tell(); - rStream.Seek( nOldPos ); - Init( nOldPos, nStrmLen, STR_LOAD_DOC ); -} - - -FilterProgressBar::FilterProgressBar( XclImpStream& rStream ) : pStr( NULL ), pXIStr( &rStream ) -{ - Init( rStream.Tell(), rStream.GetStreamSize(), STR_LOAD_DOC ); -} - - -FilterProgressBar::FilterProgressBar( UINT32 nObjCount ) : pStr( NULL ), pXIStr( NULL ) -{ - Init( 0, nObjCount, STR_PROGRESS_CALCULATING ); -} - - -FilterProgressBar::~FilterProgressBar() -{ - nInstances--; - - if( pPrgrs ) - delete pPrgrs; -} - - -void FilterProgressBar::Init( ULONG nStartPos, ULONG nSize, USHORT nResStr ) -{ - nInstances++; - - nCnt = 0; - - if( nInstances == 1 ) - { - nUnitSize = (nSize < 128) ? 1 : (nSize / 128); - nNextUnit = 0; - pPrgrs = new ScProgress( NULL, ScGlobal::GetRscString( nResStr ), nSize ); - pPrgrs->SetState( nStartPos ); - } - else - pPrgrs = NULL; -} - - -void FilterProgressBar::Progress( void ) -{ - if( pPrgrs ) - { - UINT32 nNewState; - if( pStr ) - nNewState = pStr->Tell(); - else if( pXIStr ) - nNewState = pXIStr->Tell(); - else - { - nCnt++; - nNewState = nCnt; - } - - if( nNewState >= nNextUnit ) - { - pPrgrs->SetState( nNewState ); - nNextUnit += nUnitSize; - } - } -} - - //___________________________________________________________________ diff --git a/sc/source/filter/excel/expop2.cxx b/sc/source/filter/excel/expop2.cxx index dad17f1c57f5..4f29f8e3b352 100644 --- a/sc/source/filter/excel/expop2.cxx +++ b/sc/source/filter/excel/expop2.cxx @@ -2,9 +2,9 @@ * * $RCSfile: expop2.cxx,v $ * - * $Revision: 1.13 $ + * $Revision: 1.14 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:16:01 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -135,17 +135,6 @@ ExportBiff5::ExportBiff5( SvStorage& rRootStorage, SvStream& aStream, ScDocument if( pExcRoot->fRowScale <= 0.0 ) pExcRoot->fRowScale = 1.0; - double fColScale = pExcRoot->pExtDocOpt->fColScale; - if( fColScale <= 0.0 ) - { - fColScale = aFilterOpt.GetExcelColScale(); - if( fColScale <= 0.0 ) - fColScale = 1.0; - - fColScale *= 1.027027027027; // adjustment for export of calc documents - } - pExcRoot->fColScale = fColScale; - pExcDoc = new ExcDocument( *this ); } diff --git a/sc/source/filter/excel/fontbuff.cxx b/sc/source/filter/excel/fontbuff.cxx index 67e67d97b17f..b6d7906fcddc 100644 --- a/sc/source/filter/excel/fontbuff.cxx +++ b/sc/source/filter/excel/fontbuff.cxx @@ -2,9 +2,9 @@ * * $RCSfile: fontbuff.cxx,v $ * - * $Revision: 1.9 $ + * $Revision: 1.10 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:16:01 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses diff --git a/sc/source/filter/excel/impop.cxx b/sc/source/filter/excel/impop.cxx index 83ca0f808803..7b5245468408 100644 --- a/sc/source/filter/excel/impop.cxx +++ b/sc/source/filter/excel/impop.cxx @@ -2,9 +2,9 @@ * * $RCSfile: impop.cxx,v $ * - * $Revision: 1.47 $ + * $Revision: 1.48 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:24 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -238,10 +238,6 @@ ImportExcel::ImportExcel( SvStream& rSvStrm, ScDocument* pDoc, const String& rBa // options from configuration ScFilterOptions aFilterOpt; - pExcRoot->fColScale = aFilterOpt.GetExcelColScale(); - if( pExcRoot->fColScale <= 0.0 ) - pExcRoot->fColScale = 1.0; - pExcRoot->fRowScale = aFilterOpt.GetExcelRowScale(); if( pExcRoot->fRowScale <= 0.0 ) pExcRoot->fRowScale = 1.0; @@ -497,11 +493,15 @@ void ImportExcel::Row25( void ) void ImportExcel::Bof2( void ) { sal_uInt16 nSubType; +#if SC_XCL_USEDECR maStrm.UseDecryption( false ); +#endif maStrm.Ignore( 2 ); maStrm >> nSubType; SetBiff( xlBiff2 ); +#if SC_XCL_USEDECR maStrm.UseDecryption( true ); +#endif pExcRoot->eHauptDateiTyp = Biff2; if( nSubType == 0x0010 ) // Worksheet? @@ -563,7 +563,7 @@ void ImportExcel::Externsheet( void ) bool bSameWorkBook; aIn.AppendByteString( aEncodedUrl, false ); XclImpUrlHelper::DecodeUrl( aUrl, aTabName, bSameWorkBook, *pExcRoot->pIR, aEncodedUrl ); - ScfTools::ConvertName( aTabName ); + ScfTools::ConvertToScSheetName( aTabName ); pExcRoot->pExtSheetBuff->Add( aUrl, aTabName, bSameWorkBook ); } @@ -584,7 +584,7 @@ void ImportExcel::Name25( void ) // Namen einlesen String aName( aIn.ReadRawByteString( nLenName ) ); - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScDefinedName( aName ); pFormConv->Reset(); if( nAttr0 & 0x02 ) @@ -626,13 +626,18 @@ void ImportExcel::Name25( void ) sal_Char cFirstNameChar = ( sal_Char ) aName.GetChar( 0 ); const BOOL bPrintArea = bBuildIn && ( cFirstNameChar == EXC_BUILTIN_PRINTAREA ); const BOOL bPrintTitles = bBuildIn && ( cFirstNameChar == EXC_BUILTIN_PRINTTITLES ); + RangeType eNameType = RT_ABSAREA; + + if(bPrintArea) + eNameType = RT_PRINTAREA; + if( bBuildIn ) {// Build-in name XclTools::GetBuiltInName( aName, cFirstNameChar, nSheet ); } else - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScDefinedName( aName ); pFormConv->Reset(); if( nOpt & (EXC_NAME_VB | EXC_NAME_BIG) ) @@ -658,7 +663,7 @@ void ImportExcel::Name25( void ) pExcRoot->pRNameBuff->Store( aName, NULL, nSheet ); else // ohne hidden - pExcRoot->pRNameBuff->Store( aName, pErgebnis, nSheet, bPrintArea ); + pExcRoot->pRNameBuff->Store( aName, pErgebnis, nSheet, eNameType); }// ----------------------------------------- Ende fuer Biff5 } @@ -821,7 +826,7 @@ void ImportExcel::Externname25( void ) if( ( nOpt & 0x0001 ) || ( ( nOpt & 0xFFFE ) == 0x0000 ) ) {// external name - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScDefinedName( aName ); pExcRoot->pExtNameBuff->AddName( aName ); } else if( nOpt & 0x0010 ) @@ -845,7 +850,8 @@ void ImportExcel::Colwidth( void ) if( nColLast > MAXCOL ) nColLast = MAXCOL; - pColRowBuff->SetWidthRange( nColFirst, nColLast, CalcColWidth( nColWidth ) ); + sal_uInt16 nScWidth = XclTools::GetScColumnWidth( nColWidth, GetCharWidth() ); + pColRowBuff->SetWidthRange( nColFirst, nColLast, nScWidth ); } @@ -932,6 +938,7 @@ void ImportExcel::DocProtect( void ) BOOL ImportExcel::Filepass( void ) { +#if SC_XCL_USEDECR if( pExcRoot->eHauptDateiTyp <= Biff5 ) { aIn.UseDecryption( false ); @@ -958,6 +965,7 @@ BOOL ImportExcel::Filepass( void ) return !bValid; } else +#endif // POST: return = TRUE, wenn Password <> 0 return aIn.ReaduInt32() != 0; } @@ -1003,10 +1011,16 @@ void ImportExcel::Ixfe( void ) void ImportExcel::DefColWidth( void ) { - UINT16 nWidth; - aIn >> nWidth; + // stored as entire characters -> convert to 1/256 of characters (as in COLINFO) + double fDefWidth = 256.0 * maStrm.ReaduInt16(); + + // #i3006# additional space for default width - Excel adds space depending on font size + long nFontHt = GetFontBuffer().GetAppFontData().mnHeight; + fDefWidth += 40960.0 / ::std::max( nFontHt - 15L, 60L ) + 50.0; + fDefWidth = ::std::min( fDefWidth, 65535.0 ); - pColRowBuff->SetDefWidth( CalcColWidth( (UINT16) ( (double)nWidth * 292.5 ) ) ); + sal_uInt16 nScWidth = XclTools::GetScColumnWidth( static_cast< sal_uInt16 >( fDefWidth ), GetCharWidth() ); + pColRowBuff->SetDefWidth( nScWidth ); } @@ -1034,7 +1048,8 @@ void ImportExcel::Colinfo( void ) if( nOpt & EXC_COL_HIDDEN ) // Cols hidden? pColRowBuff->HideColRange( nColFirst, nColLast ); - pColRowBuff->SetWidthRange( nColFirst, nColLast, CalcColWidth( nColWidth ) ); + sal_uInt16 nScWidth = XclTools::GetScColumnWidth( nColWidth, GetCharWidth() ); + pColRowBuff->SetWidthRange( nColFirst, nColLast, nScWidth ); pColRowBuff->SetDefaultXF( nColFirst, nColLast, nXF ); } @@ -1112,7 +1127,7 @@ void ImportExcel::Boundsheet( void ) nGrbit = 0x0000; String aName( aIn.ReadByteString( FALSE ) ); - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScSheetName( aName ); *pExcRoot->pTabNameBuff << aName; @@ -1199,10 +1214,8 @@ void ImportExcel::Palette( void ) void ImportExcel::Standardwidth( void ) { - UINT16 nWidth; - aIn >> nWidth; - - pColRowBuff->SetDefWidth( CalcColWidth( nWidth ), TRUE ); + sal_uInt16 nScWidth = XclTools::GetScColumnWidth( maStrm.ReaduInt16(), GetCharWidth() ); + pColRowBuff->SetDefWidth( nScWidth, TRUE ); } @@ -1634,11 +1647,15 @@ void ImportExcel::Row34( void ) void ImportExcel::Bof3( void ) { sal_uInt16 nSubType; +#if SC_XCL_USEDECR maStrm.UseDecryption( false ); +#endif maStrm.Ignore( 2 ); maStrm >> nSubType; SetBiff( xlBiff3 ); +#if SC_XCL_USEDECR maStrm.UseDecryption( true ); +#endif DBG_ASSERT( nSubType != 0x0100, "*ImportExcel::Bof3(): Biff3 als Workbook?!" ); pExcRoot->eHauptDateiTyp = Biff3; @@ -1685,7 +1702,7 @@ void ImportExcel::Name34( void ) } else { - ScfTools::ConvertName( aName ); + ScfTools::ConvertToScDefinedName( aName ); bPrintArea = bPrintTitles = bBuildIn = FALSE; } @@ -1725,7 +1742,7 @@ void ImportExcel::Array34( void ) BYTE nFirstCol, nLastCol; aIn >> nFirstRow >> nLastRow >> nFirstCol >> nLastCol; - aIn.Ignore( 6 ); + aIn.Ignore( (pExcRoot->eHauptDateiTyp >= Biff5) ? 6 : 2 ); aIn >> nFormLen; if( nLastRow <= MAXROW && nLastCol <= MAXCOL ) @@ -1864,11 +1881,15 @@ void ImportExcel::Window2_5( void ) void ImportExcel::Bof4( void ) { sal_uInt16 nSubType; +#if SC_XCL_USEDECR maStrm.UseDecryption( false ); +#endif maStrm.Ignore( 2 ); maStrm >> nSubType; SetBiff( xlBiff4 ); +#if SC_XCL_USEDECR maStrm.UseDecryption( true ); +#endif pExcRoot->eHauptDateiTyp = Biff4; if( nSubType == 0x0010 ) // Sheet? @@ -1894,10 +1915,14 @@ void ImportExcel::Bof5( void ) BiffTyp eHaupt = Biff5; BiffTyp eDatei; +#if SC_XCL_USEDECR maStrm.UseDecryption( false ); +#endif maStrm >> nVers >> nSubType; SetBiff( (nVers == 0x0600) ? xlBiff8 : xlBiff5 ); +#if SC_XCL_USEDECR maStrm.UseDecryption( true ); +#endif switch( nSubType ) { @@ -1961,6 +1986,21 @@ void ImportExcel::EndSheet( void ) if( pExcRoot->eHauptDateiTyp < Biff8 ) pExcRoot->pExtNameBuff->Reset(); + + // no or empty HEADER record + if( !bHasHeader ) + { + SvxSetItem aHeaderSetItem( (const SvxSetItem&) pStyleSheetItemSet->Get( ATTR_PAGE_HEADERSET ) ); + aHeaderSetItem.GetItemSet().Put( SfxBoolItem( ATTR_PAGE_ON, sal_False ) ); + pStyleSheetItemSet->Put( aHeaderSetItem ); + } + // no or empty FOOTER record + if( !bHasFooter ) + { + SvxSetItem aFooterSetItem( (const SvxSetItem&) pStyleSheetItemSet->Get( ATTR_PAGE_FOOTERSET ) ); + aFooterSetItem.GetItemSet().Put( SfxBoolItem( ATTR_PAGE_ON, sal_False ) ); + pStyleSheetItemSet->Put( aFooterSetItem ); + } } @@ -1975,7 +2015,7 @@ void ImportExcel::NeueTabelle( void ) ScStyleSheetPool* pStyleShPool = pD->GetStyleSheetPool(); SfxStyleSheetBase* pStyleSh = pStyleShPool->Find( aStyleName, SFX_STYLE_FAMILY_PAGE ); - pStyleSheetItemSet = pStyleSh ? &pStyleSh->GetItemSet() : + pExcRoot->pStyleSheetItemSet = pStyleSheetItemSet = pStyleSh ? &pStyleSh->GetItemSet() : &pStyleShPool->Make( aStyleName, SFX_STYLE_FAMILY_PAGE, SFXSTYLEBIT_USERDEF ).GetItemSet(); pExcRoot->bDefaultPage = TRUE; @@ -2160,7 +2200,6 @@ void ImportExcel::PostDocLoad( void ) } } - pExcRoot->pExtDocOpt->fColScale = pExcRoot->fColScale; pD->SetExtDocOptions( pExcRoot->pExtDocOpt ); pExcRoot->pExtDocOpt = NULL; @@ -2230,21 +2269,6 @@ void ImportExcel::PostDocLoad( void ) } } } - - // no or empty HEADER record - if( !bHasHeader ) - { - SvxSetItem aHeaderSetItem( (const SvxSetItem&) pStyleSheetItemSet->Get( ATTR_PAGE_HEADERSET ) ); - aHeaderSetItem.GetItemSet().Put( SfxBoolItem( ATTR_PAGE_ON, sal_False ) ); - pStyleSheetItemSet->Put( aHeaderSetItem ); - } - // no or empty FOOTER record - if( !bHasFooter ) - { - SvxSetItem aFooterSetItem( (const SvxSetItem&) pStyleSheetItemSet->Get( ATTR_PAGE_FOOTERSET ) ); - aFooterSetItem.GetItemSet().Put( SfxBoolItem( ATTR_PAGE_ON, sal_False ) ); - pStyleSheetItemSet->Put( aFooterSetItem ); - } } @@ -2277,22 +2301,6 @@ void ImportExcel::SetTextCell( const UINT16 nC, const UINT16 nR, String& r, cons } -UINT16 ImportExcel::CalcColWidth( const UINT16 n ) -{ - double f = ( double ) n; - - f *= pExcRoot->fColScale; - f *= 23.0; - f -= 90.0; - f *= 25.0 / 1328.0; - - if( f < 0.0 ) - f = 0.0; - - return ( UINT16 ) f; -} - - void ImportExcel::SetMarginItem( SfxItemSet& rItemSet, double fMarginInch, XclMarginType eType ) { sal_uInt16 nMarginTwips = XclTools::GetTwipsFromInch( fMarginInch ); diff --git a/sc/source/filter/excel/makefile.mk b/sc/source/filter/excel/makefile.mk index 7e591e41d9c8..b02c12c73543 100644 --- a/sc/source/filter/excel/makefile.mk +++ b/sc/source/filter/excel/makefile.mk @@ -2,9 +2,9 @@ # # $RCSfile: makefile.mk,v $ # -# $Revision: 1.16 $ +# $Revision: 1.17 $ # -# last change: $Author: dr $ $Date: 2002-11-21 12:16:01 $ +# last change: $Author: hr $ $Date: 2003-03-26 18:04:33 $ # # The Contents of this file are made available subject to the terms of # either of the following licenses @@ -84,6 +84,7 @@ SLOFILES = \ $(SLO)$/xltools.obj \ $(SLO)$/xlroot.obj \ $(SLO)$/xlstyle.obj \ + $(SLO)$/xlocx.obj \ $(SLO)$/xistream.obj \ $(SLO)$/xiroot.obj \ $(SLO)$/xihelper.obj \ diff --git a/sc/source/filter/excel/namebuff.cxx b/sc/source/filter/excel/namebuff.cxx index d1fc21931936..cef2aa3dbd0e 100644 --- a/sc/source/filter/excel/namebuff.cxx +++ b/sc/source/filter/excel/namebuff.cxx @@ -2,9 +2,9 @@ * * $RCSfile: namebuff.cxx,v $ * - * $Revision: 1.13 $ + * $Revision: 1.14 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:24 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -169,14 +169,14 @@ BOOL NameBuffer::Find( const sal_Char* pRefName, UINT16& rIndex ) -void RangeNameBuffer::Store( ByteString& r, const ScTokenArray* p, UINT16 n, const BOOL b ) +void RangeNameBuffer::Store( ByteString& r, const ScTokenArray* p, UINT16 n, const RangeType t) { String aTmpStr( r, *pExcRoot->pCharset ); - Store( aTmpStr, p, n, b ); + Store( aTmpStr, p, n, t ); } -void RangeNameBuffer::Store( String& rName, const ScTokenArray* pDef, UINT16 nAltSheet, const BOOL bPrintarea ) +void RangeNameBuffer::Store( String& rName, const ScTokenArray* pDef, UINT16 nAltSheet, const RangeType eNameType) { if( pDef ) { @@ -196,8 +196,12 @@ void RangeNameBuffer::Store( String& rName, const ScTokenArray* pDef, UINT16 nAl pData->GuessPosition(); pData->SetIndex( ( UINT16 ) Count() ); - if( bPrintarea ) - pData->AddType( RT_PRINTAREA ); + if( eNameType == RT_PRINTAREA ) + pData->AddType( eNameType ); + else if( eNameType == RT_CRITERIA ) + pData->SetType( eNameType ); + else if( eNameType == RT_NAME ) + pData->SetType( eNameType ); pExcRoot->pScRangeName->Insert( pData ); diff --git a/sc/source/filter/excel/read.cxx b/sc/source/filter/excel/read.cxx index eba5cc7ddafd..784047423ce5 100644 --- a/sc/source/filter/excel/read.cxx +++ b/sc/source/filter/excel/read.cxx @@ -2,9 +2,9 @@ * * $RCSfile: read.cxx,v $ * - * $Revision: 1.36 $ + * $Revision: 1.37 $ * - * last change: $Author: jmarmion $ $Date: 2002-12-10 14:07:24 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:34 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -148,9 +148,8 @@ FltError ImportExcel::Read( void ) DBG_ASSERT( &aIn != NULL, "-ImportExcel::Read(): Kein Stream - wie dass?!" ); - ::std::auto_ptr< ScfProgressBar > pProgress( new ScfProgressBar( ScGlobal::GetRscString( STR_LOAD_DOC ) ) ); - sal_uInt32 nStreamSeg = pProgress->AddSegment( aIn.GetStreamSize() ); - pProgress->ActivateSegment( nStreamSeg ); + ::std::auto_ptr< ScfSimpleProgressBar > pProgress( new ScfSimpleProgressBar( + aIn.GetStreamSize(), GetDocShell(), STR_LOAD_DOC ) ); while( eAkt != Z_Ende ) { @@ -1015,8 +1014,6 @@ FltError ImportExcel8::Read( void ) } #endif - CreateTmpCtrlStorage(); - UINT16 nOpcode; // aktueller Opcode UINT16 nBofLevel = 0; @@ -1042,9 +1039,8 @@ FltError ImportExcel8::Read( void ) DBG_ASSERT( &aIn != NULL, "-ImportExcel8::Read(): Kein Stream - wie dass?!" ); - ::std::auto_ptr< ScfProgressBar > pProgress( new ScfProgressBar( ScGlobal::GetRscString( STR_LOAD_DOC ) ) ); - sal_uInt32 nStreamSeg = pProgress->AddSegment( aIn.GetStreamSize() ); - pProgress->ActivateSegment( nStreamSeg ); + ::std::auto_ptr< ScfSimpleProgressBar > pProgress( new ScfSimpleProgressBar( + aIn.GetStreamSize(), GetDocShell(), STR_LOAD_DOC ) ); bObjSection = FALSE; @@ -1197,7 +1193,7 @@ FltError ImportExcel8::Read( void ) NeueTabelle(); if( pExcRoot->eDateiTyp == Biff8C ) { - if( bWithDrawLayer && aObjManager.IsCurrObjChart() ) + if( bWithDrawLayer && GetObjectManager().IsCurrObjChart() ) ReadChart8( *pProgress, FALSE ); // zunaechst Return vergessen else {// Stream-Teil mit Chart ueberlesen @@ -1256,7 +1252,7 @@ FltError ImportExcel8::Read( void ) case EXC_ID_HLINK: XclImpHyperlink::ReadHlink( maStrm ); break; case EXC_ID_LABELRANGES: XclImpLabelranges::ReadLabelranges( maStrm ); break; - case EXC_ID_DVAL: XclImpValidation::ReadDval( maStrm, *this ); break; + case EXC_ID_DVAL: XclImpValidation::ReadDval( maStrm ); break; case EXC_ID_DV: XclImpValidation::ReadDv( maStrm, *pFormConv ); break; case EXC_ID_QSI: GetWebQueryBuffer().ReadQsi( maStrm ); break; @@ -1299,7 +1295,7 @@ FltError ImportExcel8::Read( void ) { Bof5(); if( pExcRoot->eDateiTyp == Biff8C && bWithDrawLayer && - aObjManager.IsCurrObjChart() ) + GetObjectManager().IsCurrObjChart() ) ReadChart8( *pProgress, FALSE ); // zunaechst Return vergessen else { @@ -1359,7 +1355,7 @@ FltError ImportExcel8::Read( void ) Bof5(); NeueTabelle(); - aObjManager.InsertDummyObj(); + GetObjectManager().InsertDummyObj(); switch( pExcRoot->eDateiTyp ) { @@ -1372,7 +1368,7 @@ FltError ImportExcel8::Read( void ) aIn.StoreGlobalPosition(); break; case Biff8C: - aObjManager.SetNewCurrObjChart(); + GetObjectManager().SetNewCurrObjChart(); pExcRoot->bChartTab = TRUE; ReadChart8( *pProgress, TRUE ); pExcRoot->bChartTab = FALSE; @@ -1500,7 +1496,7 @@ FltError ImportExcel8::Read( void ) //___________________________________________________________________ -FltError ImportExcel8::ReadChart8( ScfProgressBar& rProgress, const BOOL bOwnTab ) +FltError ImportExcel8::ReadChart8( ScfSimpleProgressBar& rProgress, const BOOL bOwnTab ) { bFirstScl = TRUE; @@ -1508,7 +1504,7 @@ FltError ImportExcel8::ReadChart8( ScfProgressBar& rProgress, const BOOL bOwnTab BOOL bLoop; UINT16 nOpcode; // current opcode - XclImpChart* pChart = aObjManager.GetCurrChartData(); + XclImpChart* pChart = GetObjectManager().GetCurrChartData(); if( !pChart ) { bLoop = TRUE; @@ -1554,11 +1550,11 @@ FltError ImportExcel8::ReadChart8( ScfProgressBar& rProgress, const BOOL bOwnTab case 0x100D: pChart->ReadSeriestext( aIn ); break; // SERIESTEXT case 0x1014: pChart->ReadChartformat(); break; // CHARTFORMAT case 0x1015: pChart->ReadLegend( aIn ); break; // LEGEND - case 0x1017: pChart = aObjManager.ReplaceChartData( aIn, ctBar ); break; // BAR - case 0x1018: pChart = aObjManager.ReplaceChartData( aIn, ctLine ); break; // LINE - case 0x1019: pChart = aObjManager.ReplaceChartData( aIn, ctPie ); break; // PIE - case 0x101A: pChart = aObjManager.ReplaceChartData( aIn, ctArea ); break; // AREA - case 0x101B: pChart = aObjManager.ReplaceChartData( aIn, ctScatter );break; // SCATTER + case 0x1017: pChart = GetObjectManager().ReplaceChartData( aIn, ctBar ); break; // BAR + case 0x1018: pChart = GetObjectManager().ReplaceChartData( aIn, ctLine ); break; // LINE + case 0x1019: pChart = GetObjectManager().ReplaceChartData( aIn, ctPie ); break; // PIE + case 0x101A: pChart = GetObjectManager().ReplaceChartData( aIn, ctArea ); break; // AREA + case 0x101B: pChart = GetObjectManager().ReplaceChartData( aIn, ctScatter );break; // SCATTER case 0x101C: pChart->ReadChartline( aIn ); break; // CHARTLINE case 0x101D: pChart->ReadAxis( aIn ); break; // AXIS case 0x101E: pChart->ReadTick( aIn ); break; // TICK @@ -1576,8 +1572,8 @@ FltError ImportExcel8::ReadChart8( ScfProgressBar& rProgress, const BOOL bOwnTab case 0x103A: pChart->Read3D( aIn ); break; // 3D case 0x103C: pChart->ReadPicf( aIn ); break; // PICF case 0x103D: pChart->ReadDropbar( aIn ); break; // DROPBAR - case 0x103E: pChart = aObjManager.ReplaceChartData( aIn, ctNet ); break; // RADAR - case 0x103F: pChart = aObjManager.ReplaceChartData( aIn, ctSurface );break; // SURFACE + case 0x103E: pChart = GetObjectManager().ReplaceChartData( aIn, ctNet ); break; // RADAR + case 0x103F: pChart = GetObjectManager().ReplaceChartData( aIn, ctSurface );break; // SURFACE case 0x1041: pChart->ReadAxisparent( aIn ); break; // AXISPARENT case 0x1045: pChart->ReadSertocrt( aIn ); break; // SERTOCRT case 0x1046: pChart->ReadAxesused( aIn ); break; // AXESUSED diff --git a/sc/source/filter/excel/xecontent.cxx b/sc/source/filter/excel/xecontent.cxx index bc75b2b5869f..2ffbb9785ebc 100644 --- a/sc/source/filter/excel/xecontent.cxx +++ b/sc/source/filter/excel/xecontent.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xecontent.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:24 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:34 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses diff --git a/sc/source/filter/excel/xehelper.cxx b/sc/source/filter/excel/xehelper.cxx index 272108bcc002..fb838eca6ba3 100644 --- a/sc/source/filter/excel/xehelper.cxx +++ b/sc/source/filter/excel/xehelper.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xehelper.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:25 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:34 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -694,10 +694,29 @@ void XclExpHFConverter::AppendPortion( String& rHFString, const EditTextObject* aParaText.AppendAscii( "&D" ); else if( pFieldData->ISA( SvxTimeField ) || pFieldData->ISA( SvxExtTimeField ) ) aParaText.AppendAscii( "&T" ); - else if( pFieldData->ISA( SvxFileField ) || pFieldData->ISA( SvxExtFileField ) ) - aParaText.AppendAscii( "&F" ); else if( pFieldData->ISA( SvxTableField ) ) aParaText.AppendAscii( "&A" ); + else if( pFieldData->ISA( SvxFileField ) ) // title -> file name + aParaText.AppendAscii( "&F" ); + else if( pFieldData->ISA( SvxExtFileField ) ) + { + const SvxExtFileField* pFileField = static_cast< const SvxExtFileField* >( pFieldData ); + switch( pFileField->GetFormat() ) + { + case SVXFILEFORMAT_NAME_EXT: + case SVXFILEFORMAT_NAME: + aParaText.AppendAscii( "&F" ); + break; + case SVXFILEFORMAT_PATH: + aParaText.AppendAscii( "&Z" ); + break; + case SVXFILEFORMAT_FULLPATH: + aParaText.AppendAscii( "&Z&F" ); + break; + default: + DBG_ERRORFILE( "XclExpHFConverter::AppendPortion - unknown file field" ); + } + } } } else diff --git a/sc/source/filter/excel/xelink.cxx b/sc/source/filter/excel/xelink.cxx index 199f3b98da87..8391fb3e7fc5 100644 --- a/sc/source/filter/excel/xelink.cxx +++ b/sc/source/filter/excel/xelink.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xelink.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:25 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:34 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses diff --git a/sc/source/filter/excel/xerecord.cxx b/sc/source/filter/excel/xerecord.cxx index 1212eda87304..fecc93d55911 100644 --- a/sc/source/filter/excel/xerecord.cxx +++ b/sc/source/filter/excel/xerecord.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xerecord.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:12:49 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:35 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -82,6 +82,12 @@ void XclExpRecordBase::Save( XclExpStream& rStrm ) { } +void XclExpRecordBase::SaveRepeated( XclExpStream& rStrm, sal_uInt32 nCount ) +{ + for( sal_uInt32 nIndex = 0; nIndex < nCount; ++nIndex ) + Save( rStrm ); +} + // ---------------------------------------------------------------------------- @@ -95,6 +101,12 @@ XclExpRecord::~XclExpRecord() { } +void XclExpRecord::SetRecHeader( sal_uInt16 nRecId, sal_uInt32 nRecSize ) +{ + SetRecId( nRecId ); + SetRecSize( nRecSize ); +} + void XclExpRecord::WriteBody( XclExpStream& rStrm ) { } @@ -118,6 +130,26 @@ void XclExpBoolRecord::WriteBody( XclExpStream& rStrm ) // ---------------------------------------------------------------------------- +XclExpDummyRecord::XclExpDummyRecord( sal_uInt16 nRecId, const void* pRecData, sal_uInt32 nRecSize ) : + XclExpRecord( nRecId ) +{ + SetData( pRecData, nRecSize ); +} + +void XclExpDummyRecord::SetData( const void* pRecData, sal_uInt32 nRecSize ) +{ + mpData = pRecData; + SetRecSize( pRecData ? nRecSize : 0 ); +} + +void XclExpDummyRecord::WriteBody( XclExpStream& rStrm ) +{ + rStrm.Write( mpData, GetRecSize() ); +} + + +// ---------------------------------------------------------------------------- + void XclExpRefRecord::Save( XclExpStream& rStrm ) { mrRec.Save( rStrm ); diff --git a/sc/source/filter/excel/xeroot.cxx b/sc/source/filter/excel/xeroot.cxx index 3cf6f73e92fd..347c40884383 100644 --- a/sc/source/filter/excel/xeroot.cxx +++ b/sc/source/filter/excel/xeroot.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xeroot.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:26 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:35 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -81,6 +81,7 @@ #include "xecontent.hxx" #endif +#include <patattr.hxx> // Global data ================================================================ @@ -101,11 +102,12 @@ XclExpRoot::XclExpRoot( XclExpRootData& rExpRootData ) : XclRoot( rExpRootData ), mrExpData( rExpRootData ) { - mrExpData.mpPalette.reset( new XclExpPalette( *this ) ); - mrExpData.mpFontBuffer.reset( new XclExpFontBuffer( *this ) ); - mrExpData.mpNumFmtBuffer.reset( new XclExpNumFmtBuffer( *this ) ); + mrExpData.mpPalette.reset( new XclExpPalette( GetRoot() ) ); + mrExpData.mpFontBuffer.reset( new XclExpFontBuffer( GetRoot() ) ); + mrExpData.mpNumFmtBuffer.reset( new XclExpNumFmtBuffer( GetRoot() ) ); + mrExpData.mpXFBuffer.reset( new XclExpXFBuffer( GetRoot() ) ); mrExpData.mpTabIdBuffer.reset( new XclExpTabIdBuffer( GetDoc() ) ); - mrExpData.mpLinkManager.reset( new XclExpLinkManager( *this ) ); + mrExpData.mpLinkManager.reset( new XclExpLinkManager( GetRoot() ) ); } XclExpRoot::XclExpRoot( const XclExpRoot& rRoot ) : @@ -123,9 +125,9 @@ XclExpRoot& XclExpRoot::operator=( const XclExpRoot& rRoot ) void XclExpRoot::SetBiff( XclBiff eBiff ) { XclRoot::SetBiff( eBiff ); - GetPalette().SetBiff( eBiff ); - GetFontBuffer().SetBiff( eBiff ); - GetNumFmtBuffer().SetBiff( eBiff ); + GetPalette().OnChangeBiff(); + GetFontBuffer().OnChangeBiff(); + GetNumFmtBuffer().OnChangeBiff(); } XclExpSst& XclExpRoot::GetSst() const @@ -150,6 +152,11 @@ XclExpNumFmtBuffer& XclExpRoot::GetNumFmtBuffer() const return *mrExpData.mpNumFmtBuffer; } +XclExpXFBuffer& XclExpRoot::GetXFBuffer() const +{ + return *mrExpData.mpXFBuffer; +} + XclExpTabIdBuffer& XclExpRoot::GetTabIdBuffer() const { return *mrExpData.mpTabIdBuffer; diff --git a/sc/source/filter/excel/xestream.cxx b/sc/source/filter/excel/xestream.cxx index b7e69696a6d4..2b4e25019429 100644 --- a/sc/source/filter/excel/xestream.cxx +++ b/sc/source/filter/excel/xestream.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xestream.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:26 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:35 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses diff --git a/sc/source/filter/excel/xestyle.cxx b/sc/source/filter/excel/xestyle.cxx index 57655f89d0c7..ad8104e74db3 100644 --- a/sc/source/filter/excel/xestyle.cxx +++ b/sc/source/filter/excel/xestyle.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xestyle.cxx,v $ * - * $Revision: 1.3 $ + * $Revision: 1.4 $ * - * last change: $Author: dr $ $Date: 2002-12-12 16:42:32 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:35 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -76,24 +76,52 @@ #ifndef _SV_FONTCVT_HXX #include <vcl/fontcvt.hxx> #endif -#ifndef _ZFORLIST_HXX -#include <svtools/zforlist.hxx> -#endif #ifndef _ZFORMAT_HXX #include <svtools/zformat.hxx> #endif +#ifndef SC_ITEMS_HXX +#include "scitems.hxx" +#endif +#ifndef _SVX_ALGITEM_HXX +#include <svx/algitem.hxx> +#endif +#ifndef _SVX_BOXITEM_HXX +#include <svx/boxitem.hxx> +#endif +#ifndef _SVX_ROTMODIT_HXX +#include <svx/rotmodit.hxx> +#endif +#ifndef _SVX_COLRITEM_HXX +#include <svx/colritem.hxx> +#endif +#ifndef _SVX_BRSHITEM_HXX +#include <svx/brshitem.hxx> +#endif +#ifndef _SVX_FRMDIRITEM_HXX +#include <svx/frmdiritem.hxx> +#endif + #ifndef SC_DOCUMENT_HXX #include "document.hxx" #endif +#ifndef SC_STLPOOL_HXX +#include "stlpool.hxx" +#endif #ifndef SC_SCPATATR_HXX #include "patattr.hxx" #endif +#ifndef SC_SCATTR_HXX +#include "attrib.hxx" +#endif #ifndef SC_XEHELPER_HXX #include "xehelper.hxx" #endif +#ifndef _RTL_TENCINFO_H +#include <rtl/tencinfo.h> +#endif // PALETTE record - color information ========================================= @@ -124,7 +152,7 @@ inline XclExpStream& operator<<( XclExpStream& rStrm, const Color& rColor ) // additional classes for color reduction ------------------------------------- /** Maps a color list index to a palette index. - @descr Used to remap the CID data vector from list indexes to palette indexes. */ + @descr Used to remap the color ID data vector from list indexes to palette indexes. */ struct XclRemap { sal_uInt32 mnPalIndex; /// Index to palette. @@ -152,9 +180,9 @@ typedef ::std::vector< XclNearest > XclNearestVec; IMPL_FIXEDMEMPOOL_NEWDEL( XclExpPalette::XclListColor, 100, 100 ) -XclExpPalette::XclListColor::XclListColor( const Color& rColor, sal_uInt32 nCID ) : +XclExpPalette::XclListColor::XclListColor( const Color& rColor, sal_uInt32 nColorId ) : maColor( rColor ), - mnCID( nCID ), + mnColorId( nColorId ), mnWeight( 0 ) { } @@ -198,16 +226,18 @@ const sal_Int32 EXC_PAL_MAXDIST = 0x7FFFFFFF; XclExpPalette::XclExpPalette( const XclExpRoot& rRoot ) : XclExpRecord( EXC_ID_PALETTE ), + XclDefaultPalette( rRoot.GetBiff() ), + XclExpRoot( rRoot ), mnLastIx( 0 ) { - SetRecSize( GetColorCount() * 4 + 2 ); InsertColor( Color( COL_BLACK ), xlColorCellText ); - SetBiff( rRoot.GetBiff() ); + OnChangeBiff(); } -void XclExpPalette::SetBiff( XclBiff eBiff ) +void XclExpPalette::OnChangeBiff() { - XclDefaultPalette::SetBiff( eBiff ); + SetDefaultColors( GetBiff() ); + SetRecSize( GetColorCount() * 4 + 2 ); // initialize maPalette with default colors sal_uInt32 nCount = GetColorCount(); @@ -232,7 +262,7 @@ sal_uInt32 XclExpPalette::InsertColor( const Color& rColor, XclColorType eType, pEntry->UpdateWeighting( eType ); mnLastIx = nIndex; - return pEntry->GetCID(); + return pEntry->GetColorId(); } sal_uInt32 XclExpPalette::InsertIndex( sal_uInt16 nIndex ) @@ -242,19 +272,19 @@ sal_uInt32 XclExpPalette::InsertIndex( sal_uInt16 nIndex ) void XclExpPalette::ReduceColors() { -// --- build initial CID data vector (maCIDDataVec) --- +// --- build initial color ID data vector (maColorIdDataVec) --- sal_uInt32 nCount = maColorList.Count(); - maCIDDataVec.resize( nCount ); + maColorIdDataVec.resize( nCount ); for( sal_uInt32 nIx = 0; nIx < nCount; ++nIx ) { XclListColor* pListColor = maColorList.GetObject( nIx ); - maCIDDataVec[ pListColor->GetCID() ].Set( pListColor->GetColor(), nIx ); + maColorIdDataVec[ pListColor->GetColorId() ].Set( pListColor->GetColor(), nIx ); } // --- loop as long as current color count does not fit into palette of current BIFF --- - // CID data vector (maCIDDataVec) will map CIDs to color list entries (maColorList) + // Color ID data vector (maColorIdDataVec) will map color IDs to color list entries (maColorList) while( maColorList.Count() > GetColorCount() ) { // find a list color to remove @@ -292,19 +322,19 @@ void XclExpPalette::ReduceColors() aRemapVec[ nFound ].SetIndex( nNearest ); } - // remap CID data map (maCIDDataVec) from list indexes to palette indexes - for( XclCIDDataVec::iterator aIter = maCIDDataVec.begin(), aEnd = maCIDDataVec.end(); + // remap color ID data map (maColorIdDataVec) from list indexes to palette indexes + for( XclColorIdDataVec::iterator aIter = maColorIdDataVec.begin(), aEnd = maColorIdDataVec.end(); aIter != aEnd; ++aIter ) aIter->mnIndex = aRemapVec[ aIter->mnIndex ].mnPalIndex; } -sal_uInt16 XclExpPalette::GetColorIndex( sal_uInt32 nCID ) const +sal_uInt16 XclExpPalette::GetColorIndex( sal_uInt32 nColorId ) const { sal_uInt16 nRet = 0; - if( nCID >= EXC_PAL_INDEXBASE ) - nRet = static_cast< sal_uInt16 >( nCID & ~EXC_PAL_INDEXBASE ); - else if( nCID < maCIDDataVec.size() ) - nRet = GetXclIndex( maCIDDataVec[ nCID ].mnIndex ); + if( nColorId >= EXC_PAL_INDEXBASE ) + nRet = static_cast< sal_uInt16 >( nColorId & ~EXC_PAL_INDEXBASE ); + else if( nColorId < maColorIdDataVec.size() ) + nRet = GetXclIndex( maColorIdDataVec[ nColorId ].mnIndex ); return nRet; } @@ -319,22 +349,22 @@ sal_uInt16 XclExpPalette::GetColorIndex( const Color& rColor, sal_uInt16 nAutoDe } void XclExpPalette::GetMixedColors( - sal_uInt16& rnXclForeIx, sal_uInt16& rnXclBackIx, sal_uInt16& rnXclPattern, - sal_uInt32 nCIDForegr, sal_uInt32 nCIDBackgr ) const + sal_uInt16& rnXclForeIx, sal_uInt16& rnXclBackIx, sal_uInt8& rnXclPattern, + sal_uInt32 nForeColorId, sal_uInt32 nBackColorId ) const { - if( (nCIDForegr >= EXC_PAL_INDEXBASE) || (nCIDBackgr >= EXC_PAL_INDEXBASE) || (rnXclPattern != EXC_PATT_SOLID) ) + if( (nForeColorId >= EXC_PAL_INDEXBASE) || (nBackColorId >= EXC_PAL_INDEXBASE) || (rnXclPattern != EXC_PATT_SOLID) ) { - rnXclForeIx = GetColorIndex( nCIDForegr ); - rnXclBackIx = GetColorIndex( nCIDBackgr ); + rnXclForeIx = GetColorIndex( nForeColorId ); + rnXclBackIx = GetColorIndex( nBackColorId ); return; } rnXclForeIx = rnXclBackIx = 0; - if( nCIDForegr >= maCIDDataVec.size() ) + if( nForeColorId >= maColorIdDataVec.size() ) return; sal_uInt32 nIndex1, nIndex2; - Color aForeColor( GetOriginalColor( nCIDForegr ) ); + Color aForeColor( GetOriginalColor( nForeColorId ) ); sal_Int32 nFirstDist = GetNearPaletteColors( nIndex1, nIndex2, aForeColor ); if( (nIndex1 >= maPalette.size()) || (nIndex2 >= maPalette.size()) ) return; @@ -377,10 +407,10 @@ ColorData XclExpPalette::GetColorData( sal_uInt16 nXclIndex, ColorData nDefault return GetDefColorData( nXclIndex, nDefault ); } -const Color& XclExpPalette::GetOriginalColor( sal_uInt32 nCID ) const +const Color& XclExpPalette::GetOriginalColor( sal_uInt32 nColorId ) const { - if( nCID < maCIDDataVec.size() ) - return maCIDDataVec[ nCID ].maColor; + if( nColorId < maColorIdDataVec.size() ) + return maColorIdDataVec[ nColorId ].maColor; return maPalette[ 0 ].maColor; } @@ -446,9 +476,9 @@ void XclExpPalette::MergeListColors( sal_uInt32 nKeep, sal_uInt32 nRemove ) pKeepEntry->Merge( *pRemoveEntry ); maColorList.Delete( nRemove ); - // recalculate CID data map (maps CIDs to color list indexes) - XclCIDDataVec::iterator aEnd = maCIDDataVec.end(); - for( XclCIDDataVec::iterator aIter = maCIDDataVec.begin(); aIter != aEnd; ++aIter ) + // recalculate color ID data map (maps color IDs to color list indexes) + XclColorIdDataVec::iterator aEnd = maColorIdDataVec.end(); + for( XclColorIdDataVec::iterator aIter = maColorIdDataVec.begin(); aIter != aEnd; ++aIter ) { if( aIter->mnIndex == nRemove ) aIter->mnIndex = nKeep; // not "else if", aIter->mnIndex may become greater than nRemove in previous op. @@ -582,7 +612,7 @@ inline XclExpStream& operator<<( XclExpStream& rStrm, XclEscapement eEscapem ) XclExpFont::XclExpFont( const XclExpRoot& rRoot ) : XclExpRecord( EXC_ID_FONT, 14 ), XclExpRoot( rRoot ), - mnCID( rRoot.GetPalette().InsertIndex( EXC_FONT_AUTOCOLOR ) ), + mnColorId( rRoot.GetPalette().InsertIndex( EXC_FONT_AUTOCOLOR ) ), mnHash( 0 ), mbHasColor( false ) { @@ -602,12 +632,12 @@ void XclExpFont::SetName( const String& rName ) void XclExpFont::SetColor( const Color& rColor ) { - SetCID( GetPalette().InsertColor( rColor, xlColorCellText, EXC_FONT_AUTOCOLOR ) ); + SetColorId( GetPalette().InsertColor( rColor, xlColorCellText, EXC_FONT_AUTOCOLOR ) ); } -void XclExpFont::SetCID( sal_uInt32 nCID ) +void XclExpFont::SetColorId( sal_uInt32 nColorId ) { - mnCID = nCID; + mnColorId = nColorId; mbHasColor = true; } @@ -627,8 +657,8 @@ void XclExpFont::SetFont( const Font& rFont ) SetUnderline( rFont.GetUnderline() ); SetItalic( rFont.GetItalic() != ITALIC_NONE ); SetStrikeout( rFont.GetStrikeout() != STRIKEOUT_NONE ); - SetOutline( rFont.IsOutline() == TRUE ); - SetShadow( rFont.IsShadow() == TRUE ); + SetOutline( !!rFont.IsOutline() ); // BOOL->bool + SetShadow( !!rFont.IsShadow() ); // BOOL->bool CalcHash(); } @@ -651,7 +681,7 @@ bool XclExpFont::operator==( const XclExpFont& rCmp ) const { return (mnHash == rCmp.mnHash) && - (!mbHasColor || !rCmp.mbHasColor || (mnCID == rCmp.mnCID)) && + (!mbHasColor || !rCmp.mbHasColor || (mnColorId == rCmp.mnColorId)) && (maData.mnHeight == rCmp.maData.mnHeight) && (maData.mnWeight == rCmp.maData.mnWeight) && (maData.meUnderline == rCmp.maData.meUnderline) && @@ -683,21 +713,7 @@ sal_uInt8 XclExpFont::GetXclFamily( FontFamily eFamily ) sal_uInt8 XclExpFont::GetXclCharSet( rtl_TextEncoding eCharSet ) { - switch( eCharSet ) - { - case RTL_TEXTENCODING_DONTKNOW: return EXC_FONTCSET_DONTKNOW; - case RTL_TEXTENCODING_MS_1252: return EXC_FONTCSET_MS_1252; - case RTL_TEXTENCODING_APPLE_ROMAN: return EXC_FONTCSET_APPLE_ROMAN; - case RTL_TEXTENCODING_IBM_437: return EXC_FONTCSET_IBM_437; - case RTL_TEXTENCODING_IBM_850: return EXC_FONTCSET_IBM_850; - case RTL_TEXTENCODING_IBM_860: return EXC_FONTCSET_IBM_860; - case RTL_TEXTENCODING_IBM_861: return EXC_FONTCSET_IBM_861; - case RTL_TEXTENCODING_IBM_863: return EXC_FONTCSET_IBM_863; - case RTL_TEXTENCODING_IBM_865: return EXC_FONTCSET_IBM_865; - case (rtl_TextEncoding) 9: return EXC_FONTCSET_SYSTEM; - case RTL_TEXTENCODING_SYMBOL: return EXC_FONTCSET_SYMBOL; - } - return EXC_FONTCSET_DONTKNOW; + return rtl_getBestWindowsCharsetFromTextEncoding(eCharSet); } sal_uInt16 XclExpFont::GetXclWeight( FontWeight eWeight ) @@ -757,7 +773,7 @@ void XclExpFont::WriteBody( XclExpStream& rStrm ) rStrm << maData.mnHeight << nAttr - << GetPalette().GetColorIndex( mnCID ) + << GetPalette().GetColorIndex( mnColorId ) << maData.mnWeight << maData.meEscapem << maData.meUnderline @@ -772,20 +788,23 @@ void XclExpFont::WriteBody( XclExpStream& rStrm ) XclExpFontBuffer::XclExpFontBuffer( const XclExpRoot& rRoot ) : XclExpRoot( rRoot ), - mnMaxCount( 0 ) + mnXclMaxCount( 0 ) { - SetBiff( GetBiff() ); + OnChangeBiff(); + + // currently always using Arial/10 + SetCharWidth( 110 ); } -void XclExpFontBuffer::SetBiff( XclBiff eBiff ) +void XclExpFontBuffer::OnChangeBiff() { - DBG_ASSERT( maFontList.Empty(), "XclExpFontBuffer::SetBiff - call is too late" ); - switch( eBiff ) + DBG_ASSERT( maFontList.Empty(), "XclExpFontBuffer::OnChangeBiff - call is too late" ); + switch( GetBiff() ) { - case xlBiff4: mnMaxCount = EXC_FONT_MAXCOUNT4; break; + case xlBiff4: mnXclMaxCount = EXC_FONT_MAXCOUNT4; break; case xlBiff5: - case xlBiff7: mnMaxCount = EXC_FONT_MAXCOUNT5; break; - case xlBiff8: mnMaxCount = EXC_FONT_MAXCOUNT8; break; + case xlBiff7: mnXclMaxCount = EXC_FONT_MAXCOUNT5; break; + case xlBiff8: mnXclMaxCount = EXC_FONT_MAXCOUNT8; break; default: DBG_ERROR_BIFF(); } } @@ -793,7 +812,7 @@ void XclExpFontBuffer::SetBiff( XclBiff eBiff ) sal_uInt16 XclExpFontBuffer::GetIndex( const XclExpFont& rFont, sal_uInt16 nDefault ) { sal_uInt32 nIndex = Find( rFont ); - return (nIndex < mnMaxCount) ? GetXclIndex( nIndex ) : nDefault; + return (nIndex < mnXclMaxCount) ? GetXclIndex( nIndex ) : nDefault; } sal_uInt16 XclExpFontBuffer::Insert( XclExpFont*& rpFont ) @@ -810,11 +829,11 @@ sal_uInt16 XclExpFontBuffer::Insert( XclExpFont*& rpFont ) XclExpFont* pOldFont = maFontList.GetObject( nIndex ); // old font does not have a color -> take color from new font if( !pOldFont->HasColor() ) - pOldFont->SetCID( rpFont->GetCID() ); + pOldFont->SetColorId( rpFont->GetColorId() ); delete rpFont; rpFont = pOldFont; } - else if( nCount < mnMaxCount ) + else if( nCount < mnXclMaxCount ) { // --- font not found, possible to insert --- maFontList.Append( rpFont ); @@ -833,7 +852,7 @@ sal_uInt16 XclExpFontBuffer::Insert( XclExpFont*& rpFont ) sal_uInt16 XclExpFontBuffer::Insert( const Font& rFont ) { - XclExpFont* pNewFont = new XclExpFont( *this ); + XclExpFont* pNewFont = new XclExpFont( GetRoot() ); pNewFont->SetFont( rFont ); return Insert( pNewFont ); } @@ -854,7 +873,7 @@ void XclExpFontBuffer::Save( XclExpStream& rStrm ) void XclExpFontBuffer::InitDefaultFonts() { - XclExpFont aFont( *this ); + XclExpFont aFont( GetRoot() ); aFont.SetName( String( RTL_CONSTASCII_USTRINGPARAM( "Arial" ) ) ); aFont.SetFamily( FAMILY_DONTKNOW ); aFont.SetCharSet( RTL_TEXTENCODING_DONTKNOW ); @@ -889,7 +908,7 @@ void XclExpFontBuffer::InitDefaultFonts() } } -sal_uInt16 XclExpFontBuffer::GetXclIndex( sal_uInt32 nIndex ) +sal_uInt16 XclExpFontBuffer::GetXclIndex( sal_uInt32 nIndex ) const { if( nIndex > 3 ) ++nIndex; @@ -948,9 +967,10 @@ XclExpNumFmtBuffer::XclExpNumFmtBuffer( const XclExpRoot& rRoot ) : cannot convert from 'class String *' to 'class String (*)[54]' The effective result here is class String (*)[54*1] */ mpKeywordTable( new NfKeywordTable[ 1 ] ), - mpFormatter( new SvNumberFormatter( rRoot.GetDoc().GetServiceManager(), LANGUAGE_ENGLISH_US ) ) + mpFormatter( new SvNumberFormatter( rRoot.GetDoc().GetServiceManager(), LANGUAGE_ENGLISH_US ) ), + mnStdFmt( GetFormatter().GetStandardFormat( GetDefLanguage() ) ) { - SetBiff( GetBiff() ); + OnChangeBiff(); mpFormatter->FillKeywordTable( *mpKeywordTable, LANGUAGE_ENGLISH_US ); // remap codes unknown to Excel @@ -965,10 +985,10 @@ XclExpNumFmtBuffer::~XclExpNumFmtBuffer() delete[] mpKeywordTable; } -void XclExpNumFmtBuffer::SetBiff( XclBiff eBiff ) +void XclExpNumFmtBuffer::OnChangeBiff() { - DBG_ASSERT( maFormatMap.empty(), "XclExpNumFmtBuffer::SetBiff - call is too late" ); - switch( eBiff ) + DBG_ASSERT( maFormatMap.empty(), "XclExpNumFmtBuffer::OnChangeBiff - call is too late" ); + switch( GetBiff() ) { case xlBiff5: case xlBiff7: mnXclOffset = EXC_FORMAT_OFFSET5; break; @@ -977,10 +997,10 @@ void XclExpNumFmtBuffer::SetBiff( XclBiff eBiff ) } } -sal_uInt16 XclExpNumFmtBuffer::Insert( sal_uInt32 nFormatIx ) +sal_uInt16 XclExpNumFmtBuffer::Insert( sal_uInt32 nScFormatIx ) { XclExpNumFmtVec::const_iterator aIter = - ::std::find_if( maFormatMap.begin(), maFormatMap.end(), XclExpNumFmtPred( nFormatIx ) ); + ::std::find_if( maFormatMap.begin(), maFormatMap.end(), XclExpNumFmtPred( nScFormatIx ) ); if( aIter != maFormatMap.end() ) return aIter->mnXclIx; @@ -988,7 +1008,7 @@ sal_uInt16 XclExpNumFmtBuffer::Insert( sal_uInt32 nFormatIx ) if( nSize < 0xFFFFUL - mnXclOffset ) { sal_uInt16 nXclIx = static_cast< sal_uInt16 >( nSize + mnXclOffset ); - maFormatMap.push_back( XclExpNumFmt( nFormatIx, nXclIx ) ); + maFormatMap.push_back( XclExpNumFmt( nScFormatIx, nXclIx ) ); return nXclIx; } @@ -1062,7 +1082,7 @@ void XclExpNumFmtBuffer::WriteFormatRecord( XclExpStream& rStrm, const XclExpNum void XclExpNumFmtBuffer::WriteDefaultFormats( XclExpStream& rStrm ) { - const XclExpDefaultFormat* pEnd = pDefaultFormats + STATIC_TABLE_SIZE( pDefaultFormats ); + const XclExpDefaultFormat* pEnd = STATIC_TABLE_END( pDefaultFormats ); for( const XclExpDefaultFormat* pCurr = pDefaultFormats; pCurr != pEnd; ++pCurr ) WriteFormatRecord( rStrm, pCurr->mnIndex, String( pCurr->mpFormat, RTL_TEXTENCODING_UTF8 ) ); } @@ -1070,5 +1090,630 @@ void XclExpNumFmtBuffer::WriteDefaultFormats( XclExpStream& rStrm ) // XF, STYLE record - Cell formatting ========================================= +XclExpXFBorder::XclExpXFBorder() : + mnLeftColorId( 0 ), + mnRightColorId( 0 ), + mnTopColorId( 0 ), + mnBottomColorId( 0 ), + mnLeftLine( EXC_LINE_NONE ), + mnRightLine( EXC_LINE_NONE ), + mnTopLine( EXC_LINE_NONE ), + mnBottomLine( EXC_LINE_NONE ) +{ +} + +#if 0 +void lcl_GetBorder2( sal_uInt8& rnFlags, const XclExpXFBorder& rBorder ) +{ + ::set_flag( rnFlags, EXC_XF2_LEFTLINE, rBorder.mnLeftLine != EXC_LINE_NONE ); + ::set_flag( rnFlags, EXC_XF2_RIGHTLINE, rBorder.mnRightLine != EXC_LINE_NONE ); + ::set_flag( rnFlags, EXC_XF2_TOPLINE, rBorder.mnTopLine != EXC_LINE_NONE ); + ::set_flag( rnFlags, EXC_XF2_BOTTOMLINE, rBorder.mnBottomLine != EXC_LINE_NONE ); +} + +void lcl_GetBorder3( sal_uInt32& rnFlags, const XclExpXFBorder& rBorder, const XclExpPalette& rPalette ) +{ + ::insert_value( rnFlags, rBorder.mnTopLine, 0, 3 ); + ::insert_value( rnFlags, rBorder.mnLeftLine, 8, 3 ); + ::insert_value( rnFlags, rBorder.mnBottomLine, 16, 3 ); + ::insert_value( rnFlags, rBorder.mnRightLine, 24, 3 ); + ::insert_value( rnFlags, rPalette.GetColorIndex( rBorder.mnTopColorId ), 3, 5 ); + ::insert_value( rnFlags, rPalette.GetColorIndex( rBorder.mnLeftColorId ), 11, 5 ); + ::insert_value( rnFlags, rPalette.GetColorIndex( rBorder.mnBottomColorId ), 19, 5 ); + ::insert_value( rnFlags, rPalette.GetColorIndex( rBorder.mnRightColorId ), 27, 5 ); +} +#endif + +void lcl_GetBorder5( + sal_uInt32& rnBorder, sal_uInt32& rnArea, + const XclExpXFBorder& rBorder, const XclExpPalette& rPalette ) +{ + ::insert_value( rnBorder, rBorder.mnTopLine, 0, 3 ); + ::insert_value( rnBorder, rBorder.mnLeftLine, 3, 3 ); + ::insert_value( rnArea, rBorder.mnBottomLine, 22, 3 ); + ::insert_value( rnBorder, rBorder.mnRightLine, 6, 3 ); + ::insert_value( rnBorder, rPalette.GetColorIndex( rBorder.mnTopColorId ), 9, 7 ); + ::insert_value( rnBorder, rPalette.GetColorIndex( rBorder.mnLeftColorId ), 16, 7 ); + ::insert_value( rnArea, rPalette.GetColorIndex( rBorder.mnBottomColorId ), 25, 7 ); + ::insert_value( rnBorder, rPalette.GetColorIndex( rBorder.mnRightColorId ), 23, 7 ); +} + +void lcl_GetBorder8( + sal_uInt32& rnBorder1, sal_uInt32& rnBorder2, + const XclExpXFBorder& rBorder, const XclExpPalette& rPalette ) +{ + ::insert_value( rnBorder1, rBorder.mnLeftLine, 0, 4 ); + ::insert_value( rnBorder1, rBorder.mnRightLine, 4, 4 ); + ::insert_value( rnBorder1, rBorder.mnTopLine, 8, 4 ); + ::insert_value( rnBorder1, rBorder.mnBottomLine, 12, 4 ); + ::insert_value( rnBorder1, rPalette.GetColorIndex( rBorder.mnLeftColorId ), 16, 7 ); + ::insert_value( rnBorder1, rPalette.GetColorIndex( rBorder.mnRightColorId ), 23, 7 ); + ::insert_value( rnBorder2, rPalette.GetColorIndex( rBorder.mnTopColorId ), 0, 7 ); + ::insert_value( rnBorder2, rPalette.GetColorIndex( rBorder.mnBottomColorId ), 7, 7 ); +} + + +// ---------------------------------------------------------------------------- + +XclExpXFArea::XclExpXFArea() : + mnForeColorId( 0 ), + mnBackColorId( 0 ), + mnPattern( EXC_PATT_NONE ) +{ +} + +#if 0 +void lcl_GetArea2( sal_uInt8& rnFlags, const XclExpXFArea& rArea ) +{ + ::set_flag( rnFlags, EXC_XF2_BACKGROUND, rArea.mnPattern != EXC_PATT_NONE ); +} + +void lcl_GetArea3( sal_uInt16& rnArea, const XclExpXFArea& rArea, const XclExpPalette& rPalette ) +{ + ::insert_value( rnArea, rArea.mnPattern, 0, 6 ); + ::insert_value( rnArea, rPalette.GetColorIndex( rArea.mnForeColorId ), 6, 5 ); + ::insert_value( rnArea, rPalette.GetColorIndex( rArea.mnBackColorId ), 11, 5 ); +} +#endif + +void lcl_GetArea5( sal_uInt32& rnArea, const XclExpXFArea& rArea, const XclExpPalette& rPalette ) +{ + sal_uInt16 nXclForeIx, nXclBackIx; + sal_uInt8 nXclPattern = rArea.mnPattern; + rPalette.GetMixedColors( nXclForeIx, nXclBackIx, nXclPattern, rArea.mnForeColorId, rArea.mnBackColorId ); + ::insert_value( rnArea, nXclPattern, 16, 6 ); + ::insert_value( rnArea, nXclForeIx, 0, 7 ); + ::insert_value( rnArea, nXclBackIx, 7, 7 ); +} + +void lcl_GetArea8( sal_uInt32& rnBorder2, sal_uInt16& rnArea, const XclExpXFArea& rArea, const XclExpPalette& rPalette ) +{ + sal_uInt16 nXclForeIx, nXclBackIx; + sal_uInt8 nXclPattern = rArea.mnPattern; + rPalette.GetMixedColors( nXclForeIx, nXclBackIx, nXclPattern, rArea.mnForeColorId, rArea.mnBackColorId ); + ::insert_value( rnBorder2, nXclPattern, 26, 6 ); + ::insert_value( rnArea, nXclForeIx, 0, 7 ); + ::insert_value( rnArea, nXclBackIx, 7, 7 ); +} + + +// ---------------------------------------------------------------------------- + +XclExpXF::XclExpXF( + const XclExpRoot& rRoot, const ScPatternAttr* pPattern, + sal_uInt32 nForcedNumFmt, bool bForceWrapped ) : + mbCellXF( true ) +{ + Init( rRoot, pPattern, nForcedNumFmt, bForceWrapped ); +} + +XclExpXF::XclExpXF( const XclExpRoot& rRoot, SfxStyleSheetBase& rStyleSheet ) : + mbCellXF( false ) +{ + // create an own ScPatternAttr and let Init() do all the work + mpOwnPattern.reset( new ScPatternAttr( rStyleSheet.GetItemSet().Clone() ) ); + Init( rRoot, mpOwnPattern.get() ); +} + +bool XclExpXF::Equals( const ScPatternAttr* pPattern, sal_uInt32 nForcedNumFmt, bool bForceWrapped ) const +{ + return mbCellXF && (mpPattern == pPattern) && + ((nForcedNumFmt == NUMBERFORMAT_ENTRY_NOT_FOUND) || (mnNumFmt == nForcedNumFmt)) && + (!bForceWrapped || mbWrapped); +} + +void XclExpXF::GetBorderLine( + sal_uInt8& rnXclLine, sal_uInt32& rnColorId, + XclExpPalette& rPalette, const SvxBorderLine* pLine ) +{ + if( pLine ) + { + sal_uInt16 nOuterWidth = pLine->GetOutWidth(); + sal_uInt16 nDistance = pLine->GetDistance(); + if( nDistance > 0 ) + rnXclLine = EXC_LINE_DOUBLE; + else if( nOuterWidth > DEF_LINE_WIDTH_2 ) + rnXclLine = EXC_LINE_THICK; + else if( nOuterWidth > DEF_LINE_WIDTH_1 ) + rnXclLine = EXC_LINE_MEDIUM; + else if( nOuterWidth > DEF_LINE_WIDTH_0 ) + rnXclLine = EXC_LINE_THIN; + else if( nOuterWidth > 0 ) + rnXclLine = EXC_LINE_HAIR; + else + rnXclLine = EXC_LINE_NONE; + rnColorId = rPalette.InsertColor( pLine->GetColor(), xlColorCellBorder ); + } + else + { + rnXclLine = EXC_LINE_NONE; + rnColorId = rPalette.InsertIndex( 0 ); + } +} + +void XclExpXF::GetBorder( XclExpXFBorder& rBorder, XclExpPalette& rPalette, const ScPatternAttr& rPattern ) +{ + const SvxBoxItem& rBoxItem = static_cast< const SvxBoxItem& >( rPattern.GetItem( ATTR_BORDER ) ); + GetBorderLine( rBorder.mnLeftLine, rBorder.mnLeftColorId, rPalette, rBoxItem.GetLeft() ); + GetBorderLine( rBorder.mnRightLine, rBorder.mnRightColorId, rPalette, rBoxItem.GetRight() ); + GetBorderLine( rBorder.mnTopLine, rBorder.mnTopColorId, rPalette, rBoxItem.GetTop() ); + GetBorderLine( rBorder.mnBottomLine, rBorder.mnBottomColorId, rPalette, rBoxItem.GetBottom() ); +} + +void XclExpXF::GetArea( XclExpXFArea& rArea, XclExpPalette& rPalette, const ScPatternAttr& rPattern ) +{ + const SvxBrushItem& rBrushItem = static_cast< const SvxBrushItem& >( rPattern.GetItem( ATTR_BACKGROUND ) ); + rArea.mnPattern = rBrushItem.GetColor().GetTransparency() ? EXC_PATT_NONE : EXC_PATT_SOLID; + rArea.mnForeColorId = rPalette.InsertColor( rBrushItem.GetColor(), xlColorCellArea ); + rArea.mnBackColorId = rPalette.InsertColor( Color( COL_BLACK ), xlColorCellArea ); +} + +void XclExpXF::Init( + const XclExpRoot& rRoot, const ScPatternAttr* pPattern, + sal_uInt32 nForcedNumFmt, bool bForceWrapped ) +{ + XclExpPalette& rPalette = rRoot.GetPalette(); + XclExpNumFmtBuffer& rNumFmtBuffer = rRoot.GetNumFmtBuffer(); + +// *** reset members *** + + // mbCellXF set in constructors + SetRecHeader( EXC_ID_XF, (rRoot.GetBiff() == xlBiff8) ? 20 : 16 ); + mpPattern = pPattern; + meHorAlign = xlHAlignGeneral; + meVerAlign = xlVAlignBottom; + meOrient = xlTextOrientNoRot; + meTextDir = xlTextDirContext; + mnParent = mbCellXF ? EXC_XF_DEFAULTSTYLE : EXC_XF_STYLEPARENT; + mnFont = mnNumFmt = 0; + if( nForcedNumFmt != NUMBERFORMAT_ENTRY_NOT_FOUND ) + mnNumFmt = rNumFmtBuffer.Insert( nForcedNumFmt ); + mnIndent = mnRotation = 0; + mbLocked = true; // default in Calc and Excel + mbHidden = false; + mbWrapped = bForceWrapped; + mbProtUsed = mbFontUsed = mbFmtUsed = mbAlignUsed = mbBorderUsed = mbAreaUsed = false; + +// *** formatting attributes *** + + if( !mpPattern ) + { + maArea.mnForeColorId = rPalette.InsertIndex( 64 ); + maArea.mnBackColorId = rPalette.InsertIndex( 65 ); + if( nForcedNumFmt == NUMBERFORMAT_ENTRY_NOT_FOUND ) + mnNumFmt = rNumFmtBuffer.Insert( rNumFmtBuffer.GetStandardFormat() ); + return; + } + +// Creates a variable 'name' of type "const 'type' &" and assigns item with 'which' ID from mpPattern. +#define GETITEM( type, name, which ) \ + const type & name = static_cast< const type & >( mpPattern->GetItem( which ) ) + + // cell protection + GETITEM( ScProtectionAttr, rProtItem, ATTR_PROTECTION ); + mbLocked = !!rProtItem.GetProtection(); // BOOL->bool + mbHidden = rProtItem.GetHideFormula() || rProtItem.GetHideCell(); + + // font + mnFont = rRoot.GetFontBuffer().Insert( *mpPattern ); + + // number format + if( nForcedNumFmt == NUMBERFORMAT_ENTRY_NOT_FOUND ) // don't overwrite forced format + { + GETITEM( SfxUInt32Item, rNumFmtItem, ATTR_VALUE_FORMAT ); + mnNumFmt = rNumFmtBuffer.Insert( rNumFmtItem.GetValue() ); + } + + // horizontal alignment + GETITEM( SvxHorJustifyItem, rHorJustItem, ATTR_HOR_JUSTIFY ); + switch( static_cast< SvxCellHorJustify >( rHorJustItem.GetValue() ) ) + { + case SVX_HOR_JUSTIFY_STANDARD: meHorAlign = xlHAlignGeneral; break; + case SVX_HOR_JUSTIFY_LEFT: meHorAlign = xlHAlignLeft; break; + case SVX_HOR_JUSTIFY_CENTER: meHorAlign = xlHAlignCenter; break; + case SVX_HOR_JUSTIFY_RIGHT: meHorAlign = xlHAlignRight; break; + case SVX_HOR_JUSTIFY_BLOCK: meHorAlign = xlHAlignJustify; break; + case SVX_HOR_JUSTIFY_REPEAT: meHorAlign = xlHAlignFill; break; + default: DBG_ERROR( "XclExpXF::Init - unknown horizontal adjustment" ); + } + + // text wrap + if( !mbWrapped ) // only, if not yet forced by caller + { + GETITEM( SfxBoolItem, rWrapItem, ATTR_LINEBREAK ); + mbWrapped = !!rWrapItem.GetValue(); // BOOL->bool + } + + // vertical alignment + GETITEM( SvxVerJustifyItem, rVerJustItem, ATTR_VER_JUSTIFY ); + switch( static_cast< SvxCellVerJustify >( rVerJustItem.GetValue() ) ) + { + case SVX_VER_JUSTIFY_STANDARD: meVerAlign = xlVAlignBottom; break; + case SVX_VER_JUSTIFY_TOP: meVerAlign = xlVAlignTop; break; + case SVX_VER_JUSTIFY_CENTER: meVerAlign = xlVAlignCenter; break; + case SVX_VER_JUSTIFY_BOTTOM: meVerAlign = xlVAlignBottom; break; + default: DBG_ERROR( "XclExpXF::Init - unknown vertical adjustment" ); + } + + // text indent + GETITEM( SfxUInt16Item, rIndentItem, ATTR_INDENT ); + sal_Int32 nTmpIndent = rIndentItem.GetValue(); // SfxUInt16Item returns INT16, weird... + (nTmpIndent += 100) /= 200; + mnIndent = static_cast< sal_uInt8 >( ::std::max( ::std::min( nTmpIndent, 0x0FL ), 0L ) ); + + // orientation and rotation + GETITEM( SvxOrientationItem, rOrientItem, ATTR_ORIENTATION ); + switch( static_cast< SvxCellOrientation >( rOrientItem.GetValue() ) ) + { + case SVX_ORIENTATION_STANDARD: meOrient = xlTextOrientNoRot; break; + case SVX_ORIENTATION_TOPBOTTOM: meOrient = xlTextOrient90cw; break; + case SVX_ORIENTATION_BOTTOMTOP: meOrient = xlTextOrient90ccw; break; + case SVX_ORIENTATION_STACKED: meOrient = xlTextOrientTopBottom; break; + default: DBG_ERROR( "XclExpXF::Init - unknown text orientation" ); + } + switch( meOrient ) + { + case xlTextOrientTopBottom: mnRotation = EXC_XF8_STACKED; break; + // #i4378# old calc doc's without real rotation + case xlTextOrient90ccw: mnRotation = 90; break; + case xlTextOrient90cw: mnRotation = 180; break; + default: + { + GETITEM( SfxInt32Item, rRotateItem, ATTR_ROTATE_VALUE ); + mnRotation = XclTools::GetXclRotation( rRotateItem.GetValue() ); + } + } + + // cell border + GetBorder( maBorder, rPalette, *mpPattern ); + + // cell background area + GetArea( maArea, rPalette, *mpPattern ); + + // CTL text direction + GETITEM( SvxFrameDirectionItem, rFrameDirItem, ATTR_WRITINGDIR ); + switch( static_cast< SvxFrameDirection >( rFrameDirItem.GetValue() ) ) + { + case FRMDIR_ENVIRONMENT: meTextDir = xlTextDirContext; break; + case FRMDIR_HORI_LEFT_TOP: meTextDir = xlTextDirLTR; break; + case FRMDIR_HORI_RIGHT_TOP: meTextDir = xlTextDirRTL; break; + default: DBG_ERRORFILE( "XclExpXF::Init - unknown CTL text direction" ); + } + +#undef GETITEM + +// *** used/unused flags *** + + // all font items + static const sal_uInt16 pnFontWhichIds[] = + { + ATTR_FONT_HEIGHT, + ATTR_FONT_WEIGHT, + ATTR_FONT_POSTURE, + ATTR_FONT_UNDERLINE, + ATTR_FONT_CROSSEDOUT, + ATTR_FONT_CONTOUR, + ATTR_FONT_SHADOWED, + ATTR_FONT_COLOR, + ATTR_FONT_LANGUAGE, + 0 + }; + + const SfxItemSet& rItemSet = mpPattern->GetItemSet(); + +// Expands to true if rItemSet really contains the item with 'which' ID. +#define CHECKITEM( which ) (rItemSet.GetItemState( which, FALSE ) == SFX_ITEM_SET) + + switch( rRoot.GetBiff() ) + { + // all 'case's -> run through + case xlBiff8: // new in BIFF8/BIFF8X + mbAlignUsed |= CHECKITEM( ATTR_ROTATE_VALUE ) || + CHECKITEM( ATTR_INDENT ) || CHECKITEM( ATTR_WRITINGDIR ); + + case xlBiff7: // new in BIFF7 - nothing + case xlBiff5: // new in BIFF5 - nothing + case xlBiff4: // new in BIFF4 + mbAlignUsed |= CHECKITEM( ATTR_VER_JUSTIFY ) || CHECKITEM( ATTR_ORIENTATION ); + + case xlBiff3: // attributes in all BIFF versions (BIFF2 does not use the flags at all) + mbProtUsed |= CHECKITEM( ATTR_PROTECTION ); + mbFontUsed |= !!mpPattern->HasItemsSet( pnFontWhichIds ); // BOOL->bool + mbFmtUsed |= CHECKITEM( ATTR_VALUE_FORMAT ); + mbBorderUsed |= CHECKITEM( ATTR_BORDER ); + mbAreaUsed |= CHECKITEM( ATTR_BACKGROUND ); + mbAlignUsed |= CHECKITEM( ATTR_HOR_JUSTIFY ) || CHECKITEM( ATTR_LINEBREAK ); + break; + } + +#undef CHECKITEM +} + +sal_uInt8 XclExpXF::GetUsedAttribMask() const +{ + sal_uInt8 nUsedFlags = 0; + // "mbCellXF == mb***Used" evaluates to correct value in cell and style XFs + ::set_flag( nUsedFlags, EXC_XF_DIFF_PROT, mbCellXF == mbProtUsed ); + ::set_flag( nUsedFlags, EXC_XF_DIFF_FONT, mbCellXF == mbFontUsed ); + ::set_flag( nUsedFlags, EXC_XF_DIFF_VALFMT, mbCellXF == mbFmtUsed ); + ::set_flag( nUsedFlags, EXC_XF_DIFF_ALIGN, mbCellXF == mbAlignUsed ); + ::set_flag( nUsedFlags, EXC_XF_DIFF_BORDER, mbCellXF == mbBorderUsed ); + ::set_flag( nUsedFlags, EXC_XF_DIFF_AREA, mbCellXF == mbAreaUsed ); + return nUsedFlags; +} + +void XclExpXF::WriteBody5( XclExpStream& rStrm ) +{ + sal_uInt16 nTypeProt = 0; + ::set_flag( nTypeProt, EXC_XF_LOCKED, mbLocked ); + ::set_flag( nTypeProt, EXC_XF_HIDDEN, mbHidden ); + ::set_flag( nTypeProt, EXC_XF_STYLE, !mbCellXF ); + ::insert_value( nTypeProt, mnParent, 4, 12 ); + + sal_uInt16 nAlign = 0; + ::insert_value( nAlign, meHorAlign, 0, 3 ); + ::set_flag( nAlign, EXC_XF_WRAPPED, mbWrapped ); + ::insert_value( nAlign, meVerAlign, 4, 3 ); + ::insert_value( nAlign, meOrient, 8, 2 ); + ::insert_value( nAlign, GetUsedAttribMask(), 10, 6 ); + + sal_uInt32 nArea = 0, nBorder = 0; + lcl_GetBorder5( nBorder, nArea, maBorder, rStrm.GetRoot().GetPalette() ); + lcl_GetArea5( nArea, maArea, rStrm.GetRoot().GetPalette() ); + + rStrm << mnFont << mnNumFmt << nTypeProt << nAlign << nArea << nBorder; +} + +void XclExpXF::WriteBody8( XclExpStream& rStrm ) +{ + sal_uInt16 nTypeProt = 0; + ::set_flag( nTypeProt, EXC_XF_LOCKED, mbLocked ); + ::set_flag( nTypeProt, EXC_XF_HIDDEN, mbHidden ); + ::set_flag( nTypeProt, EXC_XF_STYLE, !mbCellXF ); + ::insert_value( nTypeProt, mnParent, 4, 12 ); + + sal_uInt16 nAlign = 0; + ::insert_value( nAlign, meHorAlign, 0, 3 ); + ::set_flag( nAlign, EXC_XF_WRAPPED, mbWrapped ); + ::insert_value( nAlign, meVerAlign, 4, 3 ); + ::insert_value( nAlign, mnRotation, 8, 8 ); + + sal_uInt16 nMiscAttrib = 0; + ::insert_value( nMiscAttrib, mnIndent, 0, 4 ); + ::insert_value( nMiscAttrib, meTextDir, 6, 2 ); + ::insert_value( nMiscAttrib, GetUsedAttribMask(), 10, 6 ); + + sal_uInt32 nBorder1 = 0, nBorder2 = 0; + sal_uInt16 nArea = 0; + lcl_GetBorder8( nBorder1, nBorder2, maBorder, rStrm.GetRoot().GetPalette() ); + lcl_GetArea8( nBorder2, nArea, maArea, rStrm.GetRoot().GetPalette() ); + + rStrm << mnFont << mnNumFmt << nTypeProt << nAlign << nMiscAttrib << nBorder1 << nBorder2 << nArea; +} + +void XclExpXF::WriteBody( XclExpStream& rStrm ) +{ + switch( rStrm.GetRoot().GetBiff() ) + { + case xlBiff5: + case xlBiff7: WriteBody5( rStrm ); break; + case xlBiff8: WriteBody8( rStrm ); break; + default: DBG_ERROR_BIFF(); + } +} + + +// ---------------------------------------------------------------------------- + +XclExpStyle::XclExpStyle( const String& rName, sal_uInt16 nXFIndex ) : + XclExpRecord( EXC_ID_STYLE ), + maName( rName ), + mnXFIndex( nXFIndex ) +{ + DBG_ASSERT( maName.Len(), "XclExpStyle::XclExpStyle - empty style name" ); +} + +void XclExpStyle::WriteBody( XclExpStream& rStrm ) +{ + XclExpString aNameEx; + if( rStrm.GetRoot().GetBiff() >= xlBiff8 ) + aNameEx.Assign( maName ); + else + aNameEx.AssignByte( maName, rStrm.GetRoot().GetCharSet(), EXC_STR_8BITLENGTH ); + rStrm << mnXFIndex << aNameEx; +} + + +// ---------------------------------------------------------------------------- + +XclExpXFBuffer::XclExpXFBuffer( const XclExpRoot& rRoot ) : + XclExpRoot( rRoot ), + mnXclMaxCount( EXC_XF_MAXCOUNT ), + mnXclOffset( EXC_XF_OFFSET ) +{ +} + +void XclExpXFBuffer::InsertUserStyles() +{ + SfxStyleSheetIterator aStyleIter( GetDoc().GetStyleSheetPool(), SFX_STYLE_FAMILY_PARA ); + for( SfxStyleSheetBase* pStyle = aStyleIter.First(); pStyle; pStyle = aStyleIter.Next() ) + if( pStyle->IsUserDefined() ) + InsertStyle( *pStyle ); +} + +sal_uInt16 XclExpXFBuffer::Insert( const ScPatternAttr* pPattern, bool bForceWrapped ) +{ + return InsertCellXF( pPattern, NUMBERFORMAT_ENTRY_NOT_FOUND, bForceWrapped ); +} + +sal_uInt16 XclExpXFBuffer::Insert( const ScPatternAttr* pPattern, sal_uInt32 nForcedNumFmt ) +{ + return InsertCellXF( pPattern, nForcedNumFmt, false ); +} + +sal_uInt16 XclExpXFBuffer::InsertStyle( SfxStyleSheetBase& rStyleSheet ) +{ + // create the XF record + sal_uInt16 nXFIndex = EXC_XF_DEFAULTSTYLE; + if( maXFList.Count() < EXC_XF_MAXCOUNT ) + { + nXFIndex = GetXclIndex( maXFList.Count() ); + maXFList.Append( new XclExpXF( GetRoot(), rStyleSheet ) ); + } + + // create the STYLE record + if( rStyleSheet.GetName().Len() ) + maStyleList.Append( new XclExpStyle( rStyleSheet.GetName(), nXFIndex ) ); + + return nXFIndex; +} + +void XclExpXFBuffer::Save( XclExpStream& rStrm ) +{ + // XF records + switch( GetBiff() ) + { + case xlBiff5: + case xlBiff7: WriteDefaultXFs5( rStrm ); break; + case xlBiff8: WriteDefaultXFs8( rStrm ); break; + default: DBG_ERROR_BIFF(); + } + maXFList.Save( rStrm ); + + // STYLE records + switch( GetBiff() ) + { + case xlBiff5: + case xlBiff7: + case xlBiff8: WriteDefaultStyles5( rStrm ); break; + default: DBG_ERROR_BIFF(); + } + maStyleList.Save( rStrm ); +} + +sal_uInt16 XclExpXFBuffer::GetXclIndex( sal_uInt32 nIndex ) const +{ + DBG_ASSERT( nIndex < mnXclMaxCount, "XclExpXFBuffer::GetXclIndex - invalid index" ); + return static_cast< sal_uInt16 >( nIndex + mnXclOffset ); +} + +sal_uInt16 XclExpXFBuffer::InsertCellXF( + const ScPatternAttr* pPattern, sal_uInt32 nForcedNumFmt, bool bForceWrapped ) +{ + sal_uInt32 nIndex = LIST_ENTRY_NOTFOUND; + + // try to find existing cell XF + for( const XclExpXF* pXF = maXFList.First(); pXF; pXF = maXFList.Next() ) + { + if( pXF->Equals( pPattern, nForcedNumFmt, bForceWrapped ) ) + { + nIndex = maXFList.GetCurPos(); + break; + } + } + + // not found - insert new XF + if( nIndex == LIST_ENTRY_NOTFOUND ) + { + nIndex = maXFList.Count(); + if( nIndex < EXC_XF_MAXCOUNT ) + maXFList.Append( new XclExpXF( GetRoot(), pPattern, nForcedNumFmt, bForceWrapped ) ); + else + // list full - fall back to default cell XF + return EXC_XF_DEFAULTCELL; + } + + return GetXclIndex( nIndex ); +} + +void XclExpXFBuffer::WriteDefaultXFs5( XclExpStream& rStrm ) +{ + static const sal_uInt8 pnDefStyle[] = { 0x00,0x00,0x00,0x00,0xF5,0xFF,0x20,0x00,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnOutlineStyle1[] = { 0x01,0x00,0x00,0x00,0xF5,0xFF,0x20,0xF4,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnOutlineStyle2[] = { 0x02,0x00,0x00,0x00,0xF5,0xFF,0x20,0xF4,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnOutlineStyle3[] = { 0x00,0x00,0x00,0x00,0xF5,0xFF,0x20,0xF4,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnDefCell[] = { 0x00,0x00,0x00,0x00,0x01,0x00,0x20,0x00,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnBuiltInStyle1[] = { 0x05,0x00,0x2B,0x00,0xF5,0xFF,0x20,0xF8,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnBuiltInStyle2[] = { 0x05,0x00,0x29,0x00,0xF5,0xFF,0x20,0xF8,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnBuiltInStyle3[] = { 0x05,0x00,0x2C,0x00,0xF5,0xFF,0x20,0xF8,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnBuiltInStyle4[] = { 0x05,0x00,0x2A,0x00,0xF5,0xFF,0x20,0xF8,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + static const sal_uInt8 pnBuiltInStyle5[] = { 0x05,0x00,0x09,0x00,0xF5,0xFF,0x20,0xF8,0xC0,0x20,0x00,0x00,0x00,0x00,0x00,0x00 }; + + // default style (1) + XclExpDummyRecord aXF( EXC_ID_XF, pnDefStyle, STATIC_TABLE_SIZE( pnDefStyle ) ); aXF.Save( rStrm ); + // outline styles (14) + aXF.SetData( pnOutlineStyle1, STATIC_TABLE_SIZE( pnOutlineStyle1 ) ); aXF.SaveRepeated( rStrm, 2 ); + aXF.SetData( pnOutlineStyle2, STATIC_TABLE_SIZE( pnOutlineStyle2 ) ); aXF.SaveRepeated( rStrm, 2 ); + aXF.SetData( pnOutlineStyle3, STATIC_TABLE_SIZE( pnOutlineStyle3 ) ); aXF.SaveRepeated( rStrm, 10 ); + // default cell XF (1) + aXF.SetData( pnDefCell, STATIC_TABLE_SIZE( pnDefCell ) ); aXF.Save( rStrm ); + // built-in styles (5) + aXF.SetData( pnBuiltInStyle1, STATIC_TABLE_SIZE( pnBuiltInStyle1 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle2, STATIC_TABLE_SIZE( pnBuiltInStyle2 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle3, STATIC_TABLE_SIZE( pnBuiltInStyle3 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle4, STATIC_TABLE_SIZE( pnBuiltInStyle4 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle5, STATIC_TABLE_SIZE( pnBuiltInStyle5 ) ); aXF.Save( rStrm ); +} + +void XclExpXFBuffer::WriteDefaultXFs8( XclExpStream& rStrm ) +{ + static const sal_uInt8 pnDefStyle[] = { 0x00,0x00,0x00,0x00,0xF5,0xFF,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnOutlineStyle1[] = { 0x01,0x00,0x00,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnOutlineStyle2[] = { 0x02,0x00,0x00,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnOutlineStyle3[] = { 0x00,0x00,0x00,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnDefCell[] = { 0x00,0x00,0x00,0x00,0x01,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnBuiltInStyle1[] = { 0x01,0x00,0x2B,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnBuiltInStyle2[] = { 0x01,0x00,0x29,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnBuiltInStyle3[] = { 0x01,0x00,0x2C,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnBuiltInStyle4[] = { 0x01,0x00,0x2A,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + static const sal_uInt8 pnBuiltInStyle5[] = { 0x01,0x00,0x09,0x00,0xF5,0xFF,0x20,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x20 }; + + // default style (1) + XclExpDummyRecord aXF( EXC_ID_XF, pnDefStyle, STATIC_TABLE_SIZE( pnDefStyle ) ); aXF.Save( rStrm ); + // outline styles (14) + aXF.SetData( pnOutlineStyle1, STATIC_TABLE_SIZE( pnOutlineStyle1 ) ); aXF.SaveRepeated( rStrm, 2 ); + aXF.SetData( pnOutlineStyle2, STATIC_TABLE_SIZE( pnOutlineStyle2 ) ); aXF.SaveRepeated( rStrm, 2 ); + aXF.SetData( pnOutlineStyle3, STATIC_TABLE_SIZE( pnOutlineStyle3 ) ); aXF.SaveRepeated( rStrm, 10 ); + // default cell XF (1) + aXF.SetData( pnDefCell, STATIC_TABLE_SIZE( pnDefCell ) ); aXF.Save( rStrm ); + // built-in styles (5) + aXF.SetData( pnBuiltInStyle1, STATIC_TABLE_SIZE( pnBuiltInStyle1 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle2, STATIC_TABLE_SIZE( pnBuiltInStyle2 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle3, STATIC_TABLE_SIZE( pnBuiltInStyle3 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle4, STATIC_TABLE_SIZE( pnBuiltInStyle4 ) ); aXF.Save( rStrm ); + aXF.SetData( pnBuiltInStyle5, STATIC_TABLE_SIZE( pnBuiltInStyle5 ) ); aXF.Save( rStrm ); +} + +void XclExpXFBuffer::WriteDefaultStyles5( XclExpStream& rStrm ) +{ + XclExpUInt32Record( EXC_ID_STYLE, 0xFF038010 ).Save( rStrm ); + XclExpUInt32Record( EXC_ID_STYLE, 0xFF068011 ).Save( rStrm ); + XclExpUInt32Record( EXC_ID_STYLE, 0xFF048012 ).Save( rStrm ); + XclExpUInt32Record( EXC_ID_STYLE, 0xFF078013 ).Save( rStrm ); + XclExpUInt32Record( EXC_ID_STYLE, 0xFF008000 ).Save( rStrm ); + XclExpUInt32Record( EXC_ID_STYLE, 0xFF058014 ).Save( rStrm ); +} + + // ============================================================================ diff --git a/sc/source/filter/excel/xicontent.cxx b/sc/source/filter/excel/xicontent.cxx index a5f8366356b8..49ee80cfd828 100644 --- a/sc/source/filter/excel/xicontent.cxx +++ b/sc/source/filter/excel/xicontent.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xicontent.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-04 14:18:17 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:36 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -145,6 +145,7 @@ #endif +#include "XclImpObjects.hxx" #include "excform.hxx" @@ -183,6 +184,7 @@ void XclImpBitmap::ReadBitmap( XclImpStream& rStrm ) { const XclImpRoot& rRoot = rStrm.GetRoot(); DBG_ASSERT( rRoot.mpRD->pStyleSheetItemSet, "XclImpBitmap::ReadBitmap - no itemset" ); + if( !rRoot.mpRD->pStyleSheetItemSet ) return; SfxItemSet& rItemSet = *rRoot.mpRD->pStyleSheetItemSet; sal_uInt32 nID; @@ -475,15 +477,16 @@ void XclImpLabelranges::ReadLabelranges( XclImpStream& rStrm ) // Data Validation ============================================================ -void XclImpValidation::ReadDval( XclImpStream& rStrm, XclImpRoot& rRoot ) +void XclImpValidation::ReadDval( XclImpStream& rStrm ) { + const XclImpRoot& rRoot = rStrm.GetRoot(); DBG_ASSERT_BIFF( rRoot.GetBiff() == xlBiff8 ); sal_uInt32 nObjId; rStrm.Ignore( 10 ); rStrm >> nObjId; if( nObjId != EXC_DVAL_NOOBJ ) - rRoot.SetIgnoreObject( nObjId ); + rRoot.GetObjectManager().SetIgnoreObject( nObjId ); } void XclImpValidation::ReadDv( XclImpStream& rStrm, ExcelToSc& rFmlaConv ) diff --git a/sc/source/filter/excel/xihelper.cxx b/sc/source/filter/excel/xihelper.cxx index a0d68643a523..2c304539777c 100644 --- a/sc/source/filter/excel/xihelper.cxx +++ b/sc/source/filter/excel/xihelper.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xihelper.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:26 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:36 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -323,6 +323,7 @@ void XclImpHFConverter::ParseString( const String& rHFString ) } eState = xlPSText; const sal_Unicode* pChar = rHFString.GetBuffer(); + const sal_Unicode* pNull = pChar + rHFString.Len(); // pointer to teminating null char while( *pChar ) { switch( eState ) @@ -365,9 +366,20 @@ void XclImpHFConverter::ParseString( const String& rHFString ) case 'N': InsertField( SvxFieldItem( SvxPagesField() ) ); break; // page count case 'D': InsertField( SvxFieldItem( SvxDateField() ) ); break; // date case 'T': InsertField( SvxFieldItem( SvxTimeField() ) ); break; // time - case 'F': InsertField( SvxFieldItem( SvxExtFileField() ) ); break; // file case 'A': InsertField( SvxFieldItem( SvxTableField() ) ); break; // table name + case 'Z': // file path + InsertField( SvxFieldItem( SvxExtFileField() ) ); // convert to full name + if( (pNull - pChar >= 2) && (*(pChar + 1) == '&') && (*(pChar + 2) == 'F') ) + { + // &Z&F found - ignore the &F part + pChar += 2; + } + break; + case 'F': // file name + InsertField( SvxFieldItem( SvxExtFileField( EMPTY_STRING, SVXFILETYPE_VAR, SVXFILEFORMAT_NAME_EXT ) ) ); + break; + case 'U': // underline SetAttribs(); mpFontData->meUnderline = (mpFontData->meUnderline == xlUnderlSingle) ? @@ -616,7 +628,7 @@ void XclImpUrlHelper::DecodeUrl( rUrl.Append( '\\' ); else // control character in raw name -> DDE link { - rUrl.Append( '|' ); + rUrl.Append( EXC_DDE_DELIM ); eState = xlUrlRaw; } break; diff --git a/sc/source/filter/excel/xilink.cxx b/sc/source/filter/excel/xilink.cxx index 7f80582178b5..5ed531463adf 100644 --- a/sc/source/filter/excel/xilink.cxx +++ b/sc/source/filter/excel/xilink.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xilink.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:12:51 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:36 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -129,8 +129,8 @@ XclImpExtName::XclImpExtName( XclImpStream& rStrm ) if( ::get_flag( nFlags, EXC_EXTN_BUILTIN ) || !::get_flag( nFlags, EXC_EXTN_OLE_OR_DDE ) ) { meType = xlExtName; - ScfTools::ConvertName( maName, true ); // also a point is a valid char for func names! - maName = rStrm.GetRoot().GetAddInNames().GetScName( maName ); + maAddInName = rStrm.GetRoot().GetAddInNames().GetScName( maName ); + ScfTools::ConvertToScDefinedName( maName ); } else meType = ::get_flagvalue( nFlags, EXC_EXTN_OLE, xlExtOLE, xlExtDDE ); @@ -205,14 +205,17 @@ void XclImpSupbookTab::CreateTable( ScDocument& rDoc, const String& rUrl ) XclImpSupbook::XclImpSupbook( XclImpStream& rStrm ) : mnCurrExcTab( EXC_TAB_INVALID ), - mbSelf( false ) + mbSelf( false ), + mbAddIn( false ) { sal_uInt16 nTabCnt; rStrm >> nTabCnt; if( rStrm.GetRecLeft() == 2 ) { - mbSelf = (rStrm.ReaduInt16() == EXC_SUPB_SELF); + sal_uInt16 nType = rStrm.ReaduInt16(); + mbSelf = (nType == EXC_SUPB_SELF); + mbAddIn = (nType == EXC_SUPB_ADDIN); return; } @@ -242,7 +245,7 @@ void XclImpSupbook::ReadUrl( XclImpStream& rStrm, String& rUrl, bool& rbSelf ) void XclImpSupbook::ReadTabName( XclImpStream& rStrm, String& rTabName ) { rStrm.AppendUniString( rTabName ); - ScfTools::ConvertName( rTabName ); + ScfTools::ConvertToScSheetName( rTabName ); } void XclImpSupbook::ReadXct( XclImpStream& rStrm ) @@ -277,9 +280,7 @@ const XclImpExtName* XclImpSupbook::GetExtName( sal_uInt16 nXclIndex ) const bool XclImpSupbook::GetLink( String& rApplic, String& rDoc ) const { - // first backslash is application name delimiter - // (created by XclImpUrlDecoder::DecodeUrl()) - xub_StrLen nPos = maUrl.Search( '\\' ); + xub_StrLen nPos = maUrl.Search( EXC_DDE_DELIM ); if( mbSelf || !maUrl.Len() || (nPos == STRING_NOTFOUND) ) return false; rApplic = maUrl.Copy( 0, nPos ); diff --git a/sc/source/filter/excel/xiroot.cxx b/sc/source/filter/excel/xiroot.cxx index 88cc80e83959..f24c562fdd95 100644 --- a/sc/source/filter/excel/xiroot.cxx +++ b/sc/source/filter/excel/xiroot.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xiroot.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:12:51 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:36 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -62,7 +62,6 @@ #ifdef PCH #include "filt_pch.hxx" #endif - #pragma hdrstop // ============================================================================ @@ -81,12 +80,13 @@ #include "xicontent.hxx" #endif +#include "XclImpObjects.hxx" + // Global data ================================================================ XclImpRootData::XclImpRootData( XclBiff eBiff, ScDocument& rDocument, const String& rBasePath, CharSet eCharSet ) : - XclRootData( eBiff, rDocument, rBasePath, eCharSet ), - mbIgnoreObjSorted( false ) + XclRootData( eBiff, rDocument, rBasePath, eCharSet ) { } @@ -101,13 +101,13 @@ XclImpRoot::XclImpRoot( XclImpRootData& rImpRootData ) : XclRoot( rImpRootData ), mrImpData( rImpRootData ) { - mrImpData.mpPalette.reset( new XclImpPalette( *this ) ); - mrImpData.mpFontBuffer.reset( new XclImpFontBuffer( *this ) ); - mrImpData.mpNumFmtBuffer.reset( new XclImpNumFmtBuffer( *this ) ); - mrImpData.mpXFBuffer.reset( new XclImpXFBuffer( *this ) ); - mrImpData.mpXFIndexBuffer.reset( new XclImpXFIndexBuffer( *this ) ); + mrImpData.mpPalette.reset( new XclImpPalette( GetRoot() ) ); + mrImpData.mpFontBuffer.reset( new XclImpFontBuffer( GetRoot() ) ); + mrImpData.mpNumFmtBuffer.reset( new XclImpNumFmtBuffer( GetRoot() ) ); + mrImpData.mpXFBuffer.reset( new XclImpXFBuffer( GetRoot() ) ); + mrImpData.mpXFIndexBuffer.reset( new XclImpXFIndexBuffer( GetRoot() ) ); mrImpData.mpTabIdBuffer.reset( new XclImpTabIdBuffer ); - mrImpData.mpLinkManager.reset( new XclImpLinkManager( *this ) ); + mrImpData.mpLinkManager.reset( new XclImpLinkManager( GetRoot() ) ); } XclImpRoot::XclImpRoot( const XclImpRoot& rRoot ) : @@ -125,13 +125,13 @@ XclImpRoot& XclImpRoot::operator=( const XclImpRoot& rRoot ) void XclImpRoot::SetBiff( XclBiff eBiff ) { XclRoot::SetBiff( eBiff ); - GetPalette().SetBiff( eBiff ); + GetPalette().OnChangeBiff(); } XclImpSst& XclImpRoot::GetSst() const { if( !mrImpData.mpSst.get() ) - mrImpData.mpSst.reset( new XclImpSst( *this ) ); + mrImpData.mpSst.reset( new XclImpSst( GetRoot() ) ); return *mrImpData.mpSst; } @@ -170,10 +170,17 @@ XclImpLinkManager& XclImpRoot::GetLinkManager() const return *mrImpData.mpLinkManager; } +XclImpObjectManager& XclImpRoot::GetObjectManager() const +{ + if( !mrImpData.mpObjManager.get() ) + mrImpData.mpObjManager.reset( new XclImpObjectManager( GetRoot() ) ); + return *mrImpData.mpObjManager; +} + XclImpWebQueryBuffer& XclImpRoot::GetWebQueryBuffer() const { if( !mrImpData.mpWebQBuffer.get() ) - mrImpData.mpWebQBuffer.reset( new XclImpWebQueryBuffer( *this ) ); + mrImpData.mpWebQBuffer.reset( new XclImpWebQueryBuffer( GetRoot() ) ); return *mrImpData.mpWebQBuffer; } @@ -192,22 +199,6 @@ void XclImpRoot::CheckCellRangeList( ScRangeList& rRanges ) const XclRoot::CheckCellRangeList( rRanges, GetScMaxPos() ); } -void XclImpRoot::SetIgnoreObject( sal_uInt32 nObjId ) -{ - mrImpData.maIgnoreObj.push_back( nObjId ); - mrImpData.mbIgnoreObjSorted = false; -} - -bool XclImpRoot::IsIgnoreObject( sal_uInt32 nObjId ) const -{ - if( !mrImpData.mbIgnoreObjSorted ) - { - ::std::sort( mrImpData.maIgnoreObj.begin(), mrImpData.maIgnoreObj.end() ); - mrImpData.mbIgnoreObjSorted = true; - } - return ::std::binary_search( mrImpData.maIgnoreObj.begin(), mrImpData.maIgnoreObj.end(), nObjId ); -} - // ============================================================================ diff --git a/sc/source/filter/excel/xistream.cxx b/sc/source/filter/excel/xistream.cxx index eb367435abc1..e81d3c1a906b 100644 --- a/sc/source/filter/excel/xistream.cxx +++ b/sc/source/filter/excel/xistream.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xistream.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:27 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:37 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -83,6 +83,7 @@ // ============================================================================ +#if SC_XCL_USEDECR XclImpDecrypter::~XclImpDecrypter() { } @@ -222,6 +223,7 @@ sal_uInt32 XclImpBiff8Decrypter::ReadDecrypt( SvStream& rStrm, void* pData, sal_ { return rStrm.Read( pData, nBytes ); } +#endif // ============================================================================ @@ -279,7 +281,9 @@ XclImpStream::XclImpStream( SvStream& rInStrm, const XclImpRoot& rRoot, bool bCo mnRecSize( 0 ), mnRecLeft( 0 ), mbCont( bContHandling ), +#if SC_XCL_USEDECR mbUseDecr( false ), +#endif mbValidRec( false ), mbValid( false ), mbWarnings( true ) @@ -300,7 +304,9 @@ bool XclImpStream::GetNextRecord( sal_uInt16& rnRecId, sal_uInt16& rnRecSize ) if( bRet ) { mrStrm >> rnRecId >> rnRecSize; // read direct +#if SC_XCL_USEDECR SetDecrypterOffset( rnRecSize ); +#endif } else rnRecId = rnRecSize = 0; @@ -359,6 +365,7 @@ void XclImpStream::InitializeRecord( bool bContHandling, sal_uInt16 nAltContId ) } } +#if SC_XCL_USEDECR void XclImpStream::EnableDecryption( XclImpDecrypter* pDecrypter ) { mpDecrypter.reset( pDecrypter ); @@ -370,6 +377,7 @@ void XclImpStream::UseDecryption( bool bUse ) { mbUseDecr = (mpDecrypter.get() && mpDecrypter->IsValid()) ? bUse : false; } +#endif bool XclImpStream::GetContinue() { @@ -455,7 +463,9 @@ void XclImpStream::SeekGlobalPosition() mnComplRecSize = mnCurrRecSize; mbHasComplRec = !mbCont; mbValidRec = mbValid = mbGlobValidRec; +#if SC_XCL_USEDECR SetDecrypterOffset( mnRecSize ); +#endif } } @@ -477,24 +487,29 @@ sal_uInt32 XclImpStream::GetRecSize() void XclImpStream::ReadAtom( sal_Int8& rnValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) mpDecrypter->ReadDecrypt( mrStrm, &rnValue, 1 ); else +#endif mrStrm >> rnValue; --mnRecLeft; } void XclImpStream::ReadAtom( sal_uInt8& rnValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) mpDecrypter->ReadDecrypt( mrStrm, &rnValue, 1 ); else +#endif mrStrm >> rnValue; --mnRecLeft; } void XclImpStream::ReadAtom( sal_Int16& rnValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) { SVBT16 pBuffer; @@ -502,12 +517,14 @@ void XclImpStream::ReadAtom( sal_Int16& rnValue ) rnValue = static_cast< sal_Int16 >( SVBT16ToShort( pBuffer ) ); } else +#endif mrStrm >> rnValue; mnRecLeft -= 2; } void XclImpStream::ReadAtom( sal_uInt16& rnValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) { SVBT16 pBuffer; @@ -515,12 +532,14 @@ void XclImpStream::ReadAtom( sal_uInt16& rnValue ) rnValue = SVBT16ToShort( pBuffer ); } else +#endif mrStrm >> rnValue; mnRecLeft -= 2; } void XclImpStream::ReadAtom( sal_Int32& rnValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) { SVBT32 pBuffer; @@ -528,12 +547,14 @@ void XclImpStream::ReadAtom( sal_Int32& rnValue ) rnValue = static_cast< sal_Int32 >( SVBT32ToLong( pBuffer ) ); } else +#endif mrStrm >> rnValue; mnRecLeft -= 4; } void XclImpStream::ReadAtom( sal_uInt32& rnValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) { SVBT32 pBuffer; @@ -541,12 +562,14 @@ void XclImpStream::ReadAtom( sal_uInt32& rnValue ) rnValue = SVBT32ToLong( pBuffer ); } else +#endif mrStrm >> rnValue; mnRecLeft -= 4; } void XclImpStream::ReadAtom( float& rfValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) { SVBT32 pBuffer; @@ -555,12 +578,14 @@ void XclImpStream::ReadAtom( float& rfValue ) memcpy( &rfValue, &nValue, 4 ); } else +#endif mrStrm >> rfValue; mnRecLeft -= 4; } void XclImpStream::ReadAtom( double& rfValue ) { +#if SC_XCL_USEDECR if( mbUseDecr ) { SVBT64 pBuffer; @@ -568,14 +593,19 @@ void XclImpStream::ReadAtom( double& rfValue ) rfValue = SVBT64ToDouble( pBuffer ); } else +#endif mrStrm >> rfValue; mnRecLeft -= 8; } sal_uInt32 XclImpStream::ReadData( void* pData, sal_uInt32 nBytes ) { +#if SC_XCL_USEDECR sal_uInt32 nRet = mbUseDecr ? mpDecrypter->ReadDecrypt( mrStrm, pData, nBytes ) : mrStrm.Read( pData, nBytes ); +#else + sal_uInt32 nRet = mrStrm.Read( pData, nBytes ); +#endif mnRecLeft -= nRet; return nRet; } diff --git a/sc/source/filter/excel/xistyle.cxx b/sc/source/filter/excel/xistyle.cxx index e0a489fa9e35..f7c5eb32fe3e 100644 --- a/sc/source/filter/excel/xistyle.cxx +++ b/sc/source/filter/excel/xistyle.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xistyle.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:27 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:37 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -161,10 +161,16 @@ // PALETTE record - color information ========================================= XclImpPalette::XclImpPalette( const XclImpRoot& rRoot ) : - XclDefaultPalette( rRoot.GetBiff() ) + XclDefaultPalette( rRoot.GetBiff() ), + XclImpRoot( rRoot ) { } +void XclImpPalette::OnChangeBiff() +{ + SetDefaultColors( GetBiff() ); +} + ColorData XclImpPalette::GetColorData( sal_uInt16 nXclIndex, ColorData nDefault ) const { if( nXclIndex >= GetIndexOffset() ) @@ -244,6 +250,19 @@ XclImpFont::XclImpFont( const XclImpRoot& rRoot, const XclFontData& rFontData ) Update(); /// sets internal font charset/family and script types } +long XclImpFont::GetCharWidth() const +{ + if( SfxPrinter* pPrinter = GetPrinter() ) + { + Font aFont( maData.maName, Size( 0, maData.mnHeight ) ); + aFont.SetFamily( meFontFamily ); + aFont.SetCharSet( meFontCharSet ); + pPrinter->SetFont( aFont ); + return pPrinter->GetTextWidth( String( '0' ) ); + } + return 11 * maData.mnHeight / 20; +} + void XclImpFont::ReadFont( XclImpStream& rStrm ) { switch( GetBiff() ) @@ -274,35 +293,6 @@ void XclImpFont::ReadFont( XclImpStream& rStrm ) Update(); } -double XclImpFont::CalcColumnScale() const -{ - double fScale; - switch( maData.mnHeight ) - { - case 240: fScale = 1.21860; break; // 12pt - case 320: fScale = 1.61040; break; // 16pt - default: - { - SfxPrinter* pPrinter = GetPrinter(); - if( pPrinter ) - { - Font aFont( maData.maName, Size( 0, maData.mnHeight ) ); - aFont.SetFamily( meFontFamily ); - aFont.SetCharSet( meFontCharSet ); - pPrinter->SetFont( aFont ); - fScale = pPrinter->GetTextWidth( String( '0' ) ); - fScale /= 111.0; - } - else - { - fScale = maData.mnHeight; - fScale /= 200.0; // default height = 10pt = 200twips - } - } - } - return fScale; -} - void XclImpFont::FillToItemSet( SfxItemSet& rItemSet, XclFontWhichIDMode eMode ) const { bool bEE = (eMode == xlFontEEIDs) || (eMode == xlFontHFIDs); @@ -469,15 +459,7 @@ FontFamily XclImpFont::GetScFontFamily( sal_uInt8 nXclFamily, const String& rNam CharSet XclImpFont::GetScFontCharSet( sal_uInt8 nXclCharSet ) { - CharSet eScCharSet; - switch( nXclCharSet ) - { - case EXC_FONTCSET_MS_1252: eScCharSet = RTL_TEXTENCODING_MS_1252; break; - case EXC_FONTCSET_IBM_850: eScCharSet = RTL_TEXTENCODING_IBM_850; break; - case EXC_FONTCSET_SYMBOL: eScCharSet = RTL_TEXTENCODING_SYMBOL; break; - default: eScCharSet = ScfTools::GetSystemCharSet(); - } - return eScCharSet; + return rtl_getTextEncodingFromWindowsCharset(nXclCharSet); } FontItalic XclImpFont::GetScFontPosture( bool bXclItalic ) @@ -531,19 +513,31 @@ SvxEscapement XclImpFont::GetScFontEscapement( XclEscapement eXclEscapem ) // ---------------------------------------------------------------------------- +XclImpFontBuffer::XclImpFontBuffer( const XclImpRoot& rRoot ) : + XclImpRoot( rRoot ) +{ + // application font for column width calculation, filled with first font from font list + maAppFont.maName.AssignAscii( "Arial" ); + maAppFont.mnHeight = 200; + SetCharWidth( 110 ); +} + void XclImpFontBuffer::ReadFont( XclImpStream& rStrm ) { // Font with index 4 is not stored in an Excel file -> create a dummy font. if( maFontList.Count() == 4 ) - maFontList.Append( new XclImpFont( *maFontList.GetObject( 0 ) ) ); + maFontList.Append( new XclImpFont( *GetFont( 0 ) ) ); - XclImpFont* pFont = new XclImpFont( *this ); + XclImpFont* pFont = new XclImpFont( GetRoot() ); pFont->ReadFont( rStrm ); maFontList.Append( pFont ); - // Calculate the column scale from first font and current printer. if( maFontList.Count() == 1 ) - mpRD->fColScale *= pFont->CalcColumnScale(); + { + maAppFont = pFont->GetFontData(); + // #i3006# Calculate the width of '0' from first font and current printer. + SetCharWidth( pFont->GetCharWidth() ); + } } void XclImpFontBuffer::FillToItemSet( sal_uInt16 nFontIndex, SfxItemSet& rItemSet, XclFontWhichIDMode eMode ) const @@ -613,7 +607,7 @@ static const XclImpBuiltInFormat pBuiltInFormats[] = XclImpNumFmtBuffer::XclImpNumFmtBuffer( const XclImpRoot& rRoot ) : XclImpRoot( rRoot ), - mnDefault( GetFormatter().GetStandardFormat( GetDefLanguage() ) ) + mnStdFmt( GetFormatter().GetStandardFormat( GetDefLanguage() ) ) { } @@ -622,7 +616,7 @@ sal_uInt32 XclImpNumFmtBuffer::GetFormat( sal_uInt32 nIndex ) if( maKeyVec.empty() ) InsertBuiltinFormats(); - return (nIndex < maKeyVec.size()) ? maKeyVec[ nIndex ] : mnDefault; + return (nIndex < maKeyVec.size()) ? maKeyVec[ nIndex ] : mnStdFmt; } void XclImpNumFmtBuffer::ReadFormat( XclImpStream& rStrm ) @@ -676,7 +670,7 @@ void XclImpNumFmtBuffer::ReadFormat( XclImpStream& rStrm ) void XclImpNumFmtBuffer::InsertBuiltinFormats() { - const XclImpBuiltInFormat* pEnd = pBuiltInFormats + STATIC_TABLE_SIZE( pBuiltInFormats ); + const XclImpBuiltInFormat* pEnd = STATIC_TABLE_END( pBuiltInFormats ); String aFormat; xub_StrLen nCheckPos; @@ -700,122 +694,87 @@ void XclImpNumFmtBuffer::InsertBuiltinFormats() void XclImpNumFmtBuffer::InsertKey( sal_uInt32 nIndex, sal_uInt32 nFormatKey ) { if( nIndex >= maKeyVec.size() ) - maKeyVec.resize( nIndex + 1, mnDefault ); + maKeyVec.resize( nIndex + 1, mnStdFmt ); maKeyVec[ nIndex ] = nFormatKey; } // XF, STYLE record - Cell formatting ========================================= -/** Contains color and line style for each cell border line. */ -struct XclImpXFBorder -{ - sal_uInt16 mnLeftColor; /// Index to color for left line. - sal_uInt16 mnRightColor; /// Index to color for right line. - sal_uInt16 mnTopColor; /// Index to color for top line. - sal_uInt16 mnBottomColor; /// Index to color for bottom line. - sal_uInt8 mnLeftLine; /// Style of left line. - sal_uInt8 mnRightLine; /// Style of right line. - sal_uInt8 mnTopLine; /// Style of top line. - sal_uInt8 mnBottomLine; /// Style of bottom line. - - void SetBorder2( sal_uInt8 nFlags ); - void SetBorder34( sal_uInt32 nBorder ); - void SetBorder5( sal_uInt32 nBorder, sal_uInt32 nArea ); - void SetBorder8( sal_uInt32 nBorder1, sal_uInt32 nBorder2 ); -}; - -void XclImpXFBorder::SetBorder2( sal_uInt8 nFlags ) +void lcl_SetBorder2( XclImpXFBorder& rBorder, sal_uInt8 nFlags ) { - ::extract_value( mnLeftLine, nFlags, 3, 1 ); - ::extract_value( mnRightLine, nFlags, 4, 1 ); - ::extract_value( mnTopLine, nFlags, 5, 1 ); - ::extract_value( mnBottomLine, nFlags, 6, 1 ); - mnLeftColor = mnRightColor = mnTopColor = mnBottomColor = 0; // black + rBorder.mnLeftLine = ::get_flagvalue( nFlags, EXC_XF2_LEFTLINE, EXC_LINE_THIN, EXC_LINE_NONE ); + rBorder.mnRightLine = ::get_flagvalue( nFlags, EXC_XF2_RIGHTLINE, EXC_LINE_THIN, EXC_LINE_NONE ); + rBorder.mnTopLine = ::get_flagvalue( nFlags, EXC_XF2_TOPLINE, EXC_LINE_THIN, EXC_LINE_NONE ); + rBorder.mnBottomLine = ::get_flagvalue( nFlags, EXC_XF2_BOTTOMLINE, EXC_LINE_THIN, EXC_LINE_NONE ); + rBorder.mnLeftColor = rBorder.mnRightColor = rBorder.mnTopColor = rBorder.mnBottomColor = EXC_COLOR_BIFF2_BLACK; } -void XclImpXFBorder::SetBorder34( sal_uInt32 nBorder ) +void lcl_SetBorder3( XclImpXFBorder& rBorder, sal_uInt32 nBorder ) { - ::extract_value( mnTopLine, nBorder, 0, 3 ); - ::extract_value( mnLeftLine, nBorder, 8, 3 ); - ::extract_value( mnBottomLine, nBorder, 16, 3 ); - ::extract_value( mnRightLine, nBorder, 24, 3 ); - ::extract_value( mnTopColor, nBorder, 3, 5 ); - ::extract_value( mnLeftColor, nBorder, 11, 5 ); - ::extract_value( mnBottomColor, nBorder, 19, 5 ); - ::extract_value( mnRightColor, nBorder, 27, 5 ); + ::extract_value( rBorder.mnTopLine, nBorder, 0, 3 ); + ::extract_value( rBorder.mnLeftLine, nBorder, 8, 3 ); + ::extract_value( rBorder.mnBottomLine, nBorder, 16, 3 ); + ::extract_value( rBorder.mnRightLine, nBorder, 24, 3 ); + ::extract_value( rBorder.mnTopColor, nBorder, 3, 5 ); + ::extract_value( rBorder.mnLeftColor, nBorder, 11, 5 ); + ::extract_value( rBorder.mnBottomColor, nBorder, 19, 5 ); + ::extract_value( rBorder.mnRightColor, nBorder, 27, 5 ); } -void XclImpXFBorder::SetBorder5( sal_uInt32 nBorder, sal_uInt32 nArea ) +void lcl_SetBorder5( XclImpXFBorder& rBorder, sal_uInt32 nBorder, sal_uInt32 nArea ) { - ::extract_value( mnTopLine, nBorder, 0, 3 ); - ::extract_value( mnLeftLine, nBorder, 3, 3 ); - ::extract_value( mnBottomLine, nArea, 22, 3 ); - ::extract_value( mnRightLine, nBorder, 6, 3 ); - ::extract_value( mnTopColor, nBorder, 9, 7 ); - ::extract_value( mnLeftColor, nBorder, 16, 7 ); - ::extract_value( mnBottomColor, nArea, 25, 7 ); - ::extract_value( mnRightColor, nBorder, 23, 7 ); + ::extract_value( rBorder.mnTopLine, nBorder, 0, 3 ); + ::extract_value( rBorder.mnLeftLine, nBorder, 3, 3 ); + ::extract_value( rBorder.mnBottomLine, nArea, 22, 3 ); + ::extract_value( rBorder.mnRightLine, nBorder, 6, 3 ); + ::extract_value( rBorder.mnTopColor, nBorder, 9, 7 ); + ::extract_value( rBorder.mnLeftColor, nBorder, 16, 7 ); + ::extract_value( rBorder.mnBottomColor, nArea, 25, 7 ); + ::extract_value( rBorder.mnRightColor, nBorder, 23, 7 ); } -void XclImpXFBorder::SetBorder8( sal_uInt32 nBorder1, sal_uInt32 nBorder2 ) +void lcl_SetBorder8( XclImpXFBorder& rBorder, sal_uInt32 nBorder1, sal_uInt32 nBorder2 ) { - ::extract_value( mnLeftLine, nBorder1, 0, 4 ); - ::extract_value( mnRightLine, nBorder1, 4, 4 ); - ::extract_value( mnTopLine, nBorder1, 8, 4 ); - ::extract_value( mnBottomLine, nBorder1, 12, 4 ); - ::extract_value( mnLeftColor, nBorder1, 16, 7 ); - ::extract_value( mnRightColor, nBorder1, 23, 7 ); - ::extract_value( mnTopColor, nBorder2, 0, 7 ); - ::extract_value( mnBottomColor, nBorder2, 7, 7 ); + ::extract_value( rBorder.mnLeftLine, nBorder1, 0, 4 ); + ::extract_value( rBorder.mnRightLine, nBorder1, 4, 4 ); + ::extract_value( rBorder.mnTopLine, nBorder1, 8, 4 ); + ::extract_value( rBorder.mnBottomLine, nBorder1, 12, 4 ); + ::extract_value( rBorder.mnLeftColor, nBorder1, 16, 7 ); + ::extract_value( rBorder.mnRightColor, nBorder1, 23, 7 ); + ::extract_value( rBorder.mnTopColor, nBorder2, 0, 7 ); + ::extract_value( rBorder.mnBottomColor, nBorder2, 7, 7 ); } // ---------------------------------------------------------------------------- -/** Contains background colors and pattern. */ -struct XclImpXFArea -{ - sal_uInt16 mnForeColor; /// Index to foreground color. - sal_uInt16 mnBackColor; /// Index to background color. - sal_uInt8 mnPattern; /// Fill pattern. - - void SetArea2( sal_uInt8 nFlags ); - void SetArea34( sal_uInt16 nArea ); - void SetArea5( sal_uInt32 nArea ); - void SetArea8( sal_uInt32 nBorder2, sal_uInt16 nArea ); -}; - -void XclImpXFArea::SetArea2( sal_uInt8 nFlags ) +void lcl_SetArea2( XclImpXFArea& rArea, sal_uInt8 nFlags ) { - mnPattern = EXC_PATT_NONE; - if( nFlags & EXC_XF2_BACKGROUND ) - { - mnPattern = EXC_PATT_12_5_PERC; - mnForeColor = EXC_COLOR_BIFF2_BLACK; - mnBackColor = EXC_COLOR_BIFF2_WHITE; - } + rArea.mnPattern = ::get_flagvalue( nFlags, EXC_XF2_BACKGROUND, EXC_PATT_12_5_PERC, EXC_PATT_NONE ); + rArea.mnForeColor = EXC_COLOR_BIFF2_BLACK; + rArea.mnBackColor = EXC_COLOR_BIFF2_WHITE; } -void XclImpXFArea::SetArea34( sal_uInt16 nArea ) +void lcl_SetArea3( XclImpXFArea& rArea, sal_uInt16 nArea ) { - ::extract_value( mnPattern, nArea, 0, 6 ); - ::extract_value( mnForeColor, nArea, 6, 5 ); - ::extract_value( mnBackColor, nArea, 11, 5 ); + ::extract_value( rArea.mnPattern, nArea, 0, 6 ); + ::extract_value( rArea.mnForeColor, nArea, 6, 5 ); + ::extract_value( rArea.mnBackColor, nArea, 11, 5 ); } -void XclImpXFArea::SetArea5( sal_uInt32 nArea ) +void lcl_SetArea5( XclImpXFArea& rArea, sal_uInt32 nArea ) { - ::extract_value( mnPattern, nArea, 16, 6 ); - ::extract_value( mnForeColor, nArea, 0, 7 ); - ::extract_value( mnBackColor, nArea, 7, 7 ); + ::extract_value( rArea.mnPattern, nArea, 16, 6 ); + ::extract_value( rArea.mnForeColor, nArea, 0, 7 ); + ::extract_value( rArea.mnBackColor, nArea, 7, 7 ); } -void XclImpXFArea::SetArea8( sal_uInt32 nBorder2, sal_uInt16 nArea ) +void lcl_SetArea8( XclImpXFArea& rArea, sal_uInt32 nBorder2, sal_uInt16 nArea ) { - ::extract_value( mnPattern, nBorder2, 26, 6 ); - ::extract_value( mnForeColor, nArea, 0, 7 ); - ::extract_value( mnBackColor, nArea, 7, 7 ); + ::extract_value( rArea.mnPattern, nBorder2, 26, 6 ); + ::extract_value( rArea.mnForeColor, nArea, 0, 7 ); + ::extract_value( rArea.mnBackColor, nArea, 7, 7 ); } @@ -823,22 +782,25 @@ void XclImpXFArea::SetArea8( sal_uInt32 nBorder2, sal_uInt16 nArea ) XclImpXF::XclImpXF( const XclImpRoot& rRoot ) : XclImpRoot( rRoot ), - meHorAlign( xlHAlignParent ), - meVerAlign( xlVAlignParent ), - meWrap( xlTextWrapParent ), - meOrient( xlTextOrientParent ), - meTextDir( xlTextDirParent ), - mnRotation( 0 ), - mnValFormat( 0 ), - mnIndent( 0 ), - mnFont( 0 ), + meHorAlign( xlHAlignGeneral ), + meVerAlign( xlVAlignBottom ), + meOrient( xlTextOrientNoRot ), + meTextDir( xlTextDirContext ), mnParent( 0 ), + mnNumFmt( 0 ), + mnFont( 0 ), + mnIndent( 0 ), + mnRotation( 0 ), mbCellXF( true ), // default is cell XF mbLocked( true ), // default in Excel and Calc mbHidden( false ), - mbFontValid( false ), - mbFmtValid( false ), - mbProtValid( false ) + mbWrapped( false ), + mbProtUsed( false ), + mbFontUsed( false ), + mbFmtUsed( false ), + mbAlignUsed( false ), + mbBorderUsed( false ), + mbAreaUsed( false ) { } @@ -848,136 +810,160 @@ XclImpXF::~XclImpXF() void XclImpXF::ReadXF2( XclImpStream& rStrm ) { - sal_uInt8 nValFmt, nFlags; + sal_uInt8 nNumFmt, nFlags; mnFont = rStrm.ReaduInt8(); rStrm.Ignore( 1 ); - rStrm >> nValFmt >> nFlags; + rStrm >> nNumFmt >> nFlags; - GetBorder().SetBorder2( nFlags ); - GetArea().SetArea2( nFlags ); - mnValFormat = GetNumFmtBuffer().GetFormat( nValFmt & EXC_XF2_VALFMT_MASK ); + lcl_SetBorder2( maBorder, nFlags ); + lcl_SetArea2( maArea, nFlags ); + mnNumFmt = GetNumFmtBuffer().GetFormat( nNumFmt & EXC_XF2_VALFMT_MASK ); ::extract_value( meHorAlign, nFlags, 0, 3 ); - meVerAlign = xlVAlignTop; - meWrap = xlTextWrapNo; - meOrient = xlTextOrientNoRot; - mbLocked = ::get_flag( nValFmt, EXC_XF2_LOCKED ); - mbHidden = ::get_flag( nValFmt, EXC_XF2_HIDDEN ); + mbLocked = ::get_flag( nNumFmt, EXC_XF2_LOCKED ); + mbHidden = ::get_flag( nNumFmt, EXC_XF2_HIDDEN ); - mbFontValid = mbFmtValid = mbProtValid = true; + //! TODO flags + mbProtUsed = mbFontUsed = mbFmtUsed = mbAlignUsed = mbBorderUsed = mbAreaUsed = true; } void XclImpXF::ReadXF3( XclImpStream& rStrm ) { sal_uInt32 nBorder; sal_uInt16 nFlags, nAlign, nArea; - sal_uInt8 nValFmt; + sal_uInt8 nNumFmt; mnFont = rStrm.ReaduInt8(); - rStrm >> nValFmt >> nFlags >> nAlign >> nArea >> nBorder; + rStrm >> nNumFmt >> nFlags >> nAlign >> nArea >> nBorder; mbCellXF = !::get_flag( nFlags, EXC_XF_STYLE ); // new in BIFF3 ::extract_value( mnParent, nAlign, 4, 12 ); // new in BIFF3 - GetBorder().SetBorder34( nBorder ); - GetArea().SetArea34( nArea ); // new in BIFF3 - mnValFormat = GetNumFmtBuffer().GetFormat( nValFmt ); + lcl_SetBorder3( maBorder, nBorder ); + lcl_SetArea3( maArea, nArea ); // new in BIFF3 + mnNumFmt = GetNumFmtBuffer().GetFormat( nNumFmt ); ::extract_value( meHorAlign, nAlign, 0, 3 ); - meVerAlign = xlVAlignTop; - ::extract_value( meWrap, nAlign, 3, 1 ); // new in BIFF3 - meOrient = xlTextOrientNoRot; + mbWrapped = ::get_flag( nAlign, EXC_XF_WRAPPED ); // new in BIFF3 mbLocked = ::get_flag( nFlags, EXC_XF_LOCKED ); mbHidden = ::get_flag( nFlags, EXC_XF_HIDDEN ); - mbFontValid = mbFmtValid = mbProtValid = true; + //! TODO flags + mbProtUsed = mbFontUsed = mbFmtUsed = mbAlignUsed = mbBorderUsed = mbAreaUsed = true; } void XclImpXF::ReadXF4( XclImpStream& rStrm ) { sal_uInt32 nBorder; sal_uInt16 nFlags, nAlign, nArea; - sal_uInt8 nValFmt; + sal_uInt8 nNumFmt; mnFont = rStrm.ReaduInt8(); - rStrm >> nValFmt >> nFlags >> nAlign >> nArea >> nBorder; + rStrm >> nNumFmt >> nFlags >> nAlign >> nArea >> nBorder; mbCellXF = !::get_flag( nFlags, EXC_XF_STYLE ); ::extract_value( mnParent, nFlags, 4, 12 ); - GetBorder().SetBorder34( nBorder ); - GetArea().SetArea34( nArea ); - mnValFormat = GetNumFmtBuffer().GetFormat( nValFmt ); + lcl_SetBorder3( maBorder, nBorder ); + lcl_SetArea3( maArea, nArea ); + mnNumFmt = GetNumFmtBuffer().GetFormat( nNumFmt ); ::extract_value( meHorAlign, nAlign, 0, 3 ); ::extract_value( meVerAlign, nAlign, 4, 2 ); // new in BIFF4 - ::extract_value( meWrap, nAlign, 3, 1 ); + mbWrapped = ::get_flag( nAlign, EXC_XF_WRAPPED ); ::extract_value( meOrient, nAlign, 6, 2 ); // new in BIFF4 mbLocked = ::get_flag( nFlags, EXC_XF_LOCKED ); mbHidden = ::get_flag( nFlags, EXC_XF_HIDDEN ); - mbFontValid = mbFmtValid = mbProtValid = true; + //! TODO flags + mbProtUsed = mbFontUsed = mbFmtUsed = mbAlignUsed = mbBorderUsed = mbAreaUsed = true; } void XclImpXF::ReadXF5( XclImpStream& rStrm ) { sal_uInt32 nArea, nBorder; - sal_uInt16 nValFmt, nFlags, nAlign; - rStrm >> mnFont >> nValFmt >> nFlags >> nAlign >> nArea >> nBorder; + sal_uInt16 nNumFmt, nFlags, nAlign; + rStrm >> mnFont >> nNumFmt >> nFlags >> nAlign >> nArea >> nBorder; mbCellXF = !::get_flag( nFlags, EXC_XF_STYLE ); ::extract_value( mnParent, nFlags, 4, 12 ); - GetBorder().SetBorder5( nBorder, nArea ); - GetArea().SetArea5( nArea ); - mnValFormat = GetNumFmtBuffer().GetFormat( nValFmt ); + lcl_SetBorder5( maBorder, nBorder, nArea ); + lcl_SetArea5( maArea, nArea ); + mnNumFmt = GetNumFmtBuffer().GetFormat( nNumFmt ); ::extract_value( meHorAlign, nAlign, 0, 3 ); ::extract_value( meVerAlign, nAlign, 4, 3 ); - ::extract_value( meWrap, nAlign, 3, 1 ); + mbWrapped = ::get_flag( nAlign, EXC_XF_WRAPPED ); ::extract_value( meOrient, nAlign, 8, 2 ); mbLocked = ::get_flag( nFlags, EXC_XF_LOCKED ); mbHidden = ::get_flag( nFlags, EXC_XF_HIDDEN ); - mbFontValid = mbFmtValid = mbProtValid = true; + //! TODO flags + mbProtUsed = mbFontUsed = mbFmtUsed = mbAlignUsed = mbBorderUsed = mbAreaUsed = true; } void XclImpXF::ReadXF8( XclImpStream& rStrm ) { sal_uInt32 nBorder1, nBorder2; - sal_uInt16 nReadFont, nValFmt, nFlags1, nAlign, nFlags2, nArea; - rStrm >> nReadFont >> nValFmt >> nFlags1 >> nAlign >> nFlags2 >> nBorder1 >> nBorder2 >> nArea; + sal_uInt16 nReadFont, nReadNumFmt, nTypeProt, nAlign, nMiscAttrib, nArea; + rStrm >> nReadFont >> nReadNumFmt >> nTypeProt >> nAlign >> nMiscAttrib >> nBorder1 >> nBorder2 >> nArea; - mbCellXF = !::get_flag( nFlags1, EXC_XF_STYLE ); + mbCellXF = !::get_flag( nTypeProt, EXC_XF_STYLE ); if( mbCellXF ) - ::extract_value( mnParent, nFlags1, 4, 12 ); - // Border - if( mbCellXF || !::get_flag( nFlags2, EXC_XF_DIFF_BORDER ) ) - GetBorder().SetBorder8( nBorder1, nBorder2 ); - // Area - if( mbCellXF || !::get_flag( nFlags2, EXC_XF_DIFF_AREA ) ) - GetArea().SetArea8( nBorder2, nArea ); - // Font - mbFontValid = mbCellXF || !::get_flag( nFlags2, EXC_XF_DIFF_FONT ); - if( mbFontValid ) + ::extract_value( mnParent, nTypeProt, 4, 12 ); + + // Remark about finding the mb***Used flags: + // - In cell XFs a *set* bit means a used attribute. + // - In style XFs a *cleared* bit means a used attribute. + // The mb***Used members always store true, if the attribute is used. + // The "mbCellXF == ::get_flag(...)" construct evaluates to true in + // both mentioned cases: cell XF and set bit; or style XF and cleared bit. + sal_uInt8 nUsedFlags; + ::extract_value( nUsedFlags, nMiscAttrib, 10, 6 ); + + // Remark about using the attributes from the XFs: + // Cell XF flag used (set) -> take from cell XF + // Cell XF flag unused (cleared): + // Parent style XF flag used (cleared) -> take from style XF + // Parent style XF flag unused (set) -> take from cell XF (!) + //! TODO not implemented yet + + // cell border + mbBorderUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_BORDER )); + if( mbCellXF || mbBorderUsed ) //! always in cell XFs until the parent XF is really read + lcl_SetBorder8( maBorder, nBorder1, nBorder2 ); + + // background area + mbAreaUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_AREA )); + if( mbCellXF || mbAreaUsed ) + lcl_SetArea8( maArea, nBorder2, nArea ); + + // font + mbFontUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_FONT )); + if( mbCellXF || mbFontUsed ) mnFont = nReadFont; - // Value format - mbFmtValid = mbCellXF || !::get_flag( nFlags2, EXC_XF_DIFF_VALFMT ); - if( mbFmtValid ) - mnValFormat = GetNumFmtBuffer().GetFormat( nValFmt ); - // Alignment - if( mbCellXF || !::get_flag( nFlags2, EXC_XF_DIFF_ALIGN ) ) + + // number format + mbFmtUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_VALFMT )); + if( mbCellXF || mbFmtUsed ) + mnNumFmt = GetNumFmtBuffer().GetFormat( nReadNumFmt ); + + // alignment + mbAlignUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_ALIGN )); + if( mbCellXF || mbAlignUsed ) { ::extract_value( meHorAlign, nAlign, 0, 3 ); ::extract_value( meVerAlign, nAlign, 4, 3 ); - ::extract_value( meWrap, nAlign, 3, 1 ); - ::extract_value( mnRotation, nAlign, 8, 8 ); // new in BIFF8 - meOrient = (mnRotation == EXC_ROT_STACKED) ? xlTextOrientTopBottom : xlTextOrientRot; - ::extract_value( meTextDir, nFlags2, 6, 2 ); // new in BIFF8X + mbWrapped = ::get_flag( nAlign, EXC_XF_WRAPPED ); + ::extract_value( mnRotation, nAlign, 8, 8 ); // new in BIFF8 + meOrient = (mnRotation == EXC_XF8_STACKED) ? xlTextOrientTopBottom : xlTextOrientRot; + ::extract_value( mnIndent, nMiscAttrib, 0, 4 ); // new in BIFF8 + mnIndent *= 200; + ::extract_value( meTextDir, nMiscAttrib, 6, 2 ); // new in BIFF8X } - // Cell protection - mbProtValid = mbCellXF || !::get_flag( nFlags2, EXC_XF_DIFF_PROT ); - if( mbProtValid ) + + // cell protection + mbProtUsed = (mbCellXF == ::get_flag( nUsedFlags, EXC_XF_DIFF_PROT )); + if( mbCellXF || mbProtUsed ) { - mbLocked = ::get_flag( nFlags1, EXC_XF_LOCKED ); - mbHidden = ::get_flag( nFlags1, EXC_XF_HIDDEN ); + mbLocked = ::get_flag( nTypeProt, EXC_XF_LOCKED ); + mbHidden = ::get_flag( nTypeProt, EXC_XF_HIDDEN ); } - ::extract_value( mnIndent, nFlags2, 0, 4 ); // new in BIFF8 - mnIndent *= 200; } void XclImpXF::ReadXF( XclImpStream& rStrm ) @@ -994,7 +980,7 @@ void XclImpXF::ReadXF( XclImpStream& rStrm ) } } -const ScPatternAttr& XclImpXF::GetPattern() +const ScPatternAttr& XclImpXF::GetPattern() const { if( mpPattern.get() ) return *mpPattern; @@ -1003,87 +989,71 @@ const ScPatternAttr& XclImpXF::GetPattern() mpPattern.reset( new ScPatternAttr( GetDoc().GetPool() ) ); SfxItemSet& rItemSet = mpPattern->GetItemSet(); - // value format - if( mbCellXF || mbFmtValid ) - { - rItemSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, static_cast< sal_uInt32 >( mnValFormat ) ) ); - ScGlobal::AddLanguage( rItemSet, GetFormatter() ); - } + // locked/hidden + if( mbCellXF || mbProtUsed ) + rItemSet.Put( ScProtectionAttr( mbLocked, mbHidden ) ); // font - if( mbCellXF || mbFontValid ) + if( mbCellXF || mbFontUsed ) GetFontBuffer().FillToItemSet( mnFont, rItemSet, xlFontScIDs ); - // locked/hidden - if( mbCellXF || mbProtValid ) - rItemSet.Put( ScProtectionAttr( mbLocked, mbHidden ) ); + // value format + if( mbCellXF || mbFmtUsed ) + { + rItemSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, static_cast< sal_uInt32 >( mnNumFmt ) ) ); + ScGlobal::AddLanguage( rItemSet, GetFormatter() ); + } // border - if( mpBorder.get() ) - SetBorder( rItemSet, GetPalette(), - mpBorder->mnLeftLine, mpBorder->mnLeftColor, - mpBorder->mnRightLine, mpBorder->mnRightColor, - mpBorder->mnTopLine, mpBorder->mnTopColor, - mpBorder->mnBottomLine, mpBorder->mnBottomColor ); + if( mbCellXF || mbBorderUsed ) + SetBorder( rItemSet, GetPalette(), maBorder ); // area - if( mpArea.get() ) - SetArea( rItemSet, GetPalette(), mpArea->mnPattern, mpArea->mnForeColor, mpArea->mnBackColor ); + if( mbCellXF || mbAreaUsed ) + SetArea( rItemSet, GetPalette(), maArea ); - // horizontal alignment - if( mbCellXF || (meHorAlign != xlHAlignParent) ) + // alignment + if( mbCellXF || mbAlignUsed ) { + // horizontal alignment SvxCellHorJustify eHorJust = SVX_HOR_JUSTIFY_STANDARD; switch( meHorAlign ) { - case xlHAlignParent: case xlHAlignGeneral: eHorJust = SVX_HOR_JUSTIFY_STANDARD; break; case xlHAlignLeft: eHorJust = SVX_HOR_JUSTIFY_LEFT; break; case xlHAlignCenterAcrSel: case xlHAlignCenter: eHorJust = SVX_HOR_JUSTIFY_CENTER; break; case xlHAlignRight: eHorJust = SVX_HOR_JUSTIFY_RIGHT; break; case xlHAlignFill: eHorJust = SVX_HOR_JUSTIFY_REPEAT; break; - case xlHAlignJustify: eHorJust = SVX_HOR_JUSTIFY_BLOCK; break; - default: - DBG_ERRORFILE( "XclImpXF::GetPattern - unknown horizontal adjustment" ); + case xlHAlignJustify: + case xlHAlignDistrib: eHorJust = SVX_HOR_JUSTIFY_BLOCK; break; + default: DBG_ERRORFILE( "XclImpXF::GetPattern - unknown horizontal adjustment" ); } rItemSet.Put( SvxHorJustifyItem( eHorJust ) ); - } - // text wrap - if( mbCellXF || (meWrap != xlTextWrapParent) ) - { + // text wrap SfxBoolItem aWrap( ATTR_LINEBREAK ); - aWrap.SetValue( meWrap == xlTextWrapYes ); + aWrap.SetValue( mbWrapped ); rItemSet.Put( aWrap ); - } - // vertical alignment - if( mbCellXF || (meVerAlign != xlVAlignParent) ) - { + // vertical alignment SvxCellVerJustify eVertJust = SVX_VER_JUSTIFY_STANDARD; switch( meVerAlign ) { - case xlVAlignParent: case xlVAlignTop: eVertJust = SVX_VER_JUSTIFY_TOP; break; case xlVAlignCenter: eVertJust = SVX_VER_JUSTIFY_CENTER; break; case xlVAlignBottom: eVertJust = SVX_VER_JUSTIFY_BOTTOM; break; case xlVAlignJustify: case xlVAlignDistrib: eVertJust = SVX_VER_JUSTIFY_TOP; break; - default: - DBG_ERRORFILE( "XclImpXF::GetPattern - unknown vertical adjustment" ); + default: DBG_ERRORFILE( "XclImpXF::GetPattern - unknown vertical adjustment" ); } rItemSet.Put( SvxVerJustifyItem( eVertJust ) ); - } - // indent - if( mnIndent > 0 ) + // indent rItemSet.Put( SfxUInt16Item( ATTR_INDENT, mnIndent ) ); - // text orientation - if( mbCellXF || (meOrient != xlTextOrientParent) ) - { - if( (meOrient == xlTextOrientRot) && (mnRotation != EXC_ROT_STACKED) ) + // text orientation + if( (meOrient == xlTextOrientRot) && (mnRotation != EXC_XF8_STACKED) ) { // set an angle in the range from -90 to 90 degrees DBG_ASSERT( mnRotation <= 180, "XclImpXF::GetPattern - illegal rotation angle" ); @@ -1101,33 +1071,27 @@ const ScPatternAttr& XclImpXF::GetPattern() SvxCellOrientation eSvxOrient = SVX_ORIENTATION_STANDARD; switch( meOrient ) { - case xlTextOrientParent: case xlTextOrientNoRot: eSvxOrient = SVX_ORIENTATION_STANDARD; break; case xlTextOrientRot: - DBG_ASSERT( mnRotation == EXC_ROT_STACKED, + DBG_ASSERT( mnRotation == EXC_XF8_STACKED, "XclImpXF::GetPattern - stacked expected (0xFF)" ); + // run through case xlTextOrientTopBottom: eSvxOrient = SVX_ORIENTATION_STACKED; break; case xlTextOrient90ccw: eSvxOrient = SVX_ORIENTATION_BOTTOMTOP; break; case xlTextOrient90cw: eSvxOrient = SVX_ORIENTATION_TOPBOTTOM; break; - default: - DBG_ERRORFILE( "XclImpXF::GetPattern - unknown text orientation" ); + default: DBG_ERRORFILE( "XclImpXF::GetPattern - unknown text orientation" ); } rItemSet.Put( SvxOrientationItem( eSvxOrient ) ); } - } - // CTL text direction - if( mbCellXF || (meTextDir != xlTextDirParent) ) - { + // CTL text direction SvxFrameDirection eFrameDir = FRMDIR_ENVIRONMENT; switch( meTextDir ) { - case xlTextDirParent: case xlTextDirContext: eFrameDir = FRMDIR_ENVIRONMENT; break; case xlTextDirLTR: eFrameDir = FRMDIR_HORI_LEFT_TOP; break; case xlTextDirRTL: eFrameDir = FRMDIR_HORI_RIGHT_TOP; break; - default: - DBG_ERRORFILE( "XclImpXF::GetPattern - unknown CTL text direction" ); + default: DBG_ERRORFILE( "XclImpXF::GetPattern - unknown CTL text direction" ); } rItemSet.Put( SvxFrameDirectionItem( eFrameDir, ATTR_WRITINGDIR ) ); } @@ -1135,26 +1099,12 @@ const ScPatternAttr& XclImpXF::GetPattern() return *mpPattern; } -XclImpXFBorder& XclImpXF::GetBorder() +SvxBorderLine* XclImpXF::CreateBorderLine( const XclImpPalette& rPalette, sal_uInt8 nXclLine, sal_uInt16 nXclColor ) { - if( !mpBorder.get() ) - mpBorder.reset( new XclImpXFBorder ); - return *mpBorder; -} - -XclImpXFArea& XclImpXF::GetArea() -{ - if( !mpArea.get() ) - mpArea.reset( new XclImpXFArea ); - return *mpArea; -} - -SvxBorderLine* XclImpXF::CreateBorderItem( const XclImpPalette& rPalette, sal_uInt8 nXclLine, sal_uInt16 nXclColor ) -{ - if( !nXclLine ) + if( nXclLine == EXC_LINE_NONE ) return NULL; - static const sal_uInt16 ppLineParam[][ 3 ] = + static const sal_uInt16 ppnLineParam[][ 3 ] = { // outer width, inner width, distance { 0, 0, 0 }, // 0 = none @@ -1173,44 +1123,37 @@ SvxBorderLine* XclImpXF::CreateBorderItem( const XclImpPalette& rPalette, sal_uI { DEF_LINE_WIDTH_2, 0, 0 } // D = med slant dashdot }; - if( nXclLine >= STATIC_TABLE_SIZE( ppLineParam ) ) - nXclLine = 1; + if( nXclLine >= STATIC_TABLE_SIZE( ppnLineParam ) ) + nXclLine = EXC_LINE_THIN; SvxBorderLine* pItem = new SvxBorderLine; pItem->SetColor( rPalette.GetColor( nXclColor, COL_BLACK ) ); - pItem->SetOutWidth( ppLineParam[ nXclLine ][ 0 ] ); - pItem->SetInWidth( ppLineParam[ nXclLine ][ 1 ] ); - pItem->SetDistance( ppLineParam[ nXclLine ][ 2 ] ); + pItem->SetOutWidth( ppnLineParam[ nXclLine ][ 0 ] ); + pItem->SetInWidth( ppnLineParam[ nXclLine ][ 1 ] ); + pItem->SetDistance( ppnLineParam[ nXclLine ][ 2 ] ); return pItem; } -void XclImpXF::SetBorder( - SfxItemSet& rItemSet, const XclImpPalette& rPalette, - sal_uInt8 nXclLeftLine, sal_uInt16 nXclLeftColor, - sal_uInt8 nXclRightLine, sal_uInt16 nXclRightColor, - sal_uInt8 nXclTopLine, sal_uInt16 nXclTopColor, - sal_uInt8 nXclBottomLine, sal_uInt16 nXclBottomColor ) +void XclImpXF::SetBorder( SfxItemSet& rItemSet, const XclImpPalette& rPalette, const XclImpXFBorder& rBorder ) { SvxBoxItem aBox( ATTR_BORDER ); - ::std::auto_ptr< SvxBorderLine > pLineItem; - pLineItem.reset( CreateBorderItem( rPalette, nXclLeftLine, nXclLeftColor ) ); - aBox.SetLine( pLineItem.get(), BOX_LINE_LEFT ); - pLineItem.reset( CreateBorderItem( rPalette, nXclRightLine, nXclRightColor ) ); - aBox.SetLine( pLineItem.get(), BOX_LINE_RIGHT ); - pLineItem.reset( CreateBorderItem( rPalette, nXclTopLine, nXclTopColor ) ); - aBox.SetLine( pLineItem.get(), BOX_LINE_TOP ); - pLineItem.reset( CreateBorderItem( rPalette, nXclBottomLine, nXclBottomColor ) ); - aBox.SetLine( pLineItem.get(), BOX_LINE_BOTTOM ); + ::std::auto_ptr< SvxBorderLine > pLine; + pLine.reset( CreateBorderLine( rPalette, rBorder.mnLeftLine, rBorder.mnLeftColor ) ); + aBox.SetLine( pLine.get(), BOX_LINE_LEFT ); + pLine.reset( CreateBorderLine( rPalette, rBorder.mnRightLine, rBorder.mnRightColor ) ); + aBox.SetLine( pLine.get(), BOX_LINE_RIGHT ); + pLine.reset( CreateBorderLine( rPalette, rBorder.mnTopLine, rBorder.mnTopColor ) ); + aBox.SetLine( pLine.get(), BOX_LINE_TOP ); + pLine.reset( CreateBorderLine( rPalette, rBorder.mnBottomLine, rBorder.mnBottomColor ) ); + aBox.SetLine( pLine.get(), BOX_LINE_BOTTOM ); rItemSet.Put( aBox ); } -void XclImpXF::SetArea( - SfxItemSet& rItemSet, const XclImpPalette& rPalette, - sal_uInt8 nXclPattern, sal_uInt16 nXclForeColor, sal_uInt16 nXclBackColor ) +void XclImpXF::SetArea( SfxItemSet& rItemSet, const XclImpPalette& rPalette, const XclImpXFArea& rArea ) { - static const sal_uInt16 pRatioTable[] = + static const sal_uInt16 pnRatioTable[] = { // 0x8000 = 100% 0x8000, 0x0000, 0x4000, 0x2000, // 00 - 03 0x6000, 0x4000, 0x4000, 0x4000, // 04 - 07 @@ -1220,23 +1163,20 @@ void XclImpXF::SetArea( }; // no background -> set nothing! - if( nXclPattern != EXC_PATT_NONE ) + if( rArea.mnPattern != EXC_PATT_NONE ) { - Color aFore( rPalette.GetColor( nXclForeColor, COL_WHITE ) ); - if( nXclForeColor == 64 ) + Color aFore( rPalette.GetColor( rArea.mnForeColor, COL_WHITE ) ); + if( rArea.mnForeColor == 64 ) aFore.SetColor( COL_BLACK ); - Color aBack( rPalette.GetColor( nXclBackColor, COL_WHITE ) ); - if( nXclBackColor == 64 ) + Color aBack( rPalette.GetColor( rArea.mnBackColor, COL_WHITE ) ); + if( rArea.mnBackColor == 64 ) aBack.SetColor( COL_BLACK ); - if( nXclPattern < STATIC_TABLE_SIZE( pRatioTable ) ) - { - sal_uInt16 nRatio = pRatioTable[ nXclPattern ]; - rItemSet.Put( SvxBrushItem( ScfTools::GetMixedColor( aFore, aBack, nRatio ) ) ); - } - else - rItemSet.Put( SvxBrushItem( aFore ) ); + if( rArea.mnPattern < STATIC_TABLE_SIZE( pnRatioTable ) ) + aFore = ScfTools::GetMixedColor( aFore, aBack, pnRatioTable[ rArea.mnPattern ] ); + + rItemSet.Put( SvxBrushItem( aFore ) ); } } @@ -1251,7 +1191,7 @@ XclImpXFBuffer::XclImpXFBuffer( const XclImpRoot& rRoot ) : void XclImpXFBuffer::ReadXF( XclImpStream& rStrm ) { - XclImpXF* pXF = new XclImpXF( *this ); + XclImpXF* pXF = new XclImpXF( GetRoot() ); pXF->ReadXF( rStrm ); maXFList.Append( pXF ); } @@ -1285,7 +1225,7 @@ void XclImpXFBuffer::ReadStyle( XclImpStream& rStrm ) } } -const ScPatternAttr& XclImpXFBuffer::GetPattern( sal_uInt32 nXFIndex ) +const ScPatternAttr& XclImpXFBuffer::GetPattern( sal_uInt32 nXFIndex ) const { XclImpXF* pXF = maXFList.GetObject( nXFIndex ); DBG_ASSERT( pXF || (GetBiff() == xlBiff2), "XclImpXFBuffer::GetPattern - XF not found" ); diff --git a/sc/source/filter/excel/xlocx.cxx b/sc/source/filter/excel/xlocx.cxx new file mode 100644 index 000000000000..77155a00028b --- /dev/null +++ b/sc/source/filter/excel/xlocx.cxx @@ -0,0 +1,286 @@ +/************************************************************************* + * + * $RCSfile: xlocx.cxx,v $ + * + * $Revision: 1.2 $ + * + * last change: $Author: hr $ $Date: 2003-03-26 18:04:37 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifdef PCH +#include "filt_pch.hxx" +#endif +#pragma hdrstop + +// ============================================================================ + +#ifndef SC_XLOCX_HXX +#include "xlocx.hxx" +#endif + +#ifndef _COM_SUN_STAR_LANG_XCOMPONENT_HPP_ +#include <com/sun/star/lang/XComponent.hpp> +#endif +#ifndef _COM_SUN_STAR_LANG_XMULTISERVICEFACTORY_HPP_ +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#endif +#ifndef _COM_SUN_STAR_CONTAINER_XINDEXCONTAINER_HPP_ +#include <com/sun/star/container/XIndexContainer.hpp> +#endif +#ifndef _COM_SUN_STAR_DRAWING_XDRAWPAGE_HPP_ +#include <com/sun/star/drawing/XDrawPage.hpp> +#endif +#ifndef _COM_SUN_STAR_DRAWING_XCONTROLSHAPE_HPP_ +#include <com/sun/star/drawing/XControlShape.hpp> +#endif +#ifndef _COM_SUN_STAR_FORM_XFORMCOMPONENT_HPP_ +#include <com/sun/star/form/XFormComponent.hpp> +#endif + +#ifndef _SVDPAGE_HXX +#include <svx/svdpage.hxx> +#endif +#ifndef _SVX_UNOAPI_HXX_ +#include <svx/unoapi.hxx> +#endif + +#ifndef SC_DOCUMENT_HXX +#include "document.hxx" +#endif +#ifndef SC_DRWLAYER_HXX +#include "drwlayer.hxx" +#endif + +#include "XclImpObjects.hxx" +#include "xcl97rec.hxx" + + +using ::com::sun::star::uno::Reference; +using ::com::sun::star::uno::Any; +using ::com::sun::star::uno::XInterface; +using ::com::sun::star::uno::UNO_QUERY; +using ::com::sun::star::container::XIndexContainer; +using ::com::sun::star::lang::XMultiServiceFactory; +using ::com::sun::star::awt::XControlModel; +using ::com::sun::star::form::XFormComponent; +using ::com::sun::star::drawing::XDrawPage; +using ::com::sun::star::drawing::XShape; +using ::com::sun::star::drawing::XControlShape; + + +#define EXC_STREAMNAME_CTLS String( RTL_CONSTASCII_USTRINGPARAM( "Ctls" ) ) + + +// OCX controls =============================================================== + +XclOcxConverter::XclOcxConverter( const XclRoot& rRoot ) : + SvxMSConvertOCXControls( rRoot.GetDocShell(), NULL ), + XclRoot( rRoot ), + mnCurrTab( 0 ), + mnCachedTab( 0 ) +{ +} + +XclOcxConverter::~XclOcxConverter() +{ +} + +void XclOcxConverter::SetCurrTab( sal_uInt16 nTab ) +{ + mnCurrTab = nTab; +} + +const Reference< XDrawPage >& XclOcxConverter::GetDrawPage() +{ + // find and cache draw page if uninitialized or sheet index has been changed + if( !xDrawPage.is() || (mnCachedTab != mnCurrTab) ) + { + if( ScDrawLayer* pDrawLayer = GetDoc().GetDrawLayer() ) + { + // mnCurrTab set in ReadControl() contains sheet index of current control + if( SdrPage* pPage = pDrawLayer->GetPage( mnCurrTab ) ) + { + xDrawPage = Reference< XDrawPage >( pPage->getUnoPage(), UNO_QUERY ); + mnCachedTab = mnCurrTab; + } + } + } + + return xDrawPage; +} + + +// ---------------------------------------------------------------------------- + +XclImpOcxConverter::XclImpOcxConverter( const XclRoot& rRoot ) : + XclOcxConverter( rRoot ) +{ + mxStrm = ScfTools::OpenStorageStreamRead( GetRootStorage(), EXC_STREAMNAME_CTLS ); +} + +void XclImpOcxConverter::ReadControl( XclImpEscherOle& rObj ) +{ + DBG_ASSERT( rObj.GetObjType() == otCtrl, "XclOcxConverter::ReadControl - no control object" ); + if( mxStrm.Is() && (rObj.GetObjType() == otCtrl) ) + { + // virtual call of GetDrawPage() needs current sheet index + SetCurrTab( rObj.GetTab() ); + + // stream position of the extra data for this control + sal_uInt32 nStrmPos = rObj.GetCtrlStreamPos(); + mxStrm->Seek( nStrmPos ); + + // the shape to fill + Reference< XShape > xShape = ::GetXShapeForSdrObject( const_cast< SdrObject* >( rObj.GetSdrObj() ) ); + + // reads from mxStrm into xShape, inserts the control into the document + if( ReadOCXExcelKludgeStream( mxStrm, &xShape, TRUE ) ) + { + if( SdrObject* pSdrObj = ::GetSdrObjectFromXShape( xShape ) ) + rObj.SetSdrObj( pSdrObj ); + } + } +} + +sal_Bool XclImpOcxConverter::InsertControl( + const Reference< XFormComponent >& rxFormComp, + const ::com::sun::star::awt::Size& rSize, + Reference< XShape >* pxShape, + BOOL bFloatingCtrl ) +{ + sal_Bool bRet = sal_False; + XShapeRef xShape; + + const Reference< XIndexContainer >& rxFormCompsIC = GetFormComps(); + const Reference< XMultiServiceFactory >& rxServiceFactory = GetServiceFactory(); + if( rxFormCompsIC.is() && rxServiceFactory.is() ) + { + Any aFormCompAny; + aFormCompAny <<= rxFormComp; + rxFormCompsIC->insertByIndex( rxFormCompsIC->getCount(), aFormCompAny ); + + // create the control shape + Reference< XInterface > xCreate = rxServiceFactory->createInstance( + String( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.ControlShape" ) ) ); + xShape = Reference< XShape >( xCreate, UNO_QUERY ); + if( xShape.is() ) + { + xShape->setSize( rSize ); + // set control model at the shape + Reference< XControlShape > xControlShape( xShape, UNO_QUERY ); + Reference< XControlModel > xControlModel( rxFormComp, UNO_QUERY ); + if( xControlShape.is() && xControlModel.is() ) + { + xControlShape->setControl( xControlModel ); + if( pxShape ) + *pxShape = xShape; + bRet = sal_True; + } + } + } + + return bRet; +} + + +// ---------------------------------------------------------------------------- + +#if EXC_INCL_EXP_OCX + +XclExpOcxConverter::XclExpOcxConverter( const XclRoot& rRoot ) : + XclOcxConverter( rRoot ) +{ +} + +XclExpObjControl* XclExpOcxConverter::CreateObjRec( const Reference< XShape >& rxShape ) +{ + XclExpObjControl* pObjRec = NULL; + + // the shape to export + const SdrObject* pSdrObj = ::GetSdrObjectFromXShape( rxShape ); + Reference< XControlShape > xControlShape( rxShape, UNO_QUERY ); + + if( pSdrObj && xControlShape.is() ) + { + // the control model + Reference< XControlModel > xControlModel = xControlShape->getControl(); + if( xControlModel.is() ) + { + // output stream + if( !mxStrm.Is() ) + mxStrm = ScfTools::OpenStorageStreamWrite( GetRootStorage(), EXC_STREAMNAME_CTLS ); + if( mxStrm.Is() ) + { + String aClassName; + sal_uInt32 nStrmStart = mxStrm->Tell(); + + // writes from xControlModel into mxStrm, raw class name returned in aClassName + if( WriteOCXExcelKludgeStream( mxStrm, xControlModel, rxShape->getSize(), aClassName ) ) + { + sal_uInt32 nStrmSize = mxStrm->Tell() - nStrmStart; + // adjust the class name to "Forms.***.1" + aClassName.InsertAscii( "Forms.", 0 ).AppendAscii( ".1" ); + pObjRec = new XclExpObjControl( *this, rxShape, aClassName, nStrmStart, nStrmSize ); + } + } + } + } + return pObjRec; +} + +#endif + +// ============================================================================ + diff --git a/sc/source/filter/excel/xlroot.cxx b/sc/source/filter/excel/xlroot.cxx index 3a3a998c3bf8..fcf67866f763 100644 --- a/sc/source/filter/excel/xlroot.cxx +++ b/sc/source/filter/excel/xlroot.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xlroot.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:12:53 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:38 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -111,14 +111,21 @@ XclRootData::XclRootData( XclBiff eBiff, ScDocument& rDocument, const String& rB meLang( ScGlobal::eLnge ), maScMaxPos( MAXCOL, MAXROW, MAXTAB ), maXclMaxPos( EXC_MAXCOL_BIFF2, EXC_MAXROW_BIFF2, EXC_MAXTAB_BIFF2 ), + mnCharWidth( 110 ), mnScTab( 0 ), mbTruncated( false ), mpRDP( new RootData )//! { +#ifdef DBG_UTIL + mnObjCnt = 0; +#endif } XclRootData::~XclRootData() { +#ifdef DBG_UTIL + DBG_ASSERT( mnObjCnt == 0, "XclRootData::~XclRootData - wrong object count" ); +#endif } @@ -128,20 +135,30 @@ XclRoot::XclRoot( XclRootData& rRootData ) : mrData( rRootData ), mpRD( rRootData.mpRDP.get() )//! { +#ifdef DBG_UTIL + ++mrData.mnObjCnt; +#endif } XclRoot::XclRoot( const XclRoot& rRoot ) : mrData( rRoot.mrData ), mpRD( rRoot.mpRD )//! { +#ifdef DBG_UTIL + ++mrData.mnObjCnt; +#endif } XclRoot::~XclRoot() { +#ifdef DBG_UTIL + --mrData.mnObjCnt; +#endif } XclRoot& XclRoot::operator=( const XclRoot& rRoot ) { + // allowed for assignment in derived classes - but test if the same root data is used DBG_ASSERT( &mrData == &rRoot.mrData, "XclRoot::operator= - incompatible root data" ); return *this; } @@ -187,6 +204,11 @@ ScRangeName& XclRoot::GetNamedRanges() const return *GetDoc().GetRangeName(); } +SvStorage* XclRoot::GetRootStorage() const +{ + return mpRD->pRootStorage; +} + ScEditEngineDefaulter& XclRoot::GetEditEngine() const { if( !mrData.mpEditEngine.get() ) diff --git a/sc/source/filter/excel/xlstyle.cxx b/sc/source/filter/excel/xlstyle.cxx index 150f52a5461d..ab1a70419d0c 100644 --- a/sc/source/filter/excel/xlstyle.cxx +++ b/sc/source/filter/excel/xlstyle.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xlstyle.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: dr $ $Date: 2002-11-21 12:12:53 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:38 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -116,10 +116,10 @@ XclDefaultPalette::XclDefaultPalette( XclBiff eBiff ) : mnIndexOffset( 0 ) { if( eBiff != xlBiffUnknown ) - SetBiff( eBiff ); + SetDefaultColors( eBiff ); } -void XclDefaultPalette::SetBiff( XclBiff eBiff ) +void XclDefaultPalette::SetDefaultColors( XclBiff eBiff ) { switch( eBiff ) { diff --git a/sc/source/filter/excel/xltools.cxx b/sc/source/filter/excel/xltools.cxx index 127c56376228..6183b5376e83 100644 --- a/sc/source/filter/excel/xltools.cxx +++ b/sc/source/filter/excel/xltools.cxx @@ -2,9 +2,9 @@ * * $RCSfile: xltools.cxx,v $ * - * $Revision: 1.2 $ + * $Revision: 1.3 $ * - * last change: $Author: dr $ $Date: 2002-12-06 16:39:27 $ + * last change: $Author: hr $ $Date: 2003-03-26 18:04:38 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -82,10 +82,6 @@ #include <svx/editstat.hxx> #endif -#ifndef _COM_SUN_STAR_UNO_REFERENCE_HXX_ -#include <com/sun/star/uno/Reference.hxx> -#endif - #ifndef SC_DOCUMENT_HXX #include "document.hxx" #endif @@ -110,13 +106,6 @@ #endif -namespace com { namespace sun { namespace star { namespace frame { class XModel; } } } } - - -using ::com::sun::star::uno::Reference; -using ::com::sun::star::frame::XModel; - - // GUID import/export ========================================================= XclGuid::XclGuid() @@ -124,16 +113,12 @@ XclGuid::XclGuid() memset( mpData, 0, 16 ); } -XclGuid::XclGuid( const XclGuid& rSrc ) -{ - operator=( rSrc ); -} - XclGuid::XclGuid( sal_uInt32 nData1, sal_uInt16 nData2, sal_uInt16 nData3, sal_uInt8 nData41, sal_uInt8 nData42, sal_uInt8 nData43, sal_uInt8 nData44, sal_uInt8 nData45, sal_uInt8 nData46, sal_uInt8 nData47, sal_uInt8 nData48 ) { + // convert to little endian -> makes streaming easy LongToSVBT32( nData1, mpData ); ShortToSVBT16( nData2, mpData + 4 ); ShortToSVBT16( nData3, mpData + 6 ); @@ -147,12 +132,6 @@ XclGuid::XclGuid( mpData[ 15 ] = nData48; } -XclGuid& XclGuid::operator=( const XclGuid& rSrc ) -{ - memcpy( mpData, rSrc.mpData, 16 ); - return *this; -} - bool operator==( const XclGuid& rCmp1, const XclGuid& rCmp2 ) { return memcmp( rCmp1.mpData, rCmp2.mpData, 16 ) == 0; @@ -160,13 +139,13 @@ bool operator==( const XclGuid& rCmp1, const XclGuid& rCmp2 ) XclImpStream& operator>>( XclImpStream& rStrm, XclGuid& rGuid ) { - rStrm.Read( rGuid.mpData, 16 ); + rStrm.Read( rGuid.mpData, 16 ); // mpData always in little endian return rStrm; } XclExpStream& operator<<( XclExpStream& rStrm, const XclGuid& rGuid ) { - rStrm.Write( rGuid.mpData, 16 ); + rStrm.Write( rGuid.mpData, 16 ); // mpData already in little endian return rStrm; } @@ -238,24 +217,24 @@ bool XclTools::GetRKFromDouble( sal_Int32& rnRKValue, double fValue ) } -sal_Int32 XclTools::GetScRotation( sal_uInt16 nExcRot ) +sal_Int32 XclTools::GetScRotation( sal_uInt16 nXclRot ) { - if( nExcRot > 180 ) + if( nXclRot > 180 ) return 27000; - return static_cast< sal_Int32 >( 100 * ((nExcRot > 90) ? 450 - nExcRot : nExcRot) ); + return static_cast< sal_Int32 >( 100 * ((nXclRot > 90) ? 450 - nXclRot : nXclRot) ); } -sal_uInt16 XclTools::GetExcRotation( sal_Int32 nScRot ) +sal_uInt8 XclTools::GetXclRotation( sal_Int32 nScRot ) { - sal_Int32 nExcRot = nScRot / 100; - if( (0 <= nExcRot) && (nExcRot <= 90) ) - return static_cast< sal_uInt16 >( nExcRot ); - if( nExcRot < 180 ) - return static_cast< sal_uInt16 >( 270 - nExcRot ); - if( nExcRot < 270 ) - return static_cast< sal_uInt16 >( nExcRot - 180 ); - if( nExcRot < 360 ) - return static_cast< sal_uInt16 >( 450 - nExcRot ); + sal_Int32 nXclRot = nScRot / 100; + if( (0 <= nXclRot) && (nXclRot <= 90) ) + return static_cast< sal_uInt8 >( nXclRot ); + if( nXclRot < 180 ) + return static_cast< sal_uInt8 >( 270 - nXclRot ); + if( nXclRot < 270 ) + return static_cast< sal_uInt8 >( nXclRot - 180 ); + if( nXclRot < 360 ) + return static_cast< sal_uInt8 >( 450 - nXclRot ); return 0; } @@ -316,6 +295,19 @@ double XclTools::GetInchFromTwips( sal_uInt16 nTwips ) } +sal_uInt16 XclTools::GetScColumnWidth( sal_uInt16 nXclWidth, long nScCharWidth ) +{ + double fScWidth = static_cast< double >( nXclWidth ) / 256.0 * nScCharWidth + 0.5; + return static_cast< sal_uInt16 >( ::std::min( fScWidth, 65535.0 ) ); +} + +sal_uInt16 XclTools::GetXclColumnWidth( sal_uInt16 nScWidth, long nScCharWidth ) +{ + double fXclWidth = static_cast< double >( nScWidth ) * 256.0 / nScCharWidth + 0.5; + return static_cast< sal_uInt16 >( ::std::min( fXclWidth, 65535.0 ) ); +} + + // built-in names ------------------------------------------------------------- static const sal_Char* ppNames[] = @@ -422,7 +414,7 @@ bool XclTools::GetScLanguage( LanguageType& reScLang, sal_uInt16 nXclCountry ) { const XclLanguageEntry* pLast = pLanguages + STATIC_TABLE_SIZE( pLanguages ); const XclLanguageEntry* pResult = ::std::lower_bound( pLanguages, pLast, nXclCountry, XclLanguageEntrySWO() ); - if( pResult != pLast ) + if( (pResult != pLast) && (pResult->mnXclCountry == nXclCountry) ) { reScLang = pResult->meLanguage; return true; |