xref: /aoo41x/main/sc/source/filter/lotus/op.cxx (revision 3ee7c2db)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



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

//------------------------------------------------------------------------

#include <tools/solar.h>
#include <rtl/math.hxx>

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <stdlib.h>

#include "scitems.hxx"
#include "patattr.hxx"
#include "docpool.hxx"
#include <svx/algitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/wghtitem.hxx>

#include "cell.hxx"
#include "rangenam.hxx"
#include "document.hxx"
#include "postit.hxx"

#include "op.h"
#include "optab.h"
#include "tool.h"
#include "decl.h"
#include "lotform.hxx"
#include "lotrange.hxx"

#include "root.hxx"

#include "ftools.hxx"

#include <vector>
#include <map>

extern WKTYP		eTyp;			// -> filter.cxx, aktueller Dateityp
extern sal_Bool			bEOF;			// -> filter.cxx, zeigt Dateiende an
extern sal_uInt8			nDefaultFormat;	// -> tool.cxx, Default-Zellenformat
extern ScDocument*	pDoc;			// -> filter.cxx, Aufhaenger zum Dokumentzugriff
extern CharSet		eCharVon;       // -> filter.cxx, character set specified

static sal_uInt16		nDefWidth = ( sal_uInt16 ) ( TWIPS_PER_CHAR * 10 );

extern std::map<sal_uInt16, ScPatternAttr> aLotusPatternPool;

void NI( SvStream& r, sal_uInt16 n )
{
	r.SeekRel( n );
}


void OP_BOF( SvStream& r, sal_uInt16 /*n*/ )
{
	r.SeekRel( 2 );        // Versionsnummer ueberlesen
}


void OP_EOF( SvStream& /*r*/, sal_uInt16 /*n*/ )
{
	bEOF = sal_True;
}


void OP_Integer( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt8			nFormat;
	sal_uInt16			nCol, nRow;
	SCTAB			nTab = 0;
	sal_Int16			nValue;

	r >> nFormat >> nCol >> nRow >> nValue;

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow))
    {
        ScValueCell*	pZelle = new ScValueCell( ( double ) nValue );
        pDoc->PutCell( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, pZelle, ( sal_Bool ) sal_True );

        // 0 Stellen nach'm Komma!
        SetFormat( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, nFormat, 0 );
    }
}


void OP_Number( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt8			nFormat;
	sal_uInt16			nCol, nRow;
	SCTAB			nTab = 0;
	double			fValue;

	r >> nFormat >> nCol >> nRow >> fValue;

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow))
    {
        fValue = ::rtl::math::round( fValue, 15 );
        ScValueCell*	pZelle = new ScValueCell( fValue );
        pDoc->PutCell( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, pZelle, ( sal_Bool ) sal_True );

        SetFormat( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, nFormat, nDezFloat );
    }
}


void OP_Label( SvStream& r, sal_uInt16 n )
{
	sal_uInt8			nFormat;
	sal_uInt16			nCol, nRow;
	SCTAB			nTab = 0;

	r >> nFormat >> nCol >> nRow;

    n -= (n > 5) ? 5 : n;

    sal_Char* pText = new sal_Char[n + 1];
    r.Read( pText, n );
    pText[n] = 0;

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow))
    {
        nFormat &= 0x80;    // Bit 7 belassen
        nFormat |= 0x75;    // protected egal, special-text gesetzt

        PutFormString( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, pText );

        SetFormat( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, nFormat, nDezStd );
    }

    delete [] pText;
}


void OP_Formula( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt8				nFormat;
	sal_uInt16				nCol, nRow, nFormulaSize;
	SCTAB			        nTab = 0;

	r >> nFormat >> nCol >> nRow;
	r.SeekRel( 8 );    // Ergebnis ueberspringen
	r >> nFormulaSize;

	const ScTokenArray*	pErg;
	sal_Int32				nBytesLeft = nFormulaSize;
	ScAddress			aAddress( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab );

	LotusToSc			aConv( r, pLotusRoot->eCharsetQ, sal_False );
	aConv.Reset( aAddress );
	aConv.Convert( pErg, nBytesLeft );

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow))
    {
        ScFormulaCell*		pZelle = new ScFormulaCell( pLotusRoot->pDoc, aAddress, pErg );

        pZelle->AddRecalcMode( RECALCMODE_ONLOAD_ONCE );

        pDoc->PutCell( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, pZelle, ( sal_Bool ) sal_True );

        // nFormat = Standard -> Nachkommastellen wie Float
        SetFormat( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), nTab, nFormat, nDezFloat );
    }
}


void OP_ColumnWidth( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt16				nCol, nBreite;
	sal_uInt8				nWidthSpaces;
	SCTAB			        nTab = 0;

	r >> nCol >> nWidthSpaces;

    if (ValidCol( static_cast<SCCOL>(nCol)))
    {
        if( nWidthSpaces )
            // Annahme: 10cpi-Zeichensatz
            nBreite = ( sal_uInt16 ) ( TWIPS_PER_CHAR * nWidthSpaces );
        else
        {
            pDoc->SetColHidden(static_cast<SCCOL>(nCol), static_cast<SCCOL>(nCol), 0, true);
            nBreite = nDefWidth;
        }

        pDoc->SetColWidth( static_cast<SCCOL> (nCol), nTab, nBreite );
    }
}


void OP_NamedRange( SvStream& r, sal_uInt16 /*n*/ )
	{
	// POST:    waren Koordinaten ungueltig, wird nicht gespeichert
	sal_uInt16				nColSt, nRowSt, nColEnd, nRowEnd;

    sal_Char cPuffer[ 16+1 ];
	r.Read( cPuffer, 16 );
	cPuffer[ 16 ] = 0;

	r >> nColSt >> nRowSt >> nColEnd >> nRowEnd;

    if (ValidColRow( static_cast<SCCOL>(nColSt), nRowSt) && ValidColRow( static_cast<SCCOL>(nColEnd), nRowEnd))
    {
        LotusRange*			pRange;

        if( nColSt == nColEnd && nRowSt == nRowEnd )
            pRange = new LotusRange( static_cast<SCCOL> (nColSt), static_cast<SCROW> (nRowSt) );
        else
            pRange = new LotusRange( static_cast<SCCOL> (nColSt), static_cast<SCROW> (nRowSt),
                    static_cast<SCCOL> (nColEnd), static_cast<SCROW> (nRowEnd) );

        sal_Char cBuf[sizeof(cPuffer)+1];
        if( isdigit( *cPuffer ) )
        {	// erstes Zeichen im Namen eine Zahl -> 'A' vor Namen setzen
            cBuf[0] = 'A';
            strcpy( cBuf + 1, cPuffer );       // #100211# - checked
        }
        else
            strcpy( cBuf, cPuffer );           // #100211# - checked

        String				aTmp( cBuf, pLotusRoot->eCharsetQ );

        ScfTools::ConvertToScDefinedName( aTmp );

        pLotusRoot->pRangeNames->Append( pRange, aTmp );
    }
}


void OP_SymphNamedRange( SvStream& r, sal_uInt16 /*n*/ )
{
	// POST:    waren Koordinaten ungueltig, wird nicht gespeichert
	sal_uInt16				nColSt, nRowSt, nColEnd, nRowEnd;
	sal_uInt8				nType;

    sal_Char cPuffer[ 16+1 ];
	r.Read( cPuffer, 16 );
	cPuffer[ 16 ] = 0;

	r >> nColSt >> nRowSt >> nColEnd >> nRowEnd >> nType;

    if (ValidColRow( static_cast<SCCOL>(nColSt), nRowSt) && ValidColRow( static_cast<SCCOL>(nColEnd), nRowEnd))
    {
        LotusRange*			pRange;

        if( nType )
            pRange = new LotusRange( static_cast<SCCOL> (nColSt), static_cast<SCROW> (nRowSt) );
        else
            pRange = new LotusRange( static_cast<SCCOL> (nColSt), static_cast<SCROW> (nRowSt),
                    static_cast<SCCOL> (nColEnd), static_cast<SCROW> (nRowEnd) );

        sal_Char cBuf[sizeof(cPuffer)+1];
        if( isdigit( *cPuffer ) )
        {	// erstes Zeichen im Namen eine Zahl -> 'A' vor Namen setzen
            cBuf[0] = 'A';
            strcpy( cBuf + 1, cPuffer );       // #100211# - checked
        }
        else
            strcpy( cBuf, cPuffer );           // #100211# - checked

        String		aTmp( cBuf, pLotusRoot->eCharsetQ );
        ScfTools::ConvertToScDefinedName( aTmp );

        pLotusRoot->pRangeNames->Append( pRange, aTmp );
    }
}


void OP_Footer( SvStream& r, sal_uInt16 n )
{
	r.SeekRel( n );
}


void OP_Header( SvStream& r, sal_uInt16 n )
{
	r.SeekRel( n );
}


void OP_Margins( SvStream& r, sal_uInt16 n )
{
	r.SeekRel( n );
}


void OP_HiddenCols( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt16		nByte, nBit;
	SCCOL		nCount;
	sal_uInt8		nAkt;
	nCount = 0;

	for( nByte = 0 ; nByte < 32 ; nByte++ ) // 32 Bytes mit ...
	{
		r >> nAkt;
		for( nBit = 0 ; nBit < 8 ; nBit++ ) // ...jeweils 8 Bits = 256 Bits
		{
			if( nAkt & 0x01 )   // unterstes Bit gesetzt?
				// -> Hidden Col
                pDoc->SetColHidden(nCount, nCount, 0, true);

			nCount++;
            nAkt = nAkt / 2;    // der Naechste bitte...
		}
	}
}


void OP_Window1( SvStream& r, sal_uInt16 n )
{
	r.SeekRel( 4 );    // Cursor Pos ueberspringen

	r >> nDefaultFormat;

	r.SeekRel( 1 );    // 'unused' ueberspringen

	r >> nDefWidth;

	r.SeekRel( n - 8 );  // und den Rest ueberspringen

	nDefWidth = ( sal_uInt16 ) ( TWIPS_PER_CHAR * nDefWidth );

	// statt Defaulteinstellung in SC alle Cols zu Fuss setzen
	for( SCCOL nCol = 0 ; nCol <= MAXCOL ; nCol++ )
		pDoc->SetColWidth( nCol, 0, nDefWidth );
}


void OP_Blank( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt16		nCol, nRow;
	sal_uInt8		nFormat;
	r >> nFormat >> nCol >> nRow;

	SetFormat( static_cast<SCCOL> (nCol), static_cast<SCROW> (nRow), 0, nFormat, nDezFloat );
}

void OP_BOF123( SvStream& r, sal_uInt16 /*n*/ )
{
	r.SeekRel( 26 );
}


void OP_EOF123( SvStream& /*r*/, sal_uInt16 /*n*/ )
{
	bEOF = sal_True;
}

void OP_Label123( SvStream& r, sal_uInt16 n )
{
	sal_uInt8      nTab, nCol;
	sal_uInt16    nRow;
	r >> nRow >> nTab >> nCol;
    n -= (n > 4) ? 4 : n;

	sal_Char* pText = new sal_Char[n + 1];
	r.Read( pText, n );
	pText[ n ] = 0;

	PutFormString( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), static_cast<SCTAB>(nTab), pText );

	delete []pText;
}

void OP_Number123( SvStream& r, sal_uInt16 /*n*/ )
{
	sal_uInt8    nCol,nTab;
	sal_uInt16  nRow;
	sal_uInt32   nValue;

	r >> nRow >> nTab >> nCol >> nValue;

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow) && nTab < pDoc->GetMaxTableNumber())
    {
        double fValue = Snum32ToDouble( nValue );

        ScValueCell *pCell = new ScValueCell( fValue );
        pDoc->PutCell( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), static_cast<SCTAB>(nTab), pCell, (sal_Bool) sal_True );
    }
}

void OP_Formula123( SvStream& r, sal_uInt16 n )
{
    sal_uInt8 nCol,nTab;
    sal_uInt16 nRow;

    r >> nRow >> nTab >> nCol;
    r.SeekRel( 8 );    // Result- jump over

    const ScTokenArray*	pErg;
    sal_Int32				nBytesLeft = (n > 12) ? n - 12 : 0;
    ScAddress			aAddress( nCol, nRow, nTab );

    LotusToSc			aConv( r, pLotusRoot->eCharsetQ, sal_True );
    aConv.Reset( aAddress );
    aConv.Convert( pErg, nBytesLeft );

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow) && nTab < pDoc->GetMaxTableNumber())
    {
        ScFormulaCell*		pCell = new ScFormulaCell( pLotusRoot->pDoc, aAddress, pErg );

        pCell->AddRecalcMode( RECALCMODE_ONLOAD_ONCE );

        pDoc->PutCell( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), static_cast<SCTAB>(nTab), pCell, (sal_Bool) sal_True );
    }
}

void OP_IEEENumber123( SvStream& r, sal_uInt16 /*n*/ )
{
    sal_uInt8 nCol,nTab;
    sal_uInt16 nRow;
    double dValue;

    r >> nRow >> nTab >> nCol >> dValue;

    if (ValidColRow( static_cast<SCCOL>(nCol), nRow) && nTab < pDoc->GetMaxTableNumber())
    {
        ScValueCell *pCell = new ScValueCell(dValue);
        pDoc->PutCell( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), static_cast<SCTAB>(nTab), pCell, (sal_Bool) sal_True );
    }
}

void OP_Note123( SvStream& r, sal_uInt16 n)
{
    sal_uInt8      nTab, nCol;
    sal_uInt16    nRow;
    r >> nRow >> nTab >> nCol;
    n -= (n > 4) ? 4 : n;

    sal_Char* pText = new sal_Char[n + 1];
    r.Read( pText, n );
    pText[ n ] = 0;

    String aNoteText(pText,pLotusRoot->eCharsetQ);
    delete [] pText;

    ScAddress aPos( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), static_cast<SCTAB>(nTab) );
    ScNoteUtil::CreateNoteFromString( *pDoc, aPos, aNoteText, false, false );
}

void OP_HorAlign123( sal_uInt8 nAlignPattern, SfxItemSet& rPatternItemSet )
{
//      pre:  Pattern is stored in the last 3 bites of the 21st byte
//      post: Appropriate Horizontal Alignement is set in rPattern according to the bit pattern.
//
//      LEFT:001, RIGHT:010, CENTER:011, JUSTIFY:110,
//      LEFT-Text/RIGHT-NUMBER:100, DEFAULT:000

	nAlignPattern = ( nAlignPattern & 0x07);

	switch (nAlignPattern)
 	{
		case 1:
            rPatternItemSet.Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_LEFT, ATTR_HOR_JUSTIFY ) );
			break;
	  	case 2:
            rPatternItemSet.Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_RIGHT, ATTR_HOR_JUSTIFY ) );
            break;
		case 3:
            rPatternItemSet.Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_CENTER, ATTR_HOR_JUSTIFY) );
            break;
  		case 4:
            rPatternItemSet.Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_STANDARD, ATTR_HOR_JUSTIFY ) );
            break;
		case 6:
            rPatternItemSet.Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_BLOCK, ATTR_HOR_JUSTIFY ) );
            break;
  		default:
            rPatternItemSet.Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_STANDARD, ATTR_HOR_JUSTIFY ) );
            break;
  	}
}

void OP_VerAlign123( sal_uInt8 nAlignPattern,SfxItemSet& rPatternItemSet  )
{
//      pre:  Pattern is stored in the last 3 bites of the 22nd byte
//      post: Appropriate Verticle Alignement is set in rPattern according to the bit pattern.
//
//      TOP:001, MIDDLE:010, DOWN:100, DEFAULT:000

	nAlignPattern = ( nAlignPattern & 0x07);

    switch (nAlignPattern)
    {
        case 0:
            rPatternItemSet.Put( SvxVerJustifyItem(SVX_VER_JUSTIFY_STANDARD, ATTR_VER_JUSTIFY) );
            break;
        case 1:
            rPatternItemSet.Put( SvxVerJustifyItem(SVX_VER_JUSTIFY_TOP, ATTR_VER_JUSTIFY) );
            break;
        case 2:
            rPatternItemSet.Put( SvxVerJustifyItem(SVX_VER_JUSTIFY_CENTER, ATTR_VER_JUSTIFY) );
            break;
        case 4:
            rPatternItemSet.Put( SvxVerJustifyItem(SVX_VER_JUSTIFY_BOTTOM, ATTR_VER_JUSTIFY) );
            break;
        default:
            rPatternItemSet.Put( SvxVerJustifyItem(SVX_VER_JUSTIFY_STANDARD, ATTR_VER_JUSTIFY) );
            break;
    }
}

void OP_CreatePattern123( SvStream& r, sal_uInt16 n)
{
    sal_uInt16 nCode,nPatternId;

    ScPatternAttr aPattern(pDoc->GetPool());
    SfxItemSet& rItemSet = aPattern.GetItemSet();

    r >> nCode;
    n -= (n > 2) ? 2 : n;

    if ( nCode == 0x0fd2 )
    {
        r >> nPatternId;

        sal_uInt8 Hor_Align, Ver_Align, temp;
        sal_Bool bIsBold,bIsUnderLine,bIsItalics;

        r.SeekRel(12);

        // Read 17th Byte
        r >> temp;

        bIsBold = (temp & 0x01);
        bIsItalics = (temp & 0x02);
        bIsUnderLine = (temp & 0x04);

        if ( bIsBold )
            rItemSet.Put( SvxWeightItem(WEIGHT_BOLD,ATTR_FONT_WEIGHT) );
        if ( bIsItalics )
            rItemSet.Put( SvxPostureItem(ITALIC_NORMAL, ATTR_FONT_POSTURE ) );
        if ( bIsUnderLine )
            rItemSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, ATTR_FONT_UNDERLINE ) );

        r.SeekRel(3);

        // Read 21st Byte
        r >> Hor_Align;
        OP_HorAlign123( Hor_Align, rItemSet );

        r >> Ver_Align;
        OP_VerAlign123( Ver_Align, rItemSet );

        aLotusPatternPool.insert( std::map<sal_uInt16, ScPatternAttr>::value_type( nPatternId, aPattern ) );
        n -= (n > 20) ? 20 : n;
    }
    r.SeekRel(n);
}

void OP_SheetName123( SvStream& rStream, sal_uInt16 nLength )
{
    if (nLength <= 4)
    {
        rStream.SeekRel(nLength);
        return;
    }

    // B0 36 [sheet number (2 bytes?)] [sheet name (null terminated char array)]

    sal_uInt16 nDummy;
    rStream >> nDummy; // ignore the first 2 bytes (B0 36).
    rStream >> nDummy;
    SCTAB nSheetNum = static_cast<SCTAB>(nDummy);
    pDoc->MakeTable(nSheetNum);

    ::std::vector<sal_Char> sSheetName;
    sSheetName.reserve(nLength-4);
    for (sal_uInt16 i = 4; i < nLength; ++i)
    {
        sal_Char c;
        rStream >> c;
        sSheetName.push_back(c);
    }

    if (!sSheetName.empty())
    {
        String aName(&sSheetName[0], eCharVon);
        pDoc->RenameTab(nSheetNum, aName);
    }
}

void OP_ApplyPatternArea123( SvStream& rStream )
{
    sal_uInt16 nOpcode, nLength;
    sal_uInt16 nCol = 0, nColCount = 0, nRow = 0, nRowCount = 0, nTab = 0, nData, nTabCount = 0, nLevel = 0;

    do
    {
        rStream >> nOpcode >> nLength;
        switch ( nOpcode )
        {
            case ROW_FORMAT_MARKER:
                nLevel++;
                break;
            case COL_FORMAT_MARKER:
                nLevel--;
                if( nLevel == 1 )
                {
                    nTab = nTab + nTabCount;
                    nCol = 0; nColCount = 0;
                    nRow = 0; nRowCount = 0;
                }
                break;
            case LOTUS_FORMAT_INDEX:
				if( nLength >= 2 )
                {
                    rStream >> nData;
                    rStream.SeekRel( nLength - 2 );
                    if( nLevel == 1 )
                        nTabCount = nData;
                    else if( nLevel == 2 )
                    {
                        nCol = nCol + nColCount;
                        nColCount = nData;
                        if ( nCol > 0xff ) // 256 is the max col size supported by 123
                            nCol = 0;
                    }
                    else if( nLevel == 3 )
                    {
                        nRow = nRow + nRowCount;
                        nRowCount = nData;
                        if ( nRow > 0x1fff ) // 8192 is the max row size supported by 123
                            nRow = 0;
                    }
                }
                else
                    rStream.SeekRel( nLength );
                break;
            case LOTUS_FORMAT_INFO:
				if( nLength >= 2 )
                {
                    rStream >> nData;
                    rStream.SeekRel( nLength - 2 );
                    std::map<sal_uInt16, ScPatternAttr>::iterator loc = aLotusPatternPool.find( nData );
                    // #126338# apparently, files with invalid index occur in the wild -> don't crash then
                    if ( loc != aLotusPatternPool.end() )
                        for( int i = 0; i < nTabCount; i++)
                        {
                            pDoc->ApplyPatternAreaTab( nCol, nRow, nCol +  nColCount - 1, nRow + nRowCount - 1, static_cast< SCTAB >( nTab + i ), loc->second );
                        }
                }
                else
                    rStream.SeekRel( nLength );
                break;
            default:
                rStream.SeekRel( nLength );
                break;
        }
    }
    while( nLevel && !rStream.IsEof() );

    aLotusPatternPool.clear();
}