diff options
Diffstat (limited to 'binfilter/bf_sc/source/core')
116 files changed, 93177 insertions, 0 deletions
diff --git a/binfilter/bf_sc/source/core/data/makefile.mk b/binfilter/bf_sc/source/core/data/makefile.mk new file mode 100644 index 000000000000..5f1abbc133e6 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/makefile.mk @@ -0,0 +1,111 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +EXTERNAL_WARNINGS_NOT_ERRORS := TRUE + +PRJ=..$/..$/..$/.. +BFPRJ=..$/..$/.. + +PRJNAME=binfilter +TARGET=sc_data + +NO_HIDS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk +.INCLUDE : $(BFPRJ)$/util$/makefile.pmk +INC+= -I$(PRJ)$/inc$/bf_sc +# --- Files -------------------------------------------------------- + +SLOFILES = \ + $(SLO)$/sc_bclist.obj \ + $(SLO)$/sc_bcaslot.obj \ + $(SLO)$/sc_docpool.obj \ + $(SLO)$/sc_poolhelp.obj \ + $(SLO)$/sc_column.obj \ + $(SLO)$/sc_column2.obj \ + $(SLO)$/sc_column3.obj \ + $(SLO)$/sc_document.obj \ + $(SLO)$/sc_documen2.obj \ + $(SLO)$/sc_documen3.obj \ + $(SLO)$/sc_documen4.obj \ + $(SLO)$/sc_documen5.obj \ + $(SLO)$/sc_documen6.obj \ + $(SLO)$/sc_documen7.obj \ + $(SLO)$/sc_documen8.obj \ + $(SLO)$/sc_documen9.obj \ + $(SLO)$/sc_fillinfo.obj \ + $(SLO)$/sc_table1.obj \ + $(SLO)$/sc_table2.obj \ + $(SLO)$/sc_table3.obj \ + $(SLO)$/sc_table4.obj \ + $(SLO)$/sc_table5.obj \ + $(SLO)$/sc_olinetab.obj \ + $(SLO)$/sc_patattr.obj \ + $(SLO)$/sc_cell.obj \ + $(SLO)$/sc_cell2.obj \ + $(SLO)$/sc_attarray.obj \ + $(SLO)$/sc_attrib.obj \ + $(SLO)$/sc_global.obj \ + $(SLO)$/sc_global2.obj \ + $(SLO)$/sc_globalx.obj \ + $(SLO)$/sc_markarr.obj \ + $(SLO)$/sc_markdata.obj \ + $(SLO)$/sc_dociter.obj \ + $(SLO)$/sc_drwlayer.obj \ + $(SLO)$/sc_userdat.obj \ + $(SLO)$/sc_drawpage.obj \ + $(SLO)$/sc_stlsheet.obj \ + $(SLO)$/sc_stlpool.obj \ + $(SLO)$/sc_dptabsrc.obj \ + $(SLO)$/sc_dptabdat.obj \ + $(SLO)$/sc_dpshttab.obj \ + $(SLO)$/sc_dpoutput.obj \ + $(SLO)$/sc_dpobject.obj \ + $(SLO)$/sc_dpsave.obj \ + $(SLO)$/sc_pivot.obj \ + $(SLO)$/sc_pivot2.obj \ + $(SLO)$/sc_dbdocutl.obj \ + $(SLO)$/sc_pagepar.obj \ + $(SLO)$/sc_conditio.obj \ + $(SLO)$/sc_validat.obj \ + $(SLO)$/sc_sortparam.obj + +EXCEPTIONSFILES= \ + $(SLO)$/sc_documen6.obj \ + $(SLO)$/sc_dpobject.obj \ + $(SLO)$/sc_dpoutput.obj \ + $(SLO)$/sc_dpsave.obj \ + $(SLO)$/sc_dbdocutl.obj \ + $(SLO)$/sc_dptabsrc.obj \ + $(SLO)$/sc_globalx.obj + +# --- Tagets ------------------------------------------------------- + +.INCLUDE : target.mk + diff --git a/binfilter/bf_sc/source/core/data/sc_attarray.cxx b/binfilter/bf_sc/source/core/data/sc_attarray.cxx new file mode 100644 index 000000000000..1722c9990bf5 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_attarray.cxx @@ -0,0 +1,1699 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include "scitems.hxx" +#include <bf_svx/algitem.hxx> +#include <bf_svx/boxitem.hxx> +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/shaditem.hxx> +#include <bf_svtools/poolcach.hxx> + +#include <bf_svx/fontitem.hxx> + +#include "attarray.hxx" +#include "document.hxx" +#include "docpool.hxx" +#include "patattr.hxx" +#include "stlsheet.hxx" +#include "stlpool.hxx" +#include "rechead.hxx" +#include "globstr.hrc" +namespace binfilter { + + +#undef DBG_INVALIDATE +/*N*/ #define DBGOUTPUT(s) \ +/*N*/ DBG_ERROR( String("Invalidate ") + String(s) + String(": ") \ +/*N*/ + String(nCol) + String('/') + String(aAdrStart.Row()) + String('/') + String(nTab) \ +/*N*/ + String(" bis ") \ +/*N*/ + String(nCol) + String('/') + String(aAdrEnd.Row()) + String('/') + String(nTab) \ +/*N*/ ); + +// STATIC DATA ----------------------------------------------------------- + + +//------------------------------------------------------------------------ + +/*N*/ ScAttrArray::ScAttrArray( USHORT nNewCol, USHORT nNewTab, ScDocument* pDoc ) : +/*N*/ nCol( nNewCol ), +/*N*/ nTab( nNewTab ), +/*N*/ pDocument( pDoc ) +/*N*/ { +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ +/*N*/ nCount = nLimit = 1; +/*N*/ pData = new ScAttrEntry[1]; +/*N*/ if (pData) +/*N*/ { +/*N*/ pData[0].nRow = MAXROW; +/*N*/ pData[0].pPattern = pDocument->GetDefPattern(); // ohne Put !!! +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScAttrArray::~ScAttrArray() +/*N*/ { +/*N*/ #ifdef DBG_UTIL +/*N*/ TestData(); +/*N*/ #endif +/*N*/ +/*N*/ if (pData) +/*N*/ { +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ pDocPool->Remove(*pData[i].pPattern); +/*N*/ +/*N*/ delete[] pData; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +#ifdef DBG_UTIL +/*N*/ void ScAttrArray::TestData() const +/*N*/ { +/*N*/ USHORT nErr = 0; +/*N*/ if (pData) +/*N*/ { +/*N*/ USHORT nPos=0; +/*N*/ for (nPos=0; nPos<nCount; nPos++) +/*N*/ { +/*N*/ if (nPos) +/*N*/ if (pData[nPos].pPattern == pData[nPos-1].pPattern || pData[nPos].nRow <= pData[nPos-1].nRow) +/*N*/ ++nErr; +/*N*/ if (pData[nPos].pPattern->Which() != ATTR_PATTERN) +/*N*/ ++nErr; +/*N*/ } +/*N*/ if ( nPos && pData[nPos-1].nRow != MAXROW ) +/*N*/ ++nErr; +/*N*/ } +/*N*/ if (nErr) +/*N*/ { +/*?*/ ByteString aMsg = ByteString::CreateFromInt32(nErr); +/*?*/ aMsg += " errors in attribute array, column "; +/*?*/ aMsg += ByteString::CreateFromInt32(nCol); +/*?*/ DBG_ERROR( aMsg.GetBuffer() ); +/*N*/ } +/*N*/ } +#endif + +//------------------------------------------------------------------------ + +/*N*/ void ScAttrArray::Reset( const ScPatternAttr* pPattern, BOOL bAlloc ) +/*N*/ { +/*N*/ if (pData) +/*N*/ { +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ const ScPatternAttr* pOldPattern; +/*N*/ ScAddress aAdrStart( nCol, 0, nTab ); +/*N*/ ScAddress aAdrEnd ( nCol, 0, nTab ); +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ // ueberpruefen, ob Attributierung die Textbreite der Zelle aendert +/*N*/ pOldPattern = pData[i].pPattern; +/*N*/ BOOL bNumFormatChanged; +/*N*/ if ( ScGlobal::CheckWidthInvalidate( bNumFormatChanged, +/*N*/ pPattern->GetItemSet(), pOldPattern->GetItemSet() ) ) +/*N*/ { +/*N*/ aAdrStart.SetRow( i ? pData[i-1].nRow+1 : 0 ); +/*N*/ aAdrEnd .SetRow( pData[i].nRow ); +/*N*/ pDocument->InvalidateTextWidth( &aAdrStart, &aAdrEnd, bNumFormatChanged ); +/*N*/ #ifdef DBG_INVALIDATE +/*N*/ DBGOUTPUT("Reset"); +/*N*/ #endif +/*N*/ } +/*N*/ // bedingtes Format gesetzt oder geloescht? +/*N*/ if ( &pPattern->GetItem(ATTR_CONDITIONAL) != &pOldPattern->GetItem(ATTR_CONDITIONAL) ) +/*N*/ { +/*?*/ pDocument->ConditionalChanged( ((const SfxUInt32Item&) +/*?*/ pOldPattern->GetItem(ATTR_CONDITIONAL)).GetValue() ); +/*?*/ pDocument->ConditionalChanged( ((const SfxUInt32Item&) +/*?*/ pPattern->GetItem(ATTR_CONDITIONAL)).GetValue() ); +/*N*/ } +/*N*/ pDocPool->Remove(*pOldPattern); +/*N*/ } +/*N*/ delete[] pData; +/*N*/ +/*N*/ if (bAlloc) +/*N*/ { +/*N*/ nCount = nLimit = 1; +/*N*/ pData = new ScAttrEntry[1]; +/*N*/ if (pData) +/*N*/ { +/*N*/ ScPatternAttr* pNewPattern = (ScPatternAttr*) &pDocPool->Put(*pPattern); +/*N*/ pData[0].nRow = MAXROW; +/*N*/ pData[0].pPattern = pNewPattern; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nCount = nLimit = 0; +/*N*/ pData = NULL; // muss sofort wieder belegt werden ! +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScAttrArray::Concat(USHORT nPos) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ if (pData && (nPos < nCount)) +/*N*/ { +/*N*/ if (nPos > 0) +/*N*/ { +/*N*/ if (pData[nPos - 1].pPattern == pData[nPos].pPattern) +/*N*/ { +/*?*/ pData[nPos - 1].nRow = pData[nPos].nRow; +/*?*/ pDocument->GetPool()->Remove(*pData[nPos].pPattern); +/*?*/ memmove(&pData[nPos], &pData[nPos + 1], (nCount - nPos - 1) * sizeof(ScAttrEntry)); +/*?*/ pData[nCount - 1].pPattern = NULL; +/*?*/ pData[nCount - 1].nRow = 0; +/*?*/ nCount--; +/*?*/ nPos--; +/*?*/ bRet = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if (nPos + 1 < nCount) +/*N*/ { +/*N*/ if (pData[nPos + 1].pPattern == pData[nPos].pPattern) +/*N*/ { +/*N*/ pData[nPos].nRow = pData[nPos + 1].nRow; +/*N*/ pDocument->GetPool()->Remove(*pData[nPos].pPattern); +/*N*/ memmove(&pData[nPos + 1], &pData[nPos + 2], (nCount - nPos - 2) * sizeof(ScAttrEntry)); +/*N*/ pData[nCount - 1].pPattern = NULL; +/*N*/ pData[nCount - 1].nRow = 0; +/*N*/ nCount--; +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScAttrArray::Search( USHORT nRow, short& nIndex ) const +/*N*/ { +/*N*/ short nLo = 0; +/*N*/ short nHi = ((short) nCount) - 1; +/*N*/ short nStartRow = 0; +/*N*/ short nEndRow = 0; +/*N*/ short i = 0; +/*N*/ BOOL bFound = (nCount == 1); +/*N*/ if (pData) +/*N*/ { +/*N*/ while ( !bFound && nLo <= nHi ) +/*N*/ { +/*N*/ i = (nLo + nHi) / 2; +/*N*/ if (i > 0) +/*N*/ nStartRow = (short) pData[i - 1].nRow; +/*N*/ else +/*N*/ nStartRow = -1; +/*N*/ nEndRow = (short) pData[i].nRow; +/*N*/ if (nEndRow < (short) nRow) +/*N*/ nLo = ++i; +/*N*/ else +/*N*/ if (nStartRow >= (short) nRow) +/*N*/ nHi = --i; +/*N*/ else +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bFound = FALSE; +/*N*/ +/*N*/ if (bFound) +/*N*/ nIndex=i; +/*N*/ else +/*N*/ nIndex=0; +/*N*/ return bFound; +/*N*/ } + + +/*N*/ const ScPatternAttr* ScAttrArray::GetPattern( USHORT nRow ) const +/*N*/ { +/*N*/ short i; +/*N*/ if (Search( nRow, i )) +/*N*/ return pData[i].pPattern; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + + + +//------------------------------------------------------------------------ + +/*N*/ void ScAttrArray::SetPattern( USHORT nRow, const ScPatternAttr* pPattern, BOOL bPutToPool ) +/*N*/ { +/*N*/ SetPatternArea( nRow, nRow, pPattern, bPutToPool ); +/*N*/ } + + +/*N*/ void ScAttrArray::SetPatternArea(USHORT nStartRow, USHORT nEndRow, const ScPatternAttr *pPattern, BOOL bPutToPool ) +/*N*/ { +/*N*/ if (nStartRow >= 0 && nStartRow <= MAXROW && nEndRow >= 0 && nEndRow <= MAXROW) +/*N*/ { +/*N*/ if (bPutToPool) +/*N*/ pPattern = (const ScPatternAttr*) &pDocument->GetPool()->Put(*pPattern); +/*N*/ +/*N*/ if ((nStartRow == 0) && (nEndRow == MAXROW)) +/*N*/ Reset(pPattern); +/*N*/ else +/*N*/ { +/*N*/ USHORT nNeeded = nCount + 2; +/*N*/ if ( nLimit < nNeeded ) +/*N*/ { +/*N*/ nLimit += SC_ATTRARRAY_DELTA; +/*N*/ if ( nLimit < nNeeded ) +/*N*/ nLimit = nNeeded; +/*N*/ ScAttrEntry* pNewData = new ScAttrEntry[nLimit]; +/*N*/ memcpy( pNewData, pData, nCount*sizeof(ScAttrEntry) ); +/*N*/ delete[] pData; +/*N*/ pData = pNewData; +/*N*/ } +/*N*/ +/*N*/ ScAddress aAdrStart( nCol, 0, nTab ); +/*N*/ ScAddress aAdrEnd ( nCol, 0, nTab ); +/*N*/ +/*N*/ USHORT ni = 0; // number of entries in beginning +/*N*/ USHORT nx = 0; // track position +/*N*/ USHORT ns = 0; // start row of track position +/*N*/ if ( nStartRow > 0 ) +/*N*/ { +/*N*/ // skip beginning +/*N*/ short nIndex; +/*N*/ Search( nStartRow, nIndex ); +/*N*/ ni = nIndex; +/*N*/ +/*N*/ if ( ni ) +/*N*/ { +/*N*/ nx = ni; +/*N*/ ns = pData[ni-1].nRow+1; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // ueberpruefen, ob Attributierung die Textbreite der Zelle aendert +/*N*/ // oder bedingte Formate neu gesetzt oder geloescht werden +/*N*/ while ( ns <= nEndRow ) +/*N*/ { +/*N*/ const SfxItemSet& rNewSet = pPattern->GetItemSet(); +/*N*/ const SfxItemSet& rOldSet = pData[nx].pPattern->GetItemSet(); +/*N*/ +/*N*/ BOOL bNumFormatChanged; +/*N*/ if ( ScGlobal::CheckWidthInvalidate( bNumFormatChanged, +/*N*/ rNewSet, rOldSet ) ) +/*N*/ { +/*N*/ aAdrStart.SetRow( Max(nStartRow,ns) ); +/*N*/ aAdrEnd .SetRow( Min(nEndRow,pData[nx].nRow) ); +/*N*/ pDocument->InvalidateTextWidth( &aAdrStart, &aAdrEnd, bNumFormatChanged ); +/*N*/ #ifdef DBG_INVALIDATE +/*N*/ DBGOUTPUT("SetPatternArea"); +/*N*/ #endif +/*N*/ } +/*N*/ if ( &rNewSet.Get(ATTR_CONDITIONAL) != &rOldSet.Get(ATTR_CONDITIONAL) ) +/*N*/ { +/*N*/ pDocument->ConditionalChanged( ((const SfxUInt32Item&) +/*N*/ rOldSet.Get(ATTR_CONDITIONAL)).GetValue() ); +/*N*/ pDocument->ConditionalChanged( ((const SfxUInt32Item&) +/*N*/ rNewSet.Get(ATTR_CONDITIONAL)).GetValue() ); +/*N*/ } +/*N*/ ns = pData[nx].nRow + 1; +/*N*/ nx++; +/*N*/ } +/*N*/ +/*N*/ // continue modifying data array +/*N*/ +/*N*/ USHORT nInsert; // insert position (MAXROW+1 := no insert) +/*N*/ BOOL bCombined = FALSE; +/*N*/ BOOL bSplit = FALSE; +/*N*/ if ( nStartRow > 0 ) +/*N*/ { +/*N*/ nInsert = MAXROW+1; +/*N*/ if ( pData[ni].pPattern != pPattern ) +/*N*/ { +/*N*/ if ( ni == 0 || (pData[ni-1].nRow < nStartRow - 1) ) +/*N*/ { // may be a split or a simple insert or just a shrink, +/*N*/ // row adjustment is done further down +/*N*/ if ( pData[ni].nRow > nEndRow ) +/*N*/ bSplit = TRUE; +/*N*/ ni++; +/*N*/ nInsert = ni; +/*N*/ } +/*N*/ else if ( ni > 0 && pData[ni-1].nRow == nStartRow - 1 ) +/*N*/ nInsert = ni; +/*N*/ } +/*N*/ if ( ni > 0 && pData[ni-1].pPattern == pPattern ) +/*N*/ { // combine +/*N*/ pData[ni-1].nRow = nEndRow; +/*N*/ nInsert = MAXROW+1; +/*N*/ bCombined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nInsert = 0; +/*N*/ +/*N*/ USHORT nj = ni; // stop position of range to replace +/*N*/ while ( nj < nCount && pData[nj].nRow <= nEndRow ) +/*N*/ nj++; +/*N*/ if ( !bSplit ) +/*N*/ { +/*N*/ if ( nj < nCount && pData[nj].pPattern == pPattern ) +/*N*/ { // combine +/*N*/ if ( ni > 0 ) +/*N*/ { +/*N*/ if ( pData[ni-1].pPattern == pPattern ) +/*N*/ { // adjacent entries +/*N*/ pData[ni-1].nRow = pData[nj].nRow; +/*N*/ nj++; +/*N*/ } +/*N*/ else if ( ni == nInsert ) +/*N*/ pData[ni-1].nRow = nStartRow - 1; // shrink +/*N*/ } +/*N*/ nInsert = MAXROW+1; +/*N*/ bCombined = TRUE; +/*N*/ } +/*N*/ else if ( ni > 0 && ni == nInsert ) +/*N*/ pData[ni-1].nRow = nStartRow - 1; // shrink +/*N*/ } +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ if ( bSplit ) +/*N*/ { // duplicate splitted entry in pool +/*N*/ pDocPool->Put( *pData[ni-1].pPattern ); +/*N*/ } +/*N*/ if ( ni < nj ) +/*N*/ { // remove middle entries +/*N*/ for ( USHORT nk=ni; nk<nj; nk++) +/*N*/ { // remove entries from pool +/*N*/ pDocPool->Remove( *pData[nk].pPattern ); +/*N*/ } +/*N*/ if ( !bCombined ) +/*N*/ { // replace one entry +/*N*/ pData[ni].nRow = nEndRow; +/*N*/ pData[ni].pPattern = pPattern; +/*N*/ ni++; +/*N*/ nInsert = MAXROW+1; +/*N*/ } +/*N*/ if ( ni < nj ) +/*N*/ { // remove entries +/*N*/ memmove( pData + ni, pData + nj, (nCount - nj) * sizeof(ScAttrEntry) ); +/*N*/ nCount -= nj - ni; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( nInsert <= MAXROW ) +/*N*/ { // insert or append new entry +/*N*/ if ( nInsert <= nCount ) +/*N*/ { +/*N*/ if ( !bSplit ) +/*N*/ memmove( pData + nInsert + 1, pData + nInsert, +/*N*/ (nCount - nInsert) * sizeof(ScAttrEntry) ); +/*N*/ else +/*N*/ { +/*N*/ memmove( pData + nInsert + 2, pData + nInsert, +/*N*/ (nCount - nInsert) * sizeof(ScAttrEntry) ); +/*N*/ pData[nInsert+1] = pData[nInsert-1]; +/*N*/ nCount++; +/*N*/ } +/*N*/ } +/*N*/ if ( nInsert ) +/*N*/ pData[nInsert-1].nRow = nStartRow - 1; +/*N*/ pData[nInsert].nRow = nEndRow; +/*N*/ pData[nInsert].pPattern = pPattern; +/*N*/ nCount++; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ // InfoBox(0, String(nCount) + String(" Eintraege") ).Execute(); +/*N*/ +/*N*/ #ifdef DBG_UTIL +/*N*/ TestData(); +/*N*/ #endif +/*N*/ } + + +/*N*/ void ScAttrArray::ApplyStyleArea( USHORT nStartRow, USHORT nEndRow, ScStyleSheet* pStyle ) +/*N*/ { +/*N*/ if (nStartRow >= 0 && nStartRow <= MAXROW && nEndRow >= 0 && nEndRow <= MAXROW) +/*N*/ { +/*N*/ short nPos; +/*N*/ USHORT nStart=0; +/*N*/ if (!Search( nStartRow, nPos )) +/*N*/ { +/*N*/ DBG_ERROR("Search-Fehler"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ ScAddress aAdrStart( nCol, 0, nTab ); +/*N*/ ScAddress aAdrEnd ( nCol, 0, nTab ); +/*N*/ +/*N*/ do +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern = pData[nPos].pPattern; +/*N*/ ScPatternAttr* pNewPattern = new ScPatternAttr(*pOldPattern); +/*N*/ pNewPattern->SetStyleSheet(pStyle); +/*N*/ USHORT nY1 = nStart; +/*N*/ USHORT nY2 = pData[nPos].nRow; +/*N*/ nStart = pData[nPos].nRow + 1; +/*N*/ +/*N*/ if ( *pNewPattern == *pOldPattern ) +/*N*/ { +/*N*/ // keep the original pattern (might be default) +/*N*/ // pNewPattern is deleted below +/*N*/ nPos++; +/*N*/ } +/*N*/ else if ( nY1 < nStartRow || nY2 > nEndRow ) +/*N*/ { +/*N*/ if (nY1 < nStartRow) nY1=nStartRow; +/*N*/ if (nY2 > nEndRow) nY2=nEndRow; +/*N*/ SetPatternArea( nY1, nY2, pNewPattern, TRUE ); +/*N*/ Search( nStart, nPos ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // ueberpruefen, ob Attributierung die Textbreite der Zelle aendert +/*N*/ // bedingte Formate in Vorlagen gibt es (noch) nicht +/*N*/ +/*N*/ const SfxItemSet& rNewSet = pNewPattern->GetItemSet(); +/*N*/ const SfxItemSet& rOldSet = pOldPattern->GetItemSet(); +/*N*/ +/*N*/ BOOL bNumFormatChanged; +/*N*/ if ( ScGlobal::CheckWidthInvalidate( bNumFormatChanged, +/*N*/ rNewSet, rOldSet ) ) +/*N*/ { +/*N*/ aAdrStart.SetRow( nPos ? pData[nPos-1].nRow+1 : 0 ); +/*N*/ aAdrEnd .SetRow( pData[nPos].nRow ); +/*N*/ pDocument->InvalidateTextWidth( &aAdrStart, &aAdrEnd, bNumFormatChanged ); +/*N*/ #ifdef DBG_INVALIDATE +/*N*/ DBGOUTPUT("ApplyStyleArea"); +/*N*/ #endif +/*N*/ } +/*N*/ +/*N*/ pDocument->GetPool()->Remove(*pData[nPos].pPattern); +/*N*/ pData[nPos].pPattern = (const ScPatternAttr*) +/*N*/ &pDocument->GetPool()->Put(*pNewPattern); +/*N*/ if (Concat(nPos)) +/*?*/ Search(nStart, nPos); +/*N*/ else +/*N*/ nPos++; +/*N*/ } +/*N*/ delete pNewPattern; +/*N*/ } +/*N*/ while ((nStart <= nEndRow) && (nPos < (short)nCount)); +/*N*/ } +/*N*/ +/*N*/ #ifdef DBG_UTIL +/*N*/ TestData(); +/*N*/ #endif +/*N*/ } + + + // const wird weggecastet, weil es sonst + // zu ineffizient/kompliziert wird! + + + + +/*N*/ void ScAttrArray::ApplyCacheArea( USHORT nStartRow, USHORT nEndRow, SfxItemPoolCache* pCache ) +/*N*/ { +/*N*/ #ifdef DBG_UTIL +/*N*/ TestData(); +/*N*/ #endif +/*N*/ +/*N*/ if (nStartRow >= 0 && nStartRow <= MAXROW && nEndRow >= 0 && nEndRow <= MAXROW) +/*N*/ { +/*N*/ short nPos; +/*N*/ USHORT nStart=0; +/*N*/ if (!Search( nStartRow, nPos )) +/*N*/ { +/*N*/ DBG_ERROR("Search-Fehler"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ ScAddress aAdrStart( nCol, 0, nTab ); +/*N*/ ScAddress aAdrEnd ( nCol, 0, nTab ); +/*N*/ +/*N*/ do +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern = pData[nPos].pPattern; +/*N*/ const ScPatternAttr* pNewPattern = (const ScPatternAttr*) &pCache->ApplyTo( *pOldPattern, TRUE ); +/*N*/ ScDocumentPool::CheckRef( *pOldPattern ); +/*N*/ ScDocumentPool::CheckRef( *pNewPattern ); +/*N*/ if (pNewPattern != pOldPattern) +/*N*/ { +/*N*/ USHORT nY1 = nStart; +/*N*/ USHORT nY2 = pData[nPos].nRow; +/*N*/ nStart = pData[nPos].nRow + 1; +/*N*/ +/*N*/ if ( nY1 < nStartRow || nY2 > nEndRow ) +/*N*/ { +/*N*/ if (nY1 < nStartRow) nY1=nStartRow; +/*N*/ if (nY2 > nEndRow) nY2=nEndRow; +/*N*/ SetPatternArea( nY1, nY2, pNewPattern ); +/*N*/ Search( nStart, nPos ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // ueberpruefen, ob Attributierung die Textbreite der Zelle aendert +/*N*/ +/*N*/ const SfxItemSet& rNewSet = pNewPattern->GetItemSet(); +/*N*/ const SfxItemSet& rOldSet = pOldPattern->GetItemSet(); +/*N*/ +/*N*/ BOOL bNumFormatChanged; +/*N*/ if ( ScGlobal::CheckWidthInvalidate( bNumFormatChanged, +/*N*/ rNewSet, rOldSet ) ) +/*N*/ { +/*N*/ aAdrStart.SetRow( nPos ? pData[nPos-1].nRow+1 : 0 ); +/*N*/ aAdrEnd .SetRow( pData[nPos].nRow ); +/*N*/ pDocument->InvalidateTextWidth( &aAdrStart, &aAdrEnd, bNumFormatChanged ); +/*N*/ #ifdef DBG_INVALIDATE +/*N*/ DBGOUTPUT("ApplyCacheArea"); +/*N*/ #endif +/*N*/ } +/*N*/ +/*N*/ // bedingte Formate neu gesetzt oder geloescht ? +/*N*/ +/*N*/ if ( &rNewSet.Get(ATTR_CONDITIONAL) != &rOldSet.Get(ATTR_CONDITIONAL) ) +/*N*/ { +/*?*/ pDocument->ConditionalChanged( ((const SfxUInt32Item&) +/*?*/ rOldSet.Get(ATTR_CONDITIONAL)).GetValue() ); +/*?*/ pDocument->ConditionalChanged( ((const SfxUInt32Item&) +/*?*/ rNewSet.Get(ATTR_CONDITIONAL)).GetValue() ); +/*N*/ } +/*N*/ +/*N*/ pDocument->GetPool()->Remove(*pData[nPos].pPattern); +/*N*/ pData[nPos].pPattern = pNewPattern; +/*N*/ if (Concat(nPos)) +/*?*/ Search(nStart, nPos); +/*N*/ else +/*N*/ ++nPos; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ //!!!!!!!!!!!!!!!!!! mit diesem Remove gibt es Abstuerze (Calc1 Import) +/*?*/ //! pDocument->GetPool()->Remove(*pNewPattern); +/*?*/ nStart = pData[nPos].nRow + 1; +/*?*/ ++nPos; +/*N*/ } +/*N*/ } +/*N*/ while (nStart <= nEndRow); +/*N*/ } +/*N*/ +/*N*/ #ifdef DBG_UTIL +/*N*/ TestData(); +/*N*/ #endif +/*N*/ } + + +/*N*/ void lcl_MergeDeep( SfxItemSet& rMergeSet, const SfxItemSet& rSource ) +/*N*/ { +/*N*/ const SfxPoolItem* pNewItem; +/*N*/ const SfxPoolItem* pOldItem; +/*N*/ for (USHORT nId=ATTR_PATTERN_START; nId<=ATTR_PATTERN_END; nId++) +/*N*/ { +/*N*/ // pMergeSet hat keinen Parent +/*N*/ SfxItemState eOldState = rMergeSet.GetItemState( nId, FALSE, &pOldItem ); +/*N*/ +/*N*/ if ( eOldState == SFX_ITEM_DEFAULT ) // Default +/*N*/ { +/*N*/ SfxItemState eNewState = rSource.GetItemState( nId, TRUE, &pNewItem ); +/*N*/ if ( eNewState == SFX_ITEM_SET ) +/*N*/ { +/*N*/ if ( *pNewItem != rMergeSet.GetPool()->GetDefaultItem(nId) ) +/*N*/ rMergeSet.InvalidateItem( nId ); +/*N*/ } +/*N*/ } +/*N*/ else if ( eOldState == SFX_ITEM_SET ) // Item gesetzt +/*N*/ { +/*N*/ SfxItemState eNewState = rSource.GetItemState( nId, TRUE, &pNewItem ); +/*N*/ if ( eNewState == SFX_ITEM_SET ) +/*N*/ { +/*N*/ if ( pNewItem != pOldItem ) // beide gepuhlt +/*?*/ rMergeSet.InvalidateItem( nId ); +/*N*/ } +/*N*/ else // Default +/*N*/ { +/*N*/ if ( *pOldItem != rSource.GetPool()->GetDefaultItem(nId) ) +/*N*/ rMergeSet.InvalidateItem( nId ); +/*N*/ } +/*N*/ } +/*N*/ // Dontcare bleibt Dontcare +/*N*/ } +/*N*/ } + + +/*N*/ void ScAttrArray::MergePatternArea( USHORT nStartRow, USHORT nEndRow, +/*N*/ SfxItemSet** ppSet, BOOL bDeep ) const +/*N*/ { +/*N*/ if (nStartRow >= 0 && nStartRow <= MAXROW && nEndRow >= 0 && nEndRow <= MAXROW) +/*N*/ { +/*N*/ const ScPatternAttr* pOld1 = NULL; +/*N*/ const ScPatternAttr* pOld2 = NULL; +/*N*/ +/*N*/ short nPos; +/*N*/ USHORT nStart=0; +/*N*/ if (!Search( nStartRow, nPos )) +/*N*/ { +/*N*/ DBG_ERROR("Search-Fehler"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ do +/*N*/ { +/*N*/ // gleiche Patterns muessen nicht mehrfach angesehen werden +/*N*/ +/*N*/ const ScPatternAttr* pPattern = pData[nPos].pPattern; +/*N*/ if ( pPattern != pOld1 && pPattern != pOld2 ) +/*N*/ { +/*N*/ const SfxItemSet& rThisSet = pPattern->GetItemSet(); +/*N*/ if (*ppSet) +/*N*/ { +/*N*/ // (*ppSet)->MergeValues( rThisSet, FALSE ); +/*N*/ // geht nicht, weil die Vorlagen nicht beruecksichtigt werden +/*N*/ +/*N*/ if (bDeep) +/*N*/ lcl_MergeDeep( **ppSet, rThisSet ); +/*N*/ else +/*N*/ (*ppSet)->MergeValues( rThisSet, FALSE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // erstes Pattern - in Set ohne Parent kopieren +/*N*/ *ppSet = new SfxItemSet( *rThisSet.GetPool(), rThisSet.GetRanges() ); +/*N*/ (*ppSet)->Set( rThisSet, bDeep ); +/*N*/ } +/*N*/ +/*N*/ pOld2 = pOld1; +/*N*/ pOld1 = pPattern; +/*N*/ } +/*N*/ +/*N*/ nStart = pData[nPos].nRow + 1; +/*N*/ ++nPos; +/*N*/ } +/*N*/ while (nStart <= nEndRow); +/*N*/ } +/*N*/ } + + + +// Umrandung zusammenbauen + + + + + + +// +// Rahmen anwenden +// + +// ApplyFrame - auf einen Eintrag im Array + + + + + + + + + +// Testen, ob Bereich bestimmtes Attribut enthaelt + +/*N*/ BOOL ScAttrArray::HasAttrib( USHORT nRow1, USHORT nRow2, USHORT nMask ) const +/*N*/ { +/*N*/ short nStartIndex; +/*N*/ short nEndIndex; +/*N*/ Search( nRow1, nStartIndex ); +/*N*/ Search( nRow2, nEndIndex ); +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ for (short i=nStartIndex; i<=nEndIndex && !bFound; i++) +/*N*/ { +/*N*/ const ScPatternAttr* pPattern = pData[i].pPattern; +/*N*/ if ( nMask & HASATTR_MERGED ) +/*N*/ { +/*N*/ const ScMergeAttr* pMerge = +/*N*/ (const ScMergeAttr*) &pPattern->GetItem( ATTR_MERGE ); +/*N*/ if ( pMerge->GetColMerge() > 1 || pMerge->GetRowMerge() > 1 ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & ( HASATTR_OVERLAPPED | HASATTR_NOTOVERLAPPED | HASATTR_AUTOFILTER ) ) +/*N*/ { +/*N*/ const ScMergeFlagAttr* pMergeFlag = +/*N*/ (const ScMergeFlagAttr*) &pPattern->GetItem( ATTR_MERGE_FLAG ); +/*N*/ if ( (nMask & HASATTR_OVERLAPPED) && pMergeFlag->IsOverlapped() ) +/*N*/ bFound = TRUE; +/*N*/ if ( (nMask & HASATTR_NOTOVERLAPPED) && !pMergeFlag->IsOverlapped() ) +/*N*/ bFound = TRUE; +/*N*/ if ( (nMask & HASATTR_AUTOFILTER) && pMergeFlag->HasAutoFilter() ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_LINES ) +/*N*/ { +/*N*/ const SvxBoxItem* pBox = +/*N*/ (const SvxBoxItem*) &pPattern->GetItem( ATTR_BORDER ); +/*N*/ if ( pBox->GetLeft() || pBox->GetRight() || pBox->GetTop() || pBox->GetBottom() ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_SHADOW ) +/*N*/ { +/*N*/ const SvxShadowItem* pShadow = +/*N*/ (const SvxShadowItem*) &pPattern->GetItem( ATTR_SHADOW ); +/*N*/ if ( pShadow->GetLocation() != SVX_SHADOW_NONE ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_CONDITIONAL ) +/*N*/ { +/*N*/ const SfxUInt32Item* pConditional = +/*N*/ (const SfxUInt32Item*) &pPattern->GetItem( ATTR_CONDITIONAL ); +/*N*/ if ( pConditional->GetValue() != 0 ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_PROTECTED ) +/*N*/ { +/*N*/ const ScProtectionAttr* pProtect = +/*N*/ (const ScProtectionAttr*) &pPattern->GetItem( ATTR_PROTECTION ); +/*N*/ if ( pProtect->GetProtection() || pProtect->GetHideCell() ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_ROTATE ) +/*N*/ { +/*N*/ const SfxInt32Item* pRotate = +/*N*/ (const SfxInt32Item*) &pPattern->GetItem( ATTR_ROTATE_VALUE ); +/*N*/ if ( pRotate->GetValue() != 0 ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_NEEDHEIGHT ) +/*N*/ { +/*N*/ SvxCellOrientation eOrient = (SvxCellOrientation) +/*N*/ ((const SvxOrientationItem&)pPattern->GetItem( ATTR_ORIENTATION )).GetValue(); +/*N*/ if (eOrient != SVX_ORIENTATION_STANDARD) +/*N*/ bFound = TRUE; +/*N*/ else if (((const SfxBoolItem&)pPattern->GetItem( ATTR_LINEBREAK )).GetValue()) +/*N*/ bFound = TRUE; +/*N*/ else if ((SvxCellHorJustify)((const SvxHorJustifyItem&)pPattern-> +/*N*/ GetItem( ATTR_HOR_JUSTIFY )).GetValue() == SVX_HOR_JUSTIFY_BLOCK) +/*N*/ bFound = TRUE; +/*N*/ else if (((const SfxUInt32Item&)pPattern->GetItem( ATTR_CONDITIONAL )).GetValue()) +/*N*/ bFound = TRUE; +/*N*/ else if (((const SfxInt32Item&)pPattern->GetItem( ATTR_ROTATE_VALUE )).GetValue()) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & ( HASATTR_SHADOW_RIGHT | HASATTR_SHADOW_DOWN ) ) +/*N*/ { +/*N*/ const SvxShadowItem* pShadow = +/*N*/ (const SvxShadowItem*) &pPattern->GetItem( ATTR_SHADOW ); +/*N*/ SvxShadowLocation eLoc = pShadow->GetLocation(); +/*N*/ if ( nMask & HASATTR_SHADOW_RIGHT ) +/*N*/ if ( eLoc == SVX_SHADOW_TOPRIGHT || eLoc == SVX_SHADOW_BOTTOMRIGHT ) +/*N*/ bFound = TRUE; +/*N*/ if ( nMask & HASATTR_SHADOW_DOWN ) +/*N*/ if ( eLoc == SVX_SHADOW_BOTTOMLEFT || eLoc == SVX_SHADOW_BOTTOMRIGHT ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( nMask & HASATTR_RTL ) +/*N*/ { +/*?*/ const SvxFrameDirectionItem& rDirection = +/*?*/ (const SvxFrameDirectionItem&) pPattern->GetItem( ATTR_WRITINGDIR ); +/*?*/ if ( rDirection.GetValue() == FRMDIR_HORI_RIGHT_TOP ) +/*?*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + +// Bereich um evtl. enthaltene Zusammenfassungen erweitern +// und evtl. MergeFlag anpassen (bRefresh) + +/*N*/ BOOL ScAttrArray::ExtendMerge( USHORT nThisCol, USHORT nStartRow, USHORT nEndRow, +/*N*/ USHORT& rPaintCol, USHORT& rPaintRow, +/*N*/ BOOL bRefresh, BOOL bAttrs ) +/*N*/ { +/*N*/ const ScPatternAttr* pPattern; +/*N*/ const ScMergeAttr* pItem; +/*N*/ short nStartIndex; +/*N*/ short nEndIndex; +/*N*/ Search( nStartRow, nStartIndex ); +/*N*/ Search( nEndRow, nEndIndex ); +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ for (short i=nStartIndex; i<=nEndIndex; i++) +/*N*/ { +/*N*/ pPattern = pData[i].pPattern; +/*N*/ pItem = (const ScMergeAttr*) &pPattern->GetItem( ATTR_MERGE ); +/*N*/ INT16 nCountX = pItem->GetColMerge(); +/*N*/ INT16 nCountY = pItem->GetRowMerge(); +/*N*/ if (nCountX>1 || nCountY>1) +/*N*/ { +/*N*/ USHORT nThisRow = (i>0) ? pData[i-1].nRow+1 : 0; +/*N*/ USHORT nMergeEndCol = nThisCol + nCountX - 1; +/*N*/ USHORT nMergeEndRow = nThisRow + nCountY - 1; +/*N*/ if (nMergeEndCol > rPaintCol && nMergeEndCol <= MAXCOL) +/*N*/ rPaintCol = nMergeEndCol; +/*N*/ if (nMergeEndRow > rPaintRow && nMergeEndRow <= MAXROW) +/*N*/ rPaintRow = nMergeEndRow; +/*N*/ bFound = TRUE; +/*N*/ +/*N*/ if (bAttrs) +/*N*/ { +/*N*/ const SvxShadowItem* pShadow = +/*N*/ (const SvxShadowItem*) &pPattern->GetItem( ATTR_SHADOW ); +/*N*/ SvxShadowLocation eLoc = pShadow->GetLocation(); +/*N*/ if ( eLoc == SVX_SHADOW_TOPRIGHT || eLoc == SVX_SHADOW_BOTTOMRIGHT ) +/*N*/ if ( nMergeEndCol+1 > rPaintCol && nMergeEndCol < MAXCOL ) +/*N*/ rPaintCol = nMergeEndCol+1; +/*N*/ if ( eLoc == SVX_SHADOW_BOTTOMLEFT || eLoc == SVX_SHADOW_BOTTOMRIGHT ) +/*?*/ if ( nMergeEndRow+1 > rPaintRow && nMergeEndRow < MAXROW ) +/*?*/ rPaintRow = nMergeEndRow+1; +/*N*/ } +/*N*/ +/*N*/ if (bRefresh) +/*N*/ { +/*?*/ if ( nMergeEndCol > nThisCol ) +/*?*/ pDocument->ApplyFlagsTab( nThisCol+1, nThisRow, nMergeEndCol, pData[i].nRow, +/*?*/ nTab, SC_MF_HOR ); +/*?*/ if ( nMergeEndRow > nThisRow ) +/*?*/ pDocument->ApplyFlagsTab( nThisCol, nThisRow+1, nThisCol, nMergeEndRow, +/*?*/ nTab, SC_MF_VER ); +/*?*/ if ( nMergeEndCol > nThisCol && nMergeEndRow > nThisRow ) +/*?*/ pDocument->ApplyFlagsTab( nThisCol+1, nThisRow+1, nMergeEndCol, nMergeEndRow, +/*?*/ nTab, SC_MF_HOR | SC_MF_VER ); +/*?*/ +/*?*/ Search( nThisRow, i ); // Daten wurden veraendert +/*?*/ Search( nStartRow, nStartIndex ); +/*?*/ Search( nEndRow, nEndIndex ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + + +/*N*/ BOOL ScAttrArray::RemoveAreaMerge(USHORT nStartRow, USHORT nEndRow) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ const ScPatternAttr* pPattern; +/*N*/ const ScMergeAttr* pItem; +/*N*/ short nIndex; +/*N*/ +/*N*/ Search( nStartRow, nIndex ); +/*N*/ USHORT nThisStart = (nIndex>0) ? pData[nIndex-1].nRow+1 : 0; +/*N*/ if (nThisStart < nStartRow) +/*N*/ nThisStart = nStartRow; +/*N*/ +/*N*/ while ( nThisStart <= nEndRow ) +/*N*/ { +/*N*/ USHORT nThisEnd = pData[nIndex].nRow; +/*N*/ if (nThisEnd > nEndRow) +/*N*/ nThisEnd = nEndRow; +/*N*/ +/*N*/ pPattern = pData[nIndex].pPattern; +/*N*/ pItem = (const ScMergeAttr*) &pPattern->GetItem( ATTR_MERGE ); +/*N*/ INT16 nCountX = pItem->GetColMerge(); +/*N*/ INT16 nCountY = pItem->GetRowMerge(); +/*N*/ if (nCountX>1 || nCountY>1) +/*N*/ { +/*N*/ const ScMergeAttr* pAttr = (const ScMergeAttr*) +/*N*/ &pDocument->GetPool()->GetDefaultItem( ATTR_MERGE ); +/*N*/ const ScMergeFlagAttr* pFlagAttr = (const ScMergeFlagAttr*) +/*N*/ &pDocument->GetPool()->GetDefaultItem( ATTR_MERGE_FLAG ); +/*N*/ +/*N*/ DBG_ASSERT( nCountY==1 || nThisStart==nThisEnd, "was'n hier los?" ); +/*N*/ +/*N*/ USHORT nThisCol = nCol; +/*N*/ USHORT nMergeEndCol = nThisCol + nCountX - 1; +/*N*/ USHORT nMergeEndRow = nThisEnd + nCountY - 1; +/*N*/ +/*N*/ //! ApplyAttr fuer Bereiche !!! +/*N*/ +/*N*/ for (USHORT nThisRow = nThisStart; nThisRow <= nThisEnd; nThisRow++) +/*N*/ pDocument->ApplyAttr( nThisCol, nThisRow, nTab, *pAttr ); +/*N*/ +/*N*/ ScPatternAttr* pNewPattern = new ScPatternAttr( pDocument->GetPool() ); +/*N*/ SfxItemSet* pSet = &pNewPattern->GetItemSet(); +/*N*/ pSet->Put( *pFlagAttr ); +/*N*/ pDocument->ApplyPatternAreaTab( nThisCol, nThisStart, nMergeEndCol, nMergeEndRow, +/*N*/ nTab, *pNewPattern ); +/*N*/ delete pNewPattern; +/*N*/ +/*N*/ Search( nThisEnd, nIndex ); // Daten wurden veraendert !!! +/*N*/ } +/*N*/ +/*N*/ ++nIndex; +/*N*/ if ( nIndex < (short) nCount ) +/*N*/ nThisStart = pData[nIndex-1].nRow+1; +/*N*/ else +/*N*/ nThisStart = MAXROW+1; // Ende +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + + // Bereich loeschen, aber Merge-Flags stehenlassen + +/*N*/ void ScAttrArray::DeleteAreaSafe(USHORT nStartRow, USHORT nEndRow) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 SetPatternAreaSafe( nStartRow, nEndRow, pDocument->GetDefPattern(), TRUE ); +/*N*/ } + + + + +/*N*/ BOOL ScAttrArray::ApplyFlags( USHORT nStartRow, USHORT nEndRow, INT16 nFlags ) +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern; +/*N*/ +/*N*/ INT16 nOldValue; +/*N*/ short nIndex; +/*N*/ USHORT nRow; +/*N*/ USHORT nThisRow; +/*N*/ BOOL bChanged = FALSE; +/*N*/ +/*N*/ Search( nStartRow, nIndex ); +/*N*/ nThisRow = (nIndex>0) ? pData[nIndex-1].nRow+1 : 0; +/*N*/ if (nThisRow < nStartRow) nThisRow = nStartRow; +/*N*/ +/*N*/ while ( nThisRow <= nEndRow ) +/*N*/ { +/*N*/ pOldPattern = pData[nIndex].pPattern; +/*N*/ nOldValue = ((const ScMergeFlagAttr*) &pOldPattern->GetItem( ATTR_MERGE_FLAG ))->GetValue(); +/*N*/ if ( (nOldValue | nFlags) != nOldValue ) +/*N*/ { +/*N*/ nRow = pData[nIndex].nRow; +/*N*/ USHORT nAttrRow = Min( (USHORT)nRow, (USHORT)nEndRow ); +/*N*/ ScPatternAttr aNewPattern(*pOldPattern); +/*N*/ aNewPattern.GetItemSet().Put( ScMergeFlagAttr( nOldValue | nFlags ) ); +/*N*/ SetPatternArea( nThisRow, nAttrRow, &aNewPattern, TRUE ); +/*N*/ Search( nThisRow, nIndex ); // Daten wurden veraendert !!! +/*N*/ bChanged = TRUE; +/*N*/ } +/*N*/ +/*N*/ ++nIndex; +/*N*/ nThisRow = pData[nIndex-1].nRow+1; +/*N*/ } +/*N*/ +/*N*/ return bChanged; +/*N*/ } + + +/*N*/ BOOL ScAttrArray::RemoveFlags( USHORT nStartRow, USHORT nEndRow, INT16 nFlags ) +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern; +/*N*/ +/*N*/ INT16 nOldValue; +/*N*/ short nIndex; +/*N*/ USHORT nRow; +/*N*/ USHORT nThisRow; +/*N*/ BOOL bChanged = FALSE; +/*N*/ +/*N*/ Search( nStartRow, nIndex ); +/*N*/ nThisRow = (nIndex>0) ? pData[nIndex-1].nRow+1 : 0; +/*N*/ if (nThisRow < nStartRow) nThisRow = nStartRow; +/*N*/ +/*N*/ while ( nThisRow <= nEndRow ) +/*N*/ { +/*N*/ pOldPattern = pData[nIndex].pPattern; +/*N*/ nOldValue = ((const ScMergeFlagAttr*) &pOldPattern->GetItem( ATTR_MERGE_FLAG ))->GetValue(); +/*N*/ if ( (nOldValue & ~nFlags) != nOldValue ) +/*N*/ { +/*N*/ nRow = pData[nIndex].nRow; +/*N*/ USHORT nAttrRow = Min( (USHORT)nRow, (USHORT)nEndRow ); +/*N*/ ScPatternAttr aNewPattern(*pOldPattern); +/*N*/ aNewPattern.GetItemSet().Put( ScMergeFlagAttr( nOldValue & ~nFlags ) ); +/*N*/ SetPatternArea( nThisRow, nAttrRow, &aNewPattern, TRUE ); +/*N*/ Search( nThisRow, nIndex ); // Daten wurden veraendert !!! +/*N*/ bChanged = TRUE; +/*N*/ } +/*N*/ +/*N*/ ++nIndex; +/*N*/ nThisRow = pData[nIndex-1].nRow+1; +/*N*/ } +/*N*/ +/*N*/ return bChanged; +/*N*/ } + + +/*N*/ void ScAttrArray::ClearItems( USHORT nStartRow, USHORT nEndRow, const USHORT* pWhich ) +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern; +/*N*/ +/*N*/ short nIndex; +/*N*/ USHORT nRow; +/*N*/ USHORT nThisRow; +/*N*/ +/*N*/ Search( nStartRow, nIndex ); +/*N*/ nThisRow = (nIndex>0) ? pData[nIndex-1].nRow+1 : 0; +/*N*/ if (nThisRow < nStartRow) nThisRow = nStartRow; +/*N*/ +/*N*/ while ( nThisRow <= nEndRow ) +/*N*/ { +/*N*/ pOldPattern = pData[nIndex].pPattern; +/*N*/ if ( pOldPattern->HasItemsSet( pWhich ) ) +/*N*/ { +/*N*/ ScPatternAttr aNewPattern(*pOldPattern); +/*N*/ aNewPattern.ClearItems( pWhich ); +/*N*/ +/*N*/ nRow = pData[nIndex].nRow; +/*N*/ USHORT nAttrRow = Min( (USHORT)nRow, (USHORT)nEndRow ); +/*N*/ SetPatternArea( nThisRow, nAttrRow, &aNewPattern, TRUE ); +/*N*/ Search( nThisRow, nIndex ); // Daten wurden veraendert !!! +/*N*/ } +/*N*/ +/*N*/ ++nIndex; +/*N*/ nThisRow = pData[nIndex-1].nRow+1; +/*N*/ } +/*N*/ } + + + + + + +/*N*/ void ScAttrArray::FindStyleSheet( const SfxStyleSheetBase* pStyleSheet, BOOL* pUsed, BOOL bReset ) +/*N*/ { +/*N*/ USHORT nStart = 0; +/*N*/ short nPos = 0; +/*N*/ while (nPos < (short) nCount) +/*N*/ { +/*N*/ USHORT nEnd = pData[nPos].nRow; +/*N*/ if (pData[nPos].pPattern->GetStyleSheet() == pStyleSheet) +/*N*/ { +/*N*/ // for (USHORT nRow = nStart; nRow <= nEnd; nRow++) +/*N*/ // pUsed[nRow] = TRUE; +/*N*/ +/*N*/ memset( &pUsed[nStart], TRUE, nEnd-nStart+1 ); +/*N*/ +/*N*/ if (bReset) +/*N*/ { +/*?*/ ScPatternAttr* pNewPattern = new ScPatternAttr(*pData[nPos].pPattern); +/*?*/ pDocument->GetPool()->Remove(*pData[nPos].pPattern); +/*?*/ pNewPattern->SetStyleSheet( (ScStyleSheet*) +/*?*/ pDocument->GetStyleSheetPool()-> +/*?*/ Find( ScGlobal::GetRscString(STR_STYLENAME_STANDARD), +/*?*/ SFX_STYLE_FAMILY_PARA, +/*?*/ SFXSTYLEBIT_AUTO | SCSTYLEBIT_STANDARD ) ); +/*?*/ pData[nPos].pPattern = (const ScPatternAttr*) +/*?*/ &pDocument->GetPool()->Put(*pNewPattern); +/*?*/ delete pNewPattern; +/*?*/ +/*?*/ if (Concat(nPos)) +/*?*/ { +/*?*/ Search(nStart, nPos); +/*?*/ --nPos; // wegen ++ am Ende +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ nStart = nEnd + 1; +/*N*/ ++nPos; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScAttrArray::IsEmpty() const +/*N*/ { +/*N*/ if (nCount == 1) +/*N*/ { +/*N*/ if ( pData[0].pPattern != pDocument->GetDefPattern() ) +/*N*/ return FALSE; +/*N*/ else +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScAttrArray::HasVisibleAttr( USHORT& rFirstRow, USHORT& rLastRow, BOOL bSkipFirst ) const +/*N*/ { +/*N*/ DBG_ASSERT( nCount, "nCount == 0" ); +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nStart = 0; +/*N*/ +/*N*/ if ( bSkipFirst ) // Anfang ueberspringen, wenn >1 Zeile +/*N*/ { +/*N*/ USHORT nVisStart = 1; +/*N*/ while ( nVisStart < nCount && +/*N*/ pData[nVisStart].pPattern->IsVisibleEqual(*pData[nVisStart-1].pPattern) ) +/*N*/ ++nVisStart; +/*N*/ if ( nVisStart >= nCount || pData[nVisStart-1].nRow > 0 ) // mehr als 1 Zeile? +/*N*/ nStart = nVisStart; +/*N*/ } +/*N*/ +/*N*/ USHORT nVisCount = nCount-1; // am Ende zusammengehoerende weglassen +/*N*/ while ( nVisCount > nStart && +/*N*/ pData[nVisCount].pPattern->IsVisibleEqual(*pData[nVisCount-1].pPattern) ) +/*N*/ --nVisCount; +/*N*/ +/*N*/ while ( nStart < nVisCount && !bFound ) +/*N*/ { +/*N*/ if ( pData[nStart].pPattern->IsVisible() ) +/*N*/ { +/*N*/ rFirstRow = nStart ? ( pData[nStart-1].nRow + 1 ) : 0; +/*N*/ rLastRow = pData[nStart].nRow; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ else +/*N*/ ++nStart; +/*N*/ } +/*N*/ +/*N*/ if (!bFound) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bEnd = FALSE; +/*N*/ USHORT nPos = nVisCount; +/*N*/ while ( nPos > nStart && !bEnd ) +/*N*/ { +/*N*/ --nPos; +/*N*/ if ( pData[nPos].pPattern->IsVisible() ) +/*N*/ { +/*N*/ rLastRow = pData[nPos].nRow; +/*N*/ bEnd = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + + + +/*N*/ BOOL ScAttrArray::IsVisibleEqual( const ScAttrArray& rOther, +/*N*/ USHORT nStartRow, USHORT nEndRow ) const +/*N*/ { +/*N*/ BOOL bEqual = TRUE; +/*N*/ short nThisPos = 0; +/*N*/ short nOtherPos = 0; +/*N*/ if ( nStartRow ) +/*N*/ { +/*N*/ Search( nStartRow, nThisPos ); +/*N*/ rOther.Search( nStartRow, nOtherPos ); +/*N*/ } +/*N*/ +/*N*/ while ( nThisPos<nCount && nOtherPos<rOther.nCount && bEqual ) +/*N*/ { +/*N*/ USHORT nThisRow = pData[nThisPos].nRow; +/*N*/ USHORT nOtherRow = rOther.pData[nOtherPos].nRow; +/*N*/ const ScPatternAttr* pThisPattern = pData[nThisPos].pPattern; +/*N*/ const ScPatternAttr* pOtherPattern = rOther.pData[nOtherPos].pPattern; +/*N*/ bEqual = ( pThisPattern == pOtherPattern || +/*N*/ pThisPattern->IsVisibleEqual(*pOtherPattern) ); +/*N*/ +/*N*/ if ( nThisRow >= nOtherRow ) +/*N*/ { +/*N*/ if ( nOtherRow >= nEndRow ) break; +/*N*/ ++nOtherPos; +/*N*/ } +/*N*/ if ( nThisRow <= nOtherRow ) +/*N*/ { +/*N*/ if ( nThisRow >= nEndRow ) break; +/*N*/ ++nThisPos; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual; +/*N*/ } + + +/*N*/ BOOL ScAttrArray::IsAllEqual( const ScAttrArray& rOther, USHORT nStartRow, USHORT nEndRow ) const +/*N*/ { +/*N*/ //! mit IsVisibleEqual zusammenfassen? +/*N*/ +/*N*/ BOOL bEqual = TRUE; +/*N*/ short nThisPos = 0; +/*N*/ short nOtherPos = 0; +/*N*/ if ( nStartRow ) +/*N*/ { +/*?*/ Search( nStartRow, nThisPos ); +/*?*/ rOther.Search( nStartRow, nOtherPos ); +/*N*/ } +/*N*/ +/*N*/ while ( nThisPos<nCount && nOtherPos<rOther.nCount && bEqual ) +/*N*/ { +/*N*/ USHORT nThisRow = pData[nThisPos].nRow; +/*N*/ USHORT nOtherRow = rOther.pData[nOtherPos].nRow; +/*N*/ const ScPatternAttr* pThisPattern = pData[nThisPos].pPattern; +/*N*/ const ScPatternAttr* pOtherPattern = rOther.pData[nOtherPos].pPattern; +/*N*/ bEqual = ( pThisPattern == pOtherPattern ); +/*N*/ +/*N*/ if ( nThisRow >= nOtherRow ) +/*N*/ { +/*N*/ if ( nOtherRow >= nEndRow ) break; +/*N*/ ++nOtherPos; +/*N*/ } +/*N*/ if ( nThisRow <= nOtherRow ) +/*N*/ { +/*N*/ if ( nThisRow >= nEndRow ) break; +/*N*/ ++nThisPos; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual; +/*N*/ } + + +/*N*/ BOOL ScAttrArray::TestInsertCol( USHORT nStartRow, USHORT nEndRow) const +/*N*/ { +/*N*/ // horizontal zusammengefasste duerfen nicht herausgeschoben werden +/*N*/ // (ob die ganze Zusammenfassung betroffen ist, ist hier nicht zu erkennen) +/*N*/ +/*N*/ BOOL bTest = TRUE; +/*N*/ if (!IsEmpty()) +/*N*/ { +/*N*/ short nIndex = 0; +/*N*/ if ( nStartRow ) +/*N*/ Search( nStartRow, nIndex ); +/*N*/ +/*N*/ for ( ; nIndex < nCount; nIndex++ ) +/*N*/ { +/*N*/ if ( ((const ScMergeFlagAttr&)pData[nIndex].pPattern-> +/*N*/ GetItem(ATTR_MERGE_FLAG)).IsHorOverlapped() ) +/*N*/ { +/*N*/ bTest = FALSE; // darf nicht herausgeschoben werden +/*N*/ break; +/*N*/ } +/*N*/ if ( pData[nIndex].nRow >= nEndRow ) // Ende des Bereichs +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ return bTest; +/*N*/ } + + +/*N*/ BOOL ScAttrArray::TestInsertRow( USHORT nSize ) const +/*N*/ { +/*N*/ // wenn die erste herausgeschobene Zeile vertikal ueberlappt ist, +/*N*/ // wuerde eine kaputte Zusammenfassung uebrigbleiben +/*N*/ +/*N*/ if (pData) +/*N*/ { +/*N*/ // MAXROW + 1 - nSize = erste herausgeschobene Zeile +/*N*/ +/*N*/ USHORT nFirstLost = nCount-1; +/*N*/ while ( nFirstLost && pData[nFirstLost-1].nRow >= MAXROW + 1 - nSize ) +/*N*/ --nFirstLost; +/*N*/ +/*N*/ if ( ((const ScMergeFlagAttr&)pData[nFirstLost].pPattern-> +/*N*/ GetItem(ATTR_MERGE_FLAG)).IsVerOverlapped() ) +/*N*/ return FALSE; +/*N*/ } +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ void ScAttrArray::InsertRow( USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ if (!pData) +/*N*/ return; +/*N*/ +/*N*/ USHORT nSearch = nStartRow ? nStartRow - 1 : 0; // Vorgaenger erweitern +/*N*/ short nIndex; +/*N*/ Search( nSearch, nIndex ); +/*N*/ +/*N*/ // ein gesetztes ScMergeAttr darf nicht ausgedehnt werden +/*N*/ // (darum hinterher wieder loeschen) +/*N*/ +/*N*/ BOOL bDoMerge = ((const ScMergeAttr&) pData[nIndex].pPattern->GetItem(ATTR_MERGE)).IsMerged(); +/*N*/ +/*N*/ USHORT nRemove = 0; +/*N*/ USHORT i; +/*N*/ for (i = nIndex; i < nCount-1; i++) +/*N*/ { +/*N*/ USHORT nNew = pData[i].nRow + nSize; +/*N*/ if ( nNew >= MAXROW ) // Ende erreicht ? +/*N*/ { +/*N*/ nNew = MAXROW; +/*N*/ if (!nRemove) +/*N*/ nRemove = i+1; // folgende loeschen +/*N*/ } +/*N*/ pData[i].nRow = nNew; +/*N*/ } +/*N*/ +/*N*/ // muessen Eintraege am Ende geloescht werden? +/*N*/ +/*N*/ if (nRemove && nRemove < nCount) +/*N*/ DeleteRange( nRemove, nCount-1 ); +/*N*/ +/*N*/ if (bDoMerge) // ausgedehntes ScMergeAttr wieder reparieren +/*N*/ { +/*N*/ //! ApplyAttr fuer Bereiche !!! +/*N*/ +/*N*/ const SfxPoolItem& rDef = pDocument->GetPool()->GetDefaultItem( ATTR_MERGE ); +/*N*/ for (i=0; i<nSize; i++) +/*N*/ pDocument->ApplyAttr( nCol, nStartRow+i, nTab, rDef ); +/*N*/ +/*N*/ // im eingefuegten Bereich ist nichts zusammengefasst +/*N*/ } +/*N*/ +/*N*/ // Flags nicht duplizieren +/*N*/ //! direkt am Pattern testen ?? +/*N*/ RemoveFlags( nStartRow, nStartRow+nSize-1, SC_MF_HOR | SC_MF_VER | SC_MF_AUTO ); +/*N*/ } + + +/*N*/ void ScAttrArray::DeleteRow( USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ if (pData) +/*N*/ { +/*N*/ BOOL bFirst=TRUE; +/*N*/ USHORT nStartIndex; +/*N*/ USHORT nEndIndex; +/*N*/ USHORT i = 0; +/*N*/ for (i = 0; i < nCount-1; i++) +/*N*/ if (pData[i].nRow >= nStartRow && pData[i].nRow <= nStartRow+nSize-1) +/*N*/ { +/*N*/ if (bFirst) +/*N*/ { +/*N*/ nStartIndex = i; +/*N*/ bFirst = FALSE; +/*N*/ } +/*N*/ nEndIndex = i; +/*N*/ } +/*N*/ if (!bFirst) +/*N*/ { +/*N*/ USHORT nStart; +/*N*/ if (nStartIndex==0) +/*N*/ nStart = 0; +/*N*/ else +/*N*/ nStart = pData[nStartIndex-1].nRow + 1; +/*N*/ +/*N*/ if (nStart < nStartRow) +/*N*/ { +/*N*/ pData[nStartIndex].nRow = nStartRow - 1; +/*N*/ ++nStartIndex; +/*N*/ } +/*N*/ if (nEndIndex >= nStartIndex) +/*N*/ { +/*N*/ DeleteRange( nStartIndex, nEndIndex ); +/*N*/ if (nStartIndex > 0) +/*N*/ if ( pData[nStartIndex-1].pPattern == pData[nStartIndex].pPattern ) +/*N*/ DeleteRange( nStartIndex-1, nStartIndex-1 ); +/*N*/ } +/*N*/ } +/*N*/ for (i = 0; i < nCount-1; i++) +/*N*/ if (pData[i].nRow >= nStartRow) +/*N*/ pData[i].nRow -= nSize; +/*N*/ +/*N*/ // unten nicht Default-Pattern nachschieben, um Druckbereiche erkennen zu koennen +/*N*/ // stattdessen nur Merge-Flags loeschen +/*N*/ +/*N*/ RemoveFlags( MAXROW-nSize+1, MAXROW, SC_MF_HOR | SC_MF_VER | SC_MF_AUTO ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScAttrArray::DeleteRange( USHORT nStartIndex, USHORT nEndIndex ) +/*N*/ { +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ for (USHORT i = nStartIndex; i <= nEndIndex; i++) +/*N*/ pDocPool->Remove(*pData[i].pPattern); +/*N*/ +/*N*/ memmove( &pData[nStartIndex], &pData[nEndIndex + 1], (nCount - nEndIndex - 1) * sizeof(ScAttrEntry) ); +/*N*/ nCount -= nEndIndex-nStartIndex+1; +/*N*/ } + + +/*N*/ void ScAttrArray::DeleteArea(USHORT nStartRow, USHORT nEndRow) +/*N*/ { +/*N*/ RemoveAreaMerge( nStartRow, nEndRow ); // von zusammengefassten auch die Flags loeschen +/*N*/ +/*N*/ if ( !HasAttrib( nStartRow, nEndRow, HASATTR_OVERLAPPED | HASATTR_AUTOFILTER) ) +/*N*/ SetPatternArea( nStartRow, nEndRow, pDocument->GetDefPattern() ); +/*N*/ else +/*?*/ DeleteAreaSafe( nStartRow, nEndRow ); // Merge-Flags stehenlassen +/*N*/ } + + +/*N*/ void ScAttrArray::DeleteHardAttr(USHORT nStartRow, USHORT nEndRow) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 const ScPatternAttr* pDefPattern = pDocument->GetDefPattern(); +/*N*/ } + + // Verschieben innerhalb eines Dokuments + +/*N*/ void ScAttrArray::MoveTo(USHORT nStartRow, USHORT nEndRow, ScAttrArray& rAttrArray) +/*N*/ { +/*N*/ USHORT nStart = nStartRow; +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ if ((pData[i].nRow >= nStartRow) && ((i==0) ? TRUE : pData[i-1].nRow < nEndRow)) +/*N*/ { +/*N*/ // Kopieren (bPutToPool=TRUE) +/*N*/ rAttrArray.SetPatternArea( nStart, Min( (USHORT)pData[i].nRow, (USHORT)nEndRow ), +/*N*/ pData[i].pPattern, TRUE ); +/*N*/ } +/*N*/ nStart = Max( (USHORT)nStart, (USHORT)(pData[i].nRow + 1) ); +/*N*/ } +/*N*/ DeleteArea(nStartRow, nEndRow); +/*N*/ } + + + // Kopieren zwischen Dokumenten (Clipboard) + +/*N*/ void ScAttrArray::CopyArea( USHORT nStartRow, USHORT nEndRow, short nDy, ScAttrArray& rAttrArray, +/*N*/ INT16 nStripFlags ) +/*N*/ { +/*N*/ nStartRow -= nDy; // Source +/*N*/ nEndRow -= nDy; +/*N*/ +/*N*/ USHORT nDestStart = Max((short)((short)nStartRow + nDy), (short) 0); +/*N*/ USHORT nDestEnd = Min((short)((short)nEndRow + nDy), (short) MAXROW); +/*N*/ +/*N*/ ScDocumentPool* pSourceDocPool = pDocument->GetPool(); +/*N*/ ScDocumentPool* pDestDocPool = rAttrArray.pDocument->GetPool(); +/*N*/ BOOL bSamePool = (pSourceDocPool==pDestDocPool); +/*N*/ +/*N*/ for (USHORT i = 0; (i < nCount) && (nDestStart <= nDestEnd); i++) +/*N*/ { +/*N*/ if (pData[i].nRow >= nStartRow) +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern = pData[i].pPattern; +/*N*/ const ScPatternAttr* pNewPattern; +/*N*/ +/*N*/ if (IsDefaultItem( pOldPattern )) +/*N*/ { +/*N*/ // am Default muss nichts veraendert werden +/*N*/ +/*N*/ pNewPattern = (const ScPatternAttr*) +/*N*/ &pDestDocPool->GetDefaultItem( ATTR_PATTERN ); +/*N*/ } +/*N*/ else if ( nStripFlags ) +/*N*/ { +/*?*/ ScPatternAttr* pTmpPattern = new ScPatternAttr( *pOldPattern ); +/*?*/ INT16 nNewFlags = 0; +/*?*/ if ( nStripFlags != SC_MF_ALL ) +/*?*/ nNewFlags = ((const ScMergeFlagAttr&)pTmpPattern->GetItem(ATTR_MERGE_FLAG)). +/*?*/ GetValue() & ~nStripFlags; +/*?*/ +/*?*/ if ( nNewFlags ) +/*?*/ pTmpPattern->GetItemSet().Put( ScMergeFlagAttr( nNewFlags ) ); +/*?*/ else +/*?*/ pTmpPattern->GetItemSet().ClearItem( ATTR_MERGE_FLAG ); +/*?*/ +/*?*/ if (bSamePool) +/*?*/ pNewPattern = (ScPatternAttr*) &pDestDocPool->Put(*pTmpPattern); +/*?*/ else +/*?*/ pNewPattern = pTmpPattern->PutInPool( rAttrArray.pDocument, pDocument ); +/*?*/ delete pTmpPattern; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (bSamePool) +/*N*/ pNewPattern = (ScPatternAttr*) &pDestDocPool->Put(*pOldPattern); +/*N*/ else +/*N*/ pNewPattern = pOldPattern->PutInPool( rAttrArray.pDocument, pDocument ); +/*N*/ } +/*N*/ +/*N*/ rAttrArray.SetPatternArea(nDestStart, +/*N*/ Min((USHORT)(pData[i].nRow + nDy), nDestEnd), pNewPattern); +/*N*/ } +/*N*/ +/*N*/ // when pasting from clipboard and skipping filtered rows, the adjusted end position +/*N*/ // can be negative +/*N*/ nDestStart = Max((short)nDestStart, (short)(pData[i].nRow + nDy + 1)); +/*N*/ } +/*N*/ } + + // Flags stehenlassen + //! mit CopyArea zusammenfassen !!! + + + + + + +//------------------------------------------------------------------------ +// +// Laden / Speichern +// + + +/*N*/ void ScAttrArray::Save( SvStream& rStream ) const +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream, 8 ); +/*N*/ +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ +/*N*/ USHORT nSaveCount = nCount; +/*N*/ USHORT nSaveMaxRow = pDocument->GetSrcMaxRow(); +/*N*/ if ( nSaveMaxRow != MAXROW ) +/*N*/ { +/*?*/ if ( nSaveCount > 1 && pData[nSaveCount-2].nRow >= nSaveMaxRow ) +/*?*/ { +/*?*/ pDocument->SetLostData(); // Warnung ausgeben +/*?*/ do +/*?*/ --nSaveCount; +/*?*/ while ( nSaveCount > 1 && pData[nSaveCount-2].nRow >= nSaveMaxRow ); +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ rStream << nSaveCount; +/*N*/ +/*N*/ const SfxPoolItem* pItem; +/*N*/ for (USHORT i=0; i<nSaveCount; i++) +/*N*/ { +/*N*/ rStream << Min( pData[i].nRow, nSaveMaxRow ); +/*N*/ +/*N*/ const ScPatternAttr* pPattern = pData[i].pPattern; +/*N*/ pDocPool->StoreSurrogate( rStream, pPattern ); +/*N*/ +/*N*/ // FALSE, weil ATTR_CONDITIONAL (noch) nicht in Vorlagen: +/*N*/ if (pPattern->GetItemSet().GetItemState(ATTR_CONDITIONAL,FALSE,&pItem) == SFX_ITEM_SET) +/*N*/ pDocument->SetConditionalUsed( ((const SfxUInt32Item*)pItem)->GetValue() ); +/*N*/ +/*N*/ if (pPattern->GetItemSet().GetItemState(ATTR_VALIDDATA,FALSE,&pItem) == SFX_ITEM_SET) +/*N*/ pDocument->SetValidationUsed( ((const SfxUInt32Item*)pItem)->GetValue() ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScAttrArray::Load( SvStream& rStream ) +/*N*/ { +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ if ( nNewCount > MAXROW+1 ) // wuerde das Array zu gross? +/*N*/ { +/*?*/ pDocument->SetLostData(); +/*?*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ Reset( pDocument->GetDefPattern(), FALSE ); // loeschen +/*N*/ pData = new ScAttrEntry[nNewCount]; // neu anlegen +/*N*/ for (USHORT i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ rStream >> pData[i].nRow; +/*N*/ +/*N*/ USHORT nWhich = ATTR_PATTERN; +/*N*/ const ScPatternAttr* pNewPattern = (const ScPatternAttr*) +/*N*/ pDocPool->LoadSurrogate( rStream, nWhich, ATTR_PATTERN ); +/*N*/ if (!pNewPattern) +/*N*/ { +/*?*/ // da is was schiefgelaufen +/*?*/ DBG_ERROR("ScAttrArray::Load: Surrogat nicht im Pool"); +/*?*/ pNewPattern = pDocument->GetDefPattern(); +/*N*/ } +/*N*/ ScDocumentPool::CheckRef( *pNewPattern ); +/*N*/ pData[i].pPattern = pNewPattern; +/*N*/ +/*N*/ // LoadSurrogate erhoeht auch die Ref +/*N*/ } +/*N*/ nCount = nLimit = nNewCount; +/*N*/ +/*N*/ if ( nCount > 1 && pData[nCount-2].nRow >= MAXROW ) // faengt ein Attribut hinter MAXROW an? +/*N*/ { +/*?*/ pDocument->SetLostData(); +/*?*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ if ( pDocument->GetSrcMaxRow() != MAXROW ) // Ende anpassen? +/*N*/ { +/*N*/ // Ende immer auf MAXROW umsetzen (nur auf 32 Bit) +/*N*/ +/*N*/ DBG_ASSERT( pData[nCount-1].nRow == pDocument->GetSrcMaxRow(), "Attribut-Ende ?!?" ); +/*N*/ pData[nCount-1].nRow = MAXROW; +/*N*/ } +/*N*/ } + + +/*N*/ void ScAttrArray::ConvertFontsAfterLoad() +/*N*/ { +/*N*/ ScFontToSubsFontConverter_AutoPtr xFontConverter; +/*N*/ const ULONG nFlags = FONTTOSUBSFONT_IMPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS; +/*N*/ short nIndex = 0; +/*N*/ USHORT nThisRow = 0; +/*N*/ +/*N*/ while ( nThisRow <= MAXROW ) +/*N*/ { +/*N*/ const ScPatternAttr* pOldPattern = pData[nIndex].pPattern; +/*N*/ const SfxPoolItem* pItem; +/*N*/ if( pOldPattern->GetItemSet().GetItemState( ATTR_FONT, FALSE, &pItem ) == SFX_ITEM_SET ) +/*N*/ { +/*N*/ const SvxFontItem* pFontItem = (const SvxFontItem*) pItem; +/*N*/ const String& rOldName = pFontItem->GetFamilyName(); +/*N*/ xFontConverter = CreateFontToSubsFontConverter( rOldName, nFlags ); +/*N*/ if ( xFontConverter ) +/*N*/ { +/*N*/ String aNewName( GetFontToSubsFontName( xFontConverter ) ); +/*N*/ if ( aNewName != rOldName ) +/*N*/ { +/*N*/ USHORT nAttrRow = pData[nIndex].nRow; +/*N*/ SvxFontItem aNewItem( pFontItem->GetFamily(), aNewName, +/*N*/ pFontItem->GetStyleName(), pFontItem->GetPitch(), +/*N*/ RTL_TEXTENCODING_DONTKNOW, ATTR_FONT ); +/*N*/ ScPatternAttr aNewPattern( *pOldPattern ); +/*N*/ aNewPattern.GetItemSet().Put( aNewItem ); +/*N*/ SetPatternArea( nThisRow, nAttrRow, &aNewPattern, TRUE ); +/*N*/ Search( nThisRow, nIndex ); //! data changed +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ ++nIndex; +/*N*/ nThisRow = pData[nIndex-1].nRow+1; +/*N*/ } +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_attrib.cxx b/binfilter/bf_sc/source/core/data/sc_attrib.cxx new file mode 100644 index 000000000000..0b59fbcb91f3 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_attrib.cxx @@ -0,0 +1,1180 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + +#include <com/sun/star/util/CellProtection.hpp> + +#include "scitems.hxx" +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/boxitem.hxx> +#include <bf_svx/editobj.hxx> + + + +#include <bf_svx/itemdata.hxx> + +#include <tools/date.hxx> + +#include <tools/time.hxx> + +#include <bf_svx/flditem.hxx> + +#include "attrib.hxx" +#include "editutil.hxx" +#include "bf_sc.hrc" +#include "globstr.hrc" + +#include "textuno.hxx" // ScHeaderFooterContentObj +namespace binfilter { + +using namespace ::com::sun::star; + +//------------------------------------------------------------------------ + +/*N*/ TYPEINIT1(ScMergeAttr, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(ScProtectionAttr, SfxPoolItem); +/*N*/ TYPEINIT1(ScRangeItem, SfxPoolItem); +/*N*/ TYPEINIT1(ScTableListItem, SfxPoolItem); +/*N*/ TYPEINIT1(ScPageHFItem, SfxPoolItem); +/*N*/ TYPEINIT1(ScViewObjectModeItem, SfxEnumItem); +/*N*/ TYPEINIT1(ScDoubleItem, SfxPoolItem); + +//------------------------------------------------------------------------ + +// +// Item - Implementierungen +// + +//------------------------------------------------------------------------ +// Merge +//------------------------------------------------------------------------ + +/*N*/ ScMergeAttr::ScMergeAttr(): +/*N*/ SfxPoolItem(ATTR_MERGE), +/*N*/ nColMerge(0), +/*N*/ nRowMerge(0) +/*N*/ {} + +//------------------------------------------------------------------------ + +/*N*/ ScMergeAttr::ScMergeAttr( INT16 nCol, INT16 nRow): +/*N*/ SfxPoolItem(ATTR_MERGE), +/*N*/ nColMerge(nCol), +/*N*/ nRowMerge(nRow) +/*N*/ {} + +//------------------------------------------------------------------------ + +/*N*/ ScMergeAttr::ScMergeAttr(const ScMergeAttr& rItem): +/*N*/ SfxPoolItem(ATTR_MERGE) +/*N*/ { +/*N*/ nColMerge = rItem.nColMerge; +/*N*/ nRowMerge = rItem.nRowMerge; +/*N*/ } + +/*N*/ __EXPORT ScMergeAttr::~ScMergeAttr() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ int __EXPORT ScMergeAttr::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( Which() != rItem.Which() || Type() == rItem.Type(), "which ==, type !=" ); +/*N*/ return (Which() == rItem.Which()) +/*N*/ && (nColMerge == ((ScMergeAttr&)rItem).nColMerge) +/*N*/ && (nRowMerge == ((ScMergeAttr&)rItem).nRowMerge); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScMergeAttr::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new ScMergeAttr(*this); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScMergeAttr::Create( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ INT16 nCol; +/*N*/ INT16 nRow; +/*N*/ rStream >> nCol; +/*N*/ rStream >> nRow; +/*N*/ return new ScMergeAttr(nCol,nRow); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& __EXPORT ScMergeAttr::Store( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ rStream << nColMerge; +/*N*/ rStream << nRowMerge; +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ +// MergeFlag +//------------------------------------------------------------------------ + +/*N*/ ScMergeFlagAttr::ScMergeFlagAttr(): +/*N*/ SfxInt16Item(ATTR_MERGE_FLAG, 0) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScMergeFlagAttr::ScMergeFlagAttr(INT16 nFlags): +/*N*/ SfxInt16Item(ATTR_MERGE_FLAG, nFlags) +/*N*/ { +/*N*/ } + +/*N*/ __EXPORT ScMergeFlagAttr::~ScMergeFlagAttr() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ +// Protection +//------------------------------------------------------------------------ + +/*N*/ ScProtectionAttr::ScProtectionAttr(): +/*N*/ SfxPoolItem(ATTR_PROTECTION), +/*N*/ bProtection(TRUE), +/*N*/ bHideFormula(FALSE), +/*N*/ bHideCell(FALSE), +/*N*/ bHidePrint(FALSE) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScProtectionAttr::ScProtectionAttr( BOOL bProtect, BOOL bHFormula, +/*N*/ BOOL bHCell, BOOL bHPrint): +/*N*/ SfxPoolItem(ATTR_PROTECTION), +/*N*/ bProtection(bProtect), +/*N*/ bHideFormula(bHFormula), +/*N*/ bHideCell(bHCell), +/*N*/ bHidePrint(bHPrint) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScProtectionAttr::ScProtectionAttr(const ScProtectionAttr& rItem): +/*N*/ SfxPoolItem(ATTR_PROTECTION) +/*N*/ { +/*N*/ bProtection = rItem.bProtection; +/*N*/ bHideFormula = rItem.bHideFormula; +/*N*/ bHideCell = rItem.bHideCell; +/*N*/ bHidePrint = rItem.bHidePrint; +/*N*/ } + +/*N*/ __EXPORT ScProtectionAttr::~ScProtectionAttr() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ bool __EXPORT ScProtectionAttr::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case 0 : +/*N*/ { +/*N*/ util::CellProtection aProtection; +/*N*/ aProtection.IsLocked = bProtection; +/*N*/ aProtection.IsFormulaHidden = bHideFormula; +/*N*/ aProtection.IsHidden = bHideCell; +/*N*/ aProtection.IsPrintHidden = bHidePrint; +/*N*/ rVal <<= aProtection; +/*N*/ break; +/*N*/ } +/*N*/ case MID_1 : +/*N*/ rVal <<= (sal_Bool ) bProtection; break; +/*N*/ case MID_2 : +/*N*/ rVal <<= (sal_Bool ) bHideFormula; break; +/*N*/ case MID_3 : +/*N*/ rVal <<= (sal_Bool ) bHideCell; break; +/*N*/ case MID_4 : +/*N*/ rVal <<= (sal_Bool ) bHidePrint; break; +/*N*/ default: +/*N*/ DBG_ERROR("Wrong MemberID!"); +/*N*/ return false; +/*N*/ } +/*N*/ +/*N*/ return true; +/*N*/ } + +/*N*/ bool __EXPORT ScProtectionAttr::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ bool bRet = false; +/*N*/ sal_Bool bVal; +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case 0 : +/*N*/ { +/*N*/ util::CellProtection aProtection; +/*N*/ if ( rVal >>= aProtection ) +/*N*/ { +/*N*/ bProtection = aProtection.IsLocked; +/*N*/ bHideFormula = aProtection.IsFormulaHidden; +/*N*/ bHideCell = aProtection.IsHidden; +/*N*/ bHidePrint = aProtection.IsPrintHidden; +/*N*/ bRet = true; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("exception - wrong argument"); +/*N*/ break; +/*N*/ } +/*N*/ case MID_1 : +/*N*/ bRet = (rVal >>= bVal); if (bRet) bProtection=bVal; break; +/*N*/ case MID_2 : +/*N*/ bRet = (rVal >>= bVal); if (bRet) bHideFormula=bVal; break; +/*N*/ case MID_3 : +/*N*/ bRet = (rVal >>= bVal); if (bRet) bHideCell=bVal; break; +/*N*/ case MID_4 : +/*N*/ bRet = (rVal >>= bVal); if (bRet) bHidePrint=bVal; break; +/*N*/ default: +/*N*/ DBG_ERROR("Wrong MemberID!"); +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ int __EXPORT ScProtectionAttr::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( Which() != rItem.Which() || Type() == rItem.Type(), "which ==, type !=" ); +/*N*/ return (Which() == rItem.Which()) +/*N*/ && (bProtection == ((ScProtectionAttr&)rItem).bProtection) +/*N*/ && (bHideFormula == ((ScProtectionAttr&)rItem).bHideFormula) +/*N*/ && (bHideCell == ((ScProtectionAttr&)rItem).bHideCell) +/*N*/ && (bHidePrint == ((ScProtectionAttr&)rItem).bHidePrint); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScProtectionAttr::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new ScProtectionAttr(*this); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScProtectionAttr::Create( SvStream& rStream, USHORT n ) const +/*N*/ { +/*N*/ BOOL bProtect; +/*N*/ BOOL bHFormula; +/*N*/ BOOL bHCell; +/*N*/ BOOL bHPrint; +/*N*/ +/*N*/ rStream >> bProtect; +/*N*/ rStream >> bHFormula; +/*N*/ rStream >> bHCell; +/*N*/ rStream >> bHPrint; +/*N*/ +/*N*/ return new ScProtectionAttr(bProtect,bHFormula,bHCell,bHPrint); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& __EXPORT ScProtectionAttr::Store( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ rStream << bProtection; +/*N*/ rStream << bHideFormula; +/*N*/ rStream << bHideCell; +/*N*/ rStream << bHidePrint; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- +// ScRangeItem - Tabellenbereich +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ int __EXPORT ScRangeItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( aRange == ( (ScRangeItem&)rAttr ).aRange ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* __EXPORT ScRangeItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new ScRangeItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + + +//----------------------------------------------------------------------- + +/*N*/ USHORT __EXPORT ScRangeItem::GetVersion( USHORT nFileVersion ) const +/*N*/ { +/*N*/ return 2; +/*N*/ } + +//----------------------------------------------------------------------- + +/*N*/ SvStream& __EXPORT ScRangeItem::Store( SvStream& rStrm, USHORT nVer ) const +/*N*/ { +/*N*/ rStrm << aRange; +/*N*/ rStrm << nFlags; +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +//----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* __EXPORT ScRangeItem::Create( SvStream& rStream, USHORT nVersion ) const +/*N*/ { +/*N*/ ScRange aNewRange; +/*N*/ BOOL nNewFlags = FALSE; +/*N*/ +/*N*/ switch ( nVersion ) +/*N*/ { +/*N*/ case 2: +/*N*/ rStream >> aNewRange; +/*N*/ rStream >> nNewFlags; +/*N*/ break; +/*N*/ +/*N*/ case 1: +/*N*/ rStream >> aNewRange; +/*N*/ nNewFlags = 0; +/*N*/ break; +/*N*/ +/*N*/ case 0: +/*N*/ { +/*N*/ // alte Version mit ScArea -> 5 USHORTs lesen +/*N*/ ScAddress& rStart = aNewRange.aStart; +/*N*/ ScAddress& rEnd = aNewRange.aEnd; +/*N*/ USHORT n; +/*N*/ +/*N*/ rStream >> n; +/*N*/ +/*N*/ if ( n > MAXTAB ) +/*N*/ { +/*N*/ nNewFlags = SCR_ALLTABS; +/*N*/ rStart.SetTab( 0 ); rEnd.SetTab( 0 ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nNewFlags = 0; +/*N*/ rStart.SetTab( n ); rEnd.SetTab( n ); +/*N*/ } +/*N*/ +/*N*/ rStream >> n; rStart.SetCol( n ); +/*N*/ rStream >> n; rStart.SetRow( n ); +/*N*/ rStream >> n; rEnd .SetCol( n ); +/*N*/ rStream >> n; rEnd .SetRow( n ); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ DBG_ERROR( "ScRangeItem::Create: Unknown Version!" ); +/*N*/ } +/*N*/ +/*N*/ return ( new ScRangeItem( Which(), aNewRange, nNewFlags ) ); +/*N*/ } + + +// ----------------------------------------------------------------------- +// ScTableListItem - Liste von Tabellen(-nummern) +// ----------------------------------------------------------------------- + +/*N*/ ScTableListItem::ScTableListItem( const ScTableListItem& rCpy ) +/*N*/ : SfxPoolItem ( rCpy.Which() ), +/*N*/ nCount ( rCpy.nCount ) +/*N*/ { +/*N*/ if ( nCount > 0 ) +/*N*/ { +/*N*/ pTabArr = new USHORT [nCount]; +/*N*/ +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ pTabArr[i] = rCpy.pTabArr[i]; +/*N*/ } +/*N*/ else +/*N*/ pTabArr = NULL; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScTableListItem::ScTableListItem( const USHORT nWhich, const List& rList ) +/*N*/ : SfxPoolItem ( nWhich ), +/*N*/ nCount ( 0 ), +/*N*/ pTabArr ( NULL ) +/*N*/ { +/*N*/ SetTableList( rList ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ __EXPORT ScTableListItem::~ScTableListItem() +/*N*/ { +/*N*/ delete [] pTabArr; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ int __EXPORT ScTableListItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ ScTableListItem& rCmp = (ScTableListItem&)rAttr; +/*N*/ BOOL bEqual = (nCount == rCmp.nCount); +/*N*/ +/*N*/ if ( nCount > 0 ) +/*N*/ { +/*N*/ USHORT i=0; +/*N*/ +/*N*/ bEqual = ( pTabArr && rCmp.pTabArr ); +/*N*/ +/*N*/ while ( bEqual && i<nCount ) +/*N*/ { +/*N*/ bEqual = ( pTabArr[i] == rCmp.pTabArr[i] ); +/*N*/ i++; +/*N*/ } +/*N*/ } +/*N*/ return bEqual; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* __EXPORT ScTableListItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new ScTableListItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + + +//----------------------------------------------------------------------- + +/*N*/ SvStream& __EXPORT ScTableListItem::Store( SvStream& rStrm, USHORT nVer ) const +/*N*/ { +/*N*/ rStrm << nCount; +/*N*/ +/*N*/ if ( nCount>0 && pTabArr ) +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ rStrm << pTabArr[i]; +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +//----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* __EXPORT ScTableListItem::Create( SvStream& rStrm, USHORT ) const +/*N*/ { +/*N*/ ScTableListItem* pNewItem; +/*N*/ List aList; +/*N*/ USHORT* p; +/*N*/ USHORT nTabCount; +/*N*/ USHORT nTabNo; +/*N*/ +/*N*/ rStrm >> nTabCount; +/*N*/ +/*N*/ if ( nTabCount > 0 ) +/*N*/ { +/*N*/ for ( USHORT i=0; i<nTabCount; i++ ) +/*N*/ { +/*N*/ rStrm >> nTabNo; +/*N*/ aList.Insert( new USHORT(nTabNo) ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pNewItem = new ScTableListItem( Which(), aList ); +/*N*/ +/*N*/ aList.First(); +/*N*/ while ( p = (USHORT*)aList.Remove() ) +/*N*/ delete p; +/*N*/ +/*N*/ return pNewItem; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ void ScTableListItem::SetTableList( const List& rList ) +/*N*/ { +/*N*/ nCount = (USHORT)rList.Count(); +/*N*/ +/*N*/ delete [] pTabArr; +/*N*/ +/*N*/ if ( nCount > 0 ) +/*N*/ { +/*N*/ pTabArr = new USHORT [nCount]; +/*N*/ +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ pTabArr[i] = *( (USHORT*)rList.GetObject( i ) ); +/*N*/ } +/*N*/ else +/*N*/ pTabArr = NULL; +/*N*/ } + + +// ----------------------------------------------------------------------- +// ScPageHFItem - Daten der Kopf-/Fußzeilen +// ----------------------------------------------------------------------- + +/*N*/ ScPageHFItem::ScPageHFItem( USHORT nWhich ) +/*N*/ : SfxPoolItem ( nWhich ), +/*N*/ pLeftArea ( NULL ), +/*N*/ pCenterArea ( NULL ), +/*N*/ pRightArea ( NULL ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScPageHFItem::ScPageHFItem( const ScPageHFItem& rItem ) +/*N*/ : SfxPoolItem ( rItem ), +/*N*/ pLeftArea ( NULL ), +/*N*/ pCenterArea ( NULL ), +/*N*/ pRightArea ( NULL ) +/*N*/ { +/*N*/ if ( rItem.pLeftArea ) +/*N*/ pLeftArea = rItem.pLeftArea->Clone(); +/*N*/ if ( rItem.pCenterArea ) +/*N*/ pCenterArea = rItem.pCenterArea->Clone(); +/*N*/ if ( rItem.pRightArea ) +/*N*/ pRightArea = rItem.pRightArea->Clone(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScPageHFItem::~ScPageHFItem() +/*N*/ { +/*N*/ delete pLeftArea; +/*N*/ delete pCenterArea; +/*N*/ delete pRightArea; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ bool __EXPORT ScPageHFItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ uno::Reference<sheet::XHeaderFooterContent> xContent = +/*N*/ new ScHeaderFooterContentObj( pLeftArea, pCenterArea, pRightArea ); +/*N*/ +/*N*/ rVal <<= xContent; +/*N*/ return true; +/*N*/ } + +/*N*/ bool __EXPORT ScPageHFItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ bool bRet = false; +/*N*/ uno::Reference<sheet::XHeaderFooterContent> xContent; +/*N*/ if ( rVal >>= xContent ) +/*N*/ { +/*N*/ if ( xContent.is() ) +/*N*/ { +/*N*/ ScHeaderFooterContentObj* pImp = +/*N*/ ScHeaderFooterContentObj::getImplementation( xContent ); +/*N*/ if (pImp) +/*N*/ { +/*N*/ const EditTextObject* pImpLeft = pImp->GetLeftEditObject(); +/*N*/ delete pLeftArea; +/*N*/ pLeftArea = pImpLeft ? pImpLeft->Clone() : NULL; +/*N*/ +/*N*/ const EditTextObject* pImpCenter = pImp->GetCenterEditObject(); +/*N*/ delete pCenterArea; +/*N*/ pCenterArea = pImpCenter ? pImpCenter->Clone() : NULL; +/*N*/ +/*N*/ const EditTextObject* pImpRight = pImp->GetRightEditObject(); +/*N*/ delete pRightArea; +/*N*/ pRightArea = pImpRight ? pImpRight->Clone() : NULL; +/*N*/ +/*N*/ if ( !pLeftArea || !pCenterArea || !pRightArea ) +/*N*/ { +/*?*/ // keine Texte auf NULL stehen lassen +/*?*/ ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), TRUE ); +/*?*/ if (!pLeftArea) +/*?*/ pLeftArea = aEngine.CreateTextObject(); +/*?*/ if (!pCenterArea) +/*?*/ pCenterArea = aEngine.CreateTextObject(); +/*?*/ if (!pRightArea) +/*?*/ pRightArea = aEngine.CreateTextObject(); +/*N*/ } +/*N*/ +/*N*/ bRet = true; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!bRet) +/*N*/ { +/*N*/ DBG_ERROR("exception - wrong argument"); +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ String __EXPORT ScPageHFItem::GetValueText() const +/*N*/ { +/*N*/ return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScPageHFItem")); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ int __EXPORT ScPageHFItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" ); +/*N*/ +/*N*/ const ScPageHFItem& r = (const ScPageHFItem&)rItem; +/*N*/ +/*N*/ return ScGlobal::EETextObjEqual(pLeftArea, r.pLeftArea) +/*N*/ && ScGlobal::EETextObjEqual(pCenterArea, r.pCenterArea) +/*N*/ && ScGlobal::EETextObjEqual(pRightArea, r.pRightArea); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScPageHFItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new ScPageHFItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ USHORT __EXPORT ScPageHFItem::GetVersion( USHORT nFileVersion ) const +/*N*/ { +/*N*/ // 0 = ohne Feldbefehle +/*N*/ // 1 = Titel bzw. Dateiname mit SvxFileField +/*N*/ // 2 = Pfad und/oder Dateiname mit SvxExtFileField, Titel mit SvxFileField +/*N*/ return 2; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void lcl_SetSpace( String& rStr, const ESelection& rSel ) +/*N*/ { +/*N*/ // Text durch ein Leerzeichen ersetzen, damit Positionen stimmen: +/*N*/ +/*N*/ xub_StrLen nLen = rSel.nEndPos-rSel.nStartPos; +/*N*/ rStr.Erase( rSel.nStartPos, nLen-1 ); +/*N*/ rStr.SetChar( rSel.nStartPos, ' ' ); +/*N*/ } + +/*N*/ BOOL lcl_ConvertFields(EditEngine& rEng, const String* pCommands) +/*N*/ { +/*N*/ BOOL bChange = FALSE; +/*N*/ USHORT nParCnt = rEng.GetParagraphCount(); +/*N*/ for (USHORT nPar = 0; nPar<nParCnt; nPar++) +/*N*/ { +/*N*/ String aStr = rEng.GetText( nPar ); +/*N*/ xub_StrLen nPos; +/*N*/ +/*N*/ while ((nPos = aStr.Search(pCommands[0])) != STRING_NOTFOUND) +/*N*/ { +/*N*/ ESelection aSel( nPar,nPos, nPar,nPos+pCommands[0].Len() ); +/*N*/ rEng.QuickInsertField( SvxFieldItem(SvxPageField()), aSel ); +/*N*/ lcl_SetSpace(aStr, aSel ); bChange = TRUE; +/*N*/ } +/*N*/ while ((nPos = aStr.Search(pCommands[1])) != STRING_NOTFOUND) +/*N*/ { +/*N*/ ESelection aSel( nPar,nPos, nPar,nPos+pCommands[1].Len() ); +/*N*/ rEng.QuickInsertField( SvxFieldItem(SvxPagesField()), aSel ); +/*N*/ lcl_SetSpace(aStr, aSel ); bChange = TRUE; +/*N*/ } +/*N*/ while ((nPos = aStr.Search(pCommands[2])) != STRING_NOTFOUND) +/*N*/ { +/*N*/ ESelection aSel( nPar,nPos, nPar,nPos+pCommands[2].Len() ); +/*N*/ rEng.QuickInsertField( SvxFieldItem(SvxDateField(Date(),SVXDATETYPE_VAR)), aSel ); +/*N*/ lcl_SetSpace(aStr, aSel ); bChange = TRUE; +/*N*/ } +/*N*/ while ((nPos = aStr.Search(pCommands[3])) != STRING_NOTFOUND) +/*N*/ { +/*N*/ ESelection aSel( nPar,nPos, nPar,nPos+pCommands[3].Len() ); +/*N*/ rEng.QuickInsertField( SvxFieldItem(SvxTimeField()), aSel ); +/*N*/ lcl_SetSpace(aStr, aSel ); bChange = TRUE; +/*N*/ } +/*N*/ while ((nPos = aStr.Search(pCommands[4])) != STRING_NOTFOUND) +/*N*/ { +/*N*/ ESelection aSel( nPar,nPos, nPar,nPos+pCommands[4].Len() ); +/*N*/ rEng.QuickInsertField( SvxFieldItem(SvxFileField()), aSel ); +/*N*/ lcl_SetSpace(aStr, aSel ); bChange = TRUE; +/*N*/ } +/*N*/ while ((nPos = aStr.Search(pCommands[5])) != STRING_NOTFOUND) +/*N*/ { +/*N*/ ESelection aSel( nPar,nPos, nPar,nPos+pCommands[5].Len() ); +/*N*/ rEng.QuickInsertField( SvxFieldItem(SvxTableField()), aSel ); +/*N*/ lcl_SetSpace(aStr, aSel ); bChange = TRUE; +/*N*/ } +/*N*/ } +/*N*/ return bChange; +/*N*/ } + +#define SC_FIELD_COUNT 6 + +/*N*/ SfxPoolItem* __EXPORT ScPageHFItem::Create( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ EditTextObject* pLeft = EditTextObject::Create(rStream); +/*N*/ EditTextObject* pCenter = EditTextObject::Create(rStream); +/*N*/ EditTextObject* pRight = EditTextObject::Create(rStream); +/*N*/ +/*N*/ DBG_ASSERT( pLeft && pCenter && pRight, "Error reading ScPageHFItem" ); +/*N*/ +/*N*/ if ( pLeft == NULL || pLeft->GetParagraphCount() == 0 || +/*N*/ pCenter == NULL || pCenter->GetParagraphCount() == 0 || +/*N*/ pRight == NULL || pRight->GetParagraphCount() == 0 ) +/*N*/ { +/*?*/ // If successfully loaded, each object contains at least one paragraph. +/*?*/ // Excel import in 5.1 created broken TextObjects (#67442#) that are +/*?*/ // corrected here to avoid saving wrong files again (#90487#). +/*?*/ +/*?*/ ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), TRUE ); +/*?*/ if ( pLeft == NULL || pLeft->GetParagraphCount() == 0 ) +/*?*/ { +/*?*/ delete pLeft; +/*?*/ pLeft = aEngine.CreateTextObject(); +/*?*/ } +/*?*/ if ( pCenter == NULL || pCenter->GetParagraphCount() == 0 ) +/*?*/ { +/*?*/ delete pCenter; +/*?*/ pCenter = aEngine.CreateTextObject(); +/*?*/ } +/*?*/ if ( pRight == NULL || pRight->GetParagraphCount() == 0 ) +/*?*/ { +/*?*/ delete pRight; +/*?*/ pRight = aEngine.CreateTextObject(); +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ if ( nVer < 1 ) // alte Feldbefehle umsetzen +/*N*/ { +/*N*/ USHORT i; +/*N*/ const String& rDel = ScGlobal::GetRscString( STR_HFCMD_DELIMITER ); +/*N*/ String aCommands[SC_FIELD_COUNT]; +/*N*/ for (i=0; i<SC_FIELD_COUNT; i++) +/*N*/ aCommands[i] = rDel; +/*N*/ aCommands[0] += ScGlobal::GetRscString(STR_HFCMD_PAGE); +/*N*/ aCommands[1] += ScGlobal::GetRscString(STR_HFCMD_PAGES); +/*N*/ aCommands[2] += ScGlobal::GetRscString(STR_HFCMD_DATE); +/*N*/ aCommands[3] += ScGlobal::GetRscString(STR_HFCMD_TIME); +/*N*/ aCommands[4] += ScGlobal::GetRscString(STR_HFCMD_FILE); +/*N*/ aCommands[5] += ScGlobal::GetRscString(STR_HFCMD_TABLE); +/*N*/ for (i=0; i<SC_FIELD_COUNT; i++) +/*N*/ aCommands[i] += rDel; +/*N*/ +/*N*/ ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), TRUE ); +/*N*/ aEngine.SetText(*pLeft); +/*N*/ if (lcl_ConvertFields(aEngine,aCommands)) +/*N*/ { +/*?*/ delete pLeft; +/*?*/ pLeft = aEngine.CreateTextObject(); +/*N*/ } +/*N*/ aEngine.SetText(*pCenter); +/*N*/ if (lcl_ConvertFields(aEngine,aCommands)) +/*N*/ { +/*?*/ delete pCenter; +/*?*/ pCenter = aEngine.CreateTextObject(); +/*N*/ } +/*N*/ aEngine.SetText(*pRight); +/*N*/ if (lcl_ConvertFields(aEngine,aCommands)) +/*N*/ { +/*?*/ delete pRight; +/*?*/ pRight = aEngine.CreateTextObject(); +/*N*/ } +/*N*/ } +/*N*/ else if ( nVer < 2 ) +/*N*/ { // nichts tun, SvxFileField nicht gegen SvxExtFileField austauschen +/*N*/ } +/*N*/ +/*N*/ ScPageHFItem* pItem = new ScPageHFItem( Which() ); +/*N*/ pItem->SetArea( pLeft, SC_HF_LEFTAREA ); +/*N*/ pItem->SetArea( pCenter, SC_HF_CENTERAREA ); +/*N*/ pItem->SetArea( pRight, SC_HF_RIGHTAREA ); +/*N*/ +/*N*/ return pItem; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ class ScFieldChangerEditEngine : public ScEditEngineDefaulter +/*N*/ { +/*N*/ TypeId aExtFileId; +/*N*/ USHORT nConvPara; +/*N*/ xub_StrLen nConvPos; +/*N*/ BOOL bConvert; +/*N*/ +/*N*/ public: +/*N*/ ScFieldChangerEditEngine( SfxItemPool* pEnginePool, BOOL bDeleteEnginePool ); +/*N*/ virtual ~ScFieldChangerEditEngine() {} +/*N*/ +/*N*/ virtual String CalcFieldValue( const SvxFieldItem& rField, USHORT nPara, +/*N*/ USHORT nPos, Color*& rTxtColor, +/*N*/ Color*& rFldColor ); +/*N*/ +/*N*/ BOOL ConvertFields(); +/*N*/ }; +/*N*/ +/*N*/ ScFieldChangerEditEngine::ScFieldChangerEditEngine( SfxItemPool* pEnginePool, +/*N*/ BOOL bDeleteEnginePool ) : +/*N*/ ScEditEngineDefaulter( pEnginePool, bDeleteEnginePool ), +/*N*/ aExtFileId( TYPE( SvxExtFileField ) ), +/*N*/ nConvPara( 0 ), +/*N*/ nConvPos( 0 ), +/*N*/ bConvert( FALSE ) +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ String ScFieldChangerEditEngine::CalcFieldValue( const SvxFieldItem& rField, +/*N*/ USHORT nPara, USHORT nPos, Color*& rTxtColor, Color*& rFldColor ) +/*N*/ { +/*N*/ const SvxFieldData* pFieldData = rField.GetField(); +/*N*/ if ( pFieldData && pFieldData->Type() == aExtFileId ) +/*N*/ { +/*N*/ bConvert = TRUE; +/*N*/ nConvPara = nPara; +/*N*/ nConvPos = nPos; +/*N*/ } +/*N*/ return EMPTY_STRING; +/*N*/ } +/*N*/ +/*N*/ BOOL ScFieldChangerEditEngine::ConvertFields() +/*N*/ { +/*N*/ BOOL bConverted = FALSE; +/*N*/ do +/*N*/ { +/*N*/ bConvert = FALSE; +/*N*/ UpdateFields(); +/*N*/ if ( bConvert ) +/*N*/ { +/*N*/ ESelection aSel( nConvPara, nConvPos, nConvPara, nConvPos+1 ); +/*N*/ QuickInsertField( SvxFileField(), aSel ); +/*N*/ bConverted = TRUE; +/*N*/ } +/*N*/ } while ( bConvert ); +/*N*/ return bConverted; +/*N*/ } + +/*N*/ void lcl_StoreOldFields( ScFieldChangerEditEngine& rEngine, +/*N*/ const EditTextObject* pArea, SvStream& rStream ) +/*N*/ { +/*N*/ rEngine.SetText( *pArea ); +/*N*/ if ( rEngine.ConvertFields() ) +/*N*/ { +/*N*/ EditTextObject* pObj = rEngine.CreateTextObject(); +/*N*/ pObj->Store( rStream ); +/*N*/ delete pObj; +/*N*/ } +/*N*/ else +/*N*/ pArea->Store( rStream ); +/*N*/ } + +/*N*/ SvStream& __EXPORT ScPageHFItem::Store( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ if ( pLeftArea && pCenterArea && pRightArea ) +/*N*/ { +/*N*/ if ( rStream.GetVersion() < SOFFICE_FILEFORMAT_50 ) +/*N*/ { +/*N*/ ScFieldChangerEditEngine aEngine( EditEngine::CreatePool(), TRUE ); +/*N*/ lcl_StoreOldFields( aEngine, pLeftArea, rStream ); +/*N*/ lcl_StoreOldFields( aEngine, pCenterArea, rStream ); +/*N*/ lcl_StoreOldFields( aEngine, pRightArea, rStream ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pLeftArea->Store(rStream); +/*N*/ pCenterArea->Store(rStream); +/*N*/ pRightArea->Store(rStream); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ // soll eigentlich nicht sein, kommt aber vor, wenn das Default-Item +/*?*/ // fuer ein ItemSet kopiert wird (#61826#) ... +/*?*/ +/*?*/ ScFieldChangerEditEngine aEngine( EditEngine::CreatePool(), TRUE ); +/*?*/ EditTextObject* pEmpytObj = aEngine.CreateTextObject(); +/*?*/ +/*?*/ DBG_ASSERT( pEmpytObj, "Error creating empty EditTextObject :-(" ); +/*?*/ +/*?*/ if ( rStream.GetVersion() < SOFFICE_FILEFORMAT_50 ) +/*?*/ { +/*?*/ if ( pLeftArea ) +/*?*/ lcl_StoreOldFields( aEngine, pLeftArea, rStream ); +/*?*/ else +/*?*/ pEmpytObj->Store( rStream ); +/*?*/ +/*?*/ if ( pCenterArea ) +/*?*/ lcl_StoreOldFields( aEngine, pCenterArea, rStream ); +/*?*/ else +/*?*/ pEmpytObj->Store( rStream ); +/*?*/ +/*?*/ if ( pRightArea ) +/*?*/ lcl_StoreOldFields( aEngine, pRightArea, rStream ); +/*?*/ else +/*?*/ pEmpytObj->Store( rStream ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ (pLeftArea ? pLeftArea : pEmpytObj )->Store(rStream); +/*?*/ (pCenterArea ? pCenterArea : pEmpytObj )->Store(rStream); +/*?*/ (pRightArea ? pRightArea : pEmpytObj )->Store(rStream); +/*?*/ } +/*?*/ +/*?*/ delete pEmpytObj; +/*N*/ } +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPageHFItem::SetLeftArea( const EditTextObject& rNew ) +/*N*/ { +/*N*/ delete pLeftArea; +/*N*/ pLeftArea = rNew.Clone(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPageHFItem::SetCenterArea( const EditTextObject& rNew ) +/*N*/ { +/*N*/ delete pCenterArea; +/*N*/ pCenterArea = rNew.Clone(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPageHFItem::SetRightArea( const EditTextObject& rNew ) +/*N*/ { +/*N*/ delete pRightArea; +/*N*/ pRightArea = rNew.Clone(); +/*N*/ } + +/*N*/ void __EXPORT ScPageHFItem::SetArea( EditTextObject *pNew, int nArea ) +/*N*/ { +/*N*/ switch ( nArea ) +/*N*/ { +/*N*/ case SC_HF_LEFTAREA: delete pLeftArea; pLeftArea = pNew; break; +/*N*/ case SC_HF_CENTERAREA: delete pCenterArea; pCenterArea = pNew; break; +/*N*/ case SC_HF_RIGHTAREA: delete pRightArea; pRightArea = pNew; break; +/*N*/ default: +/*N*/ DBG_ERROR( "New Area?" ); +/*N*/ } +/*N*/ } + +//----------------------------------------------------------------------- +// ScViewObjectModeItem - Darstellungsmodus von ViewObjekten +//----------------------------------------------------------------------- + +/*N*/ ScViewObjectModeItem::ScViewObjectModeItem( USHORT nWhich ) +/*N*/ : SfxEnumItem( nWhich, VOBJ_MODE_SHOW ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScViewObjectModeItem::ScViewObjectModeItem( USHORT nWhich, ScVObjMode eMode ) +/*N*/ : SfxEnumItem( nWhich, eMode ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScViewObjectModeItem::~ScViewObjectModeItem() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ USHORT __EXPORT ScViewObjectModeItem::GetValueCount() const +/*N*/ { +/*N*/ return 3; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScViewObjectModeItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new ScViewObjectModeItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ USHORT __EXPORT ScViewObjectModeItem::GetVersion( USHORT nFileVersion ) const +/*N*/ { +/*N*/ return 1; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScViewObjectModeItem::Create( +/*N*/ SvStream& rStream, +/*N*/ USHORT nVersion ) const +/*N*/ { +/*N*/ if ( nVersion == 0 ) +/*N*/ { +/*N*/ // alte Version mit AllEnumItem -> mit Mode "Show" erzeugen +/*N*/ return new ScViewObjectModeItem( Which() ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nVal; +/*N*/ rStream >> nVal; +/*N*/ return new ScViewObjectModeItem( Which(), (ScVObjMode)nVal ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- +// double +// ----------------------------------------------------------------------- + +/*N*/ ScDoubleItem::ScDoubleItem( USHORT nWhich, double nVal ) +/*N*/ : SfxPoolItem ( nWhich ), +/*N*/ nValue ( nVal ) +/*N*/ { +/*N*/ } +/*N*/ +//------------------------------------------------------------------------ + +/*N*/ ScDoubleItem::ScDoubleItem( const ScDoubleItem& rItem ) +/*N*/ : SfxPoolItem ( rItem ) +/*N*/ { +/*N*/ nValue = rItem.nValue; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ String __EXPORT ScDoubleItem::GetValueText() const +/*N*/ { +/*N*/ return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScDoubleItem")); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ int __EXPORT ScDoubleItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal Which or Type" ); +/*N*/ const ScDoubleItem& _rItem = (const ScDoubleItem&)rItem; +/*N*/ return int(nValue == _rItem.nValue); +/*N*/ //int(nValue == ((const ScDoubleItem&)rItem).nValue); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScDoubleItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new ScDoubleItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* __EXPORT ScDoubleItem::Create( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ double nTmp=0; +/*N*/ rStream >> nTmp; +/*N*/ +/*N*/ ScDoubleItem* pItem = new ScDoubleItem( Which(), nTmp ); +/*N*/ +/*N*/ return pItem; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& __EXPORT ScDoubleItem::Store( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ rStream << nValue; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScDoubleItem::~ScDoubleItem() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_bcaslot.cxx b/binfilter/bf_sc/source/core/data/sc_bcaslot.cxx new file mode 100644 index 000000000000..c70d48dc75f2 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_bcaslot.cxx @@ -0,0 +1,580 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <bf_sfx2/objsh.hxx> +#include <bf_svtools/lstner.hxx> + +// INCLUDE --------------------------------------------------------------- + +#include "document.hxx" +#include "bcaslot.hxx" +#include "scerrors.hxx" +namespace binfilter { + +// Anzahl der Slots je Dimension +// muessen ganzzahlige Teiler von MAXCOL+1 bzw. MAXROW+1 sein +#define BCA_SLOTS_COL 16 +#define BCA_SLOTS_ROW 256 +#define BCA_SLOT_COLS ((MAXCOL+1) / BCA_SLOTS_COL) +#define BCA_SLOT_ROWS ((MAXROW+1) / BCA_SLOTS_ROW) +// vielfaches? +#if (BCA_SLOT_COLS * BCA_SLOTS_COL) != (MAXCOL+1) +#error bad BCA_SLOTS_COL value! +#endif +#if (BCA_SLOT_ROWS * BCA_SLOTS_ROW) != (MAXROW+1) +#error bad BCA_SLOTS_ROW value! +#endif +// Groesse des Slot-Arrays +#define BCA_SLOTS (BCA_SLOTS_COL * BCA_SLOTS_ROW) +#if BCA_SLOTS > 16350 +#error BCA_SLOTS DOOMed! +#endif + +DECLARE_LIST( ScBroadcastAreaList, ScBroadcastArea* )//STRIP008 ; + +// STATIC DATA ----------------------------------------------------------- + +#ifdef erDEBUG +ULONG erCountBCAInserts = 0; +ULONG erCountBCAFinds = 0; +#endif + +/*N*/ SV_IMPL_OP_PTRARR_SORT( ScBroadcastAreas, ScBroadcastAreaPtr ); +/*N*/ TYPEINIT1( ScHint, SfxSimpleHint ); +TYPEINIT1( ScAreaChangedHint, SfxHint ); + + +/*N*/ ScBroadcastAreaSlot::ScBroadcastAreaSlot( ScDocument* pDocument, +/*N*/ ScBroadcastAreaSlotMachine* pBASMa ) : +/*N*/ pDoc( pDocument ), +/*N*/ pBASM( pBASMa ) +/*N*/ { +/*N*/ pBroadcastAreaTbl = new ScBroadcastAreas( BCA_INITGROWSIZE, BCA_INITGROWSIZE ); +/*N*/ pTmpSeekBroadcastArea = new ScBroadcastArea( ScRange() ); +/*N*/ } + + +/*N*/ ScBroadcastAreaSlot::~ScBroadcastAreaSlot() +/*N*/ { +/*N*/ USHORT nPos = pBroadcastAreaTbl->Count(); +/*N*/ if ( nPos ) +/*N*/ { +/*N*/ ScBroadcastArea** ppArea = +/*N*/ ((ScBroadcastArea**) pBroadcastAreaTbl->GetData()) + nPos - 1; +/*N*/ for ( ; nPos-- >0; ppArea-- ) +/*N*/ { +/*N*/ if ( !(*ppArea)->DecRef() ) +/*N*/ delete *ppArea; +/*N*/ } +/*N*/ } +/*N*/ delete pBroadcastAreaTbl; +/*N*/ delete pTmpSeekBroadcastArea; +/*N*/ } + + +// nur hier werden neue BroadcastAreas angelegt, wodurch keine doppelten entstehen. +// Ist rpArea != NULL werden keine Listener gestartet sondern nur die Area +// eingetragen und der RefCount erhoeht +/*N*/ void ScBroadcastAreaSlot::StartListeningArea( const ScRange& rRange, +/*N*/ SfxListener* pListener, ScBroadcastArea*& rpArea +/*N*/ ) +/*N*/ { +/*N*/ DBG_ASSERT(pListener, "StartListeningArea: pListener Null"); +/*N*/ if ( pDoc->GetHardRecalcState() ) +/*N*/ return; +/*N*/ if ( (long)( (pBroadcastAreaTbl->Count() + 1 + BCA_INITGROWSIZE) +/*N*/ * sizeof(ScBroadcastArea*) ) >= USHRT_MAX +/*N*/ ) +/*N*/ { +/*?*/ if ( !pDoc->GetHardRecalcState() ) +/*?*/ { +/*?*/ pDoc->SetHardRecalcState( 1 ); +/*?*/ +/*?*/ SfxObjectShell* pShell = pDoc->GetDocumentShell(); +/*?*/ DBG_ASSERT( pShell, "Missing DocShell :-/" ); +/*?*/ +/*?*/ if ( pShell ) +/*?*/ pShell->SetError( SCWARN_CORE_HARD_RECALC ); +/*?*/ +/*?*/ pDoc->SetAutoCalc( FALSE ); +/*?*/ pDoc->SetHardRecalcState( 2 ); +/*?*/ } +/*?*/ return; +/*N*/ } +/*N*/ if ( !rpArea ) +/*N*/ { +/*N*/ rpArea = new ScBroadcastArea( rRange ); +/*N*/ // meistens existiert die Area noch nicht, der Versuch sofort zu inserten +/*N*/ // erspart in diesen Faellen ein doppeltes Seek_Entry +/*N*/ if ( pBroadcastAreaTbl->Insert( rpArea ) ) +/*N*/ rpArea->IncRef(); +/*N*/ else +/*N*/ { +/*N*/ delete rpArea; +/*N*/ rpArea = GetBroadcastArea( rRange ); +/*N*/ } +/*N*/ pListener->StartListening( *rpArea, TRUE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( pBroadcastAreaTbl->Insert( rpArea ) ) +/*N*/ rpArea->IncRef(); +/*N*/ } +/*N*/ } + + +/*N*/ // Ist rpArea != NULL werden keine Listener gestopt sondern nur die Area +/*N*/ // ausgetragen und der RefCount vermindert +/*N*/ void ScBroadcastAreaSlot::EndListeningArea( const ScRange& rRange, +/*N*/ SfxListener* pListener, ScBroadcastArea*& rpArea +/*N*/ ) +/*N*/ { +/*N*/ DBG_ASSERT(pListener, "EndListeningArea: pListener Null"); +/*N*/ if ( !rpArea ) +/*N*/ { +/*N*/ USHORT nPos; +/*N*/ if ( (nPos = FindBroadcastArea( rRange )) == USHRT_MAX ) +/*N*/ return; +/*N*/ rpArea = (*pBroadcastAreaTbl)[ nPos ]; +/*N*/ pListener->EndListening( *rpArea ); +/*N*/ if ( !rpArea->HasListeners() ) +/*N*/ { // wenn keiner mehr zuhoert ist die Area ueberfluessig +/*N*/ pBroadcastAreaTbl->Remove( nPos ); +/*N*/ if ( !rpArea->DecRef() ) +/*N*/ { +/*N*/ delete rpArea; +/*N*/ rpArea = NULL; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( !rpArea->HasListeners() ) +/*N*/ { +/*N*/ USHORT nPos; +/*N*/ if ( (nPos = FindBroadcastArea( rRange )) == USHRT_MAX ) +/*N*/ return; +/*N*/ pBroadcastAreaTbl->Remove( nPos ); +/*N*/ if ( !rpArea->DecRef() ) +/*N*/ { +/*N*/ delete rpArea; +/*N*/ rpArea = NULL; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ +/*N*/ USHORT ScBroadcastAreaSlot::FindBroadcastArea( const ScRange& rRange ) const +/*N*/ { +/*N*/ USHORT nPos; +/*N*/ pTmpSeekBroadcastArea->UpdateRange( rRange ); +/*N*/ if ( pBroadcastAreaTbl->Seek_Entry( pTmpSeekBroadcastArea, &nPos ) ) +/*N*/ return nPos; +/*N*/ return USHRT_MAX; +/*N*/ } + + +/*N*/ ScBroadcastArea* ScBroadcastAreaSlot::GetBroadcastArea( +/*N*/ const ScRange& rRange ) const +/*N*/ { +/*N*/ USHORT nPos; +/*N*/ if ( (nPos = FindBroadcastArea( rRange )) != USHRT_MAX ) +/*N*/ return (*pBroadcastAreaTbl)[ nPos ]; +/*N*/ return 0; +/*N*/ } + + +/*N*/ BOOL ScBroadcastAreaSlot::AreaBroadcast( const ScHint& rHint) const +/*N*/ { +/*N*/ USHORT nCount = pBroadcastAreaTbl->Count(); +/*N*/ if ( nCount == 0 ) +/*N*/ return FALSE; +/*N*/ const ScBroadcastArea** ppArea = +/*N*/ (const ScBroadcastArea**) pBroadcastAreaTbl->GetData(); +/*N*/ BOOL bIsBroadcasted = FALSE; +/*N*/ // leider laesst sich nicht nach dem erstmoeglichen suchen +/*N*/ USHORT nPos = 0; +/*N*/ // den letztmoeglichen suchen, Seek_Entry liefert naechst groesseren +/*N*/ // oder freie Position wenn nicht gefunden +/*N*/ USHORT nPosEnd; +/*N*/ const ScAddress& rAddress = rHint.GetAddress(); +/*N*/ pTmpSeekBroadcastArea->UpdateRange( ScRange( rAddress, +/*N*/ ScAddress( MAXCOL, MAXROW, MAXTAB ) ) ); +/*N*/ if ( !pBroadcastAreaTbl->Seek_Entry( pTmpSeekBroadcastArea, &nPosEnd ) +/*N*/ && nPosEnd > 0 ) +/*N*/ --nPosEnd; +/*N*/ for ( ; nPos <= nPosEnd; ++nPos, ppArea++ ) +/*N*/ { +/*N*/ if ( ((ScBroadcastArea*)*ppArea)->In( rAddress ) ) +/*N*/ { +/*N*/ ((ScBroadcastArea*)*ppArea)->Broadcast( rHint ); +/*N*/ bIsBroadcasted = TRUE; +/*N*/ } +/*N*/ } +/*N*/ return bIsBroadcasted; +/*N*/ } + + +/*N*/ BOOL ScBroadcastAreaSlot::AreaBroadcastInRange( const ScRange& rRange, +/*N*/ const ScHint& rHint) const +/*N*/ { +/*N*/ USHORT nCount = pBroadcastAreaTbl->Count(); +/*N*/ if ( nCount == 0 ) +/*N*/ return FALSE; +/*N*/ const ScBroadcastArea** ppArea = +/*N*/ (const ScBroadcastArea**) pBroadcastAreaTbl->GetData(); +/*N*/ BOOL bIsBroadcasted = FALSE; +/*N*/ // unfortunately we can't search for the first matching entry +/*N*/ USHORT nPos = 0; +/*N*/ // search the last matching entry, Seek_Entry returns the next being +/*N*/ // greater, or a free position if not found +/*N*/ USHORT nPosEnd; +/*N*/ pTmpSeekBroadcastArea->UpdateRange( rRange ); +/*N*/ if ( !pBroadcastAreaTbl->Seek_Entry( pTmpSeekBroadcastArea, &nPosEnd ) && +/*N*/ nPosEnd > 0 ) +/*N*/ --nPosEnd; +/*N*/ for ( ; nPos <= nPosEnd; ++nPos, ppArea++ ) +/*N*/ { +/*N*/ if ( ((ScBroadcastArea*)*ppArea)->Intersects( rRange ) ) +/*N*/ { +/*N*/ ((ScBroadcastArea*)*ppArea)->Broadcast( rHint ); +/*N*/ bIsBroadcasted = TRUE; +/*N*/ } +/*N*/ } +/*N*/ return bIsBroadcasted; +/*N*/ } + + +// DelBroadcastAreasInRange wird unter Windows (16 Bit) kaputtoptimiert + +#ifdef WIN +#pragma optimize("",off) +#endif + +/*N*/ void ScBroadcastAreaSlot::DelBroadcastAreasInRange( const ScRange& rRange ) +/*N*/ { +/*N*/ ScBroadcastArea* pArea; +/*N*/ ScAddress aStart( rRange.aStart ); +/*N*/ USHORT nPos = pBroadcastAreaTbl->Count(); +/*N*/ const ScBroadcastArea** ppArea = +/*N*/ (const ScBroadcastArea**) pBroadcastAreaTbl->GetData() + nPos - 1; +/*N*/ for ( ; nPos-- >0; ppArea-- ) +/*N*/ { // rueckwaerts wg. Pointer-Aufrueckerei im Array +/*N*/ pArea = (ScBroadcastArea*)*ppArea; +/*N*/ if ( pArea->aStart < aStart ) +/*N*/ return; // davor nur noch niedrigere +/*N*/ // gesuchte muessen komplett innerhalb von rRange liegen +/*N*/ if ( rRange.In( pArea->aStart ) && rRange.In( pArea->aEnd ) ) +/*N*/ { +/*N*/ pBroadcastAreaTbl->Remove( nPos ); +/*N*/ ppArea = (const ScBroadcastArea**) pBroadcastAreaTbl->GetData() +/*N*/ + nPos; +/*N*/ if ( !pArea->DecRef() ) +/*N*/ delete pArea; +/*N*/ } +/*N*/ } +/*N*/ } + +#ifdef WIN +#pragma optimize("",on) +#endif + + + + + +// --- ScBroadcastAreaSlotMachine ------------------------------------- + +/*N*/ ScBroadcastAreaSlotMachine::ScBroadcastAreaSlotMachine( +/*N*/ ScDocument* pDocument ) : +/*N*/ pDoc( pDocument ), +/*N*/ pBCAlwaysList( new ScBroadcastAreaList ), +/*N*/ pUpdateChain( NULL ), +/*N*/ pEOUpdateChain( NULL ) +/*N*/ { +/*N*/ ppSlots = new ScBroadcastAreaSlot* [ BCA_SLOTS ]; +/*N*/ memset( ppSlots, 0 , sizeof( ScBroadcastAreaSlot* ) * BCA_SLOTS ); +/*N*/ } + + +/*N*/ ScBroadcastAreaSlotMachine::~ScBroadcastAreaSlotMachine() +/*N*/ { +/*N*/ +/*N*/ ScBroadcastAreaSlot** pp = ppSlots; +/*N*/ for ( USHORT j=0; j < BCA_SLOTS; ++j, ++pp ) +/*N*/ { +/*N*/ if ( *pp ) +/*N*/ delete *pp; +/*N*/ } +/*N*/ delete[] ppSlots; +/*N*/ +/*N*/ for ( ScBroadcastArea* pBCA = pBCAlwaysList->First(); pBCA; pBCA = pBCAlwaysList->Next() ) +/*N*/ { +/*N*/ delete pBCA; +/*N*/ } +/*N*/ delete pBCAlwaysList; +/*N*/ } + + +/*N*/ inline USHORT ScBroadcastAreaSlotMachine::ComputeSlotOffset( +/*N*/ const ScAddress& rAddress ) const +/*N*/ { +/*N*/ USHORT nRow = rAddress.Row(); +/*N*/ USHORT nCol = rAddress.Col(); +/*N*/ if ( nRow > MAXROW || nCol > MAXCOL ) +/*N*/ { +/*N*/ DBG_ASSERT( FALSE, "Row/Col ungueltig!" ); +/*N*/ return 0; +/*N*/ } +/*N*/ else +/*N*/ return +/*N*/ nRow / BCA_SLOT_ROWS + +/*N*/ nCol / BCA_SLOT_COLS * BCA_SLOTS_ROW; +/*N*/ } + + +/*N*/ void ScBroadcastAreaSlotMachine::ComputeAreaPoints( const ScRange& rRange, +/*N*/ USHORT& rStart, USHORT& rEnd, USHORT& rRowBreak +/*N*/ ) const +/*N*/ { +/*N*/ rStart = ComputeSlotOffset( rRange.aStart ); +/*N*/ rEnd = ComputeSlotOffset( rRange.aEnd ); +/*N*/ // Anzahl Zeilen-Slots pro Spalte minus eins +/*N*/ rRowBreak = ComputeSlotOffset( +/*N*/ ScAddress( rRange.aStart.Col(), rRange.aEnd.Row(), 0 ) ) - rStart; +/*N*/ } + + +/*N*/ void ScBroadcastAreaSlotMachine::StartListeningArea( const ScRange& rRange, +/*N*/ SfxListener* pListener +/*N*/ ) +/*N*/ { +/*N*/ if ( rRange == BCA_LISTEN_ALWAYS ) +/*N*/ { +/*N*/ ScBroadcastArea* pBCA; +/*N*/ if ( !pBCAlwaysList->Count() ) +/*N*/ { +/*N*/ pBCA = new ScBroadcastArea( rRange ); +/*N*/ pListener->StartListening( *pBCA, FALSE ); // kein PreventDupes +/*N*/ pBCAlwaysList->Insert( pBCA, LIST_APPEND ); +/*N*/ return ; +/*N*/ } +/*N*/ ScBroadcastArea* pLast; +/*N*/ for ( pBCA = pBCAlwaysList->First(); pBCA; pBCA = pBCAlwaysList->Next() ) +/*N*/ { +/*N*/ if ( pListener->IsListening( *pBCA ) ) +/*N*/ return ; // keine Dupes +/*N*/ pLast = pBCA; +/*N*/ } +/*?*/ pBCA = pLast; +/*?*/ //! ListenerArrays don't shrink! +/*?*/ if ( pBCA->GetListenerCount() > ((USHRT_MAX / 2) / sizeof(SfxBroadcaster*)) ) +/*?*/ { // Arrays nicht zu gross werden lassen +/*?*/ pBCA = new ScBroadcastArea( rRange ); +/*?*/ pBCAlwaysList->Insert( pBCA, LIST_APPEND ); +/*?*/ } +/*?*/ pListener->StartListening( *pBCA, FALSE ); // kein PreventDupes +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nStart, nEnd, nRowBreak; +/*N*/ ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak ); +/*N*/ USHORT nOff = nStart; +/*N*/ USHORT nBreak = nOff + nRowBreak; +/*N*/ ScBroadcastAreaSlot** pp = ppSlots + nOff; +/*N*/ ScBroadcastArea* pArea = NULL; +/*N*/ while ( nOff <= nEnd ) +/*N*/ { +/*N*/ if ( !*pp ) +/*N*/ *pp = new ScBroadcastAreaSlot( pDoc, this ); +/*N*/ // der erste erzeugt ggbf. die BroadcastArea +/*N*/ (*pp)->StartListeningArea( rRange, pListener, pArea ); +/*N*/ if ( nOff < nBreak ) +/*N*/ { +/*N*/ ++nOff; +/*N*/ ++pp; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nStart += BCA_SLOTS_ROW; +/*N*/ nOff = nStart; +/*N*/ pp = ppSlots + nOff; +/*N*/ nBreak = nOff + nRowBreak; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScBroadcastAreaSlotMachine::EndListeningArea( const ScRange& rRange, +/*N*/ SfxListener* pListener +/*N*/ ) +/*N*/ { +/*N*/ if ( rRange == BCA_LISTEN_ALWAYS ) +/*N*/ { +/*?*/ if ( pBCAlwaysList->Count() ) +/*?*/ { +/*?*/ for ( ScBroadcastArea* pBCA = pBCAlwaysList->First(); pBCA; pBCA = pBCAlwaysList->Next() ) +/*?*/ { +/*?*/ // EndListening liefert FALSE wenn !IsListening, keine Dupes +/*?*/ if ( pListener->EndListening( *pBCA, FALSE ) ) +/*?*/ { +/*?*/ if ( !pBCA->HasListeners() ) +/*?*/ { +/*?*/ pBCAlwaysList->Remove(); +/*?*/ delete pBCA; +/*?*/ } +/*?*/ return ; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nStart, nEnd, nRowBreak; +/*N*/ ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak ); +/*N*/ USHORT nOff = nStart; +/*N*/ USHORT nBreak = nOff + nRowBreak; +/*N*/ ScBroadcastAreaSlot** pp = ppSlots + nOff; +/*N*/ ScBroadcastArea* pArea = NULL; +/*N*/ while ( nOff <= nEnd ) +/*N*/ { +/*N*/ if ( *pp ) +/*N*/ (*pp)->EndListeningArea( rRange, pListener, pArea ); +/*N*/ if ( nOff < nBreak ) +/*N*/ { +/*N*/ ++nOff; +/*N*/ ++pp; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nStart += BCA_SLOTS_ROW; +/*N*/ nOff = nStart; +/*N*/ pp = ppSlots + nOff; +/*N*/ nBreak = nOff + nRowBreak; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ +/*N*/ BOOL ScBroadcastAreaSlotMachine::AreaBroadcast( const ScHint& rHint ) const +/*N*/ { +/*N*/ const ScAddress& rAddress = rHint.GetAddress(); +/*N*/ if ( rAddress == BCA_BRDCST_ALWAYS ) +/*N*/ { +/*N*/ if ( pBCAlwaysList->Count() ) +/*N*/ { +/*N*/ for ( ScBroadcastArea* pBCA = pBCAlwaysList->First(); pBCA; pBCA = pBCAlwaysList->Next() ) +/*N*/ { +/*N*/ pBCA->Broadcast( rHint ); +/*N*/ } +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScBroadcastAreaSlot* pSlot = ppSlots[ ComputeSlotOffset( rAddress ) ]; +/*N*/ if ( pSlot ) +/*N*/ return pSlot->AreaBroadcast( rHint ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScBroadcastAreaSlotMachine::AreaBroadcastInRange( const ScRange& rRange, +/*N*/ const ScHint& rHint ) const +/*N*/ { +/*N*/ BOOL bBroadcasted = FALSE; +/*N*/ USHORT nStart, nEnd, nRowBreak; +/*N*/ ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak ); +/*N*/ USHORT nOff = nStart; +/*N*/ USHORT nBreak = nOff + nRowBreak; +/*N*/ ScBroadcastAreaSlot** pp = ppSlots + nOff; +/*N*/ while ( nOff <= nEnd ) +/*N*/ { +/*N*/ if ( *pp ) +/*N*/ bBroadcasted |= (*pp)->AreaBroadcastInRange( rRange, rHint ); +/*N*/ if ( nOff < nBreak ) +/*N*/ { +/*N*/ ++nOff; +/*N*/ ++pp; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nStart += BCA_SLOTS_ROW; +/*N*/ nOff = nStart; +/*N*/ pp = ppSlots + nOff; +/*N*/ nBreak = nOff + nRowBreak; +/*N*/ } +/*N*/ } +/*N*/ return bBroadcasted; +/*N*/ } + + +/*N*/ void ScBroadcastAreaSlotMachine::DelBroadcastAreasInRange( +/*N*/ const ScRange& rRange +/*N*/ ) +/*N*/ { +/*N*/ USHORT nStart, nEnd, nRowBreak; +/*N*/ ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak ); +/*N*/ USHORT nOff = nStart; +/*N*/ USHORT nBreak = nOff + nRowBreak; +/*N*/ ScBroadcastAreaSlot** pp = ppSlots + nOff; +/*N*/ while ( nOff <= nEnd ) +/*N*/ { +/*N*/ if ( *pp ) +/*N*/ (*pp)->DelBroadcastAreasInRange( rRange ); +/*N*/ if ( nOff < nBreak ) +/*N*/ { +/*N*/ ++nOff; +/*N*/ ++pp; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nStart += BCA_SLOTS_ROW; +/*N*/ nOff = nStart; +/*N*/ pp = ppSlots + nOff; +/*N*/ nBreak = nOff + nRowBreak; +/*N*/ } +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_bclist.cxx b/binfilter/bf_sc/source/core/data/sc_bclist.cxx new file mode 100644 index 000000000000..d6f49bf0f839 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_bclist.cxx @@ -0,0 +1,192 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------ + +#include <bf_svtools/lstner.hxx> +#include <tools/list.hxx> + +#include "bclist.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ + +#define SC_LISTENERS_MAX 1024 + +/*N*/ DECLARE_LIST(ScBroadcasters, SfxBroadcaster*)//STRIP008 ; + +//------------------------------------------------------------------------ + +/*N*/ ScBroadcasterList::ScBroadcasterList() : +/*N*/ pMoreBCs( NULL ) +/*N*/ { +/*N*/ } + +/*N*/ ScBroadcasterList::~ScBroadcasterList() +/*N*/ { +/*N*/ if (pMoreBCs) +/*N*/ { +/*?*/ ULONG nCount = pMoreBCs->Count(); +/*?*/ for (ULONG i=0; i<nCount; i++) +/*?*/ { +/*?*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*?*/ delete pBC; +/*?*/ } +/*?*/ delete pMoreBCs; +/*N*/ } +/*N*/ } + +/*N*/ void ScBroadcasterList::StartBroadcasting( SfxListener& rLst, BOOL bCheckDup ) +/*N*/ { +/*N*/ if (bCheckDup) +/*N*/ { +/*N*/ if (rLst.IsListening(aFirstBC)) +/*N*/ return; +/*N*/ if (pMoreBCs) +/*N*/ { +/*?*/ ULONG nCount = pMoreBCs->Count(); +/*?*/ for (ULONG i=0; i<nCount; i++) +/*?*/ { +/*?*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*?*/ if (rLst.IsListening(*pBC)) +/*?*/ return; +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( aFirstBC.GetListenerCount() < SC_LISTENERS_MAX ) +/*N*/ { +/*N*/ rLst.StartListening(aFirstBC, FALSE); +/*N*/ return; +/*N*/ } +/*N*/ if (pMoreBCs) +/*N*/ { +/*?*/ ULONG nCount = pMoreBCs->Count(); +/*?*/ for (ULONG i=0; i<nCount; i++) +/*?*/ { +/*?*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*?*/ if ( pBC->GetListenerCount() < SC_LISTENERS_MAX ) +/*?*/ { +/*?*/ rLst.StartListening(*pBC, FALSE); +/*?*/ return; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ if (!pMoreBCs) +/*?*/ pMoreBCs = new ScBroadcasters; +/*N*/ SfxBroadcaster* pNew = new SfxBroadcaster; +/*N*/ rLst.StartListening(*pNew, FALSE); +/*N*/ pMoreBCs->Insert(pNew, (ULONG)0); // vorne +/*N*/ } + +/*N*/ void ScBroadcasterList::EndBroadcasting( SfxListener& rLst ) +/*N*/ { +/*N*/ rLst.EndListening(aFirstBC); +/*N*/ if (pMoreBCs) +/*N*/ { +/*?*/ ULONG nCount = pMoreBCs->Count(); +/*?*/ for (ULONG i=0; i<nCount; i++) +/*?*/ { +/*?*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*?*/ rLst.EndListening(*pBC); +/*?*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScBroadcasterList::HasListeners() const +/*N*/ { +/*N*/ if (aFirstBC.HasListeners()) +/*N*/ return TRUE; +/*N*/ if (pMoreBCs) +/*N*/ { +/*?*/ ULONG nCount = pMoreBCs->Count(); +/*?*/ for (ULONG i=0; i<nCount; i++) +/*?*/ { +/*?*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*?*/ if (pBC->HasListeners()) +/*?*/ return TRUE; +/*?*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScBroadcasterList::Broadcast( const SfxHint &rHint ) +/*N*/ { +/*N*/ aFirstBC.Broadcast( rHint ); +/*N*/ if (pMoreBCs) +/*N*/ { +/*?*/ ULONG nCount = pMoreBCs->Count(); +/*?*/ for (ULONG i=0; i<nCount; i++) +/*?*/ { +/*?*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*?*/ pBC->Broadcast( rHint ); +/*?*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScBroadcasterList::MoveListenersTo( ScBroadcasterList& rNew ) +/*N*/ { +/*N*/ SfxBroadcaster* pNewBC = &rNew.aFirstBC; +/*N*/ +/*N*/ USHORT nLstCount, nLstPos; +/*N*/ nLstCount = aFirstBC.GetListenerCount(); +/*N*/ for (nLstPos=nLstCount; nLstPos>0;) +/*N*/ { +/*N*/ --nLstPos; +/*N*/ SfxListener* pLst = aFirstBC.GetListener(nLstPos); +/*N*/ rNew.StartBroadcasting(*pLst, TRUE); +/*N*/ pLst->EndListening(aFirstBC); +/*N*/ } +/*N*/ if (pMoreBCs) +/*N*/ { +/*N*/ ULONG nBCCount = pMoreBCs->Count(); +/*N*/ for (ULONG i=0; i<nBCCount; i++) +/*N*/ { +/*N*/ SfxBroadcaster* pBC = pMoreBCs->GetObject(i); +/*N*/ nLstCount = pBC->GetListenerCount(); +/*N*/ for (nLstPos=nLstCount; nLstPos>0;) +/*N*/ { +/*N*/ --nLstPos; +/*N*/ SfxListener* pLst = pBC->GetListener(nLstPos); +/*N*/ rNew.StartBroadcasting(*pLst, TRUE); +/*N*/ pLst->EndListening(*pBC); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_cell.cxx b/binfilter/bf_sc/source/core/data/sc_cell.cxx new file mode 100644 index 000000000000..99ed87c7904e --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_cell.cxx @@ -0,0 +1,1611 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#ifdef MAC + // StackSpace +#include <mac_start.h> +#include <Memory.h> +#include <fp.h> +#include <mac_end.h> +#endif + +#if defined (SOLARIS) || defined (FREEBSD) || defined (OPENBSD) +#include <ieeefp.h> +#elif ( defined ( LINUX ) && ( GLIBC < 2 ) ) +#include <i386/ieeefp.h> +#endif + +#include <bf_svtools/zforlist.hxx> +#include <float.h> // _finite + +#include "interpre.hxx" +#include "scmatrix.hxx" +#include "docoptio.hxx" +#include "rechead.hxx" +#include "rangenam.hxx" +#include "progress.hxx" +#include "bclist.hxx" +namespace binfilter { + +// jetzt fuer alle Systeme niedriger Wert, Rest wird per FormulaTree ausgebuegelt, +// falls wirklich eine tiefe Rekursion ist, geht das schneller, als zu versuchen +// und dann doch nicht zu schaffen.. +#define SIMPLEMAXRECURSION +#ifdef SIMPLEMAXRECURSION + #define MAXRECURSION 50 +#else +#if defined( WIN ) || defined( OS2 ) + #define MAXRECURSION 50 +#elif defined( MAC ) + // wird per StackSpace() ermittelt +#else + #define MAXRECURSION 1000 +#endif +#endif + +// STATIC DATA ----------------------------------------------------------- + +#ifdef USE_MEMPOOL +// MemPools auf 4k Boundaries - 64 Bytes ausrichten +/*N*/ const USHORT nMemPoolValueCell = (0x8000 - 64) / sizeof(ScValueCell); +/*N*/ const USHORT nMemPoolFormulaCell = (0x8000 - 64) / sizeof(ScFormulaCell); +/*N*/ const USHORT nMemPoolStringCell = (0x4000 - 64) / sizeof(ScStringCell); +/*N*/ const USHORT nMemPoolNoteCell = (0x1000 - 64) / sizeof(ScNoteCell); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScValueCell, nMemPoolValueCell, nMemPoolValueCell ) +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScFormulaCell, nMemPoolFormulaCell, nMemPoolFormulaCell ) +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScStringCell, nMemPoolStringCell, nMemPoolStringCell ) +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScNoteCell, nMemPoolNoteCell, nMemPoolNoteCell ) +#endif + +#ifdef _MSC_VER +#pragma code_seg() +#endif + +INT8 ScFormulaCell::nIterMode = 0; + +#ifdef DBG_UTIL +static const sal_Char __FAR_DATA msgDbgInfinity[] = + "Formelzelle INFINITY ohne Err503 !!! (os/2?)\n" + "NICHTS anruehren und ER bescheid sagen!"; +#endif + +// ----------------------------------------------------------------------- + +DECLARE_LIST (ScFormulaCellList, ScFormulaCell*)//STRIP008 ; + + +/*N*/ ScBaseCell* ScBaseCell::Clone(ScDocument* pDoc) const +/*N*/ { +/*N*/ switch (eCellType) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ return new ScValueCell(*(const ScValueCell*)this); +/*N*/ case CELLTYPE_STRING: +/*N*/ return new ScStringCell(*(const ScStringCell*)this); +/*N*/ case CELLTYPE_EDIT: +/*N*/ return new ScEditCell(*(const ScEditCell*)this, pDoc); +/*N*/ case CELLTYPE_FORMULA: +/*N*/ return new ScFormulaCell(pDoc, ((ScFormulaCell*)this)->aPos, +/*N*/ *(const ScFormulaCell*)this); +/*N*/ case CELLTYPE_NOTE: +/*N*/ return new ScNoteCell(*(const ScNoteCell*)this); +/*N*/ default: +/*N*/ DBG_ERROR("Unbekannter Zellentyp"); +/*N*/ return NULL; +/*N*/ } +/*N*/ } + +/*N*/ ScBaseCell::~ScBaseCell() +/*N*/ { +/*N*/ delete pNote; +/*N*/ delete pBroadcaster; +/*N*/ DBG_ASSERT( eCellType == CELLTYPE_DESTROYED, "BaseCell Destructor" ); +/*N*/ } + +/*N*/ void ScBaseCell::Delete() +/*N*/ { +/*N*/ DELETEZ(pNote); +/*N*/ switch (eCellType) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ delete (ScValueCell*) this; +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ delete (ScStringCell*) this; +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ delete (ScEditCell*) this; +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ delete (ScFormulaCell*) this; +/*N*/ break; +/*N*/ case CELLTYPE_NOTE: +/*N*/ delete (ScNoteCell*) this; +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR("Unbekannter Zellentyp"); +/*N*/ break; +/*N*/ } +/*N*/ } + +/*N*/ void ScBaseCell::SetNote( const ScPostIt& rNote ) +/*N*/ { +/*N*/ if (rNote.GetText().Len() > 0) +/*N*/ { +/*N*/ if (!pNote) +/*N*/ pNote = new ScPostIt(rNote); +/*N*/ else +/*N*/ *pNote = rNote; +/*N*/ } +/*N*/ else +/*?*/ DELETEZ(pNote); +/*N*/ } + +/*N*/ BOOL ScBaseCell::GetNote( ScPostIt& rNote ) const +/*N*/ { +/*N*/ if ( pNote ) +/*N*/ rNote = *pNote; +/*N*/ else +/*?*/ rNote.Clear(); +/*N*/ +/*N*/ return ( pNote != NULL ); +/*N*/ } + +/*N*/ ScBaseCell* ScBaseCell::CreateTextCell( const String& rString, ScDocument* pDoc ) +/*N*/ { +/*N*/ if ( rString.Search('\n') != STRING_NOTFOUND || rString.Search(CHAR_CR) != STRING_NOTFOUND ) +/*?*/ return new ScEditCell( rString, pDoc ); +/*N*/ else +/*N*/ return new ScStringCell( rString ); +/*N*/ } + +/*N*/ void ScBaseCell::LoadNote( SvStream& rStream ) +/*N*/ { +/*N*/ pNote = new ScPostIt; +/*N*/ rStream >> *pNote; +/*N*/ } + +/*N*/ void ScBaseCell::SetBroadcaster(ScBroadcasterList* pNew) +/*N*/ { +/*N*/ delete pBroadcaster; +/*N*/ pBroadcaster = pNew; +/*N*/ } + +/*M*/ void ScBaseCell::StartListeningTo( ScDocument* pDoc, USHORT nOnlyNames ) +/*M*/ { +/*M*/ if ( eCellType == CELLTYPE_FORMULA && !pDoc->IsClipOrUndo() +/*M*/ && !pDoc->GetNoListening() +/*M*/ && !((ScFormulaCell*)this)->IsInChangeTrack() +/*M*/ ) +/*M*/ { +/*M*/ pDoc->SetDetectiveDirty(TRUE); // es hat sich was geaendert... +/*M*/ +/*M*/ ScFormulaCell* pFormCell = (ScFormulaCell*)this; +/*M*/ ScTokenArray* pArr = pFormCell->GetCode(); +/*M*/ if( pArr->IsRecalcModeAlways() ) +/*M*/ pDoc->StartListeningArea( BCA_LISTEN_ALWAYS, pFormCell ); +/*M*/ else +/*M*/ { +/*M*/ if ( nOnlyNames && ((nOnlyNames & SC_LISTENING_EXCEPT) == 0) && +/*M*/ pArr->IsReplacedSharedFormula() ) +/*M*/ nOnlyNames = 0; +/*M*/ pArr->Reset(); +/*M*/ for( ScToken* t = pArr->GetNextReferenceRPN(); t; +/*M*/ t = pArr->GetNextReferenceRPN() ) +/*M*/ { +/*M*/ StackVar eType = t->GetType(); +/*M*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*M*/ SingleRefData& rRef2 = (eType == svDoubleRef ? +/*M*/ t->GetDoubleRef().Ref2 : rRef1); +/*M*/ BOOL bDo = FALSE; +/*M*/ if ( !nOnlyNames ) +/*M*/ bDo = TRUE; +/*M*/ else +/*M*/ { +/*M*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 bDo = pArr->IsReplacedSharedFormula(); +/*M*/ } +/*M*/ if ( bDo ) +/*M*/ { +/*M*/ switch( eType ) +/*M*/ { +/*M*/ case svSingleRef: +/*M*/ rRef1.CalcAbsIfRel( pFormCell->aPos ); +/*M*/ if ( rRef1.Valid() ) +/*M*/ { +/*M*/ pDoc->StartListeningCell( +/*M*/ ScAddress( rRef1.nCol, +/*M*/ rRef1.nRow, +/*M*/ rRef1.nTab ), pFormCell ); +/*M*/ } +/*M*/ break; +/*M*/ case svDoubleRef: +/*M*/ t->CalcAbsIfRel( pFormCell->aPos ); +/*M*/ if ( rRef1.Valid() && rRef2.Valid() ) +/*M*/ { +/*M*/ if ( t->GetOpCode() == ocColRowNameAuto ) +/*M*/ { // automagically +/*?*/ if ( rRef1.IsColRel() ) +/*?*/ { // ColName +/*?*/ pDoc->StartListeningArea( ScRange ( +/*?*/ 0, +/*?*/ rRef1.nRow, +/*?*/ rRef1.nTab, +/*?*/ MAXCOL, +/*?*/ rRef2.nRow, +/*?*/ rRef2.nTab ), pFormCell ); +/*?*/ } +/*?*/ else +/*?*/ { // RowName +/*?*/ pDoc->StartListeningArea( ScRange ( +/*?*/ rRef1.nCol, +/*?*/ 0, +/*?*/ rRef1.nTab, +/*?*/ rRef2.nCol, +/*?*/ MAXROW, +/*?*/ rRef2.nTab ), pFormCell ); +/*?*/ } +/*M*/ } +/*M*/ else +/*M*/ { +/*M*/ pDoc->StartListeningArea( ScRange ( +/*M*/ rRef1.nCol, +/*M*/ rRef1.nRow, +/*M*/ rRef1.nTab, +/*M*/ rRef2.nCol, +/*M*/ rRef2.nRow, +/*M*/ rRef2.nTab ), pFormCell ); +/*M*/ } +/*M*/ } +/*M*/ break; +/*M*/ } +/*M*/ } +/*M*/ } +/*M*/ } +/*M*/ pArr->SetReplacedSharedFormula( FALSE ); +/*M*/ } +/*M*/ } + +// pArr gesetzt -> Referenzen von anderer Zelle nehmen +// dann muss auch aPos uebergeben werden! + +/*N*/ void ScBaseCell::EndListeningTo( ScDocument* pDoc, USHORT nOnlyNames, +/*N*/ ScTokenArray* pArr, ScAddress aPos ) +/*N*/ { +/*N*/ if ( eCellType == CELLTYPE_FORMULA && !pDoc->IsClipOrUndo() +/*N*/ && !((ScFormulaCell*)this)->IsInChangeTrack() +/*N*/ ) +/*N*/ { +/*N*/ pDoc->SetDetectiveDirty(TRUE); // es hat sich was geaendert... +/*N*/ +/*N*/ ScFormulaCell* pFormCell = (ScFormulaCell*)this; +/*N*/ if( pFormCell->GetCode()->IsRecalcModeAlways() ) +/*?*/ pDoc->EndListeningArea( BCA_LISTEN_ALWAYS, pFormCell ); +/*N*/ else +/*N*/ { +/*N*/ if (!pArr) +/*N*/ { +/*N*/ pArr = pFormCell->GetCode(); +/*N*/ aPos = pFormCell->aPos; +/*N*/ } +/*N*/ pArr->Reset(); +/*N*/ for( ScToken* t = pArr->GetNextReferenceRPN(); t; +/*N*/ t = pArr->GetNextReferenceRPN() ) +/*N*/ { +/*N*/ StackVar eType = t->GetType(); +/*N*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*N*/ SingleRefData& rRef2 = (eType == svDoubleRef ? +/*N*/ t->GetDoubleRef().Ref2 : rRef1); +/*N*/ BOOL bDo; +/*N*/ if ( !nOnlyNames ) +/*N*/ bDo = TRUE; +/*N*/ else +/*N*/ { +/*?*/ bDo = FALSE; +/*?*/ if ( nOnlyNames & SC_LISTENING_NAMES_REL ) +/*?*/ bDo |= (rRef1.IsRelName() || rRef2.IsRelName()); +/*?*/ if ( nOnlyNames & SC_LISTENING_NAMES_ABS ) +/*?*/ { DBG_BF_ASSERT(0, "STRIP");} //STRIP001 bDo |= t->IsRPNReferenceAbsName(); +/*?*/ if ( nOnlyNames & SC_LISTENING_EXCEPT ) +/*?*/ bDo = !bDo; +/*N*/ } +/*N*/ if ( bDo ) +/*N*/ { +/*N*/ switch( t->GetType() ) +/*N*/ { +/*N*/ case svSingleRef: +/*N*/ rRef1.CalcAbsIfRel( aPos ); +/*N*/ if ( rRef1.Valid() ) +/*N*/ { +/*N*/ pDoc->EndListeningCell( +/*N*/ ScAddress( rRef1.nCol, +/*N*/ rRef1.nRow, +/*N*/ rRef1.nTab ), pFormCell ); +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef: +/*N*/ t->CalcAbsIfRel( aPos ); +/*N*/ if ( rRef1.Valid() && rRef2.Valid() ) +/*N*/ { +/*N*/ if ( t->GetOpCode() == ocColRowNameAuto ) +/*N*/ { // automagically +/*?*/ if ( rRef1.IsColRel() ) +/*?*/ { // ColName +/*?*/ pDoc->EndListeningArea( ScRange ( +/*?*/ 0, +/*?*/ rRef1.nRow, +/*?*/ rRef1.nTab, +/*?*/ MAXCOL, +/*?*/ rRef2.nRow, +/*?*/ rRef2.nTab ), pFormCell ); +/*?*/ } +/*?*/ else +/*?*/ { // RowName +/*?*/ pDoc->EndListeningArea( ScRange ( +/*?*/ rRef1.nCol, +/*?*/ 0, +/*?*/ rRef1.nTab, +/*?*/ rRef2.nCol, +/*?*/ MAXROW, +/*?*/ rRef2.nTab ), pFormCell ); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pDoc->EndListeningArea( ScRange ( +/*N*/ rRef1.nCol, +/*N*/ rRef1.nRow, +/*N*/ rRef1.nTab, +/*N*/ rRef2.nCol, +/*N*/ rRef2.nRow, +/*N*/ rRef2.nTab ), pFormCell ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScBaseCell::HasValueData() const +/*N*/ { +/*N*/ switch ( eCellType ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : +/*N*/ return TRUE; +/*N*/ case CELLTYPE_FORMULA : +/*N*/ return ((ScFormulaCell*)this)->IsValue(); +/*N*/ default: +/*N*/ return FALSE; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScBaseCell::HasStringData() const +/*N*/ { +/*N*/ switch ( eCellType ) +/*N*/ { +/*N*/ case CELLTYPE_STRING : +/*N*/ case CELLTYPE_EDIT : +/*N*/ return TRUE; +/*N*/ case CELLTYPE_FORMULA : +/*N*/ return !((ScFormulaCell*)this)->IsValue(); +/*N*/ default: +/*N*/ return FALSE; +/*N*/ } +/*N*/ } + +/*N*/ String ScBaseCell::GetStringData() const +/*N*/ { +/*N*/ String aStr; +/*N*/ switch ( eCellType ) +/*N*/ { +/*N*/ case CELLTYPE_STRING: +/*N*/ ((const ScStringCell*)this)->GetString( aStr ); +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ ((const ScEditCell*)this)->GetString( aStr ); +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ ((ScFormulaCell*)this)->GetString( aStr ); // an der Formelzelle nicht-const +/*N*/ break; +/*N*/ } +/*N*/ return aStr; +/*N*/ } + +// static +/*N*/ BOOL ScBaseCell::CellEqual( const ScBaseCell* pCell1, const ScBaseCell* pCell2 ) +/*N*/ { +/*N*/ CellType eType1 = CELLTYPE_NONE; +/*N*/ CellType eType2 = CELLTYPE_NONE; +/*N*/ if ( pCell1 ) +/*N*/ { +/*N*/ eType1 = pCell1->GetCellType(); +/*N*/ if (eType1 == CELLTYPE_EDIT) +/*N*/ eType1 = CELLTYPE_STRING; +/*N*/ else if (eType1 == CELLTYPE_NOTE) +/*N*/ eType1 = CELLTYPE_NONE; +/*N*/ } +/*N*/ if ( pCell2 ) +/*N*/ { +/*N*/ eType2 = pCell2->GetCellType(); +/*N*/ if (eType2 == CELLTYPE_EDIT) +/*N*/ eType2 = CELLTYPE_STRING; +/*N*/ else if (eType2 == CELLTYPE_NOTE) +/*N*/ eType2 = CELLTYPE_NONE; +/*N*/ } +/*N*/ if ( eType1 != eType2 ) +/*N*/ return FALSE; +/*N*/ +/*N*/ switch ( eType1 ) // beide Typen gleich +/*N*/ { +/*N*/ case CELLTYPE_NONE: // beide leer +/*N*/ return TRUE; +/*N*/ case CELLTYPE_VALUE: // wirklich Value-Zellen +/*N*/ return ( ((const ScValueCell*)pCell1)->GetValue() == +/*N*/ ((const ScValueCell*)pCell2)->GetValue() ); +/*N*/ case CELLTYPE_STRING: // String oder Edit +/*N*/ { +/*N*/ String aText1; +/*N*/ if ( pCell1->GetCellType() == CELLTYPE_STRING ) +/*N*/ ((const ScStringCell*)pCell1)->GetString(aText1); +/*N*/ else +/*N*/ ((const ScEditCell*)pCell1)->GetString(aText1); +/*N*/ String aText2; +/*N*/ if ( pCell2->GetCellType() == CELLTYPE_STRING ) +/*N*/ ((const ScStringCell*)pCell2)->GetString(aText2); +/*N*/ else +/*N*/ ((const ScEditCell*)pCell2)->GetString(aText2); +/*N*/ return ( aText1 == aText2 ); +/*N*/ } +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ //! eingefuegte Zeilen / Spalten beruecksichtigen !!!!! +/*N*/ //! Vergleichsfunktion an der Formelzelle ??? +/*N*/ //! Abfrage mit ScColumn::SwapRow zusammenfassen! +/*N*/ +/*N*/ ScTokenArray* pCode1 = ((ScFormulaCell*)pCell1)->GetCode(); +/*N*/ ScTokenArray* pCode2 = ((ScFormulaCell*)pCell2)->GetCode(); +/*N*/ +/*N*/ if (pCode1->GetLen() == pCode2->GetLen()) // nicht-UPN +/*N*/ { +/*N*/ BOOL bEqual = TRUE; +/*N*/ USHORT nLen = pCode1->GetLen(); +/*N*/ ScToken** ppToken1 = pCode1->GetArray(); +/*N*/ ScToken** ppToken2 = pCode2->GetArray(); +/*N*/ for (USHORT i=0; i<nLen; i++) +/*N*/ if ( !ppToken1[i]->TextEqual(*(ppToken2[i])) ) +/*N*/ { +/*N*/ bEqual = FALSE; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ if (bEqual) +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ return FALSE; // unterschiedlich lang oder unterschiedliche Tokens +/*N*/ } +/*N*/ default: +/*N*/ DBG_ERROR("huch, was fuer Zellen???"); +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +//----------------------------------------------------------------------------------- + +/*N*/ ScFormulaCell::ScFormulaCell( ScDocument* pDoc, const ScAddress& rPos, +/*N*/ const String& rFormula, BYTE cMatInd ) : +/*N*/ ScBaseCell( CELLTYPE_FORMULA ), +/*N*/ aPos( rPos ), +/*N*/ pCode( NULL ), +/*N*/ nErgValue( 0.0 ), +/*N*/ bIsValue( TRUE ), +/*N*/ bDirty( TRUE ), // -> wg. Benutzung im Fkt.AutoPiloten, war: cMatInd != 0 +/*N*/ bChanged( FALSE ), +/*N*/ bRunning( FALSE ), +/*N*/ bCompile( FALSE ), +/*N*/ bSubTotal( FALSE ), +/*N*/ pDocument( pDoc ), +/*N*/ nFormatType( NUMBERFORMAT_NUMBER ), +/*N*/ nFormatIndex(0), +/*N*/ cMatrixFlag ( cMatInd ), +/*N*/ pMatrix( NULL ), +/*N*/ bIsIterCell (FALSE), +/*N*/ bInChangeTrack( FALSE ), +/*N*/ bTableOpDirty( FALSE ), +/*N*/ pPrevious(0), +/*N*/ pNext(0), +/*N*/ pPreviousTrack(0), +/*N*/ pNextTrack(0), +/*N*/ nMatCols(0), +/*N*/ nMatRows(0) +/*N*/ { +/*N*/ Compile( rFormula, TRUE ); // bNoListening, erledigt Insert +/*N*/ } + +// Wird von den Importfiltern verwendet + +/*N*/ ScFormulaCell::ScFormulaCell( ScDocument* pDoc, const ScAddress& rPos, +/*N*/ const ScTokenArray* pArr, BYTE cInd ) : +/*N*/ ScBaseCell( CELLTYPE_FORMULA ), +/*N*/ aPos( rPos ), +/*N*/ pCode( pArr ? new ScTokenArray( *pArr ) : new ScTokenArray ), +/*N*/ nErgValue( 0.0 ), +/*N*/ bIsValue( TRUE ), +/*N*/ bDirty( NULL != pArr ), // -> wg. Benutzung im Fkt.AutoPiloten, war: cInd != 0 +/*N*/ bChanged( FALSE ), +/*N*/ bRunning( FALSE ), +/*N*/ bCompile( FALSE ), +/*N*/ bSubTotal( FALSE ), +/*N*/ pDocument( pDoc ), +/*N*/ nFormatType( NUMBERFORMAT_NUMBER ), +/*N*/ nFormatIndex(0), +/*N*/ cMatrixFlag ( cInd ), +/*N*/ pMatrix ( NULL ), +/*N*/ bIsIterCell (FALSE), +/*N*/ bInChangeTrack( FALSE ), +/*N*/ bTableOpDirty( FALSE ), +/*N*/ pPrevious(0), +/*N*/ pNext(0), +/*N*/ pPreviousTrack(0), +/*N*/ pNextTrack(0), +/*N*/ nMatCols(0), +/*N*/ nMatRows(0) +/*N*/ { +/*N*/ // UPN-Array erzeugen +/*N*/ if( pCode->GetLen() && !pCode->GetError() && !pCode->GetCodeLen() ) +/*N*/ { +/*N*/ ScCompiler aComp(pDocument, aPos, *pCode); +/*N*/ bSubTotal = aComp.CompileTokenArray(); +/*N*/ nFormatType = aComp.GetNumFormatType(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ if ( pCode->GetNextOpCodeRPN( ocSubTotal ) ) +/*N*/ bSubTotal = TRUE; +/*N*/ } +/*N*/ } + +/*N*/ ScFormulaCell::ScFormulaCell( ScDocument* pDoc, const ScAddress& rNewPos, +/*N*/ const ScFormulaCell& rScFormulaCell, USHORT nCopyFlags ) : +/*N*/ ScBaseCell( rScFormulaCell ), +/*N*/ SfxListener(), +/*N*/ aErgString( rScFormulaCell.aErgString ), +/*N*/ nErgValue( rScFormulaCell.nErgValue ), +/*N*/ bIsValue( rScFormulaCell.bIsValue ), +/*N*/ bDirty( rScFormulaCell.bDirty ), +/*N*/ bChanged( rScFormulaCell.bChanged ), +/*N*/ bRunning( rScFormulaCell.bRunning ), +/*N*/ bCompile( rScFormulaCell.bCompile ), +/*N*/ bSubTotal( rScFormulaCell.bSubTotal ), +/*N*/ pDocument( pDoc ), +/*N*/ nFormatType( rScFormulaCell.nFormatType ), +/*N*/ nFormatIndex( pDoc == rScFormulaCell.pDocument ? rScFormulaCell.nFormatIndex : 0 ), +/*N*/ cMatrixFlag ( rScFormulaCell.cMatrixFlag ), +/*N*/ bIsIterCell (FALSE), +/*N*/ bInChangeTrack( FALSE ), +/*N*/ bTableOpDirty( FALSE ), +/*N*/ pPrevious(0), +/*N*/ pNext(0), +/*N*/ pPreviousTrack(0), +/*N*/ pNextTrack(0), +/*N*/ aPos( rNewPos ), +/*N*/ nMatCols( rScFormulaCell.nMatCols ), +/*N*/ nMatRows( rScFormulaCell.nMatRows ) +/*N*/ { +/*N*/ if (rScFormulaCell.pMatrix) +/*?*/ pMatrix = rScFormulaCell.pMatrix->Clone(); +/*N*/ else +/*N*/ pMatrix = NULL; +/*N*/ pCode = rScFormulaCell.pCode->Clone(); +/*N*/ +/*N*/ if ( nCopyFlags & 0x0001 ) +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 pCode->ReadjustRelative3DReferences( rScFormulaCell.aPos, aPos ); +/*N*/ +/*N*/ // evtl. Fehler zuruecksetzen und neu kompilieren +/*N*/ // nicht im Clipboard - da muss das Fehlerflag erhalten bleiben +/*N*/ // Spezialfall Laenge=0: als Fehlerzelle erzeugt, dann auch Fehler behalten +/*N*/ if ( pCode->GetError() && !pDocument->IsClipboard() && pCode->GetLen() ) +/*N*/ { +/*N*/ pCode->SetError( 0 ); +/*N*/ bCompile = TRUE; +/*N*/ } +/*N*/ //! Compile ColRowNames on URM_MOVE/URM_COPY _after_ UpdateReference +/*N*/ BOOL bCompileLater = FALSE; +/*N*/ BOOL bClipMode = rScFormulaCell.pDocument->IsClipboard(); +/*N*/ if( !bCompile ) +/*N*/ { // Name references with references and ColRowNames +/*N*/ pCode->Reset(); +/*N*/ for( ScToken* t = pCode->GetNextReferenceOrName(); t && !bCompile; +/*N*/ t = pCode->GetNextReferenceOrName() ) +/*N*/ { +/*N*/ if ( t->GetType() == svIndex ) +/*N*/ { +/*?*/ ScRangeData* pRangeData = pDoc->GetRangeName()->FindIndex( t->GetIndex() ); +/*?*/ if( pRangeData ) +/*?*/ { +/*?*/ if( pRangeData->HasReferences() ) +/*?*/ bCompile = TRUE; +/*?*/ } +/*?*/ else +/*?*/ bCompile = TRUE; // invalid reference! +/*N*/ } +/*N*/ else if ( t->GetOpCode() == ocColRowName ) +/*N*/ { +/*N*/ bCompile = TRUE; // new lookup needed +/*N*/ bCompileLater = bClipMode; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if( bCompile ) +/*N*/ { +/*N*/ if ( !bCompileLater && bClipMode ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 pCode->Reset(); +/*N*/ } +/*N*/ if ( !bCompileLater ) +/*N*/ { +/*N*/ // bNoListening, bei in Clip/Undo sowieso nicht, +/*N*/ // bei aus Clip auch nicht, sondern nach Insert(Clone) und UpdateReference +/*N*/ CompileTokenArray( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ } + +// +---+---+---+---+---+---+---+---+ +// | |Str|Num|Dir|cMatrix| +// +---+---+---+---+---+---+---+---+ + +/*N*/ ScFormulaCell::ScFormulaCell( ScDocument* pDoc, const ScAddress& rPos, +/*N*/ SvStream& rStream, ScMultipleReadHeader& rHdr ) : +/*N*/ ScBaseCell( CELLTYPE_FORMULA ), +/*N*/ aPos( rPos ), +/*N*/ pCode( new ScTokenArray ), +/*N*/ nErgValue( 0.0 ), +/*N*/ bIsValue( TRUE ), +/*N*/ bDirty( FALSE ), +/*N*/ bChanged( FALSE ), +/*N*/ bRunning( FALSE ), +/*N*/ bCompile( FALSE ), +/*N*/ bSubTotal( FALSE ), +/*N*/ pDocument( pDoc ), +/*N*/ nFormatType( 0 ), +/*N*/ nFormatIndex(0), +/*N*/ pMatrix ( NULL ), +/*N*/ bIsIterCell (FALSE), +/*N*/ bInChangeTrack( FALSE ), +/*N*/ bTableOpDirty( FALSE ), +/*N*/ pPrevious(0), +/*N*/ pNext(0), +/*N*/ pPreviousTrack(0), +/*N*/ pNextTrack(0), +/*N*/ nMatCols(0), +/*N*/ nMatRows(0) +/*N*/ { +/*N*/ // ScReadHeader aHdr( rStream ); +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ USHORT nVer = (USHORT) pDoc->GetSrcVersion(); +/*N*/ +/*N*/ if( nVer >= SC_NUMFMT ) +/*N*/ { +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ #ifdef DBG_UTIL +/*N*/ // static BOOL bShown = 0; +/*N*/ // if ( !bShown && SOFFICE_FILEFORMAT_NOW > SOFFICE_FILEFORMAT_50 ) +/*N*/ // { +/*N*/ // bShown = 1; +/*N*/ // DBG_ERRORFILE( "bei inkompatiblem FileFormat den FormatIndex umheben!" ); +/*N*/ // } +/*N*/ #endif +/*N*/ if( cData & 0x0F ) +/*N*/ { +/*N*/ BYTE nSkip = cData & 0x0F; +/*N*/ if ( (cData & 0x10) && nSkip >= sizeof(UINT32) ) +/*N*/ { +/*N*/ UINT32 n; +/*N*/ rStream >> n; +/*N*/ nFormatIndex = n; +/*N*/ nSkip -= sizeof(UINT32); +/*N*/ } +/*N*/ if ( nSkip ) +/*?*/ rStream.SeekRel( nSkip ); +/*N*/ } +/*N*/ BYTE cFlags; +/*N*/ rStream >> cFlags >> nFormatType; +/*N*/ cMatrixFlag = (BYTE) ( cFlags & 0x03 ); +/*N*/ bDirty = BOOL( ( cFlags & 0x04 ) != 0 ); +/*N*/ if( cFlags & 0x08 ) +/*N*/ rStream >> nErgValue; +/*N*/ if( cFlags & 0x10 ) +/*N*/ { +/*N*/ rStream.ReadByteString( aErgString, rStream.GetStreamCharSet() ); +/*N*/ bIsValue = FALSE; +/*N*/ } +/*N*/ pCode->Load( rStream, nVer, aPos ); +/*N*/ if ( (cFlags & 0x18) == 0 ) +/*N*/ bDirty = TRUE; // #67161# no result stored => recalc +/*N*/ if( cFlags & 0x20 ) +/*N*/ bSubTotal = TRUE; +/*N*/ else if ( nVer < SC_SUBTOTAL_BUGFIX ) +/*N*/ { // #65285# in alten Dokumenten war Flag nicht gesetzt, wenn Formel +/*?*/ // manuell eingegeben wurde (nicht via Daten->Teilergebnisse) +/*N*/ if ( pCode->HasOpCodeRPN( ocSubTotal ) ) +/*N*/ { +/*?*/ bDirty = TRUE; // neu berechnen +/*?*/ bSubTotal = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if ( cMatrixFlag == MM_FORMULA && rHdr.BytesLeft() ) +/*N*/ rStream >> nMatCols >> nMatRows; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ UINT16 nCodeLen; +/*N*/ if( pDoc->GetSrcVersion() >= SC_FORMULA_LCLVER ) +/*N*/ rStream.SeekRel( 2 ); +/*N*/ rStream >> cMatrixFlag >> nCodeLen; +/*N*/ if( cMatrixFlag == 5 ) +/*N*/ cMatrixFlag = 0; +/*N*/ cMatrixFlag &= 3; +/*N*/ if( nCodeLen ) +/*N*/ pCode->Load30( rStream, aPos ); +/*N*/ // Wir koennen hier bei Calc 3.0-Docs noch kein UPN-Array +/*N*/ // erzeugen, da die Named Ranges noch nicht eingelesen sind +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ // after loading, it must be known if ocMacro is in any formula +/*N*/ // (for macro warning, and to insert the hidden view) +/*N*/ if ( !pDoc->GetHasMacroFunc() && pCode->HasOpCodeRPN( ocMacro ) ) +/*N*/ pDoc->SetHasMacroFunc( TRUE ); +/*N*/ } + +/*N*/ BOOL lcl_IsBeyond( ScTokenArray* pCode, USHORT nMaxRow ) +/*N*/ { +/*N*/ ScToken* t; +/*N*/ pCode->Reset(); +/*N*/ while ( t = pCode->GetNextReferenceRPN() ) // RPN -> auch in Namen +/*N*/ if ( t->GetSingleRef().nRow > nMaxRow || +/*N*/ (t->GetType() == svDoubleRef && +/*N*/ t->GetDoubleRef().Ref2.nRow > nMaxRow) ) +/*N*/ return TRUE; +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScFormulaCell::Save( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ USHORT nSaveMaxRow = pDocument->GetSrcMaxRow(); +/*N*/ if ( nSaveMaxRow < MAXROW && lcl_IsBeyond( pCode, nSaveMaxRow ) ) +/*N*/ { +/*?*/ // Zelle mit Ref-Error erzeugen und speichern +/*?*/ // StartEntry/EndEntry passiert beim Speichern der neuen Zelle +/*?*/ +/*?*/ SingleRefData aRef; +/*?*/ aRef.InitAddress(ScAddress()); +/*?*/ aRef.SetColRel(TRUE); +/*?*/ aRef.SetColDeleted(TRUE); +/*?*/ aRef.SetRowRel(TRUE); +/*?*/ aRef.SetRowDeleted(TRUE); +/*?*/ aRef.CalcRelFromAbs(aPos); +/*?*/ ScTokenArray aArr; +/*?*/ aArr.AddSingleReference(aRef); +/*?*/ aArr.AddOpCode(ocStop); +/*?*/ ScFormulaCell* pErrCell = new ScFormulaCell( pDocument, aPos, &aArr ); +/*?*/ pErrCell->Save( rStream, rHdr ); +/*?*/ delete pErrCell; +/*?*/ +/*?*/ pDocument->SetLostData(); // Warnung ausgeben +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ if ( bIsValue && !pCode->GetError() && !::rtl::math::isFinite( nErgValue ) ) +/*N*/ { +/*N*/ DBG_ERRORFILE( msgDbgInfinity ); +/*N*/ pCode->SetError( errIllegalFPOperation ); +/*N*/ } +/*N*/ BYTE cFlags = cMatrixFlag & 0x03; +/*N*/ if( bDirty ) +/*N*/ cFlags |= 0x04; +/*N*/ // Daten speichern? +/*N*/ if( pCode->IsRecalcModeNormal() && !pCode->GetError() ) +/*N*/ cFlags |= bIsValue ? 0x08 : 0x10; +/*N*/ if ( bSubTotal ) +/*N*/ cFlags |= 0x20; +/*N*/ #ifdef DBG_UTIL +/*N*/ static BOOL bShown = 0; +/*N*/ if ( !bShown && rStream.GetVersion() > SOFFICE_FILEFORMAT_50 ) +/*N*/ { +/*N*/ bShown = 1; +/*N*/ DBG_ERRORFILE( "bei inkompatiblem FileFormat den FormatIndex umheben!" ); +/*N*/ } +/*N*/ // rStream << (BYTE) 0x00; +/*N*/ #endif +/*N*/ if ( nFormatIndex ) +/*N*/ rStream << (BYTE) (0x10 | sizeof(UINT32)) << static_cast<sal_uInt32>(nFormatIndex); +/*N*/ else +/*N*/ rStream << (BYTE) 0x00; +/*N*/ rStream << cFlags << (UINT16) nFormatType; +/*N*/ if( cFlags & 0x08 ) +/*N*/ rStream << nErgValue; +/*N*/ if( cFlags & 0x10 ) +/*N*/ rStream.WriteByteString( aErgString, rStream.GetStreamCharSet() ); +/*N*/ pCode->Store( rStream, aPos ); +/*N*/ if ( cMatrixFlag == MM_FORMULA ) +/*N*/ rStream << nMatCols << nMatRows; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ ScBaseCell* ScFormulaCell::Clone( ScDocument* pDoc, const ScAddress& rPos, +/*N*/ BOOL bNoListening ) const +/*N*/ { +/*N*/ ScFormulaCell* pCell = new ScFormulaCell( pDoc, rPos, *this ); +/*N*/ if ( !bNoListening ) +/*N*/ pCell->StartListeningTo( pDoc ); +/*N*/ return pCell; +/*N*/ } + +/*N*/ void ScFormulaCell::GetFormula( String& rFormula ) const +/*N*/ { +/*N*/ if( pCode->GetError() && !pCode->GetLen() ) +/*N*/ { +/*?*/ rFormula = ScGlobal::GetErrorString( pCode->GetError() ); return; +/*N*/ } +/*N*/ else if( cMatrixFlag == MM_REFERENCE ) +/*N*/ { +/*N*/ // Referenz auf eine andere Zelle, die eine Matrixformel enthaelt +/*N*/ pCode->Reset(); +/*N*/ ScToken* p = pCode->GetNextReferenceRPN(); +/*N*/ if( p ) +/*N*/ { +/*N*/ ScBaseCell* pCell = NULL; +/*N*/ if ( !IsInChangeTrack() ) +/*N*/ { +/*N*/ SingleRefData& rRef = p->GetSingleRef(); +/*N*/ rRef.CalcAbsIfRel( aPos ); +/*N*/ if ( rRef.Valid() ) +/*N*/ pCell = pDocument->GetCell( ScAddress( rRef.nCol, +/*N*/ rRef.nRow, rRef.nTab ) ); +/*N*/ } +/*N*/ if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ((ScFormulaCell*)pCell)->GetFormula(rFormula); +/*N*/ return; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*?*/ aComp.CreateStringFromTokenArray( rFormula ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("ScFormulaCell::GetFormula: Keine Matrix"); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*N*/ aComp.CreateStringFromTokenArray( rFormula ); +/*N*/ } +/*N*/ +/*N*/ rFormula.Insert( '=',0 ); +/*N*/ if( cMatrixFlag ) +/*N*/ { +/*N*/ rFormula.Insert('{', 0); +/*N*/ rFormula += '}'; +/*N*/ } +/*N*/ } + +/*N*/ void ScFormulaCell::Compile( const String& rFormula, BOOL bNoListening ) +/*N*/ { +/*N*/ if ( pDocument->IsClipOrUndo() ) return; +/*N*/ BOOL bWasInFormulaTree = pDocument->IsInFormulaTree( this ); +/*N*/ if ( bWasInFormulaTree ) +/*?*/ pDocument->RemoveFromFormulaTree( this ); +/*N*/ // pCode darf fuer Abfragen noch nicht geloescht, muss aber leer sein +/*N*/ if ( pCode ) +/*N*/ pCode->Clear(); +/*N*/ ScTokenArray* pCodeOld = pCode; +/*N*/ ScCompiler aComp(pDocument, aPos); +/*N*/ if ( pDocument->IsImportingXML() ) +/*?*/ aComp.SetCompileEnglish( TRUE ); +/*N*/ pCode = aComp.CompileString( rFormula ); +/*N*/ if ( pCodeOld ) +/*N*/ delete pCodeOld; +/*N*/ if( !pCode->GetError() ) +/*N*/ { +/*N*/ if ( !pCode->GetLen() && aErgString.Len() && rFormula == aErgString ) +/*N*/ { // #65994# nicht rekursiv CompileTokenArray/Compile/CompileTokenArray +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( rFormula.GetChar(0) == '=' ) +/*N*/ } +/*N*/ bCompile = TRUE; +/*N*/ CompileTokenArray( bNoListening ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bChanged = TRUE; +/*N*/ SetTextWidth( TEXTWIDTH_DIRTY ); +/*N*/ SetScriptType( SC_SCRIPTTYPE_UNKNOWN ); +/*N*/ } +/*N*/ if ( bWasInFormulaTree ) +/*?*/ pDocument->PutInFormulaTree( this ); +/*N*/ } + + +/*N*/ void ScFormulaCell::CompileTokenArray( BOOL bNoListening ) +/*N*/ { +/*N*/ // Noch nicht compiliert? +/*N*/ if( !pCode->GetLen() && aErgString.Len() ) +/*N*/ Compile( aErgString ); +/*N*/ else if( bCompile && !pDocument->IsClipOrUndo() && !pCode->GetError() ) +/*N*/ { +/*N*/ // RPN-Laenge kann sich aendern +/*N*/ BOOL bWasInFormulaTree = pDocument->IsInFormulaTree( this ); +/*N*/ if ( bWasInFormulaTree ) +/*?*/ pDocument->RemoveFromFormulaTree( this ); +/*N*/ +/*N*/ // Laden aus Filter? Dann noch nix machen! +/*N*/ if( pDocument->IsInsertingFromOtherDoc() ) +/*N*/ bNoListening = TRUE; +/*N*/ +/*N*/ if( !bNoListening && pCode->GetCodeLen() ) +/*?*/ EndListeningTo( pDocument ); +/*N*/ ScCompiler aComp(pDocument, aPos, *pCode ); +/*N*/ bSubTotal = aComp.CompileTokenArray(); +/*N*/ if( !pCode->GetError() ) +/*N*/ { +/*N*/ nFormatType = aComp.GetNumFormatType(); +/*N*/ nFormatIndex = 0; +/*N*/ bChanged = TRUE; +/*N*/ nErgValue = 0.0; +/*N*/ aErgString.Erase(); +/*N*/ bCompile = FALSE; +/*N*/ if ( !bNoListening ) +/*N*/ StartListeningTo( pDocument ); +/*N*/ } +/*N*/ if ( bWasInFormulaTree ) +/*?*/ pDocument->PutInFormulaTree( this ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScFormulaCell::CompileXML( ScProgress& rProgress ) +/*N*/ { +/*N*/ if ( cMatrixFlag == MM_REFERENCE ) +/*N*/ { // is already token code via ScDocFunc::EnterMatrix, ScDocument::InsertMatrixFormula +/*N*/ // just establish listeners +/*N*/ StartListeningTo( pDocument ); +/*N*/ return ; +/*N*/ } +/*N*/ +/*N*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*N*/ aComp.SetCompileEnglish( TRUE ); +/*N*/ aComp.SetImportXML( TRUE ); +/*N*/ String aFormula; +/*N*/ aComp.CreateStringFromTokenArray( aFormula ); +/*N*/ pDocument->DecXMLImportedFormulaCount( aFormula.Len() ); +/*N*/ rProgress.SetStateCountDownOnPercent( pDocument->GetXMLImportedFormulaCount() ); +/*N*/ // pCode darf fuer Abfragen noch nicht geloescht, muss aber leer sein +/*N*/ if ( pCode ) +/*N*/ pCode->Clear(); +/*N*/ ScTokenArray* pCodeOld = pCode; +/*N*/ pCode = aComp.CompileString( aFormula ); +/*N*/ delete pCodeOld; +/*N*/ if( !pCode->GetError() ) +/*N*/ { +/*N*/ if ( !pCode->GetLen() ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( aFormula.GetChar(0) == '=' ) +/*N*/ } +/*N*/ bSubTotal = aComp.CompileTokenArray(); +/*N*/ if( !pCode->GetError() ) +/*N*/ { +/*N*/ nFormatType = aComp.GetNumFormatType(); +/*N*/ nFormatIndex = 0; +/*N*/ bChanged = TRUE; +/*N*/ bCompile = FALSE; +/*N*/ StartListeningTo( pDocument ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bChanged = TRUE; +/*N*/ SetTextWidth( TEXTWIDTH_DIRTY ); +/*N*/ SetScriptType( SC_SCRIPTTYPE_UNKNOWN ); +/*N*/ } +/*N*/ +/*N*/ // Same as in Load: after loading, it must be known if ocMacro is in any formula +/*N*/ // (for macro warning, CompileXML is called at the end of loading XML file) +/*N*/ if ( !pDocument->GetHasMacroFunc() && pCode->HasOpCodeRPN( ocMacro ) ) +/*N*/ pDocument->SetHasMacroFunc( TRUE ); +/*N*/ } + + +/*N*/ void ScFormulaCell::CalcAfterLoad() +/*N*/ { +/*N*/ BOOL bNewCompiled = FALSE; +/*N*/ // Falls ein Calc 1.0-Doc eingelesen wird, haben wir ein Ergebnis, +/*N*/ // aber kein TokenArray +/*N*/ if( !pCode->GetLen() && aErgString.Len() ) +/*N*/ { +/*?*/ Compile( aErgString, TRUE ); +/*?*/ aErgString.Erase(); +/*?*/ bDirty = TRUE; +/*?*/ bNewCompiled = TRUE; +/*N*/ } +/*N*/ // Das UPN-Array wird nicht erzeugt, wenn ein Calc 3.0-Doc eingelesen +/*N*/ // wurde, da die RangeNames erst jetzt existieren. +/*N*/ if( pCode->GetLen() && !pCode->GetCodeLen() && !pCode->GetError() ) +/*N*/ { +/*N*/ ScCompiler aComp(pDocument, aPos, *pCode); +/*N*/ bSubTotal = aComp.CompileTokenArray(); +/*N*/ nFormatType = aComp.GetNumFormatType(); +/*N*/ nFormatIndex = 0; +/*N*/ bDirty = TRUE; +/*N*/ bCompile = FALSE; +/*N*/ bNewCompiled = TRUE; +/*N*/ } +/*N*/ // irgendwie koennen unter os/2 mit rotter FPU-Exception /0 ohne Err503 +/*N*/ // gespeichert werden, woraufhin spaeter im NumberFormatter die BLC Lib +/*N*/ // bei einem fabs(-NAN) abstuerzt (#32739#) +/*N*/ // hier fuer alle Systeme ausbuegeln, damit da auch Err503 steht +/*N*/ if ( bIsValue && !::rtl::math::isFinite( nErgValue ) ) +/*N*/ { +/*?*/ DBG_ERRORFILE("Formelzelle INFINITY !!! Woher kommt das Dokument?"); +/*?*/ nErgValue = 0.0; +/*?*/ pCode->SetError( errIllegalFPOperation ); +/*?*/ bDirty = TRUE; +/*N*/ } +/*N*/ // DoubleRefs bei binaeren Operatoren waren vor v5.0 immer Matrix, +/*N*/ // jetzt nur noch wenn in Matrixformel, sonst implizite Schnittmenge +/*N*/ if ( pDocument->GetSrcVersion() < SC_MATRIX_DOUBLEREF && +/*N*/ GetMatrixFlag() == MM_NONE && pCode->HasMatrixDoubleRefOps() ) +/*N*/ { +/*N*/ cMatrixFlag = MM_FORMULA; +/*N*/ nMatCols = 1; +/*N*/ nMatRows = 1; +/*N*/ } +/*N*/ // Muss die Zelle berechnet werden? +/*N*/ // Nach Load koennen Zellen einen Fehlercode enthalten, auch dann +/*N*/ // Listener starten und ggbf. neu berechnen wenn nicht RECALCMODE_NORMAL +/*N*/ if( !bNewCompiled || !pCode->GetError() ) +/*N*/ { +/*N*/ StartListeningTo( pDocument ); +/*N*/ if( !pCode->IsRecalcModeNormal() ) +/*N*/ bDirty = TRUE; +/*N*/ } +/*N*/ if ( pCode->GetError() == errInterpOverflow ) +/*N*/ { // versuchen Err527 wegzubuegeln +/*N*/ bDirty = TRUE; +/*N*/ } +/*N*/ else if ( pCode->IsRecalcModeAlways() ) +/*N*/ { // zufall(), heute(), jetzt() bleiben immer im FormulaTree, damit sie +/*N*/ // auch bei jedem F9 berechnet werden. +/*N*/ bDirty = TRUE; +/*N*/ } +/*N*/ // Noch kein SetDirty weil noch nicht alle Listener bekannt, erst in +/*N*/ // SetDirtyAfterLoad. +/*N*/ } + +/*N*/ void ScFormulaCell::Interpret() +/*N*/ { +/*N*/ static USHORT nRecCount = 0; +/*N*/ static ScFormulaCell* pLastIterInterpreted = NULL; +/*N*/ if ( !IsDirtyOrInTableOpDirty() ) +/*N*/ return; // fuer IterCircRef, nix doppelt +/*N*/ +/*N*/ //! HACK: +/*N*/ // Wenn der Aufruf aus einem Reschedule im DdeLink-Update kommt, dirty stehenlassen +/*N*/ // Besser: Dde-Link Update ohne Reschedule oder ganz asynchron !!! +/*N*/ +/*N*/ if ( pDocument->IsInDdeLinkUpdate() ) +/*N*/ return; +/*N*/ +/*N*/ if (bRunning) +/*N*/ { +/*N*/ // Keine Iterierung? +/*N*/ if (!pDocument->GetDocOptions().IsIter()) +/*N*/ pCode->SetError( errCircularReference ); +/*N*/ else +/*N*/ { +/*?*/ if (pCode->GetError() == errCircularReference) +/*?*/ pCode->SetError( 0 ); +/*?*/ nIterMode = 1; +/*?*/ bIsIterCell = TRUE; +/*?*/ pLastIterInterpreted = NULL; +/*N*/ } +/*N*/ return; +/*N*/ } +/*N*/ // #63038# fuer GetErrCode, IsValue, GetValue nicht mehrfach interpretieren +/*N*/ if ( nIterMode && pLastIterInterpreted == this ) +/*N*/ return ; +/*N*/ +/*N*/ if( !pCode->GetCodeLen() && !pCode->GetError() ) +/*N*/ { +/*N*/ // #i11719# no UPN and no error and no token code but result string present +/*N*/ // => interpretation of this cell during name-compilation and unknown names +/*N*/ // => can't exchange underlying code array in CompileTokenArray() / +/*N*/ // Compile() because interpreter's token iterator would crash. +/*N*/ // This should only be a temporary condition and, since we set an +/*N*/ // error, if ran into it again we'd bump into the dirty-clearing +/*N*/ // condition further down. +/*N*/ if ( !pCode->GetLen() && aErgString.Len() ) +/*N*/ { +/*N*/ pCode->SetError( errNoCode ); +/*N*/ // This is worth an assertion; if encountered in daily work +/*N*/ // documents we might need another solution. Or just confirm correctness. +/*N*/ DBG_ERRORFILE( "ScFormulaCell::Interpret: no UPN, no error, no token, but string" ); +/*N*/ return; +/*N*/ } +/*?*/ CompileTokenArray(); +/*N*/ } +/*N*/ +/*N*/ if( pCode->GetCodeLen() && pDocument ) +/*N*/ { +/*N*/ #if defined(MAC) && !defined(SIMPLEMAXRECURSION) +/*N*/ if( StackSpace() < 2048 ) // 2K Stack noch uebriglassen +/*N*/ #else +/*N*/ if( nRecCount > MAXRECURSION ) +/*N*/ #endif +/*N*/ { +/*?*/ pCode->SetError( errInterpOverflow ); +/*?*/ // Zelle bleibt in FormulaTree, naechstes Mal sind evtl. +/*?*/ // Vorgaenger bereits berechnet worden bzw. von der View wird +/*?*/ // via ScCellFormat::GetString CalcFormulaTree angeworfen +/*?*/ bDirty = FALSE; +/*?*/ bTableOpDirty = FALSE; +/*?*/ nErgValue = 0.0; +/*?*/ bIsValue = TRUE; +/*?*/ nIterMode = 0; +/*?*/ bIsIterCell = FALSE; +/*?*/ pLastIterInterpreted = NULL; +/*?*/ bChanged = TRUE; +/*?*/ SetTextWidth( TEXTWIDTH_DIRTY ); +/*?*/ SetScriptType( SC_SCRIPTTYPE_UNKNOWN ); +/*?*/ return; +/*N*/ } +/*N*/ nRecCount++; +/*N*/ pDocument->IncInterpretLevel(); +/*N*/ ScInterpreter* p = new ScInterpreter( this, pDocument, aPos, *pCode ); +/*N*/ USHORT nOldErrCode = pCode->GetError(); +/*N*/ USHORT nIterCount = 0; +/*N*/ if ( nIterMode == 0 ) +/*N*/ { // nur beim ersten Mal +/*N*/ // wenn neu kompilierte Zelle 0.0 ergibt wird kein Changed erkannt +/*N*/ // und die Zelle wird nicht sofort repainted! +/*N*/ // bChanged = FALSE; +/*N*/ if ( nOldErrCode == errNoConvergence +/*N*/ && pDocument->GetDocOptions().IsIter() ) +/*?*/ pCode->SetError( 0 ); +/*N*/ } +/*N*/ BOOL bRepeat = TRUE; +/*N*/ while( bRepeat ) +/*N*/ { +/*N*/ if ( pMatrix ) +/*N*/ { +/*?*/ delete pMatrix; +/*?*/ pMatrix = NULL; +/*N*/ } +/*N*/ +/*N*/ switch ( pCode->GetError() ) +/*N*/ { +/*?*/ case errCircularReference : // wird neu festgestellt +/*?*/ case errInterpOverflow : // Err527 eine Chance geben +/*?*/ pCode->SetError( 0 ); +/*?*/ break; +/*N*/ } +/*N*/ +/*N*/ bRunning = TRUE; +/*N*/ p->Interpret(); +/*N*/ bRunning = FALSE; +/*N*/ if( pCode->GetError() +/*N*/ && pCode->GetError() != errCircularReference ) +/*N*/ { +/*N*/ bDirty = FALSE; +/*N*/ bTableOpDirty = FALSE; +/*N*/ nIterMode = 0; +/*N*/ bIsIterCell = FALSE; +/*N*/ pLastIterInterpreted = NULL; +/*N*/ bChanged = TRUE; +/*N*/ bIsValue = TRUE; +/*N*/ break; +/*N*/ } +/*N*/ if( nIterMode == 1 && bIsIterCell ) +/*N*/ { +/*?*/ pLastIterInterpreted = NULL; +/*?*/ ++nIterCount; +/*?*/ // schoen konvergiert? +/*?*/ if( (p->GetResultType() == svDouble +/*?*/ && fabs( p->GetNumResult() - nErgValue ) <= +/*?*/ pDocument->GetDocOptions().GetIterEps()) +/*?*/ ) +/*?*/ { +/*?*/ nIterMode = 0; +/*?*/ bIsIterCell = FALSE; +/*?*/ bDirty = FALSE; +/*?*/ bTableOpDirty = FALSE; +/*?*/ bRepeat = FALSE; +/*?*/ } +/*?*/ // Zu oft rumgelaufen? +/*?*/ else if( nIterCount >= pDocument->GetDocOptions().GetIterCount() ) +/*?*/ { +/*?*/ nIterMode = 0; +/*?*/ bIsIterCell = FALSE; +/*?*/ bDirty = FALSE; +/*?*/ bTableOpDirty = FALSE; +/*?*/ bRepeat = FALSE; +/*?*/ pCode->SetError( errNoConvergence ); +/*?*/ } +/*?*/ if ( p->GetResultType() == svDouble ) +/*?*/ { +/*?*/ if( !bIsValue || nErgValue != p->GetNumResult() ) +/*?*/ bChanged = TRUE; +/*?*/ bIsValue = TRUE; +/*?*/ nErgValue = p->GetNumResult(); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ bRepeat = FALSE; +/*N*/ } +/*N*/ +/*N*/ switch( p->GetResultType() ) +/*N*/ { +/*N*/ case svDouble: +/*N*/ if( nErgValue != p->GetNumResult() || !bIsValue ) +/*N*/ { +/*N*/ bChanged = TRUE; +/*N*/ bIsValue = TRUE; +/*N*/ nErgValue = p->GetNumResult(); +/*N*/ } +/*N*/ break; +/*N*/ case svString: +/*N*/ if( aErgString != p->GetStringResult() || bIsValue ) +/*N*/ { +/*N*/ bChanged = TRUE; +/*N*/ bIsValue = FALSE; +/*N*/ aErgString = p->GetStringResult(); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ // Neuer Fehlercode? +/*N*/ if( !bChanged && pCode->GetError() != nOldErrCode ) +/*N*/ bChanged = TRUE; +/*N*/ // Anderes Zahlenformat? +/*N*/ if( nFormatType != p->GetRetFormatType() ) +/*N*/ { +/*N*/ nFormatType = p->GetRetFormatType(); +/*N*/ bChanged = TRUE; +/*N*/ } +/*N*/ if( nFormatIndex != p->GetRetFormatIndex() ) +/*N*/ { +/*N*/ nFormatIndex = p->GetRetFormatIndex(); +/*N*/ bChanged = TRUE; +/*N*/ } +/*N*/ // Genauigkeit wie angezeigt? +/*N*/ if ( bIsValue && !pCode->GetError() +/*N*/ && pDocument->GetDocOptions().IsCalcAsShown() +/*N*/ && nFormatType != NUMBERFORMAT_DATE +/*N*/ && nFormatType != NUMBERFORMAT_TIME +/*N*/ && nFormatType != NUMBERFORMAT_DATETIME ) +/*N*/ { +/*?*/ ULONG nFormat = pDocument->GetNumberFormat( aPos ); +/*?*/ if ( nFormatIndex && (nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 ) +/*?*/ nFormat = nFormatIndex; +/*?*/ if ( (nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 ) +/*?*/ nFormat = ScGlobal::GetStandardFormat( +/*?*/ *pDocument->GetFormatTable(), nFormat, nFormatType ); +/*?*/ nErgValue = pDocument->RoundValueAsShown( nErgValue, nFormat ); +/*N*/ } +/*N*/ if ( nIterMode == 0 ) +/*N*/ { +/*N*/ bDirty = FALSE; +/*N*/ bTableOpDirty = FALSE; +/*N*/ } +/*N*/ else +/*N*/ pLastIterInterpreted = this; +/*N*/ pMatrix = p->GetMatrixResult(); +/*N*/ if( pMatrix ) +/*N*/ { +/*N*/ #if 0 +/*?*/ //! MatrixFormel immer changed?!? +/*?*/ // ist bei MD's Rundumschlag von r1.167 --> r1.168 reingekommen +/*?*/ // => ewiges Repaint von MatrixFormel, besonders bei DDE laestig +/*?*/ // ab r1.260 (sv369b) probieren wir's mal ohne.. +/*?*/ if( cMatrixFlag == MM_FORMULA ) +/*?*/ bChanged = TRUE; +/*?*/ else +/*N*/ #else +/*N*/ if( cMatrixFlag != MM_FORMULA ) +/*N*/ #endif +/*N*/ { // mit linker oberer Ecke weiterleben +/*?*/ delete pMatrix; +/*?*/ pMatrix = NULL; +/*N*/ } +/*N*/ } +/*N*/ if( bChanged ) +/*N*/ { +/*N*/ SetTextWidth( TEXTWIDTH_DIRTY ); +/*N*/ SetScriptType( SC_SCRIPTTYPE_UNKNOWN ); +/*N*/ } +/*N*/ delete p; +/*N*/ nRecCount--; +/*N*/ pDocument->DecInterpretLevel(); +/*N*/ if ( pCode->GetError() != errInterpOverflow +/*N*/ && !pCode->IsRecalcModeAlways() ) +/*N*/ pDocument->RemoveFromFormulaTree( this ); +/*N*/ #ifdef DBG_UTIL +/*N*/ if ( bIsValue && !pCode->GetError() && !::rtl::math::isFinite( nErgValue ) ) +/*N*/ { +/*N*/ DBG_ERRORFILE( msgDbgInfinity ); +/*N*/ nErgValue = 0.0; +/*N*/ pCode->SetError( errIllegalFPOperation ); +/*N*/ } +/*N*/ #endif +/*N*/ +/*N*/ // FORCED Zellen auch sofort auf Gueltigkeit testen (evtl. Makro starten) +/*N*/ +/*N*/ if ( pCode->IsRecalcModeForced() ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ ULONG nValidation = ((const SfxUInt32Item*) pDocument->GetAttr( +/*N*/ } +/*N*/ +/*N*/ // Reschedule verlangsamt das ganze erheblich, nur bei Prozentaenderung ausfuehren +/*N*/ ScProgress::GetInterpretProgress()->SetStateCountDownOnPercent( +/*N*/ pDocument->GetFormulaCodeInTree() ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // Zelle bei Compiler-Fehlern nicht ewig auf dirty stehenlassen +/*N*/ DBG_ASSERT( pCode->GetError(), "kein UPN-Code und kein Fehler ?!?!" ); +/*N*/ bDirty = FALSE; +/*N*/ bTableOpDirty = FALSE; +/*N*/ } +/*N*/ } + +/*N*/ ULONG ScFormulaCell::GetStandardFormat( SvNumberFormatter& rFormatter, ULONG nFormat ) const +/*N*/ { +/*N*/ if ( nFormatIndex && (nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 ) +/*N*/ return nFormatIndex; +/*N*/ if ( bIsValue ) //! nicht IsValue() +/*N*/ return ScGlobal::GetStandardFormat( nErgValue, rFormatter, nFormat, nFormatType ); +/*N*/ else +/*N*/ return ScGlobal::GetStandardFormat( rFormatter, nFormat, nFormatType ); +/*N*/ } + + +/*N*/ void __EXPORT ScFormulaCell::SFX_NOTIFY( SfxBroadcaster& rBC, +/*N*/ const TypeId& rBCType, const SfxHint& rHint, const TypeId& rHintType ) +/*N*/ { +/*N*/ if ( !pDocument->IsInDtorClear() && !pDocument->GetHardRecalcState() ) +/*N*/ { +/*N*/ const ScHint* p = PTR_CAST( ScHint, &rHint ); +/*N*/ if( p && (p->GetId() & (SC_HINT_DATACHANGED | SC_HINT_DYING | +/*N*/ SC_HINT_TABLEOPDIRTY)) ) +/*N*/ { +/*N*/ BOOL bForceTrack = FALSE; +/*N*/ if ( p->GetId() & SC_HINT_TABLEOPDIRTY ) +/*N*/ { +/*?*/ bForceTrack = !bTableOpDirty; +/*?*/ if ( !bTableOpDirty ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 pDocument->AddTableOpFormulaCell( this ); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bForceTrack = !bDirty; +/*N*/ bDirty = TRUE; +/*N*/ } +/*N*/ // #35962# Don't remove from FormulaTree to put in FormulaTrack to +/*N*/ // put in FormulaTree again and again, only if necessary. +/*N*/ // Any other means except RECALCMODE_ALWAYS by which a cell could +/*N*/ // be in FormulaTree if it would notify other cells through +/*N*/ // FormulaTrack which weren't in FormulaTrack/FormulaTree before?!? +/*N*/ // #87866# Yes. The new TableOpDirty made it necessary to have a +/*N*/ // forced mode where formulas may still be in FormulaTree from +/*N*/ // TableOpDirty but have to notify dependents for normal dirty. +/*N*/ if ( (bForceTrack || !pDocument->IsInFormulaTree( this ) +/*N*/ || pCode->IsRecalcModeAlways()) +/*N*/ && !pDocument->IsInFormulaTrack( this ) ) +/*N*/ pDocument->AppendToFormulaTrack( this ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScFormulaCell::SetDirty() +/*N*/ { +/*N*/ if ( !IsInChangeTrack() ) +/*N*/ { +/*N*/ if ( pDocument->GetHardRecalcState() ) +/*N*/ bDirty = TRUE; +/*N*/ else +/*N*/ { +/*N*/ // Mehrfach-FormulaTracking in Load und in CompileAll +/*N*/ // nach CopyScenario und CopyBlockFromClip vermeiden. +/*N*/ // Wenn unbedingtes FormulaTracking noetig, vor SetDirty bDirty=FALSE +/*N*/ // setzen, z.B. in CompileTokenArray +/*N*/ if ( !bDirty || !pDocument->IsInFormulaTree( this ) ) +/*N*/ { +/*N*/ bDirty = TRUE; +/*N*/ pDocument->AppendToFormulaTrack( this ); +/*N*/ pDocument->TrackFormulas(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScFormulaCell::SetTableOpDirty() +/*N*/ { +/*N*/ if ( !IsInChangeTrack() ) +/*N*/ { +/*N*/ if ( pDocument->GetHardRecalcState() ) +/*N*/ bTableOpDirty = TRUE; +/*N*/ else +/*N*/ { +/*N*/ if ( !bTableOpDirty || !pDocument->IsInFormulaTree( this ) ) +/*N*/ { +/*N*/ if ( !bTableOpDirty ) +/*N*/ { +/*N*/ pDocument->AddTableOpFormulaCell( this ); +/*N*/ bTableOpDirty = TRUE; +/*N*/ } +/*N*/ pDocument->AppendToFormulaTrack( this ); +/*N*/ pDocument->TrackFormulas( SC_HINT_TABLEOPDIRTY ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScFormulaCell::IsDirtyOrInTableOpDirty() +/*N*/ { +/*N*/ return bDirty || (bTableOpDirty && pDocument->IsInInterpreterTableOp()); +/*N*/ } + + +/*N*/ void ScFormulaCell::SetErrCode( USHORT n ) +/*N*/ { +/*N*/ pCode->SetError( n ); +/*N*/ bIsValue = FALSE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScDetectiveRefIter::ScDetectiveRefIter( ScFormulaCell* pCell ) +/*N*/ { +/*N*/ pCode = pCell->GetCode(); +/*N*/ pCode->Reset(); +/*N*/ aPos = pCell->aPos; +/*N*/ } + +/*N*/ BOOL lcl_ScDetectiveRefIter_SkipRef( ScToken* p ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = p->GetSingleRef(); +/*N*/ if ( rRef1.IsColDeleted() || rRef1.IsRowDeleted() || rRef1.IsTabDeleted() +/*N*/ || !rRef1.Valid() ) +/*N*/ return TRUE; +/*N*/ if ( p->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = p->GetDoubleRef().Ref2; +/*N*/ if ( rRef2.IsColDeleted() || rRef2.IsRowDeleted() || rRef2.IsTabDeleted() +/*N*/ || !rRef2.Valid() ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDetectiveRefIter::GetNextRef( ScTripel& rStart, ScTripel& rEnd ) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ +/*N*/ ScToken* p = pCode->GetNextReferenceRPN(); +/*N*/ if (p) +/*N*/ p->CalcAbsIfRel( aPos ); +/*N*/ +/*N*/ while ( p && lcl_ScDetectiveRefIter_SkipRef( p ) ) +/*N*/ { +/*N*/ p = pCode->GetNextReferenceRPN(); +/*N*/ if (p) +/*N*/ p->CalcAbsIfRel( aPos ); +/*N*/ } +/*N*/ +/*N*/ if( p ) +/*N*/ { +/*N*/ SingleDoubleRefProvider aProv( *p ); +/*N*/ rStart.Put( aProv.Ref1.nCol, +/*N*/ aProv.Ref1.nRow, +/*N*/ aProv.Ref1.nTab ); +/*N*/ rEnd.Put( aProv.Ref2.nCol, +/*N*/ aProv.Ref2.nRow, +/*N*/ aProv.Ref2.nTab ); +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + +//----------------------------------------------------------------------------------- + +/*N*/ ScFormulaCell::~ScFormulaCell() +/*N*/ { +/*N*/ pDocument->RemoveFromFormulaTree( this ); +/*N*/ delete pCode; +/*N*/ delete pMatrix; +/*N*/ pMatrix = NULL; +/*N*/ #ifdef DBG_UTIL +/*N*/ eCellType = CELLTYPE_DESTROYED; +/*N*/ #endif +/*N*/ } + + +/*N*/ #ifdef DBG_UTIL +/*N*/ +/*N*/ ScStringCell::~ScStringCell() +/*N*/ { +/*N*/ eCellType = CELLTYPE_DESTROYED; +/*N*/ } +/*N*/ #endif + //! ValueCell auch nur bei DBG_UTIL, + //! auch in cell.hxx aendern !!!!!!!!!!!!!!!!!!!! + +/*N*/ ScValueCell::~ScValueCell() +/*N*/ { +/*N*/ eCellType = CELLTYPE_DESTROYED; +/*N*/ } + +/*N*/ #ifdef DBG_UTIL +/*N*/ +/*N*/ ScNoteCell::~ScNoteCell() +/*N*/ { +/*N*/ eCellType = CELLTYPE_DESTROYED; +/*N*/ } +/*N*/ #endif + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_cell2.cxx b/binfilter/bf_sc/source/core/data/sc_cell2.cxx new file mode 100644 index 000000000000..7cc527200eaf --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_cell2.cxx @@ -0,0 +1,894 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <vcl/mapmod.hxx> +#include <bf_svx/editobj.hxx> + +#include "cell.hxx" +#include "rangenam.hxx" +#include "rechead.hxx" +#include "refupdat.hxx" +#include "editutil.hxx" +#include "chgtrack.hxx" +#include "indexmap.hxx" +namespace binfilter { + + +// STATIC DATA ----------------------------------------------------------- + +#ifdef _MSC_VER +#pragma code_seg("SCSTATICS") +#endif + +#ifdef USE_MEMPOOL +const USHORT nMemPoolEditCell = (0x1000 - 64) / sizeof(ScNoteCell); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScEditCell, nMemPoolEditCell, nMemPoolEditCell ) +#endif + +#ifdef _MSC_VER +#pragma code_seg() +#endif + +// ----------------------------------------------------------------------- + +/*N*/ ScEditCell::ScEditCell( const EditTextObject* pObject, ScDocument* pDocP, +/*N*/ const SfxItemPool* pFromPool ) : +/*N*/ ScBaseCell( CELLTYPE_EDIT ), +/*N*/ pString( NULL ), +/*N*/ pDoc( pDocP ) +/*N*/ { +/*N*/ SetTextObject( pObject, pFromPool ); +/*N*/ } + +/*N*/ ScEditCell::ScEditCell( const ScEditCell& rEditCell, ScDocument* pDocP ) : +/*N*/ ScBaseCell( CELLTYPE_EDIT ), +/*N*/ pString( NULL ), +/*N*/ pDoc( pDocP ) +/*N*/ { +/*N*/ SetTextObject( rEditCell.pData, rEditCell.pDoc->GetEditPool() ); +/*N*/ } + +/*N*/ ScEditCell::ScEditCell( SvStream& rStream, USHORT nVer, ScDocument* pDocP ) : +/*N*/ ScBaseCell( CELLTYPE_EDIT ), +/*N*/ pString( NULL ), +/*N*/ pDoc( pDocP ) +/*N*/ { +/*N*/ if( nVer >= SC_DATABYTES2 ) +/*N*/ { +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ if( cData & 0x0F ) +/*?*/ rStream.SeekRel( cData & 0x0F ); +/*N*/ } +/*N*/ if ( nVer < SC_VERSION_EDITPOOL ) +/*N*/ { // jedes hat seinen eigenen Pool, dem neuen zuordnen +/*?*/ EditTextObject* pTmp = EditTextObject::Create( rStream ); +/*?*/ SetTextObject( pTmp, NULL ); +/*?*/ delete pTmp; +/*N*/ } +/*N*/ else +/*N*/ pData = EditTextObject::Create( rStream, pDoc->GetEditPool() ); +/*N*/ } + +/*N*/ ScEditCell::ScEditCell( const String& rString, ScDocument* pDocP ) : +/*N*/ ScBaseCell( CELLTYPE_EDIT ), +/*N*/ pString( NULL ), +/*N*/ pDoc( pDocP ) +/*N*/ { +/*N*/ DBG_ASSERT( rString.Search('\n') != STRING_NOTFOUND || +/*N*/ rString.Search(CHAR_CR) != STRING_NOTFOUND, +/*N*/ "EditCell mit einfachem Text !?!?" ); +/*N*/ +/*N*/ EditEngine& rEngine = pDoc->GetEditEngine(); +/*N*/ rEngine.SetText( rString ); +/*N*/ pData = rEngine.CreateTextObject(); +/*N*/ } + +/*N*/ ScEditCell::~ScEditCell() +/*N*/ { +/*N*/ delete pData; +/*N*/ delete pString; +/*N*/ +/*N*/ #ifdef DBG_UTIL +/*N*/ eCellType = CELLTYPE_DESTROYED; +/*N*/ #endif +/*N*/ } + + + +/*N*/ void ScEditCell::GetData( const EditTextObject*& rpObject ) const +/*N*/ { +/*N*/ rpObject = pData; +/*N*/ } + +/*N*/ void ScEditCell::GetString( String& rString ) const +/*N*/ { +/*N*/ if ( pString ) +/*N*/ rString = *pString; +/*N*/ else if ( pData ) +/*N*/ { +/*N*/ // auch Text von URL-Feldern, Doc-Engine ist eine ScFieldEditEngine +/*N*/ EditEngine& rEngine = pDoc->GetEditEngine(); +/*N*/ rEngine.SetText( *pData ); +/*N*/ rString = ScEditUtil::GetSpaceDelimitedString(rEngine); // space between paragraphs +/*N*/ // kurze Strings fuer Formeln merken +/*N*/ if ( rString.Len() < MAXSTRLEN ) +/*N*/ ((ScEditCell*)this)->pString = new String( rString ); //! non-const +/*N*/ } +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + +/*N*/ void ScEditCell::Save( SvStream& rStream ) const +/*N*/ { +/*N*/ DBG_ASSERT(pData,"StoreTextObject(NULL)"); +/*N*/ rStream << (BYTE) 0x00; +/*N*/ if ( rStream.GetVersion() < SOFFICE_FILEFORMAT_50 ) +/*N*/ { // jedem seinen eigenen Pool +/*?*/ ScEditEngineDefaulter aEngine( EditEngine::CreatePool(), TRUE ); +/*?*/ // #52396# richtige Metric schreiben +/*?*/ aEngine.SetRefMapMode( MAP_100TH_MM ); +/*?*/ aEngine.SetText( *pData ); +/*?*/ EditTextObject* pTmp = aEngine.CreateTextObject(); +/*?*/ pTmp->Store( rStream ); +/*?*/ delete pTmp; +/*N*/ } +/*N*/ else +/*N*/ pData->Store( rStream ); +/*N*/ } + +/*N*/ void ScEditCell::SetTextObject( const EditTextObject* pObject, +/*N*/ const SfxItemPool* pFromPool ) +/*N*/ { +/*N*/ if ( pObject ) +/*N*/ { +/*N*/ if ( pFromPool && pDoc->GetEditPool() == pFromPool ) +/*N*/ pData = pObject->Clone(); +/*N*/ else +/*N*/ { //! anderer Pool +/*?*/ // Leider gibt es keinen anderen Weg, um den Pool umzuhaengen, +/*N*/ // als das Object durch eine entsprechende Engine zu schleusen.. // cellformats.sdc +/*N*/ /*?*/ EditEngine& rEngine = pDoc->GetEditEngine(); +/*N*/ /*?*/ rEngine.SetText( *pObject ); +/*N*/ /*?*/ pData = rEngine.CreateTextObject(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ pData = NULL; +/*N*/ } + +//--------------------------------------------------------------------- + +/*N*/ void ScFormulaCell::GetEnglishFormula( String& rFormula, BOOL bCompileXML ) const +/*N*/ { +/*N*/ //! mit GetFormula zusammenfassen !!! +/*N*/ +/*N*/ if( pCode->GetError() && !pCode->GetLen() ) +/*N*/ { +/*N*/ rFormula = ScGlobal::GetErrorString( pCode->GetError() ); return; +/*N*/ } +/*N*/ else if( cMatrixFlag == MM_REFERENCE ) +/*N*/ { +/*N*/ // Referenz auf eine andere Zelle, die eine Matrixformel enthaelt +/*N*/ pCode->Reset(); +/*N*/ ScToken* p = pCode->GetNextReferenceRPN(); +/*N*/ if( p ) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ SingleRefData& rRef = p->GetSingleRef(); +/*N*/ rRef.CalcAbsIfRel( aPos ); +/*N*/ if ( rRef.Valid() ) +/*N*/ pCell = pDocument->GetCell( ScAddress( rRef.nCol, +/*N*/ rRef.nRow, rRef.nTab ) ); +/*N*/ else +/*N*/ pCell = NULL; +/*N*/ if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ((ScFormulaCell*)pCell)->GetEnglishFormula(rFormula, bCompileXML); +/*N*/ return; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*N*/ aComp.SetCompileEnglish( TRUE ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ aComp.CreateStringFromTokenArray( rFormula ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("ScFormulaCell::GetEnglishFormula: Keine Matrix"); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*N*/ aComp.SetCompileEnglish( TRUE ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ aComp.CreateStringFromTokenArray( rFormula ); +/*N*/ } +/*N*/ +/*N*/ rFormula.Insert( '=',0 ); +/*N*/ if( cMatrixFlag ) +/*N*/ { +/*N*/ rFormula.Insert('{', 0); +/*N*/ rFormula += '}'; +/*N*/ } +/*N*/ } + +/*N*/ void ScFormulaCell::GetEnglishFormula( ::rtl::OUStringBuffer& rBuffer, BOOL bCompileXML ) const +/*N*/ { +/*N*/ //! mit GetFormula zusammenfassen !!! +/*N*/ +/*N*/ if( pCode->GetError() && !pCode->GetLen() ) +/*N*/ { +/*?*/ rBuffer = ::rtl::OUStringBuffer(ScGlobal::GetErrorString( pCode->GetError() )); return; +/*N*/ } +/*N*/ else if( cMatrixFlag == MM_REFERENCE ) +/*N*/ { +/*?*/ // Referenz auf eine andere Zelle, die eine Matrixformel enthaelt +/*?*/ pCode->Reset(); +/*?*/ ScToken* p = pCode->GetNextReferenceRPN(); +/*?*/ if( p ) +/*?*/ { +/*?*/ ScBaseCell* pCell; +/*?*/ SingleRefData& rRef = p->GetSingleRef(); +/*?*/ rRef.CalcAbsIfRel( aPos ); +/*?*/ if ( rRef.Valid() ) +/*?*/ pCell = pDocument->GetCell( ScAddress( rRef.nCol, +/*?*/ rRef.nRow, rRef.nTab ) ); +/*?*/ else +/*?*/ pCell = NULL; +/*?*/ if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA) +/*?*/ { +/*?*/ ((ScFormulaCell*)pCell)->GetEnglishFormula(rBuffer, bCompileXML); +/*?*/ return; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*?*/ aComp.SetCompileEnglish( TRUE ); +/*?*/ aComp.SetCompileXML( bCompileXML ); +/*?*/ aComp.CreateStringFromTokenArray( rBuffer ); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ DBG_ERROR("ScFormulaCell::GetEnglishFormula: Keine Matrix"); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScCompiler aComp( pDocument, aPos, *pCode ); +/*N*/ aComp.SetCompileEnglish( TRUE ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ aComp.CreateStringFromTokenArray( rBuffer ); +/*N*/ } +/*N*/ +/*N*/ sal_Unicode ch('='); +/*N*/ rBuffer.insert( 0, &ch, 1 ); +/*N*/ if( cMatrixFlag ) +/*N*/ { +/*N*/ sal_Unicode ch2('{'); +/*N*/ rBuffer.insert(0, &ch2, 1); +/*N*/ rBuffer.append(sal_Unicode('}')); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScFormulaCell::IsValue() +/*N*/ { +/*N*/ if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc()) +/*N*/ Interpret(); +/*N*/ return bIsValue; +/*N*/ } + +/*N*/ double ScFormulaCell::GetValue() +/*N*/ { +/*N*/ if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc()) +/*?*/ Interpret(); +/*N*/ if ( !pCode->GetError() || pCode->GetError() == errDoubleRef) +/*N*/ return nErgValue; +/*N*/ return 0.0; +/*N*/ } + +/*N*/ double ScFormulaCell::GetValueAlways() +/*N*/ { +/*N*/ // for goal seek: return result value even if error code is set +/*N*/ +/*N*/ if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc()) +/*N*/ Interpret(); +/*N*/ return nErgValue; +/*N*/ } + +/*N*/ void ScFormulaCell::GetString( String& rString ) +/*N*/ { +/*N*/ if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc()) +/*?*/ Interpret(); +/*N*/ if ( !pCode->GetError() || pCode->GetError() == errDoubleRef) +/*N*/ rString = aErgString; +/*N*/ else +/*?*/ rString.Erase(); +/*N*/ } + +/*N*/ void ScFormulaCell::GetMatrix(ScMatrix** ppMat) +/*N*/ { +/*N*/ if ( pDocument->GetAutoCalc() ) +/*N*/ { +/*N*/ // war !bDirty gespeichert aber zugehoerige Matrixzelle bDirty? +/*N*/ // => wir brauchen pMatrix +/*N*/ if ( !pMatrix && cMatrixFlag == MM_FORMULA ) +/*N*/ bDirty = TRUE; +/*N*/ if ( IsDirtyOrInTableOpDirty() ) +/*N*/ Interpret(); +/*N*/ } +/*N*/ if (!pCode->GetError()) +/*N*/ *ppMat = pMatrix; +/*N*/ else +/*N*/ *ppMat = NULL; +/*N*/ } + +/*N*/ BOOL ScFormulaCell::GetMatrixOrigin( ScAddress& rPos ) const +/*N*/ { +/*N*/ switch ( cMatrixFlag ) +/*N*/ { +/*N*/ case MM_FORMULA : +/*N*/ rPos = aPos; +/*N*/ return TRUE; +/*N*/ break; +/*N*/ case MM_REFERENCE : +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ ScToken* t = pCode->GetNextReferenceRPN(); +/*N*/ if( t ) +/*N*/ { +/*N*/ SingleRefData& rRef = t->GetSingleRef(); +/*N*/ rRef.CalcAbsIfRel( aPos ); +/*N*/ if ( rRef.Valid() ) +/*N*/ { +/*N*/ rPos.Set( rRef.nCol, rRef.nRow, rRef.nTab ); +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + + +/* + Edge-Values: + + 8 + 4 16 + 2 + + innerhalb: 1 + ausserhalb: 0 + (reserviert: offen: 32) + */ + +/*N*/ USHORT ScFormulaCell::GetMatrixEdge( ScAddress& rOrgPos ) +/*N*/ { +/*N*/ switch ( cMatrixFlag ) +/*N*/ { +/*N*/ case MM_FORMULA : +/*N*/ case MM_REFERENCE : +/*N*/ { +/*N*/ static USHORT nC, nR; +/*N*/ ScAddress aOrg; +/*N*/ if ( !GetMatrixOrigin( aOrg ) ) +/*N*/ return 0; // dumm gelaufen.. +/*N*/ if ( aOrg != rOrgPos ) +/*N*/ { // erstes Mal oder andere Matrix als letztes Mal +/*N*/ rOrgPos = aOrg; +/*N*/ ScFormulaCell* pFCell; +/*N*/ if ( cMatrixFlag == MM_REFERENCE ) +/*N*/ pFCell = (ScFormulaCell*) pDocument->GetCell( aOrg ); +/*N*/ else +/*N*/ pFCell = this; // this MM_FORMULA +/*N*/ // this gibt's nur einmal, kein Vergleich auf pFCell==this +/*N*/ if ( pFCell && pFCell->GetCellType() == CELLTYPE_FORMULA +/*N*/ && pFCell->cMatrixFlag == MM_FORMULA ) +/*N*/ { +/*N*/ pFCell->GetMatColsRows( nC, nR ); +/*N*/ if ( nC == 0 || nR == 0 ) +/*N*/ { // aus altem Dokument geladen, neu erzeugen +/*?*/ nC = nR = 1; +/*?*/ ScAddress aTmpOrg; +/*?*/ ScBaseCell* pCell; +/*?*/ ScAddress aAdr( aOrg ); +/*?*/ aAdr.IncCol(); +/*?*/ BOOL bCont = TRUE; +/*?*/ do +/*?*/ { +/*?*/ pCell = pDocument->GetCell( aAdr ); +/*?*/ if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA +/*?*/ && ((ScFormulaCell*)pCell)->cMatrixFlag == MM_REFERENCE +/*?*/ && GetMatrixOrigin( aTmpOrg ) && aTmpOrg == aOrg ) +/*?*/ { +/*?*/ nC++; +/*?*/ aAdr.IncCol(); +/*?*/ } +/*?*/ else +/*?*/ bCont = FALSE; +/*?*/ } while ( bCont ); +/*?*/ aAdr = aOrg; +/*?*/ aAdr.IncRow(); +/*?*/ bCont = TRUE; +/*?*/ do +/*?*/ { +/*?*/ pCell = pDocument->GetCell( aAdr ); +/*?*/ if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA +/*?*/ && ((ScFormulaCell*)pCell)->cMatrixFlag == MM_REFERENCE +/*?*/ && GetMatrixOrigin( aTmpOrg ) && aTmpOrg == aOrg ) +/*?*/ { +/*?*/ nR++; +/*?*/ aAdr.IncRow(); +/*?*/ } +/*?*/ else +/*?*/ bCont = FALSE; +/*?*/ } while ( bCont ); +/*?*/ pFCell->SetMatColsRows( nC, nR ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ #ifdef DBG_UTIL +/*N*/ String aTmp; +/*N*/ ByteString aMsg( "broken Matrix, no MatFormula at origin, Pos: " ); +/*N*/ aPos.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument ); +/*N*/ aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US ); +/*N*/ aMsg += ", MatOrg: "; +/*N*/ aOrg.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument ); +/*N*/ aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US ); +/*N*/ DBG_ERRORFILE( aMsg.GetBuffer() ); +/*N*/ #endif +/*N*/ return 0; // bad luck ... +/*N*/ } +/*N*/ } +/*N*/ // here we are, healthy and clean, somewhere in between +/*N*/ short dC = aPos.Col() - aOrg.Col(); +/*N*/ short dR = aPos.Row() - aOrg.Row(); +/*N*/ USHORT nEdges = 0; +/*N*/ if ( dC >= 0 && dR >= 0 && dC < nC && dR < nR ) +/*N*/ { +/*N*/ if ( dC == 0 ) +/*N*/ nEdges |= 4; // linke Kante +/*N*/ if ( dC+1 == nC ) +/*N*/ nEdges |= 16; // rechte Kante +/*N*/ if ( dR == 0 ) +/*N*/ nEdges |= 8; // obere Kante +/*N*/ if ( dR+1 == nR ) +/*N*/ nEdges |= 2; // untere Kante +/*N*/ if ( !nEdges ) +/*N*/ nEdges = 1; // mittendrin +/*N*/ } +/*N*/ #ifdef DBG_UTIL +/*N*/ else +/*N*/ { +/*?*/ String aTmp; +/*?*/ ByteString aMsg( "broken Matrix, Pos: " ); +/*?*/ aPos.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument ); +/*?*/ aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US ); +/*?*/ aMsg += ", MatOrg: "; +/*?*/ aOrg.Format( aTmp, SCA_VALID_COL | SCA_VALID_ROW, pDocument ); +/*?*/ aMsg += ByteString( aTmp, RTL_TEXTENCODING_ASCII_US ); +/*?*/ aMsg += ", MatCols: "; +/*?*/ aMsg += ByteString::CreateFromInt32( nC ); +/*?*/ aMsg += ", MatRows: "; +/*?*/ aMsg += ByteString::CreateFromInt32( nR ); +/*?*/ aMsg += ", DiffCols: "; +/*?*/ aMsg += ByteString::CreateFromInt32( dC ); +/*?*/ aMsg += ", DiffRows: "; +/*?*/ aMsg += ByteString::CreateFromInt32( dR ); +/*?*/ DBG_ERRORFILE( aMsg.GetBuffer() ); +/*N*/ } +/*N*/ #endif +/*N*/ return nEdges; +/*N*/ break; +/*N*/ } +/*N*/ default: +/*N*/ return 0; +/*N*/ } +/*N*/ } + +/*N*/ USHORT ScFormulaCell::GetErrCode() +/*N*/ { +/*N*/ if (IsDirtyOrInTableOpDirty() && pDocument->GetAutoCalc()) +/*N*/ Interpret(); +/*N*/ return pCode->GetError(); +/*N*/ } + +/*N*/ BOOL ScFormulaCell::HasRelNameReference() const +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ for( ScToken* t = pCode->GetNextReferenceRPN(); t; +/*N*/ t = pCode->GetNextReferenceRPN() ) +/*N*/ { +/*N*/ if ( t->GetSingleRef().IsRelName() || +/*N*/ (t->GetType() == svDoubleRef && +/*N*/ t->GetDoubleRef().Ref2.IsRelName()) ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScFormulaCell::UpdateReference(UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& r, +/*N*/ short nDx, short nDy, short nDz, +/*N*/ ScDocument* pUndoDoc ) +/*N*/ {DBG_BF_ASSERT(0, "STRIP");//STRIP001 +/*N*/ } + +/*N*/ void ScFormulaCell::UpdateInsertTab(USHORT nTable) +/*N*/ { +/*N*/ BOOL bPosChanged = ( aPos.Tab() >= nTable ? TRUE : FALSE ); +/*N*/ pCode->Reset(); +/*N*/ if( pCode->GetNextReferenceRPN() && !pDocument->IsClipOrUndo() ) +/*N*/ { +/*N*/ EndListeningTo( pDocument ); +/*N*/ // IncTab _nach_ EndListeningTo und _vor_ Compiler UpdateInsertTab ! +/*N*/ if ( bPosChanged ) +/*?*/ aPos.IncTab(); +/*N*/ ScRangeData* pRangeData; +/*N*/ ScCompiler aComp(pDocument, aPos, *pCode); +/*N*/ pRangeData = aComp.UpdateInsertTab( nTable, FALSE ); +/*N*/ if (pRangeData) // Shared Formula gegen echte Formel +/*N*/ { // austauschen +/*?*/ BOOL bChanged; +/*?*/ pDocument->RemoveFromFormulaTree( this ); // update formula count +/*?*/ delete pCode; +/*?*/ pCode = new ScTokenArray( *pRangeData->GetCode() ); +/*M*/ pCode->SetReplacedSharedFormula( TRUE ); +/*?*/ ScCompiler aComp2(pDocument, aPos, *pCode); +/*?*/ aComp2.MoveRelWrap(); +/*?*/ aComp2.UpdateInsertTab( nTable, FALSE ); +/*?*/ // If the shared formula contained a named range/formula containing +/*?*/ // an absolute reference to a sheet, those have to be readjusted. +/*?*/ aComp2.UpdateDeleteTab( nTable, FALSE, TRUE, bChanged ); +/*?*/ bCompile = TRUE; +/*N*/ } +/*N*/ // kein StartListeningTo weil pTab[nTab] noch nicht existiert! +/*N*/ } +/*N*/ else if ( bPosChanged ) +/*?*/ aPos.IncTab(); +/*N*/ } + +/*N*/ BOOL ScFormulaCell::UpdateDeleteTab(USHORT nTable, BOOL bIsMove) +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ BOOL bPosChanged = ( aPos.Tab() > nTable ? TRUE : FALSE ); +/*N*/ pCode->Reset(); +/*N*/ if( pCode->GetNextReferenceRPN() && !pDocument->IsClipOrUndo() ) +/*N*/ { +/*N*/ EndListeningTo( pDocument ); +/*N*/ // IncTab _nach_ EndListeningTo und _vor_ Compiler UpdateDeleteTab ! +/*N*/ if ( bPosChanged ) +/*N*/ aPos.IncTab(-1); +/*N*/ ScRangeData* pRangeData; +/*N*/ ScCompiler aComp(pDocument, aPos, *pCode); +/*N*/ pRangeData = aComp.UpdateDeleteTab(nTable, bIsMove, FALSE, bChanged); +/*N*/ if (pRangeData) // Shared Formula gegen echte Formel +/*N*/ { // austauschen +/*N*/ pDocument->RemoveFromFormulaTree( this ); // update formula count +/*N*/ delete pCode; +/*N*/ pCode = pRangeData->GetCode()->Clone(); +/*N*/ pCode->SetReplacedSharedFormula( TRUE ); +/*N*/ ScCompiler aComp2(pDocument, aPos, *pCode); +/*N*/ aComp2.CompileTokenArray(); +/*N*/ aComp2.MoveRelWrap(); +/*N*/ aComp2.UpdateDeleteTab( nTable, FALSE, FALSE, bChanged ); +/*N*/ // If the shared formula contained a named range/formula containing +/*N*/ // an absolute reference to a sheet, those have to be readjusted. +/*N*/ aComp2.UpdateInsertTab( nTable,TRUE ); +/*N*/ // bChanged kann beim letzten UpdateDeleteTab zurueckgesetzt worden sein +/*N*/ bChanged = TRUE; +/*N*/ bCompile = TRUE; +/*N*/ } +/*N*/ // kein StartListeningTo weil pTab[nTab] noch nicht korrekt! +/*N*/ } +/*N*/ else if ( bPosChanged ) +/*N*/ aPos.IncTab(-1); +/*N*/ +/*N*/ return bChanged; +/*N*/ } + +/*N*/ BOOL ScFormulaCell::TestTabRefAbs(USHORT nTable) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +DBG_BF_ASSERT(0, "STRIP"); /*N*/ if( !pDocument->IsClipOrUndo() ) +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ ScToken* p = pCode->GetNextReferenceRPN(); +/*N*/ while( p ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = p->GetSingleRef(); +/*N*/ if( !rRef1.IsTabRel() ) +/*N*/ { +/*N*/ if( (short) nTable != rRef1.nTab ) +/*N*/ bRet = TRUE; +/*N*/ else if (nTable != aPos.Tab()) +/*N*/ rRef1.nTab = aPos.Tab(); +/*N*/ } +/*N*/ if( p->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = p->GetDoubleRef().Ref2; +/*N*/ if( !rRef2.IsTabRel() ) +/*N*/ { +/*N*/ if( (short) nTable != rRef2.nTab ) +/*N*/ bRet = TRUE; +/*N*/ else if (nTable != aPos.Tab()) +/*N*/ rRef2.nTab = aPos.Tab(); +/*N*/ } +/*N*/ } +/*N*/ p = pCode->GetNextReferenceRPN(); +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/*N*/ void ScFormulaCell::UpdateCompile( BOOL bForceIfNameInUse ) +/*N*/ { +/*N*/ if ( bForceIfNameInUse && !bCompile ) +/*?*/ { DBG_BF_ASSERT(0, "STRIP");} /*N*/ bCompile = pCode->HasNameOrColRowName(); +/*N*/ if ( bCompile ) +/*?*/ pCode->SetError( 0 ); // damit auch wirklich kompiliert wird +/*N*/ CompileTokenArray(); +/*N*/ } + +/*N*/ BOOL lcl_IsRangeNameInUse(USHORT nIndex, ScTokenArray* pCode, ScRangeName* pNames) +/*N*/ { +/*N*/ for (ScToken* p = pCode->First(); p; p = pCode->Next()) +/*N*/ { +/*N*/ if (p->GetOpCode() == ocName) +/*N*/ { +/*N*/ if (p->GetIndex() == nIndex) +/*N*/ return TRUE; +/*N*/ else +/*N*/ { +/*N*/ // RangeData kann Null sein in bestimmten Excel-Dateien (#31168#) +/*N*/ ScRangeData* pSubName = pNames->FindIndex(p->GetIndex()); +/*N*/ if (pSubName && lcl_IsRangeNameInUse(nIndex, +/*N*/ pSubName->GetCode(), pNames)) +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScFormulaCell::IsRangeNameInUse(USHORT nIndex) const +/*N*/ { +/*N*/ return lcl_IsRangeNameInUse( nIndex, pCode, pDocument->GetRangeName() ); +/*N*/ } + +/*N*/ void ScFormulaCell::CompileDBFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ // zwei Phasen, muessen (!) nacheinander aufgerufen werden: +/*N*/ // 1. FormelString mit alten Namen erzeugen +/*N*/ // 2. FormelString mit neuen Namen kompilieren +/*N*/ if ( bCreateFormulaString ) +/*N*/ { +/*N*/ BOOL bRecompile = FALSE; +/*N*/ pCode->Reset(); +/*N*/ for ( ScToken* p = pCode->First(); p && !bRecompile; p = pCode->Next() ) +/*N*/ { +/*N*/ switch ( p->GetOpCode() ) +/*N*/ { +/*N*/ case ocBad: // DB-Bereich evtl. zugefuegt +/*N*/ case ocColRowName: // #36762# falls Namensgleichheit +/*N*/ case ocDBArea: // DB-Bereich +/*N*/ bRecompile = TRUE; +/*N*/ break; +/*N*/ case ocName: +/*?*/ if ( p->GetIndex() >= SC_START_INDEX_DB_COLL ) +/*?*/ bRecompile = TRUE; // DB-Bereich +/*N*/ } +/*N*/ } +/*N*/ if ( bRecompile ) +/*N*/ { +/*N*/ String aFormula; +/*N*/ GetFormula( aFormula ); +/*N*/ if ( GetMatrixFlag() != MM_NONE && aFormula.Len() ) +/*N*/ { +/*?*/ if ( aFormula.GetChar( aFormula.Len()-1 ) == '}' ) +/*?*/ aFormula.Erase( aFormula.Len()-1 , 1 ); +/*?*/ if ( aFormula.GetChar(0) == '{' ) +/*?*/ aFormula.Erase( 0, 1 ); +/*N*/ } +/*N*/ EndListeningTo( pDocument ); +/*N*/ pDocument->RemoveFromFormulaTree( this ); +/*N*/ pCode->Clear(); +/*N*/ aErgString = aFormula; +/*N*/ } +/*N*/ } +/*N*/ else if ( !pCode->GetLen() && aErgString.Len() ) +/*N*/ { +/*N*/ Compile( aErgString ); +/*N*/ aErgString.Erase(); +/*N*/ SetDirty(); +/*N*/ } +/*N*/ } + +/*N*/ void ScFormulaCell::CompileNameFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ // zwei Phasen, muessen (!) nacheinander aufgerufen werden: +/*N*/ // 1. FormelString mit alten RangeNames erzeugen +/*N*/ // 2. FormelString mit neuen RangeNames kompilieren +/*N*/ if ( bCreateFormulaString ) +/*N*/ { +/*N*/ BOOL bRecompile = FALSE; +/*N*/ pCode->Reset(); +/*N*/ for ( ScToken* p = pCode->First(); p && !bRecompile; p = pCode->Next() ) +/*N*/ { +/*N*/ switch ( p->GetOpCode() ) +/*N*/ { +/*N*/ case ocBad: // RangeName evtl. zugefuegt +/*N*/ case ocColRowName: // #36762# falls Namensgleichheit +/*N*/ bRecompile = TRUE; +/*N*/ break; +/*N*/ default: +/*N*/ if ( p->GetType() == svIndex ) +/*N*/ bRecompile = TRUE; // RangeName +/*N*/ } +/*N*/ } +/*N*/ if ( bRecompile ) +/*N*/ { +/*N*/ String aFormula; +/*N*/ GetFormula( aFormula ); +/*N*/ if ( GetMatrixFlag() != MM_NONE && aFormula.Len() ) +/*N*/ { +/*?*/ if ( aFormula.GetChar( aFormula.Len()-1 ) == '}' ) +/*?*/ aFormula.Erase( aFormula.Len()-1 , 1 ); +/*?*/ if ( aFormula.GetChar(0) == '{' ) +/*?*/ aFormula.Erase( 0, 1 ); +/*N*/ } +/*N*/ EndListeningTo( pDocument ); +/*N*/ pDocument->RemoveFromFormulaTree( this ); +/*N*/ pCode->Clear(); +/*N*/ aErgString = aFormula; +/*N*/ } +/*N*/ } +/*N*/ else if ( !pCode->GetLen() && aErgString.Len() ) +/*N*/ { +/*N*/ Compile( aErgString ); +/*N*/ aErgString.Erase(); +/*N*/ SetDirty(); +/*N*/ } +/*N*/ } + +/*N*/ void ScFormulaCell::CompileColRowNameFormula() +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ for ( ScToken* p = pCode->First(); p; p = pCode->Next() ) +/*N*/ { +/*N*/ if ( p->GetOpCode() == ocColRowName ) +/*N*/ { +/*N*/ bCompile = TRUE; +/*N*/ CompileTokenArray(); +/*N*/ SetDirty(); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ ScValueCell::ScValueCell( SvStream& rStream, USHORT nVer ) : +/*N*/ ScBaseCell( CELLTYPE_VALUE ) +/*N*/ { +/*N*/ if( nVer >= SC_DATABYTES2 ) +/*N*/ { +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ if( cData & 0x0F ) +/*?*/ rStream.SeekRel( cData & 0x0F ); +/*N*/ } +/*N*/ rStream >> aValue; +/*N*/ } + +/*N*/ void ScValueCell::Save( SvStream& rStream ) const +/*N*/ { +/*N*/ rStream << (BYTE) 0x00 << aValue; +/*N*/ } + +/*N*/ ScStringCell::ScStringCell( SvStream& rStream, USHORT nVer ) : +/*N*/ ScBaseCell( CELLTYPE_STRING ) +/*N*/ { +/*N*/ if( nVer >= SC_DATABYTES2 ) +/*N*/ { +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ if( cData & 0x0F ) +/*?*/ rStream.SeekRel( cData & 0x0F ); +/*N*/ } +/*N*/ rStream.ReadByteString( aString, rStream.GetStreamCharSet() ); +/*N*/ } + +/*N*/ void ScStringCell::Save( SvStream& rStream, FontToSubsFontConverter hConv ) const +/*N*/ { +/*N*/ rStream << (BYTE) 0x00; +/*N*/ if ( !hConv ) +/*N*/ rStream.WriteByteString( aString, rStream.GetStreamCharSet() ); +/*N*/ else +/*N*/ { +/*N*/ String aTmp( aString ); +/*N*/ sal_Unicode* p = aTmp.GetBufferAccess(); +/*N*/ sal_Unicode const * const pStop = p + aTmp.Len(); +/*N*/ for ( ; p < pStop; ++p ) +/*N*/ { +/*N*/ *p = ConvertFontToSubsFontChar( hConv, *p ); +/*N*/ } +/*N*/ aTmp.ReleaseBufferAccess(); +/*N*/ rStream.WriteByteString( aTmp, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ } + +/*N*/ void ScStringCell::ConvertFont( FontToSubsFontConverter hConv ) +/*N*/ { +/*N*/ if ( hConv ) +/*N*/ { +/*N*/ sal_Unicode* p = aString.GetBufferAccess(); +/*N*/ sal_Unicode const * const pStop = p + aString.Len(); +/*N*/ for ( ; p < pStop; ++p ) +/*N*/ { +/*N*/ *p = ConvertFontToSubsFontChar( hConv, *p ); +/*N*/ } +/*N*/ aString.ReleaseBufferAccess(); +/*N*/ } +/*N*/ } + +/*N*/ ScNoteCell::ScNoteCell( SvStream& rStream, USHORT nVer ) : +/*N*/ ScBaseCell( CELLTYPE_NOTE ) +/*N*/ { +/*N*/ if( nVer >= SC_DATABYTES2 ) +/*N*/ { +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ if( cData & 0x0F ) +/*?*/ rStream.SeekRel( cData & 0x0F ); +/*N*/ } +/*N*/ } + +/*N*/ void ScNoteCell::Save( SvStream& rStream ) const +/*N*/ { +/*N*/ rStream << (BYTE) 0x00; +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_column.cxx b/binfilter/bf_sc/source/core/data/sc_column.cxx new file mode 100644 index 000000000000..76bf4e7d0fa2 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_column.cxx @@ -0,0 +1,1363 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svtools/poolcach.hxx> +#include <bf_svx/scripttypeitem.hxx> +#include <string.h> + +#include "scitems.hxx" +#include "cell.hxx" +#include "document.hxx" +#include "docpool.hxx" +#include "attarray.hxx" +#include "patattr.hxx" +#include "markdata.hxx" +namespace binfilter { + +//#pragma optimize ( "", off ) +// nur Search ohne Optimierung! + +// STATIC DATA ----------------------------------------------------------- + + +/*N*/ inline BOOL CellVisible( const ScBaseCell* pCell ) //! an Zelle verschieben +/*N*/ { +/*N*/ return ( pCell->GetCellType() != CELLTYPE_NOTE || pCell->GetNotePtr() ); +/*N*/ } + +/*N*/ inline BOOL IsAmbiguousScriptNonZero( BYTE nScript ) +/*N*/ { +/*N*/ //! move to a header file +/*N*/ return ( nScript != SCRIPTTYPE_LATIN && +/*N*/ nScript != SCRIPTTYPE_ASIAN && +/*N*/ nScript != SCRIPTTYPE_COMPLEX && +/*N*/ nScript != 0 ); +/*N*/ } + +// ----------------------------------------------------------------------------------------- + + +/*N*/ ScColumn::ScColumn() : +/*N*/ nCol( 0 ), +/*N*/ nCount( 0 ), +/*N*/ nLimit( 0 ), +/*N*/ pItems( NULL ), +/*N*/ pDocument( NULL ), +/*N*/ pAttrArray( NULL ) +/*N*/ { +/*N*/ } + + +/*N*/ ScColumn::~ScColumn() +/*N*/ { +/*N*/ FreeAll(); +/*N*/ if (pAttrArray) delete pAttrArray; +/*N*/ } + + +/*N*/ void ScColumn::Init(USHORT nNewCol, USHORT nNewTab, ScDocument* pDoc) +/*N*/ { +/*N*/ nCol = nNewCol; +/*N*/ nTab = nNewTab; +/*N*/ pDocument = pDoc; +/*N*/ pAttrArray = new ScAttrArray( nCol, nTab, pDocument ); +/*N*/ } + + + + +/*N*/ USHORT ScColumn::GetBlockMatrixEdges( USHORT nRow1, USHORT nRow2, USHORT nMask ) const +/*N*/ { +/*N*/ // nix:0, mitte:1, unten:2, links:4, oben:8, rechts:16, offen:32 +/*N*/ if ( !pItems ) +/*N*/ return 0; +/*N*/ if ( nRow1 == nRow2 ) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if ( Search( nRow1, nIndex ) ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA +/*N*/ && ((ScFormulaCell*)pCell)->GetMatrixFlag() ) +/*N*/ { +/*N*/ ScAddress aOrg( (UINT32)0xFFFFFFFF ); +/*N*/ return ((ScFormulaCell*)pCell)->GetMatrixEdge( aOrg ); +/*N*/ } +/*N*/ } +/*N*/ return 0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScAddress aOrg( (UINT32)0xFFFFFFFF ); +/*N*/ BOOL bOpen = FALSE; +/*N*/ USHORT nEdges = 0; +/*N*/ USHORT nIndex; +/*N*/ Search( nRow1, nIndex ); +/*N*/ while ( nIndex < nCount && pItems[nIndex].nRow <= nRow2 ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA +/*N*/ && ((ScFormulaCell*)pCell)->GetMatrixFlag() ) +/*N*/ { +/*N*/ nEdges = ((ScFormulaCell*)pCell)->GetMatrixEdge( aOrg ); +/*N*/ if ( nEdges ) +/*N*/ { +/*N*/ if ( nEdges & 8 ) +/*N*/ bOpen = TRUE; // obere Kante oeffnet, weitersehen +/*N*/ else if ( !bOpen ) +/*N*/ return nEdges | 32; // es gibt was, was nicht geoeffnet wurde +/*N*/ else if ( nEdges & 1 ) +/*N*/ return nEdges; // mittendrin +/*N*/ // (nMask & 16 und (4 und nicht 16)) oder +/*N*/ // (nMask & 4 und (16 und nicht 4)) +/*N*/ if ( ((nMask & 16) && (nEdges & 4) && !(nEdges & 16)) +/*N*/ || ((nMask & 4) && (nEdges & 16) && !(nEdges & 4)) ) +/*N*/ return nEdges; // nur linke/rechte Kante +/*N*/ if ( nEdges & 2 ) +/*N*/ bOpen = FALSE; // untere Kante schliesst +/*N*/ } +/*N*/ } +/*N*/ nIndex++; +/*N*/ } +/*N*/ if ( bOpen ) +/*N*/ nEdges |= 32; // es geht noch weiter +/*N*/ return nEdges; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScColumn::HasSelectionMatrixFragment(const ScMarkData& rMark) const +/*N*/ { +/*N*/ if ( rMark.IsMultiMarked() ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ ScAddress aOrg( (UINT32)0xFFFFFFFF ); +/*N*/ ScAddress aCurOrg( (UINT32)0xFFFFFFFF ); +/*N*/ USHORT nTop, nBottom; +/*N*/ ScMarkArrayIter aMarkIter( rMark.GetArray()+nCol ); +/*N*/ while ( !bFound && aMarkIter.Next( nTop, nBottom ) ) +/*N*/ { +/*N*/ BOOL bOpen = FALSE; +/*N*/ USHORT nEdges; +/*N*/ USHORT nIndex; +/*N*/ Search( nTop, nIndex ); +/*N*/ while ( !bFound && nIndex < nCount && pItems[nIndex].nRow <= nBottom ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA +/*N*/ && ((ScFormulaCell*)pCell)->GetMatrixFlag() ) +/*N*/ { +/*N*/ nEdges = ((ScFormulaCell*)pCell)->GetMatrixEdge( aOrg ); +/*N*/ if ( nEdges ) +/*N*/ { +/*N*/ if ( nEdges & 8 ) +/*N*/ bOpen = TRUE; // obere Kante oeffnet, weitersehen +/*N*/ else if ( !bOpen ) +/*N*/ return TRUE; // es gibt was, was nicht geoeffnet wurde +/*N*/ else if ( nEdges & 1 ) +/*N*/ bFound = TRUE; // mittendrin, alles selektiert? +/*N*/ // (4 und nicht 16) oder (16 und nicht 4) +/*N*/ if ( (((nEdges & 4) | 16) ^ ((nEdges & 16) | 4)) ) +/*N*/ bFound = TRUE; // nur linke/rechte Kante, alles selektiert? +/*N*/ if ( nEdges & 2 ) +/*N*/ bOpen = FALSE; // untere Kante schliesst +/*N*/ +/*N*/ if ( bFound ) +/*N*/ { // alles selektiert? +/*?*/ if ( aCurOrg != aOrg ) +/*?*/ { // neue Matrix zu pruefen? +/*?*/ aCurOrg = aOrg; +/*?*/ ScFormulaCell* pFCell; +/*?*/ if ( ((ScFormulaCell*)pCell)->GetMatrixFlag() +/*?*/ == MM_REFERENCE ) +/*?*/ pFCell = (ScFormulaCell*) pDocument->GetCell( aOrg ); +/*?*/ else +/*?*/ pFCell = (ScFormulaCell*)pCell; +/*?*/ USHORT nC, nR; +/*?*/ pFCell->GetMatColsRows( nC, nR ); +/*?*/ ScRange aRange( aOrg, ScAddress( +/*?*/ aOrg.Col() + nC - 1, aOrg.Row() + nR - 1, +/*?*/ aOrg.Tab() ) ); +/*?*/ if ( rMark.IsAllMarked( aRange ) ) +/*?*/ bFound = FALSE; +/*?*/ } +/*?*/ else +/*?*/ bFound = FALSE; // war schon +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ nIndex++; +/*N*/ } +/*N*/ if ( bOpen ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ return bFound; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + + + +/*N*/ BOOL ScColumn::HasAttrib( USHORT nRow1, USHORT nRow2, USHORT nMask ) const +/*N*/ { +/*N*/ return pAttrArray->HasAttrib( nRow1, nRow2, nMask ); +/*N*/ } + + + + +/*N*/ BOOL ScColumn::ExtendMerge( USHORT nThisCol, USHORT nStartRow, USHORT nEndRow, +/*N*/ USHORT& rPaintCol, USHORT& rPaintRow, +/*N*/ BOOL bRefresh, BOOL bAttrs ) +/*N*/ { +/*N*/ return pAttrArray->ExtendMerge( nThisCol, nStartRow, nEndRow, rPaintCol, rPaintRow, bRefresh, bAttrs ); +/*N*/ } + + +/*N*/ void ScColumn::MergeSelectionPattern( SfxItemSet** ppSet, const ScMarkData& rMark, BOOL bDeep ) const +/*N*/ { +/*N*/ USHORT nTop; +/*N*/ USHORT nBottom; +/*N*/ +/*N*/ if ( rMark.IsMultiMarked() ) +/*N*/ { +/*N*/ ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol ); +/*N*/ while (aMarkIter.Next( nTop, nBottom )) +/*N*/ pAttrArray->MergePatternArea( nTop, nBottom, ppSet, bDeep ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::MergePatternArea( SfxItemSet** ppSet, USHORT nRow1, USHORT nRow2, BOOL bDeep ) const +/*N*/ { +/*N*/ pAttrArray->MergePatternArea( nRow1, nRow2, ppSet, bDeep ); +/*N*/ } + + + + + + +/*N*/ const ScPatternAttr* ScColumn::GetPattern( USHORT nRow ) const +/*N*/ { +/*N*/ return pAttrArray->GetPattern( nRow ); +/*N*/ } + + +/*N*/ const SfxPoolItem* ScColumn::GetAttr( USHORT nRow, USHORT nWhich ) const +/*N*/ { +/*N*/ return &pAttrArray->GetPattern( nRow )->GetItemSet().Get(nWhich); +/*N*/ } + + +/*N*/ ULONG ScColumn::GetNumberFormat( USHORT nRow ) const +/*N*/ { +/*N*/ return pAttrArray->GetPattern( nRow )->GetNumberFormat( pDocument->GetFormatTable() ); +/*N*/ } + + +/*N*/ short ScColumn::ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark ) +/*N*/ { +/*N*/ USHORT nTop; +/*N*/ USHORT nBottom; +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ if ( rMark.IsMultiMarked() ) +/*N*/ { +/*N*/ ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol ); +/*N*/ while (aMarkIter.Next( nTop, nBottom )) +/*N*/ { +/*N*/ pAttrArray->ApplyCacheArea( nTop, nBottom, pCache ); +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!bFound) +/*N*/ return -1; +/*N*/ else if (nTop==0 && nBottom==MAXROW) +/*N*/ return 0; +/*N*/ else +/*N*/ return (short) nBottom; +/*N*/ } + + + + + + + + + + +/*N*/ void ScColumn::ApplyPatternArea( USHORT nStartRow, USHORT nEndRow, const ScPatternAttr& rPatAttr ) +/*N*/ { +/*N*/ const SfxItemSet* pSet = &rPatAttr.GetItemSet(); +/*N*/ SfxItemPoolCache aCache( pDocument->GetPool(), pSet ); +/*N*/ pAttrArray->ApplyCacheArea( nStartRow, nEndRow, &aCache ); +/*N*/ } + + + + + + +/*N*/ void ScColumn::ApplyStyleArea( USHORT nStartRow, USHORT nEndRow, const ScStyleSheet& rStyle ) +/*N*/ { +/*N*/ pAttrArray->ApplyStyleArea(nStartRow, nEndRow, (ScStyleSheet*)&rStyle); +/*N*/ } + + +/*N*/ void ScColumn::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark) +/*N*/ { +/*N*/ USHORT nTop; +/*N*/ USHORT nBottom; +/*N*/ +/*N*/ if ( rMark.IsMultiMarked() ) +/*N*/ { +/*N*/ ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol ); +/*N*/ while (aMarkIter.Next( nTop, nBottom )) +/*N*/ pAttrArray->ApplyStyleArea(nTop, nBottom, (ScStyleSheet*)&rStyle); +/*N*/ } +/*N*/ } + +/*N*/ const ScStyleSheet* ScColumn::GetSelectionStyle( const ScMarkData& rMark, BOOL& rFound ) const +/*N*/ { +/*N*/ rFound = FALSE; +/*N*/ if (!rMark.IsMultiMarked()) +/*N*/ { +/*N*/ DBG_ERROR("ScColumn::GetSelectionStyle ohne Selektion"); +/*N*/ return NULL; +/*N*/ } +/*N*/ +/*N*/ BOOL bEqual = TRUE; +/*N*/ +/*N*/ const ScStyleSheet* pStyle = NULL; +/*N*/ const ScStyleSheet* pNewStyle; +/*N*/ +/*N*/ ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol ); +/*N*/ USHORT nTop; +/*N*/ USHORT nBottom; +/*N*/ while (bEqual && aMarkIter.Next( nTop, nBottom )) +/*N*/ { +/*N*/ ScAttrIterator aAttrIter( pAttrArray, nTop, nBottom ); +/*N*/ USHORT nRow; +/*N*/ USHORT nDummy; +/*N*/ const ScPatternAttr* pPattern; +/*N*/ while (bEqual && ( pPattern = aAttrIter.Next( nRow, nDummy ) )) +/*N*/ { +/*N*/ pNewStyle = pPattern->GetStyleSheet(); +/*N*/ rFound = TRUE; +/*N*/ if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) ) +/*N*/ bEqual = FALSE; // unterschiedliche +/*N*/ pStyle = pNewStyle; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual ? pStyle : NULL; +/*N*/ } + + +/*N*/ const ScStyleSheet* ScColumn::GetAreaStyle( BOOL& rFound, USHORT nRow1, USHORT nRow2 ) const +/*N*/ { +/*N*/ rFound = FALSE; +/*N*/ +/*N*/ BOOL bEqual = TRUE; +/*N*/ +/*N*/ const ScStyleSheet* pStyle = NULL; +/*N*/ const ScStyleSheet* pNewStyle; +/*N*/ +/*N*/ ScAttrIterator aAttrIter( pAttrArray, nRow1, nRow2 ); +/*N*/ USHORT nRow; +/*N*/ USHORT nDummy; +/*N*/ const ScPatternAttr* pPattern; +/*N*/ while (bEqual && ( pPattern = aAttrIter.Next( nRow, nDummy ) )) +/*N*/ { +/*N*/ pNewStyle = pPattern->GetStyleSheet(); +/*N*/ rFound = TRUE; +/*N*/ if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) ) +/*N*/ bEqual = FALSE; // unterschiedliche +/*N*/ pStyle = pNewStyle; +/*N*/ } +/*N*/ +/*N*/ return bEqual ? pStyle : NULL; +/*N*/ } + + +/*N*/ void ScColumn::FindStyleSheet( const SfxStyleSheetBase* pStyleSheet, BOOL* pUsed, BOOL bReset ) +/*N*/ { +/*N*/ pAttrArray->FindStyleSheet( pStyleSheet, pUsed, bReset ); +/*N*/ } + + +/*N*/ BOOL ScColumn::ApplyFlags( USHORT nStartRow, USHORT nEndRow, INT16 nFlags ) +/*N*/ { +/*N*/ return pAttrArray->ApplyFlags( nStartRow, nEndRow, nFlags ); +/*N*/ } + + +/*N*/ BOOL ScColumn::RemoveFlags( USHORT nStartRow, USHORT nEndRow, INT16 nFlags ) +/*N*/ { +/*N*/ return pAttrArray->RemoveFlags( nStartRow, nEndRow, nFlags ); +/*N*/ } + + +/*N*/ void ScColumn::ClearItems( USHORT nStartRow, USHORT nEndRow, const USHORT* pWhich ) +/*N*/ { +/*N*/ pAttrArray->ClearItems( nStartRow, nEndRow, pWhich ); +/*N*/ } + + +/*N*/ void ScColumn::ApplyAttr( USHORT nRow, const SfxPoolItem& rAttr ) +/*N*/ { +/*N*/ // um nur ein neues SetItem zu erzeugen, brauchen wir keinen SfxItemPoolCache. +/*N*/ //! Achtung: der SfxItemPoolCache scheint zuviele Refs fuer das neue SetItem zu erzeugen ?? +/*N*/ +/*N*/ ScDocumentPool* pDocPool = pDocument->GetPool(); +/*N*/ +/*N*/ const ScPatternAttr* pOldPattern = pAttrArray->GetPattern( nRow ); +/*N*/ ScPatternAttr* pTemp = new ScPatternAttr(*pOldPattern); +/*N*/ pTemp->GetItemSet().Put(rAttr); +/*N*/ const ScPatternAttr* pNewPattern = (const ScPatternAttr*) &pDocPool->Put( *pTemp ); +/*N*/ +/*N*/ if ( pNewPattern != pOldPattern ) +/*N*/ pAttrArray->SetPattern( nRow, pNewPattern ); +/*N*/ else +/*?*/ pDocPool->Remove( *pNewPattern ); // ausser Spesen nichts gewesen +/*N*/ +/*N*/ delete pTemp; +/*N*/ +/*N*/ // alte Version mit SfxItemPoolCache: +/*N*/ #if 0 +/*?*/ SfxItemPoolCache aCache( pDocument->GetPool(), &rAttr ); +/*?*/ +/*?*/ const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow ); +/*?*/ +/*?*/ // TRUE = alten Eintrag behalten +/*?*/ +/*?*/ ScPatternAttr* pNewPattern = (ScPatternAttr*) &aCache.ApplyTo( *pPattern, TRUE ); +/*?*/ ScDocumentPool::CheckRef( *pPattern ); +/*?*/ ScDocumentPool::CheckRef( *pNewPattern ); +/*?*/ +/*?*/ if (pNewPattern != pPattern) +/*?*/ pAttrArray->SetPattern( nRow, pNewPattern ); +/*N*/ #endif +/*N*/ } + +#ifdef _MSC_VER +#pragma optimize ( "", off ) +#endif + + +/*N*/ BOOL ScColumn::Search( USHORT nRow, USHORT& nIndex ) const +/*N*/ { +/*N*/ if ( !pItems || !nCount ) +/*N*/ { +/*N*/ nIndex = 0; +/*N*/ return FALSE; +/*N*/ } +/*N*/ USHORT nMinRow = pItems[0].nRow; +/*N*/ if ( nRow <= nMinRow ) +/*N*/ { +/*N*/ nIndex = 0; +/*N*/ return nRow == nMinRow; +/*N*/ } +/*N*/ USHORT nMaxRow = pItems[nCount-1].nRow; +/*N*/ if ( nRow >= nMaxRow ) +/*N*/ { +/*N*/ if ( nRow == nMaxRow ) +/*N*/ { +/*N*/ nIndex = nCount - 1; +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nIndex = nCount; +/*N*/ return FALSE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ short nOldLo, nOldHi; +/*N*/ short nLo = nOldLo = 0; +/*N*/ short nHi = nOldHi = Min( (short)(nCount-1), (short)nRow ); +/*N*/ short i = 0; +/*N*/ BOOL bFound = FALSE; +/*N*/ // einigermassen durchgaengige Belegung? => interpolierende Suche +/*N*/ BOOL bInterpol = (nMaxRow - nMinRow < nCount * 2); +/*N*/ USHORT nR; +/*N*/ +/*N*/ while ( !bFound && nLo <= nHi ) +/*N*/ { +/*N*/ if ( !bInterpol || nHi - nLo < 3 ) +/*N*/ i = (nLo+nHi) / 2; // kein Aufwand, kein division by zero +/*N*/ else +/*N*/ { // interpolierende Suche +/*N*/ long nLoRow = pItems[nLo].nRow; // kein USHORT Unterlauf bei Subtraktion +/*N*/ i = nLo + (short)((long)(nRow - nLoRow) * (nHi - nLo) +/*N*/ / (pItems[nHi].nRow - nLoRow)); +/*N*/ if ( i < 0 || i >= nCount ) +/*N*/ { // oops ... +/*N*/ i = (nLo+nHi) / 2; +/*N*/ bInterpol = FALSE; +/*N*/ } +/*N*/ } +/*N*/ nR = pItems[i].nRow; +/*N*/ if ( nR < nRow ) +/*N*/ { +/*N*/ nLo = i+1; +/*N*/ if ( bInterpol ) +/*N*/ { +/*N*/ if ( nLo <= nOldLo ) +/*N*/ bInterpol = FALSE; +/*N*/ else +/*N*/ nOldLo = nLo; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( nR > nRow ) +/*N*/ { +/*N*/ nHi = i-1; +/*N*/ if ( bInterpol ) +/*N*/ { +/*N*/ if ( nHi >= nOldHi ) +/*N*/ bInterpol = FALSE; +/*N*/ else +/*N*/ nOldHi = nHi; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if (bFound) +/*N*/ nIndex = i; +/*N*/ else +/*N*/ nIndex = nLo; // hinterer Index +/*N*/ return bFound; +/*N*/ } + +#ifdef _MSC_VER +#pragma optimize ( "", on ) +#endif + + +/*N*/ ScBaseCell* ScColumn::GetCell( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ return pItems[nIndex].pCell; +/*N*/ return NULL; +/*N*/ } + + +/*N*/ void ScColumn::Resize( USHORT nSize ) +/*N*/ { +/*N*/ if (nSize > MAXROW+1) +/*N*/ nSize = MAXROW+1; +/*N*/ if (nSize < nCount) +/*N*/ nSize = nCount; +/*N*/ +/*N*/ ColEntry* pNewItems; +/*N*/ if (nSize) +/*N*/ { +/*N*/ USHORT nNewSize = nSize + COLUMN_DELTA - 1; +/*N*/ nNewSize -= nNewSize % COLUMN_DELTA; +/*N*/ nLimit = nNewSize; +/*N*/ pNewItems = new ColEntry[nLimit]; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nLimit = 0; +/*N*/ pNewItems = NULL; +/*N*/ } +/*N*/ if (pItems) +/*N*/ { +/*N*/ if (pNewItems) +/*N*/ memmove( pNewItems, pItems, nCount * sizeof(ColEntry) ); +/*N*/ delete[] pItems; +/*N*/ } +/*N*/ pItems = pNewItems; +/*N*/ } + +// SetNewRow gehoert zu SwapRow + + +// SwapRow zum Sortieren + + + + + +/*N*/ BOOL ScColumn::TestInsertCol( USHORT nStartRow, USHORT nEndRow) const +/*N*/ { +/*N*/ if (!IsEmpty()) +/*N*/ { +/*N*/ BOOL bTest = TRUE; +/*N*/ if (pItems) +/*N*/ for (USHORT i=0; (i<nCount) && bTest; i++) +/*N*/ bTest = ((pItems[i].nRow < nStartRow) && (pItems[i].nRow > nEndRow)) +/*N*/ || !CellVisible(pItems[i].pCell); +/*N*/ +/*N*/ // AttrArray testet nur zusammengefasste +/*N*/ +/*N*/ if ((bTest) && (pAttrArray)) +/*N*/ bTest = pAttrArray->TestInsertCol(nStartRow, nEndRow); +/*N*/ +/*N*/ //! rausgeschobene Attribute bei Undo beruecksichtigen +/*N*/ +/*N*/ return bTest; +/*N*/ } +/*N*/ else +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ BOOL ScColumn::TestInsertRow( USHORT nSize ) const +/*N*/ { +/*N*/ // AttrArray testet nur zusammengefasste +/*N*/ +/*N*/ if ( pItems && nCount ) +/*N*/ return ( pItems[nCount-1].nRow <= MAXROW-nSize && pAttrArray->TestInsertRow( nSize ) ); +/*N*/ else +/*N*/ return pAttrArray->TestInsertRow( nSize ); +/*N*/ +/*N*/ //! rausgeschobene Attribute bei Undo beruecksichtigen +/*N*/ +/*N*/ if ( nSize > MAXROW ) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nVis = nCount; +/*N*/ while ( nVis && !CellVisible(pItems[nVis-1].pCell) ) +/*N*/ --nVis; +/*N*/ +/*N*/ if ( nVis ) +/*N*/ return ( pItems[nVis-1].nRow <= MAXROW-nSize ); +/*N*/ else +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ void ScColumn::InsertRow( USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ pAttrArray->InsertRow( nStartRow, nSize ); +/*N*/ +/*N*/ //! Search +/*N*/ +/*N*/ if ( !pItems || !nCount ) +/*N*/ return; +/*N*/ +/*N*/ USHORT i; +/*N*/ Search( nStartRow, i ); +/*N*/ if ( i >= nCount ) +/*N*/ return ; +/*N*/ +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ +/*N*/ USHORT nNewCount = nCount; +/*N*/ BOOL bCountChanged = FALSE; +/*N*/ ScAddress aAdr( nCol, 0, nTab ); +/*N*/ ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL ); // only areas (ScBaseCell* == NULL) +/*N*/ ScAddress& rAddress = aHint.GetAddress(); +/*N*/ // for sparse occupation use single broadcasts, not ranges +/*N*/ BOOL bSingleBroadcasts = (((pItems[nCount-1].nRow - pItems[i].nRow) / +/*N*/ (nCount - i)) > 1); +/*N*/ if ( bSingleBroadcasts ) +/*N*/ { +/*N*/ USHORT nLastBroadcast = MAXROW+1; +/*N*/ for ( ; i < nCount; i++) +/*N*/ { +/*N*/ USHORT nOldRow = pItems[i].nRow; +/*N*/ // #43940# Aenderung Quelle broadcasten +/*N*/ if ( nLastBroadcast != nOldRow ) +/*N*/ { // direkt aufeinanderfolgende nicht doppelt broadcasten +/*N*/ rAddress.SetRow( nOldRow ); +/*N*/ pDocument->AreaBroadcast( aHint ); +/*N*/ } +/*N*/ USHORT nNewRow = (pItems[i].nRow += nSize); +/*N*/ // #43940# Aenderung Ziel broadcasten +/*N*/ rAddress.SetRow( nNewRow ); +/*N*/ pDocument->AreaBroadcast( aHint ); +/*N*/ nLastBroadcast = nNewRow; +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow ); +/*N*/ if ( nNewRow > MAXROW && !bCountChanged ) +/*N*/ { +/*N*/ nNewCount = i; +/*N*/ bCountChanged = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rAddress.SetRow( pItems[i].nRow ); +/*N*/ ScRange aRange( rAddress ); +/*N*/ for ( ; i < nCount; i++) +/*N*/ { +/*N*/ USHORT nNewRow = (pItems[i].nRow += nSize); +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow ); +/*N*/ if ( nNewRow > MAXROW && !bCountChanged ) +/*N*/ { +/*N*/ nNewCount = i; +/*N*/ bCountChanged = TRUE; +/*N*/ aRange.aEnd.SetRow( MAXROW ); +/*N*/ } +/*N*/ } +/*N*/ if ( !bCountChanged ) +/*N*/ aRange.aEnd.SetRow( pItems[nCount-1].nRow ); +/*N*/ pDocument->AreaBroadcastInRange( aRange, aHint ); +/*N*/ } +/*N*/ +/*N*/ if (bCountChanged) +/*N*/ { +/*N*/ USHORT nDelCount = nCount - nNewCount; +/*N*/ ScBaseCell** ppDelCells = new ScBaseCell*[nDelCount]; +/*N*/ USHORT* pDelRows = new USHORT[nDelCount]; +/*N*/ for (i = 0; i < nDelCount; i++) +/*N*/ { +/*N*/ ppDelCells[i] = pItems[nNewCount+i].pCell; +/*N*/ pDelRows[i] = pItems[nNewCount+i].nRow; +/*N*/ } +/*N*/ nCount = nNewCount; +/*N*/ +/*N*/ for (i = 0; i < nDelCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = ppDelCells[i]; +/*N*/ DBG_ASSERT( !CellVisible(pCell), "sichtbare Zelle weggeschoben" ); +/*N*/ ScBroadcasterList* pBC = pCell->GetBroadcaster(); +/*N*/ if (pBC) +/*N*/ { +/*N*/ MoveListeners( *pBC, pDelRows[i] - nSize ); +/*N*/ pCell->SetBroadcaster(NULL); +/*N*/ pCell->Delete(); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ delete[] pDelRows; +/*N*/ delete[] ppDelCells; +/*N*/ } +/*N*/ +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + + + +/*N*/ void ScColumn::CopyToColumn(USHORT nRow1, USHORT nRow2, USHORT nFlags, BOOL bMarked, +/*N*/ ScColumn& rColumn, const ScMarkData* pMarkData, BOOL bAsLink ) +/*N*/ { +/*N*/ if (bMarked) +/*N*/ { +/*N*/ USHORT nStart, nEnd; +/*N*/ if (pMarkData && pMarkData->IsMultiMarked()) +/*N*/ { +/*N*/ ScMarkArrayIter aIter( pMarkData->GetArray()+nCol ); +/*N*/ +/*N*/ while ( aIter.Next( nStart, nEnd ) && nStart <= nRow2 ) +/*N*/ { +/*N*/ if ( nEnd >= nRow1 ) +/*N*/ CopyToColumn( Max(nRow1,nStart), Min(nRow2,nEnd), +/*N*/ nFlags, FALSE, rColumn, pMarkData, bAsLink ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("CopyToColumn: bMarked, aber keine Markierung"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ if ( (nFlags & IDF_ATTRIB) != 0 ) +/*N*/ { +/*N*/ if ( (nFlags & IDF_STYLES) != IDF_STYLES ) +/*N*/ { // StyleSheets im Zieldokument bleiben erhalten +/*?*/ // z.B. DIF und RTF Clipboard-Import +/*?*/ for ( USHORT nRow = nRow1; nRow <= nRow2; nRow++ ) +/*?*/ { +/*?*/ const ScStyleSheet* pStyle = +/*?*/ rColumn.pAttrArray->GetPattern( nRow )->GetStyleSheet(); +/*?*/ const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow ); +/*?*/ ScPatternAttr* pNewPattern = new ScPatternAttr( *pPattern ); +/*?*/ pNewPattern->SetStyleSheet( (ScStyleSheet*)pStyle ); +/*?*/ rColumn.pAttrArray->SetPattern( nRow, pNewPattern, TRUE ); +/*?*/ delete pNewPattern; +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ pAttrArray->CopyArea( nRow1, nRow2, 0, *rColumn.pAttrArray); +/*N*/ } +/*N*/ +/*N*/ +/*N*/ if ((nFlags & IDF_CONTENTS) != 0) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT nBlockCount = 0; +/*N*/ USHORT nStartIndex, nEndIndex; +/*N*/ for (i = 0; i < nCount; i++) +/*N*/ if ((pItems[i].nRow >= nRow1) && (pItems[i].nRow <= nRow2)) +/*N*/ { +/*N*/ if (!nBlockCount) +/*N*/ nStartIndex = i; +/*N*/ nEndIndex = i; +/*N*/ ++nBlockCount; +/*N*/ } +/*N*/ +/*N*/ if (nBlockCount) +/*N*/ { +/*N*/ rColumn.Resize( rColumn.GetCellCount() + nBlockCount ); +/*N*/ ScAddress aAdr( rColumn.nCol, 0, rColumn.nTab ); +/*N*/ for (i = nStartIndex; i <= nEndIndex; i++) +/*N*/ { +/*N*/ ScBaseCell* pOld = pItems[i].pCell; +/*N*/ aAdr.SetRow( pItems[i].nRow ); +/*N*/ ScBaseCell* pNew = NULL; +/*N*/ if (bAsLink) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pNew = CreateRefCell( rColumn.pDocument, aAdr, i, nFlags ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pNew = CloneCell( i, nFlags, rColumn.pDocument, aAdr ); +/*N*/ +/*N*/ if ( pNew && pNew->GetNotePtr() && (nFlags & IDF_NOTE) == 0 ) +/*?*/ pNew->DeleteNote(); +/*N*/ } +/*N*/ +/*N*/ if (pNew) +/*N*/ rColumn.Insert(pItems[i].nRow, pNew); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + + + + + + + + + +/*N*/ void ScColumn::MarkScenarioIn( ScMarkData& rDestMark ) const +/*N*/ { +/*N*/ ScRange aRange( nCol, 0, nTab ); +/*N*/ +/*N*/ ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW ); +/*N*/ USHORT nStart, nEnd; +/*N*/ const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd ); +/*N*/ while (pPattern) +/*N*/ { +/*N*/ if ( ((ScMergeFlagAttr&)pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() ) +/*N*/ { +/*N*/ aRange.aStart.SetRow( nStart ); +/*N*/ aRange.aEnd.SetRow( nEnd ); +/*N*/ rDestMark.SetMultiMarkArea( aRange, TRUE ); +/*N*/ } +/*N*/ +/*N*/ pPattern = aAttrIter.Next( nStart, nEnd ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::SwapCol(ScColumn& rCol) +/*N*/ { +/*N*/ USHORT nTemp; +/*N*/ +/*N*/ nTemp = rCol.nCount; +/*N*/ rCol.nCount = nCount; +/*N*/ nCount = nTemp; +/*N*/ +/*N*/ nTemp = rCol.nLimit; +/*N*/ rCol.nLimit = nLimit; +/*N*/ nLimit = nTemp; +/*N*/ +/*N*/ ColEntry* pTempItems = rCol.pItems; +/*N*/ rCol.pItems = pItems; +/*N*/ pItems = pTempItems; +/*N*/ +/*N*/ ScAttrArray* pTempAttr = rCol.pAttrArray; +/*N*/ rCol.pAttrArray = pAttrArray; +/*N*/ pAttrArray = pTempAttr; +/*N*/ +/*N*/ // #38415# AttrArray muss richtige Spaltennummer haben +/*N*/ pAttrArray->SetCol(nCol); +/*N*/ rCol.pAttrArray->SetCol(rCol.nCol); +/*N*/ +/*N*/ USHORT i; +/*N*/ if (pItems) +/*N*/ for (i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ pCell->aPos.SetCol(nCol); +/*N*/ } +/*N*/ if (rCol.pItems) +/*N*/ for (i = 0; i < rCol.nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* pCell = (ScFormulaCell*) rCol.pItems[i].pCell; +/*N*/ if( pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ pCell->aPos.SetCol(rCol.nCol); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::MoveTo(USHORT nStartRow, USHORT nEndRow, ScColumn& rCol) +/*N*/ { +/*N*/ pAttrArray->MoveTo(nStartRow, nEndRow, *rCol.pAttrArray); +/*N*/ +/*N*/ if (pItems) +/*N*/ { +/*N*/ USHORT nStartPos; +/*N*/ USHORT nMoveCount=0; +/*N*/ USHORT i; +/*N*/ for (i=0; i < nCount; i++) +/*N*/ { +/*N*/ if ((pItems[i].nRow >= nStartRow) && (pItems[i].nRow <= nEndRow)) +/*N*/ { +/*N*/ if (nMoveCount==0) +/*N*/ nStartPos=i; +/*N*/ ++nMoveCount; +/*N*/ +/*N*/ rCol.Insert(pItems[i].nRow, pItems[i].pCell); +/*N*/ } +/*N*/ } +/*N*/ if (nMoveCount > 0) +/*N*/ { +/*N*/ // Formeln benachrichtigen, dass sich etwas aendert +/*N*/ +/*N*/ ScNoteCell* pNoteCell = new ScNoteCell; // Dummy wie in DeleteRange +/*N*/ USHORT nEndPos = nStartPos+nMoveCount-1; +/*N*/ for (i=nStartPos; i<=nEndPos; i++) +/*N*/ pItems[i].pCell = pNoteCell; // nicht auf die verschobenen zugreifen +/*N*/ ScAddress aAdr( nCol, 0, nTab ); +/*N*/ ScHint aHint( SC_HINT_DYING, aAdr, NULL ); // areas only +/*N*/ ScAddress& rAddress = aHint.GetAddress(); +/*N*/ for (i=nStartPos; i<=nEndPos; i++) +/*N*/ { +/*N*/ rAddress.SetRow( pItems[i].nRow ); +/*N*/ pDocument->AreaBroadcast( aHint ); +/*N*/ } +/*N*/ delete pNoteCell; +/*N*/ +/*N*/ nCount -= nMoveCount; +/*N*/ memmove( &pItems[nStartPos], &pItems[nStartPos+nMoveCount], +/*N*/ (nCount - nStartPos) * sizeof(ColEntry) ); +/*N*/ pItems[nCount].nRow = 0; +/*N*/ pItems[nCount].pCell = NULL; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, short nDx, short nDy, short nDz, +/*N*/ ScDocument* pUndoDoc ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ { +/*N*/ ScRange aRange( ScAddress( nCol1, nRow1, nTab1 ), +/*N*/ ScAddress( nCol2, nRow2, nTab2 ) ); +/*N*/ if ( eUpdateRefMode == URM_COPY && nRow1 == nRow2 ) +/*N*/ { // z.B. eine einzelne Zelle aus dem Clipboard eingefuegt +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ USHORT nIndex; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ // #90279# For performance reasons two loop bodies instead of +/*?*/ // testing for update mode in each iteration. +/*?*/ // Anyways, this is still a bottleneck on large arrays with few +/*?*/ // formulas cells. +/*?*/ if ( eUpdateRefMode == URM_COPY ) +/*?*/ { +/*?*/ USHORT i; +/*?*/ Search( nRow1, i ); +/*?*/ for ( ; i < nCount; i++ ) +/*?*/ { +/*?*/ USHORT nRow = pItems[i].nRow; +/*?*/ if ( nRow > nRow2 ) +/*?*/ break; +/*?*/ ScBaseCell* pCell = pItems[i].pCell; +/*?*/ if( pCell->GetCellType() == CELLTYPE_FORMULA) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ((ScFormulaCell*)pCell)->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc ); +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ USHORT i = 0; +/*?*/ for ( ; i < nCount; i++ ) +/*?*/ { +/*?*/ ScBaseCell* pCell = pItems[i].pCell; +/*?*/ if( pCell->GetCellType() == CELLTYPE_FORMULA) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 USHORT nRow = pItems[i].nRow; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + + + +/*N*/ void ScColumn::UpdateInsertTab( USHORT nTable) +/*N*/ { +/*N*/ if (nTab >= nTable) nTab++; +/*N*/ if( pItems ) +/*N*/ UpdateInsertTabOnlyCells( nTable ); +/*N*/ } + + +/*N*/ void ScColumn::UpdateInsertTabOnlyCells( USHORT nTable) +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ pCell->UpdateInsertTab(nTable); +/*N*/ if ( nRow != pItems[i].nRow ) +/*N*/ Search( nRow, i ); // Listener geloescht/eingefuegt? +/*N*/ } +/*N*/ } +/*N*/ } + + + + +/*N*/ void ScColumn::UpdateDeleteTab( USHORT nTable, BOOL bIsMove, ScColumn* pRefUndo ) +/*N*/ { +/*N*/ if (nTab > nTable) +/*N*/ pAttrArray->SetTab(--nTab); +/*N*/ +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ ScFormulaCell* pOld = (ScFormulaCell*)pItems[i].pCell; +/*N*/ +/*N*/ ScFormulaCell* pSave = NULL; +/*N*/ if (pRefUndo) +/*N*/ pSave = (ScFormulaCell*)pOld->Clone( pDocument, +/*N*/ ScAddress( nCol, nRow, nTab ), TRUE ); +/*N*/ +/*N*/ BOOL bChanged = pOld->UpdateDeleteTab(nTable, bIsMove); +/*N*/ if ( nRow != pItems[i].nRow ) +/*N*/ Search( nRow, i ); // Listener geloescht/eingefuegt? +/*N*/ +/*N*/ if (pRefUndo) +/*N*/ { +/*N*/ if (bChanged) +/*N*/ pRefUndo->Insert( nRow, pSave ); +/*N*/ else +/*N*/ delete pSave; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::UpdateCompile( BOOL bForceIfNameInUse ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( p->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ p->UpdateCompile( bForceIfNameInUse ); +/*N*/ if ( nRow != pItems[i].nRow ) +/*?*/ Search( nRow, i ); // Listener geloescht/eingefuegt? +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::SetTabNo(USHORT nNewTab) +/*N*/ { +/*N*/ nTab = nNewTab; +/*N*/ pAttrArray->SetTab( nNewTab ); +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( p->GetCellType() == CELLTYPE_FORMULA ) +/*?*/ p->aPos.SetTab( nNewTab ); +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScColumn::IsRangeNameInUse(USHORT nRow1, USHORT nRow2, USHORT nIndex) const +/*N*/ { +/*N*/ BOOL bInUse = FALSE; +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; !bInUse && (i < nCount); i++) +/*N*/ if ((pItems[i].nRow >= nRow1) && +/*N*/ (pItems[i].nRow <= nRow2) && +/*N*/ (pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA)) +/*N*/ bInUse = ((ScFormulaCell*)pItems[i].pCell)->IsRangeNameInUse(nIndex); +/*N*/ return bInUse; +/*N*/ } + + + + +/*N*/ void ScColumn::SetDirtyVar() +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( p->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ p->SetDirtyVar(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::SetDirty() +/*N*/ { +/*N*/ // wird nur dokumentweit verwendet, kein FormulaTrack +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( p->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ p->SetDirtyVar(); +/*N*/ if ( !pDocument->IsInFormulaTree( p ) ) +/*N*/ pDocument->PutInFormulaTree( p ); +/*N*/ } +/*N*/ } +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + + + +/*N*/ void ScColumn::SetTableOpDirty( const ScRange& rRange ) +/*N*/ { +/*N*/ if ( !pItems || !nCount ) +/*N*/ return ; +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // no multiple recalculation +/*N*/ USHORT nRow2 = rRange.aEnd.Row(); +/*N*/ ScAddress aPos( nCol, 0, nTab ); +/*N*/ ScHint aHint( SC_HINT_TABLEOPDIRTY, aPos, NULL ); +/*N*/ USHORT nRow, nIndex; +/*N*/ Search( rRange.aStart.Row(), nIndex ); +/*N*/ while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->SetTableOpDirty(); +/*N*/ else +/*N*/ { +/*N*/ aHint.GetAddress().SetRow( nRow ); +/*N*/ aHint.SetCell( pCell ); +/*N*/ pDocument->Broadcast( aHint ); +/*N*/ } +/*N*/ nIndex++; +/*N*/ } +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScColumn::SetDirtyAfterLoad() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if ( p->GetCellType() == CELLTYPE_FORMULA && p->GetDirty() ) +/*N*/ p->SetDirty(); +/*N*/ // wenn die Zelle durch CalcAfterLoad schon bDirty war, muss +/*N*/ // jetzt noch FormulaTracking stattfinden +/*N*/ } +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScColumn::SetRelNameDirty() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell; +/*N*/ if( p->GetCellType() == CELLTYPE_FORMULA && p->HasRelNameReference() ) +/*N*/ p->SetDirty(); +/*N*/ } +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScColumn::CalcAll() +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ #if OSL_DEBUG_LEVEL > 1 +/*N*/ // nach F9 ctrl-F9: ueberprueft die Berechnung per FormulaTree +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ double nOldVal, nNewVal; +/*N*/ nOldVal = pFCell->GetValue(); +/*N*/ #endif +/*N*/ ((ScFormulaCell*)pCell)->Interpret(); +/*N*/ #if OSL_DEBUG_LEVEL > 1 +/*N*/ if ( pFCell->GetCode()->IsRecalcModeNormal() ) +/*N*/ nNewVal = pFCell->GetValue(); +/*N*/ else +/*N*/ nNewVal = nOldVal; // random(), jetzt() etc. +/*N*/ DBG_ASSERT( nOldVal==nNewVal, "CalcAll: nOldVal != nNewVal" ); +/*N*/ #endif +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::CompileAll() +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*?*/ USHORT nRow = pItems[i].nRow; +/*?*/ // fuer unbedingtes kompilieren +/*?*/ // bCompile=TRUE und pCode->nError=0 +/*?*/ ((ScFormulaCell*)pCell)->GetCode()->SetError( 0 ); +/*?*/ ((ScFormulaCell*)pCell)->SetCompile( TRUE ); +/*?*/ ((ScFormulaCell*)pCell)->CompileTokenArray(); +/*?*/ if ( nRow != pItems[i].nRow ) +/*?*/ Search( nRow, i ); // Listener geloescht/eingefuegt? +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::CompileXML( ScProgress& rProgress ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ ((ScFormulaCell*)pCell)->CompileXML( rProgress ); +/*N*/ if ( nRow != pItems[i].nRow ) +/*N*/ Search( nRow, i ); // Listener geloescht/eingefuegt? +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::CalcAfterLoad() +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->CalcAfterLoad(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::ResetChanged( USHORT nStartRow, USHORT nEndRow ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ Search(nStartRow,nIndex); +/*N*/ while (nIndex<nCount && pItems[nIndex].nRow <= nEndRow) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ ((ScFormulaCell*)pCell)->ResetChanged(); +/*N*/ ++nIndex; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScColumn::HasEditCells(USHORT nStartRow, USHORT nEndRow, USHORT& rFirst) const +/*N*/ { +/*N*/ // used in GetOptimalHeight - ambiguous script type counts as edit cell +/*N*/ +/*N*/ USHORT nRow; +/*N*/ USHORT nIndex; +/*N*/ Search(nStartRow,nIndex); +/*N*/ while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : FALSE ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_EDIT || +/*N*/ IsAmbiguousScriptNonZero( pDocument->GetScriptType(nCol, nRow, nTab, pCell) ) ) +/*N*/ { +/*N*/ rFirst = nRow; +/*N*/ return TRUE; +/*N*/ } +/*N*/ ++nIndex; +/*N*/ } +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_column2.cxx b/binfilter/bf_sc/source/core/data/sc_column2.cxx new file mode 100644 index 000000000000..64275fc797d9 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_column2.cxx @@ -0,0 +1,1792 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/algitem.hxx> +#include <bf_svx/editobj.hxx> +#include <bf_svx/emphitem.hxx> +#include <bf_svx/fhgtitem.hxx> +#include <bf_svx/forbiddencharacterstable.hxx> +#include <bf_svx/rotmodit.hxx> +#include <bf_svx/scripttypeitem.hxx> +#include <bf_svx/unolingu.hxx> +#include <vcl/outdev.hxx> +#include <math.h> + +#include "cell.hxx" +#include "document.hxx" +#include "attarray.hxx" +#include "patattr.hxx" +#include "cellform.hxx" +#include "rechead.hxx" +#include "editutil.hxx" +#include "subtotal.hxx" +#include "markdata.hxx" +#include "dbcolect.hxx" +#include "bclist.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + +// factor from font size to optimal cell height (text width) +#define SC_ROT_BREAK_FACTOR 6 + +// ----------------------------------------------------------------------- + +/*N*/ inline BOOL CellVisible( const ScBaseCell* pCell ) +/*N*/ { +/*N*/ return ( pCell->GetCellType() != CELLTYPE_NOTE || pCell->GetNotePtr() ); +/*N*/ } +/*N*/ +/*N*/ inline BOOL IsAmbiguousScript( BYTE nScript ) +/*N*/ { +/*N*/ //! move to a header file +/*N*/ return ( nScript != SCRIPTTYPE_LATIN && +/*N*/ nScript != SCRIPTTYPE_ASIAN && +/*N*/ nScript != SCRIPTTYPE_COMPLEX ); +/*N*/ } + +// ----------------------------------------------------------------------------------------- + +// +// Datei-Operationen +// + +// ----------------------------------------------------------------------------------------- + +// special handling for non-convertable characters is no longer needed +#if 0 + +// read string from a string cell in original CharSet + + +#endif + +// ----------------------------------------------------------------------------------------- + +/*N*/ void ScColumn::LoadData( SvStream& rStream ) +/*N*/ { +/*N*/ USHORT nNewCount; +/*N*/ USHORT nNewRow; +/*N*/ BYTE nByte; +/*N*/ USHORT nVer = (USHORT) pDocument->GetSrcVersion(); +/*N*/ +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> nNewCount; +/*N*/ if ( nNewCount > MAXROW+1 ) // wuerde das Array zu gross? +/*N*/ { +/*?*/ pDocument->SetLostData(); +/*?*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ Resize( nNewCount ); // veraendert nCount nicht +/*N*/ for (USHORT i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ rStream >> nNewRow; +/*N*/ rStream >> nByte; +/*N*/ +/*N*/ if ( nNewRow > MAXROW ) // Zeilennummer zu gross? +/*N*/ { +/*?*/ pDocument->SetLostData(); +/*?*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ switch ((CellType) nByte) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ ScValueCell* pCell = new ScValueCell( rStream, nVer ); +/*N*/ Append( nNewRow, pCell ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ { +/*N*/ ScStringCell* pCell = new ScStringCell( rStream, nVer ); +/*N*/ Append( nNewRow, pCell ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_SYMBOLS: +/*N*/ { +/*N*/ CharSet eOld = rStream.GetStreamCharSet(); +/*N*/ // convert into true symbol characters +/*N*/ rStream.SetStreamCharSet( RTL_TEXTENCODING_SYMBOL ); +/*N*/ ScStringCell* pCell = new ScStringCell( rStream, nVer ); +/*N*/ Append( nNewRow, pCell ); +/*N*/ rStream.SetStreamCharSet( eOld ); +/*N*/ ScSymbolStringCellEntry * pEntry = new ScSymbolStringCellEntry; +/*N*/ pEntry->pCell = pCell; +/*N*/ pEntry->nRow = nNewRow; +/*N*/ pDocument->GetLoadedSymbolStringCellsList().Insert( +/*N*/ pEntry, LIST_APPEND ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ { +/*N*/ ScEditCell* pCell = new ScEditCell( rStream, nVer, pDocument ); +/*N*/ Append( nNewRow, pCell ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ ScFormulaCell* pCell = new ScFormulaCell( +/*N*/ pDocument, ScAddress( nCol, nNewRow, nTab ), rStream, aHdr ); +/*N*/ Append( nNewRow, pCell); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_NOTE: +/*N*/ { +/*N*/ ScNoteCell *pCell = new ScNoteCell( rStream, nVer ); +/*N*/ Append( nNewRow, pCell); +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "Falscher Zellentyp" ); +/*N*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL lcl_RemoveAny( ScDocument* pDocument, USHORT nCol, USHORT nTab ) +/*N*/ { +/*N*/ ScDBCollection* pDBColl = pDocument->GetDBCollection(); +/*N*/ if ( pDBColl ) +/*N*/ { +/*N*/ USHORT nCount = pDBColl->GetCount(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDBData* pData = (*pDBColl)[i]; +/*N*/ if ( pData->IsStripData() && +/*N*/ pData->HasImportParam() && !pData->HasImportSelection() ) +/*N*/ { +/*?*/ ScRange aDBRange; +/*?*/ pData->GetArea(aDBRange); +/*?*/ if ( nTab == aDBRange.aStart.Tab() && +/*?*/ nCol >= aDBRange.aStart.Col() && nCol <= aDBRange.aEnd.Col() ) +/*?*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +BOOL lcl_RemoveThis( ScDocument* pDocument, USHORT nCol, USHORT nRow, USHORT nTab ) +{ + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScDBCollection* pDBColl = pDocument->GetDBCollection(); + + return FALSE; +} + +/*N*/ void ScColumn::SaveData( SvStream& rStream ) const +/*N*/ { +/*N*/ CellType eCellType; +/*N*/ ScBaseCell* pCell; +/*N*/ USHORT i; +/*N*/ ScFontToSubsFontConverter_AutoPtr xFontConverter; +/*N*/ const ULONG nFontConverterFlags = FONTTOSUBSFONT_EXPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS; +/*N*/ +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nSaveCount = nCount; +/*N*/ +/*N*/ // Zeilen hinter MAXROW abziehen +/*N*/ USHORT nSaveMaxRow = pDocument->GetSrcMaxRow(); +/*N*/ if ( nSaveMaxRow != MAXROW ) +/*N*/ { +/*N*/ if ( nSaveCount && pItems[nSaveCount-1].nRow > nSaveMaxRow ) +/*N*/ { +/*?*/ pDocument->SetLostData(); // Warnung ausgeben +/*?*/ do +/*?*/ --nSaveCount; +/*?*/ while ( nSaveCount && pItems[nSaveCount-1].nRow > nSaveMaxRow ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Zellen abziehen, die wegen Import nicht gespeichert werden +/*N*/ BOOL bRemoveAny = lcl_RemoveAny( pDocument, nCol, nTab ); +/*N*/ USHORT nEffCount = nSaveCount; +/*N*/ if ( bRemoveAny ) +/*N*/ { +/*?*/ for (i=0; i<nSaveCount; i++) +/*?*/ if ( lcl_RemoveThis( pDocument, nCol, pItems[i].nRow, nTab ) ) +/*?*/ --nEffCount; +/*?*/ +/*?*/ // String aDbg("Tab ");aDbg+=nTab;aDbg+=" Col ";aDbg+=nCol; +/*?*/ // aDbg+=" Remove ";aDbg+=nSaveCount-nEffCount; DBG_ERROR(aDbg); +/*N*/ } +/*N*/ +/*N*/ rStream << nEffCount; // nEffCount: Zellen, die wirklich gespeichert werden +/*N*/ +/*N*/ ScAttrIterator aIter( pAttrArray, 0, MAXROW ); +/*N*/ USHORT nStt, nEnd; +/*N*/ const ScPatternAttr* pAttr; +/*N*/ do +/*N*/ { +/*N*/ pAttr = aIter.Next( nStt, nEnd ); +/*N*/ } +/*N*/ while( pAttr && !( +/*N*/ (xFontConverter = pAttr->GetSubsFontConverter( nFontConverterFlags )) +/*N*/ || pAttr->IsSymbolFont()) ); +/*N*/ +/*N*/ for (i=0; i<nSaveCount; i++) // nSaveCount: Ende auf MAXROW angepasst +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ +/*N*/ if ( !bRemoveAny || !lcl_RemoveThis( pDocument, nCol, nRow, nTab ) ) +/*N*/ { +/*N*/ rStream << nRow; +/*N*/ +/*N*/ pCell = pItems[i].pCell; +/*N*/ eCellType = pCell->GetCellType(); +/*N*/ +/*N*/ switch( eCellType ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ rStream << (BYTE) eCellType; +/*N*/ ((ScValueCell*)pCell)->Save( rStream ); +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ if( pAttr ) +/*N*/ { +/*N*/ if( nRow > nEnd ) +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ pAttr = aIter.Next( nStt, nEnd ); +/*N*/ } +/*N*/ while ( pAttr && nRow > nEnd ); // #99139# skip all formats before this cell +/*N*/ } +/*N*/ while( pAttr && !( +/*N*/ (xFontConverter = pAttr->GetSubsFontConverter( nFontConverterFlags )) +/*N*/ || pAttr->IsSymbolFont()) ); +/*N*/ } +/*N*/ if( pAttr && nRow >= nStt && nRow <= nEnd ) +/*N*/ eCellType = CELLTYPE_SYMBOLS; +/*N*/ } +/*N*/ rStream << (BYTE) eCellType; +/*N*/ if ( eCellType == CELLTYPE_SYMBOLS ) +/*N*/ { +/*N*/ // cell string contains true symbol characters +/*N*/ CharSet eOld = rStream.GetStreamCharSet(); +/*N*/ rStream.SetStreamCharSet( RTL_TEXTENCODING_SYMBOL ); +/*N*/ ((ScStringCell*)pCell)->Save( rStream, xFontConverter ); +/*N*/ rStream.SetStreamCharSet( eOld ); +/*N*/ } +/*N*/ else +/*N*/ ((ScStringCell*)pCell)->Save( rStream ); +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ rStream << (BYTE) eCellType; +/*N*/ ((ScEditCell*)pCell)->Save( rStream ); +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ rStream << (BYTE) eCellType; +/*N*/ ((ScFormulaCell*)pCell)->Save( rStream, aHdr ); +/*N*/ break; +/*N*/ case CELLTYPE_NOTE: +/*N*/ rStream << (BYTE) eCellType; +/*N*/ ((ScNoteCell*)pCell)->Save( rStream ); +/*N*/ break; +/*?*/ default: +/*?*/ { +/*?*/ // #53846# soll zwar nicht vorkommen, aber falls doch, +/*?*/ // eine leere NoteCell speichern, damit das Dokument +/*?*/ // ueberhaupt wieder geladen werden kann. +/*?*/ rStream << (BYTE) CELLTYPE_NOTE; +/*?*/ ScNoteCell aDummyCell; +/*?*/ aDummyCell.Save( rStream ); +/*?*/ DBG_ERROR( "Falscher Zellentyp" ); +/*?*/ } +/*?*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------------------------- + +/*N*/ void ScColumn::LoadNotes( SvStream& rStream ) +/*N*/ { +/*N*/ ScReadHeader aHdr(rStream); +/*N*/ +/*N*/ USHORT nNoteCount; +/*N*/ rStream >> nNoteCount; +/*N*/ for (USHORT i=0; i<nNoteCount && rStream.GetError() == SVSTREAM_OK; i++) +/*N*/ { +/*N*/ USHORT nPos; +/*N*/ rStream >> nPos; +/*N*/ if (nPos < nCount) +/*N*/ pItems[nPos].pCell->LoadNote(rStream); +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("falsche Pos in ScColumn::LoadNotes"); +/*N*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ USHORT ScColumn::NoteCount( USHORT nMaxRow ) const +/*N*/ { +/*N*/ USHORT nNoteCount = 0; +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ( pItems[i].pCell->GetNotePtr() && pItems[i].nRow<=nMaxRow ) +/*N*/ ++nNoteCount; +/*N*/ +/*N*/ return nNoteCount; +/*N*/ } + +/*N*/ void ScColumn::SaveNotes( SvStream& rStream ) const +/*N*/ { +/*N*/ USHORT nSaveMaxRow = pDocument->GetSrcMaxRow(); +/*N*/ USHORT i; +/*N*/ +/*N*/ BOOL bRemoveAny = lcl_RemoveAny( pDocument, nCol, nTab ); +/*N*/ USHORT nNoteCount; +/*N*/ if ( bRemoveAny ) +/*N*/ { +/*?*/ // vorher zaehlen, wieviele Notizen es werden +/*?*/ +/*?*/ nNoteCount = 0; +/*?*/ for (i=0; i<nCount; i++) +/*?*/ if ( pItems[i].pCell->GetNotePtr() && pItems[i].nRow<=nSaveMaxRow && +/*?*/ !lcl_RemoveThis( pDocument, nCol, pItems[i].nRow, nTab ) ) +/*?*/ ++nNoteCount; +/*N*/ } +/*N*/ else +/*N*/ nNoteCount = NoteCount(nSaveMaxRow); +/*N*/ +/*N*/ // Speichern +/*N*/ // Als Positionen muessen die Indizes gespeichert werden, die beim Laden entstehen, +/*N*/ // also ohne die weggelassenen Zellen mitzuzaehlen. +/*N*/ +/*N*/ ScWriteHeader aHdr(rStream); +/*N*/ rStream << nNoteCount; +/*N*/ +/*N*/ USHORT nDestPos = 0; +/*N*/ for (i=0; i<nCount && rStream.GetError() == SVSTREAM_OK; i++) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ if ( !bRemoveAny || !lcl_RemoveThis( pDocument, nCol, nRow, nTab ) ) +/*N*/ { +/*N*/ const ScPostIt* pNote = pItems[i].pCell->GetNotePtr(); +/*N*/ if ( pNote && nRow <= nSaveMaxRow ) +/*N*/ { +/*N*/ rStream << nDestPos; +/*N*/ rStream << *pNote; +/*N*/ } +/*N*/ ++nDestPos; // nDestPos zaehlt die in SaveData gespeicherten Zellen +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // SetLostData ist schon in SaveData passiert, wenn noetig +/*N*/ } + +// ----------------------------------------------------------------------------------------- + +/*N*/ void ScColumn::CorrectSymbolCells( CharSet eStreamCharSet ) +/*N*/ { +/*N*/ // #99139# find and correct string cells that are formatted with a symbol font, +/*N*/ // but are not in the LoadedSymbolStringCellsList +/*N*/ // (because CELLTYPE_SYMBOLS wasn't written in the file) +/*N*/ +/*N*/ ScFontToSubsFontConverter_AutoPtr xFontConverter; +/*N*/ const ULONG nFontConverterFlags = FONTTOSUBSFONT_EXPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS; +/*N*/ +/*N*/ BOOL bListInitialized = FALSE; +/*N*/ ScSymbolStringCellEntry* pCurrentEntry = NULL; +/*N*/ +/*N*/ ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW ); +/*N*/ USHORT nStt, nEnd; +/*N*/ const ScPatternAttr* pAttr = aAttrIter.Next( nStt, nEnd ); +/*N*/ while ( pAttr ) +/*N*/ { +/*N*/ if ( (xFontConverter = pAttr->GetSubsFontConverter( nFontConverterFlags )) || +/*N*/ pAttr->IsSymbolFont() ) +/*N*/ { +/*N*/ ScColumnIterator aCellIter( this, nStt, nEnd ); +/*N*/ USHORT nRow; +/*N*/ ScBaseCell* pCell; +/*N*/ while ( aCellIter.Next( nRow, pCell ) ) +/*N*/ { +/*N*/ if ( pCell->GetCellType() == CELLTYPE_STRING ) +/*N*/ { +/*N*/ List& rList = pDocument->GetLoadedSymbolStringCellsList(); +/*N*/ if (!bListInitialized) +/*N*/ { +/*N*/ pCurrentEntry = (ScSymbolStringCellEntry*)rList.First(); +/*N*/ bListInitialized = TRUE; +/*N*/ } +/*N*/ +/*N*/ while ( pCurrentEntry && pCurrentEntry->nRow < nRow ) +/*N*/ pCurrentEntry = (ScSymbolStringCellEntry*)rList.Next(); +/*N*/ +/*N*/ if ( pCurrentEntry && pCurrentEntry->nRow == nRow ) +/*N*/ { +/*N*/ // found +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ // not in list -> convert and put into list +/*?*/ +/*?*/ ScStringCell* pStrCell = (ScStringCell*)pCell; +/*?*/ String aOldStr; +/*?*/ pStrCell->GetString( aOldStr ); +/*?*/ +/*?*/ // convert back to stream character set (get original data) +/*?*/ ByteString aByteStr( aOldStr, eStreamCharSet ); +/*?*/ +/*?*/ // convert using symbol encoding, as for CELLTYPE_SYMBOLS cells +/*?*/ String aNewStr( aByteStr, RTL_TEXTENCODING_SYMBOL ); +/*?*/ pStrCell->SetString( aNewStr ); +/*?*/ +/*?*/ ScSymbolStringCellEntry * pEntry = new ScSymbolStringCellEntry; +/*?*/ pEntry->pCell = pStrCell; +/*?*/ pEntry->nRow = nRow; +/*?*/ +/*?*/ if ( pCurrentEntry ) +/*?*/ rList.Insert( pEntry ); // before current entry - pCurrentEntry stays valid +/*?*/ else +/*?*/ rList.Insert( pEntry, LIST_APPEND ); // append if already behind last entry +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pAttr = aAttrIter.Next( nStt, nEnd ); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScColumn::Load( SvStream& rStream, ScMultipleReadHeader& rHdr ) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ while (rHdr.BytesLeft() && rStream.GetError() == SVSTREAM_OK) +/*N*/ { +/*N*/ USHORT nID; +/*N*/ rStream >> nID; +/*N*/ switch (nID) +/*N*/ { +/*N*/ case SCID_COLDATA: +/*N*/ LoadData( rStream ); +/*N*/ break; +/*N*/ case SCID_COLNOTES: +/*N*/ LoadNotes( rStream ); +/*N*/ break; +/*N*/ case SCID_COLATTRIB: +/*N*/ pAttrArray->Load( rStream ); +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ DBG_ERROR("unbekannter Sub-Record in ScColumn::Load"); +/*N*/ ScReadHeader aDummyHeader( rStream ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ // #99139# old versions didn't always write CELLTYPE_SYMBOLS for symbol string cells, +/*N*/ // so we have to look for remaining string cells in areas that are formatted with +/*N*/ // symbol font: +/*N*/ CorrectSymbolCells( rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ if ( pDocument->SymbolStringCellsPending() ) +/*N*/ { +/*N*/ ScFontToSubsFontConverter_AutoPtr xFontConverter; +/*N*/ const ULONG nFontConverterFlags = FONTTOSUBSFONT_IMPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS; +/*N*/ ScSymbolStringCellEntry* pE; +/*N*/ USHORT nStt, nEnd; +/*N*/ +/*N*/ ScAttrIterator aIter( pAttrArray, 0, MAXROW ); +/*N*/ const ScPatternAttr* pAttr = aIter.Next( nStt, nEnd ); +/*N*/ xFontConverter = pAttr->GetSubsFontConverter( nFontConverterFlags ); +/*N*/ +/*N*/ List& rList = pDocument->GetLoadedSymbolStringCellsList(); +/*N*/ for ( pE = (ScSymbolStringCellEntry*) rList.First(); pE; +/*N*/ pE = (ScSymbolStringCellEntry*) rList.Next() ) +/*N*/ { +/*N*/ const ScPatternAttr* pLastAttr = pAttr; +/*N*/ while ( nEnd < pE->nRow ) +/*N*/ { +/*N*/ pAttr = aIter.Next( nStt, nEnd ); +/*N*/ } +/*N*/ if ( pAttr != pLastAttr ) +/*N*/ xFontConverter = pAttr->GetSubsFontConverter( nFontConverterFlags ); +/*N*/ pE->pCell->ConvertFont( xFontConverter ); +/*N*/ delete pE; +/*N*/ } +/*N*/ rList.Clear(); +/*N*/ } +/*N*/ pAttrArray->ConvertFontsAfterLoad(); +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScColumn::Save( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ if (!IsEmptyData()) //! Test, ob alles weggelassen wird? +/*N*/ { +/*N*/ rStream << (USHORT) SCID_COLDATA; +/*N*/ SaveData( rStream ); +/*N*/ } +/*N*/ USHORT nNotes = NoteCount(); //! Test, ob alles weggelassen wird? +/*N*/ if (nNotes) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_COLNOTES; +/*N*/ SaveNotes( rStream ); +/*N*/ } +/*N*/ if (!IsEmptyAttr()) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_COLATTRIB; +/*N*/ pAttrArray->Save( rStream ); +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +// ----------------------------------------------------------------------------------------- + + // GetNeededSize: optimale Hoehe / Breite in Pixeln + +/*N*/ long ScColumn::GetNeededSize( USHORT nRow, OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bWidth, const ScNeededSizeOptions& rOptions ) +/*N*/ { +/*N*/ long nValue=0; +/*N*/ USHORT nIndex; +/*N*/ double nPPT = bWidth ? nPPTX : nPPTY; +/*N*/ if (Search(nRow,nIndex)) +/*N*/ { +/*N*/ const ScPatternAttr* pPattern = rOptions.pPattern; +/*N*/ if (!pPattern) +/*N*/ pPattern = pAttrArray->GetPattern( nRow ); +/*N*/ +/*N*/ // zusammengefasst? +/*N*/ // Merge nicht in bedingter Formatierung +/*N*/ +/*N*/ const ScMergeAttr* pMerge = (const ScMergeAttr*)&pPattern->GetItem(ATTR_MERGE); +/*N*/ const ScMergeFlagAttr* pFlag = (const ScMergeFlagAttr*)&pPattern->GetItem(ATTR_MERGE_FLAG); +/*N*/ +/*N*/ if ( bWidth ) +/*N*/ { +/*N*/ if ( pFlag->IsHorOverlapped() ) +/*N*/ return 0; +/*N*/ if ( rOptions.bSkipMerged && pMerge->GetColMerge() > 1 ) +/*N*/ return 0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( pFlag->IsVerOverlapped() ) +/*N*/ return 0; +/*N*/ if ( rOptions.bSkipMerged && pMerge->GetRowMerge() > 1 ) +/*N*/ return 0; +/*N*/ } +/*N*/ +/*N*/ // bedingte Formatierung +/*N*/ const SfxItemSet* pCondSet = NULL; +/*N*/ if ( ((const SfxUInt32Item&)pPattern->GetItem(ATTR_CONDITIONAL)).GetValue() ) +/*N*/ pCondSet = pDocument->GetCondResult( nCol, nRow, nTab ); +/*N*/ +/*N*/ // Zeilenumbruch? +/*N*/ +/*N*/ const SfxPoolItem* pCondItem; +/*N*/ SvxCellHorJustify eHorJust; +/*N*/ if (pCondSet && +/*N*/ pCondSet->GetItemState(ATTR_HOR_JUSTIFY, TRUE, &pCondItem) == SFX_ITEM_SET) +/*N*/ eHorJust = (SvxCellHorJustify)((const SvxHorJustifyItem*)pCondItem)->GetValue(); +/*N*/ else +/*N*/ eHorJust = (SvxCellHorJustify)((const SvxHorJustifyItem&) +/*N*/ pPattern->GetItem( ATTR_HOR_JUSTIFY )).GetValue(); +/*N*/ BOOL bBreak; +/*N*/ if ( eHorJust == SVX_HOR_JUSTIFY_BLOCK ) +/*N*/ bBreak = TRUE; +/*N*/ else if ( pCondSet && +/*N*/ pCondSet->GetItemState(ATTR_LINEBREAK, TRUE, &pCondItem) == SFX_ITEM_SET) +/*?*/ bBreak = ((const SfxBoolItem*)pCondItem)->GetValue(); +/*N*/ else +/*N*/ bBreak = ((const SfxBoolItem&)pPattern->GetItem(ATTR_LINEBREAK)).GetValue(); +/*N*/ +/*N*/ // get other attributes from pattern and conditional formatting +/*N*/ +/*N*/ SvxCellOrientation eOrient; +/*N*/ if (pCondSet && +/*N*/ pCondSet->GetItemState(ATTR_ORIENTATION, TRUE, &pCondItem) == SFX_ITEM_SET) +/*?*/ eOrient = (SvxCellOrientation)((const SvxOrientationItem*)pCondItem)->GetValue(); +/*N*/ else +/*N*/ eOrient = (SvxCellOrientation)((const SvxOrientationItem&) +/*N*/ pPattern->GetItem(ATTR_ORIENTATION)).GetValue(); +/*N*/ BOOL bAsianVertical = ( eOrient == SVX_ORIENTATION_STACKED && +/*N*/ ((const SfxBoolItem&)pPattern->GetItem( ATTR_VERTICAL_ASIAN, pCondSet )).GetValue() ); +/*N*/ if ( bAsianVertical ) +/*N*/ bBreak = FALSE; +/*N*/ +/*N*/ if ( bWidth && bBreak ) // after determining bAsianVertical (bBreak may be reset) +/*N*/ return 0; +/*N*/ +/*N*/ long nRotate = 0; +/*N*/ SvxRotateMode eRotMode = SVX_ROTATE_MODE_STANDARD; +/*N*/ if ( eOrient == SVX_ORIENTATION_STANDARD ) +/*N*/ { +/*N*/ if (pCondSet && +/*N*/ pCondSet->GetItemState(ATTR_ROTATE_VALUE, TRUE, &pCondItem) == SFX_ITEM_SET) +/*?*/ nRotate = ((const SfxInt32Item*)pCondItem)->GetValue(); +/*N*/ else +/*N*/ nRotate = ((const SfxInt32Item&)pPattern->GetItem(ATTR_ROTATE_VALUE)).GetValue(); +/*N*/ if ( nRotate ) +/*N*/ { +/*?*/ if (pCondSet && +/*?*/ pCondSet->GetItemState(ATTR_ROTATE_MODE, TRUE, &pCondItem) == SFX_ITEM_SET) +/*?*/ eRotMode = (SvxRotateMode)((const SvxRotateModeItem*)pCondItem)->GetValue(); +/*?*/ else +/*?*/ eRotMode = (SvxRotateMode)((const SvxRotateModeItem&) +/*?*/ pPattern->GetItem(ATTR_ROTATE_MODE)).GetValue(); +/*?*/ +/*?*/ if ( nRotate == 18000 ) +/*?*/ eRotMode = SVX_ROTATE_MODE_STANDARD; // keinen Ueberlauf +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ const SvxMarginItem* pMargin; +/*N*/ if (pCondSet && +/*N*/ pCondSet->GetItemState(ATTR_MARGIN, TRUE, &pCondItem) == SFX_ITEM_SET) +/*?*/ pMargin = (const SvxMarginItem*) pCondItem; +/*N*/ else +/*N*/ pMargin = (const SvxMarginItem*) &pPattern->GetItem(ATTR_MARGIN); +/*N*/ USHORT nIndent = 0; +/*N*/ if ( eHorJust == SVX_HOR_JUSTIFY_LEFT ) +/*N*/ { +/*N*/ if (pCondSet && +/*N*/ pCondSet->GetItemState(ATTR_INDENT, TRUE, &pCondItem) == SFX_ITEM_SET) +/*?*/ nIndent = ((const SfxUInt16Item*)pCondItem)->GetValue(); +/*N*/ else +/*N*/ nIndent = ((const SfxUInt16Item&)pPattern->GetItem(ATTR_INDENT)).GetValue(); +/*N*/ } +/*N*/ +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ BYTE nScript = pDocument->GetScriptType( nCol, nRow, nTab, pCell ); +/*N*/ if (nScript == 0) nScript = ScGlobal::GetDefaultScriptType(); +/*N*/ +/*N*/ // also call SetFont for edit cells, because bGetFont may be set only once +/*N*/ // bGetFont is set also if script type changes +/*N*/ if (rOptions.bGetFont) +/*N*/ { +/*N*/ Fraction aFontZoom = ( eOrient == SVX_ORIENTATION_STANDARD ) ? rZoomX : rZoomY; +/*N*/ Font aFont; +/*N*/ // font color doesn't matter here +/*N*/ pPattern->GetFont( aFont, SC_AUTOCOL_BLACK, pDev, &aFontZoom, pCondSet, nScript ); +/*N*/ pDev->SetFont(aFont); +/*N*/ } +/*N*/ +/*N*/ BOOL bAddMargin = TRUE; +/*N*/ BOOL bEditEngine = ( pCell->GetCellType() == CELLTYPE_EDIT || +/*N*/ eOrient == SVX_ORIENTATION_STACKED || +/*N*/ IsAmbiguousScript( nScript ) ); +/*N*/ +/*N*/ if (!bEditEngine) // direkte Ausgabe +/*N*/ { +/*N*/ String aValStr; +/*N*/ Color* pColor; +/*N*/ SvNumberFormatter* pFormatter = pDocument->GetFormatTable(); +/*N*/ ULONG nFormat = pPattern->GetNumberFormat( pFormatter, pCondSet ); +/*N*/ ScCellFormat::GetString( pCell, nFormat, aValStr, &pColor, +/*N*/ *pFormatter, +/*N*/ TRUE, rOptions.bFormula, ftCheck ); +/*N*/ if (aValStr.Len()) +/*N*/ { +/*N*/ // SetFont ist nach oben verschoben +/*N*/ +/*N*/ Size aSize( pDev->GetTextWidth( aValStr ), pDev->GetTextHeight() ); +/*N*/ if ( eOrient != SVX_ORIENTATION_STANDARD ) +/*N*/ { +/*?*/ long nTemp = aSize.Width(); +/*?*/ aSize.Width() = aSize.Height(); +/*?*/ aSize.Height() = nTemp; +/*N*/ } +/*N*/ else if ( nRotate ) +/*N*/ { +/*?*/ //! unterschiedliche Skalierung X/Y beruecksichtigen +/*?*/ +/*?*/ double nRealOrient = nRotate * F_PI18000; // nRotate sind 1/100 Grad +/*?*/ double nCosAbs = fabs( cos( nRealOrient ) ); +/*?*/ double nSinAbs = fabs( sin( nRealOrient ) ); +/*?*/ long nHeight = (long)( aSize.Height() * nCosAbs + aSize.Width() * nSinAbs ); +/*?*/ long nWidth; +/*?*/ if ( eRotMode == SVX_ROTATE_MODE_STANDARD ) +/*?*/ nWidth = (long)( aSize.Width() * nCosAbs + aSize.Height() * nSinAbs ); +/*?*/ else if ( rOptions.bTotalSize ) +/*?*/ { +/*?*/ nWidth = (long) ( pDocument->GetColWidth( nCol,nTab ) * nPPT ); +/*?*/ bAddMargin = FALSE; +/*?*/ // nur nach rechts: +/*?*/ //! unterscheiden nach Ausrichtung oben/unten (nur Text/ganze Hoehe) +DBG_BF_ASSERT(0, "STRIP"); +/*?*/ } +/*?*/ else +/*?*/ nWidth = (long)( aSize.Height() / nSinAbs ); //! begrenzen? +/*?*/ +/*?*/ if ( bBreak && !rOptions.bTotalSize ) +/*?*/ { +/*?*/ // #47744# limit size for line break +/*?*/ long nCmp = pDev->GetFont().GetSize().Height() * SC_ROT_BREAK_FACTOR; +/*?*/ if ( nHeight > nCmp ) +/*?*/ nHeight = nCmp; +/*?*/ } +/*?*/ +/*?*/ aSize = Size( nWidth, nHeight ); +/*N*/ } +/*N*/ nValue = bWidth ? aSize.Width() : aSize.Height(); +/*N*/ +/*N*/ if ( bAddMargin ) +/*N*/ { +/*N*/ if (bWidth) +/*N*/ { +/*?*/ nValue += (long) ( pMargin->GetLeftMargin() * nPPT ) + +/*?*/ (long) ( pMargin->GetRightMargin() * nPPT ); +/*?*/ if ( nIndent ) +/*?*/ nValue += (long) ( nIndent * nPPT ); +/*N*/ } +/*N*/ else +/*N*/ nValue += (long) ( pMargin->GetTopMargin() * nPPT ) + +/*N*/ (long) ( pMargin->GetBottomMargin() * nPPT ); +/*N*/ } +/*N*/ +/*N*/ // Zeilenumbruch ausgefuehrt ? +/*N*/ +/*N*/ if ( bBreak && !bWidth ) +/*N*/ { +/*N*/ // Test mit EditEngine zur Sicherheit schon bei 90% +/*N*/ // (wegen Rundungsfehlern und weil EditEngine teilweise anders formatiert) +/*N*/ +/*N*/ long nDocPixel = (long) ( ( pDocument->GetColWidth( nCol,nTab ) - +/*N*/ pMargin->GetLeftMargin() - pMargin->GetRightMargin() - +/*N*/ nIndent ) +/*N*/ * nPPT ); +/*N*/ nDocPixel = (nDocPixel * 9) / 10; // zur Sicherheit +/*N*/ if ( aSize.Width() > nDocPixel ) +/*N*/ bEditEngine = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bEditEngine) +/*N*/ { +/*N*/ // der Font wird bei !bEditEngine nicht jedesmal neu gesetzt +/*N*/ Font aOldFont = pDev->GetFont(); +/*N*/ +/*N*/ MapMode aHMMMode( MAP_100TH_MM, Point(), rZoomX, rZoomY ); +/*N*/ +/*N*/ // am Dokument speichern ? +/*N*/ ScFieldEditEngine* pEngine = pDocument->CreateFieldEditEngine(); +/*N*/ +/*N*/ pEngine->SetUpdateMode( FALSE ); +/*N*/ MapMode aOld = pDev->GetMapMode(); +/*N*/ pDev->SetMapMode( aHMMMode ); +/*N*/ pEngine->SetRefDevice( pDev ); +/*N*/ pEngine->SetForbiddenCharsTable( pDocument->GetForbiddenCharacters() ); +/*N*/ pEngine->SetAsianCompressionMode( pDocument->GetAsianCompression() ); +/*N*/ pEngine->SetKernAsianPunctuation( pDocument->GetAsianKerning() ); +/*N*/ SfxItemSet* pSet = new SfxItemSet( pEngine->GetEmptyItemSet() ); +/*N*/ pPattern->FillEditItemSet( pSet, pCondSet ); +/*N*/ +/*N*/ // no longer needed, are setted with the text (is faster) +/*N*/ // pEngine->SetDefaults( pSet ); +/*N*/ +/*N*/ +/*N*/ Size aPaper = Size( 1000000, 1000000 ); +/*N*/ if ( eOrient==SVX_ORIENTATION_STACKED && !bAsianVertical ) +/*?*/ aPaper.Width() = 1; +/*N*/ else if (bBreak) +/*N*/ { +/*N*/ double fWidthFactor = nPPTX; +/*N*/ BOOL bTextWysiwyg = ( pDev->GetOutDevType() == OUTDEV_PRINTER ); +/*N*/ if ( bTextWysiwyg ) +/*N*/ { +/*N*/ // #95593# if text is formatted for printer, don't use PixelToLogic, +/*N*/ // to ensure the exact same paper width (and same line breaks) as in +/*N*/ // ScEditUtil::GetEditArea, used for output. +/*N*/ +/*N*/ fWidthFactor = HMM_PER_TWIPS; +/*N*/ } +/*N*/ +/*N*/ // use original width for hidden columns: +/*N*/ long nDocWidth = (long) ( pDocument->GetOriginalWidth(nCol,nTab) * fWidthFactor ); +/*N*/ USHORT nColMerge = pMerge->GetColMerge(); +/*N*/ if (nColMerge > 1) +/*N*/ for (USHORT nColAdd=1; nColAdd<nColMerge; nColAdd++) +/*N*/ nDocWidth += (long) ( pDocument->GetColWidth(nCol+nColAdd,nTab) * fWidthFactor ); +/*N*/ nDocWidth -= (long) ( pMargin->GetLeftMargin() * fWidthFactor ) +/*N*/ + (long) ( pMargin->GetRightMargin() * fWidthFactor ) +/*N*/ + 1; // Ausgabebereich ist Breite-1 Pixel (wegen Gitterlinien) +/*N*/ if ( nIndent ) +/*N*/ nDocWidth -= (long) ( nIndent * fWidthFactor ); +/*N*/ +/*N*/ // space for AutoFilter button: 20 * nZoom/100 +/*N*/ if ( pFlag->HasAutoFilter() && !bTextWysiwyg ) +/*?*/ nDocWidth -= (rZoomX.GetNumerator()*20)/rZoomX.GetDenominator(); +/*N*/ +/*N*/ aPaper.Width() = nDocWidth; +/*N*/ +/*N*/ if ( !bTextWysiwyg ) +/*N*/ aPaper = pDev->PixelToLogic( aPaper, aHMMMode ); +/*N*/ } +/*N*/ pEngine->SetPaperSize(aPaper); +/*N*/ +/*N*/ if ( pCell->GetCellType() == CELLTYPE_EDIT ) +/*N*/ { +/*N*/ const EditTextObject* pData; +/*N*/ ((ScEditCell*)pCell)->GetData(pData); +/*N*/ pEngine->SetTextNewDefaults(*pData, pSet); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ Color* pColor; +/*N*/ SvNumberFormatter* pFormatter = pDocument->GetFormatTable(); +/*N*/ ULONG nFormat = pPattern->GetNumberFormat( pFormatter, pCondSet ); +/*N*/ String aString; +/*N*/ ScCellFormat::GetString( pCell, nFormat, aString, &pColor, +/*N*/ *pFormatter, +/*N*/ TRUE, rOptions.bFormula, ftCheck ); +/*N*/ if (aString.Len()) +/*N*/ pEngine->SetTextNewDefaults(aString, pSet); +/*N*/ else +/*?*/ pEngine->SetDefaults(pSet); +/*N*/ } +/*N*/ +/*N*/ BOOL bEngineVertical = pEngine->IsVertical(); +/*N*/ pEngine->SetVertical( bAsianVertical ); +/*N*/ pEngine->SetUpdateMode( TRUE ); +/*N*/ +/*N*/ BOOL bEdWidth = bWidth; +/*N*/ if ( eOrient != SVX_ORIENTATION_STANDARD && eOrient != SVX_ORIENTATION_STACKED ) +/*N*/ bEdWidth = !bEdWidth; +/*N*/ if ( nRotate ) +/*N*/ { +/*?*/ //! unterschiedliche Skalierung X/Y beruecksichtigen +/*?*/ +/*?*/ Size aSize( pEngine->CalcTextWidth(), pEngine->GetTextHeight() ); +/*?*/ double nRealOrient = nRotate * F_PI18000; // nRotate sind 1/100 Grad +/*?*/ double nCosAbs = fabs( cos( nRealOrient ) ); +/*?*/ double nSinAbs = fabs( sin( nRealOrient ) ); +/*?*/ long nHeight = (long)( aSize.Height() * nCosAbs + aSize.Width() * nSinAbs ); +/*?*/ long nWidth; +/*?*/ if ( eRotMode == SVX_ROTATE_MODE_STANDARD ) +/*?*/ nWidth = (long)( aSize.Width() * nCosAbs + aSize.Height() * nSinAbs ); +/*?*/ else if ( rOptions.bTotalSize ) +/*?*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ nWidth = (long) ( pDocument->GetColWidth( nCol,nTab ) * nPPT ); +/*?*/ } +/*?*/ else +/*?*/ nWidth = (long)( aSize.Height() / nSinAbs ); //! begrenzen? +/*?*/ aSize = Size( nWidth, nHeight ); +/*?*/ +/*?*/ Size aPixSize = pDev->LogicToPixel( aSize, aHMMMode ); +/*?*/ if ( bEdWidth ) +/*?*/ nValue = aPixSize.Width(); +/*?*/ else +/*?*/ { +/*?*/ nValue = aPixSize.Height(); +/*?*/ +/*?*/ if ( bBreak && !rOptions.bTotalSize ) +/*?*/ { +/*?*/ // #47744# limit size for line break +/*?*/ long nCmp = aOldFont.GetSize().Height() * SC_ROT_BREAK_FACTOR; +/*?*/ if ( nValue > nCmp ) +/*?*/ nValue = nCmp; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ else if ( bEdWidth ) +/*N*/ { +/*N*/ if (bBreak) +/*N*/ nValue = 0; +/*N*/ else +/*N*/ nValue = pDev->LogicToPixel(Size( pEngine->CalcTextWidth(), 0 ), +/*N*/ aHMMMode).Width(); +/*N*/ } +/*N*/ else // Hoehe +/*N*/ { +/*N*/ nValue = pDev->LogicToPixel(Size( 0, pEngine->GetTextHeight() ), +/*N*/ aHMMMode).Height(); +/*N*/ } +/*N*/ +/*N*/ if ( nValue && bAddMargin ) +/*N*/ { +/*N*/ if (bWidth) +/*N*/ { +/*N*/ nValue += (long) ( pMargin->GetLeftMargin() * nPPT ) + +/*N*/ (long) ( pMargin->GetRightMargin() * nPPT ); +/*N*/ if (nIndent) +/*?*/ nValue += (long) ( nIndent * nPPT ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nValue += (long) ( pMargin->GetTopMargin() * nPPT ) + +/*N*/ (long) ( pMargin->GetBottomMargin() * nPPT ); +/*N*/ +/*N*/ if ( bAsianVertical && pDev->GetOutDevType() != OUTDEV_PRINTER ) +/*N*/ { +/*N*/ // add 1pt extra (default margin value) for line breaks with SetVertical +/*N*/ nValue += (long) ( 20 * nPPT ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // EditEngine is cached and re-used, so the old vertical flag must be restored +/*N*/ pEngine->SetVertical( bEngineVertical ); +/*N*/ +/*N*/ pDocument->DisposeFieldEditEngine(pEngine); +/*N*/ +/*N*/ pDev->SetMapMode( aOld ); +/*N*/ pDev->SetFont( aOldFont ); +/*N*/ } +/*N*/ +/*N*/ if (bWidth) +/*N*/ { +/*N*/ // Platz fuer Autofilter-Button +/*N*/ // 20 * nZoom/100 +/*N*/ // bedingte Formatierung hier nicht interessant +/*N*/ +/*N*/ INT16 nFlags = ((const ScMergeFlagAttr&)pPattern->GetItem(ATTR_MERGE_FLAG)).GetValue(); +/*N*/ if (nFlags & SC_MF_AUTO) +/*?*/ nValue += (rZoomX.GetNumerator()*20)/rZoomX.GetDenominator(); +/*N*/ } +/*N*/ } +/*N*/ return nValue; +/*N*/ } + +/*N*/ long ScColumn::GetSimpleTextNeededSize( USHORT nIndex, OutputDevice* pDev, +/*N*/ BOOL bWidth ) +/*N*/ { +/*N*/ long nValue=0; +/*N*/ if ( nIndex < nCount ) +/*N*/ { +/*N*/ USHORT nRow = pItems[nIndex].nRow; +/*N*/ const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow ); +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ String aValStr; +/*N*/ Color* pColor; +/*N*/ SvNumberFormatter* pFormatter = pDocument->GetFormatTable(); +/*N*/ ULONG nFormat = pPattern->GetNumberFormat( pFormatter ); +/*N*/ ScCellFormat::GetString( pCell, nFormat, aValStr, &pColor, +/*N*/ *pFormatter, TRUE, FALSE, ftCheck ); +/*N*/ if ( aValStr.Len() ) +/*N*/ { +/*N*/ if ( bWidth ) +/*N*/ nValue = pDev->GetTextWidth( aValStr ); +/*N*/ else +/*?*/ nValue = pDev->GetTextHeight(); +/*N*/ } +/*N*/ } +/*N*/ return nValue; +/*N*/ } + +/*N*/ USHORT ScColumn::GetOptimalColWidth( OutputDevice* pDev, double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bFormula, USHORT nOldWidth, +/*N*/ const ScMarkData* pMarkData, +/*N*/ BOOL bSimpleTextImport ) +/*N*/ { +/*N*/ if (nCount == 0) +/*N*/ return nOldWidth; +/*N*/ +/*N*/ USHORT nWidth = (USHORT) (nOldWidth * nPPTX); +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ ScMarkedDataIter aDataIter(this, pMarkData, TRUE); +/*N*/ if ( bSimpleTextImport ) +/*N*/ { // alles eins bis auf NumberFormate +/*N*/ const ScPatternAttr* pPattern = GetPattern( 0 ); +/*N*/ Font aFont; +/*N*/ // font color doesn't matter here +/*N*/ pPattern->GetFont( aFont, SC_AUTOCOL_BLACK, pDev, &rZoomX, NULL ); +/*N*/ pDev->SetFont( aFont ); +/*N*/ const SvxMarginItem* pMargin = (const SvxMarginItem*) &pPattern->GetItem(ATTR_MARGIN); +/*N*/ long nMargin = (long) ( pMargin->GetLeftMargin() * nPPTX ) + +/*N*/ (long) ( pMargin->GetRightMargin() * nPPTX ); +/*N*/ +/*N*/ while (aDataIter.Next( nIndex )) +/*N*/ { +/*N*/ USHORT nThis = (USHORT) (GetSimpleTextNeededSize( nIndex, pDev, +/*N*/ TRUE ) + nMargin); +/*N*/ if (nThis) +/*N*/ { +/*N*/ if (nThis>nWidth || !bFound) +/*N*/ { +/*N*/ nWidth = nThis; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ ScNeededSizeOptions aOptions; +/*?*/ aOptions.bFormula = bFormula; +/*?*/ const ScPatternAttr* pOldPattern = NULL; +/*?*/ BYTE nOldScript = 0; +/*?*/ +/*?*/ while (aDataIter.Next( nIndex )) +/*?*/ { +/*?*/ USHORT nRow = pItems[nIndex].nRow; +/*?*/ +/*?*/ BYTE nScript = pDocument->GetScriptType( nCol, nRow, nTab, pItems[nIndex].pCell ); +/*?*/ if (nScript == 0) nScript = ScGlobal::GetDefaultScriptType(); +/*?*/ +/*?*/ const ScPatternAttr* pPattern = GetPattern( nRow ); +/*?*/ aOptions.pPattern = pPattern; +/*?*/ aOptions.bGetFont = (pPattern != pOldPattern || nScript != nOldScript); +/*?*/ USHORT nThis = (USHORT) GetNeededSize( nRow, pDev, nPPTX, nPPTY, +/*?*/ rZoomX, rZoomY, TRUE, aOptions ); +/*?*/ pOldPattern = pPattern; +/*?*/ if (nThis) +/*?*/ { +/*?*/ if (nThis>nWidth || !bFound) +/*?*/ { +/*?*/ nWidth = nThis; +/*?*/ bFound = TRUE; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ if (bFound) +/*N*/ { +/*N*/ nWidth += 2; +/*N*/ USHORT nTwips = (USHORT) (nWidth / nPPTX); +/*N*/ return nTwips; +/*N*/ } +/*N*/ else +/*N*/ return nOldWidth; +/*N*/ } + +/*N*/ USHORT lcl_GetAttribHeight( const ScPatternAttr& rPattern, USHORT nFontHeightId ) +/*N*/ { +/*N*/ USHORT nHeight = (USHORT) ((const SvxFontHeightItem&) rPattern.GetItem(nFontHeightId)).GetHeight(); +/*N*/ const SvxMarginItem* pMargin = (const SvxMarginItem*) &rPattern.GetItem(ATTR_MARGIN); +/*N*/ nHeight += nHeight / 5; +/*N*/ // gibt bei 10pt 240 +/*N*/ +/*N*/ if ( ((const SvxEmphasisMarkItem&)rPattern. +/*N*/ GetItem(ATTR_FONT_EMPHASISMARK)).GetEmphasisMark() != EMPHASISMARK_NONE ) +/*N*/ { +/*N*/ // add height for emphasis marks +/*N*/ //! font metrics should be used instead +/*N*/ nHeight += nHeight / 4; +/*N*/ } +/*N*/ +/*N*/ if ( nHeight + 240 > ScGlobal::nDefFontHeight ) +/*N*/ { +/*N*/ nHeight += ScGlobal::nDefFontHeight; +/*N*/ nHeight -= 240; +/*N*/ } +/*N*/ +/*N*/ // Standard-Hoehe: TextHeight + Raender - 23 +/*N*/ // -> 257 unter Windows +/*N*/ +/*N*/ if (nHeight > STD_ROWHEIGHT_DIFF) +/*N*/ nHeight -= STD_ROWHEIGHT_DIFF; +/*N*/ +/*N*/ nHeight += pMargin->GetTopMargin() + pMargin->GetBottomMargin(); +/*N*/ +/*N*/ return nHeight; +/*N*/ } + +// pHeight in Twips +// nMinHeight, nMinStart zur Optimierung: ab nRow >= nMinStart ist mindestens nMinHeight +// (wird nur bei bStdAllowed ausgewertet) + +/*N*/ void ScColumn::GetOptimalHeight( USHORT nStartRow, USHORT nEndRow, USHORT* pHeight, +/*N*/ OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bShrink, USHORT nMinHeight, USHORT nMinStart ) +/*N*/ { +/*N*/ ScAttrIterator aIter( pAttrArray, nStartRow, nEndRow ); +/*N*/ +/*N*/ USHORT nStart; +/*N*/ USHORT nEnd; +/*N*/ USHORT nEditPos = 0; +/*N*/ USHORT nNextEnd = 0; +/*N*/ +/*N*/ // bei bedingter Formatierung werden immer die einzelnen Zellen angesehen +/*N*/ +/*N*/ const ScPatternAttr* pPattern = aIter.Next(nStart,nEnd); +/*N*/ while ( pPattern ) +/*N*/ { +/*N*/ const ScMergeAttr* pMerge = (const ScMergeAttr*)&pPattern->GetItem(ATTR_MERGE); +/*N*/ const ScMergeFlagAttr* pFlag = (const ScMergeFlagAttr*)&pPattern->GetItem(ATTR_MERGE_FLAG); +/*N*/ if ( pMerge->GetRowMerge() > 1 || pFlag->IsOverlapped() ) +/*N*/ { +/*N*/ // nix - vertikal bei der zusammengefassten und den ueberdeckten, +/*N*/ // horizontal nur bei den ueberdeckten (unsichtbaren) - +/*N*/ // eine nur horizontal zusammengefasste wird aber beruecksichtigt +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nRow; +/*N*/ BOOL bStdAllowed = ((const SvxOrientationItem&) pPattern->GetItem(ATTR_ORIENTATION)). +/*N*/ GetValue() == (USHORT) SVX_ORIENTATION_STANDARD; +/*N*/ BOOL bStdOnly = FALSE; +/*N*/ if (bStdAllowed) +/*N*/ { +/*N*/ BOOL bBreak = ((SfxBoolItem&)pPattern->GetItem(ATTR_LINEBREAK)).GetValue() || +/*N*/ ((SvxCellHorJustify)((const SvxHorJustifyItem&)pPattern-> +/*N*/ GetItem( ATTR_HOR_JUSTIFY )).GetValue() == +/*N*/ SVX_HOR_JUSTIFY_BLOCK); +/*N*/ bStdOnly = !bBreak; +/*N*/ +/*N*/ // bedingte Formatierung: Zellen durchgehen +/*N*/ if ( bStdOnly && ((const SfxUInt32Item&)pPattern-> +/*N*/ GetItem(ATTR_CONDITIONAL)).GetValue() ) +/*N*/ bStdOnly = FALSE; +/*N*/ +/*N*/ // gedrehter Text: Zellen durchgehen +/*N*/ if ( bStdOnly && ((const SfxInt32Item&)pPattern-> +/*N*/ GetItem(ATTR_ROTATE_VALUE)).GetValue() ) +/*N*/ bStdOnly = FALSE; +/*N*/ } +/*N*/ +/*N*/ if (bStdOnly) +/*N*/ if (HasEditCells(nStart,nEnd,nEditPos)) // includes mixed script types +/*N*/ { +/*N*/ if (nEditPos == nStart) +/*N*/ { +/*N*/ bStdOnly = FALSE; +/*N*/ if (nEnd > nEditPos) +/*N*/ nNextEnd = nEnd; +/*N*/ nEnd = nEditPos; // einzeln ausrechnen +/*N*/ bStdAllowed = FALSE; // wird auf jeden Fall per Zelle berechnet +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nNextEnd = nEnd; +/*N*/ nEnd = nEditPos - 1; // Standard - Teil +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bStdAllowed) +/*N*/ { +/*N*/ USHORT nLatHeight = 0; +/*N*/ USHORT nCjkHeight = 0; +/*N*/ USHORT nCtlHeight = 0; +/*N*/ USHORT nDefHeight; +/*N*/ BYTE nDefScript = ScGlobal::GetDefaultScriptType(); +/*N*/ if ( nDefScript == SCRIPTTYPE_ASIAN ) +/*N*/ nDefHeight = nCjkHeight = lcl_GetAttribHeight( *pPattern, ATTR_CJK_FONT_HEIGHT ); +/*N*/ else if ( nDefScript == SCRIPTTYPE_COMPLEX ) +/*?*/ nDefHeight = nCtlHeight = lcl_GetAttribHeight( *pPattern, ATTR_CTL_FONT_HEIGHT ); +/*N*/ else +/*?*/ nDefHeight = nLatHeight = lcl_GetAttribHeight( *pPattern, ATTR_FONT_HEIGHT ); +/*N*/ +/*N*/ // if everything below is already larger, the loop doesn't have to +/*N*/ // be run again +/*N*/ USHORT nStdEnd = nEnd; +/*N*/ if ( nDefHeight <= nMinHeight && nStdEnd >= nMinStart ) +/*N*/ nStdEnd = nMinStart ? nMinStart-1 : 0; +/*N*/ +/*N*/ for (nRow=nStart; nRow<=nStdEnd; nRow++) +/*N*/ if (nDefHeight > pHeight[nRow-nStartRow]) +/*N*/ pHeight[nRow-nStartRow] = nDefHeight; +/*N*/ +/*N*/ if ( bStdOnly ) +/*N*/ { +/*N*/ // if cells are not handled individually below, +/*N*/ // check for cells with different script type +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ Search(nStart,nIndex); +/*N*/ while ( nIndex < nCount && (nRow=pItems[nIndex].nRow) <= nEnd ) +/*N*/ { +/*N*/ BYTE nScript = pDocument->GetScriptType( nCol, nRow, nTab, pItems[nIndex].pCell ); +/*N*/ if ( nScript != nDefScript ) +/*N*/ { +/*N*/ if ( nScript == SCRIPTTYPE_ASIAN ) +/*N*/ { +/*?*/ if ( nCjkHeight == 0 ) +/*?*/ nCjkHeight = lcl_GetAttribHeight( *pPattern, ATTR_CJK_FONT_HEIGHT ); +/*?*/ if (nCjkHeight > pHeight[nRow-nStartRow]) +/*?*/ pHeight[nRow-nStartRow] = nCjkHeight; +/*N*/ } +/*N*/ else if ( nScript == SCRIPTTYPE_COMPLEX ) +/*N*/ { +/*?*/ if ( nCtlHeight == 0 ) +/*?*/ nCtlHeight = lcl_GetAttribHeight( *pPattern, ATTR_CTL_FONT_HEIGHT ); +/*?*/ if (nCtlHeight > pHeight[nRow-nStartRow]) +/*?*/ pHeight[nRow-nStartRow] = nCtlHeight; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( nLatHeight == 0 ) +/*N*/ nLatHeight = lcl_GetAttribHeight( *pPattern, ATTR_FONT_HEIGHT ); +/*N*/ if (nLatHeight > pHeight[nRow-nStartRow]) +/*N*/ pHeight[nRow-nStartRow] = nLatHeight; +/*N*/ } +/*N*/ } +/*N*/ ++nIndex; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!bStdOnly) // belegte Zellen suchen +/*N*/ { +/*N*/ ScNeededSizeOptions aOptions; +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ Search(nStart,nIndex); +/*N*/ while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEnd) : FALSE ) +/*N*/ { +/*N*/ // Zellhoehe nur berechnen, wenn sie spaeter auch gebraucht wird (#37928#) +/*N*/ +/*N*/ if ( bShrink || !(pDocument->GetRowFlags(nRow, nTab) & CR_MANUALSIZE) ) +/*N*/ { +/*N*/ aOptions.pPattern = pPattern; +/*N*/ USHORT nHeight = (USHORT) +/*N*/ ( GetNeededSize( nRow, pDev, nPPTX, nPPTY, +/*N*/ rZoomX, rZoomY, FALSE, aOptions ) / nPPTY ); +/*N*/ if (nHeight > pHeight[nRow-nStartRow]) +/*N*/ pHeight[nRow-nStartRow] = nHeight; +/*N*/ } +/*N*/ ++nIndex; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (nNextEnd) +/*N*/ { +/*N*/ nStart = nEnd + 1; +/*N*/ nEnd = nNextEnd; +/*N*/ nNextEnd = 0; +/*N*/ } +/*N*/ else +/*N*/ pPattern = aIter.Next(nStart,nEnd); +/*N*/ } +/*N*/ } + + +// ========================================================================================= + + + +// ========================================================================================= + +/*N*/ BOOL ScColumn::TestTabRefAbs(USHORT nTable) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA ) +/*?*/ if (((ScFormulaCell*)pItems[i].pCell)->TestTabRefAbs(nTable)) +/*?*/ bRet = TRUE; +/*N*/ return bRet; +/*N*/ } + +// ========================================================================================= + +/*N*/ ScColumnIterator::ScColumnIterator( const ScColumn* pCol, USHORT nStart, USHORT nEnd ) : +/*N*/ pColumn( pCol ), +/*N*/ nTop( nStart ), +/*N*/ nBottom( nEnd ) +/*N*/ { +/*N*/ pColumn->Search( nTop, nPos ); +/*N*/ } + +/*N*/ ScColumnIterator::~ScColumnIterator() +/*N*/ { +/*N*/ } + +/*N*/ BOOL ScColumnIterator::Next( USHORT& rRow, ScBaseCell*& rpCell ) +/*N*/ { +/*N*/ if ( nPos < pColumn->nCount ) +/*N*/ { +/*N*/ rRow = pColumn->pItems[nPos].nRow; +/*N*/ if ( rRow <= nBottom ) +/*N*/ { +/*N*/ rpCell = pColumn->pItems[nPos].pCell; +/*N*/ ++nPos; +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ rRow = 0; +/*N*/ rpCell = NULL; +/*N*/ return FALSE; +/*N*/ } + +// ----------------------------------------------------------------------------------------- + +/*N*/ ScMarkedDataIter::ScMarkedDataIter( const ScColumn* pCol, const ScMarkData* pMarkData, +/*N*/ BOOL bAllIfNone ) : +/*N*/ pColumn( pCol ), +/*N*/ pMarkIter( NULL ), +/*N*/ bNext( TRUE ), +/*N*/ bAll( bAllIfNone ) +/*N*/ { +/*N*/ if (pMarkData && pMarkData->IsMultiMarked()) +/*N*/ pMarkIter = new ScMarkArrayIter( pMarkData->GetArray() + pCol->GetCol() ); +/*N*/ } + +/*N*/ ScMarkedDataIter::~ScMarkedDataIter() +/*N*/ { +/*N*/ delete pMarkIter; +/*N*/ } + +/*N*/ BOOL ScMarkedDataIter::Next( USHORT& rIndex ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ do +/*N*/ { +/*N*/ if (bNext) +/*N*/ { +/*N*/ if (!pMarkIter || !pMarkIter->Next( nTop, nBottom )) +/*N*/ { +/*N*/ if (bAll) // ganze Spalte +/*N*/ { +/*N*/ nTop = 0; +/*N*/ nBottom = MAXROW; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } +/*N*/ pColumn->Search( nTop, nPos ); +/*N*/ bNext = FALSE; +/*N*/ bAll = FALSE; // nur beim ersten Versuch +/*N*/ } +/*N*/ +/*N*/ if ( nPos >= pColumn->nCount ) +/*N*/ return FALSE; +/*N*/ +/*N*/ if ( pColumn->pItems[nPos].nRow <= nBottom ) +/*N*/ bFound = TRUE; +/*N*/ else +/*N*/ bNext = TRUE; +/*N*/ } +/*N*/ while (!bFound); +/*N*/ +/*N*/ rIndex = nPos++; +/*N*/ return TRUE; +/*N*/ } + + +//------------ + +/*N*/ BOOL ScColumn::IsEmptyData() const +/*N*/ { +/*N*/ return (nCount == 0); +/*N*/ } + +/*N*/ BOOL ScColumn::IsEmptyVisData(BOOL bNotes) const +/*N*/ { +/*N*/ if (!pItems || nCount == 0) +/*N*/ return TRUE; +/*N*/ else +/*N*/ { +/*N*/ BOOL bVisData = FALSE; +/*N*/ USHORT i; +/*N*/ for (i=0; i<nCount && !bVisData; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->GetNotePtr()) ) +/*N*/ bVisData = TRUE; +/*N*/ } +/*N*/ return !bVisData; +/*N*/ } +/*N*/ } + + +/*N*/ USHORT ScColumn::GetLastVisDataPos(BOOL bNotes) const +/*N*/ { +/*N*/ USHORT nRet = 0; +/*N*/ if (pItems) +/*N*/ { +/*N*/ USHORT i; +/*N*/ BOOL bFound = FALSE; +/*N*/ for (i=nCount; i>0 && !bFound; ) +/*N*/ { +/*N*/ --i; +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->GetNotePtr()) ) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ nRet = pItems[i].nRow; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return nRet; +/*N*/ } + +/*N*/ USHORT ScColumn::GetFirstVisDataPos(BOOL bNotes) const +/*N*/ { +/*N*/ USHORT nRet = 0; +/*N*/ if (pItems) +/*N*/ { +/*N*/ USHORT i; +/*N*/ BOOL bFound = FALSE; +/*N*/ for (i=0; i<nCount && !bFound; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->GetNotePtr()) ) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ nRet = pItems[i].nRow; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return nRet; +/*N*/ } + + +/*N*/ BOOL ScColumn::IsEmptyAttr() const +/*N*/ { +/*N*/ if (pAttrArray) +/*N*/ return pAttrArray->IsEmpty(); +/*N*/ else +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScColumn::IsEmpty() const +/*N*/ { +/*N*/ return (IsEmptyData() && IsEmptyAttr()); +/*N*/ } + + + + + + + + +/*N*/ BOOL ScColumn::HasDataAt(USHORT nRow) const +/*N*/ { +/* USHORT nIndex; + return Search( nRow, nIndex ); +*/ +/*N*/ // immer nur sichtbare interessant ? +/*N*/ //! dann HasVisibleDataAt raus +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ if (CellVisible(pItems[nIndex].pCell)) +/*N*/ return TRUE; +/*N*/ +/*N*/ return FALSE; +/*N*/ +/*N*/ } + + + + +/*N*/ BOOL ScColumn::IsAllAttrEqual( const ScColumn& rCol, USHORT nStartRow, USHORT nEndRow ) const +/*N*/ { +/*N*/ if (pAttrArray && rCol.pAttrArray) +/*N*/ return pAttrArray->IsAllEqual( *rCol.pAttrArray, nStartRow, nEndRow ); +/*N*/ else +/*N*/ return !pAttrArray && !rCol.pAttrArray; +/*N*/ } + +/*N*/ BOOL ScColumn::IsVisibleAttrEqual( const ScColumn& rCol, USHORT nStartRow, USHORT nEndRow ) const +/*N*/ { +/*N*/ if (pAttrArray && rCol.pAttrArray) +/*N*/ return pAttrArray->IsVisibleEqual( *rCol.pAttrArray, nStartRow, nEndRow ); +/*N*/ else +/*N*/ return !pAttrArray && !rCol.pAttrArray; +/*N*/ } + +/*N*/ BOOL ScColumn::HasVisibleAttr( USHORT& rFirstRow, USHORT& rLastRow, BOOL bSkipFirst ) const +/*N*/ { +/*N*/ if (pAttrArray) +/*N*/ return pAttrArray->HasVisibleAttr(rFirstRow,rLastRow,bSkipFirst); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + + +/*N*/ void ScColumn::StartListening( SfxListener& rLst, USHORT nRow ) +/*N*/ { +/*N*/ ScBroadcasterList* pBC = NULL; +/*N*/ ScBaseCell* pCell; +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow,nIndex)) +/*N*/ { +/*N*/ pCell = pItems[nIndex].pCell; +/*N*/ pBC = pCell->GetBroadcaster(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pCell = new ScNoteCell; +/*N*/ Insert(nRow, pCell); +/*N*/ } +/*N*/ +/*N*/ if (!pBC) +/*N*/ { +/*N*/ pBC = new ScBroadcasterList; +/*N*/ pCell->SetBroadcaster(pBC); +/*N*/ } +/*N*/ // rLst.StartListening(*pBC,TRUE); +/*N*/ pBC->StartBroadcasting( rLst, TRUE ); +/*N*/ } + +/*N*/ void ScColumn::MoveListeners( ScBroadcasterList& rSource, USHORT nDestRow ) +/*N*/ { +/*N*/ ScBroadcasterList* pBC = NULL; +/*N*/ ScBaseCell* pCell; +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ if (Search(nDestRow,nIndex)) +/*N*/ { +/*N*/ pCell = pItems[nIndex].pCell; +/*N*/ pBC = pCell->GetBroadcaster(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pCell = new ScNoteCell; +/*N*/ Insert(nDestRow, pCell); +/*N*/ } +/*N*/ +/*N*/ if (!pBC) +/*N*/ { +/*N*/ pBC = new ScBroadcasterList; +/*N*/ pCell->SetBroadcaster(pBC); +/*N*/ } +/*N*/ +/*N*/ rSource.MoveListenersTo( *pBC ); +/*N*/ } + +/*N*/ void ScColumn::EndListening( SfxListener& rLst, USHORT nRow ) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow,nIndex)) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ ScBroadcasterList* pBC = pCell->GetBroadcaster(); +/*N*/ if (pBC) +/*N*/ { +/*N*/ // rLst.EndListening(*pBC); +/*N*/ pBC->EndBroadcasting(rLst); +/*N*/ +/*N*/ if (!pBC->HasListeners()) +/*N*/ { +/*N*/ if (pCell->GetCellType() == CELLTYPE_NOTE && !pCell->GetNotePtr()) +/*N*/ DeleteAtIndex(nIndex); +/*N*/ else +/*N*/ pCell->SetBroadcaster(NULL); +/*N*/ } +/*N*/ } +/*N*/ // else +/*N*/ // DBG_ERROR("ScColumn::EndListening - kein Broadcaster"); +/*N*/ } +/*N*/ // else +/*N*/ // DBG_ERROR("ScColumn::EndListening - keine Zelle"); +/*N*/ } + + +/*N*/ void ScColumn::CompileDBFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*) pCell)->CompileDBFormula( bCreateFormulaString ); +/*N*/ } +/*N*/ } + +/*N*/ void ScColumn::CompileNameFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*) pCell)->CompileNameFormula( bCreateFormulaString ); +/*N*/ } +/*N*/ } + +/*N*/ void ScColumn::CompileColRowNameFormula() +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*) pCell)->CompileColRowNameFormula(); +/*N*/ } +/*N*/ } + +/*N*/ void lcl_UpdateSubTotal( ScFunctionData& rData, ScBaseCell* pCell ) +/*N*/ { +/*N*/ double nValue; +/*N*/ BOOL bVal = FALSE; +/*N*/ BOOL bCell = TRUE; +/*N*/ switch (pCell->GetCellType()) +/*N*/ { +/*?*/ case CELLTYPE_VALUE: +/*?*/ nValue = ((ScValueCell*)pCell)->GetValue(); +/*?*/ bVal = TRUE; +/*?*/ break; +/*?*/ case CELLTYPE_FORMULA: +/*?*/ { +/*?*/ if ( rData.eFunc != SUBTOTAL_FUNC_CNT2 ) // da interessiert's nicht +/*?*/ { +/*?*/ ScFormulaCell* pFC = (ScFormulaCell*)pCell; +/*?*/ if ( pFC->GetErrCode() ) +/*?*/ { +/*?*/ if ( rData.eFunc != SUBTOTAL_FUNC_CNT ) // fuer Anzahl einfach weglassen +/*?*/ rData.bError = TRUE; +/*?*/ } +/*?*/ else if (pFC->IsValue()) +/*?*/ { +/*?*/ nValue = pFC->GetValue(); +/*?*/ bVal = TRUE; +/*?*/ } +/*?*/ // sonst Text +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case CELLTYPE_NOTE: +/*?*/ bCell = FALSE; +/*?*/ break; +/*?*/ // bei Strings nichts +/*N*/ } +/*N*/ +/*N*/ if (!rData.bError) +/*N*/ { +/*N*/ switch (rData.eFunc) +/*N*/ { +/*?*/ case SUBTOTAL_FUNC_SUM: +/*?*/ case SUBTOTAL_FUNC_AVE: +/*?*/ if (bVal) +/*?*/ { +/*?*/ ++rData.nCount; +/*?*/ if (!SubTotal::SafePlus( rData.nVal, nValue )) +/*?*/ rData.bError = TRUE; +/*?*/ } +/*?*/ break; +/*?*/ case SUBTOTAL_FUNC_CNT: // nur Werte +/*?*/ if (bVal) +/*?*/ ++rData.nCount; +/*?*/ break; +/*N*/ case SUBTOTAL_FUNC_CNT2: // alle +/*N*/ if (bCell) +/*N*/ ++rData.nCount; +/*N*/ break; +/*?*/ case SUBTOTAL_FUNC_MAX: +/*?*/ if (bVal) +/*?*/ if (++rData.nCount == 1 || nValue > rData.nVal ) +/*?*/ rData.nVal = nValue; +/*?*/ break; +/*?*/ case SUBTOTAL_FUNC_MIN: +/*?*/ if (bVal) +/*?*/ if (++rData.nCount == 1 || nValue < rData.nVal ) +/*?*/ rData.nVal = nValue; +/*?*/ break; +/*N*/ } +/*N*/ } +/*N*/ } + +// Mehrfachselektion: +/*N*/ void ScColumn::UpdateSelectionFunction( const ScMarkData& rMark, +/*N*/ ScFunctionData& rData, const BYTE* pRowFlags, +/*N*/ BOOL bDoExclude, USHORT nExStartRow, USHORT nExEndRow ) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ ScMarkedDataIter aDataIter(this, &rMark, FALSE); +/*N*/ while (aDataIter.Next( nIndex )) +/*N*/ { +/*N*/ USHORT nRow = pItems[nIndex].nRow; +/*N*/ if ( !pRowFlags || !( pRowFlags[nRow] & CR_HIDDEN ) ) +/*N*/ if ( !bDoExclude || nRow < nExStartRow || nRow > nExEndRow ) +/*N*/ lcl_UpdateSubTotal( rData, pItems[nIndex].pCell ); +/*N*/ } +/*N*/ } + +// bei bNoMarked die Mehrfachselektion weglassen +/*N*/ void ScColumn::UpdateAreaFunction( ScFunctionData& rData, BYTE* pRowFlags, +/*N*/ USHORT nStartRow, USHORT nEndRow ) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ Search( nStartRow, nIndex ); +/*N*/ while ( nIndex<nCount && pItems[nIndex].nRow<=nEndRow ) +/*N*/ { +/*N*/ USHORT nRow = pItems[nIndex].nRow; +/*N*/ if ( !pRowFlags || !( pRowFlags[nRow] & CR_HIDDEN ) ) +/*N*/ lcl_UpdateSubTotal( rData, pItems[nIndex].pCell ); +/*N*/ ++nIndex; +/*N*/ } +/*N*/ } + +/*N*/ long ScColumn::GetWeightedCount() const +/*N*/ { +/*N*/ long nTotal = 0; +/*N*/ +/*N*/ // Notizen werden nicht gezaehlt +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ switch ( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ case CELLTYPE_STRING: +/*N*/ ++nTotal; +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ nTotal += 5 + ((ScFormulaCell*)pCell)->GetCode()->GetCodeLen(); +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ nTotal += 50; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return nTotal; +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_column3.cxx b/binfilter/bf_sc/source/core/data/sc_column3.cxx new file mode 100644 index 000000000000..f84eba85b1b0 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_column3.cxx @@ -0,0 +1,1060 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <bf_sfx2/objsh.hxx> +#include <bf_svtools/zforlist.hxx> + +#include "scitems.hxx" +#include "cell.hxx" +#include "document.hxx" +#include "attarray.hxx" +#include "cellform.hxx" +#include "detfunc.hxx" // fuer Notizen bei DeleteRange +namespace binfilter { + +// Err527 Workaround +extern const ScFormulaCell* pLastFormulaTreeTop; // in cellform.cxx + +// STATIC DATA ----------------------------------------------------------- + +/*N*/ BOOL ScColumn::bDoubleAlloc = FALSE; // fuer Import: Groesse beim Allozieren verdoppeln +/*N*/ +/*N*/ +/*N*/ void ScColumn::Insert( USHORT nRow, ScBaseCell* pNewCell ) +/*N*/ { +/*N*/ BOOL bIsAppended = FALSE; +/*N*/ if (pItems && nCount) +/*N*/ { +/*N*/ if (pItems[nCount-1].nRow < nRow) +/*N*/ { +/*N*/ Append(nRow, pNewCell ); +/*N*/ bIsAppended = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if ( !bIsAppended ) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ { +/*N*/ ScBaseCell* pOldCell = pItems[nIndex].pCell; +/*N*/ ScBroadcasterList* pBC = pOldCell->GetBroadcaster(); +/*N*/ if (pBC && !pNewCell->GetBroadcaster()) +/*N*/ { +/*N*/ pNewCell->SetBroadcaster( pBC ); +/*N*/ pOldCell->ForgetBroadcaster(); +/*N*/ } +/*N*/ if (pOldCell->GetNotePtr() && !pNewCell->GetNotePtr()) +/*?*/ pNewCell->SetNote( *pOldCell->GetNotePtr() ); +/*N*/ if ( pOldCell->GetCellType() == CELLTYPE_FORMULA && !pDocument->IsClipOrUndo() ) +/*N*/ { +/*?*/ pOldCell->EndListeningTo( pDocument ); +/*?*/ // falls in EndListening NoteCell in gleicher Col zerstoert +/*?*/ if ( nIndex >= nCount || pItems[nIndex].nRow != nRow ) +/*?*/ Search(nRow, nIndex); +/*N*/ } +/*N*/ pOldCell->Delete(); +/*N*/ pItems[nIndex].pCell = pNewCell; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (nCount + 1 > nLimit) +/*N*/ { +/*N*/ if (bDoubleAlloc) +/*N*/ { +/*N*/ if (nLimit < COLUMN_DELTA) +/*N*/ nLimit = COLUMN_DELTA; +/*N*/ else +/*N*/ { +/*N*/ nLimit *= 2; +/*N*/ if ( nLimit > MAXROW+1 ) +/*N*/ nLimit = MAXROW+1; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nLimit += COLUMN_DELTA; +/*N*/ +/*N*/ ColEntry* pNewItems = new ColEntry[nLimit]; +/*N*/ if (pItems) +/*N*/ { +/*N*/ memmove( pNewItems, pItems, nCount * sizeof(ColEntry) ); +/*N*/ delete[] pItems; +/*N*/ } +/*N*/ pItems = pNewItems; +/*N*/ } +/*N*/ memmove( &pItems[nIndex + 1], &pItems[nIndex], (nCount - nIndex) * sizeof(ColEntry) ); +/*N*/ pItems[nIndex].pCell = pNewCell; +/*N*/ pItems[nIndex].nRow = nRow; +/*N*/ ++nCount; +/*N*/ } +/*N*/ } +/*N*/ // Bei aus Clipboard sind hier noch falsche (alte) Referenzen! +/*N*/ // Werden in CopyBlockFromClip per UpdateReference umgesetzt, +/*N*/ // danach StartListeningFromClip und BroadcastFromClip gerufen. +/*N*/ // Wird ins Clipboard/UndoDoc gestellt, wird kein Broadcast gebraucht. +/*N*/ // Nach Import wird CalcAfterLoad gerufen, dort Listening. +/*N*/ if ( !(pDocument->IsClipOrUndo() || pDocument->IsInsertingFromOtherDoc()) ) +/*N*/ { +/*N*/ pNewCell->StartListeningTo( pDocument ); +/*N*/ CellType eCellType = pNewCell->GetCellType(); +/*N*/ // Notizzelle entsteht beim Laden nur durch StartListeningCell, +/*N*/ // ausloesende Formelzelle muss sowieso dirty sein. +/*N*/ if ( !(pDocument->IsCalcingAfterLoad() && eCellType == CELLTYPE_NOTE) ) +/*N*/ { +/*N*/ if ( eCellType == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pNewCell)->SetDirty(); +/*N*/ else +/*N*/ pDocument->Broadcast( ScHint( SC_HINT_DATACHANGED, +/*N*/ ScAddress( nCol, nRow, nTab ), pNewCell ) ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::Insert( USHORT nRow, ULONG nNumberFormat, ScBaseCell* pCell ) +/*N*/ { +/*N*/ Insert(nRow, pCell); +/*N*/ short eOldType = pDocument->GetFormatTable()-> +/*N*/ GetType( (ULONG) +/*N*/ ((SfxUInt32Item*)GetAttr( nRow, ATTR_VALUE_FORMAT ))-> +/*N*/ GetValue() ); +/*N*/ short eNewType = pDocument->GetFormatTable()->GetType(nNumberFormat); +/*N*/ if (!pDocument->GetFormatTable()->IsCompatible(eOldType, eNewType)) +/*N*/ ApplyAttr( nRow, SfxUInt32Item( ATTR_VALUE_FORMAT, (UINT32) nNumberFormat) ); +/*N*/ } + + +/*N*/ void ScColumn::Append( USHORT nRow, ScBaseCell* pCell ) +/*N*/ { +/*N*/ if (nCount + 1 > nLimit) +/*N*/ { +/*N*/ if (bDoubleAlloc) +/*N*/ { +/*N*/ if (nLimit < COLUMN_DELTA) +/*N*/ nLimit = COLUMN_DELTA; +/*N*/ else +/*N*/ { +/*N*/ nLimit *= 2; +/*N*/ if ( nLimit > MAXROW+1 ) +/*N*/ nLimit = MAXROW+1; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nLimit += COLUMN_DELTA; +/*N*/ +/*N*/ ColEntry* pNewItems = new ColEntry[nLimit]; +/*N*/ if (pItems) +/*N*/ { +/*N*/ memmove( pNewItems, pItems, nCount * sizeof(ColEntry) ); +/*N*/ delete[] pItems; +/*N*/ } +/*N*/ pItems = pNewItems; +/*N*/ } +/*N*/ pItems[nCount].pCell = pCell; +/*N*/ pItems[nCount].nRow = nRow; +/*N*/ ++nCount; +/*N*/ } + + +/*N*/ void ScColumn::DeleteAtIndex( USHORT nIndex ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ ScNoteCell* pNoteCell = new ScNoteCell; +/*N*/ pItems[nIndex].pCell = pNoteCell; // Dummy fuer Interpret +/*N*/ pDocument->Broadcast( ScHint( SC_HINT_DYING, +/*N*/ ScAddress( nCol, pItems[nIndex].nRow, nTab ), pCell ) ); +/*N*/ delete pNoteCell; +/*N*/ --nCount; +/*N*/ memmove( &pItems[nIndex], &pItems[nIndex + 1], (nCount - nIndex) * sizeof(ColEntry) ); +/*N*/ pItems[nCount].nRow = 0; +/*N*/ pItems[nCount].pCell = NULL; +/*N*/ pCell->EndListeningTo( pDocument ); +/*N*/ pCell->Delete(); +/*N*/ } + + +/*N*/ void ScColumn::FreeAll() +/*N*/ { +/*N*/ if (pItems) +/*N*/ { +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ pItems[i].pCell->Delete(); +/*N*/ delete[] pItems; +/*N*/ pItems = NULL; +/*N*/ } +/*N*/ nCount = 0; +/*N*/ nLimit = 0; +/*N*/ } + + +/*N*/ void ScColumn::DeleteRow( USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ pAttrArray->DeleteRow( nStartRow, nSize ); +/*N*/ +/*N*/ if ( !pItems || !nCount ) +/*N*/ return ; +/*N*/ +/*N*/ USHORT nFirstIndex; +/*N*/ Search( nStartRow, nFirstIndex ); +/*N*/ if ( nFirstIndex >= nCount ) +/*N*/ return ; +/*N*/ +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ +/*N*/ BOOL bFound=FALSE; +/*N*/ USHORT nEndRow = nStartRow + nSize - 1; +/*N*/ USHORT nStartIndex; +/*N*/ USHORT nEndIndex; +/*N*/ USHORT i; +/*N*/ +/*N*/ for ( i = nFirstIndex; i < nCount && pItems[i].nRow <= nEndRow; i++ ) +/*N*/ { +/*N*/ if (!bFound) +/*N*/ { +/*N*/ nStartIndex = i; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ nEndIndex = i; +/*N*/ +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ ScBroadcasterList* pBC = pCell->GetBroadcaster(); +/*N*/ if (pBC) +/*N*/ { +/*N*/ // gibt jetzt invalid reference, kein Aufruecken der direkten Referenzen +/*N*/ // MoveListeners( *pBC, nRow+nSize ); +/*N*/ pCell->SetBroadcaster(NULL); +/*N*/ // in DeleteRange werden leere Broadcaster geloescht +/*N*/ } +/*N*/ } +/*N*/ if (bFound) +/*N*/ { +/*N*/ DeleteRange( nStartIndex, nEndIndex, IDF_CONTENTS ); +/*N*/ Search( nStartRow, i ); +/*N*/ if ( i >= nCount ) +/*N*/ { +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ return ; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ i = nFirstIndex; +/*N*/ +/*N*/ ScAddress aAdr( nCol, 0, nTab ); +/*N*/ ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL ); // only areas (ScBaseCell* == NULL) +/*N*/ ScAddress& rAddress = aHint.GetAddress(); +/*N*/ // for sparse occupation use single broadcasts, not ranges +/*N*/ BOOL bSingleBroadcasts = (((pItems[nCount-1].nRow - pItems[i].nRow) / +/*N*/ (nCount - i)) > 1); +/*N*/ if ( bSingleBroadcasts ) +/*N*/ { +/*N*/ USHORT nLastBroadcast = MAXROW+1; +/*N*/ for ( ; i < nCount; i++ ) +/*N*/ { +/*N*/ USHORT nOldRow = pItems[i].nRow; +/*N*/ // #43940# Aenderung Quelle broadcasten +/*N*/ rAddress.SetRow( nOldRow ); +/*N*/ pDocument->AreaBroadcast( aHint ); +/*N*/ USHORT nNewRow = (pItems[i].nRow -= nSize); +/*N*/ // #43940# Aenderung Ziel broadcasten +/*N*/ if ( nLastBroadcast != nNewRow ) +/*N*/ { // direkt aufeinanderfolgende nicht doppelt broadcasten +/*N*/ rAddress.SetRow( nNewRow ); +/*N*/ pDocument->AreaBroadcast( aHint ); +/*N*/ } +/*N*/ nLastBroadcast = nOldRow; +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rAddress.SetRow( pItems[i].nRow ); +/*N*/ ScRange aRange( rAddress ); +/*N*/ aRange.aEnd.SetRow( pItems[nCount-1].nRow ); +/*N*/ for ( ; i < nCount; i++ ) +/*N*/ { +/*N*/ USHORT nNewRow = (pItems[i].nRow -= nSize); +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow ); +/*N*/ } +/*N*/ pDocument->AreaBroadcastInRange( aRange, aHint ); +/*N*/ } +/*N*/ +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScColumn::DeleteRange( USHORT nStartIndex, USHORT nEndIndex, USHORT nDelFlag ) +/*N*/ { +/*N*/ USHORT nDelCount = 0; +/*N*/ ScBaseCell** ppDelCells = new ScBaseCell*[nEndIndex-nStartIndex+1]; +/*N*/ +/*N*/ BOOL bSimple = ((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS); +/*N*/ USHORT i; +/*N*/ +/*N*/ // Notiz-Zeichenobjekte +/*N*/ if (nDelFlag & IDF_NOTE) +/*N*/ { +/*N*/ for ( i = nStartIndex; i <= nEndIndex; i++ ) +/*N*/ { +/*N*/ const ScPostIt* pNote = pItems[i].pCell->GetNotePtr(); +/*N*/ if ( pNote && pNote->IsShown() ) +/*N*/ { +/*?*/ ScDetectiveFunc( pDocument, nTab ).HideComment( nCol, pItems[i].nRow ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Broadcaster stehenlassen +/*N*/ if (bSimple) +/*N*/ { +/*N*/ for (i = nStartIndex; i <= nEndIndex && bSimple; i++) +/*N*/ if (pItems[i].pCell->GetBroadcaster()) +/*N*/ bSimple = FALSE; +/*N*/ } +/*N*/ +/*N*/ ScHint aHint( SC_HINT_DYING, ScAddress( nCol, 0, nTab ), NULL ); +/*N*/ +/*N*/ if (bSimple) // Bereich komplett loeschen +/*N*/ { +/*N*/ ScBaseCell* pOldCell; +/*N*/ ScNoteCell* pNoteCell = new ScNoteCell; // Dummy +/*N*/ for (i = nStartIndex; i <= nEndIndex; i++) +/*N*/ { +/*N*/ pOldCell = pItems[i].pCell; +/*N*/ if (pOldCell->GetCellType() == CELLTYPE_FORMULA) // Formeln spaeter loeschen +/*N*/ ppDelCells[nDelCount++] = pOldCell; +/*N*/ else +/*N*/ { +/*N*/ // Interpret in Broadcast darf kein Value finden +/*N*/ pItems[i].pCell = pNoteCell; +/*N*/ aHint.GetAddress().SetRow( pItems[i].nRow ); +/*N*/ aHint.SetCell( pOldCell ); +/*N*/ pDocument->Broadcast( aHint ); +/*N*/ pOldCell->Delete(); +/*N*/ } +/*N*/ } +/*N*/ delete pNoteCell; +/*N*/ memmove( &pItems[nStartIndex], &pItems[nEndIndex + 1], (nCount - nEndIndex - 1) * sizeof(ColEntry) ); +/*N*/ nCount -= nEndIndex-nStartIndex+1; +/*N*/ } +/*N*/ else // Zellen einzeln durchgehen +/*N*/ { +/*N*/ USHORT j = nStartIndex; +/*N*/ for (USHORT i = nStartIndex; i <= nEndIndex; i++) +/*N*/ { +/*N*/ BOOL bDelete = FALSE; +/*N*/ ScBaseCell* pOldCell = pItems[j].pCell; +/*N*/ CellType eCellType = pOldCell->GetCellType(); +/*N*/ switch ( eCellType ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ if ( ( nDelFlag & (IDF_DATETIME|IDF_VALUE) ) == (IDF_DATETIME|IDF_VALUE) ) +/*N*/ bDelete = TRUE; +/*N*/ else +/*N*/ { +/*?*/ ULONG nIndex = (ULONG)((SfxUInt32Item*)GetAttr( pItems[j].nRow, ATTR_VALUE_FORMAT ))->GetValue(); +/*?*/ short nTyp = pDocument->GetFormatTable()->GetType(nIndex); +/*?*/ if ((nTyp == NUMBERFORMAT_DATE) || (nTyp == NUMBERFORMAT_TIME) || (nTyp == NUMBERFORMAT_DATETIME)) +/*?*/ bDelete = ((nDelFlag & IDF_DATETIME) != 0); +/*?*/ else +/*?*/ bDelete = ((nDelFlag & IDF_VALUE) != 0); +/*N*/ } +/*N*/ break; +/*?*/ case CELLTYPE_STRING: +/*N*/ case CELLTYPE_EDIT: bDelete = ((nDelFlag & IDF_STRING) != 0); break; +/*?*/ case CELLTYPE_FORMULA: bDelete = ((nDelFlag & IDF_FORMULA) != 0); break; +/*?*/ case CELLTYPE_NOTE: +/*?*/ bDelete = ((nDelFlag & IDF_NOTE) != 0) && +/*?*/ (pOldCell->GetBroadcaster() == NULL); +/*?*/ break; +/*N*/ } +/*N*/ +/*N*/ if (bDelete) +/*N*/ { +/*N*/ ScNoteCell* pNoteCell = NULL; +/*N*/ if (eCellType != CELLTYPE_NOTE) +/*N*/ { +/*N*/ if ((nDelFlag & IDF_NOTE) == 0) +/*N*/ { +/*?*/ const ScPostIt* pNote = pOldCell->GetNotePtr(); +/*?*/ if (pNote) +/*?*/ pNoteCell = new ScNoteCell(*pNote); +/*N*/ } +/*N*/ ScBroadcasterList* pBC = pOldCell->GetBroadcaster(); +/*N*/ if (pBC) +/*N*/ { +/*N*/ if (!pNoteCell) +/*N*/ pNoteCell = new ScNoteCell; +/*N*/ pNoteCell->SetBroadcaster(pBC); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ USHORT nOldRow = pItems[j].nRow; +/*N*/ if (pNoteCell) +/*N*/ { +/*N*/ pItems[j].pCell = pNoteCell; +/*N*/ ++j; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ --nCount; +/*N*/ memmove( &pItems[j], &pItems[j + 1], (nCount - j) * sizeof(ColEntry) ); +/*N*/ pItems[nCount].nRow = 0; +/*N*/ pItems[nCount].pCell = NULL; +/*N*/ } +/*N*/ // ACHTUNG! pItems bereits verschoben! +/*N*/ // Interpret in Broadcast muss neue/keine Zelle finden +/*N*/ if (eCellType == CELLTYPE_FORMULA) // Formeln spaeter loeschen +/*N*/ { +/*N*/ ppDelCells[nDelCount++] = pOldCell; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aHint.GetAddress().SetRow( nOldRow ); +/*N*/ aHint.SetCell( pOldCell ); +/*N*/ pDocument->Broadcast( aHint ); +/*N*/ if (eCellType != CELLTYPE_NOTE) +/*N*/ pOldCell->ForgetBroadcaster(); +/*N*/ pOldCell->Delete(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ if (nDelFlag & IDF_NOTE) +/*?*/ if (pItems[j].pCell->GetNotePtr()) +/*?*/ pItems[j].pCell->DeleteNote(); +/*?*/ ++j; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // erst Listener abhaengen kann Neuberechnungen sparen +/*N*/ // eventuell werden dabei vorher entstandene NoteCell mitsamt +/*N*/ // ihren Broadcaster deleted! +/*N*/ for (i=0; i<nDelCount; i++) +/*N*/ { +/*?*/ ((ScFormulaCell*) ppDelCells[i])->EndListeningTo( pDocument ); +/*N*/ } +/*N*/ // gibts die NoteCell und damit den Broadcaster noch? +/*N*/ // If not, discard them all before broadcasting takes place! +/*N*/ for (i=0; i<nDelCount; i++) +/*N*/ { +/*?*/ ScFormulaCell* pOldCell = (ScFormulaCell*) ppDelCells[i]; +/*?*/ USHORT nIndex; +/*?*/ if ( !Search( pOldCell->aPos.Row(), nIndex ) ) +/*?*/ pOldCell->ForgetBroadcaster(); +/*N*/ } +/*N*/ for (i=0; i<nDelCount; i++) +/*N*/ { +/*?*/ ScFormulaCell* pOldCell = (ScFormulaCell*) ppDelCells[i]; +/*?*/ aHint.SetAddress( pOldCell->aPos ); +/*?*/ aHint.SetCell( pOldCell ); +/*?*/ pDocument->Broadcast( aHint ); +/*?*/ pOldCell->ForgetBroadcaster(); +/*?*/ pOldCell->Delete(); +/*N*/ } +/*N*/ +/*N*/ delete[] ppDelCells; +/*N*/ } + + +/*N*/ void ScColumn::DeleteArea(USHORT nStartRow, USHORT nEndRow, USHORT nDelFlag) +/*N*/ { +/*N*/ // FreeAll darf hier nicht gerufen werden wegen Broadcastern +/*N*/ +/*N*/ // Attribute erst am Ende, damit vorher noch zwischen Zahlen und Datum +/*N*/ // unterschieden werden kann (#47901#) +/*N*/ +/*N*/ USHORT nContFlag = nDelFlag & IDF_CONTENTS; +/*N*/ if (pItems && nCount && nContFlag) +/*N*/ { +/*N*/ if (nStartRow==0 && nEndRow==MAXROW) +/*N*/ DeleteRange( 0, nCount-1, nContFlag ); +/*N*/ else +/*N*/ { +/*?*/ BOOL bFound=FALSE; +/*?*/ USHORT nStartIndex; +/*?*/ USHORT nEndIndex; +/*?*/ for (USHORT i = 0; i < nCount; i++) +/*?*/ if ((pItems[i].nRow >= nStartRow) && (pItems[i].nRow <= nEndRow)) +/*?*/ { +/*?*/ if (!bFound) +/*?*/ { +/*?*/ nStartIndex = i; +/*?*/ bFound = TRUE; +/*?*/ } +/*?*/ nEndIndex = i; +/*?*/ } +/*?*/ if (bFound) +/*?*/ DeleteRange( nStartIndex, nEndIndex, nContFlag ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( nDelFlag & IDF_EDITATTR ) +/*N*/ { +/*?*/ DBG_ASSERT( nContFlag == 0, "DeleteArea: falsche Flags" ); +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ RemoveEditAttribs( nStartRow, nEndRow ); +/*N*/ } +/*N*/ +/*N*/ // Attribute erst hier +/*N*/ if ((nDelFlag & IDF_ATTRIB) == IDF_ATTRIB) pAttrArray->DeleteArea( nStartRow, nEndRow ); +/*N*/ else if ((nDelFlag & IDF_ATTRIB) != 0) pAttrArray->DeleteHardAttr( nStartRow, nEndRow ); +/*N*/ } + + + + +// rColumn = Quelle +// nRow1, nRow2 = Zielposition + + + + // Formelzellen werden jetzt schon hier kopiert, + // Notizen muessen aber evtl. noch geloescht werden + +/*N*/ ScBaseCell* ScColumn::CloneCell(USHORT nIndex, USHORT nFlags, +/*N*/ ScDocument* pDestDoc, const ScAddress& rDestPos) +/*N*/ { +/*N*/ ScBaseCell* pNew = 0; +/*N*/ ScBaseCell* pSource = pItems[nIndex].pCell; +/*N*/ switch (pSource->GetCellType()) +/*N*/ { +/*?*/ case CELLTYPE_NOTE: +/*?*/ if (nFlags & IDF_NOTE) +/*?*/ pNew = new ScNoteCell(*(ScNoteCell*)pSource); +/*?*/ break; +/*?*/ case CELLTYPE_EDIT: +/*?*/ if (nFlags & IDF_STRING) +/*?*/ pNew = new ScEditCell( *(ScEditCell*)pSource, pDestDoc ); +/*?*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ if (nFlags & IDF_STRING) +/*N*/ pNew = new ScStringCell(*(ScStringCell*)pSource); +/*N*/ break; +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ BOOL bDoIns = FALSE; +/*N*/ USHORT nMask = nFlags & ( IDF_DATETIME | IDF_VALUE ); +/*N*/ if ( nMask == (IDF_DATETIME | IDF_VALUE) ) +/*N*/ bDoIns = TRUE; +/*N*/ else if ( nMask ) +/*N*/ { +/*?*/ ULONG nNumIndex = (ULONG)((SfxUInt32Item*) GetAttr( +/*?*/ pItems[nIndex].nRow, ATTR_VALUE_FORMAT ))->GetValue(); +/*?*/ short nTyp = pDocument->GetFormatTable()->GetType(nNumIndex); +/*?*/ if (nTyp == NUMBERFORMAT_DATE || nTyp == NUMBERFORMAT_TIME || nTyp == NUMBERFORMAT_DATETIME) +/*?*/ bDoIns = (nFlags & IDF_DATETIME)!=0; +/*?*/ else +/*?*/ bDoIns = (nFlags & IDF_VALUE)!=0; +/*N*/ } +/*N*/ if (bDoIns) +/*N*/ pNew = new ScValueCell(*(ScValueCell*)pSource); +/*N*/ } +/*N*/ break; +/*?*/ case CELLTYPE_FORMULA: +/*?*/ { +/*?*/ ScFormulaCell* pForm = (ScFormulaCell*)pSource; +/*?*/ if (nFlags & IDF_FORMULA) +/*?*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pNew = pForm->Clone( pDestDoc, rDestPos, TRUE ); +/*?*/ } +/*?*/ else if ( (nFlags & (IDF_VALUE | IDF_DATETIME | IDF_STRING)) && +/*?*/ !pDestDoc->IsUndo() ) +/*?*/ { +/*?*/ // #48491# ins Undo-Dokument immer nur die Original-Zelle kopieren, +/*?*/ // aus Formeln keine Value/String-Zellen erzeugen +/*?*/ +/*?*/ USHORT nErr = pForm->GetErrCode(); +/*?*/ if ( nErr ) +/*?*/ { +/*?*/ // Fehler werden immer mit "Zahlen" kopiert +/*?*/ // (Das ist hiermit willkuerlich so festgelegt) +/*?*/ +/*?*/ if ( nFlags & IDF_VALUE ) +/*?*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ ScFormulaCell* pErrCell = new ScFormulaCell( pDestDoc, rDestPos ); +/*?*/ } +/*?*/ } +/*?*/ else if ( pForm->IsValue() ) +/*?*/ { +/*?*/ BOOL bDoIns = FALSE; +/*?*/ USHORT nMask = nFlags & ( IDF_DATETIME | IDF_VALUE ); +/*?*/ if ( nMask == (IDF_DATETIME | IDF_VALUE) ) +/*?*/ bDoIns = TRUE; +/*?*/ else if ( nMask ) +/*?*/ { +/*?*/ ULONG nNumIndex = (ULONG)((SfxUInt32Item*) GetAttr( +/*?*/ pItems[nIndex].nRow, ATTR_VALUE_FORMAT ))->GetValue(); +/*?*/ short nTyp = pDocument->GetFormatTable()->GetType(nNumIndex); +/*?*/ if (nTyp == NUMBERFORMAT_DATE || nTyp == NUMBERFORMAT_TIME || nTyp == NUMBERFORMAT_DATETIME) +/*?*/ bDoIns = (nFlags & IDF_DATETIME)!=0; +/*?*/ else +/*?*/ bDoIns = (nFlags & IDF_VALUE)!=0; +/*?*/ } +/*?*/ +/*?*/ if (bDoIns) +/*?*/ { +/*?*/ double nVal = pForm->GetValue(); +/*?*/ pNew = new ScValueCell(nVal); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ if (nFlags & IDF_STRING) +/*?*/ { +/*?*/ String aString; +/*?*/ pForm->GetString(aString); +/*?*/ if ( aString.Len() ) +/*?*/ pNew = new ScStringCell(aString); +/*?*/ // #33224# LeerStrings nicht kopieren +/*?*/ } +/*?*/ } +/*?*/ if ( pNew && pSource->GetNotePtr() && ( nFlags & IDF_NOTE ) ) +/*?*/ pNew->SetNote(*pSource->GetNotePtr()); +/*?*/ } +/*?*/ } +/*?*/ break; +/*N*/ } +/*N*/ +/*N*/ if ( !pNew && pSource->GetNotePtr() && ( nFlags & IDF_NOTE ) ) +/*?*/ pNew = new ScNoteCell(*pSource->GetNotePtr()); +/*N*/ +/*N*/ return pNew; +/*N*/ } + + + + +// Ergebnis in rVal1 + + + + + + + +/*N*/ ScAttrIterator* ScColumn::CreateAttrIterator( USHORT nStartRow, USHORT nEndRow ) const +/*N*/ { +/*N*/ return new ScAttrIterator( pAttrArray, nStartRow, nEndRow ); +/*N*/ } + + +/*N*/ void ScColumn::StartAllListeners() +/*N*/ { +/*N*/ if (pItems) +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ ((ScFormulaCell*)pCell)->StartListeningTo( pDocument ); +/*N*/ if ( nRow != pItems[i].nRow ) +/*N*/ Search( nRow, i ); // Listener eingefuegt? +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::StartNameListeners( BOOL bOnlyRelNames ) +/*N*/ { +/*N*/ if (pItems) +/*N*/ { +/*N*/ USHORT nNameListening = (bOnlyRelNames ? SC_LISTENING_NAMES_REL : +/*N*/ SC_LISTENING_NAMES_REL | SC_LISTENING_NAMES_ABS); +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[i].pCell; +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ USHORT nRow = pItems[i].nRow; +/*N*/ ((ScFormulaCell*)pCell)->StartListeningTo( pDocument, nNameListening ); +/*N*/ if ( nRow != pItems[i].nRow ) +/*N*/ Search( nRow, i ); // Listener eingefuegt? +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + + + +// TRUE = Zahlformat gesetzt +/*N*/ BOOL ScColumn::SetString( USHORT nRow, USHORT nTab, const String& rString ) +/*N*/ { +/*N*/ BOOL bNumFmtSet = FALSE; +/*N*/ if (VALIDROW(nRow)) +/*N*/ { +/*N*/ ScBaseCell* pNewCell = NULL; +/*N*/ BOOL bIsLoading = FALSE; +/*N*/ if (rString.Len() > 0) +/*N*/ { +/*N*/ double nVal; +/*N*/ sal_uInt32 nIndex, nOldIndex; +/*N*/ sal_Unicode cFirstChar; +/*N*/ SvNumberFormatter* pFormatter = pDocument->GetFormatTable(); +/*N*/ SfxObjectShell* pDocSh = pDocument->GetDocumentShell(); +/*N*/ if ( pDocSh ) +/*N*/ bIsLoading = pDocSh->IsLoading(); +/*N*/ // IsLoading bei ConvertFrom Import +/*N*/ if ( !bIsLoading ) +/*N*/ { +/*N*/ nIndex = nOldIndex = GetNumberFormat( nRow ); +/*N*/ if ( rString.Len() > 1 +/*N*/ && pFormatter->GetType(nIndex) != NUMBERFORMAT_TEXT ) +/*N*/ cFirstChar = rString.GetChar(0); +/*N*/ else +/*N*/ cFirstChar = 0; // Text +/*N*/ } +/*N*/ else +/*N*/ { // waehrend ConvertFrom Import gibt es keine gesetzten Formate +/*N*/ cFirstChar = rString.GetChar(0); +/*N*/ } +/*N*/ +/*N*/ if ( cFirstChar == '=' ) +/*N*/ { +/*?*/ if ( rString.Len() == 1 ) // = Text +/*?*/ pNewCell = new ScStringCell( rString ); +/*?*/ else // =Formel +/*?*/ pNewCell = new ScFormulaCell( pDocument, +/*?*/ ScAddress( nCol, nRow, nTab ), rString, 0 ); +/*N*/ } +/*N*/ else if ( cFirstChar == '\'') // 'Text +/*?*/ pNewCell = new ScStringCell( rString.Copy(1) ); +/*N*/ else +/*N*/ { +/*N*/ BOOL bIsText = FALSE; +/*N*/ if ( bIsLoading ) +/*N*/ { +/*N*/ if ( pItems && nCount ) +/*N*/ { +/*?*/ String aStr; +/*?*/ USHORT i = nCount; +/*?*/ USHORT nStop = (i >= 3 ? i - 3 : 0); +/*?*/ // die letzten Zellen vergleichen, ob gleicher String +/*?*/ // und IsNumberFormat eingespart werden kann +/*?*/ do +/*?*/ { +/*?*/ i--; +/*?*/ ScBaseCell* pCell = pItems[i].pCell; +/*?*/ switch ( pCell->GetCellType() ) +/*?*/ { +/*?*/ case CELLTYPE_STRING : +/*?*/ ((ScStringCell*)pCell)->GetString( aStr ); +/*?*/ if ( rString == aStr ) +/*?*/ bIsText = TRUE; +/*?*/ break; +/*?*/ case CELLTYPE_NOTE : // durch =Formel referenziert +/*?*/ break; +/*?*/ default: +/*?*/ if ( i == nCount - 1 ) +/*?*/ i = 0; +/*?*/ // wahrscheinlich ganze Spalte kein String +/*?*/ } +/*?*/ } while ( i && i > nStop && !bIsText ); +/*N*/ } +/*N*/ // nIndex fuer IsNumberFormat vorbelegen +/*N*/ if ( !bIsText ) +/*N*/ nIndex = nOldIndex = pFormatter->GetStandardIndex(); +/*N*/ } +/*N*/ if ( !bIsText && +/*N*/ pFormatter->IsNumberFormat(rString, nIndex, nVal) ) +/*N*/ { // Zahl +/*?*/ pNewCell = new ScValueCell( nVal ); +/*?*/ if ( nIndex != nOldIndex) +/*?*/ { +/*?*/ ApplyAttr( nRow, SfxUInt32Item( ATTR_VALUE_FORMAT, +/*?*/ (UINT32) nIndex) ); +/*?*/ bNumFmtSet = TRUE; +/*?*/ } +/*N*/ } +/*N*/ else // Text +/*N*/ pNewCell = new ScStringCell( rString ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( bIsLoading && (!nCount || nRow > pItems[nCount-1].nRow) ) +/*N*/ { // Search einsparen und ohne Umweg ueber Insert, Listener aufbauen +/*N*/ // und Broadcast kommt eh erst nach dem Laden +/*N*/ if ( pNewCell ) +/*N*/ Append( nRow, pNewCell ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT i; +/*N*/ if (Search(nRow, i)) +/*N*/ { +/*?*/ ScBaseCell* pOldCell = pItems[i].pCell; +/*?*/ const ScPostIt* pNote = pOldCell->GetNotePtr(); +/*?*/ ScBroadcasterList* pBC = pOldCell->GetBroadcaster(); +/*?*/ if (pNewCell || pNote || pBC) +/*?*/ { +/*?*/ if (!pNewCell) +/*?*/ pNewCell = new ScNoteCell(); +/*?*/ if (pNote) +/*?*/ pNewCell->SetNote(*pNote); +/*?*/ if (pBC) +/*?*/ { +/*?*/ pNewCell->SetBroadcaster(pBC); +/*?*/ pOldCell->ForgetBroadcaster(); +/*?*/ pLastFormulaTreeTop = 0; // Err527 Workaround +/*?*/ } +/*?*/ +/*?*/ if ( pOldCell->GetCellType() == CELLTYPE_FORMULA ) +/*?*/ { +/*?*/ pOldCell->EndListeningTo( pDocument ); +/*?*/ // falls in EndListening NoteCell in gleicher Col zerstoert +/*?*/ if ( i >= nCount || pItems[i].nRow != nRow ) +/*?*/ Search(nRow, i); +/*?*/ } +/*?*/ pOldCell->Delete(); +/*?*/ pItems[i].pCell = pNewCell; // ersetzen +/*?*/ if ( pNewCell->GetCellType() == CELLTYPE_FORMULA ) +/*?*/ { +/*?*/ pNewCell->StartListeningTo( pDocument ); +/*?*/ ((ScFormulaCell*)pNewCell)->SetDirty(); +/*?*/ } +/*?*/ else +/*?*/ pDocument->Broadcast( ScHint( SC_HINT_DATACHANGED, +/*?*/ ScAddress( nCol, nRow, nTab ), pNewCell ) ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ DeleteAtIndex(i); // loeschen und Broadcast +/*?*/ } +/*N*/ } +/*N*/ else if (pNewCell) +/*N*/ { +/*N*/ Insert(nRow, pNewCell); // neu eintragen und Broadcast +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // hier keine Formate mehr fuer Formeln setzen! +/*N*/ // (werden bei der Ausgabe abgefragt) +/*N*/ +/*N*/ } +/*N*/ return bNumFmtSet; +/*N*/ } + + + +// +// GetDataEntries - Strings aus zusammenhaengendem Bereich um nRow +// + +// DATENT_MAX - max. Anzahl Eintrage in Liste fuer Auto-Eingabe +// DATENT_SEARCH - max. Anzahl Zellen, die durchsucht werden - neu: nur Strings zaehlen +#define DATENT_MAX 200 +#define DATENT_SEARCH 2000 + + + +#undef DATENT_MAX +#undef DATENT_SEARCH + + + + +/*N*/ void ScColumn::SetError( USHORT nRow, const USHORT nError) +/*N*/ { +/*N*/ if (VALIDROW(nRow)) +/*N*/ { +/*N*/ ScFormulaCell* pCell = new ScFormulaCell +/*N*/ ( pDocument, ScAddress( nCol, nRow, nTab ) ); +/*N*/ pCell->SetErrCode( nError ); +/*N*/ Insert( nRow, pCell ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::SetValue( USHORT nRow, const double& rVal) +/*N*/ { +/*N*/ if (VALIDROW(nRow)) +/*N*/ { +/*N*/ ScBaseCell* pCell = new ScValueCell(rVal); +/*N*/ Insert( nRow, pCell ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::SetNote( USHORT nRow, const ScPostIt& rNote) +/*N*/ { +/*N*/ BOOL bEmpty = !rNote.GetText().Len(); +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if (bEmpty && pCell->GetCellType() == CELLTYPE_NOTE && !pCell->GetBroadcaster()) +/*?*/ DeleteAtIndex(nIndex); +/*N*/ else +/*N*/ pCell->SetNote(rNote); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (!bEmpty) +/*N*/ Insert(nRow, new ScNoteCell(rNote)); +/*N*/ } +/*N*/ } + + +/*N*/ void ScColumn::GetString( USHORT nRow, String& rString ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ Color* pColor; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if (pCell->GetCellType() != CELLTYPE_NOTE) +/*N*/ { +/*N*/ ULONG nFormat = GetNumberFormat( nRow ); +/*N*/ ScCellFormat::GetString( pCell, nFormat, rString, &pColor, *(pDocument->GetFormatTable()) ); +/*N*/ } +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + + +/*N*/ void ScColumn::GetInputString( USHORT nRow, String& rString ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ { +/*?*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*?*/ if (pCell->GetCellType() != CELLTYPE_NOTE) +/*?*/ { +/*?*/ ULONG nFormat = GetNumberFormat( nRow ); +/*?*/ ScCellFormat::GetInputString( pCell, nFormat, rString, *(pDocument->GetFormatTable()) ); +/*?*/ } +/*?*/ else +/*?*/ rString.Erase(); +/*N*/ } +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + + +/*N*/ double ScColumn::GetValue( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ switch (pCell->GetCellType()) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ return ((ScValueCell*)pCell)->GetValue(); +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ if (((ScFormulaCell*)pCell)->IsValue()) +/*N*/ return ((ScFormulaCell*)pCell)->GetValue(); +/*N*/ else +/*N*/ return 0.0; +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ return 0.0; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ return 0.0; +/*N*/ } + +/*N*/ BOOL ScColumn::GetNote( USHORT nRow, ScPostIt& rNote) const +/*N*/ { +/*N*/ BOOL bHasNote = FALSE; +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ bHasNote = pItems[nIndex].pCell->GetNote(rNote); +/*N*/ else +/*?*/ rNote.Clear(); +/*N*/ +/*N*/ return bHasNote; +/*N*/ } + + +/*N*/ CellType ScColumn::GetCellType( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ return pItems[nIndex].pCell->GetCellType(); +/*N*/ return CELLTYPE_NONE; +/*N*/ } + + +/*N*/ USHORT ScColumn::GetErrCode( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ { +/*N*/ ScBaseCell* pCell = pItems[nIndex].pCell; +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ return ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ } +/*N*/ return 0; +/*N*/ } + + +/*N*/ BOOL ScColumn::HasStringData( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ return (pItems[nIndex].pCell)->HasStringData(); +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScColumn::HasValueData( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ if (Search(nRow, nIndex)) +/*N*/ return (pItems[nIndex].pCell)->HasValueData(); +/*N*/ return FALSE; +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_conditio.cxx b/binfilter/bf_sc/source/core/data/sc_conditio.cxx new file mode 100644 index 000000000000..033290704ade --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_conditio.cxx @@ -0,0 +1,1370 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------ + +#include "scitems.hxx" +#include <bf_sfx2/objsh.hxx> +#include <bf_svtools/itemset.hxx> +#include <bf_svtools/zforlist.hxx> +#include <rtl/math.hxx> + + +#include "conditio.hxx" +#include "cell.hxx" +#include "document.hxx" +#include "hints.hxx" +#include "rechead.hxx" +#include "stlpool.hxx" +#include "rangenam.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ SV_IMPL_OP_PTRARR_SORT( ScConditionalFormats_Impl, ScConditionalFormatPtr ); + +//------------------------------------------------------------------------ + +/*N*/ BOOL lcl_HasRelRef( ScDocument* pDoc, ScTokenArray* pFormula, USHORT nRecursion = 0 ) +/*N*/ { +/*N*/ if (pFormula) +/*N*/ { +/*N*/ pFormula->Reset(); +/*N*/ ScToken* t; +/*N*/ for( t = pFormula->GetNextReferenceOrName(); t; t = pFormula->GetNextReferenceOrName() ) +/*N*/ { +/*N*/ if( t->GetType() == svIndex ) +/*N*/ { +/*?*/ ScRangeData* pRangeData = pDoc->GetRangeName()->FindIndex( t->GetIndex() ); +/*?*/ if( (t->GetOpCode() == ocName) && (nRecursion < 42) && pRangeData && +/*?*/ lcl_HasRelRef( pDoc, pRangeData->GetCode(), nRecursion + 1 ) ) +/*?*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*N*/ if ( rRef1.IsColRel() || rRef1.IsRowRel() || rRef1.IsTabRel() ) +/*N*/ return TRUE; +/*?*/ if ( t->GetType() == svDoubleRef ) +/*?*/ { +/*?*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*?*/ if ( rRef2.IsColRel() || rRef2.IsRowRel() || rRef2.IsTabRel() ) +/*?*/ return TRUE; +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ ScConditionEntry::ScConditionEntry( const ScConditionEntry& r ) : +/*N*/ eOp(r.eOp), +/*N*/ nOptions(r.nOptions), +/*N*/ nVal1(r.nVal1), +/*N*/ nVal2(r.nVal2), +/*N*/ aStrVal1(r.aStrVal1), +/*N*/ aStrVal2(r.aStrVal2), +/*N*/ bIsStr1(r.bIsStr1), +/*N*/ bIsStr2(r.bIsStr2), +/*N*/ bRelRef1(r.bRelRef1), +/*N*/ bRelRef2(r.bRelRef2), +/*N*/ pFormula1(NULL), +/*N*/ pFormula2(NULL), +/*N*/ pFCell1(NULL), +/*N*/ pFCell2(NULL), +/*N*/ pDoc(r.pDoc), +/*N*/ aSrcPos(r.aSrcPos), +/*N*/ bFirstRun(TRUE) +/*N*/ { +/*N*/ // ScTokenArray copy ctor erzeugt flache Kopie +/*N*/ +/*N*/ if (r.pFormula1) +/*N*/ pFormula1 = new ScTokenArray( *r.pFormula1 ); +/*N*/ if (r.pFormula2) +/*N*/ pFormula2 = new ScTokenArray( *r.pFormula2 ); +/*N*/ +/*N*/ // Formelzellen werden erst bei IsValid angelegt +/*N*/ } + +/*N*/ ScConditionEntry::ScConditionEntry( ScDocument* pDocument, const ScConditionEntry& r ) : +/*N*/ eOp(r.eOp), +/*N*/ nOptions(r.nOptions), +/*N*/ nVal1(r.nVal1), +/*N*/ nVal2(r.nVal2), +/*N*/ aStrVal1(r.aStrVal1), +/*N*/ aStrVal2(r.aStrVal2), +/*N*/ bIsStr1(r.bIsStr1), +/*N*/ bIsStr2(r.bIsStr2), +/*N*/ bRelRef1(r.bRelRef1), +/*N*/ bRelRef2(r.bRelRef2), +/*N*/ pFormula1(NULL), +/*N*/ pFormula2(NULL), +/*N*/ pFCell1(NULL), +/*N*/ pFCell2(NULL), +/*N*/ pDoc(pDocument), +/*N*/ aSrcPos(r.aSrcPos), +/*N*/ bFirstRun(TRUE) +/*N*/ { +/*N*/ // echte Kopie der Formeln (fuer Ref-Undo) +/*N*/ +/*N*/ if (r.pFormula1) +/*N*/ pFormula1 = r.pFormula1->Clone(); +/*N*/ if (r.pFormula2) +/*N*/ pFormula2 = r.pFormula2->Clone(); +/*N*/ +/*N*/ // Formelzellen werden erst bei IsValid angelegt +/*N*/ //! im Clipboard nicht - dann vorher interpretieren !!! +/*N*/ } + +/*N*/ ScConditionEntry::ScConditionEntry( ScConditionMode eOper, +/*N*/ const String& rExpr1, const String& rExpr2, +/*N*/ ScDocument* pDocument, const ScAddress& rPos, +/*N*/ BOOL bCompileEnglish, BOOL bCompileXML ) : +/*N*/ eOp(eOper), +/*N*/ nOptions(0), // spaeter... +/*N*/ nVal1(0.0), +/*N*/ nVal2(0.0), +/*N*/ bIsStr1(FALSE), +/*N*/ bIsStr2(FALSE), +/*N*/ bRelRef1(FALSE), +/*N*/ bRelRef2(FALSE), +/*N*/ pFormula1(NULL), +/*N*/ pFormula2(NULL), +/*N*/ pFCell1(NULL), +/*N*/ pFCell2(NULL), +/*N*/ pDoc(pDocument), +/*N*/ aSrcPos(rPos), +/*N*/ bFirstRun(TRUE) +/*N*/ { +/*N*/ Compile( rExpr1, rExpr2, bCompileEnglish, bCompileXML, FALSE ); +/*N*/ +/*N*/ // Formelzellen werden erst bei IsValid angelegt +/*N*/ } + +/*N*/ ScConditionEntry::~ScConditionEntry() +/*N*/ { +/*N*/ delete pFCell1; +/*N*/ delete pFCell2; +/*N*/ +/*N*/ delete pFormula1; +/*N*/ delete pFormula2; +/*N*/ } + +/*N*/ ScConditionEntry::ScConditionEntry( SvStream& rStream, ScMultipleReadHeader& rHdr, +/*N*/ ScDocument* pDocument ) : +/*N*/ nVal1(0.0), +/*N*/ nVal2(0.0), +/*N*/ bIsStr1(FALSE), +/*N*/ bIsStr2(FALSE), +/*N*/ bRelRef1(FALSE), +/*N*/ bRelRef2(FALSE), +/*N*/ pFormula1(NULL), +/*N*/ pFormula2(NULL), +/*N*/ pFCell1(NULL), +/*N*/ pFCell2(NULL), +/*N*/ pDoc(pDocument), +/*N*/ bFirstRun(TRUE) +/*N*/ { +/*N*/ USHORT nVer = (USHORT) pDoc->GetSrcVersion(); +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ BYTE nOpByte; +/*N*/ rStream >> nOpByte; +/*N*/ eOp = (ScConditionMode) nOpByte; +/*N*/ +/*N*/ rStream >> nOptions; +/*N*/ +/*N*/ ScAddress aPos; +/*N*/ BYTE nTypeByte; +/*N*/ rStream >> nTypeByte; +/*N*/ ScConditionValType eType = (ScConditionValType) nTypeByte; +/*N*/ if ( eType == SC_VAL_FORMULA ) +/*N*/ { +/*N*/ rStream >> aPos; +/*N*/ pFormula1 = new ScTokenArray; +/*N*/ pFormula1->Load( rStream, nVer, aPos ); +/*N*/ bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 ); +/*N*/ } +/*N*/ else if ( eType == SC_VAL_VALUE ) +/*N*/ rStream >> nVal1; +/*N*/ else +/*N*/ { +/*?*/ bIsStr1 = TRUE; +/*?*/ rStream.ReadByteString( aStrVal1, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ +/*N*/ if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN ) +/*N*/ { +/*?*/ rStream >> nTypeByte; +/*?*/ eType = (ScConditionValType) nTypeByte; +/*?*/ if ( eType == SC_VAL_FORMULA ) +/*?*/ { +/*?*/ rStream >> aPos; +/*?*/ pFormula2 = new ScTokenArray; +/*?*/ pFormula2->Load( rStream, nVer, aPos ); +/*?*/ bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 ); +/*?*/ } +/*?*/ else if ( eType == SC_VAL_VALUE ) +/*?*/ rStream >> nVal2; +/*?*/ else +/*?*/ { +/*?*/ bIsStr2 = TRUE; +/*?*/ rStream.ReadByteString( aStrVal2, rStream.GetStreamCharSet() ); +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ aSrcPos = aPos; +/*N*/ +/*N*/ // Formelzellen werden erst bei IsValid angelegt +/*N*/ } + +/*N*/ void ScConditionEntry::StoreCondition(SvStream& rStream, ScMultipleWriteHeader& rHdr) const +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ // 1) Byte fuer die Operation +/*N*/ // 2) USHORT fuer Optionen +/*N*/ // 3) Byte, ob Wert, String oder Formel folgt +/*N*/ // 4) double, String oder TokenArray +/*N*/ // 5) je nach Operation 3 und 4 nochmal +/*N*/ // vor jedem TokenArray noch die Position als ScAddress +/*N*/ +/*N*/ rStream << (BYTE) eOp; +/*N*/ rStream << nOptions; +/*N*/ +/*N*/ ScConditionValType eType = +/*N*/ pFormula1 ? SC_VAL_FORMULA : ( bIsStr1 ? SC_VAL_STRING : SC_VAL_VALUE ); +/*N*/ rStream << (BYTE) eType; +/*N*/ if ( eType == SC_VAL_FORMULA ) +/*N*/ { +/*N*/ rStream << aSrcPos; +/*N*/ pFormula1->Store( rStream, aSrcPos ); +/*N*/ } +/*N*/ else if ( eType == SC_VAL_VALUE ) +/*N*/ rStream << nVal1; +/*N*/ else +/*?*/ rStream.WriteByteString( aStrVal1, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN ) +/*N*/ { +/*?*/ eType = pFormula2 ? SC_VAL_FORMULA : ( bIsStr2 ? SC_VAL_STRING : SC_VAL_VALUE ); +/*?*/ rStream << (BYTE) eType; +/*?*/ if ( eType == SC_VAL_FORMULA ) +/*?*/ { +/*?*/ rStream << aSrcPos; +/*?*/ pFormula2->Store( rStream, aSrcPos ); +/*?*/ } +/*?*/ else if ( eType == SC_VAL_VALUE ) +/*?*/ rStream << nVal2; +/*?*/ else +/*?*/ rStream.WriteByteString( aStrVal2, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ void ScConditionEntry::Compile( const String& rExpr1, const String& rExpr2, +/*N*/ BOOL bEnglish, BOOL bCompileXML, BOOL bTextToReal ) +/*N*/ { +/*N*/ if ( rExpr1.Len() || rExpr2.Len() ) +/*N*/ { +/*N*/ ScCompiler aComp( pDoc, aSrcPos ); +/*N*/ aComp.SetCompileEnglish( bEnglish ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ +/*N*/ if ( rExpr1.Len() ) +/*N*/ { +/*N*/ if ( pDoc->IsImportingXML() && !bTextToReal ) +/*N*/ { +/*?*/ // temporary formula string as string tokens +/*?*/ //! merge with lcl_ScDocFunc_CreateTokenArrayXML +/*?*/ pFormula1 = new ScTokenArray; +/*?*/ pFormula1->AddString( rExpr1 ); +/*?*/ // bRelRef1 is set when the formula is compiled again (CompileXML) +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pFormula1 = aComp.CompileString( rExpr1 ); +/*N*/ if ( pFormula1->GetLen() == 1 ) +/*N*/ { +/*?*/ // einzelne (konstante Zahl) ? +/*?*/ ScToken* pToken = pFormula1->First(); +/*?*/ if ( pToken->GetOpCode() == ocPush ) +/*?*/ { +/*?*/ if ( pToken->GetType() == svDouble ) +/*?*/ { +/*?*/ nVal1 = pToken->GetDouble(); +/*?*/ DELETEZ(pFormula1); // nicht als Formel merken +/*?*/ } +/*?*/ else if ( pToken->GetType() == svString ) +/*?*/ { +/*?*/ bIsStr1 = TRUE; +/*?*/ aStrVal1 = pToken->GetString(); +/*?*/ DELETEZ(pFormula1); // nicht als Formel merken +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ bRelRef1 = lcl_HasRelRef( pDoc, pFormula1 ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( rExpr2.Len() ) +/*N*/ { +/*N*/ if ( pDoc->IsImportingXML() && !bTextToReal ) +/*N*/ { +/*?*/ // temporary formula string as string tokens +/*?*/ //! merge with lcl_ScDocFunc_CreateTokenArrayXML +/*?*/ pFormula2 = new ScTokenArray; +/*?*/ pFormula2->AddString( rExpr2 ); +/*?*/ // bRelRef2 is set when the formula is compiled again (CompileXML) +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pFormula2 = aComp.CompileString( rExpr2 ); +/*N*/ if ( pFormula2->GetLen() == 1 ) +/*N*/ { +/*N*/ // einzelne (konstante Zahl) ? +/*N*/ ScToken* pToken = pFormula2->First(); +/*N*/ if ( pToken->GetOpCode() == ocPush ) +/*N*/ { +/*N*/ if ( pToken->GetType() == svDouble ) +/*N*/ { +/*N*/ nVal2 = pToken->GetDouble(); +/*N*/ DELETEZ(pFormula2); // nicht als Formel merken +/*N*/ } +/*N*/ else if ( pToken->GetType() == svString ) +/*N*/ { +/*?*/ bIsStr2 = TRUE; +/*?*/ aStrVal2 = pToken->GetString(); +/*?*/ DELETEZ(pFormula2); // nicht als Formel merken +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ bRelRef2 = lcl_HasRelRef( pDoc, pFormula2 ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionEntry::MakeCells( const ScAddress& rPos ) // Formelzellen anlegen +/*N*/ { +/*N*/ if ( !pDoc->IsClipOrUndo() ) // nie im Clipboard rechnen! +/*N*/ { +/*N*/ if ( pFormula1 && !pFCell1 && !bRelRef1 ) +/*N*/ { +/*?*/ pFCell1 = new ScFormulaCell( pDoc, rPos, pFormula1 ); +/*?*/ pFCell1->StartListeningTo( pDoc ); +/*N*/ } +/*N*/ +/*N*/ if ( pFormula2 && !pFCell2 && !bRelRef2 ) +/*N*/ { +/*?*/ pFCell2 = new ScFormulaCell( pDoc, rPos, pFormula2 ); +/*?*/ pFCell2->StartListeningTo( pDoc ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionEntry::SetIgnoreBlank(BOOL bSet) +/*N*/ { +/*N*/ // Das Bit SC_COND_NOBLANKS wird gesetzt, wenn Blanks nicht ignoriert werden +/*N*/ // (nur bei Gueltigkeit) +/*N*/ +/*N*/ if (bSet) +/*N*/ nOptions &= ~SC_COND_NOBLANKS; +/*N*/ else +/*N*/ nOptions |= SC_COND_NOBLANKS; +/*N*/ } + + +/*N*/ void ScConditionEntry::CompileXML() +/*N*/ { +/*N*/ // Convert the text tokens that were created during XML import into real tokens: +/*N*/ // The stored string tokens contain english function names, but no XML-style references +/*N*/ +/*N*/ Compile( GetExpression(aSrcPos, 0, 0, TRUE, FALSE, TRUE), +/*N*/ GetExpression(aSrcPos, 1, 0, TRUE, FALSE, TRUE), +/*N*/ TRUE, FALSE, TRUE ); +/*N*/ } + +/*N*/ void lcl_CondUpdateInsertTab( ScTokenArray& rCode, USHORT nInsTab, USHORT nPosTab, BOOL& rChanged ) +/*N*/ { +/*N*/ // Insert table: only update absolute table references. +/*N*/ // (Similar to ScCompiler::UpdateInsertTab with bIsName=TRUE, result is the same as for named ranges) +/*N*/ // For deleting, ScCompiler::UpdateDeleteTab is used because of the handling of invalid references. +/*N*/ +/*N*/ rCode.Reset(); +/*N*/ ScToken* p = rCode.GetNextReference(); +/*N*/ while( p ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = p->GetSingleRef(); +/*N*/ if ( !rRef1.IsTabRel() && nInsTab <= rRef1.nTab ) +/*N*/ { +/*?*/ rRef1.nTab += 1; +/*?*/ rRef1.nRelTab = rRef1.nTab - nPosTab; +/*?*/ rChanged = TRUE; +/*N*/ } +/*N*/ if( p->GetType() == svDoubleRef ) +/*N*/ { +/*?*/ SingleRefData& rRef2 = p->GetDoubleRef().Ref2; +/*?*/ if ( !rRef2.IsTabRel() && nInsTab <= rRef2.nTab ) +/*?*/ { +/*?*/ rRef2.nTab += 1; +/*?*/ rRef2.nRelTab = rRef2.nTab - nPosTab; +/*?*/ rChanged = TRUE; +/*N*/ } +/*N*/ } +/*N*/ p = rCode.GetNextReference(); +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionEntry::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ BOOL bInsertTab = ( eUpdateRefMode == URM_INSDEL && nDz == 1 ); +/*N*/ BOOL bDeleteTab = ( eUpdateRefMode == URM_INSDEL && nDz == -1 ); +/*N*/ +/*N*/ BOOL bChanged1 = FALSE; +/*N*/ BOOL bChanged2 = FALSE; +/*N*/ +/*N*/ if (pFormula1) +/*N*/ { +/*N*/ if ( bInsertTab ) +/*N*/ lcl_CondUpdateInsertTab( *pFormula1, rRange.aStart.Tab(), aSrcPos.Tab(), bChanged1 ); +/*N*/ else +/*N*/ { +/*?*/ ScCompiler aComp( pDoc, aSrcPos, *pFormula1 ); +/*?*/ if ( bDeleteTab ) +/*?*/ aComp.UpdateDeleteTab( rRange.aStart.Tab(), FALSE, TRUE, bChanged1 ); +/*?*/ else +/*?*/ aComp.UpdateNameReference( eUpdateRefMode, rRange, nDx, nDy, nDz, bChanged1 ); +/*N*/ } +/*N*/ +/*N*/ if (bChanged1) +/*?*/ DELETEZ(pFCell1); // is created again in IsValid +/*N*/ } +/*N*/ if (pFormula2) +/*N*/ { +/*?*/ if ( bInsertTab ) +/*?*/ lcl_CondUpdateInsertTab( *pFormula2, rRange.aStart.Tab(), aSrcPos.Tab(), bChanged2 ); +/*?*/ else +/*?*/ { +/*?*/ ScCompiler aComp( pDoc, aSrcPos, *pFormula2 ); +/*?*/ if ( bDeleteTab ) +/*?*/ aComp.UpdateDeleteTab( rRange.aStart.Tab(), FALSE, TRUE, bChanged2 ); +/*?*/ else +/*?*/ aComp.UpdateNameReference( eUpdateRefMode, rRange, nDx, nDy, nDz, bChanged2 ); +/*?*/ } +/*?*/ +/*?*/ if (bChanged2) +/*?*/ DELETEZ(pFCell2); // is created again in IsValid +/*N*/ } +/*N*/ } + + +//! als Vergleichsoperator ans TokenArray ??? + +/*N*/ BOOL lcl_IsEqual( const ScTokenArray* pArr1, const ScTokenArray* pArr2 ) +/*N*/ { +/*N*/ // verglichen wird nur das nicht-UPN Array +/*N*/ +/*N*/ if ( pArr1 && pArr2 ) +/*N*/ { +/*N*/ USHORT nLen = pArr1->GetLen(); +/*N*/ if ( pArr2->GetLen() != nLen ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ScToken** ppToken1 = pArr1->GetArray(); +/*N*/ ScToken** ppToken2 = pArr2->GetArray(); +/*N*/ for (USHORT i=0; i<nLen; i++) +/*N*/ { +/*N*/ if ( ppToken1[i] != ppToken2[i] && +/*N*/ !(*ppToken1[i] == *ppToken2[i]) ) +/*N*/ return FALSE; // Unterschied +/*N*/ } +/*N*/ return TRUE; // alle Eintraege gleich +/*N*/ } +/*N*/ else +/*N*/ return !pArr1 && !pArr2; // beide 0 -> gleich +/*N*/ } + +/*N*/ int ScConditionEntry::operator== ( const ScConditionEntry& r ) const +/*N*/ { +/*N*/ BOOL bEq = (eOp == r.eOp && nOptions == r.nOptions && +/*N*/ lcl_IsEqual( pFormula1, r.pFormula1 ) && +/*N*/ lcl_IsEqual( pFormula2, r.pFormula2 )); +/*N*/ if (bEq) +/*N*/ { +/*N*/ // bei Formeln auch die Referenz-Tabelle vergleichen +/*N*/ if ( ( pFormula1 || pFormula2 ) && aSrcPos != r.aSrcPos ) +/*N*/ bEq = FALSE; +/*N*/ +/*N*/ // wenn keine Formeln, Werte vergleichen +/*N*/ if ( !pFormula1 && ( nVal1 != r.nVal1 || aStrVal1 != r.aStrVal1 || bIsStr1 != r.bIsStr1 ) ) +/*N*/ bEq = FALSE; +/*N*/ if ( !pFormula2 && ( nVal2 != r.nVal2 || aStrVal2 != r.aStrVal2 || bIsStr2 != r.bIsStr2 ) ) +/*N*/ bEq = FALSE; +/*N*/ } +/*N*/ +/*N*/ return bEq; +/*N*/ } + +/*N*/ void ScConditionEntry::Interpret( const ScAddress& rPos ) +/*N*/ { +/*N*/ // Formelzellen anlegen +/*N*/ // dabei koennen neue Broadcaster (Note-Zellen) ins Dokument eingefuegt werden !!!! +/*N*/ +/*N*/ if ( ( pFormula1 && !pFCell1 ) || ( pFormula2 && !pFCell2 ) ) +/*N*/ MakeCells( rPos ); +/*N*/ +/*N*/ // Formeln auswerten +/*N*/ +/*N*/ BOOL bDirty = FALSE; //! 1 und 2 getrennt ??? +/*N*/ +/*N*/ ScFormulaCell* pTemp1 = NULL; +/*N*/ ScFormulaCell* pEff1 = pFCell1; +/*N*/ if ( bRelRef1 ) +/*N*/ { +/*N*/ pTemp1 = new ScFormulaCell( pDoc, rPos, pFormula1 ); // ohne Listening +/*N*/ pEff1 = pTemp1; +/*N*/ } +/*N*/ if ( pEff1 ) +/*N*/ { +/*N*/ if (!pEff1->IsRunning()) // keine 522 erzeugen +/*N*/ { +/*N*/ //! Changed statt Dirty abfragen !!! +/*N*/ if (pEff1->GetDirty() && !bRelRef1) +/*N*/ bDirty = TRUE; +/*N*/ if (pEff1->IsValue()) +/*N*/ { +/*N*/ bIsStr1 = FALSE; +/*N*/ nVal1 = pEff1->GetValue(); +/*N*/ aStrVal1.Erase(); +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ bIsStr1 = TRUE; +/*?*/ pEff1->GetString( aStrVal1 ); +/*?*/ nVal1 = 0.0; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ delete pTemp1; +/*N*/ +/*N*/ ScFormulaCell* pTemp2 = NULL; +/*N*/ ScFormulaCell* pEff2 = pFCell2; //@ 1!=2 +/*N*/ if ( bRelRef2 ) +/*N*/ { +/*N*/ pTemp2 = new ScFormulaCell( pDoc, rPos, pFormula2 ); // ohne Listening +/*N*/ pEff2 = pTemp2; +/*N*/ } +/*N*/ if ( pEff2 ) +/*N*/ { +/*N*/ if (!pEff2->IsRunning()) // keine 522 erzeugen +/*N*/ { +/*N*/ if (pEff2->GetDirty() && !bRelRef2) +/*N*/ bDirty = TRUE; +/*N*/ if (pEff2->IsValue()) +/*N*/ { +/*N*/ bIsStr2 = FALSE; +/*N*/ nVal2 = pEff2->GetValue(); +/*N*/ aStrVal2.Erase(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bIsStr2 = TRUE; +/*N*/ pEff2->GetString( aStrVal2 ); +/*N*/ nVal2 = 0.0; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ delete pTemp2; +/*N*/ +/*N*/ // wenn IsRunning, bleiben die letzten Werte erhalten +/*N*/ +/*N*/ if (bDirty && !bFirstRun) +/*N*/ { +/*N*/ // bei bedingten Formaten neu painten +/*N*/ +/*N*/ DataChanged( NULL ); // alles +/*N*/ } +/*N*/ +/*N*/ bFirstRun = FALSE; +/*N*/ } + +/*N*/ BOOL ScConditionEntry::IsValid( double nArg ) const +/*N*/ { +/*N*/ // Interpret muss schon gerufen sein +/*N*/ +/*N*/ if ( bIsStr1 ) +/*N*/ { +/*N*/ // wenn auf String getestet wird, bei Zahlen immer FALSE, ausser bei "ungleich" +/*N*/ +/*N*/ return ( eOp == SC_COND_NOTEQUAL ); +/*N*/ } +/*N*/ +/*N*/ if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN ) +/*N*/ if ( bIsStr2 ) +/*N*/ return FALSE; +/*N*/ +/*N*/ double nComp1 = nVal1; // Kopie, damit vertauscht werden kann +/*N*/ double nComp2 = nVal2; +/*N*/ +/*N*/ if ( eOp == SC_COND_BETWEEN || eOp == SC_COND_NOTBETWEEN ) +/*N*/ if ( nComp1 > nComp2 ) +/*N*/ { +/*N*/ // richtige Reihenfolge fuer Wertebereich +/*N*/ double nTemp = nComp1; nComp1 = nComp2; nComp2 = nTemp; +/*N*/ } +/*N*/ +/*N*/ // Alle Grenzfaelle muessen per ::rtl::math::approxEqual getestet werden! +/*N*/ +/*N*/ BOOL bValid = FALSE; +/*N*/ switch (eOp) +/*N*/ { +/*?*/ case SC_COND_NONE: +/*?*/ break; // immer FALSE; +/*?*/ case SC_COND_EQUAL: +/*?*/ bValid = ::rtl::math::approxEqual( nArg, nComp1 ); +/*?*/ break; +/*?*/ case SC_COND_NOTEQUAL: +/*?*/ bValid = !::rtl::math::approxEqual( nArg, nComp1 ); +/*?*/ break; +/*?*/ case SC_COND_GREATER: +/*?*/ bValid = ( nArg > nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 ); +/*?*/ break; +/*?*/ case SC_COND_EQGREATER: +/*?*/ bValid = ( nArg >= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 ); +/*?*/ break; +/*?*/ case SC_COND_LESS: +/*?*/ bValid = ( nArg < nComp1 ) && !::rtl::math::approxEqual( nArg, nComp1 ); +/*?*/ break; +/*?*/ case SC_COND_EQLESS: +/*?*/ bValid = ( nArg <= nComp1 ) || ::rtl::math::approxEqual( nArg, nComp1 ); +/*?*/ break; +/*?*/ case SC_COND_BETWEEN: +/*?*/ bValid = ( nArg >= nComp1 && nArg <= nComp2 ) || +/*?*/ ::rtl::math::approxEqual( nArg, nComp1 ) || ::rtl::math::approxEqual( nArg, nComp2 ); +/*?*/ break; +/*?*/ case SC_COND_NOTBETWEEN: +/*?*/ bValid = ( nArg < nComp1 || nArg > nComp2 ) && +/*?*/ !::rtl::math::approxEqual( nArg, nComp1 ) && !::rtl::math::approxEqual( nArg, nComp2 ); +/*?*/ break; +/*N*/ case SC_COND_DIRECT: +/*N*/ bValid = !::rtl::math::approxEqual( nComp1, 0.0 ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR("unbekannte Operation bei ScConditionEntry"); +/*N*/ break; +/*N*/ } +/*N*/ return bValid; +/*N*/ } + + +/*N*/ BOOL ScConditionEntry::IsCellValid( ScBaseCell* pCell, const ScAddress& rPos ) const +/*N*/ { +/*N*/ ((ScConditionEntry*)this)->Interpret(rPos); // Formeln auswerten +/*N*/ +/*N*/ double nArg = 0.0; +/*N*/ String aArgStr; +/*N*/ BOOL bVal = TRUE; +/*N*/ +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ switch (eType) +/*N*/ { +/*?*/ case CELLTYPE_VALUE: +/*?*/ nArg = ((ScValueCell*)pCell)->GetValue(); +/*?*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ bVal = pFCell->IsValue(); +/*N*/ if (bVal) +/*N*/ nArg = pFCell->GetValue(); +/*N*/ else +/*?*/ pFCell->GetString(aArgStr); +/*N*/ } +/*N*/ break; +/*?*/ case CELLTYPE_STRING: +/*?*/ case CELLTYPE_EDIT: +/*?*/ bVal = FALSE; +/*?*/ if ( eType == CELLTYPE_STRING ) +/*?*/ ((ScStringCell*)pCell)->GetString(aArgStr); +/*?*/ else +/*?*/ ((ScEditCell*)pCell)->GetString(aArgStr); +/*?*/ break; +/*N*/ +/*N*/ default: +/*N*/ pCell = NULL; // Note-Zellen wie leere +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!pCell) +/*N*/ if (bIsStr1) +/*N*/ bVal = FALSE; // leere Zellen je nach Bedingung +/*N*/ +/*N*/ if (bVal) +/*N*/ return IsValid( nArg ); +/*N*/ else +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return FALSE;} //STRIP001 return IsValidStr( aArgStr ); +/*N*/ } + +/*N*/ String ScConditionEntry::GetExpression( const ScAddress& rCursor, USHORT nIndex, +/*N*/ ULONG nNumFmt, BOOL bEnglish, +/*N*/ BOOL bCompileXML, BOOL bTextToReal ) const +/*N*/ { +/*N*/ String aRet; +/*N*/ +/*N*/ if ( bEnglish && nNumFmt == 0 ) +/*N*/ nNumFmt = pDoc->GetFormatTable()->GetStandardIndex( LANGUAGE_ENGLISH_US ); +/*N*/ +/*N*/ if ( nIndex==0 ) +/*N*/ { +/*N*/ if ( pFormula1 ) +/*N*/ { +/*N*/ ScCompiler aComp(pDoc, rCursor, *pFormula1); +/*N*/ aComp.SetCompileEnglish( bEnglish ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ aComp.SetImportXML( bTextToReal ); // set only from CompileXML method +/*N*/ aComp.CreateStringFromTokenArray( aRet ); +/*N*/ } +/*N*/ else if (bIsStr1) +/*N*/ { +/*N*/ aRet = '"'; +/*N*/ aRet += aStrVal1; +/*N*/ aRet += '"'; +/*N*/ } +/*N*/ else +/*?*/ pDoc->GetFormatTable()->GetInputLineString(nVal1, nNumFmt, aRet); +/*N*/ } +/*N*/ else if ( nIndex==1 ) +/*N*/ { +/*N*/ if ( pFormula2 ) +/*N*/ { +/*?*/ ScCompiler aComp(pDoc, rCursor, *pFormula2); +/*?*/ aComp.SetCompileEnglish( bEnglish ); +/*?*/ aComp.SetCompileXML( bCompileXML ); +/*M*/ aComp.SetImportXML( bTextToReal ); // set only from CompileXML method +/*?*/ aComp.CreateStringFromTokenArray( aRet ); +/*N*/ } +/*N*/ else if (bIsStr2) +/*N*/ { +/*N*/ aRet = '"'; +/*N*/ aRet += aStrVal2; +/*N*/ aRet += '"'; +/*N*/ } +/*N*/ else +/*N*/ pDoc->GetFormatTable()->GetInputLineString(nVal2, nNumFmt, aRet); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("GetExpression: falscher Index"); +/*N*/ +/*N*/ return aRet; +/*N*/ } + + +/*N*/ void ScConditionEntry::SourceChanged( const ScAddress& rChanged ) +/*N*/ { +/*N*/ for (USHORT nPass = 0; nPass < 2; nPass++) +/*N*/ { +/*N*/ ScTokenArray* pFormula = nPass ? pFormula2 : pFormula1; +/*N*/ if (pFormula) +/*N*/ { +/*N*/ pFormula->Reset(); +/*N*/ ScToken* t; +/*N*/ for( t = pFormula->GetNextReference(); t; t = pFormula->GetNextReference() ) +/*N*/ { +/*N*/ SingleDoubleRefProvider aProv( *t ); +/*N*/ if ( aProv.Ref1.IsColRel() || aProv.Ref1.IsRowRel() || aProv.Ref1.IsTabRel() || +/*N*/ aProv.Ref2.IsColRel() || aProv.Ref2.IsRowRel() || aProv.Ref2.IsTabRel() ) +/*N*/ { +/*N*/ // absolut muss getroffen sein, relativ bestimmt Bereich +/*N*/ +/*N*/ BOOL bHit = TRUE; +/*N*/ INT16 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ +/*N*/ if ( aProv.Ref1.IsColRel() ) +/*N*/ nCol2 = rChanged.Col() - aProv.Ref1.nRelCol; +/*N*/ else +/*N*/ { +/*N*/ bHit &= ( rChanged.Col() >= aProv.Ref1.nCol ); +/*N*/ nCol2 = MAXCOL; +/*N*/ } +/*N*/ if ( aProv.Ref1.IsRowRel() ) +/*N*/ nRow2 = rChanged.Row() - aProv.Ref1.nRelRow; +/*N*/ else +/*N*/ { +/*N*/ bHit &= ( rChanged.Row() >= aProv.Ref1.nRow ); +/*N*/ nRow2 = MAXROW; +/*N*/ } +/*N*/ if ( aProv.Ref1.IsTabRel() ) +/*N*/ nTab2 = rChanged.Tab() - aProv.Ref1.nRelTab; +/*N*/ else +/*N*/ { +/*N*/ bHit &= ( rChanged.Tab() >= aProv.Ref1.nTab ); +/*N*/ nTab2 = MAXTAB; +/*N*/ } +/*N*/ +/*N*/ if ( aProv.Ref2.IsColRel() ) +/*N*/ nCol1 = rChanged.Col() - aProv.Ref2.nRelCol; +/*N*/ else +/*N*/ { +/*N*/ bHit &= ( rChanged.Col() <= aProv.Ref2.nCol ); +/*N*/ nCol1 = 0; +/*N*/ } +/*N*/ if ( aProv.Ref2.IsRowRel() ) +/*N*/ nRow1 = rChanged.Row() - aProv.Ref2.nRelRow; +/*N*/ else +/*N*/ { +/*N*/ bHit &= ( rChanged.Row() <= aProv.Ref2.nRow ); +/*N*/ nRow1 = 0; +/*N*/ } +/*N*/ if ( aProv.Ref2.IsTabRel() ) +/*N*/ nTab1 = rChanged.Tab() - aProv.Ref2.nRelTab; +/*N*/ else +/*N*/ { +/*N*/ bHit &= ( rChanged.Tab() <= aProv.Ref2.nTab ); +/*N*/ nTab1 = 0; +/*N*/ } +/*N*/ +/*N*/ if ( bHit ) +/*N*/ { +/*N*/ //! begrenzen +/*N*/ +/*N*/ ScRange aPaint( nCol1,nRow1,nTab1, nCol2,nRow2,nTab2 ); +/*N*/ +/*N*/ // kein Paint, wenn es nur die Zelle selber ist +/*N*/ if ( aPaint.aStart != rChanged || aPaint.aEnd != rChanged ) +/*N*/ DataChanged( &aPaint ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionEntry::DataChanged( const ScRange* pModified ) const +/*N*/ { +/*N*/ // nix +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScCondFormatEntry::ScCondFormatEntry( ScConditionMode eOper, +/*N*/ const String& rExpr1, const String& rExpr2, +/*N*/ ScDocument* pDocument, const ScAddress& rPos, +/*N*/ const String& rStyle, +/*N*/ BOOL bCompileEnglish, BOOL bCompileXML ) : +/*N*/ ScConditionEntry( eOper, rExpr1, rExpr2, pDocument, rPos, bCompileEnglish, bCompileXML ), +/*N*/ aStyleName( rStyle ), +/*N*/ pParent( NULL ) +/*N*/ { +/*N*/ } + +/*N*/ ScCondFormatEntry::ScCondFormatEntry( const ScCondFormatEntry& r ) : +/*N*/ ScConditionEntry( r ), +/*N*/ aStyleName( r.aStyleName ), +/*N*/ pParent( NULL ) +/*N*/ { +/*N*/ } + +/*N*/ ScCondFormatEntry::ScCondFormatEntry( ScDocument* pDocument, const ScCondFormatEntry& r ) : +/*N*/ ScConditionEntry( pDocument, r ), +/*N*/ aStyleName( r.aStyleName ), +/*N*/ pParent( NULL ) +/*N*/ { +/*N*/ } + +/*N*/ ScCondFormatEntry::ScCondFormatEntry( SvStream& rStream, ScMultipleReadHeader& rHdr, +/*N*/ ScDocument* pDocument ) : +/*N*/ ScConditionEntry( rStream, rHdr, pDocument ), +/*N*/ pParent( NULL ) +/*N*/ { +/*N*/ // im Datei-Header sind getrennte Eintraege fuer ScConditionEntry und ScCondFormatEntry +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ rStream.ReadByteString( aStyleName, rStream.GetStreamCharSet() ); +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ void ScCondFormatEntry::Store(SvStream& rStream, ScMultipleWriteHeader& rHdr) const +/*N*/ { +/*N*/ // im Datei-Header sind getrennte Eintraege fuer ScConditionEntry und ScCondFormatEntry +/*N*/ +/*N*/ StoreCondition( rStream, rHdr ); +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ rStream.WriteByteString( aStyleName, rStream.GetStreamCharSet() ); +/*N*/ rHdr.EndEntry(); +/*N*/ } + + +/*N*/ int ScCondFormatEntry::operator== ( const ScCondFormatEntry& r ) const +/*N*/ { +/*N*/ return ScConditionEntry::operator==( r ) && +/*N*/ aStyleName == r.aStyleName; +/*N*/ +/*N*/ // Range wird nicht verglichen +/*N*/ } + +/*N*/ ScCondFormatEntry::~ScCondFormatEntry() +/*N*/ { +/*N*/ } + +/*N*/ void ScCondFormatEntry::DataChanged( const ScRange* pModified ) const +/*N*/ { +/*N*/ if ( pParent ) +/*N*/ pParent->DoRepaint( pModified ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScConditionalFormat::ScConditionalFormat(sal_uInt32 nNewKey, ScDocument* pDocument) : +/*N*/ pDoc( pDocument ), +/*N*/ pAreas( NULL ), +/*N*/ nKey( nNewKey ), +/*N*/ ppEntries( NULL ), +/*N*/ nEntryCount( 0 ) +/*N*/ { +/*N*/ } + +/*N*/ ScConditionalFormat::ScConditionalFormat(const ScConditionalFormat& r) : +/*N*/ pDoc( r.pDoc ), +/*N*/ pAreas( NULL ), +/*N*/ nKey( r.nKey ), +/*N*/ ppEntries( NULL ), +/*N*/ nEntryCount( r.nEntryCount ) +/*N*/ { +/*N*/ if (nEntryCount) +/*N*/ { +/*N*/ ppEntries = new ScCondFormatEntry*[nEntryCount]; +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ { +/*N*/ ppEntries[i] = new ScCondFormatEntry(*r.ppEntries[i]); +/*N*/ ppEntries[i]->SetParent(this); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ ScConditionalFormat* ScConditionalFormat::Clone(ScDocument* pNewDoc) const +/*N*/ { +/*N*/ // echte Kopie der Formeln (fuer Ref-Undo / zwischen Dokumenten) +/*N*/ +/*N*/ if (!pNewDoc) +/*N*/ pNewDoc = pDoc; +/*N*/ +/*N*/ ScConditionalFormat* pNew = new ScConditionalFormat(nKey, pNewDoc); +/*N*/ DBG_ASSERT(!pNew->ppEntries, "wo kommen die Eintraege her?"); +/*N*/ +/*N*/ if (nEntryCount) +/*N*/ { +/*N*/ pNew->ppEntries = new ScCondFormatEntry*[nEntryCount]; +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ { +/*N*/ pNew->ppEntries[i] = new ScCondFormatEntry( pNewDoc, *ppEntries[i] ); +/*N*/ pNew->ppEntries[i]->SetParent(pNew); +/*N*/ } +/*N*/ pNew->nEntryCount = nEntryCount; +/*N*/ } +/*N*/ +/*N*/ return pNew; +/*N*/ } + +/*N*/ ScConditionalFormat::ScConditionalFormat(SvStream& rStream, ScMultipleReadHeader& rHdr, +/*N*/ ScDocument* pDocument) : +/*N*/ pDoc( pDocument ), +/*N*/ pAreas( NULL ), +/*N*/ ppEntries( NULL ), +/*N*/ nEntryCount( 0 ) +/*N*/ { +/*N*/ // ein Eintrag im Header fuer die ScConditionalFormat-Daten, +/*N*/ // je zwei Eintraege fuer jede Bedingung (ScConditionEntry und ScCondFormatEntry) +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream >> nKey; +/*N*/ rStream >> nEntryCount; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ // Eintraege laden +/*N*/ +/*N*/ if (nEntryCount) +/*N*/ { +/*N*/ ppEntries = new ScCondFormatEntry*[nEntryCount]; +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ { +/*N*/ ppEntries[i] = new ScCondFormatEntry(rStream, rHdr, pDocument); +/*N*/ ppEntries[i]->SetParent(this); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionalFormat::Store(SvStream& rStream, ScMultipleWriteHeader& rHdr) const +/*N*/ { +/*N*/ // ein Eintrag im Header fuer die ScConditionalFormat-Daten, +/*N*/ // je zwei Eintraege fuer jede Bedingung (ScConditionEntry und ScCondFormatEntry) +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream << nKey; +/*N*/ rStream << nEntryCount; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ // Eintraege speichern +/*N*/ +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ ppEntries[i]->Store(rStream, rHdr); +/*N*/ } + +/*N*/ BOOL ScConditionalFormat::EqualEntries( const ScConditionalFormat& r ) const +/*N*/ { +/*N*/ if ( nEntryCount != r.nEntryCount ) +/*N*/ return FALSE; +/*N*/ +/*N*/ //! auf gleiche Eintraege in anderer Reihenfolge testen ??? +/*N*/ +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ if ( ! (*ppEntries[i] == *r.ppEntries[i]) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +/*N*/ void ScConditionalFormat::AddEntry( const ScCondFormatEntry& rNew ) +/*N*/ { +/*N*/ ScCondFormatEntry** ppNew = new ScCondFormatEntry*[nEntryCount+1]; +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ ppNew[i] = ppEntries[i]; +/*N*/ ppNew[nEntryCount] = new ScCondFormatEntry(rNew); +/*N*/ ppNew[nEntryCount]->SetParent(this); +/*N*/ ++nEntryCount; +/*N*/ delete[] ppEntries; +/*N*/ ppEntries = ppNew; +/*N*/ } + +/*N*/ ScConditionalFormat::~ScConditionalFormat() +/*N*/ { +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ delete ppEntries[i]; +/*N*/ delete[] ppEntries; +/*N*/ +/*N*/ delete pAreas; +/*N*/ } + +/*N*/ const ScCondFormatEntry* ScConditionalFormat::GetEntry( USHORT nPos ) const +/*N*/ { +/*N*/ if ( nPos < nEntryCount ) +/*N*/ return ppEntries[nPos]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ const String& ScConditionalFormat::GetCellStyle( ScBaseCell* pCell, const ScAddress& rPos ) const +/*N*/ { +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ if ( ppEntries[i]->IsCellValid( pCell, rPos ) ) +/*N*/ return ppEntries[i]->GetStyle(); +/*N*/ +/*N*/ return EMPTY_STRING; +/*N*/ } + +/*N*/ void lcl_Extend( ScRange& rRange, ScDocument* pDoc, BOOL bLines ) +/*N*/ { +/*N*/ USHORT nTab = rRange.aStart.Tab(); +/*N*/ DBG_ASSERT(rRange.aEnd.Tab() == nTab, "lcl_Extend - mehrere Tabellen?"); +/*N*/ +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ +/*N*/ BOOL bEx = pDoc->ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab ); +/*N*/ +/*N*/ if (bLines) +/*N*/ { +/*N*/ if (nStartCol > 0) --nStartCol; +/*N*/ if (nStartRow > 0) --nStartRow; +/*N*/ if (nEndCol < MAXCOL) ++nEndCol; +/*N*/ if (nEndRow < MAXROW) ++nEndRow; +/*N*/ } +/*N*/ +/*N*/ if ( bEx || bLines ) +/*N*/ { +/*N*/ rRange.aStart.Set( nStartCol, nStartRow, nTab ); +/*N*/ rRange.aEnd.Set( nEndCol, nEndRow, nTab ); +/*N*/ } +/*N*/ } + +/*N*/ BOOL lcl_CutRange( ScRange& rRange, const ScRange& rOther ) +/*N*/ { +/*N*/ rRange.Justify(); +/*N*/ ScRange aCmpRange = rOther; +/*N*/ aCmpRange.Justify(); +/*N*/ +/*N*/ if ( rRange.aStart.Col() <= aCmpRange.aEnd.Col() && +/*N*/ rRange.aEnd.Col() >= aCmpRange.aStart.Col() && +/*N*/ rRange.aStart.Row() <= aCmpRange.aEnd.Row() && +/*N*/ rRange.aEnd.Row() >= aCmpRange.aStart.Row() && +/*N*/ rRange.aStart.Tab() <= aCmpRange.aEnd.Tab() && +/*N*/ rRange.aEnd.Tab() >= aCmpRange.aStart.Tab() ) +/*N*/ { +/*N*/ if ( rRange.aStart.Col() < aCmpRange.aStart.Col() ) +/*N*/ rRange.aStart.SetCol( aCmpRange.aStart.Col() ); +/*N*/ if ( rRange.aStart.Row() < aCmpRange.aStart.Row() ) +/*N*/ rRange.aStart.SetRow( aCmpRange.aStart.Row() ); +/*N*/ if ( rRange.aStart.Tab() < aCmpRange.aStart.Tab() ) +/*N*/ rRange.aStart.SetTab( aCmpRange.aStart.Tab() ); +/*N*/ if ( rRange.aEnd.Col() > aCmpRange.aEnd.Col() ) +/*N*/ rRange.aEnd.SetCol( aCmpRange.aEnd.Col() ); +/*N*/ if ( rRange.aEnd.Row() > aCmpRange.aEnd.Row() ) +/*N*/ rRange.aEnd.SetRow( aCmpRange.aEnd.Row() ); +/*N*/ if ( rRange.aEnd.Tab() > aCmpRange.aEnd.Tab() ) +/*N*/ rRange.aEnd.SetTab( aCmpRange.aEnd.Tab() ); +/*N*/ +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ return FALSE; // ausserhalb +/*N*/ } + +/*N*/ void ScConditionalFormat::DoRepaint( const ScRange* pModified ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ SfxObjectShell* pSh = pDoc->GetDocumentShell(); +/*N*/ if (pSh) +/*N*/ { +/*N*/ // Rahmen/Schatten enthalten? +/*N*/ // (alle Bedingungen testen) +/*N*/ BOOL bExtend = FALSE; +/*N*/ BOOL bRotate = FALSE; +/*N*/ for (i=0; i<nEntryCount; i++) +/*N*/ { +/*N*/ String aStyle = ppEntries[i]->GetStyle(); +/*N*/ if (aStyle.Len()) +/*N*/ { +/*N*/ SfxStyleSheetBase* pStyleSheet = +/*N*/ pDoc->GetStyleSheetPool()->Find( aStyle, SFX_STYLE_FAMILY_PARA ); +/*N*/ if ( pStyleSheet ) +/*N*/ { +/*N*/ const SfxItemSet& rSet = pStyleSheet->GetItemSet(); +/*N*/ if (rSet.GetItemState( ATTR_BORDER, TRUE ) == SFX_ITEM_SET || +/*N*/ rSet.GetItemState( ATTR_SHADOW, TRUE ) == SFX_ITEM_SET) +/*N*/ { +/*N*/ bExtend = TRUE; +/*N*/ } +/*N*/ if (rSet.GetItemState( ATTR_ROTATE_VALUE, TRUE ) == SFX_ITEM_SET || +/*N*/ rSet.GetItemState( ATTR_ROTATE_MODE, TRUE ) == SFX_ITEM_SET) +/*N*/ { +/*N*/ bRotate = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!pAreas) // RangeList ggf. holen +/*N*/ { +/*N*/ pAreas = new ScRangeList; +/*N*/ pDoc->FindConditionalFormat( nKey, *pAreas ); +/*N*/ } +/*N*/ USHORT nCount = (USHORT) pAreas->Count(); +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScRange aRange = *pAreas->GetObject(i); +/*N*/ BOOL bDo = TRUE; +/*N*/ if ( pModified ) +/*N*/ { +/*N*/ if ( !lcl_CutRange( aRange, *pModified ) ) +/*N*/ bDo = FALSE; +/*N*/ } +/*N*/ if (bDo) +/*N*/ { +/*N*/ lcl_Extend( aRange, pDoc, bExtend ); // zusammengefasste und bExtend +/*N*/ if ( bRotate ) +/*N*/ { +/*?*/ aRange.aStart.SetCol(0); +/*?*/ aRange.aEnd.SetCol(MAXCOL); // gedreht: ganze Zeilen +/*N*/ } +/*N*/ +/*N*/ // gedreht -> ganze Zeilen +/*N*/ if ( aRange.aStart.Col() != 0 || aRange.aEnd.Col() != MAXCOL ) +/*N*/ { +/*N*/ if ( pDoc->HasAttrib( 0,aRange.aStart.Row(),aRange.aStart.Tab(), +/*N*/ MAXCOL,aRange.aEnd.Row(),aRange.aEnd.Tab(), +/*N*/ HASATTR_ROTATE ) ) +/*N*/ { +/*?*/ aRange.aStart.SetCol(0); +/*?*/ aRange.aEnd.SetCol(MAXCOL); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pSh->Broadcast( ScPaintHint( aRange, PAINT_GRID ) ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionalFormat::InvalidateArea() +/*N*/ { +/*N*/ delete pAreas; +/*N*/ pAreas = NULL; +/*N*/ } + + +/*N*/ void ScConditionalFormat::CompileXML() +/*N*/ { +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ ppEntries[i]->CompileXML(); +/*N*/ } + +/*N*/ void ScConditionalFormat::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ ppEntries[i]->UpdateReference(eUpdateRefMode, rRange, nDx, nDy, nDz); +/*N*/ +/*N*/ delete pAreas; // aus dem AttrArray kommt beim Einfuegen/Loeschen kein Aufruf +/*N*/ pAreas = NULL; +/*N*/ } + + +/*N*/ void ScConditionalFormat::SourceChanged( const ScAddress& rAddr ) +/*N*/ { +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ ppEntries[i]->SourceChanged( rAddr ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScConditionalFormatList::ScConditionalFormatList(const ScConditionalFormatList& rList) +/*N*/ { +/*N*/ // fuer Ref-Undo - echte Kopie mit neuen Tokens! +/*N*/ +/*N*/ USHORT nCount = rList.Count(); +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ InsertNew( rList[i]->Clone() ); +/*N*/ +/*N*/ //! sortierte Eintraege aus rList schneller einfuegen ??? +/*N*/ } + +/*N*/ void ScConditionalFormatList::Load( SvStream& rStream, ScDocument* pDocument ) +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ +/*N*/ for (USHORT i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ ScConditionalFormat* pNew = new ScConditionalFormat( rStream, aHdr, pDocument ); +/*N*/ InsertNew( pNew ); +/*N*/ } +/*N*/ } + +/*N*/ void ScConditionalFormatList::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ USHORT i; +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nCount = Count(); +/*N*/ USHORT nUsed = 0; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ((*this)[i]->IsUsed()) +/*N*/ ++nUsed; +/*N*/ +/*N*/ rStream << nUsed; // Anzahl der gespeicherten +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScConditionalFormat* pForm = (*this)[i]; +/*N*/ if (pForm->IsUsed()) +/*N*/ pForm->Store( rStream, aHdr ); +/*N*/ } +/*N*/ } + +/*N*/ ScConditionalFormat* ScConditionalFormatList::GetFormat( sal_uInt32 nKey ) +/*N*/ { +/*N*/ //! binaer suchen +/*N*/ +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ if ((*this)[i]->GetKey() == nKey) +/*N*/ return (*this)[i]; +/*N*/ +/*N*/ DBG_ERROR("ScConditionalFormatList: Eintrag nicht gefunden"); +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScConditionalFormatList::ResetUsed() +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ (*this)[i]->SetUsed(FALSE); +/*N*/ } + + +/*N*/ void ScConditionalFormatList::CompileXML() +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ (*this)[i]->CompileXML(); +/*N*/ } + +/*N*/ void ScConditionalFormatList::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ (*this)[i]->UpdateReference( eUpdateRefMode, rRange, nDx, nDy, nDz ); +/*N*/ } + + +/*N*/ void ScConditionalFormatList::SourceChanged( const ScAddress& rAddr ) +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ (*this)[i]->SourceChanged( rAddr ); +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dbdocutl.cxx b/binfilter/bf_sc/source/core/data/sc_dbdocutl.cxx new file mode 100644 index 000000000000..35b9bcc4e5f0 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dbdocutl.cxx @@ -0,0 +1,195 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// INCLUDE --------------------------------------------------------------- + +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/sdbc/XRow.hpp> + +#include <bf_svtools/zforlist.hxx> + +#include "dbdocutl.hxx" +#include "document.hxx" +#include "cell.hxx" +namespace binfilter { + +using namespace ::com::sun::star; + +#define D_TIMEFACTOR 86400.0 + +// ----------------------------------------------------------------------- + +// static +/*N*/ void ScDatabaseDocUtil::PutData( ScDocument* pDoc, USHORT nCol, USHORT nRow, USHORT nTab, +/*N*/ const uno::Reference<sdbc::XRow>& xRow, long nRowPos, +/*N*/ long nType, BOOL bCurrency, BOOL* pSimpleFlag ) +/*N*/ { +/*N*/ String aString; +/*N*/ double nVal = 0.0; +/*N*/ BOOL bValue = FALSE; +/*N*/ BOOL bEmptyFlag = FALSE; +/*N*/ BOOL bError = FALSE; +/*N*/ ULONG nFormatIndex = 0; +/*N*/ +/*N*/ //! wasNull calls only if null value was found? +/*N*/ +/*N*/ try +/*N*/ { +/*N*/ switch ( nType ) +/*N*/ { +/*N*/ case sdbc::DataType::BIT: +/*N*/ //! use language from doc (here, date/time and currency)? +/*N*/ nFormatIndex = pDoc->GetFormatTable()->GetStandardFormat( +/*N*/ NUMBERFORMAT_LOGICAL, ScGlobal::eLnge ); +/*N*/ nVal = (xRow->getBoolean(nRowPos) ? 1 : 0); +/*N*/ bEmptyFlag = ( nVal == 0.0 ) && xRow->wasNull(); +/*N*/ bValue = TRUE; +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::TINYINT: +/*N*/ case sdbc::DataType::SMALLINT: +/*N*/ case sdbc::DataType::INTEGER: +/*N*/ case sdbc::DataType::BIGINT: +/*N*/ case sdbc::DataType::FLOAT: +/*N*/ case sdbc::DataType::REAL: +/*N*/ case sdbc::DataType::DOUBLE: +/*N*/ case sdbc::DataType::NUMERIC: +/*N*/ case sdbc::DataType::DECIMAL: +/*N*/ //! do the conversion here? +/*N*/ nVal = xRow->getDouble(nRowPos); +/*N*/ bEmptyFlag = ( nVal == 0.0 ) && xRow->wasNull(); +/*N*/ bValue = TRUE; +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::CHAR: +/*N*/ case sdbc::DataType::VARCHAR: +/*N*/ case sdbc::DataType::LONGVARCHAR: +/*N*/ aString = xRow->getString(nRowPos); +/*N*/ bEmptyFlag = ( aString.Len() == 0 ) && xRow->wasNull(); +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::DATE: +/*N*/ { +/*N*/ SvNumberFormatter* pFormTable = pDoc->GetFormatTable(); +/*N*/ nFormatIndex = pFormTable->GetStandardFormat( +/*N*/ NUMBERFORMAT_DATE, ScGlobal::eLnge ); +/*N*/ +/*N*/ util::Date aDate = xRow->getDate(nRowPos); +/*N*/ nVal = Date( aDate.Day, aDate.Month, aDate.Year ) - +/*N*/ *pFormTable->GetNullDate(); +/*N*/ bEmptyFlag = xRow->wasNull(); +/*N*/ bValue = TRUE; +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::TIME: +/*N*/ { +/*N*/ SvNumberFormatter* pFormTable = pDoc->GetFormatTable(); +/*N*/ nFormatIndex = pFormTable->GetStandardFormat( +/*N*/ NUMBERFORMAT_TIME, ScGlobal::eLnge ); +/*N*/ +/*N*/ util::Time aTime = xRow->getTime(nRowPos); +/*N*/ nVal = ( aTime.Hours * 3600 + aTime.Minutes * 60 + +/*N*/ aTime.Seconds + aTime.HundredthSeconds / 100.0 ) / D_TIMEFACTOR; +/*N*/ bEmptyFlag = xRow->wasNull(); +/*N*/ bValue = TRUE; +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::TIMESTAMP: +/*N*/ { +/*N*/ SvNumberFormatter* pFormTable = pDoc->GetFormatTable(); +/*N*/ nFormatIndex = pFormTable->GetStandardFormat( +/*N*/ NUMBERFORMAT_DATETIME, ScGlobal::eLnge ); +/*N*/ +/*N*/ util::DateTime aStamp = xRow->getTimestamp(nRowPos); +/*N*/ nVal = ( Date( aStamp.Day, aStamp.Month, aStamp.Year ) - +/*N*/ *pFormTable->GetNullDate() ) + +/*N*/ ( aStamp.Hours * 3600 + aStamp.Minutes * 60 + +/*N*/ aStamp.Seconds + aStamp.HundredthSeconds / 100.0 ) / D_TIMEFACTOR; +/*N*/ bEmptyFlag = xRow->wasNull(); +/*N*/ bValue = TRUE; +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::SQLNULL: +/*N*/ bEmptyFlag = TRUE; +/*N*/ break; +/*N*/ +/*N*/ case sdbc::DataType::BINARY: +/*N*/ case sdbc::DataType::VARBINARY: +/*N*/ case sdbc::DataType::LONGVARBINARY: +/*N*/ default: +/*N*/ bError = TRUE; // unknown type +/*N*/ } +/*N*/ } +/*N*/ catch ( uno::Exception& ) +/*N*/ { +/*N*/ bError = TRUE; +/*N*/ } +/*N*/ +/*N*/ if ( bValue && bCurrency ) +/*N*/ nFormatIndex = pDoc->GetFormatTable()->GetStandardFormat( +/*N*/ NUMBERFORMAT_CURRENCY, ScGlobal::eLnge ); +/*N*/ +/*N*/ ScBaseCell* pCell; +/*N*/ if (bEmptyFlag) +/*N*/ { +/*N*/ pCell = NULL; +/*N*/ pDoc->PutCell( nCol, nRow, nTab, pCell ); +/*N*/ } +/*N*/ else if (bError) +/*N*/ { +/*N*/ pDoc->SetError( nCol, nRow, nTab, NOVALUE ); +/*N*/ } +/*N*/ else if (bValue) +/*N*/ { +/*?*/ pCell = new ScValueCell( nVal ); +/*N*/ if (nFormatIndex == 0) +/*N*/ pDoc->PutCell( nCol, nRow, nTab, pCell ); +/*N*/ else +/*N*/ pDoc->PutCell( nCol, nRow, nTab, pCell, nFormatIndex ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (aString.Len()) +/*N*/ { +/*N*/ pCell = ScBaseCell::CreateTextCell( aString, pDoc ); +/*N*/ if ( pSimpleFlag && pCell->GetCellType() == CELLTYPE_EDIT ) +/*N*/ *pSimpleFlag = FALSE; +/*N*/ } +/*N*/ else +/*N*/ pCell = NULL; +/*N*/ pDoc->PutCell( nCol, nRow, nTab, pCell ); +/*N*/ } +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dociter.cxx b/binfilter/bf_sc/source/core/data/sc_dociter.cxx new file mode 100644 index 000000000000..abcf5a17368f --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dociter.cxx @@ -0,0 +1,997 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svtools/zforlist.hxx> + +#include "dociter.hxx" +#include "document.hxx" +#include "cell.hxx" +#include "attarray.hxx" +#include "docoptio.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ +//------------------------------------------------------------------------ +void lcl_IterGetNumberFormat( ULONG& nFormat, const ScAttrArray*& rpArr, + USHORT& nAttrEndRow, const ScAttrArray* pNewArr, USHORT nRow, + ScDocument* pDoc ) +{ + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( rpArr != pNewArr || nAttrEndRow < nRow ) +} + +/*N*/ ScValueIterator::ScValueIterator( ScDocument* pDocument, const ScRange& rRange, +/*N*/ BOOL bSTotal, BOOL bTextZero ) : +/*N*/ pDoc( pDocument ), +/*N*/ nStartCol( rRange.aStart.Col() ), +/*N*/ nStartRow( rRange.aStart.Row() ), +/*N*/ nStartTab( rRange.aStart.Tab() ), +/*N*/ nEndCol( rRange.aEnd.Col() ), +/*N*/ nEndRow( rRange.aEnd.Row() ), +/*N*/ nEndTab( rRange.aEnd.Tab() ), +/*N*/ bSubTotal(bSTotal), +/*N*/ nNumFmtType( NUMBERFORMAT_UNDEFINED ), +/*N*/ nNumFmtIndex(0), +/*N*/ bNumValid( FALSE ), +/*N*/ bNextValid( FALSE ), +/*N*/ bCalcAsShown( pDocument->GetDocOptions().IsCalcAsShown() ), +/*N*/ bTextAsZero( bTextZero ) +/*N*/ { +/*N*/ PutInOrder( nStartCol, nEndCol); +/*N*/ PutInOrder( nStartRow, nEndRow); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ if (nStartCol > MAXCOL) nStartCol = MAXCOL; +/*N*/ if (nEndCol > MAXCOL) nEndCol = MAXCOL; +/*N*/ if (nStartRow > MAXROW) nStartRow = MAXROW; +/*N*/ if (nEndRow > MAXROW) nEndRow = MAXROW; +/*N*/ if (nStartTab > MAXTAB) nStartTab = MAXTAB; +/*N*/ if (nEndTab > MAXTAB) nEndTab = MAXTAB; +/*N*/ +/*N*/ nCol = nStartCol; +/*N*/ nRow = nStartRow; +/*N*/ nTab = nStartTab; +/*N*/ +/*N*/ nColRow = 0; // wird bei GetFirst initialisiert +/*N*/ +/*N*/ nNumFormat = 0; // werden bei GetNumberFormat initialisiert +/*N*/ pAttrArray = 0; +/*N*/ nAttrEndRow = 0; +/*N*/ } + +/*N*/ BOOL ScValueIterator::GetThis(double& rValue, USHORT& rErr) +/*N*/ { +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ for (;;) +/*N*/ { +/*N*/ if ( nRow > nEndRow ) +/*N*/ { +/*N*/ nRow = nStartRow; +/*N*/ do +/*N*/ { +/*N*/ nCol++; +/*N*/ if ( nCol > nEndCol ) +/*N*/ { +/*N*/ nCol = nStartCol; +/*N*/ nTab++; +/*N*/ if ( nTab > nEndTab ) +/*N*/ { +/*N*/ rValue = 0.0; +/*N*/ rErr = 0; +/*N*/ return FALSE; // Ende und Aus +/*N*/ } +/*N*/ } +/*N*/ pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ } while ( pCol->nCount == 0 ); +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ } +/*N*/ +/*N*/ while (( nColRow < pCol->nCount ) && ( pCol->pItems[nColRow].nRow < nRow )) +/*N*/ nColRow++; +/*N*/ +/*N*/ if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= nEndRow ) +/*N*/ { +/*N*/ nRow = pCol->pItems[nColRow].nRow + 1; +/*N*/ if ( !bSubTotal || !pDoc->pTab[nTab]->IsFiltered( nRow-1 ) ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pCol->pItems[nColRow].pCell; +/*N*/ ++nColRow; +/*N*/ switch (pCell->GetCellType()) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ bNumValid = FALSE; +/*N*/ rValue = ((ScValueCell*)pCell)->GetValue(); +/*N*/ rErr = 0; +/*N*/ --nRow; +/*N*/ if ( bCalcAsShown ) +/*N*/ { +/*?*/ #ifndef WTC +/*?*/ lcl_IterGetNumberFormat( nNumFormat,pAttrArray, +/*?*/ #else +/*?*/ lcl_IterGetNumberFormat( nNumFormat, +/*?*/ (ScAttrArray const *&)pAttrArray, +/*?*/ #endif +/*?*/ nAttrEndRow, pCol->pAttrArray, nRow, pDoc ); +/*?*/ rValue = pDoc->RoundValueAsShown( rValue, nNumFormat ); +/*N*/ } +/*N*/ // +/*N*/ // wenn in der selben Spalte gleich noch eine Value-Cell folgt, die +/*N*/ // auch noch im Block liegt, den Wert jetzt schon holen +/*N*/ // +/*N*/ if ( nColRow < pCol->nCount && +/*N*/ pCol->pItems[nColRow].nRow <= nEndRow && +/*N*/ pCol->pItems[nColRow].pCell->GetCellType() == CELLTYPE_VALUE && +/*N*/ !bSubTotal ) +/*N*/ { +/*N*/ fNextValue = ((ScValueCell*)pCol->pItems[nColRow].pCell)->GetValue(); +/*N*/ nNextRow = pCol->pItems[nColRow].nRow; +/*N*/ bNextValid = TRUE; +/*N*/ if ( bCalcAsShown ) +/*N*/ { +/*?*/ #ifndef WTC +/*?*/ lcl_IterGetNumberFormat( nNumFormat, pAttrArray, +/*?*/ #else +/*?*/ lcl_IterGetNumberFormat( nNumFormat, +/*?*/ (ScAttrArray const *&)pAttrArray, +/*?*/ #endif +/*?*/ nAttrEndRow, pCol->pAttrArray, nNextRow, pDoc ); +/*?*/ fNextValue = pDoc->RoundValueAsShown( fNextValue, nNumFormat ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return TRUE; // gefunden +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ if (!bSubTotal || !((ScFormulaCell*)pCell)->IsSubTotal()) +/*N*/ { +/*N*/ rErr = ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ if ( rErr || ((ScFormulaCell*)pCell)->IsValue() ) +/*N*/ { +/*N*/ rValue = ((ScFormulaCell*)pCell)->GetValue(); +/*N*/ nRow--; +/*N*/ bNumValid = FALSE; +/*N*/ return TRUE; // gefunden +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_STRING : +/*N*/ case CELLTYPE_EDIT : +/*N*/ { +/*N*/ if ( bTextAsZero ) +/*N*/ { +/*N*/ rErr = 0; +/*N*/ rValue = 0.0; +/*N*/ nNumFmtType = NUMBERFORMAT_NUMBER; +/*N*/ nNumFmtIndex = 0; +/*N*/ bNumValid = TRUE; +/*N*/ --nRow; +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nRow = nEndRow + 1; // naechste Spalte +/*N*/ } +/*N*/ } + +/*N*/ void ScValueIterator::GetCurNumFmtInfo( short& nType, ULONG& nIndex ) +/*N*/ { +/*N*/ if (!bNumValid) +/*N*/ { +/*N*/ const ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ nNumFmtIndex = pCol->GetNumberFormat( nRow ); +/*N*/ if ( (nNumFmtIndex % SV_COUNTRY_LANGUAGE_OFFSET) == 0 ) +/*N*/ { +/*N*/ const ScBaseCell* pCell; +/*N*/ USHORT nIdx = nColRow - 1; +/*N*/ // there might be rearranged something, so be on the safe side +/*N*/ if ( nIdx < pCol->nCount && pCol->pItems[nIdx].nRow == nRow ) +/*N*/ pCell = pCol->pItems[nIdx].pCell; +/*N*/ else +/*N*/ { +/*?*/ if ( pCol->Search( nRow, nIdx ) ) +/*?*/ pCell = pCol->pItems[nIdx].pCell; +/*?*/ else +/*?*/ pCell = NULL; +/*N*/ } +/*N*/ if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((const ScFormulaCell*)pCell)->GetFormatInfo( nNumFmtType, nNumFmtIndex ); +/*N*/ else +/*N*/ nNumFmtType = pDoc->GetFormatTable()->GetType( nNumFmtIndex ); +/*N*/ } +/*N*/ else +/*N*/ nNumFmtType = pDoc->GetFormatTable()->GetType( nNumFmtIndex ); +/*N*/ bNumValid = TRUE; +/*N*/ } +/*N*/ nType = nNumFmtType; +/*N*/ nIndex = nNumFmtIndex; +/*N*/ } + +/*N*/ BOOL ScValueIterator::GetFirst(double& rValue, USHORT& rErr) +/*N*/ { +/*N*/ nCol = nStartCol; +/*N*/ nRow = nStartRow; +/*N*/ nTab = nStartTab; +/*N*/ +/*N*/ // nColRow = 0; +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ +/*N*/ nNumFormat = 0; // werden bei GetNumberFormat initialisiert +/*N*/ pAttrArray = 0; +/*N*/ nAttrEndRow = 0; +/*N*/ +/*N*/ return GetThis(rValue, rErr); +/*N*/ } + +/* ist inline: +BOOL ScValueIterator::GetNext(double& rValue, USHORT& rErr) +{ + ++nRow; + return GetThis(rValue, rErr); +} +*/ + +//------------------------------------------------------------------------ +//------------------------------------------------------------------------ + +/*N*/ ScQueryValueIterator::ScQueryValueIterator(ScDocument* pDocument, USHORT nTable, const ScQueryParam& rParam) : +/*N*/ pDoc( pDocument ), +/*N*/ nTab( nTable), +/*N*/ aParam (rParam), +/*N*/ nNumFmtType( NUMBERFORMAT_UNDEFINED ), +/*N*/ nNumFmtIndex(0), +/*N*/ bCalcAsShown( pDocument->GetDocOptions().IsCalcAsShown() ) +/*N*/ { +/*N*/ nCol = aParam.nCol1; +/*N*/ nRow = aParam.nRow1; +/*N*/ nColRow = 0; // wird bei GetFirst initialisiert +/*N*/ USHORT i; +/*N*/ USHORT nCount = aParam.GetEntryCount(); +/*N*/ for (i=0; (i<nCount) && (aParam.GetEntry(i).bDoQuery); i++) +/*N*/ { +/*N*/ ScQueryEntry& rEntry = aParam.GetEntry(i); +/*N*/ sal_uInt32 nIndex = 0; +/*N*/ rEntry.bQueryByString = +/*N*/ !(pDoc->GetFormatTable()->IsNumberFormat(*rEntry.pStr, nIndex, rEntry.nVal)); +/*N*/ } +/*N*/ nNumFormat = 0; // werden bei GetNumberFormat initialisiert +/*N*/ pAttrArray = 0; +/*N*/ nAttrEndRow = 0; +/*N*/ } +/*N*/ +/*N*/ BOOL ScQueryValueIterator::GetThis(double& rValue, USHORT& rErr) +/*N*/ { +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ USHORT nFirstQueryField = aParam.GetEntry(0).nField; +/*N*/ for ( ;; ) +/*N*/ { +/*N*/ if ( nRow > aParam.nRow2 ) +/*N*/ { +/*N*/ nRow = aParam.nRow1; +/*N*/ if (aParam.bHasHeader) +/*N*/ nRow++; +/*N*/ do +/*N*/ { +/*N*/ nCol++; +/*N*/ if ( nCol > aParam.nCol2 ) +/*N*/ { +/*N*/ rValue = 0.0; +/*N*/ rErr = 0; +/*N*/ return FALSE; // Ende und Aus +/*N*/ } +/*N*/ pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ } while ( pCol->nCount == 0 ); +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ } +/*N*/ +/*N*/ while ( (nColRow < pCol->nCount) && (pCol->pItems[nColRow].nRow < nRow) ) +/*N*/ nColRow++; +/*N*/ +/*N*/ if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= aParam.nRow2 ) +/*N*/ { +/*N*/ nRow = pCol->pItems[nColRow].nRow; +/*N*/ ScBaseCell* pCell = pCol->pItems[nColRow].pCell; +/*N*/ if ( (pDoc->pTab[nTab])->ValidQuery( nRow, aParam, NULL, +/*N*/ (nCol == nFirstQueryField ? pCell : NULL) ) ) +/*N*/ { +/*N*/ switch (pCell->GetCellType()) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ rValue = ((ScValueCell*)pCell)->GetValue(); +/*N*/ if ( bCalcAsShown ) +/*N*/ { +/*N*/ #if ! ( defined WTC || defined ICC || defined HPUX || defined C50 || defined C52 || ( defined GCC && __GNUC__ >= 3 ) || ( defined WNT && _MSC_VER >= 1400 ) ) +/*N*/ lcl_IterGetNumberFormat( nNumFormat, pAttrArray, +/*N*/ #else +/*N*/ lcl_IterGetNumberFormat( nNumFormat, +/*N*/ (ScAttrArray const *&)pAttrArray, +/*N*/ #endif +/*N*/ nAttrEndRow, pCol->pAttrArray, nRow, pDoc ); +/*N*/ rValue = pDoc->RoundValueAsShown( rValue, nNumFormat ); +/*N*/ } +/*N*/ nNumFmtType = NUMBERFORMAT_NUMBER; +/*N*/ nNumFmtIndex = 0; +/*N*/ rErr = 0; +/*N*/ return TRUE; // gefunden +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ if (((ScFormulaCell*)pCell)->IsValue()) +/*N*/ { +/*N*/ rValue = ((ScFormulaCell*)pCell)->GetValue(); +/*N*/ pDoc->GetNumberFormatInfo( nNumFmtType, +/*N*/ nNumFmtIndex, ScAddress( nCol, nRow, nTab ), +/*N*/ *((ScFormulaCell*)pCell) ); +/*N*/ rErr = ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ return TRUE; // gefunden +/*N*/ } +/*N*/ else +/*N*/ nRow++; +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ nRow++; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nRow++; +/*N*/ } +/*N*/ else +/*N*/ nRow = aParam.nRow2 + 1; // Naechste Spalte +/*N*/ } +/*N*/ return FALSE; +/*N*/ } +/*N*/ +/*N*/ BOOL ScQueryValueIterator::GetFirst(double& rValue, USHORT& rErr) +/*N*/ { +/*N*/ nCol = aParam.nCol1; +/*N*/ nRow = aParam.nRow1; +/*N*/ if (aParam.bHasHeader) +/*N*/ nRow++; +/*N*/ // nColRow = 0; +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ return GetThis(rValue, rErr); +/*N*/ } +/*N*/ +/*N*/ BOOL ScQueryValueIterator::GetNext(double& rValue, USHORT& rErr) +/*N*/ { +/*N*/ ++nRow; +/*N*/ return GetThis(rValue, rErr); +/*N*/ } + +//------------------------------------------------------------------------------- + +/*N*/ ScCellIterator::ScCellIterator( ScDocument* pDocument, +/*N*/ USHORT nSCol, USHORT nSRow, USHORT nSTab, +/*N*/ USHORT nECol, USHORT nERow, USHORT nETab, BOOL bSTotal ) : +/*N*/ pDoc( pDocument ), +/*N*/ nStartCol( nSCol), +/*N*/ nStartRow( nSRow), +/*N*/ nStartTab( nSTab ), +/*N*/ nEndCol( nECol ), +/*N*/ nEndRow( nERow), +/*N*/ nEndTab( nETab ), +/*N*/ bSubTotal(bSTotal) +/*N*/ +/*N*/ { +/*N*/ PutInOrder( nStartCol, nEndCol); +/*N*/ PutInOrder( nStartRow, nEndRow); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ if (nStartCol > MAXCOL) nStartCol = MAXCOL; +/*N*/ if (nEndCol > MAXCOL) nEndCol = MAXCOL; +/*N*/ if (nStartRow > MAXROW) nStartRow = MAXROW; +/*N*/ if (nEndRow > MAXROW) nEndRow = MAXROW; +/*N*/ if (nStartTab > MAXTAB) nStartTab = MAXTAB; +/*N*/ if (nEndTab > MAXTAB) nEndTab = MAXTAB; +/*N*/ +/*N*/ while (nEndTab>0 && !pDoc->pTab[nEndTab]) +/*N*/ --nEndTab; // nur benutzte Tabellen +/*N*/ if (nStartTab>nEndTab) +/*N*/ nStartTab = nEndTab; +/*N*/ +/*N*/ nCol = nStartCol; +/*N*/ nRow = nStartRow; +/*N*/ nTab = nStartTab; +/*N*/ nColRow = 0; // wird bei GetFirst initialisiert +/*N*/ +/*N*/ if (!pDoc->pTab[nTab]) +/*N*/ { +/*N*/ DBG_ERROR("Tabelle nicht gefunden"); +/*N*/ nStartCol = nCol = MAXCOL+1; +/*N*/ nStartRow = nRow = MAXROW+1; +/*N*/ nStartTab = nTab = MAXTAB+1; // -> Abbruch bei GetFirst +/*N*/ } +/*N*/ } + +/*N*/ ScCellIterator::ScCellIterator +/*N*/ ( ScDocument* pDocument, const ScRange& rRange, BOOL bSTotal ) : +/*N*/ pDoc( pDocument ), +/*N*/ nStartCol( rRange.aStart.Col() ), +/*N*/ nStartRow( rRange.aStart.Row() ), +/*N*/ nStartTab( rRange.aStart.Tab() ), +/*N*/ nEndCol( rRange.aEnd.Col() ), +/*N*/ nEndRow( rRange.aEnd.Row() ), +/*N*/ nEndTab( rRange.aEnd.Tab() ), +/*N*/ bSubTotal(bSTotal) +/*N*/ +/*N*/ { +/*N*/ PutInOrder( nStartCol, nEndCol); +/*N*/ PutInOrder( nStartRow, nEndRow); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ if (nStartCol > MAXCOL) nStartCol = MAXCOL; +/*N*/ if (nEndCol > MAXCOL) nEndCol = MAXCOL; +/*N*/ if (nStartRow > MAXROW) nStartRow = MAXROW; +/*N*/ if (nEndRow > MAXROW) nEndRow = MAXROW; +/*N*/ if (nStartTab > MAXTAB) nStartTab = MAXTAB; +/*N*/ if (nEndTab > MAXTAB) nEndTab = MAXTAB; +/*N*/ +/*N*/ while (nEndTab>0 && !pDoc->pTab[nEndTab]) +/*N*/ --nEndTab; // nur benutzte Tabellen +/*N*/ if (nStartTab>nEndTab) +/*N*/ nStartTab = nEndTab; +/*N*/ +/*N*/ nCol = nStartCol; +/*N*/ nRow = nStartRow; +/*N*/ nTab = nStartTab; +/*N*/ nColRow = 0; // wird bei GetFirst initialisiert +/*N*/ +/*N*/ if (!pDoc->pTab[nTab]) +/*N*/ { +/*N*/ DBG_ERROR("Tabelle nicht gefunden"); +/*N*/ nStartCol = nCol = MAXCOL+1; +/*N*/ nStartRow = nRow = MAXROW+1; +/*N*/ nStartTab = nTab = MAXTAB+1; // -> Abbruch bei GetFirst +/*N*/ } +/*N*/ } + +/*N*/ ScBaseCell* ScCellIterator::GetThis() +/*N*/ { +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ for ( ;; ) +/*N*/ { +/*N*/ if ( nRow > nEndRow ) +/*N*/ { +/*N*/ nRow = nStartRow; +/*N*/ do +/*N*/ { +/*N*/ nCol++; +/*N*/ if ( nCol > nEndCol ) +/*N*/ { +/*N*/ nCol = nStartCol; +/*N*/ nTab++; +/*N*/ if ( nTab > nEndTab ) +/*N*/ return NULL; // Ende und Aus +/*N*/ } +/*N*/ pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ } while ( pCol->nCount == 0 ); +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ } +/*N*/ +/*N*/ while ( (nColRow < pCol->nCount) && (pCol->pItems[nColRow].nRow < nRow) ) +/*N*/ nColRow++; +/*N*/ +/*N*/ if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= nEndRow ) +/*N*/ { +/*N*/ nRow = pCol->pItems[nColRow].nRow; +/*N*/ if ( !bSubTotal || !pDoc->pTab[nTab]->IsFiltered( nRow ) ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pCol->pItems[nColRow].pCell; +/*N*/ +/*N*/ if ( bSubTotal && pCell->GetCellType() == CELLTYPE_FORMULA +/*N*/ && ((ScFormulaCell*)pCell)->IsSubTotal() ) +/*N*/ nRow++; // Sub-Total-Zeilen nicht +/*N*/ else +/*N*/ return pCell; // gefunden +/*N*/ } +/*N*/ else +/*N*/ nRow++; +/*N*/ } +/*N*/ else +/*N*/ nRow = nEndRow + 1; // Naechste Spalte +/*N*/ } +/*N*/ } + +/*N*/ ScBaseCell* ScCellIterator::GetFirst() +/*N*/ { +/*N*/ if ( nTab > MAXTAB ) +/*N*/ return NULL; +/*N*/ nCol = nStartCol; +/*N*/ nRow = nStartRow; +/*N*/ nTab = nStartTab; +/*N*/ // nColRow = 0; +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ return GetThis(); +/*N*/ } + +/*N*/ ScBaseCell* ScCellIterator::GetNext() +/*N*/ { +/*N*/ ++nRow; +/*N*/ return GetThis(); +/*N*/ } + +//------------------------------------------------------------------------------- + +/*N*/ ScQueryCellIterator::ScQueryCellIterator(ScDocument* pDocument, USHORT nTable, +/*N*/ const ScQueryParam& rParam, BOOL bMod ) : +/*N*/ pDoc( pDocument ), +/*N*/ nTab( nTable), +/*N*/ aParam (rParam), +/*N*/ nStopOnMismatch( nStopOnMismatchDisabled ), +/*N*/ nTestEqualCondition( nTestEqualConditionDisabled ), +/*N*/ bAdvanceQuery( FALSE ) +/*N*/ { +/*N*/ nCol = aParam.nCol1; +/*N*/ nRow = aParam.nRow1; +/*N*/ nColRow = 0; // wird bei GetFirst initialisiert +/*N*/ USHORT i; +/*N*/ if (bMod) // sonst schon eingetragen +/*N*/ { +/*N*/ for (i=0; (i<MAXQUERY) && (aParam.GetEntry(i).bDoQuery); i++) +/*N*/ { +/*?*/ ScQueryEntry& rEntry = aParam.GetEntry(i); +/*?*/ sal_uInt32 nIndex = 0; +/*?*/ rEntry.bQueryByString = +/*?*/ !(pDoc->GetFormatTable()->IsNumberFormat(*rEntry.pStr, +/*?*/ nIndex, rEntry.nVal)); +/*N*/ } +/*N*/ } +/*N*/ nNumFormat = 0; // werden bei GetNumberFormat initialisiert +/*N*/ pAttrArray = 0; +/*N*/ nAttrEndRow = 0; +/*N*/ } +/*N*/ +/*N*/ ScBaseCell* ScQueryCellIterator::GetThis() +/*N*/ { +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ USHORT nFirstQueryField = aParam.GetEntry(0).nField; +/*N*/ for ( ;; ) +/*N*/ { +/*N*/ if ( nRow > aParam.nRow2 ) +/*N*/ { +/*N*/ nRow = aParam.nRow1; +/*N*/ if (aParam.bHasHeader) +/*?*/ nRow++; +/*N*/ do +/*M*/ { +/*M*/ if ( ++nCol > aParam.nCol2 ) +/*M*/ return NULL; // Ende und Aus +/*M*/ if ( bAdvanceQuery ) +/*M*/ { +/*M*/ AdvanceQueryParamEntryField(); +/*M*/ nFirstQueryField = aParam.GetEntry(0).nField; +/*M*/ } +/*M*/ pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*M*/ } while ( pCol->nCount == 0 ); +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ } +/*N*/ +/*N*/ while ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow < nRow ) +/*N*/ nColRow++; +/*N*/ +/*N*/ if ( nColRow < pCol->nCount && pCol->pItems[nColRow].nRow <= aParam.nRow2 ) +/*N*/ { +/*N*/ if ( pCol->pItems[nColRow].pCell->GetCellType() == CELLTYPE_NOTE ) +/*?*/ nRow++; +/*N*/ else +/*N*/ { +/*N*/ BOOL bTestEqualCondition; +/*N*/ nRow = pCol->pItems[nColRow].nRow; +/*N*/ ScBaseCell* pCell = pCol->pItems[nColRow].pCell; +/*N*/ if ( (pDoc->pTab[nTab])->ValidQuery( nRow, aParam, NULL, +/*N*/ (nCol == nFirstQueryField ? pCell : NULL), +/*N*/ (nTestEqualCondition ? &bTestEqualCondition : NULL) ) ) +/*N*/ { +/*N*/ if ( nTestEqualCondition && bTestEqualCondition ) +/*N*/ nTestEqualCondition |= nTestEqualConditionMatched; +/*N*/ return pCell; // found +/*N*/ } +/*N*/ else if ( nStopOnMismatch ) +/*N*/ { +/*N*/ nStopOnMismatch |= nStopOnMismatchOccured; +/*N*/ // Yes, even a mismatch may have a fulfilled equal +/*N*/ // condition if regular expressions were involved and +/*N*/ // SC_LESS_EQUAL or SC_GREATER_EQUAL were queried. +/*N*/ if ( nTestEqualCondition && bTestEqualCondition ) +/*?*/ nTestEqualCondition |= nTestEqualConditionMatched; +/*N*/ return NULL; +/*N*/ } +/*N*/ else +/*N*/ nRow++; +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ nRow = aParam.nRow2 + 1; // Naechste Spalte +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ ScBaseCell* ScQueryCellIterator::GetFirst() +/*N*/ { +/*N*/ nCol = aParam.nCol1; +/*N*/ nRow = aParam.nRow1; +/*N*/ if (aParam.bHasHeader) +/*?*/ nRow++; +/*N*/ // nColRow = 0; +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ pCol->Search( nRow, nColRow ); +/*N*/ return GetThis(); +/*N*/ } +/*N*/ +/*N*/ ScBaseCell* ScQueryCellIterator::GetNext() +/*N*/ { +/*N*/ ++nRow; +/*N*/ if ( nStopOnMismatch ) +/*N*/ nStopOnMismatch = nStopOnMismatchEnabled; +/*N*/ if ( nTestEqualCondition ) +/*N*/ nTestEqualCondition = nTestEqualConditionEnabled; +/*N*/ return GetThis(); +/*N*/ } +/*N*/ +/*N*/ ULONG ScQueryCellIterator::GetNumberFormat() +/*N*/ { +/*N*/ ScColumn* pCol = &(pDoc->pTab[nTab])->aCol[nCol]; +/*N*/ #if ! ( defined WTC || defined ICC || defined HPUX || defined C50 || defined C52 || ( defined GCC && __GNUC__ >= 3 ) || ( defined WNT && _MSC_VER >= 1400 ) ) +/*N*/ lcl_IterGetNumberFormat( nNumFormat, pAttrArray, +/*N*/ #else +/*N*/ lcl_IterGetNumberFormat( nNumFormat, +/*N*/ (ScAttrArray const *&)pAttrArray, +/*N*/ #endif +/*N*/ nAttrEndRow, pCol->pAttrArray, nRow, pDoc ); +/*N*/ return nNumFormat; +/*N*/ } + +/*N*/ void ScQueryCellIterator::AdvanceQueryParamEntryField() +/*N*/ { +/*N*/ USHORT nEntries = aParam.GetEntryCount(); +/*N*/ for ( USHORT j = 0; j < nEntries; j++ ) +/*N*/ { +/*N*/ ScQueryEntry& rEntry = aParam.GetEntry( j ); +/*N*/ if ( rEntry.bDoQuery ) +/*N*/ { +/*N*/ if ( rEntry.nField < MAXCOL ) +/*N*/ rEntry.nField++; +/*N*/ else +/*N*/ { +/*N*/ DBG_ERRORFILE( "AdvanceQueryParamEntryField: ++rEntry.nField > MAXCOL" ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ break; // for +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScQueryCellIterator::FindEqualOrSortedLastInRange( USHORT& nFoundCol, USHORT& nFoundRow ) +/*N*/ { +/*N*/ nFoundCol = MAXCOL+1; +/*N*/ nFoundRow = MAXROW+1; +/*N*/ SetStopOnMismatch( TRUE ); // assume sorted keys +/*N*/ SetTestEqualCondition( TRUE ); +/*N*/ if ( GetFirst() ) +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ nFoundCol = GetCol(); +/*N*/ nFoundRow = GetRow(); +/*N*/ } while ( !IsEqualConditionFulfilled() && GetNext() ); +/*N*/ } +/*N*/ if ( IsEqualConditionFulfilled() ) +/*N*/ { +/*N*/ nFoundCol = GetCol(); +/*N*/ nFoundRow = GetRow(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ if ( StoppedOnMismatch() ) +/*N*/ { // Assume found entry to be the last value less than or equal to query. +/*N*/ // But keep on searching for an equal match. +/*N*/ SetStopOnMismatch( FALSE ); +/*N*/ SetTestEqualCondition( FALSE ); +/*N*/ USHORT nEntries = aParam.GetEntryCount(); +/*N*/ for ( USHORT j = 0; j < nEntries; j++ ) +/*N*/ { +/*N*/ ScQueryEntry& rEntry = aParam.GetEntry( j ); +/*N*/ if ( rEntry.bDoQuery ) +/*N*/ { +/*N*/ switch ( rEntry.eOp ) +/*N*/ { +/*N*/ case SC_LESS_EQUAL : +/*N*/ case SC_GREATER_EQUAL : +/*N*/ rEntry.eOp = SC_EQUAL; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ break; // for +/*N*/ } +/*N*/ if ( GetNext() ) +/*N*/ { +/*?*/ nFoundCol = GetCol(); +/*?*/ nFoundRow = GetRow(); +/*N*/ } +/*N*/ } +/*N*/ return (nFoundCol <= MAXCOL) && (nFoundRow <= MAXROW); +/*N*/ } + + +//------------------------------------------------------------------------------- + +/*N*/ ScHorizontalCellIterator::ScHorizontalCellIterator(ScDocument* pDocument, USHORT nTable, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2 ) : +/*N*/ pDoc( pDocument ), +/*N*/ nTab( nTable ), +/*N*/ nStartCol( nCol1 ), +/*N*/ nEndCol( nCol2 ), +/*N*/ nEndRow( nRow2 ), +/*N*/ nCol( nCol1 ), +/*N*/ nRow( nRow1 ), +/*N*/ bMore( TRUE ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT nIndex; +/*N*/ +/*N*/ pNextRows = new USHORT[ nCol2-nCol1+1 ]; +/*N*/ pNextIndices = new USHORT[ nCol2-nCol1+1 ]; +/*N*/ +/*N*/ for (i=nStartCol; i<=nEndCol; i++) +/*N*/ { +/*N*/ ScColumn* pCol = &pDoc->pTab[nTab]->aCol[i]; +/*N*/ +/*N*/ pCol->Search( nRow1, nIndex ); +/*N*/ if ( nIndex < pCol->nCount ) +/*N*/ { +/*N*/ pNextRows[i-nStartCol] = pCol->pItems[nIndex].nRow; +/*N*/ pNextIndices[i-nStartCol] = nIndex; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pNextRows[i-nStartCol] = MAXROW+1; // nichts gefunden +/*N*/ pNextIndices[i-nStartCol] = MAXROW+1; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (pNextRows[0] != nRow1) +/*N*/ Advance(); +/*N*/ } + +/*N*/ ScHorizontalCellIterator::~ScHorizontalCellIterator() +/*N*/ { +/*N*/ delete [] pNextRows; +/*N*/ delete [] pNextIndices; +/*N*/ } + +/*N*/ ScBaseCell* ScHorizontalCellIterator::GetNext( USHORT& rCol, USHORT& rRow ) +/*N*/ { +/*N*/ if ( bMore ) +/*N*/ { +/*N*/ rCol = nCol; +/*N*/ rRow = nRow; +/*N*/ +/*N*/ ScColumn* pCol = &pDoc->pTab[nTab]->aCol[nCol]; +/*N*/ USHORT nIndex = pNextIndices[nCol-nStartCol]; +/*N*/ DBG_ASSERT( nIndex < pCol->nCount, "ScHorizontalCellIterator::GetNext: nIndex out of range" ); +/*N*/ ScBaseCell* pCell = pCol->pItems[nIndex].pCell; +/*N*/ if ( ++nIndex < pCol->nCount ) +/*N*/ { +/*N*/ pNextRows[nCol-nStartCol] = pCol->pItems[nIndex].nRow; +/*N*/ pNextIndices[nCol-nStartCol] = nIndex; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pNextRows[nCol-nStartCol] = MAXROW+1; // nichts gefunden +/*N*/ pNextIndices[nCol-nStartCol] = MAXROW+1; +/*N*/ } +/*N*/ +/*N*/ Advance(); +/*N*/ return pCell; +/*N*/ } +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ BOOL ScHorizontalCellIterator::ReturnNext( USHORT& rCol, USHORT& rRow ) +/*N*/ { +/*N*/ rCol = nCol; +/*N*/ rRow = nRow; +/*N*/ return bMore; +/*N*/ } + +/*N*/ void ScHorizontalCellIterator::Advance() +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=nCol+1; i<=nEndCol && !bFound; i++) +/*N*/ if (pNextRows[i-nStartCol] == nRow) +/*N*/ { +/*N*/ nCol = i; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ +/*N*/ if (!bFound) +/*N*/ { +/*N*/ USHORT nMinRow = MAXROW+1; +/*N*/ for (i=nStartCol; i<=nEndCol; i++) +/*N*/ if (pNextRows[i-nStartCol] < nMinRow) +/*N*/ { +/*N*/ nCol = i; +/*N*/ nMinRow = pNextRows[i-nStartCol]; +/*N*/ } +/*N*/ +/*N*/ if (nMinRow <= nEndRow) +/*N*/ { +/*N*/ nRow = nMinRow; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( !bFound ) +/*N*/ bMore = FALSE; +/*N*/ } + +//------------------------------------------------------------------------------- + + +//------------------------------------------------------------------------------- + + +//------------------------------------------------------------------------------- + +/*N*/ ScDocAttrIterator::ScDocAttrIterator(ScDocument* pDocument, USHORT nTable, +/*N*/ USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2) : +/*N*/ pDoc( pDocument ), +/*N*/ nTab( nTable ), +/*N*/ nCol( nCol1 ), +/*N*/ nEndCol( nCol2 ), +/*N*/ nStartRow( nRow1 ), +/*N*/ nEndRow( nRow2 ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pDoc->pTab[nTab] ) +/*N*/ pColIter = pDoc->pTab[nTab]->aCol[nCol].CreateAttrIterator( nStartRow, nEndRow ); +/*N*/ else +/*N*/ pColIter = NULL; +/*N*/ } + +/*N*/ ScDocAttrIterator::~ScDocAttrIterator() +/*N*/ { +/*N*/ delete pColIter; +/*N*/ } + +/*N*/ const ScPatternAttr* ScDocAttrIterator::GetNext( USHORT& rCol, USHORT& rRow1, USHORT& rRow2 ) +/*N*/ { +/*N*/ while ( pColIter ) +/*N*/ { +/*N*/ const ScPatternAttr* pPattern = pColIter->Next( rRow1, rRow2 ); +/*N*/ if ( pPattern ) +/*N*/ { +/*N*/ rCol = nCol; +/*N*/ return pPattern; +/*N*/ } +/*N*/ +/*N*/ delete pColIter; +/*N*/ ++nCol; +/*N*/ if ( nCol <= nEndCol ) +/*N*/ pColIter = pDoc->pTab[nTab]->aCol[nCol].CreateAttrIterator( nStartRow, nEndRow ); +/*N*/ else +/*N*/ pColIter = NULL; +/*N*/ } +/*N*/ return NULL; // is nix mehr +/*N*/ } + +//------------------------------------------------------------------------------- + +/*N*/ ScAttrRectIterator::ScAttrRectIterator(ScDocument* pDocument, USHORT nTable, +/*N*/ USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2) : +/*N*/ pDoc( pDocument ), +/*N*/ nTab( nTable ), +/*N*/ nEndCol( nCol2 ), +/*N*/ nStartRow( nRow1 ), +/*N*/ nEndRow( nRow2 ), +/*N*/ nIterStartCol( nCol1 ), +/*N*/ nIterEndCol( nCol1 ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pDoc->pTab[nTab] ) +/*N*/ { +/*N*/ pColIter = pDoc->pTab[nTab]->aCol[nIterStartCol].CreateAttrIterator( nStartRow, nEndRow ); +/*N*/ while ( nIterEndCol < nEndCol && +/*N*/ pDoc->pTab[nTab]->aCol[nIterEndCol].IsAllAttrEqual( +/*N*/ pDoc->pTab[nTab]->aCol[nIterEndCol+1], nStartRow, nEndRow ) ) +/*N*/ ++nIterEndCol; +/*N*/ } +/*N*/ else +/*N*/ pColIter = NULL; +/*N*/ } + +/*N*/ ScAttrRectIterator::~ScAttrRectIterator() +/*N*/ { +/*N*/ delete pColIter; +/*N*/ } + +/*N*/ void ScAttrRectIterator::DataChanged() +/*N*/ { +/*N*/ if (pColIter) +/*N*/ { +/*N*/ USHORT nNextRow = pColIter->GetNextRow(); +/*N*/ delete pColIter; +/*N*/ pColIter = pDoc->pTab[nTab]->aCol[nIterStartCol].CreateAttrIterator( nNextRow, nEndRow ); +/*N*/ } +/*N*/ } + +/*N*/ const ScPatternAttr* ScAttrRectIterator::GetNext( USHORT& rCol1, USHORT& rCol2, +/*N*/ USHORT& rRow1, USHORT& rRow2 ) +/*N*/ { +/*N*/ while ( pColIter ) +/*N*/ { +/*N*/ const ScPatternAttr* pPattern = pColIter->Next( rRow1, rRow2 ); +/*N*/ if ( pPattern ) +/*N*/ { +/*N*/ rCol1 = nIterStartCol; +/*N*/ rCol2 = nIterEndCol; +/*N*/ return pPattern; +/*N*/ } +/*N*/ +/*N*/ delete pColIter; +/*N*/ nIterStartCol = nIterEndCol+1; +/*N*/ if ( nIterStartCol <= nEndCol ) +/*N*/ { +/*N*/ nIterEndCol = nIterStartCol; +/*N*/ pColIter = pDoc->pTab[nTab]->aCol[nIterStartCol].CreateAttrIterator( nStartRow, nEndRow ); +/*N*/ while ( nIterEndCol < nEndCol && +/*N*/ pDoc->pTab[nTab]->aCol[nIterEndCol].IsAllAttrEqual( +/*N*/ pDoc->pTab[nTab]->aCol[nIterEndCol+1], nStartRow, nEndRow ) ) +/*N*/ ++nIterEndCol; +/*N*/ } +/*N*/ else +/*N*/ pColIter = NULL; +/*N*/ } +/*N*/ return NULL; // is nix mehr +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_docpool.cxx b/binfilter/bf_sc/source/core/data/sc_docpool.cxx new file mode 100644 index 000000000000..888137d11c18 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_docpool.cxx @@ -0,0 +1,607 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "scitems.hxx" +#include <vcl/outdev.hxx> +#include <bf_svtools/aeitem.hxx> +#include <bf_svx/algitem.hxx> +#include <bf_svx/boxitem.hxx> +#include <bf_svx/brshitem.hxx> +#include <bf_svx/charreliefitem.hxx> +#include <bf_svx/cntritem.hxx> +#include <bf_svx/colritem.hxx> +#include <bf_svx/crsditem.hxx> +#include <bf_svx/emphitem.hxx> +#include <bf_svx/fhgtitem.hxx> +#include <bf_svx/fontitem.hxx> +#include <bf_svx/forbiddenruleitem.hxx> +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/hngpnctitem.hxx> +#include <bf_svx/langitem.hxx> +#include <bf_svx/lrspitem.hxx> +#include <bf_svx/pageitem.hxx> +#include <bf_svx/pbinitem.hxx> +#include <bf_svx/postitem.hxx> +#include <bf_svx/rotmodit.hxx> +#include <bf_svx/scriptspaceitem.hxx> +#include <bf_svx/shaditem.hxx> +#include <bf_svx/shdditem.hxx> +#include <bf_svx/sizeitem.hxx> +#include <bf_svx/svxitems.hrc> +#include <bf_svx/udlnitem.hxx> +#include <bf_svx/ulspitem.hxx> +#include <bf_svx/wghtitem.hxx> +#include <bf_svx/wrlmitem.hxx> +#include <bf_svx/xmlcnitm.hxx> + +#include "docpool.hxx" +#include "attrib.hxx" +#include "patattr.hxx" +#include "globstr.hrc" +#include "bf_sc.hrc" // Slot-IDs +namespace binfilter { + + +#define SC_MAX_POOLREF (SFX_ITEMS_OLD_MAXREF - 39) +#define SC_SAFE_POOLREF (SC_MAX_POOLREF + 20) + +// STATIC DATA ----------------------------------------------------------- + +/*N*/ USHORT* ScDocumentPool::pVersionMap1 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap2 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap3 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap4 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap5 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap6 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap7 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap8 = 0; +/*N*/ USHORT* ScDocumentPool::pVersionMap9 = 0; + +// ATTR_FONT_TWOLINES (not used) was changed to ATTR_USERDEF (not saved in binary format) in 641c + +/*N*/ static SfxItemInfo __READONLY_DATA aItemInfos[] = +/*N*/ { +/*N*/ { SID_ATTR_CHAR_FONT, SFX_ITEM_POOLABLE }, // ATTR_FONT +/*N*/ { SID_ATTR_CHAR_FONTHEIGHT, SFX_ITEM_POOLABLE }, // ATTR_FONT_HEIGHT +/*N*/ { SID_ATTR_CHAR_WEIGHT, SFX_ITEM_POOLABLE }, // ATTR_FONT_WEIGHT +/*N*/ { SID_ATTR_CHAR_POSTURE, SFX_ITEM_POOLABLE }, // ATTR_FONT_POSTURE +/*N*/ { SID_ATTR_CHAR_UNDERLINE, SFX_ITEM_POOLABLE }, // ATTR_FONT_UNDERLINE +/*N*/ { SID_ATTR_CHAR_STRIKEOUT, SFX_ITEM_POOLABLE }, // ATTR_FONT_CROSSEDOUT +/*N*/ { SID_ATTR_CHAR_CONTOUR, SFX_ITEM_POOLABLE }, // ATTR_FONT_CONTOUR +/*N*/ { SID_ATTR_CHAR_SHADOWED, SFX_ITEM_POOLABLE }, // ATTR_FONT_SHADOWED +/*N*/ { SID_ATTR_CHAR_COLOR, SFX_ITEM_POOLABLE }, // ATTR_FONT_COLOR +/*N*/ { SID_ATTR_CHAR_LANGUAGE, SFX_ITEM_POOLABLE }, // ATTR_FONT_LANGUAGE +/*N*/ { SID_ATTR_CHAR_CJK_FONT, SFX_ITEM_POOLABLE }, // ATTR_CJK_FONT from 614 +/*N*/ { SID_ATTR_CHAR_CJK_FONTHEIGHT, SFX_ITEM_POOLABLE }, // ATTR_CJK_FONT_HEIGHT from 614 +/*N*/ { SID_ATTR_CHAR_CJK_WEIGHT, SFX_ITEM_POOLABLE }, // ATTR_CJK_FONT_WEIGHT from 614 +/*N*/ { SID_ATTR_CHAR_CJK_POSTURE, SFX_ITEM_POOLABLE }, // ATTR_CJK_FONT_POSTURE from 614 +/*N*/ { SID_ATTR_CHAR_CJK_LANGUAGE, SFX_ITEM_POOLABLE }, // ATTR_CJK_FONT_LANGUAGE from 614 +/*N*/ { SID_ATTR_CHAR_CTL_FONT, SFX_ITEM_POOLABLE }, // ATTR_CTL_FONT from 614 +/*N*/ { SID_ATTR_CHAR_CTL_FONTHEIGHT, SFX_ITEM_POOLABLE }, // ATTR_CTL_FONT_HEIGHT from 614 +/*N*/ { SID_ATTR_CHAR_CTL_WEIGHT, SFX_ITEM_POOLABLE }, // ATTR_CTL_FONT_WEIGHT from 614 +/*N*/ { SID_ATTR_CHAR_CTL_POSTURE, SFX_ITEM_POOLABLE }, // ATTR_CTL_FONT_POSTURE from 614 +/*N*/ { SID_ATTR_CHAR_CTL_LANGUAGE, SFX_ITEM_POOLABLE }, // ATTR_CTL_FONT_LANGUAGE from 614 +/*N*/ { SID_ATTR_CHAR_EMPHASISMARK, SFX_ITEM_POOLABLE }, // ATTR_FONT_EMPHASISMARK from 614 +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_USERDEF from 614 / 641c +/*N*/ { SID_ATTR_CHAR_WORDLINEMODE, SFX_ITEM_POOLABLE }, // ATTR_FONT_WORDLINE from 632b +/*N*/ { SID_ATTR_CHAR_RELIEF, SFX_ITEM_POOLABLE }, // ATTR_FONT_RELIEF from 632b +/*N*/ { SID_ATTR_ALIGN_HYPHENATION, SFX_ITEM_POOLABLE }, // ATTR_HYPHENATE from 632b +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_SCRIPTSPACE from 614d +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_HANGPUNCTUATION from 614d +/*N*/ { SID_ATTR_PARA_FORBIDDEN_RULES,SFX_ITEM_POOLABLE }, // ATTR_FORBIDDEN_RULES from 614d +/*N*/ { SID_ATTR_ALIGN_HOR_JUSTIFY, SFX_ITEM_POOLABLE }, // ATTR_HOR_JUSTIFY +/*N*/ { SID_ATTR_ALIGN_INDENT, SFX_ITEM_POOLABLE }, // ATTR_INDENT ab 350 +/*N*/ { SID_ATTR_ALIGN_VER_JUSTIFY, SFX_ITEM_POOLABLE }, // ATTR_VER_JUSTIFY +/*N*/ { SID_ATTR_ALIGN_ORIENTATION, SFX_ITEM_POOLABLE }, // ATTR_ORIENTATION +/*N*/ { SID_ATTR_ALIGN_DEGREES, SFX_ITEM_POOLABLE }, // ATTR_ROTATE_VALUE ab 367 +/*N*/ { SID_ATTR_ALIGN_LOCKPOS, SFX_ITEM_POOLABLE }, // ATTR_ROTATE_MODE ab 367 +/*N*/ { SID_ATTR_ALIGN_ASIANVERTICAL, SFX_ITEM_POOLABLE }, // ATTR_VERTICAL_ASIAN from 642 +/*N*/ { SID_ATTR_FRAMEDIRECTION, SFX_ITEM_POOLABLE }, // ATTR_WRITINGDIR from 643 +/*N*/ { SID_ATTR_ALIGN_LINEBREAK, SFX_ITEM_POOLABLE }, // ATTR_LINEBREAK +/*N*/ { SID_ATTR_ALIGN_MARGIN, SFX_ITEM_POOLABLE }, // ATTR_MARGIN +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_MERGE +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_MERGE_FLAG +/*N*/ { SID_ATTR_NUMBERFORMAT_VALUE, SFX_ITEM_POOLABLE }, // ATTR_VALUE_FORMAT +/*N*/ { ATTR_LANGUAGE_FORMAT, SFX_ITEM_POOLABLE }, // ATTR_LANGUAGE_FORMAT ab 329, wird im Dialog mit SID_ATTR_NUMBERFORMAT_VALUE kombiniert +/*N*/ { SID_ATTR_BRUSH, SFX_ITEM_POOLABLE }, // ATTR_BACKGROUND +/*N*/ { SID_SCATTR_PROTECTION, SFX_ITEM_POOLABLE }, // ATTR_PROTECTION +/*N*/ { SID_ATTR_BORDER_OUTER, SFX_ITEM_POOLABLE }, // ATTR_BORDER +/*N*/ { SID_ATTR_BORDER_INNER, SFX_ITEM_POOLABLE }, // ATTR_BORDER_INNER +/*N*/ { SID_ATTR_BORDER_SHADOW, SFX_ITEM_POOLABLE }, // ATTR_SHADOW +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_VALIDDATA +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_CONDITIONAL +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_PATTERN +/*N*/ { SID_ATTR_LRSPACE, SFX_ITEM_POOLABLE }, // ATTR_LRSPACE +/*N*/ { SID_ATTR_ULSPACE, SFX_ITEM_POOLABLE }, // ATTR_ULSPACE +/*N*/ { SID_ATTR_PAGE, SFX_ITEM_POOLABLE }, // ATTR_PAGE +/*N*/ { 0, SFX_ITEM_POOLABLE }, // ATTR_PAGE_PAPERTRAY, seit 303 nur noch dummy +/*N*/ { SID_ATTR_PAGE_PAPERBIN, SFX_ITEM_POOLABLE }, // ATTR_PAGE_PAPERBIN +/*N*/ { SID_ATTR_PAGE_SIZE, SFX_ITEM_POOLABLE }, // ATTR_PAGE_SIZE +/*N*/ { SID_ATTR_PAGE_MAXSIZE, SFX_ITEM_POOLABLE }, // ATTR_PAGE_MAXSIZE +/*N*/ { SID_ATTR_PAGE_EXT1, SFX_ITEM_POOLABLE }, // ATTR_PAGE_HORCENTER +/*N*/ { SID_ATTR_PAGE_EXT2, SFX_ITEM_POOLABLE }, // ATTR_PAGE_VERCENTER +/*N*/ { SID_ATTR_PAGE_ON, SFX_ITEM_POOLABLE }, // ATTR_PAGE_ON +/*N*/ { SID_ATTR_PAGE_DYNAMIC, SFX_ITEM_POOLABLE }, // ATTR_PAGE_DYNAMIC +/*N*/ { SID_ATTR_PAGE_SHARED, SFX_ITEM_POOLABLE }, // ATTR_PAGE_SHARED +/*N*/ { SID_SCATTR_PAGE_NOTES, SFX_ITEM_POOLABLE }, // ATTR_PAGE_NOTES +/*N*/ { SID_SCATTR_PAGE_GRID, SFX_ITEM_POOLABLE }, // ATTR_PAGE_GRID +/*N*/ { SID_SCATTR_PAGE_HEADERS, SFX_ITEM_POOLABLE }, // ATTR_PAGE_HEADERS +/*N*/ { SID_SCATTR_PAGE_CHARTS, SFX_ITEM_POOLABLE }, // ATTR_PAGE_CHARTS +/*N*/ { SID_SCATTR_PAGE_OBJECTS, SFX_ITEM_POOLABLE }, // ATTR_PAGE_OBJECTS +/*N*/ { SID_SCATTR_PAGE_DRAWINGS, SFX_ITEM_POOLABLE }, // ATTR_PAGE_DRAWINGS +/*N*/ { SID_SCATTR_PAGE_TOPDOWN, SFX_ITEM_POOLABLE }, // ATTR_PAGE_TOPDOWN +/*N*/ { SID_SCATTR_PAGE_SCALE, SFX_ITEM_POOLABLE }, // ATTR_PAGE_SCALE +/*N*/ { SID_SCATTR_PAGE_SCALETOPAGES, SFX_ITEM_POOLABLE }, // ATTR_PAGE_SCALETOPAGES +/*N*/ { SID_SCATTR_PAGE_FIRSTPAGENO, SFX_ITEM_POOLABLE }, // ATTR_PAGE_FIRSTPAGENO +/*N*/ { SID_SCATTR_PAGE_PRINTAREA, SFX_ITEM_POOLABLE }, // ATTR_PAGE_PRINTAREA +/*N*/ { SID_SCATTR_PAGE_REPEATROW, SFX_ITEM_POOLABLE }, // ATTR_PAGE_REPEATROW +/*N*/ { SID_SCATTR_PAGE_REPEATCOL, SFX_ITEM_POOLABLE }, // ATTR_PAGE_REPEATCOL +/*N*/ { SID_SCATTR_PAGE_PRINTTABLES, SFX_ITEM_POOLABLE }, // ATTR_PAGE_PRINTTABLES +/*N*/ { SID_SCATTR_PAGE_HEADERLEFT, SFX_ITEM_POOLABLE }, // ATTR_PAGE_HEADERLEFT +/*N*/ { SID_SCATTR_PAGE_FOOTERLEFT, SFX_ITEM_POOLABLE }, // ATTR_PAGE_FOOTERLEFT +/*N*/ { SID_SCATTR_PAGE_HEADERRIGHT, SFX_ITEM_POOLABLE }, // ATTR_PAGE_HEADERRIGHT +/*N*/ { SID_SCATTR_PAGE_FOOTERRIGHT, SFX_ITEM_POOLABLE }, // ATTR_PAGE_FOOTERRIGHT +/*N*/ { SID_ATTR_PAGE_HEADERSET, SFX_ITEM_POOLABLE }, // ATTR_PAGE_HEADERSET +/*N*/ { SID_ATTR_PAGE_FOOTERSET, SFX_ITEM_POOLABLE }, // ATTR_PAGE_FOOTERSET +/*N*/ { SID_SCATTR_PAGE_FORMULAS, SFX_ITEM_POOLABLE }, // ATTR_PAGE_FORMULAS +/*N*/ { SID_SCATTR_PAGE_NULLVALS, SFX_ITEM_POOLABLE } // ATTR_PAGE_NULLVALS +/*N*/ }; + +// ----------------------------------------------------------------------- + +/*N*/ ScDocumentPool::ScDocumentPool( SfxItemPool* pSecPool, BOOL bLoadRefCounts ) +/*N*/ +/*N*/ : SfxItemPool ( String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("ScDocumentPool")), +/*N*/ ATTR_STARTINDEX, ATTR_ENDINDEX, +/*N*/ aItemInfos, NULL, bLoadRefCounts ), +/*N*/ pSecondary ( pSecPool ) +/*N*/ { +/*N*/ // latin font from GetDefaultFonts is not used, DEFAULTFONT_LATIN_SPREADSHEET instead +/*N*/ Font aStdFont = OutputDevice::GetDefaultFont( DEFAULTFONT_LATIN_SPREADSHEET, LANGUAGE_ENGLISH_US, +/*N*/ DEFAULTFONT_FLAGS_ONLYONE ); +/*N*/ SvxFontItem* pStdFont = new SvxFontItem( aStdFont.GetFamily(), +/*N*/ aStdFont.GetName(), aStdFont.GetStyleName(), +/*N*/ aStdFont.GetPitch(), aStdFont.GetCharSet(), +/*N*/ ATTR_FONT ); +/*N*/ +/*N*/ SvxFontItem* pCjkFont = new SvxFontItem( ATTR_CJK_FONT ); +/*N*/ SvxFontItem* pCtlFont = new SvxFontItem( ATTR_CTL_FONT ); +/*N*/ SvxFontItem aDummy; +/*N*/ GetDefaultFonts( aDummy, *pCjkFont, *pCtlFont ); +/*N*/ +/*N*/ SvxBoxInfoItem* pGlobalBorderInnerAttr = new SvxBoxInfoItem( ATTR_BORDER_INNER ); +/*N*/ SfxItemSet* pSet = new SfxItemSet( *this, ATTR_PATTERN_START, ATTR_PATTERN_END ); +/*N*/ SfxItemSet aSetItemItemSet( *this, +/*N*/ ATTR_BACKGROUND, ATTR_BACKGROUND, +/*N*/ ATTR_BORDER, ATTR_SHADOW, +/*N*/ ATTR_LRSPACE, ATTR_ULSPACE, +/*N*/ ATTR_PAGE_SIZE, ATTR_PAGE_SIZE, +/*N*/ ATTR_PAGE_ON, ATTR_PAGE_SHARED, +/*N*/ 0 ); +/*N*/ +/*N*/ pGlobalBorderInnerAttr->SetLine(NULL, BOXINFO_LINE_HORI); +/*N*/ pGlobalBorderInnerAttr->SetLine(NULL, BOXINFO_LINE_VERT); +/*N*/ pGlobalBorderInnerAttr->SetTable(TRUE); +/*N*/ pGlobalBorderInnerAttr->SetDist((BOOL)FALSE); +/*N*/ pGlobalBorderInnerAttr->SetMinDist(FALSE); +/*N*/ +/*N*/ ppPoolDefaults = new SfxPoolItem*[ATTR_ENDINDEX-ATTR_STARTINDEX+1]; +/*N*/ +/*N*/ ppPoolDefaults[ ATTR_FONT - ATTR_STARTINDEX ] = pStdFont; +/*N*/ ppPoolDefaults[ ATTR_FONT_HEIGHT - ATTR_STARTINDEX ] = new SvxFontHeightItem( 200 ); // 10 pt; +/*N*/ ppPoolDefaults[ ATTR_FONT_WEIGHT - ATTR_STARTINDEX ] = new SvxWeightItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_POSTURE - ATTR_STARTINDEX ] = new SvxPostureItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_UNDERLINE - ATTR_STARTINDEX ] = new SvxUnderlineItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_CROSSEDOUT - ATTR_STARTINDEX ] = new SvxCrossedOutItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_CONTOUR - ATTR_STARTINDEX ] = new SvxContourItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_SHADOWED - ATTR_STARTINDEX ] = new SvxShadowedItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_COLOR - ATTR_STARTINDEX ] = new SvxColorItem( Color(COL_AUTO) ); +/*N*/ ppPoolDefaults[ ATTR_FONT_LANGUAGE - ATTR_STARTINDEX ] = new SvxLanguageItem( LanguageType(LANGUAGE_DONTKNOW), ATTR_FONT_LANGUAGE ); +/*N*/ ppPoolDefaults[ ATTR_CJK_FONT - ATTR_STARTINDEX ] = pCjkFont; +/*N*/ ppPoolDefaults[ ATTR_CJK_FONT_HEIGHT - ATTR_STARTINDEX ] = new SvxFontHeightItem( 200, 100, ATTR_CJK_FONT_HEIGHT ); +/*N*/ ppPoolDefaults[ ATTR_CJK_FONT_WEIGHT - ATTR_STARTINDEX ] = new SvxWeightItem( WEIGHT_NORMAL, ATTR_CJK_FONT_WEIGHT ); +/*N*/ ppPoolDefaults[ ATTR_CJK_FONT_POSTURE- ATTR_STARTINDEX ] = new SvxPostureItem( ITALIC_NONE, ATTR_CJK_FONT_POSTURE ); +/*N*/ ppPoolDefaults[ ATTR_CJK_FONT_LANGUAGE-ATTR_STARTINDEX ] = new SvxLanguageItem( LanguageType(LANGUAGE_DONTKNOW), +/*N*/ ATTR_CJK_FONT_LANGUAGE ); +/*N*/ ppPoolDefaults[ ATTR_CTL_FONT - ATTR_STARTINDEX ] = pCtlFont; +/*N*/ ppPoolDefaults[ ATTR_CTL_FONT_HEIGHT - ATTR_STARTINDEX ] = new SvxFontHeightItem( 200, 100, ATTR_CTL_FONT_HEIGHT ); +/*N*/ ppPoolDefaults[ ATTR_CTL_FONT_WEIGHT - ATTR_STARTINDEX ] = new SvxWeightItem( WEIGHT_NORMAL, ATTR_CTL_FONT_WEIGHT ); +/*N*/ ppPoolDefaults[ ATTR_CTL_FONT_POSTURE- ATTR_STARTINDEX ] = new SvxPostureItem( ITALIC_NONE, ATTR_CTL_FONT_POSTURE ); +/*N*/ ppPoolDefaults[ ATTR_CTL_FONT_LANGUAGE-ATTR_STARTINDEX ] = new SvxLanguageItem( LanguageType(LANGUAGE_DONTKNOW), +/*N*/ ATTR_CTL_FONT_LANGUAGE ); +/*N*/ ppPoolDefaults[ ATTR_FONT_EMPHASISMARK-ATTR_STARTINDEX ] = new SvxEmphasisMarkItem; +/*N*/ ppPoolDefaults[ ATTR_USERDEF - ATTR_STARTINDEX ] = new SvXMLAttrContainerItem( ATTR_USERDEF ); +/*N*/ ppPoolDefaults[ ATTR_FONT_WORDLINE - ATTR_STARTINDEX ] = new SvxWordLineModeItem; +/*N*/ ppPoolDefaults[ ATTR_FONT_RELIEF - ATTR_STARTINDEX ] = new SvxCharReliefItem; +/*N*/ ppPoolDefaults[ ATTR_HYPHENATE - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_HYPHENATE ); +/*N*/ ppPoolDefaults[ ATTR_SCRIPTSPACE - ATTR_STARTINDEX ] = new SvxScriptSpaceItem; +/*N*/ ppPoolDefaults[ ATTR_HANGPUNCTUATION - ATTR_STARTINDEX ] = new SvxHangingPunctuationItem; +/*N*/ ppPoolDefaults[ ATTR_FORBIDDEN_RULES - ATTR_STARTINDEX ] = new SvxForbiddenRuleItem; +/*N*/ ppPoolDefaults[ ATTR_HOR_JUSTIFY - ATTR_STARTINDEX ] = new SvxHorJustifyItem; +/*N*/ ppPoolDefaults[ ATTR_INDENT - ATTR_STARTINDEX ] = new SfxUInt16Item( ATTR_INDENT, 0 ); +/*N*/ ppPoolDefaults[ ATTR_VER_JUSTIFY - ATTR_STARTINDEX ] = new SvxVerJustifyItem; +/*N*/ ppPoolDefaults[ ATTR_ORIENTATION - ATTR_STARTINDEX ] = new SvxOrientationItem; +/*N*/ ppPoolDefaults[ ATTR_ROTATE_VALUE - ATTR_STARTINDEX ] = new SfxInt32Item( ATTR_ROTATE_VALUE, 0 ); +/*N*/ ppPoolDefaults[ ATTR_ROTATE_MODE - ATTR_STARTINDEX ] = new SvxRotateModeItem( SVX_ROTATE_MODE_BOTTOM, ATTR_ROTATE_MODE ); +/*N*/ ppPoolDefaults[ ATTR_VERTICAL_ASIAN - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_VERTICAL_ASIAN ); + // The default for the ATTR_WRITINGDIR cell attribute must by FRMDIR_ENVIRONMENT, + // so that value is returned when asking for a default cell's attributes. + // The value from the page style is set as DefaultHorizontalTextDirection for the EditEngine. +/*N*/ ppPoolDefaults[ ATTR_WRITINGDIR - ATTR_STARTINDEX ] = new SvxFrameDirectionItem( FRMDIR_ENVIRONMENT, ATTR_WRITINGDIR ); +/*N*/ ppPoolDefaults[ ATTR_LINEBREAK - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_LINEBREAK ); +/*N*/ ppPoolDefaults[ ATTR_MARGIN - ATTR_STARTINDEX ] = new SvxMarginItem; +/*N*/ ppPoolDefaults[ ATTR_MERGE - ATTR_STARTINDEX ] = new ScMergeAttr; +/*N*/ ppPoolDefaults[ ATTR_MERGE_FLAG - ATTR_STARTINDEX ] = new ScMergeFlagAttr; +/*N*/ ppPoolDefaults[ ATTR_VALUE_FORMAT - ATTR_STARTINDEX ] = new SfxUInt32Item( ATTR_VALUE_FORMAT, 0 ); +/*N*/ ppPoolDefaults[ ATTR_LANGUAGE_FORMAT - ATTR_STARTINDEX ] = new SvxLanguageItem( ScGlobal::eLnge, ATTR_LANGUAGE_FORMAT ); +/*N*/ ppPoolDefaults[ ATTR_BACKGROUND - ATTR_STARTINDEX ] = new SvxBrushItem( Color(COL_TRANSPARENT), ATTR_BACKGROUND ); +/*N*/ ppPoolDefaults[ ATTR_PROTECTION - ATTR_STARTINDEX ] = new ScProtectionAttr; +/*N*/ ppPoolDefaults[ ATTR_BORDER - ATTR_STARTINDEX ] = new SvxBoxItem( ATTR_BORDER ); +/*N*/ ppPoolDefaults[ ATTR_BORDER_INNER - ATTR_STARTINDEX ] = pGlobalBorderInnerAttr; +/*N*/ ppPoolDefaults[ ATTR_SHADOW - ATTR_STARTINDEX ] = new SvxShadowItem( ATTR_SHADOW ); +/*N*/ ppPoolDefaults[ ATTR_VALIDDATA - ATTR_STARTINDEX ] = new SfxUInt32Item( ATTR_VALIDDATA, 0 ); +/*N*/ ppPoolDefaults[ ATTR_CONDITIONAL - ATTR_STARTINDEX ] = new SfxUInt32Item( ATTR_CONDITIONAL, 0 ); +/*N*/ +/*N*/ // GetRscString funktioniert erst nach ScGlobal::Init, zu erkennen am EmptyBrushItem +/*N*/ //! zusaetzliche Methode ScGlobal::IsInit() oder so... +/*N*/ //! oder erkennen, ob dies der Secondary-Pool fuer einen MessagePool ist +/*N*/ if ( ScGlobal::GetEmptyBrushItem() ) +/*N*/ ppPoolDefaults[ ATTR_PATTERN - ATTR_STARTINDEX ] = new ScPatternAttr( pSet, ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ); +/*N*/ else +/*N*/ ppPoolDefaults[ ATTR_PATTERN - ATTR_STARTINDEX ] = new ScPatternAttr( pSet, +/*N*/ String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(STRING_STANDARD)) ); //! without name? +/*N*/ +/*N*/ ppPoolDefaults[ ATTR_LRSPACE - ATTR_STARTINDEX ] = new SvxLRSpaceItem( ATTR_LRSPACE ); +/*N*/ ppPoolDefaults[ ATTR_ULSPACE - ATTR_STARTINDEX ] = new SvxULSpaceItem( ATTR_ULSPACE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE - ATTR_STARTINDEX ] = new SvxPageItem( ATTR_PAGE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_PAPERTRAY - ATTR_STARTINDEX ] = new SfxAllEnumItem( ATTR_PAGE_PAPERTRAY ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_PAPERBIN - ATTR_STARTINDEX ] = new SvxPaperBinItem( ATTR_PAGE_PAPERBIN ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_SIZE - ATTR_STARTINDEX ] = new SvxSizeItem( ATTR_PAGE_SIZE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_MAXSIZE - ATTR_STARTINDEX ] = new SvxSizeItem( ATTR_PAGE_MAXSIZE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_HORCENTER - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_HORCENTER ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_VERCENTER - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_VERCENTER ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_ON - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_ON, TRUE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_DYNAMIC - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_DYNAMIC, TRUE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_SHARED - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_SHARED, TRUE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_NOTES - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_NOTES, FALSE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_GRID - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_GRID, FALSE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_HEADERS - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_HEADERS, FALSE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_CHARTS - ATTR_STARTINDEX ] = new ScViewObjectModeItem( ATTR_PAGE_CHARTS ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_OBJECTS - ATTR_STARTINDEX ] = new ScViewObjectModeItem( ATTR_PAGE_OBJECTS ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_DRAWINGS - ATTR_STARTINDEX ] = new ScViewObjectModeItem( ATTR_PAGE_DRAWINGS ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_TOPDOWN - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_TOPDOWN, TRUE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_SCALE - ATTR_STARTINDEX ] = new SfxUInt16Item( ATTR_PAGE_SCALE, 100 ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_SCALETOPAGES-ATTR_STARTINDEX ] = new SfxUInt16Item( ATTR_PAGE_SCALETOPAGES, 1 ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_FIRSTPAGENO- ATTR_STARTINDEX ] = new SfxUInt16Item( ATTR_PAGE_FIRSTPAGENO, 1 ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_PRINTAREA - ATTR_STARTINDEX ] = new ScRangeItem( ATTR_PAGE_PRINTAREA ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_REPEATROW - ATTR_STARTINDEX ] = new ScRangeItem( ATTR_PAGE_REPEATROW ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_REPEATCOL - ATTR_STARTINDEX ] = new ScRangeItem( ATTR_PAGE_REPEATCOL ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_PRINTTABLES- ATTR_STARTINDEX ] = new ScTableListItem( ATTR_PAGE_PRINTTABLES ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_HEADERLEFT - ATTR_STARTINDEX ] = new ScPageHFItem( ATTR_PAGE_HEADERLEFT ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_FOOTERLEFT - ATTR_STARTINDEX ] = new ScPageHFItem( ATTR_PAGE_FOOTERLEFT ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_HEADERRIGHT- ATTR_STARTINDEX ] = new ScPageHFItem( ATTR_PAGE_HEADERRIGHT ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_FOOTERRIGHT- ATTR_STARTINDEX ] = new ScPageHFItem( ATTR_PAGE_FOOTERRIGHT ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_HEADERSET - ATTR_STARTINDEX ] = new SvxSetItem( ATTR_PAGE_HEADERSET, aSetItemItemSet ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_FOOTERSET - ATTR_STARTINDEX ] = new SvxSetItem( ATTR_PAGE_FOOTERSET, aSetItemItemSet ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_FORMULAS - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_FORMULAS, FALSE ); +/*N*/ ppPoolDefaults[ ATTR_PAGE_NULLVALS - ATTR_STARTINDEX ] = new SfxBoolItem( ATTR_PAGE_NULLVALS, TRUE ); +/*N*/ // ppPoolDefaults[ ATTR_ITEM_DOUBLE - ATTR_STARTINDEX ] = new ScDoubleItem( ATTR_ITEM_DOUBLE, 0 ); +/*N*/ +/*N*/ SetDefaults( ppPoolDefaults ); +/*N*/ +/*N*/ if ( pSecondary ) +/*?*/ SetSecondaryPool( pSecondary ); +/*N*/ +/*N*/ // ATTR_LANGUAGE_FORMAT ab sv329 eingefuegt, VersionMap in _ScGlobal__Init +/*N*/ SetVersionMap( 1, 100, 157, pVersionMap1 ); +/*N*/ +/*N*/ // ATTR_VALIDDATA, ATTR_CONDITIONAL ab 341 +/*N*/ SetVersionMap( 2, 100, 158, pVersionMap2 ); +/*N*/ +/*N*/ // ATTR_INDENT ab 350 +/*N*/ SetVersionMap( 3, 100, 160, pVersionMap3 ); +/*N*/ +/*N*/ // ATTR_ROTATE_VALUE, ATTR_ROTATE_MODE ab 367 +/*N*/ SetVersionMap( 4, 100, 161, pVersionMap4 ); +/*N*/ +/*N*/ // CJK, CTL, EMPHASISMARK, TWOLINES from 614 +/*N*/ SetVersionMap( 5, 100, 163, pVersionMap5 ); +/*N*/ +/*N*/ // ATTR_SCRIPTSPACE, ATTR_HANGPUNCTUATION, ATTR_FORBIDDEN_RULES from 614d +/*N*/ SetVersionMap( 6, 100, 175, pVersionMap6 ); +/*N*/ +/*N*/ // ATTR_FONT_WORDLINE, ATTR_FONT_RELIEF, ATTR_HYPHENATE from 632b +/*N*/ SetVersionMap( 7, 100, 178, pVersionMap7 ); +/*N*/ +/*N*/ // ATTR_VERTICAL_ASIAN from 642q +/*N*/ SetVersionMap( 8, 100, 181, pVersionMap8 ); + + // ATTR_WRITINGDIR from 643y +/*N*/ SetVersionMap( 9, 100, 182, pVersionMap9 ); +/*N*/ } + +/*N*/ __EXPORT ScDocumentPool::~ScDocumentPool() +/*N*/ { +/*N*/ Delete(); +/*N*/ +/*N*/ for ( USHORT i=0; i < ATTR_ENDINDEX-ATTR_STARTINDEX+1; i++ ) +/*N*/ { +/*N*/ SetRefCount( *ppPoolDefaults[i], 0 ); +/*N*/ delete ppPoolDefaults[i]; +/*N*/ } +/*N*/ +/*N*/ delete[] ppPoolDefaults; +/*N*/ delete pSecondary; +/*N*/ } + +/*N*/ void ScDocumentPool::InitVersionMaps() +/*N*/ { +/*N*/ DBG_ASSERT( !pVersionMap1 && !pVersionMap2 && +/*N*/ !pVersionMap3 && !pVersionMap4 && +/*N*/ !pVersionMap5 && !pVersionMap6 && +/*N*/ !pVersionMap7 && !pVersionMap8 && +/*N*/ !pVersionMap9, "InitVersionMaps call multiple times" ); +/*N*/ +/*N*/ // alte WhichId's mappen +/*N*/ // nicht mit ATTR_* zaehlen, falls die sich nochmal aendern +/*N*/ +/*N*/ // erste Map: ATTR_LANGUAGE_FORMAT ab sv329 eingefuegt +/*N*/ +/*N*/ const USHORT nMap1Start = 100; // alter ATTR_STARTINDEX +/*N*/ const USHORT nMap1End = 157; // alter ATTR_ENDINDEX +/*N*/ const USHORT nMap1Count = nMap1End - nMap1Start + 1; +/*N*/ const USHORT nMap1New = 18; // ATTR_LANGUAGE_FORMAT - ATTR_STARTINDEX +/*N*/ pVersionMap1 = new USHORT [ nMap1Count ]; +/*N*/ USHORT i, j; +/*N*/ for ( i=0, j=nMap1Start; i < nMap1New; i++, j++ ) +/*N*/ pVersionMap1[i] = j; +/*N*/ // ein Eintrag eingefuegt... +/*N*/ for ( i=nMap1New, j=nMap1Start+nMap1New+1; i < nMap1Count; i++, j++ ) +/*N*/ pVersionMap1[i] = j; +/*N*/ +/*N*/ // zweite Map: ATTR_VALIDDATA und ATTR_CONDITIONAL ab 341 eingefuegt +/*N*/ +/*N*/ const USHORT nMap2Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap2End = 158; // ATTR_ENDINDEX +/*N*/ const USHORT nMap2Count = nMap2End - nMap2Start + 1; +/*N*/ const USHORT nMap2New = 24; // ATTR_VALIDDATA - ATTR_STARTINDEX +/*N*/ pVersionMap2 = new USHORT [ nMap2Count ]; +/*N*/ for ( i=0, j=nMap2Start; i < nMap2New; i++, j++ ) +/*N*/ pVersionMap2[i] = j; +/*N*/ // zwei Eintraege eingefuegt... +/*N*/ for ( i=nMap2New, j=nMap2Start+nMap2New+2; i < nMap2Count; i++, j++ ) +/*N*/ pVersionMap2[i] = j; +/*N*/ +/*N*/ // dritte Map: ATTR_INDENT ab 350 eingefuegt +/*N*/ +/*N*/ const USHORT nMap3Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap3End = 160; // ATTR_ENDINDEX +/*N*/ const USHORT nMap3Count = nMap3End - nMap3Start + 1; +/*N*/ const USHORT nMap3New = 11; // ATTR_INDENT - ATTR_STARTINDEX +/*N*/ pVersionMap3 = new USHORT [ nMap3Count ]; +/*N*/ for ( i=0, j=nMap3Start; i < nMap3New; i++, j++ ) +/*N*/ pVersionMap3[i] = j; +/*N*/ // ein Eintrag eingefuegt... +/*N*/ for ( i=nMap3New, j=nMap3Start+nMap3New+1; i < nMap3Count; i++, j++ ) +/*N*/ pVersionMap3[i] = j; +/*N*/ +/*N*/ // vierte Map: ATTR_ROTATE_VALUE und ATTR_ROTATE_MODE ab 367 eingefuegt +/*N*/ +/*N*/ const USHORT nMap4Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap4End = 161; // ATTR_ENDINDEX +/*N*/ const USHORT nMap4Count = nMap4End - nMap4Start + 1; +/*N*/ const USHORT nMap4New = 14; // ATTR_ROTATE_VALUE - ATTR_STARTINDEX +/*N*/ pVersionMap4 = new USHORT [ nMap4Count ]; +/*N*/ for ( i=0, j=nMap4Start; i < nMap4New; i++, j++ ) +/*N*/ pVersionMap4[i] = j; +/*N*/ // zwei Eintraege eingefuegt... +/*N*/ for ( i=nMap4New, j=nMap4Start+nMap4New+2; i < nMap4Count; i++, j++ ) +/*N*/ pVersionMap4[i] = j; +/*N*/ +/*N*/ // fifth map: CJK..., CTL..., EMPHASISMARK, TWOLINES (12 items) added in 614 +/*N*/ +/*N*/ const USHORT nMap5Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap5End = 163; // ATTR_ENDINDEX +/*N*/ const USHORT nMap5Count = nMap5End - nMap5Start + 1; +/*N*/ const USHORT nMap5New = 10; // ATTR_CJK_FONT - ATTR_STARTINDEX +/*N*/ pVersionMap5 = new USHORT [ nMap5Count ]; +/*N*/ for ( i=0, j=nMap5Start; i < nMap5New; i++, j++ ) +/*N*/ pVersionMap5[i] = j; +/*N*/ // 12 entries inserted +/*N*/ for ( i=nMap5New, j=nMap5Start+nMap5New+12; i < nMap5Count; i++, j++ ) +/*N*/ pVersionMap5[i] = j; +/*N*/ +/*N*/ // sixth map: ATTR_SCRIPTSPACE, ATTR_HANGPUNCTUATION, ATTR_FORBIDDEN_RULES added in 614d +/*N*/ +/*N*/ const USHORT nMap6Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap6End = 175; // ATTR_ENDINDEX +/*N*/ const USHORT nMap6Count = nMap6End - nMap6Start + 1; +/*N*/ const USHORT nMap6New = 22; // ATTR_SCRIPTSPACE - ATTR_STARTINDEX +/*N*/ pVersionMap6 = new USHORT [ nMap6Count ]; +/*N*/ for ( i=0, j=nMap6Start; i < nMap6New; i++, j++ ) +/*N*/ pVersionMap6[i] = j; +/*N*/ // 3 entries inserted +/*N*/ for ( i=nMap6New, j=nMap6Start+nMap6New+3; i < nMap6Count; i++, j++ ) +/*N*/ pVersionMap6[i] = j; +/*N*/ +/*N*/ // seventh map: ATTR_FONT_WORDLINE, ATTR_FONT_RELIEF, ATTR_HYPHENATE added in 632b +/*N*/ +/*N*/ const USHORT nMap7Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap7End = 178; // ATTR_ENDINDEX +/*N*/ const USHORT nMap7Count = nMap7End - nMap7Start + 1; +/*N*/ const USHORT nMap7New = 22; // ATTR_FONT_WORDLINE - ATTR_STARTINDEX +/*N*/ pVersionMap7 = new USHORT [ nMap7Count ]; +/*N*/ for ( i=0, j=nMap7Start; i < nMap7New; i++, j++ ) +/*N*/ pVersionMap7[i] = j; +/*N*/ // 3 entries inserted +/*N*/ for ( i=nMap7New, j=nMap7Start+nMap7New+3; i < nMap7Count; i++, j++ ) +/*N*/ pVersionMap7[i] = j; +/*N*/ +/*N*/ // eighth map: ATTR_VERTICAL_ASIAN added in 642q +/*N*/ +/*N*/ const USHORT nMap8Start = 100; // ATTR_STARTINDEX +/*N*/ const USHORT nMap8End = 181; // ATTR_ENDINDEX +/*N*/ const USHORT nMap8Count = nMap8End - nMap8Start + 1; +/*N*/ const USHORT nMap8New = 34; // ATTR_VERTICAL_ASIAN - ATTR_STARTINDEX +/*N*/ pVersionMap8 = new USHORT [ nMap8Count ]; +/*N*/ for ( i=0, j=nMap8Start; i < nMap8New; i++, j++ ) +/*N*/ pVersionMap8[i] = j; +/*N*/ // 1 entry inserted +/*N*/ for ( i=nMap8New, j=nMap8Start+nMap8New+1; i < nMap8Count; i++, j++ ) +/*N*/ pVersionMap8[i] = j; + +/*M*/ // 9th map: ATTR_WRITINGDIR added in 643y +/*M*/ +/*M*/ const USHORT nMap9Start = 100; // ATTR_STARTINDEX +/*M*/ const USHORT nMap9End = 182; // ATTR_ENDINDEX +/*M*/ const USHORT nMap9Count = nMap9End - nMap9Start + 1; +/*M*/ const USHORT nMap9New = 35; // ATTR_WRITINGDIR - ATTR_STARTINDEX +/*M*/ pVersionMap9 = new USHORT [ nMap9Count ]; +/*M*/ for ( i=0, j=nMap9Start; i < nMap9New; i++, j++ ) +/*M*/ pVersionMap9[i] = j; +/*M*/ // 1 entry inserted +/*M*/ for ( i=nMap9New, j=nMap9Start+nMap9New+1; i < nMap9Count; i++, j++ ) +/*M*/ pVersionMap9[i] = j; +/*N*/ } + +/*N*/ void ScDocumentPool::DeleteVersionMaps() +/*N*/ { +/*N*/ DBG_ASSERT( pVersionMap1 && pVersionMap2 && +/*N*/ pVersionMap3 && pVersionMap4 && +/*N*/ pVersionMap5 && pVersionMap6 && +/*M*/ pVersionMap7 && pVersionMap8 && +/*M*/ pVersionMap9, "DeleteVersionMaps without maps" ); +/*M*/ +/*M*/ delete[] pVersionMap9; +/*M*/ pVersionMap9 = 0; +/*N*/ delete[] pVersionMap8; +/*N*/ pVersionMap8 = 0; +/*N*/ delete[] pVersionMap7; +/*N*/ pVersionMap7 = 0; +/*N*/ delete[] pVersionMap6; +/*N*/ pVersionMap6 = 0; +/*N*/ delete[] pVersionMap5; +/*N*/ pVersionMap5 = 0; +/*N*/ delete[] pVersionMap4; +/*N*/ pVersionMap4 = 0; +/*N*/ delete[] pVersionMap3; +/*N*/ pVersionMap3 = 0; +/*N*/ delete[] pVersionMap2; +/*N*/ pVersionMap2 = 0; +/*N*/ delete[] pVersionMap1; +/*N*/ pVersionMap1 = 0; +/*N*/ } + +// ---------------------------------------------------------------------------------------- +// +// Fuer die Pattern-Attribute (SetItems) kann der USHORT RefCount leicht ueberlaufen +// (z.B. 600 ganze Zeilen abwechselnd formatieren). +// Darum wird der RefCount bei SC_MAX_POOLREF festgehalten und nicht mehr hoch- oder +// heruntergezaehlt. Dieser RefCount wird dann erst beim naechsten Laden neu gezaehlt. +// Die Differenz zwischen SC_MAX_POOLREF und SC_SAFE_POOLREF ist ein wenig groesser +// als noetig, um zu erkennen, wenn der RefCount aus Versehen doch "normal" veraendert +// wird (Assertions). +// + +/*N*/ const SfxPoolItem& __EXPORT ScDocumentPool::Put( const SfxPoolItem& rItem, USHORT nWhich ) +/*N*/ { +/*N*/ if ( rItem.Which() != ATTR_PATTERN ) // nur Pattern ist special +/*N*/ return SfxItemPool::Put( rItem, nWhich ); +/*N*/ +/*N*/ // das Default-Pattern dieses Pools nicht kopieren +/*N*/ if (&rItem == ppPoolDefaults[ ATTR_PATTERN - ATTR_STARTINDEX ]) +/*N*/ return rItem; +/*N*/ +/*N*/ // ansonsten muss Put immer passieren, weil es ein anderer Pool sein kann +/*N*/ const SfxPoolItem& rNew = SfxItemPool::Put( rItem, nWhich ); +/*N*/ CheckRef( rNew ); +/*N*/ return rNew; +/*N*/ } + +/*N*/ void __EXPORT ScDocumentPool::Remove( const SfxPoolItem& rItem ) +/*N*/ { +/*N*/ if ( rItem.Which() == ATTR_PATTERN ) // nur Pattern ist special +/*N*/ { +/*N*/ ULONG nRef = rItem.GetRefCount(); +/*N*/ if ( nRef >= (ULONG) SC_MAX_POOLREF && nRef <= (ULONG) SFX_ITEMS_OLD_MAXREF ) +/*N*/ { +/*?*/ if ( nRef != (ULONG) SC_SAFE_POOLREF ) +/*?*/ { +/*?*/ DBG_ERROR("Wer fummelt da an meinen Ref-Counts herum"); +/*?*/ SetRefCount( (SfxPoolItem&)rItem, (ULONG) SC_SAFE_POOLREF ); +/*?*/ } +/*?*/ return; // nicht herunterzaehlen +/*N*/ } +/*N*/ } +/*N*/ SfxItemPool::Remove( rItem ); +/*N*/ } + +/*N*/ void ScDocumentPool::CheckRef( const SfxPoolItem& rItem ) // static +/*N*/ { +/*N*/ ULONG nRef = rItem.GetRefCount(); +/*N*/ if ( nRef >= (ULONG) SC_MAX_POOLREF && nRef <= (ULONG) SFX_ITEMS_OLD_MAXREF ) +/*N*/ { +/*?*/ // beim Apply vom Cache wird evtl. um 2 hochgezaehlt (auf MAX+1 oder SAFE+2), +/*?*/ // heruntergezaehlt wird nur einzeln (in LoadCompleted) +/*?*/ DBG_ASSERT( nRef<=(ULONG)SC_MAX_POOLREF+1 || (nRef>=(ULONG)SC_SAFE_POOLREF-1 && nRef<=(ULONG)SC_SAFE_POOLREF+2), +/*?*/ "ScDocumentPool::CheckRef" ); +/*?*/ SetRefCount( (SfxPoolItem&)rItem, (ULONG) SC_SAFE_POOLREF ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocumentPool::MyLoadCompleted() +/*N*/ { +/*N*/ LoadCompleted(); +/*N*/ +/*N*/ USHORT nCount = GetItemCount(ATTR_PATTERN); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ const SfxPoolItem* pItem = GetItem(ATTR_PATTERN, i); +/*N*/ if (pItem) +/*N*/ CheckRef(*pItem); +/*N*/ } +/*N*/ } + +// ---------------------------------------------------------------------------------------- + + + + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen2.cxx b/binfilter/bf_sc/source/core/data/sc_documen2.cxx new file mode 100644 index 000000000000..a1f5d4a5429f --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen2.cxx @@ -0,0 +1,1411 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define _BIGINT_HXX +#define _SFXMULTISEL_HXX +//#define _STACK_HXX +//#define _QUEUE_HXX +#define _DYNARR_HXX +#define _TREELIST_HXX +#define _CACHESTR_HXX +#define _NEW_HXX +//#define _SHL_HXX *** +//#define _LINK_HXX *** +//#define _ERRCODE_HXX *** +//#define _GEN_HXX *** +//#define _FRACT_HXX *** +//#define _STRING_HXX *** +//#define _MTF_HXX *** +//#define _CONTNR_HXX *** +//#define _LIST_HXX *** +//#define _TABLE_HXX *** +#define _DYNARY_HXX +//#define _UNQIDX_HXX *** +//#define _SVMEMPOOL_HXX *** +//#define _UNQID_HXX *** +//#define _DEBUG_HXX *** +//#define _DATE_HXX *** +//#define _TIME_HXX *** +//#define _DATETIME_HXX *** +//#define _INTN_HXX *** +//#define _WLDCRD_HXX *** +//#define _FSYS_HXX *** +//#define _STREAM_HXX *** +#define _CACHESTR_HXX +//#define _SV_MULTISEL_HXX + + + +#define _SV_NOXSOUND + +#define _BASDLG_HXX +#define _CACHESTR_HXX +#define _CTRLTOOL_HXX +#define _DLGCFG_HXX +#define _EXTATTR_HXX +#define _FILDLG_HXX +#define _FRM3D_HXX +#define _INTRO_HXX +#define _ISETBWR_HXX +#define _NO_SVRTF_PARSER_HXX +#define _MACRODLG_HXX +#define _MODALDLG_HXX +#define _MOREBUTTON_HXX +#define _OUTLINER_HXX +#define _PASSWD_HXX +//#define _QUEUE_HXX +#define _RULER_HXX +#define _SCRWIN_HXX +#define _SETBRW_HXX +#define _STATUS_HXX +#define _STDMENU_HXX +#define _TABBAR_HXX +#define _RULER_HXX +#define _SCRWIN_HXX +#define _SELENG_HXX +#define _SETBRW_HXX +#define _SOUND_HXX +#define _STATUS_HXX +#define _STDMENU_HXX + + +//#define _PRNDLG_HXX *** +//#define _POLY_HXX ** +// TOOLS +#define _BIGINT_HXX +#define _SFXMULTISEL_HXX +//#define _STACK_HXX +//#define _QUEUE_HXX +#define _DYNARR_HXX +#define _TREELIST_HXX +#define _CACHESTR_HXX + +//SV +//#define _CLIP_HXX +#define _CONFIG_HXX +#define _CURSOR_HXX +#define _FONTDLG_HXX +#define _PRVWIN_HXX + +#ifndef OS2 +#define _MENUBTN_HXX +#endif + +//#define _SOBASE_HXX +//#define _SOSTOR_HXX +//#define _SOCORE_HXX +//#define _SOINPL_HXX + +#define _SFX_DOCFILE_HXX +#define _SFX_DOCFILT_HXX +#define _SFX_DOCINF_HXX +#define _SFX_DOCSH_HXX +#define _SFX_INTERNO_HXX +#define _SFX_PRNMON_HXX +#define _SFX_RESMGR_HXX +#define _SFX_TEMPLDLG_HXX +#define _SFXAPPWIN_HXX +#define _SFXBASIC_HXX +#define _SFXCTRLITEM +#define _SFXDLGCFG_HXX +#define _SFXDISPATCH_HXX +#define _SFXDOCFILE_HXX +#define _SFXDOCMAN_HXX +#define _SFXDOCMGR_HXX +#define _SFXDOCTDLG_HXX +#define _SFXFILEDLG_HXX +#define _SFXIMGMGR_HXX +#define _SFXIPFRM_HXX +#define _SFX_MACRO_HXX +#define _SFXMNUITEM_HXX +#define _SFXMNUMGR_HXX +#define _SFXMULTISEL_HXX +//#define _SFXMSG_HXX +#define _SFXMSGDESCR_HXX +#define _SFXMSGPOOL_HXX +#define _SFX_MINFITEM_HXX +#define _SFXOBJFACE_HXX +#define _SFXOBJFAC_HXX +#define _SFX_SAVEOPT_HXX +#define _SFXSTBITEM_HXX +#define _SFXSTBMGR_HXX +#define _SFXTBXCTRL_HXX +#define _SFXTBXMGR_HXX + +//#define _SI_HXX +//#define SI_NODRW +#define _SI_DLL_HXX +#define _SIDLL_HXX +#define _SI_NOITEMS +#define _SI_NOOTHERFORMS +#define _SI_NOSBXCONTROLS +#define _SINOSBXCONTROLS +#define _SI_NODRW // +#define _SI_NOCONTROL +#define _VCBRW_HXX +#define _VCTRLS_HXX +//#define _VCSBX_HXX +#define _VCONT_HXX +#define _VDRWOBJ_HXX +#define _VCATTR_HXX + + +#define _SVBOXITM_HXX +#define _SVCONTNR_HXX +#define _SVDIALDLL_HXX +//#define _SVDATTR_HXX +#define _SVDRAG_HXX +#define _SVDXOUT_HXX +#define _SVDEC_HXX +#define _SVDIO_HXX +//#define _SVDLAYER_HXX +#define _SVINCVW_HXX +#define _SVRTV_HXX +#define _SVTABBX_HXX +#define _SVTREEBOX_HXX +#define _SVTREELIST_HXX + +#define _SVX_DAILDLL_HXX +#define _SVX_HYPHEN_HXX +#define _SVX_IMPGRF_HXX +#define _SVX_OPTITEMS_HXX +#define _SVX_OPTGERL_HXX +#define _SVX_OPTSAVE_HXX +#define _SVX_OPTSPELL_HXX +#define _SVX_OPTPATH_HXX +#define _SVX_OPTLINGU_HXX +#define _SVX_RULER_HXX +#define _SVX_RULRITEM_HXX +#define _SVX_SPLWRAP_HXX +#define _SVX_SPLDLG_HXX +#define _SVX_THESDLG_HXX + + +// INCLUDE --------------------------------------------------------------- + +#define _ZFORLIST_DECLARE_TABLE +#include "scitems.hxx" +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/forbiddencharacterstable.hxx> +#include <bf_svx/linkmgr.hxx> +#include <bf_sfx2/objsh.hxx> +#include <bf_sfx2/printer.hxx> +#include <bf_svtools/zformat.hxx> +#include <bf_svtools/PasswordHelper.hxx> +#include <tools/tenccvt.hxx> +#include <rtl/crc.h> + +#include "attrib.hxx" +#include "patattr.hxx" +#include "rangenam.hxx" +#include "dbcolect.hxx" +#include "pivot.hxx" +#include "docpool.hxx" +#include "stlpool.hxx" +#include "stlsheet.hxx" +#include "globstr.hrc" +#include "chartarr.hxx" +#include "rechead.hxx" +#include "bcaslot.hxx" +#include "addinlis.hxx" +#include "chartlis.hxx" +#include "validat.hxx" +#include "detdata.hxx" +#include "bf_sc.hrc" // FID_DATACHANGED +#include "chgtrack.hxx" +#include "chgviset.hxx" +#include "editutil.hxx" +#include "dpobject.hxx" +#include "indexmap.hxx" +#include "scrdata.hxx" +#include "poolhelp.hxx" +#include <legacysmgr/legacy_binfilters_smgr.hxx> //STRIP002 +namespace binfilter { +// STATIC DATA ----------------------------------------------------------- + +/*N*/ ScDocument::ScDocument( ScDocumentMode eMode, +/*N*/ SfxObjectShell* pDocShell ) : +/*N*/ xServiceManager( ::legacy_binfilters::getLegacyProcessServiceFactory() ), +/*N*/ pDrawLayer( NULL ), +/*N*/ pColorTable( NULL ), +/*N*/ pShell( pDocShell ), +/*N*/ pPrinter( NULL ), +/*N*/ bAutoCalc( eMode == SCDOCMODE_DOCUMENT ), +/*N*/ bAutoCalcShellDisabled( FALSE ), +/*N*/ bForcedFormulaPending( FALSE ), +/*N*/ bCalculatingFormulaTree( FALSE ), +/*N*/ bIsUndo( eMode == SCDOCMODE_UNDO ), +/*N*/ bIsClip( eMode == SCDOCMODE_CLIP ), +/*N*/ bCutMode( FALSE ), +/*N*/ nMaxTableNumber( 0 ), +/*N*/ pCondFormList( NULL ), +/*N*/ pValidationList( NULL ), +/*N*/ pFormatExchangeList( NULL ), +/*N*/ bIsEmbedded( FALSE ), +/*N*/ bProtected( FALSE ), +/*N*/ pLinkManager( NULL ), +/*N*/ pDocOptions( NULL ), +/*N*/ pViewOptions( NULL ), +/*N*/ pExtDocOptions( NULL ), +/*N*/ pConsolidateDlgData( NULL ), +/*N*/ pFormulaTree( NULL ), +/*N*/ pEOFormulaTree( NULL ), +/*N*/ aCurTextWidthCalcPos(MAXCOL,0,0), +/*N*/ // bNoSetDirty( TRUE ), +/*N*/ bNoSetDirty( FALSE ), +/*N*/ pFormulaTrack( NULL ), +/*N*/ pEOFormulaTrack( NULL ), +/*N*/ nFormulaTrackCount(0), +/*N*/ bInsertingFromOtherDoc( FALSE ), + bImportingXML( FALSE ), // #i41083# this has to be set in ScXMLImport::startDocument +/*N*/ nHardRecalcState(0), +/*N*/ bCalcingAfterLoad( FALSE ), +/*N*/ bNoListening( FALSE ), +/*N*/ bLoadingDone( TRUE ), +/*N*/ nVisibleTab( 0 ), +/*N*/ bIdleDisabled( FALSE ), +/*N*/ bInLinkUpdate( FALSE ), +/*N*/ bDetectiveDirty( FALSE ), +/*N*/ nMacroCallMode( SC_MACROCALL_ALLOWED ), +/*N*/ bHasMacroFunc( FALSE ), +/*N*/ bChartListenerCollectionNeedsUpdate( FALSE ), +/*N*/ bHasForcedFormulas( FALSE ), +/*N*/ nVisSpellState( 0 ), +/*N*/ pOtherObjects( NULL ), +/*N*/ pClipData( NULL ), +/*N*/ nFormulaCodeInTree(0), +/*N*/ nInterpretLevel(0), +/*N*/ nMacroInterpretLevel(0), +/*N*/ nInterpreterTableOpLevel(0), +/*N*/ bLostData(FALSE), +/*N*/ pDetOpList(NULL), +/*N*/ bInDtorClear( FALSE ), +/*N*/ bExpandRefs( FALSE ), +/*N*/ pUnoBroadcaster( NULL ), +/*N*/ pChangeTrack( NULL ), +/*N*/ pChangeViewSettings( NULL ), +/*N*/ pEditEngine( NULL ), +/*N*/ eLinkMode(LM_UNKNOWN), +/*N*/ pDPCollection( NULL ), +/*N*/ pScriptTypeData( NULL ), +/*N*/ nAsianCompression(SC_ASIANCOMPRESSION_INVALID), +/*N*/ nAsianKerning(SC_ASIANKERNING_INVALID), +/*N*/ pLoadedSymbolStringCellList( NULL ), +/*N*/ bPastingDrawFromOtherDoc( FALSE ), +/*N*/ pCacheFieldEditEngine( NULL ), +/*N*/ nInDdeLinkUpdate( 0 ), +/*N*/ nXMLImportedFormulaCount( 0 ), +/*N*/ bInUnoBroadcast( FALSE ), +/*N*/ bStyleSheetUsageInvalid( TRUE ) +/*N*/ { +/*N*/ eSrcSet = gsl_getSystemTextEncoding(); +/*N*/ nSrcVer = SC_CURRENT_VERSION; +/*N*/ nSrcMaxRow = MAXROW; +/*N*/ +/*N*/ if ( eMode == SCDOCMODE_DOCUMENT ) +/*N*/ { +/*N*/ if ( pDocShell ) +/*N*/ pLinkManager = new SvxLinkManager( pDocShell ); +/*N*/ +/*N*/ xPoolHelper = new ScPoolHelper( this ); +/*N*/ +/*N*/ pTab[0] = NULL; +/*N*/ pBASM = new ScBroadcastAreaSlotMachine( this ); +/*N*/ pChartListenerCollection = new ScChartListenerCollection( this ); +/*N*/ pRefreshTimerControl = new ScRefreshTimerControl; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pTab[0] = NULL; +/*N*/ pBASM = NULL; +/*N*/ pChartListenerCollection = NULL; +/*N*/ pRefreshTimerControl = NULL; +/*N*/ } +/*N*/ +/*N*/ for (USHORT i=1; i<=MAXTAB; i++) +/*N*/ pTab[i] = NULL; +/*N*/ +/*N*/ pRangeName = new ScRangeName( 4, 4, FALSE, this ); +/*N*/ pDBCollection = new ScDBCollection( 4, 4, FALSE, this ); +/*N*/ pPivotCollection = new ScPivotCollection(4, 4, this ); +/*N*/ pSelectionAttr = NULL; +/*N*/ pChartCollection = new ScChartCollection; +/*N*/ xColNameRanges = new ScRangePairList; +/*N*/ xRowNameRanges = new ScRangePairList; +/*N*/ ImplCreateOptions(); +/*N*/ // languages for a visible document are set by docshell later (from options) +/*N*/ SetLanguage( ScGlobal::eLnge, ScGlobal::eLnge, ScGlobal::eLnge ); +/*N*/ +/*N*/ aTrackTimer.SetTimeoutHdl( LINK( this, ScDocument, TrackTimeHdl ) ); +/*N*/ aTrackTimer.SetTimeout( 100 ); +/*N*/ } + + + + +/*N*/ void ScDocument::StartChangeTracking() // Changetracking.sdc +/*N*/ { +/*N*/ if (!pChangeTrack) +/*N*/ pChangeTrack = new ScChangeTrack( this ); +/*N*/ } + +/*N*/ void ScDocument::EndChangeTracking() // Changetracking.sdc +/*N*/ { +/*N*/ delete pChangeTrack; +/*N*/ pChangeTrack = NULL; +/*N*/ } + +/*N*/ void ScDocument::SetChangeTrack( ScChangeTrack* pTrack ) +/*N*/ { + // #i49161# this is needed to save documents with change tracking + DBG_ASSERT( pTrack->GetDocument() == this, "SetChangeTrack: different documents" ); + if ( !pTrack || pTrack == pChangeTrack || pTrack->GetDocument() != this ) + return ; + EndChangeTracking(); + pChangeTrack = pTrack; +/*N*/ } + + +/*N*/ IMPL_LINK( ScDocument, TrackTimeHdl, Timer*, pTimer ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( ScDdeLink::IsInUpdate() ) // nicht verschachteln +/*N*/ return 0; +/*N*/ } + + +/*N*/ ScDocument::~ScDocument() +/*N*/ { +/*N*/ DBG_ASSERT( !bInLinkUpdate, "bInLinkUpdate in dtor" ); +/*N*/ +/*N*/ bInDtorClear = TRUE; +/*N*/ +/*N*/ // first of all disable all refresh timers by deleting the control +/*N*/ if ( pRefreshTimerControl ) +/*N*/ { // To be sure there isn't anything running do it with a protector, +/*N*/ // this ensures also that nothing needs the control anymore. +/*N*/ ScRefreshTimerProtector aProt( GetRefreshTimerControlAddress() ); +/*N*/ delete pRefreshTimerControl, pRefreshTimerControl = NULL; +/*N*/ } +/*N*/ +/*N*/ // Links aufrauemen +/*N*/ +/*N*/ if ( pLinkManager ) +/*N*/ { +/*N*/ // BaseLinks freigeben +/*N*/ for ( USHORT n = pLinkManager->GetServers().Count(); n; ) +/*?*/ pLinkManager->GetServers()[ --n ]->Closed(); +/*N*/ +/*N*/ if ( pLinkManager->GetLinks().Count() ) +/*N*/ pLinkManager->Remove( 0, pLinkManager->GetLinks().Count() ); +/*N*/ } +/*N*/ +/*N*/ ScAddInAsync::RemoveDocument( this ); +/*N*/ ScAddInListener::RemoveDocument( this ); +/*N*/ delete pChartListenerCollection; // vor pBASM wg. evtl. Listener! +/*N*/ pChartListenerCollection = NULL; +/*N*/ // BroadcastAreas vor allen Zellen zerstoeren um unnoetige +/*N*/ // Einzel-EndListenings der Formelzellen zu vermeiden +/*N*/ delete pBASM; // BroadcastAreaSlotMachine +/*N*/ pBASM = NULL; +/*N*/ +/*N*/ if (pUnoBroadcaster) +/*N*/ { +/*N*/ delete pUnoBroadcaster; // broadcasted nochmal SFX_HINT_DYING +/*N*/ pUnoBroadcaster = NULL; +/*N*/ } +/*N*/ +/*N*/ Clear(); +/*N*/ +/*N*/ if (pCondFormList) +/*N*/ { +/*N*/ pCondFormList->DeleteAndDestroy( 0, pCondFormList->Count() ); +/*N*/ DELETEZ(pCondFormList); +/*N*/ } +/*N*/ if (pValidationList) +/*N*/ { +/*N*/ pValidationList->DeleteAndDestroy( 0, pValidationList->Count() ); +/*N*/ DELETEZ(pValidationList); +/*N*/ } +/*N*/ delete pRangeName; +/*N*/ delete pDBCollection; +/*N*/ delete pPivotCollection; +/*N*/ delete pSelectionAttr; +/*N*/ delete pChartCollection; +/*N*/ DeleteDrawLayer(); +/*N*/ delete pFormatExchangeList; +/*N*/ delete pPrinter; +/*N*/ ImplDeleteOptions(); +/*N*/ delete pConsolidateDlgData; +/*N*/ delete pLinkManager; +/*N*/ delete pClipData; +/*N*/ delete pDetOpList; // loescht auch die Eintraege +/*N*/ delete pChangeTrack; +/*N*/ delete pEditEngine; +/*N*/ delete pChangeViewSettings; // und weg damit +/*N*/ +/*N*/ delete pDPCollection; +/*N*/ +/*N*/ // delete the EditEngine before destroying the xPoolHelper +/*N*/ delete pCacheFieldEditEngine; +/*N*/ +/*N*/ if ( xPoolHelper.is() && !bIsClip ) +/*N*/ xPoolHelper->SourceDocumentGone(); +/*N*/ xPoolHelper.clear(); +/*N*/ +/*N*/ DeleteColorTable(); +/*N*/ delete pScriptTypeData; +/*N*/ delete pOtherObjects; +/*N*/ +/*N*/ } + + +/*N*/ SvNumberFormatter* ScDocument::GetFormatTable() const +/*N*/ { +/*N*/ return xPoolHelper->GetFormTable(); +/*N*/ } + +/*N*/ SfxItemPool* ScDocument::GetEditPool() const +/*N*/ { +/*N*/ return xPoolHelper->GetEditPool(); +/*N*/ } + +/*N*/ SfxItemPool* ScDocument::GetEnginePool() const +/*N*/ { +/*N*/ return xPoolHelper->GetEnginePool(); +/*N*/ } + +/*N*/ ScFieldEditEngine& ScDocument::GetEditEngine() +/*N*/ { +/*N*/ if ( !pEditEngine ) +/*N*/ { +/*N*/ pEditEngine = new ScFieldEditEngine( GetEnginePool(), GetEditPool() ); +/*N*/ pEditEngine->SetUpdateMode( FALSE ); +/*N*/ pEditEngine->EnableUndo( FALSE ); +/*N*/ pEditEngine->SetRefMapMode( MAP_100TH_MM ); +/*N*/ pEditEngine->SetForbiddenCharsTable( xForbiddenCharacters ); +/*N*/ } +/*N*/ return *pEditEngine; +/*N*/ } + +/*N*/ void ScDocument::ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if (bIsClip) +/*N*/ } + +/*N*/ void lcl_RefreshPivotData( ScPivotCollection* pColl ) +/*N*/ { +/*N*/ USHORT nCount = pColl->GetCount(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScPivot* pPivot = (*pColl)[i]; +/*N*/ if (pPivot->CreateData(TRUE)) +/*N*/ pPivot->ReleaseData(); +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::SymbolStringCellsPending() const +/*N*/ { +/*N*/ return pLoadedSymbolStringCellList && pLoadedSymbolStringCellList->Count(); +/*N*/ } + + +/*N*/ List& ScDocument::GetLoadedSymbolStringCellsList() +/*N*/ { +/*N*/ if ( !pLoadedSymbolStringCellList ) +/*N*/ pLoadedSymbolStringCellList = new List; +/*N*/ return *pLoadedSymbolStringCellList; +/*N*/ } + + +/*N*/ BOOL ScDocument::Load( SvStream& rStream, ScProgress* pProgress ) +/*N*/ { +/*N*/ bLoadingDone = FALSE; +/*N*/ +/*N*/ //---------------------------------------------------- +/*N*/ +/*N*/ Clear(); +/*N*/ USHORT nOldBufSize = rStream.GetBufferSize(); +/*N*/ rStream.SetBufferSize( 32768 ); +/*N*/ +/*N*/ // Progress-Bar +/*N*/ +/*N*/ // ULONG nCurPos = rStream.Tell(); +/*N*/ // ULONG nEndPos = rStream.Seek( STREAM_SEEK_TO_END ); +/*N*/ // rStream.Seek( nCurPos ); +/*N*/ // ScProgress aProgress( NULL, ScGlobal::GetRscString(STR_LOAD_DOC), nEndPos - nCurPos ); +/*N*/ +/*N*/ BOOL bError = FALSE; +/*N*/ USHORT nVersion = 0; +/*N*/ USHORT nVerMaxRow = MAXROW_30; // 8191, wenn in der Datei nichts steht +/*N*/ USHORT nTab = 0; +/*N*/ USHORT nEnumDummy; +/*N*/ String aEmptyName; +/*N*/ String aPageStyle; +/*N*/ CharSet eOldSet = rStream.GetStreamCharSet(); +/*N*/ +/*N*/ USHORT nID; +/*N*/ rStream >> nID; +/*N*/ if (nID == SCID_DOCUMENT || nID == SCID_NEWDOCUMENT ) +/*N*/ { +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ while (aHdr.BytesLeft() && !bError ) +/*N*/ { +/*N*/ USHORT nSubID; +/*N*/ rStream >> nSubID; +/*N*/ switch (nSubID) +/*N*/ { +/*N*/ case SCID_DOCFLAGS: +/*N*/ { +/*N*/ ScReadHeader aFlagsHdr( rStream ); +/*N*/ +/*N*/ rStream >> nVersion; // 312 abwaerts +/*N*/ rStream.ReadByteString( aPageStyle, rStream.GetStreamCharSet() ); +/*N*/ rStream >> bProtected; // Dokument geschuetzt +/*N*/ String aPass; +/*N*/ rStream.ReadByteString( aPass, rStream.GetStreamCharSet() ); +/*N*/ if (aPass.Len()) +/*?*/ SvPasswordHelper::GetHashPassword(aProtectPass, aPass); +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ { +/*N*/ rStream >> nEnumDummy; +/*N*/ eLanguage = LanguageType( nEnumDummy ); +/*N*/ } +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ rStream >> bAutoCalc; +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ rStream >> nVisibleTab; +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ rStream >> nVersion; // echte Version +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ rStream >> nVerMaxRow; // sonst auf 8191 lassen +/*N*/ +/*N*/ nSrcVer = nVersion; // Member +/*N*/ nSrcMaxRow = nVerMaxRow; // Member +/*N*/ +/*N*/ // Fuer Debugging bis hin zur SC 3.0a: +/*N*/ if( nVersion > 0x0002 && nVersion < SC_NUMFMT ) +/*N*/ { +/*N*/ bError = TRUE; +/*N*/ rStream.SetError( SVSTREAM_WRONGVERSION ); +/*N*/ } +/*N*/ +/*N*/ // Das obere Byte muss kleiner oder gleich sein +/*N*/ // (3.1 Dateien mit 8192 Zeilen koennen noch gelesen werden) +/*N*/ +/*N*/ if( ( nSrcVer & 0xFF00 ) > ( SC_CURRENT_VERSION & 0xFF00 ) ) +/*N*/ { +/*N*/ bError = TRUE; +/*N*/ rStream.SetError( SVSTREAM_WRONGVERSION ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SCID_CHARSET: +/*N*/ { +/*N*/ ScReadHeader aSetHdr( rStream ); +/*N*/ BYTE cSet, cGUI; // cGUI is dummy, old GUIType +/*N*/ rStream >> cGUI >> cSet; +/*N*/ eSrcSet = (CharSet) cSet; +/*N*/ rStream.SetStreamCharSet( ::GetSOLoadTextEncoding( +/*N*/ eSrcSet, (USHORT)rStream.GetVersion() ) ); +/*N*/ } +/*N*/ break; +/*?*/ case SCID_LINKUPMODE: // Link Update Mode +/*?*/ { +/*?*/ ScReadHeader aSetHdr( rStream ); +/*?*/ BYTE cSet; +/*?*/ rStream >> cSet; +/*?*/ eLinkMode=(ScLkUpdMode) cSet; +/*?*/ } +/*?*/ break; +/*N*/ case SCID_TABLE: +/*N*/ pTab[nTab] = new ScTable(this, nTab, aEmptyName); +/*N*/ pTab[nTab]->SetPageStyle( aPageStyle ); +/*N*/ pTab[nTab]->Load(rStream,nVersion,pProgress); +/*N*/ ++nTab; +/*N*/ break; +/*N*/ case SCID_DRAWING: +/*N*/ LoadDrawLayer(rStream); +/*N*/ break; +/*N*/ case SCID_DDELINKS: +/*N*/ LoadDdeLinks(rStream); +/*N*/ break; +/*N*/ case SCID_AREALINKS: +/*N*/ LoadAreaLinks(rStream); +/*N*/ break; +/*N*/ case SCID_RANGENAME: +/*N*/ pRangeName->Load(rStream, nVersion ); +/*N*/ break; +/*N*/ case SCID_DBAREAS: +/*N*/ pDBCollection->Load( rStream ); +/*N*/ break; +/*?*/ case SCID_DATAPILOT: +/*?*/ GetDPCollection()->LoadNew( rStream ); +/*?*/ break; +/*N*/ case SCID_PIVOT: +/*N*/ pPivotCollection->Load( rStream ); +/*N*/ break; +/*N*/ case SCID_CHARTS: +/*N*/ pChartCollection->Load( this, rStream ); +/*N*/ break; +/*N*/ case SCID_COLNAMERANGES: +/*N*/ xColNameRanges->Load( rStream, nVersion ); +/*N*/ break; +/*N*/ case SCID_ROWNAMERANGES: +/*N*/ xRowNameRanges->Load( rStream, nVersion ); +/*N*/ break; +/*N*/ case SCID_CONDFORMATS: +/*N*/ if (!pCondFormList) +/*N*/ pCondFormList = new ScConditionalFormatList; +/*N*/ pCondFormList->Load( rStream, this ); +/*N*/ break; +/*N*/ case SCID_VALIDATION: +/*N*/ if (!pValidationList) +/*N*/ pValidationList = new ScValidationDataList; +/*N*/ pValidationList->Load( rStream, this ); +/*N*/ break; +/*N*/ case SCID_DETOPLIST: +/*N*/ if (!pDetOpList) +/*N*/ pDetOpList = new ScDetOpList; +/*N*/ pDetOpList->Load( rStream ); +/*N*/ break; +/*N*/ case SCID_NUMFORMAT: +/*N*/ { +/*N*/ ScReadHeader aNumHeader(rStream); +/*N*/ xPoolHelper->GetFormTable()->Load(rStream); +/*N*/ } +/*N*/ break; +/*N*/ case SCID_DOCOPTIONS: +/*N*/ ImplLoadDocOptions(rStream); +/*N*/ break; +/*N*/ case SCID_VIEWOPTIONS: +/*N*/ ImplLoadViewOptions(rStream); +/*N*/ break; +/*N*/ case SCID_PRINTSETUP: +/*N*/ { +/*N*/ ScReadHeader aJobHeader(rStream); +/*N*/ SfxItemSet* pSet = new SfxItemSet( *xPoolHelper->GetDocPool(), +/*N*/ SID_PRINTER_NOTFOUND_WARN, SID_PRINTER_NOTFOUND_WARN, +/*N*/ SID_PRINTER_CHANGESTODOC, SID_PRINTER_CHANGESTODOC, +/*N*/ SID_SCPRINTOPTIONS, SID_SCPRINTOPTIONS, +/*N*/ NULL ); +/*N*/ SetPrinter( SfxPrinter::Create( rStream, pSet ) ); +/*N*/ } +/*N*/ break; +/*?*/ case SCID_CONSOLIDATA: +/*?*/ if (!pConsolidateDlgData) +/*?*/ pConsolidateDlgData = new ScConsolidateParam; +/*?*/ pConsolidateDlgData->Load( rStream ); +/*?*/ break; +/*?*/ case SCID_CHANGETRACK: +/*N*/ if ( pChangeTrack ) // Changetracking.sdc +/*N*/ /*?*/ pChangeTrack->Clear(); // es kann nur einen geben +/*N*/ /*?*/ else +/*N*/ /*?*/ StartChangeTracking(); +/*N*/ /*?*/ pChangeTrack->Load( rStream, nVersion ); +/*?*/ break; +/*N*/ case SCID_CHGVIEWSET: +/*N*/ if (!pChangeViewSettings) +/*N*/ pChangeViewSettings = new ScChangeViewSettings; +/*N*/ pChangeViewSettings->Load( rStream, nVersion ); +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ DBG_ERROR("unbekannter Sub-Record in ScDocument::Load"); +/*N*/ ScReadHeader aDummyHdr( rStream ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (rStream.GetError() != SVSTREAM_OK) +/*N*/ bError = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // Assertion nur, wenn kein Passwort gesetzt ist +/*N*/ DBG_ASSERT( rStream.GetKey().Len(), "Load: SCID_DOCUMENT nicht gefunden" ); +/*N*/ bError = TRUE; +/*N*/ } +/*N*/ +/*N*/ rStream.SetStreamCharSet( eOldSet ); +/*N*/ rStream.SetBufferSize( nOldBufSize ); +/*N*/ +/*N*/ if (!bError) // Neuberechnungen +/*N*/ { +/*N*/ xPoolHelper->GetStylePool()->UpdateStdNames(); // falls mit Version in anderer Sprache gespeichert +/*N*/ +/*N*/ // Zahlformat-Sprache +/*N*/ // (kann nicht in LoadPool passieren, weil der Numberformatter geladen sein muss) +/*N*/ +/*N*/ ScDocumentPool* pPool = xPoolHelper->GetDocPool(); +/*N*/ if ( pPool->GetLoadingVersion() == 0 ) // 0 = Pool-Version bis 3.1 +/*N*/ { +/*N*/ // in 3.1-Dokumenten gibt es ATTR_LANGUAGE_FORMAT noch nicht +/*N*/ // darum bei Bedarf zu ATTR_VALUE_FORMAT noch die Sprache dazutun +/*N*/ // (Bug #37441#) +/*N*/ +/*N*/ // harte Attribute: +/*N*/ +/*N*/ SvNumberFormatter* pFormatter = xPoolHelper->GetFormTable(); +/*N*/ USHORT nCount = pPool->GetItemCount(ATTR_PATTERN); +/*N*/ ScPatternAttr* pPattern; +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ pPattern = (ScPatternAttr*)pPool->GetItem(ATTR_PATTERN, i); +/*N*/ if (pPattern) +/*N*/ ScGlobal::AddLanguage( pPattern->GetItemSet(), *pFormatter ); +/*N*/ } +/*N*/ +/*N*/ // Vorlagen: +/*N*/ +/*N*/ SfxStyleSheetIterator aIter( xPoolHelper->GetStylePool(), SFX_STYLE_FAMILY_PARA ); +/*N*/ for ( SfxStyleSheetBase* pStyle = aIter.First(); pStyle; pStyle = aIter.Next() ) +/*N*/ ScGlobal::AddLanguage( pStyle->GetItemSet(), *pFormatter ); +/*N*/ } +/*N*/ +/*N*/ // change FontItems in styles +/*N*/ xPoolHelper->GetStylePool()->ConvertFontsAfterLoad(); +/*N*/ +/*N*/ // Druckbereiche etc. +/*N*/ +/*N*/ SfxStyleSheetIterator aIter( xPoolHelper->GetStylePool(), SFX_STYLE_FAMILY_PAGE ); +/*N*/ ScStyleSheet* pStyleSheet = NULL; +/*N*/ +/*N*/ nMaxTableNumber = 0; +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ { +/*N*/ // MaxTableNumber ermitteln +/*N*/ +/*N*/ nMaxTableNumber = i+1; +/*N*/ +/*N*/ // Druckbereiche aus <= 3.00.2 Dokumenten +/*N*/ // aus den PageStyles holen und jetzt an +/*N*/ // der Tabelle speichern. +/*N*/ +/*N*/ pStyleSheet = (ScStyleSheet*)aIter.Find( pTab[i]->GetPageStyle() ); +/*N*/ +/*N*/ if ( pStyleSheet ) +/*N*/ { +/*N*/ SfxItemSet& rSet = pStyleSheet->GetItemSet(); +/*N*/ const ScRangeItem* pPrintAreaItem = NULL; +/*N*/ const ScRangeItem* pRepeatColItem = NULL; +/*N*/ const ScRangeItem* pRepeatRowItem = NULL; +/*N*/ +/*N*/ rSet.GetItemState( ATTR_PAGE_PRINTAREA, TRUE, +/*N*/ (const SfxPoolItem**)&pPrintAreaItem ); +/*N*/ rSet.GetItemState( ATTR_PAGE_REPEATCOL, TRUE, +/*N*/ (const SfxPoolItem**)&pRepeatColItem ); +/*N*/ rSet.GetItemState( ATTR_PAGE_REPEATROW, TRUE, +/*N*/ (const SfxPoolItem**)&pRepeatRowItem ); +/*N*/ +/*N*/ if ( pPrintAreaItem ) // Druckbereiche +/*N*/ { +/*N*/ if ( !pPrintAreaItem->GetFlags() ) +/*N*/ { +/*N*/ SetPrintRangeCount( i, 1 ); +/*N*/ SetPrintRange( i, 0, pPrintAreaItem->GetRange() ); +/*N*/ } +/*N*/ rSet.ClearItem( ATTR_PAGE_PRINTAREA ); +/*N*/ } +/*N*/ +/*N*/ if ( pRepeatColItem ) // Wiederholungsspalte +/*N*/ { +/*?*/ SetRepeatColRange( i, !pRepeatColItem->GetFlags() +/*?*/ ? &pRepeatColItem->GetRange() +/*?*/ : (const ScRange *)NULL ); +/*?*/ rSet.ClearItem( ATTR_PAGE_REPEATCOL ); +/*N*/ } +/*N*/ +/*N*/ if ( pRepeatRowItem ) // Wiederholungszeile +/*N*/ { +/*?*/ SetRepeatRowRange( i, !pRepeatRowItem->GetFlags() +/*?*/ ? &pRepeatRowItem->GetRange() +/*?*/ : (const ScRange *)NULL ); +/*?*/ rSet.ClearItem( ATTR_PAGE_REPEATROW ); +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ +/*N*/ if ( pDPCollection && pDPCollection->GetCount() ) +/*?*/ pPivotCollection->FreeAll(); +/*N*/ else +/*N*/ { +/*N*/ lcl_RefreshPivotData( pPivotCollection ); +/*N*/ GetDPCollection()->ConvertOldTables( *pPivotCollection ); +/*N*/ } +/*N*/ if ( pDPCollection ) +/*N*/ pDPCollection->EnsureNames(); // make sure every table has a name +/*N*/ +/*N*/ SetAutoFilterFlags(); +/*N*/ if (pDrawLayer) +/*N*/ UpdateAllCharts(); +/*N*/ #ifdef DBG_UTIL +/*N*/ //2do: wg. #62107 +/*N*/ // ChartListenerCollection speichern/laden, damit nach dem Laden das Update +/*N*/ // hier einmal eingespart werden kann und somit nicht mehr alle Charts +/*N*/ // angefasst werden muessen. Die ChartListenerCollection muss dann zum Master +/*N*/ // der Referenzen werden. +/*N*/ // static BOOL bShown = 0; +/*N*/ // if ( !bShown && SOFFICE_FILEFORMAT_NOW > SOFFICE_FILEFORMAT_50 ) +/*N*/ // { +/*N*/ // bShown = 1; +/*N*/ // DBG_ERRORFILE( "bei inkompatiblem FileFormat ChartListenerCollection speichern!" ); +/*N*/ // } +/*N*/ #endif +/*N*/ UpdateChartListenerCollection(); +/*N*/ if (pDrawLayer) +/*N*/ RefreshNoteFlags(); +/*N*/ CalcAfterLoad(); +/*N*/ } +/*N*/ +/*N*/ if ( pLoadedSymbolStringCellList ) +/*N*/ { // we had symbol string cells, list was cleared by columns, delete it +/*N*/ delete pLoadedSymbolStringCellList; +/*N*/ pLoadedSymbolStringCellList = NULL; +/*N*/ } +/*N*/ +/*N*/ //---------------------------------------------------- +/*N*/ +/*N*/ bLoadingDone = TRUE; +/*N*/ +/*N*/ return !bError; +/*N*/ } + +/*N*/ BOOL ScDocument::Save( SvStream& rStream, ScProgress* pProgress ) const +/*N*/ { +/*N*/ ((ScDocument*)this)->bLoadingDone = FALSE; // nicht zwischendrin reinpfuschen lassen +/*N*/ +/*N*/ ((ScDocument*)this)->bLostData = FALSE; // wird beim Speichern gesetzt +/*N*/ +/*N*/ ((ScDocument*)this)->nSrcVer = SC_CURRENT_VERSION; +/*N*/ ((ScDocument*)this)->nSrcMaxRow = MAXROW; +/*N*/ if ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_31 ) +/*N*/ { +/*N*/ // 3.1 Export -> nur 8192 Zeilen schreiben, und kompatible Versionsnummer +/*N*/ +/*N*/ ((ScDocument*)this)->nSrcVer = SC_31_EXPORT_VER; +/*N*/ ((ScDocument*)this)->nSrcMaxRow = MAXROW_30; +/*N*/ } +/*N*/ else if ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_40 ) +/*N*/ { // 4.0 Export -> kompatible Versionsnummer +/*N*/ ((ScDocument*)this)->nSrcVer = SC_40_EXPORT_VER; +/*N*/ } +/*N*/ +/*N*/ USHORT i; +/*N*/ USHORT nOldBufSize = rStream.GetBufferSize(); +/*N*/ rStream.SetBufferSize( 32768 ); +/*N*/ +/*N*/ CharSet eOldSet = rStream.GetStreamCharSet(); +/*N*/ CharSet eStoreCharSet = ::GetSOStoreTextEncoding( +/*N*/ gsl_getSystemTextEncoding(), (USHORT)rStream.GetVersion() ); +/*N*/ rStream.SetStreamCharSet( eStoreCharSet ); +/*N*/ +/*N*/ +/*N*/ // Progress-Bar +/*N*/ +/*N*/ long nSavedDocCells = 0; +/*N*/ // ScProgress aProgress( NULL, ScGlobal::GetRscString( STR_SAVE_DOC ), GetWeightedCount() + 1 ); +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_NEWDOCUMENT; +/*N*/ ScWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ // Flags +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_DOCFLAGS; +/*N*/ ScWriteHeader aFlagsHdr( rStream, 18 ); //! ausprobieren +/*N*/ +/*N*/ // wg. Bug in 312 ScToken::RelToRelAbs mit DoubleRefs bekommt +/*N*/ // die 312er immer vorgegaukelt, dass es keine RelRefs gaebe, +/*N*/ // was auch ok ist, da immer absolut gespeichert wird und +/*N*/ // SR_RELATIVE nie zur Verwendung kam und nicht kommen darf. +/*N*/ if ( nSrcVer & 0xFF00 ) +/*N*/ rStream << (USHORT) nSrcVer; +/*N*/ // hoehere Major-Version darf von 312 nicht geladen werden +/*N*/ else +/*N*/ rStream << (USHORT) (SC_RELATIVE_REFS - 1); +/*N*/ +/*N*/ // dummy page style (for compatibility) +/*N*/ rStream.WriteByteString( +/*N*/ String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(STRING_STANDARD)), +/*N*/ rStream.GetStreamCharSet() ); +/*N*/ rStream << bProtected; // Dokument geschuetzt +/*N*/ String aPass; +/*N*/ //rStream.WriteByteString( aProtectPass, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aPass, rStream.GetStreamCharSet() ); +/*N*/ rStream << (USHORT) eLanguage; +/*N*/ rStream << bAutoCalc; +/*N*/ +/*N*/ rStream << nVisibleTab; +/*N*/ +/*N*/ // und hier jetzt die echte Versionsnummer +/*N*/ rStream << (USHORT) nSrcVer; +/*N*/ +/*N*/ rStream << nSrcMaxRow; // Zeilenanzahl +/*N*/ } +/*N*/ +/*N*/ // Zeichensatz +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_CHARSET; +/*N*/ ScWriteHeader aSetHdr( rStream, 2 ); +/*N*/ rStream << (BYTE) 0 // dummy, old System::GetGUIType() +/*N*/ << (BYTE) eStoreCharSet; +/*N*/ } +/*N*/ +/*N*/ // Link Update Mode +/*N*/ +/*N*/ if(eLinkMode!=LM_UNKNOWN) +/*N*/ { +/*?*/ rStream << (USHORT) SCID_LINKUPMODE; +/*?*/ ScWriteHeader aSetHdr( rStream, 1 ); +/*?*/ rStream << (BYTE) eLinkMode; +/*N*/ } +/*N*/ +/*N*/ rStream << (USHORT) SCID_RANGENAME; +/*N*/ pRangeName->Store( rStream ); +/*N*/ +/*N*/ rStream << (USHORT) SCID_DBAREAS; +/*N*/ pDBCollection->Store( rStream ); +/*N*/ +/*N*/ rStream << (USHORT) SCID_DDELINKS; +/*N*/ SaveDdeLinks( rStream ); +/*N*/ +/*N*/ rStream << (USHORT) SCID_AREALINKS; +/*N*/ SaveAreaLinks( rStream ); +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_NUMFORMAT; +/*N*/ ScWriteHeader aNumHeader(rStream); +/*N*/ xPoolHelper->GetFormTable()->Save(rStream); +/*N*/ } +/*N*/ +/*N*/ if ( xColNameRanges->Count() ) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_COLNAMERANGES; +/*N*/ xColNameRanges->Store( rStream ); +/*N*/ } +/*N*/ if ( xRowNameRanges->Count() ) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_ROWNAMERANGES; +/*N*/ xRowNameRanges->Store( rStream ); +/*N*/ } +/*N*/ +/*N*/ if (pCondFormList) +/*N*/ pCondFormList->ResetUsed(); // wird beim Speichern der Tabellen gesetzt +/*N*/ if (pValidationList) +/*N*/ pValidationList->ResetUsed(); // wird beim Speichern der Tabellen gesetzt +/*N*/ +/*N*/ // Tabellen (Daten) +/*N*/ +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ { +/*N*/ if (pTab[i]) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_TABLE; +/*N*/ pTab[i]->Save(rStream, nSavedDocCells, pProgress); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // bedingte Formate / Gueltigkeit +/*N*/ // beim Speichern der Tabellen ist eingetragen worden, +/*N*/ // welche Eintraege benutzt werden +/*N*/ +/*N*/ if (pCondFormList) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_CONDFORMATS; +/*N*/ pCondFormList->Store(rStream); +/*N*/ } +/*N*/ if (pValidationList) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_VALIDATION; +/*N*/ pValidationList->Store(rStream); +/*N*/ } +/*N*/ +/*N*/ // Liste der Detektiv-Operationen (zum Aktualisieren) +/*N*/ if (pDetOpList) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_DETOPLIST; +/*N*/ pDetOpList->Store(rStream); +/*N*/ } +/*N*/ +/*N*/ // Drawing +/*N*/ +/*N*/ // if (pDrawLayer && pDrawLayer->HasObjects()) +/*N*/ // auch ohne Objekte - wegen ColorTable etc. +/*N*/ +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_DRAWING; +/*N*/ StoreDrawLayer(rStream); +/*N*/ } +/*N*/ +/*N*/ // Collections +/*N*/ +/*N*/ // (new) DataPilot collection must be saved before old Pivot collection +/*N*/ // so old data can be skipped by new office +/*N*/ // not in 3.0 or 4.0 export to avoid warning messages +/*N*/ +/*N*/ if ( nSrcVer > SC_40_EXPORT_VER && pDPCollection && pDPCollection->GetCount() ) +/*N*/ { +/*?*/ rStream << (USHORT) SCID_DATAPILOT; // new data +/*?*/ pDPCollection->StoreNew( rStream ); +/*N*/ } +/*N*/ +/*N*/ rStream << (USHORT) SCID_PIVOT; // old data +/*N*/ if ( pDPCollection && pDPCollection->GetCount() ) +/*N*/ pDPCollection->StoreOld( rStream ); +/*N*/ else +/*N*/ pPivotCollection->Store( rStream ); // not converted or all empty +/*N*/ +/*N*/ // Charts werden hier nicht mehr gespeichert, weil +/*N*/ // jedes Chart seine Daten selber speichert +/*N*/ +/*N*/ DBG_ASSERT(!pChartCollection || !pChartCollection->GetCount(), +/*N*/ "wer hat da ein Chart eingetragen?"); +/*N*/ +/*N*/ rStream << (USHORT) SCID_DOCOPTIONS; +/*N*/ ImplSaveDocOptions(rStream); +/*N*/ +/*N*/ rStream << (USHORT) SCID_VIEWOPTIONS; +/*N*/ ImplSaveViewOptions(rStream); +/*N*/ +/*N*/ // Job-Setup vom Printer +/*N*/ +/*N*/ if (pPrinter) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_PRINTSETUP; +/*N*/ ScWriteHeader aJobHeader(rStream); +/*N*/ +/*N*/ ((ScDocument*)this)->GetPrinter()->Store( rStream ); +/*N*/ } +/*N*/ +/*N*/ if ( nSrcVer > SC_40_EXPORT_VER ) // Das folgende nicht bei 3.0 oder 4.0 Export... +/*N*/ { +/*N*/ if (pConsolidateDlgData) // Einstellungen fuer den Konsolidieren-Dialog +/*N*/ { +/*?*/ rStream << (USHORT) SCID_CONSOLIDATA; +/*?*/ pConsolidateDlgData->Store( rStream ); +/*N*/ } +/*N*/ if ( pChangeTrack ) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_CHANGETRACK; +/*N*/ pChangeTrack->Store( rStream ); +/*N*/ } +/*N*/ if ( pChangeViewSettings ) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_CHGVIEWSET; +/*N*/ pChangeViewSettings->Store( rStream ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ rStream.SetStreamCharSet( eOldSet ); +/*N*/ rStream.SetBufferSize( nOldBufSize ); +/*N*/ +/*N*/ ((ScDocument*)this)->bLoadingDone = TRUE; +/*N*/ +/*N*/ return ( rStream.GetError() == SVSTREAM_OK ); +/*N*/ } + +/*N*/ void ScDocument::SetLostData() +/*N*/ { +/*N*/ bLostData = TRUE; +/*N*/ } + + +/*N*/ void ScDocument::PutCell( USHORT nCol, USHORT nRow, USHORT nTab, +/*N*/ ScBaseCell* pCell, ULONG nFormatIndex, BOOL bForceTab ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ { +/*N*/ if ( bForceTab && !pTab[nTab] ) +/*N*/ { +/*?*/ BOOL bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags +/*?*/ +/*?*/ pTab[nTab] = new ScTable(this, nTab, +/*?*/ String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("temp")), +/*?*/ bExtras, bExtras); +/*N*/ } +/*N*/ +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->PutCell( nCol, nRow, nFormatIndex, pCell ); +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::GetPrintArea( USHORT nTab, USHORT& rEndCol, USHORT& rEndRow, +/*N*/ BOOL bNotes ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ { +/*N*/ BOOL bAny = pTab[nTab]->GetPrintArea( rEndCol, rEndRow, bNotes ); +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ ScRange aDrawRange(0,0,nTab, MAXCOL,MAXROW,nTab); +/*N*/ if (DrawGetPrintArea( aDrawRange, TRUE, TRUE )) +/*N*/ { +/*N*/ if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col(); +/*N*/ if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row(); +/*N*/ bAny = TRUE; +/*N*/ } +/*N*/ } +/*N*/ return bAny; +/*N*/ } +/*N*/ +/*N*/ rEndCol = 0; +/*N*/ rEndRow = 0; +/*N*/ return FALSE; +/*N*/ } + + + +/*N*/ BOOL ScDocument::GetDataStart( USHORT nTab, USHORT& rStartCol, USHORT& rStartRow ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ { +/*N*/ BOOL bAny = pTab[nTab]->GetDataStart( rStartCol, rStartRow ); +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ ScRange aDrawRange(0,0,nTab, MAXCOL,MAXROW,nTab); +/*N*/ if (DrawGetPrintArea( aDrawRange, TRUE, TRUE )) +/*N*/ { +/*N*/ if (aDrawRange.aStart.Col()<rStartCol) rStartCol=aDrawRange.aStart.Col(); +/*N*/ if (aDrawRange.aStart.Row()<rStartRow) rStartRow=aDrawRange.aStart.Row(); +/*N*/ bAny = TRUE; +/*N*/ } +/*N*/ } +/*N*/ return bAny; +/*N*/ } +/*N*/ +/*N*/ rStartCol = 0; +/*N*/ rStartRow = 0; +/*N*/ return FALSE; +/*N*/ } + + + +/*N*/ ULONG ScDocument::TransferTab( ScDocument* pSrcDoc, USHORT nSrcPos, +/*N*/ USHORT nDestPos, BOOL bInsertNew, +/*N*/ BOOL bResultsOnly ) +/*N*/ { +/*N*/ ULONG nRetVal = 1; // 0 => Fehler 1 = ok +/*N*/ // 2 => RefBox, 3 => NameBox +/*N*/ // 4 => beides +/*N*/ BOOL bValid = TRUE; +/*N*/ if (bInsertNew) // neu einfuegen +/*N*/ { +/*?*/ String aName; +/*?*/ pSrcDoc->GetName(nSrcPos, aName); +/*?*/ CreateValidTabName(aName); +/*?*/ bValid = InsertTab(nDestPos, aName); +/*N*/ } +/*N*/ else // bestehende Tabelle ersetzen +/*N*/ { +/*N*/ if (VALIDTAB(nDestPos) && pTab[nDestPos]) +/*N*/ { +/*N*/ pTab[nDestPos]->DeleteArea( 0,0, MAXCOL,MAXROW, IDF_ALL ); +/*N*/ // ClearDrawPage(nDestPos); +/*N*/ } +/*N*/ else +/*N*/ bValid = FALSE; +/*N*/ } +/*N*/ +/*N*/ if (bValid) +/*N*/ { +/*N*/ BOOL bOldAutoCalcSrc; +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ SetNoListening( TRUE ); +/*N*/ if ( bResultsOnly ) +/*N*/ { +/*N*/ bOldAutoCalcSrc = pSrcDoc->GetAutoCalc(); +/*N*/ pSrcDoc->SetAutoCalc( TRUE ); // falls was berechnet werden muss +/*N*/ } +/*N*/ SvNumberFormatter* pThisFormatter = xPoolHelper->GetFormTable(); +/*N*/ SvNumberFormatter* pOtherFormatter = pSrcDoc->xPoolHelper->GetFormTable(); +/*N*/ if (pOtherFormatter && pOtherFormatter != pThisFormatter) +/*N*/ { +/*N*/ SvNumberFormatterIndexTable* pExchangeList = +/*N*/ pThisFormatter->MergeFormatter(*(pOtherFormatter)); +/*N*/ if (pExchangeList->Count() > 0) +/*N*/ pFormatExchangeList = pExchangeList; +/*N*/ } +/*N*/ nDestPos = Min(nDestPos, (USHORT)(GetTableCount() - 1)); +/*N*/ pSrcDoc->pTab[nSrcPos]->CopyToTable(0, 0, MAXCOL, MAXROW, +/*N*/ ( bResultsOnly ? IDF_ALL & ~IDF_FORMULA : IDF_ALL), +/*N*/ FALSE, pTab[nDestPos] ); +/*N*/ pFormatExchangeList = NULL; +/*N*/ pTab[nDestPos]->SetTabNo(nDestPos); +/*N*/ +/*N*/ if ( !bResultsOnly ) +/*N*/ { +/*N*/ USHORT nSrcRangeNames = pSrcDoc->pRangeName->GetCount(); +/*N*/ // array containing range names which might need update of indices +/*N*/ ScRangeData** pSrcRangeNames = nSrcRangeNames ? new ScRangeData* [nSrcRangeNames] : NULL; +/*N*/ // the index mapping thereof +/*N*/ ScIndexMap aSrcRangeMap( nSrcRangeNames ); +/*N*/ BOOL bRangeNameReplace = FALSE; +/*N*/ +/*N*/ for (USHORT i = 0; i < nSrcRangeNames; i++) //! DB-Bereiche Pivot-Bereiche auch !!! +/*N*/ { +/*?*/ ScRangeData* pSrcData = (*pSrcDoc->pRangeName)[i]; +/*?*/ USHORT nOldIndex = pSrcData->GetIndex(); +/*?*/ BOOL bInUse = FALSE; +/*?*/ for (USHORT j = 0; !bInUse && (j <= MAXTAB); j++) +/*?*/ { +/*?*/ if (pSrcDoc->pTab[j]) +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ bInUse = pSrcDoc->pTab[j]->IsRangeNameInUse(0, 0, MAXCOL, MAXROW, +/*?*/ } +/*?*/ if (bInUse) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScRangeData* pData = new ScRangeData( *pSrcData ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ pSrcRangeNames[i] = NULL; +/*?*/ //aSrcRangeMap.SetPair( i, 0, 0 ); // not needed, defaulted +/*?*/ } +/*N*/ } +/*N*/ if ( bRangeNameReplace ) +/*N*/ { +/*?*/ // first update all inserted named formulas if they contain other +/*?*/ // range names and used indices changed +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ for (USHORT i = 0; i < nSrcRangeNames; i++) //! DB-Bereiche Pivot-Bereiche auch +/*N*/ } +/*N*/ if ( pSrcRangeNames ) +/*?*/ delete [] pSrcRangeNames; +/*N*/ +/*N*/ short nDz = ((short)nDestPos) - (short)nSrcPos; +/*N*/ pTab[nDestPos]->UpdateReference(URM_COPY, 0, 0, nDestPos, +/*N*/ MAXCOL, MAXROW, nDestPos, +/*N*/ 0, 0, nDz, NULL); +/*N*/ // Test for outside absolute references for info box +/*N*/ BOOL bIsAbsRef = pSrcDoc->pTab[nSrcPos]->TestTabRefAbs(nSrcPos); +/*N*/ // Readjust self-contained absolute references to this sheet +/*N*/ pTab[nDestPos]->TestTabRefAbs(nSrcPos); +/*N*/ if (bIsAbsRef) +/*N*/ { +/*N*/ nRetVal += 1; +/*N*/ // InfoBox AbsoluteRefs sind möglicherweise nicht mehr korrekt!! +/*N*/ } +/*N*/ pTab[nDestPos]->CompileAll(); +/*N*/ } +/*N*/ +/*N*/ SetNoListening( FALSE ); +/*N*/ if ( !bResultsOnly ) +/*N*/ pTab[nDestPos]->StartAllListeners(); +/*N*/ SetDirty(); // ist das wirklich dokumentweit noetig?!? +/*N*/ if ( bResultsOnly ) +/*N*/ pSrcDoc->SetAutoCalc( bOldAutoCalcSrc ); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ +/*N*/ // Drawing kopieren +/*N*/ +/*N*/ if (bInsertNew) +/*?*/ TransferDrawPage( pSrcDoc, nSrcPos, nDestPos ); +/*N*/ } +/*N*/ if (!bValid) +/*N*/ nRetVal = 0; +/*N*/ return nRetVal; +/*N*/ } + +// ---------------------------------------------------------------------------- + +/*N*/ void ScDocument::SetError( USHORT nCol, USHORT nRow, USHORT nTab, const USHORT nError) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->SetError( nCol, nRow, nError ); +/*N*/ } + + +// ---------------------------------------------------------------------------- + +/*N*/ void ScDocument::SetConsolidateDlgData( const ScConsolidateParam* pData ) +/*N*/ { +/*N*/ delete pConsolidateDlgData; +/*N*/ +/*N*/ if ( pData ) +/*N*/ pConsolidateDlgData = new ScConsolidateParam( *pData ); +/*N*/ else +/*N*/ pConsolidateDlgData = NULL; +/*N*/ } + +/*N*/ void ScDocument::SetChangeViewSettings(const ScChangeViewSettings& rNew) +/*N*/ { + // #i49161# this is needed to save documents with change tracking + if (pChangeViewSettings==NULL) + pChangeViewSettings = new ScChangeViewSettings; + + DBG_ASSERT( pChangeViewSettings, "Oops. No ChangeViewSettings :-( by!" ); + + *pChangeViewSettings=rNew; +/*N*/ } + +// ---------------------------------------------------------------------------- + +/*N*/ ScFieldEditEngine* ScDocument::CreateFieldEditEngine() +/*N*/ { +/*N*/ ScFieldEditEngine* pEditEngine = NULL; +/*N*/ if (!pCacheFieldEditEngine) +/*N*/ { +/*N*/ pEditEngine = new ScFieldEditEngine( GetEnginePool(), +/*N*/ GetEditPool(), FALSE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pEditEngine = pCacheFieldEditEngine; +/*N*/ pCacheFieldEditEngine = NULL; +/*N*/ } +/*N*/ return pEditEngine; +/*N*/ } + +/*N*/ void ScDocument::DisposeFieldEditEngine(ScFieldEditEngine*& rpEditEngine) +/*N*/ { +/*N*/ if (!pCacheFieldEditEngine && rpEditEngine) +/*N*/ { +/*N*/ pCacheFieldEditEngine = rpEditEngine; +/*N*/ pCacheFieldEditEngine->Clear(); +/*N*/ } +/*N*/ else +/*N*/ delete rpEditEngine; +/*N*/ rpEditEngine = NULL; +/*N*/ } + +} //namespace binfilter + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen3.cxx b/binfilter/bf_sc/source/core/data/sc_documen3.cxx new file mode 100644 index 000000000000..09dfd5b9f0d5 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen3.cxx @@ -0,0 +1,917 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#ifdef WIN +// SFX +#define _SFXAPPWIN_HXX +#define _SFX_SAVEOPT_HXX +//#define _SFX_CHILDWIN_HXX *** +#define _SFXCTRLITEM_HXX +#define _SFXPRNMON_HXX +#define _INTRO_HXX +#define _SFXMSGDESCR_HXX +#define _SFXMSGPOOL_HXX +#define _SFXFILEDLG_HXX +#define _PASSWD_HXX +#define _SFXTBXCTRL_HXX +#define _SFXSTBITEM_HXX +#define _SFXMNUITEM_HXX +#define _SFXIMGMGR_HXX +#define _SFXTBXMGR_HXX +#define _SFXSTBMGR_HXX +#define _SFX_MINFITEM_HXX +#define _SFXEVENT_HXX + +//sfxdlg.hxx +//#define _SFXTABDLG_HXX +#define _BASEDLGS_HXX +#define _SFX_DINFDLG_HXX +#define _SFXDINFEDT_HXX +#define _SFX_MGETEMPL_HXX +#define _SFX_TPLPITEM_HXX +#define _SFX_STYLEDLG_HXX +#define _NEWSTYLE_HXX +#define _SFXDOCTEMPL_HXX +#define _SFXDOCTDLG_HXX +#define _SFX_TEMPLDLG_HXX +#define _SFXNEW_HXX +#define _SFXDOCMAN_HXX +//#define _SFXDOCKWIN_HXX *** + +//sfxdoc.hxx +//#define _SFX_OBJSH_HXX +//#define _SFX_CLIENTSH_HXX *** +//#define _SFXDOCINF_HXX +#define _SFX_OBJFAC_HXX +#define _SFX_DOCFILT_HXX +#define _SFXDOCFILE_HXX +#define _VIEWFAC_HXX +#define _SFXVIEWFRM_HXX +//#define _SFXVIEWSH_HXX *** +#define _MDIFRM_HXX +#define _SFX_IPFRM_HXX +#define _SFX_INTERNO_HXX + +#endif //WIN + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svx/langitem.hxx> +#include <bf_svx/linkmgr.hxx> +#include <bf_svtools/zforlist.hxx> +#include <vcl/svapp.hxx> +#include "document.hxx" +#include "attrib.hxx" +#include "rangenam.hxx" +#include "dbcolect.hxx" +#include "pivot.hxx" +#include "docpool.hxx" +#include "poolhelp.hxx" +#include "refupdat.hxx" +#include "docoptio.hxx" +#include "viewopti.hxx" +#include "scextopt.hxx" +#include "tablink.hxx" +#include "conditio.hxx" +#include "detdata.hxx" +#include "scmod.hxx" // SC_MOD +#include "inputopt.hxx" // GetExpandRefs +#include "bf_sc.hrc" // SID_LINK +#include "hints.hxx" +#include "dpobject.hxx" + +namespace binfilter { +using namespace ::com::sun::star; + +//------------------------------------------------------------------------ + +/*N*/ ScRangeName* ScDocument::GetRangeName() +/*N*/ { +/*N*/ return pRangeName; +/*N*/ } + +/*N*/ void ScDocument::SetRangeName( ScRangeName* pNewRangeName ) +/*N*/ { +/*N*/ if (pRangeName) +/*N*/ delete pRangeName; +/*N*/ pRangeName = pNewRangeName; +/*N*/ } + + + +/*N*/ ScDBCollection* ScDocument::GetDBCollection() const +/*N*/ { +/*N*/ return pDBCollection; +/*N*/ } + + +/*N*/ ScDBData* ScDocument::GetDBAtCursor(USHORT nCol, USHORT nRow, USHORT nTab, BOOL bStartOnly) const +/*N*/ { +/*N*/ if (pDBCollection) +/*N*/ return pDBCollection->GetDBAtCursor(nCol, nRow, nTab, bStartOnly); +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScDBData* ScDocument::GetDBAtArea(USHORT nTab, USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2) const +/*N*/ { +/*N*/ if (pDBCollection) +/*N*/ return pDBCollection->GetDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2); +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScDPCollection* ScDocument::GetDPCollection() +/*N*/ { +/*N*/ if (!pDPCollection) +/*N*/ pDPCollection = new ScDPCollection(this); +/*N*/ return pDPCollection; +/*N*/ } + + + + + + + + +/*N*/ void ScDocument::SetScenario( USHORT nTab, BOOL bFlag ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetScenario(bFlag); +/*N*/ } + +/*N*/ BOOL ScDocument::IsScenario( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->IsScenario(); +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScDocument::SetScenarioData( USHORT nTab, const String& rComment, +/*N*/ const Color& rColor, USHORT nFlags ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab] && pTab[nTab]->IsScenario()) +/*N*/ { +/*N*/ pTab[nTab]->SetScenarioComment( rComment ); +/*N*/ pTab[nTab]->SetScenarioColor( rColor ); +/*N*/ pTab[nTab]->SetScenarioFlags( nFlags ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::GetScenarioData( USHORT nTab, String& rComment, +/*N*/ Color& rColor, USHORT& rFlags ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab] && pTab[nTab]->IsScenario()) +/*N*/ { +/*N*/ pTab[nTab]->GetScenarioComment( rComment ); +/*N*/ rColor = pTab[nTab]->GetScenarioColor(); +/*N*/ rFlags = pTab[nTab]->GetScenarioFlags(); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDocument::IsLinked( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->IsLinked(); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::GetLinkMode( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetLinkMode(); +/*N*/ return SC_LINK_NONE; +/*N*/ } + +/*N*/ const String& ScDocument::GetLinkDoc( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetLinkDoc(); +/*N*/ return EMPTY_STRING; +/*N*/ } + +/*N*/ const String& ScDocument::GetLinkFlt( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetLinkFlt(); +/*N*/ return EMPTY_STRING; +/*N*/ } + +/*N*/ const String& ScDocument::GetLinkOpt( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetLinkOpt(); +/*N*/ return EMPTY_STRING; +/*N*/ } + +/*N*/ const String& ScDocument::GetLinkTab( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetLinkTab(); +/*N*/ return EMPTY_STRING; +/*N*/ } + +/*N*/ ULONG ScDocument::GetLinkRefreshDelay( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetLinkRefreshDelay(); +/*N*/ return 0; +/*N*/ } + +/*N*/ void ScDocument::SetLink( USHORT nTab, BYTE nMode, const String& rDoc, +/*N*/ const String& rFilter, const String& rOptions, +/*N*/ const String& rTabName, ULONG nRefreshDelay ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetLink( nMode, rDoc, rFilter, rOptions, rTabName, nRefreshDelay ); +/*N*/ } + +/*N*/ BOOL ScDocument::HasLink( const String& rDoc, +/*N*/ const String& rFilter, const String& rOptions ) const +/*N*/ { +/*N*/ USHORT nCount = GetTableCount(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ if (pTab[i]->IsLinked() +/*N*/ && pTab[i]->GetLinkDoc() == rDoc +/*N*/ && pTab[i]->GetLinkFlt() == rFilter +/*N*/ && pTab[i]->GetLinkOpt() == rOptions) +/*N*/ return TRUE; +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::LinkExternalTab( USHORT& rTab, const String& aDocTab, +/*N*/ const String& aFileName, const String& aTabName ) +/*N*/ { +/*N*/ if ( IsClipboard() ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "LinkExternalTab in Clipboard" ); +/*N*/ return FALSE; +/*N*/ } +/*N*/ rTab = 0; +/*N*/ String aFilterName; // wird vom Loader gefuellt +/*N*/ String aOptions; // Filter-Optionen +/*N*/ ScDocumentLoader aLoader( aFileName, aFilterName, aOptions, +/*N*/ pExtDocOptions ? pExtDocOptions->nLinkCnt + 1 : 1 ); +/*N*/ if ( aLoader.IsError() ) +/*N*/ return FALSE; +/*N*/ ScDocument* pSrcDoc = aLoader.GetDocument(); +/*N*/ +/*N*/ // Tabelle kopieren +/*N*/ USHORT nSrcTab; +/*N*/ if ( pSrcDoc->GetTable( aTabName, nSrcTab ) ) +/*N*/ { +/*N*/ if ( !InsertTab( SC_TAB_APPEND, aDocTab, TRUE ) ) +/*N*/ { +/*N*/ DBG_ERRORFILE("can't insert external document table"); +/*N*/ return FALSE; +/*N*/ } +/*N*/ rTab = GetTableCount() - 1; +/*N*/ // nicht neu einfuegen, nur Ergebnisse +/*N*/ TransferTab( pSrcDoc, nSrcTab, rTab, FALSE, TRUE ); +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ +/*N*/ ULONG nRefreshDelay = 0; +/*N*/ +/*N*/ BOOL bWasThere = HasLink( aFileName, aFilterName, aOptions ); +/*N*/ SetLink( rTab, SC_LINK_VALUE, aFileName, aFilterName, aOptions, aTabName, nRefreshDelay ); +/*N*/ if ( !bWasThere ) // Link pro Quelldokument nur einmal eintragen +/*N*/ { +/*N*/ ScTableLink* pLink = new ScTableLink( pShell, aFileName, aFilterName, aOptions, nRefreshDelay ); +/*N*/ pLink->SetInCreate( TRUE ); +/*N*/ pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aFileName, +/*N*/ &aFilterName ); +/*N*/ pLink->Update(); +/*N*/ pLink->SetInCreate( FALSE ); +/*N*/ } +/*N*/ return TRUE; +/*N*/ } + +/*N*/ ScOutlineTable* ScDocument::GetOutlineTable( USHORT nTab, BOOL bCreate ) +/*N*/ { +/*N*/ ScOutlineTable* pVal = NULL; +/*N*/ +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ pVal = pTab[nTab]->GetOutlineTable(); +/*N*/ if (!pVal) +/*N*/ if (bCreate) +/*N*/ { +/*N*/ pTab[nTab]->StartOutlineTable(); +/*N*/ pVal = pTab[nTab]->GetOutlineTable(); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return pVal; +/*N*/ } + + + + + + + +// kopiert aus diesem Dokument die Zellen von Positionen, an denen in pPosDoc +// auch Zellen stehen, nach pDestDoc + + + + + +/*N*/ const ScRangeList* ScDocument::GetScenarioRanges( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetScenarioRanges(); +/*N*/ +/*N*/ return NULL; +/*N*/ } + +/*N*/ BOOL ScDocument::IsActiveScenario( USHORT nTab ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->IsActiveScenario(); +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScDocument::SetActiveScenario( USHORT nTab, BOOL bActive ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetActiveScenario( bActive ); +/*N*/ } + + +/*N*/ void ScDocument::AddUnoObject( SfxListener& rObject ) +/*N*/ { +/*N*/ if (!pUnoBroadcaster) +/*N*/ pUnoBroadcaster = new SfxBroadcaster; +/*N*/ +/*N*/ rObject.StartListening( *pUnoBroadcaster ); +/*N*/ } + +/*N*/ void ScDocument::RemoveUnoObject( SfxListener& rObject ) +/*N*/ { +/*N*/ if (pUnoBroadcaster) +/*N*/ { +/*N*/ rObject.EndListening( *pUnoBroadcaster ); +/*N*/ +/*N*/ if ( bInUnoBroadcast ) +/*N*/ { +/*?*/ // #107294# Broadcasts from ScDocument::BroadcastUno are the only way that +/*?*/ // uno object methods are called without holding a reference. +/*?*/ // +/*?*/ // If RemoveUnoObject is called from an object dtor in the finalizer thread +/*?*/ // while the main thread is calling BroadcastUno, the dtor thread must wait +/*?*/ // (or the object's Notify might try to access a deleted object). +/*?*/ // The SolarMutex can't be locked here because if a component is called from +/*?*/ // a VCL event, the main thread has the SolarMutex locked all the time. +/*?*/ // +/*?*/ // This check is done after calling EndListening, so a later BroadcastUno call +/*?*/ // won't touch this object. +/*?*/ +/*?*/ osl::SolarMutex& rSolarMutex = Application::GetSolarMutex(); +/*?*/ if ( rSolarMutex.tryToAcquire() ) +/*?*/ { +/*?*/ // BroadcastUno is always called with the SolarMutex locked, so if it +/*?*/ // can be acquired, this is within the same thread (should not happen) +/*?*/ DBG_ERRORFILE( "RemoveUnoObject called from BroadcastUno" ); +/*?*/ rSolarMutex.release(); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ // let the thread that called BroadcastUno continue +/*?*/ while ( bInUnoBroadcast ) +/*?*/ { +/*?*/ osl::Thread::yield(); +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ DBG_ERROR("No Uno broadcaster"); +/*N*/ } + +/*N*/ void ScDocument::BroadcastUno( const SfxHint &rHint ) +/*N*/ { +/*N*/ if (pUnoBroadcaster) +/*N*/ { +/*N*/ bInUnoBroadcast = TRUE; +/*N*/ pUnoBroadcaster->Broadcast( rHint ); +/*N*/ bInUnoBroadcast = FALSE; +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ short nDx, short nDy, short nDz, +/*N*/ ScDocument* pUndoDoc, BOOL bIncludeDraw ) +/*N*/ { +/*N*/ PutInOrder( nCol1, nCol2 ); +/*N*/ PutInOrder( nRow1, nRow2 ); +/*N*/ PutInOrder( nTab1, nTab2 ); +/*N*/ if (VALIDTAB(nTab1) && VALIDTAB(nTab2)) +/*N*/ { +/*N*/ BOOL bExpandRefsOld = IsExpandRefs(); +/*N*/ if ( eUpdateRefMode == URM_INSDEL && (nDx > 0 || nDy > 0 || nDz > 0) ) +/*N*/ SetExpandRefs( SC_MOD()->GetInputOptions().GetExpandRefs() ); +/*N*/ USHORT i; +/*N*/ USHORT iMax; +/*N*/ if ( eUpdateRefMode == URM_COPY ) +/*N*/ { +/*N*/ i = nTab1; +/*N*/ iMax = nTab2; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScRange aRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ xColNameRanges->UpdateReference( eUpdateRefMode, this, aRange, nDx, nDy, nDz ); +/*N*/ xRowNameRanges->UpdateReference( eUpdateRefMode, this, aRange, nDx, nDy, nDz ); +/*N*/ pDBCollection->UpdateReference( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz ); +/*N*/ pRangeName->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz ); +/*N*/ if (pPivotCollection) +/*N*/ pPivotCollection->UpdateReference( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz ); +/*N*/ if ( pDPCollection ) +/*N*/ pDPCollection->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz ); +/*N*/ UpdateChartRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz ); +/*N*/ UpdateRefAreaLinks( eUpdateRefMode, aRange, nDx, nDy, nDz ); +/*N*/ if ( pCondFormList ) +/*N*/ pCondFormList->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz ); +/*N*/ if ( pDetOpList ) +/*N*/ pDetOpList->UpdateReference( this, eUpdateRefMode, aRange, nDx, nDy, nDz ); +/*N*/ if ( pUnoBroadcaster ) +/*N*/ pUnoBroadcaster->Broadcast( ScUpdateRefHint( +/*N*/ eUpdateRefMode, aRange, nDx, nDy, nDz ) ); +/*N*/ i = 0; +/*N*/ iMax = MAXTAB; +/*N*/ } +/*N*/ for ( ; i<=iMax; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->UpdateReference( +/*N*/ eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, +/*N*/ nDx, nDy, nDz, pUndoDoc, bIncludeDraw ); +/*N*/ +/*N*/ if ( bIsEmbedded ) +/*N*/ { +/*N*/ USHORT theCol1, theRow1, theTab1, theCol2, theRow2, theTab2; +/*N*/ theCol1 = aEmbedRange.aStart.Col(); +/*N*/ theRow1 = aEmbedRange.aStart.Row(); +/*N*/ theTab1 = aEmbedRange.aStart.Tab(); +/*N*/ theCol2 = aEmbedRange.aEnd.Col(); +/*N*/ theRow2 = aEmbedRange.aEnd.Row(); +/*N*/ theTab2 = aEmbedRange.aEnd.Tab(); +/*N*/ if ( ScRefUpdate::Update( this, eUpdateRefMode, nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, +/*N*/ nDx,nDy,nDz, theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) ) +/*N*/ { +/*N*/ aEmbedRange = ScRange( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ); +/*N*/ } +/*N*/ } +/*N*/ SetExpandRefs( bExpandRefsOld ); + } +/*N*/ } + + + +/*N*/ void ScDocument::Fill(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, const ScMarkData& rMark, +/*N*/ USHORT nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, +/*N*/ double nStepValue, double nMaxValue) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 PutInOrder( nCol1, nCol2 ); +/*N*/ } + + +/*N*/ void ScDocument::AutoFormat( USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow, +/*N*/ USHORT nFormatNo, const ScMarkData& rMark ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 PutInOrder( nStartCol, nEndCol ); +/*N*/ } + + +// Outline anpassen + +/*N*/ BOOL ScDocument::UpdateOutlineCol( USHORT nStartCol, USHORT nEndCol, USHORT nTab, BOOL bShow ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->UpdateOutlineCol( nStartCol, nEndCol, bShow ); +/*N*/ +/*N*/ DBG_ERROR("missing tab"); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::UpdateOutlineRow( USHORT nStartRow, USHORT nEndRow, USHORT nTab, BOOL bShow ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->UpdateOutlineRow( nStartRow, nEndRow, bShow ); +/*N*/ +/*N*/ DBG_ERROR("missing tab"); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScDocument::Sort(USHORT nTab, const ScSortParam& rSortParam, BOOL bKeepQuery) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ } + +/*N*/ USHORT ScDocument::Query(USHORT nTab, const ScQueryParam& rQueryParam, BOOL bKeepSub) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return 0; +/*N*/ } + + + + + +/*N*/ BOOL ScDocument::CreateQueryParam(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, USHORT nTab, ScQueryParam& rQueryParam) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->CreateQueryParam(nCol1, nRow1, nCol2, nRow2, rQueryParam); +/*N*/ +/*N*/ DBG_ERROR("missing tab"); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::HasColHeader( USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow, +/*N*/ USHORT nTab ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (VALIDTAB(nTab)) +/*N*/ return FALSE; +/*N*/ } + +// Funktionen werden als 1 schon vom InputHandler eingefuegt +#define SC_STRTYPE_NAMES 2 +#define SC_STRTYPE_DBNAMES 3 +#define SC_STRTYPE_HEADERS 4 + + + +/*N*/ BOOL ScDocument::IsEmbedded() const +/*N*/ { +/*N*/ return bIsEmbedded; +/*N*/ } + + + + + +/*N*/ ScRange ScDocument::GetRange( USHORT nTab, const Rectangle& rMMRect ) +/*N*/ { +/*N*/ ScTable* pTable = pTab[nTab]; +/*N*/ if (!pTable) +/*N*/ { +/*N*/ DBG_ERROR("GetRange ohne Tabelle"); +/*N*/ return ScRange(); +/*N*/ } +/*N*/ +/*N*/ long nSize; +/*N*/ long nTwips; +/*N*/ long nAdd; +/*N*/ BOOL bEnd; +/*N*/ +/*N*/ nSize = 0; +/*N*/ nTwips = (long) (rMMRect.Left() / HMM_PER_TWIPS); +/*N*/ +/*N*/ USHORT nX1 = 0; +/*N*/ bEnd = FALSE; +/*N*/ while (!bEnd) +/*N*/ { +/*N*/ nAdd = (long) pTable->GetColWidth(nX1); +/*N*/ if (nSize+nAdd <= nTwips+1 && nX1<MAXCOL) +/*N*/ { +/*N*/ nSize += nAdd; +/*N*/ ++nX1; +/*N*/ } +/*N*/ else +/*N*/ bEnd = TRUE; +/*N*/ } +/*N*/ +/*N*/ nTwips = (long) (rMMRect.Right() / HMM_PER_TWIPS); +/*N*/ +/*N*/ USHORT nX2 = nX1; +/*N*/ bEnd = FALSE; +/*N*/ while (!bEnd) +/*N*/ { +/*N*/ nAdd = (long) pTable->GetColWidth(nX2); +/*N*/ if (nSize+nAdd < nTwips && nX2<MAXCOL) +/*N*/ { +/*N*/ nSize += nAdd; +/*N*/ ++nX2; +/*N*/ } +/*N*/ else +/*N*/ bEnd = TRUE; +/*N*/ } +/*N*/ +/*N*/ +/*N*/ nSize = 0; +/*N*/ nTwips = (long) (rMMRect.Top() / HMM_PER_TWIPS); +/*N*/ +/*N*/ USHORT nY1 = 0; +/*N*/ bEnd = FALSE; +/*N*/ while (!bEnd) +/*N*/ { +/*N*/ nAdd = (long) pTable->GetRowHeight(nY1); +/*N*/ if (nSize+nAdd <= nTwips+1 && nY1<MAXROW) +/*N*/ { +/*N*/ nSize += nAdd; +/*N*/ ++nY1; +/*N*/ } +/*N*/ else +/*N*/ bEnd = TRUE; +/*N*/ } +/*N*/ +/*N*/ nTwips = (long) (rMMRect.Bottom() / HMM_PER_TWIPS); +/*N*/ +/*N*/ USHORT nY2 = nY1; +/*N*/ bEnd = FALSE; +/*N*/ while (!bEnd) +/*N*/ { +/*N*/ nAdd = (long) pTable->GetRowHeight(nY2); +/*N*/ if (nSize+nAdd < nTwips && nY2<MAXROW) +/*N*/ { +/*N*/ nSize += nAdd; +/*N*/ ++nY2; +/*N*/ } +/*N*/ else +/*N*/ bEnd = TRUE; +/*N*/ } +/*N*/ +/*N*/ return ScRange( nX1,nY1,nTab, nX2,nY2,nTab ); +/*N*/ } + + +// VisArea auf Zellgrenzen anpassen + +/*N*/ void lcl_SnapHor( ScTable* pTable, long& rVal, USHORT& rStartCol ) +/*N*/ { +/*N*/ USHORT nCol = 0; +/*N*/ long nTwips = (long) (rVal / HMM_PER_TWIPS); +/*N*/ long nSnap = 0; +/*N*/ while ( nCol<MAXCOL ) +/*N*/ { +/*N*/ long nAdd = pTable->GetColWidth(nCol); +/*N*/ if ( nSnap + nAdd/2 < nTwips || nCol < rStartCol ) +/*N*/ { +/*N*/ nSnap += nAdd; +/*N*/ ++nCol; +/*N*/ } +/*N*/ else +/*N*/ break; +/*N*/ } +/*N*/ rVal = (long) ( nSnap * HMM_PER_TWIPS ); +/*N*/ rStartCol = nCol; +/*N*/ } + +/*N*/ void lcl_SnapVer( ScTable* pTable, long& rVal, USHORT& rStartRow ) +/*N*/ { +/*N*/ USHORT nRow = 0; +/*N*/ long nTwips = (long) (rVal / HMM_PER_TWIPS); +/*N*/ long nSnap = 0; +/*N*/ while ( nRow<MAXROW ) +/*N*/ { +/*N*/ long nAdd = pTable->GetRowHeight(nRow); +/*N*/ if ( nSnap + nAdd/2 < nTwips || nRow < rStartRow ) +/*N*/ { +/*N*/ nSnap += nAdd; +/*N*/ ++nRow; +/*N*/ } +/*N*/ else +/*N*/ break; +/*N*/ } +/*N*/ rVal = (long) ( nSnap * HMM_PER_TWIPS ); +/*N*/ rStartRow = nRow; +/*N*/ } + +/*N*/ void ScDocument::SnapVisArea( Rectangle& rRect ) const +/*N*/ { +/*N*/ ScTable* pTable = pTab[nVisibleTab]; +/*N*/ if (!pTable) +/*N*/ { +/*N*/ DBG_ERROR("SetEmbedded ohne Tabelle"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ USHORT nCol = 0; +/*N*/ lcl_SnapHor( pTable, rRect.Left(), nCol ); +/*N*/ ++nCol; // mindestens eine Spalte +/*N*/ lcl_SnapHor( pTable, rRect.Right(), nCol ); +/*N*/ +/*N*/ USHORT nRow = 0; +/*N*/ lcl_SnapVer( pTable, rRect.Top(), nRow ); +/*N*/ ++nRow; // mindestens eine Zeile +/*N*/ lcl_SnapVer( pTable, rRect.Bottom(), nRow ); +/*N*/ } + +/*N*/ void ScDocument::SetDocProtection( BOOL bProtect, const uno::Sequence<sal_Int8>& rPasswd ) +/*N*/ { +/*N*/ bProtected = bProtect; +/*N*/ aProtectPass = rPasswd; +/*N*/ } + +/*N*/ void ScDocument::SetTabProtection( USHORT nTab, BOOL bProtect, const uno::Sequence<sal_Int8>& rPasswd ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->SetProtection( bProtect, rPasswd ); +/*N*/ } + +/*N*/ BOOL ScDocument::IsDocProtected() const +/*N*/ { +/*N*/ return bProtected; +/*N*/ } + +/*N*/ BOOL ScDocument::IsDocEditable() const +/*N*/ { +/*N*/ // import into read-only document is possible - must be extended if other filters use api +/*N*/ +/*N*/ return !bProtected && ( !pShell || !pShell->IsReadOnly() || bImportingXML ); +/*N*/ } + +/*N*/ BOOL ScDocument::IsTabProtected( USHORT nTab ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->IsProtected(); +/*N*/ +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ const uno::Sequence<sal_Int8>& ScDocument::GetDocPassword() const +/*N*/ { +/*N*/ return aProtectPass; +/*N*/ } + +/*N*/ const uno::Sequence<sal_Int8>& ScDocument::GetTabPassword( USHORT nTab ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->GetPassword(); +/*N*/ +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return aProtectPass; +/*N*/ } + +/*N*/ const ScDocOptions& ScDocument::GetDocOptions() const +/*N*/ { +/*N*/ DBG_ASSERT( pDocOptions, "No DocOptions! :-(" ); +/*N*/ return *pDocOptions; +/*N*/ } + +/*N*/ void ScDocument::SetDocOptions( const ScDocOptions& rOpt ) +/*N*/ { +/*N*/ USHORT d,m,y; +/*N*/ +/*N*/ DBG_ASSERT( pDocOptions, "No DocOptions! :-(" ); +/*N*/ *pDocOptions = rOpt; +/*N*/ rOpt.GetDate( d,m,y ); +/*N*/ +/*N*/ SvNumberFormatter* pFormatter = xPoolHelper->GetFormTable(); +/*N*/ pFormatter->ChangeNullDate( d,m,y ); +/*N*/ pFormatter->ChangeStandardPrec( (USHORT)rOpt.GetStdPrecision() ); +/*N*/ pFormatter->SetYear2000( rOpt.GetYear2000() ); +/*N*/ } + +/*N*/ const ScViewOptions& ScDocument::GetViewOptions() const +/*N*/ { +/*N*/ DBG_ASSERT( pViewOptions, "No ViewOptions! :-(" ); +/*N*/ return *pViewOptions; +/*N*/ } + +/*N*/ void ScDocument::SetViewOptions( const ScViewOptions& rOpt ) +/*N*/ { +/*N*/ DBG_ASSERT( pViewOptions, "No ViewOptions! :-(" ); +/*N*/ *pViewOptions = rOpt; +/*N*/ } + +/*N*/ void ScDocument::GetLanguage( LanguageType& rLatin, LanguageType& rCjk, LanguageType& rCtl ) const +/*N*/ { +/*N*/ rLatin = eLanguage; +/*N*/ rCjk = eCjkLanguage; +/*N*/ rCtl = eCtlLanguage; +/*N*/ } + +/*N*/ void ScDocument::SetLanguage( LanguageType eLatin, LanguageType eCjk, LanguageType eCtl ) +/*N*/ { +/*N*/ eLanguage = eLatin; +/*N*/ eCjkLanguage = eCjk; +/*N*/ eCtlLanguage = eCtl; +/*N*/ if ( xPoolHelper.is() ) +/*N*/ { +/*N*/ ScDocumentPool* pPool = xPoolHelper->GetDocPool(); +/*N*/ pPool->SetPoolDefaultItem( SvxLanguageItem( eLanguage, ATTR_FONT_LANGUAGE ) ); +/*N*/ pPool->SetPoolDefaultItem( SvxLanguageItem( eCjkLanguage, ATTR_CJK_FONT_LANGUAGE ) ); +/*N*/ pPool->SetPoolDefaultItem( SvxLanguageItem( eCtlLanguage, ATTR_CTL_FONT_LANGUAGE ) ); +/*N*/ } +/*N*/ +/*N*/ UpdateDrawLanguages(); // set edit engine defaults in drawing layer pool +/*N*/ } + +/*N*/ Rectangle ScDocument::GetMMRect( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nTab ) +/*N*/ { +/*N*/ if (nTab > MAXTAB || !pTab[nTab]) +/*N*/ { +/*N*/ DBG_ERROR("GetMMRect: falsche Tabelle"); +/*N*/ return Rectangle(0,0,0,0); +/*N*/ } +/*N*/ +/*N*/ USHORT i; +/*N*/ Rectangle aRect; +/*N*/ +/*N*/ for (i=0; i<nStartCol; i++) +/*N*/ aRect.Left() += GetColWidth(i,nTab); +/*N*/ for (i=0; i<nStartRow; i++) +/*N*/ aRect.Top() += FastGetRowHeight(i,nTab); +/*N*/ +/*N*/ aRect.Right() = aRect.Left(); +/*N*/ aRect.Bottom() = aRect.Top(); +/*N*/ +/*N*/ for (i=nStartCol; i<=nEndCol; i++) +/*N*/ aRect.Right() += GetColWidth(i,nTab); +/*N*/ for (i=nStartRow; i<=nEndRow; i++) +/*N*/ aRect.Bottom() += FastGetRowHeight(i,nTab); +/*N*/ +/*N*/ aRect.Left() = (long)(aRect.Left() * HMM_PER_TWIPS); +/*N*/ aRect.Right() = (long)(aRect.Right() * HMM_PER_TWIPS); +/*N*/ aRect.Top() = (long)(aRect.Top() * HMM_PER_TWIPS); +/*N*/ aRect.Bottom() = (long)(aRect.Bottom() * HMM_PER_TWIPS); +/*N*/ +/*N*/ return aRect; +/*N*/ } + +/*N*/ void ScDocument::DoMerge( USHORT nTab, USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow ) +/*N*/ { +/*N*/ ScMergeAttr aAttr( nEndCol-nStartCol+1, nEndRow-nStartRow+1 ); +/*N*/ ApplyAttr( nStartCol, nStartRow, nTab, aAttr ); +/*N*/ +/*N*/ if ( nEndCol > nStartCol ) +/*N*/ ApplyFlagsTab( nStartCol+1, nStartRow, nEndCol, nStartRow, nTab, SC_MF_HOR ); +/*N*/ if ( nEndRow > nStartRow ) +/*N*/ ApplyFlagsTab( nStartCol, nStartRow+1, nStartCol, nEndRow, nTab, SC_MF_VER ); +/*N*/ if ( nEndCol > nStartCol && nEndRow > nStartRow ) +/*N*/ ApplyFlagsTab( nStartCol+1, nStartRow+1, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER ); +/*N*/ } + + +/*N*/ void ScDocument::ExtendPrintArea( OutputDevice* pDev, USHORT nTab, +/*N*/ USHORT nStartCol, USHORT nStartRow, USHORT& rEndCol, USHORT nEndRow ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->ExtendPrintArea( pDev, nStartCol, nStartRow, rEndCol, nEndRow ); +/*N*/ } + +/*N*/ void ScDocument::IncSizeRecalcLevel( USHORT nTab ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->IncRecalcLevel(); +/*N*/ } + +/*N*/ void ScDocument::DecSizeRecalcLevel( USHORT nTab ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->DecRecalcLevel(); +/*N*/ } + + + + +} //namespace binfilter + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen4.cxx b/binfilter/bf_sc/source/core/data/sc_documen4.cxx new file mode 100644 index 000000000000..08a69c308879 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen4.cxx @@ -0,0 +1,501 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svtools/intitem.hxx> +#include <vcl/sound.hxx> + +#include "globstr.hrc" +#include "subtotal.hxx" +#include "interpre.hxx" +#include "markdata.hxx" +#include "validat.hxx" +#include "scitems.hxx" +#include "stlpool.hxx" +#include "poolhelp.hxx" +#include "detdata.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + +// Nach der Regula Falsi Methode +/*N*/ BOOL ScDocument::Solver(USHORT nFCol, USHORT nFRow, USHORT nFTab, +/*N*/ USHORT nVCol, USHORT nVRow, USHORT nVTab, +/*N*/ const String& sValStr, double& nX) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ nX = 0.0; +/*N*/ if (ValidColRow(nFCol, nFRow) && ValidColRow(nVCol, nVRow) && +/*N*/ VALIDTAB(nFTab) && VALIDTAB(nVTab) && pTab[nFTab] && pTab[nVTab]) +/*N*/ { +/*N*/ CellType eFType, eVType; +/*N*/ GetCellType(nFCol, nFRow, nFTab, eFType); +/*N*/ GetCellType(nVCol, nVRow, nVTab, eVType); +/*N*/ // CELLTYPE_NOTE: kein Value aber von Formel referiert +/*N*/ if (eFType == CELLTYPE_FORMULA && (eVType == CELLTYPE_VALUE +/*N*/ || eVType == CELLTYPE_NOTE) ) +/*N*/ { +/*N*/ SingleRefData aRefData; +/*N*/ aRefData.InitFlags(); +/*N*/ aRefData.nCol = nVCol; +/*N*/ aRefData.nRow = nVRow; +/*N*/ aRefData.nTab = nVTab; +/*N*/ +/*N*/ ScTokenArray aArr; +/*N*/ aArr.AddOpCode( ocBackSolver ); +/*N*/ aArr.AddOpCode( ocOpen ); +/*N*/ aArr.AddSingleReference( aRefData ); +/*N*/ aArr.AddOpCode( ocSep ); +/*N*/ +/*N*/ aRefData.nCol = nFCol; +/*N*/ aRefData.nRow = nFRow; +/*N*/ aRefData.nTab = nFTab; +/*N*/ +/*N*/ aArr.AddSingleReference( aRefData ); +/*N*/ aArr.AddOpCode( ocSep ); +/*N*/ aArr.AddString( sValStr.GetBuffer() ); +/*N*/ aArr.AddOpCode( ocClose ); +/*N*/ aArr.AddOpCode( ocStop ); +/*N*/ +/*N*/ ScFormulaCell* pCell = new ScFormulaCell( this, ScAddress(), &aArr ); +/*N*/ +/*N*/ if (pCell) +/*N*/ { +/*N*/ pCell->Interpret(); +/*N*/ USHORT nErrCode = pCell->GetErrCode(); +/*N*/ nX = pCell->GetValueAlways(); +/*N*/ if (nErrCode == 0) // kein fehler beim Rechnen +/*N*/ bRet = TRUE; +/*N*/ delete pCell; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/*N*/ void ScDocument::InsertMatrixFormula(USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ const ScMarkData& rMark, +/*N*/ const String& rFormula, +/*N*/ const ScTokenArray* pArr ) +/*N*/ { +/*N*/ PutInOrder(nCol1, nCol2); +/*N*/ PutInOrder(nRow1, nRow2); +/*N*/ USHORT i, j, k, nTab1; +/*N*/ i = 0; +/*N*/ BOOL bStop = FALSE; +/*N*/ while (i <= MAXTAB && !bStop) // erste markierte Tabelle finden +/*N*/ { +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ bStop = TRUE; +/*N*/ else +/*N*/ i++; +/*N*/ } +/*N*/ nTab1 = i; +/*N*/ if (i == MAXTAB + 1) +/*N*/ { +/*N*/ Sound::Beep(); +/*N*/ DBG_ERROR("ScDocument::InsertMatrixFormula Keine Tabelle markiert"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ ScFormulaCell* pCell; +/*N*/ ScAddress aPos( nCol1, nRow1, nTab1 ); +/*N*/ if (pArr) +/*N*/ pCell = new ScFormulaCell( this, aPos, pArr, MM_FORMULA ); +/*N*/ else +/*N*/ pCell = new ScFormulaCell( this, aPos, rFormula, MM_FORMULA ); +/*N*/ pCell->SetMatColsRows( nCol2 - nCol1 + 1, nRow2 - nRow1 + 1 ); +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ { +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ { +/*N*/ if (i == nTab1) +/*N*/ pTab[i]->PutCell(nCol1, nRow1, pCell); +/*N*/ else +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pTab[i]->PutCell(nCol1, nRow1, pCell->Clone(this, ScAddress( nCol1, nRow1, i))); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ SingleRefData aRefData; +/*N*/ aRefData.InitFlags(); +/*N*/ aRefData.nCol = nCol1; +/*N*/ aRefData.nRow = nRow1; +/*N*/ aRefData.nTab = nTab1; +/*N*/ aRefData.SetColRel( TRUE ); +/*N*/ aRefData.SetRowRel( TRUE ); +/*N*/ aRefData.SetTabRel( TRUE ); +/*N*/ aRefData.CalcRelFromAbs( ScAddress( nCol1, nRow1, nTab1 ) ); +/*N*/ +/*N*/ ScTokenArray aArr; +/*N*/ ScToken* t = aArr.AddSingleReference(aRefData); +/*N*/ t->NewOpCode( ocMatRef ); +/*N*/ +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ { +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ { +/*N*/ pTab[i]->DoColResize( nCol1, nCol2, nRow2 - nRow1 + 1 ); +/*N*/ if (i != nTab1) +/*N*/ { +/*?*/ aRefData.nTab = i; +/*?*/ aRefData.nRelTab = i - nTab1; +/*?*/ t->GetSingleRef() = aRefData; +/*N*/ } +/*N*/ for (j = nCol1; j <= nCol2; j++) +/*N*/ { +/*N*/ for (k = nRow1; k <= nRow2; k++) +/*N*/ { +/*N*/ if (j != nCol1 || k != nRow1) // nicht in der ersten Zelle +/*N*/ { +/*N*/ // Array muss geklont werden, damit jede +/*N*/ // Zelle ein eigenes Array erhaelt! +/*N*/ aPos = ScAddress( j, k, i ); +/*N*/ t->CalcRelFromAbs( aPos ); +/*N*/ pCell = new ScFormulaCell( this, aPos, aArr.Clone(), MM_REFERENCE ); +/*N*/ pTab[i]->PutCell(j, k, (ScBaseCell*) pCell); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + +/*N*/ BOOL ScDocument::GetNextMarkedCell( USHORT& rCol, USHORT& rRow, USHORT nTab, +/*N*/ const ScMarkData& rMark ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetNextMarkedCell( rCol, rRow, rMark ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScDocument::CompileDBFormula() +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ } + +/*N*/ void ScDocument::CompileDBFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ { +/*N*/ if (pTab[i]) pTab[i]->CompileDBFormula( bCreateFormulaString ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::CompileNameFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ if ( pCondFormList ) +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pCondFormList->CompileAll(); // nach ScNameDlg noetig +/*N*/ +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ { +/*N*/ if (pTab[i]) pTab[i]->CompileNameFormula( bCreateFormulaString ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::CompileColRowNameFormula() +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ { +/*N*/ if (pTab[i]) pTab[i]->CompileColRowNameFormula(); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::DoColResize( USHORT nTab, USHORT nCol1, USHORT nCol2, USHORT nAdd ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->DoColResize( nCol1, nCol2, nAdd ); +/*N*/ else +/*N*/ DBG_ERROR("DoColResize: falsche Tabelle"); +/*N*/ } + +/*N*/ void ScDocument::InvalidateTableArea() +/*N*/ { +/*N*/ for (USHORT nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++) +/*N*/ { +/*N*/ pTab[nTab]->InvalidateTableArea(); +/*N*/ if ( pTab[nTab]->IsScenario() ) +/*N*/ pTab[nTab]->InvalidateScenarioRanges(); +/*N*/ } +/*N*/ } + + + +/*N*/ BOOL ScDocument::GetSelectionFunction( ScSubTotalFunc eFunc, +/*N*/ const ScAddress& rCursor, const ScMarkData& rMark, +/*N*/ double& rResult ) +/*N*/ { +/*N*/ ScFunctionData aData(eFunc); +/*N*/ +/*N*/ ScRange aSingle( rCursor ); +/*N*/ if ( rMark.IsMarked() ) +/*N*/ rMark.GetMarkArea(aSingle); +/*N*/ +/*N*/ USHORT nStartCol = aSingle.aStart.Col(); +/*N*/ USHORT nStartRow = aSingle.aStart.Row(); +/*N*/ USHORT nEndCol = aSingle.aEnd.Col(); +/*N*/ USHORT nEndRow = aSingle.aEnd.Row(); +/*N*/ +/*N*/ for (USHORT nTab=0; nTab<=MAXTAB && !aData.bError; nTab++) +/*N*/ if (pTab[nTab] && rMark.GetTableSelect(nTab)) +/*N*/ pTab[nTab]->UpdateSelectionFunction( aData, +/*N*/ nStartCol, nStartRow, nEndCol, nEndRow, rMark ); +/*N*/ +/*N*/ //! rMark an UpdateSelectionFunction uebergeben !!!!! +/*N*/ +/*N*/ if (!aData.bError) +/*N*/ switch (eFunc) +/*N*/ { +/*N*/ case SUBTOTAL_FUNC_SUM: +/*N*/ rResult = aData.nVal; +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_CNT: +/*N*/ case SUBTOTAL_FUNC_CNT2: +/*N*/ rResult = aData.nCount; +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_AVE: +/*N*/ if (aData.nCount) +/*N*/ rResult = aData.nVal / (double) aData.nCount; +/*N*/ else +/*N*/ aData.bError = TRUE; +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_MAX: +/*N*/ case SUBTOTAL_FUNC_MIN: +/*N*/ if (aData.nCount) +/*N*/ rResult = aData.nVal; +/*N*/ else +/*N*/ aData.bError = TRUE; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ if (aData.bError) +/*N*/ rResult = 0.0; +/*N*/ +/*N*/ return !aData.bError; +/*N*/ } + +/*N*/ double ScDocument::RoundValueAsShown( double fVal, ULONG nFormat ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 short nType; + return 0;//STRIP001 return fVal; +} + +// +// bedingte Formate und Gueltigkeitsbereiche +// + +/*N*/ ULONG ScDocument::AddCondFormat( const ScConditionalFormat& rNew ) +/*N*/ { +/*N*/ if (rNew.IsEmpty()) +/*N*/ return 0; // leer ist immer 0 +/*N*/ +/*N*/ if (!pCondFormList) +/*N*/ pCondFormList = new ScConditionalFormatList; +/*N*/ +/*N*/ ULONG nMax = 0; +/*N*/ USHORT nCount = pCondFormList->Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScConditionalFormat* pForm = (*pCondFormList)[i]; +/*N*/ ULONG nKey = pForm->GetKey(); +/*N*/ if ( pForm->EqualEntries( rNew ) ) +/*N*/ return nKey; +/*N*/ if ( nKey > nMax ) +/*N*/ nMax = nKey; +/*N*/ } +/*N*/ +/*N*/ // Der Aufruf kann aus ScPatternAttr::PutInPool kommen, darum Clone (echte Kopie) +/*N*/ +/*N*/ ULONG nNewKey = nMax + 1; +/*N*/ ScConditionalFormat* pInsert = rNew.Clone(this); +/*N*/ pInsert->SetKey( nNewKey ); +/*N*/ pCondFormList->InsertNew( pInsert ); +/*N*/ return nNewKey; +/*N*/ } + +/*N*/ ULONG ScDocument::AddValidationEntry( const ScValidationData& rNew ) +/*N*/ { +/*N*/ if (rNew.IsEmpty()) +/*N*/ return 0; // leer ist immer 0 +/*N*/ +/*N*/ if (!pValidationList) +/*N*/ pValidationList = new ScValidationDataList; +/*N*/ +/*N*/ ULONG nMax = 0; +/*N*/ USHORT nCount = pValidationList->Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScValidationData* pData = (*pValidationList)[i]; +/*N*/ ULONG nKey = pData->GetKey(); +/*N*/ if ( pData->EqualEntries( rNew ) ) +/*N*/ return nKey; +/*N*/ if ( nKey > nMax ) +/*N*/ nMax = nKey; +/*N*/ } +/*N*/ +/*N*/ // Der Aufruf kann aus ScPatternAttr::PutInPool kommen, darum Clone (echte Kopie) +/*N*/ +/*N*/ ULONG nNewKey = nMax + 1; +/*N*/ ScValidationData* pInsert = rNew.Clone(this); +/*N*/ pInsert->SetKey( nNewKey ); +/*N*/ pValidationList->InsertNew( pInsert ); +/*N*/ return nNewKey; +/*N*/ } + + +/*N*/ const SfxItemSet* ScDocument::GetCondResult( USHORT nCol, USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ const ScConditionalFormat* pForm = GetCondFormat( nCol, nRow, nTab ); +/*N*/ if ( pForm ) +/*N*/ { +/*N*/ ScBaseCell* pCell = ((ScDocument*)this)->GetCell(ScAddress(nCol,nRow,nTab)); +/*N*/ String aStyle = pForm->GetCellStyle( pCell, ScAddress(nCol, nRow, nTab) ); +/*N*/ if (aStyle.Len()) +/*N*/ { +/*N*/ SfxStyleSheetBase* pStyleSheet = xPoolHelper->GetStylePool()->Find( aStyle, SFX_STYLE_FAMILY_PARA ); +/*N*/ if ( pStyleSheet ) +/*N*/ return &pStyleSheet->GetItemSet(); +/*N*/ // if style is not there, treat like no condition +/*N*/ } +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ const ScConditionalFormat* ScDocument::GetCondFormat( +/*N*/ USHORT nCol, USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ ULONG nIndex = ((const SfxUInt32Item*)GetAttr(nCol,nRow,nTab,ATTR_CONDITIONAL))->GetValue(); +/*N*/ if (nIndex) +/*N*/ { +/*N*/ if (pCondFormList) +/*N*/ return pCondFormList->GetFormat( nIndex ); +/*N*/ else +/*N*/ DBG_ERROR("pCondFormList ist 0"); +/*N*/ } +/*N*/ +/*N*/ return NULL; +/*N*/ } + +/*N*/ const ScValidationData* ScDocument::GetValidationEntry( ULONG nIndex ) const +/*N*/ { +/*N*/ if ( pValidationList ) +/*N*/ return pValidationList->GetData( nIndex ); +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScDocument::FindConditionalFormat( ULONG nKey, ScRangeList& rRanges ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB && pTab[i]; i++) +/*N*/ pTab[i]->FindConditionalFormat( nKey, rRanges ); +/*N*/ } + + +/*N*/ void ScDocument::ConditionalChanged( ULONG nKey ) +/*N*/ { +/*N*/ if ( nKey && pCondFormList && !bIsClip && !bIsUndo ) // nKey==0 -> noop +/*N*/ { +/*N*/ ScConditionalFormat* pForm = pCondFormList->GetFormat( nKey ); +/*N*/ if (pForm) +/*N*/ pForm->InvalidateArea(); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::SetConditionalUsed( ULONG nKey ) // aus dem Speichern der Tabellen +/*N*/ { +/*N*/ if ( nKey && pCondFormList ) // nKey==0 -> noop +/*N*/ { +/*N*/ ScConditionalFormat* pForm = pCondFormList->GetFormat( nKey ); +/*N*/ if (pForm) +/*N*/ pForm->SetUsed(TRUE); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::SetValidationUsed( ULONG nKey ) // aus dem Speichern der Tabellen +/*N*/ { +/*N*/ if ( nKey && pValidationList ) // nKey==0 -> noop +/*N*/ { +/*N*/ ScValidationData* pData = pValidationList->GetData( nKey ); +/*N*/ if (pData) +/*N*/ pData->SetUsed(TRUE); +/*N*/ } +/*N*/ } + + +//------------------------------------------------------------------------ + + +/*N*/ void ScDocument::AddDetectiveOperation( const ScDetOpData& rData ) +/*N*/ { +/*N*/ if (!pDetOpList) +/*N*/ pDetOpList = new ScDetOpList; +/*N*/ +/*N*/ pDetOpList->Append( new ScDetOpData( rData ) ); +/*N*/ } + +/*N*/ void ScDocument::ClearDetectiveOperations() +/*N*/ { +/*N*/ delete pDetOpList; // loescht auch die Eintraege +/*N*/ pDetOpList = NULL; +/*N*/ } + + +//------------------------------------------------------------------------ +// +// Vergleich von Dokumenten +// +//------------------------------------------------------------------------ + +// Pfriemel-Faktoren +#define SC_DOCCOMP_MAXDIFF 256 +#define SC_DOCCOMP_MINGOOD 128 +#define SC_DOCCOMP_COLUMNS 10 +#define SC_DOCCOMP_ROWS 100 + + + + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen5.cxx b/binfilter/bf_sc/source/core/data/sc_documen5.cxx new file mode 100644 index 000000000000..b5bfdb0acd9a --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen5.cxx @@ -0,0 +1,541 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#ifdef _MSC_VER +#pragma optimize("",off) +#endif +#ifdef _MSC_VER +#pragma optimize("q",off) // p-code off +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_sfx2/objsh.hxx> +#include <bf_svx/svditer.hxx> +#include <bf_svx/svdoole2.hxx> +#include <bf_svx/svdpage.hxx> +#include <bf_sch/schdll.hxx> +#include <bf_sch/memchrt.hxx> +#include <bf_sch/schdll0.hxx> + +#include "document.hxx" +#include "drwlayer.hxx" +#include "chartarr.hxx" +#include "chartlis.hxx" +#include "refupdat.hxx" +namespace binfilter { + +#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED +#define SO2_DECL_SVINPLACEOBJECT_DEFINED +SO2_DECL_REF(SvInPlaceObject) +#endif + +// ----------------------------------------------------------------------- + + // Charts aus altem Dokument updaten + +/*N*/ void ScDocument::UpdateAllCharts(BOOL bDoUpdate) +/*N*/ { +/*N*/ if (!pDrawLayer) +/*N*/ return; +/*N*/ +/*N*/ USHORT nDataCount = pChartCollection->GetCount(); +/*N*/ if ( !nDataCount ) +/*N*/ return ; // nothing to do +/*?*/ +/*?*/ USHORT nPos; +/*?*/ +/*?*/ for (USHORT nTab=0; nTab<=MAXTAB; nTab++) +/*?*/ { +/*?*/ if (pTab[nTab]) +/*?*/ { +/*?*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*?*/ DBG_ASSERT(pPage,"Page ?"); +/*?*/ +/*?*/ ScRange aRange; +/*?*/ SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); +/*?*/ SdrObject* pObject = aIter.Next(); +/*?*/ while (pObject) +/*?*/ { +/*?*/ if ( pObject->GetObjIdentifier() == OBJ_OLE2 ) +/*?*/ { +/*?*/ SvInPlaceObjectRef aIPObj = ((SdrOle2Obj*)pObject)->GetObjRef(); +/*?*/ if (aIPObj.Is()) +/*?*/ { +/*?*/ // String aIPName = aIPObj->GetName()->GetName(); +/*?*/ +/*?*/ SvInfoObject* pInfoObj = pShell->Find( aIPObj ); +/*?*/ String aIPName; +/*?*/ +/*?*/ if ( pInfoObj ) +/*?*/ aIPName = pInfoObj->GetObjName(); +/*?*/ +/*?*/ for (nPos=0; nPos<nDataCount; nPos++) +/*?*/ { +/*?*/ ScChartArray* pChartObj = (*pChartCollection)[nPos]; +/*?*/ if (pChartObj->GetName() == aIPName) +/*?*/ { +/*?*/ if (bDoUpdate) +/*?*/ { +/*?*/ SchMemChart* pMemChart = pChartObj->CreateMemChart(); +/*?*/ SchDLL::Update( aIPObj, pMemChart ); +/*?*/ delete pMemChart; +/*?*/ } +/*?*/ else // nur Position uebernehmen +/*?*/ { +/*?*/ SchMemChart* pChartData = SchDLL::GetChartData(aIPObj); +/*?*/ if (pChartData) +/*?*/ { +/*?*/ pChartObj->SetExtraStrings(*pChartData); +/*?*/ // aIPObj->SetModified( TRUE ); +/*?*/ } +/*?*/ } +/*?*/ ScChartListener* pCL = new ScChartListener( +/*?*/ aIPName, this, pChartObj->GetRangeList() ); +/*?*/ pChartListenerCollection->Insert( pCL ); +/*?*/ pCL->StartListeningTo(); +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ pObject = aIter.Next(); +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ pChartCollection->FreeAll(); +/*N*/ } + + +/*N*/ void ScDocument::UpdateChartArea( const String& rChartName, +/*N*/ const ScRangeListRef& rNewList, BOOL bColHeaders, BOOL bRowHeaders, +/*N*/ BOOL bAdd, Window* pWindow ) +/*N*/ { +/*N*/ if (!pDrawLayer) +/*N*/ return; +/*N*/ +/*N*/ for (USHORT nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++) +/*N*/ { +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetObjIdentifier() == OBJ_OLE2 && +/*N*/ ((SdrOle2Obj*)pObject)->GetPersistName() == rChartName ) +/*N*/ { +/*N*/ SvInPlaceObjectRef aIPObj = ((SdrOle2Obj*)pObject)->GetObjRef(); +/*N*/ if (aIPObj.Is()) +/*N*/ { +/*N*/ const SchMemChart* pChartData = SchDLL::GetChartData(aIPObj); +/*N*/ if ( pChartData ) +/*N*/ { +/*N*/ ScChartArray aArray( this, *pChartData ); +/*N*/ if ( bAdd ) +/*N*/ { +/*N*/ // bei bAdd werden Header-Angaben ignoriert +/*N*/ aArray.AddToRangeList( rNewList ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aArray.SetRangeList( rNewList ); +/*N*/ aArray.SetHeaders( bColHeaders, bRowHeaders ); +/*N*/ } +/*N*/ pChartListenerCollection->ChangeListening( +/*N*/ rChartName, aArray.GetRangeList() ); +/*N*/ +/*N*/ +/*N*/ SchMemChart* pMemChart = aArray.CreateMemChart(); +/*N*/ ScChartArray::CopySettings( *pMemChart, *pChartData ); +/*N*/ +/*N*/ SchDLL::Update( aIPObj, pMemChart, pWindow ); +/*N*/ delete pMemChart; +/*N*/ +/*N*/ // Dies veranlaesst Chart zum sofortigen Update +/*N*/ //SvData aEmpty; +/*N*/ //aIPObj->SendDataChanged( aEmpty ); +/*N*/ aIPObj->SendViewChanged(); +/*N*/ pObject->SendRepaintBroadcast(); +/*N*/ +/*N*/ return; // nicht weitersuchen +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::UpdateChart( const String& rChartName, Window* pWindow ) +/*N*/ { +/*N*/ if (!pDrawLayer || bInDtorClear) +/*N*/ return; +/*N*/ +/*N*/ for (USHORT nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++) +/*N*/ { +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetObjIdentifier() == OBJ_OLE2 && +/*N*/ ((SdrOle2Obj*)pObject)->GetPersistName() == rChartName ) +/*N*/ { +/*N*/ SvInPlaceObjectRef aIPObj = ((SdrOle2Obj*)pObject)->GetObjRef(); +/*N*/ if (aIPObj.Is()) +/*N*/ { +/*N*/ const SchMemChart* pChartData = SchDLL::GetChartData(aIPObj); +/*N*/ if ( pChartData ) +/*N*/ { +/*N*/ ScChartArray aArray( this, *pChartData ); +/*N*/ +/*N*/ SchMemChart* pMemChart = aArray.CreateMemChart(); +/*N*/ ScChartArray::CopySettings( *pMemChart, *pChartData ); +/*N*/ +/*N*/ // #57655# Chart-Update ohne geaenderte Einstellungen (MemChart) +/*N*/ // soll das Dokument nicht auf modified setzen (z.B. in frisch +/*N*/ // geladenem Dokument durch initiales Recalc) +/*N*/ +/*N*/ // #72576# disable SetModified for readonly documents only +/*N*/ +/*N*/ BOOL bEnabled = ( ((pShell && pShell->IsReadOnly()) || +/*N*/ IsImportingXML()) && +/*N*/ aIPObj->IsEnableSetModified() ); +/*N*/ if (bEnabled) +/*N*/ aIPObj->EnableSetModified(FALSE); +/*N*/ +/*N*/ SchDLL::Update( aIPObj, pMemChart, pWindow ); +/*N*/ delete pMemChart; +/*N*/ +/*N*/ // Dies veranlaesst Chart zum sofortigen Update +/*N*/ //SvData aEmpty; +/*N*/ //aIPObj->SendDataChanged( aEmpty ); +/*N*/ aIPObj->SendViewChanged(); +/*N*/ pObject->SendRepaintBroadcast(); +/*N*/ +/*N*/ if (bEnabled) +/*N*/ aIPObj->EnableSetModified(TRUE); +/*N*/ +/*N*/ return; // nicht weitersuchen +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::UpdateChartRef( UpdateRefMode eUpdateRefMode, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ if (!pDrawLayer) +/*N*/ return; +/*N*/ +/*N*/ USHORT nChartCount = pChartListenerCollection->GetCount(); +/*N*/ for ( USHORT nIndex = 0; nIndex < nChartCount; nIndex++ ) +/*N*/ { +/*?*/ ScChartListener* pChartListener = +/*?*/ (ScChartListener*) (pChartListenerCollection->At(nIndex)); +/*?*/ ScRangeListRef aRLR( pChartListener->GetRangeList() ); +/*?*/ ScRangeListRef aNewRLR( new ScRangeList ); +/*?*/ BOOL bChanged = FALSE; +/*?*/ BOOL bDataChanged = FALSE; +/*?*/ for ( ScRangePtr pR = aRLR->First(); pR; pR = aRLR->Next() ) +/*?*/ { +/*?*/ USHORT theCol1 = pR->aStart.Col(); +/*?*/ USHORT theRow1 = pR->aStart.Row(); +/*?*/ USHORT theTab1 = pR->aStart.Tab(); +/*?*/ USHORT theCol2 = pR->aEnd.Col(); +/*?*/ USHORT theRow2 = pR->aEnd.Row(); +/*?*/ USHORT theTab2 = pR->aEnd.Tab(); +/*?*/ ScRefUpdateRes eRes = ScRefUpdate::Update( +/*?*/ this, eUpdateRefMode, +/*?*/ nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, +/*?*/ nDx,nDy,nDz, +/*?*/ theCol1,theRow1,theTab1, +/*?*/ theCol2,theRow2,theTab2 ); +/*?*/ if ( eRes != UR_NOTHING ) +/*?*/ { +/*?*/ bChanged = TRUE; +/*?*/ aNewRLR->Append( ScRange( +/*?*/ theCol1, theRow1, theTab1, +/*?*/ theCol2, theRow2, theTab2 )); +/*?*/ if ( eUpdateRefMode == URM_INSDEL +/*?*/ && !bDataChanged +/*?*/ && (eRes == UR_INVALID || +/*?*/ ((pR->aEnd.Col() - pR->aStart.Col() +/*?*/ != theCol2 - theCol1) +/*?*/ || (pR->aEnd.Row() - pR->aStart.Row() +/*?*/ != theRow2 - theRow1) +/*?*/ || (pR->aEnd.Tab() - pR->aStart.Tab() +/*?*/ != theTab2 - theTab1))) ) +/*?*/ { +/*?*/ bDataChanged = TRUE; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ aNewRLR->Append( *pR ); +/*?*/ } +/*?*/ if ( bChanged ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( nDz != 0 ) +/*?*/ } +/*N*/ } +/*N*/ } + + + + +/*N*/ BOOL ScDocument::HasData( USHORT nCol, USHORT nRow, USHORT nTab ) +/*N*/ { +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->HasData( nCol, nRow ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ SchMemChart* ScDocument::FindChartData(const String& rName, BOOL bForModify) +/*N*/ { +/*N*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (!pDrawLayer) +/*N*/ return NULL; // nix +/*N*/ } + + +/*N*/ BOOL lcl_StringInCollection( const StrCollection* pColl, const String& rStr ) +/*N*/ { +/*N*/ if ( !pColl ) +/*N*/ return FALSE; +/*N*/ +/*N*/ StrData aData( rStr ); +/*N*/ USHORT nDummy; +/*N*/ return pColl->Search( &aData, nDummy ); +/*N*/ } + +/*N*/ void ScDocument::UpdateChartListenerCollection() +/*N*/ { +/*N*/ bChartListenerCollectionNeedsUpdate = FALSE; +/*N*/ if (!pDrawLayer) +/*N*/ return; +/*N*/ else +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ // Range fuer Suche unwichtig +/*N*/ ScChartListener aCLSearcher( EMPTY_STRING, this, aRange ); +/*N*/ for (USHORT nTab=0; nTab<=MAXTAB; nTab++) +/*N*/ { +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetObjIdentifier() == OBJ_OLE2 ) +/*N*/ { +/*N*/ String aObjName = ((SdrOle2Obj*)pObject)->GetPersistName(); +/*N*/ aCLSearcher.SetString( aObjName ); +/*N*/ USHORT nIndex; +/*N*/ if ( pChartListenerCollection->Search( &aCLSearcher, nIndex ) ) +/*N*/ { +/*N*/ ((ScChartListener*) (pChartListenerCollection-> +/*N*/ At( nIndex )))->SetUsed( TRUE ); +/*N*/ } +/*N*/ else if ( lcl_StringInCollection( pOtherObjects, aObjName ) ) +/*N*/ { +/*N*/ // non-chart OLE object -> don't touch +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // SchDLL::GetChartData always loads the chart dll, +/*N*/ // so SchModuleDummy::HasID must be tested before +/*N*/ +/*N*/ BOOL bIsChart = FALSE; +/*N*/ USHORT nId; +/*N*/ +/*N*/ // Ask the SvPersist for the InfoObject to find out +/*N*/ // whether it is a Chart. The old way with GetObjRef +/*N*/ // loads the object which takes too much unnecessary +/*N*/ // time +/*N*/ SvInfoObject* pInfoObj = pShell->Find(aObjName); +/*N*/ DBG_ASSERT(pInfoObj, "Why isn't here a SvInfoObject?"); +/*N*/ if ( pInfoObj && +/*N*/ ((nId = SchModuleDummy::HasID(pInfoObj->GetClassName()) ) != 0) ) +/*N*/ { +/*N*/ SvInPlaceObjectRef aIPObj = ((SdrOle2Obj*)pObject)->GetObjRef(); +/*N*/ DBG_ASSERT(aIPObj.Is(), "no SvInPlaceObject given"); +/*N*/ if (aIPObj.Is()) +/*N*/ { +/*N*/ BOOL bSO6 = (nId >= SOFFICE_FILEFORMAT_60); +/*N*/ SchMemChart* pChartData = SchDLL::GetChartData(aIPObj); +/*N*/ // #84359# manually inserted OLE object +/*N*/ // => no listener at ScAddress(0,0,0) +/*N*/ // >=SO6: if no series set +/*N*/ // < SO6: if no SomeData set +/*N*/ if ( pChartData && +/*N*/ ((!bSO6 && pChartData->SomeData1().Len()) || +/*N*/ (bSO6 && pChartData->GetChartRange().maRanges.size())) ) +/*N*/ { +/*N*/ if ( PastingDrawFromOtherDoc() ) +/*N*/ { +/*?*/ // #89247# Remove series ranges from +/*?*/ // charts not originating from the +/*?*/ // same document, they become true OLE +/*?*/ // objects. +/*?*/ pChartData->SomeData1().Erase(); +/*?*/ pChartData->SomeData2().Erase(); +/*?*/ pChartData->SomeData3().Erase(); +/*?*/ pChartData->SomeData4().Erase(); +/*?*/ SchChartRange aChartRange; +/*?*/ pChartData->SetChartRange( aChartRange ); +/*?*/ pChartData->SetReadOnly( FALSE ); +/*?*/ SchDLL::Update( aIPObj, pChartData ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bIsChart = TRUE; +/*N*/ +/*N*/ ScChartArray aArray( this, *pChartData ); +/*N*/ ScChartListener* pCL = new ScChartListener( +/*N*/ aObjName, +/*N*/ this, aArray.GetRangeList() ); +/*N*/ pChartListenerCollection->Insert( pCL ); +/*N*/ pCL->StartListeningTo(); +/*N*/ pCL->SetUsed( TRUE ); +/*N*/ +/*N*/ BOOL bForceSave = FALSE; +/*N*/ +/*N*/ // Set ReadOnly flag at MemChart, so Chart knows +/*N*/ // about the external data in a freshly loaded document. +/*N*/ // #73642# only if the chart really has external data +/*N*/ if ( aArray.IsValid() ) +/*N*/ { +/*N*/ pChartData->SetReadOnly( TRUE ); +/*N*/ +/*N*/ // #81525# re-create series ranges from old extra string +/*N*/ // if not set (after loading) +/*N*/ if ( !bSO6 ) +/*N*/ { +/*N*/ String aOldData3 = pChartData->SomeData3(); +/*N*/ aArray.SetExtraStrings( *pChartData ); +/*N*/ if ( aOldData3 != pChartData->SomeData3() ) +/*N*/ { +/*N*/ // #96148# ChartRange isn't saved in binary format anyway, +/*N*/ // but SomeData3 (sheet names) has to survive swapping out, +/*N*/ // or the chart can't be saved to 6.0 format. +/*N*/ +/*N*/ bForceSave = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ #if 1 +/*N*/ // #74046# initially loaded charts need the number formatter standard precision +/*N*/ BOOL bEnabled = aIPObj->IsEnableSetModified(); +/*N*/ if (bEnabled) +/*N*/ aIPObj->EnableSetModified(FALSE); +/*N*/ pChartData->SetNumberFormatter( GetFormatTable() ); +/*N*/ SchDLL::Update( aIPObj, pChartData ); +/*N*/ //! pChartData got deleted, don't use it anymore +/*N*/ if (bEnabled) +/*N*/ aIPObj->EnableSetModified(TRUE); +/*N*/ #ifdef DBG_UTIL +/*N*/ // static BOOL bShown74046 = 0; +/*N*/ // if ( !bShown74046 && SOFFICE_FILEFORMAT_NOW > SOFFICE_FILEFORMAT_50 ) +/*N*/ // { +/*N*/ // bShown74046 = 1; +/*N*/ // DBG_ERRORFILE( "on incompatible file format save number formatter standard precision in chart" ); +/*N*/ // } +/*N*/ #endif +/*N*/ #endif +/*N*/ if ( bForceSave ) +/*N*/ { +/*N*/ // #96148# after adjusting the data that wasn't in the MemChart +/*N*/ // in a binary file (ChartRange etc.), the chart object has to be +/*N*/ // saved (within the open document, in transacted mode, so the +/*N*/ // original file isn't changed yet), so the changes are still +/*N*/ // there after the chart is swapped out and loaded again. +/*N*/ // The chart can't get the modified flag set, because then it +/*N*/ // wouldn't be swapped out at all. So it has to be saved manually +/*N*/ // here (which is unnecessary if the chart is modified before it +/*N*/ // it swapped out). At this point, we don't have to care about +/*N*/ // contents being lost when saving in old binary format, because +/*N*/ // the chart was just loaded from that format. +/*N*/ +/*N*/ aIPObj->DoSave(); +/*N*/ aIPObj->DoSaveCompleted(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if (!bIsChart) +/*N*/ { +/*N*/ // put into list of other ole objects, so the object doesn't have to +/*N*/ // be swapped in the next time UpdateChartListenerCollection is called +/*N*/ //! remove names when objects are no longer there? +/*N*/ // (object names aren't used again before reloading the document) +/*N*/ +/*N*/ if (!pOtherObjects) +/*N*/ pOtherObjects = new StrCollection; +/*N*/ pOtherObjects->Insert( new StrData( aObjName ) ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ // alle nicht auf SetUsed gesetzten loeschen +/*N*/ pChartListenerCollection->FreeUnused(); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::AddOLEObjectToCollection(const String& rName) +/*N*/ { +/*N*/ if (!pOtherObjects) +/*N*/ pOtherObjects = new StrCollection; +/*N*/ pOtherObjects->Insert( new StrData( rName ) ); +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen6.cxx b/binfilter/bf_sc/source/core/data/sc_documen6.cxx new file mode 100644 index 000000000000..898b72fe8963 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen6.cxx @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef PCH +#include "core_pch.hxx" +#endif + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "scitems.hxx" +#include <bf_svx/scripttypeitem.hxx> + +#include <com/sun/star/i18n/XBreakIterator.hpp> +#include <com/sun/star/i18n/ScriptType.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> + +#include "document.hxx" +#include "cell.hxx" +#include "cellform.hxx" +#include "patattr.hxx" +#include "scrdata.hxx" +#include "poolhelp.hxx" +namespace binfilter { + +using namespace ::com::sun::star; + +#define SC_BREAKITER_SERVICE "com.sun.star.i18n.BreakIterator" + +// +// this file is compiled with exceptions enabled +// put functions here that need exceptions! +// + +// ----------------------------------------------------------------------- + +/*N*/ const uno::Reference< i18n::XBreakIterator >& ScDocument::GetBreakIterator() +/*N*/ { +/*N*/ if ( !pScriptTypeData ) +/*N*/ pScriptTypeData = new ScScriptTypeData; +/*N*/ if ( !pScriptTypeData->xBreakIter.is() ) +/*N*/ { +/*N*/ uno::Reference< uno::XInterface > xInterface = xServiceManager->createInstance( +/*N*/ ::rtl::OUString::createFromAscii( SC_BREAKITER_SERVICE ) ); +/*N*/ pScriptTypeData->xBreakIter = uno::Reference< i18n::XBreakIterator >( xInterface, uno::UNO_QUERY ); +/*N*/ DBG_ASSERT( pScriptTypeData->xBreakIter.is(), "can't get BreakIterator" ); +/*N*/ } +/*N*/ return pScriptTypeData->xBreakIter; +/*N*/ } + + +/*N*/ BYTE ScDocument::GetStringScriptType( const String& rString ) +/*N*/ { +/*N*/ +/*N*/ BYTE nRet = 0; +/*N*/ if (rString.Len()) +/*N*/ { +/*N*/ uno::Reference<i18n::XBreakIterator> xBreakIter = GetBreakIterator(); +/*N*/ if ( xBreakIter.is() ) +/*N*/ { +/*N*/ ::rtl::OUString aText = rString; +/*N*/ sal_Int32 nLen = aText.getLength(); +/*N*/ +/*N*/ sal_Int32 nPos = 0; +/*N*/ do +/*N*/ { +/*N*/ sal_Int16 nType = xBreakIter->getScriptType( aText, nPos ); +/*N*/ switch ( nType ) +/*N*/ { +/*N*/ case i18n::ScriptType::LATIN: +/*N*/ nRet |= SCRIPTTYPE_LATIN; +/*N*/ break; +/*N*/ case i18n::ScriptType::ASIAN: +/*N*/ nRet |= SCRIPTTYPE_ASIAN; +/*N*/ break; +/*N*/ case i18n::ScriptType::COMPLEX: +/*N*/ nRet |= SCRIPTTYPE_COMPLEX; +/*N*/ break; +/*N*/ // WEAK is ignored +/*N*/ } +/*N*/ nPos = xBreakIter->endOfScript( aText, nPos, nType ); +/*N*/ } +/*N*/ while ( nPos >= 0 && nPos < nLen ); +/*N*/ } +/*N*/ } +/*N*/ return nRet; +/*N*/ } + +/*N*/ BYTE ScDocument::GetCellScriptType( ScBaseCell* pCell, ULONG nNumberFormat ) +/*N*/ { +/*N*/ if ( !pCell ) +/*N*/ return 0; // empty +/*N*/ +/*N*/ BYTE nStored = pCell->GetScriptType(); +/*N*/ if ( nStored != SC_SCRIPTTYPE_UNKNOWN ) // stored value valid? +/*N*/ return nStored; // use stored value +/*N*/ +/*N*/ String aStr; +/*N*/ Color* pColor; +/*N*/ ScCellFormat::GetString( pCell, nNumberFormat, aStr, &pColor, *xPoolHelper->GetFormTable() ); +/*N*/ +/*N*/ BYTE nRet = GetStringScriptType( aStr ); +/*N*/ +/*N*/ pCell->SetScriptType( nRet ); // store for later calls +/*N*/ +/*N*/ return nRet; +/*N*/ } + +/*N*/ BYTE ScDocument::GetScriptType( USHORT nCol, USHORT nRow, USHORT nTab, ScBaseCell* pCell ) +/*N*/ { +/*N*/ // if cell is not passed, take from document +/*N*/ +/*N*/ if (!pCell) +/*N*/ { +/*N*/ pCell = GetCell( ScAddress( nCol, nRow, nTab ) ); +/*N*/ if ( !pCell ) +/*N*/ return 0; // empty +/*N*/ } +/*N*/ +/*N*/ // if script type is set, don't have to get number formats +/*N*/ +/*N*/ BYTE nStored = pCell->GetScriptType(); +/*N*/ if ( nStored != SC_SCRIPTTYPE_UNKNOWN ) // stored value valid? +/*N*/ return nStored; // use stored value +/*N*/ +/*N*/ // include number formats from conditional formatting +/*N*/ +/*N*/ const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab ); +/*N*/ if (!pPattern) return 0; +/*N*/ const SfxItemSet* pCondSet = NULL; +/*N*/ if ( ((const SfxUInt32Item&)pPattern->GetItem(ATTR_CONDITIONAL)).GetValue() ) +/*N*/ pCondSet = GetCondResult( nCol, nRow, nTab ); +/*N*/ +/*N*/ ULONG nFormat = pPattern->GetNumberFormat( xPoolHelper->GetFormTable(), pCondSet ); +/*N*/ return GetCellScriptType( pCell, nFormat ); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen7.cxx b/binfilter/bf_sc/source/core/data/sc_documen7.cxx new file mode 100644 index 000000000000..58973eae7725 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen7.cxx @@ -0,0 +1,409 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + +#if defined( WNT ) && defined( erBEEP ) +#include <svwin.h> +#define erBEEPER() Beep( 666, 66 ) +#else +#define erBEEPER() +#endif + +#include "document.hxx" +#include "bcaslot.hxx" +#include "cell.hxx" +#include "scmod.hxx" // SC_MOD +#include "inputopt.hxx" // GetExpandRefs +#include "conditio.hxx" +#include "bclist.hxx" + + + +#include "globstr.hrc" +namespace binfilter { + +extern const ScFormulaCell* pLastFormulaTreeTop; // cellform.cxx Err527 WorkAround + +// STATIC DATA ----------------------------------------------------------- + +#ifdef erDEBUG +ULONG erCountBCAInserts = 0; +ULONG erCountBCAFinds = 0; +#endif + +// ----------------------------------------------------------------------- + +/*N*/ void ScDocument::StartListeningArea( const ScRange& rRange, +/*N*/ SfxListener* pListener +/*N*/ ) +/*N*/ { +/*N*/ if ( pBASM ) +/*N*/ pBASM->StartListeningArea( rRange, pListener ); +/*N*/ } + + +/*N*/ void ScDocument::EndListeningArea( const ScRange& rRange, +/*N*/ SfxListener* pListener +/*N*/ ) +/*N*/ { +/*N*/ if ( pBASM ) +/*N*/ pBASM->EndListeningArea( rRange, pListener ); +/*N*/ } + + +/*N*/ void ScDocument::Broadcast( ULONG nHint, const ScAddress& rAddr, +/*N*/ ScBaseCell* pCell +/*N*/ ) +/*N*/ { +/*N*/ if ( !pBASM ) +/*N*/ return ; // Clipboard or Undo +/*N*/ ScHint aHint( nHint, rAddr, pCell ); +/*N*/ Broadcast( aHint ); +/*N*/ } + + +/*N*/ void ScDocument::Broadcast( const ScHint& rHint ) +/*N*/ { +/*N*/ if ( !pBASM ) +/*N*/ return ; // Clipboard or Undo +/*N*/ if ( !nHardRecalcState ) +/*N*/ { +/*N*/ BOOL bIsBroadcasted = FALSE; +/*N*/ ScBaseCell* pCell = rHint.GetCell(); +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ ScBroadcasterList* pBC = pCell->GetBroadcaster(); +/*N*/ if ( pBC ) +/*N*/ { +/*N*/ pBC->Broadcast( rHint ); +/*N*/ bIsBroadcasted = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if ( pBASM->AreaBroadcast( rHint ) || bIsBroadcasted ) +/*N*/ TrackFormulas( rHint.GetId() ); +/*N*/ } +/*N*/ +/*N*/ // Repaint fuer bedingte Formate mit relativen Referenzen: +/*N*/ if ( pCondFormList && rHint.GetAddress() != BCA_BRDCST_ALWAYS ) +/*?*/ pCondFormList->SourceChanged( rHint.GetAddress() ); +/*N*/ } + + +/*N*/ void ScDocument::AreaBroadcast( const ScHint& rHint ) +/*N*/ { +/*N*/ if ( !pBASM ) +/*N*/ return ; // Clipboard or Undo +/*N*/ if ( !nHardRecalcState ) +/*N*/ { +/*N*/ if ( pBASM->AreaBroadcast( rHint ) ) +/*N*/ TrackFormulas( rHint.GetId() ); +/*N*/ } +/*N*/ +/*N*/ // Repaint fuer bedingte Formate mit relativen Referenzen: +/*N*/ if ( pCondFormList && rHint.GetAddress() != BCA_BRDCST_ALWAYS ) +/*N*/ pCondFormList->SourceChanged( rHint.GetAddress() ); +/*N*/ } + + +/*N*/ void ScDocument::AreaBroadcastInRange( const ScRange& rRange, const ScHint& rHint ) +/*N*/ { +/*N*/ if ( !pBASM ) +/*N*/ return ; // Clipboard or Undo +/*N*/ if ( !nHardRecalcState ) +/*N*/ { +/*N*/ if ( pBASM->AreaBroadcastInRange( rRange, rHint ) ) +/*N*/ TrackFormulas( rHint.GetId() ); +/*N*/ } +/*N*/ +/*N*/ // Repaint for conditional formats containing relative references. +/*N*/ //! This is _THE_ bottle neck! +/*N*/ if ( pCondFormList ) +/*N*/ { +/*N*/ USHORT nCol, nRow, nTab, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ rRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ ScAddress aAddress( rRange.aStart ); +/*N*/ for ( nTab = nTab1; nTab <= nTab2; ++nTab ) +/*N*/ { +/*N*/ aAddress.SetTab( nTab ); +/*N*/ for ( nCol = nCol1; nCol <= nCol2; ++nCol ) +/*N*/ { +/*N*/ aAddress.SetCol( nCol ); +/*N*/ for ( nRow = nRow1; nRow <= nRow2; ++nRow ) +/*N*/ { +/*N*/ aAddress.SetRow( nRow ); +/*N*/ pCondFormList->SourceChanged( aAddress ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::DelBroadcastAreasInRange( const ScRange& rRange ) +/*N*/ { +/*N*/ if ( pBASM ) +/*N*/ pBASM->DelBroadcastAreasInRange( rRange ); +/*N*/ } + +/*N*/ void ScDocument::StartListeningCell( const ScAddress& rAddress, +/*N*/ SfxListener* pListener ) +/*N*/ { +/*N*/ DBG_ASSERT(pListener, "StartListeningCell: pListener Null"); +/*N*/ USHORT nTab = rAddress.Tab(); +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->StartListening( rAddress, pListener ); +/*N*/ } + +/*N*/ void ScDocument::EndListeningCell( const ScAddress& rAddress, +/*N*/ SfxListener* pListener ) +/*N*/ { +/*N*/ DBG_ASSERT(pListener, "EndListeningCell: pListener Null"); +/*N*/ USHORT nTab = rAddress.Tab(); +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->EndListening( rAddress, pListener ); +/*N*/ } + + +/*N*/ void ScDocument::PutInFormulaTree( ScFormulaCell* pCell ) +/*N*/ { +/*N*/ DBG_ASSERT( pCell, "PutInFormulaTree: pCell Null" ); +/*N*/ RemoveFromFormulaTree( pCell ); +/*N*/ // anhaengen +/*N*/ if ( pEOFormulaTree ) +/*N*/ pEOFormulaTree->SetNext( pCell ); +/*N*/ else +/*N*/ pFormulaTree = pCell; // kein Ende, kein Anfang.. +/*N*/ pCell->SetPrevious( pEOFormulaTree ); +/*N*/ pCell->SetNext( 0 ); +/*N*/ pEOFormulaTree = pCell; +/*N*/ nFormulaCodeInTree += pCell->GetCode()->GetCodeLen(); +/*N*/ } + + +/*N*/ void ScDocument::RemoveFromFormulaTree( ScFormulaCell* pCell ) +/*N*/ { +/*N*/ DBG_ASSERT( pCell, "RemoveFromFormulaTree: pCell Null" ); +/*N*/ ScFormulaCell* pPrev = pCell->GetPrevious(); +/*N*/ // wenn die Zelle die erste oder sonstwo ist +/*N*/ if ( pPrev || pFormulaTree == pCell ) +/*N*/ { +/*N*/ ScFormulaCell* pNext = pCell->GetNext(); +/*N*/ if ( pPrev ) +/*N*/ pPrev->SetNext( pNext ); // gibt Vorlaeufer +/*N*/ else +/*N*/ pFormulaTree = pNext; // ist erste Zelle +/*N*/ if ( pNext ) +/*N*/ pNext->SetPrevious( pPrev ); // gibt Nachfolger +/*N*/ else +/*N*/ pEOFormulaTree = pPrev; // ist letzte Zelle +/*N*/ pCell->SetPrevious( 0 ); +/*N*/ pCell->SetNext( 0 ); +/*N*/ USHORT nRPN = pCell->GetCode()->GetCodeLen(); +/*N*/ if ( nFormulaCodeInTree >= nRPN ) +/*N*/ nFormulaCodeInTree -= nRPN; +/*N*/ else +/*N*/ { +/*N*/ DBG_ERRORFILE( "RemoveFromFormulaTree: nFormulaCodeInTree < nRPN" ); +/*N*/ nFormulaCodeInTree = 0; +/*N*/ } +/*N*/ } +/*N*/ else if ( !pFormulaTree && nFormulaCodeInTree ) +/*N*/ { +/*?*/ DBG_ERRORFILE( "!pFormulaTree && nFormulaCodeInTree != 0" ); +/*?*/ nFormulaCodeInTree = 0; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::IsInFormulaTree( ScFormulaCell* pCell ) const +/*N*/ { +/*N*/ return pCell->GetPrevious() || pFormulaTree == pCell; +/*N*/ } + + + + +/*N*/ void ScDocument::ClearFormulaTree() +/*N*/ { +/*N*/ ScFormulaCell* pCell; +/*N*/ ScFormulaCell* pTree = pFormulaTree; +/*N*/ while ( pTree ) +/*N*/ { +/*N*/ pCell = pTree; +/*N*/ pTree = pCell->GetNext(); +/*N*/ if ( !pCell->GetCode()->IsRecalcModeAlways() ) +/*N*/ RemoveFromFormulaTree( pCell ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::AppendToFormulaTrack( ScFormulaCell* pCell ) +/*N*/ { +/*N*/ DBG_ASSERT( pCell, "AppendToFormulaTrack: pCell Null" ); +/*N*/ // Zelle kann nicht in beiden Listen gleichzeitig sein +/*N*/ RemoveFromFormulaTrack( pCell ); +/*N*/ RemoveFromFormulaTree( pCell ); +/*N*/ if ( pEOFormulaTrack ) +/*N*/ pEOFormulaTrack->SetNextTrack( pCell ); +/*N*/ else +/*N*/ pFormulaTrack = pCell; // kein Ende, kein Anfang.. +/*N*/ pCell->SetPreviousTrack( pEOFormulaTrack ); +/*N*/ pCell->SetNextTrack( 0 ); +/*N*/ pEOFormulaTrack = pCell; +/*N*/ ++nFormulaTrackCount; +/*N*/ } + + +/*N*/ void ScDocument::RemoveFromFormulaTrack( ScFormulaCell* pCell ) +/*N*/ { +/*N*/ DBG_ASSERT( pCell, "RemoveFromFormulaTrack: pCell Null" ); +/*N*/ ScFormulaCell* pPrev = pCell->GetPreviousTrack(); +/*N*/ // wenn die Zelle die erste oder sonstwo ist +/*N*/ if ( pPrev || pFormulaTrack == pCell ) +/*N*/ { +/*N*/ ScFormulaCell* pNext = pCell->GetNextTrack(); +/*N*/ if ( pPrev ) +/*?*/ pPrev->SetNextTrack( pNext ); // gibt Vorlaeufer +/*N*/ else +/*N*/ pFormulaTrack = pNext; // ist erste Zelle +/*N*/ if ( pNext ) +/*N*/ pNext->SetPreviousTrack( pPrev ); // gibt Nachfolger +/*N*/ else +/*N*/ pEOFormulaTrack = pPrev; // ist letzte Zelle +/*N*/ pCell->SetPreviousTrack( 0 ); +/*N*/ pCell->SetNextTrack( 0 ); +/*N*/ --nFormulaTrackCount; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::IsInFormulaTrack( ScFormulaCell* pCell ) const +/*N*/ { +/*N*/ return pCell->GetPreviousTrack() || pFormulaTrack == pCell; +/*N*/ } + + +/* + Der erste wird gebroadcastet, + die dadurch entstehenden werden durch das Notify an den Track gehaengt. + Der nachfolgende broadcastet wieder usw. + View stoesst Interpret an. + */ +/*N*/ void ScDocument::TrackFormulas( ULONG nHintId ) +/*N*/ { +/*N*/ +/*N*/ if ( pFormulaTrack ) +/*N*/ { +///*N*/ BOOL bWasWaiting = Application::IsWait(); +///*N*/ if ( !bWasWaiting ) +///*N*/ Application::EnterWait(); +/*N*/ erBEEPER(); +/*N*/ ScBroadcasterList* pBC; +/*N*/ ScFormulaCell* pTrack; +/*N*/ ScFormulaCell* pNext; +/*N*/ BOOL bIsChanged = TRUE; +/*N*/ pTrack = pFormulaTrack; +/*N*/ do +/*N*/ { +/*N*/ ScHint aHint( nHintId, pTrack->aPos, pTrack ); +/*N*/ if ( pBC = pTrack->GetBroadcaster() ) +/*N*/ pBC->Broadcast( aHint ); +/*N*/ pBASM->AreaBroadcast( aHint ); +/*N*/ // Repaint fuer bedingte Formate mit relativen Referenzen: +/*N*/ if ( pCondFormList ) +/*N*/ pCondFormList->SourceChanged( pTrack->aPos ); +/*N*/ pTrack = pTrack->GetNextTrack(); +/*N*/ } while ( pTrack ); +/*N*/ pTrack = pFormulaTrack; +/*N*/ BOOL bHaveForced = FALSE; +/*N*/ do +/*N*/ { +/*N*/ pNext = pTrack->GetNextTrack(); +/*N*/ RemoveFromFormulaTrack( pTrack ); +/*N*/ PutInFormulaTree( pTrack ); +/*N*/ if ( pTrack->GetCode()->IsRecalcModeForced() ) +/*N*/ bHaveForced = TRUE; +/*N*/ pTrack = pNext; +/*N*/ } while ( pTrack ); +/*N*/ if ( bHaveForced ) +/*N*/ { +/*?*/ SetForcedFormulas( TRUE ); +/*?*/ if ( bAutoCalc && !IsAutoCalcShellDisabled() && !IsInInterpreter() +/*?*/ && !IsCalculatingFormulaTree() ) +{DBG_BF_ASSERT(0, "STRIP"); }//STRIP001 /*?*/ CalcFormulaTree( TRUE ); +/*?*/ else +/*?*/ SetForcedFormulaPending( TRUE ); +/*N*/ } +///*N*/ if ( !bWasWaiting ) +///*N*/ Application::LeaveWait(); +/*N*/ } +/*N*/ DBG_ASSERT( nFormulaTrackCount==0, "TrackFormulas: nFormulaTrackCount!=0" ); +/*N*/ } + + +/*N*/ void ScDocument::StartAllListeners() +/*N*/ { +/*N*/ for ( USHORT i = 0; i <= MAXTAB; ++i ) +/*N*/ if ( pTab[i] ) +/*N*/ pTab[i]->StartAllListeners(); +/*N*/ } + +/*N*/ void ScDocument::UpdateBroadcastAreas( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz +/*N*/ ) +/*N*/ { +/*N*/ BOOL bExpandRefsOld = IsExpandRefs(); +/*N*/ if ( eUpdateRefMode == URM_INSDEL && (nDx > 0 || nDy > 0 || nDz > 0) ) +/*N*/ SetExpandRefs( SC_MOD()->GetInputOptions().GetExpandRefs() ); +/*N*/ SetExpandRefs( bExpandRefsOld ); +/*N*/ } + +/*N*/ void ScDocument::SetAutoCalc( BOOL bNewAutoCalc ) +/*N*/ { +/*N*/ BOOL bOld = bAutoCalc; +/*N*/ bAutoCalc = bNewAutoCalc; +/*N*/ if ( !bOld && bNewAutoCalc && bHasForcedFormulas ) +/*N*/ { +/*?*/ if ( IsAutoCalcShellDisabled() ) +/*?*/ SetForcedFormulaPending( TRUE ); +/*?*/ else if ( !IsInInterpreter() ) +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ CalcFormulaTree( TRUE ); +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen8.cxx b/binfilter/bf_sc/source/core/data/sc_documen8.cxx new file mode 100644 index 000000000000..918fea3fd13b --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen8.cxx @@ -0,0 +1,648 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "scitems.hxx" +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/langitem.hxx> +#include <bf_svx/linkmgr.hxx> +#include <bf_sfx2/printer.hxx> +#include <bf_svtools/flagitem.hxx> +#define _SVSTDARR_USHORTS +#include <bf_svtools/zformat.hxx> +#include <bf_sfx2/misccfg.hxx> +#include <bf_sfx2/app.hxx> + + +#include "poolhelp.hxx" +#include "docpool.hxx" +#include "stlpool.hxx" +#include "docoptio.hxx" +#include "viewopti.hxx" +#include "rechead.hxx" +#include "ddelink.hxx" +#include "scmatrix.hxx" +#include "arealink.hxx" +#include "patattr.hxx" +#include "editutil.hxx" +#include "document.hxx" +#include "refupdat.hxx" +#include "scmod.hxx" +#include "globstr.hrc" +#include "bf_sc.hrc" +namespace binfilter { + +#define GET_SCALEVALUE(set,id) ((const SfxUInt16Item&)(set.Get( id ))).GetValue() + +// states for online spelling in the visible range (0 is set initially) +#define VSPL_START 0 +#define VSPL_DONE 1 + + +// STATIC DATA ----------------------------------------------------------- + + + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::ImplLoadDocOptions( SvStream& rStream ) +/*N*/ { +/*N*/ USHORT d,m,y; +/*N*/ +/*N*/ DBG_ASSERT( pDocOptions, "No DocOptions to load! :-(" ); +/*N*/ +/*N*/ pDocOptions->Load( rStream ); +/*N*/ +/*N*/ if ( pDocOptions->GetStdPrecision() > 20 ) //!!! ist 20 als Maximum konstant ??? +/*N*/ { +/*?*/ DBG_ERROR( "Document options corrupted. Setting to defaults." ); +/*?*/ pDocOptions->ResetDocOptions(); +/*N*/ } +/*N*/ +/*N*/ pDocOptions->GetDate( d,m,y ); +/*N*/ SvNumberFormatter* pFormatter = xPoolHelper->GetFormTable(); +/*N*/ pFormatter->ChangeNullDate( d,m,y ); +/*N*/ pFormatter->ChangeStandardPrec( pDocOptions->GetStdPrecision() ); +/*N*/ pFormatter->SetYear2000( pDocOptions->GetYear2000() ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::ImplLoadViewOptions( SvStream& rStream ) +/*N*/ { +/*N*/ DBG_ASSERT( pViewOptions, "No ViewOptions to load! :-(" ); +/*N*/ rStream >> *pViewOptions; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::ImplSaveDocOptions( SvStream& rStream ) const +/*N*/ { +/*N*/ DBG_ASSERT( pDocOptions, "No DocOptions to save! :-(" ); +/*N*/ pDocOptions->Save( rStream ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::ImplSaveViewOptions( SvStream& rStream ) const +/*N*/ { +/*N*/ DBG_ASSERT( pViewOptions, "No ViewOptions to save! :-(" ); +/*N*/ rStream << *pViewOptions; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::ImplCreateOptions() +/*N*/ { +/*N*/ pDocOptions = new ScDocOptions(); +/*N*/ pViewOptions = new ScViewOptions(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::ImplDeleteOptions() +/*N*/ { +/*N*/ delete pDocOptions; +/*N*/ delete pViewOptions; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPrinter* ScDocument::GetPrinter() +/*N*/ { +/*N*/ if ( !pPrinter ) +/*N*/ { +/*N*/ SfxItemSet* pSet = +/*N*/ new SfxItemSet( *xPoolHelper->GetDocPool(), +/*N*/ SID_PRINTER_NOTFOUND_WARN, SID_PRINTER_NOTFOUND_WARN, +/*N*/ SID_PRINTER_CHANGESTODOC, SID_PRINTER_CHANGESTODOC, +/*N*/ SID_SCPRINTOPTIONS, SID_SCPRINTOPTIONS, +/*N*/ NULL ); +/*N*/ +/*N*/ SfxMiscCfg* pOffCfg = SFX_APP()->GetMiscConfig(); +/*N*/ if ( pOffCfg ) +/*N*/ { +/*N*/ USHORT nFlags = 0; +/*N*/ if ( pOffCfg->IsPaperOrientationWarning() ) +/*N*/ nFlags |= SFX_PRINTER_CHG_ORIENTATION; +/*N*/ if ( pOffCfg->IsPaperSizeWarning() ) +/*N*/ nFlags |= SFX_PRINTER_CHG_SIZE; +/*N*/ pSet->Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC, nFlags ) ); +/*N*/ pSet->Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, pOffCfg->IsNotFoundWarning() ) ); +/*N*/ } +/*N*/ +/*N*/ pPrinter = new SfxPrinter( pSet ); +/*N*/ UpdateDrawPrinter(); +/*N*/ pPrinter->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() ); +/*N*/ } +/*N*/ +/*N*/ return pPrinter; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::SetPrinter( SfxPrinter* pNewPrinter ) +/*N*/ { +/*N*/ if ( pNewPrinter == pPrinter ) +/*N*/ { +/*N*/ // #i6706# SetPrinter is called with the same printer again if +/*N*/ // the JobSetup has changed. In that case just call UpdateDrawPrinter +/*N*/ // (SetRefDevice for drawing layer) because of changed text sizes. +/*N*/ UpdateDrawPrinter(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SfxPrinter* pOld = pPrinter; +/*N*/ pPrinter = pNewPrinter; +/*N*/ UpdateDrawPrinter(); +/*N*/ pPrinter->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() ); +/*N*/ delete pOld; +/*N*/ } +/*N*/ InvalidateTextWidth(); // in both cases +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::SetPrintOptions() +/*N*/ { +/*N*/ if ( !pPrinter ) GetPrinter(); // setzt pPrinter +/*N*/ DBG_ASSERT( pPrinter, "Error in printer creation :-/" ); +/*N*/ +/*N*/ if ( pPrinter ) +/*N*/ { +/*N*/ SfxMiscCfg* pOffCfg = SFX_APP()->GetMiscConfig(); +/*N*/ if ( pOffCfg ) +/*N*/ { +/*N*/ SfxItemSet aOptSet( pPrinter->GetOptions() ); +/*N*/ +/*N*/ USHORT nFlags = 0; +/*N*/ if ( pOffCfg->IsPaperOrientationWarning() ) +/*N*/ nFlags |= SFX_PRINTER_CHG_ORIENTATION; +/*N*/ if ( pOffCfg->IsPaperSizeWarning() ) +/*N*/ nFlags |= SFX_PRINTER_CHG_SIZE; +/*N*/ aOptSet.Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC, nFlags ) ); +/*N*/ aOptSet.Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, pOffCfg->IsNotFoundWarning() ) ); +/*N*/ +/*N*/ pPrinter->SetOptions( aOptSet ); +/*N*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScDocument::RemovePageStyleInUse( const String& rStyle ) +/*N*/ { +/*N*/ BOOL bWasInUse = FALSE; +/*N*/ const USHORT nCount = GetTableCount(); +/*N*/ +/*N*/ for ( USHORT i=0; i<nCount && pTab[i]; i++ ) +/*N*/ if ( pTab[i]->GetPageStyle() == rStyle ) +/*N*/ { +/*N*/ bWasInUse = TRUE; +/*N*/ pTab[i]->SetPageStyle( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ); +/*N*/ } +/*N*/ +/*N*/ return bWasInUse; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*M*/ BYTE ScDocument::GetEditTextDirection(USHORT nTab) const +/*M*/ { +/*M*/ EEHorizontalTextDirection eRet = EE_HTEXTDIR_DEFAULT; +/*M*/ +/*M*/ String aStyleName = GetPageStyle( nTab ); +/*M*/ SfxStyleSheetBase* pStyle = xPoolHelper->GetStylePool()->Find( aStyleName, SFX_STYLE_FAMILY_PAGE ); +/*M*/ if ( pStyle ) +/*M*/ { +/*M*/ SfxItemSet& rStyleSet = pStyle->GetItemSet(); +/*M*/ SvxFrameDirection eDirection = (SvxFrameDirection) +/*M*/ ((const SvxFrameDirectionItem&)rStyleSet.Get( ATTR_WRITINGDIR )).GetValue(); +/*M*/ +/*M*/ if ( eDirection == FRMDIR_HORI_LEFT_TOP ) +/*M*/ eRet = EE_HTEXTDIR_L2R; +/*M*/ else if ( eDirection == FRMDIR_HORI_RIGHT_TOP ) +/*M*/ eRet = EE_HTEXTDIR_R2L; +/*M*/ // else (invalid for EditEngine): keep "default" +/*M*/ } +/*M*/ +/*M*/ return eRet; +/*M*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::InvalidateTextWidth( const ScAddress* pAdrFrom, +/*N*/ const ScAddress* pAdrTo, +/*N*/ BOOL bBroadcast ) +/*N*/ { +/*N*/ bBroadcast = (bBroadcast && GetDocOptions().IsCalcAsShown() && !IsImportingXML()); +/*N*/ if ( pAdrFrom && !pAdrTo ) +/*N*/ { +/*?*/ const USHORT nTab = pAdrFrom->Tab(); +/*?*/ +/*?*/ if ( pTab[nTab] ) +/*?*/ pTab[nTab]->InvalidateTextWidth( pAdrFrom, NULL, bBroadcast ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ const USHORT nTabStart = pAdrFrom ? pAdrFrom->Tab() : 0; +/*N*/ const USHORT nTabEnd = pAdrTo ? pAdrTo->Tab() : MAXTAB; +/*N*/ +/*N*/ for ( USHORT nTab=nTabStart; nTab<=nTabEnd; nTab++ ) +/*N*/ if ( pTab[nTab] ) +/*N*/ pTab[nTab]->InvalidateTextWidth( pAdrFrom, pAdrTo, bBroadcast ); +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +#define CALCMAX 1000 // Berechnungen +#define ABORT_EVENTS (INPUT_ANY & ~INPUT_TIMER & ~INPUT_OTHER) + +//------------------------------------------------------------------------ + + +// SPELL_MAXCELLS muss mindestens 256 sein, solange am Iterator keine +// Start-Spalte gesetzt werden kann + +//! SPELL_MAXTEST fuer Timer und Idle unterschiedlich ??? + +// SPELL_MAXTEST now divided between visible and rest of document + +#define SPELL_MAXTEST_VIS 1 +#define SPELL_MAXTEST_ALL 3 +#define SPELL_MAXCELLS 256 + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::SaveDdeLinks(SvStream& rStream) const +/*N*/ { +/*N*/ // bei 4.0-Export alle mit Modus != DEFAULT weglassen +/*N*/ BOOL bExport40 = ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_40 ); +/*N*/ +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ +/*N*/ // erstmal zaehlen... +/*N*/ +/*N*/ USHORT nDdeCount = 0; +/*N*/ USHORT i; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*N*/ if (pBase->ISA(ScDdeLink)) +/*?*/ if ( !bExport40 || ((ScDdeLink*)pBase)->GetMode() == SC_DDE_DEFAULT ) +/*?*/ ++nDdeCount; +/*N*/ } +/*N*/ +/*N*/ // Header +/*N*/ +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ rStream << nDdeCount; +/*N*/ +/*N*/ // Links speichern +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*N*/ if (pBase->ISA(ScDdeLink)) +/*N*/ { +/*?*/ ScDdeLink* pLink = (ScDdeLink*)pBase; +/*?*/ if ( !bExport40 || pLink->GetMode() == SC_DDE_DEFAULT ) +/*?*/ pLink->Store( rStream, aHdr ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::LoadDdeLinks(SvStream& rStream) +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nCount; +/*N*/ rStream >> nCount; +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*?*/ ScDdeLink* pLink = new ScDdeLink( this, rStream, aHdr ); +/*?*/ pLinkManager->InsertDDELink( pLink, +/*?*/ pLink->GetAppl(), pLink->GetTopic(), pLink->GetItem() ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::SetInLinkUpdate(BOOL bSet) +/*N*/ { +/*N*/ // called from TableLink and AreaLink +/*N*/ +/*N*/ DBG_ASSERT( bInLinkUpdate != bSet, "SetInLinkUpdate twice" ); +/*N*/ bInLinkUpdate = bSet; +/*N*/ } + + +/*N*/ BOOL ScDocument::UpdateDdeLink( const String& rAppl, const String& rTopic, const String& rItem ) +/*N*/ { +/*N*/ // fuer refresh() per StarOne Api +/*N*/ // ResetValue() fuer einzelnen Link nicht noetig +/*N*/ //! wenn's mal alles asynchron wird, aber auch hier +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ if (pLinkManager) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ } +/*N*/ return bFound; +/*N*/ } + + + +/*N*/ USHORT ScDocument::GetDdeLinkCount() const +/*N*/ { +/*N*/ USHORT nDdeCount = 0; +/*N*/ if (pLinkManager) +/*N*/ { +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ if ((*rLinks[i])->ISA(ScDdeLink)) +/*N*/ ++nDdeCount; +/*N*/ } +/*N*/ return nDdeCount; +/*N*/ } + +/*N*/ BOOL ScDocument::GetDdeLinkData( USHORT nPos, String& rAppl, String& rTopic, String& rItem ) const +/*N*/ { +/*N*/ USHORT nDdeCount = 0; +/*N*/ if (pLinkManager) +/*N*/ { +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*N*/ if (pBase->ISA(ScDdeLink)) +/*N*/ { +/*N*/ if ( nDdeCount == nPos ) +/*N*/ { +/*N*/ ScDdeLink* pDde = (ScDdeLink*)pBase; +/*N*/ rAppl = pDde->GetAppl(); +/*N*/ rTopic = pDde->GetTopic(); +/*N*/ rItem = pDde->GetItem(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ ++nDdeCount; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::GetDdeLinkMode(USHORT nPos, USHORT& nMode) +/*N*/ { +/*N*/ USHORT nDdeCount = 0; +/*N*/ if (pLinkManager) +/*N*/ { +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*N*/ if (pBase->ISA(ScDdeLink)) +/*N*/ { +/*N*/ if ( nDdeCount == nPos ) +/*N*/ { +/*N*/ ScDdeLink* pDde = (ScDdeLink*)pBase; +/*N*/ nMode = pDde->GetMode(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ ++nDdeCount; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::GetDdeLinkResultDimension( USHORT nPos, USHORT& nCol, USHORT& nRow, ScMatrix*& pMatrix) +/*N*/ { +/*N*/ USHORT nDdeCount = 0; +/*N*/ if (pLinkManager) +/*N*/ { +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*N*/ if (pBase->ISA(ScDdeLink)) +/*N*/ { +/*N*/ if ( nDdeCount == nPos ) +/*N*/ { +/*N*/ ScDdeLink* pDde = (ScDdeLink*)pBase; +/*N*/ pMatrix = pDde->GetResult(); +/*N*/ if (pMatrix) +/*N*/ { +/*N*/ pMatrix->GetDimensions(nCol, nRow); +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ ++nDdeCount; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::GetDdeLinkResult(const ScMatrix* pMatrix, USHORT nCol, USHORT nRow, String& rStrValue, double& rDoubValue, BOOL& bIsString) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (pMatrix) +/*N*/ return TRUE; +/*N*/ } + +/*N*/ void ScDocument::CreateDdeLink(const String& rAppl, const String& rTopic, const String& rItem, const BYTE nMode ) +/*N*/ { + // DDE-Link anlegen und nicht updaten (z.B. fuer Excel-Import, +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 // damit nicht ohne Nachfrage Verbindungen aufgebaut werden) +/*N*/ } + +/*N*/ BOOL ScDocument::FindDdeLink(const String& rAppl, const String& rTopic, const String& rItem, const BYTE nMode, USHORT& nPos ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (pLinkManager) +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDocument::CreateDdeLinkResultDimension(USHORT nPos, USHORT nCols, USHORT nRows, ScMatrix*& pMatrix) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 USHORT nDdeCount = 0; +/*N*/ return FALSE; +/*N*/ } + +void ScDocument::SetDdeLinkResult(ScMatrix* pMatrix, const USHORT nCol, const USHORT nRow, const String& rStrValue, const double& rDoubValue, BOOL bString, BOOL bEmpty) +{ +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 DBG_ASSERT(pMatrix, "there is no matrix"); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocument::UpdateRefAreaLinks( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ if (pLinkManager) +/*N*/ { +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*?*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*?*/ if (pBase->ISA(ScAreaLink)) +/*?*/ { +/*?*/ ScAreaLink* pLink = (ScAreaLink*) pBase; +/*?*/ ScRange aOutRange = pLink->GetDestArea(); +/*?*/ +/*?*/ USHORT nCol1 = aOutRange.aStart.Col(); +/*?*/ USHORT nRow1 = aOutRange.aStart.Row(); +/*?*/ USHORT nTab1 = aOutRange.aStart.Tab(); +/*?*/ USHORT nCol2 = aOutRange.aEnd.Col(); +/*?*/ USHORT nRow2 = aOutRange.aEnd.Row(); +/*?*/ USHORT nTab2 = aOutRange.aEnd.Tab(); +/*?*/ +/*?*/ ScRefUpdateRes eRes = +/*?*/ ScRefUpdate::Update( this, eUpdateRefMode, +/*?*/ rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(), +/*?*/ rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), nDx, nDy, nDz, +/*?*/ nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*?*/ if ( eRes != UR_NOTHING ) +/*?*/ pLink->SetDestArea( ScRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ) ); +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::SaveAreaLinks(SvStream& rStream) const +/*N*/ { +/*N*/ const ::binfilter::SvBaseLinks& rLinks = pLinkManager->GetLinks(); +/*N*/ USHORT nCount = rLinks.Count(); +/*N*/ +/*N*/ // erstmal zaehlen... +/*N*/ +/*N*/ USHORT nAreaCount = 0; +/*N*/ USHORT i; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ((*rLinks[i])->ISA(ScAreaLink)) // rLinks[i] = Pointer auf Ref +/*N*/ ++nAreaCount; +/*N*/ +/*N*/ // Header +/*N*/ +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ rStream << nAreaCount; +/*N*/ +/*N*/ // Links speichern +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ ::binfilter::SvBaseLink* pBase = *rLinks[i]; +/*N*/ if (pBase->ISA(ScAreaLink)) +/*N*/ { +/*?*/ ScAreaLink* pLink = (ScAreaLink*)pBase; +/*?*/ +/*?*/ aHdr.StartEntry(); +/*?*/ +/*?*/ rStream.WriteByteString( pLink->GetFile(), rStream.GetStreamCharSet() ); +/*?*/ rStream.WriteByteString( pLink->GetFilter(), rStream.GetStreamCharSet() ); +/*?*/ rStream.WriteByteString( pLink->GetSource(), rStream.GetStreamCharSet() ); +/*?*/ rStream << pLink->GetDestArea(); // ScRange +/*?*/ rStream.WriteByteString( pLink->GetOptions(), rStream.GetStreamCharSet() ); +/*?*/ // filter options starting from 336 +/*?*/ +/*?*/ aHdr.EndEntry(); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::LoadAreaLinks(SvStream& rStream) +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ if (!pShell) +/*N*/ { +/*N*/ DBG_ERROR("AreaLinks koennen nicht ohne Shell geladen werden"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ String aFile, aFilter, aOptions, aSource; +/*N*/ ScRange aDestArea; +/*N*/ +/*N*/ USHORT nCount; +/*N*/ rStream >> nCount; +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 aHdr.StartEntry(); +/*?*/ +/*N*/ } +/*N*/ } + + +//------------------------------------------------------------------------ + +// TimerDelays etc. + +// ---------------------------------------------------------------------------- + +/*N*/ BOOL ScDocument::CheckMacroWarn() +/*N*/ { +/*N*/ // The check for macro configuration, macro warning and disabling is now handled +/*N*/ // in SfxObjectShell::AdjustMacroMode, called by SfxObjectShell::CallBasic. +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + + +//------------------------------------------------------------------------ + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_documen9.cxx b/binfilter/bf_sc/source/core/data/sc_documen9.cxx new file mode 100644 index 000000000000..0a2bdfffaf95 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_documen9.cxx @@ -0,0 +1,531 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svx/eeitem.hxx> +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/fontitem.hxx> +#include <bf_svx/forbiddencharacterstable.hxx> +#include <bf_svx/langitem.hxx> +#include <bf_svx/svditer.hxx> +#include <bf_svx/svdocapt.hxx> +#include <bf_svx/svdoole2.hxx> +#include <bf_svx/svdouno.hxx> +#include <bf_svx/svdpage.hxx> +#include <bf_svx/xtable.hxx> +#include <bf_sfx2/objsh.hxx> +#include <bf_sfx2/printer.hxx> +#include <bf_svtools/saveopt.hxx> +#include <bf_svtools/pathoptions.hxx> +#include <bf_sch/schdll.hxx> +#include <bf_sch/schdll0.hxx> + +#include "document.hxx" +#include "docoptio.hxx" +#include "drwlayer.hxx" +#include "userdat.hxx" +#include "patattr.hxx" +#include "rechead.hxx" +#include "poolhelp.hxx" +#include "docpool.hxx" +#include "detfunc.hxx" // for UpdateAllComments +#include "editutil.hxx" +namespace binfilter { + + +// ----------------------------------------------------------------------- + +/*N*/ XColorTable* ScDocument::GetColorTable() +/*N*/ { +/*N*/ if (pDrawLayer) +/*N*/ return pDrawLayer->GetColorTable(); +/*N*/ else +/*N*/ { +/*N*/ if (!pColorTable) +/*N*/ { +/*N*/ SvtPathOptions aPathOpt; +/*N*/ pColorTable = new XColorTable( aPathOpt.GetPalettePath() ); +/*N*/ } +/*N*/ +/*N*/ return pColorTable; +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::TransferDrawPage(ScDocument* pSrcDoc, USHORT nSrcPos, USHORT nDestPos) +/*N*/ { +/*N*/ if (pDrawLayer && pSrcDoc->pDrawLayer) +/*N*/ { +/*?*/ SdrPage* pOldPage = pSrcDoc->pDrawLayer->GetPage(nSrcPos); +/*?*/ SdrPage* pNewPage = pDrawLayer->GetPage(nDestPos); +/*?*/ +/*?*/ if (pOldPage && pNewPage) +/*?*/ { +/*?*/ SdrObjListIter aIter( *pOldPage, IM_FLAT ); +/*?*/ SdrObject* pOldObject = aIter.Next(); +/*?*/ while (pOldObject) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::InitDrawLayer( SfxObjectShell* pDocShell ) +/*N*/ { +/*N*/ if (pDocShell && !pShell) +/*N*/ pShell = pDocShell; +/*N*/ +/*N*/ // DBG_ASSERT(pShell,"InitDrawLayer ohne Shell"); +/*N*/ +/*N*/ if (!pDrawLayer) +/*N*/ { +/*N*/ String aName; +/*N*/ if ( pShell && !pShell->IsLoading() ) // #88438# don't call GetTitle while loading +/*N*/ aName = pShell->GetTitle(); +/*N*/ pDrawLayer = new ScDrawLayer( this, aName ); +/*N*/ if (pLinkManager) +/*N*/ pDrawLayer->SetLinkManager( pLinkManager ); +/*N*/ +/*N*/ // Drawing pages are accessed by table number, so they must also be present +/*N*/ // for preceding table numbers, even if the tables aren't allocated +/*N*/ // (important for clipboard documents). +/*N*/ +/*N*/ USHORT nDrawPages = 0; +/*N*/ USHORT nTab; +/*N*/ for (nTab=0; nTab<=MAXTAB; nTab++) +/*N*/ if (pTab[nTab]) +/*N*/ nDrawPages = nTab + 1; // needed number of pages +/*N*/ +/*N*/ for (nTab=0; nTab<nDrawPages; nTab++) +/*N*/ { +/*N*/ pDrawLayer->ScAddPage( nTab ); // always add page, with or without the table +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ String aName; +/*N*/ pTab[nTab]->GetName(aName); +/*N*/ pDrawLayer->ScRenamePage( nTab, aName ); +/*N*/ +/*N*/ pTab[nTab]->SetDrawPageSize(); // #54782# sofort die richtige Groesse +/*N*/ #if 0 +/*N*/ ULONG nx = (ULONG) ((double) (MAXCOL+1) * STD_COL_WIDTH * HMM_PER_TWIPS ); +/*N*/ ULONG ny = (ULONG) ((double) (MAXROW+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS ); +/*N*/ pDrawLayer->SetPageSize( nTab, Size( nx, ny ) ); +/*N*/ #endif +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pDrawLayer->SetDefaultTabulator( GetDocOptions().GetTabDistance() ); +/*N*/ +/*N*/ UpdateDrawPrinter(); +/*N*/ UpdateDrawLanguages(); +/*N*/ if (bImportingXML) +/*?*/ pDrawLayer->EnableAdjust(FALSE); +/*N*/ +/*N*/ pDrawLayer->SetForbiddenCharsTable( xForbiddenCharacters ); +/*N*/ pDrawLayer->SetCharCompressType( GetAsianCompression() ); +/*N*/ pDrawLayer->SetKernAsianPunctuation( GetAsianKerning() ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::UpdateDrawLanguages() +/*N*/ { +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ SfxItemPool& rDrawPool = pDrawLayer->GetItemPool(); +/*N*/ rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eLanguage, EE_CHAR_LANGUAGE ) ); +/*N*/ rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eCjkLanguage, EE_CHAR_LANGUAGE_CJK ) ); +/*N*/ rDrawPool.SetPoolDefaultItem( SvxLanguageItem( eCtlLanguage, EE_CHAR_LANGUAGE_CTL ) ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::UpdateDrawPrinter() +/*N*/ { +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ // use the printer even if IsValid is false +/*N*/ // Application::GetDefaultDevice causes trouble with changing MapModes +/*N*/ +/*N*/ OutputDevice* pRefDev = GetPrinter(); +/*N*/ pRefDev->SetMapMode( MAP_100TH_MM ); +/*N*/ pDrawLayer->SetRefDevice(pRefDev); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDocument::IsChart( SdrObject* pObject ) +/*N*/ { +/*N*/ if ( pObject->GetObjIdentifier() == OBJ_OLE2 ) +/*N*/ { +/*N*/ SvInPlaceObjectRef aIPObj = ((SdrOle2Obj*)pObject)->GetObjRef(); +/*N*/ if (aIPObj.Is()) +/*N*/ { +/*N*/ SvGlobalName aObjClsId = *aIPObj->GetSvFactory(); +/*N*/ if (SchModuleDummy::HasID( aObjClsId )) +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ IMPL_LINK_INLINE_START( ScDocument, GetUserDefinedColor, USHORT *, pColorIndex ) +/*N*/ { +/*N*/ return (long) &((GetColorTable()->Get(*pColorIndex))->GetColor()); +/*N*/ } +/*N*/ IMPL_LINK_INLINE_END( ScDocument, GetUserDefinedColor, USHORT *, pColorIndex ) + +/*N*/ void ScDocument::DeleteDrawLayer() +/*N*/ { +/*N*/ delete pDrawLayer; +/*N*/ } + +/*N*/ void ScDocument::DeleteColorTable() +/*N*/ { +/*N*/ delete pColorTable; +/*N*/ } + +/*N*/ void ScDocument::LoadDrawLayer(SvStream& rStream) +/*N*/ { +/*N*/ InitDrawLayer(); // anlegen +/*N*/ pDrawLayer->Load(rStream); +/*N*/ +/*N*/ // nMaxTableNumber ist noch nicht initialisiert +/*N*/ +/*N*/ USHORT nTableCount = 0; +/*N*/ while ( nTableCount <= MAXTAB && pTab[nTableCount] ) +/*N*/ ++nTableCount; +/*N*/ +/*N*/ USHORT nPageCount = pDrawLayer->GetPageCount(); +/*N*/ if ( nPageCount > nTableCount && nTableCount != 0 ) +/*N*/ { +/*?*/ // Manchmal sind beim Kopieren/Verschieben/Undo von Tabellen zuviele +/*?*/ // (leere) Pages in der Tabelle stehengeblieben. Weg damit! +/*?*/ +/*?*/ DBG_ERROR("zuviele Draw-Pages in der Datei"); +/*?*/ +/*?*/ for (USHORT i=nTableCount; i<nPageCount; i++) +/*?*/ pDrawLayer->DeletePage(nTableCount); +/*N*/ } +/*N*/ +/*N*/ // Controls auf richtigen Layer setzen +/*N*/ // (zumindest in Dateien aus der 502 koennen sie falsch sein, +/*N*/ // wegen des fehlenden Layers in alten Dateien) +/*N*/ +/*N*/ nPageCount = pDrawLayer->GetPageCount(); +/*N*/ for (USHORT i=0; i<nPageCount; i++) +/*N*/ { +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(i); +/*N*/ SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->ISA(SdrUnoObj) && pObject->GetLayer() != SC_LAYER_CONTROLS ) +/*N*/ { +/*?*/ pObject->NbcSetLayer(SC_LAYER_CONTROLS); +/*?*/ DBG_ERROR("Control war auf falschem Layer"); +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::StoreDrawLayer(SvStream& rStream) const +/*N*/ { +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ // SetSavePortable wird mit VCL nicht mehr gebraucht +/*N*/ //BOOL bIndep = SFX_APP()->GetOptions().IsIndepGrfFmt(); +/*N*/ //pDrawLayer->SetSavePortable( bIndep ); +/*N*/ +/*N*/ pDrawLayer->SetSaveCompressed( FALSE ); +/*N*/ pDrawLayer->SetSaveNative( FALSE ); +/*N*/ +/*N*/ pDrawLayer->GetItemPool().SetFileFormatVersion( (USHORT)rStream.GetVersion() ); +/*N*/ pDrawLayer->Store(rStream); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDocument::DrawGetPrintArea( ScRange& rRange, BOOL bSetHor, BOOL bSetVer ) const +/*N*/ { +/*N*/ return pDrawLayer->GetPrintArea( rRange, bSetHor, bSetVer ); +/*N*/ } + + + + + + + + + + +/*N*/ BOOL ScDocument::HasNoteObject( USHORT nCol, USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if (!pDrawLayer) +/*N*/ return FALSE; +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (!pPage) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject && !bFound) +/*N*/ { +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN && pObject->ISA( SdrCaptionObj ) ) +/*N*/ { +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject ); +/*N*/ if ( pData && nCol == pData->aStt.nCol && nRow == pData->aStt.nRow ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + +/*N*/ void ScDocument::RefreshNoteFlags() +/*N*/ { +/*N*/ if (!pDrawLayer) +/*N*/ return; +/*N*/ +/*N*/ BOOL bAnyIntObj = FALSE; +/*N*/ USHORT nTab; +/*N*/ ScPostIt aNote; +/*N*/ for (nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++) +/*N*/ { +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (pPage) +/*N*/ { +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN ) +/*N*/ { +/*?*/ bAnyIntObj = TRUE; // for all internal objects, including detective +/*?*/ +/*?*/ if ( pObject->ISA( SdrCaptionObj ) ) +/*?*/ { +/*?*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject ); +/*?*/ if ( pData ) +/*?*/ { +/*?*/ if ( GetNote( pData->aStt.nCol, pData->aStt.nRow, nTab, aNote ) ) +/*?*/ if ( !aNote.IsShown() ) +/*?*/ { +/*?*/ aNote.SetShown(TRUE); +/*?*/ SetNote( pData->aStt.nCol, pData->aStt.nRow, nTab, aNote ); +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bAnyIntObj) +/*N*/ { +/*?*/ // update attributes for all note objects and the colors of detective objects +/*?*/ // (we don't know with which settings the file was created) +/*?*/ +/*N*/ ScDetectiveFunc aFunc( this, 0 ); // detective.sdc +/*N*/ /*?*/ aFunc.UpdateAllComments(); +/*N*/ /*?*/ aFunc.UpdateAllArrowColors(); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDocument::IsPrintEmpty( USHORT nTab, USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, BOOL bLeftIsEmpty, +/*N*/ ScRange* pLastRange, Rectangle* pLastMM ) const +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (!IsBlockEmpty( nTab, nStartCol, nStartRow, nEndCol, nEndRow )) +/*N*/ return TRUE; +/*N*/ } + +/*N*/ void ScDocument::Clear() +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ { +/*N*/ delete pTab[i]; +/*N*/ pTab[i]=NULL; +/*N*/ } +/*N*/ delete pSelectionAttr; +/*N*/ pSelectionAttr = NULL; +/*N*/ +/*N*/ if (pDrawLayer) +/*N*/ pDrawLayer->Clear(); +/*N*/ } + +/*N*/ BOOL ScDocument::HasDetectiveObjects(USHORT nTab) const +/*N*/ { +/*N*/ // looks for detective objects, annotations don't count +/*N*/ // (used to adjust scale so detective objects hit their cells better) +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ SdrPage* pPage = pDrawLayer->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (pPage) +/*N*/ { +/*N*/ SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject && !bFound) +/*N*/ { +/*N*/ // anything on the internal layer except captions (annotations) +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN && !pObject->ISA( SdrCaptionObj ) ) +/*N*/ bFound = TRUE; +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + +/*N*/ void ScDocument::UpdateFontCharSet() +/*N*/ { +/*N*/ // In alten Versionen (bis incl. 4.0 ohne SP) wurden beim Austausch zwischen +/*N*/ // Systemen die CharSets in den Font-Attributen nicht angepasst. +/*N*/ // Das muss fuer Dokumente bis incl SP2 nun nachgeholt werden: +/*N*/ // Alles, was nicht SYMBOL ist, wird auf den System-CharSet umgesetzt. +/*N*/ // Bei neuen Dokumenten (Version SC_FONTCHARSET) sollte der CharSet stimmen. +/*N*/ +/*N*/ BOOL bUpdateOld = ( nSrcVer < SC_FONTCHARSET ); +/*N*/ +/*N*/ CharSet eSysSet = gsl_getSystemTextEncoding(); +/*N*/ if ( eSrcSet != eSysSet || bUpdateOld ) +/*N*/ { +/*N*/ USHORT nCount,i; +/*N*/ SvxFontItem* pItem; +/*N*/ +/*N*/ ScDocumentPool* pPool = xPoolHelper->GetDocPool(); +/*N*/ nCount = pPool->GetItemCount(ATTR_FONT); +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ pItem = (SvxFontItem*)pPool->GetItem(ATTR_FONT, i); +/*N*/ if ( pItem && ( pItem->GetCharSet() == eSrcSet || +/*N*/ ( bUpdateOld && pItem->GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) ) +/*N*/ pItem->GetCharSet() = eSysSet; +/*N*/ } +/*N*/ +/*N*/ if ( pDrawLayer ) +/*N*/ { +/*N*/ SfxItemPool& rDrawPool = pDrawLayer->GetItemPool(); +/*N*/ nCount = rDrawPool.GetItemCount(EE_CHAR_FONTINFO); +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ pItem = (SvxFontItem*)rDrawPool.GetItem(EE_CHAR_FONTINFO, i); +/*N*/ if ( pItem && ( pItem->GetCharSet() == eSrcSet || +/*N*/ ( bUpdateOld && pItem->GetCharSet() != RTL_TEXTENCODING_SYMBOL ) ) ) +/*?*/ pItem->GetCharSet() = eSysSet; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocument::SetImportingXML( BOOL bVal ) +/*N*/ { +/*N*/ bImportingXML = bVal; +/*N*/ if (pDrawLayer) +/*N*/ pDrawLayer->EnableAdjust(!bImportingXML); +/*N*/ } + +/*N*/ rtl::Reference<SvxForbiddenCharactersTable> ScDocument::GetForbiddenCharacters() +/*N*/ { +/*N*/ return xForbiddenCharacters; +/*N*/ } + +/*N*/ void ScDocument::SetForbiddenCharacters( const rtl::Reference<SvxForbiddenCharactersTable> xNew ) +/*N*/ { +/*N*/ xForbiddenCharacters = xNew; +/*N*/ if ( pEditEngine ) +/*?*/ pEditEngine->SetForbiddenCharsTable( xForbiddenCharacters ); +/*N*/ if ( pDrawLayer ) +/*N*/ pDrawLayer->SetForbiddenCharsTable( xForbiddenCharacters ); +/*N*/ } + +/*N*/ BOOL ScDocument::IsValidAsianCompression() const +/*N*/ { +/*N*/ return ( nAsianCompression != SC_ASIANCOMPRESSION_INVALID ); +/*N*/ } + +/*N*/ BYTE ScDocument::GetAsianCompression() const +/*N*/ { +/*N*/ if ( nAsianCompression == SC_ASIANCOMPRESSION_INVALID ) +/*N*/ return 0; +/*N*/ else +/*N*/ return nAsianCompression; +/*N*/ } + +/*N*/ void ScDocument::SetAsianCompression(BYTE nNew) +/*N*/ { +/*N*/ nAsianCompression = nNew; +/*N*/ if ( pEditEngine ) +/*?*/ pEditEngine->SetAsianCompressionMode( nAsianCompression ); +/*N*/ if ( pDrawLayer ) +/*N*/ pDrawLayer->SetCharCompressType( nAsianCompression ); +/*N*/ } + +/*N*/ BOOL ScDocument::IsValidAsianKerning() const +/*N*/ { +/*N*/ return ( nAsianKerning != SC_ASIANKERNING_INVALID ); +/*N*/ } + +/*N*/ BOOL ScDocument::GetAsianKerning() const +/*N*/ { +/*N*/ if ( nAsianKerning == SC_ASIANKERNING_INVALID ) +/*N*/ return FALSE; +/*N*/ else +/*N*/ return (BOOL)nAsianKerning; +/*N*/ } + +/*N*/ void ScDocument::SetAsianKerning(BOOL bNew) +/*N*/ { +/*N*/ nAsianKerning = (BYTE)bNew; +/*N*/ if ( pEditEngine ) +/*?*/ pEditEngine->SetKernAsianPunctuation( (BOOL)nAsianKerning ); +/*N*/ if ( pDrawLayer ) +/*N*/ pDrawLayer->SetKernAsianPunctuation( (BOOL)nAsianKerning ); +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_document.cxx b/binfilter/bf_sc/source/core/data/sc_document.cxx new file mode 100644 index 000000000000..abed98c378de --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_document.cxx @@ -0,0 +1,3028 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#define _ZFORLIST_DECLARE_TABLE +#include "scitems.hxx" +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/boxitem.hxx> +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/editeng.hxx> +#include <bf_svtools/poolcach.hxx> +#include <bf_svtools/saveopt.hxx> +#include <bf_svtools/zforlist.hxx> +#include <tools/tenccvt.hxx> + +#include "attarray.hxx" +#include "patattr.hxx" +#include "rangenam.hxx" +#include "poolhelp.hxx" +#include "docpool.hxx" +#include "stlpool.hxx" +#include "globstr.hrc" +#include "rechead.hxx" +#include "dbcolect.hxx" +#include "pivot.hxx" +#include "chartlis.hxx" +#include "drwlayer.hxx" +#include "validat.hxx" +#include "prnsave.hxx" +#include "chgtrack.hxx" +#include "bf_sc.hrc" +#include "scresid.hxx" +#include "hints.hxx" +#include "detdata.hxx" +#include "cell.hxx" +#include "dpobject.hxx" +#include "indexmap.hxx" +#include "detfunc.hxx" // for UpdateAllComments +#include "scmod.hxx" +#include "dociter.hxx" +#include "progress.hxx" +#ifndef __SGI_STL_SET +#include <set> +#endif +namespace binfilter { + +/*N*/ struct ScDefaultAttr +/*N*/ { +/*N*/ const ScPatternAttr* pAttr; +/*N*/ USHORT nFirst; +/*N*/ USHORT nCount; +/*N*/ ScDefaultAttr(const ScPatternAttr* pPatAttr) : pAttr(pPatAttr), nFirst(0), nCount(0) {} +/*N*/ }; + +/*N*/ struct ScLessDefaultAttr +/*N*/ { +/*N*/ sal_Bool operator() (const ScDefaultAttr& rValue1, const ScDefaultAttr& rValue2) const +/*N*/ { +/*N*/ return rValue1.pAttr < rValue2.pAttr; +/*N*/ } +/*N*/ }; + +/*N*/ typedef std::set<ScDefaultAttr, ScLessDefaultAttr> ScDefaultAttrSet; + +/*N*/ void ScDocument::MakeTable( USHORT nTab ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && !pTab[nTab] ) +/*N*/ { +/*N*/ String aString = ScGlobal::GetRscString(STR_TABLE_DEF); //"Tabelle" +/*N*/ aString += String::CreateFromInt32(nTab+1); +/*N*/ CreateValidTabName( aString ); // keine doppelten +/*N*/ +/*N*/ pTab[nTab] = new ScTable(this, nTab, aString); +/*N*/ ++nMaxTableNumber; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::HasTable( USHORT nTab ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return TRUE; +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::GetName( USHORT nTab, String& rName ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ pTab[nTab]->GetName( rName ); +/*N*/ return TRUE; +/*N*/ } +/*N*/ rName.Erase(); +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::GetTable( const String& rName, USHORT& rTab ) const +/*N*/ { +/*N*/ String aUpperName = rName; +/*N*/ ScGlobal::pCharClass->toUpper(aUpperName); +/*N*/ String aCompName; +/*N*/ +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ { +/*N*/ pTab[i]->GetName( aCompName ); +/*N*/ ScGlobal::pCharClass->toUpper(aCompName); +/*N*/ if (aUpperName == aCompName) +/*N*/ { +/*N*/ rTab = i; +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ rTab = 0; +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::ValidTabName( const String& rName ) const +/*N*/ { + /* If changed, ScfTools::ConvertToScSheetName (sc/source/filter/ftools/ftools.cxx) + needs to be changed too. */ +/*N*/ using namespace ::com::sun::star::i18n; +/*N*/ sal_Int32 nStartFlags = KParseTokens::ANY_LETTER_OR_NUMBER | +/*N*/ KParseTokens::ASC_UNDERSCORE; +/*N*/ sal_Int32 nContFlags = nStartFlags; +/*N*/ String aContChars( RTL_CONSTASCII_USTRINGPARAM(" ") ); +/*N*/ ParseResult rRes = ScGlobal::pCharClass->parsePredefinedToken( KParseType::IDENTNAME, rName, 0, +/*N*/ nStartFlags, EMPTY_STRING, nContFlags, aContChars ); +/*N*/ return (rRes.TokenType & KParseType::IDENTNAME) && rRes.EndPos == rName.Len(); +/*N*/ } + + +/*N*/ BOOL ScDocument::ValidNewTabName( const String& rName ) const +/*N*/ { +/*N*/ BOOL bValid = ValidTabName(rName); +/*N*/ for (USHORT i=0; (i<=MAXTAB) && bValid; i++) +/*N*/ if (pTab[i]) +/*N*/ { +/*N*/ String aOldName; +/*N*/ pTab[i]->GetName(aOldName); +/*N*/ bValid = !ScGlobal::pTransliteration->isEqual( rName, aOldName ); +/*N*/ } +/*N*/ return bValid; +/*N*/ } + + +/*N*/ void ScDocument::CreateValidTabName(String& rName) const +/*N*/ { +/*N*/ if ( !ValidTabName(rName) ) +/*N*/ { +/*?*/ // neu erzeugen +/*?*/ +/*?*/ const String aStrTable( ScResId(SCSTR_TABLE) ); +/*?*/ BOOL bOk = FALSE; +/*?*/ +/*?*/ // vorneweg testen, ob der Prefix als gueltig erkannt wird +/*?*/ // wenn nicht, nur doppelte vermeiden +/*?*/ BOOL bPrefix = ValidTabName( aStrTable ); +/*?*/ DBG_ASSERT(bPrefix, "ungueltiger Tabellenname"); +/*?*/ USHORT nDummy; +/*?*/ +/*?*/ USHORT nLoops = 0; // "zur Sicherheit" +/*?*/ for ( USHORT i = nMaxTableNumber+1; !bOk && nLoops <= MAXTAB; i++ ) +/*?*/ { +/*?*/ rName = aStrTable; +/*?*/ rName += String::CreateFromInt32(i); +/*?*/ if (bPrefix) +/*?*/ bOk = ValidNewTabName( rName ); +/*?*/ else +/*?*/ bOk = !GetTable( rName, nDummy ); +/*?*/ ++nLoops; +/*?*/ } +/*?*/ +/*?*/ DBG_ASSERT(bOk, "kein gueltiger Tabellenname gefunden"); +/*?*/ if ( !bOk ) +/*?*/ rName = aStrTable; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // uebergebenen Namen ueberpruefen +/*N*/ +/*N*/ if ( !ValidNewTabName(rName) ) +/*N*/ { +/*N*/ USHORT i = 1; +/*N*/ String aName; +/*N*/ do +/*N*/ { +/*N*/ i++; +/*N*/ aName = rName; +/*N*/ aName += '_'; +/*N*/ aName += String::CreateFromInt32(i); +/*N*/ } +/*N*/ while (!ValidNewTabName(aName) && (i < MAXTAB+1)); +/*N*/ rName = aName; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::InsertTab( USHORT nPos, const String& rName, +/*N*/ BOOL bExternalDocument ) +/*N*/ { +/*N*/ USHORT nTabCount = GetTableCount(); +/*N*/ BOOL bValid = (nTabCount <= MAXTAB); +/*N*/ if ( !bExternalDocument ) // sonst rName == "'Doc'!Tab", vorher pruefen +/*N*/ bValid = (bValid && ValidNewTabName(rName)); +/*N*/ if (bValid) +/*N*/ { +/*N*/ if (nPos == SC_TAB_APPEND || nPos == nTabCount) +/*N*/ { +/*?*/ pTab[nTabCount] = new ScTable(this, nTabCount, rName); +/*?*/ ++nMaxTableNumber; +/*?*/ if ( bExternalDocument ) +/*?*/ pTab[nTabCount]->SetVisible( FALSE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (VALIDTAB(nPos) && (nPos < nTabCount)) +/*N*/ { +/*N*/ ScRange aRange( 0,0,nPos, MAXCOL,MAXROW,MAXTAB ); +/*N*/ xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 ); +/*N*/ xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 ); +/*N*/ pRangeName->UpdateTabRef( nPos, 1 ); +/*N*/ pDBCollection->UpdateReference( +/*N*/ URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 ); +/*N*/ if (pPivotCollection) +/*N*/ pPivotCollection->UpdateReference( +/*N*/ URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 ); +/*N*/ if (pDPCollection) +/*?*/ pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,1 ); +/*N*/ if (pDetOpList) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,1 ); +/*N*/ UpdateChartRef( URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 ); +/*N*/ UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,1 ); +/*N*/ if ( pUnoBroadcaster ) +/*N*/ pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,1 ) ); +/*N*/ +/*N*/ USHORT i; +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->UpdateInsertTab(nPos); +/*N*/ for (i = nTabCount; i > nPos; i--) +/*N*/ pTab[i] = pTab[i - 1]; +/*N*/ pTab[nPos] = new ScTable(this, nPos, rName); +/*N*/ ++nMaxTableNumber; +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->UpdateCompile(); +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StartAllListeners(); +/*N*/ +/*N*/ // update conditional formats after table is inserted +/*N*/ if ( pCondFormList ) +/*N*/ pCondFormList->UpdateReference( URM_INSDEL, aRange, 0,0,1 ); +/*N*/ // #81844# sheet names of references are not valid until sheet is inserted +/*N*/ if ( pChartListenerCollection ) +/*N*/ pChartListenerCollection->UpdateScheduledSeriesRanges(); +/*N*/ +/*N*/ SetDirty(); +/*N*/ bValid = TRUE; +/*N*/ } +/*N*/ else +/*N*/ bValid = FALSE; +/*N*/ } +/*N*/ } +/*N*/ return bValid; +/*N*/ } + + +/*N*/ BOOL ScDocument::DeleteTab( USHORT nTab, ScDocument* pRefUndoDoc ) +/*N*/ { +/*N*/ BOOL bValid = FALSE; +/*N*/ if (VALIDTAB(nTab)) +/*N*/ { +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ USHORT nTabCount = GetTableCount(); +/*N*/ if (nTabCount > 1) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab ); +/*N*/ DelBroadcastAreasInRange( aRange ); +/*N*/ +/*N*/ aRange.aEnd.SetTab( MAXTAB ); +/*N*/ xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1 ); +/*N*/ xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1 ); +/*N*/ pRangeName->UpdateTabRef( nTab, 2 ); +/*N*/ pDBCollection->UpdateReference( +/*N*/ URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 ); +/*N*/ if (pPivotCollection) +/*N*/ pPivotCollection->UpdateReference( +/*N*/ URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 ); +/*N*/ if (pDPCollection) +/*N*/ pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,-1 ); +/*N*/ if (pDetOpList) +/*N*/ pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,-1 ); +/*N*/ UpdateChartRef( URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 ); +/*N*/ UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1 ); +/*N*/ if ( pCondFormList ) +/*N*/ pCondFormList->UpdateReference( URM_INSDEL, aRange, 0,0,-1 ); +/*N*/ if ( pUnoBroadcaster ) +/*N*/ pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,-1 ) ); +/*N*/ +/*N*/ USHORT i; +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->UpdateDeleteTab(nTab,FALSE, +/*N*/ pRefUndoDoc ? pRefUndoDoc->pTab[i] : 0); +/*N*/ delete pTab[nTab]; +/*N*/ for (i=nTab + 1; i < nTabCount; i++) +/*N*/ pTab[i - 1] = pTab[i]; +/*N*/ pTab[nTabCount - 1] = NULL; +/*N*/ --nMaxTableNumber; +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->UpdateCompile(); +/*N*/ // Excel-Filter loescht einige Tables waehrend des Ladens, +/*N*/ // Listener werden erst nach dem Laden aufgesetzt +/*N*/ if ( !bInsertingFromOtherDoc ) +/*N*/ { +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StartAllListeners(); +/*N*/ SetDirty(); +/*N*/ } +/*N*/ // #81844# sheet names of references are not valid until sheet is deleted +/*N*/ pChartListenerCollection->UpdateScheduledSeriesRanges(); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ bValid = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return bValid; +/*N*/ } + + +/*N*/ BOOL ScDocument::RenameTab( USHORT nTab, const String& rName, BOOL bUpdateRef, +/*N*/ BOOL bExternalDocument ) +/*N*/ { +/*N*/ BOOL bValid = FALSE; +/*N*/ USHORT i; +/*N*/ if VALIDTAB(nTab) +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ if ( bExternalDocument ) +/*N*/ bValid = TRUE; // zusammengesetzter Name +/*N*/ else +/*N*/ bValid = ValidTabName(rName); +/*N*/ for (i=0; (i<=MAXTAB) && bValid; i++) +/*N*/ if (pTab[i] && (i != nTab)) +/*N*/ { +/*N*/ String aOldName; +/*N*/ pTab[i]->GetName(aOldName); +/*N*/ bValid = !ScGlobal::pTransliteration->isEqual( rName, aOldName ); +/*N*/ } +/*N*/ if (bValid) +/*N*/ { +/*N*/ pTab[nTab]->SetName(rName); +/*N*/ if ( pChartListenerCollection ) +/*N*/ pChartListenerCollection->UpdateSeriesRangesContainingTab( nTab ); +/*N*/ } +/*N*/ } +/*N*/ return bValid; +/*N*/ } + + +/*N*/ void ScDocument::SetVisible( USHORT nTab, BOOL bVisible ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->SetVisible(bVisible); +/*N*/ } + + +/*N*/ BOOL ScDocument::IsVisible( USHORT nTab ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->IsVisible(); +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +/* ---------------------------------------------------------------------------- + benutzten Bereich suchen: + + GetCellArea - nur Daten + GetTableArea - Daten / Attribute + GetPrintArea - beruecksichtigt auch Zeichenobjekte, + streicht Attribute bis ganz rechts / unten +---------------------------------------------------------------------------- */ + + +/*N*/ BOOL ScDocument::GetCellArea( USHORT nTab, USHORT& rEndCol, USHORT& rEndRow ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->GetCellArea( rEndCol, rEndRow ); +/*N*/ +/*N*/ rEndCol = 0; +/*N*/ rEndRow = 0; +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::GetTableArea( USHORT nTab, USHORT& rEndCol, USHORT& rEndRow ) const +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->GetTableArea( rEndCol, rEndRow ); +/*N*/ +/*N*/ rEndCol = 0; +/*N*/ rEndRow = 0; +/*N*/ return FALSE; +/*N*/ } + + +// zusammenhaengender Bereich + +/*N*/ void ScDocument::GetDataArea( USHORT nTab, USHORT& rStartCol, USHORT& rStartRow, +/*N*/ USHORT& rEndCol, USHORT& rEndRow, BOOL bIncludeOld ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow, bIncludeOld ); +/*N*/ } + + + + + + +/*N*/ BOOL ScDocument::CanInsertRow( const ScRange& rRange ) const +/*N*/ { +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ USHORT nStartTab = rRange.aStart.Tab(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ USHORT nEndTab = rRange.aEnd.Tab(); +/*N*/ PutInOrder( nStartCol, nEndCol ); +/*N*/ PutInOrder( nStartRow, nEndRow ); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ USHORT nSize = nEndRow - nStartRow + 1; +/*N*/ +/*N*/ BOOL bTest = TRUE; +/*N*/ for (USHORT i=nStartTab; i<=nEndTab && bTest; i++) +/*N*/ if (pTab[i]) +/*N*/ bTest &= pTab[i]->TestInsertRow( nStartCol, nEndCol, nSize ); +/*N*/ +/*N*/ return bTest; +/*N*/ } + + +/*N*/ BOOL ScDocument::InsertRow( USHORT nStartCol, USHORT nStartTab, +/*N*/ USHORT nEndCol, USHORT nEndTab, +/*N*/ USHORT nStartRow, USHORT nSize, ScDocument* pRefUndoDoc ) +/*N*/ { +/*N*/ PutInOrder( nStartCol, nEndCol ); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ BOOL bTest = TRUE; +/*N*/ BOOL bRet = FALSE; +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ USHORT i = 0; +/*N*/ for (i=nStartTab; i<=nEndTab && bTest; i++) +/*N*/ if (pTab[i]) +/*N*/ bTest &= pTab[i]->TestInsertRow( nStartCol, nEndCol, nSize ); +/*N*/ if (bTest) +/*N*/ { +/*N*/ // UpdateBroadcastAreas muss vor UpdateReference gerufen werden, damit nicht +/*N*/ // Eintraege verschoben werden, die erst bei UpdateReference neu erzeugt werden +/*N*/ +/*N*/ UpdateBroadcastAreas( URM_INSDEL, ScRange( +/*N*/ ScAddress( nStartCol, nStartRow, nStartTab ), +/*N*/ ScAddress( nEndCol, MAXROW, nEndTab )), 0, nSize, 0 ); +/*N*/ UpdateReference( URM_INSDEL, nStartCol, nStartRow, nStartTab, +/*N*/ nEndCol, MAXROW, nEndTab, +/*N*/ 0, nSize, 0, pRefUndoDoc, FALSE ); // without drawing objects +/*N*/ for (i=nStartTab; i<=nEndTab; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->InsertRow( nStartCol, nEndCol, nStartRow, nSize ); +/*N*/ +/*N*/ // #82991# UpdateRef for drawing layer must be after inserting, +/*N*/ // when the new row heights are known. +/*N*/ for (i=nStartTab; i<=nEndTab; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->UpdateDrawRef( URM_INSDEL, +/*N*/ nStartCol, nStartRow, nStartTab, nEndCol, MAXROW, nEndTab, +/*N*/ 0, nSize, 0 ); +/*N*/ +/*N*/ if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() ) +/*N*/ { // durch Restaurierung von Referenzen auf geloeschte Bereiche ist +/*N*/ // ein neues Listening faellig, bisherige Listener wurden in +/*N*/ // FormulaCell UpdateReference abgehaengt +/*N*/ StartAllListeners(); +/*N*/ } +/*N*/ else +/*N*/ { // RelName listeners have been removed in UpdateReference +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StartNameListeners( TRUE ); +/*N*/ // #69592# at least all cells using range names pointing relative +/*N*/ // to the moved range must recalculate +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->SetRelNameDirty(); +/*N*/ } +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ if ( bRet ) +/*N*/ pChartListenerCollection->UpdateDirtyCharts(); +/*N*/ return bRet; +/*N*/ } + + +/*N*/ BOOL ScDocument::InsertRow( const ScRange& rRange, ScDocument* pRefUndoDoc ) +/*N*/ { +/*N*/ return InsertRow( rRange.aStart.Col(), rRange.aStart.Tab(), +/*N*/ rRange.aEnd.Col(), rRange.aEnd.Tab(), +/*N*/ rRange.aStart.Row(), rRange.aEnd.Row()-rRange.aStart.Row()+1, +/*N*/ pRefUndoDoc ); +/*N*/ } + + +/*N*/ void ScDocument::DeleteRow( USHORT nStartCol, USHORT nStartTab, +/*N*/ USHORT nEndCol, USHORT nEndTab, +/*N*/ USHORT nStartRow, USHORT nSize, +/*N*/ ScDocument* pRefUndoDoc, BOOL* pUndoOutline ) +/*N*/ { +/*N*/ PutInOrder( nStartCol, nEndCol ); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ +/*N*/ if ( nStartRow+nSize <= MAXROW ) +/*N*/ { +/*N*/ DelBroadcastAreasInRange( ScRange( +/*N*/ ScAddress( nStartCol, nStartRow, nStartTab ), +/*N*/ ScAddress( nEndCol, nStartRow+nSize-1, nEndTab ) ) ); +/*N*/ UpdateBroadcastAreas( URM_INSDEL, ScRange( +/*N*/ ScAddress( nStartCol, nStartRow+nSize, nStartTab ), +/*N*/ ScAddress( nEndCol, MAXROW, nEndTab )), 0, -(short) nSize, 0 ); +/*N*/ } +/*N*/ else +/*N*/ DelBroadcastAreasInRange( ScRange( +/*N*/ ScAddress( nStartCol, nStartRow, nStartTab ), +/*N*/ ScAddress( nEndCol, MAXROW, nEndTab ) ) ); +/*N*/ +/*N*/ if ( nStartRow+nSize <= MAXROW ) +/*N*/ { +/*N*/ UpdateReference( URM_INSDEL, nStartCol, nStartRow+nSize, nStartTab, +/*N*/ nEndCol, MAXROW, nEndTab, +/*N*/ 0, -(short) nSize, 0, pRefUndoDoc ); +/*N*/ } +/*N*/ +/*N*/ if (pUndoOutline) +/*N*/ *pUndoOutline = FALSE; +/*N*/ +/*N*/ USHORT i=0; +/*N*/ for (i=nStartTab; i<=nEndTab; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->DeleteRow( nStartCol, nEndCol, nStartRow, nSize, pUndoOutline ); +/*N*/ +/*N*/ if ( nStartRow+nSize <= MAXROW ) +/*N*/ { // Name listeners have been removed in UpdateReference +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StartNameListeners( FALSE ); +/*N*/ // #69592# at least all cells using range names pointing relative to +/*N*/ // the moved range must recalculate +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->SetRelNameDirty(); +/*N*/ } +/*N*/ +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ pChartListenerCollection->UpdateDirtyCharts(); +/*N*/ } + + +/*N*/ void ScDocument::DeleteRow( const ScRange& rRange, ScDocument* pRefUndoDoc, BOOL* pUndoOutline ) +/*N*/ { +/*N*/ DeleteRow( rRange.aStart.Col(), rRange.aStart.Tab(), +/*N*/ rRange.aEnd.Col(), rRange.aEnd.Tab(), +/*N*/ rRange.aStart.Row(), rRange.aEnd.Row()-rRange.aStart.Row()+1, +/*N*/ pRefUndoDoc, pUndoOutline ); +/*N*/ } + + +/*N*/ BOOL ScDocument::CanInsertCol( const ScRange& rRange ) const +/*N*/ { +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ USHORT nStartTab = rRange.aStart.Tab(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ USHORT nEndTab = rRange.aEnd.Tab(); +/*N*/ PutInOrder( nStartCol, nEndCol ); +/*N*/ PutInOrder( nStartRow, nEndRow ); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ USHORT nSize = nEndCol - nStartCol + 1; +/*N*/ +/*N*/ BOOL bTest = TRUE; +/*N*/ for (USHORT i=nStartTab; i<=nEndTab && bTest; i++) +/*N*/ if (pTab[i]) +/*N*/ bTest &= pTab[i]->TestInsertCol( nStartRow, nEndRow, nSize ); +/*N*/ +/*N*/ return bTest; +/*N*/ } + + +/*N*/ BOOL ScDocument::InsertCol( USHORT nStartRow, USHORT nStartTab, +/*N*/ USHORT nEndRow, USHORT nEndTab, +/*N*/ USHORT nStartCol, USHORT nSize, ScDocument* pRefUndoDoc ) +/*N*/ { +/*N*/ PutInOrder( nStartRow, nEndRow ); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ BOOL bTest = TRUE; +/*N*/ BOOL bRet = FALSE; +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ USHORT i=0; +/*N*/ for (i=nStartTab; i<=nEndTab && bTest; i++) +/*N*/ if (pTab[i]) +/*N*/ bTest &= pTab[i]->TestInsertCol( nStartRow, nEndRow, nSize ); +/*N*/ if (bTest) +/*N*/ { +/*N*/ UpdateBroadcastAreas( URM_INSDEL, ScRange( +/*N*/ ScAddress( nStartCol, nStartRow, nStartTab ), +/*N*/ ScAddress( MAXCOL, nEndRow, nEndTab )), nSize, 0, 0 ); +/*N*/ UpdateReference( URM_INSDEL, nStartCol, nStartRow, nStartTab, +/*N*/ MAXCOL, nEndRow, nEndTab, +/*N*/ nSize, 0, 0, pRefUndoDoc ); +/*N*/ for (i=nStartTab; i<=nEndTab; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->InsertCol( nStartCol, nStartRow, nEndRow, nSize ); +/*N*/ +/*N*/ if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() ) +/*N*/ { // durch Restaurierung von Referenzen auf geloeschte Bereiche ist +/*N*/ // ein neues Listening faellig, bisherige Listener wurden in +/*N*/ // FormulaCell UpdateReference abgehaengt +/*N*/ StartAllListeners(); +/*N*/ } +/*N*/ else +/*N*/ { // RelName listeners have been removed in UpdateReference +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StartNameListeners( TRUE ); +/*N*/ // #69592# at least all cells using range names pointing relative +/*N*/ // to the moved range must recalculate +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->SetRelNameDirty(); +/*N*/ } +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ if ( bRet ) +/*N*/ pChartListenerCollection->UpdateDirtyCharts(); +/*N*/ return bRet; +/*N*/ } + + +/*N*/ BOOL ScDocument::InsertCol( const ScRange& rRange, ScDocument* pRefUndoDoc ) +/*N*/ { +/*N*/ return InsertCol( rRange.aStart.Row(), rRange.aStart.Tab(), +/*N*/ rRange.aEnd.Row(), rRange.aEnd.Tab(), +/*N*/ rRange.aStart.Col(), rRange.aEnd.Col()-rRange.aStart.Col()+1, +/*N*/ pRefUndoDoc ); +/*N*/ } + + +/*N*/ void ScDocument::DeleteCol(USHORT nStartRow, USHORT nStartTab, USHORT nEndRow, USHORT nEndTab, +/*N*/ USHORT nStartCol, USHORT nSize, ScDocument* pRefUndoDoc, +/*N*/ BOOL* pUndoOutline ) +/*N*/ { +/*N*/ PutInOrder( nStartRow, nEndRow ); +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ +/*N*/ if ( nStartCol+nSize <= MAXCOL ) +/*N*/ { +/*N*/ DelBroadcastAreasInRange( ScRange( +/*N*/ ScAddress( nStartCol, nStartRow, nStartTab ), +/*N*/ ScAddress( nStartCol+nSize-1, nEndRow, nEndTab ) ) ); +/*N*/ UpdateBroadcastAreas( URM_INSDEL, ScRange( +/*N*/ ScAddress( nStartCol+nSize, nStartRow, nStartTab ), +/*N*/ ScAddress( MAXCOL, nEndRow, nEndTab )), -(short) nSize, 0, 0 ); +/*N*/ } +/*N*/ else +/*N*/ DelBroadcastAreasInRange( ScRange( +/*N*/ ScAddress( nStartCol, nStartRow, nStartTab ), +/*N*/ ScAddress( MAXCOL, nEndRow, nEndTab ) ) ); +/*N*/ +/*N*/ if ( nStartCol+nSize <= MAXCOL ) +/*N*/ { +/*N*/ UpdateReference( URM_INSDEL, nStartCol+nSize, nStartRow, nStartTab, +/*N*/ MAXCOL, nEndRow, nEndTab, +/*N*/ -(short) nSize, 0, 0, pRefUndoDoc ); +/*N*/ } +/*N*/ +/*N*/ if (pUndoOutline) +/*N*/ *pUndoOutline = FALSE; +/*N*/ +/*N*/ USHORT i=0; +/*N*/ for (i=nStartTab; i<=nEndTab; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->DeleteCol( nStartCol, nStartRow, nEndRow, nSize, pUndoOutline ); +/*N*/ +/*N*/ if ( nStartCol+nSize <= MAXCOL ) +/*N*/ { // Name listeners have been removed in UpdateReference +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StartNameListeners( FALSE ); +/*N*/ // #69592# at least all cells using range names pointing relative to +/*N*/ // the moved range must recalculate +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->SetRelNameDirty(); +/*N*/ } +/*N*/ +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ pChartListenerCollection->UpdateDirtyCharts(); +/*N*/ } + + +/*N*/ void ScDocument::DeleteCol( const ScRange& rRange, ScDocument* pRefUndoDoc, BOOL* pUndoOutline ) +/*N*/ { +/*N*/ DeleteCol( rRange.aStart.Row(), rRange.aStart.Tab(), +/*N*/ rRange.aEnd.Row(), rRange.aEnd.Tab(), +/*N*/ rRange.aStart.Col(), rRange.aEnd.Col()-rRange.aStart.Col()+1, +/*N*/ pRefUndoDoc, pUndoOutline ); +/*N*/ } + + +// fuer Area-Links: Zellen einuegen/loeschen, wenn sich der Bereich veraendert +// (ohne Paint) + + + + + + +/*N*/ BOOL ScDocument::CanFitBlock( const ScRange& rOld, const ScRange& rNew ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return FALSE; //STRIP001 if ( rOld == rNew ) +/*N*/ } + + +/*N*/ void ScDocument::FitBlock( const ScRange& rOld, const ScRange& rNew, BOOL bClear ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (bClear) +/*N*/ } + + +/*N*/ void ScDocument::DeleteArea(USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ const ScMarkData& rMark, USHORT nDelFlag) +/*N*/ { +/*N*/ PutInOrder( nCol1, nCol2 ); +/*N*/ PutInOrder( nRow1, nRow2 ); +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ if ( rMark.GetTableSelect(i) || bIsUndo ) +/*N*/ pTab[i]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScDocument::DeleteAreaTab(USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ USHORT nTab, USHORT nDelFlag) +/*N*/ { +/*N*/ PutInOrder( nCol1, nCol2 ); +/*N*/ PutInOrder( nRow1, nRow2 ); +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ pTab[nTab]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::DeleteAreaTab( const ScRange& rRange, USHORT nDelFlag ) +/*N*/ { +/*N*/ for ( USHORT nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); nTab++ ) +/*N*/ DeleteAreaTab( rRange.aStart.Col(), rRange.aStart.Row(), +/*N*/ rRange.aEnd.Col(), rRange.aEnd.Row(), +/*N*/ nTab, nDelFlag ); +/*N*/ } + + +/*N*/ void ScDocument::InitUndo( ScDocument* pSrcDoc, USHORT nTab1, USHORT nTab2, +/*N*/ BOOL bColInfo, BOOL bRowInfo ) +/*N*/ { +/*N*/ if (bIsUndo) +/*N*/ { +/*N*/ Clear(); +/*N*/ +/*N*/ xPoolHelper = pSrcDoc->xPoolHelper; +/*N*/ +/*N*/ String aString; +/*N*/ for (USHORT nTab = nTab1; nTab <= nTab2; nTab++) +/*N*/ pTab[nTab] = new ScTable(this, nTab, aString, bColInfo, bRowInfo); +/*N*/ +/*N*/ nMaxTableNumber = nTab2 + 1; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("InitUndo"); +/*N*/ } + +/*N*/ void ScDocument::CopyToDocument(USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ USHORT nFlags, BOOL bOnlyMarked, ScDocument* pDestDoc, +/*N*/ const ScMarkData* pMarks, BOOL bColRowFlags ) +/*N*/ { +/*N*/ PutInOrder( nCol1, nCol2 ); +/*N*/ PutInOrder( nRow1, nRow2 ); +/*N*/ PutInOrder( nTab1, nTab2 ); +/*N*/ if( !pDestDoc->aDocName.Len() ) +/*N*/ pDestDoc->aDocName = aDocName; +/*N*/ if (VALIDTAB(nTab1) && VALIDTAB(nTab2)) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDestDoc->GetAutoCalc(); +/*N*/ pDestDoc->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i = nTab1; i <= nTab2; i++) +/*N*/ { +/*N*/ if (pTab[i] && pDestDoc->pTab[i]) +/*N*/ pTab[i]->CopyToTable( nCol1, nRow1, nCol2, nRow2, nFlags, +/*N*/ bOnlyMarked, pDestDoc->pTab[i], pMarks, +/*N*/ FALSE, bColRowFlags ); +/*N*/ } +/*N*/ pDestDoc->SetAutoCalc( bOldAutoCalc ); +/*N*/ } +/*N*/ } + + + + +/*N*/ void ScDocument::CopyToDocument(const ScRange& rRange, +/*N*/ USHORT nFlags, BOOL bOnlyMarked, ScDocument* pDestDoc, +/*N*/ const ScMarkData* pMarks, BOOL bColRowFlags) +/*N*/ { +/*N*/ ScRange aNewRange = rRange; +/*N*/ aNewRange.Justify(); +/*N*/ +/*N*/ if( !pDestDoc->aDocName.Len() ) +/*N*/ pDestDoc->aDocName = aDocName; +/*N*/ BOOL bOldAutoCalc = pDestDoc->GetAutoCalc(); +/*N*/ pDestDoc->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i = aNewRange.aStart.Tab(); i <= aNewRange.aEnd.Tab(); i++) +/*N*/ if (pTab[i] && pDestDoc->pTab[i]) +/*N*/ pTab[i]->CopyToTable(aNewRange.aStart.Col(), aNewRange.aStart.Row(), +/*N*/ aNewRange.aEnd.Col(), aNewRange.aEnd.Row(), +/*N*/ nFlags, bOnlyMarked, pDestDoc->pTab[i], +/*N*/ pMarks, FALSE, bColRowFlags); +/*N*/ pDestDoc->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + + + +/*N*/ void ScDocument::CopyToClip(USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ BOOL bCut, ScDocument* pClipDoc, +/*N*/ BOOL bAllTabs, const ScMarkData* pMarks, +/*N*/ BOOL bKeepScenarioFlags, BOOL bIncludeObjects) +/*N*/ { +/*N*/ DBG_ASSERT( bAllTabs || pMarks, "CopyToClip: ScMarkData fehlt" ); +/*N*/ +/*N*/ if (!bIsClip) +/*N*/ { +/*N*/ PutInOrder( nCol1, nCol2 ); +/*N*/ PutInOrder( nRow1, nRow2 ); +/*N*/ if (!pClipDoc) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ DBG_ERROR("CopyToClip: no ClipDoc"); +/*N*/ } +/*N*/ +/*N*/ pClipDoc->aDocName = aDocName; +/*N*/ pClipDoc->aClipRange = ScRange( nCol1,nRow1,0, nCol2,nRow2,0 ); +/*N*/ pClipDoc->ResetClip( this, pMarks ); +/*N*/ USHORT i, j; +/*N*/ pClipDoc->pRangeName->FreeAll(); +/*N*/ for (i = 0; i < pRangeName->GetCount(); i++) //! DB-Bereiche Pivot-Bereiche auch !!! +/*N*/ { +/*N*/ USHORT nIndex = ((ScRangeData*)((*pRangeName)[i]))->GetIndex(); +/*N*/ BOOL bInUse = FALSE; +/*N*/ for (j = 0; !bInUse && (j <= MAXTAB); j++) +/*N*/ { +/*N*/ if (pTab[j]) +/*N*/ bInUse = pTab[j]->IsRangeNameInUse(nCol1, nRow1, nCol2, nRow2, +/*N*/ nIndex); +/*N*/ } +/*N*/ if (bInUse) +/*N*/ { +/*N*/ ScRangeData* pData = new ScRangeData(*((*pRangeName)[i])); +/*N*/ if (!pClipDoc->pRangeName->Insert(pData)) +/*N*/ delete pData; +/*N*/ else +/*N*/ pData->SetIndex(nIndex); +/*N*/ } +/*N*/ } +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i] && pClipDoc->pTab[i]) +/*N*/ if ( bAllTabs || !pMarks || pMarks->GetTableSelect(i) ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pTab[i]->CopyToClip(nCol1, nRow1, nCol2, nRow2, pClipDoc->pTab[i], bKeepScenarioFlags); +/*N*/ +/*N*/ if ( pDrawLayer && bIncludeObjects ) +/*N*/ { +/*N*/ // also copy drawing objects +/*N*/ +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ Rectangle aObjRect = GetMMRect( nCol1, nRow1, nCol2, nRow2, i ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pClipDoc->bCutMode = bCut; +/*N*/ } +/*N*/ } + +void ScDocument::StartListeningFromClip( USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, const ScMarkData& rMark, USHORT nInsFlag ) +{ +} + + +/*N*/ void ScDocument::BroadcastFromClip( USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ const ScMarkData& rMark, USHORT nInsFlag ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if (nInsFlag & IDF_CONTENTS) +/*N*/ } + + +/*N*/ void ScDocument::CopyBlockFromClip( USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ const ScMarkData& rMark, +/*N*/ short nDx, short nDy, +/*N*/ const ScCopyBlockFromClipParams* pCBFCP ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 ScTable** ppClipTab = pCBFCP->pClipDoc->pTab; +/*N*/ } + + +/*N*/ void ScDocument::CopyNonFilteredFromClip( USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ const ScMarkData& rMark, +/*N*/ short nDx, short nDy, +/*N*/ const ScCopyBlockFromClipParams* pCBFCP ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 // call CopyBlockFromClip for ranges of consecutive non-filtered rows +/*N*/ } + + +/*N*/ void ScDocument::CopyFromClip( const ScRange& rDestRange, const ScMarkData& rMark, +/*N*/ USHORT nInsFlag, +/*N*/ ScDocument* pRefUndoDoc, ScDocument* pClipDoc, BOOL bResetCut, +/*N*/ BOOL bAsLink, BOOL bIncludeFiltered, BOOL bSkipAttrForEmpty ) +/*N*/ { +/*N*/ if (!bIsClip && pClipDoc) +/*N*/ { +/*N*/ if (pClipDoc->bIsClip && pClipDoc->GetTableCount()) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); // avoid multiple recalculations +/*N*/ +/*N*/ SvNumberFormatter* pThisFormatter = xPoolHelper->GetFormTable(); +/*N*/ SvNumberFormatter* pOtherFormatter = pClipDoc->xPoolHelper->GetFormTable(); +/*N*/ if (pOtherFormatter && pOtherFormatter != pThisFormatter) +/*N*/ { +/*N*/ SvNumberFormatterIndexTable* pExchangeList = +/*N*/ pThisFormatter->MergeFormatter(*(pOtherFormatter)); +/*N*/ if (pExchangeList->Count() > 0) +/*N*/ pFormatExchangeList = pExchangeList; +/*N*/ } +/*N*/ +/*N*/ USHORT nClipRangeNames = pClipDoc->pRangeName->GetCount(); +/*N*/ // array containing range names which might need update of indices +/*N*/ ScRangeData** pClipRangeNames = nClipRangeNames ? new ScRangeData* [nClipRangeNames] : NULL; +/*N*/ // the index mapping thereof +/*N*/ ScIndexMap aClipRangeMap( nClipRangeNames ); +/*N*/ BOOL bRangeNameReplace = FALSE; +/*N*/ +/*N*/ USHORT i, k; +/*N*/ for (i = 0; i < nClipRangeNames; i++) //! DB-Bereiche Pivot-Bereiche auch +/*N*/ { + /* Copy only if the name doesn't exist in this document. + If it exists we use the already existing name instead, + another possibility could be to create new names if + documents differ. + A proper solution would ask the user how to proceed. + The adjustment of the indices in the formulas is done later. + */ +/*N*/ ScRangeData* pClipData = (*pClipDoc->pRangeName)[i]; +/*N*/ if ( pRangeName->SearchName( pClipData->GetName(), k ) ) +/*N*/ { +/*N*/ pClipRangeNames[i] = NULL; // range name not inserted +/*N*/ USHORT nOldIndex = pClipData->GetIndex(); +/*N*/ USHORT nNewIndex = ((*pRangeName)[k])->GetIndex(); +/*N*/ aClipRangeMap.SetPair( i, nOldIndex, nNewIndex ); +/*N*/ if ( !bRangeNameReplace ) +/*N*/ bRangeNameReplace = ( nOldIndex != nNewIndex ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScRangeData* pData = new ScRangeData( *pClipData ); +/*N*/ pData->SetDocument(this); +/*N*/ if ( pRangeName->FindIndex( pData->GetIndex() ) ) +/*N*/ pData->SetIndex(0); // need new index, done in Insert +/*N*/ if ( pRangeName->Insert( pData ) ) +/*N*/ { +/*N*/ pClipRangeNames[i] = pData; +/*N*/ USHORT nOldIndex = pClipData->GetIndex(); +/*N*/ USHORT nNewIndex = pData->GetIndex(); +/*N*/ aClipRangeMap.SetPair( i, nOldIndex, nNewIndex ); +/*N*/ if ( !bRangeNameReplace ) +/*N*/ bRangeNameReplace = ( nOldIndex != nNewIndex ); +/*N*/ } +/*N*/ else +/*N*/ { // must be an overflow +/*N*/ delete pData; +/*N*/ pClipRangeNames[i] = NULL; +/*N*/ aClipRangeMap.SetPair( i, pClipData->GetIndex(), 0 ); +/*N*/ bRangeNameReplace = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ USHORT nCol1 = rDestRange.aStart.Col(); +/*N*/ USHORT nRow1 = rDestRange.aStart.Row(); +/*N*/ USHORT nCol2 = rDestRange.aEnd.Col(); +/*N*/ USHORT nRow2 = rDestRange.aEnd.Row(); +/*N*/ +/*N*/ USHORT nXw = pClipDoc->aClipRange.aEnd.Col(); +/*N*/ USHORT nYw = pClipDoc->aClipRange.aEnd.Row(); +/*N*/ pClipDoc->ExtendMerge( pClipDoc->aClipRange.aStart.Col(), +/*N*/ pClipDoc->aClipRange.aStart.Row(), +/*N*/ nXw, nYw, 0 ); +/*N*/ nXw -= pClipDoc->aClipRange.aEnd.Col(); +/*N*/ nYw -= pClipDoc->aClipRange.aEnd.Row(); // only extra value from ExtendMerge +/*N*/ USHORT nDestAddX, nDestAddY; +/*N*/ pClipDoc->GetClipArea( nDestAddX, nDestAddY, bIncludeFiltered ); +/*N*/ nXw += nDestAddX; +/*N*/ nYw += nDestAddY; // ClipArea, plus ExtendMerge value +/*N*/ +/*N*/ // Inhalte entweder komplett oder gar nicht loeschen: +/*N*/ USHORT nDelFlag = IDF_NONE; +/*N*/ if ( nInsFlag & IDF_CONTENTS ) +/*N*/ nDelFlag |= IDF_CONTENTS; +/*N*/ // With bSkipAttrForEmpty, don't remove attributes, copy +/*N*/ // on top of existing attributes instead. +/*N*/ if ( ( nInsFlag & IDF_ATTRIB ) && !bSkipAttrForEmpty ) +/*N*/ nDelFlag |= IDF_ATTRIB; +/*N*/ DeleteArea(nCol1, nRow1, nCol2, nRow2, rMark, nDelFlag); +/*N*/ +/*N*/ bInsertingFromOtherDoc = TRUE; // kein Broadcast/Listener aufbauen bei Insert +/*N*/ USHORT nC1 = nCol1; +/*N*/ USHORT nR1 = nRow1; +/*N*/ USHORT nC2 = nC1 + nXw; +/*N*/ USHORT nR2 = nR1 + nYw; +/*N*/ USHORT nClipStartCol = pClipDoc->aClipRange.aStart.Col(); +/*N*/ USHORT nClipStartRow = pClipDoc->aClipRange.aStart.Row(); +/*N*/ +/*N*/ ScCopyBlockFromClipParams aCBFCP; +/*N*/ aCBFCP.pRefUndoDoc = pRefUndoDoc; +/*N*/ aCBFCP.pClipDoc = pClipDoc; +/*N*/ aCBFCP.nInsFlag = nInsFlag; +/*N*/ aCBFCP.bAsLink = bAsLink; +/*N*/ aCBFCP.bSkipAttrForEmpty = bSkipAttrForEmpty; +/*N*/ aCBFCP.nTabStart = MAXTAB; // wird in der Schleife angepasst +/*N*/ aCBFCP.nTabEnd = 0; // wird in der Schleife angepasst +/*N*/ +/*N*/ // Inc/DecRecalcLevel einmal aussen, damit nicht fuer jeden Block +/*N*/ // die Draw-Seitengroesse neu berechnet werden muss +/*N*/ //! nur wenn ganze Zeilen/Spalten kopiert werden? +/*N*/ +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ { +/*N*/ if ( i < aCBFCP.nTabStart ) +/*N*/ aCBFCP.nTabStart = i; +/*N*/ aCBFCP.nTabEnd = i; +/*N*/ pTab[i]->IncRecalcLevel(); +/*N*/ } +/*N*/ +/*N*/ // bei mindestens 64 Zeilen wird in ScColumn::CopyFromClip voralloziert +/*N*/ BOOL bDoDouble = ( nYw < 64 && nRow2 - nRow1 > 64); +/*N*/ BOOL bOldDouble = ScColumn::bDoubleAlloc; +/*N*/ if (bDoDouble) +/*N*/ ScColumn::bDoubleAlloc = TRUE; +/*N*/ +/*N*/ do +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ short nDx = ((short)nC1) - nClipStartCol; +/*N*/ short nDy = ((short)nR1) - nClipStartRow; +/*N*/ if ( bIncludeFiltered ) +/*N*/ CopyBlockFromClip( nC1, nR1, nC2, nR2, rMark, nDx, nDy, &aCBFCP ); +/*N*/ else +/*N*/ CopyNonFilteredFromClip( nC1, nR1, nC2, nR2, rMark, nDx, nDy, &aCBFCP ); +/*N*/ nC1 = nC2 + 1; +/*N*/ nC2 = Min((USHORT)(nC1 + nXw), nCol2); +/*N*/ } +/*N*/ while (nC1 <= nCol2); +/*N*/ nC1 = nCol1; +/*N*/ nC2 = nC1 + nXw; +/*N*/ nR1 = nR2 + 1; +/*N*/ nR2 = Min((USHORT)(nR1 + nYw), nRow2); +/*N*/ } +/*N*/ while (nR1 <= nRow2); +/*N*/ +/*N*/ ScColumn::bDoubleAlloc = bOldDouble; +/*N*/ +/*N*/ for (i = 0; i <= MAXTAB; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ pTab[i]->DecRecalcLevel(); +/*N*/ +/*N*/ bInsertingFromOtherDoc = FALSE; +/*N*/ pFormatExchangeList = NULL; +/*N*/ if ( bRangeNameReplace ) +/*N*/ { +/*N*/ // first update all inserted named formulas if they contain other +/*N*/ // range names and used indices changed +/*N*/ for (i = 0; i < nClipRangeNames; i++) //! DB-Bereiche Pivot-Bereiche auch +/*N*/ { +/*N*/ if ( pClipRangeNames[i] ) +/*N*/ pClipRangeNames[i]->ReplaceRangeNamesInUse( aClipRangeMap ); +/*N*/ } +/*N*/ // then update the formulas, they might need the just updated range names +/*N*/ USHORT nC1 = nCol1; +/*N*/ USHORT nR1 = nRow1; +/*N*/ USHORT nC2 = nC1 + nXw; +/*N*/ USHORT nR2 = nR1 + nYw; +/*N*/ do +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ for (k = 0; k <= MAXTAB; k++) +/*N*/ { +/*N*/ if ( pTab[k] && rMark.GetTableSelect(k) ) +/*N*/ pTab[k]->ReplaceRangeNamesInUse(nC1, nR1, +/*N*/ nC2, nR2, aClipRangeMap ); +/*N*/ } +/*N*/ nC1 = nC2 + 1; +/*N*/ nC2 = Min((USHORT)(nC1 + nXw), nCol2); +/*N*/ } while (nC1 <= nCol2); +/*N*/ nC1 = nCol1; +/*N*/ nC2 = nC1 + nXw; +/*N*/ nR1 = nR2 + 1; +/*N*/ nR2 = Min((USHORT)(nR1 + nYw), nRow2); +/*N*/ } while (nR1 <= nRow2); +/*N*/ } +/*N*/ if ( pClipRangeNames ) +/*N*/ delete [] pClipRangeNames; +/*N*/ // Listener aufbauen nachdem alles inserted wurde +/*N*/ StartListeningFromClip( nCol1, nRow1, nCol2, nRow2, rMark, nInsFlag ); +/*N*/ // nachdem alle Listener aufgebaut wurden, kann gebroadcastet werden +/*N*/ BroadcastFromClip( nCol1, nRow1, nCol2, nRow2, rMark, nInsFlag ); +/*N*/ if (bResetCut) +/*N*/ pClipDoc->bCutMode = FALSE; +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } +/*N*/ } +/*N*/ } + + + + +/*N*/ void ScDocument::GetClipArea(USHORT& nClipX, USHORT& nClipY, BOOL bIncludeFiltered) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if (bIsClip) +/*N*/ } + + + + + + + + + + + + +/*N*/ void ScDocument::PutCell( USHORT nCol, USHORT nRow, USHORT nTab, ScBaseCell* pCell, BOOL bForceTab ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ { +/*N*/ if ( bForceTab && !pTab[nTab] ) +/*N*/ { +/*N*/ BOOL bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags +/*N*/ +/*N*/ pTab[nTab] = new ScTable(this, nTab, +/*N*/ String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("temp")), +/*N*/ bExtras, bExtras); +/*N*/ ++nMaxTableNumber; +/*N*/ } +/*N*/ +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->PutCell( nCol, nRow, pCell ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::PutCell( const ScAddress& rPos, ScBaseCell* pCell, BOOL bForceTab ) +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( bForceTab && !pTab[nTab] ) +/*N*/ { +/*?*/ BOOL bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags +/*?*/ +/*?*/ pTab[nTab] = new ScTable(this, nTab, +/*?*/ String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("temp")), +/*?*/ bExtras, bExtras); +/*?*/ ++nMaxTableNumber; +/*N*/ } +/*N*/ +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->PutCell( rPos, pCell ); +/*N*/ } + + +/*N*/ BOOL ScDocument::SetString( USHORT nCol, USHORT nRow, USHORT nTab, const String& rString ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->SetString( nCol, nRow, nTab, rString ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScDocument::SetValue( USHORT nCol, USHORT nRow, USHORT nTab, const double& rVal ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->SetValue( nCol, nRow, rVal ); +/*N*/ } + + +/*N*/ void ScDocument::SetNote( USHORT nCol, USHORT nRow, USHORT nTab, const ScPostIt& rNote ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->SetNote( nCol, nRow, rNote ); +/*N*/ } + + +/*N*/ void ScDocument::GetString( USHORT nCol, USHORT nRow, USHORT nTab, String& rString ) +/*N*/ { +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ pTab[nTab]->GetString( nCol, nRow, rString ); +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + + +/*N*/ void ScDocument::GetInputString( USHORT nCol, USHORT nRow, USHORT nTab, String& rString ) +/*N*/ { +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ pTab[nTab]->GetInputString( nCol, nRow, rString ); +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + + +/*N*/ void ScDocument::GetValue( USHORT nCol, USHORT nRow, USHORT nTab, double& rValue ) +/*N*/ { +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ rValue = pTab[nTab]->GetValue( nCol, nRow ); +/*N*/ else +/*N*/ rValue = 0.0; +/*N*/ } + + +/*N*/ double ScDocument::GetValue( const ScAddress& rPos ) +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( pTab[nTab] ) +/*N*/ return pTab[nTab]->GetValue( rPos ); +/*N*/ return 0.0; +/*N*/ } + + +/*N*/ void ScDocument::GetNumberFormat( USHORT nCol, USHORT nRow, USHORT nTab, +/*N*/ sal_uInt32& rFormat ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ rFormat = pTab[nTab]->GetNumberFormat( nCol, nRow ); +/*N*/ return ; +/*N*/ } +/*N*/ rFormat = 0; +/*N*/ } + + +/*N*/ ULONG ScDocument::GetNumberFormat( const ScAddress& rPos ) const +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( pTab[nTab] ) +/*N*/ return pTab[nTab]->GetNumberFormat( rPos ); +/*N*/ return 0; +/*N*/ } + + +/*N*/ void ScDocument::GetNumberFormatInfo( short& nType, ULONG& nIndex, +/*N*/ const ScAddress& rPos, const ScFormulaCell& rFCell ) const +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( pTab[nTab] ) +/*N*/ { +/*N*/ nIndex = pTab[nTab]->GetNumberFormat( rPos ); +/*N*/ if ( (nIndex % SV_COUNTRY_LANGUAGE_OFFSET) == 0 ) +/*N*/ rFCell.GetFormatInfo( nType, nIndex ); +/*N*/ else +/*N*/ nType = GetFormatTable()->GetType( nIndex ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nType = NUMBERFORMAT_UNDEFINED; +/*N*/ nIndex = 0; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::GetNote( USHORT nCol, USHORT nRow, USHORT nTab, ScPostIt& rNote ) +/*N*/ { +/*N*/ BOOL bHasNote = FALSE; +/*N*/ +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ bHasNote = pTab[nTab]->GetNote( nCol, nRow, rNote ); +/*N*/ else +/*?*/ rNote.Clear(); +/*N*/ +/*N*/ return bHasNote; +/*N*/ } + + +/*N*/ CellType ScDocument::GetCellType( const ScAddress& rPos ) const +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( pTab[nTab] ) +/*N*/ return pTab[nTab]->GetCellType( rPos ); +/*N*/ return CELLTYPE_NONE; +/*N*/ } + + +/*N*/ void ScDocument::GetCellType( USHORT nCol, USHORT nRow, USHORT nTab, +/*N*/ CellType& rCellType ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ rCellType = pTab[nTab]->GetCellType( nCol, nRow ); +/*N*/ else +/*N*/ rCellType = CELLTYPE_NONE; +/*N*/ } + + +/*N*/ void ScDocument::GetCell( USHORT nCol, USHORT nRow, USHORT nTab, +/*N*/ ScBaseCell*& rpCell ) const +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ rpCell = pTab[nTab]->GetCell( nCol, nRow ); +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("GetCell ohne Tabelle"); +/*N*/ rpCell = NULL; +/*N*/ } +/*N*/ } + + +/*N*/ ScBaseCell* ScDocument::GetCell( const ScAddress& rPos ) const +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( pTab[nTab] ) +/*N*/ return pTab[nTab]->GetCell( rPos ); +/*N*/ +/*N*/ DBG_ERROR("GetCell ohne Tabelle"); +/*N*/ return NULL; +/*N*/ } + + +/*N*/ BOOL ScDocument::HasStringData( USHORT nCol, USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ return pTab[nTab]->HasStringData( nCol, nRow ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::HasValueData( USHORT nCol, USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( VALIDTAB(nTab) && pTab[nTab] ) +/*N*/ return pTab[nTab]->HasValueData( nCol, nRow ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + + + + + +/*N*/ void ScDocument::SetDirty() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ bAutoCalc = FALSE; // keine Mehrfachberechnung +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) pTab[i]->SetDirty(); +/*N*/ +/*N*/ // Charts werden zwar auch ohne AutoCalc im Tracking auf Dirty gesetzt, +/*N*/ // wenn alle Formeln dirty sind, werden die Charts aber nicht mehr erwischt +/*N*/ // (#45205#) - darum alle Charts nochmal explizit +/*N*/ if (pChartListenerCollection) +/*N*/ pChartListenerCollection->SetDirty(); +/*N*/ +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScDocument::SetDirty( const ScRange& rRange ) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ bAutoCalc = FALSE; // keine Mehrfachberechnung +/*N*/ USHORT nTab2 = rRange.aEnd.Tab(); +/*N*/ for (USHORT i=rRange.aStart.Tab(); i<=nTab2; i++) +/*N*/ if (pTab[i]) pTab[i]->SetDirty( rRange ); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScDocument::SetTableOpDirty( const ScRange& rRange ) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ bAutoCalc = FALSE; // no multiple recalculation +/*N*/ USHORT nTab2 = rRange.aEnd.Tab(); +/*N*/ for (USHORT i=rRange.aStart.Tab(); i<=nTab2; i++) +/*N*/ if (pTab[i]) pTab[i]->SetTableOpDirty( rRange ); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScDocument::AddTableOpFormulaCell( ScFormulaCell* pCell ) +/*N*/ { +/*N*/ ScInterpreterTableOpParams* p = aTableOpList.Last(); +/*N*/ if ( p && p->bCollectNotifications ) +/*N*/ { +/*N*/ if ( p->bRefresh ) +/*N*/ { // refresh pointers only +/*N*/ p->aNotifiedFormulaCells.push_back( pCell ); +/*N*/ } +/*N*/ else +/*N*/ { // init both, address and pointer +/*N*/ p->aNotifiedFormulaCells.push_back( pCell ); +/*N*/ p->aNotifiedFormulaPos.push_back( pCell->aPos ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::CalcAll() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( TRUE ); +/*N*/ USHORT i; +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) pTab[i]->SetDirtyVar(); +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) pTab[i]->CalcAll(); +/*N*/ ClearFormulaTree(); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + + + +/*N*/ void ScDocument::CompileXML() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = GetAutoCalc(); +/*N*/ SetAutoCalc( FALSE ); +/*N*/ ScProgress aProgress( GetDocumentShell(), ScGlobal::GetRscString( +/*N*/ STR_PROGRESS_CALCULATING ), GetXMLImportedFormulaCount() ); +/*N*/ +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) pTab[i]->CompileXML( aProgress ); +/*N*/ +/*N*/ if ( pCondFormList ) +/*N*/ pCondFormList->CompileXML(); +/*N*/ if ( pValidationList ) +/*N*/ pValidationList->CompileXML(); +/*N*/ +/*N*/ SetDirty(); +/*N*/ SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScDocument::CalcAfterLoad() +/*N*/ { +/*N*/ if (bIsClip) // Excel-Dateien werden aus dem Clipboard in ein Clip-Doc geladen +/*N*/ return; // dann wird erst beim Einfuegen in das richtige Doc berechnet +/*N*/ +/*N*/ bCalcingAfterLoad = TRUE; +/*N*/ USHORT i=0; +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) pTab[i]->CalcAfterLoad(); +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) pTab[i]->SetDirtyAfterLoad(); +/*N*/ bCalcingAfterLoad = FALSE; +/*N*/ +/*N*/ SetDetectiveDirty(FALSE); // noch keine wirklichen Aenderungen +/*N*/ } + + +/*N*/ USHORT ScDocument::GetErrCode( const ScAddress& rPos ) const +/*N*/ { +/*N*/ USHORT nTab = rPos.Tab(); +/*N*/ if ( pTab[nTab] ) +/*N*/ return pTab[nTab]->GetErrCode( rPos ); +/*N*/ return 0; +/*N*/ } + + +/*N*/ void ScDocument::ResetChanged( const ScRange& rRange ) +/*N*/ { +/*N*/ USHORT nStartTab = rRange.aStart.Tab(); +/*N*/ USHORT nEndTab = rRange.aEnd.Tab(); +/*N*/ for (USHORT nTab=nStartTab; nTab<=nEndTab; nTab++) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->ResetChanged( rRange ); +/*N*/ } + +// +// Spaltenbreiten / Zeilenhoehen -------------------------------------- +// + + +/*N*/ void ScDocument::SetColWidth( USHORT nCol, USHORT nTab, USHORT nNewWidth ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetColWidth( nCol, nNewWidth ); +/*N*/ } + + + + +/*N*/ void ScDocument::SetRowHeightRange( USHORT nStartRow, USHORT nEndRow, USHORT nTab, USHORT nNewHeight ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetRowHeightRange +/*N*/ ( nStartRow, nEndRow, nNewHeight, 1.0, 1.0 ); +/*N*/ } + + +/*N*/ void ScDocument::SetManualHeight( USHORT nStartRow, USHORT nEndRow, USHORT nTab, BOOL bManual ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetManualHeight( nStartRow, nEndRow, bManual ); +/*N*/ } + + +/*N*/ USHORT ScDocument::GetColWidth( USHORT nCol, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetColWidth( nCol ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + + +/*N*/ USHORT ScDocument::GetOriginalWidth( USHORT nCol, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetOriginalWidth( nCol ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + + + + +/*N*/ USHORT ScDocument::GetOriginalHeight( USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetOriginalHeight( nRow ); +/*N*/ DBG_ERROR("Wrong table number"); +/*N*/ return 0; +/*N*/ } + + +/*N*/ USHORT ScDocument::GetRowHeight( USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetRowHeight( nRow ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + + +/*N*/ USHORT ScDocument::GetHiddenRowCount( USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetHiddenRowCount( nRow ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + + + + + + +/*N*/ USHORT ScDocument::GetOptimalColWidth( USHORT nCol, USHORT nTab, OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bFormula, const ScMarkData* pMarkData, +/*N*/ BOOL bSimpleTextImport ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetOptimalColWidth( nCol, pDev, nPPTX, nPPTY, +/*N*/ rZoomX, rZoomY, bFormula, pMarkData, bSimpleTextImport ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + + + + +/*N*/ BOOL ScDocument::SetOptimalHeight( USHORT nStartRow, USHORT nEndRow, USHORT nTab, USHORT nExtra, +/*N*/ OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bShrink ) +/*N*/ { +/*N*/ //! MarkToMulti(); +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->SetOptimalHeight( nStartRow, nEndRow, nExtra, +/*N*/ pDev, nPPTX, nPPTY, rZoomX, rZoomY, bShrink ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return FALSE; +/*N*/ } + + +// +// Spalten-/Zeilen-Flags ---------------------------------------------- +// + +/*N*/ void ScDocument::ShowCol(USHORT nCol, USHORT nTab, BOOL bShow) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->ShowCol( nCol, bShow ); +/*N*/ } + + +/*N*/ void ScDocument::ShowRows(USHORT nRow1, USHORT nRow2, USHORT nTab, BOOL bShow) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->ShowRows( nRow1, nRow2, bShow ); +/*N*/ } + + + + +/*N*/ void ScDocument::SetRowFlags( USHORT nRow, USHORT nTab, BYTE nNewFlags ) +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetRowFlags( nRow, nNewFlags ); +/*N*/ } + + +/*N*/ BYTE ScDocument::GetColFlags( USHORT nCol, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetColFlags( nCol ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + +/*N*/ BYTE ScDocument::GetRowFlags( USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetRowFlags( nRow ); +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ return 0; +/*N*/ } + + + + + +/*N*/ USHORT ScDocument::GetLastChangedCol( USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetLastChangedCol(); +/*N*/ return 0; +/*N*/ } + +/*N*/ USHORT ScDocument::GetLastChangedRow( USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetLastChangedRow(); +/*N*/ return 0; +/*N*/ } + + +/*N*/ USHORT ScDocument::GetNextDifferentChangedCol( USHORT nTab, USHORT nStart) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ { +/*N*/ BYTE nStartFlags = pTab[nTab]->GetColFlags(nStart); +/*N*/ USHORT nStartWidth = pTab[nTab]->GetOriginalWidth(nStart); +/*N*/ for (USHORT nCol = nStart + 1; nCol <= MAXCOL; nCol++) +/*N*/ { +/*N*/ if (((nStartFlags & CR_MANUALBREAK) != (pTab[nTab]->GetColFlags(nCol) & CR_MANUALBREAK)) || +/*N*/ (nStartWidth != pTab[nTab]->GetOriginalWidth(nCol)) || +/*N*/ ((nStartFlags & CR_HIDDEN) != (pTab[nTab]->GetColFlags(nCol) & CR_HIDDEN)) ) +/*N*/ return nCol; +/*N*/ } +/*N*/ return MAXCOL; +/*N*/ } +/*N*/ return 0; +/*N*/ } + +/*N*/ USHORT ScDocument::GetNextDifferentChangedRow( USHORT nTab, USHORT nStart, bool bCareManualSize) const +/*N*/ { +/*N*/ if ( nTab<=MAXTAB && pTab[nTab] ) +/*N*/ { +/*N*/ BYTE nStartFlags = pTab[nTab]->GetRowFlags(nStart); +/*N*/ USHORT nStartHeight = pTab[nTab]->GetOriginalHeight(nStart); +/*N*/ for (USHORT nRow = nStart + 1; nRow <= MAXROW; nRow++) +/*N*/ { +/*N*/ if (((nStartFlags & CR_MANUALBREAK) != (pTab[nTab]->GetRowFlags(nRow) & CR_MANUALBREAK)) || +/*N*/ ((nStartFlags & CR_MANUALSIZE) != (pTab[nTab]->GetRowFlags(nRow) & CR_MANUALSIZE)) || +/*N*/ (bCareManualSize && (nStartFlags & CR_MANUALSIZE) && (nStartHeight != pTab[nTab]->GetOriginalHeight(nRow))) || +/*N*/ (!bCareManualSize && ((nStartHeight != pTab[nTab]->GetOriginalHeight(nRow))))) +/*N*/ return nRow; +/*N*/ } +/*N*/ return MAXROW; +/*N*/ } +/*N*/ return 0; +/*N*/ } + +/*N*/ BOOL ScDocument::GetColDefault( USHORT nTab, USHORT nCol, USHORT nLastRow, USHORT& nDefault) +/*N*/ { +/*N*/ BOOL bRet(FALSE); +/*N*/ nDefault = 0; +/*N*/ ScDocAttrIterator aDocAttrItr(this, nTab, nCol, 0, nCol, nLastRow); +/*N*/ USHORT nColumn, nStartRow, nEndRow; +/*N*/ const ScPatternAttr* pAttr = aDocAttrItr.GetNext(nColumn, nStartRow, nEndRow); +/*N*/ if (nEndRow < nLastRow) +/*N*/ { +/*N*/ ScDefaultAttrSet aSet; +/*N*/ ScDefaultAttrSet::iterator aItr = aSet.end(); +/*N*/ while (pAttr) +/*N*/ { +/*N*/ ScDefaultAttr aAttr(pAttr); +/*N*/ aItr = aSet.find(aAttr); +/*N*/ if (aItr == aSet.end()) +/*N*/ { +/*N*/ aAttr.nCount = nEndRow - nStartRow + 1; +/*N*/ aAttr.nFirst = nStartRow; +/*N*/ aSet.insert(aAttr); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aAttr.nCount = aItr->nCount + nEndRow - nStartRow + 1; +/*N*/ aAttr.nFirst = aItr->nFirst; +/*N*/ aSet.erase(aItr); +/*N*/ aSet.insert(aAttr); +/*N*/ } +/*N*/ pAttr = aDocAttrItr.GetNext(nColumn, nStartRow, nEndRow); +/*N*/ } +/*N*/ ScDefaultAttrSet::iterator aDefaultItr = aSet.begin(); +/*N*/ aItr = aDefaultItr; +/*N*/ aItr++; +/*N*/ while (aItr != aSet.end()) +/*N*/ { +/*N*/ if (aItr->nCount > aDefaultItr->nCount) +/*N*/ aDefaultItr = aItr; +/*N*/ aItr++; +/*N*/ } +/*N*/ nDefault = aDefaultItr->nFirst; +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ else +/*N*/ bRet = TRUE; +/*N*/ return bRet; +/*N*/ } + +/*N*/ BOOL ScDocument::GetRowDefault( USHORT nTab, USHORT nRow, USHORT nLastCol, USHORT& nDefault) +/*N*/ { +/*N*/ BOOL bRet(FALSE); +/*N*/ return bRet; +/*N*/ } + +// +// Attribute ---------------------------------------------------------- +// + +/*N*/ const SfxPoolItem* ScDocument::GetAttr( USHORT nCol, USHORT nRow, USHORT nTab, USHORT nWhich ) const +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ { +/*N*/ const SfxPoolItem* pTemp = pTab[nTab]->GetAttr( nCol, nRow, nWhich ); +/*N*/ if (pTemp) +/*N*/ return pTemp; +/*N*/ else +/*N*/ DBG_ERROR( "Attribut Null" ); +/*N*/ } +/*N*/ return &xPoolHelper->GetDocPool()->GetDefaultItem( nWhich ); +/*N*/ } + + +/*N*/ const ScPatternAttr* ScDocument::GetPattern( USHORT nCol, USHORT nRow, USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetPattern( nCol, nRow ); +/*N*/ return NULL; +/*N*/ } + + +/*N*/ void ScDocument::ApplyAttr( USHORT nCol, USHORT nRow, USHORT nTab, const SfxPoolItem& rAttr ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->ApplyAttr( nCol, nRow, rAttr ); +/*N*/ } + + + + +/*N*/ void ScDocument::ApplyPatternArea( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, +/*N*/ const ScMarkData& rMark, +/*N*/ const ScPatternAttr& rAttr ) +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ if (rMark.GetTableSelect(i)) +/*N*/ pTab[i]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr ); +/*N*/ } + + +/*N*/ void ScDocument::ApplyPatternAreaTab( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nTab, const ScPatternAttr& rAttr ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr ); +/*N*/ } + + + + + +/*N*/ void ScDocument::ApplyStyleArea( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, +/*N*/ const ScMarkData& rMark, +/*N*/ const ScStyleSheet& rStyle) +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ if (rMark.GetTableSelect(i)) +/*N*/ pTab[i]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle ); +/*N*/ } + + +/*N*/ void ScDocument::ApplyStyleAreaTab( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nTab, const ScStyleSheet& rStyle) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ pTab[nTab]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle ); +/*N*/ } + + +/*N*/ void ScDocument::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark) +/*N*/ { +/*N*/ // ApplySelectionStyle needs multi mark +/*N*/ if ( rMark.IsMarked() && !rMark.IsMultiMarked() ) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea( aRange ); +/*N*/ ApplyStyleArea( aRange.aStart.Col(), aRange.aStart.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row(), rMark, rStyle ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if ( pTab[i] && rMark.GetTableSelect(i) ) +/*N*/ pTab[i]->ApplySelectionStyle( rStyle, rMark ); +/*N*/ } +/*N*/ } + +/*N*/ const ScStyleSheet* ScDocument::GetSelectionStyle( const ScMarkData& rMark ) const +/*N*/ { +/*N*/ BOOL bEqual = TRUE; +/*N*/ BOOL bFound; +/*N*/ USHORT i; +/*N*/ +/*N*/ const ScStyleSheet* pStyle = NULL; +/*N*/ const ScStyleSheet* pNewStyle; +/*N*/ +/*N*/ if ( rMark.IsMultiMarked() ) +/*N*/ for (i=0; i<=MAXTAB && bEqual; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ { +/*N*/ pNewStyle = pTab[i]->GetSelectionStyle( rMark, bFound ); +/*N*/ if (bFound) +/*N*/ { +/*N*/ if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) ) +/*N*/ bEqual = FALSE; // unterschiedliche +/*N*/ pStyle = pNewStyle; +/*N*/ } +/*N*/ } +/*N*/ if ( rMark.IsMarked() ) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea( aRange ); +/*N*/ for (i=aRange.aStart.Tab(); i<=aRange.aEnd.Tab() && bEqual; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ { +/*N*/ pNewStyle = pTab[i]->GetAreaStyle( bFound, +/*N*/ aRange.aStart.Col(), aRange.aStart.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row() ); +/*N*/ if (bFound) +/*N*/ { +/*N*/ if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) ) +/*N*/ bEqual = FALSE; // unterschiedliche +/*N*/ pStyle = pNewStyle; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual ? pStyle : NULL; +/*N*/ } + + +/*N*/ void ScDocument::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, BOOL bRemoved, +/*N*/ OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY ) +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->StyleSheetChanged +/*N*/ ( pStyleSheet, bRemoved, pDev, nPPTX, nPPTY, rZoomX, rZoomY ); +/*N*/ +/*N*/ if ( pStyleSheet && pStyleSheet->GetName() == ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ) +/*N*/ { +/*N*/ // update attributes for all note objects +/*N*/ +/*N*/ ScDetectiveFunc aFunc( this, 0 ); +/*N*/ aFunc.UpdateAllComments(); +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::IsStyleSheetUsed( const ScStyleSheet& rStyle, BOOL bGatherAllStyles ) const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return FALSE; //STRIP001 +/*N*/ } + + + + + +/*N*/ BOOL ScDocument::ApplyFlagsTab( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nTab, INT16 nFlags ) +/*N*/ { +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->ApplyFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags ); +/*N*/ +/*N*/ DBG_ERROR("ApplyFlags: falsche Tabelle"); +/*N*/ return FALSE; +/*N*/ } + + + + +/*N*/ BOOL ScDocument::RemoveFlagsTab( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nTab, INT16 nFlags ) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*N*/ return FALSE; +/*N*/ } + + + + + + +/*N*/ ScPatternAttr* ScDocument::CreateSelectionPattern( const ScMarkData& rMark, BOOL bDeep ) +/*N*/ { +/*N*/ SfxItemSet* pSet = NULL; +/*N*/ USHORT i; +/*N*/ +/*N*/ if ( rMark.IsMultiMarked() ) // multi selection +/*N*/ { +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ pTab[i]->MergeSelectionPattern( &pSet, rMark, bDeep ); +/*N*/ } +/*N*/ if ( rMark.IsMarked() ) // simle selection +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea(aRange); +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ pTab[i]->MergePatternArea( &pSet, +/*N*/ aRange.aStart.Col(), aRange.aStart.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row(), bDeep ); +/*N*/ } +/*N*/ +/*N*/ DBG_ASSERT( pSet, "SelectionPattern Null" ); +/*N*/ if (pSet) +/*N*/ return new ScPatternAttr( pSet ); +/*N*/ else +/*?*/ return new ScPatternAttr( GetPool() ); // empty +/*N*/ } + + +/*N*/ void ScDocument::GetSelectionFrame( const ScMarkData& rMark, +/*N*/ SvxBoxItem& rLineOuter, +/*N*/ SvxBoxInfoItem& rLineInner ) +/*N*/ { +/*N*/ rLineOuter.SetLine(NULL, BOX_LINE_TOP); +/*N*/ rLineOuter.SetLine(NULL, BOX_LINE_BOTTOM); +/*N*/ rLineOuter.SetLine(NULL, BOX_LINE_LEFT); +/*N*/ rLineOuter.SetLine(NULL, BOX_LINE_RIGHT); +/*N*/ rLineOuter.SetDistance(0); +/*N*/ +/*N*/ rLineInner.SetLine(NULL, BOXINFO_LINE_HORI); +/*N*/ rLineInner.SetLine(NULL, BOXINFO_LINE_VERT); +/*N*/ rLineInner.SetTable(TRUE); +/*N*/ rLineInner.SetDist((BOOL)FALSE); +/*N*/ rLineInner.SetMinDist(FALSE); +/*N*/ +/*N*/ ScLineFlags aFlags; +/*N*/ +/*N*/ if (rMark.IsMarked()) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea(aRange); +/*N*/ rLineInner.SetTable(aRange.aStart!=aRange.aEnd); +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i] && rMark.GetTableSelect(i)) +/*N*/ pTab[i]->MergeBlockFrame( &rLineOuter, &rLineInner, aFlags, +/*N*/ aRange.aStart.Col(), aRange.aStart.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row() ); +/*N*/ } +/*N*/ +/*N*/ // Don't care Status auswerten +/*N*/ +/*N*/ rLineInner.SetValid( VALID_LEFT, ( aFlags.nLeft != SC_LINE_DONTCARE ) ); +/*N*/ rLineInner.SetValid( VALID_RIGHT, ( aFlags.nRight != SC_LINE_DONTCARE ) ); +/*N*/ rLineInner.SetValid( VALID_TOP, ( aFlags.nTop != SC_LINE_DONTCARE ) ); +/*N*/ rLineInner.SetValid( VALID_BOTTOM, ( aFlags.nBottom != SC_LINE_DONTCARE ) ); +/*N*/ rLineInner.SetValid( VALID_HORI, ( aFlags.nHori != SC_LINE_DONTCARE ) ); +/*N*/ rLineInner.SetValid( VALID_VERT, ( aFlags.nVert != SC_LINE_DONTCARE ) ); +/*N*/ } + + +/*N*/ BOOL ScDocument::HasAttrib( USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, USHORT nMask ) +/*N*/ { +/*N*/ if ( nMask & HASATTR_ROTATE ) +/*N*/ { +/*N*/ // Attribut im Dokument ueberhaupt verwendet? +/*N*/ // (wie in fillinfo) +/*N*/ +/*N*/ ScDocumentPool* pPool = xPoolHelper->GetDocPool(); +/*N*/ +/*N*/ BOOL bAnyItem = FALSE; +/*N*/ USHORT nRotCount = pPool->GetItemCount( ATTR_ROTATE_VALUE ); +/*N*/ for (USHORT nItem=0; nItem<nRotCount; nItem++) +/*N*/ if (pPool->GetItem( ATTR_ROTATE_VALUE, nItem )) +/*N*/ { +/*N*/ bAnyItem = TRUE; +/*N*/ break; +/*N*/ } +/*N*/ if (!bAnyItem) +/*N*/ nMask &= ~HASATTR_ROTATE; +/*N*/ } +/*N*/ +/*N*/ if ( nMask & HASATTR_RTL ) +/*N*/ { +/*?*/ // first check if right-to left is in the pool at all +/*?*/ // (the same item is used in cell and page format) +/*?*/ +/*?*/ ScDocumentPool* pPool = xPoolHelper->GetDocPool(); +/*?*/ +/*?*/ BOOL bHasRtl = FALSE; +/*?*/ USHORT nDirCount = pPool->GetItemCount( ATTR_WRITINGDIR ); +/*?*/ for (USHORT nItem=0; nItem<nDirCount; nItem++) +/*?*/ { +/*?*/ const SfxPoolItem* pItem = pPool->GetItem( ATTR_WRITINGDIR, nItem ); +/*?*/ if ( pItem && ((const SvxFrameDirectionItem*)pItem)->GetValue() == FRMDIR_HORI_RIGHT_TOP ) +/*?*/ { +/*?*/ bHasRtl = TRUE; +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ if (!bHasRtl) +/*?*/ nMask &= ~HASATTR_RTL; +/*N*/ } +/*N*/ +/*N*/ if (!nMask) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=nTab1; i<=nTab2 && !bFound; i++) +/*N*/ if (pTab[i]) +/*N*/ { +/*N*/ if ( nMask & HASATTR_RTL ) +/*N*/ { +/*?*/ if ( GetEditTextDirection(i) == EE_HTEXTDIR_R2L ) // sheet default +/*?*/ bFound = TRUE; +/*N*/ } +/*N*/ +/*N*/ bFound |= pTab[i]->HasAttrib( nCol1, nRow1, nCol2, nRow2, nMask ); +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + +/*N*/ BOOL ScDocument::HasAttrib( const ScRange& rRange, USHORT nMask ) +/*N*/ { +/*N*/ return HasAttrib( rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(), +/*N*/ rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), +/*N*/ nMask ); +/*N*/ } + +/*N*/ BOOL ScDocument::IsBlockEmpty( USHORT nTab, USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow ) const +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (VALIDTAB(nTab)) +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScDocument::LockTable(USHORT nTab) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->LockTable(); +/*N*/ else +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ } + + +/*N*/ void ScDocument::UnlockTable(USHORT nTab) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->UnlockTable(); +/*N*/ else +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ } + + +/*N*/ BOOL ScDocument::IsBlockEditable( USHORT nTab, USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, +/*N*/ BOOL* pOnlyNotBecauseOfMatrix /* = NULL */ ) const +/*N*/ { +/*N*/ // import into read-only document is possible - must be extended if other filters use api +/*N*/ if ( pShell && pShell->IsReadOnly() && !bImportingXML ) +/*N*/ { +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ return FALSE; +/*N*/ } +/*N*/ +/*N*/ if (VALIDTAB(nTab)) +/*N*/ if (pTab[nTab]) +/*N*/ return pTab[nTab]->IsBlockEditable( nStartCol, nStartRow, nEndCol, +/*N*/ nEndRow, pOnlyNotBecauseOfMatrix ); +/*N*/ +/*N*/ DBG_ERROR("Falsche Tabellennummer"); +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScDocument::IsSelectionEditable( const ScMarkData& rMark, +/*N*/ BOOL* pOnlyNotBecauseOfMatrix /* = NULL */ ) const +/*N*/ { +/*N*/ // import into read-only document is possible - must be extended if other filters use api +/*N*/ if ( pShell && pShell->IsReadOnly() && !bImportingXML ) +/*N*/ { +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ return FALSE; +/*N*/ } +/*N*/ +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea(aRange); +/*N*/ +/*N*/ BOOL bOk = TRUE; +/*N*/ BOOL bMatrix = ( pOnlyNotBecauseOfMatrix != NULL ); +/*N*/ for ( USHORT i=0; i<=MAXTAB && (bOk || bMatrix); i++ ) +/*N*/ { +/*N*/ if ( pTab[i] && rMark.GetTableSelect(i) ) +/*N*/ { +/*N*/ if (rMark.IsMarked()) +/*N*/ { +/*N*/ if ( !pTab[i]->IsBlockEditable( aRange.aStart.Col(), +/*N*/ aRange.aStart.Row(), aRange.aEnd.Col(), +/*N*/ aRange.aEnd.Row(), pOnlyNotBecauseOfMatrix ) ) +/*N*/ { +/*N*/ bOk = FALSE; +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ bMatrix = *pOnlyNotBecauseOfMatrix; +/*N*/ } +/*N*/ } +/*N*/ if (rMark.IsMultiMarked()) +/*N*/ { +/*N*/ if ( !pTab[i]->IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix ) ) +/*N*/ { +/*N*/ bOk = FALSE; +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ bMatrix = *pOnlyNotBecauseOfMatrix; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = ( !bOk && bMatrix ); +/*N*/ +/*N*/ return bOk; +/*N*/ } + + + + + + + + +/*N*/ BOOL ScDocument::GetMatrixFormulaRange( const ScAddress& rCellPos, ScRange& rMatrix ) +/*N*/ { +/*N*/ // if rCell is part of a matrix formula, return its complete range +/*N*/ +/*N*/ BOOL bRet = FALSE; +/*N*/ ScBaseCell* pCell = GetCell( rCellPos ); +/*N*/ if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ScAddress aOrigin = rCellPos; +/*N*/ if ( ((ScFormulaCell*)pCell)->GetMatrixOrigin( aOrigin ) ) +/*N*/ { +/*N*/ if ( aOrigin != rCellPos ) +/*N*/ pCell = GetCell( aOrigin ); +/*N*/ if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ USHORT nSizeX, nSizeY; +/*N*/ ((ScFormulaCell*)pCell)->GetMatColsRows(nSizeX,nSizeY); +/*N*/ if ( !(nSizeX && nSizeY) ) +/*N*/ { +/*?*/ // GetMatrixEdge computes also dimensions of the matrix +/*?*/ // if not already done (may occur if document is loaded +/*?*/ // from old file format). +/*?*/ // Needs an "invalid" initialized address. +/*?*/ aOrigin = UINT32(0xffffffff); +/*?*/ ((ScFormulaCell*)pCell)->GetMatrixEdge(aOrigin); +/*?*/ ((ScFormulaCell*)pCell)->GetMatColsRows(nSizeX,nSizeY); +/*N*/ } +/*N*/ if ( nSizeX && nSizeY ) +/*N*/ { +/*N*/ ScAddress aEnd( aOrigin.Col() + nSizeX - 1, +/*N*/ aOrigin.Row() + nSizeY - 1, +/*N*/ aOrigin.Tab() ); +/*N*/ +/*N*/ rMatrix.aStart = aOrigin; +/*N*/ rMatrix.aEnd = aEnd; +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + + +/*N*/ BOOL ScDocument::ExtendOverlapped( USHORT& rStartCol, USHORT& rStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nTab ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ if ( ValidColRow(rStartCol,rStartRow) && ValidColRow(nEndCol,nEndRow) && nTab<=MAXTAB ) +/*N*/ { +/*N*/ if (pTab[nTab]) +/*N*/ { +/*N*/ USHORT nCol; +/*N*/ USHORT nOldCol = rStartCol; +/*N*/ USHORT nOldRow = rStartRow; +/*N*/ for (nCol=nOldCol; nCol<=nEndCol; nCol++) +/*N*/ while (((ScMergeFlagAttr*)GetAttr(nCol,rStartRow,nTab,ATTR_MERGE_FLAG))-> +/*N*/ IsVerOverlapped()) +/*N*/ --rStartRow; +/*N*/ +/*N*/ //! weiterreichen ? +/*N*/ +/*N*/ ScAttrArray* pAttrArray = pTab[nTab]->aCol[nOldCol].pAttrArray; +/*N*/ short nIndex; +/*N*/ pAttrArray->Search( nOldRow, nIndex ); +/*N*/ USHORT nAttrPos = nOldRow; +/*N*/ while (nAttrPos<=nEndRow) +/*N*/ { +/*N*/ DBG_ASSERT( nIndex < (short) pAttrArray->nCount, "Falscher Index im AttrArray" ); +/*N*/ +/*N*/ if (((ScMergeFlagAttr&)pAttrArray->pData[nIndex].pPattern-> +/*N*/ GetItem(ATTR_MERGE_FLAG)).IsHorOverlapped()) +/*N*/ { +/*N*/ USHORT nLoopEndRow = Min( nEndRow, pAttrArray->pData[nIndex].nRow ); +/*N*/ for (USHORT nAttrRow = nAttrPos; nAttrRow <= nLoopEndRow; nAttrRow++) +/*N*/ { +/*N*/ USHORT nTempCol = nOldCol; +/*N*/ do +/*N*/ --nTempCol; +/*N*/ while (((ScMergeFlagAttr*)GetAttr(nTempCol,nAttrRow,nTab,ATTR_MERGE_FLAG)) +/*N*/ ->IsHorOverlapped()); +/*N*/ if (nTempCol < rStartCol) +/*N*/ rStartCol = nTempCol; +/*N*/ } +/*N*/ } +/*N*/ nAttrPos = pAttrArray->pData[nIndex].nRow + 1; +/*N*/ ++nIndex; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("ExtendOverlapped: falscher Bereich"); +/*N*/ +/*N*/ return bFound; +/*N*/ } + + +/*N*/ BOOL ScDocument::ExtendMerge( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT& rEndCol, USHORT& rEndRow, +/*N*/ USHORT nTab, BOOL bRefresh, BOOL bAttrs ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ if ( ValidColRow(nStartCol,nStartRow) && ValidColRow(rEndCol,rEndRow) && nTab<=MAXTAB ) +/*N*/ { +/*N*/ if (pTab[nTab]) +/*N*/ bFound = pTab[nTab]->ExtendMerge( nStartCol, nStartRow, rEndCol, rEndRow, bRefresh, bAttrs ); +/*N*/ +/*N*/ if (bRefresh) +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ RefreshAutoFilter( nStartCol, nStartRow, rEndCol, rEndRow, nTab ); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("ExtendMerge: falscher Bereich"); +/*N*/ +/*N*/ return bFound; +/*N*/ } + + +/*N*/ BOOL ScDocument::ExtendMerge( ScRange& rRange, BOOL bRefresh, BOOL bAttrs ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nStartTab = rRange.aStart.Tab(); +/*N*/ USHORT nEndTab = rRange.aEnd.Tab(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ for (USHORT nTab = nStartTab; nTab <= nEndTab; nTab++ ) +/*N*/ { +/*N*/ USHORT nExtendCol = rRange.aEnd.Col(); +/*N*/ USHORT nExtendRow = rRange.aEnd.Row(); +/*N*/ if (ExtendMerge( rRange.aStart.Col(), rRange.aStart.Row(), +/*N*/ nExtendCol, nExtendRow, +/*N*/ nTab, bRefresh, bAttrs ) ) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ if (nExtendCol > nEndCol) nEndCol = nExtendCol; +/*N*/ if (nExtendRow > nEndRow) nEndRow = nExtendRow; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ rRange.aEnd.SetCol(nEndCol); +/*N*/ rRange.aEnd.SetRow(nEndRow); +/*N*/ +/*N*/ return bFound; +/*N*/ } + + +/*N*/ BOOL ScDocument::ExtendOverlapped( ScRange& rRange ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nStartTab = rRange.aStart.Tab(); +/*N*/ USHORT nEndTab = rRange.aEnd.Tab(); +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ +/*N*/ PutInOrder( nStartTab, nEndTab ); +/*N*/ for (USHORT nTab = nStartTab; nTab <= nEndTab; nTab++ ) +/*N*/ { +/*N*/ USHORT nExtendCol = rRange.aStart.Col(); +/*N*/ USHORT nExtendRow = rRange.aStart.Row(); +/*N*/ ExtendOverlapped( nExtendCol, nExtendRow, +/*N*/ rRange.aEnd.Col(), rRange.aEnd.Row(), nTab ); +/*N*/ if (nExtendCol < nStartCol) +/*N*/ { +/*N*/ nStartCol = nExtendCol; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if (nExtendRow < nStartRow) +/*N*/ { +/*N*/ nStartRow = nExtendRow; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ rRange.aStart.SetCol(nStartCol); +/*N*/ rRange.aStart.SetRow(nStartRow); +/*N*/ +/*N*/ return bFound; +/*N*/ } + + + +/*N*/ void ScDocument::SetAutoFilterFlags() +/*N*/ { +/*N*/ USHORT nCount = pDBCollection->GetCount(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDBData* pData = (*pDBCollection)[i]; +/*N*/ USHORT nDBTab; +/*N*/ USHORT nDBStartCol; +/*N*/ USHORT nDBStartRow; +/*N*/ USHORT nDBEndCol; +/*N*/ USHORT nDBEndRow; +/*N*/ pData->GetArea( nDBTab, nDBStartCol,nDBStartRow, nDBEndCol,nDBEndRow ); +/*N*/ pData->SetAutoFilter( HasAttrib( nDBStartCol,nDBStartRow,nDBTab, +/*N*/ nDBEndCol,nDBStartRow,nDBTab, HASATTR_AUTOFILTER ) ); +/*N*/ } +/*N*/ } + + + + + + + + +/*N*/ void ScDocument::ApplySelectionFrame( const ScMarkData& rMark, +/*N*/ const SvxBoxItem* pLineOuter, +/*N*/ const SvxBoxInfoItem* pLineInner ) +/*N*/ { +/*N*/ if (rMark.IsMarked()) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea(aRange); +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ if (rMark.GetTableSelect(i)) +/*N*/ pTab[i]->ApplyBlockFrame( pLineOuter, pLineInner, +/*N*/ aRange.aStart.Col(), aRange.aStart.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row() ); +/*N*/ } +/*N*/ } + + + + +/*N*/ void ScDocument::ApplySelectionPattern( const ScPatternAttr& rAttr, const ScMarkData& rMark ) +/*N*/ { +/*N*/ const SfxItemSet* pSet = &rAttr.GetItemSet(); +/*N*/ BOOL bSet = FALSE; +/*N*/ USHORT i; +/*N*/ for (i=ATTR_PATTERN_START; i<=ATTR_PATTERN_END && !bSet; i++) +/*N*/ if (pSet->GetItemState(i) == SFX_ITEM_SET) +/*N*/ bSet = TRUE; +/*N*/ +/*N*/ if (bSet) +/*N*/ { +/*N*/ // ApplySelectionCache needs multi mark +/*N*/ if ( rMark.IsMarked() && !rMark.IsMultiMarked() ) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rMark.GetMarkArea( aRange ); +/*N*/ ApplyPatternArea( aRange.aStart.Col(), aRange.aStart.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row(), rMark, rAttr ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SfxItemPoolCache aCache( xPoolHelper->GetDocPool(), pSet ); +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (pTab[i]) +/*N*/ if (rMark.GetTableSelect(i)) +/*N*/ pTab[i]->ApplySelectionCache( &aCache, rMark ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScDocument::ChangeSelectionIndent( BOOL bIncrement, const ScMarkData& rMark ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ } + + +/*N*/ void ScDocument::ClearSelectionItems( const USHORT* pWhich, const ScMarkData& rMark ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ } + + + + + + +/*N*/ ScPatternAttr* ScDocument::GetDefPattern() const +/*N*/ { +/*N*/ return (ScPatternAttr*) &xPoolHelper->GetDocPool()->GetDefaultItem(ATTR_PATTERN); +/*N*/ } + + +/*N*/ ScDocumentPool* ScDocument::GetPool() +/*N*/ { +/*N*/ return xPoolHelper->GetDocPool(); +/*N*/ } + + + +/*N*/ ScStyleSheetPool* ScDocument::GetStyleSheetPool() const +/*N*/ { +/*N*/ return xPoolHelper->GetStylePool(); +/*N*/ } + + + + + + +/*N*/ void ScDocument::GetNextPos( USHORT& rCol, USHORT& rRow, USHORT nTab, short nMovX, short nMovY, +/*N*/ BOOL bMarked, BOOL bUnprotected, const ScMarkData& rMark ) +/*N*/ { +/*N*/ DBG_ASSERT( !nMovX || !nMovY, "GetNextPos: nur X oder Y" ); +/*N*/ +/*N*/ ScMarkData aCopyMark = rMark; +/*N*/ aCopyMark.SetMarking(FALSE); +/*N*/ aCopyMark.MarkToMulti(); +/*N*/ +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->GetNextPos( rCol, rRow, nMovX, nMovY, bMarked, bUnprotected, aCopyMark ); +/*N*/ } + +// +// Datei-Operationen +// + + +/*N*/ void ScDocument::UpdStlShtPtrsFrmNms() +/*N*/ { +/*N*/ ScPatternAttr::pDoc = this; +/*N*/ +/*N*/ ScDocumentPool* pPool = xPoolHelper->GetDocPool(); +/*N*/ +/*N*/ USHORT nCount = pPool->GetItemCount(ATTR_PATTERN); +/*N*/ ScPatternAttr* pPattern; +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ pPattern = (ScPatternAttr*)pPool->GetItem(ATTR_PATTERN, i); +/*N*/ if (pPattern) +/*N*/ pPattern->UpdateStyleSheet(); +/*N*/ } +/*N*/ ((ScPatternAttr&)pPool->GetDefaultItem(ATTR_PATTERN)).UpdateStyleSheet(); +/*N*/ } + + + + +/*N*/ void lcl_RemoveMergeFromStyles( ScStyleSheetPool* pStylePool ) +/*N*/ { +/*N*/ pStylePool->SetSearchMask( SFX_STYLE_FAMILY_ALL ); +/*N*/ +/*N*/ USHORT nCount = pStylePool->Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ // in alten Versionen wurden statt SFXSTYLEBIT_USERDEF alle Bits gesetzt +/*N*/ SfxStyleSheetBase* pStyle = (*pStylePool)[i]; +/*N*/ if ( pStyle->GetMask() & SFXSTYLEBIT_READONLY ) +/*N*/ pStyle->SetMask( pStyle->GetMask() & ~SFXSTYLEBIT_READONLY ); +/*N*/ +/*N*/ SfxItemSet& rSet = pStyle->GetItemSet(); +/*N*/ rSet.ClearItem( ATTR_MERGE ); +/*N*/ rSet.ClearItem( ATTR_MERGE_FLAG ); +/*N*/ +/*N*/ // Das SvxBoxInfoItem wurde bis zur 358 falsch geladen, so dass +/*N*/ // Seitenvorlagen falsche Items mit bDist = FALSE enthalten koennen +/*N*/ if ( pStyle->GetFamily() == SFX_STYLE_FAMILY_PAGE ) +/*N*/ { +/*N*/ const SvxBoxInfoItem& rPageInfo = (const SvxBoxInfoItem&)rSet.Get(ATTR_BORDER_INNER); +/*N*/ if ( !rPageInfo.IsDist() ) +/*N*/ { +/*N*/ DBG_WARNING("altes SvxBoxInfoItem muss korrigiert werden"); +/*N*/ SvxBoxInfoItem aNew( rPageInfo ); +/*N*/ aNew.SetDist( TRUE ); +/*N*/ rSet.Put( aNew ); +/*N*/ } +/*N*/ // Das gilt fuer alle Hdr/Ftr-SetItems, darum kann das SetItem auch +/*N*/ // direkt im Pool geaendert werden (const weggecastet): +/*N*/ SfxItemSet& rHdrSet = ((SvxSetItem&)rSet.Get(ATTR_PAGE_HEADERSET)).GetItemSet(); +/*N*/ const SvxBoxInfoItem& rHdrInfo = (const SvxBoxInfoItem&)rHdrSet.Get(ATTR_BORDER_INNER); +/*N*/ if ( !rHdrInfo.IsDist() ) +/*N*/ { +/*N*/ DBG_WARNING("altes SvxBoxInfoItem muss korrigiert werden"); +/*N*/ SvxBoxInfoItem aNew( rHdrInfo ); +/*N*/ aNew.SetDist( TRUE ); +/*N*/ rHdrSet.Put( aNew ); +/*N*/ } +/*N*/ SfxItemSet& rFtrSet = ((SvxSetItem&)rSet.Get(ATTR_PAGE_FOOTERSET)).GetItemSet(); +/*N*/ const SvxBoxInfoItem& rFtrInfo = (const SvxBoxInfoItem&)rFtrSet.Get(ATTR_BORDER_INNER); +/*N*/ if ( !rFtrInfo.IsDist() ) +/*N*/ { +/*N*/ DBG_WARNING("altes SvxBoxInfoItem muss korrigiert werden"); +/*N*/ SvxBoxInfoItem aNew( rFtrInfo ); +/*N*/ aNew.SetDist( TRUE ); +/*N*/ rFtrSet.Put( aNew ); +/*N*/ } +/*N*/ const SfxUInt16Item& rScaleItem = (const SfxUInt16Item&)rSet.Get(ATTR_PAGE_SCALE); +/*N*/ USHORT nScale = rScaleItem.GetValue(); +/*N*/ //! Extra-Konstanten fuer Seitenformat? +/*N*/ // 0 ist erlaubt (wird gesetzt bei Scale To Pages) +/*N*/ if ( nScale != 0 && ( nScale < MINZOOM || nScale > MAXZOOM ) ) +/*N*/ { +/*?*/ // konnte anscheinend mal irgendwie kaputtgehen (#34508#) +/*?*/ DBG_WARNING("kaputter Zoom im Seitenformat muss korrigiert werden"); +/*?*/ rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, 100 ) ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScDocument::LoadPool( SvStream& rStream, BOOL bLoadRefCounts ) +/*N*/ { +/*N*/ // bLoadingDone wird beim Laden des StylePools (ScStyleSheet::GetItemSet) gebraucht +/*N*/ bLoadingDone = FALSE; +/*N*/ +/*N*/ USHORT nOldBufSize = rStream.GetBufferSize(); +/*N*/ rStream.SetBufferSize( 32768 ); +/*N*/ CharSet eOldSet = rStream.GetStreamCharSet(); +/*N*/ +/*N*/ SetPrinter( NULL ); +/*N*/ +/*N*/ ScPatternAttr::pDoc = this; +/*N*/ +/*N*/ if ( xPoolHelper.is() && !bIsClip ) +/*N*/ xPoolHelper->SourceDocumentGone(); +/*N*/ +/*N*/ xPoolHelper = new ScPoolHelper( this ); +/*N*/ +/*N*/ xPoolHelper->GetDocPool()->SetFileFormatVersion( (USHORT)rStream.GetVersion() ); +/*N*/ BOOL bStylesFound = FALSE; +/*N*/ +/*N*/ BOOL bRet = FALSE; +/*N*/ USHORT nID; +/*N*/ rStream >> nID; +/*N*/ if (nID == SCID_POOLS || nID == SCID_NEWPOOLS) +/*N*/ { +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ while (aHdr.BytesLeft()) +/*N*/ { +/*N*/ USHORT nSubID; +/*N*/ rStream >> nSubID; +/*N*/ ScReadHeader aSubHdr( rStream ); +/*N*/ switch (nSubID) +/*N*/ { +/*N*/ case SCID_CHARSET: +/*N*/ { +/*N*/ BYTE cSet, cGUI; // cGUI is dummy, old GUIType +/*N*/ rStream >> cGUI >> cSet; +/*N*/ eSrcSet = (CharSet) cSet; +/*N*/ rStream.SetStreamCharSet( ::GetSOLoadTextEncoding( +/*N*/ eSrcSet, (USHORT)rStream.GetVersion() ) ); +/*N*/ } +/*N*/ break; +/*N*/ case SCID_DOCPOOL: +/*N*/ xPoolHelper->GetDocPool()->Load( rStream ); +/*N*/ break; +/*N*/ case SCID_STYLEPOOL: +/*N*/ { +/*N*/ // StylePool konvertiert beim Laden selber +/*N*/ CharSet eOld = rStream.GetStreamCharSet(); +/*N*/ rStream.SetStreamCharSet( gsl_getSystemTextEncoding() ); //! ??? +/*N*/ xPoolHelper->GetStylePool()->Load( rStream ); +/*N*/ rStream.SetStreamCharSet( eOld ); +/*N*/ lcl_RemoveMergeFromStyles( xPoolHelper->GetStylePool() ); // setzt auch ReadOnly zurueck +/*N*/ bStylesFound = TRUE; +/*N*/ } +/*N*/ break; +/*N*/ case SCID_EDITPOOL : +/*N*/ xPoolHelper->GetEditPool()->Load( rStream ); +/*N*/ break; +/*?*/ default: +/*?*/ DBG_ERROR("unbekannter Sub-Record in ScDocument::LoadPool"); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ UpdStlShtPtrsFrmNms(); +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ else +/*?*/ DBG_ERROR("LoadPool: SCID_POOLS nicht gefunden"); +/*N*/ +/*N*/ if (!bStylesFound) +/*?*/ xPoolHelper->GetStylePool()->CreateStandardStyles(); +/*N*/ +/*N*/ rStream.SetStreamCharSet( eOldSet ); +/*N*/ rStream.SetBufferSize( nOldBufSize ); +/*N*/ +/*N*/ bLoadingDone = TRUE; +/*N*/ +/*N*/ // Das Uno-Objekt merkt sich einen Pointer auf den NumberFormatter +/*N*/ // -> mitteilen, dass der alte Pointer ungueltig geworden ist +/*N*/ BroadcastUno( ScPointerChangedHint(SC_POINTERCHANGED_NUMFMT) ); +/*N*/ +/*N*/ return bRet; +/*N*/ } + + +/*N*/ BOOL ScDocument::SavePool( SvStream& rStream ) const +/*N*/ { +/*N*/ xPoolHelper->GetDocPool()->SetFileFormatVersion( (USHORT)rStream.GetVersion() ); +/*N*/ +/*N*/ USHORT nOldBufSize = rStream.GetBufferSize(); +/*N*/ rStream.SetBufferSize( 32768 ); +/*N*/ CharSet eOldSet = rStream.GetStreamCharSet(); +/*N*/ CharSet eStoreCharSet = ::GetSOStoreTextEncoding( +/*N*/ gsl_getSystemTextEncoding(), (USHORT)rStream.GetVersion() ); +/*N*/ rStream.SetStreamCharSet( eStoreCharSet ); +/*N*/ +/*N*/ // ::com::press-Mode fuer Grafiken in Brush-Items (Hintergrund im Seitenformat) +/*N*/ +/*N*/ USHORT nComprMode = rStream.GetCompressMode() & ~(COMPRESSMODE_ZBITMAP | COMPRESSMODE_NATIVE); +/*N*/ BOOL bNative = FALSE; +/*N*/ BOOL bCompr = FALSE; +/*N*/ +/*N*/ if ( rStream.GetVersion() >= SOFFICE_FILEFORMAT_40 && bCompr ) +/*N*/ nComprMode |= COMPRESSMODE_ZBITMAP; // komprimiert ab 4.0 +/*N*/ if ( rStream.GetVersion() > SOFFICE_FILEFORMAT_40 && bNative ) +/*N*/ nComprMode |= COMPRESSMODE_NATIVE; // Originalformat ab 5.0 +/*N*/ rStream.SetCompressMode( nComprMode ); +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_NEWPOOLS; +/*N*/ ScWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_CHARSET; +/*N*/ ScWriteHeader aSetHdr( rStream, 2 ); +/*N*/ rStream << (BYTE) 0 // dummy, old System::GetGUIType() +/*N*/ << (BYTE) eStoreCharSet; +/*N*/ } +/*N*/ +/*N*/ // Force the default style's name to be "Standard" for all languages in the file. +/*N*/ // This is needed for versions up to 5.1, to find the default pattern's style in +/*N*/ // the UpdateStyleSheet call. +/*N*/ // #89078# this has to be set for the DocPool save, too, so the default style name +/*N*/ // is adjusted for the patterns, or a wrong style would be used if other styles +/*N*/ // match the default style's name after CharacterSet conversion. +/*N*/ +/*N*/ String aFileStdName = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(STRING_STANDARD)); +/*N*/ if ( aFileStdName != ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ) +/*N*/ xPoolHelper->GetStylePool()->SetForceStdName( &aFileStdName ); +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_DOCPOOL; +/*N*/ ScWriteHeader aDocPoolHdr( rStream ); +/*N*/ xPoolHelper->GetDocPool()->Store( rStream ); +/*N*/ } +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_STYLEPOOL; +/*N*/ ScWriteHeader aStylePoolHdr( rStream ); +/*N*/ xPoolHelper->GetStylePool()->SetSearchMask( SFX_STYLE_FAMILY_ALL ); +/*N*/ +/*N*/ xPoolHelper->GetStylePool()->Store( rStream, FALSE ); +/*N*/ } +/*N*/ +/*N*/ xPoolHelper->GetStylePool()->SetForceStdName( NULL ); +/*N*/ +/*N*/ if ( rStream.GetVersion() >= SOFFICE_FILEFORMAT_50 ) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_EDITPOOL; +/*N*/ ScWriteHeader aEditPoolHdr( rStream ); +/*N*/ xPoolHelper->GetEditPool()->SetFileFormatVersion( (USHORT)rStream.GetVersion() ); +/*N*/ xPoolHelper->GetEditPool()->Store( rStream ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ rStream.SetStreamCharSet( eOldSet ); +/*N*/ rStream.SetBufferSize( nOldBufSize ); +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ long ScDocument::GetCellCount() const +/*N*/ { +/*N*/ long nCellCount = 0L; +/*N*/ +/*N*/ for ( USHORT nTab=0; nTab<=MAXTAB; nTab++ ) +/*N*/ if ( pTab[nTab] ) +/*N*/ nCellCount += pTab[nTab]->GetCellCount(); +/*N*/ +/*N*/ return nCellCount; +/*N*/ } + + +/*N*/ long ScDocument::GetWeightedCount() const +/*N*/ { +/*N*/ long nCellCount = 0L; +/*N*/ +/*N*/ for ( USHORT nTab=0; nTab<=MAXTAB; nTab++ ) +/*N*/ if ( pTab[nTab] ) +/*N*/ nCellCount += pTab[nTab]->GetWeightedCount(); +/*N*/ +/*N*/ return nCellCount; +/*N*/ } + + + + +/*N*/ void ScDocument::SetPageStyle( USHORT nTab, const String& rName ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetPageStyle( rName ); +/*N*/ } + + +/*N*/ const String& ScDocument::GetPageStyle( USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetPageStyle(); +/*N*/ +/*N*/ return EMPTY_STRING; +/*N*/ } + + +/*N*/ void ScDocument::SetPageSize( USHORT nTab, const Size& rSize ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetPageSize( rSize ); +/*N*/ } + +/*N*/ Size ScDocument::GetPageSize( USHORT nTab ) const +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ return pTab[nTab]->GetPageSize(); +/*N*/ +/*N*/ DBG_ERROR("falsche Tab"); +/*N*/ return Size(); +/*N*/ } + + +/*N*/ void ScDocument::SetRepeatArea( USHORT nTab, USHORT nStartCol, USHORT nEndCol, USHORT nStartRow, USHORT nEndRow ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->SetRepeatArea( nStartCol, nEndCol, nStartRow, nEndRow ); +/*N*/ } + +/*N*/ void ScDocument::UpdatePageBreaks( USHORT nTab, const ScRange* pUserArea ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->UpdatePageBreaks( pUserArea ); +/*N*/ } + +/*N*/ void ScDocument::RemoveManualBreaks( USHORT nTab ) +/*N*/ { +/*N*/ if ( nTab <= MAXTAB && pTab[nTab] ) +/*N*/ pTab[nTab]->RemoveManualBreaks(); +/*N*/ } + + + + + +/*N*/ BOOL ScDocument::HasPrintRange() +/*N*/ { +/*N*/ BOOL bResult = FALSE; +/*N*/ +/*N*/ for ( USHORT i=0; !bResult && i<nMaxTableNumber; i++ ) +/*N*/ if ( pTab[i] ) +/*N*/ bResult = ( pTab[i]->GetPrintRangeCount() > 0 ); +/*N*/ +/*N*/ return bResult; +/*N*/ } + + +/*N*/ USHORT ScDocument::GetPrintRangeCount( USHORT nTab ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetPrintRangeCount(); +/*N*/ +/*N*/ return 0; +/*N*/ } + + +/*N*/ const ScRange* ScDocument::GetPrintRange( USHORT nTab, USHORT nPos ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetPrintRange(nPos); +/*N*/ +/*N*/ return NULL; +/*N*/ } + + +/*N*/ const ScRange* ScDocument::GetRepeatColRange( USHORT nTab ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetRepeatColRange(); +/*N*/ +/*N*/ return NULL; +/*N*/ } + + +/*N*/ const ScRange* ScDocument::GetRepeatRowRange( USHORT nTab ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ return pTab[nTab]->GetRepeatRowRange(); +/*N*/ +/*N*/ return NULL; +/*N*/ } + + +// #42845# zeroptimiert +/*N*/ #if defined(WIN) && defined(MSC) +/*N*/ #pragma optimize("",off) +/*N*/ #endif +/*N*/ void ScDocument::SetPrintRangeCount( USHORT nTab, USHORT nNew ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetPrintRangeCount( nNew ); +/*N*/ } +/*N*/ #if defined(WIN) && defined(MSC) +/*N*/ #pragma optimize("",on) +/*N*/ #endif + + +/*N*/ void ScDocument::SetPrintRange( USHORT nTab, USHORT nPos, const ScRange& rNew ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetPrintRange( nPos, rNew ); +/*N*/ } + + +/*N*/ void ScDocument::SetRepeatColRange( USHORT nTab, const ScRange* pNew ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetRepeatColRange( pNew ); +/*N*/ } + + +/*N*/ void ScDocument::SetRepeatRowRange( USHORT nTab, const ScRange* pNew ) +/*N*/ { +/*N*/ if (nTab<=MAXTAB && pTab[nTab]) +/*N*/ pTab[nTab]->SetRepeatRowRange( pNew ); +/*N*/ } + + +/*N*/ ScPrintRangeSaver* ScDocument::CreatePrintRangeSaver() const +/*N*/ { +/*N*/ USHORT nCount = GetTableCount(); +/*N*/ ScPrintRangeSaver* pNew = new ScPrintRangeSaver( nCount ); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ if (pTab[i]) +/*N*/ pTab[i]->FillPrintSaver( pNew->GetTabData(i) ); +/*N*/ return pNew; +/*N*/ } + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dpobject.cxx b/binfilter/bf_sc/source/core/data/sc_dpobject.cxx new file mode 100644 index 000000000000..77554d3b3b44 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dpobject.cxx @@ -0,0 +1,1090 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// INCLUDE --------------------------------------------------------------- + +#include "dpobject.hxx" +#include "dptabsrc.hxx" +#include "dpsave.hxx" +#include "dpoutput.hxx" +#include "dpshttab.hxx" +#include "dpsdbtab.hxx" +#include "document.hxx" +#include "rechead.hxx" +#include "pivot.hxx" // PIVOT_DATA_FIELD +#include "dapiuno.hxx" // ScDataPilotConversion +#include "miscuno.hxx" +#include "scerrors.hxx" +#include "refupdat.hxx" + +#include <com/sun/star/sheet/GeneralFunction.hpp> +#include <com/sun/star/sheet/DataPilotFieldOrientation.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/lang/XInitialization.hpp> +#include <com/sun/star/container/XContentEnumerationAccess.hpp> + +#include <comphelper/processfactory.hxx> +#include <tools/debug.hxx> +#include <bf_svtools/zforlist.hxx> // IsNumberFormat +#include <legacysmgr/legacy_binfilters_smgr.hxx> //STRIP002 +namespace binfilter { +using namespace ::com::sun::star; + +// ----------------------------------------------------------------------- + +#define MAX_LABELS 256 //!!! from fieldwnd.hxx, must be moved to global.hxx + +// ----------------------------------------------------------------------- + +#define SCDPSOURCE_SERVICE "com.sun.star.sheet.DataPilotSource" + +// ----------------------------------------------------------------------- + +// incompatible versions of data pilot files +#define SC_DP_VERSION_CURRENT 6 + +// type of source data +#define SC_DP_SOURCE_SHEET 0 +#define SC_DP_SOURCE_DATABASE 1 +#define SC_DP_SOURCE_SERVICE 2 + +// ----------------------------------------------------------------------- + +//! move to a header file +#define DP_PROP_COLUMNGRAND "ColumnGrand" +#define DP_PROP_FUNCTION "Function" +#define DP_PROP_IGNOREEMPTY "IgnoreEmptyRows" +#define DP_PROP_ISDATALAYOUT "IsDataLayoutDimension" +//#define DP_PROP_ISVISIBLE "IsVisible" +#define DP_PROP_ORIENTATION "Orientation" +#define DP_PROP_ORIGINAL "Original" +#define DP_PROP_POSITION "Position" +#define DP_PROP_REPEATIFEMPTY "RepeatIfEmpty" +#define DP_PROP_ROWGRAND "RowGrand" +#define DP_PROP_SHOWDETAILS "ShowDetails" +#define DP_PROP_SHOWEMPTY "ShowEmpty" +#define DP_PROP_SUBTOTALS "SubTotals" +#define DP_PROP_USEDHIERARCHY "UsedHierarchy" + +// ----------------------------------------------------------------------- + +/*N*/ USHORT lcl_GetDataGetOrientation( const uno::Reference<sheet::XDimensionsSupplier>& xSource ) +/*N*/ { +/*N*/ long nRet = sheet::DataPilotFieldOrientation_HIDDEN; +/*N*/ if ( xSource.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions(); +/*N*/ uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName ); +/*N*/ long nIntCount = xIntDims->getCount(); +/*N*/ BOOL bFound = FALSE; +/*N*/ for (long nIntDim=0; nIntDim<nIntCount && !bFound; nIntDim++) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xIntDim = +/*N*/ ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) ); +/*N*/ uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY ); +/*N*/ if ( xDimProp.is() ) +/*N*/ { +/*N*/ bFound = ScUnoHelpFunctions::GetBoolProperty( xDimProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ISDATALAYOUT) ); +/*N*/ //! error checking -- is "IsDataLayoutDimension" property required?? +/*N*/ if (bFound) +/*N*/ nRet = ScUnoHelpFunctions::GetEnumProperty( +/*N*/ xDimProp, ::rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), +/*N*/ sheet::DataPilotFieldOrientation_HIDDEN ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return nRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScDPObject::ScDPObject( ScDocument* pD ) : +/*N*/ pDoc( pD ), +/*N*/ bAlive( FALSE ), +/*N*/ pSaveData( NULL ), +/*N*/ pSheetDesc( NULL ), +/*N*/ pImpDesc( NULL ), +/*N*/ pServDesc( NULL ), +/*N*/ pOutput( NULL ), +/*N*/ bSettingsChanged( FALSE ) +/*N*/ { +/*N*/ } + +/*N*/ ScDPObject::ScDPObject(const ScDPObject& r) : +/*N*/ pDoc( r.pDoc ), +/*N*/ bAlive( FALSE ), +/*N*/ pSaveData( NULL ), +/*N*/ aTableName( r.aTableName ), +/*N*/ aTableTag( r.aTableTag ), +/*N*/ aOutRange( r.aOutRange ), +/*N*/ pSheetDesc( NULL ), +/*N*/ pImpDesc( NULL ), +/*N*/ pServDesc( NULL ), +/*N*/ pOutput( NULL ), +/*N*/ bSettingsChanged( FALSE ) +/*N*/ { +/*N*/ if (r.pSaveData) +/*N*/ pSaveData = new ScDPSaveData(*r.pSaveData); +/*N*/ if (r.pSheetDesc) +/*N*/ pSheetDesc = new ScSheetSourceDesc(*r.pSheetDesc); +/*N*/ if (r.pImpDesc) +/*N*/ pImpDesc = new ScImportSourceDesc(*r.pImpDesc); +/*N*/ if (r.pServDesc) +/*N*/ pServDesc = new ScDPServiceDesc(*r.pServDesc); +/*N*/ // xSource (and pOutput) is not copied +/*N*/ } + +/*N*/ ScDPObject::~ScDPObject() +/*N*/ { +/*N*/ delete pOutput; +/*N*/ delete pSaveData; +/*N*/ delete pSheetDesc; +/*N*/ delete pImpDesc; +/*N*/ delete pServDesc; +/*N*/ } + +/*N*/ DataObject* ScDPObject::Clone() const +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return new ScDPObject(*this); +/*N*/ } + +/*N*/ void ScDPObject::SetAlive(BOOL bSet) +/*N*/ { +/*N*/ bAlive = bSet; +/*N*/ } + +/*N*/ void ScDPObject::SetSaveData(const ScDPSaveData& rData) +/*N*/ { +/*N*/ delete pSaveData; +/*N*/ pSaveData = new ScDPSaveData( rData ); +/*N*/ +/*N*/ InvalidateData(); // re-init source from SaveData +/*N*/ } + +/*N*/ void ScDPObject::SetOutRange(const ScRange& rRange) +/*N*/ { +/*N*/ aOutRange = rRange; +/*N*/ +/*N*/ if ( pOutput ) +/*N*/ pOutput->SetPosition( rRange.aStart ); +/*N*/ } + +/*N*/ void ScDPObject::SetSheetDesc(const ScSheetSourceDesc& rDesc) +/*N*/ { +/*N*/ if ( pSheetDesc && rDesc == *pSheetDesc ) +/*N*/ return; // nothing to do +/*N*/ +/*N*/ DELETEZ( pImpDesc ); +/*N*/ DELETEZ( pServDesc ); +/*N*/ +/*N*/ delete pImpDesc; +/*N*/ pSheetDesc = new ScSheetSourceDesc(rDesc); +/*N*/ +/*N*/ // make valid QueryParam +/*N*/ +/*N*/ pSheetDesc->aQueryParam.nCol1 = pSheetDesc->aSourceRange.aStart.Col(); +/*N*/ pSheetDesc->aQueryParam.nRow1 = pSheetDesc->aSourceRange.aStart.Row(); +/*N*/ pSheetDesc->aQueryParam.nCol2 = pSheetDesc->aSourceRange.aEnd.Col(); +/*N*/ pSheetDesc->aQueryParam.nRow2 = pSheetDesc->aSourceRange.aEnd.Row();; +/*N*/ pSheetDesc->aQueryParam.bHasHeader = TRUE; +/*N*/ USHORT nCount = pSheetDesc->aQueryParam.GetEntryCount(); +/*N*/ +/*N*/ InvalidateSource(); // new source must be created +/*N*/ } + +/*N*/ void ScDPObject::SetImportDesc(const ScImportSourceDesc& rDesc) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( pImpDesc && rDesc == *pImpDesc ) +/*N*/ } + +/*N*/ void ScDPObject::SetServiceData(const ScDPServiceDesc& rDesc) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( pServDesc && rDesc == *pServDesc ) +/*N*/ } + + +/*N*/ BOOL ScDPObject::IsSheetData() const +/*N*/ { +/*N*/ return ( pSheetDesc != NULL ); +/*N*/ } + +/*N*/ void ScDPObject::SetName(const String& rNew) +/*N*/ { +/*N*/ aTableName = rNew; +/*N*/ } + +/*N*/ void ScDPObject::SetTag(const String& rNew) +/*N*/ { +/*N*/ aTableTag = rNew; +/*N*/ } + + + +/*N*/ void ScDPObject::CreateObjects() +/*N*/ { +/*N*/ if (!xSource.is()) +/*N*/ { +/*N*/ //! cache DPSource and/or Output? +/*N*/ +/*N*/ DBG_ASSERT( bAlive, "CreateObjects on non-inserted DPObject" ); +/*N*/ +/*N*/ DELETEZ( pOutput ); // not valid when xSource is changed +/*N*/ +/*N*/ if ( pImpDesc ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScDatabaseDPData* pData = new ScDatabaseDPData( pDoc->GetServiceManager(), *pImpDesc ); +/*N*/ } +/*N*/ else if ( pServDesc ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 xSource = CreateSource( *pServDesc ); +/*N*/ } +/*N*/ +/*N*/ if ( !xSource.is() ) // sheet data or error in above cases +/*N*/ { +/*N*/ DBG_ASSERT( !pImpDesc && !pServDesc, "DPSource could not be created" ); +/*N*/ if (!pSheetDesc) +/*N*/ { +/*?*/ DBG_ERROR("no source descriptor"); +/*?*/ pSheetDesc = new ScSheetSourceDesc; // dummy defaults +/*N*/ } +/*N*/ ScSheetDPData* pData = new ScSheetDPData( pDoc, *pSheetDesc ); +/*N*/ xSource = new ScDPSource( pData ); +/*N*/ } +/*N*/ +/*N*/ if (pSaveData) +/*N*/ pSaveData->WriteToSource( xSource ); +/*N*/ } +/*N*/ else if (bSettingsChanged) +/*N*/ { +/*?*/ DELETEZ( pOutput ); // not valid when xSource is changed +/*?*/ +/*?*/ uno::Reference<util::XRefreshable> xRef( xSource, uno::UNO_QUERY ); +/*?*/ if (xRef.is()) +/*?*/ { +/*?*/ try +/*?*/ { +/*?*/ xRef->refresh(); +/*?*/ } +/*?*/ catch(uno::Exception&) +/*?*/ { +/*?*/ DBG_ERROR("exception in refresh"); +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ if (pSaveData) +/*?*/ pSaveData->WriteToSource( xSource ); +/*N*/ } +/*N*/ bSettingsChanged = FALSE; +/*N*/ } + +/*N*/ void ScDPObject::InvalidateData() +/*N*/ { +/*N*/ bSettingsChanged = TRUE; +/*N*/ } + +/*N*/ void ScDPObject::InvalidateSource() +/*N*/ { +/*N*/ xSource = NULL; +/*N*/ } + + + +/*N*/ void ScDPObject::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 // Output area +} + +/*N*/ USHORT lcl_FirstSubTotal( const uno::Reference<beans::XPropertySet>& xDimProp ) // PIVOT_FUNC mask +/*N*/ { +/*N*/ uno::Reference<sheet::XHierarchiesSupplier> xDimSupp( xDimProp, uno::UNO_QUERY ); +/*N*/ if ( xDimProp.is() && xDimSupp.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XIndexAccess> xHiers = new ScNameToIndexAccess( xDimSupp->getHierarchies() ); +/*N*/ long nHierarchy = ScUnoHelpFunctions::GetLongProperty( xDimProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_USEDHIERARCHY) ); +/*N*/ if ( nHierarchy >= xHiers->getCount() ) +/*N*/ nHierarchy = 0; +/*N*/ +/*N*/ uno::Reference<uno::XInterface> xHier = ScUnoHelpFunctions::AnyToInterface( +/*N*/ xHiers->getByIndex(nHierarchy) ); +/*N*/ uno::Reference<sheet::XLevelsSupplier> xHierSupp( xHier, uno::UNO_QUERY ); +/*N*/ if ( xHierSupp.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XIndexAccess> xLevels = new ScNameToIndexAccess( xHierSupp->getLevels() ); +/*N*/ uno::Reference<uno::XInterface> xLevel = +/*N*/ ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex( 0 ) ); +/*N*/ uno::Reference<beans::XPropertySet> xLevProp( xLevel, uno::UNO_QUERY ); +/*N*/ if ( xLevProp.is() ) +/*N*/ { +/*N*/ uno::Any aSubAny; +/*N*/ try +/*N*/ { +/*N*/ aSubAny = xLevProp->getPropertyValue( +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_SUBTOTALS) ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ } +/*N*/ uno::Sequence<sheet::GeneralFunction> aSeq; +/*N*/ if ( aSubAny >>= aSeq ) +/*N*/ { +/*N*/ USHORT nMask = 0; +/*N*/ const sheet::GeneralFunction* pArray = aSeq.getConstArray(); +/*N*/ long nCount = aSeq.getLength(); +/*N*/ for (long i=0; i<nCount; i++) +/*?*/ nMask |= ScDataPilotConversion::FunctionBit(pArray[i]); +/*N*/ return nMask; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*?*/ DBG_ERROR("FirstSubTotal: NULL"); +/*?*/ return 0; +/*N*/ } + +/*N*/ USHORT lcl_CountBits( USHORT nBits ) +/*N*/ { +/*N*/ if (!nBits) return 0; +/*N*/ +/*N*/ USHORT nCount = 0; +/*N*/ USHORT nMask = 1; +/*N*/ for (USHORT i=0; i<16; i++) +/*N*/ { +/*N*/ if ( nBits & nMask ) +/*N*/ ++nCount; +/*N*/ nMask <<= 1; +/*N*/ } +/*N*/ return nCount; +/*N*/ } + +/*N*/ USHORT lcl_FillOldFields( PivotField* pFields, +/*N*/ const uno::Reference<sheet::XDimensionsSupplier>& xSource, +/*N*/ USHORT nOrient, USHORT nColAdd, BOOL bAddData ) +/*N*/ { +/*N*/ USHORT nOutCount = 0; +/*N*/ BOOL bDataFound = FALSE; +/*N*/ +/*N*/ //! merge multiple occurences (data field with different functions) +/*N*/ //! force data field in one dimension +/*N*/ +/*N*/ long nPos[PIVOT_MAXFIELD]; +/*N*/ +/*N*/ uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions(); +/*N*/ uno::Reference<container::XIndexAccess> xDims = new ScNameToIndexAccess( xDimsName ); +/*N*/ long nDimCount = xDims->getCount(); +/*N*/ for (long nDim=0; nDim < nDimCount && nOutCount < PIVOT_MAXFIELD; nDim++) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xIntDim = +/*N*/ ScUnoHelpFunctions::AnyToInterface( xDims->getByIndex(nDim) ); +/*N*/ uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY ); +/*N*/ long nDimOrient = ScUnoHelpFunctions::GetEnumProperty( +/*N*/ xDimProp, ::rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), +/*N*/ sheet::DataPilotFieldOrientation_HIDDEN ); +/*N*/ if ( xDimProp.is() && nDimOrient == nOrient ) +/*N*/ { +/*N*/ USHORT nMask = 0; +/*N*/ if ( nOrient == sheet::DataPilotFieldOrientation_DATA ) +/*N*/ { +/*N*/ sheet::GeneralFunction eFunc = (sheet::GeneralFunction)ScUnoHelpFunctions::GetEnumProperty( +/*N*/ xDimProp, ::rtl::OUString::createFromAscii(DP_PROP_FUNCTION), +/*N*/ sheet::GeneralFunction_NONE ); +/*N*/ if ( eFunc == sheet::GeneralFunction_AUTO ) +/*N*/ { +/*N*/ //! test for numeric data +/*?*/ eFunc = sheet::GeneralFunction_SUM; +/*N*/ } +/*N*/ nMask = ScDataPilotConversion::FunctionBit(eFunc); +/*N*/ } +/*N*/ else +/*N*/ nMask = lcl_FirstSubTotal( xDimProp ); // from first hierarchy +/*N*/ +/*N*/ BOOL bDataLayout = ScUnoHelpFunctions::GetBoolProperty( xDimProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ISDATALAYOUT) ); +/*N*/ uno::Any aOrigAny; +/*N*/ try +/*N*/ { +/*N*/ aOrigAny = xDimProp->getPropertyValue( +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ORIGINAL) ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ long nDupSource = -1; +/*N*/ uno::Reference<uno::XInterface> xIntOrig = ScUnoHelpFunctions::AnyToInterface( aOrigAny ); +/*N*/ if ( xIntOrig.is() ) +/*N*/ { +/*?*/ uno::Reference<container::XNamed> xNameOrig( xIntOrig, uno::UNO_QUERY ); +/*?*/ if ( xNameOrig.is() ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 nDupSource = lcl_FindName( xNameOrig->getName(), xDimsName ); +/*N*/ } +/*N*/ +/*N*/ BOOL bDupUsed = FALSE; +/*N*/ if ( nDupSource >= 0 ) +/*N*/ { +/*?*/ // add function bit to previous entry +/*?*/ +/*?*/ short nCompCol; +/*?*/ if ( bDataLayout ) +/*?*/ nCompCol = PIVOT_DATA_FIELD; +/*?*/ else +/*?*/ nCompCol = (short)(nDupSource+nColAdd); //! seek source column from name +/*?*/ +/*?*/ for (USHORT nOld=0; nOld<nOutCount && !bDupUsed; nOld++) +/*?*/ if ( pFields[nOld].nCol == nCompCol ) +/*?*/ { +/*?*/ // add to previous column only if new bits aren't already set there +/*?*/ if ( ( pFields[nOld].nFuncMask & nMask ) == 0 ) +/*?*/ { +/*?*/ pFields[nOld].nFuncMask |= nMask; +/*?*/ pFields[nOld].nFuncCount = lcl_CountBits( pFields[nOld].nFuncMask ); +/*?*/ bDupUsed = TRUE; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ if ( !bDupUsed ) // also for duplicated dim if original has different orientation +/*N*/ { +/*N*/ if ( bDataLayout ) +/*N*/ { +/*N*/ pFields[nOutCount].nCol = PIVOT_DATA_FIELD; +/*N*/ bDataFound = TRUE; +/*N*/ } +/*N*/ else if ( nDupSource >= 0 ) // if source was not found (different orientation) +/*?*/ pFields[nOutCount].nCol = (short)(nDupSource+nColAdd); //! seek from name +/*N*/ else +/*N*/ pFields[nOutCount].nCol = (short)(nDim+nColAdd); //! seek source column from name +/*N*/ +/*N*/ pFields[nOutCount].nFuncMask = nMask; +/*N*/ pFields[nOutCount].nFuncCount = lcl_CountBits( nMask ); +/*N*/ nPos[nOutCount] = ScUnoHelpFunctions::GetLongProperty( xDimProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_POSITION) ); +/*N*/ ++nOutCount; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // sort by getPosition() value +/*N*/ +/*N*/ for (long i=0; i+1<nOutCount; i++) +/*N*/ { +/*N*/ for (long j=0; j+i+1<nOutCount; j++) +/*N*/ if ( nPos[j+1] < nPos[j] ) +/*N*/ { +/*?*/ long nTemp = nPos[j+1]; +/*?*/ nPos[j+1] = nPos[j]; +/*?*/ nPos[j] = nTemp; +/*?*/ PivotField aField = pFields[j+1]; +/*?*/ pFields[j+1] = pFields[j]; +/*?*/ pFields[j] = aField; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( bAddData && !bDataFound ) +/*N*/ { +/*?*/ if ( nOutCount >= PIVOT_MAXFIELD ) // space for data field? +/*?*/ --nOutCount; //! error? +/*?*/ pFields[nOutCount].nCol = PIVOT_DATA_FIELD; +/*?*/ pFields[nOutCount].nFuncMask = 0; +/*?*/ pFields[nOutCount].nFuncCount = 0; +/*?*/ ++nOutCount; +/*N*/ } +/*N*/ +/*N*/ return nOutCount; +/*N*/ } + +/*N*/ void lcl_SaveOldFieldArr( SvStream& rStream, +/*N*/ const uno::Reference<sheet::XDimensionsSupplier>& xSource, +/*N*/ USHORT nOrient, USHORT nColAdd, BOOL bAddData ) +/*N*/ { +/*N*/ // PIVOT_MAXFIELD = max. number in old files +/*N*/ PivotField aFields[PIVOT_MAXFIELD]; +/*N*/ USHORT nOutCount = lcl_FillOldFields( aFields, xSource, nOrient, nColAdd, bAddData ); +/*N*/ +/*N*/ rStream << nOutCount; +/*N*/ for (USHORT i=0; i<nOutCount; i++) +/*N*/ { +/*N*/ rStream << (BYTE) 0x00 +/*N*/ << aFields[i].nCol +/*N*/ << aFields[i].nFuncMask +/*N*/ << aFields[i].nFuncCount; +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDPObject::StoreNew( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ // save all data +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ if ( pImpDesc ) +/*N*/ { +/*N*/ rStream << (BYTE) SC_DP_SOURCE_DATABASE; +/*N*/ rStream.WriteByteString( pImpDesc->aDBName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( pImpDesc->aObject, rStream.GetStreamCharSet() ); +/*N*/ rStream << pImpDesc->nType; // USHORT +/*N*/ rStream << pImpDesc->bNative; +/*N*/ } +/*N*/ else if ( pServDesc ) +/*N*/ { +/*N*/ rStream << (BYTE) SC_DP_SOURCE_SERVICE; +/*N*/ rStream.WriteByteString( pServDesc->aServiceName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( pServDesc->aParSource, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( pServDesc->aParName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( pServDesc->aParUser, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( pServDesc->aParPass, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (!pSheetDesc) +/*N*/ { +/*N*/ DBG_ERROR("no source descriptor"); +/*N*/ ((ScDPObject*)this)->pSheetDesc = new ScSheetSourceDesc; // dummy defaults +/*N*/ } +/*N*/ +/*N*/ rStream << (BYTE) SC_DP_SOURCE_SHEET; +/*N*/ rStream << pSheetDesc->aSourceRange; +/*N*/ pSheetDesc->aQueryParam.Store( rStream ); +/*N*/ } +/*N*/ +/*N*/ rStream << aOutRange; +/*N*/ +/*N*/ DBG_ASSERT(pSaveData, "ScDPObject::StoreNew no SaveData"); +/*N*/ pSaveData->Store( rStream ); +/*N*/ +/*N*/ // additional data starting from 561b +/*N*/ rStream.WriteByteString( aTableName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aTableTag, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ BOOL ScDPObject::LoadNew(SvStream& rStream, ScMultipleReadHeader& rHdr ) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ DELETEZ( pImpDesc ); +/*N*/ DELETEZ( pSheetDesc ); +/*N*/ DELETEZ( pServDesc ); +/*N*/ +/*N*/ BYTE nType; +/*N*/ rStream >> nType; +/*N*/ switch (nType) +/*N*/ { +/*N*/ case SC_DP_SOURCE_DATABASE: +/*N*/ pImpDesc = new ScImportSourceDesc; +/*N*/ rStream.ReadByteString( pImpDesc->aDBName, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( pImpDesc->aObject, rStream.GetStreamCharSet() ); +/*N*/ rStream >> pImpDesc->nType; // USHORT +/*N*/ rStream >> pImpDesc->bNative; +/*N*/ break; +/*N*/ +/*N*/ case SC_DP_SOURCE_SHEET: +/*N*/ pSheetDesc = new ScSheetSourceDesc; +/*N*/ rStream >> pSheetDesc->aSourceRange; +/*N*/ pSheetDesc->aQueryParam.Load( rStream ); +/*N*/ break; +/*N*/ +/*N*/ case SC_DP_SOURCE_SERVICE: +/*N*/ { +/*N*/ String aServiceName, aParSource, aParName, aParUser, aParPass; +/*N*/ rStream.ReadByteString( aServiceName, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aParSource, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aParName, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aParUser, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aParPass, rStream.GetStreamCharSet() ); +/*N*/ pServDesc = new ScDPServiceDesc( aServiceName, +/*N*/ aParSource, aParName, aParUser, aParPass ); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ DBG_ERROR("unknown source type"); +/*N*/ } +/*N*/ +/*N*/ rStream >> aOutRange; +/*N*/ +/*N*/ SetSaveData(ScDPSaveData()); +/*N*/ pSaveData->Load( rStream ); +/*N*/ +/*N*/ if (rHdr.BytesLeft()) // additional data starting from 561b +/*N*/ { +/*N*/ rStream.ReadByteString( aTableName, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aTableTag, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScDPObject::StoreOld( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ // write compatible data for office 5.1 and below +/*N*/ +/*N*/ DBG_ASSERT( pSheetDesc, "StoreOld: !pSheetDesc" ); +/*N*/ ScRange aStoreRange; +/*N*/ ScQueryParam aStoreQuery; +/*N*/ if (pSheetDesc) +/*N*/ { +/*N*/ aStoreRange = pSheetDesc->aSourceRange; +/*N*/ aStoreQuery = pSheetDesc->aQueryParam; +/*N*/ } +/*N*/ +/*N*/ ((ScDPObject*)this)->CreateObjects(); // xSource is needed for field numbers +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream << (BOOL) TRUE; // bHasHeader +/*N*/ +/*N*/ rStream << aStoreRange.aStart.Col(); +/*N*/ rStream << aStoreRange.aStart.Row(); +/*N*/ rStream << aStoreRange.aEnd.Col(); +/*N*/ rStream << aStoreRange.aEnd.Row(); +/*N*/ rStream << aStoreRange.aStart.Tab(); +/*N*/ +/*N*/ //! make sure aOutRange is initialized +/*N*/ +/*N*/ rStream << aOutRange.aStart.Col(); +/*N*/ rStream << aOutRange.aStart.Row(); +/*N*/ rStream << aOutRange.aEnd.Col(); +/*N*/ rStream << aOutRange.aEnd.Row(); +/*N*/ rStream << aOutRange.aStart.Tab(); +/*N*/ +/*N*/ BOOL bAddData = ( lcl_GetDataGetOrientation( xSource ) == sheet::DataPilotFieldOrientation_HIDDEN ); +/*N*/ +/*N*/ lcl_SaveOldFieldArr( rStream, xSource, sheet::DataPilotFieldOrientation_ROW, aStoreRange.aStart.Col(), bAddData ); +/*N*/ lcl_SaveOldFieldArr( rStream, xSource, sheet::DataPilotFieldOrientation_COLUMN, aStoreRange.aStart.Col(), FALSE ); +/*N*/ lcl_SaveOldFieldArr( rStream, xSource, sheet::DataPilotFieldOrientation_DATA, aStoreRange.aStart.Col(), FALSE ); +/*N*/ +/*N*/ aStoreQuery.Store( rStream ); +/*N*/ +/*N*/ BOOL bColumnGrand = TRUE; +/*N*/ BOOL bRowGrand = TRUE; +/*N*/ BOOL bIgnoreEmpty = FALSE; +/*N*/ BOOL bRepeatIfEmpty = FALSE; +/*N*/ +/*N*/ uno::Reference<beans::XPropertySet> xProp( xSource, uno::UNO_QUERY ); +/*N*/ if (xProp.is()) +/*N*/ { +/*N*/ bColumnGrand = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_COLUMNGRAND), TRUE ); +/*N*/ bRowGrand = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ROWGRAND), TRUE ); +/*N*/ +/*N*/ // following properties may be missing for external sources +/*N*/ bIgnoreEmpty = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_IGNOREEMPTY) ); +/*N*/ bRepeatIfEmpty = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_REPEATIFEMPTY) ); +/*N*/ } +/*N*/ +/*N*/ rStream << bIgnoreEmpty; // bIgnoreEmpty +/*N*/ rStream << bRepeatIfEmpty; // bDetectCat +/*N*/ +/*N*/ rStream << bColumnGrand; // bMakeTotalCol +/*N*/ rStream << bRowGrand; // bMakeTotalRow +/*N*/ +/*N*/ if( rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) +/*N*/ { +/*N*/ rStream.WriteByteString( aTableName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aTableTag, rStream.GetStreamCharSet() ); +/*N*/ rStream << (USHORT)0; // nColNameCount +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScDPObject::FillOldParam(ScPivotParam& rParam, BOOL bForFile) const +/*N*/ { +/*N*/ ((ScDPObject*)this)->CreateObjects(); // xSource is needed for field numbers +/*N*/ +/*N*/ rParam.nCol = aOutRange.aStart.Col(); +/*N*/ rParam.nRow = aOutRange.aStart.Row(); +/*N*/ rParam.nTab = aOutRange.aStart.Tab(); +/*N*/ // ppLabelArr / nLabels is not changed +/*N*/ +/*N*/ USHORT nColAdd = 0; +/*N*/ if ( bForFile ) +/*N*/ { +/*N*/ // in old file format, columns are within document, not within source range +/*N*/ +/*N*/ DBG_ASSERT( pSheetDesc, "FillOldParam: bForFile, !pSheetDesc" ); +/*N*/ nColAdd = pSheetDesc->aSourceRange.aStart.Col(); +/*N*/ } +/*N*/ +/*N*/ BOOL bAddData = ( lcl_GetDataGetOrientation( xSource ) == sheet::DataPilotFieldOrientation_HIDDEN ); +/*N*/ rParam.nColCount = lcl_FillOldFields( rParam.aColArr, +/*N*/ xSource, sheet::DataPilotFieldOrientation_COLUMN, nColAdd, bAddData ); +/*N*/ rParam.nRowCount = lcl_FillOldFields( rParam.aRowArr, +/*N*/ xSource, sheet::DataPilotFieldOrientation_ROW, nColAdd, FALSE ); +/*N*/ rParam.nDataCount = lcl_FillOldFields( rParam.aDataArr, +/*N*/ xSource, sheet::DataPilotFieldOrientation_DATA, nColAdd, FALSE ); +/*N*/ +/*N*/ uno::Reference<beans::XPropertySet> xProp( xSource, uno::UNO_QUERY ); +/*N*/ if (xProp.is()) +/*N*/ { +/*N*/ try +/*N*/ { +/*N*/ rParam.bMakeTotalCol = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_COLUMNGRAND), TRUE ); +/*N*/ rParam.bMakeTotalRow = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ROWGRAND), TRUE ); +/*N*/ +/*N*/ // following properties may be missing for external sources +/*N*/ rParam.bIgnoreEmptyRows = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_IGNOREEMPTY) ); +/*N*/ rParam.bDetectCategories = ScUnoHelpFunctions::GetBoolProperty( xProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_REPEATIFEMPTY) ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ // no error +/*N*/ } +/*N*/ } +/*N*/ return TRUE; +/*N*/ } + + + + +//------------------------------------------------------------------------ +// convert old pivot tables into new datapilot tables + + +// static +/*N*/ void ScDPObject::ConvertOrientation( ScDPSaveData& rSaveData, +/*N*/ PivotField* pFields, USHORT nCount, USHORT nOrient, +/*N*/ ScDocument* pDoc, USHORT nRow, USHORT nTab, +/*N*/ const uno::Reference<sheet::XDimensionsSupplier>& xSource, +/*N*/ BOOL bOldDefaults, +/*N*/ PivotField* pRefColFields, USHORT nRefColCount, +/*N*/ PivotField* pRefRowFields, USHORT nRefRowCount ) +/*N*/ { +/*N*/ // pDoc or xSource must be set +/*N*/ DBG_ASSERT( pDoc || xSource.is(), "missing string source" ); +/*N*/ +/*N*/ String aDocStr; +/*N*/ ScDPSaveDimension* pDim; +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ USHORT nCol = pFields[i].nCol; +/*N*/ USHORT nFuncs = pFields[i].nFuncMask; +/*N*/ if ( nCol == PIVOT_DATA_FIELD ) +/*N*/ pDim = rSaveData.GetDataLayoutDimension(); +/*N*/ else +/*N*/ { +/*N*/ if ( pDoc ) +/*N*/ pDoc->GetString( nCol, nRow, nTab, aDocStr ); +/*N*/ else +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 aDocStr = lcl_GetDimName( xSource, nCol ); // cols must start at 0 +/*N*/ +/*N*/ if ( aDocStr.Len() ) +/*N*/ pDim = rSaveData.GetDimensionByName(aDocStr); +/*N*/ else +/*?*/ pDim = NULL; +/*N*/ } +/*N*/ +/*N*/ if ( pDim ) +/*N*/ { +/*N*/ if ( nOrient == sheet::DataPilotFieldOrientation_DATA ) // set summary function +/*N*/ { +/*N*/ // generate an individual entry for each function +/*N*/ BOOL bFirst = TRUE; +/*N*/ +/*N*/ // if a dimension is used for column or row and data, +/*N*/ // use duplicated dimensions for all data occurrences +/*N*/ if (pRefColFields) +/*N*/ for (USHORT nRefCol=0; nRefCol<nRefColCount; nRefCol++) +/*N*/ if (pRefColFields[nRefCol].nCol == nCol) +/*?*/ bFirst = FALSE; +/*N*/ if (pRefRowFields) +/*N*/ for (USHORT nRefRow=0; nRefRow<nRefRowCount; nRefRow++) +/*N*/ if (pRefRowFields[nRefRow].nCol == nCol) +/*?*/ bFirst = FALSE; +/*N*/ +/*N*/ // if set via api, a data column may occur several times +/*N*/ // (if the function hasn't been changed yet) -> also look for duplicate data column +/*N*/ for (USHORT nPrevData=0; nPrevData<i; nPrevData++) +/*?*/ if (pFields[nPrevData].nCol == nCol) +/*?*/ bFirst = FALSE; +/*N*/ +/*N*/ USHORT nMask = 1; +/*N*/ for (USHORT nBit=0; nBit<16; nBit++) +/*N*/ { +/*N*/ if ( nFuncs & nMask ) +/*N*/ { +/*N*/ sheet::GeneralFunction eFunc = ScDataPilotConversion::FirstFunc( nMask ); +/*N*/ if (bFirst) +/*N*/ { +/*N*/ pDim->SetOrientation( nOrient ); +/*N*/ pDim->SetFunction( eFunc ); +/*N*/ bFirst = FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ ScDPSaveDimension* pDup = rSaveData.DuplicateDimension(pDim->GetName()); +/*?*/ pDup->SetOrientation( nOrient ); +/*?*/ pDup->SetFunction( eFunc ); +/*N*/ } +/*N*/ } +/*N*/ nMask *= 2; +/*N*/ } +/*N*/ } +/*N*/ else // set SubTotals +/*N*/ { +/*N*/ pDim->SetOrientation( nOrient ); +/*N*/ +/*N*/ USHORT nFuncArray[16]; +/*N*/ USHORT nFuncCount = 0; +/*N*/ USHORT nMask = 1; +/*N*/ for (USHORT nBit=0; nBit<16; nBit++) +/*N*/ { +/*N*/ if ( nFuncs & nMask ) +/*?*/ nFuncArray[nFuncCount++] = ScDataPilotConversion::FirstFunc( nMask ); +/*N*/ nMask *= 2; +/*N*/ } +/*N*/ pDim->SetSubTotals( nFuncCount, nFuncArray ); +/*N*/ +/*N*/ // ShowEmpty was implicit in old tables, +/*N*/ // must be set for data layout dimension (not accessible in dialog) +/*N*/ if ( bOldDefaults || nCol == PIVOT_DATA_FIELD ) +/*N*/ pDim->SetShowEmpty( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ } +} + +/*N*/ void ScDPObject::InitFromOldPivot( const ScPivot& rOld, ScDocument* pDoc, BOOL bSetSource ) +/*N*/ { +/*N*/ ScDPSaveData aSaveData; +/*N*/ +/*N*/ ScPivotParam aParam; +/*N*/ ScQueryParam aQuery; +/*N*/ ScArea aArea; +/*N*/ rOld.GetParam( aParam, aQuery, aArea ); +/*N*/ +/*N*/ ConvertOrientation( aSaveData, aParam.aColArr, aParam.nColCount, +/*N*/ sheet::DataPilotFieldOrientation_COLUMN, pDoc, aArea.nRowStart, aArea.nTab, +/*N*/ uno::Reference<sheet::XDimensionsSupplier>(), TRUE ); +/*N*/ ConvertOrientation( aSaveData, aParam.aRowArr, aParam.nRowCount, +/*N*/ sheet::DataPilotFieldOrientation_ROW, pDoc, aArea.nRowStart, aArea.nTab, +/*N*/ uno::Reference<sheet::XDimensionsSupplier>(), TRUE ); +/*N*/ ConvertOrientation( aSaveData, aParam.aDataArr, aParam.nDataCount, +/*N*/ sheet::DataPilotFieldOrientation_DATA, pDoc, aArea.nRowStart, aArea.nTab, +/*N*/ uno::Reference<sheet::XDimensionsSupplier>(), TRUE, +/*N*/ aParam.aColArr, aParam.nColCount, aParam.aRowArr, aParam.nRowCount ); +/*N*/ +/*N*/ aSaveData.SetIgnoreEmptyRows( rOld.GetIgnoreEmpty() ); +/*N*/ aSaveData.SetRepeatIfEmpty( rOld.GetDetectCat() ); +/*N*/ aSaveData.SetColumnGrand( rOld.GetMakeTotalCol() ); +/*N*/ aSaveData.SetRowGrand( rOld.GetMakeTotalRow() ); +/*N*/ +/*N*/ SetSaveData( aSaveData ); +/*N*/ if (bSetSource) +/*N*/ { +/*N*/ ScSheetSourceDesc aDesc; +/*N*/ aDesc.aSourceRange = rOld.GetSrcArea(); +/*N*/ rOld.GetQuery( aDesc.aQueryParam ); +/*N*/ SetSheetDesc( aDesc ); +/*N*/ } +/*N*/ SetOutRange( rOld.GetDestArea() ); +/*N*/ +/*N*/ aTableName = rOld.GetName(); +/*N*/ aTableTag = rOld.GetTag(); +/*N*/ } + +// ----------------------------------------------------------------------- + +// static + +// static + +// static + +// ----------------------------------------------------------------------- + +/*N*/ ScDPCollection::ScDPCollection(ScDocument* pDocument) : +/*N*/ pDoc( pDocument ) +/*N*/ { +/*N*/ } + +/*N*/ ScDPCollection::ScDPCollection(const ScDPCollection& r) : +/*N*/ Collection(r), +/*N*/ pDoc(r.pDoc) +/*N*/ { +/*N*/ } + +/*N*/ ScDPCollection::~ScDPCollection() +/*N*/ { +/*N*/ } + +/*N*/ DataObject* ScDPCollection::Clone() const +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return new ScDPCollection(*this); +/*N*/ } + +/*N*/ BOOL ScDPCollection::StoreOld( SvStream& rStream ) const +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ +/*N*/ USHORT nSheetCount = 0; +/*N*/ USHORT i; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ( ((const ScDPObject*)At(i))->IsSheetData() ) +/*N*/ ++nSheetCount; +/*N*/ +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream << nSheetCount; // only tables from sheet data +/*N*/ +/*N*/ for (i=0; i<nCount && bSuccess; i++) +/*N*/ { +/*N*/ const ScDPObject* pObj = (const ScDPObject*)At(i); +/*N*/ if ( pObj->IsSheetData() ) +/*N*/ bSuccess = pObj->StoreOld( rStream, aHdr ); +/*N*/ } +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ BOOL ScDPCollection::StoreNew( SvStream& rStream ) const +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream << (long)SC_DP_VERSION_CURRENT; +/*N*/ rStream << (long)nCount; +/*N*/ +/*N*/ for (USHORT i=0; i<nCount && bSuccess; i++) +/*N*/ bSuccess = ((const ScDPObject*)At(i))->StoreNew( rStream, aHdr ); +/*N*/ +/*N*/ return bSuccess; +/*N*/ } +/*N*/ +/*N*/ BOOL ScDPCollection::LoadNew( SvStream& rStream ) +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ +/*N*/ FreeAll(); +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ long nVer; +/*N*/ rStream >> nVer; +/*N*/ +/*N*/ // check for all supported versions here.. +/*N*/ +/*N*/ if ( nVer != SC_DP_VERSION_CURRENT ) +/*N*/ { +/*N*/ DBG_ERROR("skipping unknown version of data pilot obejct"); +/*N*/ if ( rStream.GetError() == SVSTREAM_OK ) +/*N*/ rStream.SetError( SCWARN_IMPORT_INFOLOST ); +/*N*/ return FALSE; +/*N*/ } +/*N*/ +/*N*/ long nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ for (long i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ ScDPObject* pObj = new ScDPObject( pDoc ); +/*N*/ if ( pObj->LoadNew(rStream, aHdr) ) +/*N*/ { +/*N*/ pObj->SetAlive( TRUE ); +/*N*/ Insert( pObj ); +/*N*/ } +/*N*/ else +/*N*/ delete pObj; +/*N*/ } +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ void ScDPCollection::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& r, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ ((ScDPObject*)At(i))->UpdateReference( eUpdateRefMode, r, nDx, nDy, nDz ); +/*N*/ } + +/*N*/ String ScDPCollection::CreateNewName( USHORT nMin ) const +/*N*/ { +/*N*/ String aBase = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("DataPilot")); +/*N*/ //! from Resource? +/*N*/ +/*N*/ for (USHORT nAdd=0; nAdd<=nCount; nAdd++) // nCount+1 tries +/*N*/ { +/*N*/ String aNewName = aBase; +/*N*/ aNewName += String::CreateFromInt32( nMin + nAdd ); +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=0; i<nCount && !bFound; i++) +/*N*/ if (((const ScDPObject*)pItems[i])->GetName() == aNewName) +/*N*/ bFound = TRUE; +/*N*/ if (!bFound) +/*N*/ return aNewName; // found unused Name +/*N*/ } +/*N*/ return String(); // should not happen +/*N*/ } + +/*N*/ void ScDPCollection::EnsureNames() +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ if (!((const ScDPObject*)At(i))->GetName().Len()) +/*?*/ ((ScDPObject*)At(i))->SetName( CreateNewName() ); +/*N*/ } + +//------------------------------------------------------------------------ +// convert old pivot tables into new datapilot tables + +/*N*/ void ScDPCollection::ConvertOldTables( ScPivotCollection& rOldColl ) +/*N*/ { +/*N*/ // convert old pivot tables into new datapilot tables +/*N*/ +/*N*/ USHORT nOldCount = rOldColl.GetCount(); +/*N*/ for (USHORT i=0; i<nOldCount; i++) +/*N*/ { +/*N*/ ScDPObject* pNewObj = new ScDPObject(pDoc); +/*N*/ pNewObj->InitFromOldPivot( *(rOldColl)[i], pDoc, TRUE ); +/*N*/ pNewObj->SetAlive( TRUE ); +/*N*/ Insert( pNewObj ); +/*N*/ } +/*N*/ rOldColl.FreeAll(); +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dpoutput.cxx b/binfilter/bf_sc/source/core/data/sc_dpoutput.cxx new file mode 100644 index 000000000000..982250007ab1 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dpoutput.cxx @@ -0,0 +1,117 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svx/algitem.hxx> +#include <bf_svx/boxitem.hxx> +#include <bf_svx/brshitem.hxx> +#include <bf_svx/wghtitem.hxx> + +#include "dpoutput.hxx" +#include "document.hxx" +#include "patattr.hxx" +#include "docpool.hxx" +#include "markdata.hxx" +#include "attrib.hxx" +#include "compiler.hxx" // errNoValue +#include "miscuno.hxx" +#include "globstr.hrc" +#include "stlpool.hxx" +#include "stlsheet.hxx" + +#include <com/sun/star/sheet/XLevelsSupplier.hpp> +#include <com/sun/star/sheet/XHierarchiesSupplier.hpp> +#include <com/sun/star/sheet/XDataPilotResults.hpp> +#include <com/sun/star/sheet/XDataPilotMemberResults.hpp> +#include <com/sun/star/sheet/DataResultFlags.hpp> +#include <com/sun/star/sheet/MemberResultFlags.hpp> +#include <com/sun/star/sheet/DataPilotFieldOrientation.hpp> +#include <com/sun/star/container/XNamed.hpp> +namespace binfilter { + +using namespace ::com::sun::star; + +// ----------------------------------------------------------------------- + +//! move to a header file +#define DP_PROP_ORIENTATION "Orientation" +#define DP_PROP_POSITION "Position" +#define DP_PROP_USEDHIERARCHY "UsedHierarchy" +#define DP_PROP_DATADESCR "DataDescription" +#define DP_PROP_ISDATALAYOUT "IsDataLayoutDimension" +#define DP_PROP_NUMBERFORMAT "NumberFormat" + +// ----------------------------------------------------------------------- + +//! dynamic!!! +#define SC_DPOUT_MAXLEVELS 256 + + +struct ScDPOutLevelData +{ + long nDim; + long nHier; + long nLevel; + long nDimPos; + uno::Sequence<sheet::MemberResult> aResult; + String aCaption; + + ScDPOutLevelData() { nDim = nHier = nLevel = nDimPos = -1; } + + BOOL operator<(const ScDPOutLevelData& r) const + { return nDimPos<r.nDimPos || ( nDimPos==r.nDimPos && nHier<r.nHier ) || + ( nDimPos==r.nDimPos && nHier==r.nHier && nLevel<r.nLevel ); } + + void Swap(ScDPOutLevelData& r) +//! { ScDPOutLevelData aTemp = r; r = *this; *this = aTemp; } + { ScDPOutLevelData aTemp; aTemp = r; r = *this; *this = aTemp; } + + //! bug (73840) in uno::Sequence - copy and then assign doesn't work! +}; + +ScDPOutput::~ScDPOutput() +{ + delete[] pColFields; + delete[] pRowFields; + delete[] pPageFields; + + delete[] pColNumFmt; + delete[] pRowNumFmt; +} + +/*N*/ void ScDPOutput::SetPosition( const ScAddress& rPos ) +/*N*/ { +/*N*/ aStartPos = rPos; +/*N*/ bSizesValid = bSizeOverflow = FALSE; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dpsave.cxx b/binfilter/bf_sc/source/core/data/sc_dpsave.cxx new file mode 100644 index 000000000000..e7f80ea7066e --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dpsave.cxx @@ -0,0 +1,845 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// INCLUDE --------------------------------------------------------------- + +#include "dpsave.hxx" +#include "miscuno.hxx" +#include "scerrors.hxx" + +#include <tools/debug.hxx> +#include <tools/stream.hxx> + +#include <com/sun/star/sheet/GeneralFunction.hpp> +#include <com/sun/star/sheet/DataPilotFieldOrientation.hpp> +#include <com/sun/star/sheet/XHierarchiesSupplier.hpp> +#include <com/sun/star/sheet/XLevelsSupplier.hpp> +#include <com/sun/star/sheet/XMembersSupplier.hpp> +#include <com/sun/star/container/XNamed.hpp> +#include <com/sun/star/util/XCloneable.hpp> +namespace binfilter { + +using namespace ::com::sun::star; + +// ----------------------------------------------------------------------- + +#define SC_DPSAVEMODE_NO 0 +#define SC_DPSAVEMODE_YES 1 +#define SC_DPSAVEMODE_DONTKNOW 2 + +// ----------------------------------------------------------------------- + +//! move to a header file +#define DP_PROP_COLUMNGRAND "ColumnGrand" +#define DP_PROP_FUNCTION "Function" +#define DP_PROP_IGNOREEMPTY "IgnoreEmptyRows" +#define DP_PROP_ISDATALAYOUT "IsDataLayoutDimension" +#define DP_PROP_ISVISIBLE "IsVisible" +#define DP_PROP_ORIENTATION "Orientation" +#define DP_PROP_REPEATIFEMPTY "RepeatIfEmpty" +#define DP_PROP_ROWGRAND "RowGrand" +#define DP_PROP_SHOWDETAILS "ShowDetails" +#define DP_PROP_SHOWEMPTY "ShowEmpty" +#define DP_PROP_SUBTOTALS "SubTotals" +#define DP_PROP_USEDHIERARCHY "UsedHierarchy" + +// ----------------------------------------------------------------------- + +/*N*/ void lcl_SetBoolProperty( const uno::Reference<beans::XPropertySet>& xProp, +/*N*/ const ::rtl::OUString& rName, sal_Bool bValue ) +/*N*/ { +/*N*/ //! move to ScUnoHelpFunctions? +/*N*/ +/*N*/ xProp->setPropertyValue( rName, uno::Any( &bValue, getBooleanCppuType() ) ); +/*N*/ } +/*N*/ +/*N*/ // ----------------------------------------------------------------------- +/*N*/ +/*N*/ void lcl_SkipExtra( SvStream& rStream ) +/*N*/ { +/*N*/ USHORT nExtra; +/*N*/ rStream >> nExtra; +/*N*/ if ( nExtra ) +/*N*/ { +/*N*/ rStream.SeekRel( nExtra ); +/*N*/ if ( rStream.GetError() == SVSTREAM_OK ) +/*N*/ rStream.SetError( SCWARN_IMPORT_INFOLOST ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // ----------------------------------------------------------------------- +/*N*/ +/*N*/ ScDPSaveMember::ScDPSaveMember(const String& rName) : +/*N*/ aName( rName ), +/*N*/ nVisibleMode( SC_DPSAVEMODE_DONTKNOW ), +/*N*/ nShowDetailsMode( SC_DPSAVEMODE_DONTKNOW ) +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ ScDPSaveMember::ScDPSaveMember(const ScDPSaveMember& r) : +/*N*/ aName( r.aName ), +/*N*/ nVisibleMode( r.nVisibleMode ), +/*N*/ nShowDetailsMode( r.nShowDetailsMode ) +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ ScDPSaveMember::ScDPSaveMember(SvStream& rStream) +/*N*/ { +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream >> nVisibleMode; +/*N*/ rStream >> nShowDetailsMode; +/*N*/ +/*N*/ lcl_SkipExtra( rStream ); // reads at least 1 USHORT +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveMember::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ rStream.WriteByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream << nVisibleMode; +/*N*/ rStream << nShowDetailsMode; +/*N*/ +/*N*/ rStream << (USHORT) 0; // nExtra +/*N*/ } +/*N*/ +/*N*/ ScDPSaveMember::~ScDPSaveMember() +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ BOOL ScDPSaveMember::operator== ( const ScDPSaveMember& r ) const +/*N*/ { +/*N*/ if ( aName != r.aName || +/*N*/ nVisibleMode != r.nVisibleMode || +/*N*/ nShowDetailsMode != r.nShowDetailsMode ) +/*N*/ return FALSE; +/*N*/ +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveMember::SetIsVisible(BOOL bSet) +/*N*/ { +/*N*/ nVisibleMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveMember::SetShowDetails(BOOL bSet) +/*N*/ { +/*N*/ nShowDetailsMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveMember::WriteToSource( const uno::Reference<uno::XInterface>& xMember ) +/*N*/ { +/*N*/ // nothing to do? +/*N*/ if ( nVisibleMode == SC_DPSAVEMODE_DONTKNOW && nShowDetailsMode == SC_DPSAVEMODE_DONTKNOW ) +/*N*/ return; +/*N*/ +/*N*/ uno::Reference<beans::XPropertySet> xMembProp( xMember, uno::UNO_QUERY ); +/*N*/ DBG_ASSERT( xMembProp.is(), "no properties at member" ); +/*N*/ if ( xMembProp.is() ) +/*N*/ { +/*N*/ // exceptions are caught at ScDPSaveData::WriteToSource +/*N*/ +/*N*/ if ( nVisibleMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xMembProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ISVISIBLE), (BOOL)nVisibleMode ); +/*N*/ +/*N*/ if ( nShowDetailsMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xMembProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_SHOWDETAILS), (BOOL)nShowDetailsMode ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // ----------------------------------------------------------------------- +/*N*/ +/*N*/ ScDPSaveDimension::ScDPSaveDimension(const String& rName, BOOL bDataLayout) : +/*N*/ aName( rName ), +/*N*/ bIsDataLayout( bDataLayout ), +/*N*/ bDupFlag( FALSE ), +/*N*/ nOrientation( sheet::DataPilotFieldOrientation_HIDDEN ), +/*N*/ bSubTotalDefault( TRUE ), +/*N*/ nSubTotalCount( 0 ), +/*N*/ pSubTotalFuncs( NULL ), +/*N*/ nShowEmptyMode( SC_DPSAVEMODE_DONTKNOW ), +/*N*/ nFunction( sheet::GeneralFunction_AUTO ), +/*N*/ nUsedHierarchy( -1 ), +/*N*/ pLayoutName( NULL ) +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ ScDPSaveDimension::ScDPSaveDimension(const ScDPSaveDimension& r) : +/*N*/ aName( r.aName ), +/*N*/ bIsDataLayout( r.bIsDataLayout ), +/*N*/ bDupFlag( r.bDupFlag ), +/*N*/ nOrientation( r.nOrientation ), +/*N*/ bSubTotalDefault( r.bSubTotalDefault ), +/*N*/ nSubTotalCount( r.nSubTotalCount ), +/*N*/ pSubTotalFuncs( NULL ), +/*N*/ nShowEmptyMode( r.nShowEmptyMode ), +/*N*/ nFunction( r.nFunction ), +/*N*/ nUsedHierarchy( r.nUsedHierarchy ) +/*N*/ { +/*N*/ if ( nSubTotalCount && r.pSubTotalFuncs ) +/*N*/ { +/*N*/ pSubTotalFuncs = new USHORT[nSubTotalCount]; +/*N*/ for (long nSub=0; nSub<nSubTotalCount; nSub++) +/*N*/ pSubTotalFuncs[nSub] = r.pSubTotalFuncs[nSub]; +/*N*/ } +/*N*/ +/*N*/ long nCount = r.aMemberList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveMember* pNew = new ScDPSaveMember( *(ScDPSaveMember*)r.aMemberList.GetObject(i) ); +/*N*/ aMemberList.Insert( pNew, LIST_APPEND ); +/*N*/ } +/*N*/ if (r.pLayoutName) +/*N*/ pLayoutName = new String( *(r.pLayoutName) ); +/*N*/ else +/*N*/ pLayoutName = NULL; +/*N*/ } +/*N*/ +/*N*/ ScDPSaveDimension::ScDPSaveDimension(SvStream& rStream) +/*N*/ { +/*N*/ long i; +/*N*/ +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream >> bIsDataLayout; +/*N*/ +/*N*/ rStream >> bDupFlag; +/*N*/ +/*N*/ rStream >> nOrientation; +/*N*/ rStream >> nFunction; // enum GeneralFunction +/*N*/ rStream >> nUsedHierarchy; +/*N*/ +/*N*/ rStream >> nShowEmptyMode; //! at level +/*N*/ +/*N*/ rStream >> bSubTotalDefault; //! at level +/*N*/ rStream >> nSubTotalCount; +/*N*/ if (nSubTotalCount) +/*N*/ { +/*N*/ pSubTotalFuncs = new USHORT[nSubTotalCount]; +/*N*/ for (i=0; i<nSubTotalCount; i++) +/*N*/ rStream >> pSubTotalFuncs[i]; +/*N*/ } +/*N*/ else +/*N*/ pSubTotalFuncs = NULL; +/*N*/ +/*N*/ lcl_SkipExtra( rStream ); // reads at least 1 USHORT +/*N*/ +/*N*/ long nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ for (i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ ScDPSaveMember* pNew = new ScDPSaveMember( rStream ); +/*N*/ aMemberList.Insert( pNew, LIST_APPEND ); +/*N*/ } +/*N*/ pLayoutName = NULL; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveDimension::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ long i; +/*N*/ +/*N*/ rStream.WriteByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream << bIsDataLayout; +/*N*/ +/*N*/ rStream << bDupFlag; +/*N*/ +/*N*/ rStream << nOrientation; +/*N*/ rStream << nFunction; // enum GeneralFunction +/*N*/ rStream << nUsedHierarchy; +/*N*/ +/*N*/ rStream << nShowEmptyMode; //! at level +/*N*/ +/*N*/ //! subtotals at level +/*N*/ rStream << bSubTotalDefault; +/*N*/ long nSubCnt = pSubTotalFuncs ? nSubTotalCount : 0; +/*N*/ rStream << nSubCnt; +/*N*/ for (i=0; i<nSubCnt; i++) +/*N*/ rStream << pSubTotalFuncs[i]; +/*N*/ +/*N*/ rStream << (USHORT) 0; // nExtra +/*N*/ +/*N*/ long nCount = aMemberList.Count(); +/*N*/ rStream << nCount; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScDPSaveMember* pMember = (const ScDPSaveMember*)aMemberList.GetObject(i); +/*N*/ pMember->Store( rStream ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ ScDPSaveDimension::~ScDPSaveDimension() +/*N*/ { +/*N*/ long nCount = aMemberList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ delete (ScDPSaveMember*)aMemberList.GetObject(i); +/*N*/ aMemberList.Clear(); +/*N*/ if (pLayoutName) +/*N*/ delete pLayoutName; +/*N*/ delete [] pSubTotalFuncs; +/*N*/ } +/*N*/ +/*N*/ BOOL ScDPSaveDimension::operator== ( const ScDPSaveDimension& r ) const +/*N*/ { +/*N*/ if ( aName != r.aName || +/*N*/ bIsDataLayout != r.bIsDataLayout || +/*N*/ bDupFlag != r.bDupFlag || +/*N*/ nOrientation != r.nOrientation || +/*N*/ nFunction != r.nFunction || +/*N*/ nUsedHierarchy != r.nUsedHierarchy || +/*N*/ nShowEmptyMode != r.nShowEmptyMode || +/*N*/ bSubTotalDefault != r.bSubTotalDefault || +/*N*/ nSubTotalCount != r.nSubTotalCount ) +/*N*/ return FALSE; +/*N*/ +/*N*/ if ( nSubTotalCount && ( !pSubTotalFuncs || !r.pSubTotalFuncs ) ) // should not happen +/*N*/ return FALSE; +/*N*/ +/*N*/ long i; +/*N*/ for (i=0; i<nSubTotalCount; i++) +/*N*/ if ( pSubTotalFuncs[i] != r.pSubTotalFuncs[i] ) +/*N*/ return FALSE; +/*N*/ +/*N*/ long nCount = aMemberList.Count(); +/*N*/ if ( nCount != r.aMemberList.Count() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ( !( *(ScDPSaveMember*)aMemberList.GetObject(i) == +/*N*/ *(ScDPSaveMember*)r.aMemberList.GetObject(i) ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ +/*N*/ void ScDPSaveDimension::SetOrientation(USHORT nNew) +/*N*/ { +/*N*/ nOrientation = nNew; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveDimension::SetSubTotals(long nCount, const USHORT* pFuncs) +/*N*/ { +/*N*/ if (pSubTotalFuncs) +/*N*/ delete pSubTotalFuncs; +/*N*/ nSubTotalCount = nCount; +/*N*/ if ( nCount && pFuncs ) +/*N*/ { +/*N*/ pSubTotalFuncs = new USHORT[nCount]; +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ pSubTotalFuncs[i] = pFuncs[i]; +/*N*/ } +/*N*/ else +/*N*/ pSubTotalFuncs = NULL; +/*N*/ +/*N*/ bSubTotalDefault = FALSE; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveDimension::SetShowEmpty(BOOL bSet) +/*N*/ { +/*N*/ nShowEmptyMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveDimension::SetFunction(USHORT nNew) +/*N*/ { +/*N*/ nFunction = nNew; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveDimension::SetUsedHierarchy(long nNew) +/*N*/ { +/*N*/ nUsedHierarchy = nNew; +/*N*/ } + +/*N*/ BOOL ScDPSaveDimension::HasLayoutName() const +/*N*/ { +/*N*/ return ( pLayoutName != NULL ); +/*N*/ } + +/*N*/ void ScDPSaveDimension::ResetLayoutName() +/*N*/ { +/*N*/ delete pLayoutName; +/*N*/ pLayoutName = NULL; +/*N*/ } + +/*N*/ void ScDPSaveDimension::SetLayoutName(const String* pName) +/*N*/ { +/*N*/ if (pName) +/*N*/ { +/*N*/ if (pLayoutName) +/*N*/ delete pLayoutName; +/*N*/ pLayoutName = new String( *pName ); +/*N*/ } +/*N*/ } + +/*N*/ const String& ScDPSaveDimension::GetLayoutName() const +/*N*/ { +/*N*/ if (pLayoutName) +/*N*/ return *pLayoutName; +/*N*/ return aName; +/*N*/ } + +/*N*/ void ScDPSaveDimension::WriteToSource( const uno::Reference<uno::XInterface>& xDim ) +/*N*/ { +/*N*/ uno::Reference<beans::XPropertySet> xDimProp( xDim, uno::UNO_QUERY ); +/*N*/ DBG_ASSERT( xDimProp.is(), "no properties at dimension" ); +/*N*/ if ( xDimProp.is() ) +/*N*/ { +/*N*/ // exceptions are caught at ScDPSaveData::WriteToSource +/*N*/ uno::Any aAny; +/*N*/ +/*N*/ sheet::DataPilotFieldOrientation eOrient = (sheet::DataPilotFieldOrientation)nOrientation; +/*N*/ aAny <<= eOrient; +/*N*/ xDimProp->setPropertyValue( ::rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), aAny ); +/*N*/ +/*N*/ sheet::GeneralFunction eFunc = (sheet::GeneralFunction)nFunction; +/*N*/ aAny <<= eFunc; +/*N*/ xDimProp->setPropertyValue( ::rtl::OUString::createFromAscii(DP_PROP_FUNCTION), aAny ); +/*N*/ +/*N*/ if ( nUsedHierarchy >= 0 ) +/*N*/ { +/*N*/ aAny <<= (INT32)nUsedHierarchy; +/*N*/ xDimProp->setPropertyValue( ::rtl::OUString::createFromAscii(DP_PROP_USEDHIERARCHY), aAny ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Level loop outside of aMemberList loop +/*N*/ // because SubTotals have to be set independently of known members +/*N*/ +/*N*/ long nCount = aMemberList.Count(); +/*N*/ +/*N*/ long nHierCount = 0; +/*N*/ uno::Reference<container::XIndexAccess> xHiers; +/*N*/ uno::Reference<sheet::XHierarchiesSupplier> xHierSupp( xDim, uno::UNO_QUERY ); +/*N*/ if ( xHierSupp.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XNameAccess> xHiersName = xHierSupp->getHierarchies(); +/*N*/ xHiers = new ScNameToIndexAccess( xHiersName ); +/*N*/ nHierCount = xHiers->getCount(); +/*N*/ } +/*N*/ +/*N*/ for (long nHier=0; nHier<nHierCount; nHier++) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xHierarchy = ScUnoHelpFunctions::AnyToInterface( xHiers->getByIndex(nHier) ); +/*N*/ +/*N*/ long nLevCount = 0; +/*N*/ uno::Reference<container::XIndexAccess> xLevels; +/*N*/ uno::Reference<sheet::XLevelsSupplier> xLevSupp( xHierarchy, uno::UNO_QUERY ); +/*N*/ if ( xLevSupp.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XNameAccess> xLevelsName = xLevSupp->getLevels(); +/*N*/ xLevels = new ScNameToIndexAccess( xLevelsName ); +/*N*/ nLevCount = xLevels->getCount(); +/*N*/ } +/*N*/ +/*N*/ for (long nLev=0; nLev<nLevCount; nLev++) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xLevel = ScUnoHelpFunctions::AnyToInterface( xLevels->getByIndex(nLev) ); +/*N*/ uno::Reference<beans::XPropertySet> xLevProp( xLevel, uno::UNO_QUERY ); +/*N*/ DBG_ASSERT( xLevProp.is(), "no properties at level" ); +/*N*/ if ( xLevProp.is() ) +/*N*/ { +/*N*/ if ( !bSubTotalDefault ) +/*N*/ { +/*N*/ if ( !pSubTotalFuncs ) +/*N*/ nSubTotalCount = 0; +/*N*/ +/*N*/ uno::Sequence<sheet::GeneralFunction> aSeq(nSubTotalCount); +/*N*/ sheet::GeneralFunction* pArray = aSeq.getArray(); +/*N*/ for (long i=0; i<nSubTotalCount; i++) +/*N*/ pArray[i] = (sheet::GeneralFunction)pSubTotalFuncs[i]; +/*N*/ uno::Any aAny; +/*N*/ aAny <<= aSeq; +/*N*/ xLevProp->setPropertyValue( ::rtl::OUString::createFromAscii(DP_PROP_SUBTOTALS), aAny ); +/*N*/ } +/*N*/ if ( nShowEmptyMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xLevProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_SHOWEMPTY), (BOOL)nShowEmptyMode ); +/*N*/ +/*N*/ // exceptions are caught at ScDPSaveData::WriteToSource +/*N*/ } +/*N*/ +/*N*/ if ( nCount > 0 ) +/*N*/ { +/*N*/ uno::Reference<sheet::XMembersSupplier> xMembSupp( xLevel, uno::UNO_QUERY ); +/*N*/ if ( xMembSupp.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XNameAccess> xMembers = xMembSupp->getMembers(); +/*N*/ if ( xMembers.is() ) +/*N*/ { +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveMember* pMember = (ScDPSaveMember*)aMemberList.GetObject(i); +/*N*/ ::rtl::OUString aName = pMember->GetName(); +/*N*/ if ( xMembers->hasByName( aName ) ) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xMemberInt = ScUnoHelpFunctions::AnyToInterface( +/*N*/ xMembers->getByName( aName ) ); +/*N*/ pMember->WriteToSource( xMemberInt ); +/*N*/ } +/*N*/ // missing member is no error +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +// ----------------------------------------------------------------------- + +/*N*/ ScDPSaveData::ScDPSaveData() : +/*N*/ nColumnGrandMode( SC_DPSAVEMODE_DONTKNOW ), +/*N*/ nRowGrandMode( SC_DPSAVEMODE_DONTKNOW ), +/*N*/ nIgnoreEmptyMode( SC_DPSAVEMODE_DONTKNOW ), +/*N*/ nRepeatEmptyMode( SC_DPSAVEMODE_DONTKNOW ) +/*N*/ { +/*N*/ } + +/*N*/ ScDPSaveData::ScDPSaveData(const ScDPSaveData& r) : +/*N*/ nColumnGrandMode( r.nColumnGrandMode ), +/*N*/ nRowGrandMode( r.nRowGrandMode ), +/*N*/ nIgnoreEmptyMode( r.nIgnoreEmptyMode ), +/*N*/ nRepeatEmptyMode( r.nRepeatEmptyMode ) +/*N*/ { +/*N*/ long nCount = r.aDimList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pNew = new ScDPSaveDimension( *(ScDPSaveDimension*)r.aDimList.GetObject(i) ); +/*N*/ aDimList.Insert( pNew, LIST_APPEND ); +/*N*/ } +/*N*/ } + +/*N*/ ScDPSaveData& ScDPSaveData::operator= ( const ScDPSaveData& r ) +/*N*/ { +/*N*/ if ( &r != this ) +/*N*/ { +/*N*/ nColumnGrandMode = r.nColumnGrandMode; +/*N*/ nRowGrandMode = r.nRowGrandMode; +/*N*/ nIgnoreEmptyMode = r.nIgnoreEmptyMode; +/*N*/ nRepeatEmptyMode = r.nRepeatEmptyMode; +/*N*/ +/*N*/ // remove old dimensions +/*N*/ +/*N*/ long nCount = aDimList.Count(); +/*N*/ long i; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ delete (ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ aDimList.Clear(); +/*N*/ +/*N*/ // copy new dimensions +/*N*/ +/*N*/ nCount = r.aDimList.Count(); +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pNew = +/*N*/ new ScDPSaveDimension( *(ScDPSaveDimension*)r.aDimList.GetObject(i) ); +/*N*/ aDimList.Insert( pNew, LIST_APPEND ); +/*N*/ } +/*N*/ } +/*N*/ return *this; +/*N*/ } +/*N*/ +/*N*/ BOOL ScDPSaveData::operator== ( const ScDPSaveData& r ) const +/*N*/ { +/*N*/ if ( nColumnGrandMode != r.nColumnGrandMode || +/*N*/ nRowGrandMode != r.nRowGrandMode || +/*N*/ nIgnoreEmptyMode != r.nIgnoreEmptyMode || +/*N*/ nRepeatEmptyMode != r.nRepeatEmptyMode ) +/*N*/ return FALSE; +/*N*/ +/*N*/ long nCount = aDimList.Count(); +/*N*/ if ( nCount != r.aDimList.Count() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ if ( !( *(ScDPSaveDimension*)aDimList.GetObject(i) == +/*N*/ *(ScDPSaveDimension*)r.aDimList.GetObject(i) ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +/*N*/ ScDPSaveData::~ScDPSaveData() +/*N*/ { +/*N*/ long nCount = aDimList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ delete (ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ aDimList.Clear(); +/*N*/ } + +/*N*/ ScDPSaveDimension* ScDPSaveData::GetDimensionByName(const String& rName) +/*N*/ { +/*N*/ long nCount = aDimList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ if ( pDim->GetName() == rName && !pDim->IsDataLayout() ) +/*N*/ return pDim; +/*N*/ } +/*N*/ ScDPSaveDimension* pNew = new ScDPSaveDimension( rName, FALSE ); +/*N*/ aDimList.Insert( pNew, LIST_APPEND ); +/*N*/ return pNew; +/*N*/ } + +/*N*/ ScDPSaveDimension* ScDPSaveData::GetExistingDimensionByName(const String& rName) +/*N*/ { +/*N*/ long nCount = aDimList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ if ( pDim->GetName() == rName && !pDim->IsDataLayout() ) +/*N*/ return pDim; +/*N*/ } +/*N*/ return NULL; // don't create new +/*N*/ } + +/*N*/ ScDPSaveDimension* ScDPSaveData::GetDataLayoutDimension() +/*N*/ { +/*N*/ long nCount = aDimList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ if ( pDim->IsDataLayout() ) +/*N*/ return pDim; +/*N*/ } +/*N*/ ScDPSaveDimension* pNew = new ScDPSaveDimension( String(), TRUE ); +/*N*/ aDimList.Insert( pNew, LIST_APPEND ); +/*N*/ return pNew; +/*N*/ } +/*N*/ +/*N*/ ScDPSaveDimension* ScDPSaveData::DuplicateDimension(const String& rName) +/*N*/ { +/*N*/ // always insert new +/*N*/ //! check if dimension is there? +/*N*/ +/*N*/ ScDPSaveDimension* pOld = GetDimensionByName( rName ); +/*N*/ ScDPSaveDimension* pNew = new ScDPSaveDimension( *pOld ); +/*N*/ pNew->SetDupFlag( TRUE ); +/*N*/ aDimList.Insert( pNew, LIST_APPEND ); +/*N*/ return pNew; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::SetColumnGrand(BOOL bSet) +/*N*/ { +/*N*/ nColumnGrandMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::SetRowGrand(BOOL bSet) +/*N*/ { +/*N*/ nRowGrandMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::SetIgnoreEmptyRows(BOOL bSet) +/*N*/ { +/*N*/ nIgnoreEmptyMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::SetRepeatIfEmpty(BOOL bSet) +/*N*/ { +/*N*/ nRepeatEmptyMode = bSet; +/*N*/ } +/*N*/ +/*N*/ void lcl_ResetOrient( const uno::Reference<sheet::XDimensionsSupplier>& xSource ) +/*N*/ { +/*N*/ sheet::DataPilotFieldOrientation eOrient = sheet::DataPilotFieldOrientation_HIDDEN; +/*N*/ +/*N*/ uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions(); +/*N*/ uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName ); +/*N*/ long nIntCount = xIntDims->getCount(); +/*N*/ for (long nIntDim=0; nIntDim<nIntCount; nIntDim++) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) ); +/*N*/ uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY ); +/*N*/ if (xDimProp.is()) +/*N*/ { +/*N*/ uno::Any aAny; +/*N*/ aAny <<= eOrient; +/*N*/ xDimProp->setPropertyValue( ::rtl::OUString::createFromAscii(DP_PROP_ORIENTATION), aAny ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::WriteToSource( const uno::Reference<sheet::XDimensionsSupplier>& xSource ) +/*N*/ { +/*N*/ if (!xSource.is()) +/*N*/ return; +/*N*/ +/*N*/ // source options must be first! +/*N*/ +/*N*/ uno::Reference<beans::XPropertySet> xSourceProp( xSource, uno::UNO_QUERY ); +/*N*/ DBG_ASSERT( xSourceProp.is(), "no properties at source" ); +/*N*/ if ( xSourceProp.is() ) +/*N*/ { +/*N*/ // source options are not available for external sources +/*N*/ //! use XPropertySetInfo to test for availability? +/*N*/ +/*N*/ try +/*N*/ { +/*N*/ if ( nIgnoreEmptyMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xSourceProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_IGNOREEMPTY), (BOOL)nIgnoreEmptyMode ); +/*N*/ if ( nRepeatEmptyMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xSourceProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_REPEATIFEMPTY), (BOOL)nRepeatEmptyMode ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ // no error +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // exceptions in the other calls are errors +/*N*/ try +/*N*/ { +/*N*/ // reset all orientations +/*N*/ //! "forgetSettings" or similar at source ????? +/*N*/ //! reset all duplicated dimensions, or reuse them below !!! +/*N*/ +/*N*/ lcl_ResetOrient( xSource ); +/*N*/ +/*N*/ long nCount = aDimList.Count(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pDim = (ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ ::rtl::OUString aName = pDim->GetName(); +/*N*/ BOOL bData = pDim->IsDataLayout(); +/*N*/ +/*N*/ //! getByName for ScDPSource, including DataLayoutDimension !!!!!!!! +/*N*/ +/*N*/ uno::Reference<container::XNameAccess> xDimsName = xSource->getDimensions(); +/*N*/ uno::Reference<container::XIndexAccess> xIntDims = new ScNameToIndexAccess( xDimsName ); +/*N*/ long nIntCount = xIntDims->getCount(); +/*N*/ BOOL bFound = FALSE; +/*N*/ for (long nIntDim=0; nIntDim<nIntCount && !bFound; nIntDim++) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xIntDim = ScUnoHelpFunctions::AnyToInterface( xIntDims->getByIndex(nIntDim) ); +/*N*/ if ( bData ) +/*N*/ { +/*N*/ uno::Reference<beans::XPropertySet> xDimProp( xIntDim, uno::UNO_QUERY ); +/*N*/ if ( xDimProp.is() ) +/*N*/ { +/*N*/ bFound = ScUnoHelpFunctions::GetBoolProperty( xDimProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ISDATALAYOUT) ); +/*N*/ //! error checking -- is "IsDataLayoutDimension" property required?? +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ uno::Reference<container::XNamed> xDimName( xIntDim, uno::UNO_QUERY ); +/*N*/ if ( xDimName.is() && xDimName->getName() == aName ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ +/*N*/ if ( bFound ) +/*N*/ { +/*N*/ if ( pDim->GetDupFlag() ) +/*N*/ { +/*N*/ String aNewName = pDim->GetName(); +/*N*/ +/*N*/ // different name for each duplication of a (real) dimension... +/*N*/ for (long j=0; j<=i; j++) //! Test !!!!!! +/*N*/ aNewName += '*'; //! modify name at creation of SaveDimension +/*N*/ +/*N*/ uno::Reference<util::XCloneable> xCloneable( xIntDim, uno::UNO_QUERY ); +/*N*/ DBG_ASSERT( xCloneable.is(), "cannot clone dimension" ); +/*N*/ if (xCloneable.is()) +/*N*/ { +/*N*/ uno::Reference<util::XCloneable> xNew = xCloneable->createClone(); +/*N*/ uno::Reference<container::XNamed> xNewName( xNew, uno::UNO_QUERY ); +/*N*/ if (xNewName.is()) +/*N*/ { +/*N*/ xNewName->setName( aNewName ); +/*N*/ pDim->WriteToSource( xNew ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ pDim->WriteToSource( xIntDim ); +/*N*/ } +/*N*/ } +/*N*/ DBG_ASSERT(bFound, "WriteToSource: Dimension not found"); +/*N*/ } +/*N*/ +/*N*/ if ( xSourceProp.is() ) +/*N*/ { +/*N*/ if ( nColumnGrandMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xSourceProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_COLUMNGRAND), (BOOL)nColumnGrandMode ); +/*N*/ if ( nRowGrandMode != SC_DPSAVEMODE_DONTKNOW ) +/*N*/ lcl_SetBoolProperty( xSourceProp, +/*N*/ ::rtl::OUString::createFromAscii(DP_PROP_ROWGRAND), (BOOL)nRowGrandMode ); +/*N*/ } +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ DBG_ERROR("exception in WriteToSource"); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ //! multi-header for individual entries +/*N*/ +/*N*/ long nCount = aDimList.Count(); +/*N*/ rStream << nCount; +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScDPSaveDimension* pDim = (const ScDPSaveDimension*)aDimList.GetObject(i); +/*N*/ pDim->Store( rStream ); +/*N*/ } +/*N*/ +/*N*/ rStream << nColumnGrandMode; +/*N*/ rStream << nRowGrandMode; +/*N*/ rStream << nIgnoreEmptyMode; +/*N*/ rStream << nRepeatEmptyMode; +/*N*/ +/*N*/ rStream << (USHORT) 0; // nExtra +/*N*/ } +/*N*/ +/*N*/ void ScDPSaveData::Load( SvStream& rStream ) +/*N*/ { +/*N*/ //! multi-header for individual entries +/*N*/ +/*N*/ DBG_ASSERT( aDimList.Count()==0, "ScDPSaveData::Load not empty" ); +/*N*/ +/*N*/ long nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ for (long i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ ScDPSaveDimension* pNew = new ScDPSaveDimension( rStream ); +/*N*/ aDimList.Insert( pNew, LIST_APPEND ); +/*N*/ } +/*N*/ +/*N*/ rStream >> nColumnGrandMode; +/*N*/ rStream >> nRowGrandMode; +/*N*/ rStream >> nIgnoreEmptyMode; +/*N*/ rStream >> nRepeatEmptyMode; +/*N*/ +/*N*/ lcl_SkipExtra( rStream ); // reads at least 1 USHORT +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dpshttab.cxx b/binfilter/bf_sc/source/core/data/sc_dpshttab.cxx new file mode 100644 index 000000000000..52864e35cdf1 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dpshttab.cxx @@ -0,0 +1,230 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE -------------------------------------------------------------- + +#include <tools/debug.hxx> +#include <bf_svtools/zforlist.hxx> + +#include "dpshttab.hxx" +#include "document.hxx" +#include "collect.hxx" +#include "globstr.hrc" +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ class ScSheetDPData_Impl +/*N*/ { +/*N*/ public: +/*N*/ ScDocument* pDoc; +/*N*/ ScRange aRange; +/*N*/ ScQueryParam aQuery; +/*N*/ long nColCount; +/*N*/ BOOL bIgnoreEmptyRows; +/*N*/ BOOL bRepeatIfEmpty; +/*N*/ TypedStrCollection** ppStrings; +/*N*/ BOOL* pDateDim; +/*N*/ USHORT nNextRow; // for iterator, within range +/*N*/ +/*N*/ ScSheetDPData_Impl() {} +/*N*/ }; + +// ----------------------------------------------------------------------- + +/*M*/ ScSheetDPData::ScSheetDPData( ScDocument* pD, const ScSheetSourceDesc& rDesc ) +/*M*/ : pSpecial(NULL) +/*M*/ { +/*M*/ long nCount = rDesc.aSourceRange.aEnd.Col() - rDesc.aSourceRange.aStart.Col() + 1; +/*M*/ pImpl = new ScSheetDPData_Impl; +/*M*/ pImpl->pDoc = pD; +/*M*/ pImpl->aRange = rDesc.aSourceRange; +/*M*/ pImpl->aQuery = rDesc.aQueryParam; +/*M*/ pImpl->bIgnoreEmptyRows = FALSE; +/*M*/ pImpl->bRepeatIfEmpty = FALSE; +/*M*/ pImpl->nColCount = nCount; +/*M*/ pImpl->ppStrings = new TypedStrCollection*[nCount]; +/*M*/ pImpl->pDateDim = NULL; +/*M*/ for (long i=0; i<nCount; i++) +/*M*/ pImpl->ppStrings[i] = NULL; +/*M*/ +/*M*/ pImpl->nNextRow = pImpl->aRange.aStart.Row() + 1; +/*M*/ +/*M*/ long nEntryCount(pImpl->aQuery.GetEntryCount()); +/*M*/ pSpecial = new BOOL[nEntryCount]; +/*M*/ for (long j = 0; j < nEntryCount; ++j ) +/*M*/ { +/*M*/ ScQueryEntry& rEntry = pImpl->aQuery.GetEntry(j); +/*M*/ if (rEntry.bDoQuery) +/*M*/ { +/*M*/ pSpecial[j] = false; +/*M*/ if (!rEntry.bQueryByString) +/*M*/ { +/*M*/ if (*rEntry.pStr == EMPTY_STRING && +/*M*/ ((rEntry.nVal == SC_EMPTYFIELDS) || (rEntry.nVal == SC_NONEMPTYFIELDS))) +/*M*/ pSpecial[j] = true; +/*M*/ } +/*M*/ else +/*M*/ { +/*M*/ sal_uInt32 nIndex = 0; +/*M*/ rEntry.bQueryByString = +/*M*/ !(pD->GetFormatTable()-> +/*M*/ IsNumberFormat(*rEntry.pStr, nIndex, rEntry.nVal)); +/*M*/ } +/*M*/ } +/*M*/ } +/*M*/ } + +/*N*/ ScSheetDPData::~ScSheetDPData() +/*N*/ { +/*N*/ for (long i=0; i<pImpl->nColCount; i++) +/*N*/ delete pImpl->ppStrings[i]; +/*N*/ delete[] pImpl->ppStrings; +/*N*/ delete[] pImpl->pDateDim; +/*N*/ delete pImpl; +/*M*/ delete[] pSpecial; +/*N*/ } + +/*N*/ void ScSheetDPData::DisposeData() +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*N*/ } + +/*N*/ long ScSheetDPData::GetColumnCount() +/*N*/ { +/*N*/ return pImpl->nColCount; +/*N*/ } + + +/*N*/ const TypedStrCollection& ScSheetDPData::GetColumnEntries(long nColumn) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 +/*N*/ } + +/*N*/ String ScSheetDPData::getDimensionName(long nColumn) +/*N*/ { +/*N*/ if (getIsDataLayoutDimension(nColumn)) +/*N*/ { +/*N*/ //! different internal and display names? +/*N*/ //return "Data"; +/*N*/ return ScGlobal::GetRscString(STR_PIVOT_DATA); +/*N*/ } +/*N*/ else if ( nColumn >= pImpl->nColCount ) +/*N*/ { +/*?*/ DBG_ERROR("getDimensionName: invalid dimension"); +/*?*/ return String(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nDocCol = (USHORT)(pImpl->aRange.aStart.Col() + nColumn); +/*N*/ USHORT nDocRow = pImpl->aRange.aStart.Row(); +/*N*/ USHORT nDocTab = pImpl->aRange.aStart.Tab(); +/*N*/ String aDocStr; +/*N*/ pImpl->pDoc->GetString( nDocCol, nDocRow, nDocTab, aDocStr ); +/*N*/ return aDocStr; +/*N*/ } +/*N*/ } + +/*N*/ BOOL lcl_HasDateFormat( ScDocument* pDoc, const ScRange& rRange ) +/*N*/ { +/*N*/ //! iterate formats in range? +/*N*/ +/*N*/ ScAddress aPos = rRange.aStart; +/*N*/ aPos.SetRow( aPos.Row() + 1 ); // below title +/*N*/ ULONG nFormat = pDoc->GetNumberFormat( aPos ); +/*N*/ SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); +/*N*/ return ( pFormatter->GetType(nFormat) & NUMBERFORMAT_DATE ) != 0; +/*N*/ } + +/*N*/ BOOL ScSheetDPData::IsDateDimension(long nDim) +/*N*/ { +/*N*/ if (getIsDataLayoutDimension(nDim)) +/*N*/ { +/*N*/ return FALSE; +/*N*/ } +/*N*/ else if ( nDim >= pImpl->nColCount ) +/*N*/ { +/*?*/ DBG_ERROR("IsDateDimension: invalid dimension"); +/*?*/ return FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (!pImpl->pDateDim) +/*N*/ { +/*N*/ pImpl->pDateDim = new BOOL[pImpl->nColCount]; +/*N*/ ScRange aTestRange = pImpl->aRange; +/*N*/ for (long i=0; i<pImpl->nColCount; i++) +/*N*/ { +/*N*/ USHORT nCol = (USHORT)( pImpl->aRange.aStart.Col() + i ); +/*N*/ aTestRange.aStart.SetCol(nCol); +/*N*/ aTestRange.aEnd.SetCol(nCol); +/*N*/ pImpl->pDateDim[i] = lcl_HasDateFormat( pImpl->pDoc, aTestRange ); +/*N*/ } +/*N*/ } +/*N*/ return pImpl->pDateDim[nDim]; +/*N*/ } +/*N*/ } + +/*N*/ UINT32 ScSheetDPData::GetNumberFormat(long nDim) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return 0; //STRIP001 +/*N*/ } + +/*N*/ BOOL ScSheetDPData::getIsDataLayoutDimension(long nColumn) +/*N*/ { +/*N*/ return ( nColumn == pImpl->nColCount ); +/*N*/ } + +/*N*/ void ScSheetDPData::SetEmptyFlags( BOOL bIgnoreEmptyRows, BOOL bRepeatIfEmpty ) +/*N*/ { +/*N*/ pImpl->bIgnoreEmptyRows = bIgnoreEmptyRows; +/*N*/ pImpl->bRepeatIfEmpty = bRepeatIfEmpty; +/*N*/ } + +/*N*/ void ScSheetDPData::ResetIterator() +/*N*/ { +/*N*/ pImpl->nNextRow = pImpl->aRange.aStart.Row() + 1; +/*N*/ } + + +/*N*/ BOOL ScSheetDPData::GetNextRow( const ScDPTableIteratorParam& rParam ) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return FALSE; //STRIP001 +/*N*/ } + +// ----------------------------------------------------------------------- + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dptabdat.cxx b/binfilter/bf_sc/source/core/data/sc_dptabdat.cxx new file mode 100644 index 000000000000..97f599589dc2 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dptabdat.cxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + +#include "dptabdat.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ ScDPTableData::ScDPTableData() +/*N*/ { +/*N*/ nLastDateVal = nLastHier = nLastLevel = nLastRet = -1; // invalid +/*N*/ +/*N*/ //! reset before new calculation (in case the base date is changed) +/*N*/ } + +/*N*/ ScDPTableData::~ScDPTableData() +/*N*/ { +/*N*/ } + + + +// ----------------------------------------------------------------------- + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_dptabsrc.cxx b/binfilter/bf_sc/source/core/data/sc_dptabsrc.cxx new file mode 100644 index 000000000000..20b0178bb76f --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_dptabsrc.cxx @@ -0,0 +1,1151 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <tools/debug.hxx> +#include <rtl/math.hxx> +#include <bf_svtools/itemprop.hxx> +#include <vcl/svapp.hxx> + +#include "dptabsrc.hxx" +#include "dptabdat.hxx" +#include "global.hxx" +#include "collect.hxx" +#include "datauno.hxx" // ScDataUnoConversion +#include "miscuno.hxx" +#include "unonames.hxx" +#include "dptabres.hxx" + +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/sheet/DataPilotFieldOrientation.hpp> + +#include <unotools/calendarwrapper.hxx> +#include <com/sun/star/i18n/CalendarDisplayIndex.hpp> +namespace binfilter { + +using namespace ::com::sun::star; + +// ----------------------------------------------------------------------- + +#define SC_MINCOUNT_LIMIT 1000000 + +// ----------------------------------------------------------------------- + +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPSource, "ScDPSource", "com.sun.star.sheet.DataPilotSource" ) +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPDimensions, "ScDPDimensions", "com.sun.star.sheet.DataPilotSourceDimensions" ) +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPDimension, "ScDPDimension", "com.sun.star.sheet.DataPilotSourceDimension" ) +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPHierarchies, "ScDPHierarchies", "com.sun.star.sheet.DataPilotSourceHierarcies" ) +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPHierarchy, "ScDPHierarchy", "com.sun.star.sheet.DataPilotSourceHierarcy" ) +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPLevels, "ScDPLevels", "com.sun.star.sheet.DataPilotSourceLevels" ) +/*N*/ SC_SIMPLE_SERVICE_INFO( ScDPLevel, "ScDPLevel", "com.sun.star.sheet.DataPilotSourceLevel" ) + +// ----------------------------------------------------------------------- + +// property maps for PropertySetInfo +// DataDescription / NumberFormat are internal + +// ----------------------------------------------------------------------- + +//! move to a header? +/*N*/ BOOL lcl_GetBoolFromAny( const uno::Any& aAny ) +/*N*/ { +/*N*/ if ( aAny.getValueTypeClass() == uno::TypeClass_BOOLEAN ) +/*N*/ return *(sal_Bool*)aAny.getValue(); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void lcl_SetBoolInAny( uno::Any& rAny, BOOL bValue ) +/*N*/ { +/*N*/ rAny.setValue( &bValue, getBooleanCppuType() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScDPSource::ScDPSource( ScDPTableData* pD ) : +/*N*/ pData( pD ), +/*N*/ pDimensions( NULL ), +/*N*/ nColDimCount( 0 ), +/*N*/ nRowDimCount( 0 ), +/*N*/ nDataDimCount( 0 ), +/*N*/ nPageDimCount( 0 ), +/*N*/ nDupCount( 0 ), +/*N*/ bResultOverflow( FALSE ), +/*N*/ pResData( NULL ), +/*N*/ pColResRoot( NULL ), +/*N*/ pRowResRoot( NULL ), +/*N*/ pColResults( NULL ), +/*N*/ pRowResults( NULL ), +/*N*/ bColumnGrand( TRUE ), // default is true +/*N*/ bRowGrand( TRUE ), +/*N*/ bIgnoreEmptyRows( FALSE ), +/*N*/ bRepeatIfEmpty( FALSE ) +/*N*/ { +/*N*/ pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty ); +/*N*/ } + +/*N*/ ScDPSource::~ScDPSource() +/*N*/ { +/*N*/ delete pData; // ScDPTableData is not ref-counted +/*N*/ +/*N*/ if (pDimensions) +/*N*/ pDimensions->release(); // ref-counted +/*N*/ +/*N*/ //! free lists +/*N*/ +/*N*/ delete[] pColResults; +/*N*/ delete[] pRowResults; +/*N*/ +/*N*/ delete pColResRoot; +/*N*/ delete pRowResRoot; +/*N*/ delete pResData; +/*N*/ } + +/*N*/ USHORT ScDPSource::GetOrientation(long nColumn) +/*N*/ { +/*N*/ long i; +/*N*/ for (i=0; i<nColDimCount; i++) +/*N*/ if (nColDims[i] == nColumn) +/*N*/ return sheet::DataPilotFieldOrientation_COLUMN; +/*N*/ for (i=0; i<nRowDimCount; i++) +/*N*/ if (nRowDims[i] == nColumn) +/*N*/ return sheet::DataPilotFieldOrientation_ROW; +/*N*/ for (i=0; i<nDataDimCount; i++) +/*N*/ if (nDataDims[i] == nColumn) +/*N*/ return sheet::DataPilotFieldOrientation_DATA; +/*N*/ for (i=0; i<nPageDimCount; i++) +/*?*/ if (nPageDims[i] == nColumn) +/*?*/ return sheet::DataPilotFieldOrientation_PAGE; +/*N*/ return sheet::DataPilotFieldOrientation_HIDDEN; +/*N*/ } + + + +/*N*/ long ScDPSource::GetPosition(long nColumn) +/*N*/ { +/*N*/ long i; +/*N*/ for (i=0; i<nColDimCount; i++) +/*N*/ if (nColDims[i] == nColumn) +/*N*/ return i; +/*N*/ for (i=0; i<nRowDimCount; i++) +/*N*/ if (nRowDims[i] == nColumn) +/*N*/ return i; +/*N*/ for (i=0; i<nDataDimCount; i++) +/*N*/ if (nDataDims[i] == nColumn) +/*N*/ return i; +/*N*/ for (i=0; i<nPageDimCount; i++) +/*?*/ if (nPageDims[i] == nColumn) +/*?*/ return i; +/*N*/ return 0; +/*N*/ } + +/*N*/ BOOL lcl_TestSubTotal( BOOL& rAllowed, long nColumn, long* pArray, long nCount, ScDPSource* pSource ) +/*N*/ { +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ if (pArray[i] == nColumn) +/*N*/ { +/*N*/ // no subtotals for data layout dim, no matter where +/*N*/ if ( pSource->IsDataLayoutDimension(nColumn) ) +/*N*/ rAllowed = FALSE; +/*N*/ else +/*N*/ { +/*N*/ // no subtotals if no other dim but data layout follows +/*N*/ long nNextIndex = i+1; +/*N*/ if ( nNextIndex < nCount && pSource->IsDataLayoutDimension(pArray[nNextIndex]) ) +/*N*/ ++nNextIndex; +/*N*/ if ( nNextIndex >= nCount ) +/*N*/ rAllowed = FALSE; +/*N*/ } +/*N*/ +/*N*/ return TRUE; // found +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDPSource::SubTotalAllowed(long nColumn) +/*N*/ { +/*N*/ //! cache this at ScDPResultData +/*N*/ BOOL bAllowed = TRUE; +/*N*/ if ( lcl_TestSubTotal( bAllowed, nColumn, nColDims, nColDimCount, this ) ) +/*N*/ return bAllowed; +/*N*/ if ( lcl_TestSubTotal( bAllowed, nColumn, nRowDims, nRowDimCount, this ) ) +/*N*/ return bAllowed; +/*N*/ return bAllowed; +/*N*/ } + +/*N*/ void lcl_RemoveDim( long nRemove, long* pDims, long& rCount ) +/*N*/ { +/*N*/ for (long i=0; i<rCount; i++) +/*N*/ if ( pDims[i] == nRemove ) +/*N*/ { +/*?*/ for (long j=i; j+1<rCount; j++) +/*?*/ pDims[j] = pDims[j+1]; +/*?*/ --rCount; +/*?*/ return; +/*N*/ } +/*N*/ } + +/*N*/ void ScDPSource::SetOrientation(long nColumn, USHORT nNew) +/*N*/ { +/*N*/ //! change to no-op if new orientation is equal to old? +/*N*/ +/*N*/ // remove from old list +/*N*/ lcl_RemoveDim( nColumn, nColDims, nColDimCount ); +/*N*/ lcl_RemoveDim( nColumn, nRowDims, nRowDimCount ); +/*N*/ lcl_RemoveDim( nColumn, nDataDims, nDataDimCount ); +/*N*/ lcl_RemoveDim( nColumn, nPageDims, nPageDimCount ); +/*N*/ +/*N*/ // add to new list +/*N*/ switch (nNew) +/*N*/ { +/*N*/ case sheet::DataPilotFieldOrientation_COLUMN: +/*N*/ nColDims[nColDimCount++] = nColumn; +/*N*/ break; +/*N*/ case sheet::DataPilotFieldOrientation_ROW: +/*N*/ nRowDims[nRowDimCount++] = nColumn; +/*N*/ break; +/*N*/ case sheet::DataPilotFieldOrientation_DATA: +/*N*/ nDataDims[nDataDimCount++] = nColumn; +/*N*/ break; +/*N*/ case sheet::DataPilotFieldOrientation_PAGE: +/*?*/ nPageDims[nPageDimCount++] = nColumn; +/*N*/ break; +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDPSource::IsDataLayoutDimension(long nDim) +/*N*/ { +/*N*/ return nDim == pData->GetColumnCount(); +/*N*/ } + + +/*N*/ BOOL ScDPSource::IsDateDimension(long nDim) +/*N*/ { +/*N*/ return pData->IsDateDimension(nDim); +/*N*/ } + +/*N*/ ScDPDimensions* ScDPSource::GetDimensionsObject() +/*N*/ { +/*N*/ if (!pDimensions) +/*N*/ { +/*N*/ pDimensions = new ScDPDimensions(this); +/*N*/ pDimensions->acquire(); // ref-counted +/*N*/ } +/*N*/ return pDimensions; +/*N*/ } + +/*N*/ uno::Reference<container::XNameAccess> SAL_CALL ScDPSource::getDimensions() throw(uno::RuntimeException) +/*N*/ { +/*N*/ return GetDimensionsObject(); +/*N*/ } + + + +/*N*/ long ScDPSource::GetSourceDim(long nDim) +/*N*/ { +/*N*/ // original source dimension or data layout dimension? +/*N*/ if ( nDim <= pData->GetColumnCount() ) +/*N*/ return nDim; +/*N*/ +/*?*/ if ( nDim < pDimensions->getCount() ) +/*?*/ { +/*?*/ ScDPDimension* pDimObj = pDimensions->getByIndex( nDim ); +/*?*/ if ( pDimObj ) +/*?*/ { +/*?*/ long nSource = pDimObj->GetSourceDim(); +/*?*/ if ( nSource >= 0 ) +/*?*/ return nSource; +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ DBG_ERROR("GetSourceDim: wrong dim"); +/*?*/ return nDim; +/*N*/ } + +/*?*/ uno::Sequence< uno::Sequence<sheet::DataResult> > SAL_CALL ScDPSource::getResults() +/*?*/ throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return uno::Sequence< uno::Sequence<sheet::DataResult> >(0); //STRIP001 +/*?*/ } + +/*?*/ void SAL_CALL ScDPSource::refresh() throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*?*/ } + +/*?*/ void SAL_CALL ScDPSource::addRefreshListener( const uno::Reference<util::XRefreshListener >& l ) +/*?*/ throw(uno::RuntimeException) +/*?*/ { +/*?*/ DBG_ERROR("not implemented"); //! exception? +/*?*/ } + +/*?*/ void SAL_CALL ScDPSource::removeRefreshListener( const uno::Reference<util::XRefreshListener >& l ) +/*?*/ throw(uno::RuntimeException) +/*?*/ { +/*?*/ DBG_ERROR("not implemented"); //! exception? +/*?*/ } + + +/*N*/ BOOL ScDPSource::getColumnGrand() const +/*N*/ { +/*N*/ return bColumnGrand; +/*N*/ } + +/*N*/ void ScDPSource::setColumnGrand(BOOL bSet) +/*N*/ { +/*N*/ bColumnGrand = bSet; +/*N*/ } + +/*N*/ BOOL ScDPSource::getRowGrand() const +/*N*/ { +/*N*/ return bRowGrand; +/*N*/ } + +/*N*/ void ScDPSource::setRowGrand(BOOL bSet) +/*N*/ { +/*N*/ bRowGrand = bSet; +/*N*/ } + +/*N*/ BOOL ScDPSource::getIgnoreEmptyRows() const +/*N*/ { +/*N*/ return bIgnoreEmptyRows; +/*N*/ } + +/*N*/ void ScDPSource::setIgnoreEmptyRows(BOOL bSet) +/*N*/ { +/*N*/ bIgnoreEmptyRows = bSet; +/*N*/ pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty ); +/*N*/ } + +/*N*/ BOOL ScDPSource::getRepeatIfEmpty() const +/*N*/ { +/*N*/ return bRepeatIfEmpty; +/*N*/ } + +/*N*/ void ScDPSource::setRepeatIfEmpty(BOOL bSet) +/*N*/ { +/*N*/ bRepeatIfEmpty = bSet; +/*N*/ pData->SetEmptyFlags( bIgnoreEmptyRows, bRepeatIfEmpty ); +/*N*/ } + + + + + + + + +// XPropertySet + +/*?*/ uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPSource::getPropertySetInfo() +/*?*/ throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return uno::Reference<beans::XPropertySetInfo>(0); //STRIP001 +/*?*/ } + +/*N*/ void SAL_CALL ScDPSource::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& aValue ) +/*N*/ throw(beans::UnknownPropertyException, beans::PropertyVetoException, +/*N*/ lang::IllegalArgumentException, lang::WrappedTargetException, +/*N*/ uno::RuntimeException) +/*N*/ { +/*N*/ String aNameStr = aPropertyName; +/*N*/ if ( aNameStr.EqualsAscii( SC_UNO_COLGRAND ) ) +/*N*/ setColumnGrand( lcl_GetBoolFromAny( aValue ) ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_ROWGRAND ) ) +/*N*/ setRowGrand( lcl_GetBoolFromAny( aValue ) ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_IGNOREEM ) ) +/*N*/ setIgnoreEmptyRows( lcl_GetBoolFromAny( aValue ) ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_REPEATIF ) ) +/*N*/ setRepeatIfEmpty( lcl_GetBoolFromAny( aValue ) ); +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("unknown property"); +/*N*/ //! THROW( UnknownPropertyException() ); +/*N*/ } +/*N*/ } + +/*N*/ uno::Any SAL_CALL ScDPSource::getPropertyValue( const ::rtl::OUString& aPropertyName ) +/*N*/ throw(beans::UnknownPropertyException, lang::WrappedTargetException, +/*N*/ uno::RuntimeException) +/*N*/ { +/*N*/ uno::Any aRet; +/*N*/ String aNameStr = aPropertyName; +/*N*/ if ( aNameStr.EqualsAscii( SC_UNO_COLGRAND ) ) +/*N*/ lcl_SetBoolInAny( aRet, getColumnGrand() ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_ROWGRAND ) ) +/*N*/ lcl_SetBoolInAny( aRet, getRowGrand() ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_IGNOREEM ) ) +/*N*/ lcl_SetBoolInAny( aRet, getIgnoreEmptyRows() ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_REPEATIF ) ) +/*N*/ lcl_SetBoolInAny( aRet, getRepeatIfEmpty() ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_DATADESC ) ) // read-only +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 aRet <<= ::rtl::OUString( getDataDescription() ); +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("unknown property"); +/*N*/ //! THROW( UnknownPropertyException() ); +/*N*/ } +/*N*/ return aRet; +/*N*/ } + +/*N*/ SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPSource ) + +// ----------------------------------------------------------------------- + +/*N*/ ScDPDimensions::ScDPDimensions( ScDPSource* pSrc ) : +/*N*/ pSource( pSrc ), +/*N*/ ppDims( NULL ) +/*N*/ { +/*N*/ //! hold pSource +/*N*/ +/*N*/ // include data layout dimension and duplicated dimensions +/*N*/ nDimCount = pSource->GetData()->GetColumnCount() + 1 + pSource->GetDupCount(); +/*N*/ } + +/*N*/ ScDPDimensions::~ScDPDimensions() +/*N*/ { +/*N*/ //! release pSource +/*N*/ +/*N*/ if (ppDims) +/*N*/ { +/*N*/ for (long i=0; i<nDimCount; i++) +/*N*/ if ( ppDims[i] ) +/*N*/ ppDims[i]->release(); // ref-counted +/*N*/ delete[] ppDims; +/*N*/ } +/*N*/ } + + +// very simple XNameAccess implementation using getCount/getByIndex + +/*N*/ uno::Any SAL_CALL ScDPDimensions::getByName( const ::rtl::OUString& aName ) +/*N*/ throw(container::NoSuchElementException, +/*N*/ lang::WrappedTargetException, uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ if ( getByIndex(i)->getName() == aName ) +/*N*/ { +/*N*/ uno::Reference<container::XNamed> xNamed = getByIndex(i); +/*N*/ uno::Any aRet; +/*N*/ aRet <<= xNamed; +/*N*/ return aRet; +/*N*/ } +/*N*/ +/*N*/ throw container::NoSuchElementException(); +/*N*/ return uno::Any(); +/*N*/ } + +/*N*/ uno::Sequence<rtl::OUString> SAL_CALL ScDPDimensions::getElementNames() throw(uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ uno::Sequence<rtl::OUString> aSeq(nCount); +/*N*/ ::rtl::OUString* pArr = aSeq.getArray(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ pArr[i] = getByIndex(i)->getName(); +/*N*/ return aSeq; +/*N*/ } + +/*?*/ sal_Bool SAL_CALL ScDPDimensions::hasByName( const ::rtl::OUString& aName ) throw(uno::RuntimeException) +/*?*/ { +/*?*/ long nCount = getCount(); +/*?*/ for (long i=0; i<nCount; i++) +/*?*/ if ( getByIndex(i)->getName() == aName ) +/*?*/ return TRUE; +/*?*/ return FALSE; +/*?*/ } + +/*?*/ uno::Type SAL_CALL ScDPDimensions::getElementType() throw(uno::RuntimeException) +/*?*/ { +/*?*/ return getCppuType((uno::Reference<container::XNamed>*)0); +/*?*/ } + +/*?*/ sal_Bool SAL_CALL ScDPDimensions::hasElements() throw(uno::RuntimeException) +/*?*/ { +/*?*/ return ( getCount() > 0 ); +/*?*/ } + +// end of XNameAccess implementation + +/*N*/ long ScDPDimensions::getCount() const +/*N*/ { +/*N*/ // in tabular data, every column of source data is a dimension +/*N*/ +/*N*/ return nDimCount; +/*N*/ } + +/*N*/ ScDPDimension* ScDPDimensions::getByIndex(long nIndex) const +/*N*/ { +/*N*/ if ( nIndex >= 0 && nIndex < nDimCount ) +/*N*/ { +/*N*/ if ( !ppDims ) +/*N*/ { +/*N*/ ((ScDPDimensions*)this)->ppDims = new ScDPDimension*[nDimCount]; +/*N*/ for (long i=0; i<nDimCount; i++) +/*N*/ ppDims[i] = NULL; +/*N*/ } +/*N*/ if ( !ppDims[nIndex] ) +/*N*/ { +/*N*/ ppDims[nIndex] = new ScDPDimension( pSource, nIndex ); +/*N*/ ppDims[nIndex]->acquire(); // ref-counted +/*N*/ } +/*N*/ +/*N*/ return ppDims[nIndex]; +/*N*/ } +/*N*/ +/*N*/ return NULL; //! exception? +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScDPDimension::ScDPDimension( ScDPSource* pSrc, long nD ) : +/*N*/ pSource( pSrc ), +/*N*/ nDim( nD ), +/*N*/ pHierarchies( NULL ), +/*N*/ nUsedHier( 0 ), +/*N*/ nFunction( SUBTOTAL_FUNC_SUM ), // sum is default +/*N*/ nSourceDim( -1 ) +/*N*/ { +/*N*/ //! hold pSource +/*N*/ } + +/*N*/ ScDPDimension::~ScDPDimension() +/*N*/ { +/*N*/ //! release pSource +/*N*/ +/*N*/ if ( pHierarchies ) +/*N*/ pHierarchies->release(); // ref-counted +/*N*/ } + +/*N*/ ScDPHierarchies* ScDPDimension::GetHierarchiesObject() +/*N*/ { +/*N*/ if (!pHierarchies) +/*N*/ { +/*N*/ pHierarchies = new ScDPHierarchies( pSource, nDim ); +/*N*/ pHierarchies->acquire(); // ref-counted +/*N*/ } +/*N*/ return pHierarchies; +/*N*/ } + +/*N*/ uno::Reference<container::XNameAccess> SAL_CALL ScDPDimension::getHierarchies() +/*N*/ throw(uno::RuntimeException) +/*N*/ { +/*N*/ return GetHierarchiesObject(); +/*N*/ } + +/*N*/ ::rtl::OUString SAL_CALL ScDPDimension::getName() throw(uno::RuntimeException) +/*N*/ { +/*N*/ if (aName.Len()) +/*N*/ return aName; +/*N*/ else +/*N*/ return pSource->GetData()->getDimensionName( nDim ); +/*N*/ } + +/*?*/ void SAL_CALL ScDPDimension::setName( const ::rtl::OUString& rNewName ) throw(uno::RuntimeException) +/*?*/ { +/*?*/ // used after cloning +/*?*/ aName = String( rNewName ); +/*?*/ } + +/*N*/ USHORT ScDPDimension::getOrientation() const +/*N*/ { +/*N*/ return pSource->GetOrientation( nDim ); +/*N*/ } + +/*N*/ void ScDPDimension::setOrientation(USHORT nNew) +/*N*/ { +/*N*/ pSource->SetOrientation( nDim, nNew ); +/*N*/ } + +/*N*/ long ScDPDimension::getPosition() const +/*N*/ { +/*N*/ return pSource->GetPosition( nDim ); +/*N*/ } + + +/*N*/ BOOL ScDPDimension::getIsDataLayoutDimension() const +/*N*/ { +/*N*/ return pSource->GetData()->getIsDataLayoutDimension( nDim ); +/*N*/ } + +/*N*/ USHORT ScDPDimension::getFunction() const +/*N*/ { +/*N*/ return nFunction; +/*N*/ } + +/*N*/ void ScDPDimension::setFunction(USHORT nNew) +/*N*/ { +/*N*/ nFunction = nNew; +/*N*/ } + +/*N*/ long ScDPDimension::getUsedHierarchy() const +/*N*/ { +/*N*/ return nUsedHier; +/*N*/ } + + + +/*?*/ uno::Reference<util::XCloneable> SAL_CALL ScDPDimension::createClone() throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return uno::Reference<util::XCloneable>(0); //STRIP001 +/*?*/ } + + +// XPropertySet + +/*?*/ uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPDimension::getPropertySetInfo() +/*?*/ throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return uno::Reference<beans::XPropertySetInfo>(0); //STRIP001 +/*?*/ } + +/*N*/ void SAL_CALL ScDPDimension::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& aValue ) +/*N*/ throw(beans::UnknownPropertyException, beans::PropertyVetoException, +/*N*/ lang::IllegalArgumentException, lang::WrappedTargetException, +/*N*/ uno::RuntimeException) +/*N*/ { +/*N*/ String aNameStr = aPropertyName; +/*N*/ if ( aNameStr.EqualsAscii( SC_UNO_POSITION ) ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 INT32 nInt; +/*N*/ } +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_USEDHIER ) ) +/*N*/ { +/*?*/ INT32 nInt; +/*?*/ if (aValue >>= nInt) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 setUsedHierarchy( nInt ); +/*N*/ } +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_ORIENTAT ) ) +/*N*/ { +/*N*/ sheet::DataPilotFieldOrientation eEnum; +/*N*/ if (aValue >>= eEnum) +/*N*/ setOrientation( eEnum ); +/*N*/ } +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_FUNCTION ) ) +/*N*/ { +/*N*/ sheet::GeneralFunction eEnum; +/*N*/ if (aValue >>= eEnum) +/*N*/ setFunction( eEnum ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("unknown property"); +/*N*/ //! THROW( UnknownPropertyException() ); +/*N*/ } +/*N*/ } + +/*N*/ uno::Any SAL_CALL ScDPDimension::getPropertyValue( const ::rtl::OUString& aPropertyName ) +/*N*/ throw(beans::UnknownPropertyException, lang::WrappedTargetException, +/*N*/ uno::RuntimeException) +/*N*/ { +/*N*/ uno::Any aRet; +/*N*/ String aNameStr = aPropertyName; +/*N*/ if ( aNameStr.EqualsAscii( SC_UNO_POSITION ) ) +/*N*/ aRet <<= (sal_Int32) getPosition(); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_USEDHIER ) ) +/*N*/ aRet <<= (sal_Int32) getUsedHierarchy(); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_ORIENTAT ) ) +/*N*/ { +/*N*/ sheet::DataPilotFieldOrientation eVal = (sheet::DataPilotFieldOrientation)getOrientation(); +/*N*/ aRet <<= eVal; +/*N*/ } +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_FUNCTION ) ) +/*N*/ { +/*N*/ sheet::GeneralFunction eVal = (sheet::GeneralFunction)getFunction(); +/*N*/ aRet <<= eVal; +/*N*/ } +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_ISDATALA ) ) // read-only properties +/*N*/ lcl_SetBoolInAny( aRet, getIsDataLayoutDimension() ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_NUMBERFO ) ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 aRet <<= (sal_Int32) pSource->GetData()->GetNumberFormat( +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_ORIGINAL ) ) +/*N*/ { +/*N*/ uno::Reference<container::XNamed> xOriginal; +/*N*/ if (nSourceDim >= 0) +/*?*/ xOriginal = pSource->GetDimensionsObject()->getByIndex(nSourceDim); +/*N*/ aRet <<= xOriginal; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("unknown property"); +/*N*/ //! THROW( UnknownPropertyException() ); +/*N*/ } +/*N*/ return aRet; +/*N*/ } + +/*N*/ SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPDimension ) + +// ----------------------------------------------------------------------- + +/*N*/ ScDPHierarchies::ScDPHierarchies( ScDPSource* pSrc, long nD ) : +/*N*/ pSource( pSrc ), +/*N*/ nDim( nD ), +/*N*/ ppHiers( NULL ) +/*N*/ { +/*N*/ //! hold pSource +/*N*/ +/*N*/ // date columns have 3 hierarchies (flat/quarter/week), other columns only one +/*N*/ long nSrcDim = pSource->GetSourceDim( nDim ); +/*N*/ if ( pSource->IsDateDimension( nSrcDim ) ) +/*?*/ nHierCount = SC_DAPI_DATE_HIERARCHIES; +/*N*/ else +/*N*/ nHierCount = 1; +/*N*/ } + +/*N*/ ScDPHierarchies::~ScDPHierarchies() +/*N*/ { +/*N*/ //! release pSource +/*N*/ +/*N*/ if (ppHiers) +/*N*/ { +/*N*/ for (long i=0; i<nHierCount; i++) +/*N*/ if ( ppHiers[i] ) +/*N*/ ppHiers[i]->release(); // ref-counted +/*N*/ delete[] ppHiers; +/*N*/ } +/*N*/ } + +// very simple XNameAccess implementation using getCount/getByIndex + +/*N*/ uno::Any SAL_CALL ScDPHierarchies::getByName( const ::rtl::OUString& aName ) +/*N*/ throw(container::NoSuchElementException, +/*N*/ lang::WrappedTargetException, uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ if ( getByIndex(i)->getName() == aName ) +/*N*/ { +/*N*/ uno::Reference<container::XNamed> xNamed = getByIndex(i); +/*N*/ uno::Any aRet; +/*N*/ aRet <<= xNamed; +/*N*/ return aRet; +/*N*/ } +/*N*/ +/*?*/ throw container::NoSuchElementException(); +/*N*/ return uno::Any(); +/*N*/ } + +/*N*/ uno::Sequence<rtl::OUString> SAL_CALL ScDPHierarchies::getElementNames() throw(uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ uno::Sequence<rtl::OUString> aSeq(nCount); +/*N*/ ::rtl::OUString* pArr = aSeq.getArray(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ pArr[i] = getByIndex(i)->getName(); +/*N*/ return aSeq; +/*N*/ } + +/*?*/ sal_Bool SAL_CALL ScDPHierarchies::hasByName( const ::rtl::OUString& aName ) throw(uno::RuntimeException) +/*?*/ { +/*?*/ long nCount = getCount(); +/*?*/ for (long i=0; i<nCount; i++) +/*?*/ if ( getByIndex(i)->getName() == aName ) +/*?*/ return TRUE; +/*?*/ return FALSE; +/*?*/ } + +/*?*/ uno::Type SAL_CALL ScDPHierarchies::getElementType() throw(uno::RuntimeException) +/*?*/ { +/*?*/ return getCppuType((uno::Reference<container::XNamed>*)0); +/*?*/ } + +/*?*/ sal_Bool SAL_CALL ScDPHierarchies::hasElements() throw(uno::RuntimeException) +/*?*/ { +/*?*/ return ( getCount() > 0 ); +/*?*/ } + +// end of XNameAccess implementation + +/*N*/ long ScDPHierarchies::getCount() const +/*N*/ { +/*N*/ return nHierCount; +/*N*/ } + +/*N*/ ScDPHierarchy* ScDPHierarchies::getByIndex(long nIndex) const +/*N*/ { +/*N*/ // pass hierarchy index to new object in case the implementation +/*N*/ // will be extended to more than one hierarchy +/*N*/ +/*N*/ if ( nIndex >= 0 && nIndex < nHierCount ) +/*N*/ { +/*N*/ if ( !ppHiers ) +/*N*/ { +/*N*/ ((ScDPHierarchies*)this)->ppHiers = new ScDPHierarchy*[nHierCount]; +/*N*/ for (long i=0; i<nHierCount; i++) +/*N*/ ppHiers[i] = NULL; +/*N*/ } +/*N*/ if ( !ppHiers[nIndex] ) +/*N*/ { +/*N*/ ppHiers[nIndex] = new ScDPHierarchy( pSource, nDim, nIndex ); +/*N*/ ppHiers[nIndex]->acquire(); // ref-counted +/*N*/ } +/*N*/ +/*N*/ return ppHiers[nIndex]; +/*N*/ } +/*N*/ +/*N*/ return NULL; //! exception? +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScDPHierarchy::ScDPHierarchy( ScDPSource* pSrc, long nD, long nH ) : +/*N*/ pSource( pSrc ), +/*N*/ nDim( nD ), +/*N*/ nHier( nH ), +/*N*/ pLevels( NULL ) +/*N*/ { +/*N*/ //! hold pSource +/*N*/ } + +/*N*/ ScDPHierarchy::~ScDPHierarchy() +/*N*/ { +/*N*/ //! release pSource +/*N*/ +/*N*/ if (pLevels) +/*N*/ pLevels->release(); // ref-counted +/*N*/ } + +/*N*/ ScDPLevels* ScDPHierarchy::GetLevelsObject() +/*N*/ { +/*N*/ if (!pLevels) +/*N*/ { +/*N*/ pLevels = new ScDPLevels( pSource, nDim, nHier ); +/*N*/ pLevels->acquire(); // ref-counted +/*N*/ } +/*N*/ return pLevels; +/*N*/ } + +/*N*/ uno::Reference<container::XNameAccess> SAL_CALL ScDPHierarchy::getLevels() +/*N*/ throw(uno::RuntimeException) +/*N*/ { +/*N*/ return GetLevelsObject(); +/*N*/ } + +/*N*/ ::rtl::OUString SAL_CALL ScDPHierarchy::getName() throw(uno::RuntimeException) +/*N*/ { +/*N*/ String aRet; //! globstr-ID !!!! +/*N*/ switch (nHier) +/*N*/ { +/*N*/ case SC_DAPI_HIERARCHY_FLAT: +/*N*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("flat")); +/*N*/ break; //! name ??????? +/*N*/ case SC_DAPI_HIERARCHY_QUARTER: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Quarter")); +/*?*/ break; //! name ??????? +/*N*/ case SC_DAPI_HIERARCHY_WEEK: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Week")); +/*?*/ break; //! name ??????? +/*N*/ } +/*N*/ return aRet; +/*N*/ } + +/*?*/ void SAL_CALL ScDPHierarchy::setName( const ::rtl::OUString& rNewName ) throw(uno::RuntimeException) +/*?*/ { +/*?*/ DBG_ERROR("not implemented"); //! exception? +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScDPLevels::ScDPLevels( ScDPSource* pSrc, long nD, long nH ) : +/*N*/ pSource( pSrc ), +/*N*/ nDim( nD ), +/*N*/ nHier( nH ), +/*N*/ ppLevs( NULL ) +/*N*/ { +/*N*/ //! hold pSource +/*N*/ +/*N*/ // text columns have only one level +/*N*/ +/*N*/ long nSrcDim = pSource->GetSourceDim( nDim ); +/*N*/ if ( pSource->IsDateDimension( nSrcDim ) ) +/*N*/ { +/*?*/ switch ( nHier ) +/*?*/ { +/*?*/ case SC_DAPI_HIERARCHY_FLAT: nLevCount = SC_DAPI_FLAT_LEVELS; break; +/*?*/ case SC_DAPI_HIERARCHY_QUARTER: nLevCount = SC_DAPI_QUARTER_LEVELS; break; +/*?*/ case SC_DAPI_HIERARCHY_WEEK: nLevCount = SC_DAPI_WEEK_LEVELS; break; +/*?*/ default: +/*?*/ DBG_ERROR("wrong hierarchy"); +/*?*/ nLevCount = 0; +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ nLevCount = 1; +/*N*/ } + +/*N*/ ScDPLevels::~ScDPLevels() +/*N*/ { +/*N*/ //! release pSource +/*N*/ +/*N*/ if (ppLevs) +/*N*/ { +/*N*/ for (long i=0; i<nLevCount; i++) +/*N*/ if ( ppLevs[i] ) +/*N*/ ppLevs[i]->release(); // ref-counted +/*N*/ delete[] ppLevs; +/*N*/ } +/*N*/ } + +// very simple XNameAccess implementation using getCount/getByIndex + +/*N*/ uno::Any SAL_CALL ScDPLevels::getByName( const ::rtl::OUString& aName ) +/*N*/ throw(container::NoSuchElementException, +/*N*/ lang::WrappedTargetException, uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ if ( getByIndex(i)->getName() == aName ) +/*N*/ { +/*N*/ uno::Reference<container::XNamed> xNamed = getByIndex(i); +/*N*/ uno::Any aRet; +/*N*/ aRet <<= xNamed; +/*N*/ return aRet; +/*N*/ } +/*N*/ +/*?*/ throw container::NoSuchElementException(); +/*N*/ return uno::Any(); +/*N*/ } + +/*N*/ uno::Sequence<rtl::OUString> SAL_CALL ScDPLevels::getElementNames() throw(uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ uno::Sequence<rtl::OUString> aSeq(nCount); +/*N*/ ::rtl::OUString* pArr = aSeq.getArray(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ pArr[i] = getByIndex(i)->getName(); +/*N*/ return aSeq; +/*N*/ } + +/*N*/ sal_Bool SAL_CALL ScDPLevels::hasByName( const ::rtl::OUString& aName ) throw(uno::RuntimeException) +/*N*/ { +/*N*/ long nCount = getCount(); +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ if ( getByIndex(i)->getName() == aName ) +/*N*/ return TRUE; +/*N*/ return FALSE; +/*N*/ } + +/*N*/ uno::Type SAL_CALL ScDPLevels::getElementType() throw(uno::RuntimeException) +/*N*/ { +/*N*/ return getCppuType((uno::Reference<container::XNamed>*)0); +/*N*/ } + +/*N*/ sal_Bool SAL_CALL ScDPLevels::hasElements() throw(uno::RuntimeException) +/*N*/ { +/*N*/ return ( getCount() > 0 ); +/*N*/ } + +// end of XNameAccess implementation + +/*N*/ long ScDPLevels::getCount() const +/*N*/ { +/*N*/ return nLevCount; +/*N*/ } + +/*N*/ ScDPLevel* ScDPLevels::getByIndex(long nIndex) const +/*N*/ { +/*N*/ if ( nIndex >= 0 && nIndex < nLevCount ) +/*N*/ { +/*N*/ if ( !ppLevs ) +/*N*/ { +/*N*/ ((ScDPLevels*)this)->ppLevs = new ScDPLevel*[nLevCount]; +/*N*/ for (long i=0; i<nLevCount; i++) +/*N*/ ppLevs[i] = NULL; +/*N*/ } +/*N*/ if ( !ppLevs[nIndex] ) +/*N*/ { +/*N*/ ppLevs[nIndex] = new ScDPLevel( pSource, nDim, nHier, nIndex ); +/*N*/ ppLevs[nIndex]->acquire(); // ref-counted +/*N*/ } +/*N*/ +/*N*/ return ppLevs[nIndex]; +/*N*/ } +/*N*/ +/*N*/ return NULL; //! exception? +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScDPLevel::ScDPLevel( ScDPSource* pSrc, long nD, long nH, long nL ) : +/*N*/ pSource( pSrc ), +/*N*/ nDim( nD ), +/*N*/ nHier( nH ), +/*N*/ nLev( nL ), +/*N*/ pMembers( NULL ), +/*N*/ bShowEmpty( FALSE ) +/*N*/ { +/*N*/ //! hold pSource +/*N*/ // aSubTotals is empty +/*N*/ } + +/*N*/ ScDPLevel::~ScDPLevel() +/*N*/ { +/*N*/ //! release pSource +/*N*/ +/*N*/ if ( pMembers ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 pMembers->release(); // ref-counted +/*N*/ } + + +/*?*/ uno::Reference<container::XNameAccess> SAL_CALL ScDPLevel::getMembers() throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return uno::Reference<container::XNameAccess>(0); //STRIP001 +/*?*/ } + +/*?*/ uno::Sequence<sheet::MemberResult> SAL_CALL ScDPLevel::getResults() throw(uno::RuntimeException) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*?*/ return uno::Sequence<sheet::MemberResult>(0); //! Error? +/*?*/ } + +/*N*/ ::rtl::OUString SAL_CALL ScDPLevel::getName() throw(uno::RuntimeException) +/*N*/ { +/*N*/ long nSrcDim = pSource->GetSourceDim( nDim ); +/*N*/ if ( pSource->IsDateDimension( nSrcDim ) ) +/*?*/ { +/*?*/ String aRet; //! globstr-ID !!!! +/*?*/ +/*?*/ if ( nHier == SC_DAPI_HIERARCHY_QUARTER ) +/*?*/ { +/*?*/ switch ( nLev ) +/*?*/ { +/*?*/ case SC_DAPI_LEVEL_YEAR: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Year")); +/*?*/ break; +/*?*/ case SC_DAPI_LEVEL_QUARTER: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Quarter")); +/*?*/ break; +/*?*/ case SC_DAPI_LEVEL_MONTH: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Month")); +/*?*/ break; +/*?*/ case SC_DAPI_LEVEL_DAY: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Day")); +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ else if ( nHier == SC_DAPI_HIERARCHY_WEEK ) +/*?*/ { +/*?*/ switch ( nLev ) +/*?*/ { +/*?*/ case SC_DAPI_LEVEL_YEAR: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Year")); +/*?*/ break; +/*?*/ case SC_DAPI_LEVEL_WEEK: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Week")); +/*?*/ break; +/*?*/ case SC_DAPI_LEVEL_WEEKDAY: +/*?*/ aRet = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Weekday")); +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ if (aRet.Len()) +/*?*/ return aRet; +/*N*/ } +/*N*/ +/*N*/ return pSource->GetData()->getDimensionName( nSrcDim ); // (original) dimension name +/*N*/ } + +/*?*/ void SAL_CALL ScDPLevel::setName( const ::rtl::OUString& rNewName ) throw(uno::RuntimeException) +/*?*/ { +/*?*/ DBG_ERROR("not implemented"); //! exception? +/*?*/ } + +/*N*/ uno::Sequence<sheet::GeneralFunction> ScDPLevel::getSubTotals() const +/*N*/ { +/*N*/ //! separate functions for settings and evaluation? +/*N*/ +/*N*/ long nSrcDim = pSource->GetSourceDim( nDim ); +/*N*/ if ( !pSource->SubTotalAllowed( nSrcDim ) ) +/*N*/ return uno::Sequence<sheet::GeneralFunction>(0); +/*N*/ +/*N*/ return aSubTotals; +/*N*/ } + + + +/*N*/ void ScDPLevel::setShowEmpty(BOOL bSet) +/*N*/ { +/*N*/ bShowEmpty = bSet; +/*N*/ } + +// XPropertySet + +/*N*/ uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDPLevel::getPropertySetInfo() +/*N*/ throw(uno::RuntimeException) +/*N*/ { +/*N*/ SolarMutexGuard aGuard; +/*N*/ +/*N*/ static SfxItemPropertyMap aDPLevelMap_Impl[] = +/*N*/ { +/*N*/ {MAP_CHAR_LEN(SC_UNO_SHOWEMPT), 0, &getBooleanCppuType(), 0, 0 }, +/*N*/ {MAP_CHAR_LEN(SC_UNO_SUBTOTAL), 0, &getCppuType((uno::Sequence<sheet::GeneralFunction>*)0), 0, 0 }, +/*N*/ {0,0,0,0} +/*N*/ }; +/*N*/ static uno::Reference<beans::XPropertySetInfo> aRef = +/*N*/ new SfxItemPropertySetInfo( aDPLevelMap_Impl ); +/*N*/ return aRef; +/*N*/ } + +/*N*/ void SAL_CALL ScDPLevel::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& aValue ) +/*N*/ throw(beans::UnknownPropertyException, beans::PropertyVetoException, +/*N*/ lang::IllegalArgumentException, lang::WrappedTargetException, +/*N*/ uno::RuntimeException) +/*N*/ { +/*N*/ String aNameStr = aPropertyName; +/*N*/ if ( aNameStr.EqualsAscii( SC_UNO_SHOWEMPT ) ) +/*N*/ setShowEmpty( lcl_GetBoolFromAny( aValue ) ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_SUBTOTAL ) ) +/*N*/ { +/*?*/ uno::Sequence<sheet::GeneralFunction> aSeq; +/*?*/ if ( aValue >>= aSeq ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 setSubTotals( aSeq ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("unknown property"); +/*N*/ //! THROW( UnknownPropertyException() ); +/*N*/ } +/*N*/ } + +/*N*/ uno::Any SAL_CALL ScDPLevel::getPropertyValue( const ::rtl::OUString& aPropertyName ) +/*N*/ throw(beans::UnknownPropertyException, lang::WrappedTargetException, +/*N*/ uno::RuntimeException) +/*N*/ { +/*N*/ uno::Any aRet; +/*N*/ String aNameStr = aPropertyName; +/*N*/ if ( aNameStr.EqualsAscii( SC_UNO_SHOWEMPT ) ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 lcl_SetBoolInAny( aRet, getShowEmpty() ); +/*N*/ else if ( aNameStr.EqualsAscii( SC_UNO_SUBTOTAL ) ) +/*N*/ { +/*N*/ uno::Sequence<sheet::GeneralFunction> aSeq = getSubTotals(); //! avoid extra copy? +/*N*/ aRet <<= aSeq; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR("unknown property"); +/*N*/ //! THROW( UnknownPropertyException() ); +/*N*/ } +/*N*/ return aRet; +/*N*/ } + +/*N*/ SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPLevel ) + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_drawpage.cxx b/binfilter/bf_sc/source/core/data/sc_drawpage.cxx new file mode 100644 index 000000000000..43559bfb9ddf --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_drawpage.cxx @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + +#include "drawpage.hxx" +#include "drwlayer.hxx" +#include "pageuno.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +// ----------------------------------------------------------------------- + +/*N*/ ScDrawPage::ScDrawPage(ScDrawLayer& rNewModel, StarBASIC* pBasic, BOOL bMasterPage) : +/*N*/ FmFormPage(rNewModel, pBasic, bMasterPage) +/*N*/ { +/*N*/ SetSize( Size( LONG_MAX, LONG_MAX ) ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ __EXPORT ScDrawPage::~ScDrawPage() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > ScDrawPage::createUnoPage() +/*N*/ { +/*N*/ return static_cast<cppu::OWeakObject*>( new ScPageObj( this ) ); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_drwlayer.cxx b/binfilter/bf_sc/source/core/data/sc_drwlayer.cxx new file mode 100644 index 000000000000..0f09ef768ba3 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_drwlayer.cxx @@ -0,0 +1,928 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + +#include "scitems.hxx" +#include <bf_svx/eeitem.hxx> +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/objfac3d.hxx> +#include <bf_svx/svdoutl.hxx> +#include <bf_svx/svditer.hxx> +#include <bf_svx/svdoedge.hxx> +#include <bf_svx/svdoole2.hxx> +#include <bf_svx/svdundo.hxx> +#include <bf_svx/drawitem.hxx> +#include <bf_svx/fhgtitem.hxx> +#include <bf_sfx2/docfile.hxx> +#include <bf_svtools/pathoptions.hxx> +#include <bf_svtools/itempool.hxx> +#include <bf_offmgr/app.hxx> + +#include "drwlayer.hxx" +#include "drawpage.hxx" +#include "document.hxx" +#include "rechead.hxx" +#include "userdat.hxx" +#include "globstr.hrc" +#include "scmod.hxx" +namespace binfilter { + +#define DET_ARROW_OFFSET 1000 + +// Abstand zur naechsten Zelle beim Loeschen (bShrink), damit der Anker +// immer an der richtigen Zelle angezeigt wird +//#define SHRINK_DIST 3 +// und noch etwas mehr, damit das Objekt auch sichtbar in der Zelle liegt +#define SHRINK_DIST 25 + +#define SHRINK_DIST_TWIPS 15 + +// ----------------------------------------------------------------------- +// +// Das Anpassen der Detektiv-UserData muss zusammen mit den Draw-Undo's +// in der SdrUndoGroup liegen, darum von SdrUndoAction abgeleitet: + + +// ----------------------------------------------------------------------- + +// STATIC DATA ----------------------------------------------------------- + +/*N*/ TYPEINIT1(ScTabDeletedHint, SfxHint); +/*N*/ TYPEINIT1(ScTabSizeChangedHint, SfxHint); + +static ScDrawObjFactory* pFac = NULL; +static E3dObjFactory* pF3d = NULL; +static USHORT nInst = 0; + +SvPersist* ScDrawLayer::pGlobalDrawPersist = NULL; + +BOOL bDrawIsInUndo = FALSE; //! Member + +// ----------------------------------------------------------------------- + +/*N*/ __EXPORT ScTabDeletedHint::~ScTabDeletedHint() +/*N*/ { +/*N*/ } + +/*N*/ ScTabSizeChangedHint::ScTabSizeChangedHint( USHORT nTabNo ) : +/*N*/ nTab( nTabNo ) +/*N*/ { +/*N*/ } + +/*N*/ __EXPORT ScTabSizeChangedHint::~ScTabSizeChangedHint() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +#define MAXMM 10000000 + +/*N*/ inline void TwipsToMM( long& nVal ) +/*N*/ { +/*N*/ nVal = (long) ( nVal * HMM_PER_TWIPS ); +/*N*/ } + +/*N*/ inline void ReverseTwipsToMM( long& nVal ) +/*N*/ { +/*N*/ // reverse the effect of TwipsToMM - round up here (add 1) +/*N*/ +/*N*/ nVal = ((long) ( nVal / HMM_PER_TWIPS )) + 1; +/*N*/ } + +/*N*/ void lcl_TwipsToMM( Point& rPoint ) +/*N*/ { +/*N*/ TwipsToMM( rPoint.X() ); +/*N*/ TwipsToMM( rPoint.Y() ); +/*N*/ } + +/*N*/ void lcl_ReverseTwipsToMM( Point& rPoint ) +/*N*/ { +/*N*/ ReverseTwipsToMM( rPoint.X() ); +/*N*/ ReverseTwipsToMM( rPoint.Y() ); +/*N*/ } + +/*N*/ void lcl_ReverseTwipsToMM( Rectangle& rRect ) +/*N*/ { +/*N*/ ReverseTwipsToMM( rRect.Left() ); +/*N*/ ReverseTwipsToMM( rRect.Right() ); +/*N*/ ReverseTwipsToMM( rRect.Top() ); +/*N*/ ReverseTwipsToMM( rRect.Bottom() ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +/*N*/ ScDrawLayer::ScDrawLayer( ScDocument* pDocument, const String& rName ) : +/*N*/ FmFormModel( SvtPathOptions().GetPalettePath(), +/*N*/ NULL, // SfxItemPool* Pool +/*N*/ pGlobalDrawPersist ? +/*N*/ pGlobalDrawPersist : +/*N*/ ( pDocument ? pDocument->GetDocumentShell() : NULL ), +/*N*/ TRUE ), // bUseExtColorTable (is set below) +/*N*/ aName( rName ), +/*N*/ pDoc( pDocument ), +/*N*/ pUndoGroup( NULL ), +/*N*/ bRecording( FALSE ), +/*N*/ bAdjustEnabled( TRUE ), +/*N*/ bHyphenatorSet( FALSE ) +/*N*/ { +/*N*/ pGlobalDrawPersist = NULL; // nur einmal benutzen +/*N*/ +/*N*/ SfxObjectShell* pObjSh = pDocument ? pDocument->GetDocumentShell() : NULL; +/*N*/ if ( pObjSh ) +/*N*/ { +/*N*/ SetObjectShell( pObjSh ); +/*N*/ +/*N*/ // set color table +/*N*/ SvxColorTableItem* pColItem = (SvxColorTableItem*) pObjSh->GetItem( ITEMID_COLOR_TABLE ); +/*N*/ XColorTable* pXCol = pColItem ? pColItem->GetColorTable() : OFF_APP()->GetStdColorTable(); +/*N*/ SetColorTable( pXCol ); +/*N*/ } +/*N*/ else +/*?*/ SetColorTable( OFF_APP()->GetStdColorTable() ); +/*N*/ +/*N*/ SetSwapGraphics(TRUE); +/*N*/ // SetSwapAsynchron(TRUE); // an der View +/*N*/ +/*N*/ SetScaleUnit(MAP_100TH_MM); +/*N*/ SfxItemPool& rPool = GetItemPool(); +/*N*/ rPool.SetDefaultMetric(SFX_MAPUNIT_100TH_MM); +/*N*/ SvxFrameDirectionItem aModeItem( FRMDIR_ENVIRONMENT, EE_PARA_WRITINGDIR ); +/*N*/ rPool.SetPoolDefaultItem( aModeItem ); +/*N*/ rPool.FreezeIdRanges(); // der Pool wird auch direkt verwendet +/*N*/ +/*N*/ SdrLayerAdmin& rAdmin = GetLayerAdmin(); +/*N*/ rAdmin.NewLayer(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("vorne")), SC_LAYER_FRONT); +/*N*/ rAdmin.NewLayer(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("hinten")), SC_LAYER_BACK); +/*N*/ rAdmin.NewLayer(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("intern")), SC_LAYER_INTERN); +/*N*/ rAdmin.NewLayer(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Controls")), SC_LAYER_CONTROLS); +/*N*/ // "Controls" is new - must also be created when loading +/*N*/ +/*N*/ // Link fuer URL-Fields setzen +/*N*/ ScModule* pScMod = SC_MOD(); +/*N*/ Outliner& rOutliner = GetDrawOutliner(); +/*N*/ rOutliner.SetCalcFieldValueHdl( LINK( pScMod, ScModule, CalcFieldValueHdl ) ); +/*N*/ +/*N*/ Outliner& rHitOutliner = GetHitTestOutliner(); +/*N*/ rHitOutliner.SetCalcFieldValueHdl( LINK( pScMod, ScModule, CalcFieldValueHdl ) ); +/*N*/ +/*N*/ // #95129# SJ: set FontHeight pool defaults without changing static SdrEngineDefaults +/*N*/ SfxItemPool* pOutlinerPool = rOutliner.GetEditTextObjectPool(); +/*N*/ if ( pOutlinerPool ) +/*N*/ pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT )); // 12Pt +/*N*/ SfxItemPool* pHitOutlinerPool = rHitOutliner.GetEditTextObjectPool(); +/*N*/ if ( pHitOutlinerPool ) +/*N*/ pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT )); // 12Pt +/*N*/ +/*N*/ // URL-Buttons haben keinen Handler mehr, machen alles selber +/*N*/ +/*N*/ if( !nInst++ ) +/*N*/ { +/*N*/ pFac = new ScDrawObjFactory; +/*N*/ pF3d = new E3dObjFactory; +/*N*/ } +/*N*/ } + +/*N*/ __EXPORT ScDrawLayer::~ScDrawLayer() +/*N*/ { +/*N*/ Broadcast(SdrHint(HINT_MODELCLEARED)); +/*N*/ +/*N*/ Clear(); +/*N*/ +/*N*/ delete pUndoGroup; +/*N*/ if( !--nInst ) +/*N*/ { +/*N*/ delete pFac, pFac = NULL; +/*N*/ delete pF3d, pF3d = NULL; +/*N*/ } +/*N*/ } + + +/*N*/ SdrPage* __EXPORT ScDrawLayer::AllocPage(FASTBOOL bMasterPage) +/*N*/ { +/*N*/ // don't create basic until it is needed +/*N*/ StarBASIC* pBasic = NULL; +/*N*/ ScDrawPage* pPage = new ScDrawPage( *this, pBasic, bMasterPage ); +/*N*/ return pPage; +/*N*/ } + + +/*N*/ void ScDrawLayer::UpdateBasic() +/*N*/ { +/*N*/ // don't create basic until it is needed +/*N*/ //! remove this method? +/*N*/ } + + + +/*N*/ void ScDrawLayer::ScAddPage( USHORT nTab ) +/*N*/ { +/*N*/ if (bDrawIsInUndo) +/*N*/ return; +/*N*/ +/*N*/ ScDrawPage* pPage = (ScDrawPage*)AllocPage( FALSE ); +/*N*/ InsertPage(pPage, nTab); +/*N*/ if (bRecording) +/*N*/ AddCalcUndo(new SdrUndoNewPage(*pPage)); +/*N*/ } + + +/*N*/ void ScDrawLayer::ScRenamePage( USHORT nTab, const String& rNewName ) +/*N*/ { +/*N*/ ScDrawPage* pPage = (ScDrawPage*) GetPage(nTab); +/*N*/ if (pPage) +/*N*/ pPage->SetName(rNewName); +/*N*/ } + + + + + +/*N*/ void ScDrawLayer::SetPageSize( USHORT nPageNo, const Size& rSize ) +/*N*/ { +/*N*/ SdrPage* pPage = GetPage(nPageNo); +/*N*/ if (pPage) +/*N*/ { +/*N*/ if ( rSize != pPage->GetSize() ) +/*N*/ { +/*N*/ pPage->SetSize( rSize ); +/*N*/ Broadcast( ScTabSizeChangedHint( nPageNo ) ); // SetWorkArea() an den Views +/*N*/ } +/*N*/ +/*N*/ // Detektivlinien umsetzen (an neue Hoehen/Breiten anpassen) +/*N*/ // auch wenn Groesse gleich geblieben ist +/*N*/ // (einzelne Zeilen/Spalten koennen geaendert sein) +/*N*/ +/*N*/ ULONG nCount = pPage->GetObjCount(); +/*N*/ for ( ULONG i = 0; i < nCount; i++ ) +/*N*/ { +/*N*/ SdrObject* pObj = pPage->GetObj( i ); +/*N*/ ScDrawObjData* pData = GetObjData( pObj ); +/*N*/ if( pData ) +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ RecalcPos( pObj, pData ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScDrawLayer::Load( SvStream& rStream ) +/*N*/ { +/*N*/ bRecording = FALSE; +/*N*/ DELETEZ(pUndoGroup); +/*N*/ +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ while (aHdr.BytesLeft()) +/*N*/ { +/*N*/ USHORT nID; +/*N*/ rStream >> nID; +/*N*/ switch (nID) +/*N*/ { +/*N*/ case SCID_DRAWPOOL: +/*N*/ { +/*N*/ ScReadHeader aPoolHdr( rStream ); +/*N*/ GetItemPool().Load( rStream ); //! in Pool-Stream ? +/*N*/ } +/*N*/ break; +/*N*/ case SCID_DRAWMODEL: +/*N*/ { +/*N*/ ScReadHeader aDrawHdr( rStream ); +/*N*/ rStream >> *this; +/*N*/ +/*N*/ // Control-Layer ist nicht in alten Dateien +/*N*/ SdrLayerAdmin& rAdmin = GetLayerAdmin(); +/*N*/ const SdrLayer* pLayer = rAdmin.GetLayerPerID(SC_LAYER_CONTROLS); +/*N*/ if (!pLayer) +/*N*/ rAdmin.NewLayer( +/*N*/ String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Controls")), +/*N*/ SC_LAYER_CONTROLS); +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ DBG_ERROR("unbekannter Sub-Record in ScDrawLayer::Load"); +/*N*/ ScReadHeader aDummyHdr( rStream ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ GetItemPool().LoadCompleted(); +/*N*/ } + +/*N*/ void ScDrawLayer::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ //-/ const_cast<ScDrawLayer*>(this)->PrepareStore(); // non-const +/*N*/ const_cast<ScDrawLayer*>(this)->PreSave(); // non-const +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_DRAWPOOL; +/*N*/ ScWriteHeader aPoolHdr( rStream ); +/*N*/ GetItemPool().Store( rStream ); //! in Pool-Stream ? +/*N*/ } +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_DRAWMODEL; +/*N*/ ScWriteHeader aDrawHdr( rStream ); +/*N*/ rStream << *this; +/*N*/ } +/*N*/ +/*N*/ const_cast<ScDrawLayer*>(this)->PostSave(); // non-const +/*N*/ } + +/*N*/ BOOL ScDrawLayer::GetPrintArea( ScRange& rRange, BOOL bSetHor, BOOL bSetVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( pDoc, "ScDrawLayer::GetPrintArea without document" ); +/*N*/ if ( !pDoc ) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nTab = rRange.aStart.Tab(); +/*N*/ DBG_ASSERT( rRange.aEnd.Tab() == nTab, "GetPrintArea: Tab unterschiedlich" ); +/*N*/ +/*N*/ BOOL bAny = FALSE; +/*N*/ long nEndX = 0; +/*N*/ long nEndY = 0; +/*N*/ long nStartX = LONG_MAX; +/*N*/ long nStartY = LONG_MAX; +/*N*/ USHORT i; +/*N*/ +/*N*/ // Grenzen ausrechnen +/*N*/ +/*N*/ if (!bSetHor) +/*N*/ { +/*?*/ nStartX = 0; +/*?*/ USHORT nStartCol = rRange.aStart.Col(); +/*?*/ for (i=0; i<nStartCol; i++) +/*?*/ nStartX +=pDoc->GetColWidth(i,nTab); +/*?*/ nEndX = nStartX; +/*?*/ USHORT nEndCol = rRange.aEnd.Col(); +/*?*/ for (i=nStartCol; i<=nEndCol; i++) +/*?*/ nEndX += pDoc->GetColWidth(i,nTab); +/*?*/ nStartX = (long)(nStartX * HMM_PER_TWIPS); +/*?*/ nEndX = (long)(nEndX * HMM_PER_TWIPS); +/*N*/ } +/*N*/ if (!bSetVer) +/*N*/ { +/*?*/ nStartY = 0; +/*?*/ USHORT nStartRow = rRange.aStart.Row(); +/*?*/ for (i=0; i<nStartRow; i++) +/*?*/ nStartY +=pDoc->FastGetRowHeight(i,nTab); +/*?*/ nEndY = nStartY; +/*?*/ USHORT nEndRow = rRange.aEnd.Row(); +/*?*/ for (i=nStartRow; i<=nEndRow; i++) +/*?*/ nEndY += pDoc->FastGetRowHeight(i,nTab); +/*?*/ nStartY = (long)(nStartY * HMM_PER_TWIPS); +/*?*/ nEndY = (long)(nEndY * HMM_PER_TWIPS); +/*N*/ } +/*N*/ +/*N*/ const SdrPage* pPage = GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page nicht gefunden"); +/*N*/ if (pPage) +/*N*/ { +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ //! Flags (ausgeblendet?) testen +/*N*/ +/*N*/ Rectangle aObjRect = pObject->GetBoundRect(); +/*N*/ BOOL bFit = TRUE; +/*N*/ if ( !bSetHor && ( aObjRect.Right() < nStartX || aObjRect.Left() > nEndX ) ) +/*N*/ bFit = FALSE; +/*N*/ if ( !bSetVer && ( aObjRect.Bottom() < nStartY || aObjRect.Top() > nEndY ) ) +/*N*/ bFit = FALSE; +/*N*/ if ( bFit ) +/*N*/ { +/*N*/ if (bSetHor) +/*N*/ { +/*N*/ if (aObjRect.Left() < nStartX) nStartX = aObjRect.Left(); +/*N*/ if (aObjRect.Right() > nEndX) nEndX = aObjRect.Right(); +/*N*/ } +/*N*/ if (bSetVer) +/*N*/ { +/*N*/ if (aObjRect.Top() < nStartY) nStartY = aObjRect.Top(); +/*N*/ if (aObjRect.Bottom() > nEndY) nEndY = aObjRect.Bottom(); +/*N*/ } +/*N*/ bAny = TRUE; +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bAny) +/*N*/ { +/*N*/ DBG_ASSERT( nStartX<=nEndX && nStartY<=nEndY, "Start/End falsch in ScDrawLayer::GetPrintArea" ); +/*N*/ +/*N*/ if (bSetHor) +/*N*/ { +/*N*/ nStartX = (long) (nStartX / HMM_PER_TWIPS); +/*N*/ nEndX = (long) (nEndX / HMM_PER_TWIPS); +/*N*/ long nWidth; +/*N*/ +/*N*/ nWidth = 0; +/*N*/ for (i=0; i<MAXCOL && nWidth<=nStartX; i++) +/*N*/ nWidth += pDoc->GetColWidth(i,nTab); +/*N*/ rRange.aStart.SetCol( i ? (i-1) : 0 ); +/*N*/ +/*N*/ nWidth = 0; +/*N*/ for (i=0; i<MAXCOL && nWidth<=nEndX; i++) //! bei Start anfangen +/*N*/ nWidth += pDoc->GetColWidth(i,nTab); +/*N*/ rRange.aEnd.SetCol( i ? (i-1) : 0 ); +/*N*/ } +/*N*/ +/*N*/ if (bSetVer) +/*N*/ { +/*N*/ nStartY = (long) (nStartY / HMM_PER_TWIPS); +/*N*/ nEndY = (long) (nEndY / HMM_PER_TWIPS); +/*N*/ long nHeight; +/*N*/ +/*N*/ nHeight = 0; +/*N*/ for (i=0; i<MAXROW && nHeight<=nStartY; i++) +/*N*/ nHeight += pDoc->FastGetRowHeight(i,nTab); +/*N*/ rRange.aStart.SetRow( i ? (i-1) : 0 ); +/*N*/ +/*N*/ nHeight = 0; +/*N*/ for (i=0; i<MAXROW && nHeight<=nEndY; i++) +/*N*/ nHeight += pDoc->FastGetRowHeight(i,nTab); +/*N*/ rRange.aEnd.SetRow( i ? (i-1) : 0 ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (bSetHor) +/*N*/ { +/*N*/ rRange.aStart.SetCol(0); +/*N*/ rRange.aEnd.SetCol(0); +/*N*/ } +/*N*/ if (bSetVer) +/*N*/ { +/*N*/ rRange.aStart.SetRow(0); +/*N*/ rRange.aEnd.SetRow(0); +/*N*/ } +/*N*/ } +/*N*/ return bAny; +/*N*/ } + +/*N*/ void ScDrawLayer::AddCalcUndo( SdrUndoAction* pUndo ) +/*N*/ { +/*N*/ if (bRecording) +/*N*/ { +/*N*/ if (!pUndoGroup) +/*N*/ pUndoGroup = new SdrUndoGroup(*this); +/*N*/ +/*N*/ pUndoGroup->AddAction( pUndo ); +/*N*/ } +/*N*/ else +/*N*/ delete pUndo; +/*N*/ } + +// MoveAreaTwips: all measures are kept in twips +/*N*/ void ScDrawLayer::MoveAreaTwips( USHORT nTab, const Rectangle& rArea, +/*N*/ const Point& rMove, const Point& rTopLeft ) +/*N*/ { +/*N*/ if (!rMove.X() && !rMove.Y()) +/*N*/ return; // nix +/*N*/ +/*N*/ SdrPage* pPage = GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page nicht gefunden"); +/*N*/ if (!pPage) +/*N*/ return; +/*N*/ +/*N*/ // fuer Shrinking! +/*N*/ Rectangle aNew( rArea ); +/*N*/ BOOL bShrink = FALSE; +/*N*/ if ( rMove.X() < 0 || rMove.Y() < 0 ) // verkleinern +/*N*/ { +/*N*/ if ( rTopLeft != rArea.TopLeft() ) // sind gleich beim Verschieben von Zellen +/*N*/ { +/*N*/ bShrink = TRUE; +/*N*/ aNew.Left() = rTopLeft.X(); +/*N*/ aNew.Top() = rTopLeft.Y(); +/*N*/ } +/*N*/ } +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if( GetAnchor( pObject ) == SCA_CELL ) +/*N*/ { +/*N*/ if ( GetObjData( pObject ) ) // Detektiv-Pfeil ? +/*N*/ { +/*N*/ // hier nichts +/*N*/ } +/*N*/ else if ( pObject->ISA( SdrEdgeObj ) ) // Verbinder? +/*N*/ { +/*N*/ // hier auch nichts +/*N*/ //! nicht verbundene Enden wie bei Linien (s.u.) behandeln? +/*N*/ } +/*N*/ else if ( pObject->IsPolyObj() && pObject->GetPointCount()==2 ) +/*N*/ { +/*N*/ for (USHORT i=0; i<2; i++) +/*N*/ { +/*N*/ BOOL bMoved = FALSE; +/*N*/ Point aPoint = pObject->GetPoint(i); +/*N*/ lcl_ReverseTwipsToMM( aPoint ); +/*N*/ if (rArea.IsInside(aPoint)) +/*N*/ { +/*N*/ aPoint += rMove; bMoved = TRUE; +/*N*/ } +/*N*/ else if (bShrink && aNew.IsInside(aPoint)) +/*N*/ { +/*?*/ // Punkt ist in betroffener Zelle - Test auf geloeschten Bereich +/*?*/ if ( rMove.X() && aPoint.X() >= rArea.Left() + rMove.X() ) +/*?*/ { +/*?*/ aPoint.X() = rArea.Left() + rMove.X() - SHRINK_DIST_TWIPS; +/*?*/ if ( aPoint.X() < 0 ) aPoint.X() = 0; +/*?*/ bMoved = TRUE; +/*?*/ } +/*?*/ if ( rMove.Y() && aPoint.Y() >= rArea.Top() + rMove.Y() ) +/*?*/ { +/*?*/ aPoint.Y() = rArea.Top() + rMove.Y() - SHRINK_DIST_TWIPS; +/*?*/ if ( aPoint.Y() < 0 ) aPoint.Y() = 0; +/*?*/ bMoved = TRUE; +/*?*/ } +/*N*/ } +/*N*/ if( bMoved ) +/*N*/ { +/*N*/ AddCalcUndo( new SdrUndoGeoObj( *pObject ) ); +/*N*/ lcl_TwipsToMM( aPoint ); +/*N*/ pObject->SetPoint( aPoint, i ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ Rectangle aObjRect = pObject->GetLogicRect(); +/*N*/ Point aOldMMPos = aObjRect.TopLeft(); // not converted, millimeters +/*N*/ lcl_ReverseTwipsToMM( aObjRect ); +/*N*/ Point aTopLeft = aObjRect.TopLeft(); +/*N*/ Size aMoveSize; +/*N*/ BOOL bDoMove = FALSE; +/*N*/ if (rArea.IsInside(aTopLeft)) +/*N*/ { +/*N*/ aMoveSize = Size(rMove.X(),rMove.Y()); +/*N*/ bDoMove = TRUE; +/*N*/ } +/*N*/ else if (bShrink && aNew.IsInside(aTopLeft)) +/*N*/ { +/*?*/ // Position ist in betroffener Zelle - Test auf geloeschten Bereich +/*?*/ if ( rMove.X() && aTopLeft.X() >= rArea.Left() + rMove.X() ) +/*?*/ { +/*?*/ aMoveSize.Width() = rArea.Left() + rMove.X() - SHRINK_DIST - aTopLeft.X(); +/*?*/ bDoMove = TRUE; +/*?*/ } +/*?*/ if ( rMove.Y() && aTopLeft.Y() >= rArea.Top() + rMove.Y() ) +/*?*/ { +/*?*/ aMoveSize.Height() = rArea.Top() + rMove.Y() - SHRINK_DIST - aTopLeft.Y(); +/*?*/ bDoMove = TRUE; +/*?*/ } +/*N*/ } +/*N*/ if ( bDoMove ) +/*N*/ { +/*N*/ if ( aTopLeft.X() + aMoveSize.Width() < 0 ) +/*?*/ aMoveSize.Width() = -aTopLeft.X(); +/*N*/ if ( aTopLeft.Y() + aMoveSize.Height() < 0 ) +/*?*/ aMoveSize.Height() = -aTopLeft.Y(); +/*N*/ +/*N*/ // get corresponding move size in millimeters: +/*N*/ Point aNewPos( aTopLeft.X() + aMoveSize.Width(), aTopLeft.Y() + aMoveSize.Height() ); +/*N*/ lcl_TwipsToMM( aNewPos ); +/*N*/ aMoveSize = Size( aNewPos.X() - aOldMMPos.X(), aNewPos.Y() - aOldMMPos.Y() ); // millimeters +/*N*/ +/*N*/ AddCalcUndo( new SdrUndoMoveObj( *pObject, aMoveSize ) ); +/*N*/ pObject->Move( aMoveSize ); +/*N*/ } +/*N*/ else if ( rArea.IsInside(aObjRect.BottomRight()) && +/*N*/ !pObject->IsResizeProtect() ) +/*N*/ { +/*N*/ // geschuetzte Groessen werden nicht veraendert +/*N*/ // (Positionen schon, weil sie ja an der Zelle "verankert" sind) +/*N*/ AddCalcUndo( new SdrUndoGeoObj( *pObject ) ); +/*N*/ long nOldSizeX = aObjRect.Right() - aObjRect.Left() + 1; +/*N*/ long nOldSizeY = aObjRect.Bottom() - aObjRect.Top() + 1; +/*N*/ pObject->Resize( aOldMMPos, Fraction( nOldSizeX+rMove.X(), nOldSizeX ), +/*N*/ Fraction( nOldSizeY+rMove.Y(), nOldSizeY ) ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScDrawLayer::WidthChanged( USHORT nTab, USHORT nCol, long nDifTwips ) +/*N*/ { +/*N*/ DBG_ASSERT( pDoc, "ScDrawLayer::WidthChanged without document" ); +/*N*/ if ( !pDoc ) +/*N*/ return; +/*N*/ +/*N*/ if (!bAdjustEnabled) +/*N*/ return; +/*N*/ +/*N*/ USHORT i; +/*N*/ Rectangle aRect; +/*N*/ Point aTopLeft; +/*N*/ +/*N*/ for (i=0; i<nCol; i++) +/*N*/ aRect.Left() += pDoc->GetColWidth(i,nTab); +/*N*/ aTopLeft.X() = aRect.Left(); +/*N*/ aRect.Left() += pDoc->GetColWidth(nCol,nTab); +/*N*/ +/*N*/ aRect.Right() = MAXMM; +/*N*/ aRect.Top() = 0; +/*N*/ aRect.Bottom() = MAXMM; +/*N*/ +/*N*/ //! aTopLeft ist falsch, wenn mehrere Spalten auf einmal ausgeblendet werden +/*N*/ +/*N*/ MoveAreaTwips( nTab, aRect, Point( nDifTwips,0 ), aTopLeft ); +/*N*/ } + +/*N*/ void ScDrawLayer::HeightChanged( USHORT nTab, USHORT nRow, long nDifTwips ) +/*N*/ { +/*N*/ DBG_ASSERT( pDoc, "ScDrawLayer::HeightChanged without document" ); +/*N*/ if ( !pDoc ) +/*N*/ return; +/*N*/ +/*N*/ if (!bAdjustEnabled) +/*N*/ return; +/*N*/ +/*N*/ USHORT i; +/*N*/ Rectangle aRect; +/*N*/ Point aTopLeft; +/*N*/ +/*N*/ for (i=0; i<nRow; i++) +/*N*/ aRect.Top() += pDoc->FastGetRowHeight(i,nTab); +/*N*/ aTopLeft.Y() = aRect.Top(); +/*N*/ aRect.Top() += pDoc->FastGetRowHeight(nRow,nTab); +/*N*/ +/*N*/ aRect.Bottom() = MAXMM; +/*N*/ aRect.Left() = 0; +/*N*/ aRect.Right() = MAXMM; +/*N*/ +/*N*/ //! aTopLeft ist falsch, wenn mehrere Zeilen auf einmal ausgeblendet werden +/*N*/ +/*N*/ MoveAreaTwips( nTab, aRect, Point( 0,nDifTwips ), aTopLeft ); +/*N*/ } + +/*N*/ BOOL ScDrawLayer::HasObjectsInRows( USHORT nTab, USHORT nStartRow, USHORT nEndRow ) +/*N*/ { +/*N*/ DBG_ASSERT( pDoc, "ScDrawLayer::HasObjectsInRows without document" ); +/*N*/ if ( !pDoc ) +/*N*/ return FALSE; +/*N*/ +/*N*/ Rectangle aTestRect; +/*N*/ +/*N*/ USHORT i; +/*N*/ for (i=0; i<nStartRow; i++) +/*N*/ aTestRect.Top() += pDoc->FastGetRowHeight(i,nTab); +/*N*/ +/*N*/ if (nEndRow==MAXROW) +/*N*/ aTestRect.Bottom() = MAXMM; +/*N*/ else +/*N*/ { +/*N*/ aTestRect.Bottom() = aTestRect.Top(); +/*N*/ for (i=nStartRow; i<=nEndRow; i++) +/*N*/ { +/*N*/ aTestRect.Bottom() += pDoc->FastGetRowHeight(i,nTab); +/*N*/ } +/*N*/ TwipsToMM( aTestRect.Bottom() ); +/*N*/ } +/*N*/ +/*N*/ TwipsToMM( aTestRect.Top() ); +/*N*/ +/*N*/ aTestRect.Left() = 0; +/*N*/ aTestRect.Right() = MAXMM; +/*N*/ +/*N*/ SdrPage* pPage = GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page nicht gefunden"); +/*N*/ if (!pPage) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ Rectangle aObjRect; +/*N*/ SdrObjListIter aIter( *pPage ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while ( pObject && !bFound ) +/*N*/ { +/*N*/ aObjRect = pObject->GetSnapRect(); //! GetLogicRect ? +/*N*/ if (aTestRect.IsInside(aObjRect.TopLeft()) || aTestRect.IsInside(aObjRect.BottomLeft())) +/*N*/ bFound = TRUE; +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + + + + + + + + +// static + +/*N*/ inline BOOL IsNamedObject( SdrObject* pObj, const String& rName ) +/*N*/ { +/*N*/ // TRUE if rName is the object's Name or PersistName +/*N*/ // (used to find a named object) +/*N*/ +/*N*/ return ( pObj->GetName() == rName || +/*N*/ ( pObj->GetObjIdentifier() == OBJ_OLE2 && +/*N*/ static_cast<SdrOle2Obj*>(pObj)->GetPersistName() == rName ) ); +/*N*/ } + +/*N*/ SdrObject* ScDrawLayer::GetNamedObject( const String& rName, USHORT nId, USHORT& rFoundTab ) const +/*N*/ { +/*N*/ USHORT nTabCount = GetPageCount(); +/*N*/ for (USHORT nTab=0; nTab<nTabCount; nTab++) +/*N*/ { +/*N*/ const SdrPage* pPage = GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (pPage) +/*N*/ { +/*N*/ SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( nId == 0 || pObject->GetObjIdentifier() == nId ) +/*N*/ if ( IsNamedObject( pObject, rName ) ) +/*N*/ { +/*N*/ rFoundTab = nTab; +/*N*/ return pObject; +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return NULL; +/*N*/ } + + + + +/*N*/ void ScDrawLayer::SetAnchor( SdrObject* pObj, ScAnchorType eType ) +/*N*/ { +/*N*/ // Ein an der Seite verankertes Objekt zeichnet sich durch eine Anker-Pos +/*N*/ // von (0,1) aus. Das ist ein shabby Trick, der aber funktioniert! +/*N*/ Point aAnchor( 0, eType == SCA_PAGE ? 1 : 0 ); +/*N*/ pObj->SetAnchorPos( aAnchor ); +/*N*/ } + +/*N*/ ScAnchorType ScDrawLayer::GetAnchor( const SdrObject* pObj ) +/*N*/ { +/*N*/ Point aAnchor( pObj->GetAnchorPos() ); +/*N*/ return ( aAnchor.Y() != 0 ) ? SCA_PAGE : SCA_CELL; +/*N*/ } + +/*N*/ ScDrawObjData* ScDrawLayer::GetObjData( SdrObject* pObj, BOOL bCreate ) // static +/*N*/ { +/*N*/ USHORT nCount = pObj->GetUserDataCount(); +/*N*/ for( USHORT i = 0; i < nCount; i++ ) +/*N*/ { +/*?*/ SdrObjUserData* pData = pObj->GetUserData( i ); +/*?*/ if( pData && pData->GetInventor() == SC_DRAWLAYER +/*?*/ && pData->GetId() == SC_UD_OBJDATA ) +/*?*/ return (ScDrawObjData*) pData; +/*N*/ } +/*N*/ if( bCreate ) +/*N*/ { +/*N*/ ScDrawObjData* pData = new ScDrawObjData; +/*N*/ pObj->InsertUserData( pData, 0 ); +/*N*/ return pData; +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScIMapInfo* ScDrawLayer::GetIMapInfo( SdrObject* pObj ) // static +/*N*/ { +/*N*/ USHORT nCount = pObj->GetUserDataCount(); +/*N*/ for( USHORT i = 0; i < nCount; i++ ) +/*N*/ { +/*?*/ SdrObjUserData* pData = pObj->GetUserData( i ); +/*?*/ if( pData && pData->GetInventor() == SC_DRAWLAYER +/*?*/ && pData->GetId() == SC_UD_IMAPDATA ) +/*?*/ return (ScIMapInfo*) pData; +/*N*/ } +/*N*/ return NULL; +/*N*/ } + + +// static: + + +/*N*/ void __EXPORT ScDrawLayer::SetChanged( FASTBOOL bFlg /* =TRUE */ ) +/*N*/ { +/*N*/ if ( bFlg && pDoc ) +/*N*/ pDoc->SetChartListenerCollectionNeedsUpdate( TRUE ); +/*N*/ FmFormModel::SetChanged( bFlg ); +/*N*/ } + +/*N*/ SvStream* __EXPORT ScDrawLayer::GetDocumentStream(SdrDocumentStreamInfo& rStreamInfo) const +/*N*/ { +/*N*/ DBG_ASSERT( pDoc, "ScDrawLayer::GetDocumentStream without document" ); +/*N*/ if ( !pDoc ) +/*N*/ return NULL; +/*N*/ +/*N*/ SvStorage* pStor = pDoc->GetDocumentShell() ? pDoc->GetDocumentShell()->GetMedium()->GetStorage() : NULL; +/*N*/ SvStream* pRet = NULL; +/*N*/ +/*N*/ if( pStor ) +/*N*/ { +/*N*/ if( rStreamInfo.maUserData.Len() && +/*N*/ ( rStreamInfo.maUserData.GetToken( 0, ':' ) == +/*N*/ String( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package" ) ) ) ) +/*N*/ { +/*?*/ const String aPicturePath( rStreamInfo.maUserData.GetToken( 1, ':' ) ); +/*?*/ +/*?*/ // graphic from picture stream in picture storage in XML package +/*?*/ if( aPicturePath.GetTokenCount( '/' ) == 2 ) +/*?*/ { +/*?*/ const String aPictureStreamName( aPicturePath.GetToken( 1, '/' ) ); +/*?*/ +/*?*/ if( !xPictureStorage.Is() ) +/*?*/ { +/*?*/ const String aPictureStorageName( aPicturePath.GetToken( 0, '/' ) ); +/*?*/ +/*?*/ if( pStor->IsContained( aPictureStorageName ) && +/*?*/ pStor->IsStorage( aPictureStorageName ) ) +/*?*/ { +/*?*/ ( (ScDrawLayer*) this )->xPictureStorage = pStor->OpenUCBStorage( aPictureStorageName, STREAM_READ | STREAM_WRITE ); +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ if( xPictureStorage.Is() && +/*?*/ xPictureStorage->IsContained( aPictureStreamName ) && +/*?*/ xPictureStorage->IsStream( aPictureStreamName ) ) +/*?*/ { +/*?*/ pRet = xPictureStorage->OpenStream( aPictureStreamName ); +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pRet = pStor->OpenStream( String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(STRING_SCSTREAM)), +/*N*/ STREAM_READ | STREAM_WRITE | STREAM_TRUNC ); +/*N*/ +/*N*/ if( pRet ) +/*N*/ { +/*N*/ pRet->SetVersion( pStor->GetVersion() ); +/*N*/ pRet->SetKey( pStor->GetKey() ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ rStreamInfo.mbDeleteAfterUse = ( pRet != NULL ); +/*N*/ } +/*N*/ +/*N*/ return pRet; +/*N*/ } + +/*N*/ void ScDrawLayer::ReleasePictureStorage() +/*N*/ { +/*N*/ xPictureStorage.Clear(); +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_fillinfo.cxx b/binfilter/bf_sc/source/core/data/sc_fillinfo.cxx new file mode 100644 index 000000000000..cf5c1802ed1e --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_fillinfo.cxx @@ -0,0 +1,86 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svx/boxitem.hxx> +#include <bf_svx/shaditem.hxx> + +#include "document.hxx" +#include "cell.hxx" +#include "attarray.hxx" +#include "markdata.hxx" +#include "patattr.hxx" +#include "poolhelp.hxx" +#include "docpool.hxx" +#include "conditio.hxx" +#include "stlpool.hxx" +namespace binfilter { + + +// ----------------------------------------------------------------------- + +enum FillInfoLinePos + { + FILP_TOP, + FILP_BOTTOM, + FILP_LEFT, + FILP_RIGHT + }; + + +/*N*/ inline const SvxBorderLine* GetNullOrLine( const SvxBoxItem* pBox, FillInfoLinePos eWhich ) +/*N*/ { +/*N*/ if (pBox) +/*N*/ { +/*N*/ if (eWhich==FILP_TOP) +/*N*/ return pBox->GetTop(); +/*N*/ else if (eWhich==FILP_BOTTOM) +/*N*/ return pBox->GetBottom(); +/*N*/ else if (eWhich==FILP_LEFT) +/*N*/ return pBox->GetLeft(); +/*N*/ else +/*N*/ return pBox->GetRight(); +/*N*/ } +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ inline BOOL ScDocument::RowHidden( USHORT nRow, USHORT nTab ) +/*N*/ { +/*N*/ return ( pTab[nTab]->pRowFlags[nRow] & CR_HIDDEN ) != 0; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_global.cxx b/binfilter/bf_sc/source/core/data/sc_global.cxx new file mode 100644 index 000000000000..7dd2a41d36ea --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_global.cxx @@ -0,0 +1,787 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svx/editobj.hxx> +#include <bf_svx/scripttypeitem.hxx> +#include <bf_svx/langitem.hxx> +#include <bf_sfx2/app.hxx> +#include <bf_svtools/zformat.hxx> +#include <vcl/image.hxx> +#include <tools/rcid.h> +#include <vcl/virdev.hxx> +#include <stdlib.h> +#include <time.h> +#include <ctype.h> + + +#include <i18npool/mslangid.hxx> +#include <unotools/intlwrapper.hxx> + +#include "autoform.hxx" +#include "patattr.hxx" +#include "addincol.hxx" +#include "adiasync.hxx" +#include "userlist.hxx" +#include "interpre.hxx" +#include "strload.hxx" +#include "docpool.hxx" +#include "unitconv.hxx" +#include "globstr.hrc" +#include "bf_sc.hrc" +#include <legacysmgr/legacy_binfilters_smgr.hxx> //STRIP002 + +namespace binfilter { +// ----------------------------------------------------------------------- + +#define CLIPST_AVAILABLE 0 +#define CLIPST_CAPTURED 1 +#define CLIPST_DELETE 2 +#define CLIPST_DRAW 3 + +ScDocShellRef* ScGlobal::pDrawClipDocShellRef = NULL; +ScAutoFormat* ScGlobal::pAutoFormat = NULL; +FuncCollection* ScGlobal::pFuncCollection = NULL; +ScUnoAddInCollection* ScGlobal::pAddInCollection = NULL; +ScUserList* ScGlobal::pUserList = NULL; +String** ScGlobal::ppRscString = NULL; +LanguageType ScGlobal::eLnge = LANGUAGE_SYSTEM; +::com::sun::star::lang::Locale* ScGlobal::pLocale = NULL; +SvtSysLocale* ScGlobal::pSysLocale = NULL; +const CharClass* ScGlobal::pCharClass = NULL; +const LocaleDataWrapper* ScGlobal::pLocaleData = NULL; +CalendarWrapper* ScGlobal::pCalendar = NULL; +CollatorWrapper* ScGlobal::pCollator = NULL; +CollatorWrapper* ScGlobal::pCaseCollator = NULL; +::utl::TransliterationWrapper* ScGlobal::pTransliteration = NULL; +::utl::TransliterationWrapper* ScGlobal::pCaseTransliteration = NULL; +IntlWrapper* ScGlobal::pScIntlWrapper = NULL; +sal_Unicode ScGlobal::cListDelimiter = ','; +String* ScGlobal::pEmptyString = NULL; +String* ScGlobal::pStrClipDocName = NULL; + +SvxBrushItem* ScGlobal::pEmptyBrushItem = NULL; +SvxBrushItem* ScGlobal::pButtonBrushItem = NULL; +SvxBrushItem* ScGlobal::pEmbeddedBrushItem = NULL; +SvxBrushItem* ScGlobal::pProtectedBrushItem = NULL; + +ImageList* ScGlobal::pOutlineBitmaps = NULL; +ImageList* ScGlobal::pOutlineBitmapsHC = NULL; + +ScFunctionList* ScGlobal::pStarCalcFunctionList = NULL; +ScFunctionMgr* ScGlobal::pStarCalcFunctionMgr = NULL; + +ScUnitConverter* ScGlobal::pUnitConverter = NULL; +SvNumberFormatter* ScGlobal::pEnglishFormatter = NULL; + +double ScGlobal::nScreenPPTX = 96.0; +double ScGlobal::nScreenPPTY = 96.0; + +USHORT ScGlobal::nDefFontHeight = 240; +USHORT ScGlobal::nStdRowHeight = 257; + +long ScGlobal::nLastRowHeightExtra = 0; +long ScGlobal::nLastColWidthExtra = STD_EXTRA_WIDTH; + +static USHORT nPPTZoom = 0; // ScreenZoom used to determine nScreenPPTX/Y + + +// ... oder so? + +BOOL bOderSo; + +class SfxViewShell; +SfxViewShell* pScActiveViewShell = NULL; //! als Member !!!!! +USHORT nScClickMouseModifier = 0; //! dito +USHORT nScFillModeMouseModifier = 0; //! dito + +// Hack: ScGlobal::GetUserList() muss InitAppOptions in der UI aufrufen, +// damit UserList aus Cfg geladen wird + +void global_InitAppOptions(); + +// ----------------------------------------------------------------------- + +/*N*/ String ScTripel::GetColRowString( BOOL bAbsolute ) const +/*N*/ { +/*N*/ String aString; +/*N*/ if (bAbsolute) +/*N*/ aString.Append( '$' ); +/*N*/ +/*N*/ if ( nCol < 26 ) +/*N*/ aString.Append( (sal_Unicode) ( 'A' + nCol ) ); +/*N*/ else +/*N*/ { +/*N*/ aString.Append( (sal_Unicode) ( 'A' + ( nCol / 26 ) - 1 ) ); +/*N*/ aString.Append( (sal_Unicode) ( 'A' + ( nCol % 26 ) ) ); +/*N*/ } +/*N*/ +/*N*/ if ( bAbsolute ) +/*N*/ aString.Append( '$' ); +/*N*/ +/*N*/ aString += String::CreateFromInt32(nRow+1); +/*N*/ +/*N*/ return aString; +/*N*/ } + +/*N*/ String ScRefTripel::GetRefString(ScDocument* pDoc, USHORT nActTab) const +/*N*/ { +/*N*/ if ( !pDoc ) +/*N*/ return EMPTY_STRING; +/*N*/ if ( nTab+1 > pDoc->GetTableCount() ) +/*N*/ return ScGlobal::GetRscString( STR_NOREF_STR ); +/*N*/ +/*N*/ String aString; +/*N*/ USHORT nFlags = SCA_VALID; +/*N*/ if ( nActTab != nTab ) +/*N*/ { +/*N*/ nFlags |= SCA_TAB_3D; +/*N*/ if ( !bRelTab ) +/*N*/ nFlags |= SCA_TAB_ABSOLUTE; +/*N*/ } +/*N*/ if ( !bRelCol ) +/*N*/ nFlags |= SCA_COL_ABSOLUTE; +/*N*/ if ( !bRelRow ) +/*N*/ nFlags |= SCA_ROW_ABSOLUTE; +/*N*/ +/*N*/ ScAddress( nCol, nRow, nTab ).Format( aString, nFlags, pDoc ); +/*N*/ +/*N*/ return aString; +/*N*/ } + + +//======================================================================== +// +// statische Funktionen +// +//======================================================================== + +/*N*/ BOOL ScGlobal::HasAttrChanged( const SfxItemSet& rNewAttrs, +/*N*/ const SfxItemSet& rOldAttrs, +/*N*/ const USHORT nWhich ) +/*N*/ { +/*N*/ BOOL bInvalidate = FALSE; +/*N*/ const SfxItemState eNewState = rNewAttrs.GetItemState( nWhich ); +/*N*/ const SfxItemState eOldState = rOldAttrs.GetItemState( nWhich ); +/*N*/ +/*N*/ //---------------------------------------------------------- +/*N*/ +/*N*/ if ( eNewState == eOldState ) +/*N*/ { +/*N*/ // beide Items gesetzt +/*N*/ // PoolItems, d.h. Pointer-Vergleich zulaessig +/*N*/ if ( SFX_ITEM_SET == eOldState ) +/*N*/ bInvalidate = (&rNewAttrs.Get( nWhich ) != &rOldAttrs.Get( nWhich )); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // ein Default-Item dabei +/*N*/ // PoolItems, d.h. Item-Vergleich noetig +/*N*/ +/*N*/ const SfxPoolItem& rOldItem = ( SFX_ITEM_SET == eOldState ) +/*N*/ ? rOldAttrs.Get( nWhich ) +/*N*/ : rOldAttrs.GetPool()->GetDefaultItem( nWhich ); +/*N*/ +/*N*/ const SfxPoolItem& rNewItem = ( SFX_ITEM_SET == eNewState ) +/*N*/ ? rNewAttrs.Get( nWhich ) +/*N*/ : rNewAttrs.GetPool()->GetDefaultItem( nWhich ); +/*N*/ +/*N*/ bInvalidate = (rNewItem != rOldItem); +/*N*/ } +/*N*/ +/*N*/ return bInvalidate; +/*N*/ } + +/*N*/ ULONG ScGlobal::GetStandardFormat( SvNumberFormatter& rFormatter, +/*N*/ ULONG nFormat, short nType ) +/*N*/ { +/*N*/ const SvNumberformat* pFormat = rFormatter.GetEntry( nFormat ); +/*N*/ if ( pFormat ) +/*N*/ return rFormatter.GetStandardFormat( nFormat, nType, pFormat->GetLanguage() ); +/*N*/ return rFormatter.GetStandardFormat( nType, eLnge ); +/*N*/ } + +/*N*/ ULONG ScGlobal::GetStandardFormat( double fNumber, SvNumberFormatter& rFormatter, +/*N*/ ULONG nFormat, short nType ) +/*N*/ { +/*N*/ const SvNumberformat* pFormat = rFormatter.GetEntry( nFormat ); +/*N*/ if ( pFormat ) +/*N*/ return rFormatter.GetStandardFormat( fNumber, nFormat, nType, +/*N*/ pFormat->GetLanguage() ); +/*?*/ return rFormatter.GetStandardFormat( nType, eLnge ); +/*N*/ } + + +// static +/*N*/ SvNumberFormatter* ScGlobal::GetEnglishFormatter() +/*N*/ { +/*N*/ if ( !pEnglishFormatter ) +/*N*/ { +/*N*/ pEnglishFormatter = new SvNumberFormatter( +/*N*/ ::legacy_binfilters::getLegacyProcessServiceFactory(), LANGUAGE_ENGLISH_US ); +/*N*/ pEnglishFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_INTL_FORMAT ); +/*N*/ } +/*N*/ return pEnglishFormatter; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScGlobal::CheckWidthInvalidate( BOOL& bNumFormatChanged, +/*N*/ const SfxItemSet& rNewAttrs, +/*N*/ const SfxItemSet& rOldAttrs ) +/*N*/ { +/*N*/ // Ueberpruefen, ob Attributaenderungen in rNewAttrs gegnueber +/*N*/ // rOldAttrs die Textbreite an einer Zelle ungueltig machen +/*N*/ +/*N*/ bNumFormatChanged = +/*N*/ HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_VALUE_FORMAT ); +/*N*/ return ( bNumFormatChanged +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_LANGUAGE_FORMAT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_HEIGHT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_HEIGHT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_HEIGHT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_WEIGHT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_WEIGHT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_WEIGHT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_POSTURE ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_POSTURE ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_POSTURE ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_UNDERLINE ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_CROSSEDOUT ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_CONTOUR ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_SHADOWED ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ORIENTATION ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ROTATE_VALUE ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ROTATE_MODE ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_LINEBREAK ) +/*N*/ || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_MARGIN ) +/*N*/ ); +/*N*/ } + + + + +/*N*/ ScAutoFormat* ScGlobal::GetAutoFormat() +/*N*/ { +/*N*/ if ( !pAutoFormat ) +/*N*/ { +/*N*/ pAutoFormat = new ScAutoFormat; +/*N*/ pAutoFormat->Load(); +/*N*/ } +/*N*/ +/*N*/ return pAutoFormat; +/*N*/ } + +/*N*/ FuncCollection* ScGlobal::GetFuncCollection() +/*N*/ { +/*N*/ if (!pFuncCollection) +/*N*/ pFuncCollection = new FuncCollection(); +/*N*/ return pFuncCollection; +/*N*/ } + +/*N*/ ScUnoAddInCollection* ScGlobal::GetAddInCollection() +/*N*/ { +/*N*/ if (!pAddInCollection) +/*N*/ pAddInCollection = new ScUnoAddInCollection(); +/*N*/ return pAddInCollection; +/*N*/ } + +/*N*/ ScUserList* ScGlobal::GetUserList() +/*N*/ { +/*N*/ // Hack: Cfg-Item an der App ggF. laden +/*N*/ +/*N*/ global_InitAppOptions(); +/*N*/ +/*N*/ if (!pUserList) +/*N*/ pUserList = new ScUserList(); +/*N*/ return pUserList; +/*N*/ } + +/*N*/ void ScGlobal::SetUserList( const ScUserList* pNewList ) +/*N*/ { +/*N*/ if ( pNewList ) +/*N*/ { +/*N*/ if ( !pUserList ) +/*N*/ pUserList = new ScUserList( *pNewList ); +/*N*/ else +/*?*/ *pUserList = *pNewList; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ delete pUserList; +/*?*/ pUserList = NULL; +/*N*/ } +/*N*/ } + +/*N*/ const String& ScGlobal::GetRscString( USHORT nIndex ) +/*N*/ { +/*N*/ DBG_ASSERT( nIndex <= STR_COUNT, +/*N*/ "-ScGlobal::GetRscString(): Index zu gross!"); +/*N*/ if( !ppRscString[ nIndex ] ) +/*N*/ { +/*N*/ ppRscString[ nIndex ] = +/*N*/ new String( ScRscStrLoader( RID_GLOBSTR, nIndex ).GetString() ); +/*N*/ } +/*N*/ return *ppRscString[ nIndex ]; +/*N*/ } + +/*N*/ String ScGlobal::GetErrorString(USHORT nErrNumber) +/*N*/ { +/*N*/ String sResStr; +/*N*/ switch (nErrNumber) +/*N*/ { +/*N*/ case NOVALUE : nErrNumber = STR_NV_STR; break; +/*N*/ case errNoRef : nErrNumber = STR_NO_REF_TABLE; break; +/*N*/ case errNoName : nErrNumber = STR_NO_NAME_REF; break; +/*N*/ case errNoAddin : nErrNumber = STR_NO_ADDIN; break; +/*N*/ case errNoMacro : nErrNumber = STR_NO_MACRO; break; +/*N*/ case errDoubleRef: +/*N*/ case errNoValue : nErrNumber = STR_NO_VALUE; break; +/*N*/ +/*N*/ default : sResStr = GetRscString(STR_ERROR_STR); +/*N*/ sResStr += String::CreateFromInt32( nErrNumber ); +/*N*/ nErrNumber = 0; +/*N*/ break; +/*N*/ } +/*N*/ if( nErrNumber ) +/*N*/ sResStr = GetRscString( nErrNumber ); +/*N*/ return sResStr; +/*N*/ } + +/*N*/ const String& ScGlobal::GetEmptyString() +/*N*/ { +/*N*/ return *pEmptyString; +/*N*/ } + + +/*N*/ void ScGlobal::Init() +/*N*/ { +/*N*/ pEmptyString = new String; +/*N*/ +/*N*/ // Die Default-Sprache fuer Zahlenformate (ScGlobal::eLnge) +/*N*/ // muss immer LANGUAGE_SYSTEM sein +/*N*/ //! Dann kann auch die Variable raus +/*N*/ eLnge = LANGUAGE_SYSTEM; +/*N*/ +/*N*/ //! Wenn Sortierung etc. von der Sprache der installierten Offfice-Version +/*N*/ //! abhaengen sollen, hier "Application::GetSettings().GetUILanguage()" +/*N*/ String aLanguage, aCountry; +/*N*/ LanguageType eOfficeLanguage = Application::GetSettings().GetLanguage(); +/*N*/ pLocale = new ::com::sun::star::lang::Locale( MsLangId::convertLanguageToLocale( eOfficeLanguage )); +/*N*/ pSysLocale = new SvtSysLocale; +/*N*/ pCharClass = pSysLocale->GetCharClassPtr(); +/*N*/ pLocaleData = pSysLocale->GetLocaleDataPtr(); +/*N*/ pCalendar = new CalendarWrapper( ::legacy_binfilters::getLegacyProcessServiceFactory() ); +/*N*/ pCalendar->loadDefaultCalendar( *pLocale ); +/*N*/ pCollator = new CollatorWrapper( ::legacy_binfilters::getLegacyProcessServiceFactory() ); +/*N*/ pCollator->loadDefaultCollator( *pLocale, SC_COLLATOR_IGNORES ); +/*N*/ pCaseCollator = new CollatorWrapper( ::legacy_binfilters::getLegacyProcessServiceFactory() ); +/*N*/ pCaseCollator->loadDefaultCollator( *pLocale, 0 ); +/*N*/ pTransliteration = new ::utl::TransliterationWrapper( +/*N*/ ::legacy_binfilters::getLegacyProcessServiceFactory(), SC_TRANSLITERATION_IGNORECASE ); +/*N*/ pTransliteration->loadModuleIfNeeded( eOfficeLanguage ); +/*N*/ pCaseTransliteration = new ::utl::TransliterationWrapper( +/*N*/ ::legacy_binfilters::getLegacyProcessServiceFactory(), SC_TRANSLITERATION_CASESENSE ); +/*N*/ pCaseTransliteration->loadModuleIfNeeded( eOfficeLanguage ); +/*N*/ pScIntlWrapper = new IntlWrapper( ::legacy_binfilters::getLegacyProcessServiceFactory(), *pLocale ); +/*N*/ +/*N*/ ppRscString = new String *[ STR_COUNT+1 ]; +/*N*/ for( USHORT nC = 0 ; nC <= STR_COUNT ; nC++ ) ppRscString[ nC ] = NULL; +/*N*/ +/*N*/ pEmptyBrushItem = new SvxBrushItem( Color( COL_TRANSPARENT ) ); +/*N*/ pButtonBrushItem = new SvxBrushItem( Color() ); +/*N*/ pEmbeddedBrushItem = new SvxBrushItem( Color( COL_LIGHTCYAN ) ); +/*N*/ pProtectedBrushItem = new SvxBrushItem( Color( COL_LIGHTGRAY ) ); +/*N*/ +/*N*/ UpdatePPT(NULL); +/*N*/ ScCompiler::Init(); +/*N*/ srand( (unsigned) time( NULL ) ); // Random Seed Init fuer Interpreter +/*N*/ +/*N*/ InitAddIns(); +/*N*/ +/*N*/ pStrClipDocName = new String( ScResId( SCSTR_NONAME ) ); +/*N*/ *pStrClipDocName += '1'; +/*N*/ +/*N*/ // ScDocumentPool::InitVersionMaps() ist schon vorher gerufen worden +/*N*/ } + +/*N*/ void ScGlobal::UpdatePPT( OutputDevice* pDev ) +/*N*/ { +/*N*/ USHORT nCurrentZoom = Application::GetSettings().GetStyleSettings().GetScreenZoom(); +/*N*/ if ( nCurrentZoom != nPPTZoom ) +/*N*/ { +/*N*/ // Screen PPT values must be updated when ScreenZoom has changed. +/*N*/ // If called from Window::DataChanged, the window is passed as pDev, +/*N*/ // to make sure LogicToPixel uses a device which already uses the new zoom. +/*N*/ // For the initial settings, NULL is passed and GetDefaultDevice used. +/*N*/ +/*N*/ if ( !pDev ) +/*N*/ pDev = Application::GetDefaultDevice(); +/*N*/ Point aPix1000 = pDev->LogicToPixel( Point(1000,1000), MAP_TWIP ); +/*N*/ nScreenPPTX = aPix1000.X() / 1000.0; +/*N*/ nScreenPPTY = aPix1000.Y() / 1000.0; +/*N*/ nPPTZoom = nCurrentZoom; +/*N*/ } +/*N*/ } + + + + +/*N*/ void ScGlobal::InitTextHeight(SfxItemPool* pPool) +/*N*/ { +/*N*/ if (!pPool) +/*N*/ { +/*?*/ DBG_ERROR("kein Pool bei ScGlobal::InitTextHeight"); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ const ScPatternAttr* pPattern = (const ScPatternAttr*)&pPool->GetDefaultItem(ATTR_PATTERN); +/*N*/ if (!pPattern) +/*N*/ { +/*?*/ DBG_ERROR("kein Default-Pattern bei ScGlobal::InitTextHeight"); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ // String aTestString('X'); +/*N*/ OutputDevice* pDefaultDev = Application::GetDefaultDevice(); +/*N*/ VirtualDevice aVirtWindow( *pDefaultDev ); +/*N*/ aVirtWindow.SetMapMode(MAP_PIXEL); +/*N*/ Font aDefFont; +/*N*/ pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, &aVirtWindow); // font color doesn't matter here +/*N*/ aVirtWindow.SetFont(aDefFont); +/*N*/ nDefFontHeight = (USHORT) aVirtWindow.PixelToLogic(Size(0, aVirtWindow.GetTextHeight()), +/*N*/ MAP_TWIP).Height(); +/*N*/ +/*N*/ const SvxMarginItem* pMargin = (const SvxMarginItem*)&pPattern->GetItem(ATTR_MARGIN); +/*N*/ +/*N*/ nStdRowHeight = (USHORT) ( nDefFontHeight + +/*N*/ pMargin->GetTopMargin() + pMargin->GetBottomMargin() +/*N*/ - STD_ROWHEIGHT_DIFF ); +/*N*/ } + +/*N*/ void ScGlobal::Clear() +/*N*/ { +/*N*/ // asyncs _vor_ ExitExternalFunc zerstoeren! +/*N*/ theAddInAsyncTbl.DeleteAndDestroy( 0, theAddInAsyncTbl.Count() ); +/*N*/ ExitExternalFunc(); +/*N*/ DELETEZ(pAutoFormat); +/*N*/ DELETEZ(pFuncCollection); +/*N*/ DELETEZ(pAddInCollection); +/*N*/ DELETEZ(pUserList); +/*N*/ +/*N*/ for( USHORT nC = 0 ; nC < STR_COUNT ; nC++ ) +/*N*/ if( ppRscString ) delete ppRscString[ nC ]; +/*N*/ delete[] ppRscString; +/*N*/ ppRscString = NULL; +/*N*/ +/*N*/ DELETEZ(pStarCalcFunctionList); // vor ResMgr zerstoeren! +/*N*/ DELETEZ(pStarCalcFunctionMgr); +/*N*/ ScCompiler::DeInit(); +/*N*/ ScInterpreter::GlobalExit(); // statischen Stack loeschen +/*N*/ +/*N*/ DELETEZ(pEmptyBrushItem); +/*N*/ DELETEZ(pButtonBrushItem); +/*N*/ DELETEZ(pEmbeddedBrushItem); +/*N*/ DELETEZ(pProtectedBrushItem); +/*N*/ DELETEZ(pOutlineBitmaps); +/*N*/ DELETEZ(pOutlineBitmapsHC); +/*N*/ // DELETEZ(pAnchorBitmap); +/*N*/ // DELETEZ(pGrayAnchorBitmap); +/*N*/ DELETEZ(pEnglishFormatter); +/*N*/ DELETEZ(pCaseTransliteration); +/*N*/ DELETEZ(pTransliteration); +/*N*/ DELETEZ(pCaseCollator); +/*N*/ DELETEZ(pCollator); +/*N*/ DELETEZ(pCalendar); +/*N*/ //! do NOT delete pCharClass since it is a pointer to the single SvtSysLocale instance +/*N*/ pCharClass = NULL; +/*N*/ //! do NOT delete pLocaleData since it is a pointer to the single SvtSysLocale instance +/*N*/ pLocaleData = NULL; +/*N*/ DELETEZ(pSysLocale); +/*N*/ DELETEZ(pLocale); +/*N*/ DELETEZ(pScIntlWrapper); +/*N*/ DELETEZ(pStrClipDocName); +/*N*/ +/*N*/ DELETEZ(pUnitConverter); +/*N*/ +/*N*/ ScDocumentPool::DeleteVersionMaps(); +/*N*/ +/*N*/ DELETEZ(pEmptyString); +/*N*/ } + +//------------------------------------------------------------------------ + +// static +/*N*/ CharSet ScGlobal::GetCharsetValue( const String& rCharSet ) +/*N*/ { +/*N*/ // new TextEncoding values +/*N*/ if ( CharClass::isAsciiNumeric( rCharSet ) ) +/*N*/ { +/*?*/ sal_Int32 nVal = rCharSet.ToInt32(); +/*?*/ if ( !nVal || nVal == RTL_TEXTENCODING_DONTKNOW ) +/*?*/ return gsl_getSystemTextEncoding(); +/*?*/ return (CharSet) nVal; +/*N*/ } +/*N*/ // old CharSet values for compatibility +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("ANSI") ) return RTL_TEXTENCODING_MS_1252; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("MAC") ) return RTL_TEXTENCODING_APPLE_ROMAN; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC") ) return RTL_TEXTENCODING_IBM_850; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_437")) return RTL_TEXTENCODING_IBM_437; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_850")) return RTL_TEXTENCODING_IBM_850; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_860")) return RTL_TEXTENCODING_IBM_860; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_861")) return RTL_TEXTENCODING_IBM_861; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_863")) return RTL_TEXTENCODING_IBM_863; +/*N*/ else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_865")) return RTL_TEXTENCODING_IBM_865; +/*N*/ // else if (rCharSet.EqualsIgnoreCaseAscii("SYSTEM") ) return gsl_getSystemTextEncoding(); +/*N*/ else return gsl_getSystemTextEncoding(); +/*N*/ } + +//------------------------------------------------------------------------ + +// static +/*N*/ String ScGlobal::GetCharsetString( CharSet eVal ) +/*N*/ { +/*N*/ const sal_Char* pChar; +/*N*/ switch ( eVal ) +/*N*/ { +/*N*/ // old CharSet strings for compatibility +/*N*/ case RTL_TEXTENCODING_MS_1252: pChar = "ANSI"; break; +/*N*/ case RTL_TEXTENCODING_APPLE_ROMAN: pChar = "MAC"; break; +/*N*/ // IBMPC == IBMPC_850 +/*N*/ case RTL_TEXTENCODING_IBM_437: pChar = "IBMPC_437"; break; +/*N*/ case RTL_TEXTENCODING_IBM_850: pChar = "IBMPC_850"; break; +/*N*/ case RTL_TEXTENCODING_IBM_860: pChar = "IBMPC_860"; break; +/*N*/ case RTL_TEXTENCODING_IBM_861: pChar = "IBMPC_861"; break; +/*N*/ case RTL_TEXTENCODING_IBM_863: pChar = "IBMPC_863"; break; +/*N*/ case RTL_TEXTENCODING_IBM_865: pChar = "IBMPC_865"; break; +/*N*/ case RTL_TEXTENCODING_DONTKNOW: pChar = "SYSTEM"; break; +/*N*/ // new string of TextEncoding value +/*N*/ default: +/*N*/ return String::CreateFromInt32( eVal ); +/*N*/ } +/*N*/ return String::CreateFromAscii(pChar); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScFunctionList* ScGlobal::GetStarCalcFunctionList() +/*N*/ { +/*N*/ if ( !pStarCalcFunctionList ) +/*N*/ pStarCalcFunctionList = new ScFunctionList; +/*N*/ +/*N*/ return pStarCalcFunctionList; +/*N*/ } + +// static +/*N*/ ScUnitConverter* ScGlobal::GetUnitConverter() +/*N*/ { +/*N*/ if ( !pUnitConverter ) +/*N*/ pUnitConverter = new ScUnitConverter; +/*N*/ +/*N*/ return pUnitConverter; +/*N*/ } + + +//------------------------------------------------------------------------ + +// static +/*N*/ const sal_Unicode* ScGlobal::UnicodeStrChr( const sal_Unicode* pStr, +/*N*/ sal_Unicode c ) +/*N*/ { +/*N*/ if ( !pStr ) +/*N*/ return NULL; +/*N*/ while ( *pStr ) +/*N*/ { +/*N*/ if ( *pStr == c ) +/*N*/ return pStr; +/*N*/ pStr++; +/*N*/ } +/*N*/ return NULL; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScGlobal::EETextObjEqual( const EditTextObject* pObj1, +/*N*/ const EditTextObject* pObj2 ) +/*N*/ { +/*N*/ if ( pObj1 == pObj2 ) // both empty or the same object +/*N*/ return TRUE; +/*N*/ +/*N*/ if ( pObj1 && pObj2 ) +/*N*/ { +/*N*/ // first test for equal text content +/*N*/ USHORT nParCount = pObj1->GetParagraphCount(); +/*N*/ if ( nParCount != pObj2->GetParagraphCount() ) +/*N*/ return FALSE; +/*N*/ for (USHORT nPar=0; nPar<nParCount; nPar++) +/*N*/ if ( pObj1->GetText(nPar) != pObj2->GetText(nPar) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ SvMemoryStream aStream1; +/*N*/ SvMemoryStream aStream2; +/*N*/ pObj1->Store( aStream1 ); +/*N*/ pObj2->Store( aStream2 ); +/*N*/ ULONG nSize = aStream1.Tell(); +/*N*/ if ( aStream2.Tell() == nSize ) +/*N*/ if ( !memcmp( aStream1.GetData(), aStream2.GetData(), (USHORT) nSize ) ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ BYTE ScGlobal::GetDefaultScriptType() +/*N*/ { +/*N*/ // Used when text contains only WEAK characters. +/*N*/ // Script type of office language is used then (same as GetEditDefaultLanguage, +/*N*/ // to get consistent behavior of text in simple cells and EditEngine, +/*N*/ // also same as GetAppLanguage() in Writer) +/*N*/ +/*N*/ return (BYTE) SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguage() ); +/*N*/ } + +/*N*/ LanguageType ScGlobal::GetEditDefaultLanguage() +/*N*/ { +/*N*/ // used for EditEngine::SetDefaultLanguage +/*N*/ +/*N*/ return Application::GetSettings().GetLanguage(); +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ void ScGlobal::AddLanguage( SfxItemSet& rSet, SvNumberFormatter& rFormatter ) +/*N*/ { +/*N*/ DBG_ASSERT( rSet.GetItemState( ATTR_LANGUAGE_FORMAT, FALSE ) == SFX_ITEM_DEFAULT, +/*N*/ "ScGlobal::AddLanguage - language already added"); +/*N*/ +/*N*/ const SfxPoolItem* pHardItem; +/*N*/ if ( rSet.GetItemState( ATTR_VALUE_FORMAT, FALSE, &pHardItem ) == SFX_ITEM_SET ) +/*N*/ { +/*N*/ const SvNumberformat* pHardFormat = rFormatter.GetEntry( +/*N*/ ((const SfxUInt32Item*)pHardItem)->GetValue() ); +/*N*/ +/*N*/ ULONG nParentFmt = 0; // pool default +/*N*/ const SfxItemSet* pParent = rSet.GetParent(); +/*N*/ if ( pParent ) +/*N*/ nParentFmt = ((const SfxUInt32Item&)pParent->Get( ATTR_VALUE_FORMAT )).GetValue(); +/*N*/ const SvNumberformat* pParFormat = rFormatter.GetEntry( nParentFmt ); +/*N*/ +/*N*/ if ( pHardFormat && pParFormat && +/*N*/ (pHardFormat->GetLanguage() != pParFormat->GetLanguage()) ) +/*N*/ rSet.Put( SvxLanguageItem( pHardFormat->GetLanguage(), ATTR_LANGUAGE_FORMAT ) ); +/*N*/ } +/*N*/ } + + +/*N*/ ScFunctionList::ScFunctionList() : +/*N*/ nMaxFuncNameLen ( 0 ) +/*N*/ { +/*N*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScFuncDesc* pDesc = NULL; +} + +//------------------------------------------------------------------------ + +/*N*/ ScFunctionList::~ScFunctionList() +/*N*/ { +/*N*/ ScFuncDesc* pDesc = (ScFuncDesc*)aFunctionList.First(); +/*N*/ while (pDesc) +/*N*/ { +/*N*/ delete pDesc; +/*N*/ pDesc = (ScFuncDesc*)aFunctionList.Next(); +/*N*/ } +/*N*/ } + + +//======================================================================== +// class ScFuncDesc: + +/*N*/ ScFuncDesc::~ScFuncDesc() +/*N*/ { +/*N*/ USHORT nArgs; +/*N*/ +/*N*/ nArgs = nArgCount; +/*N*/ if (nArgs >= VAR_ARGS) nArgs -= VAR_ARGS-1; +/*N*/ if (nArgs) +/*N*/ { +/*?*/ for (USHORT i=0; i<nArgs; i++ ) +/*?*/ { +/*?*/ delete aDefArgNames[i]; +/*?*/ delete aDefArgDescs[i]; +/*?*/ } +/*?*/ delete [] aDefArgNames; +/*?*/ delete [] aDefArgDescs; +/*?*/ delete [] aDefArgOpt; +/*N*/ } +/*N*/ if(pFuncName) +/*?*/ delete pFuncName; +/*N*/ +/*N*/ if(pFuncDesc) +/*?*/ delete pFuncDesc; +/*N*/ } + +//======================================================================== +// class ScFunctionMgr: + +/*N*/ ScFunctionMgr::~ScFunctionMgr() +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 for (USHORT i = 0; i < MAX_FUNCCAT; i++) +/*N*/ } + +/*N*/ String ColToAlpha( const USHORT nCol ) +/*N*/ { +/*N*/ String aStr; +/*N*/ +/*N*/ if ( nCol < 26 ) +/*N*/ aStr = (sal_Unicode) ( 'A' + nCol ); +/*N*/ else +/*N*/ { +/*N*/ aStr = (sal_Unicode) ( 'A' + ( nCol / 26 ) - 1 ); +/*N*/ aStr += (sal_Unicode) ( 'A' + ( nCol % 26 ) ); +/*N*/ } +/*N*/ +/*N*/ return aStr; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_global2.cxx b/binfilter/bf_sc/source/core/data/sc_global2.cxx new file mode 100644 index 000000000000..00ac5ccf003f --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_global2.cxx @@ -0,0 +1,1393 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_sfx2/docfile.hxx> +#include <bf_sfx2/objsh.hxx> +#include <unotools/textsearch.hxx> +#include <bf_svtools/pathoptions.hxx> +#include <bf_svtools/useroptions.hxx> +#include <tools/urlobj.hxx> +#include <stdlib.h> +#include <ctype.h> + +#include <bf_svtools/syslocale.hxx> + +#include "document.hxx" +#include "rangeutl.hxx" +#include "pivot.hxx" +#include "rechead.hxx" +#include "compiler.hxx" + +#include "bf_sc.hrc" +#include "globstr.hrc" +namespace binfilter { + + +// ----------------------------------------------------------------------- + + + +#define MAX_LABELS 256 //!!! aus fieldwnd.hxx, muss noch nach global.hxx ??? + +//------------------------------------------------------------------------ +// struct ScImportParam: + +/*N*/ ScImportParam::ScImportParam() : +/*N*/ nCol1(0), +/*N*/ nRow1(0), +/*N*/ nCol2(0), +/*N*/ nRow2(0), +/*N*/ bImport(FALSE), +/*N*/ bNative(FALSE), +/*N*/ bSql(TRUE), +/*N*/ nType(ScDbTable) +/*N*/ { +/*N*/ } + +/*N*/ ScImportParam::ScImportParam( const ScImportParam& r ) : +/*N*/ nCol1 (r.nCol1), +/*N*/ nRow1 (r.nRow1), +/*N*/ nCol2 (r.nCol2), +/*N*/ nRow2 (r.nRow2), +/*N*/ bImport (r.bImport), +/*N*/ aDBName (r.aDBName), +/*N*/ aStatement (r.aStatement), +/*N*/ bNative (r.bNative), +/*N*/ bSql (r.bSql), +/*N*/ nType (r.nType) +/*N*/ { +/*N*/ } + +/*N*/ ScImportParam::~ScImportParam() +/*N*/ { +/*N*/ } + + +/*N*/ ScImportParam& ScImportParam::operator=( const ScImportParam& r ) +/*N*/ { +/*N*/ nCol1 = r.nCol1; +/*N*/ nRow1 = r.nRow1; +/*N*/ nCol2 = r.nCol2; +/*N*/ nRow2 = r.nRow2; +/*N*/ bImport = r.bImport; +/*N*/ aDBName = r.aDBName; +/*N*/ aStatement = r.aStatement; +/*N*/ bNative = r.bNative; +/*N*/ bSql = r.bSql; +/*N*/ nType = r.nType; +/*N*/ +/*N*/ return *this; +/*N*/ } + + + +//------------------------------------------------------------------------ +// struct ScQueryParam: + +/*N*/ ScQueryEntry::ScQueryEntry() +/*N*/ { +/*N*/ bDoQuery = FALSE; +/*N*/ bQueryByString = FALSE; +/*N*/ eOp = SC_EQUAL; +/*N*/ eConnect = SC_AND; +/*N*/ nField = 0; +/*N*/ nVal = 0.0; +/*N*/ pStr = new String; +/*N*/ pSearchParam = NULL; +/*N*/ pSearchText = NULL; +/*N*/ } + +/*N*/ ScQueryEntry::ScQueryEntry(const ScQueryEntry& r) +/*N*/ { +/*N*/ bDoQuery = r.bDoQuery; +/*N*/ bQueryByString = r.bQueryByString; +/*N*/ eOp = r.eOp; +/*N*/ eConnect = r.eConnect; +/*N*/ nField = r.nField; +/*N*/ nVal = r.nVal; +/*N*/ pStr = new String(*r.pStr); +/*N*/ pSearchParam = NULL; +/*N*/ pSearchText = NULL; +/*N*/ } + +/*N*/ ScQueryEntry::~ScQueryEntry() +/*N*/ { +/*N*/ delete pStr; +/*N*/ if ( pSearchParam ) +/*N*/ { +/*N*/ delete pSearchParam; +/*N*/ delete pSearchText; +/*N*/ } +/*N*/ } + +/*N*/ ScQueryEntry& ScQueryEntry::operator=( const ScQueryEntry& r ) +/*N*/ { +/*N*/ bDoQuery = r.bDoQuery; +/*N*/ bQueryByString = r.bQueryByString; +/*N*/ eOp = r.eOp; +/*N*/ eConnect = r.eConnect; +/*N*/ nField = r.nField; +/*N*/ nVal = r.nVal; +/*N*/ *pStr = *r.pStr; +/*N*/ if ( pSearchParam ) +/*N*/ { +/*?*/ delete pSearchParam; +/*?*/ delete pSearchText; +/*N*/ } +/*N*/ pSearchParam = NULL; +/*N*/ pSearchText = NULL; +/*N*/ +/*N*/ return *this; +/*N*/ } + +/*N*/ void ScQueryEntry::Clear() +/*N*/ { +/*N*/ bDoQuery = FALSE; +/*N*/ bQueryByString = FALSE; +/*N*/ eOp = SC_EQUAL; +/*N*/ eConnect = SC_AND; +/*N*/ nField = 0; +/*N*/ nVal = 0.0; +/*N*/ pStr->Erase(); +/*N*/ if ( pSearchParam ) +/*N*/ { +/*?*/ delete pSearchParam; +/*?*/ delete pSearchText; +/*N*/ } +/*N*/ pSearchParam = NULL; +/*N*/ pSearchText = NULL; +/*N*/ } + +/*N*/ BOOL ScQueryEntry::operator==( const ScQueryEntry& r ) const +/*N*/ { +/*N*/ return bDoQuery == r.bDoQuery +/*N*/ && bQueryByString == r.bQueryByString +/*N*/ && eOp == r.eOp +/*N*/ && eConnect == r.eConnect +/*N*/ && nField == r.nField +/*N*/ && nVal == r.nVal +/*N*/ && *pStr == *r.pStr; +/*N*/ //! pSearchParam und pSearchText nicht vergleichen +/*N*/ } +/*N*/ +/*N*/ void ScQueryEntry::Load( SvStream& rStream ) +/*N*/ { +/*N*/ BYTE cOp, cConnect; +/*N*/ rStream >> bDoQuery +/*N*/ >> bQueryByString +/*N*/ >> cOp +/*N*/ >> cConnect +/*N*/ >> nField +/*N*/ >> nVal; +/*N*/ rStream.ReadByteString( *pStr, rStream.GetStreamCharSet() ); +/*N*/ eOp = (ScQueryOp) cOp; +/*N*/ eConnect = (ScQueryConnect) cConnect; +/*N*/ } +/*N*/ +/*N*/ void ScQueryEntry::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ rStream << bDoQuery +/*N*/ << bQueryByString +/*N*/ << (BYTE) eOp +/*N*/ << (BYTE) eConnect +/*N*/ << nField +/*N*/ << nVal; +/*N*/ rStream.WriteByteString( *pStr, rStream.GetStreamCharSet() ); +/*N*/ } + +/*N*/ ::utl::TextSearch* ScQueryEntry::GetSearchTextPtr( BOOL bCaseSens ) +/*N*/ { +/*N*/ if ( !pSearchParam ) +/*N*/ { +/*N*/ pSearchParam = new ::utl::SearchParam( *pStr, utl::SearchParam::SRCH_REGEXP, +/*N*/ bCaseSens, FALSE, FALSE ); +/*N*/ pSearchText = new ::utl::TextSearch( *pSearchParam, *ScGlobal::pCharClass ); +/*N*/ } +/*N*/ return pSearchText; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScQueryParam::ScQueryParam() +/*N*/ { +/*N*/ nEntryCount = 0; +/*N*/ Clear(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScQueryParam::ScQueryParam( const ScQueryParam& r ) : +/*N*/ nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nTab(r.nTab), +/*N*/ nDestTab(r.nDestTab),nDestCol(r.nDestCol),nDestRow(r.nDestRow), +/*N*/ bHasHeader(r.bHasHeader),bInplace(r.bInplace),bCaseSens(r.bCaseSens), +/*N*/ bRegExp(r.bRegExp),bDuplicate(r.bDuplicate),bByRow(r.bByRow), +/*N*/ bDestPers(r.bDestPers) +/*N*/ { +/*N*/ nEntryCount = 0; +/*N*/ +/*N*/ Resize( r.nEntryCount ); +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ pEntries[i] = r.pEntries[i]; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScQueryParam::~ScQueryParam() +/*N*/ { +/*N*/ delete[] pEntries; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScQueryParam::Clear() +/*N*/ { +/*N*/ nCol1=nRow1=nCol2=nRow2= +/*N*/ nDestTab=nDestCol=nDestRow = 0; +/*N*/ nTab = USHRT_MAX; +/*N*/ bHasHeader=bCaseSens=bRegExp = FALSE; +/*N*/ bInplace=bByRow=bDuplicate=bDestPers = TRUE; +/*N*/ +/*N*/ Resize( MAXQUERY ); +/*N*/ for (USHORT i=0; i<MAXQUERY; i++) +/*N*/ pEntries[i].Clear(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScQueryParam& ScQueryParam::operator=( const ScQueryParam& r ) +/*N*/ { +/*N*/ nCol1 = r.nCol1; +/*N*/ nRow1 = r.nRow1; +/*N*/ nCol2 = r.nCol2; +/*N*/ nRow2 = r.nRow2; +/*N*/ nTab = r.nTab; +/*N*/ nDestTab = r.nDestTab; +/*N*/ nDestCol = r.nDestCol; +/*N*/ nDestRow = r.nDestRow; +/*N*/ bHasHeader = r.bHasHeader; +/*N*/ bInplace = r.bInplace; +/*N*/ bCaseSens = r.bCaseSens; +/*N*/ bRegExp = r.bRegExp; +/*N*/ bDuplicate = r.bDuplicate; +/*N*/ bByRow = r.bByRow; +/*N*/ bDestPers = r.bDestPers; +/*N*/ +/*N*/ Resize( r.nEntryCount ); +/*N*/ for (USHORT i=0; i<nEntryCount; i++) +/*N*/ pEntries[i] = r.pEntries[i]; +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + +BOOL ScQueryParam::operator==( const ScQueryParam& rOther ) const +{ + BOOL bEqual = FALSE; + + // Anzahl der Queries gleich? + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 USHORT nUsed = 0; + return bEqual; +} + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ void ScQueryParam::Resize(USHORT nNew) +/*N*/ { +/*N*/ if ( nNew < MAXQUERY ) +/*N*/ nNew = MAXQUERY; // nie weniger als MAXQUERY +/*N*/ +/*N*/ ScQueryEntry* pNewEntries = NULL; +/*N*/ if ( nNew ) +/*N*/ pNewEntries = new ScQueryEntry[nNew]; +/*N*/ +/*N*/ USHORT nCopy = Min( nEntryCount, nNew ); +/*N*/ for (USHORT i=0; i<nCopy; i++) +/*N*/ pNewEntries[i] = pEntries[i]; +/*N*/ +/*N*/ if ( nEntryCount ) +/*N*/ delete[] pEntries; +/*N*/ nEntryCount = nNew; +/*N*/ pEntries = pNewEntries; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ void ScQueryParam::FillInExcelSyntax(String& aCellStr, USHORT nIndex) +/*N*/ { +/*N*/ if (aCellStr.Len() > 0) +/*N*/ { +/*N*/ if ( nIndex >= nEntryCount ) +/*N*/ Resize( nIndex+1 ); +/*N*/ +/*N*/ ScQueryEntry& rEntry = pEntries[nIndex]; +/*N*/ +/*N*/ rEntry.bDoQuery = TRUE; +/*N*/ // Operatoren herausfiltern +/*N*/ if (aCellStr.GetChar(0) == '<') +/*N*/ { +/*N*/ if (aCellStr.GetChar(1) == '>') +/*N*/ { +/*N*/ *rEntry.pStr = aCellStr.Copy(2); +/*N*/ rEntry.eOp = SC_NOT_EQUAL; +/*N*/ } +/*N*/ else if (aCellStr.GetChar(1) == '=') +/*N*/ { +/*N*/ *rEntry.pStr = aCellStr.Copy(2); +/*N*/ rEntry.eOp = SC_LESS_EQUAL; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ *rEntry.pStr = aCellStr.Copy(1); +/*N*/ rEntry.eOp = SC_LESS; +/*N*/ } +/*N*/ } +/*N*/ else if (aCellStr.GetChar(0) == '>') +/*N*/ { +/*N*/ if (aCellStr.GetChar(1) == '=') +/*N*/ { +/*N*/ *rEntry.pStr = aCellStr.Copy(2); +/*N*/ rEntry.eOp = SC_GREATER_EQUAL; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ *rEntry.pStr = aCellStr.Copy(1); +/*N*/ rEntry.eOp = SC_GREATER; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (aCellStr.GetChar(0) == '=') +/*N*/ *rEntry.pStr = aCellStr.Copy(1); +/*N*/ else +/*N*/ *rEntry.pStr = aCellStr; +/*N*/ rEntry.eOp = SC_EQUAL; +/*N*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScQueryParam::Load( SvStream& rStream ) // z.B. fuer Pivot-Tabelle +/*N*/ { +/*N*/ // bDestPers wird nicht geladen/gespeichert +/*N*/ +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> nCol1 +/*N*/ >> nRow1 +/*N*/ >> nCol2 +/*N*/ >> nRow2 +/*N*/ >> nDestTab +/*N*/ >> nDestCol +/*N*/ >> nDestRow +/*N*/ >> bHasHeader +/*N*/ >> bInplace +/*N*/ >> bCaseSens +/*N*/ >> bRegExp +/*N*/ >> bDuplicate +/*N*/ >> bByRow; +/*N*/ +/*N*/ Resize( MAXQUERY ); +/*N*/ +/*N*/ for (USHORT i=0; i<MAXQUERY; i++) +/*N*/ pEntries[i].Load(rStream); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScQueryParam::Store( SvStream& rStream ) const // z.B. fuer Pivot-Tabelle +/*N*/ { +/*N*/ // bDestPers wird nicht geladen/gespeichert +/*N*/ +/*N*/ ScWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ DBG_ASSERT( nEntryCount <= MAXQUERY || !pEntries[MAXQUERY].bDoQuery, +/*N*/ "zuviele Eintraege bei ScQueryParam::Store" ); +/*N*/ +/*N*/ +/*N*/ if ( nEntryCount < MAXQUERY ) +/*N*/ { +/*N*/ DBG_ERROR("ScQueryParam::Store - zuwenig Eintraege"); +/*N*/ ((ScQueryParam*)this)->Resize( MAXQUERY ); +/*N*/ } +/*N*/ +/*N*/ rStream << nCol1 +/*N*/ << nRow1 +/*N*/ << nCol2 +/*N*/ << nRow2 +/*N*/ << nDestTab +/*N*/ << nDestCol +/*N*/ << nDestRow +/*N*/ << bHasHeader +/*N*/ << bInplace +/*N*/ << bCaseSens +/*N*/ << bRegExp +/*N*/ << bDuplicate +/*N*/ << bByRow; +/*N*/ +/*N*/ for (USHORT i=0; i<MAXQUERY; i++) +/*N*/ pEntries[i].Store(rStream); +/*N*/ } + +//------------------------------------------------------------------------ +// struct ScSubTotalParam: + +/*N*/ ScSubTotalParam::ScSubTotalParam() +/*N*/ { +/*N*/ for ( USHORT i=0; i<MAXSUBTOTAL; i++ ) +/*N*/ { +/*N*/ nSubTotals[i] = 0; +/*N*/ pSubTotals[i] = NULL; +/*N*/ pFunctions[i] = NULL; +/*N*/ } +/*N*/ +/*N*/ Clear(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScSubTotalParam::ScSubTotalParam( const ScSubTotalParam& r ) : +/*N*/ nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2), +/*N*/ bReplace(r.bReplace),bPagebreak(r.bPagebreak),bCaseSens(r.bCaseSens), +/*N*/ bDoSort(r.bDoSort),bAscending(r.bAscending),bUserDef(r.bUserDef),nUserIndex(r.nUserIndex), +/*N*/ bIncludePattern(r.bIncludePattern),bRemoveOnly(r.bRemoveOnly) +/*N*/ { +/*N*/ for (USHORT i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ bGroupActive[i] = r.bGroupActive[i]; +/*N*/ nField[i] = r.nField[i]; +/*N*/ +/*N*/ if ( (r.nSubTotals[i] > 0) && r.pSubTotals[i] && r.pFunctions[i] ) +/*N*/ { +/*N*/ nSubTotals[i] = r.nSubTotals[i]; +/*N*/ pSubTotals[i] = new USHORT [r.nSubTotals[i]]; +/*N*/ pFunctions[i] = new ScSubTotalFunc [r.nSubTotals[i]]; +/*N*/ +/*N*/ for (USHORT j=0; j<r.nSubTotals[i]; j++) +/*N*/ { +/*N*/ pSubTotals[i][j] = r.pSubTotals[i][j]; +/*N*/ pFunctions[i][j] = r.pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nSubTotals[i] = 0; +/*N*/ pSubTotals[i] = NULL; +/*N*/ pFunctions[i] = NULL; +/*N*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScSubTotalParam::Clear() +/*N*/ { +/*N*/ nCol1=nRow1=nCol2=nRow2=nUserIndex = 0; +/*N*/ bPagebreak=bCaseSens=bUserDef=bIncludePattern=bRemoveOnly = FALSE; +/*N*/ bAscending=bReplace=bDoSort = TRUE; +/*N*/ +/*N*/ USHORT i=0; +/*N*/ for ( i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ bGroupActive[i] = FALSE; +/*N*/ nField[i] = 0; +/*N*/ +/*N*/ if ( (nSubTotals[i] > 0) && pSubTotals[i] && pFunctions[i] ) +/*N*/ { +/*?*/ USHORT j=0; +/*?*/ for ( j=0; j<nSubTotals[i]; j++ ) +/*?*/ pSubTotals[i][j] = 0; +/*?*/ pFunctions[i][j] = SUBTOTAL_FUNC_NONE; +/*N*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScSubTotalParam& ScSubTotalParam::operator=( const ScSubTotalParam& r ) +/*N*/ { +/*N*/ nCol1 = r.nCol1; +/*N*/ nRow1 = r.nRow1; +/*N*/ nCol2 = r.nCol2; +/*N*/ nRow2 = r.nRow2; +/*N*/ bRemoveOnly = r.bRemoveOnly; +/*N*/ bReplace = r.bReplace; +/*N*/ bPagebreak = r.bPagebreak; +/*N*/ bCaseSens = r.bCaseSens; +/*N*/ bDoSort = r.bDoSort; +/*N*/ bAscending = r.bAscending; +/*N*/ bUserDef = r.bUserDef; +/*N*/ nUserIndex = r.nUserIndex; +/*N*/ bIncludePattern = r.bIncludePattern; +/*N*/ +/*N*/ for (USHORT i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ bGroupActive[i] = r.bGroupActive[i]; +/*N*/ nField[i] = r.nField[i]; +/*N*/ nSubTotals[i] = r.nSubTotals[i]; +/*N*/ +/*N*/ if ( pSubTotals[i] ) delete [] pSubTotals[i]; +/*N*/ if ( pFunctions[i] ) delete [] pFunctions[i]; +/*N*/ +/*N*/ if ( r.nSubTotals[i] > 0 ) +/*N*/ { +/*N*/ pSubTotals[i] = new USHORT [r.nSubTotals[i]]; +/*N*/ pFunctions[i] = new ScSubTotalFunc [r.nSubTotals[i]]; +/*N*/ +/*N*/ for (USHORT j=0; j<r.nSubTotals[i]; j++) +/*N*/ { +/*N*/ pSubTotals[i][j] = r.pSubTotals[i][j]; +/*N*/ pFunctions[i][j] = r.pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nSubTotals[i] = 0; +/*N*/ pSubTotals[i] = NULL; +/*N*/ pFunctions[i] = NULL; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ +// struct ScConsolidateParam: + +/*N*/ ScConsolidateParam::ScConsolidateParam() : +/*N*/ ppDataAreas( NULL ) +/*N*/ { +/*N*/ Clear(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScConsolidateParam::ScConsolidateParam( const ScConsolidateParam& r ) : +/*N*/ ppDataAreas( NULL ), +/*N*/ nCol(r.nCol),nRow(r.nRow),nTab(r.nTab), +/*N*/ bByCol(r.bByCol),bByRow(r.bByRow),bReferenceData(r.bReferenceData), +/*N*/ nDataAreaCount(0),eFunction(r.eFunction) +/*N*/ { +/*N*/ if ( r.nDataAreaCount > 0 ) +/*N*/ { +/*N*/ nDataAreaCount = r.nDataAreaCount; +/*N*/ ppDataAreas = new ScArea*[nDataAreaCount]; +/*N*/ for ( USHORT i=0; i<nDataAreaCount; i++ ) +/*N*/ ppDataAreas[i] = new ScArea( *(r.ppDataAreas[i]) ); +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScConsolidateParam::~ScConsolidateParam() +/*N*/ { +/*N*/ ClearDataAreas(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScConsolidateParam::ClearDataAreas() +/*N*/ { +/*N*/ if ( ppDataAreas ) +/*N*/ { +/*?*/ for ( USHORT i=0; i<nDataAreaCount; i++ ) +/*?*/ delete ppDataAreas[i]; +/*?*/ delete [] ppDataAreas; +/*?*/ ppDataAreas = NULL; +/*N*/ } +/*N*/ nDataAreaCount = 0; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScConsolidateParam::Clear() +/*N*/ { +/*N*/ ClearDataAreas(); +/*N*/ +/*N*/ nCol = nRow = nTab = 0; +/*N*/ bByCol = bByRow = bReferenceData = FALSE; +/*N*/ eFunction = SUBTOTAL_FUNC_SUM; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScConsolidateParam& __EXPORT ScConsolidateParam::operator=( const ScConsolidateParam& r ) +/*N*/ { +/*N*/ nCol = r.nCol; +/*N*/ nRow = r.nRow; +/*N*/ nTab = r.nTab; +/*N*/ bByCol = r.bByCol; +/*N*/ bByRow = r.bByRow; +/*N*/ bReferenceData = r.bReferenceData; +/*N*/ eFunction = r.eFunction; +/*N*/ SetAreas( r.ppDataAreas, r.nDataAreaCount ); +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScConsolidateParam::SetAreas( ScArea* const* ppAreas, USHORT nCount ) +/*N*/ { +/*N*/ ClearDataAreas(); +/*N*/ if ( ppAreas && nCount > 0 ) +/*N*/ { +/*N*/ ppDataAreas = new ScArea*[nCount]; +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ ppDataAreas[i] = new ScArea( *(ppAreas[i]) ); +/*N*/ nDataAreaCount = nCount; +/*N*/ } +/*N*/ } + +/*N*/ void ScConsolidateParam::Load( SvStream& rStream ) +/*N*/ { +/*N#116571#*/ ClearDataAreas(); +/*N#116571#*/ +/*N#116571#*/ ScReadHeader aHdr( rStream ); +/*N#116571#*/ +/*N#116571#*/ BYTE nByte; +/*N#116571#*/ rStream >> nCol >> nRow >> nTab +/*N#116571#*/ >> bByCol >> bByRow >> bReferenceData >> nByte; +/*N#116571#*/ eFunction = (ScSubTotalFunc) nByte; +/*N#116571#*/ +/*N#116571#*/ rStream >> nDataAreaCount; +/*N#116571#*/ if ( nDataAreaCount ) +/*N#116571#*/ { +/*N#116571#*/ ppDataAreas = new ScArea*[nDataAreaCount]; +/*N#116571#*/ for ( USHORT i=0; i<nDataAreaCount; i++ ) +/*N#116571#*/ { +/*N#116571#*/ ppDataAreas[i] = new ScArea(); +/*N#116571#*/ rStream >> *ppDataAreas[i]; +/*N#116571#*/ } +/*N#116571#*/ } +/*N*/ } + +/*N*/ void ScConsolidateParam::Store( SvStream& rStream ) const +/*N*/ { +/*N#116571#*/ ScWriteHeader aHdr( rStream, 12+10*nDataAreaCount ); +/*N#116571#*/ +/*N#116571#*/ rStream << nCol << nRow << nTab +/*N#116571#*/ << bByCol << bByRow << bReferenceData << (BYTE) eFunction; +/*N#116571#*/ +/*N#116571#*/ rStream << nDataAreaCount; +/*N#116571#*/ for (USHORT i=0; i<nDataAreaCount; i++) +/*N#116571#*/ rStream << *ppDataAreas[i]; +/*N*/ } + +//------------------------------------------------------------------------ +// struct ScPivotParam: + +/*N*/ ScPivotParam::ScPivotParam() +/*N*/ : nCol(0), nRow(0), nTab(0), +/*N*/ ppLabelArr( NULL ), nLabels(0), +/*N*/ nColCount(0), nRowCount(0), nDataCount(0), +/*N*/ bIgnoreEmptyRows(FALSE), bDetectCategories(FALSE), +/*N*/ bMakeTotalCol(TRUE), bMakeTotalRow(TRUE) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScPivotParam::ScPivotParam( const ScPivotParam& r ) +/*N*/ : nCol( r.nCol ), nRow( r.nRow ), nTab( r.nTab ), +/*N*/ bIgnoreEmptyRows(r.bIgnoreEmptyRows), +/*N*/ bDetectCategories(r.bDetectCategories), +/*N*/ bMakeTotalCol(r.bMakeTotalCol), +/*N*/ bMakeTotalRow(r.bMakeTotalRow), +/*N*/ ppLabelArr( NULL ), nLabels(0), +/*N*/ nColCount(0), nRowCount(0), nDataCount(0) +/*N*/ { +/*N*/ SetLabelData ( r.ppLabelArr, r.nLabels ); +/*N*/ SetPivotArrays ( r.aColArr, r.aRowArr, r.aDataArr, +/*N*/ r.nColCount, r.nRowCount, r.nDataCount ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScPivotParam::~ScPivotParam() +/*N*/ { +/*N*/ ClearLabelData(); +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPivotParam::ClearLabelData() +/*N*/ { +/*N*/ if ( (nLabels > 0) && ppLabelArr ) +/*N*/ { +/*N*/ for ( USHORT i=0; i<nLabels; i++ ) +/*N*/ delete ppLabelArr[i]; +/*N*/ delete [] ppLabelArr; +/*N*/ ppLabelArr = NULL; +/*N*/ nLabels = 0; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPivotParam::SetLabelData( LabelData** pLabArr, +/*N*/ USHORT nLab ) +/*N*/ { +/*N*/ ClearLabelData(); +/*N*/ +/*N*/ if ( (nLab > 0) && pLabArr ) +/*N*/ { +/*N*/ nLabels = (nLab>MAX_LABELS) ? MAX_LABELS : nLab; +/*N*/ ppLabelArr = new LabelData*[nLabels]; +/*N*/ for ( USHORT i=0; i<nLabels; i++ ) +/*N*/ ppLabelArr[i] = new LabelData( *(pLabArr[i]) ); +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPivotParam::SetPivotArrays ( const PivotField* pColArr, +/*N*/ const PivotField* pRowArr, +/*N*/ const PivotField* pDataArr, +/*N*/ USHORT nColCnt, +/*N*/ USHORT nRowCnt, +/*N*/ USHORT nDataCnt ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ClearPivotArrays(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScPivotParam& __EXPORT ScPivotParam::operator=( const ScPivotParam& r ) +/*N*/ { +/*N*/ nCol = r.nCol; +/*N*/ nRow = r.nRow; +/*N*/ nTab = r.nTab; +/*N*/ bIgnoreEmptyRows = r.bIgnoreEmptyRows; +/*N*/ bDetectCategories = r.bDetectCategories; +/*N*/ bMakeTotalCol = r.bMakeTotalCol; +/*N*/ bMakeTotalRow = r.bMakeTotalRow; +/*N*/ +/*N*/ SetLabelData ( r.ppLabelArr, r.nLabels ); +/*N*/ SetPivotArrays ( r.aColArr, r.aRowArr, r.aDataArr, +/*N*/ r.nColCount, r.nRowCount, r.nDataCount ); +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ +// struct ScSolveParam + +/*N*/ ScSolveParam::ScSolveParam() +/*N*/ : pStrTargetVal( NULL ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScSolveParam::ScSolveParam( const ScSolveParam& r ) +/*N*/ : aRefFormulaCell ( r.aRefFormulaCell ), +/*N*/ aRefVariableCell( r.aRefVariableCell ), +/*N*/ pStrTargetVal ( r.pStrTargetVal +/*N*/ ? new String(*r.pStrTargetVal) +/*N*/ : NULL ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScSolveParam::~ScSolveParam() +/*N*/ { +/*N*/ delete pStrTargetVal; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + + +//------------------------------------------------------------------------ +// struct ScTabOpParam + +/*N*/ ScTabOpParam::ScTabOpParam( const ScTabOpParam& r ) +/*N*/ : aRefFormulaCell ( r.aRefFormulaCell ), +/*N*/ aRefFormulaEnd ( r.aRefFormulaEnd ), +/*N*/ aRefRowCell ( r.aRefRowCell ), +/*N*/ aRefColCell ( r.aRefColCell ), +/*N*/ nMode ( r.nMode ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +//======================================================================== +// class ScPostIt +//======================================================================== + +/*N*/ ScPostIt::ScPostIt() +/*N*/ { +/*N*/ bShown = FALSE; +/*N*/ } + +/*N*/ ScPostIt::ScPostIt( const String& rText, const String& rDate, const String& rAuthor ) +/*N*/ : aStrText ( rText ), +/*N*/ aStrDate ( rDate ), +/*N*/ aStrAuthor ( rAuthor ) +/*N*/ { +/*N*/ bShown = FALSE; +/*N*/ } + +/*N*/ ScPostIt::ScPostIt( const ScPostIt& rCpy ) +/*N*/ : aStrText ( rCpy.aStrText ), +/*N*/ aStrDate ( rCpy.aStrDate ), +/*N*/ aStrAuthor ( rCpy.aStrAuthor ) +/*N*/ { +/*N*/ bShown = rCpy.bShown; +/*N*/ } + +/*N*/ __EXPORT ScPostIt::~ScPostIt() +/*N*/ { +/*N*/ } + +/*N*/ void ScPostIt::AutoSetText( const String& rNewText ) +/*N*/ { +/*N*/ aStrText = rNewText; +/*N*/ aStrDate = ScGlobal::pLocaleData->getDate( Date() ); +/*N*/ +/*N*/ // Der Einheitlichkeit halber das Datum immer ohne Uhrzeit (wie im Writer) +/*N*/ // aStrDate += ", "; +/*N*/ // aStrDate += ScGlobal::pLocaleData->getTime( Time() ); +/*N*/ +/*N*/ SvtUserOptions aUserOpt; +/*N*/ aStrAuthor = aUserOpt.GetID(); +/*N*/ } + +//======================================================================== + +/*N*/ String ScGlobal::GetAbsDocName( const String& rFileName, +/*N*/ SfxObjectShell* pShell ) +/*N*/ { +/*N*/ String aAbsName; +/*N*/ if ( !pShell->HasName() ) +/*N*/ { // maybe relative to document path working directory +/*N*/ INetURLObject aObj; +/*N*/ SvtPathOptions aPathOpt; +/*N*/ aObj.SetSmartURL( aPathOpt.GetWorkPath() ); +/*N*/ aObj.setFinalSlash(); // it IS a path +/*N*/ bool bWasAbs = true; +/*N*/ aAbsName = aObj.smartRel2Abs( rFileName, bWasAbs ).GetMainURL(INetURLObject::NO_DECODE); +/*N*/ // returned string must be encoded because it's used directly to create SfxMedium +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ const SfxMedium* pMedium = pShell->GetMedium(); +/*N*/ if ( pMedium ) +/*N*/ { +/*N*/ bool bWasAbs = true; +/*N*/ aAbsName = pMedium->GetURLObject().smartRel2Abs( rFileName, bWasAbs ).GetMainURL(INetURLObject::NO_DECODE); +/*N*/ } +/*N*/ else +/*N*/ { // This can't happen, but ... +/*?*/ // just to be sure to have the same encoding +/*?*/ INetURLObject aObj; +/*?*/ aObj.SetSmartURL( aAbsName ); +/*?*/ aAbsName = aObj.GetMainURL(INetURLObject::NO_DECODE); +/*N*/ } +/*N*/ } +/*N*/ return aAbsName; +/*N*/ } + + +/*N*/ String ScGlobal::GetDocTabName( const String& rFileName, +/*N*/ const String& rTabName ) +/*N*/ { +/*N*/ String aDocTab( '\'' ); +/*N*/ aDocTab += rFileName; +/*N*/ xub_StrLen nPos = 1; +/*N*/ while( (nPos = aDocTab.Search( '\'', nPos )) +/*N*/ != STRING_NOTFOUND ) +/*N*/ { // escape Quotes +/*N*/ aDocTab.Insert( '\\', nPos ); +/*N*/ nPos += 2; +/*N*/ } +/*N*/ aDocTab += '\''; +/*N*/ aDocTab += SC_COMPILER_FILE_TAB_SEP; +/*N*/ aDocTab += rTabName; // "'Doc'#Tab" +/*N*/ return aDocTab; +/*N*/ } + + +/*N*/ USHORT lcl_ConvertSingleRef( BOOL& bExternal, const sal_Unicode* p, +/*N*/ ScDocument* pDoc, ScAddress& rAddr ) +/*N*/ { +/*N*/ if ( !*p ) +/*N*/ return 0; +/*N*/ USHORT nRes = 0; +/*N*/ String aDocName; // der pure Dokumentenname +/*N*/ String aDocTab; // zusammengesetzt fuer Table +/*N*/ String aTab; +/*N*/ BOOL bExtDoc = FALSE; +/*N*/ BOOL bNeedExtTab = FALSE; +/*N*/ +/*N*/ if ( *p == '\'' && ScGlobal::UnicodeStrChr( p, SC_COMPILER_FILE_TAB_SEP ) ) +/*N*/ { +/*?*/ BOOL bQuote = TRUE; // Dokumentenname ist immer quoted +/*?*/ aDocTab += *p++; +/*?*/ while ( bQuote && *p ) +/*?*/ { +/*?*/ if ( *p == '\'' && *(p-1) != '\\' ) +/*?*/ bQuote = FALSE; +/*?*/ else if( !(*p == '\\' && *(p+1) == '\'') ) +/*?*/ aDocName += *p; // falls escaped Quote: nur Quote in den Namen +/*?*/ aDocTab += *p++; +/*?*/ } +/*?*/ aDocTab += *p; // den SC_COMPILER_FILE_TAB_SEP mitnehmen +/*?*/ if( *p++ == SC_COMPILER_FILE_TAB_SEP ) +/*?*/ bExtDoc = TRUE; +/*?*/ else +/*?*/ return nRes; +/*N*/ } +/*N*/ +/*N*/ USHORT nCol = 0; +/*N*/ USHORT nRow = 0; +/*N*/ USHORT nTab = 0; +/*N*/ USHORT nBits = SCA_VALID_TAB; +/*N*/ const sal_Unicode* q; +/*N*/ if ( ScGlobal::UnicodeStrChr( p, '.') ) +/*N*/ { +/*N*/ nRes |= SCA_TAB_3D; +/*N*/ if ( bExtDoc ) +/*N*/ nRes |= SCA_TAB_ABSOLUTE; +/*N*/ if (*p == '$') +/*N*/ nRes |= SCA_TAB_ABSOLUTE, p++; +/*N*/ BOOL bQuote = FALSE; +/*N*/ if( *p == '\'' ) +/*N*/ p++, bQuote = TRUE; +/*N*/ while (*p && (*p != '.')) +/*N*/ { +/*N*/ if( bQuote && *p == '\'' ) +/*N*/ { +/*N*/ p++; break; +/*N*/ } +/*N*/ aTab += *p++; +/*N*/ } +/*N*/ if( *p++ != '.' ) +/*N*/ nBits = 0; +/*N*/ if ( pDoc ) +/*N*/ { +/*N*/ if ( bExtDoc ) +/*N*/ { +/*N*/ bExternal = TRUE; +/*N*/ aDocTab += aTab; // "'Doc'#Tab" +/*N*/ if ( !pDoc->GetTable( aDocTab, nTab ) ) +/*N*/ { +/*N*/ if ( pDoc->ValidTabName( aTab ) ) +/*N*/ { +/*N*/ aDocName = ScGlobal::GetAbsDocName( aDocName, +/*N*/ pDoc->GetDocumentShell() ); +/*N*/ aDocTab = ScGlobal::GetDocTabName( aDocName, aTab ); +/*N*/ if ( !pDoc->GetTable( aDocTab, nTab ) ) +/*N*/ { +/*N*/ // erst einfuegen, wenn Rest der Ref ok +/*N*/ bNeedExtTab = TRUE; +/*N*/ nBits = 0; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nBits = 0; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( !pDoc->GetTable( aTab, nTab ) ) +/*N*/ nBits = 0; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nBits = 0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( bExtDoc ) +/*N*/ return nRes; // nach Dokument muss Tabelle folgen +/*N*/ nTab = rAddr.Tab(); +/*N*/ } +/*N*/ nRes |= nBits; +/*N*/ +/*N*/ q = p; +/*N*/ if (*p) +/*N*/ { +/*N*/ nBits = SCA_VALID_COL; +/*N*/ if (*p == '$') +/*N*/ nBits |= SCA_COL_ABSOLUTE, p++; +/*N*/ if( CharClass::isAsciiAlpha( *p ) ) +/*N*/ nCol = toupper( char(*p++) ) - 'A'; +/*N*/ else +/*N*/ nBits = 0; +/*N*/ if( CharClass::isAsciiAlpha( *p ) ) +/*N*/ nCol = ((nCol + 1) * 26) + (toupper( char(*p++) ) - 'A'); +/*N*/ if( nCol > MAXCOL ) +/*N*/ nBits = 0; +/*N*/ while( CharClass::isAsciiAlpha( *p ) ) +/*N*/ p++, nBits = 0; +/*N*/ nRes |= nBits; +/*N*/ if( !nBits ) +/*N*/ p = q; +/*N*/ } +/*N*/ +/*N*/ q = p; +/*N*/ if (*p) +/*N*/ { +/*N*/ nBits = SCA_VALID_ROW; +/*N*/ if (*p == '$') +/*N*/ nBits |= SCA_ROW_ABSOLUTE, p++; +/*N*/ if( !CharClass::isAsciiDigit( *p ) ) +/*N*/ { +/*N*/ nBits = 0; +/*N*/ nRow = USHORT(-1); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ String aTmp( p ); +/*N*/ long n = aTmp.ToInt32() - 1; +/*N*/ while (CharClass::isAsciiDigit( *p )) +/*N*/ p++; +/*N*/ if( n < 0 || n > MAXROW ) +/*N*/ nBits = 0; +/*N*/ nRow = (USHORT) n; +/*N*/ } +/*N*/ nRes |= nBits; +/*N*/ if( !nBits ) +/*N*/ p = q; +/*N*/ } +/*N*/ if ( bNeedExtTab ) +/*N*/ { +/*N*/ if ( (nRes & SCA_VALID_ROW) && (nRes & SCA_VALID_COL) +/*N*/ && pDoc->LinkExternalTab( nTab, aDocTab, aDocName, aTab ) ) +/*N*/ { +/*N*/ nRes |= SCA_VALID_TAB; +/*N*/ } +/*N*/ else +/*N*/ nRes = 0; // #NAME? statt #REF!, Dateiname bleibt erhalten +/*N*/ } +/*N*/ if ( !(nRes & SCA_VALID_ROW) && (nRes & SCA_VALID_COL) +/*N*/ && !( (nRes & SCA_TAB_3D) && (nRes & SCA_VALID_TAB)) ) +/*N*/ { // keine Row, keine Tab, aber Col => DM (...), B (...) o.ae. +/*N*/ nRes = 0; +/*N*/ } +/*N*/ if( !*p ) +/*N*/ { +/*N*/ USHORT nMask = nRes & ( SCA_VALID_ROW | SCA_VALID_COL | SCA_VALID_TAB ); +/*N*/ if( nMask == ( SCA_VALID_ROW | SCA_VALID_COL | SCA_VALID_TAB ) ) +/*N*/ nRes |= SCA_VALID; +/*N*/ } +/*N*/ else +/*N*/ nRes = 0; +/*N*/ rAddr.Set( nCol, nRow, nTab ); +/*N*/ return nRes; +/*N*/ } + + +// ConvertSingleRef mit sal_Unicode* muss vorher stehen!!! + +/*N*/ BOOL ConvertSingleRef( ScDocument* pDoc, const String& rRefString, +/*N*/ USHORT nDefTab, ScRefTripel& rRefTripel ) +/*N*/ { +/*N*/ BOOL bExternal = FALSE; +/*N*/ ScAddress aAddr( 0, 0, nDefTab ); +/*N*/ USHORT nRes = lcl_ConvertSingleRef( bExternal, rRefString.GetBuffer(), pDoc, aAddr ); +/*N*/ if( nRes & SCA_VALID ) +/*N*/ { +/*N*/ rRefTripel.Put( aAddr.Col(), aAddr.Row(), aAddr.Tab(), +/*N*/ BOOL( ( nRes & SCA_COL_ABSOLUTE ) == 0 ), +/*N*/ BOOL( ( nRes & SCA_ROW_ABSOLUTE ) == 0 ), +/*N*/ BOOL( ( nRes & SCA_TAB_ABSOLUTE ) == 0 ) ); +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ConvertDoubleRef( ScDocument* pDoc, const String& rRefString, USHORT nDefTab, +/*N*/ ScRefTripel& rStartRefTripel, ScRefTripel& rEndRefTripel ) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ xub_StrLen nPos = rRefString.Search(':'); +/*N*/ if (nPos != STRING_NOTFOUND) +/*N*/ { +/*N*/ String aTmp( rRefString ); +/*N*/ sal_Unicode* p = aTmp.GetBufferAccess(); +/*N*/ p[ nPos ] = 0; +/*N*/ if ( ConvertSingleRef( pDoc, p, nDefTab, rStartRefTripel ) ) +/*N*/ { +/*N*/ nDefTab = rStartRefTripel.GetTab(); +/*N*/ bRet = ConvertSingleRef( pDoc, p + nPos + 1, nDefTab, rEndRefTripel ); +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + + +/*N*/ USHORT ScAddress::Parse( const String& r, ScDocument* pDoc ) +/*N*/ { +/*N*/ BOOL bExternal = FALSE; +/*N*/ return lcl_ConvertSingleRef( bExternal, r.GetBuffer(), pDoc, *this ); +/*N*/ } + +/*N*/ BOOL ScRange::Intersects( const ScRange& r ) const +/*N*/ { +/*N*/ return !( +/*N*/ Min( aEnd.Col(), r.aEnd.Col() ) < Max( aStart.Col(), r.aStart.Col() ) +/*N*/ || Min( aEnd.Row(), r.aEnd.Row() ) < Max( aStart.Row(), r.aStart.Row() ) +/*N*/ || Min( aEnd.Tab(), r.aEnd.Tab() ) < Max( aStart.Tab(), r.aStart.Tab() ) +/*N*/ ); +/*N*/ } + +/*N*/ void ScRange::Justify() +/*N*/ { +/*N*/ USHORT nTemp; +/*N*/ if ( aEnd.Col() < (nTemp = aStart.Col()) ) +/*N*/ { +/*?*/ aStart.SetCol(aEnd.Col()); aEnd.SetCol(nTemp); +/*N*/ } +/*N*/ if ( aEnd.Row() < (nTemp = aStart.Row()) ) +/*N*/ { +/*?*/ aStart.SetRow(aEnd.Row()); aEnd.SetRow(nTemp); +/*N*/ } +/*N*/ if ( aEnd.Tab() < (nTemp = aStart.Tab()) ) +/*N*/ { +/*?*/ aStart.SetTab(aEnd.Tab()); aEnd.SetTab(nTemp); +/*N*/ } +/*N*/ } + + +/*N*/ USHORT ScRange::Parse( const String& r, ScDocument* pDoc ) +/*N*/ { +/*N*/ USHORT nRes1 = 0, nRes2 = 0; +/*N*/ xub_StrLen nTmp = 0; +/*N*/ xub_StrLen nPos = STRING_NOTFOUND; +/*N*/ while ( (nTmp = r.Search( ':', nTmp )) != STRING_NOTFOUND ) +/*N*/ nPos = nTmp++; // der letzte zaehlt, koennte 'd:\...'!a1:a2 sein +/*N*/ if (nPos != STRING_NOTFOUND) +/*N*/ { +/*N*/ String aTmp( r ); +/*N*/ sal_Unicode* p = aTmp.GetBufferAccess(); +/*N*/ p[ nPos ] = 0; +/*N*/ BOOL bExternal = FALSE; +/*N*/ if( nRes1 = lcl_ConvertSingleRef( bExternal, p, pDoc, aStart ) ) +/*N*/ { +/*N*/ aEnd = aStart; // die Tab _muss_ gleich sein, so ist`s weniger Code +/*N*/ if ( nRes2 = lcl_ConvertSingleRef( bExternal, p + nPos+ 1, pDoc, aEnd ) ) +/*N*/ { +/*N*/ if ( bExternal && aStart.Tab() != aEnd.Tab() ) +/*N*/ nRes2 &= ~SCA_VALID_TAB; // #REF! +/*N*/ else +/*N*/ { +/*N*/ // PutInOrder / Justify +/*N*/ USHORT nTemp, nMask, nBits1, nBits2; +/*N*/ if ( aEnd.Col() < (nTemp = aStart.Col()) ) +/*N*/ { +/*?*/ aStart.SetCol(aEnd.Col()); aEnd.SetCol(nTemp); +/*?*/ nMask = (SCA_VALID_COL | SCA_COL_ABSOLUTE); +/*?*/ nBits1 = nRes1 & nMask; +/*?*/ nBits2 = nRes2 & nMask; +/*?*/ nRes1 = (nRes1 & ~nMask) | nBits2; +/*?*/ nRes2 = (nRes2 & ~nMask) | nBits1; +/*N*/ } +/*N*/ if ( aEnd.Row() < (nTemp = aStart.Row()) ) +/*N*/ { +/*?*/ aStart.SetRow(aEnd.Row()); aEnd.SetRow(nTemp); +/*?*/ nMask = (SCA_VALID_ROW | SCA_ROW_ABSOLUTE); +/*?*/ nBits1 = nRes1 & nMask; +/*?*/ nBits2 = nRes2 & nMask; +/*?*/ nRes1 = (nRes1 & ~nMask) | nBits2; +/*?*/ nRes2 = (nRes2 & ~nMask) | nBits1; +/*N*/ } +/*N*/ if ( aEnd.Tab() < (nTemp = aStart.Tab()) ) +/*N*/ { +/*?*/ aStart.SetTab(aEnd.Tab()); aEnd.SetTab(nTemp); +/*?*/ nMask = (SCA_VALID_TAB | SCA_TAB_ABSOLUTE | SCA_TAB_3D); +/*?*/ nBits1 = nRes1 & nMask; +/*?*/ nBits2 = nRes2 & nMask; +/*?*/ nRes1 = (nRes1 & ~nMask) | nBits2; +/*?*/ nRes2 = (nRes2 & ~nMask) | nBits1; +/*N*/ } +/*N*/ if ( ((nRes1 & ( SCA_TAB_ABSOLUTE | SCA_TAB_3D )) +/*N*/ == ( SCA_TAB_ABSOLUTE | SCA_TAB_3D )) +/*N*/ && !(nRes2 & SCA_TAB_3D) ) +/*N*/ nRes2 |= SCA_TAB_ABSOLUTE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nRes1 = 0; // #38840# keine Tokens aus halben Sachen +/*N*/ } +/*N*/ } +/*N*/ nRes1 = ( ( nRes1 | nRes2 ) & SCA_VALID ) +/*N*/ | nRes1 +/*N*/ | ( ( nRes2 & 0x070F ) << 4 ); +/*N*/ return nRes1; +/*N*/ } + +/*N*/ USHORT ScRange::ParseAny( const String& r, ScDocument* pDoc ) +/*N*/ { +/*N*/ USHORT nRet = Parse( r, pDoc ); +/*N*/ const USHORT nValid = SCA_VALID | SCA_VALID_COL2 | SCA_VALID_ROW2 | SCA_VALID_TAB2; +/*N*/ if ( (nRet & nValid) != nValid ) +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ nRet = aAdr.Parse( r, pDoc ); +/*N*/ if ( nRet & SCA_VALID ) +/*N*/ aStart = aEnd = aAdr; +/*N*/ } +/*N*/ return nRet; +/*N*/ } + +/*N*/ void ScAddress::Format( String& r, USHORT nFlags, ScDocument* pDoc ) const +/*N*/ { +/*N*/ USHORT nTab = Tab(); +/*N*/ USHORT nCol = Col(); +/*N*/ r.Erase(); +/*N*/ if( nFlags & SCA_VALID ) +/*N*/ nFlags |= ( SCA_VALID_ROW | SCA_VALID_COL | SCA_VALID_TAB ); +/*N*/ if( pDoc && (nFlags & SCA_VALID_TAB ) ) +/*N*/ { +/*N*/ if ( nTab >= pDoc->GetTableCount() ) +/*N*/ { +/*?*/ r = ScGlobal::GetRscString( STR_NOREF_STR ); +/*?*/ return; +/*N*/ } +/*N*/ // if( nFlags & ( SCA_TAB_ABSOLUTE | SCA_TAB_3D ) ) +/*N*/ if( nFlags & SCA_TAB_3D ) +/*N*/ { +/*N*/ String aTabName; +/*N*/ pDoc->GetName( nTab, aTabName ); +/*N*/ +/*N*/ // externe Referenzen (wie in ScCompiler::MakeTabStr) +/*N*/ String aDoc; +/*N*/ if ( aTabName.GetChar(0) == '\'' ) +/*N*/ { // "'Doc'#Tab" +/*?*/ xub_StrLen nPos, nLen = 1; +/*?*/ while( (nPos = aTabName.Search( '\'', nLen )) +/*?*/ != STRING_NOTFOUND ) +/*?*/ nLen = nPos + 1; +/*?*/ if ( aTabName.GetChar(nLen) == SC_COMPILER_FILE_TAB_SEP ) +/*?*/ { +/*?*/ aDoc = aTabName.Copy( 0, nLen + 1 ); +/*?*/ aTabName.Erase( 0, nLen + 1 ); +/*?*/ } +/*N*/ } +/*N*/ r += aDoc; +/*N*/ +/*N*/ if( nFlags & SCA_TAB_ABSOLUTE ) +/*N*/ r += '$'; +/*N*/ ScCompiler::CheckTabQuotes( aTabName ); +/*N*/ r += aTabName; +/*N*/ r += '.'; +/*N*/ } +/*N*/ } +/*N*/ if( nFlags & SCA_VALID_COL ) +/*N*/ { +/*N*/ if( nFlags & SCA_COL_ABSOLUTE ) +/*N*/ r += '$'; +/*N*/ if ( nCol < 26 ) +/*N*/ r += (sal_Unicode) ( 'A' + nCol ); +/*N*/ else +/*N*/ { +/*N*/ r += (sal_Unicode) ( 'A' + ( nCol / 26 ) - 1 ); +/*N*/ r += (sal_Unicode) ( 'A' + ( nCol % 26 ) ); +/*N*/ } +/*N*/ } +/*N*/ if( nFlags & SCA_VALID_ROW ) +/*N*/ { +/*N*/ if ( nFlags & SCA_ROW_ABSOLUTE ) +/*N*/ r += '$'; +/*N*/ r += String::CreateFromInt32( Row()+1 ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScRange::Format( String& r, USHORT nFlags, ScDocument* pDoc ) const +/*N*/ { +/*N*/ if( !( nFlags & SCA_VALID ) ) +/*N*/ r = ScGlobal::GetRscString( STR_NOREF_STR ); +/*N*/ else +/*N*/ { +/*N*/ BOOL bOneTab = (aStart.Tab() == aEnd.Tab()); +/*N*/ if ( !bOneTab ) +/*N*/ nFlags |= SCA_TAB_3D; +/*N*/ aStart.Format( r, nFlags, pDoc ); +/*N*/ if( aStart != aEnd ) +/*N*/ { +/*N*/ String aName; +/*N*/ nFlags = ( nFlags & SCA_VALID ) | ( ( nFlags >> 4 ) & 0x070F ); +/*N*/ if ( bOneTab ) +/*N*/ pDoc = NULL; +/*N*/ else +/*N*/ nFlags |= SCA_TAB_3D; +/*N*/ aEnd.Format( aName, nFlags, pDoc ); +/*N*/ r += ':'; +/*N*/ r += aName; +/*N*/ } +/*N*/ } +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_globalx.cxx b/binfilter/bf_sc/source/core/data/sc_globalx.cxx new file mode 100644 index 000000000000..ee3598e86e8f --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_globalx.cxx @@ -0,0 +1,138 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + + +#include "callform.hxx" +#include "global.hxx" + +#include <tools/urlobj.hxx> +#include <ucbhelper/contentbroker.hxx> +#include <ucbhelper/content.hxx> +#include <unotools/localfilehelper.hxx> + +#include <tools/debug.hxx> +#include <bf_svtools/pathoptions.hxx> + +#include <com/sun/star/sdbc/XResultSet.hpp> +#include <com/sun/star/sdbc/XRow.hpp> +#include <com/sun/star/ucb/XCommandEnvironment.hpp> +#include <com/sun/star/ucb/XContentAccess.hpp> + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ucb; +namespace binfilter { + + +// static +/*N*/ void ScGlobal::InitAddIns() +/*N*/ { +/*N*/ // multi paths separated by semicolons +/*N*/ SvtPathOptions aPathOpt; +/*N*/ String aMultiPath = aPathOpt.GetAddinPath(); +/*N*/ if ( aMultiPath.Len() > 0 ) +/*N*/ { +/*N*/ xub_StrLen nTokens = aMultiPath.GetTokenCount( ';' ); +/*N*/ xub_StrLen nIndex = 0; +/*N*/ for ( xub_StrLen j=0; j<nTokens; j++ ) +/*N*/ { +/*N*/ String aPath( aMultiPath.GetToken( 0, ';', nIndex ) ); +/*N*/ if ( aPath.Len() > 0 ) +/*N*/ { +/*N*/ // use LocalFileHelper to convert the path to a URL that always points +/*N*/ // to the file on the server +/*N*/ String aUrl; +/*N*/ if ( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aPath, aUrl ) ) +/*N*/ aPath = aUrl; +/*N*/ +/*N*/ INetURLObject aObj; +/*N*/ aObj.SetSmartURL( aPath ); +/*N*/ aObj.setFinalSlash(); +/*N*/ try +/*N*/ { +/*N*/ ::ucbhelper::Content aCnt( aObj.GetMainURL(INetURLObject::NO_DECODE), +/*N*/ Reference< XCommandEnvironment > () ); +/*N*/ Reference< sdbc::XResultSet > xResultSet; +/*N*/ Sequence< ::rtl::OUString > aProps; +/*N*/ try +/*N*/ { +/*N*/ xResultSet = aCnt.createCursor( +/*N*/ aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY ); +/*N*/ } +/*N*/ catch ( Exception& ) +/*N*/ { +/*N*/ // ucb may throw different exceptions on failure now +/*N*/ // no assertion if AddIn directory doesn't exist +/*N*/ } +/*N*/ +/*N*/ if ( xResultSet.is() ) +/*N*/ { +/*N*/ Reference< sdbc::XRow > xRow( xResultSet, UNO_QUERY ); +/*N*/ Reference< XContentAccess > +/*N*/ xContentAccess( xResultSet, UNO_QUERY ); +/*N*/ try +/*N*/ { +/*N*/ if ( xResultSet->first() ) +/*N*/ { +/*N*/ do +/*?*/ { +/*?*/ ::rtl::OUString aId( xContentAccess->queryContentIdentifierString() ); +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 InitExternalFunc( aId ); +/*?*/ } +/*?*/ while ( xResultSet->next() ); +/*?*/ } +/*N*/ } +/*N*/ catch ( Exception& ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "ResultSetException catched!" ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ catch ( Exception& ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "Exception catched!" ); +/*N*/ } +/*N*/ catch ( ... ) +/*N*/ { +/*N*/ +/*N*/ DBG_ERRORFILE( "unexpected exception caught!" ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_markarr.cxx b/binfilter/bf_sc/source/core/data/sc_markarr.cxx new file mode 100644 index 000000000000..5912868d8a8e --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_markarr.cxx @@ -0,0 +1,412 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> + +#include "markarr.hxx" +#include "global.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +//------------------------------------------------------------------------ + +/*N*/ ScMarkArray::ScMarkArray() +/*N*/ { +/*N*/ nCount = nLimit = 1; +/*N*/ pData = new ScMarkEntry[1]; +/*N*/ if (pData) +/*N*/ { +/*N*/ pData[0].nRow = MAXROW; +/*N*/ pData[0].bMarked = FALSE; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScMarkArray::~ScMarkArray() +/*N*/ { +/*N*/ if (pData) +/*N*/ delete[] pData; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScMarkArray::Reset( BOOL bMarked ) +/*N*/ { +/*N*/ if (pData) +/*N*/ { +/*N*/ delete[] pData; +/*N*/ +/*N*/ nCount = nLimit = 1; +/*N*/ pData = new ScMarkEntry[1]; +/*N*/ if (pData) +/*N*/ { +/*N*/ pData[0].nRow = MAXROW; +/*N*/ pData[0].bMarked = bMarked; +/*N*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScMarkArray::Search( USHORT nRow, short& nIndex ) const +/*N*/ { +/*N*/ short nLo = 0; +/*N*/ short nHi = ((short) nCount) - 1; +/*N*/ short nStartRow = 0; +/*N*/ short nEndRow = 0; +/*N*/ short i = 0; +/*N*/ BOOL bFound = (nCount == 1); +/*N*/ if (pData) +/*N*/ { +/*N*/ while ( !bFound && nLo <= nHi ) +/*N*/ { +/*N*/ i = (nLo + nHi) / 2; +/*N*/ if (i > 0) +/*N*/ nStartRow = (short) pData[i - 1].nRow; +/*N*/ else +/*N*/ nStartRow = -1; +/*N*/ nEndRow = (short) pData[i].nRow; +/*N*/ if (nEndRow < (short) nRow) +/*N*/ nLo = ++i; +/*N*/ else +/*N*/ if (nStartRow >= (short) nRow) +/*N*/ nHi = --i; +/*N*/ else +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bFound = FALSE; +/*N*/ +/*N*/ if (bFound) +/*N*/ nIndex=i; +/*N*/ else +/*N*/ nIndex=0; +/*N*/ return bFound; +/*N*/ } + +/*N*/ BOOL ScMarkArray::GetMark( USHORT nRow ) const +/*N*/ { +/*N*/ short i; +/*N*/ if (Search( nRow, i )) +/*N*/ return pData[i].bMarked; +/*N*/ else +/*N*/ return FALSE; +/*N*/ +/*N*/ } + +//------------------------------------------------------------------------ + + +/*N*/ void ScMarkArray::SetMarkArea( USHORT nStartRow, USHORT nEndRow, BOOL bMarked ) +/*N*/ { +/*N*/ if ((nStartRow >= 0 && nStartRow <= MAXROW) && (nEndRow >= 0 && nEndRow <= MAXROW)) +/*N*/ { +/*N*/ if ((nStartRow == 0) && (nEndRow == MAXROW)) +/*N*/ { +/*N*/ Reset(bMarked); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nNeeded = nCount + 2; +/*N*/ if ( nLimit < nNeeded ) +/*N*/ { +/*N*/ nLimit += SC_MARKARRAY_DELTA; +/*N*/ if ( nLimit < nNeeded ) +/*N*/ nLimit = nNeeded; +/*N*/ ScMarkEntry* pNewData = new ScMarkEntry[nLimit]; +/*N*/ memcpy( pNewData, pData, nCount*sizeof(ScMarkEntry) ); +/*N*/ delete[] pData; +/*N*/ pData = pNewData; +/*N*/ } +/*N*/ +/*N*/ USHORT ni; // number of entries in beginning +/*N*/ USHORT nInsert; // insert position (MAXROW+1 := no insert) +/*N*/ BOOL bCombined = FALSE; +/*N*/ BOOL bSplit = FALSE; +/*N*/ if ( nStartRow > 0 ) +/*N*/ { +/*N*/ // skip beginning +/*N*/ short nIndex; +/*N*/ Search( nStartRow, nIndex ); +/*N*/ ni = nIndex; +/*N*/ +/*N*/ nInsert = MAXROW+1; +/*N*/ if ( pData[ni].bMarked != bMarked ) +/*N*/ { +/*N*/ if ( ni == 0 || (pData[ni-1].nRow < nStartRow - 1) ) +/*N*/ { // may be a split or a simple insert or just a shrink, +/*N*/ // row adjustment is done further down +/*N*/ if ( pData[ni].nRow > nEndRow ) +/*N*/ bSplit = TRUE; +/*N*/ ni++; +/*N*/ nInsert = ni; +/*N*/ } +/*N*/ else if ( ni > 0 && pData[ni-1].nRow == nStartRow - 1 ) +/*N*/ nInsert = ni; +/*N*/ } +/*N*/ if ( ni > 0 && pData[ni-1].bMarked == bMarked ) +/*N*/ { // combine +/*N*/ pData[ni-1].nRow = nEndRow; +/*N*/ nInsert = MAXROW+1; +/*N*/ bCombined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nInsert = ni = 0; +/*N*/ +/*N*/ USHORT nj = ni; // stop position of range to replace +/*N*/ while ( nj < nCount && pData[nj].nRow <= nEndRow ) +/*N*/ nj++; +/*N*/ if ( !bSplit ) +/*N*/ { +/*N*/ if ( nj < nCount && pData[nj].bMarked == bMarked ) +/*N*/ { // combine +/*N*/ if ( ni > 0 ) +/*N*/ { +/*N*/ if ( pData[ni-1].bMarked == bMarked ) +/*N*/ { // adjacent entries +/*N*/ pData[ni-1].nRow = pData[nj].nRow; +/*N*/ nj++; +/*N*/ } +/*N*/ else if ( ni == nInsert ) +/*N*/ pData[ni-1].nRow = nStartRow - 1; // shrink +/*N*/ } +/*N*/ nInsert = MAXROW+1; +/*N*/ bCombined = TRUE; +/*N*/ } +/*N*/ else if ( ni > 0 && ni == nInsert ) +/*N*/ pData[ni-1].nRow = nStartRow - 1; // shrink +/*N*/ } +/*N*/ if ( ni < nj ) +/*N*/ { // remove middle entries +/*N*/ if ( !bCombined ) +/*N*/ { // replace one entry +/*N*/ pData[ni].nRow = nEndRow; +/*N*/ pData[ni].bMarked = bMarked; +/*N*/ ni++; +/*N*/ nInsert = MAXROW+1; +/*N*/ } +/*N*/ if ( ni < nj ) +/*N*/ { // remove entries +/*N*/ memmove( pData + ni, pData + nj, (nCount - nj) * sizeof(ScMarkEntry) ); +/*N*/ nCount -= nj - ni; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( nInsert <= MAXROW ) +/*N*/ { // insert or append new entry +/*N*/ if ( nInsert <= nCount ) +/*N*/ { +/*N*/ if ( !bSplit ) +/*N*/ memmove( pData + nInsert + 1, pData + nInsert, +/*N*/ (nCount - nInsert) * sizeof(ScMarkEntry) ); +/*N*/ else +/*N*/ { +/*N*/ memmove( pData + nInsert + 2, pData + nInsert, +/*N*/ (nCount - nInsert) * sizeof(ScMarkEntry) ); +/*N*/ pData[nInsert+1] = pData[nInsert-1]; +/*N*/ nCount++; +/*N*/ } +/*N*/ } +/*N*/ if ( nInsert ) +/*N*/ pData[nInsert-1].nRow = nStartRow - 1; +/*N*/ pData[nInsert].nRow = nEndRow; +/*N*/ pData[nInsert].bMarked = bMarked; +/*N*/ nCount++; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ // InfoBox(0, String(nCount) + String(" Eintraege") ).Execute(); +/*N*/ } + + +/*N*/ BOOL ScMarkArray::IsAllMarked( USHORT nStartRow, USHORT nEndRow ) const +/*N*/ { +/*N*/ short nStartIndex; +/*N*/ short nEndIndex; +/*N*/ +/*N*/ if (Search( nStartRow, nStartIndex )) +/*N*/ if (pData[nStartIndex].bMarked) +/*N*/ if (Search( nEndRow, nEndIndex )) +/*N*/ if (nEndIndex==nStartIndex) +/*N*/ return TRUE; +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScMarkArray::HasOneMark( USHORT& rStartRow, USHORT& rEndRow ) const +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ if ( nCount == 1 ) +/*N*/ { +/*N*/ if ( pData[0].bMarked ) +/*N*/ { +/*N*/ rStartRow = 0; +/*N*/ rEndRow = MAXROW; +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else if ( nCount == 2 ) +/*N*/ { +/*N*/ if ( pData[0].bMarked ) +/*N*/ { +/*N*/ rStartRow = 0; +/*N*/ rEndRow = pData[0].nRow; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rStartRow = pData[0].nRow + 1; +/*N*/ rEndRow = MAXROW; +/*N*/ } +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ else if ( nCount == 3 ) +/*N*/ { +/*N*/ if ( pData[1].bMarked ) +/*N*/ { +/*N*/ rStartRow = pData[0].nRow + 1; +/*N*/ rEndRow = pData[1].nRow; +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/*N*/ BOOL ScMarkArray::HasMarks() const +/*N*/ { +/*N*/ return ( nCount > 1 || pData[0].bMarked ); +/*N*/ } + + + +/*N*/ void ScMarkArray::CopyMarksTo( ScMarkArray& rDestMarkArray ) const +/*N*/ { +/*N*/ delete[] rDestMarkArray.pData; +/*N*/ +/*N*/ if (pData) +/*N*/ { +/*N*/ rDestMarkArray.pData = new ScMarkEntry[nCount]; +/*N*/ memmove( rDestMarkArray.pData, pData, nCount * sizeof(ScMarkEntry) ); +/*N*/ } +/*N*/ else +/*N*/ rDestMarkArray.pData = NULL; +/*N*/ +/*N*/ rDestMarkArray.nCount = rDestMarkArray.nLimit = nCount; +/*N*/ } + +/*N*/ short ScMarkArray::GetNextMarked( short nRow, BOOL bUp ) const +/*N*/ { +/*N*/ short nRet = nRow; +/*N*/ if (VALIDROW(nRow)) +/*N*/ { +/*N*/ short nIndex; +/*N*/ Search(nRow, nIndex); +/*N*/ if (!pData[nIndex].bMarked) +/*N*/ { +/*N*/ if (bUp) +/*N*/ { +/*N*/ if (nIndex>0) +/*N*/ nRet = pData[nIndex-1].nRow; +/*N*/ else +/*N*/ nRet = -1; +/*N*/ } +/*N*/ else +/*N*/ nRet = pData[nIndex].nRow + 1; +/*N*/ } +/*N*/ } +/*N*/ return nRet; +/*N*/ } + +/*N*/ USHORT ScMarkArray::GetMarkEnd( USHORT nRow, BOOL bUp ) const +/*N*/ { +/*N*/ USHORT nRet; +/*N*/ short nIndex; +/*N*/ Search(nRow, nIndex); +/*N*/ DBG_ASSERT( pData[nIndex].bMarked, "GetMarkEnd ohne bMarked" ); +/*N*/ if (bUp) +/*N*/ { +/*N*/ if (nIndex>0) +/*N*/ nRet = pData[nIndex-1].nRow + 1; +/*N*/ else +/*N*/ nRet = 0; +/*N*/ } +/*N*/ else +/*N*/ nRet = pData[nIndex].nRow; +/*N*/ +/*N*/ return nRet; +/*N*/ } + +// +// -------------- Iterator ---------------------------------------------- +// + +/*N*/ ScMarkArrayIter::ScMarkArrayIter( const ScMarkArray* pNewArray ) : +/*N*/ pArray( pNewArray ), +/*N*/ nPos( 0 ) +/*N*/ { +/*N*/ } + +/*N*/ ScMarkArrayIter::~ScMarkArrayIter() +/*N*/ { +/*N*/ } + +/*N*/ BOOL ScMarkArrayIter::Next( USHORT& rTop, USHORT& rBottom ) +/*N*/ { +/*N*/ if ( nPos >= pArray->nCount ) +/*N*/ return FALSE; +/*N*/ while (!pArray->pData[nPos].bMarked) +/*N*/ { +/*N*/ ++nPos; +/*N*/ if ( nPos >= pArray->nCount ) +/*N*/ return FALSE; +/*N*/ } +/*N*/ rBottom = pArray->pData[nPos].nRow; +/*N*/ if (nPos==0) +/*N*/ rTop = 0; +/*N*/ else +/*N*/ rTop = pArray->pData[nPos-1].nRow + 1; +/*N*/ ++nPos; +/*N*/ return TRUE; +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_markdata.cxx b/binfilter/bf_sc/source/core/data/sc_markdata.cxx new file mode 100644 index 000000000000..3792f8eb3ed2 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_markdata.cxx @@ -0,0 +1,369 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> + +#include "markdata.hxx" +#include "markarr.hxx" +#include "rangelst.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +//------------------------------------------------------------------------ + +/*N*/ ScMarkData::ScMarkData() : +/*N*/ pMultiSel( NULL ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ bTabMarked[i] = FALSE; +/*N*/ +/*N*/ ResetMark(); +/*N*/ } + +/*N*/ ScMarkData::ScMarkData(const ScMarkData& rData) : +/*N*/ pMultiSel( NULL ), +/*N*/ aMarkRange( rData.aMarkRange ), +/*N*/ aMultiRange( rData.aMultiRange ) +/*N*/ { +/*N*/ bMarked = rData.bMarked; +/*N*/ bMultiMarked = rData.bMultiMarked; +/*N*/ bMarking = rData.bMarking; +/*N*/ bMarkIsNeg = rData.bMarkIsNeg; +/*N*/ +/*N*/ USHORT i; +/*N*/ for (i=0; i<=MAXTAB; i++) +/*N*/ bTabMarked[i] = rData.bTabMarked[i]; +/*N*/ +/*N*/ if (rData.pMultiSel) +/*N*/ { +/*N*/ pMultiSel = new ScMarkArray[MAXCOL+1]; +/*N*/ for (i=0; i<=MAXCOL; i++) +/*N*/ rData.pMultiSel[i].CopyMarksTo( pMultiSel[i] ); +/*N*/ } +/*N*/ } + + +/*N*/ ScMarkData::~ScMarkData() +/*N*/ { +/*N*/ delete[] pMultiSel; +/*N*/ } + +/*N*/ void ScMarkData::ResetMark() +/*N*/ { +/*N*/ delete[] pMultiSel; +/*N*/ pMultiSel = NULL; +/*N*/ +/*N*/ bMarked = bMultiMarked = FALSE; +/*N*/ bMarking = bMarkIsNeg = FALSE; +/*N*/ } + +/*N*/ void ScMarkData::SetMarkArea( const ScRange& rRange ) +/*N*/ { +/*N*/ aMarkRange = rRange; +/*N*/ aMarkRange.Justify(); +/*N*/ if ( !bMarked ) +/*N*/ { +/*N*/ // #77987# Upon creation of a document ScFormatShell GetTextAttrState +/*N*/ // may query (default) attributes although no sheet is marked yet. +/*N*/ // => mark that one. +/*N*/ if ( !GetSelectCount() ) +/*N*/ bTabMarked[ aMarkRange.aStart.Tab() ] = TRUE; +/*N*/ bMarked = TRUE; +/*N*/ } +/*N*/ } + +/*N*/ void ScMarkData::GetMarkArea( ScRange& rRange ) const +/*N*/ { +/*N*/ rRange = aMarkRange; //! inline ? +/*N*/ } + +/*N*/ void ScMarkData::GetMultiMarkArea( ScRange& rRange ) const +/*N*/ { +/*N*/ rRange = aMultiRange; +/*N*/ } + +/*N*/ void ScMarkData::SetMultiMarkArea( const ScRange& rRange, BOOL bMark ) +/*N*/ { +/*N*/ if (!pMultiSel) +/*N*/ { +/*N*/ pMultiSel = new ScMarkArray[MAXCOL+1]; +/*N*/ +/*N*/ // if simple mark range is set, copy to multi marks +/*N*/ if ( bMarked && !bMarkIsNeg ) +/*N*/ { +/*N*/ bMarked = FALSE; +/*N*/ SetMultiMarkArea( aMarkRange, TRUE ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ PutInOrder( nStartRow, nEndRow ); +/*N*/ PutInOrder( nStartCol, nEndCol ); +/*N*/ +/*N*/ USHORT nCol; +/*N*/ for (nCol=nStartCol; nCol<=nEndCol; nCol++) +/*N*/ pMultiSel[nCol].SetMarkArea( nStartRow, nEndRow, bMark ); +/*N*/ +/*N*/ if ( bMultiMarked ) // aMultiRange updaten +/*N*/ { +/*N*/ if ( nStartCol < aMultiRange.aStart.Col() ) +/*N*/ aMultiRange.aStart.SetCol( nStartCol ); +/*N*/ if ( nStartRow < aMultiRange.aStart.Row() ) +/*N*/ aMultiRange.aStart.SetRow( nStartRow ); +/*N*/ if ( nEndCol > aMultiRange.aEnd.Col() ) +/*N*/ aMultiRange.aEnd.SetCol( nEndCol ); +/*N*/ if ( nEndRow > aMultiRange.aEnd.Row() ) +/*N*/ aMultiRange.aEnd.SetRow( nEndRow ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aMultiRange = rRange; // neu +/*N*/ bMultiMarked = TRUE; +/*N*/ } +/*N*/ } + + +/*N*/ void ScMarkData::SelectOneTable( USHORT nTab ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ bTabMarked[i] = ( nTab == i ); +/*N*/ } + +/*N*/ USHORT ScMarkData::GetSelectCount() const +/*N*/ { +/*N*/ USHORT nCount = 0; +/*N*/ for (USHORT i=0; i<=MAXTAB; i++) +/*N*/ if (bTabMarked[i]) +/*N*/ ++nCount; +/*N*/ +/*N*/ return nCount; +/*N*/ } + +/*N*/ void ScMarkData::MarkToMulti() +/*N*/ { +/*N*/ if ( bMarked && !bMarking ) +/*N*/ { +/*N*/ SetMultiMarkArea( aMarkRange, !bMarkIsNeg ); +/*N*/ bMarked = FALSE; +/*N*/ +/*N*/ // check if all multi mark ranges have been removed +/*N*/ if ( bMarkIsNeg && !HasAnyMultiMarks() ) +/*?*/ ResetMark(); +/*N*/ } +/*N*/ } + +/*N*/ void ScMarkData::MarkToSimple() +/*N*/ { +/*N*/ if ( bMarking ) +/*N*/ return; +/*N*/ +/*N*/ if ( bMultiMarked && bMarked ) +/*?*/ MarkToMulti(); // may result in bMarked and bMultiMarked reset +/*N*/ +/*N*/ if ( bMultiMarked ) +/*N*/ { +/*N*/ DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0"); +/*N*/ +/*N*/ ScRange aNew = aMultiRange; +/*N*/ +/*N*/ BOOL bOk = FALSE; +/*N*/ USHORT nStartCol = aNew.aStart.Col(); +/*N*/ USHORT nEndCol = aNew.aEnd.Col(); +/*N*/ +/*N*/ while ( nStartCol < nEndCol && !pMultiSel[nStartCol].HasMarks() ) +/*N*/ ++nStartCol; +/*N*/ while ( nStartCol < nEndCol && !pMultiSel[nEndCol].HasMarks() ) +/*N*/ --nEndCol; +/*N*/ +/*N*/ // Zeilen werden nur aus MarkArray genommen +/*N*/ USHORT nStartRow, nEndRow; +/*N*/ if ( pMultiSel[nStartCol].HasOneMark( nStartRow, nEndRow ) ) +/*N*/ { +/*N*/ bOk = TRUE; +/*N*/ USHORT nCmpStart, nCmpEnd; +/*N*/ for (USHORT nCol=nStartCol+1; nCol<=nEndCol && bOk; nCol++) +/*N*/ if ( !pMultiSel[nCol].HasOneMark( nCmpStart, nCmpEnd ) +/*N*/ || nCmpStart != nStartRow || nCmpEnd != nEndRow ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ +/*N*/ if (bOk) +/*N*/ { +/*?*/ aNew.aStart.SetCol(nStartCol); +/*?*/ aNew.aStart.SetRow(nStartRow); +/*?*/ aNew.aEnd.SetCol(nEndCol); +/*?*/ aNew.aEnd.SetRow(nEndRow); +/*?*/ +/*?*/ ResetMark(); +/*?*/ aMarkRange = aNew; +/*?*/ bMarked = TRUE; +/*?*/ bMarkIsNeg = FALSE; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScMarkData::IsCellMarked( USHORT nCol, USHORT nRow, BOOL bNoSimple ) const +/*N*/ { +/*N*/ if ( bMarked && !bNoSimple && !bMarkIsNeg ) +/*?*/ if ( aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol && +/*?*/ aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow ) +/*?*/ return TRUE; +/*N*/ +/*N*/ if (bMultiMarked) +/*N*/ { +/*N*/ //! hier auf negative Markierung testen ? +/*N*/ +/*N*/ DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0"); +/*N*/ return pMultiSel[nCol].GetMark( nRow ); +/*N*/ } +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + + +/*N*/ void ScMarkData::MarkFromRangeList( const ScRangeList& rList, BOOL bReset ) +/*N*/ { +/*N*/ if (bReset) +/*N*/ { +/*?*/ for (USHORT i=0; i<=MAXTAB; i++) +/*?*/ bTabMarked[i] = FALSE; // Tabellen sind nicht in ResetMark +/*?*/ ResetMark(); +/*N*/ } +/*N*/ +/*N*/ ULONG nCount = rList.Count(); +/*N*/ if ( nCount == 1 && !bMarked && !bMultiMarked ) +/*N*/ { +/*N*/ ScRange aRange = *rList.GetObject(0); +/*N*/ SetMarkArea( aRange ); +/*N*/ SelectTable( aRange.aStart.Tab(), TRUE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for (ULONG i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScRange aRange = *rList.GetObject(i); +/*N*/ SetMultiMarkArea( aRange, TRUE ); +/*N*/ SelectTable( aRange.aStart.Tab(), TRUE ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScMarkData::FillRangeListWithMarks( ScRangeList* pList, BOOL bClear ) const +/*N*/ { +/*N*/ if (!pList) +/*N*/ return; +/*N*/ +/*N*/ if (bClear) +/*?*/ pList->RemoveAll(); +/*N*/ +/*N*/ //! bei mehreren selektierten Tabellen mehrere Ranges eintragen !!! +/*N*/ +/*N*/ if ( bMultiMarked ) +/*N*/ { +/*N*/ DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0"); +/*N*/ +/*N*/ USHORT nTab = aMultiRange.aStart.Tab(); +/*N*/ +/*N*/ USHORT nStartCol = aMultiRange.aStart.Col(); +/*N*/ USHORT nEndCol = aMultiRange.aEnd.Col(); +/*N*/ for (USHORT nCol=nStartCol; nCol<=nEndCol; nCol++) +/*N*/ if (pMultiSel[nCol].HasMarks()) +/*N*/ { +/*N*/ USHORT nTop, nBottom; +/*N*/ ScRange aRange( nCol, 0, nTab ); +/*N*/ ScMarkArrayIter aMarkIter( &pMultiSel[nCol] ); +/*N*/ while ( aMarkIter.Next( nTop, nBottom ) ) +/*N*/ { +/*N*/ aRange.aStart.SetRow( nTop ); +/*N*/ aRange.aEnd.SetRow( nBottom ); +/*N*/ pList->Join( aRange ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( bMarked ) +/*?*/ pList->Append( aMarkRange ); +/*N*/ } + +/*N*/ BOOL ScMarkData::IsAllMarked( const ScRange& rRange ) const +/*N*/ { +/*N*/ if ( !bMultiMarked ) +/*N*/ return FALSE; +/*N*/ +/*N*/ DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0"); +/*N*/ +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ BOOL bOk = TRUE; +/*N*/ for (USHORT nCol=nStartCol; nCol<=nEndCol && bOk; nCol++) +/*N*/ if ( !pMultiSel[nCol].IsAllMarked( nStartRow, nEndRow ) ) +/*N*/ bOk = FALSE; +/*N*/ +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScMarkData::HasMultiMarks( USHORT nCol ) const +/*N*/ { +/*N*/ if ( !bMultiMarked ) +/*N*/ return FALSE; +/*N*/ +/*N*/ DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0"); +/*N*/ +/*N*/ return pMultiSel[nCol].HasMarks(); +/*N*/ } + +/*N*/ BOOL ScMarkData::HasAnyMultiMarks() const +/*N*/ { +/*N*/ if ( !bMultiMarked ) +/*N*/ return FALSE; +/*N*/ +/*N*/ DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0"); +/*N*/ +/*N*/ for (USHORT nCol=0; nCol<=MAXCOL; nCol++) +/*N*/ if ( pMultiSel[nCol].HasMarks() ) +/*N*/ return TRUE; +/*N*/ +/*N*/ return FALSE; // nix +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_olinetab.cxx b/binfilter/bf_sc/source/core/data/sc_olinetab.cxx new file mode 100644 index 000000000000..31d4fc3305a4 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_olinetab.cxx @@ -0,0 +1,637 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <tools/debug.hxx> +#include <limits.h> + +// INCLUDE --------------------------------------------------------------- + +#include "olinetab.hxx" +#include "global.hxx" +#include "rechead.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ ScOutlineEntry::ScOutlineEntry( USHORT nNewStart, USHORT nNewSize, BOOL bNewHidden ) : +/*N*/ nStart ( nNewStart ), +/*N*/ nSize ( nNewSize ), +/*N*/ bHidden ( bNewHidden ), +/*N*/ bVisible( TRUE ) +/*N*/ { +/*N*/ } + +/*N*/ ScOutlineEntry::ScOutlineEntry( const ScOutlineEntry& rEntry ) : +/*N*/ nStart ( rEntry.nStart ), +/*N*/ nSize ( rEntry.nSize ), +/*N*/ bHidden ( rEntry.bHidden ), +/*N*/ bVisible( rEntry.bVisible ) +/*N*/ { +/*N*/ } + +/*N*/ ScOutlineEntry::ScOutlineEntry( SvStream& rStream, ScMultipleReadHeader& rHdr ) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream >> nStart; +/*N*/ rStream >> nSize; +/*N*/ rStream >> bHidden; +/*N*/ rStream >> bVisible; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ void ScOutlineEntry::Store( SvStream& rStream, ScMultipleWriteHeader& rHdr ) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream << nStart; +/*N*/ rStream << nSize; +/*N*/ rStream << bHidden; +/*N*/ rStream << bVisible; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ DataObject* ScOutlineEntry::Clone() const +/*N*/ { +/*N*/ return new ScOutlineEntry( *this ); +/*N*/ } + +/*N*/ void ScOutlineEntry::Move( short nDelta ) +/*N*/ { +/*N*/ short nNewPos = ((short) nStart) + nDelta; +/*N*/ if (nNewPos<0) +/*N*/ { +/*N*/ DBG_ERROR("OutlineEntry < 0"); +/*N*/ nNewPos = 0; +/*N*/ } +/*N*/ nStart = (USHORT) nNewPos; +/*N*/ } + +/*N*/ void ScOutlineEntry::SetSize( USHORT nNewSize ) +/*N*/ { +/*N*/ if (nNewSize) +/*N*/ nSize = nNewSize; +/*N*/ else +/*N*/ DBG_ERROR("ScOutlineEntry Size == 0"); +/*N*/ } + +/*N*/ void ScOutlineEntry::SetPosSize( USHORT nNewPos, USHORT nNewSize ) +/*N*/ { +/*N*/ nStart = nNewPos; +/*N*/ SetSize( nNewSize ); +/*N*/ } + +/*N*/ void ScOutlineEntry::SetVisible( BOOL bNewVisible ) +/*N*/ { +/*N*/ bVisible = bNewVisible; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScOutlineCollection::ScOutlineCollection() : +/*N*/ SortedCollection( 4,4,FALSE ) +/*N*/ { +/*N*/ } + +/*N*/ inline short IntCompare( USHORT nX, USHORT nY ) +/*N*/ { +/*N*/ if ( nX==nY ) return 0; +/*N*/ else if ( nX<nY ) return -1; +/*N*/ else return 1; +/*N*/ } + +/*N*/ short ScOutlineCollection::Compare(DataObject* pKey1, DataObject* pKey2) const +/*N*/ { +/*N*/ return IntCompare( ((ScOutlineEntry*)pKey1)->GetStart(), +/*N*/ ((ScOutlineEntry*)pKey2)->GetStart() ); +/*N*/ } +/*N*/ + +//------------------------------------------------------------------------ + +/*N*/ ScOutlineArray::ScOutlineArray() : +/*N*/ nDepth( 0 ) +/*N*/ { +/*N*/ } + +/*N*/ ScOutlineArray::ScOutlineArray( const ScOutlineArray& rArray ) : +/*N*/ nDepth( rArray.nDepth ) +/*N*/ { +/*N*/ for (USHORT nLevel=0; nLevel<nDepth; nLevel++) +/*N*/ { +/*N*/ USHORT nCount = rArray.aCollections[nLevel].GetCount(); +/*N*/ for (USHORT nEntry=0; nEntry<nCount; nEntry++) +/*N*/ { +/*N*/ ScOutlineEntry* pEntry = (ScOutlineEntry*) rArray.aCollections[nLevel].At(nEntry); +/*N*/ aCollections[nLevel].Insert( new ScOutlineEntry( *pEntry ) ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScOutlineArray::FindEntry( USHORT nSearchPos, USHORT& rFindLevel, USHORT& rFindIndex, +/*N*/ USHORT nMaxLevel ) +/*N*/ { +/*N*/ rFindLevel = rFindIndex = 0; +/*N*/ +/*N*/ if (nMaxLevel > nDepth) +/*N*/ nMaxLevel = nDepth; +/*N*/ +/*N*/ for (USHORT nLevel=0; nLevel<nMaxLevel; nLevel++) //! rueckwaerts suchen ? +/*N*/ { +/*N*/ ScOutlineCollection* pCollect = &aCollections[nLevel]; +/*N*/ USHORT nCount = pCollect->GetCount(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScOutlineEntry* pEntry = (ScOutlineEntry*) pCollect->At(i); +/*N*/ if ( pEntry->GetStart() <= nSearchPos && pEntry->GetEnd() >= nSearchPos ) +/*N*/ { +/*N*/ rFindLevel = nLevel + 1; // naechster Level (zum Einfuegen) +/*N*/ rFindIndex = i; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScOutlineArray::Insert( USHORT nStartCol, USHORT nEndCol, BOOL& rSizeChanged, +/*N*/ BOOL bHidden, BOOL bVisible ) +/*N*/ { +/*N*/ rSizeChanged = FALSE; +/*N*/ +/*N*/ USHORT nStartLevel; +/*N*/ USHORT nStartIndex; +/*N*/ USHORT nEndLevel; +/*N*/ USHORT nEndIndex; +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ BOOL bCont; +/*N*/ USHORT nFindMax; +/*N*/ FindEntry( nStartCol, nStartLevel, nStartIndex ); // nLevel = neuer Level (alter+1) !!! +/*N*/ FindEntry( nEndCol, nEndLevel, nEndIndex ); +/*N*/ nFindMax = Max(nStartLevel,nEndLevel); +/*N*/ do +/*N*/ { +/*N*/ bCont = FALSE; +/*N*/ +/*N*/ if ( nStartLevel == nEndLevel && nStartIndex == nEndIndex && nStartLevel < SC_OL_MAXDEPTH ) +/*N*/ bFound = TRUE; +/*N*/ +/*N*/ if (!bFound) +/*N*/ { +/*N*/ if (nFindMax>0) +/*N*/ { +/*N*/ --nFindMax; +/*N*/ if (nStartLevel) +/*N*/ if ( ((ScOutlineEntry*)aCollections[nStartLevel-1].At(nStartIndex))-> +/*N*/ GetStart() == nStartCol ) +/*N*/ FindEntry( nStartCol, nStartLevel, nStartIndex, nFindMax ); +/*N*/ if (nEndLevel) +/*?*/ if ( ((ScOutlineEntry*)aCollections[nEndLevel-1].At(nEndIndex))-> +/*?*/ GetEnd() == nEndCol ) +/*N*/ FindEntry( nEndCol, nEndLevel, nEndIndex, nFindMax ); +/*N*/ bCont = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ while ( !bFound && bCont ); +/*N*/ +/*N*/ if (!bFound) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nLevel = nStartLevel; +/*N*/ +/*N*/ // untere verschieben +/*N*/ +/*N*/ BOOL bNeedSize = FALSE; +/*N*/ for ( short nMoveLevel = nDepth-1; nMoveLevel >= (short) nLevel; nMoveLevel-- ) +/*N*/ { +/*N*/ USHORT nCount = aCollections[nMoveLevel].GetCount(); +/*N*/ BOOL bMoved = FALSE; +/*N*/ for ( USHORT i=0; i<nCount; i += bMoved ? 0 : 1 ) +/*N*/ { +/*N*/ ScOutlineEntry* pEntry = (ScOutlineEntry*) aCollections[nMoveLevel].At(i); +/*N*/ USHORT nEntryStart = pEntry->GetStart(); +/*N*/ if ( nEntryStart >= nStartCol && nEntryStart <= nEndCol ) +/*N*/ { +/*N*/ if (nMoveLevel >= SC_OL_MAXDEPTH - 1) +/*N*/ { +/*?*/ rSizeChanged = FALSE; // kein Platz +/*?*/ return FALSE; +/*N*/ } +/*N*/ aCollections[nMoveLevel+1].Insert( new ScOutlineEntry( *pEntry ) ); +/*N*/ aCollections[nMoveLevel].AtFree( i ); +/*N*/ nCount = aCollections[nMoveLevel].GetCount(); +/*N*/ bMoved = TRUE; +/*N*/ if (nMoveLevel == (short) nDepth - 1) +/*N*/ bNeedSize = TRUE; +/*N*/ } +/*N*/ else +/*N*/ bMoved = FALSE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bNeedSize) +/*N*/ { +/*N*/ ++nDepth; +/*N*/ rSizeChanged = TRUE; +/*N*/ } +/*N*/ +/*N*/ if (nDepth <= nLevel) +/*N*/ { +/*N*/ nDepth = nLevel+1; +/*N*/ rSizeChanged = TRUE; +/*N*/ } +/*N*/ +/* nicht zusammenfassen! + + // zusammenfassen + + USHORT nCount = aCollections[nLevel].GetCount(); + USHORT nIndex; + bFound = FALSE; + for ( nIndex=0; nIndex<nCount && !bFound; nIndex++ ) + { + if ( ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetEnd() + 1 == nStartCol ) + { + nStartCol = ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetStart(); + aCollections[nLevel].AtFree(nIndex); + nCount = aCollections[nLevel].GetCount(); // Daten geaendert + bFound = TRUE; + } + } + + bFound = FALSE; + for ( nIndex=0; nIndex<nCount && !bFound; nIndex++ ) + { + if ( ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetStart() == nEndCol + 1 ) + { + nEndCol = ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetEnd(); + aCollections[nLevel].AtFree(nIndex); + bFound = TRUE; + } + } +*/ +/*N*/ ScOutlineEntry* pNewEntry = new ScOutlineEntry( nStartCol, nEndCol+1-nStartCol, bHidden ); +/*N*/ pNewEntry->SetVisible( bVisible ); +/*N*/ aCollections[nLevel].Insert( pNewEntry ); +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + + + +/*N*/ BOOL ScOutlineArray::DecDepth() // nDepth auf leere Levels anpassen +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ BOOL bCont; +/*N*/ do +/*N*/ { +/*N*/ bCont = FALSE; +/*N*/ if (nDepth) +/*N*/ if (aCollections[nDepth-1].GetCount() == 0) +/*N*/ { +/*N*/ --nDepth; +/*N*/ bChanged = TRUE; +/*N*/ bCont = TRUE; +/*N*/ } +/*N*/ } +/*N*/ while (bCont); +/*N*/ return bChanged; +/*N*/ } + + +/*M*/ ScOutlineEntry* ScOutlineArray::GetEntry( USHORT nLevel, USHORT nIndex ) const +/*M*/ { +/*M*/ return (ScOutlineEntry*)((nLevel < nDepth) ? aCollections[nLevel].At(nIndex) : NULL); +/*M*/ } + +/*M*/ USHORT ScOutlineArray::GetCount( USHORT nLevel ) const +/*M*/ { +/*M*/ return (nLevel < nDepth) ? aCollections[nLevel].GetCount() : 0; +/*M*/ } + + +/*M*/ void ScOutlineArray::SetVisibleBelow( USHORT nLevel, USHORT nEntry, BOOL bValue, BOOL bSkipHidden ) +/*M*/ { +/*M*/ ScOutlineEntry* pEntry = GetEntry( nLevel, nEntry ); +/*M*/ if( pEntry ) +/*M*/ { +/*M*/ USHORT nStart = pEntry->GetStart(); +/*M*/ USHORT nEnd = pEntry->GetEnd(); +/*M*/ +/*M*/ for (USHORT nSubLevel=nLevel+1; nSubLevel<nDepth; nSubLevel++) +/*M*/ { +/*M*/ USHORT i = 0; +/*M*/ pEntry = (ScOutlineEntry*) aCollections[nSubLevel].At(i); +/*M*/ while (pEntry) +/*M*/ { +/*M*/ if (pEntry->GetStart() >= nStart && pEntry->GetEnd() <= nEnd) +/*M*/ { +/*M*/ pEntry->SetVisible(bValue); +/*M*/ +/*M*/ if (bSkipHidden) +/*M*/ if (!pEntry->IsHidden()) +/*M*/ SetVisibleBelow( nSubLevel, i, bValue, TRUE ); +/*M*/ } +/*M*/ +/*M*/ ++i; +/*M*/ pEntry = (ScOutlineEntry*) aCollections[nSubLevel].At(i); +/*M*/ } +/*M*/ +/*M*/ if (bSkipHidden) +/*M*/ nSubLevel = nDepth; // Abbruch +/*M*/ } +/*M*/ } +/*M*/ } + + + +/*N*/ BOOL ScOutlineArray::TestInsertSpace( USHORT nSize, USHORT nMaxVal ) const +/*N*/ { +/*N*/ USHORT nCount = aCollections[0].GetCount(); +/*N*/ if (nCount) +/*N*/ { +/*N*/ USHORT nEnd = ((ScOutlineEntry*) aCollections[0].At(nCount-1))->GetEnd(); +/*N*/ return ( nEnd+nSize <= nMaxVal ); +/*N*/ } +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +/*N*/ void ScOutlineArray::InsertSpace( USHORT nStartPos, USHORT nSize ) +/*N*/ { +/*N*/ ScSubOutlineIterator aIter( this ); +/*N*/ ScOutlineEntry* pEntry; +/*N*/ while((pEntry=aIter.GetNext())!=NULL) +/*N*/ { +/*N*/ if ( pEntry->GetStart() >= nStartPos ) +/*N*/ pEntry->Move(nSize); +/*N*/ else +/*N*/ { +/*N*/ USHORT nEnd = pEntry->GetEnd(); +/*N*/ // immer erweitern, wenn innerhalb der Gruppe eingefuegt +/*N*/ // beim Einfuegen am Ende nur, wenn die Gruppe nicht ausgeblendet ist +/*N*/ if ( nEnd >= nStartPos || ( nEnd+1 >= nStartPos && !pEntry->IsHidden() ) ) +/*N*/ { +/*N*/ USHORT nEntrySize = pEntry->GetSize(); +/*N*/ nEntrySize += nSize; +/*N*/ pEntry->SetSize( nEntrySize ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScOutlineArray::DeleteSpace( USHORT nStartPos, USHORT nSize ) +/*N*/ { +/*N*/ USHORT nEndPos = nStartPos + nSize - 1; +/*N*/ BOOL bNeedSave = FALSE; // Original fuer Undo benoetigt? +/*N*/ BOOL bChanged = FALSE; // fuer Test auf Level +/*N*/ +/*N*/ ScSubOutlineIterator aIter( this ); +/*N*/ ScOutlineEntry* pEntry; +/*N*/ while((pEntry=aIter.GetNext())!=NULL) +/*N*/ { +/*N*/ USHORT nEntryStart = pEntry->GetStart(); +/*N*/ USHORT nEntryEnd = pEntry->GetEnd(); +/*N*/ USHORT nEntrySize = pEntry->GetSize(); +/*N*/ +/*N*/ if ( nEntryEnd >= nStartPos ) +/*N*/ { +/*N*/ if ( nEntryStart > nEndPos ) // rechts +/*N*/ pEntry->Move(-(short)nSize); +/*N*/ else if ( nEntryStart < nStartPos && nEntryEnd >= nEndPos ) // aussen +/*N*/ pEntry->SetSize( nEntrySize-nSize ); +/*N*/ else +/*N*/ { +/*N*/ bNeedSave = TRUE; +/*N*/ if ( nEntryStart >= nStartPos && nEntryEnd <= nEndPos ) // innen +/*N*/ { +/*N*/ aIter.DeleteLast(); +/*N*/ bChanged = TRUE; +/*N*/ } +/*N*/ else if ( nEntryStart >= nStartPos ) // rechts ueber +/*N*/ pEntry->SetPosSize( nStartPos, nEntryEnd-nEndPos ); +/*N*/ else // links ueber +/*N*/ pEntry->SetSize( nStartPos-nEntryStart ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bChanged) +/*N*/ DecDepth(); +/*N*/ +/*N*/ return bNeedSave; +/*N*/ } + +/*N*/ BOOL ScOutlineArray::ManualAction( USHORT nStartPos, USHORT nEndPos, BOOL bShow, BYTE* pHiddenFlags ) +/*N*/ { +/*N*/ BOOL bModified = FALSE; +/*N*/ ScSubOutlineIterator aIter( this ); +/*N*/ ScOutlineEntry* pEntry; +/*N*/ while((pEntry=aIter.GetNext())!=NULL) +/*N*/ { +/*N*/ USHORT nEntryStart = pEntry->GetStart(); +/*N*/ USHORT nEntryEnd = pEntry->GetEnd(); +/*N*/ +/*N*/ if (nEntryEnd>=nStartPos && nEntryStart<=nEndPos) +/*N*/ { +/*?*/ if ( pEntry->IsHidden() == bShow ) +/*?*/ { +/*?*/ // #i12341# hide if all columns/rows are hidden, show if at least one +/*?*/ // is visible +/*?*/ +/*?*/ BOOL bAllHidden = TRUE; +/*?*/ for ( USHORT i=nEntryStart; i<=nEntryEnd && bAllHidden; i++ ) +/*?*/ if ( ( pHiddenFlags[i] & CR_HIDDEN ) == 0 ) +/*?*/ bAllHidden = FALSE; +/*?*/ +/*?*/ BOOL bToggle = ( bShow != bAllHidden ); +/*?*/ if ( bToggle ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 pEntry->SetHidden( !bShow ); +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ return bModified; +/*N*/ } + + +/*N*/ void ScOutlineArray::Load( SvStream& rStream ) +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> nDepth; +/*N*/ for (USHORT nLevel=0; nLevel<nDepth; nLevel++) +/*N*/ { +/*N*/ USHORT nCount; +/*N*/ rStream >> nCount; +/*N*/ for (USHORT nIndex=0; nIndex<nCount; nIndex++) +/*N*/ { +/*N*/ ScOutlineEntry* pEntry = new ScOutlineEntry( rStream, aHdr ); +/*N*/ aCollections[nLevel].Insert( pEntry ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScOutlineArray::Store( SvStream& rStream ) +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream << nDepth; +/*N*/ for (USHORT nLevel=0; nLevel<nDepth; nLevel++) +/*N*/ { +/*N*/ USHORT nCount = aCollections[nLevel].GetCount(); +/*N*/ rStream << nCount; +/*N*/ for (USHORT nIndex=0; nIndex<nCount; nIndex++) +/*N*/ ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->Store( rStream, aHdr ); +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScOutlineTable::ScOutlineTable() +/*N*/ { +/*N*/ } + +/*N*/ ScOutlineTable::ScOutlineTable( const ScOutlineTable& rOutline ) : +/*N*/ aColOutline( rOutline.aColOutline ), +/*N*/ aRowOutline( rOutline.aRowOutline ) +/*N*/ { +/*N*/ } + +/*N*/ BOOL ScOutlineTable::TestInsertCol( USHORT nSize ) +/*N*/ { +/*N*/ return aColOutline.TestInsertSpace( nSize, MAXCOL ); +/*N*/ } + +/*N*/ void ScOutlineTable::InsertCol( USHORT nStartCol, USHORT nSize ) +/*N*/ { +/*N*/ aColOutline.InsertSpace( nStartCol, nSize ); +/*N*/ } + +/*N*/ BOOL ScOutlineTable::DeleteCol( USHORT nStartCol, USHORT nSize ) +/*N*/ { +/*N*/ return aColOutline.DeleteSpace( nStartCol, nSize ); +/*N*/ } + +/*N*/ BOOL ScOutlineTable::TestInsertRow( USHORT nSize ) +/*N*/ { +/*N*/ return aRowOutline.TestInsertSpace( nSize, MAXROW ); +/*N*/ } + +/*N*/ void ScOutlineTable::InsertRow( USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ aRowOutline.InsertSpace( nStartRow, nSize ); +/*N*/ } + +/*N*/ BOOL ScOutlineTable::DeleteRow( USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ return aRowOutline.DeleteSpace( nStartRow, nSize ); +/*N*/ } + +/*N*/ void ScOutlineTable::Load( SvStream& rStream ) +/*N*/ { +/*N*/ DBG_ASSERT( aColOutline.GetDepth()==0 && aRowOutline.GetDepth()==0, +/*N*/ "Load auf nicht leere ScOutlineTable" ); +/*N*/ aColOutline.Load( rStream ); +/*N*/ aRowOutline.Load( rStream ); +/*N*/ } + +/*N*/ void ScOutlineTable::Store( SvStream& rStream ) +/*N*/ { +/*N*/ aColOutline.Store( rStream ); +/*N*/ aRowOutline.Store( rStream ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScSubOutlineIterator::ScSubOutlineIterator( ScOutlineArray* pOutlineArray ) : +/*N*/ pArray( pOutlineArray ), +/*N*/ nStart( 0 ), +/*N*/ nEnd( USHRT_MAX ), // alle durchgehen +/*N*/ nSubLevel( 0 ), +/*N*/ nSubEntry( 0 ) +/*N*/ { +/*N*/ nDepth = pArray->nDepth; +/*N*/ } + +/*N*/ +/*N*/ ScOutlineEntry* ScSubOutlineIterator::GetNext() +/*N*/ { +/*N*/ ScOutlineEntry* pEntry; +/*N*/ BOOL bFound = FALSE; +/*N*/ do +/*N*/ { +/*N*/ if (nSubLevel >= nDepth) +/*N*/ return NULL; +/*N*/ +/*N*/ pEntry = (ScOutlineEntry*) pArray->aCollections[nSubLevel].At(nSubEntry); +/*N*/ if (!pEntry) +/*N*/ { +/*N*/ nSubEntry = 0; +/*N*/ ++nSubLevel; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( pEntry->GetStart() >= nStart && pEntry->GetEnd() <= nEnd ) +/*N*/ bFound = TRUE; +/*N*/ ++nSubEntry; +/*N*/ } +/*N*/ } +/*N*/ while (!bFound); +/*N*/ return pEntry; // nSubLevel gueltig, wenn pEntry != 0 +/*N*/ } +/*N*/ +/*N*/ void ScSubOutlineIterator::DeleteLast() +/*N*/ { +/*N*/ if (nSubLevel >= nDepth) +/*N*/ { +/*N*/ DBG_ERROR("ScSubOutlineIterator::DeleteLast nach Ende"); +/*N*/ return; +/*N*/ } +/*N*/ if (nSubEntry == 0) +/*N*/ { +/*N*/ DBG_ERROR("ScSubOutlineIterator::DeleteLast vor GetNext"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ --nSubEntry; +/*N*/ pArray->aCollections[nSubLevel].AtFree(nSubEntry); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_pagepar.cxx b/binfilter/bf_sc/source/core/data/sc_pagepar.cxx new file mode 100644 index 000000000000..5e8999b749ea --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_pagepar.cxx @@ -0,0 +1,114 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <string.h> + +#include "pagepar.hxx" +namespace binfilter { + + +//======================================================================== +// struct ScPageTableParam: + +/*N*/ ScPageTableParam::ScPageTableParam() +/*N*/ { +/*N*/ Reset(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScPageTableParam::ScPageTableParam( const ScPageTableParam& r ) +/*N*/ { +/*N*/ *this = r; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScPageTableParam::~ScPageTableParam() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPageTableParam::Reset() +/*N*/ { +/*N*/ bNotes=bGrid=bHeaders=bDrawings= +/*N*/ bLeftRight=bScaleAll=bScalePageNum= +/*N*/ bFormulas=bNullVals=bSkipEmpty = FALSE; +/*N*/ bTopDown=bScaleNone=bCharts=bObjects = TRUE; +/*N*/ nScaleAll = 100; +/*N*/ nScalePageNum = 0; +/*N*/ nFirstPageNo = 1; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//======================================================================== +// struct ScPageAreaParam: + +/*N*/ ScPageAreaParam::ScPageAreaParam() +/*N*/ { +/*N*/ Reset(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScPageAreaParam::ScPageAreaParam( const ScPageAreaParam& r ) +/*N*/ { +/*N*/ *this = r; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScPageAreaParam::~ScPageAreaParam() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScPageAreaParam::Reset() +/*N*/ { +/*N*/ bPrintArea = bRepeatRow = bRepeatCol = FALSE; +/*N*/ +/*N*/ memset( &aPrintArea, 0, sizeof(ScRange) ); +/*N*/ memset( &aRepeatRow, 0, sizeof(ScRange) ); +/*N*/ memset( &aRepeatCol, 0, sizeof(ScRange) ); +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_patattr.cxx b/binfilter/bf_sc/source/core/data/sc_patattr.cxx new file mode 100644 index 000000000000..62e729549694 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_patattr.cxx @@ -0,0 +1,1175 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svx/adjitem.hxx> +#include <bf_svx/algitem.hxx> +#include <bf_svx/boxitem.hxx> +#include <bf_svx/brshitem.hxx> +#include <bf_svx/charreliefitem.hxx> +#include <bf_svx/cntritem.hxx> +#include <bf_svtools/colorcfg.hxx> +#include <bf_svx/colritem.hxx> +#include <bf_svx/crsditem.hxx> +#include <bf_svx/emphitem.hxx> +#include <bf_svx/fhgtitem.hxx> +#include <bf_svx/fontitem.hxx> +#include <bf_svx/forbiddenruleitem.hxx> +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/langitem.hxx> +#include <bf_svx/postitem.hxx> +#include <bf_svx/rotmodit.hxx> +#include <bf_svx/scripttypeitem.hxx> +#include <bf_svx/shaditem.hxx> +#include <bf_svx/shdditem.hxx> +#include <bf_svx/udlnitem.hxx> +#include <bf_svx/wghtitem.hxx> +#include <bf_svx/wrlmitem.hxx> +#include <bf_svtools/zforlist.hxx> +#include <vcl/outdev.hxx> + +#include "patattr.hxx" +#include "docpool.hxx" +#include "stlsheet.hxx" +#include "stlpool.hxx" +#include "document.hxx" +#include "globstr.hrc" +#include "validat.hxx" +#include "scmod.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +ScDocument* ScPatternAttr::pDoc = NULL; + +// ----------------------------------------------------------------------- + +//! move to some header file +inline long TwipsToHMM(long nTwips) { return (nTwips * 127 + 36) / 72; } +inline long HMMToTwips(long nHMM) { return (nHMM * 72 + 63) / 127; } + +// ----------------------------------------------------------------------- + +/*N*/ ScPatternAttr::ScPatternAttr( SfxItemSet* pItemSet, const String& rStyleName ) +/*N*/ : SfxSetItem ( ATTR_PATTERN, pItemSet ), +/*N*/ pName ( new String( rStyleName ) ), +/*N*/ pStyle ( NULL ) +/*N*/ { +/*N*/ } + +/*N*/ ScPatternAttr::ScPatternAttr( SfxItemSet* pItemSet, ScStyleSheet* pStyleSheet ) +/*N*/ : SfxSetItem ( ATTR_PATTERN, pItemSet ), +/*N*/ pName ( NULL ), +/*N*/ pStyle ( pStyleSheet ) +/*N*/ { +/*N*/ if ( pStyleSheet ) +/*?*/ GetItemSet().SetParent( &pStyleSheet->GetItemSet() ); +/*N*/ } + +/*N*/ ScPatternAttr::ScPatternAttr( SfxItemPool* pItemPool ) +/*N*/ : SfxSetItem ( ATTR_PATTERN, new SfxItemSet( *pItemPool, ATTR_PATTERN_START, ATTR_PATTERN_END ) ), +/*N*/ pName ( NULL ), +/*N*/ pStyle ( NULL ) +/*N*/ { +/*N*/ } + +/*N*/ ScPatternAttr::ScPatternAttr( const ScPatternAttr& rPatternAttr ) +/*N*/ : SfxSetItem ( rPatternAttr ), +/*N*/ pStyle ( rPatternAttr.pStyle ) +/*N*/ { +/*N*/ if (rPatternAttr.pName) +/*N*/ pName = new String(*rPatternAttr.pName); +/*N*/ else +/*N*/ pName = NULL; +/*N*/ } + +/*N*/ __EXPORT ScPatternAttr::~ScPatternAttr() +/*N*/ { +/*N*/ delete pName; +/*N*/ } + +/*N*/ SfxPoolItem* __EXPORT ScPatternAttr::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ ScPatternAttr* pPattern = new ScPatternAttr( GetItemSet().Clone(TRUE, pPool) ); +/*N*/ +/*N*/ pPattern->pStyle = pStyle; +/*N*/ pPattern->pName = pName ? new String(*pName) : NULL; +/*N*/ +/*N*/ return pPattern; +/*N*/ } + +/*N*/ inline int StrCmp( const String* pStr1, const String* pStr2 ) +/*N*/ { +/*N*/ return ( pStr1 ? ( pStr2 ? ( *pStr1 == *pStr2 ) : FALSE ) : ( pStr2 ? FALSE : TRUE ) ); +/*N*/ } + +/*N*/ int __EXPORT ScPatternAttr::operator==( const SfxPoolItem& rCmp ) const +/*N*/ { +/*N*/ return ( SfxSetItem::operator==(rCmp) && +/*N*/ StrCmp( GetStyleName(), ((const ScPatternAttr&)rCmp).GetStyleName() ) ); +/*N*/ } + +/*N*/ SfxPoolItem* __EXPORT ScPatternAttr::Create( SvStream& rStream, USHORT nVersion ) const +/*N*/ { +/*N*/ String* pStr; +/*N*/ BOOL bHasStyle; +/*N*/ short eFamDummy; +/*N*/ +/*N*/ rStream >> bHasStyle; +/*N*/ +/*N*/ if ( bHasStyle ) +/*N*/ { +/*N*/ pStr = new String; +/*N*/ rStream.ReadByteString( *pStr, rStream.GetStreamCharSet() ); +/*N*/ rStream >> eFamDummy; // wg. altem Dateiformat +/*N*/ } +/*N*/ else +/*N*/ pStr = new String( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ); +/*N*/ +/*N*/ SfxItemSet *pSet = new SfxItemSet( *GetItemSet().GetPool(), +/*N*/ ATTR_PATTERN_START, ATTR_PATTERN_END ); +/*N*/ pSet->Load( rStream ); +/*N*/ +/*N*/ ScPatternAttr* pPattern = new ScPatternAttr( pSet ); +/*N*/ +/*N*/ pPattern->pName = pStr; +/*N*/ +/*N*/ return pPattern; +/*N*/ } + +/*N*/ SvStream& __EXPORT ScPatternAttr::Store(SvStream& rStream, USHORT nItemVersion) const +/*N*/ { +/*N*/ rStream << (BOOL)TRUE; +/*N*/ +/*N*/ if ( pStyle ) +/*N*/ rStream.WriteByteString( pStyle->GetName(), rStream.GetStreamCharSet() ); +/*N*/ else if ( pName ) // wenn Style geloescht ist/war +/*?*/ rStream.WriteByteString( *pName, rStream.GetStreamCharSet() ); +/*N*/ else +/*N*/ rStream.WriteByteString( ScGlobal::GetRscString(STR_STYLENAME_STANDARD), +/*N*/ rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ rStream << (short)SFX_STYLE_FAMILY_PARA; // wg. altem Dateiformat +/*N*/ +/*N*/ GetItemSet().Store( rStream ); +/*N*/ +/*N*/ return rStream; +/*N*/ } + +/*N*/ void ScPatternAttr::GetFont( +/*N*/ Font& rFont, const SfxItemSet& rItemSet, ScAutoFontColorMode eAutoMode, +/*N*/ OutputDevice* pOutDev, const Fraction* pScale, +/*N*/ const SfxItemSet* pCondSet, BYTE nScript, +/*N*/ const Color* pBackConfigColor, const Color* pTextConfigColor ) +/*N*/ { +/*N*/ // Items auslesen +/*N*/ +/*N*/ const SvxFontItem* pFontAttr; +/*N*/ UINT32 nFontHeight; +/*N*/ FontWeight eWeight; +/*N*/ FontItalic eItalic; +/*N*/ FontUnderline eUnder; +/*N*/ BOOL bWordLine; +/*N*/ FontStrikeout eStrike; +/*N*/ BOOL bOutline; +/*N*/ BOOL bShadow; +/*N*/ FontEmphasisMark eEmphasis; +/*N*/ FontRelief eRelief; +/*N*/ Color aColor; +/*N*/ +/*N*/ USHORT nFontId, nHeightId, nWeightId, nPostureId; +/*N*/ if ( nScript == SCRIPTTYPE_ASIAN ) +/*N*/ { +/*?*/ nFontId = ATTR_CJK_FONT; +/*?*/ nHeightId = ATTR_CJK_FONT_HEIGHT; +/*?*/ nWeightId = ATTR_CJK_FONT_WEIGHT; +/*?*/ nPostureId = ATTR_CJK_FONT_POSTURE; +/*N*/ } +/*N*/ else if ( nScript == SCRIPTTYPE_COMPLEX ) +/*N*/ { +/*?*/ nFontId = ATTR_CTL_FONT; +/*?*/ nHeightId = ATTR_CTL_FONT_HEIGHT; +/*?*/ nWeightId = ATTR_CTL_FONT_WEIGHT; +/*?*/ nPostureId = ATTR_CTL_FONT_POSTURE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nFontId = ATTR_FONT; +/*N*/ nHeightId = ATTR_FONT_HEIGHT; +/*N*/ nWeightId = ATTR_FONT_WEIGHT; +/*N*/ nPostureId = ATTR_FONT_POSTURE; +/*N*/ } +/*N*/ +/*N*/ if ( pCondSet ) +/*N*/ { +/*N*/ const SfxPoolItem* pItem; +/*N*/ +/*N*/ if ( pCondSet->GetItemState( nFontId, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( nFontId ); +/*N*/ pFontAttr = (const SvxFontItem*) pItem; +/*N*/ +/*N*/ if ( pCondSet->GetItemState( nHeightId, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( nHeightId ); +/*N*/ nFontHeight = ((const SvxFontHeightItem*)pItem)->GetHeight(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( nWeightId, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( nWeightId ); +/*N*/ eWeight = (FontWeight)((const SvxWeightItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( nPostureId, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( nPostureId ); +/*N*/ eItalic = (FontItalic)((const SvxPostureItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_UNDERLINE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_UNDERLINE ); +/*N*/ eUnder = (FontUnderline)((const SvxUnderlineItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_WORDLINE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_WORDLINE ); +/*N*/ bWordLine = ((const SvxWordLineModeItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_CROSSEDOUT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_CROSSEDOUT ); +/*N*/ eStrike = (FontStrikeout)((const SvxCrossedOutItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_CONTOUR, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_CONTOUR ); +/*N*/ bOutline = ((const SvxContourItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_SHADOWED, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_SHADOWED ); +/*N*/ bShadow = ((const SvxShadowedItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_EMPHASISMARK, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_EMPHASISMARK ); +/*N*/ eEmphasis = ((const SvxEmphasisMarkItem*)pItem)->GetEmphasisMark(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_RELIEF, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_RELIEF ); +/*N*/ eRelief = (FontRelief)((const SvxCharReliefItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_COLOR, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_FONT_COLOR ); +/*N*/ aColor = ((const SvxColorItem*)pItem)->GetValue(); +/*N*/ } +/*N*/ else // alles aus rItemSet +/*N*/ { +/*N*/ pFontAttr = &(const SvxFontItem&)rItemSet.Get( nFontId ); +/*N*/ nFontHeight = ((const SvxFontHeightItem&) +/*N*/ rItemSet.Get( nHeightId )).GetHeight(); +/*N*/ eWeight = (FontWeight)((const SvxWeightItem&) +/*N*/ rItemSet.Get( nWeightId )).GetValue(); +/*N*/ eItalic = (FontItalic)((const SvxPostureItem&) +/*N*/ rItemSet.Get( nPostureId )).GetValue(); +/*N*/ eUnder = (FontUnderline)((const SvxUnderlineItem&) +/*N*/ rItemSet.Get( ATTR_FONT_UNDERLINE )).GetValue(); +/*N*/ bWordLine = ((const SvxWordLineModeItem&) +/*N*/ rItemSet.Get( ATTR_FONT_WORDLINE )).GetValue(); +/*N*/ eStrike = (FontStrikeout)((const SvxCrossedOutItem&) +/*N*/ rItemSet.Get( ATTR_FONT_CROSSEDOUT )).GetValue(); +/*N*/ bOutline = ((const SvxContourItem&) +/*N*/ rItemSet.Get( ATTR_FONT_CONTOUR )).GetValue(); +/*N*/ bShadow = ((const SvxShadowedItem&) +/*N*/ rItemSet.Get( ATTR_FONT_SHADOWED )).GetValue(); +/*N*/ eEmphasis = ((const SvxEmphasisMarkItem&) +/*N*/ rItemSet.Get( ATTR_FONT_EMPHASISMARK )).GetEmphasisMark(); +/*N*/ eRelief = (FontRelief)((const SvxCharReliefItem&) +/*N*/ rItemSet.Get( ATTR_FONT_RELIEF )).GetValue(); +/*N*/ aColor = ((const SvxColorItem&) +/*N*/ rItemSet.Get( ATTR_FONT_COLOR )).GetValue(); +/*N*/ } +/*N*/ DBG_ASSERT(pFontAttr,"nanu?"); +/*N*/ +/*N*/ // auswerten +/*N*/ +/*N*/ // FontItem: +/*N*/ +/*N*/ if (rFont.GetName() != pFontAttr->GetFamilyName()) +/*N*/ rFont.SetName( pFontAttr->GetFamilyName() ); +/*N*/ if (rFont.GetStyleName() != pFontAttr->GetStyleName()) +/*?*/ rFont.SetStyleName( pFontAttr->GetStyleName() ); +/*N*/ if (rFont.GetFamily() != pFontAttr->GetFamily()) +/*N*/ rFont.SetFamily( pFontAttr->GetFamily() ); +/*N*/ if (rFont.GetCharSet() != pFontAttr->GetCharSet()) +/*N*/ rFont.SetCharSet( pFontAttr->GetCharSet() ); +/*N*/ if (rFont.GetPitch() != pFontAttr->GetPitch()) +/*N*/ rFont.SetPitch( pFontAttr->GetPitch() ); +/*N*/ +/*N*/ // Groesse +/*N*/ +/*N*/ if ( pOutDev != NULL ) +/*N*/ { +/*N*/ Size aEffSize; +/*N*/ Fraction aFraction( 1,1 ); +/*N*/ if (pScale) +/*N*/ aFraction = *pScale; +/*N*/ Size aSize( 0, (long) nFontHeight ); +/*N*/ MapMode aDestMode = pOutDev->GetMapMode(); +/*N*/ MapMode aSrcMode( MAP_TWIP, Point(), aFraction, aFraction ); +/*N*/ if (aDestMode.GetMapUnit() == MAP_PIXEL) +/*N*/ aEffSize = pOutDev->LogicToPixel( aSize, aSrcMode ); +/*N*/ else +/*N*/ { +/*?*/ Fraction aFractOne(1,1); +/*?*/ aDestMode.SetScaleX( aFractOne ); +/*?*/ aDestMode.SetScaleY( aFractOne ); +/*?*/ aEffSize = OutputDevice::LogicToLogic( aSize, aSrcMode, aDestMode ); +/*N*/ } +/*N*/ rFont.SetSize( aEffSize ); +/*N*/ } +/*N*/ else /* if pOutDev != NULL */ +/*N*/ { +/*?*/ rFont.SetSize( Size( 0, (long) nFontHeight ) ); +/*N*/ } +/*N*/ + // determine effective font color + +/*M*/ if ( ( aColor.GetColor() == COL_AUTO && eAutoMode != SC_AUTOCOL_RAW ) || +/*M*/ eAutoMode == SC_AUTOCOL_IGNOREFONT || eAutoMode == SC_AUTOCOL_IGNOREALL ) +/*M*/ { +/*M*/ if ( eAutoMode == SC_AUTOCOL_BLACK ) +/*M*/ aColor.SetColor( COL_BLACK ); +/*M*/ else +/*M*/ { +/*M*/ // get background color from conditional or own set +/*M*/ Color aBackColor; +/*M*/ if ( pCondSet ) +/*M*/ { +/*M*/ const SfxPoolItem* pItem; +/*M*/ if ( pCondSet->GetItemState( ATTR_BACKGROUND, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rItemSet.Get( ATTR_BACKGROUND ); +/*M*/ aBackColor = ((const SvxBrushItem*)pItem)->GetColor(); +/*M*/ } +/*M*/ else +/*N*/ aBackColor = ((const SvxBrushItem&)rItemSet.Get( ATTR_BACKGROUND )).GetColor(); +/*M*/ +/*M*/ // if background color attribute is transparent, use window color for brightness comparisons +/*M*/ if ( aBackColor == COL_TRANSPARENT || +/*M*/ eAutoMode == SC_AUTOCOL_IGNOREBACK || eAutoMode == SC_AUTOCOL_IGNOREALL ) +/*M*/ { +/*M*/ if ( eAutoMode == SC_AUTOCOL_PRINT ) +/*M*/ aBackColor.SetColor( COL_WHITE ); +/*M*/ else if ( pBackConfigColor ) +/*M*/ { +/*M*/ // pBackConfigColor can be used to avoid repeated lookup of the configured color +/*M*/ aBackColor = *pBackConfigColor; +/*M*/ } +/*M*/ else +/*N*/ aBackColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(DOCCOLOR).nColor ); +/*M*/ } +/*M*/ +/*M*/ // get system text color for comparison +/*M*/ Color aSysTextColor; +/*M*/ if ( eAutoMode == SC_AUTOCOL_PRINT ) +/*M*/ aSysTextColor.SetColor( COL_BLACK ); +/*N*/ else if ( pTextConfigColor ) +/*N*/ { +/*N*/ // pTextConfigColor can be used to avoid repeated lookup of the configured color +/*N*/ aSysTextColor = *pTextConfigColor; +/*N*/ } +/*N*/ else +/*N*/ aSysTextColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(FONTCOLOR).nColor ); +/*M*/ +/*M*/ // select the resulting color +/*M*/ if ( aBackColor.IsDark() && aSysTextColor.IsDark() ) +/*M*/ { +/*M*/ // use white instead of dark on dark +/*M*/ aColor.SetColor( COL_WHITE ); +/*M*/ } +/*M*/ else if ( aBackColor.IsBright() && aSysTextColor.IsBright() ) +/*M*/ { +/*M*/ // use black instead of bright on bright +/*M*/ aColor.SetColor( COL_BLACK ); +/*M*/ } +/*M*/ else +/*M*/ { +/*M*/ // use aSysTextColor (black for SC_AUTOCOL_PRINT, from style settings otherwise) +/*M*/ aColor = aSysTextColor; +/*M*/ } +/*M*/ } +/*M*/ } + + // set font effects + +/*N*/ if (rFont.GetWeight() != eWeight) +/*N*/ rFont.SetWeight( eWeight ); +/*N*/ if (rFont.GetItalic() != eItalic) +/*N*/ rFont.SetItalic( eItalic ); +/*N*/ if (rFont.GetUnderline() != eUnder) +/*N*/ rFont.SetUnderline( eUnder ); +/*N*/ if (rFont.IsWordLineMode() != bWordLine) +/*N*/ rFont.SetWordLineMode( bWordLine ); +/*N*/ if (rFont.GetStrikeout() != eStrike) +/*N*/ rFont.SetStrikeout( eStrike ); +/*N*/ if (rFont.IsOutline() != bOutline) +/*N*/ rFont.SetOutline( bOutline ); +/*N*/ if (rFont.IsShadow() != bShadow) +/*N*/ rFont.SetShadow( bShadow ); +/*N*/ if (rFont.GetEmphasisMark() != eEmphasis) +/*N*/ rFont.SetEmphasisMark( eEmphasis ); +/*N*/ if (rFont.GetRelief() != eRelief) +/*N*/ rFont.SetRelief( eRelief ); +/*N*/ if (rFont.GetColor() != aColor) +/*N*/ rFont.SetColor( aColor ); +/*N*/ if (!rFont.IsTransparent()) +/*N*/ rFont.SetTransparent( TRUE ); +/*N*/ } + +/*N*/ void ScPatternAttr::GetFont( +/*N*/ Font& rFont, ScAutoFontColorMode eAutoMode, +/*N*/ OutputDevice* pOutDev, const Fraction* pScale, +/*N*/ const SfxItemSet* pCondSet, BYTE nScript, +/*N*/ const Color* pBackConfigColor, const Color* pTextConfigColor ) const +/*N*/ { +/*N*/ GetFont( rFont, GetItemSet(), eAutoMode, pOutDev, pScale, pCondSet, nScript, pBackConfigColor, pTextConfigColor ); +/*N*/ } + + +/*N*/ void ScPatternAttr::FillToEditItemSet( SfxItemSet& rEditSet, const SfxItemSet& rSrcSet, const SfxItemSet* pCondSet ) +/*N*/ { +/*N*/ // Items auslesen +/*N*/ +/*N*/ SvxColorItem aColorItem(EE_CHAR_COLOR); // use item as-is +/*N*/ SvxFontItem aFontItem(EE_CHAR_FONTINFO); // use item as-is +/*N*/ SvxFontItem aCjkFontItem(EE_CHAR_FONTINFO_CJK); +/*N*/ SvxFontItem aCtlFontItem(EE_CHAR_FONTINFO_CTL); +/*N*/ long nTHeight, nCjkTHeight, nCtlTHeight; // Twips +/*N*/ FontWeight eWeight, eCjkWeight, eCtlWeight; +/*N*/ SvxUnderlineItem aUnderlineItem(UNDERLINE_NONE, EE_CHAR_UNDERLINE); +/*N*/ BOOL bWordLine; +/*N*/ FontStrikeout eStrike; +/*N*/ FontItalic eItalic, eCjkItalic, eCtlItalic; +/*N*/ BOOL bOutline; +/*N*/ BOOL bShadow; +/*N*/ BOOL bForbidden; +/*N*/ FontEmphasisMark eEmphasis; +/*N*/ FontRelief eRelief; +/*N*/ LanguageType eLang, eCjkLang, eCtlLang; +/*N*/ BOOL bHyphenate; +/*N*/ SvxFrameDirection eDirection; +/*N*/ +/*N*/ //! additional parameter to control if language is needed? +/*N*/ +/*N*/ if ( pCondSet ) +/*N*/ { +/*N*/ const SfxPoolItem* pItem; +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_COLOR, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_COLOR ); +/*N*/ aColorItem = *(const SvxColorItem*)pItem; +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT ); +/*N*/ aFontItem = *(const SvxFontItem*)pItem; +/*N*/ if ( pCondSet->GetItemState( ATTR_CJK_FONT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CJK_FONT ); +/*N*/ aCjkFontItem = *(const SvxFontItem*)pItem; +/*N*/ if ( pCondSet->GetItemState( ATTR_CTL_FONT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CTL_FONT ); +/*N*/ aCtlFontItem = *(const SvxFontItem*)pItem; +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_HEIGHT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_HEIGHT ); +/*N*/ nTHeight = ((const SvxFontHeightItem*)pItem)->GetHeight(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CJK_FONT_HEIGHT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CJK_FONT_HEIGHT ); +/*N*/ nCjkTHeight = ((const SvxFontHeightItem*)pItem)->GetHeight(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CTL_FONT_HEIGHT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CTL_FONT_HEIGHT ); +/*N*/ nCtlTHeight = ((const SvxFontHeightItem*)pItem)->GetHeight(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_WEIGHT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_WEIGHT ); +/*N*/ eWeight = (FontWeight)((const SvxWeightItem*)pItem)->GetValue(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CJK_FONT_WEIGHT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CJK_FONT_WEIGHT ); +/*N*/ eCjkWeight = (FontWeight)((const SvxWeightItem*)pItem)->GetValue(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CTL_FONT_WEIGHT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CTL_FONT_WEIGHT ); +/*N*/ eCtlWeight = (FontWeight)((const SvxWeightItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_POSTURE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_POSTURE ); +/*N*/ eItalic = (FontItalic)((const SvxPostureItem*)pItem)->GetValue(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CJK_FONT_POSTURE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CJK_FONT_POSTURE ); +/*N*/ eCjkItalic = (FontItalic)((const SvxPostureItem*)pItem)->GetValue(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CTL_FONT_POSTURE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CTL_FONT_POSTURE ); +/*N*/ eCtlItalic = (FontItalic)((const SvxPostureItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_UNDERLINE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_UNDERLINE ); +/*N*/ aUnderlineItem = *(const SvxUnderlineItem*)pItem; +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_WORDLINE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_WORDLINE ); +/*N*/ bWordLine = ((const SvxWordLineModeItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_CROSSEDOUT, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_CROSSEDOUT ); +/*N*/ eStrike = (FontStrikeout)((const SvxCrossedOutItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_CONTOUR, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_CONTOUR ); +/*N*/ bOutline = ((const SvxContourItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_SHADOWED, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_SHADOWED ); +/*N*/ bShadow = ((const SvxShadowedItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FORBIDDEN_RULES, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FORBIDDEN_RULES ); +/*N*/ bForbidden = ((const SvxForbiddenRuleItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_EMPHASISMARK, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_EMPHASISMARK ); +/*N*/ eEmphasis = ((const SvxEmphasisMarkItem*)pItem)->GetEmphasisMark(); +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_RELIEF, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_RELIEF ); +/*N*/ eRelief = (FontRelief)((const SvxCharReliefItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_FONT_LANGUAGE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_FONT_LANGUAGE ); +/*N*/ eLang = ((const SvxLanguageItem*)pItem)->GetLanguage(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CJK_FONT_LANGUAGE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CJK_FONT_LANGUAGE ); +/*N*/ eCjkLang = ((const SvxLanguageItem*)pItem)->GetLanguage(); +/*N*/ if ( pCondSet->GetItemState( ATTR_CTL_FONT_LANGUAGE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_CTL_FONT_LANGUAGE ); +/*N*/ eCtlLang = ((const SvxLanguageItem*)pItem)->GetLanguage(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_HYPHENATE, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_HYPHENATE ); +/*N*/ bHyphenate = ((const SfxBoolItem*)pItem)->GetValue(); +/*N*/ +/*N*/ if ( pCondSet->GetItemState( ATTR_WRITINGDIR, TRUE, &pItem ) != SFX_ITEM_SET ) +/*N*/ pItem = &rSrcSet.Get( ATTR_WRITINGDIR ); +/*N*/ eDirection = (SvxFrameDirection)((const SvxFrameDirectionItem*)pItem)->GetValue(); +/*N*/ } +/*N*/ else // alles direkt aus Pattern +/*N*/ { +/*N*/ aColorItem = (const SvxColorItem&) rSrcSet.Get( ATTR_FONT_COLOR ); +/*N*/ aFontItem = (const SvxFontItem&) rSrcSet.Get( ATTR_FONT ); +/*N*/ aCjkFontItem = (const SvxFontItem&) rSrcSet.Get( ATTR_CJK_FONT ); +/*N*/ aCtlFontItem = (const SvxFontItem&) rSrcSet.Get( ATTR_CTL_FONT ); +/*N*/ nTHeight = ((const SvxFontHeightItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_HEIGHT )).GetHeight(); +/*N*/ nCjkTHeight = ((const SvxFontHeightItem&) +/*N*/ rSrcSet.Get( ATTR_CJK_FONT_HEIGHT )).GetHeight(); +/*N*/ nCtlTHeight = ((const SvxFontHeightItem&) +/*N*/ rSrcSet.Get( ATTR_CTL_FONT_HEIGHT )).GetHeight(); +/*N*/ eWeight = (FontWeight)((const SvxWeightItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_WEIGHT )).GetValue(); +/*N*/ eCjkWeight = (FontWeight)((const SvxWeightItem&) +/*N*/ rSrcSet.Get( ATTR_CJK_FONT_WEIGHT )).GetValue(); +/*N*/ eCtlWeight = (FontWeight)((const SvxWeightItem&) +/*N*/ rSrcSet.Get( ATTR_CTL_FONT_WEIGHT )).GetValue(); +/*N*/ eItalic = (FontItalic)((const SvxPostureItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_POSTURE )).GetValue(); +/*N*/ eCjkItalic = (FontItalic)((const SvxPostureItem&) +/*N*/ rSrcSet.Get( ATTR_CJK_FONT_POSTURE )).GetValue(); +/*N*/ eCtlItalic = (FontItalic)((const SvxPostureItem&) +/*N*/ rSrcSet.Get( ATTR_CTL_FONT_POSTURE )).GetValue(); +/*N*/ aUnderlineItem = (const SvxUnderlineItem&) rSrcSet.Get( ATTR_FONT_UNDERLINE ); +/*N*/ bWordLine = ((const SvxWordLineModeItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_WORDLINE )).GetValue(); +/*N*/ eStrike = (FontStrikeout)((const SvxCrossedOutItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_CROSSEDOUT )).GetValue(); +/*N*/ bOutline = ((const SvxContourItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_CONTOUR )).GetValue(); +/*N*/ bShadow = ((const SvxShadowedItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_SHADOWED )).GetValue(); +/*N*/ bForbidden = ((const SvxForbiddenRuleItem&) +/*N*/ rSrcSet.Get( ATTR_FORBIDDEN_RULES )).GetValue(); +/*N*/ eEmphasis = ((const SvxEmphasisMarkItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_EMPHASISMARK )).GetEmphasisMark(); +/*N*/ eRelief = (FontRelief)((const SvxCharReliefItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_RELIEF )).GetValue(); +/*N*/ eLang = ((const SvxLanguageItem&) +/*N*/ rSrcSet.Get( ATTR_FONT_LANGUAGE )).GetLanguage(); +/*N*/ eCjkLang = ((const SvxLanguageItem&) +/*N*/ rSrcSet.Get( ATTR_CJK_FONT_LANGUAGE )).GetLanguage(); +/*N*/ eCtlLang = ((const SvxLanguageItem&) +/*N*/ rSrcSet.Get( ATTR_CTL_FONT_LANGUAGE )).GetLanguage(); +/*N*/ bHyphenate = ((const SfxBoolItem&) +/*N*/ rSrcSet.Get( ATTR_HYPHENATE )).GetValue(); +/*N*/ eDirection = (SvxFrameDirection)((const SvxFrameDirectionItem&) +/*N*/ rSrcSet.Get( ATTR_WRITINGDIR )).GetValue(); +/*N*/ } +/*N*/ +/*N*/ // kompatibel zu LogicToLogic rechnen, also 2540/1440 = 127/72, und runden +/*N*/ +/*N*/ long nHeight = TwipsToHMM(nTHeight); +/*N*/ long nCjkHeight = TwipsToHMM(nCjkTHeight); +/*N*/ long nCtlHeight = TwipsToHMM(nCtlTHeight); +/*N*/ +/*N*/ // put items into EditEngine ItemSet +/*N*/ +/*N*/ if ( aColorItem.GetValue().GetColor() == COL_AUTO ) +/*N*/ { +/*N*/ // #108979# When cell attributes are converted to EditEngine paragraph attributes, +/*N*/ // don't create a hard item for automatic color, because that would be converted +/*N*/ // to black when the item's Store method is used in CreateTransferable/WriteBin. +/*N*/ // COL_AUTO is the EditEngine's pool default, so ClearItem will result in automatic +/*N*/ // color, too, without having to store the item. +/*N*/ rEditSet.ClearItem( EE_CHAR_COLOR ); +/*N*/ } +/*N*/ else +/*N*/ rEditSet.Put( aColorItem ); +/*N*/ rEditSet.Put( aFontItem ); +/*N*/ rEditSet.Put( aCjkFontItem ); +/*N*/ rEditSet.Put( aCtlFontItem ); +/*N*/ rEditSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) ); +/*N*/ rEditSet.Put( SvxFontHeightItem( nCjkHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) ); +/*N*/ rEditSet.Put( SvxFontHeightItem( nCtlHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) ); +/*N*/ rEditSet.Put( SvxWeightItem ( eWeight, EE_CHAR_WEIGHT ) ); +/*N*/ rEditSet.Put( SvxWeightItem ( eCjkWeight, EE_CHAR_WEIGHT_CJK ) ); +/*N*/ rEditSet.Put( SvxWeightItem ( eCtlWeight, EE_CHAR_WEIGHT_CTL ) ); +/*N*/ rEditSet.Put( aUnderlineItem ); +/*N*/ rEditSet.Put( SvxWordLineModeItem( bWordLine, EE_CHAR_WLM ) ); +/*N*/ rEditSet.Put( SvxCrossedOutItem( eStrike, EE_CHAR_STRIKEOUT ) ); +/*N*/ rEditSet.Put( SvxPostureItem ( eItalic, EE_CHAR_ITALIC ) ); +/*N*/ rEditSet.Put( SvxPostureItem ( eCjkItalic, EE_CHAR_ITALIC_CJK ) ); +/*N*/ rEditSet.Put( SvxPostureItem ( eCtlItalic, EE_CHAR_ITALIC_CTL ) ); +/*N*/ rEditSet.Put( SvxContourItem ( bOutline, EE_CHAR_OUTLINE ) ); +/*N*/ rEditSet.Put( SvxShadowedItem ( bShadow, EE_CHAR_SHADOW ) ); +/*N*/ rEditSet.Put( SfxBoolItem ( EE_PARA_FORBIDDENRULES, bForbidden ) ); +/*N*/ rEditSet.Put( SvxEmphasisMarkItem( eEmphasis, EE_CHAR_EMPHASISMARK ) ); +/*N*/ rEditSet.Put( SvxCharReliefItem( eRelief, EE_CHAR_RELIEF ) ); +/*N*/ rEditSet.Put( SvxLanguageItem ( eLang, EE_CHAR_LANGUAGE ) ); +/*N*/ rEditSet.Put( SvxLanguageItem ( eCjkLang, EE_CHAR_LANGUAGE_CJK ) ); +/*N*/ rEditSet.Put( SvxLanguageItem ( eCtlLang, EE_CHAR_LANGUAGE_CTL ) ); +/*N*/ rEditSet.Put( SfxBoolItem ( EE_PARA_HYPHENATE, bHyphenate ) ); +/*N*/ rEditSet.Put( SvxFrameDirectionItem( eDirection, EE_PARA_WRITINGDIR ) ); +/*N*/ } + +/*N*/ void ScPatternAttr::FillEditItemSet( SfxItemSet* pEditSet, const SfxItemSet* pCondSet ) const +/*N*/ { +/*N*/ if( pEditSet ) +/*N*/ FillToEditItemSet( *pEditSet, GetItemSet(), pCondSet ); +/*N*/ } + + +/*N*/ void ScPatternAttr::GetFromEditItemSet( SfxItemSet& rDestSet, const SfxItemSet& rEditSet ) +/*N*/ { +/*N*/ const SfxPoolItem* pItem; +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_COLOR,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxColorItem(ATTR_FONT_COLOR) = *(const SvxColorItem*)pItem ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_FONTINFO,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxFontItem(ATTR_FONT) = *(const SvxFontItem*)pItem ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_FONTINFO_CJK,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxFontItem(ATTR_CJK_FONT) = *(const SvxFontItem*)pItem ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_FONTINFO_CTL,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxFontItem(ATTR_CTL_FONT) = *(const SvxFontItem*)pItem ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_FONTHEIGHT,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxFontHeightItem( HMMToTwips( ((const SvxFontHeightItem*)pItem)->GetHeight() ), +/*N*/ 100, ATTR_FONT_HEIGHT ) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_FONTHEIGHT_CJK,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxFontHeightItem( HMMToTwips( ((const SvxFontHeightItem*)pItem)->GetHeight() ), +/*N*/ 100, ATTR_CJK_FONT_HEIGHT ) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_FONTHEIGHT_CTL,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxFontHeightItem( HMMToTwips( ((const SvxFontHeightItem*)pItem)->GetHeight() ), +/*N*/ 100, ATTR_CTL_FONT_HEIGHT ) ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_WEIGHT,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxWeightItem( (FontWeight)((const SvxWeightItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_WEIGHT) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_WEIGHT_CJK,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxWeightItem( (FontWeight)((const SvxWeightItem*)pItem)->GetValue(), +/*N*/ ATTR_CJK_FONT_WEIGHT) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_WEIGHT_CTL,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxWeightItem( (FontWeight)((const SvxWeightItem*)pItem)->GetValue(), +/*N*/ ATTR_CTL_FONT_WEIGHT) ); +/*N*/ +/*N*/ // SvxUnderlineItem contains enum and color +/*N*/ if (rEditSet.GetItemState(EE_CHAR_UNDERLINE,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxUnderlineItem(UNDERLINE_NONE,ATTR_FONT_UNDERLINE) = *(const SvxUnderlineItem*)pItem ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_WLM,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxWordLineModeItem( ((const SvxWordLineModeItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_WORDLINE) ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_STRIKEOUT,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxCrossedOutItem( (FontStrikeout)((const SvxCrossedOutItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_CROSSEDOUT) ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_ITALIC,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxPostureItem( (FontItalic)((const SvxPostureItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_POSTURE) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_ITALIC_CJK,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxPostureItem( (FontItalic)((const SvxPostureItem*)pItem)->GetValue(), +/*N*/ ATTR_CJK_FONT_POSTURE) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_ITALIC_CTL,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxPostureItem( (FontItalic)((const SvxPostureItem*)pItem)->GetValue(), +/*N*/ ATTR_CTL_FONT_POSTURE) ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_CHAR_OUTLINE,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxContourItem( ((const SvxContourItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_CONTOUR) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_SHADOW,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxShadowedItem( ((const SvxShadowedItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_SHADOWED) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_EMPHASISMARK,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxEmphasisMarkItem( ((const SvxEmphasisMarkItem*)pItem)->GetEmphasisMark(), +/*N*/ ATTR_FONT_EMPHASISMARK) ); +/*N*/ if (rEditSet.GetItemState(EE_CHAR_RELIEF,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ rDestSet.Put( SvxCharReliefItem( (FontRelief)((const SvxCharReliefItem*)pItem)->GetValue(), +/*N*/ ATTR_FONT_RELIEF) ); +/*N*/ +/*N*/ if (rEditSet.GetItemState(EE_PARA_JUST,TRUE,&pItem) == SFX_ITEM_SET) +/*N*/ { +/*N*/ SvxCellHorJustify eVal; +/*N*/ switch ( ((const SvxAdjustItem*)pItem)->GetAdjust() ) +/*N*/ { +/*N*/ case SVX_ADJUST_LEFT: +/*N*/ // #30154# EditEngine Default ist bei dem GetAttribs() ItemSet +/*N*/ // immer gesetzt! +/*N*/ // ob links oder rechts entscheiden wir selbst bei Text/Zahl +/*N*/ eVal = SVX_HOR_JUSTIFY_STANDARD; +/*N*/ break; +/*N*/ case SVX_ADJUST_RIGHT: +/*N*/ eVal = SVX_HOR_JUSTIFY_RIGHT; +/*N*/ break; +/*N*/ case SVX_ADJUST_BLOCK: +/*N*/ eVal = SVX_HOR_JUSTIFY_BLOCK; +/*N*/ break; +/*N*/ case SVX_ADJUST_CENTER: +/*N*/ eVal = SVX_HOR_JUSTIFY_CENTER; +/*N*/ break; +/*N*/ case SVX_ADJUST_BLOCKLINE: +/*N*/ eVal = SVX_HOR_JUSTIFY_BLOCK; +/*N*/ break; +/*N*/ case SVX_ADJUST_END: +/*N*/ eVal = SVX_HOR_JUSTIFY_RIGHT; +/*N*/ break; +/*N*/ default: +/*N*/ eVal = SVX_HOR_JUSTIFY_STANDARD; +/*N*/ } +/*N*/ if ( eVal != SVX_HOR_JUSTIFY_STANDARD ) +/*N*/ rDestSet.Put( SvxHorJustifyItem( eVal, ATTR_HOR_JUSTIFY) ); +/*N*/ } +/*N*/ } + +/*N*/ void ScPatternAttr::GetFromEditItemSet( const SfxItemSet* pEditSet ) +/*N*/ { +/*N*/ if( pEditSet ) +/*N*/ GetFromEditItemSet( GetItemSet(), *pEditSet ); +/*N*/ } + +/*N*/ void ScPatternAttr::FillEditParaItems( SfxItemSet* pEditSet ) const +/*N*/ { +/*N*/ // in GetFromEditItemSet schon dabei, in FillEditItemSet aber nicht +/*N*/ // Hor. Ausrichtung Standard wird immer als "links" umgesetzt +/*N*/ +/*N*/ const SfxItemSet& rMySet = GetItemSet(); +/*N*/ +/*N*/ SvxCellHorJustify eHorJust = (SvxCellHorJustify) +/*N*/ ((const SvxHorJustifyItem&)rMySet.Get(ATTR_HOR_JUSTIFY)).GetValue(); +/*N*/ +/*N*/ SvxAdjust eSvxAdjust; +/*N*/ switch (eHorJust) +/*N*/ { +/*N*/ case SVX_HOR_JUSTIFY_RIGHT: eSvxAdjust = SVX_ADJUST_RIGHT; break; +/*N*/ case SVX_HOR_JUSTIFY_CENTER: eSvxAdjust = SVX_ADJUST_CENTER; break; +/*N*/ case SVX_HOR_JUSTIFY_BLOCK: eSvxAdjust = SVX_ADJUST_BLOCK; break; +/*N*/ default: eSvxAdjust = SVX_ADJUST_LEFT; break; +/*N*/ } +/*N*/ pEditSet->Put( SvxAdjustItem( eSvxAdjust, EE_PARA_JUST ) ); +/*N*/ } + +/*N*/ void ScPatternAttr::DeleteUnchanged( const ScPatternAttr* pOldAttrs ) +/*N*/ { +/*N*/ SfxItemSet& rThisSet = GetItemSet(); +/*N*/ const SfxItemSet& rOldSet = pOldAttrs->GetItemSet(); +/*N*/ +/*N*/ const SfxPoolItem* pThisItem; +/*N*/ const SfxPoolItem* pOldItem; +/*N*/ +/*N*/ for ( USHORT nWhich=ATTR_PATTERN_START; nWhich<=ATTR_PATTERN_END; nWhich++ ) +/*N*/ { +/*N*/ // only items that are set are interesting +/*N*/ if ( rThisSet.GetItemState( nWhich, FALSE, &pThisItem ) == SFX_ITEM_SET ) +/*N*/ { +/*N*/ SfxItemState eOldState = rOldSet.GetItemState( nWhich, TRUE, &pOldItem ); +/*N*/ if ( eOldState == SFX_ITEM_SET ) +/*N*/ { +/*?*/ // item is set in OldAttrs (or its parent) -> compare pointers +/*?*/ if ( pThisItem == pOldItem ) +/*?*/ rThisSet.ClearItem( nWhich ); +/*N*/ } +/*N*/ else if ( eOldState != SFX_ITEM_DONTCARE ) +/*N*/ { +/*N*/ // not set in OldAttrs -> compare item value to default item +/*N*/ if ( *pThisItem == rThisSet.GetPool()->GetDefaultItem( nWhich ) ) +/*N*/ rThisSet.ClearItem( nWhich ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScPatternAttr::HasItemsSet( const USHORT* pWhich ) const +/*N*/ { +/*N*/ const SfxItemSet& rSet = GetItemSet(); +/*N*/ for (USHORT i=0; pWhich[i]; i++) +/*N*/ if ( rSet.GetItemState( pWhich[i], FALSE ) == SFX_ITEM_SET ) +/*N*/ return TRUE; +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScPatternAttr::ClearItems( const USHORT* pWhich ) +/*N*/ { +/*N*/ SfxItemSet& rSet = GetItemSet(); +/*N*/ for (USHORT i=0; pWhich[i]; i++) +/*N*/ rSet.ClearItem(pWhich[i]); +/*N*/ } + +/*N*/ SfxStyleSheetBase* lcl_CopyStyleToPool +/*N*/ ( +/*N*/ SfxStyleSheetBase* pSrcStyle, +/*N*/ SfxStyleSheetBasePool* pSrcPool, +/*N*/ SfxStyleSheetBasePool* pDestPool +/*N*/ ) +/*N*/ { +/*N*/ if ( !pSrcStyle || !pDestPool || !pSrcPool ) +/*N*/ { +/*N*/ DBG_ERROR( "CopyStyleToPool: Invalid Arguments :-/" ); +/*N*/ return NULL; +/*N*/ } +/*N*/ +/*N*/ //-------------------------------------------------------- +/*N*/ +/*N*/ const String aStrSrcStyle = pSrcStyle->GetName(); +/*N*/ const SfxStyleFamily eFamily = pSrcStyle->GetFamily(); +/*N*/ SfxStyleSheetBase* pDestStyle = pDestPool->Find( aStrSrcStyle, eFamily ); +/*N*/ +/*N*/ if ( !pDestStyle ) +/*N*/ { +/*?*/ const String aStrParent = pSrcStyle->GetParent(); +/*?*/ +/*?*/ pDestStyle = &pDestPool->Make( aStrSrcStyle, eFamily, SFXSTYLEBIT_USERDEF ); +/*?*/ pDestStyle->GetItemSet().Put( pSrcStyle->GetItemSet() ); +/*?*/ +/*?*/ // ggF. abgeleitete Styles erzeugen, wenn nicht vorhanden: +/*?*/ +/*?*/ if ( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) != aStrParent && +/*?*/ aStrSrcStyle != aStrParent && +/*?*/ !pDestPool->Find( aStrParent, eFamily ) ) +/*?*/ { +/*?*/ lcl_CopyStyleToPool( pSrcPool->Find( aStrParent, eFamily ), +/*?*/ pSrcPool, pDestPool ); +/*?*/ } +/*?*/ +/*?*/ pDestStyle->SetParent( aStrParent ); +/*N*/ } +/*N*/ +/*N*/ return pDestStyle; +/*N*/ } + +/*N*/ ScPatternAttr* ScPatternAttr::PutInPool( ScDocument* pDestDoc, ScDocument* pSrcDoc ) const +/*N*/ { +/*N*/ const SfxItemSet* pSrcSet = &GetItemSet(); +/*N*/ +/*N*/ ScPatternAttr* pDestPattern = new ScPatternAttr(pDestDoc->GetPool()); +/*N*/ SfxItemSet* pDestSet = &pDestPattern->GetItemSet(); +/*N*/ +/*N*/ // Zellformatvorlage in anderes Dokument kopieren: +/*N*/ +/*N*/ if ( pDestDoc != pSrcDoc ) +/*N*/ { +/*N*/ DBG_ASSERT( pStyle, "Missing Pattern-Style! :-/" ); +/*N*/ +/*N*/ // wenn Vorlage im DestDoc vorhanden, dieses benutzen, sonst Style +/*N*/ // mit Parent-Vorlagen kopieren/ggF. erzeugen und dem DestDoc hinzufuegen +/*N*/ +/*N*/ SfxStyleSheetBase* pStyleCpy = lcl_CopyStyleToPool( pStyle, +/*N*/ pSrcDoc->GetStyleSheetPool(), +/*N*/ pDestDoc->GetStyleSheetPool() ); +/*N*/ +/*N*/ pDestPattern->SetStyleSheet( (ScStyleSheet*)pStyleCpy ); +/*N*/ } +/*N*/ +/*N*/ for ( USHORT nAttrId = ATTR_PATTERN_START; nAttrId <= ATTR_PATTERN_END; nAttrId++ ) +/*N*/ { +/*N*/ const SfxPoolItem* pSrcItem; +/*N*/ SfxItemState eItemState = pSrcSet->GetItemState( nAttrId, FALSE, &pSrcItem ); +/*N*/ if (eItemState==SFX_ITEM_ON) +/*N*/ { +/*N*/ SfxPoolItem* pNewItem = NULL; +/*N*/ +/*N*/ if ( nAttrId == ATTR_CONDITIONAL ) +/*N*/ { +/*?*/ // Bedingte Formate ins neue Dokument kopieren +/*?*/ +/*?*/ ULONG nNewIndex = 0; +/*?*/ ScConditionalFormatList* pSrcList = pSrcDoc->GetCondFormList(); +/*?*/ if ( pSrcList ) +/*?*/ { +/*?*/ ULONG nOldIndex = ((const SfxUInt32Item*)pSrcItem)->GetValue(); +/*?*/ const ScConditionalFormat* pOldData = pSrcList->GetFormat( nOldIndex ); +/*?*/ if ( pOldData ) +/*?*/ { +/*?*/ nNewIndex = pDestDoc->AddCondFormat( *pOldData ); +/*?*/ +/*?*/ // zugehoerige Styles auch mitkopieren +/*?*/ //! nur wenn Format bei Add neu angelegt +/*?*/ +/*?*/ ScStyleSheetPool* pSrcSPool = pSrcDoc->GetStyleSheetPool(); +/*?*/ ScStyleSheetPool* pDestSPool = pDestDoc->GetStyleSheetPool(); +/*?*/ USHORT nStlCnt = pOldData->Count(); +/*?*/ for (USHORT i=0; i<nStlCnt; i++) +/*?*/ { +/*?*/ String aName = pOldData->GetEntry(i)->GetStyle(); +/*?*/ SfxStyleSheetBase* pSrcStl = +/*?*/ pSrcDoc->GetStyleSheetPool()->Find(aName, SFX_STYLE_FAMILY_PARA); +/*?*/ lcl_CopyStyleToPool( pSrcStl, pSrcSPool, pDestSPool ); +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ pNewItem = new SfxUInt32Item( ATTR_CONDITIONAL, nNewIndex ); +/*N*/ } +/*N*/ else if ( nAttrId == ATTR_VALIDDATA ) +/*N*/ { +/*?*/ // Gueltigkeit ins neue Dokument kopieren +/*?*/ +/*?*/ ULONG nNewIndex = 0; +/*?*/ ScValidationDataList* pSrcList = pSrcDoc->GetValidationList(); +/*?*/ if ( pSrcList ) +/*?*/ { +/*?*/ ULONG nOldIndex = ((const SfxUInt32Item*)pSrcItem)->GetValue(); +/*?*/ const ScValidationData* pOldData = pSrcList->GetData( nOldIndex ); +/*?*/ if ( pOldData ) +/*?*/ nNewIndex = pDestDoc->AddValidationEntry( *pOldData ); +/*?*/ } +/*?*/ pNewItem = new SfxUInt32Item( ATTR_VALIDDATA, nNewIndex ); +/*N*/ } +/*N*/ else if ( nAttrId == ATTR_VALUE_FORMAT && pDestDoc->GetFormatExchangeList() ) +/*N*/ { +/*N*/ // Zahlformate nach Exchange-Liste +/*N*/ +/*N*/ ULONG nOldFormat = ((const SfxUInt32Item*)pSrcItem)->GetValue(); +/*N*/ ULONG* pNewFormat = (ULONG*)pDestDoc->GetFormatExchangeList()->Get(nOldFormat); +/*N*/ if (pNewFormat) +/*?*/ pNewItem = new SfxUInt32Item( ATTR_VALUE_FORMAT, (UINT32) (*pNewFormat) ); +/*N*/ } +/*N*/ +/*N*/ if ( pNewItem ) +/*N*/ { +/*?*/ pDestSet->Put(*pNewItem); +/*?*/ delete pNewItem; +/*N*/ } +/*N*/ else +/*N*/ pDestSet->Put(*pSrcItem); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ ScPatternAttr* pPatternAttr = +/*N*/ (ScPatternAttr*) &pDestDoc->GetPool()->Put(*pDestPattern); +/*N*/ delete pDestPattern; +/*N*/ return pPatternAttr; +/*N*/ } + +/*N*/ BOOL ScPatternAttr::IsVisible() const +/*N*/ { +/*N*/ const SfxItemSet& rSet = GetItemSet(); +/*N*/ const SfxItemPool* pPool = rSet.GetPool(); +/*N*/ +/*N*/ const SfxPoolItem* pItem; +/*N*/ SfxItemState eState; +/*N*/ +/*N*/ eState = rSet.GetItemState( ATTR_BACKGROUND, TRUE, &pItem ); +/*N*/ if ( eState == SFX_ITEM_SET ) +/*N*/ if ( ((SvxBrushItem*)pItem)->GetColor().GetColor() != COL_TRANSPARENT ) +/*N*/ return TRUE; +/*N*/ +/*N*/ eState = rSet.GetItemState( ATTR_BORDER, TRUE, &pItem ); +/*N*/ if ( eState == SFX_ITEM_SET ) +/*N*/ { +/*N*/ SvxBoxItem* pBoxItem = (SvxBoxItem*) pItem; +/*N*/ if ( pBoxItem->GetTop() || pBoxItem->GetBottom() || +/*N*/ pBoxItem->GetLeft() || pBoxItem->GetRight() ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ eState = rSet.GetItemState( ATTR_SHADOW, TRUE, &pItem ); +/*N*/ if ( eState == SFX_ITEM_SET ) +/*?*/ if ( ((SvxShadowItem*)pItem)->GetLocation() != SVX_SHADOW_NONE ) +/*?*/ return TRUE; +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +/*N*/ inline BOOL OneEqual( const SfxItemSet& rSet1, const SfxItemSet& rSet2, USHORT nId ) +/*N*/ { +/*N*/ const SfxPoolItem* pItem1 = &rSet1.Get(nId); +/*N*/ const SfxPoolItem* pItem2 = &rSet2.Get(nId); +/*N*/ return ( pItem1 == pItem2 || *pItem1 == *pItem2 ); +/*N*/ } + +/*N*/ BOOL ScPatternAttr::IsVisibleEqual( const ScPatternAttr& rOther ) const +/*N*/ { +/*N*/ const SfxItemSet& rThisSet = GetItemSet(); +/*N*/ const SfxItemSet& rOtherSet = rOther.GetItemSet(); +/*N*/ +/*N*/ return OneEqual( rThisSet, rOtherSet, ATTR_BACKGROUND ) && +/*N*/ OneEqual( rThisSet, rOtherSet, ATTR_BORDER ) && +/*N*/ OneEqual( rThisSet, rOtherSet, ATTR_SHADOW ); +/*N*/ +/*N*/ //! auch hier nur wirklich sichtbare Werte testen !!! +/*N*/ } + +/*N*/ const String* ScPatternAttr::GetStyleName() const +/*N*/ { +/*N*/ return pName ? pName : ( pStyle ? &pStyle->GetName() : NULL ); +/*N*/ } + + +/*N*/ void ScPatternAttr::SetStyleSheet( ScStyleSheet* pNewStyle ) +/*N*/ { +/*N*/ if (pNewStyle) +/*N*/ { +/*N*/ SfxItemSet& rPatternSet = GetItemSet(); +/*N*/ const SfxItemSet& rStyleSet = pNewStyle->GetItemSet(); +/*N*/ +/*N*/ for (USHORT i=ATTR_PATTERN_START; i<=ATTR_PATTERN_END; i++) +/*N*/ { +/*N*/ if (rStyleSet.GetItemState(i, TRUE) == SFX_ITEM_SET) +/*N*/ rPatternSet.ClearItem(i); +/*N*/ } +/*N*/ rPatternSet.SetParent(&pNewStyle->GetItemSet()); +/*N*/ pStyle = pNewStyle; +/*N*/ DELETEZ( pName ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR( "ScPatternAttr::SetStyleSheet( NULL ) :-|" ); +/*N*/ GetItemSet().SetParent(NULL); +/*N*/ pStyle = NULL; +/*N*/ } +/*N*/ } + +/*N*/ void ScPatternAttr::UpdateStyleSheet() +/*N*/ { +/*N*/ if (pName) +/*N*/ { +/*N*/ pStyle = (ScStyleSheet*)pDoc->GetStyleSheetPool()->Find(*pName, SFX_STYLE_FAMILY_PARA); +/*N*/ +/*N*/ // wenn Style nicht gefunden, Standard nehmen, +/*N*/ // damit keine leere Anzeige im Toolbox-Controller +/*N*/ //! es wird vorausgesetzt, dass "Standard" immer der erste Eintrag ist! +/*N*/ if (!pStyle) +/*N*/ { +/*N*/ SfxStyleSheetIterator* pIter = pDoc->GetStyleSheetPool()->CreateIterator( +/*N*/ SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_ALL ); +/*N*/ pStyle = (ScStyleSheet*)pIter->First(); +/*N*/ } +/*N*/ +/*N*/ if (pStyle) +/*N*/ { +/*N*/ GetItemSet().SetParent(&pStyle->GetItemSet()); +/*N*/ DELETEZ( pName ); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ pStyle = NULL; +/*N*/ } + + +/*N*/ BOOL ScPatternAttr::IsSymbolFont() const +/*N*/ { +/*N*/ const SfxPoolItem* pItem; +/*N*/ if( GetItemSet().GetItemState( ATTR_FONT, TRUE, &pItem ) == SFX_ITEM_SET ) +/*N*/ return BOOL( ((const SvxFontItem*) pItem)->GetCharSet() +/*N*/ == RTL_TEXTENCODING_SYMBOL ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ FontToSubsFontConverter ScPatternAttr::GetSubsFontConverter( ULONG nFlags ) const +/*N*/ { +/*N*/ const SfxPoolItem* pItem; +/*N*/ if( GetItemSet().GetItemState( ATTR_FONT, TRUE, &pItem ) == SFX_ITEM_SET ) +/*N*/ return CreateFontToSubsFontConverter( +/*N*/ ((const SvxFontItem*) pItem)->GetFamilyName(), nFlags ); +/*N*/ else +/*N*/ return 0; +/*N*/ } + + +/*N*/ ULONG ScPatternAttr::GetNumberFormat( SvNumberFormatter* pFormatter ) const +/*N*/ { +/*N*/ ULONG nFormat = +/*N*/ ((SfxUInt32Item*)&GetItemSet().Get( ATTR_VALUE_FORMAT ))->GetValue(); +/*N*/ LanguageType eLang = +/*N*/ ((SvxLanguageItem*)&GetItemSet().Get( ATTR_LANGUAGE_FORMAT ))->GetLanguage(); +/*N*/ if ( nFormat < SV_COUNTRY_LANGUAGE_OFFSET && eLang == LANGUAGE_SYSTEM ) +/*N*/ ; // es bleibt wie es ist +/*N*/ else if ( pFormatter ) +/*N*/ nFormat = pFormatter->GetFormatForLanguageIfBuiltIn( nFormat, eLang ); +/*N*/ return nFormat; +/*N*/ } + +// dasselbe, wenn bedingte Formatierung im Spiel ist: + +/*N*/ ULONG ScPatternAttr::GetNumberFormat( SvNumberFormatter* pFormatter, +/*N*/ const SfxItemSet* pCondSet ) const +/*N*/ { +/*N*/ DBG_ASSERT(pFormatter,"GetNumberFormat ohne Formatter"); +/*N*/ +/*N*/ const SfxPoolItem* pFormItem; +/*N*/ if ( !pCondSet || pCondSet->GetItemState(ATTR_VALUE_FORMAT,TRUE,&pFormItem) != SFX_ITEM_SET ) +/*N*/ pFormItem = &GetItemSet().Get(ATTR_VALUE_FORMAT); +/*N*/ +/*N*/ const SfxPoolItem* pLangItem; +/*N*/ if ( !pCondSet || pCondSet->GetItemState(ATTR_LANGUAGE_FORMAT,TRUE,&pLangItem) != SFX_ITEM_SET ) +/*N*/ pLangItem = &GetItemSet().Get(ATTR_LANGUAGE_FORMAT); +/*N*/ +/*N*/ return pFormatter->GetFormatForLanguageIfBuiltIn( +/*N*/ ((SfxUInt32Item*)pFormItem)->GetValue(), +/*N*/ ((SvxLanguageItem*)pLangItem)->GetLanguage() ); +/*N*/ } + +/*N*/ const SfxPoolItem& ScPatternAttr::GetItem( USHORT nWhich, const SfxItemSet* pCondSet ) const +/*N*/ { +/*N*/ const SfxPoolItem* pCondItem; +/*N*/ if ( pCondSet && pCondSet->GetItemState( nWhich, TRUE, &pCondItem ) == SFX_ITEM_SET ) +/*?*/ return *pCondItem; +/*N*/ +/*N*/ return GetItemSet().Get(nWhich); +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_pivot.cxx b/binfilter/bf_sc/source/core/data/sc_pivot.cxx new file mode 100644 index 000000000000..b77191660776 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_pivot.cxx @@ -0,0 +1,1313 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// ----------------------------------------------------------------------- + +#ifdef _MSC_VER +#pragma optimize("",off) +#endif +#ifdef _MSC_VER +#pragma optimize("q",off) // p-code off +#endif + + +// INCLUDE --------------------------------------------------------------- + +#include <tools/solar.h> +#include <string.h> +#include <math.h> + + +#include "globstr.hrc" +#include "subtotal.hxx" +#include "docpool.hxx" +#include "document.hxx" +#include "userlist.hxx" +#include "pivot.hxx" +#include "cell.hxx" +#include "rechead.hxx" +namespace binfilter { + + +// STATIC DATA ----------------------------------------------------------- + +//! bei Gelegenheit... + +static short nStaticStrRefCount = 0; +static String* pLabel[PIVOT_MAXFUNC+1]; // incl. "auto" +static String* pLabelTotal; +static String* pLabelData; + +static USHORT nDataMult = 1; + +#define nFirstLine 2 + +static const USHORT nFuncMaskArr[PIVOT_MAXFUNC+1] = + { PIVOT_FUNC_SUM, + PIVOT_FUNC_COUNT, + PIVOT_FUNC_AVERAGE, + PIVOT_FUNC_MAX, + PIVOT_FUNC_MIN, + PIVOT_FUNC_PRODUCT, + PIVOT_FUNC_COUNT_NUM, + PIVOT_FUNC_STD_DEV, + PIVOT_FUNC_STD_DEVP, + PIVOT_FUNC_STD_VAR, + PIVOT_FUNC_STD_VARP, + PIVOT_FUNC_AUTO }; // automatisch + +// ----------------------------------------------------------------------- + +// 1 Filter-Knopf +// 2 Feldnamen links +// 3 "Daten" links +// 4 Feldnamen oben +// 5 "Daten" oben +// 6 einzelne "Gesamt" oben rechts +// 7 "Gesamt" oben rechts +// 8 einzelne "Gesamt" unten links +// 9 "Gesamt" unten links +// 10 innere Kategorie links +// 11 Teilergebnis Label einzeln links +// 12 Teilergebnis Label gesamt links +// 13 letzte Kategorie links +// 14 innere Kategorie oben +// 15 Teilergebnis Label einzeln oben +// 16 Teilergebnis Label gesamt oben +// 17 letzte Kategorie oben +// 18 Werte innen +// 19 Werte in Teilergebnisspalte +// 20 Werte in Gesamt-Spalte +// 21 Werte in einzelnen Gesamt-Spalten +// 22 Werte in Ergebnis-Zeile Teilergebnis oder Gesamt +// 23 Kreuzung von Spalte/Zeile (Teilergebnis-Spalte) +// 24 Kreuzung von Spalte/Zeile (Gesamt-Spalte) +// 25 wie 24 bei einzelnen "Gesamt" + + + +/*N*/ ScPivot::ScPivot(ScDocument* pDocument) : +/*N*/ pDoc (pDocument), +/*N*/ aQuery (), +/*N*/ bHasHeader (FALSE), +/*N*/ bIgnoreEmpty (FALSE), +/*N*/ bDetectCat (FALSE), +/*N*/ bMakeTotalCol (TRUE), +/*N*/ bMakeTotalRow (TRUE), +/*N*/ nColNameCount (0), +/*N*/ pColNames (NULL), +/*N*/ nSrcCol1 (0), +/*N*/ nSrcRow1 (0), +/*N*/ nSrcCol2 (0), +/*N*/ nSrcRow2 (0), +/*N*/ nSrcTab (0), +/*N*/ nDestCol1 (0), +/*N*/ nDestRow1 (0), +/*N*/ nDestCol2 (0), +/*N*/ nDestRow2 (0), +/*N*/ nDestTab (0), +/*N*/ nDataStartCol (0), +/*N*/ nDataStartRow (0), +/*N*/ nColCount (0), +/*N*/ nRowCount (0), +/*N*/ nDataCount (0), +/*N*/ bValidArea (FALSE), +/*N*/ bDataAtCol (FALSE) +/*N*/ { +/*N*/ short i; +/*N*/ for (i=0; i<PIVOT_MAXFIELD; i++) +/*N*/ { +/*N*/ pColList[i] = new PivotStrCollection(); +/*N*/ pRowList[i] = new PivotStrCollection(); +/*N*/ } +/*N*/ pDataList = pColList[0]; +/*N*/ ppDataArr = NULL; +/*N*/ nDataColCount = 0; +/*N*/ nDataRowCount = 0; +/*N*/ nRecCount = 0; +/*N*/ pColRef = NULL; +/*N*/ +/*N*/ // Initialisierung der statischen Strings, wenn noetig +/*N*/ nStaticStrRefCount += 1; +/*N*/ if ( nStaticStrRefCount < 2 ) +/*N*/ { +/*N*/ pLabelTotal = new String( ScGlobal::GetRscString(STR_PIVOT_TOTAL) ); +/*N*/ pLabelData = new String( ScGlobal::GetRscString(STR_PIVOT_DATA) ); +/*N*/ +/*N*/ for ( i=0; i<=PIVOT_MAXFUNC; i++ ) // incl. "auto" +/*N*/ pLabel[i] = new String; // kein Leerzeichen +/*N*/ +/*N*/ *pLabel[ 0] = ScGlobal::GetRscString(STR_FUN_TEXT_SUM); +/*N*/ *pLabel[ 1] = ScGlobal::GetRscString(STR_FUN_TEXT_COUNT); +/*N*/ *pLabel[ 2] = ScGlobal::GetRscString(STR_FUN_TEXT_AVG); +/*N*/ *pLabel[ 3] = ScGlobal::GetRscString(STR_FUN_TEXT_MAX); +/*N*/ *pLabel[ 4] = ScGlobal::GetRscString(STR_FUN_TEXT_MIN); +/*N*/ *pLabel[ 5] = ScGlobal::GetRscString(STR_FUN_TEXT_PRODUCT); +/*N*/ *pLabel[ 6] = ScGlobal::GetRscString(STR_FUN_TEXT_COUNT); // Count2 +/*N*/ *pLabel[ 7] = ScGlobal::GetRscString(STR_FUN_TEXT_STDDEV); +/*N*/ *pLabel[ 8] = ScGlobal::GetRscString(STR_FUN_TEXT_STDDEV); // Stddev2 +/*N*/ *pLabel[ 9] = ScGlobal::GetRscString(STR_FUN_TEXT_VAR); +/*N*/ *pLabel[10] = ScGlobal::GetRscString(STR_FUN_TEXT_VAR); // Var2 +/*N*/ *pLabel[11] = ScGlobal::GetRscString(STR_TABLE_ERGEBNIS); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ ScPivot::ScPivot(const ScPivot& rPivot): +/*N*/ pDoc (rPivot.pDoc), +/*N*/ aQuery (rPivot.aQuery), +/*N*/ bHasHeader (rPivot.bHasHeader), +/*N*/ bIgnoreEmpty (rPivot.bIgnoreEmpty), +/*N*/ bDetectCat (rPivot.bDetectCat), +/*N*/ bMakeTotalCol (rPivot.bMakeTotalCol), +/*N*/ bMakeTotalRow (rPivot.bMakeTotalRow), +/*N*/ nColNameCount (0), +/*N*/ pColNames (NULL), +/*N*/ aName (rPivot.aName), +/*N*/ aTag (rPivot.aTag), +/*N*/ nSrcCol1 (rPivot.nSrcCol1), +/*N*/ nSrcRow1 (rPivot.nSrcRow1), +/*N*/ nSrcCol2 (rPivot.nSrcCol2), +/*N*/ nSrcRow2 (rPivot.nSrcRow2), +/*N*/ nSrcTab (rPivot.nSrcTab), +/*N*/ nDestCol1 (rPivot.nDestCol1), +/*N*/ nDestRow1 (rPivot.nDestRow1), +/*N*/ nDestCol2 (rPivot.nDestCol2), +/*N*/ nDestRow2 (rPivot.nDestRow2), +/*N*/ nDestTab (rPivot.nDestTab), +/*N*/ nDataStartCol (0), +/*N*/ nDataStartRow (0), +/*N*/ nColCount (0), +/*N*/ nRowCount (0), +/*N*/ nDataCount (0), +/*N*/ bValidArea (FALSE), +/*N*/ bDataAtCol (FALSE) +/*N*/ { +/*N*/ if (rPivot.nColNameCount && rPivot.pColNames) +/*N*/ { +/*N*/ nColNameCount = rPivot.nColNameCount; +/*N*/ pColNames = new String[nColNameCount]; +/*N*/ for (USHORT nCol=0; nCol<nColNameCount; nCol++) +/*N*/ pColNames[nCol] = rPivot.pColNames[nCol]; +/*N*/ } +/*N*/ +/*N*/ short i; +/*N*/ for (i=0; i<PIVOT_MAXFIELD; i++) +/*N*/ { +/*N*/ pColList[i] = new PivotStrCollection(); +/*N*/ pRowList[i] = new PivotStrCollection(); +/*N*/ } +/*N*/ pDataList = pColList[0]; +/*N*/ ppDataArr = NULL; +/*N*/ nRecCount = 0; +/*N*/ pColRef = NULL; +/*N*/ +/*N*/ SetColFields( rPivot.aColArr, rPivot.nColCount ); +/*N*/ SetRowFields( rPivot.aRowArr, rPivot.nRowCount ); +/*N*/ SetDataFields( rPivot.aDataArr, rPivot.nDataCount ); +/*N*/ +/*N*/ nStaticStrRefCount += 1; +/*N*/ } + +/*N*/ ScPivot::~ScPivot() +/*N*/ { +/*N*/ short i; +/*N*/ for (i=0; i<PIVOT_MAXFIELD; i++) +/*N*/ { +/*N*/ delete pColList[i]; +/*N*/ delete pRowList[i]; +/*N*/ } +/*N*/ if (ppDataArr) +/*N*/ { +/*N*/ for (i=0; i<nDataRowCount; i++) +/*N*/ delete[] ppDataArr[i]; +/*N*/ delete[] ppDataArr; +/*N*/ ppDataArr = NULL; +/*N*/ } +/*N*/ delete[] pColRef; +/*N*/ +/*N*/ delete[] pColNames; +/*N*/ +/*N*/ // statische Strings ggF. wieder abraeumen +/*N*/ nStaticStrRefCount -= 1; +/*N*/ if ( nStaticStrRefCount == 0 ) +/*N*/ { +/*N*/ delete pLabelTotal; +/*N*/ delete pLabelData; +/*N*/ +/*N*/ for ( i=0; i<=PIVOT_MAXFUNC; i++ ) // incl. "auto" +/*N*/ delete pLabel[i]; +/*N*/ } +/*N*/ } + + +/*N*/ void lcl_LoadFieldArr30( SvStream& rStream, PivotField* pField, USHORT nCount ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ rStream >> pField[i].nCol +/*N*/ >> pField[i].nFuncMask +/*N*/ >> pField[i].nFuncCount; +/*N*/ } +/*N*/ } + +/*N*/ void lcl_LoadFieldArr( SvStream& rStream, PivotField* pField, USHORT nCount ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ if( cData & 0x0F ) +/*N*/ rStream.SeekRel( cData & 0x0F ); +/*N*/ rStream >> pField[i].nCol +/*N*/ >> pField[i].nFuncMask +/*N*/ >> pField[i].nFuncCount; +/*N*/ } +/*N*/ } + +/*N*/ void lcl_SaveFieldArr( SvStream& rStream, const PivotField* pField, USHORT nCount ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ rStream << (BYTE) 0x00 +/*N*/ << pField[i].nCol +/*N*/ << pField[i].nFuncMask +/*N*/ << pField[i].nFuncCount; +/*N*/ } +/*N*/ } + +// nach Load muessen Daten neu berechnet werden ! + +/*N*/ BOOL ScPivot::Load( SvStream& rStream, ScMultipleReadHeader& rHdr ) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream >> bHasHeader +/*N*/ +/*N*/ >> nSrcCol1 +/*N*/ >> nSrcRow1 +/*N*/ >> nSrcCol2 +/*N*/ >> nSrcRow2 +/*N*/ >> nSrcTab +/*N*/ +/*N*/ >> nDestCol1 +/*N*/ >> nDestRow1 +/*N*/ >> nDestCol2 +/*N*/ >> nDestRow2 +/*N*/ >> nDestTab; +/*N*/ +/*N*/ // Arrays immer ueber Set...Fields initalisieren! +/*N*/ +/*N*/ short nCount; +/*N*/ PivotFieldArr aFieldArr; +/*N*/ +/*N*/ if( pDoc->GetSrcVersion() >= SC_DATABYTES2 ) +/*N*/ { +/*N*/ rStream >> nCount; +/*N*/ lcl_LoadFieldArr( rStream, aFieldArr, nCount ); +/*N*/ SetColFields(aFieldArr, nCount); +/*N*/ +/*N*/ rStream >> nCount; +/*N*/ lcl_LoadFieldArr( rStream, aFieldArr, nCount ); +/*N*/ SetRowFields(aFieldArr, nCount); +/*N*/ +/*N*/ rStream >> nCount; +/*N*/ lcl_LoadFieldArr( rStream, aFieldArr, nCount ); +/*N*/ SetDataFields(aFieldArr, nCount); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rStream >> nCount; +/*N*/ lcl_LoadFieldArr30( rStream, aFieldArr, nCount ); +/*N*/ SetColFields(aFieldArr, nCount); +/*N*/ +/*N*/ rStream >> nCount; +/*N*/ lcl_LoadFieldArr30( rStream, aFieldArr, nCount ); +/*N*/ SetRowFields(aFieldArr, nCount); +/*N*/ +/*N*/ rStream >> nCount; +/*N*/ lcl_LoadFieldArr30( rStream, aFieldArr, nCount ); +/*N*/ SetDataFields(aFieldArr, nCount); +/*N*/ } +/*N*/ +/*N*/ aQuery.Load( rStream ); +/*N*/ +/*N*/ rStream >> bIgnoreEmpty; +/*N*/ rStream >> bDetectCat; +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ { +/*N*/ rStream >> bMakeTotalCol; // ab 355i +/*N*/ rStream >> bMakeTotalRow; +/*N*/ } +/*N*/ +/*N*/ if (rHdr.BytesLeft()) // ab 500a +/*N*/ { +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aTag, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ DBG_ASSERT(!pColNames, "Spaltennamen schon gesetzt?"); +/*N*/ rStream >> nColNameCount; +/*N*/ if (nColNameCount) +/*N*/ { +/*N*/ pColNames = new String[nColNameCount]; +/*N*/ for (USHORT nCol=0; nCol<nColNameCount; nCol++) +/*N*/ rStream.ReadByteString( pColNames[nCol], rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ } +/*N*/ // sonst wird hinterher aus ScPivotCollection::Load ein Name vergeben +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScPivot::Store( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream << bHasHeader +/*N*/ +/*N*/ << nSrcCol1 +/*N*/ << nSrcRow1 +/*N*/ << nSrcCol2 +/*N*/ << nSrcRow2 +/*N*/ << nSrcTab +/*N*/ +/*N*/ << nDestCol1 +/*N*/ << nDestRow1 +/*N*/ << nDestCol2 +/*N*/ << nDestRow2 +/*N*/ << nDestTab +/*N*/ +/*N*/ << nColCount; +/*N*/ lcl_SaveFieldArr( rStream, aColArr, nColCount ); +/*N*/ rStream << nRowCount; +/*N*/ lcl_SaveFieldArr( rStream, aRowArr, nRowCount ); +/*N*/ rStream << nDataCount; +/*N*/ lcl_SaveFieldArr( rStream, aDataArr, nDataCount ); +/*N*/ +/*N*/ aQuery.Store( rStream ); +/*N*/ +/*N*/ rStream << bIgnoreEmpty; +/*N*/ rStream << bDetectCat; +/*N*/ +/*N*/ rStream << bMakeTotalCol; // ab 355i +/*N*/ rStream << bMakeTotalRow; +/*N*/ +/*N*/ if( rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) // Name/Tag/Spalten ab 5.0 +/*N*/ { +/*N*/ rStream.WriteByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aTag, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ if (!pColNames) ((ScPivot*)this)->nColNameCount = 0; // soll nicht sein +/*N*/ rStream << nColNameCount; +/*N*/ for (USHORT nCol=0; nCol<nColNameCount; nCol++) +/*N*/ rStream.WriteByteString( pColNames[nCol], rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } + +/*N*/ void ScPivot::SetQuery(const ScQueryParam& rQuery) +/*N*/ { +/*N*/ aQuery = rQuery; +/*N*/ +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ void ScPivot::GetQuery(ScQueryParam& rQuery) const +/*N*/ { +/*N*/ rQuery = aQuery; +/*N*/ } + +/*N*/ void ScPivot::SetHeader(BOOL bHeader) +/*N*/ { +/*N*/ bHasHeader = bHeader; +/*N*/ bValidArea = FALSE; +/*N*/ } + + +/*N*/ void ScPivot::SetIgnoreEmpty(BOOL bIgnore) +/*N*/ { +/*N*/ bIgnoreEmpty = bIgnore; +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ BOOL ScPivot::GetIgnoreEmpty() const +/*N*/ { +/*N*/ return bIgnoreEmpty; +/*N*/ } + +/*N*/ void ScPivot::SetDetectCat(BOOL bDetect) +/*N*/ { +/*N*/ bDetectCat = bDetect; +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ BOOL ScPivot::GetDetectCat() const +/*N*/ { +/*N*/ return bDetectCat; +/*N*/ } + +/*N*/ void ScPivot::SetMakeTotalCol(BOOL bSet) +/*N*/ { +/*N*/ bMakeTotalCol = bSet; +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ BOOL ScPivot::GetMakeTotalCol() const +/*N*/ { +/*N*/ return bMakeTotalCol; +/*N*/ } + +/*N*/ void ScPivot::SetMakeTotalRow(BOOL bSet) +/*N*/ { +/*N*/ bMakeTotalRow = bSet; +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ BOOL ScPivot::GetMakeTotalRow() const +/*N*/ { +/*N*/ return bMakeTotalRow; +/*N*/ } + +/*N*/ void ScPivot::SetName(const String& rNew) +/*N*/ { +/*N*/ aName = rNew; +/*N*/ } + +/*N*/ const String& ScPivot::GetName() const +/*N*/ { +/*N*/ return aName; +/*N*/ } + +/*N*/ void ScPivot::SetTag(const String& rNew) +/*N*/ { +/*N*/ aTag = rNew; +/*N*/ } + +/*N*/ const String& ScPivot::GetTag() const +/*N*/ { +/*N*/ return aTag; +/*N*/ } + +/*N*/ void ScPivot::SetSrcArea(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, USHORT nTab) +/*N*/ { +/*N*/ nSrcCol1 = Min(nCol1, (USHORT)MAXCOL); +/*N*/ nSrcRow1 = Min(nRow1, (USHORT)MAXROW); +/*N*/ nSrcCol2 = Min(nCol2, (USHORT)MAXCOL); +/*N*/ nSrcRow2 = Min(nRow2, (USHORT)MAXROW); +/*N*/ nSrcTab = nTab; +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ void ScPivot::GetSrcArea(USHORT& rCol1, USHORT& rRow1, USHORT& rCol2, USHORT& rRow2, USHORT& rTab) const +/*N*/ { +/*N*/ rCol1 = nSrcCol1; +/*N*/ rRow1 = nSrcRow1; +/*N*/ rCol2 = nSrcCol2; +/*N*/ rRow2 = nSrcRow2; +/*N*/ rTab = nSrcTab; +/*N*/ } + +/*N*/ ScRange ScPivot::GetSrcArea() const +/*N*/ { +/*N*/ return ScRange( nSrcCol1,nSrcRow1,nSrcTab, nSrcCol2,nSrcRow2,nSrcTab ); +/*N*/ } + +/*N*/ void ScPivot::SetDestPos(USHORT nCol, USHORT nRow, USHORT nTab) +/*N*/ { +/*N*/ nDestCol1 = nCol; +/*N*/ nDestRow1 = nRow; +/*N*/ nDestTab = nTab; +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ void ScPivot::GetDestArea(USHORT& rCol1, USHORT& rRow1, USHORT& rCol2, USHORT& rRow2, USHORT& rTab) const +/*N*/ { +/*N*/ rCol1 = nDestCol1; +/*N*/ rRow1 = nDestRow1; +/*N*/ rTab = nDestTab; +/*N*/ if (bValidArea) +/*N*/ { +/*N*/ rCol2 = nDestCol2; +/*N*/ rRow2 = nDestRow2; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rCol2 = nDestCol1; +/*N*/ rRow2 = nDestRow1; +/*N*/ } +/*N*/ } + +/*N*/ ScRange ScPivot::GetDestArea() const +/*N*/ { +/*N*/ ScAddress aStart( nDestCol1, nDestRow1, nDestTab ); +/*N*/ ScAddress aEnd = aStart; +/*N*/ if ( bValidArea ) +/*N*/ aEnd = ScAddress( nDestCol2, nDestRow2, nDestTab ); +/*N*/ return ScRange( aStart, aEnd ); +/*N*/ } + +/*N*/ void ScPivot::MoveSrcArea( USHORT nNewCol, USHORT nNewRow, USHORT nNewTab ) +/*N*/ { +/*N*/ if ( nNewCol != nSrcCol1 || nNewRow != nSrcRow1 || nNewTab != nSrcTab ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ short nDiffX = nNewCol - (short) nSrcCol1; +/*N*/ short nDiffY = nNewRow - (short) nSrcRow1; +/*N*/ +/*N*/ nSrcTab = nNewTab; +/*N*/ nSrcCol1 += nDiffX; +/*N*/ nSrcCol2 += nDiffX; +/*N*/ nSrcRow1 += nDiffY; +/*N*/ nSrcRow2 += nDiffY; +/*N*/ +/*N*/ aQuery.nCol1 += nDiffX; +/*N*/ aQuery.nCol2 += nDiffX; +/*N*/ aQuery.nRow1 += nDiffY; +/*N*/ aQuery.nRow2 += nDiffY; +/*N*/ +/*N*/ USHORT nEC = aQuery.GetEntryCount(); +/*N*/ for (i=0; i<nEC; i++) +/*N*/ if (aQuery.GetEntry(i).bDoQuery) +/*N*/ aQuery.GetEntry(i).nField += nDiffX; +/*N*/ +/*N*/ if (bValidArea) +/*N*/ { +/*N*/ short nC; +/*N*/ for (nC=0; nC<nColCount; nC++) +/*N*/ if (aColArr[nC].nCol != PIVOT_DATA_FIELD) +/*N*/ aColArr[nC].nCol += nDiffX; +/*N*/ for (nC=0; nC<nRowCount; nC++) +/*N*/ if (aRowArr[nC].nCol != PIVOT_DATA_FIELD) +/*N*/ aRowArr[nC].nCol += nDiffX; +/*N*/ for (nC=0; nC<nDataCount; nC++) +/*N*/ if (aDataArr[nC].nCol != PIVOT_DATA_FIELD) +/*N*/ aDataArr[nC].nCol += nDiffX; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScPivot::MoveDestArea( USHORT nNewCol, USHORT nNewRow, USHORT nNewTab ) +/*N*/ { +/*N*/ if ( nNewCol != nDestCol1 || nNewRow != nDestRow1 || nNewTab != nDestTab ) +/*N*/ { +/*N*/ short nDiffX = nNewCol - (short) nDestCol1; +/*N*/ short nDiffY = nNewRow - (short) nDestRow1; +/*N*/ +/*N*/ nDestTab = nNewTab; +/*N*/ nDestCol1 += nDiffX; +/*N*/ nDestRow1 += nDiffY; +/*N*/ +/*N*/ if (bValidArea) +/*N*/ { +/*N*/ nDestCol2 += nDiffX; +/*N*/ nDestRow2 += nDiffY; +/*N*/ +/*N*/ nDataStartCol += nDiffX; +/*N*/ nDataStartRow += nDiffY; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScPivot::SetColFields(const PivotField* pFieldArr, short nCount) +/*N*/ { +/*N*/ nColCount = Max((short)0, Min(nCount, (short)PIVOT_MAXFIELD)); +/*N*/ for (short i = 0; i < nColCount; i++) +/*N*/ { +/*N*/ aColArr[i] = pFieldArr[i]; +/*N*/ aColArr[i].nFuncCount = 0; +/*N*/ if (aColArr[i].nCol == PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ aColArr[i].nFuncMask = PIVOT_FUNC_NONE; +/*N*/ pDataList = pColList[i]; +/*N*/ bDataAtCol = TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for (short j=0; j<=PIVOT_MAXFUNC; j++) // incl. "auto" +/*N*/ if (aColArr[i].nFuncMask & nFuncMaskArr[j]) +/*N*/ aColArr[i].nFuncCount++; +/*N*/ } +/*N*/ } +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ void ScPivot::GetColFields(PivotField* pFieldArr, short& rCount) const +/*N*/ { +/*N*/ for (short i=0; i<nColCount; i++) +/*N*/ pFieldArr[i] = aColArr[i]; +/*N*/ rCount = nColCount; +/*N*/ } + +/*N*/ void ScPivot::SetRowFields(const PivotField* pFieldArr, short nCount) +/*N*/ { +/*N*/ nRowCount = Max((short)0, Min(nCount, (short)PIVOT_MAXFIELD)); +/*N*/ for (short i = 0; i < nRowCount; i++) +/*N*/ { +/*N*/ aRowArr[i] = pFieldArr[i]; +/*N*/ aRowArr[i].nFuncCount = 0; +/*N*/ if (aRowArr[i].nCol == PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ aRowArr[i].nFuncMask = PIVOT_FUNC_NONE; +/*N*/ pDataList = pRowList[i]; +/*N*/ bDataAtCol = FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for (short j=0; j<=PIVOT_MAXFUNC; j++) // incl. "auto" +/*N*/ if (aRowArr[i].nFuncMask & nFuncMaskArr[j]) +/*N*/ aRowArr[i].nFuncCount++; +/*N*/ } +/*N*/ } +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ void ScPivot::GetRowFields(PivotField* pFieldArr, short& rCount) const +/*N*/ { +/*N*/ for (short i=0; i<nRowCount; i++) +/*N*/ pFieldArr[i] = aRowArr[i]; +/*N*/ rCount = nRowCount; +/*N*/ } + +/*N*/ void ScPivot::SetDataFields(const PivotField* pFieldArr, short nCount) +/*N*/ { +/*N*/ USHORT nFuncNo; +/*N*/ short i; +/*N*/ +/*N*/ // +/*N*/ // nDataCount vorausberechnen (wie unten) +/*N*/ // +/*N*/ +/*N*/ nDataCount = 0; +/*N*/ for (i = 0; i < nCount; i++) +/*N*/ for (nFuncNo=0; nFuncNo<PIVOT_MAXFUNC; nFuncNo++) +/*N*/ if (pFieldArr[i].nFuncMask & nFuncMaskArr[nFuncNo]) +/*N*/ if (nDataCount+1 < PIVOT_MAXFIELD) +/*N*/ ++nDataCount; +/*N*/ +/*N*/ // +/*N*/ // Eintraege anpassen +/*N*/ // +/*N*/ +/*N*/ if ((nRowCount == 1) && (aRowArr[0].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1)) +/*N*/ { +/*?*/ aColArr[nColCount] = aRowArr[0]; +/*?*/ pDataList = pColList[nColCount]; +/*?*/ nColCount++; +/*?*/ nRowCount--; +/*?*/ bDataAtCol = TRUE; +/*N*/ } +/*N*/ if ((nColCount == 1) && (aColArr[0].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1)) +/*N*/ { +/*?*/ aRowArr[nRowCount] = aColArr[0]; +/*?*/ pDataList = pRowList[nRowCount]; +/*?*/ nRowCount++; +/*?*/ nColCount--; +/*?*/ bDataAtCol = FALSE; +/*N*/ } +/*N*/ +/*N*/ if ((nDataCount == 1) +/*N*/ && (aColArr[nColCount-1].nCol != PIVOT_DATA_FIELD) +/*N*/ && (aColArr[nRowCount-1].nCol != PIVOT_DATA_FIELD)) +/*N*/ { +/*?*/ if (bDataAtCol) +/*?*/ { +/*?*/ PivotField aField; +/*?*/ short nIndex = PIVOT_MAXFIELD; +/*?*/ for (i=0; i<nColCount; i++) +/*?*/ { +/*?*/ if (aColArr[i].nCol == PIVOT_DATA_FIELD) +/*?*/ { +/*?*/ aField = aColArr[i]; +/*?*/ nIndex = i; +/*?*/ } +/*?*/ } +/*?*/ DBG_ASSERT(nIndex < PIVOT_MAXFIELD, "no data field (GPF in old versions!)"); +/*?*/ if ( nIndex < PIVOT_MAXFIELD ) +/*?*/ { +/*?*/ memcpy(&aColArr[nIndex], &aColArr[nIndex+1], (PIVOT_MAXFIELD - nIndex - 1) * sizeof(PivotField)); +/*?*/ aColArr[nColCount-1] = aField; +/*?*/ pDataList = pColList[nColCount-1]; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ PivotField aField; +/*?*/ short nIndex = PIVOT_MAXFIELD; +/*?*/ for (i=0; i<nRowCount; i++) +/*?*/ { +/*?*/ if (aRowArr[i].nCol == PIVOT_DATA_FIELD) +/*?*/ { +/*?*/ aField = aRowArr[i]; +/*?*/ nIndex = i; +/*?*/ } +/*?*/ } +/*?*/ DBG_ASSERT(nIndex < PIVOT_MAXFIELD, "no data field (GPF in old versions!)"); +/*?*/ if ( nIndex < PIVOT_MAXFIELD ) +/*?*/ { +/*?*/ memcpy(&aRowArr[nIndex], &aRowArr[nIndex+1], (PIVOT_MAXFIELD - nIndex - 1) * sizeof(PivotField)); +/*?*/ aRowArr[nRowCount-1] = aField; +/*?*/ pDataList = pRowList[nRowCount-1]; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Datenfelder in Eintraege mit nur einer Funktion aufteilen +/*N*/ // +/*N*/ +/*N*/ pDataList->FreeAll(); +/*N*/ nDataCount = 0; +/*N*/ for (i = 0; i < nCount; i++) +/*N*/ { +/*N*/ for (nFuncNo=0; nFuncNo<PIVOT_MAXFUNC; nFuncNo++) +/*N*/ if (pFieldArr[i].nFuncMask & nFuncMaskArr[nFuncNo]) +/*N*/ if (nDataCount+1 < PIVOT_MAXFIELD) +/*N*/ { +/*N*/ aDataArr[nDataCount] = pFieldArr[i]; +/*N*/ aDataArr[nDataCount].nFuncCount = 0; +/*N*/ aDataArr[nDataCount].nFuncMask = nFuncMaskArr[nFuncNo]; +/*N*/ +/*N*/ String aStr; +/*N*/ pDoc->GetString(aDataArr[nDataCount].nCol, nSrcRow1, nSrcTab, aStr); +/*N*/ if (aStr.Len() == 0) +/*?*/ aStr = ColToAlpha( aDataArr[nDataCount].nCol ); +/*N*/ TypedStrData* pStrData = new TypedStrData(aStr); +/*N*/ if (!(pDataList->AtInsert(pDataList->GetCount(), pStrData))) +/*N*/ { +/*?*/ delete pStrData; +/*?*/ DBG_ERROR("Fehler bei pDataList->AtInsert"); +/*N*/ } +/*N*/ +/*N*/ ++nDataCount; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // +/*N*/ // +/*N*/ +/*N*/ bValidArea = FALSE; +/*N*/ } + +/*N*/ void ScPivot::GetDataFields(PivotField* pFieldArr, short& rCount) const +/*N*/ { +/* for (short i=0; i<nDataCount; i++) + pFieldArr[i] = aDataArr[i]; + rCount = nDataCount; +*/ +/*N*/ +/*N*/ rCount = 0; +/*N*/ for (short i=0; i<nDataCount; i++) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ for (short j=0; j<rCount && !bFound; j++) +/*?*/ if (pFieldArr[j].nCol == aDataArr[i].nCol) +/*?*/ { +/*?*/ // add to previous column only if new bits aren't already set there +/*?*/ if ( ( pFieldArr[j].nFuncMask & aDataArr[i].nFuncMask ) == 0 ) +/*?*/ { +/*?*/ pFieldArr[j].nFuncMask |= aDataArr[i].nFuncMask; +/*?*/ pFieldArr[j].nFuncCount++; +/*?*/ bFound = TRUE; +/*?*/ } +/*?*/ } +/*N*/ if (!bFound) +/*N*/ { +/*N*/ pFieldArr[rCount] = aDataArr[i]; +/*N*/ ++rCount; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScPivot::CreateData(BOOL bKeepDest) +/*N*/ { +/*N*/ // +/*N*/ // +/*N*/ // +/*N*/ +/*N*/ USHORT nOldCol2 = nDestCol2; +/*N*/ USHORT nOldRow2 = nDestRow2; +/*N*/ +/*N*/ pColRef = new PivotColRef[MAXCOL]; +/*N*/ aQuery.nCol1 = nSrcCol1; +/*N*/ aQuery.nRow1 = nSrcRow1; +/*N*/ aQuery.nCol2 = nSrcCol2; +/*N*/ aQuery.nRow2 = nSrcRow2; +/*N*/ aQuery.bHasHeader = bHasHeader; +/*N*/ BOOL bRet = CreateFields(); +/*N*/ if (bRet) +/*N*/ { +/*N*/ short i=0; // nDataMult berechnen - nach CreateFields, vor CreateFieldData !!! +/*N*/ nDataMult = 1; +/*N*/ if (nDataCount > 1) +/*N*/ { +/*?*/ if (bDataAtCol) +/*?*/ { +/*?*/ while (i<nColCount && aColArr[i].nCol != PIVOT_DATA_FIELD) i++; +/*?*/ i++; +/*?*/ while (i<nColCount) +/*?*/ nDataMult *= pColList[i++]->GetCount(); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ while (i<nRowCount && aRowArr[i].nCol != PIVOT_DATA_FIELD) i++; +/*?*/ i++; +/*?*/ while (i<nRowCount) +/*?*/ nDataMult *= pRowList[i++]->GetCount(); +/*?*/ } +/*N*/ } +/*N*/ DBG_ASSERT(nDataMult,"nDataMult==0"); +/*N*/ +/*N*/ CalcArea(); +/*N*/ if ((nDestCol2 <= MAXCOL) && (nDestRow2 <= MAXROW)) +/*N*/ { +/*N*/ CreateFieldData(); +/*N*/ bValidArea = TRUE; +/*N*/ } +/*N*/ else +/*N*/ bRet = FALSE; +/*N*/ } +/*N*/ +/*N*/ if ( bKeepDest ) +/*N*/ { +/*N*/ bValidArea = TRUE; //! ??? +/*N*/ nDestCol2 = nOldCol2; +/*N*/ nDestRow2 = nOldRow2; +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + + +/*N*/ void ScPivot::ReleaseData() +/*N*/ { +/*N*/ short i; +/*N*/ for (i = 0; i < PIVOT_MAXFIELD; i++) +/*N*/ { +/*N*/ pColList[i]->FreeAll(); +/*N*/ pRowList[i]->FreeAll(); +/*N*/ } +/*N*/ if (ppDataArr) +/*N*/ { +/*N*/ for (i=0; i<nDataRowCount; i++) +/*N*/ delete[] ppDataArr[i]; +/*N*/ delete[] ppDataArr; +/*N*/ ppDataArr = NULL; +/*N*/ } +/*N*/ nDataColCount = 0; +/*N*/ nDataRowCount = 0; +/*N*/ delete[] pColRef; +/*N*/ pColRef = NULL; +/*N*/ } + + + + + + +//-------------------------------------------------------------------------------------------------- +// Private Methoden +//-------------------------------------------------------------------------------------------------- + +/*N*/ BOOL ScPivot::CreateFields() +/*N*/ { +/*N*/ short i; +/*N*/ USHORT nRow; +/*N*/ USHORT nHeader; +/*N*/ String aStr; +/*N*/ TypedStrData* pStrData; +/*N*/ if (bHasHeader) +/*N*/ nHeader = 1; +/*N*/ else +/*N*/ nHeader = 0; +/*N*/ +/*N*/ // Sortieren nach Benutzerdefinierte Listen ?? +/*N*/ for (i = 0; i < nColCount; i++) +/*N*/ { +/*N*/ if (aColArr[i].nCol != PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ pDoc->GetString(aColArr[i].nCol, nSrcRow1 + nHeader, nSrcTab, aStr); +/*N*/ pColList[i]->SetUserData(ScGlobal::GetUserList()->GetData(aStr)); +/*N*/ } +/*N*/ else +/*N*/ pColList[i]->SetUserData(NULL); +/*N*/ } +/*N*/ for (i = 0; i < nRowCount; i++) +/*N*/ { +/*N*/ if (aRowArr[i].nCol != PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ pDoc->GetString(aRowArr[i].nCol, nSrcRow1 + nHeader, nSrcTab, aStr); +/*N*/ pRowList[i]->SetUserData(ScGlobal::GetUserList()->GetData(aStr)); +/*N*/ } +/*N*/ else +/*?*/ pRowList[i]->SetUserData(NULL); +/*N*/ } +/*N*/ +/*N*/ ScAddress aSrcAdr( nSrcCol1, 0, nSrcTab ); +/*N*/ for (nRow = nSrcRow1 + nHeader; nRow <= nSrcRow2; nRow++) +/*N*/ { +/*N*/ BOOL bValidLine = TRUE; +/*N*/ if (bIgnoreEmpty) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 aSrcAdr.SetRow( nRow ); +/*N*/ } +/*N*/ if (bValidLine) +/*N*/ bValidLine = pDoc->pTab[nSrcTab]->ValidQuery(nRow, aQuery); +/*N*/ if (bValidLine) +/*N*/ { +/*N*/ // Sortierte Liste der Felder erzeugen +/*N*/ //! statt GetCategoryString leere weglassen ! +/*N*/ +/*N*/ for (i = 0; i < nColCount; i++) +/*N*/ { +/*N*/ if (aColArr[i].nCol != PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ USHORT nCatRow = bDetectCat ? GetCategoryRow( aColArr[i].nCol, nRow ) : nRow; +/*N*/ pStrData = new TypedStrData( pDoc, aColArr[i].nCol, nCatRow, nSrcTab, TRUE ); +/*N*/ if (!(pColList[i]->Insert(pStrData))) +/*N*/ delete pStrData; +/*N*/ } +/*N*/ } +/*N*/ for (i = 0; i < nRowCount; i++) +/*N*/ { +/*N*/ if (aRowArr[i].nCol != PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ USHORT nCatRow = bDetectCat ? GetCategoryRow( aRowArr[i].nCol, nRow ) : nRow; +/*N*/ pStrData = new TypedStrData( pDoc, aRowArr[i].nCol, nCatRow, nSrcTab, TRUE ); +/*N*/ if (!(pRowList[i]->Insert(pStrData))) +/*N*/ delete pStrData; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return TRUE; +/*N*/ } + +/*N*/ void ScPivot::CreateFieldData() +/*N*/ { +/*N*/ USHORT* pRowListIndex = nRowCount ? new USHORT[nRowCount] : NULL; +/*N*/ USHORT* pColListIndex = nColCount ? new USHORT[nColCount] : NULL; +/*N*/ +/*N*/ short i,j,k; +/*N*/ +/*N*/ ppDataArr = new SubTotal*[nDataRowCount]; +/*N*/ for (i=0; i<nDataRowCount; i++) +/*N*/ ppDataArr[i] = new SubTotal[nDataColCount]; +/*N*/ +/*N*/ if (bDataAtCol) +/*N*/ for (j=0; j<nDataRowCount; j++) +/*N*/ for (i=0; i<nDataColCount; i++) +/*N*/ ppDataArr[j][i].nIndex = j/nDataMult%nDataCount; +/*N*/ else +/*?*/ for (j=0; j<nDataRowCount; j++) +/*?*/ for (i=0; i<nDataColCount; i++) +/*?*/ ppDataArr[j][i].nIndex = i/nDataMult%nDataCount; +/*N*/ +/*N*/ short nHeader; +/*N*/ if (bHasHeader) +/*N*/ nHeader = 1; +/*N*/ else +/*N*/ nHeader = 0; +/*N*/ ScAddress aSrcAdr( nSrcCol1, 0, nSrcTab ); +/*N*/ for (USHORT nRow = nSrcRow1 + nHeader; nRow <= nSrcRow2; nRow++) +/*N*/ { +/*N*/ BOOL bValidLine = TRUE; +/*N*/ if (bIgnoreEmpty) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 aSrcAdr.SetRow( nRow ); +/*N*/ } +/*N*/ if (bValidLine) +/*N*/ bValidLine = pDoc->pTab[nSrcTab]->ValidQuery(nRow, aQuery); +/*N*/ if (bValidLine) +/*N*/ { +/*N*/ // Indizes der Kategorien nur einmal ausserhalb nDataCount +/*N*/ for (j=0; j<nRowCount; j++) +/*N*/ if (aRowArr[j].nCol != PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ USHORT nCatRow = bDetectCat ? GetCategoryRow( aRowArr[j].nCol, nRow ) : nRow; +/*N*/ TypedStrData aStrData( pDoc, aRowArr[j].nCol, nCatRow, nSrcTab, TRUE ); +/*N*/ pRowListIndex[j] = pRowList[j]->GetIndex(&aStrData); +/*N*/ } +/*N*/ for (j=0; j<nColCount; j++) +/*N*/ if (aColArr[j].nCol != PIVOT_DATA_FIELD) +/*N*/ { +/*N*/ USHORT nCatRow = bDetectCat ? GetCategoryRow( aColArr[j].nCol, nRow ) : nRow; +/*N*/ TypedStrData aStrData( pDoc, aColArr[j].nCol, nCatRow, nSrcTab, TRUE ); +/*N*/ pColListIndex[j] = pColList[j]->GetIndex(&aStrData); +/*N*/ } +/*N*/ +/*N*/ String aStr; +/*N*/ short nCIndex; +/*N*/ short nRIndex; +/*N*/ short nIndex; +/*N*/ ScAddress aAdr( 0, nRow, nSrcTab ); +/*N*/ +/*N*/ for (i=0; i<nDataCount; i++) +/*N*/ { +/*N*/ // ColIndex Berechnen +/*N*/ nCIndex = 0; +/*N*/ for (j=0; j<nRowCount; j++) +/*N*/ { +/*N*/ if (aRowArr[j].nCol == PIVOT_DATA_FIELD) +/*N*/ nIndex = i; +/*N*/ else +/*N*/ nIndex = pRowListIndex[j]; +/*N*/ if (nIndex) +/*N*/ { +/*N*/ for (k=j+1; k<nRowCount; k++) +/*?*/ nIndex *= pRowList[k]->GetCount(); +/*N*/ nCIndex += nIndex; +/*N*/ } +/*N*/ } +/*N*/ // RowIndex Berechnen +/*N*/ nRIndex = 0; +/*N*/ for (j=0; j<nColCount; j++) +/*N*/ { +/*N*/ if (aColArr[j].nCol == PIVOT_DATA_FIELD) +/*N*/ nIndex = i; +/*N*/ else +/*N*/ nIndex = pColListIndex[j]; +/*N*/ if (nIndex) +/*N*/ { +/*N*/ for (k=j+1; k<nColCount; k++) +/*N*/ nIndex *= pColList[k]->GetCount(); +/*N*/ nRIndex += nIndex; +/*N*/ } +/*N*/ } +/*N*/ // Daten eintragen +/*N*/ if ((nCIndex < nDataColCount) && (nRIndex < nDataRowCount)) +/*N*/ { +/*N*/ DBG_ASSERT((short)ppDataArr[nRIndex][nCIndex].nIndex == i, "falsch init."); +/*N*/ +/*N*/ ppDataArr[nRIndex][nCIndex].nIndex = i; +/*N*/ aAdr.SetCol( aDataArr[i].nCol ); +/*N*/ CellType eCellType = pDoc->GetCellType( aAdr ); +/*N*/ if ((eCellType != CELLTYPE_NONE) && (eCellType != CELLTYPE_NOTE)) +/*N*/ { +/*N*/ BOOL bValue = (eCellType == CELLTYPE_VALUE); +/*N*/ if (eCellType == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ScBaseCell* pCell = pDoc->GetCell( aAdr ); +/*N*/ bValue = ((ScFormulaCell*)pCell)->IsValue(); +/*N*/ } +/*N*/ +/*N*/ if (bValue) +/*N*/ { +/*N*/ double nVal = pDoc->GetValue( aAdr ); +/*N*/ ppDataArr[nRIndex][nCIndex].Update(nVal); +/*N*/ } +/*N*/ else +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 ppDataArr[nRIndex][nCIndex].UpdateNoVal(); // nur nCount +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ delete pColListIndex; +/*N*/ delete pRowListIndex; +/*N*/ } + +/*N*/ void ScPivot::CalcArea() +/*N*/ { +/*N*/ BOOL bNoRows = (nRowCount == 0) || ( nRowCount == 1 && aRowArr[0].nCol == PIVOT_DATA_FIELD ); +/*N*/ BOOL bNoCols = (nColCount == 0) || ( nColCount == 1 && aColArr[0].nCol == PIVOT_DATA_FIELD ); +/*N*/ if (!bMakeTotalCol) bNoRows = TRUE; +/*N*/ if (!bMakeTotalRow) bNoCols = TRUE; +/*N*/ +/*N*/ short i; +/*N*/ short nDx; +/*N*/ // StartSpalte/StartZeile des Datenbereichs berechnen +/*N*/ if (bDataAtCol) +/*N*/ { +/*N*/ if (nDataCount > 1) +/*?*/ nDataStartCol = nDestCol1 + nColCount; +/*N*/ else +/*N*/ nDataStartCol = nDestCol1 + Max(0, nColCount - 1); +/*N*/ } +/*N*/ else +/*?*/ nDataStartCol = nDestCol1 + nColCount; +/*N*/ if (!bDataAtCol) +/*N*/ { +/*?*/ if (nDataCount > 1) +/*?*/ nDataStartRow = nDestRow1 + nRowCount + nFirstLine + 1; +/*?*/ else +/*?*/ nDataStartRow = nDestRow1 + Max(0, nRowCount - 1) + nFirstLine + 1; +/*N*/ } +/*N*/ else +/*N*/ nDataStartRow = nDestRow1 + nRowCount + nFirstLine + 1; +/*N*/ +/*N*/ // +/*N*/ // Groesse der PivotTabelle berechnen +/*N*/ // +/*N*/ +/*N*/ if (nRowCount == 0 || (nRowCount==1 && aRowArr[0].nCol==PIVOT_DATA_FIELD && nDataCount==1)) +/*N*/ { +/*?*/ nDataColCount = 1; +/*?*/ if (nDataCount == 1) +/*?*/ nDestCol2 = nDestCol1 + nColCount - 1; +/*?*/ else +/*?*/ nDestCol2 = nDestCol1 + nColCount; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // Anzahl Spalten +/*N*/ if ((aRowArr[nRowCount-1].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1)) +/*N*/ nDx = 2; +/*N*/ else +/*N*/ nDx = 1; +/*N*/ long nColLines = pRowList[nRowCount-nDx]->GetCount(); // long um Ueberlauf zu erkennen +/*N*/ nDataColCount = pRowList[nRowCount-nDx]->GetCount(); +/*N*/ for (i=nRowCount-nDx-1; i >= 0; i--) +/*N*/ { +/*?*/ nColLines *= pRowList[i]->GetCount(); +/*?*/ nDataColCount *= pRowList[i]->GetCount(); +/*?*/ if (!bDataAtCol) +/*?*/ nColLines += (pRowList[i]->GetCount() * aRowArr[i].nFuncCount * nDataCount); +/*?*/ else +/*?*/ nColLines += (pRowList[i]->GetCount() * aRowArr[i].nFuncCount); +/*N*/ } +/*N*/ /* + // Ergebnisspalten des letzten Elements + if (aRowArr[nRowCount-1].nCol != PIVOT_DATA_FIELD) + nColLines += (pRowList[nRowCount-1]->GetCount() * aRowArr[nRowCount-1].nFuncCount); + */ +/*N*/ if (nColLines > MAXCOL) +/*?*/ nDestCol2 = MAXCOL+2; // ungueltig, 1 wird unten abgezogen +/*N*/ else if (bDataAtCol) +/*N*/ { +/*N*/ if (nDataCount > 1) +/*?*/ nDestCol2 = nDestCol1 + nColCount + nColLines; +/*N*/ else +/*N*/ nDestCol2 = nDestCol1 + (nColCount - 1) + nColLines; +/*N*/ if (!bMakeTotalCol) +/*?*/ --nDestCol2; +/*N*/ } +/*N*/ else +/*?*/ nDestCol2 = nDestCol1 + nColCount + nColLines; +/*N*/ } +/*N*/ +/*N*/ if (nColCount == 0 || (nColCount==1 && aColArr[0].nCol==PIVOT_DATA_FIELD && nDataCount==1)) +/*N*/ { +/*?*/ nDataRowCount = 1; +/*?*/ if (nDataCount == 1) +/*?*/ nDestRow2 = nDestRow1 + (nRowCount - 1) + nFirstLine + 1; +/*?*/ else +/*?*/ nDestRow2 = nDestRow1 + nRowCount + nFirstLine + 1; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // Anzahl Zeilen +/*N*/ if ((aColArr[nColCount-1].nCol == PIVOT_DATA_FIELD) && (nDataCount == 1)) +/*N*/ nDx = 2; +/*N*/ else +/*N*/ nDx = 1; +/*N*/ long nRowLines = pColList[nColCount-nDx]->GetCount(); // long um Ueberlauf zu erkennen +/*N*/ nDataRowCount = pColList[nColCount-nDx]->GetCount(); +/*N*/ for (i=nColCount-nDx-1; i >= 0; i--) +/*N*/ { +/*?*/ nRowLines *= pColList[i]->GetCount(); +/*?*/ nDataRowCount *= pColList[i]->GetCount(); +/*?*/ if (bDataAtCol) +/*?*/ nRowLines += (pColList[i]->GetCount() * aColArr[i].nFuncCount * nDataCount); +/*?*/ else +/*?*/ nRowLines += (pColList[i]->GetCount() * aColArr[i].nFuncCount); +/*N*/ } + /* + // Ergebniszeilen des letzten Elements + if (aColArr[nColCount-1].nCol != PIVOT_DATA_FIELD) + nRowLines += (pColList[nColCount-1]->GetCount() * aColArr[nColCount-1].nFuncCount); + */ +/*N*/ if (nRowLines > MAXROW) +/*?*/ nDestRow2 = MAXROW+2; // ungueltig, 1 wird unten abgezogen +/*N*/ else if (!bDataAtCol) +/*N*/ { +/*?*/ if (nDataCount > 1) +/*?*/ nDestRow2 = nDestRow1 + nRowCount + nRowLines + nFirstLine + 1; +/*?*/ else +/*?*/ nDestRow2 = nDestRow1 + (nRowCount - 1) + nRowLines + nFirstLine + 1; +/*?*/ if (!bMakeTotalRow) +/*?*/ --nDestRow2; +/*N*/ } +/*N*/ else +/*N*/ nDestRow2 = nDestRow1 + nRowCount + nRowLines + nFirstLine + 1; +/*N*/ } +/*N*/ +/*N*/ if (bDataAtCol) +/*N*/ { +/*N*/ if (!bNoCols) +/*N*/ nDestRow2 += nDataCount; +/*N*/ nDestRow2 --; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ if (!bNoRows) +/*?*/ nDestCol2 += nDataCount; +/*?*/ nDestCol2 --; +/*N*/ } +/*N*/ } + + + + + +/*N*/ USHORT ScPivot::GetCategoryRow( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ USHORT nMinRow = nSrcRow1; +/*N*/ if (bHasHeader) ++nMinRow; +/*N*/ BOOL bFound = FALSE; +/*N*/ do +/*N*/ { +/*N*/ if ( !pDoc->HasData( nCol, nRow, nSrcTab ) && nRow>nMinRow ) +/*N*/ --nRow; +/*N*/ else +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ while (!bFound); +/*N*/ return nRow; +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_pivot2.cxx b/binfilter/bf_sc/source/core/data/sc_pivot2.cxx new file mode 100644 index 000000000000..f70ee20c2a24 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_pivot2.cxx @@ -0,0 +1,291 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#ifdef _MSC_VER +#pragma optimize("",off) +#endif +#ifdef _MSC_VER +#pragma optimize("q",off) // p-code off +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <unotools/transliterationwrapper.hxx> + +#include "globstr.hrc" +#include "rangeutl.hxx" +#include "pivot.hxx" +#include "rechead.hxx" +#include "refupdat.hxx" +#include "stlsheet.hxx" +namespace binfilter { + + +// STATIC DATA ----------------------------------------------------------- + +//-------------------------------------------------------------------------------------------------- +// Hilfsmethoden von ScPivot +//-------------------------------------------------------------------------------------------------- + + + + + + + + + + +//-------------------------------------------------------------------------------------------------- + +/*N*/ void ScPivot::GetParam( ScPivotParam& rParam, ScQueryParam& rQuery, ScArea& rSrcArea ) const +/*N*/ { +/*N*/ short nCount; +/*N*/ USHORT nDummy; +/*N*/ GetDestArea( rParam.nCol,rParam.nRow, nDummy,nDummy, rParam.nTab ); +/*N*/ +/*N*/ // Row und Col in der Bedeutung vertauscht: +/*N*/ GetRowFields( rParam.aColArr, nCount ); +/*N*/ rParam.nColCount = (USHORT) nCount; +/*N*/ GetColFields( rParam.aRowArr, nCount ); +/*N*/ rParam.nRowCount = (USHORT) nCount; +/*N*/ GetDataFields( rParam.aDataArr, nCount ); +/*N*/ rParam.nDataCount = (USHORT) nCount; +/*N*/ +/*N*/ rParam.bIgnoreEmptyRows = GetIgnoreEmpty(); +/*N*/ rParam.bDetectCategories = GetDetectCat(); +/*N*/ rParam.bMakeTotalCol = GetMakeTotalCol(); +/*N*/ rParam.bMakeTotalRow = GetMakeTotalRow(); +/*N*/ +/*N*/ GetQuery(rQuery); +/*N*/ GetSrcArea( rSrcArea.nColStart, rSrcArea.nRowStart, +/*N*/ rSrcArea.nColEnd, rSrcArea.nRowEnd, rSrcArea.nTab ); +/*N*/ } + +/*N*/ void ScPivot::SetParam( const ScPivotParam& rParam, const ScQueryParam& rQuery, +/*N*/ const ScArea& rSrcArea ) +/*N*/ { +/*N*/ SetQuery( rQuery ); +/*N*/ SetHeader( TRUE ); +/*N*/ SetSrcArea( rSrcArea.nColStart, rSrcArea.nRowStart, +/*N*/ rSrcArea.nColEnd, rSrcArea.nRowEnd, rSrcArea.nTab ); +/*N*/ SetDestPos( rParam.nCol, rParam.nRow, rParam.nTab ); +/*N*/ SetIgnoreEmpty( rParam.bIgnoreEmptyRows ); +/*N*/ SetDetectCat( rParam.bDetectCategories ); +/*N*/ SetMakeTotalCol( rParam.bMakeTotalCol ); +/*N*/ SetMakeTotalRow( rParam.bMakeTotalRow ); +/*N*/ +/*N*/ // Row und Col in der Bedeutung vertauscht: +/*N*/ SetRowFields( rParam.aColArr, rParam.nColCount ); +/*N*/ SetColFields( rParam.aRowArr, rParam.nRowCount ); +/*N*/ SetDataFields( rParam.aDataArr, rParam.nDataCount ); +/*N*/ } + +/*N*/ DataObject* ScPivot::Clone() const +/*N*/ { +/*N*/ return new ScPivot(*this); +/*N*/ } + +//-------------------------------------------------------------------------------------------------- +// PivotStrCollection +//-------------------------------------------------------------------------------------------------- + + +/*N*/ short PivotStrCollection::Compare(DataObject* pKey1, DataObject* pKey2) const +/*N*/ { +/*N*/ DBG_ASSERT(pKey1&&pKey2,"0-Zeiger bei PivotStrCollection::Compare"); +/*N*/ +/*N*/ short nResult = 0; +/*N*/ +/*N*/ TypedStrData& rData1 = (TypedStrData&)*pKey1; +/*N*/ TypedStrData& rData2 = (TypedStrData&)*pKey2; +/*N*/ +/*N*/ if ( rData1.nStrType > rData2.nStrType ) +/*N*/ nResult = 1; +/*N*/ else if ( rData1.nStrType < rData2.nStrType ) +/*N*/ nResult = -1; +/*N*/ else if ( !rData1.nStrType /* && !rData2.nStrType */ ) +/*N*/ { +/*?*/ // Zahlen vergleichen: +/*?*/ +/*?*/ if ( rData1.nValue == rData2.nValue ) +/*?*/ nResult = 0; +/*?*/ else if ( rData1.nValue < rData2.nValue ) +/*?*/ nResult = -1; +/*?*/ else +/*?*/ nResult = 1; +/*N*/ } +/*N*/ else /* if ( rData1.nStrType && rData2.nStrType ) */ +/*N*/ { +/*N*/ // Strings vergleichen: +/*N*/ +/*N*/ if (pUserData) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 nResult = pUserData->ICompare(rData1.aStrValue, rData2.aStrValue); +/*N*/ else +/*N*/ { +/*N*/ nResult = (short) ScGlobal::pTransliteration->compareString( +/*N*/ rData1.aStrValue, rData2.aStrValue ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return nResult; +/*N*/ } + +/*N*/ short PivotStrCollection::GetIndex(TypedStrData* pData) const +/*N*/ { +/*N*/ USHORT nIndex = 0; +/*N*/ if (!Search(pData, nIndex)) +/*N*/ nIndex = 0; +/*N*/ return (short)nIndex; +/*N*/ } + +//-------------------------------------------------------------------------------------------------- +// PivotCollection +//-------------------------------------------------------------------------------------------------- + +/*N*/ String ScPivotCollection::CreateNewName( USHORT nMin ) const +/*N*/ { +/*N*/ String aBase( RTL_CONSTASCII_USTRINGPARAM("DataPilot") ); +/*N*/ //! from Resource? +/*N*/ +/*N*/ for (USHORT nAdd=0; nAdd<=nCount; nAdd++) // nCount+1 Versuche +/*N*/ { +/*N*/ String aNewName = aBase; +/*N*/ aNewName += String::CreateFromInt32( nMin + nAdd ); +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=0; i<nCount && !bFound; i++) +/*N*/ if (((ScPivot*)pItems[i])->GetName() == aNewName) +/*N*/ bFound = TRUE; +/*N*/ if (!bFound) +/*N*/ return aNewName; // freien Namen gefunden +/*N*/ } +/*N*/ return String(); // sollte nicht vorkommen +/*N*/ } + + +/*N*/ BOOL ScPivotCollection::Load(SvStream& rStream) +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ USHORT nNewCount, i; +/*N*/ FreeAll(); +/*N*/ +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> nNewCount; +/*N*/ for (i=0; i<nNewCount && bSuccess; i++) +/*N*/ { +/*N*/ ScPivot* pPivot = new ScPivot( pDoc ); +/*N*/ if (pPivot) +/*N*/ { +/*N*/ bSuccess = pPivot->Load(rStream, aHdr); +/*N*/ Insert( pPivot ); +/*N*/ } +/*N*/ else +/*N*/ bSuccess = FALSE; +/*N*/ } +/*N*/ +/*N*/ // fuer alte Dateien: eindeutige Namen vergeben +/*N*/ +/*N*/ if (bSuccess) +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if (!((const ScPivot*)At(i))->GetName().Len()) +/*N*/ ((ScPivot*)At(i))->SetName( CreateNewName() ); +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ BOOL ScPivotCollection::Store(SvStream& rStream) const +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream << nCount; +/*N*/ +/*N*/ for (USHORT i=0; i<nCount && bSuccess; i++) +/*?*/ bSuccess = ((const ScPivot*)At(i))->Store( rStream, aHdr ); +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ void ScPivotCollection::UpdateReference(UpdateRefMode eUpdateRefMode, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*?*/ USHORT theCol1; +/*?*/ USHORT theRow1; +/*?*/ USHORT theTab1; +/*?*/ USHORT theCol2; +/*?*/ USHORT theRow2; +/*?*/ USHORT theTab2; +/*?*/ ScRefUpdateRes eRes; +/*?*/ ScPivot* pPivot = (ScPivot*)pItems[i]; +/*?*/ +/*?*/ // Source +/*?*/ +/*?*/ pPivot->GetSrcArea( theCol1, theRow1, theCol2, theRow2, theTab1 ); +/*?*/ theTab2 = theTab1; +/*?*/ +/*?*/ eRes = ScRefUpdate::Update( pDoc, eUpdateRefMode, +/*?*/ nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz, +/*?*/ theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ); +/*?*/ +/*?*/ if (eRes != UR_NOTHING) +/*?*/ pPivot->MoveSrcArea( theCol1, theRow1, theTab1 ); +/*?*/ +/*?*/ // Dest +/*?*/ +/*?*/ pPivot->GetDestArea( theCol1, theRow1, theCol2, theRow2, theTab1 ); +/*?*/ theTab2 = theTab1; +/*?*/ +/*?*/ eRes = ScRefUpdate::Update( pDoc, eUpdateRefMode, +/*?*/ nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz, +/*?*/ theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ); +/*?*/ +/*?*/ if (eRes != UR_NOTHING) +/*?*/ pPivot->MoveDestArea( theCol1, theRow1, theTab1 ); +/*N*/ } +/*N*/ } + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_poolhelp.cxx b/binfilter/bf_sc/source/core/data/sc_poolhelp.cxx new file mode 100644 index 000000000000..5988251cacf4 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_poolhelp.cxx @@ -0,0 +1,91 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svtools/zforlist.hxx> +#include <bf_svx/editeng.hxx> + +#include "poolhelp.hxx" +#include "document.hxx" +#include "docpool.hxx" +#include "stlpool.hxx" + +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ ScPoolHelper::ScPoolHelper( ScDocument* pSourceDoc ) +/*N*/ { +/*N*/ DBG_ASSERT( pSourceDoc, "ScPoolHelper: no document" ); +/*N*/ +/*N*/ pDocPool = new ScDocumentPool; +/*N*/ pDocPool->FreezeIdRanges(); +/*N*/ +/*N*/ pStylePool = new ScStyleSheetPool( *pDocPool, pSourceDoc ); +/*N*/ +/*N*/ pFormTable = new SvNumberFormatter( pSourceDoc->GetServiceManager(), ScGlobal::eLnge ); +/*N*/ pFormTable->SetColorLink( LINK( pSourceDoc, ScDocument, GetUserDefinedColor ) ); +/*N*/ pFormTable->SetEvalDateFormat( NF_EVALDATEFORMAT_INTL_FORMAT ); +/*N*/ +/*N*/ pEditPool = EditEngine::CreatePool(); +/*N*/ pEditPool->SetDefaultMetric( SFX_MAPUNIT_100TH_MM ); +/*N*/ pEditPool->FreezeIdRanges(); +/*N*/ pEditPool->SetFileFormatVersion( SOFFICE_FILEFORMAT_50 ); // used in ScGlobal::EETextObjEqual +/*N*/ +/*N*/ pEnginePool = EditEngine::CreatePool(); +/*N*/ pEnginePool->SetDefaultMetric( SFX_MAPUNIT_100TH_MM ); +/*N*/ pEnginePool->FreezeIdRanges(); +/*N*/ } + +/*N*/ ScPoolHelper::~ScPoolHelper() +/*N*/ { +/*N*/ delete pEnginePool; +/*N*/ delete pEditPool; +/*N*/ delete pFormTable; +/*N*/ delete pStylePool; +/*N*/ delete pDocPool; +/*N*/ } + +/*N*/ void ScPoolHelper::SourceDocumentGone() +/*N*/ { +/*N*/ // reset all pointers to the source document +/*N*/ pStylePool->SetDocument( NULL ); +/*N*/ pFormTable->SetColorLink( Link() ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_sortparam.cxx b/binfilter/bf_sc/source/core/data/sc_sortparam.cxx new file mode 100644 index 000000000000..10ec7a97c5b1 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_sortparam.cxx @@ -0,0 +1,98 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "sortparam.hxx" + +namespace binfilter { + + +//------------------------------------------------------------------------ + +/*N*/ ScSortParam::ScSortParam() +/*N*/ { +/*N*/ Clear(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScSortParam::ScSortParam( const ScSortParam& r ) : +/*N*/ nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2), +/*N*/ bHasHeader(r.bHasHeader),bCaseSens(r.bCaseSens), +/*N*/ bByRow(r.bByRow),bUserDef(r.bUserDef),nUserIndex(r.nUserIndex),bIncludePattern(r.bIncludePattern), +/*N*/ bInplace(r.bInplace), +/*N*/ nDestTab(r.nDestTab),nDestCol(r.nDestCol),nDestRow(r.nDestRow), +/*N*/ aCollatorLocale( r.aCollatorLocale ), aCollatorAlgorithm( r.aCollatorAlgorithm ) +/*N*/ { +/*N*/ for (USHORT i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ bDoSort[i] = r.bDoSort[i]; +/*N*/ nField[i] = r.nField[i]; +/*N*/ bAscending[i] = r.bAscending[i]; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScSortParam::Clear() +/*N*/ { +/*N*/ nCol1=nRow1=nCol2=nRow2=nDestTab=nDestCol=nDestRow=nUserIndex = 0; +/*N*/ bHasHeader=bCaseSens=bUserDef = FALSE; +/*N*/ bByRow=bIncludePattern=bInplace = TRUE; +/*N*/ aCollatorLocale = ::com::sun::star::lang::Locale(); +/*N*/ aCollatorAlgorithm.Erase(); +/*N*/ +/*N*/ for (USHORT i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ bDoSort[i] = FALSE; +/*N*/ nField[i] = 0; +/*N*/ bAscending[i] = TRUE; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_stlpool.cxx b/binfilter/bf_sc/source/core/data/sc_stlpool.cxx new file mode 100644 index 000000000000..d1cf7627da44 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_stlpool.cxx @@ -0,0 +1,576 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include "scitems.hxx" +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svx/algitem.hxx> +#include <bf_svx/boxitem.hxx> +#include <bf_svx/brshitem.hxx> +#include <bf_svx/editobj.hxx> +#include <bf_svx/fhgtitem.hxx> + + + +#include <bf_svx/itemdata.hxx> + +#include <tools/date.hxx> + +#include <tools/time.hxx> + +#include <bf_svx/flditem.hxx> +#include <bf_svx/fontitem.hxx> +#include <bf_svx/postitem.hxx> +#include <bf_svx/udlnitem.hxx> +#include <bf_svx/wghtitem.hxx> +#include <bf_svtools/zforlist.hxx> +#include <vcl/outdev.hxx> +#include <vcl/svapp.hxx> + +#include "bf_sc.hrc" +#include "attrib.hxx" +#include "globstr.hrc" +#include "document.hxx" +#include "stlpool.hxx" +#include "stlsheet.hxx" +#include "rechead.hxx" +#include "editutil.hxx" +#include "patattr.hxx" +namespace binfilter { + + +//======================================================================== + +/*N*/ ScStyleSheetPool::ScStyleSheetPool( SfxItemPool& rPool, +/*N*/ ScDocument* pDocument ) +/*N*/ : SfxStyleSheetPool( rPool ), +/*N*/ pActualStyleSheet( NULL ), +/*N*/ pDoc( pDocument ), +/*N*/ pForceStdName( NULL ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScStyleSheetPool::~ScStyleSheetPool() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScStyleSheetPool::SetDocument( ScDocument* pDocument ) +/*N*/ { +/*N*/ pDoc = pDocument; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScStyleSheetPool::SetForceStdName( const String* pSet ) +/*N*/ { +/*N*/ pForceStdName = pSet; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxStyleSheetBase& ScStyleSheetPool::Make( const String& rName, +/*N*/ SfxStyleFamily eFam, USHORT mask, USHORT nPos ) +/*N*/ { +/*N*/ // When updating styles from a template, Office 5.1 sometimes created +/*N*/ // files with multiple default styles. +/*N*/ // Create new styles in that case: +/*N*/ +/*N*/ //! only when loading? +/*N*/ +/*N*/ if ( rName.EqualsAscii(STRING_STANDARD) && Find( rName, eFam ) != NULL ) +/*N*/ { +/*?*/ DBG_ERROR("renaming additional default style"); +/*?*/ long nCount = aStyles.Count(); +/*?*/ for ( long nAdd = 1; nAdd <= nCount; nAdd++ ) +/*?*/ { +/*?*/ String aNewName = ScGlobal::GetRscString(STR_STYLENAME_STANDARD); +/*?*/ aNewName += String::CreateFromInt32( nAdd ); +/*?*/ if ( Find( aNewName, eFam ) == NULL ) +/*?*/ return SfxStyleSheetPool::Make( aNewName, eFam, mask, nPos ); +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ return SfxStyleSheetPool::Make( rName, eFam, mask, nPos ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxStyleSheetBase* __EXPORT ScStyleSheetPool::Create( +/*N*/ const String& rName, +/*N*/ SfxStyleFamily eFamily, +/*N*/ USHORT nMask ) +/*N*/ { +/*N*/ ScStyleSheet* pSheet = new ScStyleSheet( rName, *this, eFamily, nMask ); +/*N*/ if ( eFamily == SFX_STYLE_FAMILY_PARA && ScGlobal::GetRscString(STR_STYLENAME_STANDARD) != rName ) +/*N*/ pSheet->SetParent( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ); +/*N*/ +/*N*/ return pSheet; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxStyleSheetBase* __EXPORT ScStyleSheetPool::Create( const SfxStyleSheetBase& rStyle ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 DBG_ASSERT( rStyle.ISA(ScStyleSheet), "Invalid StyleSheet-class! :-/" ); +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ +// +// Standard-Vorlagen +// +//------------------------------------------------------------------------ + +#define SCSTR(id) ScGlobal::GetRscString(id) + + +//------------------------------------------------------------------------ + +/*N*/ void lcl_CheckFont( SfxItemSet& rSet, LanguageType eLang, USHORT nFontType, USHORT nItemId ) +/*N*/ { +/*N*/ if ( eLang != LANGUAGE_NONE && eLang != LANGUAGE_DONTKNOW && eLang != LANGUAGE_SYSTEM ) +/*N*/ { +/*N*/ Font aDefFont = OutputDevice::GetDefaultFont( nFontType, eLang, DEFAULTFONT_FLAGS_ONLYONE ); +/*N*/ SvxFontItem aNewItem( aDefFont.GetFamily(), aDefFont.GetName(), aDefFont.GetStyleName(), +/*N*/ aDefFont.GetPitch(), aDefFont.GetCharSet(), nItemId ); +/*N*/ if ( aNewItem != rSet.Get( nItemId ) ) +/*N*/ { +/*?*/ // put item into style's ItemSet only if different from (static) default +/*?*/ rSet.Put( aNewItem ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScStyleSheetPool::CreateStandardStyles() +/*N*/ { +/*N*/ // neue Eintraege auch bei CopyStdStylesFrom eintragen +/*N*/ +/*N*/ Color aColBlack ( COL_BLACK ); +/*N*/ Color aColGrey ( COL_LIGHTGRAY ); +/*N*/ String aStr; +/*N*/ xub_StrLen nStrLen; +/*N*/ String aHelpFile;//XXX JN welcher Text??? +/*N*/ ULONG nNumFmt = 0L; +/*N*/ SfxItemSet* pSet = NULL; +/*N*/ SfxItemSet* pHFSet = NULL; +/*N*/ SvxSetItem* pHFSetItem = NULL; +/*N*/ ScEditEngineDefaulter* pEdEngine = new ScEditEngineDefaulter( EditEngine::CreatePool(), TRUE ); +/*N*/ pEdEngine->SetUpdateMode( FALSE ); +/*N*/ EditTextObject* pEmptyTxtObj = pEdEngine->CreateTextObject(); +/*N*/ EditTextObject* pTxtObj = NULL; +/*N*/ ScPageHFItem* pHeaderItem = new ScPageHFItem( ATTR_PAGE_HEADERRIGHT ); +/*N*/ ScPageHFItem* pFooterItem = new ScPageHFItem( ATTR_PAGE_FOOTERRIGHT ); +/*N*/ ScStyleSheet* pSheet = NULL; +/*N*/ SvxBorderLine aBorderLine ( &aColBlack, DEF_LINE_WIDTH_2 ); +/*N*/ SvxBoxItem aBoxItem ( ATTR_BORDER ); +/*N*/ SvxBoxInfoItem aBoxInfoItem ( ATTR_BORDER_INNER ); +/*N*/ +/*N*/ String aStrStandard = ScGlobal::GetRscString(STR_STYLENAME_STANDARD); +/*N*/ +/*N*/ //========================================================== +/*N*/ // Zellformatvorlagen: +/*N*/ //========================================================== +/*N*/ +/*N*/ //------------ +/*N*/ // 1. Standard +/*N*/ //------------ +/*N*/ pSheet = (ScStyleSheet*) &Make( aStrStandard, SFX_STYLE_FAMILY_PARA, SCSTYLEBIT_STANDARD ); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_CELL_STD ); +/*N*/ +/*N*/ // if default fonts for the document's languages are different from the pool default, +/*N*/ // put them into the default style +/*N*/ // (not as pool defaults, because pool defaults can't be changed by the user) +/*N*/ // the document languages must be set before creating the default styles! +/*N*/ +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ LanguageType eLatin, eCjk, eCtl; +/*N*/ pDoc->GetLanguage( eLatin, eCjk, eCtl ); +/*N*/ +/*N*/ // #108374# / #107782#: If the UI language is Korean, the default Latin font has to +/*N*/ // be queried for Korean, too (the Latin language from the document can't be Korean). +/*N*/ // This is the same logic as in SwDocShell::InitNew. +/*N*/ LanguageType eUiLanguage = Application::GetSettings().GetUILanguage(); +/*N*/ switch( eUiLanguage ) +/*N*/ { +/*N*/ case LANGUAGE_KOREAN: +/*N*/ case LANGUAGE_KOREAN_JOHAB: +/*N*/ eLatin = eUiLanguage; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ lcl_CheckFont( *pSet, eLatin, DEFAULTFONT_LATIN_SPREADSHEET, ATTR_FONT ); +/*N*/ lcl_CheckFont( *pSet, eCjk, DEFAULTFONT_CJK_SPREADSHEET, ATTR_CJK_FONT ); +/*N*/ lcl_CheckFont( *pSet, eCtl, DEFAULTFONT_CTL_SPREADSHEET, ATTR_CTL_FONT ); +/*N*/ +/*N*/ //------------ +/*N*/ // 2. Ergebnis +/*N*/ //------------ +/*N*/ +/*N*/ pSheet = (ScStyleSheet*) &Make( SCSTR( STR_STYLENAME_RESULT ), +/*N*/ SFX_STYLE_FAMILY_PARA, +/*N*/ SCSTYLEBIT_STANDARD ); +/*N*/ pSheet->SetParent( aStrStandard ); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_CELL_ERG ); +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ pSet->Put( SvxWeightItem( WEIGHT_BOLD, ATTR_FONT_WEIGHT ) ); +/*N*/ pSet->Put( SvxPostureItem( ITALIC_NORMAL, ATTR_FONT_POSTURE ) ); +/*N*/ pSet->Put( SvxUnderlineItem( UNDERLINE_SINGLE, ATTR_FONT_UNDERLINE ) ); +/*N*/ +/*N*/ //------------- +/*N*/ // 3. Ergebnis1 +/*N*/ //------------- +/*N*/ +/*N*/ pSheet = (ScStyleSheet*) &Make( SCSTR( STR_STYLENAME_RESULT1 ), +/*N*/ SFX_STYLE_FAMILY_PARA, +/*N*/ SCSTYLEBIT_STANDARD ); +/*N*/ +/*N*/ pSheet->SetParent( SCSTR( STR_STYLENAME_RESULT ) ); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_CELL_ERG1 ); +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ nNumFmt = pDoc->GetFormatTable()->GetStandardFormat( NUMBERFORMAT_CURRENCY, +/*N*/ ScGlobal::eLnge ); +/*N*/ pSet->Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumFmt ) ); +/*N*/ +/*N*/ //---------------- +/*N*/ // 4. Ueberschrift +/*N*/ //---------------- +/*N*/ +/*N*/ pSheet = (ScStyleSheet*) &Make( SCSTR( STR_STYLENAME_HEADLINE ), +/*N*/ SFX_STYLE_FAMILY_PARA, +/*N*/ SCSTYLEBIT_STANDARD ); +/*N*/ +/*N*/ pSheet->SetParent( aStrStandard ); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_CELL_UEB ); +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ pSet->Put( SvxFontHeightItem( 320, 100, ATTR_FONT_HEIGHT ) ); // 16pt +/*N*/ pSet->Put( SvxWeightItem( WEIGHT_BOLD, ATTR_FONT_WEIGHT ) ); +/*N*/ pSet->Put( SvxPostureItem( ITALIC_NORMAL, ATTR_FONT_POSTURE ) ); +/*N*/ pSet->Put( SvxHorJustifyItem( SVX_HOR_JUSTIFY_CENTER, ATTR_HOR_JUSTIFY ) ); +/*N*/ +/*N*/ //----------------- +/*N*/ // 5. Ueberschrift1 +/*N*/ //----------------- +/*N*/ +/*N*/ pSheet = (ScStyleSheet*) &Make( SCSTR( STR_STYLENAME_HEADLINE1 ), +/*N*/ SFX_STYLE_FAMILY_PARA, +/*N*/ SCSTYLEBIT_STANDARD ); +/*N*/ +/*N*/ pSheet->SetParent( SCSTR( STR_STYLENAME_HEADLINE ) ); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_CELL_UEB1 ); +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ pSet->Put( SvxOrientationItem( SVX_ORIENTATION_BOTTOMTOP, ATTR_ORIENTATION ) ); +/*N*/ +/*N*/ //========================================================== +/*N*/ // Seitenformat-Vorlagen: +/*N*/ //========================================================== +/*N*/ +/*N*/ //------------ +/*N*/ // 1. Standard +/*N*/ //------------ +/*N*/ +/*N*/ pSheet = (ScStyleSheet*) &Make( aStrStandard, +/*N*/ SFX_STYLE_FAMILY_PAGE, +/*N*/ SCSTYLEBIT_STANDARD ); +/*N*/ +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_PAGE_STD ); +/*N*/ +/*N*/ // Abstand der Kopf-/Fusszeilen von der Tabelle +/*N*/ pHFSetItem = new SvxSetItem( ((SvxSetItem&)pSet->Get( ATTR_PAGE_HEADERSET ) ) ); +/*N*/ pSet->Put( *pHFSetItem, ATTR_PAGE_HEADERSET ); +/*N*/ pSet->Put( *pHFSetItem, ATTR_PAGE_FOOTERSET ); +/*N*/ DELETEZ( pHFSetItem ); +/*N*/ +/*N*/ //---------------------------------------- +/*N*/ // Kopfzeile: +/*N*/ // [leer][\TABELLE\][leer] +/*N*/ //---------------------------------------- +/*N*/ pEdEngine->SetText(EMPTY_STRING); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxTableField()), ESelection() ); +/*N*/ pTxtObj = pEdEngine->CreateTextObject(); +/*N*/ pHeaderItem->SetLeftArea ( *pEmptyTxtObj ); +/*N*/ pHeaderItem->SetCenterArea( *pTxtObj ); +/*N*/ pHeaderItem->SetRightArea ( *pEmptyTxtObj ); +/*N*/ pSet->Put( *pHeaderItem ); +/*N*/ DELETEZ( pTxtObj ); +/*N*/ +/*N*/ //---------------------------------------- +/*N*/ // Fusszeile: +/*N*/ // [leer][Seite \SEITE\][leer] +/*N*/ //---------------------------------------- +/*N*/ aStr = SCSTR( STR_PAGE ); aStr += ' '; +/*N*/ pEdEngine->SetText( aStr ); +/*N*/ nStrLen = aStr.Len(); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxPageField()), ESelection(0,nStrLen,0,nStrLen) ); +/*N*/ pTxtObj = pEdEngine->CreateTextObject(); +/*N*/ pFooterItem->SetLeftArea ( *pEmptyTxtObj ); +/*N*/ pFooterItem->SetCenterArea( *pTxtObj ); +/*N*/ pFooterItem->SetRightArea ( *pEmptyTxtObj ); +/*N*/ pSet->Put( *pFooterItem ); +/*N*/ DELETEZ( pTxtObj ); +/*N*/ +/*N*/ //---------- +/*N*/ // 2. Report +/*N*/ //---------- +/*N*/ +/*N*/ pSheet = (ScStyleSheet*) &Make( SCSTR( STR_STYLENAME_REPORT ), +/*N*/ SFX_STYLE_FAMILY_PAGE, +/*N*/ SCSTYLEBIT_STANDARD ); +/*N*/ pSet = &pSheet->GetItemSet(); +/*N*/ pSheet->SetHelpId( aHelpFile, HID_SC_SHEET_PAGE_REP ); +/*N*/ +/*N*/ // Hintergrund und Umrandung +/*N*/ aBoxItem.SetLine( &aBorderLine, BOX_LINE_TOP ); +/*N*/ aBoxItem.SetLine( &aBorderLine, BOX_LINE_BOTTOM ); +/*N*/ aBoxItem.SetLine( &aBorderLine, BOX_LINE_LEFT ); +/*N*/ aBoxItem.SetLine( &aBorderLine, BOX_LINE_RIGHT ); +/*N*/ aBoxItem.SetDistance( 10 ); // 0.2mm +/*N*/ aBoxInfoItem.SetValid( VALID_TOP, TRUE ); +/*N*/ aBoxInfoItem.SetValid( VALID_BOTTOM, TRUE ); +/*N*/ aBoxInfoItem.SetValid( VALID_LEFT, TRUE ); +/*N*/ aBoxInfoItem.SetValid( VALID_RIGHT, TRUE ); +/*N*/ aBoxInfoItem.SetValid( VALID_DISTANCE, TRUE ); +/*N*/ aBoxInfoItem.SetTable( FALSE ); +/*N*/ aBoxInfoItem.SetDist ( TRUE ); +/*N*/ +/*N*/ pHFSetItem = new SvxSetItem( ((SvxSetItem&)pSet->Get( ATTR_PAGE_HEADERSET ) ) ); +/*N*/ pHFSet = &(pHFSetItem->GetItemSet()); +/*N*/ +/*N*/ pHFSet->Put( SvxBrushItem( aColGrey, ATTR_BACKGROUND ) ); +/*N*/ pHFSet->Put( aBoxItem ); +/*N*/ pHFSet->Put( aBoxInfoItem ); +/*N*/ pSet->Put( *pHFSetItem, ATTR_PAGE_HEADERSET ); +/*N*/ pSet->Put( *pHFSetItem, ATTR_PAGE_FOOTERSET ); +/*N*/ DELETEZ( pHFSetItem ); +/*N*/ +/*N*/ //---------------------------------------- +/*N*/ // Kopfzeile: +/*N*/ // [\TABELLE\ (\DATEI\)][leer][\DATUM\, \ZEIT\] +/*N*/ //---------------------------------------- +/*N*/ aStr = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(" ()")); +/*N*/ pEdEngine->SetText( aStr ); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxFileField()), ESelection(0,2,0,2) ); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxTableField()), ESelection() ); +/*N*/ pTxtObj = pEdEngine->CreateTextObject(); +/*N*/ pHeaderItem->SetLeftArea( *pTxtObj ); +/*N*/ pHeaderItem->SetCenterArea( *pEmptyTxtObj ); +/*N*/ DELETEZ( pTxtObj ); +/*N*/ aStr = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(", ")); +/*N*/ pEdEngine->SetText( aStr ); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxTimeField()), ESelection(0,2,0,2) ); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxDateField(Date(),SVXDATETYPE_VAR)), +/*N*/ ESelection() ); +/*N*/ pTxtObj = pEdEngine->CreateTextObject(); +/*N*/ pHeaderItem->SetRightArea( *pTxtObj ); +/*N*/ DELETEZ( pTxtObj ); +/*N*/ pSet->Put( *pHeaderItem ); +/*N*/ +/*N*/ //---------------------------------------- +/*N*/ // Fusszeile: +/*N*/ // [leer][Seite: \SEITE\ / \SEITEN\][leer] +/*N*/ //---------------------------------------- +/*N*/ aStr = SCSTR( STR_PAGE ); aStr += ' '; +/*N*/ nStrLen = aStr.Len(); +/*N*/ aStr.AppendAscii(RTL_CONSTASCII_STRINGPARAM(" / ")); +/*N*/ xub_StrLen nStrLen2 = aStr.Len(); +/*N*/ pEdEngine->SetText( aStr ); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxPagesField()), ESelection(0,nStrLen2,0,nStrLen2) ); +/*N*/ pEdEngine->QuickInsertField( SvxFieldItem(SvxPageField()), ESelection(0,nStrLen,0,nStrLen) ); +/*N*/ pTxtObj = pEdEngine->CreateTextObject(); +/*N*/ pFooterItem->SetLeftArea ( *pEmptyTxtObj ); +/*N*/ pFooterItem->SetCenterArea( *pTxtObj ); +/*N*/ pFooterItem->SetRightArea ( *pEmptyTxtObj ); +/*N*/ pSet->Put( *pFooterItem ); +/*N*/ DELETEZ( pTxtObj ); +/*N*/ +/*N*/ //---------------------------------------------------- +/*N*/ DELETEZ( pEmptyTxtObj ); +/*N*/ DELETEZ( pHeaderItem ); +/*N*/ DELETEZ( pFooterItem ); +/*N*/ DELETEZ( pEdEngine ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScStyleSheetPool::UpdateStdNames() +/*N*/ { +/*N*/ // Standard-Styles den richtigen Namen in der Programm-Sprache geben +/*N*/ +/*N*/ String aHelpFile; +/*N*/ ULONG nCount = aStyles.Count(); +/*N*/ for (ULONG n=0; n<nCount; n++) +/*N*/ { +/*N*/ SfxStyleSheetBase* pStyle = aStyles.GetObject(n); +/*N*/ if (!pStyle->IsUserDefined()) +/*N*/ { +/*N*/ String aOldName = pStyle->GetName(); +/*N*/ ULONG nHelpId = pStyle->GetHelpId( aHelpFile ); +/*N*/ SfxStyleFamily eFam = pStyle->GetFamily(); +/*N*/ +/*N*/ BOOL bHelpKnown = TRUE; +/*N*/ String aNewName; +/*N*/ USHORT nNameId = 0; +/*N*/ switch( nHelpId ) +/*N*/ { +/*N*/ case HID_SC_SHEET_CELL_STD: +/*N*/ case HID_SC_SHEET_PAGE_STD: nNameId = STR_STYLENAME_STANDARD; break; +/*N*/ case HID_SC_SHEET_CELL_ERG: nNameId = STR_STYLENAME_RESULT; break; +/*N*/ case HID_SC_SHEET_CELL_ERG1: nNameId = STR_STYLENAME_RESULT1; break; +/*N*/ case HID_SC_SHEET_CELL_UEB: nNameId = STR_STYLENAME_HEADLINE; break; +/*N*/ case HID_SC_SHEET_CELL_UEB1: nNameId = STR_STYLENAME_HEADLINE1; break; +/*N*/ case HID_SC_SHEET_PAGE_REP: nNameId = STR_STYLENAME_REPORT; break; +/*N*/ default: +/*N*/ // 0 oder falsche (alte) HelpId +/*N*/ bHelpKnown = FALSE; +/*N*/ } +/*N*/ if (bHelpKnown) +/*N*/ { +/*N*/ if ( nNameId ) +/*N*/ aNewName = SCSTR( nNameId ); +/*N*/ +/*N*/ if ( aNewName.Len() && aNewName != aOldName && !Find( aNewName, eFam ) ) +/*N*/ { +/*N*/ DBG_TRACE( "Renaming style..." ); +/*N*/ +/*N*/ pStyle->SetName( aNewName ); // setzt auch Parents um +/*N*/ +/*N*/ // Styles in Patterns sind schon auf Pointer umgesetzt +/*N*/ if (eFam == SFX_STYLE_FAMILY_PAGE) +/*N*/ { +/*N*/ // Page-Styles umsetzen +/*N*/ // TableCount am Doc ist noch nicht initialisiert +/*N*/ for (USHORT nTab=0; nTab<=MAXTAB && pDoc->HasTable(nTab); nTab++) +/*N*/ if (pDoc->GetPageStyle(nTab) == aOldName) +/*?*/ pDoc->SetPageStyle(nTab, aNewName); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // wrong or no HelpId -> set new HelpId +/*N*/ +/*N*/ // no assertion for wrong HelpIds because this happens +/*N*/ // with old files (#67218#) or with old files that were +/*N*/ // saved again with a new version in a different language +/*N*/ // (so SrcVersion doesn't help) +/*N*/ +/*N*/ USHORT nNewId = 0; +/*N*/ if ( eFam == SFX_STYLE_FAMILY_PARA ) +/*N*/ { +/*N*/ if ( aOldName == SCSTR( STR_STYLENAME_STANDARD ) ) +/*N*/ nNewId = HID_SC_SHEET_CELL_STD; +/*N*/ else if ( aOldName == SCSTR( STR_STYLENAME_RESULT ) ) +/*N*/ nNewId = HID_SC_SHEET_CELL_ERG; +/*N*/ else if ( aOldName == SCSTR( STR_STYLENAME_RESULT1 ) ) +/*N*/ nNewId = HID_SC_SHEET_CELL_ERG1; +/*N*/ else if ( aOldName == SCSTR( STR_STYLENAME_HEADLINE ) ) +/*N*/ nNewId = HID_SC_SHEET_CELL_UEB; +/*N*/ else if ( aOldName == SCSTR( STR_STYLENAME_HEADLINE1 ) ) +/*N*/ nNewId = HID_SC_SHEET_CELL_UEB1; +/*N*/ } +/*N*/ else // PAGE +/*N*/ { +/*N*/ if ( aOldName == SCSTR( STR_STYLENAME_STANDARD ) ) +/*N*/ nNewId = HID_SC_SHEET_PAGE_STD; +/*N*/ else if ( aOldName == SCSTR( STR_STYLENAME_REPORT ) ) +/*N*/ nNewId = HID_SC_SHEET_PAGE_REP; +/*N*/ } +/*N*/ +/*N*/ if ( nNewId ) // new ID found from name -> set ID +/*N*/ { +/*?*/ pStyle->SetHelpId( aHelpFile, nNewId ); +/*N*/ } +/*N*/ else if ( nHelpId == 0 ) // no old and no new ID +/*N*/ { +/*N*/ // #71471# probably user defined style without SFXSTYLEBIT_USERDEF set +/*N*/ // (from StarCalc 1.0 import), fixed in src563 and above +/*N*/ //! may also be default style from a different language +/*N*/ //! test if name was generated from StarCalc 1.0 import? +/*N*/ DBG_ASSERT(pDoc->GetSrcVersion() <= SC_SUBTOTAL_BUGFIX, +/*N*/ "user defined style without SFXSTYLEBIT_USERDEF"); +/*N*/ pStyle->SetMask( pStyle->GetMask() | SFXSTYLEBIT_USERDEF ); +/*N*/ } +/*N*/ // else: wrong old ID and no new ID found: +/*N*/ // probably default style from a different language +/*N*/ // -> leave unchanged (HelpId will be set if loaded with matching +/*N*/ // language version later) +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + + + +/*N*/ void ScStyleSheetPool::ConvertFontsAfterLoad() +/*N*/ { +/*N*/ ScFontToSubsFontConverter_AutoPtr xFontConverter; +/*N*/ const ULONG nFlags = FONTTOSUBSFONT_IMPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS; +/*N*/ SfxStyleSheetIterator aIter( this, SFX_STYLE_FAMILY_PARA ); +/*N*/ for ( SfxStyleSheetBase* pStyle = aIter.First(); pStyle; pStyle = aIter.Next() ) +/*N*/ { +/*N*/ const SfxPoolItem* pItem; +/*N*/ if( pStyle->GetItemSet().GetItemState( ATTR_FONT, FALSE, &pItem ) == SFX_ITEM_SET ) +/*N*/ { +/*N*/ const SvxFontItem* pFontItem = (const SvxFontItem*) pItem; +/*N*/ const String& rOldName = pFontItem->GetFamilyName(); +/*N*/ xFontConverter = CreateFontToSubsFontConverter( rOldName, nFlags ); +/*N*/ if ( xFontConverter ) +/*N*/ { +/*?*/ String aNewName( GetFontToSubsFontName( xFontConverter ) ); +/*?*/ if ( aNewName != rOldName ) +/*?*/ { +/*?*/ SvxFontItem aNewItem( pFontItem->GetFamily(), aNewName, +/*?*/ pFontItem->GetStyleName(), pFontItem->GetPitch(), +/*?*/ RTL_TEXTENCODING_DONTKNOW, ATTR_FONT ); +/*?*/ pStyle->GetItemSet().Put( aNewItem ); +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_stlsheet.cxx b/binfilter/bf_sc/source/core/data/sc_stlsheet.cxx new file mode 100644 index 000000000000..3ae2b1445e0f --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_stlsheet.cxx @@ -0,0 +1,317 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ +#include "document.hxx" +#include "stlsheet.hxx" +#include "stlpool.hxx" + +#include "scitems.hxx" +#include <bf_svx/boxitem.hxx> +#include <bf_svx/frmdiritem.hxx> +#include <bf_svx/lrspitem.hxx> +#include <bf_svx/pageitem.hxx> +#include <bf_svx/paperinf.hxx> +#include <bf_svx/sizeitem.hxx> +#include <bf_svx/ulspitem.hxx> +#include <bf_sfx2/printer.hxx> +#include <bf_svtools/itempool.hxx> +#include <bf_svtools/itemset.hxx> + +#include "globstr.hrc" +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ TYPEINIT1(ScStyleSheet, SfxStyleSheet); + +#define TWO_CM 1134 +#define HFDIST_CM 142 + +//======================================================================== + +/*N*/ ScStyleSheet::ScStyleSheet( const String& rName, +/*N*/ ScStyleSheetPool& rPool, +/*N*/ SfxStyleFamily eFamily, +/*N*/ USHORT nMask ) +/*N*/ +/*N*/ : SfxStyleSheet ( rName, rPool, eFamily, nMask ) +/*N*/ , eUsage( UNKNOWN ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScStyleSheet::ScStyleSheet( const ScStyleSheet& rStyle ) +/*N*/ : SfxStyleSheet ( rStyle ) +/*N*/ , eUsage( UNKNOWN ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScStyleSheet::~ScStyleSheet() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ BOOL __EXPORT ScStyleSheet::SetParent( const String& rParentName ) +/*N*/ { +/*N*/ BOOL bResult = FALSE; +/*N*/ String aEffName = rParentName; +/*N*/ SfxStyleSheetBase* pStyle = rPool.Find( aEffName, nFamily ); +/*N*/ if (!pStyle) +/*N*/ { +/*N*/ SfxStyleSheetIterator* pIter = rPool.CreateIterator( nFamily, SFXSTYLEBIT_ALL ); +/*N*/ pStyle = pIter->First(); +/*N*/ if (pStyle) +/*N*/ aEffName = pStyle->GetName(); +/*N*/ } +/*N*/ +/*N*/ if ( pStyle && aEffName != GetName() ) +/*N*/ { +/*N*/ bResult = SfxStyleSheet::SetParent( aEffName ); +/*N*/ if (bResult) +/*N*/ { +/*N*/ SfxItemSet& rParentSet = pStyle->GetItemSet(); +/*N*/ GetItemSet().SetParent( &rParentSet ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bResult; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxItemSet& __EXPORT ScStyleSheet::GetItemSet() +/*N*/ { +/*N*/ if ( !pSet ) +/*N*/ { +/*N*/ switch ( GetFamily() ) +/*N*/ { +/*N*/ case SFX_STYLE_FAMILY_PAGE: +/*N*/ { +/*N*/ // Seitenvorlagen sollen nicht ableitbar sein, +/*N*/ // deshalb werden an dieser Stelle geeignete +/*N*/ // Werte eingestellt. (==Standard-Seitenvorlage) +/*N*/ +/*N*/ SfxItemPool& rPool = GetPool().GetPool(); +/*N*/ pSet = new SfxItemSet( rPool, +/*N*/ ATTR_BACKGROUND, ATTR_BACKGROUND, +/*N*/ ATTR_BORDER, ATTR_SHADOW, +/*N*/ ATTR_LRSPACE, ATTR_PAGE_NULLVALS, +/*M*/ ATTR_WRITINGDIR, ATTR_WRITINGDIR, +/*N*/ ATTR_USERDEF, ATTR_USERDEF, +/*N*/ 0 ); +/*N*/ +/*N*/ // Wenn gerade geladen wird, wird auch der Set hinterher aus der Datei +/*N*/ // gefuellt, es brauchen also keine Defaults gesetzt zu werden. +/*N*/ // GetPrinter wuerde dann auch einen neuen Printer anlegen, weil der +/*N*/ // gespeicherte Printer noch nicht geladen ist! +/*N*/ +/*N*/ ScDocument* pDoc = ((ScStyleSheetPool&)GetPool()).GetDocument(); +/*N*/ if ( pDoc && pDoc->IsLoadingDone() ) +/*N*/ { +/*N*/ // Setzen von sinnvollen Default-Werten: +/*N*/ //!!! const-Document wegcasten (im Ctor mal bei Gelegenheit aendern) +/*N*/ SfxPrinter* pPrinter = pDoc->GetPrinter(); +/*N*/ USHORT nBinCount = pPrinter->GetPaperBinCount(); +/*N*/ SvxPageItem aPageItem( ATTR_PAGE ); +/*N*/ // #50536# PaperBin auf Default lassen, +/*N*/ // nicht auf aktuelle Drucker-Einstellung umsetzen +/*N*/ SvxSizeItem aPaperSizeItem( +/*N*/ ATTR_PAGE_SIZE, +/*N*/ SvxPaperInfo::GetPaperSize(pPrinter) ); +/*N*/ +/*N*/ SvxSetItem aHFSetItem( +/*N*/ (const SvxSetItem&) +/*N*/ rPool.GetDefaultItem(ATTR_PAGE_HEADERSET) ); +/*N*/ +/*N*/ SfxItemSet& rHFSet = aHFSetItem.GetItemSet(); +/*N*/ SvxSizeItem aHFSizeItem( // 0,5 cm + Abstand +/*N*/ ATTR_PAGE_SIZE, +/*N*/ Size( 0, (long)( 500 / HMM_PER_TWIPS ) + HFDIST_CM ) ); +/*N*/ +/*N*/ SvxULSpaceItem aHFDistItem ( HFDIST_CM,// nUp +/*N*/ HFDIST_CM,// nLow +/*N*/ ATTR_ULSPACE ); +/*N*/ +/*N*/ SvxLRSpaceItem aLRSpaceItem( TWO_CM, // nLeft +/*N*/ TWO_CM, // nRight +/*N*/ TWO_CM, // nTLeft +/*N*/ 0, // nFirstLineOffset +/*N*/ ATTR_LRSPACE ); +/*N*/ SvxULSpaceItem aULSpaceItem( TWO_CM, // nUp +/*N*/ TWO_CM, // nLow +/*N*/ ATTR_ULSPACE ); +/*N*/ SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER ); +/*N*/ +/*N*/ aBoxInfoItem.SetTable( FALSE ); +/*N*/ aBoxInfoItem.SetDist( TRUE ); +/*N*/ aBoxInfoItem.SetValid( VALID_DISTANCE, TRUE ); +/*N*/ +/*N*/ aPageItem.SetLandscape( ORIENTATION_LANDSCAPE +/*N*/ == pPrinter->GetOrientation() ); +/*N*/ +/*N*/ rHFSet.Put( aBoxInfoItem ); +/*N*/ rHFSet.Put( aHFSizeItem ); +/*N*/ rHFSet.Put( aHFDistItem ); +/*N*/ rHFSet.Put( SvxLRSpaceItem( 0,0,0,0, ATTR_LRSPACE ) ); // Rand auf Null setzen +/*N*/ +/*N*/ pSet->Put( aHFSetItem, ATTR_PAGE_HEADERSET ); +/*N*/ pSet->Put( aHFSetItem, ATTR_PAGE_FOOTERSET ); +/*N*/ pSet->Put( aBoxInfoItem ); // PoolDefault wg. Formatvorlagen +/*N*/ // nicht ueberschreiben! +/*N*/ +/*M*/ // Writing direction: not as pool default because the default for cells +/*M*/ // must remain FRMDIR_ENVIRONMENT, and each page style's setting is +/*M*/ // supposed to be saved in the file format. +/*M*/ // The page default may be read from a configuration item later. +/*M*/ SvxFrameDirection eDirection = FRMDIR_HORI_LEFT_TOP; +/*M*/ pSet->Put( SvxFrameDirectionItem( eDirection ), ATTR_WRITINGDIR ); +/*M*/ +/*N*/ rPool.SetPoolDefaultItem( aPageItem ); +/*N*/ rPool.SetPoolDefaultItem( aPaperSizeItem ); +/*N*/ rPool.SetPoolDefaultItem( aLRSpaceItem ); +/*N*/ rPool.SetPoolDefaultItem( aULSpaceItem ); +/*N*/ rPool.SetPoolDefaultItem( SfxUInt16Item( ATTR_PAGE_SCALE, 100 ) ); +/*N*/ rPool.SetPoolDefaultItem( SfxUInt16Item( ATTR_PAGE_SCALETOPAGES, 0 ) ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case SFX_STYLE_FAMILY_PARA: +/*N*/ default: +/*N*/ pSet = new SfxItemSet( GetPool().GetPool(), +/*N*/ ATTR_PATTERN_START, ATTR_PATTERN_END, +/*N*/ 0 ); +/*N*/ break; +/*N*/ } +/*N*/ bMySet = TRUE; +/*N*/ } +/*N*/ +/*N*/ return *pSet; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL __EXPORT ScStyleSheet::IsUsed() const +/*N*/ { +/*N*/ if ( GetFamily() == SFX_STYLE_FAMILY_PARA ) +/*N*/ { +/*?*/ // Always query the document to let it decide if a rescan is necessary, +/*?*/ // and store the state. +/*?*/ ScDocument* pDoc = ((ScStyleSheetPool&)rPool).GetDocument(); +/*?*/ if ( pDoc && pDoc->IsStyleSheetUsed( *this, TRUE ) ) +/*?*/ eUsage = USED; +/*?*/ else +/*?*/ eUsage = NOTUSED; +/*?*/ return eUsage == USED; +/*N*/ } +/*N*/ else +/*N*/ return TRUE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void __EXPORT ScStyleSheet::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType, +/*N*/ const SfxHint& rHint, const TypeId& rHintType ) +/*N*/ { +/*N*/ if ( rHint.ISA(SfxSimpleHint) ) +/*N*/ if ( ((SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) +/*N*/ GetItemSet().SetParent( NULL ); +/*N*/ } + +//------------------------------------------------------------------------ + +// #66123# schmutzige Tricks, um die Standard-Vorlage immer als "Standard" zu speichern, +// obwohl der fuer den Benutzer sichtbare Name uebersetzt ist: + +/*N*/ const String& ScStyleSheet::GetName() const +/*N*/ { +/*N*/ const String& rBase = SfxStyleSheet::GetName(); +/*N*/ const String* pForceStdName = ((ScStyleSheetPool&)rPool).GetForceStdName(); +/*N*/ if ( pForceStdName && rBase == ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ) +/*N*/ return *pForceStdName; +/*N*/ else +/*N*/ return rBase; +/*N*/ } + +/*N*/ const String& ScStyleSheet::GetParent() const +/*N*/ { +/*N*/ const String& rBase = SfxStyleSheet::GetParent(); +/*N*/ const String* pForceStdName = ((ScStyleSheetPool&)rPool).GetForceStdName(); +/*N*/ if ( pForceStdName && rBase == ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ) +/*N*/ return *pForceStdName; +/*N*/ else +/*N*/ return rBase; +/*N*/ } + +/*N*/ const String& ScStyleSheet::GetFollow() const +/*N*/ { +/*N*/ const String& rBase = SfxStyleSheet::GetFollow(); +/*N*/ const String* pForceStdName = ((ScStyleSheetPool&)rPool).GetForceStdName(); +/*N*/ if ( pForceStdName && rBase == ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ) +/*N*/ return *pForceStdName; +/*N*/ else +/*N*/ return rBase; +/*N*/ } + +// Verhindern, dass ein Style "Standard" angelegt wird, wenn das nicht der +// Standard-Name ist, weil sonst beim Speichern zwei Styles denselben Namen haetten +// (Beim Laden wird der Style direkt per Make mit dem Namen erzeugt, so dass diese +// Abfrage dann nicht gilt) +//! Wenn irgendwann aus dem Laden SetName aufgerufen wird, muss fuer das Laden ein +//! Flag gesetzt und abgefragt werden. +//! Die ganze Abfrage muss raus, wenn fuer eine neue Datei-Version die Namens-Umsetzung wegfaellt. + +/*N*/ BOOL ScStyleSheet::SetName( const String& rNew ) +/*N*/ { +/*N*/ String aFileStdName = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(STRING_STANDARD)); +/*N*/ if ( rNew == aFileStdName && aFileStdName != ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ) +/*N*/ return FALSE; +/*N*/ else +/*N*/ return SfxStyleSheet::SetName( rNew ); +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_table1.cxx b/binfilter/bf_sc/source/core/data/sc_table1.cxx new file mode 100644 index 000000000000..c445e619d41d --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_table1.cxx @@ -0,0 +1,874 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#ifdef WIN + +// SFX +#define _SFXAPPWIN_HXX +#define _SFX_SAVEOPT_HXX +//#define _SFX_CHILDWIN_HXX *** +#define _SFXCTRLITEM_HXX +#define _SFXPRNMON_HXX +#define _INTRO_HXX +#define _SFXMSGDESCR_HXX +#define _SFXMSGPOOL_HXX +#define _SFXFILEDLG_HXX +#define _PASSWD_HXX +#define _SFXTBXCTRL_HXX +#define _SFXSTBITEM_HXX +#define _SFXMNUITEM_HXX +#define _SFXIMGMGR_HXX +#define _SFXTBXMGR_HXX +#define _SFXSTBMGR_HXX +#define _SFX_MINFITEM_HXX +#define _SFXEVENT_HXX + +//#define _SI_HXX +//#define SI_NODRW +#define _SI_DLL_HXX +#define _SIDLL_HXX +#define _SI_NOITEMS +#define _SI_NOOTHERFORMS +#define _SI_NOSBXCONTROLS +#define _SINOSBXCONTROLS +#define _SI_NODRW // +#define _SI_NOCONTROL +#define _VCBRW_HXX +#define _VCTRLS_HXX +//#define _VCSBX_HXX +#define _VCONT_HXX +#define _VDRWOBJ_HXX +#define _VCATTR_HXX + + +#define _SVX_DAILDLL_HXX +#define _SVX_HYPHEN_HXX +#define _SVX_IMPGRF_HXX +#define _SVX_OPTITEMS_HXX +#define _SVX_OPTGERL_HXX +#define _SVX_OPTSAVE_HXX +#define _SVX_OPTSPELL_HXX +#define _SVX_OPTPATH_HXX +#define _SVX_OPTLINGU_HXX +#define _SVX_RULER_HXX +#define _SVX_RULRITEM_HXX +#define _SVX_SPLWRAP_HXX +#define _SVX_SPLDLG_HXX +#define _SVX_THESDLG_HXX + +#endif //WIN + +// INCLUDE --------------------------------------------------------------- + +#include <unotools/textsearch.hxx> +#include <bf_sfx2/objsh.hxx> + +#include "cell.hxx" +#include "document.hxx" +#include "drwlayer.hxx" +#include "olinetab.hxx" +#include "globstr.hrc" +#include "refupdat.hxx" +#include "markdata.hxx" +#include "progress.hxx" +#include "hints.hxx" // fuer Paint-Broadcast +#include "prnsave.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +extern BOOL bIsOlk, bOderSo; + +// ----------------------------------------------------------------------- + +/*N*/ ScTable::ScTable( ScDocument* pDoc, USHORT nNewTab, const String& rNewName, +/*N*/ BOOL bColInfo, BOOL bRowInfo ) : +/*N*/ pDocument( pDoc ), +/*N*/ aName( rNewName ), +/*N*/ nTab( nNewTab ), +/*N*/ bScenario( FALSE ), +/*N*/ bActiveScenario( FALSE ), +/*N*/ nScenarioFlags( 0 ), +/*N*/ aScenarioColor( COL_LIGHTGRAY ), +/*N*/ nLinkMode( 0 ), +/*N*/ pColWidth( NULL ), +/*N*/ pColFlags( NULL ), +/*N*/ pRowHeight( NULL ), +/*N*/ pRowFlags( NULL ), +/*N*/ pOutlineTable( NULL ), +/*N*/ bVisible( TRUE ), +/*N*/ pSearchParam( NULL ), +/*N*/ pSearchText ( NULL ), +/*N*/ bProtected( FALSE ), +/*N*/ nRecalcLvl( 0 ), +/*N*/ bPageSizeValid( FALSE ), +/*N*/ nRepeatStartX( REPEAT_NONE ), +/*N*/ nRepeatStartY( REPEAT_NONE ), +/*N*/ aPageStyle( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ), +/*N*/ bTableAreaValid( FALSE ), +/*N*/ nPrintRangeCount( 0 ), +/*N*/ pPrintRanges( NULL ), +/*N*/ pRepeatColRange( NULL ), +/*N*/ pRepeatRowRange( NULL ), +/*N*/ nLockCount( 0 ), +/*N*/ pScenarioRanges( NULL ), +/*N*/ pSortCollator( NULL ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ if (bColInfo) +/*N*/ { +/*N*/ pColWidth = new USHORT[ MAXCOL+1 ]; +/*N*/ pColFlags = new BYTE[ MAXCOL+1 ]; +/*N*/ +/*N*/ for (i=0; i<=MAXCOL; i++) +/*N*/ { +/*N*/ pColWidth[i] = STD_COL_WIDTH; +/*N*/ pColFlags[i] = 0; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bRowInfo) +/*N*/ { +/*N*/ pRowHeight = new USHORT[ MAXROW+1 ]; +/*N*/ pRowFlags = new BYTE[ MAXROW+1 ]; +/*N*/ +/*N*/ for (i=0; i<=MAXROW; i++) +/*N*/ { +/*N*/ pRowHeight[i] = ScGlobal::nStdRowHeight; +/*N*/ pRowFlags[i] = 0; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ pDrawLayer->ScAddPage( nTab ); +/*N*/ pDrawLayer->ScRenamePage( nTab, aName ); +/*N*/ ULONG nx = (ULONG) ((double) (MAXCOL+1) * STD_COL_WIDTH * HMM_PER_TWIPS ); +/*N*/ ULONG ny = (ULONG) ((double) (MAXROW+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS ); +/*N*/ pDrawLayer->SetPageSize( nTab, Size( nx, ny ) ); +/*N*/ } +/*N*/ +/*N*/ for (i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].Init( i, nTab, pDocument ); +/*N*/ } + +/*N*/ ScTable::~ScTable() +/*N*/ { +/*N*/ if (!pDocument->IsInDtorClear()) +/*N*/ { +/*?*/ // nicht im dtor die Pages in der falschen Reihenfolge loeschen +/*?*/ // (nTab stimmt dann als Page-Number nicht!) +/*?*/ // In ScDocument::Clear wird hinterher per Clear am DrawLayer alles geloescht. +/*?*/ +/*?*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*?*/ if (pDrawLayer) +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pDrawLayer->ScRemovePage( nTab ); +/*N*/ } +/*N*/ +/*N*/ delete[] pColWidth; +/*N*/ delete[] pRowHeight; +/*N*/ delete[] pColFlags; +/*N*/ delete[] pRowFlags; +/*N*/ delete pOutlineTable; +/*N*/ delete pSearchParam; +/*N*/ delete pSearchText; +/*N*/ delete[] pPrintRanges; +/*N*/ delete pRepeatColRange; +/*N*/ delete pRepeatRowRange; +/*N*/ delete pScenarioRanges; +/*N*/ DestroySortCollator(); +/*N*/ } + +/*N*/ void ScTable::GetName( String& rName ) const +/*N*/ { +/*N*/ rName = aName; +/*N*/ } + +/*N*/ void ScTable::SetName( const String& rNewName ) +/*N*/ { +/*N*/ String aMd( "D\344umling", RTL_TEXTENCODING_MS_1252 ); // ANSI +/*N*/ if( rNewName == aMd ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 bIsOlk = bOderSo = TRUE; +/*N*/ aName = rNewName; +/*N*/ } + +/*N*/ void ScTable::SetVisible( BOOL bVis ) +/*N*/ { +/*N*/ bVisible = bVis; +/*N*/ } + +/*N*/ void ScTable::SetScenario( BOOL bFlag ) +/*N*/ { +/*N*/ bScenario = bFlag; +/*N*/ } + +/*N*/ void ScTable::SetLink( BYTE nMode, +/*N*/ const String& rDoc, const String& rFlt, const String& rOpt, +/*N*/ const String& rTab, ULONG nRefreshDelay ) +/*N*/ { +/*N*/ nLinkMode = nMode; +/*N*/ aLinkDoc = rDoc; // Datei +/*N*/ aLinkFlt = rFlt; // Filter +/*N*/ aLinkOpt = rOpt; // Filter-Optionen +/*N*/ aLinkTab = rTab; // Tabellenname in Quelldatei +/*N*/ nLinkRefreshDelay = nRefreshDelay; // refresh delay in seconds, 0==off +/*N*/ } + +/*N*/ USHORT ScTable::GetOptimalColWidth( USHORT nCol, OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bFormula, const ScMarkData* pMarkData, +/*N*/ BOOL bSimpleTextImport ) +/*N*/ { +/*N*/ return aCol[nCol].GetOptimalColWidth( pDev, nPPTX, nPPTY, rZoomX, rZoomY, +/*N*/ bFormula, STD_COL_WIDTH - STD_EXTRA_WIDTH, pMarkData, bSimpleTextImport ); +/*N*/ } + + +/*N*/ BOOL ScTable::SetOptimalHeight( USHORT nStartRow, USHORT nEndRow, USHORT nExtra, +/*N*/ OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY, +/*N*/ BOOL bForce ) +/*N*/ { +/*N*/ DBG_ASSERT( nExtra==0 || bForce, "autom. OptimalHeight mit Extra" ); +/*N*/ +/*N*/ BOOL bChanged = FALSE; +/*N*/ USHORT nCount = nEndRow-nStartRow+1; +/*N*/ +/*N*/ ScProgress* pProgress = NULL; +/*N*/ if ( nCount > 1 ) +/*N*/ pProgress = new ScProgress( pDocument->GetDocumentShell(), +/*N*/ ScGlobal::GetRscString(STR_PROGRESS_HEIGHTING), GetWeightedCount() ); +/*N*/ +/*N*/ USHORT* pHeight = new USHORT[nCount]; // Twips ! +/*N*/ memset( pHeight, 0, sizeof(USHORT) * nCount ); +/*N*/ +/*N*/ // zuerst einmal ueber den ganzen Bereich +/*N*/ // (mit der letzten Spalte in der Hoffnung, dass die am ehesten noch auf +/*N*/ // Standard formatiert ist) +/*N*/ +/*N*/ aCol[MAXCOL].GetOptimalHeight( +/*N*/ nStartRow, nEndRow, pHeight, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bForce, 0, 0 ); +/*N*/ +/*N*/ // daraus Standardhoehe suchen, die im unteren Bereich gilt +/*N*/ +/*N*/ USHORT nMinHeight = pHeight[nCount-1]; +/*N*/ USHORT nPos = nCount-1; +/*N*/ while ( nPos && pHeight[nPos-1] >= nMinHeight ) +/*N*/ --nPos; +/*N*/ USHORT nMinStart = nStartRow + nPos; +/*N*/ +/*N*/ long nWeightedCount = 0; +/*N*/ for (USHORT nCol=0; nCol<MAXCOL; nCol++) // MAXCOL schon oben +/*N*/ { +/*N*/ aCol[nCol].GetOptimalHeight( +/*N*/ nStartRow, nEndRow, pHeight, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bForce, +/*N*/ nMinHeight, nMinStart ); +/*N*/ +/*N*/ if (pProgress) +/*N*/ { +/*N*/ long nWeight = aCol[nCol].GetWeightedCount(); +/*N*/ if (nWeight) // nochmal denselben Status muss auch nicht sein +/*N*/ { +/*N*/ nWeightedCount += nWeight; +/*N*/ pProgress->SetState( nWeightedCount ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ USHORT nRngStart; +/*N*/ USHORT nRngEnd; +/*N*/ USHORT nLast = 0; +/*N*/ USHORT i; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ if ( (pRowFlags[nStartRow+i] & CR_MANUALSIZE) == 0 || bForce ) +/*N*/ { +/*N*/ if (nExtra) +/*N*/ pRowFlags[nStartRow+i] |= CR_MANUALSIZE; +/*N*/ else +/*N*/ pRowFlags[nStartRow+i] &= ~CR_MANUALSIZE; +/*N*/ +/*N*/ if (nLast) +/*N*/ { +/*N*/ if (pHeight[i]+nExtra == nLast) +/*N*/ nRngEnd = nStartRow+i; +/*N*/ else +/*N*/ { +/*N*/ bChanged |= SetRowHeightRange( nRngStart, nRngEnd, nLast, nPPTX, nPPTY ); +/*N*/ nLast = 0; +/*N*/ } +/*N*/ } +/*N*/ if (!nLast) +/*N*/ { +/*N*/ nLast = pHeight[i]+nExtra; +/*N*/ nRngStart = nStartRow+i; +/*N*/ nRngEnd = nStartRow+i; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (nLast) +/*N*/ bChanged |= SetRowHeightRange( nRngStart, nRngEnd, nLast, nPPTX, nPPTY ); +/*N*/ nLast = 0; +/*N*/ } +/*N*/ } +/*N*/ if (nLast) +/*N*/ bChanged |= SetRowHeightRange( nRngStart, nRngEnd, nLast, nPPTX, nPPTY ); +/*N*/ +/*N*/ delete[] pHeight; +/*N*/ delete pProgress; +/*N*/ +/*N*/ return bChanged; +/*N*/ } + +/*N*/ BOOL ScTable::GetCellArea( USHORT& rEndCol, USHORT& rEndRow ) const +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nMaxX = 0; +/*N*/ USHORT nMaxY = 0; +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ if (!aCol[i].IsEmptyVisData(TRUE)) // TRUE = Notizen zaehlen auch +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ nMaxX = i; +/*N*/ USHORT nColY = aCol[i].GetLastVisDataPos(TRUE); +/*N*/ if (nColY > nMaxY) +/*N*/ nMaxY = nColY; +/*N*/ } +/*N*/ +/*N*/ rEndCol = nMaxX; +/*N*/ rEndRow = nMaxY; +/*N*/ return bFound; +/*N*/ } + +/*N*/ BOOL ScTable::GetTableArea( USHORT& rEndCol, USHORT& rEndRow ) const +/*N*/ { +/*N*/ BOOL bRet = TRUE; //! merken? +/*N*/ if (!bTableAreaValid) +/*N*/ { +/*N*/ bRet = GetPrintArea( ((ScTable*)this)->nTableAreaX, +/*N*/ ((ScTable*)this)->nTableAreaY, TRUE ); +/*N*/ ((ScTable*)this)->bTableAreaValid = TRUE; +/*N*/ } +/*N*/ rEndCol = nTableAreaX; +/*N*/ rEndRow = nTableAreaY; +/*N*/ return bRet; +/*N*/ } + +/* vorher: + + BOOL bFound = FALSE; + USHORT nMaxX = 0; + USHORT nMaxY = 0; + for (USHORT i=0; i<=MAXCOL; i++) + if (!aCol[i].IsEmpty()) + { + bFound = TRUE; + nMaxX = i; + USHORT nColY = aCol[i].GetLastEntryPos(); + if (nColY > nMaxY) + nMaxY = nColY; + } + + rEndCol = nMaxX; + rEndRow = nMaxY; + return bFound; +*/ + +/*N*/ BOOL ScTable::GetPrintArea( USHORT& rEndCol, USHORT& rEndRow, BOOL bNotes ) const +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nMaxX = 0; +/*N*/ USHORT nMaxY = 0; +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<=MAXCOL; i++) // Attribute testen +/*N*/ { +/*N*/ USHORT nFirstRow,nLastRow; +/*N*/ if (aCol[i].HasVisibleAttr( nFirstRow,nLastRow, FALSE )) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ nMaxX = i; +/*N*/ if (nLastRow > nMaxY) +/*N*/ nMaxY = nLastRow; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (nMaxX == MAXCOL) // Attribute rechts weglassen +/*N*/ { +/*N*/ --nMaxX; +/*N*/ while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1]) ) +/*N*/ --nMaxX; +/*N*/ } +/*N*/ +/*N*/ for (i=0; i<=MAXCOL; i++) // Daten testen +/*N*/ if (!aCol[i].IsEmptyVisData(bNotes)) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ if (i>nMaxX) +/*N*/ nMaxX = i; +/*N*/ USHORT nColY = aCol[i].GetLastVisDataPos(bNotes); +/*N*/ if (nColY > nMaxY) +/*N*/ nMaxY = nColY; +/*N*/ } +/*N*/ +/*N*/ rEndCol = nMaxX; +/*N*/ rEndRow = nMaxY; +/*N*/ return bFound; +/*N*/ } + + + +/*N*/ BOOL ScTable::GetDataStart( USHORT& rStartCol, USHORT& rStartRow ) const +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nMinX = MAXCOL; +/*N*/ USHORT nMinY = MAXROW; +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<=MAXCOL; i++) // Attribute testen +/*N*/ { +/*N*/ USHORT nFirstRow,nLastRow; +/*N*/ if (aCol[i].HasVisibleAttr( nFirstRow,nLastRow, TRUE )) +/*N*/ { +/*N*/ if (!bFound) +/*N*/ nMinX = i; +/*N*/ bFound = TRUE; +/*N*/ if (nFirstRow < nMinY) +/*N*/ nMinY = nFirstRow; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (nMinX == 0) // Attribute links weglassen +/*N*/ { +/*N*/ if ( aCol[0].IsVisibleAttrEqual(aCol[1]) ) // keine einzelnen +/*N*/ { +/*?*/ ++nMinX; +/*?*/ while ( nMinX<MAXCOL && aCol[nMinX].IsVisibleAttrEqual(aCol[nMinX-1]) ) +/*?*/ ++nMinX; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ BOOL bDatFound = FALSE; +/*N*/ for (i=0; i<=MAXCOL; i++) // Daten testen +/*N*/ if (!aCol[i].IsEmptyVisData(TRUE)) +/*N*/ { +/*N*/ if (!bDatFound && i<nMinX) +/*N*/ nMinX = i; +/*N*/ bFound = bDatFound = TRUE; +/*N*/ USHORT nColY = aCol[i].GetFirstVisDataPos(TRUE); +/*N*/ if (nColY < nMinY) +/*N*/ nMinY = nColY; +/*N*/ } +/*N*/ +/*N*/ rStartCol = nMinX; +/*N*/ rStartRow = nMinY; +/*N*/ return bFound; +/*N*/ } + +/*N*/ void ScTable::GetDataArea( USHORT& rStartCol, USHORT& rStartRow, USHORT& rEndCol, USHORT& rEndRow, +/*N*/ BOOL bIncludeOld ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 BOOL bLeft = FALSE; +/*N*/ } + + + + + + +/*N*/ void ScTable::GetNextPos( USHORT& rCol, USHORT& rRow, short nMovX, short nMovY, +/*N*/ BOOL bMarked, BOOL bUnprotected, const ScMarkData& rMark ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if (bUnprotected && !IsProtected()) // Tabelle ueberhaupt geschuetzt? +/*N*/ } + +/*N*/ BOOL ScTable::GetNextMarkedCell( USHORT& rCol, USHORT& rRow, const ScMarkData& rMark ) +/*N*/ { +/*N*/ const ScMarkArray* pMarkArray = rMark.GetArray(); +/*N*/ DBG_ASSERT(pMarkArray,"GetNextMarkedCell ohne MarkArray"); +/*N*/ if ( !pMarkArray ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ++rRow; // naechste Zelle ist gesucht +/*N*/ +/*N*/ while ( rCol <= MAXCOL ) +/*N*/ { +/*N*/ const ScMarkArray& rArray = pMarkArray[rCol]; +/*N*/ while ( rRow <= MAXROW ) +/*N*/ { +/*N*/ USHORT nStart = (USHORT) rArray.GetNextMarked( (short) rRow, FALSE ); +/*N*/ if ( nStart <= MAXROW ) +/*N*/ { +/*N*/ USHORT nEnd = rArray.GetMarkEnd( nStart, FALSE ); +/*N*/ ScColumnIterator aColIter( &aCol[rCol], nStart, nEnd ); +/*N*/ USHORT nCellRow; +/*N*/ ScBaseCell* pCell = NULL; +/*N*/ while ( aColIter.Next( nCellRow, pCell ) ) +/*N*/ { +/*N*/ if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) +/*N*/ { +/*N*/ rRow = nCellRow; +/*N*/ return TRUE; // Zelle gefunden +/*N*/ } +/*N*/ } +/*N*/ rRow = nEnd + 1; // naechsten markierten Bereich suchen +/*N*/ } +/*N*/ else +/*N*/ rRow = MAXROW + 1; // Ende der Spalte +/*N*/ } +/*N*/ rRow = 0; +/*N*/ ++rCol; // naechste Spalte testen +/*N*/ } +/*N*/ +/*N*/ return FALSE; // alle Spalten durch +/*N*/ } + +/*N*/ void ScTable::UpdateDrawRef( UpdateRefMode eUpdateRefMode, USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ if ( nTab >= nTab1 && nTab <= nTab2 && nDz == 0 ) // only within the table +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ } +/*N*/ } + +/*N*/ void ScTable::UpdateReference( UpdateRefMode eUpdateRefMode, USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, short nDx, short nDy, short nDz, +/*N*/ ScDocument* pUndoDoc, BOOL bIncludeDraw ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT iMax; +/*N*/ if ( eUpdateRefMode == URM_COPY ) +/*N*/ { +/*N*/ i = nCol1; +/*N*/ iMax = nCol2; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ i = 0; +/*N*/ iMax = MAXCOL; +/*N*/ } +/*N*/ for ( ; i<=iMax; i++) +/*N*/ aCol[i].UpdateReference( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, +/*N*/ nDx, nDy, nDz, pUndoDoc ); +/*N*/ +/*N*/ if ( bIncludeDraw ) +/*N*/ UpdateDrawRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz ); +/*N*/ +/*N*/ if ( nTab >= nTab1 && nTab <= nTab2 && nDz == 0 ) // print ranges: only within the table +/*N*/ { +/*?*/ USHORT nSTab,nETab,nSCol,nSRow,nECol,nERow; +/*?*/ BOOL bRecalcPages = FALSE; +/*?*/ +/*?*/ if ( pPrintRanges && nPrintRangeCount ) +/*?*/ for ( i=0; i<nPrintRangeCount; i++ ) +/*?*/ { +/*?*/ nSTab = nETab = pPrintRanges[i].aStart.Tab(); +/*?*/ nSCol = pPrintRanges[i].aStart.Col(); +/*?*/ nSRow = pPrintRanges[i].aStart.Row(); +/*?*/ nECol = pPrintRanges[i].aEnd.Col(); +/*?*/ nERow = pPrintRanges[i].aEnd.Row(); +/*?*/ +/*?*/ if ( ScRefUpdate::Update( pDocument, eUpdateRefMode, +/*?*/ nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, +/*?*/ nDx,nDy,nDz, +/*?*/ nSCol,nSRow,nSTab, nECol,nERow,nETab ) ) +/*?*/ { +/*?*/ pPrintRanges[i] = ScRange( nSCol, nSRow, nSTab, nECol, nERow, nSTab ); +/*?*/ bRecalcPages = TRUE; +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ if ( pRepeatColRange ) +/*?*/ { +/*?*/ nSTab = nETab = pRepeatColRange->aStart.Tab(); +/*?*/ nSCol = pRepeatColRange->aStart.Col(); +/*?*/ nSRow = pRepeatColRange->aStart.Row(); +/*?*/ nECol = pRepeatColRange->aEnd.Col(); +/*?*/ nERow = pRepeatColRange->aEnd.Row(); +/*?*/ +/*?*/ if ( ScRefUpdate::Update( pDocument, eUpdateRefMode, +/*?*/ nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, +/*?*/ nDx,nDy,nDz, +/*?*/ nSCol,nSRow,nSTab, nECol,nERow,nETab ) ) +/*?*/ { +/*?*/ *pRepeatColRange = ScRange( nSCol, nSRow, nSTab, nECol, nERow, nSTab ); +/*?*/ bRecalcPages = TRUE; +/*?*/ nRepeatStartX = nSCol; // fuer UpdatePageBreaks +/*?*/ nRepeatEndX = nECol; +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ if ( pRepeatRowRange ) +/*?*/ { +/*?*/ nSTab = nETab = pRepeatRowRange->aStart.Tab(); +/*?*/ nSCol = pRepeatRowRange->aStart.Col(); +/*?*/ nSRow = pRepeatRowRange->aStart.Row(); +/*?*/ nECol = pRepeatRowRange->aEnd.Col(); +/*?*/ nERow = pRepeatRowRange->aEnd.Row(); +/*?*/ +/*?*/ if ( ScRefUpdate::Update( pDocument, eUpdateRefMode, +/*?*/ nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, +/*?*/ nDx,nDy,nDz, +/*?*/ nSCol,nSRow,nSTab, nECol,nERow,nETab ) ) +/*?*/ { +/*?*/ *pRepeatRowRange = ScRange( nSCol, nSRow, nSTab, nECol, nERow, nSTab ); +/*?*/ bRecalcPages = TRUE; +/*?*/ nRepeatStartY = nSRow; // fuer UpdatePageBreaks +/*?*/ nRepeatEndY = nERow; +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ // updating print ranges is not necessary with multiple print ranges +/*?*/ if ( bRecalcPages && GetPrintRangeCount() <= 1 ) +/*?*/ { +/*?*/ UpdatePageBreaks(NULL); +/*?*/ +/*?*/ SfxObjectShell* pDocSh = pDocument->GetDocumentShell(); +/*?*/ if (pDocSh) +/*?*/ pDocSh->Broadcast( ScPaintHint( +/*?*/ ScRange(0,0,nTab,MAXCOL,MAXROW,nTab), +/*?*/ PAINT_GRID ) ); +/*?*/ } +/*N*/ } +/*N*/ } + + + +/*N*/ void ScTable::UpdateInsertTab(USHORT nTable) +/*N*/ { +/*N*/ if (nTab >= nTable) nTab++; +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) aCol[i].UpdateInsertTab(nTable); +/*N*/ } + + +/*N*/ void ScTable::UpdateDeleteTab( USHORT nTable, BOOL bIsMove, ScTable* pRefUndo ) +/*N*/ { +/*N*/ if (nTab > nTable) nTab--; +/*N*/ +/*N*/ USHORT i; +/*N*/ if (pRefUndo) +/*N*/ for (i=0; i <= MAXCOL; i++) aCol[i].UpdateDeleteTab(nTable, bIsMove, &pRefUndo->aCol[i]); +/*N*/ else +/*N*/ for (i=0; i <= MAXCOL; i++) aCol[i].UpdateDeleteTab(nTable, bIsMove, NULL); +/*N*/ } + +/*N*/ void ScTable::UpdateCompile( BOOL bForceIfNameInUse ) +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) +/*N*/ { +/*N*/ aCol[i].UpdateCompile( bForceIfNameInUse ); +/*N*/ } +/*N*/ } + +/*N*/ void ScTable::SetTabNo(USHORT nNewTab) +/*N*/ { +/*N*/ nTab = nNewTab; +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) aCol[i].SetTabNo(nNewTab); +/*N*/ } + +/*N*/ BOOL ScTable::IsRangeNameInUse(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, + USHORT nIndex) const +/*N*/ { +/*N*/ BOOL bInUse = FALSE; +/*N*/ for (USHORT i = nCol1; !bInUse && (i <= nCol2) && (i <= MAXCOL); i++) +/*N*/ bInUse = aCol[i].IsRangeNameInUse(nRow1, nRow2, nIndex); +/*N*/ return bInUse; +/*N*/ } + +/*N*/ void ScTable::ReplaceRangeNamesInUse(USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, +/*N*/ const ScIndexMap& rMap ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 for (USHORT i = nCol1; i <= nCol2 && (i <= MAXCOL); i++) +/*N*/ } + +/*N*/ void ScTable::ExtendPrintArea( OutputDevice* pDev, +/*N*/ USHORT nStartCol, USHORT nStartRow, USHORT& rEndCol, USHORT nEndRow ) +/*N*/ { +/*N*/ if ( !pColFlags || !pRowFlags ) +/*N*/ { +/*N*/ DBG_ERROR("keine ColInfo oder RowInfo in ExtendPrintArea"); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ Point aPix1000 = pDev->LogicToPixel( Point(1000,1000), MAP_TWIP ); +/*N*/ double nPPTX = aPix1000.X() / 1000.0; +/*N*/ double nPPTY = aPix1000.Y() / 1000.0; +/*N*/ +/*N*/ BOOL bEmpty[MAXCOL+1]; +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ bEmpty[i] = ( aCol[i].GetCellCount() == 0 ); +/*N*/ +/*N*/ USHORT nIndex; +/*N*/ USHORT nPrintCol = rEndCol; +/*N*/ for (USHORT nRow = nStartRow; nRow<=nEndRow; nRow++) +/*N*/ { +/*N*/ if ( ( pRowFlags[nRow] & CR_HIDDEN ) == 0 ) +/*N*/ { +/*N*/ USHORT nDataCol = rEndCol; +/*N*/ while (nDataCol > 0 && ( bEmpty[nDataCol] || !aCol[nDataCol].Search(nRow,nIndex) ) ) +/*N*/ --nDataCol; +/*N*/ if ( ( pColFlags[nDataCol] & CR_HIDDEN ) == 0 ) +/*N*/ { +/*N*/ ScBaseCell* pCell = aCol[nDataCol].GetCell(nRow); +/*N*/ if (pCell) +/*N*/ { +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ if (eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT +/*N*/ || (eType == CELLTYPE_FORMULA && !((ScFormulaCell*)pCell)->IsValue()) ) +/*N*/ { +/*N*/ BOOL bFormula = FALSE; //! uebergeben +/*N*/ long nPixel = pCell->GetTextWidth(); +/*N*/ +/*N*/ // Breite bereits im Idle-Handler berechnet? +/*N*/ if ( TEXTWIDTH_DIRTY == nPixel ) +/*N*/ { +/*N*/ ScNeededSizeOptions aOptions; +/*N*/ aOptions.bTotalSize = TRUE; +/*N*/ aOptions.bFormula = bFormula; +/*N*/ aOptions.bSkipMerged = FALSE; +/*N*/ +/*N*/ Fraction aZoom(1,1); +/*N*/ nPixel = aCol[nDataCol].GetNeededSize( nRow, +/*N*/ pDev,nPPTX,nPPTY,aZoom,aZoom, +/*N*/ TRUE, aOptions ); +/*N*/ pCell->SetTextWidth( (USHORT)nPixel ); +/*N*/ } +/*N*/ +/*N*/ long nTwips = (long) (nPixel / nPPTX); +/*N*/ long nDocW = GetColWidth( nDataCol ); +/*N*/ USHORT nCol = nDataCol; +/*N*/ while (nTwips > nDocW && nCol < MAXCOL) +/*N*/ { +/*N*/ ++nCol; +/*N*/ nDocW += GetColWidth( nCol ); +/*N*/ } +/*N*/ if (nCol>nPrintCol) +/*N*/ nPrintCol = nCol; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ rEndCol = nPrintCol; +/*N*/ } + +/*N*/ void ScTable::DoColResize( USHORT nCol1, USHORT nCol2, USHORT nAdd ) +/*N*/ { +/*N*/ for (USHORT nCol=nCol1; nCol<=nCol2; nCol++) +/*N*/ aCol[nCol].Resize(aCol[nCol].GetCellCount() + nAdd); +/*N*/ } + +/*N*/ #define SET_PRINTRANGE( p1, p2 ) \ +/*N*/ if ( (p2) ) \ +/*N*/ { \ +/*N*/ if ( (p1) ) \ +/*N*/ *(p1) = *(p2); \ +/*N*/ else \ +/*N*/ (p1) = new ScRange( *(p2) ); \ +/*N*/ } \ +/*N*/ else \ +/*N*/ DELETEZ( (p1) ) + +/*N*/ void ScTable::SetRepeatColRange( const ScRange* pNew ) +/*N*/ { +/*N*/ SET_PRINTRANGE( pRepeatColRange, pNew ); +/*N*/ } + +/*N*/ void ScTable::SetRepeatRowRange( const ScRange* pNew ) +/*N*/ { +/*N*/ SET_PRINTRANGE( pRepeatRowRange, pNew ); +/*N*/ } + +// #42845# zeroptimiert +#if defined(WIN) && defined(MSC) +#pragma optimize("",off) +#endif +/*N*/ void ScTable::SetPrintRangeCount( USHORT nNew ) +/*N*/ { +/*N*/ ScRange* pNewRanges; +/*N*/ if (nNew) +/*N*/ pNewRanges = new ScRange[nNew]; +/*N*/ else +/*N*/ pNewRanges = NULL; +/*N*/ +/*N*/ if ( pPrintRanges && nNew >= nPrintRangeCount ) // Anzahl vergroessert? +/*?*/ for ( USHORT i=0; i<nPrintRangeCount; i++ ) // (fuer "Hinzufuegen") +/*?*/ pNewRanges[i] = pPrintRanges[i]; // alte Ranges kopieren +/*N*/ +/*N*/ delete[] pPrintRanges; +/*N*/ pPrintRanges = pNewRanges; +/*N*/ nPrintRangeCount = nNew; +/*N*/ } +#if defined(WIN) && defined(MSC) +#pragma optimize("",on) +#endif + +/*N*/ void ScTable::SetPrintRange( USHORT nPos, const ScRange& rNew ) +/*N*/ { +/*N*/ if (nPos < nPrintRangeCount && pPrintRanges) +/*N*/ pPrintRanges[nPos] = rNew; +/*N*/ else +/*N*/ DBG_ERROR("SetPrintRange falsch"); +/*N*/ } + +/*N*/ const ScRange* ScTable::GetPrintRange(USHORT nPos) const +/*N*/ { +/*N*/ if (nPos < nPrintRangeCount && pPrintRanges) +/*N*/ return pPrintRanges+nPos; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScTable::FillPrintSaver( ScPrintSaverTab& rSaveTab ) const +/*N*/ { +/*N*/ rSaveTab.SetAreas( nPrintRangeCount, pPrintRanges ); +/*N*/ rSaveTab.SetRepeat( pRepeatColRange, pRepeatRowRange ); +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_table2.cxx b/binfilter/bf_sc/source/core/data/sc_table2.cxx new file mode 100644 index 000000000000..4c81443b010d --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_table2.cxx @@ -0,0 +1,1974 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <tools/urlobj.hxx> +#include <math.h> +#include <bf_svtools/PasswordHelper.hxx> +#include <unotools/transliterationwrapper.hxx> + +#include "patattr.hxx" +#include "docpool.hxx" +#include "document.hxx" +#include "drwlayer.hxx" +#include "olinetab.hxx" +#include "rechead.hxx" +#include "stlpool.hxx" +#include "attarray.hxx" // Iterator +#include "markdata.hxx" +#include "progress.hxx" +#include "dociter.hxx" +#include "conditio.hxx" +#include "chartlis.hxx" +#include "globstr.hrc" +#include "bf_so3/staticbaseurl.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +void lcl_LoadRange( SvStream& rStream, ScRange** ppRange ); +void lcl_SaveRange( SvStream& rStream, ScRange* pRange ); + + + +/*N*/ BOOL ScTable::SetOutlineTable( const ScOutlineTable* pNewOutline ) +/*N*/ { +/*N*/ USHORT nOldSizeX = 0; +/*N*/ USHORT nOldSizeY = 0; +/*N*/ USHORT nNewSizeX = 0; +/*N*/ USHORT nNewSizeY = 0; +/*N*/ +/*N*/ if (pOutlineTable) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ nOldSizeX = pOutlineTable->GetColArray()->GetDepth(); +/*N*/ } +/*N*/ +/*N*/ if (pNewOutline) +/*N*/ { +/*N*/ pOutlineTable = new ScOutlineTable( *pNewOutline ); +/*N*/ nNewSizeX = pOutlineTable->GetColArray()->GetDepth(); +/*N*/ nNewSizeY = pOutlineTable->GetRowArray()->GetDepth(); +/*N*/ } +/*N*/ else +/*N*/ pOutlineTable = NULL; +/*N*/ +/*N*/ return ( nNewSizeX != nOldSizeX || nNewSizeY != nOldSizeY ); // Groesse geaendert ? +/*N*/ } + + +/*N*/ void ScTable::StartOutlineTable() +/*N*/ { +/*N*/ if (!pOutlineTable) +/*N*/ pOutlineTable = new ScOutlineTable; +/*N*/ } + + +/*N*/ BOOL ScTable::TestInsertRow( USHORT nStartCol, USHORT nEndCol, USHORT nSize ) +/*N*/ { +/*N*/ BOOL bTest = TRUE; +/*N*/ +/*N*/ if ( nStartCol==0 && nEndCol==MAXCOL && pOutlineTable ) +/*N*/ bTest = pOutlineTable->TestInsertRow(nSize); +/*N*/ +/*N*/ for (USHORT i=nStartCol; (i<=nEndCol) && bTest; i++) +/*N*/ bTest = aCol[i].TestInsertRow( nSize ); +/*N*/ +/*N*/ return bTest; +/*N*/ } + + +/*N*/ void ScTable::InsertRow( USHORT nStartCol, USHORT nEndCol, USHORT nStartRow, USHORT nSize ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ nRecalcLvl++; +/*N*/ if (nStartCol==0 && nEndCol==MAXCOL) +/*N*/ { +/*N*/ if (pRowHeight && pRowFlags) +/*N*/ { +/*N*/ memmove( &pRowHeight[nStartRow+nSize], &pRowHeight[nStartRow], +/*N*/ (MAXROW - nStartRow + 1 - nSize) * sizeof(pRowHeight[0]) ); +/*N*/ memmove( &pRowFlags[nStartRow+nSize], &pRowFlags[nStartRow], +/*N*/ (MAXROW - nStartRow + 1 - nSize) * sizeof(pRowFlags[0]) ); +/*N*/ +/*N*/ // #67451# copy row height from row above +/*N*/ USHORT nSourceRow = ( nStartRow > 0 ) ? ( nStartRow - 1 ) : 0; +/*N*/ BYTE nNewFlags = pRowFlags[nSourceRow] & CR_MANUALSIZE; +/*N*/ USHORT nNewHeight = pRowHeight[nSourceRow]; +/*N*/ for (i=nStartRow; i<nStartRow+nSize; i++) +/*N*/ { +/*N*/ pRowHeight[i] = nNewHeight; +/*N*/ pRowFlags[i] = nNewFlags; +/*N*/ } +/*N*/ } +/*N*/ if (pOutlineTable) +/*N*/ pOutlineTable->InsertRow( nStartRow, nSize ); +/*N*/ } +/*N*/ +/*N*/ for (i=nStartCol; i<=nEndCol; i++) +/*N*/ aCol[i].InsertRow( nStartRow, nSize ); +/*N*/ if( !--nRecalcLvl ) +/*N*/ SetDrawPageSize(); +/*N*/ } + + +/*N*/ void ScTable::DeleteRow( USHORT nStartCol, USHORT nEndCol, USHORT nStartRow, USHORT nSize, +/*N*/ BOOL* pUndoOutline ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ nRecalcLvl++; +/*N*/ if (nStartCol==0 && nEndCol==MAXCOL) +/*N*/ { +/*N*/ if (pRowHeight && pRowFlags) +/*N*/ { +/*N*/ memmove( &pRowHeight[nStartRow], &pRowHeight[nStartRow+nSize], +/*N*/ (MAXROW - nStartRow + 1 - nSize) * sizeof(pRowHeight[0]) ); +/*N*/ memmove( &pRowFlags[nStartRow], &pRowFlags[nStartRow+nSize], +/*N*/ (MAXROW - nStartRow + 1 - nSize) * sizeof(pRowFlags[0]) ); +/*N*/ } +/*N*/ if (pOutlineTable) +/*N*/ if (pOutlineTable->DeleteRow( nStartRow, nSize )) +/*N*/ if (pUndoOutline) +/*N*/ *pUndoOutline = TRUE; +/*N*/ } +/*N*/ +/*N*/ for (i=nStartCol; i<=nEndCol; i++) +/*N*/ aCol[i].DeleteRow( nStartRow, nSize ); +/*N*/ if( !--nRecalcLvl ) +/*N*/ SetDrawPageSize(); +/*N*/ } + + +/*N*/ BOOL ScTable::TestInsertCol( USHORT nStartRow, USHORT nEndRow, USHORT nSize ) +/*N*/ { +/*N*/ BOOL bTest = TRUE; +/*N*/ +/*N*/ if ( nStartRow==0 && nEndRow==MAXROW && pOutlineTable ) +/*N*/ bTest = pOutlineTable->TestInsertCol(nSize); +/*N*/ +/*N*/ if ( nSize > MAXCOL ) +/*N*/ bTest = FALSE; +/*N*/ +/*N*/ for (USHORT i=MAXCOL; (i+nSize>MAXCOL) && bTest; i--) +/*N*/ bTest = aCol[i].TestInsertCol(nStartRow, nEndRow); +/*N*/ +/*N*/ return bTest; +/*N*/ } + + +/*N*/ void ScTable::InsertCol( USHORT nStartCol, USHORT nStartRow, USHORT nEndRow, USHORT nSize ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ nRecalcLvl++; +/*N*/ if (nStartRow==0 && nEndRow==MAXROW) +/*N*/ { +/*N*/ if (pColWidth && pColFlags) +/*N*/ { +/*N*/ memmove( &pColWidth[nStartCol+nSize], &pColWidth[nStartCol], +/*N*/ (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColWidth[0]) ); +/*N*/ memmove( &pColFlags[nStartCol+nSize], &pColFlags[nStartCol], +/*N*/ (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColFlags[0]) ); +/*N*/ } +/*N*/ if (pOutlineTable) +/*N*/ pOutlineTable->InsertCol( nStartCol, nSize ); +/*N*/ } +/*N*/ +/*N*/ +/*N*/ if ((nStartRow == 0) && (nEndRow == MAXROW)) +/*N*/ { +/*N*/ for (i=0; i < nSize; i++) +/*N*/ for (USHORT nCol = MAXCOL; nCol > nStartCol; nCol--) +/*N*/ aCol[nCol].SwapCol(aCol[nCol-1]); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for (i=0; i+nSize+nStartCol <= MAXCOL; i++) +/*N*/ aCol[MAXCOL - nSize - i].MoveTo(nStartRow, nEndRow, aCol[MAXCOL - i]); +/*N*/ } +/*N*/ +/*N*/ if (nStartCol>0) // copy old attributes +/*N*/ { +/*N*/ USHORT nWhichArray[2]; +/*N*/ nWhichArray[0] = ATTR_MERGE; +/*N*/ nWhichArray[1] = 0; +/*N*/ +/*N*/ for (i=0; i<nSize; i++) +/*N*/ { +/*N*/ aCol[nStartCol-1].CopyToColumn( nStartRow, nEndRow, IDF_ATTRIB, +/*N*/ FALSE, aCol[nStartCol+i] ); +/*N*/ aCol[nStartCol+i].RemoveFlags( nStartRow, nEndRow, +/*N*/ SC_MF_HOR | SC_MF_VER | SC_MF_AUTO ); +/*N*/ aCol[nStartCol+i].ClearItems( nStartRow, nEndRow, nWhichArray ); +/*N*/ } +/*N*/ } +/*N*/ if( !--nRecalcLvl ) +/*N*/ SetDrawPageSize(); +/*N*/ } + + +/*N*/ void ScTable::DeleteCol( USHORT nStartCol, USHORT nStartRow, USHORT nEndRow, USHORT nSize, +/*N*/ BOOL* pUndoOutline ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ nRecalcLvl++; +/*N*/ if (nStartRow==0 && nEndRow==MAXROW) +/*N*/ { +/*N*/ if (pColWidth && pColFlags) +/*N*/ { +/*N*/ memmove( &pColWidth[nStartCol], &pColWidth[nStartCol+nSize], +/*N*/ (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColWidth[0]) ); +/*N*/ memmove( &pColFlags[nStartCol], &pColFlags[nStartCol+nSize], +/*N*/ (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColFlags[0]) ); +/*N*/ } +/*N*/ if (pOutlineTable) +/*N*/ if (pOutlineTable->DeleteCol( nStartCol, nSize )) +/*N*/ if (pUndoOutline) +/*N*/ *pUndoOutline = TRUE; +/*N*/ } +/*N*/ +/*N*/ +/*N*/ for (i = 0; i < nSize; i++) +/*N*/ aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, IDF_ALL); +/*N*/ +/*N*/ if ((nStartRow == 0) && (nEndRow == MAXROW)) +/*N*/ { +/*N*/ for (i=0; i < nSize; i++) +/*N*/ for (USHORT nCol = nStartCol; nCol < MAXCOL; nCol++) +/*N*/ aCol[nCol].SwapCol(aCol[nCol+1]); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for (i=0; i+nSize+nStartCol <= MAXCOL; i++) +/*N*/ aCol[nStartCol + nSize + i].MoveTo(nStartRow, nEndRow, aCol[nStartCol + i]); +/*N*/ } +/*N*/ if( !--nRecalcLvl ) +/*N*/ SetDrawPageSize(); +/*N*/ } + + +/*N*/ void ScTable::DeleteArea(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, USHORT nDelFlag) +/*N*/ { +/*N*/ if (nCol2 > MAXCOL) nCol2 = MAXCOL; +/*N*/ if (nRow2 > MAXROW) nRow2 = MAXROW; +/*N*/ if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2)) +/*N*/ { +/*N*/ // nRecalcLvl++; +/*N*/ +/*N*/ for (USHORT i = nCol1; i <= nCol2; i++) +/*N*/ aCol[i].DeleteArea(nRow1, nRow2, nDelFlag); +/*N*/ +/*N*/ // +/*N*/ // Zellschutz auf geschuetzter Tabelle nicht setzen +/*N*/ // +/*N*/ +/*N*/ if ( bProtected && (nDelFlag & IDF_ATTRIB) ) +/*N*/ { +/*N*/ ScPatternAttr aPattern(pDocument->GetPool()); +/*N*/ aPattern.GetItemSet().Put( ScProtectionAttr( FALSE ) ); +/*N*/ ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern ); +/*N*/ } +/*N*/ +/* if( !--nRecalcLvl ) + SetDrawPageSize(); +*/ +/*N*/ } +/*N*/ } + + + + +// pTable = Clipboard + + + + + + +// Markierung von diesem Dokument + + + + +/*N*/ void ScTable::StartAllListeners() +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].StartAllListeners(); +/*N*/ } + + +/*N*/ void ScTable::StartNameListeners( BOOL bOnlyRelNames ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].StartNameListeners( bOnlyRelNames ); +/*N*/ } + + + + + + +/*N*/ void ScTable::CopyToTable(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, +/*N*/ USHORT nFlags, BOOL bMarked, ScTable* pDestTab, +/*N*/ const ScMarkData* pMarkData, +/*N*/ BOOL bAsLink, BOOL bColRowFlags) +/*N*/ { +/*N*/ if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2)) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ if (nFlags) +/*N*/ for (i = nCol1; i <= nCol2; i++) +/*N*/ aCol[i].CopyToColumn(nRow1, nRow2, nFlags, bMarked, +/*N*/ pDestTab->aCol[i], pMarkData, bAsLink); +/*N*/ +/*N*/ if (bColRowFlags) // Spaltenbreiten/Zeilenhoehen/Flags +/*N*/ { +/*N*/ // Charts muessen beim Ein-/Ausblenden angepasst werden +/*N*/ ScChartListenerCollection* pCharts = pDestTab->pDocument->GetChartListenerCollection(); +/*N*/ if ( pCharts && !pCharts->GetCount() ) +/*N*/ pCharts = NULL; +/*N*/ +/*N*/ if (nRow1==0 && nRow2==MAXROW && pColWidth && pDestTab->pColWidth) +/*N*/ for (i=nCol1; i<=nCol2; i++) +/*N*/ { +/*N*/ BOOL bChange = pCharts && +/*N*/ ( pDestTab->pColFlags[i] & CR_HIDDEN ) != ( pColFlags[i] & CR_HIDDEN ); +/*N*/ pDestTab->pColWidth[i] = pColWidth[i]; +/*N*/ pDestTab->pColFlags[i] = pColFlags[i]; +/*N*/ //! Aenderungen zusammenfassen? +/*N*/ if (bChange) +/*?*/ { DBG_BF_ASSERT(0, "STRIP");} //STRIP001 pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, MAXROW, nTab )); +/*N*/ } +/*N*/ +/*N*/ if (nCol1==0 && nCol2==MAXCOL && pRowHeight && pDestTab->pRowHeight) +/*N*/ for (i=nRow1; i<=nRow2; i++) +/*N*/ { +/*N*/ BOOL bChange = pCharts && +/*N*/ ( pDestTab->pRowFlags[i] & CR_HIDDEN ) != ( pRowFlags[i] & CR_HIDDEN ); +/*N*/ pDestTab->pRowHeight[i] = pRowHeight[i]; +/*N*/ pDestTab->pRowFlags[i] = pRowFlags[i]; +/*N*/ //! Aenderungen zusammenfassen? +/*N*/ if (bChange) +/*?*/ { DBG_BF_ASSERT(0, "STRIP");} //STRIP001 pCharts->SetRangeDirty(ScRange( 0, i, nTab, MAXCOL, i, nTab )); +/*N*/ } +/*N*/ +/*N*/ pDestTab->SetOutlineTable( pOutlineTable ); // auch nur wenn bColRowFlags +/*N*/ } +/*N*/ } +/*N*/ } + + + + + + + +/*N*/ void ScTable::MarkScenarioIn( ScMarkData& rDestMark, USHORT nNeededBits ) const +/*N*/ { +/*N*/ DBG_ASSERT( bScenario, "bScenario == FALSE" ); +/*N*/ +/*N*/ if ( ( nScenarioFlags & nNeededBits ) != nNeededBits ) // alle Bits gesetzt? +/*N*/ return; +/*N*/ +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].MarkScenarioIn( rDestMark ); +/*N*/ } + + +/*N*/ void ScTable::InvalidateScenarioRanges() +/*N*/ { +/*N*/ delete pScenarioRanges; +/*N*/ pScenarioRanges = NULL; +/*N*/ } + +/*N*/ const ScRangeList* ScTable::GetScenarioRanges() const +/*N*/ { +/*N*/ DBG_ASSERT( bScenario, "bScenario == FALSE" ); +/*N*/ +/*N*/ if (!pScenarioRanges) +/*N*/ { +/*N*/ ((ScTable*)this)->pScenarioRanges = new ScRangeList; +/*N*/ ScMarkData aMark; +/*N*/ MarkScenarioIn( aMark, 0 ); // immer +/*N*/ aMark.FillRangeListWithMarks( pScenarioRanges, FALSE ); +/*N*/ } +/*N*/ return pScenarioRanges; +/*N*/ } + + +/*N*/ void ScTable::PutCell( USHORT nCol, USHORT nRow, ScBaseCell* pCell ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ { +/*N*/ if (pCell) +/*N*/ aCol[nCol].Insert( nRow, pCell ); +/*N*/ else +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ aCol[nCol].Delete( nRow ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScTable::PutCell( USHORT nCol, USHORT nRow, ULONG nFormatIndex, ScBaseCell* pCell ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ { +/*N*/ if (pCell) +/*N*/ aCol[nCol].Insert( nRow, nFormatIndex, pCell ); +/*N*/ else +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ aCol[nCol].Delete( nRow ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScTable::PutCell( const ScAddress& rPos, ScBaseCell* pCell ) +/*N*/ { +/*N*/ if (pCell) +/*N*/ aCol[rPos.Col()].Insert( rPos.Row(), pCell ); +/*N*/ else +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ aCol[rPos.Col()].Delete( rPos.Row() ); +/*N*/ } + + +/*N*/ BOOL ScTable::SetString( USHORT nCol, USHORT nRow, USHORT nTab, const String& rString ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].SetString( nRow, nTab, rString ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScTable::SetValue( USHORT nCol, USHORT nRow, const double& rVal ) +/*N*/ { +/*N*/ if (ValidColRow(nCol, nRow)) +/*N*/ aCol[nCol].SetValue( nRow, rVal ); +/*N*/ } + + +/*N*/ void ScTable::SetNote( USHORT nCol, USHORT nRow, const ScPostIt& rNote) +/*N*/ { +/*N*/ if (ValidColRow(nCol, nRow)) +/*N*/ aCol[nCol].SetNote(nRow, rNote); +/*N*/ } + + +/*N*/ void ScTable::GetString( USHORT nCol, USHORT nRow, String& rString ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ aCol[nCol].GetString( nRow, rString ); +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + + +/*N*/ void ScTable::GetInputString( USHORT nCol, USHORT nRow, String& rString ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ aCol[nCol].GetInputString( nRow, rString ); +/*N*/ else +/*N*/ rString.Erase(); +/*N*/ } + +/*N*/ double ScTable::GetValue( USHORT nCol, USHORT nRow ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0.0;//STRIP001 if (ValidColRow( nCol, nRow )) +/*N*/ } + +/*N*/ BOOL ScTable::GetNote( USHORT nCol, USHORT nRow, ScPostIt& rNote) +/*N*/ { +/*N*/ BOOL bHasNote = FALSE; +/*N*/ +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ bHasNote = aCol[nCol].GetNote( nRow, rNote ); +/*N*/ else +/*?*/ rNote.Clear(); +/*N*/ +/*N*/ return bHasNote; +/*N*/ } + + +/*N*/ CellType ScTable::GetCellType( USHORT nCol, USHORT nRow ) const +/*N*/ { +/*N*/ if (ValidColRow( nCol, nRow )) +/*N*/ return aCol[nCol].GetCellType( nRow ); +/*N*/ return CELLTYPE_NONE; +/*N*/ } + + +/*N*/ ScBaseCell* ScTable::GetCell( USHORT nCol, USHORT nRow ) const +/*N*/ { +/*N*/ if (ValidColRow( nCol, nRow )) +/*N*/ return aCol[nCol].GetCell( nRow ); +/*N*/ +/*N*/ DBG_ERROR("GetCell ausserhalb"); +/*N*/ return NULL; +/*N*/ } + + + + +/*N*/ BOOL ScTable::HasData( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].HasDataAt( nRow ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScTable::HasStringData( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].HasStringData( nRow ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScTable::HasValueData( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].HasValueData( nRow ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ void ScTable::SetDirtyVar() +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].SetDirtyVar(); +/*N*/ } + + +/*N*/ void ScTable::SetDirty() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].SetDirty(); +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScTable::SetDirty( const ScRange& rRange ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ } + + +/*N*/ void ScTable::SetTableOpDirty( const ScRange& rRange ) +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // no multiple recalculation +/*N*/ USHORT nCol2 = rRange.aEnd.Col(); +/*N*/ for (USHORT i=rRange.aStart.Col(); i<=nCol2; i++) +/*N*/ aCol[i].SetTableOpDirty( rRange ); +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScTable::SetDirtyAfterLoad() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].SetDirtyAfterLoad(); +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScTable::SetRelNameDirty() +/*N*/ { +/*N*/ BOOL bOldAutoCalc = pDocument->GetAutoCalc(); +/*N*/ pDocument->SetAutoCalc( FALSE ); // Mehrfachberechnungen vermeiden +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].SetRelNameDirty(); +/*N*/ pDocument->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScTable::CalcAll() +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) aCol[i].CalcAll(); +/*N*/ } + + +/*N*/ void ScTable::CompileAll() +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) aCol[i].CompileAll(); +/*N*/ } + + +/*N*/ void ScTable::CompileXML( ScProgress& rProgress ) +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) +/*N*/ { +/*N*/ aCol[i].CompileXML( rProgress ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScTable::CalcAfterLoad() +/*N*/ { +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) aCol[i].CalcAfterLoad(); +/*N*/ } + + +/*N*/ void ScTable::ResetChanged( const ScRange& rRange ) +/*N*/ { +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ USHORT nEndCol = rRange.aEnd.Col(); +/*N*/ USHORT nEndRow = rRange.aEnd.Row(); +/*N*/ +/*N*/ for (USHORT nCol=nStartCol; nCol<=nEndCol; nCol++) +/*N*/ aCol[nCol].ResetChanged(nStartRow, nEndRow); +/*N*/ } + +// Attribute + +/*N*/ const SfxPoolItem* ScTable::GetAttr( USHORT nCol, USHORT nRow, USHORT nWhich ) const +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].GetAttr( nRow, nWhich ); +/*N*/ else +/*N*/ return NULL; +/*N*/ } + + +/*N*/ ULONG ScTable::GetNumberFormat( USHORT nCol, USHORT nRow ) const +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].GetNumberFormat( nRow ); +/*N*/ else +/*N*/ return 0; +/*N*/ } + + +/*N*/ const ScPatternAttr* ScTable::GetPattern( USHORT nCol, USHORT nRow ) const +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ return aCol[nCol].GetPattern( nRow ); +/*N*/ else +/*N*/ return NULL; +/*N*/ } + + +/*N*/ BOOL ScTable::HasAttrib( USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, USHORT nMask ) const +/*N*/ { +/*N*/ BOOL bFound=FALSE; +/*N*/ for (USHORT i=nCol1; i<=nCol2 && !bFound; i++) +/*N*/ bFound |= aCol[i].HasAttrib( nRow1, nRow2, nMask ); +/*N*/ return bFound; +/*N*/ } + + + + + + +/*N*/ BOOL ScTable::ExtendMerge( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT& rEndCol, USHORT& rEndRow, +/*N*/ BOOL bRefresh, BOOL bAttrs ) +/*N*/ { +/*N*/ BOOL bFound=FALSE; +/*N*/ USHORT nOldEndX = rEndCol; +/*N*/ USHORT nOldEndY = rEndRow; +/*N*/ for (USHORT i=nStartCol; i<=nOldEndX; i++) +/*N*/ bFound |= aCol[i].ExtendMerge( i, nStartRow, nOldEndY, rEndCol, rEndRow, bRefresh, bAttrs ); +/*N*/ return bFound; +/*N*/ } + +/*N*/ BOOL ScTable::HasBlockMatrixFragment( USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2 ) const +/*N*/ { +/*N*/ // nix:0, mitte:1, unten:2, links:4, oben:8, rechts:16, offen:32 +/*N*/ USHORT nEdges; +/*N*/ +/*N*/ if ( nCol1 == nCol2 ) +/*N*/ { // linke und rechte Spalte +/*N*/ const USHORT n = 4 | 16; +/*N*/ nEdges = aCol[nCol1].GetBlockMatrixEdges( nRow1, nRow2, n ); +/*N*/ // nicht (4 und 16) oder 1 oder 32 +/*N*/ if ( nEdges && (((nEdges & n) != n) || (nEdges & 33)) ) +/*N*/ return TRUE; // linke oder rechte Kante fehlt oder offen +/*N*/ } +/*N*/ else +/*N*/ { // linke Spalte +/*N*/ nEdges = aCol[nCol1].GetBlockMatrixEdges( nRow1, nRow2, 4 ); +/*N*/ // nicht 4 oder 1 oder 32 +/*N*/ if ( nEdges && (((nEdges & 4) != 4) || (nEdges & 33)) ) +/*N*/ return TRUE; // linke Kante fehlt oder offen +/*N*/ // rechte Spalte +/*N*/ nEdges = aCol[nCol2].GetBlockMatrixEdges( nRow1, nRow2, 16 ); +/*N*/ // nicht 16 oder 1 oder 32 +/*N*/ if ( nEdges && (((nEdges & 16) != 16) || (nEdges & 33)) ) +/*N*/ return TRUE; // rechte Kante fehlt oder offen +/*N*/ } +/*N*/ +/*N*/ if ( nRow1 == nRow2 ) +/*N*/ { // obere und untere Zeile +/*N*/ USHORT i; +/*N*/ BOOL bOpen = FALSE; +/*N*/ const USHORT n = 2 | 8; +/*N*/ for ( i=nCol1; i<=nCol2; i++) +/*N*/ { +/*N*/ nEdges = aCol[i].GetBlockMatrixEdges( nRow1, nRow1, n ); +/*N*/ if ( nEdges ) +/*N*/ { +/*N*/ if ( (nEdges & n) != n ) +/*N*/ return TRUE; // obere oder untere Kante fehlt +/*N*/ if ( nEdges & 4 ) +/*N*/ bOpen = TRUE; // linke Kante oeffnet, weitersehen +/*N*/ else if ( !bOpen ) +/*N*/ return TRUE; // es gibt was, was nicht geoeffnet wurde +/*N*/ if ( nEdges & 16 ) +/*N*/ bOpen = FALSE; // rechte Kante schliesst +/*N*/ } +/*N*/ } +/*N*/ if ( bOpen ) +/*N*/ return TRUE; // es geht noch weiter +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT j, nR, n, i; +/*N*/ // erst obere Zeile, dann untere Zeile +/*N*/ for ( j=0, nR=nRow1, n=8; j<2; j++, nR=nRow2, n=2 ) +/*N*/ { +/*N*/ BOOL bOpen = FALSE; +/*N*/ for ( i=nCol1; i<=nCol2; i++) +/*N*/ { +/*N*/ nEdges = aCol[i].GetBlockMatrixEdges( nR, nR, n ); +/*N*/ if ( nEdges ) +/*N*/ { +/*N*/ // in oberere Zeile keine obere Kante bzw. +/*N*/ // in unterer Zeile keine untere Kante +/*N*/ if ( (nEdges & n) != n ) +/*N*/ return TRUE; +/*N*/ if ( nEdges & 4 ) +/*N*/ bOpen = TRUE; // linke Kante oeffnet, weitersehen +/*N*/ else if ( !bOpen ) +/*N*/ return TRUE; // es gibt was, was nicht geoeffnet wurde +/*N*/ if ( nEdges & 16 ) +/*N*/ bOpen = FALSE; // rechte Kante schliesst +/*N*/ } +/*N*/ } +/*N*/ if ( bOpen ) +/*N*/ return TRUE; // es geht noch weiter +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScTable::HasSelectionMatrixFragment( const ScMarkData& rMark ) const +/*N*/ { +/*N*/ BOOL bFound=FALSE; +/*N*/ for (USHORT i=0; i<=MAXCOL && !bFound; i++) +/*N*/ bFound |= aCol[i].HasSelectionMatrixFragment(rMark); +/*N*/ return bFound; +/*N*/ } + + +/*N*/ BOOL ScTable::IsBlockEditable( USHORT nCol1, USHORT nRow1, USHORT nCol2, +/*N*/ USHORT nRow2, BOOL* pOnlyNotBecauseOfMatrix /* = NULL */ ) const +/*N*/ { +/*N*/ BOOL bIsEditable; +/*N*/ if ( nLockCount ) +/*N*/ bIsEditable = FALSE; +/*N*/ else if ( bProtected ) +/*N*/ bIsEditable = !HasAttrib( nCol1, nRow1, nCol2, nRow2, HASATTR_PROTECTED ); +/*N*/ else +/*N*/ bIsEditable = TRUE; +/*N*/ if ( bIsEditable ) +/*N*/ { +/*N*/ if ( HasBlockMatrixFragment( nCol1, nRow1, nCol2, nRow2 ) ) +/*N*/ { +/*N*/ bIsEditable = FALSE; +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = TRUE; +/*N*/ } +/*N*/ else if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ } +/*N*/ else if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ return bIsEditable; +/*N*/ } + + +/*N*/ BOOL ScTable::IsSelectionEditable( const ScMarkData& rMark, +/*N*/ BOOL* pOnlyNotBecauseOfMatrix /* = NULL */ ) const +/*N*/ { +/*N*/ BOOL bIsEditable; +/*N*/ if ( nLockCount ) +/*N*/ bIsEditable = FALSE; +/*N*/ else if ( bProtected ) + { +{DBG_BF_ASSERT(0, "STRIP");} //STRIP001 /*?*/ bIsEditable = !HasAttribSelection( rMark, HASATTR_PROTECTED ); + bIsEditable = FALSE; + } +/*N*/ else +/*N*/ bIsEditable = TRUE; +/*N*/ if ( bIsEditable ) +/*N*/ { +/*N*/ if ( HasSelectionMatrixFragment( rMark ) ) +/*N*/ { +/*N*/ bIsEditable = FALSE; +/*N*/ if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = TRUE; +/*N*/ } +/*N*/ else if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ } +/*N*/ else if ( pOnlyNotBecauseOfMatrix ) +/*N*/ *pOnlyNotBecauseOfMatrix = FALSE; +/*N*/ return bIsEditable; +/*N*/ } + + + +/*N*/ void ScTable::LockTable() +/*N*/ { +/*N*/ ++nLockCount; +/*N*/ } + + +/*N*/ void ScTable::UnlockTable() +/*N*/ { +/*N*/ if (nLockCount) +/*N*/ --nLockCount; +/*N*/ else +/*N*/ DBG_ERROR("UnlockTable ohne LockTable"); +/*N*/ } + + +/*N*/ void ScTable::MergeSelectionPattern( SfxItemSet** ppSet, const ScMarkData& rMark, BOOL bDeep ) const +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].MergeSelectionPattern( ppSet, rMark, bDeep ); +/*N*/ } + + +/*N*/ void ScTable::MergePatternArea( SfxItemSet** ppSet, USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2, BOOL bDeep ) const +/*N*/ { +/*N*/ for (USHORT i=nCol1; i<=nCol2; i++) +/*N*/ aCol[i].MergePatternArea( ppSet, nRow1, nRow2, bDeep ); +/*N*/ } + + +/*N*/ void ScTable::MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner, ScLineFlags& rFlags, +/*N*/ USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow ) const +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) +/*N*/ } + + +/*N*/ void ScTable::ApplyBlockFrame( const SvxBoxItem* pLineOuter, const SvxBoxInfoItem* pLineInner, +/*N*/ USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) +/*N*/ } + + + + +/*N*/ void ScTable::ApplyPatternArea( USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow, +/*N*/ const ScPatternAttr& rAttr ) +/*N*/ { +/*N*/ if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) +/*N*/ { +/*N*/ PutInOrder(nStartCol, nEndCol); +/*N*/ PutInOrder(nStartRow, nEndRow); +/*N*/ for (USHORT i = nStartCol; i <= nEndCol; i++) +/*N*/ aCol[i].ApplyPatternArea(nStartRow, nEndRow, rAttr); +/*N*/ } +/*N*/ } + + + + + + +/*N*/ void ScTable::ApplyStyleArea( USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow, const ScStyleSheet& rStyle ) +/*N*/ { +/*N*/ if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) +/*N*/ { +/*N*/ PutInOrder(nStartCol, nEndCol); +/*N*/ PutInOrder(nStartRow, nEndRow); +/*N*/ for (USHORT i = nStartCol; i <= nEndCol; i++) +/*N*/ aCol[i].ApplyStyleArea(nStartRow, nEndRow, rStyle); +/*N*/ } +/*N*/ } + +/*N*/ void ScTable::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].ApplySelectionStyle( rStyle, rMark ); +/*N*/ } + +/*N*/ const ScStyleSheet* ScTable::GetSelectionStyle( const ScMarkData& rMark, BOOL& rFound ) const +/*N*/ { +/*N*/ rFound = FALSE; +/*N*/ +/*N*/ BOOL bEqual = TRUE; +/*N*/ BOOL bColFound; +/*N*/ USHORT i; +/*N*/ +/*N*/ const ScStyleSheet* pStyle = NULL; +/*N*/ const ScStyleSheet* pNewStyle; +/*N*/ +/*N*/ for (i=0; i<=MAXCOL && bEqual; i++) +/*N*/ if (rMark.HasMultiMarks(i)) +/*N*/ { +/*N*/ pNewStyle = aCol[i].GetSelectionStyle( rMark, bColFound ); +/*N*/ if (bColFound) +/*N*/ { +/*N*/ rFound = TRUE; +/*N*/ if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) ) +/*N*/ bEqual = FALSE; // unterschiedliche +/*N*/ pStyle = pNewStyle; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual ? pStyle : NULL; +/*N*/ } + + +/*N*/ const ScStyleSheet* ScTable::GetAreaStyle( BOOL& rFound, USHORT nCol1, USHORT nRow1, +/*N*/ USHORT nCol2, USHORT nRow2 ) const +/*N*/ { +/*N*/ rFound = FALSE; +/*N*/ +/*N*/ BOOL bEqual = TRUE; +/*N*/ BOOL bColFound; +/*N*/ USHORT i; +/*N*/ +/*N*/ const ScStyleSheet* pStyle = NULL; +/*N*/ const ScStyleSheet* pNewStyle; +/*N*/ +/*N*/ for (i=nCol1; i<=nCol2 && bEqual; i++) +/*N*/ { +/*N*/ pNewStyle = aCol[i].GetAreaStyle(bColFound, nRow1, nRow2); +/*N*/ if (bColFound) +/*N*/ { +/*N*/ rFound = TRUE; +/*N*/ if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) ) +/*N*/ bEqual = FALSE; // unterschiedliche +/*N*/ pStyle = pNewStyle; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual ? pStyle : NULL; +/*N*/ } + + +/*N*/ void ScTable::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, BOOL bRemoved, +/*N*/ OutputDevice* pDev, +/*N*/ double nPPTX, double nPPTY, +/*N*/ const Fraction& rZoomX, const Fraction& rZoomY ) +/*N*/ { +/*N*/ BOOL* pUsed = new BOOL[MAXROW+1]; +/*N*/ memset( pUsed, 0, sizeof(BOOL) * (MAXROW+1) ); +/*N*/ +/*N*/ USHORT nCol; +/*N*/ for (nCol=0; nCol<=MAXCOL; nCol++) +/*N*/ aCol[nCol].FindStyleSheet( pStyleSheet, pUsed, bRemoved ); +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT i; +/*N*/ USHORT nStart; +/*N*/ USHORT nEnd; +/*N*/ for (i=0; i<=MAXROW; i++) +/*N*/ { +/*N*/ if (pUsed[i]) +/*N*/ { +/*N*/ if (!bFound) +/*N*/ { +/*N*/ nStart = i; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ nEnd = i; +/*N*/ } +/*N*/ else if (bFound) +/*N*/ { +/*?*/ SetOptimalHeight( nStart, nEnd, 0, pDev, nPPTX, nPPTY, rZoomX, rZoomY, FALSE ); +/*?*/ bFound = FALSE; +/*N*/ } +/*N*/ } +/*N*/ if (bFound) +/*N*/ SetOptimalHeight( nStart, nEnd, 0, pDev, nPPTX, nPPTY, rZoomX, rZoomY, FALSE ); +/*N*/ +/*N*/ delete[] pUsed; +/*N*/ } + + +/*N*/ BOOL ScTable::ApplyFlags( USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow, +/*N*/ INT16 nFlags ) +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) +/*N*/ for (USHORT i = nStartCol; i <= nEndCol; i++) +/*N*/ bChanged |= aCol[i].ApplyFlags(nStartRow, nEndRow, nFlags); +/*N*/ return bChanged; +/*N*/ } + + + + + + +/*N*/ void ScTable::ApplyAttr( USHORT nCol, USHORT nRow, const SfxPoolItem& rAttr ) +/*N*/ { +/*N*/ if (ValidColRow(nCol,nRow)) +/*N*/ aCol[nCol].ApplyAttr( nRow, rAttr ); +/*N*/ } + + +/*N*/ void ScTable::ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) +/*N*/ aCol[i].ApplySelectionCache( pCache, rMark ); +/*N*/ } + + + + + + +// Spaltenbreiten / Zeilenhoehen + +/*N*/ void ScTable::SetColWidth( USHORT nCol, USHORT nNewWidth ) +/*N*/ { +/*N*/ if (VALIDCOL(nCol) && pColWidth) +/*N*/ { +/*N*/ if (!nNewWidth) +/*N*/ { +/*N*/ // DBG_ERROR("Spaltenbreite 0 in SetColWidth"); +/*N*/ nNewWidth = STD_COL_WIDTH; +/*N*/ } +/*N*/ +/*N*/ if ( nNewWidth != pColWidth[nCol] ) +/*N*/ { +/*N*/ nRecalcLvl++; +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*N*/ pDrawLayer->WidthChanged( nTab, nCol, ((long) nNewWidth) - (long) pColWidth[nCol] ); +/*N*/ pColWidth[nCol] = nNewWidth; +/*N*/ if( !--nRecalcLvl ) +/*N*/ SetDrawPageSize(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("Falsche Spaltennummer oder keine Breiten"); +/*N*/ } + + +/*N*/ void ScTable::SetRowHeight( USHORT nRow, USHORT nNewHeight ) +/*N*/ { +/*N*/ if (VALIDROW(nRow) && pRowHeight) +/*N*/ { +/*N*/ if (!nNewHeight) +/*N*/ { +/*?*/ DBG_ERROR("Zeilenhoehe 0 in SetRowHeight"); +/*?*/ nNewHeight = ScGlobal::nStdRowHeight; +/*N*/ } +/*N*/ +/*N*/ if ( nNewHeight != pRowHeight[nRow] ) +/*N*/ { +/*N*/ nRecalcLvl++; +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*N*/ pDrawLayer->HeightChanged( nTab, nRow, ((long) nNewHeight) - (long) pRowHeight[nRow] ); +/*N*/ pRowHeight[nRow] = nNewHeight; +/*N*/ if( !--nRecalcLvl ) +/*?*/ SetDrawPageSize(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("Falsche Zeilennummer oder keine Hoehen"); +/*N*/ } + + +/*N*/ BOOL ScTable::SetRowHeightRange( USHORT nStartRow, USHORT nEndRow, USHORT nNewHeight, +/*N*/ double nPPTX,double nPPTY ) +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && pRowHeight) +/*N*/ { +/*N*/ nRecalcLvl++; +/*N*/ if (!nNewHeight) +/*N*/ { +/*?*/ DBG_ERROR("Zeilenhoehe 0 in SetRowHeight"); +/*?*/ nNewHeight = ScGlobal::nStdRowHeight; +/*N*/ } +/*N*/ +/*N*/ long nNewPix = (long) ( nNewHeight * nPPTY ); +/*N*/ +/*N*/ BOOL bSingle = FALSE; +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*N*/ if (pDrawLayer->HasObjectsInRows( nTab, nStartRow, nEndRow )) +/*N*/ bSingle = TRUE; +/*N*/ +/*N*/ USHORT nRow; +/*N*/ if (bSingle) +/*N*/ { +/*N*/ BOOL bDiff = FALSE; +/*N*/ for (nRow=nStartRow; nRow<=nEndRow && !bDiff; nRow++) +/*N*/ bDiff = ( pRowHeight[nRow] != nNewHeight ); +/*N*/ if (!bDiff) +/*N*/ bSingle = FALSE; +/*N*/ } +/*N*/ if (bSingle) +/*N*/ { +/*N*/ if (nEndRow-nStartRow < 20) +/*N*/ for (nRow=nStartRow; nRow<=nEndRow; nRow++) +/*N*/ { +/*N*/ if (!bChanged) +/*N*/ if ( pRowHeight[nRow] != nNewHeight ) +/*N*/ bChanged = ( nNewPix != (long) ( pRowHeight[nRow] * nPPTY ) ); +/*N*/ SetRowHeight( nRow, nNewHeight ); +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ USHORT nMid = (nStartRow+nEndRow) / 2; +/*?*/ if (SetRowHeightRange( nStartRow, nMid, nNewHeight, 1.0, 1.0 )) +/*?*/ bChanged = TRUE; +/*?*/ if (SetRowHeightRange( nMid+1, nEndRow, nNewHeight, 1.0, 1.0 )) +/*?*/ bChanged = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ long nHeightDif = 0; +/*N*/ for (nRow=nStartRow; nRow<=nEndRow; nRow++) +/*N*/ nHeightDif += ((long) nNewHeight) - (long) pRowHeight[nRow]; +/*N*/ pDrawLayer->HeightChanged( nTab, nEndRow, nHeightDif ); +/*N*/ } +/*N*/ for (nRow=nStartRow; nRow<=nEndRow; nRow++) +/*N*/ { +/*N*/ if (!bChanged) +/*N*/ if ( pRowHeight[nRow] != nNewHeight ) +/*N*/ bChanged = ( nNewPix != (long) ( pRowHeight[nRow] * nPPTY ) ); +/*N*/ pRowHeight[nRow] = nNewHeight; +/*N*/ } +/*N*/ } +/*N*/ if( !--nRecalcLvl ) +/*N*/ SetDrawPageSize(); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("Falsche Zeilennummer oder keine Hoehen"); +/*N*/ +/*N*/ return bChanged; +/*N*/ } + + +/*N*/ void ScTable::SetManualHeight( USHORT nStartRow, USHORT nEndRow, BOOL bManual ) +/*N*/ { +/*N*/ if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && pRowFlags) +/*N*/ { +/*N*/ USHORT nRow; +/*N*/ if (bManual) +/*N*/ for (nRow=nStartRow; nRow<=nEndRow; nRow++) +/*N*/ pRowFlags[nRow] |= CR_MANUALSIZE; +/*N*/ else +/*N*/ for (nRow=nStartRow; nRow<=nEndRow; nRow++) +/*N*/ pRowFlags[nRow] &= ~CR_MANUALSIZE; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("Falsche Zeilennummer oder keine Zeilenflags"); +/*N*/ } + + +/*N*/ USHORT ScTable::GetColWidth( USHORT nCol ) const +/*N*/ { +/*N*/ DBG_ASSERT(VALIDCOL(nCol),"Falsche Spaltennummer"); +/*N*/ +/*N*/ if (VALIDCOL(nCol) && pColFlags && pColWidth) +/*N*/ { +/*N*/ if ( pColFlags[nCol] & CR_HIDDEN ) +/*N*/ return 0; +/*N*/ else +/*N*/ return pColWidth[nCol]; +/*N*/ } +/*N*/ else +/*N*/ return (USHORT) STD_COL_WIDTH; +/*N*/ } + + +/*N*/ USHORT ScTable::GetOriginalWidth( USHORT nCol ) const // immer die eingestellte +/*N*/ { +/*N*/ DBG_ASSERT(VALIDCOL(nCol),"Falsche Spaltennummer"); +/*N*/ +/*N*/ if (VALIDCOL(nCol) && pColWidth) +/*N*/ return pColWidth[nCol]; +/*N*/ else +/*N*/ return (USHORT) STD_COL_WIDTH; +/*N*/ } + + + + +/*N*/ USHORT ScTable::GetRowHeight( USHORT nRow ) const +/*N*/ { +/*N*/ DBG_ASSERT(VALIDROW(nRow),"Falsche Zeilennummer"); +/*N*/ +/*N*/ if (VALIDROW(nRow) && pRowFlags && pRowHeight) +/*N*/ { +/*N*/ if ( pRowFlags[nRow] & CR_HIDDEN ) +/*N*/ return 0; +/*N*/ else +/*N*/ return pRowHeight[nRow]; +/*N*/ } +/*N*/ else +/*N*/ return (USHORT) ScGlobal::nStdRowHeight; +/*N*/ } + + +/*N*/ USHORT ScTable::GetOriginalHeight( USHORT nRow ) const // non-0 even if hidden +/*N*/ { +/*N*/ DBG_ASSERT(VALIDROW(nRow),"wrong row number"); +/*N*/ +/*N*/ if (VALIDROW(nRow) && pRowHeight) +/*N*/ return pRowHeight[nRow]; +/*N*/ else +/*N*/ return (USHORT) ScGlobal::nStdRowHeight; +/*N*/ } + + +// Spalten-/Zeilen-Flags + + +/*N*/ USHORT ScTable::GetHiddenRowCount( USHORT nRow ) const +/*N*/ { +/*N*/ USHORT nEndRow = nRow; +/*N*/ if ( pRowFlags ) +/*N*/ { +/*N*/ while ( nEndRow <= MAXROW && ( pRowFlags[nEndRow] & CR_HIDDEN ) ) +/*N*/ ++nEndRow; +/*N*/ } +/*N*/ return nEndRow - nRow; +/*N*/ } + + +//! ShowRows / DBShowRows zusammenfassen + +/*N*/ void ScTable::ShowCol(USHORT nCol, BOOL bShow) +/*N*/ { +/*N*/ if (VALIDCOL(nCol) && pColFlags) +/*N*/ { +/*N*/ BOOL bWasVis = ( pColFlags[nCol] & CR_HIDDEN ) == 0; +/*N*/ if (bWasVis != bShow) +/*N*/ { +/*N*/ nRecalcLvl++; +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ if (bShow) +/*N*/ pDrawLayer->WidthChanged( nTab, nCol, (long) pColWidth[nCol] ); +/*N*/ else +/*N*/ pDrawLayer->WidthChanged( nTab, nCol, -(long) pColWidth[nCol] ); +/*N*/ } +/*N*/ +/*N*/ if (bShow) +/*N*/ pColFlags[nCol] &= ~CR_HIDDEN; +/*N*/ else +/*N*/ pColFlags[nCol] |= CR_HIDDEN; +/*N*/ if( !--nRecalcLvl ) +/*?*/ SetDrawPageSize(); +/*N*/ +/*N*/ ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection(); +/*N*/ if ( pCharts && pCharts->GetCount() ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, MAXROW, nTab )); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("Falsche Spaltennummer oder keine Flags"); +/*N*/ } + + +/*N*/ void ScTable::ShowRows(USHORT nRow1, USHORT nRow2, BOOL bShow) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT nStartRow = nRow1; +/*N*/ nRecalcLvl++; +/*N*/ while (nStartRow <= nRow2) +/*N*/ { +/*N*/ USHORT nEndRow = nStartRow; +/*N*/ BYTE nOldFlag = pRowFlags[nStartRow] & CR_HIDDEN; +/*N*/ while ( nEndRow < nRow2 && (pRowFlags[nEndRow+1] & CR_HIDDEN) == nOldFlag ) +/*N*/ ++nEndRow; +/*N*/ +/*N*/ BOOL bWasVis = ( nOldFlag == 0 ); +/*N*/ BOOL bChanged = ( bWasVis != bShow ); +/*N*/ if ( bChanged ) +/*N*/ { +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*N*/ { +/*N*/ long nHeight = 0; +/*N*/ for (i=nStartRow; i<=nEndRow; i++) +/*N*/ nHeight += pRowHeight[i]; +/*N*/ +/*N*/ if (bShow) +/*N*/ pDrawLayer->HeightChanged( nTab, nStartRow, nHeight ); +/*N*/ else +/*N*/ pDrawLayer->HeightChanged( nTab, nStartRow, -nHeight ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bShow) +/*N*/ for (i=nStartRow; i<=nEndRow; i++) +/*N*/ pRowFlags[i] &= ~(CR_HIDDEN | CR_FILTERED); +/*N*/ else +/*N*/ for (i=nStartRow; i<=nEndRow; i++) +/*N*/ pRowFlags[i] |= CR_HIDDEN; +/*N*/ +/*N*/ if ( bChanged ) +/*N*/ { +/*N*/ ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection(); +/*N*/ if ( pCharts && pCharts->GetCount() ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab )); +/*N*/ } +/*N*/ +/*N*/ nStartRow = nEndRow + 1; +/*N*/ } +/*N*/ if( !--nRecalcLvl ) +/*?*/ SetDrawPageSize(); +/*N*/ } + + +/*N*/ BOOL ScTable::IsFiltered(USHORT nRow) const +/*N*/ { +/*N*/ if (VALIDROW(nRow) && pRowFlags) +/*N*/ return ( pRowFlags[nRow] & CR_FILTERED ) != 0; +/*N*/ +/*N*/ DBG_ERROR("Falsche Zeilennummer oder keine Flags"); +/*N*/ return FALSE; +/*N*/ } + + + + +/*N*/ void ScTable::SetRowFlags( USHORT nRow, BYTE nNewFlags ) +/*N*/ { +/*N*/ if (VALIDROW(nRow) && pRowFlags) +/*N*/ pRowFlags[nRow] = nNewFlags; +/*N*/ else +/*N*/ DBG_ERROR("Falsche Zeilennummer oder keine Flags"); +/*N*/ } + + +/*N*/ BYTE ScTable::GetColFlags( USHORT nCol ) const +/*N*/ { +/*N*/ if (VALIDCOL(nCol) && pColFlags) +/*N*/ return pColFlags[nCol]; +/*N*/ else +/*N*/ return 0; +/*N*/ } + + +/*N*/ BYTE ScTable::GetRowFlags( USHORT nRow ) const +/*N*/ { +/*N*/ if (VALIDROW(nRow) && pRowFlags) +/*N*/ return pRowFlags[nRow]; +/*N*/ else +/*N*/ return 0; +/*N*/ } + + + + + + +/*N*/ USHORT ScTable::GetLastChangedCol() const +/*N*/ { +/*N*/ if ( !pColFlags ) +/*N*/ return 0; +/*N*/ +/*N*/ USHORT nLastFound = 0; +/*N*/ for (USHORT nCol = 1; nCol <= MAXCOL; nCol++) +/*N*/ if ((pColFlags[nCol] & ~CR_PAGEBREAK) || (pColWidth[nCol] != STD_COL_WIDTH)) +/*N*/ nLastFound = nCol; +/*N*/ +/*N*/ return nLastFound; +/*N*/ } + + +/*N*/ USHORT ScTable::GetLastChangedRow() const +/*N*/ { +/*N*/ if ( !pRowFlags ) +/*N*/ return 0; +/*N*/ +/*N*/ USHORT nLastFound = 0; +/*N*/ for (USHORT nRow = 1; nRow <= MAXROW; nRow++) +/*N*/ if ((pRowFlags[nRow] & ~CR_PAGEBREAK) || (pRowHeight[nRow] != ScGlobal::nStdRowHeight)) +/*N*/ nLastFound = nRow; +/*N*/ +/*N*/ return nLastFound; +/*N*/ } + + +/*N*/ BOOL ScTable::UpdateOutlineCol( USHORT nStartCol, USHORT nEndCol, BOOL bShow ) +/*N*/ { +/*N*/ if (pOutlineTable && pColFlags) +/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return FALSE;} //STRIP001 return pOutlineTable->GetColArray()->ManualAction( nStartCol, nEndCol, bShow, pColFlags ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL ScTable::UpdateOutlineRow( USHORT nStartRow, USHORT nEndRow, BOOL bShow ) +/*N*/ { +/*N*/ if (pOutlineTable && pRowFlags) +/*N*/ return pOutlineTable->GetRowArray()->ManualAction( nStartRow, nEndRow, bShow, pRowFlags ); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + + +// Auto-Outline + +/*N*/ inline short DiffSign( USHORT a, USHORT b ) +/*N*/ { +/*N*/ return (a<b) ? -1 : +/*N*/ (a>b) ? 1 : 0; +/*N*/ } + + + +// +// Datei-Operationen +// + +// Laden + +/*N*/ BOOL ScTable::Load( SvStream& rStream, USHORT nVersion, ScProgress* pProgress ) +/*N*/ { +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ USHORT i; +/*N*/ +/*N*/ while (aHdr.BytesLeft() && rStream.GetError() == SVSTREAM_OK) +/*N*/ { +/*N*/ USHORT nID; +/*N*/ rStream >> nID; +/*N*/ switch (nID) +/*N*/ { +/*N*/ case SCID_COLUMNS: // Spalten (Daten) +/*N*/ { +/*N*/ ScMultipleReadHeader aColHdr( rStream ); +/*N*/ if( nVersion >= SC_DATABYTES ) +/*N*/ while( aColHdr.BytesLeft() ) +/*N*/ { +/*N*/ BYTE nCol; +/*N*/ rStream >> nCol; +/*N*/ aCol[ nCol ].Load(rStream, aColHdr); +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rStream.Tell() ); +/*N*/ } +/*N*/ else +/*N*/ for (i=0; i<=MAXCOL; i++) +/*N*/ { +/*N*/ aCol[i].Load(rStream, aColHdr); +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rStream.Tell() ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SCID_COLROWFLAGS: // Spalten-/Zeilenflags +/*N*/ { +/*N*/ ScReadHeader aFlagsHdr( rStream ); +/*N*/ +/*N*/ BYTE nFlags; +/*N*/ USHORT nVal; +/*N*/ short nRep; +/*N*/ +/*N*/ i=0; +/*N*/ while (i<=MAXCOL) +/*N*/ { +/*N*/ rStream >> nRep; +/*N*/ rStream >> nVal; +/*N*/ while (nRep-- && i<=MAXCOL) +/*N*/ pColWidth[i++] = nVal; +/*N*/ } +/*N*/ DBG_ASSERT(nRep==-1, "Fehler bei Spaltenbreiten"); +/*N*/ i=0; +/*N*/ while (i<=MAXCOL) +/*N*/ { +/*N*/ rStream >> nRep; +/*N*/ rStream >> nFlags; +/*N*/ while (nRep-- && i<=MAXCOL) +/*N*/ pColFlags[i++] = nFlags; +/*N*/ } +/*N*/ DBG_ASSERT(nRep==-1, "Fehler bei Spaltenflags"); +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rStream.Tell() ); +/*N*/ +/*N*/ // aus der Datei immer soviele Zeilen laden, wie gespeichert wurden +/*N*/ USHORT nSrcMaxRow = pDocument->GetSrcMaxRow(); +/*N*/ +/*N*/ i=0; +/*N*/ while (i<=nSrcMaxRow) // nSrcMaxRow und MAXROW evtl. unterschiedlich +/*N*/ { +/*N*/ rStream >> nRep; +/*N*/ rStream >> nVal; +/*N*/ while (nRep--) +/*N*/ { +/*N*/ if (i<=MAXROW) +/*N*/ pRowHeight[i] = nVal; +/*N*/ ++i; +/*N*/ } +/*N*/ } +/*N*/ DBG_ASSERT(i==nSrcMaxRow+1, "Fehler bei Zeilenhoehen"); +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rStream.Tell() ); +/*N*/ i=0; +/*N*/ while (i<=nSrcMaxRow) // nSrcMaxRow und MAXROW evtl. unterschiedlich +/*N*/ { +/*N*/ rStream >> nRep; +/*N*/ rStream >> nFlags; +/*N*/ while (nRep--) +/*N*/ { +/*N*/ if (i<=MAXROW) +/*N*/ pRowFlags[i] = nFlags; +/*N*/ ++i; +/*N*/ } +/*N*/ } +/*N*/ DBG_ASSERT(i==nSrcMaxRow+1, "Fehler bei Zeilenflags"); +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rStream.Tell() ); +/*N*/ } +/*N*/ break; +/*N*/ case SCID_TABOPTIONS: // einzelne Einstellungen +/*N*/ { +/*N*/ ScReadHeader aFlagsHdr( rStream ); +/*N*/ +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ rStream >> bScenario; +/*N*/ rStream.ReadByteString( aComment, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ rStream >> bProtected; +/*N*/ String aPass; +/*N*/ rStream.ReadByteString( aPass, rStream.GetStreamCharSet() ); +/*N*/ if (aPass.Len()) +/*N*/ SvPasswordHelper::GetHashPassword(aProtectPass, aPass); +/*N*/ +/*N*/ BOOL bOutline; +/*N*/ rStream >> bOutline; +/*N*/ if (bOutline) +/*N*/ { +/*N*/ StartOutlineTable(); +/*N*/ pOutlineTable->Load( rStream ); +/*N*/ } +/*N*/ +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ { +/*N*/ SfxStyleSheetBasePool* pStylePool = +/*N*/ pDocument->GetStyleSheetPool(); +/*N*/ +/*N*/ rStream.ReadByteString( aPageStyle, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ if ( !pStylePool->Find( aPageStyle, SFX_STYLE_FAMILY_PAGE ) ) +/*N*/ { +/*N*/ DBG_TRACE( "PageStyle not found. Using Standard." ); +/*N*/ aPageStyle = ScGlobal::GetRscString(STR_STYLENAME_STANDARD); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ { +/*N*/ BOOL bOneRange; // einzelner Druckbereich ? +/*N*/ rStream >> bOneRange; +/*N*/ if ( bOneRange ) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ rStream >> aRange; +/*N*/ SetPrintRangeCount( 1 ); +/*N*/ SetPrintRange( 0, aRange ); +/*N*/ } +/*N*/ +/*N*/ lcl_LoadRange( rStream, &pRepeatColRange ); +/*N*/ lcl_LoadRange( rStream, &pRepeatRowRange ); +/*N*/ } +/*N*/ +/*N*/ if ( aFlagsHdr.BytesLeft() ) +/*N*/ rStream >> bVisible; +/*N*/ +/*N*/ if ( aFlagsHdr.BytesLeft() ) // Druckbereiche ab Version 314c +/*N*/ { +/*N*/ USHORT nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ if ( nNewCount ) +/*N*/ { +/*?*/ ScRange aTmp; +/*?*/ SetPrintRangeCount( nNewCount ); +/*?*/ for (i=0; i<nNewCount; i++) +/*?*/ { +/*?*/ rStream >> aTmp; +/*?*/ SetPrintRange( i, aTmp ); +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ if ( aFlagsHdr.BytesLeft() ) // erweiterte Szenario-Flags ab 5.0 +/*N*/ { +/*N*/ rStream >> aScenarioColor; +/*N*/ rStream >> nScenarioFlags; +/*N*/ rStream >> bActiveScenario; +/*N*/ } +/*N*/ else if ( bScenario ) +/*N*/ { +/*?*/ // Default fuer Szenarien aus alten Dateien?? +/*?*/ // Wenn die alten Szenarien wirklich benutzt wurden, +/*?*/ // wuerde der Rahmen wahrscheinlich stoeren. +/*?*/ +/*?*/ nScenarioFlags = SC_SCENARIO_COPYALL; +/*N*/ } +/*N*/ +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rStream.Tell() ); +/*N*/ } +/*N*/ break; +/*N*/ case SCID_TABLINK: // Verknuepfung +/*N*/ { +/*N*/ ScReadHeader aLinkHdr( rStream ); +/*N*/ +/*N*/ rStream >> nLinkMode; +/*N*/ rStream.ReadByteString( aLinkDoc, rStream.GetStreamCharSet() ); +/*N*/ aLinkDoc = ::binfilter::StaticBaseUrl::RelToAbs( aLinkDoc ); +/*N*/ rStream.ReadByteString( aLinkFlt, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aLinkTab, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ BOOL bRelURL; +/*N*/ if ( aLinkHdr.BytesLeft() ) +/*N*/ rStream >> bRelURL; +/*N*/ else +/*N*/ bRelURL = FALSE; +/*N*/ // externer Tabellenname relativ zu absolut +/*N*/ if ( nLinkMode == SC_LINK_VALUE && bRelURL ) +/*N*/ aName = ScGlobal::GetDocTabName( aLinkDoc, aLinkTab ); +/*N*/ +/*N*/ if ( aLinkHdr.BytesLeft() ) // ab 336 auch Filter-Optionen +/*N*/ rStream.ReadByteString( aLinkOpt, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ DBG_ERROR("unbekannter Sub-Record in ScTable::Load"); +/*N*/ ScReadHeader aDummyHeader( rStream ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Neuberechnungen +/*N*/ +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if (pDrawLayer) +/*?*/ pDrawLayer->ScRenamePage( nTab, aName ); +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +// Speichern + + +/*N*/ void lcl_SaveValue( SvStream& rStream, USHORT* pValue, USHORT nEnd ) +/*N*/ { +/*N*/ USHORT nPos = 0; +/*N*/ while (nPos<=nEnd) +/*N*/ { +/*N*/ USHORT nVal = pValue[nPos]; +/*N*/ USHORT nNextPos = nPos+1; +/*N*/ while (nNextPos<=nEnd && pValue[nNextPos]==nVal) +/*N*/ ++nNextPos; +/*N*/ rStream << (USHORT)( nNextPos - nPos ); +/*N*/ rStream << nVal; +/*N*/ nPos = nNextPos; +/*N*/ } +/*N*/ } + + +/*N*/ void lcl_SaveFlags( SvStream& rStream, BYTE* pValue, USHORT nEnd ) +/*N*/ { +/*N*/ USHORT nPos = 0; +/*N*/ while (nPos<=nEnd) +/*N*/ { +/*N*/ BYTE nVal = pValue[nPos] & CR_SAVEMASK; +/*N*/ USHORT nNextPos = nPos+1; +/*N*/ while (nNextPos<=nEnd && (pValue[nNextPos] & CR_SAVEMASK)==nVal) +/*N*/ ++nNextPos; +/*N*/ rStream << (USHORT)( nNextPos - nPos ); +/*N*/ rStream << nVal; +/*N*/ nPos = nNextPos; +/*N*/ } +/*N*/ } + + +/*N*/ void lcl_LoadRange( SvStream& rStream, ScRange** ppRange ) +/*N*/ { +/*N*/ BOOL bIsSet = FALSE; +/*N*/ +/*N*/ rStream >> bIsSet; +/*N*/ +/*N*/ if ( bIsSet ) +/*N*/ { +/*N*/ *ppRange = new ScRange; +/*N*/ rStream >> **ppRange; +/*N*/ } +/*N*/ else +/*N*/ *ppRange = NULL; +/*N*/ } + + +/*N*/ void lcl_SaveRange( SvStream& rStream, ScRange* pRange ) +/*N*/ { +/*N*/ if ( pRange ) +/*N*/ { +/*N*/ rStream << (BOOL)TRUE; +/*N*/ rStream << *pRange; +/*N*/ } +/*N*/ else +/*N*/ rStream << (BOOL)FALSE; +/*N*/ } + + +/*N*/ BOOL ScTable::Save( SvStream& rStream, long& rSavedDocCells, ScProgress* pProgress ) const +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream ); +/*N*/ USHORT i; +/*N*/ +/*N*/ // Spalten (Daten) +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_COLUMNS; +/*N*/ ScMultipleWriteHeader aColHdr( rStream ); +/*N*/ +/*N*/ for (i=0; i<=MAXCOL; i++) +/*N*/ { +/*N*/ const ScColumn* pCol = &aCol[ i ]; +/*N*/ if( !pCol->IsEmptyData() || pCol->NoteCount() || !pCol->IsEmptyAttr()) +/*N*/ { +/*N*/ rStream << (BYTE) i; +/*N*/ aCol[i].Save(rStream, aColHdr); +/*N*/ rSavedDocCells += aCol[i].GetWeightedCount(); +/*N*/ if (pProgress) +/*N*/ pProgress->SetState( rSavedDocCells ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Spalten-/Zeilenflags +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_COLROWFLAGS; +/*N*/ ScWriteHeader aFlagsHdr( rStream ); +/*N*/ +/*N*/ USHORT nSaveMaxRow = pDocument->GetSrcMaxRow(); +/*N*/ +/*N*/ lcl_SaveValue( rStream, pColWidth, MAXCOL ); +/*N*/ lcl_SaveFlags( rStream, pColFlags, MAXCOL ); +/*N*/ lcl_SaveValue( rStream, pRowHeight,nSaveMaxRow ); +/*N*/ lcl_SaveFlags( rStream, pRowFlags, nSaveMaxRow ); +/*N*/ +/*N*/ // wenn dabei weniger Zeilenhoehen als vorhanden gespeichert wurden, +/*N*/ // gibt das noch keine Warnung wegen Datenverlust. +/*N*/ } +/*N*/ +/*N*/ BOOL bRelURL = FALSE; +/*N*/ String aLinkDocSaveName( aLinkDoc ); +/*N*/ String aSaveName( aName ); +/*N*/ if ( nLinkMode ) +/*N*/ { +/*N*/ aLinkDocSaveName = ::binfilter::StaticBaseUrl::AbsToRel( aLinkDocSaveName ); +/*N*/ aLinkDocSaveName = INetURLObject::decode( aLinkDocSaveName, +/*N*/ INET_HEX_ESCAPE, INetURLObject::DECODE_UNAMBIGUOUS ); +/*N*/ if ( ScGlobal::pTransliteration->isEqual( aLinkDocSaveName, +/*N*/ INetURLObject::decode( aLinkDoc, INET_HEX_ESCAPE, +/*N*/ INetURLObject::DECODE_UNAMBIGUOUS ) ) ) +/*N*/ { +/*N*/ aSaveName = INetURLObject::decode( aSaveName, +/*N*/ INET_HEX_ESCAPE, INetURLObject::DECODE_UNAMBIGUOUS ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bRelURL = TRUE; +/*N*/ // Reference to external sheet, only the sheet name is stored +/*N*/ // instead of the absolute DocTabName, will be reconcatenated upon +/*N*/ // load time. +/*N*/ if ( nLinkMode == SC_LINK_VALUE ) +/*N*/ aSaveName = aLinkTab; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // einzelne Einstellungen +/*N*/ +/*N*/ { +/*N*/ rStream << (USHORT) SCID_TABOPTIONS; +/*N*/ ScWriteHeader aFlagsHdr( rStream ); +/*N*/ +/*N*/ rStream.WriteByteString( aSaveName, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ rStream << bScenario; +/*N*/ rStream.WriteByteString( aComment, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ rStream << bProtected; +/*N*/ String aPass; +/*N*/ //rStream.WriteByteString( aProtectPass, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aPass, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ BOOL bOutline = ( pOutlineTable != NULL ); +/*N*/ rStream << bOutline; +/*N*/ if (bOutline) +/*N*/ pOutlineTable->Store( rStream ); +/*N*/ +/*N*/ rStream.WriteByteString( aPageStyle, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ if ( pPrintRanges && nPrintRangeCount == 1 ) // kompatibel zu alten Versionen +/*N*/ lcl_SaveRange( rStream, pPrintRanges ); // (nur wenn genau ein Bereich) +/*N*/ else +/*N*/ lcl_SaveRange( rStream, NULL ); +/*N*/ lcl_SaveRange( rStream, pRepeatColRange ); +/*N*/ lcl_SaveRange( rStream, pRepeatRowRange ); +/*N*/ +/*N*/ rStream << bVisible; +/*N*/ +/*N*/ if ( pPrintRanges && nPrintRangeCount>1 ) // einzelner Bereich schon oben +/*N*/ { +/*?*/ rStream << nPrintRangeCount; // ab Version 314c +/*?*/ if ( nPrintRangeCount > 1 ) +/*?*/ for ( i=0; i<nPrintRangeCount; i++) +/*?*/ rStream << pPrintRanges[i]; +/*N*/ } +/*N*/ else +/*N*/ rStream << (USHORT) 0; +/*N*/ +/*N*/ if( rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) // erweiterte Szenario-Flags ab 5.0 +/*N*/ { +/*N*/ rStream << aScenarioColor; +/*N*/ rStream << nScenarioFlags; +/*N*/ rStream << bActiveScenario; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Verknuepfung +/*N*/ +/*N*/ if (nLinkMode) +/*N*/ { +/*N*/ rStream << (USHORT) SCID_TABLINK; +/*N*/ ScWriteHeader aLinkHdr( rStream ); +/*N*/ +/*N*/ // Hack, um verknuepfte Tabellen mit der 3.1 laden zu koennen (#35242#) +/*N*/ // bei 3.1 Export Filter von "StarCalc 4.0" auf "StarCalc 3.0" umsetzen +/*N*/ // (4.0 Dateien koennen vom Calc 3.1 gelesen werden) +/*N*/ String aSaveFlt = aLinkFlt; +/*N*/ if ( rStream.GetVersion() == SOFFICE_FILEFORMAT_31 && aSaveFlt.EqualsAscii("StarCalc 4.0") ) +/*?*/ aSaveFlt.AssignAscii(RTL_CONSTASCII_STRINGPARAM("StarCalc 3.0")); +/*N*/ +/*N*/ rStream << nLinkMode; +/*N*/ rStream.WriteByteString( aLinkDocSaveName, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aSaveFlt, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aLinkTab, rStream.GetStreamCharSet() ); +/*N*/ rStream << bRelURL; +/*N*/ rStream.WriteByteString( aLinkOpt, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + + // CopyData - fuer Query in anderen Bereich + + + + + + + +// Berechnen der Groesse der Tabelle und setzen der Groesse an der DrawPage + +/*N*/ void ScTable::SetDrawPageSize() +/*N*/ { +/*N*/ ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer(); +/*N*/ if( pDrawLayer ) +/*N*/ { +/*N*/ ULONG x = GetColOffset( MAXCOL + 1 ); +/*N*/ ULONG y = GetRowOffset( MAXROW + 1 ); +/*N*/ x = (ULONG) ((double) x * HMM_PER_TWIPS); +/*N*/ y = (ULONG) ((double) y * HMM_PER_TWIPS); +/*N*/ pDrawLayer->SetPageSize( nTab, Size( x, y ) ); +/*N*/ } +/*N*/ } + + +/*N*/ ULONG ScTable::GetRowOffset( USHORT nRow ) const +/*N*/ { +/*N*/ ULONG n = 0; +/*N*/ if ( pRowFlags && pRowHeight ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ BYTE* pFlags = pRowFlags; +/*N*/ USHORT* pHeight = pRowHeight; +/*N*/ for( i = 0; i < nRow; i++, pFlags++, pHeight++ ) +/*N*/ if( !( *pFlags & CR_HIDDEN ) ) +/*N*/ n += *pHeight; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("GetRowOffset: Daten fehlen"); +/*N*/ return n; +/*N*/ } + + +/*N*/ ULONG ScTable::GetColOffset( USHORT nCol ) const +/*N*/ { +/*N*/ ULONG n = 0; +/*N*/ if ( pColFlags && pColWidth ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ BYTE* pFlags = pColFlags; +/*N*/ USHORT* pWidth = pColWidth; +/*N*/ for( i = 0; i < nCol; i++, pFlags++, pWidth++ ) +/*N*/ if( !( *pFlags & CR_HIDDEN ) ) +/*N*/ n += *pWidth; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("GetColumnOffset: Daten fehlen"); +/*N*/ return n; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_table3.cxx b/binfilter/bf_sc/source/core/data/sc_table3.cxx new file mode 100644 index 000000000000..f04f7fa2b480 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_table3.cxx @@ -0,0 +1,412 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <rtl/math.hxx> +#include <unotools/textsearch.hxx> +#include <unotools/collatorwrapper.hxx> +#include <stdlib.h> +#include <unotools/transliterationwrapper.hxx> + +#include "scitems.hxx" +#include "cell.hxx" +#include "document.hxx" +#include "globstr.hrc" +#include "patattr.hxx" +#include "subtotal.hxx" +#include "docoptio.hxx" +#include "markdata.hxx" +#include "attarray.hxx" +#include "cellform.hxx" + +#include <vector> +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +const USHORT nMaxSorts = 3; // maximale Anzahl Sortierkriterien in aSortParam + +struct ScSortInfo +{ + ScBaseCell* pCell; + USHORT nOrg; + DECL_FIXEDMEMPOOL_NEWDEL( ScSortInfo ); +}; +/*N*/ const USHORT nMemPoolSortInfo = (0x8000 - 64) / sizeof(ScSortInfo); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScSortInfo, nMemPoolSortInfo, nMemPoolSortInfo )//STRIP008 ; + +// END OF STATIC DATA ----------------------------------------------------- + + + + + + + + + +/*N*/ void ScTable::DestroySortCollator() +/*N*/ { +/*N*/ if ( pSortCollator ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ if ( !IsSortCollatorGlobal() ) +/*N*/ } +/*N*/ } + + + + + + + + + + + + + +// Testen, ob beim Loeschen von Zwischenergebnissen andere Daten mit geloescht werden +// (fuer Hinweis-Box) + + +// alte Ergebnisse loeschen +// rParam.nRow2 wird veraendert ! + + +// harte Zahlenformate loeschen (fuer Ergebnisformeln) + + + +// at least MSC needs this at linkage level to be able to use it in a template + +// neue Zwischenergebnisse +// rParam.nRow2 wird veraendert ! + + + +/*N*/ BOOL ScTable::ValidQuery(USHORT nRow, const ScQueryParam& rParam, +/*N*/ BOOL* pSpecial /* =NULL */ , ScBaseCell* pCell /* =NULL */ , +/*N*/ BOOL* pbTestEqualCondition /* = NULL */ ) +/*N*/ { +/*N*/ if (!rParam.GetEntry(0).bDoQuery) +/*N*/ return TRUE; +/*N*/ +/*N*/ //--------------------------------------------------------------- +/*N*/ +/*N*/ const USHORT nFixedBools = 32; +/*N*/ BOOL aBool[nFixedBools]; +/*N*/ BOOL aTest[nFixedBools]; +/*N*/ USHORT nEntryCount = rParam.GetEntryCount(); +/*N*/ BOOL* pPasst = ( nEntryCount <= nFixedBools ? &aBool[0] : new BOOL[nEntryCount] ); +/*N*/ BOOL* pTest = ( nEntryCount <= nFixedBools ? &aTest[0] : new BOOL[nEntryCount] ); +/*N*/ +/*N*/ short nPos = -1; +/*N*/ USHORT i = 0; +/*N*/ BOOL bMatchWholeCell = pDocument->GetDocOptions().IsMatchWholeCell(); +/*N*/ CollatorWrapper* pCollator = (rParam.bCaseSens ? ScGlobal::pCaseCollator : +/*N*/ ScGlobal::pCollator); +/*N*/ ::utl::TransliterationWrapper* pTransliteration = (rParam.bCaseSens ? +/*N*/ ScGlobal::pCaseTransliteration : ScGlobal::pTransliteration); +/*N*/ +/*N*/ while ( (i < nEntryCount) && rParam.GetEntry(i).bDoQuery ) +/*N*/ { +/*N*/ ScQueryEntry& rEntry = rParam.GetEntry(i); +/*N*/ // we can only handle one single direct query +/*N*/ if ( !pCell || i > 0 ) +/*?*/ pCell = GetCell( rEntry.nField, nRow ); +/*N*/ +/*N*/ BOOL bOk = FALSE; +/*N*/ BOOL bTestEqual = FALSE; +/*N*/ +/*N*/ if ( pSpecial && pSpecial[i] ) +/*N*/ { +/*?*/ if (rEntry.nVal == SC_EMPTYFIELDS) +/*?*/ bOk = !( aCol[rEntry.nField].HasDataAt( nRow ) ); +/*?*/ else // if (rEntry.nVal == SC_NONEMPTYFIELDS) +/*?*/ bOk = aCol[rEntry.nField].HasDataAt( nRow ); +/*N*/ } +/*N*/ else if ( !rEntry.bQueryByString && +/*N*/ (pCell ? pCell->HasValueData() : HasValueData(rEntry.nField, nRow)) ) +/*N*/ { // by Value +/*N*/ double nCellVal; +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ switch ( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : +/*N*/ nCellVal = ((ScValueCell*)pCell)->GetValue(); +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA : +/*?*/ nCellVal = ((ScFormulaCell*)pCell)->GetValue(); +/*?*/ break; +/*?*/ default: +/*?*/ nCellVal = 0.0; +/*N*/ } +/*N*/ +/*N*/ } +/*N*/ else +/*?*/ nCellVal = GetValue( rEntry.nField, nRow ); +/*N*/ switch (rEntry.eOp) +/*N*/ { +/*N*/ case SC_EQUAL : +/*?*/ bOk = ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*?*/ break; +/*?*/ case SC_LESS : +/*?*/ bOk = (nCellVal < rEntry.nVal) && !::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*?*/ break; +/*?*/ case SC_GREATER : +/*?*/ bOk = (nCellVal > rEntry.nVal) && !::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*?*/ break; +/*?*/ case SC_LESS_EQUAL : +/*N*/ bOk = (nCellVal < rEntry.nVal) || ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*N*/ if ( bOk && pbTestEqualCondition ) +/*N*/ bTestEqual = ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*N*/ break; +/*?*/ case SC_GREATER_EQUAL : +/*?*/ bOk = (nCellVal > rEntry.nVal) || ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*?*/ if ( bOk && pbTestEqualCondition ) +/*?*/ bTestEqual = ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*?*/ break; +/*?*/ case SC_NOT_EQUAL : +/*?*/ bOk = !::rtl::math::approxEqual( nCellVal, rEntry.nVal ); +/*?*/ break; +/*N*/ } +/*N*/ } +/*N*/ else if ( (rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL) +/*N*/ || (rEntry.bQueryByString +/*N*/ && (pCell ? pCell->HasStringData() : HasStringData(rEntry.nField, nRow))) +/*N*/ ) +/*N*/ { // by String +/*N*/ String aCellStr; +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ if (pCell->GetCellType() != CELLTYPE_NOTE) +/*N*/ { +/*N*/ ULONG nFormat = GetNumberFormat( rEntry.nField, nRow ); +/*N*/ ScCellFormat::GetInputString( pCell, nFormat, aCellStr, *(pDocument->GetFormatTable()) ); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ GetInputString( rEntry.nField, nRow, aCellStr ); +/*N*/ +/*N*/ BOOL bRealRegExp = (rParam.bRegExp && ((rEntry.eOp == SC_EQUAL) +/*N*/ || (rEntry.eOp == SC_NOT_EQUAL))); +/*N*/ BOOL bTestRegExp = (pbTestEqualCondition && rParam.bRegExp +/*N*/ && ((rEntry.eOp == SC_LESS_EQUAL) +/*N*/ || (rEntry.eOp == SC_GREATER_EQUAL))); +/*N*/ if ( bRealRegExp || bTestRegExp ) +/*N*/ { +/*N*/ xub_StrLen nStart = 0; +/*N*/ xub_StrLen nEnd = aCellStr.Len(); +/*N*/ BOOL bMatch = (BOOL) rEntry.GetSearchTextPtr( rParam.bCaseSens ) +/*N*/ ->SearchFrwrd( aCellStr, &nStart, &nEnd ); +/*N*/ // from 614 on, nEnd is behind the found text +/*N*/ if ( bMatch && bMatchWholeCell +/*N*/ && (nStart != 0 || nEnd != aCellStr.Len()) ) +/*?*/ bMatch = FALSE; // RegExp must match entire cell string +/*N*/ if ( bRealRegExp ) +/*N*/ bOk = ((rEntry.eOp == SC_NOT_EQUAL) ? !bMatch : bMatch); +/*N*/ else +/*?*/ bTestEqual = bMatch; +/*N*/ } +/*N*/ if ( !bRealRegExp ) +/*N*/ { +/*N*/ if ( rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL ) +/*N*/ { +/*N*/ if ( bMatchWholeCell ) +/*N*/ bOk = pTransliteration->isEqual( aCellStr, *rEntry.pStr ); +/*N*/ else +/*N*/ { +/*N*/ ::com::sun::star::uno::Sequence< sal_Int32 > xOff; +/*N*/ String aCell( pTransliteration->transliterate( +/*N*/ aCellStr, ScGlobal::eLnge, 0, aCellStr.Len(), +/*N*/ &xOff ) ); +/*N*/ String aQuer( pTransliteration->transliterate( +/*N*/ *rEntry.pStr, ScGlobal::eLnge, 0, rEntry.pStr->Len(), +/*N*/ &xOff ) ); +/*N*/ bOk = (aCell.Search( aQuer ) != STRING_NOTFOUND); +/*N*/ } +/*N*/ if ( rEntry.eOp == SC_NOT_EQUAL ) +/*?*/ bOk = !bOk; +/*N*/ } +/*N*/ else +/*N*/ { // use collator here because data was probably sorted +/*?*/ sal_Int32 nCompare = pCollator->compareString( +/*?*/ aCellStr, *rEntry.pStr ); +/*?*/ switch (rEntry.eOp) +/*?*/ { +/*?*/ case SC_LESS : +/*?*/ bOk = (nCompare < 0); +/*?*/ break; +/*?*/ case SC_GREATER : +/*?*/ bOk = (nCompare > 0); +/*?*/ break; +/*?*/ case SC_LESS_EQUAL : +/*?*/ bOk = (nCompare <= 0); +/*?*/ if ( bOk && pbTestEqualCondition && !bTestEqual ) +/*?*/ bTestEqual = (nCompare == 0); +/*?*/ break; +/*?*/ case SC_GREATER_EQUAL : +/*?*/ bOk = (nCompare >= 0); +/*?*/ if ( bOk && pbTestEqualCondition && !bTestEqual ) +/*?*/ bTestEqual = (nCompare == 0); +/*?*/ break; +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (nPos == -1) +/*N*/ { +/*N*/ nPos++; +/*N*/ pPasst[nPos] = bOk; +/*N*/ pTest[nPos] = bTestEqual; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ if (rEntry.eConnect == SC_AND) +/*?*/ { +/*?*/ pPasst[nPos] = pPasst[nPos] && bOk; +/*?*/ pTest[nPos] = pTest[nPos] && bTestEqual; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ nPos++; +/*?*/ pPasst[nPos] = bOk; +/*?*/ pTest[nPos] = bTestEqual; +/*?*/ } +/*N*/ } +/*N*/ i++; +/*N*/ } +/*N*/ +/*N*/ for ( i=1; (short)i <= nPos; i++ ) +/*N*/ { +/*?*/ pPasst[0] = pPasst[0] || pPasst[i]; +/*?*/ pTest[0] = pTest[0] || pTest[i]; +/*N*/ } +/*N*/ +/*N*/ BOOL bRet = pPasst[0]; +/*N*/ if ( pPasst != &aBool[0] ) +/*?*/ delete [] pPasst; +/*N*/ if ( pbTestEqualCondition ) +/*N*/ *pbTestEqualCondition = pTest[0]; +/*N*/ if ( pTest != &aTest[0] ) +/*?*/ delete [] pTest; +/*N*/ +/*N*/ return bRet; +/*N*/ } + + + + + +/*N*/ BOOL ScTable::CreateQueryParam(USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, ScQueryParam& rQueryParam) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 USHORT i, nCount; +return FALSE;//STRIP001 return bValid; +/*N*/ } + + + + + +/*N*/ long ScTable::GetCellCount() const +/*N*/ { +/*N*/ long nCellCount = 0; +/*N*/ +/*N*/ for ( USHORT nCol=0; nCol<=MAXCOL; nCol++ ) +/*N*/ nCellCount += aCol[nCol].GetCellCount(); +/*N*/ +/*N*/ return nCellCount; +/*N*/ } + +/*N*/ long ScTable::GetWeightedCount() const +/*N*/ { +/*N*/ long nCellCount = 0; +/*N*/ +/*N*/ for ( USHORT nCol=0; nCol<=MAXCOL; nCol++ ) +/*N*/ if ( aCol[nCol].GetCellCount() ) // GetCellCount ist inline +/*N*/ nCellCount += aCol[nCol].GetWeightedCount(); +/*N*/ +/*N*/ return nCellCount; +/*N*/ } + +/*N*/ void ScTable::UpdateSelectionFunction( ScFunctionData& rData, +/*N*/ USHORT nStartCol, USHORT nStartRow, USHORT nEndCol, USHORT nEndRow, +/*N*/ const ScMarkData& rMark ) +/*N*/ { +/*N*/ // Cursor neben einer Markierung nicht beruecksichtigen: +/*N*/ //! nur noch MarkData uebergeben, Cursorposition ggf. hineinselektieren!!! +/*N*/ BOOL bSingle = ( rMark.IsMarked() || !rMark.IsMultiMarked() ); +/*N*/ +/*N*/ // Mehrfachselektion: +/*N*/ +/*N*/ USHORT nCol; +/*N*/ if ( rMark.IsMultiMarked() ) +/*N*/ for (nCol=0; nCol<=MAXCOL && !rData.bError; nCol++) +/*N*/ if ( !pColFlags || !( pColFlags[nCol] & CR_HIDDEN ) ) +/*N*/ aCol[nCol].UpdateSelectionFunction( rMark, rData, pRowFlags, +/*N*/ bSingle && ( nCol >= nStartCol && nCol <= nEndCol ), +/*N*/ nStartRow, nEndRow ); +/*N*/ +/*N*/ // Einfachselektion (oder Cursor) nur wenn nicht negativ (und s.o.): +/*N*/ +/*N*/ if ( bSingle && !rMark.IsMarkNegative() ) +/*N*/ for (nCol=nStartCol; nCol<=nEndCol && !rData.bError; nCol++) +/*N*/ if ( !pColFlags || !( pColFlags[nCol] & CR_HIDDEN ) ) +/*N*/ aCol[nCol].UpdateAreaFunction( rData, pRowFlags, nStartRow, nEndRow ); +/*N*/ } + +/*N*/ void ScTable::FindConditionalFormat( ULONG nKey, ScRangeList& rList ) +/*N*/ { +/*N*/ USHORT nStartRow, nEndRow; +/*N*/ for (USHORT nCol=0; nCol<=MAXCOL; nCol++) +/*N*/ { +/*N*/ ScAttrIterator* pIter = aCol[nCol].CreateAttrIterator( 0, MAXCOL ); +/*N*/ const ScPatternAttr* pPattern = pIter->Next( nStartRow, nEndRow ); +/*N*/ while (pPattern) +/*N*/ { +/*N*/ if (((SfxUInt32Item&)pPattern->GetItem(ATTR_CONDITIONAL)).GetValue() == nKey) +/*N*/ rList.Join( ScRange(nCol,nStartRow,nTab, nCol,nEndRow,nTab) ); +/*N*/ pPattern = pIter->Next( nStartRow, nEndRow ); +/*N*/ } +/*N*/ delete pIter; +/*N*/ } +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_table4.cxx b/binfilter/bf_sc/source/core/data/sc_table4.cxx new file mode 100644 index 000000000000..73b184ba5e4c --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_table4.cxx @@ -0,0 +1,116 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#ifdef _MSC_VER +#pragma optimize("",off) +#endif + // sonst Absturz Win beim Fuellen + +#include "scitems.hxx" + +#include "globstr.hrc" +#include "document.hxx" +#include "autoform.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +#define _D_MAX_LONG_ (double) 0x7fffffff + +extern USHORT nScFillModeMouseModifier; // global.cxx + +// ----------------------------------------------------------------------- + + + + + + + + + + + + + + +#define LF_LEFT 1 +#define LF_TOP 2 +#define LF_RIGHT 4 +#define LF_BOTTOM 8 +#define LF_ALL (LF_LEFT | LF_TOP | LF_RIGHT | LF_BOTTOM) + + + +/*N*/ void ScTable::SetError( USHORT nCol, USHORT nRow, USHORT nError) +/*N*/ { +/*N*/ if (ValidColRow(nCol, nRow)) +/*N*/ aCol[nCol].SetError( nRow, nError ); +/*N*/ } + + + + + +/*N*/ BOOL ScTable::TestTabRefAbs(USHORT nTable) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ for (USHORT i=0; i <= MAXCOL; i++) +/*N*/ if (aCol[i].TestTabRefAbs(nTable)) +/*N*/ bRet = TRUE; +/*N*/ return bRet; +/*N*/ } + + +/*N*/ void ScTable::CompileDBFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) aCol[i].CompileDBFormula( bCreateFormulaString ); +/*N*/ } + +/*N*/ void ScTable::CompileNameFormula( BOOL bCreateFormulaString ) +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) aCol[i].CompileNameFormula( bCreateFormulaString ); +/*N*/ } + +/*N*/ void ScTable::CompileColRowNameFormula() +/*N*/ { +/*N*/ for (USHORT i=0; i<=MAXCOL; i++) aCol[i].CompileColRowNameFormula(); +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_table5.cxx b/binfilter/bf_sc/source/core/data/sc_table5.cxx new file mode 100644 index 000000000000..44da94034ecb --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_table5.cxx @@ -0,0 +1,369 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include "attrib.hxx" +#include "patattr.hxx" +#include "cell.hxx" +#include "document.hxx" +#include "stlpool.hxx" +#include "globstr.hrc" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +#define GET_SCALEVALUE(set,id) ((const SfxUInt16Item&)(set.Get( id ))).GetValue() + + +/*N*/ void ScTable::UpdatePageBreaks( const ScRange* pUserArea ) +/*N*/ { +/*N*/ if ( pDocument->IsImportingXML() ) +/*N*/ return; +/*N*/ if ( !pUserArea && !bPageSizeValid ) +/*N*/ return; +/*N*/ +/*N*/ SfxStyleSheetBase* pStyle = pDocument->GetStyleSheetPool()-> +/*N*/ Find( aPageStyle, SFX_STYLE_FAMILY_PAGE ); +/*N*/ if ( !pStyle ) +/*N*/ { +/*N*/ DBG_ERROR("UpdatePageBreaks: Style nicht gefunden"); +/*N*/ return; +/*N*/ } +/*N*/ SfxItemSet* pStyleSet = &pStyle->GetItemSet(); +/*N*/ const SfxPoolItem* pItem; +/*N*/ +/*N*/ USHORT i; +/*N*/ USHORT nX; +/*N*/ USHORT nY; +/*N*/ USHORT nStartCol = 0; +/*N*/ USHORT nStartRow = 0; +/*N*/ USHORT nEndCol = MAXCOL; +/*N*/ USHORT nEndRow = MAXROW; +/*N*/ if (pUserArea) +/*N*/ { +/*N*/ nStartCol = pUserArea->aStart.Col(); +/*N*/ nStartRow = pUserArea->aStart.Row(); +/*N*/ nEndCol = pUserArea->aEnd.Col(); +/*N*/ nEndRow = pUserArea->aEnd.Row(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nAreaCount = GetPrintRangeCount(); +/*N*/ if ( nAreaCount > 1 ) +/*N*/ { +/*N*/ // bei mehreren Bereichen nichts anzeigen: +/*N*/ +/*N*/ for (nX=0; nX<MAXCOL; nX++) +/*N*/ pColFlags[nX] &= ~CR_PAGEBREAK; +/*N*/ for (nY=0; nY<MAXROW; nY++) +/*N*/ pRowFlags[nY] &= ~CR_PAGEBREAK; +/*N*/ +/*N*/ return; +/*N*/ } +/*N*/ else if ( nAreaCount == 1 ) +/*N*/ { +/*N*/ const ScRange* pArea = GetPrintRange( 0 ); +/*N*/ if (pArea) +/*N*/ { +/*N*/ nStartCol = pArea->aStart.Col(); +/*N*/ nStartRow = pArea->aStart.Row(); +/*N*/ nEndCol = pArea->aEnd.Col(); +/*N*/ nEndRow = pArea->aEnd.Row(); +/*N*/ } +/*N*/ } // sonst alles +/*N*/ } +/*N*/ +/*N*/ // bSkipBreaks holen: +/*N*/ +/*N*/ BOOL bSkipBreaks = FALSE; +/*N*/ +/*N*/ if ( pStyleSet->GetItemState( ATTR_PAGE_SCALETOPAGES, FALSE, &pItem ) == SFX_ITEM_SET ) +/*N*/ { +/*N*/ DBG_ASSERT( pItem->ISA(SfxUInt16Item), "falsches Item" ); +/*N*/ bSkipBreaks = ( ((const SfxUInt16Item*)pItem)->GetValue() > 0 ); +/*N*/ } +/*N*/ +/*N*/ //-------------------------------------------------------------------------- +/*N*/ +/*N*/ long nPageSizeX = aPageSizeTwips.Width(); +/*N*/ long nPageSizeY = aPageSizeTwips.Height(); +/*N*/ +/*N*/ // Anfang: Breaks loeschen +/*N*/ +/*N*/ for (nX=0; nX<nStartCol; nX++) +/*N*/ pColFlags[nX] &= ~CR_PAGEBREAK; +/*N*/ for (nY=0; nY<nStartRow; nY++) +/*N*/ pRowFlags[nY] &= ~CR_PAGEBREAK; +/*N*/ +/*N*/ if (nStartCol) +/*N*/ pColFlags[nStartCol] |= CR_PAGEBREAK; //! AREABREAK +/*N*/ if (nStartRow) +/*N*/ pRowFlags[nStartRow] |= CR_PAGEBREAK; //! AREABREAK +/*N*/ +/*N*/ // Mittelteil: Breaks verteilen +/*N*/ +/*N*/ BOOL bRepeatCol = ( nRepeatStartX != REPEAT_NONE ); +/*N*/ BOOL bColFound = FALSE; +/*N*/ long nSizeX = 0; +/*N*/ for (nX=nStartCol; nX<=nEndCol; nX++) +/*N*/ { +/*N*/ BOOL bStartOfPage = FALSE; +/*N*/ long nThisX = ( pColFlags[nX] & CR_HIDDEN ) ? 0 : pColWidth[nX]; +/*N*/ if ( (nSizeX+nThisX > nPageSizeX) || ((pColFlags[nX] & CR_MANUALBREAK) && !bSkipBreaks) ) +/*N*/ { +/*N*/ pColFlags[nX] |= CR_PAGEBREAK; +/*N*/ nSizeX = 0; +/*N*/ bStartOfPage = TRUE; +/*N*/ } +/*N*/ else if (nX != nStartCol) +/*N*/ pColFlags[nX] &= ~CR_PAGEBREAK; +/*N*/ else +/*N*/ bStartOfPage = TRUE; +/*N*/ +/*N*/ if ( bStartOfPage && bRepeatCol && nX>nRepeatStartX && !bColFound ) +/*N*/ { +/*N*/ // subtract size of repeat columns from page size +/*N*/ for (i=nRepeatStartX; i<=nRepeatEndX; i++) +/*N*/ nPageSizeX -= ( pColFlags[i] & CR_HIDDEN ) ? 0 : pColWidth[i]; +/*N*/ while (nX<=nRepeatEndX) +/*N*/ pColFlags[++nX] &= ~CR_PAGEBREAK; +/*N*/ bColFound = TRUE; +/*N*/ } +/*N*/ +/*N*/ nSizeX += nThisX; +/*N*/ } +/*N*/ +/*N*/ BOOL bRepeatRow = ( nRepeatStartY != REPEAT_NONE ); +/*N*/ BOOL bRowFound = FALSE; +/*N*/ long nSizeY = 0; +/*N*/ for (nY=nStartRow; nY<=nEndRow; nY++) +/*N*/ { +/*N*/ BOOL bStartOfPage = FALSE; +/*N*/ long nThisY = ( pRowFlags[nY] & CR_HIDDEN ) ? 0 : pRowHeight[nY]; +/*N*/ if ( (nSizeY+nThisY > nPageSizeY) || ((pRowFlags[nY] & CR_MANUALBREAK) && !bSkipBreaks) ) +/*N*/ { +/*N*/ pRowFlags[nY] |= CR_PAGEBREAK; +/*N*/ nSizeY = 0; +/*N*/ bStartOfPage = TRUE; +/*N*/ } +/*N*/ else if (nY != nStartRow) +/*N*/ pRowFlags[nY] &= ~CR_PAGEBREAK; +/*N*/ else +/*N*/ bStartOfPage = TRUE; +/*N*/ +/*N*/ if ( bStartOfPage && bRepeatRow && nY>nRepeatStartY && !bRowFound ) +/*N*/ { +/*?*/ // subtract size of repeat rows from page size +/*?*/ for (i=nRepeatStartY; i<=nRepeatEndY; i++) +/*?*/ nPageSizeY -= ( pRowFlags[i] & CR_HIDDEN ) ? 0 : pRowHeight[i]; +/*?*/ while (nY<=nRepeatEndY) +/*?*/ pRowFlags[++nY] &= ~CR_PAGEBREAK; +/*?*/ bRowFound = TRUE; +/*N*/ } +/*N*/ +/*N*/ nSizeY += nThisY; +/*N*/ } +/*N*/ +/*N*/ // Ende: Breaks loeschen +/*N*/ +/*N*/ if (nEndCol < MAXCOL) +/*N*/ { +/*N*/ pColFlags[nEndCol+1] |= CR_PAGEBREAK; //! AREABREAK +/*N*/ for (nX=nEndCol+2; nX<=MAXCOL; nX++) +/*N*/ pColFlags[nX] &= ~CR_PAGEBREAK; +/*N*/ } +/*N*/ if (nEndRow < MAXROW) +/*N*/ { +/*N*/ pRowFlags[nEndRow+1] |= CR_PAGEBREAK; //! AREABREAK +/*N*/ for (nY=nEndRow+2; nY<=MAXROW; nY++) +/*N*/ pRowFlags[nY] &= ~CR_PAGEBREAK; +/*N*/ } +/*N*/ } + +/*N*/ void ScTable::RemoveManualBreaks() +/*N*/ { +/*N*/ if (pColFlags) +/*N*/ for (USHORT nCol = 0; nCol <= MAXCOL; nCol++) +/*N*/ pColFlags[nCol] &= ~CR_MANUALBREAK; +/*N*/ +/*N*/ if (pRowFlags) +/*N*/ for (USHORT nRow = 0; nRow <= MAXROW; nRow++) +/*N*/ pRowFlags[nRow] &= ~CR_MANUALBREAK; +/*N*/ } + + +/*N*/ void ScTable::SetPageSize( const Size& rSize ) +/*N*/ { +/*N*/ if ( rSize.Width() != 0 && rSize.Height() != 0 ) +/*N*/ { +/*N*/ bPageSizeValid = TRUE; +/*N*/ aPageSizeTwips = rSize; +/*N*/ } +/*N*/ else +/*N*/ bPageSizeValid = FALSE; +/*N*/ } + +/*N*/ Size ScTable::GetPageSize() const +/*N*/ { +/*N*/ if ( bPageSizeValid ) +/*N*/ return aPageSizeTwips; +/*N*/ else +/*N*/ return Size(); // leer +/*N*/ } + +/*N*/ void ScTable::SetRepeatArea( USHORT nStartCol, USHORT nEndCol, USHORT nStartRow, USHORT nEndRow ) +/*N*/ { +/*N*/ nRepeatStartX = nStartCol; +/*N*/ nRepeatEndX = nEndCol; +/*N*/ nRepeatStartY = nStartRow; +/*N*/ nRepeatEndY = nEndRow; +/*N*/ } + +/*N*/ void ScTable::StartListening( const ScAddress& rAddress, SfxListener* pListener ) +/*N*/ { +/*N*/ aCol[rAddress.Col()].StartListening( *pListener, rAddress.Row() ); +/*N*/ } + +/*N*/ void ScTable::EndListening( const ScAddress& rAddress, SfxListener* pListener ) +/*N*/ { +/*N*/ aCol[rAddress.Col()].EndListening( *pListener, rAddress.Row() ); +/*N*/ } + +/*N*/ void ScTable::SetPageStyle( const String& rName ) +/*N*/ { +/*N*/ if ( aPageStyle != rName ) +/*N*/ { +/*N*/ String aStrNew = rName; +/*N*/ SfxStyleSheetBasePool* pStylePool = pDocument->GetStyleSheetPool(); +/*N*/ SfxStyleSheetBase* pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE ); +/*N*/ +/*N*/ if ( !pNewStyle ) +/*N*/ { +/*?*/ aStrNew = ScGlobal::GetRscString(STR_STYLENAME_STANDARD); +/*?*/ pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE ); +/*N*/ } +/*N*/ +/*N*/ if ( aPageStyle != aStrNew ) +/*N*/ { +/*N*/ SfxStyleSheetBase* pOldStyle = pStylePool->Find( aPageStyle, SFX_STYLE_FAMILY_PAGE ); +/*N*/ +/*N*/ if ( pOldStyle && pNewStyle ) +/*N*/ { +/*N*/ SfxItemSet& rOldSet = pOldStyle->GetItemSet(); +/*N*/ SfxItemSet& rNewSet = pNewStyle->GetItemSet(); +/*N*/ const USHORT nOldScale = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALE); +/*N*/ const USHORT nOldScaleToPages = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALETOPAGES); +/*N*/ const USHORT nNewScale = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALE); +/*N*/ const USHORT nNewScaleToPages = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALETOPAGES); +/*N*/ +/*N*/ if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) ) +/*N*/ InvalidateTextWidth(); +/*N*/ } +/*N*/ +/*N*/ if ( pNewStyle ) // auch ohne den alten (fuer UpdateStdNames) +/*N*/ aPageStyle = aStrNew; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScTable::InvalidateTextWidth( const ScAddress* pAdrFrom, +/*N*/ const ScAddress* pAdrTo, +/*N*/ BOOL bBroadcast ) +/*N*/ { +/*N*/ if ( pAdrFrom && !pAdrTo ) +/*N*/ { +/*?*/ ScBaseCell* pCell = aCol[pAdrFrom->Col()].GetCell( pAdrFrom->Row() ); +/*?*/ if ( pCell ) +/*?*/ { +/*?*/ pCell->SetTextWidth( TEXTWIDTH_DIRTY ); +/*?*/ pCell->SetScriptType( SC_SCRIPTTYPE_UNKNOWN ); +/*?*/ if ( bBroadcast ) +/*?*/ { // nur bei CalcAsShown +/*?*/ switch ( pCell->GetCellType() ) +/*?*/ { +/*?*/ case CELLTYPE_VALUE : +/*?*/ pDocument->Broadcast( SC_HINT_DATACHANGED, +/*?*/ ScAddress( pAdrFrom->Col(), pAdrFrom->Row(), nTab ), +/*?*/ pCell ); +/*?*/ break; +/*?*/ case CELLTYPE_FORMULA : +/*?*/ ((ScFormulaCell*)pCell)->SetDirty(); +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ const USHORT nColStart = pAdrFrom ? pAdrFrom->Col() : 0; +/*N*/ const USHORT nRowStart = pAdrFrom ? pAdrFrom->Row() : 0; +/*N*/ const USHORT nColEnd = pAdrTo ? pAdrTo->Col() : MAXCOL; +/*N*/ const USHORT nRowEnd = pAdrTo ? pAdrTo->Row() : MAXROW; +/*N*/ +/*N*/ for ( USHORT nCol=nColStart; nCol<=nColEnd; nCol++ ) +/*N*/ { +/*N*/ ScColumnIterator aIter( &aCol[nCol], nRowStart, nRowEnd ); +/*N*/ ScBaseCell* pCell = NULL; +/*N*/ USHORT nRow = nRowStart; +/*N*/ +/*N*/ while ( aIter.Next( nRow, pCell ) ) +/*N*/ { +/*N*/ pCell->SetTextWidth( TEXTWIDTH_DIRTY ); +/*N*/ pCell->SetScriptType( SC_SCRIPTTYPE_UNKNOWN ); +/*N*/ if ( bBroadcast ) +/*N*/ { // nur bei CalcAsShown +/*?*/ switch ( pCell->GetCellType() ) +/*?*/ { +/*?*/ case CELLTYPE_VALUE : +/*?*/ pDocument->Broadcast( SC_HINT_DATACHANGED, +/*?*/ ScAddress( nCol, nRow, nTab ), pCell ); +/*?*/ break; +/*?*/ case CELLTYPE_FORMULA : +/*?*/ ((ScFormulaCell*)pCell)->SetDirty(); +/*?*/ break; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_userdat.cxx b/binfilter/bf_sc/source/core/data/sc_userdat.cxx new file mode 100644 index 000000000000..a9fa6b06c9fd --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_userdat.cxx @@ -0,0 +1,723 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +// TOOLS +#define _BIGINT_HXX +#define _SFXMULTISEL_HXX +#define _STACK_HXX +#define _QUEUE_HXX +#define _DYNARR_HXX +#define _TREELIST_HXX +#define _CACHESTR_HXX +#define _NEW_HXX +//#define _SHL_HXX +//#define _LINK_HXX +//#define _ERRCODE_HXX +//#define _GEN_HXX +//#define _FRACT_HXX +//#define _STRING_HXX +//#define _MTF_HXX +//#define _CONTNR_HXX +//#define _LIST_HXX +//#define _TABLE_HXX +#define _DYNARY_HXX +//#define _UNQIDX_HXX +#define _SVMEMPOOL_HXX +//#define _UNQID_HXX +//#define _DEBUG_HXX +//#define _DATE_HXX +//#define _TIME_HXX +//#define _DATETIME_HXX +//#define _INTN_HXX +//#define _WLDCRD_HXX +//#define _FSYS_HXX +//#define _STREAM_HXX +#define _SV_MULTISEL_HXX + +//SV +//#define _CLIP_HXX *** +#define _CONFIG_HXX +#define _CURSOR_HXX +#define _FONTDLG_HXX +#define _PRVWIN_HXX +//#define _COLOR_HXX +//#define _PAL_HXX +//#define _BITMAP_HXX +//#define _GDIOBJ_HXX +//#define _POINTR_HXX +//#define _ICON_HXX +//#define _IMAGE_HXX +//#define _KEYCOD_HXX +//#define _EVENT_HXX +#define _HELP_HXX +//#define _APP_HXX +//#define _MDIAPP_HXX +//#define _TIMER_HXX +//#define _METRIC_HXX +//#define _REGION_HXX +//#define _OUTDEV_HXX +//#define _SYSTEM_HXX +//#define _VIRDEV_HXX +//#define _JOBSET_HXX +//#define _PRINT_HXX +//#define _WINDOW_HXX +//#define _SYSWIN_HXX +//#define _WRKWIN_HXX +#define _MDIWIN_HXX +//#define _FLOATWIN_HXX +//#define _DOCKWIN_HXX +//#define _CTRL_HXX +//#define _SCRBAR_HXX +//#define _BUTTON_HXX +//#define _IMAGEBTN_HXX +//#define _FIXED_HXX +//#define _GROUP_HXX +//#define _EDIT_HXX +//#define _COMBOBOX_HXX +//#define _LSTBOX_HXX +//#define _SELENG_HXX *** +//#define _SPLIT_HXX +#define _SPIN_HXX +//#define _FIELD_HXX +//#define _MOREBTN_HXX *** +//#define _TOOLBOX_HXX +//#define _STATUS_HXX *** +//#define _DIALOG_HXX +//#define _MSGBOX_HXX +//#define _SYSDLG_HXX +#define _FILDLG_HXX +//#define _PRNDLG_HXX +#define _COLDLG_HXX +//#define _TABDLG_HXX +//#define _MENU_HXX +//#define _GDIMTF_HXX +//#define _POLY_HXX +//#define _ACCEL_HXX +//#define _GRAPH_HXX +#define _SOUND_HXX + +#if defined WIN +#define _MENUBTN_HXX +#endif + +//svtools +#define _SCRWIN_HXX +#define _RULER_HXX +//#define _TABBAR_HXX +//#define _VALUESET_HXX +#define _STDMENU_HXX +//#define _STDCTRL_HXX +//#define _CTRLBOX_HXX +#define _CTRLTOOL_HXX +#define _EXTATTR_HXX +#define _FRM3D_HXX +#define _EXTATTR_HXX + +//SVTOOLS +//#define _SVTREELIST_HXX *** +#define _FILTER_HXX +//#define _SVLBOXITM_HXX *** +//#define _SVTREEBOX_HXX *** +#define _SVICNVW_HXX +#define _SVTABBX_HXX + +//sfxcore.hxx +//#define _SFXINIMGR_HXX *** +//#define _SFXCFGITEM_HXX +//#define _SFX_PRINTER_HXX +#define _SFXGENLINK_HXX +#define _SFXHINTPOST_HXX +#define _SFXDOCINF_HXX +#define _SFXLINKHDL_HXX +//#define _SFX_PROGRESS_HXX + +//sfxsh.hxx +//#define _SFX_SHELL_HXX +//#define _SFXAPP_HXX +//#define _SFXDISPATCH_HXX +//#define _SFXMSG_HXX *** +//#define _SFXOBJFACE_HXX *** +//#define _SFXREQUEST_HXX +#define _SFXMACRO_HXX + +// SFX +//#define _SFXAPPWIN_HXX *** +#define _SFX_SAVEOPT_HXX +//#define _SFX_CHILDWIN_HXX +//#define _SFXCTRLITEM_HXX +#define _SFXPRNMON_HXX +#define _INTRO_HXX +#define _SFXMSGDESCR_HXX +#define _SFXMSGPOOL_HXX +#define _SFXFILEDLG_HXX +#define _PASSWD_HXX +#define _SFXTBXCTRL_HXX +#define _SFXSTBITEM_HXX +#define _SFXMNUITEM_HXX +#define _SFXIMGMGR_HXX +#define _SFXTBXMGR_HXX +#define _SFXSTBMGR_HXX +#define _SFX_MINFITEM_HXX +#define _SFXEVENT_HXX + +//sfxdoc.hxx +//#define _SFX_OBJSH_HXX +//#define _SFX_CLIENTSH_HXX +//#define _SFXDOCINF_HXX +//#define _SFX_OBJFAC_HXX +#define _SFX_DOCFILT_HXX +//#define _SFXDOCFILE_HXX *** +//define _VIEWFAC_HXX +//#define _SFXVIEWFRM_HXX +//#define _SFXVIEWSH_HXX +//#define _MDIFRM_HXX *** +#define _SFX_IPFRM_HXX +//#define _SFX_INTERNO_HXX + +//sfxdlg.hxx +//#define _SFXTABDLG_HXX +//#define _BASEDLGS_HXX *** +#define _SFX_DINFDLG_HXX +#define _SFXDINFEDT_HXX +#define _SFX_MGETEMPL_HXX +#define _SFX_TPLPITEM_HXX +//#define _SFX_STYLEDLG_HXX +#define _NEWSTYLE_HXX +//#define _SFXDOCTEMPL_HXX *** +//#define _SFXDOCTDLG_HXX *** +//#define _SFX_TEMPLDLG_HXX *** +//#define _SFXNEW_HXX *** +#define _SFXDOCMAN_HXX +//#define _SFXDOCKWIN_HXX + +//sfxitems.hxx +#define _SFX_WHMAP_HXX +#define _ARGS_HXX +//#define _SFXPOOLITEM_HXX +//#define _SFXINTITEM_HXX +//#define _SFXENUMITEM_HXX +#define _SFXFLAGITEM_HXX +//#define _SFXSTRITEM_HXX +#define _SFXPTITEM_HXX +#define _SFXRECTITEM_HXX +//#define _SFXITEMPOOL_HXX +//#define _SFXITEMSET_HXX +#define _SFXITEMITER_HXX +#define _SFX_WHITER_HXX +#define _SFXPOOLCACH_HXX +//#define _AEITEM_HXX +#define _SFXRNGITEM_HXX +//#define _SFXSLSTITM_HXX +//#define _SFXSTYLE_HXX + +//xout.hxx +//#define _XENUM_HXX +//#define _XPOLY_HXX +//#define _XATTR_HXX +//#define _XOUTX_HXX +//#define _XPOOL_HXX +//#define _XTABLE_HXX + +//svdraw.hxx +#define _SDR_NOITEMS +#define _SDR_NOTOUCH +#define _SDR_NOTRANSFORM +//#define _SDR_NOOBJECTS +//#define _SDR_NOVIEWS + +//#define SI_NOITEMS +//#define SI_NODRW +#define _SI_NOSBXCONTROLS +//#define _VCATTR_HXX +#define _VCONT_HXX +//#define _VCSBX_HXX +#define _SI_NOOTHERFORMS +#define _VCTRLS_HXX +//#define _VCDRWOBJ_HXX +#define _SI_NOCONTROL +#define _SETBRW_HXX +#define _VCBRW_HXX +#define _SI_NOSBXCONTROLS +//#define _SIDLL_HXX *** + +#define _SVX_DAILDLL_HXX +#define _SVX_HYPHEN_HXX +#define _SVX_IMPGRF_HXX +#define _SVX_OPTITEMS_HXX +#define _SVX_OPTGERL_HXX +#define _SVX_OPTSAVE_HXX +#define _SVX_OPTSPELL_HXX +#define _SVX_OPTPATH_HXX +#define _SVX_OPTLINGU_HXX +#define _SVX_RULER_HXX +#define _SVX_RULRITEM_HXX +#define _SVX_SPLWRAP_HXX +#define _SVX_SPLDLG_HXX +#define _SVX_THESDLG_HXX + +// neu +#define _BIGINT_HXX +#define _SFXMULTISEL_HXX +#define _STACK_HXX +#define _QUEUE_HXX +#define _DYNARR_HXX +#define _TREELIST_HXX +#define _CACHESTR_HXX +#define _NEW_HXX +//#define _SHL_HXX +//#define _LINK_HXX +//#define _ERRCODE_HXX +//#define _GEN_HXX +//#define _FRACT_HXX +//#define _STRING_HXX +//#define _MTF_HXX +//#define _CONTNR_HXX +//#define _LIST_HXX +//#define _TABLE_HXX +#define _DYNARY_HXX +//#define _UNQIDX_HXX +#define _SVMEMPOOL_HXX +//#define _UNQID_HXX +//#define _DEBUG_HXX +//#define _DATE_HXX +//#define _TIME_HXX +//#define _DATETIME_HXX +//#define _INTN_HXX +//#define _WLDCRD_HXX +//#define _FSYS_HXX +//#define _STREAM_HXX +#define _CACHESTR_HXX +#define _SV_MULTISEL_HXX + +//SV +//#define _CLIP_HXX *** +#define _CONFIG_HXX +#define _CURSOR_HXX +#define _FONTDLG_HXX +#define _PRVWIN_HXX +//#define _COLOR_HXX +//#define _PAL_HXX +//#define _BITMAP_HXX +//#define _GDIOBJ_HXX +//#define _POINTR_HXX +//#define _ICON_HXX +//#define _IMAGE_HXX +//#define _KEYCOD_HXX +//#define _EVENT_HXX +#define _HELP_HXX +//#define _APP_HXX +//#define _MDIAPP_HXX +//#define _TIMER_HXX +//#define _METRIC_HXX +//#define _REGION_HXX +//#define _OUTDEV_HXX +//#define _SYSTEM_HXX +//#define _VIRDEV_HXX +//#define _JOBSET_HXX +//#define _PRINT_HXX +//#define _WINDOW_HXX +//#define _SYSWIN_HXX +//#define _WRKWIN_HXX +#define _MDIWIN_HXX +//#define _FLOATWIN_HXX +//#define _DOCKWIN_HXX +//#define _CTRL_HXX +//#define _SCRBAR_HXX +//#define _BUTTON_HXX +//#define _IMAGEBTN_HXX +//#define _FIXED_HXX +//#define _GROUP_HXX +//#define _EDIT_HXX +//#define _COMBOBOX_HXX +//#define _LSTBOX_HXX +//#define _SELENG_HXX *** +//#define _SPLIT_HXX +#define _SPIN_HXX +//#define _FIELD_HXX +//#define _MOREBTN_HXX *** +//#define _TOOLBOX_HXX +//#define _STATUS_HXX *** +//#define _DIALOG_HXX +//#define _MSGBOX_HXX +//#define _SYSDLG_HXX +#define _FILDLG_HXX +//#define _PRNDLG_HXX +#define _COLDLG_HXX +//#define _TABDLG_HXX +//#define _MENU_HXX *** +//#define _GDIMTF_HXX +//#define _POLY_HXX +//#define _ACCEL_HXX +//#define _GRAPH_HXX +#define _SOUND_HXX + + + + + +#define _BIGINT_HXX +#define _SFXMULTISEL_HXX +#define _STACK_HXX +#define _QUEUE_HXX +#define _DYNARR_HXX +#define _TREELIST_HXX +#define _CACHESTR_HXX +#define _NEW_HXX +//#define _SHL_HXX +//#define _LINK_HXX +//#define _ERRCODE_HXX +//#define _GEN_HXX +//#define _FRACT_HXX +//#define _STRING_HXX +//#define _MTF_HXX +//#define _CONTNR_HXX +//#define _LIST_HXX +//#define _TABLE_HXX +#define _DYNARY_HXX +//#define _UNQIDX_HXX +#define _SVMEMPOOL_HXX +//#define _UNQID_HXX +//#define _DEBUG_HXX +//#define _DATE_HXX +//#define _TIME_HXX +//#define _DATETIME_HXX +//#define _INTN_HXX +//#define _WLDCRD_HXX +//#define _FSYS_HXX +//#define _STREAM_HXX +#define _CACHESTR_HXX +#define _SV_MULTISEL_HXX + +//SV +//#define _CLIP_HXX *** +#define _CONFIG_HXX +#define _CURSOR_HXX +#define _FONTDLG_HXX +#define _PRVWIN_HXX +//#define _COLOR_HXX +//#define _PAL_HXX +//#define _BITMAP_HXX +//#define _GDIOBJ_HXX +//#define _POINTR_HXX +//#define _ICON_HXX +//#define _IMAGE_HXX +//#define _KEYCOD_HXX +//#define _EVENT_HXX +#define _HELP_HXX +//#define _APP_HXX +//#define _MDIAPP_HXX +//#define _TIMER_HXX +//#define _METRIC_HXX +//#define _REGION_HXX +//#define _OUTDEV_HXX +//#define _SYSTEM_HXX +//#define _VIRDEV_HXX +//#define _JOBSET_HXX +//#define _PRINT_HXX +//#define _WINDOW_HXX +//#define _SYSWIN_HXX +//#define _WRKWIN_HXX +#define _MDIWIN_HXX +//#define _FLOATWIN_HXX +//#define _DOCKWIN_HXX +//#define _CTRL_HXX +//#define _SCRBAR_HXX +//#define _BUTTON_HXX +//#define _IMAGEBTN_HXX +//#define _FIXED_HXX +//#define _GROUP_HXX +//#define _EDIT_HXX +//#define _COMBOBOX_HXX +//#define _LSTBOX_HXX +//#define _SELENG_HXX *** +//#define _SPLIT_HXX +#define _SPIN_HXX +//#define _FIELD_HXX +//#define _MOREBTN_HXX *** +//#define _TOOLBOX_HXX +//#define _STATUS_HXX *** +//#define _DIALOG_HXX +//#define _MSGBOX_HXX +//#define _SYSDLG_HXX +//#define _FILDLG_HXX +//#define _PRNDLG_HXX +#define _COLDLG_HXX +//#define _TABDLG_HXX +//#define _MENU_HXX +//#define _GDIMTF_HXX +//#define _POLY_HXX +//#define _ACCEL_HXX +//#define _GRAPH_HXX +#define _SOUND_HXX + +#if defined WIN +#define _MENUBTN_HXX +#endif + +//svtools +#define _SCRWIN_HXX +#define _RULER_HXX +//#define _TABBAR_HXX +//#define _VALUESET_HXX +#define _STDMENU_HXX +//#define _STDCTRL_HXX +//#define _CTRLBOX_HXX +#define _CTRLTOOL_HXX +#define _EXTATTR_HXX +#define _FRM3D_HXX +#define _EXTATTR_HXX + +//SVTOOLS +//#define _SVTREELIST_HXX *** +#define _FILTER_HXX +//#define _SVLBOXITM_HXX *** +//#define _SVTREEBOX_HXX *** +#define _SVICNVW_HXX +#define _SVTABBX_HXX + +//sfxcore.hxx +//#define _SFXINIMGR_HXX *** +//#define _SFXCFGITEM_HXX +//#define _SFX_PRINTER_HXX +#define _SFXGENLINK_HXX +#define _SFXHINTPOST_HXX +#define _SFXDOCINF_HXX +#define _SFXLINKHDL_HXX +//#define _SFX_PROGRESS_HXX + +//sfxsh.hxx +//#define _SFX_SHELL_HXX +//#define _SFXAPP_HXX +//#define _SFXDISPATCH_HXX +//#define _SFXMSG_HXX *** +//#define _SFXOBJFACE_HXX *** +//#define _SFXREQUEST_HXX +#define _SFXMACRO_HXX + +// SFX +//#define _SFXAPPWIN_HXX *** +#define _SFX_SAVEOPT_HXX +//#define _SFX_CHILDWIN_HXX +//#define _SFXCTRLITEM_HXX +#define _SFXPRNMON_HXX +#define _INTRO_HXX +#define _SFXMSGDESCR_HXX +#define _SFXMSGPOOL_HXX +#define _SFXFILEDLG_HXX +#define _PASSWD_HXX +#define _SFXTBXCTRL_HXX +#define _SFXSTBITEM_HXX +#define _SFXMNUITEM_HXX +#define _SFXIMGMGR_HXX +#define _SFXTBXMGR_HXX +#define _SFXSTBMGR_HXX +#define _SFX_MINFITEM_HXX +#define _SFXEVENT_HXX + + +#define _SFXFILEDLG_HXX +#define _SFXIMGMGR_HXX +#define _SFXIPFRM_HXX +#define _SFX_MACRO_HXX +#define _SFXMNUITEM_HXX +#define _SFXMNUMGR_HXX +#define _SFXMULTISEL_HXX +#define _SFXMSG_HXX +#define _SFXMSGDESCR_HXX +#define _SFXMSGPOOL_HXX +#define _SFX_MINFITEM_HXX +#define _SFXOBJFACE_HXX +#define _SFXOBJFAC_HXX +//#define _SFXREQUEST_HXX +#define _SFX_SAVEOPT_HXX +#define _SFXSTBITEM_HXX +#define _SFXSTBMGR_HXX +#define _SFXTBXCTRL_HXX +#define _SFXTBXMGR_HXX + +#define _SVX_DAILDLL_HXX +#define _SVX_HYPHEN_HXX +#define _SVX_IMPGRF_HXX +#define _SVX_OPTITEMS_HXX +#define _SVX_OPTGERL_HXX +#define _SVX_OPTSAVE_HXX +#define _SVX_OPTSPELL_HXX +#define _SVX_OPTPATH_HXX +#define _SVX_OPTLINGU_HXX +#define _SVX_RULER_HXX +#define _SVX_RULRITEM_HXX +#define _SVX_SPLWRAP_HXX +#define _SVX_SPLDLG_HXX +#define _SVX_THESDLG_HXX + + +// INCLUDE --------------------------------------------------------------- + + +#include "drwlayer.hxx" +#include "rechead.hxx" +#include "userdat.hxx" +#include "bf_so3/staticbaseurl.hxx" + +namespace binfilter { +// STATIC DATA ----------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ ScDrawObjFactory::ScDrawObjFactory() +/*N*/ { +/*N*/ SdrObjFactory::InsertMakeUserDataHdl( LINK ( this, ScDrawObjFactory, MakeUserData ) ); +/*N*/ } + +/*N*/ ScDrawObjFactory::~ScDrawObjFactory() +/*N*/ { +/*N*/ SdrObjFactory::RemoveMakeUserDataHdl( LINK ( this, ScDrawObjFactory, MakeUserData ) ); +/*N*/ } + +/*N*/ IMPL_LINK_INLINE_START( ScDrawObjFactory, MakeUserData, SdrObjFactory *, pObjFactory ) +/*N*/ { +/*N*/ if ( pObjFactory->nInventor == SC_DRAWLAYER ) +/*N*/ { +/*N*/ if ( pObjFactory->nIdentifier == SC_UD_OBJDATA ) +/*N*/ pObjFactory->pNewData = new ScDrawObjData; +/*N*/ else if ( pObjFactory->nIdentifier == SC_UD_IMAPDATA ) +/*N*/ pObjFactory->pNewData = new ScIMapInfo; +/*N*/ else +/*N*/ DBG_ERROR("MakeUserData: falsche ID"); +/*N*/ } +/*N*/ return 0; +/*N*/ } +/*N*/ IMPL_LINK_INLINE_END( ScDrawObjFactory, MakeUserData, SdrObjFactory *, pObjFactory ) + +//------------------------------------------------------------------------ + +/*N*/ ScDrawObjData::ScDrawObjData() : SdrObjUserData( SC_DRAWLAYER, SC_UD_OBJDATA, 0 ) +/*N*/ { +/*N*/ bValidEnd = FALSE; +/*N*/ } +/*N*/ +/*N*/ ScDrawObjData::ScDrawObjData( const ScDrawObjData& r ) +/*N*/ : SdrObjUserData( r ), aStt( r.aStt ), aEnd( r.aEnd ), +/*N*/ bValidStart( r.bValidStart ), bValidEnd( r.bValidEnd ) +/*N*/ {} +/*N*/ +/*N*/ ScDrawObjData::~ScDrawObjData() +/*N*/ {} +/*N*/ +/*N*/ SdrObjUserData* ScDrawObjData::Clone(SdrObject* pObj) const +/*N*/ { +/*N*/ return new ScDrawObjData( *this ); +/*N*/ } +/*N*/ +/*N*/ void ScDrawObjData::ReadData( SvStream& r ) +/*N*/ { +/*N*/ SdrObjUserData::ReadData( r ); +/*N*/ +/*N*/ USHORT n; +/*N*/ r >> aStt.nCol >> aStt.nRow >> aStt.nTab +/*N*/ >> aEnd.nCol >> aEnd.nRow >> aEnd.nTab +/*N*/ >> n; +/*N*/ bValidEnd = BOOL( n & 0x0001 ); +/*N*/ bValidStart = !BOOL( n & 0x0002 ); // Default (0) = bValidStart fuer alte Dokumente +/*N*/ } +/*N*/ +/*N*/ void ScDrawObjData::WriteData( SvStream& r ) +/*N*/ { +/*N*/ SdrObjUserData::WriteData( r ); +/*N*/ +/*N*/ USHORT n = 0x0000; +/*N*/ if (bValidEnd) n |= 0x0001; +/*N*/ if (!bValidStart) n |= 0x0002; // Default (0) = bValidStart fuer alte Dokumente +/*N*/ +/*N*/ r << (UINT16) aStt.nCol << (UINT16) aStt.nRow << (UINT16) aStt.nTab +/*N*/ << (UINT16) aEnd.nCol << (UINT16) aEnd.nRow << (UINT16) aEnd.nTab +/*N*/ << n; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScIMapInfo::ScIMapInfo() : +/*N*/ SdrObjUserData( SC_DRAWLAYER, SC_UD_IMAPDATA, 0 ) +/*N*/ { +/*N*/ } + +/*N*/ ScIMapInfo::ScIMapInfo( const ImageMap& rImageMap ) : +/*N*/ SdrObjUserData( SC_DRAWLAYER, SC_UD_IMAPDATA, 0 ), +/*N*/ aImageMap( rImageMap ) +/*N*/ { +/*N*/ } + +/*N*/ ScIMapInfo::ScIMapInfo( const ScIMapInfo& rIMapInfo ) : +/*N*/ SdrObjUserData( rIMapInfo ), +/*N*/ aImageMap( rIMapInfo.aImageMap ) +/*N*/ { +/*N*/ } + +/*N*/ __EXPORT ScIMapInfo::~ScIMapInfo() +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ SdrObjUserData* __EXPORT ScIMapInfo::Clone( SdrObject* pObj ) const +/*N*/ { +/*N*/ return new ScIMapInfo( *this ); +/*N*/ } +/*N*/ +/*N*/ void __EXPORT ScIMapInfo::WriteData( SvStream& rOStm ) +/*N*/ { +/*N*/ SdrObjUserData::WriteData( rOStm ); +/*N*/ +/*N*/ ScWriteHeader aHdr( rOStm ); +/*N*/ +/*N*/ aImageMap.Write( + rOStm, ::binfilter::StaticBaseUrl::GetBaseURL(INetURLObject::NO_DECODE)); +/*N*/ } +/*N*/ +/*N*/ void __EXPORT ScIMapInfo::ReadData( SvStream& rIStm ) +/*N*/ { +/*N*/ SdrObjUserData::ReadData( rIStm ); +/*N*/ +/*N*/ ScReadHeader aHdr( rIStm ); +/*N*/ +/*N*/ aImageMap.Read( + rIStm, ::binfilter::StaticBaseUrl::GetBaseURL(INetURLObject::NO_DECODE)); +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/data/sc_validat.cxx b/binfilter/bf_sc/source/core/data/sc_validat.cxx new file mode 100644 index 000000000000..04800c8dd7f1 --- /dev/null +++ b/binfilter/bf_sc/source/core/data/sc_validat.cxx @@ -0,0 +1,312 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + + +#include <math.h> + + +#include "validat.hxx" +#include "patattr.hxx" +#include "rechead.hxx" +#include "globstr.hrc" +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ SV_IMPL_OP_PTRARR_SORT( ScValidationEntries_Impl, ScValidationDataPtr ); + +//------------------------------------------------------------------------ + +// +// Eintrag fuer Gueltigkeit (es gibt nur eine Bedingung) +// + +/*N*/ ScValidationData::ScValidationData( ScValidationMode eMode, ScConditionMode eOper, +/*N*/ const String& rExpr1, const String& rExpr2, +/*N*/ ScDocument* pDocument, const ScAddress& rPos, +/*N*/ BOOL bCompileEnglish, BOOL bCompileXML ) : +/*N*/ ScConditionEntry( eOper, rExpr1, rExpr2, pDocument, rPos, bCompileEnglish, bCompileXML ), +/*N*/ nKey( 0 ), +/*N*/ eDataMode( eMode ) +/*N*/ { +/*N*/ bShowInput = bShowError = FALSE; +/*N*/ eErrorStyle = SC_VALERR_STOP; +/*N*/ } + +/*N*/ ScValidationData::ScValidationData( const ScValidationData& r ) : +/*N*/ ScConditionEntry( r ), +/*N*/ nKey( r.nKey ), +/*N*/ eDataMode( r.eDataMode ), +/*N*/ bShowInput( r.bShowInput ), +/*N*/ bShowError( r.bShowError ), +/*N*/ eErrorStyle( r.eErrorStyle ), +/*N*/ aInputTitle( r.aInputTitle ), +/*N*/ aInputMessage( r.aInputMessage ), +/*N*/ aErrorTitle( r.aErrorTitle ), +/*N*/ aErrorMessage( r.aErrorMessage ) +/*N*/ { +/*N*/ // Formeln per RefCount kopiert +/*N*/ } + +/*N*/ ScValidationData::ScValidationData( ScDocument* pDocument, const ScValidationData& r ) : +/*N*/ ScConditionEntry( pDocument, r ), +/*N*/ nKey( r.nKey ), +/*N*/ eDataMode( r.eDataMode ), +/*N*/ bShowInput( r.bShowInput ), +/*N*/ bShowError( r.bShowError ), +/*N*/ eErrorStyle( r.eErrorStyle ), +/*N*/ aInputTitle( r.aInputTitle ), +/*N*/ aInputMessage( r.aInputMessage ), +/*N*/ aErrorTitle( r.aErrorTitle ), +/*N*/ aErrorMessage( r.aErrorMessage ) +/*N*/ { +/*N*/ // Formeln wirklich kopiert +/*N*/ } + +/*N*/ ScValidationData::ScValidationData( SvStream& rStream, ScMultipleReadHeader& rHdr, +/*N*/ ScDocument* pDocument ) : +/*N*/ ScConditionEntry( rStream, rHdr, pDocument ) +/*N*/ { +/*N*/ // im Datei-Header sind getrennte Eintraege fuer ScConditionEntry und ScValidationData +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ // 1) Key +/*N*/ // 2) eDataMode +/*N*/ // 3) bShowInput +/*N*/ // 4) aInputTitle +/*N*/ // 5) aInputMessage +/*N*/ // 6) bShowError +/*N*/ // 7) aErrorTitle +/*N*/ // 8) aErrorMessage +/*N*/ // 9) eErrorStyle +/*N*/ +/*N*/ USHORT nDummy; +/*N*/ rStream >> nKey; +/*N*/ rStream >> nDummy; +/*N*/ eDataMode = (ScValidationMode) nDummy; +/*N*/ rStream >> bShowInput; +/*N*/ rStream.ReadByteString( aInputTitle, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aInputMessage, rStream.GetStreamCharSet() ); +/*N*/ rStream >> bShowError; +/*N*/ rStream.ReadByteString( aErrorTitle, rStream.GetStreamCharSet() ); +/*N*/ rStream.ReadByteString( aErrorMessage, rStream.GetStreamCharSet() ); +/*N*/ rStream >> nDummy; +/*N*/ eErrorStyle = (ScValidErrorStyle) nDummy; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ ScValidationData::~ScValidationData() +/*N*/ { +/*N*/ } + +/*N*/ void ScValidationData::Store(SvStream& rStream, ScMultipleWriteHeader& rHdr) const +/*N*/ { +/*N*/ // im Datei-Header sind getrennte Eintraege fuer ScConditionEntry und ScValidationData +/*N*/ +/*N*/ StoreCondition( rStream, rHdr ); +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ // 1) Key +/*N*/ // 2) eDataMode +/*N*/ // 3) bShowInput +/*N*/ // 4) aInputTitle +/*N*/ // 5) aInputMessage +/*N*/ // 6) bShowError +/*N*/ // 7) aErrorTitle +/*N*/ // 8) aErrorMessage +/*N*/ // 9) eErrorStyle +/*N*/ +/*N*/ rStream << nKey; +/*N*/ rStream << (USHORT) eDataMode; +/*N*/ rStream << bShowInput; +/*N*/ rStream.WriteByteString( aInputTitle, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aInputMessage, rStream.GetStreamCharSet() ); +/*N*/ rStream << bShowError; +/*N*/ rStream.WriteByteString( aErrorTitle, rStream.GetStreamCharSet() ); +/*N*/ rStream.WriteByteString( aErrorMessage, rStream.GetStreamCharSet() ); +/*N*/ rStream << (USHORT) eErrorStyle; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ BOOL ScValidationData::IsEmpty() const +/*N*/ { +/*N*/ String aEmpty; +/*N*/ ScValidationData aDefault( SC_VALID_ANY, SC_COND_EQUAL, aEmpty, aEmpty, GetDocument(), ScAddress() ); +/*N*/ return EqualEntries( aDefault ); +/*N*/ } + +/*N*/ BOOL ScValidationData::EqualEntries( const ScValidationData& r ) const +/*N*/ { +/*N*/ // gleiche Parameter eingestellt (ohne Key) +/*N*/ +/*N*/ return ScConditionEntry::operator==(r) && +/*N*/ eDataMode == r.eDataMode && +/*N*/ bShowInput == r.bShowInput && +/*N*/ bShowError == r.bShowError && +/*N*/ eErrorStyle == r.eErrorStyle && +/*N*/ aInputTitle == r.aInputTitle && +/*N*/ aInputMessage == r.aInputMessage && +/*N*/ aErrorTitle == r.aErrorTitle && +/*N*/ aErrorMessage == r.aErrorMessage; +/*N*/ } + +/*N*/ void ScValidationData::ResetInput() +/*N*/ { +/*N*/ bShowInput = FALSE; +/*N*/ } + +/*N*/ void ScValidationData::ResetError() +/*N*/ { +/*N*/ bShowError = FALSE; +/*N*/ } + +/*N*/ void ScValidationData::SetInput( const String& rTitle, const String& rMsg ) +/*N*/ { +/*N*/ bShowInput = TRUE; +/*N*/ aInputTitle = rTitle; +/*N*/ aInputMessage = rMsg; +/*N*/ } + +/*N*/ void ScValidationData::SetError( const String& rTitle, const String& rMsg, +/*N*/ ScValidErrorStyle eStyle ) +/*N*/ { +/*N*/ bShowError = TRUE; +/*N*/ eErrorStyle = eStyle; +/*N*/ aErrorTitle = rTitle; +/*N*/ aErrorMessage = rMsg; +/*N*/ } + +/*N*/ BOOL ScValidationData::GetErrMsg( String& rTitle, String& rMsg, +/*N*/ ScValidErrorStyle& rStyle ) const +/*N*/ { +/*N*/ rTitle = aErrorTitle; +/*N*/ rMsg = aErrorMessage; +/*N*/ rStyle = eErrorStyle; +/*N*/ return bShowError; +/*N*/ } + +/*N*/ BOOL ScValidationData::IsDataValid( ScBaseCell* pCell, const ScAddress& rPos ) const +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return FALSE; //STRIP001 double nVal = 0.0; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScValidationDataList::ScValidationDataList(const ScValidationDataList& rList) +/*N*/ { +/*N*/ // fuer Ref-Undo - echte Kopie mit neuen Tokens! +/*N*/ +/*N*/ USHORT nCount = rList.Count(); +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ InsertNew( rList[i]->Clone() ); +/*N*/ +/*N*/ //! sortierte Eintraege aus rList schneller einfuegen ??? +/*N*/ } + +/*N*/ ScValidationData* ScValidationDataList::GetData( sal_uInt32 nKey ) +/*N*/ { +/*N*/ //! binaer suchen +/*N*/ +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ if ((*this)[i]->GetKey() == nKey) +/*N*/ return (*this)[i]; +/*N*/ +/*N*/ DBG_ERROR("ScValidationDataList: Eintrag nicht gefunden"); +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScValidationDataList::Load( SvStream& rStream, ScDocument* pDocument ) +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ +/*N*/ for (USHORT i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ ScValidationData* pNew = new ScValidationData( rStream, aHdr, pDocument ); +/*N*/ InsertNew( pNew ); +/*N*/ } +/*N*/ } + +/*N*/ void ScValidationDataList::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ USHORT i; +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nCount = Count(); +/*N*/ USHORT nUsed = 0; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ((*this)[i]->IsUsed()) +/*N*/ ++nUsed; +/*N*/ +/*N*/ rStream << nUsed; // Anzahl der gespeicherten +/*N*/ +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScValidationData* pForm = (*this)[i]; +/*N*/ if (pForm->IsUsed()) +/*N*/ pForm->Store( rStream, aHdr ); +/*N*/ } +/*N*/ } + +/*N*/ void ScValidationDataList::ResetUsed() +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ (*this)[i]->SetUsed(FALSE); +/*N*/ } + +/*N*/ void ScValidationDataList::CompileXML() +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ (*this)[i]->CompileXML(); +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/addinhelpid.hxx b/binfilter/bf_sc/source/core/inc/addinhelpid.hxx new file mode 100644 index 000000000000..ca78d9b16725 --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/addinhelpid.hxx @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_ADDINHELPID_HXX +#define SC_ADDINHELPID_HXX + +#include <rtl/ustring.hxx> +namespace binfilter { + + +// ============================================================================ + +struct ScUnoAddInHelpId; + +/** Generates help IDs for standard Calc AddIns. */ +class ScUnoAddInHelpIdGenerator +{ +private: + const ScUnoAddInHelpId* pCurrHelpIds; /// Array of function names and help IDs. + sal_uInt32 nArrayCount; /// Count of array entries. + +public: + ScUnoAddInHelpIdGenerator( const ::rtl::OUString& rServiceName ); + + /** Sets service name of the AddIn. Has to be done before requesting help IDs. */ + void SetServiceName( const ::rtl::OUString& rServiceName ); + + /** @return The help ID of the function with given built-in name or 0 if not found. */ + sal_uInt16 GetHelpId( const ::rtl::OUString& rFuncName ) const; +}; + + +// ============================================================================ + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/addinlis.hxx b/binfilter/bf_sc/source/core/inc/addinlis.hxx new file mode 100644 index 000000000000..0ff0734d18a5 --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/addinlis.hxx @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_ADDINLIS_HXX +#define SC_ADDINLIS_HXX + +#include "adiasync.hxx" // for ScAddInDocs PtrArr + +#include <com/sun/star/sheet/XResultListener.hpp> + +#include <com/sun/star/sheet/XVolatileResult.hpp> + +#include <com/sun/star/lang/XServiceInfo.hpp> + +#include <cppuhelper/implbase2.hxx> +namespace binfilter { + + + +class ScDocument; + + +class ScAddInListener : public cppu::WeakImplHelper2< + ::com::sun::star::sheet::XResultListener, + ::com::sun::star::lang::XServiceInfo >, + public SfxBroadcaster +{ +private: + ::com::sun::star::uno::Reference< ::com::sun::star::sheet::XVolatileResult> xVolRes; + ::com::sun::star::uno::Any aResult; + ScAddInDocs* pDocs; // documents where this is used + + static List aAllListeners; + + // always allocated via CreateListener + ScAddInListener( + ::com::sun::star::uno::Reference< + ::com::sun::star::sheet::XVolatileResult> xVR, + ScDocument* pD ); + +public: + virtual ~ScAddInListener(); + + // create Listener and put it into global list + static ScAddInListener* CreateListener( + ::com::sun::star::uno::Reference< + ::com::sun::star::sheet::XVolatileResult> xVR, + ScDocument* pDoc ); + + static ScAddInListener* Get( ::com::sun::star::uno::Reference< + ::com::sun::star::sheet::XVolatileResult> xVR ); + static void RemoveDocument( ScDocument* pDocument ); + + BOOL HasDocument( ScDocument* pDoc ) const { return pDocs->Seek_Entry( pDoc ); } + void AddDocument( ScDocument* pDoc ) { pDocs->Insert( pDoc ); } + const ::com::sun::star::uno::Any& GetResult() const { return aResult; } + + + // XResultListener + virtual void SAL_CALL modified( const ::com::sun::star::sheet::ResultEvent& aEvent ) + throw(::com::sun::star::uno::RuntimeException); + + // XEventListener + virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) + throw(::com::sun::star::uno::RuntimeException); + + // XServiceInfo + virtual ::rtl::OUString SAL_CALL getImplementationName( ) + throw(::com::sun::star::uno::RuntimeException); + virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) + throw(::com::sun::star::uno::RuntimeException); + virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( ) + throw(::com::sun::star::uno::RuntimeException); +}; + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/adiasync.hxx b/binfilter/bf_sc/source/core/inc/adiasync.hxx new file mode 100644 index 000000000000..2214d2fe6860 --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/adiasync.hxx @@ -0,0 +1,95 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _SC_ADIASYNC_HXX +#define _SC_ADIASYNC_HXX + +#include <bf_svtools/brdcst.hxx> + +#include "callform.hxx" +class String; +namespace binfilter { + +extern "C" { +void CALLTYPE ScAddInAsyncCallBack( double& nHandle, void* pData ); +} + + +class ScAddInAsync; +typedef ScAddInAsync* ScAddInAsyncPtr; +SV_DECL_PTRARR_SORT( ScAddInAsyncs, ScAddInAsyncPtr, 4, 4 )//STRIP008 ; +extern ScAddInAsyncs theAddInAsyncTbl; // in adiasync.cxx + +class ScDocument; +typedef ScDocument* ScAddInDocPtr; +SV_DECL_PTRARR_SORT( ScAddInDocs, ScAddInDocPtr, 1, 1 )//STRIP008 ; + + +class ScAddInAsync : public SfxBroadcaster +{ +private: + union + { + double nVal; // aktueller Wert + String* pStr; + }; + ScAddInDocs* pDocs; // Liste der benutzenden Dokumente + FuncData* pFuncData; // Zeiger auf die Daten in der Collection + ULONG nHandle; // wird von double auf ULONG gecasted + ParamType eType; // PTR_DOUBLE oder PTR_STRING Ergebnis + BOOL bValid; // ob Wert gueltig + +public: + // cTor nur wenn ScAddInAsync::Get fehlschlaegt! + // nIndex: Index aus der FunctionCollection + ScAddInAsync( ULONG nHandle, USHORT nIndex, + ScDocument* pDoc ); + // default-cTor nur fuer das eine globale aSeekObj !!! + ScAddInAsync(); + virtual ~ScAddInAsync(); + static ScAddInAsync* Get( ULONG nHandle ); + static void RemoveDocument( ScDocument* pDocument ); + BOOL IsValid() const { return bValid; } + ParamType GetType() const { return eType; } + double GetValue() const { return nVal; } + const String& GetString() const { return *pStr; } + BOOL HasDocument( ScDocument* pDoc ) const + { return pDocs->Seek_Entry( pDoc ); } + void AddDocument( ScDocument* pDoc ) { pDocs->Insert( pDoc ); } + + // Vergleichsoperatoren fuer PtrArrSort + BOOL operator < ( const ScAddInAsync& r ) { return nHandle < r.nHandle; } + BOOL operator ==( const ScAddInAsync& r ) { return nHandle == r.nHandle; } +}; + + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/ansitab.hxx b/binfilter/bf_sc/source/core/inc/ansitab.hxx new file mode 100644 index 000000000000..afa5f9e1219b --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/ansitab.hxx @@ -0,0 +1,585 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_ANSITAB_HXX +#define SC_ANSITAB_HXX + +#include <tools/solar.h> +namespace binfilter { + +#define C_ILLEGAL 0x0000 +#define C_CHAR 0x0001 +#define C_CHAR_BOOL 0x0002 +#define C_CHAR_WORD 0x0004 +#define C_CHAR_VALUE 0x0008 +#define C_CHAR_STRING 0x0010 +#define C_CHAR_DONTCARE 0x0020 +#define C_BOOL 0x0040 +#define C_WORD 0x0080 +#define C_WORD_SEP 0x0100 +#define C_VALUE 0x0200 +#define C_VALUE_SEP 0x0400 +#define C_VALUE_EXP 0x0800 +#define C_VALUE_SIGN 0x1000 +#define C_VALUE_VALUE 0x2000 +#define C_STRING_SEP 0x4000 + +#ifdef OS2 +USHORT CharTable[256] = +{ + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_DONTCARE | C_WORD_SEP | C_VALUE_SEP, // 32 = " " + C_CHAR | C_WORD_SEP | C_VALUE_SEP, // 33 = "!" + C_CHAR_STRING | C_STRING_SEP, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_VALUE, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, // 38 = "&" + C_ILLEGAL, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, // 40 = "(" + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR | C_WORD_SEP | C_VALUE_EXP | C_VALUE_SIGN, + C_VALUE, + C_CHAR | C_WORD_SEP | C_VALUE_EXP | C_VALUE_SIGN, + C_WORD | C_VALUE, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, // 50 = "2" + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_WORD, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR_BOOL | C_WORD_SEP | C_VALUE_SEP, // 60 = "<" + C_CHAR | C_BOOL | C_WORD_SEP | C_VALUE_SEP, + C_CHAR_BOOL | C_BOOL | C_WORD_SEP | C_VALUE_SEP, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 70 = "F" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 80 = "P" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 90 = "Z" + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_WORD, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 100 = "d" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 110 = "n" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 120 = "x" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, // 124 = "|" + C_ILLEGAL, + C_ILLEGAL, // 126 = "~" + C_ILLEGAL, // 127 + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, // 130 + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 140 + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, // 150 + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 160 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 170 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 180 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 190 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 200 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 210 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL , // 220 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 230 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 240 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 250 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL // 255 +}; + +//#elif defined MAC +//#elif defined UNIX +// +#else + +USHORT CharTable[256] = +{ + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_DONTCARE | C_WORD_SEP | C_VALUE_SEP, // 32 = " " + C_CHAR | C_WORD_SEP | C_VALUE_SEP, // 33 = "!" + C_CHAR_STRING | C_STRING_SEP, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_VALUE, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, // 38 = "&" + C_ILLEGAL, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, // 40 = "(" + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR | C_WORD_SEP | C_VALUE_EXP | C_VALUE_SIGN, + C_VALUE, + C_CHAR | C_WORD_SEP | C_VALUE_EXP | C_VALUE_SIGN, + C_WORD | C_VALUE, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, // 50 = "2" + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_CHAR_VALUE | C_WORD | C_VALUE | C_VALUE_EXP | C_VALUE_VALUE, + C_WORD, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_CHAR_BOOL | C_WORD_SEP | C_VALUE_SEP, // 60 = "<" + C_CHAR | C_BOOL | C_WORD_SEP | C_VALUE_SEP, + C_CHAR_BOOL | C_BOOL | C_WORD_SEP | C_VALUE_SEP, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 70 = "F" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 80 = "P" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 90 = "Z" + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR | C_WORD_SEP | C_VALUE_SEP, + C_WORD, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 100 = "d" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 110 = "n" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, // 120 = "x" + C_CHAR_WORD | C_WORD, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, // 124 = "|" + C_ILLEGAL, + C_ILLEGAL, // 126 = "~" + C_ILLEGAL, // 127 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 130 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 140 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 150 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 160 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 170 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 180 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 190 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 200 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 210 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, // 220 + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, // 230 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 240 + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL, // 250 + C_ILLEGAL, + C_CHAR_WORD | C_WORD, + C_ILLEGAL, + C_ILLEGAL, + C_ILLEGAL // 255 +}; + +#endif + + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/bcaslot.hxx b/binfilter/bf_sc/source/core/inc/bcaslot.hxx new file mode 100644 index 000000000000..7fb8710f8cb0 --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/bcaslot.hxx @@ -0,0 +1,158 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _SC_BCASLOT_HXX +#define _SC_BCASLOT_HXX + +#include <bf_svtools/brdcst.hxx> +#include <bf_svtools/svarray.hxx> + +#include "global.hxx" +#include "brdcst.hxx" +namespace binfilter { + +class ScBroadcastArea; +class ScBroadcastAreaList; + +#define BCA_INITGROWSIZE 16 +typedef ScBroadcastArea* ScBroadcastAreaPtr; +SV_DECL_PTRARR_SORT( ScBroadcastAreas, ScBroadcastAreaPtr, + BCA_INITGROWSIZE, BCA_INITGROWSIZE )//STRIP008 ; + +// wird in einem nach Objekten sortierten SV_PTRARR_SORT benutzt +class ScBroadcastArea : public ScRange, public SfxBroadcaster +{ +private: + ScBroadcastArea* pUpdateChainNext; + USHORT nRefCount; + BOOL bInUpdateChain; + +public: + ScBroadcastArea( const ScRange& rRange ) + : ScRange( rRange ), SfxBroadcaster(), pUpdateChainNext( NULL ), + nRefCount( 0 ), bInUpdateChain( FALSE ) {} + inline void UpdateRange( const ScRange& rNewRange ) + { aStart = rNewRange.aStart; aEnd = rNewRange.aEnd; } + inline ScAddress GetStart() const { return aStart; } + inline ScAddress GetEnd() const { return aEnd; } + inline void IncRef() { ++nRefCount; } + inline USHORT DecRef() { return --nRefCount; } + inline ScBroadcastArea* GetUpdateChainNext() const { return pUpdateChainNext; } + inline void SetUpdateChainNext( ScBroadcastArea* p ) { pUpdateChainNext = p; } + inline BOOL IsInUpdateChain() const { return bInUpdateChain; } + inline void SetInUpdateChain( BOOL b ) { bInUpdateChain = b; } + + // zur Sortierung wird die linke obere Ecke herangezogen, + // ist diese gleich, zaehlt auch die rechte untere Ecke + BOOL operator < ( const ScBroadcastArea& rArea ) const + { return aStart < rArea.aStart || + (aStart == rArea.aStart && aEnd < rArea.aEnd) ; } + BOOL operator ==( const ScBroadcastArea& rArea ) const + { return aStart == rArea.aStart && aEnd == rArea.aEnd; } +}; +class ScBroadcastAreaSlotMachine; + +// Sammlung von BroadcastAreas +class ScBroadcastAreaSlot +{ +private: + ScBroadcastAreas* pBroadcastAreaTbl; + ScBroadcastArea* pTmpSeekBroadcastArea; // fuer Seek_Entry + ScDocument* pDoc; + ScBroadcastAreaSlotMachine* pBASM; + + USHORT FindBroadcastArea( const ScRange& rRange ) const; + ScBroadcastArea* GetBroadcastArea( const ScRange& rRange ) const; + +public: + ScBroadcastAreaSlot( ScDocument* pDoc, + ScBroadcastAreaSlotMachine* pBASM ); + ~ScBroadcastAreaSlot(); + const ScBroadcastAreas& GetBroadcastAreas() const + { return *pBroadcastAreaTbl; } + void StartListeningArea( const ScRange& rRange, + SfxListener* pListener, + ScBroadcastArea*& rpArea ); + void EndListeningArea( const ScRange& rRange, + SfxListener* pListener, + ScBroadcastArea*& rpArea ); + BOOL AreaBroadcast( const ScHint& rHint ) const; + // return: mindestens ein Broadcast gewesen + BOOL AreaBroadcastInRange( const ScRange& rRange, + const ScHint& rHint ) const; +/*N*/ void DelBroadcastAreasInRange( const ScRange& rRange ); +}; + + +/* + BroadcastAreaSlots und deren Verwaltung, einmal je Dokument + + +---+---+ + | 0 | 2 | Anordnung Cols/Rows + +---+---+ + | 1 | 3 | + +---+---+ + */ + +class ScBroadcastAreaSlotMachine +{ +private: + ScBroadcastAreaSlot** ppSlots; + ScDocument* pDoc; + ScBroadcastAreaList* pBCAlwaysList; // fuer den RC_ALWAYS Spezialbereich + ScBroadcastArea* pUpdateChain; + ScBroadcastArea* pEOUpdateChain; + + inline USHORT ComputeSlotOffset( const ScAddress& rAddress ) const; + void ComputeAreaPoints( const ScRange& rRange, + USHORT& nStart, USHORT& nEnd, + USHORT& nRowBreak ) const; + +public: + ScBroadcastAreaSlotMachine( ScDocument* pDoc ); + ~ScBroadcastAreaSlotMachine(); + void StartListeningArea( const ScRange& rRange, + SfxListener* pListener ); + void EndListeningArea( const ScRange& rRange, + SfxListener* pListener ); + BOOL AreaBroadcast( const ScHint& rHint ) const; + // return: mindestens ein Broadcast gewesen + BOOL AreaBroadcastInRange( const ScRange& rRange, const ScHint& rHint ) const; +/*N*/ void DelBroadcastAreasInRange( const ScRange& rRange ); + inline ScBroadcastArea* GetUpdateChain() const { return pUpdateChain; } + inline void SetUpdateChain( ScBroadcastArea* p ) { pUpdateChain = p; } + inline ScBroadcastArea* GetEOUpdateChain() const { return pEOUpdateChain; } + inline void SetEOUpdateChain( ScBroadcastArea* p ) { pEOUpdateChain = p; } +}; + + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/ddelink.hxx b/binfilter/bf_sc/source/core/inc/ddelink.hxx new file mode 100644 index 000000000000..54cafbfa67d9 --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/ddelink.hxx @@ -0,0 +1,91 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_DDELINK_HXX +#define SC_DDELINK_HXX + +#include <bf_so3/lnkbase.hxx> +#include <bf_svtools/brdcst.hxx> +namespace binfilter { + +class ScDocument; +class ScMatrix; +class ScMultipleReadHeader; +class ScMultipleWriteHeader; + +class ScDdeLink : public ::binfilter::SvBaseLink, public SfxBroadcaster +{ +private: +static BOOL bIsInUpdate; + + ScDocument* pDoc; + + String aAppl; // Verbindungsdaten + String aTopic; + String aItem; + BYTE nMode; // Zahlformat-Modus + + BOOL bNeedUpdate; // wird gesetzt, wenn Update nicht moeglich war + + ScMatrix* pResult; // Ergebnis + +public: + TYPEINFO(); + + ScDdeLink( ScDocument* pD, + const String& rA, const String& rT, const String& rI, + BYTE nM ); + ScDdeLink( ScDocument* pD, SvStream& rStream, ScMultipleReadHeader& rHdr ); + virtual ~ScDdeLink(); + + void Store( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const; + + // von SvBaseLink ueberladen: + virtual void DataChanged( const String& rMimeType, + const ::com::sun::star::uno::Any & rValue ); + + // von SfxBroadcaster ueberladen: + + // fuer Interpreter: + + const ScMatrix* GetResult() const { return pResult; } + ScMatrix* GetResult() {return pResult; } + + const String& GetAppl() const { return aAppl; } + const String& GetTopic() const { return aTopic; } + const String& GetItem() const { return aItem; } + BYTE GetMode() const { return nMode; } + + void TryUpdate(); +}; + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/interpre.hxx b/binfilter/bf_sc/source/core/inc/interpre.hxx new file mode 100644 index 000000000000..cc11ccc3d5ec --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/interpre.hxx @@ -0,0 +1,723 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_INTERPRE_HXX +#define SC_INTERPRE_HXX + +#define SC_SPEW_ENABLED 0 + +#include <math.h> + +#include <rtl/math.hxx> + +#include "compiler.hxx" +#include "cell.hxx" +#include "scdll.hxx" +#include "document.hxx" + +#if SC_SPEW_ENABLED +#include "scspew.hxx" +#endif +class SbxVariable; +namespace binfilter { + +class SvNumberFormatter; +class ScDocument; +class ScMatrix; +class ScBaseCell; +class ScFormulaCell; + +#define MAX_ANZ_MAT 150 + // Maximale Anzahl fuer Zwischenergebnis + // Matrizen + // Maximum ca. 85 wird bei Invertierung + // von 128 x 128 benoetigt! + + +#ifndef MSC + #include <setjmp.h> +#else + extern "C" + { + #define _JBLEN 9 /* bp, di, si, sp, ret addr, ds */ + typedef int jmp_buf[_JBLEN]; + #define _JMP_BUF_DEFINED + #define setjmp _setjmp + int __cdecl _setjmp(jmp_buf); + void __cdecl longjmp(jmp_buf, int); + }; +#endif + + +struct ScCompare +{ + double nVal[2]; + String* pVal[2]; + BOOL bVal[2]; + BOOL bEmpty[2]; + ScCompare( String* p1, String* p2 ) + { + pVal[ 0 ] = p1; + pVal[ 1 ] = p2; + bEmpty[0] = FALSE; + bEmpty[1] = FALSE; + } +}; + +class ScToken; + +#define MAXSTACK (4096 / sizeof(ScToken*)) + +class ScTokenStack +{ +public: + DECL_FIXEDMEMPOOL_NEWDEL( ScTokenStack ) + ScToken* pPointer[ MAXSTACK ]; +}; + +class ScErrorStack +{ +public: + DECL_FIXEDMEMPOOL_NEWDEL( ScErrorStack ) + USHORT pPointer[ MAXSTACK ]; +}; + +enum ScIterFunc { + ifSUM, // Aufsummieren + ifSUMSQ, // Quadratsummen + ifPRODUCT, // Multiplizieren + ifAVERAGE, // Durchschnitt + ifCOUNT, // Anzahl Werte + ifCOUNT2, // Anzahl Werte (nichtleer) + ifMIN, // Minimum + ifMAX // Maximum +}; + +class ScInterpreter +{ + // distibution function objects need the GetxxxDist methods + friend class ScGammaDistFunction; + friend class ScBetaDistFunction; + friend class ScTDistFunction; + friend class ScFDistFunction; + friend class ScChiDistFunction; + +public: + DECL_FIXEDMEMPOOL_NEWDEL( ScInterpreter ) + static USHORT nGlobalError; // globale Fehlervariable +#if SC_SPEW_ENABLED + static ScSpew theSpew; +#endif + + static void GlobalExit(); // aus ScGlobal::Clear() gerufen + + /// Could string be a regular expression? + /// If pDoc!=NULL the document options are taken into account and if + /// RegularExpressions are disabled the function returns FALSE regardless + /// of the string content. + static BOOL MayBeRegExp( const String& rStr, const ScDocument* pDoc ); + +private: + static ScTokenStack* pGlobalStack; + static ScErrorStack* pGlobalErrorStack; + static BOOL bGlobalStackInUse; + + ScTokenIterator aCode; + ScAddress aPos; + ScTokenArray& rArr; + String aResult; + ScDocument* pDok; // Pointer aufs Dokument + double nResult; + ScMatrix* pResult; + ScFormulaCell* pMyFormulaCell; // die Zelle mit der Formel + SvNumberFormatter* pFormatter; + StackVar eResult; + + USHORT nGlobError; // lokale Kopie + const ScToken* pCur; // aktuelles Token + String aTempStr; // fuer GetString() + ScTokenStack* pStackObj; // enthaelt den Stack + ScToken** pStack; // der Stack + ScErrorStack* pErrorStackObj; // enthaelt den ErrorStack + USHORT* pErrorStack; // der ErrorStack + USHORT sp; // der Stackpointer + USHORT maxsp; // der maximale StackPointer + double** ppGlobSortArray; // Pointer auf Array zum Sortieren + ScMatrix** ppTempMatArray; // Array fuer temporaere Matrizen + USHORT nMatCount; // dazugehoeriger Zaehler + BOOL bMatDel; // und Kontrollvariable + USHORT nRetMat; // Index der Return-Matrix + ULONG nFuncFmtIndex; // NumberFormatIndex einer Funktion + ULONG nCurFmtIndex; // aktueller NumberFormatIndex + ULONG nRetFmtIndex; // ggbf. NumberFormatIndex des Ausdrucks + short nFuncFmtType; // NumberFormatTyp einer Funktion + short nCurFmtType; // aktueller NumberFormatTyp + short nRetFmtType; // NumberFormatTyp des Ausdrucks + BOOL glSubTotal; // Flag fuer Subtotalfunktionen + BYTE cPar; // aktuelle Anzahl Parameter + BOOL bCalcAsShown; // Genauigkeit wie angezeigt + BOOL bMatrixFormula; // Formelzelle ist Matrixformel + +//---------------------------------Funktionen in interpre.cxx--------- +// nMust <= nAct <= nMax ? ok : SetError, PushInt +inline BOOL MustHaveParamCount( BYTE nAct, BYTE nMust ); +inline BOOL MustHaveParamCount( BYTE nAct, BYTE nMust, BYTE nMax ); +inline BOOL MustHaveParamCountMin( BYTE nAct, BYTE nMin ); +void SetParameterExpected(); +void SetIllegalParameter(); +void SetIllegalArgument(); +void SetNoValue(); +void SetNV(); +//------------------------------------------------------------------------- +// Funktionen für den Zugriff auf das Document +//------------------------------------------------------------------------- +void ReplaceCell( ScAddress& ); // for TableOp +void ReplaceCell( USHORT& rCol, USHORT& rRow, USHORT& rTab ); // for TableOp +BOOL IsTableOpInRange( const ScRange& ); +ULONG GetCellNumberFormat( const ScAddress&, const ScBaseCell* ); +double GetCellValue( const ScAddress&, const ScBaseCell* ); +double GetCellValueOrZero( const ScAddress&, const ScBaseCell* ); +double GetValueCellValue( const ScAddress&, const ScValueCell* ); +ScBaseCell* GetCell( const ScAddress& rPos ) + { return pDok->GetCell( rPos ); } +void GetCellString( String& rStr, const ScBaseCell* pCell ); +USHORT GetCellErrCode( const ScBaseCell* pCell ); +inline CellType GetCellType( const ScBaseCell* pCell ) + { return pCell ? pCell->GetCellType() : CELLTYPE_NONE; } +inline BOOL HasCellValueData( const ScBaseCell* pCell ) + { return pCell ? pCell->HasValueData() : FALSE; } +inline BOOL HasCellStringData( const ScBaseCell* pCell ) + { return pCell ? pCell->HasStringData() : FALSE; } +BOOL CreateDoubleArr(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, BYTE* pCellArr); +BOOL CreateStringArr(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, BYTE* pCellArr); +BOOL CreateCellArr(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, BYTE* pCellArr); +//----------------------------------------------------------------------------- +// Stackoperationen +//----------------------------------------------------------------------------- +void Push( ScToken& r ); +void PushTempToken( const ScToken& ); +void PushTempToken( ScToken* ); //! see warnings in interpr4.cxx +void Pop(); +void PopError(); +BYTE PopByte(); +double PopDouble(); +const String& PopString(); +void PopSingleRef( ScAddress& ); +void PopSingleRef(USHORT& rCol, USHORT &rRow, USHORT& rTab); +void PopDoubleRef( ScRange&, BOOL bDontCheckForTableOp = FALSE ); +void PopDoubleRef(USHORT& rCol1, USHORT &rRow1, USHORT& rTab1, + USHORT& rCol2, USHORT &rRow2, USHORT& rTab2, + BOOL bDontCheckForTableOp = FALSE ); +BOOL PopDoubleRefOrSingleRef( ScAddress& rAdr ); +void PopDoubleRefPushMatrix(); +inline void MatrixDoubleRefToMatrix(); // wenn MatrixFormula: PopDoubleRefPushMatrix +ScMatrix* PopMatrix(); +//void PushByte(BYTE nVal); +void PushDouble(double nVal); +void PushInt( int nVal ); +void PushStringBuffer( const sal_Unicode* pString ); +void PushString( const String& rString ); +void PushSingleRef(USHORT nCol, USHORT nRow, USHORT nTab); +void PushDoubleRef(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2); +void PushMatrix(ScMatrix* pMat); +StackVar GetStackType(); +// peek StackType of Parameter, Parameter 1 == TOS, 2 == TOS-1, ... +StackVar GetStackType( BYTE nParam ); +BYTE GetByte() { return cPar; } +/* +short GetShort(); +double GetLong(); +*/ +// generiert aus DoubleRef positionsabhaengige SingleRef +BOOL DoubleRefToPosSingleRef( const ScRange& rRange, ScAddress& rAdr ); +double GetDouble(); +BOOL GetBool() { return GetDouble() != 0.0; } +const String& GetString(); +ScMatrix* GetMatrix(USHORT& nMatInd); // in interpr2.cxx +void ScTableOp(); // Mehrfachoperatione; +void ScErrCell(); // Sonderbehandlung + +//-----------------------------allgemeine Hilfsfunktionen +void SetMaxIterationCount(USHORT n); +inline void CurFmtToFuncFmt() + { nFuncFmtType = nCurFmtType; nFuncFmtIndex = nCurFmtIndex; } +// Check for String overflow of rResult+rAdd and set error and erase rResult +// if so. Return TRUE if ok, FALSE if overflow +inline BOOL CheckStringResultLen( String& rResult, const String& rAdd ); +//---------------------------------Funktionen in interpr1.cxx--------- +//-----------------------------Textfunktionen +void ScIfJump(); +void ScChoseJump(); +short CompareFunc( const ScCompare& rComp ); +short Compare(); +ScMatrix* CompareMat(); +void ScEqual(); +void ScNotEqual(); +void ScLess(); +void ScGreater(); +void ScLessEqual(); +void ScGreaterEqual(); +void ScAnd(); +void ScOr(); +void ScNot(); +void ScNeg(); +void ScPercentSign(); +void ScIntersect(); +void ScPi(); +void ScRandom(); +void ScTrue(); +void ScFalse(); +void ScDeg(); +void ScRad(); +void ScSin(); +void ScCos(); +void ScTan(); +void ScCot(); +void ScArcSin(); +void ScArcCos(); +void ScArcTan(); +void ScArcCot(); +void ScSinHyp(); +void ScCosHyp(); +void ScTanHyp(); +void ScCotHyp(); +void ScArcSinHyp(); +void ScArcCosHyp(); +void ScArcTanHyp(); +void ScArcCotHyp(); +void ScExp(); +void ScLn(); +void ScLog10(); +void ScSqrt(); +void ScIsEmpty(); +short IsString(); +void ScIsString(); +void ScIsNonString(); +void ScIsLogical(UINT16 aOldNumType); +void ScType(); +void ScCell(); +void ScIsRef(); +void ScIsValue(); +void ScIsFormula(); +void ScFormula(); +void ScRoman(); +void ScArabic(); +void ScIsNV(); +void ScIsErr(); +void ScIsError(); +short IsEven(); +void ScIsEven(); +void ScIsOdd(); +void ScN(); +void ScCode(); +void ScTrim(); +void ScUpper(); +void ScPropper(); +void ScLower(); +void ScLen(); +void ScT(); +void ScValue(); +void ScClean(); +void ScChar(); +void ScMin( BOOL bTextAsZero = FALSE ); +void ScMax( BOOL bTextAsZero = FALSE ); +double IterateParameters( ScIterFunc, BOOL bTextAsZero = FALSE ); +void ScSumSQ(); +void ScSum(); +void ScProduct(); +void ScAverage( BOOL bTextAsZero = FALSE ); +void ScCount(); +void ScCount2(); +void GetStVarParams( double& rVal, double& rValCount, BOOL bTextAsZero = FALSE ); +void ScVar( BOOL bTextAsZero = FALSE ); +void ScVarP( BOOL bTextAsZero = FALSE ); +void ScStDev( BOOL bTextAsZero = FALSE ); +void ScStDevP( BOOL bTextAsZero = FALSE ); +void ScColumns(); +void ScRows(); +void ScTables(); +void ScColumn(); +void ScRow(); +void ScTable(); +void ScMatch(); +void ScCountIf(); +void ScSumIf(); +void ScCountEmptyCells(); +void ScLookup(); +void ScHLookup(); +void ScVLookup(); +void ScSubTotal(); + +// If upon call rMissingField==TRUE then the database field parameter may be +// missing (Xcl DCOUNT() syntax), or may be faked as missing by having the +// value 0.0 or being exactly the entire database range reference (old SO +// compatibility). If this was the case then rMissingField is set to TRUE upon +// return. If rMissingField==FALSE upon call all "missing cases" are considered +// to be an error. +BOOL GetDBParams( USHORT& rTab, ScQueryParam& rParam, BOOL& rMissingField ); + +void DBIterator( ScIterFunc ); +void ScDBSum(); +void ScDBCount(); +void ScDBCount2(); +void ScDBAverage(); +void ScDBGet(); +void ScDBMax(); +void ScDBMin(); +void ScDBProduct(); +void GetDBStVarParams( double& rVal, double& rValCount ); +void ScDBStdDev(); +void ScDBStdDevP(); +void ScDBVar(); +void ScDBVarP(); +void ScIndirect(); +void ScAdress(); +void ScOffset(); +void ScIndex(); +void ScMultiArea(); +void ScAreas(); +void ScCurrency(); +void ScReplace(); +void ScFixed(); +void ScFind(); +void ScExact(); +void ScLeft(); +void ScRight(); +void ScSearch(); +void ScMid(); +void ScText(); +void ScSubstitute(); +void ScRept(); +void ScConcat(); +void ScExternal(); +void ScMissing(); +void ScMacro(); +BOOL SetSbxVariable( SbxVariable* pVar, const ScAddress& ); +BOOL SetSbxVariable( SbxVariable* pVar, USHORT nCol, USHORT nRow, USHORT nTab ); +void ScErrorType(); +void ScDBArea(); +void ScColRowNameAuto(); +void ScCalcTeam(); +void ScAnswer(); +void ScTTT(); +void ScSpewFunc(); +void ScGame(){DBG_BF_ASSERT(0, "STRIP");} //STRIP001 void ScGame(); + +//----------------Funktionen in interpr2.cxx--------------- +double GetDate(INT16 nYear, INT16 nMonth, INT16 nDay); +void ScGetActDate(); +void ScGetActTime(); +void ScGetYear(); +void ScGetMonth(); +void ScGetDay(); +void ScGetDayOfWeek(); +void ScGetWeekOfYear(); +void ScEasterSunday(); +void ScGetHour(); +void ScGetMin(); +void ScGetSec(); +void ScPlusMinus(); +void ScAbs(); +void ScInt(); +void ScEven(); +void ScOdd(); +void ScCeil(); +void ScFloor(); +void RoundNumber( rtl_math_RoundingMode eMode ); +void ScRound(); +void ScRoundUp(); +void ScRoundDown(); +void ScGetDateValue(); +void ScGetTimeValue(); +void ScArcTan2(); +void ScLog(); +void ScGetDate(); +void ScGetTime(); +void ScGetDiffDate(); +void ScGetDiffDate360(); +void ScPower(); +void ScAmpersand(); +void ScAdd(); +void ScSub(); +void ScMul(); +void ScDiv(); +void ScPow(); +void ScCurrent(); +void ScStyle(); +void ScDde(); +void ScBase(); +void ScDecimal(); +void ScConvert(); + +//----------------------- Finanzfunktionen ------------------------------------ +void ScNBW(); +void ScIKV(); +void ScMIRR(); +void ScISPMT(); + +double ScGetBw(double fZins, double fZzr, double fRmz, + double fZw, double fF); +void ScBW(); +void ScDIA(); +double ScGetGDA(double fWert, double fRest, double fDauer, + double fPeriode, double fFaktor); +void ScGDA(); +void ScGDA2(); +double ScInterVDB(double fWert,double fRest,double fDauer,double fDauer1, + double fPeriode,double fFaktor); +void ScVDB(); +void ScLaufz(); +void ScLIA(); +double ScGetRmz(double fZins, double fZzr, double fBw, + double fZw, double fF); +void ScRMZ(); +void ScZGZ(); +double ScGetZw(double fZins, double fZzr, double fRmz, + double fBw, double fF); +void ScZW(); +void ScZZR(); +double GetZinsIterationEps(double fZzr, double fRmz, double fBw, double fZw, + double fF, double& fSchaetzwert); +void ScZins(); +double ScGetZinsZ(double fZins, double fZr, double fZzr, double fBw, + double fZw, double fF, double& fRmz); +void ScZinsZ(); +void ScKapz(); +void ScKumZinsZ(); +void ScKumKapZ(); +void ScEffektiv(); +void ScNominal(); +void ScMod(); +void ScBackSolver(); +void ScIntercept(); +//-------------------------Funktionen in interpr5.cxx-------------------------- +double ScGetGGT(double fx, double fy); +void ScGGT(); +void ScKGV(); +//-------------------------- Matrixfunktionen --------------------------------- +ScMatrix* GetNewMat(USHORT nC, USHORT nR, USHORT& nMatInd); +void ResetNewMat(USHORT nIndex); +void ScMatValue(); +void MEMat(ScMatrix* mM, USHORT n); +void MFastMult(ScMatrix* pA, ScMatrix* pB, ScMatrix* pR, USHORT n, USHORT m, USHORT l); +void MFastSub(ScMatrix* pA, ScMatrix* pB, ScMatrix* pR, USHORT n, USHORT m); +void MFastTrans(ScMatrix* pA, ScMatrix* pR, USHORT n, USHORT m); +BOOL MFastBackSubst(ScMatrix* pA, ScMatrix* pR, USHORT n, BOOL bIsUpper); +BOOL ScMatLUP(ScMatrix* mA, USHORT m, USHORT p, + ScMatrix* mL, ScMatrix* mU, ScMatrix* mP, + ULONG& rPermutCounter, BOOL& bIsInvertable); +void ScMatDet(); +void ScMatInv(); +void ScMatMult(); +void ScMatTrans(); +void ScEMat(); +void ScMatRef(); +ScMatrix* MatAdd(ScMatrix* pMat1, ScMatrix* pMat2); +ScMatrix* MatSub(ScMatrix* pMat1, ScMatrix* pMat2); +ScMatrix* MatMul(ScMatrix* pMat1, ScMatrix* pMat2); +ScMatrix* MatDiv(ScMatrix* pMat1, ScMatrix* pMat2); +ScMatrix* MatPow(ScMatrix* pMat1, ScMatrix* pMat2); +ScMatrix* MatConcat(ScMatrix* pMat1, ScMatrix* pMat2); +void ScSumProduct(); +void ScSumX2MY2(); +void ScSumX2DY2(); +void ScSumXMY2(); +void ScGrowth(); +// multiple Regression: Varianzen der Koeffizienten +BOOL RGetVariances( ScMatrix* pV, ScMatrix* pX, USHORT nC, USHORT nR, + BOOL bSwapColRow, BOOL bZeroConstant ); +void ScRGP(); +void ScRKP(); +void ScForecast(); +//-------------------------------------------------------------------------------- +// Funktionen in interpr3.cxx +// Statistik: +void ScNoName(); +double phi(double x); +double taylor(double* pPolynom, USHORT nMax, double x); +double gauss(double x); +double gaussinv(double x); +double GetGammaDist(double x, double alpha, double beta); +double GetBetaDist(double x, double alpha, double beta); +double GetChiDist(double fChi, double fDF); +double GetFDist(double x, double fF1, double fF2); +double GetTDist(double T, double fDF); +double Fakultaet(double x); +double BinomKoeff(double n, double k); +double GammaHelp(double& x, BOOL& bReflect); +double GetGamma(double x); +double GetLogGamma(double x); +void ScLogGamma(); +void ScPhi(); +void ScGauss(); +void ScStdNormDist(); +void ScFisher(); +void ScFisherInv(); +void ScFact(); +void ScNormDist(); +void ScGammaDist(); +void ScGammaInv(); +void ScExpDist(); +void ScBinomDist(); +void ScPoissonDist(); +void ScKombin(); +void ScKombin2(); +void ScVariationen(); +void ScVariationen2(); +void ScB(); +void ScHypGeomDist(); +void ScLogNormDist(); +void ScLogNormInv(); +void ScTDist(); +void ScFDist(); +void ScChiDist(); +void ScWeibull(); +void ScBetaDist(); +void ScFInv(); +void ScTInv(); +void ScChiInv(); +void ScBetaInv(); +void ScCritBinom(); +void ScNegBinomDist(); +void ScKurt(); +void ScHarMean(); +void ScGeoMean(); +void ScStandard(); +void ScSkew(); +void ScMedian(); +void GetSortArray(BYTE nParamCount, double** ppSortArray, ULONG& nSize); +void QuickSort(long nLo, long nHi, double* pSortArr); +void ScModalValue(); +void ScAveDev(); +void ScDevSq(); +void ScZTest(); +void ScTTest(); +void ScFTest(); +void ScChiTest(); +void ScRank(); +void ScPercentile(); +void ScPercentrank(); +void ScLarge(); +void ScSmall(); +void ScFrequency(); +void ScQuartile(); +void ScNormInv(); +void ScSNormInv(); +void ScConfidence(); +void ScTrimMean(); +void ScProbability(); +void ScCorrel(); +void ScCovar(); +void ScPearson(); +void ScRSQ(); +void ScSTEXY(); +void ScSlope(); +void ScTrend(); + + +public: + ScInterpreter( ScFormulaCell* pCell, ScDocument* pDoc, + const ScAddress&, ScTokenArray& ); + ~ScInterpreter(); + + StackVar Interpret(); + + static void SetError(USHORT nError) + { if (nError && !nGlobalError) nGlobalError = nError; } + + static USHORT GetError() { return nGlobalError; } + + const String& GetStringResult() { return aResult; } + double GetNumResult() { return nResult; } + ScMatrix* GetMatrixResult() { return pResult; } + StackVar GetResultType() { return eResult; } + short GetRetFormatType() { return nRetFmtType; } + ULONG GetRetFormatIndex() { return nRetFmtIndex; } + BOOL HadMatrix() const { return bMatDel; } +}; + + +inline void ScInterpreter::MatrixDoubleRefToMatrix() +{ + if ( bMatrixFormula && GetStackType() == svDoubleRef ) + PopDoubleRefPushMatrix(); +} + + +inline BOOL ScInterpreter::MustHaveParamCount( BYTE nAct, BYTE nMust ) +{ + if ( nAct == nMust ) + return TRUE; + if ( nAct < nMust ) + SetParameterExpected(); + else + SetIllegalParameter(); + return FALSE; +} + + +inline BOOL ScInterpreter::MustHaveParamCount( BYTE nAct, BYTE nMust, BYTE nMax ) +{ + if ( nMust <= nAct && nAct <= nMax ) + return TRUE; + if ( nAct < nMust ) + SetParameterExpected(); + else + SetIllegalParameter(); + return FALSE; +} + + +inline BOOL ScInterpreter::MustHaveParamCountMin( BYTE nAct, BYTE nMin ) +{ + if ( nAct >= nMin ) + return TRUE; + SetParameterExpected(); + return FALSE; +} + + +inline BOOL ScInterpreter::CheckStringResultLen( String& rResult, const String& rAdd ) +{ + if ( (ULONG) rResult.Len() + rAdd.Len() > STRING_MAXLEN ) + { + SetError( errStringOverflow ); + rResult.Erase(); + return FALSE; + } + return TRUE; +} + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/poolhelp.hxx b/binfilter/bf_sc/source/core/inc/poolhelp.hxx new file mode 100644 index 000000000000..20d30254e922 --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/poolhelp.hxx @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_POOLHELP_HXX +#define SC_POOLHELP_HXX + +#include <salhelper/simplereferenceobject.hxx> + +namespace binfilter { + +class SvNumberFormatter; +class SfxItemPool; +class ScDocument; +class ScDocumentPool; +class ScStyleSheetPool; + + +class ScPoolHelper : public salhelper::SimpleReferenceObject +{ +private: + ScDocumentPool* pDocPool; + ScStyleSheetPool* pStylePool; + SvNumberFormatter* pFormTable; + SfxItemPool* pEditPool; // EditTextObjectPool + SfxItemPool* pEnginePool; // EditEnginePool + +public: + ScPoolHelper( ScDocument* pSourceDoc ); + virtual ~ScPoolHelper(); + + // called in dtor of main document + void SourceDocumentGone(); + + // access to pointers (are never 0): + ScDocumentPool* GetDocPool() const { return pDocPool; } + ScStyleSheetPool* GetStylePool() const { return pStylePool; } + SvNumberFormatter* GetFormTable() const { return pFormTable; } + SfxItemPool* GetEditPool() const { return pEditPool; } + SfxItemPool* GetEnginePool() const { return pEnginePool; } +}; + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/refupdat.hxx b/binfilter/bf_sc/source/core/inc/refupdat.hxx new file mode 100644 index 000000000000..46324660039c --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/refupdat.hxx @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_REFUPDAT_HXX +#define SC_REFUPDAT_HXX + +#include "global.hxx" +namespace binfilter { + +class ScDocument; +class ScBigRange; +struct ComplRefData; + +enum ScRefUpdateRes { + UR_NOTHING = 0, // keine Anpassungen + UR_UPDATED = 1, // Anpassungen erfolgt + UR_INVALID = 2 // Referenz wurde ungueltig +}; + +class ScRefUpdate +{ +public: + static ScRefUpdateRes Update + ( ScDocument* pDoc, UpdateRefMode eUpdateRefMode, + USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, + short nDx, short nDy, short nDz, + USHORT& theCol1, USHORT& theRow1, USHORT& theTab1, + USHORT& theCol2, USHORT& theRow2, USHORT& theTab2 ); + + static ScRefUpdateRes Update( UpdateRefMode eUpdateRefMode, + const ScBigRange& rWhere, + INT32 nDx, INT32 nDy, INT32 nDz, + ScBigRange& rWhat ); + + static ScRefUpdateRes Update( ScDocument* pDoc, + UpdateRefMode eUpdateRefMode, + const ScAddress& rPos, const ScRange& rRange, + short nDx, short nDy, short nDz, + ComplRefData& rRef ); + static ScRefUpdateRes Move( ScDocument* pDoc, const ScAddress& rPos, + short nDx, short nDy, short nDz, + ComplRefData& rRef, BOOL bWrap, BOOL bAbsolute ); + static void MoveRelWrap( ScDocument* pDoc, const ScAddress& rPos, + ComplRefData& rRef ); +}; + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/scmatrix.hxx b/binfilter/bf_sc/source/core/inc/scmatrix.hxx new file mode 100644 index 000000000000..9155d8badd8d --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/scmatrix.hxx @@ -0,0 +1,184 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_MATRIX_HXX +#define SC_MATRIX_HXX + +#include "global.hxx" + +#include <tools/string.hxx> +class SvStream; +namespace binfilter { + +#define SC_MATVAL_STRING 0x01 +#define SC_MATVAL_EMPTY 0x03 // EMPTY is empty string plus flag + +union MatValue +{ + double fVal; + String* pS; + + /// Only valid if ScMatrix methods indicate so! + const String& GetString() const { return pS ? *pS : EMPTY_STRING; } +}; + +/** Matrix representation of double values and strings. + + @ATTENTION: optimized for speed and double values. + + Matrix elements are not initialized after construction. + + All methods using an ULONG nIndex parameter and all Is... methods don't + check the range for validity! However, the Put... and Get... methods using + USHORT nCol/nRow parameters do check the range. <p> + + GetString( ULONG nIndex ) does not check if there really is a string, do + this with IsString() first. GetString( USHORT nC, USHORT nR ) does check + it and returns and empty string if there is no string. Both GetDouble() + methods don't check for a string, do this with IsNumeric() or IsString() + or IsValue() first. <p> + + PutDouble() does not reset an eventual string! Use + PutDoubleAndResetString() if that is wanted. Also the FillDouble...() + methods don't reset strings. As a consequence memory leaks may occur if + used wrong. + */ +class ScMatrix +{ + USHORT nAnzCol; + USHORT nAnzRow; + MatValue* pMat; + BYTE* bIsString; + + void ResetIsString(); + void DeleteIsString(); + void CreateMatrix(USHORT nC, USHORT nR); + + // pStr may be NULL, bFlag MUST NOT be 0 + void PutStringEntry( const String* pStr, BYTE bFlag, ULONG nIndex ); + +public: + + /// The maximum number of elements a matrix may have at runtime + inline static ULONG GetElementsMax() + { + const size_t nMemMax = (((size_t)(~0))-64) / sizeof(MatValue); + const ULONG nArbitraryLimit = 0x80000; // 512k elements ~= 4MB memory + return nMemMax < nArbitraryLimit ? nMemMax : nArbitraryLimit; + } + + ScMatrix(USHORT nC, USHORT nR) { CreateMatrix(nC, nR); } + ~ScMatrix(); + ScMatrix* Clone() const; + BOOL HasMat() const { return pMat != NULL; } + + ScMatrix(SvStream& rStream); + void Store(SvStream& rStream) const; + + void GetDimensions(USHORT& rC, USHORT& rR) const { rC = nAnzCol; rR = nAnzRow; }; + ULONG GetElementCount() const { return (ULONG) nAnzCol * nAnzRow; } + void PutDouble(double fVal, USHORT nC, USHORT nR); + void PutDouble(double fVal, ULONG nIndex) { pMat[nIndex].fVal = fVal; } + void PutString(const String& rStr, USHORT nC, USHORT nR); + void PutString(const String& rStr, ULONG nIndex); + void PutEmpty(USHORT nC, USHORT nR); + void PutEmpty(ULONG nIndex); + void FillDouble( double fVal, USHORT nC1, USHORT nR1, USHORT nC2, USHORT nR2 ); + void FillDoubleLowerLeft( double fVal, USHORT nC2 ); // lower left triangle + /// @return 0.0 if empty + double GetDouble(USHORT nC, USHORT nR) const; + /// @return 0.0 if empty + double GetDouble(ULONG nIndex) const { return pMat[nIndex].fVal; } + const String& GetString(USHORT nC, USHORT nR) const; + const String& GetString(ULONG nIndex) const + { return pMat[nIndex].GetString(); } + + /// @ATTENTION: If bString the MatValue->pS may still be NULL to indicate + /// an empty string! + const MatValue* Get(USHORT nC, USHORT nR, BOOL& bString) const; + + /// @return <TRUE/> if string or empty + BOOL IsString( ULONG nIndex ) const + { return bIsString && bIsString[nIndex]; } + /// @return <TRUE/> if string or empty + BOOL IsString( USHORT nC, USHORT nR ) const + { return bIsString && bIsString[ (ULONG) nC * nAnzRow + nR ]; } + BOOL IsEmpty( ULONG nIndex ) const + { return bIsString && bIsString[nIndex] == SC_MATVAL_EMPTY; } + BOOL IsEmpty( USHORT nC, USHORT nR ) const + { return bIsString && bIsString[ (ULONG) nC * nAnzRow + nR ] == SC_MATVAL_EMPTY; } + BOOL IsValue( ULONG nIndex ) const + { return !bIsString || !bIsString[nIndex]; } + BOOL IsValue( USHORT nC, USHORT nR ) const + { return !bIsString || !bIsString[ (ULONG) nC * nAnzRow + nR ]; } + BOOL IsValueOrEmpty( ULONG nIndex ) const + { return !bIsString || !bIsString[nIndex] || bIsString[nIndex] == SC_MATVAL_EMPTY; } + BOOL IsValueOrEmpty( USHORT nC, USHORT nR ) const + { return !bIsString || !bIsString[ (ULONG) nC * nAnzRow + nR ] + || bIsString[ (ULONG) nC * nAnzRow + nR ] == SC_MATVAL_EMPTY; } + + /// @return <TRUE/> if entire matrix is numeric and no strings are contained + BOOL IsNumeric() const { return bIsString == NULL; } + + void MatTrans(ScMatrix& mRes) const; + void MatCopy (ScMatrix& mRes) const; + /// Copy upper left of this matrix to mRes matrix. + /// This matrix dimensions must be greater than mRes matrix dimensions. + + // Convert ScInterpreter::CompareMat values (-1,0,1) to boolean values + void CompareEqual(); + void CompareNotEqual(); + void CompareLess(); + void CompareGreater(); + void CompareLessEqual(); + void CompareGreaterEqual(); + + BOOL And(); // logical AND of all matrix values + BOOL Or(); // logical OR of all matrix values + + // All other matrix functions MatMult, MInv, ... are in ScInterpreter + // to be numerically safe. +}; + + +// Old values as used up to SO52. +// The overall elements count had to be <= SC_MAX_MAT_DIM * SC_MAX_MAT_DIM. +// Don't use except maybe for file format compatibility. +// In any other case use ScMatrix::GetElementsMax() instead. +#ifdef WIN +#define SC_OLD_MAX_MAT_DIM 64 +#else +#define SC_OLD_MAX_MAT_DIM 128 +#endif +#define SC_OLD_MAX_MAT_ELEMENTS ((SC_OLD_MAX_MAT_DIM) * (SC_OLD_MAX_MAT_DIM)) + + +} //namespace binfilter +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/inc/scrdata.hxx b/binfilter/bf_sc/source/core/inc/scrdata.hxx new file mode 100644 index 000000000000..92d8feef4eae --- /dev/null +++ b/binfilter/bf_sc/source/core/inc/scrdata.hxx @@ -0,0 +1,53 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef SC_SCRDATA_HXX +#define SC_SCRDATA_HXX + +#include <com/sun/star/uno/Reference.hxx> + +namespace com { namespace sun { namespace star { namespace i18n { + class XBreakIterator; +} } } } + +namespace binfilter { + +class ScScriptTypeData +{ +public: + ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XBreakIterator > xBreakIter; + + ScScriptTypeData() {} + ~ScScriptTypeData() {} +}; + +} //namespace binfilter +#endif + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/src/makefile.mk b/binfilter/bf_sc/source/core/src/makefile.mk new file mode 100644 index 000000000000..0b040b9a2161 --- /dev/null +++ b/binfilter/bf_sc/source/core/src/makefile.mk @@ -0,0 +1,50 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +EXTERNAL_WARNINGS_NOT_ERRORS := TRUE +PRJ=..$/..$/..$/.. +BFPRJ=..$/..$/.. + +PRJNAME=binfilter +TARGET=sc_core + +NO_HIDS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk +INC+= -I$(PRJ)$/inc$/bf_sc + +# --- Files -------------------------------------------------------- + +SRS1NAME=$(TARGET) +SRC1FILES = \ + sc_compiler.src +# --- Tagets ------------------------------------------------------- + +.INCLUDE : target.mk + diff --git a/binfilter/bf_sc/source/core/src/sc_compiler.src b/binfilter/bf_sc/source/core/src/sc_compiler.src new file mode 100644 index 000000000000..596e2d2f35dd --- /dev/null +++ b/binfilter/bf_sc/source/core/src/sc_compiler.src @@ -0,0 +1,7928 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#define NO_LOCALIZE_EXPORT +#include "bf_sc.hrc" // Definition RID_XXX +#include "compiler.hrc" // Definition SC_OPCODE_XXX (interne OpCodes) + +Resource RID_SC_FUNCTION_NAMES +{ + String SC_OPCODE_IF + { + Text [ de ] = "WENN" ; + Text [ en-US ] = "IF" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SE"; + Text[ ru ] = "ЕСЛИ"; + Text[ el ] = "IF"; + Text[ nl ] = "ALS"; + Text[ fr ] = "SI"; + Text[ es ] = "SI"; + Text[ fi ] = "JOS"; + Text[ ca ] = "IF"; + Text[ it ] = "SE"; + Text[ da ] = "HVIS"; + Text[ sv ] = "OM"; + Text[ pl ] = "IF"; + Text[ pt-BR ] = "SE"; + Text[ th ] = "IF"; + Text[ ja ] = "IF"; + Text[ ko ] = "IF"; + Text[ zh-CN ] = "IF"; + Text[ zh-TW ] = "IF"; + Text[ tr ] = "EÄžER"; + Text[ hi-IN ] = "IF"; + Text[ ar ] = "IF"; + Text[ he ] = "WENN"; + }; + String SC_OPCODE_CHOSE + { + Text [ de ] = "WAHL" ; + Text [ en-US ] = "CHOOSE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SELECCIONAR"; + Text[ ru ] = "ВЫБОР"; + Text[ el ] = "CHOOSE"; + Text[ nl ] = "KIEZEN"; + Text[ fr ] = "CHOISIR"; + Text[ es ] = "ELEGIR"; + Text[ fi ] = "VALITSE_INDEKSI"; + Text[ ca ] = "CHOOSE"; + Text[ it ] = "SCEGLI"; + Text[ da ] = "VÆLG"; + Text[ sv ] = "VÄLJ"; + Text[ pl ] = "CHOOSE"; + Text[ pt-BR ] = "ESCOLHER"; + Text[ th ] = "CHOOSE"; + Text[ ja ] = "CHOOSE"; + Text[ ko ] = "CHOOSE"; + Text[ zh-CN ] = "CHOOSE"; + Text[ zh-TW ] = "CHOOSE"; + Text[ tr ] = "SEÇ"; + Text[ hi-IN ] = "CHOOSE"; + Text[ ar ] = "CHOOSE"; + Text[ he ] = "WAHL"; + }; + String SC_OPCODE_OPEN { Text = "(" ; }; + String SC_OPCODE_CLOSE { Text = ")" ; }; + String SC_OPCODE_SEP { Text = ";" ; }; + String SC_OPCODE_PERCENT_SIGN { Text = "%" ; }; + String SC_OPCODE_ADD { Text = "+" ; }; + String SC_OPCODE_SUB { Text = "-" ; }; + String SC_OPCODE_MUL { Text = "*" ; }; + String SC_OPCODE_DIV { Text = "/" ; }; + String SC_OPCODE_AMPERSAND { Text = "&" ; }; + String SC_OPCODE_POW { Text = "^" ; }; + String SC_OPCODE_EQUAL { Text = "=" ; }; + String SC_OPCODE_NOT_EQUAL { Text = "<>" ; }; + String SC_OPCODE_LESS { Text = "<" ; }; + String SC_OPCODE_GREATER { Text = ">" ; }; + String SC_OPCODE_LESS_EQUAL { Text = "<=" ; }; + String SC_OPCODE_GREATER_EQUAL { Text = ">=" ; }; + String SC_OPCODE_AND + { + Text [ de ] = "UND" ; + Text [ en-US ] = "AND" ; + Text [ x-comment ] = " "; + Text[ pt ] = "E"; + Text[ ru ] = "И"; + Text[ el ] = "KAI"; + Text[ nl ] = "EN"; + Text[ fr ] = "ET"; + Text[ es ] = "Y"; + Text[ fi ] = "JA"; + Text[ ca ] = "AND"; + Text[ it ] = "E"; + Text[ da ] = "OG"; + Text[ sv ] = "OCH"; + Text[ pl ] = "AND"; + Text[ pt-BR ] = "E"; + Text[ th ] = "à¹à¸¥à¸° "; + Text[ ja ] = "AND"; + Text[ ko ] = "AND"; + Text[ zh-CN ] = "AND"; + Text[ zh-TW ] = "AND"; + Text[ tr ] = "VE"; + Text[ hi-IN ] = "AND"; + Text[ ar ] = "AND"; + Text[ he ] = "UND"; + }; + String SC_OPCODE_OR + { + Text [ de ] = "ODER" ; + Text [ en-US ] = "OR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "OU"; + Text[ ru ] = "ИЛИ"; + Text[ el ] = "OR"; + Text[ nl ] = "OF"; + Text[ fr ] = "OU"; + Text[ es ] = "O"; + Text[ fi ] = "TAI"; + Text[ ca ] = "OR"; + Text[ it ] = "O"; + Text[ da ] = "ELLER"; + Text[ sv ] = "ELLER"; + Text[ pl ] = "OR"; + Text[ pt-BR ] = "OU"; + Text[ th ] = "หรืà¸"; + Text[ ja ] = "OR"; + Text[ ko ] = "OR"; + Text[ zh-CN ] = "OR"; + Text[ zh-TW ] = "OR"; + Text[ tr ] = "VEYA"; + Text[ hi-IN ] = "OR"; + Text[ ar ] = "OR"; + Text[ he ] = "ODER"; + }; + String SC_OPCODE_INTERSECT { Text = "!" ; }; + String SC_OPCODE_UNION { Text = ";" ; }; + String SC_OPCODE_RANGE { Text = ":" ; }; + String SC_OPCODE_NOT + { + Text [ de ] = "NICHT" ; + Text [ en-US ] = "NOT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NÃO"; + Text[ ru ] = "ÐЕ"; + Text[ el ] = "NOT"; + Text[ nl ] = "NIET"; + Text[ fr ] = "NON"; + Text[ es ] = "NO"; + Text[ fi ] = "EI"; + Text[ ca ] = "NOT"; + Text[ it ] = "NON"; + Text[ da ] = "IKKE"; + Text[ sv ] = "ICKE"; + Text[ pl ] = "NOT"; + Text[ pt-BR ] = "NÃO"; + Text[ th ] = "NOT"; + Text[ ja ] = "NOT"; + Text[ ko ] = "NOT"; + Text[ zh-CN ] = "NOT"; + Text[ zh-TW ] = "NOT"; + Text[ tr ] = "OLUMSUZ"; + Text[ hi-IN ] = "NOT"; + Text[ ar ] = "NOT"; + Text[ he ] = "NICHT"; + }; + String SC_OPCODE_NEG + { + Text [ de ] = "NEG"; + Text [ en-US ] = "NEG"; + Text[ pt ] = "NEG"; + Text[ ru ] = "NEG"; + Text[ el ] = "NEG"; + Text[ nl ] = "NEG"; + Text[ fr ] = "NEG"; + Text[ es ] = "NEG"; + Text[ fi ] = "NEG"; + Text[ ca ] = "NEG"; + Text[ it ] = "NEG"; + Text[ da ] = "NEG"; + Text[ sv ] = "NEG"; + Text[ pl ] = "NEG"; + Text[ pt-BR ] = "NEG"; + Text[ th ] = "NEG"; + Text[ ja ] = "NEG"; + Text[ ko ] = "NEG"; + Text[ zh-CN ] = "NEG"; + Text[ zh-TW ] = "NEG"; + Text[ tr ] = "NEG"; + Text[ hi-IN ] = "NEG"; + Text[ ar ] = "NEG"; + Text[ he ] = "NEG"; + }; + String SC_OPCODE_NEG_SUB { Text = "-" ; }; + String SC_OPCODE_PI + { + Text [ de ] = "PI" ; + // ??? + Text [ en-US ] = "PI" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PI"; + Text[ ru ] = "ПИ"; + Text[ el ] = "PI"; + Text[ nl ] = "PI"; + Text[ fr ] = "PI"; + Text[ es ] = "PI"; + Text[ fi ] = "Pii"; + Text[ ca ] = "PI"; + Text[ it ] = "PI.GRECO"; + Text[ da ] = "PI"; + Text[ sv ] = "PI"; + Text[ pl ] = "PI"; + Text[ pt-BR ] = "PI"; + Text[ th ] = "ไพ"; + Text[ ja ] = "PI"; + Text[ ko ] = "PI"; + Text[ zh-CN ] = "PI"; + Text[ zh-TW ] = "PI"; + Text[ tr ] = "PÄ°"; + Text[ hi-IN ] = "PI"; + Text[ ar ] = "PI"; + Text[ he ] = "PI"; + }; + String SC_OPCODE_RANDOM + { + Text [ de ] = "ZUFALLSZAHL" ; + Text [ en-US ] = "RAND" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ALEATÃ’RIO"; + Text[ ru ] = "СЛЧИС"; + Text[ el ] = "RAND"; + Text[ nl ] = "ASELECT"; + Text[ fr ] = "ALEA"; + Text[ es ] = "ALEATORIO"; + Text[ fi ] = "SATUNNAISLUKU"; + Text[ ca ] = "RAND"; + Text[ it ] = "CASUALE"; + Text[ da ] = "SLUMP"; + Text[ sv ] = "SLUMP"; + Text[ pl ] = "RAND"; + Text[ pt-BR ] = "ALEATÖRIO"; + Text[ th ] = "RAND"; + Text[ ja ] = "RAND"; + Text[ ko ] = "RAND"; + Text[ zh-CN ] = "RAND"; + Text[ zh-TW ] = "RAND"; + Text[ tr ] = "KENAR"; + Text[ hi-IN ] = "RAND"; + Text[ ar ] = "RAND"; + Text[ he ] = "ZUFALLSZAHL"; + }; + String SC_OPCODE_TRUE + { + Text [ de ] = "WAHR" ; + Text [ en-US ] = "TRUE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VERDADEIRO"; + Text[ ru ] = "ИСТИÐÐ"; + Text[ el ] = "TRUE"; + Text[ nl ] = "WAAR"; + Text[ fr ] = "VRAI"; + Text[ es ] = "VERDADERO"; + Text[ fi ] = "TOSI"; + Text[ ca ] = "TRUE"; + Text[ it ] = "VERO"; + Text[ da ] = "SAND"; + Text[ sv ] = "SANT"; + Text[ pl ] = "TRUE"; + Text[ pt-BR ] = "VERDADEIRO"; + Text[ th ] = "จริง"; + Text[ ja ] = "TRUE"; + Text[ ko ] = "TRUE"; + Text[ zh-CN ] = "TRUE"; + Text[ zh-TW ] = "TRUE"; + Text[ tr ] = "DOÄžRU"; + Text[ hi-IN ] = "TRUE"; + Text[ ar ] = "TRUE"; + Text[ he ] = "WAHR"; + }; + String SC_OPCODE_FALSE + { + Text [ de ] = "FALSCH" ; + Text [ en-US ] = "FALSE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FALSO"; + Text[ ru ] = "ЛОЖЬ"; + Text[ el ] = "FALSE"; + Text[ nl ] = "ONWAAR"; + Text[ fr ] = "FAUX"; + Text[ es ] = "FALSO"; + Text[ fi ] = "EPÄTOSI"; + Text[ ca ] = "FALSE"; + Text[ it ] = "FALSO"; + Text[ da ] = "FALSK"; + Text[ sv ] = "FALSKT"; + Text[ pl ] = "FALSE"; + Text[ pt-BR ] = "FALSO"; + Text[ th ] = "เท็จ"; + Text[ ja ] = "FALSE"; + Text[ ko ] = "FALSE"; + Text[ zh-CN ] = "FALSE"; + Text[ zh-TW ] = "FALSE"; + Text[ tr ] = "YANLIÅž"; + Text[ hi-IN ] = "FALSE"; + Text[ ar ] = "FALSE"; + Text[ he ] = "FALSCH"; + }; + String SC_OPCODE_GET_ACT_DATE + { + Text [ de ] = "HEUTE" ; + Text [ en-US ] = "TODAY" ; + Text [ x-comment ] = " "; + Text[ pt ] = "HOJE"; + Text[ ru ] = "СЕГОДÐЯ"; + Text[ el ] = "TODAY"; + Text[ nl ] = "VANDAAG"; + Text[ fr ] = "AUJOURDHUI"; + Text[ es ] = "HOY"; + Text[ fi ] = "TÄMÄ_PÄIVÄ"; + Text[ ca ] = "TODAY"; + Text[ it ] = "OGGI"; + Text[ da ] = "IDAG"; + Text[ sv ] = "IDAG"; + Text[ pl ] = "TODAY"; + Text[ pt-BR ] = "HOJE"; + Text[ th ] = "วันนี้"; + Text[ ja ] = "TODAY"; + Text[ ko ] = "TODAY"; + Text[ zh-CN ] = "TODAY"; + Text[ zh-TW ] = "TODAY"; + Text[ tr ] = "BUGÃœN"; + Text[ hi-IN ] = "TODAY"; + Text[ ar ] = "TODAY"; + Text[ he ] = "HEUTE"; + }; + String SC_OPCODE_GET_ACT_TIME + { + Text [ de ] = "JETZT" ; + Text [ en-US ] = "NOW" ; + Text [ x-comment ] = " "; + Text[ pt ] = "AGORA"; + Text[ ru ] = "СЕЙЧÐС"; + Text[ el ] = "NOW"; + Text[ nl ] = "NU"; + Text[ fr ] = "MAINTENANT"; + Text[ es ] = "AHORA"; + Text[ fi ] = "NYT"; + Text[ ca ] = "NOW"; + Text[ it ] = "ADESSO"; + Text[ da ] = "NU"; + Text[ sv ] = "NU"; + Text[ pl ] = "NOW"; + Text[ pt-BR ] = "AGORA"; + Text[ th ] = "NOW"; + Text[ ja ] = "NOW"; + Text[ ko ] = "NOW"; + Text[ zh-CN ] = "NOW"; + Text[ zh-TW ] = "NOW"; + Text[ tr ] = "ŞİMDÄ°"; + Text[ hi-IN ] = "NOW"; + Text[ ar ] = "NOW"; + Text[ he ] = "JETZT"; + }; + String SC_OPCODE_NO_VALUE + { + Text [ de ] = "NV" ; + Text [ en-US ] = "NA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NA"; + Text[ ru ] = "Ð/Д"; + Text[ el ] = "NA"; + Text[ nl ] = "NB"; + Text[ fr ] = "NA"; + Text[ es ] = "NOD"; + Text[ fi ] = "PUUTTUU"; + Text[ ca ] = "NA"; + Text[ it ] = "NON.DISP"; + Text[ da ] = "IKKE.TILGÆNGELIG"; + Text[ sv ] = "SAKNAS"; + Text[ pl ] = "NA"; + Text[ pt-BR ] = "NA"; + Text[ th ] = "NA"; + Text[ ja ] = "NA"; + Text[ ko ] = "NA"; + Text[ zh-CN ] = "NA"; + Text[ zh-TW ] = "NA"; + Text[ tr ] = "BULUNMAMAKTADIR"; + Text[ hi-IN ] = "NA"; + Text[ ar ] = "NA"; + Text[ he ] = "NV"; + }; + String SC_OPCODE_CURRENT + { + Text [ de ] = "AKTUELL" ; + Text [ en-US ] = "CURRENT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ACTUAL"; + Text[ ru ] = "ТЕКУЩ"; + Text[ el ] = "CURRENT"; + Text[ nl ] = "ACTUEEL"; + Text[ fr ] = "ACTUELLE"; + Text[ es ] = "ACTUAL"; + Text[ fi ] = "NYKYINEN"; + Text[ ca ] = "CURRENT"; + Text[ it ] = "ATTUALE"; + Text[ da ] = "AKTUEL"; + Text[ sv ] = "AKTUELL"; + Text[ pl ] = "CURRENT"; + Text[ pt-BR ] = "ATUAL"; + Text[ th ] = "CURRENT"; + Text[ ja ] = "CURRENT"; + Text[ ko ] = "CURRENT"; + Text[ zh-CN ] = "CURRENT"; + Text[ zh-TW ] = "CURRENT"; + Text[ tr ] = "MEVCUT"; + Text[ hi-IN ] = "CURRENT"; + Text[ ar ] = "CURRENT"; + Text[ he ] = "AKTUELL"; + }; + String SC_OPCODE_DEG + { + Text [ de ] = "DEG" ; + Text [ en-US ] = "DEGREES" ; + Text [ x-comment ] = " "; + Text[ pt ] = "GRAUS"; + Text[ ru ] = "ГРÐДУСЫ"; + Text[ el ] = "DEGREES"; + Text[ nl ] = "GRADEN"; + Text[ fr ] = "DEGRES"; + Text[ es ] = "GRADOS"; + Text[ fi ] = "ASTEET"; + Text[ ca ] = "DEGREES"; + Text[ it ] = "GRADI"; + Text[ da ] = "GRADER"; + Text[ sv ] = "GRADER"; + Text[ pl ] = "DEGREES"; + Text[ pt-BR ] = "GRAUS"; + Text[ th ] = "DEGREES"; + Text[ ja ] = "DEGREES"; + Text[ ko ] = "DEGREES"; + Text[ zh-CN ] = "DEGREES"; + Text[ zh-TW ] = "DEGREES"; + Text[ tr ] = "DEGREES"; + Text[ hi-IN ] = "DEGREES"; + Text[ ar ] = "DEGREES"; + Text[ he ] = "DEG"; + }; + String SC_OPCODE_RAD + { + Text [ de ] = "RAD" ; + Text [ en-US ] = "RADIANS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "RADIANOS"; + Text[ ru ] = "Ð ÐДИÐÐЫ"; + Text[ el ] = "RADIANS"; + Text[ nl ] = "RADIALEN"; + Text[ fr ] = "RADIANS"; + Text[ es ] = "RADIANES"; + Text[ fi ] = "RADIAANIT"; + Text[ ca ] = "RADIANS"; + Text[ it ] = "RADIANTI"; + Text[ da ] = "RADIANER"; + Text[ sv ] = "RADIANER"; + Text[ pl ] = "RADIANS"; + Text[ pt-BR ] = "RADIANOS"; + Text[ th ] = "RADIANS"; + Text[ ja ] = "RADIANS"; + Text[ ko ] = "RADIANS"; + Text[ zh-CN ] = "RADIANS"; + Text[ zh-TW ] = "RADIANS"; + Text[ tr ] = "RADYANLAR"; + Text[ hi-IN ] = "RADIANS"; + Text[ ar ] = "RADIANS"; + Text[ he ] = "RAD"; + }; + String SC_OPCODE_SIN + { + Text [ de ] = "SIN" ; + Text [ en-US ] = "SIN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SEN"; + Text[ ru ] = "SIN"; + Text[ el ] = "SIN"; + Text[ nl ] = "SIN"; + Text[ fr ] = "SIN"; + Text[ es ] = "SENO"; + Text[ fi ] = "SIN"; + Text[ ca ] = "SIN"; + Text[ it ] = "SEN"; + Text[ da ] = "SIN"; + Text[ sv ] = "SIN"; + Text[ pl ] = "SIN"; + Text[ pt-BR ] = "SEN"; + Text[ th ] = "SIN"; + Text[ ja ] = "SIN"; + Text[ ko ] = "SIN"; + Text[ zh-CN ] = "SIN"; + Text[ zh-TW ] = "SIN"; + Text[ tr ] = "SÄ°N"; + Text[ hi-IN ] = "SIN"; + Text[ ar ] = "SIN"; + Text[ he ] = "SIN"; + }; + String SC_OPCODE_COS + { + Text [ de ] = "COS"; + Text [ en-US ] = "COS"; + Text[ pt ] = "COS"; + Text[ ru ] = "COS"; + Text[ el ] = "COS"; + Text[ nl ] = "COS"; + Text[ fr ] = "COS"; + Text[ es ] = "COS"; + Text[ fi ] = "COS"; + Text[ ca ] = "COS"; + Text[ it ] = "COS"; + Text[ da ] = "COS"; + Text[ sv ] = "COS"; + Text[ pl ] = "COS"; + Text[ pt-BR ] = "COS"; + Text[ th ] = "COS"; + Text[ ja ] = "COS"; + Text[ ko ] = "COS"; + Text[ zh-CN ] = "COS"; + Text[ zh-TW ] = "COS"; + Text[ tr ] = "COS"; + Text[ hi-IN ] = "COS"; + Text[ ar ] = "COS"; + Text[ he ] = "COS"; + }; + String SC_OPCODE_TAN + { + Text [ de ] = "TAN"; + Text [ en-US ] = "TAN"; + Text[ pt ] = "TAN"; + Text[ ru ] = "TAN"; + Text[ el ] = "TAN"; + Text[ nl ] = "TAN"; + Text[ fr ] = "TAN"; + Text[ es ] = "TAN"; + Text[ fi ] = "TAN"; + Text[ ca ] = "TAN"; + Text[ it ] = "TAN"; + Text[ da ] = "TAN"; + Text[ sv ] = "TAN"; + Text[ pl ] = "TAN"; + Text[ pt-BR ] = "TAN"; + Text[ th ] = "TAN"; + Text[ ja ] = "TAN"; + Text[ ko ] = "TAN"; + Text[ zh-CN ] = "TAN"; + Text[ zh-TW ] = "TAN"; + Text[ tr ] = "TAN"; + Text[ hi-IN ] = "TAN"; + Text[ ar ] = "TAN"; + Text[ he ] = "TAN"; + }; + String SC_OPCODE_COT + { + Text [ de ] = "COT"; + Text [ en-US ] = "COT"; + Text[ pt ] = "COT"; + Text[ ru ] = "COT"; + Text[ el ] = "COT"; + Text[ nl ] = "COT"; + Text[ fr ] = "COT"; + Text[ es ] = "COT"; + Text[ fi ] = "COT"; + Text[ ca ] = "COT"; + Text[ it ] = "COT"; + Text[ da ] = "COT"; + Text[ sv ] = "COT"; + Text[ pl ] = "COT"; + Text[ pt-BR ] = "COT"; + Text[ th ] = "COT"; + Text[ ja ] = "COT"; + Text[ ko ] = "COT"; + Text[ zh-CN ] = "COT"; + Text[ zh-TW ] = "COT"; + Text[ tr ] = "COT"; + Text[ hi-IN ] = "COT"; + Text[ ar ] = "COT"; + Text[ he ] = "COT"; + }; + String SC_OPCODE_ARC_SIN + { + Text [ de ] = "ARCSIN" ; + Text [ en-US ] = "ASIN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ASEN"; + Text[ ru ] = "ASIN"; + Text[ el ] = "ASIN"; + Text[ nl ] = "BOOGSIN"; + Text[ fr ] = "ASIN"; + Text[ es ] = "ASENO"; + Text[ fi ] = "ASIN"; + Text[ ca ] = "ASIN"; + Text[ it ] = "ARCSEN"; + Text[ da ] = "ARCSIN"; + Text[ sv ] = "ARCSIN"; + Text[ pl ] = "ASIN"; + Text[ pt-BR ] = "ASEN"; + Text[ th ] = "ASIN"; + Text[ ja ] = "ASIN"; + Text[ ko ] = "ASIN"; + Text[ zh-CN ] = "ASIN"; + Text[ zh-TW ] = "ASIN"; + Text[ tr ] = "ASÄ°N"; + Text[ hi-IN ] = "ASIN"; + Text[ ar ] = "ASIN"; + Text[ he ] = "ARCSIN"; + }; + String SC_OPCODE_ARC_COS + { + Text [ de ] = "ARCCOS" ; + Text [ en-US ] = "ACOS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ACOS"; + Text[ ru ] = "ACOS"; + Text[ el ] = "ACOS"; + Text[ nl ] = "BOOGCOS"; + Text[ fr ] = "ACOS"; + Text[ es ] = "ACOS"; + Text[ fi ] = "ACOS"; + Text[ ca ] = "ACOS"; + Text[ it ] = "ARCCOS"; + Text[ da ] = "ARCCOS"; + Text[ sv ] = "ARCCOS"; + Text[ pl ] = "ACOS"; + Text[ pt-BR ] = "ACOS"; + Text[ th ] = "ACOS"; + Text[ ja ] = "ACOS"; + Text[ ko ] = "ACOS"; + Text[ zh-CN ] = "ACOS"; + Text[ zh-TW ] = "ACOS"; + Text[ tr ] = "ACOS"; + Text[ hi-IN ] = "ACOS"; + Text[ ar ] = "ACOS"; + Text[ he ] = "ARCCOS"; + }; + String SC_OPCODE_ARC_TAN + { + Text [ de ] = "ARCTAN" ; + Text [ en-US ] = "ATAN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ATAN"; + Text[ ru ] = "ATAN"; + Text[ el ] = "ATAN"; + Text[ nl ] = "BOOGTAN"; + Text[ fr ] = "ATAN"; + Text[ es ] = "ATAN"; + Text[ fi ] = "ATAN"; + Text[ ca ] = "ATAN"; + Text[ it ] = "ARCTAN"; + Text[ da ] = "ARCTAN"; + Text[ sv ] = "ARCTAN"; + Text[ pl ] = "ATAN"; + Text[ pt-BR ] = "ATAN"; + Text[ th ] = "ATAN"; + Text[ ja ] = "ATAN"; + Text[ ko ] = "ATAN"; + Text[ zh-CN ] = "ATAN"; + Text[ zh-TW ] = "ATAN"; + Text[ tr ] = "ATAN"; + Text[ hi-IN ] = "ATAN"; + Text[ ar ] = "ATAN"; + Text[ he ] = "ARCTAN"; + }; + String SC_OPCODE_ARC_COT + { + Text [ de ] = "ARCCOT" ; + Text [ en-US ] = "ACOT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ATAN"; + Text[ ru ] = "ACOT"; + Text[ el ] = "ACOT"; + Text[ nl ] = "BOOGCOT"; + Text[ fr ] = "ACOT"; + Text[ es ] = "ACOT"; + Text[ fi ] = "ACOT"; + Text[ ca ] = "ACOT"; + Text[ it ] = "ARCCOT"; + Text[ da ] = "ARCCOT"; + Text[ sv ] = "ARCCOT"; + Text[ pl ] = "ACOT"; + Text[ pt-BR ] = "ACOT"; + Text[ th ] = "ACOT"; + Text[ ja ] = "ACOT"; + Text[ ko ] = "ACOT"; + Text[ zh-CN ] = "ACOT"; + Text[ zh-TW ] = "ACOT"; + Text[ tr ] = "ACOT"; + Text[ hi-IN ] = "ACOT"; + Text[ ar ] = "ACOT"; + Text[ he ] = "ARCCOT"; + }; + String SC_OPCODE_SIN_HYP + { + Text [ de ] = "SINHYP" ; + Text [ en-US ] = "SINH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SENH"; + Text[ ru ] = "SINH"; + Text[ el ] = "SINH"; + Text[ nl ] = "SINH"; + Text[ fr ] = "SINH"; + Text[ es ] = "SENOH"; + Text[ fi ] = "SINH"; + Text[ ca ] = "SINH"; + Text[ it ] = "SENH"; + Text[ da ] = "SINH"; + Text[ sv ] = "SINH"; + Text[ pl ] = "SINH"; + Text[ pt-BR ] = "SENH"; + Text[ th ] = "SINH"; + Text[ ja ] = "SINH"; + Text[ ko ] = "SINH"; + Text[ zh-CN ] = "SINH"; + Text[ zh-TW ] = "SINH"; + Text[ tr ] = "SÄ°NH"; + Text[ hi-IN ] = "SINH"; + Text[ ar ] = "SINH"; + Text[ he ] = "SINHYP"; + }; + String SC_OPCODE_COS_HYP + { + Text [ de ] = "COSHYP" ; + Text [ en-US ] = "COSH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COSH"; + Text[ ru ] = "COSH"; + Text[ el ] = "COSH"; + Text[ nl ] = "COSH"; + Text[ fr ] = "COSH"; + Text[ es ] = "COSH"; + Text[ fi ] = "COSH"; + Text[ ca ] = "COSH"; + Text[ it ] = "COSH"; + Text[ da ] = "COSH"; + Text[ sv ] = "COSH"; + Text[ pl ] = "COSH"; + Text[ pt-BR ] = "COSH"; + Text[ th ] = "COSH"; + Text[ ja ] = "COSH"; + Text[ ko ] = "COSH"; + Text[ zh-CN ] = "COSH"; + Text[ zh-TW ] = "COSH"; + Text[ tr ] = "COSH"; + Text[ hi-IN ] = "COSH"; + Text[ ar ] = "COSH"; + Text[ he ] = "COSHYP"; + }; + String SC_OPCODE_TAN_HYP + { + Text [ de ] = "TANHYP" ; + Text [ en-US ] = "TANH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TANH"; + Text[ ru ] = "TANH"; + Text[ el ] = "TANH"; + Text[ nl ] = "TANH"; + Text[ fr ] = "TANH"; + Text[ es ] = "TANH"; + Text[ fi ] = "TANH"; + Text[ ca ] = "TANH"; + Text[ it ] = "TANH"; + Text[ da ] = "TANH"; + Text[ sv ] = "TANH"; + Text[ pl ] = "TANH"; + Text[ pt-BR ] = "TANH"; + Text[ th ] = "TANH"; + Text[ ja ] = "TANH"; + Text[ ko ] = "TANH"; + Text[ zh-CN ] = "TANH"; + Text[ zh-TW ] = "TANH"; + Text[ tr ] = "TANH"; + Text[ hi-IN ] = "TANH"; + Text[ ar ] = "TANH"; + Text[ he ] = "TANHYP"; + }; + String SC_OPCODE_COT_HYP + { + Text [ de ] = "COTHYP" ; + Text [ en-US ] = "COTH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COTH"; + Text[ ru ] = "COTH"; + Text[ el ] = "COTH"; + Text[ nl ] = "COTH"; + Text[ fr ] = "COTH"; + Text[ es ] = "COTH"; + Text[ fi ] = "COTH"; + Text[ ca ] = "COTH"; + Text[ it ] = "COTH"; + Text[ da ] = "COTH"; + Text[ sv ] = "COTH"; + Text[ pl ] = "COTH"; + Text[ pt-BR ] = "COTH"; + Text[ th ] = "COTH"; + Text[ ja ] = "COTH"; + Text[ ko ] = "COTH"; + Text[ zh-CN ] = "COTH"; + Text[ zh-TW ] = "COTH"; + Text[ tr ] = "COTH"; + Text[ hi-IN ] = "COTH"; + Text[ ar ] = "COTH"; + Text[ he ] = "COTHYP"; + }; + String SC_OPCODE_ARC_SIN_HYP + { + Text [ de ] = "ARCSINHYP" ; + Text [ en-US ] = "ASINH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ASENH"; + Text[ ru ] = "ASINH"; + Text[ el ] = "ASINH"; + Text[ nl ] = "BOOGSINH"; + Text[ fr ] = "ASINH"; + Text[ es ] = "ASENOH"; + Text[ fi ] = "ASINH"; + Text[ ca ] = "ASINH"; + Text[ it ] = "ARCSENH"; + Text[ da ] = "ARCSINH"; + Text[ sv ] = "ARCSINH"; + Text[ pl ] = "ASINH"; + Text[ pt-BR ] = "ASENH"; + Text[ th ] = "ASINH"; + Text[ ja ] = "ASINH"; + Text[ ko ] = "ASINH"; + Text[ zh-CN ] = "ASINH"; + Text[ zh-TW ] = "ASINH"; + Text[ tr ] = "ASÄ°NH"; + Text[ hi-IN ] = "ASINH"; + Text[ ar ] = "ASINH"; + Text[ he ] = "ARCSINHYP"; + }; + String SC_OPCODE_ARC_COS_HYP + { + Text [ de ] = "ARCCOSHYP" ; + Text [ en-US ] = "ACOSH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ACOSH"; + Text[ ru ] = "ACOSH"; + Text[ el ] = "ACOSH"; + Text[ nl ] = "BOOGCOSH"; + Text[ fr ] = "ACOSH"; + Text[ es ] = "ACOSH"; + Text[ fi ] = "ACOSH"; + Text[ ca ] = "ACOSH"; + Text[ it ] = "ARCCOSH"; + Text[ da ] = "ARCCOSH"; + Text[ sv ] = "ARCCOSH"; + Text[ pl ] = "ACOSH"; + Text[ pt-BR ] = "ACOSH"; + Text[ th ] = "ACOSH"; + Text[ ja ] = "ACOSH"; + Text[ ko ] = "ACOSH"; + Text[ zh-CN ] = "ACOSH"; + Text[ zh-TW ] = "ACOSH"; + Text[ tr ] = "ACOSH"; + Text[ hi-IN ] = "ACOSH"; + Text[ ar ] = "ACOSH"; + Text[ he ] = "ARCCOSHYP"; + }; + String SC_OPCODE_ARC_TAN_HYP + { + Text [ de ] = "ARCTANHYP" ; + Text [ en-US ] = "ATANH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ATANH"; + Text[ ru ] = "ATANH"; + Text[ el ] = "ATANH"; + Text[ nl ] = "BOOGTANH"; + Text[ fr ] = "ATANH"; + Text[ es ] = "ATANH"; + Text[ fi ] = "ATANH"; + Text[ ca ] = "ATANH"; + Text[ it ] = "ARCTANH"; + Text[ da ] = "ARCTANH"; + Text[ sv ] = "ARCTANH"; + Text[ pl ] = "ATANH"; + Text[ pt-BR ] = "ATANH"; + Text[ th ] = "ATANH"; + Text[ ja ] = "ATANH"; + Text[ ko ] = "ATANH"; + Text[ zh-CN ] = "ATANH"; + Text[ zh-TW ] = "ATANH"; + Text[ tr ] = "ATANH"; + Text[ hi-IN ] = "ATANH"; + Text[ ar ] = "ATANH"; + Text[ he ] = "ARCTANHYP"; + }; + String SC_OPCODE_ARC_COT_HYP + { + Text [ de ] = "ARCCOTHYP" ; + Text [ en-US ] = "ACOTH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ATANH"; + Text[ ru ] = "ACOTH"; + Text[ el ] = "ACOTH"; + Text[ nl ] = "BOOGCOTH"; + Text[ fr ] = "ACOTH"; + Text[ es ] = "ACOTH"; + Text[ fi ] = "ACOTH"; + Text[ ca ] = "ACOTH"; + Text[ it ] = "ARCCOTH"; + Text[ da ] = "ARCCOTH"; + Text[ sv ] = "ARCCOTH"; + Text[ pl ] = "ACOTH"; + Text[ pt-BR ] = "ACOTH"; + Text[ th ] = "ACOTH"; + Text[ ja ] = "ACOTH"; + Text[ ko ] = "ACOTH"; + Text[ zh-CN ] = "ACOTH"; + Text[ zh-TW ] = "ACOTH"; + Text[ tr ] = "ACOTH"; + Text[ hi-IN ] = "ACOTH"; + Text[ ar ] = "ACOTH"; + Text[ he ] = "ARCCOTHYP"; + }; + String SC_OPCODE_EXP + { + Text [ de ] = "EXP"; + Text [ en-US ] = "EXP"; + Text[ pt ] = "EXP"; + Text[ ru ] = "EXP"; + Text[ el ] = "EXP"; + Text[ nl ] = "EXP"; + Text[ fr ] = "EXP"; + Text[ es ] = "EXP"; + Text[ fi ] = "EXP"; + Text[ ca ] = "EXP"; + Text[ it ] = "EXP"; + Text[ da ] = "EXP"; + Text[ sv ] = "EXP"; + Text[ pl ] = "EXP"; + Text[ pt-BR ] = "EXP"; + Text[ th ] = "EXP"; + Text[ ja ] = "EXP"; + Text[ ko ] = "EXP"; + Text[ zh-CN ] = "EXP"; + Text[ zh-TW ] = "EXP"; + Text[ tr ] = "EXP"; + Text[ hi-IN ] = "EXP"; + Text[ ar ] = "EXP"; + Text[ he ] = "EXP"; + }; + String SC_OPCODE_LN + { + Text [ de ] = "LN"; + Text [ en-US ] = "LN"; + Text[ pt ] = "LN"; + Text[ ru ] = "LN"; + Text[ el ] = "LN"; + Text[ nl ] = "LN"; + Text[ fr ] = "LN"; + Text[ es ] = "LN"; + Text[ fi ] = "LN"; + Text[ ca ] = "LN"; + Text[ it ] = "LN"; + Text[ da ] = "LN"; + Text[ sv ] = "LN"; + Text[ pl ] = "LN"; + Text[ pt-BR ] = "LN"; + Text[ th ] = "LN"; + Text[ ja ] = "LN"; + Text[ ko ] = "LN"; + Text[ zh-CN ] = "LN"; + Text[ zh-TW ] = "LN"; + Text[ tr ] = "LN"; + Text[ hi-IN ] = "LN"; + Text[ ar ] = "LN"; + Text[ he ] = "LN"; + }; + String SC_OPCODE_SQRT + { + Text [ de ] = "WURZEL" ; + Text [ en-US ] = "SQRT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "RAÃZ.Q"; + Text[ ru ] = "КОРЕÐЬ"; + Text[ el ] = "SQRT"; + Text[ nl ] = "WORTEL"; + Text[ fr ] = "RACINE"; + Text[ es ] = "RAÃZ"; + Text[ fi ] = "NELIÖJUURI"; + Text[ ca ] = "SQRT"; + Text[ it ] = "RADQ"; + Text[ da ] = "KVROD"; + Text[ sv ] = "ROT"; + Text[ pl ] = "SQRT"; + Text[ pt-BR ] = "RAIZ"; + Text[ th ] = "SQRT"; + Text[ ja ] = "SQRT"; + Text[ ko ] = "SQRT"; + Text[ zh-CN ] = "SQRT"; + Text[ zh-TW ] = "SQRT"; + Text[ tr ] = "KAREKÖK"; + Text[ hi-IN ] = "SQRT"; + Text[ ar ] = "SQRT"; + Text[ he ] = "WURZEL"; + }; + String SC_OPCODE_FACT + { + Text [ de ] = "FAKULTÄT" ; + Text [ en-US ] = "FACT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FACT"; + Text[ ru ] = "ФÐКТР"; + Text[ el ] = "FACT"; + Text[ nl ] = "FACULTEIT"; + Text[ fr ] = "FACT"; + Text[ es ] = "FACT"; + Text[ fi ] = "KERTOMA"; + Text[ ca ] = "FACT"; + Text[ it ] = "FATTORIALE"; + Text[ da ] = "FAKULTET"; + Text[ sv ] = "FAKULTET"; + Text[ pl ] = "FACT"; + Text[ pt-BR ] = "FATORIAL"; + Text[ th ] = "FACT"; + Text[ ja ] = "FACT"; + Text[ ko ] = "FACT"; + Text[ zh-CN ] = "FACT"; + Text[ zh-TW ] = "FACT"; + Text[ tr ] = "FAKTÖRÄ°YEL"; + Text[ hi-IN ] = "FACT"; + Text[ ar ] = "FACT"; + Text[ he ] = "FAKULTÄT"; + }; + String SC_OPCODE_GET_YEAR + { + Text [ de ] = "JAHR" ; + Text [ en-US ] = "YEAR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ANO"; + Text[ ru ] = "ГОД"; + Text[ el ] = "YEAR"; + Text[ nl ] = "JAAR"; + Text[ fr ] = "ANNEE"; + Text[ es ] = "AÑO"; + Text[ fi ] = "VUOSI"; + Text[ ca ] = "YEAR"; + Text[ it ] = "ANNO"; + Text[ da ] = "Ã…R"; + Text[ sv ] = "Ã…R"; + Text[ pl ] = "YEAR"; + Text[ pt-BR ] = "ANO"; + Text[ th ] = "ปี"; + Text[ ja ] = "YEAR"; + Text[ ko ] = "YEAR"; + Text[ zh-CN ] = "YEAR"; + Text[ zh-TW ] = "YEAR"; + Text[ tr ] = "YIL"; + Text[ hi-IN ] = "YEAR"; + Text[ ar ] = "YEAR"; + Text[ he ] = "JAHR"; + }; + String SC_OPCODE_GET_MONTH + { + Text [ de ] = "MONAT" ; + Text [ en-US ] = "MONTH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÊS"; + Text[ ru ] = "МЕСЯЦ"; + Text[ el ] = "MONTH"; + Text[ nl ] = "MAAND"; + Text[ fr ] = "MOIS"; + Text[ es ] = "MES"; + Text[ fi ] = "KUUKAUSI"; + Text[ ca ] = "MONTH"; + Text[ it ] = "MESE"; + Text[ da ] = "MÃ…NED"; + Text[ sv ] = "MÃ…NAD"; + Text[ pl ] = "MONTH"; + Text[ pt-BR ] = "MÊS"; + Text[ th ] = "เดืà¸à¸™"; + Text[ ja ] = "MONTH"; + Text[ ko ] = "MONTH"; + Text[ zh-CN ] = "MONTH"; + Text[ zh-TW ] = "MONTH"; + Text[ tr ] = "AY"; + Text[ hi-IN ] = "MONTH"; + Text[ ar ] = "MONTH"; + Text[ he ] = "MONAT"; + }; + String SC_OPCODE_GET_DAY + { + Text [ de ] = "TAG" ; + Text [ en-US ] = "DAY" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIA"; + Text[ ru ] = "ДЕÐЬ"; + Text[ el ] = "DAY"; + Text[ nl ] = "DAG"; + Text[ fr ] = "JOUR"; + Text[ es ] = "DÃA"; + Text[ fi ] = "PÄIVÄ"; + Text[ ca ] = "DAY"; + Text[ it ] = "GIORNO"; + Text[ da ] = "DAG"; + Text[ sv ] = "DAG"; + Text[ pl ] = "DAY"; + Text[ pt-BR ] = "DIA"; + Text[ th ] = "วัน"; + Text[ ja ] = "DAY"; + Text[ ko ] = "DAY"; + Text[ zh-CN ] = "DAY"; + Text[ zh-TW ] = "DAY"; + Text[ tr ] = "GÃœN"; + Text[ hi-IN ] = "DAY"; + Text[ ar ] = "DAY"; + Text[ he ] = "TAG"; + }; + String SC_OPCODE_GET_HOUR + { + Text [ de ] = "STUNDE" ; + Text [ en-US ] = "HOUR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "HORA"; + Text[ ru ] = "ЧÐС"; + Text[ el ] = "HOUR"; + Text[ nl ] = "UUR"; + Text[ fr ] = "HEURE"; + Text[ es ] = "HORA"; + Text[ fi ] = "TUNNIT"; + Text[ ca ] = "HOUR"; + Text[ it ] = "ORA"; + Text[ da ] = "TIME"; + Text[ sv ] = "TIMME"; + Text[ pl ] = "HOUR"; + Text[ pt-BR ] = "HORA"; + Text[ th ] = "ชัวโมง"; + Text[ ja ] = "HOUR"; + Text[ ko ] = "HOUR"; + Text[ zh-CN ] = "HOUR"; + Text[ zh-TW ] = "HOUR"; + Text[ tr ] = "SAAT"; + Text[ hi-IN ] = "HOUR"; + Text[ ar ] = "HOUR"; + Text[ he ] = "STUNDE"; + }; + String SC_OPCODE_GET_MIN + { + Text [ de ] = "MINUTE" ; + Text [ en-US ] = "MINUTE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MINUTO"; + Text[ ru ] = "МИÐУТЫ"; + Text[ el ] = "MINUTE"; + Text[ nl ] = "MINUUT"; + Text[ fr ] = "MINUTE"; + Text[ es ] = "MINUTO"; + Text[ fi ] = "MINUUTIT"; + Text[ ca ] = "MINUTE"; + Text[ it ] = "MINUTO"; + Text[ da ] = "MINUT"; + Text[ sv ] = "MINUT"; + Text[ pl ] = "MINUTE"; + Text[ pt-BR ] = "MINUTO"; + Text[ th ] = "นาที"; + Text[ ja ] = "MINUTE"; + Text[ ko ] = "MINUTE"; + Text[ zh-CN ] = "MINUTE"; + Text[ zh-TW ] = "MINUTE"; + Text[ tr ] = "DAKÄ°KA"; + Text[ hi-IN ] = "MINUTE"; + Text[ ar ] = "MINUTE"; + Text[ he ] = "MINUTE"; + }; + String SC_OPCODE_GET_SEC + { + Text [ de ] = "SEKUNDE" ; + Text [ en-US ] = "SECOND" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SEGUNDO"; + Text[ ru ] = "СЕКУÐДЫ"; + Text[ el ] = "SECOND"; + Text[ nl ] = "SECONDE"; + Text[ fr ] = "SECONDE"; + Text[ es ] = "SEGUNDO"; + Text[ fi ] = "SEKUNNIT"; + Text[ ca ] = "SECOND"; + Text[ it ] = "SECONDO"; + Text[ da ] = "SEKUND"; + Text[ sv ] = "SEKUND"; + Text[ pl ] = "SECOND"; + Text[ pt-BR ] = "SEGUNDO"; + Text[ th ] = "วินาที"; + Text[ ja ] = "SECOND"; + Text[ ko ] = "SECOND"; + Text[ zh-CN ] = "SECOND"; + Text[ zh-TW ] = "SECOND"; + Text[ tr ] = "SANÄ°YE"; + Text[ hi-IN ] = "SECOND"; + Text[ ar ] = "SECOND"; + Text[ he ] = "SEKUNDE"; + }; + String SC_OPCODE_PLUS_MINUS + { + Text [ de ] = "VORZEICHEN" ; + Text [ en-US ] = "SIGN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SINAL"; + Text[ ru ] = "ЗÐÐК"; + Text[ el ] = "SIGN"; + Text[ nl ] = "POS.NEG"; + Text[ fr ] = "SIGNE"; + Text[ es ] = "SIGNO"; + Text[ fi ] = "ETUMERKKI"; + Text[ ca ] = "SIGN"; + Text[ it ] = "SEGNO"; + Text[ da ] = "FORTEGN"; + Text[ sv ] = "TECKEN"; + Text[ pl ] = "SIGN"; + Text[ pt-BR ] = "SINAL"; + Text[ th ] = "SIGN"; + Text[ ja ] = "SIGN"; + Text[ ko ] = "SIGN"; + Text[ zh-CN ] = "SIGN"; + Text[ zh-TW ] = "SIGN"; + Text[ tr ] = "Ä°ÅžARET"; + Text[ hi-IN ] = "SIGN"; + Text[ ar ] = "SIGN"; + Text[ he ] = "VORZEICHEN"; + }; + String SC_OPCODE_ABS + { + Text [ de ] = "ABS" ; + Text [ en-US ] = "ABS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ABS"; + Text[ ru ] = "ABS"; + Text[ el ] = "ABS"; + Text[ nl ] = "ABS"; + Text[ fr ] = "ABS"; + Text[ es ] = "ABS"; + Text[ fi ] = "ABS"; + Text[ ca ] = "ABS"; + Text[ it ] = "ASS"; + Text[ da ] = "ABS"; + Text[ sv ] = "ABS"; + Text[ pl ] = "ABS"; + Text[ pt-BR ] = "ABS"; + Text[ th ] = "ABS"; + Text[ ja ] = "ABS"; + Text[ ko ] = "ABS"; + Text[ zh-CN ] = "ABS"; + Text[ zh-TW ] = "ABS"; + Text[ tr ] = "MUTLAKDEÄžER"; + Text[ hi-IN ] = "ABS"; + Text[ ar ] = "ABS"; + Text[ he ] = "ABS"; + }; + String SC_OPCODE_INT + { + Text [ de ] = "GANZZAHL" ; + Text [ en-US ] = "INT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NÚM.INT"; + Text[ ru ] = "ЦЕЛОЕ"; + Text[ el ] = "INT"; + Text[ nl ] = "INTEGER"; + Text[ fr ] = "ENT"; + Text[ es ] = "ENTERO"; + Text[ fi ] = "KOKONAISLUKU"; + Text[ ca ] = "INT"; + Text[ it ] = "INT"; + Text[ da ] = "HELTAL"; + Text[ sv ] = "HELTAL"; + Text[ pl ] = "INT"; + Text[ pt-BR ] = "INT"; + Text[ th ] = "จำนวนเต็ม "; + Text[ ja ] = "INT"; + Text[ ko ] = "INT"; + Text[ zh-CN ] = "INT"; + Text[ zh-TW ] = "INT"; + Text[ tr ] = "TAMSAYI"; + Text[ hi-IN ] = "INT"; + Text[ ar ] = "INT"; + Text[ he ] = "GANZZAHL"; + }; + String SC_OPCODE_PHI + { + Text [ de ] = "PHI"; + Text [ en-US ] = "PHI"; + Text[ pt ] = "FI"; + Text[ ru ] = "ФИ"; + Text[ el ] = "PHI"; + Text[ nl ] = "PHI"; + Text[ fr ] = "PHI"; + Text[ es ] = "PHI"; + Text[ fi ] = "Fii"; + Text[ ca ] = "phi"; + Text[ it ] = "FI"; + Text[ da ] = "phi"; + Text[ sv ] = "FI"; + Text[ pl ] = "PHI"; + Text[ pt-BR ] = "fi"; + Text[ th ] = "ไฟ"; + Text[ ja ] = "PHI"; + Text[ ko ] = "PHI"; + Text[ zh-CN ] = "PHI"; + Text[ zh-TW ] = "PHI"; + Text[ tr ] = "PHI"; + Text[ hi-IN ] = "PHI"; + Text[ ar ] = "PHI"; + Text[ he ] = "PHI"; + }; + String SC_OPCODE_GAUSS + { + Text [ de ] = "GAUSS"; + Text [ en-US ] = "GAUSS"; + Text[ pt ] = "GAUSS"; + Text[ ru ] = "GAUSS"; + Text[ el ] = "GAUSS"; + Text[ nl ] = "GAUSS"; + Text[ fr ] = "GAUSS"; + Text[ es ] = "GAUSS"; + Text[ fi ] = "GAUSS"; + Text[ ca ] = "GAUSS"; + Text[ it ] = "GAUSS"; + Text[ da ] = "GAUSS"; + Text[ sv ] = "GAUSS"; + Text[ pl ] = "GAUSS"; + Text[ pt-BR ] = "GAUSS"; + Text[ th ] = "GAUSS"; + Text[ ja ] = "GAUSS"; + Text[ ko ] = "GAUSS"; + Text[ zh-CN ] = "GAUSS"; + Text[ zh-TW ] = "GAUSS"; + Text[ tr ] = "GAUSS"; + Text[ hi-IN ] = "GAUSS"; + Text[ ar ] = "GAUSS"; + Text[ he ] = "GAUSS"; + }; + String SC_OPCODE_IS_EMPTY + { + Text [ de ] = "ISTLEER" ; + Text [ en-US ] = "ISBLANK" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.CÉL.VAZIA"; + Text[ ru ] = "ЕПУСТО"; + Text[ el ] = "ISBLANK"; + Text[ nl ] = "ISLEEG"; + Text[ fr ] = "ESTVIDE"; + Text[ es ] = "ESBLANCO"; + Text[ fi ] = "ONTYHJÄ"; + Text[ ca ] = "ISBLANK"; + Text[ it ] = "VAL.VUOTO"; + Text[ da ] = "ER.TOM"; + Text[ sv ] = "ÄRTOM"; + Text[ pl ] = "ISBLANK"; + Text[ pt-BR ] = "É.CÉL.VAZIA"; + Text[ th ] = "ISBLANK"; + Text[ ja ] = "ISBLANK"; + Text[ ko ] = "ISBLANK"; + Text[ zh-CN ] = "ISBLANK"; + Text[ zh-TW ] = "ISBLANK"; + Text[ tr ] = "ISTBLANK"; + Text[ hi-IN ] = "ISBLANK"; + Text[ ar ] = "ISBLANK"; + Text[ he ] = "ISTLEER"; + }; + String SC_OPCODE_IS_STRING + { + Text [ de ] = "ISTTEXT" ; + Text [ en-US ] = "ISTEXT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.TEXTO"; + Text[ ru ] = "ЕТЕКСТ"; + Text[ el ] = "ISTEXT"; + Text[ nl ] = "ISTEKST"; + Text[ fr ] = "ESTTEXTE"; + Text[ es ] = "ESTEXTO"; + Text[ fi ] = "ONTEKSTI"; + Text[ ca ] = "ISTEXT"; + Text[ it ] = "VAL.TESTO"; + Text[ da ] = "ER.TEKST"; + Text[ sv ] = "ÄRTEXT"; + Text[ pl ] = "ISTEXT"; + Text[ pt-BR ] = "ÉTEXTO"; + Text[ th ] = "ISTEXT"; + Text[ ja ] = "ISTEXT"; + Text[ ko ] = "ISTEXT"; + Text[ zh-CN ] = "ISTEXT"; + Text[ zh-TW ] = "ISTEXT"; + Text[ tr ] = "METÄ°NSORGULA"; + Text[ hi-IN ] = "ISTEXT"; + Text[ ar ] = "ISTEXT"; + Text[ he ] = "ISTTEXT"; + }; + String SC_OPCODE_IS_NON_STRING + { + Text [ de ] = "ISTKTEXT" ; + Text [ en-US ] = "ISNONTEXT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.NÃO.TEXTO"; + Text[ ru ] = "ЕÐЕТЕКСТ"; + Text[ el ] = "ISNONTEXT"; + Text[ nl ] = "ISGEENTEKST"; + Text[ fr ] = "ESTNONTEXTE"; + Text[ es ] = "ESNOTEXTO"; + Text[ fi ] = "ONEI_TEKSTI"; + Text[ ca ] = "ISNONTEXT"; + Text[ it ] = "VAL.NON.TESTO"; + Text[ da ] = "ER.IKKE.TEKST"; + Text[ sv ] = "ÄREJTEXT"; + Text[ pl ] = "ISNONTEXT"; + Text[ pt-BR ] = "É.NÃO.TEXTO"; + Text[ th ] = "ISNONTEXT"; + Text[ ja ] = "ISNONTEXT"; + Text[ ko ] = "ISNONTEXT"; + Text[ zh-CN ] = "ISNONTEXT"; + Text[ zh-TW ] = "ISNONTEXT"; + Text[ tr ] = "METÄ°NDIÅžISORGULA"; + Text[ hi-IN ] = "ISNONTEXT"; + Text[ ar ] = "ISNONTEXT"; + Text[ he ] = "ISTKTEXT"; + }; + String SC_OPCODE_IS_LOGICAL + { + Text [ de ] = "ISTLOG" ; + Text [ en-US ] = "ISLOGICAL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.LÓGICO"; + Text[ ru ] = "ЕЛОГИЧ"; + Text[ el ] = "ISLOGICAL"; + Text[ nl ] = "ISLOGISCH"; + Text[ fr ] = "ESTLOGIQUE"; + Text[ es ] = "ESLOGICO"; + Text[ fi ] = "ONTOTUUS"; + Text[ ca ] = "ISLOGICAL"; + Text[ it ] = "VAL.LOGICO"; + Text[ da ] = "ER.LOGISK"; + Text[ sv ] = "ÄRLOGISK"; + Text[ pl ] = "ISLOGICAL"; + Text[ pt-BR ] = "ÉLÓGICO"; + Text[ th ] = "ISLOGICAL"; + Text[ ja ] = "ISLOGICAL"; + Text[ ko ] = "ISLOGICAL"; + Text[ zh-CN ] = "ISLOGICAL"; + Text[ zh-TW ] = "ISLOGICAL"; + Text[ tr ] = "MANTIKSALSAYISORGULA"; + Text[ hi-IN ] = "ISLOGICAL"; + Text[ ar ] = "ISLOGICAL"; + Text[ he ] = "ISTLOG"; + }; + String SC_OPCODE_TYPE + { + Text [ de ] = "TYP" ; + Text [ en-US ] = "TYPE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TIPO"; + Text[ ru ] = "ТИП"; + Text[ el ] = "TYPE"; + Text[ nl ] = "TYPE"; + Text[ fr ] = "TYPE"; + Text[ es ] = "TIPO"; + Text[ fi ] = "TYYPPI"; + Text[ ca ] = "TYPE"; + Text[ it ] = "TIPO"; + Text[ da ] = "VÆRDITYPE"; + Text[ sv ] = "VÄRDETYP"; + Text[ pl ] = "TYPE"; + Text[ pt-BR ] = "TIPO"; + Text[ th ] = "ชนิด"; + Text[ ja ] = "TYPE"; + Text[ ko ] = "TYPE"; + Text[ zh-CN ] = "TYPE"; + Text[ zh-TW ] = "TYPE"; + Text[ tr ] = "TÄ°P"; + Text[ hi-IN ] = "TYPE"; + Text[ ar ] = "TYPE"; + Text[ he ] = "TYP"; + }; + String SC_OPCODE_CELL + { + Text [ de ] = "ZELLE" ; + Text [ en-US ] = "CELL"; + Text[ pt ] = "CÉLULA"; + Text[ ru ] = "ЯЧЕЙКÐ"; + Text[ el ] = "ΚΕΛΙ"; + Text[ nl ] = "CEL"; + Text[ fr ] = "CELLULE"; + Text[ es ] = "CELDA"; + Text[ fi ] = "SOLU"; + Text[ ca ] = "CELL"; + Text[ it ] = "CELLA"; + Text[ da ] = "CELLE"; + Text[ sv ] = "CELL"; + Text[ pl ] = "CELL"; + Text[ pt-BR ] = "CELL"; + Text[ th ] = "เซลล์"; + Text[ ja ] = "CELL"; + Text[ ko ] = "CELL"; + Text[ zh-CN ] = "CELL"; + Text[ zh-TW ] = "CELL"; + Text[ tr ] = "HÃœCRE"; + Text[ hi-IN ] = "CELL"; + Text[ ar ] = "CELL"; + Text[ he ] = "ZELLE"; + }; + String SC_OPCODE_IS_REF + { + Text [ de ] = "ISTBEZUG" ; + Text [ en-US ] = "ISREF" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.REF"; + Text[ ru ] = "ЕССЫЛКÐ"; + Text[ el ] = "ISREF"; + Text[ nl ] = "ISVERWIJZING"; + Text[ fr ] = "ESTREF"; + Text[ es ] = "ESREF"; + Text[ fi ] = "ONVIITT"; + Text[ ca ] = "ISREF"; + Text[ it ] = "VAL.RIF"; + Text[ da ] = "ER.REFERENCE"; + Text[ sv ] = "ÄRREF"; + Text[ pl ] = "ISREF"; + Text[ pt-BR ] = "ÉREF"; + Text[ th ] = "ISREF"; + Text[ ja ] = "ISREF"; + Text[ ko ] = "ISREF"; + Text[ zh-CN ] = "ISREF"; + Text[ zh-TW ] = "ISREF"; + Text[ tr ] = "REFERANSSORGULA"; + Text[ hi-IN ] = "ISREF"; + Text[ ar ] = "ISREF"; + Text[ he ] = "ISTBEZUG"; + }; + String SC_OPCODE_IS_VALUE + { + Text [ de ] = "ISTZAHL" ; + Text [ en-US ] = "ISNUMBER" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.NÚMERO"; + Text[ ru ] = "ЕЧИСЛО"; + Text[ el ] = "ISNUMBER"; + Text[ nl ] = "ISGETAL"; + Text[ fr ] = "ESTNUM"; + Text[ es ] = "ESNÚMERO"; + Text[ fi ] = "ONLUKU"; + Text[ ca ] = "ISNUMBER"; + Text[ it ] = "VAL.NUMERO"; + Text[ da ] = "ER.TAL"; + Text[ sv ] = "ÄRTAL"; + Text[ pl ] = "ISNUMBER"; + Text[ pt-BR ] = "ÉNÚM"; + Text[ th ] = "ISNUMBER"; + Text[ ja ] = "ISNUMBER"; + Text[ ko ] = "ISNUMBER"; + Text[ zh-CN ] = "ISNUMBER"; + Text[ zh-TW ] = "ISNUMBER"; + Text[ tr ] = "SAYISORGULA"; + Text[ hi-IN ] = "ISNUMBER"; + Text[ ar ] = "ISNUMBER"; + Text[ he ] = "ISTZAHL"; + }; + String SC_OPCODE_IS_FORMULA + { + Text [ de ] = "ISTFORMEL" ; + Text [ en-US ] = "ISFORMULA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.FÓRMULA"; + Text[ ru ] = "ЕФОРМУЛÐ"; + Text[ el ] = "ISFORMULA"; + Text[ nl ] = "ISFORMULE"; + Text[ fr ] = "ESTFORMULE"; + Text[ es ] = "ESFÓRMULA"; + Text[ fi ] = "ONKAAVA"; + Text[ ca ] = "ISFORMULA"; + Text[ it ] = "VAL.FORMULA"; + Text[ da ] = "ER.FORMEL"; + Text[ sv ] = "ÄRFORMEL"; + Text[ pl ] = "ISFORMULA"; + Text[ pt-BR ] = "ÉFÓRMULA"; + Text[ th ] = "ISFORMULA"; + Text[ ja ] = "ISFORMULA"; + Text[ ko ] = "ISFORMULA"; + Text[ zh-CN ] = "ISFORMULA"; + Text[ zh-TW ] = "ISFORMULA"; + Text[ tr ] = "FORMÃœLSORGULA"; + Text[ hi-IN ] = "ISFORMULA"; + Text[ ar ] = "ISFORMULA"; + Text[ he ] = "ISTFORMEL"; + }; + String SC_OPCODE_IS_NV + { + Text [ de ] = "ISTNV" ; + Text [ en-US ] = "ISNA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.NÃO.DISP"; + Text[ ru ] = "ЕÐД"; + Text[ el ] = "ISNA"; + Text[ nl ] = "ISNB"; + Text[ fr ] = "ESTNA"; + Text[ es ] = "ESNOD"; + Text[ fi ] = "ONPUUTTUU"; + Text[ ca ] = "ISNA"; + Text[ it ] = "VAL.NON.DISP"; + Text[ da ] = "ER.IKKE.TILGÆNGELIG"; + Text[ sv ] = "ÄRSAKNAD"; + Text[ pl ] = "ISNA"; + Text[ pt-BR ] = "É.NÃO.DISP"; + Text[ th ] = "ISNA"; + Text[ ja ] = "ISNA"; + Text[ ko ] = "ISNA"; + Text[ zh-CN ] = "ISNA"; + Text[ zh-TW ] = "ISNA"; + Text[ tr ] = "ERİŞİMHATASISORGULA"; + Text[ hi-IN ] = "ISNA"; + Text[ ar ] = "ISNA"; + Text[ he ] = "ISTNV"; + }; + String SC_OPCODE_IS_ERR + { + Text [ de ] = "ISTFEHL" ; + Text [ en-US ] = "ISERR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.ERRO"; + Text[ ru ] = "ЕОШ"; + Text[ el ] = "ISERR"; + Text[ nl ] = "ISERR"; + Text[ fr ] = "ESTERR"; + Text[ es ] = "ESERR"; + Text[ fi ] = "ONVIRH"; + Text[ ca ] = "ISERR"; + Text[ it ] = "VAL.ERR"; + Text[ da ] = "ER.FJL"; + Text[ sv ] = "ÄRF"; + Text[ pl ] = "ISERR"; + Text[ pt-BR ] = "ÉERRO"; + Text[ th ] = "ISERR"; + Text[ ja ] = "ISERR"; + Text[ ko ] = "ISERR"; + Text[ zh-CN ] = "ISERR"; + Text[ zh-TW ] = "ISERR"; + Text[ tr ] = "ERİŞİMDIÅžIHATASORGULA"; + Text[ hi-IN ] = "ISERR"; + Text[ ar ] = "ISERR"; + Text[ he ] = "ISTFEHL"; + }; + String SC_OPCODE_IS_ERROR + { + Text [ de ] = "ISTFEHLER" ; + Text [ en-US ] = "ISERROR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "É.ERROS"; + Text[ ru ] = "ЕОШИБКÐ"; + Text[ el ] = "ISERROR"; + Text[ nl ] = "ISFOUT"; + Text[ fr ] = "ESTERREUR"; + Text[ es ] = "ESERROR"; + Text[ fi ] = "ONVIRHE"; + Text[ ca ] = "ISERROR"; + Text[ it ] = "VAL.ERRORE"; + Text[ da ] = "ER.FEJL"; + Text[ sv ] = "ÄRFEL"; + Text[ pl ] = "ISERROR"; + Text[ pt-BR ] = "ÉERROS"; + Text[ th ] = "ISERROR"; + Text[ ja ] = "ISERROR"; + Text[ ko ] = "ISERROR"; + Text[ zh-CN ] = "ISERROR"; + Text[ zh-TW ] = "ISERROR"; + Text[ tr ] = "HATASORGULA"; + Text[ hi-IN ] = "ISERROR"; + Text[ ar ] = "ISERROR"; + Text[ he ] = "ISTFEHLER"; + }; + String SC_OPCODE_IS_EVEN + { + Text [ de ] = "ISTGERADE" ; + Text [ en-US ] = "ISEVEN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ÉPAR"; + Text[ ru ] = "ЕЧЕТÐ"; + Text[ el ] = "ISEVEN"; + Text[ nl ] = "IS.EVEN"; + Text[ fr ] = "EST.PAIR"; + Text[ es ] = "ESPAR"; + Text[ fi ] = "ONPARILLINEN"; + Text[ ca ] = "ISEVEN"; + Text[ it ] = "VAL.PARI"; + Text[ da ] = "ER.LIGE"; + Text[ sv ] = "ÄRJÄMN"; + Text[ pl ] = "ISEVEN"; + Text[ pt-BR ] = "ÉPAR"; + Text[ th ] = "ISEVEN"; + Text[ ja ] = "ISEVEN"; + Text[ ko ] = "ISEVEN"; + Text[ zh-CN ] = "ISEVEN"; + Text[ zh-TW ] = "ISEVEN"; + Text[ tr ] = "ÇİFTSAYISORGULA"; + Text[ hi-IN ] = "ISEVEN"; + Text[ ar ] = "ISEVEN"; + Text[ he ] = "ISTGERADE"; + }; + String SC_OPCODE_IS_ODD + { + Text [ de ] = "ISTUNGERADE" ; + Text [ en-US ] = "ISODD" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ÉÃMPAR"; + Text[ ru ] = "ЕÐЕЧЕТÐ"; + Text[ el ] = "ISODD"; + Text[ nl ] = "ISONEVEN"; + Text[ fr ] = "EST.IMPAIR"; + Text[ es ] = "ESIMPAR"; + Text[ fi ] = "ONPARITON"; + Text[ ca ] = "ISODD"; + Text[ it ] = "VAL.DISPARI"; + Text[ da ] = "ER.ULIGE"; + Text[ sv ] = "ÄRUDDA"; + Text[ pl ] = "ISODD"; + Text[ pt-BR ] = "ÉÃMPAR"; + Text[ th ] = "ISODD"; + Text[ ja ] = "ISODD"; + Text[ ko ] = "ISODD"; + Text[ zh-CN ] = "ISODD"; + Text[ zh-TW ] = "ISODD"; + Text[ tr ] = "TEKSAYISORGULA"; + Text[ hi-IN ] = "ISODD"; + Text[ ar ] = "ISODD"; + Text[ he ] = "ISTUNGERADE"; + }; + String SC_OPCODE_N + { + Text [ de ] = "N" ; + Text [ en-US ] = "N" ; + Text [ x-comment ] = " "; + Text[ pt ] = "N"; + Text[ ru ] = "Ч"; + Text[ el ] = "N"; + Text[ nl ] = "N"; + Text[ fr ] = "N"; + Text[ es ] = "N"; + Text[ fi ] = "N"; + Text[ ca ] = "N"; + Text[ it ] = "NUM"; + Text[ da ] = "N"; + Text[ sv ] = "N"; + Text[ pl ] = "N"; + Text[ pt-BR ] = "N"; + Text[ th ] = "à¸à¸²à¸£à¸—ดลà¸à¸‡"; + Text[ ja ] = "N"; + Text[ ko ] = "N"; + Text[ zh-CN ] = "N"; + Text[ zh-TW ] = "N"; + Text[ tr ] = "N"; + Text[ hi-IN ] = "N"; + Text[ ar ] = "N"; + Text[ he ] = "N"; + }; + String SC_OPCODE_GET_DATE_VALUE + { + Text [ de ] = "DATWERT" ; + Text [ en-US ] = "DATEVALUE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DATA.VALOR"; + Text[ ru ] = "ДÐТÐЗÐÐЧ"; + Text[ el ] = "DATEVALUE"; + Text[ nl ] = "DATUMWAARDE"; + Text[ fr ] = "DATEVAL"; + Text[ es ] = "FECHANÚMERO"; + Text[ fi ] = "PÄIVÄYSARVO"; + Text[ ca ] = "DATEVALUE"; + Text[ it ] = "DATA.VALORE"; + Text[ da ] = "DATOVÆRDI"; + Text[ sv ] = "DATUMVÄRDE"; + Text[ pl ] = "DATEVALUE"; + Text[ pt-BR ] = "DATA.VALOR"; + Text[ th ] = "DATEVALUE"; + Text[ ja ] = "DATEVALUE"; + Text[ ko ] = "DATEVALUE"; + Text[ zh-CN ] = "DATEVALUE"; + Text[ zh-TW ] = "DATEVALUE"; + Text[ tr ] = "TARÄ°HDEÄžERÄ°"; + Text[ hi-IN ] = "DATEVALUE"; + Text[ ar ] = "DATEVALUE"; + Text[ he ] = "DATWERT"; + }; + String SC_OPCODE_GET_TIME_VALUE + { + Text [ de ] = "ZEITWERT" ; + Text [ en-US ] = "TIMEVALUE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VALOR.TEMPO"; + Text[ ru ] = "ВРЕМЯЗÐÐЧ"; + Text[ el ] = "TIMEVALUE"; + Text[ nl ] = "TIJDWAARDE"; + Text[ fr ] = "TEMPSVAL"; + Text[ es ] = "HORANÚMERO"; + Text[ fi ] = "AIKA_ARVO"; + Text[ ca ] = "TIMEVALUE"; + Text[ it ] = "ORARIO.VALORE"; + Text[ da ] = "TIDSVÆRDI"; + Text[ sv ] = "TIDVÄRDE"; + Text[ pl ] = "TIMEVALUE"; + Text[ pt-BR ] = "VALOR.TEMPO"; + Text[ th ] = "TIMEVALUE"; + Text[ ja ] = "TIMEVALUE"; + Text[ ko ] = "TIMEVALUE"; + Text[ zh-CN ] = "TIMEVALUE"; + Text[ zh-TW ] = "TIMEVALUE"; + Text[ tr ] = "SAATDEÄžERÄ°"; + Text[ hi-IN ] = "TIMEVALUE"; + Text[ ar ] = "TIMEVALUE"; + Text[ he ] = "ZEITWERT"; + }; + String SC_OPCODE_CODE + { + Text [ de ] = "CODE" ; + Text [ en-US ] = "CODE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CÓDIGO"; + Text[ ru ] = "КОДСИМВ"; + Text[ el ] = "CODE"; + Text[ nl ] = "CODE"; + Text[ fr ] = "CODE"; + Text[ es ] = "CÓDIGO"; + Text[ fi ] = "KOODI"; + Text[ ca ] = "CODE"; + Text[ it ] = "CODICE"; + Text[ da ] = "KODE"; + Text[ sv ] = "KOD"; + Text[ pl ] = "CODE"; + Text[ pt-BR ] = "CÓDIGO"; + Text[ th ] = "CODE"; + Text[ ja ] = "CODE"; + Text[ ko ] = "CODE"; + Text[ zh-CN ] = "CODE"; + Text[ zh-TW ] = "CODE"; + Text[ tr ] = "KOD"; + Text[ hi-IN ] = "CODE"; + Text[ ar ] = "CODE"; + Text[ he ] = "CODE"; + }; + String SC_OPCODE_TRIM + { + Text [ de ] = "GLÄTTEN" ; + Text [ en-US ] = "TRIM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COMPACTAR"; + Text[ ru ] = "СЖПРОБЕЛЫ"; + Text[ el ] = "TRIM"; + Text[ nl ] = "SPATIES.WISSEN"; + Text[ fr ] = "SUPPRESPACE"; + Text[ es ] = "COMPACTAR"; + Text[ fi ] = "POISTA_VÄLIT"; + Text[ ca ] = "TRIM"; + Text[ it ] = "ANNULLA.SPAZI"; + Text[ da ] = "TRIM"; + Text[ sv ] = "RENSA"; + Text[ pl ] = "TRIM"; + Text[ pt-BR ] = "ARRUMAR"; + Text[ th ] = "TRIM"; + Text[ ja ] = "TRIM"; + Text[ ko ] = "TRIM"; + Text[ zh-CN ] = "TRIM"; + Text[ zh-TW ] = "TRIM"; + Text[ tr ] = "DENKLEÅžTÄ°R"; + Text[ hi-IN ] = "TRIM"; + Text[ ar ] = "TRIM"; + Text[ he ] = "GLÄTTEN"; + }; + String SC_OPCODE_UPPER + { + Text [ de ] = "GROSS" ; + Text [ en-US ] = "UPPER" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MAIÚSCULA"; + Text[ ru ] = "ПРОПИСÐ"; + Text[ el ] = "UPPER"; + Text[ nl ] = "HOOFDLETTERS"; + Text[ fr ] = "MAJUSCULE"; + Text[ es ] = "MAYÚSC"; + Text[ fi ] = "ISOT"; + Text[ ca ] = "UPPER"; + Text[ it ] = "MAIUSC"; + Text[ da ] = "STORE.BOGSTAVER"; + Text[ sv ] = "VERSALER"; + Text[ pl ] = "UPPER"; + Text[ pt-BR ] = "MAIÚSCULA"; + Text[ th ] = "UPPER"; + Text[ ja ] = "UPPER"; + Text[ ko ] = "UPPER"; + Text[ zh-CN ] = "UPPER"; + Text[ zh-TW ] = "UPPER"; + Text[ tr ] = "DAHA ÃœSTTE"; + Text[ hi-IN ] = "UPPER"; + Text[ ar ] = "UPPER"; + Text[ he ] = "GROSS"; + }; + String SC_OPCODE_PROPPER + { + Text [ de ] = "GROSS2" ; + Text [ en-US ] = "PROPER" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INICIAL.MAIÚSCULA"; + Text[ ru ] = "ПРОПÐÐЧ"; + Text[ el ] = "PROPER"; + Text[ nl ] = "BEGINLETTERS2"; + Text[ fr ] = "NOMPROPRE"; + Text[ es ] = "NOMPROPIO"; + Text[ fi ] = "ERISNIMI"; + Text[ ca ] = "PROPER"; + Text[ it ] = "MAIUSC.INIZ"; + Text[ da ] = "STORT.FORBOGSTAV"; + Text[ sv ] = "INITIAL"; + Text[ pl ] = "PROPER"; + Text[ pt-BR ] = "PRI.MAIÚSCULA"; + Text[ th ] = "PROPER"; + Text[ ja ] = "PROPER"; + Text[ ko ] = "PROPER"; + Text[ zh-CN ] = "PROPER"; + Text[ zh-TW ] = "PROPER"; + Text[ tr ] = "UYGUN"; + Text[ hi-IN ] = "PROPER"; + Text[ ar ] = "PROPER"; + Text[ he ] = "GROSS2"; + }; + String SC_OPCODE_LOWER + { + Text [ de ] = "KLEIN" ; + Text [ en-US ] = "LOWER" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MINÚSCULA"; + Text[ ru ] = "СТРОЧÐ"; + Text[ el ] = "LOWER"; + Text[ nl ] = "KLEINE.LETTERS"; + Text[ fr ] = "MINUSCULE"; + Text[ es ] = "MINUSC"; + Text[ fi ] = "PIENET"; + Text[ ca ] = "LOWER"; + Text[ it ] = "MINUSC"; + Text[ da ] = "SMÃ….BOGSTAVER"; + Text[ sv ] = "GEMENER"; + Text[ pl ] = "LOWER"; + Text[ pt-BR ] = "MINÚSCULA"; + Text[ th ] = "ด้านล่าง"; + Text[ ja ] = "LOWER"; + Text[ ko ] = "LOWER"; + Text[ zh-CN ] = "LOWER"; + Text[ zh-TW ] = "LOWER"; + Text[ tr ] = "DAHA ALTTA"; + Text[ hi-IN ] = "LOWER"; + Text[ ar ] = "LOWER"; + Text[ he ] = "KLEIN"; + }; + String SC_OPCODE_LEN + { + Text [ de ] = "LÄNGE" ; + Text [ en-US ] = "LEN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NÚM.CARACT"; + Text[ ru ] = "ДЛСТР"; + Text[ el ] = "LEN"; + Text[ nl ] = "LENGTE"; + Text[ fr ] = "NBCAR"; + Text[ es ] = "LARGO"; + Text[ fi ] = "PITUUS"; + Text[ ca ] = "LEN"; + Text[ it ] = "LUNGHEZZA"; + Text[ da ] = "LÆNGDE"; + Text[ sv ] = "LÄNGD"; + Text[ pl ] = "LEN"; + Text[ pt-BR ] = "NÚM.CARACT"; + Text[ th ] = "LEN"; + Text[ ja ] = "LEN"; + Text[ ko ] = "LEN"; + Text[ zh-CN ] = "LEG"; + Text[ zh-TW ] = "LEG"; + Text[ tr ] = "UZUNLUK"; + Text[ hi-IN ] = "LEN"; + Text[ ar ] = "LEN"; + Text[ he ] = "LÄNGE"; + }; + String SC_OPCODE_T + { + Text [ de ] = "T"; + Text [ en-US ] = "T"; + Text[ pt ] = "S"; + Text[ ru ] = "Т"; + Text[ el ] = "Σ"; + Text[ nl ] = "S"; + Text[ fr ] = "T"; + Text[ es ] = "T"; + Text[ fi ] = "S"; + Text[ ca ] = "S"; + Text[ it ] = "T"; + Text[ da ] = "S"; + Text[ sv ] = "T"; + Text[ pl ] = "S"; + Text[ pt-BR ] = "S"; + Text[ th ] = "T"; + Text[ ja ] = "T"; + Text[ ko ] = "T"; + Text[ zh-CN ] = "T"; + Text[ zh-TW ] = "T"; + Text[ tr ] = "T"; + Text[ hi-IN ] = "T"; + Text[ ar ] = "Ù"; + Text[ he ] = "T"; + }; + String SC_OPCODE_VALUE + { + Text [ de ] = "WERT" ; + Text [ en-US ] = "VALUE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VALOR"; + Text[ ru ] = "ЗÐÐЧЕÐ"; + Text[ el ] = "VALUE"; + Text[ nl ] = "WAARDE"; + Text[ fr ] = "CNUM"; + Text[ es ] = "VALOR"; + Text[ fi ] = "ARVO"; + Text[ ca ] = "VALUE"; + Text[ it ] = "VALORE"; + Text[ da ] = "VÆRDI"; + Text[ sv ] = "TEXTNUM"; + Text[ pl ] = "VALUE"; + Text[ pt-BR ] = "VALOR"; + Text[ th ] = "ค่า "; + Text[ ja ] = "VALUE"; + Text[ ko ] = "VALUE"; + Text[ zh-CN ] = "VALUE"; + Text[ zh-TW ] = "VALUE"; + Text[ tr ] = "DEÄžER"; + Text[ hi-IN ] = "VALUE"; + Text[ ar ] = "VALUE"; + Text[ he ] = "WERT"; + }; + String SC_OPCODE_CLEAN + { + Text [ de ] = "SÄUBERN" ; + Text [ en-US ] = "CLEAN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LIMPAR"; + Text[ ru ] = "ПЕЧСИМВ"; + Text[ el ] = "CLEAN"; + Text[ nl ] = "WISSEN.CONTROL"; + Text[ fr ] = "EPURAGE"; + Text[ es ] = "LIMPIAR"; + Text[ fi ] = "SIIVOA"; + Text[ ca ] = "CLEAN"; + Text[ it ] = "LIBERA"; + Text[ da ] = "RENS"; + Text[ sv ] = "STÄDA"; + Text[ pl ] = "CLEAN"; + Text[ pt-BR ] = "TIRAR"; + Text[ th ] = "CLEAN"; + Text[ ja ] = "CLEAN"; + Text[ ko ] = "CLEAN"; + Text[ zh-CN ] = "CLEAN"; + Text[ zh-TW ] = "CLEAN"; + Text[ tr ] = "TEMÄ°ZLE"; + Text[ hi-IN ] = "CLEAN"; + Text[ ar ] = "CLEAN"; + Text[ he ] = "SÄUBERN"; + }; + String SC_OPCODE_CHAR + { + Text [ de ] = "ZEICHEN" ; + Text [ en-US ] = "CHAR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CARACT"; + Text[ ru ] = "СИМВОЛ"; + Text[ el ] = "CHAR"; + Text[ nl ] = "TEKEN"; + Text[ fr ] = "CAR"; + Text[ es ] = "CARÃCTER"; + Text[ fi ] = "MERKKI"; + Text[ ca ] = "CHAR"; + Text[ it ] = "CODICE.CARATT"; + Text[ da ] = "TEGN"; + Text[ sv ] = "TECKENKOD"; + Text[ pl ] = "CHAR"; + Text[ pt-BR ] = "CARACT"; + Text[ th ] = "ตัวà¸à¸±à¸à¸‚ระ"; + Text[ ja ] = "CHAR"; + Text[ ko ] = "CHAR"; + Text[ zh-CN ] = "CHAR"; + Text[ zh-TW ] = "CHAR"; + Text[ tr ] = "KARAKTER"; + Text[ hi-IN ] = "CHAR"; + Text[ ar ] = "CHAR"; + Text[ he ] = "ZEICHEN"; + }; + String SC_OPCODE_LOG10 + { + Text [ de ] = "LOG10"; + Text [ en-US ] = "LOG10"; + Text[ pt ] = "LOG10"; + Text[ ru ] = "LOG10"; + Text[ el ] = "LOG10"; + Text[ nl ] = "LOG10"; + Text[ fr ] = "LOG10"; + Text[ es ] = "LOG10"; + Text[ fi ] = "LOG10"; + Text[ ca ] = "LOG10"; + Text[ it ] = "LOG10"; + Text[ da ] = "LOG10"; + Text[ sv ] = "LOG10"; + Text[ pl ] = "LOG10"; + Text[ pt-BR ] = "LOG10"; + Text[ th ] = "LOG10"; + Text[ ja ] = "LOG10"; + Text[ ko ] = "LOG10"; + Text[ zh-CN ] = "LOG10"; + Text[ zh-TW ] = "LOG10"; + Text[ tr ] = "\nLOG10"; + Text[ hi-IN ] = "LOG10"; + Text[ ar ] = "LOG10"; + Text[ he ] = "LOG10"; + }; + String SC_OPCODE_EVEN + { + Text [ de ] = "GERADE" ; + Text [ en-US ] = "EVEN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PAR"; + Text[ ru ] = "ЧЕТÐ"; + Text[ el ] = "EVEN"; + Text[ nl ] = "EVEN"; + Text[ fr ] = "PAIR"; + Text[ es ] = "REDONDEA.PAR"; + Text[ fi ] = "PARILLINEN"; + Text[ ca ] = "EVEN"; + Text[ it ] = "PARI"; + Text[ da ] = "LIGE"; + Text[ sv ] = "JÄMN"; + Text[ pl ] = "EVEN"; + Text[ pt-BR ] = "PAR"; + Text[ th ] = "EVEN"; + Text[ ja ] = "EVEN"; + Text[ ko ] = "EVEN"; + Text[ zh-CN ] = "EVEN"; + Text[ zh-TW ] = "EVEN"; + Text[ tr ] = "ÇİFT"; + Text[ hi-IN ] = "EVEN"; + Text[ ar ] = "EVEN"; + Text[ he ] = "GERADE"; + }; + String SC_OPCODE_ODD + { + Text [ de ] = "UNGERADE" ; + Text [ en-US ] = "ODD" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ÃMPAR"; + Text[ ru ] = "ÐЕЧЕТ"; + Text[ el ] = "ODD"; + Text[ nl ] = "ONEVEN"; + Text[ fr ] = "IMPAIR"; + Text[ es ] = "REDONDEA.IMPAR"; + Text[ fi ] = "PARITON"; + Text[ ca ] = "ODD"; + Text[ it ] = "DISPARI"; + Text[ da ] = "ULIGE"; + Text[ sv ] = "UDDA"; + Text[ pl ] = "ODD"; + Text[ pt-BR ] = "ÃMPAR"; + Text[ th ] = "ODD"; + Text[ ja ] = "ODD"; + Text[ ko ] = "ODD"; + Text[ zh-CN ] = "ODD"; + Text[ zh-TW ] = "ODD"; + Text[ tr ] = "TEK"; + Text[ hi-IN ] = "ODD"; + Text[ ar ] = "ODD"; + Text[ he ] = "UNGERADE"; + }; + String SC_OPCODE_STD_NORM_DIST + { + Text [ de ] = "STANDNORMVERT" ; + Text [ en-US ] = "NORMSDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.NORM.P"; + Text[ ru ] = "ÐОРМСТРÐСП"; + Text[ el ] = "NORMSDIST"; + Text[ nl ] = "STAND.NORM.VERD"; + Text[ fr ] = "LOI.NORMALE.STANDARD"; + Text[ es ] = "DISTR.NORM.ESTAND"; + Text[ fi ] = "NORM_JAKAUMA_NORMIT"; + Text[ ca ] = "NORMSDIST"; + Text[ it ] = "DISTRIB.NORM.ST"; + Text[ da ] = "STANDARDNORMFORDELING"; + Text[ sv ] = "NORMSFÖRD"; + Text[ pl ] = "NORMSDIST"; + Text[ pt-BR ] = "DIST.NORMP"; + Text[ th ] = "NORMSDIST"; + Text[ ja ] = "NORMSDIST"; + Text[ ko ] = "NORMSDIST"; + Text[ zh-CN ] = "NORMSDIST"; + Text[ zh-TW ] = "NORMSDIST"; + Text[ tr ] = "NORMALKÃœMÃœLATÄ°FDAÄžILIM"; + Text[ hi-IN ] = "NORMSDIST"; + Text[ ar ] = "NORMSDIST"; + Text[ he ] = "STANDNORMVERT"; + }; + String SC_OPCODE_FISHER + { + Text [ de ] = "FISHER"; + Text [ en-US ] = "FISHER"; + Text[ pt ] = "FISHER"; + Text[ ru ] = "FISHER"; + Text[ el ] = "FISHER"; + Text[ nl ] = "FISHER"; + Text[ fr ] = "FISHER"; + Text[ es ] = "FISHER"; + Text[ fi ] = "FISHER"; + Text[ ca ] = "FISHER"; + Text[ it ] = "FISHER"; + Text[ da ] = "FISHER"; + Text[ sv ] = "FISHER"; + Text[ pl ] = "FISHER"; + Text[ pt-BR ] = "FISHER"; + Text[ th ] = "FISHER"; + Text[ ja ] = "FISHER"; + Text[ ko ] = "FISHER"; + Text[ zh-CN ] = "FISHER"; + Text[ zh-TW ] = "FISHER"; + Text[ tr ] = "FISHER"; + Text[ hi-IN ] = "FISHER"; + Text[ ar ] = "FISHER"; + Text[ he ] = "FISHER"; + }; + String SC_OPCODE_FISHER_INV + { + Text [ de ] = "FISHERINV" ; + Text [ en-US ] = "FISHERINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.FISHER"; + Text[ ru ] = "ФИШЕРОБР"; + Text[ el ] = "FISHERINV"; + Text[ nl ] = "FISHER.INV"; + Text[ fr ] = "FISHER.INVERSE"; + Text[ es ] = "PRUEBA.FISHER.INV"; + Text[ fi ] = "FISHER_KÄÄNT"; + Text[ ca ] = "FISHERINV"; + Text[ it ] = "INV.FISHER"; + Text[ da ] = "FISHERINV"; + Text[ sv ] = "FISHERINV"; + Text[ pl ] = "FISHERINV"; + Text[ pt-BR ] = "FISHERINV"; + Text[ th ] = "FISHERINV"; + Text[ ja ] = "FISHERINV"; + Text[ ko ] = "FISHERINV"; + Text[ zh-CN ] = "FISHERINV"; + Text[ zh-TW ] = "FISHERINV"; + Text[ tr ] = "TERSFISHERDÖNÜŞÜMÃœ"; + Text[ hi-IN ] = "FISHERINV"; + Text[ ar ] = "FISHERINV"; + Text[ he ] = "FISHERINV"; + }; + String SC_OPCODE_S_NORM_INV + { + Text [ de ] = "STANDNORMINV" ; + Text [ en-US ] = "NORMSINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.NORM.P"; + Text[ ru ] = "ÐОРМСТОБР"; + Text[ el ] = "NORMSINV"; + Text[ nl ] = "STAND.NORM.INV"; + Text[ fr ] = "LOI.NORMALE.STANDARD.INVERSE"; + Text[ es ] = "DISTR.NORM.ESTAND.INV"; + Text[ fi ] = "NORM_JAKAUMA_NORMIT_KÄÄNT"; + Text[ ca ] = "NORMSINV"; + Text[ it ] = "INV.NORM.ST"; + Text[ da ] = "STANDARDNORMINV"; + Text[ sv ] = "NORMSINV"; + Text[ pl ] = "NORMSINV"; + Text[ pt-BR ] = "INV.NORMP"; + Text[ th ] = "NORMSINV"; + Text[ ja ] = "NORMSINV"; + Text[ ko ] = "NORMSINV"; + Text[ zh-CN ] = "NORMSINV"; + Text[ zh-TW ] = "NORMSINV"; + Text[ tr ] = "TERSKÃœMÃœLATÄ°FDAÄžILIM"; + Text[ hi-IN ] = "NORMSINV"; + Text[ ar ] = "NORMSINV"; + Text[ he ] = "STANDNORMINV"; + }; + String SC_OPCODE_GAMMA_LN + { + Text [ de ] = "GAMMALN" ; + Text [ en-US ] = "GAMMALN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LN.GAMMA"; + Text[ ru ] = "ГÐММÐÐЛОГ"; + Text[ el ] = "GAMMALN"; + Text[ nl ] = "GAMMA.LN"; + Text[ fr ] = "LNGAMMA"; + Text[ es ] = "GAMMA.LN"; + Text[ fi ] = "GAMMALN"; + Text[ ca ] = "GAMMALN"; + Text[ it ] = "LN.GAMMA"; + Text[ da ] = "GAMMALN"; + Text[ sv ] = "GAMMALN"; + Text[ pl ] = "GAMMALN"; + Text[ pt-BR ] = "LNGAMA"; + Text[ th ] = "GAMMALN"; + Text[ ja ] = "GAMMALN"; + Text[ ko ] = "GAMMALN"; + Text[ zh-CN ] = "GAMMALN"; + Text[ zh-TW ] = "GAMMALN"; + Text[ tr ] = "GAMMAFONKSÄ°YONUDOÄžALLOGARÄ°TMASI"; + Text[ hi-IN ] = "GAMMALN"; + Text[ ar ] = "GAMMALN"; + Text[ he ] = "GAMMALN"; + }; + String SC_OPCODE_ERROR_TYPE + { + Text [ de ] = "FEHLERTYP" ; + Text [ en-US ] = "ERRORTYPE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TIPO.ERRO"; + Text[ ru ] = "ТИПОШИБКИ"; + Text[ el ] = "ERRORTYPE"; + Text[ nl ] = "TYPE.FOUT"; + Text[ fr ] = "TYPE.ERREUR"; + Text[ es ] = "TIPO.DE.ERROR"; + Text[ fi ] = "VIRHEEN_LAJI"; + Text[ ca ] = "ERRORTYPE"; + Text[ it ] = "ERRORE.TIPO"; + Text[ da ] = "FEJLTYPE"; + Text[ sv ] = "FELTYP"; + Text[ pl ] = "ERRORTYPE"; + Text[ pt-BR ] = "TIPODEERRO"; + Text[ th ] = "ERRORTYPE"; + Text[ ja ] = "ERRORTYPE"; + Text[ ko ] = "ERRORTYPE"; + Text[ zh-CN ] = "ERRORTYPE"; + Text[ zh-TW ] = "ERRORTYPE"; + Text[ tr ] = "HATATÄ°PÄ°"; + Text[ hi-IN ] = "ERRORTYPE"; + Text[ ar ] = "ERRORTYPE"; + Text[ he ] = "FEHLERTYP"; + }; + String SC_OPCODE_ERR_CELL { Text = "ZellError" ; }; // ?? Text klein, dt. & engl. gemischt ?? + String SC_OPCODE_FORMULA + { + Text [ de ] = "FORMEL"; + Text [ en-US ] = "FORMULA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FORMULA"; + Text[ ru ] = "ФОРМУЛÐ"; + Text[ el ] = "FORMULA"; + Text[ nl ] = "FORMULE"; + Text[ fr ] = "FORMULE"; + Text[ es ] = "FORMULA"; + Text[ fi ] = "KAAVA"; + Text[ ca ] = "FORMULA"; + Text[ it ] = "FORMULA"; + Text[ da ] = "FORMEL"; + Text[ sv ] = "FORMEL"; + Text[ pl ] = "FORMULA"; + Text[ pt-BR ] = "FÓRMULA"; + Text[ th ] = "สูตร"; + Text[ ja ] = "FORMULA"; + Text[ ko ] = "FORMULA"; + Text[ zh-CN ] = "FORMULA"; + Text[ zh-TW ] = "FORMULA"; + Text[ tr ] = "FORMÃœL"; + Text[ hi-IN ] = "FORMULA"; + Text[ ar ] = "FORMULA"; + Text[ he ] = "FORMEL"; + }; + String SC_OPCODE_ARABIC + { + Text [ de ] = "ARABISCH" ; + Text [ en-US ] = "ARABIC"; + Text[ pt ] = "ÃRABE"; + Text[ ru ] = "ÐÐ ÐБСКИЕ"; + Text[ el ] = "ΑΡΑΒΙΚΑ"; + Text[ nl ] = "ARABISCH"; + Text[ fr ] = "ARABE"; + Text[ es ] = "ÃRABE"; + Text[ fi ] = "ARABIALAINEN"; + Text[ ca ] = "ARABIC"; + Text[ it ] = "ARABO"; + Text[ da ] = "ARABERTAL"; + Text[ sv ] = "ARABISK"; + Text[ pl ] = "ARABIC"; + Text[ pt-BR ] = "ÃRABE"; + Text[ th ] = "ภาษาà¸à¸²à¸£à¸šà¸´à¸"; + Text[ ja ] = "ARABIC"; + Text[ ko ] = "ARABIC"; + Text[ zh-CN ] = "ARABIC"; + Text[ zh-TW ] = "ARABIC"; + Text[ tr ] = "ARABÄ°K"; + Text[ hi-IN ] = "ARABIC"; + Text[ ar ] = "ARABIC"; + Text[ he ] = "ARABISCH"; + }; + String SC_OPCODE_ARC_TAN_2 + { + Text [ de ] = "ARCTAN2" ; + Text [ en-US ] = "ATAN2" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ATAN2"; + Text[ ru ] = "ATAN2"; + Text[ el ] = "ATAN2"; + Text[ nl ] = "BOOGTAN2"; + Text[ fr ] = "ATAN2"; + Text[ es ] = "ATAN2"; + Text[ fi ] = "ATAN2"; + Text[ ca ] = "ATAN2"; + Text[ it ] = "ARCTAN.2"; + Text[ da ] = "ARCTAN2"; + Text[ sv ] = "ARCTAN2"; + Text[ pl ] = "ATAN2"; + Text[ pt-BR ] = "ATAN2"; + Text[ th ] = "ATAN2"; + Text[ ja ] = "ATAN2"; + Text[ ko ] = "ATAN2"; + Text[ zh-CN ] = "ATAN2"; + Text[ zh-TW ] = "ATAN2"; + Text[ tr ] = "ATAN2"; + Text[ hi-IN ] = "ATAN2"; + Text[ ar ] = "ATAN2"; + Text[ he ] = "ARCTAN2"; + }; + String SC_OPCODE_CEIL + { + Text [ de ] = "OBERGRENZE" ; + Text [ en-US ] = "CEILING" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LIMITE.SUPERIOR"; + Text[ ru ] = "ОКРВВЕРХ"; + Text[ el ] = "CEILING"; + Text[ nl ] = "AFRONDEN.BOVEN"; + Text[ fr ] = "PLAFOND"; + Text[ es ] = "MÚLTIPLO.SUPERIOR"; + Text[ fi ] = "PYÖRISTÄ_KERR_YLÖS"; + Text[ ca ] = "CEILING"; + Text[ it ] = "ARROTONDA.ECCESSO"; + Text[ da ] = "AFRUND.LOFT"; + Text[ sv ] = "RUNDA.UPP"; + Text[ pl ] = "CEILING"; + Text[ pt-BR ] = "TETO"; + Text[ th ] = "CEILING"; + Text[ ja ] = "CEILING"; + Text[ ko ] = "CEILING"; + Text[ zh-CN ] = "CEILING"; + Text[ zh-TW ] = "CEILING"; + Text[ tr ] = "ÃœSTSINIR"; + Text[ hi-IN ] = "CEILING"; + Text[ ar ] = "CEILING"; + Text[ he ] = "OBERGRENZE"; + }; + String SC_OPCODE_FLOOR + { + Text [ de ] = "UNTERGRENZE" ; + Text [ en-US ] = "FLOOR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LIMITE.INFERIOR"; + Text[ ru ] = "ОКРВÐИЗ"; + Text[ el ] = "FLOOR"; + Text[ nl ] = "AFRONDEN.BENEDEN"; + Text[ fr ] = "PLANCHER"; + Text[ es ] = "MÚLTIPLO.INFERIOR"; + Text[ fi ] = "PYÖRISTÄ_KERR_ALAS"; + Text[ ca ] = "FLOOR"; + Text[ it ] = "ARROTONDA.DIFETTO"; + Text[ da ] = "AFRUND.GULV"; + Text[ sv ] = "RUNDA.NER"; + Text[ pl ] = "FLOOR"; + Text[ pt-BR ] = "ARREDMULTB"; + Text[ th ] = "FLOOR"; + Text[ ja ] = "FLOOR"; + Text[ ko ] = "FLOOR"; + Text[ zh-CN ] = "FLOOR"; + Text[ zh-TW ] = "FLOOR"; + Text[ tr ] = "ALTSINIR"; + Text[ hi-IN ] = "FLOOR"; + Text[ ar ] = "FLOOR"; + Text[ he ] = "UNTERGRENZE"; + }; + String SC_OPCODE_ROUND + { + Text [ de ] = "RUNDEN" ; + Text [ en-US ] = "ROUND" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ARREDONDAR"; + Text[ ru ] = "ОКРУГЛ"; + Text[ el ] = "ROUND"; + Text[ nl ] = "AFRONDEN"; + Text[ fr ] = "ARRONDI"; + Text[ es ] = "REDONDEAR"; + Text[ fi ] = "PYÖRISTÄ"; + Text[ ca ] = "ROUND"; + Text[ it ] = "ARROTONDA"; + Text[ da ] = "AFRUND"; + Text[ sv ] = "AVRUNDA"; + Text[ pl ] = "ROUND"; + Text[ pt-BR ] = "ARRED"; + Text[ th ] = "ROUND"; + Text[ ja ] = "ROUND"; + Text[ ko ] = "ROUND"; + Text[ zh-CN ] = "ROUND"; + Text[ zh-TW ] = "ROUND"; + Text[ tr ] = "YUVARLA"; + Text[ hi-IN ] = "ROUND"; + Text[ ar ] = "ROUND"; + Text[ he ] = "RUNDEN"; + }; + String SC_OPCODE_ROUND_UP + { + Text [ de ] = "AUFRUNDEN" ; + Text [ en-US ] = "ROUNDUP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ARRED.PARA.CIMA"; + Text[ ru ] = "ОКРУГЛВВЕРХ"; + Text[ el ] = "ROUNDUP"; + Text[ nl ] = "AFRONDEN.NAAR.BOVEN"; + Text[ fr ] = "ARRONDI.SUP"; + Text[ es ] = "REDONDEAR.MAS"; + Text[ fi ] = "PYÖRISTÄ_DES_YLÖS"; + Text[ ca ] = "ROUNDUP"; + Text[ it ] = "ARROTONDA.PER.ECC"; + Text[ da ] = "RUND.OP"; + Text[ sv ] = "AVRUNDA.UPPÃ…T"; + Text[ pl ] = "ROUNDUP"; + Text[ pt-BR ] = "ARRED.PARA.CIMA"; + Text[ th ] = "ROUNDUP"; + Text[ ja ] = "ROUNDUP"; + Text[ ko ] = "ROUNDUP"; + Text[ zh-CN ] = "ROUNDUP"; + Text[ zh-TW ] = "ROUNDUP"; + Text[ tr ] = "ÃœSTDEÄžEREYUVARLA"; + Text[ hi-IN ] = "ROUNDUP"; + Text[ ar ] = "ROUNDUP"; + Text[ he ] = "AUFRUNDEN"; + }; + String SC_OPCODE_ROUND_DOWN + { + Text [ de ] = "ABRUNDEN" ; + Text [ en-US ] = "ROUNDDOWN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ARRED.PARA.BAIXO"; + Text[ ru ] = "ОКРУГЛВÐИЗ"; + Text[ el ] = "ROUNDDOWN"; + Text[ nl ] = "AFRONDEN.NAAR.BENEDEN"; + Text[ fr ] = "ARRONDI.INF"; + Text[ es ] = "REDONDEAR.MENOS"; + Text[ fi ] = "PYÖRISTÄ_DES_ALAS"; + Text[ ca ] = "ROUNDDOWN"; + Text[ it ] = "ARROTONDA.PER.DIF"; + Text[ da ] = "RUND.NED"; + Text[ sv ] = "AVRUNDA.NEDÃ…T"; + Text[ pl ] = "ROUNDDOWN"; + Text[ pt-BR ] = "ARRED.PARA.BAIXO"; + Text[ th ] = "ROUNDDOWN"; + Text[ ja ] = "ROUNDDOWN"; + Text[ ko ] = "ROUNDDOWN"; + Text[ zh-CN ] = "ROUNDDOWN"; + Text[ zh-TW ] = "ROUNDDOWN"; + Text[ tr ] = "ALTDEÄžEREYUVARLA"; + Text[ hi-IN ] = "ROUNDDOWN"; + Text[ ar ] = "ROUNDDOWN"; + Text[ he ] = "ABRUNDEN"; + }; + String SC_OPCODE_TRUNC + { + Text [ de ] = "KÃœRZEN" ; + Text [ en-US ] = "TRUNC" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TRUNCAR"; + Text[ ru ] = "ОТБР"; + Text[ el ] = "TRUNC"; + Text[ nl ] = "GEHEEL"; + Text[ fr ] = "TRONQUE"; + Text[ es ] = "TRUNCAR"; + Text[ fi ] = "KATKAISE"; + Text[ ca ] = "TRUNC"; + Text[ it ] = "TRONCA"; + Text[ da ] = "AFKORT"; + Text[ sv ] = "AVKORTA"; + Text[ pl ] = "TRUNC"; + Text[ pt-BR ] = "TRUNCAR"; + Text[ th ] = "TRUNC"; + Text[ ja ] = "TRUNC"; + Text[ ko ] = "TRUNC"; + Text[ zh-CN ] = "TRUNC"; + Text[ zh-TW ] = "TRUNC"; + Text[ tr ] = "TAMSAYI"; + Text[ hi-IN ] = "TRUNC"; + Text[ ar ] = "TRUNC"; + Text[ he ] = "KÃœRZEN"; + }; + String SC_OPCODE_LOG + { + Text [ de ] = "LOG"; + Text [ en-US ] = "LOG"; + Text[ pt ] = "LOG"; + Text[ ru ] = "LOG"; + Text[ el ] = "LOG"; + Text[ nl ] = "LOG"; + Text[ fr ] = "LOG"; + Text[ es ] = "LOG"; + Text[ fi ] = "LOG"; + Text[ ca ] = "LOG"; + Text[ it ] = "LOG"; + Text[ da ] = "LOG"; + Text[ sv ] = "LOG"; + Text[ pl ] = "LOG"; + Text[ pt-BR ] = "LOG"; + Text[ th ] = "LOG"; + Text[ ja ] = "LOG"; + Text[ ko ] = "LOG"; + Text[ zh-CN ] = "LOG"; + Text[ zh-TW ] = "LOG"; + Text[ tr ] = "LOG"; + Text[ hi-IN ] = "LOG"; + Text[ ar ] = "LOG"; + Text[ he ] = "LOG"; + }; + String SC_OPCODE_POWER + { + Text [ de ] = "POTENZ" ; + Text [ en-US ] = "POWER" ; + Text [ x-comment ] = " "; + Text[ pt ] = "POTÊNCIA"; + Text[ ru ] = "СТЕПЕÐЬ"; + Text[ el ] = "POWER"; + Text[ nl ] = "MACHT"; + Text[ fr ] = "PUISSANCE"; + Text[ es ] = "POTENCIA"; + Text[ fi ] = "POTENSSI"; + Text[ ca ] = "POWER"; + Text[ it ] = "POTENZA"; + Text[ da ] = "POTENS"; + Text[ sv ] = "UPPHÖJT.TILL"; + Text[ pl ] = "POWER"; + Text[ pt-BR ] = "POTÊNCIA"; + Text[ th ] = "ตัวเลข"; + Text[ ja ] = "POWER"; + Text[ ko ] = "POWER"; + Text[ zh-CN ] = "POWER"; + Text[ zh-TW ] = "POWER"; + Text[ tr ] = "ÃœS"; + Text[ hi-IN ] = "POWER"; + Text[ ar ] = "POWER"; + Text[ he ] = "POTENZ"; + }; + String SC_OPCODE_GGT + { + Text [ de ] = "GGT" ; + Text [ en-US ] = "GCD" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MDC"; + Text[ ru ] = "ÐОД"; + Text[ el ] = "GCD"; + Text[ nl ] = "GGD"; + Text[ fr ] = "PGCD"; + Text[ es ] = "M.C.D"; + Text[ fi ] = "SUURIN_YHT_TEKIJÄ"; + Text[ ca ] = "GCD"; + Text[ it ] = "MCD"; + Text[ da ] = "STØRSTE.FÆLLES.DIVISOR"; + Text[ sv ] = "SGD"; + Text[ pl ] = "GCD"; + Text[ pt-BR ] = "MDC"; + Text[ th ] = "GCD"; + Text[ ja ] = "GCD"; + Text[ ko ] = "GCD"; + Text[ zh-CN ] = "GCD"; + Text[ zh-TW ] = "GCD"; + Text[ tr ] = "OBEB"; + Text[ hi-IN ] = "GCD"; + Text[ ar ] = "GCD"; + Text[ he ] = "GGT"; + }; + String SC_OPCODE_KGV + { + Text [ de ] = "KGV" ; + Text [ en-US ] = "LCM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MMC"; + Text[ ru ] = "ÐОК"; + Text[ el ] = "LCM"; + Text[ nl ] = "KGV"; + Text[ fr ] = "PPCM"; + Text[ es ] = "M.C.M"; + Text[ fi ] = "PIENIN_YHT_JAETTAVA"; + Text[ ca ] = "LCM"; + Text[ it ] = "MCM"; + Text[ da ] = "MINDSTE.FÆLLES.MULTIPLUM"; + Text[ sv ] = "MGM"; + Text[ pl ] = "LCM"; + Text[ pt-BR ] = "MMC"; + Text[ th ] = "LCM"; + Text[ ja ] = "LCM"; + Text[ ko ] = "LCM"; + Text[ zh-CN ] = "LCM"; + Text[ zh-TW ] = "LCM"; + Text[ tr ] = "OKEK"; + Text[ hi-IN ] = "LCM"; + Text[ ar ] = "LCM"; + Text[ he ] = "KGV"; + }; + String SC_OPCODE_MOD + { + Text [ de ] = "REST" ; + Text [ en-US ] = "MOD" ; + Text [ x-comment ] = " "; + Text[ pt ] = "RESTO"; + Text[ ru ] = "ОСТÐТ"; + Text[ el ] = "MOD"; + Text[ nl ] = "REST"; + Text[ fr ] = "MOD"; + Text[ es ] = "RESIDUO"; + Text[ fi ] = "JAKOJ"; + Text[ ca ] = "MOD"; + Text[ it ] = "RESTO"; + Text[ da ] = "REST"; + Text[ sv ] = "REST"; + Text[ pl ] = "MOD"; + Text[ pt-BR ] = "MOD"; + Text[ th ] = "MOD"; + Text[ ja ] = "MOD"; + Text[ ko ] = "MOD"; + Text[ zh-CN ] = "MOD"; + Text[ zh-TW ] = "MOD"; + Text[ tr ] = "MOD"; + Text[ hi-IN ] = "MOD"; + Text[ ar ] = "MOD"; + Text[ he ] = "REST"; + }; + String SC_OPCODE_SUM_PRODUCT + { + Text [ de ] = "SUMMENPRODUKT" ; + Text [ en-US ] = "SUMPRODUCT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMAR.PRODUTO"; + Text[ ru ] = "СУММПРОИЗВ"; + Text[ el ] = "SUMPRODUCT"; + Text[ nl ] = "SOMPRODUKT"; + Text[ fr ] = "SOMMEPROD"; + Text[ es ] = "SUMA.PRODUCTO"; + Text[ fi ] = "TULOJEN_SUMMA"; + Text[ ca ] = "SUMPRODUCT"; + Text[ it ] = "MATR.SOMMA.PRODOTTO"; + Text[ da ] = "SUMPRODUKT"; + Text[ sv ] = "PRODUKTSUMMA"; + Text[ pl ] = "SUMPRODUCT"; + Text[ pt-BR ] = "SOMARPRODUTO"; + Text[ th ] = "SUMPRODUCT"; + Text[ ja ] = "SUMPRODUCT"; + Text[ ko ] = "SUMPRODUCT"; + Text[ zh-CN ] = "SUMPRODUCT"; + Text[ zh-TW ] = "SUMPRODUCT"; + Text[ tr ] = "MATRÄ°XÇARPIMI"; + Text[ hi-IN ] = "SUMPRODUCT"; + Text[ ar ] = "SUMPRODUCT"; + Text[ he ] = "SUMMENPRODUKT"; + }; + String SC_OPCODE_SUM_SQ + { + Text [ de ] = "QUADRATESUMME" ; + Text [ en-US ] = "SUMSQ" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMARQUAD"; + Text[ ru ] = "СУММÐКВ"; + Text[ el ] = "SUMSQ"; + Text[ nl ] = "KWADRATENSOM"; + Text[ fr ] = "SOMME.CARRES"; + Text[ es ] = "SUMA.CUADRADOS"; + Text[ fi ] = "NELIÖSUMMA"; + Text[ ca ] = "SUMSQ"; + Text[ it ] = "SOMMA.Q"; + Text[ da ] = "SUMKV"; + Text[ sv ] = "KVADRATSUMMA"; + Text[ pl ] = "SUMSQ"; + Text[ pt-BR ] = "SOMAQUAD"; + Text[ th ] = "SUMSQ"; + Text[ ja ] = "SUMSQ"; + Text[ ko ] = "SUMSQ"; + Text[ zh-CN ] = "SUMSQ"; + Text[ zh-TW ] = "SUMSQ"; + Text[ tr ] = "KARETOPLAMI"; + Text[ hi-IN ] = "SUMSQ"; + Text[ ar ] = "SUMSQ"; + Text[ he ] = "QUADRATESUMME"; + }; + String SC_OPCODE_SUM_X2MY2 + { + Text [ de ] = "SUMMEX2MY2" ; + Text [ en-US ] = "SUMX2MY2" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMA.X2MY2"; + Text[ ru ] = "СУММРÐЗÐКВ"; + Text[ el ] = "SUMX2MY2"; + Text[ nl ] = "SOM.X2MINY2"; + Text[ fr ] = "SOMME.X2MY2"; + Text[ es ] = "SUMAX2MENOSY2"; + Text[ fi ] = "NELIÖSUMMIEN_EROTUS"; + Text[ ca ] = "SUMX2MY2"; + Text[ it ] = "SOMMA.DIFF.Q"; + Text[ da ] = "SUMX2MY2"; + Text[ sv ] = "SUMMAX2MY2"; + Text[ pl ] = "SUMX2MY2"; + Text[ pt-BR ] = "SOMAX2DY2"; + Text[ th ] = "SUMX2MY2"; + Text[ ja ] = "SUMX2MY2"; + Text[ ko ] = "SUMX2MY2"; + Text[ zh-CN ] = "SUMX2MY2"; + Text[ zh-TW ] = "SUMX2MY2"; + Text[ tr ] = "TPLMX2TPLM2"; + Text[ hi-IN ] = "SUMX2MY2"; + Text[ ar ] = "SUMX2MY2"; + Text[ he ] = "SUMMEX2MY2"; + }; + String SC_OPCODE_SUM_X2DY2 + { + Text [ de ] = "SUMMEX2PY2" ; + Text [ en-US ] = "SUMX2PY2" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMA.X2PY2"; + Text[ ru ] = "СУММСУММКВ"; + Text[ el ] = "SUMX2PY2"; + Text[ nl ] = "SOM.X2PLUSY2"; + Text[ fr ] = "SOMME.X2PY2"; + Text[ es ] = "SUMAX2MASY2"; + Text[ fi ] = "NELIÖSUMMIEN_SUMMA"; + Text[ ca ] = "SUMX2PY2"; + Text[ it ] = "SOMMA.SOMMA.Q"; + Text[ da ] = "SUMX2PY2"; + Text[ sv ] = "SUMMAX2PY2"; + Text[ pl ] = "SUMX2PY2"; + Text[ pt-BR ] = "SOMAX2SY2"; + Text[ th ] = "SUMX2PY2"; + Text[ ja ] = "SUMX2PY2"; + Text[ ko ] = "SUMX2PY2"; + Text[ zh-CN ] = "SUMX2PY2"; + Text[ zh-TW ] = "SUMX2PY2"; + Text[ tr ] = "TPLMX2py22"; + Text[ hi-IN ] = "SUMX2PY2"; + Text[ ar ] = "SUMX2PY2"; + Text[ he ] = "SUMMEX2PY2"; + }; + String SC_OPCODE_SUM_XMY2 + { + Text [ de ] = "SUMMEXMY2" ; + Text [ en-US ] = "SUMXMY2" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMA.XMY2"; + Text[ ru ] = "СУММКВРÐЗÐ"; + Text[ el ] = "SUMXMY2"; + Text[ nl ] = "SOM.XMINY.2"; + Text[ fr ] = "SOMME.XMY2"; + Text[ es ] = "SUMAXMENOSY2"; + Text[ fi ] = "EROTUSTEN_NELIÖSUMMA"; + Text[ ca ] = "SUMXMY2"; + Text[ it ] = "SOMMA.Q.DIFF"; + Text[ da ] = "SUMXMY2"; + Text[ sv ] = "SUMMAXMY2"; + Text[ pl ] = "SUMXMY2"; + Text[ pt-BR ] = "SOMAXMY2"; + Text[ th ] = "SUMXMY2"; + Text[ ja ] = "SUMXMY2"; + Text[ ko ] = "SUMXMY2"; + Text[ zh-CN ] = "SUMXMY2"; + Text[ zh-TW ] = "SUMXMY2"; + Text[ tr ] = "TPLMXMY2"; + Text[ hi-IN ] = "SUMXMY2"; + Text[ ar ] = "SUMXMY2"; + Text[ he ] = "SUMMEXMY2"; + }; + String SC_OPCODE_GET_DATE + { + Text [ de ] = "DATUM" ; + Text [ en-US ] = "DATE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DATA"; + Text[ ru ] = "ДÐТÐ"; + Text[ el ] = "DATE"; + Text[ nl ] = "DATUM"; + Text[ fr ] = "DATE"; + Text[ es ] = "FECHA"; + Text[ fi ] = "PÄIVÄYS"; + Text[ ca ] = "DATE"; + Text[ it ] = "DATA"; + Text[ da ] = "DATO"; + Text[ sv ] = "DATUM"; + Text[ pl ] = "DATE"; + Text[ pt-BR ] = "DATA"; + Text[ th ] = "วัน"; + Text[ ja ] = "DATE"; + Text[ ko ] = "DATE"; + Text[ zh-CN ] = "DATE"; + Text[ zh-TW ] = "DATE"; + Text[ tr ] = "TARÄ°H"; + Text[ hi-IN ] = "DATE"; + Text[ ar ] = "DATE"; + Text[ he ] = "‮ת×ריך‬"; + }; + String SC_OPCODE_GET_TIME + { + Text [ de ] = "ZEIT" ; + Text [ en-US ] = "TIME" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TEMPO"; + Text[ ru ] = "ВРЕМЯ"; + Text[ el ] = "TIME"; + Text[ nl ] = "TIJD"; + Text[ fr ] = "TEMPS"; + Text[ es ] = "NSHORA"; + Text[ fi ] = "AIKA"; + Text[ ca ] = "TIME"; + Text[ it ] = "ORARIO"; + Text[ da ] = "TID"; + Text[ sv ] = "KLOCKSLAG"; + Text[ pl ] = "TIME"; + Text[ pt-BR ] = "TEMPO"; + Text[ th ] = "เวลา"; + Text[ ja ] = "TIME"; + Text[ ko ] = "TIME"; + Text[ zh-CN ] = "TIME"; + Text[ zh-TW ] = "TIME"; + Text[ tr ] = "SAAT"; + Text[ hi-IN ] = "TIME"; + Text[ ar ] = "TIME"; + Text[ he ] = "ZEIT"; + }; + String SC_OPCODE_GET_DIFF_DATE + { + Text [ de ] = "TAGE" ; + Text [ en-US ] = "DAYS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIAS"; + Text[ ru ] = "ДÐЕЙ"; + Text[ el ] = "DAYS"; + Text[ nl ] = "DAGEN"; + Text[ fr ] = "JOURS"; + Text[ es ] = "DÃAS"; + Text[ fi ] = "PÄIVÄT"; + Text[ ca ] = "DAYS"; + Text[ it ] = "GIORNI"; + Text[ da ] = "DAGE"; + Text[ sv ] = "DAGAR"; + Text[ pl ] = "DAYS"; + Text[ pt-BR ] = "DIAS"; + Text[ th ] = "วัน"; + Text[ ja ] = "DAYS"; + Text[ ko ] = "DAYS"; + Text[ zh-CN ] = "DAYS"; + Text[ zh-TW ] = "DAYS"; + Text[ tr ] = "GÃœNLER"; + Text[ hi-IN ] = "DAYS"; + Text[ ar ] = "DAYS"; + Text[ he ] = "TAGE"; + }; + String SC_OPCODE_GET_DIFF_DATE_360 + { + Text [ de ] = "TAGE360" ; + Text [ en-US ] = "DAYS360" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIAS360"; + Text[ ru ] = "ДÐЕЙ360"; + Text[ el ] = "DAYS360"; + Text[ nl ] = "DAGEN360"; + Text[ fr ] = "JOURS360"; + Text[ es ] = "DÃAS360"; + Text[ fi ] = "PÄIVÄT360"; + Text[ ca ] = "DAYS360"; + Text[ it ] = "GIORNO360"; + Text[ da ] = "DAGE360"; + Text[ sv ] = "DAGAR360"; + Text[ pl ] = "DAYS360"; + Text[ pt-BR ] = "DIAS360"; + Text[ th ] = "DAYS360"; + Text[ ja ] = "DAYS360"; + Text[ ko ] = "DAYS360"; + Text[ zh-CN ] = "DAYS360"; + Text[ zh-TW ] = "DAYS360"; + Text[ tr ] = "GÃœN360"; + Text[ hi-IN ] = "DAYS360"; + Text[ ar ] = "DAYS360"; + Text[ he ] = "TAGE360"; + }; + String SC_OPCODE_MIN + { + Text [ de ] = "MIN" ; + Text [ en-US ] = "MIN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÃNIMO"; + Text[ ru ] = "МИÐ"; + Text[ el ] = "MIN"; + Text[ nl ] = "MIN"; + Text[ fr ] = "MIN"; + Text[ es ] = "MÃN"; + Text[ fi ] = "MIN"; + Text[ ca ] = "MIN"; + Text[ it ] = "MIN"; + Text[ da ] = "MIN"; + Text[ sv ] = "MIN"; + Text[ pl ] = "MIN"; + Text[ pt-BR ] = "MÃNIMO"; + Text[ th ] = "น้à¸à¸¢à¸—ี่สุด"; + Text[ ja ] = "MIN"; + Text[ ko ] = "MIN"; + Text[ zh-CN ] = "MIN"; + Text[ zh-TW ] = "MIN"; + Text[ tr ] = "MÄ°N"; + Text[ hi-IN ] = "MIN"; + Text[ ar ] = "MIN"; + Text[ he ] = "MIN"; + }; + String SC_OPCODE_MIN_A + { + Text [ de ] = "MINA" ; + Text [ en-US ] = "MINA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÃNIMOA"; + Text[ ru ] = "МИÐÐ"; + Text[ el ] = "MINA"; + Text[ nl ] = "MINA"; + Text[ fr ] = "MINA"; + Text[ es ] = "MÃNA"; + Text[ fi ] = "MINA"; + Text[ ca ] = "MINA"; + Text[ it ] = "MIN.VALORI"; + Text[ da ] = "MINV"; + Text[ sv ] = "MINA"; + Text[ pl ] = "MINA"; + Text[ pt-BR ] = "MÃNIMOA"; + Text[ th ] = "MINA"; + Text[ ja ] = "MINA"; + Text[ ko ] = "MINA"; + Text[ zh-CN ] = "MINA"; + Text[ zh-TW ] = "MINA"; + Text[ tr ] = "MÄ°NA"; + Text[ hi-IN ] = "MINA"; + Text[ ar ] = "MINA"; + Text[ he ] = "MINA"; + }; + String SC_OPCODE_MAX + { + Text [ de ] = "MAX" ; + Text [ en-US ] = "MAX" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÃXIMO"; + Text[ ru ] = "ÐœÐКС"; + Text[ el ] = "MAX"; + Text[ nl ] = "MAX"; + Text[ fr ] = "MAX"; + Text[ es ] = "MÃX"; + Text[ fi ] = "MAKS"; + Text[ ca ] = "MAX"; + Text[ it ] = "MAX"; + Text[ da ] = "MAKS"; + Text[ sv ] = "MAX"; + Text[ pl ] = "MAX"; + Text[ pt-BR ] = "MÃXIMO"; + Text[ th ] = "มาà¸à¸—ี่สุด"; + Text[ ja ] = "MAX"; + Text[ ko ] = "MAX"; + Text[ zh-CN ] = "MAX"; + Text[ zh-TW ] = "MAX"; + Text[ tr ] = "MAX"; + Text[ hi-IN ] = "MAX"; + Text[ ar ] = "MAX"; + Text[ he ] = "MAX"; + }; + String SC_OPCODE_MAX_A + { + Text [ de ] = "MAXA" ; + Text [ en-US ] = "MAXA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÃXIMOA"; + Text[ ru ] = "ÐœÐКСÐ"; + Text[ el ] = "MAXA"; + Text[ nl ] = "MAXA"; + Text[ fr ] = "MAXA"; + Text[ es ] = "MÃXA"; + Text[ fi ] = "MAKSA"; + Text[ ca ] = "MAXA"; + Text[ it ] = "MAX.VALORI"; + Text[ da ] = "MAKSV"; + Text[ sv ] = "MAXA"; + Text[ pl ] = "MAXA"; + Text[ pt-BR ] = "MÃXIMOA"; + Text[ th ] = "MAXA"; + Text[ ja ] = "MAXA"; + Text[ ko ] = "MAXA"; + Text[ zh-CN ] = "MAXA"; + Text[ zh-TW ] = "MAXA"; + Text[ tr ] = "MAXA"; + Text[ hi-IN ] = "MAXA"; + Text[ ar ] = "MAXA"; + Text[ he ] = "MAXA"; + }; + String SC_OPCODE_SUM + { + Text [ de ] = "SUMME" ; + Text [ en-US ] = "SUM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMA"; + Text[ ru ] = "СУММ"; + Text[ el ] = "SUM"; + Text[ nl ] = "SOM"; + Text[ fr ] = "SOMME"; + Text[ es ] = "SUMA"; + Text[ fi ] = "SUMMA"; + Text[ ca ] = "SUM"; + Text[ it ] = "SOMMA"; + Text[ da ] = "SUM"; + Text[ sv ] = "SUMMA"; + Text[ pl ] = "SUM"; + Text[ pt-BR ] = "SOMA"; + Text[ th ] = "ผลรวม"; + Text[ ja ] = "SUM"; + Text[ ko ] = "SUM"; + Text[ zh-CN ] = "SUM"; + Text[ zh-TW ] = "SUM"; + Text[ tr ] = "TOPLAM"; + Text[ hi-IN ] = "SUM"; + Text[ ar ] = "SUM"; + Text[ he ] = "SUMME"; + }; + String SC_OPCODE_PRODUCT + { + Text [ de ] = "PRODUKT" ; + Text [ en-US ] = "PRODUCT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PRODUTO"; + Text[ ru ] = "ПРОИЗВЕДЕÐИЕ"; + Text[ el ] = "PRODUCT"; + Text[ nl ] = "PRODUKT"; + Text[ fr ] = "PRODUIT"; + Text[ es ] = "PRODUCTO"; + Text[ fi ] = "TULO"; + Text[ ca ] = "PRODUCT"; + Text[ it ] = "PRODOTTO"; + Text[ da ] = "PRODUKT"; + Text[ sv ] = "PRODUKT"; + Text[ pl ] = "PRODUCT"; + Text[ pt-BR ] = "MULT"; + Text[ th ] = "ผลผลิต"; + Text[ ja ] = "PRODUCT"; + Text[ ko ] = "PRODUCT"; + Text[ zh-CN ] = "PRODUCT"; + Text[ zh-TW ] = "PRODUCT"; + Text[ tr ] = "ÇARPIM"; + Text[ hi-IN ] = "PRODUCT"; + Text[ ar ] = "PRODUCT"; + Text[ he ] = "PRODUKT"; + }; + String SC_OPCODE_AVERAGE + { + Text [ de ] = "MITTELWERT" ; + Text [ en-US ] = "AVERAGE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÉDIA"; + Text[ ru ] = "СРЗÐÐЧ"; + Text[ el ] = "AVERAGE"; + Text[ nl ] = "GEMIDDELDE"; + Text[ fr ] = "MOYENNE"; + Text[ es ] = "PROMEDIO"; + Text[ fi ] = "KESKIARVO"; + Text[ ca ] = "AVERAGE"; + Text[ it ] = "MEDIA"; + Text[ da ] = "MIDDEL"; + Text[ sv ] = "MEDEL"; + Text[ pl ] = "AVERAGE"; + Text[ pt-BR ] = "MÉDIA"; + Text[ th ] = "เฉลี่ย"; + Text[ ja ] = "AVERAGE"; + Text[ ko ] = "AVERAGE"; + Text[ zh-CN ] = "AVERAGE"; + Text[ zh-TW ] = "AVERAGE"; + Text[ tr ] = "ORTALAMA"; + Text[ hi-IN ] = "AVERAGE"; + Text[ ar ] = "AVERAGE"; + Text[ he ] = "MITTELWERT"; + }; + String SC_OPCODE_AVERAGE_A + { + Text [ de ] = "MITTELWERTA" ; + Text [ en-US ] = "AVERAGEA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÉDIAA"; + Text[ ru ] = "СРЗÐÐЧÐ"; + Text[ el ] = "AVERAGEA"; + Text[ nl ] = "GEMIDDELDEA"; + Text[ fr ] = "MOYENNEA"; + Text[ es ] = "PROMEDIOA"; + Text[ fi ] = "KESKIARVOA"; + Text[ ca ] = "AVERAGEA"; + Text[ it ] = "MEDIA.VALORI"; + Text[ da ] = "MIDDELV"; + Text[ sv ] = "MEDELA"; + Text[ pl ] = "AVERAGEA"; + Text[ pt-BR ] = "MÉDIAA"; + Text[ th ] = "AVERAGEA"; + Text[ ja ] = "AVERAGEA"; + Text[ ko ] = "AVERAGEA"; + Text[ zh-CN ] = "AVERAGEA"; + Text[ zh-TW ] = "AVERAGEA"; + Text[ tr ] = "ORTALAMAA"; + Text[ hi-IN ] = "AVERAGEA"; + Text[ ar ] = "AVERAGEA"; + Text[ he ] = "MITTELWERTA"; + }; + String SC_OPCODE_COUNT + { + Text [ de ] = "ANZAHL" ; + Text [ en-US ] = "COUNT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CONTAR.NÚMEROS"; + Text[ ru ] = "СЧЕТ"; + Text[ el ] = "COUNT"; + Text[ nl ] = "AANTAL"; + Text[ fr ] = "NB"; + Text[ es ] = "CONTAR"; + Text[ fi ] = "LASKE"; + Text[ ca ] = "COUNT"; + Text[ it ] = "CONTA.NUMERI"; + Text[ da ] = "TÆL"; + Text[ sv ] = "ANTAL"; + Text[ pl ] = "COUNT"; + Text[ pt-BR ] = "CONT.NÚM"; + Text[ th ] = "ตัวเลข"; + Text[ ja ] = "COUNT"; + Text[ ko ] = "COUNT"; + Text[ zh-CN ] = "COUNT"; + Text[ zh-TW ] = "COUNT"; + Text[ tr ] = "SAY"; + Text[ hi-IN ] = "COUNT"; + Text[ ar ] = "COUNT"; + Text[ he ] = "ANZAHL"; + }; + String SC_OPCODE_COUNT_2 + { + Text [ de ] = "ANZAHL2" ; + Text [ en-US ] = "COUNTA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CONTAR.VAL"; + Text[ ru ] = "СЧЕТ2"; + Text[ el ] = "COUNTA"; + Text[ nl ] = "AANTAL2"; + Text[ fr ] = "NBVAL"; + Text[ es ] = "CONTARA"; + Text[ fi ] = "LASKE_A"; + Text[ ca ] = "COUNTA"; + Text[ it ] = "CONTA.VALORI"; + Text[ da ] = "TÆLV"; + Text[ sv ] = "ANTALV"; + Text[ pl ] = "COUNTA"; + Text[ pt-BR ] = "CONT.VALORES"; + Text[ th ] = "นับA"; + Text[ ja ] = "COUNTA"; + Text[ ko ] = "COUNTA"; + Text[ zh-CN ] = "COUNTA"; + Text[ zh-TW ] = "COUNTA"; + Text[ tr ] = "SAYA"; + Text[ hi-IN ] = "COUNTA"; + Text[ ar ] = "COUNTA"; + Text[ he ] = "ANZAHL2"; + }; + String SC_OPCODE_NBW + { + Text [ de ] = "NBW" ; + Text [ en-US ] = "NPV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VPL"; + Text[ ru ] = "ÐПЗ"; + Text[ el ] = "NPV"; + Text[ nl ] = "NHW"; + Text[ fr ] = "VAN"; + Text[ es ] = "VNA"; + Text[ fi ] = "NNA"; + Text[ ca ] = "NPV"; + Text[ it ] = "VAN"; + Text[ da ] = "NUTIDSVÆRDI"; + Text[ sv ] = "NETNUVÄRDE"; + Text[ pl ] = "NPV"; + Text[ pt-BR ] = "VPL"; + Text[ th ] = "NPV"; + Text[ ja ] = "NPV"; + Text[ ko ] = "NPV"; + Text[ zh-CN ] = "NPV"; + Text[ zh-TW ] = "NPV"; + Text[ tr ] = "NETBUGÃœNKÃœDEÄžER"; + Text[ hi-IN ] = "NPV"; + Text[ ar ] = "NPV"; + Text[ he ] = "NBW"; + }; + String SC_OPCODE_IKV + { + Text [ de ] = "IKV" ; + Text [ en-US ] = "IRR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TIR"; + Text[ ru ] = "Ð’ÐДОХ"; + Text[ el ] = "IRR"; + Text[ nl ] = "IR"; + Text[ fr ] = "TRI"; + Text[ es ] = "TIR"; + Text[ fi ] = "SISÄINEN_KORKO"; + Text[ ca ] = "IRR"; + Text[ it ] = "TIR.COST"; + Text[ da ] = "IA"; + Text[ sv ] = "IR"; + Text[ pl ] = "IRR"; + Text[ pt-BR ] = "TIR"; + Text[ th ] = "IRR"; + Text[ ja ] = "IRR"; + Text[ ko ] = "IRR"; + Text[ zh-CN ] = "IRR"; + Text[ zh-TW ] = "IRR"; + Text[ tr ] = "İÇFAÄ°ZORANI"; + Text[ hi-IN ] = "IRR"; + Text[ ar ] = "IRR"; + Text[ he ] = "IKV"; + }; + String SC_OPCODE_MIRR + { + Text [ de ] = "QIKV" ; + Text [ en-US ] = "MIRR"; + Text[ pt ] = "MTIR"; + Text[ ru ] = "МВСД"; + Text[ el ] = "MIRR"; + Text[ nl ] = "QIR"; + Text[ fr ] = "TRIM"; + Text[ es ] = "MIRR"; + Text[ fi ] = "MSISÄINEN"; + Text[ ca ] = "MIRR"; + Text[ it ] = "TIR.VAR"; + Text[ da ] = "QIKV"; + Text[ sv ] = "MODIR"; + Text[ pl ] = "MIRR"; + Text[ pt-BR ] = "MTIR"; + Text[ th ] = "MIRR"; + Text[ ja ] = "MIRR"; + Text[ ko ] = "MIRR"; + Text[ zh-CN ] = "MIRR"; + Text[ zh-TW ] = "MIRR"; + Text[ tr ] = "DEĞİŞTÄ°RÄ°LMİŞİÇFAÄ°ZORANI"; + Text[ hi-IN ] = "MIRR"; + Text[ ar ] = "MIRR"; + Text[ he ] = "QIKV"; + }; + String SC_OPCODE_ISPMT + { + Text [ de ] = "ISPMT" ; + Text [ en-US ] = "ISPMT"; + Text[ pt ] = "ISPMT"; + Text[ ru ] = "ПРОЦПЛÐТ"; + Text[ el ] = "ISPMT"; + Text[ nl ] = "ISPMT"; + Text[ fr ] = "ISPMT"; + Text[ es ] = "INT.PAGO.DIR"; + Text[ fi ] = "ISPMT"; + Text[ ca ] = "ISPMT"; + Text[ it ] = "INTERESSE.RATA"; + Text[ da ] = "ISPMT"; + Text[ sv ] = "RALÃ…N"; + Text[ pl ] = "ISPMT"; + Text[ pt-BR ] = "ÉPGTO"; + Text[ th ] = "ISPMT"; + Text[ ja ] = "ISPMT"; + Text[ ko ] = "ISPMT"; + Text[ zh-CN ] = "ISPMT"; + Text[ zh-TW ] = "ISPMT"; + Text[ tr ] = "FAÄ°ZORANI (SABÄ°TAMORTÄ°SMAN)"; + Text[ hi-IN ] = "ISPMT"; + Text[ ar ] = "ISPMT"; + Text[ he ] = "ISPMT"; + }; + String SC_OPCODE_VAR + { + Text [ de ] = "VARIANZ" ; + Text [ en-US ] = "VAR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VAR"; + Text[ ru ] = "ДИСП"; + Text[ el ] = "VAR"; + Text[ nl ] = "VAR"; + Text[ fr ] = "VAR"; + Text[ es ] = "VAR"; + Text[ fi ] = "VAR"; + Text[ ca ] = "VAR"; + Text[ it ] = "VAR"; + Text[ da ] = "VARIANS"; + Text[ sv ] = "VARIANS"; + Text[ pl ] = "VAR"; + Text[ pt-BR ] = "VAR"; + Text[ th ] = "VAR"; + Text[ ja ] = "VAR"; + Text[ ko ] = "VAR"; + Text[ zh-CN ] = "VAR"; + Text[ zh-TW ] = "VAR"; + Text[ tr ] = "DEĞİŞKEN"; + Text[ hi-IN ] = "VAR"; + Text[ ar ] = "VAR"; + Text[ he ] = "VARIANZ"; + }; + String SC_OPCODE_VAR_A + { + Text [ de ] = "VARIANZA" ; + Text [ en-US ] = "VARA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VARA"; + Text[ ru ] = "ДИСПÐ"; + Text[ el ] = "VARA"; + Text[ nl ] = "VARA"; + Text[ fr ] = "VARA"; + Text[ es ] = "VARA"; + Text[ fi ] = "VARA"; + Text[ ca ] = "VARA"; + Text[ it ] = "VAR.VALORI"; + Text[ da ] = "VARIANSV"; + Text[ sv ] = "VARIANSA"; + Text[ pl ] = "VARA"; + Text[ pt-BR ] = "VARA"; + Text[ th ] = "VARA"; + Text[ ja ] = "VARA"; + Text[ ko ] = "VARA"; + Text[ zh-CN ] = "VARA"; + Text[ zh-TW ] = "VARA"; + Text[ tr ] = "DEĞİŞKENA"; + Text[ hi-IN ] = "VARA"; + Text[ ar ] = "VARA"; + Text[ he ] = "VARIANZA"; + }; + String SC_OPCODE_VAR_P + { + Text [ de ] = "VARIANZEN" ; + Text [ en-US ] = "VARP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VARP"; + Text[ ru ] = "ДИСПР"; + Text[ el ] = "VARP"; + Text[ nl ] = "VARP"; + Text[ fr ] = "VAR.P"; + Text[ es ] = "VARP"; + Text[ fi ] = "VARP"; + Text[ ca ] = "VARP"; + Text[ it ] = "VAR.POP"; + Text[ da ] = "VARIANSP"; + Text[ sv ] = "VARIANSP"; + Text[ pl ] = "VARP"; + Text[ pt-BR ] = "VARP"; + Text[ th ] = "VARP"; + Text[ ja ] = "VARP"; + Text[ ko ] = "VARP"; + Text[ zh-CN ] = "VARP"; + Text[ zh-TW ] = "VARP"; + Text[ tr ] = "DEĞİŞKENP"; + Text[ hi-IN ] = "VARP"; + Text[ ar ] = "VARP"; + Text[ he ] = "VARIANZEN"; + }; + String SC_OPCODE_VAR_P_A + { + Text [ de ] = "VARIANZENA" ; + Text [ en-US ] = "VARPA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VARPA"; + Text[ ru ] = "ДИСПРÐ"; + Text[ el ] = "VARPA"; + Text[ nl ] = "VARPA"; + Text[ fr ] = "VAR.PA"; + Text[ es ] = "VARPA"; + Text[ fi ] = "VARPA"; + Text[ ca ] = "VARPA"; + Text[ it ] = "VAR.POP.VALORI"; + Text[ da ] = "VARIANSNV"; + Text[ sv ] = "VARIANSPA"; + Text[ pl ] = "VARPA"; + Text[ pt-BR ] = "VARPA"; + Text[ th ] = "VARPA"; + Text[ ja ] = "VARPA"; + Text[ ko ] = "VARPA"; + Text[ zh-CN ] = "VARPA"; + Text[ zh-TW ] = "VARPA"; + Text[ tr ] = "DEĞİŞKENPA"; + Text[ hi-IN ] = "VARPA"; + Text[ ar ] = "VARPA"; + Text[ he ] = "VARIANZENA"; + }; + String SC_OPCODE_ST_DEV + { + Text [ de ] = "STABW" ; + Text [ en-US ] = "STDEV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DESV.PAD"; + Text[ ru ] = "СТÐÐДОТКЛОÐ"; + Text[ el ] = "STDEV"; + Text[ nl ] = "STDEV"; + Text[ fr ] = "ECARTYPE"; + Text[ es ] = "DESVEST"; + Text[ fi ] = "KESKIHAJONTA"; + Text[ ca ] = "STDEV"; + Text[ it ] = "DEV.ST"; + Text[ da ] = "STDAFV"; + Text[ sv ] = "STDAV"; + Text[ pl ] = "STDEV"; + Text[ pt-BR ] = "DESVPAD"; + Text[ th ] = "STDEV"; + Text[ ja ] = "STDEV"; + Text[ ko ] = "STDEV"; + Text[ zh-CN ] = "STDEV"; + Text[ zh-TW ] = "STDEV"; + Text[ tr ] = "STSAPMA"; + Text[ hi-IN ] = "STDEV"; + Text[ ar ] = "STDEV"; + Text[ he ] = "STABW"; + }; + String SC_OPCODE_ST_DEV_A + { + Text [ de ] = "STABWA" ; + Text [ en-US ] = "STDEVA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DESV.PADA"; + Text[ ru ] = "СТÐÐДОТКЛОÐÐ"; + Text[ el ] = "STDEVA"; + Text[ nl ] = "STDEVA"; + Text[ fr ] = "ECARTYPEA"; + Text[ es ] = "DESVESTA"; + Text[ fi ] = "KESKIHAJONTAA"; + Text[ ca ] = "STDEVA"; + Text[ it ] = "DEV.ST.VALORI"; + Text[ da ] = "STDAFVV"; + Text[ sv ] = "STDAVA"; + Text[ pl ] = "STDEVA"; + Text[ pt-BR ] = "DESVPADA"; + Text[ th ] = "STDEVA"; + Text[ ja ] = "STDEVA"; + Text[ ko ] = "STDEVA"; + Text[ zh-CN ] = "STDEVA"; + Text[ zh-TW ] = "STDEVA"; + Text[ tr ] = "STSAPMAA"; + Text[ hi-IN ] = "STDEVA"; + Text[ ar ] = "STDEVA"; + Text[ he ] = "STABWA"; + }; + String SC_OPCODE_ST_DEV_P + { + Text [ de ] = "STABWN" ; + Text [ en-US ] = "STDEVP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DESV.PAD.P"; + Text[ ru ] = "СТÐÐДОТКЛОÐП"; + Text[ el ] = "STDEVP"; + Text[ nl ] = "STDEVP"; + Text[ fr ] = "ECARTYPEP"; + Text[ es ] = "DESVESTP"; + Text[ fi ] = "KESKIHAJONTAP"; + Text[ ca ] = "STDEVP"; + Text[ it ] = "DEV.ST.POP"; + Text[ da ] = "STDAFVP"; + Text[ sv ] = "STDAVP"; + Text[ pl ] = "STDEVP"; + Text[ pt-BR ] = "DESVPADP"; + Text[ th ] = "STDEVP"; + Text[ ja ] = "STDEVP"; + Text[ ko ] = "STDEVP"; + Text[ zh-CN ] = "STDEVP"; + Text[ zh-TW ] = "STDEVP"; + Text[ tr ] = "STSAPMAP"; + Text[ hi-IN ] = "STDEVP"; + Text[ ar ] = "STDEVP"; + Text[ he ] = "STABWN"; + }; + String SC_OPCODE_ST_DEV_P_A + { + Text [ de ] = "STABWNA" ; + Text [ en-US ] = "STDEVPA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DESV.PAD.PA"; + Text[ ru ] = "СТÐÐДОТКЛОÐПÐ"; + Text[ el ] = "STDEVPA"; + Text[ nl ] = "STDEVPA"; + Text[ fr ] = "ECARTYPEPA"; + Text[ es ] = "DESVESTPA"; + Text[ fi ] = "KESKIHAJONTAPA"; + Text[ ca ] = "STDEVPA"; + Text[ it ] = "DEV.ST.POP.VALORI"; + Text[ da ] = "STDAFVPV"; + Text[ sv ] = "STDAVPA"; + Text[ pl ] = "STDEVPA"; + Text[ pt-BR ] = "DESVPADPA"; + Text[ th ] = "STDEVPA"; + Text[ ja ] = "STDEVPA"; + Text[ ko ] = "STDEVPA"; + Text[ zh-CN ] = "STDEVPA"; + Text[ zh-TW ] = "STDEVPA"; + Text[ tr ] = "STSAPMAPA"; + Text[ hi-IN ] = "STDEVPA"; + Text[ ar ] = "STDEVPA"; + Text[ he ] = "STABWNA"; + }; + String SC_OPCODE_B + { + Text [ de ] = "B"; + Text [ en-US ] = "B"; + Text[ pt ] = "B"; + Text[ ru ] = "B"; + Text[ el ] = "B"; + Text[ nl ] = "B"; + Text[ fr ] = "B"; + Text[ es ] = "B"; + Text[ fi ] = "B"; + Text[ ca ] = "B"; + Text[ it ] = "B"; + Text[ da ] = "B"; + Text[ sv ] = "B"; + Text[ pl ] = "B"; + Text[ pt-BR ] = "B"; + Text[ th ] = "B"; + Text[ ja ] = "B"; + Text[ ko ] = "B"; + Text[ zh-CN ] = "B"; + Text[ zh-TW ] = "B"; + Text[ tr ] = "B"; + Text[ hi-IN ] = "B"; + Text[ ar ] = "B"; + Text[ he ] = "B"; + }; + String SC_OPCODE_NORM_DIST + { + Text [ de ] = "NORMVERT" ; + Text [ en-US ] = "NORMDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.NORM"; + Text[ ru ] = "ÐОРМРÐСП"; + Text[ el ] = "NORMDIST"; + Text[ nl ] = "NORM.VERD"; + Text[ fr ] = "LOI.NORMALE"; + Text[ es ] = "DISTR.NORM"; + Text[ fi ] = "NORM_JAKAUMA"; + Text[ ca ] = "NORMDIST"; + Text[ it ] = "DISTRIB.NORM"; + Text[ da ] = "NORMFORDELING"; + Text[ sv ] = "NORMFÖRD"; + Text[ pl ] = "NORMDIST"; + Text[ pt-BR ] = "DIST.NORM"; + Text[ th ] = "NORMDIST"; + Text[ ja ] = "NORMDIST"; + Text[ ko ] = "NORMDIST"; + Text[ zh-CN ] = "NORMDIST"; + Text[ zh-TW ] = "NORMDIST"; + Text[ tr ] = "NORMALDAÄžILIM"; + Text[ hi-IN ] = "NORMDIST"; + Text[ ar ] = "NORMDIST"; + Text[ he ] = "NORMVERT"; + }; + String SC_OPCODE_EXP_DIST + { + Text [ de ] = "EXPONVERT" ; + Text [ en-US ] = "EXPONDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.EXPON"; + Text[ ru ] = "ÐКСПРÐСП"; + Text[ el ] = "EXPONDIST"; + Text[ nl ] = "EXPON.VERD"; + Text[ fr ] = "LOI.EXPONENTIELLE"; + Text[ es ] = "DISTR.EXP"; + Text[ fi ] = "EKSPONENTIAALIJAKAUMA"; + Text[ ca ] = "EXPONDIST"; + Text[ it ] = "DISTRIB.EXP"; + Text[ da ] = "EKSPFORDELING"; + Text[ sv ] = "EXPONFÖRD"; + Text[ pl ] = "EXPONDIST"; + Text[ pt-BR ] = "DISTEXPON"; + Text[ th ] = "EXPONDIST"; + Text[ ja ] = "EXPONDIST"; + Text[ ko ] = "EXPONDIST"; + Text[ zh-CN ] = "EXPONDIST"; + Text[ zh-TW ] = "EXPONDIST"; + Text[ tr ] = "ÃœSTELDAÄžILIM"; + Text[ hi-IN ] = "EXPONDIST"; + Text[ ar ] = "EXPONDIST"; + Text[ he ] = "EXPONVERT"; + }; + String SC_OPCODE_BINOM_DIST + { + Text [ de ] = "BINOMVERT" ; + Text [ en-US ] = "BINOMDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DISTR.BINOM"; + Text[ ru ] = "БИÐОМРÐСП"; + Text[ el ] = "BINOMDIST"; + Text[ nl ] = "BINOMIALE.VERD"; + Text[ fr ] = "LOI.BINOMIALE"; + Text[ es ] = "DISTR.BINOM"; + Text[ fi ] = "BINOMIJAKAUMA"; + Text[ ca ] = "BINOMDIST"; + Text[ it ] = "DISTRIB.BINOM"; + Text[ da ] = "BINOMINALFORDELING"; + Text[ sv ] = "BINOMFÖRD"; + Text[ pl ] = "BINOMDIST"; + Text[ pt-BR ] = "DISTRBINOM"; + Text[ th ] = "BINOMDIST"; + Text[ ja ] = "BINOMDIST"; + Text[ ko ] = "BINOMDIST"; + Text[ zh-CN ] = "BINOMDIST"; + Text[ zh-TW ] = "BINOMDIST"; + Text[ tr ] = "BÄ°NOMDAÄžILIMI"; + Text[ hi-IN ] = "BINOMDIST"; + Text[ ar ] = "BINOMDIST"; + Text[ he ] = "BINOMVERT"; + }; + String SC_OPCODE_POISSON_DIST + { + Text [ de ] = "POISSON" ; + Text [ en-US ] = "POISSON" ; + Text [ x-comment ] = " "; + Text[ pt ] = "POISSON"; + Text[ ru ] = "ПУÐССОÐ"; + Text[ el ] = "POISSON"; + Text[ nl ] = "POISSON"; + Text[ fr ] = "LOI.POISSON"; + Text[ es ] = "POISSON"; + Text[ fi ] = "POISSON"; + Text[ ca ] = "POISSON"; + Text[ it ] = "POISSON"; + Text[ da ] = "POISSON"; + Text[ sv ] = "POISSON"; + Text[ pl ] = "POISSON"; + Text[ pt-BR ] = "POISSON"; + Text[ th ] = "POISSON"; + Text[ ja ] = "POISSON"; + Text[ ko ] = "POISSON"; + Text[ zh-CN ] = "POISSON"; + Text[ zh-TW ] = "POISSON"; + Text[ tr ] = "POISSON"; + Text[ hi-IN ] = "POISSON"; + Text[ ar ] = "POISSON"; + Text[ he ] = "POISSON"; + }; + String SC_OPCODE_KOMBIN + { + Text [ de ] = "KOMBINATIONEN" ; + Text [ en-US ] = "COMBIN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COMBIN"; + Text[ ru ] = "ЧИСЛКОМБ"; + Text[ el ] = "COMBIN"; + Text[ nl ] = "COMBINATIES"; + Text[ fr ] = "COMBIN"; + Text[ es ] = "COMBINAR"; + Text[ fi ] = "KOMBINAATIO"; + Text[ ca ] = "COMBIN"; + Text[ it ] = "COMBINAZIONE"; + Text[ da ] = "KOMBIN"; + Text[ sv ] = "KOMBIN"; + Text[ pl ] = "COMBIN"; + Text[ pt-BR ] = "COMBIN"; + Text[ th ] = "COMBIN"; + Text[ ja ] = "COMBIN"; + Text[ ko ] = "COMBIN"; + Text[ zh-CN ] = "COMBIN"; + Text[ zh-TW ] = "COMBIN"; + Text[ tr ] = "KOMBÄ°NASYON"; + Text[ hi-IN ] = "COMBIN"; + Text[ ar ] = "COMBIN"; + Text[ he ] = "KOMBINATIONEN"; + }; + String SC_OPCODE_KOMBIN_2 + { + Text [ de ] = "KOMBINATIONEN2" ; + Text [ en-US ] = "COMBINA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COMBIN2"; + Text[ ru ] = "ЧИСЛКОМБ2"; + Text[ el ] = "COMBINA"; + Text[ nl ] = "COMBINATIES2"; + Text[ fr ] = "COMBINA"; + Text[ es ] = "COMBINAR2"; + Text[ fi ] = "KOMBINAATIOA"; + Text[ ca ] = "COMBINA"; + Text[ it ] = "COMBINA"; + Text[ da ] = "KOMBIN2"; + Text[ sv ] = "KOMBIN2"; + Text[ pl ] = "COMBINA"; + Text[ pt-BR ] = "COMBINA"; + Text[ th ] = "COMBINA"; + Text[ ja ] = "COMBINA"; + Text[ ko ] = "COMBINA"; + Text[ zh-CN ] = "COMBINA"; + Text[ zh-TW ] = "COMBINA"; + Text[ tr ] = "KOMBÄ°NASYONA"; + Text[ hi-IN ] = "COMBINA"; + Text[ ar ] = "COMBINA"; + Text[ he ] = "KOMBINATIONEN2"; + }; + String SC_OPCODE_VARIATIONEN + { + Text [ de ] = "VARIATIONEN" ; + Text [ en-US ] = "PERMUT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PERMUTAÇÃO"; + Text[ ru ] = "ПЕРЕСТ"; + Text[ el ] = "PERMUT"; + Text[ nl ] = "PERMUTATIES"; + Text[ fr ] = "PERMUTATION"; + Text[ es ] = "PERMUTACIONES"; + Text[ fi ] = "PERMUTAATIO"; + Text[ ca ] = "PERMUT"; + Text[ it ] = "PERMUTAZIONE"; + Text[ da ] = "PERMUT"; + Text[ sv ] = "PERMUT"; + Text[ pl ] = "PERMUT"; + Text[ pt-BR ] = "PERMUT"; + Text[ th ] = "à¸à¸²à¸£à¹à¸›à¸£à¸œà¸±à¸™"; + Text[ ja ] = "PERMUT"; + Text[ ko ] = "PERMUT"; + Text[ zh-CN ] = "PERMUT"; + Text[ zh-TW ] = "PERMUT"; + Text[ tr ] = "PERMUTASYON"; + Text[ hi-IN ] = "PERMUT"; + Text[ ar ] = "PERMUT"; + Text[ he ] = "VARIATIONEN"; + }; + String SC_OPCODE_VARIATIONEN_2 + { + Text [ de ] = "VARIATIONEN2" ; + Text [ en-US ] = "PERMUTATIONA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COMBIN"; + Text[ ru ] = "ПЕРЕСТ2"; + Text[ el ] = "PERMUTATIONA"; + Text[ nl ] = "PERMUTATIES2"; + Text[ fr ] = "PERMUTATIONA"; + Text[ es ] = "PERMUTACIONESA"; + Text[ fi ] = "PERMUTAATIOA"; + Text[ ca ] = "PERMUTATIONA"; + Text[ it ] = "PERMUTAZIONA"; + Text[ da ] = "PERMUT2"; + Text[ sv ] = "PERMUT2"; + Text[ pl ] = "PERMUTATIONA"; + Text[ pt-BR ] = "PERMUTAÇÂOA"; + Text[ th ] = "PERMUTATIONA"; + Text[ ja ] = "PERMUTATIONA"; + Text[ ko ] = "PERMUTATIONA"; + Text[ zh-CN ] = "PERMUTATIONA"; + Text[ zh-TW ] = "PERMUTATIONA"; + Text[ tr ] = "PERMUTASYONA"; + Text[ hi-IN ] = "PERMUTATIONA"; + Text[ ar ] = "PERMUTATIONA"; + Text[ he ] = "VARIATIONEN2"; + }; + String SC_OPCODE_BW + { + Text [ de ] = "BW" ; + Text [ en-US ] = "PV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VA"; + Text[ ru ] = "ТЗ"; + Text[ el ] = "PV"; + Text[ nl ] = "HW"; + Text[ fr ] = "VA"; + Text[ es ] = "VA"; + Text[ fi ] = "NA"; + Text[ ca ] = "PV"; + Text[ it ] = "VA"; + Text[ da ] = "NV"; + Text[ sv ] = "NUVÄRDE"; + Text[ pl ] = "PV"; + Text[ pt-BR ] = "VP"; + Text[ th ] = "PV"; + Text[ ja ] = "PV"; + Text[ ko ] = "PV"; + Text[ zh-CN ] = "PV"; + Text[ zh-TW ] = "PV"; + Text[ tr ] = "BUGÃœNKÃœDEÄžER"; + Text[ hi-IN ] = "PV"; + Text[ ar ] = "PV"; + Text[ he ] = "BW"; + }; + String SC_OPCODE_DIA + { + Text [ de ] = "DIA" ; + Text [ en-US ] = "SYD" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SYD"; + Text[ ru ] = "ÐМГД"; + Text[ el ] = "SYD"; + Text[ nl ] = "SYD"; + Text[ fr ] = "SYD"; + Text[ es ] = "SYD"; + Text[ fi ] = "VUOSIPOISTO"; + Text[ ca ] = "SYD"; + Text[ it ] = "AMMORT.ANNUO"; + Text[ da ] = "Ã…RSAFSKRIVNING"; + Text[ sv ] = "Ã…RSAVSKR"; + Text[ pl ] = "SYD"; + Text[ pt-BR ] = "SDA"; + Text[ th ] = "ภาพนิ่ง"; + Text[ ja ] = "SYD"; + Text[ ko ] = "SYD"; + Text[ zh-CN ] = "SYD"; + Text[ zh-TW ] = "SYD"; + Text[ tr ] = "ARÄ°TMETÄ°KAMORTÄ°SMANAZALMAORANI"; + Text[ hi-IN ] = "SYD"; + Text[ ar ] = "SYD"; + Text[ he ] = "DIA"; + }; + String SC_OPCODE_GDA + { + Text [ de ] = "GDA" ; + Text [ en-US ] = "DDB" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDD"; + Text[ ru ] = "ДДОБ"; + Text[ el ] = "DDB"; + Text[ nl ] = "DDB"; + Text[ fr ] = "DDB"; + Text[ es ] = "DDB"; + Text[ fi ] = "DDB"; + Text[ ca ] = "DDB"; + Text[ it ] = "AMMORT"; + Text[ da ] = "DSA"; + Text[ sv ] = "DEGAVSKR"; + Text[ pl ] = "DDB"; + Text[ pt-BR ] = "BDD"; + Text[ th ] = "DDB"; + Text[ ja ] = "DDB"; + Text[ ko ] = "DDB"; + Text[ zh-CN ] = "DDB"; + Text[ zh-TW ] = "DDB"; + Text[ tr ] = "AMORTÄ°SMAN(Aritmetik azaltma metodu)"; + Text[ hi-IN ] = "DDB"; + Text[ ar ] = "DDB"; + Text[ he ] = "GDA"; + }; + String SC_OPCODE_GDA_2 + { + Text [ de ] = "GDA2" ; + Text [ en-US ] = "DB" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BD"; + Text[ ru ] = "ДОБ"; + Text[ el ] = "DB"; + Text[ nl ] = "DB"; + Text[ fr ] = "DB"; + Text[ es ] = "DB"; + Text[ fi ] = "DB"; + Text[ ca ] = "DB"; + Text[ it ] = "AMMORT.FISSO"; + Text[ da ] = "DB"; + Text[ sv ] = "DB"; + Text[ pl ] = "DB"; + Text[ pt-BR ] = "BD"; + Text[ th ] = "DB"; + Text[ ja ] = "DB"; + Text[ ko ] = "DB"; + Text[ zh-CN ] = "DB"; + Text[ zh-TW ] = "DB"; + Text[ tr ] = "AMORTÄ°SMAN(Çifte azaltma metodu)"; + Text[ hi-IN ] = "DB"; + Text[ ar ] = "DB"; + Text[ he ] = "GDA2"; + }; + String SC_OPCODE_VBD + { + Text [ de ] = "VDB" ; + Text [ en-US ] = "VDB" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDV"; + Text[ ru ] = "ПДОБ"; + Text[ el ] = "VDB"; + Text[ nl ] = "VDB"; + Text[ fr ] = "VDB"; + Text[ es ] = "DVS"; + Text[ fi ] = "VDB"; + Text[ ca ] = "VDB"; + Text[ it ] = "AMMORT.VAR"; + Text[ da ] = "VSA"; + Text[ sv ] = "VDEGRAVSKR"; + Text[ pl ] = "VDB"; + Text[ pt-BR ] = "BDV"; + Text[ th ] = "VDB"; + Text[ ja ] = "VDB"; + Text[ ko ] = "VDB"; + Text[ zh-CN ] = "VDB"; + Text[ zh-TW ] = "VDB"; + Text[ tr ] = "AMORTÄ°SMAN(DeÄŸiÅŸken azaltma metodu)"; + Text[ hi-IN ] = "VDB"; + Text[ ar ] = "VDB"; + Text[ he ] = "VDB"; + }; + String SC_OPCODE_LAUFZ + { + Text [ de ] = "LAUFZEIT" ; + Text [ en-US ] = "DURATION" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DURAÇÃO"; + Text[ ru ] = "ПРОДОЛЖИТ"; + Text[ el ] = "DURATION"; + Text[ nl ] = "DUUR"; + Text[ fr ] = "DUREE"; + Text[ es ] = "PLAZO"; + Text[ fi ] = "KESTO"; + Text[ ca ] = "DURATION"; + Text[ it ] = "DURATA"; + Text[ da ] = "VARIGHED"; + Text[ sv ] = "LÖPTID"; + Text[ pl ] = "DURATION"; + Text[ pt-BR ] = "DURAÇÃO"; + Text[ th ] = "DURATION"; + Text[ ja ] = "DURATION"; + Text[ ko ] = "DURATION"; + Text[ zh-CN ] = "DURATION"; + Text[ zh-TW ] = "DURATION"; + Text[ tr ] = "SÃœRE"; + Text[ hi-IN ] = "DURATION"; + Text[ ar ] = "DURATION"; + Text[ he ] = "LAUFZEIT"; + }; + String SC_OPCODE_LIA + { + Text [ de ] = "LIA" ; + Text [ en-US ] = "SLN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "AMORLINC"; + Text[ ru ] = "ÐМР"; + Text[ el ] = "SLN"; + Text[ nl ] = "LIN.AFSCHR"; + Text[ fr ] = "AMORLIN"; + Text[ es ] = "SLN"; + Text[ fi ] = "STP"; + Text[ ca ] = "SLN"; + Text[ it ] = "AMMORT.COST"; + Text[ da ] = "LA"; + Text[ sv ] = "LINAVSKR"; + Text[ pl ] = "SLN"; + Text[ pt-BR ] = "DPD"; + Text[ th ] = "SLN"; + Text[ ja ] = "SLN"; + Text[ ko ] = "SLN"; + Text[ zh-CN ] = "SLN"; + Text[ zh-TW ] = "SLN"; + Text[ tr ] = "DOÄžRUSALAMORTÄ°SMAN"; + Text[ hi-IN ] = "SLN"; + Text[ ar ] = "SLN"; + Text[ he ] = "LIA"; + }; + String SC_OPCODE_RMZ + { + Text [ de ] = "RMZ" ; + Text [ en-US ] = "PMT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PGTO"; + Text[ ru ] = "ППЛÐТ"; + Text[ el ] = "PMT"; + Text[ nl ] = "RMB"; + Text[ fr ] = "VPM"; + Text[ es ] = "PAGO"; + Text[ fi ] = "MAKSU"; + Text[ ca ] = "PMT"; + Text[ it ] = "RATA"; + Text[ da ] = "YDELSE"; + Text[ sv ] = "BETALNING"; + Text[ pl ] = "PMT"; + Text[ pt-BR ] = "PGTO"; + Text[ th ] = "PMT"; + Text[ ja ] = "PMT"; + Text[ ko ] = "PMT"; + Text[ zh-CN ] = "PMT"; + Text[ zh-TW ] = "PMT"; + Text[ tr ] = "ÖDEMEPERÄ°YODU"; + Text[ hi-IN ] = "PMT"; + Text[ ar ] = "PMT"; + Text[ he ] = "RMZ"; + }; + String SC_OPCODE_COLUMNS + { + Text [ de ] = "SPALTEN" ; + Text [ en-US ] = "COLUMNS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COLUNAS"; + Text[ ru ] = "ЧИСЛСТОЛБ"; + Text[ el ] = "COLUMNS"; + Text[ nl ] = "KOLOMMEN"; + Text[ fr ] = "COLONNES"; + Text[ es ] = "COLUMNAS"; + Text[ fi ] = "SARAKKEET"; + Text[ ca ] = "COLUMNS"; + Text[ it ] = "COLONNE"; + Text[ da ] = "KOLONNER"; + Text[ sv ] = "KOLUMNER"; + Text[ pl ] = "COLUMNS"; + Text[ pt-BR ] = "COLS"; + Text[ th ] = "คà¸à¸¥à¸±à¸¡à¸™à¹Œ"; + Text[ ja ] = "COLUMNS"; + Text[ ko ] = "COLUMNS"; + Text[ zh-CN ] = "COLUMNS"; + Text[ zh-TW ] = "COLUMNS"; + Text[ tr ] = "SÃœTUNLAR"; + Text[ hi-IN ] = "COLUMNS"; + Text[ ar ] = "COLUMNS"; + Text[ he ] = "SPALTEN"; + }; + String SC_OPCODE_ROWS + { + Text [ de ] = "ZEILEN" ; + Text [ en-US ] = "ROWS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LINHAS"; + Text[ ru ] = "ЧСТРОК"; + Text[ el ] = "ROWS"; + Text[ nl ] = "RIJEN"; + Text[ fr ] = "LIGNES"; + Text[ es ] = "FILAS"; + Text[ fi ] = "RIVIT"; + Text[ ca ] = "ROWS"; + Text[ it ] = "RIGHE"; + Text[ da ] = "RÆKKER"; + Text[ sv ] = "RADER"; + Text[ pl ] = "ROWS"; + Text[ pt-BR ] = "LINS"; + Text[ th ] = "บรรทัด"; + Text[ ja ] = "ROWS"; + Text[ ko ] = "ROWS"; + Text[ zh-CN ] = "ROWS"; + Text[ zh-TW ] = "ROWS"; + Text[ tr ] = "SATIRLAR"; + Text[ hi-IN ] = "ROWS"; + Text[ ar ] = "ROWS"; + Text[ he ] = "ZEILEN"; + }; + String SC_OPCODE_TABLES + { + Text [ de ] = "TABELLEN" ; + Text [ en-US ] = "SHEETS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FOLHAS"; + Text[ ru ] = "ЛИСТЫ"; + Text[ el ] = "SHEETS"; + Text[ nl ] = "TABELLEN"; + Text[ fr ] = "FEUILLES"; + Text[ es ] = "HOJAS"; + Text[ fi ] = "TAULUKOT"; + Text[ ca ] = "SHEETS"; + Text[ it ] = "TABELLE"; + Text[ da ] = "TABELLER"; + Text[ sv ] = "TABELLER"; + Text[ pl ] = "SHEETS"; + Text[ pt-BR ] = "PLANILHAS"; + Text[ th ] = "ตาราง"; + Text[ ja ] = "SHEETS"; + Text[ ko ] = "SHEETS"; + Text[ zh-CN ] = "SHEETS"; + Text[ zh-TW ] = "SHEETS"; + Text[ tr ] = "TABLOLAR"; + Text[ hi-IN ] = "SHEETS"; + Text[ ar ] = "SHEETS"; + Text[ he ] = "TABELLEN"; + }; + String SC_OPCODE_COLUMN + { + Text [ de ] = "SPALTE" ; + Text [ en-US ] = "COLUMN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COLUNA"; + Text[ ru ] = "СТОЛБЕЦ"; + Text[ el ] = "COLUMN"; + Text[ nl ] = "KOLOM"; + Text[ fr ] = "COLONNE"; + Text[ es ] = "COLUMNA"; + Text[ fi ] = "SARAKE"; + Text[ ca ] = "COLUMN"; + Text[ it ] = "RIF.COLONNA"; + Text[ da ] = "KOLONNE"; + Text[ sv ] = "KOLUMN"; + Text[ pl ] = "COLUMN"; + Text[ pt-BR ] = "COLUNA"; + Text[ th ] = "คà¸à¸¥à¸±à¸¡à¸™à¹Œ "; + Text[ ja ] = "COLUMN"; + Text[ ko ] = "COLUMN"; + Text[ zh-CN ] = "COLUMN"; + Text[ zh-TW ] = "COLUMN"; + Text[ tr ] = "SÃœTUN"; + Text[ hi-IN ] = "COLUMN"; + Text[ ar ] = "COLUMN"; + Text[ he ] = "SPALTE"; + }; + String SC_OPCODE_ROW + { + Text [ de ] = "ZEILE" ; + Text [ en-US ] = "ROW" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LINHA"; + Text[ ru ] = "СТРОКÐ"; + Text[ el ] = "ROW"; + Text[ nl ] = "RIJ"; + Text[ fr ] = "LIGNE"; + Text[ es ] = "FILA"; + Text[ fi ] = "RIVI"; + Text[ ca ] = "ROW"; + Text[ it ] = "RIF.RIGA"; + Text[ da ] = "RÆKKE"; + Text[ sv ] = "RAD"; + Text[ pl ] = "ROW"; + Text[ pt-BR ] = "LINHA"; + Text[ th ] = "บรรทัด"; + Text[ ja ] = "ROW"; + Text[ ko ] = "ROW"; + Text[ zh-CN ] = "ROW"; + Text[ zh-TW ] = "ROW"; + Text[ tr ] = "SATIR"; + Text[ hi-IN ] = "ROW"; + Text[ ar ] = "ROW"; + Text[ he ] = "ZEILE"; + }; + String SC_OPCODE_TABLE + { + Text [ de ] = "TABELLE" ; + Text [ en-US ] = "SHEET" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FOLHA"; + Text[ ru ] = "ЛИСТ"; + Text[ el ] = "SHEET"; + Text[ nl ] = "TABEL"; + Text[ fr ] = "FEUILLE"; + Text[ es ] = "HOJA"; + Text[ fi ] = "TAULUKKO"; + Text[ ca ] = "SHEET"; + Text[ it ] = "TABELLA"; + Text[ da ] = "TABEL"; + Text[ sv ] = "TABELL"; + Text[ pl ] = "SHEET"; + Text[ pt-BR ] = "PLANILHA"; + Text[ th ] = "à¸à¸£à¸°à¸”าษคำนวณ"; + Text[ ja ] = "SHEET"; + Text[ ko ] = "SHEET"; + Text[ zh-CN ] = "SHEET"; + Text[ zh-TW ] = "SHEET"; + Text[ tr ] = "TABLO"; + Text[ hi-IN ] = "SHEET"; + Text[ ar ] = "SHEET"; + Text[ he ] = "TABELLE"; + }; + String SC_OPCODE_ZGZ + { + Text [ de ] = "ZGZ" ; + Text [ en-US ] = "RRI" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ZGZ"; + Text[ ru ] = "ГПС"; + Text[ el ] = "ZGZ"; + Text[ nl ] = "ZGZ"; + Text[ fr ] = "RENTINVEST"; + Text[ es ] = "INT.RENDIMIENTO"; + Text[ fi ] = "TUOTTOPROSENTTI"; + Text[ ca ] = "RRI"; + Text[ it ] = "INT.RENDIMENTO"; + Text[ da ] = "RRI"; + Text[ sv ] = "RRI"; + Text[ pl ] = "RRI"; + Text[ pt-BR ] = "TIR"; + Text[ th ] = "RRI"; + Text[ ja ] = "ZGZ"; + Text[ ko ] = "ZGZ"; + Text[ zh-CN ] = "ZGZ"; + Text[ zh-TW ] = "ZGZ"; + Text[ tr ] = "FAÄ°ZORANI"; + Text[ hi-IN ] = "RRI"; + Text[ ar ] = "ZGZ"; + Text[ he ] = "ZGZ"; + }; + String SC_OPCODE_ZW + { + Text [ de ] = "ZW" ; + Text [ en-US ] = "FV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VF"; + Text[ ru ] = "БЗ"; + Text[ el ] = "FV"; + Text[ nl ] = "TW"; + Text[ fr ] = "VC"; + Text[ es ] = "VF"; + Text[ fi ] = "TULEVA_ARVO"; + Text[ ca ] = "FV"; + Text[ it ] = "VAL.FUT"; + Text[ da ] = "FV"; + Text[ sv ] = "SLUTVÄRDE"; + Text[ pl ] = "FV"; + Text[ pt-BR ] = "VF"; + Text[ th ] = "FV"; + Text[ ja ] = "FV"; + Text[ ko ] = "FV"; + Text[ zh-CN ] = "FV"; + Text[ zh-TW ] = "FV"; + Text[ tr ] = "GELECEKDEÄžER"; + Text[ hi-IN ] = "FV"; + Text[ ar ] = "FV"; + Text[ he ] = "ZW"; + }; + String SC_OPCODE_ZZR + { + Text [ de ] = "ZZR" ; + Text [ en-US ] = "NPER" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NPER"; + Text[ ru ] = "КПЕР"; + Text[ el ] = "NPER"; + Text[ nl ] = "NPER"; + Text[ fr ] = "NPM"; + Text[ es ] = "NPER"; + Text[ fi ] = "NJAKSO"; + Text[ ca ] = "NPER"; + Text[ it ] = "NUM.RATE"; + Text[ da ] = "NPER"; + Text[ sv ] = "PERIODER"; + Text[ pl ] = "NPER"; + Text[ pt-BR ] = "NPER"; + Text[ th ] = "NPER"; + Text[ ja ] = "NPER"; + Text[ ko ] = "NPER"; + Text[ zh-CN ] = "NPER"; + Text[ zh-TW ] = "NPER"; + Text[ tr ] = "PERÄ°YOTSAYISI"; + Text[ hi-IN ] = "NPER"; + Text[ ar ] = "NPER"; + Text[ he ] = "ZZR"; + }; + String SC_OPCODE_ZINS + { + Text [ de ] = "ZINS" ; + Text [ en-US ] = "RATE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TAXA"; + Text[ ru ] = "СТÐВКÐ"; + Text[ el ] = "RATE"; + Text[ nl ] = "RENTE"; + Text[ fr ] = "TAUX"; + Text[ es ] = "TASA"; + Text[ fi ] = "KORKO"; + Text[ ca ] = "RATE"; + Text[ it ] = "TASSO"; + Text[ da ] = "RENTE"; + Text[ sv ] = "RÄNTA"; + Text[ pl ] = "RATE"; + Text[ pt-BR ] = "TAXA"; + Text[ th ] = "à¸à¸±à¸•à¸£à¸²"; + Text[ ja ] = "RATE"; + Text[ ko ] = "RATE"; + Text[ zh-CN ] = "RATE"; + Text[ zh-TW ] = "RATE"; + Text[ tr ] = "ORAN"; + Text[ hi-IN ] = "RATE"; + Text[ ar ] = "RATE"; + Text[ he ] = "ZINS"; + }; + String SC_OPCODE_ZINS_Z + { + Text [ de ] = "ZINSZ" ; + Text [ en-US ] = "IPMT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PPGTO"; + Text[ ru ] = "ПЛПРОЦ"; + Text[ el ] = "IPMT"; + Text[ nl ] = "IBET"; + Text[ fr ] = "INTPER"; + Text[ es ] = "PAGOINT"; + Text[ fi ] = "IPMT"; + Text[ ca ] = "IPMT"; + Text[ it ] = "P.RATA"; + Text[ da ] = "R.YDELSE"; + Text[ sv ] = "RBETALNING"; + Text[ pl ] = "IPMT"; + Text[ pt-BR ] = "IPGTO"; + Text[ th ] = "IPMT"; + Text[ ja ] = "IPMT"; + Text[ ko ] = "IPMT"; + Text[ zh-CN ] = "IPMT"; + Text[ zh-TW ] = "IPMT"; + Text[ tr ] = "ÖDEME (Sermaye)"; + Text[ hi-IN ] = "IPMT"; + Text[ ar ] = "IPMT"; + Text[ he ] = "ZINSZ"; + }; + String SC_OPCODE_KAPZ + { + Text [ de ] = "KAPZ" ; + Text [ en-US ] = "PPMT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "IPGTO"; + Text[ ru ] = "ОСÐПЛÐТ"; + Text[ el ] = "PPMT"; + Text[ nl ] = "PBET"; + Text[ fr ] = "PRINCPER"; + Text[ es ] = "AMORTIZACION"; + Text[ fi ] = "PPMT"; + Text[ ca ] = "PPMT"; + Text[ it ] = "INTERESSI"; + Text[ da ] = "H.YDELSE"; + Text[ sv ] = "AMORT"; + Text[ pl ] = "PPMT"; + Text[ pt-BR ] = "PPGTO"; + Text[ th ] = "PPMT"; + Text[ ja ] = "PPMT"; + Text[ ko ] = "PPMT"; + Text[ zh-CN ] = "PPMT"; + Text[ zh-TW ] = "PPMT"; + Text[ tr ] = "ÖDEME (periyodik,sabit faiz)"; + Text[ hi-IN ] = "PPMT"; + Text[ ar ] = "PPMT"; + Text[ he ] = "KAPZ"; + }; + String SC_OPCODE_KUM_ZINS_Z + { + Text [ de ] = "KUMZINSZ" ; + Text [ en-US ] = "CUMIPMT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PGTOJURACUM"; + Text[ ru ] = "ОБЩПЛÐТÐ"; + Text[ el ] = "CUMIPMT"; + Text[ nl ] = "CUM.RENTE"; + Text[ fr ] = "CUMUL.INTER"; + Text[ es ] = "PAGO.INT.ENTRE"; + Text[ fi ] = "MAKSETTU_KORKO"; + Text[ ca ] = "CUMIPMT"; + Text[ it ] = "INT.CUMUL"; + Text[ da ] = "AKKUM.RENTE"; + Text[ sv ] = "KUMRÄNTA"; + Text[ pl ] = "CUMIPMT"; + Text[ pt-BR ] = "PGTOJURACUM"; + Text[ th ] = "CUMIPMT"; + Text[ ja ] = "CUMIPMT"; + Text[ ko ] = "CUMIPMT"; + Text[ zh-CN ] = "CUMIPMT"; + Text[ zh-TW ] = "CUMIPMT"; + Text[ tr ] = "KÃœMÃœLATÄ°FÖDEME (Sermaye)"; + Text[ hi-IN ] = "CUMIPMT"; + Text[ ar ] = "CUMIPMT"; + Text[ he ] = "KUMZINSZ"; + }; + String SC_OPCODE_KUM_KAP_Z + { + Text [ de ] = "KUMKAPITAL" ; + Text [ en-US ] = "CUMPRINC" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PGTOCAPACUM"; + Text[ ru ] = "ОБЩДОХОД"; + Text[ el ] = "CUMPRINC"; + Text[ nl ] = "CUM.HOOFDSOM"; + Text[ fr ] = "CUMUL.PRINCPER"; + Text[ es ] = "PAGO.PRINC.ENTRE"; + Text[ fi ] = "MAKSETTU_LYHENNYS"; + Text[ ca ] = "CUMPRINC"; + Text[ it ] = "CAP.CUM"; + Text[ da ] = "AKKUM.HOVEDSTOL"; + Text[ sv ] = "KUMPRIS"; + Text[ pl ] = "CUMPRINC"; + Text[ pt-BR ] = "PGTOCAPACUM"; + Text[ th ] = "CUMPRINC"; + Text[ ja ] = "CUMPRINC"; + Text[ ko ] = "CUMPRINC"; + Text[ zh-CN ] = "CUMPRINC"; + Text[ zh-TW ] = "CUMPRINC"; + Text[ tr ] = "KÃœMÃœLATÄ°FSERMAYE"; + Text[ hi-IN ] = "CUMPRINC"; + Text[ ar ] = "CUMPRINC"; + Text[ he ] = "KUMKAPITAL"; + }; + String SC_OPCODE_EFFEKTIV + { + Text [ de ] = "EFFEKTIV" ; + Text [ en-US ] = "EFFECTIVE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "EFECTIVA"; + Text[ ru ] = "ÐФФЕКТПРОЦ"; + Text[ el ] = "EFFECTIVE"; + Text[ nl ] = "EFFECT.RENTE"; + Text[ fr ] = "TAUX.EFFECTIF"; + Text[ es ] = "INT.EFECTIVO"; + Text[ fi ] = "TODELLINEN"; + Text[ ca ] = "EFFECTIVE"; + Text[ it ] = "EFFETTIVO"; + Text[ da ] = "EFFEKTIV"; + Text[ sv ] = "EFFRÄNTA"; + Text[ pl ] = "EFFECTIVE"; + Text[ pt-BR ] = "EFETIVA"; + Text[ th ] = "EFFECTIVE"; + Text[ ja ] = "EFFECTIVE"; + Text[ ko ] = "EFFECTIVE"; + Text[ zh-CN ] = "EFFECTIVE"; + Text[ zh-TW ] = "EFFECTIVE"; + Text[ tr ] = "EFFEKTÄ°F"; + Text[ hi-IN ] = "EFFECTIVE"; + Text[ ar ] = "EFFECTIVE"; + Text[ he ] = "EFFEKTIV"; + }; + String SC_OPCODE_NOMINAL + { + Text [ de ] = "NOMINAL" ; + Text [ en-US ] = "NOMINAL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NOMINAL"; + Text[ ru ] = "ÐОМИÐÐЛ"; + Text[ el ] = "NOMINAL"; + Text[ nl ] = "NOMINALE.RENTE"; + Text[ fr ] = "TAUX.NOMINAL"; + Text[ es ] = "TASA.NOMINAL"; + Text[ fi ] = "KORKO_VUOSI"; + Text[ ca ] = "NOMINAL"; + Text[ it ] = "NOMINALE"; + Text[ da ] = "NOMINEL"; + Text[ sv ] = "NOMRÄNTA"; + Text[ pl ] = "NOMINAL"; + Text[ pt-BR ] = "NOMINAL"; + Text[ th ] = "NOMINAL"; + Text[ ja ] = "NOMINAL"; + Text[ ko ] = "NOMINAL"; + Text[ zh-CN ] = "NOMINAL"; + Text[ zh-TW ] = "NOMINAL"; + Text[ tr ] = "NOMÄ°NAL"; + Text[ hi-IN ] = "NOMINAL"; + Text[ ar ] = "NOMINAL"; + Text[ he ] = "NOMINAL"; + }; + String SC_OPCODE_SUB_TOTAL + { + Text [ de ] = "TEILERGEBNIS" ; + Text [ en-US ] = "SUBTOTAL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SUBTOTAL"; + Text[ ru ] = "ПРОМЕЖУТОЧÐЫЕ_ИТОГИ"; + Text[ el ] = "SUBTOTAL"; + Text[ nl ] = "SUBTOTAAL"; + Text[ fr ] = "SOUS.TOTAL"; + Text[ es ] = "SUBTOTALES"; + Text[ fi ] = "VÄLISUMMA"; + Text[ ca ] = "SUBTOTAL"; + Text[ it ] = "SUBTOTALE"; + Text[ da ] = "SUBTOTAL"; + Text[ sv ] = "DELSUMMA"; + Text[ pl ] = "SUBTOTAL"; + Text[ pt-BR ] = "SUBTOTAL"; + Text[ th ] = "ฟังà¸à¹Œà¸Šà¸±à¹ˆà¸™à¸œà¸¥à¸¥à¸±à¸žà¸˜à¹Œ"; + Text[ ja ] = "SUBTOTAL"; + Text[ ko ] = "SUBTOTAL"; + Text[ zh-CN ] = "SUBTOTAL"; + Text[ zh-TW ] = "SUBTOTAL"; + Text[ tr ] = "ARATOPLAM"; + Text[ hi-IN ] = "SUBTOTAL"; + Text[ ar ] = "SUBTOTAL"; + Text[ he ] = "TEILERGEBNIS"; + }; + String SC_OPCODE_DB_SUM + { + Text [ de ] = "DBSUMME" ; + Text [ en-US ] = "DSUM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDSOMA"; + Text[ ru ] = "БДСУММ"; + Text[ el ] = "DSUM"; + Text[ nl ] = "DBSOM"; + Text[ fr ] = "BDSOMME"; + Text[ es ] = "BDSUMA"; + Text[ fi ] = "TSUMMA"; + Text[ ca ] = "DSUM"; + Text[ it ] = "DB.SOMMA"; + Text[ da ] = "DSUM"; + Text[ sv ] = "DSUMMA"; + Text[ pl ] = "DSUM"; + Text[ pt-BR ] = "BDSOMA"; + Text[ th ] = "DSUM"; + Text[ ja ] = "DSUM"; + Text[ ko ] = "DSUM"; + Text[ zh-CN ] = "DSUM"; + Text[ zh-TW ] = "DSUM"; + Text[ tr ] = "VTOPLAM"; + Text[ hi-IN ] = "DSUM"; + Text[ ar ] = "DSUM"; + Text[ he ] = "DBSUMME"; + }; + String SC_OPCODE_DB_COUNT + { + Text [ de ] = "DBANZAHL" ; + Text [ en-US ] = "DCOUNT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDCONTAR"; + Text[ ru ] = "БСЧЕТ"; + Text[ el ] = "DCOUNT"; + Text[ nl ] = "DBAANTAL"; + Text[ fr ] = "BDNB"; + Text[ es ] = "BDCONTAR"; + Text[ fi ] = "TLASKE"; + Text[ ca ] = "DCOUNT"; + Text[ it ] = "DB.CONTA.NUMERI"; + Text[ da ] = "DTÆL"; + Text[ sv ] = "DANTAL"; + Text[ pl ] = "DCOUNT"; + Text[ pt-BR ] = "BDCONTAR"; + Text[ th ] = "DCOUNT"; + Text[ ja ] = "DCOUNT"; + Text[ ko ] = "DCOUNT"; + Text[ zh-CN ] = "DCOUNT"; + Text[ zh-TW ] = "DCOUNT"; + Text[ tr ] = "VSAY"; + Text[ hi-IN ] = "DCOUNT"; + Text[ ar ] = "DCOUNT"; + Text[ he ] = "DBANZAHL"; + }; + String SC_OPCODE_DB_COUNT_2 + { + Text [ de ] = "DBANZAHL2" ; + Text [ en-US ] = "DCOUNTA" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDCONTAR.VAL"; + Text[ ru ] = "БСЧЕТ2"; + Text[ el ] = "DCOUNTA"; + Text[ nl ] = "DBAANTALC"; + Text[ fr ] = "BDNBVAL"; + Text[ es ] = "BDCONTARA"; + Text[ fi ] = "TLASKEA"; + Text[ ca ] = "DCOUNTA"; + Text[ it ] = "DB.CONTA.VALORI"; + Text[ da ] = "DTÆLV"; + Text[ sv ] = "DANTALV"; + Text[ pl ] = "DCOUNTA"; + Text[ pt-BR ] = "BDCONTARA"; + Text[ th ] = "DCOUNTA"; + Text[ ja ] = "DCOUNTA"; + Text[ ko ] = "DCOUNTA"; + Text[ zh-CN ] = "DCOUNTA"; + Text[ zh-TW ] = "DCOUNTA"; + Text[ tr ] = "VSAYA"; + Text[ hi-IN ] = "DCOUNTA"; + Text[ ar ] = "DCOUNTA"; + Text[ he ] = "DBANZAHL2"; + }; + String SC_OPCODE_DB_AVERAGE + { + Text [ de ] = "DBMITTELWERT" ; + Text [ en-US ] = "DAVERAGE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDMÉDIA"; + Text[ ru ] = "ДСРЗÐÐЧ"; + Text[ el ] = "DAVERAGE"; + Text[ nl ] = "DBGEMIDDELDE"; + Text[ fr ] = "BDMOYENNE"; + Text[ es ] = "BDPROMEDIO"; + Text[ fi ] = "TKESKIARVO"; + Text[ ca ] = "DAVERAGE"; + Text[ it ] = "DB.MEDIA"; + Text[ da ] = "DMIDDEL"; + Text[ sv ] = "DMEDEL"; + Text[ pl ] = "DAVERAGE"; + Text[ pt-BR ] = "BDMÉDIA"; + Text[ th ] = "DAVERAGE"; + Text[ ja ] = "DAVERAGE"; + Text[ ko ] = "DAVERAGE"; + Text[ zh-CN ] = "DAVERAGE"; + Text[ zh-TW ] = "DAVERAGE"; + Text[ tr ] = "VORTALAMA"; + Text[ hi-IN ] = "DAVERAGE"; + Text[ ar ] = "DAVERAGE"; + Text[ he ] = "DBMITTELWERT"; + }; + String SC_OPCODE_DB_GET + { + Text [ de ] = "DBAUSZUG" ; + Text [ en-US ] = "DGET" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDOBTER"; + Text[ ru ] = "БИЗВЛЕЧЬ"; + Text[ el ] = "DGET"; + Text[ nl ] = "DBLEZEN"; + Text[ fr ] = "BDLIRE"; + Text[ es ] = "BDEXTRAER"; + Text[ fi ] = "TNOUDA"; + Text[ ca ] = "DGET"; + Text[ it ] = "DB.VALORI"; + Text[ da ] = "DHENT"; + Text[ sv ] = "DHÄMTA"; + Text[ pl ] = "DGET"; + Text[ pt-BR ] = "BDEXTRAIR"; + Text[ th ] = "DGET"; + Text[ ja ] = "DGET"; + Text[ ko ] = "DGET"; + Text[ zh-CN ] = "DGET"; + Text[ zh-TW ] = "DGET"; + Text[ tr ] = "VBUL"; + Text[ hi-IN ] = "DGET"; + Text[ ar ] = "DGET"; + Text[ he ] = "DBAUSZUG"; + }; + String SC_OPCODE_DB_MAX + { + Text [ de ] = "DBMAX" ; + Text [ en-US ] = "DMAX" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDMÃX"; + Text[ ru ] = "ДМÐКС"; + Text[ el ] = "DMAX"; + Text[ nl ] = "DBMAX"; + Text[ fr ] = "BDMAX"; + Text[ es ] = "BDMAX"; + Text[ fi ] = "TMAKS"; + Text[ ca ] = "DMAX"; + Text[ it ] = "DB.MAX"; + Text[ da ] = "DMAKS"; + Text[ sv ] = "DMAX"; + Text[ pl ] = "DMAX"; + Text[ pt-BR ] = "BDMÃX"; + Text[ th ] = "DMAX"; + Text[ ja ] = "DMAX"; + Text[ ko ] = "DMAX"; + Text[ zh-CN ] = "DMAX"; + Text[ zh-TW ] = "DMAX"; + Text[ tr ] = "VMAX"; + Text[ hi-IN ] = "DMAX"; + Text[ ar ] = "DMAX"; + Text[ he ] = "DBMAX"; + }; + String SC_OPCODE_DB_MIN + { + Text [ de ] = "DBMIN" ; + Text [ en-US ] = "DMIN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDMIN"; + Text[ ru ] = "ДМИÐ"; + Text[ el ] = "DMIN"; + Text[ nl ] = "DBMIN"; + Text[ fr ] = "BDMIN"; + Text[ es ] = "BDMIN"; + Text[ fi ] = "TMIN"; + Text[ ca ] = "DMIN"; + Text[ it ] = "DB.MIN"; + Text[ da ] = "DMIN"; + Text[ sv ] = "DMIN"; + Text[ pl ] = "DMIN"; + Text[ pt-BR ] = "BDMÃN"; + Text[ th ] = "DMIN"; + Text[ ja ] = "DMIN"; + Text[ ko ] = "DMIN"; + Text[ zh-CN ] = "DMIN"; + Text[ zh-TW ] = "DMIN"; + Text[ tr ] = "VMIN"; + Text[ hi-IN ] = "DMIN"; + Text[ ar ] = "DMIN"; + Text[ he ] = "DBMIN"; + }; + String SC_OPCODE_DB_PRODUCT + { + Text [ de ] = "DBPRODUKT" ; + Text [ en-US ] = "DPRODUCT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DMULTIPL"; + Text[ ru ] = "БДПРОИЗВЕД"; + Text[ el ] = "DPRODUCT"; + Text[ nl ] = "DBPRODUKT"; + Text[ fr ] = "BDPRODUIT"; + Text[ es ] = "BDPRODUCTO"; + Text[ fi ] = "TTULO"; + Text[ ca ] = "DPRODUCT"; + Text[ it ] = "DB.PRODOTTO"; + Text[ da ] = "DPRODUKT"; + Text[ sv ] = "DPRODUKT"; + Text[ pl ] = "DPRODUCT"; + Text[ pt-BR ] = "BDMULTIPL"; + Text[ th ] = "DPRODUCT"; + Text[ ja ] = "DPRODUCT"; + Text[ ko ] = "DPRODUCT"; + Text[ zh-CN ] = "DPRODUCT"; + Text[ zh-TW ] = "DPRODUCT"; + Text[ tr ] = "VÇARPIM"; + Text[ hi-IN ] = "DPRODUCT"; + Text[ ar ] = "DPRODUCT"; + Text[ he ] = "DBPRODUKT"; + }; + String SC_OPCODE_DB_STD_DEV + { + Text [ de ] = "DBSTDABW" ; + Text [ en-US ] = "DSTDEV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDDESVPAD"; + Text[ ru ] = "ДСТÐÐДОТКЛ"; + Text[ el ] = "DSTDEV"; + Text[ nl ] = "DBSTDEV"; + Text[ fr ] = "BDECARTYPE"; + Text[ es ] = "BDDESVEST"; + Text[ fi ] = "TKESKIHAJONTA"; + Text[ ca ] = "DSTDEV"; + Text[ it ] = "DB.DEV.ST"; + Text[ da ] = "DSTAFV"; + Text[ sv ] = "DSTDAV"; + Text[ pl ] = "DSTDEV"; + Text[ pt-BR ] = "BDEST"; + Text[ th ] = "DSTDEV"; + Text[ ja ] = "DSTDEV"; + Text[ ko ] = "DSTDEV"; + Text[ zh-CN ] = "DSTDEV"; + Text[ zh-TW ] = "DSTDEV"; + Text[ tr ] = "VSTSAPMA"; + Text[ hi-IN ] = "DSTDEV"; + Text[ ar ] = "DSTDEV"; + Text[ he ] = "DBSTDABW"; + }; + String SC_OPCODE_DB_STD_DEV_P + { + Text [ de ] = "DBSTDABWN" ; + Text [ en-US ] = "DSTDEVP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDDESVPADP"; + Text[ ru ] = "ДСТÐÐДОТКЛП"; + Text[ el ] = "DSTDEVP"; + Text[ nl ] = "DBSTDEVP"; + Text[ fr ] = "BDECARTYPEP"; + Text[ es ] = "BDDESVESTP"; + Text[ fi ] = "TKESKIHAJONTAP"; + Text[ ca ] = "DSTDEVP"; + Text[ it ] = "DB.DEV.ST.POP"; + Text[ da ] = "DSTAFVP"; + Text[ sv ] = "DSTDAVP"; + Text[ pl ] = "DSTDEVP"; + Text[ pt-BR ] = "BDDESVPA"; + Text[ th ] = "DSTDEVP"; + Text[ ja ] = "DSTDEVP"; + Text[ ko ] = "DSTDEVP"; + Text[ zh-CN ] = "DSTDEVP"; + Text[ zh-TW ] = "DSTDEVP"; + Text[ tr ] = "DSTDEVP"; + Text[ hi-IN ] = "DSTDEVP"; + Text[ ar ] = "DSTDEVP"; + Text[ he ] = "DBSTDABWN"; + }; + String SC_OPCODE_DB_VAR + { + Text [ de ] = "DBVARIANZ" ; + Text [ en-US ] = "DVAR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDVAR"; + Text[ ru ] = "БДДИСП"; + Text[ el ] = "DVAR"; + Text[ nl ] = "DBVAR"; + Text[ fr ] = "BDVAR"; + Text[ es ] = "BDVAR"; + Text[ fi ] = "TVARIANSSI"; + Text[ ca ] = "DVAR"; + Text[ it ] = "DB.VAR"; + Text[ da ] = "DVARIANS"; + Text[ sv ] = "DVARIANS"; + Text[ pl ] = "DVAR"; + Text[ pt-BR ] = "BDVAREST"; + Text[ th ] = "DVAR"; + Text[ ja ] = "DVAR"; + Text[ ko ] = "DVAR"; + Text[ zh-CN ] = "DVAR"; + Text[ zh-TW ] = "DVAR"; + Text[ tr ] = "VDEĞİŞKEN"; + Text[ hi-IN ] = "DVAR"; + Text[ ar ] = "DVAR"; + Text[ he ] = "DBVARIANZ"; + }; + String SC_OPCODE_DB_VAR_P + { + Text [ de ] = "DBVARIANZEN" ; + Text [ en-US ] = "DVARP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BDVARP"; + Text[ ru ] = "БДДИСПП"; + Text[ el ] = "DVARP"; + Text[ nl ] = "DBVARP"; + Text[ fr ] = "BDVARP"; + Text[ es ] = "BDVARP"; + Text[ fi ] = "TVARIANSSIP"; + Text[ ca ] = "DVARP"; + Text[ it ] = "DB.VAR.POP"; + Text[ da ] = "DVARIANSP"; + Text[ sv ] = "DVARIANSP"; + Text[ pl ] = "DVARP"; + Text[ pt-BR ] = "BDVARP"; + Text[ th ] = "DVARP"; + Text[ ja ] = "DVARP"; + Text[ ko ] = "DVARP"; + Text[ zh-CN ] = "DVARP"; + Text[ zh-TW ] = "DVARP"; + Text[ tr ] = "VDEĞİŞKENP"; + Text[ hi-IN ] = "DVARP"; + Text[ ar ] = "DVARP"; + Text[ he ] = "DBVARIANZEN"; + }; + String SC_OPCODE_INDIRECT + { + Text [ de ] = "INDIREKT" ; + Text [ en-US ] = "INDIRECT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INDIRECTO"; + Text[ ru ] = "ДВССЫЛ"; + Text[ el ] = "INDIRECT"; + Text[ nl ] = "INDIRECT"; + Text[ fr ] = "INDIRECT"; + Text[ es ] = "INDIRECTO"; + Text[ fi ] = "EPÄSUORA"; + Text[ ca ] = "INDIRECT"; + Text[ it ] = "INDIRETTO"; + Text[ da ] = "INDIREKTE"; + Text[ sv ] = "INDIREKT"; + Text[ pl ] = "INDIRECT"; + Text[ pt-BR ] = "INDIRETO"; + Text[ th ] = "INDIRECT"; + Text[ ja ] = "INDIRECT"; + Text[ ko ] = "INDIRECT"; + Text[ zh-CN ] = "INDIRECT"; + Text[ zh-TW ] = "INDIRECT"; + Text[ tr ] = "DOLAYLI"; + Text[ hi-IN ] = "INDIRECT"; + Text[ ar ] = "INDIRECT"; + Text[ he ] = "INDIREKT"; + }; + String SC_OPCODE_ADRESS + { + Text [ de ] = "ADRESSE" ; + Text [ en-US ] = "ADDRESS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ENDEREÇO"; + Text[ ru ] = "ÐДРЕС"; + Text[ el ] = "ADDRESS"; + Text[ nl ] = "ADRES"; + Text[ fr ] = "ADRESSE"; + Text[ es ] = "DIRECCIÓN"; + Text[ fi ] = "OSOITE"; + Text[ ca ] = "ADDRESS"; + Text[ it ] = "INDIRIZZO"; + Text[ da ] = "ADRESSE"; + Text[ sv ] = "ADRESS"; + Text[ pl ] = "ADDRESS"; + Text[ pt-BR ] = "ENDEREÇO"; + Text[ th ] = "ที่à¸à¸¢à¸¹à¹ˆà¸œà¸¹à¹‰à¸ˆà¸±à¸”พิมพ์"; + Text[ ja ] = "ADDRESS"; + Text[ ko ] = "ADDRESS"; + Text[ zh-CN ] = "ADDRESS"; + Text[ zh-TW ] = "ADDRESS"; + Text[ tr ] = "ADRES"; + Text[ hi-IN ] = "ADDRESS"; + Text[ ar ] = "ADDRESS"; + Text[ he ] = "ADRESSE"; + }; + String SC_OPCODE_MATCH + { + Text [ de ] = "VERGLEICH" ; + Text [ en-US ] = "MATCH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CORRESP"; + Text[ ru ] = "ПОИСКПОЗ"; + Text[ el ] = "MATCH"; + Text[ nl ] = "VERGELIJKEN"; + Text[ fr ] = "EQUIV"; + Text[ es ] = "COINCIDIR"; + Text[ fi ] = "VASTINE"; + Text[ ca ] = "MATCH"; + Text[ it ] = "CONFRONTA"; + Text[ da ] = "SAMMENLIGN"; + Text[ sv ] = "PASSA"; + Text[ pl ] = "MATCH"; + Text[ pt-BR ] = "CORRESP"; + Text[ th ] = "MATCH"; + Text[ ja ] = "MATCH"; + Text[ ko ] = "MATCH"; + Text[ zh-CN ] = "MATCH"; + Text[ zh-TW ] = "MATCH"; + Text[ tr ] = "UYUM"; + Text[ hi-IN ] = "MATCH"; + Text[ ar ] = "MATCH"; + Text[ he ] = "VERGLEICH"; + }; + String SC_OPCODE_COUNT_EMPTY_CELLS + { + Text [ de ] = "ANZAHLLEEREZELLEN" ; + Text [ en-US ] = "COUNTBLANK" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CONTAR.VAZIO"; + Text[ ru ] = "СЧИТÐТЬПУСТОТЫ"; + Text[ el ] = "COUNTBLANK"; + Text[ nl ] = "AANTAL.LEGE.CELLEN"; + Text[ fr ] = "NB.VIDE"; + Text[ es ] = "CONTAR.BLANCO"; + Text[ fi ] = "LASKE_TYHJÄT"; + Text[ ca ] = "COUNTBLANK"; + Text[ it ] = "CONTA.VUOTE"; + Text[ da ] = "ANTAL.BLANKE"; + Text[ sv ] = "ANTAL.TOMMA"; + Text[ pl ] = "COUNTBLANK"; + Text[ pt-BR ] = "CONTAR.VAZIO"; + Text[ th ] = "COUNTBLANK"; + Text[ ja ] = "COUNTBLANK"; + Text[ ko ] = "COUNTBLANK"; + Text[ zh-CN ] = "COUNTBLANK"; + Text[ zh-TW ] = "COUNTBLANK"; + Text[ tr ] = "SAYBOÅž"; + Text[ hi-IN ] = "COUNTBLANK"; + Text[ ar ] = "COUNTBLANK"; + Text[ he ] = "ANZAHLLEEREZELLEN"; + }; + String SC_OPCODE_COUNT_IF + { + Text [ de ] = "ZÄHLENWENN" ; + Text [ en-US ] = "COUNTIF" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CONTAR.SE"; + Text[ ru ] = "СЧЕТЕСЛИ"; + Text[ el ] = "COUNTIF"; + Text[ nl ] = "AANTAL.ALS"; + Text[ fr ] = "NB.SI"; + Text[ es ] = "CONTAR.SI"; + Text[ fi ] = "LASKE_JOS"; + Text[ ca ] = "COUNTIF"; + Text[ it ] = "CONTA.SE"; + Text[ da ] = "TÆLHVIS"; + Text[ sv ] = "ANTAL.OM"; + Text[ pl ] = "COUNTIF"; + Text[ pt-BR ] = "CONT.SE"; + Text[ th ] = "COUNTIF"; + Text[ ja ] = "COUNTIF"; + Text[ ko ] = "COUNTIF"; + Text[ zh-CN ] = "COUNTIF"; + Text[ zh-TW ] = "COUNTIF"; + Text[ tr ] = "SAYEÄžER"; + Text[ hi-IN ] = "COUNTIF"; + Text[ ar ] = "COUNTIF"; + Text[ he ] = "ZÄHLENWENN"; + }; + String SC_OPCODE_SUM_IF + { + Text [ de ] = "SUMMEWENN" ; + Text [ en-US ] = "SUMIF" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SOMA.SE"; + Text[ ru ] = "СУММЕСЛИ"; + Text[ el ] = "SUMIF"; + Text[ nl ] = "SOM.ALS"; + Text[ fr ] = "SOMME.SI"; + Text[ es ] = "SUMAR.SI"; + Text[ fi ] = "SUMMA_JOS"; + Text[ ca ] = "SUMIF"; + Text[ it ] = "SOMMA.SE"; + Text[ da ] = "SUM.HVIS"; + Text[ sv ] = "SUMMA.OM"; + Text[ pl ] = "SUMIF"; + Text[ pt-BR ] = "SOMASE"; + Text[ th ] = "SUMIF"; + Text[ ja ] = "SUMIF"; + Text[ ko ] = "SUMIF"; + Text[ zh-CN ] = "SUMIF"; + Text[ zh-TW ] = "SUMIF"; + Text[ tr ] = "TOPLAEÄžER"; + Text[ hi-IN ] = "SUMIF"; + Text[ ar ] = "SUMIF"; + Text[ he ] = "SUMMEWENN"; + }; + String SC_OPCODE_LOOKUP + { + Text [ de ] = "VERWEIS" ; + Text [ en-US ] = "LOOKUP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "REFERÊNCIA"; + Text[ ru ] = "ПРОСМОТР"; + Text[ el ] = "LOOKUP"; + Text[ nl ] = "ZOEKEN"; + Text[ fr ] = "RECHERCHE"; + Text[ es ] = "BUSCAR"; + Text[ fi ] = "HAKU"; + Text[ ca ] = "LOOKUP"; + Text[ it ] = "CERCA"; + Text[ da ] = "SLÃ….OP"; + Text[ sv ] = "LETAUPP"; + Text[ pl ] = "LOOKUP"; + Text[ pt-BR ] = "PROC"; + Text[ th ] = "LOOKUP"; + Text[ ja ] = "LOOKUP"; + Text[ ko ] = "LOOKUP"; + Text[ zh-CN ] = "LOOKUP"; + Text[ zh-TW ] = "LOOKUP"; + Text[ tr ] = "ÃœSTEBAK"; + Text[ hi-IN ] = "LOOKUP"; + Text[ ar ] = "LOOKUP"; + Text[ he ] = "VERWEIS"; + }; + String SC_OPCODE_V_LOOKUP + { + Text [ de ] = "SVERWEIS" ; + Text [ en-US ] = "VLOOKUP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PROCV"; + Text[ ru ] = "ВПР"; + Text[ el ] = "VLOOKUP"; + Text[ nl ] = "VERT.ZOEKEN"; + Text[ fr ] = "RECHERCHEV"; + Text[ es ] = "BUSCARV"; + Text[ fi ] = "PHAKU"; + Text[ ca ] = "VLOOKUP"; + Text[ it ] = "CERCA.VERT"; + Text[ da ] = "LOPSLAG"; + Text[ sv ] = "LETARAD"; + Text[ pl ] = "VLOOKUP"; + Text[ pt-BR ] = "PROCV"; + Text[ th ] = "VLOOKUP"; + Text[ ja ] = "VLOOKUP"; + Text[ ko ] = "VLOOKUP"; + Text[ zh-CN ] = "VLOOKUP"; + Text[ zh-TW ] = "VLOOKUP"; + Text[ tr ] = "DÄ°KEYÃœSTEBAK"; + Text[ hi-IN ] = "VLOOKUP"; + Text[ ar ] = "VLOOKUP"; + Text[ he ] = "SVERWEIS"; + }; + String SC_OPCODE_H_LOOKUP + { + Text [ de ] = "WVERWEIS" ; + Text [ en-US ] = "HLOOKUP" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PROCH"; + Text[ ru ] = "ГПР"; + Text[ el ] = "HLOOKUP"; + Text[ nl ] = "HORIZ.ZOEKEN"; + Text[ fr ] = "RECHERCHEH"; + Text[ es ] = "BUSCARH"; + Text[ fi ] = "VHAKU"; + Text[ ca ] = "HLOOKUP"; + Text[ it ] = "CERCA.ORIZZ"; + Text[ da ] = "VOPSLAG"; + Text[ sv ] = "LETAKOLUMN"; + Text[ pl ] = "HLOOKUP"; + Text[ pt-BR ] = "PROCH"; + Text[ th ] = "HLOOKUP"; + Text[ ja ] = "HLOOKUP"; + Text[ ko ] = "HLOOKUP"; + Text[ zh-CN ] = "HLOOKUP"; + Text[ zh-TW ] = "HLOOKUP"; + Text[ tr ] = "YATAYÃœSTEBAK"; + Text[ hi-IN ] = "HLOOKUP"; + Text[ ar ] = "HLOOKUP"; + Text[ he ] = "WVERWEIS"; + }; + String SC_OPCODE_MULTI_AREA + { + Text [ de ] = "MULTIBEREICH" ; + Text [ en-US ] = "MULTIRANGE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INTERV.MÚLTIPL."; + Text[ ru ] = "МУЛЬТИОБЛÐСТЬ"; + Text[ el ] = "MULTIRANGE"; + Text[ nl ] = "MULTIBEREIK"; + Text[ fr ] = "MULTIRANGE"; + Text[ es ] = "MULTIRANGO"; + Text[ fi ] = "MULTIRANGE"; + Text[ ca ] = "MULTIRANGE"; + Text[ it ] = "MULTIRANGE"; + Text[ da ] = "MULTIOMRÃ…DE"; + Text[ sv ] = "MULTIOMRÃ…DE"; + Text[ pl ] = "MULTIRANGE"; + Text[ pt-BR ] = "INTERV.MÚLTIPL"; + Text[ th ] = "MULTIRANGE"; + Text[ ja ] = "MULTIRANGE"; + Text[ ko ] = "MULTIRANGE"; + Text[ zh-CN ] = "MULTIRANGE"; + Text[ zh-TW ] = "MULTIRANGE"; + Text[ tr ] = "ÇOKLUARALIK"; + Text[ hi-IN ] = "MULTIRANGE"; + Text[ ar ] = "MULTIRANGE"; + Text[ he ] = "MULTIBEREICH"; + }; + String SC_OPCODE_OFFSET + { + Text [ de ] = "VERSCHIEBUNG" ; + Text [ en-US ] = "OFFSET" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DESLOCAMENTO"; + Text[ ru ] = "СМЕЩЕÐИЕ"; + Text[ el ] = "OFFSET"; + Text[ nl ] = "VERSCHUIVING"; + Text[ fr ] = "DECALER"; + Text[ es ] = "DESREF"; + Text[ fi ] = "SIIRTYMÄ"; + Text[ ca ] = "OFFSET"; + Text[ it ] = "SCARTO"; + Text[ da ] = "FORSKYDNING"; + Text[ sv ] = "FÖRSKJUTA"; + Text[ pl ] = "OFFSET"; + Text[ pt-BR ] = "DESLOC"; + Text[ th ] = "à¸à¸²à¸£à¸§à¸²à¸‡"; + Text[ ja ] = "OFFSET"; + Text[ ko ] = "OFFSET"; + Text[ zh-CN ] = "OFFSET"; + Text[ zh-TW ] = "OFFSET"; + Text[ tr ] = "DENKLEÅžTÄ°R"; + Text[ hi-IN ] = "OFFSET"; + Text[ ar ] = "OFFSET"; + Text[ he ] = "VERSCHIEBUNG"; + }; + String SC_OPCODE_INDEX + { + Text [ de ] = "INDEX" ; + // ?? erstes Zeichen = I ?? + Text [ en-US ] = "INDEX" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ÃNDICE"; + Text[ ru ] = "ИÐДЕКС"; + Text[ el ] = "INDEX"; + Text[ nl ] = "INDEX"; + Text[ fr ] = "INDEX"; + Text[ es ] = "ÃNDICE"; + Text[ fi ] = "INDEKSI"; + Text[ ca ] = "INDEX"; + Text[ it ] = "INDICE"; + Text[ da ] = "INDEKS"; + Text[ sv ] = "INDEX"; + Text[ pl ] = "INDEX"; + Text[ pt-BR ] = "ÃNDICE"; + Text[ th ] = "ดัชนี"; + Text[ ja ] = "INDEX"; + Text[ ko ] = "INDEX"; + Text[ zh-CN ] = "INDEX"; + Text[ zh-TW ] = "INDEX"; + Text[ tr ] = "Ä°NDEKS"; + Text[ hi-IN ] = "INDEX"; + Text[ ar ] = "INDEX"; + Text[ he ] = "INDEX"; + }; + String SC_OPCODE_AREAS + { + Text [ de ] = "BEREICHE" ; + Text [ en-US ] = "AREAS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ÃREAS"; + Text[ ru ] = "ОБЛÐСТИ"; + Text[ el ] = "AREAS"; + Text[ nl ] = "BEREIKEN"; + Text[ fr ] = "ZONES"; + Text[ es ] = "ÃREAS"; + Text[ fi ] = "ALUEET"; + Text[ ca ] = "AREAS"; + Text[ it ] = "AREE"; + Text[ da ] = "OMRÃ…DER"; + Text[ sv ] = "OMRÃ…DEN"; + Text[ pl ] = "AREAS"; + Text[ pt-BR ] = "ÃREAS"; + Text[ th ] = "ส่วน"; + Text[ ja ] = "AREAS"; + Text[ ko ] = "AREAS"; + Text[ zh-CN ] = "AREAS"; + Text[ zh-TW ] = "AREAS"; + Text[ tr ] = "ALANLAR"; + Text[ hi-IN ] = "AREAS"; + Text[ ar ] = "AREAS"; + Text[ he ] = "BEREICHE"; + }; + String SC_OPCODE_CURRENCY + { + Text [ de ] = "DM" ; + Text [ en-US ] = "DOLLAR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MOEDA"; + Text[ ru ] = "РУБЛЬ"; + Text[ el ] = "DOLLAR"; + Text[ nl ] = "GULDEN"; + Text[ fr ] = "FRANC"; + Text[ es ] = "MONEDA"; + Text[ fi ] = "VALUUTTA"; + Text[ ca ] = "DOLLAR"; + Text[ it ] = "VALUTA"; + Text[ da ] = "KR"; + Text[ sv ] = "VALUTA"; + Text[ pl ] = "DOLLAR"; + Text[ pt-BR ] = "MOEDA"; + Text[ th ] = "DOLLAR"; + Text[ ja ] = "YEN"; + Text[ ko ] = "DOLLAR"; + Text[ zh-CN ] = "RMB"; + Text[ zh-TW ] = "DOLLAR"; + Text[ tr ] = "DOLAR"; + Text[ hi-IN ] = "DOLLAR"; + Text[ ar ] = "DOLLAR"; + Text[ he ] = "DM"; + }; + String SC_OPCODE_REPLACE + { + Text [ de ] = "ERSETZEN" ; + Text [ en-US ] = "REPLACE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SUBSTITUIR"; + Text[ ru ] = "ЗÐМЕÐИТЬ"; + Text[ el ] = "REPLACE"; + Text[ nl ] = "VERVANGEN"; + Text[ fr ] = "REMPLACER"; + Text[ es ] = "REEMPLAZAR"; + Text[ fi ] = "KORVAA"; + Text[ ca ] = "REPLACE"; + Text[ it ] = "RIMPIAZZA"; + Text[ da ] = "ERSTAT"; + Text[ sv ] = "ERSÄTT"; + Text[ pl ] = "REPLACE"; + Text[ pt-BR ] = "MUDAR"; + Text[ th ] = "à¹à¸—นที่"; + Text[ ja ] = "REPLACE"; + Text[ ko ] = "REPLACE"; + Text[ zh-CN ] = "REPLACE"; + Text[ zh-TW ] = "REPLACE"; + Text[ tr ] = "DEĞİŞTÄ°R"; + Text[ hi-IN ] = "REPLACE"; + Text[ ar ] = "REPLACE"; + Text[ he ] = "ERSETZEN"; + }; + String SC_OPCODE_FIXED + { + Text [ de ] = "FEST" ; + Text [ en-US ] = "FIXED" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FIXAR"; + Text[ ru ] = "ФИКСИРОВÐÐÐЫЙ"; + Text[ el ] = "FIXED"; + Text[ nl ] = "VAST"; + Text[ fr ] = "CTXT"; + Text[ es ] = "FIJO"; + Text[ fi ] = "KIINTEÄ"; + Text[ ca ] = "FIXED"; + Text[ it ] = "FISSO"; + Text[ da ] = "FAST"; + Text[ sv ] = "FASTTAL"; + Text[ pl ] = "FIXED"; + Text[ pt-BR ] = "DEF.NÚM.DEC"; + Text[ th ] = "คงที่"; + Text[ ja ] = "FIXED"; + Text[ ko ] = "ê³ ì •"; + Text[ zh-CN ] = "FIXED"; + Text[ zh-TW ] = "FIXED"; + Text[ tr ] = "SABÄ°TLENMÄ°Åž"; + Text[ hi-IN ] = "FIXED"; + Text[ ar ] = "FIXED"; + Text[ he ] = "FEST"; + }; + String SC_OPCODE_FIND + { + Text [ de ] = "FINDEN" ; + Text [ en-US ] = "FIND" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LOCALIZAR"; + Text[ ru ] = "ÐÐЙТИ"; + Text[ el ] = "FIND"; + Text[ nl ] = "VIND.ALLES"; + Text[ fr ] = "TROUVE"; + Text[ es ] = "ENCONTRAR"; + Text[ fi ] = "ETSI"; + Text[ ca ] = "FIND"; + Text[ it ] = "TROVA"; + Text[ da ] = "FIND"; + Text[ sv ] = "HITTA"; + Text[ pl ] = "FIND"; + Text[ pt-BR ] = "PROCURAR"; + Text[ th ] = "FIND"; + Text[ ja ] = "FIND"; + Text[ ko ] = "FIND"; + Text[ zh-CN ] = "FIND"; + Text[ zh-TW ] = "FIND"; + Text[ tr ] = "BUL"; + Text[ hi-IN ] = "FIND"; + Text[ ar ] = "FIND"; + Text[ he ] = "FINDEN"; + }; + String SC_OPCODE_EXACT + { + Text [ de ] = "IDENTISCH" ; + Text [ en-US ] = "EXACT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "IDÊNTICO"; + Text[ ru ] = "СОВПÐД"; + Text[ el ] = "EXACT"; + Text[ nl ] = "GELIJK"; + Text[ fr ] = "EXACT"; + Text[ es ] = "IGUAL"; + Text[ fi ] = "VERTAA"; + Text[ ca ] = "EXACT"; + Text[ it ] = "IDENTICO"; + Text[ da ] = "EKSAKT"; + Text[ sv ] = "EXAKT"; + Text[ pl ] = "EXACT"; + Text[ pt-BR ] = "EXATO"; + Text[ th ] = "เหมืà¸à¸™à¸à¸±à¸™"; + Text[ ja ] = "EXACT"; + Text[ ko ] = "EXACT"; + Text[ zh-CN ] = "EXACT"; + Text[ zh-TW ] = "EXACT"; + Text[ tr ] = "KESÄ°N"; + Text[ hi-IN ] = "EXACT"; + Text[ ar ] = "EXACT"; + Text[ he ] = "IDENTISCH"; + }; + String SC_OPCODE_LEFT + { + Text [ de ] = "LINKS" ; + Text [ en-US ] = "LEFT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ESQUERDA"; + Text[ ru ] = "ЛЕВСИМВ"; + Text[ el ] = "LEFT"; + Text[ nl ] = "LINKS"; + Text[ fr ] = "GAUCHE"; + Text[ es ] = "IZQUIERDA"; + Text[ fi ] = "VASEN"; + Text[ ca ] = "LEFT"; + Text[ it ] = "SINISTRA"; + Text[ da ] = "VENSTRE"; + Text[ sv ] = "VÄNSTER"; + Text[ pl ] = "LEFT"; + Text[ pt-BR ] = "ESQUERDA"; + Text[ th ] = "ซ้าย "; + Text[ ja ] = "LEFT"; + Text[ ko ] = "LEFT"; + Text[ zh-CN ] = "LEFT"; + Text[ zh-TW ] = "LEFT"; + Text[ tr ] = "SOL"; + Text[ hi-IN ] = "LEFT"; + Text[ ar ] = "LEFT"; + Text[ he ] = "LINKS"; + }; + String SC_OPCODE_RIGHT + { + Text [ de ] = "RECHTS" ; + Text [ en-US ] = "RIGHT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIREITA"; + Text[ ru ] = "ПРÐВСИМВ"; + Text[ el ] = "ΔΕΞΙΑ"; + Text[ nl ] = "RECHTS"; + Text[ fr ] = "DROITE"; + Text[ es ] = "DERECHA"; + Text[ fi ] = "OIKEA"; + Text[ ca ] = "RIGHT"; + Text[ it ] = "DESTRA"; + Text[ da ] = "HØJRE"; + Text[ sv ] = "HÖGER"; + Text[ pl ] = "RIGHT"; + Text[ pt-BR ] = "DIREITA"; + Text[ th ] = "ขวา "; + Text[ ja ] = "RIGHT"; + Text[ ko ] = "RIGHT"; + Text[ zh-CN ] = "RIGHT"; + Text[ zh-TW ] = "RIGHT"; + Text[ tr ] = "SAÄž"; + Text[ hi-IN ] = "RIGHT"; + Text[ ar ] = "RIGHT"; + Text[ he ] = "RECHTS"; + }; + String SC_OPCODE_SEARCH + { + Text [ de ] = "SUCHEN" ; + Text [ en-US ] = "SEARCH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PROCURAR"; + Text[ ru ] = "ПОИСК"; + Text[ el ] = "SEARCH"; + Text[ nl ] = "VIND.SPEC"; + Text[ fr ] = "CHERCHE"; + Text[ es ] = "BUSCAR"; + Text[ fi ] = "KÄY_LÄPI"; + Text[ ca ] = "SEARCH"; + Text[ it ] = "RICERCA"; + Text[ da ] = "SØG"; + Text[ sv ] = "SÖK"; + Text[ pl ] = "SEARCH"; + Text[ pt-BR ] = "LOCALIZAR"; + Text[ th ] = "ค้นหา"; + Text[ ja ] = "SEARCH"; + Text[ ko ] = "SEARCH"; + Text[ zh-CN ] = "SEARCH"; + Text[ zh-TW ] = "SEARCH"; + Text[ tr ] = "ARA"; + Text[ hi-IN ] = "SEARCH"; + Text[ ar ] = "SEARCH"; + Text[ he ] = "SUCHEN"; + }; + String SC_OPCODE_MID + { + Text [ de ] = "TEIL" ; + Text [ en-US ] = "MID" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÉDIA"; + Text[ ru ] = "ПСТР"; + Text[ el ] = "MID"; + Text[ nl ] = "DEEL"; + Text[ fr ] = "STXT"; + Text[ es ] = "EXTRAE"; + Text[ fi ] = "POIMI_TEKSTI"; + Text[ ca ] = "MID"; + Text[ it ] = "STRINGA.ESTRAI"; + Text[ da ] = "MIDT"; + Text[ sv ] = "EXTEXT"; + Text[ pl ] = "MID"; + Text[ pt-BR ] = "EXT.TEXTO"; + Text[ th ] = "MID"; + Text[ ja ] = "MID"; + Text[ ko ] = "MID"; + Text[ zh-CN ] = "MID"; + Text[ zh-TW ] = "MID"; + Text[ tr ] = "ORTA"; + Text[ hi-IN ] = "MID"; + Text[ ar ] = "MID"; + Text[ he ] = "TEIL"; + }; + String SC_OPCODE_TEXT + { + Text [ de ] = "TEXT" ; + Text [ en-US ] = "TEXT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TEXTO"; + Text[ ru ] = "ТЕКСТ"; + Text[ el ] = "TEXT"; + Text[ nl ] = "TEKST"; + Text[ fr ] = "TEXTE"; + Text[ es ] = "TEXTO"; + Text[ fi ] = "TEKSTI"; + Text[ ca ] = "TEXT"; + Text[ it ] = "TESTO"; + Text[ da ] = "TEKST"; + Text[ sv ] = "TEXT"; + Text[ pl ] = "TEXT"; + Text[ pt-BR ] = "TEXTO"; + Text[ th ] = "ข้à¸à¸„วาม"; + Text[ ja ] = "TEXT"; + Text[ ko ] = "TEXT"; + Text[ zh-CN ] = "TEXT"; + Text[ zh-TW ] = "TEXT"; + Text[ tr ] = "METÄ°N"; + Text[ hi-IN ] = "TEXT"; + Text[ ar ] = "TEXT"; + Text[ he ] = "TEXT"; + }; + String SC_OPCODE_SUBSTITUTE + { + Text [ de ] = "WECHSELN" ; + Text [ en-US ] = "SUBSTITUTE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "SUBSTITUIR"; + Text[ ru ] = "ПОДСТÐВИТЬ"; + Text[ el ] = "SUBSTITUTE"; + Text[ nl ] = "SUBSTITUEREN"; + Text[ fr ] = "SUBSTITUE"; + Text[ es ] = "SUSTITUIR"; + Text[ fi ] = "VAIHDA"; + Text[ ca ] = "SUBSTITUTE"; + Text[ it ] = "SOSTITUISCI"; + Text[ da ] = "UDSKIFT"; + Text[ sv ] = "BYT.UT"; + Text[ pl ] = "SUBSTITUTE"; + Text[ pt-BR ] = "SUBSTITUIR"; + Text[ th ] = "SUBSTITUTE"; + Text[ ja ] = "SUBSTITUTE"; + Text[ ko ] = "SUBSTITUTE"; + Text[ zh-CN ] = "SUBSTITUTE"; + Text[ zh-TW ] = "SUBSTITUTE"; + Text[ tr ] = "ÇIKAR"; + Text[ hi-IN ] = "SUBSTITUTE"; + Text[ ar ] = "SUBSTITUTE"; + Text[ he ] = "WECHSELN"; + }; + String SC_OPCODE_REPT + { + Text [ de ] = "WIEDERHOLEN" ; + Text [ en-US ] = "REPT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "REPETIR"; + Text[ ru ] = "ПОВТОР"; + Text[ el ] = "REPT"; + Text[ nl ] = "HERHALING"; + Text[ fr ] = "REPT"; + Text[ es ] = "REPETIR"; + Text[ fi ] = "TOISTA"; + Text[ ca ] = "REPT"; + Text[ it ] = "RIPETI"; + Text[ da ] = "GENTAG"; + Text[ sv ] = "REP"; + Text[ pl ] = "REPT"; + Text[ pt-BR ] = "REPT"; + Text[ th ] = "ทำซ้ำ"; + Text[ ja ] = "REPT"; + Text[ ko ] = "REPT"; + Text[ zh-CN ] = "REPT"; + Text[ zh-TW ] = "REPT"; + Text[ tr ] = "REPT"; + Text[ hi-IN ] = "REPT"; + Text[ ar ] = "REPT"; + Text[ he ] = "WIEDERHOLEN"; + }; + String SC_OPCODE_CONCAT + { + Text [ de ] = "VERKETTEN" ; + Text [ en-US ] = "CONCATENATE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CONCATENAR"; + Text[ ru ] = "СЦЕПИТЬ"; + Text[ el ] = "CONCATENATE"; + Text[ nl ] = "TEKST.SAMENVOEGEN"; + Text[ fr ] = "CONCATENER"; + Text[ es ] = "CONCATENAR"; + Text[ fi ] = "KETJUTA"; + Text[ ca ] = "CONCATENATE"; + Text[ it ] = "CONCATENA"; + Text[ da ] = "SAMMENKÆDNING"; + Text[ sv ] = "SAMMANFOGA"; + Text[ pl ] = "CONCATENATE"; + Text[ pt-BR ] = "CONCATENAR"; + Text[ th ] = "เชื่à¸à¸¡à¹‚ยงà¸à¸£à¸à¸š"; + Text[ ja ] = "CONCATENATE"; + Text[ ko ] = "CONCATENATE"; + Text[ zh-CN ] = "CONCATENATE"; + Text[ zh-TW ] = "CONCATENATE"; + Text[ tr ] = "SIRALA"; + Text[ hi-IN ] = "CONCATENATE"; + Text[ ar ] = "CONCATENATE"; + Text[ he ] = "VERKETTEN"; + }; + String SC_OPCODE_MAT_VALUE + { + Text [ de ] = "MWERT" ; + Text [ en-US ] = "MVALUE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "VALOR.MATRIZ"; + Text[ ru ] = "МЗÐÐЧ"; + Text[ el ] = "MVALUE"; + Text[ nl ] = "WAARDEMAT"; + Text[ fr ] = "MVALUE"; + Text[ es ] = "MVALOR"; + Text[ fi ] = "MVALUE"; + Text[ ca ] = "MVALUE"; + Text[ it ] = "MATR.VALORE"; + Text[ da ] = "MVÆRDI"; + Text[ sv ] = "MVÄRDE"; + Text[ pl ] = "MVALUE"; + Text[ pt-BR ] = "MATRIZ.VALOR"; + Text[ th ] = "MVALUE"; + Text[ ja ] = "MVALUE"; + Text[ ko ] = "MVALUE"; + Text[ zh-CN ] = "MVALUE"; + Text[ zh-TW ] = "MVALUE"; + Text[ tr ] = "MDEÄžER"; + Text[ hi-IN ] = "MVALUE"; + Text[ ar ] = "MVALUE"; + Text[ he ] = "MWERT"; + }; + String SC_OPCODE_MAT_DET + { + Text [ de ] = "MDET" ; + Text [ en-US ] = "MDETERM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MATRIZ.DETERM"; + Text[ ru ] = "МОПРЕД"; + Text[ el ] = "MDETERM"; + Text[ nl ] = "DETERMINANT.MAT"; + Text[ fr ] = "DETERMAT"; + Text[ es ] = "MDETERM"; + Text[ fi ] = "MDETERM"; + Text[ ca ] = "MDETERM"; + Text[ it ] = "MATR.DETERM"; + Text[ da ] = "MDETERM"; + Text[ sv ] = "MDETERM"; + Text[ pl ] = "MDETERM"; + Text[ pt-BR ] = "MATRIZ.DETERM"; + Text[ th ] = "MDETERM"; + Text[ ja ] = "MDETERM"; + Text[ ko ] = "MDETERM"; + Text[ zh-CN ] = "MDETERM"; + Text[ zh-TW ] = "MDETERM"; + Text[ tr ] = "MDETERMÄ°NANT"; + Text[ hi-IN ] = "MDETERM"; + Text[ ar ] = "MDETERM"; + Text[ he ] = "MDET"; + }; + String SC_OPCODE_MAT_INV + { + Text [ de ] = "MINV" ; + Text [ en-US ] = "MINVERSE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MATRIZ.INVERSA"; + Text[ ru ] = "МОБР"; + Text[ el ] = "MINVERSE"; + Text[ nl ] = "INVERSEMAT"; + Text[ fr ] = "INVERSEMAT"; + Text[ es ] = "MINVERSA"; + Text[ fi ] = "MKÄÄNTEINEN"; + Text[ ca ] = "MINVERSE"; + Text[ it ] = "MATR.INVERSA"; + Text[ da ] = "MINVERT"; + Text[ sv ] = "MINVERT"; + Text[ pl ] = "MINVERSE"; + Text[ pt-BR ] = "MATRIZ.INVERSO"; + Text[ th ] = "MINVERSE"; + Text[ ja ] = "MINVERSE"; + Text[ ko ] = "MINVERSE"; + Text[ zh-CN ] = "MINVERSE"; + Text[ zh-TW ] = "MINVERSE"; + Text[ tr ] = "MTERS"; + Text[ hi-IN ] = "MINVERSE"; + Text[ ar ] = "MINVERSE"; + Text[ he ] = "MINV"; + }; + String SC_OPCODE_MAT_MULT + { + Text [ de ] = "MMULT" ; + Text [ en-US ] = "MMULT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MATRIZ.MULT"; + Text[ ru ] = "МУМÐОЖ"; + Text[ el ] = "MMULT"; + Text[ nl ] = "PRODUKTMAT"; + Text[ fr ] = "PRODUITMAT"; + Text[ es ] = "MMULT"; + Text[ fi ] = "MKERRO"; + Text[ ca ] = "MMULT"; + Text[ it ] = "MATR.PRODOTTO"; + Text[ da ] = "MPRODUKT"; + Text[ sv ] = "MMULT"; + Text[ pl ] = "MMULT"; + Text[ pt-BR ] = "MATRIZ.MULT"; + Text[ th ] = "MMULT"; + Text[ ja ] = "MMULT"; + Text[ ko ] = "MMULT"; + Text[ zh-CN ] = "MMULT"; + Text[ zh-TW ] = "MMULT"; + Text[ tr ] = "MÇARP"; + Text[ hi-IN ] = "MMULT"; + Text[ ar ] = "MMULT"; + Text[ he ] = "MMULT"; + }; + String SC_OPCODE_MAT_TRANS + { + Text [ de ] = "MTRANS" ; + Text [ en-US ] = "TRANSPOSE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TRANSPOR"; + Text[ ru ] = "МТРÐÐС"; + Text[ el ] = "TRANSPOSE"; + Text[ nl ] = "TRANSPONEREN"; + Text[ fr ] = "TRANSPOSE"; + Text[ es ] = "TRANSPONER"; + Text[ fi ] = "TRANSPONOI"; + Text[ ca ] = "TRANSPOSE"; + Text[ it ] = "MATR.TRASPOSTA"; + Text[ da ] = "TRANSPONER"; + Text[ sv ] = "MTRANS"; + Text[ pl ] = "TRANSPOSE"; + Text[ pt-BR ] = "TRANSPOR"; + Text[ th ] = "TRANSPOSE"; + Text[ ja ] = "TRANSPOSE"; + Text[ ko ] = "TRANSPOSE"; + Text[ zh-CN ] = "TRANSPOSE"; + Text[ zh-TW ] = "TRANSPOSE"; + Text[ tr ] = "TRANSPOZ"; + Text[ hi-IN ] = "TRANSPOSE"; + Text[ ar ] = "TRANSPOSE"; + Text[ he ] = "MTRANS"; + }; + String SC_OPCODE_MATRIX_UNIT + { + Text [ de ] = "EINHEITSMATRIX" ; + Text [ en-US ] = "MUNIT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MATRIZ.UNITÃRIA"; + Text[ ru ] = "ЕДМÐТРИЦÐ"; + Text[ el ] = "MUNIT"; + Text[ nl ] = "EENHEIDSMAT"; + Text[ fr ] = "MUNIT"; + Text[ es ] = "MUNITARIA"; + Text[ fi ] = "YKSIKKÖNELIÖ"; + Text[ ca ] = "MUNIT"; + Text[ it ] = "MUNIT"; + Text[ da ] = "ENHEDSMATRIX"; + Text[ sv ] = "ENHETSMATRIS"; + Text[ pl ] = "MUNIT"; + Text[ pt-BR ] = "MATRIZ.UNIT"; + Text[ th ] = "MUNIT"; + Text[ ja ] = "MUNIT"; + Text[ ko ] = "MUNIT"; + Text[ zh-CN ] = "MUNIT"; + Text[ zh-TW ] = "MUNIT"; + Text[ tr ] = "BÄ°RÄ°MKARELERMATRÄ°SÄ°"; + Text[ hi-IN ] = "MUNIT"; + Text[ ar ] = "MUNIT"; + Text[ he ] = "EINHEITSMATRIX"; + }; + String SC_OPCODE_BACK_SOLVER + { + Text [ de ] = "ZIELWERTSUCHE" ; + Text [ en-US ] = "GOALSEEK" ; + Text [ x-comment ] = " "; + Text[ pt ] = "RESOLVER"; + Text[ ru ] = "ПОДБОРПÐÐ "; + Text[ el ] = "GOALSEEK"; + Text[ nl ] = "DOELZOEKEN"; + Text[ fr ] = "CHERCHEVALCIBLE"; + Text[ es ] = "VALORPRETENDIDO"; + Text[ fi ] = "TAVOITTEEN_HAKU"; + Text[ ca ] = "GOALSEEK"; + Text[ it ] = "RICERCA VALORE DESTINAZIONE"; + Text[ da ] = "MÃ…LSØGNING"; + Text[ sv ] = "MÃ…LSÖKNING"; + Text[ pl ] = "GOALSEEK"; + Text[ pt-BR ] = "ATINGIR.META"; + Text[ th ] = "ค้นหาค่าเป้าหมาย"; + Text[ ja ] = "GOALSEEK"; + Text[ ko ] = "GOALSEEK"; + Text[ zh-CN ] = "GOALSEEK"; + Text[ zh-TW ] = "GOALSEEK"; + Text[ tr ] = "HEDEF ARA"; + Text[ hi-IN ] = "GOALSEEK"; + Text[ ar ] = "البØØ« عن القيمة الهدÙ"; + Text[ he ] = "ZIELWERTSUCHE"; + }; + String SC_OPCODE_HYP_GEOM_DIST + { + Text [ de ] = "HYPGEOMVERT" ; + Text [ en-US ] = "HYPGEOMDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.HIPERGEOM"; + Text[ ru ] = "ГИПЕРГЕОМЕТ"; + Text[ el ] = "HYPGEOMDIST"; + Text[ nl ] = "HYPERGEO.VERD"; + Text[ fr ] = "LOI.HYPERGEOMETRIQUE"; + Text[ es ] = "DISTR.HIPERGEOM"; + Text[ fi ] = "HYPERGEOM_JAKAUMA"; + Text[ ca ] = "HYPGEOMDIST"; + Text[ it ] = "DISTRIB.IPERGEOM"; + Text[ da ] = "HYPGEOFORDELING"; + Text[ sv ] = "HYPGEOMFÖRD"; + Text[ pl ] = "HYPGEOMDIST"; + Text[ pt-BR ] = "DIST.HIPERGEOM"; + Text[ th ] = "HYPGEOMDIST"; + Text[ ja ] = "HYPGEOMDIST"; + Text[ ko ] = "HYPGEOMDIST"; + Text[ zh-CN ] = "HYPGEOMDIST"; + Text[ zh-TW ] = "HYPGEOMDIST"; + Text[ tr ] = "HYPGEOMETRÄ°KDAÄžILIM"; + Text[ hi-IN ] = "HYPGEOMDIST"; + Text[ ar ] = "HYPGEOMDIST"; + Text[ he ] = "HYPGEOMVERT"; + }; + String SC_OPCODE_LOG_NORM_DIST + { + Text [ de ] = "LOGNORMVERT" ; + Text [ en-US ] = "LOGNORMDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.NORMAL.LOG"; + Text[ ru ] = "ЛОГÐОРМРÐСП"; + Text[ el ] = "LOGNORMDIST"; + Text[ nl ] = "LOG.NORM.VERD"; + Text[ fr ] = "LOI.LOGNORMALE"; + Text[ es ] = "DISTR.LOG.NORM"; + Text[ fi ] = "LOGNORM_JAKAUMA"; + Text[ ca ] = "LOGNORMDIST"; + Text[ it ] = "DISTRIB.LOGNORM"; + Text[ da ] = "LOGNORMFORDELING"; + Text[ sv ] = "LOGNORMFÖRD"; + Text[ pl ] = "LOGNORMDIST"; + Text[ pt-BR ] = "DIST.LOGNORMAL"; + Text[ th ] = "LOGNORMDIST"; + Text[ ja ] = "LOGNORMDIST"; + Text[ ko ] = "LOGNORMDIST"; + Text[ zh-CN ] = "LOGNORMDIST"; + Text[ zh-TW ] = "LOGNORMDIST"; + Text[ tr ] = "LOGNORMALDAÄžILIM"; + Text[ hi-IN ] = "LOGNORMDIST"; + Text[ ar ] = "LOGNORMDIST"; + Text[ he ] = "LOGNORMVERT"; + }; + String SC_OPCODE_T_DIST + { + Text [ de ] = "TVERT" ; + Text [ en-US ] = "TDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.T"; + Text[ ru ] = "СТЬЮДРÐСП"; + Text[ el ] = "TDIST"; + Text[ nl ] = "T.VERD"; + Text[ fr ] = "LOI.STUDENT"; + Text[ es ] = "DISTR.T"; + Text[ fi ] = "TJAKAUMA"; + Text[ ca ] = "TDIST"; + Text[ it ] = "DISTRIB.T"; + Text[ da ] = "TFORDELING"; + Text[ sv ] = "TFÖRD"; + Text[ pl ] = "TDIST"; + Text[ pt-BR ] = "DISTT"; + Text[ th ] = "TDIST"; + Text[ ja ] = "TDIST"; + Text[ ko ] = "TDIST"; + Text[ zh-CN ] = "TDIST"; + Text[ zh-TW ] = "TDIST"; + Text[ tr ] = "TDAÄžILIMI"; + Text[ hi-IN ] = "TDIST"; + Text[ ar ] = "TDIST"; + Text[ he ] = "TVERT"; + }; + String SC_OPCODE_F_DIST + { + Text [ de ] = "FVERT" ; + Text [ en-US ] = "FDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.F"; + Text[ ru ] = "FÐ ÐСП"; + Text[ el ] = "FDIST"; + Text[ nl ] = "F.VERDELING"; + Text[ fr ] = "LOI.F"; + Text[ es ] = "DISTR.F"; + Text[ fi ] = "FJAKAUMA"; + Text[ ca ] = "FDIST"; + Text[ it ] = "DISTRIB.F"; + Text[ da ] = "FFORDELING"; + Text[ sv ] = "FFÖRD"; + Text[ pl ] = "FDIST"; + Text[ pt-BR ] = "DISTF"; + Text[ th ] = "FDIST"; + Text[ ja ] = "FDIST"; + Text[ ko ] = "FDIST"; + Text[ zh-CN ] = "FDIST"; + Text[ zh-TW ] = "FDIST"; + Text[ tr ] = "FDAÄžILIMI"; + Text[ hi-IN ] = "FDIST"; + Text[ ar ] = "FDIST"; + Text[ he ] = "FVERT"; + }; + String SC_OPCODE_CHI_DIST + { + Text [ de ] = "CHIVERT" ; + Text [ en-US ] = "CHIDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.CHI"; + Text[ ru ] = "ХИ2Ð ÐСП"; + Text[ el ] = "CHIDIST"; + Text[ nl ] = "CHI.KWADRAAT"; + Text[ fr ] = "LOI.KHIDEUX"; + Text[ es ] = "DISTR.JI"; + Text[ fi ] = "CHIJAKAUMA"; + Text[ ca ] = "CHIDIST"; + Text[ it ] = "DISTRIB.CHI"; + Text[ da ] = "CHIFORDELING"; + Text[ sv ] = "CHI2FÖRD"; + Text[ pl ] = "CHIDIST"; + Text[ pt-BR ] = "DIST.QUI"; + Text[ th ] = "CHIDIST"; + Text[ ja ] = "CHIDIST"; + Text[ ko ] = "CHIDIST"; + Text[ zh-CN ] = "CHIDIST"; + Text[ zh-TW ] = "CHIDIST"; + Text[ tr ] = "CHIDAÄžILIMI"; + Text[ hi-IN ] = "CHIDIST"; + Text[ ar ] = "CHIDIST"; + Text[ he ] = "CHIVERT"; + }; + String SC_OPCODE_WEIBULL + { + Text [ de ] = "WEIBULL" ; + Text [ en-US ] = "WEIBULL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "WEIBULL"; + Text[ ru ] = "ВЕЙБУЛ"; + Text[ el ] = "WEIBULL"; + Text[ nl ] = "WEIBULL"; + Text[ fr ] = "LOI.WEIBULL"; + Text[ es ] = "DIST.WEIBULL"; + Text[ fi ] = "WEIBULL"; + Text[ ca ] = "WEIBULL"; + Text[ it ] = "WEIBULL"; + Text[ da ] = "WEIBULL"; + Text[ sv ] = "WEIBULL"; + Text[ pl ] = "WEIBULL"; + Text[ pt-BR ] = "WEIBULL"; + Text[ th ] = "WEIBULL"; + Text[ ja ] = "WEIBULL"; + Text[ ko ] = "WEIBULL"; + Text[ zh-CN ] = "WEIBULL"; + Text[ zh-TW ] = "WEIBULL"; + Text[ tr ] = "WEIBULL"; + Text[ hi-IN ] = "WEIBULL"; + Text[ ar ] = "WEIBULL"; + Text[ he ] = "WEIBULL"; + }; + String SC_OPCODE_NEG_BINOM_VERT + { + Text [ de ] = "NEGBINOMVERT" ; + Text [ en-US ] = "NEGBINOMDIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.BINOM.NEG"; + Text[ ru ] = "ОТРБИÐОМРÐСП"; + Text[ el ] = "NEGBINOMDIST"; + Text[ nl ] = "NEG.BINOM.VERD"; + Text[ fr ] = "LOI.BINOMIALE.NEG"; + Text[ es ] = "NEGBINOMDIST"; + Text[ fi ] = "BINOMIJAKAUMA_NEG"; + Text[ ca ] = "NEGBINOMDIST"; + Text[ it ] = "DISTRIB.BINOM.NEG"; + Text[ da ] = "NEGBINOMFORDELING"; + Text[ sv ] = "NEGBINOMFÖRD"; + Text[ pl ] = "NEGBINOMDIST"; + Text[ pt-BR ] = "DIST.BIN.NEG"; + Text[ th ] = "NEGBINOMDIST"; + Text[ ja ] = "NEGBINOMDIST"; + Text[ ko ] = "NEGBINOMDIST"; + Text[ zh-CN ] = "NEGBINOMDIST"; + Text[ zh-TW ] = "NEGBINOMDIST"; + Text[ tr ] = "NEGBINOMDAÄžILIMI"; + Text[ hi-IN ] = "NEGBINOMDIST"; + Text[ ar ] = "NEGBINOMDIST"; + Text[ he ] = "NEGBINOMVERT"; + }; + String SC_OPCODE_KRIT_BINOM + { + Text [ de ] = "KRITBINOM" ; + Text [ en-US ] = "CRITBINOM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CRIT.BINOM"; + Text[ ru ] = "КРИТБИÐОМ"; + Text[ el ] = "CRITBINOM"; + Text[ nl ] = "CRIT.BINOM"; + Text[ fr ] = "CRITERE.LOI.BINOMIALE"; + Text[ es ] = "BINOM.CRIT"; + Text[ fi ] = "BINOMIJAKAUMA_KRIT"; + Text[ ca ] = "CRITBINOM"; + Text[ it ] = "CRIT.BINOM"; + Text[ da ] = "KRITBINOM"; + Text[ sv ] = "KRITBINOM"; + Text[ pl ] = "CRITBINOM"; + Text[ pt-BR ] = "CRIT.BINOM"; + Text[ th ] = "CRITBINOM"; + Text[ ja ] = "CRITBINOM"; + Text[ ko ] = "CRITBINOM"; + Text[ zh-CN ] = "CRITBINOM"; + Text[ zh-TW ] = "CRITBINOM"; + Text[ tr ] = "CRITBINOM"; + Text[ hi-IN ] = "CRITBINOM"; + Text[ ar ] = "CRITBINOM"; + Text[ he ] = "KRITBINOM"; + }; + String SC_OPCODE_KURT + { + Text [ de ] = "KURT" ; + Text [ en-US ] = "KURT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "KURT"; + Text[ ru ] = "ÐКСЦЕСС"; + Text[ el ] = "KURT"; + Text[ nl ] = "KURTOSIS"; + Text[ fr ] = "KURTOSIS"; + Text[ es ] = "CURTOSIS"; + Text[ fi ] = "KURT"; + Text[ ca ] = "KURT"; + Text[ it ] = "CURTOSI"; + Text[ da ] = "TOPSTEJL"; + Text[ sv ] = "TOPPIGHET"; + Text[ pl ] = "KURT"; + Text[ pt-BR ] = "CURT"; + Text[ th ] = "KURT"; + Text[ ja ] = "KURT"; + Text[ ko ] = "KURT"; + Text[ zh-CN ] = "KURT"; + Text[ zh-TW ] = "KURT"; + Text[ tr ] = "BASIKLIK"; + Text[ hi-IN ] = "KURT"; + Text[ ar ] = "KURT"; + Text[ he ] = "KURT"; + }; + String SC_OPCODE_HAR_MEAN + { + Text [ de ] = "HARMITTEL" ; + Text [ en-US ] = "HARMEAN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÉDIA.HARMÓNICA"; + Text[ ru ] = "СРГÐÐ Ðœ"; + Text[ el ] = "HARMEAN"; + Text[ nl ] = "HARM.GEM"; + Text[ fr ] = "MOYENNE.HARMONIQUE"; + Text[ es ] = "MEDIA.ARMO"; + Text[ fi ] = "KESKIARVO_HARM"; + Text[ ca ] = "HARMEAN"; + Text[ it ] = "MEDIA.ARMONICA"; + Text[ da ] = "HARMIDDELVÆRDI"; + Text[ sv ] = "HARMMEDEL"; + Text[ pl ] = "HARMEAN"; + Text[ pt-BR ] = "MÉDIA.HARMÔNICA"; + Text[ th ] = "HARMEAN"; + Text[ ja ] = "HARMEAN"; + Text[ ko ] = "HARMEAN"; + Text[ zh-CN ] = "HARMEAN"; + Text[ zh-TW ] = "HARMEAN"; + Text[ tr ] = "HARMONÄ°K"; + Text[ hi-IN ] = "HARMEAN"; + Text[ ar ] = "HARMEAN"; + Text[ he ] = "HARMITTEL"; + }; + String SC_OPCODE_GEO_MEAN + { + Text [ de ] = "GEOMITTEL" ; + Text [ en-US ] = "GEOMEAN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÉDIA.GEOMÉTRICA"; + Text[ ru ] = "СРГЕОМ"; + Text[ el ] = "GEOMEAN"; + Text[ nl ] = "MEETK.GEM"; + Text[ fr ] = "MOYENNE.GEOMETRIQUE"; + Text[ es ] = "MEDIA.GEOM"; + Text[ fi ] = "KESKIARVO_GEOM"; + Text[ ca ] = "GEOMEAN"; + Text[ it ] = "MEDIA.GEOMETRICA"; + Text[ da ] = "GEOMIDDELVÆRDI"; + Text[ sv ] = "GEOMEAN"; + Text[ pl ] = "GEOMEAN"; + Text[ pt-BR ] = "MÉDIA.GEOMÉTRICA"; + Text[ th ] = "GEOMEAN"; + Text[ ja ] = "GEOMEAN"; + Text[ ko ] = "GEOMEAN"; + Text[ zh-CN ] = "GEOMEAN"; + Text[ zh-TW ] = "GEOMEAN"; + Text[ tr ] = "GEOMETRÄ°K"; + Text[ hi-IN ] = "GEOMEAN"; + Text[ ar ] = "GEOMEAN"; + Text[ he ] = "GEOMITTEL"; + }; + String SC_OPCODE_STANDARD + { + Text [ de ] = "STANDARDISIERUNG" ; + Text [ en-US ] = "STANDARDIZE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NORMALIZAR"; + Text[ ru ] = "ÐОРМÐЛИЗÐЦИЯ"; + Text[ el ] = "STANDARDIZE"; + Text[ nl ] = "STANDAARDISERING"; + Text[ fr ] = "CENTREE.REDUITE"; + Text[ es ] = "NORMALIZACIÓN"; + Text[ fi ] = "NORMITA"; + Text[ ca ] = "STANDARDIZE"; + Text[ it ] = "NORMALIZZA"; + Text[ da ] = "STANDARDISER"; + Text[ sv ] = "STANDARDISERA"; + Text[ pl ] = "STANDARDIZE"; + Text[ pt-BR ] = "PADRONIZAR"; + Text[ th ] = "STANDARDIZE"; + Text[ ja ] = "STANDARDIZE"; + Text[ ko ] = "STANDARDIZE"; + Text[ zh-CN ] = "STANDARDIZE"; + Text[ zh-TW ] = "STANDARDIZE"; + Text[ tr ] = "STANDART"; + Text[ hi-IN ] = "STANDARDIZE"; + Text[ ar ] = "STANDARDIZE"; + Text[ he ] = "STANDARDISIERUNG"; + }; + String SC_OPCODE_AVE_DEV + { + Text [ de ] = "MITTELABW" ; + Text [ en-US ] = "AVEDEV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DESV.MÉDIO"; + Text[ ru ] = "СРОТКЛ"; + Text[ el ] = "AVEDEV"; + Text[ nl ] = "GEM.DEVIATIE"; + Text[ fr ] = "ECART.MOYEN"; + Text[ es ] = "DESVPROM"; + Text[ fi ] = "KESKIPOIKKEAMA"; + Text[ ca ] = "AVEDEV"; + Text[ it ] = "MEDIA.DEV"; + Text[ da ] = "MAD"; + Text[ sv ] = "MEDELAVV"; + Text[ pl ] = "AVEDEV"; + Text[ pt-BR ] = "DESV.MÉDIO"; + Text[ th ] = "AVEDEV"; + Text[ ja ] = "AVEDEV"; + Text[ ko ] = "AVEDEV"; + Text[ zh-CN ] = "AVEDEV"; + Text[ zh-TW ] = "AVEDEV"; + Text[ tr ] = "ORTALAMASAPMA"; + Text[ hi-IN ] = "AVEDEV"; + Text[ ar ] = "AVEDEV"; + Text[ he ] = "MITTELABW"; + }; + String SC_OPCODE_SCHIEFE + { + Text [ de ] = "SCHIEFE" ; + Text [ en-US ] = "SKEW" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ASSIMETRIA"; + Text[ ru ] = "СКОС"; + Text[ el ] = "SKEW"; + Text[ nl ] = "SCHEEFHEID"; + Text[ fr ] = "COEFFICIENT.ASYMETRIE"; + Text[ es ] = "COEFICIENTE.ASIMETRIA"; + Text[ fi ] = "JAKAUMAN_VINOUS"; + Text[ ca ] = "SKEW"; + Text[ it ] = "ASIMMETRIA"; + Text[ da ] = "SKÆVHED"; + Text[ sv ] = "SNEDHET"; + Text[ pl ] = "SKEW"; + Text[ pt-BR ] = "DISTORÇÃO"; + Text[ th ] = "SKEW"; + Text[ ja ] = "SKEW"; + Text[ ko ] = "SKEW"; + Text[ zh-CN ] = "SKEW"; + Text[ zh-TW ] = "SKEW"; + Text[ tr ] = "ÇARPIKLIK"; + Text[ hi-IN ] = "SKEW"; + Text[ ar ] = "SKEW"; + Text[ he ] = "SCHIEFE"; + }; + String SC_OPCODE_DEV_SQ + { + Text [ de ] = "SUMQUADABW" ; + Text [ en-US ] = "DEVSQ" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DEVSQ"; + Text[ ru ] = "КВÐДРОТКЛ"; + Text[ el ] = "DEVSQ"; + Text[ nl ] = "DEV.KWAD"; + Text[ fr ] = "SOMME.CARRES.ECARTS"; + Text[ es ] = "DESVIA2"; + Text[ fi ] = "OIKAISTU_NELIÖSUMMA"; + Text[ ca ] = "DEVSQ"; + Text[ it ] = "DEV.Q"; + Text[ da ] = "SAK"; + Text[ sv ] = "KVADAVV"; + Text[ pl ] = "DEVSQ"; + Text[ pt-BR ] = "DESVQ"; + Text[ th ] = "DEVSQ"; + Text[ ja ] = "DEVSQ"; + Text[ ko ] = "DEVSQ"; + Text[ zh-CN ] = "DEVSQ"; + Text[ zh-TW ] = "DEVSQ"; + Text[ tr ] = "SSAPMAKARE"; + Text[ hi-IN ] = "DEVSQ"; + Text[ ar ] = "DEVSQ"; + Text[ he ] = "SUMQUADABW"; + }; + String SC_OPCODE_MEDIAN + { + Text [ de ] = "MEDIAN" ; + Text [ en-US ] = "MEDIAN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MEDIANA"; + Text[ ru ] = "МЕДИÐÐÐ"; + Text[ el ] = "MEDIAN"; + Text[ nl ] = "MEDIAAN"; + Text[ fr ] = "MEDIANE"; + Text[ es ] = "MEDIANA"; + Text[ fi ] = "MEDIAANI"; + Text[ ca ] = "MEDIAN"; + Text[ it ] = "MEDIANA"; + Text[ da ] = "MEDIAN"; + Text[ sv ] = "MEDIAN"; + Text[ pl ] = "MEDIAN"; + Text[ pt-BR ] = "MED"; + Text[ th ] = "MEDIAN"; + Text[ ja ] = "MEDIAN"; + Text[ ko ] = "MEDIAN"; + Text[ zh-CN ] = "MEDIAN"; + Text[ zh-TW ] = "MEDIAN"; + Text[ tr ] = "MEDYAN"; + Text[ hi-IN ] = "MEDIAN"; + Text[ ar ] = "MEDIAN"; + Text[ he ] = "MEDIAN"; + }; + String SC_OPCODE_MODAL_VALUE + { + Text [ de ] = "MODALWERT" ; + Text [ en-US ] = "MODE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MODAL"; + Text[ ru ] = "РЕЖИМ"; + Text[ el ] = "MODE"; + Text[ nl ] = "MODUS"; + Text[ fr ] = "MODE"; + Text[ es ] = "MODA"; + Text[ fi ] = "MOODI"; + Text[ ca ] = "MODE"; + Text[ it ] = "MODA"; + Text[ da ] = "HYPPIGST"; + Text[ sv ] = "TYPVÄRDE"; + Text[ pl ] = "MODE"; + Text[ pt-BR ] = "MODO"; + Text[ th ] = "MODE"; + Text[ ja ] = "MODE"; + Text[ ko ] = "MODE"; + Text[ zh-CN ] = "MODE"; + Text[ zh-TW ] = "MODE"; + Text[ tr ] = "MOD"; + Text[ hi-IN ] = "MODE"; + Text[ ar ] = "MODE"; + Text[ he ] = "MODALWERT"; + }; + String SC_OPCODE_Z_TEST + { + Text [ de ] = "GTEST" ; + Text [ en-US ] = "ZTEST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TESTEZ"; + Text[ ru ] = "ZТЕСТ"; + Text[ el ] = "ZTEST"; + Text[ nl ] = "Z.TOETS"; + Text[ fr ] = "TEST.Z"; + Text[ es ] = "PRUEBA.Z"; + Text[ fi ] = "ZTESTI"; + Text[ ca ] = "ZTEST"; + Text[ it ] = "TEST.Z"; + Text[ da ] = "ZTEST"; + Text[ sv ] = "ZTEST"; + Text[ pl ] = "ZTEST"; + Text[ pt-BR ] = "TESTEZ"; + Text[ th ] = "ZTEST"; + Text[ ja ] = "ZTEST"; + Text[ ko ] = "ZTEST"; + Text[ zh-CN ] = "ZTEST"; + Text[ zh-TW ] = "ZTEST"; + Text[ tr ] = "ZTESTÄ°"; + Text[ hi-IN ] = "ZTEST"; + Text[ ar ] = "ZTEST"; + Text[ he ] = "GTEST"; + }; + String SC_OPCODE_T_TEST + { + Text [ de ] = "TTEST" ; + Text [ en-US ] = "TTEST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TESTE.T"; + Text[ ru ] = "ТТЕСТ"; + Text[ el ] = "TTEST"; + Text[ nl ] = "T.TOETS"; + Text[ fr ] = "TEST.STUDENT"; + Text[ es ] = "PRUEBA.T"; + Text[ fi ] = "TTESTI"; + Text[ ca ] = "TTEST"; + Text[ it ] = "TEST.T"; + Text[ da ] = "TTEST"; + Text[ sv ] = "TTEST"; + Text[ pl ] = "TTEST"; + Text[ pt-BR ] = "TESTET"; + Text[ th ] = "TTEST"; + Text[ ja ] = "TTEST"; + Text[ ko ] = "TTEST"; + Text[ zh-CN ] = "TTEST"; + Text[ zh-TW ] = "TTEST"; + Text[ tr ] = "TTESTÄ°"; + Text[ hi-IN ] = "TTEST"; + Text[ ar ] = "TTEST"; + Text[ he ] = "TTEST"; + }; + String SC_OPCODE_RANK + { + Text [ de ] = "RANG" ; + Text [ en-US ] = "RANK" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ORDEM"; + Text[ ru ] = "Ð ÐÐГ"; + Text[ el ] = "RANK"; + Text[ nl ] = "RANG"; + Text[ fr ] = "RANG"; + Text[ es ] = "JERARQUÃA"; + Text[ fi ] = "ARVON_MUKAAN"; + Text[ ca ] = "RANK"; + Text[ it ] = "RANGO"; + Text[ da ] = "PLADS"; + Text[ sv ] = "RANG"; + Text[ pl ] = "RANK"; + Text[ pt-BR ] = "ORDEM"; + Text[ th ] = "RANK"; + Text[ ja ] = "RANK"; + Text[ ko ] = "RANK"; + Text[ zh-CN ] = "RANK"; + Text[ zh-TW ] = "RANK"; + Text[ tr ] = "SIRA"; + Text[ hi-IN ] = "RANK"; + Text[ ar ] = "RANK"; + Text[ he ] = "RANG"; + }; + String SC_OPCODE_PERCENTILE + { + Text [ de ] = "QUANTIL" ; + Text [ en-US ] = "PERCENTILE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PERCENTIL"; + Text[ ru ] = "ПЕРСЕÐТИЛЬ"; + Text[ el ] = "PERCENTILE"; + Text[ nl ] = "PERCENTIEL"; + Text[ fr ] = "CENTILE"; + Text[ es ] = "PERCENTIL"; + Text[ fi ] = "PROSENTTIPISTE"; + Text[ ca ] = "PERCENTILE"; + Text[ it ] = "PERCENTILE"; + Text[ da ] = "FRAKTIL"; + Text[ sv ] = "PERCENTIL"; + Text[ pl ] = "PERCENTILE"; + Text[ pt-BR ] = "PERCENTIL"; + Text[ th ] = "PERCENTILE"; + Text[ ja ] = "PERCENTILE"; + Text[ ko ] = "PERCENTILE"; + Text[ zh-CN ] = "PERCENTILE"; + Text[ zh-TW ] = "PERCENTILE"; + Text[ tr ] = "PERSENTÄ°L"; + Text[ hi-IN ] = "PERCENTILE"; + Text[ ar ] = "PERCENTILE"; + Text[ he ] = "QUANTIL"; + }; + String SC_OPCODE_PERCENT_RANK + { + Text [ de ] = "QUANTILSRANG" ; + Text [ en-US ] = "PERCENTRANK" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ORDEM.PERCENTUAL"; + Text[ ru ] = "ПРОЦЕÐТРÐÐГ"; + Text[ el ] = "PERCENTRANK"; + Text[ nl ] = "PERCENT.RANG"; + Text[ fr ] = "RANG.POURCENTAGE"; + Text[ es ] = "RANGO.PERCENTIL"; + Text[ fi ] = "PROSENTTIJÄRJESTYS"; + Text[ ca ] = "PERCENTRANK"; + Text[ it ] = "PERCENT.RANGO"; + Text[ da ] = "PROCENTPLADS"; + Text[ sv ] = "PROCENTRANG"; + Text[ pl ] = "PERCENTRANK"; + Text[ pt-BR ] = "ORDEM.PORCENTUAL"; + Text[ th ] = "PERCENTRANK"; + Text[ ja ] = "PERCENTRANK"; + Text[ ko ] = "PERCENTRANK"; + Text[ zh-CN ] = "PERCENTRANK"; + Text[ zh-TW ] = "PERCENTRANK"; + Text[ tr ] = "YÃœZDESIRA"; + Text[ hi-IN ] = "PERCENTRANK"; + Text[ ar ] = "PERCENTRANK"; + Text[ he ] = "QUANTILSRANG"; + }; + String SC_OPCODE_LARGE + { + Text [ de ] = "KGRÖSSTE" ; + Text [ en-US ] = "LARGE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MAIOR"; + Text[ ru ] = "ÐÐИБОЛЬШИЙ"; + Text[ el ] = "LARGE"; + Text[ nl ] = "GROOTSTE"; + Text[ fr ] = "GRANDE.VALEUR"; + Text[ es ] = "K.ESIMO.MAYOR"; + Text[ fi ] = "SUURI"; + Text[ ca ] = "LARGE"; + Text[ it ] = "GRANDE"; + Text[ da ] = "STØRSTE"; + Text[ sv ] = "STÖRSTA"; + Text[ pl ] = "LARGE"; + Text[ pt-BR ] = "MAIOR"; + Text[ th ] = "LARGE"; + Text[ ja ] = "LARGE"; + Text[ ko ] = "LARGE"; + Text[ zh-CN ] = "LARGE"; + Text[ zh-TW ] = "LARGE"; + Text[ tr ] = "GENÄ°Åž"; + Text[ hi-IN ] = "LARGE"; + Text[ ar ] = "LARGE"; + Text[ he ] = "KGRÖSSTE"; + }; + String SC_OPCODE_SMALL + { + Text [ de ] = "KKLEINSTE" ; + Text [ en-US ] = "SMALL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MENOR"; + Text[ ru ] = "ÐÐИМЕÐЬШИЙ"; + Text[ el ] = "SMALL"; + Text[ nl ] = "KLEINSTE"; + Text[ fr ] = "PETITE.VALEUR"; + Text[ es ] = "K.ESIMO.MENOR"; + Text[ fi ] = "PIENI"; + Text[ ca ] = "SMALL"; + Text[ it ] = "PICCOLO"; + Text[ da ] = "MINDSTE"; + Text[ sv ] = "MINSTA"; + Text[ pl ] = "SMALL"; + Text[ pt-BR ] = "MENOR"; + Text[ th ] = "SMALL"; + Text[ ja ] = "SMALL"; + Text[ ko ] = "SMALL"; + Text[ zh-CN ] = "SMALL"; + Text[ zh-TW ] = "SMALL"; + Text[ tr ] = "DAR"; + Text[ hi-IN ] = "SMALL"; + Text[ ar ] = "SMALL"; + Text[ he ] = "KKLEINSTE"; + }; + String SC_OPCODE_FREQUENCY + { + Text [ de ] = "HÄUFIGKEIT" ; + Text [ en-US ] = "FREQUENCY" ; + Text [ x-comment ] = " "; + Text[ pt ] = "FREQUÊNCIA"; + Text[ ru ] = "ЧÐСТОТÐ"; + Text[ el ] = "FREQUENCY"; + Text[ nl ] = "INTERVAL"; + Text[ fr ] = "FREQUENCE"; + Text[ es ] = "FRECUENCIA"; + Text[ fi ] = "TAAJUUS"; + Text[ ca ] = "FREQUENCY"; + Text[ it ] = "FREQUENZA"; + Text[ da ] = "FREKVENS"; + Text[ sv ] = "FREKVENS"; + Text[ pl ] = "FREQUENCY"; + Text[ pt-BR ] = "FREQÜÊNCIA"; + Text[ th ] = "FREQUENCY"; + Text[ ja ] = "FREQUENCY"; + Text[ ko ] = "FREQUENCY"; + Text[ zh-CN ] = "FREQUENCY"; + Text[ zh-TW ] = "FREQUENCY"; + Text[ tr ] = "FREKANS"; + Text[ hi-IN ] = "FREQUENCY"; + Text[ ar ] = "FREQUENCY"; + Text[ he ] = "HÄUFIGKEIT"; + }; + String SC_OPCODE_QUARTILE + { + Text [ de ] = "QUARTILE" ; + Text [ en-US ] = "QUARTILE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "QUARTIL"; + Text[ ru ] = "КВÐРТИЛЬ"; + Text[ el ] = "QUARTILE"; + Text[ nl ] = "KWARTIEL"; + Text[ fr ] = "QUARTILE"; + Text[ es ] = "CUARTIL"; + Text[ fi ] = "NELJÄNNES"; + Text[ ca ] = "QUARTILE"; + Text[ it ] = "QUARTILE"; + Text[ da ] = "KVARTILE"; + Text[ sv ] = "KVARTIL"; + Text[ pl ] = "QUARTILE"; + Text[ pt-BR ] = "QUARTIL"; + Text[ th ] = "QUARTILE"; + Text[ ja ] = "QUARTILE"; + Text[ ko ] = "QUARTILE"; + Text[ zh-CN ] = "QUARTILE"; + Text[ zh-TW ] = "QUARTILE"; + Text[ tr ] = "KARTÄ°L"; + Text[ hi-IN ] = "QUARTILE"; + Text[ ar ] = "QUARTILE"; + Text[ he ] = "QUARTILE"; + }; + String SC_OPCODE_NORM_INV + { + Text [ de ] = "NORMINV" ; + Text [ en-US ] = "NORMINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.NORM"; + Text[ ru ] = "ÐОРМОБР"; + Text[ el ] = "NORMINV"; + Text[ nl ] = "NORM.INV"; + Text[ fr ] = "LOI.NORMALE.INVERSE"; + Text[ es ] = "DISTR.NORM.INV"; + Text[ fi ] = "NORM_JAKAUMA_KÄÄNT"; + Text[ ca ] = "NORMINV"; + Text[ it ] = "INV.NORM"; + Text[ da ] = "NORMINV"; + Text[ sv ] = "NORMINV"; + Text[ pl ] = "NORMINV"; + Text[ pt-BR ] = "INV.NORM"; + Text[ th ] = "NORMINV"; + Text[ ja ] = "NORMINV"; + Text[ ko ] = "NORMINV"; + Text[ zh-CN ] = "NORMINV"; + Text[ zh-TW ] = "NORMINV"; + Text[ tr ] = "TERSNORMALDAÄžILIM"; + Text[ hi-IN ] = "NORMINV"; + Text[ ar ] = "NORMINV"; + Text[ he ] = "NORMINV"; + }; + String SC_OPCODE_CONFIDENCE + { + Text [ de ] = "KONFIDENZ" ; + Text [ en-US ] = "CONFIDENCE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INT.CONFIANÇA"; + Text[ ru ] = "ДОВЕРИТ"; + Text[ el ] = "CONFIDENCE"; + Text[ nl ] = "BETROUWBAARHEID"; + Text[ fr ] = "INTERVALLE.CONFIANCE"; + Text[ es ] = "INTERVALO.CONFIANZA"; + Text[ fi ] = "LUOTTAMUSVÄLI"; + Text[ ca ] = "CONFIDENCE"; + Text[ it ] = "CONFIDENZA"; + Text[ da ] = "KONFIDENSINTERVAL"; + Text[ sv ] = "KONFIDENS"; + Text[ pl ] = "CONFIDENCE"; + Text[ pt-BR ] = "INT.CONFIANÇA"; + Text[ th ] = "CONFIDENCE"; + Text[ ja ] = "CONFIDENCE"; + Text[ ko ] = "CONFIDENCE"; + Text[ zh-CN ] = "CONFIDENCE"; + Text[ zh-TW ] = "CONFIDENCE"; + Text[ tr ] = "GÃœVEN"; + Text[ hi-IN ] = "CONFIDENCE"; + Text[ ar ] = "CONFIDENCE"; + Text[ he ] = "KONFIDENZ"; + }; + String SC_OPCODE_F_TEST + { + Text [ de ] = "FTEST" ; + Text [ en-US ] = "FTEST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TESTEF"; + Text[ ru ] = "FТЕСТ"; + Text[ el ] = "FTEST"; + Text[ nl ] = "F.TOETS"; + Text[ fr ] = "TEST.F"; + Text[ es ] = "PRUEBA.F"; + Text[ fi ] = "FTESTI"; + Text[ ca ] = "FTEST"; + Text[ it ] = "TEST.F"; + Text[ da ] = "FTEST"; + Text[ sv ] = "FTEST"; + Text[ pl ] = "FTEST"; + Text[ pt-BR ] = "TESTEF"; + Text[ th ] = "FTEST"; + Text[ ja ] = "FTEST"; + Text[ ko ] = "FTEST"; + Text[ zh-CN ] = "FTEST"; + Text[ zh-TW ] = "FTEST"; + Text[ tr ] = "FTESTÄ°"; + Text[ hi-IN ] = "FTEST"; + Text[ ar ] = "FTEST"; + Text[ he ] = "FTEST"; + }; + String SC_OPCODE_TRIM_MEAN + { + Text [ de ] = "GESTUTZTMITTEL" ; + Text [ en-US ] = "TRIMMEAN" ; + Text [ x-comment ] = " "; + Text[ pt ] = "MÉDIA.INTERNA"; + Text[ ru ] = "УРЕЗСРЕДÐЕЕ"; + Text[ el ] = "TRIMMEAN"; + Text[ nl ] = "GETRIMD.GEM"; + Text[ fr ] = "MOYENNE.REDUITE"; + Text[ es ] = "MEDIA.ACOTADA"; + Text[ fi ] = "KESKIARVO_TASATTU"; + Text[ ca ] = "TRIMMEAN"; + Text[ it ] = "MEDIA.TRONCATA"; + Text[ da ] = "TRIMMIDDELVÆRDI"; + Text[ sv ] = "TRIMMEDEL"; + Text[ pl ] = "TRIMMEAN"; + Text[ pt-BR ] = "MÉDIA.INTERNA"; + Text[ th ] = "TRIMMEAN"; + Text[ ja ] = "TRIMMEAN"; + Text[ ko ] = "TRIMMEAN"; + Text[ zh-CN ] = "TRIMMEAN"; + Text[ zh-TW ] = "TRIMMEAN"; + Text[ tr ] = "ORTALAMATRIM"; + Text[ hi-IN ] = "TRIMMEAN"; + Text[ ar ] = "TRIMMEAN"; + Text[ he ] = "GESTUTZTMITTEL"; + }; + String SC_OPCODE_PROB + { + Text [ de ] = "WAHRSCHBEREICH" ; + Text [ en-US ] = "PROB" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PROB"; + Text[ ru ] = "ВЕРОЯТÐОСТЬ"; + Text[ el ] = "PROB"; + Text[ nl ] = "KANS"; + Text[ fr ] = "PROBABILITE"; + Text[ es ] = "PROBABILIDAD"; + Text[ fi ] = "TODENNÄKÖISYYS"; + Text[ ca ] = "PROB"; + Text[ it ] = "PROBABILITÀ"; + Text[ da ] = "SANDSYNLIGHED"; + Text[ sv ] = "SANNOLIKHET"; + Text[ pl ] = "PROB"; + Text[ pt-BR ] = "PROB"; + Text[ th ] = "PROB"; + Text[ ja ] = "PROB"; + Text[ ko ] = "PROB"; + Text[ zh-CN ] = "PROB"; + Text[ zh-TW ] = "PROB"; + Text[ tr ] = "OLASILIK"; + Text[ hi-IN ] = "PROB"; + Text[ ar ] = "PROB"; + Text[ he ] = "WAHRSCHBEREICH"; + }; + String SC_OPCODE_CORREL + { + Text [ de ] = "KORREL" ; + Text [ en-US ] = "CORREL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CORREL"; + Text[ ru ] = "КОРРЕЛ"; + Text[ el ] = "CORREL"; + Text[ nl ] = "CORRELATIE"; + Text[ fr ] = "COEFFICIENT.CORRELATION"; + Text[ es ] = "COEF.DE.CORREL"; + Text[ fi ] = "KORRELAATIO"; + Text[ ca ] = "CORREL"; + Text[ it ] = "CORRELAZIONE"; + Text[ da ] = "KORRELATION"; + Text[ sv ] = "KORREL"; + Text[ pl ] = "CORREL"; + Text[ pt-BR ] = "CORREL"; + Text[ th ] = "CORREL"; + Text[ ja ] = "CORREL"; + Text[ ko ] = "CORREL"; + Text[ zh-CN ] = "CORREL"; + Text[ zh-TW ] = "CORREL"; + Text[ tr ] = "KORELASYON"; + Text[ hi-IN ] = "CORREL"; + Text[ ar ] = "CORREL"; + Text[ he ] = "KORREL"; + }; + String SC_OPCODE_COVAR + { + Text [ de ] = "KOVAR" ; + Text [ en-US ] = "COVAR" ; + Text [ x-comment ] = " "; + Text[ pt ] = "COVAR"; + Text[ ru ] = "КОВÐÐ "; + Text[ el ] = "COVAR"; + Text[ nl ] = "COVARIANTIE"; + Text[ fr ] = "COVARIANCE"; + Text[ es ] = "COVAR"; + Text[ fi ] = "KOVARIANSSI"; + Text[ ca ] = "COVAR"; + Text[ it ] = "COVARIANZA"; + Text[ da ] = "KOVARIANS"; + Text[ sv ] = "KOVAR"; + Text[ pl ] = "COVAR"; + Text[ pt-BR ] = "COVAR"; + Text[ th ] = "COVAR"; + Text[ ja ] = "COVAR"; + Text[ ko ] = "COVAR"; + Text[ zh-CN ] = "COVAR"; + Text[ zh-TW ] = "COVAR"; + Text[ tr ] = "KOVARYANS"; + Text[ hi-IN ] = "COVAR"; + Text[ ar ] = "COVAR"; + Text[ he ] = "KOVAR"; + }; + String SC_OPCODE_PEARSON + { + Text [ de ] = "PEARSON" ; + Text [ en-US ] = "PEARSON" ; + Text [ x-comment ] = " "; + Text[ pt ] = "PEARSON"; + Text[ ru ] = "ПИРСОÐ"; + Text[ el ] = "PEARSON"; + Text[ nl ] = "PEARSON"; + Text[ fr ] = "PEARSON"; + Text[ es ] = "PEARSON"; + Text[ fi ] = "PEARSON"; + Text[ ca ] = "PEARSON"; + Text[ it ] = "PEARSON"; + Text[ da ] = "PEARSON"; + Text[ sv ] = "PEARSON"; + Text[ pl ] = "PEARSON"; + Text[ pt-BR ] = "PEARSON"; + Text[ th ] = "PEARSON"; + Text[ ja ] = "PEARSON"; + Text[ ko ] = "PEARSON"; + Text[ zh-CN ] = "PEARSON"; + Text[ zh-TW ] = "PEARSON"; + Text[ tr ] = "PEARSON"; + Text[ hi-IN ] = "PEARSON"; + Text[ ar ] = "PEARSON"; + Text[ he ] = "PEARSON"; + }; + String SC_OPCODE_RSQ + { + Text [ de ] = "BESTIMMTHEITSMASS" ; + Text [ en-US ] = "RSQ" ; + Text [ x-comment ] = " "; + Text[ pt ] = "R.QUAD"; + Text[ ru ] = "КВПИРСОÐ"; + Text[ el ] = "RSQ"; + Text[ nl ] = "R.KWADRAAT"; + Text[ fr ] = "COEFFICIENT.DETERMINATION"; + Text[ es ] = "COEFICIENTE.R2"; + Text[ fi ] = "PEARSON_NELIÖ"; + Text[ ca ] = "RSQ"; + Text[ it ] = "RQ"; + Text[ da ] = "FORKLARINGSGRAD"; + Text[ sv ] = "RKV"; + Text[ pl ] = "RSQ"; + Text[ pt-BR ] = "RQUAD"; + Text[ th ] = "RSQ"; + Text[ ja ] = "RSQ"; + Text[ ko ] = "RSQ"; + Text[ zh-CN ] = "RSQ"; + Text[ zh-TW ] = "RSQ"; + Text[ tr ] = "RSQ"; + Text[ hi-IN ] = "RSQ"; + Text[ ar ] = "RSQ"; + Text[ he ] = "BESTIMMTHEITSMASS"; + }; + String SC_OPCODE_STEYX + { + Text [ de ] = "STFEHLERYX" ; + Text [ en-US ] = "STEYX" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ERRO.TIPO.YX"; + Text[ ru ] = "СТОШYX"; + Text[ el ] = "STEYX"; + Text[ nl ] = "STFOUTYX"; + Text[ fr ] = "ERREUR.TYPE.XY"; + Text[ es ] = "ERROR.TÃPICO.XY"; + Text[ fi ] = "KESKIVIRHE"; + Text[ ca ] = "STEYX"; + Text[ it ] = "ERR.STD.YX"; + Text[ da ] = "STFYX"; + Text[ sv ] = "STDFELYX"; + Text[ pl ] = "STEYX"; + Text[ pt-BR ] = "EPADYX"; + Text[ th ] = "STEYX"; + Text[ ja ] = "STEYX"; + Text[ ko ] = "STEYX"; + Text[ zh-CN ] = "STEYX"; + Text[ zh-TW ] = "STEYX"; + Text[ tr ] = "STEYX"; + Text[ hi-IN ] = "STEYX"; + Text[ ar ] = "STEYX"; + Text[ he ] = "STFEHLERYX"; + }; + String SC_OPCODE_SLOPE + { + Text [ de ] = "STEIGUNG" ; + Text [ en-US ] = "SLOPE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DECLIVE"; + Text[ ru ] = "ÐÐКЛОÐ"; + Text[ el ] = "SLOPE"; + Text[ nl ] = "STIJGING"; + Text[ fr ] = "PENTE"; + Text[ es ] = "PENDIENTE"; + Text[ fi ] = "KULMAKERROIN"; + Text[ ca ] = "SLOPE"; + Text[ it ] = "PENDENZA"; + Text[ da ] = "STIGNING"; + Text[ sv ] = "LUTNING"; + Text[ pl ] = "SLOPE"; + Text[ pt-BR ] = "INCLINAÇÃO"; + Text[ th ] = "SLOPE"; + Text[ ja ] = "SLOPE"; + Text[ ko ] = "SLOPE"; + Text[ zh-CN ] = "SLOPE"; + Text[ zh-TW ] = "SLOPE"; + Text[ tr ] = "EĞİM"; + Text[ hi-IN ] = "SLOPE"; + Text[ ar ] = "SLOPE"; + Text[ he ] = "STEIGUNG"; + }; + String SC_OPCODE_INTERCEPT + { + Text [ de ] = "ACHSENABSCHNITT" ; + Text [ en-US ] = "INTERCEPT" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INTERCEPÇÃO"; + Text[ ru ] = "ОТРЕЗОК"; + Text[ el ] = "INTERCEPT"; + Text[ nl ] = "SNIJPUNT"; + Text[ fr ] = "ORDONNEE.ORIGINE"; + Text[ es ] = "INTERSECCIÓN.EJE"; + Text[ fi ] = "LEIKKAUSPISTE"; + Text[ ca ] = "INTERCEPT"; + Text[ it ] = "INTERCETTA"; + Text[ da ] = "SKÆRING"; + Text[ sv ] = "SKÄRNINGSPUNKT"; + Text[ pl ] = "INTERCEPT"; + Text[ pt-BR ] = "INTERCEPÇÃO"; + Text[ th ] = "INTERCEPT"; + Text[ ja ] = "INTERCEPT"; + Text[ ko ] = "INTERCEPT"; + Text[ zh-CN ] = "INTERCEPT"; + Text[ zh-TW ] = "INTERCEPT"; + Text[ tr ] = "BEKLENEN"; + Text[ hi-IN ] = "INTERCEPT"; + Text[ ar ] = "INTERCEPT"; + Text[ he ] = "ACHSENABSCHNITT"; + }; + String SC_OPCODE_TREND + { + Text [ de ] = "TREND" ; + Text [ en-US ] = "TREND" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TENDÊNCIA"; + Text[ ru ] = "ТЕÐДЕÐЦИЯ"; + Text[ el ] = "TREND"; + Text[ nl ] = "TREND"; + Text[ fr ] = "TENDANCE"; + Text[ es ] = "TENDENCIA"; + Text[ fi ] = "SUUNTAUS"; + Text[ ca ] = "TREND"; + Text[ it ] = "TENDENZA"; + Text[ da ] = "TENDENS"; + Text[ sv ] = "TREND"; + Text[ pl ] = "TREND"; + Text[ pt-BR ] = "TENDÊNCIA"; + Text[ th ] = "TREND"; + Text[ ja ] = "TREND"; + Text[ ko ] = "TREND"; + Text[ zh-CN ] = "TREND"; + Text[ zh-TW ] = "TREND"; + Text[ tr ] = "TREND"; + Text[ hi-IN ] = "TREND"; + Text[ ar ] = "TREND"; + Text[ he ] = "TREND"; + }; + String SC_OPCODE_GROWTH + { + Text [ de ] = "VARIATION" ; + Text [ en-US ] = "GROWTH" ; + Text [ x-comment ] = " "; + Text[ pt ] = "CRESCIMENTO"; + Text[ ru ] = "РОСТ"; + Text[ el ] = "GROWTH"; + Text[ nl ] = "GROEI"; + Text[ fr ] = "CROISSANCE"; + Text[ es ] = "CRECIMIENTO"; + Text[ fi ] = "KASVU"; + Text[ ca ] = "GROWTH"; + Text[ it ] = "CRESCITA"; + Text[ da ] = "FORØGELSE"; + Text[ sv ] = "EXPTREND"; + Text[ pl ] = "GROWTH"; + Text[ pt-BR ] = "CRESCIMENTO"; + Text[ th ] = "GROWTH"; + Text[ ja ] = "GROWTH"; + Text[ ko ] = "GROWTH"; + Text[ zh-CN ] = "GROWTH"; + Text[ zh-TW ] = "GROWTH"; + Text[ tr ] = "BÃœYÃœME"; + Text[ hi-IN ] = "GROWTH"; + Text[ ar ] = "GROWTH"; + Text[ he ] = "VARIATION"; + }; + String SC_OPCODE_RGP + { + Text [ de ] = "RGP" ; + Text [ en-US ] = "LINEST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "REGR.LINEAR"; + Text[ ru ] = "ЛИÐЕЙÐ"; + Text[ el ] = "LINEST"; + Text[ nl ] = "LIJNSCH"; + Text[ fr ] = "DROITEREG"; + Text[ es ] = "ESTIMACIÓN.LINEAL"; + Text[ fi ] = "LINREGR"; + Text[ ca ] = "LINEST"; + Text[ it ] = "REGR.LIN"; + Text[ da ] = "LINREGR"; + Text[ sv ] = "REGR"; + Text[ pl ] = "LINEST"; + Text[ pt-BR ] = "PROJ.LIN"; + Text[ th ] = "LINEST"; + Text[ ja ] = "LINEST"; + Text[ ko ] = "LINEST"; + Text[ zh-CN ] = "LINEST"; + Text[ zh-TW ] = "LINEST"; + Text[ tr ] = "DOÄžRUSALTREND"; + Text[ hi-IN ] = "LINEST"; + Text[ ar ] = "LINEST"; + Text[ he ] = "RGP"; + }; + String SC_OPCODE_RKP + { + Text [ de ] = "RKP" ; + Text [ en-US ] = "LOGEST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "LOGEST"; + Text[ ru ] = "ЛОГПРИБЛ"; + Text[ el ] = "LOGEST"; + Text[ nl ] = "LOGSCH"; + Text[ fr ] = "LOGREG"; + Text[ es ] = "ESTIMACIÓN.LOGARÃTMICA"; + Text[ fi ] = "LOGREGR"; + Text[ ca ] = "LOGEST"; + Text[ it ] = "REGR.LOG"; + Text[ da ] = "LOGREGR"; + Text[ sv ] = "EXPREGR"; + Text[ pl ] = "LOGEST"; + Text[ pt-BR ] = "PROJ.LOG"; + Text[ th ] = "LOGEST"; + Text[ ja ] = "LOGEST"; + Text[ ko ] = "LOGEST"; + Text[ zh-CN ] = "LOGEST"; + Text[ zh-TW ] = "LOGEST"; + Text[ tr ] = "LOGEST"; + Text[ hi-IN ] = "LOGEST"; + Text[ ar ] = "LOGEST"; + Text[ he ] = "RKP"; + }; + String SC_OPCODE_FORECAST + { + Text [ de ] = "SCHÄTZER" ; + Text [ en-US ] = "FORECAST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "REGRESSÃO.LINEAR"; + Text[ ru ] = "ПРЕДСКÐЗ"; + Text[ el ] = "FORECAST"; + Text[ nl ] = "VOORSPELLEN"; + Text[ fr ] = "PREVISION"; + Text[ es ] = "PRONÓSTICO"; + Text[ fi ] = "ENNUSTE"; + Text[ ca ] = "FORECAST"; + Text[ it ] = "PREVISIONE"; + Text[ da ] = "PROGNOSE"; + Text[ sv ] = "PREDIKTION"; + Text[ pl ] = "FORECAST"; + Text[ pt-BR ] = "PREVISÃO"; + Text[ th ] = "FORECAST"; + Text[ ja ] = "FORECAST"; + Text[ ko ] = "FORECAST"; + Text[ zh-CN ] = "FORECAST"; + Text[ zh-TW ] = "FORECAST"; + Text[ tr ] = "TAHMÄ°NÄ°"; + Text[ hi-IN ] = "FORECAST"; + Text[ ar ] = "FORECAST"; + Text[ he ] = "SCHÄTZER"; + }; + String SC_OPCODE_CHI_INV + { + Text [ de ] = "CHIINV" ; + Text [ en-US ] = "CHIINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.CHI"; + Text[ ru ] = "ХИОБР"; + Text[ el ] = "CHIINV"; + Text[ nl ] = "CHI.KWADRAAT.INV"; + Text[ fr ] = "KHIDEUX.INVERSE"; + Text[ es ] = "PRUEBA.JI.INV"; + Text[ fi ] = "CHIJAKAUMA_KÄÄNT"; + Text[ ca ] = "CHIINV"; + Text[ it ] = "INV.CHI"; + Text[ da ] = "CHIINV"; + Text[ sv ] = "CHI2INV"; + Text[ pl ] = "CHIINV"; + Text[ pt-BR ] = "INV.QUI"; + Text[ th ] = "CHIINV"; + Text[ ja ] = "CHIINV"; + Text[ ko ] = "CHIINV"; + Text[ zh-CN ] = "CHIINV"; + Text[ zh-TW ] = "CHIINV"; + Text[ tr ] = "TERSCHI"; + Text[ hi-IN ] = "CHIINV"; + Text[ ar ] = "CHIINV"; + Text[ he ] = "CHIINV"; + }; + String SC_OPCODE_GAMMA_DIST + { + Text [ de ] = "GAMMAVERT" ; + Text [ en-US ] = "GAMMADIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.GAMMA"; + Text[ ru ] = "ГÐММÐÐ ÐСП"; + Text[ el ] = "GAMMADIST"; + Text[ nl ] = "GAMMA.VERD"; + Text[ fr ] = "LOI.GAMMA"; + Text[ es ] = "DISTR.GAMMA"; + Text[ fi ] = "GAMMAJAKAUMA"; + Text[ ca ] = "GAMMADIST"; + Text[ it ] = "DISTRIB.GAMMA"; + Text[ da ] = "GAMMAFORDELING"; + Text[ sv ] = "GAMMAFÖRD"; + Text[ pl ] = "GAMMADIST"; + Text[ pt-BR ] = "DISTGAMA"; + Text[ th ] = "GAMMADIST"; + Text[ ja ] = "GAMMADIST"; + Text[ ko ] = "GAMMADIST"; + Text[ zh-CN ] = "GAMMADIST"; + Text[ zh-TW ] = "GAMMADIST"; + Text[ tr ] = "GAMMADAÄžILIMI"; + Text[ hi-IN ] = "GAMMADIST"; + Text[ ar ] = "GAMMADIST"; + Text[ he ] = "GAMMAVERT"; + }; + String SC_OPCODE_GAMMA_INV + { + Text [ de ] = "GAMMAINV" ; + Text [ en-US ] = "GAMMAINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.GAMMA"; + Text[ ru ] = "ГÐММÐОБР"; + Text[ el ] = "GAMMAINV"; + Text[ nl ] = "GAMMA.INV"; + Text[ fr ] = "LOI.GAMMA.INVERSE"; + Text[ es ] = "DISTR.GAMMA.INV"; + Text[ fi ] = "GAMMAJAKAUMA_KÄÄNT"; + Text[ ca ] = "GAMMAINV"; + Text[ it ] = "INV.GAMMA"; + Text[ da ] = "GAMMAINV"; + Text[ sv ] = "GAMMAINV"; + Text[ pl ] = "GAMMAINV"; + Text[ pt-BR ] = "INVGAMA"; + Text[ th ] = "GAMMAINV"; + Text[ ja ] = "GAMMAINV"; + Text[ ko ] = "GAMMAINV"; + Text[ zh-CN ] = "GAMMAINV"; + Text[ zh-TW ] = "GAMMAINV"; + Text[ tr ] = "TERSGAMMA"; + Text[ hi-IN ] = "GAMMAINV"; + Text[ ar ] = "GAMMAINV"; + Text[ he ] = "GAMMAINV"; + }; + String SC_OPCODE_T_INV + { + Text [ de ] = "TINV" ; + Text [ en-US ] = "TINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.T"; + Text[ ru ] = "СТЬЮДРÐСПОБР"; + Text[ el ] = "TINV"; + Text[ nl ] = "T.INV"; + Text[ fr ] = "LOI.STUDENT.INVERSE"; + Text[ es ] = "DISTR.T.INV"; + Text[ fi ] = "TJAKAUMA_KÄÄNT"; + Text[ ca ] = "TINV"; + Text[ it ] = "INV.T"; + Text[ da ] = "TINV"; + Text[ sv ] = "TINV"; + Text[ pl ] = "TINV"; + Text[ pt-BR ] = "INVT"; + Text[ th ] = "TINV"; + Text[ ja ] = "TINV"; + Text[ ko ] = "TINV"; + Text[ zh-CN ] = "TINV"; + Text[ zh-TW ] = "TINV"; + Text[ tr ] = "TERST"; + Text[ hi-IN ] = "TINV"; + Text[ ar ] = "TINV"; + Text[ he ] = "TINV"; + }; + String SC_OPCODE_F_INV + { + Text [ de ] = "FINV" ; + Text [ en-US ] = "FINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.F"; + Text[ ru ] = "FОБР"; + Text[ el ] = "FINV"; + Text[ nl ] = "F.INVERSE"; + Text[ fr ] = "INVERSE.LOI.F"; + Text[ es ] = "DISTR.F.INV"; + Text[ fi ] = "FJAKAUMA_KÄÄNT"; + Text[ ca ] = "FINV"; + Text[ it ] = "INV.F"; + Text[ da ] = "FINV"; + Text[ sv ] = "FINV"; + Text[ pl ] = "FINV"; + Text[ pt-BR ] = "INVF"; + Text[ th ] = "FINV"; + Text[ ja ] = "FINV"; + Text[ ko ] = "FINV"; + Text[ zh-CN ] = "FINV"; + Text[ zh-TW ] = "FINV"; + Text[ tr ] = "TERSF"; + Text[ hi-IN ] = "FINV"; + Text[ ar ] = "FINV"; + Text[ he ] = "FINV"; + }; + String SC_OPCODE_CHI_TEST + { + Text [ de ] = "CHITEST" ; + Text [ en-US ] = "CHITEST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "TESTE.CHI"; + Text[ ru ] = "ХИТЕСТ"; + Text[ el ] = "CHITEST"; + Text[ nl ] = "CHI.TOETS"; + Text[ fr ] = "TEST.KHIDEUX"; + Text[ es ] = "PRUEBA.JI"; + Text[ fi ] = "CHITESTI"; + Text[ ca ] = "CHITEST"; + Text[ it ] = "TEST.CHI"; + Text[ da ] = "CHITEST"; + Text[ sv ] = "CHI2TEST"; + Text[ pl ] = "CHITEST"; + Text[ pt-BR ] = "TESTE.QUI"; + Text[ th ] = "CHITEST"; + Text[ ja ] = "CHITEST"; + Text[ ko ] = "CHITEST"; + Text[ zh-CN ] = "CHITEST"; + Text[ zh-TW ] = "CHITEST"; + Text[ tr ] = "CHITESTÄ°"; + Text[ hi-IN ] = "CHITEST"; + Text[ ar ] = "CHITEST"; + Text[ he ] = "CHITEST"; + }; + String SC_OPCODE_LOG_INV + { + Text [ de ] = "LOGINV" ; + Text [ en-US ] = "LOGINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.LOG"; + Text[ ru ] = "ЛОГОБР"; + Text[ el ] = "LOGINV"; + Text[ nl ] = "LOG.NORM.INV"; + Text[ fr ] = "LOI.LOGNORMALE.INVERSE"; + Text[ es ] = "INV.LOG"; + Text[ fi ] = "LOGNORM_JAKAUMA_KÄÄNT"; + Text[ ca ] = "LOGINV"; + Text[ it ] = "INV.LOGNORM"; + Text[ da ] = "LOGINV"; + Text[ sv ] = "LOGINV"; + Text[ pl ] = "LOGINV"; + Text[ pt-BR ] = "INVLOG"; + Text[ th ] = "LOGINV"; + Text[ ja ] = "LOGINV"; + Text[ ko ] = "LOGINV"; + Text[ zh-CN ] = "LOGINV"; + Text[ zh-TW ] = "LOGINV"; + Text[ tr ] = "TERSLOG"; + Text[ hi-IN ] = "LOGINV"; + Text[ ar ] = "LOGINV"; + Text[ he ] = "LOGINV"; + }; + String SC_OPCODE_TABLE_OP + { + Text [ de ] = "MEHRFACHOPERATION" ; + Text [ en-US ] = "MULTIPLE.OPERATIONS" ; + Text [ x-comment ] = " "; + Text[ pt ] = "OPERAÇÃO.MÚLTIPLA"; + Text[ ru ] = "СОВМЕЩ.ОПЕРÐЦИИ"; + Text[ el ] = "MULTIPLE.OPERATIONS"; + Text[ nl ] = "MEERVOUD.OPERATIE"; + Text[ fr ] = "OPERATION.MULTIPLE"; + Text[ es ] = "OPERACIÓN.MÚLTIPLE"; + Text[ fi ] = "MULTIPLE_OPERATIONS"; + Text[ ca ] = "MULTIPLE.OPERATIONS"; + Text[ it ] = "OPERAZIONE.MULTIPLA"; + Text[ da ] = "MULTIOPERATION"; + Text[ sv ] = "MULTIPEL.OPERATION"; + Text[ pl ] = "MULTIPLE.OPERATIONS"; + Text[ pt-BR ] = "OPERAÇÃO.MÚLTIPLA"; + Text[ th ] = "หลาย.ปà¸à¸´à¸šà¸±à¸•à¸´à¸à¸²à¸£"; + Text[ ja ] = "MULTIPLE.OPERATIONS"; + Text[ ko ] = "MULTIPLE.OPERATIONS"; + Text[ zh-CN ] = "MULTIPLE.OPERATIONS"; + Text[ zh-TW ] = "MULTIPLE.OPERATIONS"; + Text[ tr ] = "ÇOKLU.Ä°ÅžLEMLER"; + Text[ hi-IN ] = "MULTIPLE.OPERATIONS"; + Text[ ar ] = "MULTIPLE OPERATIONS"; + Text[ he ] = "MEHRFACHOPERATION"; + }; + String SC_OPCODE_BETA_DIST + { + Text [ de ] = "BETAVERT" ; + Text [ en-US ] = "BETADIST" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIST.BETA"; + Text[ ru ] = "БЕТÐÐ ÐСП"; + Text[ el ] = "BETADIST"; + Text[ nl ] = "BÈTA.VERD"; + Text[ fr ] = "LOI.BETA"; + Text[ es ] = "DISTR.BETA"; + Text[ fi ] = "BEETAJAKAUMA"; + Text[ ca ] = "BETADIST"; + Text[ it ] = "DISTRIB.BETA"; + Text[ da ] = "BETAFORDELING"; + Text[ sv ] = "BETAFÖRD"; + Text[ pl ] = "BETADIST"; + Text[ pt-BR ] = "DISTBETA"; + Text[ th ] = "BETADIST"; + Text[ ja ] = "BETADIST"; + Text[ ko ] = "BETADIST"; + Text[ zh-CN ] = "BETADIST"; + Text[ zh-TW ] = "BETADIST"; + Text[ tr ] = "BETADAÄžILIMI"; + Text[ hi-IN ] = "BETADIST"; + Text[ ar ] = "BETADIST"; + Text[ he ] = "BETAVERT"; + }; + String SC_OPCODE_BETA_INV + { + Text [ de ] = "BETAINV" ; + Text [ en-US ] = "BETAINV" ; + Text [ x-comment ] = " "; + Text[ pt ] = "INV.BETA"; + Text[ ru ] = "БЕТÐОБР"; + Text[ el ] = "BETAINV"; + Text[ nl ] = "BÈTA.INV"; + Text[ fr ] = "BETA.INVERSE"; + Text[ es ] = "DISTR.BETA.INV"; + Text[ fi ] = "BEETAJAKAUMA_KÄÄNT"; + Text[ ca ] = "BETAINV"; + Text[ it ] = "INV.BETA"; + Text[ da ] = "BETAINV"; + Text[ sv ] = "BETAINV"; + Text[ pl ] = "BETAINV"; + Text[ pt-BR ] = "BETA.ACUM.INV"; + Text[ th ] = "BETAINV"; + Text[ ja ] = "BETAINV"; + Text[ ko ] = "BETAINV"; + Text[ zh-CN ] = "BETAINV"; + Text[ zh-TW ] = "BETAINV"; + Text[ tr ] = "TERSBETA"; + Text[ hi-IN ] = "BETAINV"; + Text[ ar ] = "BETAINV"; + Text[ he ] = "BETAINV"; + }; + String SC_OPCODE_WEEK + { + Text [ de ] = "KALENDERWOCHE" ; + Text [ en-US ] = "WEEKNUM" ; + Text [ x-comment ] = " "; + Text[ pt ] = "NÚMSEMANA"; + Text[ ru ] = "КÐЛЕÐД.ÐЕДЕЛЯ"; + Text[ el ] = "WEEKNUM"; + Text[ nl ] = "KALENDERWEEK"; + Text[ fr ] = "NO.SEMAINE"; + Text[ es ] = "NÚM.SEMANA"; + Text[ fi ] = "VIIKKO_NRO"; + Text[ ca ] = "WEEKNUM"; + Text[ it ] = "NUM.SETTIMANA"; + Text[ da ] = "KALENDERUGE"; + Text[ sv ] = "VECKONR"; + Text[ pl ] = "WEEKNUM"; + Text[ pt-BR ] = "NÚM.SEMANA"; + Text[ th ] = "WEEKNUM"; + Text[ ja ] = "WEEKNUM"; + Text[ ko ] = "WEEKNUM"; + Text[ zh-CN ] = "WEEKNUM"; + Text[ zh-TW ] = "WEEKNUM"; + Text[ tr ] = "HAFTASAYISI"; + Text[ hi-IN ] = "WEEKNUM"; + Text[ ar ] = "WEEKNUM"; + Text[ he ] = "KALENDERWOCHE"; + }; + String SC_OPCODE_EASTERSUNDAY + { + Text [ de ] = "OSTERSONNTAG" ; + Text [ en-US ] = "EASTERSUNDAY" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DOMINGOPÃSCOA"; + Text[ ru ] = "ПÐСХÐЛЬÐОЕВОСКРЕСЕÐЬЕ"; + Text[ el ] = "EASTERSUNDAY"; + Text[ nl ] = "EERSTEPAASDAG"; + Text[ fr ] = "DIMANCHEDEPAQUES"; + Text[ es ] = "DOMINGOPASCUA"; + Text[ fi ] = "PÄÄS_SUNNUNTAI"; + Text[ ca ] = "EASTERSUNDAY"; + Text[ it ] = "DOMENICA.DI.PASQUA"; + Text[ da ] = "PÃ…SKESØNDAG"; + Text[ sv ] = "PÃ…SKDAGEN"; + Text[ pl ] = "EASTERSUNDAY"; + Text[ pt-BR ] = "DOMINGOPÃSCOA"; + Text[ th ] = "EASTERSUNDAY"; + Text[ ja ] = "EASTERSUNDAY"; + Text[ ko ] = "EASTERSUNDAY"; + Text[ zh-CN ] = "EASTERSUNDAY"; + Text[ zh-TW ] = "EASTERSUNDAY"; + Text[ tr ] = "DOÄžUPAZAR"; + Text[ hi-IN ] = "EASTERSUNDAY"; + Text[ ar ] = "EASTERSUNDAY"; + Text[ he ] = "OSTERSONNTAG"; + }; + String SC_OPCODE_GET_DAY_OF_WEEK + { + Text [ de ] = "WOCHENTAG" ; + Text [ en-US ] = "WEEKDAY" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DIA.SEMANA"; + Text[ ru ] = "ÐЕДДЕÐЬ"; + Text[ el ] = "WEEKDAY"; + Text[ nl ] = "WEEKDAG"; + Text[ fr ] = "JOURSEM"; + Text[ es ] = "DÃASEM"; + Text[ fi ] = "VIIKONPÄIVÄ"; + Text[ ca ] = "WEEKDAY"; + Text[ it ] = "GIORNO.SETTIMANA"; + Text[ da ] = "UGEDAG"; + Text[ sv ] = "VECKODAG"; + Text[ pl ] = "WEEKDAY"; + Text[ pt-BR ] = "DIA.DA.SEMANA"; + Text[ th ] = "WEEKDAY"; + Text[ ja ] = "WEEKDAY"; + Text[ ko ] = "WEEKDAY"; + Text[ zh-CN ] = "WEEKDAY"; + Text[ zh-TW ] = "WEEKDAY"; + Text[ tr ] = "HAFTAİÇİ"; + Text[ hi-IN ] = "WEEKDAY"; + Text[ ar ] = "WEEKDAY"; + Text[ he ] = "WOCHENTAG"; + }; + String SC_OPCODE_NO_NAME + { + Text [ de ] = "#NAME!" ; + Text [ en-US ] = "#NAME!" ; + Text [ x-comment ] = " "; + Text[ pt ] = "#NOME!"; + Text[ ru ] = "#ИМЯ!"; + Text[ el ] = "#NAME!"; + Text[ nl ] = "#NAAM!"; + Text[ fr ] = "#NOM!"; + Text[ es ] = "#NOMBRE!"; + Text[ fi ] = "#NIMI!"; + Text[ ca ] = "#NAME!"; + Text[ it ] = "#NOME!"; + Text[ da ] = "#NAVN!"; + Text[ sv ] = "#NAMN!"; + Text[ pl ] = "#NAME!"; + Text[ pt-BR ] = "#NOME!"; + Text[ th ] = "#NAME!"; + Text[ ja ] = "#NAME!"; + Text[ ko ] = "#NAME!"; + Text[ zh-CN ] = "#NAME!"; + Text[ zh-TW ] = "#NAME!"; + Text[ tr ] = "#AD!"; + Text[ hi-IN ] = "#NAME!"; + Text[ ar ] = "#NAME!"; + Text[ he ] = "#NAME!"; + }; + String SC_OPCODE_STYLE + { + Text [ de ] = "VORLAGE" ; + Text [ en-US ] = "STYLE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "ESTILO"; + Text[ ru ] = "СТИЛЬ"; + Text[ el ] = "STYLE"; + Text[ nl ] = "PROFIEL"; + Text[ fr ] = "STYLE"; + Text[ es ] = "ESTILO"; + Text[ fi ] = "TYYLI"; + Text[ ca ] = "STYLE"; + Text[ it ] = "MODELLO"; + Text[ da ] = "TYPOGRAFI"; + Text[ sv ] = "FORMATMALL"; + Text[ pl ] = "STYLE"; + Text[ pt-BR ] = "ESTILO"; + Text[ th ] = "ลัà¸à¸©à¸“ะ"; + Text[ ja ] = "STYLE"; + Text[ ko ] = "STYLE"; + Text[ zh-CN ] = "STYLE"; + Text[ zh-TW ] = "STYLE"; + Text[ tr ] = "STÄ°L"; + Text[ hi-IN ] = "STYLE"; + Text[ ar ] = "STYLE"; + Text[ he ] = "VORLAGE"; + }; + String SC_OPCODE_DDE + { + Text [ de ] = "DDE"; + Text [ en-US ] = "DDE"; + Text[ pt ] = "DDE"; + Text[ ru ] = "DDE"; + Text[ el ] = "DDE"; + Text[ nl ] = "DDE"; + Text[ fr ] = "DDE"; + Text[ es ] = "DDE"; + Text[ fi ] = "DDE"; + Text[ ca ] = "DDE"; + Text[ it ] = "DDE"; + Text[ da ] = "DDE"; + Text[ sv ] = "DDE"; + Text[ pl ] = "DDE"; + Text[ pt-BR ] = "DDE"; + Text[ th ] = "DDE"; + Text[ ja ] = "DDE"; + Text[ ko ] = "DDE"; + Text[ zh-CN ] = "DDE"; + Text[ zh-TW ] = "DDE"; + Text[ tr ] = "DDE"; + Text[ hi-IN ] = "DDE"; + Text[ ar ] = "DDE"; + Text[ he ] = "DDE"; + }; + String SC_OPCODE_BASE + { + Text [ de ] = "BASIS" ; + Text [ en-US ] = "BASE" ; + Text [ x-comment ] = " "; + Text[ pt ] = "BASE"; + Text[ ru ] = "БÐЗИС"; + Text[ el ] = "BASE"; + Text[ nl ] = "BASIS"; + Text[ fr ] = "BASE"; + Text[ es ] = "BASE"; + Text[ fi ] = "KANTALUKU"; + Text[ ca ] = "BASE"; + Text[ it ] = "BASE"; + Text[ da ] = "BASIS"; + Text[ sv ] = "BAS"; + Text[ pl ] = "BASE"; + Text[ pt-BR ] = "BASE"; + Text[ th ] = "à¸à¸²à¸™"; + Text[ ja ] = "BASE"; + Text[ ko ] = "BASE"; + Text[ zh-CN ] = "BASE"; + Text[ zh-TW ] = "BASE"; + Text[ tr ] = "TABAN"; + Text[ hi-IN ] = "BASE"; + Text[ ar ] = "BASE"; + Text[ he ] = "BASIS"; + }; + String SC_OPCODE_DECIMAL + { + Text [ de ] = "DEZIMAL" ; + Text [ en-US ] = "DECIMAL" ; + Text [ x-comment ] = " "; + Text[ pt ] = "DECIMAL"; + Text[ ru ] = "ДЕСЯТИЧÐЫЙ"; + Text[ el ] = "DECIMAL"; + Text[ nl ] = "DECIMAAL"; + Text[ fr ] = "DECIMAL"; + Text[ es ] = "DECIMAL"; + Text[ fi ] = "DESIMAALI"; + Text[ ca ] = "DECIMAL"; + Text[ it ] = "DECIMALE"; + Text[ da ] = "DECIMAL"; + Text[ sv ] = "DECIMAL"; + Text[ pl ] = "DECIMAL"; + Text[ pt-BR ] = "DECIMAL"; + Text[ th ] = "ทศนิยม"; + Text[ ja ] = "DECIMAL"; + Text[ ko ] = "DECIMAL"; + Text[ zh-CN ] = "DECIMAL"; + Text[ zh-TW ] = "DECIMAL"; + Text[ tr ] = "ONDALIK"; + Text[ hi-IN ] = "DECIMAL"; + Text[ ar ] = "DECIMAL"; + Text[ he ] = "DEZIMAL"; + }; + String SC_OPCODE_CONVERT + { + Text [ de ] = "UMRECHNEN" ; + Text [ en-US ] = "CONVERT"; + Text [ x-comment ] = " "; + Text[ pt ] = "CONVERTER"; + Text[ ru ] = "ПРЕОБРÐЗОВÐÐИЕ"; + Text[ el ] = "CONVERT"; + Text[ nl ] = "CONVERTEREN"; + Text[ fr ] = "CONVERTIR"; + Text[ es ] = "CONVERTIR"; + Text[ fi ] = "MUUNNOS"; + Text[ ca ] = "CONVERT"; + Text[ it ] = "CONVERTI"; + Text[ da ] = "OMREGN"; + Text[ sv ] = "OMRÄKNA"; + Text[ pl ] = "CONVERT"; + Text[ pt-BR ] = "CONVERTER"; + Text[ th ] = "CONVERT"; + Text[ ja ] = "CONVERT"; + Text[ ko ] = "CONVERT"; + Text[ zh-CN ] = "CONVERT"; + Text[ zh-TW ] = "CONVERT"; + Text[ tr ] = "DÖNÜŞTÃœR"; + Text[ hi-IN ] = "CONVERT"; + Text[ ar ] = "CONVERT"; + Text[ he ] = "UMRECHNEN"; + }; + String SC_OPCODE_ROMAN + { + Text [ de ] = "RÖMISCH"; + Text [ en-US ] = "ROMAN"; + Text[ pt ] = "ROMANO"; + Text[ ru ] = "РИМСКИЕ"; + Text[ el ] = "ΡΩΜΑΙΚΑ"; + Text[ nl ] = "ROMEINS"; + Text[ fr ] = "ROMAIN"; + Text[ es ] = "ROMANO"; + Text[ fi ] = "ROMAN"; + Text[ ca ] = "ROMAN"; + Text[ it ] = "ROMANO"; + Text[ da ] = "ROMERTAL"; + Text[ sv ] = "ROMERSK"; + Text[ pl ] = "ROMAN"; + Text[ pt-BR ] = "ROMANO"; + Text[ th ] = "ROMAN"; + Text[ ja ] = "ROMAN"; + Text[ ko ] = "ROMAN"; + Text[ zh-CN ] = "ROMAN"; + Text[ zh-TW ] = "ROMAN"; + Text[ tr ] = "ROMAN"; + Text[ hi-IN ] = "ROMAN"; + Text[ ar ] = "ROMAN"; + Text[ he ] = "RÖMISCH"; + }; +}; +Resource RID_SC_FUNCTION_NAMES_ENGLISH +{ + String SC_OPCODE_IF { Text = "IF" ; }; + String SC_OPCODE_CHOSE { Text = "CHOOSE" ; }; + String SC_OPCODE_OPEN { Text = "(" ; }; + String SC_OPCODE_CLOSE { Text = ")" ; }; + String SC_OPCODE_SEP { Text = ";" ; }; + String SC_OPCODE_PERCENT_SIGN { Text = "%" ; }; + String SC_OPCODE_ADD { Text = "+" ; }; + String SC_OPCODE_SUB { Text = "-" ; }; + String SC_OPCODE_MUL { Text = "*" ; }; + String SC_OPCODE_DIV { Text = "/" ; }; + String SC_OPCODE_AMPERSAND { Text = "&" ; }; + String SC_OPCODE_POW { Text = "^" ; }; + String SC_OPCODE_EQUAL { Text = "=" ; }; + String SC_OPCODE_NOT_EQUAL { Text = "<>" ; }; + String SC_OPCODE_LESS { Text = "<" ; }; + String SC_OPCODE_GREATER { Text = ">" ; }; + String SC_OPCODE_LESS_EQUAL { Text = "<=" ; }; + String SC_OPCODE_GREATER_EQUAL { Text = ">=" ; }; + String SC_OPCODE_AND { Text = "AND" ; }; + String SC_OPCODE_OR { Text = "OR" ; }; + String SC_OPCODE_INTERSECT { Text = "!" ; }; + String SC_OPCODE_UNION { Text = ";" ; }; + String SC_OPCODE_RANGE { Text = ":" ; }; + String SC_OPCODE_NOT { Text = "NOT" ; }; + String SC_OPCODE_NEG { Text = "NEG" ; }; + String SC_OPCODE_NEG_SUB { Text = "-" ; }; + String SC_OPCODE_PI { Text = "PI" ; }; + String SC_OPCODE_RANDOM { Text = "RAND" ; }; + String SC_OPCODE_TRUE { Text = "TRUE" ; }; + String SC_OPCODE_FALSE { Text = "FALSE" ; }; + String SC_OPCODE_GET_ACT_DATE { Text = "TODAY" ; }; + String SC_OPCODE_GET_ACT_TIME { Text = "NOW" ; }; + String SC_OPCODE_NO_VALUE { Text = "NA" ; }; + String SC_OPCODE_CURRENT { Text = "CURRENT" ; }; + String SC_OPCODE_DEG { Text = "DEGREES" ; }; + String SC_OPCODE_RAD { Text = "RADIANS" ; }; + String SC_OPCODE_SIN { Text = "SIN" ; }; + String SC_OPCODE_COS { Text = "COS" ; }; + String SC_OPCODE_TAN { Text = "TAN" ; }; + String SC_OPCODE_COT { Text = "COT" ; }; + String SC_OPCODE_ARC_SIN { Text = "ASIN" ; }; + String SC_OPCODE_ARC_COS { Text = "ACOS" ; }; + String SC_OPCODE_ARC_TAN { Text = "ATAN" ; }; + String SC_OPCODE_ARC_COT { Text = "ACOT" ; }; + String SC_OPCODE_SIN_HYP { Text = "SINH" ; }; + String SC_OPCODE_COS_HYP { Text = "COSH" ; }; + String SC_OPCODE_TAN_HYP { Text = "TANH" ; }; + String SC_OPCODE_COT_HYP { Text = "COTH" ; }; + String SC_OPCODE_ARC_SIN_HYP { Text = "ASINH" ; }; + String SC_OPCODE_ARC_COS_HYP { Text = "ACOSH" ; }; + String SC_OPCODE_ARC_TAN_HYP { Text = "ATANH" ; }; + String SC_OPCODE_ARC_COT_HYP { Text = "ACOTH" ; }; + String SC_OPCODE_EXP { Text = "EXP" ; }; + String SC_OPCODE_LN { Text = "LN" ; }; + String SC_OPCODE_SQRT { Text = "SQRT" ; }; + String SC_OPCODE_FACT { Text = "FACT" ; }; + String SC_OPCODE_GET_YEAR { Text = "YEAR" ; }; + String SC_OPCODE_GET_MONTH { Text = "MONTH" ; }; + String SC_OPCODE_GET_DAY { Text = "DAY" ; }; + String SC_OPCODE_GET_HOUR { Text = "HOUR" ; }; + String SC_OPCODE_GET_MIN { Text = "MINUTE" ; }; + String SC_OPCODE_GET_SEC { Text = "SECOND" ; }; + String SC_OPCODE_PLUS_MINUS { Text = "SIGN" ; }; + String SC_OPCODE_ABS { Text = "ABS" ; }; + String SC_OPCODE_INT { Text = "INT" ; }; + String SC_OPCODE_PHI { Text = "PHI" ; }; + String SC_OPCODE_GAUSS { Text = "GAUSS" ; }; + String SC_OPCODE_IS_EMPTY { Text = "ISBLANK" ; }; + String SC_OPCODE_IS_STRING { Text = "ISTEXT" ; }; + String SC_OPCODE_IS_NON_STRING { Text = "ISNONTEXT" ; }; + String SC_OPCODE_IS_LOGICAL { Text = "ISLOGICAL" ; }; + String SC_OPCODE_TYPE { Text = "TYPE" ; }; + String SC_OPCODE_CELL { Text = "CELL" ; }; + String SC_OPCODE_IS_REF { Text = "ISREF" ; }; + String SC_OPCODE_IS_VALUE { Text = "ISNUMBER" ; }; + String SC_OPCODE_IS_FORMULA { Text = "ISFORMULA" ; }; + String SC_OPCODE_IS_NV { Text = "ISNA" ; }; + String SC_OPCODE_IS_ERR { Text = "ISERR" ; }; + String SC_OPCODE_IS_ERROR { Text = "ISERROR" ; }; + String SC_OPCODE_IS_EVEN { Text = "ISEVEN" ; }; + String SC_OPCODE_IS_ODD { Text = "ISODD" ; }; + String SC_OPCODE_N { Text = "N" ; }; + String SC_OPCODE_GET_DATE_VALUE { Text = "DATEVALUE" ; }; + String SC_OPCODE_GET_TIME_VALUE { Text = "TIMEVALUE" ; }; + String SC_OPCODE_CODE { Text = "CODE" ; }; + String SC_OPCODE_TRIM { Text = "TRIM" ; }; + String SC_OPCODE_UPPER { Text = "UPPER" ; }; + String SC_OPCODE_PROPPER { Text = "PROPER" ; }; + String SC_OPCODE_LOWER { Text = "LOWER" ; }; + String SC_OPCODE_LEN { Text = "LEN" ; }; + String SC_OPCODE_T { Text = "T" ; }; + String SC_OPCODE_VALUE { Text = "VALUE" ; }; + String SC_OPCODE_CLEAN { Text = "CLEAN" ; }; + String SC_OPCODE_CHAR { Text = "CHAR" ; }; + String SC_OPCODE_LOG10 { Text = "LOG10" ; }; + String SC_OPCODE_EVEN { Text = "EVEN" ; }; + String SC_OPCODE_ODD { Text = "ODD" ; }; + String SC_OPCODE_STD_NORM_DIST { Text = "NORMSDIST" ; }; + String SC_OPCODE_FISHER { Text = "FISHER" ; }; + String SC_OPCODE_FISHER_INV { Text = "FISHERINV" ; }; + String SC_OPCODE_S_NORM_INV { Text = "NORMSINV" ; }; + String SC_OPCODE_GAMMA_LN { Text = "GAMMALN" ; }; + String SC_OPCODE_ERROR_TYPE { Text = "ERRORTYPE" ; }; + String SC_OPCODE_ERR_CELL { Text = "ZellError" ; }; // ?? Text klein, dt. & engl. gemischt ?? + String SC_OPCODE_FORMULA { Text = "FORMULA"; }; + String SC_OPCODE_ARC_TAN_2 { Text = "ATAN2" ; }; + String SC_OPCODE_CEIL { Text = "CEILING" ; }; + String SC_OPCODE_FLOOR { Text = "FLOOR" ; }; + String SC_OPCODE_ROUND { Text = "ROUND" ; }; + String SC_OPCODE_ROUND_UP { Text = "ROUNDUP" ; }; + String SC_OPCODE_ROUND_DOWN { Text = "ROUNDDOWN" ; }; + String SC_OPCODE_TRUNC { Text = "TRUNC" ; }; + String SC_OPCODE_LOG { Text = "LOG" ; }; + String SC_OPCODE_POWER { Text = "POWER" ; }; + String SC_OPCODE_GGT { Text = "GCD" ; }; + String SC_OPCODE_KGV { Text = "LCM" ; }; + String SC_OPCODE_MOD { Text = "MOD" ; }; + String SC_OPCODE_SUM_PRODUCT { Text = "SUMPRODUCT" ; }; + String SC_OPCODE_SUM_SQ { Text = "SUMSQ" ; }; + String SC_OPCODE_SUM_X2MY2 { Text = "SUMX2MY2" ; }; + String SC_OPCODE_SUM_X2DY2 { Text = "SUMX2PY2" ; }; + String SC_OPCODE_SUM_XMY2 { Text = "SUMXMY2" ; }; + String SC_OPCODE_GET_DATE { Text = "DATE" ; }; + String SC_OPCODE_GET_TIME { Text = "TIME" ; }; + String SC_OPCODE_GET_DIFF_DATE { Text = "DAYS" ; }; + String SC_OPCODE_GET_DIFF_DATE_360 { Text = "DAYS360" ; }; + String SC_OPCODE_MIN { Text = "MIN" ; }; + String SC_OPCODE_MIN_A { Text = "MINA" ; }; + String SC_OPCODE_MAX { Text = "MAX" ; }; + String SC_OPCODE_MAX_A { Text = "MAXA" ; }; + String SC_OPCODE_SUM { Text = "SUM" ; }; + String SC_OPCODE_PRODUCT { Text = "PRODUCT" ; }; + String SC_OPCODE_AVERAGE { Text = "AVERAGE" ; }; + String SC_OPCODE_AVERAGE_A { Text = "AVERAGEA" ; }; + String SC_OPCODE_COUNT { Text = "COUNT" ; }; + String SC_OPCODE_COUNT_2 { Text = "COUNTA" ; }; + String SC_OPCODE_NBW { Text = "NPV" ; }; + String SC_OPCODE_IKV { Text = "IRR" ; }; + String SC_OPCODE_MIRR { Text = "MIRR" ; }; + String SC_OPCODE_ISPMT { Text = "ISPMT" ; }; + String SC_OPCODE_VAR { Text = "VAR" ; }; + String SC_OPCODE_VAR_A { Text = "VARA" ; }; + String SC_OPCODE_VAR_P { Text = "VARP" ; }; + String SC_OPCODE_VAR_P_A { Text = "VARPA" ; }; + String SC_OPCODE_ST_DEV { Text = "STDEV" ; }; + String SC_OPCODE_ST_DEV_A { Text = "STDEVA" ; }; + String SC_OPCODE_ST_DEV_P { Text = "STDEVP" ; }; + String SC_OPCODE_ST_DEV_P_A { Text = "STDEVPA" ; }; + String SC_OPCODE_B { Text = "B" ; }; + String SC_OPCODE_NORM_DIST { Text = "NORMDIST" ; }; + String SC_OPCODE_EXP_DIST { Text = "EXPONDIST" ; }; + String SC_OPCODE_BINOM_DIST { Text = "BINOMDIST" ; }; + String SC_OPCODE_POISSON_DIST { Text = "POISSON" ; }; + String SC_OPCODE_KOMBIN { Text = "COMBIN" ; }; + String SC_OPCODE_KOMBIN_2 { Text = "COMBINA" ; }; + String SC_OPCODE_VARIATIONEN { Text = "PERMUT" ; }; + String SC_OPCODE_VARIATIONEN_2 { Text = "PERMUTATIONA" ; }; + String SC_OPCODE_BW { Text = "PV" ; }; + String SC_OPCODE_DIA { Text = "SYD" ; }; + String SC_OPCODE_GDA { Text = "DDB" ; }; + String SC_OPCODE_GDA_2 { Text = "DB" ; }; + String SC_OPCODE_VBD { Text = "VDB" ; }; + String SC_OPCODE_LAUFZ { Text = "DURATION" ; }; + String SC_OPCODE_LIA { Text = "SLN" ; }; + String SC_OPCODE_RMZ { Text = "PMT" ; }; + String SC_OPCODE_COLUMNS { Text = "COLUMNS" ; }; + String SC_OPCODE_ROWS { Text = "ROWS" ; }; + String SC_OPCODE_TABLES { Text = "SHEETS" ; }; + String SC_OPCODE_COLUMN { Text = "COLUMN" ; }; + String SC_OPCODE_ROW { Text = "ROW" ; }; + String SC_OPCODE_TABLE { Text = "SHEET" ; }; + String SC_OPCODE_ZGZ { Text = "ZGZ" ; }; + String SC_OPCODE_ZW { Text = "FV" ; }; + String SC_OPCODE_ZZR { Text = "NPER" ; }; + String SC_OPCODE_ZINS { Text = "RATE" ; }; + String SC_OPCODE_ZINS_Z { Text = "IPMT" ; }; + String SC_OPCODE_KAPZ { Text = "PPMT" ; }; + String SC_OPCODE_KUM_ZINS_Z { Text = "CUMIPMT" ; }; + String SC_OPCODE_KUM_KAP_Z { Text = "CUMPRINC" ; }; + String SC_OPCODE_EFFEKTIV { Text = "EFFECTIVE" ; }; + String SC_OPCODE_NOMINAL { Text = "NOMINAL" ; }; + String SC_OPCODE_SUB_TOTAL { Text = "SUBTOTAL" ; }; + String SC_OPCODE_DB_SUM { Text = "DSUM" ; }; + String SC_OPCODE_DB_COUNT { Text = "DCOUNT" ; }; + String SC_OPCODE_DB_COUNT_2 { Text = "DCOUNTA" ; }; + String SC_OPCODE_DB_AVERAGE { Text = "DAVERAGE" ; }; + String SC_OPCODE_DB_GET { Text = "DGET" ; }; + String SC_OPCODE_DB_MAX { Text = "DMAX" ; }; + String SC_OPCODE_DB_MIN { Text = "DMIN" ; }; + String SC_OPCODE_DB_PRODUCT { Text = "DPRODUCT" ; }; + String SC_OPCODE_DB_STD_DEV { Text = "DSTDEV" ; }; + String SC_OPCODE_DB_STD_DEV_P { Text = "DSTDEVP" ; }; + String SC_OPCODE_DB_VAR { Text = "DVAR" ; }; + String SC_OPCODE_DB_VAR_P { Text = "DVARP" ; }; + String SC_OPCODE_INDIRECT { Text = "INDIRECT" ; }; + String SC_OPCODE_ADRESS { Text = "ADDRESS" ; }; + String SC_OPCODE_MATCH { Text = "MATCH" ; }; + String SC_OPCODE_COUNT_EMPTY_CELLS { Text = "COUNTBLANK" ; }; + String SC_OPCODE_COUNT_IF { Text = "COUNTIF" ; }; + String SC_OPCODE_SUM_IF { Text = "SUMIF" ; }; + String SC_OPCODE_LOOKUP { Text = "LOOKUP" ; }; + String SC_OPCODE_V_LOOKUP { Text = "VLOOKUP" ; }; + String SC_OPCODE_H_LOOKUP { Text = "HLOOKUP" ; }; + String SC_OPCODE_MULTI_AREA { Text = "MULTIRANGE" ; }; + String SC_OPCODE_OFFSET { Text = "OFFSET" ; }; + String SC_OPCODE_INDEX { Text = "INDEX" ; }; + String SC_OPCODE_AREAS { Text = "AREAS" ; }; + String SC_OPCODE_CURRENCY { Text = "DOLLAR" ; }; + String SC_OPCODE_REPLACE { Text = "REPLACE" ; }; + String SC_OPCODE_FIXED { Text = "FIXED" ; }; + String SC_OPCODE_FIND { Text = "FIND" ; }; + String SC_OPCODE_EXACT { Text = "EXACT" ; }; + String SC_OPCODE_LEFT { Text = "LEFT" ; }; + String SC_OPCODE_RIGHT { Text = "RIGHT" ; }; + String SC_OPCODE_SEARCH { Text = "SEARCH" ; }; + String SC_OPCODE_MID { Text = "MID" ; }; + String SC_OPCODE_TEXT { Text = "TEXT" ; }; + String SC_OPCODE_SUBSTITUTE { Text = "SUBSTITUTE" ; }; + String SC_OPCODE_REPT { Text = "REPT" ; }; + String SC_OPCODE_CONCAT { Text = "CONCATENATE" ; }; + String SC_OPCODE_MAT_VALUE { Text = "MVALUE" ; }; + String SC_OPCODE_MAT_DET { Text = "MDETERM" ; }; + String SC_OPCODE_MAT_INV { Text = "MINVERSE" ; }; + String SC_OPCODE_MAT_MULT { Text = "MMULT" ; }; + String SC_OPCODE_MAT_TRANS { Text = "TRANSPOSE" ; }; + String SC_OPCODE_MATRIX_UNIT { Text = "MUNIT" ; }; + String SC_OPCODE_BACK_SOLVER { Text = "GOALSEEK" ; }; + String SC_OPCODE_HYP_GEOM_DIST { Text = "HYPGEOMDIST" ; }; + String SC_OPCODE_LOG_NORM_DIST { Text = "LOGNORMDIST" ; }; + String SC_OPCODE_T_DIST { Text = "TDIST" ; }; + String SC_OPCODE_F_DIST { Text = "FDIST" ; }; + String SC_OPCODE_CHI_DIST { Text = "CHIDIST" ; }; + String SC_OPCODE_WEIBULL { Text = "WEIBULL" ; }; + String SC_OPCODE_NEG_BINOM_VERT { Text = "NEGBINOMDIST" ; }; + String SC_OPCODE_KRIT_BINOM { Text = "CRITBINOM" ; }; + String SC_OPCODE_KURT { Text = "KURT" ; }; + String SC_OPCODE_HAR_MEAN { Text = "HARMEAN" ; }; + String SC_OPCODE_GEO_MEAN { Text = "GEOMEAN" ; }; + String SC_OPCODE_STANDARD { Text = "STANDARDIZE" ; }; + String SC_OPCODE_AVE_DEV { Text = "AVEDEV" ; }; + String SC_OPCODE_SCHIEFE { Text = "SKEW" ; }; + String SC_OPCODE_DEV_SQ { Text = "DEVSQ" ; }; + String SC_OPCODE_MEDIAN { Text = "MEDIAN" ; }; + String SC_OPCODE_MODAL_VALUE { Text = "MODE" ; }; + String SC_OPCODE_Z_TEST { Text = "ZTEST" ; }; + String SC_OPCODE_T_TEST { Text = "TTEST" ; }; + String SC_OPCODE_RANK { Text = "RANK" ; }; + String SC_OPCODE_PERCENTILE { Text = "PERCENTILE" ; }; + String SC_OPCODE_PERCENT_RANK { Text = "PERCENTRANK" ; }; + String SC_OPCODE_LARGE { Text = "LARGE" ; }; + String SC_OPCODE_SMALL { Text = "SMALL" ; }; + String SC_OPCODE_FREQUENCY { Text = "FREQUENCY" ; }; + String SC_OPCODE_QUARTILE { Text = "QUARTILE" ; }; + String SC_OPCODE_NORM_INV { Text = "NORMINV" ; }; + String SC_OPCODE_CONFIDENCE { Text = "CONFIDENCE" ; }; + String SC_OPCODE_F_TEST { Text = "FTEST" ; }; + String SC_OPCODE_TRIM_MEAN { Text = "TRIMMEAN" ; }; + String SC_OPCODE_PROB { Text = "PROB" ; }; + String SC_OPCODE_CORREL { Text = "CORREL" ; }; + String SC_OPCODE_COVAR { Text = "COVAR" ; }; + String SC_OPCODE_PEARSON { Text = "PEARSON" ; }; + String SC_OPCODE_RSQ { Text = "RSQ" ; }; + String SC_OPCODE_STEYX { Text = "STEYX" ; }; + String SC_OPCODE_SLOPE { Text = "SLOPE" ; }; + String SC_OPCODE_INTERCEPT { Text = "INTERCEPT" ; }; + String SC_OPCODE_TREND { Text = "TREND" ; }; + String SC_OPCODE_GROWTH { Text = "GROWTH" ; }; + String SC_OPCODE_RGP { Text = "LINEST" ; }; + String SC_OPCODE_RKP { Text = "LOGEST" ; }; + String SC_OPCODE_FORECAST { Text = "FORECAST" ; }; + String SC_OPCODE_CHI_INV { Text = "CHIINV" ; }; + String SC_OPCODE_GAMMA_DIST { Text = "GAMMADIST" ; }; + String SC_OPCODE_GAMMA_INV { Text = "GAMMAINV" ; }; + String SC_OPCODE_T_INV { Text = "TINV" ; }; + String SC_OPCODE_F_INV { Text = "FINV" ; }; + String SC_OPCODE_CHI_TEST { Text = "CHITEST" ; }; + String SC_OPCODE_LOG_INV { Text = "LOGINV" ; }; + String SC_OPCODE_TABLE_OP { Text = "TABLE" ; }; + String SC_OPCODE_BETA_DIST { Text = "BETADIST" ; }; + String SC_OPCODE_BETA_INV { Text = "BETAINV" ; }; + String SC_OPCODE_WEEK { Text = "WEEKNUM" ; }; + String SC_OPCODE_EASTERSUNDAY { Text = "EASTERSUNDAY" ; }; + String SC_OPCODE_GET_DAY_OF_WEEK { Text = "WEEKDAY" ; }; + String SC_OPCODE_NO_NAME { Text = "#NAME!" ; }; + String SC_OPCODE_STYLE { Text = "STYLE" ; }; + String SC_OPCODE_DDE { Text = "DDE" ; }; + String SC_OPCODE_BASE { Text = "BASE" ; }; + String SC_OPCODE_DECIMAL { Text = "DECIMAL" ; }; + String SC_OPCODE_CONVERT { Text = "CONVERT" ; }; + String SC_OPCODE_ROMAN { Text = "ROMAN" ; }; + String SC_OPCODE_ARABIC { Text = "ARABIC" ; }; +}; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/binfilter/bf_sc/source/core/tool/makefile.mk b/binfilter/bf_sc/source/core/tool/makefile.mk new file mode 100644 index 000000000000..927c2cd32f95 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/makefile.mk @@ -0,0 +1,107 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +EXTERNAL_WARNINGS_NOT_ERRORS := TRUE +PRJ=..$/..$/..$/.. +BFPRJ=..$/..$/.. + +PRJNAME=binfilter +TARGET=sc_tool + +NO_HIDS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk +.INCLUDE : $(BFPRJ)$/util$/makefile.pmk +INC+= -I$(PRJ)$/inc$/bf_sc +# --- Files -------------------------------------------------------- + +SLOFILES = \ + $(SLO)$/sc_adiasync.obj \ + $(SLO)$/sc_appoptio.obj \ + $(SLO)$/sc_autoform.obj \ + $(SLO)$/sc_callform.obj \ + $(SLO)$/sc_cellform.obj \ + $(SLO)$/sc_chartarr.obj \ + $(SLO)$/sc_chartlis.obj \ + $(SLO)$/sc_chgtrack.obj \ + $(SLO)$/sc_chgviset.obj \ + $(SLO)$/sc_collect.obj \ + $(SLO)$/sc_compiler.obj \ + $(SLO)$/sc_consoli.obj \ + $(SLO)$/sc_dbcolect.obj \ + $(SLO)$/sc_ddelink.obj \ + $(SLO)$/sc_detfunc.obj \ + $(SLO)$/sc_detdata.obj \ + $(SLO)$/sc_docoptio.obj \ + $(SLO)$/sc_editutil.obj \ + $(SLO)$/sc_indexmap.obj \ + $(SLO)$/sc_interpr1.obj \ + $(SLO)$/sc_interpr2.obj \ + $(SLO)$/sc_interpr3.obj \ + $(SLO)$/sc_interpr4.obj \ + $(SLO)$/sc_interpr5.obj \ + $(SLO)$/sc_interpr6.obj \ + $(SLO)$/sc_progress.obj \ + $(SLO)$/sc_rangenam.obj \ + $(SLO)$/sc_rangelst.obj \ + $(SLO)$/sc_rangeutl.obj \ + $(SLO)$/sc_rechead.obj \ + $(SLO)$/sc_refupdat.obj \ + $(SLO)$/sc_refdata.obj \ + $(SLO)$/sc_scmatrix.obj \ + $(SLO)$/sc_subtotal.obj \ + $(SLO)$/sc_token.obj \ + $(SLO)$/sc_unitconv.obj \ + $(SLO)$/sc_userlist.obj \ + $(SLO)$/sc_viewopti.obj \ + $(SLO)$/sc_inputopt.obj \ + $(SLO)$/sc_printopt.obj \ + $(SLO)$/sc_optutil.obj \ + $(SLO)$/sc_zforauto.obj \ + $(SLO)$/sc_hints.obj \ + $(SLO)$/sc_prnsave.obj \ + $(SLO)$/sc_addincol.obj \ + $(SLO)$/sc_addinlis.obj \ + $(SLO)$/sc_addinhelpid.obj \ + $(SLO)$/sc_rangeseq.obj \ + $(SLO)$/sc_refreshtimer.obj + +EXCEPTIONSFILES= \ + $(SLO)$/sc_addincol.obj + +# [kh] POWERPC compiler problem +.IF "$(OS)$(COM)$(CPUNAME)"=="LINUXGCCPOWERPC" +NOOPTFILES= \ + $(SLO)$/sc_subtotal.obj +.ENDIF + +# --- Tagets ------------------------------------------------------- + +.INCLUDE : target.mk + diff --git a/binfilter/bf_sc/source/core/tool/sc_addincol.cxx b/binfilter/bf_sc/source/core/tool/sc_addincol.cxx new file mode 100644 index 000000000000..e1fced76bac2 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_addincol.cxx @@ -0,0 +1,1119 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <comphelper/processfactory.hxx> +#include <tools/debug.hxx> +#include <i18npool/mslangid.hxx> +#include <vcl/svapp.hxx> +#include <bf_sfx2/objsh.hxx> +#include <unotools/charclass.hxx> + +#include <com/sun/star/container/XContentEnumerationAccess.hpp> +#include <com/sun/star/lang/XServiceName.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/reflection/XIdlClass.hpp> +#include <com/sun/star/reflection/XIdlClassProvider.hpp> +#include <com/sun/star/beans/XIntrospectionAccess.hpp> +#include <com/sun/star/beans/XIntrospection.hpp> +#include <com/sun/star/beans/MethodConcept.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/table/XCellRange.hpp> +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/sheet/XCompatibilityNames.hpp> + +#include "addincol.hxx" +#include "addinhelpid.hxx" +#include "compiler.hxx" +#include "scmatrix.hxx" +#include "addinlis.hxx" +#include "scfuncs.hrc" +#include <legacysmgr/legacy_binfilters_smgr.hxx> +namespace binfilter { +using namespace ::com::sun::star; + +//------------------------------------------------------------------------ + +#define SC_CALLERPOS_NONE (-1) + +#define SCADDINSUPPLIER_SERVICE "com.sun.star.sheet.AddIn" + +//------------------------------------------------------------------------ + + +#define SC_FUNCGROUP_COUNT ID_FUNCTION_GRP_ADDINS + +static const sal_Char* __FAR_DATA aFuncNames[SC_FUNCGROUP_COUNT] = + { + // array index = ID - 1 (ID starts at 1) + // all upper case + "Database", // ID_FUNCTION_GRP_DATABASE + "Date&Time", // ID_FUNCTION_GRP_DATETIME + "Financial", // ID_FUNCTION_GRP_FINANZ + "Information", // ID_FUNCTION_GRP_INFO + "Logical", // ID_FUNCTION_GRP_LOGIC + "Mathematical", // ID_FUNCTION_GRP_MATH + "Matrix", // ID_FUNCTION_GRP_MATRIX + "Statistical", // ID_FUNCTION_GRP_STATISTIC + "Spreadsheet", // ID_FUNCTION_GRP_TABLE + "Text", // ID_FUNCTION_GRP_TEXT + "Add-In" // ID_FUNCTION_GRP_ADDINS + }; + + +//------------------------------------------------------------------------ + +struct ScAddInArgDesc +{ + String aName; + String aDescription; + ScAddInArgumentType eType; + BOOL bOptional; +}; + +class ScUnoAddInFuncData +{ +private: + String aOriginalName; // kept in formula + String aLocalName; // for display + String aUpperName; // for entering formulas + String aUpperLocal; // for entering formulas + String aDescription; + uno::Reference<reflection::XIdlMethod> xFunction; + uno::Any aObject; + long nArgCount; + ScAddInArgDesc* pArgDescs; + long nCallerPos; + USHORT nCategory; + USHORT nHelpId; + mutable uno::Sequence<sheet::LocalizedName> aCompNames; + mutable BOOL bCompInitialized; + +public: + ScUnoAddInFuncData( const String& rNam, const String& rLoc, + const String& rDesc, + USHORT nCat, USHORT nHelp, + const uno::Reference<reflection::XIdlMethod>& rFunc, + const uno::Any& rO, + long nAC, const ScAddInArgDesc* pAD, + long nCP ); + ~ScUnoAddInFuncData(); + + const String& GetOriginalName() const { return aOriginalName; } + const String& GetLocalName() const { return aLocalName; } + const String& GetUpperName() const { return aUpperName; } + const String& GetUpperLocal() const { return aUpperLocal; } + const uno::Reference<reflection::XIdlMethod>& GetFunction() const + { return xFunction; } + const uno::Any& GetObject() const { return aObject; } + long GetArgumentCount() const { return nArgCount; } + const ScAddInArgDesc* GetArguments() const { return pArgDescs; } + long GetCallerPos() const { return nCallerPos; } + const String& GetDescription() const { return aDescription; } + USHORT GetCategory() const { return nCategory; } + USHORT GetHelpId() const { return nHelpId; } + + const uno::Sequence<sheet::LocalizedName>& GetCompNames() const; +}; + +//------------------------------------------------------------------------ + +/*N*/ ScUnoAddInFuncData::ScUnoAddInFuncData( const String& rNam, const String& rLoc, +/*N*/ const String& rDesc, +/*N*/ USHORT nCat, USHORT nHelp, +/*N*/ const uno::Reference<reflection::XIdlMethod>& rFunc, +/*N*/ const uno::Any& rO, +/*N*/ long nAC, const ScAddInArgDesc* pAD, +/*N*/ long nCP ) : +/*N*/ aOriginalName( rNam ), +/*N*/ aUpperName( rNam ), +/*N*/ aLocalName( rLoc ), +/*N*/ aUpperLocal( rLoc ), +/*N*/ aDescription( rDesc ), +/*N*/ nCategory( nCat ), +/*N*/ nHelpId( nHelp ), +/*N*/ xFunction( rFunc ), +/*N*/ aObject( rO ), +/*N*/ nArgCount( nAC ), +/*N*/ nCallerPos( nCP ), +/*N*/ bCompInitialized( FALSE ) +/*N*/ { +/*N*/ if ( nArgCount ) +/*N*/ { +/*N*/ pArgDescs = new ScAddInArgDesc[nArgCount]; +/*N*/ for (long i=0; i<nArgCount; i++) +/*N*/ pArgDescs[i] = pAD[i]; +/*N*/ } +/*N*/ else +/*N*/ pArgDescs = NULL; +/*N*/ +/*N*/ ScGlobal::pCharClass->toUpper(aUpperName); +/*N*/ ScGlobal::pCharClass->toUpper(aUpperLocal); +/*N*/ } + +/*N*/ ScUnoAddInFuncData::~ScUnoAddInFuncData() +/*N*/ { +/*N*/ delete[] pArgDescs; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ BOOL lcl_ConvertToDouble( const uno::Any& rAny, double& rOut ) +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ uno::TypeClass eClass = rAny.getValueTypeClass(); +/*N*/ switch (eClass) +/*N*/ { +/*N*/ //! extract integer values +/*N*/ case uno::TypeClass_ENUM: +/*N*/ case uno::TypeClass_BOOLEAN: +/*N*/ case uno::TypeClass_CHAR: +/*N*/ case uno::TypeClass_BYTE: +/*N*/ case uno::TypeClass_SHORT: +/*N*/ case uno::TypeClass_UNSIGNED_SHORT: +/*N*/ case uno::TypeClass_LONG: +/*N*/ case uno::TypeClass_UNSIGNED_LONG: +/*N*/ case uno::TypeClass_FLOAT: +/*N*/ case uno::TypeClass_DOUBLE: +/*N*/ rAny >>= rOut; +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ } +/*N*/ if (!bRet) +/*N*/ rOut = 0.0; +/*N*/ return bRet; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScUnoAddInCollection::ScUnoAddInCollection() : +/*N*/ nFuncCount( 0 ), +/*N*/ ppFuncData( NULL ), +/*N*/ pExactHashMap( NULL ), +/*N*/ pNameHashMap( NULL ), +/*N*/ pLocalHashMap( NULL ), +/*N*/ bInitialized( FALSE ) +/*N*/ { +/*N*/ } + +/*N*/ ScUnoAddInCollection::~ScUnoAddInCollection() +/*N*/ { +/*N*/ delete pExactHashMap; +/*N*/ delete pNameHashMap; +/*N*/ delete pLocalHashMap; +/*N*/ if ( ppFuncData ) +/*N*/ { +/*N*/ for ( long i=0; i<nFuncCount; i++ ) +/*N*/ delete ppFuncData[i]; +/*N*/ delete[] ppFuncData; +/*N*/ } +/*N*/ } + +/*N*/ void ScUnoAddInCollection::Initialize() +/*N*/ { +/*N*/ DBG_ASSERT( !bInitialized, "Initialize twice?" ); +/*N*/ +/*N*/ uno::Reference<lang::XMultiServiceFactory> xManager = ::legacy_binfilters::getLegacyProcessServiceFactory(); +/*N*/ uno::Reference<container::XContentEnumerationAccess> xEnAc( xManager, uno::UNO_QUERY ); +/*N*/ if ( xEnAc.is() ) +/*N*/ { +/*N*/ uno::Reference<container::XEnumeration> xEnum = +/*N*/ xEnAc->createContentEnumeration( +/*N*/ ::rtl::OUString::createFromAscii(SCADDINSUPPLIER_SERVICE) ); +/*N*/ if ( xEnum.is() ) +/*N*/ { +/*N*/ // loop through all AddIns +/*N*/ while ( xEnum->hasMoreElements() ) +/*N*/ { +/*N*/ uno::Any aAddInAny = xEnum->nextElement(); +/*N*/ //? if ( aAddInAny.getReflection()->getTypeClass() == uno::TypeClass_INTERFACE ) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xIntFac; +/*N*/ aAddInAny >>= xIntFac; +/*N*/ if ( xIntFac.is() ) +/*N*/ { +/*N*/ uno::Reference<lang::XSingleServiceFactory> xFac( xIntFac, uno::UNO_QUERY ); +/*N*/ if ( xFac.is() ) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xInterface = xFac->createInstance(); +/*N*/ ReadFromAddIn( xInterface ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ bInitialized = TRUE; // with or without functions +/*N*/ } + + + +/*N*/ USHORT lcl_GetCategory( const String& rName ) +/*N*/ { +/*N*/ for (USHORT i=0; i<SC_FUNCGROUP_COUNT; i++) +/*N*/ if ( rName.EqualsAscii( aFuncNames[i] ) ) +/*N*/ return i+1; // IDs start at 1 +/*N*/ +/*N*/ return ID_FUNCTION_GRP_ADDINS; // if not found, use Add-In group +/*N*/ } + +/*N*/ inline BOOL IsTypeName( const ::rtl::OUString& rName, const uno::Type& rType ) +/*N*/ { +/*N*/ return rName == rType.getTypeName(); +/*N*/ } + +/*N*/ BOOL lcl_ValidReturnType( const uno::Reference<reflection::XIdlClass>& xClass ) +/*N*/ { +/*N*/ // this must match with ScUnoAddInCall::SetResult +/*N*/ +/*N*/ if ( !xClass.is() ) return FALSE; +/*N*/ +/*N*/ switch (xClass->getTypeClass()) +/*N*/ { +/*N*/ // case uno::TypeClass_VOID: +/*N*/ // ??? +/*N*/ +/*N*/ case uno::TypeClass_ANY: // variable type +/*N*/ case uno::TypeClass_ENUM: //! ??? +/*N*/ case uno::TypeClass_BOOLEAN: +/*N*/ case uno::TypeClass_CHAR: +/*N*/ case uno::TypeClass_BYTE: +/*N*/ case uno::TypeClass_SHORT: +/*N*/ case uno::TypeClass_UNSIGNED_SHORT: +/*N*/ case uno::TypeClass_LONG: +/*N*/ case uno::TypeClass_UNSIGNED_LONG: +/*N*/ case uno::TypeClass_FLOAT: +/*N*/ case uno::TypeClass_DOUBLE: +/*N*/ case uno::TypeClass_STRING: +/*N*/ return TRUE; // values or string +/*N*/ +/*N*/ case uno::TypeClass_INTERFACE: +/*N*/ { +/*N*/ // return type XInterface may contain a XVolatileResult +/*N*/ //! XIdlClass needs getType() method! +/*N*/ +/*N*/ ::rtl::OUString sName = xClass->getName(); +/*N*/ return ( +/*N*/ IsTypeName( sName, getCppuType((uno::Reference<sheet::XVolatileResult>*)0) ) || +/*N*/ IsTypeName( sName, getCppuType((uno::Reference<uno::XInterface>*)0) ) ); +/*N*/ } +/*N*/ +/*N*/ default: +/*N*/ { +/*N*/ // nested sequences for arrays +/*N*/ //! XIdlClass needs getType() method! +/*N*/ +/*N*/ ::rtl::OUString sName = xClass->getName(); +/*N*/ return ( +/*N*/ IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<INT32> >*)0) ) || +/*N*/ IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<double> >*)0) ) || +/*N*/ IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<rtl::OUString> >*)0) ) || +/*N*/ IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<uno::Any> >*)0) ) ); +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ ScAddInArgumentType lcl_GetArgType( const uno::Reference<reflection::XIdlClass>& xClass ) +/*N*/ { +/*N*/ if (!xClass.is()) +/*N*/ return SC_ADDINARG_NONE; +/*N*/ +/*N*/ uno::TypeClass eType = xClass->getTypeClass(); +/*N*/ +/*N*/ if ( eType == uno::TypeClass_LONG ) //! other integer types? +/*N*/ return SC_ADDINARG_INTEGER; +/*N*/ +/*N*/ if ( eType == uno::TypeClass_DOUBLE ) +/*N*/ return SC_ADDINARG_DOUBLE; +/*N*/ +/*N*/ if ( eType == uno::TypeClass_STRING ) +/*N*/ return SC_ADDINARG_STRING; +/*N*/ +/*N*/ //! XIdlClass needs getType() method! +/*N*/ ::rtl::OUString sName = xClass->getName(); +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<INT32> >*)0) )) +/*N*/ return SC_ADDINARG_INTEGER_ARRAY; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<double> >*)0) )) +/*N*/ return SC_ADDINARG_DOUBLE_ARRAY; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<rtl::OUString> >*)0) )) +/*N*/ return SC_ADDINARG_STRING_ARRAY; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Sequence< uno::Sequence<uno::Any> >*)0) )) +/*N*/ return SC_ADDINARG_MIXED_ARRAY; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Any*)0) )) +/*N*/ return SC_ADDINARG_VALUE_OR_ARRAY; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Reference<table::XCellRange>*)0) )) +/*N*/ return SC_ADDINARG_CELLRANGE; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Reference<beans::XPropertySet>*)0) )) +/*N*/ return SC_ADDINARG_CALLER; +/*N*/ +/*N*/ if (IsTypeName( sName, getCppuType((uno::Sequence<uno::Any>*)0) )) +/*N*/ return SC_ADDINARG_VARARGS; +/*N*/ +/*N*/ return SC_ADDINARG_NONE; +/*N*/ } + +/*N*/ void ScUnoAddInCollection::ReadFromAddIn( const uno::Reference<uno::XInterface>& xInterface ) +/*N*/ { +/*N*/ uno::Reference<sheet::XAddIn> xAddIn( xInterface, uno::UNO_QUERY ); +/*N*/ uno::Reference<lang::XServiceName> xName( xInterface, uno::UNO_QUERY ); +/*N*/ if ( xAddIn.is() && xName.is() ) +/*N*/ { +/*N*/ // AddIns must use the language for which the office is installed +/*N*/ LanguageType eOfficeLang = Application::GetSettings().GetUILanguage(); +/*N*/ +/*N*/ lang::Locale aLocale( MsLangId::convertLanguageToLocale( eOfficeLang )); +/*N*/ xAddIn->setLocale( aLocale ); +/*N*/ +/*N*/ String aServiceName = String( xName->getServiceName() ); +/*N*/ ScUnoAddInHelpIdGenerator aHelpIdGenerator( xName->getServiceName() ); +/*N*/ +/*N*/ //! pass XIntrospection to ReadFromAddIn +/*N*/ +/*N*/ uno::Reference<lang::XMultiServiceFactory> xManager = ::legacy_binfilters::getLegacyProcessServiceFactory(); +/*N*/ if ( xManager.is() ) +/*N*/ { +/*N*/ uno::Reference<beans::XIntrospection> xIntro( +/*N*/ xManager->createInstance(::rtl::OUString::createFromAscii( +/*N*/ "com.sun.star.beans.Introspection" )), +/*N*/ uno::UNO_QUERY ); +/*N*/ if ( xIntro.is() ) +/*N*/ { +/*N*/ uno::Any aObject; +/*N*/ aObject <<= xAddIn; +/*N*/ uno::Reference<beans::XIntrospectionAccess> xAcc = xIntro->inspect(aObject); +/*N*/ if (xAcc.is()) +/*N*/ { +/*N*/ uno::Sequence< uno::Reference<reflection::XIdlMethod> > aMethods = +/*N*/ xAcc->getMethods( beans::MethodConcept::ALL ); +/*N*/ long nNewCount = aMethods.getLength(); +/*N*/ if ( nNewCount ) +/*N*/ { +/*N*/ long nOld = nFuncCount; +/*N*/ nFuncCount = nNewCount+nOld; +/*N*/ if ( nOld ) +/*N*/ { +/*N*/ ScUnoAddInFuncData** ppNew = new ScUnoAddInFuncData*[nFuncCount]; +/*N*/ for (long i=0; i<nOld; i++) +/*N*/ ppNew[i] = ppFuncData[i]; +/*N*/ delete[] ppFuncData; +/*N*/ ppFuncData = ppNew; +/*N*/ } +/*N*/ else +/*N*/ ppFuncData = new ScUnoAddInFuncData*[nFuncCount]; +/*N*/ +/*N*/ //! TODO: adjust bucket count? +/*N*/ if ( !pExactHashMap ) +/*N*/ pExactHashMap = new ScAddInHashMap; +/*N*/ if ( !pNameHashMap ) +/*N*/ pNameHashMap = new ScAddInHashMap; +/*N*/ if ( !pLocalHashMap ) +/*N*/ pLocalHashMap = new ScAddInHashMap; +/*N*/ +/*N*/ const uno::Reference<reflection::XIdlMethod>* pArray = aMethods.getConstArray(); +/*N*/ for (long nFuncPos=0; nFuncPos<nNewCount; nFuncPos++) +/*N*/ { +/*N*/ ppFuncData[nFuncPos+nOld] = NULL; +/*N*/ +/*N*/ uno::Reference<reflection::XIdlMethod> xFunc = pArray[nFuncPos]; +/*N*/ if (xFunc.is()) +/*N*/ { +/*N*/ // leave out internal functions +/*N*/ uno::Reference<reflection::XIdlClass> xClass = +/*N*/ xFunc->getDeclaringClass(); +/*N*/ BOOL bSkip = TRUE; +/*N*/ if ( xClass.is() ) +/*N*/ { +/*N*/ //! XIdlClass needs getType() method! +/*N*/ ::rtl::OUString sName = xClass->getName(); +/*N*/ bSkip = ( +/*N*/ IsTypeName( sName, +/*N*/ getCppuType((uno::Reference<uno::XInterface>*)0) ) || +/*N*/ IsTypeName( sName, +/*N*/ getCppuType((uno::Reference<reflection::XIdlClassProvider>*)0) ) || +/*N*/ IsTypeName( sName, +/*N*/ getCppuType((uno::Reference<lang::XServiceName>*)0) ) || +/*N*/ IsTypeName( sName, +/*N*/ getCppuType((uno::Reference<lang::XServiceInfo>*)0) ) || +/*N*/ IsTypeName( sName, +/*N*/ getCppuType((uno::Reference<sheet::XAddIn>*)0) ) ); +/*N*/ } +/*N*/ if (!bSkip) +/*N*/ { +/*N*/ uno::Reference<reflection::XIdlClass> xReturn = +/*N*/ xFunc->getReturnType(); +/*N*/ if ( !lcl_ValidReturnType( xReturn ) ) +/*N*/ bSkip = TRUE; +/*N*/ } +/*N*/ if (!bSkip) +/*N*/ { +/*N*/ ::rtl::OUString aFuncU = xFunc->getName(); +/*N*/ +/*N*/ // stored function name: (service name).(function) +/*N*/ String aFuncName = aServiceName; +/*N*/ aFuncName += '.'; +/*N*/ aFuncName += String( aFuncU ); +/*N*/ +/*N*/ BOOL bValid = TRUE; +/*N*/ long nVisibleCount = 0; +/*N*/ long nCallerPos = SC_CALLERPOS_NONE; +/*N*/ +/*N*/ uno::Sequence<reflection::ParamInfo> aParams = +/*N*/ xFunc->getParameterInfos(); +/*N*/ long nParamCount = aParams.getLength(); +/*N*/ const reflection::ParamInfo* pParArr = aParams.getConstArray(); +/*N*/ long nParamPos; +/*N*/ for (nParamPos=0; nParamPos<nParamCount; nParamPos++) +/*N*/ { +/*N*/ if ( pParArr[nParamPos].aMode != reflection::ParamMode_IN ) +/*N*/ bValid = FALSE; +/*N*/ uno::Reference<reflection::XIdlClass> xParClass = +/*N*/ pParArr[nParamPos].aType; +/*N*/ ScAddInArgumentType eArgType = lcl_GetArgType( xParClass ); +/*N*/ if ( eArgType == SC_ADDINARG_NONE ) +/*N*/ bValid = FALSE; +/*N*/ else if ( eArgType == SC_ADDINARG_CALLER ) +/*N*/ nCallerPos = nParamPos; +/*N*/ else +/*N*/ ++nVisibleCount; +/*N*/ } +/*N*/ if (bValid) +/*N*/ { +/*N*/ USHORT nCategory = lcl_GetCategory( +/*N*/ String( +/*N*/ xAddIn->getProgrammaticCategoryName( +/*N*/ aFuncU ) ) ); +/*N*/ +/*N*/ USHORT nHelpId = aHelpIdGenerator.GetHelpId( aFuncU ); +/*N*/ +/*N*/ ::rtl::OUString aLocalU; +/*N*/ try +/*N*/ { +/*N*/ aLocalU = xAddIn-> +/*N*/ getDisplayFunctionName( aFuncU ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ aLocalU = ::rtl::OUString::createFromAscii( "###" ); +/*N*/ } +/*N*/ String aLocalName = String( aLocalU ); +/*N*/ +/*N*/ ::rtl::OUString aDescU; +/*N*/ try +/*N*/ { +/*N*/ aDescU = xAddIn-> +/*N*/ getFunctionDescription( aFuncU ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ aDescU = ::rtl::OUString::createFromAscii( "###" ); +/*N*/ } +/*N*/ String aDescription = String( aDescU ); +/*N*/ +/*N*/ ScAddInArgDesc* pVisibleArgs = NULL; +/*N*/ if ( nVisibleCount > 0 ) +/*N*/ { +/*N*/ ScAddInArgDesc aDesc; +/*N*/ pVisibleArgs = new ScAddInArgDesc[nVisibleCount]; +/*N*/ long nDestPos = 0; +/*N*/ for (nParamPos=0; nParamPos<nParamCount; nParamPos++) +/*N*/ { +/*N*/ uno::Reference<reflection::XIdlClass> xParClass = +/*N*/ pParArr[nParamPos].aType; +/*N*/ ScAddInArgumentType eArgType = lcl_GetArgType( xParClass ); +/*N*/ if ( eArgType != SC_ADDINARG_CALLER ) +/*N*/ { +/*N*/ ::rtl::OUString aArgName; +/*N*/ try +/*N*/ { +/*N*/ aArgName = xAddIn-> +/*N*/ getDisplayArgumentName( aFuncU, nParamPos ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ aArgName = ::rtl::OUString::createFromAscii( "###" ); +/*N*/ } +/*N*/ ::rtl::OUString aArgDesc; +/*N*/ try +/*N*/ { +/*N*/ aArgDesc = xAddIn-> +/*N*/ getArgumentDescription( aFuncU, nParamPos ); +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ aArgName = ::rtl::OUString::createFromAscii( "###" ); +/*N*/ } +/*N*/ +/*N*/ BOOL bOptional = +/*N*/ ( eArgType == SC_ADDINARG_VALUE_OR_ARRAY || +/*N*/ eArgType == SC_ADDINARG_VARARGS ); +/*N*/ +/*N*/ aDesc.eType = eArgType; +/*N*/ aDesc.aName = String( aArgName ); +/*N*/ aDesc.aDescription = String( aArgDesc ); +/*N*/ aDesc.bOptional = bOptional; +/*N*/ +/*N*/ pVisibleArgs[nDestPos++] = aDesc; +/*N*/ } +/*N*/ } +/*N*/ DBG_ASSERT( nDestPos==nVisibleCount, "wrong count" ); +/*N*/ } +/*N*/ +/*N*/ ppFuncData[nFuncPos+nOld] = new ScUnoAddInFuncData( +/*N*/ aFuncName, aLocalName, aDescription, +/*N*/ nCategory, nHelpId, +/*N*/ xFunc, aObject, +/*N*/ nVisibleCount, pVisibleArgs, nCallerPos ); +/*N*/ +/*N*/ const ScUnoAddInFuncData* pData = +/*N*/ ppFuncData[nFuncPos+nOld]; +/*N*/ pExactHashMap->insert( +/*N*/ ScAddInHashMap::value_type( +/*N*/ pData->GetOriginalName(), +/*N*/ pData ) ); +/*N*/ pNameHashMap->insert( +/*N*/ ScAddInHashMap::value_type( +/*N*/ pData->GetUpperName(), +/*N*/ pData ) ); +/*N*/ pLocalHashMap->insert( +/*N*/ ScAddInHashMap::value_type( +/*N*/ pData->GetUpperLocal(), +/*N*/ pData ) ); +/*N*/ +/*N*/ delete[] pVisibleArgs; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ String ScUnoAddInCollection::FindFunction( const String& rUpperName, BOOL bLocalFirst ) +/*N*/ { +/*N*/ if (!bInitialized) +/*N*/ Initialize(); +/*N*/ +/*N*/ if (nFuncCount == 0) +/*N*/ return EMPTY_STRING; +/*N*/ +/*N*/ if ( bLocalFirst ) +/*N*/ { +/*N*/ // first scan all local names (used for entering formulas) +/*N*/ +/*N*/ ScAddInHashMap::const_iterator iLook( pLocalHashMap->find( rUpperName ) ); +/*N*/ if ( iLook != pLocalHashMap->end() ) +/*?*/ return iLook->second->GetOriginalName(); +/*N*/ +/*N*/ #if 0 +/*N*/ // after that, scan international names (really?) +/*N*/ +/*N*/ iLook = pNameHashMap->find( rUpperName ); +/*N*/ if ( iLook != pNameHashMap->end() ) +/*N*/ return iLook->second->GetOriginalName(); +/*N*/ #endif +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // first scan international names (used when calling a function) +/*N*/ //! before that, check for exact match??? +/*N*/ +/*N*/ ScAddInHashMap::const_iterator iLook( pNameHashMap->find( rUpperName ) ); +/*N*/ if ( iLook != pNameHashMap->end() ) +/*N*/ return iLook->second->GetOriginalName(); +/*N*/ +/*N*/ // after that, scan all local names (to allow replacing old AddIns with Uno) +/*N*/ +/*N*/ iLook = pLocalHashMap->find( rUpperName ); +/*N*/ if ( iLook != pLocalHashMap->end() ) +/*N*/ return iLook->second->GetOriginalName(); +/*N*/ } +/*N*/ +/*N*/ return EMPTY_STRING; +/*N*/ } + +/*N*/ const ScUnoAddInFuncData* ScUnoAddInCollection::GetFuncData( const String& rName ) +/*N*/ { +/*N*/ if (!bInitialized) +/*?*/ Initialize(); +/*N*/ +/*N*/ // rName must be the exact internal name +/*N*/ +/*N*/ ScAddInHashMap::const_iterator iLook( pExactHashMap->find( rName ) ); +/*N*/ if ( iLook != pExactHashMap->end() ) +/*N*/ return iLook->second; +/*N*/ +/*N*/ return NULL; +/*N*/ } + + + + + + +//------------------------------------------------------------------------ + +/*N*/ ScUnoAddInCall::ScUnoAddInCall( ScUnoAddInCollection& rColl, const String& rName, +/*N*/ long nParamCount ) : +/*N*/ nErrCode( errNoCode ), // before function was called +/*N*/ bHasString( TRUE ), +/*N*/ fValue( 0.0 ), +/*N*/ pMatrix( NULL ), +/*N*/ bValidCount( FALSE ) +/*N*/ { +/*N*/ pFuncData = rColl.GetFuncData( rName ); +/*N*/ DBG_ASSERT( pFuncData, "Function Data missing" ); +/*N*/ if ( pFuncData ) +/*N*/ { +/*N*/ long nDescCount = pFuncData->GetArgumentCount(); +/*N*/ const ScAddInArgDesc* pArgs = pFuncData->GetArguments(); +/*N*/ long nVarCount = 0; +/*N*/ +/*N*/ // is aVarArg sequence needed? +/*N*/ if ( nParamCount >= nDescCount && nDescCount > 0 && +/*N*/ pArgs[nDescCount-1].eType == SC_ADDINARG_VARARGS ) +/*N*/ { +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 long nVarCount = nParamCount - ( nDescCount - 1 ); // size of last argument +/*N*/ } +/*N*/ else if ( nParamCount <= nDescCount ) +/*N*/ { +/*N*/ // all args behind nParamCount must be optional +/*N*/ bValidCount = TRUE; +/*N*/ for (long i=nParamCount; i<nDescCount; i++) +/*?*/ if ( !pArgs[i].bOptional ) +/*?*/ bValidCount = FALSE; +/*N*/ } +/*N*/ // else invalid (too many arguments) +/*N*/ +/*N*/ if ( bValidCount ) +/*N*/ aArgs.realloc( nDescCount ); // sequence must always match function signature +/*N*/ } +/*N*/ } + +/*N*/ ScUnoAddInCall::~ScUnoAddInCall() +/*N*/ { +/*N*/ // pFuncData is deleted with ScUnoAddInCollection +/*N*/ +/*N*/ delete pMatrix; +/*N*/ } + +/*N*/ BOOL ScUnoAddInCall::ValidParamCount() +/*N*/ { +/*N*/ return bValidCount; +/*N*/ } + +/*N*/ ScAddInArgumentType ScUnoAddInCall::GetArgType( long nPos ) +/*N*/ { +/*N*/ if ( pFuncData ) +/*N*/ { +/*N*/ long nCount = pFuncData->GetArgumentCount(); +/*N*/ const ScAddInArgDesc* pArgs = pFuncData->GetArguments(); +/*N*/ +/*N*/ // if last arg is sequence, use "any" type +/*N*/ if ( nCount > 0 && nPos >= nCount-1 && pArgs[nCount-1].eType == SC_ADDINARG_VARARGS ) +/*N*/ return SC_ADDINARG_VALUE_OR_ARRAY; +/*N*/ +/*N*/ if ( nPos < nCount ) +/*N*/ return pArgs[nPos].eType; +/*N*/ } +/*N*/ return SC_ADDINARG_VALUE_OR_ARRAY; //! error code !!!! +/*N*/ } + +/*N*/ BOOL ScUnoAddInCall::NeedsCaller() const +/*N*/ { +/*N*/ return pFuncData && pFuncData->GetCallerPos() != SC_CALLERPOS_NONE; +/*N*/ } + +/*N*/ void ScUnoAddInCall::SetCaller( const uno::Reference<uno::XInterface>& rInterface ) +/*N*/ { +/*N*/ xCaller = rInterface; +/*N*/ } + +/*N*/ void ScUnoAddInCall::SetCallerFromObjectShell( SfxObjectShell* pObjSh ) +/*N*/ { +/*N*/ if (pObjSh) +/*N*/ { +/*N*/ uno::Reference<uno::XInterface> xInt( pObjSh->GetBaseModel(), uno::UNO_QUERY ); +/*N*/ SetCaller( xInt ); +/*N*/ } +/*N*/ } + +/*N*/ void ScUnoAddInCall::SetParam( long nPos, const uno::Any& rValue ) +/*N*/ { +/*N*/ if ( pFuncData ) +/*N*/ { +/*N*/ long nCount = pFuncData->GetArgumentCount(); +/*N*/ const ScAddInArgDesc* pArgs = pFuncData->GetArguments(); +/*N*/ if ( nCount > 0 && nPos >= nCount-1 && pArgs[nCount-1].eType == SC_ADDINARG_VARARGS ) +/*N*/ { +/*N*/ long nVarPos = nPos-(nCount-1); +/*N*/ if ( nVarPos < aVarArg.getLength() ) +/*N*/ aVarArg.getArray()[nVarPos] = rValue; +/*N*/ else +/*N*/ DBG_ERROR("wrong argument number"); +/*N*/ } +/*N*/ else if ( nPos < aArgs.getLength() ) +/*N*/ aArgs.getArray()[nPos] = rValue; +/*N*/ else +/*N*/ DBG_ERROR("wrong argument number"); +/*N*/ } +/*N*/ } + +/*N*/ void ScUnoAddInCall::ExecuteCall() +/*N*/ { +/*N*/ if ( !pFuncData ) +/*N*/ return; +/*N*/ +/*N*/ long nCount = pFuncData->GetArgumentCount(); +/*N*/ const ScAddInArgDesc* pArgs = pFuncData->GetArguments(); +/*N*/ if ( nCount > 0 && pArgs[nCount-1].eType == SC_ADDINARG_VARARGS ) +/*N*/ { +/*N*/ // insert aVarArg as last argument +/*N*/ //! after inserting caller (to prevent copying twice)? +/*N*/ +/*N*/ DBG_ASSERT( aArgs.getLength() == nCount, "wrong argument count" ); +/*N*/ aArgs.getArray()[nCount-1] <<= aVarArg; +/*N*/ } +/*N*/ +/*N*/ if ( pFuncData->GetCallerPos() != SC_CALLERPOS_NONE ) +/*N*/ { +/*N*/ uno::Any aCallerAny; +/*N*/ aCallerAny <<= xCaller; +/*N*/ +/*N*/ long nUserLen = aArgs.getLength(); +/*N*/ long nCallPos = pFuncData->GetCallerPos(); +/*N*/ if (nCallPos>nUserLen) // should not happen +/*N*/ { +/*N*/ DBG_ERROR("wrong CallPos"); +/*N*/ nCallPos = nUserLen; +/*N*/ } +/*N*/ +/*N*/ long nDestLen = nUserLen + 1; +/*N*/ uno::Sequence<uno::Any> aRealArgs( nDestLen ); +/*N*/ uno::Any* pDest = aRealArgs.getArray(); +/*N*/ +/*N*/ const uno::Any* pSource = aArgs.getConstArray(); +/*N*/ long nSrcPos = 0; +/*N*/ +/*N*/ for ( long nDestPos = 0; nDestPos < nDestLen; nDestPos++ ) +/*N*/ { +/*N*/ if ( nDestPos == nCallPos ) +/*N*/ pDest[nDestPos] = aCallerAny; +/*N*/ else +/*N*/ pDest[nDestPos] = pSource[nSrcPos++]; +/*N*/ } +/*N*/ +/*N*/ ExecuteCallWithArgs( aRealArgs ); +/*N*/ } +/*N*/ else +/*N*/ ExecuteCallWithArgs( aArgs ); +/*N*/ } + +/*N*/ void ScUnoAddInCall::ExecuteCallWithArgs(uno::Sequence<uno::Any>& rCallArgs) +/*N*/ { +/*N*/ // rCallArgs may not match argument descriptions (because of caller) +/*N*/ +/*N*/ uno::Reference<reflection::XIdlMethod> xFunction; +/*N*/ uno::Any aObject; +/*N*/ if ( pFuncData ) +/*N*/ { +/*N*/ xFunction = pFuncData->GetFunction(); +/*N*/ aObject = pFuncData->GetObject(); +/*N*/ } +/*N*/ +/*N*/ if ( xFunction.is() ) +/*N*/ { +/*N*/ uno::Any aAny; +/*N*/ nErrCode = 0; +/*N*/ +/*N*/ try +/*N*/ { +/*N*/ aAny = xFunction->invoke( aObject, rCallArgs ); +/*N*/ } +/*N*/ catch(lang::IllegalArgumentException&) +/*N*/ { +/*N*/ nErrCode = errIllegalArgument; +/*N*/ } +/*N*/ #if 0 +/*N*/ catch(FloatingPointException&) +/*N*/ { +/*N*/ nErrCode = errIllegalFPOperation; +/*N*/ } +/*N*/ #endif +/*N*/ catch(reflection::InvocationTargetException& rWrapped) +/*N*/ { +/*N*/ if ( rWrapped.TargetException.getValueType().equals( +/*N*/ getCppuType( (lang::IllegalArgumentException*)0 ) ) ) +/*N*/ nErrCode = errIllegalArgument; +/*N*/ else +/*N*/ nErrCode = errNoValue; +/*N*/ } +/*N*/ catch(uno::Exception&) +/*N*/ { +/*N*/ nErrCode = errNoValue; +/*N*/ } +/*N*/ +/*N*/ if (!nErrCode) +/*N*/ SetResult( aAny ); // convert result to Calc types +/*N*/ } +/*N*/ } + +/*N*/ void ScUnoAddInCall::SetResult( const uno::Any& rNewRes ) +/*N*/ { +/*N*/ nErrCode = 0; +/*N*/ xVarRes = NULL; +/*N*/ +/*N*/ // Reflection* pRefl = rNewRes.getReflection(); +/*N*/ +/*N*/ uno::TypeClass eClass = rNewRes.getValueTypeClass(); +/*N*/ uno::Type aType = rNewRes.getValueType(); +/*N*/ switch (eClass) +/*N*/ { +/*N*/ case uno::TypeClass_VOID: +/*N*/ nErrCode = NOVALUE; // #nv +/*N*/ break; +/*N*/ +/*N*/ case uno::TypeClass_ENUM: +/*N*/ case uno::TypeClass_BOOLEAN: +/*N*/ case uno::TypeClass_CHAR: +/*N*/ case uno::TypeClass_BYTE: +/*N*/ case uno::TypeClass_SHORT: +/*N*/ case uno::TypeClass_UNSIGNED_SHORT: +/*N*/ case uno::TypeClass_LONG: +/*N*/ case uno::TypeClass_UNSIGNED_LONG: +/*N*/ case uno::TypeClass_FLOAT: +/*N*/ case uno::TypeClass_DOUBLE: +/*N*/ lcl_ConvertToDouble( rNewRes, fValue ); +/*N*/ bHasString = FALSE; +/*N*/ break; +/*N*/ +/*N*/ case uno::TypeClass_STRING: +/*N*/ { +/*N*/ ::rtl::OUString aUStr; +/*N*/ rNewRes >>= aUStr; +/*N*/ aString = String( aUStr ); +/*N*/ bHasString = TRUE; +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case uno::TypeClass_INTERFACE: +/*N*/ { +/*N*/ //! directly extract XVolatileResult from any? +/*N*/ uno::Reference<uno::XInterface> xInterface; +/*N*/ rNewRes >>= xInterface; +/*N*/ if ( xInterface.is() ) +/*N*/ xVarRes = uno::Reference<sheet::XVolatileResult>( xInterface, uno::UNO_QUERY ); +/*N*/ +/*N*/ if (!xVarRes.is()) +/*N*/ nErrCode = errNoValue; // unknown interface +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<INT32> > *)0 ) ) ) +/*N*/ { +/*N*/ const uno::Sequence< uno::Sequence<INT32> >* pRowSeq = NULL; +/*N*/ +/*N*/ //! use pointer from any! +/*N*/ uno::Sequence< uno::Sequence<INT32> > aSequence; +/*N*/ if ( rNewRes >>= aSequence ) +/*N*/ pRowSeq = &aSequence; +/*N*/ +/*N*/ if ( pRowSeq ) +/*N*/ { +/*N*/ long nRowCount = pRowSeq->getLength(); +/*N*/ const uno::Sequence<INT32>* pRowArr = pRowSeq->getConstArray(); +/*N*/ long nMaxColCount = 0; +/*N*/ long nCol, nRow; +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nTmp = pRowArr[nRow].getLength(); +/*N*/ if ( nTmp > nMaxColCount ) +/*N*/ nMaxColCount = nTmp; +/*N*/ } +/*N*/ if ( nMaxColCount && nRowCount ) +/*N*/ { +/*N*/ pMatrix = new ScMatrix( (USHORT)nMaxColCount, (USHORT)nRowCount ); +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nColCount = pRowArr[nRow].getLength(); +/*N*/ const INT32* pColArr = pRowArr[nRow].getConstArray(); +/*N*/ for (nCol=0; nCol<nColCount; nCol++) +/*N*/ pMatrix->PutDouble( pColArr[nCol], (USHORT)nCol, (USHORT)nRow ); +/*N*/ for (nCol=nColCount; nCol<nMaxColCount; nCol++) +/*N*/ pMatrix->PutDouble( 0.0, (USHORT)nCol, (USHORT)nRow ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<double> > *)0 ) ) ) +/*N*/ { +/*N*/ const uno::Sequence< uno::Sequence<double> >* pRowSeq = NULL; +/*N*/ +/*N*/ //! use pointer from any! +/*N*/ uno::Sequence< uno::Sequence<double> > aSequence; +/*N*/ if ( rNewRes >>= aSequence ) +/*N*/ pRowSeq = &aSequence; +/*N*/ +/*N*/ if ( pRowSeq ) +/*N*/ { +/*N*/ long nRowCount = pRowSeq->getLength(); +/*N*/ const uno::Sequence<double>* pRowArr = pRowSeq->getConstArray(); +/*N*/ long nMaxColCount = 0; +/*N*/ long nCol, nRow; +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nTmp = pRowArr[nRow].getLength(); +/*N*/ if ( nTmp > nMaxColCount ) +/*N*/ nMaxColCount = nTmp; +/*N*/ } +/*N*/ if ( nMaxColCount && nRowCount ) +/*N*/ { +/*N*/ pMatrix = new ScMatrix( (USHORT)nMaxColCount, (USHORT)nRowCount ); +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nColCount = pRowArr[nRow].getLength(); +/*N*/ const double* pColArr = pRowArr[nRow].getConstArray(); +/*N*/ for (nCol=0; nCol<nColCount; nCol++) +/*N*/ pMatrix->PutDouble( pColArr[nCol], (USHORT)nCol, (USHORT)nRow ); +/*N*/ for (nCol=nColCount; nCol<nMaxColCount; nCol++) +/*N*/ pMatrix->PutDouble( 0.0, (USHORT)nCol, (USHORT)nRow ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<rtl::OUString> > *)0 ) ) ) +/*N*/ { +/*N*/ const uno::Sequence< uno::Sequence<rtl::OUString> >* pRowSeq = NULL; +/*N*/ +/*N*/ //! use pointer from any! +/*N*/ uno::Sequence< uno::Sequence<rtl::OUString> > aSequence; +/*N*/ if ( rNewRes >>= aSequence ) +/*N*/ pRowSeq = &aSequence; +/*N*/ +/*N*/ if ( pRowSeq ) +/*N*/ { +/*N*/ long nRowCount = pRowSeq->getLength(); +/*N*/ const uno::Sequence<rtl::OUString>* pRowArr = pRowSeq->getConstArray(); +/*N*/ long nMaxColCount = 0; +/*N*/ long nCol, nRow; +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nTmp = pRowArr[nRow].getLength(); +/*N*/ if ( nTmp > nMaxColCount ) +/*N*/ nMaxColCount = nTmp; +/*N*/ } +/*N*/ if ( nMaxColCount && nRowCount ) +/*N*/ { +/*N*/ pMatrix = new ScMatrix( (USHORT)nMaxColCount, (USHORT)nRowCount ); +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nColCount = pRowArr[nRow].getLength(); +/*N*/ const ::rtl::OUString* pColArr = pRowArr[nRow].getConstArray(); +/*N*/ for (nCol=0; nCol<nColCount; nCol++) +/*N*/ pMatrix->PutString( String( pColArr[nCol] ), +/*N*/ (USHORT)nCol, (USHORT)nRow ); +/*N*/ for (nCol=nColCount; nCol<nMaxColCount; nCol++) +/*N*/ pMatrix->PutString( EMPTY_STRING, (USHORT)nCol, (USHORT)nRow ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<uno::Any> > *)0 ) ) ) +/*N*/ { +/*N*/ const uno::Sequence< uno::Sequence<uno::Any> >* pRowSeq = NULL; +/*N*/ +/*N*/ //! use pointer from any! +/*N*/ uno::Sequence< uno::Sequence<uno::Any> > aSequence; +/*N*/ if ( rNewRes >>= aSequence ) +/*N*/ pRowSeq = &aSequence; +/*N*/ +/*N*/ if ( pRowSeq ) +/*N*/ { +/*N*/ long nRowCount = pRowSeq->getLength(); +/*N*/ const uno::Sequence<uno::Any>* pRowArr = pRowSeq->getConstArray(); +/*N*/ long nMaxColCount = 0; +/*N*/ long nCol, nRow; +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nTmp = pRowArr[nRow].getLength(); +/*N*/ if ( nTmp > nMaxColCount ) +/*N*/ nMaxColCount = nTmp; +/*N*/ } +/*N*/ if ( nMaxColCount && nRowCount ) +/*N*/ { +/*N*/ ::rtl::OUString aUStr; +/*N*/ pMatrix = new ScMatrix( (USHORT)nMaxColCount, (USHORT)nRowCount ); +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ long nColCount = pRowArr[nRow].getLength(); +/*N*/ const uno::Any* pColArr = pRowArr[nRow].getConstArray(); +/*N*/ for (nCol=0; nCol<nColCount; nCol++) +/*N*/ { +/*N*/ //Reflection* pRefl = pColArr[nCol].getReflection(); +/*N*/ //if ( pRefl->equals( *OUString_getReflection() ) ) +/*N*/ if ( pColArr[nCol] >>= aUStr ) +/*N*/ pMatrix->PutString( String( aUStr ), +/*N*/ (USHORT)nCol, (USHORT)nRow ); +/*N*/ else +/*N*/ { +/*N*/ // try to convert to double, empty if not possible +/*N*/ +/*N*/ double fCellVal; +/*N*/ if ( lcl_ConvertToDouble( pColArr[nCol], fCellVal ) ) +/*N*/ pMatrix->PutDouble( fCellVal, (USHORT)nCol, (USHORT)nRow ); +/*N*/ else +/*N*/ pMatrix->PutEmpty( (USHORT)nCol, (USHORT)nRow ); +/*N*/ } +/*N*/ } +/*N*/ for (nCol=nColCount; nCol<nMaxColCount; nCol++) +/*N*/ pMatrix->PutString( EMPTY_STRING, (USHORT)nCol, (USHORT)nRow ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!pMatrix) // no array found +/*N*/ nErrCode = errNoValue; //! code for error in return type??? +/*N*/ } +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_addinhelpid.cxx b/binfilter/bf_sc/source/core/tool/sc_addinhelpid.cxx new file mode 100644 index 000000000000..31321aaa35d2 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_addinhelpid.cxx @@ -0,0 +1,221 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// ============================================================================ + +#include "addinhelpid.hxx" + +#include "bf_sc.hrc" +namespace binfilter { + + +// ============================================================================ + +// A struct containing the built-in function name and the built-in help ID. +struct ScUnoAddInHelpId +{ + const sal_Char* pFuncName; + sal_uInt16 nHelpId; +}; + + +// ---------------------------------------------------------------------------- + +// Help IDs for Analysis AddIn. MUST BE SORTED for binary search. +const ScUnoAddInHelpId pAnalysisHelpIds[] = +{ + { "getAccrint" , HID_AAI_FUNC_ACCRINT }, + { "getAccrintm" , HID_AAI_FUNC_ACCRINTM }, + { "getAmordegrc" , HID_AAI_FUNC_AMORDEGRC }, + { "getAmorlinc" , HID_AAI_FUNC_AMORLINC }, + { "getBesseli" , HID_AAI_FUNC_BESSELI }, + { "getBesselj" , HID_AAI_FUNC_BESSELJ }, + { "getBesselk" , HID_AAI_FUNC_BESSELK }, + { "getBessely" , HID_AAI_FUNC_BESSELY }, + { "getBin2Dec" , HID_AAI_FUNC_BIN2DEC }, + { "getBin2Hex" , HID_AAI_FUNC_BIN2HEX }, + { "getBin2Oct" , HID_AAI_FUNC_BIN2OCT }, + { "getComplex" , HID_AAI_FUNC_COMPLEX }, + { "getConvert" , HID_AAI_FUNC_CONVERT }, + { "getCoupdaybs" , HID_AAI_FUNC_COUPDAYBS }, + { "getCoupdays" , HID_AAI_FUNC_COUPDAYS }, + { "getCoupdaysnc" , HID_AAI_FUNC_COUPDAYSNC }, + { "getCoupncd" , HID_AAI_FUNC_COUPNCD }, + { "getCoupnum" , HID_AAI_FUNC_COUPNUM }, + { "getCouppcd" , HID_AAI_FUNC_COUPPCD }, + { "getCumipmt" , HID_AAI_FUNC_CUMIPMT }, + { "getCumprinc" , HID_AAI_FUNC_CUMPRINC }, + { "getDec2Bin" , HID_AAI_FUNC_DEC2BIN }, + { "getDec2Hex" , HID_AAI_FUNC_DEC2HEX }, + { "getDec2Oct" , HID_AAI_FUNC_DEC2OCT }, + { "getDelta" , HID_AAI_FUNC_DELTA }, + { "getDisc" , HID_AAI_FUNC_DISC }, + { "getDollarde" , HID_AAI_FUNC_DOLLARDE }, + { "getDollarfr" , HID_AAI_FUNC_DOLLARFR }, + { "getDuration" , HID_AAI_FUNC_DURATION }, + { "getEdate" , HID_AAI_FUNC_EDATE }, + { "getEffect" , HID_AAI_FUNC_EFFECT }, + { "getEomonth" , HID_AAI_FUNC_EOMONTH }, + { "getErf" , HID_AAI_FUNC_ERF }, + { "getErfc" , HID_AAI_FUNC_ERFC }, + { "getFactdouble" , HID_AAI_FUNC_FACTDOUBLE }, + { "getFvschedule" , HID_AAI_FUNC_FVSCHEDULE }, + { "getGcd" , HID_AAI_FUNC_GCD }, + { "getGestep" , HID_AAI_FUNC_GESTEP }, + { "getHex2Bin" , HID_AAI_FUNC_HEX2BIN }, + { "getHex2Dec" , HID_AAI_FUNC_HEX2DEC }, + { "getHex2Oct" , HID_AAI_FUNC_HEX2OCT }, + { "getImabs" , HID_AAI_FUNC_IMABS }, + { "getImaginary" , HID_AAI_FUNC_IMAGINARY }, + { "getImargument" , HID_AAI_FUNC_IMARGUMENT }, + { "getImconjugate" , HID_AAI_FUNC_IMCONJUGATE }, + { "getImcos" , HID_AAI_FUNC_IMCOS }, + { "getImdiv" , HID_AAI_FUNC_IMDIV }, + { "getImexp" , HID_AAI_FUNC_IMEXP }, + { "getImln" , HID_AAI_FUNC_IMLN }, + { "getImlog10" , HID_AAI_FUNC_IMLOG10 }, + { "getImlog2" , HID_AAI_FUNC_IMLOG2 }, + { "getImpower" , HID_AAI_FUNC_IMPOWER }, + { "getImproduct" , HID_AAI_FUNC_IMPRODUCT }, + { "getImreal" , HID_AAI_FUNC_IMREAL }, + { "getImsin" , HID_AAI_FUNC_IMSIN }, + { "getImsqrt" , HID_AAI_FUNC_IMSQRT }, + { "getImsub" , HID_AAI_FUNC_IMSUB }, + { "getImsum" , HID_AAI_FUNC_IMSUM }, + { "getIntrate" , HID_AAI_FUNC_INTRATE }, + { "getIseven" , HID_AAI_FUNC_ISEVEN }, + { "getIsodd" , HID_AAI_FUNC_ISODD }, + { "getLcm" , HID_AAI_FUNC_LCM }, + { "getMduration" , HID_AAI_FUNC_MDURATION }, + { "getMround" , HID_AAI_FUNC_MROUND }, + { "getMultinomial" , HID_AAI_FUNC_MULTINOMIAL }, + { "getNetworkdays" , HID_AAI_FUNC_NETWORKDAYS }, + { "getNominal" , HID_AAI_FUNC_NOMINAL }, + { "getOct2Bin" , HID_AAI_FUNC_OCT2BIN }, + { "getOct2Dec" , HID_AAI_FUNC_OCT2DEZ }, + { "getOct2Hex" , HID_AAI_FUNC_OCT2HEX }, + { "getOddfprice" , HID_AAI_FUNC_ODDFPRICE }, + { "getOddfyield" , HID_AAI_FUNC_ODDFYIELD }, + { "getOddlprice" , HID_AAI_FUNC_ODDLPRICE }, + { "getOddlyield" , HID_AAI_FUNC_ODDLYIELD }, + { "getPrice" , HID_AAI_FUNC_PRICE }, + { "getPricedisc" , HID_AAI_FUNC_PRICEDISC }, + { "getPricemat" , HID_AAI_FUNC_PRICEMAT }, + { "getQuotient" , HID_AAI_FUNC_QUOTIENT }, + { "getRandbetween" , HID_AAI_FUNC_RANDBETWEEN }, + { "getReceived" , HID_AAI_FUNC_RECEIVED }, + { "getSeriessum" , HID_AAI_FUNC_SERIESSUM }, + { "getSqrtpi" , HID_AAI_FUNC_SQRTPI }, + { "getTbilleq" , HID_AAI_FUNC_TBILLEQ }, + { "getTbillprice" , HID_AAI_FUNC_TBILLPRICE }, + { "getTbillyield" , HID_AAI_FUNC_TBILLYIELD }, + { "getWeeknum" , HID_AAI_FUNC_WEEKNUM }, + { "getWorkday" , HID_AAI_FUNC_WORKDAY }, + { "getXirr" , HID_AAI_FUNC_XIRR }, + { "getXnpv" , HID_AAI_FUNC_XNPV }, + { "getYearfrac" , HID_AAI_FUNC_YEARFRAC }, + { "getYield" , HID_AAI_FUNC_YIELD }, + { "getYielddisc" , HID_AAI_FUNC_YIELDDISC }, + { "getYieldmat" , HID_AAI_FUNC_YIELDMAT } +}; + + +// ---------------------------------------------------------------------------- + +// Help IDs for DateFunc AddIn. MUST BE SORTED for binary search. +const ScUnoAddInHelpId pDateFuncHelpIds[] = +{ + { "getDaysInMonth" , HID_DAI_FUNC_DAYSINMONTH }, + { "getDaysInYear" , HID_DAI_FUNC_DAYSINYEAR }, + { "getDiffMonths" , HID_DAI_FUNC_DIFFMONTHS }, + { "getDiffWeeks" , HID_DAI_FUNC_DIFFWEEKS }, + { "getDiffYears" , HID_DAI_FUNC_DIFFYEARS }, + { "getRot13" , HID_DAI_FUNC_ROT13 }, + { "getWeeksInYear" , HID_DAI_FUNC_WEEKSINYEAR } +}; + + +// ============================================================================ + +/*N*/ ScUnoAddInHelpIdGenerator::ScUnoAddInHelpIdGenerator( const ::rtl::OUString& rServiceName ) +/*N*/ { +/*N*/ SetServiceName( rServiceName ); +/*N*/ } + +/*N*/ void ScUnoAddInHelpIdGenerator::SetServiceName( const ::rtl::OUString& rServiceName ) +/*N*/ { +/*N*/ pCurrHelpIds = NULL; +/*N*/ sal_uInt32 nSize = 0; +/*N*/ +/*N*/ if( rServiceName.equalsAscii( "com.sun.star.sheet.addin.Analysis" ) ) +/*N*/ { +/*N*/ pCurrHelpIds = pAnalysisHelpIds; +/*N*/ nSize = sizeof( pAnalysisHelpIds ); +/*N*/ } +/*N*/ else if( rServiceName.equalsAscii( "com.sun.star.sheet.addin.DateFunctions" ) ) +/*N*/ { +/*N*/ pCurrHelpIds = pDateFuncHelpIds; +/*N*/ nSize = sizeof( pDateFuncHelpIds ); +/*N*/ } +/*N*/ +/*N*/ nArrayCount = nSize / sizeof( ScUnoAddInHelpId ); +/*N*/ } + +/*N*/ sal_uInt16 ScUnoAddInHelpIdGenerator::GetHelpId( const ::rtl::OUString& rFuncName ) const +/*N*/ { +/*N*/ if( !pCurrHelpIds || !nArrayCount ) +/*N*/ return 0; +/*N*/ +/*N*/ const ScUnoAddInHelpId* pFirst = pCurrHelpIds; +/*N*/ const ScUnoAddInHelpId* pLast = pCurrHelpIds + nArrayCount - 1; +/*N*/ +/*N*/ while( pFirst <= pLast ) +/*N*/ { +/*N*/ const ScUnoAddInHelpId* pMiddle = pFirst + (pLast - pFirst) / 2; +/*N*/ sal_Int32 nResult = rFuncName.compareToAscii( pMiddle->pFuncName ); +/*N*/ if( !nResult ) +/*N*/ return pMiddle->nHelpId; +/*N*/ else if( nResult < 0 ) +/*N*/ pLast = pMiddle - 1; +/*N*/ else +/*N*/ pFirst = pMiddle + 1; +/*N*/ } +/*N*/ +/*N*/ return 0; +/*N*/ } + + +// ============================================================================ + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_addinlis.cxx b/binfilter/bf_sc/source/core/tool/sc_addinlis.cxx new file mode 100644 index 000000000000..03f85bec1bda --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_addinlis.cxx @@ -0,0 +1,192 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <bf_sfx2/objsh.hxx> +#include <vcl/svapp.hxx> + + +#include "addinlis.hxx" +#include "miscuno.hxx" // SC_IMPL_SERVICE_INFO +#include "document.hxx" +#include "bf_sc.hrc" +namespace binfilter { + +using namespace ::com::sun::star; + +//------------------------------------------------------------------------ + +//SMART_UNO_IMPLEMENTATION( ScAddInListener, UsrObject ); + +/*N*/ SC_SIMPLE_SERVICE_INFO( ScAddInListener, "ScAddInListener", "stardiv.one.sheet.AddInListener" ) + +//------------------------------------------------------------------------ + +/*N*/ List ScAddInListener::aAllListeners; + +//------------------------------------------------------------------------ + +/*N*/ // static +/*N*/ ScAddInListener* ScAddInListener::CreateListener( +/*N*/ uno::Reference<sheet::XVolatileResult> xVR, ScDocument* pDoc ) +/*N*/ { +/*N*/ ScAddInListener* pNew = new ScAddInListener( xVR, pDoc ); +/*N*/ +/*N*/ pNew->acquire(); // for aAllListeners +/*N*/ aAllListeners.Insert( pNew, LIST_APPEND ); +/*N*/ +/*N*/ if ( xVR.is() ) +/*N*/ xVR->addResultListener( pNew ); // after at least 1 ref exists! +/*N*/ +/*N*/ return pNew; +/*N*/ } + +/*N*/ ScAddInListener::ScAddInListener( uno::Reference<sheet::XVolatileResult> xVR, ScDocument* pDoc ) : +/*N*/ xVolRes( xVR ) +/*N*/ { +/*N*/ pDocs = new ScAddInDocs( 1, 1 ); +/*N*/ pDocs->Insert( pDoc ); +/*N*/ } + +/*N*/ ScAddInListener::~ScAddInListener() +/*N*/ { +/*N*/ delete pDocs; +/*N*/ } + +/*N*/ // static +/*N*/ ScAddInListener* ScAddInListener::Get( uno::Reference<sheet::XVolatileResult> xVR ) +/*N*/ { +/*N*/ sheet::XVolatileResult* pComp = xVR.get(); +/*N*/ +/*N*/ ULONG nCount = aAllListeners.Count(); +/*N*/ for (ULONG nPos=0; nPos<nCount; nPos++) +/*N*/ { +/*N*/ ScAddInListener* pLst = (ScAddInListener*)aAllListeners.GetObject(nPos); +/*N*/ if ( pComp == (sheet::XVolatileResult*)pLst->xVolRes.get() ) +/*N*/ return pLst; +/*N*/ } +/*N*/ return NULL; // not found +/*N*/ } + +//! move to some container object? +// static +/*N*/ void ScAddInListener::RemoveDocument( ScDocument* pDocumentP ) +/*N*/ { +/*N*/ ULONG nPos = aAllListeners.Count(); +/*N*/ while (nPos) +/*N*/ { +/*?*/ // loop backwards because elements are removed +/*?*/ --nPos; +/*?*/ ScAddInListener* pLst = (ScAddInListener*)aAllListeners.GetObject(nPos); +/*?*/ ScAddInDocs* p = pLst->pDocs; +/*?*/ USHORT nFoundPos; +/*?*/ if ( p->Seek_Entry( pDocumentP, &nFoundPos ) ) +/*?*/ { +/*?*/ p->Remove( nFoundPos ); +/*?*/ if ( p->Count() == 0 ) +/*?*/ { +/*?*/ // this AddIn is no longer used +/*?*/ // dont delete, just remove the ref for the list +/*?*/ +/*?*/ aAllListeners.Remove( nPos ); +/*?*/ +/*?*/ if ( pLst->xVolRes.is() ) +/*?*/ pLst->xVolRes->removeResultListener( pLst ); +/*?*/ +/*?*/ pLst->release(); // Ref for aAllListeners - pLst may be deleted here +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +// XResultListener + +/*N*/ void SAL_CALL ScAddInListener::modified( const ::com::sun::star::sheet::ResultEvent& aEvent ) +/*N*/ throw(::com::sun::star::uno::RuntimeException) +/*N*/ { +/*N*/ SolarMutexGuard aGuard; //! or generate a UserEvent +/*N*/ +/*N*/ aResult = aEvent.Value; // store result +/*N*/ +/*N*/ if ( !HasListeners() ) +/*N*/ { +/*N*/ //! remove from list and removeListener, as in RemoveDocument ??? +/*N*/ +/*N*/ #if 0 +/*N*/ //! this will crash if called before first StartListening !!! +/*N*/ aAllListeners.Remove( this ); +/*N*/ if ( xVolRes.is() ) +/*N*/ xVolRes->removeResultListener( this ); +/*N*/ release(); // Ref for aAllListeners - this may be deleted here +/*N*/ return; +/*N*/ #endif +/*N*/ } +/*N*/ +/*N*/ // notify document of changes +/*N*/ +/*N*/ Broadcast( ScHint( SC_HINT_DATACHANGED, ScAddress( 0 ), NULL ) ); +/*N*/ +/*N*/ const ScDocument** ppDoc = (const ScDocument**) pDocs->GetData(); +/*N*/ USHORT nCount = pDocs->Count(); +/*N*/ for ( USHORT j=0; j<nCount; j++, ppDoc++ ) +/*N*/ { +/*N*/ ScDocument* pDoc = (ScDocument*)*ppDoc; +/*N*/ pDoc->TrackFormulas(); +/*N*/ pDoc->GetDocumentShell()->Broadcast( SfxSimpleHint( FID_DATACHANGED ) ); +/*N*/ pDoc->ResetChanged( ScRange(0,0,0,MAXCOL,MAXROW,MAXTAB) ); +/*N*/ } +/*N*/ } + +// XEventListener + +/*N*/ void SAL_CALL ScAddInListener::disposing( const ::com::sun::star::lang::EventObject& Source ) +/*N*/ throw(::com::sun::star::uno::RuntimeException) +/*N*/ { +/*N*/ // hold a ref so this is not deleted at removeResultListener +/*N*/ uno::Reference<sheet::XResultListener> xRef( this ); +/*N*/ +/*N*/ if ( xVolRes.is() ) +/*N*/ { +/*N*/ xVolRes->removeResultListener( this ); +/*N*/ xVolRes = NULL; +/*N*/ } +/*N*/ } + + +//------------------------------------------------------------------------ + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_adiasync.cxx b/binfilter/bf_sc/source/core/tool/sc_adiasync.cxx new file mode 100644 index 000000000000..d333d1e02993 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_adiasync.cxx @@ -0,0 +1,148 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include <bf_sfx2/objsh.hxx> + +#include "adiasync.hxx" +#include "document.hxx" +#include "bf_sc.hrc" // FID_DATACHANGED + +#include <osl/thread.h> +namespace binfilter { + + +//------------------------------------------------------------------------ + +#ifdef _MSC_VER +#pragma code_seg("SCSTATICS") +#endif + +ScAddInAsyncs theAddInAsyncTbl; +static ScAddInAsync aSeekObj; + +#ifdef _MSC_VER +#pragma code_seg() +#endif + + +/*N*/ SV_IMPL_OP_PTRARR_SORT( ScAddInAsyncs, ScAddInAsyncPtr ); + +/*N*/ SV_IMPL_PTRARR_SORT( ScAddInDocs, ScAddInDocPtr ); + + + + +/*N*/ ScAddInAsync::ScAddInAsync() : +/*N*/ SfxBroadcaster(), +/*N*/ nHandle( 0 ) +/*N*/ { // nur fuer aSeekObj ! +/*N*/ } + + + +/*N*/ ScAddInAsync::ScAddInAsync( ULONG nHandleP, USHORT nIndex, ScDocument* pDoc ) : +/*N*/ SfxBroadcaster(), +/*N*/ pStr( NULL ), +/*N*/ nHandle( nHandleP ), +/*N*/ bValid( FALSE ) +/*N*/ { +/*N*/ pDocs = new ScAddInDocs( 1, 1 ); +/*N*/ pDocs->Insert( pDoc ); +/*N*/ pFuncData = (FuncData*)ScGlobal::GetFuncCollection()->At(nIndex); +/*N*/ eType = pFuncData->GetAsyncType(); +/*N*/ theAddInAsyncTbl.Insert( this ); +/*N*/ } + + + +/*N*/ ScAddInAsync::~ScAddInAsync() +/*N*/ { +/*N*/ // aSeekObj hat das alles nicht, Handle 0 gibt es sonst nicht +/*N*/ if ( nHandle ) +/*N*/ { +/*?*/ // im dTor wg. theAddInAsyncTbl.DeleteAndDestroy in ScGlobal::Clear +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 pFuncData->Unadvice( (double)nHandle ); +/*N*/ } +/*N*/ } + + + +/*N*/ ScAddInAsync* ScAddInAsync::Get( ULONG nHandleP ) +/*N*/ { +/*N*/ USHORT nPos; +/*N*/ ScAddInAsync* pRet = 0; +/*N*/ aSeekObj.nHandle = nHandleP; +/*N*/ if ( theAddInAsyncTbl.Seek_Entry( &aSeekObj, &nPos ) ) +/*N*/ pRet = theAddInAsyncTbl[ nPos ]; +/*N*/ aSeekObj.nHandle = 0; +/*N*/ return pRet; +/*N*/ } + + + + + + +/*N*/ void ScAddInAsync::RemoveDocument( ScDocument* pDocumentP ) +/*N*/ { +/*N*/ USHORT nPos = theAddInAsyncTbl.Count(); +/*N*/ if ( nPos ) +/*N*/ { +/*?*/ const ScAddInAsync** ppAsync = +/*?*/ (const ScAddInAsync**) theAddInAsyncTbl.GetData() + nPos - 1; +/*?*/ for ( ; nPos-- >0; ppAsync-- ) +/*?*/ { // rueckwaerts wg. Pointer-Aufrueckerei im Array +/*?*/ ScAddInDocs* p = ((ScAddInAsync*)*ppAsync)->pDocs; +/*?*/ USHORT nFoundPos; +/*?*/ if ( p->Seek_Entry( pDocumentP, &nFoundPos ) ) +/*?*/ { +/*?*/ p->Remove( nFoundPos ); +/*?*/ if ( p->Count() == 0 ) +/*?*/ { // dieses AddIn wird nicht mehr benutzt +/*?*/ ScAddInAsync* pAsync = (ScAddInAsync*)*ppAsync; +/*?*/ theAddInAsyncTbl.Remove( nPos ); +/*?*/ delete pAsync; +/*?*/ ppAsync = (const ScAddInAsync**) theAddInAsyncTbl.GetData() +/*?*/ + nPos; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_appoptio.cxx b/binfilter/bf_sc/source/core/tool/sc_appoptio.cxx new file mode 100644 index 000000000000..df9b03a270dc --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_appoptio.cxx @@ -0,0 +1,678 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------ + + + +#include "appoptio.hxx" +#include "rechead.hxx" +#include "userlist.hxx" +#include "bf_sc.hrc" +#include "compiler.hrc" +#include "miscuno.hxx" +namespace binfilter { + +using namespace utl; +using namespace rtl; +using namespace ::com::sun::star::uno; + +// STATIC DATA ----------------------------------------------------------- + +#define SC_VERSION ((USHORT)304) + +//======================================================================== +// ScAppOptions - Applikations-Optionen +//======================================================================== + +/*N*/ ScAppOptions::ScAppOptions() : pLRUList( NULL ) +/*N*/ { +/*N*/ SetDefaults(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScAppOptions::ScAppOptions( const ScAppOptions& rCpy ) : pLRUList( NULL ) +/*N*/ { +/*N*/ *this = rCpy; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScAppOptions::~ScAppOptions() +/*N*/ { +/*N*/ delete [] pLRUList; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScAppOptions::SetDefaults() +/*N*/ { +/*N*/ if ( ScOptionsUtil::IsMetricSystem() ) +/*N*/ eMetric = FUNIT_CM; // default for countries with metric system +/*N*/ else +/*N*/ eMetric = FUNIT_INCH; // default for others +/*N*/ +/*N*/ nZoom = 100; +/*N*/ eZoomType = SVX_ZOOM_PERCENT; +/*N*/ nStatusFunc = SUBTOTAL_FUNC_SUM; +/*N*/ bAutoComplete = TRUE; +/*N*/ bDetectiveAuto = TRUE; +/*N*/ +/*N*/ delete [] pLRUList; +/*N*/ pLRUList = new USHORT[5]; // sinnvoll vorbelegen +/*N*/ pLRUList[0] = SC_OPCODE_SUM; +/*N*/ pLRUList[1] = SC_OPCODE_AVERAGE; +/*N*/ pLRUList[2] = SC_OPCODE_MIN; +/*N*/ pLRUList[3] = SC_OPCODE_MAX; +/*N*/ pLRUList[4] = SC_OPCODE_IF; +/*N*/ nLRUFuncCount = 5; +/*N*/ +/*N*/ nTrackContentColor = COL_TRANSPARENT; +/*N*/ nTrackInsertColor = COL_TRANSPARENT; +/*N*/ nTrackDeleteColor = COL_TRANSPARENT; +/*N*/ nTrackMoveColor = COL_TRANSPARENT; +/*N*/ eLinkMode = LM_ON_DEMAND; +/*N*/ +/*N*/ nDefaultObjectSizeWidth = 8000; +/*N*/ nDefaultObjectSizeHeight = 5000; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ const ScAppOptions& ScAppOptions::operator=( const ScAppOptions& rCpy ) +/*N*/ { +/*N*/ eMetric = rCpy.eMetric; +/*N*/ eZoomType = rCpy.eZoomType; +/*N*/ nZoom = rCpy.nZoom; +/*N*/ SetLRUFuncList( rCpy.pLRUList, rCpy.nLRUFuncCount ); +/*N*/ nStatusFunc = rCpy.nStatusFunc; +/*N*/ bAutoComplete = rCpy.bAutoComplete; +/*N*/ bDetectiveAuto = rCpy.bDetectiveAuto; +/*N*/ nTrackContentColor = rCpy.nTrackContentColor; +/*N*/ nTrackInsertColor = rCpy.nTrackInsertColor; +/*N*/ nTrackDeleteColor = rCpy.nTrackDeleteColor; +/*N*/ nTrackMoveColor = rCpy.nTrackMoveColor; +/*N*/ eLinkMode = rCpy.eLinkMode; +/*N*/ nDefaultObjectSizeWidth = rCpy.nDefaultObjectSizeWidth; +/*N*/ nDefaultObjectSizeHeight = rCpy.nDefaultObjectSizeHeight; +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator>>( SvStream& rStream, ScAppOptions& rOpt ) +/*N*/ { +/*N*/ rOpt.SetDefaults(); +/*N*/ +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ BYTE n; +/*N*/ rStream >> n; rOpt.eMetric = (FieldUnit)n; +/*N*/ +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ rStream >> n; rOpt.nLRUFuncCount = (USHORT)n; +/*N*/ +/*N*/ delete [] rOpt.pLRUList; +/*N*/ rOpt.pLRUList = new USHORT[rOpt.nLRUFuncCount]; +/*N*/ +/*N*/ for ( USHORT i=0; i<rOpt.nLRUFuncCount; i++ ) +/*N*/ rStream >> rOpt.pLRUList[i]; +/*N*/ } +/*N*/ +/*N*/ // ab 31.10.95: globale benutzerdefinierte Listen einlesen :-/ +/*N*/ // (kleiner Hack :-/) +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ ScUserList* pUserList = ScGlobal::GetUserList(); +/*N*/ pUserList->Load( rStream ); +/*N*/ } +/*N*/ +/*N*/ // ab 11.12.95 (304) +/*N*/ // Zoom-Faktor +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ USHORT e; +/*N*/ rStream >> e; rOpt.eZoomType = (SvxZoomType)e; +/*N*/ rStream >> rOpt.nZoom; +/*N*/ } +/*N*/ +/*N*/ // ab 23.5.96: Funktion fuer Statusbar-Controller, Flag fuer Auto-Eingabe +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ rStream >> rOpt.nStatusFunc; +/*N*/ rStream >> rOpt.bAutoComplete; +/*N*/ } +/*N*/ +/*N*/ // ab 15.3.98: Farben fuer Change-Tracking +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ rStream >> rOpt.nTrackContentColor; +/*N*/ rStream >> rOpt.nTrackInsertColor; +/*N*/ rStream >> rOpt.nTrackDeleteColor; +/*N*/ rStream >> rOpt.nTrackMoveColor; +/*N*/ } +/*N*/ +/*N*/ // ab 22.6.98: Automatisches Detektiv-Update +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.bDetectiveAuto; +/*N*/ +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ BYTE nLinkMode; +/*N*/ rStream >> nLinkMode; +/*N*/ rOpt.eLinkMode=(ScLkUpdMode) nLinkMode; +/*N*/ } +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator<<( SvStream& rStream, const ScAppOptions& rOpt ) +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream, 25 ); +/*N*/ +/*N*/ rStream << (BYTE)rOpt.eMetric; +/*N*/ rStream << (BYTE)rOpt.nLRUFuncCount; +/*N*/ +/*N*/ if ( rOpt.nLRUFuncCount > 0 ) +/*N*/ { +/*N*/ for ( USHORT i=0; i<rOpt.nLRUFuncCount; i++ ) +/*N*/ rStream << rOpt.pLRUList[i]; +/*N*/ } +/*N*/ +/*N*/ // ab 31.10.95: globale benutzerdefinierte Listen speichern +/*N*/ // (kleiner Hack :-/) +/*N*/ ScUserList* pUserList = ScGlobal::GetUserList(); +/*N*/ pUserList->Store( rStream ); +/*N*/ +/*N*/ // ab 11.12.95 (304) +/*N*/ // Zoom-Faktor +/*N*/ rStream << (USHORT)rOpt.eZoomType; +/*N*/ rStream << rOpt.nZoom; +/*N*/ +/*N*/ // ab 23.5.96: Funktion fuer Statusbar-Controller, Flag fuer Auto-Eingabe +/*N*/ rStream << rOpt.nStatusFunc; +/*N*/ rStream << rOpt.bAutoComplete; +/*N*/ +/*N*/ // ab 15.3.98: Farben fuer Change-Tracking +/*N*/ rStream << rOpt.nTrackContentColor; +/*N*/ rStream << rOpt.nTrackInsertColor; +/*N*/ rStream << rOpt.nTrackDeleteColor; +/*N*/ rStream << rOpt.nTrackMoveColor; +/*N*/ +/*N*/ // ab 22.6.98: Automatisches Detektiv-Update +/*N*/ rStream << rOpt.bDetectiveAuto; +/*N*/ rStream << (BYTE) rOpt.eLinkMode; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScAppOptions::SetLRUFuncList( const USHORT* pList, const USHORT nCount ) +/*N*/ { +/*N*/ delete [] pLRUList; +/*N*/ +/*N*/ nLRUFuncCount = nCount; +/*N*/ +/*N*/ if ( nLRUFuncCount > 0 ) +/*N*/ { +/*N*/ pLRUList = new USHORT[nLRUFuncCount]; +/*N*/ +/*N*/ for ( USHORT i=0; i<nLRUFuncCount; i++ ) +/*N*/ pLRUList[i] = pList[i]; +/*N*/ } +/*N*/ else +/*N*/ pLRUList = NULL; +/*N*/ } + +//================================================================== +// Config Item containing app options +//================================================================== + +/*N*/ void lcl_SetLastFunctions( ScAppOptions& rOpt, const Any& rValue ) +/*N*/ { +/*N*/ Sequence<sal_Int32> aSeq; +/*N*/ if ( rValue >>= aSeq ) +/*N*/ { +/*N*/ long nCount = aSeq.getLength(); +/*N*/ if ( nCount < USHRT_MAX ) +/*N*/ { +/*N*/ const sal_Int32* pArray = aSeq.getConstArray(); +/*N*/ USHORT* pUShorts = new USHORT[nCount]; +/*N*/ for (long i=0; i<nCount; i++) +/*N*/ pUShorts[i] = (USHORT) pArray[i]; +/*N*/ +/*N*/ rOpt.SetLRUFuncList( pUShorts, nCount ); +/*N*/ +/*N*/ delete[] pUShorts; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void lcl_SetSortList( const Any& rValue ) +/*N*/ { +/*N*/ Sequence<OUString> aSeq; +/*N*/ if ( rValue >>= aSeq ) +/*N*/ { +/*N*/ long nCount = aSeq.getLength(); +/*N*/ const OUString* pArray = aSeq.getConstArray(); +/*N*/ ScUserList aList; +/*N*/ +/*N*/ // if setting is "default", keep default values from ScUserList ctor +/*N*/ //! mark "default" in a safe way +/*N*/ BOOL bDefault = ( nCount == 1 && +/*N*/ pArray[0].equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "NULL" ) ) ); +/*N*/ +/*N*/ if (!bDefault) +/*N*/ { +/*?*/ aList.FreeAll(); +/*?*/ +/*?*/ for (long i=0; i<nCount; i++) +/*?*/ { +/*?*/ ScUserListData* pNew = new ScUserListData( pArray[i] ); +/*?*/ if ( !aList.Insert(pNew) ) +/*?*/ delete pNew; +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ ScGlobal::SetUserList( &aList ); +/*N*/ } +/*N*/ } + + +//------------------------------------------------------------------ + +#define CFGPATH_LAYOUT "Office.Calc/Layout" + +#define SCLAYOUTOPT_MEASURE 0 +#define SCLAYOUTOPT_STATUSBAR 1 +#define SCLAYOUTOPT_ZOOMVAL 2 +#define SCLAYOUTOPT_ZOOMTYPE 3 +#define SCLAYOUTOPT_COUNT 4 + +#define CFGPATH_INPUT "Office.Calc/Input" + +#define SCINPUTOPT_LASTFUNCS 0 +#define SCINPUTOPT_AUTOINPUT 1 +#define SCINPUTOPT_DET_AUTO 2 +#define SCINPUTOPT_COUNT 3 + +#define CFGPATH_REVISION "Office.Calc/Revision/Color" + +#define SCREVISOPT_CHANGE 0 +#define SCREVISOPT_INSERTION 1 +#define SCREVISOPT_DELETION 2 +#define SCREVISOPT_MOVEDENTRY 3 +#define SCREVISOPT_COUNT 4 + +#define CFGPATH_CONTENT "Office.Calc/Content/Update" + +#define SCCONTENTOPT_LINK 0 +#define SCCONTENTOPT_COUNT 1 + +#define CFGPATH_SORTLIST "Office.Calc/SortList" + +#define SCSORTLISTOPT_LIST 0 +#define SCSORTLISTOPT_COUNT 1 + +#define CFGPATH_MISC "Office.Calc/Misc" + +#define SCMISCOPT_DEFOBJWIDTH 0 +#define SCMISCOPT_DEFOBJHEIGHT 1 +#define SCMISCOPT_COUNT 2 + + +/*N*/ Sequence<OUString> ScAppCfg::GetLayoutPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "Other/MeasureUnit/NonMetric", // SCLAYOUTOPT_MEASURE +/*N*/ "Other/StatusbarFunction", // SCLAYOUTOPT_STATUSBAR +/*N*/ "Zoom/Value", // SCLAYOUTOPT_ZOOMVAL +/*N*/ "Zoom/Type" // SCLAYOUTOPT_ZOOMTYPE +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCLAYOUTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCLAYOUTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ // adjust for metric system +/*N*/ if (ScOptionsUtil::IsMetricSystem()) +/*N*/ pNames[SCLAYOUTOPT_MEASURE] = OUString::createFromAscii( "Other/MeasureUnit/Metric" ); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScAppCfg::GetInputPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "LastFunctions", // SCINPUTOPT_LASTFUNCS +/*N*/ "AutoInput", // SCINPUTOPT_AUTOINPUT +/*N*/ "DetectiveAuto" // SCINPUTOPT_DET_AUTO +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCINPUTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCINPUTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScAppCfg::GetRevisionPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "Change", // SCREVISOPT_CHANGE +/*N*/ "Insertion", // SCREVISOPT_INSERTION +/*N*/ "Deletion", // SCREVISOPT_DELETION +/*N*/ "MovedEntry" // SCREVISOPT_MOVEDENTRY +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCREVISOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCREVISOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScAppCfg::GetContentPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "Link" // SCCONTENTOPT_LINK +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCCONTENTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCCONTENTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScAppCfg::GetSortListPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "List" // SCSORTLISTOPT_LIST +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCSORTLISTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCSORTLISTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScAppCfg::GetMiscPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "DefaultObjectSize/Width", // SCMISCOPT_DEFOBJWIDTH +/*N*/ "DefaultObjectSize/Height" // SCMISCOPT_DEFOBJHEIGHT +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCMISCOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCMISCOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + + +/*N*/ ScAppCfg::ScAppCfg() : +/*N*/ aLayoutItem( OUString::createFromAscii( CFGPATH_LAYOUT ) ), +/*N*/ aInputItem( OUString::createFromAscii( CFGPATH_INPUT ) ), +/*N*/ aRevisionItem( OUString::createFromAscii( CFGPATH_REVISION ) ), +/*N*/ aContentItem( OUString::createFromAscii( CFGPATH_CONTENT ) ), +/*N*/ aSortListItem( OUString::createFromAscii( CFGPATH_SORTLIST ) ), +/*N*/ aMiscItem( OUString::createFromAscii( CFGPATH_MISC ) ) +/*N*/ { +/*N*/ sal_Int32 nIntVal; +/*N*/ +/*N*/ Sequence<OUString> aNames; +/*N*/ Sequence<Any> aValues; +/*N*/ const Any* pValues = NULL; +/*N*/ +/*N*/ aNames = GetLayoutPropertyNames(); +/*N*/ aValues = aLayoutItem.GetProperties(aNames); +/*N*/ aLayoutItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCLAYOUTOPT_MEASURE: +/*N*/ if (pValues[nProp] >>= nIntVal) SetAppMetric( (FieldUnit) nIntVal ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_STATUSBAR: +/*N*/ if (pValues[nProp] >>= nIntVal) SetStatusFunc( (USHORT) nIntVal ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_ZOOMVAL: +/*N*/ if (pValues[nProp] >>= nIntVal) SetZoom( (USHORT) nIntVal ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_ZOOMTYPE: +/*N*/ if (pValues[nProp] >>= nIntVal) SetZoomType( (SvxZoomType) nIntVal ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aLayoutItem.SetCommitLink( LINK( this, ScAppCfg, LayoutCommitHdl ) ); +/*N*/ +/*N*/ aNames = GetInputPropertyNames(); +/*N*/ aValues = aInputItem.GetProperties(aNames); +/*N*/ aInputItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCINPUTOPT_LASTFUNCS: +/*N*/ lcl_SetLastFunctions( *this, pValues[nProp] ); +/*N*/ break; +/*N*/ case SCINPUTOPT_AUTOINPUT: +/*N*/ SetAutoComplete( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_DET_AUTO: +/*N*/ SetDetectiveAuto( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aInputItem.SetCommitLink( LINK( this, ScAppCfg, InputCommitHdl ) ); +/*N*/ +/*N*/ aNames = GetRevisionPropertyNames(); +/*N*/ aValues = aRevisionItem.GetProperties(aNames); +/*N*/ aRevisionItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCREVISOPT_CHANGE: +/*N*/ if (pValues[nProp] >>= nIntVal) SetTrackContentColor( (ULONG) nIntVal ); +/*N*/ break; +/*N*/ case SCREVISOPT_INSERTION: +/*N*/ if (pValues[nProp] >>= nIntVal) SetTrackInsertColor( (ULONG) nIntVal ); +/*N*/ break; +/*N*/ case SCREVISOPT_DELETION: +/*N*/ if (pValues[nProp] >>= nIntVal) SetTrackDeleteColor( (ULONG) nIntVal ); +/*N*/ break; +/*N*/ case SCREVISOPT_MOVEDENTRY: +/*N*/ if (pValues[nProp] >>= nIntVal) SetTrackMoveColor( (ULONG) nIntVal ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aRevisionItem.SetCommitLink( LINK( this, ScAppCfg, RevisionCommitHdl ) ); +/*N*/ +/*N*/ aNames = GetContentPropertyNames(); +/*N*/ aValues = aContentItem.GetProperties(aNames); +/*N*/ aContentItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCCONTENTOPT_LINK: +/*N*/ if (pValues[nProp] >>= nIntVal) SetLinkMode( (ScLkUpdMode) nIntVal ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aContentItem.SetCommitLink( LINK( this, ScAppCfg, ContentCommitHdl ) ); +/*N*/ +/*N*/ aNames = GetSortListPropertyNames(); +/*N*/ aValues = aSortListItem.GetProperties(aNames); +/*N*/ aSortListItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCSORTLISTOPT_LIST: +/*N*/ lcl_SetSortList( pValues[nProp] ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aSortListItem.SetCommitLink( LINK( this, ScAppCfg, SortListCommitHdl ) ); +/*N*/ +/*N*/ aNames = GetMiscPropertyNames(); +/*N*/ aValues = aMiscItem.GetProperties(aNames); +/*N*/ aMiscItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCMISCOPT_DEFOBJWIDTH: +/*N*/ if (pValues[nProp] >>= nIntVal) SetDefaultObjectSizeWidth( nIntVal ); +/*N*/ break; +/*N*/ case SCMISCOPT_DEFOBJHEIGHT: +/*N*/ if (pValues[nProp] >>= nIntVal) SetDefaultObjectSizeHeight( nIntVal ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aMiscItem.SetCommitLink( LINK( this, ScAppCfg, MiscCommitHdl ) ); +/*N*/ } + +/*N*/ IMPL_LINK( ScAppCfg, LayoutCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetLayoutPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScAppCfg, InputCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetInputPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScAppCfg, RevisionCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetRevisionPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScAppCfg, ContentCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetContentPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScAppCfg, SortListCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetSortListPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScAppCfg, MiscCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetMiscPropertyNames(); +/*N*/ return 0; +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_autoform.cxx b/binfilter/bf_sc/source/core/tool/sc_autoform.cxx new file mode 100644 index 000000000000..f467f84d810c --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_autoform.cxx @@ -0,0 +1,906 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define READ_OLDVERS + +#include "autoform.hxx" + +#include <bf_sfx2/docfile.hxx> +#include <bf_svtools/pathoptions.hxx> +#include <vcl/outdev.hxx> +#include <bf_svx/dialmgr.hxx> +#include <bf_svx/dialogs.hrc> +#include <tools/urlobj.hxx> + +#include <tools/tenccvt.hxx> + +#include "globstr.hrc" +namespace binfilter { + +//------------------------------------------------------------------------ + +sal_Char *linker_dummy = ""; + +// Standard-Name ist jetzt STR_STYLENAME_STANDARD (wie Vorlagen) +//static const sal_Char __FAR_DATA cStandardName[] = "Standard"; + +static const sal_Char __FAR_DATA sAutoTblFmtName[] = "autotbl.fmt"; + +// bis SO5PF +const USHORT AUTOFORMAT_ID_X = 9501; +const USHORT AUTOFORMAT_ID_358 = 9601; +const USHORT AUTOFORMAT_DATA_ID_X = 9502; + +// ab SO5 +//! in nachfolgenden Versionen muss der Betrag dieser IDs groesser sein +const USHORT AUTOFORMAT_ID_504 = 9801; +const USHORT AUTOFORMAT_DATA_ID_504 = 9802; + +const USHORT AUTOFORMAT_ID_552 = 9901; +const USHORT AUTOFORMAT_DATA_ID_552 = 9902; + +// --- from 641 on: CJK and CTL font settings +const USHORT AUTOFORMAT_ID_641 = 10001; +const USHORT AUTOFORMAT_DATA_ID_641 = 10002; + +// aktuelle Version +const USHORT AUTOFORMAT_ID = AUTOFORMAT_ID_641; +const USHORT AUTOFORMAT_DATA_ID = AUTOFORMAT_DATA_ID_641; + + +#ifdef READ_OLDVERS +const USHORT AUTOFORMAT_OLD_ID_OLD = 4201; +const USHORT AUTOFORMAT_OLD_DATA_ID = 4202; +const USHORT AUTOFORMAT_OLD_ID_NEW = 4203; +#endif + + +// Struct mit Versionsnummern der Items + +/*N*/ struct ScAfVersions +/*N*/ { +/*N*/ public: +/*N*/ USHORT nFontVersion; +/*N*/ USHORT nFontHeightVersion; +/*N*/ USHORT nWeightVersion; +/*N*/ USHORT nPostureVersion; +/*N*/ USHORT nUnderlineVersion; +/*N*/ USHORT nCrossedOutVersion; +/*N*/ USHORT nContourVersion; +/*N*/ USHORT nShadowedVersion; +/*N*/ USHORT nColorVersion; +/*N*/ USHORT nBoxVersion; +/*N*/ USHORT nBrushVersion; +/*N*/ +/*N*/ USHORT nAdjustVersion; +/*N*/ +/*N*/ USHORT nHorJustifyVersion; +/*N*/ USHORT nVerJustifyVersion; +/*N*/ USHORT nOrientationVersion; +/*N*/ USHORT nMarginVersion; +/*N*/ USHORT nBoolVersion; +/*N*/ USHORT nInt32Version; +/*N*/ USHORT nRotateModeVersion; +/*N*/ +/*N*/ USHORT nNumFmtVersion; +/*N*/ +/*N*/ ScAfVersions(); +/*N*/ void Load( SvStream& rStream, USHORT nVer ); +/*N*/ static void Write(SvStream& rStream); +/*N*/ }; + +/*N*/ ScAfVersions::ScAfVersions() : +/*N*/ nFontVersion(0), +/*N*/ nFontHeightVersion(0), +/*N*/ nWeightVersion(0), +/*N*/ nPostureVersion(0), +/*N*/ nUnderlineVersion(0), +/*N*/ nCrossedOutVersion(0), +/*N*/ nContourVersion(0), +/*N*/ nShadowedVersion(0), +/*N*/ nColorVersion(0), +/*N*/ nBoxVersion(0), +/*N*/ nBrushVersion(0), +/*N*/ nAdjustVersion(0), +/*N*/ nHorJustifyVersion(0), +/*N*/ nVerJustifyVersion(0), +/*N*/ nOrientationVersion(0), +/*N*/ nMarginVersion(0), +/*N*/ nBoolVersion(0), +/*N*/ nInt32Version(0), +/*N*/ nRotateModeVersion(0), +/*N*/ nNumFmtVersion(0) +/*N*/ { +/*N*/ } + +/*N*/ void ScAfVersions::Load( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ rStream >> nFontVersion; +/*N*/ rStream >> nFontHeightVersion; +/*N*/ rStream >> nWeightVersion; +/*N*/ rStream >> nPostureVersion; +/*N*/ rStream >> nUnderlineVersion; +/*N*/ rStream >> nCrossedOutVersion; +/*N*/ rStream >> nContourVersion; +/*N*/ rStream >> nShadowedVersion; +/*N*/ rStream >> nColorVersion; +/*N*/ rStream >> nBoxVersion; +/*N*/ rStream >> nBrushVersion; +/*N*/ rStream >> nAdjustVersion; +/*N*/ rStream >> nHorJustifyVersion; +/*N*/ rStream >> nVerJustifyVersion; +/*N*/ rStream >> nOrientationVersion; +/*N*/ rStream >> nMarginVersion; +/*N*/ rStream >> nBoolVersion; +/*N*/ if ( nVer >= AUTOFORMAT_ID_504 ) +/*N*/ { +/*N*/ rStream >> nInt32Version; +/*N*/ rStream >> nRotateModeVersion; +/*N*/ } +/*N*/ rStream >> nNumFmtVersion; +/*N*/ } + +/*N*/ void ScAfVersions::Write(SvStream& rStream) +/*N*/ { +/*N*/ rStream << SvxFontItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxFontHeightItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxWeightItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxPostureItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxUnderlineItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxCrossedOutItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxContourItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxShadowedItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxColorItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxBoxItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxBrushItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ +/*N*/ rStream << SvxAdjustItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ +/*N*/ rStream << SvxHorJustifyItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxVerJustifyItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxOrientationItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxMarginItem().GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SfxBoolItem(ATTR_LINEBREAK).GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SfxInt32Item(ATTR_ROTATE_VALUE).GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ rStream << SvxRotateModeItem(SVX_ROTATE_MODE_STANDARD,0).GetVersion(SOFFICE_FILEFORMAT_40); +/*N*/ +/*N*/ rStream << (USHORT)0; // Num-Format +/*N*/ } + +// --------------------------------------------------------------------------- + +/*N*/ ScAutoFormatDataField::ScAutoFormatDataField() : +/*N*/ aCJKFont( ATTR_CJK_FONT ), +/*N*/ aCJKHeight( 240, 100, ATTR_CJK_FONT_HEIGHT ), +/*N*/ aCJKWeight( WEIGHT_NORMAL, ATTR_CJK_FONT_WEIGHT ), +/*N*/ aCJKPosture( ITALIC_NONE, ATTR_CJK_FONT_POSTURE ), +/*N*/ aCTLFont( ATTR_CTL_FONT ), +/*N*/ aCTLHeight( 240, 100, ATTR_CTL_FONT_HEIGHT ), +/*N*/ aCTLWeight( WEIGHT_NORMAL, ATTR_CTL_FONT_WEIGHT ), +/*N*/ aCTLPosture( ITALIC_NONE, ATTR_CTL_FONT_POSTURE ), +/*N*/ aLinebreak( ATTR_LINEBREAK ), +/*N*/ aRotateAngle( ATTR_ROTATE_VALUE ), +/*N*/ aRotateMode( SVX_ROTATE_MODE_STANDARD, ATTR_ROTATE_MODE ) +/*N*/ { +/*N*/ } + +/*N*/ ScAutoFormatDataField::ScAutoFormatDataField( const ScAutoFormatDataField& rCopy ) : +/*N*/ aFont( rCopy.aFont ), +/*N*/ aHeight( rCopy.aHeight ), +/*N*/ aWeight( rCopy.aWeight ), +/*N*/ aPosture( rCopy.aPosture ), +/*N*/ aCJKFont( rCopy.aCJKFont ), +/*N*/ aCJKHeight( rCopy.aCJKHeight ), +/*N*/ aCJKWeight( rCopy.aCJKWeight ), +/*N*/ aCJKPosture( rCopy.aCJKPosture ), +/*N*/ aCTLFont( rCopy.aCTLFont ), +/*N*/ aCTLHeight( rCopy.aCTLHeight ), +/*N*/ aCTLWeight( rCopy.aCTLWeight ), +/*N*/ aCTLPosture( rCopy.aCTLPosture ), +/*N*/ aUnderline( rCopy.aUnderline ), +/*N*/ aCrossedOut( rCopy.aCrossedOut ), +/*N*/ aContour( rCopy.aContour ), +/*N*/ aShadowed( rCopy.aShadowed ), +/*N*/ aColor( rCopy.aColor ), +/*N*/ aBox( rCopy.aBox ), +/*N*/ aBackground( rCopy.aBackground ), +/*N*/ aAdjust( rCopy.aAdjust ), +/*N*/ aHorJustify( rCopy.aHorJustify ), +/*N*/ aVerJustify( rCopy.aVerJustify ), +/*N*/ aOrientation( rCopy.aOrientation ), +/*N*/ aMargin( rCopy.aMargin ), +/*N*/ aLinebreak( rCopy.aLinebreak ), +/*N*/ aRotateAngle( rCopy.aRotateAngle ), +/*N*/ aRotateMode( rCopy.aRotateMode ), +/*N*/ aNumFormat( rCopy.aNumFormat ) +/*N*/ { +/*N*/ } + +/*N*/ ScAutoFormatDataField::~ScAutoFormatDataField() +/*N*/ { +/*N*/ } + +/*N*/ void ScAutoFormatDataField::SetAdjust( const SvxAdjustItem& rAdjust ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 aAdjust.SetAdjust( rAdjust.GetAdjust() ); +/*N*/ } + +/*N*/ #define READ( aItem, ItemType, nVers ) \ +/*N*/ pNew = aItem.Create( rStream, nVers ); \ +/*N*/ aItem = *(ItemType*)pNew; \ +/*N*/ delete pNew; + +/*N*/ BOOL ScAutoFormatDataField::Load( SvStream& rStream, const ScAfVersions& rVersions, USHORT nVer ) +/*N*/ { +/*N*/ SfxPoolItem* pNew; +/*N*/ +/*N*/ READ( aFont, SvxFontItem, rVersions.nFontVersion) +/*N*/ READ( aHeight, SvxFontHeightItem, rVersions.nFontHeightVersion) +/*N*/ READ( aWeight, SvxWeightItem, rVersions.nWeightVersion) +/*N*/ READ( aPosture, SvxPostureItem, rVersions.nPostureVersion) +/*N*/ // --- from 641 on: CJK and CTL font settings +/*N*/ if( AUTOFORMAT_DATA_ID_641 <= nVer ) +/*N*/ { +/*N*/ READ( aCJKFont, SvxFontItem, rVersions.nFontVersion) +/*N*/ READ( aCJKHeight, SvxFontHeightItem, rVersions.nFontHeightVersion) +/*N*/ READ( aCJKWeight, SvxWeightItem, rVersions.nWeightVersion) +/*N*/ READ( aCJKPosture, SvxPostureItem, rVersions.nPostureVersion) +/*N*/ READ( aCTLFont, SvxFontItem, rVersions.nFontVersion) +/*N*/ READ( aCTLHeight, SvxFontHeightItem, rVersions.nFontHeightVersion) +/*N*/ READ( aCTLWeight, SvxWeightItem, rVersions.nWeightVersion) +/*N*/ READ( aCTLPosture, SvxPostureItem, rVersions.nPostureVersion) +/*N*/ } +/*N*/ READ( aUnderline, SvxUnderlineItem, rVersions.nUnderlineVersion) +/*N*/ READ( aCrossedOut, SvxCrossedOutItem, rVersions.nCrossedOutVersion) +/*N*/ READ( aContour, SvxContourItem, rVersions.nContourVersion) +/*N*/ READ( aShadowed, SvxShadowedItem, rVersions.nShadowedVersion) +/*N*/ READ( aColor, SvxColorItem, rVersions.nColorVersion) +/*N*/ READ( aBox, SvxBoxItem, rVersions.nBoxVersion) +/*N*/ READ( aBackground, SvxBrushItem, rVersions.nBrushVersion) +/*N*/ +/*N*/ pNew = aAdjust.Create( rStream, rVersions.nAdjustVersion ); +/*N*/ SetAdjust( *(SvxAdjustItem*)pNew ); +/*N*/ delete pNew; +/*N*/ +/*N*/ READ( aHorJustify, SvxHorJustifyItem, rVersions.nHorJustifyVersion) +/*N*/ READ( aVerJustify, SvxVerJustifyItem, rVersions.nVerJustifyVersion) +/*N*/ READ( aOrientation, SvxOrientationItem, rVersions.nOrientationVersion) +/*N*/ READ( aMargin, SvxMarginItem, rVersions.nMarginVersion) +/*N*/ +/*N*/ pNew = aLinebreak.Create( rStream, rVersions.nBoolVersion ); +/*N*/ SetLinebreak( *(SfxBoolItem*)pNew ); +/*N*/ delete pNew; +/*N*/ +/*N*/ if ( nVer >= AUTOFORMAT_DATA_ID_504 ) +/*N*/ { +/*N*/ pNew = aRotateAngle.Create( rStream, rVersions.nInt32Version ); +/*N*/ SetRotateAngle( *(SfxInt32Item*)pNew ); +/*N*/ delete pNew; +/*N*/ pNew = aRotateMode.Create( rStream, rVersions.nRotateModeVersion ); +/*N*/ SetRotateMode( *(SvxRotateModeItem*)pNew ); +/*N*/ delete pNew; +/*N*/ } +/*N*/ +/*N*/ if( 0 == rVersions.nNumFmtVersion ) +/*N*/ aNumFormat.Load( rStream ); +/*N*/ +/*N*/ // adjust charset in font +/*N*/ CharSet eSysSet = gsl_getSystemTextEncoding(); +/*N*/ CharSet eSrcSet = rStream.GetStreamCharSet(); +/*N*/ if( eSrcSet != eSysSet && aFont.GetCharSet() == eSrcSet ) +/*N*/ aFont.GetCharSet() = eSysSet; +/*N*/ +/*N*/ return (rStream.GetError() == 0); +/*N*/ } + +/*N*/ #ifdef READ_OLDVERS +/*N*/ BOOL ScAutoFormatDataField::LoadOld( SvStream& rStream, const ScAfVersions& rVersions ) +/*N*/ { +/*N*/ SfxPoolItem* pNew; +/*N*/ +/*N*/ aNumFormat.Load(rStream); +/*N*/ +/*N*/ READ( aFont, SvxFontItem, rVersions.nFontVersion) +/*N*/ READ( aHeight, SvxFontHeightItem, rVersions.nFontHeightVersion) +/*N*/ READ( aWeight, SvxWeightItem, rVersions.nWeightVersion) +/*N*/ READ( aPosture, SvxPostureItem, rVersions.nPostureVersion) +/*N*/ READ( aUnderline, SvxUnderlineItem, rVersions.nUnderlineVersion) +/*N*/ READ( aCrossedOut, SvxCrossedOutItem, rVersions.nCrossedOutVersion) +/*N*/ READ( aContour, SvxContourItem, rVersions.nContourVersion) +/*N*/ READ( aShadowed, SvxShadowedItem, rVersions.nShadowedVersion) +/*N*/ READ( aColor, SvxColorItem, rVersions.nColorVersion) +/*N*/ READ( aHorJustify, SvxHorJustifyItem, rVersions.nHorJustifyVersion) +/*N*/ READ( aVerJustify, SvxVerJustifyItem, rVersions.nVerJustifyVersion) +/*N*/ READ( aOrientation, SvxOrientationItem, rVersions.nOrientationVersion) +/*N*/ pNew = aLinebreak.Create( rStream, rVersions.nBoolVersion ); +/*N*/ SetLinebreak( *(SfxBoolItem*)pNew ); +/*N*/ delete pNew; +/*N*/ READ( aMargin, SvxMarginItem, rVersions.nMarginVersion) +/*N*/ READ( aBox, SvxBoxItem, rVersions.nBoxVersion) +/*N*/ READ( aBackground, SvxBrushItem, rVersions.nBrushVersion) +/*N*/ +/*N*/ return (rStream.GetError() == 0); +/*N*/ } +/*N*/ #endif +/*N*/ +/*N*/ BOOL ScAutoFormatDataField::Save( SvStream& rStream ) +/*N*/ { +/*N*/ aFont.Store ( rStream, aFont.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aHeight.Store ( rStream, aHeight.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aWeight.Store ( rStream, aWeight.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aPosture.Store ( rStream, aPosture.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ // --- from 641 on: CJK and CTL font settings +/*N*/ aCJKFont.Store ( rStream, aCJKFont.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCJKHeight.Store ( rStream, aCJKHeight.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCJKWeight.Store ( rStream, aCJKWeight.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCJKPosture.Store ( rStream, aCJKPosture.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCTLFont.Store ( rStream, aCTLFont.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCTLHeight.Store ( rStream, aCTLHeight.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCTLWeight.Store ( rStream, aCTLWeight.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCTLPosture.Store ( rStream, aCTLPosture.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ +/*N*/ aUnderline.Store ( rStream, aUnderline.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aCrossedOut.Store ( rStream, aCrossedOut.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aContour.Store ( rStream, aContour.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aShadowed.Store ( rStream, aShadowed.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aColor.Store ( rStream, aColor.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aBox.Store ( rStream, aBox.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aBackground.Store ( rStream, aBackground.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ +/*N*/ aAdjust.Store ( rStream, aAdjust.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ +/*N*/ aHorJustify.Store ( rStream, aHorJustify.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aVerJustify.Store ( rStream, aVerJustify.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aOrientation.Store ( rStream, aOrientation.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aMargin.Store ( rStream, aMargin.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aLinebreak.Store ( rStream, aLinebreak.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ // Rotation ab SO5 +/*N*/ aRotateAngle.Store ( rStream, aRotateAngle.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ aRotateMode.Store ( rStream, aRotateMode.GetVersion( SOFFICE_FILEFORMAT_40 ) ); +/*N*/ +/*N*/ aNumFormat.Save( rStream ); +/*N*/ +/*N*/ return (rStream.GetError() == 0); +/*N*/ } + + +// --------------------------------------------------------------------------- + +/*N*/ ScAutoFormatData::ScAutoFormatData() +/*N*/ { +/*N*/ nStrResId = USHRT_MAX; +/*N*/ +/*N*/ bIncludeValueFormat = +/*N*/ bIncludeFont = +/*N*/ bIncludeJustify = +/*N*/ bIncludeFrame = +/*N*/ bIncludeBackground = +/*N*/ bIncludeWidthHeight = TRUE; +/*N*/ +/*N*/ ppDataField = new ScAutoFormatDataField*[ 16 ]; +/*N*/ for( USHORT nIndex = 0; nIndex < 16; ++nIndex ) +/*N*/ ppDataField[ nIndex ] = new ScAutoFormatDataField; +/*N*/ } + +/*N*/ ScAutoFormatData::ScAutoFormatData( const ScAutoFormatData& rData ) : +/*N*/ aName( rData.aName ), +/*N*/ nStrResId( rData.nStrResId ), +/*N*/ bIncludeValueFormat( rData.bIncludeValueFormat ), +/*N*/ bIncludeFont( rData.bIncludeFont ), +/*N*/ bIncludeJustify( rData.bIncludeJustify ), +/*N*/ bIncludeFrame( rData.bIncludeFrame ), +/*N*/ bIncludeBackground( rData.bIncludeBackground ), +/*N*/ bIncludeWidthHeight( rData.bIncludeWidthHeight ) +/*N*/ { +/*N*/ ppDataField = new ScAutoFormatDataField*[ 16 ]; +/*N*/ for( USHORT nIndex = 0; nIndex < 16; ++nIndex ) +/*N*/ ppDataField[ nIndex ] = new ScAutoFormatDataField( rData.GetField( nIndex ) ); +/*N*/ } + +/*N*/ ScAutoFormatData::~ScAutoFormatData() +/*N*/ { +/*N*/ for( USHORT nIndex = 0; nIndex < 16; ++nIndex ) +/*N*/ delete ppDataField[ nIndex ]; +/*N*/ delete[] ppDataField; +/*N*/ } + +/*N*/ ScAutoFormatDataField& ScAutoFormatData::GetField( USHORT nIndex ) +/*N*/ { +/*N*/ DBG_ASSERT( (0 <= nIndex) && (nIndex < 16), "ScAutoFormatData::GetField - illegal index" ); +/*N*/ DBG_ASSERT( ppDataField && ppDataField[ nIndex ], "ScAutoFormatData::GetField - no data" ); +/*N*/ return *ppDataField[ nIndex ]; +/*N*/ } + +/*N*/ const ScAutoFormatDataField& ScAutoFormatData::GetField( USHORT nIndex ) const +/*N*/ { +/*N*/ DBG_ASSERT( (0 <= nIndex) && (nIndex < 16), "ScAutoFormatData::GetField - illegal index" ); +/*N*/ DBG_ASSERT( ppDataField && ppDataField[ nIndex ], "ScAutoFormatData::GetField - no data" ); +/*N*/ return *ppDataField[ nIndex ]; +/*N*/ } + +/*N*/ const SfxPoolItem* ScAutoFormatData::GetItem( USHORT nIndex, USHORT nWhich ) const +/*N*/ { +/*N*/ const ScAutoFormatDataField& rField = GetField( nIndex ); +/*N*/ switch( nWhich ) +/*N*/ { +/*N*/ case ATTR_FONT: return &rField.GetFont(); +/*N*/ case ATTR_FONT_HEIGHT: return &rField.GetHeight(); +/*N*/ case ATTR_FONT_WEIGHT: return &rField.GetWeight(); +/*N*/ case ATTR_FONT_POSTURE: return &rField.GetPosture(); +/*N*/ case ATTR_CJK_FONT: return &rField.GetCJKFont(); +/*N*/ case ATTR_CJK_FONT_HEIGHT: return &rField.GetCJKHeight(); +/*N*/ case ATTR_CJK_FONT_WEIGHT: return &rField.GetCJKWeight(); +/*N*/ case ATTR_CJK_FONT_POSTURE: return &rField.GetCJKPosture(); +/*N*/ case ATTR_CTL_FONT: return &rField.GetCTLFont(); +/*N*/ case ATTR_CTL_FONT_HEIGHT: return &rField.GetCTLHeight(); +/*N*/ case ATTR_CTL_FONT_WEIGHT: return &rField.GetCTLWeight(); +/*N*/ case ATTR_CTL_FONT_POSTURE: return &rField.GetCTLPosture(); +/*N*/ case ATTR_FONT_UNDERLINE: return &rField.GetUnderline(); +/*N*/ case ATTR_FONT_CROSSEDOUT: return &rField.GetCrossedOut(); +/*N*/ case ATTR_FONT_CONTOUR: return &rField.GetContour(); +/*N*/ case ATTR_FONT_SHADOWED: return &rField.GetShadowed(); +/*N*/ case ATTR_FONT_COLOR: return &rField.GetColor(); +/*N*/ case ATTR_BORDER: return &rField.GetBox(); +/*N*/ case ATTR_BACKGROUND: return &rField.GetBackground(); +/*N*/ case ATTR_HOR_JUSTIFY: return &rField.GetHorJustify(); +/*N*/ case ATTR_VER_JUSTIFY: return &rField.GetVerJustify(); +/*N*/ case ATTR_ORIENTATION: return &rField.GetOrientation(); +/*N*/ case ATTR_MARGIN: return &rField.GetMargin(); +/*N*/ case ATTR_LINEBREAK: return &rField.GetLinebreak(); +/*N*/ case ATTR_ROTATE_VALUE: return &rField.GetRotateAngle(); +/*N*/ case ATTR_ROTATE_MODE: return &rField.GetRotateMode(); +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScAutoFormatData::PutItem( USHORT nIndex, const SfxPoolItem& rItem ) +/*N*/ { +/*N*/ ScAutoFormatDataField& rField = GetField( nIndex ); +/*N*/ switch( rItem.Which() ) +/*N*/ { +/*N*/ case ATTR_FONT: rField.SetFont( (const SvxFontItem&)rItem ); break; +/*N*/ case ATTR_FONT_HEIGHT: rField.SetHeight( (const SvxFontHeightItem&)rItem ); break; +/*N*/ case ATTR_FONT_WEIGHT: rField.SetWeight( (const SvxWeightItem&)rItem ); break; +/*N*/ case ATTR_FONT_POSTURE: rField.SetPosture( (const SvxPostureItem&)rItem ); break; +/*N*/ case ATTR_CJK_FONT: rField.SetCJKFont( (const SvxFontItem&)rItem ); break; +/*N*/ case ATTR_CJK_FONT_HEIGHT: rField.SetCJKHeight( (const SvxFontHeightItem&)rItem ); break; +/*N*/ case ATTR_CJK_FONT_WEIGHT: rField.SetCJKWeight( (const SvxWeightItem&)rItem ); break; +/*N*/ case ATTR_CJK_FONT_POSTURE: rField.SetCJKPosture( (const SvxPostureItem&)rItem ); break; +/*N*/ case ATTR_CTL_FONT: rField.SetCTLFont( (const SvxFontItem&)rItem ); break; +/*N*/ case ATTR_CTL_FONT_HEIGHT: rField.SetCTLHeight( (const SvxFontHeightItem&)rItem ); break; +/*N*/ case ATTR_CTL_FONT_WEIGHT: rField.SetCTLWeight( (const SvxWeightItem&)rItem ); break; +/*N*/ case ATTR_CTL_FONT_POSTURE: rField.SetCTLPosture( (const SvxPostureItem&)rItem ); break; +/*N*/ case ATTR_FONT_UNDERLINE: rField.SetUnderline( (const SvxUnderlineItem&)rItem ); break; +/*N*/ case ATTR_FONT_CROSSEDOUT: rField.SetCrossedOut( (const SvxCrossedOutItem&)rItem ); break; +/*N*/ case ATTR_FONT_CONTOUR: rField.SetContour( (const SvxContourItem&)rItem ); break; +/*N*/ case ATTR_FONT_SHADOWED: rField.SetShadowed( (const SvxShadowedItem&)rItem ); break; +/*N*/ case ATTR_FONT_COLOR: rField.SetColor( (const SvxColorItem&)rItem ); break; +/*N*/ case ATTR_BORDER: rField.SetBox( (const SvxBoxItem&)rItem ); break; +/*N*/ case ATTR_BACKGROUND: rField.SetBackground( (const SvxBrushItem&)rItem ); break; +/*N*/ case ATTR_HOR_JUSTIFY: rField.SetHorJustify( (const SvxHorJustifyItem&)rItem ); break; +/*N*/ case ATTR_VER_JUSTIFY: rField.SetVerJustify( (const SvxVerJustifyItem&)rItem ); break; +/*N*/ case ATTR_ORIENTATION: rField.SetOrientation( (const SvxOrientationItem&)rItem );break; +/*N*/ case ATTR_MARGIN: rField.SetMargin( (const SvxMarginItem&)rItem ); break; +/*N*/ case ATTR_LINEBREAK: rField.SetLinebreak( (const SfxBoolItem&)rItem ); break; +/*N*/ case ATTR_ROTATE_VALUE: rField.SetRotateAngle( (const SfxInt32Item&)rItem ); break; +/*N*/ case ATTR_ROTATE_MODE: rField.SetRotateMode( (const SvxRotateModeItem&)rItem ); break; +/*N*/ } +/*N*/ } + + + + + + + +/*N*/ BOOL ScAutoFormatData::Load( SvStream& rStream, const ScAfVersions& rVersions ) +/*N*/ { +/*N*/ BOOL bRet = TRUE; +/*N*/ USHORT nVer = 0; +/*N*/ rStream >> nVer; +/*N*/ bRet = 0 == rStream.GetError(); +/*N*/ if( bRet && (nVer == AUTOFORMAT_DATA_ID_X || +/*N*/ (AUTOFORMAT_DATA_ID_504 <= nVer && nVer <= AUTOFORMAT_DATA_ID)) ) +/*N*/ { +/*N*/ CharSet eSysSet = gsl_getSystemTextEncoding(); +/*N*/ CharSet eSrcSet = rStream.GetStreamCharSet(); +/*N*/ +/*N*/ BOOL b; +/*N*/ rStream.ReadByteString( aName, eSrcSet ); +/*N*/ if( AUTOFORMAT_DATA_ID_552 <= nVer ) +/*N*/ { +/*N*/ rStream >> nStrResId; +/*N*/ USHORT nId = RID_SVXSTR_TBLAFMT_BEGIN + nStrResId; +/*N*/ if( RID_SVXSTR_TBLAFMT_BEGIN <= nId && +/*N*/ nId < RID_SVXSTR_TBLAFMT_END ) +/*N*/ { +/*N*/ aName = SVX_RESSTR( nId ); +/*N*/ } +/*N*/ else +/*N*/ nStrResId = USHRT_MAX; +/*N*/ } +/*N*/ +/*N*/ rStream >> b; bIncludeFont = b; +/*N*/ rStream >> b; bIncludeJustify = b; +/*N*/ rStream >> b; bIncludeFrame = b; +/*N*/ rStream >> b; bIncludeBackground = b; +/*N*/ rStream >> b; bIncludeValueFormat = b; +/*N*/ rStream >> b; bIncludeWidthHeight = b; +/*N*/ +/*N*/ bRet = 0 == rStream.GetError(); +/*N*/ for( USHORT i = 0; bRet && i < 16; ++i ) +/*N*/ bRet = GetField( i ).Load( rStream, rVersions, nVer ); +/*N*/ } +/*N*/ else +/*N*/ bRet = FALSE; +/*N*/ return bRet; +/*N*/ } + +/*N*/ #ifdef READ_OLDVERS +/*N*/ BOOL ScAutoFormatData::LoadOld( SvStream& rStream, const ScAfVersions& rVersions ) +/*N*/ { +/*N*/ BOOL bRet = TRUE; +/*N*/ USHORT nVal = 0; +/*N*/ rStream >> nVal; +/*N*/ bRet = (rStream.GetError() == 0); +/*N*/ if (bRet && (nVal == AUTOFORMAT_OLD_DATA_ID)) +/*N*/ { +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ BOOL b; +/*N*/ rStream >> b; bIncludeFont = b; +/*N*/ rStream >> b; bIncludeJustify = b; +/*N*/ rStream >> b; bIncludeFrame = b; +/*N*/ rStream >> b; bIncludeBackground = b; +/*N*/ rStream >> b; bIncludeValueFormat = b; +/*N*/ rStream >> b; bIncludeWidthHeight = b; +/*N*/ +/*N*/ bRet = 0 == rStream.GetError(); +/*N*/ for (USHORT i=0; bRet && i < 16; i++) +/*N*/ bRet = GetField( i ).LoadOld( rStream, rVersions ); +/*N*/ } +/*N*/ else +/*N*/ bRet = FALSE; +/*N*/ return bRet; +/*N*/ } +/*N*/ #endif +/*N*/ +/*N*/ BOOL ScAutoFormatData::Save(SvStream& rStream) +/*N*/ { +/*N*/ USHORT nVal = AUTOFORMAT_DATA_ID; +/*N*/ BOOL b; +/*N*/ rStream << nVal; +/*N*/ rStream.WriteByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ #if 0 +/*N*/ // This was an internal flag to allow creating AutoFormats with localized names +/*N*/ +/*N*/ if ( USHRT_MAX == nStrResId ) +/*N*/ { +/*N*/ String aIniVal( SFX_APP()->GetIniManager()->Get( +/*N*/ SFX_GROUP_WORKINGSET_IMPL, +/*N*/ String( RTL_CONSTASCII_USTRINGPARAM( "SaveTableAutoFmtNameId" )))); +/*N*/ if( 0 != aIniVal.ToInt32() ) +/*N*/ { +/*N*/ // check Name for ResId +/*N*/ for( USHORT nId = RID_SVXSTR_TBLAFMT_BEGIN; +/*N*/ RID_SVXSTR_TBLAFMT_END > nId; ++nId ) +/*N*/ { +/*N*/ String s( SVX_RES( nId ) ); +/*N*/ if( s == aName ) +/*N*/ { +/*N*/ nStrResId = nId - RID_SVXSTR_TBLAFMT_BEGIN; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ #endif +/*N*/ +/*N*/ rStream << nStrResId; +/*N*/ rStream << ( b = bIncludeFont ); +/*N*/ rStream << ( b = bIncludeJustify ); +/*N*/ rStream << ( b = bIncludeFrame ); +/*N*/ rStream << ( b = bIncludeBackground ); +/*N*/ rStream << ( b = bIncludeValueFormat ); +/*N*/ rStream << ( b = bIncludeWidthHeight ); +/*N*/ +/*N*/ BOOL bRet = 0 == rStream.GetError(); +/*N*/ for (USHORT i = 0; bRet && (i < 16); i++) +/*N*/ bRet = GetField( i ).Save( rStream ); +/*N*/ +/*N*/ return bRet; +/*N*/ } + +//--------------------------------------------------------------------------------------- +//--------------------------------------------------------------------------------------- + +/*N*/ ScAutoFormat::ScAutoFormat(USHORT nLim, USHORT nDel, BOOL bDup): +/*N*/ SortedCollection (nLim, nDel, bDup), +/*N*/ bSaveLater (FALSE) +/*N*/ { +/*N*/ // create default autoformat +/*N*/ ScAutoFormatData* pData = new ScAutoFormatData; +/*N*/ String aName(ScGlobal::GetRscString(STR_STYLENAME_STANDARD)); +/*N*/ pData->SetName(aName); +/*N*/ +/*N*/ // default font, default height +/*N*/ Font aStdFont = OutputDevice::GetDefaultFont( +/*N*/ DEFAULTFONT_LATIN_SPREADSHEET, LANGUAGE_ENGLISH_US, DEFAULTFONT_FLAGS_ONLYONE ); +/*N*/ SvxFontItem aFontItem( +/*N*/ aStdFont.GetFamily(), aStdFont.GetName(), aStdFont.GetStyleName(), +/*N*/ aStdFont.GetPitch(), aStdFont.GetCharSet() ); +/*N*/ +/*N*/ aStdFont = OutputDevice::GetDefaultFont( +/*N*/ DEFAULTFONT_CJK_SPREADSHEET, LANGUAGE_ENGLISH_US, DEFAULTFONT_FLAGS_ONLYONE ); +/*N*/ SvxFontItem aCJKFontItem( +/*N*/ aStdFont.GetFamily(), aStdFont.GetName(), aStdFont.GetStyleName(), +/*N*/ aStdFont.GetPitch(), aStdFont.GetCharSet(), ATTR_CJK_FONT ); +/*N*/ +/*N*/ aStdFont = OutputDevice::GetDefaultFont( +/*N*/ DEFAULTFONT_CTL_SPREADSHEET, LANGUAGE_ENGLISH_US, DEFAULTFONT_FLAGS_ONLYONE ); +/*N*/ SvxFontItem aCTLFontItem( +/*N*/ aStdFont.GetFamily(), aStdFont.GetName(), aStdFont.GetStyleName(), +/*N*/ aStdFont.GetPitch(), aStdFont.GetCharSet(), ATTR_CTL_FONT ); +/*N*/ +/*N*/ SvxFontHeightItem aHeight( 200 ); // 10 pt; +/*N*/ +/*N*/ // black thin border +/*N*/ Color aBlack( COL_BLACK ); +/*N*/ SvxBorderLine aLine( &aBlack, DEF_LINE_WIDTH_0 ); +/*N*/ SvxBoxItem aBox; +/*N*/ aBox.SetLine(&aLine, BOX_LINE_LEFT); +/*N*/ aBox.SetLine(&aLine, BOX_LINE_TOP); +/*N*/ aBox.SetLine(&aLine, BOX_LINE_RIGHT); +/*N*/ aBox.SetLine(&aLine, BOX_LINE_BOTTOM); +/*N*/ +/*N*/ Color aWhite(COL_WHITE); +/*N*/ Color aBlue(COL_BLUE); +/*N*/ SvxColorItem aWhiteText( aWhite ); +/*N*/ SvxColorItem aBlackText( aBlack ); +/*N*/ SvxBrushItem aBlueBack( aBlue ); +/*N*/ SvxBrushItem aWhiteBack( aWhite ); +/*N*/ SvxBrushItem aGray70Back( Color(0x4d, 0x4d, 0x4d) ); +/*N*/ SvxBrushItem aGray20Back( Color(0xcc, 0xcc, 0xcc) ); +/*N*/ +/*N*/ for (USHORT i=0; i<16; i++) +/*N*/ { +/*N*/ pData->PutItem( i, aBox ); +/*N*/ pData->PutItem( i, aFontItem ); +/*N*/ pData->PutItem( i, aCJKFontItem ); +/*N*/ pData->PutItem( i, aCTLFontItem ); +/*N*/ aHeight.SetWhich( ATTR_FONT_HEIGHT ); +/*N*/ pData->PutItem( i, aHeight ); +/*N*/ aHeight.SetWhich( ATTR_CJK_FONT_HEIGHT ); +/*N*/ pData->PutItem( i, aHeight ); +/*N*/ aHeight.SetWhich( ATTR_CTL_FONT_HEIGHT ); +/*N*/ pData->PutItem( i, aHeight ); +/*N*/ if (i<4) // top: white on blue +/*N*/ { +/*N*/ pData->PutItem( i, aWhiteText ); +/*N*/ pData->PutItem( i, aBlueBack ); +/*N*/ } +/*N*/ else if ( i%4 == 0 ) // left: white on gray70 +/*N*/ { +/*N*/ pData->PutItem( i, aWhiteText ); +/*N*/ pData->PutItem( i, aGray70Back ); +/*N*/ } +/*N*/ else if ( i%4 == 3 || i >= 12 ) // right and bottom: black on gray20 +/*N*/ { +/*N*/ pData->PutItem( i, aBlackText ); +/*N*/ pData->PutItem( i, aGray20Back ); +/*N*/ } +/*N*/ else // center: black on white +/*N*/ { +/*N*/ pData->PutItem( i, aBlackText ); +/*N*/ pData->PutItem( i, aWhiteBack ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ Insert(pData); +/*N*/ } + +/*N*/ ScAutoFormat::ScAutoFormat(const ScAutoFormat& rAutoFormat) : +/*N*/ SortedCollection (rAutoFormat), +/*N*/ bSaveLater (FALSE) +/*N*/ {} + +/*N*/ ScAutoFormat::~ScAutoFormat() +/*N*/ { +/*N*/ // Bei Aenderungen per StarOne wird nicht sofort gespeichert, sondern zuerst nur +/*N*/ // das SaveLater Flag gesetzt. Wenn das Flag noch gesetzt ist, jetzt speichern. +/*N*/ +/*N*/ if (bSaveLater) +/*N*/ Save(); +/*N*/ } + +/*N*/ void ScAutoFormat::SetSaveLater( BOOL bSet ) +/*N*/ { +/*N*/ bSaveLater = bSet; +/*N*/ } + + +/*N*/ BOOL ScAutoFormat::Load() +/*N*/ { +/*N*/ BOOL bRet = TRUE; +/*N*/ +/*N*/ INetURLObject aURL; +/*N*/ SvtPathOptions aPathOpt; +/*N*/ aURL.SetSmartURL( aPathOpt.GetUserConfigPath() ); +/*N*/ aURL.setFinalSlash(); +/*N*/ aURL.Append( String( RTL_CONSTASCII_USTRINGPARAM( sAutoTblFmtName ) ) ); +/*N*/ +/*N*/ SfxMedium aMedium( aURL.GetMainURL(INetURLObject::NO_DECODE), STREAM_READ, TRUE ); +/*N*/ SvStream* pStream = aMedium.GetInStream(); +/*N*/ bRet = (pStream && pStream->GetError() == 0); +/*N*/ if (bRet) +/*N*/ { +/*N*/ SvStream& rStream = *pStream; +/*N*/ // Achtung hier muss ein allgemeiner Header gelesen werden +/*N*/ USHORT nVal = 0; +/*N*/ rStream >> nVal; +/*N*/ bRet = 0 == rStream.GetError(); +/*N*/ +/*N*/ ScAfVersions aVersions; +/*N*/ +/*N*/ if (bRet) +/*N*/ { +/*N*/ if( nVal == AUTOFORMAT_ID_358 || +/*N*/ (AUTOFORMAT_ID_504 <= nVal && nVal <= AUTOFORMAT_ID) ) +/*N*/ { +/*N*/ UINT16 nFileVers = SOFFICE_FILEFORMAT_40; +/*N*/ BYTE nChrSet, nCnt; +/*N*/ long nPos = rStream.Tell(); +/*N*/ rStream >> nCnt >> nChrSet; +/*N*/ // if( 4 <= nCnt ) +/*N*/ // rStream >> nFileVers; +/*N*/ if( rStream.Tell() != ULONG(nPos + nCnt) ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "Der Header enthaelt mehr/neuere Daten" ); +/*N*/ rStream.Seek( nPos + nCnt ); +/*N*/ } +/*N*/ rStream.SetStreamCharSet( GetSOLoadTextEncoding( nChrSet, nFileVers ) ); +/*N*/ rStream.SetVersion( nFileVers ); +/*N*/ } +/*N*/ +/*N*/ if( nVal == AUTOFORMAT_ID_358 || nVal == AUTOFORMAT_ID_X || +/*N*/ (AUTOFORMAT_ID_504 <= nVal && nVal <= AUTOFORMAT_ID) ) +/*N*/ { +/*N*/ aVersions.Load( rStream, nVal ); // Item-Versionen +/*N*/ +/*N*/ ScAutoFormatData* pData; +/*N*/ USHORT nAnz = 0; +/*N*/ rStream >> nAnz; +/*N*/ bRet = (rStream.GetError() == 0); +/*N*/ for (USHORT i=0; bRet && (i < nAnz); i++) +/*N*/ { +/*N*/ pData = new ScAutoFormatData(); +/*N*/ bRet = pData->Load(rStream, aVersions); +/*N*/ Insert(pData); +/*N*/ } +/*N*/ } +/*N*/ #ifdef READ_OLDVERS +/*N*/ else +/*N*/ { +/*N*/ if( AUTOFORMAT_OLD_ID_NEW == nVal ) +/*N*/ { +/*N*/ // alte Version der Versions laden +/*N*/ rStream >> aVersions.nFontVersion; +/*N*/ rStream >> aVersions.nFontHeightVersion; +/*N*/ rStream >> aVersions.nWeightVersion; +/*N*/ rStream >> aVersions.nPostureVersion; +/*N*/ rStream >> aVersions.nUnderlineVersion; +/*N*/ rStream >> aVersions.nCrossedOutVersion; +/*N*/ rStream >> aVersions.nContourVersion; +/*N*/ rStream >> aVersions.nShadowedVersion; +/*N*/ rStream >> aVersions.nColorVersion; +/*N*/ rStream >> aVersions.nHorJustifyVersion; +/*N*/ rStream >> aVersions.nVerJustifyVersion; +/*N*/ rStream >> aVersions.nOrientationVersion; +/*N*/ rStream >> aVersions.nBoolVersion; +/*N*/ rStream >> aVersions.nMarginVersion; +/*N*/ rStream >> aVersions.nBoxVersion; +/*N*/ rStream >> aVersions.nBrushVersion; +/*N*/ } +/*N*/ if( AUTOFORMAT_OLD_ID_OLD == nVal || +/*N*/ AUTOFORMAT_OLD_ID_NEW == nVal ) +/*N*/ { +/*N*/ ScAutoFormatData* pData; +/*N*/ USHORT nAnz = 0; +/*N*/ rStream >> nAnz; +/*N*/ bRet = 0 == rStream.GetError(); +/*N*/ for( USHORT i=0; bRet && (i < nAnz); ++i ) +/*N*/ { +/*N*/ pData = new ScAutoFormatData(); +/*N*/ bRet = pData->LoadOld( rStream, aVersions ); +/*N*/ Insert( pData ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bRet = FALSE; +/*N*/ } +/*N*/ #endif +/*N*/ } +/*N*/ } +/*N*/ bSaveLater = FALSE; +/*N*/ return bRet; +/*N*/ } + +/*N*/ BOOL ScAutoFormat::Save() +/*N*/ { +/*N*/ BOOL bRet = TRUE; +/*N*/ +/*N*/ INetURLObject aURL; +/*N*/ SvtPathOptions aPathOpt; +/*N*/ aURL.SetSmartURL( aPathOpt.GetUserConfigPath() ); +/*N*/ aURL.setFinalSlash(); +/*N*/ aURL.Append( String( RTL_CONSTASCII_USTRINGPARAM( sAutoTblFmtName ) ) ); +/*N*/ +/*N*/ SfxMedium aMedium( aURL.GetMainURL(INetURLObject::NO_DECODE), STREAM_WRITE, TRUE ); +/*N*/ SvStream* pStream = aMedium.GetOutStream(); +/*N*/ bRet = (pStream && pStream->GetError() == 0); +/*N*/ if (bRet) +/*N*/ { +/*N*/ SvStream& rStream = *pStream; +/*N*/ rStream.SetVersion( SOFFICE_FILEFORMAT_40 ); +/*N*/ +/*N*/ // Achtung hier muss ein allgemeiner Header gespeichert werden +/*N*/ USHORT nVal = AUTOFORMAT_ID; +/*N*/ rStream << nVal +/*N*/ << (BYTE)2 // Anzahl von Zeichen des Headers incl. diesem +/*N*/ << (BYTE)::GetSOStoreTextEncoding( +/*N*/ gsl_getSystemTextEncoding(), rStream.GetVersion() ); +/*N*/ // << (BYTE)4 // Anzahl von Zeichen des Headers incl. diesem +/*N*/ // << (BYTE)::GetStoreCharSet(::GetSystemCharSet()) +/*N*/ // << (UNIT16)SOFFICE_FILEFORMAT_NOW; +/*N*/ ScAfVersions::Write(rStream); // Item-Versionen +/*N*/ +/*N*/ bRet = (rStream.GetError() == 0); +/*N*/ //----------------------------------------------------------- +/*N*/ rStream << (USHORT)(nCount - 1); +/*N*/ bRet = (rStream.GetError() == 0); +/*N*/ for (USHORT i=1; bRet && (i < nCount); i++) +/*N*/ bRet = ((ScAutoFormatData*)pItems[i])->Save(rStream); +/*N*/ rStream.Flush(); +/*N*/ +/*N*/ aMedium.Commit(); +/*N*/ } +/*N*/ bSaveLater = FALSE; +/*N*/ return bRet; +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_callform.cxx b/binfilter/bf_sc/source/core/tool/sc_callform.cxx new file mode 100644 index 000000000000..294db281dbec --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_callform.cxx @@ -0,0 +1,318 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <osl/module.hxx> + +#include "adiasync.hxx" +#include <tools/debug.hxx> +namespace binfilter { + + +//------------------------------------------------------------------------ + +extern "C" { + +typedef void (CALLTYPE* ExFuncPtr1)(void*); +typedef void (CALLTYPE* ExFuncPtr2)(void*, void*); +typedef void (CALLTYPE* ExFuncPtr3)(void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr4)(void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr5)(void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr6)(void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr7)(void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr8)(void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr9)(void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr10)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr11)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr12)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr13)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr14)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr15)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); +typedef void (CALLTYPE* ExFuncPtr16)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); + +typedef void (CALLTYPE* GetFuncCountPtr)(USHORT& nCount); +typedef void (CALLTYPE* GetFuncDataPtr) + (USHORT& nNo, sal_Char* pFuncName, USHORT& nParamCount, ParamType* peType, sal_Char* pInternalName); + +typedef void (CALLTYPE* SetLanguagePtr)( USHORT& nLanguage ); +typedef void (CALLTYPE* GetParamDesc) + (USHORT& nNo, USHORT& nParam, sal_Char* pName, sal_Char* pDesc ); + +typedef void (CALLTYPE* IsAsync) ( USHORT& nNo, + ParamType* peType ); +typedef void (CALLTYPE* Advice) ( USHORT& nNo, + AdvData& pfCallback ); +typedef void (CALLTYPE* Unadvice)( double& nHandle ); + +typedef void (CALLTYPE* FARPROC) ( void ); + +} + +#if defined(OS2) && defined(BLC) +#define GETFUNCTIONCOUNT "_GetFunctionCount" +#define GETFUNCTIONDATA "_GetFunctionData" +#define SETLANGUAGE "_SetLanguage" +#define GETPARAMDESC "_GetParameterDescription" +#define ISASYNC "_IsAsync" +#define ADVICE "_Advice" +#define UNADVICE "_Unadvice" +#else // Pascal oder extern "C" +#define GETFUNCTIONCOUNT "GetFunctionCount" +#define GETFUNCTIONDATA "GetFunctionData" +#define SETLANGUAGE "SetLanguage" +#define GETPARAMDESC "GetParameterDescription" +#define ISASYNC "IsAsync" +#define ADVICE "Advice" +#define UNADVICE "Unadvice" +#endif + +#define LIBFUNCNAME( name ) \ + (String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( name ) )) + +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +/*N*/ FuncData::FuncData(const String& rIName) : +/*N*/ pModuleData (NULL), +/*N*/ aInternalName (rIName), +/*N*/ // aFuncName (""), +/*N*/ nNumber (0), +/*N*/ nParamCount (0), +/*N*/ eAsyncType (NONE) +/*N*/ { +/*N*/ for (USHORT i = 0; i < MAXFUNCPARAM; i++) +/*N*/ eParamType[i] = PTR_DOUBLE; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ FuncData::FuncData(const FuncData& rData) : +/*N*/ pModuleData (rData.pModuleData), +/*N*/ aInternalName (rData.aInternalName), +/*N*/ aFuncName (rData.aFuncName), +/*N*/ nNumber (rData.nNumber), +/*N*/ nParamCount (rData.nParamCount), +/*N*/ eAsyncType (rData.eAsyncType) +/*N*/ { +/*N*/ for (USHORT i = 0; i < MAXFUNCPARAM; i++) +/*N*/ eParamType[i] = rData.eParamType[i]; +/*N*/ } + +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +/*N*/ short FuncCollection::Compare(DataObject* pKey1, DataObject* pKey2) const +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); return 0; //STRIP001 return (short) ScGlobal::pTransliteration->compareString( +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL FuncCollection::SearchFunc( const String& rName, USHORT& rIndex ) const +/*N*/ { +/*N*/ FuncData aDataObj(rName); +/*N*/ return Search( &aDataObj, rIndex ); +/*N*/ } + +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +class ModuleData : public DataObject +{ + friend class ModuleCollection; + String aName; + osl::Module* pInstance; +public: + ModuleData(const String& rStr, osl::Module* pInst) : aName (rStr), pInstance (pInst) {} + ModuleData(const ModuleData& rData) : aName (rData.aName) {pInstance = new osl::Module(aName);} + ~ModuleData() { delete pInstance; } + virtual DataObject* Clone() const { return new ModuleData(*this); } + + const String& GetName() const { return aName; } + osl::Module* GetInstance() const { return pInstance; } + void FreeInstance() { delete pInstance; pInstance = 0; } +}; + +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +/*N*/ class ModuleCollection : public SortedCollection +/*N*/ { +/*N*/ public: +/*N*/ ModuleCollection(USHORT nLim = 4, USHORT nDel = 4, BOOL bDup = FALSE) : SortedCollection ( nLim, nDel, bDup ) {} +/*N*/ ModuleCollection(const ModuleCollection& rModuleCollection) : SortedCollection ( rModuleCollection ) {} +/*N*/ +/*N*/ virtual DataObject* Clone() const { return new ModuleCollection(*this); } +/*N*/ ModuleData* operator[]( const USHORT nIndex) const {return (ModuleData*)At(nIndex);} + virtual short Compare(DataObject* pKey1, DataObject* pKey2) const{DBG_BF_ASSERT(0, "STRIP"); return 0;} //STRIP001 virtual short Compare(DataObject* pKey1, DataObject* pKey2) const; +/*N*/ }; + +/*N*/ #ifdef _MSC_VER +/*N*/ #pragma code_seg("SCSTATICS") +/*N*/ #endif +/*N*/ +/*N*/ static ModuleCollection aModuleCollection; +/*N*/ +/*N*/ #ifdef _MSC_VER +/*N*/ #pragma code_seg() +/*N*/ #endif + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + + +//------------------------------------------------------------------------ + +/*N*/ void ExitExternalFunc() +/*N*/ { +/*N*/ USHORT nCount = aModuleCollection.GetCount(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*?*/ ModuleData* pData = aModuleCollection[i]; +/*?*/ pData->FreeInstance(); +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL FuncData::Call(void** ppParam) +/*N*/ { +/*N*/ BOOL bRet = FALSE; + osl::Module* pLib = pModuleData->GetInstance(); +/*N*/ FARPROC fProc = (FARPROC)pLib->getSymbol(aFuncName); +/*N*/ if (fProc != NULL) +/*N*/ { +/*N*/ switch (nParamCount) +/*N*/ { +/*N*/ case 1 : +/*N*/ (*((ExFuncPtr1)fProc))(ppParam[0]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 2 : +/*N*/ (*((ExFuncPtr2)fProc))(ppParam[0], ppParam[1]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 3 : +/*N*/ (*((ExFuncPtr3)fProc))(ppParam[0], ppParam[1], ppParam[2]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 4 : +/*N*/ (*((ExFuncPtr4)fProc))(ppParam[0], ppParam[1], ppParam[2], ppParam[3]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 5 : +/*N*/ (*((ExFuncPtr5)fProc))(ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 6 : +/*N*/ (*((ExFuncPtr6)fProc))(ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 7 : +/*N*/ (*((ExFuncPtr7)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 8 : +/*N*/ (*((ExFuncPtr8)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 9 : +/*N*/ (*((ExFuncPtr9)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 10 : +/*N*/ (*((ExFuncPtr10)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 11 : +/*N*/ (*((ExFuncPtr11)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9], ppParam[10]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 12: +/*N*/ (*((ExFuncPtr12)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9], ppParam[10], ppParam[11]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 13: +/*N*/ (*((ExFuncPtr13)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9], ppParam[10], ppParam[11], +/*N*/ ppParam[12]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 14 : +/*N*/ (*((ExFuncPtr14)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9], ppParam[10], ppParam[11], +/*N*/ ppParam[12], ppParam[13]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 15 : +/*N*/ (*((ExFuncPtr15)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9], ppParam[10], ppParam[11], +/*N*/ ppParam[12], ppParam[13], ppParam[14]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ case 16 : +/*N*/ (*((ExFuncPtr16)fProc))( ppParam[0], ppParam[1], ppParam[2], ppParam[3], ppParam[4], ppParam[5], +/*N*/ ppParam[6], ppParam[7], ppParam[8], ppParam[9], ppParam[10], ppParam[11], +/*N*/ ppParam[12], ppParam[13], ppParam[14], ppParam[15]); +/*N*/ bRet = TRUE; +/*N*/ break; +/*N*/ default : break; +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_cellform.cxx b/binfilter/bf_sc/source/core/tool/sc_cellform.cxx new file mode 100644 index 000000000000..4fe9a23d06f7 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_cellform.cxx @@ -0,0 +1,219 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_sfx2/objsh.hxx> +#include <bf_svtools/zforlist.hxx> + +#include "cellform.hxx" +#include "cell.hxx" +#include "document.hxx" +#include "bf_sc.hrc" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +// Err527 Workaround +const ScFormulaCell* pLastFormulaTreeTop = 0; + +// ----------------------------------------------------------------------- + +/*N*/ void ScCellFormat::GetString( ScBaseCell* pCell, ULONG nFormat, String& rString, +/*N*/ Color** ppColor, SvNumberFormatter& rFormatter, +/*N*/ BOOL bNullVals, +/*N*/ BOOL bFormula, +/*N*/ ScForceTextFmt eForceTextFmt ) +/*N*/ { +/*N*/ *ppColor = NULL; +/*N*/ if (&rFormatter==NULL) +/*N*/ { +/*N*/ rString.Erase(); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ switch(eType) +/*N*/ { +/*N*/ case CELLTYPE_STRING: +/*N*/ { +/*N*/ String aCellString; +/*N*/ ((ScStringCell*)pCell)->GetString( aCellString ); +/*N*/ rFormatter.GetOutputString( aCellString, nFormat, rString, ppColor ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ { +/*N*/ String aCellString; +/*N*/ ((ScEditCell*)pCell)->GetString( aCellString ); +/*N*/ rFormatter.GetOutputString( aCellString, nFormat, rString, ppColor ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ double nValue = ((ScValueCell*)pCell)->GetValue(); +/*N*/ if ( !bNullVals && nValue == 0.0 ) +/*N*/ rString.Erase(); +/*N*/ else +/*N*/ { +/*N*/ if( eForceTextFmt == ftCheck ) +/*N*/ { +/*N*/ if( nFormat && rFormatter.IsTextFormat( nFormat ) ) +/*N*/ eForceTextFmt = ftForce; +/*N*/ } +/*N*/ if( eForceTextFmt == ftForce ) +/*N*/ { +/*?*/ String aTemp; +/*?*/ rFormatter.GetOutputString( nValue, 0, aTemp, ppColor ); +/*?*/ rFormatter.GetOutputString( aTemp, nFormat, rString, ppColor ); +/*N*/ } +/*N*/ else +/*N*/ rFormatter.GetOutputString( nValue, nFormat, rString, ppColor ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ if ( bFormula ) +/*?*/ pFCell->GetFormula( rString ); +/*N*/ else +/*N*/ { +/*N*/ // #62160# Ein via Interpreter gestartetes Makro, das hart +/*N*/ // auf Formelzellen zugreift, bekommt einen CellText, auch +/*N*/ // wenn dadurch ein weiterer Interpreter gestartet wird, +/*N*/ // aber nicht wenn diese Zelle gerade interpretiert wird. +/*N*/ // IdleCalc startet generell keine weiteren Interpreter, +/*N*/ // um keine Err522 (zirkulaer) zu bekommen. +/*N*/ if ( pFCell->GetDocument()->IsInInterpreter() && +/*N*/ (!pFCell->GetDocument()->GetMacroInterpretLevel() +/*N*/ || pFCell->IsRunning()) ) +/*N*/ { +/*?*/ rString.AssignAscii( RTL_CONSTASCII_STRINGPARAM("...") ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nErrCode = pFCell->GetErrCode(); +/*N*/ if ( nErrCode == errInterpOverflow ) +/*N*/ { // maxrecursion ausbuegeln, Err527 Workaround +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScDocument* pDoc = pFCell->GetDocument(); +/*N*/ } +/*N*/ +/*N*/ // erst nach dem Interpretieren (GetErrCode) das Zahlformat holen: +/*N*/ if ( (nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 ) +/*N*/ nFormat = pFCell->GetStandardFormat( rFormatter, +/*N*/ nFormat ); +/*N*/ +/*N*/ if (nErrCode != 0) +/*N*/ rString = ScGlobal::GetErrorString(nErrCode); +/*N*/ else if ( pFCell->IsValue() ) +/*N*/ { +/*N*/ double fValue = pFCell->GetValue(); +/*N*/ if ( !bNullVals && fValue == 0.0 ) +/*?*/ rString.Erase(); +/*N*/ else +/*N*/ rFormatter.GetOutputString( fValue, nFormat, rString, ppColor ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ String aCellString; +/*N*/ pFCell->GetString( aCellString ); +/*N*/ rFormatter.GetOutputString( aCellString, nFormat, rString, ppColor ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ rString.Erase(); +/*N*/ break; +/*N*/ } +/*N*/ } + +/*N*/ void ScCellFormat::GetInputString( ScBaseCell* pCell, ULONG nFormat, String& rString, +/*N*/ SvNumberFormatter& rFormatter ) +/*N*/ { +/*N*/ if (&rFormatter==NULL) +/*N*/ { +/*N*/ rString.Erase(); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ switch(eType) +/*N*/ { +/*N*/ case CELLTYPE_STRING: +/*N*/ { +/*N*/ ((ScStringCell*)pCell)->GetString( rString ); +/*N*/ } +/*N*/ break; +/*?*/ case CELLTYPE_EDIT: +/*?*/ { +/*?*/ ((ScEditCell*)pCell)->GetString( rString ); +/*?*/ } +/*?*/ break; +/*?*/ case CELLTYPE_VALUE: +/*?*/ { +/*?*/ double nValue = ((ScValueCell*)pCell)->GetValue(); +/*?*/ rFormatter.GetInputLineString( nValue, nFormat, rString ); +/*?*/ } +/*?*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ if (((ScFormulaCell*)pCell)->IsValue()) +/*N*/ { +/*?*/ double nValue = ((ScFormulaCell*)pCell)->GetValue(); +/*?*/ rFormatter.GetInputLineString( nValue, nFormat, rString ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ((ScFormulaCell*)pCell)->GetString( rString ); +/*N*/ } +/*N*/ +/*N*/ USHORT nErrCode = ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ if (nErrCode != 0) +/*N*/ { +/*?*/ rString.Erase(); +/*N*/ } +/*N*/ } +/*N*/ break; +/*?*/ default: +/*?*/ rString.Erase(); +/*?*/ break; +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_chartarr.cxx b/binfilter/bf_sc/source/core/tool/sc_chartarr.cxx new file mode 100644 index 000000000000..26e6b2416c9d --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_chartarr.cxx @@ -0,0 +1,1203 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svtools/zforlist.hxx> +#include <bf_sch/schdll.hxx> +#include <bf_sch/memchrt.hxx> +#include <float.h> // DBL_MIN + +#include "chartarr.hxx" +#include "document.hxx" +#include "rechead.hxx" +#include "globstr.hrc" +#include "cell.hxx" +#include "docoptio.hxx" +namespace binfilter { + + +// ----------------------------------------------------------------------- + +// static +/*N*/ void ScChartArray::CopySettings( SchMemChart& rDest, const SchMemChart& rSource ) +/*N*/ { +/*N*/ rDest.SetMainTitle( rSource.GetMainTitle() ); +/*N*/ rDest.SetSubTitle( rSource.GetSubTitle() ); +/*N*/ rDest.SetXAxisTitle( rSource.GetXAxisTitle() ); +/*N*/ rDest.SetYAxisTitle( rSource.GetYAxisTitle() ); +/*N*/ rDest.SetZAxisTitle( rSource.GetZAxisTitle() ); +/*N*/ +/*N*/ const sal_Int32* pArr; +/*N*/ if ( rSource.GetRowCount() == rDest.GetRowCount() && +/*N*/ rSource.GetColCount() == rDest.GetColCount() ) +/*N*/ { +/*N*/ // don't copy column/row number formats here (are set in new MemChart object) +/*N*/ +/*N*/ if ( (pArr = rSource.GetRowTranslation()) ) rDest.SetRowTranslation( pArr ); +/*N*/ if ( (pArr = rSource.GetColTranslation()) ) rDest.SetColTranslation( pArr ); +/*N*/ rDest.SetTranslation( rSource.GetTranslation() ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScChartArray::ScChartArray( ScDocument* pDoc, const ScRangeListRef& rRangeList, +/*N*/ const String& rChartName ) : +/*N*/ aRangeListRef( rRangeList ), +/*N*/ aName( rChartName ), +/*N*/ pDocument( pDoc ), +/*N*/ pPositionMap( NULL ), +/*N*/ eGlue( SC_CHARTGLUE_NA ), +/*N*/ nStartCol(0), +/*N*/ nStartRow(0), +/*N*/ bColHeaders( FALSE ), +/*N*/ bRowHeaders( FALSE ), +/*N*/ bDummyUpperLeft( FALSE ), +/*N*/ bValid( TRUE ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( aRangeListRef.Is() ) +/*N*/ } +/*N*/ +/*N*/ ScChartArray::ScChartArray( const ScChartArray& rArr ) : +/*N*/ aRangeListRef( rArr.aRangeListRef ), +/*N*/ aName(rArr.aName), +/*N*/ pDocument(rArr.pDocument), +/*N*/ pPositionMap( NULL ), +/*N*/ eGlue(rArr.eGlue), +/*N*/ nStartCol(rArr.nStartCol), +/*N*/ nStartRow(rArr.nStartRow), +/*N*/ bColHeaders(rArr.bColHeaders), +/*N*/ bRowHeaders(rArr.bRowHeaders), +/*N*/ bDummyUpperLeft( rArr.bDummyUpperLeft ), +/*N*/ bValid(rArr.bValid) +/*N*/ { +/*N*/ } +/*N*/ +/*N*/ ScChartArray::ScChartArray( ScDocument* pDoc, SvStream& rStream, ScMultipleReadHeader& rHdr ) : +/*N*/ pDocument( pDoc ), +/*N*/ pPositionMap( NULL ), +/*N*/ eGlue( SC_CHARTGLUE_NONE ), +/*N*/ bDummyUpperLeft( FALSE ), +/*N*/ bValid( TRUE ) +/*N*/ { +/*N*/ USHORT nCol2, nRow2, nTable; +/*N*/ +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream >> nTable; +/*N*/ rStream >> nStartCol; +/*N*/ rStream >> nStartRow; +/*N*/ rStream >> nCol2; +/*N*/ rStream >> nRow2; +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream >> bColHeaders; +/*N*/ rStream >> bRowHeaders; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ SetRangeList( ScRange( nStartCol, nStartRow, nTable, nCol2, nRow2, nTable ) ); +/*N*/ } + +/*N*/ ScChartArray::ScChartArray( ScDocument* pDoc, const SchMemChart& rData ) : +/*N*/ pDocument( pDoc ), +/*N*/ pPositionMap( NULL ) +/*N*/ { +/*N*/ BOOL bInitOk = bValid = FALSE; +/*N*/ const SchChartRange& rChartRange = rData.GetChartRange(); +/*N*/ ::std::vector< SchCellRangeAddress >::const_iterator iRange = +/*N*/ rChartRange.maRanges.begin(); +/*N*/ if ( iRange != rChartRange.maRanges.end() ) +/*N*/ { // new SO6 chart format +/*N*/ bValid = TRUE; +/*N*/ bColHeaders = rChartRange.mbFirstRowContainsLabels; +/*N*/ bRowHeaders = rChartRange.mbFirstColumnContainsLabels; +/*N*/ aRangeListRef = new ScRangeList; +/*N*/ for ( ; iRange != rChartRange.maRanges.end(); ++iRange ) +/*N*/ { +/*N*/ const SchSingleCell& rAddr1 = (*iRange).maUpperLeft.maCells[0]; +/*N*/ const SchSingleCell& rAddr2 = (*iRange).maLowerRight.maCells[0]; +/*N*/ USHORT nTab = (USHORT) (*iRange).mnTableNumber; +/*N*/ ScRange aRange( +/*N*/ (USHORT) rAddr1.mnColumn, (USHORT) rAddr1.mnRow, nTab, +/*N*/ (USHORT) rAddr2.mnColumn, (USHORT) rAddr2.mnRow, nTab ); +/*N*/ aRangeListRef->Append( aRange ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // old SO5 chart format +/*N*/ //! A similar routine is implemented in +/*N*/ //! SchMemChart::ConvertChartRangeForCalc() for OldToNew. If anything +/*N*/ //! is changed here it propably must be changed there too! +/*N*/ const sal_Unicode cTok = ';'; +/*N*/ xub_StrLen nToken; +/*N*/ String aPos = ((SchMemChart&)rData).SomeData1(); +/*N*/ if ( (nToken = aPos.GetTokenCount( cTok )) >= 5) +/*N*/ { +/*N*/ String aOpt = ((SchMemChart&)rData).SomeData2(); +/*N*/ xub_StrLen nOptToken = aOpt.GetTokenCount( cTok ); +/*N*/ BOOL bNewChart = (nOptToken >= 4); // as of 341/342 +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ xub_StrLen nInd = 0; +/*N*/ for ( xub_StrLen j=0; j < nToken; j+=5 ) +/*N*/ { +/*N*/ xub_StrLen nInd2 = nInd; +/*N*/ nTab1 = (USHORT) aPos.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ // To make old versions (<341/342) skip it, the token separator +/*N*/ // is a ',' +/*N*/ if ( bNewChart ) +/*?*/ nTab2 = (USHORT) aPos.GetToken( 1, ',', nInd2 ).ToInt32(); +/*N*/ else +/*N*/ nTab2 = nTab1; +/*N*/ nCol1 = (USHORT) aPos.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ nRow1 = (USHORT) aPos.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ nCol2 = (USHORT) aPos.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ nRow2 = (USHORT) aPos.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ AddToRangeList( ScRange( nCol1, nRow1, nTab1, +/*N*/ nCol2, nRow2, nTab2 ) ); +/*N*/ } +/*N*/ bValid = TRUE; +/*N*/ +/*N*/ if (aOpt.Len() >= 2) +/*N*/ { +/*N*/ bColHeaders = ( aOpt.GetChar(0) != '0' ); +/*N*/ bRowHeaders = ( aOpt.GetChar(1) != '0' ); +/*N*/ if ( aOpt.Len() >= 3 ) +/*N*/ { +/*N*/ if ( bNewChart ) +/*N*/ { +/*N*/ bDummyUpperLeft = ( aOpt.GetChar(2) != '0' ); +/*N*/ xub_StrLen nInd = 4; // 111; +/*N*/ eGlue = (ScChartGlue) aOpt.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ nStartCol = (USHORT) aOpt.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ nStartRow = (USHORT) aOpt.GetToken( 0, cTok, nInd ).ToInt32(); +/*N*/ bInitOk = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bColHeaders = bRowHeaders = FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ SetRangeList( ScRange() ); +/*?*/ bColHeaders = bRowHeaders = bValid = FALSE; +/*N*/ } +/*N*/ } +/*N*/ if ( !bInitOk ) +/*N*/ { // muessen in GlueState neu berechnet werden +/*N*/ InvalidateGlue(); +/*N*/ nStartCol = nStartRow = 0; +/*N*/ bDummyUpperLeft = FALSE; +/*N*/ } +/*N*/ } + +/*N*/ ScChartArray::~ScChartArray() +/*N*/ { +/*N*/ delete pPositionMap; +/*N*/ } + + + + +/*N*/ void ScChartArray::SetRangeList( const ScRange& rRange ) +/*N*/ { +/*N*/ aRangeListRef = new ScRangeList; +/*N*/ aRangeListRef->Append( rRange ); +/*N*/ InvalidateGlue(); +/*N*/ } + +/*N*/ void ScChartArray::AddToRangeList( const ScRange& rRange ) +/*N*/ { +/*N*/ if ( aRangeListRef.Is() ) +/*N*/ aRangeListRef->Append( rRange ); +/*N*/ else +/*N*/ SetRangeList( rRange ); +/*N*/ InvalidateGlue(); +/*N*/ } + +/*N*/ void ScChartArray::AddToRangeList( const ScRangeListRef& rAdd ) +/*N*/ { +/*N*/ if ( aRangeListRef.Is() ) +/*N*/ { +/*N*/ ULONG nCount = rAdd->Count(); +/*N*/ for (ULONG i=0; i<nCount; i++) +/*N*/ aRangeListRef->Join( *rAdd->GetObject(i) ); +/*N*/ } +/*N*/ else +/*N*/ SetRangeList( rAdd ); +/*N*/ InvalidateGlue(); +/*N*/ } + +/*N*/ void ScChartArray::GlueState() +/*N*/ { +/*N*/ if ( eGlue != SC_CHARTGLUE_NA ) +/*N*/ return; +/*N*/ bDummyUpperLeft = FALSE; +/*N*/ ScRangePtr pR; +/*N*/ if ( aRangeListRef->Count() <= 1 ) +/*N*/ { +/*?*/ if ( pR = aRangeListRef->First() ) +/*?*/ { +/*?*/ if ( pR->aStart.Tab() == pR->aEnd.Tab() ) +/*?*/ eGlue = SC_CHARTGLUE_NONE; +/*?*/ else +/*?*/ eGlue = SC_CHARTGLUE_COLS; // mehrere Tabellen spaltenweise +/*?*/ nStartCol = pR->aStart.Col(); +/*?*/ nStartRow = pR->aStart.Row(); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ InvalidateGlue(); +/*?*/ nStartCol = nStartRow = 0; +/*?*/ } +/*?*/ return; +/*N*/ } +/*N*/ ULONG nOldPos = aRangeListRef->GetCurPos(); +/*N*/ +/*N*/ pR = aRangeListRef->First(); +/*N*/ nStartCol = pR->aStart.Col(); +/*N*/ nStartRow = pR->aStart.Row(); +/*N*/ USHORT nMaxCols, nMaxRows, nEndCol, nEndRow; +/*N*/ nMaxCols = nMaxRows = nEndCol = nEndRow = 0; +/*N*/ do +/*N*/ { // umspannenden Bereich etc. feststellen +/*N*/ USHORT nTmp, n1, n2; +/*N*/ if ( (n1 = pR->aStart.Col()) < nStartCol ) +/*N*/ nStartCol = n1; +/*N*/ if ( (n2 = pR->aEnd.Col()) > nEndCol ) +/*N*/ nEndCol = n2; +/*N*/ if ( (nTmp = n2 - n1 + 1) > nMaxCols ) +/*N*/ nMaxCols = nTmp; +/*N*/ if ( (n1 = pR->aStart.Row()) < nStartRow ) +/*N*/ nStartRow = n1; +/*N*/ if ( (n2 = pR->aEnd.Row()) > nEndRow ) +/*N*/ nEndRow = n2; +/*N*/ if ( (nTmp = n2 - n1 + 1) > nMaxRows ) +/*N*/ nMaxRows = nTmp; +/*N*/ } while ( pR = aRangeListRef->Next() ); +/*N*/ USHORT nC = nEndCol - nStartCol + 1; +/*N*/ if ( nC == 1 ) +/*N*/ { +/*N*/ eGlue = SC_CHARTGLUE_ROWS; +/*N*/ return; +/*N*/ } +/*N*/ USHORT nR = nEndRow - nStartRow + 1; +/*N*/ if ( nR == 1 ) +/*N*/ { +/*N*/ eGlue = SC_CHARTGLUE_COLS; +/*N*/ return; +/*N*/ } +/*N*/ ULONG nCR = (ULONG)nC * nR; +/*N*/ //2do: +/* + Erstmal simpel ohne Bitmaskiererei, maximal koennten so 8MB alloziert + werden (256 Cols mal 32000 Rows), das liesse sich mit 2 Bit je Eintrag + auf 2MB reduzieren, andererseits ist es so schneller. + Weitere Platz-Optimierung waere, in dem Array nur die wirklich benutzten + Zeilen/Spalten abzulegen, wuerde aber ein weiteres durchlaufen der + RangeList und indirekten Zugriff auf das Array bedeuten. + */ +/*N*/ const BYTE nHole = 0; +/*N*/ const BYTE nOccu = 1; +/*N*/ const BYTE nFree = 2; +/*N*/ const BYTE nGlue = 3; +/*N*/ #ifdef WIN +/*?*/ // we hate 16bit, don't we? +/*?*/ BYTE huge* p; +/*?*/ BYTE huge* pA = (BYTE huge*) SvMemAlloc( nCR ); +/*?*/ if ( nCR > (ULONG)((USHORT)~0) ) +/*?*/ { // in 32k Bloecken initialisieren +/*?*/ ULONG j; +/*?*/ for ( j=0; j<nCR; j+=0x8000 ) +/*?*/ { +/*?*/ memset( pA+j, nHole, Min( (ULONG)0x8000, nCR-j ) ); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ memset( pA, nHole, nCR * sizeof(BYTE) ); +/*N*/ #else +/*N*/ BYTE* p; +/*N*/ BYTE* pA = new BYTE[ nCR ]; +/*N*/ memset( pA, 0, nCR * sizeof(BYTE) ); +/*N*/ #endif +/*N*/ +/*N*/ USHORT nCol, nRow, nCol1, nRow1, nCol2, nRow2; +/*N*/ for ( pR = aRangeListRef->First(); pR; pR = aRangeListRef->Next() ) +/*N*/ { // Selektionen 2D als belegt markieren +/*N*/ nCol1 = pR->aStart.Col() - nStartCol; +/*N*/ nCol2 = pR->aEnd.Col() - nStartCol; +/*N*/ nRow1 = pR->aStart.Row() - nStartRow; +/*N*/ nRow2 = pR->aEnd.Row() - nStartRow; +/*N*/ for ( nCol = nCol1; nCol <= nCol2; nCol++ ) +/*N*/ { +/*N*/ p = pA + (ULONG)nCol * nR + nRow1; +/*N*/ for ( nRow = nRow1; nRow <= nRow2; nRow++, p++ ) +/*N*/ *p = nOccu; +/*N*/ } +/*N*/ } +/*N*/ BOOL bGlue = TRUE; +/*N*/ +/*N*/ BOOL bGlueCols = FALSE; +/*N*/ for ( nCol = 0; bGlue && nCol < nC; nCol++ ) +/*N*/ { // Spalten probieren durchzugehen und als frei markieren +/*N*/ p = pA + (ULONG)nCol * nR; +/*N*/ for ( nRow = 0; bGlue && nRow < nR; nRow++, p++ ) +/*N*/ { +/*N*/ if ( *p == nOccu ) +/*N*/ { // Wenn einer mittendrin liegt ist keine Zusammenfassung +/*N*/ // moeglich. Am Rand koennte ok sein, wenn in dieser Spalte +/*N*/ // in jeder belegten Zeile einer belegt ist. +/*N*/ if ( nRow > 0 && nCol > 0 ) +/*N*/ bGlue = FALSE; // nCol==0 kann DummyUpperLeft sein +/*N*/ else +/*N*/ nRow = nR; +/*N*/ } +/*N*/ else +/*N*/ *p = nFree; +/*N*/ } +/*N*/ if ( bGlue && *(p = (pA + ((((ULONG)nCol+1) * nR) - 1))) == nFree ) +/*N*/ { // Spalte als komplett frei markieren +/*N*/ *p = nGlue; +/*N*/ bGlueCols = TRUE; // mindestens eine freie Spalte +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ BOOL bGlueRows = FALSE; +/*N*/ for ( nRow = 0; bGlue && nRow < nR; nRow++ ) +/*N*/ { // Zeilen probieren durchzugehen und als frei markieren +/*N*/ p = pA + nRow; +/*N*/ for ( nCol = 0; bGlue && nCol < nC; nCol++, p+=nR ) +/*N*/ { +/*N*/ if ( *p == nOccu ) +/*N*/ { +/*N*/ if ( nCol > 0 && nRow > 0 ) +/*N*/ bGlue = FALSE; // nRow==0 kann DummyUpperLeft sein +/*N*/ else +/*N*/ nCol = nC; +/*N*/ } +/*N*/ else +/*N*/ *p = nFree; +/*N*/ } +/*N*/ if ( bGlue && *(p = (pA + ((((ULONG)nC-1) * nR) + nRow))) == nFree ) +/*N*/ { // Zeile als komplett frei markieren +/*N*/ *p = nGlue; +/*N*/ bGlueRows = TRUE; // mindestens eine freie Zeile +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // n=1: die linke obere Ecke koennte bei Beschriftung automagisch +/*N*/ // hinzugezogen werden +/*N*/ p = pA + 1; +/*N*/ for ( ULONG n = 1; bGlue && n < nCR; n++, p++ ) +/*N*/ { // ein unberuehrtes Feld heisst, dass es weder spaltenweise noch +/*N*/ // zeilenweise zu erreichen war, also nichts zusamenzufassen +/*N*/ if ( *p == nHole ) +/*N*/ bGlue = FALSE; +/*N*/ } +/*N*/ if ( bGlue ) +/*N*/ { +/*N*/ if ( bGlueCols && bGlueRows ) +/*N*/ eGlue = SC_CHARTGLUE_BOTH; +/*N*/ else if ( bGlueRows ) +/*N*/ eGlue = SC_CHARTGLUE_ROWS; +/*N*/ else +/*N*/ eGlue = SC_CHARTGLUE_COLS; +/*N*/ if ( *pA != nOccu ) +/*N*/ bDummyUpperLeft = TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ eGlue = SC_CHARTGLUE_NONE; +/*N*/ } +/*N*/ +/*N*/ #ifdef WIN +/*?*/ SvMemFree( pA ); +/*N*/ #else +/*N*/ delete [] pA; +/*N*/ #endif +/*N*/ } + + +#ifdef _MSC_VER +#pragma optimize("",off) +#endif + +/*N*/ SchMemChart* ScChartArray::CreateMemChart() +/*N*/ { +/*N*/ ULONG nCount = aRangeListRef->Count(); +/*N*/ if ( nCount > 1 ) +/*N*/ return CreateMemChartMulti(); +/*N*/ else if ( nCount == 1 ) +/*N*/ { +/*N*/ ScRange* pR = aRangeListRef->First(); +/*N*/ if ( pR->aStart.Tab() != pR->aEnd.Tab() ) +/*?*/ return CreateMemChartMulti(); +/*N*/ else +/*N*/ return CreateMemChartSingle(); +/*N*/ } +/*N*/ else +/*?*/ return CreateMemChartMulti(); // kann 0 Range besser ab als Single +/*N*/ } + +/*N*/ SchMemChart* ScChartArray::CreateMemChartSingle() +/*N*/ { +/*N*/ USHORT i,nCol,nRow; +/*N*/ +/*N*/ // +/*N*/ // wirkliche Groesse (ohne versteckte Zeilen/Spalten) +/*N*/ // +/*N*/ +/*N*/ USHORT nColAdd = bRowHeaders ? 1 : 0; +/*N*/ USHORT nRowAdd = bColHeaders ? 1 : 0; +/*N*/ +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ aRangeListRef->First()->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ +/*N*/ USHORT nStrCol = nCol1; // fuer Beschriftung merken +/*N*/ USHORT nStrRow = nRow1; +/*N*/ // Beschriftungen auch nach HiddenCols finden +/*N*/ while ( (pDocument->GetColFlags( nCol1, nTab1) & CR_HIDDEN) != 0 ) +/*N*/ nCol1++; +/*N*/ while ( (pDocument->GetRowFlags( nRow1, nTab1) & CR_HIDDEN) != 0 ) +/*N*/ nRow1++; +/*N*/ // falls alles hidden ist, bleibt die Beschriftung am Anfang +/*N*/ if ( nCol1 <= nCol2 ) +/*N*/ { +/*N*/ nStrCol = nCol1; +/*N*/ nCol1 += nColAdd; +/*N*/ } +/*N*/ if ( nRow1 <= nRow2 ) +/*N*/ { +/*N*/ nStrRow = nRow1; +/*N*/ nRow1 += nRowAdd; +/*N*/ } +/*N*/ +/*N*/ USHORT nTotalCols = ( nCol1 <= nCol2 ? nCol2 - nCol1 + 1 : 0 ); +/*N*/ USHORT* pCols = new USHORT[nTotalCols ? nTotalCols : 1]; +/*N*/ USHORT nColCount = 0; +/*N*/ for (i=0; i<nTotalCols; i++) +/*N*/ if ((pDocument->GetColFlags(nCol1+i,nTab1)&CR_HIDDEN)==0) +/*N*/ pCols[nColCount++] = nCol1+i; +/*N*/ +/*N*/ USHORT nTotalRows = ( nRow1 <= nRow2 ? nRow2 - nRow1 + 1 : 0 ); +/*N*/ USHORT* pRows = new USHORT[nTotalRows ? nTotalRows : 1]; +/*N*/ USHORT nRowCount = 0; +/*N*/ for (i=0; i<nTotalRows; i++) +/*N*/ if ((pDocument->GetRowFlags(nRow1+i,nTab1)&CR_HIDDEN)==0) +/*N*/ pRows[nRowCount++] = nRow1+i; +/*N*/ +/*N*/ BOOL bValidData = TRUE; +/*N*/ if ( !nColCount ) +/*N*/ { +/*N*/ bValidData = FALSE; +/*N*/ nColCount = 1; +/*N*/ pCols[0] = nStrCol; +/*N*/ } +/*N*/ if ( !nRowCount ) +/*N*/ { +/*N*/ bValidData = FALSE; +/*N*/ nRowCount = 1; +/*N*/ pRows[0] = nStrRow; +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Daten +/*N*/ // +/*N*/ +/*N*/ SchMemChart* pMemChart = SchDLL::NewMemChart( nColCount, nRowCount ); +/*N*/ if (pMemChart) +/*N*/ { +/*N*/ SvNumberFormatter* pFormatter = pDocument->GetFormatTable(); +/*N*/ pMemChart->SetNumberFormatter( pFormatter ); +/*N*/ if ( bValidData ) +/*N*/ { +/*N*/ BOOL bCalcAsShown = pDocument->GetDocOptions().IsCalcAsShown(); +/*N*/ ScBaseCell* pCell; +/*N*/ for (nCol=0; nCol<nColCount; nCol++) +/*N*/ { +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ double nVal = DBL_MIN; // Hack fuer Chart, um leere Zellen zu erkennen +/*N*/ +/*N*/ pDocument->GetCell( pCols[nCol], pRows[nRow], nTab1, pCell ); +/*N*/ if (pCell) +/*N*/ { +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ if (eType == CELLTYPE_VALUE) +/*N*/ { +/*?*/ nVal = ((ScValueCell*)pCell)->GetValue(); +/*?*/ if ( bCalcAsShown && nVal != 0.0 ) +/*?*/ { +/*?*/ sal_uInt32 nFormat; +/*?*/ pDocument->GetNumberFormat( pCols[nCol], +/*?*/ pRows[nRow], nTab1, nFormat ); +/*?*/ nVal = pDocument->RoundValueAsShown( nVal, nFormat ); +/*?*/ } +/*N*/ } +/*N*/ else if (eType == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ if ( (pFCell->GetErrCode() == 0) && pFCell->IsValue() ) +/*N*/ nVal = pFCell->GetValue(); +/*N*/ } +/*N*/ } +/*N*/ pMemChart->SetData(nCol, nRow, nVal); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ //! Flag, dass Daten ungueltig ?? +/*?*/ +/*?*/ for (nCol=0; nCol<nColCount; nCol++) +/*?*/ for (nRow=0; nRow<nRowCount; nRow++) +/*?*/ pMemChart->SetData( nCol, nRow, DBL_MIN ); +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Spalten-Header +/*N*/ // +/*N*/ +/*N*/ for (nCol=0; nCol<nColCount; nCol++) +/*N*/ { +/*N*/ String aString, aColStr; +/*N*/ if (bColHeaders) +/*N*/ pDocument->GetString( pCols[nCol], nStrRow, nTab1, aString ); +/*N*/ if ( !aString.Len() ) +/*N*/ { +/*N*/ aString = ScGlobal::GetRscString(STR_COLUMN); +/*N*/ aString += ' '; +/*N*/ // aString += String::CreateFromInt32( pCols[nCol]+1 ); +/*N*/ ScAddress aPos( pCols[ nCol ], 0, 0 ); +/*N*/ aPos.Format( aColStr, SCA_VALID_COL, NULL ); +/*N*/ aString += aColStr; +/*N*/ } +/*N*/ pMemChart->SetColText(nCol, aString); +/*N*/ +/*N*/ ULONG nNumberAttr = pDocument->GetNumberFormat( ScAddress( +/*N*/ pCols[nCol], nRow1, nTab1 ) ); +/*N*/ pMemChart->SetNumFormatIdCol( nCol, nNumberAttr ); +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Zeilen-Header +/*N*/ // +/*N*/ +/*N*/ for (nRow=0; nRow<nRowCount; nRow++) +/*N*/ { +/*N*/ String aString; +/*N*/ if (bRowHeaders) +/*N*/ { +/*N*/ ScAddress aAddr( nStrCol, pRows[nRow], nTab1 ); +/*N*/ pDocument->GetString( nStrCol, pRows[nRow], nTab1, aString ); +/*N*/ } +/*N*/ if ( !aString.Len() ) +/*N*/ { +/*N*/ aString = ScGlobal::GetRscString(STR_ROW); +/*N*/ aString += ' '; +/*N*/ aString += String::CreateFromInt32( pRows[nRow]+1 ); +/*N*/ } +/*N*/ pMemChart->SetRowText(nRow, aString); +/*N*/ +/*N*/ ULONG nNumberAttr = pDocument->GetNumberFormat( ScAddress( +/*N*/ nCol1, pRows[nRow], nTab1 ) ); +/*N*/ pMemChart->SetNumFormatIdRow( nRow, nNumberAttr ); +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Titel +/*N*/ // +/*N*/ +/*N*/ pMemChart->SetMainTitle(ScGlobal::GetRscString(STR_CHART_MAINTITLE)); +/*N*/ pMemChart->SetSubTitle(ScGlobal::GetRscString(STR_CHART_SUBTITLE)); +/*N*/ pMemChart->SetXAxisTitle(ScGlobal::GetRscString(STR_CHART_XTITLE)); +/*N*/ pMemChart->SetYAxisTitle(ScGlobal::GetRscString(STR_CHART_YTITLE)); +/*N*/ pMemChart->SetZAxisTitle(ScGlobal::GetRscString(STR_CHART_ZTITLE)); +/*N*/ +/*N*/ // +/*N*/ // Zahlen-Typ +/*N*/ // +/*N*/ +/*N*/ ULONG nNumberAttr = pDocument->GetNumberFormat( ScAddress( +/*N*/ nCol1, nRow1, nTab1 ) ); +/*N*/ if (pFormatter) +/*N*/ pMemChart->SetDataType(pFormatter->GetType( nNumberAttr )); +/*N*/ +/*N*/ // +/*N*/ // Parameter-Strings +/*N*/ // +/*N*/ +/*N*/ SetExtraStrings( *pMemChart ); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("SchDLL::NewMemChart gibt 0 zurueck!"); +/*N*/ +/*N*/ // Aufraeumen +/*N*/ +/*N*/ delete[] pRows; +/*N*/ delete[] pCols; +/*N*/ +/*N*/ return pMemChart; +/*N*/ } + +/*N*/ SchMemChart* ScChartArray::CreateMemChartMulti() +/*N*/ { +/*N*/ CreatePositionMap(); +/*N*/ USHORT nColCount = pPositionMap->GetColCount(); +/*N*/ USHORT nRowCount = pPositionMap->GetRowCount(); +/*N*/ +/*N*/ USHORT nCol, nRow; +/*N*/ +/*N*/ // +/*N*/ // Daten +/*N*/ // +/*N*/ +/*N*/ SchMemChart* pMemChart = SchDLL::NewMemChart( nColCount, nRowCount ); +/*N*/ if (pMemChart) +/*N*/ { +/*N*/ pMemChart->SetNumberFormatter( pDocument->GetFormatTable() ); +/*N*/ BOOL bCalcAsShown = pDocument->GetDocOptions().IsCalcAsShown(); +/*N*/ ULONG nIndex = 0; +/*N*/ for ( nCol = 0; nCol < nColCount; nCol++ ) +/*N*/ { +/*N*/ for ( nRow = 0; nRow < nRowCount; nRow++, nIndex++ ) +/*N*/ { +/*N*/ double nVal = DBL_MIN; // Hack fuer Chart, um leere Zellen zu erkennen +/*N*/ const ScAddress* pPos = pPositionMap->GetPosition( nIndex ); +/*N*/ if ( pPos ) +/*N*/ { // sonst: Luecke +/*N*/ ScBaseCell* pCell = pDocument->GetCell( *pPos ); +/*N*/ if (pCell) +/*N*/ { +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ if (eType == CELLTYPE_VALUE) +/*N*/ { +/*?*/ nVal = ((ScValueCell*)pCell)->GetValue(); +/*?*/ if ( bCalcAsShown && nVal != 0.0 ) +/*?*/ { +/*?*/ ULONG nFormat = pDocument->GetNumberFormat( *pPos ); +/*?*/ nVal = pDocument->RoundValueAsShown( nVal, nFormat ); +/*?*/ } +/*N*/ } +/*N*/ else if (eType == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ if ( (pFCell->GetErrCode() == 0) && pFCell->IsValue() ) +/*N*/ nVal = pFCell->GetValue(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ pMemChart->SetData(nCol, nRow, nVal); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ //2do: Beschriftung bei Luecken +/*N*/ +/*N*/ // +/*N*/ // Spalten-Header +/*N*/ // +/*N*/ +/*N*/ USHORT nPosCol = 0; +/*N*/ for ( nCol = 0; nCol < nColCount; nCol++ ) +/*N*/ { +/*N*/ String aString, aColStr; +/*N*/ const ScAddress* pPos = pPositionMap->GetColHeaderPosition( nCol ); +/*N*/ if ( bColHeaders && pPos ) +/*N*/ pDocument->GetString( +/*N*/ pPos->Col(), pPos->Row(), pPos->Tab(), aString ); +/*N*/ if ( !aString.Len() ) +/*N*/ { +/*?*/ aString = ScGlobal::GetRscString(STR_COLUMN); +/*?*/ aString += ' '; +/*?*/ if ( pPos ) +/*?*/ nPosCol = pPos->Col() + 1; +/*?*/ else +/*?*/ nPosCol++; +/*?*/ ScAddress aPos( nPosCol - 1, 0, 0 ); +/*?*/ aPos.Format( aColStr, SCA_VALID_COL, NULL ); +/*?*/ // aString += String::CreateFromInt32( nPosCol ); +/*?*/ aString += aColStr; +/*N*/ } +/*N*/ pMemChart->SetColText(nCol, aString); +/*N*/ +/*N*/ ULONG nNumberAttr = 0; +/*N*/ pPos = pPositionMap->GetPosition( nCol, 0 ); +/*N*/ if ( pPos ) +/*N*/ nNumberAttr = pDocument->GetNumberFormat( *pPos ); +/*N*/ pMemChart->SetNumFormatIdCol( nCol, nNumberAttr ); +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Zeilen-Header +/*N*/ // +/*N*/ +/*N*/ USHORT nPosRow = 0; +/*N*/ for ( nRow = 0; nRow < nRowCount; nRow++ ) +/*N*/ { +/*N*/ String aString; +/*N*/ const ScAddress* pPos = pPositionMap->GetRowHeaderPosition( nRow ); +/*N*/ if ( bRowHeaders && pPos ) +/*N*/ { +/*N*/ pDocument->GetString( +/*N*/ pPos->Col(), pPos->Row(), pPos->Tab(), aString ); +/*N*/ } +/*N*/ if ( !aString.Len() ) +/*N*/ { +/*?*/ aString = ScGlobal::GetRscString(STR_ROW); +/*?*/ aString += ' '; +/*?*/ if ( pPos ) +/*?*/ nPosRow = pPos->Row() + 1; +/*?*/ else +/*?*/ nPosRow++; +/*?*/ aString += String::CreateFromInt32( nPosRow ); +/*N*/ } +/*N*/ pMemChart->SetRowText(nRow, aString); +/*N*/ +/*N*/ ULONG nNumberAttr = 0; +/*N*/ pPos = pPositionMap->GetPosition( 0, nRow ); +/*N*/ if ( pPos ) +/*N*/ nNumberAttr = pDocument->GetNumberFormat( *pPos ); +/*N*/ pMemChart->SetNumFormatIdRow( nRow, nNumberAttr ); +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Titel +/*N*/ // +/*N*/ +/*N*/ pMemChart->SetMainTitle(ScGlobal::GetRscString(STR_CHART_MAINTITLE)); +/*N*/ pMemChart->SetSubTitle(ScGlobal::GetRscString(STR_CHART_SUBTITLE)); +/*N*/ pMemChart->SetXAxisTitle(ScGlobal::GetRscString(STR_CHART_XTITLE)); +/*N*/ pMemChart->SetYAxisTitle(ScGlobal::GetRscString(STR_CHART_YTITLE)); +/*N*/ pMemChart->SetZAxisTitle(ScGlobal::GetRscString(STR_CHART_ZTITLE)); +/*N*/ +/*N*/ // +/*N*/ // Zahlen-Typ +/*N*/ // +/*N*/ +/*N*/ SvNumberFormatter* pFormatter = pDocument->GetFormatTable(); +/*N*/ if (pFormatter) +/*N*/ { +/*N*/ ULONG nIndex = 0; +/*N*/ ULONG nCount = pPositionMap->GetCount(); +/*N*/ const ScAddress* pPos; +/*N*/ do +/*N*/ { +/*N*/ pPos = pPositionMap->GetPosition( nIndex ); +/*N*/ } while ( !pPos && ++nIndex < nCount ); +/*N*/ ULONG nFormat = ( pPos ? pDocument->GetNumberFormat( *pPos ) : 0 ); +/*N*/ pMemChart->SetDataType( pFormatter->GetType( nFormat ) ); +/*N*/ } +/*N*/ +/*N*/ // +/*N*/ // Parameter-Strings +/*N*/ // +/*N*/ +/*N*/ SetExtraStrings( *pMemChart ); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR("SchDLL::NewMemChart gibt 0 zurueck!"); +/*N*/ +/*N*/ return pMemChart; +/*N*/ } + +/*N*/ void ScChartArray::SetExtraStrings( SchMemChart& rMem ) +/*N*/ { +/*N*/ ScRangePtr pR; +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ #if 0 +/* now this is done in SchMemChart::ConvertChartRangeForCalc() for SO5 file format + const sal_Unicode cTok = ';'; + String aRef; + for ( pR = aRangeListRef->First(); pR; pR = aRangeListRef->Next() ) + { + pR->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); + if ( aRef.Len() ) + aRef += cTok; + aRef += String::CreateFromInt32( nTab1 ); + // hier ',' als TokenSep damit alte Versionen (<341/342) das ueberlesen + aRef += ','; aRef += String::CreateFromInt32( nTab2 ); + aRef += cTok; aRef += String::CreateFromInt32( nCol1 ); + aRef += cTok; aRef += String::CreateFromInt32( nRow1 ); + aRef += cTok; aRef += String::CreateFromInt32( nCol2 ); + aRef += cTok; aRef += String::CreateFromInt32( nRow2 ); + } + + String aFlags = bColHeaders ? '1' : '0'; + aFlags += bRowHeaders ? '1' : '0'; + aFlags += bDummyUpperLeft ? '1' : '0'; + aFlags += cTok; + aFlags += String::CreateFromInt32( eGlue ); + aFlags += cTok; + aFlags += String::CreateFromInt32( nStartCol ); + aFlags += cTok; + aFlags += String::CreateFromInt32( nStartRow ); + + rMem.SomeData1() = aRef; + rMem.SomeData2() = aFlags; +*/ +/*N*/ #endif +/*N*/ +/*N*/ String aSheetNames; +/*N*/ SchChartRange aChartRange; +/*N*/ aChartRange.mbFirstColumnContainsLabels = bRowHeaders; +/*N*/ aChartRange.mbFirstRowContainsLabels = bColHeaders; +/*N*/ aChartRange.mbKeepCopyOfData = sal_False; +/*N*/ for ( pR = aRangeListRef->First(); pR; pR = aRangeListRef->Next() ) +/*N*/ { +/*N*/ pR->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ for ( USHORT nTab = nTab1; nTab <= nTab2; ++nTab ) +/*N*/ { +/*N*/ SchCellRangeAddress aCellRangeAddress; +/*N*/ SchSingleCell aCell; +/*N*/ aCell.mnColumn = nCol1; +/*N*/ aCell.mnRow = nRow1; +/*N*/ aCellRangeAddress.maUpperLeft.maCells.push_back( aCell ); +/*N*/ aCell.mnColumn = nCol2; +/*N*/ aCell.mnRow = nRow2; +/*N*/ aCellRangeAddress.maLowerRight.maCells.push_back( aCell ); +/*N*/ aCellRangeAddress.mnTableNumber = nTab; +/*N*/ String aName; +/*N*/ pDocument->GetName( nTab, aName ); +/*N*/ aCellRangeAddress.msTableName = aName; +/*N*/ aChartRange.maRanges.push_back( aCellRangeAddress ); +/*N*/ if ( aSheetNames.Len() ) +/*N*/ aSheetNames += ';'; +/*N*/ aSheetNames += aName; +/*N*/ } +/*N*/ } +/*N*/ rMem.SetChartRange( aChartRange ); +/*N*/ +/*N*/ // #90896# need that for OLE and clipboard of old binary file format +/*N*/ rMem.SomeData3() = aSheetNames; +/*N*/ +/*N*/ rMem.SetReadOnly( TRUE ); // Daten nicht im Chart per Daten-Fenster veraendern +/*N*/ } +/*N*/ +/*N*/ #ifdef _MSC_VER +/*N*/ #pragma optimize("",on) +/*N*/ #endif + + +/*N*/ const ScChartPositionMap* ScChartArray::GetPositionMap() +/*N*/ { +/*N*/ if ( !pPositionMap ) +/*N*/ CreatePositionMap(); +/*N*/ return pPositionMap; +/*N*/ } + + +/*N*/ void ScChartArray::CreatePositionMap() +/*N*/ { +/*N*/ if ( eGlue == SC_CHARTGLUE_NA && pPositionMap ) +/*N*/ { +/*?*/ delete pPositionMap; +/*?*/ pPositionMap = NULL; +/*N*/ } +/*N*/ +/*N*/ if ( pPositionMap ) +/*N*/ return ; +/*N*/ +/*N*/ USHORT nColAdd = bRowHeaders ? 1 : 0; +/*N*/ USHORT nRowAdd = bColHeaders ? 1 : 0; +/*N*/ +/*N*/ USHORT nCol, nRow, nTab, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ +/*N*/ // +/*N*/ // wirkliche Groesse (ohne versteckte Zeilen/Spalten) +/*N*/ // +/*N*/ +/*N*/ USHORT nColCount, nRowCount; +/*N*/ nColCount = nRowCount = 0; +/*N*/ +/*N*/ GlueState(); +/*N*/ +/*N*/ BOOL bNoGlue = (eGlue == SC_CHARTGLUE_NONE); +/*N*/ Table* pCols = new Table; +/*N*/ Table* pNewRowTable = new Table; +/*N*/ ScAddress* pNewAddress = new ScAddress; +/*N*/ ScRangePtr pR; +/*N*/ Table* pCol; +/*N*/ ScAddress* pPos; +/*N*/ USHORT nNoGlueRow = 0; +/*N*/ for ( pR = aRangeListRef->First(); pR; pR = aRangeListRef->Next() ) +/*N*/ { +/*N*/ pR->GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ for ( nTab = nTab1; nTab <= nTab2; nTab++ ) +/*N*/ { +/*N*/ // nTab im ColKey, um gleiche Col/Row in anderer Table haben zu koennen +/*N*/ ScAddress aInsCol( (bNoGlue ? 0 : nCol1), 0, nTab ); +/*N*/ for ( nCol = nCol1; nCol <= nCol2; nCol++, aInsCol.IncCol() ) +/*N*/ { +/*N*/ if ( (pDocument->GetColFlags( nCol, nTab) & CR_HIDDEN) == 0 ) +/*N*/ { +/*N*/ ULONG nInsCol = (ULONG)(UINT32) aInsCol; +/*N*/ if ( bNoGlue || eGlue == SC_CHARTGLUE_ROWS ) +/*N*/ { // meistens gleiche Cols +/*N*/ if ( !(pCol = (Table*) pCols->Get( nInsCol )) ) +/*N*/ { +/*N*/ pCols->Insert( nInsCol, pNewRowTable ); +/*N*/ pCol = pNewRowTable; +/*N*/ pNewRowTable = new Table; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // meistens neue Cols +/*?*/ if ( pCols->Insert( nInsCol, pNewRowTable ) ) +/*?*/ { +/*?*/ pCol = pNewRowTable; +/*?*/ pNewRowTable = new Table; +/*?*/ } +/*?*/ else +/*?*/ pCol = (Table*) pCols->Get( nInsCol ); +/*N*/ } +/*N*/ // bei anderer Tabelle wurde bereits neuer ColKey erzeugt, +/*N*/ // die Zeilen muessen fuer's Dummy fuellen gleich sein! +/*N*/ ULONG nInsRow = (bNoGlue ? nNoGlueRow : nRow1); +/*N*/ for ( nRow = nRow1; nRow <= nRow2; nRow++, nInsRow++ ) +/*N*/ { +/*N*/ if ( (pDocument->GetRowFlags( nRow, nTab) & CR_HIDDEN) == 0 ) +/*N*/ { +/*N*/ if ( pCol->Insert( nInsRow, pNewAddress ) ) +/*N*/ { +/*N*/ pNewAddress->Set( nCol, nRow, nTab ); +/*N*/ pNewAddress = new ScAddress; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ // bei NoGlue werden zusammengehoerige Tabellen als ColGlue dargestellt +/*N*/ nNoGlueRow += nRow2 - nRow1 + 1; +/*N*/ } +/*N*/ delete pNewAddress; +/*N*/ delete pNewRowTable; +/*N*/ +/*N*/ // Anzahl der Daten +/*N*/ nColCount = (USHORT) pCols->Count(); +/*N*/ if ( pCol = (Table*) pCols->First() ) +/*N*/ { +/*N*/ if ( bDummyUpperLeft ) +/*?*/ pCol->Insert( 0, (void*)0 ); // Dummy fuer Beschriftung +/*N*/ nRowCount = (USHORT) pCol->Count(); +/*N*/ } +/*N*/ else +/*N*/ nRowCount = 0; +/*N*/ if ( nColCount ) +/*N*/ nColCount -= nColAdd; +/*N*/ if ( nRowCount ) +/*N*/ nRowCount -= nRowAdd; +/*N*/ +/*N*/ if ( nColCount==0 || nRowCount==0 ) +/*N*/ { // einen Eintrag ohne Daten erzeugen +/*?*/ pR = aRangeListRef->First(); +/*?*/ if ( pCols->Count() > 0 ) +/*?*/ pCol = (Table*) pCols->First(); +/*?*/ else +/*?*/ { +/*?*/ pCol = new Table; +/*?*/ pCols->Insert( 0, pCol ); +/*?*/ } +/*?*/ nColCount = 1; +/*?*/ if ( pCol->Count() > 0 ) +/*?*/ { // kann ja eigentlich nicht sein, wenn nColCount==0 || nRowCount==0 +/*?*/ pPos = (ScAddress*) pCol->First(); +/*?*/ if ( pPos ) +/*?*/ { +/*?*/ delete pPos; +/*?*/ pCol->Replace( pCol->GetCurKey(), (void*)0 ); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ pCol->Insert( 0, (void*)0 ); +/*?*/ nRowCount = 1; +/*?*/ nColAdd = 0; +/*?*/ nRowAdd = 0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( bNoGlue ) +/*N*/ { // Luecken mit Dummies fuellen, erste Spalte ist Master +/*?*/ Table* pFirstCol = (Table*) pCols->First(); +/*?*/ ULONG nCount = pFirstCol->Count(); +/*?*/ pFirstCol->First(); +/*?*/ for ( ULONG n = 0; n < nCount; n++, pFirstCol->Next() ) +/*?*/ { +/*?*/ ULONG nKey = pFirstCol->GetCurKey(); +/*?*/ pCols->First(); +/*?*/ while ( pCol = (Table*) pCols->Next() ) +/*?*/ pCol->Insert( nKey, (void*)0 ); // keine Daten +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ pPositionMap = new ScChartPositionMap( nColCount, nRowCount, +/*N*/ nColAdd, nRowAdd, *pCols ); +/*N*/ +/*N*/ // Aufraeumen +/*N*/ for ( pCol = (Table*) pCols->First(); pCol; pCol = (Table*) pCols->Next() ) +/*N*/ { //! nur Tables loeschen, nicht die ScAddress* +/*N*/ delete pCol; +/*N*/ } +/*N*/ delete pCols; +/*N*/ } + + +/*N*/ ScChartPositionMap::ScChartPositionMap( USHORT nChartCols, USHORT nChartRows, +/*N*/ USHORT nColAdd, USHORT nRowAdd, Table& rCols ) : +/*N*/ nCount( (ULONG) nChartCols * nChartRows ), +/*N*/ nColCount( nChartCols ), +/*N*/ nRowCount( nChartRows ), +/*N*/ ppData( new ScAddress* [ nChartCols * nChartRows ] ), +/*N*/ ppColHeader( new ScAddress* [ nChartCols ] ), +/*N*/ ppRowHeader( new ScAddress* [ nChartRows ] ) +/*N*/ { +/*N*/ DBG_ASSERT( nColCount && nRowCount, "ScChartPositionMap without dimension" ); +/*N*/ #ifdef WIN +/*N*/ #error ScChartPositionMap not implemented for 16-bit dumdums +/*N*/ #endif +/*N*/ +/*N*/ ScAddress* pPos; +/*N*/ USHORT nCol, nRow; +/*N*/ +/*N*/ Table* pCol = (Table*) rCols.First(); +/*N*/ +/*N*/ // Zeilen-Header +/*N*/ pPos = (ScAddress*) pCol->First(); +/*N*/ if ( nRowAdd ) +/*N*/ pPos = (ScAddress*) pCol->Next(); +/*N*/ if ( nColAdd ) +/*N*/ { // eigenstaendig +/*N*/ for ( nRow = 0; nRow < nRowCount; nRow++ ) +/*N*/ { +/*N*/ ppRowHeader[ nRow ] = pPos; +/*N*/ pPos = (ScAddress*) pCol->Next(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // Kopie +/*?*/ for ( nRow = 0; nRow < nRowCount; nRow++ ) +/*?*/ { +/*?*/ ppRowHeader[ nRow ] = ( pPos ? new ScAddress( *pPos ) : NULL ); +/*?*/ pPos = (ScAddress*) pCol->Next(); +/*?*/ } +/*N*/ } +/*N*/ if ( nColAdd ) +/*N*/ pCol = (Table*) rCols.Next(); +/*N*/ +/*N*/ // Daten spaltenweise und Spalten-Header +/*N*/ ULONG nIndex = 0; +/*N*/ for ( nCol = 0; nCol < nColCount; nCol++ ) +/*N*/ { +/*N*/ if ( pCol ) +/*N*/ { +/*N*/ pPos = (ScAddress*) pCol->First(); +/*N*/ if ( nRowAdd ) +/*N*/ { +/*N*/ ppColHeader[ nCol ] = pPos; // eigenstaendig +/*N*/ pPos = (ScAddress*) pCol->Next(); +/*N*/ } +/*N*/ else +/*?*/ ppColHeader[ nCol ] = ( pPos ? new ScAddress( *pPos ) : NULL ); +/*N*/ for ( USHORT nRow = 0; nRow < nRowCount; nRow++, nIndex++ ) +/*N*/ { +/*N*/ ppData[ nIndex ] = pPos; +/*N*/ pPos = (ScAddress*) pCol->Next(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ ppColHeader[ nCol ] = NULL; +/*?*/ for ( nRow = 0; nRow < nRowCount; nRow++, nIndex++ ) +/*?*/ { +/*?*/ ppData[ nIndex ] = NULL; +/*?*/ } +/*N*/ } +/*N*/ pCol = (Table*) rCols.Next(); +/*N*/ } +/*N*/ } + + +/*N*/ ScChartPositionMap::~ScChartPositionMap() +/*N*/ { +/*N*/ for ( ULONG nIndex=0; nIndex < nCount; nIndex++ ) +/*N*/ { +/*N*/ delete ppData[nIndex]; +/*N*/ } +/*N*/ delete [] ppData; +/*N*/ +/*N*/ USHORT j; +/*N*/ for ( j=0; j < nColCount; j++ ) +/*N*/ { +/*N*/ delete ppColHeader[j]; +/*N*/ } +/*N*/ delete [] ppColHeader; +/*N*/ for ( j=0; j < nRowCount; j++ ) +/*N*/ { +/*N*/ delete ppRowHeader[j]; +/*N*/ } +/*N*/ delete [] ppRowHeader; +/*N*/ } + + + + + + +// +// Collection +// + + + +/*N*/ BOOL ScChartCollection::Load( ScDocument* pDoc, SvStream& rStream ) +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ USHORT nNewCount; +/*N*/ FreeAll(); +/*N*/ +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> nNewCount; +/*N*/ +/*N*/ for (USHORT i=0; i<nNewCount && bSuccess; i++) +/*N*/ { +/*?*/ ScChartArray* pObject = new ScChartArray( pDoc, rStream, aHdr ); +/*?*/ bSuccess = Insert( pObject ); +/*N*/ } +/*N*/ return bSuccess; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_chartlis.cxx b/binfilter/bf_sc/source/core/tool/sc_chartlis.cxx new file mode 100644 index 000000000000..d26ff12480b1 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_chartlis.cxx @@ -0,0 +1,354 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <vcl/svapp.hxx> + +#include "chartlis.hxx" +#include "document.hxx" +#include <tools/debug.hxx> +namespace binfilter { + +using namespace ::com::sun::star; + + +//2do: DocOption TimeOut? +#define SC_CHARTTIMEOUT 1000 // eine Sekunde keine Aenderung/KeyEvent + + +// ==================================================================== + +/*N*/ class ScChartUnoData +/*N*/ { +/*N*/ uno::Reference< chart::XChartDataChangeEventListener > xListener; +/*N*/ uno::Reference< chart::XChartData > xSource; +/*N*/ +/*N*/ public: +/*N*/ ScChartUnoData( const uno::Reference< chart::XChartDataChangeEventListener >& rL, +/*N*/ const uno::Reference< chart::XChartData >& rS ) : +/*N*/ xListener( rL ), xSource( rS ) {} +/*N*/ ~ScChartUnoData() {} +/*N*/ +/*N*/ const uno::Reference< chart::XChartDataChangeEventListener >& GetListener() const { return xListener; } +/*N*/ const uno::Reference< chart::XChartData >& GetSource() const { return xSource; } +/*N*/ }; + + +// === ScChartListener ================================================ + +/*N*/ ScChartListener::ScChartListener( const String& rName, ScDocument* pDocP, +/*N*/ const ScRange& rRange ) : +/*N*/ StrData( rName ), +/*N*/ pDoc( pDocP ), +/*N*/ pUnoData( NULL ), +/*N*/ bUsed( FALSE ), +/*N*/ bDirty( FALSE ), +/*N*/ bSeriesRangesScheduled( FALSE ) +/*N*/ { +/*N*/ SetRangeList( rRange ); +/*N*/ } + +/*N*/ ScChartListener::ScChartListener( const String& rName, ScDocument* pDocP, +/*N*/ const ScRangeListRef& rRangeList ) : +/*N*/ StrData( rName ), +/*N*/ aRangeListRef( rRangeList ), +/*N*/ pDoc( pDocP ), +/*N*/ pUnoData( NULL ), +/*N*/ bUsed( FALSE ), +/*N*/ bDirty( FALSE ), +/*N*/ bSeriesRangesScheduled( FALSE ) +/*N*/ { +/*N*/ } + +/*N*/ ScChartListener::ScChartListener( const ScChartListener& r ) : +/*N*/ StrData( r ), +/*N*/ pDoc( r.pDoc ), +/*N*/ pUnoData( NULL ), +/*N*/ bUsed( FALSE ), +/*N*/ bDirty( r.bDirty ), +/*N*/ bSeriesRangesScheduled( r.bSeriesRangesScheduled ) +/*N*/ { +/*N*/ if ( r.pUnoData ) +/*N*/ pUnoData = new ScChartUnoData( *r.pUnoData ); +/*N*/ if ( r.aRangeListRef.Is() ) +/*N*/ aRangeListRef = new ScRangeList( *r.aRangeListRef ); +/*N*/ } + +/*N*/ ScChartListener::~ScChartListener() +/*N*/ { +/*N*/ if ( GetBroadcasterCount() ) +/*N*/ EndListeningTo(); +/*N*/ delete pUnoData; +/*N*/ } + +/*N*/ DataObject* ScChartListener::Clone() const +/*N*/ { + DBG_BF_ASSERT(0, "STRIP");return NULL; //STRIP001 return new ScChartListener( *this ); +/*N*/ } + +/*N*/ void ScChartListener::SetUno( +/*N*/ const uno::Reference< chart::XChartDataChangeEventListener >& rListener, +/*N*/ const uno::Reference< chart::XChartData >& rSource ) +/*N*/ { +/*N*/ // DBG_ASSERT( rListener.is() && rSource.is(), "Nullpointer bei SetUno" ); +/*N*/ delete pUnoData; +/*N*/ pUnoData = new ScChartUnoData( rListener, rSource ); +/*N*/ } + +/*N*/ uno::Reference< chart::XChartDataChangeEventListener > ScChartListener::GetUnoListener() const +/*N*/ { +/*N*/ if ( pUnoData ) +/*N*/ return pUnoData->GetListener(); +/*N*/ return uno::Reference< chart::XChartDataChangeEventListener >(); +/*N*/ } + +/*N*/ uno::Reference< chart::XChartData > ScChartListener::GetUnoSource() const +/*N*/ { +/*N*/ if ( pUnoData ) +/*N*/ return pUnoData->GetSource(); +/*N*/ return uno::Reference< chart::XChartData >(); +/*N*/ } + +/*N*/ void __EXPORT ScChartListener::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) +/*N*/ { +/*N*/ const ScHint* p = PTR_CAST( ScHint, &rHint ); +/*N*/ if( p && (p->GetId() & (SC_HINT_DATACHANGED | SC_HINT_DYING)) ) +/*N*/ { +/*N*/ bDirty = TRUE; +/*N*/ pDoc->GetChartListenerCollection()->StartTimer(); +/*N*/ } +/*N*/ } + +/*N*/ void ScChartListener::Update() +/*N*/ { +/*N*/ if ( pDoc->IsInInterpreter() ) +/*N*/ { // #73482# If interpreting do nothing and restart timer so we don't +/*?*/ // interfere with interpreter and don't produce an Err522 or similar. +/*?*/ // This may happen if we are rescheduled via Basic function. +/*?*/ pDoc->GetChartListenerCollection()->StartTimer(); +/*?*/ return ; +/*N*/ } +/*N*/ if ( pUnoData ) +/*N*/ { +/*?*/ bDirty = FALSE; +/*?*/ //! irgendwann mal erkennen, was sich innerhalb des Charts geaendert hat +/*?*/ chart::ChartDataChangeEvent aEvent( pUnoData->GetSource(), +/*?*/ chart::ChartDataChangeType_ALL, +/*?*/ 0, 0, 0, 0 ); +/*?*/ pUnoData->GetListener()->chartDataChanged( aEvent ); +/*N*/ } +/*N*/ else if ( pDoc->GetAutoCalc() ) +/*N*/ { +/*N*/ bDirty = FALSE; +/*N*/ pDoc->UpdateChart( GetString(), NULL ); +/*N*/ } +/*N*/ } + +/*N*/ void ScChartListener::StartListeningTo() +/*N*/ { +/*N*/ if ( aRangeListRef.Is() ) +/*N*/ for ( ScRangePtr pR = aRangeListRef->First(); pR; +/*N*/ pR = aRangeListRef->Next() ) +/*N*/ { +/*N*/ if ( pR->aStart == pR->aEnd ) +/*?*/ pDoc->StartListeningCell( pR->aStart, this ); +/*N*/ else +/*N*/ pDoc->StartListeningArea( *pR, this ); +/*N*/ } +/*N*/ } + +/*N*/ void ScChartListener::EndListeningTo() +/*N*/ { +/*N*/ if ( aRangeListRef.Is() ) +/*N*/ for ( ScRangePtr pR = aRangeListRef->First(); pR; +/*N*/ pR = aRangeListRef->Next() ) +/*N*/ { +/*N*/ if ( pR->aStart == pR->aEnd ) +/*?*/ pDoc->EndListeningCell( pR->aStart, this ); +/*N*/ else +/*N*/ pDoc->EndListeningArea( *pR, this ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScChartListener::SetRangeList( const ScRange& rRange ) +/*N*/ { +/*N*/ aRangeListRef = new ScRangeList; +/*N*/ aRangeListRef->Append( rRange ); +/*N*/ } + + + + + + + + + + +// === ScChartListenerCollection ====================================== + +/*N*/ ScChartListenerCollection::ScChartListenerCollection( ScDocument* pDocP ) : +/*N*/ StrCollection( 4, 4, FALSE ), +/*N*/ pDoc( pDocP ) +/*N*/ { +/*N*/ aTimer.SetTimeoutHdl( LINK( this, ScChartListenerCollection, TimerHdl ) ); +/*N*/ } + + +/*N*/ ScChartListenerCollection::~ScChartListenerCollection() +/*N*/ { +/*N*/ // #96783# remove ChartListener objects before aTimer dtor is called, because +/*N*/ // ScChartListener::EndListeningTo may cause ScChartListenerCollection::StartTimer +/*N*/ // to be called if an empty ScNoteCell is deleted +/*N*/ +/*N*/ if (GetCount()) +/*N*/ FreeAll(); +/*N*/ } + +/*N*/ DataObject* ScChartListenerCollection::Clone() const +/*N*/ { + DBG_BF_ASSERT(0, "STRIP");return NULL;//STRIP001 return new ScChartListenerCollection( *this ); +/*N*/ } + + +/*N*/ void ScChartListenerCollection::ChangeListening( const String& rName, +/*N*/ const ScRangeListRef& rRangeListRef, BOOL bDirty ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScChartListener aCLSearcher( rName, pDoc, rRangeListRef ); +/*N*/ } + +/*N*/ void ScChartListenerCollection::FreeUnused() +/*N*/ { +/*N*/ // rueckwaerts wg. Pointer-Aufrueckerei im Array +/*N*/ for ( USHORT nIndex = nCount; nIndex-- >0; ) +/*N*/ { +/*N*/ ScChartListener* pCL = (ScChartListener*) pItems[ nIndex ]; +/*N*/ // Uno-Charts nicht rauskicken +/*N*/ // (werden per FreeUno von aussen geloescht) +/*N*/ if ( !pCL->IsUno() ) +/*N*/ { +/*N*/ if ( pCL->IsUsed() ) +/*N*/ pCL->SetUsed( FALSE ); +/*N*/ else +/*?*/ Free( pCL ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScChartListenerCollection::FreeUno( const uno::Reference< chart::XChartDataChangeEventListener >& rListener, +/*N*/ const uno::Reference< chart::XChartData >& rSource ) +/*N*/ { +/*N*/ // rueckwaerts wg. Pointer-Aufrueckerei im Array +/*N*/ for ( USHORT nIndex = nCount; nIndex-- >0; ) +/*N*/ { +/*N*/ ScChartListener* pCL = (ScChartListener*) pItems[ nIndex ]; +/*N*/ if ( pCL->IsUno() && +/*N*/ pCL->GetUnoListener() == rListener && +/*N*/ pCL->GetUnoSource() == rSource ) +/*N*/ { +/*N*/ Free( pCL ); +/*N*/ } +/*N*/ //! sollte nur einmal vorkommen? +/*N*/ } +/*N*/ } + +/*N*/ void ScChartListenerCollection::StartTimer() +/*N*/ { +/*N*/ aTimer.SetTimeout( SC_CHARTTIMEOUT ); +/*N*/ aTimer.Start(); +/*N*/ } + +/*N*/ IMPL_LINK( ScChartListenerCollection, TimerHdl, Timer*, pTimer ) +/*N*/ { +/*N*/ if ( Application::AnyInput( INPUT_KEYBOARD ) ) +/*N*/ { +/*?*/ aTimer.Start(); +/*?*/ return 0; +/*N*/ } +/*N*/ UpdateDirtyCharts(); +/*N*/ return 0; +/*N*/ } + +/*N*/ void ScChartListenerCollection::UpdateDirtyCharts() +/*N*/ { +/*N*/ for ( USHORT nIndex = 0; nIndex < nCount; nIndex++ ) +/*N*/ { +/*N*/ ScChartListener* pCL = (ScChartListener*) pItems[ nIndex ]; +/*N*/ if ( pCL->IsDirty() ) +/*N*/ pCL->Update(); +/*N*/ if ( aTimer.IsActive() && !pDoc->IsImportingXML()) +/*N*/ break; // da kam einer dazwischen +/*N*/ } +/*N*/ } + + +/*N*/ void ScChartListenerCollection::SetDirty() +/*N*/ { +/*N*/ for ( USHORT nIndex = 0; nIndex < nCount; nIndex++ ) +/*N*/ { +/*?*/ ScChartListener* pCL = (ScChartListener*) pItems[ nIndex ]; +/*?*/ pCL->SetDirty( TRUE ); +/*N*/ } +/*N*/ StartTimer(); +/*N*/ } + + + + + + +/*N*/ void ScChartListenerCollection::UpdateScheduledSeriesRanges() +/*N*/ { +/*N*/ for ( USHORT nIndex = 0; nIndex < nCount; nIndex++ ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScChartListener* pCL = (ScChartListener*) pItems[ nIndex ]; +/*N*/ } +/*N*/ } + + +/*N*/ void ScChartListenerCollection::UpdateSeriesRangesContainingTab( USHORT nTab ) +/*N*/ { +/*N*/ ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab ); +/*N*/ for ( USHORT nIndex = 0; nIndex < nCount; nIndex++ ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScChartListener* pCL = (ScChartListener*) pItems[ nIndex ]; +/*N*/ } +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_chgtrack.cxx b/binfilter/bf_sc/source/core/tool/sc_chgtrack.cxx new file mode 100644 index 000000000000..512852a0c954 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_chgtrack.cxx @@ -0,0 +1,3853 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <bf_svtools/zforlist.hxx> +#include <bf_svtools/isethint.hxx> +#include <bf_svtools/itempool.hxx> +#include <bf_sfx2/app.hxx> +#include <bf_svtools/useroptions.hxx> +#include <bf_sfx2/sfxsids.hrc> +#include <bf_svx/adritem.hxx> + +#include "cell.hxx" +#include "dociter.hxx" +#include "rechead.hxx" +#include "scerrors.hxx" +#include "scmod.hxx" // SC_MOD +#include "inputopt.hxx" // GetExpandRefs +#include "patattr.hxx" +#include "hints.hxx" + +#include "globstr.hrc" + +#define SC_CHGTRACK_CXX +#include "chgtrack.hxx" + +#include "refupdat.hxx" + +namespace binfilter { + +/*N*/ DECLARE_STACK( ScChangeActionStack, ScChangeAction* ) + +const USHORT nMemPoolChangeActionCellListEntry = (0x2000 - 64) / sizeof(ScChangeActionCellListEntry); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScChangeActionCellListEntry, nMemPoolChangeActionCellListEntry, nMemPoolChangeActionCellListEntry )//STRIP008 ; + +const USHORT nMemPoolChangeActionLinkEntry = (0x8000 - 64) / sizeof(ScChangeActionLinkEntry); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScChangeActionLinkEntry, nMemPoolChangeActionLinkEntry, nMemPoolChangeActionLinkEntry )//STRIP008 ; + +// loaded MSB > eigenes => inkompatibel +#define SC_CHGTRACK_FILEFORMAT_FIRST 0x0001 +#define SC_CHGTRACK_FILEFORMAT 0x0001 + +// --- ScChangeAction ------------------------------------------------------ + +/*N*/ ScChangeAction::ScChangeAction( ScChangeActionType eTypeP, const ScRange& rRange ) +/*N*/ : +/*N*/ aBigRange( rRange ), +/*N*/ pNext( NULL ), +/*N*/ pPrev( NULL ), +/*N*/ pLinkAny( NULL ), +/*N*/ pLinkDeletedIn( NULL ), +/*N*/ pLinkDeleted( NULL ), +/*N*/ pLinkDependent( NULL ), +/*N*/ nAction( 0 ), +/*N*/ nRejectAction( 0 ), +/*N*/ eType( eTypeP ), +/*N*/ eState( SC_CAS_VIRGIN ) +/*N*/ { +/*N*/ aDateTime.ConvertToUTC(); +/*N*/ } + +/*N*/ ScChangeAction::ScChangeAction( ScChangeActionType eTypeP, const ScBigRange& rRange, +/*N*/ const ULONG nTempAction, const ULONG nTempRejectAction, +/*N*/ const ScChangeActionState eTempState, const DateTime& aTempDateTime, +/*N*/ const String& aTempUser, const String& aTempComment) +/*N*/ : +/*N*/ aBigRange( rRange ), +/*N*/ pNext( NULL ), +/*N*/ pPrev( NULL ), +/*N*/ pLinkAny( NULL ), +/*N*/ pLinkDeletedIn( NULL ), +/*N*/ pLinkDeleted( NULL ), +/*N*/ pLinkDependent( NULL ), +/*N*/ nAction( nTempAction ), +/*N*/ nRejectAction( nTempRejectAction ), +/*N*/ eType( eTypeP ), +/*N*/ eState( eTempState ), +/*N*/ aDateTime( aTempDateTime ), +/*N*/ aUser( aTempUser ), +/*N*/ aComment( aTempComment ) +/*N*/ { +/*N*/ } + +/*N*/ ScChangeAction::ScChangeAction( ScChangeActionType eTypeP, const ScBigRange& rRange, +/*N*/ const ULONG nTempAction) +/*N*/ : +/*N*/ aBigRange( rRange ), +/*N*/ pNext( NULL ), +/*N*/ pPrev( NULL ), +/*N*/ pLinkAny( NULL ), +/*N*/ pLinkDeletedIn( NULL ), +/*N*/ pLinkDeleted( NULL ), +/*N*/ pLinkDependent( NULL ), +/*N*/ nAction( nTempAction ), +/*N*/ nRejectAction( 0 ), +/*N*/ eType( eTypeP ), +/*N*/ eState( SC_CAS_VIRGIN ) +/*N*/ { +/*N*/ aDateTime.ConvertToUTC(); +/*N*/ } + +/*N*/ ScChangeAction::ScChangeAction( SvStream& rStrm, ScMultipleReadHeader& rHdr, +/*N*/ ScChangeTrack* pTrack ) +/*N*/ : +/*N*/ pNext( NULL ), +/*N*/ pPrev( NULL ), +/*N*/ pLinkAny( NULL ), +/*N*/ pLinkDeletedIn( NULL ), +/*N*/ pLinkDeleted( NULL ), +/*N*/ pLinkDependent( NULL ) +/*N*/ { +/*N*/ // ScChangeTrack speichert aUser als Index auf Collection und eType selber +/*N*/ UINT32 n32; +/*N*/ UINT16 n16; +/*N*/ rStrm >> aBigRange; +/*N*/ rStrm >> n32; aDateTime.SetDate( n32 ); +/*N*/ rStrm >> n32; aDateTime.SetTime( n32 ); +/*N*/ rStrm >> n32; nAction = n32; +/*N*/ rStrm >> n32; nRejectAction = n32; +/*N*/ rStrm >> n16; eState = (ScChangeActionState) n16; +/*N*/ rStrm.ReadByteString( aComment, rStrm.GetStreamCharSet() ); +/*N*/ // LinkEntries in zweiter Runde +/*N*/ } + + +/*N*/ ScChangeAction::~ScChangeAction() +/*N*/ { +/*N*/ RemoveAllLinks(); +/*N*/ } + + +/*N*/ BOOL ScChangeAction::Store( SvStream& rStrm, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ // ScChangeTrack speichert aUser als Index auf Collection und eType selber +/*N*/ rStrm << aBigRange; +/*N*/ rStrm << (UINT32) aDateTime.GetDate(); +/*N*/ rStrm << (UINT32) aDateTime.GetTime(); +/*N*/ rStrm << (UINT32) nAction; +/*N*/ rStrm << (UINT32) nRejectAction; +/*N*/ rStrm << (UINT16) eState; +/*N*/ rStrm.WriteByteString( aComment, rStrm.GetStreamCharSet() ); +/*N*/ // LinkEntries in zweiter Runde +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ BOOL ScChangeAction::StoreLinks( SvStream& rStrm ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::StoreLinkChain( pLinkDeleted, rStrm ); +/*N*/ bOk &= ScChangeAction::StoreLinkChain( pLinkDependent, rStrm ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeAction::LoadLinks( SvStream& rStrm, ScChangeTrack* pTrack ) // Changetracking.sdc +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::LoadLinkChain( this, &pLinkDeleted, rStrm, +/*N*/ pTrack, TRUE ); +/*N*/ bOk &= ScChangeAction::LoadLinkChain( this, &pLinkDependent, rStrm, +/*N*/ pTrack, FALSE ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeAction::IsTouchable() const +/*N*/ { +/*N*/ //! sequence order of execution is significant +/*N*/ if ( IsRejected() || GetType() == SC_CAT_REJECT || IsDeletedIn() ) +/*N*/ return FALSE; +/*N*/ // content may reject and be touchable if on top +/*N*/ if ( GetType() == SC_CAT_CONTENT ) +/*N*/ return ((ScChangeActionContent*)this)->IsTopContent(); +/*N*/ if ( IsRejecting() ) +/*N*/ return FALSE; +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScChangeAction::IsInternalRejectable() const +/*N*/ { +/*N*/ //! sequence order of execution is significant +/*N*/ if ( !IsVirgin() ) +/*N*/ return FALSE; +/*N*/ if ( IsDeletedIn() ) +/*N*/ return FALSE; +/*N*/ if ( GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ ScChangeActionContent* pNextContent = +/*N*/ ((ScChangeActionContent*)this)->GetNextContent(); +/*N*/ if ( pNextContent == NULL ) +/*N*/ return TRUE; // *this is TopContent +/*N*/ return pNextContent->IsRejected(); // *this is next rejectable +/*N*/ } +/*N*/ return IsTouchable(); +/*N*/ } + + +/*N*/ void ScChangeAction::RemoveAllLinks() +/*N*/ { +/*N*/ RemoveAllAnyLinks(); +/*N*/ RemoveAllDeletedIn(); +/*N*/ RemoveAllDeleted(); +/*N*/ RemoveAllDependent(); +/*N*/ } + + +/*N*/ void ScChangeAction::RemoveAllAnyLinks() +/*N*/ { +/*N*/ while ( pLinkAny ) +/*N*/ delete pLinkAny; // rueckt sich selbst hoch +/*N*/ } + + +/*N*/ BOOL ScChangeAction::RemoveDeletedIn( const ScChangeAction* p ) +/*N*/ { +/*N*/ BOOL bRemoved = FALSE; +/*N*/ ScChangeActionLinkEntry* pL = GetDeletedIn(); +/*N*/ while ( pL ) +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pNextLink = pL->GetNext(); +/*N*/ if ( pL->GetAction() == p ) +/*N*/ { +/*N*/ delete pL; +/*N*/ bRemoved = TRUE; +/*N*/ } +/*N*/ pL = pNextLink; +/*N*/ } +/*N*/ return bRemoved; +/*N*/ } + + +/*N*/ BOOL ScChangeAction::IsDeletedIn( const ScChangeAction* p ) const +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pL = GetDeletedIn(); +/*N*/ while ( pL ) +/*N*/ { +/*N*/ if ( pL->GetAction() == p ) +/*N*/ return TRUE; +/*N*/ pL = pL->GetNext(); +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScChangeAction::RemoveAllDeletedIn() +/*N*/ { +/*N*/ //! nicht vom evtl. TopContent sondern wirklich dieser +/*N*/ while ( pLinkDeletedIn ) +/*N*/ delete pLinkDeletedIn; // rueckt sich selbst hoch +/*N*/ } + + +/*N*/ BOOL ScChangeAction::IsDeletedInDelType( ScChangeActionType eDelType ) const +/*N*/ { +/*N*/ ScChangeAction* p; +/*N*/ ScChangeActionLinkEntry* pL = GetDeletedIn(); +/*N*/ if ( pL ) +/*N*/ { +/*N*/ // InsertType fuer MergePrepare/MergeOwn +/*N*/ ScChangeActionType eInsType; +/*N*/ switch ( eDelType ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ eInsType = SC_CAT_INSERT_COLS; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ eInsType = SC_CAT_INSERT_ROWS; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ eInsType = SC_CAT_INSERT_TABS; +/*N*/ break; +/*N*/ default: +/*N*/ eInsType = SC_CAT_NONE; +/*N*/ } +/*N*/ while ( pL ) +/*N*/ { +/*N*/ if ( (p = pL->GetAction()) && +/*N*/ (p->GetType() == eDelType || p->GetType() == eInsType) ) +/*N*/ return TRUE; +/*N*/ pL = pL->GetNext(); +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScChangeAction::SetDeletedIn( ScChangeAction* p ) // Changetracking.sdc +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink1 = AddDeletedIn( p ); +/*N*/ ScChangeActionLinkEntry* pLink2; +/*N*/ if ( GetType() == SC_CAT_CONTENT ) +/*N*/ pLink2 = p->AddDeleted( ((ScChangeActionContent*)this)->GetTopContent() ); +/*N*/ else +/*N*/ pLink2 = p->AddDeleted( this ); +/*N*/ pLink1->SetLink( pLink2 ); +/*N*/ } + + +/*N*/ void ScChangeAction::RemoveAllDeleted() +/*N*/ { +/*N*/ while ( pLinkDeleted ) +/*N*/ delete pLinkDeleted; // rueckt sich selbst hoch +/*N*/ } + + +/*N*/ void ScChangeAction::RemoveAllDependent() +/*N*/ { +/*N*/ while ( pLinkDependent ) +/*N*/ delete pLinkDependent; // rueckt sich selbst hoch +/*N*/ } + + +/*N*/ void ScChangeAction::UpdateReference( const ScChangeTrack* pTrack, +/*N*/ UpdateRefMode eMode, const ScBigRange& rRange, +/*N*/ INT32 nDx, INT32 nDy, INT32 nDz ) +/*N*/ { +/*N*/ ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, GetBigRange() ); +/*N*/ } + + +/*N*/ String ScChangeAction::GetRefString( const ScBigRange& rRange, +/*N*/ ScDocument* pDoc, BOOL bFlag3D ) const +/*N*/ { +/*N*/ String aStr; +/*N*/ USHORT nFlags = ( rRange.IsValid( pDoc ) ? SCA_VALID : 0 ); +/*N*/ if ( !nFlags ) +/*N*/ aStr = ScGlobal::GetRscString( STR_NOREF_STR ); +/*N*/ else +/*N*/ { +/*N*/ ScRange aTmpRange( rRange.MakeRange() ); +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ if ( bFlag3D ) +/*N*/ { +/*N*/ pDoc->GetName( aTmpRange.aStart.Tab(), aStr ); +/*N*/ aStr += '.'; +/*N*/ } +/*N*/ aStr += binfilter::ColToAlpha( aTmpRange.aStart.Col() ); +/*N*/ aStr += ':'; +/*N*/ aStr += binfilter::ColToAlpha( aTmpRange.aEnd.Col() ); +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ if ( bFlag3D ) +/*N*/ { +/*N*/ pDoc->GetName( aTmpRange.aStart.Tab(), aStr ); +/*N*/ aStr += '.'; +/*N*/ } +/*N*/ aStr += String::CreateFromInt32( aTmpRange.aStart.Row() + 1 ); +/*N*/ aStr += ':'; +/*N*/ aStr += String::CreateFromInt32( aTmpRange.aEnd.Row() + 1 ); +/*N*/ break; +/*N*/ default: +/*N*/ if ( bFlag3D || GetType() == SC_CAT_INSERT_TABS ) +/*N*/ nFlags |= SCA_TAB_3D; +/*N*/ aTmpRange.Format( aStr, nFlags, pDoc ); +/*N*/ } +/*N*/ if ( (bFlag3D && IsDeleteType()) || IsDeletedIn() ) +/*N*/ { +/*N*/ aStr.Insert( '(', 0 ); +/*N*/ aStr += ')'; +/*N*/ } +/*N*/ } +/*N*/ return aStr; +/*N*/ } + + +/*N*/ void ScChangeAction::GetRefString( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bFlag3D ) const +/*N*/ { +/*N*/ rStr = GetRefString( GetBigRange(), pDoc, bFlag3D ); +/*N*/ } + + +/*N*/ void ScChangeAction::Accept() +/*N*/ { +/*N*/ if ( IsVirgin() ) +/*N*/ { +/*N*/ SetState( SC_CAS_ACCEPTED ); +/*N*/ DeleteCellEntries(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeAction::SetRejected() +/*N*/ { +/*N*/ if ( IsVirgin() ) +/*N*/ { +/*N*/ SetState( SC_CAS_REJECTED ); +/*N*/ RemoveAllLinks(); +/*N*/ DeleteCellEntries(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeAction::RejectRestoreContents( ScChangeTrack* pTrack, +/*N*/ short nDx, short nDy ) +/*N*/ { +/*N*/ // Liste der Contents aufbauen +/*N*/ ScChangeActionCellListEntry* pListContents = NULL; +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkDeleted; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeAction* p = pL->GetAction(); +/*N*/ if ( p && p->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ ScChangeActionCellListEntry* pE = new ScChangeActionCellListEntry( +/*N*/ (ScChangeActionContent*) p, pListContents ); +/*N*/ pListContents = pE; +/*N*/ } +/*N*/ } +/*N*/ SetState( SC_CAS_REJECTED ); // vor UpdateReference fuer Move +/*N*/ pTrack->UpdateReference( this, TRUE ); // LinkDeleted freigeben +/*N*/ DBG_ASSERT( !pLinkDeleted, "ScChangeAction::RejectRestoreContents: pLinkDeleted != NULL" ); +/*N*/ // Liste der Contents abarbeiten und loeschen +/*N*/ ScDocument* pDoc = pTrack->GetDocument(); +/*N*/ ScChangeActionCellListEntry* pE = pListContents; +/*N*/ while ( pE ) +/*N*/ { +/*N*/ if ( !pE->pContent->IsDeletedIn() && +/*N*/ pE->pContent->GetBigRange().aStart.IsValid( pDoc ) ) +/*N*/ pE->pContent->PutNewValueToDoc( pDoc, nDx, nDy ); +/*N*/ ScChangeActionCellListEntry* pNext; +/*N*/ pNext = pE->pNext; +/*N*/ delete pE; +/*N*/ pE = pNext; +/*N*/ } +/*N*/ DeleteCellEntries(); // weg mit den generierten +/*N*/ } + + +// static +/*N*/ void ScChangeAction::StoreCell( ScBaseCell* pCell, SvStream& rStrm, +/*N*/ ScMultipleWriteHeader& rHdr ) +/*N*/ { +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ CellType eCellType = pCell->GetCellType(); +/*N*/ switch( eCellType ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ rStrm << (BYTE) eCellType; +/*N*/ ((ScValueCell*)pCell)->Save( rStrm ); +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ rStrm << (BYTE) eCellType; +/*N*/ ((ScStringCell*)pCell)->Save( rStrm ); +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ rStrm << (BYTE) eCellType; +/*N*/ ((ScEditCell*)pCell)->Save( rStrm ); +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ rStrm << (BYTE) eCellType; +/*N*/ rStrm << ((ScFormulaCell*)pCell)->aPos; +/*N*/ ((ScFormulaCell*)pCell)->Save( rStrm, rHdr ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "ScChangeAction::StoreCell: unknown CellType" ); +/*N*/ rStrm << (BYTE) CELLTYPE_NONE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ rStrm << (BYTE) CELLTYPE_NONE; +/*N*/ } + + +// static +/*N*/ ScBaseCell* ScChangeAction::LoadCell( SvStream& rStrm, +/*N*/ ScMultipleReadHeader& rHdr, ScDocument* pDoc, USHORT nVer ) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ BYTE nByte; +/*N*/ rStrm >> nByte; +/*N*/ switch ( (CellType) nByte ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ pCell = new ScValueCell( rStrm, nVer ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ { +/*N*/ pCell = new ScStringCell( rStrm, nVer ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ { +/*N*/ pCell = new ScEditCell( rStrm, nVer, pDoc ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ ScAddress aPos; +/*N*/ rStrm >> aPos; +/*N*/ pCell = new ScFormulaCell( pDoc, aPos, rStrm, rHdr ); +/*N*/ ((ScFormulaCell*)pCell)->SetInChangeTrack( TRUE ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_NONE : +/*N*/ pCell = NULL; +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "ScChangeAction::LoadCell: unknown CellType" ); +/*N*/ rStrm.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*N*/ pCell = NULL; +/*N*/ } +/*N*/ return pCell; +/*N*/ } + + +// static +/*N*/ BOOL ScChangeAction::StoreLinkChain( ScChangeActionLinkEntry* pLinkFirst, +/*N*/ SvStream& rStrm ) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ UINT32 nCount = 0; +/*N*/ if ( pLinkFirst ) +/*N*/ { +/*N*/ // rueckwaerts speichern, damit onLoad mit Insert die Reihenfolge wieder stimmt +/*N*/ Stack* pStack = new Stack; +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkFirst; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ++nCount; +/*N*/ pStack->Push( pL ); +/*N*/ } +/*N*/ rStrm << nCount; +/*N*/ ScChangeActionLinkEntry* pHere; +/*N*/ while ( pHere = (ScChangeActionLinkEntry*) pStack->Pop() ) +/*N*/ { +/*N*/ ScChangeAction* p = pHere->GetAction(); +/*N*/ rStrm << (UINT32) ( p ? p->GetActionNumber() : 0 ); +/*N*/ } +/*N*/ delete pStack; +/*N*/ } +/*N*/ else +/*N*/ rStrm << nCount; +/*N*/ return bOk; +/*N*/ } + + +// static +/*N*/ BOOL ScChangeAction::LoadLinkChain( ScChangeAction* pOfAction, // Changetracking.sdc +/*N*/ ScChangeActionLinkEntry** ppLinkFirst, SvStream& rStrm, +/*N*/ ScChangeTrack* pTrack, BOOL bLinkDeleted ) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ UINT32 nCount; +/*N*/ rStrm >> nCount; +/*N*/ for ( UINT32 j = 0; j < nCount; j++ ) +/*N*/ { +/*N*/ ScChangeAction* pAct = NULL; +/*N*/ UINT32 nAct; +/*N*/ rStrm >> nAct; +/*N*/ if ( nAct ) +/*N*/ { +/*N*/ pAct = pTrack->GetActionOrGenerated( nAct ); +/*N*/ DBG_ASSERT( pAct, "ScChangeAction::LoadLinkChain: missing Action" ); +/*N*/ } +/*N*/ if ( bLinkDeleted ) +/*N*/ { +/*N*/ if ( pAct ) +/*N*/ pAct->SetDeletedIn( pOfAction ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry( +/*N*/ ppLinkFirst, pAct ); +/*N*/ if ( pAct ) +/*N*/ pAct->AddLink( pOfAction, pLink ); +/*N*/ } +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ void ScChangeAction::SetDeletedInThis( ULONG nActionNumber, +/*N*/ const ScChangeTrack* pTrack ) +/*N*/ { +/*N*/ if ( nActionNumber ) +/*N*/ { +/*N*/ ScChangeAction* pAct = pTrack->GetActionOrGenerated( nActionNumber ); +/*N*/ DBG_ASSERT( pAct, "ScChangeAction::SetDeletedInThis: missing Action" ); +/*N*/ if ( pAct ) +/*N*/ pAct->SetDeletedIn( this ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeAction::AddDependent( ULONG nActionNumber, +/*N*/ const ScChangeTrack* pTrack ) +/*N*/ { +/*N*/ if ( nActionNumber ) +/*N*/ { +/*N*/ ScChangeAction* pAct = pTrack->GetActionOrGenerated( nActionNumber ); +/*N*/ DBG_ASSERT( pAct, "ScChangeAction::AddDependent: missing Action" ); +/*N*/ if ( pAct ) +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = AddDependent( pAct ); +/*N*/ pAct->AddLink( this, pLink ); +/*N*/ } +/*N*/ } +/*N*/ } + +// static +/*N*/ BOOL ScChangeAction::StoreCellList( ScChangeActionCellListEntry* pFirstCell, +/*N*/ SvStream& rStrm ) +/*N*/ { +/*N*/ UINT32 nCount = 0; +/*N*/ for ( const ScChangeActionCellListEntry* pE = pFirstCell; pE; +/*N*/ pE = pE->pNext ) +/*N*/ ++nCount; +/*N*/ rStrm << nCount; +/*N*/ +/*N*/ if ( nCount ) +/*N*/ { +/*N*/ for ( const ScChangeActionCellListEntry* pE = pFirstCell; pE; +/*N*/ pE = pE->pNext ) +/*N*/ { // Store/Load vertauscht die Reihenfolge, aber das ist hierbei egal +/*N*/ rStrm << (UINT32) pE->pContent->GetActionNumber(); +/*N*/ } +/*N*/ } +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ BOOL ScChangeAction::LoadCellList( ScChangeAction* pOfAction, +/*N*/ ScChangeActionCellListEntry*& pFirstCell, SvStream& rStrm, +/*N*/ ScChangeTrack* pTrack ) +/*N*/ { +/*N*/ UINT32 nCount; +/*N*/ rStrm >> nCount; +/*N*/ if ( nCount ) +/*N*/ { +/*N*/ for ( UINT32 j = 0; j < nCount; j++ ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent; +/*N*/ UINT32 nContent; +/*N*/ rStrm >> nContent; +/*N*/ pContent = (ScChangeActionContent*) pTrack->GetActionOrGenerated( nContent ); +/*N*/ if ( pContent ) +/*N*/ pOfAction->AddContent( pContent ); +/*N*/ else +/*N*/ DBG_ERROR( "ScChangeActionDel::LoadLinks: missing Content" ); +/*N*/ } +/*N*/ } +/*N*/ return TRUE; +/*N*/ } + + +// --- ScChangeActionIns --------------------------------------------------- + +/*N*/ ScChangeActionIns::ScChangeActionIns( const ScRange& rRange ) +/*N*/ : ScChangeAction( SC_CAT_NONE, rRange ) +/*N*/ { +/*N*/ if ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() == MAXCOL ) +/*N*/ { +/*N*/ aBigRange.aStart.SetCol( nInt32Min ); +/*N*/ aBigRange.aEnd.SetCol( nInt32Max ); +/*N*/ if ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == MAXROW ) +/*N*/ { +/*N*/ SetType( SC_CAT_INSERT_TABS ); +/*N*/ aBigRange.aStart.SetRow( nInt32Min ); +/*N*/ aBigRange.aEnd.SetRow( nInt32Max ); +/*N*/ } +/*N*/ else +/*N*/ SetType( SC_CAT_INSERT_ROWS ); +/*N*/ } +/*N*/ else if ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == MAXROW ) +/*N*/ { +/*N*/ SetType( SC_CAT_INSERT_COLS ); +/*N*/ aBigRange.aStart.SetRow( nInt32Min ); +/*N*/ aBigRange.aEnd.SetRow( nInt32Max ); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR( "ScChangeActionIns: Block not supported!" ); +/*N*/ } + + +/*N*/ ScChangeActionIns::ScChangeActionIns( SvStream& rStrm, +/*N*/ ScMultipleReadHeader& rHdr, ScChangeTrack* pTrack ) +/*N*/ : +/*N*/ ScChangeAction( rStrm, rHdr, pTrack ) +/*N*/ { +/*N*/ } + +/*N*/ ScChangeActionIns::ScChangeActionIns(const ULONG nActionNumber, const ScChangeActionState eState, const ULONG nRejectingNumber, +/*N*/ const ScBigRange& aBigRange, const String& aUser, const DateTime& aDateTime, const String& sComment, +/*N*/ const ScChangeActionType eType) +/*N*/ : +/*N*/ ScChangeAction(eType, aBigRange, nActionNumber, nRejectingNumber, eState, aDateTime, aUser, sComment) +/*N*/ { +/*N*/ } + +/*N*/ ScChangeActionIns::~ScChangeActionIns() +/*N*/ { +/*N*/ } + + +/*N*/ BOOL ScChangeActionIns::Store( SvStream& rStrm, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::Store( rStrm, rHdr ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ void ScChangeActionIns::GetDescription( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bSplitRange ) const +/*N*/ { +/*N*/ USHORT nWhatId; +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ nWhatId = STR_COLUMN; +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ nWhatId = STR_ROW; +/*N*/ break; +/*N*/ default: +/*N*/ nWhatId = STR_AREA; +/*N*/ } +/*N*/ +/*N*/ String aRsc( ScGlobal::GetRscString( STR_CHANGED_INSERT ) ); +/*N*/ xub_StrLen nPos = aRsc.SearchAscii( "#1" ); +/*N*/ rStr += aRsc.Copy( 0, nPos ); +/*N*/ rStr += ScGlobal::GetRscString( nWhatId ); +/*N*/ rStr += ' '; +/*N*/ rStr += GetRefString( GetBigRange(), pDoc ); +/*N*/ rStr += aRsc.Copy( nPos+2 ); +/*N*/ } + + +/*N*/ BOOL ScChangeActionIns::Reject( ScDocument* pDoc ) +/*N*/ { +/*N*/ if ( !aBigRange.IsValid( pDoc ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ScRange aRange( aBigRange.MakeRange() ); +/*N*/ if ( !pDoc->IsBlockEditable( aRange.aStart.Tab(), aRange.aStart.Col(), +/*N*/ aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row() ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ pDoc->DeleteCol( aRange ); +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ pDoc->DeleteRow( aRange ); +/*N*/ break; +/*N*/ case SC_CAT_INSERT_TABS : +/*N*/ pDoc->DeleteTab( aRange.aStart.Tab() ); +/*N*/ break; +/*N*/ } +/*N*/ SetState( SC_CAS_REJECTED ); +/*N*/ RemoveAllLinks(); +/*N*/ return TRUE; +/*N*/ } + + +// --- ScChangeActionDel --------------------------------------------------- + +/*N*/ ScChangeActionDel::ScChangeActionDel( const ScRange& rRange, +/*N*/ short nDxP, short nDyP, ScChangeTrack* pTrackP ) +/*N*/ : +/*N*/ ScChangeAction( SC_CAT_NONE, rRange ), +/*N*/ pTrack( pTrackP ), +/*N*/ pFirstCell( NULL ), +/*N*/ pLinkMove( NULL ), +/*N*/ pCutOff( NULL ), +/*N*/ nCutOff( 0 ), +/*N*/ nDx( nDxP ), +/*N*/ nDy( nDyP ) +/*N*/ { +/*N*/ if ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() == MAXCOL ) +/*N*/ { +/*N*/ aBigRange.aStart.SetCol( nInt32Min ); +/*N*/ aBigRange.aEnd.SetCol( nInt32Max ); +/*N*/ if ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == MAXROW ) +/*N*/ { +/*N*/ SetType( SC_CAT_DELETE_TABS ); +/*N*/ aBigRange.aStart.SetRow( nInt32Min ); +/*N*/ aBigRange.aEnd.SetRow( nInt32Max ); +/*N*/ } +/*N*/ else +/*N*/ SetType( SC_CAT_DELETE_ROWS ); +/*N*/ } +/*N*/ else if ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == MAXROW ) +/*N*/ { +/*N*/ SetType( SC_CAT_DELETE_COLS ); +/*N*/ aBigRange.aStart.SetRow( nInt32Min ); +/*N*/ aBigRange.aEnd.SetRow( nInt32Max ); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR( "ScChangeActionDel: Block not supported!" ); +/*N*/ } + + +/*N*/ ScChangeActionDel::ScChangeActionDel( SvStream& rStrm, +/*N*/ ScMultipleReadHeader& rHdr, ScDocument* pDoc, USHORT nVer, +/*N*/ ScChangeTrack* pTrackP ) +/*N*/ : +/*N*/ ScChangeAction( rStrm, rHdr, pTrackP ), +/*N*/ pTrack( pTrackP ), +/*N*/ pFirstCell( NULL ), +/*N*/ pLinkMove( NULL ) +/*N*/ { +/*N*/ UINT32 n32; +/*N*/ INT16 n16s; +/*N*/ rStrm >> n32; pCutOff = (ScChangeActionIns*)(ULONG) n32; +/*N*/ rStrm >> n16s; nCutOff = n16s; +/*N*/ rStrm >> n16s; nDx = n16s; +/*N*/ rStrm >> n16s; nDy = n16s; +/*N*/ } + +/*N*/ ScChangeActionDel::ScChangeActionDel(const ULONG nActionNumber, const ScChangeActionState eState, const ULONG nRejectingNumber, +/*N*/ const ScBigRange& aBigRange, const String& aUser, const DateTime& aDateTime, const String &sComment, +/*N*/ const ScChangeActionType eType, const short nD, ScChangeTrack* pTrackP) // wich of nDx and nDy is set is depend on the type +/*N*/ : +/*N*/ ScChangeAction(eType, aBigRange, nActionNumber, nRejectingNumber, eState, aDateTime, aUser, sComment), +/*N*/ pTrack( pTrackP ), +/*N*/ pFirstCell( NULL ), +/*N*/ pLinkMove( NULL ), +/*N*/ pCutOff( NULL ), +/*N*/ nCutOff( 0 ), +/*N*/ nDx( 0 ), +/*N*/ nDy( 0 ) +/*N*/ { +/*N*/ if (eType == SC_CAT_DELETE_COLS) +/*N*/ nDx = nD; +/*N*/ else if (eType == SC_CAT_DELETE_ROWS) +/*N*/ nDy = nD; +/*N*/ } + +/*N*/ ScChangeActionDel::~ScChangeActionDel() +/*N*/ { +/*N*/ DeleteCellEntries(); +/*N*/ while ( pLinkMove ) +/*N*/ delete pLinkMove; +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::Store( SvStream& rStrm, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::Store( rStrm, rHdr ); +/*N*/ rStrm << (UINT32) ( pCutOff ? pCutOff->GetActionNumber() : 0 ); +/*N*/ rStrm << (INT16) nCutOff; +/*N*/ rStrm << (INT16) nDx; +/*N*/ rStrm << (INT16) nDy; +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::StoreLinks( SvStream& rStrm ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::StoreLinks( rStrm ); +/*N*/ UINT32 nCount = 0; +/*N*/ if ( pLinkMove ) +/*N*/ { +/*N*/ // rueckwaerts speichern, damit onLoad mit Insert die Reihenfolge wieder stimmt +/*N*/ Stack* pStack = new Stack; +/*N*/ for ( ScChangeActionDelMoveEntry* pL = pLinkMove; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ++nCount; +/*N*/ pStack->Push( pL ); +/*N*/ } +/*N*/ rStrm << nCount; +/*N*/ ScChangeActionDelMoveEntry* pHere; +/*N*/ while ( pHere = (ScChangeActionDelMoveEntry*) pStack->Pop() ) +/*N*/ { +/*N*/ ScChangeAction* p = pHere->GetAction(); +/*N*/ rStrm << (UINT32) ( p ? p->GetActionNumber() : 0 ); +/*N*/ rStrm << (INT16) pHere->GetCutOffFrom(); +/*N*/ rStrm << (INT16) pHere->GetCutOffTo(); +/*N*/ } +/*N*/ delete pStack; +/*N*/ } +/*N*/ else +/*N*/ rStrm << nCount; +/*N*/ +/*N*/ bOk &= ScChangeAction::StoreCellList( pFirstCell, rStrm ); +/*N*/ +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::LoadLinks( SvStream& rStrm, ScChangeTrack* pTrack ) +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::LoadLinks( rStrm, pTrack ); +/*N*/ UINT32 nCount; +/*N*/ rStrm >> nCount; +/*N*/ for ( UINT32 j = 0; j < nCount; j++ ) +/*N*/ { +/*N*/ ScChangeActionMove* pAct = NULL; +/*N*/ UINT32 nAct; +/*N*/ rStrm >> nAct; +/*N*/ if ( nAct ) +/*N*/ { +/*N*/ pAct = (ScChangeActionMove*) pTrack->GetAction( nAct ); +/*N*/ DBG_ASSERT( pAct, "ScChangeActionDel::LoadLinks: missing Move" ); +/*N*/ } +/*N*/ INT16 nFrom, nTo; +/*N*/ rStrm >> nFrom >> nTo; +/*N*/ ScChangeActionDelMoveEntry* pLink = new ScChangeActionDelMoveEntry( +/*N*/ &pLinkMove, pAct, nFrom, nTo ); +/*N*/ if ( pAct ) +/*N*/ pAct->AddLink( this, pLink ); +/*N*/ } +/*N*/ if ( pCutOff ) +/*N*/ { +/*N*/ pCutOff = (ScChangeActionIns*) pTrack->GetAction( (ULONG) pCutOff ); +/*N*/ DBG_ASSERT( pCutOff, "ScChangeActionDel::LoadLinks: missing Insert" ); +/*N*/ } +/*N*/ +/*N*/ bOk &= ScChangeAction::LoadCellList( this, pFirstCell, rStrm, pTrack ); +/*N*/ +/*N*/ return bOk; +/*N*/ } + +/*N*/ void ScChangeActionDel::AddContent( ScChangeActionContent* pContent ) +/*N*/ { +/*N*/ ScChangeActionCellListEntry* pE = new ScChangeActionCellListEntry( +/*N*/ pContent, pFirstCell ); +/*N*/ pFirstCell = pE; +/*N*/ } + + +/*N*/ void ScChangeActionDel::DeleteCellEntries() +/*N*/ { +/*N*/ pTrack->DeleteCellEntries( pFirstCell, this ); +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::IsBaseDelete() const +/*N*/ { +/*N*/ return !GetDx() && !GetDy(); +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::IsTopDelete() const +/*N*/ { +/*N*/ const ScChangeAction* p = GetNext(); +/*N*/ if ( !p || p->GetType() != GetType() ) +/*N*/ return TRUE; +/*N*/ return ((ScChangeActionDel*)p)->IsBaseDelete(); +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::IsMultiDelete() const +/*N*/ { +/*N*/ if ( GetDx() || GetDy() ) +/*N*/ return TRUE; +/*N*/ const ScChangeAction* p = GetNext(); +/*N*/ if ( !p || p->GetType() != GetType() ) +/*N*/ return FALSE; +/*N*/ const ScChangeActionDel* pDel = (const ScChangeActionDel*) p; +/*N*/ if ( (pDel->GetDx() > GetDx() || pDel->GetDy() > GetDy()) && +/*N*/ pDel->GetBigRange() == aBigRange ) +/*N*/ return TRUE; +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScChangeActionDel::UpdateReference( const ScChangeTrack* pTrack, +/*N*/ UpdateRefMode eMode, const ScBigRange& rRange, +/*N*/ INT32 nDx, INT32 nDy, INT32 nDz ) +/*N*/ { +/*N*/ ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, GetBigRange() ); +/*N*/ if ( !IsDeletedIn() ) +/*N*/ return ; +/*N*/ // evtl. in "druntergerutschten" anpassen +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkDeleted; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeAction* p = pL->GetAction(); +/*N*/ if ( p && p->GetType() == SC_CAT_CONTENT && +/*N*/ !GetBigRange().In( p->GetBigRange() ) ) +/*N*/ { +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ p->GetBigRange().aStart.SetCol( GetBigRange().aStart.Col() ); +/*N*/ p->GetBigRange().aEnd.SetCol( GetBigRange().aStart.Col() ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ p->GetBigRange().aStart.SetRow( GetBigRange().aStart.Row() ); +/*N*/ p->GetBigRange().aEnd.SetRow( GetBigRange().aStart.Row() ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ p->GetBigRange().aStart.SetTab( GetBigRange().aStart.Tab() ); +/*N*/ p->GetBigRange().aEnd.SetTab( GetBigRange().aStart.Tab() ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ ScBigRange ScChangeActionDel::GetOverAllRange() const +/*N*/ { +/*N*/ ScBigRange aTmpRange( GetBigRange() ); +/*N*/ aTmpRange.aEnd.SetCol( aTmpRange.aEnd.Col() + GetDx() ); +/*N*/ aTmpRange.aEnd.SetRow( aTmpRange.aEnd.Row() + GetDy() ); +/*N*/ return aTmpRange; +/*N*/ } + + +/*N*/ void ScChangeActionDel::GetDescription( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bSplitRange ) const +/*N*/ { +/*N*/ USHORT nWhatId; +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ nWhatId = STR_COLUMN; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ nWhatId = STR_ROW; +/*N*/ break; +/*N*/ default: +/*N*/ nWhatId = STR_AREA; +/*N*/ } +/*N*/ +/*N*/ ScBigRange aTmpRange( GetBigRange() ); +/*N*/ if ( !IsRejected() ) +/*N*/ { +/*N*/ if ( bSplitRange ) +/*N*/ { +/*N*/ aTmpRange.aStart.SetCol( aTmpRange.aStart.Col() + GetDx() ); +/*N*/ aTmpRange.aStart.SetRow( aTmpRange.aStart.Row() + GetDy() ); +/*N*/ } +/*N*/ aTmpRange.aEnd.SetCol( aTmpRange.aEnd.Col() + GetDx() ); +/*N*/ aTmpRange.aEnd.SetRow( aTmpRange.aEnd.Row() + GetDy() ); +/*N*/ } +/*N*/ +/*N*/ String aRsc( ScGlobal::GetRscString( STR_CHANGED_DELETE ) ); +/*N*/ xub_StrLen nPos = aRsc.SearchAscii( "#1" ); +/*N*/ rStr += aRsc.Copy( 0, nPos ); +/*N*/ rStr += ScGlobal::GetRscString( nWhatId ); +/*N*/ rStr += ' '; +/*N*/ rStr += GetRefString( aTmpRange, pDoc ); +/*N*/ rStr += aRsc.Copy( nPos+2 ); +/*N*/ } + + +/*N*/ BOOL ScChangeActionDel::Reject( ScDocument* pDoc ) +/*N*/ { +/*N*/ if ( !aBigRange.IsValid( pDoc ) && GetType() != SC_CAT_DELETE_TABS ) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bOk = TRUE; +/*N*/ +/*N*/ if ( IsTopDelete() ) +/*N*/ { // den kompletten Bereich in einem Rutsch restaurieren +/*N*/ ScBigRange aTmpRange( GetOverAllRange() ); +/*N*/ if ( !aTmpRange.IsValid( pDoc ) ) +/*N*/ { +/*N*/ if ( GetType() == SC_CAT_DELETE_TABS ) +/*N*/ { // wird Tab angehaengt? +/*N*/ if ( aTmpRange.aStart.Tab() > pDoc->GetMaxTableNumber() ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ else +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ if ( bOk ) +/*N*/ { +/*N*/ ScRange aRange( aTmpRange.MakeRange() ); +/*N*/ // InDelete... fuer Formel UpdateReference in Document +/*N*/ pTrack->SetInDeleteRange( aRange ); +/*N*/ pTrack->SetInDeleteTop( TRUE ); +/*N*/ pTrack->SetInDeleteUndo( TRUE ); +/*N*/ pTrack->SetInDelete( TRUE ); +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ if ( !(aRange.aStart.Col() == 0 && aRange.aEnd.Col() == MAXCOL) ) +/*N*/ { // nur wenn nicht TabDelete +/*N*/ if ( bOk = pDoc->CanInsertCol( aRange ) ) +/*N*/ bOk = pDoc->InsertCol( aRange ); +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ if ( bOk = pDoc->CanInsertRow( aRange ) ) +/*N*/ bOk = pDoc->InsertRow( aRange ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ { +/*N*/ //2do: Tabellennamen merken? +/*N*/ String aName; +/*N*/ pDoc->CreateValidTabName( aName ); +/*N*/ if ( bOk = pDoc->ValidNewTabName( aName ) ) +/*N*/ bOk = pDoc->InsertTab( aRange.aStart.Tab(), aName ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ pTrack->SetInDelete( FALSE ); +/*N*/ pTrack->SetInDeleteUndo( FALSE ); +/*N*/ } +/*N*/ if ( !bOk ) +/*N*/ { +/*N*/ pTrack->SetInDeleteTop( FALSE ); +/*N*/ return FALSE; +/*N*/ } +/*N*/ // InDeleteTop fuer UpdateReference-Undo behalten +/*N*/ } +/*N*/ +/*N*/ // setzt rejected und ruft UpdateReference-Undo und DeleteCellEntries +/*N*/ RejectRestoreContents( pTrack, GetDx(), GetDy() ); +/*N*/ +/*N*/ pTrack->SetInDeleteTop( FALSE ); +/*N*/ RemoveAllLinks(); +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ void ScChangeActionDel::UndoCutOffMoves() +/*N*/ { // abgeschnittene Moves wiederherstellen, Entries/Links deleten +/*N*/ while ( pLinkMove ) +/*N*/ { +/*N*/ ScChangeActionMove* pMove = pLinkMove->GetMove(); +/*N*/ short nFrom = pLinkMove->GetCutOffFrom(); +/*N*/ short nTo = pLinkMove->GetCutOffTo(); +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ if ( nFrom > 0 ) +/*N*/ pMove->GetFromRange().aStart.IncCol( -nFrom ); +/*N*/ else if ( nFrom < 0 ) +/*N*/ pMove->GetFromRange().aEnd.IncCol( -nFrom ); +/*N*/ if ( nTo > 0 ) +/*N*/ pMove->GetBigRange().aStart.IncCol( -nTo ); +/*N*/ else if ( nTo < 0 ) +/*N*/ pMove->GetBigRange().aEnd.IncCol( -nTo ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ if ( nFrom > 0 ) +/*N*/ pMove->GetFromRange().aStart.IncRow( -nFrom ); +/*N*/ else if ( nFrom < 0 ) +/*N*/ pMove->GetFromRange().aEnd.IncRow( -nFrom ); +/*N*/ if ( nTo > 0 ) +/*N*/ pMove->GetBigRange().aStart.IncRow( -nTo ); +/*N*/ else if ( nTo < 0 ) +/*N*/ pMove->GetBigRange().aEnd.IncRow( -nTo ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ if ( nFrom > 0 ) +/*N*/ pMove->GetFromRange().aStart.IncTab( -nFrom ); +/*N*/ else if ( nFrom < 0 ) +/*N*/ pMove->GetFromRange().aEnd.IncTab( -nFrom ); +/*N*/ if ( nTo > 0 ) +/*N*/ pMove->GetBigRange().aStart.IncTab( -nTo ); +/*N*/ else if ( nTo < 0 ) +/*N*/ pMove->GetBigRange().aEnd.IncTab( -nTo ); +/*N*/ break; +/*N*/ } +/*N*/ delete pLinkMove; // rueckt sich selbst hoch +/*N*/ } +/*N*/ } + +/*N*/ void ScChangeActionDel::UndoCutOffInsert() +/*N*/ { // abgeschnittenes Insert wiederherstellen +/*N*/ if ( pCutOff ) +/*N*/ { +/*N*/ switch ( pCutOff->GetType() ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ if ( nCutOff < 0 ) +/*N*/ pCutOff->GetBigRange().aEnd.IncCol( -nCutOff ); +/*N*/ else +/*N*/ pCutOff->GetBigRange().aStart.IncCol( -nCutOff ); +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ if ( nCutOff < 0 ) +/*N*/ pCutOff->GetBigRange().aEnd.IncRow( -nCutOff ); +/*N*/ else +/*N*/ pCutOff->GetBigRange().aStart.IncRow( -nCutOff ); +/*N*/ break; +/*N*/ case SC_CAT_INSERT_TABS : +/*N*/ if ( nCutOff < 0 ) +/*N*/ pCutOff->GetBigRange().aEnd.IncTab( -nCutOff ); +/*N*/ else +/*N*/ pCutOff->GetBigRange().aStart.IncTab( -nCutOff ); +/*N*/ break; +/*N*/ } +/*N*/ SetCutOffInsert( NULL, 0 ); +/*N*/ } +/*N*/ } + + +// --- ScChangeActionMove -------------------------------------------------- + +/*N*/ ScChangeActionMove::ScChangeActionMove( SvStream& rStrm, +/*N*/ ScMultipleReadHeader& rHdr, ScChangeTrack* pTrackP ) +/*N*/ : +/*N*/ ScChangeAction( rStrm, rHdr, pTrackP ), +/*N*/ pTrack( pTrackP ), +/*N*/ pFirstCell( NULL ), +/*N*/ nStartLastCut(0), +/*N*/ nEndLastCut(0) +/*N*/ { +/*N*/ rStrm >> aFromRange; +/*N*/ } + +/*N*/ ScChangeActionMove::ScChangeActionMove(const ULONG nActionNumber, const ScChangeActionState eState, const ULONG nRejectingNumber, +/*N*/ const ScBigRange& aToBigRange, const String& aUser, const DateTime& aDateTime, const String &sComment, +/*N*/ const ScBigRange& aFromBigRange, ScChangeTrack* pTrackP) // wich of nDx and nDy is set is depend on the type +/*N*/ : +/*N*/ ScChangeAction(SC_CAT_MOVE, aToBigRange, nActionNumber, nRejectingNumber, eState, aDateTime, aUser, sComment), +/*N*/ aFromRange(aFromBigRange), +/*N*/ pTrack( pTrackP ), +/*N*/ pFirstCell( NULL ), +/*N*/ nStartLastCut(0), +/*N*/ nEndLastCut(0) +/*N*/ { +/*N*/ } + +/*N*/ ScChangeActionMove::~ScChangeActionMove() +/*N*/ { +/*N*/ DeleteCellEntries(); +/*N*/ } + + +/*N*/ BOOL ScChangeActionMove::Store( SvStream& rStrm, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::Store( rStrm, rHdr ); +/*N*/ rStrm << aFromRange; +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeActionMove::StoreLinks( SvStream& rStrm ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::StoreLinks( rStrm ); +/*N*/ bOk &= ScChangeAction::StoreCellList( pFirstCell, rStrm ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeActionMove::LoadLinks( SvStream& rStrm, ScChangeTrack* pTrack ) +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::LoadLinks( rStrm, pTrack ); +/*N*/ bOk &= ScChangeAction::LoadCellList( this, pFirstCell, rStrm, pTrack ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ void ScChangeActionMove::AddContent( ScChangeActionContent* pContent ) +/*N*/ { +/*N*/ ScChangeActionCellListEntry* pE = new ScChangeActionCellListEntry( +/*N*/ pContent, pFirstCell ); +/*N*/ pFirstCell = pE; +/*N*/ } + + +/*N*/ void ScChangeActionMove::DeleteCellEntries() +/*N*/ { +/*N*/ pTrack->DeleteCellEntries( pFirstCell, this ); +/*N*/ } + + +/*N*/ void ScChangeActionMove::UpdateReference( const ScChangeTrack* pTrack, +/*N*/ UpdateRefMode eMode, const ScBigRange& rRange, +/*N*/ INT32 nDx, INT32 nDy, INT32 nDz ) +/*N*/ { +/*N*/ ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, aFromRange ); +/*N*/ ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, GetBigRange() ); +/*N*/ } + + +/*N*/ void ScChangeActionMove::GetDelta( INT32& nDx, INT32& nDy, INT32& nDz ) const +/*N*/ { +/*N*/ const ScBigAddress& rToPos = GetBigRange().aStart; +/*N*/ const ScBigAddress& rFromPos = GetFromRange().aStart; +/*N*/ nDx = rToPos.Col() - rFromPos.Col(); +/*N*/ nDy = rToPos.Row() - rFromPos.Row(); +/*N*/ nDz = rToPos.Tab() - rFromPos.Tab(); +/*N*/ } + + +/*N*/ void ScChangeActionMove::GetDescription( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bSplitRange ) const +/*N*/ { +/*N*/ BOOL bFlag3D = ( GetFromRange().aStart.Tab() != GetBigRange().aStart.Tab() ); +/*N*/ +/*N*/ String aRsc( ScGlobal::GetRscString( STR_CHANGED_MOVE ) ); +/*N*/ +/*N*/ xub_StrLen nPos = 0; +/*N*/ String aTmpStr = ScChangeAction::GetRefString( GetFromRange(), pDoc, bFlag3D ); +/*N*/ nPos = aRsc.SearchAscii( "#1", nPos ); +/*N*/ aRsc.Erase( nPos, 2 ); +/*N*/ aRsc.Insert( aTmpStr, nPos ); +/*N*/ nPos += aTmpStr.Len(); +/*N*/ +/*N*/ aTmpStr = ScChangeAction::GetRefString( GetBigRange(), pDoc, bFlag3D ); +/*N*/ nPos = aRsc.SearchAscii( "#2", nPos ); +/*N*/ aRsc.Erase( nPos, 2 ); +/*N*/ aRsc.Insert( aTmpStr, nPos ); +/*N*/ nPos += aTmpStr.Len(); +/*N*/ +/*N*/ rStr += aRsc; +/*N*/ } + + +/*N*/ void ScChangeActionMove::GetRefString( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bFlag3D ) const +/*N*/ { +/*N*/ if ( !bFlag3D ) +/*N*/ bFlag3D = ( GetFromRange().aStart.Tab() != GetBigRange().aStart.Tab() ); +/*N*/ rStr = ScChangeAction::GetRefString( GetFromRange(), pDoc, bFlag3D ); +/*N*/ rStr += ','; +/*N*/ rStr += ' '; +/*N*/ rStr += ScChangeAction::GetRefString( GetBigRange(), pDoc, bFlag3D ); +/*N*/ } + + +/*N*/ BOOL ScChangeActionMove::Reject( ScDocument* pDoc ) +/*N*/ { +/*N*/ if ( !(aBigRange.IsValid( pDoc ) && aFromRange.IsValid( pDoc )) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ScRange aToRange( aBigRange.MakeRange() ); +/*N*/ ScRange aFrmRange( aFromRange.MakeRange() ); +/*N*/ +/*N*/ BOOL bOk = pDoc->IsBlockEditable( aToRange.aStart.Tab(), +/*N*/ aToRange.aStart.Col(), aToRange.aStart.Row(), +/*N*/ aToRange.aEnd.Col(), aToRange.aEnd.Row() ); +/*N*/ if ( bOk ) +/*N*/ bOk = pDoc->IsBlockEditable( aFrmRange.aStart.Tab(), +/*N*/ aFrmRange.aStart.Col(), aFrmRange.aStart.Row(), +/*N*/ aFrmRange.aEnd.Col(), aFrmRange.aEnd.Row() ); +/*N*/ if ( !bOk ) +/*N*/ return FALSE; +/*N*/ +/*N*/ pTrack->LookUpContents( aToRange, pDoc, 0, 0, 0 ); // zu movende Contents +/*N*/ +/*N*/ pDoc->DeleteAreaTab( aToRange, IDF_ALL ); +/*N*/ pDoc->DeleteAreaTab( aFrmRange, IDF_ALL ); +/*N*/ // Formeln im Dokument anpassen +/*N*/ pDoc->UpdateReference( URM_MOVE, +/*N*/ aFrmRange.aStart.Col(), aFrmRange.aStart.Row(), aFrmRange.aStart.Tab(), +/*N*/ aFrmRange.aEnd.Col(), aFrmRange.aEnd.Row(), aFrmRange.aEnd.Tab(), +/*N*/ (short) aFrmRange.aStart.Col() - aToRange.aStart.Col(), +/*N*/ (short) aFrmRange.aStart.Row() - aToRange.aStart.Row(), +/*N*/ (short) aFrmRange.aStart.Tab() - aToRange.aStart.Tab(), NULL ); +/*N*/ +/*N*/ // LinkDependent freigeben, nachfolgendes UpdateReference-Undo setzt +/*N*/ // ToRange->FromRange Dependents +/*N*/ RemoveAllDependent(); +/*N*/ +/*N*/ // setzt rejected und ruft UpdateReference-Undo und DeleteCellEntries +/*N*/ RejectRestoreContents( pTrack, 0, 0 ); +/*N*/ +/*N*/ while ( pLinkDependent ) +/*N*/ { +/*N*/ ScChangeAction* p = pLinkDependent->GetAction(); +/*N*/ if ( p && p->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent = (ScChangeActionContent*) p; +/*N*/ if ( !pContent->IsDeletedIn() && +/*N*/ pContent->GetBigRange().aStart.IsValid( pDoc ) ) +/*N*/ pContent->PutNewValueToDoc( pDoc, 0, 0 ); +/*N*/ // in LookUpContents generierte loeschen +/*N*/ if ( pTrack->IsGenerated( pContent->GetActionNumber() ) && +/*N*/ !pContent->IsDeletedIn() ) +/*N*/ { +/*N*/ pLinkDependent->UnLink(); //! sonst wird der mitgeloescht +/*N*/ pTrack->DeleteGeneratedDelContent( pContent ); +/*N*/ } +/*N*/ } +/*N*/ delete pLinkDependent; +/*N*/ } +/*N*/ +/*N*/ RemoveAllLinks(); +/*N*/ return TRUE; +/*N*/ } + + +// --- ScChangeActionContent ----------------------------------------------- + +const USHORT nMemPoolChangeActionContent = (0x8000 - 64) / sizeof(ScChangeActionContent); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScChangeActionContent, nMemPoolChangeActionContent, nMemPoolChangeActionContent )//STRIP008 ; + + +/*N*/ ScChangeActionContent::ScChangeActionContent( SvStream& rStrm, +/*N*/ ScMultipleReadHeader& rHdr, ScDocument* pDoc, USHORT nVer, +/*N*/ ScChangeTrack* pTrack ) +/*N*/ : +/*N*/ ScChangeAction( rStrm, rHdr, pTrack ), +/*N*/ pNextInSlot( NULL ), +/*N*/ ppPrevInSlot( NULL ) +/*N*/ { +/*N*/ UINT32 n32; // Changetracking.sdc +/*N*/ rStrm.ReadByteString( aOldValue, rStrm.GetStreamCharSet() ); +/*N*/ rStrm.ReadByteString( aNewValue, rStrm.GetStreamCharSet() ); +/*N*/ rStrm >> n32; pNextContent = (ScChangeActionContent*)(ULONG) n32; +/*N*/ rStrm >> n32; pPrevContent = (ScChangeActionContent*)(ULONG) n32; +/*N*/ +/*N*/ { +/*N*/ ScMultipleReadHeader aDataHdr( rStrm ); +/*N*/ pOldCell = ScChangeAction::LoadCell( rStrm, aDataHdr, pDoc, nVer ); +/*N*/ pNewCell = ScChangeAction::LoadCell( rStrm, aDataHdr, pDoc, nVer ); +/*N*/ } +/*N*/ } + +/*N*/ ScChangeActionContent::ScChangeActionContent( const ULONG nActionNumber, +/*N*/ const ScChangeActionState eState, const ULONG nRejectingNumber, +/*N*/ const ScBigRange& aBigRange, const String& aUser, +/*N*/ const DateTime& aDateTime, const String& sComment, +/*N*/ ScBaseCell* pTempOldCell, ScDocument* pDoc, const String& sResult ) +/*N*/ : +/*N*/ ScChangeAction(SC_CAT_CONTENT, aBigRange, nActionNumber, nRejectingNumber, eState, aDateTime, aUser, sComment), +/*N*/ pOldCell(pTempOldCell), +/*N*/ pNewCell(NULL), +/*N*/ pNextContent(NULL), +/*N*/ pPrevContent(NULL), +/*N*/ pNextInSlot(NULL), +/*N*/ ppPrevInSlot(NULL), +/*N*/ aOldValue(sResult) +/*N*/ +/*N*/ { +/*N*/ if (pOldCell) +/*N*/ ScChangeActionContent::SetCell( aOldValue, pOldCell, 0, pDoc ); +/*N*/ } + +/*N*/ ScChangeActionContent::ScChangeActionContent( const ULONG nActionNumber, +/*N*/ ScBaseCell* pTempNewCell, const ScBigRange& aBigRange, +/*N*/ ScDocument* pDoc ) +/*N*/ : +/*N*/ ScChangeAction(SC_CAT_CONTENT, aBigRange, nActionNumber), +/*N*/ pNewCell(pTempNewCell), +/*N*/ pOldCell(NULL), +/*N*/ pNextContent(NULL), +/*N*/ pPrevContent(NULL), +/*N*/ pNextInSlot(NULL), +/*N*/ ppPrevInSlot(NULL) +/*N*/ { +/*N*/ if (pNewCell) +/*N*/ ScChangeActionContent::SetCell( aNewValue, pNewCell, 0, pDoc ); +/*N*/ } + +/*N*/ ScChangeActionContent::~ScChangeActionContent() +/*N*/ { +/*N*/ ClearTrack(); +/*N*/ } + + +/*N*/ void ScChangeActionContent::ClearTrack() +/*N*/ { +/*N*/ RemoveFromSlot(); +/*N*/ if ( pPrevContent ) +/*N*/ pPrevContent->pNextContent = pNextContent; +/*N*/ if ( pNextContent ) +/*N*/ pNextContent->pPrevContent = pPrevContent; +/*N*/ } + + +/*N*/ BOOL ScChangeActionContent::Store( SvStream& rStrm, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::Store( rStrm, rHdr ); +/*N*/ rStrm.WriteByteString( aOldValue, rStrm.GetStreamCharSet() ); +/*N*/ rStrm.WriteByteString( aNewValue, rStrm.GetStreamCharSet() ); +/*N*/ rStrm << (UINT32) ( pNextContent ? pNextContent->GetActionNumber() : 0 ); +/*N*/ rStrm << (UINT32) ( pPrevContent ? pPrevContent->GetActionNumber() : 0 ); +/*N*/ +/*N*/ { +/*N*/ ScMultipleWriteHeader aDataHdr( rStrm ); +/*N*/ ScChangeAction::StoreCell( pOldCell, rStrm, aDataHdr ); +/*N*/ ScChangeAction::StoreCell( pNewCell, rStrm, aDataHdr ); +/*N*/ } +/*N*/ +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeActionContent::StoreLinks( SvStream& rStrm ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::StoreLinks( rStrm ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeActionContent::LoadLinks( SvStream& rStrm, ScChangeTrack* pTrack ) +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::LoadLinks( rStrm, pTrack ); +/*N*/ if ( pNextContent ) +/*N*/ { +/*N*/ pNextContent = (ScChangeActionContent*) pTrack->GetAction( +/*N*/ (ULONG) pNextContent ); +/*N*/ DBG_ASSERT( pNextContent, +/*N*/ "ScChangeActionContent::LoadLinks: missing NextContent" ); +/*N*/ } +/*N*/ if ( pPrevContent ) +/*N*/ { +/*N*/ pPrevContent = (ScChangeActionContent*) pTrack->GetAction( +/*N*/ (ULONG) pPrevContent ); +/*N*/ DBG_ASSERT( pPrevContent, +/*N*/ "ScChangeActionContent::LoadLinks: missing PrevContent" ); +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ ScChangeActionContent* ScChangeActionContent::GetTopContent() const // Changetracking.sdc +/*N*/ { +/*N*/ if ( pNextContent ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent = pNextContent; +/*N*/ while ( pContent->pNextContent ) +/*N*/ pContent = pContent->pNextContent; +/*N*/ return pContent; +/*N*/ } +/*N*/ return (ScChangeActionContent*) this; +/*N*/ } + + +/*N*/ ScChangeActionLinkEntry* ScChangeActionContent::GetDeletedIn() const +/*N*/ { +/*N*/ if ( pNextContent ) +/*N*/ return GetTopContent()->pLinkDeletedIn; +/*N*/ return pLinkDeletedIn; +/*N*/ } + + +/*N*/ ScChangeActionLinkEntry** ScChangeActionContent::GetDeletedInAddress() +/*N*/ { +/*N*/ if ( pNextContent ) +/*N*/ return GetTopContent()->GetDeletedInAddress(); +/*N*/ return &pLinkDeletedIn; +/*N*/ } + + +/*N*/ void ScChangeActionContent::SetOldValue( const ScBaseCell* pCell, +/*N*/ const ScDocument* pFromDoc, ScDocument* pToDoc ) +/*N*/ { +/*N*/ ScChangeActionContent::SetValue( aOldValue, pOldCell, +/*N*/ aBigRange.aStart.MakeAddress(), pCell, pFromDoc, pToDoc ); +/*N*/ } + + +/*N*/ void ScChangeActionContent::SetNewValue( const ScBaseCell* pCell, +/*N*/ ScDocument* pDoc ) +/*N*/ { +/*N*/ ScChangeActionContent::SetValue( aNewValue, pNewCell, +/*N*/ aBigRange.aStart.MakeAddress(), pCell, pDoc, pDoc ); +/*N*/ } + + +/*N*/ void ScChangeActionContent::SetNewCell( ScBaseCell* pCell, ScDocument* pDoc ) +/*N*/ { +/*N*/ DBG_ASSERT( !pNewCell, "ScChangeActionContent::SetNewCell: overwriting existing cell" ); +/*N*/ pNewCell = pCell; +/*N*/ ScChangeActionContent::SetCell( aNewValue, pNewCell, 0, pDoc ); +/*N*/ } + +/*N*/ void ScChangeActionContent::GetOldString( String& rStr ) const +/*N*/ { +/*N*/ GetValueString( rStr, aOldValue, pOldCell ); +/*N*/ } + + +/*N*/ void ScChangeActionContent::GetNewString( String& rStr ) const +/*N*/ { +/*N*/ GetValueString( rStr, aNewValue, pNewCell ); +/*N*/ } + + +/*N*/ void ScChangeActionContent::GetDescription( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bSplitRange ) const +/*N*/ { +/*N*/ +/*N*/ String aRsc( ScGlobal::GetRscString( STR_CHANGED_CELL ) ); +/*N*/ +/*N*/ String aTmpStr; +/*N*/ GetRefString( aTmpStr, pDoc ); +/*N*/ +/*N*/ xub_StrLen nPos = 0; +/*N*/ nPos = aRsc.SearchAscii( "#1", nPos ); +/*N*/ aRsc.Erase( nPos, 2 ); +/*N*/ aRsc.Insert( aTmpStr, nPos ); +/*N*/ nPos += aTmpStr.Len(); +/*N*/ +/*N*/ GetOldString( aTmpStr ); +/*N*/ if ( !aTmpStr.Len() ) +/*N*/ aTmpStr = ScGlobal::GetRscString( STR_CHANGED_BLANK ); +/*N*/ nPos = aRsc.SearchAscii( "#2", nPos ); +/*N*/ aRsc.Erase( nPos, 2 ); +/*N*/ aRsc.Insert( aTmpStr, nPos ); +/*N*/ nPos += aTmpStr.Len(); +/*N*/ +/*N*/ GetNewString( aTmpStr ); +/*N*/ if ( !aTmpStr.Len() ) +/*N*/ aTmpStr = ScGlobal::GetRscString( STR_CHANGED_BLANK ); +/*N*/ nPos = aRsc.SearchAscii( "#3", nPos ); +/*N*/ aRsc.Erase( nPos, 2 ); +/*N*/ aRsc.Insert( aTmpStr, nPos ); +/*N*/ +/*N*/ rStr += aRsc; +/*N*/ } + + +/*N*/ void ScChangeActionContent::GetRefString( String& rStr, ScDocument* pDoc, +/*N*/ BOOL bFlag3D ) const +/*N*/ { +/*N*/ USHORT nFlags = ( GetBigRange().IsValid( pDoc ) ? SCA_VALID : 0 ); +/*N*/ if ( nFlags ) +/*N*/ { +/*N*/ const ScBaseCell* pCell = GetNewCell(); +/*N*/ if ( ScChangeActionContent::GetContentCellType( pCell ) == SC_CACCT_MATORG ) +/*N*/ { +/*N*/ ScBigRange aBigRange( GetBigRange() ); +/*N*/ USHORT nC, nR; +/*N*/ ((const ScFormulaCell*)pCell)->GetMatColsRows( nC, nR ); +/*N*/ aBigRange.aEnd.IncCol( nC-1 ); +/*N*/ aBigRange.aEnd.IncRow( nR-1 ); +/*N*/ rStr = ScChangeAction::GetRefString( aBigRange, pDoc, bFlag3D ); +/*N*/ +/*N*/ return ; +/*N*/ } +/*N*/ +/*N*/ ScAddress aTmpAddress( GetBigRange().aStart.MakeAddress() ); +/*N*/ if ( bFlag3D ) +/*N*/ nFlags |= SCA_TAB_3D; +/*N*/ aTmpAddress.Format( rStr, nFlags, pDoc ); +/*N*/ if ( IsDeletedIn() ) +/*N*/ { +/*N*/ rStr.Insert( '(', 0 ); +/*N*/ rStr += ')'; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ rStr = ScGlobal::GetRscString( STR_NOREF_STR ); +/*N*/ } + + +/*N*/ BOOL ScChangeActionContent::Reject( ScDocument* pDoc ) +/*N*/ { +/*N*/ if ( !aBigRange.IsValid( pDoc ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ PutOldValueToDoc( pDoc, 0, 0 ); +/*N*/ +/*N*/ SetState( SC_CAS_REJECTED ); +/*N*/ RemoveAllLinks(); +/*N*/ +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ ScChangeActionContentCellType ScChangeActionContent::GetContentCellType( const ScBaseCell* pCell ) +/*N*/ { +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ switch ( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : +/*N*/ case CELLTYPE_STRING : +/*N*/ case CELLTYPE_EDIT : +/*N*/ return SC_CACCT_NORMAL; +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA : +/*N*/ switch ( ((const ScFormulaCell*)pCell)->GetMatrixFlag() ) +/*N*/ { +/*N*/ case MM_NONE : +/*N*/ return SC_CACCT_NORMAL; +/*N*/ break; +/*N*/ case MM_FORMULA : +/*N*/ case MM_FAKE : +/*N*/ return SC_CACCT_MATORG; +/*N*/ break; +/*N*/ case MM_REFERENCE : +/*N*/ return SC_CACCT_MATREF; +/*N*/ break; +/*N*/ } +/*N*/ return SC_CACCT_NORMAL; +/*N*/ break; +/*N*/ default: +/*N*/ return SC_CACCT_NONE; +/*N*/ } +/*N*/ } +/*N*/ return SC_CACCT_NONE; +/*N*/ } + + +// static +/*N*/ BOOL ScChangeActionContent::NeedsNumberFormat( const ScBaseCell* pCell ) +/*N*/ { +/*N*/ return pCell && pCell->GetCellType() == CELLTYPE_VALUE; +/*N*/ } + + +// static +/*N*/ void ScChangeActionContent::SetValue( String& rStr, ScBaseCell*& pCell, +/*N*/ const ScAddress& rPos, const ScBaseCell* pOrgCell, +/*N*/ const ScDocument* pFromDoc, ScDocument* pToDoc ) +/*N*/ { +/*N*/ if ( ScChangeActionContent::NeedsNumberFormat( pOrgCell ) ) +/*N*/ ScChangeActionContent::SetValue( rStr, pCell, +/*N*/ pFromDoc->GetNumberFormat( rPos ), pOrgCell, pFromDoc, pToDoc ); +/*N*/ else +/*N*/ ScChangeActionContent::SetValue( rStr, pCell, +/*N*/ 0, pOrgCell, pFromDoc, pToDoc ); +/*N*/ } + + +// static +/*N*/ void ScChangeActionContent::SetValue( String& rStr, ScBaseCell*& pCell, +/*N*/ ULONG nFormat, const ScBaseCell* pOrgCell, +/*N*/ const ScDocument* pFromDoc, ScDocument* pToDoc ) +/*N*/ { +/*N*/ rStr.Erase(); +/*N*/ if ( pCell ) +/*N*/ pCell->Delete(); +/*N*/ if ( ScChangeActionContent::GetContentCellType( pOrgCell ) ) +/*N*/ { +/*N*/ pCell = pOrgCell->Clone( pToDoc ); +/*N*/ switch ( pOrgCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : +/*N*/ { // z.B. Datum auch als solches merken +/*N*/ double nValue = ((ScValueCell*)pOrgCell)->GetValue(); +/*N*/ pFromDoc->GetFormatTable()->GetInputLineString( nValue, +/*N*/ nFormat, rStr ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA : +/*N*/ ((ScFormulaCell*)pCell)->SetInChangeTrack( TRUE ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ pCell = NULL; +/*N*/ } + + +// static +/*N*/ void ScChangeActionContent::SetCell( String& rStr, ScBaseCell* pCell, +/*N*/ ULONG nFormat, const ScDocument* pDoc ) +/*N*/ { +/*N*/ rStr.Erase(); +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ switch ( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : +/*N*/ { // e.g. remember date as date string +/*N*/ double nValue = ((ScValueCell*)pCell)->GetValue(); +/*N*/ pDoc->GetFormatTable()->GetInputLineString( nValue, +/*N*/ nFormat, rStr ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA : +/*N*/ ((ScFormulaCell*)pCell)->SetInChangeTrack( TRUE ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeActionContent::GetValueString( String& rStr, +/*N*/ const String& rValue, const ScBaseCell* pCell ) const +/*N*/ { +/*N*/ if ( !rValue.Len() ) +/*N*/ { +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ switch ( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_STRING : +/*N*/ ((ScStringCell*)pCell)->GetString( rStr ); +/*N*/ break; +/*N*/ case CELLTYPE_EDIT : +/*N*/ ((ScEditCell*)pCell)->GetString( rStr ); +/*N*/ break; +/*N*/ case CELLTYPE_VALUE : // ist immer in rValue +/*N*/ rStr = rValue; +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA : +/*N*/ GetFormulaString( rStr, (ScFormulaCell*) pCell ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ rStr.Erase(); +/*N*/ } +/*N*/ else +/*N*/ rStr = rValue; +/*N*/ } + + +/*N*/ void ScChangeActionContent::GetFormulaString( String& rStr, +/*N*/ const ScFormulaCell* pCell ) const +/*N*/ { +/*N*/ ScAddress aPos( aBigRange.aStart.MakeAddress() ); +/*N*/ if ( aPos == pCell->aPos || IsDeletedIn() ) +/*N*/ pCell->GetFormula( rStr ); +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR( "ScChangeActionContent::GetFormulaString: aPos != pCell->aPos" ); +/*N*/ ScFormulaCell* pNew = (ScFormulaCell*) pCell->Clone( +/*N*/ pCell->GetDocument(), aPos, TRUE ); // TRUE: bNoListening +/*N*/ pNew->GetFormula( rStr ); +/*N*/ delete pNew; +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeActionContent::PutOldValueToDoc( ScDocument* pDoc, +/*N*/ short nDx, short nDy ) const +/*N*/ { +/*N*/ PutValueToDoc( pOldCell, aOldValue, pDoc, nDx, nDy ); +/*N*/ } + + +/*N*/ void ScChangeActionContent::PutNewValueToDoc( ScDocument* pDoc, +/*N*/ short nDx, short nDy ) const +/*N*/ { +/*N*/ PutValueToDoc( pNewCell, aNewValue, pDoc, nDx, nDy ); +/*N*/ } + + +/*N*/ void ScChangeActionContent::PutValueToDoc( ScBaseCell* pCell, +/*N*/ const String& rValue, ScDocument* pDoc, short nDx, short nDy ) const +/*N*/ { +/*N*/ ScAddress aPos( aBigRange.aStart.MakeAddress() ); +/*N*/ if ( nDx ) +/*N*/ aPos.IncCol( nDx ); +/*N*/ if ( nDy ) +/*N*/ aPos.IncRow( nDy ); +/*N*/ if ( !rValue.Len() ) +/*N*/ { +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ switch ( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : // ist immer in rValue +/*N*/ pDoc->SetString( aPos.Col(), aPos.Row(), aPos.Tab(), rValue ); +/*N*/ break; +/*N*/ default: +/*N*/ switch ( ScChangeActionContent::GetContentCellType( pCell ) ) +/*N*/ { +/*N*/ case SC_CACCT_MATORG : +/*N*/ { +/*N*/ USHORT nC, nR; +/*N*/ ((const ScFormulaCell*)pCell)->GetMatColsRows( nC, nR ); +/*N*/ DBG_ASSERT( nC>0 && nR>0, "ScChangeActionContent::PutValueToDoc: MatColsRows?" ); +/*N*/ ScRange aRange( aPos ); +/*N*/ if ( nC > 1 ) +/*N*/ aRange.aEnd.IncCol( nC-1 ); +/*N*/ if ( nR > 1 ) +/*N*/ aRange.aEnd.IncRow( nR-1 ); +/*N*/ ScMarkData aDestMark; +/*N*/ aDestMark.SelectOneTable( aPos.Tab() ); +/*N*/ aDestMark.SetMarkArea( aRange ); +/*N*/ pDoc->InsertMatrixFormula( aPos.Col(), aPos.Row(), +/*N*/ aRange.aEnd.Col(), aRange.aEnd.Row(), +/*N*/ aDestMark, EMPTY_STRING, +/*N*/ ((const ScFormulaCell*)pCell)->GetCode() ); +/*N*/ } +/*N*/ break; +/*N*/ case SC_CACCT_MATREF : +/*N*/ // nothing +/*N*/ break; +/*N*/ default: +/*N*/ pDoc->PutCell( aPos, pCell->Clone( pDoc ) ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ pDoc->PutCell( aPos, NULL ); +/*N*/ } +/*N*/ else +/*N*/ pDoc->SetString( aPos.Col(), aPos.Row(), aPos.Tab(), rValue ); +/*N*/ } + + +/*N*/ void lcl_InvalidateReference( ScToken& rTok, const ScBigAddress& rPos ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = rTok.GetSingleRef(); +/*N*/ if ( rPos.Col() < 0 || MAXCOL < rPos.Col() ) +/*N*/ { +/*N*/ rRef1.nCol = (INT16)(~0); +/*N*/ rRef1.nRelCol = (INT16)(~0); +/*N*/ rRef1.SetColDeleted( TRUE ); +/*N*/ } +/*N*/ if ( rPos.Row() < 0 || MAXROW < rPos.Row() ) +/*N*/ { +/*N*/ rRef1.nRow = (INT16)(~0); +/*N*/ rRef1.nRelRow = (INT16)(~0); +/*N*/ rRef1.SetRowDeleted( TRUE ); +/*N*/ } +/*N*/ if ( rPos.Tab() < 0 || MAXTAB < rPos.Tab() ) +/*N*/ { +/*N*/ rRef1.nTab = (INT16)(~0); +/*N*/ rRef1.nRelTab = (INT16)(~0); +/*N*/ rRef1.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ if ( rTok.GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = rTok.GetDoubleRef().Ref2; +/*N*/ if ( rPos.Col() < 0 || MAXCOL < rPos.Col() ) +/*N*/ { +/*N*/ rRef2.nCol = (INT16)(~0); +/*N*/ rRef2.nRelCol = (INT16)(~0); +/*N*/ rRef2.SetColDeleted( TRUE ); +/*N*/ } +/*N*/ if ( rPos.Row() < 0 || MAXROW < rPos.Row() ) +/*N*/ { +/*N*/ rRef2.nRow = (INT16)(~0); +/*N*/ rRef2.nRelRow = (INT16)(~0); +/*N*/ rRef2.SetRowDeleted( TRUE ); +/*N*/ } +/*N*/ if ( rPos.Tab() < 0 || MAXTAB < rPos.Tab() ) +/*N*/ { +/*N*/ rRef2.nTab = (INT16)(~0); +/*N*/ rRef2.nRelTab = (INT16)(~0); +/*N*/ rRef2.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeActionContent::UpdateReference( const ScChangeTrack* pTrack, +/*N*/ UpdateRefMode eMode, const ScBigRange& rRange, +/*N*/ INT32 nDx, INT32 nDy, INT32 nDz ) +/*N*/ { +/*N*/ USHORT nOldSlot = ScChangeTrack::ComputeContentSlot( aBigRange.aStart.Row() ); +/*N*/ ScRefUpdate::Update( eMode, rRange, nDx, nDy, nDz, aBigRange ); +/*N*/ USHORT nNewSlot = ScChangeTrack::ComputeContentSlot( aBigRange.aStart.Row() ); +/*N*/ if ( nNewSlot != nOldSlot ) +/*N*/ { +/*N*/ RemoveFromSlot(); +/*N*/ InsertInSlot( &(pTrack->GetContentSlots()[nNewSlot]) ); +/*N*/ } +/*N*/ +/*N*/ if ( pTrack->IsInDelete() && !pTrack->IsInDeleteTop() ) +/*N*/ return ; // Formeln nur kompletten Bereich updaten +/*N*/ +/*N*/ BOOL bOldFormula = ( pOldCell && pOldCell->GetCellType() == CELLTYPE_FORMULA ); +/*N*/ BOOL bNewFormula = ( pNewCell && pNewCell->GetCellType() == CELLTYPE_FORMULA ); +/*N*/ if ( bOldFormula || bNewFormula ) +/*N*/ { // via ScFormulaCell UpdateReference anpassen (dort) +/*N*/ if ( pTrack->IsInDelete() ) +/*N*/ { +/*N*/ const ScRange& rDelRange = pTrack->GetInDeleteRange(); +/*N*/ if ( nDx > 0 ) +/*N*/ nDx = rDelRange.aEnd.Col() - rDelRange.aStart.Col() + 1; +/*N*/ else if ( nDx < 0 ) +/*N*/ nDx = -(rDelRange.aEnd.Col() - rDelRange.aStart.Col() + 1); +/*N*/ if ( nDy > 0 ) +/*N*/ nDy = rDelRange.aEnd.Row() - rDelRange.aStart.Row() + 1; +/*N*/ else if ( nDy < 0 ) +/*N*/ nDy = -(rDelRange.aEnd.Row() - rDelRange.aStart.Row() + 1); +/*N*/ if ( nDz > 0 ) +/*N*/ nDz = rDelRange.aEnd.Tab() - rDelRange.aStart.Tab() + 1; +/*N*/ else if ( nDz < 0 ) +/*N*/ nDz = -(rDelRange.aEnd.Tab() - rDelRange.aStart.Tab() + 1); +/*N*/ } +/*N*/ ScBigRange aTmpRange( rRange ); +/*N*/ switch ( eMode ) +/*N*/ { +/*N*/ case URM_INSDEL : +/*N*/ if ( nDx < 0 || nDy < 0 || nDz < 0 ) +/*N*/ { // Delete startet dort hinter geloeschtem Bereich, +/*N*/ // Position wird dort angepasst. +/*N*/ if ( nDx ) +/*N*/ aTmpRange.aStart.IncCol( -nDx ); +/*N*/ if ( nDy ) +/*N*/ aTmpRange.aStart.IncRow( -nDy ); +/*N*/ if ( nDz ) +/*N*/ aTmpRange.aStart.IncTab( -nDz ); +/*N*/ } +/*N*/ break; +/*N*/ case URM_MOVE : +/*N*/ // Move ist hier Quelle, dort Ziel, +/*N*/ // Position muss vorher angepasst sein. +/*N*/ if ( bOldFormula ) +/*N*/ ((ScFormulaCell*)pOldCell)->aPos = aBigRange.aStart.MakeAddress(); +/*N*/ if ( bNewFormula ) +/*N*/ ((ScFormulaCell*)pNewCell)->aPos = aBigRange.aStart.MakeAddress(); +/*N*/ if ( nDx ) +/*N*/ { +/*N*/ aTmpRange.aStart.IncCol( nDx ); +/*N*/ aTmpRange.aEnd.IncCol( nDx ); +/*N*/ } +/*N*/ if ( nDy ) +/*N*/ { +/*N*/ aTmpRange.aStart.IncRow( nDy ); +/*N*/ aTmpRange.aEnd.IncRow( nDy ); +/*N*/ } +/*N*/ if ( nDz ) +/*N*/ { +/*N*/ aTmpRange.aStart.IncTab( nDz ); +/*N*/ aTmpRange.aEnd.IncTab( nDz ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ ScRange aRange( aTmpRange.MakeRange() ); +/*N*/ if ( bOldFormula ) +/*N*/ ((ScFormulaCell*)pOldCell)->UpdateReference( eMode, aRange, +/*N*/ (short) nDx, (short) nDy, (short) nDz, NULL ); +/*N*/ if ( bNewFormula ) +/*N*/ ((ScFormulaCell*)pNewCell)->UpdateReference( eMode, aRange, +/*N*/ (short) nDx, (short) nDy, (short) nDz, NULL ); +/*N*/ if ( !aBigRange.aStart.IsValid( pTrack->GetDocument() ) ) +/*N*/ { //! HACK! +/*N*/ //! UpdateReference kann nicht mit Positionen ausserhalb des +/*N*/ //! Dokuments umgehen, deswegen alles auf #REF! setzen +/*N*/ //2do: make it possible! das bedeutet grossen Umbau von ScAddress etc.! +/*N*/ const ScBigAddress& rPos = aBigRange.aStart; +/*N*/ if ( bOldFormula ) +/*N*/ { +/*N*/ ScToken* t; +/*N*/ ScTokenArray* pArr = ((ScFormulaCell*)pOldCell)->GetCode(); +/*N*/ pArr->Reset(); +/*N*/ while ( t = pArr->GetNextReference() ) +/*N*/ lcl_InvalidateReference( *t, rPos ); +/*N*/ pArr->Reset(); +/*N*/ while ( t = pArr->GetNextReferenceRPN() ) +/*N*/ lcl_InvalidateReference( *t, rPos ); +/*N*/ } +/*N*/ if ( bNewFormula ) +/*N*/ { +/*N*/ ScToken* t; +/*N*/ ScTokenArray* pArr = ((ScFormulaCell*)pNewCell)->GetCode(); +/*N*/ pArr->Reset(); +/*N*/ while ( t = pArr->GetNextReference() ) +/*N*/ lcl_InvalidateReference( *t, rPos ); +/*N*/ pArr->Reset(); +/*N*/ while ( t = pArr->GetNextReferenceRPN() ) +/*N*/ lcl_InvalidateReference( *t, rPos ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +// --- ScChangeActionReject ------------------------------------------------ + +/*N*/ ScChangeActionReject::ScChangeActionReject( SvStream& rStrm, +/*N*/ ScMultipleReadHeader& rHdr, ScChangeTrack* pTrack ) +/*N*/ : +/*N*/ ScChangeAction( rStrm, rHdr, pTrack ) +/*N*/ { +/*N*/ } + +/*N*/ ScChangeActionReject::ScChangeActionReject(const ULONG nActionNumber, const ScChangeActionState eState, const ULONG nRejectingNumber, +/*N*/ const ScBigRange& aBigRange, const String& aUser, const DateTime& aDateTime, const String& sComment) +/*N*/ : +/*N*/ ScChangeAction(SC_CAT_CONTENT, aBigRange, nActionNumber, nRejectingNumber, eState, aDateTime, aUser, sComment) +/*N*/ { +/*N*/ } + +/*N*/ BOOL ScChangeActionReject::Store( SvStream& rStrm, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ BOOL bOk = ScChangeAction::Store( rStrm, rHdr ); +/*N*/ return TRUE; +/*N*/ } + + +// --- ScChangeTrack ------------------------------------------------------- + +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScChangeTrackMsgInfo, 16, 16 )//STRIP008 ; + +const USHORT ScChangeTrack::nContentRowsPerSlot = InitContentRowsPerSlot(); +const USHORT ScChangeTrack::nContentSlots = + (MAXROW+1) / InitContentRowsPerSlot() + 2; + +// static +/*N*/ USHORT ScChangeTrack::InitContentRowsPerSlot() +/*N*/ { +/*N*/ const USHORT nMaxSlots = 0xffe0 / sizeof( ScChangeActionContent* ) - 2; +/*N*/ USHORT nRowsPerSlot = (MAXROW+1) / nMaxSlots; +/*N*/ if ( nRowsPerSlot * nMaxSlots < (MAXROW+1) ) +/*N*/ ++nRowsPerSlot; +/*N*/ return nRowsPerSlot; +/*N*/ } + + +/*N*/ ScChangeTrack::ScChangeTrack( ScDocument* pDocP ) : // Changetracking.sdc +/*N*/ pDoc( pDocP ) +/*N*/ { +/*N*/ Init(); +/*N*/ StartListening( *SfxGetpApp() ); +/*N*/ ppContentSlots = new ScChangeActionContent* [ nContentSlots ]; +/*N*/ memset( ppContentSlots, 0, nContentSlots * sizeof( ScChangeActionContent* ) ); +/*N*/ } + +/*N*/ ScChangeTrack::ScChangeTrack( ScDocument* pDocP, const StrCollection& aTempUserCollection) : +/*N*/ pDoc( pDocP ), +/*N*/ aUserCollection(aTempUserCollection) +/*N*/ { +/*N*/ Init(); +/*N*/ StartListening( *SfxGetpApp() ); +/*N*/ ppContentSlots = new ScChangeActionContent* [ nContentSlots ]; +/*N*/ memset( ppContentSlots, 0, nContentSlots * sizeof( ScChangeActionContent* ) ); +/*N*/ } + +/*N*/ ScChangeTrack::~ScChangeTrack() // Changetracking.sdc +/*N*/ { +/*N*/ DtorClear(); +/*N*/ delete [] ppContentSlots; +/*N*/ } + + +/*N*/ void ScChangeTrack::Init() // Changetracking.sdc +/*N*/ { +/*N*/ pFirst = NULL; +/*N*/ pLast = NULL; +/*N*/ pFirstGeneratedDelContent = NULL; +/*N*/ pLastCutMove = NULL; +/*N*/ pLinkInsertCol = NULL; +/*N*/ pLinkInsertRow = NULL; +/*N*/ pLinkInsertTab = NULL; +/*N*/ pLinkMove = NULL; +/*N*/ pBlockModifyMsg = NULL; +/*N*/ nActionMax = 0; +/*N*/ nGeneratedMin = SC_CHGTRACK_GENERATED_START; +/*N*/ nMarkLastSaved = 0; +/*N*/ nStartLastCut = 0; +/*N*/ nEndLastCut = 0; +/*N*/ nLastMerge = 0; +/*N*/ eMergeState = SC_CTMS_NONE; +/*N*/ nLoadedFileFormatVersion = SC_CHGTRACK_FILEFORMAT; +/*N*/ bLoadSave = FALSE; +/*N*/ bInDelete = FALSE; +/*N*/ bInDeleteTop = FALSE; +/*N*/ bInDeleteUndo = FALSE; +/*N*/ bInPasteCut = FALSE; +/*N*/ bUseFixDateTime = FALSE; +/*N*/ bTime100thSeconds = TRUE; +/*N*/ +/*N*/ SvtUserOptions aUserOpt; +/*N*/ aUser = aUserOpt.GetFirstName(); +/*N*/ aUser += ' '; +/*N*/ aUser += aUserOpt.GetLastName(); +/*N*/ aUserCollection.Insert( new StrData( aUser ) ); +/*N*/ } + + +/*N*/ void ScChangeTrack::DtorClear() // Changetracking.sdc +/*N*/ { +/*N*/ ScChangeAction* p; +/*N*/ ScChangeAction* pNext; +/*N*/ for ( p = GetFirst(); p; p = pNext ) +/*N*/ { +/*N*/ pNext = p->GetNext(); +/*N*/ delete p; +/*N*/ } +/*N*/ for ( p = pFirstGeneratedDelContent; p; p = pNext ) +/*N*/ { +/*N*/ pNext = p->GetNext(); +/*N*/ delete p; +/*N*/ } +/*N*/ for ( p = aPasteCutTable.First(); p; p = aPasteCutTable.Next() ) +/*N*/ { +/*N*/ delete p; +/*N*/ } +/*N*/ delete pLastCutMove; +/*N*/ ClearMsgQueue(); +/*N*/ } + + +/*N*/ void ScChangeTrack::ClearMsgQueue() // Changetracking.sdc +/*N*/ { +/*N*/ if ( pBlockModifyMsg ) +/*N*/ { +/*N*/ delete pBlockModifyMsg; +/*N*/ pBlockModifyMsg = NULL; +/*N*/ } +/*N*/ ScChangeTrackMsgInfo* pMsgInfo; +/*N*/ while ( pMsgInfo = aMsgStackTmp.Pop() ) +/*N*/ delete pMsgInfo; +/*N*/ while ( pMsgInfo = aMsgStackFinal.Pop() ) +/*N*/ delete pMsgInfo; +/*N*/ while ( pMsgInfo = aMsgQueue.Get() ) +/*N*/ delete pMsgInfo; +/*N*/ } + + +/*N*/ void ScChangeTrack::Clear() // Changetracking.sdc +/*N*/ { +/*N*/ DtorClear(); +/*N*/ aTable.Clear(); +/*N*/ aGeneratedTable.Clear(); +/*N*/ aPasteCutTable.Clear(); +/*N*/ aUserCollection.FreeAll(); +/*N*/ aUser.Erase(); +/*N*/ Init(); +/*N*/ } + + +/*N*/ void __EXPORT ScChangeTrack::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) +/*N*/ { +/*N*/ if ( !pDoc->IsInDtorClear() ) +/*N*/ { +/*N*/ const SfxItemSetHint* pHint = PTR_CAST( SfxItemSetHint, &rHint ); +/*N*/ if ( pHint ) +/*N*/ { +/*N*/ const SfxItemSet& rSet = pHint->GetItemSet(); +/*N*/ const SfxPoolItem* pItem; +/*N*/ if ( rSet.GetItemState( +/*N*/ rSet.GetPool()->GetWhich( SID_ATTR_ADDRESS ), +/*N*/ TRUE, &pItem ) == SFX_ITEM_SET ) +/*N*/ { +/*N*/ USHORT nOldCount = aUserCollection.GetCount(); +/*N*/ +/*N*/ String aStr( ((SvxAddressItem*)pItem)->GetFirstName() ); +/*N*/ aStr += ' '; +/*N*/ aStr += ((SvxAddressItem*)pItem)->GetName(); +/*N*/ SetUser( aStr ); +/*N*/ +/*N*/ if ( aUserCollection.GetCount() != nOldCount ) +/*N*/ { +/*N*/ // New user in collection -> have to repaint because +/*N*/ // colors may be different now (#106697#). +/*N*/ // (Has to be done in the Notify handler, to be sure +/*N*/ // the user collection has already been updated) +/*N*/ +/*N*/ SfxObjectShell* pDocSh = pDoc->GetDocumentShell(); +/*N*/ if (pDocSh) +/*N*/ pDocSh->Broadcast( ScPaintHint( ScRange(0,0,0,MAXCOL,MAXROW,MAXTAB), PAINT_GRID ) ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::SetUser( const String& rUser ) // Changetracking.sdc +/*N*/ { +/*N*/ if ( IsLoadSave() ) +/*N*/ return ; // nicht die Collection zerschiessen +/*N*/ +/*N*/ aUser = rUser; +/*N*/ StrData* pStrData = new StrData( aUser ); +/*N*/ if ( !aUserCollection.Insert( pStrData ) ) +/*N*/ delete pStrData; +/*N*/ } + + +/*N*/ void ScChangeTrack::StartBlockModify( ScChangeTrackMsgType eMsgType, +/*N*/ ULONG nStartAction ) +/*N*/ { +/*N*/ if ( aModifiedLink.IsSet() ) +/*N*/ { +/*N*/ if ( pBlockModifyMsg ) +/*N*/ aMsgStackTmp.Push( pBlockModifyMsg ); // Block im Block +/*N*/ pBlockModifyMsg = new ScChangeTrackMsgInfo; +/*N*/ pBlockModifyMsg->eMsgType = eMsgType; +/*N*/ pBlockModifyMsg->nStartAction = nStartAction; +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::EndBlockModify( ULONG nEndAction ) +/*N*/ { +/*N*/ if ( aModifiedLink.IsSet() ) +/*N*/ { +/*N*/ if ( pBlockModifyMsg ) +/*N*/ { +/*N*/ if ( pBlockModifyMsg->nStartAction <= nEndAction ) +/*N*/ { +/*N*/ pBlockModifyMsg->nEndAction = nEndAction; +/*N*/ // Blocks in Blocks aufgeloest +/*N*/ aMsgStackFinal.Push( pBlockModifyMsg ); +/*N*/ } +/*N*/ else +/*N*/ delete pBlockModifyMsg; +/*N*/ pBlockModifyMsg = aMsgStackTmp.Pop(); // evtl. Block im Block +/*N*/ } +/*N*/ if ( !pBlockModifyMsg ) +/*N*/ { +/*N*/ BOOL bNew = FALSE; +/*N*/ ScChangeTrackMsgInfo* pMsg; +/*N*/ while ( pMsg = aMsgStackFinal.Pop() ) +/*N*/ { +/*N*/ aMsgQueue.Put( pMsg ); +/*N*/ bNew = TRUE; +/*N*/ } +/*N*/ if ( bNew ) +/*N*/ aModifiedLink.Call( this ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::NotifyModified( ScChangeTrackMsgType eMsgType, +/*N*/ ULONG nStartAction, ULONG nEndAction ) +/*N*/ { +/*N*/ if ( aModifiedLink.IsSet() ) +/*N*/ { +/*N*/ if ( !pBlockModifyMsg || pBlockModifyMsg->eMsgType != eMsgType || +/*N*/ (IsGenerated( nStartAction ) && +/*N*/ (eMsgType == SC_CTM_APPEND || eMsgType == SC_CTM_REMOVE)) ) +/*N*/ { // Append innerhalb von Append z.B. nicht +/*N*/ StartBlockModify( eMsgType, nStartAction ); +/*N*/ EndBlockModify( nEndAction ); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void lcl_EnsureSorting( StrCollection& rCollection ) // Changetracking.sdc +/*N*/ { +/*N*/ BOOL bSorted = TRUE; +/*N*/ USHORT nCount = rCollection.GetCount(); +/*N*/ USHORT i; +/*N*/ for (i=0; i+1<nCount; i++) +/*N*/ if ( rCollection.Compare( rCollection[i], rCollection[i+1] ) != -1 ) +/*N*/ bSorted = FALSE; +/*N*/ +/*N*/ if ( !bSorted ) +/*N*/ { +/*N*/ // if not sorted, rebuild collection +/*N*/ StrCollection aNewColl; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ { +/*N*/ DataObject* pNewObj = rCollection[i]->Clone(); +/*N*/ if (!aNewColl.Insert(pNewObj)) +/*N*/ delete pNewObj; +/*N*/ } +/*N*/ rCollection = aNewColl; +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScChangeTrack::Load( SvStream& rStrm, USHORT nVer ) // Changetracking.sdc +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ SetLoadSave( TRUE ); +/*N*/ +/*N*/ ScReadHeader aGlobalHdr( rStrm ); +/*N*/ +/*N*/ BYTE n8; +/*N*/ UINT16 n16; +/*N*/ UINT32 n32; +/*N*/ +/*N*/ rStrm >> n16; nLoadedFileFormatVersion = n16; +/*N*/ if ( (nLoadedFileFormatVersion & 0xFF00) > (SC_CHGTRACK_FILEFORMAT & 0xFF00) ) +/*N*/ { // inkompatible neuere Version +/*N*/ Clear(); +/*N*/ rStrm.SetError( SCWARN_IMPORT_INFOLOST ); +/*N*/ return FALSE; +/*N*/ } +/*N*/ +/*N*/ aUserCollection.Load( rStrm ); +/*N*/ +/*N*/ ULONG nCount, nLastAction, nGeneratedCount; +/*N*/ rStrm >> n32; nCount = n32; +/*N*/ rStrm >> n32; nActionMax = n32; +/*N*/ rStrm >> n32; nLastAction = n32; +/*N*/ +/*N*/ rStrm >> n32; nGeneratedCount = n32; +/*N*/ +/*N*/ // GeneratedDelContents laden +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStrm ); +/*N*/ for ( ULONG j = 0; j < nGeneratedCount && bOk; j++ ) +/*N*/ { +/*N*/ ScChangeActionContent* pAct; +/*N*/ +/*N*/ aHdr.StartEntry(); +/*N*/ +/*N*/ ScChangeActionType eType; +/*N*/ rStrm >> n8; eType = (ScChangeActionType) n8; +/*N*/ +/*N*/ switch ( eType ) +/*N*/ { +/*N*/ case SC_CAT_CONTENT : +/*N*/ pAct = new ScChangeActionContent( rStrm, aHdr, pDoc, nVer, this ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "ScChangeTrack::Load: unknown GeneratedType" ); +/*N*/ pAct = NULL; +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ +/*N*/ aHdr.EndEntry(); +/*N*/ +/*N*/ if ( pAct ) +/*N*/ { +/*N*/ pAct->SetType( eType ); +/*N*/ if ( pFirstGeneratedDelContent ) +/*N*/ pFirstGeneratedDelContent->pPrev = pAct; +/*N*/ pAct->pNext = pFirstGeneratedDelContent; +/*N*/ pFirstGeneratedDelContent = pAct; +/*N*/ aGeneratedTable.Insert( pAct->GetActionNumber(), pAct ); +/*N*/ } +/*N*/ } +/*N*/ rStrm >> n32; nGeneratedMin = n32; +/*N*/ } +/*N*/ +/*N*/ if ( bOk ) +/*N*/ bOk = ( nGeneratedCount == aGeneratedTable.Count() ); +/*N*/ DBG_ASSERT( bOk, "ScChangeTrack::Load: Generated failed" ); +/*N*/ +/*N*/ +/*N*/ // erste Runde: Actions laden +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStrm ); +/*N*/ for ( ULONG j = 0; j < nCount && bOk; j++ ) +/*N*/ { +/*N*/ ScChangeAction* pAct; +/*N*/ +/*N*/ aHdr.StartEntry(); +/*N*/ +/*N*/ USHORT nUserIndex; +/*N*/ rStrm >> n16; nUserIndex = n16; +/*N*/ +/*N*/ ScChangeActionType eType; +/*N*/ rStrm >> n8; eType = (ScChangeActionType) n8; +/*N*/ +/*N*/ switch ( eType ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ case SC_CAT_INSERT_TABS : +/*N*/ pAct = new ScChangeActionIns( rStrm, aHdr, this ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ pAct = new ScChangeActionDel( rStrm, aHdr, pDoc, nVer, this ); +/*N*/ break; +/*N*/ case SC_CAT_MOVE : +/*N*/ pAct = new ScChangeActionMove( rStrm, aHdr, this ); +/*N*/ break; +/*N*/ case SC_CAT_CONTENT : +/*N*/ pAct = new ScChangeActionContent( rStrm, aHdr, pDoc, nVer, this ); +/*N*/ break; +/*N*/ case SC_CAT_REJECT : +/*N*/ pAct = new ScChangeActionReject( rStrm, aHdr, this ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "ScChangeTrack::Load: unknown ScChangeActionType" ); +/*N*/ pAct = NULL; +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ +/*N*/ aHdr.EndEntry(); +/*N*/ +/*N*/ if ( pAct ) +/*N*/ { +/*N*/ pAct->SetType( eType ); +/*N*/ if ( nUserIndex != 0xffff ) +/*N*/ { +/*N*/ StrData* pUser = (StrData*) aUserCollection.At( nUserIndex ); +/*N*/ if ( pUser ) +/*N*/ pAct->SetUser( pUser->GetString() ); +/*N*/ } +/*N*/ AppendLoaded( pAct ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( pLast ) +/*N*/ nMarkLastSaved = pLast->GetActionNumber(); +/*N*/ +/*N*/ if ( bOk ) +/*N*/ bOk = ( nMarkLastSaved == nLastAction && nCount == aTable.Count() ); +/*N*/ DBG_ASSERT( bOk, "ScChangeTrack::Load: failed" ); +/*N*/ +/*N*/ // zweite Runde: Links laden und alles verpointern +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStrm ); +/*N*/ for ( ScChangeAction* p = GetFirst(); p && bOk; p = p->GetNext() ) +/*N*/ { +/*N*/ aHdr.StartEntry(); +/*N*/ bOk = p->LoadLinks( rStrm, this ); +/*N*/ aHdr.EndEntry(); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ SetLoadSave( FALSE ); +/*N*/ +/*N*/ // versions between 583 and 633 had the sorting wrong -> correct (after loading the actions) +/*N*/ lcl_EnsureSorting( aUserCollection ); +/*N*/ +/*N*/ // den aktuellen User erst einfuegen, wenn die Actions bereits ihre User haben +/*N*/ SetUser( aUser ); +/*N*/ +/*N*/ if ( !bOk ) +/*N*/ { +/*N*/ Clear(); // eindeutiger Zustand +/*N*/ rStrm.SetError( SCWARN_IMPORT_INFOLOST ); +/*N*/ } +/*N*/ +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScChangeTrack::Store( SvStream& rStrm ) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ SetLoadSave( TRUE ); +/*N*/ +/*N*/ ScWriteHeader aGlobalHdr( rStrm ); +/*N*/ +/*N*/ rStrm << (UINT16) SC_CHGTRACK_FILEFORMAT; +/*N*/ +/*N*/ aUserCollection.Store( rStrm ); +/*N*/ +/*N*/ ULONG nCount = aTable.Count(); +/*N*/ ULONG nLastAction = ( pLast ? pLast->GetActionNumber() : 0 ); +/*N*/ ULONG nGeneratedCount = aGeneratedTable.Count(); +/*N*/ rStrm << (UINT32) nCount << (UINT32) nActionMax << (UINT32) nLastAction; +/*N*/ rStrm << (UINT32) nGeneratedCount; +/*N*/ +/*N*/ // GeneratedDelContents speichern +/*N*/ ULONG nSave = 0; +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStrm ); +/*N*/ ULONG nNewGeneratedMin = SC_CHGTRACK_GENERATED_START; +/*N*/ for ( ScChangeAction* p = pFirstGeneratedDelContent; p && bOk; +/*N*/ p = p->GetNext() ) +/*N*/ { +/*N*/ ++nSave; +/*N*/ aHdr.StartEntry(); +/*N*/ rStrm << (BYTE) p->GetType(); +/*N*/ bOk = p->Store( rStrm, aHdr ); +/*N*/ aHdr.EndEntry(); +/*N*/ ULONG nAct = p->GetActionNumber(); +/*N*/ if ( nNewGeneratedMin > nAct ) +/*N*/ nNewGeneratedMin = nAct; +/*N*/ } +/*N*/ nGeneratedMin = nNewGeneratedMin; // evtl. unbenutzten Bereich freigeben +/*N*/ rStrm << (UINT32) nGeneratedMin; +/*N*/ } +/*N*/ +/*N*/ if ( bOk ) +/*N*/ bOk = ( nGeneratedCount == nSave ); +/*N*/ DBG_ASSERT( bOk, "ScChangeTrack::Store: failed" ); +/*N*/ +/*N*/ // erste Runde: Actions speichern +/*N*/ nSave = 0; +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStrm ); +/*N*/ StrData* pUserSearch = new StrData( aUser ); +/*N*/ USHORT nUserIndex; +/*N*/ for ( ScChangeAction* p = GetFirst(); p && bOk; p = p->GetNext() ) +/*N*/ { +/*N*/ ++nSave; +/*N*/ aHdr.StartEntry(); +/*N*/ +/*N*/ pUserSearch->SetString( p->GetUser() ); +/*N*/ if ( aUserCollection.Search( pUserSearch, nUserIndex ) ) +/*N*/ rStrm << (UINT16) nUserIndex; +/*N*/ else +/*N*/ rStrm << (UINT16) 0xffff; +/*N*/ rStrm << (BYTE) p->GetType(); +/*N*/ +/*N*/ bOk = p->Store( rStrm, aHdr ); +/*N*/ +/*N*/ aHdr.EndEntry(); +/*N*/ } +/*N*/ delete pUserSearch; +/*N*/ } +/*N*/ +/*N*/ if ( pLast ) +/*N*/ nMarkLastSaved = pLast->GetActionNumber(); +/*N*/ +/*N*/ if ( bOk ) +/*N*/ bOk = ( nCount == nSave ); +/*N*/ DBG_ASSERT( bOk, "ScChangeTrack::Store: failed" ); +/*N*/ +/*N*/ // zweite Runde: Links speichern +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStrm ); +/*N*/ for ( ScChangeAction* p = GetFirst(); p && bOk; p = p->GetNext() ) +/*N*/ { +/*N*/ aHdr.StartEntry(); +/*N*/ bOk = p->StoreLinks( rStrm ); +/*N*/ aHdr.EndEntry(); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ SetLoadSave( FALSE ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ void ScChangeTrack::MasterLinks( ScChangeAction* pAppend ) +/*N*/ { +/*N*/ ScChangeActionType eType = pAppend->GetType(); +/*N*/ +/*N*/ if ( eType == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ if ( !IsGenerated( pAppend->GetActionNumber() ) ) +/*N*/ { +/*N*/ USHORT nSlot = ComputeContentSlot( +/*N*/ pAppend->GetBigRange().aStart.Row() ); +/*N*/ ((ScChangeActionContent*)pAppend)->InsertInSlot( +/*N*/ &ppContentSlots[nSlot] ); +/*N*/ } +/*N*/ return ; +/*N*/ } +/*N*/ +/*N*/ if ( pAppend->IsRejecting() ) +/*N*/ return ; // Rejects haben keine Abhaengigkeiten +/*N*/ +/*N*/ switch ( eType ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry( +/*N*/ &pLinkInsertCol, pAppend ); +/*N*/ pAppend->AddLink( NULL, pLink ); +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry( +/*N*/ &pLinkInsertRow, pAppend ); +/*N*/ pAppend->AddLink( NULL, pLink ); +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_INSERT_TABS : +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry( +/*N*/ &pLinkInsertTab, pAppend ); +/*N*/ pAppend->AddLink( NULL, pLink ); +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_MOVE : +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = new ScChangeActionLinkEntry( +/*N*/ &pLinkMove, pAppend ); +/*N*/ pAppend->AddLink( NULL, pLink ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::AppendLoaded( ScChangeAction* pAppend ) +/*N*/ { +/*N*/ aTable.Insert( pAppend->GetActionNumber(), pAppend ); // Changetracking.sdc +/*N*/ if ( !pLast ) +/*N*/ pFirst = pLast = pAppend; +/*N*/ else +/*N*/ { +/*N*/ pLast->pNext = pAppend; +/*N*/ pAppend->pPrev = pLast; +/*N*/ pLast = pAppend; +/*N*/ } +/*N*/ MasterLinks( pAppend ); +/*N*/ } + + +/*N*/ void ScChangeTrack::Append( ScChangeAction* pAppend, ULONG nAction ) +/*N*/ { +/*N*/ if ( nActionMax < nAction ) +/*N*/ nActionMax = nAction; +/*N*/ pAppend->SetUser( aUser ); +/*N*/ if ( bUseFixDateTime ) +/*N*/ pAppend->SetDateTimeUTC( aFixDateTime ); +/*N*/ pAppend->SetActionNumber( nAction ); +/*N*/ aTable.Insert( nAction, pAppend ); +/*N*/ // UpdateReference Inserts vor Dependencies. +/*N*/ // Delete rejectendes Insert hatte UpdateReference mit Delete-Undo. +/*N*/ // UpdateReference auch wenn pLast==NULL, weil pAppend ein Delete sein +/*N*/ // kann, dass DelContents generiert haben kann +/*N*/ if ( pAppend->IsInsertType() && !pAppend->IsRejecting() ) +/*N*/ UpdateReference( pAppend, FALSE ); +/*N*/ if ( !pLast ) +/*N*/ pFirst = pLast = pAppend; +/*N*/ else +/*N*/ { +/*N*/ pLast->pNext = pAppend; +/*N*/ pAppend->pPrev = pLast; +/*N*/ pLast = pAppend; +/*N*/ Dependencies( pAppend ); +/*N*/ } +/*N*/ // UpdateReference Inserts nicht nach Dependencies. +/*N*/ // Move rejectendes Move hatte UpdateReference mit Move-Undo, Inhalt in +/*N*/ // ToRange nicht deleten. +/*N*/ if ( !pAppend->IsInsertType() && +/*N*/ !(pAppend->GetType() == SC_CAT_MOVE && pAppend->IsRejecting()) ) +/*N*/ UpdateReference( pAppend, FALSE ); +/*N*/ MasterLinks( pAppend ); +/*N*/ +/*N*/ if ( aModifiedLink.IsSet() ) +/*N*/ { +/*N*/ NotifyModified( SC_CTM_APPEND, nAction, nAction ); +/*N*/ if ( pAppend->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent = (ScChangeActionContent*) pAppend; +/*N*/ if ( pContent = pContent->GetPrevContent() ) +/*N*/ { +/*N*/ ULONG nMod = pContent->GetActionNumber(); +/*N*/ NotifyModified( SC_CTM_CHANGE, nMod, nMod ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ NotifyModified( SC_CTM_CHANGE, pFirst->GetActionNumber(), +/*N*/ pLast->GetActionNumber() ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::Append( ScChangeAction* pAppend ) +/*N*/ { +/*N*/ Append( pAppend, ++nActionMax ); +/*N*/ } + + +/*N*/ void ScChangeTrack::AppendDeleteRange( const ScRange& rRange, +/*N*/ ScDocument* pRefDoc, short nDz, ULONG nRejectingInsert ) +/*N*/ { +/*N*/ SetInDeleteRange( rRange ); +/*N*/ StartBlockModify( SC_CTM_APPEND, GetActionMax() + 1 ); +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ rRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ for ( USHORT nTab = nTab1; nTab <= nTab2; nTab++ ) +/*N*/ { +/*N*/ if ( !pRefDoc || nTab < pRefDoc->GetTableCount() ) +/*N*/ { +/*N*/ if ( nCol1 == 0 && nCol2 == MAXCOL ) +/*N*/ { // ganze Zeilen und/oder Tabellen +/*N*/ if ( nRow1 == 0 && nRow2 == MAXROW ) +/*N*/ { // ganze Tabellen +/*N*/ //2do: geht nicht auch komplette Tabelle als ganzes? +/*N*/ ScRange aRange( 0, 0, nTab, 0, MAXROW, nTab ); +/*N*/ for ( USHORT nCol = nCol1; nCol <= nCol2; nCol++ ) +/*N*/ { // spaltenweise ist weniger als zeilenweise +/*N*/ aRange.aStart.SetCol( nCol ); +/*N*/ aRange.aEnd.SetCol( nCol ); +/*N*/ if ( nCol == nCol2 ) +/*N*/ SetInDeleteTop( TRUE ); +/*N*/ AppendOneDeleteRange( aRange, pRefDoc, nCol-nCol1, 0, +/*N*/ nTab-nTab1 + nDz, nRejectingInsert ); +/*N*/ } +/*N*/ //! immer noch InDeleteTop +/*N*/ AppendOneDeleteRange( rRange, pRefDoc, 0, 0, +/*N*/ nTab-nTab1 + nDz, nRejectingInsert ); +/*N*/ } +/*N*/ else +/*N*/ { // ganze Zeilen +/*N*/ ScRange aRange( 0, 0, nTab, MAXCOL, 0, nTab ); +/*N*/ for ( USHORT nRow = nRow1; nRow <= nRow2; nRow++ ) +/*N*/ { +/*N*/ aRange.aStart.SetRow( nRow ); +/*N*/ aRange.aEnd.SetRow( nRow ); +/*N*/ if ( nRow == nRow2 ) +/*N*/ SetInDeleteTop( TRUE ); +/*N*/ AppendOneDeleteRange( aRange, pRefDoc, 0, nRow-nRow1, +/*N*/ 0, nRejectingInsert ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if ( nRow1 == 0 && nRow2 == MAXROW ) +/*N*/ { // ganze Spalten +/*N*/ ScRange aRange( 0, 0, nTab, 0, MAXROW, nTab ); +/*N*/ for ( USHORT nCol = nCol1; nCol <= nCol2; nCol++ ) +/*N*/ { +/*N*/ aRange.aStart.SetCol( nCol ); +/*N*/ aRange.aEnd.SetCol( nCol ); +/*N*/ if ( nCol == nCol2 ) +/*N*/ SetInDeleteTop( TRUE ); +/*N*/ AppendOneDeleteRange( aRange, pRefDoc, nCol-nCol1, 0, +/*N*/ 0, nRejectingInsert ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR( "ScChangeTrack::AppendDeleteRange: Block not supported!" ); +/*N*/ SetInDeleteTop( FALSE ); +/*N*/ } +/*N*/ } +/*N*/ EndBlockModify( GetActionMax() ); +/*N*/ } + + +/*N*/ void ScChangeTrack::AppendOneDeleteRange( const ScRange& rOrgRange, +/*N*/ ScDocument* pRefDoc, short nDx, short nDy, short nDz, +/*N*/ ULONG nRejectingInsert ) +/*N*/ { +/*N*/ ScRange aTrackRange( rOrgRange ); +/*N*/ if ( nDx ) +/*N*/ { +/*N*/ aTrackRange.aStart.IncCol( -nDx ); +/*N*/ aTrackRange.aEnd.IncCol( -nDx ); +/*N*/ } +/*N*/ if ( nDy ) +/*N*/ { +/*N*/ aTrackRange.aStart.IncRow( -nDy ); +/*N*/ aTrackRange.aEnd.IncRow( -nDy ); +/*N*/ } +/*N*/ if ( nDz ) +/*N*/ { +/*N*/ aTrackRange.aStart.IncTab( -nDz ); +/*N*/ aTrackRange.aEnd.IncTab( -nDz ); +/*N*/ } +/*N*/ ScChangeActionDel* pAct = new ScChangeActionDel( aTrackRange, nDx, nDy, +/*N*/ this ); +/*N*/ // TabDelete keine Contents, sind in einzelnen Spalten +/*N*/ if ( !(rOrgRange.aStart.Col() == 0 && rOrgRange.aStart.Row() == 0 && +/*N*/ rOrgRange.aEnd.Col() == MAXCOL && rOrgRange.aEnd.Row() == MAXROW) ) +/*N*/ LookUpContents( rOrgRange, pRefDoc, -nDx, -nDy, -nDz ); +/*N*/ if ( nRejectingInsert ) +/*N*/ { +/*N*/ pAct->SetRejectAction( nRejectingInsert ); +/*N*/ pAct->SetState( SC_CAS_ACCEPTED ); +/*N*/ } +/*N*/ Append( pAct ); +/*N*/ } + + +/*N*/ void ScChangeTrack::LookUpContents( const ScRange& rOrgRange, +/*N*/ ScDocument* pRefDoc, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ if ( pRefDoc ) +/*N*/ { +/*N*/ ScAddress aPos; +/*N*/ ScBigAddress aBigPos; +/*N*/ ScCellIterator aIter( pRefDoc, rOrgRange ); +/*N*/ ScBaseCell* pCell = aIter.GetFirst(); +/*N*/ while ( pCell ) +/*N*/ { +/*N*/ if ( ScChangeActionContent::GetContentCellType( pCell ) ) +/*N*/ { +/*N*/ aBigPos.Set( aIter.GetCol() + nDx, aIter.GetRow() + nDy, +/*N*/ aIter.GetTab() + nDz ); +/*N*/ ScChangeActionContent* pContent = SearchContentAt( aBigPos, NULL ); +/*N*/ if ( !pContent ) +/*N*/ { // nicht getrackte Contents +/*N*/ aPos.Set( aIter.GetCol() + nDx, aIter.GetRow() + nDy, +/*N*/ aIter.GetTab() + nDz ); +/*N*/ GenerateDelContent( aPos, pCell, pRefDoc ); +/*N*/ //! der Content wird hier _nicht_ per AddContent hinzugefuegt, +/*N*/ //! sondern in UpdateReference, um z.B. auch kreuzende Deletes +/*N*/ //! korrekt zu erfassen +/*N*/ } +/*N*/ } +/*N*/ pCell = aIter.GetNext(); +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::DeleteCellEntries( ScChangeActionCellListEntry*& pCellList, +/*N*/ ScChangeAction* pDeletor ) +/*N*/ { +/*N*/ ScChangeActionCellListEntry* pE = pCellList; +/*N*/ while ( pE ) +/*N*/ { +/*N*/ ScChangeActionCellListEntry* pNext = pE->pNext; +/*N*/ pE->pContent->RemoveDeletedIn( pDeletor ); +/*N*/ if ( IsGenerated( pE->pContent->GetActionNumber() ) && +/*N*/ !pE->pContent->IsDeletedIn() ) +/*N*/ DeleteGeneratedDelContent( pE->pContent ); +/*N*/ delete pE; +/*N*/ pE = pNext; +/*N*/ } +/*N*/ pCellList = NULL; +/*N*/ } + + +/*N*/ ScChangeActionContent* ScChangeTrack::GenerateDelContent( +/*N*/ const ScAddress& rPos, const ScBaseCell* pCell, +/*N*/ const ScDocument* pFromDoc ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent = new ScChangeActionContent( +/*N*/ ScRange( rPos ) ); +/*N*/ pContent->SetActionNumber( --nGeneratedMin ); +/*N*/ // nur NewValue +/*N*/ ScChangeActionContent::SetValue( pContent->aNewValue, pContent->pNewCell, +/*N*/ rPos, pCell, pFromDoc, pDoc ); +/*N*/ // pNextContent und pPrevContent werden nicht gesetzt +/*N*/ if ( pFirstGeneratedDelContent ) +/*N*/ { // vorne reinhaengen +/*N*/ pFirstGeneratedDelContent->pPrev = pContent; +/*N*/ pContent->pNext = pFirstGeneratedDelContent; +/*N*/ } +/*N*/ pFirstGeneratedDelContent = pContent; +/*N*/ aGeneratedTable.Insert( nGeneratedMin, pContent ); +/*N*/ NotifyModified( SC_CTM_APPEND, nGeneratedMin, nGeneratedMin ); +/*N*/ return pContent; +/*N*/ } + + +/*N*/ void ScChangeTrack::DeleteGeneratedDelContent( ScChangeActionContent* pContent ) +/*N*/ { +/*N*/ ULONG nAct = pContent->GetActionNumber(); +/*N*/ aGeneratedTable.Remove( nAct ); +/*N*/ if ( pFirstGeneratedDelContent == pContent ) +/*N*/ pFirstGeneratedDelContent = (ScChangeActionContent*) pContent->pNext; +/*N*/ if ( pContent->pNext ) +/*N*/ pContent->pNext->pPrev = pContent->pPrev; +/*N*/ if ( pContent->pPrev ) +/*N*/ pContent->pPrev->pNext = pContent->pNext; +/*N*/ delete pContent; +/*N*/ NotifyModified( SC_CTM_REMOVE, nAct, nAct ); +/*N*/ if ( nAct == nGeneratedMin ) +/*N*/ ++nGeneratedMin; //! erst nach NotifyModified wg. IsGenerated +/*N*/ } + +/*N*/ ScChangeActionContent* ScChangeTrack::SearchContentAt( +/*N*/ const ScBigAddress& rPos, ScChangeAction* pButNotThis ) const +/*N*/ { +/*N*/ USHORT nSlot = ComputeContentSlot( rPos.Row() ); +/*N*/ for ( ScChangeActionContent* p = ppContentSlots[nSlot]; p; +/*N*/ p = p->GetNextInSlot() ) +/*N*/ { +/*N*/ if ( p != pButNotThis && !p->IsDeletedIn() && +/*N*/ p->GetBigRange().aStart == rPos ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent = p->GetTopContent(); +/*N*/ if ( !pContent->IsDeletedIn() ) +/*N*/ return pContent; +/*N*/ } +/*N*/ } +/*N*/ return NULL; +/*N*/ } + + +/*N*/ void ScChangeTrack::AddDependentWithNotify( ScChangeAction* pParent, +/*N*/ ScChangeAction* pDependent ) +/*N*/ { +/*N*/ ScChangeActionLinkEntry* pLink = pParent->AddDependent( pDependent ); +/*N*/ pDependent->AddLink( pParent, pLink ); +/*N*/ if ( aModifiedLink.IsSet() ) +/*N*/ { +/*N*/ ULONG nMod = pParent->GetActionNumber(); +/*N*/ NotifyModified( SC_CTM_PARENT, nMod, nMod ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::Dependencies( ScChangeAction* pAct ) +/*N*/ { +/*N*/ // Finde die letzte Abhaengigkeit fuer jeweils Col/Row/Tab. +/*N*/ // Content an gleicher Position verketten. +/*N*/ // Move Abhaengigkeiten. +/*N*/ ScChangeActionType eActType = pAct->GetType(); +/*N*/ if ( eActType == SC_CAT_REJECT || +/*N*/ (eActType == SC_CAT_MOVE && pAct->IsRejecting()) ) +/*N*/ return ; // diese Rejects sind nicht abhaengig +/*N*/ +/*N*/ if ( eActType == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ if ( !(((ScChangeActionContent*)pAct)->GetNextContent() || +/*N*/ ((ScChangeActionContent*)pAct)->GetPrevContent()) ) +/*N*/ { // Contents an gleicher Position verketten +/*N*/ ScChangeActionContent* pContent = SearchContentAt( +/*N*/ pAct->GetBigRange().aStart, pAct ); +/*N*/ if ( pContent ) +/*N*/ { +/*N*/ pContent->SetNextContent( (ScChangeActionContent*) pAct ); +/*N*/ ((ScChangeActionContent*)pAct)->SetPrevContent( pContent ); +/*N*/ } +/*N*/ } +/*N*/ const ScBaseCell* pCell = ((ScChangeActionContent*)pAct)->GetNewCell(); +/*N*/ if ( ScChangeActionContent::GetContentCellType( pCell ) == SC_CACCT_MATREF ) +/*N*/ { +/*N*/ ScAddress aOrg; +/*N*/ ((const ScFormulaCell*)pCell)->GetMatrixOrigin( aOrg ); +/*N*/ ScChangeActionContent* pContent = SearchContentAt( aOrg, pAct ); +/*N*/ if ( pContent && pContent->IsMatrixOrigin() ) +/*N*/ { +/*N*/ AddDependentWithNotify( pContent, pAct ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScChangeTrack::Dependencies: MatOrg not found" ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( !(pLinkInsertCol || pLinkInsertRow || pLinkInsertTab || pLinkMove) ) +/*N*/ return ; // keine Dependencies +/*N*/ if ( pAct->IsRejecting() ) +/*N*/ return ; // ausser Content keine Dependencies +/*N*/ +/*N*/ // Insert in einem entsprechenden Insert haengt davon ab, sonst muesste +/*N*/ // der vorherige Insert gesplittet werden. +/*N*/ // Sich kreuzende Inserts und Deletes sind nicht abhaengig. +/*N*/ // Alles andere ist abhaengig. +/*N*/ +/*N*/ // Der zuletzt eingelinkte Insert steht am Anfang einer Kette, +/*N*/ // also genau richtig +/*N*/ +/*N*/ const ScBigRange& rRange = pAct->GetBigRange(); +/*N*/ BOOL bActNoInsert = !pAct->IsInsertType(); +/*N*/ BOOL bActColDel = ( eActType == SC_CAT_DELETE_COLS ); +/*N*/ BOOL bActRowDel = ( eActType == SC_CAT_DELETE_ROWS ); +/*N*/ BOOL bActTabDel = ( eActType == SC_CAT_DELETE_TABS ); +/*N*/ +/*N*/ if ( pLinkInsertCol && (eActType == SC_CAT_INSERT_COLS || +/*N*/ (bActNoInsert && !bActRowDel && !bActTabDel)) ) +/*N*/ { +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkInsertCol; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeActionIns* pTest = (ScChangeActionIns*) pL->GetAction(); +/*N*/ if ( !pTest->IsRejected() && +/*N*/ pTest->GetBigRange().Intersects( rRange ) ) +/*N*/ { +/*N*/ AddDependentWithNotify( pTest, pAct ); +/*N*/ break; // for +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( pLinkInsertRow && (eActType == SC_CAT_INSERT_ROWS || +/*N*/ (bActNoInsert && !bActColDel && !bActTabDel)) ) +/*N*/ { +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkInsertRow; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeActionIns* pTest = (ScChangeActionIns*) pL->GetAction(); +/*N*/ if ( !pTest->IsRejected() && +/*N*/ pTest->GetBigRange().Intersects( rRange ) ) +/*N*/ { +/*N*/ AddDependentWithNotify( pTest, pAct ); +/*N*/ break; // for +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( pLinkInsertTab && (eActType == SC_CAT_INSERT_TABS || +/*N*/ (bActNoInsert && !bActColDel && !bActRowDel)) ) +/*N*/ { +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkInsertTab; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeActionIns* pTest = (ScChangeActionIns*) pL->GetAction(); +/*N*/ if ( !pTest->IsRejected() && +/*N*/ pTest->GetBigRange().Intersects( rRange ) ) +/*N*/ { +/*N*/ AddDependentWithNotify( pTest, pAct ); +/*N*/ break; // for +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( pLinkMove ) +/*N*/ { +/*N*/ if ( eActType == SC_CAT_CONTENT ) +/*N*/ { // Content ist von FromRange abhaengig +/*N*/ const ScBigAddress& rPos = rRange.aStart; +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkMove; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeActionMove* pTest = (ScChangeActionMove*) pL->GetAction(); +/*N*/ if ( !pTest->IsRejected() && +/*N*/ pTest->GetFromRange().In( rPos ) ) +/*N*/ { +/*N*/ AddDependentWithNotify( pTest, pAct ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if ( eActType == SC_CAT_MOVE ) +/*N*/ { // Move FromRange ist von ToRange abhaengig +/*N*/ const ScBigRange& rFromRange = ((ScChangeActionMove*)pAct)->GetFromRange(); +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkMove; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeActionMove* pTest = (ScChangeActionMove*) pL->GetAction(); +/*N*/ if ( !pTest->IsRejected() && +/*N*/ pTest->GetBigRange().Intersects( rFromRange ) ) +/*N*/ { +/*N*/ AddDependentWithNotify( pTest, pAct ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // Inserts und Deletes sind abhaengig, sobald sie FromRange oder +/*N*/ // ToRange kreuzen +/*N*/ for ( ScChangeActionLinkEntry* pL = pLinkMove; pL; pL = pL->GetNext() ) +/*N*/ { +/*N*/ ScChangeActionMove* pTest = (ScChangeActionMove*) pL->GetAction(); +/*N*/ if ( !pTest->IsRejected() && +/*N*/ (pTest->GetFromRange().Intersects( rRange ) || +/*N*/ pTest->GetBigRange().Intersects( rRange )) ) +/*N*/ { +/*N*/ AddDependentWithNotify( pTest, pAct ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::Remove( ScChangeAction* pRemove ) +/*N*/ { +/*N*/ // aus Track ausklinken +/*N*/ ULONG nAct = pRemove->GetActionNumber(); +/*N*/ aTable.Remove( nAct ); +/*N*/ if ( nAct == nActionMax ) +/*N*/ --nActionMax; +/*N*/ if ( pRemove == pLast ) +/*N*/ pLast = pRemove->pPrev; +/*N*/ if ( pRemove == pFirst ) +/*N*/ pFirst = pRemove->pNext; +/*N*/ if ( nAct == nMarkLastSaved ) +/*N*/ nMarkLastSaved = +/*N*/ ( pRemove->pPrev ? pRemove->pPrev->GetActionNumber() : 0 ); +/*N*/ +/*N*/ // aus der globalen Kette ausklinken +/*N*/ if ( pRemove->pNext ) +/*N*/ pRemove->pNext->pPrev = pRemove->pPrev; +/*N*/ if ( pRemove->pPrev ) +/*N*/ pRemove->pPrev->pNext = pRemove->pNext; +/*N*/ +/*N*/ // Dependencies nicht loeschen, passiert on delete automatisch durch +/*N*/ // LinkEntry, ohne Listen abzuklappern +/*N*/ +/*N*/ if ( aModifiedLink.IsSet() ) +/*N*/ { +/*N*/ NotifyModified( SC_CTM_REMOVE, nAct, nAct ); +/*N*/ if ( pRemove->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ ScChangeActionContent* pContent = (ScChangeActionContent*) pRemove; +/*N*/ if ( pContent = pContent->GetPrevContent() ) +/*N*/ { +/*N*/ ULONG nMod = pContent->GetActionNumber(); +/*N*/ NotifyModified( SC_CTM_CHANGE, nMod, nMod ); +/*N*/ } +/*N*/ } +/*N*/ else if ( pLast ) +/*N*/ NotifyModified( SC_CTM_CHANGE, pFirst->GetActionNumber(), +/*N*/ pLast->GetActionNumber() ); +/*N*/ } +/*N*/ +/*N*/ if ( IsInPasteCut() && pRemove->GetType() == SC_CAT_CONTENT ) +/*N*/ { //! Content wird wiederverwertet +/*N*/ ScChangeActionContent* pContent = (ScChangeActionContent*) pRemove; +/*N*/ pContent->RemoveAllLinks(); +/*N*/ pContent->ClearTrack(); +/*N*/ pContent->pNext = pContent->pPrev = NULL; +/*N*/ pContent->pNextContent = pContent->pPrevContent = NULL; +/*N*/ } +/*N*/ } + + +/*N*/ void ScChangeTrack::UpdateReference( ScChangeAction* pAct, BOOL bUndo ) +/*N*/ { +/*N*/ ScChangeActionType eActType = pAct->GetType(); +/*N*/ if ( eActType == SC_CAT_CONTENT || eActType == SC_CAT_REJECT ) +/*N*/ return ; +/*N*/ +/*N*/ //! Formelzellen haengen nicht im Dokument +/*N*/ BOOL bOldAutoCalc = pDoc->GetAutoCalc(); +/*N*/ pDoc->SetAutoCalc( FALSE ); +/*N*/ BOOL bOldNoListening = pDoc->GetNoListening(); +/*N*/ pDoc->SetNoListening( TRUE ); +/*N*/ //! Formelzellen ExpandRefs synchronisiert zu denen im Dokument +/*N*/ BOOL bOldExpandRefs = pDoc->IsExpandRefs(); +/*N*/ if ( (!bUndo && pAct->IsInsertType()) || (bUndo && pAct->IsDeleteType()) ) +/*N*/ pDoc->SetExpandRefs( SC_MOD()->GetInputOptions().GetExpandRefs() ); +/*N*/ +/*N*/ if ( pAct->IsDeleteType() ) +/*N*/ { +/*N*/ SetInDeleteUndo( bUndo ); +/*N*/ SetInDelete( TRUE ); +/*N*/ } +/*N*/ else if ( GetMergeState() == SC_CTMS_OWN ) +/*N*/ { +/*N*/ // Referenzen von Formelzellen wiederherstellen, +/*N*/ // vorheriges MergePrepare war bei einem Insert wie ein Delete +/*N*/ if ( pAct->IsInsertType() ) +/*N*/ SetInDeleteUndo( TRUE ); +/*N*/ } +/*N*/ +/*N*/ //! erst die generated, als waeren sie vorher getrackt worden +/*N*/ if ( pFirstGeneratedDelContent ) +/*N*/ UpdateReference( (ScChangeAction**)&pFirstGeneratedDelContent, pAct, +/*N*/ bUndo ); +/*N*/ UpdateReference( &pFirst, pAct, bUndo ); +/*N*/ +/*N*/ SetInDelete( FALSE ); +/*N*/ SetInDeleteUndo( FALSE ); +/*N*/ +/*N*/ pDoc->SetExpandRefs( bOldExpandRefs ); +/*N*/ pDoc->SetNoListening( bOldNoListening ); +/*N*/ pDoc->SetAutoCalc( bOldAutoCalc ); +/*N*/ } + + +/*N*/ void ScChangeTrack::UpdateReference( ScChangeAction** ppFirstAction, +/*N*/ ScChangeAction* pAct, BOOL bUndo ) +/*N*/ { +/*N*/ ScChangeActionType eActType = pAct->GetType(); +/*N*/ BOOL bGeneratedDelContents = +/*N*/ ( ppFirstAction == (ScChangeAction**)&pFirstGeneratedDelContent ); +/*N*/ const ScBigRange& rOrgRange = pAct->GetBigRange(); +/*N*/ ScBigRange aRange( rOrgRange ); +/*N*/ ScBigRange aDelRange( rOrgRange ); +/*N*/ INT32 nDx, nDy, nDz; +/*N*/ nDx = nDy = nDz = 0; +/*N*/ UpdateRefMode eMode = URM_INSDEL; +/*N*/ BOOL bDel = FALSE; +/*N*/ switch ( eActType ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ aRange.aEnd.SetCol( nInt32Max ); +/*N*/ nDx = rOrgRange.aEnd.Col() - rOrgRange.aStart.Col() + 1; +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ aRange.aEnd.SetRow( nInt32Max ); +/*N*/ nDy = rOrgRange.aEnd.Row() - rOrgRange.aStart.Row() + 1; +/*N*/ break; +/*N*/ case SC_CAT_INSERT_TABS : +/*N*/ aRange.aEnd.SetTab( nInt32Max ); +/*N*/ nDz = rOrgRange.aEnd.Tab() - rOrgRange.aStart.Tab() + 1; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ aRange.aEnd.SetCol( nInt32Max ); +/*N*/ nDx = -(rOrgRange.aEnd.Col() - rOrgRange.aStart.Col() + 1); +/*N*/ aDelRange.aEnd.SetCol( aDelRange.aStart.Col() - nDx - 1 ); +/*N*/ bDel = TRUE; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ aRange.aEnd.SetRow( nInt32Max ); +/*N*/ nDy = -(rOrgRange.aEnd.Row() - rOrgRange.aStart.Row() + 1); +/*N*/ aDelRange.aEnd.SetRow( aDelRange.aStart.Row() - nDy - 1 ); +/*N*/ bDel = TRUE; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ aRange.aEnd.SetTab( nInt32Max ); +/*N*/ nDz = -(rOrgRange.aEnd.Tab() - rOrgRange.aStart.Tab() + 1); +/*N*/ aDelRange.aEnd.SetTab( aDelRange.aStart.Tab() - nDz - 1 ); +/*N*/ bDel = TRUE; +/*N*/ break; +/*N*/ case SC_CAT_MOVE : +/*N*/ eMode = URM_MOVE; +/*N*/ ((ScChangeActionMove*)pAct)->GetDelta( nDx, nDy, nDz ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "ScChangeTrack::UpdateReference: unknown Type" ); +/*N*/ } +/*N*/ if ( bUndo ) +/*N*/ { +/*N*/ nDx = -nDx; +/*N*/ nDy = -nDy; +/*N*/ nDz = -nDz; +/*N*/ } +/*N*/ if ( bDel ) +/*N*/ { //! fuer diesen Mechanismus gilt: +/*N*/ //! es gibt nur ganze, einfache geloeschte Spalten/Zeilen +/*N*/ ScChangeActionDel* pActDel = (ScChangeActionDel*) pAct; +/*N*/ if ( !bUndo ) +/*N*/ { // Delete +/*N*/ ScChangeActionType eInsType; // fuer Insert-Undo-"Deletes" +/*N*/ switch ( eActType ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ eInsType = SC_CAT_INSERT_COLS; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ eInsType = SC_CAT_INSERT_ROWS; +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ eInsType = SC_CAT_INSERT_TABS; +/*N*/ break; +/*N*/ } +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ BOOL bUpdate = TRUE; +/*N*/ if ( GetMergeState() == SC_CTMS_OTHER && +/*N*/ p->GetActionNumber() <= GetLastMerge() ) +/*N*/ { // Delete in mergendem Dokument, Action im zu mergenden +/*N*/ if ( p->IsInsertType() ) +/*N*/ { +/*N*/ // Bei Insert Referenzen nur anpassen, wenn das Delete +/*N*/ // das Insert nicht schneidet. +/*N*/ if ( !aDelRange.Intersects( p->GetBigRange() ) ) +/*N*/ p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz ); +/*N*/ bUpdate = FALSE; +/*N*/ } +/*N*/ else if ( p->GetType() == SC_CAT_CONTENT && +/*N*/ p->IsDeletedInDelType( eInsType ) ) +/*N*/ { // Content in Insert-Undo-"Delete" +/*N*/ // Nicht anpassen, wenn dieses Delete in dem +/*N*/ // Insert-"Delete" sein wuerde (ist nur verschoben). +/*N*/ if ( aDelRange.In( p->GetBigRange().aStart ) ) +/*N*/ bUpdate = FALSE; +/*N*/ else +/*N*/ { +/*N*/ const ScChangeActionLinkEntry* pLink = p->GetDeletedIn(); +/*N*/ while ( pLink && bUpdate ) +/*N*/ { +/*N*/ const ScChangeAction* pDel = pLink->GetAction(); +/*N*/ if ( pDel && pDel->GetType() == eInsType && +/*N*/ pDel->GetBigRange().In( aDelRange ) ) +/*N*/ bUpdate = FALSE; +/*N*/ pLink = pLink->GetNext(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( !bUpdate ) +/*N*/ continue; // for +/*N*/ } +/*N*/ if ( aDelRange.In( p->GetBigRange() ) ) +/*N*/ { +/*N*/ // Innerhalb eines gerade geloeschten Bereiches nicht +/*N*/ // anpassen, stattdessen dem Bereich zuordnen. +/*N*/ // Mehrfache geloeschte Bereiche "stapeln". +/*N*/ // Kreuzende Deletes setzen mehrfach geloescht. +/*N*/ if ( !p->IsDeletedInDelType( eActType ) ) +/*N*/ { +/*N*/ p->SetDeletedIn( pActDel ); +/*N*/ // GeneratedDelContent in zu loeschende Liste aufnehmen +/*N*/ if ( bGeneratedDelContents ) +/*N*/ pActDel->AddContent( (ScChangeActionContent*) p ); +/*N*/ } +/*N*/ bUpdate = FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // Eingefuegte Bereiche abschneiden, wenn Start/End im +/*N*/ // Delete liegt, aber das Insert nicht komplett innerhalb +/*N*/ // des Delete liegt bzw. das Delete nicht komplett im +/*N*/ // Insert. Das Delete merkt sich, welchem Insert es was +/*N*/ // abgeschnitten hat, es kann auch nur ein einziges Insert +/*N*/ // sein (weil Delete einspaltig/einzeilig ist). +/*N*/ // Abgeschnittene Moves kann es viele geben. +/*N*/ //! Ein Delete ist immer einspaltig/einzeilig, deswegen 1 +/*N*/ //! ohne die Ueberlappung auszurechnen. +/*N*/ switch ( p->GetType() ) +/*N*/ { +/*N*/ case SC_CAT_INSERT_COLS : +/*N*/ if ( eActType == SC_CAT_DELETE_COLS ) +/*N*/ { +/*N*/ if ( aDelRange.In( p->GetBigRange().aStart ) ) +/*N*/ { +/*N*/ pActDel->SetCutOffInsert( +/*N*/ (ScChangeActionIns*) p, 1 ); +/*N*/ p->GetBigRange().aStart.IncCol( 1 ); +/*N*/ } +/*N*/ else if ( aDelRange.In( p->GetBigRange().aEnd ) ) +/*N*/ { +/*N*/ pActDel->SetCutOffInsert( +/*N*/ (ScChangeActionIns*) p, -1 ); +/*N*/ p->GetBigRange().aEnd.IncCol( -1 ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_INSERT_ROWS : +/*N*/ if ( eActType == SC_CAT_DELETE_ROWS ) +/*N*/ { +/*N*/ if ( aDelRange.In( p->GetBigRange().aStart ) ) +/*N*/ { +/*N*/ pActDel->SetCutOffInsert( +/*N*/ (ScChangeActionIns*) p, 1 ); +/*N*/ p->GetBigRange().aStart.IncRow( 1 ); +/*N*/ } +/*N*/ else if ( aDelRange.In( p->GetBigRange().aEnd ) ) +/*N*/ { +/*N*/ pActDel->SetCutOffInsert( +/*N*/ (ScChangeActionIns*) p, -1 ); +/*N*/ p->GetBigRange().aEnd.IncRow( -1 ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_INSERT_TABS : +/*N*/ if ( eActType == SC_CAT_DELETE_TABS ) +/*N*/ { +/*N*/ if ( aDelRange.In( p->GetBigRange().aStart ) ) +/*N*/ { +/*N*/ pActDel->SetCutOffInsert( +/*N*/ (ScChangeActionIns*) p, 1 ); +/*N*/ p->GetBigRange().aStart.IncTab( 1 ); +/*N*/ } +/*N*/ else if ( aDelRange.In( p->GetBigRange().aEnd ) ) +/*N*/ { +/*N*/ pActDel->SetCutOffInsert( +/*N*/ (ScChangeActionIns*) p, -1 ); +/*N*/ p->GetBigRange().aEnd.IncTab( -1 ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SC_CAT_MOVE : +/*N*/ { +/*N*/ ScChangeActionMove* pMove = (ScChangeActionMove*) p; +/*N*/ short nFrom = 0; +/*N*/ short nTo = 0; +/*N*/ if ( aDelRange.In( pMove->GetBigRange().aStart ) ) +/*N*/ nTo = 1; +/*N*/ else if ( aDelRange.In( pMove->GetBigRange().aEnd ) ) +/*N*/ nTo = -1; +/*N*/ if ( aDelRange.In( pMove->GetFromRange().aStart ) ) +/*N*/ nFrom = 1; +/*N*/ else if ( aDelRange.In( pMove->GetFromRange().aEnd ) ) +/*N*/ nFrom = -1; +/*N*/ if ( nFrom ) +/*N*/ { +/*N*/ switch ( eActType ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ if ( nFrom > 0 ) +/*N*/ pMove->GetFromRange().aStart.IncCol( nFrom ); +/*N*/ else +/*N*/ pMove->GetFromRange().aEnd.IncCol( nFrom ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ if ( nFrom > 0 ) +/*N*/ pMove->GetFromRange().aStart.IncRow( nFrom ); +/*N*/ else +/*N*/ pMove->GetFromRange().aEnd.IncRow( nFrom ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ if ( nFrom > 0 ) +/*N*/ pMove->GetFromRange().aStart.IncTab( nFrom ); +/*N*/ else +/*N*/ pMove->GetFromRange().aEnd.IncTab( nFrom ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if ( nTo ) +/*N*/ { +/*N*/ switch ( eActType ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ if ( nTo > 0 ) +/*N*/ pMove->GetBigRange().aStart.IncCol( nTo ); +/*N*/ else +/*N*/ pMove->GetBigRange().aEnd.IncCol( nTo ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ if ( nTo > 0 ) +/*N*/ pMove->GetBigRange().aStart.IncRow( nTo ); +/*N*/ else +/*N*/ pMove->GetBigRange().aEnd.IncRow( nTo ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ if ( nTo > 0 ) +/*N*/ pMove->GetBigRange().aStart.IncTab( nTo ); +/*N*/ else +/*N*/ pMove->GetBigRange().aEnd.IncTab( nTo ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if ( nFrom || nTo ) +/*N*/ { +/*N*/ ScChangeActionDelMoveEntry* pLink = +/*N*/ pActDel->AddCutOffMove( pMove, nFrom, nTo ); +/*N*/ pMove->AddLink( pActDel, pLink ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if ( bUpdate ) +/*N*/ { +/*N*/ p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz ); +/*N*/ if ( p->GetType() == eActType && !p->IsRejected() && +/*N*/ !pActDel->IsDeletedIn() && +/*N*/ p->GetBigRange().In( aDelRange ) ) +/*N*/ pActDel->SetDeletedIn( p ); // "druntergerutscht" +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // Undo Delete +/*N*/ ScChangeAction* pNextAction = NULL; +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ BOOL bUpdate = TRUE; +/*N*/ if ( aDelRange.In( p->GetBigRange() ) ) +/*N*/ { +/*N*/ if ( p->IsDeletedInDelType( eActType ) ) +/*N*/ { +/*N*/ if ( p->IsDeletedIn( pActDel ) ) +/*N*/ { +/*N*/ if ( p->GetType() != SC_CAT_CONTENT || +/*N*/ ((ScChangeActionContent*)p)->IsTopContent() ) +/*N*/ { // erst der TopContent wird wirklich entfernt +/*N*/ p->RemoveDeletedIn( pActDel ); +/*N*/ // GeneratedDelContent _nicht_ aus Liste loeschen, +/*N*/ // wir brauchen ihn evtl. noch fuer Reject, +/*N*/ // geloescht wird in DeleteCellEntries +/*N*/ } +/*N*/ } +/*N*/ bUpdate = FALSE; +/*N*/ } +/*N*/ else if ( eActType != SC_CAT_DELETE_TABS && +/*N*/ p->IsDeletedInDelType( SC_CAT_DELETE_TABS ) ) +/*N*/ { // in geloeschten Tabellen nicht updaten, +/*N*/ // ausser wenn Tabelle verschoben wird +/*N*/ bUpdate = FALSE; +/*N*/ } +/*N*/ if ( p->GetType() == eActType && pActDel->IsDeletedIn( p ) ) +/*N*/ { +/*N*/ pActDel->RemoveDeletedIn( p ); // "druntergerutscht" +/*N*/ bUpdate = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if ( bUpdate ) +/*N*/ p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz ); +/*N*/ } +/*N*/ if ( !bGeneratedDelContents ) +/*N*/ { // die werden sonst noch fuer das echte Undo gebraucht +/*N*/ pActDel->UndoCutOffInsert(); +/*N*/ pActDel->UndoCutOffMoves(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if ( eActType == SC_CAT_MOVE ) +/*N*/ { +/*N*/ ScChangeActionMove* pActMove = (ScChangeActionMove*) pAct; +/*N*/ BOOL bLastCutMove = ( pActMove == pLastCutMove ); +/*N*/ const ScBigRange& rTo = pActMove->GetBigRange(); +/*N*/ const ScBigRange& rFrom = pActMove->GetFromRange(); +/*N*/ if ( !bUndo ) +/*N*/ { // Move +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ if ( p->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ // Inhalt in Ziel deleten (Inhalt in Quelle moven) +/*N*/ if ( rTo.In( p->GetBigRange() ) ) +/*N*/ { +/*N*/ if ( !p->IsDeletedIn( pActMove ) ) +/*N*/ { +/*N*/ p->SetDeletedIn( pActMove ); +/*N*/ // GeneratedDelContent in zu loeschende Liste aufnehmen +/*N*/ if ( bGeneratedDelContents ) +/*N*/ pActMove->AddContent( (ScChangeActionContent*) p ); +/*N*/ } +/*N*/ } +/*N*/ else if ( bLastCutMove && +/*N*/ p->GetActionNumber() > nEndLastCut && +/*N*/ rFrom.In( p->GetBigRange() ) ) +/*N*/ { // Paste Cut: neuer Content nach Cut eingefuegt, bleibt. +/*N*/ // Aufsplitten der ContentChain +/*N*/ ScChangeActionContent *pHere, *pTmp; +/*N*/ pHere = (ScChangeActionContent*) p; +/*N*/ while ( (pTmp = pHere->GetPrevContent()) && +/*N*/ pTmp->GetActionNumber() > nEndLastCut ) +/*N*/ pHere = pTmp; +/*N*/ if ( pTmp ) +/*N*/ { // wird TopContent des Move +/*N*/ pTmp->SetNextContent( NULL ); +/*N*/ pHere->SetPrevContent( NULL ); +/*N*/ } +/*N*/ do +/*N*/ { // Abhaengigkeit vom FromRange herstellen +/*N*/ AddDependentWithNotify( pActMove, pHere ); +/*N*/ } while ( pHere = pHere->GetNextContent() ); +/*N*/ } +/*N*/ else +/*N*/ p->UpdateReference( this, eMode, rFrom, nDx, nDy, nDz ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // Undo Move +/*N*/ BOOL bActRejected = pActMove->IsRejected(); +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ if ( p->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ // Inhalt in Ziel moven, wenn nicht deleted, sonst undelete +/*N*/ if ( p->IsDeletedIn( pActMove ) ) +/*N*/ { +/*N*/ if ( ((ScChangeActionContent*)p)->IsTopContent() ) +/*N*/ { // erst der TopContent wird wirklich entfernt +/*N*/ p->RemoveDeletedIn( pActMove ); +/*N*/ // GeneratedDelContent _nicht_ aus Liste loeschen, +/*N*/ // wir brauchen ihn evtl. noch fuer Reject, +/*N*/ // geloescht wird in DeleteCellEntries +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ p->UpdateReference( this, eMode, rTo, nDx, nDy, nDz ); +/*N*/ if ( bActRejected && +/*N*/ ((ScChangeActionContent*)p)->IsTopContent() && +/*N*/ rFrom.In( p->GetBigRange() ) ) +/*N*/ { // Abhaengigkeit herstellen, um Content zu schreiben +/*N*/ ScChangeActionLinkEntry* pLink = +/*N*/ pActMove->AddDependent( p ); +/*N*/ p->AddLink( pActMove, pLink ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // Insert / Undo Insert +/*N*/ switch ( GetMergeState() ) +/*N*/ { +/*N*/ case SC_CTMS_NONE : +/*N*/ case SC_CTMS_OTHER : +/*N*/ { +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SC_CTMS_PREPARE : +/*N*/ { +/*N*/ // in Insert-Undo "Deleten" +/*N*/ const ScChangeActionLinkEntry* pLink = pAct->GetFirstDependentEntry(); +/*N*/ while ( pLink ) +/*N*/ { +/*N*/ ScChangeAction* p = (ScChangeAction*) pLink->GetAction(); +/*N*/ if ( p ) +/*N*/ p->SetDeletedIn( pAct ); +/*N*/ pLink = pLink->GetNext(); +/*N*/ } +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ if ( !p->IsDeletedIn( pAct ) ) +/*N*/ p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case SC_CTMS_OWN : +/*N*/ { +/*N*/ for ( ScChangeAction* p = *ppFirstAction; p; p = p->GetNext() ) +/*N*/ { +/*N*/ if ( p == pAct ) +/*N*/ continue; // for +/*N*/ if ( !p->IsDeletedIn( pAct ) ) +/*N*/ p->UpdateReference( this, eMode, aRange, nDx, nDy, nDz ); +/*N*/ } +/*N*/ // in Insert-Undo "Delete" rueckgaengig +/*N*/ const ScChangeActionLinkEntry* pLink = pAct->GetFirstDependentEntry(); +/*N*/ while ( pLink ) +/*N*/ { +/*N*/ ScChangeAction* p = (ScChangeAction*) pLink->GetAction(); +/*N*/ if ( p ) +/*N*/ p->RemoveDeletedIn( pAct ); +/*N*/ pLink = pLink->GetNext(); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScChangeTrack::Reject( ScChangeAction* pAct, ScChangeActionTable* pTable, +/*N*/ BOOL bRecursion ) +/*N*/ { +/*N*/ if ( !pAct->IsInternalRejectable() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bOk = TRUE; +/*N*/ BOOL bRejected = FALSE; +/*N*/ if ( pAct->IsInsertType() ) +/*N*/ { +/*N*/ if ( pAct->HasDependent() && !bRecursion ) +/*N*/ { +/*N*/ const ScBigRange& rRange = pAct->GetBigRange(); +/*N*/ DBG_ASSERT( pTable, "ScChangeTrack::Reject: Insert ohne Table" ); +/*N*/ for ( ScChangeAction* p = pTable->Last(); p && bOk; p = pTable->Prev() ) +/*N*/ { +/*N*/ // keine Contents restoren, die eh geloescht werden wuerden +/*N*/ if ( p->GetType() == SC_CAT_CONTENT ) +/*N*/ p->SetRejected(); +/*N*/ else if ( p->IsDeleteType() ) +/*N*/ p->Accept(); // geloeschtes ins Nirvana +/*N*/ else +/*N*/ bOk = Reject( p, NULL, TRUE ); //! rekursiv +/*N*/ } +/*N*/ } +/*N*/ if ( bOk && (bRejected = pAct->Reject( pDoc )) ) +/*N*/ { +/*N*/ // pRefDoc NULL := geloeschte Zellen nicht speichern +/*N*/ AppendDeleteRange( pAct->GetBigRange().MakeRange(), NULL, (short) 0, +/*N*/ pAct->GetActionNumber() ); +/*N*/ } +/*N*/ } +/*N*/ else if ( pAct->IsDeleteType() ) +/*N*/ { +/*N*/ DBG_ASSERT( !pTable, "ScChangeTrack::Reject: Delete mit Table" ); +/*N*/ ScBigRange aDelRange; +/*N*/ ULONG nRejectAction = pAct->GetActionNumber(); +/*N*/ BOOL bTabDel, bTabDelOk; +/*N*/ if ( pAct->GetType() == SC_CAT_DELETE_TABS ) +/*N*/ { +/*N*/ bTabDel = TRUE; +/*N*/ aDelRange = pAct->GetBigRange(); +/*N*/ bOk = bTabDelOk = pAct->Reject( pDoc ); +/*N*/ if ( bOk ) +/*N*/ { +/*N*/ pAct = pAct->GetPrev(); +/*N*/ bOk = ( pAct && pAct->GetType() == SC_CAT_DELETE_COLS ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bTabDel = bTabDelOk = FALSE; +/*N*/ ScChangeActionDel* pDel = (ScChangeActionDel*) pAct; +/*N*/ if ( bOk ) +/*N*/ { +/*N*/ aDelRange = pDel->GetOverAllRange(); +/*N*/ bOk = aDelRange.IsValid( pDoc ); +/*N*/ } +/*N*/ BOOL bOneOk = FALSE; +/*N*/ if ( bOk ) +/*N*/ { +/*N*/ ScChangeActionType eActType = pAct->GetType(); +/*N*/ switch ( eActType ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ aDelRange.aStart.SetCol( aDelRange.aEnd.Col() ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ aDelRange.aStart.SetRow( aDelRange.aEnd.Row() ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ aDelRange.aStart.SetTab( aDelRange.aEnd.Tab() ); +/*N*/ break; +/*N*/ } +/*N*/ ScChangeAction* p = pAct; +/*N*/ BOOL bLoop = TRUE; +/*N*/ do +/*N*/ { +/*N*/ pDel = (ScChangeActionDel*) p; +/*N*/ bOk = pDel->Reject( pDoc ); +/*N*/ if ( bOk ) +/*N*/ { +/*N*/ if ( bOneOk ) +/*N*/ { +/*N*/ switch ( pDel->GetType() ) +/*N*/ { +/*N*/ case SC_CAT_DELETE_COLS : +/*N*/ aDelRange.aStart.IncCol( -1 ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_ROWS : +/*N*/ aDelRange.aStart.IncRow( -1 ); +/*N*/ break; +/*N*/ case SC_CAT_DELETE_TABS : +/*N*/ aDelRange.aStart.IncTab( -1 ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bOneOk = TRUE; +/*N*/ } +/*N*/ if ( pDel->IsBaseDelete() ) +/*N*/ bLoop = FALSE; +/*N*/ else +/*N*/ p = p->GetPrev(); +/*N*/ } while ( bOk && bLoop && p && p->GetType() == eActType && +/*N*/ !((ScChangeActionDel*)p)->IsTopDelete() ); +/*N*/ } +/*N*/ bRejected = bOk; +/*N*/ if ( bOneOk || (bTabDel && bTabDelOk) ) +/*N*/ { +/*N*/ // Delete-Reject machte UpdateReference Undo +/*N*/ ScChangeActionIns* pReject = new ScChangeActionIns( +/*N*/ aDelRange.MakeRange() ); +/*N*/ pReject->SetRejectAction( nRejectAction ); +/*N*/ pReject->SetState( SC_CAS_ACCEPTED ); +/*N*/ Append( pReject ); +/*N*/ } +/*N*/ } +/*N*/ else if ( pAct->GetType() == SC_CAT_MOVE ) +/*N*/ { +/*N*/ if ( pAct->HasDependent() && !bRecursion ) +/*N*/ { +/*N*/ const ScBigRange& rRange = pAct->GetBigRange(); +/*N*/ DBG_ASSERT( pTable, "ScChangeTrack::Reject: Move ohne Table" ); +/*N*/ for ( ScChangeAction* p = pTable->Last(); p && bOk; p = pTable->Prev() ) +/*N*/ { +/*N*/ bOk = Reject( p, NULL, TRUE ); //! rekursiv +/*N*/ } +/*N*/ } +/*N*/ if ( bOk && (bRejected = pAct->Reject( pDoc )) ) +/*N*/ { +/*N*/ ScChangeActionMove* pReject = new ScChangeActionMove( +/*N*/ pAct->GetBigRange().MakeRange(), +/*N*/ ((ScChangeActionMove*)pAct)->GetFromRange().MakeRange(), this ); +/*N*/ pReject->SetRejectAction( pAct->GetActionNumber() ); +/*N*/ pReject->SetState( SC_CAS_ACCEPTED ); +/*N*/ Append( pReject ); +/*N*/ } +/*N*/ } +/*N*/ else if ( pAct->GetType() == SC_CAT_CONTENT ) +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ ScChangeActionContent* pReject; +/*N*/ if ( bRecursion ) +/*N*/ pReject = NULL; +/*N*/ else +/*N*/ { +/*N*/ aRange = pAct->GetBigRange().aStart.MakeAddress(); +/*N*/ pReject = new ScChangeActionContent( aRange ); +/*N*/ pReject->SetOldValue( pDoc->GetCell( aRange.aStart ), pDoc, pDoc ); +/*N*/ } +/*N*/ if ( (bRejected = pAct->Reject( pDoc )) && !bRecursion ) +/*N*/ { +/*N*/ pReject->SetNewValue( pDoc->GetCell( aRange.aStart ), pDoc ); +/*N*/ pReject->SetRejectAction( pAct->GetActionNumber() ); +/*N*/ pReject->SetState( SC_CAS_ACCEPTED ); +/*N*/ Append( pReject ); +/*N*/ } +/*N*/ else if ( pReject ) +/*N*/ delete pReject; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR( "ScChangeTrack::Reject: say what?" ); +/*N*/ +/*N*/ return bRejected; +/*N*/ } + + +ULONG ScChangeTrack::AddLoadedGenerated(ScBaseCell* pNewCell, const ScBigRange& aBigRange ) +{ +/*N*/ ScChangeActionContent* pAct = new ScChangeActionContent( --nGeneratedMin, pNewCell, aBigRange, pDoc ); +/*N*/ if ( pAct ) +/*N*/ { +/*N*/ if ( pFirstGeneratedDelContent ) +/*N*/ pFirstGeneratedDelContent->pPrev = pAct; +/*N*/ pAct->pNext = pFirstGeneratedDelContent; +/*N*/ pFirstGeneratedDelContent = pAct; +/*N*/ aGeneratedTable.Insert( pAct->GetActionNumber(), pAct ); +/*N*/ return pAct->GetActionNumber(); +/*N*/ } +/*N*/ return 0; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_chgviset.cxx b/binfilter/bf_sc/source/core/tool/sc_chgviset.cxx new file mode 100644 index 000000000000..64da1b2236eb --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_chgviset.cxx @@ -0,0 +1,161 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <unotools/textsearch.hxx> + +#include "chgviset.hxx" +#include "rechead.hxx" +namespace binfilter { +// ----------------------------------------------------------------------- +/*N*/ ScChangeViewSettings::~ScChangeViewSettings() +/*N*/ { +/*N*/ if(pCommentSearcher!=NULL) +/*?*/ delete pCommentSearcher; +/*N*/ } + + +// #i49161# this is needed to save documents with change tracking +ScChangeViewSettings& ScChangeViewSettings::operator=( const ScChangeViewSettings& r ) +{ + SetTheComment(r.aComment); + + aFirstDateTime =r.aFirstDateTime; + aLastDateTime =r.aLastDateTime; + aAuthorToShow =r.aAuthorToShow; + aRangeList =r.aRangeList; + eDateMode =r.eDateMode; + bShowIt =r.bShowIt; + bIsDate =r.bIsDate; + bIsAuthor =r.bIsAuthor; + bIsComment =r.bIsComment; + bIsRange =r.bIsRange; + bEveryoneButMe =r.bEveryoneButMe; + bShowAccepted =r.bShowAccepted; + bShowRejected =r.bShowRejected; + + return *this; +} + + +/*N*/ void ScChangeViewSettings::SetTheComment(const String& rString) +/*N*/ { +/*N*/ aComment=rString; +/*N*/ if(pCommentSearcher!=NULL) +/*N*/ { +/*N*/ delete pCommentSearcher; +/*N*/ pCommentSearcher=NULL; +/*N*/ } +/*N*/ +/*N*/ if(rString.Len()>0) +/*N*/ { +/*N*/ utl::SearchParam aSearchParam( rString, +/*N*/ utl::SearchParam::SRCH_REGEXP,FALSE,FALSE,FALSE ); +/*N*/ +/*N*/ pCommentSearcher = new utl::TextSearch( aSearchParam, *ScGlobal::pCharClass ); +/*N*/ } +/*N*/ } + +/*N*/ void ScChangeViewSettings::Load( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ BYTE nByte; +/*N*/ UINT32 nDT; +/*N*/ rStream >> bShowIt; +/*N*/ rStream >> bIsDate; +/*N*/ rStream >> nByte; eDateMode = (ScChgsDateMode)nByte; +/*N*/ rStream >> nDT; aFirstDateTime.SetDate( nDT ); +/*N*/ rStream >> nDT; aFirstDateTime.SetTime( nDT ); +/*N*/ rStream >> nDT; aLastDateTime.SetDate( nDT ); +/*N*/ rStream >> nDT; aLastDateTime.SetTime( nDT ); +/*N*/ rStream >> bIsAuthor; +/*N*/ rStream >> bEveryoneButMe; +/*N*/ rStream.ReadByteString( aAuthorToShow, rStream.GetStreamCharSet() ); +/*N*/ rStream >> bIsRange; +/*N*/ aRangeList.Load( rStream, nVer ); +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ rStream >> bShowAccepted; +/*N*/ rStream >> bShowRejected; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bShowAccepted = FALSE; +/*N*/ bShowRejected = FALSE; +/*N*/ } +/*N*/ +/*N*/ // Zusaetzlich Kommentar-Informationen lesen (src509) +/*N*/ if ( aHdr.BytesLeft() ) //#59103# +/*N*/ { +/*N*/ rStream >> bIsComment; +/*N*/ rStream.ReadByteString( aComment, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bIsComment = FALSE; +/*N*/ aComment.Erase(); +/*N*/ } +/*N*/ SetTheComment(aComment); +/*N*/ } + +/*N*/ void ScChangeViewSettings::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream, 42 ); // Groesse, wenn String und RangeList leer sind +/*N*/ +/*N*/ rStream << bShowIt; +/*N*/ rStream << bIsDate; +/*N*/ rStream << (BYTE) eDateMode; +/*N*/ rStream << (UINT32) aFirstDateTime.GetDate(); +/*N*/ rStream << (UINT32) aFirstDateTime.GetTime(); +/*N*/ rStream << (UINT32) aLastDateTime.GetDate(); +/*N*/ rStream << (UINT32) aLastDateTime.GetTime(); +/*N*/ rStream << bIsAuthor; +/*N*/ rStream << bEveryoneButMe; +/*N*/ rStream.WriteByteString( aAuthorToShow, rStream.GetStreamCharSet() ); +/*N*/ rStream << bIsRange; +/*N*/ aRangeList.Store( rStream ); +/*N*/ rStream << bShowAccepted; +/*N*/ rStream << bShowRejected; +/*N*/ +/*N*/ // Zusaetzlich Kommentar-Informationen schreiben (src509) +/*N*/ if(bIsComment || aComment.Len()>0) //#59103# +/*N*/ { +/*N*/ rStream << bIsComment; +/*N*/ rStream.WriteByteString( aComment, rStream.GetStreamCharSet() ); +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_collect.cxx b/binfilter/bf_sc/source/core/tool/sc_collect.cxx new file mode 100644 index 000000000000..19116fd89860 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_collect.cxx @@ -0,0 +1,374 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <string.h> + + +#include "rechead.hxx" +#include "collect.hxx" +#include "document.hxx" +#include <tools/debug.hxx>// fuer TypedStrData Konstruktor +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ DataObject::~DataObject() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ +// Collection +//------------------------------------------------------------------------ + +/*N*/ void lcl_DeleteDataObjects( DataObject** p, USHORT nCount ) +/*N*/ { +/*N*/ if ( p ) +/*N*/ { +/*N*/ for (USHORT i = 0; i < nCount; i++) delete p[i]; +/*N*/ delete[] p; +/*N*/ p = NULL; +/*N*/ } +/*N*/ } + +/*N*/ Collection::Collection(USHORT nLim, USHORT nDel) : +/*N*/ nCount ( 0 ), +/*N*/ nLimit ( nLim ), +/*N*/ nDelta ( nDel ), +/*N*/ pItems ( NULL ) +/*N*/ { +/*N*/ if (nDelta > MAXDELTA) +/*N*/ nDelta = MAXDELTA; +/*N*/ else if (nDelta == 0) +/*N*/ nDelta = 1; +/*N*/ if (nLimit > MAXCOLLECTIONSIZE) +/*N*/ nLimit = MAXCOLLECTIONSIZE; +/*N*/ else if (nLimit < nDelta) +/*N*/ nLimit = nDelta; +/*N*/ pItems = new DataObject*[nLimit]; +/*N*/ } + +/*N*/ Collection::Collection(const Collection& rCollection) +/*N*/ : nCount ( 0 ), +/*N*/ nLimit ( 0 ), +/*N*/ nDelta ( 0 ), +/*N*/ pItems ( NULL ) +/*N*/ { +/*N*/ *this = rCollection; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ Collection::~Collection() +/*N*/ { +/*N*/ lcl_DeleteDataObjects( pItems, nCount ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void Collection::AtFree(USHORT nIndex) +/*N*/ { +/*N*/ if ((pItems) && (nIndex < nCount)) +/*N*/ { +/*N*/ delete pItems[nIndex]; +/*N*/ --nCount; // before memmove +/*N*/ memmove ( &pItems[nIndex], &pItems[nIndex + 1], (nCount - nIndex) * sizeof(DataObject*)); +/*N*/ pItems[nCount] = NULL; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void Collection::Free(DataObject* pDataObject) +/*N*/ { +/*N*/ AtFree(IndexOf(pDataObject)); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void Collection::FreeAll() +/*N*/ { +/*N*/ lcl_DeleteDataObjects( pItems, nCount ); +/*N*/ nCount = 0; +/*N*/ pItems = new DataObject*[nLimit]; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL Collection::AtInsert(USHORT nIndex, DataObject* pDataObject) +/*N*/ { +/*N*/ if ((nCount < MAXCOLLECTIONSIZE) && (nIndex <= nCount) && pItems) +/*N*/ { +/*N*/ if (nCount == nLimit) +/*N*/ { +/*N*/ DataObject** pNewItems = new DataObject*[nLimit + nDelta]; +/*N*/ if (!pNewItems) +/*N*/ return FALSE; +/*N*/ nLimit += nDelta; +/*N*/ memmove(pNewItems, pItems, nCount * sizeof(DataObject*)); +/*N*/ delete[] pItems; +/*N*/ pItems = pNewItems; +/*N*/ } +/*N*/ if (nCount > nIndex) +/*N*/ memmove(&pItems[nIndex + 1], &pItems[nIndex], (nCount - nIndex) * sizeof(DataObject*)); +/*N*/ pItems[nIndex] = pDataObject; +/*N*/ nCount++; +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL Collection::Insert(DataObject* pDataObject) +/*N*/ { +/*N*/ return AtInsert(nCount, pDataObject); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ DataObject* Collection::At(USHORT nIndex) const +/*N*/ { +/*N*/ if (nIndex < nCount) +/*N*/ return pItems[nIndex]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ USHORT Collection::IndexOf(DataObject* pDataObject) const +/*N*/ { +/*N*/ USHORT nIndex = 0xffff; +/*N*/ for (USHORT i = 0; ((i < nCount) && (nIndex == 0xffff)); i++) +/*N*/ { +/*N*/ if (pItems[i] == pDataObject) nIndex = i; +/*N*/ } +/*N*/ return nIndex; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ Collection& Collection::operator=( const Collection& r ) +/*N*/ { +/*N*/ lcl_DeleteDataObjects( pItems, nCount ); +/*N*/ +/*N*/ nCount = r.nCount; +/*N*/ nLimit = r.nLimit; +/*N*/ nDelta = r.nDelta; +/*N*/ pItems = new DataObject*[nLimit]; +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ pItems[i] = r.pItems[i]->Clone(); +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ DataObject* Collection::Clone() const +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); return NULL; //STRIP001 return new Collection(*this); +/*N*/ } + +//------------------------------------------------------------------------ +// SortedCollection +//------------------------------------------------------------------------ + +/*N*/ SortedCollection::SortedCollection(USHORT nLim, USHORT nDel, BOOL bDup) : +/*N*/ Collection (nLim, nDel), +/*N*/ bDuplicates ( bDup) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ BOOL SortedCollection::Search(DataObject* pDataObject, USHORT& rIndex) const +/*N*/ { +/*N*/ rIndex = nCount; +/*N*/ BOOL bFound = FALSE; +/*N*/ short nLo = 0; +/*N*/ short nHi = nCount - 1; +/*N*/ short nIndex; +/*N*/ short nCompare; +/*N*/ while (nLo <= nHi) +/*N*/ { +/*N*/ nIndex = (nLo + nHi) / 2; +/*N*/ nCompare = Compare(pItems[nIndex], pDataObject); +/*N*/ if (nCompare < 0) +/*N*/ nLo = nIndex + 1; +/*N*/ else +/*N*/ { +/*N*/ nHi = nIndex - 1; +/*N*/ if (nCompare == 0) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ nLo = nIndex; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ rIndex = nLo; +/*N*/ return bFound; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL SortedCollection::Insert(DataObject* pDataObject) +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ BOOL bFound = Search(pDataObject, nIndex); +/*N*/ if (bFound) +/*N*/ { +/*N*/ if (bDuplicates) +/*N*/ return AtInsert(nIndex, pDataObject); +/*N*/ else +/*N*/ return FALSE; +/*N*/ } +/*N*/ else +/*N*/ return AtInsert(nIndex, pDataObject); +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +// IsEqual - komplette Inhalte vergleichen + + +//------------------------------------------------------------------------ + +/*N*/ DataObject* StrData::Clone() const +/*N*/ { + return new StrData(*this); // #i49161# this is needed +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ short StrCollection::Compare(DataObject* pKey1, DataObject* pKey2) const +/*N*/ { +/*N*/ StringCompare eComp = ((StrData*)pKey1)->aStr.CompareTo(((StrData*)pKey2)->aStr); +/*N*/ if (eComp == COMPARE_EQUAL) +/*N*/ return 0; +/*N*/ else if (eComp == COMPARE_LESS) +/*N*/ return -1; +/*N*/ else +/*N*/ return 1; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ DataObject* StrCollection::Clone() const +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return new StrCollection(*this); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void StrCollection::Load( SvStream& rStream ) // Changetracking.sdc +/*N*/ { +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ lcl_DeleteDataObjects( pItems, nCount ); +/*N*/ BOOL bDups; +/*N*/ rStream >> bDups; +/*N*/ SetDups( bDups ); +/*N*/ rStream >> nCount >> nLimit >> nDelta; +/*N*/ pItems = new DataObject*[nLimit]; +/*N*/ String aStr; +/*N*/ rtl_TextEncoding eSet = rStream.GetStreamCharSet(); +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ { +/*N*/ rStream.ReadByteString( aStr, eSet ); +/*N*/ pItems[i] = new StrData( aStr ); +/*N*/ } +/*N*/ } + +/*N*/ void StrCollection::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream ); +/*N*/ BOOL bDups = IsDups(); +/*N*/ rStream << bDups << nCount << nLimit << nDelta; +/*N*/ rtl_TextEncoding eSet = rStream.GetStreamCharSet(); +/*N*/ for ( USHORT i=0; i<nCount; i++ ) +/*N*/ { +/*N*/ rStream.WriteByteString( ((StrData*)pItems[i])->GetString(), eSet ); +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ +// TypedStrCollection +//------------------------------------------------------------------------ + +/*N*/ TypedStrData::TypedStrData( ScDocument* pDoc, USHORT nCol, USHORT nRow, USHORT nTab, +/*N*/ BOOL bAllStrings ) +/*N*/ { +/*N*/ if ( pDoc->HasValueData( nCol, nRow, nTab ) ) +/*N*/ { +/*?*/ pDoc->GetValue( nCol, nRow, nTab, nValue ); +/*?*/ if (bAllStrings) +/*?*/ pDoc->GetString( nCol, nRow, nTab, aStrValue ); +/*?*/ nStrType = 0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pDoc->GetString( nCol, nRow, nTab, aStrValue ); +/*N*/ nValue = 0.0; +/*N*/ nStrType = 1; //! Typ uebergeben ? +/*N*/ } +/*N*/ } + +/*N*/ DataObject* TypedStrData::Clone() const +/*N*/ { +/*N*/ return new TypedStrData(*this); +/*N*/ } + + +/*N*/ short TypedStrCollection::Compare( DataObject* pKey1, DataObject* pKey2 ) const +/*N*/ { +/*N*/ short nResult = 0; +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 if ( pKey1 && pKey2 ) +/*N*/ return nResult; +/*N*/ } + + + // Gross-/Kleinschreibung anpassen + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_compiler.cxx b/binfilter/bf_sc/source/core/tool/sc_compiler.cxx new file mode 100644 index 000000000000..c238b6360f25 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_compiler.cxx @@ -0,0 +1,3240 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_sfx2/app.hxx> +#include <bf_sfx2/objsh.hxx> +#include "bf_basic/sbmeth.hxx" +#include "bf_basic/sbstar.hxx" +#include <bf_svtools/zforlist.hxx> +#include <tools/rcid.h> +#include <tools/solar.h> +#include <tools/urlobj.hxx> +#include <rtl/math.hxx> +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#include "rangenam.hxx" +#include "dbcolect.hxx" +#include "document.hxx" +#include "callform.hxx" +#include "addincol.hxx" +#include "refupdat.hxx" +#include "scresid.hxx" +#include "bf_sc.hrc" +#include "globstr.hrc" +#include "cell.hxx" +#include "dociter.hxx" +#include "docoptio.hxx" +namespace binfilter { + + +/*N*/ String* ScCompiler::pSymbolTableNative = NULL; +/*N*/ String* ScCompiler::pSymbolTableEnglish = NULL; +/*N*/ USHORT ScCompiler::nAnzStrings = 0; +/*N*/ ULONG* ScCompiler::pCharTable = 0; +/*N*/ ScOpCodeHashMap* ScCompiler::pSymbolHashMapNative = NULL; +/*N*/ ScOpCodeHashMap* ScCompiler::pSymbolHashMapEnglish = NULL; + +/*N*/ enum ScanState +/*N*/ { +/*N*/ ssGetChar, +/*N*/ ssGetBool, +/*N*/ ssGetString, +/*N*/ ssSkipString, +/*N*/ ssGetIdent, +/*N*/ ssStop +/*N*/ }; + +/*N*/ struct ScArrayStack +/*N*/ { +/*N*/ ScArrayStack* pNext; +/*N*/ ScTokenArray* pArr; +/*N*/ BOOL bTemp; +/*N*/ }; + +/*N*/ static sal_Char* pInternal[ 5 ] = { "GAME", "SPEW", "TTT", "STARCALCTEAM", "ANTWORT" }; + + +///////////////////////////////////////////////////////////////////////// + +/*N*/ short lcl_GetRetFormat( OpCode eOpCode ) +/*N*/ { +/*N*/ switch (eOpCode) +/*N*/ { +/*N*/ case ocEqual: +/*N*/ case ocNotEqual: +/*N*/ case ocLess: +/*N*/ case ocGreater: +/*N*/ case ocLessEqual: +/*N*/ case ocGreaterEqual: +/*N*/ case ocAnd: +/*N*/ case ocOr: +/*N*/ case ocNot: +/*N*/ case ocTrue: +/*N*/ case ocFalse: +/*N*/ case ocIsEmpty: +/*N*/ case ocIsString: +/*N*/ case ocIsNonString: +/*N*/ case ocIsLogical: +/*N*/ case ocIsRef: +/*N*/ case ocIsValue: +/*N*/ case ocIsFormula: +/*N*/ case ocIsNV: +/*N*/ case ocIsErr: +/*N*/ case ocIsError: +/*N*/ case ocIsEven: +/*N*/ case ocIsOdd: +/*N*/ case ocExact: +/*N*/ return NUMBERFORMAT_LOGICAL; +/*N*/ case ocGetActDate: +/*N*/ case ocGetDate: +/*N*/ case ocEasterSunday : +/*N*/ return NUMBERFORMAT_DATE; +/*N*/ case ocGetActTime: +/*N*/ return NUMBERFORMAT_DATETIME; +/*N*/ case ocGetTime: +/*N*/ return NUMBERFORMAT_TIME; +/*N*/ case ocNBW: +/*N*/ case ocBW: +/*N*/ case ocDIA: +/*N*/ case ocGDA: +/*N*/ case ocGDA2: +/*N*/ case ocVBD: +/*N*/ case ocLIA: +/*N*/ case ocRMZ: +/*N*/ case ocZW: +/*N*/ case ocZinsZ: +/*N*/ case ocKapz: +/*N*/ case ocKumZinsZ: +/*N*/ case ocKumKapZ: +/*N*/ return NUMBERFORMAT_CURRENCY; +/*N*/ case ocZins: +/*N*/ case ocIKV: +/*N*/ case ocMIRR: +/*N*/ case ocZGZ: +/*N*/ case ocEffektiv: +/*N*/ case ocNominal: +/*N*/ case ocPercentSign: +/*N*/ return NUMBERFORMAT_PERCENT; +/*N*/ // case ocSum: +/*N*/ // case ocSumSQ: +/*N*/ // case ocProduct: +/*N*/ // case ocAverage: +/*N*/ // return -1; +/*N*/ default: +/*N*/ return NUMBERFORMAT_NUMBER; +/*N*/ } +/*N*/ return NUMBERFORMAT_NUMBER; +/*N*/ } + +///////////////////////////////////////////////////////////////////////// + +/*N*/ class ScOpCodeList : public Resource // temp object fuer Resource +/*N*/ { +/*N*/ public: +/*N*/ ScOpCodeList( USHORT, String[], ScOpCodeHashMap& ); +/*N*/ }; + +/*N*/ ScOpCodeList::ScOpCodeList( USHORT nRID, String pSymbolTable[], ScOpCodeHashMap& rHashMap ) +/*N*/ : +/*N*/ Resource( ScResId( nRID ) ) +/*N*/ { +/*N*/ for (USHORT i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; i++) +/*N*/ { +/*N*/ ScResId aRes(i); +/*N*/ aRes.SetRT(RSC_STRING); +/*N*/ if (IsAvailableRes(aRes)) +/*N*/ { +/*N*/ pSymbolTable[i] = aRes; +/*N*/ rHashMap.insert( ScOpCodeHashMap::value_type( pSymbolTable[i], (OpCode) i ) ); +/*N*/ } +/*N*/ } +/*N*/ FreeResource(); +/*N*/ } + + +/*N*/ class ScCompilerRecursionGuard +/*N*/ { +/*N*/ private: +/*N*/ short& rRecursion; +/*N*/ public: +/*N*/ ScCompilerRecursionGuard( short& rRec ) +/*N*/ : rRecursion( rRec ) { ++rRecursion; } +/*N*/ ~ScCompilerRecursionGuard() { --rRecursion; } +/*N*/ }; + + +/*N*/ void ScCompiler::Init() +/*N*/ { +/*N*/ pSymbolTableNative = new String[SC_OPCODE_LAST_OPCODE_ID+1]; +/*N*/ pSymbolHashMapNative = new ScOpCodeHashMap( SC_OPCODE_LAST_OPCODE_ID+1 ); +/*N*/ ScOpCodeList aOpCodeListNative( RID_SC_FUNCTION_NAMES, pSymbolTableNative, +/*N*/ *pSymbolHashMapNative ); +/*N*/ nAnzStrings = SC_OPCODE_LAST_OPCODE_ID+1; +/*N*/ +/*N*/ pCharTable = new ULONG [128]; +/*N*/ USHORT i; +/*N*/ for (i = 0; i < 128; i++) +/*N*/ pCharTable[i] = SC_COMPILER_C_ILLEGAL; +/*N*/ /* */ pCharTable[32] = SC_COMPILER_C_CHAR_DONTCARE | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* ! */ pCharTable[33] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* " */ pCharTable[34] = SC_COMPILER_C_CHAR_STRING | SC_COMPILER_C_STRING_SEP; +/*N*/ /* # */ pCharTable[35] = SC_COMPILER_C_WORD_SEP; +/*N*/ /* $ */ pCharTable[36] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT; +/*N*/ /* % */ pCharTable[37] = SC_COMPILER_C_VALUE; +/*N*/ /* & */ pCharTable[38] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* ' */ pCharTable[39] = SC_COMPILER_C_NAME_SEP; +/*N*/ /* ( */ pCharTable[40] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* ) */ pCharTable[41] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* * */ pCharTable[42] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* + */ pCharTable[43] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_EXP | SC_COMPILER_C_VALUE_SIGN; +/*N*/ /* , */ pCharTable[44] = SC_COMPILER_C_CHAR_VALUE | SC_COMPILER_C_VALUE; +/*N*/ /* - */ pCharTable[45] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_EXP | SC_COMPILER_C_VALUE_SIGN; +/*N*/ /* . */ pCharTable[46] = SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_VALUE | SC_COMPILER_C_VALUE | SC_COMPILER_C_IDENT; +/*N*/ /* / */ pCharTable[47] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ for (i = 48; i < 58; i++) +/*N*/ /* 0-9 */ pCharTable[i] = SC_COMPILER_C_CHAR_VALUE | SC_COMPILER_C_WORD | SC_COMPILER_C_VALUE | SC_COMPILER_C_VALUE_EXP | SC_COMPILER_C_VALUE_VALUE | SC_COMPILER_C_IDENT; +/*N*/ /* : */ pCharTable[58] = SC_COMPILER_C_WORD | SC_COMPILER_C_IDENT; +/*N*/ /* ; */ pCharTable[59] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* < */ pCharTable[60] = SC_COMPILER_C_CHAR_BOOL | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* = */ pCharTable[61] = SC_COMPILER_C_CHAR | SC_COMPILER_C_BOOL | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* > */ pCharTable[62] = SC_COMPILER_C_CHAR_BOOL | SC_COMPILER_C_BOOL | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* ? */ pCharTable[63] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD; +/*N*/ /* @ */ // FREI +/*N*/ for (i = 65; i < 91; i++) +/*N*/ /* A-Z */ pCharTable[i] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT; +/*N*/ /* [ */ // FREI +/*N*/ /* \ */ // FREI +/*N*/ /* ] */ // FREI +/*N*/ /* ^ */ pCharTable[94] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; +/*N*/ /* _ */ pCharTable[95] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT; +/*N*/ /* ` */ // FREI +/*N*/ for (i = 97; i < 123; i++) +/*N*/ /* a-z */ pCharTable[i] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT; +/*N*/ /* { */ // FREI +/*N*/ /* | */ // FREI +/*N*/ /* } */ // FREI +/*N*/ /* ~ */ // FREI +/*N*/ /* 127 */ // FREI +/*N*/ } + +/*N*/ void ScCompiler::DeInit() +/*N*/ { +/*N*/ if (pSymbolTableNative) +/*N*/ { +/*N*/ delete [] pSymbolTableNative; +/*N*/ pSymbolTableNative = NULL; +/*N*/ } +/*N*/ if (pSymbolTableEnglish) +/*N*/ { +/*?*/ delete [] pSymbolTableEnglish; +/*?*/ pSymbolTableEnglish = NULL; +/*N*/ } +/*N*/ if ( pSymbolHashMapNative ) +/*N*/ { +/*?*/ pSymbolHashMapNative->clear(); +/*?*/ delete pSymbolHashMapNative; +/*?*/ pSymbolHashMapNative = NULL; +/*N*/ } +/*N*/ if ( pSymbolHashMapEnglish ) +/*N*/ { +/*?*/ pSymbolHashMapEnglish->clear(); +/*?*/ delete pSymbolHashMapEnglish; +/*?*/ pSymbolHashMapEnglish = NULL; +/*N*/ } +/*N*/ delete [] pCharTable; +/*N*/ pCharTable = NULL; +/*N*/ } + +/*N*/ void ScCompiler::SetCompileEnglish( BOOL bCompileEnglish ) +/*N*/ { +/*N*/ if ( bCompileEnglish ) +/*N*/ { +/*N*/ if ( !pSymbolTableEnglish ) +/*N*/ { +/*N*/ pSymbolTableEnglish = new String[SC_OPCODE_LAST_OPCODE_ID+1]; +/*N*/ pSymbolHashMapEnglish = new ScOpCodeHashMap( SC_OPCODE_LAST_OPCODE_ID+1 ); +/*N*/ ScOpCodeList aOpCodeListEnglish( RID_SC_FUNCTION_NAMES_ENGLISH, +/*N*/ pSymbolTableEnglish, *pSymbolHashMapEnglish ); +/*N*/ } +/*N*/ pSymbolTable = pSymbolTableEnglish; +/*N*/ pSymbolHashMap = pSymbolHashMapEnglish; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pSymbolTable = pSymbolTableNative; +/*N*/ pSymbolHashMap = pSymbolHashMapNative; +/*N*/ } +/*N*/ } + +//-----------------------Funktionen der Klasse ScCompiler---------------------- + +/*N*/ ScCompiler::ScCompiler( ScDocument* pDocument, const ScAddress& rPos, +/*N*/ const ScTokenArray& rArr ) +/*N*/ : +/*N*/ aPos( rPos ), +/*N*/ pSymbolTable( pSymbolTableNative ), +/*N*/ pSymbolHashMap( pSymbolHashMapNative ), +/*N*/ nRecursion(0), +/*N*/ bAutoCorrect( FALSE ), +/*N*/ bCorrected( FALSE ), +/*N*/ bCompileForFAP( FALSE ), +/*N*/ bIgnoreErrors( FALSE ), +/*N*/ bCompileXML( FALSE ), +/*N*/ bImportXML ( FALSE ) +/*N*/ { +/*N*/ if (!nAnzStrings) +/*?*/ Init(); +/*N*/ pArr = (ScTokenArray*) ⇒ +/*N*/ pDoc = pDocument; +/*N*/ nMaxTab = pDoc->GetTableCount() - 1; +/*N*/ pStack = NULL; +/*N*/ nNumFmt = NUMBERFORMAT_UNDEFINED; +/*N*/ } + +/*N*/ ScCompiler::ScCompiler(ScDocument* pDocument, const ScAddress& rPos ) +/*N*/ : +/*N*/ aPos( rPos ), +/*N*/ pSymbolTable( pSymbolTableNative ), +/*N*/ pSymbolHashMap( pSymbolHashMapNative ), +/*N*/ nRecursion(0), +/*N*/ bAutoCorrect( FALSE ), +/*N*/ bCorrected( FALSE ), +/*N*/ bCompileForFAP( FALSE ), +/*N*/ bIgnoreErrors( FALSE ), +/*N*/ bCompileXML( FALSE ), +/*N*/ bImportXML ( FALSE ) +/*N*/ { +/*N*/ if (!nAnzStrings) +/*?*/ Init(); +/*N*/ pDoc = pDocument; +/*N*/ nMaxTab = pDoc->GetTableCount() - 1; +/*N*/ pStack = NULL; +/*N*/ nNumFmt = NUMBERFORMAT_UNDEFINED; +/*N*/ } + + +/*N*/ void ScCompiler::MakeColStr( ::rtl::OUStringBuffer& rBuffer, USHORT nCol ) +/*N*/ { +/*N*/ if ( nCol > MAXCOL ) +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*N*/ else +/*N*/ { +/*N*/ if (nCol < 26) +/*N*/ rBuffer.append( sal_Unicode('A' + (sal_uChar) nCol)); +/*N*/ else +/*N*/ { +/*?*/ USHORT nLoCol = nCol % 26; +/*?*/ USHORT nHiCol = (nCol / 26) - 1; +/*?*/ rBuffer.append( sal_Unicode('A' + (sal_uChar)nHiCol) ); +/*?*/ rBuffer.append( sal_Unicode('A' + (sal_uChar)nLoCol) ); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScCompiler::MakeRowStr( ::rtl::OUStringBuffer& rBuffer, USHORT nRow ) +/*N*/ { +/*N*/ if ( nRow > MAXROW ) +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*N*/ else +/*N*/ rBuffer.append(sal_Int32(nRow + 1)); +/*N*/ } + +/*N*/ String ScCompiler::MakeTabStr( USHORT nTab, String& aDoc ) +/*N*/ { +/*N*/ String aString; +/*N*/ if (!pDoc->GetName(nTab, aString)) +/*?*/ aString = ScGlobal::GetRscString(STR_NO_REF_TABLE); +/*N*/ else +/*N*/ { +/*N*/ if ( aString.GetChar(0) == '\'' ) +/*N*/ { // "'Doc'#Tab" +/*N*/ xub_StrLen nPos, nLen = 1; +/*N*/ while( (nPos = aString.Search( '\'', nLen )) != STRING_NOTFOUND ) +/*N*/ nLen = nPos + 1; +/*N*/ if ( aString.GetChar(nLen) == SC_COMPILER_FILE_TAB_SEP ) +/*N*/ { +/*N*/ aDoc = aString.Copy( 0, nLen + 1 ); +/*N*/ aString.Erase( 0, nLen + 1 ); +/*N*/ aDoc = INetURLObject::decode( aDoc, INET_HEX_ESCAPE, +/*N*/ INetURLObject::DECODE_UNAMBIGUOUS ); +/*N*/ } +/*N*/ else +/*?*/ aDoc.Erase(); +/*N*/ } +/*N*/ else +/*N*/ aDoc.Erase(); +/*N*/ CheckTabQuotes( aString ); +/*N*/ } +/*N*/ aString += '.'; +/*N*/ return aString; +/*N*/ } + +/*N*/ void ScCompiler::CheckTabQuotes( String& rString ) +/*N*/ { +/*N*/ register const sal_Unicode* p = rString.GetBuffer(); +/*N*/ register const sal_Unicode* const pEnd = p + rString.Len(); +/*N*/ while ( p < pEnd ) +/*N*/ { +/*N*/ if( !IsWordChar( *p ) ) +/*N*/ { +/*N*/ rString.Insert( '\'', 0 ); +/*N*/ rString += '\''; +/*N*/ return ; +/*N*/ } +/*N*/ p++; +/*N*/ } +/*N*/ if ( CharClass::isAsciiNumeric( rString ) ) +/*N*/ { +/*N*/ rString.Insert( '\'', 0 ); +/*N*/ rString += '\''; +/*N*/ } +/*N*/ } + +/*N*/ void ScCompiler::MakeRefStr( ::rtl::OUStringBuffer& rBuffer, ComplRefData& rRef, BOOL bSingleRef ) +/*N*/ { +/*N*/ if (bCompileXML) +/*N*/ rBuffer.append(sal_Unicode('[')); +/*N*/ ComplRefData aRef( rRef ); +/*N*/ // falls abs/rel nicht separat: Relativ- in Abs-Referenzen wandeln! +/*N*/ // AdjustReference( aRef.Ref1 ); +/*N*/ // if( !bSingleRef ) +/*N*/ // AdjustReference( aRef.Ref2 ); +/*N*/ aRef.Ref1.CalcAbsIfRel( aPos ); +/*N*/ if( !bSingleRef ) +/*N*/ aRef.Ref2.CalcAbsIfRel( aPos ); +/*N*/ if( aRef.Ref1.IsFlag3D() ) +/*N*/ { +/*N*/ if (aRef.Ref1.IsTabDeleted()) +/*N*/ { +/*?*/ if (!aRef.Ref1.IsTabRel()) +/*?*/ rBuffer.append(sal_Unicode('$')); +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*?*/ rBuffer.append(sal_Unicode('.')); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ String aDoc; +/*N*/ String aRefStr( MakeTabStr( aRef.Ref1.nTab, aDoc ) ); +/*N*/ rBuffer.append(aDoc); +/*N*/ if (!aRef.Ref1.IsTabRel()) rBuffer.append(sal_Unicode('$')); +/*N*/ rBuffer.append(aRefStr); +/*N*/ } +/*N*/ } +/*N*/ else if (bCompileXML) +/*N*/ rBuffer.append(sal_Unicode('.')); +/*N*/ if (!aRef.Ref1.IsColRel()) +/*N*/ rBuffer.append(sal_Unicode('$')); +/*N*/ if ( aRef.Ref1.IsColDeleted() ) +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*N*/ else +/*N*/ MakeColStr(rBuffer, aRef.Ref1.nCol ); +/*N*/ if (!aRef.Ref1.IsRowRel()) +/*N*/ rBuffer.append(sal_Unicode('$')); +/*N*/ if ( aRef.Ref1.IsRowDeleted() ) +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*N*/ else +/*N*/ MakeRowStr( rBuffer, aRef.Ref1.nRow ); +/*N*/ if (!bSingleRef) +/*N*/ { +/*N*/ rBuffer.append(sal_Unicode(':')); +/*N*/ if (aRef.Ref2.IsFlag3D() || aRef.Ref2.nTab != aRef.Ref1.nTab) +/*N*/ { +/*?*/ if (aRef.Ref2.IsTabDeleted()) +/*?*/ { +/*?*/ if (!aRef.Ref2.IsTabRel()) +/*?*/ rBuffer.append(sal_Unicode('$')); +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*?*/ rBuffer.append(sal_Unicode('.')); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ String aDoc; +/*?*/ String aRefStr( MakeTabStr( aRef.Ref2.nTab, aDoc ) ); +/*?*/ rBuffer.append(aDoc); +/*?*/ if (!aRef.Ref2.IsTabRel()) rBuffer.append(sal_Unicode('$')); +/*?*/ rBuffer.append(aRefStr); +/*?*/ } +/*N*/ } +/*N*/ else if (bCompileXML) +/*N*/ rBuffer.append(sal_Unicode('.')); +/*N*/ if (!aRef.Ref2.IsColRel()) +/*N*/ rBuffer.append(sal_Unicode('$')); +/*N*/ if ( aRef.Ref2.IsColDeleted() ) +/*N*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*N*/ else +/*N*/ MakeColStr( rBuffer, aRef.Ref2.nCol ); +/*N*/ if (!aRef.Ref2.IsRowRel()) +/*N*/ rBuffer.append(sal_Unicode('$')); +/*N*/ if ( aRef.Ref2.IsRowDeleted() ) +/*N*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_REF_TABLE)); +/*N*/ else +/*N*/ MakeRowStr( rBuffer, aRef.Ref2.nRow ); +/*N*/ } +/*N*/ if (bCompileXML) +/*N*/ rBuffer.append(sal_Unicode(']')); +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::SetError(USHORT nError) +/*N*/ { +/*N*/ if( !pArr->GetError() ) +/*N*/ pArr->nError = nError; +/*N*/ } + + +/*N*/ sal_Unicode* lcl_UnicodeStrNCpy( sal_Unicode* pDst, const sal_Unicode* pSrc, xub_StrLen nMax ) +/*N*/ { +/*N*/ const sal_Unicode* const pStop = pDst + nMax; +/*N*/ while ( *pSrc && pDst < pStop ) +/*N*/ { +/*N*/ *pDst++ = *pSrc++; +/*N*/ } +/*N*/ *pDst = 0; +/*N*/ return pDst; +/*N*/ } + + +//--------------------------------------------------------------------------- +// NextSymbol +//--------------------------------------------------------------------------- +// Zerlegt die Formel in einzelne Symbole fuer die weitere +// Verarbeitung (Turing-Maschine). +//--------------------------------------------------------------------------- +// Ausgangs Zustand = GetChar +//---------------+-------------------+-----------------------+--------------- +// Alter Zustand | gelesenes Zeichen | Aktion | Neuer Zustand +//---------------+-------------------+-----------------------+--------------- +// GetChar | ;()+-*/^=& | Symbol=Zeichen | Stop +// | <> | Symbol=Zeichen | GetBool +// | $ Buchstabe | Symbol=Zeichen | GetWord +// | Ziffer | Symbol=Zeichen | GetValue +// | " | Keine | GetString +// | Sonst | Keine | GetChar +//---------------+-------------------+-----------------------+--------------- +// GetBool | => | Symbol=Symbol+Zeichen | Stop +// | Sonst | Dec(CharPos) | Stop +//---------------+-------------------+-----------------------+--------------- +// GetWord | SepSymbol | Dec(CharPos) | Stop +// | ()+-*/^=<>&~ | | +// | Leerzeichen | Dec(CharPos) | Stop +// | $_:. | | +// | Buchstabe,Ziffer | Symbol=Symbol+Zeichen | GetWord +// | Sonst | Fehler | Stop +//---------------|-------------------+-----------------------+--------------- +// GetValue | ;()*/^=<>& | | +// | Leerzeichen | Dec(CharPos) | Stop +// | Ziffer E+-%,. | Symbol=Symbol+Zeichen | GetValue +// | Sonst | Fehler | Stop +//---------------+-------------------+-----------------------+--------------- +// GetString | " | Keine | Stop +// | Sonst | Symbol=Symbol+Zeichen | GetString +//---------------+-------------------+-----------------------+--------------- + +/*N*/ xub_StrLen ScCompiler::NextSymbol() +/*N*/ { +/*N*/ cSymbol[MAXSTRLEN-1] = 0; // Stopper +/*N*/ sal_Unicode* pSym = cSymbol; +/*N*/ const sal_Unicode* const pStart = aFormula.GetBuffer(); +/*N*/ const sal_Unicode* pSrc = pStart + nSrcPos; +/*N*/ BOOL bi18n = FALSE; +/*N*/ sal_Unicode c = *pSrc; +/*N*/ sal_Unicode cLast = 0; +/*N*/ BOOL bQuote = FALSE; +/*N*/ ScanState eState = ssGetChar; +/*N*/ xub_StrLen nSpaces = 0; +/*N*/ // try to parse simple tokens before calling i18n parser +/*N*/ while ((c != 0) && (eState != ssStop) ) +/*N*/ { +/*N*/ pSrc++; +/*N*/ ULONG nMask = GetCharTableFlags( c ); +/*N*/ switch (eState) +/*N*/ { +/*N*/ case ssGetChar : +/*N*/ { +/*N*/ if( nMask & SC_COMPILER_C_CHAR ) +/*N*/ { +/*N*/ *pSym++ = c; +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ else if( nMask & SC_COMPILER_C_CHAR_BOOL ) +/*N*/ { +/*N*/ *pSym++ = c; +/*N*/ eState = ssGetBool; +/*N*/ } +/*N*/ else if( nMask & SC_COMPILER_C_CHAR_STRING ) +/*N*/ { +/*N*/ *pSym++ = c; +/*N*/ eState = ssGetString; +/*N*/ } +/*N*/ else if( nMask & SC_COMPILER_C_CHAR_DONTCARE ) +/*N*/ { +/*N*/ nSpaces++; +/*N*/ } +/*N*/ else if( nMask & SC_COMPILER_C_CHAR_IDENT ) +/*N*/ { // try to get a simple ASCII identifier before calling +/*N*/ // i18n, to gain performance during import +/*N*/ *pSym++ = c; +/*N*/ eState = ssGetIdent; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bi18n = TRUE; +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case ssGetIdent: +/*N*/ { +/*N*/ if ( nMask & SC_COMPILER_C_IDENT ) +/*N*/ { // this catches also $Sheet1.A1:A$2, for example +/*N*/ *pSym++ = c; +/*N*/ } +/*N*/ else if ( 128 <= c || '\'' == c ) +/*N*/ { // High values need reparsing with i18n, +/*N*/ // single quoted $'sheet' names too (otherwise we'd had to +/*N*/ // implement everything twice). +/*N*/ pSrc = pStart + nSrcPos + nSpaces; +/*N*/ pSym = cSymbol; +/*N*/ c = *pSrc; +/*N*/ bi18n = TRUE; +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pSrc--; +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case ssGetBool : +/*N*/ { +/*N*/ if( nMask & SC_COMPILER_C_BOOL ) +/*N*/ { +/*N*/ *pSym++ = c; +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pSrc--; +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case ssGetString : +/*N*/ { +/*N*/ if( nMask & SC_COMPILER_C_STRING_SEP ) +/*N*/ { +/*N*/ if ( !bQuote ) +/*N*/ { +/*N*/ if ( *pSrc == '"' ) +/*N*/ bQuote = TRUE; // "" => literal " +/*N*/ else +/*N*/ eState = ssStop; +/*N*/ } +/*N*/ else +/*N*/ bQuote = FALSE; +/*N*/ } +/*N*/ if ( !bQuote ) +/*N*/ { +/*N*/ if( pSym == &cSymbol[ MAXSTRLEN-1 ] ) +/*N*/ { +/*N*/ SetError(errStringOverflow); +/*N*/ eState = ssSkipString; +/*N*/ } +/*N*/ else +/*N*/ *pSym++ = c; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case ssSkipString: +/*N*/ if( nMask & SC_COMPILER_C_STRING_SEP ) +/*N*/ eState = ssStop; +/*N*/ break; +/*N*/ } +/*N*/ cLast = c; +/*N*/ c = *pSrc; +/*N*/ } +/*N*/ if ( bi18n ) +/*N*/ { +/*N*/ using namespace ::com::sun::star::i18n; +/*N*/ nSrcPos += nSpaces; +/*N*/ sal_Int32 nStartFlags = KParseTokens::ANY_LETTER_OR_NUMBER | +/*N*/ KParseTokens::ASC_UNDERSCORE | KParseTokens::ASC_DOLLAR; +/*N*/ sal_Int32 nContFlags = nStartFlags | KParseTokens::ASC_DOT | +/*N*/ KParseTokens::ASC_COLON; +/*N*/ // '?' allowed in range names because of Xcl :-/ +/*N*/ static const String aAddAllowed( '?' ); +/*N*/ String aSymbol; +/*N*/ USHORT nErr = 0; +/*N*/ do +/*N*/ { +/*N*/ bi18n = FALSE; +/*N*/ // special case $'sheetname' +/*N*/ if ( pStart[nSrcPos] == '$' && pStart[nSrcPos+1] == '\'' ) +/*N*/ aSymbol += pStart[nSrcPos++]; +/*N*/ +/*N*/ ParseResult aRes = ScGlobal::pCharClass->parseAnyToken( aFormula, +/*N*/ nSrcPos, nStartFlags, aAddAllowed, nContFlags, aAddAllowed ); +/*N*/ +/*N*/ if ( !aRes.TokenType ) +/*N*/ SetError( nErr = errIllegalChar ); // parsed chars as string +/*N*/ if ( aRes.EndPos <= nSrcPos ) +/*N*/ { // ?!? +/*?*/ SetError( nErr = errIllegalChar ); +/*?*/ nSrcPos = aFormula.Len(); +/*?*/ aSymbol.Erase(); +/*?*/ } +/*N*/ else +/*N*/ { +/*N*/ aSymbol.Append( pStart + nSrcPos, aRes.EndPos - nSrcPos ); +/*N*/ nSrcPos = (xub_StrLen) aRes.EndPos; +/*N*/ if ( aRes.TokenType & KParseType::SINGLE_QUOTE_NAME ) +/*N*/ { // special cases 'sheetname'. 'filename'# +/*N*/ c = pStart[nSrcPos]; +/*N*/ bi18n = (c == '.' || c == SC_COMPILER_FILE_TAB_SEP); +/*N*/ if ( bi18n ) +/*N*/ aSymbol += pStart[nSrcPos++]; +/*N*/ } +/*N*/ else if ( aRes.TokenType & KParseType::IDENTNAME ) +/*N*/ { // special cases reference:[$]'sheetname' +/*N*/ c = aSymbol.GetChar( aSymbol.Len()-1 ); +/*N*/ bi18n = ((c == ':' || c == '$') && pStart[nSrcPos] == '\''); +/*N*/ } +/*N*/ } +/*N*/ } while ( bi18n && !nErr ); +/*N*/ xub_StrLen nLen = aSymbol.Len(); +/*N*/ if ( nLen >= MAXSTRLEN ) +/*N*/ { +/*?*/ SetError( errStringOverflow ); +/*?*/ nLen = MAXSTRLEN-1; +/*N*/ } +/*N*/ lcl_UnicodeStrNCpy( cSymbol, aSymbol.GetBuffer(), nLen ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nSrcPos = pSrc - pStart; +/*N*/ *pSym = 0; +/*N*/ } +/*N*/ if ( bAutoCorrect ) +/*N*/ aCorrectedSymbol = cSymbol; +/*N*/ return nSpaces; +/*N*/ } + +//--------------------------------------------------------------------------- +// Symbol in Token Umwandeln +//--------------------------------------------------------------------------- + +/*N*/ BOOL ScCompiler::IsOpCode( const String& rName ) +/*N*/ { +/*N*/ ScOpCodeHashMap::const_iterator iLook( pSymbolHashMap->find( rName ) ); +/*N*/ BOOL bFound = (iLook != pSymbolHashMap->end()); +/*N*/ if (bFound) +/*N*/ { +/*N*/ ScRawToken aToken; +/*N*/ aToken.SetOpCode( iLook->second ); +/*N*/ pRawToken = aToken.Clone(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ bFound = ScGlobal::GetFuncCollection()->SearchFunc(cSymbol, nIndex); +/*N*/ if( bFound ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); /*N*/ ScRawToken aToken; +/*N*/ /*?*/ aToken.SetExternal( cSymbol ); +/*N*/ /*?*/ pRawToken = aToken.Clone(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // bLocalFirst=FALSE for english +/*N*/ String aIntName = ScGlobal::GetAddInCollection()-> +/*N*/ FindFunction( rName, ( pSymbolTable != pSymbolTableEnglish ) ); +/*N*/ if (aIntName.Len()) +/*N*/ { +/*N*/ ScRawToken aToken; +/*N*/ aToken.SetExternal( aIntName.GetBuffer() ); // international name +/*N*/ pRawToken = aToken.Clone(); +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( bFound && pRawToken->GetOpCode() == ocSub && +/*N*/ (eLastOp == ocOpen || eLastOp == ocSep || +/*N*/ (eLastOp > ocEndDiv && eLastOp < ocEndBinOp /*ocEndUnOp*/))) +/*N*/ pRawToken->NewOpCode( ocNegSub ); +/*N*/ return bFound; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsOpCode2( const String& rName ) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ +/*N*/ USHORT i = 0; +/*N*/ for( i = ocInternalBegin; i <= ocInternalEnd && !bFound; i++ ) +/*N*/ bFound = rName.EqualsAscii( pInternal[ i-ocInternalBegin ] ); +/*N*/ +/*N*/ if (bFound) +/*N*/ { +/*?*/ ScRawToken aToken; +/*?*/ aToken.SetOpCode( (OpCode) --i ); +/*?*/ pRawToken = aToken.Clone(); +/*N*/ } +/*N*/ return bFound; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsValue( const String& rSym ) +/*N*/ { +/*N*/ double fVal; +/*N*/ sal_uInt32 nIndex = ( pSymbolTable == pSymbolTableEnglish ? +/*N*/ pDoc->GetFormatTable()->GetStandardIndex( LANGUAGE_ENGLISH_US ) : 0 ); +/*N*/ // ULONG nIndex = 0; +/*N*/ //// ULONG nIndex = pDoc->GetFormatTable()->GetStandardIndex(ScGlobal::eLnge); +/*N*/ if (pDoc->GetFormatTable()->IsNumberFormat( rSym, nIndex, fVal ) ) +/*N*/ { +/*N*/ USHORT nType = pDoc->GetFormatTable()->GetType(nIndex); +/*N*/ const sal_Unicode* p = aFormula.GetBuffer() + nSrcPos; +/*N*/ while( *p == ' ' ) +/*N*/ p++; +/*N*/ if ( *p == '(' && nType == NUMBERFORMAT_LOGICAL) +/*N*/ return FALSE; +/*N*/ else if( aFormula.GetChar(nSrcPos) == '.' ) +/*N*/ // Numerischer Tabellenname? +/*N*/ return FALSE; +/*N*/ else +/*N*/ { +/*N*/ if( nType == NUMBERFORMAT_TEXT ) +/*N*/ // HACK: Die Zahl ist zu gross! +/*N*/ SetError( errIllegalArgument ); +/*N*/ ScRawToken aToken; +/*N*/ aToken.SetDouble( fVal ); +/*N*/ pRawToken = aToken.Clone(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsString() +/*N*/ { +/*N*/ register const sal_Unicode* p = cSymbol; +/*N*/ while ( *p ) +/*N*/ p++; +/*N*/ xub_StrLen nLen = p - cSymbol - 1; +/*N*/ BOOL bQuote = ((cSymbol[0] == '"') && (cSymbol[nLen] == '"')); +/*N*/ if ((bQuote ? nLen-2 : nLen) > MAXSTRLEN-1) +/*N*/ { +/*?*/ SetError(errStringOverflow); +/*?*/ return FALSE; +/*N*/ } +/*N*/ if ( bQuote ) +/*N*/ { +/*?*/ cSymbol[nLen] = '\0'; +/*?*/ ScRawToken aToken; +/*?*/ aToken.SetString( cSymbol+1 ); +/*?*/ pRawToken = aToken.Clone(); +/*?*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsReference( const String& rName ) +/*N*/ { +/*N*/ // Has to be called before IsValue +/*N*/ sal_Unicode ch1 = rName.GetChar(0); +/*N*/ sal_Unicode cDecSep = ( pSymbolTable == pSymbolTableEnglish ? '.' : +/*N*/ ScGlobal::pLocaleData->getNumDecimalSep().GetChar(0) ); +/*N*/ if ( ch1 == cDecSep ) +/*N*/ return FALSE; +/*N*/ // Who was that imbecile introducing '.' as the sheet name separator!?! +/*N*/ if ( CharClass::isAsciiNumeric( ch1 ) ) +/*N*/ { // Numerical sheet name is valid. +/*N*/ // But English 1.E2 or 1.E+2 is value 100, 1.E-2 is 0.01 +/*N*/ // Don't create a #REF! of values. +/*N*/ const xub_StrLen nPos = rName.Search( '.' ); +/*N*/ if ( nPos == STRING_NOTFOUND ) +/*N*/ return FALSE; +/*N*/ sal_Unicode const * const pTabSep = rName.GetBuffer() + nPos; +/*N*/ sal_Unicode ch2 = pTabSep[1]; // maybe a column identifier +/*N*/ if ( !(ch2 == '$' || CharClass::isAsciiAlpha( ch2 )) ) +/*N*/ return FALSE; +/*?*/ if ( cDecSep == '.' && (ch2 == 'E' || ch2 == 'e') // E + - digit +/*?*/ && (GetCharTableFlags( pTabSep[2] ) & SC_COMPILER_C_VALUE_EXP) ) +/*?*/ { // #91053# +/*?*/ // If it is an 1.E2 expression check if "1" is an existent sheet +/*?*/ // name. If so, a desired value 1.E2 would have to be entered as +/*?*/ // 1E2 or 1.0E2 or 1.E+2, sorry. Another possibility would be to +/*?*/ // require numerical sheet names always being entered quoted, which +/*?*/ // is not desirable (too many 1999, 2000, 2001 sheets in use). +/*?*/ // Furthermore, XML files created with versions prior to SRC640e +/*?*/ // wouldn't contain the quotes added by MakeTabStr()/CheckTabQuotes() +/*?*/ // and would produce wrong formulas if the conditions here are met. +/*?*/ // If you can live with these restrictions you may remove the +/*?*/ // check and return an unconditional FALSE. +/*?*/ String aTabName( rName.Copy( 0, nPos ) ); +/*?*/ USHORT nTab; +/*?*/ if ( !pDoc->GetTable( aTabName, nTab ) ) +/*?*/ return FALSE; +/*?*/ // If sheet "1" exists and the expression is 1.E+2 continue as +/*?*/ // usual, the ScRange/ScAddress parser will take care of it. +/*?*/ } +/*N*/ } +/*N*/ ScRange aRange( aPos, aPos ); +/*N*/ USHORT nFlags = aRange.Parse( rName, pDoc ); +/*N*/ if( nFlags & SCA_VALID ) +/*N*/ { +/*N*/ ScRawToken aToken; +/*N*/ ComplRefData aRef; +/*N*/ aRef.InitRange( aRange ); +/*N*/ aRef.Ref1.SetColRel( (nFlags & SCA_COL_ABSOLUTE) == 0 ); +/*N*/ aRef.Ref1.SetRowRel( (nFlags & SCA_ROW_ABSOLUTE) == 0 ); +/*N*/ aRef.Ref1.SetTabRel( (nFlags & SCA_TAB_ABSOLUTE) == 0 ); +/*N*/ if ( !(nFlags & SCA_VALID_TAB) ) +/*?*/ aRef.Ref1.SetTabDeleted( TRUE ); // #REF! +/*N*/ aRef.Ref1.SetFlag3D( ( nFlags & SCA_TAB_3D ) != 0 ); +/*N*/ aRef.Ref2.SetColRel( (nFlags & SCA_COL2_ABSOLUTE) == 0 ); +/*N*/ aRef.Ref2.SetRowRel( (nFlags & SCA_ROW2_ABSOLUTE) == 0 ); +/*N*/ aRef.Ref2.SetTabRel( (nFlags & SCA_TAB2_ABSOLUTE) == 0 ); +/*N*/ if ( !(nFlags & SCA_VALID_TAB2) ) +/*?*/ aRef.Ref2.SetTabDeleted( TRUE ); // #REF! +/*N*/ aRef.Ref2.SetFlag3D( ( nFlags & SCA_TAB2_3D ) != 0 ); +/*N*/ aRef.CalcRelFromAbs( aPos ); +/*N*/ aToken.SetDoubleReference( aRef ); +/*N*/ pRawToken = aToken.Clone(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScAddress aAddr( aPos ); +/*N*/ nFlags = aAddr.Parse( rName, pDoc ); +/*N*/ // Irgend etwas muss gueltig sein, +/*N*/ // damit Tabelle1.blah oder blah.a1 als (falsche) ref erkannt wird +/*N*/ if( nFlags & ( SCA_VALID_COL|SCA_VALID_ROW|SCA_VALID_TAB ) ) +/*N*/ { +/*N*/ ScRawToken aToken; +/*N*/ SingleRefData aRef; +/*N*/ aRef.InitAddress( aAddr ); +/*N*/ aRef.SetColRel( (nFlags & SCA_COL_ABSOLUTE) == 0 ); +/*N*/ aRef.SetRowRel( (nFlags & SCA_ROW_ABSOLUTE) == 0 ); +/*N*/ aRef.SetTabRel( (nFlags & SCA_TAB_ABSOLUTE) == 0 ); +/*N*/ aRef.SetFlag3D( ( nFlags & SCA_TAB_3D ) != 0 ); +/*N*/ // Die Referenz ist wirklich ungueltig! +/*N*/ if( !( nFlags & SCA_VALID ) ) +/*N*/ { +/*N*/ if( !( nFlags & SCA_VALID_COL ) ) +/*N*/ aRef.nCol = MAXCOL+1; +/*N*/ if( !( nFlags & SCA_VALID_ROW ) ) +/*N*/ aRef.nRow = MAXROW+1; +/*N*/ if( !( nFlags & SCA_VALID_TAB ) ) +/*N*/ aRef.nTab = MAXTAB+3; +/*N*/ nFlags |= SCA_VALID; +/*N*/ } +/*N*/ aRef.CalcRelFromAbs( aPos ); +/*N*/ aToken.SetSingleReference( aRef ); +/*N*/ pRawToken = aToken.Clone(); +/*N*/ } +/*N*/ } +/*N*/ return ( nFlags & SCA_VALID ) != 0; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsMacro( const String& rName ) +/*N*/ { +/*N*/ StarBASIC* pObj = 0; +/*N*/ SfxObjectShell* pDocSh = pDoc->GetDocumentShell(); +/*N*/ +/*N*/ SfxApplication* pSfxApp = SFX_APP(); +/*N*/ pSfxApp->EnterBasicCall(); // Dok-Basic anlegen etc. +/*N*/ +/*N*/ if( pDocSh )//XXX +/*N*/ pObj = pDocSh->GetBasic(); +/*N*/ else +/*?*/ pObj = pSfxApp->GetBasic(); +/*N*/ +/*N*/ SbxMethod* pMeth = (SbxMethod*) pObj->Find( rName, SbxCLASS_METHOD ); +/*N*/ if( !pMeth ) +/*N*/ { +/*N*/ pSfxApp->LeaveBasicCall(); +/*N*/ return FALSE; +/*N*/ } +/*N*/ // Es sollte schon eine BASIC-Function sein! +/*N*/ if( pMeth->GetType() == SbxVOID +/*N*/ || ( pMeth->IsFixed() && pMeth->GetType() == SbxEMPTY ) +/*N*/ || !pMeth->ISA(SbMethod) ) +/*N*/ { +/*N*/ pSfxApp->LeaveBasicCall(); +/*N*/ return FALSE; +/*N*/ } +/*?*/ DBG_BF_ASSERT(0, "STRIP"); /*N*/ ScRawToken aToken; +/*N*/ /*?*/ aToken.SetExternal( rName.GetBuffer() ); +/*N*/ /*?*/ aToken.eOp = ocMacro; +/*N*/ /*?*/ pRawToken = aToken.Clone(); +/*N*/ /*?*/ pSfxApp->LeaveBasicCall(); +/*?*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsNamedRange( const String& rName ) +/*N*/ { +/*N*/ USHORT n; +/*N*/ ScRangeName* pRangeName = pDoc->GetRangeName(); +/*N*/ if (pRangeName->SearchName( rName, n ) ) +/*N*/ { +/*N*/ ScRangeData* pData = (*pRangeName)[n]; +/*N*/ ScRawToken aToken; +/*N*/ aToken.SetName( pData->GetIndex() ); +/*N*/ pRawToken = aToken.Clone(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsDBRange( const String& rName ) +/*N*/ { +/*N*/ USHORT n; +/*N*/ ScDBCollection* pDBColl = pDoc->GetDBCollection(); +/*N*/ if (pDBColl->SearchName( rName, n ) ) +/*N*/ { +/*?*/ ScDBData* pData = (*pDBColl)[n]; +/*?*/ ScRawToken aToken; +/*?*/ aToken.SetName( pData->GetIndex() ); +/*?*/ aToken.eOp = ocDBArea; +/*?*/ pRawToken = aToken.Clone(); +/*?*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScCompiler::IsColRowName( const String& rName ) +/*N*/ { +/*N*/ BOOL bInList = FALSE; +/*N*/ BOOL bFound = FALSE; +/*N*/ SingleRefData aRef; +/*N*/ String aName( rName ); +/*N*/ DeQuote( aName ); +/*N*/ USHORT nThisTab = aPos.Tab(); +/*N*/ for ( short jThisTab = 1; jThisTab >= 0 && !bInList; jThisTab-- ) +/*N*/ { // #50300# zuerst Bereiche auf dieser Tabelle pruefen, falls doppelte Namen +/*N*/ for ( short jRow=0; jRow<2 && !bInList; jRow++ ) +/*N*/ { +/*N*/ ScRangePairList* pRL; +/*N*/ if ( !jRow ) +/*N*/ pRL = pDoc->GetColNameRanges(); +/*N*/ else +/*N*/ pRL = pDoc->GetRowNameRanges(); +/*N*/ for ( ScRangePair* pR = pRL->First(); pR && !bInList; pR = pRL->Next() ) +/*N*/ { +/*?*/ const ScRange& rNameRange = pR->GetRange(0); +/*?*/ if ( jThisTab && !(rNameRange.aStart.Tab() <= nThisTab && +/*?*/ nThisTab <= rNameRange.aEnd.Tab()) ) +/*?*/ continue; // for +/*?*/ ScCellIterator aIter( pDoc, rNameRange ); +/*?*/ for ( ScBaseCell* pCell = aIter.GetFirst(); pCell && !bInList; +/*?*/ pCell = aIter.GetNext() ) +/*?*/ { +/*?*/ // GPF wenn Zelle via CompileNameFormula auf Zelle ohne Code +/*?*/ // trifft und HasStringData/Interpret/Compile ausgefuehrt wird +/*?*/ // und das ganze dann auch noch rekursiv.. +/*?*/ // ausserdem wird *diese* Zelle hier nicht angefasst, da noch +/*?*/ // kein RPN existiert +/*?*/ CellType eType = pCell->GetCellType(); +/*?*/ BOOL bOk = (eType == CELLTYPE_FORMULA ? +/*?*/ ((ScFormulaCell*)pCell)->GetCode()->GetCodeLen() > 0 +/*?*/ && ((ScFormulaCell*)pCell)->aPos != aPos // noIter +/*?*/ : TRUE ); +/*?*/ if ( bOk && pCell->HasStringData() ) +/*?*/ { +/*?*/ String aStr; +/*?*/ switch ( eType ) +/*?*/ { +/*?*/ case CELLTYPE_STRING: +/*?*/ ((ScStringCell*)pCell)->GetString( aStr ); +/*?*/ break; +/*?*/ case CELLTYPE_FORMULA: +/*?*/ ((ScFormulaCell*)pCell)->GetString( aStr ); +/*?*/ break; +/*?*/ case CELLTYPE_EDIT: +/*?*/ ((ScEditCell*)pCell)->GetString( aStr ); +/*?*/ break; +/*?*/ } +/*?*/ if ( ScGlobal::pTransliteration->isEqual( aStr, aName ) ) +/*?*/ { +/*?*/ aRef.InitFlags(); +/*?*/ aRef.nCol = aIter.GetCol(); +/*?*/ aRef.nRow = aIter.GetRow(); +/*?*/ aRef.nTab = aIter.GetTab(); +/*?*/ if ( !jRow ) +/*?*/ aRef.SetColRel( TRUE ); // ColName +/*?*/ else +/*?*/ aRef.SetRowRel( TRUE ); // RowName +/*?*/ aRef.CalcRelFromAbs( aPos ); +/*?*/ bInList = bFound = TRUE; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( !bInList && pDoc->GetDocOptions().IsLookUpColRowNames() ) +/*N*/ { // in der aktuellen Tabelle suchen +/*N*/ long nDistance, nMax; +/*N*/ long nMyCol = (long) aPos.Col(); +/*N*/ long nMyRow = (long) aPos.Row(); +/*N*/ BOOL bTwo = FALSE; +/*N*/ ScAddress aOne( 0, 0, aPos.Tab() ); +/*N*/ ScAddress aTwo( MAXCOL, MAXROW, aPos.Tab() ); +/*N*/ ScCellIterator aIter( pDoc, ScRange( aOne, aTwo ) ); +/*N*/ for ( ScBaseCell* pCell = aIter.GetFirst(); pCell; pCell = aIter.GetNext() ) +/*N*/ { +/*N*/ if ( bFound ) +/*N*/ { // aufhoeren wenn alles andere weiter liegt +/*N*/ if ( nMax < (long)aIter.GetCol() ) +/*N*/ break; // aIter +/*N*/ } +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ BOOL bOk = (eType == CELLTYPE_FORMULA ? +/*N*/ ((ScFormulaCell*)pCell)->GetCode()->GetCodeLen() > 0 +/*N*/ && ((ScFormulaCell*)pCell)->aPos != aPos // noIter +/*N*/ : TRUE ); +/*N*/ if ( bOk && pCell->HasStringData() ) +/*N*/ { +/*N*/ String aStr; +/*N*/ switch ( eType ) +/*N*/ { +/*N*/ case CELLTYPE_STRING: +/*N*/ ((ScStringCell*)pCell)->GetString( aStr ); +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ ((ScFormulaCell*)pCell)->GetString( aStr ); +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ ((ScEditCell*)pCell)->GetString( aStr ); +/*N*/ break; +/*N*/ } +/*N*/ if ( ScGlobal::pTransliteration->isEqual( aStr, aName ) ) +/*N*/ { +/*N*/ USHORT nCol = aIter.GetCol(); +/*N*/ USHORT nRow = aIter.GetRow(); +/*N*/ long nC = nMyCol - nCol; +/*N*/ long nR = nMyRow - nRow; +/*N*/ if ( bFound ) +/*N*/ { +/*?*/ long nD = nC * nC + nR * nR; +/*?*/ if ( nD < nDistance ) +/*?*/ { +/*?*/ if ( nC < 0 || nR < 0 ) +/*?*/ { // rechts oder unterhalb +/*?*/ bTwo = TRUE; +/*?*/ aTwo.Set( nCol, nRow, aIter.GetTab() ); +/*?*/ nMax = Max( nMyCol + Abs( nC ), nMyRow + Abs( nR ) ); +/*?*/ nDistance = nD; +/*?*/ } +/*?*/ else if ( !(nRow < aOne.Row() && nMyRow >= (long)aOne.Row()) ) +/*?*/ { // links oben, nur wenn nicht weiter oberhalb +/*?*/ // des bisherigen und nMyRow darunter +/*?*/ // (CellIter geht spaltenweise!) +/*?*/ bTwo = FALSE; +/*?*/ aOne.Set( nCol, nRow, aIter.GetTab() ); +/*?*/ nMax = Max( nMyCol + nC, nMyRow + nR ); +/*?*/ nDistance = nD; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aOne.Set( nCol, nRow, aIter.GetTab() ); +/*N*/ nDistance = nC * nC + nR * nR; +/*N*/ nMax = Max( nMyCol + Abs( nC ), nMyRow + Abs( nR ) ); +/*N*/ } +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( bFound ) +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ if ( bTwo ) +/*N*/ { +/*?*/ if ( nMyCol >= (long)aOne.Col() && nMyRow >= (long)aOne.Row() ) +/*?*/ aAdr = aOne; // links oben hat Vorrang +/*?*/ else +/*?*/ { +/*?*/ if ( nMyCol < (long)aOne.Col() ) +/*?*/ { // zwei rechts +/*?*/ if ( nMyRow >= (long)aTwo.Row() ) +/*?*/ aAdr = aTwo; // direkt rechts +/*?*/ else +/*?*/ aAdr = aOne; +/*?*/ } +/*?*/ else +/*?*/ { // zwei unten oder unten und rechts, der naechstgelegene +/*?*/ long nC1 = nMyCol - aOne.Col(); +/*?*/ long nR1 = nMyRow - aOne.Row(); +/*?*/ long nC2 = nMyCol - aTwo.Col(); +/*?*/ long nR2 = nMyRow - aTwo.Row(); +/*?*/ if ( nC1 * nC1 + nR1 * nR1 <= nC2 * nC2 + nR2 * nR2 ) +/*?*/ aAdr = aOne; +/*?*/ else +/*?*/ aAdr = aTwo; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ aAdr = aOne; +/*N*/ aRef.InitAddress( aAdr ); +/*N*/ if ( (aRef.nRow != MAXROW && pDoc->HasStringData( +/*N*/ aRef.nCol, aRef.nRow + 1, aRef.nTab )) +/*N*/ || (aRef.nRow != 0 && pDoc->HasStringData( +/*N*/ aRef.nCol, aRef.nRow - 1, aRef.nTab )) ) +/*N*/ aRef.SetRowRel( TRUE ); // RowName +/*N*/ else +/*N*/ aRef.SetColRel( TRUE ); // ColName +/*N*/ aRef.CalcRelFromAbs( aPos ); +/*N*/ } +/*N*/ } +/*N*/ if ( bFound ) +/*N*/ { +/*N*/ ScRawToken aToken; +/*N*/ aToken.SetSingleReference( aRef ); +/*N*/ aToken.eOp = ocColRowName; +/*N*/ pRawToken = aToken.Clone(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::AutoCorrectParsedSymbol() +/*N*/ { +/*N*/ xub_StrLen nPos = aCorrectedSymbol.Len(); +/*N*/ if ( nPos ) +/*N*/ { +/*N*/ nPos--; +/*N*/ const sal_Unicode cQuote = '\"'; +/*N*/ const sal_Unicode cx = 'x'; +/*N*/ const sal_Unicode cX = 'X'; +/*N*/ sal_Unicode c1 = aCorrectedSymbol.GetChar( 0 ); +/*N*/ sal_Unicode c2 = aCorrectedSymbol.GetChar( nPos ); +/*N*/ if ( c1 == cQuote && c2 != cQuote ) +/*N*/ { // "... +/*N*/ // was kein Wort bildet gehoert nicht dazu. +/*N*/ // Don't be pedantic: c < 128 should be sufficient here. +/*N*/ while ( nPos && ((aCorrectedSymbol.GetChar(nPos) < 128) && +/*N*/ ((GetCharTableFlags( aCorrectedSymbol.GetChar(nPos) ) & +/*N*/ (SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_DONTCARE)) == 0)) ) +/*N*/ nPos--; +/*N*/ if ( nPos == MAXSTRLEN - 2 ) +/*N*/ aCorrectedSymbol.SetChar( nPos, cQuote ); // '"' als 255. Zeichen +/*N*/ else +/*N*/ aCorrectedSymbol.Insert( cQuote, nPos + 1 ); +/*N*/ bCorrected = TRUE; +/*N*/ } +/*N*/ else if ( c1 != cQuote && c2 == cQuote ) +/*N*/ { // ..." +/*N*/ aCorrectedSymbol.Insert( cQuote, 0 ); +/*N*/ bCorrected = TRUE; +/*N*/ } +/*N*/ else if ( nPos == 0 && (c1 == cx || c1 == cX) ) +/*N*/ { // x => * +/*N*/ aCorrectedSymbol = pSymbolTable[ocMul]; +/*N*/ bCorrected = TRUE; +/*N*/ } +/*N*/ else if ( (GetCharTableFlags( c1 ) & SC_COMPILER_C_CHAR_VALUE) +/*N*/ && (GetCharTableFlags( c2 ) & SC_COMPILER_C_CHAR_VALUE) ) +/*N*/ { +/*N*/ xub_StrLen nXcount; +/*N*/ if ( (nXcount = aCorrectedSymbol.GetTokenCount( cx )) > 1 ) +/*N*/ { // x => * +/*N*/ xub_StrLen nIndex = 0; +/*N*/ sal_Unicode c = pSymbolTable[ocMul].GetChar(0); +/*N*/ while ( (nIndex = aCorrectedSymbol.SearchAndReplace( +/*N*/ cx, c, nIndex )) != STRING_NOTFOUND ) +/*N*/ nIndex++; +/*N*/ bCorrected = TRUE; +/*N*/ } +/*N*/ if ( (nXcount = aCorrectedSymbol.GetTokenCount( cX )) > 1 ) +/*N*/ { // X => * +/*N*/ xub_StrLen nIndex = 0; +/*N*/ sal_Unicode c = pSymbolTable[ocMul].GetChar(0); +/*N*/ while ( (nIndex = aCorrectedSymbol.SearchAndReplace( +/*N*/ cX, c, nIndex )) != STRING_NOTFOUND ) +/*N*/ nIndex++; +/*N*/ bCorrected = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ String aSymbol( aCorrectedSymbol ); +/*N*/ String aDoc; +/*N*/ xub_StrLen nPos; +/*N*/ if ( aSymbol.GetChar(0) == '\'' +/*N*/ && ((nPos = aSymbol.SearchAscii( "'#" )) != STRING_NOTFOUND) ) +/*N*/ { // 'Doc'# abspalten, kann d:\... und sonstwas sein +/*N*/ aDoc = aSymbol.Copy( 0, nPos + 2 ); +/*N*/ aSymbol.Erase( 0, nPos + 2 ); +/*N*/ } +/*N*/ xub_StrLen nRefs = aSymbol.GetTokenCount( ':' ); +/*N*/ BOOL bColons; +/*N*/ if ( nRefs > 2 ) +/*N*/ { // doppelte oder zuviele ':'? B:2::C10 => B2:C10 +/*N*/ bColons = TRUE; +/*N*/ xub_StrLen nIndex = 0; +/*N*/ String aTmp1( aSymbol.GetToken( 0, ':', nIndex ) ); +/*N*/ xub_StrLen nLen1 = aTmp1.Len(); +/*N*/ String aSym, aTmp2; +/*N*/ BOOL bLastAlp, bNextNum; +/*N*/ bLastAlp = bNextNum = TRUE; +/*N*/ xub_StrLen nStrip = 0; +/*N*/ xub_StrLen nCount = nRefs; +/*N*/ for ( xub_StrLen j=1; j<nCount; j++ ) +/*N*/ { +/*N*/ aTmp2 = aSymbol.GetToken( 0, ':', nIndex ); +/*N*/ xub_StrLen nLen2 = aTmp2.Len(); +/*N*/ if ( nLen1 || nLen2 ) +/*N*/ { +/*N*/ if ( nLen1 ) +/*N*/ { +/*N*/ aSym += aTmp1; +/*N*/ bLastAlp = CharClass::isAsciiAlpha( aTmp1 ); +/*N*/ } +/*N*/ if ( nLen2 ) +/*N*/ { +/*N*/ bNextNum = CharClass::isAsciiNumeric( aTmp2 ); +/*N*/ if ( bLastAlp == bNextNum && nStrip < 1 ) +/*N*/ { // muss abwechselnd nur Zahl/String sein, +/*N*/ // nur innerhalb einer Ref strippen +/*N*/ nRefs--; +/*N*/ nStrip++; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ xub_StrLen nSymLen = aSym.Len(); +/*N*/ if ( nSymLen +/*N*/ && (aSym.GetChar( nSymLen - 1 ) != ':') ) +/*N*/ aSym += ':'; +/*N*/ nStrip = 0; +/*N*/ } +/*N*/ bLastAlp = !bNextNum; +/*N*/ } +/*N*/ else +/*N*/ { // :: +/*N*/ nRefs--; +/*N*/ if ( nLen1 ) +/*N*/ { // B10::C10 ? naechste Runde ':' anhaengen +/*N*/ if ( !bLastAlp && !CharClass::isAsciiNumeric( aTmp1 ) ) +/*N*/ nStrip++; +/*N*/ } +/*N*/ bNextNum = !bLastAlp; +/*N*/ } +/*N*/ aTmp1 = aTmp2; +/*N*/ nLen1 = nLen2; +/*N*/ } +/*N*/ else +/*N*/ nRefs--; +/*N*/ } +/*N*/ aSymbol = aSym; +/*N*/ aSymbol += aTmp1; +/*N*/ } +/*N*/ else +/*N*/ bColons = FALSE; +/*N*/ if ( nRefs && nRefs <= 2 ) +/*N*/ { // Referenzdreher? 4A => A4 etc. +/*N*/ String aTab[2], aRef[2]; +/*N*/ if ( nRefs == 2 ) +/*N*/ { +/*N*/ aRef[0] = aSymbol.GetToken( 0, ':' ); +/*N*/ aRef[1] = aSymbol.GetToken( 1, ':' ); +/*N*/ } +/*N*/ else +/*N*/ aRef[0] = aSymbol; +/*N*/ +/*N*/ BOOL bChanged = FALSE; +/*N*/ BOOL bOk = TRUE; +/*N*/ USHORT nMask = SCA_VALID | SCA_VALID_COL | SCA_VALID_ROW; +/*N*/ for ( int j=0; j<nRefs; j++ ) +/*N*/ { +/*N*/ xub_StrLen nTmp = 0; +/*N*/ xub_StrLen nPos = STRING_NOTFOUND; +/*N*/ while ( (nTmp = aRef[j].Search( '.', nTmp )) != STRING_NOTFOUND ) +/*N*/ nPos = nTmp++; // der letzte zaehlt +/*N*/ if ( nPos != STRING_NOTFOUND ) +/*N*/ { +/*N*/ aTab[j] = aRef[j].Copy( 0, nPos + 1 ); // mit '.' +/*N*/ aRef[j].Erase( 0, nPos + 1 ); +/*N*/ } +/*N*/ String aOld( aRef[j] ); +/*N*/ String aStr2; +/*N*/ const sal_Unicode* p = aRef[j].GetBuffer(); +/*N*/ while ( *p && CharClass::isAsciiNumeric( *p ) ) +/*N*/ aStr2 += *p++; +/*N*/ aRef[j] = String( p ); +/*N*/ aRef[j] += aStr2; +/*N*/ if ( bColons || aRef[j] != aOld ) +/*N*/ { +/*N*/ bChanged = TRUE; +/*N*/ ScAddress aAdr; +/*N*/ bOk &= ((aAdr.Parse( aRef[j], pDoc ) & nMask) == nMask); +/*N*/ } +/*N*/ } +/*N*/ if ( bChanged && bOk ) +/*N*/ { +/*N*/ aCorrectedSymbol = aDoc; +/*N*/ aCorrectedSymbol += aTab[0]; +/*N*/ aCorrectedSymbol += aRef[0]; +/*N*/ if ( nRefs == 2 ) +/*N*/ { +/*N*/ aCorrectedSymbol += ':'; +/*N*/ aCorrectedSymbol += aTab[1]; +/*N*/ aCorrectedSymbol += aRef[1]; +/*N*/ } +/*N*/ bCorrected = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScCompiler::NextNewToken() +/*N*/ { +/*N*/ xub_StrLen nSpaces = NextSymbol(); +/*N*/ ScRawToken aToken; +/*N*/ if( cSymbol[0] ) +/*N*/ { +/*N*/ if( nSpaces ) +/*N*/ { +/*N*/ aToken.SetOpCode( ocSpaces ); +/*N*/ aToken.cByte = (BYTE) ( nSpaces > 255 ? 255 : nSpaces ); +/*N*/ if( !pArr->AddToken( aToken ) ) +/*N*/ { +/*?*/ SetError(errCodeOverflow); return FALSE; +/*N*/ } +/*N*/ } +/*N*/ if ( (cSymbol[0] == '#' || cSymbol[0] == '$') && cSymbol[1] == 0 && +/*N*/ !bAutoCorrect ) +/*N*/ { // #101100# special case to speed up broken [$]#REF documents +/*N*/ String aBad( aFormula.Copy( nSrcPos-1 ) ); +/*N*/ eLastOp = pArr->AddBad( aBad )->GetOpCode(); +/*N*/ return FALSE; +/*N*/ } +/*N*/ if( !IsString() ) +/*N*/ { +/*N*/ BOOL bMayBeFuncName; +/*N*/ if ( cSymbol[0] < 128 ) +/*N*/ bMayBeFuncName = CharClass::isAsciiAlpha( cSymbol[0] ); +/*N*/ else +/*N*/ { +/*N*/ String aTmpStr( cSymbol[0] ); +/*N*/ bMayBeFuncName = ScGlobal::pCharClass->isLetter( aTmpStr, 0 ); +/*N*/ } +/*N*/ if ( bMayBeFuncName ) +/*N*/ { // a function name must be followed by a parenthesis +/*N*/ const sal_Unicode* p = aFormula.GetBuffer() + nSrcPos; +/*N*/ while( *p == ' ' ) +/*N*/ p++; +/*N*/ bMayBeFuncName = ( *p == '(' ); +/*N*/ } +/*N*/ else +/*N*/ bMayBeFuncName = TRUE; // operators and other opcodes +/*N*/ +/*N*/ String aOrg( cSymbol ); // evtl. Dateinamen in IsReference erhalten +/*N*/ String aUpper( ScGlobal::pCharClass->upper( aOrg ) ); +/*N*/ // Spalte DM konnte nicht referiert werden, IsReference vor IsValue +/*N*/ // #42016# italian ARCTAN.2 gab #REF! => IsOpCode vor IsReference +/*N*/ if ( !(bMayBeFuncName && IsOpCode( aUpper )) +/*N*/ && !IsReference( aOrg ) +/*N*/ && !IsValue( aUpper ) +/*N*/ && !IsNamedRange( aUpper ) +/*N*/ && !IsDBRange( aUpper ) +/*N*/ && !IsColRowName( aUpper ) +/*N*/ && !(bMayBeFuncName && IsMacro( aUpper )) +/*N*/ && !(bMayBeFuncName && IsOpCode2( aUpper )) ) +/*N*/ { +/*N*/ SetError( errNoName ); +/*N*/ if ( bAutoCorrect ) +/*N*/ { // provide single token information and continue +/*?*/ ScGlobal::pCharClass->toLower( aUpper ); +/*?*/ aToken.SetString( aUpper.GetBuffer() ); +/*?*/ aToken.NewOpCode( ocBad ); +/*?*/ pRawToken = aToken.Clone(); +/*?*/ AutoCorrectParsedSymbol(); +/*N*/ } +/*N*/ else +/*N*/ { // we don't need single token information, just a bad formula +/*N*/ String aBad( aFormula.Copy( nSrcPos - aOrg.Len() ) ); +/*N*/ eLastOp = pArr->AddBad( aBad )->GetOpCode(); +/*N*/ return FALSE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return TRUE; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ ScTokenArray* ScCompiler::CompileString( const String& rFormula ) +/*N*/ { +/*N*/ ScTokenArray aArr; +/*N*/ pArr = &aArr; +/*N*/ aFormula = rFormula; +/*N*/ aFormula.EraseLeadingChars(); +/*N*/ aFormula.EraseTrailingChars(); +/*N*/ nSrcPos = 0; +/*N*/ bCorrected = FALSE; +/*N*/ if ( bAutoCorrect ) +/*N*/ { +/*?*/ aCorrectedFormula.Erase(); +/*?*/ aCorrectedSymbol.Erase(); +/*N*/ } +/*N*/ BYTE nForced = 0; // ==Formel forciert Recalc auch wenn nicht sichtbar +/*N*/ if( aFormula.GetChar(nSrcPos) == '=' ) +/*N*/ { +/*N*/ nSrcPos++; +/*N*/ nForced++; +/*N*/ if ( bAutoCorrect ) +/*N*/ aCorrectedFormula += '='; +/*N*/ } +/*N*/ if( aFormula.GetChar(nSrcPos) == '=' ) +/*N*/ { +/*N*/ nSrcPos++; +/*N*/ nForced++; +/*N*/ if ( bAutoCorrect ) +/*N*/ aCorrectedFormula += '='; +/*N*/ } +/*N*/ short nBrackets = 0; +/*N*/ eLastOp = ocOpen; +/*N*/ while( NextNewToken() ) +/*N*/ { +/*N*/ if( pRawToken->GetOpCode() == ocOpen ) +/*N*/ nBrackets++; +/*N*/ else if( pRawToken->GetOpCode() == ocClose ) +/*N*/ { +/*N*/ if( !nBrackets ) +/*N*/ { +/*?*/ SetError( errPairExpected ); +/*?*/ if ( bAutoCorrect ) +/*?*/ { +/*?*/ bCorrected = TRUE; +/*?*/ aCorrectedSymbol.Erase(); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ nBrackets--; +/*N*/ } +/*N*/ if( !pArr->Add( pRawToken->CreateToken() ) ) +/*N*/ { +/*?*/ SetError(errCodeOverflow); break; +/*N*/ } +/*N*/ eLastOp = pRawToken->GetOpCode(); +/*N*/ if ( bAutoCorrect ) +/*N*/ aCorrectedFormula += aCorrectedSymbol; +/*N*/ } +/*N*/ if ( eLastOp != ocBad ) +/*N*/ { // bei ocBad ist der Rest der Formel String, es wuerden zuviele +/*N*/ // Klammern erscheinen +/*N*/ ScByteToken aToken( ocClose ); +/*N*/ while( nBrackets-- ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); /*N*/ if( !pArr->AddToken( aToken ) ) +/*N*/ /*?*/ { +/*N*/ /*?*/ SetError(errCodeOverflow); break; +/*N*/ /*?*/ } +/*N*/ /*?*/ if ( bAutoCorrect ) +/*N*/ /*?*/ aCorrectedFormula += pSymbolTable[ocClose]; +/*N*/ } +/*N*/ } +/*N*/ if ( nForced >= 2 ) +/*?*/ pArr->SetRecalcModeForced(); +/*N*/ // pArr merken, falls danach CompileTokenArray() kommt +/*N*/ return pArr = new ScTokenArray( aArr ); +/*N*/ } + +/*N*/ void ScCompiler::PushTokenArray( ScTokenArray* pa, BOOL bTemp ) +/*N*/ { +/*N*/ if ( bAutoCorrect && !pStack ) +/*N*/ { // #61426# don't merge stacked subroutine code into entered formula +/*?*/ aCorrectedFormula += aCorrectedSymbol; +/*?*/ aCorrectedSymbol.Erase(); +/*N*/ } +/*N*/ ScArrayStack* p = new ScArrayStack; +/*N*/ p->pNext = pStack; +/*N*/ p->pArr = pArr; +/*N*/ p->bTemp = bTemp; +/*N*/ pStack = p; +/*N*/ pArr = pa; +/*N*/ } + +/*N*/ void ScCompiler::PopTokenArray() +/*N*/ { +/*N*/ if( pStack ) +/*N*/ { +/*N*/ ScArrayStack* p = pStack; +/*N*/ pStack = p->pNext; +/*N*/ p->pArr->nRefs += pArr->nRefs; +/*N*/ // special RecalcMode aus SharedFormula uebernehmen +/*N*/ if ( pArr->IsRecalcModeAlways() ) +/*?*/ p->pArr->SetRecalcModeAlways(); +/*N*/ else if ( !pArr->IsRecalcModeNormal() && p->pArr->IsRecalcModeNormal() ) +/*?*/ p->pArr->SetMaskedRecalcMode( pArr->GetRecalcMode() ); +/*N*/ p->pArr->SetCombinedBitsRecalcMode( pArr->GetRecalcMode() ); +/*N*/ if( p->bTemp ) +/*N*/ delete pArr; +/*N*/ pArr = p->pArr; +/*N*/ delete p; +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScCompiler::GetToken() +/*N*/ { +/*N*/ static const short nRecursionMax = 42; +/*N*/ ScCompilerRecursionGuard aRecursionGuard( nRecursion ); +/*N*/ if ( nRecursion > nRecursionMax ) +/*N*/ { +/*?*/ SetError( errStackOverflow ); +/*?*/ pToken = new ScByteToken( ocStop ); +/*?*/ return FALSE; +/*N*/ } +/*N*/ if ( bAutoCorrect && !pStack ) +/*N*/ { // #61426# don't merge stacked subroutine code into entered formula +/*?*/ aCorrectedFormula += aCorrectedSymbol; +/*?*/ aCorrectedSymbol.Erase(); +/*N*/ } +/*N*/ BOOL bStop = FALSE; +/*N*/ if( pArr->GetError() && !bIgnoreErrors ) +/*N*/ bStop = TRUE; +/*N*/ else +/*N*/ { +/*N*/ short nWasColRowName; +/*N*/ if ( pArr->nIndex +/*N*/ && pArr->pCode[ pArr->nIndex-1 ]->GetOpCode() == ocColRowName ) +/*N*/ nWasColRowName = 1; +/*N*/ else +/*N*/ nWasColRowName = 0; +/*N*/ pToken = pArr->Next(); +/*N*/ while( pToken && pToken->GetOpCode() == ocSpaces ) +/*N*/ { +/*N*/ if ( nWasColRowName ) +/*N*/ nWasColRowName++; +/*N*/ if ( bAutoCorrect && !pStack ) +/*?*/ CreateStringFromToken( aCorrectedFormula, pToken, FALSE ); +/*N*/ pToken = pArr->Next(); +/*N*/ } +/*N*/ if ( bAutoCorrect && !pStack && pToken ) +/*?*/ CreateStringFromToken( aCorrectedSymbol, pToken, FALSE ); +/*N*/ if( !pToken ) +/*N*/ { +/*N*/ if( pStack ) +/*N*/ { +/*N*/ PopTokenArray(); +/*N*/ return GetToken(); +/*N*/ } +/*N*/ else +/*N*/ bStop = TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( nWasColRowName >= 2 && pToken->GetOpCode() == ocColRowName ) +/*N*/ { // aus einem ocSpaces ein ocIntersect im RPN machen +/*?*/ pToken = new ScByteToken( ocIntersect ); +/*?*/ pArr->nIndex--; // ganz schweinisch.. +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if( bStop ) +/*N*/ { +/*N*/ pToken = new ScByteToken( ocStop ); +/*N*/ return FALSE; +/*N*/ } +/*N*/ if( pToken->GetOpCode() == ocSubTotal ) +/*N*/ glSubTotal = TRUE; +/*N*/ else if( pToken->GetOpCode() == ocName ) +/*N*/ { +/*N*/ ScRangeData* pRangeData = pDoc->GetRangeName()->FindIndex( pToken->GetIndex() ); +/*N*/ if (pRangeData) +/*N*/ { +/*N*/ USHORT nErr = pRangeData->GetErrCode(); +/*N*/ if( nErr ) +/*N*/ SetError( errNoName ); +/*N*/ else if ( !bCompileForFAP ) +/*N*/ { +/*N*/ ScTokenArray* pNew; +/*N*/ // #35168# Bereichsformel klammern +/*N*/ // #37680# aber nur wenn nicht schon Klammern da, +/*N*/ // geklammerte ocSep geht nicht, z.B. SUMME((...;...)) +/*N*/ // und wenn nicht direkt zwischen ocSep/Klammer, +/*N*/ // z.B. SUMME(...;(...;...)) nicht, SUMME(...;(...)*3) ja +/*N*/ // kurz: wenn kein eigenstaendiger Ausdruck +/*N*/ ScToken* p1 = pArr->PeekPrevNoSpaces(); +/*N*/ ScToken* p2 = pArr->PeekNextNoSpaces(); +/*N*/ OpCode eOp1 = (p1 ? p1->GetOpCode() : ocSep); +/*N*/ OpCode eOp2 = (p2 ? p2->GetOpCode() : ocSep); +/*N*/ BOOL bBorder1 = (eOp1 == ocSep || eOp1 == ocOpen); +/*N*/ BOOL bBorder2 = (eOp2 == ocSep || eOp2 == ocClose); +/*N*/ BOOL bAddPair = !(bBorder1 && bBorder2); +/*N*/ if ( bAddPair ) +/*N*/ { +/*N*/ pNew = new ScTokenArray; +/*N*/ pNew->AddOpCode( ocClose ); +/*N*/ PushTokenArray( pNew, TRUE ); +/*N*/ pNew->Reset(); +/*N*/ } +/*N*/ pNew = pRangeData->GetCode()->Clone(); +/*N*/ PushTokenArray( pNew, TRUE ); +/*N*/ if( pRangeData->HasReferences() ) +/*N*/ { +/*N*/ SetRelNameReference(); +/*N*/ MoveRelWrap(); +/*N*/ } +/*N*/ pNew->Reset(); +/*N*/ if ( bAddPair ) +/*N*/ { +/*N*/ pNew = new ScTokenArray; +/*N*/ pNew->AddOpCode( ocOpen ); +/*N*/ PushTokenArray( pNew, TRUE ); +/*N*/ pNew->Reset(); +/*N*/ } +/*N*/ return GetToken(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError(errNoName); +/*N*/ } +/*N*/ else if( pToken->GetOpCode() == ocColRowName ) +/*N*/ { +/*N*/ SingleRefData& rRef = pToken->GetSingleRef(); +/*N*/ rRef.CalcAbsIfRel( aPos ); +/*N*/ if ( !rRef.Valid() ) +/*N*/ { +/*N*/ SetError( errNoRef ); +/*N*/ return TRUE; +/*N*/ } +/*N*/ USHORT nCol = rRef.nCol; +/*N*/ USHORT nRow = rRef.nRow; +/*N*/ USHORT nTab = rRef.nTab; +/*N*/ ScAddress aLook( nCol, nRow, nTab ); +/*N*/ BOOL bColName = rRef.IsColRel(); +/*N*/ USHORT nMyCol = aPos.Col(); +/*N*/ USHORT nMyRow = aPos.Row(); +/*N*/ BOOL bInList = FALSE; +/*N*/ BOOL bValidName = FALSE; +/*N*/ ScRangePairList* pRL = (bColName ? +/*N*/ pDoc->GetColNameRanges() : pDoc->GetRowNameRanges()); +/*N*/ ScRange aRange; +/*N*/ for ( ScRangePair* pR = pRL->First(); pR; pR = pRL->Next() ) +/*N*/ { +/*?*/ if ( pR->GetRange(0).In( aLook ) ) +/*?*/ { +/*?*/ bInList = bValidName = TRUE; +/*?*/ aRange = pR->GetRange(1); +/*?*/ if ( bColName ) +/*?*/ { +/*?*/ aRange.aStart.SetCol( nCol ); +/*?*/ aRange.aEnd.SetCol( nCol ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ aRange.aStart.SetRow( nRow ); +/*?*/ aRange.aEnd.SetRow( nRow ); +/*?*/ } +/*?*/ break; // for +/*?*/ } +/*N*/ } +/*N*/ if ( !bInList && pDoc->GetDocOptions().IsLookUpColRowNames() ) +/*N*/ { // automagically oder durch kopieren entstanden und NamePos nicht in Liste +/*N*/ BOOL bString = pDoc->HasStringData( nCol, nRow, nTab ); +/*N*/ if ( !bString && !pDoc->GetCell( aLook ) ) +/*N*/ bString = TRUE; // leere Zelle ist ok +/*N*/ if ( bString ) +/*N*/ { //! korrespondiert mit ScInterpreter::ScColRowNameAuto +/*N*/ bValidName = TRUE; +/*N*/ if ( bColName ) +/*N*/ { // ColName +/*N*/ USHORT nStartRow = nRow + 1; +/*N*/ if ( nStartRow > MAXROW ) +/*N*/ nStartRow = MAXROW; +/*N*/ USHORT nMaxRow = MAXROW; +/*N*/ if ( nMyCol == nCol ) +/*N*/ { // Formelzelle in gleicher Col +/*?*/ if ( nMyRow == nStartRow ) +/*?*/ { // direkt unter dem Namen den Rest nehmen +/*?*/ nStartRow++; +/*?*/ if ( nStartRow > MAXROW ) +/*?*/ nStartRow = MAXROW; +/*?*/ } +/*?*/ else if ( nMyRow > nStartRow ) +/*?*/ { // weiter unten vom Namen bis zur Formelzelle +/*?*/ nMaxRow = nMyRow - 1; +/*?*/ } +/*N*/ } +/*N*/ for ( ScRangePair* pR = pRL->First(); pR; pR = pRL->Next() ) +/*N*/ { // naechster definierter ColNameRange unten ist Row-Begrenzung +/*?*/ const ScRange& rRange = pR->GetRange(1); +/*?*/ if ( rRange.aStart.Col() <= nCol && nCol <= rRange.aEnd.Col() ) +/*?*/ { // gleicher Col Bereich +/*?*/ USHORT nTmp = rRange.aStart.Row(); +/*?*/ if ( nStartRow < nTmp && nTmp <= nMaxRow ) +/*?*/ nMaxRow = nTmp - 1; +/*?*/ } +/*N*/ } +/*N*/ aRange.aStart.Set( nCol, nStartRow, nTab ); +/*N*/ aRange.aEnd.Set( nCol, nMaxRow, nTab ); +/*N*/ } +/*N*/ else +/*N*/ { // RowName +/*N*/ USHORT nStartCol = nCol + 1; +/*N*/ if ( nStartCol > MAXCOL ) +/*N*/ nStartCol = MAXCOL; +/*N*/ USHORT nMaxCol = MAXCOL; +/*N*/ if ( nMyRow == nRow ) +/*N*/ { // Formelzelle in gleicher Row +/*N*/ if ( nMyCol == nStartCol ) +/*N*/ { // direkt neben dem Namen den Rest nehmen +/*N*/ nStartCol++; +/*N*/ if ( nStartCol > MAXCOL ) +/*N*/ nStartCol = MAXCOL; +/*N*/ } +/*N*/ else if ( nMyCol > nStartCol ) +/*N*/ { // weiter rechts vom Namen bis zur Formelzelle +/*N*/ nMaxCol = nMyCol - 1; +/*N*/ } +/*N*/ } +/*N*/ for ( ScRangePair* pR = pRL->First(); pR; pR = pRL->Next() ) +/*N*/ { // naechster definierter RowNameRange rechts ist Col-Begrenzung +/*?*/ const ScRange& rRange = pR->GetRange(1); +/*?*/ if ( rRange.aStart.Row() <= nRow && nRow <= rRange.aEnd.Row() ) +/*?*/ { // gleicher Row Bereich +/*?*/ USHORT nTmp = rRange.aStart.Col(); +/*?*/ if ( nStartCol < nTmp && nTmp <= nMaxCol ) +/*?*/ nMaxCol = nTmp - 1; +/*?*/ } +/*N*/ } +/*N*/ aRange.aStart.Set( nStartCol, nRow, nTab ); +/*N*/ aRange.aEnd.Set( nMaxCol, nRow, nTab ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( bValidName ) +/*N*/ { +/*N*/ // Und nun der Zauber zur Unterscheidung zwischen +/*N*/ // Bereich und einer einzelnen Zelle daraus, die +/*N*/ // positionsabhaengig von der Formelzelle gewaehlt wird. +/*N*/ // Ist ein direkter Nachbar ein binaerer Operator (ocAdd etc.) +/*N*/ // so wird eine SingleRef passend zur Col/Row generiert, +/*N*/ // ocColRowName bzw. ocIntersect als Nachbar => Range. +/*N*/ // Spezialfall: Beschriftung gilt fuer eine einzelne Zelle, +/*N*/ // dann wird eine positionsunabhaengige SingleRef generiert. +/*N*/ BOOL bSingle = (aRange.aStart == aRange.aEnd); +/*N*/ BOOL bFound; +/*N*/ if ( bSingle ) +/*N*/ bFound = TRUE; +/*N*/ else +/*N*/ { +/*N*/ ScToken* p1 = pArr->PeekPrevNoSpaces(); +/*N*/ ScToken* p2 = pArr->PeekNextNoSpaces(); +/*N*/ // Anfang/Ende einer Formel => Single +/*N*/ OpCode eOp1 = p1 ? p1->GetOpCode() : ocAdd; +/*N*/ OpCode eOp2 = p2 ? p2->GetOpCode() : ocAdd; +/*N*/ if ( eOp1 != ocColRowName && eOp1 != ocIntersect +/*N*/ && eOp2 != ocColRowName && eOp2 != ocIntersect ) +/*N*/ { +/*N*/ if ( (ocEndDiv < eOp1 && eOp1 < ocEndBinOp) +/*N*/ || (ocEndDiv < eOp2 && eOp2 < ocEndBinOp) ) +/*N*/ bSingle = TRUE; +/*N*/ } +/*N*/ if ( bSingle ) +/*N*/ { // Col bzw. Row muss zum Range passen +/*N*/ if ( bColName ) +/*N*/ { +/*N*/ bFound = (aRange.aStart.Row() <= nMyRow +/*N*/ && nMyRow <= aRange.aEnd.Row()); +/*N*/ if ( bFound ) +/*N*/ aRange.aStart.SetRow( nMyRow ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ bFound = (aRange.aStart.Col() <= nMyCol +/*N*/ && nMyCol <= aRange.aEnd.Col()); +/*N*/ if ( bFound ) +/*?*/ aRange.aStart.SetCol( nMyCol ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ if ( !bFound ) +/*N*/ SetError(errNoRef); +/*N*/ else if ( !bCompileForFAP ) +/*N*/ { +/*N*/ ScTokenArray* pNew = new ScTokenArray; +/*N*/ if ( bSingle ) +/*N*/ { +/*N*/ SingleRefData aRefData; +/*N*/ aRefData.InitAddress( aRange.aStart ); +/*N*/ if ( bColName ) +/*N*/ aRefData.SetColRel( TRUE ); +/*N*/ else +/*?*/ aRefData.SetRowRel( TRUE ); +/*N*/ aRefData.CalcRelFromAbs( aPos ); +/*N*/ pNew->AddSingleReference( aRefData ); +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ ComplRefData aRefData; +/*?*/ aRefData.InitRange( aRange ); +/*?*/ if ( bColName ) +/*?*/ { +/*?*/ aRefData.Ref1.SetColRel( TRUE ); +/*?*/ aRefData.Ref2.SetColRel( TRUE ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ aRefData.Ref1.SetRowRel( TRUE ); +/*?*/ aRefData.Ref2.SetRowRel( TRUE ); +/*?*/ } +/*?*/ aRefData.CalcRelFromAbs( aPos ); +/*?*/ if ( bInList ) +/*?*/ pNew->AddDoubleReference( aRefData ); +/*?*/ else +/*?*/ { // automagically +/*?*/ pNew->Add( new ScDoubleRefToken( ocColRowNameAuto, +/*?*/ aRefData ) ); +/*?*/ } +/*N*/ } +/*N*/ PushTokenArray( pNew, TRUE ); +/*N*/ pNew->Reset(); +/*N*/ return GetToken(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError(errNoName); +/*N*/ } +/*N*/ else if( pToken->GetOpCode() == ocDBArea ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); /*N*/ ScDBData* pDBData = pDoc->GetDBCollection()->FindIndex( pToken->GetIndex() ); +/*N*/ /*?*/ if ( !pDBData ) +/*N*/ /*?*/ SetError(errNoName); +/*N*/ /*?*/ else if ( !bCompileForFAP ) +/*N*/ /*?*/ { +/*N*/ /*?*/ ComplRefData aRefData; +/*N*/ /*?*/ aRefData.InitFlags(); +/*N*/ /*?*/ pDBData->GetArea( (USHORT&) aRefData.Ref1.nTab, +/*N*/ /*?*/ (USHORT&) aRefData.Ref1.nCol, +/*N*/ /*?*/ (USHORT&) aRefData.Ref1.nRow, +/*N*/ /*?*/ (USHORT&) aRefData.Ref2.nCol, +/*N*/ /*?*/ (USHORT&) aRefData.Ref2.nRow); +/*N*/ /*?*/ aRefData.Ref2.nTab = aRefData.Ref1.nTab; +/*N*/ /*?*/ aRefData.CalcRelFromAbs( aPos ); +/*N*/ /*?*/ ScTokenArray* pNew = new ScTokenArray; +/*N*/ /*?*/ pNew->AddDoubleReference( aRefData ); +/*N*/ /*?*/ PushTokenArray( pNew, TRUE ); +/*N*/ /*?*/ pNew->Reset(); +/*N*/ /*?*/ return GetToken(); +/*N*/ /*?*/ } +/*N*/ } +/*N*/ else if( pToken->GetType() == svSingleRef ) +/*N*/ { +/*N*/ // if (!pDoc->HasTable( pToken->aRef.Ref1.nTab ) ) +/*N*/ // SetError(errNoRef); +/*N*/ pArr->nRefs++; +/*N*/ } +/*N*/ else if( pToken->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ // if (!pDoc->HasTable( pToken->aRef.Ref1.nTab ) || +/*N*/ // !pDoc->HasTable( pToken->aRef.Ref2.nTab )) +/*N*/ // SetError(errNoRef); +/*N*/ pArr->nRefs++; +/*N*/ } +/*N*/ return TRUE; +/*N*/ } + +/*N*/ OpCode ScCompiler::NextToken() +/*N*/ { +/*N*/ if( !GetToken() ) +/*N*/ return ocStop; +/*N*/ OpCode eOp = pToken->GetOpCode(); +/*N*/ // #38815# CompileTokenArray mit zurueckgesetztem Fehler gibt wieder Fehler +/*N*/ if ( eOp == ocBad ) +/*N*/ SetError( errNoName ); +/*N*/ // Vor einem Push muss ein Operator kommen +/*N*/ if ( (eOp == ocPush || eOp == ocColRowNameAuto) && +/*N*/ !( (eLastOp == ocOpen) || (eLastOp == ocSep) || +/*N*/ ((eLastOp > ocEndDiv) && (eLastOp < ocEndUnOp))) ) +/*?*/ SetError(errOperatorExpected); +/*N*/ // Operator und Plus = Operator +/*N*/ BOOL bLastOp = ( eLastOp == ocOpen || eLastOp == ocSep || +/*N*/ (eLastOp > ocEndDiv && eLastOp < ocEndUnOp) +/*N*/ ); +/*N*/ if( bLastOp && eOp == ocAdd ) +/*N*/ eOp = NextToken(); +/*N*/ else +/*N*/ { +/*N*/ // Vor einem Operator darf kein weiterer Operator stehen +/*N*/ // Aber AND, OR ist OK +/*N*/ if ( eOp != ocAnd && eOp != ocOr +/*N*/ && ( eOp > ocEndDiv && eOp < ocEndBinOp ) +/*N*/ && ( eLastOp == ocOpen || eLastOp == ocSep +/*N*/ || (eLastOp > ocEndDiv && eLastOp < ocEndUnOp)) ) +/*N*/ { +/*?*/ SetError(errVariableExpected); +/*?*/ if ( bAutoCorrect && !pStack ) +/*?*/ { +/*?*/ if ( eOp == eLastOp || eLastOp == ocOpen ) +/*?*/ { // doppelten Operator verwerfen +/*?*/ aCorrectedSymbol.Erase(); +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ xub_StrLen nPos = aCorrectedFormula.Len(); +/*?*/ if ( nPos ) +/*?*/ { +/*?*/ nPos--; +/*?*/ sal_Unicode c = aCorrectedFormula.GetChar( nPos ); +/*?*/ switch ( eOp ) +/*?*/ { // Operatoren vertauschen +/*?*/ case ocGreater: +/*?*/ if ( c == pSymbolTable[ocEqual].GetChar(0) ) +/*?*/ { // >= ist richtig statt => +/*?*/ aCorrectedFormula.SetChar( nPos, +/*?*/ pSymbolTable[ocGreater].GetChar(0) ); +/*?*/ aCorrectedSymbol = c; +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ break; +/*?*/ case ocLess: +/*?*/ if ( c == pSymbolTable[ocEqual].GetChar(0) ) +/*?*/ { // <= ist richtig statt =< +/*?*/ aCorrectedFormula.SetChar( nPos, +/*?*/ pSymbolTable[ocLess].GetChar(0) ); +/*?*/ aCorrectedSymbol = c; +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ else if ( c == pSymbolTable[ocGreater].GetChar(0) ) +/*?*/ { // <> ist richtig statt >< +/*?*/ aCorrectedFormula.SetChar( nPos, +/*?*/ pSymbolTable[ocLess].GetChar(0) ); +/*?*/ aCorrectedSymbol = c; +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ break; +/*?*/ case ocMul: +/*?*/ if ( c == pSymbolTable[ocSub].GetChar(0) ) +/*?*/ { // *- statt -* +/*?*/ aCorrectedFormula.SetChar( nPos, +/*?*/ pSymbolTable[ocMul].GetChar(0) ); +/*?*/ aCorrectedSymbol = c; +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ break; +/*?*/ case ocDiv: +/*?*/ if ( c == pSymbolTable[ocSub].GetChar(0) ) +/*?*/ { // /- statt -/ +/*?*/ aCorrectedFormula.SetChar( nPos, +/*?*/ pSymbolTable[ocDiv].GetChar(0) ); +/*?*/ aCorrectedSymbol = c; +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ eLastOp = eOp; +/*N*/ } +/*N*/ return eOp; +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ BOOL ScCompiler::CompileTokenArray() +/*N*/ { +/*N*/ glSubTotal = FALSE; +/*N*/ bCorrected = FALSE; +/*N*/ if( !pArr->nError || bIgnoreErrors ) +/*N*/ { +/*N*/ if ( bAutoCorrect ) +/*N*/ { +/*?*/ aCorrectedFormula.Erase(); +/*?*/ aCorrectedSymbol.Erase(); +/*N*/ } +/*N*/ pArr->nRefs = 0; // wird neu gezaehlt +/*N*/ pArr->DelRPN(); +/*N*/ pStack = NULL; +/*N*/ ScToken* pData[ MAXCODE ]; +/*N*/ pCode = pData; +/*N*/ BOOL bWasForced = pArr->IsRecalcModeForced(); +/*N*/ if ( bWasForced ) +/*N*/ { +/*N*/ if ( bAutoCorrect ) +/*N*/ aCorrectedFormula = '='; +/*N*/ } +/*N*/ pArr->ClearRecalcMode(); +/*N*/ pArr->Reset(); +/*N*/ eLastOp = ocOpen; +/*N*/ pc = 0; +/*N*/ NextToken(); +/*N*/ Expression(); +/*N*/ +/*N*/ USHORT nErrorBeforePop = pArr->nError; +/*N*/ +/*N*/ while( pStack ) +/*?*/ PopTokenArray(); +/*N*/ if( pc ) +/*N*/ { +/*N*/ pArr->pRPN = new ScToken*[ pc ]; +/*N*/ pArr->nRPN = pc; +/*N*/ memcpy( pArr->pRPN, pData, pc * sizeof( ScToken* ) ); +/*N*/ } +/*N*/ +/*N*/ if( !pArr->nError && nErrorBeforePop ) +/*N*/ pArr->nError = nErrorBeforePop; // einmal Fehler, immer Fehler +/*N*/ +/*N*/ if( pArr->nError && !bIgnoreErrors ) +/*N*/ pArr->DelRPN(); +/*N*/ +/*N*/ if ( bWasForced ) +/*?*/ pArr->SetRecalcModeForced(); +/*N*/ } +/*N*/ if( nNumFmt == NUMBERFORMAT_UNDEFINED ) +/*N*/ nNumFmt = NUMBERFORMAT_NUMBER; +/*N*/ return glSubTotal; +/*N*/ } + +//--------------------------------------------------------------------------- +// Token in den Code Eintragen +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::PutCode( ScToken* p ) +/*N*/ { +/*N*/ if( pc >= MAXCODE-1 ) +/*N*/ { +/*?*/ if ( pc == MAXCODE-1 ) +/*?*/ { +/*?*/ p = new ScByteToken( ocStop ); +/*?*/ *pCode++ = p; +/*?*/ ++pc; +/*?*/ p->IncRef(); +/*?*/ } +/*?*/ SetError(errCodeOverflow); +/*?*/ return; +/*N*/ } +/*N*/ if( pArr->GetError() && !bCompileForFAP ) +/*N*/ return; +/*N*/ *pCode++ = p; pc++; +/*N*/ p->IncRef(); +/*N*/ } + +//--------------------------------------------------------------------------- +// UPN-Erzeugung (durch Rekursion) +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::Factor() +/*N*/ { +/*N*/ if ( pArr->GetError() && !bIgnoreErrors ) +/*N*/ return; +/*N*/ ScTokenRef pFacToken; +/*N*/ OpCode eOp = pToken->GetOpCode(); +/*N*/ if( eOp == ocPush || eOp == ocColRowNameAuto || eOp == ocMatRef || +/*N*/ eOp == ocDBArea +/*N*/ || (bCompileForFAP && ((eOp == ocName) || (eOp == ocDBArea) +/*N*/ || (eOp == ocColRowName) || (eOp == ocBad))) +/*N*/ ) +/*N*/ { +/*N*/ PutCode( pToken ); +/*N*/ eOp = NextToken(); +/*N*/ if( eOp == ocOpen ) +/*N*/ { +/*?*/ // PUSH( ist ein Fehler, der durch eine unbekannte +/*?*/ // Funktion hervorgerufen wird. +/*?*/ SetError( +/*?*/ ( pToken->GetType() == svString +/*?*/ || pToken->GetType() == svSingleRef ) +/*?*/ ? errNoName : errOperatorExpected ); +/*?*/ if ( bAutoCorrect && !pStack ) +/*?*/ { // Multiplikation annehmen +/*?*/ aCorrectedFormula += pSymbolTable[ocMul]; +/*?*/ bCorrected = TRUE; +/*?*/ NextToken(); +/*?*/ eOp = Expression(); +/*?*/ if( eOp != ocClose ) +/*?*/ SetError(errPairExpected); +/*?*/ else +/*?*/ eOp = NextToken(); +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ else if( eOp == ocOpen ) +/*N*/ { +/*N*/ NextToken(); +/*N*/ eOp = Expression(); +/*N*/ if( eOp != ocClose ) +/*N*/ SetError(errPairExpected); +/*N*/ else +/*N*/ eOp = NextToken(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if( nNumFmt == NUMBERFORMAT_UNDEFINED ) +/*N*/ nNumFmt = lcl_GetRetFormat( eOp ); +/*N*/ if( eOp > ocEndUnOp && eOp < ocEndNoPar) +/*N*/ { +/*N*/ // Diese Funktionen muessen immer neu berechnet werden +/*N*/ switch( eOp ) +/*N*/ { +/*N*/ case ocRandom: +/*N*/ case ocGetActDate: +/*N*/ case ocGetActTime: +/*N*/ pArr->SetRecalcModeAlways(); +/*N*/ break; +/*N*/ } +/*N*/ pFacToken = pToken; +/*N*/ eOp = NextToken(); +/*N*/ if (eOp != ocOpen) +/*N*/ { +/*?*/ SetError(errPairExpected); +/*?*/ PutCode( pFacToken ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ eOp = NextToken(); +/*N*/ if (eOp != ocClose) +/*?*/ SetError(errPairExpected); +/*N*/ PutCode(pFacToken); +/*N*/ eOp = NextToken(); +/*N*/ } +/*N*/ } +/*N*/ // Spezialfall NICHT() und NEG() +/*N*/ else if( eOp == ocNot || eOp == ocNeg +/*N*/ || ( eOp > ocEndNoPar && eOp < ocEnd1Par) ) +/*N*/ { +/*N*/ // Functions that have to be always recalculated +/*N*/ switch( eOp ) +/*N*/ { +/*N*/ case ocFormula: +/*?*/ pArr->SetRecalcModeAlways(); +/*N*/ break; +/*N*/ } +/*N*/ pFacToken = pToken; +/*N*/ eOp = NextToken(); +/*N*/ if( nNumFmt == NUMBERFORMAT_UNDEFINED && eOp == ocNot ) +/*N*/ nNumFmt = NUMBERFORMAT_LOGICAL; +/*N*/ if (eOp == ocOpen) +/*N*/ { +/*N*/ NextToken(); +/*N*/ eOp = Expression(); +/*N*/ } +/*N*/ else +/*N*/ SetError(errPairExpected); +/*N*/ if (eOp != ocClose) +/*N*/ SetError(errPairExpected); +/*N*/ else if ( !pArr->GetError() ) +/*N*/ pFacToken->SetByte( 1 ); +/*N*/ PutCode( pFacToken ); +/*N*/ eOp = NextToken(); +/*N*/ } +/*N*/ else if ((eOp > ocEnd1Par && eOp < ocEnd2Par) +/*N*/ || eOp == ocExternal +/*N*/ || eOp == ocMacro +/*N*/ || eOp == ocAnd +/*N*/ || eOp == ocOr +/*N*/ || ( eOp >= ocInternalBegin && eOp <= ocInternalEnd ) +/*N*/ || (bCompileForFAP && ((eOp == ocIf) || (eOp == ocChose))) +/*N*/ ) +/*N*/ { +/*N*/ OpCode eFuncOp = eOp; +/*N*/ pFacToken = pToken; +/*N*/ eOp = NextToken(); +/*N*/ BOOL bNoParam = FALSE; +/*N*/ BOOL bNoPair = FALSE; +/*N*/ BYTE nMultiAreaSep = 0; +/*N*/ if (eOp == ocOpen) +/*N*/ { +/*N*/ eOp = NextToken(); +/*N*/ if ( eFuncOp == ocIndex && eOp == ocOpen ) +/*N*/ { // Mehrfachbereiche +/*?*/ BYTE SepCount = 0; +/*?*/ do +/*?*/ { +/*?*/ eOp = NextToken(); +/*?*/ if ( eOp != ocClose ) +/*?*/ { +/*?*/ SepCount++; +/*?*/ eOp = Expression(); +/*?*/ } +/*?*/ } while ( (eOp == ocSep) && (!pArr->GetError() || bIgnoreErrors) ); +/*?*/ if ( eOp != ocClose ) +/*?*/ SetError(errPairExpected); +/*?*/ eOp = NextToken(); +/*?*/ if ( eOp == ocSep ) +/*?*/ { +/*?*/ nMultiAreaSep = 1; +/*?*/ eOp = NextToken(); +/*?*/ } +/*?*/ if ( SepCount == 0 ) +/*?*/ { +/*?*/ if ( eOp == ocClose ) +/*?*/ bNoParam = TRUE; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ PutCode( new ScByteToken( ocPush, SepCount ) ); +/*?*/ if ( eOp != ocClose ) +/*?*/ eOp = Expression(); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (eOp == ocClose) +/*N*/ bNoParam = TRUE; +/*N*/ else +/*N*/ eOp = Expression(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ if (pFacToken->GetOpCode() == ocMultiArea) +/*?*/ { +/*?*/ bNoPair = TRUE; +/*?*/ NextToken(); +/*?*/ eOp = Expression(); +/*?*/ } +/*?*/ else +/*?*/ SetError(errPairExpected); +/*N*/ } +/*N*/ BYTE SepCount = nMultiAreaSep; +/*N*/ if( !bNoParam ) +/*N*/ { +/*N*/ SepCount++; +/*N*/ while ( (eOp == ocSep) && (!pArr->GetError() || bIgnoreErrors) ) +/*N*/ { +/*N*/ SepCount++; +/*N*/ NextToken(); +/*N*/ eOp = Expression(); +/*N*/ } +/*N*/ } +/*N*/ if ((eOp != ocClose) && !bNoPair ) +/*N*/ SetError(errPairExpected); +/*N*/ else +/*N*/ eOp = NextToken(); +/*N*/ // Jumps are just normal functions for the FunctionAutoPilot tree view +/*N*/ if ( bCompileForFAP && pFacToken->GetType() == svJump ) +/*?*/ pFacToken = new ScFAPToken( pFacToken->GetOpCode(), SepCount, pFacToken ); +/*N*/ else +/*N*/ pFacToken->SetByte( SepCount ); +/*N*/ PutCode( pFacToken ); +/*N*/ // Diese Funktionen muessen immer neu berechnet werden +/*N*/ switch( eFuncOp ) +/*N*/ { +/*?*/ // ocIndirect muesste sonst bei jedem Interpret StopListening +/*?*/ // und StartListening fuer ein RefTripel ausfuehren +/*?*/ case ocIndirect: +/*?*/ // ocOffset und ocIndex liefern indirekte Refs +/*?*/ case ocOffset: +/*?*/ case ocIndex: +/*?*/ pArr->SetRecalcModeAlways(); +/*?*/ break; +/*?*/ // Functions recalculated on every document load. +/*?*/ // Don't use SetRecalcModeOnLoad which would override ModeAlways +/*N*/ case ocConvert : +/*N*/ pArr->AddRecalcMode( RECALCMODE_ONLOAD ); +/*N*/ break; +/*?*/ // wird die referierte verschoben, aendert sich der Wert +/*?*/ case ocColumn : +/*?*/ case ocRow : +/*?*/ case ocCell : // CELL needs recalc on move for some possible type values +/*?*/ pArr->SetRecalcModeOnRefMove(); +/*?*/ break; +/*N*/ } +/*N*/ } +/*N*/ else if (eOp == ocIf || eOp == ocChose) +/*N*/ { +/*N*/ // Die PC-Staende sind -1 +/*N*/ pFacToken = pToken; +/*N*/ if ( eOp == ocIf ) +/*N*/ pFacToken->GetJump()[ 0 ] = 3; // if, else, behind +/*N*/ else +/*?*/ pFacToken->GetJump()[ 0 ] = MAXJUMPCOUNT+1; +/*N*/ eOp = NextToken(); +/*N*/ if (eOp == ocOpen) +/*N*/ { +/*N*/ NextToken(); +/*N*/ eOp = Expression(); +/*N*/ } +/*N*/ else +/*N*/ SetError(errPairExpected); +/*N*/ short nJumpCount = 0; +/*N*/ PutCode( pFacToken ); +/*N*/ // #36253# bei AutoCorrect (da pArr->nError ignoriert wird) +/*N*/ // unbegrenztes ocIf gibt GPF weil ScRawToken::Clone den JumpBuffer +/*N*/ // anhand von nJump[0]*2+2 alloziert, was bei ocIf 3*2+2 ist +/*N*/ const short nJumpMax = +/*N*/ (pFacToken->GetOpCode() == ocIf ? 3 : MAXJUMPCOUNT); +/*N*/ while ( (nJumpCount < (MAXJUMPCOUNT - 1)) && (eOp == ocSep) +/*N*/ && (!pArr->GetError() || bIgnoreErrors) ) +/*N*/ { +/*N*/ if ( ++nJumpCount <= nJumpMax ) +/*N*/ pFacToken->GetJump()[nJumpCount] = pc-1; +/*N*/ NextToken(); +/*N*/ eOp = Expression(); +/*N*/ PutCode( pToken ); // Als Terminator des Teilausdrucks +/*N*/ } +/*N*/ if (eOp != ocClose) +/*N*/ SetError(errPairExpected); +/*N*/ else +/*N*/ { +/*N*/ eOp = NextToken(); +/*N*/ // auch ohne AutoCorrect gibt es hier ohne nJumpMax bei +/*N*/ // mehr als 3 Parametern in ocIf einen Ueberschreiber, +/*N*/ // das war auch schon in der 312 so (jaja, die Tester..) +/*N*/ if ( ++nJumpCount <= nJumpMax ) +/*N*/ pFacToken->GetJump()[ nJumpCount ] = pc-1; +/*N*/ if ((pFacToken->GetOpCode() == ocIf && (nJumpCount > 3)) || +/*N*/ (nJumpCount >= MAXJUMPCOUNT)) +/*N*/ SetError(errIllegalParameter); +/*N*/ else +/*N*/ pFacToken->GetJump()[ 0 ] = nJumpCount; +/*N*/ } +/*N*/ } +/*N*/ else if ( eOp == ocBad ) +/*N*/ { +/*?*/ SetError( errNoName ); +/*N*/ } +/*N*/ else if ( eOp == ocClose ) +/*N*/ { +/*?*/ SetError( errParameterExpected ); +/*N*/ } +/*N*/ else if ( eOp == ocMissing ) +/*N*/ { // #84460# May occur if imported from Xcl. +/*?*/ // The real value for missing parameters depends on the function +/*?*/ // where it is used, interpreter would have to handle this. +/*?*/ // If it does remove this error case here, that could also be the +/*?*/ // time to generate ocMissing in between subsequent ocSep. +/*?*/ // Xcl import should map missings to values if possible. +/*?*/ SetError( errParameterExpected ); +/*N*/ } +/*N*/ else if ( eOp == ocSep ) +/*N*/ { // Subsequent ocSep +/*N*/ SetError( errParameterExpected ); +/*N*/ if ( bAutoCorrect && !pStack ) +/*N*/ { +/*?*/ aCorrectedSymbol.Erase(); +/*?*/ bCorrected = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ SetError( errUnknownToken ); +/*?*/ if ( bAutoCorrect && !pStack ) +/*?*/ { +/*?*/ if ( eOp == ocStop ) +/*?*/ { // trailing operator w/o operand +/*?*/ xub_StrLen nLen = aCorrectedFormula.Len(); +/*?*/ if ( nLen ) +/*?*/ aCorrectedFormula.Erase( nLen - 1 ); +/*?*/ aCorrectedSymbol.Erase(); +/*?*/ bCorrected = TRUE; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::Unary() +/*N*/ { +/*N*/ if( pToken->GetOpCode() == ocAdd ) +/*?*/ GetToken(); +/*N*/ else if ( pToken->GetOpCode() > ocNot && pToken->GetOpCode() < ocEndUnOp ) +/*N*/ { +/*?*/ ScTokenRef p = pToken; +/*?*/ NextToken(); +/*?*/ Factor(); +/*?*/ PutCode( p ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ Factor(); +/*N*/ while ( pToken->GetOpCode() == ocPercentSign ) +/*N*/ { // this operator _follows_ its operand +/*?*/ PutCode( pToken ); +/*?*/ NextToken(); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScCompiler::PowLine() +/*N*/ { +/*N*/ Unary(); +/*N*/ while (pToken->GetOpCode() == ocPow) +/*N*/ { +/*?*/ ScTokenRef p = pToken; +/*?*/ NextToken(); +/*?*/ Unary(); +/*?*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::UnionCutLine() +/*N*/ { +/*N*/ PowLine(); +/*N*/ while (pToken->GetOpCode() == ocIntersect) +/*N*/ { +/*?*/ ScTokenRef p = pToken; +/*?*/ NextToken(); +/*?*/ PowLine(); +/*?*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::MulDivLine() +/*N*/ { +/*N*/ UnionCutLine(); +/*N*/ while (pToken->GetOpCode() == ocMul || pToken->GetOpCode() == ocDiv) +/*N*/ { +/*N*/ ScTokenRef p = pToken; +/*N*/ NextToken(); +/*N*/ UnionCutLine(); +/*N*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::AddSubLine() +/*N*/ { +/*N*/ MulDivLine(); +/*N*/ while (pToken->GetOpCode() == ocAdd || pToken->GetOpCode() == ocSub) +/*N*/ { +/*N*/ ScTokenRef p = pToken; +/*N*/ NextToken(); +/*N*/ MulDivLine(); +/*N*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::ConcatLine() +/*N*/ { +/*N*/ AddSubLine(); +/*N*/ while (pToken->GetOpCode() == ocAmpersand) +/*N*/ { +/*N*/ ScTokenRef p = pToken; +/*N*/ NextToken(); +/*N*/ AddSubLine(); +/*N*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::CompareLine() +/*N*/ { +/*N*/ ConcatLine(); +/*N*/ while (pToken->GetOpCode() >= ocEqual && pToken->GetOpCode() <= ocGreaterEqual) +/*N*/ { +/*N*/ ScTokenRef p = pToken; +/*N*/ NextToken(); +/*N*/ ConcatLine(); +/*N*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ void ScCompiler::NotLine() +/*N*/ { +/*N*/ CompareLine(); +/*N*/ while (pToken->GetOpCode() == ocNot) +/*N*/ { +/*?*/ ScTokenRef p = pToken; +/*?*/ NextToken(); +/*?*/ CompareLine(); +/*?*/ PutCode(p); +/*N*/ } +/*N*/ } + +//--------------------------------------------------------------------------- + +/*N*/ OpCode ScCompiler::Expression() +/*N*/ { +/*N*/ static const short nRecursionMax = 42; +/*N*/ ScCompilerRecursionGuard aRecursionGuard( nRecursion ); +/*N*/ if ( nRecursion > nRecursionMax ) +/*N*/ { +/*?*/ SetError( errStackOverflow ); +/*?*/ return ocStop; //! stattdessen Token generieren? +/*N*/ } +/*N*/ NotLine(); +/*N*/ while (pToken->GetOpCode() == ocAnd || pToken->GetOpCode() == ocOr) +/*N*/ { +/*?*/ ScTokenRef p = pToken; +/*?*/ pToken->SetByte( 2 ); // 2 parameters! +/*?*/ NextToken(); +/*?*/ NotLine(); +/*?*/ PutCode(p); +/*N*/ } +/*N*/ return pToken->GetOpCode(); +/*N*/ } + +// Referenz aus benanntem Bereich mit relativen Angaben + +/*N*/ void ScCompiler::SetRelNameReference() +/*N*/ { +/*N*/ pArr->Reset(); +/*N*/ for( ScToken* t = pArr->GetNextReference(); t; +/*N*/ t = pArr->GetNextReference() ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*N*/ if ( rRef1.IsColRel() || rRef1.IsRowRel() || rRef1.IsTabRel() ) +/*?*/ rRef1.SetRelName( TRUE ); +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*?*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*?*/ if ( rRef2.IsColRel() || rRef2.IsRowRel() || rRef2.IsTabRel() ) +/*?*/ rRef2.SetRelName( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ } + +// nur relative aus RangeName mit Wrap an Position anpassen +/*N*/ void ScCompiler::MoveRelWrap() +/*N*/ { +/*N*/ pArr->Reset(); +/*N*/ for( ScToken* t = pArr->GetNextReference(); t; +/*N*/ t = pArr->GetNextReference() ) +/*N*/ { +/*N*/ if ( t->GetType() == svSingleRef ) +/*N*/ ScRefUpdate::MoveRelWrap( pDoc, aPos, SingleDoubleRefModifier( t->GetSingleRef() ).Ref() ); +/*N*/ else +/*?*/ ScRefUpdate::MoveRelWrap( pDoc, aPos, t->GetDoubleRef() ); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScCompiler::UpdateNameReference(UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& r, +/*N*/ short nDx, short nDy, short nDz, +/*N*/ BOOL& rChanged) +/*N*/ { +/*N*/ BOOL bRet = FALSE; // wird gesetzt, wenn rel-Ref +/*N*/ rChanged = FALSE; +/*N*/ pArr->Reset(); +/*N*/ for( ScToken* t = pArr->GetNextReference(); t; +/*N*/ t = pArr->GetNextReference() ) +/*N*/ { +/*N*/ SingleDoubleRefModifier aMod( *t ); +/*N*/ ComplRefData& rRef = aMod.Ref(); +/*N*/ if (!rRef.Ref1.IsColRel() && !rRef.Ref1.IsRowRel() && +/*N*/ (!rRef.Ref1.IsFlag3D() || !rRef.Ref1.IsTabRel()) && +/*N*/ ( t->GetType() == svSingleRef || +/*N*/ (!rRef.Ref2.IsColRel() && !rRef.Ref2.IsRowRel() && +/*N*/ (!rRef.Ref2.IsFlag3D() || !rRef.Ref2.IsTabRel())))) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); /*N*/ if (ScRefUpdate::Update( pDoc, eUpdateRefMode, aPos, +/*N*/ /*?*/ r, nDx, nDy, nDz, rRef ) != UR_NOTHING ) +/*N*/ /*?*/ rChanged = TRUE; +/*N*/ } +/*N*/ else +/*N*/ bRet = TRUE; +/*N*/ } +/*N*/ return bRet; +/*N*/ } + + +/*N*/ ScRangeData* ScCompiler::UpdateInsertTab( USHORT nTable, BOOL bIsName ) +/*N*/ { +/*N*/ ScRangeData* pRangeData = NULL; +/*N*/ short nTab; +/*N*/ USHORT nPosTab = aPos.Tab(); // _nach_ evtl. Increment! +/*N*/ USHORT nOldPosTab = ((nPosTab > nTable) ? (nPosTab - 1) : nPosTab); +/*N*/ BOOL bIsRel = FALSE; +/*N*/ ScToken* t; +/*N*/ pArr->Reset(); +/*N*/ if (bIsName) +/*?*/ t = pArr->GetNextReference(); +/*N*/ else +/*N*/ t = pArr->GetNextReferenceOrName(); +/*N*/ while( t ) +/*N*/ { +/*N*/ if( t->GetOpCode() == ocName ) +/*N*/ { +/*?*/ if (!bIsName) +/*?*/ { +/*?*/ ScRangeData* pName = pDoc->GetRangeName()->FindIndex(t->GetIndex()); +/*?*/ if (pName && pName->HasType(RT_SHAREDMOD)) +/*?*/ pRangeData = pName; +/*?*/ } +/*N*/ } +/*N*/ else if( t->GetType() != svIndex ) // es kann ein DB-Bereich sein !!! +/*N*/ { +/*N*/ if ( !(bIsName && t->GetSingleRef().IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ SingleRefData& rRef = t->GetSingleRef(); +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ { +/*N*/ nTab = rRef.nRelTab + nOldPosTab; +/*N*/ if ( nTab < 0 ) +/*?*/ nTab += pDoc->GetTableCount(); // was a wrap +/*N*/ } +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if ( nTable <= nTab ) +/*N*/ rRef.nTab = nTab + 1; +/*N*/ rRef.nRelTab = rRef.nTab - nPosTab; +/*N*/ } +/*N*/ else +/*N*/ bIsRel = TRUE; +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ if ( !(bIsName && t->GetDoubleRef().Ref2.IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ SingleRefData& rRef = t->GetDoubleRef().Ref2; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ { +/*N*/ nTab = rRef.nRelTab + nOldPosTab; +/*N*/ if ( nTab < 0 ) +/*?*/ nTab += pDoc->GetTableCount(); // was a wrap +/*N*/ } +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if ( nTable <= nTab ) +/*N*/ rRef.nTab = nTab + 1; +/*N*/ rRef.nRelTab = rRef.nTab - nPosTab; +/*N*/ } +/*N*/ else +/*N*/ bIsRel = TRUE; +/*N*/ } +/*N*/ if ( bIsName && bIsRel ) +/*N*/ pRangeData = (ScRangeData*) this; // wird in rangenam nicht dereferenziert +/*N*/ } +/*N*/ if (bIsName) +/*?*/ t = pArr->GetNextReference(); +/*N*/ else +/*N*/ t = pArr->GetNextReferenceOrName(); +/*N*/ } +/*N*/ if ( !bIsName ) +/*N*/ { +/*N*/ pArr->Reset(); +/*N*/ for ( t = pArr->GetNextReferenceRPN(); t; +/*N*/ t = pArr->GetNextReferenceRPN() ) +/*N*/ { +/*N*/ if ( t->GetRef() == 1 ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*N*/ if ( !(rRef1.IsRelName() && rRef1.IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ if ( rRef1.IsTabRel() ) +/*N*/ { +/*?*/ nTab = rRef1.nRelTab + nOldPosTab; +/*?*/ if ( nTab < 0 ) +/*?*/ nTab += pDoc->GetTableCount(); // was a wrap +/*N*/ } +/*N*/ else +/*N*/ nTab = rRef1.nTab; +/*N*/ if ( nTable <= nTab ) +/*N*/ rRef1.nTab = nTab + 1; +/*N*/ rRef1.nRelTab = rRef1.nTab - nPosTab; +/*N*/ } +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*?*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*?*/ if ( !(rRef2.IsRelName() && rRef2.IsTabRel()) ) +/*?*/ { // Namen nur absolute anpassen +/*?*/ if ( rRef2.IsTabRel() ) +/*?*/ { +/*?*/ nTab = rRef2.nRelTab + nOldPosTab; +/*?*/ if ( nTab < 0 ) +/*?*/ nTab += pDoc->GetTableCount(); // was a wrap +/*?*/ } +/*?*/ else +/*?*/ nTab = rRef2.nTab; +/*?*/ if ( nTable <= nTab ) +/*?*/ rRef2.nTab = nTab + 1; +/*?*/ rRef2.nRelTab = rRef2.nTab - nPosTab; +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return pRangeData; +/*N*/ } + +/*N*/ ScRangeData* ScCompiler::UpdateDeleteTab(USHORT nTable, BOOL bIsMove, BOOL bIsName, +/*N*/ BOOL& rChanged) +/*N*/ { +/*N*/ ScRangeData* pRangeData = NULL; +/*N*/ USHORT nTab, nTab2; +/*N*/ USHORT nPosTab = aPos.Tab(); // _nach_ evtl. Decrement! +/*N*/ USHORT nOldPosTab = ((nPosTab >= nTable) ? (nPosTab + 1) : nPosTab); +/*N*/ rChanged = FALSE; +/*N*/ BOOL bIsRel = FALSE; +/*N*/ ScToken* t; +/*N*/ pArr->Reset(); +/*N*/ if (bIsName) +/*N*/ t = pArr->GetNextReference(); +/*N*/ else +/*N*/ t = pArr->GetNextReferenceOrName(); +/*N*/ while( t ) +/*N*/ { +/*N*/ if( t->GetOpCode() == ocName ) +/*N*/ { +/*N*/ if (!bIsName) +/*N*/ { +/*N*/ ScRangeData* pName = pDoc->GetRangeName()->FindIndex(t->GetIndex()); +/*N*/ if (pName && pName->HasType(RT_SHAREDMOD)) +/*N*/ pRangeData = pName; +/*N*/ } +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ else if( t->GetType() != svIndex ) // es kann ein DB-Bereich sein !!! +/*N*/ { +/*N*/ if ( !(bIsName && t->GetSingleRef().IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ SingleRefData& rRef = t->GetSingleRef(); +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ nTab = rRef.nRelTab + nOldPosTab; +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if ( nTable < nTab ) +/*N*/ { +/*N*/ rRef.nTab = nTab - 1; +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ else if ( nTable == nTab ) +/*N*/ { +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*N*/ if ( rRef2.IsTabRel() ) +/*N*/ nTab2 = rRef2.nRelTab + nOldPosTab; +/*N*/ else +/*N*/ nTab2 = rRef2.nTab; +/*N*/ if ( nTab == nTab2 +/*N*/ || (nTab+1) >= pDoc->GetTableCount() ) +/*N*/ { +/*N*/ rRef.nTab = MAXTAB+1; +/*N*/ rRef.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ // else: nTab zeigt spaeter auf jetziges nTable+1 +/*N*/ // => Bereich verkleinert +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rRef.nTab = MAXTAB+1; +/*N*/ rRef.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ rRef.nRelTab = rRef.nTab - nPosTab; +/*N*/ } +/*N*/ else +/*N*/ bIsRel = TRUE; +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ if ( !(bIsName && t->GetDoubleRef().Ref2.IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ SingleRefData& rRef = t->GetDoubleRef().Ref2; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ nTab = rRef.nRelTab + nOldPosTab; +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if ( nTable < nTab ) +/*N*/ { +/*N*/ rRef.nTab = nTab - 1; +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ else if ( nTable == nTab ) +/*N*/ { +/*N*/ if ( !t->GetDoubleRef().Ref1.IsTabDeleted() ) +/*N*/ rRef.nTab = nTab - 1; // Bereich verkleinern +/*N*/ else +/*N*/ { +/*N*/ rRef.nTab = MAXTAB+1; +/*N*/ rRef.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ rRef.nRelTab = rRef.nTab - nPosTab; +/*N*/ } +/*N*/ else +/*N*/ bIsRel = TRUE; +/*N*/ } +/*N*/ if ( bIsName && bIsRel ) +/*N*/ pRangeData = (ScRangeData*) this; // wird in rangenam nicht dereferenziert +/*N*/ } +/*N*/ if (bIsName) +/*N*/ t = pArr->GetNextReference(); +/*N*/ else +/*N*/ t = pArr->GetNextReferenceOrName(); +/*N*/ } +/*N*/ if ( !bIsName ) +/*N*/ { +/*N*/ pArr->Reset(); +/*N*/ for ( t = pArr->GetNextReferenceRPN(); t; +/*N*/ t = pArr->GetNextReferenceRPN() ) +/*N*/ { +/*N*/ if ( t->GetRef() == 1 ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*N*/ if ( !(rRef1.IsRelName() && rRef1.IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ if ( rRef1.IsTabRel() ) +/*N*/ nTab = rRef1.nRelTab + nOldPosTab; +/*N*/ else +/*N*/ nTab = rRef1.nTab; +/*N*/ if ( nTable < nTab ) +/*N*/ { +/*N*/ rRef1.nTab = nTab - 1; +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ else if ( nTable == nTab ) +/*N*/ { +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*N*/ if ( rRef2.IsTabRel() ) +/*N*/ nTab2 = rRef2.nRelTab + nOldPosTab; +/*N*/ else +/*N*/ nTab2 = rRef2.nTab; +/*N*/ if ( nTab == nTab2 +/*N*/ || (nTab+1) >= pDoc->GetTableCount() ) +/*N*/ { +/*N*/ rRef1.nTab = MAXTAB+1; +/*N*/ rRef1.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ // else: nTab zeigt spaeter auf jetziges nTable+1 +/*N*/ // => Bereich verkleinert +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rRef1.nTab = MAXTAB+1; +/*N*/ rRef1.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ rRef1.nRelTab = rRef1.nTab - nPosTab; +/*N*/ } +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*N*/ if ( !(rRef2.IsRelName() && rRef2.IsTabRel()) ) +/*N*/ { // Namen nur absolute anpassen +/*N*/ if ( rRef2.IsTabRel() ) +/*N*/ nTab = rRef2.nRelTab + nOldPosTab; +/*N*/ else +/*N*/ nTab = rRef2.nTab; +/*N*/ if ( nTable < nTab ) +/*N*/ { +/*N*/ rRef2.nTab = nTab - 1; +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ else if ( nTable == nTab ) +/*N*/ { +/*N*/ if ( !rRef1.IsTabDeleted() ) +/*N*/ rRef2.nTab = nTab - 1; // Bereich verkleinern +/*N*/ else +/*N*/ { +/*N*/ rRef2.nTab = MAXTAB+1; +/*N*/ rRef2.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ rChanged = TRUE; +/*N*/ } +/*N*/ rRef2.nRelTab = rRef2.nTab - nPosTab; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return pRangeData; +/*N*/ } + +/*N*/ ScToken* ScCompiler::CreateStringFromToken( String& rFormula, ScToken* pToken, +/*N*/ BOOL bAllowArrAdvance ) +/*N*/ { +/*N*/ ::rtl::OUStringBuffer aBuffer; +/*N*/ ScToken* p = CreateStringFromToken( aBuffer, pToken, bAllowArrAdvance ); +/*N*/ rFormula += aBuffer; +/*N*/ return p; +/*N*/ } + +/*N*/ ScToken* ScCompiler::CreateStringFromToken( ::rtl::OUStringBuffer& rBuffer, ScToken* pToken, +/*N*/ BOOL bAllowArrAdvance ) +/*N*/ { +/*N*/ BOOL bNext = TRUE; +/*N*/ BOOL bSpaces = FALSE; +/*N*/ ScToken* t = pToken; +/*N*/ OpCode eOp = t->GetOpCode(); +/*N*/ if( eOp >= ocAnd && eOp <= ocOr ) +/*N*/ { +/*N*/ // AND, OR infix? +/*N*/ if ( bAllowArrAdvance ) +/*N*/ t = pArr->Next(); +/*N*/ else +/*N*/ t = pArr->PeekNext(); +/*N*/ bNext = FALSE; +/*N*/ bSpaces = ( !t || t->GetOpCode() != ocOpen ); +/*N*/ } +/*N*/ if( bSpaces ) +/*?*/ rBuffer.append(sal_Unicode(' ')); +/*N*/ +/*N*/ if( eOp == ocSpaces ) +/*N*/ { // most times it's just one blank +/*N*/ BYTE n = t->GetByte(); +/*N*/ for ( BYTE j=0; j<n; ++j ) +/*N*/ { +/*N*/ rBuffer.append(sal_Unicode(' ')); +/*N*/ } +/*N*/ } +/*N*/ else if( eOp >= ocInternalBegin && eOp <= ocInternalEnd ) +/*?*/ rBuffer.appendAscii( pInternal[ eOp - ocInternalBegin ] ); +/*N*/ else if( (USHORT) eOp < nAnzStrings) // Keyword: +/*N*/ rBuffer.append(pSymbolTable[eOp]); +/*N*/ else +/*N*/ { +/*?*/ DBG_ERROR("Unbekannter OpCode"); +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_NAME_REF)); +/*N*/ } +/*N*/ if( bNext ) switch( t->GetType() ) +/*N*/ { +/*N*/ case svDouble: +/*N*/ { +/*N*/ if ( pSymbolTable == pSymbolTableEnglish ) +/*N*/ { // Don't go via number formatter, slows down XML export +/*N*/ // significantly because on every formula the number formatter +/*N*/ // has to switch to/from English/native language. +/*N*/ ::rtl::math::doubleToUStringBuffer( rBuffer, t->GetDouble(), +/*N*/ rtl_math_StringFormat_Automatic, +/*N*/ rtl_math_DecimalPlaces_Max, '.', TRUE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ::rtl::math::doubleToUStringBuffer( rBuffer, t->GetDouble(), +/*N*/ rtl_math_StringFormat_Automatic, +/*N*/ rtl_math_DecimalPlaces_Max, +/*N*/ ScGlobal::pLocaleData->getNumDecimalSep().GetChar(0), +/*N*/ TRUE ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svString: +/*N*/ if( eOp == ocBad ) +/*N*/ rBuffer.append(t->GetString()); +/*N*/ else +/*N*/ { +/*N*/ if (bImportXML) +/*?*/ rBuffer.append(t->GetString()); +/*N*/ else +/*N*/ { +/*N*/ rBuffer.append(sal_Unicode('"')); +/*N*/ if ( ScGlobal::UnicodeStrChr( t->GetString().GetBuffer(), '"' ) == NULL ) +/*N*/ rBuffer.append(t->GetString()); +/*N*/ else +/*N*/ { +/*?*/ String aStr( t->GetString() ); +/*?*/ xub_StrLen nPos = 0; +/*?*/ while ( (nPos = aStr.Search( '"', nPos)) != STRING_NOTFOUND ) +/*?*/ { +/*?*/ aStr.Insert( '"', nPos ); +/*?*/ nPos += 2; +/*?*/ } +/*?*/ rBuffer.append(aStr); +/*N*/ } +/*N*/ rBuffer.append(sal_Unicode('"')); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svSingleRef: +/*N*/ { +/*N*/ SingleRefData& rRef = t->GetSingleRef(); +/*N*/ ComplRefData aRef; +/*N*/ aRef.Ref1 = aRef.Ref2 = rRef; +/*N*/ if ( eOp == ocColRowName ) +/*N*/ { +/*N*/ rRef.CalcAbsIfRel( aPos ); +/*N*/ if ( pDoc->HasStringData( rRef.nCol, rRef.nRow, rRef.nTab ) ) +/*N*/ { +/*N*/ String aStr; +/*N*/ pDoc->GetString( rRef.nCol, rRef.nRow, rRef.nTab, aStr ); +/*N*/ EnQuote( aStr ); +/*N*/ rBuffer.append(aStr); +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_NAME_REF)); +/*?*/ MakeRefStr( rBuffer, aRef, TRUE ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ MakeRefStr( rBuffer, aRef, TRUE ); +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef: +/*N*/ MakeRefStr( rBuffer, t->GetDoubleRef(), FALSE ); +/*N*/ break; +/*N*/ case svIndex: +/*N*/ { +/*N*/ ::rtl::OUStringBuffer aBuffer; +/*N*/ switch ( eOp ) +/*N*/ { +/*N*/ case ocName: +/*N*/ { +/*N*/ ScRangeData* pData = pDoc->GetRangeName()->FindIndex(t->GetIndex()); +/*N*/ if (pData) +/*N*/ { +/*N*/ if (pData->HasType(RT_SHARED)) +/*N*/ pData->UpdateSymbol( aBuffer, aPos, +/*N*/ pSymbolTable == pSymbolTableEnglish, +/*N*/ bCompileXML ); +/*N*/ else +/*N*/ aBuffer.append(pData->GetName()); +/*N*/ } +/*N*/ } +/*N*/ break; +/*?*/ case ocDBArea: +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); /*N*/ ScDBData* pDBData = pDoc->GetDBCollection()->FindIndex(t->GetIndex()); +/*N*/ /*?*/ if (pDBData) +/*N*/ /*?*/ aBuffer.append(pDBData->GetName()); +/*?*/ } +/*?*/ break; +/*?*/ } +/*N*/ if ( aBuffer.getLength() ) +/*N*/ rBuffer.append(aBuffer); +/*N*/ else +/*?*/ rBuffer.append(ScGlobal::GetRscString(STR_NO_NAME_REF)); +/*N*/ break; +/*N*/ } +/*N*/ case svExternal: +/*N*/ { +/*N*/ // show translated name of StarOne AddIns +/*N*/ String aAddIn( t->GetExternal() ); +/*N*/ if ( pSymbolTable != pSymbolTableEnglish ) +/*?*/ {DBG_BF_ASSERT(0, "STRIP");} //STRIP001 ScGlobal::GetAddInCollection()->LocalizeString( aAddIn ); +/*N*/ rBuffer.append(aAddIn); +/*N*/ } +/*N*/ break; +/*N*/ case svByte: +/*N*/ case svJump: +/*N*/ case svFAP: +/*N*/ case svMissing: +/*N*/ break; // Opcodes +/*N*/ default: +/*N*/ DBG_ERROR("ScCompiler:: GetStringFromToken errUnknownVariable"); +/*N*/ } // of switch +/*N*/ if( bSpaces ) +/*?*/ rBuffer.append(sal_Unicode(' ')); +/*N*/ if ( bAllowArrAdvance ) +/*N*/ { +/*N*/ if( bNext ) +/*N*/ t = pArr->Next(); +/*N*/ return t; +/*N*/ } +/*N*/ return pToken; +/*N*/ } + +/*N*/ void ScCompiler::CreateStringFromTokenArray( String& rFormula ) +/*N*/ { +/*N*/ ::rtl::OUStringBuffer aBuffer( pArr->GetLen() * 2 ); +/*N*/ CreateStringFromTokenArray( aBuffer ); +/*N*/ rFormula = aBuffer; +/*N*/ } + +/*N*/ void ScCompiler::CreateStringFromTokenArray( ::rtl::OUStringBuffer& rBuffer ) +/*N*/ { +/*N*/ rBuffer.setLength(0); +/*N*/ if( !pArr->GetLen() ) +/*N*/ return; +/*N*/ +/*N*/ // at least one char per token, plus some are references, some are function names +/*N*/ rBuffer.ensureCapacity( pArr->GetLen() * 2 ); +/*N*/ +/*N*/ if ( pArr->IsRecalcModeForced() ) +/*?*/ rBuffer.append(sal_Unicode('=')); +/*N*/ ScToken* t = pArr->First(); +/*N*/ while( t ) +/*N*/ t = CreateStringFromToken( rBuffer, t, TRUE ); +/*N*/ } + +/*N*/ BOOL ScCompiler::EnQuote( String& rStr ) +/*N*/ { +/*N*/ sal_Int32 nType = ScGlobal::pCharClass->getStringType( rStr, 0, rStr.Len() ); +/*N*/ if ( !CharClass::isNumericType( nType ) +/*N*/ && CharClass::isAlphaNumericType( nType ) ) +/*N*/ return FALSE; +/*N*/ xub_StrLen nPos = 0; +/*N*/ while ( (nPos = rStr.Search( '\'', nPos)) != STRING_NOTFOUND ) +/*N*/ { +/*N*/ rStr.Insert( '\\', nPos ); +/*N*/ nPos += 2; +/*N*/ } +/*N*/ rStr.Insert( '\'', 0 ); +/*N*/ rStr += '\''; +/*N*/ return TRUE; +/*N*/ } + + +/*N*/ BOOL ScCompiler::DeQuote( String& rStr ) +/*N*/ { +/*N*/ xub_StrLen nLen = rStr.Len(); +/*N*/ if ( nLen > 1 && rStr.GetChar(0) == '\'' && rStr.GetChar( nLen-1 ) == '\'' ) +/*N*/ { +/*N*/ rStr.Erase( nLen-1, 1 ); +/*N*/ rStr.Erase( 0, 1 ); +/*N*/ xub_StrLen nPos = 0; +/*N*/ while ( (nPos = rStr.SearchAscii( "\\\'", nPos)) != STRING_NOTFOUND ) +/*N*/ { +/*N*/ rStr.Erase( nPos, 1 ); +/*N*/ ++nPos; +/*N*/ } +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_consoli.cxx b/binfilter/bf_sc/source/core/tool/sc_consoli.cxx new file mode 100644 index 000000000000..6b0a27de380a --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_consoli.cxx @@ -0,0 +1,606 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> +#include <math.h> +#include <string.h> +#include "consoli.hxx" +#include "document.hxx" +#include "globstr.hrc" +#include "subtotal.hxx" +#include "cell.hxx" +namespace binfilter { + +#define SC_CONS_NOTFOUND 0xFFFF + +// STATIC DATA ----------------------------------------------------------- + +/* Strings bei Gelegenheit ganz raus... +static USHORT nFuncRes[] = { // Reihenfolge wie bei enum ScSubTotalFunc + 0, // none + STR_PIVOTFUNC_AVG, + STR_PIVOTFUNC_COUNT, + STR_PIVOTFUNC_COUNT2, + STR_PIVOTFUNC_MAX, + STR_PIVOTFUNC_MIN, + STR_PIVOTFUNC_PROD, + STR_PIVOTFUNC_STDDEV, + STR_PIVOTFUNC_STDDEV2, + STR_PIVOTFUNC_SUM, + STR_PIVOTFUNC_VAR, + STR_PIVOTFUNC_VAR2 }; +*/ + +/*N*/ static OpCode eOpCodeTable[] = { // Reihenfolge wie bei enum ScSubTotalFunc +/*N*/ ocBad, // none +/*N*/ ocAverage, +/*N*/ ocCount, +/*N*/ ocCount2, +/*N*/ ocMax, +/*N*/ ocMin, +/*N*/ ocProduct, +/*N*/ ocStDev, +/*N*/ ocStDevP, +/*N*/ ocSum, +/*N*/ ocVar, +/*N*/ ocVarP }; + +// ----------------------------------------------------------------------- + +/*N*/ void lcl_AddString( String**& pData, USHORT& nCount, const String& rInsert ) +/*N*/ { +/*N*/ String** pOldData = pData; +/*N*/ pData = new String*[ nCount+1 ]; +/*N*/ if (pOldData) +/*N*/ { +/*N*/ memmove( pData, pOldData, nCount * sizeof(String*) ); +/*N*/ delete[] pOldData; +/*N*/ } +/*N*/ pData[nCount] = new String(rInsert); +/*N*/ ++nCount; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScConsData::ScConsData() : +/*N*/ eFunction(SUBTOTAL_FUNC_SUM), +/*N*/ bReference(FALSE), +/*N*/ bColByName(FALSE), +/*N*/ bRowByName(FALSE), +/*N*/ bSubTitles(FALSE), +/*N*/ nColCount(0), +/*N*/ ppColHeaders(NULL), +/*N*/ nRowCount(0), +/*N*/ ppRowHeaders(NULL), +/*N*/ ppCount(NULL), +/*N*/ ppSum(NULL), +/*N*/ ppSumSqr(NULL), +/*N*/ ppRefs(NULL), +/*N*/ ppUsed(NULL), +/*N*/ nDataCount(0), +/*N*/ nTitleCount(0), +/*N*/ ppTitles(NULL), +/*N*/ ppTitlePos(NULL), +/*N*/ bCornerUsed(FALSE) +/*N*/ { +/*N*/ } + +/*N*/ ScConsData::~ScConsData() +/*N*/ { +/*N*/ DeleteData(); +/*N*/ } + + +/*N*/ #define DELETEARR(ppArray,nCount) \ +/*N*/ { \ +/*N*/ USHORT i; \ +/*N*/ if (ppArray) \ +/*N*/ for(i=0; i<nCount; i++) \ +/*N*/ delete[] ppArray[i]; \ +/*N*/ delete[] ppArray; \ +/*N*/ ppArray = NULL; \ +/*N*/ } +/*N*/ +/*N*/ #define DELETESTR(ppArray,nCount) \ +/*N*/ { \ +/*N*/ USHORT i; \ +/*N*/ if (ppArray) \ +/*N*/ for(i=0; i<nCount; i++) \ +/*N*/ delete ppArray[i]; \ +/*N*/ delete[] ppArray; \ +/*N*/ ppArray = NULL; \ +/*N*/ } + +/*N*/ void ScConsData::DeleteData() +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ if (ppRefs) +/*N*/ for (i=0; i<nColCount; i++) +/*N*/ { +/*N*/ for (USHORT j=0; j<nRowCount; j++) +/*N*/ if (ppUsed[i][j]) +/*N*/ ppRefs[i][j].Clear(); +/*N*/ delete[] ppRefs[i]; +/*N*/ } +/*N*/ delete[] ppRefs; +/*N*/ ppRefs = NULL; +/*N*/ +/*N*/ // DELETEARR( ppData1, nColCount ); +/*N*/ // DELETEARR( ppData2, nColCount ); +/*N*/ DELETEARR( ppCount, nColCount ); +/*N*/ DELETEARR( ppSum, nColCount ); +/*N*/ DELETEARR( ppSumSqr,nColCount ); +/*N*/ DELETEARR( ppUsed, nColCount ); // erst nach ppRefs !!! +/*N*/ DELETEARR( ppTitlePos, nRowCount ); +/*N*/ DELETESTR( ppColHeaders, nColCount ); +/*N*/ DELETESTR( ppRowHeaders, nRowCount ); +/*N*/ DELETESTR( ppTitles, nTitleCount ); +/*N*/ nTitleCount = 0; +/*N*/ nDataCount = 0; +/*N*/ +/*N*/ if (bColByName) nColCount = 0; // sonst stimmt ppColHeaders nicht +/*N*/ if (bRowByName) nRowCount = 0; +/*N*/ +/*N*/ bCornerUsed = FALSE; +/*N*/ aCornerText.Erase(); +/*N*/ } + +/*N*/ #undef DELETEARR +/*N*/ #undef DELETESTR + +/*N*/ void ScConsData::InitData( BOOL bDelete ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ if (bDelete) +/*N*/ DeleteData(); +/*N*/ +/*N*/ if (bReference && nColCount && !ppRefs) +/*N*/ { +/*N*/ ppRefs = new ScReferenceList*[nColCount]; +/*N*/ for (i=0; i<nColCount; i++) +/*N*/ ppRefs[i] = new ScReferenceList[nRowCount]; +/*N*/ } +/*N*/ else if (nColCount && !ppCount) +/*N*/ { +/*N*/ ppCount = new double*[nColCount]; +/*N*/ ppSum = new double*[nColCount]; +/*N*/ ppSumSqr = new double*[nColCount]; +/*N*/ for (i=0; i<nColCount; i++) +/*N*/ { +/*N*/ ppCount[i] = new double[nRowCount]; +/*N*/ ppSum[i] = new double[nRowCount]; +/*N*/ ppSumSqr[i] = new double[nRowCount]; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (nColCount && !ppUsed) +/*N*/ { +/*N*/ ppUsed = new BOOL*[nColCount]; +/*N*/ for (i=0; i<nColCount; i++) +/*N*/ { +/*N*/ ppUsed[i] = new BOOL[nRowCount]; +/*N*/ memset( ppUsed[i], 0, nRowCount * sizeof(BOOL) ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (nRowCount && nDataCount && !ppTitlePos) +/*N*/ { +/*N*/ ppTitlePos = new USHORT*[nRowCount]; +/*N*/ for (i=0; i<nRowCount; i++) +/*N*/ { +/*N*/ ppTitlePos[i] = new USHORT[nDataCount]; +/*N*/ memset( ppTitlePos[i], 0, nDataCount * sizeof(USHORT) ); //! unnoetig ? +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // CornerText: einzelner String +/*N*/ } + +/*N*/ void ScConsData::DoneFields() +/*N*/ { +/*N*/ InitData(FALSE); +/*N*/ } + +/*N*/ void ScConsData::SetSize( USHORT nCols, USHORT nRows ) +/*N*/ { +/*N*/ DeleteData(); +/*N*/ nColCount = nCols; +/*N*/ nRowCount = nRows; +/*N*/ } + +/*N*/ void ScConsData::GetSize( USHORT& rCols, USHORT& rRows ) const +/*N*/ { +/*N*/ rCols = nColCount; +/*N*/ rRows = nRowCount; +/*N*/ } + +/*N*/ void ScConsData::SetFlags( ScSubTotalFunc eFunc, BOOL bColName, BOOL bRowName, BOOL bRef ) +/*N*/ { +/*N*/ DeleteData(); +/*N*/ bReference = bRef; +/*N*/ bColByName = bColName; +/*N*/ if (bColName) nColCount = 0; +/*N*/ bRowByName = bRowName; +/*N*/ if (bRowName) nRowCount = 0; +/*N*/ eFunction = eFunc; +/*N*/ } + +/*N*/ void ScConsData::AddFields( ScDocument* pSrcDoc, USHORT nTab, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2 ) +/*N*/ { +/*N*/ ++nDataCount; +/*N*/ +/*N*/ String aTitle; +/*N*/ +/*N*/ USHORT nStartCol = nCol1; +/*N*/ USHORT nStartRow = nRow1; +/*N*/ if (bColByName) ++nStartRow; +/*N*/ if (bRowByName) ++nStartCol; +/*N*/ +/*N*/ if (bColByName) +/*N*/ { +/*N*/ for (USHORT nCol=nStartCol; nCol<=nCol2; nCol++) +/*N*/ { +/*N*/ pSrcDoc->GetString( nCol, nRow1, nTab, aTitle ); +/*N*/ if (aTitle.Len()) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=0; i<nColCount && !bFound; i++) +/*N*/ if ( *ppColHeaders[i] == aTitle ) +/*N*/ bFound = TRUE; +/*N*/ if (!bFound) +/*N*/ lcl_AddString( ppColHeaders, nColCount, aTitle ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (bRowByName) +/*N*/ { +/*N*/ for (USHORT nRow=nStartRow; nRow<=nRow2; nRow++) +/*N*/ { +/*N*/ pSrcDoc->GetString( nCol1, nRow, nTab, aTitle ); +/*N*/ if (aTitle.Len()) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=0; i<nRowCount && !bFound; i++) +/*N*/ if ( *ppRowHeaders[i] == aTitle ) +/*N*/ bFound = TRUE; +/*N*/ if (!bFound) +/*N*/ lcl_AddString( ppRowHeaders, nRowCount, aTitle ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScConsData::AddName( const String& rName ) +/*N*/ { +/*N*/ USHORT nArrX; +/*N*/ USHORT nArrY; +/*N*/ +/*N*/ if (bReference) +/*N*/ { +/*N*/ lcl_AddString( ppTitles, nTitleCount, rName ); +/*N*/ +/*N*/ for (nArrY=0; nArrY<nRowCount; nArrY++) +/*N*/ { +/*N*/ // Daten auf gleiche Laenge bringen +/*N*/ +/*N*/ USHORT nMax = 0; +/*N*/ for (nArrX=0; nArrX<nColCount; nArrX++) +/*N*/ if (ppUsed[nArrX][nArrY]) +/*N*/ nMax = Max( nMax, ppRefs[nArrX][nArrY].GetCount() ); +/*N*/ +/*N*/ for (nArrX=0; nArrX<nColCount; nArrX++) +/*N*/ { +/*N*/ if (!ppUsed[nArrX][nArrY]) +/*N*/ { +/*N*/ ppUsed[nArrX][nArrY] = TRUE; +/*N*/ ppRefs[nArrX][nArrY].Init(); +/*N*/ } +/*N*/ ppRefs[nArrX][nArrY].SetFullSize(nMax); +/*N*/ } +/*N*/ +/*N*/ // Positionen eintragen +/*N*/ +/*N*/ if (ppTitlePos) +/*N*/ if (nTitleCount < nDataCount) +/*N*/ ppTitlePos[nArrY][nTitleCount] = nMax; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ double lcl_CalcData( ScSubTotalFunc eFunc, +/*N*/ double fCount, double fSum, double fSumSqr) +/*N*/ { +/*N*/ if (fCount < 0.0) +/*N*/ return 0.0; +/*N*/ double fVal = 0.0; +/*N*/ switch (eFunc) +/*N*/ { +/*N*/ case SUBTOTAL_FUNC_CNT: +/*N*/ case SUBTOTAL_FUNC_CNT2: +/*N*/ fVal = fCount; +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_SUM: +/*N*/ case SUBTOTAL_FUNC_MAX: +/*N*/ case SUBTOTAL_FUNC_MIN: +/*N*/ case SUBTOTAL_FUNC_PROD: +/*N*/ fVal = fSum; +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_AVE: +/*N*/ if (fCount > 0.0) +/*N*/ fVal = fSum / fCount; +/*N*/ else +/*N*/ fCount = -MAXDOUBLE; +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_STD: +/*N*/ { +/*N*/ if (fCount > 1 && SubTotal::SafeMult(fSum, fSum)) +/*N*/ fVal = sqrt((fSumSqr - fSum/fCount)/(fCount-1.0)); +/*N*/ else +/*N*/ fCount = -MAXDOUBLE; +/*N*/ } +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_STDP: +/*N*/ { +/*N*/ if (fCount > 0 && SubTotal::SafeMult(fSum, fSum)) +/*N*/ fVal = sqrt((fSumSqr - fSum/fCount)/fCount); +/*N*/ else +/*N*/ fCount = -MAXDOUBLE; +/*N*/ } +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_VAR: +/*N*/ { +/*N*/ if (fCount > 1 && SubTotal::SafeMult(fSum, fSum)) +/*N*/ fVal = (fSumSqr - fSum/fCount)/(fCount-1.0); +/*N*/ else +/*N*/ fCount = -MAXDOUBLE; +/*N*/ } +/*N*/ break; +/*N*/ case SUBTOTAL_FUNC_VARP: +/*N*/ { +/*N*/ if (fCount > 0 && SubTotal::SafeMult(fSum, fSum)) +/*N*/ fVal = (fSumSqr - fSum/fCount)/fCount; +/*N*/ else +/*N*/ fCount = -MAXDOUBLE; +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ DBG_ERROR("unbekannte Funktion bei Consoli::CalcData"); +/*N*/ fCount = -MAXDOUBLE; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return fVal; +/*N*/ } + +/*N*/ void ScConsData::AddData( ScDocument* pSrcDoc, USHORT nTab, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2 ) +/*N*/ { +/*N*/ PutInOrder(nCol1,nCol2); +/*N*/ PutInOrder(nRow1,nRow2); +/*N*/ if ( nCol2 >= nCol1 + nColCount && !bColByName ) +/*N*/ { +/*N*/ DBG_ASSERT(0,"Bereich zu gross"); +/*N*/ nCol2 = nCol1 + nColCount - 1; +/*N*/ } +/*N*/ if ( nRow2 >= nRow1 + nRowCount && !bRowByName ) +/*N*/ { +/*N*/ DBG_ASSERT(0,"Bereich zu gross"); +/*N*/ nRow2 = nRow1 + nRowCount - 1; +/*N*/ } +/*N*/ +/*N*/ USHORT nCol; +/*N*/ USHORT nRow; +/*N*/ +/*N*/ // Ecke links oben +/*N*/ +/*N*/ if ( bColByName && bRowByName ) +/*N*/ { +/*N*/ String aThisCorner; +/*N*/ pSrcDoc->GetString(nCol1,nRow1,nTab,aThisCorner); +/*N*/ if (bCornerUsed) +/*N*/ { +/*N*/ if (aCornerText != aThisCorner) +/*N*/ aCornerText.Erase(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aCornerText = aThisCorner; +/*N*/ bCornerUsed = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Titel suchen +/*N*/ +/*N*/ USHORT nStartCol = nCol1; +/*N*/ USHORT nStartRow = nRow1; +/*N*/ if (bColByName) ++nStartRow; +/*N*/ if (bRowByName) ++nStartCol; +/*N*/ String aTitle; +/*N*/ USHORT* pDestCols = NULL; +/*N*/ USHORT* pDestRows = NULL; +/*N*/ if (bColByName) +/*N*/ { +/*N*/ pDestCols = new USHORT[nCol2-nStartCol+1]; +/*N*/ for (nCol=nStartCol; nCol<=nCol2; nCol++) +/*N*/ { +/*N*/ pSrcDoc->GetString(nCol,nRow1,nTab,aTitle); +/*N*/ USHORT nPos = SC_CONS_NOTFOUND; +/*N*/ if (aTitle.Len()) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=0; i<nColCount && !bFound; i++) +/*N*/ if ( *ppColHeaders[i] == aTitle ) +/*N*/ { +/*N*/ nPos = i; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ DBG_ASSERT(bFound, "Spalte nicht gefunden"); +/*N*/ } +/*N*/ pDestCols[nCol-nStartCol] = nPos; +/*N*/ } +/*N*/ } +/*N*/ if (bRowByName) +/*N*/ { +/*N*/ pDestRows = new USHORT[nRow2-nStartRow+1]; +/*N*/ for (nRow=nStartRow; nRow<=nRow2; nRow++) +/*N*/ { +/*N*/ pSrcDoc->GetString(nCol1,nRow,nTab,aTitle); +/*N*/ USHORT nPos = SC_CONS_NOTFOUND; +/*N*/ if (aTitle.Len()) +/*N*/ { +/*N*/ BOOL bFound = FALSE; +/*N*/ for (USHORT i=0; i<nRowCount && !bFound; i++) +/*N*/ if ( *ppRowHeaders[i] == aTitle ) +/*N*/ { +/*N*/ nPos = i; +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ DBG_ASSERT(bFound, "Zeile nicht gefunden"); +/*N*/ } +/*N*/ pDestRows[nRow-nStartRow] = nPos; +/*N*/ } +/*N*/ } +/*N*/ nCol1 = nStartCol; +/*N*/ nRow1 = nStartRow; +/*N*/ +/*N*/ // Daten +/*N*/ +/*N*/ BOOL bAnyCell = ( eFunction == SUBTOTAL_FUNC_CNT2 ); +/*N*/ for (nCol=nCol1; nCol<=nCol2; nCol++) +/*N*/ { +/*N*/ USHORT nArrX = nCol-nCol1; +/*N*/ if (bColByName) nArrX = pDestCols[nArrX]; +/*N*/ if (nArrX != SC_CONS_NOTFOUND) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 for (nRow=nRow1; nRow<=nRow2; nRow++) +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ delete[] pDestCols; +/*N*/ delete[] pDestRows; +/*N*/ } + +// fertige Daten ins Dokument schreiben +//! optimieren nach Spalten? + +/*N*/ void ScConsData::OutputToDocument( ScDocument* pDestDoc, USHORT nCol, USHORT nRow, USHORT nTab ) +/*N*/ { +/*N*/ OpCode eOpCode = eOpCodeTable[eFunction]; +/*N*/ +/*N*/ USHORT nArrX; +/*N*/ USHORT nArrY; +/*N*/ USHORT nCount; +/*N*/ USHORT nPos; +/*N*/ USHORT i; +/*N*/ +/*N*/ // Ecke links oben +/*N*/ +/*N*/ if ( bColByName && bRowByName && aCornerText.Len() ) +/*N*/ pDestDoc->SetString( nCol, nRow, nTab, aCornerText ); +/*N*/ +/*N*/ // Titel +/*N*/ +/*N*/ USHORT nStartCol = nCol; +/*N*/ USHORT nStartRow = nRow; +/*N*/ if (bColByName) ++nStartRow; +/*N*/ if (bRowByName) ++nStartCol; +/*N*/ +/*N*/ if (bColByName) +/*N*/ for (i=0; i<nColCount; i++) +/*N*/ pDestDoc->SetString( nStartCol+i, nRow, nTab, *ppColHeaders[i] ); +/*N*/ if (bRowByName) +/*N*/ for (i=0; i<nRowCount; i++) +/*N*/ pDestDoc->SetString( nCol, nStartRow+i, nTab, *ppRowHeaders[i] ); +/*N*/ +/*N*/ nCol = nStartCol; +/*N*/ nRow = nStartRow; +/*N*/ +/*N*/ // Daten +/*N*/ +/*N*/ if ( ppCount && ppUsed ) // Werte direkt einfuegen +/*N*/ { +/*N*/ for (nArrX=0; nArrX<nColCount; nArrX++) +/*N*/ for (nArrY=0; nArrY<nRowCount; nArrY++) +/*N*/ if (ppUsed[nArrX][nArrY]) +/*N*/ { +/*N*/ double fVal = lcl_CalcData( eFunction, ppCount[nArrX][nArrY], +/*N*/ ppSum[nArrX][nArrY], +/*N*/ ppSumSqr[nArrX][nArrY]); +/*N*/ if (ppCount[nArrX][nArrY] < 0.0) +/*N*/ pDestDoc->SetError( nCol+nArrX, nRow+nArrY, nTab, errNoValue ); +/*N*/ else +/*N*/ pDestDoc->SetValue( nCol+nArrX, nRow+nArrY, nTab, fVal ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( ppRefs && ppUsed ) // Referenzen einfuegen +/*N*/ { +/*N*/ //! unterscheiden, ob nach Kategorien aufgeteilt +/*N*/ String aString; +/*N*/ +/*N*/ SingleRefData aSRef; // Daten fuer Referenz-Formelzellen +/*N*/ aSRef.InitFlags(); +/*N*/ aSRef.SetFlag3D(TRUE); +/*N*/ +/*N*/ ComplRefData aCRef; // Daten fuer Summen-Zellen +/*N*/ aCRef.InitFlags(); +/*N*/ aCRef.Ref1.SetColRel(TRUE); aCRef.Ref1.SetRowRel(TRUE); aCRef.Ref1.SetTabRel(TRUE); +/*N*/ aCRef.Ref2.SetColRel(TRUE); aCRef.Ref2.SetRowRel(TRUE); aCRef.Ref2.SetTabRel(TRUE); +/*N*/ +/*N*/ for (nArrY=0; nArrY<nRowCount; nArrY++) +/*N*/ { +/*N*/ USHORT nNeeded = 0; +/*N*/ for (nArrX=0; nArrX<nColCount; nArrX++) +/*N*/ if (ppUsed[nArrX][nArrY]) +/*N*/ nNeeded = Max( nNeeded, ppRefs[nArrX][nArrY].GetCount() ); +/*N*/ +/*N*/ if (nNeeded) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 pDestDoc->InsertRow( 0,nTab, MAXCOL,nTab, nRow+nArrY, nNeeded ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_dbcolect.cxx b/binfilter/bf_sc/source/core/tool/sc_dbcolect.cxx new file mode 100644 index 000000000000..61bed284accb --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_dbcolect.cxx @@ -0,0 +1,979 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <tools/debug.hxx> +#include <unotools/transliterationwrapper.hxx> + +#include "dbcolect.hxx" +#include "rechead.hxx" +#include "document.hxx" +#include "globstr.hrc" +namespace binfilter { + + +//--------------------------------------------------------------------------------------- + +/*N*/ ScDBData::ScDBData( const String& rName, +/*N*/ USHORT nTab, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, +/*N*/ BOOL bByR, BOOL bHasH) : +/*N*/ aName (rName), +/*N*/ nTable (nTab), +/*N*/ nStartCol (nCol1), +/*N*/ nStartRow (nRow1), +/*N*/ nEndCol (nCol2), +/*N*/ nEndRow (nRow2), +/*N*/ bByRow (bByR), +/*N*/ bDoSize (FALSE), +/*N*/ bKeepFmt (FALSE), +/*N*/ bStripData (FALSE), +/*N*/ bHasHeader (bHasH), +/*N*/ bDBSelection(FALSE), +/*N*/ nIndex (0), +/*N*/ nExportIndex(0), +/*N*/ bIsAdvanced (FALSE), +/*N*/ bAutoFilter (FALSE), +/*N*/ bModified (FALSE) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ ScSortParam aSortParam; +/*N*/ ScQueryParam aQueryParam; +/*N*/ ScSubTotalParam aSubTotalParam; +/*N*/ ScImportParam aImportParam; +/*N*/ +/*N*/ for (i=0; i<MAXQUERY; i++) +/*N*/ pQueryStr[i] = new String; +/*N*/ +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ nSubTotals[i] = 0; +/*N*/ pSubTotals[i] = NULL; +/*N*/ pFunctions[i] = NULL; +/*N*/ } +/*N*/ +/*N*/ SetSortParam( aSortParam ); +/*N*/ SetQueryParam( aQueryParam ); +/*N*/ SetSubTotalParam( aSubTotalParam ); +/*N*/ SetImportParam( aImportParam ); +/*N*/ } + +/*N*/ ScDBData::ScDBData( SvStream& rStream, ScMultipleReadHeader& rHdr ) : +/*N*/ // nicht in der Datei: +/*N*/ bAutoFilter (FALSE), +/*N*/ bModified (FALSE), +/*N*/ nExportIndex (0), +/*N*/ // nicht in alten Versionen: +/*N*/ bDoSize (FALSE), +/*N*/ bKeepFmt (FALSE), +/*N*/ bStripData (FALSE), +/*N*/ nIndex (0), +/*N*/ bIsAdvanced (FALSE), +/*N*/ bDBSelection (FALSE), +/*N*/ bDBSql (TRUE), +/*N*/ nDBType (ScDbTable), +/*N*/ nSubUserIndex (0), +/*N*/ bSortUserDef (FALSE), +/*N*/ nSortUserIndex (0) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ USHORT i; +/*N*/ USHORT j; +/*N*/ BYTE nDummy; +/*N*/ rtl_TextEncoding eCharSet = rStream.GetStreamCharSet(); +/*N*/ +/*N*/ rStream.ReadByteString( aName, eCharSet ); +/*N*/ rStream >> nTable; +/*N*/ rStream >> nStartCol; +/*N*/ rStream >> nStartRow; +/*N*/ rStream >> nEndCol; +/*N*/ rStream >> nEndRow; +/*N*/ rStream >> bByRow; +/*N*/ rStream >> bHasHeader; +/*N*/ rStream >> bSortCaseSens; +/*N*/ rStream >> bIncludePattern; +/*N*/ rStream >> bSortInplace; +/*N*/ rStream >> nSortDestTab; +/*N*/ rStream >> nSortDestCol; +/*N*/ rStream >> nSortDestRow; +/*N*/ rStream >> bQueryInplace; +/*N*/ rStream >> bQueryCaseSens; +/*N*/ rStream >> bQueryRegExp; +/*N*/ rStream >> bQueryDuplicate; +/*N*/ rStream >> nQueryDestTab; +/*N*/ rStream >> nQueryDestCol; +/*N*/ rStream >> nQueryDestRow; +/*N*/ rStream >> bSubRemoveOnly; +/*N*/ rStream >> bSubReplace; +/*N*/ rStream >> bSubPagebreak; +/*N*/ rStream >> bSubCaseSens; +/*N*/ rStream >> bSubDoSort; +/*N*/ rStream >> bSubAscending; +/*N*/ rStream >> bSubIncludePattern; +/*N*/ rStream >> bSubUserDef; +/*N*/ rStream >> bDBImport; +/*N*/ +/*N*/ rStream.ReadByteString( aDBName, eCharSet ); +/*N*/ rStream.ReadByteString( aDBStatement, eCharSet ); +/*N*/ rStream >> bDBNative; +/*N*/ +/*N*/ for (i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ rStream >> bDoSort[i]; +/*N*/ rStream >> nSortField[i]; +/*N*/ rStream >> bAscending[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXQUERY; i++) +/*N*/ { +/*N*/ rStream >> bDoQuery[i]; +/*N*/ rStream >> nQueryField[i]; +/*N*/ rStream >> nDummy; eQueryOp[i] = (ScQueryOp) nDummy; +/*N*/ rStream >> bQueryByString[i]; +/*N*/ pQueryStr[i] = new String; +/*N*/ rStream.ReadByteString( *pQueryStr[i], eCharSet ); +/*N*/ rStream >> nQueryVal[i]; +/*N*/ rStream >> nDummy; eQueryConnect[i] = (ScQueryConnect) nDummy; +/*N*/ } +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ rStream >> bDoSubTotal[i]; +/*N*/ rStream >> nSubField[i]; +/*N*/ +/*N*/ USHORT nCount; +/*N*/ rStream >> nCount; +/*N*/ nSubTotals[i] = nCount; +/*N*/ +/*N*/ pSubTotals[i] = nCount ? new USHORT [nCount] : NULL; +/*N*/ pFunctions[i] = nCount ? new ScSubTotalFunc [nCount] : NULL; +/*N*/ +/*N*/ for (j=0; j<nCount; j++) +/*N*/ { +/*N*/ rStream >> pSubTotals[i][j]; +/*N*/ rStream >> nDummy; pFunctions[i][j] = (ScSubTotalFunc)nDummy; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ rStream >> nIndex; +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ rStream >> bDBSelection; +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ rStream >> bDBSql; // Default = TRUE +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ { +/*N*/ rStream >> nSubUserIndex; +/*N*/ rStream >> bSortUserDef; +/*N*/ rStream >> nSortUserIndex; +/*N*/ } +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ { +/*N*/ rStream >> bDoSize; +/*N*/ rStream >> bKeepFmt; +/*N*/ } +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ rStream >> bStripData; +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ rStream >> nDBType; // Default = ScDbTable +/*N*/ +/*N*/ if (rHdr.BytesLeft()) +/*N*/ { +/*N*/ rStream >> bIsAdvanced; // Default = FALSE +/*N*/ if (bIsAdvanced) +/*N*/ rStream >> aAdvSource; +/*N*/ } +/*N*/ +/*N*/ // aSortLocale / aSortAlgorithm are not in binary file format +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ +/*N*/ // #43070# rottes Dokument?!? +/*N*/ // nEndCol war 258 +/*N*/ // und auch die CellInfo pPattern in ScOutputData FindRotated waren NULL +/*N*/ if ( nStartCol > MAXCOL ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "nStartCol > MAXCOL" ); +/*N*/ nStartCol = MAXCOL; +/*N*/ } +/*N*/ if ( nStartRow > MAXROW ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "nStartRow > MAXROW" ); +/*N*/ nStartRow = MAXROW; +/*N*/ } +/*N*/ if ( nEndCol > MAXCOL ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "nEndCol > MAXCOL" ); +/*N*/ nEndCol = MAXCOL; +/*N*/ } +/*N*/ if ( nEndRow > MAXROW ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "nEndRow > MAXROW" ); +/*N*/ nEndRow = MAXROW; +/*N*/ } +/*N*/ if ( nQueryDestCol > MAXCOL ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "nQueryDestCol > MAXCOL" ); +/*N*/ nQueryDestCol = MAXCOL; +/*N*/ } +/*N*/ if ( nQueryDestRow > MAXROW ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "nQueryDestRow > MAXROW" ); +/*N*/ nQueryDestRow = MAXROW; +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDBData::Store( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ USHORT i; +/*N*/ USHORT j; +/*N*/ rtl_TextEncoding eCharSet = rStream.GetStreamCharSet(); +/*N*/ +/*N*/ rStream.WriteByteString( aName, eCharSet ); +/*N*/ rStream << nTable; +/*N*/ rStream << nStartCol; +/*N*/ rStream << nStartRow; +/*N*/ rStream << nEndCol; +/*N*/ rStream << nEndRow; +/*N*/ rStream << bByRow; +/*N*/ rStream << bHasHeader; +/*N*/ rStream << bSortCaseSens; +/*N*/ rStream << bIncludePattern; +/*N*/ rStream << bSortInplace; +/*N*/ rStream << nSortDestTab; +/*N*/ rStream << nSortDestCol; +/*N*/ rStream << nSortDestRow; +/*N*/ rStream << bQueryInplace; +/*N*/ rStream << bQueryCaseSens; +/*N*/ rStream << bQueryRegExp; +/*N*/ rStream << bQueryDuplicate; +/*N*/ rStream << nQueryDestTab; +/*N*/ rStream << nQueryDestCol; +/*N*/ rStream << nQueryDestRow; +/*N*/ rStream << bSubRemoveOnly; +/*N*/ rStream << bSubReplace; +/*N*/ rStream << bSubPagebreak; +/*N*/ rStream << bSubCaseSens; +/*N*/ rStream << bSubDoSort; +/*N*/ rStream << bSubAscending; +/*N*/ rStream << bSubIncludePattern; +/*N*/ rStream << bSubUserDef; +/*N*/ rStream << bDBImport; +/*N*/ +/*N*/ rStream.WriteByteString( aDBName, eCharSet ); +/*N*/ rStream.WriteByteString( aDBStatement, eCharSet ); +/*N*/ rStream << bDBNative; +/*N*/ +/*N*/ for (i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ rStream << bDoSort[i]; +/*N*/ rStream << nSortField[i]; +/*N*/ rStream << bAscending[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXQUERY; i++) +/*N*/ { +/*N*/ rStream << bDoQuery[i]; +/*N*/ rStream << nQueryField[i]; +/*N*/ rStream << (BYTE) eQueryOp[i]; +/*N*/ rStream << bQueryByString[i]; +/*N*/ rStream.WriteByteString( *pQueryStr[i], eCharSet ); +/*N*/ rStream << nQueryVal[i]; +/*N*/ rStream << (BYTE) eQueryConnect[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ rStream << bDoSubTotal[i]; +/*N*/ rStream << nSubField[i]; +/*N*/ +/*N*/ USHORT nCount = nSubTotals[i]; +/*N*/ rStream << nCount; +/*N*/ for (j=0; j<nCount; j++) +/*N*/ { +/*N*/ rStream << pSubTotals[i][j]; +/*N*/ rStream << (BYTE)pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ rStream << nIndex; // seit 24.10.95 +/*N*/ +/*N*/ rStream << bDBSelection; +/*N*/ +/*N*/ rStream << bDBSql; // seit 4.2.97 +/*N*/ +/*N*/ rStream << nSubUserIndex; // seit 5.2.97 +/*N*/ rStream << bSortUserDef; +/*N*/ rStream << nSortUserIndex; +/*N*/ +/*N*/ rStream << bDoSize; // seit 13.2.97 +/*N*/ rStream << bKeepFmt; +/*N*/ +/*N*/ rStream << bStripData; // seit 23.2.97 +/*N*/ +/*N*/ if( rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) +/*N*/ { +/*N*/ // folgendes gab's in der 4.0 noch nicht +/*N*/ +/*N*/ // alte Versionen suchen immer nach Tables und Queries +/*N*/ rStream << nDBType; // seit 20.11.97 +/*N*/ +/*N*/ // starting from 591, store advanced filter source range +/*N*/ // only if set, to avoid unneccessary warnings +/*N*/ if (bIsAdvanced) +/*N*/ { +/*?*/ rStream << (BOOL) TRUE; +/*?*/ rStream << aAdvSource; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // aSortLocale / aSortAlgorithm are not in binary file format +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } + +/*N*/ ScDBData::ScDBData( const ScDBData& rData ) : +/*N*/ ScRefreshTimer ( rData ), +/*N*/ aName (rData.aName), +/*N*/ nTable (rData.nTable), +/*N*/ nStartCol (rData.nStartCol), +/*N*/ nStartRow (rData.nStartRow), +/*N*/ nEndCol (rData.nEndCol), +/*N*/ nEndRow (rData.nEndRow), +/*N*/ bByRow (rData.bByRow), +/*N*/ bHasHeader (rData.bHasHeader), +/*N*/ bDoSize (rData.bDoSize), +/*N*/ bKeepFmt (rData.bKeepFmt), +/*N*/ bStripData (rData.bStripData), +/*N*/ bSortCaseSens (rData.bSortCaseSens), +/*N*/ bIncludePattern (rData.bIncludePattern), +/*N*/ bSortInplace (rData.bSortInplace), +/*N*/ nSortDestTab (rData.nSortDestTab), +/*N*/ nSortDestCol (rData.nSortDestCol), +/*N*/ nSortDestRow (rData.nSortDestRow), +/*N*/ bSortUserDef (rData.bSortUserDef), +/*N*/ nSortUserIndex (rData.nSortUserIndex), +/*N*/ aSortLocale (rData.aSortLocale), +/*N*/ aSortAlgorithm (rData.aSortAlgorithm), +/*N*/ bQueryInplace (rData.bQueryInplace), +/*N*/ bQueryCaseSens (rData.bQueryCaseSens), +/*N*/ bQueryRegExp (rData.bQueryRegExp), +/*N*/ bQueryDuplicate (rData.bQueryDuplicate), +/*N*/ nQueryDestTab (rData.nQueryDestTab), +/*N*/ nQueryDestCol (rData.nQueryDestCol), +/*N*/ nQueryDestRow (rData.nQueryDestRow), +/*N*/ bIsAdvanced (rData.bIsAdvanced), +/*N*/ aAdvSource (rData.aAdvSource), +/*N*/ bSubRemoveOnly (rData.bSubRemoveOnly), +/*N*/ bSubReplace (rData.bSubReplace), +/*N*/ bSubPagebreak (rData.bSubPagebreak), +/*N*/ bSubCaseSens (rData.bSubCaseSens), +/*N*/ bSubDoSort (rData.bSubDoSort), +/*N*/ bSubAscending (rData.bSubAscending), +/*N*/ bSubIncludePattern (rData.bSubIncludePattern), +/*N*/ bSubUserDef (rData.bSubUserDef), +/*N*/ nSubUserIndex (rData.nSubUserIndex), +/*N*/ bDBImport (rData.bDBImport), +/*N*/ aDBName (rData.aDBName), +/*N*/ aDBStatement (rData.aDBStatement), +/*N*/ bDBNative (rData.bDBNative), +/*N*/ bDBSelection (rData.bDBSelection), +/*N*/ bDBSql (rData.bDBSql), +/*N*/ nDBType (rData.nDBType), +/*N*/ nIndex (rData.nIndex), +/*N*/ nExportIndex (rData.nExportIndex), +/*N*/ bAutoFilter (rData.bAutoFilter), +/*N*/ bModified (rData.bModified) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT j; +/*N*/ +/*N*/ for (i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ bDoSort[i] = rData.bDoSort[i]; +/*N*/ nSortField[i] = rData.nSortField[i]; +/*N*/ bAscending[i] = rData.bAscending[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXQUERY; i++) +/*N*/ { +/*N*/ bDoQuery[i] = rData.bDoQuery[i]; +/*N*/ nQueryField[i] = rData.nQueryField[i]; +/*N*/ eQueryOp[i] = rData.eQueryOp[i]; +/*N*/ bQueryByString[i] = rData.bQueryByString[i]; +/*N*/ pQueryStr[i] = new String( *(rData.pQueryStr[i]) ); +/*N*/ nQueryVal[i] = rData.nQueryVal[i]; +/*N*/ eQueryConnect[i] = rData.eQueryConnect[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ bDoSubTotal[i] = rData.bDoSubTotal[i]; +/*N*/ nSubField[i] = rData.nSubField[i]; +/*N*/ +/*N*/ USHORT nCount = rData.nSubTotals[i]; +/*N*/ nSubTotals[i] = nCount; +/*N*/ pFunctions[i] = nCount ? new ScSubTotalFunc [nCount] : NULL; +/*N*/ pSubTotals[i] = nCount ? new USHORT [nCount] : NULL; +/*N*/ +/*N*/ for (j=0; j<nCount; j++) +/*N*/ { +/*N*/ pSubTotals[i][j] = rData.pSubTotals[i][j]; +/*N*/ pFunctions[i][j] = rData.pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ ScDBData& ScDBData::operator= (const ScDBData& rData) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT j; +/*N*/ +/*N*/ ScRefreshTimer::operator=( rData ); +/*N*/ aName = rData.aName; +/*N*/ nTable = rData.nTable; +/*N*/ nStartCol = rData.nStartCol; +/*N*/ nStartRow = rData.nStartRow; +/*N*/ nEndCol = rData.nEndCol; +/*N*/ nEndRow = rData.nEndRow; +/*N*/ bByRow = rData.bByRow; +/*N*/ bHasHeader = rData.bHasHeader; +/*N*/ bDoSize = rData.bDoSize; +/*N*/ bKeepFmt = rData.bKeepFmt; +/*N*/ bStripData = rData.bStripData; +/*N*/ bSortCaseSens = rData.bSortCaseSens; +/*N*/ bIncludePattern = rData.bIncludePattern; +/*N*/ bSortInplace = rData.bSortInplace; +/*N*/ nSortDestTab = rData.nSortDestTab; +/*N*/ nSortDestCol = rData.nSortDestCol; +/*N*/ nSortDestRow = rData.nSortDestRow; +/*N*/ bSortUserDef = rData.bSortUserDef; +/*N*/ nSortUserIndex = rData.nSortUserIndex; +/*N*/ aSortLocale = rData.aSortLocale; +/*N*/ aSortAlgorithm = rData.aSortAlgorithm; +/*N*/ bQueryInplace = rData.bQueryInplace; +/*N*/ bQueryCaseSens = rData.bQueryCaseSens; +/*N*/ bQueryRegExp = rData.bQueryRegExp; +/*N*/ bQueryDuplicate = rData.bQueryDuplicate; +/*N*/ nQueryDestTab = rData.nQueryDestTab; +/*N*/ nQueryDestCol = rData.nQueryDestCol; +/*N*/ nQueryDestRow = rData.nQueryDestRow; +/*N*/ bIsAdvanced = rData.bIsAdvanced; +/*N*/ aAdvSource = rData.aAdvSource; +/*N*/ bSubRemoveOnly = rData.bSubRemoveOnly; +/*N*/ bSubReplace = rData.bSubReplace; +/*N*/ bSubPagebreak = rData.bSubPagebreak; +/*N*/ bSubCaseSens = rData.bSubCaseSens; +/*N*/ bSubDoSort = rData.bSubDoSort; +/*N*/ bSubAscending = rData.bSubAscending; +/*N*/ bSubIncludePattern = rData.bSubIncludePattern; +/*N*/ bSubUserDef = rData.bSubUserDef; +/*N*/ nSubUserIndex = rData.nSubUserIndex; +/*N*/ bDBImport = rData.bDBImport; +/*N*/ aDBName = rData.aDBName; +/*N*/ aDBStatement = rData.aDBStatement; +/*N*/ bDBNative = rData.bDBNative; +/*N*/ bDBSelection = rData.bDBSelection; +/*N*/ bDBSql = rData.bDBSql; +/*N*/ nDBType = rData.nDBType; +/*N*/ nIndex = rData.nIndex; +/*N*/ nExportIndex = rData.nExportIndex; +/*N*/ bAutoFilter = rData.bAutoFilter; +/*N*/ +/*N*/ for (i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ bDoSort[i] = rData.bDoSort[i]; +/*N*/ nSortField[i] = rData.nSortField[i]; +/*N*/ bAscending[i] = rData.bAscending[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXQUERY; i++) +/*N*/ { +/*N*/ bDoQuery[i] = rData.bDoQuery[i]; +/*N*/ nQueryField[i] = rData.nQueryField[i]; +/*N*/ eQueryOp[i] = rData.eQueryOp[i]; +/*N*/ bQueryByString[i] = rData.bQueryByString[i]; +/*N*/ *pQueryStr[i] = *rData.pQueryStr[i]; +/*N*/ nQueryVal[i] = rData.nQueryVal[i]; +/*N*/ eQueryConnect[i] = rData.eQueryConnect[i]; +/*N*/ } +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ bDoSubTotal[i] = rData.bDoSubTotal[i]; +/*N*/ nSubField[i] = rData.nSubField[i]; +/*N*/ USHORT nCount = rData.nSubTotals[i]; +/*N*/ nSubTotals[i] = nCount; +/*N*/ +/*N*/ delete[] pSubTotals[i]; +/*N*/ delete[] pFunctions[i]; +/*N*/ +/*N*/ pSubTotals[i] = nCount ? new USHORT [nCount] : NULL; +/*N*/ pFunctions[i] = nCount ? new ScSubTotalFunc [nCount] : NULL; +/*N*/ for (j=0; j<nCount; j++) +/*N*/ { +/*N*/ pSubTotals[i][j] = rData.pSubTotals[i][j]; +/*N*/ pFunctions[i][j] = rData.pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return *this; +/*N*/ } + + +/*N*/ ScDBData::~ScDBData() +/*N*/ { +/*N*/ StopRefreshTimer(); +/*N*/ USHORT i; +/*N*/ +/*N*/ for (i=0; i<MAXQUERY; i++) +/*N*/ delete pQueryStr[i]; +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ delete[] pSubTotals[i]; +/*N*/ delete[] pFunctions[i]; +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDBData::IsBeyond(USHORT nMaxRow) const +/*N*/ { +/*N*/ return ( nStartRow > nMaxRow || +/*N*/ nEndRow > nMaxRow || +/*N*/ nQueryDestRow > nMaxRow ); +/*N*/ } + + + +/*N*/ void ScDBData::GetArea(USHORT& rTab, USHORT& rCol1, USHORT& rRow1, USHORT& rCol2, USHORT& rRow2) const +/*N*/ { +/*N*/ rTab = nTable; +/*N*/ rCol1 = nStartCol; +/*N*/ rRow1 = nStartRow; +/*N*/ rCol2 = nEndCol; +/*N*/ rRow2 = nEndRow; +/*N*/ } + +/*N*/ void ScDBData::GetArea(ScRange& rRange) const +/*N*/ { +/*N*/ rRange = ScRange( nStartCol,nStartRow,nTable, nEndCol,nEndRow,nTable ); +/*N*/ } + +/*N*/ void ScDBData::SetArea(USHORT nTab, USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2) +/*N*/ { +/*N*/ nTable = nTab; +/*N*/ nStartCol = nCol1; +/*N*/ nStartRow = nRow1; +/*N*/ nEndCol = nCol2; +/*N*/ nEndRow = nRow2; +/*N*/ } + + +/*N*/ void ScDBData::GetSortParam( ScSortParam& rSortParam ) const +/*N*/ { +/*N*/ rSortParam.nCol1 = nStartCol; +/*N*/ rSortParam.nRow1 = nStartRow; +/*N*/ rSortParam.nCol2 = nEndCol; +/*N*/ rSortParam.nRow2 = nEndRow; +/*N*/ rSortParam.bByRow = bByRow; +/*N*/ rSortParam.bHasHeader = bHasHeader; +/*N*/ rSortParam.bCaseSens = bSortCaseSens; +/*N*/ rSortParam.bInplace = bSortInplace; +/*N*/ rSortParam.nDestTab = nSortDestTab; +/*N*/ rSortParam.nDestCol = nSortDestCol; +/*N*/ rSortParam.nDestRow = nSortDestRow; +/*N*/ rSortParam.bIncludePattern = bIncludePattern; +/*N*/ rSortParam.bUserDef = bSortUserDef; +/*N*/ rSortParam.nUserIndex = nSortUserIndex; +/*N*/ for (USHORT i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ rSortParam.bDoSort[i] = bDoSort[i]; +/*N*/ rSortParam.nField[i] = nSortField[i]; +/*N*/ rSortParam.bAscending[i] = bAscending[i]; +/*N*/ } +/*N*/ rSortParam.aCollatorLocale = aSortLocale; +/*N*/ rSortParam.aCollatorAlgorithm = aSortAlgorithm; +/*N*/ } + +/*N*/ void ScDBData::SetSortParam( const ScSortParam& rSortParam ) +/*N*/ { +/*N*/ bSortCaseSens = rSortParam.bCaseSens; +/*N*/ bIncludePattern = rSortParam.bIncludePattern; +/*N*/ bSortInplace = rSortParam.bInplace; +/*N*/ nSortDestTab = rSortParam.nDestTab; +/*N*/ nSortDestCol = rSortParam.nDestCol; +/*N*/ nSortDestRow = rSortParam.nDestRow; +/*N*/ bSortUserDef = rSortParam.bUserDef; +/*N*/ nSortUserIndex = rSortParam.nUserIndex; +/*N*/ for (USHORT i=0; i<MAXSORT; i++) +/*N*/ { +/*N*/ bDoSort[i] = rSortParam.bDoSort[i]; +/*N*/ nSortField[i] = rSortParam.nField[i]; +/*N*/ bAscending[i] = rSortParam.bAscending[i]; +/*N*/ } +/*N*/ aSortLocale = rSortParam.aCollatorLocale; +/*N*/ aSortAlgorithm = rSortParam.aCollatorAlgorithm; +/*N*/ +/*N*/ //#98317#; set the orientation +/*N*/ bByRow = rSortParam.bByRow; +/*N*/ } + +/*N*/ void ScDBData::GetQueryParam( ScQueryParam& rQueryParam ) const +/*N*/ { +/*N*/ rQueryParam.nCol1 = nStartCol; +/*N*/ rQueryParam.nRow1 = nStartRow; +/*N*/ rQueryParam.nCol2 = nEndCol; +/*N*/ rQueryParam.nRow2 = nEndRow; +/*N*/ rQueryParam.nTab = nTable; +/*N*/ rQueryParam.bByRow = bByRow; +/*N*/ rQueryParam.bHasHeader = bHasHeader; +/*N*/ rQueryParam.bInplace = bQueryInplace; +/*N*/ rQueryParam.bCaseSens = bQueryCaseSens; +/*N*/ rQueryParam.bRegExp = bQueryRegExp; +/*N*/ rQueryParam.bDuplicate = bQueryDuplicate; +/*N*/ rQueryParam.nDestTab = nQueryDestTab; +/*N*/ rQueryParam.nDestCol = nQueryDestCol; +/*N*/ rQueryParam.nDestRow = nQueryDestRow; +/*N*/ +/*N*/ rQueryParam.Resize( MAXQUERY ); +/*N*/ for (USHORT i=0; i<MAXQUERY; i++) +/*N*/ { +/*N*/ ScQueryEntry& rEntry = rQueryParam.GetEntry(i); +/*N*/ +/*N*/ rEntry.bDoQuery = bDoQuery[i]; +/*N*/ rEntry.nField = nQueryField[i]; +/*N*/ rEntry.eOp = eQueryOp[i]; +/*N*/ rEntry.bQueryByString = bQueryByString[i]; +/*N*/ *rEntry.pStr = *pQueryStr[i]; +/*N*/ rEntry.nVal = nQueryVal[i]; +/*N*/ rEntry.eConnect = eQueryConnect[i]; +/*N*/ } +/*N*/ } + +/*N*/ void ScDBData::SetQueryParam(const ScQueryParam& rQueryParam) +/*N*/ { +/*N*/ DBG_ASSERT( rQueryParam.GetEntryCount() <= MAXQUERY || +/*N*/ !rQueryParam.GetEntry(MAXQUERY).bDoQuery, +/*N*/ "zuviele Eintraege bei ScDBData::SetQueryParam" ); +/*N*/ +/*N*/ // set bIsAdvanced to FALSE for everything that is not from the +/*N*/ // advanced filter dialog +/*N*/ bIsAdvanced = FALSE; +/*N*/ +/*N*/ bQueryInplace = rQueryParam.bInplace; +/*N*/ bQueryCaseSens = rQueryParam.bCaseSens; +/*N*/ bQueryRegExp = rQueryParam.bRegExp; +/*N*/ bQueryDuplicate = rQueryParam.bDuplicate; +/*N*/ nQueryDestTab = rQueryParam.nDestTab; +/*N*/ nQueryDestCol = rQueryParam.nDestCol; +/*N*/ nQueryDestRow = rQueryParam.nDestRow; +/*N*/ for (USHORT i=0; i<MAXQUERY; i++) +/*N*/ { +/*N*/ ScQueryEntry& rEntry = rQueryParam.GetEntry(i); +/*N*/ +/*N*/ bDoQuery[i] = rEntry.bDoQuery; +/*N*/ nQueryField[i] = rEntry.nField; +/*N*/ eQueryOp[i] = rEntry.eOp; +/*N*/ bQueryByString[i] = rEntry.bQueryByString; +/*N*/ *pQueryStr[i] = *rEntry.pStr; +/*N*/ nQueryVal[i] = rEntry.nVal; +/*N*/ eQueryConnect[i] = rEntry.eConnect; +/*N*/ } +/*N*/ } + +/*N*/ void ScDBData::SetAdvancedQuerySource(const ScRange* pSource) +/*N*/ { +/*N*/ if (pSource) +/*N*/ { +/*N*/ aAdvSource = *pSource; +/*N*/ bIsAdvanced = TRUE; +/*N*/ } +/*N*/ else +/*N*/ bIsAdvanced = FALSE; +/*N*/ } + +/*N*/ BOOL ScDBData::GetAdvancedQuerySource(ScRange& rSource) const +/*N*/ { +/*N*/ rSource = aAdvSource; +/*N*/ return bIsAdvanced; +/*N*/ } + +/*N*/ void ScDBData::GetSubTotalParam(ScSubTotalParam& rSubTotalParam) const +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT j; +/*N*/ +/*N*/ rSubTotalParam.nCol1 = nStartCol; +/*N*/ rSubTotalParam.nRow1 = nStartRow; +/*N*/ rSubTotalParam.nCol2 = nEndCol; +/*N*/ rSubTotalParam.nRow2 = nEndRow; +/*N*/ +/*N*/ rSubTotalParam.bRemoveOnly = bSubRemoveOnly; +/*N*/ rSubTotalParam.bReplace = bSubReplace; +/*N*/ rSubTotalParam.bPagebreak = bSubPagebreak; +/*N*/ rSubTotalParam.bCaseSens = bSubCaseSens; +/*N*/ rSubTotalParam.bDoSort = bSubDoSort; +/*N*/ rSubTotalParam.bAscending = bSubAscending; +/*N*/ rSubTotalParam.bIncludePattern = bSubIncludePattern; +/*N*/ rSubTotalParam.bUserDef = bSubUserDef; +/*N*/ rSubTotalParam.nUserIndex = nSubUserIndex; +/*N*/ +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ rSubTotalParam.bGroupActive[i] = bDoSubTotal[i]; +/*N*/ rSubTotalParam.nField[i] = nSubField[i]; +/*N*/ USHORT nCount = nSubTotals[i]; +/*N*/ +/*N*/ rSubTotalParam.nSubTotals[i] = nCount; +/*N*/ delete[] rSubTotalParam.pSubTotals[i]; +/*N*/ delete[] rSubTotalParam.pFunctions[i]; +/*N*/ rSubTotalParam.pSubTotals[i] = nCount ? new USHORT[nCount] : NULL; +/*N*/ rSubTotalParam.pFunctions[i] = nCount ? new ScSubTotalFunc[nCount] +/*N*/ : NULL; +/*N*/ for (j=0; j<nCount; j++) +/*N*/ { +/*N*/ rSubTotalParam.pSubTotals[i][j] = pSubTotals[i][j]; +/*N*/ rSubTotalParam.pFunctions[i][j] = pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDBData::SetSubTotalParam(const ScSubTotalParam& rSubTotalParam) +/*N*/ { +/*N*/ USHORT i; +/*N*/ USHORT j; +/*N*/ +/*N*/ bSubRemoveOnly = rSubTotalParam.bRemoveOnly; +/*N*/ bSubReplace = rSubTotalParam.bReplace; +/*N*/ bSubPagebreak = rSubTotalParam.bPagebreak; +/*N*/ bSubCaseSens = rSubTotalParam.bCaseSens; +/*N*/ bSubDoSort = rSubTotalParam.bDoSort; +/*N*/ bSubAscending = rSubTotalParam.bAscending; +/*N*/ bSubIncludePattern = rSubTotalParam.bIncludePattern; +/*N*/ bSubUserDef = rSubTotalParam.bUserDef; +/*N*/ nSubUserIndex = rSubTotalParam.nUserIndex; +/*N*/ +/*N*/ for (i=0; i<MAXSUBTOTAL; i++) +/*N*/ { +/*N*/ bDoSubTotal[i] = rSubTotalParam.bGroupActive[i]; +/*N*/ nSubField[i] = rSubTotalParam.nField[i]; +/*N*/ USHORT nCount = rSubTotalParam.nSubTotals[i]; +/*N*/ +/*N*/ nSubTotals[i] = nCount; +/*N*/ delete[] pSubTotals[i]; +/*N*/ delete[] pFunctions[i]; +/*N*/ pSubTotals[i] = nCount ? new USHORT [nCount] : NULL; +/*N*/ pFunctions[i] = nCount ? new ScSubTotalFunc [nCount] : NULL; +/*N*/ for (j=0; j<nCount; j++) +/*N*/ { +/*N*/ pSubTotals[i][j] = rSubTotalParam.pSubTotals[i][j]; +/*N*/ pFunctions[i][j] = rSubTotalParam.pFunctions[i][j]; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDBData::GetImportParam(ScImportParam& rImportParam) const +/*N*/ { +/*N*/ rImportParam.nCol1 = nStartCol; +/*N*/ rImportParam.nRow1 = nStartRow; +/*N*/ rImportParam.nCol2 = nEndCol; +/*N*/ rImportParam.nRow2 = nEndRow; +/*N*/ +/*N*/ rImportParam.bImport = bDBImport; +/*N*/ rImportParam.aDBName = aDBName; +/*N*/ rImportParam.aStatement = aDBStatement; +/*N*/ rImportParam.bNative = bDBNative; +/*N*/ rImportParam.bSql = bDBSql; +/*N*/ rImportParam.nType = nDBType; +/*N*/ } + +/*N*/ void ScDBData::SetImportParam(const ScImportParam& rImportParam) +/*N*/ { +/*N*/ bDBImport = rImportParam.bImport; +/*N*/ aDBName = rImportParam.aDBName; +/*N*/ aDBStatement = rImportParam.aStatement; +/*N*/ bDBNative = rImportParam.bNative; +/*N*/ bDBSql = rImportParam.bSql; +/*N*/ nDBType = rImportParam.nType; +/*N*/ } + + + + +/*N*/ DataObject* ScDBData::Clone() const +/*N*/ { +/*N*/ return new ScDBData(*this); +/*N*/ } + + +//--------------------------------------------------------------------------------------- +// Compare zum Sortieren + +/*N*/ short ScDBCollection::Compare(DataObject* pKey1, DataObject* pKey2) const +/*N*/ { +/*N*/ const String& rStr1 = ((ScDBData*)pKey1)->GetName(); +/*N*/ const String& rStr2 = ((ScDBData*)pKey2)->GetName(); +/*N*/ return (short) ScGlobal::pTransliteration->compareString( rStr1, rStr2 ); +/*N*/ } + +// IsEqual - alles gleich + + +/*N*/ ScDBData* ScDBCollection::GetDBAtCursor(USHORT nCol, USHORT nRow, USHORT nTab, BOOL bStartOnly) const +/*N*/ { +/*N*/ ScDBData* pNoNameData = NULL; +/*N*/ if (pItems) +/*N*/ { +/*N*/ const String& rNoName = ScGlobal::GetRscString( STR_DB_NONAME ); +/*N*/ +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if (((ScDBData*)pItems[i])->IsDBAtCursor(nCol, nRow, nTab, bStartOnly)) +/*N*/ } +/*N*/ return pNoNameData; // "unbenannt" nur zurueck, wenn sonst nichts gefunden +/*N*/ } + +/*N*/ ScDBData* ScDBCollection::GetDBAtArea(USHORT nTab, USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2) const +/*N*/ { +/*N*/ ScDBData* pNoNameData = NULL; +/*N*/ if (pItems) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 const String& rNoName = ScGlobal::GetRscString( STR_DB_NONAME ); +/*N*/ } +/*N*/ return pNoNameData; // "unbenannt" nur zurueck, wenn sonst nichts gefunden +/*N*/ } + +/*N*/ BOOL ScDBCollection::SearchName( const String& rName, USHORT& rIndex ) const +/*N*/ { +/*N*/ ScDBData aDataObj( rName, 0,0,0,0,0 ); +/*N*/ return Search( &aDataObj, rIndex ); +/*N*/ } + +/*N*/ BOOL ScDBCollection::Load( SvStream& rStream ) +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ USHORT nNewCount; +/*N*/ +/*N*/ while( nCount > 0 ) +/*?*/ AtFree(0); // alles loeschen +/*N*/ +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> nNewCount; +/*N*/ for (USHORT i=0; i<nNewCount && bSuccess; i++) +/*N*/ { +/*N*/ ScDBData* pData = new ScDBData( rStream, aHdr ); +/*N*/ Insert( pData ); +/*N*/ } +/*N*/ if (aHdr.BytesLeft()) // ... Erweiterungen +/*N*/ rStream >> nEntryIndex; +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ BOOL ScDBCollection::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT i; +/*N*/ USHORT nSaveCount = nCount; +/*N*/ USHORT nSaveMaxRow = pDoc->GetSrcMaxRow(); +/*N*/ if ( nSaveMaxRow < MAXROW ) +/*N*/ { +/*N*/ nSaveCount = 0; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ( !((const ScDBData*)At(i))->IsBeyond(nSaveMaxRow) ) +/*N*/ ++nSaveCount; +/*N*/ +/*N*/ if ( nSaveCount < nCount ) +/*N*/ pDoc->SetLostData(); // Warnung ausgeben +/*N*/ } +/*N*/ +/*N*/ rStream << nSaveCount; +/*N*/ +/*N*/ BOOL bSuccess = TRUE; +/*N*/ for (i=0; i<nCount && bSuccess; i++) +/*N*/ { +/*N*/ const ScDBData* pDBData = (const ScDBData*)At(i); +/*N*/ if ( nSaveMaxRow == MAXROW || !pDBData->IsBeyond(nSaveMaxRow) ) +/*N*/ bSuccess = pDBData->Store( rStream, aHdr ); +/*N*/ } +/*N*/ +/*N*/ rStream << nEntryIndex; // seit 24.10.95 +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ void ScDBCollection::UpdateReference(UpdateRefMode eUpdateRefMode, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 USHORT theCol1; +/*N*/ } +/*N*/ } + + + + +/*N*/ ScDBData* ScDBCollection::FindIndex(USHORT nIndex) +/*N*/ { +/*N*/ USHORT i = 0; +/*N*/ while (i < nCount) +/*N*/ { +/*N*/ if ((*this)[i]->GetIndex() == nIndex) +/*N*/ return (*this)[i]; +/*N*/ i++; +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ BOOL ScDBCollection::Insert(DataObject* pDataObject) +/*N*/ { +/*N*/ ScDBData* pData = (ScDBData*) pDataObject; +/*N*/ if (!pData->GetIndex()) // schon gesetzt? +/*N*/ pData->SetIndex(nEntryIndex++); +/*N*/ BOOL bInserted = SortedCollection::Insert(pDataObject); +/*N*/ if ( bInserted && pData->HasImportParam() && !pData->HasImportSelection() ) +/*N*/ { +/*?*/ pData->SetRefreshHandler( GetRefreshHandler() ); +/*?*/ pData->SetRefreshControl( pDoc->GetRefreshTimerControlAddress() ); +/*N*/ } +/*N*/ return bInserted; +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_ddelink.cxx b/binfilter/bf_sc/source/core/tool/sc_ddelink.cxx new file mode 100644 index 000000000000..808bc4b91396 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_ddelink.cxx @@ -0,0 +1,154 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svtools/zforlist.hxx> + +#include "ddelink.hxx" +#include "document.hxx" +#include "scmatrix.hxx" +#include "rechead.hxx" +#include "bf_sc.hrc" +#include "hints.hxx" +namespace binfilter { + +/*N*/ TYPEINIT2(ScDdeLink,::binfilter::SvBaseLink,SfxBroadcaster); + +#ifdef PM2 +#define DDE_TXT_ENCODING RTL_TEXTENCODING_IBM_850 +#else +#define DDE_TXT_ENCODING RTL_TEXTENCODING_MS_1252 +#endif + +/*N*/ BOOL ScDdeLink::bIsInUpdate = FALSE; + +//------------------------------------------------------------------------ + +/*N*/ ScDdeLink::ScDdeLink( ScDocument* pD, const String& rA, const String& rT, const String& rI, +/*N*/ BYTE nM ) : +/*N*/ ::binfilter::SvBaseLink(::binfilter::LINKUPDATE_ALWAYS,FORMAT_STRING), +/*N*/ pDoc( pD ), +/*N*/ aAppl( rA ), +/*N*/ aTopic( rT ), +/*N*/ aItem( rI ), +/*N*/ nMode( nM ), +/*N*/ pResult( NULL ), +/*N*/ bNeedUpdate( FALSE ) +/*N*/ { +/*N*/ } + +/*N*/ __EXPORT ScDdeLink::~ScDdeLink() +/*N*/ { +/*N*/ // Verbindung aufheben +/*N*/ +/*N*/ delete pResult; +/*N*/ } + +/*N*/ ScDdeLink::ScDdeLink( ScDocument* pD, SvStream& rStream, ScMultipleReadHeader& rHdr ) : +/*N*/ ::binfilter::SvBaseLink(::binfilter::LINKUPDATE_ALWAYS,FORMAT_STRING), +/*N*/ pDoc( pD ), +/*N*/ pResult( NULL ), +/*N*/ bNeedUpdate( FALSE ) +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rtl_TextEncoding eCharSet = rStream.GetStreamCharSet(); +/*N*/ rStream.ReadByteString( aAppl, eCharSet ); +/*N*/ rStream.ReadByteString( aTopic, eCharSet ); +/*N*/ rStream.ReadByteString( aItem, eCharSet ); +/*N*/ +/*N*/ BOOL bHasValue; +/*N*/ rStream >> bHasValue; +/*N*/ if ( bHasValue ) +/*N*/ pResult = new ScMatrix( rStream ); +/*N*/ +/*N*/ if (rHdr.BytesLeft()) // neu in 388b und der 364w (RealTime-Client) Version +/*N*/ rStream >> nMode; +/*N*/ else +/*N*/ nMode = SC_DDE_DEFAULT; +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ void ScDdeLink::Store( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rtl_TextEncoding eCharSet = rStream.GetStreamCharSet(); +/*N*/ rStream.WriteByteString( aAppl, eCharSet ); +/*N*/ rStream.WriteByteString( aTopic, eCharSet ); +/*N*/ rStream.WriteByteString( aItem, eCharSet ); +/*N*/ +/*N*/ BOOL bHasValue = ( pResult != NULL ); +/*N*/ rStream << bHasValue; +/*N*/ if (bHasValue) +/*N*/ pResult->Store( rStream ); +/*N*/ +/*N*/ if( rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) // nicht bei 4.0 Export +/*N*/ rStream << nMode; // seit 388b +/*N*/ +/*N*/ // Links mit Mode != SC_DDE_DEFAULT werden bei 4.0 Export komplett weggelassen +/*N*/ // (aus ScDocument::SaveDdeLinks) +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ void __EXPORT ScDdeLink::DataChanged( const String& rMimeType, +/*N*/ const ::com::sun::star::uno::Any & rValue ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 // wir koennen nur Strings... +/*N*/ } + + + + +/*N*/ void ScDdeLink::TryUpdate() +/*N*/ { +/*N*/ if (bIsInUpdate) +/*N*/ bNeedUpdate = TRUE; // kann jetzt nicht ausgefuehrt werden +/*N*/ else +/*N*/ { +/*N*/ bIsInUpdate = TRUE; +/*N*/ //Application::Reschedule(); //! OS/2-Simulation +/*N*/ pDoc->IncInDdeLinkUpdate(); +/*N*/ Update(); +/*N*/ pDoc->DecInDdeLinkUpdate(); +/*N*/ bIsInUpdate = FALSE; +/*N*/ bNeedUpdate = FALSE; +/*N*/ } +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_detdata.cxx b/binfilter/bf_sc/source/core/tool/sc_detdata.cxx new file mode 100644 index 000000000000..b0fd6efb2983 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_detdata.cxx @@ -0,0 +1,142 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> + +#include "detdata.hxx" +#include "refupdat.hxx" +#include "rechead.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ SV_IMPL_PTRARR( ScDetOpArr_Impl, ScDetOpDataPtr ); + +//------------------------------------------------------------------------ + +/*N*/ ScDetOpList::ScDetOpList(const ScDetOpList& rList) : +/*N*/ bHasAddError( FALSE ) +/*N*/ { +/*N*/ USHORT nCount = rList.Count(); +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ Append( new ScDetOpData(*rList[i]) ); +/*N*/ } + +/*N*/ void ScDetOpList::UpdateReference( ScDocument* pDoc, UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ USHORT nCount = Count(); +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ ScAddress aPos = (*this)[i]->GetPos(); +/*N*/ USHORT nCol1 = aPos.Col(); +/*N*/ USHORT nRow1 = aPos.Row(); +/*N*/ USHORT nTab1 = aPos.Tab(); +/*N*/ USHORT nCol2 = nCol1; +/*N*/ USHORT nRow2 = nRow1; +/*N*/ USHORT nTab2 = nTab1; +/*N*/ +/*N*/ ScRefUpdateRes eRes = +/*N*/ ScRefUpdate::Update( pDoc, eUpdateRefMode, +/*N*/ rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(), +/*N*/ rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), nDx, nDy, nDz, +/*N*/ nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ if ( eRes != UR_NOTHING ) +/*N*/ (*this)[i]->SetPos( ScAddress( nCol1, nRow1, nTab1 ) ); +/*N*/ } +/*N*/ } + +/*N*/ void ScDetOpList::Append( ScDetOpData* pData ) +/*N*/ { +/*N*/ if ( pData->GetOperation() == SCDETOP_ADDERROR ) +/*N*/ bHasAddError = TRUE; +/*N*/ +/*N*/ Insert( pData, Count() ); +/*N*/ } + + + +/*N*/ void ScDetOpList::Load( SvStream& rStream ) +/*N*/ { +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nNewCount; +/*N*/ rStream >> nNewCount; +/*N*/ +/*N*/ ScAddress aPos; +/*N*/ USHORT nOper; +/*N*/ +/*N*/ for (USHORT i=0; i<nNewCount; i++) +/*N*/ { +/*N*/ // 1) Position (ScAddress) +/*N*/ // 2) Operation (USHORT) +/*N*/ +/*N*/ aHdr.StartEntry(); +/*N*/ +/*N*/ rStream >> aPos; +/*N*/ rStream >> nOper; +/*N*/ Append( new ScDetOpData( aPos, (ScDetOpType) nOper ) ); +/*N*/ +/*N*/ aHdr.EndEntry(); +/*N*/ } +/*N*/ } + +/*N*/ void ScDetOpList::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nCount = Count(); +/*N*/ rStream << nCount; +/*N*/ +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ // 1) Position (ScAddress) +/*N*/ // 2) Operation (USHORT) +/*N*/ +/*N*/ aHdr.StartEntry(); +/*N*/ +/*N*/ ScDetOpData* pData = (*this)[i]; +/*N*/ rStream << pData->GetPos(); +/*N*/ rStream << (USHORT) pData->GetOperation(); +/*N*/ +/*N*/ aHdr.EndEntry(); +/*N*/ } +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_detfunc.cxx b/binfilter/bf_sc/source/core/tool/sc_detfunc.cxx new file mode 100644 index 000000000000..1e677adcda46 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_detfunc.cxx @@ -0,0 +1,1695 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include "scitems.hxx" +#include <bf_svtools/colorcfg.hxx> +#include <bf_svx/outlobj.hxx> + +#include <bf_svx/xdef.hxx> + +#include <bf_svx/svditer.hxx> +#include <bf_svx/svdocapt.hxx> +#include <bf_svx/svdocirc.hxx> +#include <bf_svx/svdopath.hxx> +#include <bf_svx/svdpage.hxx> +#include <bf_svx/svdundo.hxx> +#include <bf_svx/xflclit.hxx> +#include <bf_svx/xlnclit.hxx> +#include <bf_svx/xlnedcit.hxx> +#include <bf_svx/xlnedit.hxx> +#include <bf_svx/xlnedwit.hxx> +#include <bf_svx/xlnstcit.hxx> +#include <bf_svx/xlnstit.hxx> +#include <bf_svx/xlnstwit.hxx> +#include <bf_svx/xlnwtit.hxx> + +#include "detfunc.hxx" +#include "document.hxx" +#include "dociter.hxx" +#include "drwlayer.hxx" +#include "userdat.hxx" +#include "validat.hxx" +#include "cell.hxx" +#include "docpool.hxx" +#include "patattr.hxx" +#include "scmod.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ + +// #99319# line ends are now created with an empty name. +// The checkForUniqueItem method then finds a unique name for the item's value. +#define SC_LINEEND_NAME EMPTY_STRING + +//------------------------------------------------------------------------ + +enum DetInsertResult { // Return-Werte beim Einfuegen in einen Level + DET_INS_CONTINUE, + DET_INS_INSERTED, + DET_INS_EMPTY, + DET_INS_CIRCULAR }; + +// maximale Textlaenge (Zeichen), die noch in "kleines" Objekt passt +#define SC_NOTE_SMALLTEXT 100 + +//------------------------------------------------------------------------ + +//-/class ScPublicAttrObj : public SdrAttrObj +//-/{ +//-/private: +//-/ ScPublicAttrObj() {} // wird nicht angelegt +//-/public: +//-/ const XLineAttrSetItem* GetLineAttr() { return pLineAttr; } +//-/}; + +//------------------------------------------------------------------------ + +/*N*/ class ScDetectiveData +/*N*/ { +/*N*/ private: +/*N*/ SfxItemSet aBoxSet; +/*N*/ SfxItemSet aArrowSet; +/*N*/ SfxItemSet aToTabSet; +/*N*/ SfxItemSet aFromTabSet; +/*N*/ SfxItemSet aCircleSet; //! einzeln ? +/*N*/ USHORT nMaxLevel; +/*N*/ +/*N*/ public: +/*N*/ ScDetectiveData( SdrModel* pModel ); +/*N*/ +/*N*/ SfxItemSet& GetBoxSet() { return aBoxSet; } +/*N*/ SfxItemSet& GetArrowSet() { return aArrowSet; } +/*N*/ SfxItemSet& GetToTabSet() { return aToTabSet; } +/*N*/ SfxItemSet& GetFromTabSet() { return aFromTabSet; } +/*N*/ SfxItemSet& GetCircleSet() { return aCircleSet; } +/*N*/ +/*N*/ void SetMaxLevel( USHORT nVal ) { nMaxLevel = nVal; } +/*N*/ USHORT GetMaxLevel() const { return nMaxLevel; } +/*N*/ }; + +/*N*/ class ScCommentData +/*N*/ { +/*N*/ private: +/*N*/ SfxItemSet aCaptionSet; +/*N*/ +/*N*/ public: +/*N*/ ScCommentData( ScDocument* pDoc, SdrModel* pModel ); +/*N*/ +/*N*/ SfxItemSet& GetCaptionSet() { return aCaptionSet; } +/*N*/ }; + +//------------------------------------------------------------------------ + +/*N*/ ColorData ScDetectiveFunc::nArrowColor = 0; +/*N*/ ColorData ScDetectiveFunc::nErrorColor = 0; +/*N*/ ColorData ScDetectiveFunc::nCommentColor = 0; +/*N*/ BOOL ScDetectiveFunc::bColorsInitialized = FALSE; + +//------------------------------------------------------------------------ + +/*N*/ BOOL lcl_HasThickLine( SdrObject& rObj ) // detective.sdc +/*N*/ { +/*N*/ // thin lines get width 0 -> everything greater 0 is a thick line +/*N*/ +/*N*/ return ( ((const XLineWidthItem&)rObj.GetItem(XATTR_LINEWIDTH)).GetValue() > 0 ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScDetectiveData::ScDetectiveData( SdrModel* pModel ) : +/*N*/ aBoxSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ), +/*N*/ aArrowSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ), +/*N*/ aToTabSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ), +/*N*/ aFromTabSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ), +/*N*/ aCircleSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ) +/*N*/ { +/*N*/ nMaxLevel = 0; +/*N*/ +/*N*/ aBoxSet.Put( XLineColorItem( EMPTY_STRING, Color( ScDetectiveFunc::GetArrowColor() ) ) ); +/*N*/ aBoxSet.Put( XFillStyleItem( XFILL_NONE ) ); +/*N*/ +/*N*/ // #66479# Standard-Linienenden (wie aus XLineEndList::Create) selber zusammenbasteln, +/*N*/ // um von den konfigurierten Linienenden unabhaengig zu sein +/*N*/ +/*N*/ XPolygon aTriangle(4); +/*N*/ aTriangle[0].X()=10; aTriangle[0].Y()= 0; +/*N*/ aTriangle[1].X()= 0; aTriangle[1].Y()=30; +/*N*/ aTriangle[2].X()=20; aTriangle[2].Y()=30; +/*N*/ aTriangle[3].X()=10; aTriangle[3].Y()= 0; // #99319# line end polygon must be closed +/*N*/ +/*N*/ XPolygon aSquare(5); +/*N*/ aSquare[0].X()= 0; aSquare[0].Y()= 0; +/*N*/ aSquare[1].X()=10; aSquare[1].Y()= 0; +/*N*/ aSquare[2].X()=10; aSquare[2].Y()=10; +/*N*/ aSquare[3].X()= 0; aSquare[3].Y()=10; +/*N*/ aSquare[4].X()= 0; aSquare[4].Y()= 0; // #99319# line end polygon must be closed +/*N*/ +/*N*/ XPolygon aCircle(Point(0,0),100,100); +/*N*/ +/*N*/ String aName = SC_LINEEND_NAME; +/*N*/ +/*N*/ aArrowSet.Put( XLineStartItem( aName, aCircle ) ); +/*N*/ aArrowSet.Put( XLineStartWidthItem( 200 ) ); +/*N*/ aArrowSet.Put( XLineStartCenterItem( TRUE ) ); +/*N*/ aArrowSet.Put( XLineEndItem( aName, aTriangle ) ); +/*N*/ aArrowSet.Put( XLineEndWidthItem( 200 ) ); +/*N*/ aArrowSet.Put( XLineEndCenterItem( FALSE ) ); +/*N*/ +/*N*/ aToTabSet.Put( XLineStartItem( aName, aCircle ) ); +/*N*/ aToTabSet.Put( XLineStartWidthItem( 200 ) ); +/*N*/ aToTabSet.Put( XLineStartCenterItem( TRUE ) ); +/*N*/ aToTabSet.Put( XLineEndItem( aName, aSquare ) ); +/*N*/ aToTabSet.Put( XLineEndWidthItem( 300 ) ); +/*N*/ aToTabSet.Put( XLineEndCenterItem( FALSE ) ); +/*N*/ +/*N*/ aFromTabSet.Put( XLineStartItem( aName, aSquare ) ); +/*N*/ aFromTabSet.Put( XLineStartWidthItem( 300 ) ); +/*N*/ aFromTabSet.Put( XLineStartCenterItem( TRUE ) ); +/*N*/ aFromTabSet.Put( XLineEndItem( aName, aTriangle ) ); +/*N*/ aFromTabSet.Put( XLineEndWidthItem( 200 ) ); +/*N*/ aFromTabSet.Put( XLineEndCenterItem( FALSE ) ); +/*N*/ +/*N*/ aCircleSet.Put( XLineColorItem( String(), Color( ScDetectiveFunc::GetErrorColor() ) ) ); +/*N*/ aCircleSet.Put( XFillStyleItem( XFILL_NONE ) ); +/*N*/ USHORT nWidth = 55; // 54 = 1 Pixel +/*N*/ aCircleSet.Put( XLineWidthItem( nWidth ) ); +/*N*/ } + +/*N*/ ScCommentData::ScCommentData( ScDocument* pDoc, SdrModel* pModel ) : +/*N*/ aCaptionSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END, +/*N*/ EE_CHAR_START, EE_CHAR_END, 0 ) +/*N*/ { +/*N*/ XPolygon aTriangle(4); +/*N*/ aTriangle[0].X()=10; aTriangle[0].Y()= 0; +/*N*/ aTriangle[1].X()= 0; aTriangle[1].Y()=30; +/*N*/ aTriangle[2].X()=20; aTriangle[2].Y()=30; +/*N*/ aTriangle[3].X()=10; aTriangle[3].Y()= 0; // #99319# line end polygon must be closed +/*N*/ +/*N*/ String aName = SC_LINEEND_NAME; +/*N*/ +/*N*/ aCaptionSet.Put( XLineStartItem( aName, aTriangle ) ); +/*N*/ aCaptionSet.Put( XLineStartWidthItem( 200 ) ); +/*N*/ aCaptionSet.Put( XLineStartCenterItem( FALSE ) ); +/*N*/ aCaptionSet.Put( XFillStyleItem( XFILL_SOLID ) ); +/*N*/ Color aYellow( ScDetectiveFunc::GetCommentColor() ); +/*N*/ aCaptionSet.Put( XFillColorItem( String(), aYellow ) ); +/*N*/ +/*N*/ // shadow +/*N*/ // SdrShadowItem has FALSE, instead the shadow is set for the rectangle +/*N*/ // only with SetSpecialTextBoxShadow when the object is created +/*N*/ // (item must be set to adjust objects from older files) +/*N*/ aCaptionSet.Put( SdrShadowItem( FALSE ) ); +/*N*/ aCaptionSet.Put( SdrShadowXDistItem( 100 ) ); +/*N*/ aCaptionSet.Put( SdrShadowYDistItem( 100 ) ); +/*N*/ +/*N*/ // text attributes +/*N*/ aCaptionSet.Put( SdrTextLeftDistItem( 100 ) ); +/*N*/ aCaptionSet.Put( SdrTextRightDistItem( 100 ) ); +/*N*/ aCaptionSet.Put( SdrTextUpperDistItem( 100 ) ); +/*N*/ aCaptionSet.Put( SdrTextLowerDistItem( 100 ) ); +/*N*/ +/*N*/ // #78943# do use the default cell style, so the user has a chance to +/*N*/ // modify the font for the annotations +/*N*/ ((const ScPatternAttr&)pDoc->GetPool()->GetDefaultItem(ATTR_PATTERN)). +/*N*/ FillEditItemSet( &aCaptionSet ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ inline BOOL Intersect( USHORT nStartCol1, USHORT nStartRow1, USHORT nEndCol1, USHORT nEndRow1, +/*N*/ USHORT nStartCol2, USHORT nStartRow2, USHORT nEndCol2, USHORT nEndRow2 ) +/*N*/ { +/*N*/ return nEndCol1 >= nStartCol2 && nEndCol2 >= nStartCol1 && +/*N*/ nEndRow1 >= nStartRow2 && nEndRow2 >= nStartRow1; +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::HasError( const ScTripel& rStart, const ScTripel& rEnd, ScTripel& rErrPos ) +/*N*/ { +/*N*/ rErrPos = rStart; +/*N*/ USHORT nError = 0; +/*N*/ +/*N*/ ScCellIterator aCellIter( pDoc, rStart.GetCol(), rStart.GetRow(), rStart.GetTab(), +/*N*/ rEnd.GetCol(), rEnd.GetRow(), rEnd.GetTab() ); +/*N*/ ScBaseCell* pCell = aCellIter.GetFirst(); +/*N*/ while (pCell) +/*N*/ { +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ nError = ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ if (nError) +/*N*/ rErrPos.Put( aCellIter.GetCol(), aCellIter.GetRow(), aCellIter.GetTab() ); +/*N*/ } +/*N*/ pCell = aCellIter.GetNext(); +/*N*/ } +/*N*/ +/*N*/ return (nError != 0); +/*N*/ } + +/*N*/ Point ScDetectiveFunc::GetDrawPos( USHORT nCol, USHORT nRow, BOOL bArrow ) +/*N*/ { +/*N*/ // MAXCOL/ROW+1 ist erlaubt fuer Ende von Rahmen +/*N*/ if (nCol > MAXCOL+1) +/*N*/ { +/*N*/ DBG_ERROR("falsche Col in ScDetectiveFunc::GetDrawPos"); +/*N*/ nCol = MAXCOL+1; +/*N*/ } +/*N*/ if (nRow > MAXROW+1) +/*N*/ { +/*N*/ DBG_ERROR("falsche Row in ScDetectiveFunc::GetDrawPos"); +/*N*/ nRow = MAXROW+1; +/*N*/ } +/*N*/ +/*N*/ Point aPos; +/*N*/ USHORT i; +/*N*/ USHORT nLocalTab = nTab; // nicht ueber this +/*N*/ +/*N*/ for (i=0; i<nCol; i++) +/*N*/ aPos.X() += pDoc->GetColWidth( i,nLocalTab ); +/*N*/ for (i=0; i<nRow; i++) +/*N*/ aPos.Y() += pDoc->FastGetRowHeight( i,nLocalTab ); +/*N*/ +/*N*/ if (bArrow) +/*N*/ { +/*N*/ if (nCol<=MAXCOL) +/*N*/ aPos.X() += pDoc->GetColWidth( nCol, nLocalTab ) / 4; +/*N*/ if (nCol<=MAXROW) +/*N*/ aPos.Y() += pDoc->GetRowHeight( nRow, nLocalTab ) / 2; +/*N*/ } +/*N*/ +/*N*/ aPos.X() = (long) ( aPos.X() * HMM_PER_TWIPS ); +/*N*/ aPos.Y() = (long) ( aPos.Y() * HMM_PER_TWIPS ); +/*N*/ +/*N*/ return aPos; +/*N*/ } + +/*N*/ BOOL lcl_IsOtherTab( const XPolygon& rPolygon ) +/*N*/ { +/*N*/ // test if rPolygon is the line end for "other table" (rectangle) +/*N*/ +/*N*/ USHORT nCount = rPolygon.GetPointCount(); +/*N*/ if ( nCount == 4 ) +/*N*/ { +/*N*/ // 4 points -> it is a rectangle (not closed) only if the first and last point are different +/*N*/ +/*N*/ return rPolygon[0] != rPolygon[3]; +/*N*/ } +/*N*/ else if ( nCount == 5 ) +/*N*/ { +/*N*/ // 5 points -> it is a rectangle (closed) only if the first and last point are equal +/*N*/ +/*N*/ return rPolygon[0] == rPolygon[4]; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::HasArrow( USHORT nStartCol, USHORT nStartRow, USHORT nStartTab, +/*N*/ USHORT nEndCol, USHORT nEndRow, USHORT nEndTab ) +/*N*/ { +/*N*/ BOOL bStartAlien = ( nStartTab != nTab ); +/*N*/ BOOL bEndAlien = ( nEndTab != nTab ); +/*N*/ +/*N*/ if (bStartAlien && bEndAlien) +/*N*/ { +/*N*/ DBG_ERROR("bStartAlien && bEndAlien"); +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ Rectangle aStartRect; +/*N*/ Rectangle aEndRect; +/*N*/ if (!bStartAlien) +/*N*/ { +/*N*/ Point aStartPos = GetDrawPos( nStartCol, nStartRow, FALSE ); +/*N*/ Size aStartSize = Size( +/*N*/ (long) ( pDoc->GetColWidth( nStartCol, nTab) * HMM_PER_TWIPS ), +/*N*/ (long) ( pDoc->GetRowHeight( nStartRow, nTab) * HMM_PER_TWIPS ) ); +/*N*/ aStartRect = Rectangle( aStartPos, aStartSize ); +/*N*/ } +/*N*/ if (!bEndAlien) +/*N*/ { +/*N*/ Point aEndPos = GetDrawPos( nEndCol, nEndRow, FALSE ); +/*N*/ Size aEndSize = Size( +/*N*/ (long) ( pDoc->GetColWidth( nEndCol, nTab) * HMM_PER_TWIPS ), +/*N*/ (long) ( pDoc->GetRowHeight( nEndRow, nTab) * HMM_PER_TWIPS ) ); +/*N*/ aEndRect = Rectangle( aEndPos, aEndSize ); +/*N*/ } +/*N*/ +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ BOOL bFound = FALSE; +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject && !bFound) +/*N*/ { +/*N*/ if ( pObject->GetLayer()==SC_LAYER_INTERN && +/*N*/ pObject->IsPolyObj() && pObject->GetPointCount()==2 ) +/*N*/ { +/*N*/ BOOL bObjStartAlien = +/*N*/ lcl_IsOtherTab( ((const XLineStartItem&)pObject->GetItem(XATTR_LINESTART)).GetValue() ); +/*N*/ BOOL bObjEndAlien = +/*N*/ lcl_IsOtherTab( ((const XLineEndItem&)pObject->GetItem(XATTR_LINEEND)).GetValue() ); +/*N*/ +/*N*/ //-/ BOOL bObjStartAlien = FALSE; +/*N*/ //-/ BOOL bObjEndAlien = FALSE; +/*N*/ //-/ const XLineAttrSetItem* pLineAttrs = +/*N*/ //-/ ((ScPublicAttrObj*)(SdrAttrObj*)pObject)->GetLineAttr(); +/*N*/ //-/ if (pLineAttrs) +/*N*/ //-/ { +/*N*/ //-/ const SfxItemSet& rSet = pLineAttrs->GetItemSet(); +/*N*/ //-/ bObjStartAlien = (((const XLineStartItem&)rSet.Get(XATTR_LINESTART)). +/*N*/ //-/ GetValue().GetPointCount() == 4 ); +/*N*/ //-/ bObjEndAlien = (((const XLineEndItem&)rSet.Get(XATTR_LINEEND)). +/*N*/ //-/ GetValue().GetPointCount() == 4 ); +/*N*/ //-/ } +/*N*/ +/*N*/ BOOL bStartHit = bStartAlien ? bObjStartAlien : +/*N*/ ( !bObjStartAlien && aStartRect.IsInside(pObject->GetPoint(0)) ); +/*N*/ BOOL bEndHit = bEndAlien ? bObjEndAlien : +/*N*/ ( !bObjEndAlien && aEndRect.IsInside(pObject->GetPoint(1)) ); +/*N*/ +/*N*/ if ( bStartHit && bEndHit ) +/*N*/ bFound = TRUE; +/*N*/ } +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ return bFound; +/*N*/ } + + +//------------------------------------------------------------------------ + +// InsertXXX: called from DrawEntry/DrawAlienEntry and InsertObject + +/*N*/ BOOL ScDetectiveFunc::InsertArrow( USHORT nCol, USHORT nRow, +/*N*/ USHORT nRefStartCol, USHORT nRefStartRow, +/*N*/ USHORT nRefEndCol, USHORT nRefEndRow, +/*N*/ BOOL bFromOtherTab, BOOL bRed, +/*N*/ ScDetectiveData& rData ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ +/*N*/ BOOL bArea = ( nRefStartCol != nRefEndCol || nRefStartRow != nRefEndRow ); +/*N*/ if (bArea && !bFromOtherTab) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*N*/ } +/*N*/ +/*N*/ Point aStartPos = GetDrawPos( nRefStartCol, nRefStartRow, TRUE ); +/*N*/ Point aEndPos = GetDrawPos( nCol, nRow, TRUE ); +/*N*/ +/*N*/ if (bFromOtherTab) +/*N*/ { +/*N*/ aStartPos = Point( aEndPos.X() - 1000, aEndPos.Y() - 1000 ); +/*N*/ if (aStartPos.X() < 0) +/*N*/ aStartPos.X() += 2000; +/*N*/ if (aStartPos.Y() < 0) +/*N*/ aStartPos.Y() += 2000; +/*N*/ } +/*N*/ +/*N*/ SfxItemSet& rAttrSet = bFromOtherTab ? rData.GetFromTabSet() : rData.GetArrowSet(); +/*N*/ +/*N*/ if (bArea && !bFromOtherTab) +/*N*/ rAttrSet.Put( XLineWidthItem( 50 ) ); // Bereich +/*N*/ else +/*N*/ rAttrSet.Put( XLineWidthItem( 0 ) ); // einzelne Referenz +/*N*/ +/*N*/ ColorData nColorData = ( bRed ? GetErrorColor() : GetArrowColor() ); +/*N*/ rAttrSet.Put( XLineColorItem( String(), Color( nColorData ) ) ); +/*N*/ Point aPointArr[2] = {aStartPos, aEndPos}; +/*N*/ SdrPathObj* pArrow = new SdrPathObj(OBJ_LINE, +/*N*/ XPolyPolygon(XPolygon(Polygon(2, aPointArr)))); +/*N*/ +/*N*/ pArrow->NbcSetLogicRect(Rectangle(aStartPos,aEndPos)); //! noetig ??? +/*N*/ +/*N*/ //-/ pArrow->SetAttributes( rAttrSet, FALSE ); +/*N*/ pArrow->SetItemSetAndBroadcast(rAttrSet); +/*N*/ +/*N*/ ScDrawLayer::SetAnchor( pArrow, SCA_CELL ); +/*N*/ pArrow->SetLayer( SC_LAYER_INTERN ); +/*N*/ pPage->InsertObject( pArrow ); +/*N*/ pModel->AddCalcUndo( new SdrUndoInsertObj( *pArrow ) ); +/*N*/ +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pArrow, TRUE ); +/*N*/ if (bFromOtherTab) +/*N*/ pData->bValidStart = FALSE; +/*N*/ else +/*N*/ { +/*N*/ pData->aStt.nCol = nRefStartCol; +/*N*/ pData->aStt.nRow = nRefStartRow; +/*N*/ pData->aStt.nTab = nTab; +/*N*/ pData->bValidStart = TRUE; +/*N*/ } +/*N*/ +/*N*/ pData->aEnd.nCol = nCol; +/*N*/ pData->aEnd.nRow = nRow; +/*N*/ pData->aEnd.nTab = nTab; +/*N*/ pData->bValidEnd = TRUE; +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::InsertToOtherTab( USHORT nStartCol, USHORT nStartRow, +/*N*/ USHORT nEndCol, USHORT nEndRow, BOOL bRed, +/*N*/ ScDetectiveData& rData ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ +/*N*/ BOOL bArea = ( nStartCol != nEndCol || nStartRow != nEndRow ); +/*N*/ if (bArea) +/*N*/ { +/*N*/ Point aStartCorner = GetDrawPos( nStartCol, nStartRow, FALSE ); +/*N*/ Point aEndCorner = GetDrawPos( nEndCol+1, nEndRow+1, FALSE ); +/*N*/ +/*N*/ SdrRectObj* pBox = new SdrRectObj(Rectangle(aStartCorner,aEndCorner)); +/*N*/ +/*N*/ //-/ pBox->SetAttributes( rData.GetBoxSet(), FALSE ); +/*N*/ pBox->SetItemSetAndBroadcast(rData.GetBoxSet()); +/*N*/ +/*N*/ ScDrawLayer::SetAnchor( pBox, SCA_CELL ); +/*N*/ pBox->SetLayer( SC_LAYER_INTERN ); +/*N*/ pPage->InsertObject( pBox ); +/*N*/ pModel->AddCalcUndo( new SdrUndoInsertObj( *pBox ) ); +/*N*/ +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pBox, TRUE ); +/*N*/ pData->aStt.nCol = nStartCol; +/*N*/ pData->aStt.nRow = nStartRow; +/*N*/ pData->aStt.nTab = nTab; +/*N*/ pData->aEnd.nCol = nEndCol; +/*N*/ pData->aEnd.nRow = nEndRow; +/*N*/ pData->aEnd.nTab = nTab; +/*N*/ pData->bValidStart = TRUE; +/*N*/ pData->bValidEnd = TRUE; +/*N*/ } +/*N*/ +/*N*/ Point aStartPos = GetDrawPos( nStartCol, nStartRow, TRUE ); +/*N*/ Point aEndPos = Point( aStartPos.X() + 1000, aStartPos.Y() - 1000 ); +/*N*/ if (aEndPos.Y() < 0) +/*N*/ aEndPos.Y() += 2000; +/*N*/ +/*N*/ SfxItemSet& rAttrSet = rData.GetToTabSet(); +/*N*/ if (bArea) +/*N*/ rAttrSet.Put( XLineWidthItem( 50 ) ); // Bereich +/*N*/ else +/*N*/ rAttrSet.Put( XLineWidthItem( 0 ) ); // einzelne Referenz +/*N*/ +/*N*/ ColorData nColorData = ( bRed ? GetErrorColor() : GetArrowColor() ); +/*N*/ rAttrSet.Put( XLineColorItem( String(), Color( nColorData ) ) ); +/*N*/ Point aPointArr[2] = {aStartPos, aEndPos}; +/*N*/ SdrPathObj* pArrow = new SdrPathObj(OBJ_LINE, +/*N*/ XPolyPolygon(XPolygon(Polygon(2, aPointArr)))); +/*N*/ +/*N*/ pArrow->NbcSetLogicRect(Rectangle(aStartPos,aEndPos)); //! noetig ??? +/*N*/ +/*N*/ //-/ pArrow->SetAttributes( rAttrSet, FALSE ); +/*N*/ pArrow->SetItemSetAndBroadcast(rAttrSet); +/*N*/ +/*N*/ ScDrawLayer::SetAnchor( pArrow, SCA_CELL ); +/*N*/ pArrow->SetLayer( SC_LAYER_INTERN ); +/*N*/ pPage->InsertObject( pArrow ); +/*N*/ pModel->AddCalcUndo( new SdrUndoInsertObj( *pArrow ) ); +/*N*/ +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pArrow, TRUE ); +/*N*/ pData->aStt.nCol = nStartCol; +/*N*/ pData->aStt.nRow = nStartRow; +/*N*/ pData->aStt.nTab = nTab; +/*N*/ pData->bValidStart = TRUE; +/*N*/ pData->bValidEnd = FALSE; +/*N*/ +/*N*/ return TRUE; +/*N*/ } + +//------------------------------------------------------------------------ + +// DrawEntry: Formel auf dieser Tabelle, +// Referenz auf dieser oder anderer +// DrawAlienEntry: Formel auf anderer Tabelle, +// Referenz auf dieser + +// return FALSE: da war schon ein Pfeil + +/*N*/ BOOL ScDetectiveFunc::DrawEntry( USHORT nCol, USHORT nRow, +/*N*/ const ScTripel& rRefStart, const ScTripel& rRefEnd, +/*N*/ ScDetectiveData& rData ) +/*N*/ { +/*N*/ if ( HasArrow( rRefStart.GetCol(), rRefStart.GetRow(), rRefStart.GetTab(), +/*N*/ nCol, nRow, nTab ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ScTripel aErrorPos; +/*N*/ BOOL bError = HasError( rRefStart, rRefEnd, aErrorPos ); +/*N*/ BOOL bAlien = ( rRefEnd.GetTab() < nTab || rRefStart.GetTab() > nTab ); +/*N*/ +/*N*/ return InsertArrow( nCol, nRow, +/*N*/ rRefStart.GetCol(), rRefStart.GetRow(), +/*N*/ rRefEnd.GetCol(), rRefEnd.GetRow(), +/*N*/ bAlien, bError, rData ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::DrawAlienEntry( const ScTripel& rRefStart, const ScTripel& rRefEnd, +/*N*/ ScDetectiveData& rData ) +/*N*/ { +/*N*/ if ( HasArrow( rRefStart.GetCol(), rRefStart.GetRow(), rRefStart.GetTab(), +/*N*/ 0, 0, nTab+1 ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ScTripel aErrorPos; +/*N*/ BOOL bError = HasError( rRefStart, rRefEnd, aErrorPos ); +/*N*/ +/*N*/ return InsertToOtherTab( rRefStart.GetCol(), rRefStart.GetRow(), +/*N*/ rRefEnd.GetCol(), rRefEnd.GetRow(), +/*N*/ bError, rData ); +/*N*/ } + +/*N*/ void ScDetectiveFunc::DrawCircle( USHORT nCol, USHORT nRow, ScDetectiveData& rData ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ +/*N*/ Point aStartPos = GetDrawPos( nCol, nRow, FALSE ); +/*N*/ Size aSize( (long) ( pDoc->GetColWidth(nCol, nTab) * HMM_PER_TWIPS ), +/*N*/ (long) ( pDoc->GetRowHeight(nRow, nTab) * HMM_PER_TWIPS ) ); +/*N*/ Rectangle aRect( aStartPos, aSize ); +/*N*/ aRect.Left() -= 250; +/*N*/ aRect.Right() += 250; +/*N*/ aRect.Top() -= 70; +/*N*/ aRect.Bottom() += 70; +/*N*/ +/*N*/ SdrCircObj* pCircle = new SdrCircObj( OBJ_CIRC, aRect ); +/*N*/ SfxItemSet& rAttrSet = rData.GetCircleSet(); +/*N*/ +/*N*/ //-/ pCircle->SetAttributes( rAttrSet, FALSE ); +/*N*/ pCircle->SetItemSetAndBroadcast(rAttrSet); +/*N*/ +/*N*/ ScDrawLayer::SetAnchor( pCircle, SCA_CELL ); +/*N*/ pCircle->SetLayer( SC_LAYER_INTERN ); +/*N*/ pPage->InsertObject( pCircle ); +/*N*/ pModel->AddCalcUndo( new SdrUndoInsertObj( *pCircle ) ); +/*N*/ +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pCircle, TRUE ); +/*N*/ pData->aStt.nCol = nCol; +/*N*/ pData->aStt.nRow = nRow; +/*N*/ pData->aStt.nTab = nTab; +/*N*/ pData->bValidStart = TRUE; +/*N*/ pData->bValidEnd = FALSE; +/*N*/ } + + +/*N*/ void ScDetectiveFunc::DeleteArrowsAt( USHORT nCol, USHORT nRow, BOOL bDestPnt ) +/*N*/ { +/*N*/ Point aPos = GetDrawPos( nCol, nRow, FALSE ); +/*N*/ Size aSize = Size( (long) ( pDoc->GetColWidth( nCol, nTab) * HMM_PER_TWIPS ), +/*N*/ (long) ( pDoc->GetRowHeight( nRow, nTab) * HMM_PER_TWIPS ) ); +/*N*/ Rectangle aRect( aPos, aSize ); +/*N*/ +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ pPage->RecalcObjOrdNums(); +/*N*/ +/*N*/ long nDelCount = 0; +/*N*/ ULONG nObjCount = pPage->GetObjCount(); +/*N*/ if (nObjCount) +/*N*/ { +/*N*/ SdrObject** ppObj = new SdrObject*[nObjCount]; +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetLayer()==SC_LAYER_INTERN && +/*N*/ pObject->IsPolyObj() && pObject->GetPointCount()==2 ) +/*N*/ { +/*N*/ if (aRect.IsInside(pObject->GetPoint(bDestPnt))) // Start/Zielpunkt +/*N*/ ppObj[nDelCount++] = pObject; +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ long i; +/*N*/ for (i=1; i<=nDelCount; i++) +/*N*/ pModel->AddCalcUndo( new SdrUndoRemoveObj( *ppObj[nDelCount-i] ) ); +/*N*/ +/*N*/ for (i=1; i<=nDelCount; i++) +/*N*/ pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() ); +/*N*/ +/*N*/ delete[] ppObj; +/*N*/ } +/*N*/ } + + // Box um Referenz loeschen + +#define SC_DET_TOLERANCE 50 + +/*N*/ inline BOOL RectIsPoints( const Rectangle& rRect, const Point& rStart, const Point& rEnd ) +/*N*/ { +/*N*/ return rRect.Left() >= rStart.X() - SC_DET_TOLERANCE +/*N*/ && rRect.Left() <= rStart.X() + SC_DET_TOLERANCE +/*N*/ && rRect.Right() >= rEnd.X() - SC_DET_TOLERANCE +/*N*/ && rRect.Right() <= rEnd.X() + SC_DET_TOLERANCE +/*N*/ && rRect.Top() >= rStart.Y() - SC_DET_TOLERANCE +/*N*/ && rRect.Top() <= rStart.Y() + SC_DET_TOLERANCE +/*N*/ && rRect.Bottom() >= rEnd.Y() - SC_DET_TOLERANCE +/*N*/ && rRect.Bottom() <= rEnd.Y() + SC_DET_TOLERANCE; +/*N*/ } + +#undef SC_DET_TOLERANCE + +/*N*/ void ScDetectiveFunc::DeleteBox( USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2 ) +/*N*/ { +/* String aStr; + aStr += nCol1; + aStr += '/'; + aStr += nRow1; + aStr += '/'; + aStr += nCol2; + aStr += '/'; + aStr += nRow2; + InfoBox(0,aStr).Execute(); +*/ +/*N*/ +/*N*/ Point aStartCorner = GetDrawPos( nCol1, nRow1, FALSE ); +/*N*/ Point aEndCorner = GetDrawPos( nCol2+1, nRow2+1, FALSE ); +/*N*/ Rectangle aObjRect; +/*N*/ +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ pPage->RecalcObjOrdNums(); +/*N*/ +/*N*/ long nDelCount = 0; +/*N*/ ULONG nObjCount = pPage->GetObjCount(); +/*N*/ if (nObjCount) +/*N*/ { +/*N*/ SdrObject** ppObj = new SdrObject*[nObjCount]; +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN && +/*N*/ pObject->Type() == TYPE(SdrRectObj) ) +/*N*/ { +/*N*/ aObjRect = ((SdrRectObj*)pObject)->GetLogicRect(); +/*N*/ if ( RectIsPoints( aObjRect, aStartCorner, aEndCorner ) ) +/*N*/ ppObj[nDelCount++] = pObject; +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ long i; +/*N*/ for (i=1; i<=nDelCount; i++) +/*N*/ pModel->AddCalcUndo( new SdrUndoRemoveObj( *ppObj[nDelCount-i] ) ); +/*N*/ +/*N*/ for (i=1; i<=nDelCount; i++) +/*N*/ pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() ); +/*N*/ +/*N*/ delete[] ppObj; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ USHORT ScDetectiveFunc::InsertPredLevelArea( const ScTripel& rRefStart, const ScTripel& rRefEnd, +/*N*/ ScDetectiveData& rData, USHORT nLevel ) +/*N*/ { +/*N*/ USHORT nResult = DET_INS_EMPTY; +/*N*/ +/*N*/ ScCellIterator aCellIter( pDoc, rRefStart.GetCol(), rRefStart.GetRow(), rRefStart.GetTab(), +/*N*/ rRefEnd.GetCol(), rRefEnd.GetRow(), rRefEnd.GetTab() ); +/*N*/ ScBaseCell* pCell = aCellIter.GetFirst(); +/*N*/ while (pCell) +/*N*/ { +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ switch( InsertPredLevel( aCellIter.GetCol(), aCellIter.GetRow(), rData, nLevel ) ) +/*N*/ { +/*N*/ case DET_INS_INSERTED: +/*N*/ nResult = DET_INS_INSERTED; +/*N*/ break; +/*N*/ case DET_INS_CONTINUE: +/*N*/ if (nResult != DET_INS_INSERTED) +/*N*/ nResult = DET_INS_CONTINUE; +/*N*/ break; +/*N*/ case DET_INS_CIRCULAR: +/*N*/ if (nResult == DET_INS_EMPTY) +/*N*/ nResult = DET_INS_CIRCULAR; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ pCell = aCellIter.GetNext(); +/*N*/ } +/*N*/ +/*N*/ return nResult; +/*N*/ } + +/*N*/ USHORT ScDetectiveFunc::InsertPredLevel( USHORT nCol, USHORT nRow, ScDetectiveData& rData, +/*N*/ USHORT nLevel ) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ pDoc->GetCell( nCol, nRow, nTab, pCell ); +/*N*/ if (!pCell) +/*N*/ return DET_INS_EMPTY; +/*N*/ if (pCell->GetCellType() != CELLTYPE_FORMULA) +/*N*/ return DET_INS_EMPTY; +/*N*/ +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ if (pFCell->IsRunning()) +/*N*/ return DET_INS_CIRCULAR; +/*N*/ +/*N*/ if (pFCell->GetDirty()) +/*N*/ pFCell->Interpret(); // nach SetRunning geht's nicht mehr! +/*N*/ pFCell->SetRunning(TRUE); +/*N*/ +/*N*/ USHORT nResult = DET_INS_EMPTY; +/*N*/ +/*N*/ ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); +/*N*/ ScTripel aRefStart; +/*N*/ ScTripel aRefEnd; +/*N*/ while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) +/*N*/ { +/*N*/ if (DrawEntry( nCol, nRow, aRefStart, aRefEnd, rData )) +/*N*/ { +/*N*/ nResult = DET_INS_INSERTED; // neuer Pfeil eingetragen +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // weiterverfolgen +/*N*/ +/*N*/ if ( nLevel < rData.GetMaxLevel() ) +/*N*/ { +/*N*/ USHORT nSubResult; +/*N*/ BOOL bArea = (aRefStart != aRefEnd); +/*N*/ if (bArea) +/*N*/ nSubResult = InsertPredLevelArea( aRefStart, aRefEnd, rData, nLevel+1 ); +/*N*/ else +/*N*/ nSubResult = InsertPredLevel( aRefStart.GetCol(), aRefStart.GetRow(), +/*N*/ rData, nLevel+1 ); +/*N*/ +/*N*/ switch (nSubResult) +/*N*/ { +/*N*/ case DET_INS_INSERTED: +/*N*/ nResult = DET_INS_INSERTED; +/*N*/ break; +/*N*/ case DET_INS_CONTINUE: +/*N*/ if (nResult != DET_INS_INSERTED) +/*N*/ nResult = DET_INS_CONTINUE; +/*N*/ break; +/*N*/ case DET_INS_CIRCULAR: +/*N*/ if (nResult == DET_INS_EMPTY) +/*N*/ nResult = DET_INS_CIRCULAR; +/*N*/ break; +/*N*/ // DET_INS_EMPTY: unveraendert lassen +/*N*/ } +/*N*/ } +/*N*/ else // nMaxLevel erreicht +/*N*/ if (nResult != DET_INS_INSERTED) +/*N*/ nResult = DET_INS_CONTINUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pFCell->SetRunning(FALSE); +/*N*/ +/*N*/ return nResult; +/*N*/ } + +/*N*/ USHORT ScDetectiveFunc::FindPredLevelArea( const ScTripel& rRefStart, const ScTripel& rRefEnd, +/*N*/ USHORT nLevel, USHORT nDeleteLevel ) +/*N*/ { +/*N*/ USHORT nResult = nLevel; +/*N*/ +/*N*/ ScCellIterator aCellIter( pDoc, rRefStart.GetCol(), rRefStart.GetRow(), rRefStart.GetTab(), +/*N*/ rRefEnd.GetCol(), rRefEnd.GetRow(), rRefEnd.GetTab() ); +/*N*/ ScBaseCell* pCell = aCellIter.GetFirst(); +/*N*/ while (pCell) +/*N*/ { +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ USHORT nTemp = FindPredLevel( aCellIter.GetCol(), aCellIter.GetRow(), nLevel, nDeleteLevel ); +/*N*/ if (nTemp > nResult) +/*N*/ nResult = nTemp; +/*N*/ } +/*N*/ pCell = aCellIter.GetNext(); +/*N*/ } +/*N*/ +/*N*/ return nResult; +/*N*/ } + + // nDeleteLevel != 0 -> loeschen + +/*N*/ USHORT ScDetectiveFunc::FindPredLevel( USHORT nCol, USHORT nRow, USHORT nLevel, USHORT nDeleteLevel ) +/*N*/ { +/*N*/ DBG_ASSERT( nLevel<1000, "Level" ); +/*N*/ +/*N*/ ScBaseCell* pCell; +/*N*/ pDoc->GetCell( nCol, nRow, nTab, pCell ); +/*N*/ if (!pCell) +/*N*/ return nLevel; +/*N*/ if (pCell->GetCellType() != CELLTYPE_FORMULA) +/*N*/ return nLevel; +/*N*/ +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ if (pFCell->IsRunning()) +/*N*/ return nLevel; +/*N*/ +/*N*/ if (pFCell->GetDirty()) +/*N*/ pFCell->Interpret(); // nach SetRunning geht's nicht mehr! +/*N*/ pFCell->SetRunning(TRUE); +/*N*/ +/*N*/ USHORT nResult = nLevel; +/*N*/ BOOL bDelete = ( nDeleteLevel && nLevel == nDeleteLevel-1 ); +/*N*/ +/*N*/ if ( bDelete ) +/*N*/ { +/*N*/ DeleteArrowsAt( nCol, nRow, TRUE ); // Pfeile, die hierher zeigen +/*N*/ } +/*N*/ +/*N*/ ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); +/*N*/ ScTripel aRefStart; +/*N*/ ScTripel aRefEnd; +/*N*/ while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) +/*N*/ { +/*N*/ BOOL bArea = ( aRefStart != aRefEnd ); +/*N*/ +/*N*/ if ( bDelete ) // Rahmen loeschen ? +/*N*/ { +/*N*/ if (bArea) +/*N*/ { +/*N*/ DeleteBox( aRefStart.GetCol(), aRefStart.GetRow(), aRefEnd.GetCol(), aRefEnd.GetRow() ); +/*N*/ } +/*N*/ } +/*N*/ else // weitersuchen +/*N*/ { +/*N*/ if ( HasArrow( aRefStart.GetCol(),aRefStart.GetRow(),aRefStart.GetTab(), +/*N*/ nCol,nRow,nTab ) ) +/*N*/ { +/*N*/ USHORT nTemp; +/*N*/ if (bArea) +/*N*/ nTemp = FindPredLevelArea( aRefStart, aRefEnd, nLevel+1, nDeleteLevel ); +/*N*/ else +/*N*/ nTemp = FindPredLevel( aRefStart.GetCol(),aRefStart.GetRow(), +/*N*/ nLevel+1, nDeleteLevel ); +/*N*/ if (nTemp > nResult) +/*N*/ nResult = nTemp; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pFCell->SetRunning(FALSE); +/*N*/ +/*N*/ return nResult; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ USHORT ScDetectiveFunc::InsertErrorLevel( USHORT nCol, USHORT nRow, ScDetectiveData& rData, +/*N*/ USHORT nLevel ) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ pDoc->GetCell( nCol, nRow, nTab, pCell ); +/*N*/ if (!pCell) +/*N*/ return DET_INS_EMPTY; +/*N*/ if (pCell->GetCellType() != CELLTYPE_FORMULA) +/*N*/ return DET_INS_EMPTY; +/*N*/ +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ if (pFCell->IsRunning()) +/*N*/ return DET_INS_CIRCULAR; +/*N*/ +/*N*/ if (pFCell->GetDirty()) +/*N*/ pFCell->Interpret(); // nach SetRunning geht's nicht mehr! +/*N*/ pFCell->SetRunning(TRUE); +/*N*/ +/*N*/ USHORT nResult = DET_INS_EMPTY; +/*N*/ +/*N*/ ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); +/*N*/ ScTripel aRefStart; +/*N*/ ScTripel aRefEnd; +/*N*/ ScTripel aErrorPos; +/*N*/ BOOL bHasError = FALSE; +/*N*/ while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) +/*N*/ { +/*N*/ if (HasError( aRefStart, aRefEnd, aErrorPos )) +/*N*/ { +/*N*/ bHasError = TRUE; +/*N*/ if (DrawEntry( nCol, nRow, aErrorPos, aErrorPos, rData )) +/*N*/ nResult = DET_INS_INSERTED; +/*N*/ +/*N*/ // und weiterverfolgen +/*N*/ +/*N*/ if ( nLevel < rData.GetMaxLevel() ) // praktisch immer +/*N*/ { +/*N*/ if (InsertErrorLevel( aErrorPos.GetCol(), aErrorPos.GetRow(), +/*N*/ rData, nLevel+1 ) == DET_INS_INSERTED) +/*N*/ nResult = DET_INS_INSERTED; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pFCell->SetRunning(FALSE); +/*N*/ +/*N*/ // Blaetter ? +/*N*/ if (!bHasError) +/*N*/ if (InsertPredLevel( nCol, nRow, rData, rData.GetMaxLevel() ) == DET_INS_INSERTED) +/*N*/ nResult = DET_INS_INSERTED; +/*N*/ +/*N*/ return nResult; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ USHORT ScDetectiveFunc::InsertSuccLevel( USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, +/*N*/ ScDetectiveData& rData, USHORT nLevel ) +/*N*/ { +/*N*/ // ueber ganzes Dokument +/*N*/ +/*N*/ USHORT nResult = DET_INS_EMPTY; +/*N*/ // ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab ); +/*N*/ ScCellIterator aCellIter( pDoc, 0,0,0, MAXCOL,MAXROW,MAXTAB ); // alle Tabellen +/*N*/ ScBaseCell* pCell = aCellIter.GetFirst(); +/*N*/ while (pCell) +/*N*/ { +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ BOOL bRunning = pFCell->IsRunning(); +/*N*/ +/*N*/ if (pFCell->GetDirty()) +/*N*/ pFCell->Interpret(); // nach SetRunning geht's nicht mehr! +/*N*/ pFCell->SetRunning(TRUE); +/*N*/ +/*N*/ ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); +/*N*/ ScTripel aRefStart; +/*N*/ ScTripel aRefEnd; +/*N*/ while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) +/*N*/ { +/*N*/ if (aRefStart.GetTab() <= nTab && aRefEnd.GetTab() >= nTab) +/*N*/ { +/*N*/ if (Intersect( nCol1,nRow1,nCol2,nRow2, +/*N*/ aRefStart.GetCol(),aRefStart.GetRow(), +/*N*/ aRefEnd.GetCol(),aRefEnd.GetRow() )) +/*N*/ { +/*N*/ BOOL bAlien = ( aCellIter.GetTab() != nTab ); +/*N*/ BOOL bDrawRet; +/*N*/ if (bAlien) +/*N*/ bDrawRet = DrawAlienEntry( aRefStart, aRefEnd, rData ); +/*N*/ else +/*N*/ bDrawRet = DrawEntry( aCellIter.GetCol(), aCellIter.GetRow(), +/*N*/ aRefStart, aRefEnd, rData ); +/*N*/ if (bDrawRet) +/*N*/ { +/*N*/ nResult = DET_INS_INSERTED; // neuer Pfeil eingetragen +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (bRunning) +/*N*/ { +/*N*/ if (nResult == DET_INS_EMPTY) +/*N*/ nResult = DET_INS_CIRCULAR; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // weiterverfolgen +/*N*/ +/*N*/ if ( nLevel < rData.GetMaxLevel() ) +/*N*/ { +/*N*/ USHORT nSubResult = InsertSuccLevel( +/*N*/ aCellIter.GetCol(), aCellIter.GetRow(), +/*N*/ aCellIter.GetCol(), aCellIter.GetRow(), +/*N*/ rData, nLevel+1 ); +/*N*/ switch (nSubResult) +/*N*/ { +/*N*/ case DET_INS_INSERTED: +/*N*/ nResult = DET_INS_INSERTED; +/*N*/ break; +/*N*/ case DET_INS_CONTINUE: +/*N*/ if (nResult != DET_INS_INSERTED) +/*N*/ nResult = DET_INS_CONTINUE; +/*N*/ break; +/*N*/ case DET_INS_CIRCULAR: +/*N*/ if (nResult == DET_INS_EMPTY) +/*N*/ nResult = DET_INS_CIRCULAR; +/*N*/ break; +/*N*/ // DET_INS_EMPTY: unveraendert lassen +/*N*/ } +/*N*/ } +/*N*/ else // nMaxLevel erreicht +/*N*/ if (nResult != DET_INS_INSERTED) +/*N*/ nResult = DET_INS_CONTINUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ pFCell->SetRunning(bRunning); +/*N*/ } +/*N*/ pCell = aCellIter.GetNext(); +/*N*/ } +/*N*/ +/*N*/ return nResult; +/*N*/ } + +/*N*/ USHORT ScDetectiveFunc::FindSuccLevel( USHORT nCol1, USHORT nRow1, USHORT nCol2, USHORT nRow2, +/*N*/ USHORT nLevel, USHORT nDeleteLevel ) +/*N*/ { +/*N*/ DBG_ASSERT( nLevel<1000, "Level" ); +/*N*/ +/*N*/ USHORT nResult = nLevel; +/*N*/ BOOL bDelete = ( nDeleteLevel && nLevel == nDeleteLevel-1 ); +/*N*/ +/*N*/ ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab ); +/*N*/ ScBaseCell* pCell = aCellIter.GetFirst(); +/*N*/ while (pCell) +/*N*/ { +/*N*/ if (pCell->GetCellType() == CELLTYPE_FORMULA) +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*)pCell; +/*N*/ BOOL bRunning = pFCell->IsRunning(); +/*N*/ +/*N*/ if (pFCell->GetDirty()) +/*N*/ pFCell->Interpret(); // nach SetRunning geht's nicht mehr! +/*N*/ pFCell->SetRunning(TRUE); +/*N*/ +/*N*/ ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); +/*N*/ ScTripel aRefStart; +/*N*/ ScTripel aRefEnd; +/*N*/ while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) +/*N*/ { +/*N*/ if (aRefStart.GetTab() <= nTab && aRefEnd.GetTab() >= nTab) +/*N*/ { +/*N*/ if (Intersect( nCol1,nRow1,nCol2,nRow2, +/*N*/ aRefStart.GetCol(),aRefStart.GetRow(), +/*N*/ aRefEnd.GetCol(),aRefEnd.GetRow() )) +/*N*/ { +/*N*/ if ( bDelete ) // Pfeile, die hier anfangen +/*N*/ { +/*N*/ if (aRefStart != aRefEnd) +/*N*/ { +/*N*/ DeleteBox( aRefStart.GetCol(), aRefStart.GetRow(), +/*N*/ aRefEnd.GetCol(), aRefEnd.GetRow() ); +/*N*/ } +/*N*/ DeleteArrowsAt( aRefStart.GetCol(), aRefStart.GetRow(), FALSE ); +/*N*/ } +/*N*/ else if ( !bRunning && +/*N*/ HasArrow( aRefStart.GetCol(),aRefStart.GetRow(),aRefStart.GetTab(), +/*N*/ aCellIter.GetCol(),aCellIter.GetRow(),aCellIter.GetTab() ) ) +/*N*/ { +/*N*/ USHORT nTemp = FindSuccLevel( aCellIter.GetCol(), aCellIter.GetRow(), +/*N*/ aCellIter.GetCol(), aCellIter.GetRow(), +/*N*/ nLevel+1, nDeleteLevel ); +/*N*/ if (nTemp > nResult) +/*N*/ nResult = nTemp; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pFCell->SetRunning(bRunning); +/*N*/ } +/*N*/ pCell = aCellIter.GetNext(); +/*N*/ } +/*N*/ +/*N*/ return nResult; +/*N*/ } + + +// +// -------------------------------------------------------------------------------- +// + +/*N*/ BOOL ScDetectiveFunc::ShowPred( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ ScDetectiveData aData( pModel ); +/*N*/ +/*N*/ USHORT nMaxLevel = 0; +/*N*/ USHORT nResult = DET_INS_CONTINUE; +/*N*/ while (nResult == DET_INS_CONTINUE && nMaxLevel < 1000) +/*N*/ { +/*N*/ aData.SetMaxLevel( nMaxLevel ); +/*N*/ nResult = InsertPredLevel( nCol, nRow, aData, 0 ); +/*N*/ ++nMaxLevel; +/*N*/ } +/*N*/ +/*N*/ return ( nResult == DET_INS_INSERTED ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::ShowSucc( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ ScDetectiveData aData( pModel ); +/*N*/ +/*N*/ USHORT nMaxLevel = 0; +/*N*/ USHORT nResult = DET_INS_CONTINUE; +/*N*/ while (nResult == DET_INS_CONTINUE && nMaxLevel < 1000) +/*N*/ { +/*N*/ aData.SetMaxLevel( nMaxLevel ); +/*N*/ nResult = InsertSuccLevel( nCol, nRow, nCol, nRow, aData, 0 ); +/*N*/ ++nMaxLevel; +/*N*/ } +/*N*/ +/*N*/ return ( nResult == DET_INS_INSERTED ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::ShowError( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ ScTripel aPos( nCol, nRow, nTab ); +/*N*/ ScTripel aErrPos; +/*N*/ if ( !HasError( aPos,aPos,aErrPos ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ScDetectiveData aData( pModel ); +/*N*/ +/*N*/ aData.SetMaxLevel( 1000 ); +/*N*/ USHORT nResult = InsertErrorLevel( nCol, nRow, aData, 0 ); +/*N*/ +/*N*/ return ( nResult == DET_INS_INSERTED ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::DeleteSucc( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ USHORT nLevelCount = FindSuccLevel( nCol, nRow, nCol, nRow, 0, 0 ); +/*N*/ if ( nLevelCount ) +/*N*/ FindSuccLevel( nCol, nRow, nCol, nRow, 0, nLevelCount ); // loeschen +/*N*/ +/*N*/ return ( nLevelCount != 0 ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::DeletePred( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ USHORT nLevelCount = FindPredLevel( nCol, nRow, 0, 0 ); +/*N*/ if ( nLevelCount ) +/*N*/ FindPredLevel( nCol, nRow, 0, nLevelCount ); // loeschen +/*N*/ +/*N*/ return ( nLevelCount != 0 ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::DeleteAll( ScDetectiveDelete eWhat ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ pPage->RecalcObjOrdNums(); +/*N*/ +/*N*/ long nDelCount = 0; +/*N*/ ULONG nObjCount = pPage->GetObjCount(); +/*N*/ if (nObjCount) +/*N*/ { +/*N*/ SdrObject** ppObj = new SdrObject*[nObjCount]; +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN ) +/*N*/ { +/*N*/ BOOL bDoThis = TRUE; +/*N*/ if ( eWhat != SC_DET_ALL ) +/*N*/ { +/*N*/ BOOL bCircle = ( pObject->ISA(SdrCircObj) ); +/*N*/ BOOL bCaption = ( pObject->ISA(SdrCaptionObj) ); +/*N*/ if ( eWhat == SC_DET_DETECTIVE ) // Detektiv, aus Menue +/*N*/ bDoThis = !bCaption; // auch Kreise +/*N*/ else if ( eWhat == SC_DET_CIRCLES ) // Kreise, wenn neue erzeugt werden +/*N*/ bDoThis = bCircle; +/*N*/ else if ( eWhat == SC_DET_COMMENTS ) +/*N*/ bDoThis = bCaption; +/*N*/ else if ( eWhat == SC_DET_ARROWS ) // DetectiveRefresh +/*N*/ bDoThis = !bCaption && !bCircle; // don't include circles +/*N*/ else +/*N*/ DBG_ERROR("wat?"); +/*N*/ } +/*N*/ if ( bDoThis ) +/*N*/ ppObj[nDelCount++] = pObject; +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ long i; +/*N*/ for (i=1; i<=nDelCount; i++) +/*N*/ pModel->AddCalcUndo( new SdrUndoRemoveObj( *ppObj[nDelCount-i] ) ); +/*N*/ +/*N*/ for (i=1; i<=nDelCount; i++) +/*N*/ pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() ); +/*N*/ +/*N*/ delete[] ppObj; +/*N*/ } +/*N*/ +/*N*/ return ( nDelCount != 0 ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::MarkInvalid(BOOL& rOverflow) +/*N*/ { +/*N*/ rOverflow = FALSE; +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ +/*N*/ BOOL bDeleted = DeleteAll( SC_DET_CIRCLES ); // nur die Kreise +/*N*/ +/*N*/ ScDetectiveData aData( pModel ); +/*N*/ long nInsCount = 0; +/*N*/ +/*N*/ // Stellen suchen, wo Gueltigkeit definiert ist +/*N*/ +/*N*/ ScDocAttrIterator aAttrIter( pDoc, nTab, 0,0,MAXCOL,MAXROW ); +/*N*/ USHORT nCol, nRow1, nRow2; +/*N*/ const ScPatternAttr* pPattern = aAttrIter.GetNext( nCol, nRow1, nRow2 ); +/*N*/ while ( pPattern && nInsCount < SC_DET_MAXCIRCLE ) +/*N*/ { +/*N*/ ULONG nIndex = ((const SfxUInt32Item&)pPattern->GetItem(ATTR_VALIDDATA)).GetValue(); +/*N*/ if (nIndex) +/*N*/ { +/*N*/ const ScValidationData* pData = pDoc->GetValidationEntry( nIndex ); +/*N*/ if ( pData ) +/*N*/ { +/*N*/ // Zellen in dem Bereich durchgehen +/*N*/ +/*N*/ BOOL bMarkEmpty = !pData->IsIgnoreBlank(); +/*N*/ USHORT nNextRow = nRow1; +/*N*/ USHORT nRow; +/*N*/ ScCellIterator aCellIter( pDoc, nCol,nRow1,nTab, nCol,nRow2,nTab ); +/*N*/ ScBaseCell* pCell = aCellIter.GetFirst(); +/*N*/ while ( pCell && nInsCount < SC_DET_MAXCIRCLE ) +/*N*/ { +/*N*/ USHORT nCellRow = aCellIter.GetRow(); +/*N*/ if ( bMarkEmpty ) +/*N*/ for ( nRow = nNextRow; nRow < nCellRow && nInsCount < SC_DET_MAXCIRCLE; nRow++ ) +/*N*/ { +/*N*/ DrawCircle( nCol, nRow, aData ); +/*N*/ ++nInsCount; +/*N*/ } +/*N*/ if ( !pData->IsDataValid( pCell, ScAddress( nCol, nCellRow, nTab ) ) ) +/*N*/ { +/*N*/ DrawCircle( nCol, nCellRow, aData ); +/*N*/ ++nInsCount; +/*N*/ } +/*N*/ nNextRow = nCellRow + 1; +/*N*/ pCell = aCellIter.GetNext(); +/*N*/ } +/*N*/ if ( bMarkEmpty ) +/*N*/ for ( nRow = nNextRow; nRow <= nRow2 && nInsCount < SC_DET_MAXCIRCLE; nRow++ ) +/*N*/ { +/*N*/ DrawCircle( nCol, nRow, aData ); +/*N*/ ++nInsCount; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pPattern = aAttrIter.GetNext( nCol, nRow1, nRow2 ); +/*N*/ } +/*N*/ +/*N*/ if ( nInsCount >= SC_DET_MAXCIRCLE ) +/*N*/ rOverflow = TRUE; +/*N*/ +/*N*/ return ( bDeleted || nInsCount != 0 ); +/*N*/ } + +/*N*/ SdrObject* ScDetectiveFunc::ShowCommentUser( USHORT nCol, USHORT nRow, const String& rUserText, +/*N*/ const Rectangle& rVisible, BOOL bLeft, BOOL bForce, +/*N*/ SdrPage* pDestPage ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel && !pDestPage) +/*N*/ return NULL; +/*N*/ +/*N*/ SdrObject* pObject = NULL; +/*N*/ ScPostIt aNote; +/*N*/ BOOL bFound = pDoc->GetNote( nCol, nRow, nTab, aNote ); +/*N*/ if ( bFound || bForce || rUserText.Len() ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 SdrModel* pDestModel = pModel; +/*N*/ } +/*N*/ +/*N*/ return pObject; +/*N*/ } + +/*N*/ SdrObject* ScDetectiveFunc::ShowComment( USHORT nCol, USHORT nRow, BOOL bForce, SdrPage* pDestPage ) +/*N*/ { +/*N*/ return ShowCommentUser( nCol, nRow, String(), Rectangle(0,0,0,0), FALSE, bForce, pDestPage ); +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::HideComment( USHORT nCol, USHORT nRow ) +/*N*/ { +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return FALSE; +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ +/*N*/ pPage->RecalcObjOrdNums(); +/*N*/ BOOL bDone = FALSE; +/*N*/ +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject && !bDone) +/*N*/ { +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN && pObject->ISA( SdrCaptionObj ) ) +/*N*/ { +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject ); +/*N*/ if ( pData && nCol == pData->aStt.nCol && nRow == pData->aStt.nRow ) +/*N*/ { +/*N*/ pModel->AddCalcUndo( new SdrUndoRemoveObj( *pObject ) ); +/*N*/ pPage->RemoveObject( pObject->GetOrdNum() ); +/*N*/ bDone = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ +/*N*/ return bDone; +/*N*/ } + +/*N*/ void ScDetectiveFunc::UpdateAllComments() +/*N*/ { +/*N*/ // for all caption objects, update attributes and SpecialTextBoxShadow flag +/*N*/ // (on all tables - nTab is ignored!) +/*N*/ +/*N*/ // no undo actions, this is refreshed after undo +/*N*/ +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return; +/*N*/ +/*N*/ ScCommentData aData( pDoc, pModel ); +/*N*/ +/*N*/ USHORT nTabCount = pDoc->GetTableCount(); +/*N*/ for (USHORT nObjTab=0; nObjTab<nTabCount; nObjTab++) +/*N*/ { +/*N*/ SdrPage* pPage = pModel->GetPage(nObjTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (pPage) +/*N*/ { +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*?*/ if ( pObject->GetLayer() == SC_LAYER_INTERN && pObject->ISA( SdrCaptionObj ) ) +/*?*/ { +/*?*/ SdrCaptionObj* pCaption = (SdrCaptionObj*)pObject; +/*?*/ +/*?*/ SfxItemSet& rAttrSet = aData.GetCaptionSet(); +/*?*/ +/*?*/ //-/ pCaption->SetAttributes( rAttrSet, FALSE ); +/*?*/ pCaption->SetItemSetAndBroadcast(rAttrSet); +/*?*/ +/*?*/ pCaption->SetSpecialTextBoxShadow(); +/*?*/ } +/*?*/ +/*?*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDetectiveFunc::UpdateAllArrowColors() // detective.sdc +/*N*/ { +/*N*/ // no undo actions necessary +/*N*/ +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) +/*N*/ return; +/*N*/ +/*N*/ USHORT nTabCount = pDoc->GetTableCount(); +/*N*/ for (USHORT nObjTab=0; nObjTab<nTabCount; nObjTab++) +/*N*/ { +/*N*/ SdrPage* pPage = pModel->GetPage(nObjTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (pPage) +/*N*/ { +/*N*/ SdrObjListIter aIter( *pPage, IM_FLAT ); +/*N*/ SdrObject* pObject = aIter.Next(); +/*N*/ while (pObject) +/*N*/ { +/*N*/ if ( pObject->GetLayer() == SC_LAYER_INTERN ) +/*N*/ { +/*N*/ BOOL bArrow = FALSE; +/*N*/ BOOL bError = FALSE; +/*N*/ +/*N*/ ScAddress aPos; +/*N*/ ScRange aSource; +/*N*/ BOOL bDummy; +/*N*/ ScDetectiveObjType eType = GetDetectiveObjectType( pObject, aPos, aSource, bDummy ); +/*N*/ if ( eType == SC_DETOBJ_ARROW || eType == SC_DETOBJ_TOOTHERTAB ) +/*N*/ { +/*N*/ // source is valid, determine error flag from source range +/*N*/ +/*N*/ ScTripel aStart( aSource.aStart.Col(), aSource.aStart.Row(), aSource.aStart.Tab() ); +/*N*/ ScTripel aEnd( aSource.aEnd.Col(), aSource.aEnd.Row(), aSource.aEnd.Tab() ); +/*N*/ ScTripel aErrPos; +/*N*/ if ( HasError( aStart, aEnd, aErrPos ) ) +/*N*/ bError = TRUE; +/*N*/ else +/*N*/ bArrow = TRUE; +/*N*/ } +/*N*/ else if ( eType == SC_DETOBJ_FROMOTHERTAB ) +/*N*/ { +/*N*/ // source range is no longer known, take error flag from formula itself +/*N*/ // (this means, if the formula has an error, all references to other tables +/*N*/ // are marked red) +/*N*/ +/*N*/ ScTripel aFormulaPos( aPos.Col(), aPos.Row(), aPos.Tab() ); +/*N*/ ScTripel aErrPos; +/*N*/ if ( HasError( aFormulaPos, aFormulaPos, aErrPos ) ) +/*N*/ bError = TRUE; +/*N*/ else +/*N*/ bArrow = TRUE; +/*N*/ } +/*N*/ else if ( eType == SC_DETOBJ_CIRCLE ) +/*N*/ { +/*N*/ // circles (error marks) are always red +/*N*/ +/*N*/ bError = TRUE; +/*N*/ } +/*N*/ else if ( eType == SC_DETOBJ_NONE ) +/*N*/ { +/*N*/ // frame for area reference has no ObjType, always gets arrow color +/*N*/ +/*N*/ if ( pObject->ISA( SdrRectObj ) && !pObject->ISA( SdrCaptionObj ) ) +/*N*/ { +/*N*/ bArrow = TRUE; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( bArrow || bError ) +/*N*/ { +/*N*/ ColorData nColorData = ( bError ? GetErrorColor() : GetArrowColor() ); +/*N*/ pObject->SetItem( XLineColorItem( String(), Color( nColorData ) ) ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ pObject = aIter.Next(); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScDetectiveFunc::FindFrameForObject( SdrObject* pObject, ScRange& rRange ) // detective.sdc +/*N*/ { +/*N*/ // find the rectangle for an arrow (always the object directly before the arrow) +/*N*/ // rRange must be initialized to the source cell of the arrow (start of area) +/*N*/ +/*N*/ ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ if (!pModel) return FALSE; +/*N*/ +/*N*/ SdrPage* pPage = pModel->GetPage(nTab); +/*N*/ DBG_ASSERT(pPage,"Page ?"); +/*N*/ if (!pPage) return FALSE; +/*N*/ +/*N*/ ULONG nPos = pPage->GetContainer().GetPos( pObject ); +/*N*/ if ( nPos != CONTAINER_ENTRY_NOTFOUND && nPos > 0 ) +/*N*/ { +/*N*/ SdrObject* pPrevObj = pPage->GetObj( nPos - 1 ); +/*N*/ if ( pPrevObj && pPrevObj->GetLayer() == SC_LAYER_INTERN && pPrevObj->ISA(SdrRectObj) ) +/*N*/ { +/*N*/ ScDrawObjData* pPrevData = ScDrawLayer::GetObjData( pPrevObj ); +/*N*/ if ( pPrevData && pPrevData->bValidStart && pPrevData->bValidEnd ) +/*N*/ { +/*N*/ if ( pPrevData->aStt.nCol == rRange.aStart.Col() && +/*N*/ pPrevData->aStt.nRow == rRange.aStart.Row() && +/*N*/ pPrevData->aStt.nTab == rRange.aStart.Tab() ) +/*N*/ { +/*N*/ rRange.aEnd.Set( pPrevData->aEnd.nCol, +/*N*/ pPrevData->aEnd.nRow, +/*N*/ pPrevData->aEnd.nTab ); +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ ScDetectiveObjType ScDetectiveFunc::GetDetectiveObjectType( SdrObject* pObject, +/*N*/ ScAddress& rPosition, ScRange& rSource, BOOL& rRedLine ) +/*N*/ { +/*N*/ rRedLine = FALSE; // detective.sdc +/*N*/ ScDetectiveObjType eType = SC_DETOBJ_NONE; +/*N*/ +/*N*/ if ( pObject && pObject->GetLayer() == SC_LAYER_INTERN ) +/*N*/ { +/*N*/ ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject ); +/*N*/ if ( pObject->IsPolyObj() && pObject->GetPointCount() == 2 ) +/*N*/ { +/*N*/ // line object -> arrow +/*N*/ +/*N*/ if ( pData->bValidStart ) +/*N*/ eType = ( pData->bValidEnd ) ? SC_DETOBJ_ARROW : SC_DETOBJ_TOOTHERTAB; +/*N*/ else if ( pData->bValidEnd ) +/*N*/ eType = SC_DETOBJ_FROMOTHERTAB; +/*N*/ +/*N*/ if ( pData->bValidStart ) +/*N*/ rSource = ScRange( pData->aStt.nCol, pData->aStt.nRow, pData->aStt.nTab ); +/*N*/ if ( pData->bValidEnd ) +/*N*/ rPosition = ScAddress( pData->aEnd.nCol, pData->aEnd.nRow, pData->aEnd.nTab ); +/*N*/ +/*N*/ if ( pData->bValidStart && lcl_HasThickLine( *pObject ) ) +/*N*/ { +/*N*/ // thick line -> look for frame before this object +/*N*/ +/*N*/ FindFrameForObject( pObject, rSource ); // modifies rSource +/*N*/ } +/*N*/ +/*N*/ ColorData nObjColor = ((const XLineColorItem&)pObject->GetItem(XATTR_LINECOLOR)).GetValue().GetColor(); +/*N*/ if ( nObjColor == GetErrorColor() && nObjColor != GetArrowColor() ) +/*N*/ rRedLine = TRUE; +/*N*/ } +/*N*/ else if ( pObject->ISA(SdrCircObj) ) +/*N*/ { +/*N*/ if ( pData->bValidStart ) +/*N*/ { +/*N*/ // cell position is returned in rPosition +/*N*/ +/*N*/ rPosition = ScAddress( pData->aStt.nCol, pData->aStt.nRow, pData->aStt.nTab ); +/*N*/ eType = SC_DETOBJ_CIRCLE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return eType; +/*N*/ } + +/*N*/ void ScDetectiveFunc::InsertObject( ScDetectiveObjType eType, +/*N*/ const ScAddress& rPosition, const ScRange& rSource, +/*N*/ BOOL bRedLine ) +/*N*/ { +DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ScDrawLayer* pModel = pDoc->GetDrawLayer(); +/*N*/ } + +// static +/*N*/ ColorData ScDetectiveFunc::GetArrowColor() +/*N*/ { +/*N*/ if (!bColorsInitialized) +/*N*/ InitializeColors(); +/*N*/ return nArrowColor; +/*N*/ } + +// static +/*N*/ ColorData ScDetectiveFunc::GetErrorColor() +/*N*/ { +/*N*/ if (!bColorsInitialized) +/*N*/ InitializeColors(); +/*N*/ return nErrorColor; +/*N*/ } + +// static +/*N*/ ColorData ScDetectiveFunc::GetCommentColor() +/*N*/ { +/*N*/ if (!bColorsInitialized) +/*N*/ InitializeColors(); +/*N*/ return nCommentColor; +/*N*/ } + +// static +/*N*/ void ScDetectiveFunc::InitializeColors() +/*N*/ { +/*N*/ // may be called several times to update colors from configuration +/*N*/ +/*N*/ const ColorConfig& rColorCfg = SC_MOD()->GetColorConfig(); +/*N*/ nArrowColor = rColorCfg.GetColorValue(CALCDETECTIVE).nColor; +/*N*/ nErrorColor = rColorCfg.GetColorValue(CALCDETECTIVEERROR).nColor; +/*N*/ nCommentColor = rColorCfg.GetColorValue(CALCNOTESBACKGROUND).nColor; +/*N*/ +/*N*/ bColorsInitialized = TRUE; +/*N*/ } + +// static + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_docoptio.cxx b/binfilter/bf_sc/source/core/tool/sc_docoptio.cxx new file mode 100644 index 000000000000..1ea7d1538e72 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_docoptio.cxx @@ -0,0 +1,410 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <bf_svtools/zforlist.hxx> + + +#include "docoptio.hxx" +#include "rechead.hxx" +#include "bf_sc.hrc" +#include "miscuno.hxx" +namespace binfilter { + +using namespace utl; +using namespace rtl; +using namespace ::com::sun::star::uno; + +//------------------------------------------------------------------------ + +#define SC_VERSION ((USHORT)251) + + +//------------------------------------------------------------------------ + +//! these functions should be moved to some header file +inline long HMMToTwips(long nHMM) { return (nHMM * 72 + 63) / 127; } + + +//------------------------------------------------------------------------ + +/*N*/ USHORT lcl_GetDefaultTabDist() +/*N*/ { +/*N*/ if ( ScOptionsUtil::IsMetricSystem() ) +/*N*/ return 709; // 1,25 cm +/*N*/ else +/*N*/ return 720; // 1/2" +/*N*/ } + +//======================================================================== +// ScDocOptions - Dokument-Optionen +//======================================================================== + +/*N*/ ScDocOptions::ScDocOptions() +/*N*/ { +/*N*/ ResetDocOptions(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScDocOptions::ScDocOptions( const ScDocOptions& rCpy ) +/*N*/ : bIsIgnoreCase( rCpy.bIsIgnoreCase ), +/*N*/ bIsIter( rCpy.bIsIter ), +/*N*/ nIterCount( rCpy.nIterCount ), +/*N*/ fIterEps( rCpy.fIterEps ), +/*N*/ nPrecStandardFormat( rCpy.nPrecStandardFormat ), +/*N*/ nDay( rCpy.nDay ), +/*N*/ nMonth( rCpy.nMonth ), +/*N*/ nYear( rCpy.nYear ), +/*N*/ nYear2000( rCpy.nYear2000 ), +/*N*/ nTabDistance( rCpy.nTabDistance ), +/*N*/ bCalcAsShown( rCpy.bCalcAsShown ), +/*N*/ bMatchWholeCell( rCpy.bMatchWholeCell ), +/*N*/ bDoAutoSpell( rCpy.bDoAutoSpell ), +/*N*/ bLookUpColRowNames( rCpy.bLookUpColRowNames ), +/*N*/ bFormulaRegexEnabled( rCpy.bFormulaRegexEnabled ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScDocOptions::~ScDocOptions() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScDocOptions::Save(SvStream& rStream, BOOL bConfig) const +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream, 28 ); +/*N*/ +/*N*/ rStream << bIsIgnoreCase; +/*N*/ rStream << bIsIter; +/*N*/ rStream << nIterCount; +/*N*/ rStream << fIterEps; +/*N*/ rStream << nPrecStandardFormat; +/*N*/ rStream << nDay; +/*N*/ rStream << nMonth; +/*N*/ rStream << nYear; +/*N*/ rStream << nTabDistance; +/*N*/ rStream << bCalcAsShown; +/*N*/ rStream << bMatchWholeCell; +/*N*/ rStream << bDoAutoSpell; +/*N*/ rStream << bLookUpColRowNames; +/*N*/ +/*N*/ if ( bConfig || rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) // nicht bei 4.0 Export +/*N*/ { +/*N*/ if ( !bConfig && 1901 <= nYear2000 && nYear2000 <= 1999 ) +/*N*/ { // fuer SO5 auf altes Format zweistellig abbilden +/*N*/ rStream << (USHORT) (nYear2000 - 1901); +/*N*/ } +/*N*/ else +/*N*/ { // neues Format vierstellig, beliebiges Jahrhundert +/*N*/ // erzeugt in SO5 vor src513e ein Warning beim Laden +/*N*/ rStream << (USHORT) 29; // Dummy, alter SO5 Default +/*N*/ rStream << nYear2000; // echter Wert +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScDocOptions::Load(SvStream& rStream) +/*N*/ { +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> bIsIgnoreCase; +/*N*/ rStream >> bIsIter; +/*N*/ rStream >> nIterCount; +/*N*/ rStream >> fIterEps; +/*N*/ rStream >> nPrecStandardFormat; +/*N*/ rStream >> nDay; +/*N*/ rStream >> nMonth; +/*N*/ rStream >> nYear; +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> nTabDistance; +/*N*/ else +/*?*/ nTabDistance = lcl_GetDefaultTabDist(); +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> bCalcAsShown; +/*N*/ else +/*N*/ bCalcAsShown = FALSE; +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> bMatchWholeCell; +/*N*/ else +/*N*/ bMatchWholeCell = FALSE; +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> bDoAutoSpell; +/*N*/ else +/*N*/ bDoAutoSpell = FALSE; +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> bLookUpColRowNames; +/*N*/ else +/*N*/ bLookUpColRowNames = TRUE; +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ { +/*N*/ rStream >> nYear2000; // SO5 ab 24.06.98 +/*N*/ // SO51 ab src513e +/*N*/ if ( aHdr.BytesLeft() ) +/*N*/ rStream >> nYear2000; // der echte Wert +/*N*/ else +/*N*/ nYear2000 += 1901; // altes zweistelliges auf neues vierstelliges +/*N*/ } +/*N*/ else +/*N*/ nYear2000 = 18 + 1901; // alter Wert vor SO5 +/*N*/ } + +/*N*/ void ScDocOptions::ResetDocOptions() +/*N*/ { +/*N*/ bIsIgnoreCase = FALSE; +/*N*/ bIsIter = FALSE; +/*N*/ nIterCount = 100; +/*N*/ fIterEps = 1.0E-3; +/*N*/ nPrecStandardFormat = 2; +/*N*/ nDay = 30; +/*N*/ nMonth = 12; +/*N*/ nYear = 1899; +/*N*/ nYear2000 = SvNumberFormatter::GetYear2000Default(); +/*N*/ nTabDistance = lcl_GetDefaultTabDist(); +/*N*/ bCalcAsShown = FALSE; +/*N*/ bMatchWholeCell = TRUE; +/*N*/ bDoAutoSpell = FALSE; +/*N*/ bLookUpColRowNames = TRUE; +/*N*/ bFormulaRegexEnabled= TRUE; +/*N*/ } + +//======================================================================== +// ScTpCalcItem - Daten fuer die CalcOptions-TabPage +//======================================================================== + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//================================================================== +// Config Item containing document options +//================================================================== + +#define CFGPATH_CALC "Office.Calc/Calculate" + +#define SCCALCOPT_ITER_ITER 0 +#define SCCALCOPT_ITER_STEPS 1 +#define SCCALCOPT_ITER_MINCHG 2 +#define SCCALCOPT_DATE_DAY 3 +#define SCCALCOPT_DATE_MONTH 4 +#define SCCALCOPT_DATE_YEAR 5 +#define SCCALCOPT_DECIMALS 6 +#define SCCALCOPT_CASESENSITIVE 7 +#define SCCALCOPT_PRECISION 8 +#define SCCALCOPT_SEARCHCRIT 9 +#define SCCALCOPT_FINDLABEL 10 +#define SCCALCOPT_REGEX 11 +#define SCCALCOPT_COUNT 12 + +#define CFGPATH_DOCLAYOUT "Office.Calc/Layout/Other" + +#define SCDOCLAYOUTOPT_TABSTOP 0 +#define SCDOCLAYOUTOPT_COUNT 1 + + +/*N*/ Sequence<OUString> ScDocCfg::GetCalcPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "IterativeReference/Iteration", // SCCALCOPT_ITER_ITER +/*N*/ "IterativeReference/Steps", // SCCALCOPT_ITER_STEPS +/*N*/ "IterativeReference/MinimumChange", // SCCALCOPT_ITER_MINCHG +/*N*/ "Other/Date/DD", // SCCALCOPT_DATE_DAY +/*N*/ "Other/Date/MM", // SCCALCOPT_DATE_MONTH +/*N*/ "Other/Date/YY", // SCCALCOPT_DATE_YEAR +/*N*/ "Other/DecimalPlaces", // SCCALCOPT_DECIMALS +/*N*/ "Other/CaseSensitive", // SCCALCOPT_CASESENSITIVE +/*N*/ "Other/Precision", // SCCALCOPT_PRECISION +/*N*/ "Other/SearchCriteria", // SCCALCOPT_SEARCHCRIT +/*N*/ "Other/FindLabel", // SCCALCOPT_FINDLABEL +/*N*/ "Other/RegularExpressions" // SCCALCOPT_REGEX +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCCALCOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCCALCOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScDocCfg::GetLayoutPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "TabStop/NonMetric" // SCDOCLAYOUTOPT_TABSTOP +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCDOCLAYOUTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCDOCLAYOUTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ // adjust for metric system +/*N*/ if (ScOptionsUtil::IsMetricSystem()) +/*N*/ pNames[SCDOCLAYOUTOPT_TABSTOP] = OUString::createFromAscii( "TabStop/Metric" ); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ ScDocCfg::ScDocCfg() : +/*N*/ aCalcItem( OUString::createFromAscii( CFGPATH_CALC ) ), +/*N*/ aLayoutItem( OUString::createFromAscii( CFGPATH_DOCLAYOUT ) ) +/*N*/ { +/*N*/ sal_Int32 nIntVal; +/*N*/ double fDoubleVal; +/*N*/ +/*N*/ Sequence<OUString> aNames; +/*N*/ Sequence<Any> aValues; +/*N*/ const Any* pValues = NULL; +/*N*/ +/*N*/ USHORT nDateDay, nDateMonth, nDateYear; +/*N*/ GetDate( nDateDay, nDateMonth, nDateYear ); +/*N*/ +/*N*/ aNames = GetCalcPropertyNames(); +/*N*/ aValues = aCalcItem.GetProperties(aNames); +/*N*/ aCalcItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCCALCOPT_ITER_ITER: +/*N*/ SetIter( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCCALCOPT_ITER_STEPS: +/*N*/ if (pValues[nProp] >>= nIntVal) SetIterCount( (USHORT) nIntVal ); +/*N*/ break; +/*N*/ case SCCALCOPT_ITER_MINCHG: +/*N*/ if (pValues[nProp] >>= fDoubleVal) SetIterEps( fDoubleVal ); +/*N*/ break; +/*N*/ case SCCALCOPT_DATE_DAY: +/*N*/ if (pValues[nProp] >>= nIntVal) nDateDay = (USHORT) nIntVal; +/*N*/ break; +/*N*/ case SCCALCOPT_DATE_MONTH: +/*N*/ if (pValues[nProp] >>= nIntVal) nDateMonth = (USHORT) nIntVal; +/*N*/ break; +/*N*/ case SCCALCOPT_DATE_YEAR: +/*N*/ if (pValues[nProp] >>= nIntVal) nDateYear = (USHORT) nIntVal; +/*N*/ break; +/*N*/ case SCCALCOPT_DECIMALS: +/*N*/ if (pValues[nProp] >>= nIntVal) SetStdPrecision( (USHORT) nIntVal ); +/*N*/ break; +/*N*/ case SCCALCOPT_CASESENSITIVE: +/*N*/ // content is reversed +/*N*/ SetIgnoreCase( !ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCCALCOPT_PRECISION: +/*N*/ SetCalcAsShown( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCCALCOPT_SEARCHCRIT: +/*N*/ SetMatchWholeCell( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCCALCOPT_FINDLABEL: +/*N*/ SetLookUpColRowNames( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCCALCOPT_REGEX : +/*N*/ SetFormulaRegexEnabled( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aCalcItem.SetCommitLink( LINK( this, ScDocCfg, CalcCommitHdl ) ); +/*N*/ +/*N*/ SetDate( nDateDay, nDateMonth, nDateYear ); +/*N*/ +/*N*/ aNames = GetLayoutPropertyNames(); +/*N*/ aValues = aLayoutItem.GetProperties(aNames); +/*N*/ aLayoutItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCDOCLAYOUTOPT_TABSTOP: +/*N*/ // TabDistance in ScDocOptions is in twips +/*N*/ if (pValues[nProp] >>= nIntVal) +/*N*/ SetTabDistance( (USHORT) HMMToTwips( nIntVal ) ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aLayoutItem.SetCommitLink( LINK( this, ScDocCfg, LayoutCommitHdl ) ); +/*N*/ } + +/*N*/ IMPL_LINK( ScDocCfg, CalcCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetCalcPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScDocCfg, LayoutCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetLayoutPropertyNames(); +/*N*/ return 0; +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_editutil.cxx b/binfilter/bf_sc/source/core/tool/sc_editutil.cxx new file mode 100644 index 000000000000..dec195f79768 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_editutil.cxx @@ -0,0 +1,511 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "scitems.hxx" +#include <bf_svx/eeitem.hxx> +#define ITEMID_FIELD EE_FEATURE_FIELD + +#include <bf_svtools/colorcfg.hxx> +#include <bf_svx/editstat.hxx> + + +#include <bf_svtools/poolitem.hxx> + +#include <bf_svx/itemdata.hxx> + +#include <tools/date.hxx> + +#include <tools/time.hxx> + +#include <bf_svx/flditem.hxx> +#include <bf_svtools/inethist.hxx> +#include <bf_svtools/syslocale.hxx> +#ifndef _SVSTDARR_USHORTS +#define _SVSTDARR_USHORTS +#endif + +#include "editutil.hxx" +#include "docpool.hxx" +#include "patattr.hxx" +#include "scmod.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +// Delimiters zusaetzlich zu EditEngine-Default: + +const sal_Char __FAR_DATA ScEditUtil::pCalcDelimiters[] = "=();+-*/^&<>"; + + +//------------------------------------------------------------------------ + +/*N*/ String ScEditUtil::ModifyDelimiters( const String& rOld ) +/*N*/ { +/*N*/ String aRet = rOld; +/*N*/ aRet.EraseAllChars( '_' ); // underscore is used in function argument names +/*N*/ aRet.AppendAscii( RTL_CONSTASCII_STRINGPARAM( pCalcDelimiters ) ); +/*N*/ return aRet; +/*N*/ } + +/*N*/ String ScEditUtil::GetSpaceDelimitedString( const EditEngine& rEngine ) +/*N*/ { +/*N*/ String aRet; +/*N*/ USHORT nParCount = rEngine.GetParagraphCount(); +/*N*/ for (USHORT nPar=0; nPar<nParCount; nPar++) +/*N*/ { +/*N*/ if (nPar > 0) +/*N*/ aRet += ' '; +/*N*/ aRet += rEngine.GetText( nPar ); +/*N*/ } +/*N*/ return aRet; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ ScEditAttrTester::ScEditAttrTester( EditEngine* pEng ) : +/*N*/ pEngine( pEng ), +/*N*/ pEditAttrs( NULL ), +/*N*/ bNeedsObject( FALSE ), +/*N*/ bNeedsCellAttr( FALSE ) +/*N*/ { +/*N*/ if ( pEngine->GetParagraphCount() > 1 ) +/*N*/ { +/*N*/ bNeedsObject = TRUE; //! Zellatribute finden ? +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ const SfxPoolItem* pItem = NULL; +/*N*/ pEditAttrs = new SfxItemSet( pEngine->GetAttribs( +/*N*/ ESelection(0,0,0,pEngine->GetTextLen(0)) ) ); +/*N*/ const SfxItemPool* pEditPool = pEditAttrs->GetPool(); +/*N*/ +/*N*/ for (USHORT nId = EE_CHAR_START; nId <= EE_CHAR_END && !bNeedsObject; nId++) +/*N*/ { +/*N*/ SfxItemState eState = pEditAttrs->GetItemState( nId, FALSE, &pItem ); +/*N*/ if (eState == SFX_ITEM_DONTCARE) +/*N*/ bNeedsObject = TRUE; +/*N*/ else if (eState == SFX_ITEM_SET) +/*N*/ { +/*N*/ if ( nId == EE_CHAR_ESCAPEMENT || nId == EE_CHAR_PAIRKERNING || +/*N*/ nId == EE_CHAR_KERNING || nId == EE_CHAR_XMLATTRIBS ) +/*N*/ { +/*N*/ // Escapement and kerning are kept in EditEngine because there are no +/*N*/ // corresponding cell format items. User defined attributes are kept in +/*N*/ // EditEngine because "user attributes applied to all the text" is different +/*N*/ // from "user attributes applied to the cell". +/*N*/ +/*N*/ if ( *pItem != pEditPool->GetDefaultItem(nId) ) +/*N*/ bNeedsObject = TRUE; +/*N*/ } +/*N*/ else +/*N*/ if (!bNeedsCellAttr) +/*N*/ if ( *pItem != pEditPool->GetDefaultItem(nId) ) +/*N*/ bNeedsCellAttr = TRUE; +/*N*/ // SetDefaults an der EditEngine setzt Pool-Defaults +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Feldbefehle enthalten? +/*N*/ +/*N*/ SfxItemState eFieldState = pEditAttrs->GetItemState( EE_FEATURE_FIELD, FALSE ); +/*N*/ if ( eFieldState == SFX_ITEM_DONTCARE || eFieldState == SFX_ITEM_SET ) +/*N*/ bNeedsObject = TRUE; +/*N*/ +/*N*/ // not converted characters? +/*N*/ +/*N*/ SfxItemState eConvState = pEditAttrs->GetItemState( EE_FEATURE_NOTCONV, FALSE ); +/*N*/ if ( eConvState == SFX_ITEM_DONTCARE || eConvState == SFX_ITEM_SET ) +/*N*/ bNeedsObject = TRUE; +/*N*/ } +/*N*/ } + +/*N*/ ScEditAttrTester::~ScEditAttrTester() +/*N*/ { +/*N*/ delete pEditAttrs; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ ScEnginePoolHelper::ScEnginePoolHelper( SfxItemPool* pEnginePoolP, +/*N*/ BOOL bDeleteEnginePoolP ) +/*N*/ : +/*N*/ pEnginePool( pEnginePoolP ), +/*N*/ bDeleteEnginePool( bDeleteEnginePoolP ), +/*N*/ pDefaults( NULL ), +/*N*/ bDeleteDefaults( FALSE ) +/*N*/ { +/*N*/ } + + +/*N*/ ScEnginePoolHelper::ScEnginePoolHelper( const ScEnginePoolHelper& rOrg ) +/*N*/ : +/*N*/ pEnginePool( rOrg.bDeleteEnginePool ? rOrg.pEnginePool->Clone() : rOrg.pEnginePool ), +/*N*/ bDeleteEnginePool( rOrg.bDeleteEnginePool ), +/*N*/ pDefaults( NULL ), +/*N*/ bDeleteDefaults( FALSE ) +/*N*/ { +/*N*/ } + + +/*N*/ ScEnginePoolHelper::~ScEnginePoolHelper() +/*N*/ { +/*N*/ if ( bDeleteDefaults ) +/*N*/ delete pDefaults; +/*N*/ if ( bDeleteEnginePool ) +/*N*/ delete pEnginePool; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ ScEditEngineDefaulter::ScEditEngineDefaulter( SfxItemPool* pEnginePoolP, +/*N*/ BOOL bDeleteEnginePoolP ) +/*N*/ : +/*N*/ ScEnginePoolHelper( pEnginePoolP, bDeleteEnginePoolP ), +/*N*/ EditEngine( pEnginePoolP ) +/*N*/ { +/*N*/ // All EditEngines use ScGlobal::GetEditDefaultLanguage as DefaultLanguage. +/*N*/ // DefaultLanguage for InputHandler's EditEngine is updated later. +/*N*/ +/*N*/ SetDefaultLanguage( ScGlobal::GetEditDefaultLanguage() ); +/*N*/ } + + +/*N*/ ScEditEngineDefaulter::ScEditEngineDefaulter( const ScEditEngineDefaulter& rOrg ) +/*N*/ : +/*N*/ ScEnginePoolHelper( rOrg ), +/*N*/ EditEngine( pEnginePool ) +/*N*/ { +/*N*/ SetDefaultLanguage( ScGlobal::GetEditDefaultLanguage() ); +/*N*/ } + + +/*N*/ ScEditEngineDefaulter::~ScEditEngineDefaulter() +/*N*/ { +/*N*/ } + + +/*N*/ void ScEditEngineDefaulter::SetDefaults( const SfxItemSet& rSet, BOOL bRememberCopy ) +/*N*/ { +/*N*/ if ( bRememberCopy ) +/*N*/ { +/*N*/ if ( bDeleteDefaults ) +/*N*/ delete pDefaults; +/*N*/ pDefaults = new SfxItemSet( rSet ); +/*N*/ bDeleteDefaults = TRUE; +/*N*/ } +/*N*/ const SfxItemSet& rNewSet = bRememberCopy ? *pDefaults : rSet; +/*N*/ BOOL bUndo = IsUndoEnabled(); +/*N*/ EnableUndo( FALSE ); +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( FALSE ); +/*N*/ USHORT nPara = GetParagraphCount(); +/*N*/ for ( USHORT j=0; j<nPara; j++ ) +/*N*/ { +/*N*/ SetParaAttribs( j, rNewSet ); +/*N*/ } +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( TRUE ); +/*N*/ if ( bUndo ) +/*N*/ EnableUndo( TRUE ); +/*N*/ } + + +/*N*/ void ScEditEngineDefaulter::SetDefaults( SfxItemSet* pSet, BOOL bTakeOwnership ) +/*N*/ { +/*N*/ if ( bDeleteDefaults ) +/*N*/ delete pDefaults; +/*N*/ pDefaults = pSet; +/*N*/ bDeleteDefaults = bTakeOwnership; +/*N*/ if ( pDefaults ) +/*N*/ SetDefaults( *pDefaults, FALSE ); +/*N*/ } + + + + +/*N*/ void ScEditEngineDefaulter::SetText( const EditTextObject& rTextObject ) +/*N*/ { +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( FALSE ); +/*N*/ EditEngine::SetText( rTextObject ); +/*N*/ if ( pDefaults ) +/*N*/ SetDefaults( *pDefaults, FALSE ); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( TRUE ); +/*N*/ } + +/*N*/ void ScEditEngineDefaulter::SetTextNewDefaults( const EditTextObject& rTextObject, +/*N*/ const SfxItemSet& rSet, BOOL bRememberCopy ) +/*N*/ { +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( FALSE ); +/*N*/ EditEngine::SetText( rTextObject ); +/*N*/ SetDefaults( rSet, bRememberCopy ); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( TRUE ); +/*N*/ } + +/*N*/ void ScEditEngineDefaulter::SetTextNewDefaults( const EditTextObject& rTextObject, +/*N*/ SfxItemSet* pSet, BOOL bTakeOwnership ) +/*N*/ { +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*?*/ SetUpdateMode( FALSE ); +/*N*/ EditEngine::SetText( rTextObject ); +/*N*/ SetDefaults( pSet, bTakeOwnership ); +/*N*/ if ( bUpdateMode ) +/*?*/ SetUpdateMode( TRUE ); +/*N*/ } + + +/*N*/ void ScEditEngineDefaulter::SetText( const String& rText ) +/*N*/ { +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( FALSE ); +/*N*/ EditEngine::SetText( rText ); +/*N*/ if ( pDefaults ) +/*?*/ SetDefaults( *pDefaults, FALSE ); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( TRUE ); +/*N*/ } + +/*N*/ void ScEditEngineDefaulter::SetTextNewDefaults( const String& rText, +/*N*/ const SfxItemSet& rSet, BOOL bRememberCopy ) +/*N*/ { +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( FALSE ); +/*N*/ EditEngine::SetText( rText ); +/*N*/ SetDefaults( rSet, bRememberCopy ); +/*N*/ if ( bUpdateMode ) +/*N*/ SetUpdateMode( TRUE ); +/*N*/ } + +/*N*/ void ScEditEngineDefaulter::SetTextNewDefaults( const String& rText, +/*N*/ SfxItemSet* pSet, BOOL bTakeOwnership ) +/*N*/ { +/*N*/ BOOL bUpdateMode = GetUpdateMode(); +/*N*/ if ( bUpdateMode ) +/*?*/ SetUpdateMode( FALSE ); +/*N*/ EditEngine::SetText( rText ); +/*N*/ SetDefaults( pSet, bTakeOwnership ); +/*N*/ if ( bUpdateMode ) +/*?*/ SetUpdateMode( TRUE ); +/*N*/ } + + + +//------------------------------------------------------------------------ + + + + +//------------------------------------------------------------------------ +// Feldbefehle fuer Kopf- und Fusszeilen +//------------------------------------------------------------------------ + +// +// Zahlen aus \sw\source\core\doc\numbers.cxx +// + + + +/*N*/ String lcl_GetNumStr( USHORT nNo, SvxNumType eType ) +/*N*/ { +/*N*/ String aTmpStr( '0' ); +/*N*/ if( nNo ) +/*N*/ { +/*N*/ switch( eType ) +/*N*/ { +/*?*/ case SVX_CHARS_UPPER_LETTER: +/*?*/ case SVX_CHARS_LOWER_LETTER: +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 aTmpStr = lcl_GetCharStr( nNo ); +/*?*/ break; +/*?*/ +/*?*/ case SVX_ROMAN_UPPER: +/*?*/ case SVX_ROMAN_LOWER: +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 aTmpStr = lcl_GetRomanStr( nNo ); +/*?*/ break; +/*?*/ +/*?*/ case SVX_NUMBER_NONE: +/*?*/ aTmpStr.Erase(); +/*?*/ break; +/*?*/ +/*?*/ // CHAR_SPECIAL: +/*?*/ // ???? +/*?*/ +/*?*/ // case ARABIC: ist jetzt default +/*N*/ default: +/*N*/ aTmpStr = String::CreateFromInt32( nNo ); +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ if( SVX_CHARS_UPPER_LETTER == eType || SVX_ROMAN_UPPER == eType ) +/*N*/ aTmpStr.ToUpperAscii(); +/*N*/ } +/*N*/ return aTmpStr; +/*N*/ } + +/*N*/ ScHeaderFieldData::ScHeaderFieldData() +/*N*/ { +/*N*/ nPageNo = nTotalPages = 0; +/*N*/ eNumType = SVX_ARABIC; +/*N*/ } + +/*N*/ ScHeaderEditEngine::ScHeaderEditEngine( SfxItemPool* pEnginePool, BOOL bDeleteEnginePool ) +/*N*/ : ScEditEngineDefaulter( pEnginePool, bDeleteEnginePool ) +/*N*/ { +/*N*/ } + +/*N*/ String __EXPORT ScHeaderEditEngine::CalcFieldValue( const SvxFieldItem& rField, +/*N*/ USHORT nPara, USHORT nPos, +/*N*/ Color*& rTxtColor, Color*& rFldColor ) +/*N*/ { +/*N*/ String aRet; +/*N*/ const SvxFieldData* pFieldData = rField.GetField(); +/*N*/ if ( pFieldData ) +/*N*/ { +/*N*/ TypeId aType = pFieldData->Type(); +/*N*/ if (aType == TYPE(SvxPageField)) +/*N*/ aRet = lcl_GetNumStr( (USHORT)aData.nPageNo,aData.eNumType ); +/*N*/ else if (aType == TYPE(SvxPagesField)) +/*?*/ aRet = lcl_GetNumStr( (USHORT)aData.nTotalPages,aData.eNumType ); +/*N*/ else if (aType == TYPE(SvxTimeField)) +/*N*/ aRet = ScGlobal::pLocaleData->getTime(aData.aTime); +/*N*/ else if (aType == TYPE(SvxFileField)) +/*N*/ aRet = aData.aTitle; +/*N*/ else if (aType == TYPE(SvxExtFileField)) +/*N*/ { +/*?*/ switch ( ((const SvxExtFileField*)pFieldData)->GetFormat() ) +/*?*/ { +/*?*/ case SVXFILEFORMAT_FULLPATH : +/*?*/ aRet = aData.aLongDocName; +/*?*/ break; +/*?*/ default: +/*?*/ aRet = aData.aShortDocName; +/*?*/ } +/*N*/ } +/*N*/ else if (aType == TYPE(SvxTableField)) +/*N*/ aRet = aData.aTabName; +/*N*/ else if (aType == TYPE(SvxDateField)) +/*N*/ aRet = ScGlobal::pLocaleData->getDate(aData.aDate); +/*N*/ else +/*N*/ { +/*N*/ //DBG_ERROR("unbekannter Feldbefehl"); +/*N*/ aRet = '?'; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { + // #i75599# no assertion - can happen with old files +/*N*/ //DBG_ERROR("FieldData ist 0"); +/*N*/ aRet = '?'; +/*N*/ } +/*N*/ +/*N*/ return aRet; +/*N*/ } + +//------------------------------------------------------------------------ +// +// Feld-Daten +// +//------------------------------------------------------------------------ + +/*N*/ ScFieldEditEngine::ScFieldEditEngine( SfxItemPool* pEnginePool, +/*N*/ SfxItemPool* pTextObjectPool, BOOL bDeleteEnginePool ) +/*N*/ : +/*N*/ ScEditEngineDefaulter( pEnginePool, bDeleteEnginePool ), +/*N*/ bExecuteURL( TRUE ) +/*N*/ { +/*N*/ if ( pTextObjectPool ) +/*N*/ SetEditTextObjectPool( pTextObjectPool ); +/*N*/ // EE_CNTRL_URLSFXEXECUTE nicht, weil die Edit-Engine den ViewFrame nicht kennt +/*N*/ // wir haben keine StyleSheets fuer Text +/*N*/ SetControlWord( (GetControlWord() | EE_CNTRL_MARKFIELDS) & ~EE_CNTRL_RTFSTYLESHEETS ); +/*N*/ } + +/*N*/ String __EXPORT ScFieldEditEngine::CalcFieldValue( const SvxFieldItem& rField, +/*N*/ USHORT nPara, USHORT nPos, +/*N*/ Color*& rTxtColor, Color*& rFldColor ) +/*N*/ { +/*N*/ String aRet; +/*N*/ const SvxFieldData* pFieldData = rField.GetField(); +/*N*/ +/*N*/ if ( pFieldData ) +/*N*/ { +/*N*/ TypeId aType = pFieldData->Type(); +/*N*/ +/*N*/ if (aType == TYPE(SvxURLField)) +/*N*/ { +/*N*/ String aURL = ((const SvxURLField*)pFieldData)->GetURL(); +/*N*/ +/*N*/ switch ( ((const SvxURLField*)pFieldData)->GetFormat() ) +/*N*/ { +/*N*/ case SVXURLFORMAT_APPDEFAULT: //!!! einstellbar an App??? +/*N*/ case SVXURLFORMAT_REPR: +/*N*/ aRet = ((const SvxURLField*)pFieldData)->GetRepresentation(); +/*N*/ break; +/*N*/ +/*N*/ case SVXURLFORMAT_URL: +/*N*/ aRet = aURL; +/*N*/ break; +/*N*/ } +/*N*/ + ColorConfigEntry eEntry = INetURLHistory::GetOrCreate()->QueryUrl( aURL ) ? LINKSVISITED : LINKS; +/*N*/ rTxtColor = new Color( SC_MOD()->GetColorConfig().GetColorValue(eEntry).nColor ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ //DBG_ERROR("unbekannter Feldbefehl"); +/*N*/ aRet = '?'; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if (!aRet.Len()) // leer ist baeh +/*N*/ aRet = ' '; // Space ist Default der Editengine +/*N*/ +/*N*/ return aRet; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_hints.cxx b/binfilter/bf_sc/source/core/tool/sc_hints.cxx new file mode 100644 index 000000000000..59d4d1c22be7 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_hints.cxx @@ -0,0 +1,128 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "hints.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1(ScPaintHint, SfxHint); +/*N*/ TYPEINIT1(ScUpdateRefHint, SfxHint); +/*N*/ TYPEINIT1(ScPointerChangedHint, SfxHint); +/*N*/ TYPEINIT1(ScLinkRefreshedHint, SfxHint); +/*N*/ TYPEINIT1(ScAutoStyleHint, SfxHint); + +// ----------------------------------------------------------------------- +// ScPaintHint - Angabe, was neu gezeichnet werden muss +// ----------------------------------------------------------------------- + +/*N*/ ScPaintHint::ScPaintHint( const ScRange& rRng, USHORT nPaint ) : +/*N*/ aRange( rRng ), +/*N*/ nParts( nPaint ), +/*N*/ bPrint( TRUE ) +/*N*/ { +/*N*/ } + +/*N*/ ScPaintHint::~ScPaintHint() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +// ScUpdateRefHint - Referenz-Updaterei +// ----------------------------------------------------------------------- + +/*N*/ ScUpdateRefHint::ScUpdateRefHint( UpdateRefMode eMode, const ScRange& rR, +/*N*/ short nX, short nY, short nZ ) : +/*N*/ eUpdateRefMode( eMode ), +/*N*/ aRange( rR ), +/*N*/ nDx( nX ), +/*N*/ nDy( nY ), +/*N*/ nDz( nZ ) +/*N*/ { +/*N*/ } + +/*N*/ ScUpdateRefHint::~ScUpdateRefHint() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +// ScPointerChangedHint - Pointer ist ungueltig geworden +// ----------------------------------------------------------------------- + +/*N*/ ScPointerChangedHint::ScPointerChangedHint( USHORT nF ) : +/*N*/ nFlags( nF ) +/*N*/ { +/*N*/ } + +/*N*/ ScPointerChangedHint::~ScPointerChangedHint() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +// ScLinkRefreshedHint - a link has been refreshed +// ----------------------------------------------------------------------- + +/*N*/ ScLinkRefreshedHint::ScLinkRefreshedHint() : +/*N*/ nLinkType( SC_LINKREFTYPE_NONE ), +/*N*/ nDdeMode( 0 ) +/*N*/ { +/*N*/ } + +/*N*/ ScLinkRefreshedHint::~ScLinkRefreshedHint() +/*N*/ { +/*N*/ } + +/*N*/ void ScLinkRefreshedHint::SetSheetLink( const String& rSourceUrl ) +/*N*/ { +/*N*/ nLinkType = SC_LINKREFTYPE_SHEET; +/*N*/ aUrl = rSourceUrl; +/*N*/ } + + +/*N*/ void ScLinkRefreshedHint::SetAreaLink( const ScAddress& rPos ) +/*N*/ { +/*N*/ nLinkType = SC_LINKREFTYPE_AREA; +/*N*/ aDestPos = rPos; +/*N*/ } + +// ----------------------------------------------------------------------- +// ScAutoStyleHint - STYLE() function has been called +// ----------------------------------------------------------------------- + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_indexmap.cxx b/binfilter/bf_sc/source/core/tool/sc_indexmap.cxx new file mode 100644 index 000000000000..1c0099a0ea8a --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_indexmap.cxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + + +#include <memory.h> + +#include "indexmap.hxx" +namespace binfilter { + + +/*N*/ ScIndexMap::ScIndexMap( USHORT nEntries ) +/*N*/ { +/*N*/ nCount = nEntries; +/*N*/ ULONG nC = nEntries ? ((ULONG) nEntries * 2) : 2; +/*N*/ pMap = new USHORT [ nC ]; +/*N*/ memset( pMap, 0, nC * sizeof(USHORT) ); +/*N*/ } + + +/*N*/ ScIndexMap::~ScIndexMap() +/*N*/ { +/*N*/ delete [] pMap; +/*N*/ } + + +/*N*/ void ScIndexMap::SetPair( USHORT nEntry, USHORT nIndex1, USHORT nIndex2 ) +/*N*/ { +/*N*/ if ( nEntry < nCount ) +/*N*/ { +/*N*/ ULONG nOff = (ULONG) nEntry * 2; +/*N*/ pMap[nOff] = nIndex1; +/*N*/ pMap[nOff+1] = nIndex2; +/*N*/ } +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_inputopt.cxx b/binfilter/bf_sc/source/core/tool/sc_inputopt.cxx new file mode 100644 index 000000000000..53a21892c88c --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_inputopt.cxx @@ -0,0 +1,267 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------ + +#include <tools/debug.hxx> + + +#include "inputopt.hxx" +#include "rechead.hxx" +#include "global.hxx" +#include "bf_sc.hrc" +#include "miscuno.hxx" +namespace binfilter { + +using namespace utl; +using namespace rtl; +using namespace ::com::sun::star::uno; + +//------------------------------------------------------------------ + +// Version, ab der das Item kompatibel ist +#define SC_VERSION ((USHORT)351) + + +//======================================================================== +// ScInputOptions - Eingabe-Optionen +//======================================================================== + +/*N*/ ScInputOptions::ScInputOptions() +/*N*/ { +/*N*/ SetDefaults(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScInputOptions::ScInputOptions( const ScInputOptions& rCpy ) +/*N*/ { +/*N*/ *this = rCpy; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScInputOptions::~ScInputOptions() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScInputOptions::SetDefaults() +/*N*/ { +/*N*/ nMoveDir = DIR_BOTTOM; +/*N*/ bMoveSelection = TRUE; +/*N*/ bEnterEdit = FALSE; +/*N*/ bExtendFormat = FALSE; +/*N*/ bRangeFinder = TRUE; +/*N*/ bExpandRefs = FALSE; +/*N*/ bMarkHeader = TRUE; +/*N*/ bUseTabCol = FALSE; +/*N*/ bTextWysiwyg = FALSE; +/*N*/ bReplCellsWarn = TRUE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ const ScInputOptions& ScInputOptions::operator=( const ScInputOptions& rCpy ) +/*N*/ { +/*N*/ nMoveDir = rCpy.nMoveDir; +/*N*/ bMoveSelection = rCpy.bMoveSelection; +/*N*/ bEnterEdit = rCpy.bEnterEdit; +/*N*/ bExtendFormat = rCpy.bExtendFormat; +/*N*/ bRangeFinder = rCpy.bRangeFinder; +/*N*/ bExpandRefs = rCpy.bExpandRefs; +/*N*/ bMarkHeader = rCpy.bMarkHeader; +/*N*/ bUseTabCol = rCpy.bUseTabCol; +/*N*/ bTextWysiwyg = rCpy.bTextWysiwyg; +/*N*/ bReplCellsWarn = rCpy.bReplCellsWarn; +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator>>( SvStream& rStream, ScInputOptions& rOpt ) +/*N*/ { +/*N*/ rOpt.SetDefaults(); +/*N*/ +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ rStream >> rOpt.nMoveDir; +/*N*/ rStream >> rOpt.bMoveSelection; +/*N*/ rStream >> rOpt.bEnterEdit; +/*N*/ rStream >> rOpt.bExtendFormat; +/*N*/ +/*N*/ if (aHdr.BytesLeft()) +/*N*/ rStream >> rOpt.bRangeFinder; // ab 363 +/*N*/ +/*N*/ if (aHdr.BytesLeft()) +/*N*/ rStream >> rOpt.bExpandRefs; // ab 364v +/*N*/ +/*N*/ if (aHdr.BytesLeft()) +/*N*/ rStream >> rOpt.bMarkHeader; // ab 364irgendwas +/*N*/ +/*N*/ if (aHdr.BytesLeft()) +/*N*/ rStream >> rOpt.bUseTabCol; // ab 373d +/*N*/ +/*N*/ // newer additions are not in old file format +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator<<( SvStream& rStream, const ScInputOptions& rOpt ) +/*N*/ { +/*N*/ ScWriteHeader aHdr( rStream, 6 ); +/*N*/ +/*N*/ rStream << rOpt.nMoveDir; +/*N*/ rStream << rOpt.bMoveSelection; +/*N*/ rStream << rOpt.bEnterEdit; +/*N*/ rStream << rOpt.bExtendFormat; +/*N*/ rStream << rOpt.bRangeFinder; +/*N*/ rStream << rOpt.bExpandRefs; +/*N*/ rStream << rOpt.bMarkHeader; +/*N*/ rStream << rOpt.bUseTabCol; +/*N*/ +/*N*/ // newer additions are not in old file format +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//================================================================== +// Config Item containing input options +//================================================================== + +#define CFGPATH_INPUT "Office.Calc/Input" + +#define SCINPUTOPT_MOVEDIR 0 +#define SCINPUTOPT_MOVESEL 1 +#define SCINPUTOPT_EDTEREDIT 2 +#define SCINPUTOPT_EXTENDFMT 3 +#define SCINPUTOPT_RANGEFIND 4 +#define SCINPUTOPT_EXPANDREFS 5 +#define SCINPUTOPT_MARKHEADER 6 +#define SCINPUTOPT_USETABCOL 7 +#define SCINPUTOPT_TEXTWYSIWYG 8 +#define SCINPUTOPT_REPLCELLSWARN 9 +#define SCINPUTOPT_COUNT 10 + +/*N*/ Sequence<OUString> ScInputCfg::GetPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "MoveSelectionDirection", // SCINPUTOPT_MOVEDIR +/*N*/ "MoveSelection", // SCINPUTOPT_MOVESEL +/*N*/ "SwitchToEditMode", // SCINPUTOPT_EDTEREDIT +/*N*/ "ExpandFormatting", // SCINPUTOPT_EXTENDFMT +/*N*/ "ShowReference", // SCINPUTOPT_RANGEFIND +/*N*/ "ExpandReference", // SCINPUTOPT_EXPANDREFS +/*N*/ "HighlightSelection", // SCINPUTOPT_MARKHEADER +/*N*/ "UseTabCol", // SCINPUTOPT_USETABCOL +/*N*/ "UsePrinterMetrics", // SCINPUTOPT_TEXTWYSIWYG +/*N*/ "ReplaceCellsWarning" // SCINPUTOPT_REPLCELLSWARN +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCINPUTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCINPUTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ ScInputCfg::ScInputCfg() : +/*N*/ ConfigItem( OUString::createFromAscii( CFGPATH_INPUT ) ) +/*N*/ { +/*N*/ sal_Int32 nIntVal; +/*N*/ +/*N*/ Sequence<OUString> aNames = GetPropertyNames(); +/*N*/ Sequence<Any> aValues = GetProperties(aNames); +/*N*/ EnableNotification(aNames); +/*N*/ const Any* pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCINPUTOPT_MOVEDIR: +/*N*/ if ( pValues[nProp] >>= nIntVal ) +/*N*/ SetMoveDir( (USHORT)nIntVal ); +/*N*/ break; +/*N*/ case SCINPUTOPT_MOVESEL: +/*N*/ SetMoveSelection( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_EDTEREDIT: +/*N*/ SetEnterEdit( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_EXTENDFMT: +/*N*/ SetExtendFormat( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_RANGEFIND: +/*N*/ SetRangeFinder( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_EXPANDREFS: +/*N*/ SetExpandRefs( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_MARKHEADER: +/*N*/ SetMarkHeader( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_USETABCOL: +/*N*/ SetUseTabCol( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_TEXTWYSIWYG: +/*N*/ SetTextWysiwyg( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCINPUTOPT_REPLCELLSWARN: +/*N*/ SetReplaceCellsWarn( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +void ScInputCfg::Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames ) {} +void ScInputCfg::Commit() {} + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_interpr1.cxx b/binfilter/bf_sc/source/core/tool/sc_interpr1.cxx new file mode 100644 index 000000000000..6cb607abc1d0 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_interpr1.cxx @@ -0,0 +1,5432 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#ifdef RS6000 +#pragma options FLTTRAP +#include <fptrap.h> +#include <fpxcp.h> +#endif + +#include "scitems.hxx" +#include <bf_svx/langitem.hxx> +#include <bf_svx/algitem.hxx> +#include <unotools/textsearch.hxx> +#include <bf_svtools/zformat.hxx> +#include <tools/solar.h> +#include <bf_sfx2/docfile.hxx> +#include <bf_sfx2/printer.hxx> + +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#include "interpre.hxx" +#include "patattr.hxx" +#include "dociter.hxx" +#include "scmatrix.hxx" +#include "docoptio.hxx" +#include "globstr.hrc" +#include "attrib.hxx" +namespace binfilter { + + +// PI jetzt als F_PI aus solar.h +//#define PI 3.1415926535897932 +//#define MINVALUE 1.7e-307 +//#define SQRT_2_PI 2.506628274631000 + +// globale Variablen + +/*N*/ #ifdef _MSC_VER +/*N*/ #pragma code_seg("SCSTATICS") +/*N*/ #endif + +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScTokenStack, 8, 4 ) +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScErrorStack, 8, 4 ) +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScInterpreter, 32, 16 ) + +/*N*/ #ifdef _MSC_VER +/*N*/ #pragma code_seg() +/*N*/ #endif + +/*N*/ ScTokenStack* ScInterpreter::pGlobalStack = NULL; +/*N*/ ScErrorStack* ScInterpreter::pGlobalErrorStack = NULL; +/*N*/ BOOL ScInterpreter::bGlobalStackInUse = FALSE; + + +//----------------------------------------------------------------------------- +// Funktionen +//----------------------------------------------------------------------------- + + +/*N*/ void ScInterpreter::ScIfJump() +/*N*/ { +/*N*/ const short* pJump = pCur->GetJump(); +/*N*/ short nJumpCount = pJump[ 0 ]; +/*N*/ if ( GetBool() ) +/*N*/ { // TRUE +/*N*/ if( nJumpCount >= 2 ) +/*N*/ { // then Zweig +/*N*/ nFuncFmtType = NUMBERFORMAT_UNDEFINED; +/*N*/ aCode.Jump( pJump[ 1 ], pJump[ nJumpCount ] ); +/*N*/ } +/*N*/ else +/*N*/ { // kein Parameter fuer then +/*?*/ nFuncFmtType = NUMBERFORMAT_LOGICAL; +/*?*/ PushInt(1); +/*?*/ aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // FALSE +/*N*/ if( nJumpCount == 3 ) +/*N*/ { // else Zweig +/*N*/ nFuncFmtType = NUMBERFORMAT_UNDEFINED; +/*N*/ aCode.Jump( pJump[ 2 ], pJump[ nJumpCount ] ); +/*N*/ } +/*N*/ else +/*N*/ { // kein Parameter fuer else +/*?*/ nFuncFmtType = NUMBERFORMAT_LOGICAL; +/*?*/ PushInt(0); +/*?*/ aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] ); +/*N*/ } +/*N*/ } +/*N*/ } + + +void ScInterpreter::ScChoseJump() +{ + const short* pJump = pCur->GetJump(); + short nJumpCount = pJump[ 0 ]; + double nJumpIndex = ::rtl::math::approxFloor( GetDouble() ); + if ((nJumpIndex >= 1) && (nJumpIndex < nJumpCount)) + aCode.Jump( pJump[ (short) nJumpIndex ], pJump[ nJumpCount ] ); + else + SetError(errIllegalArgument); +} + + +/*N*/ short ScInterpreter::CompareFunc( const ScCompare& rComp ) +/*N*/ { +/*N*/ short nRes = 0; +/*N*/ if ( rComp.bEmpty[ 0 ] ) +/*N*/ { +/*?*/ if ( rComp.bEmpty[ 1 ] ) +/*?*/ ; // leere Zelle == leere Zelle, nRes 0 +/*?*/ else if( rComp.bVal[ 1 ] ) +/*?*/ { +/*?*/ if ( !::rtl::math::approxEqual( rComp.nVal[ 1 ], 0.0 ) ) +/*?*/ { +/*?*/ if ( rComp.nVal[ 1 ] < 0.0 ) +/*?*/ nRes = 1; // leere Zelle > -x +/*?*/ else +/*?*/ nRes = -1; // leere Zelle < x +/*?*/ } +/*?*/ // else: leere Zelle == 0.0 +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ if ( rComp.pVal[ 1 ]->Len() ) +/*?*/ nRes = -1; // leere Zelle < "..." +/*?*/ // else: leere Zelle == "" +/*?*/ } +/*N*/ } +/*N*/ else if ( rComp.bEmpty[ 1 ] ) +/*N*/ { +/*N*/ if( rComp.bVal[ 0 ] ) +/*N*/ { +/*N*/ if ( !::rtl::math::approxEqual( rComp.nVal[ 0 ], 0.0 ) ) +/*N*/ { +/*N*/ if ( rComp.nVal[ 0 ] < 0.0 ) +/*N*/ nRes = -1; // -x < leere Zelle +/*N*/ else +/*N*/ nRes = 1; // x > leere Zelle +/*N*/ } +/*N*/ // else: leere Zelle == 0.0 +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ if ( rComp.pVal[ 0 ]->Len() ) +/*?*/ nRes = 1; // "..." > leere Zelle +/*?*/ // else: "" == leere Zelle +/*N*/ } +/*N*/ } +/*N*/ else if( rComp.bVal[ 0 ] ) +/*N*/ { +/*N*/ if( rComp.bVal[ 1 ] ) +/*N*/ { +/*N*/ if ( !::rtl::math::approxEqual( rComp.nVal[ 0 ], rComp.nVal[ 1 ] ) ) +/*N*/ { +/*N*/ if( rComp.nVal[ 0 ] - rComp.nVal[ 1 ] < 0 ) +/*N*/ nRes = -1; +/*N*/ else +/*N*/ nRes = 1; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ nRes = -1; // Zahl ist kleiner als String +/*N*/ } +/*N*/ else if( rComp.bVal[ 1 ] ) +/*N*/ nRes = 1; // Zahl ist kleiner als String +/*N*/ else +/*N*/ { +/*N*/ if (pDok->GetDocOptions().IsIgnoreCase()) +/*?*/ nRes = (short) ScGlobal::pCollator->compareString( +/*?*/ *rComp.pVal[ 0 ], *rComp.pVal[ 1 ] ); +/*N*/ else +/*?*/ nRes = (short) ScGlobal::pCaseCollator->compareString( +/*?*/ *rComp.pVal[ 0 ], *rComp.pVal[ 1 ] ); +/*N*/ } +/*N*/ return nRes; +/*N*/ } + + +/*N*/ short ScInterpreter::Compare() +/*N*/ { +/*N*/ nCurFmtType = nFuncFmtType = NUMBERFORMAT_LOGICAL; +/*N*/ String aVal1, aVal2; +/*N*/ ScCompare aComp( &aVal1, &aVal2 ); +/*N*/ for( short i = 1; i >= 0; i-- ) +/*N*/ { +/*N*/ switch ( GetStackType() ) +/*N*/ { +/*N*/ case svDouble: +/*N*/ aComp.nVal[ i ] = GetDouble(); +/*N*/ aComp.bVal[ i ] = TRUE; +/*N*/ break; +/*N*/ case svString: +/*N*/ *aComp.pVal[ i ] = GetString(); +/*N*/ aComp.bVal[ i ] = FALSE; +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ case svSingleRef : +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ if ( !PopDoubleRefOrSingleRef( aAdr ) ) +/*N*/ break; +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) +/*N*/ { +/*N*/ if (HasCellStringData(pCell)) +/*N*/ { +/*N*/ GetCellString(*aComp.pVal[ i ], pCell); +/*N*/ aComp.bVal[ i ] = FALSE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aComp.nVal[ i ] = GetCellValue( aAdr, pCell ); +/*N*/ aComp.bVal[ i ] = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ aComp.bEmpty[ i ] = TRUE; +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ SetError(errIllegalParameter); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if( nGlobalError ) +/*N*/ return 0; +/*N*/ return CompareFunc( aComp ); +/*N*/ } + + +ScMatrix* ScInterpreter::CompareMat() +{ + nCurFmtType = nFuncFmtType = NUMBERFORMAT_LOGICAL; + String aVal1, aVal2; + ScCompare aComp( &aVal1, &aVal2 ); + ScMatrix* pMat[2]; + pMat[0] = pMat[1] = NULL; + USHORT nMatInd[2]; + BOOL bTmpMat[2]; + bTmpMat[0] = bTmpMat[1] = FALSE; + ScAddress aAdr; + for( short i = 1; i >= 0; i-- ) + { + switch (GetStackType()) + { + case svDouble: + aComp.nVal[ i ] = GetDouble(); + aComp.bVal[ i ] = TRUE; + break; + case svString: + *aComp.pVal[ i ] = GetString(); + aComp.bVal[ i ] = FALSE; + break; + case svSingleRef: + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) + { + if (HasCellStringData(pCell)) + { + GetCellString(*aComp.pVal[ i ], pCell); + aComp.bVal[ i ] = FALSE; + } + else + { + aComp.nVal[ i ] = GetCellValue( aAdr, pCell ); + aComp.bVal[ i ] = TRUE; + } + } + else + aComp.bEmpty[ i ] = TRUE; + } + break; + case svDoubleRef: + bTmpMat[ i ] = TRUE; + case svMatrix: + pMat[ i ] = GetMatrix( nMatInd[ i ] ); + if ( !pMat[ i ] ) + SetError(errIllegalParameter); + break; + default: + SetError(errIllegalParameter); + break; + } + } + ScMatrix* pResMat = NULL; + if( !nGlobalError ) + { + USHORT nResMatInd; + if ( pMat[0] && pMat[1] ) + { + USHORT nC0, nR0, nC1, nR1; + pMat[0]->GetDimensions( nC0, nR0 ); + pMat[1]->GetDimensions( nC1, nR1 ); + USHORT nC = Max( nC0, nC1 ); + USHORT nR = Max( nR0, nR1 ); + pResMat = GetNewMat( nC, nR, nResMatInd ); + if ( !pResMat ) + return NULL; + for ( USHORT j=0; j<nC; j++ ) + { + for ( USHORT k=0; k<nR; k++ ) + { + if ( j < nC0 && j < nC1 && k < nR0 && k < nR1 ) + { + for ( short i=1; i>=0; i-- ) + { + if ( pMat[i]->IsString(j,k) ) + { + aComp.bVal[i] = FALSE; + *aComp.pVal[i] = pMat[i]->GetString(j,k); + aComp.bEmpty[i] = pMat[i]->IsEmpty(j,k); + } + else + { + aComp.bVal[i] = TRUE; + aComp.nVal[i] = pMat[i]->GetDouble(j,k); + aComp.bEmpty[i] = FALSE; + } + } + pResMat->PutDouble( CompareFunc( aComp ), j,k ); + } + else + pResMat->PutString( ScGlobal::GetRscString(STR_NO_VALUE), j,k ); + } + } + nRetMat = nResMatInd; + } + else if ( pMat[0] || pMat[1] ) + { + short i = ( pMat[0] ? 0 : 1); + USHORT nC, nR; + pMat[i]->GetDimensions( nC, nR ); + pResMat = GetNewMat( nC, nR, nResMatInd ); + if ( !pResMat ) + return NULL; + ULONG n = (ULONG) nC * nR; + for ( ULONG j=0; j<n; j++ ) + { + if ( pMat[i]->IsValue(j) ) + { + aComp.bVal[i] = TRUE; + aComp.nVal[i] = pMat[i]->GetDouble(j); + aComp.bEmpty[i] = FALSE; + } + else + { + aComp.bVal[i] = FALSE; + *aComp.pVal[i] = pMat[i]->GetString(j); + aComp.bEmpty[i] = pMat[i]->IsEmpty(j); + } + pResMat->PutDouble( CompareFunc( aComp ), j ); + } + nRetMat = nResMatInd; + } + } + for( short x=1; x >= 0; x-- ) + { + if ( bTmpMat[x] && pMat[x] ) + { + delete pMat[x]; + ResetNewMat( nMatInd[x] ); + } + } + return pResMat; +} + + +/*N*/ void ScInterpreter::ScEqual() +/*N*/ { +/*N*/ StackVar eType; +/*N*/ if ( ((eType = GetStackType(2)) == svMatrix) || +/*N*/ (bMatrixFormula && eType == svDoubleRef) || +/*N*/ ((eType = GetStackType(1)) == svMatrix) || +/*N*/ (bMatrixFormula && eType == svDoubleRef) +/*N*/ ) +/*N*/ { +/*?*/ ScMatrix* pMat = CompareMat(); +/*?*/ if ( !pMat ) +/*?*/ SetIllegalParameter(); +/*?*/ else +/*?*/ { +/*?*/ pMat->CompareEqual(); +/*?*/ PushMatrix( pMat ); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ PushInt( Compare() == 0 ); +/*N*/ } + + +/*N*/ void ScInterpreter::ScNotEqual() +/*N*/ { +/*N*/ StackVar eType; +/*N*/ if ( ((eType = GetStackType(2)) == svMatrix) || +/*N*/ (bMatrixFormula && eType == svDoubleRef) || +/*N*/ ((eType = GetStackType(1)) == svMatrix) || +/*N*/ (bMatrixFormula && eType == svDoubleRef) +/*N*/ ) +/*N*/ { +/*?*/ ScMatrix* pMat = CompareMat(); +/*?*/ if ( !pMat ) +/*?*/ SetIllegalParameter(); +/*?*/ else +/*?*/ { +/*?*/ pMat->CompareNotEqual(); +/*?*/ PushMatrix( pMat ); +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ PushInt( Compare() != 0 ); +/*N*/ } + + +void ScInterpreter::ScLess() +{ + StackVar eType; + if ( ((eType = GetStackType(2)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) || + ((eType = GetStackType(1)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) + ) + { + ScMatrix* pMat = CompareMat(); + if ( !pMat ) + SetIllegalParameter(); + else + { + pMat->CompareLess(); + PushMatrix( pMat ); + } + } + else + PushInt( Compare() < 0 ); +} + + +void ScInterpreter::ScGreater() +{ + StackVar eType; + if ( ((eType = GetStackType(2)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) || + ((eType = GetStackType(1)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) + ) + { + ScMatrix* pMat = CompareMat(); + if ( !pMat ) + SetIllegalParameter(); + else + { + pMat->CompareGreater(); + PushMatrix( pMat ); + } + } + else + PushInt( Compare() > 0 ); +} + + +void ScInterpreter::ScLessEqual() +{ + StackVar eType; + if ( ((eType = GetStackType(2)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) || + ((eType = GetStackType(1)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) + ) + { + ScMatrix* pMat = CompareMat(); + if ( !pMat ) + SetIllegalParameter(); + else + { + pMat->CompareLessEqual(); + PushMatrix( pMat ); + } + } + else + PushInt( Compare() <= 0 ); +} + + +void ScInterpreter::ScGreaterEqual() +{ + StackVar eType; + if ( ((eType = GetStackType(2)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) || + ((eType = GetStackType(1)) == svMatrix) || + (bMatrixFormula && eType == svDoubleRef) + ) + { + ScMatrix* pMat = CompareMat(); + if ( !pMat ) + SetIllegalParameter(); + else + { + pMat->CompareGreaterEqual(); + PushMatrix( pMat ); + } + } + else + PushInt( Compare() >= 0 ); +} + + +void ScInterpreter::ScAnd() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + BYTE nParamCount = GetByte(); + if ( MustHaveParamCountMin( nParamCount, 1 ) ) + { + BOOL bHaveValue = FALSE; + short nRes = TRUE; + while( nParamCount-- ) + { + if ( !nGlobalError ) + { + switch ( GetStackType() ) + { + case svDouble : + bHaveValue = TRUE; + nRes &= ( PopDouble() != 0.0 ); + break; + case svString : + Pop(); + SetError( errNoValue ); + break; + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + if ( !nGlobalError ) + { + ScBaseCell* pCell = GetCell( aAdr ); + if ( HasCellValueData( pCell ) ) + { + bHaveValue = TRUE; + nRes &= ( GetCellValue( aAdr, pCell ) != 0.0 ); + } + // else: Xcl setzt hier keinen Fehler + } + } + break; + case svDoubleRef: + { + ScRange aRange; + PopDoubleRef( aRange ); + if ( !nGlobalError ) + { + double fVal; + USHORT nErr = 0; + ScValueIterator aValIter( pDok, aRange ); + if ( aValIter.GetFirst( fVal, nErr ) ) + { + bHaveValue = TRUE; + do + { + nRes &= ( fVal != 0.0 ); + } while ( (nErr == 0) && + aValIter.GetNext( fVal, nErr ) ); + } + SetError( nErr ); + } + } + break; + case svMatrix: + { + USHORT nMatInd; + ScMatrix* pMat = GetMatrix( nMatInd ); + if ( pMat ) + { + bHaveValue = TRUE; + nRes &= pMat->And(); + } + // else: GetMatrix hat errIllegalParameter gesetzt + } + break; + default: + Pop(); + SetError( errIllegalParameter ); + } + } + else + Pop(); + } + if ( bHaveValue ) + PushInt( nRes ); + else + SetNoValue(); + } +} + + +void ScInterpreter::ScOr() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + BYTE nParamCount = GetByte(); + if ( MustHaveParamCountMin( nParamCount, 1 ) ) + { + BOOL bHaveValue = FALSE; + short nRes = FALSE; + while( nParamCount-- ) + { + if ( !nGlobalError ) + { + switch ( GetStackType() ) + { + case svDouble : + bHaveValue = TRUE; + nRes |= ( PopDouble() != 0.0 ); + break; + case svString : + Pop(); + SetError( errNoValue ); + break; + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + if ( !nGlobalError ) + { + ScBaseCell* pCell = GetCell( aAdr ); + if ( HasCellValueData( pCell ) ) + { + bHaveValue = TRUE; + nRes |= ( GetCellValue( aAdr, pCell ) != 0.0 ); + } + // else: Xcl setzt hier keinen Fehler + } + } + break; + case svDoubleRef: + { + ScRange aRange; + PopDoubleRef( aRange ); + if ( !nGlobalError ) + { + double fVal; + USHORT nErr = 0; + ScValueIterator aValIter( pDok, aRange ); + if ( aValIter.GetFirst( fVal, nErr ) ) + { + bHaveValue = TRUE; + do + { + nRes |= ( fVal != 0.0 ); + } while ( (nErr == 0) && + aValIter.GetNext( fVal, nErr ) ); + } + SetError( nErr ); + } + } + break; + case svMatrix: + { + bHaveValue = TRUE; + USHORT nMatInd; + ScMatrix* pMat = GetMatrix( nMatInd ); + if ( pMat ) + { + bHaveValue = TRUE; + nRes |= pMat->Or(); + } + // else: GetMatrix hat errIllegalParameter gesetzt + } + break; + default: + Pop(); + SetError( errIllegalParameter ); + } + } + else + Pop(); + } + if ( bHaveValue ) + PushInt( nRes ); + else + SetNoValue(); + } +} + + +void ScInterpreter::ScNeg() +{ + MatrixDoubleRefToMatrix(); + switch ( GetStackType() ) + { + case svMatrix : + { + USHORT nMatInd; + ScMatrix* pMat = GetMatrix( nMatInd ); + if ( pMat ) + { + USHORT nC, nR; + pMat->GetDimensions( nC, nR ); + USHORT nResMat; + ScMatrix* pResMat = GetNewMat( nC, nR, nResMat ); + if ( !pResMat ) + SetNoValue(); + else + { + ULONG nCount = nC * nR; + for ( ULONG j=0; j<nCount; ++j ) + { + if ( pMat->IsValueOrEmpty(j) ) + pResMat->PutDouble( -pMat->GetDouble(j), j ); + else + pResMat->PutString( + ScGlobal::GetRscString( STR_NO_VALUE ), j ); + } + nRetMat = nResMat; + PushMatrix( pResMat ); + } + } + } + break; + default: + PushDouble( -GetDouble() ); + } +} + + +void ScInterpreter::ScPercentSign() +{ + nFuncFmtType = NUMBERFORMAT_PERCENT; + const ScToken* pSaveCur = pCur; + BYTE nSavePar = cPar; + PushInt( 100 ); + cPar = 2; + ScByteToken aDivOp( ocDiv, cPar ); + pCur = &aDivOp; + ScDiv(); + pCur = pSaveCur; + cPar = nSavePar; +} + + +void ScInterpreter::ScNot() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + PushInt( GetDouble() == 0.0 ); +} + + +/*N*/ void ScInterpreter::ScPi() +/*N*/ { +/*N*/ PushDouble(F_PI); +/*N*/ } + + +void ScInterpreter::ScRandom() +{ + PushDouble((double)rand() / RAND_MAX); +} + + +void ScInterpreter::ScTrue() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + PushInt(1); +} + + +void ScInterpreter::ScFalse() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + PushInt(0); +} + + +void ScInterpreter::ScDeg() +{ + PushDouble((GetDouble() / F_PI) * 180.0); +} + + +void ScInterpreter::ScRad() +{ + PushDouble(GetDouble() * (F_PI / 180)); +} + + +/*N*/ void ScInterpreter::ScSin() +/*N*/ { +/*N*/ PushDouble(::rtl::math::sin(GetDouble())); +/*N*/ } + + +void ScInterpreter::ScCos() +{ + PushDouble(::rtl::math::cos(GetDouble())); +} + + +void ScInterpreter::ScTan() +{ + PushDouble(::rtl::math::tan(GetDouble())); +} + + +void ScInterpreter::ScCot() +{ + PushDouble(1.0 / ::rtl::math::tan(GetDouble())); +} + + +void ScInterpreter::ScArcSin() +{ + PushDouble(asin(GetDouble())); +} + + +void ScInterpreter::ScArcCos() +{ + PushDouble(acos(GetDouble())); +} + + +void ScInterpreter::ScArcTan() +{ + PushDouble(atan(GetDouble())); +} + + +void ScInterpreter::ScArcCot() +{ + PushDouble((F_PI2) - atan(GetDouble())); +} + + +void ScInterpreter::ScSinHyp() +{ + PushDouble(sinh(GetDouble())); +} + + +void ScInterpreter::ScCosHyp() +{ + PushDouble(cosh(GetDouble())); +} + + +void ScInterpreter::ScTanHyp() +{ + PushDouble(tanh(GetDouble())); +} + + +void ScInterpreter::ScCotHyp() +{ + PushDouble(1.0 / tanh(GetDouble())); +} + + +void ScInterpreter::ScArcSinHyp() +{ + double nVal = GetDouble(); + PushDouble(log(nVal + sqrt((nVal * nVal) + 1.0))); +} + + +void ScInterpreter::ScArcCosHyp() +{ + double nVal = GetDouble(); + if (nVal < 1.0) + SetIllegalArgument(); + else + PushDouble(log(nVal + sqrt((nVal * nVal) - 1.0))); +} + + +void ScInterpreter::ScArcTanHyp() +{ + double nVal = GetDouble(); + if (fabs(nVal) >= 1.0) + SetIllegalArgument(); + else + PushDouble(0.5 * log((1.0 + nVal) / (1.0 - nVal))); +} + + +void ScInterpreter::ScArcCotHyp() +{ + double nVal = GetDouble(); + if (fabs(nVal) <= 1.0) + SetIllegalArgument(); + else + PushDouble(0.5 * log((nVal + 1.0) / (nVal - 1.0))); +} + + +void ScInterpreter::ScExp() +{ + PushDouble(exp(GetDouble())); +} + + +void ScInterpreter::ScSqrt() +{ + double fVal = GetDouble(); + if (fVal >= 0.0) + PushDouble(sqrt(fVal)); + else + SetIllegalArgument(); +} + + +void ScInterpreter::ScIsEmpty() +{ + short nRes = 0; + nFuncFmtType = NUMBERFORMAT_LOGICAL; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + CellType eCellType = GetCellType( GetCell( aAdr ) ); + if((eCellType == CELLTYPE_NONE) || (eCellType == CELLTYPE_NOTE)) + nRes = 1; + } + break; + default: + Pop(); + } + nGlobalError = 0; + PushInt( nRes ); +} + + +short ScInterpreter::IsString() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + ScBaseCell* pCell = GetCell( aAdr ); + if (GetCellErrCode( pCell ) == 0) + { + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_STRING : + case CELLTYPE_EDIT : + nRes = 1; + break; + case CELLTYPE_FORMULA : + nRes = !((ScFormulaCell*)pCell)->IsValue(); + break; + } + } + } + break; + case svString: + PopError(); + if ( !nGlobalError ) + nRes = 1; + break; + default: + Pop(); + } + nGlobalError = 0; + return nRes; +} + + +void ScInterpreter::ScIsString() +{ + PushInt( IsString() ); +} + + +void ScInterpreter::ScIsNonString() +{ + PushInt( !IsString() ); +} + + +void ScInterpreter::ScIsLogical(UINT16 aOldNumType) +{ + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + ScBaseCell* pCell = GetCell( aAdr ); + if (GetCellErrCode( pCell ) == 0) + { + if (HasCellValueData(pCell)) + { + ULONG nFormat = GetCellNumberFormat( aAdr, pCell ); + nRes = ( pFormatter->GetType(nFormat) + == NUMBERFORMAT_LOGICAL); + } + } + } + break; + default: + PopError(); + if ( !nGlobalError ) + nRes = ( nCurFmtType == NUMBERFORMAT_LOGICAL ); + } + nCurFmtType = nFuncFmtType = NUMBERFORMAT_LOGICAL; + nGlobalError = 0; + PushInt( nRes ); +} + + +void ScInterpreter::ScType() +{ + short nType = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + ScBaseCell* pCell = GetCell( aAdr ); + if (GetCellErrCode( pCell ) == 0) + { + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_STRING : + case CELLTYPE_EDIT : + nType = 2; + break; + case CELLTYPE_VALUE : + { + ULONG nFormat = GetCellNumberFormat( aAdr, pCell ); + if (pFormatter->GetType(nFormat) + == NUMBERFORMAT_LOGICAL) + nType = 4; + else + nType = 1; + } + break; + case CELLTYPE_FORMULA : + nType = 8; + break; + default: + SetIllegalParameter(); + } + } + else + nType = 16; + } + break; + case svString: + PopError(); + if ( nGlobalError ) + { + nType = 16; + nGlobalError = 0; + } + else + nType = 2; + break; + default: + PopError(); + if ( nGlobalError ) + { + nType = 16; + nGlobalError = 0; + } + else + nType = 1; + } + PushInt( nType ); +} + + +inline BOOL lcl_FormatHasNegColor( const SvNumberformat* pFormat ) +{ + return pFormat && pFormat->GetColor( 1 ); +} + + +inline BOOL lcl_FormatHasOpenPar( const SvNumberformat* pFormat ) +{ + return pFormat && (pFormat->GetFormatstring().Search( '(' ) != STRING_NOTFOUND); +} + + +void ScInterpreter::ScCell() +{ // ATTRIBUTE ; [REF] + BYTE nParamCount = GetByte(); + if( MustHaveParamCount( nParamCount, 1, 2 ) ) + { + ScAddress aCellPos( aPos ); + BOOL bError = FALSE; + if( nParamCount == 2 ) + bError = !PopDoubleRefOrSingleRef( aCellPos ); + String aInfoType( GetString() ); + if( bError || nGlobalError ) + SetIllegalParameter(); + else + { + String aResult; + ScBaseCell* pCell = GetCell( aCellPos ); + + aInfoType.ToUpperAscii(); + +// *** ADDRESS INFO *** + if( aInfoType.EqualsAscii( "COL" ) ) + { // column number (1-based) + PushInt( aCellPos.Col() + 1 ); + } + else if( aInfoType.EqualsAscii( "ROW" ) ) + { // row number (1-based) + PushInt( aCellPos.Row() + 1 ); + } + else if( aInfoType.EqualsAscii( "SHEET" ) ) + { // table number (1-based) + PushInt( aCellPos.Tab() + 1 ); + } + else if( aInfoType.EqualsAscii( "ADDRESS" ) ) + { // address formatted as [['FILENAME'#]$TABLE.]$COL$ROW + USHORT nFlags = (aCellPos.Tab() == aPos.Tab()) ? (SCA_ABS) : (SCA_ABS_3D); + aCellPos.Format( aResult, nFlags, pDok ); + PushString( aResult ); + } + else if( aInfoType.EqualsAscii( "FILENAME" ) ) + { // file name and table name: 'FILENAME'#$TABLE + USHORT nTab = aCellPos.Tab(); + if( nTab < pDok->GetTableCount() ) + { + if( pDok->GetLinkMode( nTab ) == SC_LINK_VALUE ) + pDok->GetName( nTab, aResult ); + else + { + SfxObjectShell* pShell = pDok->GetDocumentShell(); + if( pShell && pShell->GetMedium() ) + { + aResult = (sal_Unicode) '\''; + aResult += pShell->GetMedium()->GetName(); + aResult.AppendAscii( "'#$" ); + String aTabName; + pDok->GetName( nTab, aTabName ); + aResult += aTabName; + } + } + } + PushString( aResult ); + } + else if( aInfoType.EqualsAscii( "COORD" ) ) + { // address, lotus 1-2-3 formatted: $TABLE:$COL$ROW + ScAddress( aCellPos.Tab(), 0, 0 ).Format( aResult, (SCA_COL_ABSOLUTE|SCA_VALID_COL) ); + aResult += ':'; + String aCellStr; + aCellPos.Format( aCellStr, (SCA_COL_ABSOLUTE|SCA_VALID_COL|SCA_ROW_ABSOLUTE|SCA_VALID_ROW) ); + aResult += aCellStr; + PushString( aResult ); + } + +// *** CELL PROPERTIES *** + else if( aInfoType.EqualsAscii( "CONTENTS" ) ) + { // contents of the cell, no formatting + if( pCell && pCell->HasStringData() ) + { + GetCellString( aResult, pCell ); + PushString( aResult ); + } + else + PushDouble( GetCellValue( aCellPos, pCell ) ); + } + else if( aInfoType.EqualsAscii( "TYPE" ) ) + { // b = blank; l = string (label); v = otherwise (value) + if( HasCellStringData( pCell ) ) + aResult = 'l'; + else + aResult = HasCellValueData( pCell ) ? 'v' : 'b'; + PushString( aResult ); + } + else if( aInfoType.EqualsAscii( "WIDTH" ) ) + { // column width (rounded off as count of zero characters in standard font and size) + Printer* pPrinter = pDok->GetPrinter(); + MapMode aOldMode( pPrinter->GetMapMode() ); + Font aOldFont( pPrinter->GetFont() ); + Font aDefFont; + + pPrinter->SetMapMode( MAP_TWIP ); + // font color doesn't matter here + pDok->GetDefPattern()->GetFont( aDefFont, SC_AUTOCOL_BLACK, pPrinter ); + pPrinter->SetFont( aDefFont ); + long nZeroWidth = pPrinter->GetTextWidth( String( '0' ) ); + pPrinter->SetFont( aOldFont ); + pPrinter->SetMapMode( aOldMode ); + int nZeroCount = (int)(pDok->GetColWidth( aCellPos.Col(), aCellPos.Tab() ) / nZeroWidth); + PushInt( nZeroCount ); + } + else if( aInfoType.EqualsAscii( "PREFIX" ) ) + { // ' = left; " = right; ^ = centered + if( HasCellStringData( pCell ) ) + { + const SvxHorJustifyItem* pJustAttr = (const SvxHorJustifyItem*) + pDok->GetAttr( aCellPos.Col(), aCellPos.Row(), aCellPos.Tab(), ATTR_HOR_JUSTIFY ); + switch( pJustAttr->GetValue() ) + { + case SVX_HOR_JUSTIFY_STANDARD: + case SVX_HOR_JUSTIFY_LEFT: + case SVX_HOR_JUSTIFY_BLOCK: aResult = '\''; break; + case SVX_HOR_JUSTIFY_CENTER: aResult = '^'; break; + case SVX_HOR_JUSTIFY_RIGHT: aResult = '"'; break; + case SVX_HOR_JUSTIFY_REPEAT: aResult = '\\'; break; + } + } + PushString( aResult ); + } + else if( aInfoType.EqualsAscii( "PROTECT" ) ) + { // 1 = cell locked + const ScProtectionAttr* pProtAttr = (const ScProtectionAttr*) + pDok->GetAttr( aCellPos.Col(), aCellPos.Row(), aCellPos.Tab(), ATTR_PROTECTION ); + PushInt( pProtAttr->GetProtection() ? 1 : 0 ); + } + +// *** FORMATTING *** + else if( aInfoType.EqualsAscii( "FORMAT" ) ) + { // specific format code for standard formats + ULONG nFormat = pDok->GetNumberFormat( aCellPos ); + BOOL bAppendPrec = TRUE; + USHORT nPrec, nLeading; + BOOL bThousand, bIsRed; + pFormatter->GetFormatSpecialInfo( nFormat, bThousand, bIsRed, nPrec, nLeading ); + + switch( pFormatter->GetType( nFormat ) ) + { + case NUMBERFORMAT_NUMBER: aResult = (bThousand ? ',' : 'F'); break; + case NUMBERFORMAT_CURRENCY: aResult = 'C'; break; + case NUMBERFORMAT_SCIENTIFIC: aResult = 'S'; break; + case NUMBERFORMAT_PERCENT: aResult = 'P'; break; + default: + { + bAppendPrec = FALSE; + switch( pFormatter->GetIndexTableOffset( nFormat ) ) + { + case NF_DATE_SYSTEM_SHORT: + case NF_DATE_SYS_DMMMYY: + case NF_DATE_SYS_DDMMYY: + case NF_DATE_SYS_DDMMYYYY: + case NF_DATE_SYS_DMMMYYYY: + case NF_DATE_DIN_DMMMYYYY: + case NF_DATE_SYS_DMMMMYYYY: + case NF_DATE_DIN_DMMMMYYYY: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D1" ) ); break; + case NF_DATE_SYS_DDMMM: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D2" ) ); break; + case NF_DATE_SYS_MMYY: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D3" ) ); break; + case NF_DATETIME_SYSTEM_SHORT_HHMM: + case NF_DATETIME_SYS_DDMMYYYY_HHMMSS: + aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D4" ) ); break; + case NF_DATE_DIN_MMDD: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D5" ) ); break; + case NF_TIME_HHMMSSAMPM: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D6" ) ); break; + case NF_TIME_HHMMAMPM: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D7" ) ); break; + case NF_TIME_HHMMSS: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D8" ) ); break; + case NF_TIME_HHMM: aResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D9" ) ); break; + default: aResult = 'G'; + } + } + } + if( bAppendPrec ) + aResult += String::CreateFromInt32( nPrec ); + const SvNumberformat* pFormat = pFormatter->GetEntry( nFormat ); + if( lcl_FormatHasNegColor( pFormat ) ) + aResult += '-'; + if( lcl_FormatHasOpenPar( pFormat ) ) + aResult.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "()" ) ); + PushString( aResult ); + } + else if( aInfoType.EqualsAscii( "COLOR" ) ) + { // 1 = negative values are colored, otherwise 0 + const SvNumberformat* pFormat = pFormatter->GetEntry( pDok->GetNumberFormat( aCellPos ) ); + PushInt( lcl_FormatHasNegColor( pFormat ) ? 1 : 0 ); + } + else if( aInfoType.EqualsAscii( "PARENTHESES" ) ) + { // 1 = format string contains a '(' character, otherwise 0 + const SvNumberformat* pFormat = pFormatter->GetEntry( pDok->GetNumberFormat( aCellPos ) ); + PushInt( lcl_FormatHasOpenPar( pFormat ) ? 1 : 0 ); + } + else + SetIllegalArgument(); + } + } +} + + +void ScInterpreter::ScIsRef() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + if ( !nGlobalError ) + nRes = 1; + } + break; + case svDoubleRef : + { + ScRange aRange; + PopDoubleRef( aRange ); + if ( !nGlobalError ) + nRes = 1; + } + break; + default: + Pop(); + } + nGlobalError = 0; + PushInt( nRes ); +} + + +void ScInterpreter::ScIsValue() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + ScBaseCell* pCell = GetCell( aAdr ); + if (GetCellErrCode( pCell ) == 0) + { + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_VALUE : + nRes = 1; + break; + case CELLTYPE_FORMULA : + nRes = ((ScFormulaCell*)pCell)->IsValue(); + break; + } + } + } + break; + case svString: + Pop(); + break; + default: + PopError(); + if ( !nGlobalError ) + nRes = 1; + } + nGlobalError = 0; + PushInt( nRes ); +} + + +void ScInterpreter::ScIsFormula() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + nRes = (GetCellType( GetCell( aAdr ) ) == CELLTYPE_FORMULA); + } + break; + default: + Pop(); + } + nGlobalError = 0; + PushInt( nRes ); +} + + +void ScInterpreter::ScFormula() +{ + String aFormula; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + ScBaseCell* pCell = GetCell( aAdr ); + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_FORMULA : + ((ScFormulaCell*)pCell)->GetFormula( aFormula ); + break; + default: + SetError( NOVALUE ); + } + } + break; + default: + Pop(); + SetError( NOVALUE ); + } + PushString( aFormula ); +} + + + +void ScInterpreter::ScIsNV() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + PopDoubleRefOrSingleRef( aAdr ); + if ( nGlobalError == NOVALUE ) + nRes = 1; + else + { + ScBaseCell* pCell = GetCell( aAdr ); + USHORT nErr = GetCellErrCode( pCell ); + nRes = (nErr == NOVALUE); + } + } + break; + default: + PopError(); + if ( nGlobalError == NOVALUE ) + nRes = 1; + } + nGlobalError = 0; + PushInt( nRes ); +} + + +void ScInterpreter::ScIsErr() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + PopDoubleRefOrSingleRef( aAdr ); + if ( nGlobalError && nGlobalError != NOVALUE ) + nRes = 1; + else + { + ScBaseCell* pCell = GetCell( aAdr ); + USHORT nErr = GetCellErrCode( pCell ); + nRes = (nErr && nErr != NOVALUE); + } + } + break; + default: + PopError(); + if ( nGlobalError && nGlobalError != NOVALUE ) + nRes = 1; + } + nGlobalError = 0; + PushInt( nRes ); +} + + +void ScInterpreter::ScIsError() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + nRes = 1; + break; + } + if ( nGlobalError ) + nRes = 1; + else + { + ScBaseCell* pCell = GetCell( aAdr ); + nRes = (GetCellErrCode( pCell ) != 0); + } + } + break; + default: + PopError(); + if ( nGlobalError ) + nRes = 1; + } + nGlobalError = 0; + PushInt( nRes ); +} + + +short ScInterpreter::IsEven() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + short nRes = 0; + double fVal; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + break; + ScBaseCell* pCell = GetCell( aAdr ); + USHORT nErr = GetCellErrCode( pCell ); + if (nErr != 0) + SetError(nErr); + else + { + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_VALUE : + fVal = GetCellValue( aAdr, pCell ); + nRes = 1; + break; + case CELLTYPE_FORMULA : + if( ((ScFormulaCell*)pCell)->IsValue() ) + { + fVal = GetCellValue( aAdr, pCell ); + nRes = 1; + } + else + SetIllegalParameter(); + break; + default: + SetIllegalParameter(); + } + } + } + break; + case svDouble: + { + fVal = PopDouble(); + nRes = 1; + } + break; + default: + SetIllegalParameter(); + } + if (nRes) + nRes = ( fmod( ::rtl::math::approxFloor( fabs( fVal ) ), 2.0 ) < 0.5 ); + return nRes; +} + + +void ScInterpreter::ScIsEven() +{ + PushInt( IsEven() ); +} + + +void ScInterpreter::ScIsOdd() +{ + PushInt( !IsEven() ); +} + + +void ScInterpreter::ScN() +{ + USHORT nErr = nGlobalError; + nGlobalError = 0; + double fVal = GetDouble(); + if ( nGlobalError == NOVALUE || nGlobalError == errIllegalArgument ) + nGlobalError = 0; // N(#NV) und N("text") sind ok + if ( !nGlobalError && nErr != NOVALUE ) + nGlobalError = nErr; + PushDouble( fVal ); +} + + +void ScInterpreter::ScTrim() +{ // trimmt nicht nur sondern schnibbelt auch doppelte raus! + String aVal( GetString() ); + aVal.EraseLeadingChars(); + aVal.EraseTrailingChars(); + String aStr; + register const sal_Unicode* p = aVal.GetBuffer(); + register const sal_Unicode* const pEnd = p + aVal.Len(); + while ( p < pEnd ) + { + if ( *p != ' ' || p[-1] != ' ' ) // erster kann kein ' ' sein, -1 ist also ok + aStr += *p; + p++; + } + PushString( aStr ); +} + + +void ScInterpreter::ScUpper() +{ + String aString = GetString(); + ScGlobal::pCharClass->toUpper(aString); + PushString(aString); +} + + +void ScInterpreter::ScPropper() +{ +//2do: what to do with I18N-CJK ?!? + String aStr( GetString() ); + const xub_StrLen nLen = aStr.Len(); + // #i82487#,#i89963# don't try to write to empty string's BufferAccess + // (would crash now that the empty string is const) + if ( nLen > 0 ) + { + String aUpr( ScGlobal::pCharClass->upper( aStr ) ); + String aLwr( ScGlobal::pCharClass->lower( aStr ) ); + register sal_Unicode* pStr = aStr.GetBufferAccess(); + const sal_Unicode* pUpr = aUpr.GetBuffer(); + const sal_Unicode* pLwr = aLwr.GetBuffer(); + *pStr = *pUpr; + String aTmpStr( 'x' ); + xub_StrLen nPos = 1; + while( nPos < nLen ) + { + aTmpStr.SetChar( 0, pStr[nPos-1] ); + if ( !ScGlobal::pCharClass->isLetter( aTmpStr, 0 ) ) + pStr[nPos] = pUpr[nPos]; + else + pStr[nPos] = pLwr[nPos]; + nPos++; + } + aStr.ReleaseBufferAccess( nLen ); + } + PushString( aStr ); +} + + +void ScInterpreter::ScLower() +{ + String aString( GetString() ); + ScGlobal::pCharClass->toLower(aString); + PushString(aString); +} + + +void ScInterpreter::ScLen() +{ + String aStr( GetString() ); + PushDouble( aStr.Len() ); +} + + +void ScInterpreter::ScT() +{ + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + PushInt(0); + return ; + } + BOOL bValue = FALSE; + ScBaseCell* pCell = GetCell( aAdr ); + if ( GetCellErrCode( pCell ) == 0 ) + { + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_VALUE : + bValue = TRUE; + break; + case CELLTYPE_FORMULA : + bValue = ((ScFormulaCell*)pCell)->IsValue(); + break; + } + } + if ( bValue ) + PushString( EMPTY_STRING ); + else + { + // wie GetString() + GetCellString( aTempStr, pCell ); + PushString( aTempStr ); + } + } + break; + case svDouble : + { + PopError(); + PushString( EMPTY_STRING ); + } + break; + case svString : + break; + default : + SetError(errUnknownOpCode); + PushInt(0); + + } +} + + +void ScInterpreter::ScValue() +{ + String aInputString = GetString(); + sal_uInt32 nFIndex = 0; // damit default Land/Spr. + double fVal; + if (pFormatter->IsNumberFormat(aInputString, nFIndex, fVal)) + PushDouble(fVal); + else + SetIllegalArgument(); +} + + +//2do: this should be a proper unicode string method +inline BOOL lcl_ScInterpreter_IsPrintable( sal_Unicode c ) +{ + return 0x20 <= c && c != 0x7f; +} + +void ScInterpreter::ScClean() +{ + String aStr( GetString() ); + for ( xub_StrLen i = 0; i < aStr.Len(); i++ ) + { + if ( !lcl_ScInterpreter_IsPrintable( aStr.GetChar( i ) ) ) + aStr.Erase(i,1); + } + PushString(aStr); +} + + +void ScInterpreter::ScCode() +{ +//2do: make it full range unicode? + const String& rStr = GetString(); + PushInt( (sal_uChar) ByteString::ConvertFromUnicode( rStr.GetChar(0), gsl_getSystemTextEncoding() ) ); +} + + +void ScInterpreter::ScChar() +{ +//2do: make it full range unicode? + double fVal = GetDouble(); + if (fVal < 0.0 || fVal >= 256.0) + SetIllegalArgument(); + else + { + String aStr( '0' ); + aStr.SetChar( 0, ByteString::ConvertToUnicode( (sal_Char) fVal, gsl_getSystemTextEncoding() ) ); + PushString( aStr ); + } +} + + +/*N*/ void ScInterpreter::ScMin( BOOL bTextAsZero ) +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ double nMin = SC_DOUBLE_MAXVALUE; +/*N*/ double nVal = 0.0; +/*N*/ ScAddress aAdr; +/*N*/ ScRange aRange; +/*N*/ for (short i = 0; i < nParamCount; i++) +/*N*/ { +/*N*/ switch (GetStackType()) +/*N*/ { +/*?*/ case svDouble : +/*?*/ { +/*?*/ nVal = GetDouble(); +/*?*/ if (nMin > nVal) nMin = nVal; +/*?*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*?*/ } +/*?*/ break; +/*?*/ case svSingleRef : +/*?*/ { +/*?*/ PopSingleRef( aAdr ); +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ if (HasCellValueData(pCell)) +/*?*/ { +/*?*/ nVal = GetCellValue( aAdr, pCell ); +/*?*/ CurFmtToFuncFmt(); +/*?*/ if (nMin > nVal) nMin = nVal; +/*?*/ } +/*?*/ else if ( bTextAsZero && HasCellStringData( pCell ) ) +/*?*/ { +/*?*/ if ( nMin > 0.0 ) +/*?*/ nMin = 0.0; +/*?*/ } +/*?*/ } +/*?*/ break; +/*N*/ case svDoubleRef : +/*N*/ { +/*N*/ USHORT nErr = 0; +/*N*/ PopDoubleRef( aRange ); +/*N*/ ScValueIterator aValIter( pDok, aRange, glSubTotal, bTextAsZero ); +/*N*/ if (aValIter.GetFirst(nVal, nErr)) +/*N*/ { +/*N*/ if (nMin > nVal) +/*N*/ nMin = nVal; +/*N*/ aValIter.GetCurNumFmtInfo( nFuncFmtType, nFuncFmtIndex ); +/*N*/ while ((nErr == 0) && aValIter.GetNext(nVal, nErr)) +/*N*/ { +/*N*/ if (nMin > nVal) +/*N*/ nMin = nVal; +/*N*/ } +/*N*/ SetError(nErr); +/*N*/ } +/*N*/ } +/*N*/ break; +/*?*/ case svMatrix : +/*?*/ { +/*?*/ ScMatrix* pMat = PopMatrix(); +/*?*/ if (pMat) +/*?*/ { +/*?*/ USHORT nC, nR; +/*?*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ if (pMat->IsNumeric()) +/*?*/ { +/*?*/ for (USHORT i = 0; i < nC; i++) +/*?*/ for (USHORT j = 0; j < nR; j++) +/*?*/ { +/*?*/ nVal = pMat->GetDouble(i,j); +/*?*/ if (nMin > nVal) nMin = nVal; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ for (USHORT i = 0; i < nC; i++) +/*?*/ { +/*?*/ for (USHORT j = 0; j < nR; j++) +/*?*/ { +/*?*/ if (!pMat->IsString(i,j)) +/*?*/ { +/*?*/ nVal = pMat->GetDouble(i,j); +/*?*/ if (nMin > nVal) nMin = nVal; +/*?*/ } +/*?*/ else if ( bTextAsZero ) +/*?*/ { +/*?*/ if ( nMin > 0.0 ) +/*?*/ nMin = 0.0; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case svString : +/*?*/ { +/*?*/ Pop(); +/*?*/ if ( bTextAsZero ) +/*?*/ { +/*?*/ if ( nMin > 0.0 ) +/*?*/ nMin = 0.0; +/*?*/ } +/*?*/ else +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ default : +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*N*/ } +/*N*/ if (nMin == SC_DOUBLE_MAXVALUE) +/*?*/ SetIllegalArgument(); +/*N*/ else +/*N*/ PushDouble(nMin); +/*N*/ } +/*N*/ +/*N*/ #if defined(WIN) && defined(MSC) +/*N*/ #pragma optimize("",off) +/*N*/ #endif + +/*N*/ void ScInterpreter::ScMax( BOOL bTextAsZero ) +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ double nMax = -SC_DOUBLE_MAXVALUE; +/*N*/ double nVal = 0.0; +/*N*/ ScAddress aAdr; +/*N*/ ScRange aRange; +/*N*/ for (short i = 0; i < nParamCount; i++) +/*N*/ { +/*N*/ switch (GetStackType()) +/*N*/ { +/*?*/ case svDouble : +/*?*/ { +/*?*/ nVal = GetDouble(); +/*?*/ if (nMax < nVal) nMax = nVal; +/*?*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*?*/ } +/*?*/ break; +/*N*/ case svSingleRef : +/*N*/ { +/*N*/ PopSingleRef( aAdr ); +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ if (HasCellValueData(pCell)) +/*N*/ { +/*N*/ nVal = GetCellValue( aAdr, pCell ); +/*N*/ CurFmtToFuncFmt(); +/*N*/ if (nMax < nVal) nMax = nVal; +/*N*/ } +/*N*/ else if ( bTextAsZero && HasCellStringData( pCell ) ) +/*N*/ { +/*N*/ if ( nMax < 0.0 ) +/*N*/ nMax = 0.0; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ { +/*N*/ USHORT nErr = 0; +/*N*/ PopDoubleRef( aRange ); +/*N*/ ScValueIterator aValIter( pDok, aRange, glSubTotal, bTextAsZero ); +/*N*/ if (aValIter.GetFirst(nVal, nErr)) +/*N*/ { +/*N*/ if (nMax < nVal) +/*N*/ nMax = nVal; +/*N*/ aValIter.GetCurNumFmtInfo( nFuncFmtType, nFuncFmtIndex ); +/*N*/ while ((nErr == 0) && aValIter.GetNext(nVal, nErr)) +/*N*/ { +/*N*/ if (nMax < nVal) +/*N*/ nMax = nVal; +/*N*/ } +/*N*/ SetError(nErr); +/*N*/ } +/*N*/ } +/*N*/ break; +/*?*/ case svMatrix : +/*?*/ { +/*?*/ ScMatrix* pMat = PopMatrix(); +/*?*/ if (pMat) +/*?*/ { +/*?*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*?*/ USHORT nC, nR; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ if (pMat->IsNumeric()) +/*?*/ { +/*?*/ for (USHORT i = 0; i < nC; i++) +/*?*/ for (USHORT j = 0; j < nR; j++) +/*?*/ { +/*?*/ nVal = pMat->GetDouble(i,j); +/*?*/ if (nMax < nVal) nMax = nVal; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ for (USHORT i = 0; i < nC; i++) +/*?*/ { +/*?*/ for (USHORT j = 0; j < nR; j++) +/*?*/ { +/*?*/ if (!pMat->IsString(i,j)) +/*?*/ { +/*?*/ nVal = pMat->GetDouble(i,j); +/*?*/ if (nMax < nVal) nMax = nVal; +/*?*/ } +/*?*/ else if ( bTextAsZero ) +/*?*/ { +/*?*/ if ( nMax < 0.0 ) +/*?*/ nMax = 0.0; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case svString : +/*?*/ { +/*?*/ Pop(); +/*?*/ if ( bTextAsZero ) +/*?*/ { +/*?*/ if ( nMax < 0.0 ) +/*?*/ nMax = 0.0; +/*?*/ } +/*?*/ else +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ default : +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*N*/ } +/*N*/ } +/*N*/ if (nMax == -SC_DOUBLE_MAXVALUE) +/*N*/ SetIllegalArgument(); +/*N*/ else +/*N*/ PushDouble(nMax); +/*N*/ } +/*N*/ #if defined(WIN) && defined(MSC) +/*N*/ #pragma optimize("",on) +/*N*/ #endif + + +/*N*/ double ScInterpreter::IterateParameters( ScIterFunc eFunc, BOOL bTextAsZero ) +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ double fRes = ( eFunc == ifPRODUCT ) ? 1.0 : 0.0; +/*N*/ double fVal = 0.0; +/*N*/ double fMem = 0.0; +/*N*/ BOOL bNull = TRUE; +/*N*/ ULONG nCount = 0; +/*N*/ ScAddress aAdr; +/*N*/ ScRange aRange; +/*N*/ for (short i = 0; i < nParamCount; i++) +/*N*/ { +/*N*/ switch (GetStackType()) +/*N*/ { +/*N*/ +/*?*/ case svString: +/*?*/ { +/*?*/ if( eFunc == ifCOUNT ) +/*?*/ { +/*?*/ String aStr( PopString() ); +/*?*/ sal_uInt32 nFIndex = 0; // damit default Land/Spr. +/*?*/ if ( bTextAsZero || pFormatter->IsNumberFormat(aStr, nFIndex, fVal)) +/*?*/ nCount++; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ switch ( eFunc ) +/*?*/ { +/*?*/ case ifAVERAGE: +/*?*/ case ifSUM: +/*?*/ case ifSUMSQ: +/*?*/ case ifPRODUCT: +/*?*/ { +/*?*/ if ( bTextAsZero ) +/*?*/ { +/*?*/ Pop(); +/*?*/ nCount++; +/*?*/ if ( eFunc == ifPRODUCT ) +/*?*/ fRes = 0.0; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ for ( ; i < nParamCount; i++ ) +/*?*/ Pop(); +/*?*/ SetError( errNoValue ); +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ nCount++; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case svDouble : +/*?*/ fVal = GetDouble(); +/*?*/ nCount++; +/*?*/ switch( eFunc ) +/*?*/ { +/*?*/ case ifAVERAGE: +/*?*/ case ifSUM: +/*?*/ if ( bNull && fVal != 0.0 ) +/*?*/ { +/*?*/ bNull = FALSE; +/*?*/ fMem = fVal; +/*?*/ } +/*?*/ else +/*?*/ fRes += fVal; +/*?*/ break; +/*?*/ case ifSUMSQ: fRes += fVal * fVal; break; +/*?*/ case ifPRODUCT: fRes *= fVal; break; +/*?*/ } +/*?*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*?*/ break; +/*?*/ case svSingleRef : +/*?*/ { +/*?*/ PopSingleRef( aAdr ); +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ if ( pCell ) +/*?*/ { +/*?*/ if( eFunc == ifCOUNT2 ) +/*?*/ { +/*?*/ CellType eCellType = pCell->GetCellType(); +/*?*/ if (eCellType != CELLTYPE_NONE && eCellType != CELLTYPE_NOTE) +/*?*/ nCount++; +/*?*/ } +/*?*/ else if ( pCell->HasValueData() ) +/*?*/ { +/*?*/ nCount++; +/*?*/ fVal = GetCellValue( aAdr, pCell ); +/*?*/ CurFmtToFuncFmt(); +/*?*/ switch( eFunc ) +/*?*/ { +/*?*/ case ifAVERAGE: +/*?*/ case ifSUM: +/*?*/ if ( bNull && fVal != 0.0 ) +/*?*/ { +/*?*/ bNull = FALSE; +/*?*/ fMem = fVal; +/*?*/ } +/*?*/ else +/*?*/ fRes += fVal; +/*?*/ break; +/*?*/ case ifSUMSQ: fRes += fVal * fVal; break; +/*?*/ case ifPRODUCT: fRes *= fVal; break; +/*?*/ } +/*?*/ } +/*?*/ else if ( bTextAsZero && pCell->HasStringData() ) +/*?*/ { +/*?*/ nCount++; +/*?*/ if ( eFunc == ifPRODUCT ) +/*?*/ fRes = 0.0; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ break; +/*N*/ case svDoubleRef : +/*N*/ { +/*N*/ USHORT nErr = 0; +/*N*/ PopDoubleRef( aRange ); +/*N*/ if( eFunc == ifCOUNT2 ) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ ScCellIterator aIter( pDok, aRange, glSubTotal ); +/*N*/ if (pCell = aIter.GetFirst()) +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ if( eType != CELLTYPE_NONE && eType != CELLTYPE_NOTE ) +/*N*/ nCount++; +/*N*/ } +/*N*/ while ( pCell = aIter.GetNext()); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ ScValueIterator aValIter( pDok, aRange, glSubTotal, bTextAsZero ); +/*N*/ if (aValIter.GetFirst(fVal, nErr)) +/*N*/ { +/*N*/ // Schleife aus Performance-Gruenden nach innen verlegt: +/*N*/ aValIter.GetCurNumFmtInfo( nFuncFmtType, nFuncFmtIndex ); +/*N*/ switch( eFunc ) +/*N*/ { +/*N*/ case ifAVERAGE: +/*N*/ case ifSUM: +/*N*/ do +/*N*/ { +/*N*/ SetError(nErr); +/*N*/ if ( bNull && fVal != 0.0 ) +/*N*/ { +/*N*/ bNull = FALSE; +/*N*/ fMem = fVal; +/*N*/ } +/*N*/ else +/*N*/ fRes += fVal; +/*N*/ nCount++; +/*N*/ } +/*N*/ while (aValIter.GetNext(fVal, nErr)); +/*N*/ break; +/*N*/ case ifSUMSQ: +/*N*/ do +/*N*/ { +/*N*/ SetError(nErr); +/*N*/ fRes += fVal * fVal; +/*N*/ nCount++; +/*N*/ } +/*N*/ while (aValIter.GetNext(fVal, nErr)); +/*N*/ break; +/*N*/ case ifPRODUCT: +/*N*/ do +/*N*/ { +/*N*/ SetError(nErr); +/*N*/ fRes *= fVal; +/*N*/ nCount++; +/*N*/ } +/*N*/ while (aValIter.GetNext(fVal, nErr)); +/*N*/ break; +/*N*/ default: // count +/*N*/ do +/*N*/ { +/*N*/ SetError(nErr); +/*N*/ nCount++; +/*N*/ } +/*N*/ while (aValIter.GetNext(fVal, nErr)); +/*N*/ break; +/*N*/ } +/*N*/ SetError( nErr ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*?*/ case svMatrix : +/*?*/ { +/*?*/ ScMatrix* pMat = PopMatrix(); +/*?*/ if (pMat) +/*?*/ { +/*?*/ USHORT nC, nR; +/*?*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ if( eFunc == ifCOUNT2 ) +/*?*/ nCount += (ULONG) nC * nR; +/*?*/ else +/*?*/ { +/*?*/ for (USHORT i = 0; i < nC; i++) +/*?*/ { +/*?*/ for (USHORT j = 0; j < nR; j++) +/*?*/ { +/*?*/ if (!pMat->IsString(i,j)) +/*?*/ { +/*?*/ nCount++; +/*?*/ fVal = pMat->GetDouble(i,j); +/*?*/ switch( eFunc ) +/*?*/ { +/*?*/ case ifAVERAGE: +/*?*/ case ifSUM: +/*?*/ if ( bNull && fVal != 0.0 ) +/*?*/ { +/*?*/ bNull = FALSE; +/*?*/ fMem = fVal; +/*?*/ } +/*?*/ else +/*?*/ fRes += fVal; +/*?*/ break; +/*?*/ case ifSUMSQ: fRes += fVal * fVal; break; +/*?*/ case ifPRODUCT: fRes *= fVal; break; +/*?*/ } +/*?*/ } +/*?*/ else if ( bTextAsZero ) +/*?*/ { +/*?*/ nCount++; +/*?*/ if ( eFunc == ifPRODUCT ) +/*?*/ fRes = 0.0; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ default : +/*?*/ for ( ; i < nParamCount; i++ ) +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*N*/ } +/*N*/ } +/*N*/ switch( eFunc ) +/*N*/ { +/*N*/ case ifSUM: fRes = ::rtl::math::approxAdd( fRes, fMem ); break; +/*N*/ case ifAVERAGE: fRes = ::rtl::math::approxAdd( fRes, fMem ) / nCount; break; +/*N*/ case ifCOUNT2: +/*N*/ case ifCOUNT: fRes = nCount; break; +/*N*/ case ifPRODUCT: if ( !nCount ) fRes = 0.0; break; +/*N*/ } +/*N*/ // Bei Summen etc. macht ein BOOL-Ergebnis keinen Sinn +/*N*/ // und Anzahl ist immer Number (#38345#) +/*N*/ if( eFunc == ifCOUNT || nFuncFmtType == NUMBERFORMAT_LOGICAL ) +/*N*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*N*/ return fRes; +/*N*/ } + + +void ScInterpreter::ScSumSQ() +{ + PushDouble( IterateParameters( ifSUMSQ ) ); +} + + +/*N*/ void ScInterpreter::ScSum() +/*N*/ { +/*N*/ PushDouble( IterateParameters( ifSUM ) ); +/*N*/ } + + +void ScInterpreter::ScProduct() +{ + PushDouble( IterateParameters( ifPRODUCT ) ); +} + + +/*N*/ void ScInterpreter::ScAverage( BOOL bTextAsZero ) +/*N*/ { +/*N*/ PushDouble( IterateParameters( ifAVERAGE, bTextAsZero ) ); +/*N*/ } + + +void ScInterpreter::ScCount() +{ + PushDouble( IterateParameters( ifCOUNT ) ); +} + + +/*N*/ void ScInterpreter::ScCount2() +/*N*/ { +/*N*/ PushDouble( IterateParameters( ifCOUNT2 ) ); +/*N*/ } + + +/*N*/ void ScInterpreter::GetStVarParams( double& rVal, double& rValCount, +/*N*/ BOOL bTextAsZero ) +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ USHORT i; +/*N*/ double fSum = 0.0; +/*N*/ double fSumSqr = 0.0; +/*N*/ double fVal; +/*N*/ rValCount = 0.0; +/*N*/ ScAddress aAdr; +/*N*/ ScRange aRange; +/*N*/ for (i = 0; i < nParamCount; i++) +/*N*/ { +/*N*/ switch (GetStackType()) +/*N*/ { +/*N*/ case svDouble : +/*N*/ { +/*?*/ fVal = GetDouble(); +/*?*/ fSum += fVal; +/*?*/ fSumSqr += fVal*fVal; +/*?*/ rValCount++; +/*N*/ } +/*N*/ break; +/*N*/ case svSingleRef : +/*N*/ { +/*?*/ PopSingleRef( aAdr ); +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ if (HasCellValueData(pCell)) +/*?*/ { +/*?*/ fVal = GetCellValue( aAdr, pCell ); +/*?*/ fSum += fVal; +/*?*/ fSumSqr += fVal*fVal; +/*?*/ rValCount++; +/*?*/ } +/*?*/ else if ( bTextAsZero && HasCellStringData( pCell ) ) +/*?*/ rValCount++; +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ { +/*N*/ USHORT nErr = 0; +/*N*/ PopDoubleRef( aRange ); +/*N*/ ScValueIterator aValIter( pDok, aRange, glSubTotal, bTextAsZero ); +/*N*/ if (aValIter.GetFirst(fVal, nErr)) +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ fSum += fVal; +/*N*/ fSumSqr += fVal*fVal; +/*N*/ rValCount++; +/*N*/ } +/*N*/ while ((nErr == 0) && aValIter.GetNext(fVal, nErr)); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svMatrix : +/*N*/ { +/*?*/ ScMatrix* pMat = PopMatrix(); +/*?*/ if (pMat) +/*?*/ { +/*?*/ USHORT nC, nR; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ for (USHORT i = 0; i < nC; i++) +/*?*/ { +/*?*/ for (USHORT j = 0; j < nR; j++) +/*?*/ { +/*?*/ if (!pMat->IsString(i,j)) +/*?*/ { +/*?*/ fVal= pMat->GetDouble(i,j); +/*?*/ fSum += fVal; +/*?*/ fSumSqr += fVal * fVal; +/*?*/ rValCount++; +/*?*/ } +/*?*/ else if ( bTextAsZero ) +/*?*/ rValCount++; +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svString : +/*N*/ { +/*?*/ if ( bTextAsZero ) +/*?*/ rValCount++; +/*?*/ else +/*?*/ { +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*N*/ } +/*N*/ default : +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*N*/ } +/*N*/ } +/*N*/ rVal = ::rtl::math::approxSub( fSumSqr, fSum*fSum/rValCount ); +/*N*/ } + + +void ScInterpreter::ScVar( BOOL bTextAsZero ) +{ + double nVal; + double nValCount; + GetStVarParams( nVal, nValCount, bTextAsZero ); + PushDouble(nVal / (nValCount - 1.0)); +} + + +void ScInterpreter::ScVarP( BOOL bTextAsZero ) +{ + double nVal; + double nValCount; + GetStVarParams( nVal, nValCount, bTextAsZero ); + PushDouble(nVal / nValCount); +} + + +void ScInterpreter::ScStDev( BOOL bTextAsZero ) +{ + double nVal; + double nValCount; + GetStVarParams( nVal, nValCount, bTextAsZero ); + PushDouble(sqrt(nVal / (nValCount - 1.0))); +} + + +/*N*/ void ScInterpreter::ScStDevP( BOOL bTextAsZero ) +/*N*/ { +/*N*/ double nVal; +/*N*/ double nValCount; +/*N*/ GetStVarParams( nVal, nValCount, bTextAsZero ); +/*N*/ PushDouble(sqrt(nVal / nValCount)); +/*N*/ } + + +void ScInterpreter::ScColumns() +{ + BYTE nParamCount = GetByte(); + ULONG nVal = 0; + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + for (USHORT i = 1; i <= nParamCount; i++) + { + switch ( GetStackType() ) + { + case svSingleRef: + PopError(); + nVal++; + break; + case svDoubleRef: + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + nVal += (nTab2 - nTab1 + 1) * (nCol2 - nCol1 + 1); + break; + case svMatrix: + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + nVal += nC; + } + } + break; + default: + PopError(); + SetError(errIllegalParameter); + } + } + PushDouble((double)nVal); +} + + +void ScInterpreter::ScRows() +{ + BYTE nParamCount = GetByte(); + ULONG nVal = 0; + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + for (USHORT i = 1; i <= nParamCount; i++) + { + switch ( GetStackType() ) + { + case svSingleRef: + PopError(); + nVal++; + break; + case svDoubleRef: + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + nVal += (nTab2 - nTab1 + 1) * (nRow2 - nRow1 + 1); + break; + case svMatrix: + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + nVal += nR; + } + } + break; + default: + PopError(); + SetError(errIllegalParameter); + } + } + PushDouble((double)nVal); +} + +void ScInterpreter::ScTables() +{ + BYTE nParamCount = GetByte(); + ULONG nVal; + if ( nParamCount == 0 ) + nVal = pDok->GetTableCount(); + else + { + nVal = 0; + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + for (USHORT i = 1; i <= nParamCount; i++) + { + switch ( GetStackType() ) + { + case svSingleRef: + PopError(); + nVal++; + break; + case svDoubleRef: + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + nVal += (nTab2 - nTab1 + 1); + break; + case svMatrix: + PopError(); + nVal++; + break; + default: + PopError(); + SetError( errIllegalParameter ); + } + } + } + PushDouble( (double) nVal ); +} + + +void ScInterpreter::ScColumn() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 0, 1 ) ) + { + double nVal; + if (nParamCount == 0) + nVal = aPos.Col() + 1; + else + { + switch ( GetStackType() ) + { + case svSingleRef : + { + USHORT nCol1, nRow1, nTab1; + PopSingleRef( nCol1, nRow1, nTab1 ); + nVal = (double) (nCol1 + 1); + } + break; + case svDoubleRef : + { + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); + if (nCol2 > nCol1) + { + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(nCol2-nCol1+1, 1, nMatInd); + if (pResMat) + { + for (USHORT i = nCol1; i <= nCol2; i++) + pResMat->PutDouble((double)(i+1), i-nCol1, 0); + PushMatrix(pResMat); + nRetMat = nMatInd; + return; + } + else + { + SetError( errIllegalParameter ); + nVal = 0.0; + } + } + else + nVal = (double) (nCol1 + 1); + } + break; + default: + SetError( errIllegalParameter ); + nVal = 0.0; + } + } + PushDouble( nVal ); + } +} + + +void ScInterpreter::ScRow() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 0, 1 ) ) + { + double nVal; + if (nParamCount == 0) + nVal = aPos.Row() + 1; + else + { + switch ( GetStackType() ) + { + case svSingleRef : + { + USHORT nCol1, nRow1, nTab1; + PopSingleRef( nCol1, nRow1, nTab1 ); + nVal = (double) (nRow1 + 1); + } + break; + case svDoubleRef : + { + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); + if (nRow2 > nRow1) + { + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(1, nRow2-nRow1+1, nMatInd); + if (pResMat) + { + for (USHORT i = nRow1; i <= nRow2; i++) + pResMat->PutDouble((double)(i+1), 0, i-nRow1); + PushMatrix(pResMat); + nRetMat = nMatInd; + return; + } + else + { + SetError( errIllegalParameter ); + nVal = 0.0; + } + } + else + nVal = (double) (nRow1 + 1); + } + break; + default: + SetError( errIllegalParameter ); + nVal = 0.0; + } + } + PushDouble( nVal ); + } +} + +void ScInterpreter::ScTable() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 0, 1 ) ) + { + USHORT nVal = 0; + if ( nParamCount == 0 ) + nVal = aPos.Tab() + 1; + else + { + switch ( GetStackType() ) + { + case svString : + { + String aStr( PopString() ); + if ( pDok->GetTable( aStr, nVal ) ) + ++nVal; + else + SetError( errIllegalArgument ); + } + break; + case svSingleRef : + { + USHORT nCol1, nRow1, nTab1; + PopSingleRef( nCol1, nRow1, nTab1 ); + nVal = nTab1 + 1; + } + break; + case svDoubleRef : + { + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); + nVal = nTab1 + 1; + } + break; + default: + SetError( errIllegalParameter ); + } + if ( nGlobalError ) + nVal = 0; + } + PushDouble( (double) nVal ); + } +} + + +/*N*/ void ScInterpreter::ScMatch() +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if ( MustHaveParamCount( nParamCount, 2, 3 ) ) +/*N*/ { +/*N*/ double fTyp; +/*N*/ if (nParamCount == 3) +/*N*/ fTyp = GetDouble(); +/*N*/ else +/*N*/ fTyp = 1.0; +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ if (GetStackType() == svDoubleRef) +/*N*/ { +/*N*/ PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +/*N*/ if (nTab1 != nTab2 || (nCol1 != nCol2 && nRow1 != nRow2)) +/*N*/ { +/*N*/ SetIllegalParameter(); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SetIllegalParameter(); +/*N*/ return; +/*N*/ } +/*N*/ if (nGlobalError == 0) +/*N*/ { +/*N*/ double fVal; +/*N*/ String sStr; +/*N*/ ScQueryParam rParam; +/*N*/ rParam.nCol1 = nCol1; +/*N*/ rParam.nRow1 = nRow1; +/*N*/ rParam.nCol2 = nCol2; +/*N*/ rParam.bHasHeader = FALSE; +/*N*/ rParam.bInplace = TRUE; +/*N*/ rParam.bCaseSens = FALSE; +/*N*/ rParam.bRegExp = pDok->GetDocOptions().IsFormulaRegexEnabled(); +/*N*/ rParam.bDuplicate = FALSE; +/*N*/ +/*N*/ ScQueryEntry& rEntry = rParam.GetEntry(0); +/*N*/ rEntry.bDoQuery = TRUE; +/*N*/ if (fTyp < 0.0) +/*N*/ rEntry.eOp = SC_GREATER_EQUAL; +/*N*/ else if (fTyp > 0.0) +/*N*/ rEntry.eOp = SC_LESS_EQUAL; +/*N*/ switch ( GetStackType() ) +/*N*/ { +/*N*/ case svDouble: +/*N*/ { +/*N*/ fVal = GetDouble(); +/*N*/ rEntry.bQueryByString = FALSE; +/*N*/ rEntry.nVal = fVal; +/*N*/ } +/*N*/ break; +/*N*/ case svString: +/*N*/ { +/*N*/ sStr = GetString(); +/*N*/ rEntry.bQueryByString = TRUE; +/*N*/ *rEntry.pStr = sStr; +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ case svSingleRef : +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ if ( !PopDoubleRefOrSingleRef( aAdr ) ) +/*N*/ { +/*N*/ PushInt(0); +/*N*/ return ; +/*N*/ } +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ if (HasCellValueData(pCell)) +/*N*/ { +/*N*/ fVal = GetCellValue( aAdr, pCell ); +/*N*/ rEntry.bQueryByString = FALSE; +/*N*/ rEntry.nVal = fVal; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ GetCellString(sStr, pCell); +/*N*/ rEntry.bQueryByString = TRUE; +/*N*/ *rEntry.pStr = sStr; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ SetIllegalParameter(); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ if ( rEntry.bQueryByString ) +/*N*/ rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); +/*N*/ USHORT nDelta, nR, nC; +/*N*/ if (nCol1 == nCol2) +/*N*/ { // search row in column +/*N*/ rParam.nRow2 = nRow2; +/*N*/ rEntry.nField = nCol1; +/*N*/ ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); +/*N*/ if (fTyp == 0.0) +/*N*/ { // EQUAL +/*N*/ if (aCellIter.GetFirst()) +/*N*/ nR = aCellIter.GetRow(); +/*N*/ else +/*N*/ { +/*N*/ SetNV(); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // <= or >= +/*N*/ aCellIter.SetStopOnMismatch( TRUE ); +/*N*/ if ( aCellIter.GetFirst() ) +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ nR = aCellIter.GetRow(); +/*N*/ } while ( aCellIter.GetNext() ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SetNV(); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ nDelta = nR - nRow1; +/*N*/ } +/*N*/ else +/*N*/ { // search column in row +/*N*/ rParam.nRow2 = nRow1; +/*N*/ rEntry.nField = nCol1; +/*N*/ ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); +/*N*/ // Advance Entry.nField in Iterator if column changed +/*N*/ aCellIter.SetAdvanceQueryParamEntryField( TRUE ); +/*N*/ if (fTyp == 0.0) +/*N*/ { // EQUAL +/*N*/ if ( aCellIter.GetFirst() ) +/*N*/ nC = aCellIter.GetCol(); +/*N*/ else +/*N*/ { +/*N*/ SetNV(); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // <= or >= +/*N*/ aCellIter.SetStopOnMismatch( TRUE ); +/*N*/ if ( aCellIter.GetFirst() ) +/*N*/ { +/*N*/ do +/*N*/ { +/*N*/ nC = aCellIter.GetCol(); +/*N*/ } while ( aCellIter.GetNext() ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SetNV(); +/*N*/ return; +/*N*/ } +/*N*/ } +/*N*/ nDelta = nC - nCol1; +/*N*/ } +/*N*/ PushDouble((double) (nDelta + 1)); +/*N*/ } +/*N*/ else +/*N*/ SetIllegalParameter(); +/*N*/ } +/*N*/ } + + +void ScInterpreter::ScCountEmptyCells() +{ + if ( MustHaveParamCount( GetByte(), 1 ) ) + { + long nMaxCount = 0, nCount = 0; + CellType eCellType; + switch (GetStackType()) + { + case svSingleRef : + { + nMaxCount = 1; + ScAddress aAdr; + PopSingleRef( aAdr ); + eCellType = GetCellType( GetCell( aAdr ) ); + if (eCellType != CELLTYPE_NONE && eCellType != CELLTYPE_NOTE) + nCount = 1; + } + break; + case svDoubleRef : + { + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + nMaxCount = (nRow2 - nRow1 + 1) * (nCol2 - nCol1 + 1) + * (nTab2 - nTab1 + 1); + ScBaseCell* pCell; + ScCellIterator aDocIter(pDok, nCol1, nRow1, nTab1, + nCol2, nRow2, nTab2, glSubTotal); + if (pCell = aDocIter.GetFirst()) + { + do + { + if ((eCellType = pCell->GetCellType()) != CELLTYPE_NONE + && eCellType != CELLTYPE_NOTE) + nCount++; + } while ( pCell = aDocIter.GetNext() ); + } + } + break; + default : SetError(errIllegalParameter); break; + } + PushDouble(nMaxCount - nCount); + } +} + + + void ScInterpreter::ScCountIf() + { + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + String rString; + double fVal; + BOOL bIsString = TRUE; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + PushInt(0); + return ; + } + ScBaseCell* pCell = GetCell( aAdr ); + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_VALUE : + fVal = GetCellValue( aAdr, pCell ); + bIsString = FALSE; + break; + case CELLTYPE_FORMULA : + if( ((ScFormulaCell*)pCell)->IsValue() ) + { + fVal = GetCellValue( aAdr, pCell ); + bIsString = FALSE; + } + else + GetCellString(rString, pCell); + break; + case CELLTYPE_STRING : + case CELLTYPE_EDIT : + GetCellString(rString, pCell); + break; + default: + fVal = 0.0; + bIsString = FALSE; + } + } + break; + case svString: + rString = GetString(); + break; + default: + { + fVal = GetDouble(); + bIsString = FALSE; + } + } + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + switch ( GetStackType() ) + { + case svDoubleRef : + PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); + break; + case svSingleRef : + PopSingleRef( nCol1, nRow1, nTab1 ); + nCol2 = nCol1; + nRow2 = nRow1; + nTab2 = nTab1; + break; + default: + SetIllegalParameter(); + return ; + } + if ( nTab1 != nTab2 ) + { + SetIllegalParameter(); + return; + } + if (nCol1 > nCol2) + { + SetIllegalParameter(); + return; + } + if (nGlobalError == 0) + { + ScQueryParam rParam; + rParam.nRow1 = nRow1; + rParam.nRow2 = nRow2; + rParam.bHasHeader = FALSE; + rParam.bInplace = TRUE; + rParam.bCaseSens = FALSE; + rParam.bRegExp = pDok->GetDocOptions().IsFormulaRegexEnabled(); + rParam.bDuplicate = FALSE; + + ScQueryEntry& rEntry = rParam.GetEntry(0); + rEntry.bDoQuery = TRUE; + if (!bIsString) + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = fVal; + rEntry.eOp = SC_EQUAL; + } + else if( rString.Len() ) + { + rParam.FillInExcelSyntax(rString,(USHORT) 0); + sal_uInt32 nIndex = 0; + rEntry.bQueryByString = + !(pFormatter->IsNumberFormat( + *rEntry.pStr, nIndex, rEntry.nVal)); + if ( rEntry.bQueryByString ) + rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); + } + else + { + PushInt( 0 ); + return; + } + double fSum = 0.0; + rParam.nCol1 = nCol1; + rParam.nCol2 = nCol2; + rEntry.nField = nCol1; + ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); + // Entry.nField im Iterator bei Spaltenwechsel weiterschalten + aCellIter.SetAdvanceQueryParamEntryField( TRUE ); + if ( aCellIter.GetFirst() ) + { + do + { + fSum++; + } while ( aCellIter.GetNext() ); + } + PushDouble(fSum); + } + else + SetIllegalParameter(); + } + } + + + void ScInterpreter::ScSumIf() + { + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + USHORT nCol3, nRow3, nTab3, nCol4, nRow4, nTab4; + if (nParamCount == 3) + { + switch ( GetStackType() ) + { + case svDoubleRef : + PopDoubleRef( nCol3, nRow3, nTab3, nCol4, nRow4, nTab4 ); + break; + case svSingleRef : + PopSingleRef( nCol3, nRow3, nTab3 ); + nCol4 = nCol3; + nRow4 = nRow3; + nTab4 = nTab3; + break; + default: + SetIllegalParameter(); + return ; + } + if ( nTab3 != nTab4 ) + { + SetIllegalParameter(); + return; + } + } + String rString; + double fVal; + BOOL bIsString = TRUE; + switch ( GetStackType() ) + { + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + PushInt(0); + return ; + } + ScBaseCell* pCell = GetCell( aAdr ); + switch ( GetCellType( pCell ) ) + { + case CELLTYPE_VALUE : + fVal = GetCellValue( aAdr, pCell ); + bIsString = FALSE; + break; + case CELLTYPE_FORMULA : + if( ((ScFormulaCell*)pCell)->IsValue() ) + { + fVal = GetCellValue( aAdr, pCell ); + bIsString = FALSE; + } + else + GetCellString(rString, pCell); + break; + case CELLTYPE_STRING : + case CELLTYPE_EDIT : + GetCellString(rString, pCell); + break; + default: + fVal = 0.0; + bIsString = FALSE; + } + } + break; + case svString: + rString = GetString(); + break; + default: + { + fVal = GetDouble(); + bIsString = FALSE; + } + } + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + switch ( GetStackType() ) + { + case svDoubleRef : + PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); + break; + case svSingleRef : + PopSingleRef( nCol1, nRow1, nTab1 ); + nCol2 = nCol1; + nRow2 = nRow1; + nTab2 = nTab1; + break; + default: + SetIllegalParameter(); + return ; + } + if ( nTab1 != nTab2 ) + { + SetIllegalParameter(); + return; + } + if (nParamCount != 3) + { + nCol3 = nCol1; + nRow3 = nRow1; + nTab3 = nTab1; + nCol4 = nCol2; + nRow4 = nRow2; + nTab4 = nTab2; + } + else if (nCol4 - nCol3 != nCol2 - nCol1 || + nRow4 - nRow3 != nRow2 - nRow1 || nCol1 > nCol2) + { + SetIllegalParameter(); + return; + } + if (nGlobalError == 0) + { + ScQueryParam rParam; + rParam.nRow1 = nRow1; + rParam.nRow2 = nRow2; + rParam.bHasHeader = FALSE; + rParam.bInplace = TRUE; + rParam.bCaseSens = FALSE; + rParam.bRegExp = pDok->GetDocOptions().IsFormulaRegexEnabled(); + rParam.bDuplicate = FALSE; + + ScQueryEntry& rEntry = rParam.GetEntry(0); + rEntry.bDoQuery = TRUE; + if (!bIsString) + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = fVal; + rEntry.eOp = SC_EQUAL; + } + else + { + rParam.FillInExcelSyntax(rString,(USHORT) 0); + sal_uInt32 nIndex = 0; + rEntry.bQueryByString = + !(pFormatter->IsNumberFormat( + *rEntry.pStr, nIndex, rEntry.nVal)); + if ( rEntry.bQueryByString ) + rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); + } + double fSum = 0.0; + double fMem = 0.0; + BOOL bNull = TRUE; + ScAddress aAdr; + aAdr.SetTab( nTab3 ); + rParam.nCol1 = nCol1; + rParam.nCol2 = nCol2; + rEntry.nField = nCol1; + short nColDiff = nCol3 - nCol1; + short nRowDiff = nRow3 - nRow1; + ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); + // Entry.nField im Iterator bei Spaltenwechsel weiterschalten + aCellIter.SetAdvanceQueryParamEntryField( TRUE ); + if ( aCellIter.GetFirst() ) + { + do + { + aAdr.SetCol( aCellIter.GetCol() + nColDiff ); + aAdr.SetRow( aCellIter.GetRow() + nRowDiff ); + ScBaseCell* pCell = GetCell( aAdr ); + if ( HasCellValueData(pCell) ) + { + fVal = GetCellValue( aAdr, pCell ); + if ( bNull && fVal != 0.0 ) + { + bNull = FALSE; + fMem = fVal; + } + else + fSum += fVal; + } + } while ( aCellIter.GetNext() ); + } + PushDouble( ::rtl::math::approxAdd( fSum, fMem ) ); + } + else + SetIllegalParameter(); + } + } + + + void ScInterpreter::ScLookup() + { + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 2, 3 ) ) + return ; + USHORT nC3 = 0, nC1 = 0; + USHORT nR3 = 0, nR1 = 0; + ScMatrix* pMat3 = NULL; + ScMatrix* pMat1 = NULL; + USHORT nCol1 = 0; + USHORT nRow1 = 0; + USHORT nTab1 = 0; + USHORT nCol2 = 0; + USHORT nRow2 = 0; + USHORT nTab2 = 0; + USHORT nCol3 = 0; + USHORT nRow3 = 0; + USHORT nTab3 = 0; + USHORT nCol4 = 0; + USHORT nRow4 = 0; + USHORT nTab4 = 0; + USHORT nDelta; + + // param 3: data range + if ( nParamCount == 3 ) + { + if (GetStackType() == svDoubleRef) + { + PopDoubleRef(nCol3, nRow3, nTab3, nCol4, nRow4, nTab4); + if (nTab3 != nTab4 || (nCol3 != nCol4 && nRow3 != nRow4)) + { + SetIllegalParameter(); + return; + } + } + else if (GetStackType() == svMatrix) + { + pMat3 = PopMatrix(); + if (pMat3) + { + pMat3->GetDimensions(nC3, nR3); + if (nC3 != 1 && nR3 != 1) + { + SetIllegalParameter(); + return; + } + } + else + { + SetIllegalParameter(); + return; + } + } + else + { + SetIllegalParameter(); + return; + } + } + + // param 2: key range, or key range and data range + if (GetStackType() == svDoubleRef) + { + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + if ( nTab1 != nTab2 || (nParamCount == 3 && nCol1 != nCol2 && nRow1 != nRow2) ) + { + SetIllegalParameter(); + return; + } + } + else if (GetStackType() == svMatrix) + { + pMat1 = PopMatrix(); + if (pMat1) + { + pMat1->GetDimensions(nC1, nR1); + if (nC1 != 1 && nR1 != 1) + { + SetIllegalParameter(); + return; + } + } + else + { + SetIllegalParameter(); + return; + } + } + else + { + SetIllegalParameter(); + return; + } + BOOL bSpMatrix, bSpVector; + USHORT nMatCount, nVecCount; + if (pMat1 == NULL) + { + if (nRow1 == nRow2) + { + nMatCount = nCol2 - nCol1 + 1; + bSpMatrix = FALSE; + } + else + { + nMatCount = nRow2 - nRow1 + 1; + bSpMatrix = TRUE; + } + } + else + { + if (nR1 == 1) + { + nMatCount = nC1; + bSpMatrix = FALSE; + } + else + { + nMatCount = nR1; + bSpMatrix = TRUE; + } + } + if ( nParamCount < 3 ) + { + nVecCount = nMatCount; + bSpVector = bSpMatrix; + } + else if (pMat3 == NULL) + { + if (nRow3 == nRow4) + { + nVecCount = nCol4 - nCol3 + 1; + bSpVector = FALSE; + } + else + { + nVecCount = nRow4 - nRow3 + 1; + bSpVector = TRUE; + } + } + else + { + if (nR3 == 1) + { + nVecCount = nC3; + bSpVector = FALSE; + } + else + { + nVecCount = nR3; + bSpVector = TRUE; + } + } + if (nGlobalError == 0 && nVecCount == nMatCount) + { + String sStr; + ScQueryParam rParam; + rParam.nCol1 = nCol1; + rParam.nRow1 = nRow1; + rParam.nCol2 = (bSpMatrix ? nCol1 : nCol2); + rParam.nRow2 = (bSpMatrix ? nRow2 : nRow1); + rParam.bHasHeader = FALSE; + rParam.bInplace = TRUE; + rParam.bCaseSens = FALSE; + rParam.bRegExp = pDok->GetDocOptions().IsFormulaRegexEnabled(); + rParam.bDuplicate = FALSE; + + ScQueryEntry& rEntry = rParam.GetEntry(0); + rEntry.bDoQuery = TRUE; + rEntry.eOp = SC_LESS_EQUAL; + rEntry.nField = nCol1; + switch ( GetStackType() ) + { + case svDouble: + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = GetDouble(); + } + break; + case svString: + { + sStr = GetString(); + rEntry.bQueryByString = TRUE; + *rEntry.pStr = sStr; + } + break; + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + PushInt(0); + return ; + } + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = GetCellValue( aAdr, pCell ); + } + else + { + if ( GetCellType( pCell ) == CELLTYPE_NOTE ) + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = 0.0; + } + else + { + GetCellString(sStr, pCell); + rEntry.bQueryByString = TRUE; + *rEntry.pStr = sStr; + } + } + } + break; + default: + { + SetIllegalParameter(); + return; + } + } + if ( rEntry.bQueryByString ) + rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); + if (pMat1) + { + if (rEntry.bQueryByString) + { + //!!!!!!! + //! TODO: enable regex on matrix strings + //!!!!!!! + BOOL bFound = FALSE; + sal_Int32 nRes; + String aParamStr = *rEntry.pStr; + USHORT i = 0; + for ( i = 0; i < nMatCount; i++) + { + if (!pMat1->IsValue(i)) + { + nRes = ScGlobal::pCollator->compareString( + pMat1->GetString(i), aParamStr ); + if (nRes == COMPARE_EQUAL) + { + bFound = TRUE; + nDelta = i; + } + else if (nRes == COMPARE_LESS) + i = nMatCount+1; + } + } + if (i == nMatCount+2 && !bFound) + { + SetNV(); + return; + } + else if (!bFound) + nDelta = i-1; + } + else + { + BOOL bFound = FALSE; + double fVal1; + USHORT i = 0; + for ( i = 0; i < nMatCount; i++) + { + if (pMat1->IsValue(i)) + fVal1 = pMat1->GetDouble(i); + else + fVal1 = MAXDOUBLE; + if (fVal1 == rEntry.nVal) + { + bFound = TRUE; + nDelta = i; + } + else if (fVal1 > rEntry.nVal) + i = nMatCount+1; + } + if (i == nMatCount+2 && !bFound) + { + SetNV(); + return; + } + else if (!bFound) + nDelta = i-1; + } + } + else if (bSpMatrix) // lookup in column + { + rEntry.eOp = SC_LESS_EQUAL; + ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); + USHORT nC, nR; + if ( aCellIter.FindEqualOrSortedLastInRange( nC, nR ) ) + nDelta = nR - nRow1; + else + { + SetNV(); + return; + } + } + else // lookup in row + { + rEntry.eOp = SC_LESS_EQUAL; + ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); + // advance Entry.nField in Iterator upon switching columns + aCellIter.SetAdvanceQueryParamEntryField( TRUE ); + USHORT nC, nR; + if ( aCellIter.FindEqualOrSortedLastInRange( nC, nR ) ) + nDelta = nC - nCol1; + else + { + SetNV(); + return; + } + } + } + else + { + SetIllegalParameter(); + return; + } + if (pMat3) + { + if (pMat3->IsValue(nDelta)) + PushDouble(pMat3->GetDouble(nDelta)); + else + PushString(pMat3->GetString(nDelta)); + } + else + { + ScAddress aAdr; + if ( nParamCount < 3 ) + { + if (bSpVector) + { + aAdr.SetCol( nCol2 ); // data in right col of key/data range + aAdr.SetRow( nRow1 + nDelta ); + } + else + { + aAdr.SetCol( nCol1 + nDelta ); + aAdr.SetRow( nRow2 ); // data in lower row of key/data range + } + aAdr.SetTab( nTab1 ); + } + else + { + if (bSpVector) + { + aAdr.SetCol( nCol3 ); + aAdr.SetRow( nRow3 + nDelta ); + } + else + { + aAdr.SetCol( nCol3 + nDelta ); + aAdr.SetRow( nRow3 ); + } + aAdr.SetTab( nTab3 ); + } + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + PushDouble(GetCellValue( aAdr, pCell )); + else + { + String aStr; + GetCellString(aStr, pCell); + PushString(aStr); + } + } + } + + + void ScInterpreter::ScHLookup() + { + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 3, 4 ) ) + { + BOOL bSorted; + if (nParamCount == 4) + bSorted = GetBool(); + else + bSorted = TRUE; + double fIndex = ::rtl::math::approxFloor( GetDouble() ) - 1.0; + ScMatrix* pMat = NULL; + USHORT nC = 0, nR = 0; + USHORT nCol1 = 0, nRow1 = 0, nTab1 = 0, nCol2 = 0, nRow2 = 0, nTab2 = 0; + if (GetStackType() == svDoubleRef) + { + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + if (nTab1 != nTab2) + { + SetIllegalParameter(); + return; + } + } + else if (GetStackType() == svMatrix) + { + pMat = PopMatrix(); + if (pMat) + pMat->GetDimensions(nC, nR); + else + { + SetIllegalParameter(); + return; + } + } + else + { + SetIllegalParameter(); + return; + } + if ( fIndex < 0.0 || (pMat ? (fIndex >= nR) : (fIndex+nRow1 > nRow2)) ) + { + SetIllegalArgument(); + return; + } + USHORT nZIndex = (USHORT) fIndex; + if (!pMat) + nZIndex += nRow1; // Wertzeile + if (nGlobalError == 0) + { + String sStr; + ScQueryParam rParam; + rParam.nCol1 = nCol1; + rParam.nRow1 = nRow1; + rParam.nCol2 = nCol2; + rParam.nRow2 = nRow1; // nur in der ersten Zeile suchen + rParam.bHasHeader = FALSE; + rParam.bInplace = TRUE; + rParam.bCaseSens = FALSE; + rParam.bRegExp = pDok->GetDocOptions().IsFormulaRegexEnabled(); + rParam.bDuplicate = FALSE; + + ScQueryEntry& rEntry = rParam.GetEntry(0); + rEntry.bDoQuery = TRUE; + if ( bSorted ) + rEntry.eOp = SC_LESS_EQUAL; + switch ( GetStackType() ) + { + case svDouble: + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = GetDouble(); + } + break; + case svString: + { + sStr = GetString(); + rEntry.bQueryByString = TRUE; + *rEntry.pStr = sStr; + } + break; + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + PushInt(0); + return ; + } + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = GetCellValue( aAdr, pCell ); + } + else + { + if ( GetCellType( pCell ) == CELLTYPE_NOTE ) + { + rEntry.bQueryByString = FALSE; + rEntry.nVal = 0.0; + } + else + { + GetCellString(sStr, pCell); + rEntry.bQueryByString = TRUE; + *rEntry.pStr = sStr; + } + } + } + break; + default: + { + SetIllegalParameter(); + return; + } + } + if ( rEntry.bQueryByString ) + rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); + if (pMat) + { + USHORT nMatCount = nC; + short nDelta = -1; + if (rEntry.bQueryByString) + { + //!!!!!!! + //! TODO: enable regex on matrix strings + //!!!!!!! + String aParamStr = *rEntry.pStr; + USHORT i; + if ( bSorted ) + { + for (i = 0; i < nMatCount; i++) + { + if (pMat->IsString(i, 0)) + { + if ( ScGlobal::pTransliteration->isEqual( + pMat->GetString(i,0), aParamStr ) ) + i = nMatCount+1; + else + nDelta = i; + } + else + nDelta = i; + } + } + else + { + for (i = 0; i < nMatCount; i++) + { + if (pMat->IsString(i, 0)) + { + if ( ScGlobal::pTransliteration->isEqual( + pMat->GetString(i,0), aParamStr ) ) + { + nDelta = i; + i = nMatCount + 1; + } + } + } + } + } + else + { + double fVal1; + USHORT i; + if ( bSorted ) + { + for (i = 0; i < nMatCount; i++) + { + if (!pMat->IsString(i, 0)) + fVal1 = pMat->GetDouble(i,0); + else + fVal1 = MAXDOUBLE; + if (fVal1 <= rEntry.nVal) + nDelta = i; + else + i = nMatCount+1; + } + } + else + { + for (i = 0; i < nMatCount; i++) + { + if (!pMat->IsString(i, 0)) + fVal1 = pMat->GetDouble(i,0); + else + fVal1 = MAXDOUBLE; + if (fVal1 == rEntry.nVal) + { + nDelta = i; + i = nMatCount + 1; + } + } + } + } + if ( nDelta >= 0 ) + { + if (!pMat->IsString(nDelta, nZIndex)) + PushDouble(pMat->GetDouble(nDelta, nZIndex)); + else + PushString(pMat->GetString(nDelta, nZIndex)); + } + else + SetNV(); + } + else + { + rEntry.nField = nCol1; + BOOL bFound = FALSE; + USHORT nC; + if ( bSorted ) + rEntry.eOp = SC_LESS_EQUAL; + ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); + // advance Entry.nField in Iterator upon switching columns + aCellIter.SetAdvanceQueryParamEntryField( TRUE ); + if ( bSorted ) + { + USHORT nR; + bFound = aCellIter.FindEqualOrSortedLastInRange( nC, nR ); + } + else if ( aCellIter.GetFirst() ) + { + bFound = TRUE; + nC = aCellIter.GetCol(); + if ( bSorted ) + { + while ( aCellIter.GetNext() ) + nC = aCellIter.GetCol(); + } + } + if ( bFound ) + { + ScBaseCell* pCell; + ScAddress aAdr( nC, nZIndex, nTab1 ); + if ( HasCellValueData( pCell = GetCell( aAdr ) ) ) + PushDouble(GetCellValue( aAdr, pCell )); + else + { + String aStr; + GetCellString(aStr, pCell); + PushString(aStr); + } + } + else + SetNV(); + } + } + else + SetIllegalParameter(); + } + } + + +/*N*/ void ScInterpreter::ScVLookup() +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if ( MustHaveParamCount( nParamCount, 3, 4 ) ) +/*N*/ { +/*N*/ BOOL bSorted; +/*N*/ if (nParamCount == 4) +/*N*/ bSorted = GetBool(); +/*N*/ else +/*N*/ bSorted = TRUE; +/*N*/ double fIndex = ::rtl::math::approxFloor( GetDouble() ) - 1.0; +/*N*/ ScMatrix* pMat = NULL; +/*N*/ USHORT nC = 0, nR = 0; +/*N*/ USHORT nCol1 = 0, nRow1 = 0, nTab1 = 0, nCol2 = 0, nRow2 = 0, nTab2 = 0; +/*N*/ if (GetStackType() == svDoubleRef) +/*N*/ { +/*N*/ PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +/*N*/ if (nTab1 != nTab2) +/*N*/ { +/*?*/ SetIllegalParameter(); +/*?*/ return; +/*N*/ } +/*N*/ } +/*N*/ else if (GetStackType() == svMatrix) +/*N*/ { +/*?*/ pMat = PopMatrix(); +/*?*/ if (pMat) +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ else +/*?*/ { +/*?*/ SetIllegalParameter(); +/*?*/ return; +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ SetIllegalParameter(); +/*?*/ return; +/*N*/ } +/*N*/ if ( fIndex < 0.0 || (pMat ? (fIndex >= nC) : (fIndex+nCol1 > nCol2)) ) +/*N*/ { +/*?*/ SetIllegalArgument(); +/*?*/ return; +/*N*/ } +/*N*/ USHORT nSpIndex = (USHORT) fIndex; +/*N*/ if (!pMat) +/*N*/ nSpIndex += nCol1; // Wertspalte +/*N*/ if (nGlobalError == 0) +/*N*/ { +/*N*/ String sStr; +/*N*/ ScQueryParam rParam; +/*N*/ rParam.nCol1 = nCol1; +/*N*/ rParam.nRow1 = nRow1; +/*N*/ rParam.nCol2 = nCol1; // nur in der ersten Spalte suchen +/*N*/ rParam.nRow2 = nRow2; +/*N*/ rParam.bHasHeader = FALSE; +/*N*/ rParam.bInplace = TRUE; +/*N*/ rParam.bCaseSens = FALSE; +/*N*/ rParam.bRegExp = pDok->GetDocOptions().IsFormulaRegexEnabled(); +/*N*/ rParam.bDuplicate = FALSE; +/*N*/ +/*N*/ ScQueryEntry& rEntry = rParam.GetEntry(0); +/*N*/ rEntry.bDoQuery = TRUE; +/*N*/ if ( bSorted ) +/*N*/ rEntry.eOp = SC_LESS_EQUAL; +/*N*/ switch ( GetStackType() ) +/*N*/ { +/*N*/ case svDouble: +/*N*/ { +/*N*/ rEntry.bQueryByString = FALSE; +/*N*/ rEntry.nVal = GetDouble(); +/*N*/ } +/*N*/ break; +/*N*/ case svString: +/*N*/ { +/*?*/ sStr = GetString(); +/*?*/ rEntry.bQueryByString = TRUE; +/*?*/ *rEntry.pStr = sStr; +/*?*/ } +/*?*/ break; +/*N*/ case svDoubleRef : +/*N*/ case svSingleRef : +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ if ( !PopDoubleRefOrSingleRef( aAdr ) ) +/*N*/ { +/*?*/ PushInt(0); +/*?*/ return ; +/*N*/ } +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ if (HasCellValueData(pCell)) +/*N*/ { +/*?*/ rEntry.bQueryByString = FALSE; +/*?*/ rEntry.nVal = GetCellValue( aAdr, pCell ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( GetCellType( pCell ) == CELLTYPE_NOTE ) +/*N*/ { +/*?*/ rEntry.bQueryByString = FALSE; +/*?*/ rEntry.nVal = 0.0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ GetCellString(sStr, pCell); +/*N*/ rEntry.bQueryByString = TRUE; +/*N*/ *rEntry.pStr = sStr; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ { +/*?*/ SetIllegalParameter(); +/*?*/ return; +/*N*/ } +/*N*/ } +/*N*/ if ( rEntry.bQueryByString ) +/*N*/ rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); +/*N*/ if (pMat) +/*N*/ { +/*?*/ USHORT nMatCount = nR; +/*?*/ short nDelta = -1; +/*?*/ if (rEntry.bQueryByString) +/*?*/ { +/*?*/ //!!!!!!! +/*?*/ //! TODO: enable regex on matrix strings +/*?*/ //!!!!!!! +/*?*/ String aParamStr = *rEntry.pStr; +/*?*/ USHORT i; +/*?*/ if ( bSorted ) +/*?*/ { +/*?*/ for (i = 0; i < nMatCount; i++) +/*?*/ { +/*?*/ if (pMat->IsString(0, i)) +/*?*/ { +/*?*/ if ( ScGlobal::pTransliteration->isEqual( +/*?*/ pMat->GetString(0,i), aParamStr ) ) +/*?*/ i = nMatCount+1; +/*?*/ else +/*?*/ nDelta = i; +/*?*/ } +/*?*/ else +/*?*/ nDelta = i; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ for (i = 0; i < nMatCount; i++) +/*?*/ { +/*?*/ if (pMat->IsString(0, i)) +/*?*/ { +/*?*/ if ( ScGlobal::pTransliteration->isEqual( +/*?*/ pMat->GetString(0,i), aParamStr ) ) +/*?*/ { +/*?*/ nDelta = i; +/*?*/ i = nMatCount + 1; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ double fVal1; +/*?*/ USHORT i; +/*?*/ if ( bSorted ) +/*?*/ { +/*?*/ for (i = 0; i < nMatCount; i++) +/*?*/ { +/*?*/ if (!pMat->IsString(0, i)) +/*?*/ fVal1 = pMat->GetDouble(0, i); +/*?*/ else +/*?*/ fVal1 = MAXDOUBLE; +/*?*/ if (fVal1 <= rEntry.nVal) +/*?*/ nDelta = i; +/*?*/ else +/*?*/ i = nMatCount+1; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ for (i = 0; i < nMatCount; i++) +/*?*/ { +/*?*/ if (!pMat->IsString(0, i)) +/*?*/ fVal1 = pMat->GetDouble(0, i); +/*?*/ else +/*?*/ fVal1 = MAXDOUBLE; +/*?*/ if (fVal1 == rEntry.nVal) +/*?*/ { +/*?*/ nDelta = i; +/*?*/ i = nMatCount + 1; +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ } +/*?*/ if ( nDelta >= 0 ) +/*?*/ { +/*?*/ if (!pMat->IsString(nSpIndex, nDelta)) +/*?*/ PushDouble(pMat->GetDouble(nSpIndex, nDelta)); +/*?*/ else +/*?*/ PushString(pMat->GetString(nSpIndex, nDelta)); +/*?*/ } +/*?*/ else +/*?*/ SetNV(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rEntry.nField = nCol1; +/*N*/ BOOL bFound = FALSE; +/*N*/ USHORT nR; +/*N*/ if ( bSorted ) +/*N*/ rEntry.eOp = SC_LESS_EQUAL; +/*N*/ ScQueryCellIterator aCellIter(pDok, nTab1, rParam, FALSE); +/*N*/ if ( bSorted ) +/*N*/ { +/*N*/ USHORT nC; +/*N*/ bFound = aCellIter.FindEqualOrSortedLastInRange( nC, nR ); +/*N*/ } +/*N*/ else if ( aCellIter.GetFirst() ) +/*N*/ { +/*N*/ bFound = TRUE; +/*N*/ nR = aCellIter.GetRow(); +/*N*/ if ( bSorted ) +/*N*/ { +/*?*/ while (aCellIter.GetNext()) +/*?*/ nR = aCellIter.GetRow(); +/*N*/ } +/*N*/ } +/*N*/ if ( bFound ) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ ScAddress aAdr( nSpIndex, nR, nTab1 ); +/*N*/ if ( HasCellValueData( pCell = GetCell( aAdr ) ) ) +/*N*/ PushDouble(GetCellValue( aAdr, pCell )); +/*N*/ else +/*N*/ { +/*N*/ String aStr; +/*N*/ GetCellString(aStr, pCell); +/*N*/ PushString(aStr); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetNV(); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ SetIllegalParameter(); +/*N*/ } +/*N*/ } + +#if defined(WIN) && defined(MSC) +#pragma optimize("",off) +#endif + +/*N*/ void ScInterpreter::ScSubTotal() +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if ( MustHaveParamCountMin( nParamCount, 2 ) ) +/*N*/ { +/*N*/ // Wir muessen den 1. Parameter tief aus dem Stack herausfischen! +/*N*/ const ScToken* p = pStack[ sp - nParamCount ]; +/*N*/ PushTempToken( *p ); +/*N*/ int nFunc = (int) ::rtl::math::approxFloor( GetDouble() ); +/*N*/ if( nFunc < 1 || nFunc > 11 ) +/*N*/ SetIllegalParameter(); +/*N*/ else +/*N*/ { +/*N*/ cPar = nParamCount - 1; +/*N*/ glSubTotal = TRUE; +/*N*/ switch( nFunc ) +/*N*/ { +/*?*/ case SUBTOTAL_FUNC_AVE : ScAverage(); break; +/*?*/ case SUBTOTAL_FUNC_CNT : ScCount(); break; +/*?*/ case SUBTOTAL_FUNC_CNT2 : ScCount2(); break; +/*?*/ case SUBTOTAL_FUNC_MAX : ScMax(); break; +/*?*/ case SUBTOTAL_FUNC_MIN : ScMin(); break; +/*?*/ case SUBTOTAL_FUNC_PROD : ScProduct(); break; +/*?*/ case SUBTOTAL_FUNC_STD : ScStDev(); break; +/*N*/ case SUBTOTAL_FUNC_STDP : ScStDevP(); break; +/*?*/ case SUBTOTAL_FUNC_SUM : ScSum(); break; +/*?*/ case SUBTOTAL_FUNC_VAR : ScVar(); break; +/*?*/ case SUBTOTAL_FUNC_VARP : ScVarP(); break; +/*?*/ default : SetIllegalParameter(); break; +/*N*/ } +/*N*/ glSubTotal = FALSE; +/*N*/ } +/*N*/ // den abgefischten 1. Parameter entfernen +/*N*/ double nVal = GetDouble(); +/*N*/ Pop(); +/*N*/ PushDouble( nVal ); +/*N*/ } +/*N*/ } +#if defined(WIN) && defined(MSC) +#pragma optimize("",on) +#endif + + +BOOL ScInterpreter::GetDBParams(USHORT& rTab, ScQueryParam& rParam, + BOOL& rMissingField ) +{ + BOOL bRet = FALSE; + BOOL bAllowMissingField = FALSE; + if ( rMissingField ) + { + bAllowMissingField = TRUE; + rMissingField = FALSE; + } + if ( GetByte() == 3 ) + { + + USHORT nQCol1, nQRow1, nQTab1, nQCol2, nQRow2, nQTab2; + PopDoubleRef(nQCol1, nQRow1, nQTab1, nQCol2, nQRow2, nQTab2); + + BOOL bByVal = TRUE; + double nVal = 0.0; + String aStr; + ScRange aMissingRange; + BOOL bRangeFake = FALSE; + switch (GetStackType()) + { + case svDouble : + nVal = ::rtl::math::approxFloor( GetDouble() ); + if ( bAllowMissingField && nVal == 0.0 ) + rMissingField = TRUE; // fake missing parameter + break; + case svString : + bByVal = FALSE; + aStr = GetString(); + break; + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + nVal = GetCellValue( aAdr, pCell ); + else + { + bByVal = FALSE; + GetCellString(aStr, pCell); + } + } + break; + case svDoubleRef : + if ( bAllowMissingField ) + { // fake missing parameter for old SO compatibility + bRangeFake = TRUE; + PopDoubleRef( aMissingRange ); + } + else + { + PopError(); + SetError( errIllegalParameter ); + } + break; + case svMissing : + PopError(); + if ( bAllowMissingField ) + rMissingField = TRUE; + else + SetError( errIllegalParameter ); + break; + default: + PopError(); + SetError( errIllegalParameter ); + } + + USHORT nDBCol1, nDBRow1, nDBTab1, nDBCol2, nDBRow2, nDBTab2; + PopDoubleRef(nDBCol1, nDBRow1, nDBTab1, nDBCol2, nDBRow2, nDBTab2); + + if ( nGlobalError == 0 && bRangeFake ) + { + // range parameter must match entire database range + if ( aMissingRange == ScRange( nDBCol1, nDBRow1, nDBTab1, nDBCol2, + nDBRow2, nDBTab2) ) + rMissingField = TRUE; + else + SetError( errIllegalParameter ); + } + + if (nGlobalError == 0) + { + USHORT nField = nDBCol1; + BOOL bFound = TRUE; + if ( rMissingField ) + ; // special case + else if ( bByVal ) + { + if ( nVal <= 0 || nVal > (nDBCol2 - nDBCol1 + 1) ) + bFound = FALSE; + else + nField = Min(nDBCol2, (USHORT)(nDBCol1 + (USHORT)nVal - 1)); + } + else + { + bFound = FALSE; + String aCellStr; + ScAddress aLook( nDBCol1, nDBRow1, nDBTab1 ); + while (!bFound && (aLook.Col() <= nDBCol2)) + { + ScBaseCell* pCell = GetCell( aLook ); + GetCellString( aCellStr, pCell ); + bFound = ScGlobal::pTransliteration->isEqual( aCellStr, aStr ); + if (!bFound) + aLook.IncCol(); + } + nField = aLook.Col(); + } + if (bFound) + { + rParam.nCol1 = nDBCol1; + rParam.nRow1 = nDBRow1; + rParam.nCol2 = nDBCol2; + rParam.nRow2 = nDBRow2; + rParam.nTab = nDBTab1; + rParam.bHasHeader = TRUE; + rParam.bByRow = TRUE; + rParam.bInplace = TRUE; + rParam.bCaseSens = FALSE; + rParam.bRegExp = FALSE; + rParam.bDuplicate = TRUE; + if (pDok->CreateQueryParam(nQCol1, nQRow1, nQCol2, nQRow2, nQTab1, rParam)) + { + // An allowed missing field parameter sets the result field + // to any of the query fields, just to be able to return + // some cell from the iterator. + if ( rMissingField ) + nField = rParam.GetEntry(0).nField; + + rParam.nCol1 = nField; + rParam.nCol2 = nField; + rTab = nDBTab1; + bRet = TRUE; + USHORT nCount = rParam.GetEntryCount(); + for ( USHORT i=0; i < nCount; i++ ) + { + ScQueryEntry& rEntry = rParam.GetEntry(i); + if ( rEntry.bDoQuery ) + { + sal_uInt32 nIndex = 0; + rEntry.bQueryByString = !pFormatter->IsNumberFormat( + *rEntry.pStr, nIndex, rEntry.nVal ); + if ( rEntry.bQueryByString && !rParam.bRegExp ) + rParam.bRegExp = MayBeRegExp( *rEntry.pStr, pDok ); + } + else + break; // for + } + } + } + } + } + return bRet; +} + + + void ScInterpreter::DBIterator( ScIterFunc eFunc ) + { + USHORT nTab1; + double nErg = 0.0; + double fMem = 0.0; + BOOL bNull = TRUE; + ULONG nCount = 0; + ScQueryParam aQueryParam; + BOOL bMissingField = FALSE; + if ( GetDBParams( nTab1, aQueryParam, bMissingField) ) + { + double nVal; + USHORT nErr; + ScQueryValueIterator aValIter(pDok, nTab1, aQueryParam); + if ( aValIter.GetFirst(nVal, nErr) && !nErr ) + { + switch( eFunc ) + { + case ifPRODUCT: nErg = 1; break; + case ifMAX: nErg = MINDOUBLE; break; + case ifMIN: nErg = MAXDOUBLE; break; + } + do + { + nCount++; + switch( eFunc ) + { + case ifAVERAGE: + case ifSUM: + if ( bNull && nVal != 0.0 ) + { + bNull = FALSE; + fMem = nVal; + } + else + nErg += nVal; + break; + case ifSUMSQ: nErg += nVal * nVal; break; + case ifPRODUCT: nErg *= nVal; break; + case ifMAX: if( nVal > nErg ) nErg = nVal; break; + case ifMIN: if( nVal < nErg ) nErg = nVal; break; + } + } + while ( aValIter.GetNext(nVal, nErr) && !nErr ); + } + SetError(nErr); + } + else + SetIllegalParameter(); + switch( eFunc ) + { + case ifCOUNT: nErg = nCount; break; + case ifSUM: nErg = ::rtl::math::approxAdd( nErg, fMem ); break; + case ifAVERAGE: nErg = ::rtl::math::approxAdd( nErg, fMem ) / nCount; break; + } + PushDouble( nErg ); + } + + + void ScInterpreter::ScDBSum() + { + DBIterator( ifSUM ); + } + + + void ScInterpreter::ScDBCount() + { + USHORT nTab; + ScQueryParam aQueryParam; + BOOL bMissingField = TRUE; + if ( GetDBParams( nTab, aQueryParam, bMissingField) ) + { + ULONG nCount = 0; + if ( bMissingField ) + { // count all matching records + // TODO: currently the QueryIterators only return cell pointers of + // existing cells, so if a query matches an empty cell there's + // nothing returned, and therefor not counted! + // Since this has ever been the case and this code here only came + // into existance to fix #i6899 and it never worked before we'll + // have to live with it until we reimplement the iterators to also + // return empty cells, which would mean to adapt all callers of + // iterators. + ScQueryCellIterator aCellIter( pDok, nTab, aQueryParam); + if ( aCellIter.GetFirst() ) + { + do + { + nCount++; + } while ( aCellIter.GetNext() ); + } + } + else + { // count only matching records with a value in the "result" field + double nVal; + USHORT nErr = 0; + ScQueryValueIterator aValIter( pDok, nTab, aQueryParam); + if ( aValIter.GetFirst( nVal, nErr) && !nErr ) + { + do + { + nCount++; + } while ( aValIter.GetNext( nVal, nErr) && !nErr ); + } + SetError( nErr ); + } + PushDouble( nCount ); + } + else + SetIllegalParameter(); + } + + + void ScInterpreter::ScDBCount2() + { + USHORT nTab; + ScQueryParam aQueryParam; + BOOL bMissingField = FALSE; + if (GetDBParams( nTab, aQueryParam, bMissingField)) + { + ULONG nCount = 0; + ScQueryCellIterator aCellIter(pDok, nTab, aQueryParam); + if ( aCellIter.GetFirst() ) + { + do + { + nCount++; + } while ( aCellIter.GetNext() ); + } + PushDouble(nCount); + } + else + SetIllegalParameter(); + } + + + void ScInterpreter::ScDBAverage() + { + DBIterator( ifAVERAGE ); + } + + + void ScInterpreter::ScDBMax() + { + DBIterator( ifMAX ); + } + + + void ScInterpreter::ScDBMin() + { + DBIterator( ifMIN ); + } + + + void ScInterpreter::ScDBProduct() + { + DBIterator( ifPRODUCT ); + } + + + void ScInterpreter::GetDBStVarParams( double& rVal, double& rValCount ) + { + rValCount = 0.0; + double fSum = 0.0; + double fSumSqr = 0.0; + USHORT nTab; + ScQueryParam aQueryParam; + BOOL bMissingField = FALSE; + if (GetDBParams( nTab, aQueryParam, bMissingField)) + { + double fVal; + USHORT nErr; + ScQueryValueIterator aValIter(pDok, nTab, aQueryParam); + if (aValIter.GetFirst(fVal, nErr) && !nErr) + { + do + { + rValCount++; + fSum += fVal; + fSumSqr += fVal*fVal; + } + while ((nErr == 0) && aValIter.GetNext(fVal, nErr)); + } + SetError(nErr); + } + else + SetIllegalParameter(); + rVal = ::rtl::math::approxSub( fSumSqr, fSum*fSum/rValCount ); + } + + + void ScInterpreter::ScDBStdDev() + { + double fVal, fCount; + GetDBStVarParams( fVal, fCount ); + PushDouble( sqrt(fVal/(fCount-1))); + } + + + void ScInterpreter::ScDBStdDevP() + { + double fVal, fCount; + GetDBStVarParams( fVal, fCount ); + PushDouble( sqrt(fVal/fCount)); + } + + + void ScInterpreter::ScDBVar() + { + double fVal, fCount; + GetDBStVarParams( fVal, fCount ); + PushDouble(fVal/(fCount-1)); + } + + + void ScInterpreter::ScDBVarP() + { + double fVal, fCount; + GetDBStVarParams( fVal, fCount ); + PushDouble(fVal/fCount); + } + + +void ScInterpreter::ScIndirect() +{ + BYTE nParamCount = GetByte(); +/* + if (nParamCount == 2) + { + double fBool = GetDouble(); + if (fBool == 0.0) // nur TRUE erlaubt!! + { + SetIllegalParameter(); + return; + } + else + nParamCount = 1; + } +*/ + if ( MustHaveParamCount( nParamCount, 1 ) ) + { + USHORT nTab = aPos.Tab(); + String sRefStr( GetString() ); + ScRefTripel aRefTr, aRefTr2; + if ( ConvertDoubleRef( pDok, sRefStr, nTab, aRefTr, aRefTr2 ) ) + PushDoubleRef( aRefTr.GetCol(), aRefTr.GetRow(), aRefTr.GetTab(), + aRefTr2.GetCol(), aRefTr2.GetRow(), aRefTr2.GetTab() ); + else if ( ConvertSingleRef( pDok, sRefStr, nTab, aRefTr ) ) + PushSingleRef( aRefTr.GetCol(), aRefTr.GetRow(), aRefTr.GetTab() ); + else + SetIllegalArgument(); + } +} + + +void ScInterpreter::ScAdress() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 4 ) ) + { + String sTabStr; + USHORT nAbs = 1; + if (nParamCount == 4) + sTabStr = GetString(); + if (nParamCount >= 3) + nAbs = (USHORT) ::rtl::math::approxFloor(GetDouble()); + USHORT nCol = (USHORT) ::rtl::math::approxFloor(GetDouble()); + USHORT nRow = (USHORT) ::rtl::math::approxFloor(GetDouble()); + if (nCol < 1 || nCol > MAXCOL + 1 || nRow < 1 || nRow > MAXROW + 1) + { + SetIllegalParameter(); + return; + } + else + { + nRow--; + nCol--; + } + String aRefStr; + ScTripel aScTr; + aScTr.SetCol(nCol); + aScTr.SetRow(nRow); + if (nAbs == 4) + aRefStr = aScTr.GetColRowString(); + else + { + aRefStr = aScTr.GetColRowString(TRUE); + if (nAbs == 2) + aRefStr.EraseLeadingChars('$'); + else if (nAbs == 3) + aRefStr.Erase(aRefStr.Search('$',1),1); + } + if ( sTabStr.Len() ) + { + aRefStr.Insert('.',0); + aRefStr.Insert(sTabStr,0); + } + PushString(aRefStr); + } +} + + +void ScInterpreter::ScOffset() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 3, 5 ) ) + { + short nColNew, nRowNew, nColPlus, nRowPlus; + if (nParamCount == 5) + nColNew = (short) ::rtl::math::approxFloor(GetDouble()); + if (nParamCount >= 4) + nRowNew = (short) ::rtl::math::approxFloor(GetDouble()); + nColPlus = (short) ::rtl::math::approxFloor(GetDouble()); + nRowPlus = (short) ::rtl::math::approxFloor(GetDouble()); + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + if ( (nParamCount == 5 && nColNew == 0) + || (nParamCount >= 4 && nRowNew == 0) ) + { + SetIllegalParameter(); + return; + } + if (GetStackType() == svSingleRef) + { + PopSingleRef(nCol1, nRow1, nTab1); + if (nParamCount == 3) + { + nCol1 = (USHORT)((short) nCol1 + nColPlus); + nRow1 = (USHORT)((short) nRow1 + nRowPlus); + if (nCol1 > MAXCOL || nRow1 > MAXROW) + SetIllegalParameter(); + else + PushSingleRef(nCol1, nRow1, nTab1); + } + else + { + if (nParamCount == 4) + nColNew = 1; + nCol1 = (USHORT)((short)nCol1+nColPlus); // ! nCol1 wird veraendert! + nRow1 = (USHORT)((short)nRow1+nRowPlus); + nCol2 = (USHORT)((short)nCol1+nColNew-1); + nRow2 = (USHORT)((short)nRow1+nRowNew-1); + if (nCol1 > MAXCOL || nRow1 > MAXROW || + nCol2 > MAXCOL || nRow2 > MAXROW) + SetIllegalParameter(); + else + PushDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab1); + } + } + else if (GetStackType() == svDoubleRef) + { + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + if (nParamCount < 5) + nColNew = nCol2 - nCol1 + 1; + if (nParamCount < 4) + nRowNew = nRow2 - nRow1 + 1; + nCol1 = (USHORT)((short)nCol1+nColPlus); + nRow1 = (USHORT)((short)nRow1+nRowPlus); + nCol2 = (USHORT)((short)nCol1+nColNew-1); + nRow2 = (USHORT)((short)nRow1+nRowNew-1); + if (nCol1 > MAXCOL || nRow1 > MAXROW || + nCol2 > MAXCOL || nRow2 > MAXROW || nTab1 != nTab2) + SetIllegalParameter(); + else + PushDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab1); + } + else + SetIllegalParameter(); + } +} + + +void ScInterpreter::ScIndex() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 1, 4 ) ) + { + short nBereich, nMaxAnz, nCount; + USHORT nCol, nRow; + if (nParamCount == 4) + nBereich = (short) ::rtl::math::approxFloor(GetDouble()); + else + nBereich = 1; + if (nParamCount >= 3) + nCol = (USHORT) ::rtl::math::approxFloor(GetDouble()); + else + nCol = 0; + if (nParamCount >= 2) + nRow = (USHORT) ::rtl::math::approxFloor(GetDouble()); + else + nRow = 0; + if (GetStackType() == svByte) // vorher MultiSelektion? + nMaxAnz = (short) PopByte(); + else // sonst Einzelselektion + nMaxAnz = 1; + if (nBereich > nMaxAnz || nBereich < 1) + { + SetIllegalParameter(); + return; + } + if (GetStackType() == svMatrix) + { + if (nBereich != 1) + SetError(errIllegalParameter); + USHORT nMatInd1; + USHORT nOldSp = sp; + ScMatrix* pMat = GetMatrix(nMatInd1); + if (pMat) + { + USHORT nC, nR, nMatInd; + pMat->GetDimensions(nC, nR); + if (nC == 0 || nR == 0 || nCol > nC || nRow > nR) + SetIllegalArgument(); + else if (nCol == 0 && nRow == 0) + sp = nOldSp; + else if (nRow == 0) + { + ScMatrix* pResMat = GetNewMat(nC, 1, nMatInd); + if (pResMat) + { + USHORT nColMinus1 = nCol - 1; + for (USHORT i = 0; i < nC; i++) + if (!pMat->IsString(i, nColMinus1)) + pResMat->PutDouble(pMat->GetDouble(i, + nColMinus1), i, 0); + else + pResMat->PutString(pMat->GetString(i, + nColMinus1), i, 0); + PushMatrix(pResMat); + nRetMat = nMatInd; + } + else + SetNoValue(); + } + else if (nCol == 0) + { + ScMatrix* pResMat = GetNewMat(1, nR, nMatInd); + if (pResMat) + { + USHORT nRowMinus1 = nRow - 1; + for (USHORT i = 0; i < nR; i++) + if (!pMat->IsString(nRowMinus1, i)) + pResMat->PutDouble(pMat->GetDouble(nRowMinus1, + i), i); + else + pResMat->PutString(pMat->GetString(nRowMinus1, + i), i); + PushMatrix(pResMat); + nRetMat = nMatInd; + } + else + SetNoValue(); + } + else + { + if (!pMat->IsString(nCol-1, nRow-1)) + PushDouble(pMat->GetDouble(nCol-1, nRow-1)); + else + PushString(pMat->GetString(nCol-1, nRow-1)); + } + ResetNewMat(nMatInd1); + } + } + else if (GetStackType() == svSingleRef || GetStackType() == svDoubleRef) + { + ScAddress aDummyAdr; + ScRange aDummyRange; + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 = MAXTAB+1; + nCount = nMaxAnz; // Refs liegen umgekehrt auf dem Stack! + while (nCount > nBereich && !nGlobalError) // erste Refs weg + { + nCount--; + if ( GetStackType() == svSingleRef ) + PopSingleRef( aDummyAdr ); + else if ( GetStackType() == svDoubleRef ) + PopDoubleRef( aDummyRange ); + } + while (nCount > nBereich-1 && !nGlobalError) // richtigen Teilbezug + { + nCount--; + if (GetStackType() == svSingleRef) + PopSingleRef(nCol1, nRow1, nTab1); + else if (GetStackType() == svDoubleRef) + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + } + while (nCount > 0 && !nGlobalError) // restliche Refs weg + { + nCount--; + if ( GetStackType() == svSingleRef ) + PopSingleRef( aDummyAdr ); + else if ( GetStackType() == svDoubleRef ) + PopDoubleRef( aDummyRange ); + } + if (nTab2 == MAXTAB+1) // SingleRef + { + if (nCol > 1 || nRow > 1) + SetIllegalParameter(); + else + PushSingleRef(nCol1, nRow1, nTab1); + } + else // DoubleRef + { + if ( nTab1 != nTab2 || + (nCol > 0 && nCol1+nCol-1 > nCol2) || + (nRow > 0 && nRow1+nRow-1 > nRow2) ) + SetIllegalParameter(); + else if (nCol == 0 && nRow == 0) + { + if ( nCol1 == nCol2 && nRow1 == nRow2 ) + PushSingleRef( nCol1, nRow1, nTab1 ); + else + PushDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab1 ); + } + else if (nRow == 0) + { + if ( nRow1 == nRow2 ) + PushSingleRef( nCol1+nCol-1, nRow1, nTab1 ); + else + PushDoubleRef( nCol1+nCol-1, nRow1, nTab1, + nCol1+nCol-1, nRow2, nTab1 ); + } + else if (nCol == 0) + { + if ( nCol1 == nCol2 ) + PushSingleRef( nCol1, nRow1+nRow-1, nTab1 ); + else + PushDoubleRef(nCol1, nRow1+nRow-1, nTab1, + nCol2, nRow1+nRow-1, nTab1); + } + else + PushSingleRef(nCol1+nCol-1, nRow1+nRow-1, nTab1); + } + } + else + SetIllegalParameter(); + } +} + + +void ScInterpreter::ScMultiArea() +{ + // Hier ist nichts zu tun, der paramCount von ScMultiSelektion + // bleibt auf dem Stack !! + // Den muessen die nachfolgenden Funktionen (Index ...) wegraeumen !! +} + + +void ScInterpreter::ScAreas() +{ + BYTE nParamCount = GetByte(); + double fMaxAnz = 1.0; + ScAddress aDummyAdr; + ScRange aDummyRange; + for (USHORT i = 0; i < nParamCount && nGlobalError == 0; i++) + { + if (GetStackType() == svByte) // vorher MultiSelektion? + { + double fCount = 0.0; + fMaxAnz = (double) GetByte(); + while (fCount < fMaxAnz && !nGlobalError) // mehrere Refs + { + fCount++; + if (GetStackType() == svSingleRef) + PopSingleRef( aDummyAdr ); + else if (GetStackType() == svDoubleRef) + PopDoubleRef( aDummyRange ); + else + SetIllegalParameter(); + } + } + else if (GetStackType() == svSingleRef) + PopSingleRef( aDummyAdr ); + else if (GetStackType() == svDoubleRef) + PopDoubleRef( aDummyRange ); + else + SetIllegalParameter(); + } + if (nGlobalError == 0) + PushDouble((double)nParamCount + fMaxAnz - 1.0); +} + + +void ScInterpreter::ScCurrency() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 1, 2 ) ) + { + String aStr; + double fDec; + if (nParamCount == 2) + { + fDec = ::rtl::math::approxFloor(GetDouble()); + if (fDec < -15.0 || fDec > 15.0) + { + SetIllegalArgument(); + return; + } + } + else + fDec = 2.0; + double fVal = GetDouble(); + double fFac; + if ( fDec != 0.0 ) + fFac = pow( (double)10, fDec ); + else + fFac = 1.0; + if (fVal < 0.0) + fVal = ceil(fVal*fFac-0.5)/fFac; + else + fVal = floor(fVal*fFac+0.5)/fFac; + Color* pColor = NULL; + if ( fDec < 0.0 ) + fDec = 0.0; + ULONG nIndex = pFormatter->GetStandardFormat( + NUMBERFORMAT_CURRENCY, + ScGlobal::eLnge); + if ( (USHORT) fDec != pFormatter->GetFormatPrecision( nIndex ) ) + { + String sFormatString; + pFormatter->GenerateFormat(sFormatString, + nIndex, + ScGlobal::eLnge, + TRUE, // mit Tausenderpunkt + FALSE, // nicht rot + (USHORT) fDec,// Nachkommastellen + 1); // 1 Vorkommanull + if (!pFormatter->GetPreviewString(sFormatString, + fVal, + aStr, + &pColor, + ScGlobal::eLnge)) + SetError(errIllegalParameter); + } + else + { + pFormatter->GetOutputString(fVal, nIndex, aStr, &pColor); + } + PushString(aStr); + } +} + + +void ScInterpreter::ScReplace() +{ + if ( MustHaveParamCount( GetByte(), 4 ) ) + { + String aNewStr( GetString() ); + short nCount = (short) GetDouble(); + short nPos = (short) GetDouble(); + String aOldStr( GetString() ); + if( nPos < 1 || nCount < 1 ) + SetIllegalArgument(); + else + { + aOldStr.Erase( nPos-1, nCount ); + if ( CheckStringResultLen( aOldStr, aNewStr ) ) + aOldStr.Insert( aNewStr, nPos-1 ); + PushString( aOldStr ); + } + } +} + + +void ScInterpreter::ScFixed() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 1, 3 ) ) + { + String aStr; + double fDec; + BOOL bThousand; + if (nParamCount == 3) + bThousand = !GetBool(); // Param TRUE: keine Tausenderpunkte + else + bThousand = TRUE; + if (nParamCount >= 2) + { + fDec = ::rtl::math::approxFloor(GetDouble()); + if (fDec < -15.0 || fDec > 15.0) + { + SetIllegalArgument(); + return; + } + } + else + fDec = 2.0; + double fVal = GetDouble(); + double fFac; + if ( fDec != 0.0 ) + fFac = pow( (double)10, fDec ); + else + fFac = 1.0; + if (fVal < 0.0) + fVal = ceil(fVal*fFac-0.5)/fFac; + else + fVal = floor(fVal*fFac+0.5)/fFac; + Color* pColor = NULL; + String sFormatString; + if (fDec < 0.0) + fDec = 0.0; + ULONG nIndex = pFormatter->GetStandardFormat( + NUMBERFORMAT_NUMBER, + ScGlobal::eLnge); + pFormatter->GenerateFormat(sFormatString, + nIndex, + ScGlobal::eLnge, + bThousand, // mit Tausenderpunkt + FALSE, // nicht rot + (USHORT) fDec,// Nachkommastellen + 1); // 1 Vorkommanull + if (!pFormatter->GetPreviewString(sFormatString, + fVal, + aStr, + &pColor, + ScGlobal::eLnge)) + SetIllegalParameter(); + else + PushString(aStr); + } +} + + +void ScInterpreter::ScFind() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + double fAnz; + if (nParamCount == 3) + fAnz = GetDouble(); + else + fAnz = 1.0; + String sStr = GetString(); + if( fAnz < 1.0 || fAnz > (double) sStr.Len() ) + SetNoValue(); + else + { + xub_StrLen nPos = sStr.Search( GetString(), (xub_StrLen) fAnz - 1 ); + if (nPos == STRING_NOTFOUND) + SetNoValue(); + else + PushDouble((double)(nPos + 1)); + } + } +} + + +void ScInterpreter::ScExact() +{ + nFuncFmtType = NUMBERFORMAT_LOGICAL; + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + String s1( GetString() ); + String s2( GetString() ); + PushInt( s1 == s2 ); + } +} + + +void ScInterpreter::ScLeft() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 1, 2 ) ) + { + xub_StrLen n; + if (nParamCount == 2) + { + double nVal = ::rtl::math::approxFloor(GetDouble()); + if ( nVal < 0.0 || nVal > STRING_MAXLEN ) + { + SetIllegalParameter(); + return ; + } + else + n = (xub_StrLen) nVal; + } + else + n = 1; + String aStr( GetString() ); + aStr.Erase( n ); + PushString( aStr ); + } +} + + +void ScInterpreter::ScRight() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 1, 2 ) ) + { + xub_StrLen n; + if (nParamCount == 2) + { + double nVal = ::rtl::math::approxFloor(GetDouble()); + if ( nVal < 0.0 || nVal > STRING_MAXLEN ) + { + SetIllegalParameter(); + return ; + } + else + n = (xub_StrLen) nVal; + } + else + n = 1; + String aStr( GetString() ); + if( n < aStr.Len() ) + aStr.Erase( 0, aStr.Len() - n ); + PushString( aStr ); + } +} + + +void ScInterpreter::ScSearch() +{ + double fAnz; + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + if (nParamCount == 3) + { + fAnz = ::rtl::math::approxFloor(GetDouble()); + if (fAnz > double(STRING_MAXLEN)) + { + SetIllegalParameter(); + return; + } + } + else + fAnz = 1.0; + String sStr = GetString(); + String SearchStr = GetString(); + xub_StrLen nPos = (xub_StrLen) fAnz - 1; + xub_StrLen nEndPos = sStr.Len(); + if( nPos >= nEndPos ) + SetNoValue(); + else + { + ::utl::SearchParam::SearchType eSearchType = + (MayBeRegExp( SearchStr, pDok ) ? + ::utl::SearchParam::SRCH_REGEXP : ::utl::SearchParam::SRCH_NORMAL); + ::utl::SearchParam sPar(SearchStr, eSearchType, FALSE, FALSE, FALSE); + ::utl::TextSearch sT( sPar, *ScGlobal::pCharClass ); + int nBool = sT.SearchFrwrd(sStr, &nPos, &nEndPos); + if (!nBool) + SetNoValue(); + else + PushDouble((double)(nPos) + 1); + } + } +} + + +void ScInterpreter::ScMid() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double fAnz = ::rtl::math::approxFloor(GetDouble()); + double fAnfang = ::rtl::math::approxFloor(GetDouble()); + const String& rStr = GetString(); + if (fAnfang < 1.0 || fAnz < 0.0 || fAnfang > double(STRING_MAXLEN) || fAnz > double(STRING_MAXLEN)) + SetIllegalParameter(); + else + PushString(rStr.Copy( (xub_StrLen) fAnfang - 1, (xub_StrLen) fAnz )); + } +} + + +/*N*/ void ScInterpreter::ScText() +/*N*/ { +/*N*/ if ( MustHaveParamCount( GetByte(), 2 ) ) +/*N*/ { +/*N*/ String sFormatString = GetString(); +/*N*/ double fVal = GetDouble(); +/*N*/ String aStr; +/*N*/ Color* pColor = NULL; +/*N*/ LanguageType eCellLang; +/*N*/ const ScPatternAttr* pPattern = pDok->GetPattern( +/*N*/ aPos.Col(), aPos.Row(), aPos.Tab() ); +/*N*/ if ( pPattern ) +/*N*/ eCellLang = ((const SvxLanguageItem&) +/*N*/ pPattern->GetItem( ATTR_LANGUAGE_FORMAT )).GetValue(); +/*N*/ else +/*?*/ eCellLang = ScGlobal::eLnge; +/*N*/ if ( !pFormatter->GetPreviewStringGuess( sFormatString, fVal, aStr, +/*N*/ &pColor, eCellLang ) ) +/*?*/ SetIllegalParameter(); +/*N*/ else +/*N*/ PushString(aStr); +/*N*/ } +/*N*/ } + + +void ScInterpreter::ScSubstitute() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 3, 4 ) ) + { + xub_StrLen nAnz; + if (nParamCount == 4) + { + double fAnz = ::rtl::math::approxFloor(GetDouble()); + if( fAnz < 1 || fAnz > STRING_MAXLEN ) + { + SetIllegalParameter(); + return; + } + else + nAnz = (xub_StrLen) fAnz; + } + else + nAnz = 0; + String sNewStr = GetString(); + String sOldStr = GetString(); + String sStr = GetString(); + xub_StrLen nPos = 0; + xub_StrLen nCount = 0; + xub_StrLen nNewLen = sNewStr.Len(); + xub_StrLen nOldLen = sOldStr.Len(); + while( TRUE ) + { + nPos = sStr.Search( sOldStr, nPos ); + if (nPos != STRING_NOTFOUND) + { + nCount++; + if( !nAnz || nCount == nAnz ) + { + sStr.Erase(nPos,nOldLen); + if ( CheckStringResultLen( sStr, sNewStr ) ) + { + sStr.Insert(sNewStr,nPos); + nPos += nNewLen; + } + else + break; + } + else + nPos++; + } + else + break; + } + PushString( sStr ); + } +} + + +void ScInterpreter::ScRept() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double fAnz = ::rtl::math::approxFloor(GetDouble()); + String aStr( GetString() ); + if ( fAnz < 0.0 ) + SetIllegalParameter(); + else if ( fAnz * aStr.Len() > STRING_MAXLEN ) + { + SetError( errStringOverflow ); + PushInt(0); + } + else if ( fAnz == 0.0 ) + PushString( EMPTY_STRING ); + else + { + xub_StrLen n = (xub_StrLen) fAnz; + const xub_StrLen nLen = aStr.Len(); + String aRes; + const sal_Unicode* const pSrc = aStr.GetBuffer(); + sal_Unicode* pDst = aRes.AllocBuffer( n * nLen ); + while( n-- ) + { + memcpy( pDst, pSrc, nLen * sizeof(sal_Unicode) ); + pDst += nLen; + } + PushString( aRes ); + } + } +} + + +void ScInterpreter::ScConcat() +{ + BYTE nParamCount = GetByte(); + String aRes; + while( nParamCount-- ) + { + const String& rStr = GetString(); + aRes.Insert( rStr, 0 ); + } + PushString( aRes ); +} + + +/*N*/ void ScInterpreter::ScErrorType() +/*N*/ { +/*N*/ USHORT nErr; +/*N*/ USHORT nOldError = nGlobalError; +/*N*/ nGlobalError = 0; +/*N*/ switch ( GetStackType() ) +/*N*/ { +/*N*/ case svDoubleRef : +/*N*/ { +/*N*/ ScRange aRange; +/*N*/ PopDoubleRef( aRange ); +/*N*/ if ( nGlobalError ) +/*N*/ nErr = nGlobalError; +/*N*/ else +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ if ( DoubleRefToPosSingleRef( aRange, aAdr ) ) +/*N*/ nErr = pDok->GetErrCode( aAdr ); +/*N*/ else +/*N*/ nErr = nGlobalError; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svSingleRef : +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ PopSingleRef( aAdr ); +/*N*/ if ( nGlobalError ) +/*N*/ nErr = nGlobalError; +/*N*/ else +/*N*/ nErr = pDok->GetErrCode( aAdr ); +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ PopError(); +/*N*/ nErr = nGlobalError; +/*N*/ } +/*N*/ if ( nErr ) +/*N*/ { +/*N*/ nGlobalError = 0; +/*N*/ PushDouble( nErr ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nGlobalError = nOldError; +/*N*/ SetNV(); +/*N*/ } +/*N*/ } + + +/*N*/ BOOL ScInterpreter::MayBeRegExp( const String& rStr, const ScDocument* pDoc ) +/*N*/ { +/*N*/ if ( pDoc && !pDoc->GetDocOptions().IsFormulaRegexEnabled() ) +/*N*/ return FALSE; +/*N*/ if ( !rStr.Len() || (rStr.Len() == 1 && rStr.GetChar(0) != '.') ) +/*N*/ return FALSE; // einzelnes Metazeichen kann keine RegExp sein +/*N*/ static const sal_Unicode cre[] = { '.','*','+','?','[',']','^','$','\\','<','>','(',')','|', 0 }; +/*N*/ const sal_Unicode* p1 = rStr.GetBuffer(); +/*N*/ sal_Unicode c1; +/*N*/ while ( c1 = *p1++ ) +/*N*/ { +/*N*/ const sal_Unicode* p2 = cre; +/*N*/ while ( *p2 ) +/*N*/ { +/*N*/ if ( c1 == *p2++ ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_interpr2.cxx b/binfilter/bf_sc/source/core/tool/sc_interpr2.cxx new file mode 100644 index 000000000000..52bdf1dc6238 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_interpr2.cxx @@ -0,0 +1,2149 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <bf_svx/linkmgr.hxx> +#include <bf_svtools/zforlist.hxx> +#include <string.h> +#include <math.h> +#include <sal/macros.h> + +#include "interpre.hxx" +#include "bf_sc.hrc" +#include "ddelink.hxx" +#include "scmatrix.hxx" +#include "dociter.hxx" +#include "unitconv.hxx" +#include "globstr.hrc" +#include "hints.hxx" + +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +#define D_TIMEFACTOR 86400.0 +#define SCdEpsilon 1.0E-7 + +//----------------------------------------------------------------------------- +// Datum und Zeit +//----------------------------------------------------------------------------- + +/*N*/ double ScInterpreter::GetDate(INT16 nYear, INT16 nMonth, INT16 nDay) +/*N*/ { +/*N*/ if ( nYear < 100 ) +/*?*/ nYear = pFormatter->ExpandTwoDigitYear( nYear ); +/*N*/ INT16 nY, nM; +/*N*/ if (nMonth > 0) +/*N*/ { +/*N*/ nY = nYear + (nMonth-1) / 12; +/*N*/ nM = ((nMonth-1) % 12) + 1; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ nY = nYear + (nMonth-12) / 12; +/*?*/ nM = 12 - (-nMonth) % 12; +/*N*/ } +/*N*/ Date aDate(1, nM, nY); +/*N*/ aDate += nDay - 1; +/*N*/ if (aDate.IsValid()) +/*N*/ return (double) (aDate - *(pFormatter->GetNullDate())); +/*N*/ else +/*N*/ { +/*?*/ SetError(errNoValue); +/*?*/ return 0; +/*N*/ } +/*N*/ } + +//----------------------------------------------------------------------------- +// Funktionen +//----------------------------------------------------------------------------- + +/*N*/ void ScInterpreter::ScGetActDate() +/*N*/ { +/*N*/ nFuncFmtType = NUMBERFORMAT_DATE; +/*N*/ Date aActDate; +/*N*/ long nDiff = aActDate - *(pFormatter->GetNullDate()); +/*N*/ PushDouble((double) nDiff); +/*N*/ } + +void ScInterpreter::ScGetActTime() +{ + nFuncFmtType = NUMBERFORMAT_DATETIME; + Date aActDate; + long nDiff = aActDate - *(pFormatter->GetNullDate()); + Time aActTime; + double nTime = ((double)aActTime.Get100Sec() / 100 + + (double)(aActTime.GetSec() + + (aActTime.GetMin() * 60) + + (aActTime.GetHour() * 3600))) / D_TIMEFACTOR; + PushDouble( (double) nDiff + nTime ); +} + +void ScInterpreter::ScGetYear() +{ + Date aDate = *(pFormatter->GetNullDate()); + aDate += (long) ::rtl::math::approxFloor(GetDouble()); + PushDouble( (double) aDate.GetYear() ); +} + +void ScInterpreter::ScGetMonth() +{ + Date aDate = *(pFormatter->GetNullDate()); + aDate += (long) ::rtl::math::approxFloor(GetDouble()); + PushDouble( (double) aDate.GetMonth() ); +} + +/*N*/ void ScInterpreter::ScGetDay() +/*N*/ { +/*N*/ Date aDate = *(pFormatter->GetNullDate()); +/*N*/ aDate += (long)::rtl::math::approxFloor(GetDouble()); +/*N*/ PushDouble((double) aDate.GetDay()); +/*N*/ } + +void ScInterpreter::ScGetMin() +{ + double fTime = GetDouble(); + fTime -= ::rtl::math::approxFloor(fTime); // Datumsanteil weg + long nVal = (long)::rtl::math::approxFloor(fTime*D_TIMEFACTOR+0.5) % 3600; + PushDouble( (double) (nVal/60) ); +} + +void ScInterpreter::ScGetSec() +{ + double fTime = GetDouble(); + fTime -= ::rtl::math::approxFloor(fTime); // Datumsanteil weg + long nVal = (long)::rtl::math::approxFloor(fTime*D_TIMEFACTOR+0.5) % 60; + PushDouble( (double) nVal ); +} + +void ScInterpreter::ScGetHour() +{ + double fTime = GetDouble(); + fTime -= ::rtl::math::approxFloor(fTime); // Datumsanteil weg + long nVal = (long)::rtl::math::approxFloor(fTime*D_TIMEFACTOR+0.5) / 3600; + PushDouble((double) nVal); +} + +void ScInterpreter::ScGetDateValue() +{ + String aInputString = GetString(); + sal_uInt32 nFIndex = 0; // damit default Land/Spr. + double fVal; + if (pFormatter->IsNumberFormat(aInputString, nFIndex, fVal)) + { + short eType = pFormatter->GetType(nFIndex); + if (eType == NUMBERFORMAT_DATE || eType == NUMBERFORMAT_DATETIME) + PushDouble(fVal); + else + SetIllegalArgument(); + } + else + SetIllegalArgument(); +} + +/*N*/ void ScInterpreter::ScGetDayOfWeek() +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if ( MustHaveParamCount( nParamCount, 1, 2 ) ) +/*N*/ { +/*N*/ short nFlag; +/*N*/ if (nParamCount == 2) +/*?*/ nFlag = (short) ::rtl::math::approxFloor(GetDouble()); +/*N*/ else +/*N*/ nFlag = 1; +/*N*/ +/*N*/ Date aDate = *(pFormatter->GetNullDate()); +/*N*/ aDate += (long)::rtl::math::approxFloor(GetDouble()); +/*N*/ int nVal = (int) aDate.GetDayOfWeek(); +/*N*/ if (nFlag == 1) +/*N*/ { +/*N*/ if (nVal == 6) +/*N*/ nVal = 1; +/*N*/ else +/*N*/ nVal += 2; +/*N*/ } +/*N*/ else if (nFlag == 2) +/*N*/ nVal += 1; +/*N*/ PushInt( nVal ); +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ScGetWeekOfYear() +/*N*/ { +/*N*/ if ( MustHaveParamCount( GetByte(), 2 ) ) +/*N*/ { +/*N*/ short nFlag = (short) ::rtl::math::approxFloor(GetDouble()); +/*N*/ +/*N*/ Date aDate = *(pFormatter->GetNullDate()); +/*N*/ aDate += (long)::rtl::math::approxFloor(GetDouble()); +/*N*/ PushInt( (int) aDate.GetWeekOfYear( nFlag == 1 ? SUNDAY : MONDAY )); +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ScEasterSunday() +/*N*/ { +/*N*/ nFuncFmtType = NUMBERFORMAT_DATE; +/*N*/ if ( MustHaveParamCount( GetByte(), 1 ) ) +/*N*/ { +/*N*/ INT16 nDay, nMonth, nYear; +/*N*/ nYear = (INT16) ::rtl::math::approxFloor( GetDouble() ); +/*N*/ if ( nYear < 100 ) +/*?*/ nYear = pFormatter->ExpandTwoDigitYear( nYear ); +/*N*/ // don't worry, be happy :) +/*N*/ int B,C,D,E,F,G,H,I,K,L,M,N,O; +/*N*/ N = nYear % 19; +/*N*/ B = int(nYear / 100); +/*N*/ C = nYear % 100; +/*N*/ D = int(B / 4); +/*N*/ E = B % 4; +/*N*/ F = int((B + 8) / 25); +/*N*/ G = int((B - F + 1) / 3); +/*N*/ H = (19 * N + B - D - G + 15) % 30; +/*N*/ I = int(C / 4); +/*N*/ K = C % 4; +/*N*/ L = (32 + 2 * E + 2 * I - H - K) % 7; +/*N*/ M = int((N + 11 * H + 22 * L) / 451); +/*N*/ O = H + L - 7 * M + 114; +/*N*/ nDay = O % 31 + 1; +/*N*/ nMonth = int(O / 31); +/*N*/ PushDouble( GetDate( nYear, nMonth, nDay ) ); +/*N*/ } +/*N*/ } + +void ScInterpreter::ScGetDate() +{ + nFuncFmtType = NUMBERFORMAT_DATE; + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + INT16 nDay = (INT16) ::rtl::math::approxFloor(GetDouble()); + INT16 nMonth = (INT16) ::rtl::math::approxFloor(GetDouble()); + INT16 nYear = (INT16) ::rtl::math::approxFloor(GetDouble()); + if (nYear < 0) + SetIllegalParameter(); + else + { + PushDouble(GetDate(nYear, nMonth, nDay)); + } + } +} + +void ScInterpreter::ScGetTime() +{ + nFuncFmtType = NUMBERFORMAT_TIME; + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double nSec = GetDouble(); + double nMin = GetDouble(); + double nHour = GetDouble(); + PushDouble( ( (nHour * 3600) + (nMin * 60) + nSec ) / D_TIMEFACTOR ); + } +} + +void ScInterpreter::ScGetDiffDate() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double nDate2 = GetDouble(); + double nDate1 = GetDouble(); + PushDouble(nDate1 - nDate2); + } +} + +void ScInterpreter::ScGetDiffDate360() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + BOOL bFlag; + if (nParamCount == 3) + bFlag = GetBool(); + else + bFlag = FALSE; + double nDate2 = GetDouble(); + double nDate1 = GetDouble(); + double fSign; + if (nGlobalError == 0) + { + if (nDate2 < nDate1) + { + fSign = nDate1; + nDate1 = nDate2; + nDate2 = fSign; + fSign = -1.0; + } + else + fSign = 1.0; + Date aDate1 = *(pFormatter->GetNullDate()); + aDate1 += (long) ::rtl::math::approxFloor(nDate1); + Date aDate2 = *(pFormatter->GetNullDate()); + aDate2 += (long) ::rtl::math::approxFloor(nDate2); + if (aDate1.GetDay() == 31) + aDate1 -= (ULONG) 1; + else if (!bFlag) + { + if (aDate1.GetMonth() == 2) + { + switch ( aDate1.GetDay() ) + { + case 28 : + if ( !aDate1.IsLeapYear() ) + aDate1.SetDay(30); + break; + case 29 : + aDate1.SetDay(30); + break; + } + } + } + if (aDate2.GetDay() == 31) + { + if (!bFlag && aDate1.GetDay() != 30) + aDate2 += (ULONG) 1; // -> 1. + else + aDate2.SetDay(30); + } + PushDouble( fSign * (double) + ( (double) aDate2.GetDay() + (double) aDate2.GetMonth() * 30.0 + + (double) aDate2.GetYear() * 360.0 + - (double) aDate1.GetDay() - (double) aDate1.GetMonth() * 30.0 + - (double)aDate1.GetYear() * 360.0) ); + } + else + SetIllegalParameter(); + } +} + +void ScInterpreter::ScGetTimeValue() +{ + String aInputString = GetString(); + sal_uInt32 nFIndex = 0; // damit default Land/Spr. + double fVal; + if (pFormatter->IsNumberFormat(aInputString, nFIndex, fVal)) + { + short eType = pFormatter->GetType(nFIndex); + if (eType == NUMBERFORMAT_TIME || eType == NUMBERFORMAT_DATETIME) + PushDouble(fVal); + else + SetIllegalArgument(); + } + else + SetIllegalArgument(); +} + +/*N*/ void ScInterpreter::ScPlusMinus() +/*N*/ { +/*N*/ double nVal = GetDouble(); +/*N*/ short n = 0; +/*N*/ if (nVal < 0.0) +/*N*/ n = -1; +/*N*/ else if (nVal > 0.0) +/*N*/ n = 1; +/*N*/ PushInt( n ); +/*N*/ } + +void ScInterpreter::ScAbs() +{ + PushDouble(fabs(GetDouble())); +} + +/*N*/ void ScInterpreter::ScInt() +/*N*/ { +/*N*/ PushDouble(::rtl::math::approxFloor(GetDouble())); +/*N*/ } + + +/*N*/ void ScInterpreter::RoundNumber( rtl_math_RoundingMode eMode ) +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if ( MustHaveParamCount( nParamCount, 1, 2 ) ) +/*N*/ { +/*N*/ double fVal = 0.0; +/*N*/ if (nParamCount == 1) +/*N*/ fVal = ::rtl::math::round( GetDouble(), 0, eMode ); +/*N*/ else +/*N*/ { +/*N*/ INT32 nDec = (INT32) ::rtl::math::approxFloor(GetDouble()); +/*N*/ if( nDec < -20 || nDec > 20 ) +/*N*/ SetIllegalArgument(); +/*N*/ else +/*N*/ fVal = ::rtl::math::round( GetDouble(), (short)nDec, eMode ); +/*N*/ } +/*N*/ PushDouble(fVal); +/*N*/ } +/*N*/ } + +void ScInterpreter::ScRound() +{ + RoundNumber( rtl_math_RoundingMode_Corrected ); +} + +void ScInterpreter::ScRoundDown() +{ + RoundNumber( rtl_math_RoundingMode_Down ); +} + +/*N*/ void ScInterpreter::ScRoundUp() +/*N*/ { +/*N*/ RoundNumber( rtl_math_RoundingMode_Up ); +/*N*/ } + +void ScInterpreter::ScCeil() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + BOOL bAbs = ( nParamCount == 3 ? GetBool() : FALSE ); + double fDec = GetDouble(); + double fVal = GetDouble(); + if ( fDec == 0.0 ) + PushInt(0); + else if (fVal*fDec < 0.0) + SetIllegalArgument(); + else + { + if ( !bAbs && fVal < 0.0 ) + PushDouble(::rtl::math::approxFloor(fVal/fDec) * fDec); + else + PushDouble(::rtl::math::approxCeil(fVal/fDec) * fDec); + } + } +} + +void ScInterpreter::ScFloor() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + BOOL bAbs = ( nParamCount == 3 ? GetBool() : FALSE ); + double fDec = GetDouble(); + double fVal = GetDouble(); + if ( fDec == 0.0 ) + PushInt(0); + else if (fVal*fDec < 0.0) + SetIllegalArgument(); + else + { + if ( !bAbs && fVal < 0.0 ) + PushDouble(::rtl::math::approxCeil(fVal/fDec) * fDec); + else + PushDouble(::rtl::math::approxFloor(fVal/fDec) * fDec); + } + } +} + +void ScInterpreter::ScEven() +{ + double fVal = GetDouble(); + if (fVal < 0.0) + PushDouble(::rtl::math::approxFloor(fVal/2.0) * 2.0); + else + PushDouble(::rtl::math::approxCeil(fVal/2.0) * 2.0); +} + +void ScInterpreter::ScOdd() +{ + double fVal = GetDouble(); + if (fVal >= 0.0) + { + fVal = ::rtl::math::approxCeil(fVal); + if (fmod(fVal, 2.0) == 0.0) + fVal += 1.0; + } + else + { + fVal = ::rtl::math::approxFloor(fVal); + if (fmod(fVal, 2.0) == 0.0) + fVal -= 1.0; + } + PushDouble(fVal); +} + +void ScInterpreter::ScArcTan2() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double nVal2 = GetDouble(); + double nVal1 = GetDouble(); + PushDouble(atan2(nVal2, nVal1)); + } +} + +void ScInterpreter::ScLog() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double nBase = GetDouble(); + double nVal = GetDouble(); + if (nVal > 0.0 && nBase > 0.0 && nBase != 1.0) + PushDouble(log(nVal) / log(nBase)); + else + SetIllegalArgument(); + } +} + +void ScInterpreter::ScLn() +{ + double fVal = GetDouble(); + if (fVal > 0.0) + PushDouble(log(fVal)); + else + SetIllegalArgument(); +} + +void ScInterpreter::ScLog10() +{ + double fVal = GetDouble(); + if (fVal > 0.0) + PushDouble(log10(fVal)); + else + SetIllegalArgument(); +} + +void ScInterpreter::ScNBW() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 31 ) ) + { + double nVal = 0.0; + // Wir drehen den Stack um!! + ScToken* pTemp[ 31 ]; + for( short i = 0; i < nParamCount; i++ ) + pTemp[ i ] = pStack[ sp - i - 1 ]; + memcpy( &pStack[ sp - nParamCount ], pTemp, nParamCount * sizeof( ScToken* ) ); + if (nGlobalError == 0) + { + double nCount = 1.0; + double nZins = GetDouble(); + ScRange aRange; + for (short i = 2; i <= (short) nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + { + nVal += (GetDouble() / pow(1.0 + nZins, nCount)); + nCount++; + } + break; + case svSingleRef : + { + nVal += (GetDouble() / pow(1.0 + nZins, nCount)); + nCount++; + } + break; + case svDoubleRef : + { + USHORT nErr = 0; + double nCellVal; + PopDoubleRef( aRange ); + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + nVal += (nCellVal / pow(1.0 + nZins, nCount)); + nCount++; + while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr)) + { + nVal += (nCellVal / pow(1.0 + nZins, nCount)); + nCount++; + } + SetError(nErr); + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + } + PushDouble(nVal); + } +} + +#if defined(WIN) && defined(MSC) +#pragma optimize("",off) +#endif + +void ScInterpreter::ScIKV() +{ + double fSchaetzwert; + nFuncFmtType = NUMBERFORMAT_PERCENT; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 1, 2 ) ) + return; + if (nParamCount == 2) + fSchaetzwert = GetDouble(); + else + fSchaetzwert = 0.1; + USHORT sPos = sp; // Stack-Position merken + double fEps = 1.0; + double x, xNeu, fWert, fZaehler, fNenner, nCount; + if (fSchaetzwert == -1.0) + x = 0.1; // default gegen Nulldivisionen + else + x = fSchaetzwert; // Startwert + switch (GetStackType()) + { + case svDoubleRef : + break; + case svDouble : + case svSingleRef : + default: + { + SetError(errIllegalParameter); + return; + } + } + const USHORT nIterationsMax = 20; + USHORT nItCount = 0; + ScRange aRange; + while (fEps > SCdEpsilon && nItCount < nIterationsMax) + { // Newton-Verfahren: + sp = sPos; // Stack zuruecksetzen + nCount = 0.0; + fZaehler = 0.0; + fNenner = 0.0; + USHORT nErr = 0; + PopDoubleRef( aRange ); + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(fWert, nErr)) + { + fZaehler += fWert / pow(1.0+x,nCount); + fNenner += -nCount * fWert / pow(1.0+x,nCount+1.0); + nCount++; + while ((nErr == 0) && aValIter.GetNext(fWert, nErr)) + { + fZaehler += fWert / pow(1.0+x,nCount); + fNenner += -nCount * fWert / pow(1.0+x,nCount+1.0); + nCount++; + } + SetError(nErr); + } + xNeu = x - fZaehler / fNenner; // x(i+1) = x(i)-f(x(i))/f'(x(i)) + nItCount++; + fEps = fabs(xNeu - x); + x = xNeu; + } + if (fSchaetzwert == 0.0 && fabs(x) < SCdEpsilon) + x = 0.0; // auf Null normieren + if (fEps < SCdEpsilon) + PushDouble(x); + else + { + SetError(errNoConvergence); + PushInt(0); + } +} +#if defined(WIN) && defined(MSC) +#pragma optimize("",on) +#endif + + +void ScInterpreter::ScMIRR() +{ // range_of_values ; rate_invest ; rate_reinvest + nFuncFmtType = NUMBERFORMAT_PERCENT; + if( MustHaveParamCount( GetByte(), 3 ) ) + { + double fRate1_reinvest = GetDouble() + 1; + double fNPV_reinvest = 0.0; + double fPow_reinvest = 1.0; + + double fRate1_invest = GetDouble() + 1; + double fNPV_invest = 0.0; + double fPow_invest = 1.0; + + ScRange aRange; + PopDoubleRef( aRange ); + + if( nGlobalError ) + SetIllegalParameter(); + else + { + ScValueIterator aValIter( pDok, aRange, glSubTotal ); + double fCellValue; + ULONG nCount = 0; + USHORT nIterError = 0; + + BOOL bLoop = aValIter.GetFirst( fCellValue, nIterError ); + while( bLoop ) + { + if( fCellValue > 0.0 ) // reinvestments + fNPV_reinvest += fCellValue * fPow_reinvest; + else if( fCellValue < 0.0 ) // investments + fNPV_invest += fCellValue * fPow_invest; + fPow_reinvest /= fRate1_reinvest; + fPow_invest /= fRate1_invest; + nCount++; + + bLoop = aValIter.GetNext( fCellValue, nIterError ); + } + if( nIterError ) + SetError( nIterError ); + else + { + double fResult = -fNPV_reinvest / fNPV_invest; + fResult *= pow( fRate1_reinvest, double(nCount - 1) ); + fResult = pow( fResult, 1.0 / (nCount - 1) ); + PushDouble( fResult - 1.0 ); + } + } + } +} + + +void ScInterpreter::ScISPMT() +{ // rate ; period ; total_periods ; invest + if( MustHaveParamCount( GetByte(), 4 ) ) + { + double fInvest = GetDouble(); + double fTotal = GetDouble(); + double fPeriod = GetDouble(); + double fRate = GetDouble(); + + if( nGlobalError ) + SetIllegalParameter(); + else + PushDouble( fInvest * fRate * (fPeriod / fTotal - 1.0) ); + } +} + + +//----------------------- Finanzfunktionen ------------------------------------ + +double ScInterpreter::ScGetBw(double fZins, double fZzr, double fRmz, + double fZw, double fF) +{ + double fBw; + if (fZins == 0.0) + fBw = fZw + fRmz * fZzr; + else if (fF > 0.0) + fBw = (fZw * pow(1.0 + fZins, -fZzr)) + + (fRmz * (1.0 - pow(1.0 + fZins, -fZzr + 1.0)) / fZins) + + fRmz; + else + fBw = (fZw * pow(1.0 + fZins, -fZzr)) + + (fRmz * (1.0 - pow(1.0 + fZins, -fZzr)) / fZins); + return -fBw; +} + +void ScInterpreter::ScBW() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + double nRmz, nZzr, nZins, nZw = 0, nFlag = 0; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 5 ) ) + return; + if (nParamCount == 5) + nFlag = GetDouble(); + if (nParamCount >= 4) + nZw = GetDouble(); + nRmz = GetDouble(); + nZzr = GetDouble(); + nZins = GetDouble(); + PushDouble(ScGetBw(nZins, nZzr, nRmz, nZw, nFlag)); +} + +void ScInterpreter::ScDIA() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + if ( MustHaveParamCount( GetByte(), 4 ) ) + { + double nZr = GetDouble(); + double nDauer = GetDouble(); + double nRest = GetDouble(); + double nWert = GetDouble(); + double nDia = ((nWert - nRest) * (nDauer - nZr + 1.0)) / + ((nDauer * (nDauer + 1.0)) / 2.0); + PushDouble(nDia); + } +} + +double ScInterpreter::ScGetGDA(double fWert, double fRest, double fDauer, + double fPeriode, double fFaktor) +{ + double fGda, fZins, fAlterWert, fNeuerWert; + fZins = fFaktor / fDauer; + if (fZins >= 1.0) + { + fZins = 1.0; + if (fPeriode == 1.0) + fAlterWert = fWert; + else + fAlterWert = 0.0; + } + else + fAlterWert = fWert * pow(1.0 - fZins, fPeriode - 1.0); + fNeuerWert = fWert * pow(1.0 - fZins, fPeriode); + + if (fNeuerWert < fRest) + fGda = fAlterWert - fRest; + else + fGda = fAlterWert - fNeuerWert; + if (fGda < 0.0) + fGda = 0.0; + return fGda; +} + +void ScInterpreter::ScGDA() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 4, 5 ) ) + { + double nFaktor; + if (nParamCount == 5) + nFaktor = GetDouble(); + else + nFaktor = 2.0; + double nPeriode = GetDouble(); + double nDauer = GetDouble(); + double nRest = GetDouble(); + double nWert = GetDouble(); + if (nWert < 0.0 || nRest < 0.0 || nFaktor <= 0.0 || nRest > nWert + || nPeriode < 1.0 || nPeriode > nDauer) + SetIllegalParameter(); + else + PushDouble(ScGetGDA(nWert, nRest, nDauer, nPeriode, nFaktor)); + } +} + +void ScInterpreter::ScGDA2() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 4, 5 ) ) + return ; + double nMonate; + if (nParamCount == 4) + nMonate = 12.0; + else + nMonate = ::rtl::math::approxFloor(GetDouble()); + double nPeriode = GetDouble(); + double nDauer = GetDouble(); + double nRest = GetDouble(); + double nWert = GetDouble(); + if (nMonate < 1.0 || nMonate > 12.0 || nDauer > 1200.0 || nRest < 0.0 || + nPeriode > (nDauer + 1.0) || nRest > nWert || nWert < 0.0) + { + SetIllegalParameter(); + return; + } + double nAbRate = 1.0 - pow(nRest / nWert, 1.0 / nDauer); + nAbRate = ::rtl::math::approxFloor((nAbRate * 1000.0) + 0.5) / 1000.0; + double nErsteAbRate = nWert * nAbRate * nMonate / 12.0; + double nGda2; + if (::rtl::math::approxFloor(nPeriode) == 1) + nGda2 = nErsteAbRate; + else + { + double nSummAbRate = nErsteAbRate; + double nMin = nDauer; + if (nMin > nPeriode) nMin = nPeriode; + USHORT iMax = (USHORT)::rtl::math::approxFloor(nMin); + for (USHORT i = 2; i <= iMax; i++) + { + nGda2 = (nWert - nSummAbRate) * nAbRate; + nSummAbRate += nGda2; + } + if (nPeriode > nDauer) + nGda2 = ((nWert - nSummAbRate) * nAbRate * (12.0 - nMonate)) / 12.0; + } + PushDouble(nGda2); +} + + +double ScInterpreter::ScInterVDB(double fWert,double fRest,double fDauer, + double fDauer1,double fPeriode,double fFaktor) +{ + double fVdb=0; + double fIntEnd = ::rtl::math::approxCeil(fPeriode); + ULONG nLoopEnd = (ULONG) fIntEnd; + + double fTerm, fLia; + double fRestwert = fWert - fRest; + double fRestwert1 = fRestwert; + BOOL bNowLia = FALSE; + BOOL bFirstFlag=TRUE; + BOOL b2Flag=TRUE; + double fAbschlag=0; + + double fGda; + ULONG i; + fLia=0; + for ( i = 1; i <= nLoopEnd; i++) + { + if(!bNowLia) + { + fGda = ScGetGDA(fWert, fRest, fDauer, (double) i, fFaktor); + fLia = fRestwert/ (fDauer1 - (double) (i-1)); + + if (fLia > fGda) + { + fTerm = fLia; + bNowLia = TRUE; + } + else + { + fTerm = fGda; + fRestwert -= fGda; + } + } + else + { + fTerm = fLia; + } + + if ( i == nLoopEnd) + fTerm *= ( fPeriode + 1.0 - fIntEnd ); + + fVdb += fTerm; + } + return fVdb; +} + + +inline double DblMin( double a, double b ) +{ + return (a < b) ? a : b; +} + +void ScInterpreter::ScVDB() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 5, 7 ) ) + { + double fWert, fRest, fDauer, fAnfang, fEnde, fFaktor, fVdb = 0.0; + BOOL bFlag; + if (nParamCount == 7) + bFlag = GetBool(); + else + bFlag = FALSE; + if (nParamCount >= 6) + fFaktor = GetDouble(); + else + fFaktor = 2.0; + fEnde = GetDouble(); + fAnfang = GetDouble(); + fDauer = GetDouble(); + fRest = GetDouble(); + fWert = GetDouble(); + if (fAnfang < 0.0 || fEnde < fAnfang || fEnde > fDauer || fWert < 0.0 + || fRest > fWert || fFaktor <= 0.0) + SetIllegalParameter(); + else + { + double fIntStart = ::rtl::math::approxFloor(fAnfang); + double fIntEnd = ::rtl::math::approxCeil(fEnde); + ULONG nLoopStart = (ULONG) fIntStart; + ULONG nLoopEnd = (ULONG) fIntEnd; + + fVdb = 0.0; + if (bFlag) + { + for (ULONG i = nLoopStart + 1; i <= nLoopEnd; i++) + { + double fTerm = ScGetGDA(fWert, fRest, fDauer, (double) i, fFaktor); + + // Teilperioden am Anfang / Ende beruecksichtigen: + if ( i == nLoopStart+1 ) + fTerm *= ( DblMin( fEnde, fIntStart + 1.0 ) - fAnfang ); + else if ( i == nLoopEnd ) + fTerm *= ( fEnde + 1.0 - fIntEnd ); + + fVdb += fTerm; + } + } + else + { + + double fDauer1=fDauer; + double fPart; + + //@Die Frage aller Fragen: "Ist das hier richtig" + if(!::rtl::math::approxEqual(fAnfang,::rtl::math::approxFloor(fAnfang))) + { + if(fFaktor>1) + { + if(fAnfang>fDauer/2 || ::rtl::math::approxEqual(fAnfang,fDauer/2)) + { + fPart=fAnfang-fDauer/2; + fAnfang=fDauer/2; + fEnde-=fPart; + fDauer1+=1; + } + } + } + + fWert-=ScInterVDB(fWert,fRest,fDauer,fDauer1,fAnfang,fFaktor); + fVdb=ScInterVDB(fWert,fRest,fDauer,fDauer-fAnfang,fEnde-fAnfang,fFaktor); + } + } + PushDouble(fVdb); + } +} + +void ScInterpreter::ScLaufz() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double nZukunft = GetDouble(); + double nGegenwart = GetDouble(); + double nZins = GetDouble(); + PushDouble(log(nZukunft / nGegenwart) / log(1.0 + nZins)); + } +} + +void ScInterpreter::ScLIA() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double nDauer = GetDouble(); + double nRest = GetDouble(); + double nWert = GetDouble(); + PushDouble((nWert - nRest) / nDauer); + } +} + +double ScInterpreter::ScGetRmz(double fZins, double fZzr, double fBw, + double fZw, double fF) +{ + double fRmz; + if (fZins == 0.0) + fRmz = (fBw + fZw) / fZzr; + else + { + double fTerm = pow(1.0 + fZins, fZzr); + if (fF > 0.0) + fRmz = (fZw * fZins / (fTerm - 1.0) + + fBw * fZins / (1.0 - 1.0 / fTerm)) / (1.0+fZins); + else + fRmz = fZw * fZins / (fTerm - 1.0) + + fBw * fZins / (1.0 - 1.0 / fTerm); + } + return -fRmz; +} + +void ScInterpreter::ScRMZ() +{ + double nZins, nZzr, nBw, nZw = 0, nFlag = 0; + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 5 ) ) + return; + if (nParamCount == 5) + nFlag = GetDouble(); + if (nParamCount >= 4) + nZw = GetDouble(); + nBw = GetDouble(); + nZzr = GetDouble(); + nZins = GetDouble(); + PushDouble(ScGetRmz(nZins, nZzr, nBw, nZw, nFlag)); +} + +void ScInterpreter::ScZGZ() +{ + nFuncFmtType = NUMBERFORMAT_PERCENT; + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double nZukunftswert = GetDouble(); + double nGegenwartswert = GetDouble(); + double nZeitraum = GetDouble(); + PushDouble(pow(nZukunftswert / nGegenwartswert, 1.0 / nZeitraum) - 1.0); + } +} + +double ScInterpreter::ScGetZw(double fZins, double fZzr, double fRmz, + double fBw, double fF) +{ + double fZw; + if (fZins == 0.0) + fZw = fBw + fRmz * fZzr; + else + { + double fTerm = pow(1.0 + fZins, fZzr); + if (fF > 0.0) + fZw = fBw * fTerm + fRmz*(1.0 + fZins)*(fTerm - 1.0)/fZins; + else + fZw = fBw * fTerm + fRmz*(fTerm - 1.0)/fZins; + } + return -fZw; +} + +void ScInterpreter::ScZW() +{ + double nZins, nZzr, nRmz, nBw = 0, nFlag = 0; + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 5 ) ) + return; + if (nParamCount == 5) + nFlag = GetDouble(); + if (nParamCount >= 4) + nBw = GetDouble(); + nRmz = GetDouble(); + nZzr = GetDouble(); + nZins = GetDouble(); + PushDouble(ScGetZw(nZins, nZzr, nRmz, nBw, nFlag)); +} + +void ScInterpreter::ScZZR() +{ + double nZins, nRmz, nBw, nZw = 0, nFlag = 0; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 5 ) ) + return; + if (nParamCount == 5) + nFlag = GetDouble(); + if (nParamCount >= 4) + nZw = GetDouble(); + nBw = GetDouble(); + nRmz = GetDouble(); + nZins = GetDouble(); + if (nZins == 0.0) + PushDouble(-(nBw + nZw)/nRmz); + else if (nFlag > 0.0) + PushDouble(log(-(nZins*nZw-nRmz*(1.0+nZins))/(nZins*nBw+nRmz*(1.0+nZins))) + /log(1.0+nZins)); + else + PushDouble(log(-(nZins*nZw-nRmz)/(nZins*nBw+nRmz))/log(1.0+nZins)); +} + +double ScInterpreter::GetZinsIterationEps(double fZzr, double fRmz, double fBw, + double fZw, double fF, double& fSchaetzwert) +{ + double fEps = 1.0; + double x, xNeu, fTerm1, fTerm2; + if (fSchaetzwert == 0.0) + x = 0.1; // default gegen Nulldivisionen + else + x = fSchaetzwert; // Startwert + const USHORT nIterationsMax = 150; + USHORT nCount = 0; + while (fEps > SCdEpsilon && nCount < nIterationsMax) + { // Newton-Verfahren: + if (x == 0.0) + xNeu = x - + (fBw + fRmz*fZzr + fZw) / + (fBw*fZzr + fRmz*(fZzr*(fZzr-1.0) + 2*fF*fZzr)/2.0); + else + { + fTerm1 = pow(1.0+x, fZzr-1); + fTerm2 = fTerm1*(1.0+x); + xNeu = x*(1.0 - // x(i+1) = x(i) - f(x(i)) / f'(x(i)) + (x*fBw*fTerm2 + fRmz*(1.0+x*fF)*(fTerm2-1.0) + x*fZw) / + (x*x*fZzr*fBw*fTerm1 - fRmz*(fTerm2-1.0) + + x*fRmz*(1.0+x*fF)*fZzr*fTerm1) ); + } + nCount++; + fEps = fabs(xNeu - x); + x = xNeu; + } + if (fSchaetzwert == 0.0 && fabs(x) < SCdEpsilon) + x = 0.0; // auf Null normieren + fSchaetzwert = x; //n Rueckgabe + return fEps; +} + +void ScInterpreter::ScZins() +{ + double nZw = 0, nRmz, nZzr, nBw, nFlag = 0, nSchaetzwert = 0.1, fEps; + nFuncFmtType = NUMBERFORMAT_PERCENT; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 6 ) ) + return; + if (nParamCount == 6) + nSchaetzwert = GetDouble(); + if (nParamCount >= 5) + nFlag = GetDouble(); + if (nParamCount >= 4) + nZw = GetDouble(); + nBw = GetDouble(); + nRmz = GetDouble(); + nZzr = GetDouble(); + if (nFlag == 0.0) + fEps = GetZinsIterationEps(nZzr, nRmz, nBw, nZw, 0.0, nSchaetzwert); + else + fEps = GetZinsIterationEps(nZzr, nRmz, nBw, nZw, 1.0, nSchaetzwert); + if (fEps >= SCdEpsilon) + { + SetError(errNoConvergence); + nSchaetzwert = 0; + } + PushDouble(nSchaetzwert); +} + +double ScInterpreter::ScGetZinsZ(double fZins, double fZr, double fZzr, double fBw, + double fZw, double fF, double& fRmz) +{ + fRmz = ScGetRmz(fZins, fZzr, fBw, fZw, fF); // fuer kapz auch bei fZr == 1 + double fZinsZ; + nFuncFmtType = NUMBERFORMAT_CURRENCY; + if (fZr == 1.0) + { + if (fF > 0.0) + fZinsZ = 0.0; + else + fZinsZ = -fBw; + } + else + { + if (fF > 0.0) + fZinsZ = ScGetZw(fZins, fZr-2.0, fRmz, fBw, 1.0) - fRmz; + else + fZinsZ = ScGetZw(fZins, fZr-1.0, fRmz, fBw, 0.0); + } + return fZinsZ * fZins; +} + +void ScInterpreter::ScZinsZ() +{ + double nZins, nZr, nRmz, nZzr, nBw, nZw = 0, nFlag = 0; + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 4, 6 ) ) + return; + if (nParamCount == 6) + nFlag = GetDouble(); + if (nParamCount >= 5) + nZw = GetDouble(); + nBw = GetDouble(); + nZzr = GetDouble(); + nZr = GetDouble(); + nZins = GetDouble(); + if (nZr < 1.0 || nZr > nZzr) + SetIllegalParameter(); + else + PushDouble(ScGetZinsZ(nZins, nZr, nZzr, nBw, nZw, nFlag, nRmz)); +} + +void ScInterpreter::ScKapz() +{ + double nZins, nZr, nZzr, nBw, nZw = 0, nFlag = 0, nRmz, nZinsz; + nFuncFmtType = NUMBERFORMAT_CURRENCY; + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 4, 6 ) ) + return; + if (nParamCount == 6) + nFlag = GetDouble(); + if (nParamCount >= 5) + nZw = GetDouble(); + nBw = GetDouble(); + nZzr = GetDouble(); + nZr = GetDouble(); + nZins = GetDouble(); + if (nZr < 1.0 || nZr > nZzr) + SetIllegalParameter(); + else + { + nZinsz = ScGetZinsZ(nZins, nZr, nZzr, nBw, nZw, nFlag, nRmz); + PushDouble(nRmz - nZinsz); + } +} + +void ScInterpreter::ScKumZinsZ() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + if ( MustHaveParamCount( GetByte(), 6 ) ) + { + double fZins, fZzr, fBw, fAnfang, fEnde, fF, fRmz, fZinsZ; + fF = GetDouble(); + fEnde = ::rtl::math::approxFloor(GetDouble()); + fAnfang = ::rtl::math::approxFloor(GetDouble()); + fBw = GetDouble(); + fZzr = GetDouble(); + fZins = GetDouble(); + if (fAnfang < 1.0 || fEnde < fAnfang || fZins <= 0.0 || + fEnde > fZzr || fZzr <= 0.0 || fBw <= 0.0) + SetIllegalParameter(); + else + { + ULONG nAnfang = (ULONG) fAnfang; + ULONG nEnde = (ULONG) fEnde ; + fRmz = ScGetRmz(fZins, fZzr, fBw, 0.0, fF); + fZinsZ = 0.0; + if (nAnfang == 1) + { + if (fF <= 0.0) + fZinsZ = -fBw; + nAnfang++; + } + for (ULONG i = nAnfang; i <= nEnde; i++) + { + if (fF > 0.0) + fZinsZ += ScGetZw(fZins, (double)(i-2), fRmz, fBw, 1.0) - fRmz; + else + fZinsZ += ScGetZw(fZins, (double)(i-1), fRmz, fBw, 0.0); + } + fZinsZ *= fZins; + PushDouble(fZinsZ); + } + } +} + +void ScInterpreter::ScKumKapZ() +{ + nFuncFmtType = NUMBERFORMAT_CURRENCY; + if ( MustHaveParamCount( GetByte(), 6 ) ) + { + double fZins, fZzr, fBw, fAnfang, fEnde, fF, fRmz, fKapZ; + fF = GetDouble(); + fEnde = ::rtl::math::approxFloor(GetDouble()); + fAnfang = ::rtl::math::approxFloor(GetDouble()); + fBw = GetDouble(); + fZzr = GetDouble(); + fZins = GetDouble(); + if (fAnfang < 1.0 || fEnde < fAnfang || fZins <= 0.0 || + fEnde > fZzr || fZzr <= 0.0 || fBw <= 0.0) + SetIllegalParameter(); + else + { + fRmz = ScGetRmz(fZins, fZzr, fBw, 0.0, fF); + fKapZ = 0.0; + ULONG nAnfang = (ULONG) fAnfang; + ULONG nEnde = (ULONG) fEnde; + if (nAnfang == 1) + { + if (fF <= 0.0) + fKapZ = fRmz + fBw * fZins; + else + fKapZ = fRmz; + nAnfang++; + } + for (ULONG i = nAnfang; i <= nEnde; i++) + { + if (fF > 0.0) + fKapZ += fRmz - (ScGetZw(fZins, (double)(i-2), fRmz, fBw, 1.0) - fRmz) * fZins; + else + fKapZ += fRmz - ScGetZw(fZins, (double)(i-1), fRmz, fBw, 0.0) * fZins; + } + PushDouble(fKapZ); + } + } +} + +void ScInterpreter::ScEffektiv() +{ + nFuncFmtType = NUMBERFORMAT_PERCENT; + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double fPerioden = GetDouble(); + double fNominal = GetDouble(); + if (fPerioden < 1.0 || fNominal <= 0.0) + SetIllegalParameter(); + else + { + fPerioden = ::rtl::math::approxFloor(fPerioden); + PushDouble(pow(1.0 + fNominal/fPerioden, fPerioden) - 1.0); + } + } +} + +void ScInterpreter::ScNominal() +{ + nFuncFmtType = NUMBERFORMAT_PERCENT; + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double fPerioden = GetDouble(); + double fEffektiv = GetDouble(); + if (fPerioden < 1.0 || fEffektiv <= 0.0) + SetIllegalParameter(); + else + { + fPerioden = ::rtl::math::approxFloor(fPerioden); + PushDouble( (pow(fEffektiv + 1.0, 1.0 / fPerioden) - 1.0) * fPerioden ); + } + } +} + +/*N*/ void ScInterpreter::ScMod() +/*N*/ { +/*N*/ if ( MustHaveParamCount( GetByte(), 2 ) ) +/*N*/ { +/*N*/ double nVal2 = GetDouble(); +/*N*/ double nVal1 = GetDouble(); +/*N*/ PushDouble(nVal1 - (::rtl::math::approxFloor(nVal1 / nVal2) * nVal2)); +/*N*/ } +/*N*/ } + +void ScInterpreter::ScBackSolver() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + BOOL bRet = FALSE; + ScAddress aVAdr, aFAdr; + double nVal = GetDouble(); + PopSingleRef( aFAdr ); + PopSingleRef( aVAdr ); + if (nGlobalError == 0) + { + ScBaseCell* pVCell = GetCell( aVAdr ); + // CELLTYPE_NOTE: kein Value aber von Formel referiert + BOOL bTempCell = (!pVCell || pVCell->GetCellType() == CELLTYPE_NOTE); + ScBaseCell* pFCell = GetCell( aFAdr ); + if ( ((pVCell && pVCell->GetCellType() == CELLTYPE_VALUE) || bTempCell) + && pFCell && pFCell->GetCellType() == CELLTYPE_FORMULA ) + { + ScRange aVRange( aVAdr, aVAdr ); // fuer SetDirty + double nSaveVal; + ScPostIt aNote; + BOOL bHasNote; + if ( bTempCell ) + { + if ( bHasNote = (pVCell != NULL) ) + bHasNote = pVCell->GetNote( aNote ); + nSaveVal = 0.0; + pVCell = new ScValueCell( nSaveVal ); + pDok->PutCell( aVAdr, pVCell ); + } + else + nSaveVal = GetCellValue( aVAdr, pVCell ); + const USHORT nMaxIter = 100; + const double nEps = 1E-10; + const double nDelta = 1E-3; + double nBestX = nSaveVal; + double nBestF, xn1, fn1; + ScFormulaCell* pFormula = (ScFormulaCell*) pFCell; + ScValueCell* pValue = (ScValueCell*) pVCell; + pFormula->Interpret(); + BOOL bError = ( pFormula->GetErrCode() != 0 ); + // bError always corresponds with fn + fn1 = pFormula->GetValue(); + fn1 -= nVal; + xn1 = nBestX; + nBestF = fabs(fn1); + if (nBestF < nDelta) + bRet = TRUE; + double xn = xn1 + nEps; + double fn = fn1; + double fs; + USHORT i = 0; + // Nach der Regula Falsi Methode + while (!bRet && (i < nMaxIter)) + { + i++; + pValue->SetValue(xn); + pDok->SetDirty( aVRange ); + pFormula->Interpret(); + bError = ( pFormula->GetErrCode() != 0 ); + fn = pFormula->GetValue(); + fn -= nVal; + if ( bError ) + { + // move closer to last valid value (xn1), keep xn1/fn1 + double fDiff = ( xn1 - xn ) / 2; + if (fabs(fDiff) < nEps) + fDiff = (fDiff < 0.0) ? -nEps : nEps; + xn += fDiff; + } + else if (fabs(fn) < nDelta) + { + nBestX = xn; + bRet = TRUE; + } + else + { + if (fabs(fn) + nDelta < nBestF) + { + nBestX = xn; + nBestF = fabs(fn); + } + if ((xn1 - xn) != 0) + { + fs = (fn1 - fn) / (xn1 - xn); + if (fabs(fs) < nEps) + if (fs < 0.0) + fs = -nEps; + else + fs = nEps; + } + else + fs = nEps; + xn1 = xn; + fn1 = fn; + xn = xn - (fn / fs); + } + } + double nX = ::rtl::math::approxFloor((nBestX / nDelta) + 0.5) * nDelta; + if ( bRet ) + { + pValue->SetValue( nX ); + pDok->SetDirty( aVRange ); + pFormula->Interpret(); + if ( fabs( pFormula->GetValue() - nVal ) > fabs( fn ) ) + nX = nBestX; + } + else if ( bError ) + { + nX = nBestX; + } + if ( bTempCell ) + { + if ( bHasNote ) + pVCell = new ScNoteCell( aNote ); + else + pVCell = NULL; + pDok->PutCell( aVAdr, pVCell ); + } + else + pValue->SetValue(nSaveVal); + pDok->SetDirty( aVRange ); + pFormula->Interpret(); + if (!bRet) + SetError(NOVALUE); + PushDouble(nX); + } + else + { + if (!bRet) + SetError(NOVALUE); + PushInt(0); // falsche Zelltypen + } + } + else + { + if (!bRet) + SetError(NOVALUE); + PushInt(0); // nGlobalError + } + } +} + +void ScInterpreter::ScIntersect() +{ + USHORT nCol11, nRow11, nTab11, nCol21, nRow21, nTab21, + nCol12, nRow12, nTab12, nCol22, nRow22, nTab22, + nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + BYTE eStackVar = GetStackType(); + if (eStackVar == svDoubleRef) + PopDoubleRef(nCol11, nRow11, nTab11, nCol21, nRow21, nTab21); + else if (eStackVar == svSingleRef) + { + PopSingleRef(nCol11, nRow11, nTab11); + nCol21 = nCol11; + nRow21 = nRow11; + nTab21 = nTab11; + } + else + { + SetError(errNoRef); + PushInt(0); + return; + } + eStackVar = GetStackType(); + if (eStackVar == svDoubleRef) + PopDoubleRef(nCol12, nRow12, nTab12, nCol22, nRow22, nTab22); + else if (eStackVar == svSingleRef) + { + PopSingleRef(nCol12, nRow12, nTab12); + nCol22 = nCol12; + nRow22 = nRow12; + nTab22 = nTab12; + } + else + { + SetError(errNoRef); + PushInt(0); + return; + } + nCol1 = Max(nCol11, nCol12); + nRow1 = Max(nRow11, nRow12); + nTab1 = Max(nTab11, nTab12); + nCol2 = Min(nCol21, nCol22); + nRow2 = Min(nRow21, nRow22); + nTab2 = Min(nTab21, nTab22); + if (nCol2 < nCol1 || nRow2 < nRow1 || nTab2 < nTab1) + { + SetError(errNoRef); + PushInt(0); + } + else if (nCol2 == nCol1 && nRow2 == nRow1 && nTab2 == nTab1) + PushSingleRef(nCol1, nRow1, nTab1); + else + PushDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +} + + +void ScInterpreter::ScCurrent() +{ + switch ( GetStackType() ) + { + case svDouble : + { + double nVal = PopDouble(); + PushDouble( nVal ); + PushDouble( nVal ); + } + break; + case svString : + { + const String& rStr = PopString(); + PushString( rStr ); + PushString( rStr ); + } + break; + case svDoubleRef : + case svSingleRef : + { + ScAddress aAdr; + if ( !PopDoubleRefOrSingleRef( aAdr ) ) + { + PushInt(0); + break; + } + ScBaseCell* pCell = GetCell( aAdr ); + // NoteCell entsteht auch durch Referenz auf leere Zelle + if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) + { + if ( HasCellValueData( pCell ) ) + { + double nVal = GetCellValue( aAdr, pCell ); + PushDouble( nVal ); + PushDouble( nVal ); + } + else + { + String aStr; + GetCellString( aStr, pCell ); + PushString( aStr ); + PushString( aStr ); + } + } + else + { + PushSingleRef( aAdr.Col(), aAdr.Row(), aAdr.Tab() ); + PushSingleRef( aAdr.Col(), aAdr.Row(), aAdr.Tab() ); + } + } + break; + default: + SetIllegalParameter(); + } +} + +void ScInterpreter::ScStyle() +{ + BYTE nParamCount = GetByte(); + if (nParamCount >= 1 && nParamCount <= 3) + { + String aStyle2; // Vorlage nach Timer + if (nParamCount >= 3) + aStyle2 = GetString(); + long nTimeOut = 0; // Timeout + if (nParamCount >= 2) + nTimeOut = (long)(GetDouble()*1000.0); + String aStyle1 = GetString(); // Vorlage fuer sofort + + if (nTimeOut < 0) + nTimeOut = 0; + + // + // Request ausfuehren, um Vorlage anzuwenden + // + + if ( !pDok->IsClipOrUndo() ) + { + SfxObjectShell* pShell = pDok->GetDocumentShell(); + if (pShell) + { + //! notify object shell directly + + ScRange aRange(aPos); + ScAutoStyleHint aHint( aRange, aStyle1, nTimeOut, aStyle2 ); + pShell->Broadcast( aHint ); + } + } + + PushDouble(0.0); + } + else + SetIllegalParameter(); +} + +ScDdeLink* lcl_GetDdeLink( SvxLinkManager* pLinkMgr, + const String& rA, const String& rT, const String& rI, BYTE nM ) +{ + USHORT nCount = pLinkMgr->GetLinks().Count(); + for (USHORT i=0; i<nCount; i++ ) + { + ::binfilter::SvBaseLink* pBase = *pLinkMgr->GetLinks()[i]; + if (pBase->ISA(ScDdeLink)) + { + ScDdeLink* pLink = (ScDdeLink*)pBase; + if ( pLink->GetAppl() == rA && + pLink->GetTopic() == rT && + pLink->GetItem() == rI && + pLink->GetMode() == nM ) + return pLink; + } + } + + return NULL; +} + +/*N*/ void ScInterpreter::ScDde() +/*N*/ { +/*N*/ // Applikation, Datei, Bereich +/*N*/ // Application, Topic, Item +/*N*/ +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if ( MustHaveParamCount( nParamCount, 3, 4 ) ) +/*N*/ { +/*N*/ BYTE nMode = SC_DDE_DEFAULT; +/*N*/ if (nParamCount == 4) +/*N*/ nMode = (BYTE) ::rtl::math::approxFloor(GetDouble()); +/*N*/ String aItem = GetString(); +/*N*/ String aTopic = GetString(); +/*N*/ String aAppl = GetString(); +/*N*/ +/*N*/ if (nMode < SC_DDE_DEFAULT || nMode > SC_DDE_TEXT) +/*N*/ nMode = SC_DDE_DEFAULT; +/*N*/ +/*N*/ // temporary documents (ScFunctionAccess) have no DocShell +/*N*/ // and no LinkManager -> abort +/*N*/ +/*N*/ SvxLinkManager* pLinkMgr = pDok->GetLinkManager(); +/*N*/ if (!pLinkMgr) +/*N*/ { +/*N*/ SetNoValue(); +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ // Nach dem Laden muss neu interpretiert werden (Verknuepfungen aufbauen) +/*N*/ +/*N*/ if ( pMyFormulaCell->GetCode()->IsRecalcModeNormal() ) +/*N*/ pMyFormulaCell->GetCode()->SetRecalcModeOnLoad(); +/*N*/ +/*N*/ // solange der Link nicht ausgewertet ist, Idle abklemmen +/*N*/ // (um zirkulaere Referenzen zu vermeiden) +/*N*/ +/*N*/ BOOL bOldDis = pDok->IsIdleDisabled(); +/*N*/ pDok->DisableIdle( TRUE ); +/*N*/ +/*N*/ // Link-Objekt holen / anlegen +/*N*/ +/*N*/ ScDdeLink* pLink = lcl_GetDdeLink( pLinkMgr, aAppl, aTopic, aItem, nMode ); +/*N*/ +/*N*/ //! Dde-Links (zusaetzlich) effizienter am Dokument speichern !!!!! +/*N*/ // ScDdeLink* pLink = pDok->GetDdeLink( aAppl, aTopic, aItem ); +/*N*/ +/*N*/ BOOL bWasError = ( pMyFormulaCell->GetCode()->GetError() != 0 ); +/*N*/ +/*N*/ if (!pLink) +/*N*/ { +/*N*/ pLink = new ScDdeLink( pDok, aAppl, aTopic, aItem, nMode ); +/*N*/ pLinkMgr->InsertDDELink( pLink, aAppl, aTopic, aItem ); +/*N*/ +/*N*/ //! asynchron auswerten ??? +/*N*/ pLink->TryUpdate(); // TryUpdate ruft Update nicht mehrfach auf +/*N*/ +/*N*/ // StartListening erst nach dem Update, sonst circular reference +/*N*/ pMyFormulaCell->StartListening( *pLink, TRUE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( !pMyFormulaCell->IsListening( *pLink ) ) +/*N*/ pMyFormulaCell->StartListening( *pLink, TRUE ); +/*N*/ } +/*N*/ +/*N*/ // Wenn aus dem Reschedule beim Ausfuehren des Links ein Fehler +/*N*/ // (z.B. zirkulaere Referenz) entstanden ist, der vorher nicht da war, +/*N*/ // das Fehler-Flag zuruecksetzen: +/*N*/ +/*N*/ if ( pMyFormulaCell->GetCode()->GetError() && !bWasError ) +/*N*/ pMyFormulaCell->GetCode()->SetError(0); +/*N*/ +/*N*/ // Wert abfragen +/*N*/ +/*N*/ const ScMatrix* pLinkMat = pLink->GetResult(); +/*N*/ if (pLinkMat) +/*N*/ { +/*N*/ USHORT nC, nR, nMatInd; +/*N*/ pLinkMat->GetDimensions(nC, nR); +/*N*/ ScMatrix* pNewMat = GetNewMat( nC, nR, nMatInd ); +/*N*/ if (pNewMat) +/*N*/ { +/*N*/ pLinkMat->MatCopy(*pNewMat); // kopieren +/*N*/ PushMatrix( pNewMat ); +/*N*/ nRetMat = nMatInd; +/*N*/ } +/*N*/ // sonst Fehler schon in GetNewMat gesetzt +/*N*/ } +/*N*/ else +/*N*/ SetNV(); +/*N*/ +/*N*/ pDok->DisableIdle( bOldDis ); +/*N*/ } +/*N*/ } + +void ScInterpreter::ScBase() +{ // Value, Base [, MinLen] + BYTE nParamCount = GetByte(); + if ( MustHaveParamCount( nParamCount, 2, 3 ) ) + { + static const sal_Unicode __FAR_DATA pDigits[] = { + '0','1','2','3','4','5','6','7','8','9', + 'A','B','C','D','E','F','G','H','I','J','K','L','M', + 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z', + 0 + }; + static const int nDigits = (sizeof(pDigits)/sizeof(sal_Unicode))-1; + xub_StrLen nMinLen; + if ( nParamCount == 3 ) + { + double fLen = ::rtl::math::approxFloor( GetDouble() ); + if ( 1.0 <= fLen && fLen < STRING_MAXLEN ) + nMinLen = (xub_StrLen) fLen; + else if ( fLen == 0.0 ) + nMinLen = 1; + else + nMinLen = 0; // Error + } + else + nMinLen = 1; + double fBase = ::rtl::math::approxFloor( GetDouble() ); + double fVal = ::rtl::math::approxFloor( GetDouble() ); + double fChars = ((fVal > 0.0 && fBase > 0.0) ? + (ceil( log( fVal ) / log( fBase ) ) + 2.0) : + 2.0); + if ( fChars >= STRING_MAXLEN ) + nMinLen = 0; // Error + + if ( !nGlobalError && nMinLen && 2 <= fBase && fBase <= nDigits && 0 <= fVal ) + { + const xub_StrLen nConstBuf = 128; + sal_Unicode aBuf[nConstBuf]; + xub_StrLen nBuf = Max( (xub_StrLen) fChars, (xub_StrLen) (nMinLen+1) ); + sal_Unicode* pBuf = (nBuf <= nConstBuf ? aBuf : new sal_Unicode[nBuf]); + for ( xub_StrLen j = 0; j < nBuf; ++j ) + { + pBuf[j] = '0'; + } + sal_Unicode* p = pBuf + nBuf - 1; + *p = 0; + if ( fVal <= (ULONG)(~0) ) + { + ULONG nVal = (ULONG) fVal; + ULONG nBase = (ULONG) fBase; + while ( nVal && p > pBuf ) + { + *--p = pDigits[ nVal % nBase ]; + nVal /= nBase; + } + fVal = (double) nVal; + } + else + { + BOOL bDirt = FALSE; + while ( fVal && p > pBuf ) + { +//! mit fmod Rundungsfehler ab 2**48 +// double fDig = ::rtl::math::approxFloor( fmod( fVal, fBase ) ); +// so ist es etwas besser + double fInt = ::rtl::math::approxFloor( fVal / fBase ); + double fMult = fInt * fBase; +#if OSL_DEBUG_LEVEL > 1 + // #53943# =BASIS(1e308;36) => GPF mit + // nDig = (size_t) ::rtl::math::approxFloor( fVal - fMult ); + // trotz vorheriger Pruefung ob fVal >= fMult + double fDebug1 = fVal - fMult; + // fVal := 7,5975311883090e+290 + // fMult := 7,5975311883090e+290 + // fDebug1 := 1,3848924157003e+275 <- RoundOff-Error + // fVal != fMult, aber: ::rtl::math::approxEqual( fVal, fMult ) == TRUE + double fDebug2 = ::rtl::math::approxSub( fVal, fMult ); + // und ::rtl::math::approxSub( fVal, fMult ) == 0 + double fDebug3 = ( fInt ? fVal / fInt : 0.0 ); + // Nach dem strange fDebug1 und fVal < fMult ist eigentlich + // fDebug2 == fBase, trotzdem wird das mit einem Vergleich + // nicht erkannt, dann schlaegt bDirt zu und alles wird wieder gut.. +#endif + size_t nDig; + if ( fVal < fMult ) + { // da ist was gekippt + bDirt = TRUE; + nDig = 0; + } + else + { + double fDig = ::rtl::math::approxFloor( ::rtl::math::approxSub( fVal, fMult ) ); + if ( bDirt ) + { + bDirt = FALSE; + --fDig; + } + if ( fDig <= 0.0 ) + nDig = 0; + else if ( fDig >= fBase ) + nDig = ((size_t) fBase) - 1; + else + nDig = (size_t) fDig; + } + *--p = pDigits[ nDig ]; + fVal = fInt; + } + } + if ( fVal ) + { + SetError( errStringOverflow ); + PushInt(0); + } + else + { + if ( nBuf - (p - pBuf) <= nMinLen ) + p = pBuf + nBuf - 1 - nMinLen; + PushStringBuffer( p ); + } + if ( pBuf != aBuf ) + delete [] pBuf; + } + else + SetIllegalArgument(); + } +} + + +/*N*/ void ScInterpreter::ScDecimal() +/*N*/ { // Text, Base +/*N*/ if ( MustHaveParamCount( GetByte(), 2 ) ) +/*N*/ { +/*N*/ double fBase = ::rtl::math::approxFloor( GetDouble() ); +/*N*/ String aStr( GetString() ); +/*N*/ if ( !nGlobalError && 2 <= fBase && fBase <= 36 ) +/*N*/ { +/*N*/ double fVal = 0.0; +/*N*/ int nBase = (int) fBase; +/*N*/ register const sal_Unicode* p = aStr.GetBuffer(); +/*N*/ while ( *p == ' ' || *p == '\t' ) +/*N*/ p++; // strip leading white space +/*N*/ if ( nBase == 16 ) +/*N*/ { // evtl. hex-prefix strippen +/*N*/ if ( *p == 'x' || *p == 'X' ) +/*N*/ p++; +/*N*/ else if ( *p == '0' && (*(p+1) == 'x' || *(p+1) == 'X') ) +/*N*/ p += 2; +/*N*/ } +/*N*/ while ( *p ) +/*N*/ { +/*N*/ int n; +/*N*/ if ( '0' <= *p && *p <= '9' ) +/*N*/ n = *p - '0'; +/*N*/ else if ( 'A' <= *p && *p <= 'Z' ) +/*N*/ n = 10 + (*p - 'A'); +/*N*/ else if ( 'a' <= *p && *p <= 'z' ) +/*N*/ n = 10 + (*p - 'a'); +/*N*/ else +/*N*/ n = nBase; +/*N*/ if ( nBase <= n ) +/*N*/ { +/*N*/ if ( *(p+1) == 0 && +/*N*/ ( (nBase == 2 && (*p == 'b' || *p == 'B')) +/*N*/ ||(nBase == 16 && (*p == 'h' || *p == 'H')) ) +/*N*/ ) +/*N*/ ; // 101b und F00Dh sind ok +/*N*/ else +/*N*/ { +/*?*/ SetIllegalArgument(); +/*?*/ return ; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ fVal = fVal * fBase + n; +/*N*/ p++; +/*N*/ +/*N*/ } +/*N*/ PushDouble( fVal ); +/*N*/ } +/*N*/ else +/*?*/ SetIllegalArgument(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScInterpreter::ScConvert() +/*N*/ { // Value, FromUnit, ToUnit +/*N*/ if ( MustHaveParamCount( GetByte(), 3 ) ) +/*N*/ { +/*N*/ String aToUnit( GetString() ); +/*N*/ String aFromUnit( GetString() ); +/*N*/ double fVal = GetDouble(); +/*N*/ if ( nGlobalError ) +/*?*/ SetIllegalArgument(); +/*N*/ else +/*N*/ { // erst die angegebene Reihenfolge suchen, wenn nicht gefunden den Kehrwert +/*N*/ double fConv; +/*N*/ if ( ScGlobal::GetUnitConverter()->GetValue( fConv, aFromUnit, aToUnit ) ) +/*?*/ PushDouble( fVal * fConv ); +/*N*/ else if ( ScGlobal::GetUnitConverter()->GetValue( fConv, aToUnit, aFromUnit ) ) +/*N*/ PushDouble( fVal / fConv ); +/*N*/ else +/*?*/ SetNV(); +/*N*/ } +/*N*/ } +/*N*/ } + + +void ScInterpreter::ScRoman() +{ // Value [Mode] + BYTE nParamCount = GetByte(); + if( MustHaveParamCount( nParamCount, 1, 2 ) ) + { + double fMode = (nParamCount == 2) ? ::rtl::math::approxFloor( GetDouble() ) : 0.0; + double fVal = ::rtl::math::approxFloor( GetDouble() ); + if( nGlobalError ) + SetIllegalParameter(); + else if( (fMode >= 0.0) && (fMode < 5.0) && (fVal >= 0.0) && (fVal < 4000.0) ) + { + static const sal_Unicode pChars[] = { 'M', 'D', 'C', 'L', 'X', 'V', 'I' }; + static const USHORT pValues[] = { 1000, 500, 100, 50, 10, 5, 1 }; + static const USHORT nMaxIndex = (USHORT)(SAL_N_ELEMENTS(pValues) - 1); + + String aRoman; + USHORT nVal = (USHORT) fVal; + USHORT nMode = (USHORT) fMode; + + for( UINT16 i = 0; i <= nMaxIndex / 2; i++ ) + { + USHORT nIndex = 2 * i; + USHORT nDigit = nVal / pValues[ nIndex ]; + + if( (nDigit % 5) == 4 ) + { + USHORT nIndex2 = (nDigit == 4) ? nIndex - 1 : nIndex - 2; + USHORT nSteps = 0; + while( (nSteps < nMode) && (nIndex < nMaxIndex) ) + { + nSteps++; + if( pValues[ nIndex2 ] - pValues[ nIndex + 1 ] <= nVal ) + nIndex++; + else + nSteps = nMode; + } + aRoman += pChars[ nIndex ]; + aRoman += pChars[ nIndex2 ]; + nVal += pValues[ nIndex ]; + nVal -= pValues[ nIndex2 ]; + } + else + { + if( nDigit > 4 ) + aRoman += pChars[ nIndex - 1 ]; + aRoman.Expand( aRoman.Len() + (nDigit % 5), pChars[ nIndex ] ); + nVal %= pValues[ nIndex ]; + } + } + + PushString( aRoman ); + } + else + SetIllegalArgument(); + } +} + + +BOOL lcl_GetArabicValue( sal_Unicode cChar, USHORT& rnValue, BOOL& rbIsDec ) +{ + switch( cChar ) + { + case 'M': rnValue = 1000; rbIsDec = TRUE; break; + case 'D': rnValue = 500; rbIsDec = FALSE; break; + case 'C': rnValue = 100; rbIsDec = TRUE; break; + case 'L': rnValue = 50; rbIsDec = FALSE; break; + case 'X': rnValue = 10; rbIsDec = TRUE; break; + case 'V': rnValue = 5; rbIsDec = FALSE; break; + case 'I': rnValue = 1; rbIsDec = TRUE; break; + default: return FALSE; + } + return TRUE; +} + + +void ScInterpreter::ScArabic() +{ + String aRoman( GetString() ); + if( nGlobalError ) + SetIllegalParameter(); + else + { + aRoman.ToUpperAscii(); + + USHORT nValue = 0; + USHORT nValidRest = 3999; + USHORT nCharIndex = 0; + USHORT nCharCount = aRoman.Len(); + BOOL bValid = TRUE; + + while( bValid && (nCharIndex < nCharCount) ) + { + USHORT nDigit1 = 0; + USHORT nDigit2 = 0; + BOOL bIsDec1 = FALSE; + BOOL bIsDec2 = FALSE; + bValid = lcl_GetArabicValue( aRoman.GetChar( nCharIndex ), nDigit1, bIsDec1 ); + if( bValid && (nCharIndex + 1 < nCharCount) ) + bValid = lcl_GetArabicValue( aRoman.GetChar( nCharIndex + 1 ), nDigit2, bIsDec2 ); + if( bValid ) + { + if( nDigit1 >= nDigit2 ) + { + nValue += nDigit1; + nValidRest %= (nDigit1 * (bIsDec1 ? 5 : 2)); + bValid = (nValidRest >= nDigit1); + if( bValid ) + nValidRest -= nDigit1; + nCharIndex++; + } + else if( nDigit1 * 2 != nDigit2 ) + { + USHORT nDiff = nDigit2 - nDigit1; + nValue += nDiff; + bValid = (nValidRest >= nDiff); + if( bValid ) + nValidRest = nDigit1 - 1; + nCharIndex += 2; + } + else + bValid = FALSE; + } + } + if( bValid ) + PushInt( nValue ); + else + SetIllegalArgument(); + } +} + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_interpr3.cxx b/binfilter/bf_sc/source/core/tool/sc_interpr3.cxx new file mode 100644 index 000000000000..1aaf13cb1038 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_interpr3.cxx @@ -0,0 +1,3764 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/solar.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#include "interpre.hxx" +#include "dociter.hxx" +#include "scmatrix.hxx" +#include "globstr.hrc" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +#define SCdEpsilon 1.0E-7 +#define SC_MAX_ITERATION_COUNT 20 +#define MAX_ANZ_DOUBLE_FOR_SORT 100000 +// PI jetzt als F_PI aus solar.h +//#define PI 3.1415926535897932 + +//----------------------------------------------------------------------------- + +class ScDistFunc +{ +public: + virtual double GetValue(double x) const = 0; +}; + +// iteration for inverse distributions + +//template< class T > double lcl_IterateInverse( const T& rFunction, double x0, double x1, BOOL& rConvError ) +double lcl_IterateInverse( const ScDistFunc& rFunction, double x0, double x1, BOOL& rConvError ) +{ + rConvError = FALSE; + double fEps = 1.0E-7; + + DBG_ASSERT(x0<x1, "IterateInverse: wrong interval"); + + // find enclosing interval + + double f0 = rFunction.GetValue(x0); + double f1 = rFunction.GetValue(x1); + double xs; + USHORT i; + for (i = 0; i < 1000 && f0*f1 > 0.0; i++) + { + if (fabs(f0) <= fabs(f1)) + { + xs = x0; + x0 += 2.0 * (x0 - x1); + if (x0 < 0.0) + x0 = 0.0; + x1 = xs; + f1 = f0; + f0 = rFunction.GetValue(x0); + } + else + { + xs = x1; + x1 += 2.0 * (x1 - x0); + x0 = xs; + f0 = f1; + f1 = rFunction.GetValue(x1); + } + } + + if (f0 == 0.0) + return x0; + if (f1 == 0.0) + return x1; + + // simple iteration + + double x00 = x0; + double x11 = x1; + double fs = 0.0; + for (i = 0; i < 100; i++) + { + xs = 0.5*(x0+x1); + if (fabs(f1-f0) >= fEps) + { + fs = rFunction.GetValue(xs); + if (f0*fs <= 0.0) + { + x1 = xs; + f1 = fs; + } + else + { + x0 = xs; + f0 = fs; + } + } + else + { + // add one step of regula falsi to improve precision + + if ( x0 != x1 ) + { + double regxs = (f1-f0)/(x1-x0); + if ( regxs != 0.0) + { + double regx = x1 - f1/regxs; + if (regx >= x00 && regx <= x11) + { + double regfs = rFunction.GetValue(regx); + if ( fabs(regfs) < fabs(fs) ) + xs = regx; + } + } + } + + return xs; + } + } + + rConvError = TRUE; + return 0.0; +} + +//----------------------------------------------------------------------------- +// Allgemeine Funktionen +//----------------------------------------------------------------------------- + +void ScInterpreter::ScNoName() +{ + SetError(errNoName); +} + +double ScInterpreter::phi(double x) +{ + return 0.39894228040143268 * exp(-(x * x) / 2.0); +} + +double ScInterpreter::taylor(double* pPolynom, USHORT nMax, double x) +{ + double nVal = pPolynom[nMax]; + for (short i = nMax-1; i >= 0; i--) + { + nVal = pPolynom[i] + (nVal * x); + } + return nVal; +} + +double ScInterpreter::gauss(double x) +{ + double t0[] = + { 0.39894228040143268, -0.06649038006690545, 0.00997355701003582, + -0.00118732821548045, 0.00011543468761616, -0.00000944465625950, + 0.00000066596935163, -0.00000004122667415, 0.00000000227352982, + 0.00000000011301172, 0.00000000000511243, -0.00000000000021218 }; + double t2[] = + { 0.47724986805182079, 0.05399096651318805, -0.05399096651318805, + 0.02699548325659403, -0.00449924720943234, -0.00224962360471617, + 0.00134977416282970, -0.00011783742691370, -0.00011515930357476, + 0.00003704737285544, 0.00000282690796889, -0.00000354513195524, + 0.00000037669563126, 0.00000019202407921, -0.00000005226908590, + -0.00000000491799345, 0.00000000366377919, -0.00000000015981997, + -0.00000000017381238, 0.00000000002624031, 0.00000000000560919, + -0.00000000000172127, -0.00000000000008634, 0.00000000000007894 }; + double t4[] = + { 0.49996832875816688, 0.00013383022576489, -0.00026766045152977, + 0.00033457556441221, -0.00028996548915725, 0.00018178605666397, + -0.00008252863922168, 0.00002551802519049, -0.00000391665839292, + -0.00000074018205222, 0.00000064422023359, -0.00000017370155340, + 0.00000000909595465, 0.00000000944943118, -0.00000000329957075, + 0.00000000029492075, 0.00000000011874477, -0.00000000004420396, + 0.00000000000361422, 0.00000000000143638, -0.00000000000045848 }; + double asympt[] = { -1.0, 1.0, -3.0, 15.0, -105.0 }; + + double xAbs = fabs(x); + USHORT xShort = (USHORT)::rtl::math::approxFloor(xAbs); + double nVal = 0.0; + if (xShort == 0) + nVal = taylor(t0, 11, (xAbs * xAbs)) * xAbs; + else if ((xShort >= 1) && (xShort <= 2)) + nVal = taylor(t2, 23, (xAbs - 2.0)); + else if ((xShort >= 3) && (xShort <= 4)) + nVal = taylor(t4, 20, (xAbs - 4.0)); + else + nVal = 0.5 + phi(xAbs) * taylor(asympt, 4, 1.0 / (xAbs * xAbs)) / xAbs; + if (x < 0.0) + return -nVal; + else + return nVal; +} + +#if defined(WIN) && defined(MSC) +#pragma optimize("",off) +#endif + +double ScInterpreter::gaussinv(double x) +{ + double c0, c1, c2, d1, d2, d3, q, t, z; + c0 = 2.515517; + c1 = 0.802853; + c2 = 0.010328; + d1 = 1.432788; + d2 = 0.189269; + d3 = 0.001308; + if (x < 0.5) + q = x; + else + q = 1.0-x; + t = sqrt(-log(q*q)); + z = t - (c0 + t*(c1 + t*c2)) / (1.0 + t*(d1 + t*(d2 + t*d3))); + if (x < 0.5) + z *= -1.0; + return z; +} +#if defined(WIN) && defined(MSC) +#pragma optimize("",on) +#endif + +double ScInterpreter::Fakultaet(double x) +{ + x = ::rtl::math::approxFloor(x); + if (x < 0.0) + return 0.0; + else if (x == 0.0) + return 1.0; + else if (x <= 170.0) + { + double fTemp = x; + while (fTemp > 2.0) + { + fTemp--; + x *= fTemp; + } + } + else + SetError(errNoValue); +/* // Stirlingsche Naeherung zu ungenau + else + x = pow(x/exp(1), x) * sqrt(x) * SQRT_2_PI * (1.0 + 1.0 / (12.0 * x)); +*/ + return x; +} + +double ScInterpreter::BinomKoeff(double n, double k) +{ + double nVal = 0.0; + k = ::rtl::math::approxFloor(k); + if (n < k) + nVal = 0.0; + else if (k == 0.0) + nVal = 1.0; + else + { + nVal = n/k; + n--; + k--; + while (k > 0.0) + { + nVal *= n/k; + k--; + n--; + } +/* + double f1 = n; // Zaehler + double f2 = k; // Nenner + n--; + k--; + while (k > 0.0) + { + f2 *= k; + f1 *= n; + k--; + n--; + } + nVal = f1 / f2; +*/ + } + return nVal; +} + +double ScInterpreter::GammaHelp(double& x, BOOL& bReflect) +{ + double c[6] = {76.18009173, -86.50532033, 24.01409822, + -1.231739516, 0.120858003E-2, -0.536382E-5}; + if (x >= 1.0) + { + bReflect = FALSE; + x -= 1.0; + } + else + { + bReflect = TRUE; + x = 1.0 - x; + } + double s, anum; + s = 1.0; + anum = x; + for (USHORT i = 0; i < 6; i++) + { + anum += 1.0; + s += c[i]/anum; + } + s *= 2.506628275; // sqrt(2*PI) + return s; +} + +double ScInterpreter::GetGamma(double x) +{ + BOOL bReflect; + double G = GammaHelp(x, bReflect); + G = pow(x+5.5,x+0.5)*G/exp(x+5.5); + if (bReflect) + G = F_PI*x/(G*::rtl::math::sin(F_PI*x)); + return G; +} + +double ScInterpreter::GetLogGamma(double x) +{ + BOOL bReflect; + double G = GammaHelp(x, bReflect); + G = (x+0.5)*log(x+5.5)+log(G)-(x+5.5); + if (bReflect) + G = log(F_PI*x)-G-log(::rtl::math::sin(F_PI*x)); + return G; +} + +double ScInterpreter::GetBetaDist(double x, double alpha, double beta) +{ + if (beta == 1.0) + return pow(x, alpha); + else if (alpha == 1.0) + return 1.0 - pow(1.0-x,beta); + double fEps = 1.0E-8; + BOOL bReflect; + double cf, fA, fB; + if (x < (alpha+1.0)/(alpha+beta+1.0)) + { + bReflect = FALSE; + fA = alpha; + fB = beta; + } + else + { + bReflect = TRUE; + fA = beta; + fB = alpha; + x = 1.0 - x; + } + if (x < fEps) + cf = 0.0; + else + { + double a1, b1, a2, b2, fnorm, rm, apl2m, d2m, d2m1, cfnew; + a1 = 1.0; b1 = 1.0; + b2 = 1.0 - (fA+fB)*x/(fA+1.0); + if (b2 == 0.0) + { + a2 = b2; + fnorm = 1.0; + cf = 1.0; + } + else + { + a2 = 1.0; + fnorm = 1.0/b2; + cf = a2*fnorm; + } + cfnew = 1.0; + for (USHORT j = 1; j <= 100; j++) + { + rm = (double) j; + apl2m = fA + 2.0*rm; + d2m = rm*(fB-rm)*x/((apl2m-1.0)*apl2m); + d2m1 = -(fA+rm)*(fA+fB+rm)*x/(apl2m*(apl2m+1.0)); + a1 = (a2+d2m*a1)*fnorm; + b1 = (b2+d2m*b1)*fnorm; + a2 = a1 + d2m1*a2*fnorm; + b2 = b1 + d2m1*b2*fnorm; + if (b2 != 0.0) + { + fnorm = 1.0/b2; + cfnew = a2*fnorm; + if (fabs(cf-cfnew)/cf < fEps) + j = 101; + else + cf = cfnew; + } + } + if (fB < fEps) + b1 = 69; // ln(1.0E30) + else + b1 = GetLogGamma(fA)+GetLogGamma(fB)-GetLogGamma(fA+fB); + + // cf *= pow(x, fA)*pow(1.0-x,fB)/(fA*exp(b1)); + // #108995# The formula above has 0 as results for the terms too easily, + // resulting in an error where the equivalent formula below still works: + // (x can't be 0 or 1, this is handled above) + cf *= exp( log(x)*fA + log(1.0-x)*fB - b1 ) / fA; + } + if (bReflect) + return 1.0-cf; + else + return cf; +} + +double ScInterpreter::GetFDist(double x, double fF1, double fF2) +{ + double arg = fF2/(fF2+fF1*x); + double alpha = fF2/2.0; + double beta = fF1/2.0; + return (GetBetaDist(arg, alpha, beta)); +/* + double Z = (pow(fF,1.0/3.0)*(1.0-2.0/(9.0*fF2)) - (1.0-2.0/(9.0*fF1))) / + sqrt(2.0/(9.0*fF1) + pow(fF,2.0/3.0)*2.0/(9.0*fF2)); + return (0.5-gauss(Z)); +*/ +} + +double ScInterpreter::GetTDist(double T, double fDF) +{ + return 0.5 * GetBetaDist(fDF/(fDF+T*T), fDF/2.0, 0.5); +/* + USHORT DF = (USHORT) fDF; + double A = T / sqrt(DF); + double B = 1.0 + A*A; + double R; + if (DF == 1) + R = 0.5 + atan(A)/F_PI; + else if (DF % 2 == 0) + { + double S0 = A/(2.0 * sqrt(B)); + double C0 = S0; + for (USHORT i = 2; i <= DF-2; i+=2) + { + C0 *= (1.0 - 1.0/(double)i)/B; + S0 += C0; + } + R = 0.5 + S0; + } + else + { + double S1 = A / (B * F_PI); + double C1 = S1; + for (USHORT i = 3; i <= DF-2; i+=2) + { + C1 *= (1.0 - 1.0/(double)i)/B; + S1 += C1; + } + R = 0.5 + atan(A)/F_PI + S1; + } + return 1.0 - R; +*/ +} + +double ScInterpreter::GetChiDist(double fChi, double fDF) +{ + return 1.0 - GetGammaDist(fChi/2.0, fDF/2.0, 1.0); +/* + double x = 1.0; + for (double i = fDF; i >= 2.0; i -= 2.0) + x *= fChi/i; + x *= exp(-fChi/2.0); + if (fmod(fDF, 2.0) != 0.0) + x *= sqrt(2.0*fChi/F_PI); + double S = 1.0; + double T = 1.0; + double G = fDF; + BOOL bStop = FALSE; + while (!bStop) + { + G += 2.0; + T *= fChi/G; + if (T < 1.0E-7) + bStop = TRUE; + else + S += T; + } + return 1.0 - x*S; +*/ +} + +void ScInterpreter::ScLogGamma() +{ + double x = GetDouble(); + if (x > 0.0) + PushDouble(GetLogGamma(x)); + else + SetIllegalArgument(); +} + +void ScInterpreter::ScBetaDist() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 5 ) ) + return; + double fA, fB, alpha, beta, x; + if (nParamCount == 5) + fB = GetDouble(); + else + fB = 1.0; + if (nParamCount >= 4) + fA = GetDouble(); + else + fA = 0.0; + beta = GetDouble(); + alpha = GetDouble(); + x = GetDouble(); + if (x < fA || x > fB || fA == fB || alpha <= 0.0 || beta <= 0.0) + { + SetIllegalArgument(); + return; + } + x = (x-fA)/(fB-fA); // Skalierung auf (0,1) + PushDouble(GetBetaDist(x, alpha, beta)); +} + +void ScInterpreter::ScPhi() +{ + PushDouble(phi(GetDouble())); +} + +void ScInterpreter::ScGauss() +{ + PushDouble(gauss(GetDouble())); +} + +void ScInterpreter::ScFisher() +{ + double fVal = GetDouble(); + if (fabs(fVal) >= 1.0) + SetIllegalArgument(); + else + PushDouble(0.5*log((1.0+fVal)/(1.0-fVal))); +} + +void ScInterpreter::ScFisherInv() +{ + double fVal = GetDouble(); + PushDouble((exp(2.0*fVal)-1.0)/(exp(2.0*fVal)+1.0)); +} + +void ScInterpreter::ScFact() +{ + double nVal = GetDouble(); + if (nVal < 0.0) + SetIllegalArgument(); + else + PushDouble(Fakultaet(nVal)); +} + +void ScInterpreter::ScKombin() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double k = ::rtl::math::approxFloor(GetDouble()); + double n = ::rtl::math::approxFloor(GetDouble()); + if (k < 0.0 || n < 0.0 || k > n) + SetIllegalArgument(); + else + PushDouble(BinomKoeff(n, k)); + } +} + +void ScInterpreter::ScKombin2() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double k = ::rtl::math::approxFloor(GetDouble()); + double n = ::rtl::math::approxFloor(GetDouble()); + if (k < 0.0 || n < 0.0 || k > n) + SetIllegalArgument(); + else + PushDouble(BinomKoeff(n + k - 1, k)); + } +} + +void ScInterpreter::ScVariationen() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double k = ::rtl::math::approxFloor(GetDouble()); + double n = ::rtl::math::approxFloor(GetDouble()); + if (n < 0.0 || k < 0.0 || k > n) + SetIllegalArgument(); + else if (k == 0.0) + PushInt(1); // (n! / (n - 0)!) == 1 + else + { + double nVal = n; + for (ULONG i = (ULONG)k-1; i >= 1; i--) + nVal *= n-(double)i; + PushDouble(nVal); + } + } +} + +void ScInterpreter::ScVariationen2() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + double k = ::rtl::math::approxFloor(GetDouble()); + double n = ::rtl::math::approxFloor(GetDouble()); + if (n < 0.0 || k < 0.0 || k > n) + SetIllegalArgument(); + else + PushDouble(pow(n,k)); + } +} + +void ScInterpreter::ScB() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 4 ) ) + return ; + if (nParamCount == 3) + { + double x = ::rtl::math::approxFloor(GetDouble()); + double p = GetDouble(); + double n = ::rtl::math::approxFloor(GetDouble()); + if (n < 0.0 || x < 0.0 || x > n || p < 0.0 || p > 1.0) + SetIllegalArgument(); + else + { + double q = 1.0 - p; + double fFactor = pow(q, n); + if (fFactor == 0.0) + { + fFactor = pow(p, n); + if (fFactor == 0.0) + SetNoValue(); + else + { + ULONG max = (ULONG) (n - x); + for (ULONG i = 0; i < max && fFactor > 0.0; i++) + fFactor *= (n-i)/(i+1)*q/p; + PushDouble(fFactor); + } + } + else + { + ULONG max = (ULONG) x; + for (ULONG i = 0; i < max && fFactor > 0.0; i++) + fFactor *= (n-i)/(i+1)*p/q; + PushDouble(fFactor); + } + } + } + else if (nParamCount == 4) + { + double xe = GetDouble(); + double xs = GetDouble(); + double p = GetDouble(); + double n = GetDouble(); +// alter Stand 300-SC +// if ((xs < n) && (xe < n) && (p < 1.0)) +// { +// double Varianz = sqrt(n * p * (1.0 - p)); +// xs = fabs(xs - (n * p /* / 2.0 STE */ )); +// xe = fabs(xe - (n * p /* / 2.0 STE */ )); +//// STE double nVal = gauss((xs + 0.5) / Varianz) + gauss((xe + 0.5) / Varianz); +// double nVal = fabs(gauss(xs / Varianz) - gauss(xe / Varianz)); +// PushDouble(nVal); +// } + if (xe <= n && xs <= xe && + p < 1.0 && p > 0.0 && n >= 0.0 && xs >= 0.0 ) + { + double q = 1.0 - p; + double fFactor = pow(q, n); + if (fFactor == 0.0) + { + fFactor = pow(p, n); + if (fFactor == 0.0) + SetNoValue(); + else + { + double fSum = 0.0; + ULONG max; + if (xe < (ULONG) n) + max = (ULONG) (n-xe)-1; + else + max = 0; + ULONG i; + for (i = 0; i < max && fFactor > 0.0; i++) + fFactor *= (n-i)/(i+1)*q/p; + if (xs < (ULONG) n) + max = (ULONG) (n-xs); + else + fSum = fFactor; + for (; i < max && fFactor > 0.0; i++) + { + fFactor *= (n-i)/(i+1)*q/p; + fSum += fFactor; + } + PushDouble(fSum); + } + } + else + { + ULONG max; + double fSum; + if ( (ULONG) xs == 0) + { + fSum = fFactor; + max = 0; + } + else + { + max = (ULONG) xs-1; + fSum = 0.0; + } + ULONG i; + for (i = 0; i < max && fFactor > 0.0; i++) + fFactor *= (n-i)/(i+1)*p/q; + if ((ULONG)xe == 0) // beide 0 + fSum = fFactor; + else + max = (ULONG) xe; + for (; i < max && fFactor > 0.0; i++) + { + fFactor *= (n-i)/(i+1)*p/q; + fSum += fFactor; + } + PushDouble(fSum); + } + } + else + SetIllegalArgument(); + } +} + +void ScInterpreter::ScBinomDist() +{ + if ( MustHaveParamCount( GetByte(), 4 ) ) + { + double kum = GetDouble(); // 0 oder 1 + double p = GetDouble(); // p + double n = ::rtl::math::approxFloor(GetDouble()); // n + double x = ::rtl::math::approxFloor(GetDouble()); // x + double fFactor, q, fSum; + if (n < 0.0 || x < 0.0 || x > n || p < 0.0 || p > 1.0) + SetIllegalArgument(); + else if (kum == 0.0) // Dichte + { + q = 1.0 - p; + fFactor = pow(q, n); + if (fFactor == 0.0) + { + fFactor = pow(p, n); + if (fFactor == 0.0) + SetNoValue(); + else + { + ULONG max = (ULONG) (n - x); + for (ULONG i = 0; i < max && fFactor > 0.0; i++) + fFactor *= (n-i)/(i+1)*q/p; + PushDouble(fFactor); + } + } + else + { + ULONG max = (ULONG) x; + for (ULONG i = 0; i < max && fFactor > 0.0; i++) + fFactor *= (n-i)/(i+1)*p/q; + PushDouble(fFactor); + } + } + else // Verteilung + { + if (n == x) + PushDouble(1.0); + else + { + q = 1.0 - p; + fFactor = pow(q, n); + if (fFactor == 0.0) + { + fFactor = pow(p, n); + if (fFactor == 0.0) + SetNoValue(); + else + { + fSum = 1.0 - fFactor; + ULONG max = (ULONG) (n - x) - 1; + for (ULONG i = 0; i < max && fFactor > 0.0; i++) + { + fFactor *= (n-i)/(i+1)*q/p; + fSum -= fFactor; + } + if (fSum < 0.0) + PushDouble(0.0); + else + PushDouble(fSum); + } + } + else + { + double fSum = fFactor; + ULONG max = (ULONG) x; + for (ULONG i = 0; i < max && fFactor > 0.0; i++) + { + fFactor *= (n-i)/(i+1)*p/q; + fSum += fFactor; + } + PushDouble(fSum); + } + } + } + } +} + +void ScInterpreter::ScCritBinom() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double alpha = GetDouble(); // alpha + double p = GetDouble(); // p + double n = ::rtl::math::approxFloor(GetDouble()); + if (n < 0.0 || alpha <= 0.0 || alpha >= 1.0 || p < 0.0 || p > 1.0) + SetIllegalArgument(); + else + { + double q = 1.0 - p; + double fFactor = pow(q,n); + if (fFactor == 0.0) + { + fFactor = pow(p, n); + if (fFactor == 0.0) + SetNoValue(); + else + { + double fSum = 1.0 - fFactor; ULONG max = (ULONG) n; + ULONG i = 0; + for (i = 0; i < max && fSum >= alpha; i++) + { + fFactor *= (n-i)/(i+1)*q/p; + fSum -= fFactor; + } + PushDouble(n-i); + } + } + else + { + double fSum = fFactor; ULONG max = (ULONG) n; + ULONG i = 0; + for (i = 0; i < max && fSum < alpha; i++) + { + fFactor *= (n-i)/(i+1)*p/q; + fSum += fFactor; + } + PushDouble(i); + } + } + } +} + +void ScInterpreter::ScNegBinomDist() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double p = GetDouble(); // p + double r = GetDouble(); // r + double x = GetDouble(); // x + if (r < 0.0 || x < 0.0 || p < 0.0 || p > 1.0) + SetIllegalArgument(); + else + { + double q = 1.0 - p; + double fFactor = pow(p,r); + for (double i = 0.0; i < x; i++) + fFactor *= (i+r)/(i+1.0)*q; + PushDouble(fFactor); + } + } +} + +void ScInterpreter::ScNormDist() +{ + if ( MustHaveParamCount( GetByte(), 4 ) ) + { + double kum = GetDouble(); // 0 oder 1 + double sigma = GetDouble(); // Stdabw + double mue = GetDouble(); // Mittelwert + double x = GetDouble(); // x + if (sigma <= 0.0) + SetIllegalArgument(); + else if (kum == 0.0) // Dichte + PushDouble(phi((x-mue)/sigma)/sigma); + else // Verteilung + PushDouble(0.5 + gauss((x-mue)/sigma)); + } +} + +void ScInterpreter::ScLogNormDist() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double sigma = GetDouble(); // Stdabw + double mue = GetDouble(); // Mittelwert + double x = GetDouble(); // x + if (sigma <= 0.0 || x <= 0.0) + SetIllegalArgument(); + else + PushDouble(0.5 + gauss((log(x)-mue)/sigma)); + } +} + +void ScInterpreter::ScStdNormDist() +{ + PushDouble(0.5 + gauss(GetDouble())); +} + +void ScInterpreter::ScExpDist() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double kum = GetDouble(); // 0 oder 1 + double lambda = GetDouble(); // lambda + double x = GetDouble(); // x + if (lambda <= 0.0) + SetIllegalArgument(); + else if (kum == 0.0) // Dichte + { + if (x >= 0.0) + PushDouble(lambda * exp(-lambda*x)); + else + PushInt(0); + } + else // Verteilung + { + if (x > 0.0) + PushDouble(1.0 - exp(-lambda*x)); + else + PushInt(0); + } + } +} + +void ScInterpreter::ScTDist() +{ + if ( !MustHaveParamCount( GetByte(), 3 ) ) + return; + double fFlag = ::rtl::math::approxFloor(GetDouble()); + double fDF = ::rtl::math::approxFloor(GetDouble()); + double T = GetDouble(); + if (fDF < 1.0 || T < 0.0 || (fFlag != 1.0 && fFlag != 2.0) ) + { + SetIllegalArgument(); + return; + } + double R = GetTDist(T, fDF); + if (fFlag == 1.0) + PushDouble(R); + else + PushDouble(2.0*R); +} + +void ScInterpreter::ScFDist() +{ + if ( !MustHaveParamCount( GetByte(), 3 ) ) + return; + double fF2 = ::rtl::math::approxFloor(GetDouble()); + double fF1 = ::rtl::math::approxFloor(GetDouble()); + double fF = GetDouble(); + if (fF < 0.0 || fF1 < 1.0 || fF2 < 1.0 || fF1 >= 1.0E10 || fF2 >= 1.0E10) + { + SetIllegalArgument(); + return; + } + PushDouble(GetFDist(fF, fF1, fF2)); +} + +void ScInterpreter::ScChiDist() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double fDF = ::rtl::math::approxFloor(GetDouble()); + double fChi = GetDouble(); + if (fDF < 1.0 || fDF >= 1.0E5 || fChi < 0.0 ) + { + SetIllegalArgument(); + return; + } + PushDouble(GetChiDist(fChi, fDF)); +} + +void ScInterpreter::ScWeibull() +{ + if ( MustHaveParamCount( GetByte(), 4 ) ) + { + double kum = GetDouble(); // 0 oder 1 + double beta = GetDouble(); // beta + double alpha = GetDouble(); // alpha + double x = GetDouble(); // x + if (alpha <= 0.0 || beta <= 0.0 || x < 0.0) + SetIllegalArgument(); + else if (kum == 0.0) // Dichte + PushDouble(alpha/pow(beta,alpha)*pow(x,alpha-1.0)* + exp(-pow(x/beta,alpha))); + else // Verteilung + PushDouble(1.0 - exp(-pow(x/beta,alpha))); + } +} + +void ScInterpreter::ScPoissonDist() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double kum = GetDouble(); // 0 oder 1 + double lambda = GetDouble(); // Mittelwert + double x = ::rtl::math::approxFloor(GetDouble()); // x + if (lambda < 0.0 || x < 0.0) + SetIllegalArgument(); + else if (kum == 0.0) // Dichte + { + if (lambda == 0.0) + PushInt(0); + else + PushDouble(exp(-lambda)*pow(lambda,x)/Fakultaet(x)); + } + else // Verteilung + { + if (lambda == 0.0) + PushInt(1); + else + { + double sum = 1.0; + double fFak = 1.0; + ULONG nEnd = (ULONG) x; + for (ULONG i = 1; i <= nEnd; i++) + { + fFak *= (double)i; + sum += pow( lambda, (double)i ) / fFak; + } + sum *= exp(-lambda); + PushDouble(sum); + } + } + } +} + +void ScInterpreter::ScHypGeomDist() +{ + if ( MustHaveParamCount( GetByte(), 4 ) ) + { + double N = ::rtl::math::approxFloor(GetDouble()); + double M = ::rtl::math::approxFloor(GetDouble()); + double n = ::rtl::math::approxFloor(GetDouble()); + double x = ::rtl::math::approxFloor(GetDouble()); + + if( (x < 0.0) || (n < x) || (M < x) || (N < n) || (N < M) || (x < n - N + M) ) + { + SetIllegalArgument(); + return; + } + double fFactor = + BinomKoeff( n, x ) / BinomKoeff( N, M ) * BinomKoeff( N - n, M - x ); + +/* + double fFactor; + if (x == n - N + M) + fFactor = BinomKoeff(M,x)/BinomKoeff(N,n); + else + { + double fIndex = N - M - n; + if (fIndex >= 0.0) + { + fFactor = BinomKoeff(N-M,n)/BinomKoeff(N,n); + for (double i = 0; i < x; i++) + fFactor *= (M-i)*(n-i)/((i+1.0)*(N-M-n+i+1.0)); + } + else + { + fFactor = BinomKoeff(M,-fIndex)/BinomKoeff(N,n); + for (double i = -fIndex + 1.0; i < x; i++) + fFactor *= (M-i)*(n-i)/((i+1)*(N-M-n+i+1.0)); + } + } +*/ + PushDouble(fFactor); + } +} + +void ScInterpreter::ScGammaDist() +{ + if ( !MustHaveParamCount( GetByte(), 4 ) ) + return; + double kum = GetDouble(); // 0 oder 1 + double beta = GetDouble(); + double alpha = GetDouble(); + double x = GetDouble(); // x + if (x < 0.0 || alpha <= 0.0 || beta <= 0.0) + SetIllegalArgument(); + else if (kum == 0.0) // Dichte + { + double G = GetGamma(alpha); + PushDouble(pow(x,alpha-1.0)/exp(x/beta)/pow(beta,alpha)/G); + } + else // Verteilung + PushDouble(GetGammaDist(x, alpha, beta)); +} + +void ScInterpreter::ScNormInv() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double sigma = GetDouble(); + double mue = GetDouble(); + double x = GetDouble(); + if (sigma <= 0.0 || x < 0.0 || x > 1.0) + SetIllegalArgument(); + else if (x == 0.0 || x == 1.0) + SetNoValue(); + else + PushDouble(gaussinv(x)*sigma + mue); + } +} + +void ScInterpreter::ScSNormInv() +{ + double x = GetDouble(); + if (x < 0.0 || x > 1.0) + SetIllegalArgument(); + else if (x == 0.0 || x == 1.0) + SetNoValue(); + else + PushDouble(gaussinv(x)); +} + +void ScInterpreter::ScLogNormInv() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double sigma = GetDouble(); // Stdabw + double mue = GetDouble(); // Mittelwert + double y = GetDouble(); // y + if (sigma <= 0.0 || y <= 0.0 || y >= 1.0) + SetIllegalArgument(); + else + PushDouble(exp(mue+sigma*gaussinv(y))); + } +} + +class ScGammaDistFunction : public ScDistFunc +{ + ScInterpreter& rInt; + double fp, fAlpha, fBeta; + +public: + ScGammaDistFunction( ScInterpreter& rI, double fpVal, double fAlphaVal, double fBetaVal ) : + rInt(rI), fp(fpVal), fAlpha(fAlphaVal), fBeta(fBetaVal) {} + + double GetValue( double x ) const { return fp - rInt.GetGammaDist(x, fAlpha, fBeta); } +}; + +void ScInterpreter::ScGammaInv() +{ + if ( !MustHaveParamCount( GetByte(), 3 ) ) + return; + double fBeta = GetDouble(); + double fAlpha = GetDouble(); + double fP = GetDouble(); + if (fAlpha <= 0.0 || fBeta <= 0.0 || fP < 0.0 || fP >= 1.0 ) + { + SetIllegalArgument(); + return; + } + if (fP == 0.0) + PushInt(0); + else + { + BOOL bConvError; + ScGammaDistFunction aFunc( *this, fP, fAlpha, fBeta ); + double fStart = fAlpha * fBeta; + double fVal = lcl_IterateInverse( aFunc, fStart*0.5, fStart, bConvError ); + if (bConvError) + SetError(errNoConvergence); + PushDouble(fVal); + } +} + +class ScBetaDistFunction : public ScDistFunc +{ + ScInterpreter& rInt; + double fp, fAlpha, fBeta; + +public: + ScBetaDistFunction( ScInterpreter& rI, double fpVal, double fAlphaVal, double fBetaVal ) : + rInt(rI), fp(fpVal), fAlpha(fAlphaVal), fBeta(fBetaVal) {} + + double GetValue( double x ) const { return fp - rInt.GetBetaDist(x, fAlpha, fBeta); } +}; + +void ScInterpreter::ScBetaInv() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 5 ) ) + return; + double fP, fA, fB, fAlpha, fBeta; + if (nParamCount == 5) + fB = GetDouble(); + else + fB = 1.0; + if (nParamCount >= 4) + fA = GetDouble(); + else + fA = 0.0; + fBeta = GetDouble(); + fAlpha = GetDouble(); + fP = GetDouble(); + if (fP < 0.0 || fP >= 1.0 || fA == fB || fAlpha <= 0.0 || fBeta <= 0.0) + { + SetIllegalArgument(); + return; + } + if (fP == 0.0) + PushInt(0); + else + { + BOOL bConvError; + ScBetaDistFunction aFunc( *this, fP, fAlpha, fBeta ); + // 0..1 as range for iteration so it isn't extended beyond the valid range + double fVal = lcl_IterateInverse( aFunc, 0.0, 1.0, bConvError ); + if (bConvError) + { + SetError(errNoConvergence); + PushInt(0); + } + else + PushDouble(fA + fVal*(fB-fA)); // scale to (A,B) + } +} + + // Achtung: T, F und Chi + // sind monoton fallend, + // deshalb 1-Dist als Funktion + +class ScTDistFunction : public ScDistFunc +{ + ScInterpreter& rInt; + double fp, fDF; + +public: + ScTDistFunction( ScInterpreter& rI, double fpVal, double fDFVal ) : + rInt(rI), fp(fpVal), fDF(fDFVal) {} + + double GetValue( double x ) const { return fp - 2 * rInt.GetTDist(x, fDF); } +}; + +void ScInterpreter::ScTInv() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double fDF = ::rtl::math::approxFloor(GetDouble()); + double fP = GetDouble(); + if (fDF < 1.0 || fDF >= 1.0E5 || fP <= 0.0 || fP > 1.0 ) + { + SetIllegalArgument(); + return; + } + + BOOL bConvError; + ScTDistFunction aFunc( *this, fP, fDF ); + double fVal = lcl_IterateInverse( aFunc, fDF*0.5, fDF, bConvError ); + if (bConvError) + SetError(errNoConvergence); + PushDouble(fVal); +} + +class ScFDistFunction : public ScDistFunc +{ + ScInterpreter& rInt; + double fp, fF1, fF2; + +public: + ScFDistFunction( ScInterpreter& rI, double fpVal, double fF1Val, double fF2Val ) : + rInt(rI), fp(fpVal), fF1(fF1Val), fF2(fF2Val) {} + + double GetValue( double x ) const { return fp - rInt.GetFDist(x, fF1, fF2); } +}; + +void ScInterpreter::ScFInv() +{ + if ( !MustHaveParamCount( GetByte(), 3 ) ) + return; + double fF2 = ::rtl::math::approxFloor(GetDouble()); + double fF1 = ::rtl::math::approxFloor(GetDouble()); + double fP = GetDouble(); + if (fP <= 0.0 || fF1 < 1.0 || fF2 < 1.0 || fF1 >= 1.0E10 || fF2 >= 1.0E10 || fP > 1.0) + { + SetIllegalArgument(); + return; + } + + BOOL bConvError; + ScFDistFunction aFunc( *this, fP, fF1, fF2 ); + double fVal = lcl_IterateInverse( aFunc, fF1*0.5, fF1, bConvError ); + if (bConvError) + SetError(errNoConvergence); + PushDouble(fVal); +} + +class ScChiDistFunction : public ScDistFunc +{ + ScInterpreter& rInt; + double fp, fDF; + +public: + ScChiDistFunction( ScInterpreter& rI, double fpVal, double fDFVal ) : + rInt(rI), fp(fpVal), fDF(fDFVal) {} + + double GetValue( double x ) const { return fp - rInt.GetChiDist(x, fDF); } +}; + +void ScInterpreter::ScChiInv() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double fDF = ::rtl::math::approxFloor(GetDouble()); + double fP = GetDouble(); + if (fDF < 1.0 || fDF >= 1.0E5 || fP <= 0.0 || fP > 1.0 ) + { + SetIllegalArgument(); + return; + } + + BOOL bConvError; + ScChiDistFunction aFunc( *this, fP, fDF ); + double fVal = lcl_IterateInverse( aFunc, fDF*0.5, fDF, bConvError ); + if (bConvError) + SetError(errNoConvergence); + PushDouble(fVal); +} + +/***********************************************/ + +void ScInterpreter::ScConfidence() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double n = ::rtl::math::approxFloor(GetDouble()); + double sigma = GetDouble(); + double alpha = GetDouble(); + if (sigma <= 0.0 || alpha <= 0.0 || alpha >= 1.0 || n < 1.0) + SetIllegalArgument(); + else + PushDouble( gaussinv(1.0-alpha/2.0) * sigma/sqrt(n) ); + } +} + +void ScInterpreter::ScZTest() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 2, 3 ) ) + return; + double sigma, mue, x; + if (nParamCount == 3) + { + sigma = GetDouble(); + if (sigma <= 0.0) + { + SetIllegalArgument(); + return; + } + } + x = GetDouble(); + + double fSum = 0.0; + double fSumSqr = 0.0; + double fVal; + double rValCount = 0.0; + switch (GetStackType()) + { + case svDouble : + { + fVal = GetDouble(); + fSum += fVal; + fSumSqr += fVal*fVal; + rValCount++; + } + break; + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + fVal = GetCellValue( aAdr, pCell ); + fSum += fVal; + fSumSqr += fVal*fVal; + rValCount++; + } + } + break; + case svDoubleRef : + { + ScRange aRange; + USHORT nErr = 0; + PopDoubleRef( aRange ); + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(fVal, nErr)) + { + fSum += fVal; + fSumSqr += fVal*fVal; + rValCount++; + while ((nErr == 0) && aValIter.GetNext(fVal, nErr)) + { + fSum += fVal; + fSumSqr += fVal*fVal; + rValCount++; + } + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for ( ULONG i = 0; i < nCount; i++ ) + { + fVal= pMat->GetDouble(i); + fSum += fVal; + fSumSqr += fVal * fVal; + rValCount++; + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + fVal= pMat->GetDouble(i); + fSum += fVal; + fSumSqr += fVal * fVal; + rValCount++; + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + if (rValCount <= 1.0) + SetNoValue(); + else + { + mue = fSum/rValCount; + if (nParamCount != 3) + sigma = (fSumSqr - fSum*fSum/rValCount)/(rValCount-1.0); + + PushDouble(0.5 - gauss((mue-x)/sqrt(sigma/rValCount))); + } +} + +void ScInterpreter::ScTTest() +{ + if ( !MustHaveParamCount( GetByte(), 4 ) ) + return; + double fTyp = ::rtl::math::approxFloor(GetDouble()); + double fAnz = ::rtl::math::approxFloor(GetDouble()); + if (fAnz != 1.0 && fAnz != 2.0) + { + SetIllegalArgument(); + return; + } + + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat2 = GetMatrix(nMatInd2); + ScMatrix* pMat1 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + double fT, fF; + USHORT nC1, nR1, nC2, nR2, i, j; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (fTyp == 1.0) + { + if (nC1 != nC2 || nR1 != nR2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSum1 = 0.0; + double fSum2 = 0.0; + double fSumSqrD = 0.0; + double fVal1, fVal2; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fVal1 = pMat1->GetDouble(i,j); + fVal2 = pMat2->GetDouble(i,j); + fSum1 += fVal1; + fSum2 += fVal2; + fSumSqrD += (fVal1 - fVal2)*(fVal1 - fVal2); + fCount++; + } + } + if (fCount < 1.0) + { + SetNoValue(); + return; + } + fT = sqrt(fCount-1.0) * fabs(fSum1 - fSum2) / + sqrt(fCount * fSumSqrD - (fSum1-fSum2)*(fSum1-fSum2)); + fF = fCount - 1.0; + } + else if (fTyp == 2.0) + { + double fCount1 = 0.0; + double fCount2 = 0.0; + double fSum1 = 0.0; + double fSumSqr1 = 0.0; + double fSum2 = 0.0; + double fSumSqr2 = 0.0; + double fVal; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j)) + { + fVal = pMat1->GetDouble(i,j); + fSum1 += fVal; + fSumSqr1 += fVal * fVal; + fCount1++; + } + } + for (i = 0; i < nC2; i++) + for (j = 0; j < nR2; j++) + { + if (!pMat2->IsString(i,j)) + { + fVal = pMat2->GetDouble(i,j); + fSum2 += fVal; + fSumSqr2 += fVal * fVal; + fCount2++; + } + } + if (fCount1 < 2.0 || fCount2 < 2.0) + { + SetNoValue(); + return; + } +#if 0 + // alter Templin-Code + double fS1 = (fSumSqr1-fSum1*fSum1/fCount1)/(fCount1-1.0)/fCount1; + double fS2 = (fSumSqr2-fSum2*fSum2/fCount2)/(fCount2-1.0)/fCount2; + if (fS1 + fS2 == 0.0) + { + SetNoValue(); + return; + } + fT = fabs(fSum1/fCount1 - fSum2/fCount2)/sqrt(fS1+fS2); + fF = fCount1 + fCount2 - 2; +#else + // laut Bronstein-Semendjajew + double fS1 = (fSumSqr1 - fSum1*fSum1/fCount1) / (fCount1 - 1.0); // Varianz + double fS2 = (fSumSqr2 - fSum2*fSum2/fCount2) / (fCount2 - 1.0); + fT = fabs( fSum1/fCount1 - fSum2/fCount2 ) / + sqrt( (fCount1-1.0)*fS1 + (fCount2-1.0)*fS2 ) * + sqrt( fCount1*fCount2*(fCount1+fCount2-2)/(fCount1+fCount2) ); + fF = fCount1 + fCount2 - 2; +#endif + } + else if (fTyp == 3.0) + { + double fCount1 = 0.0; + double fCount2 = 0.0; + double fSum1 = 0.0; + double fSumSqr1 = 0.0; + double fSum2 = 0.0; + double fSumSqr2 = 0.0; + double fVal; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j)) + { + fVal = pMat1->GetDouble(i,j); + fSum1 += fVal; + fSumSqr1 += fVal * fVal; + fCount1++; + } + } + for (i = 0; i < nC2; i++) + for (j = 0; j < nR2; j++) + { + if (!pMat2->IsString(i,j)) + { + fVal = pMat2->GetDouble(i,j); + fSum2 += fVal; + fSumSqr2 += fVal * fVal; + fCount2++; + } + } + if (fCount1 < 2.0 || fCount2 < 2.0) + { + SetNoValue(); + return; + } + double fS1 = (fSumSqr1-fSum1*fSum1/fCount1)/(fCount1-1.0)/fCount1; + double fS2 = (fSumSqr2-fSum2*fSum2/fCount2)/(fCount2-1.0)/fCount2; + if (fS1 + fS2 == 0.0) + { + SetNoValue(); + return; + } + fT = fabs(fSum1/fCount1 - fSum2/fCount2)/sqrt(fS1+fS2); + double c = fS1/(fS1+fS2); +// s.u. fF = ::rtl::math::approxFloor(1.0/(c*c/(fCount1-1.0)+(1.0-c)*(1.0-c)/(fCount2-1.0))); +// fF = ::rtl::math::approxFloor((fS1+fS2)*(fS1+fS2)/(fS1*fS1/(fCount1-1.0) + fS2*fS2/(fCount2-1.0))); + + // GetTDist wird mit GetBetaDist berechnet und kommt auch mit nicht ganzzahligen + // Freiheitsgraden klar. Dann stimmt das Ergebnis auch mit Excel ueberein (#52406#): + fF = 1.0/(c*c/(fCount1-1.0)+(1.0-c)*(1.0-c)/(fCount2-1.0)); + } + + else + { + SetIllegalArgument(); + return; + } + if (fAnz == 1.0) + PushDouble(GetTDist(fT, fF)); + else + PushDouble(2.0*GetTDist(fT, fF)); +} + +void ScInterpreter::ScFTest() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat2 = GetMatrix(nMatInd2); + ScMatrix* pMat1 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2, i, j; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + double fCount1 = 0.0; + double fCount2 = 0.0; + double fSum1 = 0.0; + double fSumSqr1 = 0.0; + double fSum2 = 0.0; + double fSumSqr2 = 0.0; + double fVal; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j)) + { + fVal = pMat1->GetDouble(i,j); + fSum1 += fVal; + fSumSqr1 += fVal * fVal; + fCount1++; + } + } + for (i = 0; i < nC2; i++) + for (j = 0; j < nR2; j++) + { + if (!pMat2->IsString(i,j)) + { + fVal = pMat2->GetDouble(i,j); + fSum2 += fVal; + fSumSqr2 += fVal * fVal; + fCount2++; + } + } + if (fCount1 < 2.0 || fCount2 < 2.0) + { + SetNoValue(); + return; + } + double fS1 = (fSumSqr1-fSum1*fSum1/fCount1)/(fCount1-1.0); + double fS2 = (fSumSqr2-fSum2*fSum2/fCount2)/(fCount2-1.0); + if (fS1 == 0.0 || fS2 == 0.0) + { + SetNoValue(); + return; + } + double fF, fF1, fF2; + if (fS1 > fS2) + { + fF = fS1/fS2; + fF1 = fCount1-1.0; + fF2 = fCount2-1.0; + } + else + { + fF = fS2/fS1; + fF1 = fCount2-1.0; + fF2 = fCount1-1.0; + } + PushDouble(2.0*GetFDist(fF, fF1, fF2)); +/* + double Z = (pow(fF,1.0/3.0)*(1.0-2.0/(9.0*fF2)) - (1.0-2.0/(9.0*fF1))) / + sqrt(2.0/(9.0*fF1) + pow(fF,2.0/3.0)*2.0/(9.0*fF2)); + PushDouble(1.0-2.0*gauss(Z)); +*/ +} + +void ScInterpreter::ScChiTest() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat2 = GetMatrix(nMatInd2); + ScMatrix* pMat1 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fChi = 0.0; + USHORT i, j; + double fValX, fValE; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValE = pMat2->GetDouble(i,j); + fChi += (fValX-fValE)*(fValX-fValE)/fValE; + } + else + { + SetIllegalArgument(); + return; + } + } + double fDF; + if (nC1 == 1 || nR1 == 1) + { + fDF = (double)(nC1*nR1 - 1); + if (fDF == 0.0) + { + SetNoValue(); + return; + } + } + else + fDF = (double)(nC1-1)*(double)(nR1-1); + PushDouble(GetChiDist(fChi, fDF)); +/* + double fX, fS, fT, fG; + fX = 1.0; + for (double fi = fDF; fi >= 2.0; fi -= 2.0) + fX *= fChi/fi; + fX *= exp(-fChi/2.0); + if (fmod(fDF, 2.0) != 0.0) + fX *= sqrt(2.0*fChi/F_PI); + fS = 1.0; + fT = 1.0; + fG = fDF; + while (fT >= 1.0E-7) + { + fG += 2.0; + fT *= fChi/fG; + fS += fT; + } + PushDouble(1.0 - fX*fS); +*/ +} + +void ScInterpreter::ScKurt() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCountMin( nParamCount, 1 ) ) + return; + USHORT SaveSP = sp; + USHORT i; + double fSum = 0.0; + double fSumSqr = 0.0; + double fCount = 0.0; + double fVal; + ScAddress aAdr; + ScRange aRange; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + { + fVal = GetDouble(); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + fVal = GetCellValue( aAdr, pCell ); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + } + break; + case svDoubleRef : + { + PopDoubleRef( aRange ); + USHORT nErr = 0; + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(fVal, nErr)) + { + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(fVal, nErr)) + { + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + fVal = pMat->GetDouble(i); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + fVal = pMat->GetDouble(i); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + } + } + } + break; + default : + SetError(errIllegalParameter); + break; + } + } + if (nGlobalError) + { + PushInt(0); + return; + } + double fMean = fSum / fCount; + double fSSqr = (fSumSqr - fSum*fSum/fCount)/(fCount-1.0); + sp = SaveSP; + fSum = 0.0; + // #55733# GCC Optimierungsfehler, GPF wenn die 4.0 als Konstante an pow() + // uebergeben wird, auch ein "const double fPow = 4.0;" GPF't, + double fPow = 4.0; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + fSum += pow(GetDouble()-fMean,fPow); + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + fSum += pow(GetCellValue( aAdr, pCell ) - fMean, fPow); + } + break; + case svDoubleRef : + { + PopDoubleRef( aRange ); + USHORT nErr = 0; + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(fVal, nErr)) + { + fSum += pow(fVal - fMean, fPow); + while (aValIter.GetNext(fVal, nErr)) + fSum += pow(fVal - fMean, fPow); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + fSum += pow(pMat->GetDouble(i) - fMean, fPow); + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + fSum += pow(pMat->GetDouble(i) - fMean, fPow); + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + PushDouble(fCount*(fCount+1.0)/((fCount-1.0)*(fCount-2.0)*(fCount-3.0)) + *fSum/(fSSqr*fSSqr) + - 3.0*(fCount-1.0)*(fCount-1.0)/((fCount-2.0)*(fCount-3.0))); +} + +void ScInterpreter::ScHarMean() +{ + BYTE nParamCount = GetByte(); + double nVal = 0.0; + ULONG nCount = 0; + ScAddress aAdr; + ScRange aRange; + for (short i = 0; i < nParamCount && (nGlobalError == 0); i++) + { + switch (GetStackType()) + { + case svDouble : + { + double x = GetDouble(); + if (x > 0.0) + { + nVal += 1.0/x; + nCount++; + } + else + SetIllegalArgument(); + break; + } + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + double x = GetCellValue( aAdr, pCell ); + if (x > 0.0) + { + nVal += 1.0/x; + nCount++; + } + else + SetIllegalArgument(); + } + break; + } + case svDoubleRef : + { + USHORT nErr = 0; + PopDoubleRef( aRange ); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + if (nCellVal > 0.0) + { + nVal += 1.0/nCellVal; + nCount++; + } + else + SetIllegalArgument(); + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr)) + { + if (nCellVal > 0.0) + { + nVal += 1.0/nCellVal; + nCount++; + } + else + SetIllegalArgument(); + } + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + double x = pMat->GetDouble(i); + if (x > 0.0) + { + nVal += 1.0/x; + nCount++; + } + else + SetIllegalArgument(); + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + double x = pMat->GetDouble(i); + if (x > 0.0) + { + nVal += 1.0/x; + nCount++; + } + else + SetIllegalArgument(); + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + if (nGlobalError == 0) + PushDouble((double)nCount/nVal); +} + +void ScInterpreter::ScGeoMean() +{ + BYTE nParamCount = GetByte(); + double nVal = 0.0; + ULONG nCount = 0; + ScAddress aAdr; + ScRange aRange; + for (short i = 0; i < nParamCount && (nGlobalError == 0); i++) + { + switch (GetStackType()) + { + case svDouble : + { + double x = GetDouble(); + if (x > 0.0) + { + nVal += log(x); + nCount++; + } + else + SetIllegalArgument(); + break; + } + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + double x = GetCellValue( aAdr, pCell ); + if (x > 0.0) + { + nVal += log(x); + nCount++; + } + else + SetIllegalArgument(); + } + break; + } + case svDoubleRef : + { + USHORT nErr = 0; + PopDoubleRef( aRange ); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + if (nCellVal > 0.0) + { + nVal += log(nCellVal); + nCount++; + } + else + SetIllegalArgument(); + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr)) + { + if (nCellVal > 0.0) + { + nVal += log(nCellVal); + nCount++; + } + else + SetIllegalArgument(); + } + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + double x = pMat->GetDouble(i); + if (x > 0.0) + { + nVal += log(x); + nCount++; + } + else + SetIllegalArgument(); + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + double x = pMat->GetDouble(i); + if (x > 0.0) + { + nVal += log(x); + nCount++; + } + else + SetIllegalArgument(); + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + if (nGlobalError == 0) + PushDouble(exp(nVal/(double)nCount)); +} + +void ScInterpreter::ScStandard() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + double sigma = GetDouble(); + double mue = GetDouble(); + double x = GetDouble(); + if (sigma <= 0.0) + SetIllegalArgument(); + else + PushDouble((x-mue)/sigma); + } +} + +void ScInterpreter::ScSkew() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCountMin( nParamCount, 1 ) ) + return; + USHORT SaveSP = sp; + USHORT i; + double fSum = 0.0; + double fSumSqr = 0.0; + double fCount = 0.0; + double fVal; + ScAddress aAdr; + ScRange aRange; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + { + fVal = GetDouble(); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + fVal = GetCellValue( aAdr, pCell ); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + } + break; + case svDoubleRef : + { + PopDoubleRef( aRange ); + USHORT nErr = 0; + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(fVal, nErr)) + { + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(fVal, nErr)) + { + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + fVal = pMat->GetDouble(i); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + fVal = pMat->GetDouble(i); + fSum += fVal; + fSumSqr += fVal*fVal; + fCount++; + } + } + } + } + break; + default : + SetError(errIllegalParameter); + break; + } + } + if (nGlobalError) + { + PushInt(0); + return; + } + double fMean = fSum / fCount; + double fSSqr = (fSumSqr - fSum*fSum/fCount)/(fCount-1.0); + sp = SaveSP; + fSum = 0.0; + double fPow = 3.0; // vorsichtshalber wg. #55733#, siehe ScKurt() + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + fSum += pow(GetDouble()-fMean,fPow); + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + fSum += pow(GetCellValue( aAdr, pCell ) - fMean, fPow); + } + break; + case svDoubleRef : + { + PopDoubleRef( aRange ); + USHORT nErr = 0; + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(fVal, nErr)) + { + fSum += pow(fVal - fMean, fPow); + while (aValIter.GetNext(fVal, nErr)) + fSum += pow(fVal - fMean, fPow); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + fSum += pow(pMat->GetDouble(i) - fMean, fPow); + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + fSum += pow(pMat->GetDouble(i) - fMean, fPow); + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + PushDouble(fCount/((fCount-1.0)*(fCount-2.0))*fSum/(fSSqr*sqrt(fSSqr))); +} + +void ScInterpreter::ScMedian() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCountMin( nParamCount, 1 ) ) + return; + double* pSortArray = NULL; + ULONG nSize = 0; + GetSortArray(nParamCount, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + if (nSize % 2 == 0) + PushDouble((pSArray[nSize/2-1]+pSArray[nSize/2])/2.0); + else + PushDouble(pSArray[(nSize-1)/2]); + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } + +} + +void ScInterpreter::ScPercentile() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double alpha = GetDouble(); + if (alpha < 0.0 || alpha > 1.0) + { + SetIllegalArgument(); + return; + } + double* pSortArray = NULL; + ULONG nSize = 0; + GetSortArray(1, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + if (nSize == 1) + PushDouble(pSArray[0]); + else + { + ULONG nIndex = (ULONG)::rtl::math::approxFloor(alpha*(nSize-1)); + double fDiff = alpha*(nSize-1) - ::rtl::math::approxFloor(alpha*(nSize-1)); + DBG_ASSERT(nIndex >= 0 && nIndex < nSize, "ScPercentile: falscher Index (1)"); + if (fDiff == 0.0) + PushDouble(pSArray[nIndex]); + else + { + DBG_ASSERT(nIndex < nSize-1, "ScPercentile: falscher Index(2)"); + PushDouble(pSArray[nIndex] + + fDiff*(pSArray[nIndex+1]-pSArray[nIndex])); + } + } + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } +} + +void ScInterpreter::ScQuartile() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double fFlag = ::rtl::math::approxFloor(GetDouble()); + if (fFlag < 0.0 || fFlag > 4.0) + { + SetIllegalArgument(); + return; + } + double* pSortArray = NULL; + ULONG nSize = 0; + GetSortArray(1, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + if (nSize == 1) + PushDouble(pSArray[0]); + else + { + if (fFlag == 0.0) + PushDouble(pSArray[0]); + else if (fFlag == 1.0) + { + ULONG nIndex = (ULONG)::rtl::math::approxFloor(0.25*(nSize-1)); + double fDiff = 0.25*(nSize-1) - ::rtl::math::approxFloor(0.25*(nSize-1)); + DBG_ASSERT(nIndex >= 0 && nIndex < nSize, "ScQuartile: falscher Index (1)"); + if (fDiff == 0.0) + PushDouble(pSArray[nIndex]); + else + { + DBG_ASSERT(nIndex < nSize-1, "ScQuartile: falscher Index(2)"); + PushDouble(pSArray[nIndex] + + fDiff*(pSArray[nIndex+1]-pSArray[nIndex])); + } + } + else if (fFlag == 2.0) + { + if (nSize % 2 == 0) + PushDouble((pSArray[nSize/2-1]+pSArray[nSize/2])/2.0); + else + PushDouble(pSArray[(nSize-1)/2]); + } + else if (fFlag == 3.0) + { + ULONG nIndex = (ULONG)::rtl::math::approxFloor(0.75*(nSize-1)); + double fDiff = 0.75*(nSize-1) - ::rtl::math::approxFloor(0.75*(nSize-1)); + DBG_ASSERT(nIndex >= 0 && nIndex < nSize, "ScQuartile: falscher Index (3)"); + if (fDiff == 0.0) + PushDouble(pSArray[nIndex]); + else + { + DBG_ASSERT(nIndex < nSize-1, "ScQuartile: falscher Index(4)"); + PushDouble(pSArray[nIndex] + + fDiff*(pSArray[nIndex+1]-pSArray[nIndex])); + } + } + else + PushDouble(pSArray[nSize-1]); + } + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } +} + +void ScInterpreter::ScModalValue() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCountMin( nParamCount, 1 ) ) + return; + double* pSortArray = NULL; + ULONG nSize = 0; + GetSortArray(nParamCount, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + ULONG nMaxIndex, nMax = 1, nCount = 1; + double nOldVal = pSArray[0]; + ULONG i = 0; + for (i = 1; i < nSize; i++) + { + if (pSArray[i] == nOldVal) + nCount++; + else + { + nOldVal = pSArray[i]; + if (nCount > nMax) + { + nMax = nCount; + nMaxIndex = i-1; + } + nCount = 1; + } + } + if (nCount > nMax) + { + nMax = nCount; + nMaxIndex = i-1; + } + if (nMax == 1 && nCount == 1) + SetNoValue(); + else if (nMax == 1) + PushDouble(nOldVal); + else + PushDouble(pSArray[nMaxIndex]); + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } +} + +void ScInterpreter::ScLarge() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double* pSortArray = NULL; + ULONG nSize = 0; + ULONG k = (ULONG) ::rtl::math::approxFloor(GetDouble()); + if (k <= 0) + { + SetIllegalArgument(); + return; + } + GetSortArray(1, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError || nSize < k) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif +/* + ULONG nCount = 1; + double nOldVal = pSArray[nSize-1]; + for (long i = nSize-2; i >= 0 && nCount < k; i--) + { + if (pSArray[i] != nOldVal) + { + nCount++; + nOldVal = pSArray[i]; + } + } + if (nCount < k) + SetNoValue(); + else + PushDouble(nOldVal); +*/ + PushDouble( pSArray[ nSize-k ] ); + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } +} + +void ScInterpreter::ScSmall() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double* pSortArray = NULL; + ULONG nSize = 0; + ULONG k = (ULONG) ::rtl::math::approxFloor(GetDouble()); + if (k <= 0) + { + SetIllegalArgument(); + return; + } + GetSortArray(1, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError || nSize < k) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif +/* + ULONG nCount = 1; + double nOldVal = pSArray[0]; + for (ULONG i = 1; i < nSize && nCount < k; i++) + { + if (pSArray[i] != nOldVal) + { + nCount++; + nOldVal = pSArray[i]; + } + } + if (nCount < k) + SetNoValue(); + else + PushDouble(nOldVal); +*/ + PushDouble( pSArray[ k-1 ] ); + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } +} + +void ScInterpreter::ScPercentrank() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 2 ) ) + return; +/* wird nicht unterstuetzt + double fPrec; + if (nParamCount == 3) + { + fPrec = ::rtl::math::approxFloor(GetDouble()); + if (fPrec < 1.0) + { + SetIllegalArgument(); + return; + } + } + else + fPrec = 3.0; +*/ + double fNum = GetDouble(); + double* pSortArray = NULL; + ULONG nSize = 0; + GetSortArray(1, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError) + SetNoValue(); + else + { +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + if (fNum < pSArray[0] || fNum > pSArray[nSize-1]) + SetNoValue(); + else if ( nSize == 1 ) + PushDouble(1.0); // fNum == pSArray[0], see test above + else + { + double fRes; + ULONG nOldCount = 0; + double fOldVal = pSArray[0]; + ULONG i; + for (i = 1; i < nSize && pSArray[i] < fNum; i++) + { + if (pSArray[i] != fOldVal) + { + nOldCount = i; + fOldVal = pSArray[i]; + } + } + if (pSArray[i] != fOldVal) + nOldCount = i; + if (fNum == pSArray[i]) + fRes = (double)nOldCount/(double)(nSize-1); + else + { + // #75312# nOldCount is the count of smaller entries + // fNum is between pSArray[nOldCount-1] and pSArray[nOldCount] + // use linear interpolation to find a position between the entries + + if ( nOldCount == 0 ) + { + DBG_ERROR("should not happen"); + fRes = 0.0; + } + else + { + double fFract = ( fNum - pSArray[nOldCount-1] ) / + ( pSArray[nOldCount] - pSArray[nOldCount-1] ); + fRes = ( (double)(nOldCount-1)+fFract )/(double)(nSize-1); + } + } + PushDouble(fRes); + } + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + } +} + +void ScInterpreter::ScTrimMean() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + double alpha = GetDouble(); + if (alpha < 0.0 || alpha >= 1.0) + { + SetIllegalArgument(); + return; + } + double* pSortArray = NULL; + ULONG nSize = 0; + GetSortArray(1, &pSortArray, nSize); + if (!pSortArray || nSize == 0 || nGlobalError) + SetNoValue(); + else + { + ppGlobSortArray = &pSortArray; +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + ULONG nIndex = (ULONG) ::rtl::math::approxFloor(alpha*(double)nSize); + if (nIndex % 2 != 0) + nIndex--; + nIndex /= 2; + DBG_ASSERT(nIndex >= 0 && nIndex < nSize, "ScTrimMean: falscher Index"); + double fSum = 0.0; + for (ULONG i = nIndex; i < nSize-nIndex; i++) + fSum += pSArray[i]; + PushDouble(fSum/(double)(nSize-2*nIndex)); + } + if (pSortArray) + { +#ifdef WIN + SvMemFree(pSortArray); +#else + delete [] pSortArray; +#endif + ppGlobSortArray = NULL; + } +} + +void ScInterpreter::GetSortArray(BYTE nParamCount, double** ppSortArray, ULONG& nSize) +{ + *ppSortArray = NULL; + nSize = 0; + + USHORT SaveSP = sp; + USHORT i; + ULONG rValCount = 0; + ScAddress aAdr; + ScRange aRange; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + PopDouble(); + rValCount++; + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + rValCount++; + } + break; + case svDoubleRef : + { + PopDoubleRef( aRange ); + USHORT nErr = 0; + double nCellVal; + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(nCellVal, nErr)) + { + rValCount++; + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr)) + rValCount++; + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + rValCount += nCount; + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + rValCount++; + } + } + } + break; + default : + SetError(errIllegalParameter); + break; + } + } + if (rValCount > MAX_ANZ_DOUBLE_FOR_SORT || nGlobalError) + { + SetError(errStackOverflow); + return; + } + else if (rValCount == 0) + { + SetNoValue(); + return; + } +#ifdef WIN + *ppSortArray = (double*) SvMemAlloc( rValCount * sizeof(double)); + double huge* pSArray = (double huge*) (*ppSortArray); +#else + *ppSortArray = new double[rValCount]; + double* pSArray = *ppSortArray; +#endif + if (!*ppSortArray) + { + rValCount = 0; + SetError(errStackOverflow); + return; + } + sp = SaveSP; + ULONG nIndex = 0; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + pSArray[nIndex] = GetDouble(); + nIndex++; + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + pSArray[nIndex] = GetCellValue( aAdr, pCell ); + nIndex++; + } + } + break; + case svDoubleRef : + { + PopDoubleRef( aRange ); + USHORT nErr; + double nCellVal; + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(nCellVal, nErr)) + { + pSArray[nIndex] = nCellVal; + nIndex++; + while (aValIter.GetNext(nCellVal, nErr)) + { + pSArray[nIndex] = nCellVal; + nIndex++; + } + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + pSArray[nIndex] = pMat->GetDouble(i); + nIndex++; + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + pSArray[nIndex] = pMat->GetDouble(i); + nIndex++; + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + DBG_ASSERT(nIndex == rValCount,"nIndex != rValCount"); + if (nGlobalError == 0) + { + double fVal; + USHORT nInd; + for (ULONG i = 0; (i + 4) <= rValCount-1; i += 4) + { + nInd = rand() % (int) (rValCount-1); + fVal = pSArray[i]; + pSArray[i] = pSArray[nInd]; + pSArray[nInd] = fVal; + } + QuickSort(0, rValCount-1, pSArray); + } + nSize = rValCount; +} + +void ScInterpreter::QuickSort(long nLo, long nHi, double* pSortArray) +{ +#ifdef WIN + double huge* pSArray = (double huge*) pSortArray; +#else + double* pSArray = pSortArray; +#endif + if (nHi - nLo == 1) + { + if (pSArray[nLo] > pSArray[nHi]) + { + double fVal; + fVal = pSArray[nLo]; + pSArray[nLo] = pSArray[nHi]; + pSArray[nHi] = fVal; + } + } + else + { + long ni = nLo; + long nj = nHi; + do + { + while (ni <= nHi && pSArray[ni] < pSArray[nLo]) ni++; + while (nj >= nLo && pSArray[nLo] < pSArray[nj]) nj--; + if (ni <= nj) + { + if (ni != nj) + { + double fVal; + fVal = pSArray[ni]; + pSArray[ni] = pSArray[nj]; + pSArray[nj] = fVal; + } + ni++; + nj--; + } + } + while (ni < nj); + if ((nj - nLo) < (nHi - ni)) + { + if (nLo < nj) QuickSort(nLo, nj, pSortArray); + if (ni < nHi) QuickSort(ni, nHi, pSortArray); + } + else + { + if (ni < nHi) QuickSort(ni, nHi, pSortArray); + if (nLo < nj) QuickSort(nLo, nj, pSortArray); + } + } +} + +void ScInterpreter::ScRank() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 2, 3 ) ) + return; + BOOL bDescending; + if (nParamCount == 3) + bDescending = GetBool(); + else + bDescending = FALSE; + double fCount = 1.0; + BOOL bValid = FALSE; + switch (GetStackType()) + { + case svDouble : + { + double x = GetDouble(); + double fVal = GetDouble(); + if (x == fVal) + bValid = TRUE; + break; + } + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + double fVal = GetDouble(); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + double x = GetCellValue( aAdr, pCell ); + if (x == fVal) + bValid = TRUE; + } + break; + } + case svDoubleRef : + { + ScRange aRange; + USHORT nErr = 0; + PopDoubleRef( aRange ); + double fVal = GetDouble(); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + if (nCellVal == fVal) + bValid = TRUE; + else if ((!bDescending && nCellVal > fVal) || + (bDescending && nCellVal < fVal) ) + fCount++; + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr)) + { + if (nCellVal == fVal) + bValid = TRUE; + else if ((!bDescending && nCellVal > fVal) || + (bDescending && nCellVal < fVal) ) + fCount++; + } + } + SetError(nErr); + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + double fVal = GetDouble(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + double x = pMat->GetDouble(i); + if (x == fVal) + bValid = TRUE; + else if ((!bDescending && x > fVal) || + (bDescending && x < fVal) ) + fCount++; + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + double x = pMat->GetDouble(i); + if (x == fVal) + bValid = TRUE; + else if ((!bDescending && x > fVal) || + (bDescending && x < fVal) ) + fCount++; + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + if (bValid) + PushDouble(fCount); + else + SetNoValue(); +} + +void ScInterpreter::ScAveDev() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCountMin( nParamCount, 1 ) ) + return; + USHORT SaveSP = sp; + USHORT i; + double nMiddle = 0.0; + double rVal = 0.0; + double rValCount = 0.0; + ScAddress aAdr; + ScRange aRange; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + rVal += GetDouble(); + rValCount++; + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + { + rVal += GetCellValue( aAdr, pCell ); + rValCount++; + } + } + break; + case svDoubleRef : + { + USHORT nErr = 0; + double nCellVal; + PopDoubleRef( aRange ); + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(nCellVal, nErr)) + { + rVal += nCellVal; + rValCount++; + SetError(nErr); + while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr)) + { + rVal += nCellVal; + rValCount++; + } + SetError(nErr); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + { + rVal += pMat->GetDouble(i); + rValCount++; + } + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + { + rVal += pMat->GetDouble(i); + rValCount++; + } + } + } + } + break; + default : + SetError(errIllegalParameter); + break; + } + } + if (nGlobalError) + { + PushInt(0); + return; + } + nMiddle = rVal / rValCount; + sp = SaveSP; + rVal = 0.0; + for (i = 0; i < nParamCount; i++) + { + switch (GetStackType()) + { + case svDouble : + rVal += fabs(GetDouble() - nMiddle); + break; + case svSingleRef : + { + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + rVal += fabs(GetCellValue( aAdr, pCell ) - nMiddle); + } + break; + case svDoubleRef : + { + USHORT nErr = 0; + double nCellVal; + PopDoubleRef( aRange ); + ScValueIterator aValIter(pDok, aRange); + if (aValIter.GetFirst(nCellVal, nErr)) + { + rVal += (fabs(nCellVal - nMiddle)); + while (aValIter.GetNext(nCellVal, nErr)) + rVal += fabs(nCellVal - nMiddle); + } + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + ULONG nCount = pMat->GetElementCount(); + if (pMat->IsNumeric()) + { + for (ULONG i = 0; i < nCount; i++) + rVal += fabs(pMat->GetDouble(i) - nMiddle); + } + else + { + for (ULONG i = 0; i < nCount; i++) + if (!pMat->IsString(i)) + rVal += fabs(pMat->GetDouble(i) - nMiddle); + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + PushDouble(rVal / rValCount); +} + +void ScInterpreter::ScDevSq() +{ + double nVal; + double nValCount; + GetStVarParams(nVal, nValCount); + PushDouble(nVal); +} + +void ScInterpreter::ScProbability() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 3, 4 ) ) + return; + double fUp, fLo; + fUp = GetDouble(); + if (nParamCount == 4) + fLo = GetDouble(); + else + fLo = fUp; + if (fLo > fUp) + { + double fTemp = fLo; + fLo = fUp; + fUp = fTemp; + } + USHORT nMatInd1, nMatInd2; + ScMatrix* pMatP = GetMatrix(nMatInd1); + ScMatrix* pMatW = GetMatrix(nMatInd2); + if (!pMatP || !pMatW) + SetIllegalParameter(); + else + { + USHORT nC1, nR1, nC2, nR2; + pMatP->GetDimensions(nC1, nR1); + pMatW->GetDimensions(nC2, nR2); + if (nC1 != nC2 || nR1 != nR2 || nC1 == 0 || nR1 == 0 || + nC2 == 0 || nR2 == 0) + SetNV(); + else + { + double fSum = 0.0; + double fRes = 0.0; + BOOL bStop = FALSE; + double fP, fW; + ULONG nCount1 = (ULONG) nC1 * nR1; + for ( ULONG i = 0; i < nCount1 && !bStop; i++ ) + { + if (pMatP->IsValue(i) && pMatW->IsValue(i)) + { + fP = pMatP->GetDouble(i); + fW = pMatW->GetDouble(i); + if (fP < 0.0 || fP > 1.0) + bStop = TRUE; + else + { + fSum += fP; + if (fW >= fLo && fW <= fUp) + fRes += fP; + } + } + else + SetIllegalArgument(); + } + if (bStop || fabs(fSum -1.0) > 1.0E-7) + SetNoValue(); + else + PushDouble(fRes); + } + } +} + +void ScInterpreter::ScCorrel() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 2.0) + SetNoValue(); + else + PushDouble( (fSumXY-fSumX*fSumY/fCount)/ + sqrt((fSumSqrX-fSumX*fSumX/fCount)* + (fSumSqrY-fSumY*fSumY/fCount))); +} + +void ScInterpreter::ScCovar() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumY += fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 1.0) + SetNoValue(); + else + PushDouble( (fSumXY-fSumX*fSumY/fCount)/fCount); +} + +void ScInterpreter::ScPearson() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 2.0) + SetNoValue(); + else + PushDouble( (fCount*fSumXY-fSumX*fSumY)/ + sqrt((fCount*fSumSqrX-fSumX*fSumX)* + (fCount*fSumSqrY-fSumY*fSumY))); +} + +void ScInterpreter::ScRSQ() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 2.0) + SetNoValue(); + else + PushDouble( (fCount*fSumXY-fSumX*fSumY)*(fCount*fSumXY-fSumX*fSumY)/ + (fCount*fSumSqrX-fSumX*fSumX)/(fCount*fSumSqrY-fSumY*fSumY)); +} + +void ScInterpreter::ScSTEXY() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 3.0) + SetNoValue(); + else + PushDouble(sqrt((fCount*fSumSqrY - fSumY*fSumY - + (fCount*fSumXY -fSumX*fSumY)*(fCount*fSumXY -fSumX*fSumY)/ + (fCount*fSumSqrX-fSumX*fSumX) )/(fCount*(fCount-2.0)))); +} + +void ScInterpreter::ScSlope() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 1.0) + SetNoValue(); + else + PushDouble( (fCount*fSumXY-fSumX*fSumY)/ + (fCount*fSumSqrX-fSumX*fSumX) ); +} + +void ScInterpreter::ScIntercept() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 1.0) + SetNoValue(); + else + PushDouble( fSumY/fCount - (fCount*fSumXY-fSumX*fSumY)/ + (fCount*fSumSqrX-fSumX*fSumX)*fSumX/fCount ); + +} + +void ScInterpreter::ScForecast() +{ + if ( !MustHaveParamCount( GetByte(), 3 ) ) + return; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat1 = GetMatrix(nMatInd2); + ScMatrix* pMat2 = GetMatrix(nMatInd1); + if (!pMat1 || !pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nR1 != nR2 || nC1 != nC2) + { + SetIllegalParameter(); + return; + } + double fVal = GetDouble(); + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nC1; i++) + for (USHORT j = 0; j < nR1; j++) + { + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fValX = pMat1->GetDouble(i,j); + fValY = pMat2->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumXY += fValX*fValY; + fCount++; + } + } + if (fCount < 1.0) + SetNoValue(); + else + PushDouble( fSumY/fCount + (fCount*fSumXY-fSumX*fSumY)/ + (fCount*fSumSqrX-fSumX*fSumX) * (fVal - fSumX/fCount) ); +} + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_interpr4.cxx b/binfilter/bf_sc/source/core/tool/sc_interpr4.cxx new file mode 100644 index 000000000000..01a17c5a6730 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_interpr4.cxx @@ -0,0 +1,3249 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#ifdef RS6000 + +#pragma options FLTTRAP +#include <fptrap.h> +#include <fpxcp.h> + +#elif defined ( MAC ) + +#include <MAC_START.h> +#include <fp.h> +#include <MAC_END.h> +#include <ctype.h> + +#elif defined ( SOLARIS) + +#include <ieeefp.h> +#include <ctype.h> + +#elif defined ( ICC ) + +#include <ctype.h> + +#endif + + +#include <bf_sfx2/app.hxx> +#include "bf_basic/sbmeth.hxx" +#include "bf_basic/sbmod.hxx" +#include "bf_basic/sbstar.hxx" +#include "bf_basic/sbx.hxx" +#include <bf_svtools/zforlist.hxx> +#include <stdlib.h> +#include <string.h> +#include <signal.h> +#include <math.h> +#include <float.h> + + +using namespace ::com::sun::star; + +#include "interpre.hxx" +#include "dbcolect.hxx" +#include "addincol.hxx" +#include "dociter.hxx" +#include "scmatrix.hxx" +#include "bf_sc.hrc" +#include "cellsuno.hxx" +#include "optuno.hxx" +#include "rangeseq.hxx" +#include "addinlis.hxx" +namespace binfilter { + +// Implementiert in ui\miscdlgs\teamdlg.cxx + +extern void ShowTheTeam(); + +extern BOOL bOderSo; // in GLOBAL.CXX + +//-----------------------------statische Daten----------------- + +USHORT ScInterpreter::nGlobalError = 0; // fuer matherr + +#if SC_SPEW_ENABLED +ScSpew ScInterpreter::theSpew; +#endif + +//------------------------------------------------------------------------- +// Funktionen für den Zugriff auf das Document +//------------------------------------------------------------------------- + + +void ScInterpreter::ReplaceCell( ScAddress& rPos ) +{ + ScInterpreterTableOpParams* pTOp = pDok->aTableOpList.First(); + while (pTOp) + { + if ( rPos == pTOp->aOld1 ) + { + rPos = pTOp->aNew1; + return ; + } + else if ( rPos == pTOp->aOld2 ) + { + rPos = pTOp->aNew2; + return ; + } + else + pTOp = pDok->aTableOpList.Next(); + } +} + + +void ScInterpreter::ReplaceCell( USHORT& rCol, USHORT& rRow, USHORT& rTab ) +{ + ScAddress aCellPos( rCol, rRow, rTab ); + ScInterpreterTableOpParams* pTOp = pDok->aTableOpList.First(); + while (pTOp) + { + if ( aCellPos == pTOp->aOld1 ) + { + rCol = pTOp->aNew1.Col(); + rRow = pTOp->aNew1.Row(); + rTab = pTOp->aNew1.Tab(); + return ; + } + else if ( aCellPos == pTOp->aOld2 ) + { + rCol = pTOp->aNew2.Col(); + rRow = pTOp->aNew2.Row(); + rTab = pTOp->aNew2.Tab(); + return ; + } + else + pTOp = pDok->aTableOpList.Next(); + } +} + + +BOOL ScInterpreter::IsTableOpInRange( const ScRange& rRange ) +{ + if ( rRange.aStart == rRange.aEnd ) + return FALSE; // not considered to be a range in TableOp sense + + // we can't replace a single cell in a range + ScInterpreterTableOpParams* pTOp = pDok->aTableOpList.First(); + while (pTOp) + { + if ( rRange.In( pTOp->aOld1 ) ) + return TRUE; + if ( rRange.In( pTOp->aOld2 ) ) + return TRUE; + pTOp = pDok->aTableOpList.Next(); + } + return FALSE; +} + + +ULONG ScInterpreter::GetCellNumberFormat( const ScAddress& rPos, const ScBaseCell* pCell) +{ + ULONG nFormat; + USHORT nErr; + if ( pCell ) + { + if ( pCell->GetCellType() == CELLTYPE_FORMULA ) + nErr = ((ScFormulaCell*)pCell)->GetErrCode(); + else + nErr = 0; + nFormat = pDok->GetNumberFormat( rPos ); + if ( pCell->GetCellType() == CELLTYPE_FORMULA + && ((nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0) ) + nFormat = ((ScFormulaCell*)pCell)->GetStandardFormat( *pFormatter, + nFormat ); + } + else + { + nFormat = pDok->GetNumberFormat( rPos ); + nErr = 0; + } + SetError(nErr); + return nFormat; +} + + +// nur ValueCell, Formelzellen speichern das Ergebnis bereits gerundet +/*N*/ double ScInterpreter::GetValueCellValue( const ScAddress& rPos, const ScValueCell* pCell ) +/*N*/ { +/*N*/ double fVal = pCell->GetValue(); +/*N*/ if ( bCalcAsShown && fVal != 0.0 ) +/*N*/ { +/*?*/ ULONG nFormat = pDok->GetNumberFormat( rPos ); +/*?*/ fVal = pDok->RoundValueAsShown( fVal, nFormat ); +/*N*/ } +/*N*/ return fVal; +/*N*/ } + + +/*N*/ double ScInterpreter::GetCellValue( const ScAddress& rPos, const ScBaseCell* pCell ) +/*N*/ { +/*N*/ USHORT nErr = nGlobalError; +/*N*/ nGlobalError = 0; +/*N*/ double nVal = GetCellValueOrZero( rPos, pCell ); +/*N*/ if ( !nGlobalError || nGlobalError == errCellNoValue ) +/*N*/ nGlobalError = nErr; +/*N*/ return nVal; +/*N*/ } + + +/*N*/ double ScInterpreter::GetCellValueOrZero( const ScAddress& rPos, const ScBaseCell* pCell ) +/*N*/ { +/*N*/ double fValue; +/*N*/ if (pCell) +/*N*/ { +/*N*/ CellType eType = pCell->GetCellType(); +/*N*/ switch ( eType ) +/*N*/ { +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*) pCell; +/*N*/ USHORT nErr = pFCell->GetErrCode(); +/*N*/ if( !nErr ) +/*N*/ { +/*N*/ if (pFCell->IsValue()) +/*N*/ { +/*N*/ fValue = pFCell->GetValue(); +/*N*/ pDok->GetNumberFormatInfo( nCurFmtType, nCurFmtIndex, +/*N*/ rPos, *pFCell ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SetError(errCellNoValue); +/*N*/ fValue = 0.0; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ fValue = 0.0; +/*N*/ SetError(nErr); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ fValue = ((ScValueCell*)pCell)->GetValue(); +/*N*/ nCurFmtIndex = pDok->GetNumberFormat( rPos ); +/*N*/ nCurFmtType = pFormatter->GetType( nCurFmtIndex ); +/*N*/ if ( bCalcAsShown && fValue != 0.0 ) +/*?*/ fValue = pDok->RoundValueAsShown( fValue, nCurFmtIndex ); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ case CELLTYPE_EDIT: +/*?*/ #if 0 +/*?*/ // Xcl does it, but SUM(A1:A2) differs from A1+A2. No good. +/*?*/ { +/*?*/ String aStr; +/*?*/ if ( eType == CELLTYPE_STRING ) +/*?*/ ((ScStringCell*)pCell)->GetString( aStr ); +/*?*/ else +/*?*/ ((ScEditCell*)pCell)->GetString( aStr ); +/*?*/ ULONG nFIndex = 0; // damit default Land/Spr. +/*?*/ if ( !pFormatter->IsNumberFormat( aStr, nFIndex, fValue ) ) +/*?*/ { +/*?*/ SetError(errNoValue); +/*?*/ fValue = 0.0; +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ #endif +/*N*/ default: +/*N*/ SetError(errCellNoValue); +/*N*/ fValue = 0.0; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ fValue = 0.0; +/*N*/ return fValue; +/*N*/ } + + +/*N*/ void ScInterpreter::GetCellString( String& rStr, const ScBaseCell* pCell ) +/*N*/ { +/*N*/ USHORT nErr = 0; +/*N*/ if (pCell) +/*N*/ { +/*N*/ switch (pCell->GetCellType()) +/*N*/ { +/*N*/ case CELLTYPE_STRING: +/*N*/ ((ScStringCell*) pCell)->GetString(rStr); +/*N*/ break; +/*?*/ case CELLTYPE_EDIT: +/*?*/ ((ScEditCell*) pCell)->GetString(rStr); +/*?*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ ScFormulaCell* pFCell = (ScFormulaCell*) pCell; +/*N*/ nErr = pFCell->GetErrCode(); +/*N*/ if (pFCell->IsValue()) +/*N*/ { +/*?*/ double fVal = pFCell->GetValue(); +/*?*/ ULONG nIndex = pFormatter->GetStandardFormat( +/*?*/ NUMBERFORMAT_NUMBER, +/*?*/ ScGlobal::eLnge); +/*?*/ pFormatter->GetInputLineString(fVal, nIndex, rStr); +/*N*/ } +/*N*/ else +/*N*/ pFCell->GetString(rStr); +/*N*/ } +/*N*/ break; +/*?*/ case CELLTYPE_VALUE: +/*?*/ { +/*?*/ double fVal = ((ScValueCell*) pCell)->GetValue(); +/*?*/ ULONG nIndex = pFormatter->GetStandardFormat( +/*?*/ NUMBERFORMAT_NUMBER, +/*?*/ ScGlobal::eLnge); +/*?*/ pFormatter->GetInputLineString(fVal, nIndex, rStr); +/*?*/ } +/*?*/ break; +/*N*/ default: +/*N*/ rStr = ScGlobal::GetEmptyString(); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ rStr = ScGlobal::GetEmptyString(); +/*N*/ SetError(nErr); +/*N*/ } + + +USHORT ScInterpreter::GetCellErrCode( const ScBaseCell* pCell ) +{ + if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) + return ((ScFormulaCell*)pCell)->GetErrCode(); + return 0; +} + + +BOOL ScInterpreter::CreateDoubleArr(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, BYTE* pCellArr) +{ + USHORT nCount = 0; + USHORT* p = (USHORT*) pCellArr; + *p++ = nCol1; + *p++ = nRow1; + *p++ = nTab1; + *p++ = nCol2; + *p++ = nRow2; + *p++ = nTab2; + USHORT* pCount = p; + *p++ = 0; + USHORT nPos = 14; + USHORT nTab = nTab1; + ScAddress aAdr; + while (nTab <= nTab2) + { + aAdr.SetTab( nTab ); + USHORT nRow = nRow1; + while (nRow <= nRow2) + { + aAdr.SetRow( nRow ); + USHORT nCol = nCol1; + while (nCol <= nCol2) + { + aAdr.SetCol( nCol ); + ScBaseCell* pCell = pDok->GetCell( aAdr ); + if (pCell) + { + USHORT nErr = 0; + double nVal = 0.0; + BOOL bOk = TRUE; + switch ( pCell->GetCellType() ) + { + case CELLTYPE_VALUE : + nVal = GetValueCellValue( aAdr, (ScValueCell*)pCell ); + break; + case CELLTYPE_FORMULA : + if (((ScFormulaCell*)pCell)->IsValue()) + { + nErr = ((ScFormulaCell*)pCell)->GetErrCode(); + nVal = ((ScFormulaCell*)pCell)->GetValue(); + } + else + bOk = FALSE; + break; + default : + bOk = FALSE; + break; + } + if (bOk) + { + if ((nPos + (4 * sizeof(USHORT)) + sizeof(double)) > MAXARRSIZE) + return FALSE; + *p++ = nCol; + *p++ = nRow; + *p++ = nTab; + *p++ = nErr; + memcpy( p, &nVal, sizeof(double)); + nPos += 8 + sizeof(double); + p = (USHORT*) ( pCellArr + nPos ); + nCount++; + } + } + nCol++; + } + nRow++; + } + nTab++; + } + *pCount = nCount; + return TRUE; +} + + +BOOL ScInterpreter::CreateStringArr(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, + BYTE* pCellArr) +{ + USHORT nCount = 0; + USHORT* p = (USHORT*) pCellArr; + *p++ = nCol1; + *p++ = nRow1; + *p++ = nTab1; + *p++ = nCol2; + *p++ = nRow2; + *p++ = nTab2; + USHORT* pCount = p; + *p++ = 0; + USHORT nPos = 14; + USHORT nTab = nTab1; + while (nTab <= nTab2) + { + USHORT nRow = nRow1; + while (nRow <= nRow2) + { + USHORT nCol = nCol1; + while (nCol <= nCol2) + { + ScBaseCell* pCell; + pDok->GetCell(nCol, nRow, nTab, pCell); + if (pCell) + { + String aStr; + USHORT nErr = 0; + BOOL bOk = TRUE; + switch ( pCell->GetCellType() ) + { + case CELLTYPE_STRING : + ((ScStringCell*)pCell)->GetString(aStr); + break; + case CELLTYPE_EDIT : + ((ScEditCell*)pCell)->GetString(aStr); + break; + case CELLTYPE_FORMULA : + if (!((ScFormulaCell*)pCell)->IsValue()) + { + nErr = ((ScFormulaCell*)pCell)->GetErrCode(); + ((ScFormulaCell*)pCell)->GetString(aStr); + } + else + bOk = FALSE; + break; + default : + bOk = FALSE; + break; + } + if (bOk) + { + ByteString aTmp( aStr, osl_getThreadTextEncoding() ); + // In case the xub_StrLen will be longer than USHORT + // one day, and room for pad byte check. + if ( aTmp.Len() > ((USHORT)(~0)) - 2 ) + return FALSE; + // Append a 0-pad-byte if string length is not even + //! MUST be USHORT and not xub_StrLen + USHORT nStrLen = (USHORT) aTmp.Len(); + USHORT nLen = ( nStrLen + 2 ) & ~1; + + if (((ULONG)nPos + (5 * sizeof(USHORT)) + nLen) > MAXARRSIZE) + return FALSE; + *p++ = nCol; + *p++ = nRow; + *p++ = nTab; + *p++ = nErr; + *p++ = nLen; + memcpy( p, aTmp.GetBuffer(), nStrLen + 1); + nPos += 10 + nStrLen + 1; + BYTE* q = ( pCellArr + nPos ); + if( !nStrLen & 1 ) + *q++ = 0, nPos++; + p = (USHORT*) ( pCellArr + nPos ); + nCount++; + } + } + nCol++; + } + nRow++; + } + nTab++; + } + *pCount = nCount; + return TRUE; +} + + +BOOL ScInterpreter::CreateCellArr(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2, + BYTE* pCellArr) +{ + USHORT nCount = 0; + USHORT* p = (USHORT*) pCellArr; + *p++ = nCol1; + *p++ = nRow1; + *p++ = nTab1; + *p++ = nCol2; + *p++ = nRow2; + *p++ = nTab2; + USHORT* pCount = p; + *p++ = 0; + USHORT nPos = 14; + USHORT nTab = nTab1; + ScAddress aAdr; + while (nTab <= nTab2) + { + aAdr.SetTab( nTab ); + USHORT nRow = nRow1; + while (nRow <= nRow2) + { + aAdr.SetRow( nRow ); + USHORT nCol = nCol1; + while (nCol <= nCol2) + { + aAdr.SetCol( nCol ); + ScBaseCell* pCell = pDok->GetCell( aAdr ); + if (pCell) + { + USHORT nErr = 0; + USHORT nType = 0; // 0 = Zahl; 1 = String + double nVal = 0.0; + String aStr; + BOOL bOk = TRUE; + switch ( pCell->GetCellType() ) + { + case CELLTYPE_STRING : + ((ScStringCell*)pCell)->GetString(aStr); + nType = 1; + break; + case CELLTYPE_EDIT : + ((ScEditCell*)pCell)->GetString(aStr); + nType = 1; + break; + case CELLTYPE_VALUE : + nVal = GetValueCellValue( aAdr, (ScValueCell*)pCell ); + break; + case CELLTYPE_FORMULA : + nErr = ((ScFormulaCell*)pCell)->GetErrCode(); + if (((ScFormulaCell*)pCell)->IsValue()) + nVal = ((ScFormulaCell*)pCell)->GetValue(); + else + ((ScFormulaCell*)pCell)->GetString(aStr); + break; + default : + bOk = FALSE; + break; + } + if (bOk) + { + if ((nPos + (5 * sizeof(USHORT))) > MAXARRSIZE) + return FALSE; + *p++ = nCol; + *p++ = nRow; + *p++ = nTab; + *p++ = nErr; + *p++ = nType; + nPos += 10; + if (nType == 0) + { + if ((nPos + sizeof(double)) > MAXARRSIZE) + return FALSE; + memcpy( p, &nVal, sizeof(double)); + nPos += sizeof(double); + } + else + { + ByteString aTmp( aStr, osl_getThreadTextEncoding() ); + // In case the xub_StrLen will be longer than USHORT + // one day, and room for pad byte check. + if ( aTmp.Len() > ((USHORT)(~0)) - 2 ) + return FALSE; + // Append a 0-pad-byte if string length is not even + //! MUST be USHORT and not xub_StrLen + USHORT nStrLen = (USHORT) aTmp.Len(); + USHORT nLen = ( nStrLen + 2 ) & ~1; + if ( ((ULONG)nPos + 2 + nLen) > MAXARRSIZE) + return FALSE; + *p++ = nLen; + memcpy( p, aTmp.GetBuffer(), nStrLen + 1); + nPos += 2 + nStrLen + 1; + BYTE* q = ( pCellArr + nPos ); + if( !nStrLen & 1 ) + *q++ = 0, nPos++; + } + nCount++; + p = (USHORT*) ( pCellArr + nPos ); + } + } + nCol++; + } + nRow++; + } + nTab++; + } + *pCount = nCount; + return TRUE; +} + +//----------------------------------------------------------------------------- +// Stackoperationen +//----------------------------------------------------------------------------- + +// vorher wird ggf. ein Temp-Token geloescht. + + +/*N*/ void ScInterpreter::Push( ScToken& r ) +/*N*/ { +/*N*/ if ( sp >= MAXSTACK ) +/*N*/ SetError( errStackOverflow ); +/*N*/ else +/*N*/ { +/*N*/ nCurFmtType = NUMBERFORMAT_UNDEFINED; +/*N*/ r.IncRef(); +/*N*/ if( sp >= maxsp ) +/*N*/ maxsp = sp + 1; +/*N*/ else +/*N*/ pStack[ sp ]->DecRef(); +/*N*/ pStack[ sp ] = (ScToken*) &r; +/*N*/ pErrorStack[ sp ] = nGlobalError; +/*N*/ ++sp; +/*N*/ } +/*N*/ } + +// Schlichtes Wegwerfen von TOS + + +/*N*/ void ScInterpreter::Pop() +/*N*/ { +/*N*/ if( sp ) +/*N*/ sp--; +/*N*/ else +/*?*/ SetError(errUnknownStackVariable); +/*N*/ } + +// Schlichtes Wegwerfen von TOS mit Fehlercode setzen, fuer ocIsError etc. + + +void ScInterpreter::PopError() +{ + if( sp ) + { + sp--; + if ( !nGlobalError ) + nGlobalError = pErrorStack[ sp ]; + } + else + SetError(errUnknownStackVariable); +} + + +/*N*/ void ScInterpreter::PushTempToken( const ScToken& r ) +/*N*/ { +/*N*/ if ( sp >= MAXSTACK ) +/*?*/ SetError( errStackOverflow ); +/*N*/ else +/*N*/ { +/*N*/ ScToken* p = r.Clone(); +/*N*/ p->IncRef(); +/*N*/ if( sp >= maxsp ) +/*N*/ maxsp = sp + 1; +/*N*/ else +/*?*/ pStack[ sp ]->DecRef(); +/*N*/ pStack[ sp ] = p; +/*N*/ pErrorStack[ sp ] = nGlobalError; +/*N*/ ++sp; +/*N*/ } +/*N*/ } + + +//! The Token had to be allocated with `new' and must not be used after this +//! call because eventually it gets deleted in case of a errStackOverflow if +//! no RefCount was set! +/*N*/ void ScInterpreter::PushTempToken( ScToken* p ) +/*N*/ { +/*N*/ p->IncRef(); +/*N*/ if ( sp >= MAXSTACK ) +/*N*/ { +/*?*/ SetError( errStackOverflow ); +/*?*/ p->DecRef(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if( sp >= maxsp ) +/*N*/ maxsp = sp + 1; +/*N*/ else +/*N*/ pStack[ sp ]->DecRef(); +/*N*/ pStack[ sp ] = p; +/*N*/ pErrorStack[ sp ] = nGlobalError; +/*N*/ ++sp; +/*N*/ } +/*N*/ } + + +/*N*/ double ScInterpreter::PopDouble() +/*N*/ { +/*N*/ nCurFmtType = NUMBERFORMAT_NUMBER; +/*N*/ nCurFmtIndex = 0; +/*N*/ if( sp ) +/*N*/ { +/*N*/ --sp; +/*N*/ ScToken* p = pStack[ sp ]; +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp ]; +/*N*/ if( p->GetType() == svDouble ) +/*N*/ return p->GetDouble(); +/*N*/ else if( p->GetType() == svMissing ) +/*N*/ return 0.0; +/*N*/ } +/*N*/ SetError(errUnknownStackVariable); +/*N*/ return 0.0; +/*N*/ } + + +BYTE ScInterpreter::PopByte() +{ + if( sp ) + { + --sp; + ScToken* p = pStack[ sp ]; + if ( !nGlobalError ) + nGlobalError = pErrorStack[ sp ]; + if( p->GetType() == svByte ) + return p->GetByte(); + else if( p->GetType() == svMissing ) + SetError( errIllegalParameter ); + } + SetError(errUnknownStackVariable); + return 0; +} + + +/*N*/ const String& ScInterpreter::PopString() +/*N*/ { +/*N*/ nCurFmtType = NUMBERFORMAT_TEXT; +/*N*/ nCurFmtIndex = 0; +/*N*/ if( sp ) +/*N*/ { +/*N*/ --sp; +/*N*/ ScToken* p = pStack[ sp ]; +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp ]; +/*N*/ if( p->GetType() == svString ) +/*N*/ return p->GetString(); +/*N*/ else if( p->GetType() == svMissing ) +/*N*/ return EMPTY_STRING; +/*N*/ } +/*N*/ SetError(errUnknownStackVariable); +/*N*/ return EMPTY_STRING; +/*N*/ } + + +void ScInterpreter::PopSingleRef(USHORT& rCol, USHORT &rRow, USHORT& rTab) +{ + if( sp ) + { + --sp; + ScToken* p = pStack[ sp ]; + if ( !nGlobalError ) + nGlobalError = pErrorStack[ sp ]; + if( p->GetType() == svSingleRef ) + { + const SingleRefData& rRef = p->GetSingleRef(); + if ( rRef.IsColRel() ) + rCol = aPos.Col() + rRef.nRelCol; + else + rCol = rRef.nCol; + if ( rRef.IsRowRel() ) + rRow = aPos.Row() + rRef.nRelRow; + else + rRow = rRef.nRow; + if ( rRef.IsTabRel() ) + rTab = aPos.Tab() + rRef.nRelTab; + else + rTab = rRef.nTab; + if( rCol < 0 || rCol > MAXCOL || rRef.IsColDeleted() ) + SetError( errNoRef ), rCol = 0; + if( rRow < 0 || rRow > MAXROW || rRef.IsRowDeleted() ) + SetError( errNoRef ), rRow = 0; + if( rTab < 0 || rTab >= pDok->GetTableCount() || rRef.IsTabDeleted() ) + SetError( errNoRef ), rTab = 0; + if ( pDok->aTableOpList.Count() > 0 ) + ReplaceCell( rCol, rRow, rTab ); + return; + } + else if( p->GetType() == svMissing ) + SetError( errIllegalParameter ); + } + SetError(errUnknownStackVariable); +} + + +/*N*/ void ScInterpreter::PopSingleRef( ScAddress& rAdr ) +/*N*/ { +/*N*/ if( sp ) +/*N*/ { +/*N*/ --sp; +/*N*/ ScToken* p = pStack[ sp ]; +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp ]; +/*N*/ if( p->GetType() == svSingleRef ) +/*N*/ { +/*N*/ short nCol, nRow, nTab; +/*N*/ const SingleRefData& rRef = p->GetSingleRef(); +/*N*/ if ( rRef.IsColRel() ) +/*N*/ nCol = aPos.Col() + rRef.nRelCol; +/*N*/ else +/*N*/ nCol = rRef.nCol; +/*N*/ if ( rRef.IsRowRel() ) +/*N*/ nRow = aPos.Row() + rRef.nRelRow; +/*N*/ else +/*N*/ nRow = rRef.nRow; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ nTab = aPos.Tab() + rRef.nRelTab; +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if( nCol < 0 || nCol > MAXCOL || rRef.IsColDeleted() ) +/*N*/ SetError( errNoRef ), nCol = 0; +/*N*/ if( nRow < 0 || nRow > MAXROW || rRef.IsRowDeleted() ) +/*N*/ SetError( errNoRef ), nRow = 0; +/*N*/ if( nTab < 0 || nTab >= pDok->GetTableCount() || rRef.IsTabDeleted() ) +/*N*/ SetError( errNoRef ), nTab = 0; +/*N*/ rAdr.Set( (USHORT)nCol, (USHORT)nRow, (USHORT)nTab ); +/*N*/ if ( pDok->aTableOpList.Count() > 0 ) +/*?*/ ReplaceCell( rAdr ); +/*N*/ return; +/*N*/ } +/*N*/ else if( p->GetType() == svMissing ) +/*N*/ SetError( errIllegalParameter ); +/*N*/ } +/*N*/ SetError(errUnknownStackVariable); +/*N*/ } + + +/*N*/ void ScInterpreter::PopDoubleRef(USHORT& rCol1, USHORT &rRow1, USHORT& rTab1, +/*N*/ USHORT& rCol2, USHORT &rRow2, USHORT& rTab2, +/*N*/ BOOL bDontCheckForTableOp ) +/*N*/ { +/*N*/ if( sp ) +/*N*/ { +/*N*/ --sp; +/*N*/ ScToken* p = pStack[ sp ]; +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp ]; +/*N*/ if( p->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ const ComplRefData& rCRef = p->GetDoubleRef(); +/*N*/ USHORT nMaxTab = pDok->GetTableCount(); +/*N*/ { +/*N*/ const SingleRefData& rRef = rCRef.Ref1; +/*N*/ if ( rRef.IsColRel() ) +/*N*/ rCol1 = aPos.Col() + rRef.nRelCol; +/*N*/ else +/*N*/ rCol1 = rRef.nCol; +/*N*/ if ( rRef.IsRowRel() ) +/*N*/ rRow1 = aPos.Row() + rRef.nRelRow; +/*N*/ else +/*N*/ rRow1 = rRef.nRow; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ rTab1 = aPos.Tab() + rRef.nRelTab; +/*N*/ else +/*N*/ rTab1 = rRef.nTab; +/*N*/ if( rCol1 < 0 || rCol1 > MAXCOL || rRef.IsColDeleted() ) +/*N*/ SetError( errNoRef ), rCol1 = 0; +/*N*/ if( rRow1 < 0 || rRow1 > MAXROW || rRef.IsRowDeleted() ) +/*N*/ SetError( errNoRef ), rRow1 = 0; +/*N*/ if( rTab1 < 0 || rTab1 >= nMaxTab || rRef.IsTabDeleted() ) +/*N*/ SetError( errNoRef ), rTab1 = 0; +/*N*/ } +/*N*/ { +/*N*/ const SingleRefData& rRef = rCRef.Ref2; +/*N*/ if ( rRef.IsColRel() ) +/*N*/ rCol2 = aPos.Col() + rRef.nRelCol; +/*N*/ else +/*N*/ rCol2 = rRef.nCol; +/*N*/ if ( rRef.IsRowRel() ) +/*N*/ rRow2 = aPos.Row() + rRef.nRelRow; +/*N*/ else +/*N*/ rRow2 = rRef.nRow; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ rTab2 = aPos.Tab() + rRef.nRelTab; +/*N*/ else +/*N*/ rTab2 = rRef.nTab; +/*N*/ if( rCol2 < 0 || rCol2 > MAXCOL || rRef.IsColDeleted() ) +/*N*/ SetError( errNoRef ), rCol2 = 0; +/*N*/ if( rRow2 < 0 || rRow2 > MAXROW || rRef.IsRowDeleted() ) +/*N*/ SetError( errNoRef ), rRow2 = 0; +/*N*/ if( rTab2 < 0 || rTab2 >= nMaxTab || rRef.IsTabDeleted() ) +/*N*/ SetError( errNoRef ), rTab2 = 0; +/*N*/ } +/*N*/ if ( pDok->aTableOpList.Count() > 0 && !bDontCheckForTableOp ) +/*N*/ { +/*?*/ ScRange aRange( rCol1, rRow1, rTab1, rCol2, rRow2, rTab2 ); +/*?*/ if ( IsTableOpInRange( aRange ) ) +/*?*/ SetError( errIllegalParameter ); +/*N*/ } +/*N*/ return; +/*N*/ } +/*N*/ else if( p->GetType() == svMissing ) +/*N*/ SetError( errIllegalParameter ); +/*N*/ } +/*N*/ SetError(errUnknownStackVariable); +/*N*/ } + + +/*N*/ void ScInterpreter::PopDoubleRef( ScRange& rRange, BOOL bDontCheckForTableOp ) +/*N*/ { +/*N*/ if( sp ) +/*N*/ { +/*N*/ --sp; +/*N*/ ScToken* p = pStack[ sp ]; +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp ]; +/*N*/ if( p->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ const ComplRefData& rCRef = p->GetDoubleRef(); +/*N*/ short nCol, nRow, nTab; +/*N*/ USHORT nMaxTab = pDok->GetTableCount(); +/*N*/ { +/*N*/ const SingleRefData& rRef = rCRef.Ref1; +/*N*/ if ( rRef.IsColRel() ) +/*N*/ nCol = aPos.Col() + rRef.nRelCol; +/*N*/ else +/*N*/ nCol = rRef.nCol; +/*N*/ if ( rRef.IsRowRel() ) +/*N*/ nRow = aPos.Row() + rRef.nRelRow; +/*N*/ else +/*N*/ nRow = rRef.nRow; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ nTab = aPos.Tab() + rRef.nRelTab; +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if( nCol < 0 || nCol > MAXCOL || rRef.IsColDeleted() ) +/*N*/ SetError( errNoRef ), nCol = 0; +/*N*/ if( nRow < 0 || nRow > MAXROW || rRef.IsRowDeleted() ) +/*N*/ SetError( errNoRef ), nRow = 0; +/*N*/ if( nTab < 0 || nTab >= nMaxTab || rRef.IsTabDeleted() ) +/*N*/ SetError( errNoRef ), nTab = 0; +/*N*/ rRange.aStart.Set( (USHORT)nCol, (USHORT)nRow, (USHORT)nTab ); +/*N*/ } +/*N*/ { +/*N*/ const SingleRefData& rRef = rCRef.Ref2; +/*N*/ if ( rRef.IsColRel() ) +/*N*/ nCol = aPos.Col() + rRef.nRelCol; +/*N*/ else +/*N*/ nCol = rRef.nCol; +/*N*/ if ( rRef.IsRowRel() ) +/*N*/ nRow = aPos.Row() + rRef.nRelRow; +/*N*/ else +/*N*/ nRow = rRef.nRow; +/*N*/ if ( rRef.IsTabRel() ) +/*N*/ nTab = aPos.Tab() + rRef.nRelTab; +/*N*/ else +/*N*/ nTab = rRef.nTab; +/*N*/ if( nCol < 0 || nCol > MAXCOL || rRef.IsColDeleted() ) +/*N*/ SetError( errNoRef ), nCol = 0; +/*N*/ if( nRow < 0 || nRow > MAXROW || rRef.IsRowDeleted() ) +/*N*/ SetError( errNoRef ), nRow = 0; +/*N*/ if( nTab < 0 || nTab >= nMaxTab || rRef.IsTabDeleted() ) +/*N*/ SetError( errNoRef ), nTab = 0; +/*N*/ rRange.aEnd.Set( (USHORT)nCol, (USHORT)nRow, (USHORT)nTab ); +/*N*/ } +/*N*/ if ( pDok->aTableOpList.Count() > 0 && !bDontCheckForTableOp ) +/*N*/ { +/*?*/ if ( IsTableOpInRange( rRange ) ) +/*?*/ SetError( errIllegalParameter ); +/*N*/ } +/*N*/ return; +/*N*/ } +/*?*/ else if( p->GetType() == svMissing ) +/*?*/ SetError( errIllegalParameter ); +/*?*/ } +/*?*/ SetError(errUnknownStackVariable); +/*N*/ } + + +BOOL ScInterpreter::PopDoubleRefOrSingleRef( ScAddress& rAdr ) +{ + switch ( GetStackType() ) + { + case svDoubleRef : + { + ScRange aRange; + PopDoubleRef( aRange, TRUE ); + return DoubleRefToPosSingleRef( aRange, rAdr ); + } + //break; + case svSingleRef : + { + PopSingleRef( rAdr ); + return TRUE; + } + //break; + default: + Pop(); + SetError( errNoRef ); + } + return FALSE; +} + + +/*N*/ void ScInterpreter::PopDoubleRefPushMatrix() +/*N*/ { +/*N*/ if ( GetStackType() == svDoubleRef ) +/*N*/ { +/*N*/ USHORT nMatInd; +/*N*/ ScMatrix* pMat = GetMatrix( nMatInd ); +/*N*/ if ( pMat ) +/*N*/ { +/*N*/ PushMatrix( pMat ); +/*N*/ nRetMat = nMatInd; +/*N*/ } +/*N*/ else +/*?*/ SetIllegalParameter(); +/*N*/ } +/*N*/ else +/*N*/ SetError( errNoRef ); +/*N*/ } + + +/*N*/ ScMatrix* ScInterpreter::PopMatrix() +/*N*/ { +/*N*/ if( sp ) +/*N*/ { +/*N*/ --sp; +/*N*/ ScToken* p = pStack[ sp ]; +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp ]; +/*N*/ if( p->GetType() == svMatrix ) +/*N*/ return p->GetMatrix(); +/*N*/ else if( p->GetType() == svMissing ) +/*N*/ SetError( errIllegalParameter ); +/*N*/ } +/*N*/ SetError(errUnknownVariable); +/*N*/ return NULL; +/*N*/ } + + + +/*N*/ void ScInterpreter::PushDouble(double nVal) +/*N*/ { +/*N*/ if (!::rtl::math::isFinite(nVal)) +/*N*/ { +/*N*/ if ( ::rtl::math::isNan( nVal ) ) +/*N*/ SetError(errNoValue); +/*N*/ else +/*N*/ SetError(errIllegalFPOperation); +/*N*/ nVal = 0.0; +/*N*/ } +/*N*/ PushTempToken( new ScDoubleToken( nVal ) ); +/*N*/ } + + +/*N*/ void ScInterpreter::PushInt(int nVal) +/*N*/ { +/*N*/ PushTempToken( new ScDoubleToken( nVal ) ); +/*N*/ } + + +void ScInterpreter::PushStringBuffer( const sal_Unicode* pString ) +{ + if ( pString ) + PushString( String( pString ) ); + else + PushString( EMPTY_STRING ); +} + + +/*N*/ void ScInterpreter::PushString( const String& rString ) +/*N*/ { +/*N*/ PushTempToken( new ScStringToken( rString ) ); +/*N*/ } + + +void ScInterpreter::PushSingleRef(USHORT nCol, USHORT nRow, USHORT nTab) +{ + SingleRefData aRef; + aRef.InitFlags(); + aRef.nCol = nCol; + aRef.nRow = nRow; + aRef.nTab = nTab; + PushTempToken( new ScSingleRefToken( aRef ) ); +} + + +void ScInterpreter::PushDoubleRef(USHORT nCol1, USHORT nRow1, USHORT nTab1, + USHORT nCol2, USHORT nRow2, USHORT nTab2) +{ + ComplRefData aRef; + aRef.InitFlags(); + aRef.Ref1.nCol = nCol1; + aRef.Ref1.nRow = nRow1; + aRef.Ref1.nTab = nTab1; + aRef.Ref2.nCol = nCol2; + aRef.Ref2.nRow = nRow2; + aRef.Ref2.nTab = nTab2; + PushTempToken( new ScDoubleRefToken( aRef ) ); +} + + +/*N*/ void ScInterpreter::PushMatrix(ScMatrix* pMat) +/*N*/ { +/*N*/ PushTempToken( new ScMatrixToken( pMat ) ); +/*N*/ } + + +void ScInterpreter::SetParameterExpected() +{ + SetError(errParameterExpected); + PushInt(0); +} + + +void ScInterpreter::SetIllegalParameter() +{ + SetError(errIllegalParameter); + PushInt(0); +} + + +/*N*/ void ScInterpreter::SetIllegalArgument() +/*N*/ { +/*N*/ SetError(errIllegalArgument); +/*N*/ PushInt(0); +/*N*/ } + + +void ScInterpreter::SetNV() +{ + SetError(NOVALUE); + PushInt(0); +} + + +/*N*/ void ScInterpreter::SetNoValue() +/*N*/ { +/*N*/ SetError(errNoValue); +/*N*/ PushInt(0); +/*N*/ } + + +/*N*/ StackVar ScInterpreter::GetStackType() +/*N*/ { +/*N*/ StackVar eRes; +/*N*/ if( sp ) +/*N*/ { +/*N*/ eRes = pStack[sp - 1]->GetType(); +/*N*/ if( eRes == svMissing ) +/*N*/ eRes = svDouble; // default! +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SetError(errUnknownStackVariable); +/*N*/ eRes = svErr; +/*N*/ } +/*N*/ return eRes; +/*N*/ } + + +/*N*/ StackVar ScInterpreter::GetStackType( BYTE nParam ) +/*N*/ { +/*N*/ StackVar eRes; +/*N*/ if( sp > nParam-1 ) +/*N*/ { +/*N*/ eRes = pStack[sp - nParam]->GetType(); +/*N*/ if( eRes == svMissing ) +/*N*/ eRes = svDouble; // default! +/*N*/ } +/*N*/ else +/*N*/ eRes = svErr; +/*N*/ return eRes; +/*N*/ } + + +BOOL ScInterpreter::DoubleRefToPosSingleRef( const ScRange& rRange, ScAddress& rAdr ) +{ + USHORT nMyCol = aPos.Col(); + USHORT nMyRow = aPos.Row(); + USHORT nMyTab = aPos.Tab(); + USHORT nCol, nRow, nTab; + nTab = rRange.aStart.Tab(); + BOOL bOk = FALSE; + if ( rRange.aStart.Col() <= nMyCol && nMyCol <= rRange.aEnd.Col() ) + { + nRow = rRange.aStart.Row(); + if ( nRow == rRange.aEnd.Row() ) + { + bOk = TRUE; + nCol = nMyCol; + } + else if ( nTab != nMyTab && nTab == rRange.aEnd.Tab() + && rRange.aStart.Row() <= nMyRow && nMyRow <= rRange.aEnd.Row() ) + { + bOk = TRUE; + nCol = nMyCol; + nRow = nMyRow; + } + } + else if ( rRange.aStart.Row() <= nMyRow && nMyRow <= rRange.aEnd.Row() ) + { + nCol = rRange.aStart.Col(); + if ( nCol == rRange.aEnd.Col() ) + { + bOk = TRUE; + nRow = nMyRow; + } + else if ( nTab != nMyTab && nTab == rRange.aEnd.Tab() + && rRange.aStart.Col() <= nMyCol && nMyCol <= rRange.aEnd.Col() ) + { + bOk = TRUE; + nCol = nMyCol; + nRow = nMyRow; + } + } + if ( bOk ) + { + if ( nTab == rRange.aEnd.Tab() ) + ; // all done + else if ( nTab <= nMyTab && nMyTab <= rRange.aEnd.Tab() ) + nTab = nMyTab; + else + bOk = FALSE; + if ( bOk ) + rAdr.Set( nCol, nRow, nTab ); + } + if ( !bOk ) + SetError( errNoValue ); + return bOk; +} + + +/*N*/ double ScInterpreter::GetDouble() +/*N*/ { +/*N*/ double nVal; +/*N*/ switch( GetStackType() ) +/*N*/ { +/*N*/ case svDouble: +/*N*/ nVal = PopDouble(); break; +/*N*/ case svString: +/*N*/ { +/*N*/ String aStr(PopString()); +/*N*/ sal_uInt32 nFIndex = 0; // damit default Land/Spr. +/*N*/ if(!pFormatter->IsNumberFormat( aStr, nFIndex, nVal ) ) +/*N*/ { +/*N*/ SetError(errIllegalArgument); +/*N*/ nVal = 0.0; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svSingleRef: +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ PopSingleRef( aAdr ); +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ nVal = GetCellValue( aAdr, pCell ); +/*N*/ } +/*N*/ break; +/*?*/ case svDoubleRef: +/*?*/ { // positionsabhaengige SingleRef generieren +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ ScAddress aAdr; +/*?*/ if ( !nGlobalError && DoubleRefToPosSingleRef( aRange, aAdr ) ) +/*?*/ { +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ nVal = GetCellValue( aAdr, pCell ); +/*?*/ } +/*?*/ else +/*?*/ nVal = 0.0; +/*?*/ } +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ nVal = 0.0; +/*N*/ } +/*N*/ if ( nFuncFmtType == nCurFmtType ) +/*N*/ nFuncFmtIndex = nCurFmtIndex; +/*N*/ return nVal; +/*N*/ } + + +/*N*/ const String& ScInterpreter::GetString() +/*N*/ { +/*N*/ StackVar eRes = (StackVar) GetStackType(); +/*N*/ if( eRes == svDouble && pStack[ sp-1 ]->GetType() == svMissing ) +/*N*/ eRes = svString; +/*N*/ switch( eRes ) +/*N*/ { +/*?*/ case svDouble: +/*?*/ { +/*?*/ double fVal = PopDouble(); +/*?*/ ULONG nIndex = pFormatter->GetStandardFormat( +/*?*/ NUMBERFORMAT_NUMBER, +/*?*/ ScGlobal::eLnge); +/*?*/ pFormatter->GetInputLineString(fVal, nIndex, aTempStr); +/*?*/ return aTempStr; +/*?*/ } +/*?*/ //break; +/*N*/ case svString: +/*N*/ return PopString(); +/*N*/ //break; +/*N*/ case svSingleRef: +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ PopSingleRef( aAdr ); +/*N*/ if (nGlobalError == 0) +/*N*/ { +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ GetCellString( aTempStr, pCell ); +/*N*/ return aTempStr; +/*N*/ } +/*N*/ else +/*N*/ return EMPTY_STRING; +/*N*/ } +/*N*/ //break; +/*?*/ case svDoubleRef: +/*?*/ { // positionsabhaengige SingleRef generieren +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ ScAddress aAdr; +/*?*/ if ( !nGlobalError && DoubleRefToPosSingleRef( aRange, aAdr ) ) +/*?*/ { +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ GetCellString( aTempStr, pCell ); +/*?*/ return aTempStr; +/*?*/ } +/*?*/ else +/*?*/ return EMPTY_STRING; +/*?*/ } +/*?*/ //break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*N*/ } +/*N*/ return EMPTY_STRING; +/*N*/ } + + +/*N*/ void ScInterpreter::ScDBGet() +/*N*/ { +/*N*/ USHORT nTab; +/*N*/ ScQueryParam aQueryParam; +/*N*/ BOOL bMissingField = FALSE; +/*N*/ if (GetDBParams( nTab, aQueryParam, bMissingField)) +/*N*/ { +/*N*/ ScBaseCell* pCell; +/*N*/ ScQueryCellIterator aCellIter(pDok, nTab, aQueryParam); +/*N*/ if (pCell = aCellIter.GetFirst()) +/*N*/ { +/*N*/ if (aCellIter.GetNext()) +/*N*/ SetIllegalArgument(); +/*N*/ else +/*N*/ { +/*N*/ switch (pCell->GetCellType()) +/*N*/ { +/*N*/ case CELLTYPE_VALUE: +/*N*/ { +/*N*/ double rValue = ((ScValueCell*)pCell)->GetValue(); +/*N*/ if ( bCalcAsShown ) +/*N*/ { +/*N*/ ULONG nFormat; +/*N*/ nFormat = aCellIter.GetNumberFormat(); +/*N*/ rValue = pDok->RoundValueAsShown( rValue, nFormat ); +/*N*/ } +/*N*/ PushDouble(rValue); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_STRING: +/*N*/ { +/*N*/ String rString; +/*N*/ ((ScStringCell*)pCell)->GetString(rString); +/*N*/ PushString(rString); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_EDIT: +/*N*/ { +/*N*/ String rString; +/*N*/ ((ScEditCell*)pCell)->GetString(rString); +/*N*/ PushString(rString); +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_FORMULA: +/*N*/ { +/*N*/ USHORT rErr = ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ if (rErr) +/*N*/ { +/*N*/ SetError(rErr); +/*N*/ PushInt(0); +/*N*/ } +/*N*/ else if (((ScFormulaCell*)pCell)->IsValue()) +/*N*/ { +/*N*/ double rValue = ((ScFormulaCell*)pCell)->GetValue(); +/*N*/ PushDouble(rValue); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ String rString; +/*N*/ ((ScFormulaCell*)pCell)->GetString(rString); +/*N*/ PushString(rString); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case CELLTYPE_NONE: +/*N*/ case CELLTYPE_NOTE: +/*N*/ default: +/*N*/ SetIllegalArgument(); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*N*/ SetIllegalParameter(); +/*N*/ } + + +/*N*/ void ScInterpreter::ScExternal() +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ String aUnoName; +/*N*/ String aFuncName( ScGlobal::pCharClass->upper( pCur->GetExternal() ) ); +/*N*/ if (ScGlobal::GetFuncCollection()->SearchFunc(aFuncName, nIndex)) +/*N*/ { +/*?*/ FuncData* pFuncData = (FuncData*)ScGlobal::GetFuncCollection()->At(nIndex); +/*?*/ if (nParamCount == pFuncData->GetParamCount() - 1) +/*?*/ { +/*?*/ ParamType eParamType[MAXFUNCPARAM]; +/*?*/ void* ppParam[MAXFUNCPARAM]; +/*?*/ double nVal[MAXFUNCPARAM]; +/*?*/ sal_Char* pStr[MAXFUNCPARAM]; +/*?*/ BYTE* pCellArr[MAXFUNCPARAM]; +/*?*/ short i; +/*?*/ +/*?*/ for (i = 0; i < MAXFUNCPARAM; i++) +/*?*/ { +/*?*/ eParamType[i] = pFuncData->GetParamType(i); +/*?*/ ppParam[i] = NULL; +/*?*/ nVal[i] = 0.0; +/*?*/ pStr[i] = NULL; +/*?*/ pCellArr[i] = NULL; +/*?*/ } +/*?*/ +/*?*/ for (i = nParamCount; (i > 0) && (nGlobalError == 0); i--) +/*?*/ { +/*?*/ BYTE nStackType = GetStackType(); +/*?*/ switch (eParamType[i]) +/*?*/ { +/*?*/ case PTR_DOUBLE : +/*?*/ { +/*?*/ nVal[i-1] = GetDouble(); +/*?*/ ppParam[i] = &nVal[i-1]; +/*?*/ } +/*?*/ break; +/*?*/ case PTR_STRING : +/*?*/ { +/*?*/ ByteString aStr( GetString(), osl_getThreadTextEncoding() ); +/*?*/ if ( aStr.Len() >= MAXSTRLEN ) +/*?*/ SetError( errStringOverflow ); +/*?*/ else +/*?*/ { +/*?*/ pStr[i-1] = new sal_Char[MAXSTRLEN]; +/*?*/ strncpy( pStr[i-1], aStr.GetBuffer(), MAXSTRLEN ); +/*?*/ pStr[i-1][MAXSTRLEN-1] = 0; +/*?*/ ppParam[i] = pStr[i-1]; +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case PTR_DOUBLE_ARR : +/*?*/ { +/*?*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*?*/ PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +/*?*/ pCellArr[i-1] = new BYTE[MAXARRSIZE]; +/*?*/ if (!CreateDoubleArr(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, pCellArr[i-1])) +/*?*/ SetError(errCodeOverflow); +/*?*/ else +/*?*/ ppParam[i] = pCellArr[i-1]; +/*?*/ } +/*?*/ break; +/*?*/ case PTR_STRING_ARR : +/*?*/ { +/*?*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*?*/ PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +/*?*/ pCellArr[i-1] = new BYTE[MAXARRSIZE]; +/*?*/ if (!CreateStringArr(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, pCellArr[i-1])) +/*?*/ SetError(errCodeOverflow); +/*?*/ else +/*?*/ ppParam[i] = pCellArr[i-1]; +/*?*/ } +/*?*/ break; +/*?*/ case PTR_CELL_ARR : +/*?*/ { +/*?*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*?*/ PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +/*?*/ pCellArr[i-1] = new BYTE[MAXARRSIZE]; +/*?*/ if (!CreateCellArr(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, pCellArr[i-1])) +/*?*/ SetError(errCodeOverflow); +/*?*/ else +/*?*/ ppParam[i] = pCellArr[i-1]; +/*?*/ } +/*?*/ break; +/*?*/ default : +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ while ( i-- ) +/*?*/ Pop(); // im Fehlerfall (sonst ist i==0) Parameter wegpoppen +/*?*/ +/*?*/ if (nGlobalError == 0) +/*?*/ { +/*?*/ if ( pFuncData->GetAsyncType() == NONE ) +/*?*/ { +/*?*/ switch ( eParamType[0] ) +/*?*/ { +/*?*/ case PTR_DOUBLE : +/*?*/ { +/*?*/ double nErg = 0.0; +/*?*/ ppParam[0] = &nErg; +/*?*/ pFuncData->Call(ppParam); +/*?*/ PushDouble(nErg); +/*?*/ } +/*?*/ break; +/*?*/ case PTR_STRING : +/*?*/ { +/*?*/ sal_Char* pcErg = new sal_Char[MAXSTRLEN]; +/*?*/ ppParam[0] = pcErg; +/*?*/ pFuncData->Call(ppParam); +/*?*/ String aUni( pcErg, osl_getThreadTextEncoding() ); +/*?*/ PushString( aUni ); +/*?*/ delete[] pcErg; +/*?*/ } +/*?*/ break; +/*?*/ default: +/*?*/ SetError( errUnknownState ); +/*?*/ PushInt(0); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ // nach dem Laden Asyncs wieder anwerfen +/*?*/ if ( pMyFormulaCell->GetCode()->IsRecalcModeNormal() ) +/*?*/ pMyFormulaCell->GetCode()->SetRecalcModeOnLoad(); +/*?*/ // garantiert identischer Handle bei identischem Aufruf?!? +/*?*/ // sonst schei*e ... +/*?*/ double nErg = 0.0; +/*?*/ ppParam[0] = &nErg; +/*?*/ pFuncData->Call(ppParam); +/*?*/ ULONG nHandle = ULONG( nErg ); +/*?*/ if ( nHandle >= 65536 ) +/*?*/ { +/*?*/ ScAddInAsync* pAs = ScAddInAsync::Get( nHandle ); +/*?*/ if ( !pAs ) +/*?*/ { +/*?*/ pAs = new ScAddInAsync( nHandle, nIndex, pDok ); +/*?*/ pMyFormulaCell->StartListening( *pAs, TRUE ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ // falls per cut/copy/paste +/*?*/ if ( !pMyFormulaCell->IsListening( *pAs ) ) +/*?*/ pMyFormulaCell->StartListening( *pAs, TRUE ); +/*?*/ // in anderes Dokument? +/*?*/ if ( !pAs->HasDocument( pDok ) ) +/*?*/ pAs->AddDocument( pDok ); +/*?*/ } +/*?*/ if ( pAs->IsValid() ) +/*?*/ { +/*?*/ switch ( pAs->GetType() ) +/*?*/ { +/*?*/ case PTR_DOUBLE : +/*?*/ PushDouble( pAs->GetValue() ); +/*?*/ break; +/*?*/ case PTR_STRING : +/*?*/ PushString( pAs->GetString() ); +/*?*/ break; +/*?*/ default: +/*?*/ SetError( errUnknownState ); +/*?*/ PushInt(0); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ SetNV(); +/*?*/ } +/*?*/ else +/*?*/ SetNoValue(); +/*?*/ } +/*?*/ } +/*?*/ +/*?*/ for (i = 0; i < MAXFUNCPARAM; i++) +/*?*/ { +/*?*/ delete[] pStr[i]; +/*?*/ delete[] pCellArr[i]; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ while( nParamCount-- ) +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ PushInt(0); +/*?*/ } +/*N*/ } +/*N*/ else if ( ( aUnoName = ScGlobal::GetAddInCollection()->FindFunction(aFuncName, FALSE) ).Len() ) +/*N*/ { +/*N*/ // bLocalFirst=FALSE in FindFunction, cFunc should be the stored internal name +/*N*/ +/*N*/ ScUnoAddInCall aCall( *ScGlobal::GetAddInCollection(), aUnoName, nParamCount ); +/*N*/ +/*N*/ if ( !aCall.ValidParamCount() ) +/*N*/ SetError( errIllegalParameter ); +/*N*/ +/*N*/ if ( aCall.NeedsCaller() && !GetError() ) +/*N*/ { +/*N*/ SfxObjectShell* pShell = pDok->GetDocumentShell(); +/*N*/ if (pShell) +/*N*/ aCall.SetCallerFromObjectShell( pShell ); +/*N*/ else +/*N*/ { +/*?*/ // use temporary model object (without document) to supply options +/*?*/ aCall.SetCaller( static_cast<beans::XPropertySet*>( +/*?*/ new ScDocOptionsObj( pDok->GetDocOptions() ) ) ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ short nPar = nParamCount; +/*N*/ while ( nPar && !GetError() ) +/*N*/ { +/*N*/ --nPar; // 0 .. (nParamCount-1) +/*N*/ +/*N*/ ScAddInArgumentType eType = aCall.GetArgType( nPar ); +/*N*/ BYTE nStackType = GetStackType(); +/*N*/ +/*N*/ uno::Any aParam; +/*N*/ switch (eType) +/*N*/ { +/*N*/ case SC_ADDINARG_INTEGER: +/*N*/ { +/*N*/ double fVal = GetDouble(); +/*N*/ double fInt = (fVal >= 0.0) ? ::rtl::math::approxFloor( fVal ) : +/*N*/ ::rtl::math::approxCeil( fVal ); +/*N*/ if ( fInt >= LONG_MIN && fInt <= LONG_MAX ) +/*N*/ aParam <<= (INT32)fInt; +/*N*/ else +/*N*/ SetError(errIllegalArgument); +/*N*/ } +/*N*/ break; +/*N*/ +/*?*/ case SC_ADDINARG_DOUBLE: +/*?*/ aParam <<= (double) GetDouble(); +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_STRING: +/*?*/ aParam <<= ::rtl::OUString( GetString() ); +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_INTEGER_ARRAY: +/*?*/ switch( nStackType ) +/*?*/ { +/*?*/ case svDouble: +/*?*/ case svString: +/*?*/ case svSingleRef: +/*?*/ { +/*?*/ double fVal = GetDouble(); +/*?*/ double fInt = (fVal >= 0.0) ? ::rtl::math::approxFloor( fVal ) : +/*?*/ ::rtl::math::approxCeil( fVal ); +/*?*/ if ( fInt >= LONG_MIN && fInt <= LONG_MAX ) +/*?*/ { +/*?*/ INT32 nIntVal = (long)fInt; +/*?*/ uno::Sequence<INT32> aInner( &nIntVal, 1 ); +/*?*/ uno::Sequence< uno::Sequence<INT32> > aOuter( &aInner, 1 ); +/*?*/ aParam <<= aOuter; +/*?*/ } +/*?*/ else +/*?*/ SetError(errIllegalArgument); +/*?*/ } +/*?*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ if (!ScRangeToSequence::FillLongArray( aParam, pDok, aRange )) +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ case svMatrix: +/*?*/ if (!ScRangeToSequence::FillLongArray( aParam, PopMatrix() )) +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_DOUBLE_ARRAY: +/*?*/ switch( nStackType ) +/*?*/ { +/*?*/ case svDouble: +/*?*/ case svString: +/*?*/ case svSingleRef: +/*?*/ { +/*?*/ double fVal = GetDouble(); +/*?*/ uno::Sequence<double> aInner( &fVal, 1 ); +/*?*/ uno::Sequence< uno::Sequence<double> > aOuter( &aInner, 1 ); +/*?*/ aParam <<= aOuter; +/*?*/ } +/*?*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ if (!ScRangeToSequence::FillDoubleArray( aParam, pDok, aRange )) +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ case svMatrix: +/*?*/ if (!ScRangeToSequence::FillDoubleArray( aParam, PopMatrix() )) +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_STRING_ARRAY: +/*?*/ switch( nStackType ) +/*?*/ { +/*?*/ case svDouble: +/*?*/ case svString: +/*?*/ case svSingleRef: +/*?*/ { +/*?*/ ::rtl::OUString aString = ::rtl::OUString( GetString() ); +/*?*/ uno::Sequence<rtl::OUString> aInner( &aString, 1 ); +/*?*/ uno::Sequence< uno::Sequence<rtl::OUString> > aOuter( &aInner, 1 ); +/*?*/ aParam <<= aOuter; +/*?*/ } +/*?*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ if (!ScRangeToSequence::FillStringArray( aParam, pDok, aRange )) +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ case svMatrix: +/*?*/ if (!ScRangeToSequence::FillStringArray( aParam, PopMatrix(), pFormatter )) +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_MIXED_ARRAY: +/*?*/ switch( nStackType ) +/*?*/ { +/*?*/ case svDouble: +/*?*/ case svString: +/*?*/ case svSingleRef: +/*?*/ { +/*?*/ uno::Any aElem; +/*?*/ if ( nStackType == svDouble ) +/*?*/ aElem <<= (double) GetDouble(); +/*?*/ else if ( nStackType == svString ) +/*?*/ aElem <<= ::rtl::OUString( GetString() ); +/*?*/ else +/*?*/ { +/*?*/ ScAddress aAdr; +/*?*/ if ( PopDoubleRefOrSingleRef( aAdr ) ) +/*?*/ { +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ if ( pCell && pCell->HasStringData() ) +/*?*/ { +/*?*/ String aStr; +/*?*/ GetCellString( aStr, pCell ); +/*?*/ aElem <<= ::rtl::OUString( aStr ); +/*?*/ } +/*?*/ else +/*?*/ aElem <<= (double) GetCellValue( aAdr, pCell ); +/*?*/ } +/*?*/ } +/*?*/ uno::Sequence<uno::Any> aInner( &aElem, 1 ); +/*?*/ uno::Sequence< uno::Sequence<uno::Any> > aOuter( &aInner, 1 ); +/*?*/ aParam <<= aOuter; +/*?*/ } +/*?*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ if (!ScRangeToSequence::FillMixedArray( aParam, pDok, aRange )) +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ case svMatrix: +/*?*/ if (!ScRangeToSequence::FillMixedArray( aParam, PopMatrix() )) +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_VALUE_OR_ARRAY: +/*?*/ switch( nStackType ) +/*?*/ { +/*?*/ case svDouble: +/*?*/ aParam <<= (double) GetDouble(); +/*?*/ break; +/*?*/ case svString: +/*?*/ aParam <<= ::rtl::OUString( GetString() ); +/*?*/ break; +/*?*/ case svSingleRef: +/*?*/ { +/*?*/ ScAddress aAdr; +/*?*/ if ( PopDoubleRefOrSingleRef( aAdr ) ) +/*?*/ { +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ if ( pCell && pCell->HasStringData() ) +/*?*/ { +/*?*/ String aStr; +/*?*/ GetCellString( aStr, pCell ); +/*?*/ aParam <<= ::rtl::OUString( aStr ); +/*?*/ } +/*?*/ else +/*?*/ aParam <<= (double) GetCellValue( aAdr, pCell ); +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ if (!ScRangeToSequence::FillMixedArray( aParam, pDok, aRange )) +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ case svMatrix: +/*?*/ if (!ScRangeToSequence::FillMixedArray( aParam, PopMatrix() )) +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ +/*?*/ case SC_ADDINARG_CELLRANGE: +/*?*/ switch( nStackType ) +/*?*/ { +/*?*/ case svSingleRef: +/*?*/ { +/*?*/ ScAddress aAdr; +/*?*/ PopSingleRef( aAdr ); +/*?*/ ScRange aRange( aAdr ); +/*?*/ uno::Reference<table::XCellRange> xObj = +/*?*/ ScCellRangeObj::CreateRangeFromDoc( pDok, aRange ); +/*?*/ if (xObj.is()) +/*?*/ aParam <<= xObj; +/*?*/ else +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ uno::Reference<table::XCellRange> xObj = +/*?*/ ScCellRangeObj::CreateRangeFromDoc( pDok, aRange ); +/*?*/ if (xObj.is()) +/*?*/ aParam <<= xObj; +/*?*/ else +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*?*/ } +/*?*/ break; +/*?*/ +/*?*/ default: +/*?*/ Pop(); +/*?*/ SetError(errIllegalParameter); +/*N*/ } +/*N*/ aCall.SetParam( nPar, aParam ); +/*N*/ } +/*N*/ +/*N*/ while (nPar--) +/*?*/ Pop(); // in case of error, remove remaining args +/*N*/ +/*N*/ if ( !GetError() ) +/*N*/ { +/*N*/ aCall.ExecuteCall(); +/*N*/ +/*N*/ if ( aCall.HasVarRes() ) // handle async functions +/*N*/ { +/*?*/ if ( pMyFormulaCell->GetCode()->IsRecalcModeNormal() ) +/*?*/ pMyFormulaCell->GetCode()->SetRecalcModeOnLoad(); +/*?*/ +/*?*/ uno::Reference<sheet::XVolatileResult> xResult = aCall.GetVarRes(); +/*?*/ ScAddInListener* pLis = ScAddInListener::Get( xResult ); +/*?*/ if ( !pLis ) +/*?*/ { +/*?*/ pLis = ScAddInListener::CreateListener( xResult, pDok ); +/*?*/ pMyFormulaCell->StartListening( *pLis, TRUE ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ if ( !pMyFormulaCell->IsListening( *pLis ) ) +/*?*/ pMyFormulaCell->StartListening( *pLis, TRUE ); +/*?*/ if ( !pLis->HasDocument( pDok ) ) +/*?*/ pLis->AddDocument( pDok ); +/*?*/ } +/*?*/ +/*?*/ aCall.SetResult( pLis->GetResult() ); // use result from async +/*N*/ } +/*N*/ +/*N*/ if ( aCall.GetErrCode() ) +/*N*/ { +/*?*/ SetError( aCall.GetErrCode() ); +/*?*/ PushInt(0); +/*N*/ } +/*N*/ else if ( aCall.HasMatrix() ) +/*N*/ { +/*?*/ const ScMatrix* pLinkMat = aCall.GetMatrix(); // not NULL +/*?*/ +/*?*/ USHORT nC, nR, nMatInd; // copy matrix result +/*?*/ pLinkMat->GetDimensions(nC, nR); +/*?*/ ScMatrix* pNewMat = GetNewMat( nC, nR, nMatInd ); +/*?*/ if (pNewMat) +/*?*/ { +/*?*/ pLinkMat->MatCopy(*pNewMat); +/*?*/ PushMatrix( pNewMat ); +/*?*/ nRetMat = nMatInd; +/*?*/ } // otherwise error code has been set in GetNewMat +/*N*/ } +/*N*/ else if ( aCall.HasString() ) +/*?*/ PushString( aCall.GetString() ); +/*N*/ else +/*N*/ PushDouble( aCall.GetValue() ); +/*N*/ } +/*N*/ else // error... +/*?*/ PushInt(0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ while( nParamCount-- ) +/*N*/ Pop(); +/*N*/ SetError( errNoAddin ); +/*N*/ PushInt(0); +/*N*/ } +/*N*/ } + + +void ScInterpreter::ScMissing() +{ + PushTempToken( new ScMissingToken ); +} + + +/*N*/ void ScInterpreter::ScMacro() +/*N*/ { +/*N*/ SbxBase::ResetError(); +/*N*/ +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ String aMacro( pCur->GetExternal() ); +/*N*/ +/*N*/ SfxObjectShell* pDocSh = pDok->GetDocumentShell(); +/*N*/ if ( !pDocSh || !pDok->CheckMacroWarn() ) +/*N*/ { +/*N*/ SetError( errNoValue ); // ohne DocShell kein CallBasic +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ // keine Sicherheitsabfrage mehr vorneweg (nur CheckMacroWarn), das passiert im CallBasic +/*N*/ +/*N*/ SfxApplication* pSfxApp = SFX_APP(); +/*N*/ pSfxApp->EnterBasicCall(); // Dok-Basic anlegen etc. +/*N*/ +/*N*/ // Wenn das Dok waehrend eines Basic-Calls geladen wurde, +/*N*/ // ist das Sbx-Objekt evtl. nicht angelegt (?) +/*N*/ // pDocSh->GetSbxObject(); +/*N*/ +/*N*/ // Funktion ueber den einfachen Namen suchen, +/*N*/ // dann aBasicStr, aMacroStr fuer SfxObjectShell::CallBasic zusammenbauen +/*N*/ +/*N*/ StarBASIC* pRoot = pDocSh->GetBasic(); +/*N*/ SbxVariable* pVar = pRoot->Find( aMacro, SbxCLASS_METHOD ); +/*N*/ if( !pVar || pVar->GetType() == SbxVOID || !pVar->ISA(SbMethod) ) +/*N*/ { +/*?*/ SetError( errNoMacro ); +/*?*/ pSfxApp->LeaveBasicCall(); +/*?*/ return; +/*N*/ } +/*N*/ +/*N*/ SbMethod* pMethod = (SbMethod*)pVar; +/*N*/ SbModule* pModule = pMethod->GetModule(); +/*N*/ SbxObject* pObject = pModule->GetParent(); +/*N*/ DBG_ASSERT(pObject->IsA(TYPE(StarBASIC)), "Kein Basic gefunden!"); +/*N*/ String aMacroStr = pObject->GetName(); +/*N*/ aMacroStr += '.'; +/*N*/ aMacroStr += pModule->GetName(); +/*N*/ aMacroStr += '.'; +/*N*/ aMacroStr += pMethod->GetName(); +/*N*/ String aBasicStr; +/*N*/ if (pObject->GetParent()) +/*N*/ aBasicStr = pObject->GetParent()->GetName(); // Dokumentenbasic +/*N*/ else +/*?*/ aBasicStr = SFX_APP()->GetName(); // Applikationsbasic +/*N*/ +/*N*/ // Parameter-Array zusammenbauen +/*N*/ +/*N*/ SbxArrayRef refPar = new SbxArray; +/*N*/ BOOL bOk = TRUE; +/*N*/ for( short i = nParamCount; i && bOk ; i-- ) +/*N*/ { +/*N*/ SbxVariable* pPar = refPar->Get( (USHORT) i ); +/*N*/ BYTE nStackType = GetStackType(); +/*N*/ switch( nStackType ) +/*N*/ { +/*?*/ case svDouble: +/*?*/ pPar->PutDouble( GetDouble() ); +/*?*/ break; +/*?*/ case svString: +/*?*/ pPar->PutString( GetString() ); +/*?*/ break; +/*N*/ case svSingleRef: +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ PopSingleRef( aAdr ); +/*N*/ bOk = SetSbxVariable( pPar, aAdr ); +/*N*/ } +/*N*/ break; +/*?*/ case svDoubleRef: +/*?*/ { +/*?*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*?*/ PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*?*/ if( nTab1 != nTab2 ) +/*?*/ { +/*?*/ SetError( errIllegalParameter ); +/*?*/ bOk = FALSE; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ SbxDimArrayRef refArray = new SbxDimArray; +/*?*/ refArray->AddDim( 1, nRow2 - nRow1 + 1 ); +/*?*/ refArray->AddDim( 1, nCol2 - nCol1 + 1 ); +/*?*/ ScAddress aAdr( nCol1, nRow1, nTab1 ); +/*?*/ for( USHORT nRow = nRow1; bOk && nRow <= nRow2; nRow++ ) +/*?*/ { +/*?*/ aAdr.SetRow( nRow ); +/*?*/ short nIdx[ 2 ]; +/*?*/ nIdx[ 0 ] = nRow-nRow1+1; +/*?*/ for( USHORT nCol = nCol1; bOk && nCol <= nCol2; nCol++ ) +/*?*/ { +/*?*/ aAdr.SetCol( nCol ); +/*?*/ nIdx[ 1 ] = nCol-nCol1+1; +/*?*/ SbxVariable* p = refArray->Get( nIdx ); +/*?*/ bOk = SetSbxVariable( p, aAdr ); +/*?*/ } +/*?*/ } +/*?*/ pPar->PutObject( refArray ); +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ case svMatrix: +/*?*/ { +/*?*/ ScMatrix* pMat = PopMatrix(); +/*?*/ USHORT nC, nR; +/*?*/ if (pMat) +/*?*/ { +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ SbxDimArrayRef refArray = new SbxDimArray; +/*?*/ refArray->AddDim( 1, nR ); +/*?*/ refArray->AddDim( 1, nC ); +/*?*/ for( USHORT j = 0; j < nR; j++ ) +/*?*/ { +/*?*/ short nIdx[ 2 ]; +/*?*/ nIdx[ 0 ] = j+1; +/*?*/ for( USHORT i = 0; i < nC; i++ ) +/*?*/ { +/*?*/ nIdx[ 1 ] = i+1; +/*?*/ SbxVariable* p = refArray->Get( nIdx ); +/*?*/ if (pMat->IsString(i, j)) +/*?*/ p->PutString( pMat->GetString(i, j) ); +/*?*/ else +/*?*/ p->PutDouble( pMat->GetDouble(i, j) ); +/*?*/ } +/*?*/ } +/*?*/ pPar->PutObject( refArray ); +/*?*/ } +/*?*/ else +/*?*/ SetError( errIllegalParameter ); +/*?*/ } +/*?*/ break; +/*?*/ default: +/*N*/ SetError( errIllegalParameter ); +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ } +/*N*/ if( bOk ) +/*N*/ { +/*N*/ pDok->LockTable( aPos.Tab() ); +/*N*/ SbxVariableRef refRes = new SbxVariable; +/*N*/ pDok->IncMacroInterpretLevel(); +/*N*/ ErrCode eRet = pDocSh->CallBasic( aMacroStr, aBasicStr, NULL, refPar, refRes ); +/*N*/ pDok->DecMacroInterpretLevel(); +/*N*/ pDok->UnlockTable( aPos.Tab() ); +/*N*/ +/*N*/ SbxDataType eResType = refRes->GetType(); +/*N*/ if ( eRet != ERRCODE_NONE ) +/*N*/ SetNoValue(); +/*N*/ else if( eResType >= SbxINTEGER && eResType <= SbxDOUBLE ) +/*?*/ PushDouble( refRes->GetDouble() ); +/*N*/ else if ( eResType & SbxARRAY ) +/*N*/ { +/*?*/ SbxBase* pElemObj = refRes->GetObject(); +/*?*/ SbxDimArray* pDimArray = PTR_CAST(SbxDimArray,pElemObj); +/*?*/ short nDim = pDimArray->GetDims(); +/*?*/ if ( 1 <= nDim && nDim <= 2 ) +/*?*/ { +/*?*/ short nCs, nCe, nRs, nRe; +/*?*/ USHORT nC, nR, nMatInd; +/*?*/ USHORT nColIdx, nRowIdx; +/*?*/ if ( nDim == 1 ) +/*?*/ { // array( cols ) eine Zeile, mehrere Spalten +/*?*/ pDimArray->GetDim( 1, nCs, nCe ); +/*?*/ nC = USHORT(nCe - nCs + 1); +/*?*/ nRs = nRe = 0; +/*?*/ nR = 1; +/*?*/ nColIdx = 0; +/*?*/ nRowIdx = 1; +/*?*/ } +/*?*/ else +/*?*/ { // array( rows, cols ) +/*?*/ pDimArray->GetDim( 1, nRs, nRe ); +/*?*/ nR = USHORT(nRe - nRs + 1); +/*?*/ pDimArray->GetDim( 2, nCs, nCe ); +/*?*/ nC = USHORT(nCe - nCs + 1); +/*?*/ nColIdx = 1; +/*?*/ nRowIdx = 0; +/*?*/ } +/*?*/ ScMatrix* pMat = GetNewMat( nC, nR, nMatInd ); +/*?*/ if ( pMat ) +/*?*/ { +/*?*/ SbxVariable* pV; +/*?*/ SbxDataType eType; +/*?*/ for ( USHORT j=0; j < nR; j++ ) +/*?*/ { +/*?*/ short nIdx[ 2 ]; +/*?*/ // bei eindimensionalem array( cols ) wird nIdx[1] +/*?*/ // von SbxDimArray::Get ignoriert +/*?*/ nIdx[ nRowIdx ] = nRs + j; +/*?*/ for ( USHORT i=0; i < nC; i++ ) +/*?*/ { +/*?*/ nIdx[ nColIdx ] = nCs + i; +/*?*/ pV = pDimArray->Get( nIdx ); +/*?*/ eType = pV->GetType(); +/*?*/ if ( eType >= SbxINTEGER && eType <= SbxDOUBLE ) +/*?*/ pMat->PutDouble( pV->GetDouble(), i, j ); +/*?*/ else +/*?*/ pMat->PutString( pV->GetString(), i, j ); +/*?*/ } +/*?*/ } +/*?*/ PushMatrix( pMat ); +/*?*/ nRetMat = nMatInd; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*?*/ PushString( refRes->GetString() ); +/*N*/ if( pVar->GetError() ) +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ +/*N*/ pSfxApp->LeaveBasicCall(); +/*N*/ } + + +/*N*/ BOOL ScInterpreter::SetSbxVariable( SbxVariable* pVar, const ScAddress& rPos ) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ ScBaseCell* pCell = pDok->GetCell( rPos ); +/*N*/ if (pCell) +/*N*/ { +/*N*/ USHORT nErr; +/*N*/ double nVal; +/*N*/ switch( pCell->GetCellType() ) +/*N*/ { +/*N*/ case CELLTYPE_VALUE : +/*N*/ nVal = GetValueCellValue( rPos, (ScValueCell*)pCell ); +/*N*/ pVar->PutDouble( nVal ); +/*N*/ break; +/*N*/ case CELLTYPE_STRING : +/*N*/ { +/*N*/ String aVal; +/*N*/ ((ScStringCell*)pCell)->GetString( aVal ); +/*N*/ pVar->PutString( aVal ); +/*N*/ break; +/*N*/ } +/*?*/ case CELLTYPE_EDIT : +/*?*/ { +/*?*/ String aVal; +/*?*/ ((ScEditCell*) pCell)->GetString( aVal ); +/*?*/ pVar->PutString( aVal ); +/*?*/ break; +/*?*/ } +/*N*/ case CELLTYPE_FORMULA : +/*N*/ nErr = ((ScFormulaCell*)pCell)->GetErrCode(); +/*N*/ if( !nErr ) +/*N*/ { +/*N*/ if( ((ScFormulaCell*)pCell)->IsValue() ) +/*N*/ { +/*N*/ nVal = ((ScFormulaCell*)pCell)->GetValue(); +/*N*/ pVar->PutDouble( nVal ); +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ String aVal; +/*?*/ ((ScFormulaCell*)pCell)->GetString( aVal ); +/*?*/ pVar->PutString( aVal ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError( nErr ), bOk = FALSE; +/*N*/ break; +/*?*/ default : +/*?*/ pVar->PutDouble( 0.0 ); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ pVar->PutDouble( 0.0 ); +/*N*/ return bOk; +/*N*/ } + + +/*N*/ void ScInterpreter::ScTableOp() +/*N*/ { +/*N*/ BYTE nParamCount = GetByte(); +/*N*/ if (nParamCount != 3 && nParamCount != 5) +/*N*/ { +/*N*/ SetIllegalParameter(); +/*N*/ return; +/*N*/ } +/*N*/ ScInterpreterTableOpParams* pTableOp = new ScInterpreterTableOpParams; +/*N*/ if (nParamCount == 5) +/*N*/ { +/*N*/ PopSingleRef( pTableOp->aNew2 ); +/*N*/ PopSingleRef( pTableOp->aOld2 ); +/*N*/ } +/*N*/ PopSingleRef( pTableOp->aNew1 ); +/*N*/ PopSingleRef( pTableOp->aOld1 ); +/*N*/ PopSingleRef( pTableOp->aFormulaPos ); +/*N*/ +/*N*/ pTableOp->bValid = TRUE; +/*N*/ pDok->aTableOpList.Insert( pTableOp ); +/*N*/ pDok->IncInterpreterTableOpLevel(); +/*N*/ +/*N*/ BOOL bReuseLastParams = (pDok->aLastTableOpParams == *pTableOp); +/*N*/ if ( bReuseLastParams ) +/*N*/ { +/*N*/ pTableOp->aNotifiedFormulaPos = pDok->aLastTableOpParams.aNotifiedFormulaPos; +/*N*/ pTableOp->bRefresh = TRUE; +/*N*/ for ( ::std::vector< ScAddress >::const_iterator iBroadcast( +/*N*/ pTableOp->aNotifiedFormulaPos.begin() ); +/*N*/ iBroadcast != pTableOp->aNotifiedFormulaPos.end(); +/*N*/ ++iBroadcast ) +/*N*/ { // emulate broadcast and indirectly collect cell pointers +/*N*/ ScBaseCell* pCell = pDok->GetCell( *iBroadcast ); +/*N*/ if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pCell)->SetTableOpDirty(); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { // broadcast and indirectly collect cell pointers and positions +/*N*/ pDok->SetTableOpDirty( pTableOp->aOld1 ); +/*N*/ if ( nParamCount == 5 ) +/*N*/ pDok->SetTableOpDirty( pTableOp->aOld2 ); +/*N*/ } +/*N*/ pTableOp->bCollectNotifications = FALSE; +/*N*/ +/*N*/ ScBaseCell* pFCell = pDok->GetCell( pTableOp->aFormulaPos ); +/*N*/ if ( pFCell && pFCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ ((ScFormulaCell*)pFCell)->SetDirtyVar(); +/*N*/ if ( HasCellValueData( pFCell ) ) +/*N*/ PushDouble( GetCellValue( pTableOp->aFormulaPos, pFCell )); +/*N*/ else +/*N*/ { +/*N*/ String aCellString; +/*N*/ GetCellString( aCellString, pFCell ); +/*N*/ PushString( aCellString ); +/*N*/ } +/*N*/ +/*N*/ pDok->aTableOpList.Remove( pTableOp ); +/*N*/ // set dirty again once more to be able to recalculate original +/*N*/ for ( ::std::vector< ScFormulaCell* >::const_iterator iBroadcast( +/*N*/ pTableOp->aNotifiedFormulaCells.begin() ); +/*N*/ iBroadcast != pTableOp->aNotifiedFormulaCells.end(); +/*N*/ ++iBroadcast ) +/*N*/ { +/*N*/ (*iBroadcast)->SetTableOpDirty(); +/*N*/ } +/*N*/ +/*N*/ // save these params for next incarnation +/*N*/ if ( !bReuseLastParams ) +/*N*/ pDok->aLastTableOpParams = *pTableOp; +/*N*/ +/*N*/ if ( pFCell && pFCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ ((ScFormulaCell*)pFCell)->SetDirtyVar(); +/*N*/ ((ScFormulaCell*)pFCell)->GetErrCode(); // recalculate original +/*N*/ } +/*N*/ +/*N*/ // Reset all dirty flags so next incarnation does really collect all cell +/*N*/ // pointers during notifications and not just non-dirty ones, which may +/*N*/ // happen if a formula cell is used by more than one TableOp block. +/*N*/ for ( ::std::vector< ScFormulaCell* >::const_iterator iBroadcast2( +/*N*/ pTableOp->aNotifiedFormulaCells.begin() ); +/*N*/ iBroadcast2 != pTableOp->aNotifiedFormulaCells.end(); +/*N*/ ++iBroadcast2 ) +/*N*/ { +/*N*/ (*iBroadcast2)->ResetTableOpDirtyVar(); +/*N*/ } +/*N*/ delete pTableOp; +/*N*/ +/*N*/ pDok->DecInterpreterTableOpLevel(); +/*N*/ } + +void ScInterpreter::ScDBArea() +{ + ScDBData* pDBData = pDok->GetDBCollection()->FindIndex( pCur->GetIndex()); + if (pDBData) + { + ComplRefData aRefData; + aRefData.InitFlags(); + pDBData->GetArea( (USHORT&) aRefData.Ref1.nTab, + (USHORT&) aRefData.Ref1.nCol, + (USHORT&) aRefData.Ref1.nRow, + (USHORT&) aRefData.Ref2.nCol, + (USHORT&) aRefData.Ref2.nRow); + aRefData.Ref2.nTab = aRefData.Ref1.nTab; + aRefData.CalcRelFromAbs( aPos ); + PushTempToken( new ScDoubleRefToken( aRefData ) ); + } + else + SetError(errNoName); +} + + +void ScInterpreter::ScColRowNameAuto() +{ + ComplRefData aRefData( pCur->GetDoubleRef() ); + aRefData.CalcAbsIfRel( aPos ); + if ( aRefData.Valid() ) + { + INT16 nStartCol, nStartRow, nCol2, nRow2; + // evtl. Begrenzung durch definierte ColRowNameRanges merken + nCol2 = aRefData.Ref2.nCol; + nRow2 = aRefData.Ref2.nRow; + // DataArea der ersten Zelle + nStartCol = aRefData.Ref2.nCol = aRefData.Ref1.nCol; + nStartRow = aRefData.Ref2.nRow = aRefData.Ref1.nRow; + aRefData.Ref2.nTab = aRefData.Ref1.nTab; + pDok->GetDataArea( (USHORT) aRefData.Ref1.nTab, + (USHORT&) aRefData.Ref1.nCol, + (USHORT&) aRefData.Ref1.nRow, + (USHORT&) aRefData.Ref2.nCol, + (USHORT&) aRefData.Ref2.nRow, + TRUE ); + // DataArea im Ursprung begrenzen + aRefData.Ref1.nCol = nStartCol; + aRefData.Ref1.nRow = nStartRow; + + //! korrespondiert mit ScCompiler::GetToken + if ( aRefData.Ref1.IsColRel() ) + { // ColName + aRefData.Ref2.nCol = nStartCol; + // evtl. vorherige Begrenzung durch definierte ColRowNameRanges erhalten + if ( aRefData.Ref2.nRow > nRow2 ) + aRefData.Ref2.nRow = nRow2; + USHORT nMyRow; + if ( aPos.Col() == nStartCol + && nStartRow <= (nMyRow = aPos.Row()) && nMyRow <= aRefData.Ref2.nRow ) + { // Formel in gleicher Spalte und innerhalb des Range + if ( nMyRow == nStartRow ) + { // direkt unter dem Namen den Rest nehmen + nStartRow++; + if ( nStartRow > MAXROW ) + nStartRow = MAXROW; + aRefData.Ref1.nRow = nStartRow; + } + else + { // weiter unten vom Namen bis zur Formelzelle + aRefData.Ref2.nRow = nMyRow - 1; + } + } + } + else + { // RowName + aRefData.Ref2.nRow = nStartRow; + // evtl. vorherige Begrenzung durch definierte ColRowNameRanges erhalten + if ( aRefData.Ref2.nCol > nCol2 ) + aRefData.Ref2.nCol = nCol2; + USHORT nMyCol; + if ( aPos.Row() == nStartRow + && nStartCol <= (nMyCol = aPos.Col()) && nMyCol <= aRefData.Ref2.nCol ) + { // Formel in gleicher Zeile und innerhalb des Range + if ( nMyCol == nStartCol ) + { // direkt neben dem Namen den Rest nehmen + nStartCol++; + if ( nStartCol > MAXCOL ) + nStartCol = MAXCOL; + aRefData.Ref1.nCol = nStartCol; + } + else + { // weiter rechts vom Namen bis zur Formelzelle + aRefData.Ref2.nCol = nMyCol - 1; + } + } + } + aRefData.CalcRelFromAbs( aPos ); + } + else + SetError( errNoRef ); + PushTempToken( new ScDoubleRefToken( aRefData ) ); +} + +// --- internals ------------------------------------------------------------ + + +void ScInterpreter::ScAnswer() +{ + String aStr( GetString() ); + if( aStr.EqualsIgnoreCaseAscii( "Das Leben, das Universum und der ganze Rest" ) ) + { + PushInt( 42 ); + bOderSo = TRUE; + } + else + SetNoValue(); +} + + +void ScInterpreter::ScCalcTeam() +{ + static BOOL bShown = FALSE; + if( !bShown ) + { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ShowTheTeam(); +/*N*/ String aTeam( RTL_CONSTASCII_USTRINGPARAM( "Ballach, Nebel, Rentz, Rathke, Marmion" ) ); +/*N*/ if ( (GetByte() == 1) && ::rtl::math::approxEqual( GetDouble(), 1996) ) +/*N*/ /*?*/ aTeam.AppendAscii( " (a word with 'B': -Olk, -Nietsch, -Daeumling)" ); +/*N*/ /*?*/ PushString( aTeam ); +/*N*/ /*?*/ bShown = TRUE; + } + else + PushInt( 42 ); +} + + +void ScInterpreter::ScSpewFunc() +{ + BOOL bRefresh = FALSE; + BOOL bClear = FALSE; + // Stack aufraeumen + BYTE nParamCount = GetByte(); + while ( nParamCount-- ) + { + switch ( GetStackType() ) + { + case svString: + case svSingleRef: + case svDoubleRef: + { + const sal_Unicode ch = GetString().GetChar(0); + if ( !bRefresh && ch < 256 ) + bRefresh = (tolower( (sal_uChar) ch ) == 'r'); + if ( !bClear && ch < 256 ) + bClear = (tolower( (sal_uChar) ch ) == 'c'); + } + break; + default: + Pop(); + } + } + String aStr; +#if SC_SPEW_ENABLED + if ( bRefresh ) + theSpew.Clear(); // GetSpew liest SpewRulesFile neu + theSpew.GetSpew( aStr ); + if ( bClear ) + theSpew.Clear(); // release Memory + xub_StrLen nPos = 0; + while ( (nPos = aStr.SearchAndReplace( '\n', ' ', nPos )) != STRING_NOTFOUND ) + nPos++; +#else + aStr.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "spitted out all spew :-(" ) ); +#endif + PushString( aStr ); +} + + +/*N*/ +/*N*/ //#define SC_INVADER_GPF // GPF wollen wir nicht :-( +/*N*/ // zum testen Environment-Variable SC_INVADER_GPF=xxx setzen +/*N*/ // 08.10.98: wenn PB optpath.cxx gefixt hat geht's wieder +/*N*/ +/*N*/ extern void StartInvader( Window* pParent ); // StarWars, Wrapper in SVX options/optpath.cxx +/*N*/ extern void Game(); // Froggie + +void ScInterpreter::ScTTT() +{ // Temporaerer Test-Tanz, zum auspropieren von Funktionen etc. + BOOL bOk = TRUE; + BYTE nParamCount = GetByte(); + // do something, nParamCount bei Pops runterzaehlen! + + if ( bOk && nParamCount ) + { + bOk = GetBool(); + --nParamCount; + } + // Stack aufraeumen + while ( nParamCount-- ) + Pop(); + static const sal_Unicode __FAR_DATA sEyes[] = { ',',';',':','|','8','B', 0 }; + static const sal_Unicode __FAR_DATA sGoods[] = { ')',']','}', 0 }; + static const sal_Unicode __FAR_DATA sBads[] = { '(','[','{','/', 0 }; + sal_Unicode aFace[4]; + if ( bOk ) + { + aFace[0] = sEyes[ rand() % ((sizeof( sEyes )/sizeof(sal_Unicode)) - 1) ]; + aFace[1] = '-'; + aFace[2] = sGoods[ rand() % ((sizeof( sGoods )/sizeof(sal_Unicode)) - 1) ]; + } + else + { + aFace[0] = ':'; + aFace[1] = '-'; + aFace[2] = sBads[ rand() % ((sizeof( sBads )/sizeof(sal_Unicode)) - 1) ]; + } + aFace[3] = 0; + PushStringBuffer( aFace ); +} + +// ------------------------------------------------------------------------- + + +/*N*/ ScInterpreter::ScInterpreter( ScFormulaCell* pCell, ScDocument* pDoc, +/*N*/ const ScAddress& rPos, ScTokenArray& r ) : +/*N*/ pMyFormulaCell( pCell ), +/*N*/ pDok( pDoc ), +/*N*/ aCode( r ), +/*N*/ aPos( rPos ), +/*N*/ rArr( r ), +/*N*/ bCalcAsShown( pDoc->GetDocOptions().IsCalcAsShown() ), +/*N*/ pFormatter( pDoc->GetFormatTable() ) +/*N*/ { +/*N*/ // pStack = new ScToken*[ MAXSTACK ]; +/*N*/ +/*N*/ BYTE cMatFlag = pMyFormulaCell->GetMatrixFlag(); +/*N*/ bMatrixFormula = ( cMatFlag == MM_FORMULA || cMatFlag == MM_FAKE ); +/*N*/ if (!bGlobalStackInUse) +/*N*/ { +/*N*/ bGlobalStackInUse = TRUE; +/*N*/ if (!pGlobalStack) +/*N*/ pGlobalStack = new ScTokenStack; +/*N*/ if (!pGlobalErrorStack) +/*N*/ pGlobalErrorStack = new ScErrorStack; +/*N*/ pStackObj = pGlobalStack; +/*N*/ pErrorStackObj = pGlobalErrorStack; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pStackObj = new ScTokenStack; +/*N*/ pErrorStackObj = new ScErrorStack; +/*N*/ } +/*N*/ pStack = pStackObj->pPointer; +/*N*/ pErrorStack = pErrorStackObj->pPointer; +/*N*/ } + + +/*N*/ ScInterpreter::~ScInterpreter() +/*N*/ { +/*N*/ // delete pStack; +/*N*/ +/*N*/ if ( pStackObj == pGlobalStack ) +/*N*/ bGlobalStackInUse = FALSE; +/*N*/ else +/*N*/ { +/*N*/ delete pStackObj; +/*N*/ delete pErrorStackObj; +/*N*/ } +/*N*/ } + + +/*N*/ void ScInterpreter::GlobalExit() // static +/*N*/ { +/*N*/ DBG_ASSERT(!bGlobalStackInUse, "wer benutzt noch den TokenStack?"); +/*N*/ DELETEZ(pGlobalStack); +/*N*/ DELETEZ(pGlobalErrorStack); +/*N*/ } + + +/*N*/ StackVar ScInterpreter::Interpret() +/*N*/ { +/*N*/ short nRetTypeExpr = NUMBERFORMAT_UNDEFINED; +/*N*/ ULONG nRetIndexExpr = 0; +/*N*/ USHORT nErrorFunction = 0; +/*N*/ USHORT nErrorFunctionCount = 0; +/*N*/ USHORT nStackBase; +/*N*/ +/*N*/ nGlobError = nGlobalError; +/*N*/ nGlobalError = 0; +/*N*/ nMatCount = 0; +/*N*/ bMatDel = FALSE; +/*N*/ ppGlobSortArray = NULL; +/*N*/ nStackBase = sp = maxsp = 0; +/*N*/ nRetFmtType = NUMBERFORMAT_UNDEFINED; +/*N*/ nFuncFmtType = NUMBERFORMAT_UNDEFINED; +/*N*/ nFuncFmtIndex = nCurFmtIndex = nRetFmtIndex = 0; +/*N*/ nResult = 0; +/*N*/ pResult = NULL; +/*N*/ eResult = svDouble; +/*N*/ glSubTotal = FALSE; +/*N*/ UINT16 nOldOpCode = ocStop; +/*N*/ + // Once upon a time we used to have FP exceptions on, and there was a + // Windows printer driver that kept switching off exceptions, so we had to + // switch them back on again every time. Who knows if there isn't a driver + // that keeps switching exceptions on, now that we run with exceptions off, + // so reassure exceptions are really off. +/*N*/ SAL_MATH_FPEXCEPTIONS_OFF(); + +/*N*/ aCode.Reset(); +/*N*/ while( ( pCur = aCode.Next() ) != NULL +/*N*/ && (!nGlobalError || nErrorFunction <= nErrorFunctionCount) ) +/*N*/ { +/*N*/ OpCode eOp = pCur->GetOpCode(); +/*N*/ cPar = pCur->GetByte(); +/*N*/ if ( eOp == ocPush ) +/*N*/ { +/*N*/ Push( (ScToken&) *pCur ); +/*N*/ if ( sp <= MAXSTACK ) +/*N*/ pErrorStack[ sp - 1 ] = 0; // RPN-Code Push ohne Fehler +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // bisheriger Ausdruck bestimmt das aktuelle Format +/*N*/ nCurFmtType = nRetTypeExpr; +/*N*/ nCurFmtIndex = nRetIndexExpr; +/*N*/ // default Funtionsformat, andere werden bei Bedarf gesetzt +/*N*/ nFuncFmtType = NUMBERFORMAT_NUMBER; +/*N*/ nFuncFmtIndex = 0; +/*N*/ +/*N*/ if ( eOp == ocIf || eOp == ocChose ) +/*N*/ nStackBase = sp; // nicht die Jumps vertueddeln +/*N*/ else +/*N*/ nStackBase = sp - pCur->GetParamCount(); +/*N*/ if ( nStackBase > sp ) +/*N*/ nStackBase = sp; // underflow?!? +/*N*/ +/*N*/ switch( eOp ) +/*N*/ { + case ocSep: + case ocClose: // vom Compiler gepusht + case ocMissing : ScMissing(); break; +/*N*/ case ocMacro : ScMacro(); break; + case ocDBArea : ScDBArea(); break; + case ocColRowNameAuto : ScColRowNameAuto(); break; +// gesondert case ocPush : Push( (ScToken&) *pCur ); break; +/*N*/ case ocIf : ScIfJump(); break; + case ocChose : ScChoseJump(); break; +/*N*/ case ocAdd : ScAdd(); break; +/*N*/ case ocSub : ScSub(); break; +/*N*/ case ocMul : ScMul(); break; +/*N*/ case ocDiv : ScDiv(); break; +/*N*/ case ocAmpersand : ScAmpersand(); break; + case ocPow : ScPow(); break; +/*N*/ case ocEqual : ScEqual(); break; +/*N*/ case ocNotEqual : ScNotEqual(); break; + case ocLess : ScLess(); break; + case ocGreater : ScGreater(); break; + case ocLessEqual : ScLessEqual(); break; + case ocGreaterEqual : ScGreaterEqual(); break; + case ocAnd : ScAnd(); break; + case ocOr : ScOr(); break; + case ocIntersect : ScIntersect(); break; + case ocNot : ScNot(); break; + case ocNegSub : + case ocNeg : ScNeg(); break; + case ocPercentSign : ScPercentSign(); break; +/*N*/ case ocPi : ScPi(); break; + case ocRandom : ScRandom(); break; + case ocTrue : ScTrue(); break; + case ocFalse : ScFalse(); break; +/*N*/ case ocGetActDate : ScGetActDate(); break; + case ocGetActTime : ScGetActTime(); break; + case ocNoValue : nGlobalError = NOVALUE; + PushInt(0); break; + case ocDeg : ScDeg(); break; + case ocRad : ScRad(); break; +/*N*/ case ocSin : ScSin(); break; + case ocCos : ScCos(); break; + case ocTan : ScTan(); break; + case ocCot : ScCot(); break; + case ocArcSin : ScArcSin(); break; + case ocArcCos : ScArcCos(); break; + case ocArcTan : ScArcTan(); break; + case ocArcCot : ScArcCot(); break; + case ocSinHyp : ScSinHyp(); break; + case ocCosHyp : ScCosHyp(); break; + case ocTanHyp : ScTanHyp(); break; + case ocCotHyp : ScCotHyp(); break; + case ocArcSinHyp : ScArcSinHyp(); break; + case ocArcCosHyp : ScArcCosHyp(); break; + case ocArcTanHyp : ScArcTanHyp(); break; + case ocArcCotHyp : ScArcCotHyp(); break; + case ocExp : ScExp(); break; + case ocLn : ScLn(); break; + case ocLog10 : ScLog10(); break; + case ocSqrt : ScSqrt(); break; + case ocFact : ScFact(); break; + case ocGetYear : ScGetYear(); break; + case ocGetMonth : ScGetMonth(); break; +/*N*/ case ocGetDay : ScGetDay(); break; +/*N*/ case ocGetDayOfWeek : ScGetDayOfWeek(); break; +/*N*/ case ocWeek : ScGetWeekOfYear(); break; +/*N*/ case ocEasterSunday : ScEasterSunday(); break; + case ocGetHour : ScGetHour(); break; + case ocGetMin : ScGetMin(); break; + case ocGetSec : ScGetSec(); break; +/*N*/ case ocPlusMinus : ScPlusMinus(); break; + case ocAbs : ScAbs(); break; +/*N*/ case ocInt : ScInt(); break; + case ocEven : ScEven(); break; + case ocOdd : ScOdd(); break; + case ocPhi : ScPhi(); break; + case ocGauss : ScGauss(); break; + case ocStdNormDist : ScStdNormDist(); break; + case ocFisher : ScFisher(); break; + case ocFisherInv : ScFisherInv(); break; + case ocIsEmpty : ScIsEmpty(); break; + case ocIsString : ScIsString(); break; + case ocIsNonString : ScIsNonString(); break; + case ocIsLogical : ScIsLogical(nOldOpCode); break; + case ocType : ScType(); break; + case ocCell : ScCell(); break; + case ocIsRef : ScIsRef(); break; + case ocIsValue : ScIsValue(); break; + case ocIsFormula : ScIsFormula(); break; + case ocFormula : ScFormula(); break; + case ocIsNV : ScIsNV(); break; + case ocIsErr : ScIsErr(); break; + case ocIsError : ScIsError(); break; + case ocIsEven : ScIsEven(); break; + case ocIsOdd : ScIsOdd(); break; + case ocN : ScN(); break; + case ocGetDateValue : ScGetDateValue(); break; + case ocGetTimeValue : ScGetTimeValue(); break; + case ocCode : ScCode(); break; + case ocTrim : ScTrim(); break; + case ocUpper : ScUpper(); break; + case ocPropper : ScPropper(); break; + case ocLower : ScLower(); break; + case ocLen : ScLen(); break; + case ocT : ScT(); break; + case ocClean : ScClean(); break; + case ocValue : ScValue(); break; + case ocChar : ScChar(); break; + case ocArcTan2 : ScArcTan2(); break; +/*N*/ case ocMod : ScMod(); break; + case ocPower : ScPower(); break; + case ocRound : ScRound(); break; +/*N*/ case ocRoundUp : ScRoundUp(); break; + case ocTrunc : + case ocRoundDown : ScRoundDown(); break; + case ocCeil : ScCeil(); break; + case ocFloor : ScFloor(); break; + case ocSumProduct : ScSumProduct(); break; + case ocSumSQ : ScSumSQ(); break; + case ocSumX2MY2 : ScSumX2MY2(); break; + case ocSumX2DY2 : ScSumX2DY2(); break; + case ocSumXMY2 : ScSumXMY2(); break; + case ocLog : ScLog(); break; + case ocGGT : ScGGT(); break; + case ocKGV : ScKGV(); break; + case ocGetDate : ScGetDate(); break; + case ocGetTime : ScGetTime(); break; + case ocGetDiffDate : ScGetDiffDate(); break; + case ocGetDiffDate360 : ScGetDiffDate360(); break; +/*N*/ case ocMin : ScMin( FALSE ); break; + case ocMinA : ScMin( TRUE ); break; +/*N*/ case ocMax : ScMax( FALSE ); break; + case ocMaxA : ScMax( TRUE ); break; +/*N*/ case ocSum : ScSum(); break; + case ocProduct : ScProduct(); break; + case ocNBW : ScNBW(); break; + case ocIKV : ScIKV(); break; + case ocMIRR : ScMIRR(); break; + case ocISPMT : ScISPMT(); break; +/*N*/ case ocAverage : ScAverage( FALSE ); break; + case ocAverageA : ScAverage( TRUE ); break; + case ocCount : ScCount(); break; +/*N*/ case ocCount2 : ScCount2(); break; + case ocVar : ScVar( FALSE ); break; + case ocVarA : ScVar( TRUE ); break; + case ocVarP : ScVarP( FALSE ); break; + case ocVarPA : ScVarP( TRUE ); break; + case ocStDev : ScStDev( FALSE ); break; + case ocStDevA : ScStDev( TRUE ); break; + case ocStDevP : ScStDevP( FALSE ); break; + case ocStDevPA : ScStDevP( TRUE ); break; + case ocBW : ScBW(); break; + case ocDIA : ScDIA(); break; + case ocGDA : ScGDA(); break; + case ocGDA2 : ScGDA2(); break; + case ocVBD : ScVDB(); break; + case ocLaufz : ScLaufz(); break; + case ocLIA : ScLIA(); break; + case ocRMZ : ScRMZ(); break; + case ocColumns : ScColumns(); break; + case ocRows : ScRows(); break; + case ocTables : ScTables(); break; + case ocColumn : ScColumn(); break; + case ocRow : ScRow(); break; + case ocTable : ScTable(); break; + case ocZGZ : ScZGZ(); break; + case ocZW : ScZW(); break; + case ocZZR : ScZZR(); break; + case ocZins : ScZins(); break; + case ocZinsZ : ScZinsZ(); break; + case ocKapz : ScKapz(); break; + case ocKumZinsZ : ScKumZinsZ(); break; + case ocKumKapZ : ScKumKapZ(); break; + case ocEffektiv : ScEffektiv(); break; + case ocNominal : ScNominal(); break; +/*N*/ case ocSubTotal : ScSubTotal(); break; + case ocDBSum : ScDBSum(); break; + case ocDBCount : ScDBCount(); break; + case ocDBCount2 : ScDBCount2(); break; + case ocDBAverage : ScDBAverage(); break; + case ocDBGet : ScDBGet(); break; + case ocDBMax : ScDBMax(); break; + case ocDBMin : ScDBMin(); break; + case ocDBProduct : ScDBProduct(); break; + case ocDBStdDev : ScDBStdDev(); break; + case ocDBStdDevP : ScDBStdDevP(); break; + case ocDBVar : ScDBVar(); break; + case ocDBVarP : ScDBVarP(); break; + case ocIndirect : ScIndirect(); break; + case ocAdress : ScAdress(); break; + case ocMatch : ScMatch(); break; + case ocCountEmptyCells : ScCountEmptyCells(); break; + case ocCountIf : ScCountIf(); break; + case ocSumIf : ScSumIf(); break; + case ocLookup : ScLookup(); break; +/*N*/ case ocVLookup : ScVLookup(); break; + case ocHLookup : ScHLookup(); break; + case ocIndex : ScIndex(); break; + case ocMultiArea : ScMultiArea(); break; + case ocOffset : ScOffset(); break; + case ocAreas : ScAreas(); break; + case ocCurrency : ScCurrency(); break; + case ocReplace : ScReplace(); break; + case ocFixed : ScFixed(); break; + case ocFind : ScFind(); break; + case ocExact : ScExact(); break; + case ocLeft : ScLeft(); break; + case ocRight : ScRight(); break; + case ocSearch : ScSearch(); break; + case ocMid : ScMid(); break; +/*N*/ case ocText : ScText(); break; + case ocSubstitute : ScSubstitute(); break; + case ocRept : ScRept(); break; + case ocConcat : ScConcat(); break; + case ocMatValue : ScMatValue(); break; + case ocMatrixUnit : ScEMat(); break; + case ocMatDet : ScMatDet(); break; + case ocMatInv : ScMatInv(); break; + case ocMatMult : ScMatMult(); break; + case ocMatTrans : ScMatTrans(); break; +/*N*/ case ocMatRef : ScMatRef(); break; + case ocBackSolver : ScBackSolver(); break; + case ocB : ScB(); break; + case ocNormDist : ScNormDist(); break; + case ocExpDist : ScExpDist(); break; + case ocBinomDist : ScBinomDist(); break; + case ocPoissonDist : ScPoissonDist(); break; + case ocKombin : ScKombin(); break; + case ocKombin2 : ScKombin2(); break; + case ocVariationen : ScVariationen(); break; + case ocVariationen2 : ScVariationen2(); break; + case ocHypGeomDist : ScHypGeomDist(); break; + case ocLogNormDist : ScLogNormDist(); break; + case ocTDist : ScTDist(); break; + case ocFDist : ScFDist(); break; + case ocChiDist : ScChiDist(); break; + case ocStandard : ScStandard(); break; + case ocAveDev : ScAveDev(); break; + case ocDevSq : ScDevSq(); break; + case ocKurt : ScKurt(); break; + case ocSchiefe : ScSkew(); break; + case ocModalValue : ScModalValue(); break; + case ocMedian : ScMedian(); break; + case ocGeoMean : ScGeoMean(); break; + case ocHarMean : ScHarMean(); break; + case ocWeibull : ScWeibull(); break; + case ocKritBinom : ScCritBinom(); break; + case ocNegBinomVert : ScNegBinomDist(); break; + case ocNoName : ScNoName(); break; + case ocZTest : ScZTest(); break; + case ocTTest : ScTTest(); break; + case ocFTest : ScFTest(); break; + case ocRank : ScRank(); break; + case ocPercentile : ScPercentile(); break; + case ocPercentrank : ScPercentrank(); break; + case ocLarge : ScLarge(); break; + case ocSmall : ScSmall(); break; + case ocFrequency : ScFrequency(); break; + case ocQuartile : ScQuartile(); break; + case ocNormInv : ScNormInv(); break; + case ocSNormInv : ScSNormInv(); break; + case ocConfidence : ScConfidence(); break; + case ocTrimMean : ScTrimMean(); break; + case ocProb : ScProbability(); break; + case ocCorrel : ScCorrel(); break; + case ocCovar : ScCovar(); break; + case ocPearson : ScPearson(); break; + case ocRSQ : ScRSQ(); break; + case ocSTEYX : ScSTEXY(); break; + case ocSlope : ScSlope(); break; + case ocIntercept : ScIntercept(); break; + case ocTrend : ScTrend(); break; + case ocGrowth : ScGrowth(); break; + case ocRGP : ScRGP(); break; + case ocRKP : ScRKP(); break; + case ocForecast : ScForecast(); break; + case ocGammaLn : ScLogGamma(); break; + case ocGammaDist : ScGammaDist(); break; + case ocGammaInv : ScGammaInv(); break; + case ocChiTest : ScChiTest(); break; + case ocChiInv : ScChiInv(); break; + case ocTInv : ScTInv(); break; + case ocFInv : ScFInv(); break; + case ocLogInv : ScLogNormInv(); break; + case ocBetaDist : ScBetaDist(); break; + case ocBetaInv : ScBetaInv(); break; +/*N*/ case ocExternal : ScExternal(); break; + case ocTableOp : ScTableOp(); break; +// case ocErrCell : ScErrCell(); break; + case ocStop : break; + case ocErrorType : ScErrorType(); break; + case ocCurrent : ScCurrent(); break; + case ocStyle : ScStyle(); break; + case ocDde : ScDde(); break; + case ocBase : ScBase(); break; +/*N*/ case ocDecimal : ScDecimal(); break; +/*N*/ case ocConvert : ScConvert(); break; + case ocRoman : ScRoman(); break; + case ocArabic : ScArabic(); break; + case ocAnswer : ScAnswer(); break; + case ocTeam : ScCalcTeam(); break; + case ocTTT : ScTTT(); break; + case ocSpew : ScSpewFunc(); break; + case ocGame : ScGame(); break; +/*N*/ default : SetError(errUnknownOpCode); PushInt(0); break; +/*N*/ } +/*N*/ +/*N*/ // aeussere Funktion bestimmt das Format eines Ausdrucks +/*N*/ if ( nFuncFmtType != NUMBERFORMAT_UNDEFINED ) +/*N*/ { +/*N*/ nRetTypeExpr = nFuncFmtType; +/*N*/ // nur fuer Waehrungsformate den FormatIndex uebernehmen +/*N*/ nRetIndexExpr = ( nFuncFmtType == NUMBERFORMAT_CURRENCY ? +/*N*/ nFuncFmtIndex : 0 ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ // Funktionen, die einen Fehlercode auswerten und nGlobalError direkt auf 0 setzen +/*N*/ // usage: switch( OpCode ) { OCERRFUNCCASE( ++n ) } +/*N*/ #define CASEOCERRFUNC( statement ) \ +/*N*/ case ocErrorType : \ +/*N*/ case ocIsEmpty : \ +/*N*/ case ocIsErr : \ +/*N*/ case ocIsError : \ +/*N*/ case ocIsFormula : \ +/*N*/ case ocIsLogical : \ +/*N*/ case ocIsNV : \ +/*N*/ case ocIsNonString : \ +/*N*/ case ocIsRef : \ +/*N*/ case ocIsString : \ +/*N*/ case ocIsValue : \ +/*N*/ case ocN : \ +/*N*/ case ocType : \ +/*N*/ statement; +/*N*/ +/*N*/ switch ( eOp ) +/*N*/ { +/*N*/ CASEOCERRFUNC( ++nErrorFunction ) +/*N*/ } +/*N*/ if ( nGlobalError ) +/*N*/ { +/*N*/ if ( !nErrorFunctionCount ) +/*N*/ { // Anzahl der Fehlercode-Funktionen in Formel +/*N*/ for ( ScToken* t = rArr.FirstRPN(); t; t = rArr.NextRPN() ) +/*N*/ { +/*N*/ switch ( t->GetOpCode() ) +/*N*/ { +/*N*/ CASEOCERRFUNC( ++nErrorFunctionCount ) +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( nErrorFunction >= nErrorFunctionCount ) +/*N*/ ++nErrorFunction; // das war's, Fehler => Abbruch +/*N*/ else +/*N*/ { +/*?*/ if ( eOp != ocPush && sp > nStackBase + 1 ) +/*?*/ { // Stack abraeumen, geht davon aus, dass jede Funktion +/*?*/ // prinzipiell ein Ergebnis pusht, im Fehlerfall kann dies +/*?*/ // ein zufaelliger Wert sein +/*?*/ const ScToken* pResult = pStack[ sp - 1 ]; +/*?*/ while ( sp > nStackBase ) +/*?*/ Pop(); +/*?*/ PushTempToken( *pResult ); +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ nOldOpCode = eOp; +/*N*/ } +/*N*/ +/*N*/ // Ende: Returnwert holen +/*N*/ +/*N*/ if( sp ) +/*N*/ { +/*N*/ pCur = pStack[ sp-1 ]; +/*N*/ if( pCur->GetOpCode() == ocPush ) +/*N*/ { +/*N*/ if ( !nGlobalError ) +/*N*/ nGlobalError = pErrorStack[ sp-1 ]; +/*N*/ switch( eResult = pCur->GetType() ) +/*N*/ { +/*N*/ case svDouble : +/*N*/ nResult = pCur->GetDouble(); +/*N*/ if ( nFuncFmtType == NUMBERFORMAT_UNDEFINED ) +/*N*/ { +/*N*/ nRetTypeExpr = NUMBERFORMAT_NUMBER; +/*N*/ nRetIndexExpr = 0; +/*N*/ } +/*N*/ break; +/*N*/ case svString : +/*N*/ nRetTypeExpr = NUMBERFORMAT_TEXT; +/*N*/ nRetIndexExpr = 0; +/*N*/ aResult = PopString(); +/*N*/ break; +/*N*/ case svSingleRef : +/*N*/ { +/*N*/ ScAddress aAdr; +/*N*/ PopSingleRef( aAdr ); +/*N*/ if( !nGlobalError ) +/*N*/ { +/*N*/ ScBaseCell* pCell = pDok->GetCell( aAdr ); +/*N*/ if( pCell && pCell->HasStringData() ) +/*N*/ { +/*N*/ GetCellString( aResult, pCell ); +/*N*/ nRetTypeExpr = NUMBERFORMAT_TEXT; +/*N*/ nRetIndexExpr = 0; +/*N*/ eResult = svString; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nResult = GetCellValue( aAdr, pCell ); +/*N*/ nRetTypeExpr = nCurFmtType; +/*N*/ nRetIndexExpr = nCurFmtIndex; +/*N*/ eResult = svDouble; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ { +/*?*/ if ( bMatrixFormula ) +/*?*/ { // Matrix erzeugen fuer {=A1:A5} +/*?*/ PopDoubleRefPushMatrix(); +/*?*/ // kein break, weiter mit svMatrix +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ ScRange aRange; +/*?*/ PopDoubleRef( aRange ); +/*?*/ ScAddress aAdr; +/*?*/ if ( !nGlobalError && DoubleRefToPosSingleRef( aRange, aAdr ) ) +/*?*/ { +/*?*/ ScBaseCell* pCell = pDok->GetCell( aAdr ); +/*?*/ if( pCell && pCell->HasStringData() ) +/*?*/ { +/*?*/ GetCellString( aResult, pCell ); +/*?*/ nRetTypeExpr = NUMBERFORMAT_TEXT; +/*?*/ nRetIndexExpr = 0; +/*?*/ eResult = svString; +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ nResult = GetCellValue( aAdr, pCell ); +/*?*/ nRetTypeExpr = nCurFmtType; +/*?*/ nRetIndexExpr = nCurFmtIndex; +/*?*/ eResult = svDouble; +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ } +/*?*/ } +/*?*/ // kein break +/*N*/ case svMatrix : +/*N*/ pResult = PopMatrix(); +/*N*/ if (pResult) +/*N*/ { +/*N*/ BOOL bIsString; +/*N*/ const MatValue* pMatVal = pResult->Get(0, 0, bIsString); +/*N*/ if ( pMatVal ) +/*N*/ { +/*N*/ if (bIsString) +/*N*/ { +/*?*/ aResult = pMatVal->GetString(); +/*?*/ eResult = svString; +/*?*/ nRetTypeExpr = NUMBERFORMAT_TEXT; +/*?*/ nRetIndexExpr = 0; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nResult = pMatVal->fVal; +/*N*/ eResult = svDouble; +/*N*/ if ( nRetTypeExpr != NUMBERFORMAT_LOGICAL ) +/*N*/ nRetTypeExpr = NUMBERFORMAT_NUMBER; +/*N*/ nRetIndexExpr = 0; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError(errUnknownStackVariable); +/*N*/ DBG_ASSERT(nRetMat <= MAX_ANZ_MAT, +/*N*/ "ScInterpreter::nRetMat falsch"); +/*N*/ ResetNewMat(nRetMat); // Matrix nicht loeschen +/*N*/ } +/*N*/ else +/*N*/ eResult = svDouble; +/*N*/ break; +/*N*/ default : +/*N*/ SetError(errUnknownStackVariable); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError(errUnknownStackVariable); +/*N*/ } +/*N*/ else +/*N*/ SetError(errNoCode); +/*N*/ +/*N*/ if (!::rtl::math::isFinite(nResult)) +/*N*/ { +/*N*/ if ( ::rtl::math::isNan( nResult ) ) +/*N*/ SetError(errNoValue); +/*N*/ else +/*N*/ SetError(errIllegalFPOperation); +/*N*/ nResult = 0.0; +/*N*/ } +/*N*/ +/*N*/ if( nRetTypeExpr != NUMBERFORMAT_UNDEFINED ) +/*N*/ { +/*N*/ nRetFmtType = nRetTypeExpr; +/*N*/ nRetFmtIndex = nRetIndexExpr; +/*N*/ } +/*N*/ else if( nFuncFmtType != NUMBERFORMAT_UNDEFINED ) +/*N*/ { +/*N*/ nRetFmtType = nFuncFmtType; +/*N*/ nRetFmtIndex = nFuncFmtIndex; +/*N*/ } +/*N*/ else +/*N*/ nRetFmtType = NUMBERFORMAT_NUMBER; +/*N*/ // nur fuer Waehrungsformate den FormatIndex uebernehmen +/*N*/ if ( nRetFmtType != NUMBERFORMAT_CURRENCY ) +/*N*/ nRetFmtIndex = 0; +/*N*/ +/*N*/ // grrr.. EiterZirkel! +/*N*/ // Fehler nur zuruecksetzen wenn nicht errCircularReference ohne Iterationen +/*N*/ if ( nGlobalError || !(rArr.GetError() == errCircularReference && !pDok->GetDocOptions().IsIter()) ) +/*N*/ rArr.SetError( nGlobalError ); +/*N*/ +/*N*/ if (ppGlobSortArray) +/*?*/ #ifdef WIN +/*?*/ SvMemFree(*ppGlobSortArray); +/*?*/ #else +/*?*/ delete [] (*ppGlobSortArray); +/*?*/ #endif +/*N*/ if (bMatDel) +/*N*/ { +/*N*/ for (USHORT i = 0; i < MAX_ANZ_MAT; i++) +/*N*/ delete ppTempMatArray[i]; +/*N*/ delete [] ppTempMatArray; +/*N*/ } +/*N*/ // Tokens im ExprStack freigeben +/*N*/ ScToken** p = pStack; +/*N*/ while( maxsp-- ) +/*N*/ (*p++)->DecRef(); +/*N*/ nGlobalError = nGlobError; +/*N*/ return eResult; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_interpr5.cxx b/binfilter/bf_sc/source/core/tool/sc_interpr5.cxx new file mode 100644 index 000000000000..1af8655046e9 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_interpr5.cxx @@ -0,0 +1,4062 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <string.h> + +#include <bf_svtools/zforlist.hxx> + +#include "interpre.hxx" +#include "dociter.hxx" +#include "scmatrix.hxx" +#include "globstr.hrc" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +#define SCdEpsilon 1.0E-7 + + +// ----------------------------------------------------------------------- + +double ScInterpreter::ScGetGGT(double fx, double fy) +{ + if (fy == 0.0 || fx == 0.0) + { + SetError(errIllegalArgument); + return 1.0; + } + else + { + double fz = fmod(fx, fy); + while (fz > 0.0) + { + fx = fy; + fy = fz; + fz = fmod(fx, fy); + } + return fy; + } +} + +void ScInterpreter::ScGGT() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCountMin( nParamCount, 1 ) ) + { + double fSign = 1.0; + double fx, fy = 0.0; + switch (GetStackType()) + { + case svDouble : + case svString: + case svSingleRef: + { + fy = GetDouble(); + if (fy < 0.0) + { + fy *= -1.0; + fSign *= -1.0; + } + } + break; + case svDoubleRef : + { + ScRange aRange; + USHORT nErr = 0; + PopDoubleRef( aRange ); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + fy = nCellVal; + if (fy < 0.0) + { + fy *= -1.0; + fSign *= -1.0; + } + while (nErr == 0 && aValIter.GetNext(nCellVal, nErr)) + { + fx = nCellVal; + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + } + SetError(nErr); + } + else + SetError(errIllegalArgument); + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + if (nC == 0 || nR == 0) + SetError(errIllegalArgument); + else + { + if (!pMat->IsValue(0)) + { + SetIllegalArgument(); + return; + } + fy = pMat->GetDouble(0); + if (fy < 0.0) + { + fy *= -1.0; + fSign *= -1.0; + } + ULONG nCount = (ULONG) nC * nR; + for ( ULONG j = 1; j < nCount; j++ ) + { + if (!pMat->IsValue(j)) + { + SetIllegalArgument(); + return; + } + fx = pMat->GetDouble(j); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + ScRange aRange; + for (short i = 0; i < (short) nParamCount - 1; i++) + { + switch (GetStackType()) + { + case svDouble : + case svString: + case svSingleRef: + { + fx = GetDouble(); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + } + break; + case svDoubleRef : + { + USHORT nErr = 0; + PopDoubleRef( aRange ); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + fx = nCellVal; + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + while (nErr == 0 && aValIter.GetNext(nCellVal, nErr)) + { + fx = nCellVal; + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + } + SetError(nErr); + } + else + SetError(errIllegalArgument); + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + if (nC == 0 || nR == 0) + SetError(errIllegalArgument); + else + { + if (!pMat->IsValue(0)) + { + SetIllegalArgument(); + return; + } + fx = pMat->GetDouble(0); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + ULONG nCount = (ULONG) nC * nR; + for ( ULONG j = 1; j < nCount; j++ ) + { + if (!pMat->IsValue(j)) + { + SetIllegalArgument(); + return; + } + fx = pMat->GetDouble(j); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = ScGetGGT(fx, fy); + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + if (fSign == -1.0) + PushDouble(-fy); + else + PushDouble(fy); + } +} + +void ScInterpreter:: ScKGV() +{ + BYTE nParamCount = GetByte(); + if ( MustHaveParamCountMin( nParamCount, 1 ) ) + { + double fSign = 1.0; + double fx, fy = 0.0; + switch (GetStackType()) + { + case svDouble : + case svString: + case svSingleRef: + { + fy = GetDouble(); + if (fy < 0.0) + { + fy *= -1.0; + fSign *= -1.0; + } + } + break; + case svDoubleRef : + { + ScRange aRange; + USHORT nErr = 0; + PopDoubleRef( aRange ); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + fy = nCellVal; + if (fy < 0.0) + { + fy *= -1.0; + fSign *= -1.0; + } + while (nErr == 0 && aValIter.GetNext(nCellVal, nErr)) + { + fx = nCellVal; + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + } + SetError(nErr); + } + else + SetError(errIllegalArgument); + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + if (nC == 0 || nR == 0) + SetError(errIllegalArgument); + else + { + if (!pMat->IsValue(0)) + { + SetIllegalArgument(); + return; + } + fy = pMat->GetDouble(0); + if (fy < 0.0) + { + fy *= -1.0; + fSign *= -1.0; + } + ULONG nCount = (ULONG) nC * nR; + for ( ULONG j = 1; j < nCount; j++ ) + { + if (!pMat->IsValue(j)) + { + SetIllegalArgument(); + return; + } + fx = pMat->GetDouble(j); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + ScRange aRange; + for (short i = 0; i < (short) nParamCount - 1; i++) + { + switch (GetStackType()) + { + case svDouble : + case svString: + case svSingleRef: + { + fx = GetDouble(); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + } + break; + case svDoubleRef : + { + USHORT nErr = 0; + PopDoubleRef( aRange ); + double nCellVal; + ScValueIterator aValIter(pDok, aRange, glSubTotal); + if (aValIter.GetFirst(nCellVal, nErr)) + { + fx = nCellVal; + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + while (nErr == 0 && aValIter.GetNext(nCellVal, nErr)) + { + fx = nCellVal; + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + } + SetError(nErr); + } + else + SetError(errIllegalArgument); + } + break; + case svMatrix : + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + if (nC == 0 || nR == 0) + SetError(errIllegalArgument); + else + { + if (!pMat->IsValue(0)) + { + SetIllegalArgument(); + return; + } + fx = pMat->GetDouble(0); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + ULONG nCount = (ULONG) nC * nR; + for ( ULONG j = 1; j < nCount; j++ ) + { + if (!pMat->IsValue(j)) + { + SetIllegalArgument(); + return; + } + fx = pMat->GetDouble(j); + if (fx < 0.0) + { + fx *= -1.0; + fSign *= -1.0; + } + fy = fx * fy / ScGetGGT(fx, fy); + } + } + } + } + break; + default : SetError(errIllegalParameter); break; + } + } + if (fSign == -1.0) + PushDouble(-fy); + else + PushDouble(fy); + } +} + +/*N*/ ScMatrix* ScInterpreter::GetNewMat(USHORT nC, USHORT nR, USHORT& nMatInd) +/*N*/ { +/*N*/ if (nMatCount == MAX_ANZ_MAT) +/*N*/ { +/*N*/ DBG_ERROR("ScInterpreter::GetNewMat: Matrixueberlauf"); +/*N*/ SetError(errCodeOverflow); +/*N*/ nMatInd = MAX_ANZ_MAT; +/*N*/ return NULL; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (!bMatDel) // beim ersten Mal +/*N*/ { +/*N*/ ppTempMatArray = new ScMatrix* [MAX_ANZ_MAT]; +/*N*/ for (USHORT i = 0; i < MAX_ANZ_MAT; i++) +/*N*/ ppTempMatArray[i] = NULL; +/*N*/ bMatDel = TRUE; +/*N*/ } +/*N*/ ppTempMatArray[nMatCount] = new ScMatrix(nC, nR); +/*N*/ nMatInd = nMatCount++; +/*N*/ return ppTempMatArray[nMatInd]; +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ResetNewMat(USHORT nIndex) +/*N*/ { +/*N*/ if (nIndex < MAX_ANZ_MAT) +/*N*/ { +/*N*/ ppTempMatArray[nIndex] = NULL; +/*N*/ if (nIndex == nMatCount - 1) +/*N*/ nMatCount--; +/*N*/ } +/*N*/ } + +/*N*/ ScMatrix* ScInterpreter::GetMatrix(USHORT& nMatInd) +/*N*/ { +/*N*/ ScMatrix* pMat = NULL; +/*N*/ switch (GetStackType()) +/*N*/ { +/*?*/ case svSingleRef : +/*?*/ { +/*?*/ ScAddress aAdr; +/*?*/ PopSingleRef( aAdr ); +/*?*/ pMat = GetNewMat(1, 1, nMatInd); +/*?*/ if (pMat) +/*?*/ { +/*?*/ ScBaseCell* pCell = GetCell( aAdr ); +/*?*/ if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) +/*?*/ { +/*?*/ if (HasCellValueData(pCell)) +/*?*/ pMat->PutDouble(GetCellValue(aAdr, pCell), 0); +/*?*/ else +/*?*/ { +/*?*/ String aStr; +/*?*/ GetCellString(aStr, pCell); +/*?*/ pMat->PutString(aStr, 0); +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ pMat->PutEmpty( 0 ); +/*?*/ } +/*?*/ else +/*?*/ SetError(errCodeOverflow); +/*?*/ } +/*?*/ break; +/*N*/ case svDoubleRef: +/*N*/ { +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); +/*N*/ if (nTab1 == nTab2) +/*N*/ { +/*N*/ USHORT i, j; +/*N*/ if ( (ULONG) (nRow2 - nRow1 + 1) * (nCol2 - nCol1 + 1) > +/*N*/ ScMatrix::GetElementsMax() ) +/*N*/ SetError(errStackOverflow); +/*N*/ else +/*N*/ { +/*N*/ pMat = GetNewMat(nCol2 - nCol1 + 1, nRow2 - nRow1 + 1, nMatInd); +/*N*/ if (pMat) +/*N*/ { +/*N*/ ScAddress aAdr( nCol1, nRow1, nTab1 ); +/*N*/ for (i = nRow1; i <= nRow2; i++) +/*N*/ { +/*N*/ aAdr.SetRow( i ); +/*N*/ for (j = nCol1; j <= nCol2; j++) +/*N*/ { +/*N*/ aAdr.SetCol( j ); +/*N*/ ScBaseCell* pCell = GetCell( aAdr ); +/*N*/ if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) +/*N*/ { +/*N*/ if (HasCellValueData(pCell)) +/*N*/ pMat->PutDouble( +/*N*/ GetCellValue( aAdr, pCell ), +/*N*/ j-nCol1, i-nRow1); +/*N*/ else +/*N*/ { +/*?*/ String aStr; +/*?*/ GetCellString(aStr, pCell); +/*?*/ pMat->PutString(aStr, j-nCol1, i-nRow1); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ pMat->PutEmpty( j-nCol1, i-nRow1 ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError(errCodeOverflow); +/*N*/ } +/*N*/ } +/*N*/ else // keine 2D-Matrix +/*N*/ { +/*N*/ nMatInd = MAX_ANZ_MAT; +/*N*/ SetError(errIllegalParameter); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case svMatrix: +/*N*/ pMat = PopMatrix(); +/*N*/ nMatInd = MAX_ANZ_MAT; +/*N*/ break; +/*?*/ default: +/*?*/ Pop(); +/*?*/ nMatInd = MAX_ANZ_MAT; +/*?*/ SetError(errIllegalParameter); +/*?*/ break; +/*N*/ } +/*N*/ return pMat; +/*N*/ } + +void ScInterpreter::ScMatValue() +{ + if ( MustHaveParamCount( GetByte(), 3 ) ) + { + USHORT nR = (USHORT) ::rtl::math::approxFloor(GetDouble()); // 0 bis nAnz - 1 + USHORT nC = (USHORT) ::rtl::math::approxFloor(GetDouble()); // 0 bis nAnz - 1 + switch (GetStackType()) + { + case svSingleRef : + { + ScAddress aAdr; + PopSingleRef( aAdr ); + ScBaseCell* pCell = GetCell( aAdr ); + if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA) + { + USHORT nErrCode = ((ScFormulaCell*)pCell)->GetErrCode(); + if (nErrCode != 0) + { + SetError(nErrCode); + PushInt(0); + } + else + { + ScMatrix* pMat; + ((ScFormulaCell*)pCell)->GetMatrix(&pMat); + if (pMat) + { + USHORT nCl, nRw; + pMat->GetDimensions(nCl, nRw); + if (nC < nCl && nR < nRw) + { + BOOL bIsString; + const MatValue* pMatVal = pMat->Get(nC, nR, bIsString); + if (bIsString) + PushString( pMatVal->GetString() ); + else + PushDouble(pMatVal->fVal); + } + else + SetNoValue(); + } + else + SetNoValue(); + } + } + else + SetIllegalParameter(); + } + break; + case svDoubleRef : + { + USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; + PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2); + if (nCol2 - nCol1 >= nR && nRow2 - nRow1 >= nC && nTab1 == nTab2) + { + ScAddress aAdr( nCol1 + nR, nRow1 + nC, nTab1 ); + ScBaseCell* pCell = GetCell( aAdr ); + if (HasCellValueData(pCell)) + PushDouble(GetCellValue( aAdr, pCell )); + else + { + String aStr; + GetCellString(aStr, pCell); + PushString(aStr); + } + } + else + SetNoValue(); + } + break; + case svMatrix: + { + ScMatrix* pMat = PopMatrix(); + if (pMat) + { + USHORT nCl, nRw; + pMat->GetDimensions(nCl, nRw); + if (nC < nCl && nR < nRw) + { + BOOL bIsString; + const MatValue* pMatVal = pMat->Get(nC, nR, bIsString); + if (bIsString) + PushString( pMatVal->GetString() ); + else + PushDouble(pMatVal->fVal); + } + else + SetNoValue(); + } + else + SetNoValue(); + } + break; + default: + Pop(); + SetIllegalParameter(); + break; + } + } +} + +void ScInterpreter::ScEMat() +{ + if ( MustHaveParamCount( GetByte(), 1 ) ) + { + ULONG nDim = (ULONG) ::rtl::math::approxFloor(GetDouble()); + if ( nDim * nDim > ScMatrix::GetElementsMax() || nDim == 0) + SetIllegalArgument(); + else + { + USHORT nMatInd; + ScMatrix* pRMat = GetNewMat((USHORT)nDim, (USHORT)nDim, nMatInd); + if (pRMat) + { + MEMat(pRMat, (USHORT) nDim); + nRetMat = nMatInd; + PushMatrix(pRMat); + } + else + SetError(errStackOverflow); + } + } +} + +void ScInterpreter::MEMat(ScMatrix* mM, USHORT n) +{ + mM->FillDouble(0.0, 0, 0, n-1, n-1); + for (USHORT i = 0; i < n; i++) + mM->PutDouble(1.0, i, i); +} + +void ScInterpreter::MFastMult(ScMatrix* pA, ScMatrix* pB, ScMatrix* pR, + USHORT n, USHORT m, USHORT l) + // Multipliziert n x m Mat a mit m x l Mat b nach Mat r +{ + double sum; + for (USHORT i = 0; i < n; i++) + { + for (USHORT j = 0; j < l; j++) + { + sum = 0.0; + for (USHORT k = 0; k < m; k++) + sum += pA->GetDouble(i,k)*pB->GetDouble(k,j); + pR->PutDouble(sum, i, j); + } + } +} + +void ScInterpreter::MFastSub(ScMatrix* pA, ScMatrix* pB, ScMatrix* pR, + USHORT n, USHORT m) + // Subtrahiert n x m Mat a - m x l Mat b nach Mat r +{ + for (USHORT i = 0; i < n; i++) + { + for (USHORT j = 0; j < m; j++) + pR->PutDouble(pA->GetDouble(i,j) - pB->GetDouble(i,j), i, j); + } +} + +void ScInterpreter::MFastTrans(ScMatrix* pA, ScMatrix* pR, + USHORT n, USHORT m) + // Transponiert n x m Mat a nach Mat r +{ + for (USHORT i = 0; i < n; i++) + for (USHORT j = 0; j < m; j++) + pR->PutDouble(pA->GetDouble(i, j), j, i); +} + +BOOL ScInterpreter::MFastBackSubst(ScMatrix* pA, ScMatrix* pR, USHORT n, BOOL bIsUpper) + // Führt Rückwaertsersetzung der Dreickesmatrix Mat a nach Mat r durch + // 2 Versionen fuer obere (U) oder untere (L- Unit) Dreiecksmatrizen +{ + short i, j, k; + double fSum; + if (!bIsUpper) // L-Matrix, immer invertierbar + { + MEMat(pR, n); + for (i = 1; i < (short) n; i++) + { + for (j = 0; j < i; j++) + { + fSum = 0.0; + for (k = 0; k < i; k++) + fSum += pA->GetDouble(i,k) * pR->GetDouble(k,j); + pR->PutDouble(-fSum, i, j); + } + } + } + else // U-Matrix + { + for (i = 0; i < (short) n; i++) // Ist invertierbar? + if (fabs(pA->GetDouble(i,i)) < SCdEpsilon) + return FALSE; + pR->FillDoubleLowerLeft(0.0, n-1); // untere Haelfte + pR->PutDouble(1.0/pA->GetDouble(n-1, n-1), n-1, n-1); // n-1, n-1 + for (i = (short) n-2; i >= 0; i--) + { + for (j = (short) n-1; j > i; j--) + { + fSum = 0.0; + for (k = (short) n-1; k > i; k--) + fSum += pA->GetDouble(i, k) * pR->GetDouble(k, j); + pR->PutDouble(-fSum/pA->GetDouble(i, i), i, j); + } + fSum = 0.0; // Hauptdiagonale: + for (k = (short) n-1; k > i; k--) + fSum += pA->GetDouble(i, k) * pR->GetDouble(k, j); + pR->PutDouble((1.0-fSum)/pA->GetDouble(i, i), i, i); + } + } + return TRUE; +} + +BOOL ScInterpreter::ScMatLUP(ScMatrix* mA, USHORT m, USHORT p, + ScMatrix* mL, ScMatrix* mU, ScMatrix* mP, + ULONG& rPermutCounter, BOOL& bIsInvertable) + // Returnwert = False <=> Matrixarray voll + // BIsInvertable = False: <= mA hat nicht Rang m +{ + USHORT nMatInd1, nMatInd2, nMatInd3, nMatInd4, nMatInd5; + USHORT i, j; + if (m == 1) + { + mL->PutDouble(1.0,0,0); + for (j = 0; j < p; j++) + if (fabs(mA->GetDouble(0, j)) >= SCdEpsilon) + break; + if (j == p) + { + bIsInvertable = FALSE; + return TRUE; + } + MEMat(mP, p); + if (j > 0 && j < p) + { + mP->PutDouble(0.0, 0, 0); + mP->PutDouble(1.0, j, 0); + mP->PutDouble(0.0, j, j); + mP->PutDouble(1.0, 0, j); + rPermutCounter++; + } + MFastMult(mA, mP, mU, m, p, p); + } + else + { + USHORT md2 = m/2; + ScMatrix* mB = GetNewMat(md2, p, nMatInd1); + ScMatrix* mC = GetNewMat(md2, p, nMatInd2); + ScMatrix* mL1 = GetNewMat(md2, md2, nMatInd3); + ScMatrix* mU1 = GetNewMat(md2, p, nMatInd4); + ScMatrix* mP1 = GetNewMat(p, p, nMatInd5); + if (!mB || !mC || !mL1 || !mU1 || !mP1 ) + return FALSE; + for (i = 0; i < md2; i++) + { + for (j = 0; j < p; j++) + { + mB->PutDouble(mA->GetDouble(i, j), i, j); + mC->PutDouble(mA->GetDouble(md2+i,j), i, j); + } + } + if (!ScMatLUP(mB, md2, p, mL1, mU1, mP1, rPermutCounter, bIsInvertable)) + return FALSE; + if (!bIsInvertable) + { + ResetNewMat(nMatInd5); + ResetNewMat(nMatInd4); + ResetNewMat(nMatInd3); + ResetNewMat(nMatInd2); + ResetNewMat(nMatInd1); + delete mP1; + delete mU1; + delete mL1; + delete mC; + delete mB; + return TRUE; + } + USHORT nMatInd6, nMatInd7, nMatInd8, nMatInd9, nMatInd10; + USHORT nMatInd11, nMatInd12, nMatInd13; + ScMatrix* mE = GetNewMat(md2, md2, nMatInd6); + ScMatrix* mF = GetNewMat(md2, md2, nMatInd7); + ScMatrix* mEInv = GetNewMat(md2, md2, nMatInd8); + ScMatrix* mG = GetNewMat(md2, p, nMatInd9); + ScMatrix* mGs = GetNewMat(md2, p - md2, nMatInd10); + ScMatrix* mU2 = GetNewMat(md2, p - md2, nMatInd11); + ScMatrix* mP2 = GetNewMat(p - md2, p - md2, nMatInd12); + if (!mP2 || !mU2 || !mGs|| !mG || !mEInv || !mF || !mE) + return FALSE; + MFastTrans(mP1, mP, p, p); // mP = mP1 hoch -1 + ScMatrix* mD = mB; // mB wird nicht mehr gebraucht + MFastMult(mC, mP, mD, md2, p, p); + for (i = 0; i < md2; i++) + { + for (j = 0; j < md2; j++) + { + mE->PutDouble(mU1->GetDouble(i, j), i, j); + mF->PutDouble(mD->GetDouble(i, j), i, j); + } + } + BOOL bEInvok = MFastBackSubst(mE, mEInv, md2, TRUE); // MeInv = E hoch -1 + if (!bEInvok) + { + bIsInvertable = FALSE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd11); + ResetNewMat(nMatInd10); + ResetNewMat(nMatInd9); + ResetNewMat(nMatInd8); + ResetNewMat(nMatInd7); + ResetNewMat(nMatInd6); + ResetNewMat(nMatInd5); + ResetNewMat(nMatInd4); + ResetNewMat(nMatInd3); + ResetNewMat(nMatInd2); + ResetNewMat(nMatInd1); + delete mP2; + delete mU2; + delete mGs; + delete mG; + delete mEInv; + delete mF; + delete mE; + delete mP1; + delete mU1; + delete mL1; + delete mC; + delete mB; + return TRUE; + } + ScMatrix* mFEInv = mE; // mE wird nicht mehr gebraucht. + MFastMult(mF, mEInv, mFEInv, md2, md2, md2); + ScMatrix* mFEInvU1 = mC; // mC wird nicht mehr gebraucht + MFastMult(mFEInv, mU1, mFEInvU1, md2, md2, p); + MFastSub(mD, mFEInvU1, mG, md2, p); + for (i = 0; i < md2; i++) + { + for (j = 0; j < p-md2; j++) + mGs->PutDouble(mG->GetDouble(i, md2+j), i, j); + } + ScMatrix* mL2 = mF; // mF wird nicht mehr gebraucht + if (!ScMatLUP(mGs, md2, p - md2, mL2, mU2, mP2, rPermutCounter, bIsInvertable)) + return FALSE; + if (!bIsInvertable) + { + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd11); + ResetNewMat(nMatInd10); + ResetNewMat(nMatInd9); + ResetNewMat(nMatInd8); + ResetNewMat(nMatInd7); + ResetNewMat(nMatInd6); + ResetNewMat(nMatInd5); + ResetNewMat(nMatInd4); + ResetNewMat(nMatInd3); + ResetNewMat(nMatInd2); + ResetNewMat(nMatInd1); + delete mP2; + delete mU2; + delete mGs; + delete mG; + delete mEInv; + delete mF; + delete mE; + delete mP1; + delete mU1; + delete mL1; + delete mC; + delete mB; + return TRUE; + } + ScMatrix* mP3 = GetNewMat(p, p, nMatInd13); + if (!mP3) + return FALSE; + MEMat(mP3, p); + for (i = md2; i < p; i++) + { + for (j = md2; j < p; j++) + mP3->PutDouble(mP2->GetDouble(i-md2, j-md2), i, j); + } + MFastMult(mP3, mP1, mP, p, p, p); // Ergebnis P !! + ScMatrix* mP3Inv = mP1; // mP1 wird nicht mehr gebraucht; + MFastTrans(mP3, mP3Inv, p, p); + ScMatrix* mH = mD; // mD wird nicht mehr gebraucht + MFastMult(mU1, mP3Inv, mH, md2, p, p); + MEMat(mL, m); // Ergebnis L : + for (i = 0; i < md2; i++) + { + for (j = 0; j < i; j++) + mL->PutDouble(mL1->GetDouble(i, j), i, j); + } + for (i = md2; i < m; i++) + for (j = md2; j < i; j++) + mL->PutDouble(mL2->GetDouble(i-md2, j-md2), i, j); + for (i = md2; i < m; i++) + for (j = 0; j < md2; j++) + mL->PutDouble(mFEInv->GetDouble(i-md2, j), i, j); + // Ergebnis U: + mU->FillDoubleLowerLeft(0.0, m-1); + for (i = 0; i < md2; i++) + for (j = i; j < p; j++) + mU->PutDouble(mH->GetDouble(i, j), i, j); + for (i = md2; i < m; i++) + for (j = i; j < p; j++) + mU->PutDouble(mU2->GetDouble(i - md2, j - md2), i, j); + ResetNewMat(nMatInd13); // alle wieder freigeben; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd11); + ResetNewMat(nMatInd10); + ResetNewMat(nMatInd9); + ResetNewMat(nMatInd8); + ResetNewMat(nMatInd7); + ResetNewMat(nMatInd6); + ResetNewMat(nMatInd5); + ResetNewMat(nMatInd4); + ResetNewMat(nMatInd3); + ResetNewMat(nMatInd2); + ResetNewMat(nMatInd1); + delete mP3; + delete mP2; + delete mU2; + delete mGs; + delete mG; + delete mEInv; + delete mF; + delete mE; + delete mP1; + delete mU1; + delete mL1; + delete mC; + delete mB; + } + return TRUE; +} + +void ScInterpreter::ScMatDet() +{ + if ( MustHaveParamCount( GetByte(), 1 ) ) + { + USHORT nMatInd; + ScMatrix* pMat = GetMatrix(nMatInd); + if (!pMat) + { + SetIllegalParameter(); + return; + } + if ( !pMat->IsNumeric() ) + { + SetNoValue(); + return; + } + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + if ( nC != nR || nC == 0 || (ULONG) nC * nC > ScMatrix::GetElementsMax() ) + SetIllegalParameter(); + else + { + double fVal = log((double)nC) / log(2.0); + if (fVal - floor(fVal) != 0.0) + fVal = floor(fVal) + 1.0; + USHORT nDim = (USHORT) pow(2.0, fVal); + USHORT nMatInd1, nMatInd2, nMatInd3; + USHORT nMatInd4 = MAX_ANZ_MAT; + ScMatrix* pU = GetNewMat(nDim, nDim, nMatInd1); + ScMatrix* pL = GetNewMat(nDim, nDim, nMatInd2); + ScMatrix* pP = GetNewMat(nDim, nDim, nMatInd3); + ScMatrix* pA; + if (nC == nDim) + pA = pMat; + else + { + pA = GetNewMat(nDim, nDim, nMatInd4); + MEMat(pA, nDim); + for (USHORT i = 0; i < nC; i++) + for (USHORT j = 0; j < nC; j++) + { + pA->PutDouble(pMat->GetDouble(i, j), i, j); + } + } + ULONG nPermutCounter = 0; + BOOL bIsInvertable = TRUE; + BOOL bOk = ScMatLUP(pA, nDim, nDim, pL, pU, pP, + nPermutCounter, bIsInvertable); + ResetNewMat(nMatInd4); + ResetNewMat(nMatInd3); + ResetNewMat(nMatInd2); + if (nC != nDim) + delete pA; + delete pP; + delete pL; + if (bOk) + { + if (!bIsInvertable) + PushInt(0); + else + { + double fDet = 1.0; + for (USHORT i = 0; i < nC; i++) + fDet *= pU->GetDouble(i, i); + if (nPermutCounter % 2 != 0) + fDet *= -1.0; + PushDouble(fDet); + } + } + else + { + SetError(errCodeOverflow); + PushInt(0); + } + ResetNewMat(nMatInd1); + delete pU; + } + } +} + +void ScInterpreter::ScMatInv() +{ + if ( MustHaveParamCount( GetByte(), 1 ) ) + { + USHORT nMatInd; + ScMatrix* pMat = GetMatrix(nMatInd); + if (!pMat) + { + SetIllegalParameter(); + return; + } + if ( !pMat->IsNumeric() ) + { + SetNoValue(); + return; + } + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + if ( nC != nR || nC == 0 || (ULONG) nC * nC > ScMatrix::GetElementsMax() ) + SetIllegalParameter(); + else + { + double fVal = log((double)nC) / log(2.0); + if (fVal - floor(fVal) != 0.0) + fVal = floor(fVal) + 1.0; + USHORT nDim = (USHORT) pow(2.0, fVal); + USHORT nMatInd1, nMatInd2, nMatInd3; + USHORT nMatInd4 = MAX_ANZ_MAT; + ScMatrix* pU = GetNewMat(nDim, nDim, nMatInd1); + ScMatrix* pL = GetNewMat(nDim, nDim, nMatInd2); + ScMatrix* pP = GetNewMat(nDim, nDim, nMatInd3); + ScMatrix* pA; + if (nC == nDim) + pA = pMat; + else + { + pA = GetNewMat(nDim, nDim, nMatInd4); + MEMat(pA, nDim); + for (USHORT i = 0; i < nC; i++) + for (USHORT j = 0; j < nC; j++) + { + pA->PutDouble(pMat->GetDouble(i, j), i, j); + } + } + ULONG nPermutCounter = 0; + BOOL bIsInvertable = TRUE; + BOOL bOk = ScMatLUP(pA, nDim, nDim, pL, pU, pP, + nPermutCounter, bIsInvertable); + if (bOk) + { + if (!bIsInvertable) + SetNoValue(); + else + { + USHORT nMatInd5; + ScMatrix* pUInv = GetNewMat(nDim, nDim, nMatInd5); + if (!pUInv) + PushInt(0); + else + { + bOk = MFastBackSubst(pU, pUInv, nDim, TRUE); + if (!bOk) + SetNoValue(); + else + { + ScMatrix* pPInv = pU; + MFastTrans(pP, pPInv, nDim, nDim); + ScMatrix* pPInvUInv = pP; + MFastMult(pPInv, pUInv, pPInvUInv, nDim, nDim, nDim); + ScMatrix* pLInv = pPInv; + MFastBackSubst(pL, pLInv, nDim, FALSE); + if (nDim == nC) + MFastMult(pPInvUInv, pLInv, pMat, nDim, nDim, nDim); + else + { + MFastMult(pPInvUInv, pLInv, pL, nDim, nDim, nDim); + for (USHORT i = 0; i < nC; i++) + for (USHORT j = 0; j < nC; j++) + pMat->PutDouble(pL->GetDouble(i, j), i, j); + } + PushMatrix(pMat); + if (nMatInd != MAX_ANZ_MAT) // vorher neue Matrix + nRetMat = nMatInd; // sonst nRetMat wie vorher + ResetNewMat(nMatInd5); + delete pUInv; + } + } + } + } + else + { + SetError(errCodeOverflow); + PushInt(0); + } + ResetNewMat(nMatInd4); + ResetNewMat(nMatInd3); + ResetNewMat(nMatInd2); + ResetNewMat(nMatInd1); + if (nC != nDim) + delete pA; + delete pP; + delete pL; + delete pU; + } + } +} + +void ScInterpreter::ScMatMult() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + { + USHORT nMatInd1, nMatInd2; + ScMatrix* pMat2 = GetMatrix(nMatInd2); + ScMatrix* pMat1 = GetMatrix(nMatInd1); + ScMatrix* pRMat; + if (pMat1 && pMat2) + { + if ( pMat1->IsNumeric() && pMat2->IsNumeric() ) + { + USHORT nC1, nR1, nC2, nR2; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nC1 != nR2) + SetIllegalParameter(); + else + { + USHORT nMatInd; + pRMat = GetNewMat(nC2, nR1, nMatInd); // Matrixabsicherung + if (pRMat) + { + double sum; + for (USHORT i = 0; i < nR1; i++) + { + for (USHORT j = 0; j < nC2; j++) + { + sum = 0.0; + for (USHORT k = 0; k < nC1; k++) + { + sum += pMat1->GetDouble(k,i)*pMat2->GetDouble(j,k); + } + pRMat->PutDouble(sum, j, i); + } + } + PushMatrix(pRMat); + nRetMat = nMatInd; + } + else + SetNoValue(); + } + } + else + SetNoValue(); + } + else + SetIllegalParameter(); + } +} + +void ScInterpreter::ScMatTrans() +{ + if ( MustHaveParamCount( GetByte(), 1 ) ) + { + USHORT nMatInd, nMatInd1; + ScMatrix* pMat = GetMatrix(nMatInd); + ScMatrix* pRMat; + if (pMat) + { + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + pRMat = GetNewMat(nR, nC, nMatInd1); + pMat->MatTrans(*pRMat); + PushMatrix(pRMat); + nRetMat = nMatInd1; + } + else + SetIllegalParameter(); + } +} + +/*N*/ ScMatrix* ScInterpreter::MatAdd(ScMatrix* pMat1, ScMatrix* pMat2) +/*N*/ { +/*N*/ USHORT nC1, nR1, nC2, nR2, nMinC, nMinR, i, j; +/*N*/ pMat1->GetDimensions(nC1, nR1); +/*N*/ pMat2->GetDimensions(nC2, nR2); +/*N*/ if (nC1 < nC2) +/*N*/ nMinC = nC1; +/*N*/ else +/*N*/ nMinC = nC2; +/*N*/ if (nR1 < nR2) +/*N*/ nMinR = nR1; +/*N*/ else +/*N*/ nMinR = nR2; +/*N*/ USHORT nMatInd; +/*N*/ ScMatrix* pResMat = GetNewMat(nMinC, nMinR, nMatInd); +/*N*/ if (pResMat) +/*N*/ { +/*N*/ for (i = 0; i < nMinC; i++) +/*N*/ { +/*N*/ for (j = 0; j < nMinR; j++) +/*N*/ { +/*N*/ if (pMat1->IsValueOrEmpty(i,j) && pMat2->IsValueOrEmpty(i,j)) +/*N*/ pResMat->PutDouble( ::rtl::math::approxAdd( pMat1->GetDouble(i,j), +/*N*/ pMat2->GetDouble(i,j)), i, j); +/*N*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString( +/*N*/ STR_NO_VALUE), i, j); +/*N*/ } +/*N*/ } +/*N*/ nRetMat = nMatInd; +/*N*/ } +/*N*/ return pResMat; +/*N*/ } + +ScMatrix* ScInterpreter::MatSub(ScMatrix* pMat1, ScMatrix* pMat2) +{ + USHORT nC1, nR1, nC2, nR2, nMinC, nMinR, i, j; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nC1 < nC2) + nMinC = nC1; + else + nMinC = nC2; + if (nR1 < nR2) + nMinR = nR1; + else + nMinR = nR2; + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(nMinC, nMinR, nMatInd); + if (pResMat) + { + for (i = 0; i < nMinC; i++) + { + for (j = 0; j < nMinR; j++) + { + if (pMat1->IsValueOrEmpty(i,j) && pMat2->IsValueOrEmpty(i,j)) + pResMat->PutDouble( ::rtl::math::approxSub( pMat1->GetDouble(i,j), + pMat2->GetDouble(i,j)), i, j); + else + pResMat->PutString(ScGlobal::GetRscString( + STR_NO_VALUE), i, j); + } + } + nRetMat = nMatInd; + } + return pResMat; +} + +/*N*/ ScMatrix* ScInterpreter::MatMul(ScMatrix* pMat1, ScMatrix* pMat2) +/*N*/ { +/*N*/ USHORT nC1, nR1, nC2, nR2, nMinC, nMinR, i, j; +/*N*/ pMat1->GetDimensions(nC1, nR1); +/*N*/ pMat2->GetDimensions(nC2, nR2); +/*N*/ if (nC1 < nC2) +/*N*/ nMinC = nC1; +/*N*/ else +/*N*/ nMinC = nC2; +/*N*/ if (nR1 < nR2) +/*N*/ nMinR = nR1; +/*N*/ else +/*N*/ nMinR = nR2; +/*N*/ USHORT nMatInd; +/*N*/ ScMatrix* pResMat = GetNewMat(nMinC, nMinR, nMatInd); +/*N*/ if (pResMat) +/*N*/ { +/*N*/ for (i = 0; i < nMinC; i++) +/*N*/ { +/*N*/ for (j = 0; j < nMinR; j++) +/*N*/ { +/*N*/ if (pMat1->IsValueOrEmpty(i,j) && pMat2->IsValueOrEmpty(i,j)) +/*N*/ pResMat->PutDouble(pMat1->GetDouble(i,j) * +/*N*/ pMat2->GetDouble(i,j), i, j); +/*N*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString( +/*N*/ STR_NO_VALUE), i, j); +/*N*/ } +/*N*/ } +/*N*/ nRetMat = nMatInd; +/*N*/ } +/*N*/ return pResMat; +/*N*/ } + +ScMatrix* ScInterpreter::MatDiv(ScMatrix* pMat1, ScMatrix* pMat2) +{ + USHORT nC1, nR1, nC2, nR2, nMinC, nMinR, i, j; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nC1 < nC2) + nMinC = nC1; + else + nMinC = nC2; + if (nR1 < nR2) + nMinR = nR1; + else + nMinR = nR2; + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(nMinC, nMinR, nMatInd); + if (pResMat) + { + for (i = 0; i < nMinC; i++) + { + for (j = 0; j < nMinR; j++) + { + if (pMat1->IsValueOrEmpty(i,j) && pMat2->IsValueOrEmpty(i,j)) + pResMat->PutDouble(pMat1->GetDouble(i,j) / + pMat2->GetDouble(i,j), i, j); + else + pResMat->PutString(ScGlobal::GetRscString( + STR_NO_VALUE), i, j); + } + } + nRetMat = nMatInd; + } + return pResMat; +} + +ScMatrix* ScInterpreter::MatPow(ScMatrix* pMat1, ScMatrix* pMat2) +{ + USHORT nC1, nR1, nC2, nR2, nMinC, nMinR, i, j; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nC1 < nC2) + nMinC = nC1; + else + nMinC = nC2; + if (nR1 < nR2) + nMinR = nR1; + else + nMinR = nR2; + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(nMinC, nMinR, nMatInd); + if (pResMat) + { + for (i = 0; i < nMinC; i++) + { + for (j = 0; j < nMinR; j++) + { + if (pMat1->IsValueOrEmpty(i,j) && pMat2->IsValueOrEmpty(i,j)) + pResMat->PutDouble(pow(pMat1->GetDouble(i,j), + pMat2->GetDouble(i,j)), i, j); + else + pResMat->PutString(ScGlobal::GetRscString( + STR_NO_VALUE), i, j); + } + } + nRetMat = nMatInd; + } + return pResMat; +} + +ScMatrix* ScInterpreter::MatConcat(ScMatrix* pMat1, ScMatrix* pMat2) +{ + USHORT nC1, nR1, nC2, nR2, nMinC, nMinR, i, j; + pMat1->GetDimensions(nC1, nR1); + pMat2->GetDimensions(nC2, nR2); + if (nC1 < nC2) + nMinC = nC1; + else + nMinC = nC2; + if (nR1 < nR2) + nMinR = nR1; + else + nMinR = nR2; + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(nMinC, nMinR, nMatInd); + if (pResMat) + { + for (i = 0; i < nMinC; i++) + { + for (j = 0; j < nMinR; j++) + { + if (pMat1->IsString(i,j) && pMat2->IsString(i,j)) + { + String aTmp( pMat1->GetString(i,j) ); + aTmp += pMat2->GetString(i,j); + pResMat->PutString( aTmp , i, j); + } + else + pResMat->PutString(ScGlobal::GetRscString( + STR_NO_VALUE), i, j); +//! TODO: Xcl does concatenate value strings + } + } + nRetMat = nMatInd; + } + return pResMat; +} + + +// fuer DATE, TIME, DATETIME +/*N*/ void lcl_GetDiffDateTimeFmtType( short& nFuncFmt, short nFmt1, short nFmt2 ) +/*N*/ { +/*N*/ if ( nFmt1 != NUMBERFORMAT_UNDEFINED || nFmt2 != NUMBERFORMAT_UNDEFINED ) +/*N*/ { +/*N*/ if ( nFmt1 == nFmt2 ) +/*N*/ { +/*N*/ if ( nFmt1 == NUMBERFORMAT_TIME || nFmt1 == NUMBERFORMAT_DATETIME ) +/*N*/ nFuncFmt = NUMBERFORMAT_TIME; // Zeiten ergeben Zeit +/*N*/ // else: nichts besonderes, Zahl (Datum - Datum := Tage) +/*N*/ } +/*N*/ else if ( nFmt1 == NUMBERFORMAT_UNDEFINED ) +/*N*/ nFuncFmt = nFmt2; // z.B. Datum + Tage := Datum +/*N*/ else if ( nFmt2 == NUMBERFORMAT_UNDEFINED ) +/*N*/ nFuncFmt = nFmt1; +/*N*/ else +/*N*/ { +/*N*/ if ( nFmt1 == NUMBERFORMAT_DATE || nFmt2 == NUMBERFORMAT_DATE || +/*N*/ nFmt1 == NUMBERFORMAT_DATETIME || nFmt2 == NUMBERFORMAT_DATETIME ) +/*N*/ { +/*N*/ if ( nFmt1 == NUMBERFORMAT_TIME || nFmt2 == NUMBERFORMAT_TIME ) +/*N*/ nFuncFmt = NUMBERFORMAT_DATETIME; // Datum + Zeit +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScInterpreter::ScAdd() +/*N*/ { +/*N*/ ScMatrix* pMat1 = NULL; +/*N*/ ScMatrix* pMat2 = NULL; +/*N*/ double fVal1 = 0.0, fVal2 = 0.0; +/*N*/ USHORT nMatInd1, nMatInd2; +/*N*/ short nFmt1, nFmt2; +/*N*/ nFmt1 = nFmt2 = NUMBERFORMAT_UNDEFINED; +/*N*/ short nFmtCurrencyType = nCurFmtType; +/*N*/ ULONG nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ short nFmtPercentType = nCurFmtType; +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*N*/ pMat2 = GetMatrix(nMatInd2); +/*N*/ else +/*N*/ { +/*N*/ fVal2 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_DATE : +/*N*/ case NUMBERFORMAT_TIME : +/*N*/ case NUMBERFORMAT_DATETIME : +/*N*/ nFmt2 = nCurFmtType; +/*N*/ break; +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ case NUMBERFORMAT_PERCENT : +/*N*/ nFmtPercentType = NUMBERFORMAT_PERCENT; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*N*/ pMat1 = GetMatrix(nMatInd1); +/*N*/ else +/*N*/ { +/*N*/ fVal1 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_DATE : +/*N*/ case NUMBERFORMAT_TIME : +/*N*/ case NUMBERFORMAT_DATETIME : +/*N*/ nFmt1 = nCurFmtType; +/*N*/ break; +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ case NUMBERFORMAT_PERCENT : +/*N*/ nFmtPercentType = NUMBERFORMAT_PERCENT; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if (pMat1 && pMat2) +/*N*/ { +/*N*/ ScMatrix* pResMat = MatAdd(pMat1, pMat2); +/*N*/ if (!pResMat) +/*?*/ SetNoValue(); +/*N*/ else +/*N*/ PushMatrix(pResMat); +/*N*/ } +/*N*/ else if (pMat1 || pMat2) +/*N*/ { +/*?*/ double fVal; +/*?*/ ScMatrix* pMat = pMat1; +/*?*/ if (!pMat) +/*?*/ { +/*?*/ fVal = fVal1; +/*?*/ pMat = pMat2; +/*?*/ } +/*?*/ else +/*?*/ fVal = fVal2; +/*?*/ USHORT nC, nR; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ USHORT nMatInd; +/*?*/ ScMatrix* pResMat = GetNewMat(nC, nR, nMatInd); +/*?*/ if (pResMat) +/*?*/ { +/*?*/ ULONG nCount = (ULONG) nC * nR; +/*?*/ for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ { +/*?*/ if (pMat->IsValue(i)) +/*?*/ pResMat->PutDouble( ::rtl::math::approxAdd( pMat->GetDouble(i), fVal), i); +/*?*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*?*/ } +/*?*/ PushMatrix(pResMat); +/*?*/ nRetMat = nMatInd; +/*?*/ } +/*?*/ else +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*N*/ PushDouble( ::rtl::math::approxAdd( fVal1, fVal2 ) ); +/*N*/ if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY ) +/*N*/ { +/*N*/ nFuncFmtType = nFmtCurrencyType; +/*N*/ nFuncFmtIndex = nFmtCurrencyIndex; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ lcl_GetDiffDateTimeFmtType( nFuncFmtType, nFmt1, nFmt2 ); +/*N*/ if ( nFmtPercentType == NUMBERFORMAT_PERCENT && nFuncFmtType == NUMBERFORMAT_NUMBER ) +/*N*/ nFuncFmtType = NUMBERFORMAT_PERCENT; +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ScAmpersand() +/*N*/ { +/*N*/ ScMatrix* pMat1 = NULL; +/*N*/ ScMatrix* pMat2 = NULL; +/*N*/ String sStr1, sStr2; +/*N*/ USHORT nMatInd1, nMatInd2; +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*?*/ pMat2 = GetMatrix(nMatInd2); +/*N*/ else +/*N*/ sStr2 = GetString(); +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*?*/ pMat1 = GetMatrix(nMatInd1); +/*N*/ else +/*N*/ sStr1 = GetString(); +/*N*/ if (pMat1 && pMat2) +/*N*/ { +/*?*/ ScMatrix* pResMat = MatConcat(pMat1, pMat2); +/*?*/ if (!pResMat) +/*?*/ SetNoValue(); +/*?*/ else +/*?*/ PushMatrix(pResMat); +/*N*/ } +/*N*/ else if (pMat1 || pMat2) +/*N*/ { +/*?*/ String sStr; +/*?*/ BOOL bFlag; +/*?*/ ScMatrix* pMat = pMat1; +/*?*/ if (!pMat) +/*?*/ { +/*?*/ sStr = sStr1; +/*?*/ pMat = pMat2; +/*?*/ bFlag = TRUE; // double - Matrix +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ sStr = sStr2; +/*?*/ bFlag = FALSE; // Matrix - double +/*?*/ } +/*?*/ USHORT nC, nR; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ USHORT nMatInd; +/*?*/ ScMatrix* pResMat = GetNewMat(nC, nR, nMatInd); +/*?*/ if (pResMat) +/*?*/ { +/*?*/ ULONG nCount = (ULONG) nC * nR; +/*?*/ if (bFlag) +/*?*/ { +/*?*/ for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ if (!pMat->IsValue(i)) +/*?*/ { +/*?*/ String sS = sStr; +/*?*/ sS += pMat->GetString(i); +/*?*/ pResMat->PutString(sS, i); +/*?*/ } +/*?*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ if (!pMat->IsValue(i)) +/*?*/ { +/*?*/ String sS = pMat->GetString(i); +/*?*/ sS += sStr; +/*?*/ pResMat->PutString(sS, i); +/*?*/ } +/*?*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*?*/ } +/*?*/ PushMatrix(pResMat); +/*?*/ nRetMat = nMatInd; +/*?*/ } +/*?*/ else +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( CheckStringResultLen( sStr1, sStr2 ) ) +/*N*/ sStr1 += sStr2; +/*N*/ PushString(sStr1); +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ScSub() +/*N*/ { +/*N*/ ScMatrix* pMat1 = NULL; +/*N*/ ScMatrix* pMat2 = NULL; +/*N*/ double fVal1 = 0.0, fVal2 = 0.0; +/*N*/ USHORT nMatInd1, nMatInd2; +/*N*/ short nFmt1, nFmt2; +/*N*/ nFmt1 = nFmt2 = NUMBERFORMAT_UNDEFINED; +/*N*/ short nFmtCurrencyType = nCurFmtType; +/*N*/ ULONG nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ short nFmtPercentType = nCurFmtType; +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*N*/ pMat2 = GetMatrix(nMatInd2); +/*N*/ else +/*N*/ { +/*N*/ fVal2 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_DATE : +/*N*/ case NUMBERFORMAT_TIME : +/*N*/ case NUMBERFORMAT_DATETIME : +/*N*/ nFmt2 = nCurFmtType; +/*N*/ break; +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ case NUMBERFORMAT_PERCENT : +/*N*/ nFmtPercentType = NUMBERFORMAT_PERCENT; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*?*/ pMat1 = GetMatrix(nMatInd1); +/*N*/ else +/*N*/ { +/*N*/ fVal1 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_DATE : +/*N*/ case NUMBERFORMAT_TIME : +/*N*/ case NUMBERFORMAT_DATETIME : +/*N*/ nFmt1 = nCurFmtType; +/*N*/ break; +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ case NUMBERFORMAT_PERCENT : +/*N*/ nFmtPercentType = NUMBERFORMAT_PERCENT; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if (pMat1 && pMat2) +/*N*/ { +/*?*/ ScMatrix* pResMat = MatSub(pMat1, pMat2); +/*?*/ if (!pResMat) +/*?*/ SetNoValue(); +/*?*/ else +/*?*/ PushMatrix(pResMat); +/*N*/ } +/*N*/ else if (pMat1 || pMat2) +/*N*/ { +/*N*/ double fVal; +/*N*/ BOOL bFlag; +/*N*/ ScMatrix* pMat = pMat1; +/*N*/ if (!pMat) +/*N*/ { +/*N*/ fVal = fVal1; +/*N*/ pMat = pMat2; +/*N*/ bFlag = TRUE; // double - Matrix +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ fVal = fVal2; +/*N*/ bFlag = FALSE; // Matrix - double +/*N*/ } +/*N*/ USHORT nC, nR; +/*N*/ pMat->GetDimensions(nC, nR); +/*N*/ USHORT nMatInd; +/*N*/ ScMatrix* pResMat = GetNewMat(nC, nR, nMatInd); +/*N*/ if (pResMat) +/*N*/ { // mehr klammern wg. compiler macke +/*N*/ ULONG nCount = (ULONG) nC * nR; +/*N*/ if (bFlag) +/*N*/ { for ( ULONG i = 0; i < nCount; i++ ) +/*N*/ { if (pMat->IsValue(i)) +/*N*/ pResMat->PutDouble( ::rtl::math::approxSub( fVal, pMat->GetDouble(i)), i); +/*N*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ { for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ { if (pMat->IsValue(i)) +/*?*/ pResMat->PutDouble( ::rtl::math::approxSub( pMat->GetDouble(i), fVal), i); +/*?*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*?*/ } +/*N*/ } +/*N*/ PushMatrix(pResMat); +/*N*/ nRetMat = nMatInd; +/*N*/ } +/*N*/ else +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*N*/ PushDouble( ::rtl::math::approxSub( fVal1, fVal2 ) ); +/*N*/ if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY ) +/*N*/ { +/*N*/ nFuncFmtType = nFmtCurrencyType; +/*N*/ nFuncFmtIndex = nFmtCurrencyIndex; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ lcl_GetDiffDateTimeFmtType( nFuncFmtType, nFmt1, nFmt2 ); +/*N*/ if ( nFmtPercentType == NUMBERFORMAT_PERCENT && nFuncFmtType == NUMBERFORMAT_NUMBER ) +/*N*/ nFuncFmtType = NUMBERFORMAT_PERCENT; +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ScMul() +/*N*/ { +/*N*/ ScMatrix* pMat1 = NULL; +/*N*/ ScMatrix* pMat2 = NULL; +/*N*/ double fVal1 = 0.0, fVal2 = 0.0; +/*N*/ USHORT nMatInd1, nMatInd2; +/*N*/ short nFmtCurrencyType = nCurFmtType; +/*N*/ ULONG nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*N*/ pMat2 = GetMatrix(nMatInd2); +/*N*/ else +/*N*/ { +/*N*/ fVal2 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*N*/ pMat1 = GetMatrix(nMatInd1); +/*N*/ else +/*N*/ { +/*N*/ fVal1 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if (pMat1 && pMat2) +/*N*/ { +/*N*/ ScMatrix* pResMat = MatMul(pMat1, pMat2); +/*N*/ if (!pResMat) +/*?*/ SetNoValue(); +/*N*/ else +/*N*/ PushMatrix(pResMat); +/*N*/ } +/*N*/ else if (pMat1 || pMat2) +/*N*/ { +/*N*/ double fVal; +/*N*/ ScMatrix* pMat = pMat1; +/*N*/ if (!pMat) +/*N*/ { +/*N*/ fVal = fVal1; +/*N*/ pMat = pMat2; +/*N*/ } +/*N*/ else +/*N*/ fVal = fVal2; +/*N*/ USHORT nC, nR; +/*N*/ pMat->GetDimensions(nC, nR); +/*N*/ USHORT nMatInd; +/*N*/ ScMatrix* pResMat = GetNewMat(nC, nR, nMatInd); +/*N*/ if (pResMat) +/*N*/ { +/*N*/ ULONG nCount = (ULONG) nC * nR; +/*N*/ for ( ULONG i = 0; i < nCount; i++ ) +/*N*/ if (pMat->IsValue(i)) +/*N*/ pResMat->PutDouble(pMat->GetDouble(i)*fVal, i); +/*N*/ else +/*N*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*N*/ PushMatrix(pResMat); +/*N*/ nRetMat = nMatInd; +/*N*/ } +/*N*/ else +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*N*/ PushDouble(fVal1 * fVal2); +/*N*/ if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY ) +/*N*/ { +/*N*/ nFuncFmtType = nFmtCurrencyType; +/*N*/ nFuncFmtIndex = nFmtCurrencyIndex; +/*N*/ } +/*N*/ } + +/*N*/ void ScInterpreter::ScDiv() +/*N*/ { +/*N*/ ScMatrix* pMat1 = NULL; +/*N*/ ScMatrix* pMat2 = NULL; +/*N*/ double fVal1 = 0.0, fVal2 = 0.0; +/*N*/ USHORT nMatInd1, nMatInd2; +/*N*/ short nFmtCurrencyType = nCurFmtType; +/*N*/ ULONG nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ short nFmtCurrencyType2 = NUMBERFORMAT_UNDEFINED; +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*?*/ pMat2 = GetMatrix(nMatInd2); +/*N*/ else +/*N*/ { +/*N*/ fVal2 = GetDouble(); +/*N*/ // hier kein Currency uebernehmen, 123kg/456DM sind nicht DM +/*N*/ nFmtCurrencyType2 = nCurFmtType; +/*N*/ } +/*N*/ MatrixDoubleRefToMatrix(); +/*N*/ if ( GetStackType() == svMatrix ) +/*?*/ pMat1 = GetMatrix(nMatInd1); +/*N*/ else +/*N*/ { +/*N*/ fVal1 = GetDouble(); +/*N*/ switch ( nCurFmtType ) +/*N*/ { +/*N*/ case NUMBERFORMAT_CURRENCY : +/*N*/ nFmtCurrencyType = nCurFmtType; +/*N*/ nFmtCurrencyIndex = nCurFmtIndex; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ if (pMat1 && pMat2) +/*N*/ { +/*?*/ ScMatrix* pResMat = MatDiv(pMat1, pMat2); +/*?*/ if (!pResMat) +/*?*/ SetNoValue(); +/*?*/ else +/*?*/ PushMatrix(pResMat); +/*N*/ } +/*N*/ else if (pMat1 || pMat2) +/*N*/ { +/*?*/ double fVal; +/*?*/ BOOL bFlag; +/*?*/ ScMatrix* pMat = pMat1; +/*?*/ if (!pMat) +/*?*/ { +/*?*/ fVal = fVal1; +/*?*/ pMat = pMat2; +/*?*/ bFlag = TRUE; // double - Matrix +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ fVal = fVal2; +/*?*/ bFlag = FALSE; // Matrix - double +/*?*/ } +/*?*/ USHORT nC, nR; +/*?*/ pMat->GetDimensions(nC, nR); +/*?*/ USHORT nMatInd; +/*?*/ ScMatrix* pResMat = GetNewMat(nC, nR, nMatInd); +/*?*/ if (pResMat) +/*?*/ { +/*?*/ ULONG nCount = (ULONG) nC * nR; +/*?*/ if (bFlag) +/*?*/ { for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ if (pMat->IsValue(i)) +/*?*/ pResMat->PutDouble(fVal / pMat->GetDouble(i), i); +/*?*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*?*/ } +/*?*/ else +/*?*/ { for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ if (pMat->IsValue(i)) +/*?*/ pResMat->PutDouble(pMat->GetDouble(i) / fVal, i); +/*?*/ else +/*?*/ pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); +/*?*/ } +/*?*/ PushMatrix(pResMat); +/*?*/ nRetMat = nMatInd; +/*?*/ } +/*?*/ else +/*?*/ SetNoValue(); +/*N*/ } +/*N*/ else +/*N*/ PushDouble(fVal1 / fVal2); +/*N*/ if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY && nFmtCurrencyType2 != NUMBERFORMAT_CURRENCY ) +/*N*/ { // auch DM/DM ist nicht DM bzw. DEM/EUR nicht DEM +/*N*/ nFuncFmtType = nFmtCurrencyType; +/*N*/ nFuncFmtIndex = nFmtCurrencyIndex; +/*N*/ } +/*N*/ } + +void ScInterpreter::ScPower() +{ + if ( MustHaveParamCount( GetByte(), 2 ) ) + ScPow(); +} + +void ScInterpreter::ScPow() +{ + ScMatrix* pMat1 = NULL; + ScMatrix* pMat2 = NULL; + double fVal1 = 0.0, fVal2 = 0.0; + USHORT nMatInd1, nMatInd2; + MatrixDoubleRefToMatrix(); + if ( GetStackType() == svMatrix ) + pMat2 = GetMatrix(nMatInd2); + else + fVal2 = GetDouble(); + MatrixDoubleRefToMatrix(); + if ( GetStackType() == svMatrix ) + pMat1 = GetMatrix(nMatInd1); + else + fVal1 = GetDouble(); + if (pMat1 && pMat2) + { + ScMatrix* pResMat = MatPow(pMat1, pMat2); + if (!pResMat) + SetNoValue(); + else + PushMatrix(pResMat); + } + else if (pMat1 || pMat2) + { + double fVal; + BOOL bFlag; + ScMatrix* pMat = pMat1; + if (!pMat) + { + fVal = fVal1; + pMat = pMat2; + bFlag = TRUE; // double - Matrix + } + else + { + fVal = fVal2; + bFlag = FALSE; // Matrix - double + } + USHORT nC, nR; + pMat->GetDimensions(nC, nR); + USHORT nMatInd; + ScMatrix* pResMat = GetNewMat(nC, nR, nMatInd); + if (pResMat) + { + ULONG nCount = (ULONG) nC * nR; + if (bFlag) + { for ( ULONG i = 0; i < nCount; i++ ) + if (pMat->IsValue(i)) + pResMat->PutDouble(pow(fVal,pMat->GetDouble(i)), i); + else + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); + } + else + { for ( ULONG i = 0; i < nCount; i++ ) + if (pMat->IsValue(i)) + pResMat->PutDouble(pow(pMat->GetDouble(i),fVal), i); + else + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i); + } + PushMatrix(pResMat); + nRetMat = nMatInd; + } + else + SetNoValue(); + } + else + PushDouble(pow(fVal1,fVal2)); +} + +void ScInterpreter::ScSumProduct() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 1, 30 ) ) + return; + + ScMatrix* pMat1 = NULL; + ScMatrix* pMat2 = NULL; + ScMatrix* pMat = NULL; + USHORT nMatInd1, nMatInd2; + pMat2 = GetMatrix(nMatInd2); + if (!pMat2) + { + SetIllegalParameter(); + return; + } + USHORT nC, nR, nC1, nR1; + pMat2->GetDimensions(nC, nR); + pMat = pMat2; + for (USHORT i = 1; i < nParamCount; i++) + { + pMat1 = GetMatrix(nMatInd1); + if (!pMat1) + { + SetIllegalParameter(); + return; + } + pMat1->GetDimensions(nC1, nR1); + if (nC1 != nC || nR1 != nR) + { + SetNoValue(); + return; + } + ScMatrix* pResMat = MatMul(pMat1, pMat); + if (!pResMat) + { + SetNoValue(); + return; + } + else + pMat = pResMat; + } + double fSum = 0.0; + ULONG nCount = pMat->GetElementCount(); + for (ULONG j = 0; j < nCount; j++) + if (!pMat->IsString(j)) + fSum += pMat->GetDouble(j); + PushDouble(fSum); +} + +void ScInterpreter::ScSumX2MY2() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + + ScMatrix* pMat1 = NULL; + ScMatrix* pMat2 = NULL; + USHORT nMatInd1, nMatInd2, i, j; + pMat2 = GetMatrix(nMatInd2); + pMat1 = GetMatrix(nMatInd1); + if (!pMat2 || !pMat1) + { + SetIllegalParameter(); + return; + } + USHORT nC2, nR2, nC1, nR1; + pMat2->GetDimensions(nC2, nR2); + pMat1->GetDimensions(nC1, nR1); + if (nC1 != nC2 || nR1 != nR2) + { + SetNoValue(); + return; + } + double fVal, fSum = 0.0; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fVal = pMat1->GetDouble(i,j); + fSum += fVal * fVal; + fVal = pMat2->GetDouble(i,j); + fSum -= fVal * fVal; + } + PushDouble(fSum); +} + +void ScInterpreter::ScSumX2DY2() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + + ScMatrix* pMat1 = NULL; + ScMatrix* pMat2 = NULL; + USHORT nMatInd1, nMatInd2, i, j; + pMat2 = GetMatrix(nMatInd2); + pMat1 = GetMatrix(nMatInd1); + if (!pMat2 || !pMat1) + { + SetIllegalParameter(); + return; + } + USHORT nC2, nR2, nC1, nR1; + pMat2->GetDimensions(nC2, nR2); + pMat1->GetDimensions(nC1, nR1); + if (nC1 != nC2 || nR1 != nR2) + { + SetNoValue(); + return; + } + double fVal, fSum = 0.0; + for (i = 0; i < nC1; i++) + for (j = 0; j < nR1; j++) + if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j)) + { + fVal = pMat1->GetDouble(i,j); + fSum += fVal * fVal; + fVal = pMat2->GetDouble(i,j); + fSum += fVal * fVal; + } + PushDouble(fSum); +} + +void ScInterpreter::ScSumXMY2() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + + ScMatrix* pMat1 = NULL; + ScMatrix* pMat2 = NULL; + USHORT nMatInd1, nMatInd2; + pMat2 = GetMatrix(nMatInd2); + pMat1 = GetMatrix(nMatInd1); + if (!pMat2 || !pMat1) + { + SetIllegalParameter(); + return; + } + USHORT nC2, nR2, nC1, nR1; + pMat2->GetDimensions(nC2, nR2); + pMat1->GetDimensions(nC1, nR1); + if (nC1 != nC2 || nR1 != nR2) + { + SetNoValue(); + return; + } + ScMatrix* pResMat = MatSub(pMat1, pMat2); + if (!pResMat) + { + SetNoValue(); + return; + } + else + { + double fVal, fSum = 0.0; + ULONG nCount = pResMat->GetElementCount(); + for (ULONG i = 0; i < nCount; i++) + if (!pResMat->IsString(i)) + { + fVal = pResMat->GetDouble(i); + fSum += fVal * fVal; + } + PushDouble(fSum); + } +} + +void ScInterpreter::ScFrequency() +{ + if ( !MustHaveParamCount( GetByte(), 2 ) ) + return; + + USHORT nMatInd; + double* pSortArray1 = NULL; + ULONG nSize1 = 0; + GetSortArray(1, &pSortArray1, nSize1); + if (nGlobalError) + SetNoValue(); + double* pSortArray2 = NULL; + ULONG nSize2 = 0; + GetSortArray(1, &pSortArray2, nSize2); + if (!pSortArray2 || nSize2 == 0 || nGlobalError) + { + if (pSortArray1) + delete pSortArray1; + if (pSortArray2) + delete pSortArray2; + SetNoValue(); + return; + } + ScMatrix* pResMat = GetNewMat(1,(USHORT)nSize1+1,nMatInd); + if (!pResMat) + { + if (pSortArray1) + delete pSortArray1; + if (pSortArray2) + delete pSortArray2; + SetNoValue(); + return; + } + + USHORT j; + ULONG i = 0; + ULONG nCount; + for (j = 0; j < nSize1; j++) + { + nCount = 0; + while (i < nSize2 && pSortArray2[i] <= pSortArray1[j]) + { + nCount++; + i++; + } + pResMat->PutDouble((double) nCount, j); + } + pResMat->PutDouble((double) (nSize2-i), j); + if (pSortArray1) + delete pSortArray1; + if (pSortArray2) + delete pSortArray2; + PushMatrix(pResMat); + nRetMat = nMatInd; +} + +BOOL ScInterpreter::RGetVariances( ScMatrix* pV, ScMatrix* pX, + USHORT nC, USHORT nR, BOOL bSwapColRow, BOOL bZeroConstant ) +{ // multiple Regression: Varianzen der Koeffizienten + // bSwapColRow==TRUE : Koeffizienten in Zeilen statt Spalten angeordnet + USHORT i, j, k, nMatInd; + double sum; + ScMatrix* pC = GetNewMat(nC, nC, nMatInd); + if ( !pC ) + return FALSE; + // X transformiert mit X multipziert, X'X Matrix + if ( !bZeroConstant ) + { // in der X-Designmatrix existiert ein gedachtes X0j==1 + if ( bSwapColRow ) + { + for ( i=0; i<nC; i++ ) + { + for ( j=0; j<nC; j++ ) + { + sum = 0.0; + for ( k=0; k<nR; k++ ) + { + sum += (j==0 ? 1 : pX->GetDouble(k,j-1)) + * (i==0 ? 1 : pX->GetDouble(k,i-1)); + } + pC->PutDouble(sum, i, j); + } + } + } + else + { + for ( i=0; i<nC; i++ ) + { + for ( j=0; j<nC; j++ ) + { + sum = 0.0; + for ( k=0; k<nR; k++ ) + { + sum += (j==0 ? 1 : pX->GetDouble(j-1,k)) + * (i==0 ? 1 : pX->GetDouble(i-1,k)); + } + pC->PutDouble(sum, i, j); + } + } + } + } + else + { + if ( bSwapColRow ) + { + for ( i=0; i<nC; i++ ) + { + for ( j=0; j<nC; j++ ) + { + sum = 0.0; + for ( k=0; k<nR; k++ ) + { + sum += pX->GetDouble(k,j) * pX->GetDouble(k,i); + } + pC->PutDouble(sum, i, j); + } + } + } + else + { + for ( i=0; i<nC; i++ ) + { + for ( j=0; j<nC; j++ ) + { + sum = 0.0; + for ( k=0; k<nR; k++ ) + { + sum += pX->GetDouble(j,k) * pX->GetDouble(i,k); + } + pC->PutDouble(sum, i, j); + } + } + } + } + // X'X Inverse + BOOL bOk = TRUE; + USHORT nErr = nGlobalError; + PushMatrix(pC); + BYTE nTmp = cPar; + cPar = 1; + ScMatInv(); + cPar = nTmp; + if ( nGlobalError ) + { + nGlobalError = nErr; + bOk = FALSE; + } + else + { + Pop(); // pC bleibt erhalten + // Varianzen auf der Diagonalen, andere sind Kovarianzen + for (i = 0; i < nC; i++) + pV->PutDouble(pC->GetDouble(i, i), i); + } + delete pC; + ResetNewMat(nMatInd); + return bOk; +} + +void ScInterpreter::ScRGP() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 1, 4 ) ) + return; + BOOL bConstant, bStats; + if (nParamCount == 4) + bStats = GetBool(); + else + bStats = FALSE; + if (nParamCount >= 3) + bConstant = GetBool(); + else + bConstant = TRUE; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMatX; + ScMatrix* pMatY; + if (nParamCount >= 2) + pMatX = GetMatrix(nMatInd2); + else + pMatX = NULL; + pMatY = GetMatrix(nMatInd1); + if (!pMatY) + { + SetIllegalParameter(); + return; + } + BYTE nCase; // 1 = normal, 2,3 = mehrfach + USHORT nCX, nRX, nCY, nRY, M, N; + pMatY->GetDimensions(nCY, nRY); + ULONG nCountY = (ULONG) nCY * nRY; + for ( ULONG i = 0; i < nCountY; i++ ) + if (!pMatY->IsValue(i)) + { + SetIllegalArgument(); + return; + } + if (pMatX) + { + pMatX->GetDimensions(nCX, nRX); + ULONG nCountX = (ULONG) nCX * nRX; + for ( ULONG i = 0; i < nCountX; i++ ) + if (!pMatX->IsValue(i)) + { + SetIllegalArgument(); + return; + } + if (nCX == nCY && nRX == nRY) + nCase = 1; // einfache Regression + else if (nCY != 1 && nRY != 1) + { + SetIllegalParameter(); + return; + } + else if (nCY == 1) + { + if (nRX != nRY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 2; // zeilenweise + N = nRY; + M = nCX; + } + } + else if (nCX != nCY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 3; // spaltenweise + N = nCY; + M = nRX; + } + } + else + { + pMatX = GetNewMat(nCY, nRY, nMatInd2); + if (!pMatX) + { + SetIllegalParameter(); + return; + } + for ( ULONG i = 1; i <= nCountY; i++ ) + pMatX->PutDouble((double)i, i-1); + nCase = 1; + } + USHORT nMatInd; + ScMatrix* pResMat; + if (nCase == 1) + { + if (!bStats) + pResMat = GetNewMat(2,1,nMatInd); + else + pResMat = GetNewMat(2,5,nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nCY; i++) + for (USHORT j = 0; j < nRY; j++) + { + fValX = pMatX->GetDouble(i,j); + fValY = pMatY->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + if (fCount < 1.0) + SetNoValue(); + else + { + double f1 = fCount*fSumXY-fSumX*fSumY; + double fX = fCount*fSumSqrX-fSumX*fSumX; + double b, m; + if (bConstant) + { + b = fSumY/fCount - f1/fX*fSumX/fCount; + m = f1/fX; + } + else + { + b = 0.0; + m = fSumXY/fSumSqrX; + } + pResMat->PutDouble(m, 0, 0); + pResMat->PutDouble(b, 1, 0); + if (bStats) + { + double fY = fCount*fSumSqrY-fSumY*fSumY; + double fSyx = fSumSqrY-b*fSumY-m*fSumXY; + double fR2 = f1*f1/(fX*fY); + pResMat->PutDouble (fR2, 0, 2); + if (fCount < 3.0) + { + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 1 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 1 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3 ); + } + else + { + pResMat->PutDouble(sqrt(fSyx*fCount/(fX*(fCount-2.0))), 0, 1); + pResMat->PutDouble(sqrt(fSyx*fSumSqrX/fX/(fCount-2.0)), 1, 1); + pResMat->PutDouble( + sqrt((fCount*fSumSqrY - fSumY*fSumY - f1*f1/fX)/ + (fCount*(fCount-2.0))), 1, 2); + if (fR2 == 1.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3 ); + else + pResMat->PutDouble(fR2*(fCount-2.0)/(1.0-fR2), 0, 3); + } + pResMat->PutDouble(((double)(nCY*nRY))-2.0, 1, 3); + pResMat->PutDouble(fY/fCount-fSyx, 0, 4); + pResMat->PutDouble(fSyx, 1, 4); + } + } + } + else + { + USHORT nMatInd10, nMatInd12, nMatInd13, i, j, k; + if (!bStats) + pResMat = GetNewMat(M+1,1,nMatInd); + else + pResMat = GetNewMat(M+1,5,nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + BOOL bVariancesOk = TRUE; + ScMatrix* pQ = GetNewMat(M+1, M+2, nMatInd10); + ScMatrix* pE = GetNewMat(M+2, 1, nMatInd12); + ScMatrix* pV = GetNewMat(M+1, 1, nMatInd13); + pE->PutDouble(0.0, M+1); + pQ->FillDouble(0.0, 0, 0, M, M+1); + if (nCase == 2) + { + for (k = 0; k < N; k++) + { + double Yk = pMatY->GetDouble(k); + pE->PutDouble( pE->GetDouble(M+1)+Yk*Yk, M+1 ); + double sumYk = pQ->GetDouble(0, M+1) + Yk; + pQ->PutDouble( sumYk, 0, M+1 ); + pE->PutDouble( sumYk, 0 ); + for (i = 0; i < M; i++) + { + double Xik = pMatX->GetDouble(i,k); + double sumXik = pQ->GetDouble(0, i+1) + Xik; + pQ->PutDouble( sumXik, 0, i+1); + pQ->PutDouble( sumXik, i+1, 0); + double sumXikYk = pQ->GetDouble(i+1, M+1) + Xik * Yk; + pQ->PutDouble( sumXikYk, i+1, M+1); + pE->PutDouble( sumXikYk, i+1); + for (j = i; j < M; j++) + { + double sumXikXjk = pQ->GetDouble(j+1, i+1) + + Xik * pMatX->GetDouble(j,k); + pQ->PutDouble( sumXikXjk, j+1, i+1); + pQ->PutDouble( sumXikXjk, i+1, j+1); + } + } + } + } + else + { + for (k = 0; k < N; k++) + { + double Yk = pMatY->GetDouble(k); + pE->PutDouble( pE->GetDouble(M+1)+Yk*Yk, M+1 ); + double sumYk = pQ->GetDouble(0, M+1) + Yk; + pQ->PutDouble( sumYk, 0, M+1 ); + pE->PutDouble( sumYk, 0 ); + for (i = 0; i < M; i++) + { + double Xki = pMatX->GetDouble(k,i); + double sumXki = pQ->GetDouble(0, i+1) + Xki; + pQ->PutDouble( sumXki, 0, i+1); + pQ->PutDouble( sumXki, i+1, 0); + double sumXkiYk = pQ->GetDouble(i+1, M+1) + Xki * Yk; + pQ->PutDouble( sumXkiYk, i+1, M+1); + pE->PutDouble( sumXkiYk, i+1); + for (j = i; j < M; j++) + { + double sumXkiXkj = pQ->GetDouble(j+1, i+1) + + Xki * pMatX->GetDouble(k,j); + pQ->PutDouble( sumXkiXkj, j+1, i+1); + pQ->PutDouble( sumXkiXkj, i+1, j+1); + } + } + } + } + pQ->PutDouble((double)N, 0, 0); + if (bConstant) + { + USHORT S, L; + for (S = 0; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + delete pV; + ResetNewMat(nMatInd13); + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 0; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 0; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + } + } + else + { + USHORT S, L; + for (S = 1; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + delete pV; + ResetNewMat(nMatInd13); + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 1; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 1; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + pQ->PutDouble(0.0, 0, M+1); // Konstante b + } + } + // mn ... m1, b + for (i = 0; i < M+1; i++) + pResMat->PutDouble(pQ->GetDouble(M-i,M+1), i, 0); + if (bStats) + { + // pE[0] := Sigma i=1...n (Yi) + // pE[k] := Sigma i=1...n (Xki*Yi) + // pE[M+1] := Sigma i=1...n (Yi**2) + // pQ[0,M+1]:= B + // pQ[k,M+1]:= Mk + double fSQR, fSQT, fSQE; + fSQT = pE->GetDouble(M+1) + - pE->GetDouble(0) * pE->GetDouble(0) / (double)N; + fSQR = pE->GetDouble(M+1); + for (i = 0; i < M+1; i++) + fSQR -= pQ->GetDouble(i, M+1) * pE->GetDouble(i); + fSQE = fSQT-fSQR; + // r2 (Bestimmtheitsmass, 0...1) + if (fSQT == 0.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 2); + else + pResMat->PutDouble (fSQE/fSQT, 0, 2); + // ssReg (Regressions-Quadratsumme) + pResMat->PutDouble(fSQE, 0, 4); + // ssResid (Residual-Quadratsumme, Summe der Abweichungsquadrate) + pResMat->PutDouble(fSQR, 1, 4); + for (i = 2; i < 5; i++) + for (j = 2; j < M+1; j++) + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), j, i); + if (bConstant) + { + if (N-M-1 == 0) + { + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2); + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, 1); + } + else + { + double fSE2 = fSQR/(N-M-1); + // sey (Standardfehler des Schaetzwertes y) + pResMat->PutDouble(sqrt(fSE2), 1, 2); + // sen...se1 (Standardfehler der Koeffizienten mn...m1) + // seb (Standardfehler der Konstanten b) + if ( RGetVariances( pV, pMatX, M+1, N, nCase != 2, FALSE ) ) + { + for (i = 0; i < M+1; i++) + pResMat->PutDouble( sqrt(fSE2 * pV->GetDouble(i)), M-i, 1 ); + } + else + { + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), i, 1); + } + } + // F (F-Statistik) + if (fSQR == 0.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3); + else + pResMat->PutDouble(((double)(N-M-1))*fSQE/fSQR/((double)M),0, 3); + // df (Freiheitsgrad) + pResMat->PutDouble(((double)(N-M-1)), 1, 3); + } + else + { + if (N-M == 0) + { + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2); + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, 1); + } + else + { + double fSE2 = fSQR/(N-M); + pResMat->PutDouble(sqrt(fSE2), 1, 2); + if ( RGetVariances( pV, pMatX, M, N, nCase != 2, TRUE ) ) + { + for (i = 0; i < M; i++) + pResMat->PutDouble( sqrt(fSE2 * pV->GetDouble(i)), M-i-1, 1 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), M, 1); + } + else + { + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), i, 1); + } + } + if (fSQR == 0.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3); + else + pResMat->PutDouble(((double)(N-M))*fSQE/fSQR/((double)M),0, 3); + pResMat->PutDouble(((double)(N-M)), 1, 3); + } + } + delete pQ; + delete pE; + delete pV; + ResetNewMat(nMatInd13); + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + } + PushMatrix(pResMat); + nRetMat = nMatInd; +} + +void ScInterpreter::ScRKP() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 1, 4 ) ) + return; + BOOL bConstant, bStats; + if (nParamCount == 4) + bStats = GetBool(); + else + bStats = FALSE; + if (nParamCount >= 3) + bConstant = GetBool(); + else + bConstant = TRUE; + USHORT nMatInd1, nMatInd2; + ScMatrix* pMatX; + ScMatrix* pMatY; + if (nParamCount >= 2) + pMatX = GetMatrix(nMatInd2); + else + pMatX = NULL; + pMatY = GetMatrix(nMatInd1); + if (!pMatY) + { + SetIllegalParameter(); + return; + } + BYTE nCase; // 1 = normal, 2,3 = mehrfach + USHORT nCX, nRX, nCY, nRY, M, N; + pMatY->GetDimensions(nCY, nRY); + ULONG nCountY = (ULONG) nCY * nRY; + ULONG i; + for (i = 0; i < nCountY; i++) + if (!pMatY->IsValue(i)) + { + SetIllegalArgument(); + return; + } + for (i = 0; i < nCountY; i++) + { + if (pMatY->GetDouble(i) <= 0.0) + { + SetIllegalArgument(); + return; + } + else + pMatY->PutDouble(log(pMatY->GetDouble(i)), i); + } + if (pMatX) + { + pMatX->GetDimensions(nCX, nRX); + ULONG nCountX = (ULONG) nCX * nRX; + for (i = 0; i < nCountX; i++) + if (!pMatX->IsValue(i)) + { + SetIllegalArgument(); + return; + } + if (nCX == nCY && nRX == nRY) + nCase = 1; // einfache Regression + else if (nCY != 1 && nRY != 1) + { + SetIllegalParameter(); + return; + } + else if (nCY == 1) + { + if (nRX != nRY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 2; // zeilenweise + N = nRY; + M = nCX; + } + } + else if (nCX != nCY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 3; // spaltenweise + N = nCY; + M = nRX; + } + } + else + { + pMatX = GetNewMat(nCY, nRY, nMatInd2); + if (!pMatX) + { + SetIllegalParameter(); + return; + } + for ( ULONG i = 1; i <= nCountY; i++ ) + pMatX->PutDouble((double)i, i-1); + nCase = 1; + } + USHORT nMatInd; + ScMatrix* pResMat; + if (nCase == 1) + { + if (!bStats) + pResMat = GetNewMat(2,1,nMatInd); + else + pResMat = GetNewMat(2,5,nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nCY; i++) + for (USHORT j = 0; j < nRY; j++) + { + fValX = pMatX->GetDouble(i,j); + fValY = pMatY->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + if (fCount < 1.0) + SetNoValue(); + else + { + double f1 = fCount*fSumXY-fSumX*fSumY; + double fX = fCount*fSumSqrX-fSumX*fSumX; + double b, m; + if (bConstant) + { + b = fSumY/fCount - f1/fX*fSumX/fCount; + m = f1/fX; + } + else + { + b = 0.0; + m = fSumXY/fSumSqrX; + } + pResMat->PutDouble(exp(m), 0, 0); + pResMat->PutDouble(exp(b), 1, 0); + if (bStats) + { + double fY = fCount*fSumSqrY-fSumY*fSumY; + double fSyx = fSumSqrY-b*fSumY-m*fSumXY; + double fR2 = f1*f1/(fX*fY); + pResMat->PutDouble (fR2, 0, 2); + if (fCount < 3.0) + { + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 1 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 1 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3 ); + } + else + { + pResMat->PutDouble(sqrt(fSyx*fCount/(fX*(fCount-2.0))), 0, 1); + pResMat->PutDouble(sqrt(fSyx*fSumSqrX/fX/(fCount-2.0)), 1, 1); + pResMat->PutDouble( + sqrt((fCount*fSumSqrY - fSumY*fSumY - f1*f1/fX)/ + (fCount*(fCount-2.0))), 1, 2); + if (fR2 == 1.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3 ); + else + pResMat->PutDouble(fR2*(fCount-2.0)/(1.0-fR2), 0, 3); + } + pResMat->PutDouble(((double)(nCY*nRY))-2.0, 1, 3); + pResMat->PutDouble(fY/fCount-fSyx, 0, 4); + pResMat->PutDouble(fSyx, 1, 4); + } + } + } + else + { + USHORT nMatInd10, nMatInd12, nMatInd13, i, j, k; + if (!bStats) + pResMat = GetNewMat(M+1,1,nMatInd); + else + pResMat = GetNewMat(M+1,5,nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + ScMatrix* pQ = GetNewMat(M+1, M+2, nMatInd10); + ScMatrix* pE = GetNewMat(M+2, 1, nMatInd12); + ScMatrix* pV = GetNewMat(M+1, 1, nMatInd13); + pE->PutDouble(0.0, M+1); + pQ->FillDouble(0.0, 0, 0, M, M+1); + if (nCase == 2) + { + for (k = 0; k < N; k++) + { + double Yk = pMatY->GetDouble(k); + pE->PutDouble( pE->GetDouble(M+1)+Yk*Yk, M+1 ); + double sumYk = pQ->GetDouble(0, M+1) + Yk; + pQ->PutDouble( sumYk, 0, M+1 ); + pE->PutDouble( sumYk, 0 ); + for (i = 0; i < M; i++) + { + double Xik = pMatX->GetDouble(i,k); + double sumXik = pQ->GetDouble(0, i+1) + Xik; + pQ->PutDouble( sumXik, 0, i+1); + pQ->PutDouble( sumXik, i+1, 0); + double sumXikYk = pQ->GetDouble(i+1, M+1) + Xik * Yk; + pQ->PutDouble( sumXikYk, i+1, M+1); + pE->PutDouble( sumXikYk, i+1); + for (j = i; j < M; j++) + { + double sumXikXjk = pQ->GetDouble(j+1, i+1) + + Xik * pMatX->GetDouble(j,k); + pQ->PutDouble( sumXikXjk, j+1, i+1); + pQ->PutDouble( sumXikXjk, i+1, j+1); + } + } + } + } + else + { + for (k = 0; k < N; k++) + { + double Yk = pMatY->GetDouble(k); + pE->PutDouble( pE->GetDouble(M+1)+Yk*Yk, M+1 ); + double sumYk = pQ->GetDouble(0, M+1) + Yk; + pQ->PutDouble( sumYk, 0, M+1 ); + pE->PutDouble( sumYk, 0 ); + for (i = 0; i < M; i++) + { + double Xki = pMatX->GetDouble(k,i); + double sumXki = pQ->GetDouble(0, i+1) + Xki; + pQ->PutDouble( sumXki, 0, i+1); + pQ->PutDouble( sumXki, i+1, 0); + double sumXkiYk = pQ->GetDouble(i+1, M+1) + Xki * Yk; + pQ->PutDouble( sumXkiYk, i+1, M+1); + pE->PutDouble( sumXkiYk, i+1); + for (j = i; j < M; j++) + { + double sumXkiXkj = pQ->GetDouble(j+1, i+1) + + Xki * pMatX->GetDouble(k,j); + pQ->PutDouble( sumXkiXkj, j+1, i+1); + pQ->PutDouble( sumXkiXkj, i+1, j+1); + } + } + } + } + pQ->PutDouble((double)N, 0, 0); + if (bConstant) + { + USHORT S, L; + for (S = 0; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + delete pV; + ResetNewMat(nMatInd13); + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 0; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 0; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + } + } + else + { + USHORT S, L; + for (S = 1; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + delete pV; + ResetNewMat(nMatInd13); + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 1; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 1; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + pQ->PutDouble(0.0, 0, M+1); + } + } + for (i = 0; i < M+1; i++) + pResMat->PutDouble(exp(pQ->GetDouble(M-i,M+1)), i, 0); + if (bStats) + { + double fSQR, fSQT, fSQE; + fSQT = pE->GetDouble(M+1)-pE->GetDouble(0)*pE->GetDouble(0)/((double)N); + fSQR = pE->GetDouble(M+1); + for (i = 0; i < M+1; i++) + fSQR += -pQ->GetDouble(i, M+1)*pE->GetDouble(i); + fSQE = fSQT-fSQR; + if (fSQT == 0.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 2); + else + pResMat->PutDouble (fSQE/fSQT, 0, 2); + pResMat->PutDouble(fSQE, 0, 4); + pResMat->PutDouble(fSQR, 1, 4); + for (i = 2; i < 5; i++) + for (j = 2; j < M+1; j++) + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), j, i); + if (bConstant) + { + if (N-M-1 == 0) + { + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2); + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, 1); + } + else + { + double fSE2 = fSQR/(N-M-1); + pResMat->PutDouble(sqrt(fSE2), 1, 2); + if ( RGetVariances( pV, pMatX, M+1, N, nCase != 2, FALSE ) ) + { + for (i = 0; i < M+1; i++) + pResMat->PutDouble( sqrt(fSE2 * pV->GetDouble(i)), M-i, 1 ); + } + else + { + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), i, 1); + } + } + if (fSQR == 0.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3); + else + pResMat->PutDouble(((double)(N-M-1))*fSQE/fSQR/((double)M),0, 3); + pResMat->PutDouble(((double)(N-M-1)), 1, 3); + } + else + { + if (N-M == 0) + { + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2); + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, 1); + } + else + { + double fSE2 = fSQR/(N-M); + pResMat->PutDouble(sqrt(fSE2), 1, 2); + if ( RGetVariances( pV, pMatX, M, N, nCase != 2, TRUE ) ) + { + for (i = 0; i < M; i++) + pResMat->PutDouble( sqrt(fSE2 * pV->GetDouble(i)), M-i-1, 1 ); + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), M, 1); + } + else + { + for (i = 0; i < M+1; i++) + pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), i, 1); + } + } + if (fSQR == 0.0) + pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3); + else + pResMat->PutDouble(((double)(N-M))*fSQE/fSQR/((double)M),0, 3); + pResMat->PutDouble(((double)(N-M)), 1, 3); + } + } + delete pQ; + delete pE; + delete pV; + ResetNewMat(nMatInd13); + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + } + PushMatrix(pResMat); + nRetMat = nMatInd; +} + + +void ScInterpreter::ScTrend() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 1, 4 ) ) + return; + BOOL bConstant; + if (nParamCount == 4) + bConstant = GetBool(); + else + bConstant = TRUE; + USHORT nMatInd1, nMatInd2, nMatInd3; + ScMatrix* pMatX; + ScMatrix* pMatY; + ScMatrix* pMatNewX; + if (nParamCount >= 3) + pMatNewX = GetMatrix(nMatInd3); + else + pMatNewX = NULL; + if (nParamCount >= 2) + pMatX = GetMatrix(nMatInd2); + else + pMatX = NULL; + pMatY = GetMatrix(nMatInd1); + if (!pMatY) + { + SetIllegalParameter(); + return; + } + BYTE nCase; // 1 = normal, 2,3 = mehrfach + USHORT nCX, nRX, nCY, nRY, M, N; + pMatY->GetDimensions(nCY, nRY); + ULONG nCountY = (ULONG) nCY * nRY; + ULONG i; + for (i = 0; i < nCountY; i++) + if (!pMatY->IsValue(i)) + { + SetIllegalArgument(); + return; + } + if (pMatX) + { + pMatX->GetDimensions(nCX, nRX); + ULONG nCountX = (ULONG) nCX * nRX; + for (i = 0; i < nCountX; i++) + if (!pMatX->IsValue(i)) + { + SetIllegalArgument(); + return; + } + if (nCX == nCY && nRX == nRY) + nCase = 1; // einfache Regression + else if (nCY != 1 && nRY != 1) + { + SetIllegalParameter(); + return; + } + else if (nCY == 1) + { + if (nRX != nRY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 2; // zeilenweise + N = nRY; + M = nCX; + } + } + else if (nCX != nCY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 3; // spaltenweise + N = nCY; + M = nRX; + } + } + else + { + pMatX = GetNewMat(nCY, nRY, nMatInd2); + nCX = nCY; + nRX = nRY; + if (!pMatX) + { + SetIllegalParameter(); + return; + } + for (i = 1; i <= nCountY; i++) + pMatX->PutDouble((double)i, i-1); + nCase = 1; + } + USHORT nCXN, nRXN; + ULONG nCountXN; + if (!pMatNewX) + { + nCXN = nCX; + nRXN = nRX; + nCountXN = (ULONG) nCXN * nRXN; + pMatNewX = pMatX; + } + else + { + pMatNewX->GetDimensions(nCXN, nRXN); + if ((nCase == 2 && nCX != nCXN) || (nCase == 3 && nRX != nRXN)) + { + SetIllegalArgument(); + return; + } + nCountXN = (ULONG) nCXN * nRXN; + for ( ULONG i = 0; i < nCountXN; i++ ) + if (!pMatNewX->IsValue(i)) + { + SetIllegalArgument(); + return; + } + } + USHORT nMatInd; + ScMatrix* pResMat; + if (nCase == 1) + { + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nCY; i++) + for (USHORT j = 0; j < nRY; j++) + { + fValX = pMatX->GetDouble(i,j); + fValY = pMatY->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + if (fCount < 1.0) + { + SetNoValue(); + return; + } + else + { + double f1 = fCount*fSumXY-fSumX*fSumY; + double fX = fCount*fSumSqrX-fSumX*fSumX; + double b, m; + if (bConstant) + { + b = fSumY/fCount - f1/fX*fSumX/fCount; + m = f1/fX; + } + else + { + b = 0.0; + m = fSumXY/fSumSqrX; + } + pResMat = GetNewMat(nCXN, nRXN, nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + for (i = 0; i < nCountXN; i++) + pResMat->PutDouble(pMatNewX->GetDouble(i)*m+b, i); + } + } + else + { + USHORT nMatInd10, nMatInd12, i, j, k; + ScMatrix* pQ = GetNewMat(M+1, M+2, nMatInd10); + ScMatrix* pE = GetNewMat(M+2, 1, nMatInd12); + pE->PutDouble(0.0, M+1); + pQ->FillDouble(0.0, 0, 0, M, M+1); + if (nCase == 2) + { + for (k = 0; k < N; k++) + { + pE->PutDouble( + pE->GetDouble(M+1)+pMatY->GetDouble(k)*pMatY->GetDouble(k), M+1); + pQ->PutDouble(pQ->GetDouble(0, M+1) + pMatY->GetDouble(k), 0, M+1); + pE->PutDouble(pQ->GetDouble(0, M+1), 0); + for (i = 0; i < M; i++) + { + pQ->PutDouble(pQ->GetDouble(0, i+1)+pMatX->GetDouble(i,k), 0, i+1); + pQ->PutDouble(pQ->GetDouble(0, i+1), i+1, 0); + pQ->PutDouble(pQ->GetDouble(i+1, M+1) + + pMatX->GetDouble(i,k)*pMatY->GetDouble(k), i+1, M+1); + pE->PutDouble(pQ->GetDouble(i+1, M+1), i+1); + for (j = i; j < M; j++) + { + pQ->PutDouble(pQ->GetDouble(j+1, i+1) + + pMatX->GetDouble(i,k)*pMatX->GetDouble(j,k), j+1, i+1); + pQ->PutDouble(pQ->GetDouble(j+1, i+1), i+1, j+1); + } + } + } + } + else + { + for (k = 0; k < N; k++) + { + pE->PutDouble( + pE->GetDouble(M+1)+pMatY->GetDouble(k)*pMatY->GetDouble(k), M+1); + pQ->PutDouble(pQ->GetDouble(0, M+1) + pMatY->GetDouble(k), 0, M+1); + pE->PutDouble(pQ->GetDouble(0, M+1), 0); + for (i = 0; i < M; i++) + { + pQ->PutDouble(pQ->GetDouble(0, i+1)+pMatX->GetDouble(k,i), 0, i+1); + pQ->PutDouble(pQ->GetDouble(0, i+1), i+1, 0); + pQ->PutDouble(pQ->GetDouble(i+1, M+1) + + pMatX->GetDouble(k,i)*pMatY->GetDouble(k), i+1, M+1); + pE->PutDouble(pQ->GetDouble(i+1, M+1), i+1); + for (j = i; j < M; j++) + { + pQ->PutDouble(pQ->GetDouble(j+1, i+1) + + pMatX->GetDouble(k, i)*pMatX->GetDouble(k, j), j+1, i+1); + pQ->PutDouble(pQ->GetDouble(j+1, i+1), i+1, j+1); + } + } + } + } + pQ->PutDouble((double)N, 0, 0); + if (bConstant) + { + USHORT S, L; + for (S = 0; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 0; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 0; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + } + } + else + { + USHORT S, L; + for (S = 1; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 1; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 1; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + pQ->PutDouble(0.0, 0, M+1); + } + } + if (nCase == 2) + { + pResMat = GetNewMat(1, nRXN, nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + double fVal; + for (i = 0; i < nRXN; i++) + { + fVal = pQ->GetDouble(0, M+1); + for (j = 0; j < M; j++) + fVal += pQ->GetDouble(j+1, M+1)*pMatNewX->GetDouble(j, i); + pResMat->PutDouble(fVal, i); + } + } + else + { + pResMat = GetNewMat(nCXN, 1, nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + double fVal; + for (i = 0; i < nCXN; i++) + { + fVal = pQ->GetDouble(0, M+1); + for (j = 0; j < M; j++) + fVal += pQ->GetDouble(j+1, M+1)*pMatNewX->GetDouble(i, j); + pResMat->PutDouble(fVal, i); + } + } + delete pQ; + delete pE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + } + PushMatrix(pResMat); + nRetMat = nMatInd; +} + +void ScInterpreter::ScGrowth() +{ + BYTE nParamCount = GetByte(); + if ( !MustHaveParamCount( nParamCount, 1, 4 ) ) + return; + BOOL bConstant; + if (nParamCount == 4) + bConstant = GetBool(); + else + bConstant = TRUE; + USHORT nMatInd1, nMatInd2, nMatInd3; + ScMatrix* pMatX; + ScMatrix* pMatY; + ScMatrix* pMatNewX; + if (nParamCount >= 3) + pMatNewX = GetMatrix(nMatInd3); + else + pMatNewX = NULL; + if (nParamCount >= 2) + pMatX = GetMatrix(nMatInd2); + else + pMatX = NULL; + pMatY = GetMatrix(nMatInd1); + if (!pMatY) + { + SetIllegalParameter(); + return; + } + BYTE nCase; // 1 = normal, 2,3 = mehrfach + USHORT nCX, nRX, nCY, nRY, M, N; + pMatY->GetDimensions(nCY, nRY); + ULONG nCountY = (ULONG) nCY * nRY; + ULONG i; + for (i = 0; i < nCountY; i++) + if (!pMatY->IsValue(i)) + { + SetIllegalArgument(); + return; + } + for (i = 0; i < nCountY; i++) + { + if (pMatY->GetDouble(i) <= 0.0) + { + SetIllegalArgument(); + return; + } + else + pMatY->PutDouble(log(pMatY->GetDouble(i)), i); + } + if (pMatX) + { + pMatX->GetDimensions(nCX, nRX); + ULONG nCountX = (ULONG) nCX * nRX; + for ( ULONG i = 0; i < nCountX; i++ ) + if (!pMatX->IsValue(i)) + { + SetIllegalArgument(); + return; + } + if (nCX == nCY && nRX == nRY) + nCase = 1; // einfache Regression + else if (nCY != 1 && nRY != 1) + { + SetIllegalParameter(); + return; + } + else if (nCY == 1) + { + if (nRX != nRY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 2; // zeilenweise + N = nRY; + M = nCX; + } + } + else if (nCX != nCY) + { + SetIllegalParameter(); + return; + } + else + { + nCase = 3; // spaltenweise + N = nCY; + M = nRX; + } + } + else + { + pMatX = GetNewMat(nCY, nRY, nMatInd2); + nCX = nCY; + nRX = nRY; + if (!pMatX) + { + SetIllegalParameter(); + return; + } + for (i = 1; i <= nCountY; i++) + pMatX->PutDouble((double)i, i-1); + nCase = 1; + } + USHORT nCXN, nRXN; + ULONG nCountXN; + if (!pMatNewX) + { + nCXN = nCX; + nRXN = nRX; + nCountXN = (ULONG) nCXN * nRXN; + pMatNewX = pMatX; + } + else + { + pMatNewX->GetDimensions(nCXN, nRXN); + if ((nCase == 2 && nCX != nCXN) || (nCase == 3 && nRX != nRXN)) + { + SetIllegalArgument(); + return; + } + nCountXN = (ULONG) nCXN * nRXN; + for ( ULONG i = 0; i < nCountXN; i++ ) + if (!pMatNewX->IsValue(i)) + { + SetIllegalArgument(); + return; + } + } + USHORT nMatInd; + ScMatrix* pResMat; + if (nCase == 1) + { + double fCount = 0.0; + double fSumX = 0.0; + double fSumSqrX = 0.0; + double fSumY = 0.0; + double fSumSqrY = 0.0; + double fSumXY = 0.0; + double fValX, fValY; + for (USHORT i = 0; i < nCY; i++) + for (USHORT j = 0; j < nRY; j++) + { + fValX = pMatX->GetDouble(i,j); + fValY = pMatY->GetDouble(i,j); + fSumX += fValX; + fSumSqrX += fValX * fValX; + fSumY += fValY; + fSumSqrY += fValY * fValY; + fSumXY += fValX*fValY; + fCount++; + } + if (fCount < 1.0) + { + SetNoValue(); + return; + } + else + { + double f1 = fCount*fSumXY-fSumX*fSumY; + double fX = fCount*fSumSqrX-fSumX*fSumX; + double b, m; + if (bConstant) + { + b = fSumY/fCount - f1/fX*fSumX/fCount; + m = f1/fX; + } + else + { + b = 0.0; + m = fSumXY/fSumSqrX; + } + pResMat = GetNewMat(nCXN, nRXN, nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + for (i = 0; i < nCountXN; i++) + pResMat->PutDouble(exp(pMatNewX->GetDouble(i)*m+b), i); + } + } + else + { + USHORT nMatInd10, nMatInd12, i, j, k; + ScMatrix* pQ = GetNewMat(M+1, M+2, nMatInd10); + ScMatrix* pE = GetNewMat(M+2, 1, nMatInd12); + pE->PutDouble(0.0, M+1); + pQ->FillDouble(0.0, 0, 0, M, M+1); + if (nCase == 2) + { + for (k = 0; k < N; k++) + { + pE->PutDouble( + pE->GetDouble(M+1)+pMatY->GetDouble(k)*pMatY->GetDouble(k), M+1); + pQ->PutDouble(pQ->GetDouble(0, M+1) + pMatY->GetDouble(k), 0, M+1); + pE->PutDouble(pQ->GetDouble(0, M+1), 0); + for (i = 0; i < M; i++) + { + pQ->PutDouble(pQ->GetDouble(0, i+1)+pMatX->GetDouble(i,k), 0, i+1); + pQ->PutDouble(pQ->GetDouble(0, i+1), i+1, 0); + pQ->PutDouble(pQ->GetDouble(i+1, M+1) + + pMatX->GetDouble(i,k)*pMatY->GetDouble(k), i+1, M+1); + pE->PutDouble(pQ->GetDouble(i+1, M+1), i+1); + for (j = i; j < M; j++) + { + pQ->PutDouble(pQ->GetDouble(j+1, i+1) + + pMatX->GetDouble(i,k)*pMatX->GetDouble(j,k), j+1, i+1); + pQ->PutDouble(pQ->GetDouble(j+1, i+1), i+1, j+1); + } + } + } + } + else + { + for (k = 0; k < N; k++) + { + pE->PutDouble( + pE->GetDouble(M+1)+pMatY->GetDouble(k)*pMatY->GetDouble(k), M+1); + pQ->PutDouble(pQ->GetDouble(0, M+1) + pMatY->GetDouble(k), 0, M+1); + pE->PutDouble(pQ->GetDouble(0, M+1), 0); + for (i = 0; i < M; i++) + { + pQ->PutDouble(pQ->GetDouble(0, i+1)+pMatX->GetDouble(k,i), 0, i+1); + pQ->PutDouble(pQ->GetDouble(0, i+1), i+1, 0); + pQ->PutDouble(pQ->GetDouble(i+1, M+1) + + pMatX->GetDouble(k,i)*pMatY->GetDouble(k), i+1, M+1); + pE->PutDouble(pQ->GetDouble(i+1, M+1), i+1); + for (j = i; j < M; j++) + { + pQ->PutDouble(pQ->GetDouble(j+1, i+1) + + pMatX->GetDouble(k, i)*pMatX->GetDouble(k, j), j+1, i+1); + pQ->PutDouble(pQ->GetDouble(j+1, i+1), i+1, j+1); + } + } + } + } + pQ->PutDouble((double)N, 0, 0); + if (bConstant) + { + USHORT S, L; + for (S = 0; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 0; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 0; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 0; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + } + } + else + { + USHORT S, L; + for (S = 1; S < M+1; S++) + { + i = S; + while (i < M+1 && pQ->GetDouble(i, S) == 0.0) + i++; + if (i >= M+1) + { + SetNoValue(); + delete pQ; + delete pE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + return; + } + double fVal; + for (L = 1; L < M+2; L++) + { + fVal = pQ->GetDouble(S, L); + pQ->PutDouble(pQ->GetDouble(i, L), S, L); + pQ->PutDouble(fVal, i, L); + } + fVal = 1.0/pQ->GetDouble(S, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L); + for (i = 1; i < M+1; i++) + { + if (i != S) + { + fVal = -pQ->GetDouble(i, S); + for (L = 1; L < M+2; L++) + pQ->PutDouble( + pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L); + } + } + pQ->PutDouble(0.0, 0, M+1); + } + } + if (nCase == 2) + { + pResMat = GetNewMat(1, nRXN, nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + double fVal; + for (i = 0; i < nRXN; i++) + { + fVal = pQ->GetDouble(0, M+1); + for (j = 0; j < M; j++) + fVal += pQ->GetDouble(j+1, M+1)*pMatNewX->GetDouble(j, i); + pResMat->PutDouble(exp(fVal), i); + } + } + else + { + pResMat = GetNewMat(nCXN, 1, nMatInd); + if (!pResMat) + { + SetIllegalParameter(); + return; + } + double fVal; + for (i = 0; i < nCXN; i++) + { + fVal = pQ->GetDouble(0, M+1); + for (j = 0; j < M; j++) + fVal += pQ->GetDouble(j+1, M+1)*pMatNewX->GetDouble(i, j); + pResMat->PutDouble(exp(fVal), i); + } + } + delete pQ; + delete pE; + ResetNewMat(nMatInd12); + ResetNewMat(nMatInd10); + } + PushMatrix(pResMat); + nRetMat = nMatInd; +} + +/*N*/ void ScInterpreter::ScMatRef() +/*N*/ { +/*N*/ // Falls Deltarefs drin sind... +/*N*/ Push( (ScToken&) *pCur ); +/*N*/ ScAddress aAdr; +/*N*/ PopSingleRef( aAdr ); +/*N*/ ScFormulaCell* pCell = (ScFormulaCell*) GetCell( aAdr ); +/*N*/ if( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) +/*N*/ { +/*N*/ ScMatrix* pMat; +/*N*/ pCell->GetMatrix( &pMat ); +/*N*/ if( pMat ) +/*N*/ { +/*N*/ USHORT nCl, nRw; +/*N*/ pMat->GetDimensions( nCl, nRw ); +/*N*/ USHORT nC = aPos.Col() - aAdr.Col(); +/*N*/ USHORT nR = aPos.Row() - aAdr.Row(); +/*N*/ if (nC < nCl && nR < nRw) +/*N*/ { +/*N*/ BOOL bIsString; +/*N*/ const MatValue* pMatVal = pMat->Get(nC, nR, bIsString); +/*N*/ if (bIsString) +/*?*/ PushString( pMatVal->GetString() ); +/*N*/ else +/*N*/ { +/*N*/ PushDouble(pMatVal->fVal); +/*N*/ pDok->GetNumberFormatInfo( nCurFmtType, nCurFmtIndex, aAdr, *pCell ); +/*N*/ nFuncFmtType = nCurFmtType; +/*N*/ nFuncFmtIndex = nCurFmtIndex; +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ SetNV(); +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ // Ist gar keine Ergebnis-Matrix, dann bitte den Wert holen! +/*?*/ USHORT nErr = pCell->GetErrCode(); +/*?*/ SetError( nErr ); +/*?*/ if( pCell->IsValue() ) +/*?*/ PushDouble( pCell->GetValue() ); +/*?*/ else +/*?*/ { +/*?*/ String aVal; +/*?*/ pCell->GetString( aVal ); +/*?*/ PushString( aVal ); +/*?*/ } +/*?*/ pDok->GetNumberFormatInfo( nCurFmtType, nCurFmtIndex, aAdr, *pCell ); +/*?*/ nFuncFmtType = nCurFmtType; +/*?*/ nFuncFmtIndex = nCurFmtIndex; +/*?*/ } +/*N*/ } +/*N*/ else +/*N*/ SetError( errNoRef ); +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_interpr6.cxx b/binfilter/bf_sc/source/core/tool/sc_interpr6.cxx new file mode 100644 index 000000000000..398e1adc94d6 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_interpr6.cxx @@ -0,0 +1,182 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <basegfx/numeric/ftools.hxx> + + +#include "interpre.hxx" +namespace binfilter { + + +//! #66556# for os2icci3 this function MUST be compiled without optimizations, +//! otherwise it won't work at all or even worse will produce false results! +double ScInterpreter::GetGammaDist(double x, double alpha, double beta) +{ + if (x == 0.0) + return 0.0; + + x /= beta; + double gamma = alpha; + + double c = 0.918938533204672741; + double d[10] = { + 0.833333333333333333E-1, + -0.277777777777777778E-2, + 0.793650793650793651E-3, + -0.595238095238095238E-3, + 0.841750841750841751E-3, + -0.191752691752691753E-2, + 0.641025641025641025E-2, + -0.295506535947712418E-1, + 0.179644372368830573, + -0.139243221690590111E1 + }; + + int ipr = 6; + + double dx = x; + double dgamma = gamma; + int maxit = 10000; + + double z = dgamma; + double den = 1.0; + while ( z < 10.0 ) //! approx? + { + den *= z; + z += 1.0; + } + + double z2 = z*z; + double z3 = z*z2; + double z4 = z2*z2; + double z5 = z2*z3; + double a = ( z - 0.5 ) * log(z) - z + c; + double b = d[0]/z + d[1]/z3 + d[2]/z5 + d[3]/(z2*z5) + d[4]/(z4*z5) + + d[5]/(z*z5*z5) + d[6]/(z3*z5*z5) + d[7]/(z5*z5*z5) + d[8]/(z2*z5*z5*z5); + // double g = exp(a+b) / den; + + double sum = 1.0 / dgamma; + double term = 1.0 / dgamma; + double cut1 = dx - dgamma; + double cut2 = dx * 10000000000.0; + + for ( int i=1; i<=maxit; i++ ) + { + double ai = i; + term = dx * term / ( dgamma + ai ); + sum += term; + double cutoff = cut1 + ( cut2 * term / sum ); + if ( ai > cutoff ) + { + double t = sum; + // return pow( dx, dgamma ) * exp( -dx ) * t / g; + return exp( dgamma * log(dx) - dx - a - b ) * t * den; + } + } + +// DBG_ERROR("GetGammaDist bricht nicht ab"); + + return 1.0; // should not happen ... +} + +#if 0 +//! this algorithm doesn't work right in every cases! +double ScInterpreter::GetGammaDist(double x, double alpha, double beta) +{ + if (x == 0.0) + return 0.0; + double fEps = 1.0E-6; + double fGamma; + double G = GetLogGamma(alpha); + x /= beta; + G = alpha*log(x)-x-G; + if (x <= alpha+1.0) + { + if (x < fEps || fabs(G) >= 500.0) + fGamma = 0.0; + else + { + double fF = 1.0/alpha; + double fS = fF; + double anum = alpha; + for (USHORT i = 0; i < 100; i++) + { + anum += 1.0; + fF *= x/anum; + fS += fF; + if (fF < fEps) + i = 100; + } + fGamma = fS*exp(G); + } + } + else + { + if (fabs(G) >= 500.0) + fGamma = 1.0; + else + { + double a0, b0, a1, b1, cf, fnorm, a2j, a2j1, cfnew; + a0 = 0.0; b0 = 1.0; a1 = 1.0; + b1 = x; + cf = fEps; + fnorm = 1.0; + cfnew = 0.0; + for (USHORT j = 1; j <= 100; j++) + { + a2j = ((double) j) - alpha; + a2j1 = (double) j; + a0 = (a1+a2j*a0); // *fnorm; + b0 = (b1+a2j*b0); // *fnorm; + a1 = (x*a0+a2j1*a1)*fnorm; + b1 = (x*b0+a2j1*b1)*fnorm; + if (b1 != 0.0) + { + fnorm = 1.0/b1; + cfnew = a1*fnorm; + if (fabs(cf-cfnew)/cf < fEps) + j = 101; + else + cf = cfnew; + } + } + fGamma = 1.0 - exp(G)*cfnew; + } + } + return fGamma; +} +#endif + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_optutil.cxx b/binfilter/bf_sc/source/core/tool/sc_optutil.cxx new file mode 100644 index 000000000000..518a50bbe454 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_optutil.cxx @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + + +#include "optutil.hxx" +#include "global.hxx" // for pSysLocale + +#include <bf_svtools/syslocale.hxx> +namespace binfilter { + +//------------------------------------------------------------------ + +// static +/*N*/ BOOL ScOptionsUtil::IsMetricSystem() +/*N*/ { +/*N*/ //! which language should be used here - system language or installed office language? +/*N*/ +/*N*/ // MeasurementSystem eSys = Application::GetAppInternational().GetMeasurementSystem(); +/*N*/ MeasurementSystem eSys = ScGlobal::pLocaleData->getMeasurementSystemEnum(); +/*N*/ +/*N*/ return ( eSys == MEASURE_METRIC ); +/*N*/ } + +//------------------------------------------------------------------ + +/*N*/ ScLinkConfigItem::ScLinkConfigItem( const ::rtl::OUString rSubTree ) : +/*N*/ ConfigItem( rSubTree ) +/*N*/ { +/*N*/ } + +/*N*/ void ScLinkConfigItem::SetCommitLink( const Link& rLink ) +/*N*/ { +/*N*/ aCommitLink = rLink; +/*N*/ } + +void ScLinkConfigItem::Notify( const com::sun::star::uno::Sequence< rtl::OUString >& ) +{ +} + +void ScLinkConfigItem::Commit() +{ +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_printopt.cxx b/binfilter/bf_sc/source/core/tool/sc_printopt.cxx new file mode 100644 index 000000000000..b9a4e55b8f5b --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_printopt.cxx @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + + +#include "printopt.hxx" +namespace binfilter { + +using namespace utl; +using namespace rtl; +using namespace ::com::sun::star::uno; + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ ScPrintOptions::ScPrintOptions() +/*N*/ { +/*N*/ SetDefaults(); +/*N*/ } + +/*N*/ ScPrintOptions::ScPrintOptions( const ScPrintOptions& rCpy ) : +/*N*/ bSkipEmpty( rCpy.bSkipEmpty ), +/*N*/ bAllSheets( rCpy.bAllSheets ) +/*N*/ { +/*N*/ } + +/*N*/ ScPrintOptions::~ScPrintOptions() +/*N*/ { +/*N*/ } + +/*N*/ void ScPrintOptions::SetDefaults() +/*N*/ { +/*N*/ bSkipEmpty = FALSE; +/*N*/ bAllSheets = TRUE; +/*N*/ } + + + + +// ----------------------------------------------------------------------- + + + + + + + + +// ----------------------------------------------------------------------- + +#define CFGPATH_PRINT "Office.Calc/Print" + +#define SCPRINTOPT_EMPTYPAGES 0 +#define SCPRINTOPT_ALLSHEETS 1 +#define SCPRINTOPT_COUNT 2 + + +/*N*/ ScPrintCfg::ScPrintCfg() : +/*N*/ ConfigItem( OUString::createFromAscii( CFGPATH_PRINT ) ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetPropertyNames(); +/*N*/ } + + +void ScPrintCfg::Notify( const ::com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames ) +{ +} +void ScPrintCfg::Commit() +{ +} + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_prnsave.cxx b/binfilter/bf_sc/source/core/tool/sc_prnsave.cxx new file mode 100644 index 000000000000..c8acfe2f30ce --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_prnsave.cxx @@ -0,0 +1,122 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> + +#include "prnsave.hxx" +#include "global.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +//------------------------------------------------------------------ + +// +// Daten pro Tabelle +// + +/*N*/ ScPrintSaverTab::ScPrintSaverTab() : +/*N*/ nPrintCount(0), +/*N*/ pPrintRanges(NULL), +/*N*/ pRepeatCol(NULL), +/*N*/ pRepeatRow(NULL) +/*N*/ { +/*N*/ } + +/*N*/ ScPrintSaverTab::~ScPrintSaverTab() +/*N*/ { +/*N*/ delete[] pPrintRanges; +/*N*/ delete pRepeatCol; +/*N*/ delete pRepeatRow; +/*N*/ } + +/*N*/ void ScPrintSaverTab::SetAreas( USHORT nCount, const ScRange* pRanges ) +/*N*/ { +/*N*/ delete[] pPrintRanges; +/*N*/ if (nCount && pRanges) +/*N*/ { +/*N*/ nPrintCount = nCount; +/*N*/ pPrintRanges = new ScRange[nCount]; +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ pPrintRanges[i] = pRanges[i]; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nPrintCount = 0; +/*N*/ pPrintRanges = NULL; +/*N*/ } +/*N*/ } + +/*N*/ void ScPrintSaverTab::SetRepeat( const ScRange* pCol, const ScRange* pRow ) +/*N*/ { +/*N*/ delete pRepeatCol; +/*N*/ pRepeatCol = pCol ? new ScRange(*pCol) : NULL; +/*N*/ delete pRepeatRow; +/*N*/ pRepeatRow = pRow ? new ScRange(*pRow) : NULL; +/*N*/ } + + + +// +// Daten fuer das ganze Dokument +// + +/*N*/ ScPrintRangeSaver::ScPrintRangeSaver( USHORT nCount ) : +/*N*/ nTabCount( nCount ) +/*N*/ { +/*N*/ if (nCount) +/*N*/ pData = new ScPrintSaverTab[nCount]; +/*N*/ else +/*N*/ pData = NULL; +/*N*/ } + +/*N*/ ScPrintRangeSaver::~ScPrintRangeSaver() +/*N*/ { +/*N*/ delete[] pData; +/*N*/ } + +/*N*/ ScPrintSaverTab& ScPrintRangeSaver::GetTabData(USHORT nTab) +/*N*/ { +/*N*/ DBG_ASSERT(nTab<nTabCount,"ScPrintRangeSaver Tab zu gross"); +/*N*/ return pData[nTab]; +/*N*/ } + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_progress.cxx b/binfilter/bf_sc/source/core/tool/sc_progress.cxx new file mode 100644 index 000000000000..0e0872b647ce --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_progress.cxx @@ -0,0 +1,129 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include <bf_sfx2/app.hxx> +#include <bf_sfx2/objsh.hxx> +#include <bf_sfx2/sfxsids.hrc> + +#define SC_PROGRESS_CXX +#include "progress.hxx" +#include "globstr.hrc" +namespace binfilter { + + + +static ScProgress theDummyInterpretProgress; +SfxProgress* ScProgress::pGlobalProgress = NULL; +ULONG ScProgress::nGlobalRange = 0; +ULONG ScProgress::nGlobalPercent = 0; +BOOL ScProgress::bGlobalNoUserBreak = TRUE; +ScProgress* ScProgress::pInterpretProgress = &theDummyInterpretProgress; +ScProgress* ScProgress::pOldInterpretProgress = NULL; +ULONG ScProgress::nInterpretProgress = 0; +BOOL ScProgress::bAllowInterpretProgress = TRUE; +ScDocument* ScProgress::pInterpretDoc; +BOOL ScProgress::bIdleWasDisabled = FALSE; + + + +/*N*/ ScProgress::ScProgress( SfxObjectShell* pObjSh, const String& rText, +/*N*/ ULONG nRange, BOOL bAllDocs, BOOL bWait ) +/*N*/ { +/*N*/ +/*N*/ if ( pGlobalProgress || SfxProgress::GetActiveProgress( NULL ) ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ( lcl_IsHiddenDocument(pObjSh) ) +/*N*/ } +/*N*/ else if ( SFX_APP()->IsDowning() ) +/*N*/ { +/*N*/ // kommt vor z.B. beim Speichern des Clipboard-Inhalts als OLE beim Beenden +/*N*/ // Dann wuerde ein SfxProgress wild im Speicher rummuellen +/*N*/ //! Soll das so sein ??? +/*N*/ +/*N*/ pProgress = NULL; +/*N*/ } +/*N*/ else if ( pObjSh && ( pObjSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED || +/*N*/ pObjSh->GetProgress() ) ) +/*N*/ { +/*N*/ // #62808# no own progress for embedded objects, +/*N*/ // #73633# no second progress if the document already has one +/*N*/ +/*N*/ pProgress = NULL; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pProgress = new SfxProgress( pObjSh, rText, nRange, bAllDocs, bWait ); +/*N*/ pGlobalProgress = pProgress; +/*N*/ nGlobalRange = nRange; +/*N*/ nGlobalPercent = 0; +/*N*/ bGlobalNoUserBreak = TRUE; +/*N*/ } +/*N*/ } + + +/*N*/ ScProgress::ScProgress() : +/*N*/ pProgress( NULL ) +/*N*/ { // DummyInterpret +/*N*/ } + + +/*N*/ ScProgress::~ScProgress() +/*N*/ { +/*N*/ if ( pProgress ) +/*N*/ { +/*N*/ delete pProgress; +/*N*/ pGlobalProgress = NULL; +/*N*/ nGlobalRange = 0; +/*N*/ nGlobalPercent = 0; +/*N*/ bGlobalNoUserBreak = TRUE; +/*N*/ } +/*N*/ } + + +// static + + + +// static + + + +// static + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_rangelst.cxx b/binfilter/bf_sc/source/core/tool/sc_rangelst.cxx new file mode 100644 index 000000000000..a0e670a5e5dc --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_rangelst.cxx @@ -0,0 +1,555 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#define SC_RANGELST_CXX //fuer ICC + +#include <stdlib.h> // qsort + +#include "document.hxx" +#include "refupdat.hxx" +#include "rechead.hxx" +namespace binfilter { + + +// === ScRangeList ==================================================== + +/*N*/ ScRangeList::~ScRangeList() +/*N*/ { +/*N*/ for ( ScRangePtr pR = First(); pR; pR = Next() ) +/*N*/ delete pR; +/*N*/ } + +/*N*/ void ScRangeList::RemoveAll() +/*N*/ { +/*N*/ for ( ScRangePtr pR = First(); pR; pR = Next() ) +/*N*/ delete pR; +/*N*/ Clear(); +/*N*/ } + +/*N*/ USHORT ScRangeList::Parse( const String& rStr, ScDocument* pDoc, USHORT nMask ) +/*N*/ { +/*N*/ if ( rStr.Len() ) +/*N*/ { +/*N*/ nMask |= SCA_VALID; // falls das jemand vergessen sollte +/*N*/ USHORT nResult = (USHORT)~0; // alle Bits setzen +/*N*/ ScRange aRange; +/*N*/ String aOne; +/*N*/ USHORT nTab = 0; +/*N*/ if ( pDoc ) +/*N*/ { +/*N*/ //! erste markierte Tabelle gibts nicht mehr am Dokument +/*N*/ //! -> uebergeben? oder spaeter an den Ranges setzen +/*N*/ } +/*N*/ else +/*N*/ nTab = 0; +/*N*/ USHORT nTCount = rStr.GetTokenCount(); +/*N*/ for ( USHORT i=0; i<nTCount; i++ ) +/*N*/ { +/*N*/ aOne = rStr.GetToken(i); +/*N*/ if ( aOne.Search( ':' ) == STRING_NOTFOUND ) +/*N*/ { // Range muss es sein +/*N*/ String aStrTmp( aOne ); +/*N*/ aOne += ':'; +/*N*/ aOne += aStrTmp; +/*N*/ } +/*N*/ aRange.aStart.SetTab( nTab ); // Default Tab wenn nicht angegeben +/*N*/ USHORT nRes = aRange.Parse( aOne, pDoc ); +/*N*/ if ( (nRes & nMask) == nMask ) +/*N*/ Append( aRange ); +/*N*/ nResult &= nRes; // alle gemeinsamen Bits bleiben erhalten +/*N*/ } +/*N*/ return nResult; // SCA_VALID gesetzt wenn alle ok +/*N*/ } +/*N*/ else +/*N*/ return 0; +/*N*/ } + + +/*N*/ void ScRangeList::Format( String& rStr, USHORT nFlags, ScDocument* pDoc ) const +/*N*/ { +/*N*/ rStr.Erase(); +/*N*/ ULONG nCnt = Count(); +/*N*/ for ( ULONG nIdx = 0; nIdx < nCnt; nIdx++ ) +/*N*/ { +/*N*/ String aStr; +/*N*/ GetObject( nIdx )->Format( aStr, nFlags, pDoc ); +/*N*/ if ( nIdx ) +/*N*/ rStr += ';'; +/*N*/ rStr += aStr; +/*N*/ } +/*N*/ } + + +/*N*/ void ScRangeList::Join( const ScRange& r, BOOL bIsInList ) +/*N*/ { +/*N*/ if ( !Count() ) +/*N*/ { +/*N*/ Append( r ); +/*N*/ return ; +/*N*/ } +/*N*/ USHORT nCol1 = r.aStart.Col(); +/*N*/ USHORT nRow1 = r.aStart.Row(); +/*N*/ USHORT nTab1 = r.aStart.Tab(); +/*N*/ USHORT nCol2 = r.aEnd.Col(); +/*N*/ USHORT nRow2 = r.aEnd.Row(); +/*N*/ USHORT nTab2 = r.aEnd.Tab(); +/*N*/ ScRangePtr pOver = (ScRangePtr) &r; // fies aber wahr wenn bInList +/*N*/ ULONG nOldPos; +/*N*/ if ( bIsInList ) +/*N*/ { // merken um ggbf. zu loeschen bzw. wiederherzustellen +/*N*/ nOldPos = GetPos( pOver ); +/*N*/ } +/*N*/ BOOL bJoinedInput = FALSE; +/*N*/ for ( ScRangePtr p = First(); p && pOver; p = Next() ) +/*N*/ { +/*N*/ if ( p == pOver ) +/*N*/ continue; // derselbe, weiter mit dem naechsten +/*N*/ BOOL bJoined = FALSE; +/*N*/ if ( p->In( r ) ) +/*N*/ { // Range r in Range p enthalten oder identisch +/*N*/ if ( bIsInList ) +/*N*/ bJoined = TRUE; // weg mit Range r +/*N*/ else +/*N*/ { // das war's dann +/*N*/ bJoinedInput = TRUE; // nicht anhaengen +/*N*/ break; // for +/*N*/ } +/*N*/ } +/*N*/ else if ( r.In( *p ) ) +/*N*/ { // Range p in Range r enthalten, r zum neuen Range machen +/*N*/ *p = r; +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ if ( !bJoined && p->aStart.Tab() == nTab1 && p->aEnd.Tab() == nTab2 ) +/*N*/ { // 2D +/*N*/ if ( p->aStart.Col() == nCol1 && p->aEnd.Col() == nCol2 ) +/*N*/ { +/*N*/ if ( p->aStart.Row() == nRow2+1 ) +/*N*/ { // oben +/*?*/ p->aStart.SetRow( nRow1 ); +/*?*/ bJoined = TRUE; +/*N*/ } +/*N*/ else if ( p->aEnd.Row() == nRow1-1 ) +/*N*/ { // unten +/*N*/ p->aEnd.SetRow( nRow2 ); +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else if ( p->aStart.Row() == nRow1 && p->aEnd.Row() == nRow2 ) +/*N*/ { +/*N*/ if ( p->aStart.Col() == nCol2+1 ) +/*N*/ { // links +/*?*/ p->aStart.SetCol( nCol1 ); +/*?*/ bJoined = TRUE; +/*N*/ } +/*N*/ else if ( p->aEnd.Col() == nCol1-1 ) +/*N*/ { // rechts +/*N*/ p->aEnd.SetCol( nCol2 ); +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( bJoined ) +/*N*/ { +/*N*/ if ( bIsInList ) +/*N*/ { // innerhalb der Liste Range loeschen +/*N*/ Remove( nOldPos ); +/*N*/ delete pOver; +/*N*/ pOver = NULL; +/*N*/ if ( nOldPos ) +/*N*/ nOldPos--; // Seek richtig aufsetzen +/*N*/ } +/*N*/ bJoinedInput = TRUE; +/*N*/ Join( *p, TRUE ); // rekursiv! +/*N*/ } +/*N*/ } +/*N*/ if ( bIsInList ) +/*N*/ Seek( nOldPos ); +/*N*/ else if ( !bJoinedInput ) +/*N*/ Append( r ); +/*N*/ } + + + + +/*N*/ BOOL ScRangeList::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ ULONG nCount = Count(); +/*N*/ ULONG nBytes = sizeof(UINT32) + nCount * sizeof(ScRange); +/*N*/ ScWriteHeader aHdr( rStream, nBytes ); +/*N*/ rStream << (UINT32) nCount; +/*N*/ for ( ULONG j = 0; j < nCount && bOk; j++ ) +/*N*/ { +/*N*/ rStream << *GetObject( j ); +/*N*/ if( rStream.GetError() != SVSTREAM_OK ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScRangeList::Load( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ ScRange aRange; +/*N*/ UINT32 n; +/*N*/ rStream >> n; +/*N*/ ULONG nCount = n; +/*N*/ for ( ULONG j = 0; j < nCount && bOk; j++ ) +/*N*/ { +/*N*/ rStream >> aRange; +/*N*/ Append( aRange ); +/*N*/ if( rStream.GetError() != SVSTREAM_OK ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScRangeList::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ ScDocument* pDoc, const ScRange& rWhere, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ if ( Count() ) +/*N*/ { +/*N*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ rWhere.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ for ( ScRange* pR = First(); pR; pR = Next() ) +/*N*/ { +/*N*/ USHORT theCol1, theRow1, theTab1, theCol2, theRow2, theTab2; +/*N*/ pR->GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 ); +/*N*/ if ( ScRefUpdate::Update( pDoc, eUpdateRefMode, +/*N*/ nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, +/*N*/ nDx, nDy, nDz, +/*N*/ theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 ) +/*N*/ != UR_NOTHING ) +/*N*/ { +/*?*/ bChanged = TRUE; +/*?*/ pR->aStart.Set( theCol1, theRow1, theTab1 ); +/*?*/ pR->aEnd.Set( theCol2, theRow2, theTab2 ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return bChanged; +/*N*/ } + + + + + + +/*N*/ ScRangeList::ScRangeList( const ScRangeList& rList ) +/*N*/ { +/*N*/ ULONG nCount = rList.Count(); +/*N*/ for ( ULONG j = 0; j < nCount; j++ ) +/*N*/ Append( *rList.GetObject( j ) ); +/*N*/ } + + + + +/*N*/ ScRangeList& ScRangeList::operator=(const ScRangeList& rList) +/*N*/ { +/*N*/ RemoveAll(); +/*N*/ +/*N*/ ULONG nCount = rList.Count(); +/*N*/ for ( ULONG j = 0; j < nCount; j++ ) +/*N*/ Append( *rList.GetObject( j ) ); +/*N*/ +/*N*/ return *this; +/*N*/ } + + + + + + + + +// === ScRangePairList ==================================================== + +/*N*/ ScRangePairList::~ScRangePairList() +/*N*/ { +/*N*/ for ( ScRangePair* pR = First(); pR; pR = Next() ) +/*?*/ delete pR; +/*N*/ } + + +/*N*/ void ScRangePairList::Join( const ScRangePair& r, BOOL bIsInList ) +/*N*/ { +/*N*/ if ( !Count() ) +/*N*/ { +/*N*/ Append( r ); +/*N*/ return ; +/*N*/ } +/*N*/ const ScRange& r1 = r.GetRange(0); +/*N*/ const ScRange& r2 = r.GetRange(1); +/*N*/ USHORT nCol1 = r1.aStart.Col(); +/*N*/ USHORT nRow1 = r1.aStart.Row(); +/*N*/ USHORT nTab1 = r1.aStart.Tab(); +/*N*/ USHORT nCol2 = r1.aEnd.Col(); +/*N*/ USHORT nRow2 = r1.aEnd.Row(); +/*N*/ USHORT nTab2 = r1.aEnd.Tab(); +/*N*/ ScRangePair* pOver = (ScRangePair*) &r; // fies aber wahr wenn bInList +/*N*/ ULONG nOldPos; +/*N*/ if ( bIsInList ) +/*N*/ { // merken um ggbf. zu loeschen bzw. wiederherzustellen +/*N*/ nOldPos = GetPos( pOver ); +/*N*/ } +/*N*/ BOOL bJoinedInput = FALSE; +/*N*/ for ( ScRangePair* p = First(); p && pOver; p = Next() ) +/*N*/ { +/*N*/ if ( p == pOver ) +/*N*/ continue; // derselbe, weiter mit dem naechsten +/*N*/ BOOL bJoined = FALSE; +/*N*/ ScRange& rp1 = p->GetRange(0); +/*N*/ ScRange& rp2 = p->GetRange(1); +/*N*/ if ( rp2 == r2 ) +/*N*/ { // nur wenn Range2 gleich ist +/*N*/ if ( rp1.In( r1 ) ) +/*N*/ { // RangePair r in RangePair p enthalten oder identisch +/*N*/ if ( bIsInList ) +/*N*/ bJoined = TRUE; // weg mit RangePair r +/*N*/ else +/*N*/ { // das war's dann +/*N*/ bJoinedInput = TRUE; // nicht anhaengen +/*N*/ break; // for +/*N*/ } +/*N*/ } +/*N*/ else if ( r1.In( rp1 ) ) +/*N*/ { // RangePair p in RangePair r enthalten, r zum neuen RangePair machen +/*N*/ *p = r; +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ if ( !bJoined && rp1.aStart.Tab() == nTab1 && rp1.aEnd.Tab() == nTab2 +/*N*/ && rp2.aStart.Tab() == r2.aStart.Tab() +/*N*/ && rp2.aEnd.Tab() == r2.aEnd.Tab() ) +/*N*/ { // 2D, Range2 muss genauso nebeneinander liegen wie Range1 +/*N*/ if ( rp1.aStart.Col() == nCol1 && rp1.aEnd.Col() == nCol2 +/*N*/ && rp2.aStart.Col() == r2.aStart.Col() +/*N*/ && rp2.aEnd.Col() == r2.aEnd.Col() ) +/*N*/ { +/*N*/ if ( rp1.aStart.Row() == nRow2+1 +/*N*/ && rp2.aStart.Row() == r2.aEnd.Row()+1 ) +/*N*/ { // oben +/*N*/ rp1.aStart.SetRow( nRow1 ); +/*N*/ rp2.aStart.SetRow( r2.aStart.Row() ); +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ else if ( rp1.aEnd.Row() == nRow1-1 +/*N*/ && rp2.aEnd.Row() == r2.aStart.Row()-1 ) +/*N*/ { // unten +/*N*/ rp1.aEnd.SetRow( nRow2 ); +/*N*/ rp2.aEnd.SetRow( r2.aEnd.Row() ); +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else if ( rp1.aStart.Row() == nRow1 && rp1.aEnd.Row() == nRow2 +/*N*/ && rp2.aStart.Row() == r2.aStart.Row() +/*N*/ && rp2.aEnd.Row() == r2.aEnd.Row() ) +/*N*/ { +/*N*/ if ( rp1.aStart.Col() == nCol2+1 +/*N*/ && rp2.aStart.Col() == r2.aEnd.Col()+1 ) +/*N*/ { // links +/*N*/ rp1.aStart.SetCol( nCol1 ); +/*N*/ rp2.aStart.SetCol( r2.aStart.Col() ); +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ else if ( rp1.aEnd.Col() == nCol1-1 +/*N*/ && rp2.aEnd.Col() == r2.aEnd.Col()-1 ) +/*N*/ { // rechts +/*N*/ rp1.aEnd.SetCol( nCol2 ); +/*N*/ rp2.aEnd.SetCol( r2.aEnd.Col() ); +/*N*/ bJoined = TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ if ( bJoined ) +/*N*/ { +/*N*/ if ( bIsInList ) +/*N*/ { // innerhalb der Liste RangePair loeschen +/*N*/ Remove( nOldPos ); +/*N*/ delete pOver; +/*N*/ pOver = NULL; +/*N*/ if ( nOldPos ) +/*N*/ nOldPos--; // Seek richtig aufsetzen +/*N*/ } +/*N*/ bJoinedInput = TRUE; +/*N*/ Join( *p, TRUE ); // rekursiv! +/*N*/ } +/*N*/ } +/*N*/ if ( bIsInList ) +/*N*/ Seek( nOldPos ); +/*N*/ else if ( !bJoinedInput ) +/*N*/ Append( r ); +/*N*/ } + + + + +/*N*/ BOOL ScRangePairList::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ ULONG nCount = Count(); +/*N*/ ULONG nBytes = sizeof(UINT32) + nCount * sizeof(ScRangePair); +/*N*/ ScWriteHeader aHdr( rStream, nBytes ); +/*N*/ rStream << (UINT32) nCount; +/*N*/ for ( ULONG j = 0; j < nCount && bOk; j++ ) +/*N*/ { +/*N*/ rStream << *GetObject( j ); +/*N*/ if( rStream.GetError() != SVSTREAM_OK ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScRangePairList::Load( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ ScRangePair aRangePair; +/*N*/ ScRange aRange; +/*N*/ UINT32 n; +/*N*/ rStream >> n; +/*N*/ ULONG nCount = n; +/*N*/ for ( ULONG j = 0; j < nCount && bOk; j++ ) +/*N*/ { +/*N*/ if ( nVer < SC_COLROWNAME_RANGEPAIR ) +/*N*/ { // aus technical Beta 4.0 versuchen mit altem Verhalten zu uebernehmen +/*N*/ rStream >> aRange; +/*N*/ aRangePair.GetRange(0) = aRange; +/*N*/ ScRange& r = aRangePair.GetRange(1); +/*N*/ r = aRange; +/*N*/ USHORT nCol2 = aRange.aEnd.Col(); +/*N*/ USHORT nRow2 = aRange.aEnd.Row(); +/*N*/ if ( nCol2 - aRange.aStart.Col() >= nRow2 - aRange.aStart.Row() ) +/*N*/ { // ColNames +/*N*/ r.aStart.SetRow( (USHORT) Min( (ULONG)nRow2 + 1, (ULONG)MAXROW ) ); +/*N*/ r.aEnd.SetRow( MAXROW ); +/*N*/ } +/*N*/ else +/*N*/ { // RowNames +/*N*/ r.aStart.SetCol( (USHORT) Min( (ULONG)(nCol2 + 1), (ULONG)MAXCOL ) ); +/*N*/ r.aEnd.SetCol( MAXCOL ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ rStream >> aRangePair; +/*N*/ Append( aRangePair ); +/*N*/ if( rStream.GetError() != SVSTREAM_OK ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL ScRangePairList::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ ScDocument* pDoc, const ScRange& rWhere, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ if ( Count() ) +/*N*/ { +/*?*/ USHORT nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*?*/ rWhere.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*?*/ for ( ScRangePair* pR = First(); pR; pR = Next() ) +/*?*/ { +/*?*/ for ( USHORT j=0; j<2; j++ ) +/*?*/ { +/*?*/ ScRange& rRange = pR->GetRange(j); +/*?*/ USHORT theCol1, theRow1, theTab1, theCol2, theRow2, theTab2; +/*?*/ rRange.GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 ); +/*?*/ if ( ScRefUpdate::Update( pDoc, eUpdateRefMode, +/*?*/ nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, +/*?*/ nDx, nDy, nDz, +/*?*/ theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 ) +/*?*/ != UR_NOTHING ) +/*?*/ { +/*?*/ bChanged = TRUE; +/*?*/ rRange.aStart.Set( theCol1, theRow1, theTab1 ); +/*?*/ rRange.aEnd.Set( theCol2, theRow2, theTab2 ); +/*?*/ } +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ return bChanged; +/*N*/ } + + +/*N*/ ScRangePair* ScRangePairList::Find( const ScRange& rRange ) const +/*N*/ { +/*N*/ ULONG nCount = Count(); +/*N*/ for ( ULONG j = 0; j < nCount; j++ ) +/*N*/ { +/*N*/ ScRangePair* pR = GetObject( j ); +/*N*/ if ( pR->GetRange(0) == rRange ) +/*N*/ return pR; +/*N*/ } +/*N*/ return NULL; +/*N*/ } + + +/*N*/ ScRangePairList* ScRangePairList::Clone() const +/*N*/ { +/*N*/ ScRangePairList* pNew = new ScRangePairList; +/*N*/ ULONG nCount = Count(); +/*N*/ for ( ULONG j = 0; j < nCount; j++ ) +/*N*/ { +/*N*/ pNew->Append( *GetObject( j ) ); +/*N*/ } +/*N*/ return pNew; +/*N*/ } + + +struct ScRangePairNameSort +{ + ScRangePair* pPair; + ScDocument* pDoc; +}; + + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_rangenam.cxx b/binfilter/bf_sc/source/core/tool/sc_rangenam.cxx new file mode 100644 index 000000000000..ee8426d0661f --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_rangenam.cxx @@ -0,0 +1,578 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include <tools/debug.hxx> +#include <string.h> +#include <unotools/collatorwrapper.hxx> +#include <unotools/transliterationwrapper.hxx> + +#include "rangenam.hxx" +#include "compiler.hxx" +#include "rechead.hxx" +#include "document.hxx" +namespace binfilter { + + +//======================================================================== +// ScRangeData +//======================================================================== + +// Interner ctor fuer das Suchen nach einem Index + +/*N*/ ScRangeData::ScRangeData( USHORT n ) +/*N*/ : nIndex( n ), pCode( NULL ), bModified( FALSE ) +/*N*/ {} + +/*N*/ ScRangeData::ScRangeData( ScDocument* pDok, +/*N*/ const String& rName, +/*N*/ const String& rSymbol, +/*N*/ const ScAddress& rAddress, +/*N*/ RangeType nType, +/*N*/ BOOL bEnglish ) : +/*N*/ aName ( rName ), +/*N*/ aPos ( rAddress ), +/*N*/ eType ( nType ), +/*N*/ pDoc ( pDok ), +/*N*/ nIndex ( 0 ), +/*N*/ nExportIndex( 0 ), +/*N*/ pCode ( NULL ), +/*N*/ bModified ( FALSE ) +/*N*/ { +/*N*/ if (rSymbol.Len() > 0) +/*N*/ { +/*N*/ ScCompiler aComp( pDoc, aPos ); +/*N*/ aComp.SetCompileEnglish(bEnglish); +/*N*/ pCode = aComp.CompileString( rSymbol ); +/*N*/ if( !pCode->GetError() ) +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ ScToken* p = pCode->GetNextReference(); +/*N*/ if( p )// genau eine Referenz als erstes +/*N*/ { +/*N*/ if( p->GetType() == svSingleRef ) +/*N*/ eType = eType | RT_ABSPOS; +/*N*/ else +/*N*/ eType = eType | RT_ABSAREA; +/*N*/ } +/*N*/ // ggf. den Fehlercode wg. unvollstaendiger Formel setzen! +/*N*/ // Dies ist fuer die manuelle Eingabe +/*N*/ aComp.CompileTokenArray(); +/*N*/ pCode->DelRPN(); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ ScRangeData::ScRangeData(const ScRangeData& rScRangeData) : +/*N*/ aName (rScRangeData.aName), +/*N*/ aPos (rScRangeData.aPos), +/*N*/ eType (rScRangeData.eType), +/*N*/ pDoc (rScRangeData.pDoc), +/*N*/ nIndex (rScRangeData.nIndex), +/*N*/ pCode (rScRangeData.pCode ? rScRangeData.pCode->Clone() : new ScTokenArray), // echte Kopie erzeugen (nicht copy-ctor) +/*N*/ bModified (rScRangeData.bModified) +/*N*/ {} + +/*N*/ ScRangeData::~ScRangeData() +/*N*/ { +/*N*/ delete pCode; +/*N*/ } + +/*N*/ DataObject* ScRangeData::Clone() const +/*N*/ { +/*N*/ return new ScRangeData(*this); +/*N*/ } + +/*N*/ ScRangeData::ScRangeData +/*N*/ ( SvStream& rStream, ScMultipleReadHeader& rHdr, USHORT nVer ) +/*N*/ : pCode ( new ScTokenArray ), +/*N*/ bModified (FALSE) +/*N*/ +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ if( nVer >= SC_NEW_TOKEN_ARRAYS ) +/*N*/ { +/*N*/ UINT32 nPos; +/*N*/ BYTE nData; +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream >> nPos >> eType >> nIndex >> nData; +/*N*/ if( nData & 0x0F ) +/*?*/ rStream.SeekRel( nData & 0x0F ); +/*N*/ aPos = ScAddress( nPos ); +/*N*/ pCode->Load( rStream, nVer, aPos ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ UINT16 nTokLen, r, c, t; +/*N*/ rStream.ReadByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream >> c >> r >> t >> eType >> nIndex >> nTokLen; +/*N*/ aPos.Set( c, r, t ); +/*N*/ if( nTokLen ) +/*N*/ pCode->Load30( rStream, aPos ); +/*N*/ } +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ } + +/*N*/ BOOL ScRangeData::Store +/*N*/ ( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const +/*N*/ { +/*N*/ rHdr.StartEntry(); +/*N*/ +/*N*/ rStream.WriteByteString( aName, rStream.GetStreamCharSet() ); +/*N*/ rStream << (UINT32) aPos << eType << nIndex << (BYTE) 0x00; +/*N*/ pCode->Store( rStream, aPos ); +/*N*/ +/*N*/ rHdr.EndEntry(); +/*N*/ return TRUE; +/*N*/ } + +/*N*/ BOOL ScRangeData::IsBeyond( USHORT nMaxRow ) const +/*N*/ { +/*N*/ if ( aPos.Row() > nMaxRow ) +/*N*/ return TRUE; +/*N*/ +/*N*/ ScToken* t; +/*N*/ pCode->Reset(); +/*N*/ while ( t = pCode->GetNextReference() ) +/*N*/ if ( t->GetSingleRef().nRow > nMaxRow || +/*N*/ (t->GetType() == svDoubleRef && +/*N*/ t->GetDoubleRef().Ref2.nRow > nMaxRow) ) +/*N*/ return TRUE; +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ void ScRangeData::GetSymbol (String& rSymbol) const +/*N*/ { +/*N*/ ScCompiler aScComp(pDoc, aPos, *pCode); +/*N*/ aScComp.CreateStringFromTokenArray( rSymbol ); +/*N*/ } + +/*N*/ void ScRangeData::GetEnglishSymbol (String& rSymbol, BOOL bCompileXML) const +/*N*/ { +/*N*/ ScCompiler aScComp(pDoc, aPos, *pCode); +/*N*/ aScComp.SetCompileEnglish( TRUE ); +/*N*/ aScComp.SetCompileXML( bCompileXML ); +/*N*/ aScComp.CreateStringFromTokenArray( rSymbol ); +/*N*/ } + +/*N*/ void ScRangeData::UpdateSymbol( String& rSymbol, const ScAddress& rPos, +/*N*/ BOOL bEnglish, BOOL bCompileXML ) +/*N*/ { +/*N*/ ScTokenArray* pTemp = pCode->Clone(); +/*N*/ ScCompiler aComp( pDoc, rPos, *pTemp ); +/*N*/ aComp.SetCompileEnglish( bEnglish ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ aComp.MoveRelWrap(); +/*N*/ aComp.CreateStringFromTokenArray( rSymbol ); +/*N*/ delete pTemp; +/*N*/ } + +/*N*/ void ScRangeData::UpdateSymbol( ::rtl::OUStringBuffer& rBuffer, const ScAddress& rPos, +/*N*/ BOOL bEnglish, BOOL bCompileXML ) +/*N*/ { +/*N*/ ScTokenArray* pTemp = pCode->Clone(); +/*N*/ ScCompiler aComp( pDoc, rPos, *pTemp ); +/*N*/ aComp.SetCompileEnglish( bEnglish ); +/*N*/ aComp.SetCompileXML( bCompileXML ); +/*N*/ aComp.MoveRelWrap(); +/*N*/ aComp.CreateStringFromTokenArray( rBuffer ); +/*N*/ delete pTemp; +/*N*/ } + +/*N*/ void ScRangeData::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& r, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ BOOL bChanged = FALSE; +/*N*/ +/*N*/ pCode->Reset(); +/*N*/ if( pCode->GetNextReference() ) +/*N*/ { +/*N*/ ScCompiler aComp( pDoc, aPos, *pCode ); +/*N*/ BOOL bRelRef = aComp.UpdateNameReference( eUpdateRefMode, r, +/*N*/ nDx, nDy, nDz, +/*N*/ bChanged); +/*N*/ if (eType&RT_SHARED) +/*N*/ { +/*N*/ if (bRelRef) +/*N*/ eType = eType | RT_SHAREDMOD; +/*N*/ else +/*N*/ eType = eType & ~RT_SHAREDMOD; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ bModified = bChanged; +/*N*/ } + + + + + + + +/*N*/ BOOL ScRangeData::IsReference( ScRange& rRange ) const +/*N*/ { +/*N*/ BOOL bIs = FALSE; +/*N*/ if ( eType & ( RT_ABSAREA | RT_REFAREA | RT_ABSPOS ) ) +/*N*/ if ( pCode ) +/*N*/ return pCode->IsReference( rRange ); +/*N*/ +/*N*/ return bIs; +/*N*/ } + + +// wie beim Uebernehmen von Namen in Excel + +/*N*/ void ScRangeData::MakeValidName( String& rName ) // static +/*N*/ { +/*N*/ if (!ScCompiler::HasCharTable()) +/*N*/ ScCompiler::Init(); +/*N*/ +/*N*/ // ungueltige Zeichen vorne weglassen +/*N*/ xub_StrLen nPos = 0; +/*N*/ xub_StrLen nLen = rName.Len(); +/*N*/ while ( nPos < nLen && !ScCompiler::IsWordChar( rName.GetChar(nPos) ) ) +/*N*/ ++nPos; +/*N*/ if ( nPos>0 ) +/*N*/ rName.Erase(0,nPos); +/*N*/ +/*N*/ // wenn vorne ein ungueltiges Anfangszeichen steht, '_' davor +/*N*/ if ( rName.Len() && !ScCompiler::IsCharWordChar( rName.GetChar(0) ) ) +/*N*/ rName.Insert('_',0); +/*N*/ +/*N*/ // ungueltige durch '_' ersetzen +/*N*/ nLen = rName.Len(); +/*N*/ for (nPos=0; nPos<nLen; nPos++) +/*N*/ { +/*N*/ if ( !ScCompiler::IsWordChar( rName.GetChar(nPos) ) ) +/*N*/ rName.SetChar( nPos, '_' ); +/*N*/ } +/*N*/ +/*N*/ // Name darf keine Referenz beinhalten, wie in IsNameValid +/*N*/ BOOL bOk; +/*N*/ do +/*N*/ { +/*N*/ bOk = TRUE; +/*N*/ ScRange aRange; +/*N*/ if( aRange.Parse( rName, NULL ) ) +/*N*/ bOk = FALSE; +/*N*/ else +/*N*/ { +/*N*/ ScAddress aAddr; +/*N*/ if ( aAddr.Parse( rName, NULL ) ) +/*N*/ bOk = FALSE; +/*N*/ } +/*N*/ if ( !bOk ) +/*N*/ { //! Range Parse auch bei Bereich mit ungueltigem Tabellennamen gueltig +/*N*/ //! Address Parse dito, Name erzeugt deswegen bei Compile ein #REF! +/*N*/ if ( rName.SearchAndReplace( ':', '_' ) == STRING_NOTFOUND +/*N*/ && rName.SearchAndReplace( '.', '_' ) == STRING_NOTFOUND ) +/*N*/ rName.Insert('_',0); +/*N*/ } +/*N*/ } while ( !bOk ); +/*N*/ } + + + +/*N*/ USHORT ScRangeData::GetErrCode() +/*N*/ { +/*N*/ return pCode ? pCode->GetError() : 0; +/*N*/ } + +/*N*/ BOOL ScRangeData::HasReferences() const +/*N*/ { +/*N*/ pCode->Reset(); +/*N*/ return BOOL( pCode->GetNextReference() != NULL ); +/*N*/ } + +// bei TransferTab von einem in ein anderes Dokument anpassen, +// um Referenzen auf die eigene Tabelle mitzubekommen + + + +/*N*/ void ScRangeData::ReplaceRangeNamesInUse( const ScIndexMap& rMap ) +/*N*/ { +/*N*/ BOOL bCompile = FALSE; +/*N*/ for ( ScToken* p = pCode->First(); p; p = pCode->Next() ) +/*N*/ { +/*N*/ if ( p->GetOpCode() == ocName ) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 USHORT nIndex = p->GetIndex(); +/*N*/ } +/*N*/ } +/*N*/ if ( bCompile ) +/*N*/ { +/*N*/ ScCompiler aComp( pDoc, aPos, *pCode ); +/*N*/ aComp.CompileTokenArray(); +/*N*/ } +/*N*/ } + + +/*N*/ void ScRangeData::ValidateTabRefs() +/*N*/ { +/*N*/ // try to make sure all relative references and the reference position +/*N*/ // are within existing tables, so they can be represented as text +/*N*/ // (if the range of used tables is more than the existing tables, +/*N*/ // the result may still contain invalid tables, because the relative +/*N*/ // references aren't changed so formulas stay the same) +/*N*/ +/*N*/ // find range of used tables +/*N*/ +/*N*/ USHORT nMinTab = aPos.Tab(); +/*N*/ USHORT nMaxTab = nMinTab; +/*N*/ ScToken* t; +/*N*/ pCode->Reset(); +/*N*/ while ( t = pCode->GetNextReference() ) +/*N*/ { +/*N*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*N*/ if ( rRef1.IsTabRel() && !rRef1.IsTabDeleted() ) +/*N*/ { +/*N*/ if ( rRef1.nTab < nMinTab ) +/*N*/ nMinTab = rRef1.nTab; +/*N*/ if ( rRef1.nTab > nMaxTab ) +/*N*/ nMaxTab = rRef1.nTab; +/*N*/ } +/*N*/ if ( t->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*N*/ if ( rRef2.IsTabRel() && !rRef2.IsTabDeleted() ) +/*N*/ { +/*?*/ if ( rRef2.nTab < nMinTab ) +/*?*/ nMinTab = rRef2.nTab; +/*?*/ if ( rRef2.nTab > nMaxTab ) +/*?*/ nMaxTab = rRef2.nTab; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ USHORT nTabCount = pDoc->GetTableCount(); +/*N*/ if ( nMaxTab >= nTabCount && nMinTab > 0 ) +/*N*/ { +/*?*/ // move position and relative tab refs +/*?*/ // The formulas that use the name are not changed by this +/*?*/ +/*?*/ USHORT nMove = nMinTab; +/*?*/ aPos.SetTab( aPos.Tab() - nMove ); +/*?*/ +/*?*/ pCode->Reset(); +/*?*/ while ( t = pCode->GetNextReference() ) +/*?*/ { +/*?*/ SingleRefData& rRef1 = t->GetSingleRef(); +/*?*/ if ( rRef1.IsTabRel() && !rRef1.IsTabDeleted() ) +/*?*/ rRef1.nTab -= nMove; +/*?*/ if ( t->GetType() == svDoubleRef ) +/*?*/ { +/*?*/ SingleRefData& rRef2 = t->GetDoubleRef().Ref2; +/*?*/ if ( rRef2.IsTabRel() && !rRef2.IsTabDeleted() ) +/*?*/ rRef2.nTab -= nMove; +/*?*/ } +/*?*/ } +/*N*/ } +/*N*/ } + + +/*N*/ int +/*N*/ #ifdef WNT +/*N*/ __cdecl +/*N*/ #endif +/*N*/ ScRangeData::QsortNameCompare( const void* p1, const void* p2 ) +/*N*/ { +/*N*/ return (int) ScGlobal::pCollator->compareString( +/*N*/ (*(const ScRangeData**)p1)->aName, +/*N*/ (*(const ScRangeData**)p2)->aName ); +/*N*/ } + + +//======================================================================== +// ScRangeName +//======================================================================== + +/*N*/ ScRangeName::ScRangeName(const ScRangeName& rScRangeName, ScDocument* pDocument) : +/*N*/ SortedCollection ( rScRangeName ), +/*N*/ pDoc ( pDocument ), +/*N*/ nSharedMaxIndex (rScRangeName.nSharedMaxIndex) +/*N*/ { +/*N*/ for (USHORT i = 0; i < nCount; i++) +/*N*/ { +/*N*/ ((ScRangeData*)At(i))->SetDocument(pDocument); +/*N*/ ((ScRangeData*)At(i))->SetIndex(((ScRangeData*)rScRangeName.At(i))->GetIndex()); +/*N*/ } +/*N*/ } + +/*N*/ short ScRangeName::Compare(DataObject* pKey1, DataObject* pKey2) const +/*N*/ { +/*N*/ USHORT i1 = ((ScRangeData*)pKey1)->GetIndex(); +/*N*/ USHORT i2 = ((ScRangeData*)pKey2)->GetIndex(); +/*N*/ return (short) i1 - (short) i2; +/*N*/ } + +/*N*/ BOOL ScRangeName::SearchName( const String& rName, USHORT& rIndex ) const +/*N*/ { +/*N*/ USHORT i = 0; +/*N*/ while (i < nCount) +/*N*/ { +/*N*/ String aName; +/*N*/ ((*this)[i])->GetName( aName ); +/*N*/ if ( ScGlobal::pTransliteration->isEqual( aName, rName ) ) +/*N*/ { +/*N*/ rIndex = i; +/*N*/ return TRUE; +/*N*/ } +/*N*/ i++; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScRangeName::Load( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ USHORT nNewCount; +/*N*/ +/*N*/ while( nCount > 0 ) +/*?*/ AtFree(0); // alles loeschen +/*N*/ +/*N*/ ScMultipleReadHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT nDummy; +/*N*/ if( nVer >= SC_NEW_TOKEN_ARRAYS ) +/*N*/ rStream >> nSharedMaxIndex >> nNewCount; +/*N*/ else +/*N*/ rStream >> nSharedMaxIndex >> nDummy >> nNewCount; +/*N*/ for (USHORT i=0; i<nNewCount && bSuccess; i++) +/*N*/ { +/*N*/ ScRangeData* pData = new ScRangeData( rStream, aHdr, nVer ); +/*N*/ pData->SetDocument(pDoc); +/*N*/ Insert( pData ); +/*N*/ if( rStream.GetError() != SVSTREAM_OK ) +/*N*/ bSuccess = FALSE; +/*N*/ } +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ BOOL ScRangeName::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ ScMultipleWriteHeader aHdr( rStream ); +/*N*/ +/*N*/ USHORT i; +/*N*/ USHORT nSaveCount = nCount; +/*N*/ USHORT nSaveMaxRow = pDoc->GetSrcMaxRow(); +/*N*/ if ( nSaveMaxRow < MAXROW ) +/*N*/ { +/*N*/ nSaveCount = 0; +/*N*/ for (i=0; i<nCount; i++) +/*N*/ if ( !((const ScRangeData*)At(i))->IsBeyond(nSaveMaxRow) ) +/*N*/ ++nSaveCount; +/*N*/ +/*N*/ if ( nSaveCount < nCount ) +/*?*/ pDoc->SetLostData(); // Warnung ausgeben +/*N*/ } +/*N*/ +/*N*/ rStream << nSharedMaxIndex << nSaveCount; +/*N*/ BOOL bSuccess = TRUE; +/*N*/ +/*N*/ for (i=0; i<nCount && bSuccess; i++) +/*N*/ { +/*N*/ const ScRangeData* pRangeData = (const ScRangeData*)At(i); +/*N*/ if ( nSaveMaxRow == MAXROW || !pRangeData->IsBeyond(nSaveMaxRow) ) +/*N*/ bSuccess = pRangeData->Store( rStream, aHdr ); +/*N*/ } +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ void ScRangeName::UpdateReference( UpdateRefMode eUpdateRefMode, +/*N*/ const ScRange& rRange, +/*N*/ short nDx, short nDy, short nDz ) +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*N*/ ((ScRangeData*)pItems[i])->UpdateReference(eUpdateRefMode, rRange, +/*N*/ nDx, nDy, nDz); +/*N*/ } + + + + +/*N*/ BOOL ScRangeName::Insert(DataObject* pDataObject) +/*N*/ { +/*N*/ if (!((ScRangeData*)pDataObject)->GetIndex()) // schon gesetzt? +/*N*/ { +/*N*/ ((ScRangeData*)pDataObject)->SetIndex( GetEntryIndex() ); +/*N*/ } +/*N*/ +/*N*/ return SortedCollection::Insert(pDataObject); +/*N*/ } + +// Suche nach einem freien Index + +/*N*/ USHORT ScRangeName::GetEntryIndex() +/*N*/ { +/*N*/ USHORT nLast = 0; +/*N*/ for ( USHORT i = 0; i < nCount; i++ ) +/*N*/ { +/*N*/ USHORT nIdx = ((ScRangeData*)pItems[i])->GetIndex(); +/*N*/ if( nIdx > nLast ) +/*N*/ { +/*N*/ nLast = nIdx; +/*N*/ } +/*N*/ } +/*N*/ return nLast + 1; +/*N*/ } + +/*N*/ ScRangeData* ScRangeName::FindIndex( USHORT nIndex ) +/*N*/ { +/*N*/ ScRangeData aDataObj( nIndex ); +/*N*/ USHORT n; +/*N*/ if( Search( &aDataObj, n ) ) +/*N*/ return (*this)[ n ]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + + + +/*N*/ void ScRangeName::UpdateTabRef(USHORT nOldTable, USHORT nFlag, USHORT nNewTable) +/*N*/ { +/*N*/ for (USHORT i=0; i<nCount; i++) +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 ((ScRangeData*)pItems[i])->UpdateTabRef(nOldTable, nFlag, nNewTable); +/*N*/ } + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_rangeseq.cxx b/binfilter/bf_sc/source/core/tool/sc_rangeseq.cxx new file mode 100644 index 000000000000..32eb2c18f305 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_rangeseq.cxx @@ -0,0 +1,342 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <bf_svtools/zforlist.hxx> +#include <rtl/math.hxx> +#include <tools/debug.hxx> + + +#include "rangeseq.hxx" +#include "document.hxx" +#include "scmatrix.hxx" +#include "cell.hxx" +namespace binfilter { + +using namespace ::com::sun::star; + +//------------------------------------------------------------------------ + +/*N*/ long lcl_DoubleToLong( double fVal ) +/*N*/ { +/*N*/ double fInt = (fVal >= 0.0) ? ::rtl::math::approxFloor( fVal ) : +/*N*/ ::rtl::math::approxCeil( fVal ); +/*N*/ if ( fInt >= LONG_MIN && fInt <= LONG_MAX ) +/*N*/ return (long)fInt; +/*N*/ else +/*N*/ return 0; // out of range +/*N*/ } + +/*N*/ BOOL ScRangeToSequence::FillLongArray( uno::Any& rAny, ScDocument* pDoc, const ScRange& rRange ) +/*N*/ { +/*N*/ USHORT nTab = rRange.aStart.Tab(); +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ long nColCount = rRange.aEnd.Col() + 1 - rRange.aStart.Col(); +/*N*/ long nRowCount = rRange.aEnd.Row() + 1 - rRange.aStart.Row(); +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<INT32> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<INT32>* pRowAry = aRowSeq.getArray(); +/*N*/ for (long nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<INT32> aColSeq( nColCount ); +/*N*/ INT32* pColAry = aColSeq.getArray(); +/*N*/ for (long nCol = 0; nCol < nColCount; nCol++) +/*N*/ pColAry[nCol] = lcl_DoubleToLong( pDoc->GetValue( +/*N*/ ScAddress( (USHORT)(nStartCol+nCol), (USHORT)(nStartRow+nRow), nTab ) ) ); +/*N*/ +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; //! check for errors +/*N*/ } + + +/*N*/ BOOL ScRangeToSequence::FillLongArray( uno::Any& rAny, const ScMatrix* pMatrix ) +/*N*/ { +/*N*/ if (!pMatrix) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nColCount, nRowCount; +/*N*/ pMatrix->GetDimensions( nColCount, nRowCount ); +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<INT32> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<INT32>* pRowAry = aRowSeq.getArray(); +/*N*/ for (USHORT nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<INT32> aColSeq( nColCount ); +/*N*/ INT32* pColAry = aColSeq.getArray(); +/*N*/ for (USHORT nCol = 0; nCol < nColCount; nCol++) +/*N*/ if ( pMatrix->IsString( nCol, nRow ) ) +/*N*/ pColAry[nCol] = 0; +/*N*/ else +/*N*/ pColAry[nCol] = lcl_DoubleToLong( pMatrix->GetDouble( nCol, nRow ) ); +/*N*/ +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScRangeToSequence::FillDoubleArray( uno::Any& rAny, ScDocument* pDoc, const ScRange& rRange ) +/*N*/ { +/*N*/ USHORT nTab = rRange.aStart.Tab(); +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ long nColCount = rRange.aEnd.Col() + 1 - rRange.aStart.Col(); +/*N*/ long nRowCount = rRange.aEnd.Row() + 1 - rRange.aStart.Row(); +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<double> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<double>* pRowAry = aRowSeq.getArray(); +/*N*/ for (long nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<double> aColSeq( nColCount ); +/*N*/ double* pColAry = aColSeq.getArray(); +/*N*/ for (long nCol = 0; nCol < nColCount; nCol++) +/*N*/ pColAry[nCol] = pDoc->GetValue( +/*N*/ ScAddress( (USHORT)(nStartCol+nCol), (USHORT)(nStartRow+nRow), nTab ) ); +/*N*/ +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; //! check for errors +/*N*/ } + + +/*N*/ BOOL ScRangeToSequence::FillDoubleArray( uno::Any& rAny, const ScMatrix* pMatrix ) +/*N*/ { +/*N*/ if (!pMatrix) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nColCount, nRowCount; +/*N*/ pMatrix->GetDimensions( nColCount, nRowCount ); +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<double> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<double>* pRowAry = aRowSeq.getArray(); +/*N*/ for (USHORT nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<double> aColSeq( nColCount ); +/*N*/ double* pColAry = aColSeq.getArray(); +/*N*/ for (USHORT nCol = 0; nCol < nColCount; nCol++) +/*N*/ if ( pMatrix->IsString( nCol, nRow ) ) +/*N*/ pColAry[nCol] = 0.0; +/*N*/ else +/*N*/ pColAry[nCol] = pMatrix->GetDouble( nCol, nRow ); +/*N*/ +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScRangeToSequence::FillStringArray( uno::Any& rAny, ScDocument* pDoc, const ScRange& rRange ) +/*N*/ { +/*N*/ USHORT nTab = rRange.aStart.Tab(); +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ long nColCount = rRange.aEnd.Col() + 1 - rRange.aStart.Col(); +/*N*/ long nRowCount = rRange.aEnd.Row() + 1 - rRange.aStart.Row(); +/*N*/ +/*N*/ String aDocStr; +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<rtl::OUString> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<rtl::OUString>* pRowAry = aRowSeq.getArray(); +/*N*/ for (long nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<rtl::OUString> aColSeq( nColCount ); +/*N*/ ::rtl::OUString* pColAry = aColSeq.getArray(); +/*N*/ for (long nCol = 0; nCol < nColCount; nCol++) +/*N*/ { +/*N*/ pDoc->GetString( (USHORT)(nStartCol+nCol), (USHORT)(nStartRow+nRow), nTab, aDocStr ); +/*N*/ pColAry[nCol] = ::rtl::OUString( aDocStr ); +/*N*/ } +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; //! check for errors +/*N*/ } + + +/*N*/ BOOL ScRangeToSequence::FillStringArray( uno::Any& rAny, const ScMatrix* pMatrix, +/*N*/ SvNumberFormatter* pFormatter ) +/*N*/ { +/*N*/ if (!pMatrix) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nColCount, nRowCount; +/*N*/ pMatrix->GetDimensions( nColCount, nRowCount ); +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<rtl::OUString> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<rtl::OUString>* pRowAry = aRowSeq.getArray(); +/*N*/ for (USHORT nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<rtl::OUString> aColSeq( nColCount ); +/*N*/ ::rtl::OUString* pColAry = aColSeq.getArray(); +/*N*/ for (USHORT nCol = 0; nCol < nColCount; nCol++) +/*N*/ { +/*N*/ String aStr; +/*N*/ if ( pMatrix->IsString( nCol, nRow ) ) +/*N*/ { +/*N*/ if ( !pMatrix->IsEmpty( nCol, nRow ) ) +/*N*/ aStr = pMatrix->GetString( nCol, nRow ); +/*N*/ } +/*N*/ else if ( pFormatter ) +/*N*/ { +/*N*/ double fVal = pMatrix->GetDouble( nCol, nRow ); +/*N*/ Color* pColor; +/*N*/ pFormatter->GetOutputString( fVal, 0, aStr, &pColor ); +/*N*/ } +/*N*/ pColAry[nCol] = ::rtl::OUString( aStr ); +/*N*/ } +/*N*/ +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ double lcl_GetValueFromCell( ScBaseCell& rCell ) +/*N*/ { +/*N*/ //! ScBaseCell member function? +/*N*/ +/*N*/ CellType eType = rCell.GetCellType(); +/*N*/ if ( eType == CELLTYPE_VALUE ) +/*N*/ return ((ScValueCell&)rCell).GetValue(); +/*N*/ else if ( eType == CELLTYPE_FORMULA ) +/*N*/ return ((ScFormulaCell&)rCell).GetValue(); // called only if result is value +/*N*/ +/*N*/ DBG_ERROR( "GetValueFromCell: wrong type" ); +/*N*/ return 0; +/*N*/ } + +/*N*/ BOOL ScRangeToSequence::FillMixedArray( uno::Any& rAny, ScDocument* pDoc, const ScRange& rRange, +/*N*/ BOOL bAllowNV ) +/*N*/ { +/*N*/ USHORT nTab = rRange.aStart.Tab(); +/*N*/ USHORT nStartCol = rRange.aStart.Col(); +/*N*/ USHORT nStartRow = rRange.aStart.Row(); +/*N*/ long nColCount = rRange.aEnd.Col() + 1 - rRange.aStart.Col(); +/*N*/ long nRowCount = rRange.aEnd.Row() + 1 - rRange.aStart.Row(); +/*N*/ +/*N*/ String aDocStr; +/*N*/ BOOL bHasErrors = FALSE; +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<uno::Any> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<uno::Any>* pRowAry = aRowSeq.getArray(); +/*N*/ for (long nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<uno::Any> aColSeq( nColCount ); +/*N*/ uno::Any* pColAry = aColSeq.getArray(); +/*N*/ for (long nCol = 0; nCol < nColCount; nCol++) +/*N*/ { +/*N*/ uno::Any& rElement = pColAry[nCol]; +/*N*/ +/*N*/ ScAddress aPos( (USHORT)(nStartCol+nCol), (USHORT)(nStartRow+nRow), nTab ); +/*N*/ ScBaseCell* pCell = pDoc->GetCell( aPos ); +/*N*/ if ( pCell ) +/*N*/ { +/*N*/ if ( pCell->GetCellType() == CELLTYPE_FORMULA && +/*N*/ ((ScFormulaCell*)pCell)->GetErrCode() != 0 ) +/*N*/ { +/*N*/ // if NV is allowed, leave empty for errors +/*N*/ bHasErrors = TRUE; +/*N*/ } +/*N*/ else if ( pCell->HasValueData() ) +/*N*/ rElement <<= (double) lcl_GetValueFromCell( *pCell ); +/*N*/ else +/*N*/ rElement <<= ::rtl::OUString( pCell->GetStringData() ); +/*N*/ } +/*N*/ else +/*N*/ rElement <<= ::rtl::OUString(); // empty: empty string +/*N*/ } +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return bAllowNV || !bHasErrors; +/*N*/ } + + +/*N*/ BOOL ScRangeToSequence::FillMixedArray( uno::Any& rAny, const ScMatrix* pMatrix ) +/*N*/ { +/*N*/ if (!pMatrix) +/*N*/ return FALSE; +/*N*/ +/*N*/ USHORT nColCount, nRowCount; +/*N*/ pMatrix->GetDimensions( nColCount, nRowCount ); +/*N*/ +/*N*/ uno::Sequence< uno::Sequence<uno::Any> > aRowSeq( nRowCount ); +/*N*/ uno::Sequence<uno::Any>* pRowAry = aRowSeq.getArray(); +/*N*/ for (USHORT nRow = 0; nRow < nRowCount; nRow++) +/*N*/ { +/*N*/ uno::Sequence<uno::Any> aColSeq( nColCount ); +/*N*/ uno::Any* pColAry = aColSeq.getArray(); +/*N*/ for (USHORT nCol = 0; nCol < nColCount; nCol++) +/*N*/ { +/*N*/ if ( pMatrix->IsString( nCol, nRow ) ) +/*N*/ { +/*N*/ String aStr; +/*N*/ if ( !pMatrix->IsEmpty( nCol, nRow ) ) +/*N*/ aStr = pMatrix->GetString( nCol, nRow ); +/*N*/ pColAry[nCol] <<= ::rtl::OUString( aStr ); +/*N*/ } +/*N*/ else +/*N*/ pColAry[nCol] <<= (double) pMatrix->GetDouble( nCol, nRow ); +/*N*/ } +/*N*/ +/*N*/ pRowAry[nRow] = aColSeq; +/*N*/ } +/*N*/ +/*N*/ rAny <<= aRowSeq; +/*N*/ return TRUE; +/*N*/ } + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_rangeutl.cxx b/binfilter/bf_sc/source/core/tool/sc_rangeutl.cxx new file mode 100644 index 000000000000..cdd96ca1dd25 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_rangeutl.cxx @@ -0,0 +1,243 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> + +#include "rangeutl.hxx" +#include "document.hxx" +#include "dbcolect.hxx" +#include "rangenam.hxx" +#include "globstr.hrc" +namespace binfilter { + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScRangeUtil::IsAbsArea( const String& rAreaStr, +/*N*/ ScDocument* pDoc, +/*N*/ USHORT nTab, +/*N*/ String* pCompleteStr, +/*N*/ ScRefTripel* pStartPos, +/*N*/ ScRefTripel* pEndPos ) const +/*N*/ { +/*N*/ BOOL bIsAbsArea = FALSE; +/*N*/ ScRefTripel startPos; +/*N*/ ScRefTripel endPos; +/*N*/ +/*N*/ bIsAbsArea = ConvertDoubleRef( pDoc, rAreaStr, nTab, startPos, endPos ); +/*N*/ +/*N*/ if ( bIsAbsArea ) +/*N*/ { +/*N*/ startPos.SetRelCol( FALSE ); +/*N*/ startPos.SetRelRow( FALSE ); +/*N*/ startPos.SetRelTab( FALSE ); +/*N*/ endPos .SetRelCol( FALSE ); +/*N*/ endPos .SetRelRow( FALSE ); +/*N*/ endPos .SetRelTab( FALSE ); +/*N*/ +/*N*/ if ( pCompleteStr ) +/*N*/ { +/*N*/ *pCompleteStr = startPos.GetRefString( pDoc, MAXTAB+1 ); +/*N*/ *pCompleteStr += ':'; +/*N*/ *pCompleteStr += endPos .GetRefString( pDoc, nTab ); +/*N*/ } +/*N*/ +/*N*/ if ( pStartPos && pEndPos ) +/*N*/ { +/*N*/ *pStartPos = startPos; +/*N*/ *pEndPos = endPos; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bIsAbsArea; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ BOOL ScRangeUtil::MakeRangeFromName ( +/*N*/ const String& rName, +/*N*/ ScDocument* pDoc, +/*N*/ USHORT nCurTab, +/*N*/ ScRange& rRange, +/*N*/ RutlNameScope eScope +/*N*/ ) const +/*N*/ { +/*N*/ BOOL bResult=FALSE; +/*N*/ ScRangeUtil aRangeUtil; +/*N*/ USHORT nTab, nColStart, nColEnd, nRowStart, nRowEnd; +/*N*/ +/*N*/ if( eScope==RUTL_NAMES ) +/*N*/ { +/*N*/ ScRangeName& rRangeNames = *(pDoc->GetRangeName()); +/*N*/ USHORT nAt = 0; +/*N*/ +/*N*/ if ( rRangeNames.SearchName( rName, nAt ) ) +/*N*/ { +/*N*/ ScRangeData* pData = rRangeNames[nAt]; +/*N*/ String aStrArea; +/*N*/ ScRefTripel aStartPos; +/*N*/ ScRefTripel aEndPos; +/*N*/ +/*N*/ pData->GetSymbol( aStrArea ); +/*N*/ +/*N*/ if ( IsAbsArea( aStrArea, pDoc, nCurTab, +/*N*/ NULL, &aStartPos, &aEndPos ) ) +/*N*/ { +/*N*/ nTab = aStartPos.GetTab(); +/*N*/ nColStart = aStartPos.GetCol(); +/*N*/ nRowStart = aStartPos.GetRow(); +/*N*/ nColEnd = aEndPos.GetCol(); +/*N*/ nRowEnd = aEndPos.GetRow(); +/*N*/ bResult = TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 CutPosString( aStrArea, aStrArea ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if( eScope==RUTL_DBASE ) +/*N*/ { +/*N*/ ScDBCollection& rDbNames = *(pDoc->GetDBCollection()); +/*N*/ USHORT nAt = 0; +/*N*/ +/*N*/ if ( rDbNames.SearchName( rName, nAt ) ) +/*N*/ { +/*N*/ ScDBData* pData = rDbNames[nAt]; +/*N*/ +/*N*/ pData->GetArea( nTab, nColStart, nRowStart, +/*N*/ nColEnd, nRowEnd ); +/*N*/ bResult = TRUE; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ DBG_ERROR( "ScRangeUtil::MakeRangeFromName" ); +/*N*/ } +/*N*/ +/*N*/ if( bResult ) +/*N*/ { +/*N*/ rRange = ScRange( nColStart, nRowStart, nTab, nColEnd, nRowEnd, nTab ); +/*N*/ } +/*N*/ +/*N*/ return bResult; +/*N*/ } + +//======================================================================== + +/*N*/ ScArea::ScArea( USHORT tab, +/*N*/ USHORT colStart, USHORT rowStart, +/*N*/ USHORT colEnd, USHORT rowEnd ) : +/*N*/ nTab ( tab ), +/*N*/ nColStart( colStart ), nRowStart( rowStart ), +/*N*/ nColEnd ( colEnd ), nRowEnd ( rowEnd ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScArea::ScArea( const ScArea& r ) : +/*N*/ nTab ( r.nTab ), +/*N*/ nColStart( r.nColStart ), nRowStart( r.nRowStart ), +/*N*/ nColEnd ( r.nColEnd ), nRowEnd ( r.nRowEnd ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ ScArea& ScArea::operator=( const ScArea& r ) +/*N*/ { +/*N*/ nTab = r.nTab; +/*N*/ nColStart = r.nColStart; +/*N*/ nRowStart = r.nRowStart; +/*N*/ nColEnd = r.nColEnd; +/*N*/ nRowEnd = r.nRowEnd; +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator>> ( SvStream& rStream, ScArea& rArea ) +/*N*/ { +/*N*/ rStream >> rArea.nTab; +/*N*/ rStream >> rArea.nColStart; +/*N*/ rStream >> rArea.nRowStart; +/*N*/ rStream >> rArea.nColEnd; +/*N*/ rStream >> rArea.nRowEnd; +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator<< ( SvStream& rStream, const ScArea& rArea ) +/*N*/ { +/*N*/ rStream << rArea.nTab; +/*N*/ rStream << rArea.nColStart; +/*N*/ rStream << rArea.nRowStart; +/*N*/ rStream << rArea.nColEnd; +/*N*/ rStream << rArea.nRowEnd; +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_rechead.cxx b/binfilter/bf_sc/source/core/tool/sc_rechead.cxx new file mode 100644 index 000000000000..50dc0c6180e6 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_rechead.cxx @@ -0,0 +1,233 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#include <tools/debug.hxx> + +#include "rechead.hxx" +#include "scerrors.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +// ======================================================================= + +/*N*/ ScReadHeader::ScReadHeader(SvStream& rNewStream) : +/*N*/ rStream( rNewStream ) +/*N*/ { +/*N*/ sal_uInt32 nDataSize; +/*N*/ rStream >> nDataSize; +/*N*/ nDataEnd = rStream.Tell() + nDataSize; +/*N*/ } + +/*N*/ ScReadHeader::~ScReadHeader() +/*N*/ { +/*N*/ ULONG nReadEnd = rStream.Tell(); +/*N*/ DBG_ASSERT( nReadEnd <= nDataEnd, "zuviele Bytes gelesen" ); +/*N*/ if ( nReadEnd != nDataEnd ) +/*N*/ { +/*?*/ if ( rStream.GetError() == SVSTREAM_OK ) +/*?*/ rStream.SetError( SCWARN_IMPORT_INFOLOST ); +/*?*/ rStream.Seek(nDataEnd); // Rest ueberspringen +/*N*/ } +/*N*/ } + +/*N*/ ULONG ScReadHeader::BytesLeft() const +/*N*/ { +/*N*/ ULONG nReadEnd = rStream.Tell(); +/*N*/ if (nReadEnd <= nDataEnd) +/*N*/ return nDataEnd-nReadEnd; +/*N*/ +/*N*/ DBG_ERROR("Fehler bei ScReadHeader::BytesLeft"); +/*N*/ return 0; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScWriteHeader::ScWriteHeader(SvStream& rNewStream, sal_uInt32 nDefault) : +/*N*/ rStream( rNewStream ) +/*N*/ { +/*N*/ nDataSize = nDefault; +/*N*/ rStream << nDataSize; +/*N*/ +/*N*/ nDataPos = rStream.Tell(); +/*N*/ } + +/*N*/ ScWriteHeader::~ScWriteHeader() +/*N*/ { +/*N*/ ULONG nPos = rStream.Tell(); +/*N*/ +/*N*/ if ( nPos - nDataPos != nDataSize ) // Default getroffen? +/*N*/ { +/*N*/ nDataSize = nPos - nDataPos; +/*N*/ rStream.Seek(nDataPos - sizeof(sal_uInt32)); +/*N*/ rStream << nDataSize; // Groesse am Anfang eintragen +/*N*/ rStream.Seek(nPos); +/*N*/ } +/*N*/ } + +// ======================================================================= + +/*N*/ ScMultipleReadHeader::ScMultipleReadHeader(SvStream& rNewStream) : +/*N*/ rStream( rNewStream ) +/*N*/ { +/*N*/ sal_uInt32 nDataSize; +/*N*/ rStream >> nDataSize; +/*N*/ ULONG nDataPos = rStream.Tell(); +/*N*/ nTotalEnd = nDataPos + nDataSize; +/*N*/ nEntryEnd = nTotalEnd; +/*N*/ +/*N*/ rStream.SeekRel(nDataSize); +/*N*/ USHORT nID; +/*N*/ rStream >> nID; +/*N*/ if (nID != SCID_SIZES) +/*N*/ { +/*N*/ DBG_ERROR("SCID_SIZES nicht gefunden"); +/*N*/ if ( rStream.GetError() == SVSTREAM_OK ) +/*N*/ rStream.SetError( SVSTREAM_FILEFORMAT_ERROR ); +/*N*/ +/*N*/ // alles auf 0, damit BytesLeft() wenigstens abbricht +/*N*/ pBuf = NULL; pMemStream = NULL; +/*N*/ nEntryEnd = nDataPos; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ sal_uInt32 nSizeTableLen; +/*N*/ rStream >> nSizeTableLen; +/*N*/ pBuf = new BYTE[nSizeTableLen]; +/*N*/ rStream.Read( pBuf, nSizeTableLen ); +/*N*/ pMemStream = new SvMemoryStream( (char*)pBuf, nSizeTableLen, STREAM_READ ); +/*N*/ } +/*N*/ +/*N*/ nEndPos = rStream.Tell(); +/*N*/ rStream.Seek( nDataPos ); +/*N*/ } + +/*N*/ ScMultipleReadHeader::~ScMultipleReadHeader() +/*N*/ { +/*N*/ if ( pMemStream && pMemStream->Tell() != pMemStream->GetEndOfData() ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "Sizes nicht vollstaendig gelesen" ); +/*N*/ if ( rStream.GetError() == SVSTREAM_OK ) +/*N*/ rStream.SetError( SCWARN_IMPORT_INFOLOST ); +/*N*/ } +/*N*/ delete pMemStream; +/*N*/ delete[] pBuf; +/*N*/ +/*N*/ rStream.Seek(nEndPos); +/*N*/ } + +/*N*/ void ScMultipleReadHeader::EndEntry() +/*N*/ { +/*N*/ ULONG nPos = rStream.Tell(); +/*N*/ DBG_ASSERT( nPos <= nEntryEnd, "zuviel gelesen" ); +/*N*/ if ( nPos != nEntryEnd ) +/*N*/ { +/*?*/ if ( rStream.GetError() == SVSTREAM_OK ) +/*?*/ rStream.SetError( SCWARN_IMPORT_INFOLOST ); +/*?*/ rStream.Seek( nEntryEnd ); // Rest ueberspringen +/*N*/ } +/*N*/ +/*N*/ nEntryEnd = nTotalEnd; // den ganzen Rest, wenn kein StartEntry kommt +/*N*/ } + +/*N*/ void ScMultipleReadHeader::StartEntry() +/*N*/ { +/*N*/ ULONG nPos = rStream.Tell(); +/*N*/ sal_uInt32 nEntrySize; +/*N*/ (*pMemStream) >> nEntrySize; +/*N*/ +/*N*/ nEntryEnd = nPos + nEntrySize; +/*N*/ DBG_ASSERT( nEntryEnd <= nTotalEnd, "zuviele Eintraege gelesen" ); +/*N*/ } + +/*N*/ ULONG ScMultipleReadHeader::BytesLeft() const +/*N*/ { +/*N*/ ULONG nReadEnd = rStream.Tell(); +/*N*/ if (nReadEnd <= nEntryEnd) +/*N*/ return nEntryEnd-nReadEnd; +/*N*/ +/*N*/ DBG_ERROR("Fehler bei ScMultipleReadHeader::BytesLeft"); +/*N*/ return 0; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ ScMultipleWriteHeader::ScMultipleWriteHeader(SvStream& rNewStream, sal_uInt32 nDefault) : +/*N*/ rStream( rNewStream ), +/*N*/ aMemStream( 4096, 4096 ) +/*N*/ { +/*N*/ nDataSize = nDefault; +/*N*/ rStream << nDataSize; +/*N*/ +/*N*/ nDataPos = rStream.Tell(); +/*N*/ nEntryStart = nDataPos; +/*N*/ } + +/*N*/ ScMultipleWriteHeader::~ScMultipleWriteHeader() +/*N*/ { +/*N*/ ULONG nDataEnd = rStream.Tell(); +/*N*/ +/*N*/ rStream << (USHORT) SCID_SIZES; +/*N*/ rStream << static_cast<sal_uInt32>(aMemStream.Tell()); +/*N*/ rStream.Write( aMemStream.GetData(), aMemStream.Tell() ); +/*N*/ +/*N*/ if ( nDataEnd - nDataPos != nDataSize ) // Default getroffen? +/*N*/ { +/*N*/ nDataSize = nDataEnd - nDataPos; +/*N*/ ULONG nPos = rStream.Tell(); +/*N*/ rStream.Seek(nDataPos-sizeof(sal_uInt32)); +/*N*/ rStream << nDataSize; // Groesse am Anfang eintragen +/*N*/ rStream.Seek(nPos); +/*N*/ } +/*N*/ } + +/*N*/ void ScMultipleWriteHeader::EndEntry() +/*N*/ { +/*N*/ ULONG nPos = rStream.Tell(); +/*N*/ aMemStream << static_cast<sal_uInt32>(nPos - nEntryStart); +/*N*/ } + +/*N*/ void ScMultipleWriteHeader::StartEntry() +/*N*/ { +/*N*/ ULONG nPos = rStream.Tell(); +/*N*/ nEntryStart = nPos; +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_refdata.cxx b/binfilter/bf_sc/source/core/tool/sc_refdata.cxx new file mode 100644 index 000000000000..7912eea6d3a8 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_refdata.cxx @@ -0,0 +1,298 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "refdata.hxx" +namespace binfilter { + + +/*N*/ void SingleRefData::CalcRelFromAbs( const ScAddress& rPos ) +/*N*/ { +/*N*/ nRelCol = nCol - rPos.Col(); +/*N*/ nRelRow = nRow - rPos.Row(); +/*N*/ nRelTab = nTab - rPos.Tab(); +/*N*/ } + + +/*N*/ void SingleRefData::SmartRelAbs( const ScAddress& rPos ) +/*N*/ { +/*N*/ if ( Flags.bColRel ) +/*N*/ nCol = nRelCol + rPos.Col(); +/*N*/ else +/*N*/ nRelCol = nCol - rPos.Col(); +/*N*/ +/*N*/ if ( Flags.bRowRel ) +/*N*/ nRow = nRelRow + rPos.Row(); +/*N*/ else +/*N*/ nRelRow = nRow - rPos.Row(); +/*N*/ +/*N*/ if ( Flags.bTabRel ) +/*N*/ nTab = nRelTab + rPos.Tab(); +/*N*/ else +/*N*/ nRelTab = nTab - rPos.Tab(); +/*N*/ } + + +/*N*/ void SingleRefData::CalcAbsIfRel( const ScAddress& rPos ) +/*N*/ { +/*N*/ if ( Flags.bColRel ) +/*N*/ { +/*N*/ nCol = nRelCol + rPos.Col(); +/*N*/ if ( !VALIDCOL( nCol ) ) +/*N*/ Flags.bColDeleted = TRUE; +/*N*/ } +/*N*/ if ( Flags.bRowRel ) +/*N*/ { +/*N*/ nRow = nRelRow + rPos.Row(); +/*N*/ if ( !VALIDROW( nRow ) ) +/*N*/ Flags.bRowDeleted = TRUE; +/*N*/ } +/*N*/ if ( Flags.bTabRel ) +/*N*/ { +/*N*/ nTab = nRelTab + rPos.Tab(); +/*N*/ if ( !VALIDTAB( nTab ) ) +/*N*/ Flags.bTabDeleted = TRUE; +/*N*/ } +/*N*/ } + + +/*N*/ void SingleRefData::OldBoolsToNewFlags( const OldSingleRefBools& rBools ) +/*N*/ { +/*N*/ switch ( rBools.bRelCol ) +/*N*/ { +/*N*/ case SR_DELETED : +/*?*/ Flags.bColRel = TRUE; // der war verlorengegangen +/*?*/ Flags.bColDeleted = TRUE; +/*?*/ break; +/*N*/ case SR_ABSOLUTE : +/*N*/ Flags.bColRel = FALSE; +/*N*/ Flags.bColDeleted = FALSE; +/*N*/ break; +/*N*/ case SR_RELABS : +/*N*/ case SR_RELATIVE : +/*N*/ default: +/*N*/ Flags.bColRel = TRUE; +/*N*/ Flags.bColDeleted = FALSE; +/*N*/ } +/*N*/ switch ( rBools.bRelRow ) +/*N*/ { +/*N*/ case SR_DELETED : +/*?*/ Flags.bRowRel = TRUE; // der war verlorengegangen +/*?*/ Flags.bRowDeleted = TRUE; +/*?*/ break; +/*N*/ case SR_ABSOLUTE : +/*N*/ Flags.bRowRel = FALSE; +/*N*/ Flags.bRowDeleted = FALSE; +/*N*/ break; +/*N*/ case SR_RELABS : +/*N*/ case SR_RELATIVE : +/*N*/ default: +/*N*/ Flags.bRowRel = TRUE; +/*N*/ Flags.bRowDeleted = FALSE; +/*N*/ } +/*N*/ switch ( rBools.bRelTab ) +/*N*/ { +/*N*/ case SR_DELETED : +/*?*/ Flags.bTabRel = TRUE; // der war verlorengegangen +/*?*/ Flags.bTabDeleted = TRUE; +/*?*/ break; +/*N*/ case SR_ABSOLUTE : +/*N*/ Flags.bTabRel = FALSE; +/*N*/ Flags.bTabDeleted = FALSE; +/*N*/ break; +/*N*/ case SR_RELABS : +/*N*/ case SR_RELATIVE : +/*N*/ default: +/*N*/ Flags.bTabRel = TRUE; +/*N*/ Flags.bTabDeleted = FALSE; +/*N*/ } +/*N*/ Flags.bFlag3D = (rBools.bOldFlag3D & SRF_3D ? TRUE : FALSE); +/*N*/ Flags.bRelName = (rBools.bOldFlag3D & SRF_RELNAME ? TRUE : FALSE); +/*N*/ if ( !Flags.bFlag3D ) +/*N*/ Flags.bTabRel = TRUE; // ist bei einigen aelteren Dokumenten nicht gesetzt +/*N*/ } + + +/* + bis Release 3.1 sah Store so aus + + BYTE n = ( ( r.bOldFlag3D & 0x03 ) << 6 ) // RelName, 3D + | ( ( r.bRelTab & 0x03 ) << 4 ) // Relative, RelAbs + | ( ( r.bRelRow & 0x03 ) << 2 ) + | ( r.bRelCol & 0x03 ); + + bis Release 3.1 sah Load so aus + + r.bRelCol = ( n & 0x03 ); + r.bRelRow = ( ( n >> 2 ) & 0x03 ); + r.bRelTab = ( ( n >> 4 ) & 0x03 ); + r.bOldFlag3D = ( ( n >> 6 ) & 0x03 ); + + bRelCol == SR_DELETED war identisch mit bRelCol == (SR_RELATIVE | SR_RELABS) + leider.. + 3.1 liest Zukunft: Deleted wird nicht unbedingt erkannt, nur wenn auch Relativ. + Aber immer noch nCol > MAXCOL und gut sollte sein.. + */ + +/*N*/ BYTE SingleRefData::CreateStoreByteFromFlags() const +/*N*/ { +/*N*/ return (BYTE)( +/*N*/ ( (Flags.bRelName & 0x01) << 7 ) +/*N*/ | ( (Flags.bFlag3D & 0x01) << 6 ) +/*N*/ | ( (Flags.bTabDeleted & 0x01) << 5 ) +/*N*/ | ( (Flags.bTabRel & 0x01) << 4 ) +/*N*/ | ( (Flags.bRowDeleted & 0x01) << 3 ) +/*N*/ | ( (Flags.bRowRel & 0x01) << 2 ) +/*N*/ | ( (Flags.bColDeleted & 0x01) << 1 ) +/*N*/ | (Flags.bColRel & 0x01) +/*N*/ ); +/*N*/ } + + +/*N*/ void SingleRefData::CreateFlagsFromLoadByte( BYTE n ) +/*N*/ { +/*N*/ Flags.bColRel = (n & 0x01 ); +/*N*/ Flags.bColDeleted = ( (n >> 1) & 0x01 ); +/*N*/ Flags.bRowRel = ( (n >> 2) & 0x01 ); +/*N*/ Flags.bRowDeleted = ( (n >> 3) & 0x01 ); +/*N*/ Flags.bTabRel = ( (n >> 4) & 0x01 ); +/*N*/ Flags.bTabDeleted = ( (n >> 5) & 0x01 ); +/*N*/ Flags.bFlag3D = ( (n >> 6) & 0x01 ); +/*N*/ Flags.bRelName = ( (n >> 7) & 0x01 ); +/*N*/ } + + +/*N*/ BOOL SingleRefData::operator==( const SingleRefData& r ) const +/*N*/ { +/*N*/ return bFlags == r.bFlags && +/*N*/ (Flags.bColRel ? nRelCol == r.nRelCol : nCol == r.nCol) && +/*N*/ (Flags.bRowRel ? nRelRow == r.nRelRow : nRow == r.nRow) && +/*N*/ (Flags.bTabRel ? nRelTab == r.nRelTab : nTab == r.nTab); +/*N*/ } + + +// Abs-Refs muessen vorher aktualisiert werden! +// wird in refupdat.cxx mit MoveRelWrap verwendet +/*N*/ void ComplRefData::PutInOrder() +/*N*/ { +/*N*/ register short n1, n2; +/*N*/ register BOOL bTmp; +/*N*/ BYTE nRelState1, nRelState2; +/*N*/ if ( Ref1.Flags.bRelName ) +/*?*/ nRelState1 = +/*?*/ ((Ref1.Flags.bTabRel & 0x01) << 2) +/*?*/ | ((Ref1.Flags.bRowRel & 0x01) << 1) +/*?*/ | ((Ref1.Flags.bColRel & 0x01)); +/*N*/ else +/*N*/ nRelState1 = 0; +/*N*/ if ( Ref2.Flags.bRelName ) +/*?*/ nRelState2 = +/*?*/ ((Ref2.Flags.bTabRel & 0x01) << 2) +/*?*/ | ((Ref2.Flags.bRowRel & 0x01) << 1) +/*?*/ | ((Ref2.Flags.bColRel & 0x01)); +/*N*/ else +/*N*/ nRelState2 = 0; +/*N*/ if ( (n1 = Ref1.nCol) > (n2 = Ref2.nCol) ) +/*N*/ { +/*?*/ Ref1.nCol = n2; +/*?*/ Ref2.nCol = n1; +/*?*/ n1 = Ref1.nRelCol; +/*?*/ Ref1.nRelCol = Ref2.nRelCol; +/*?*/ Ref2.nRelCol = n1; +/*?*/ if ( Ref1.Flags.bRelName && Ref1.Flags.bColRel ) +/*?*/ nRelState2 |= 1; +/*?*/ else +/*?*/ nRelState2 &= ~1; +/*?*/ if ( Ref2.Flags.bRelName && Ref2.Flags.bColRel ) +/*?*/ nRelState1 |= 1; +/*?*/ else +/*?*/ nRelState1 &= ~1; +/*?*/ bTmp = Ref1.Flags.bColRel; +/*?*/ Ref1.Flags.bColRel = Ref2.Flags.bColRel; +/*?*/ Ref2.Flags.bColRel = bTmp; +/*?*/ bTmp = Ref1.Flags.bColDeleted; +/*?*/ Ref1.Flags.bColDeleted = Ref2.Flags.bColDeleted; +/*?*/ Ref2.Flags.bColDeleted = bTmp; +/*N*/ } +/*N*/ if ( (n1 = Ref1.nRow) > (n2 = Ref2.nRow) ) +/*N*/ { +/*?*/ Ref1.nRow = n2; +/*?*/ Ref2.nRow = n1; +/*?*/ n1 = Ref1.nRelRow; +/*?*/ Ref1.nRelRow = Ref2.nRelRow; +/*?*/ Ref2.nRelRow = n1; +/*?*/ if ( Ref1.Flags.bRelName && Ref1.Flags.bRowRel ) +/*?*/ nRelState2 |= 2; +/*?*/ else +/*?*/ nRelState2 &= ~2; +/*?*/ if ( Ref2.Flags.bRelName && Ref2.Flags.bRowRel ) +/*?*/ nRelState1 |= 2; +/*?*/ else +/*?*/ nRelState1 &= ~2; +/*?*/ bTmp = Ref1.Flags.bRowRel; +/*?*/ Ref1.Flags.bRowRel = Ref2.Flags.bRowRel; +/*?*/ Ref2.Flags.bRowRel = bTmp; +/*?*/ bTmp = Ref1.Flags.bRowDeleted; +/*?*/ Ref1.Flags.bRowDeleted = Ref2.Flags.bRowDeleted; +/*?*/ Ref2.Flags.bRowDeleted = bTmp; +/*N*/ } +/*N*/ if ( (n1 = Ref1.nTab) > (n2 = Ref2.nTab) ) +/*N*/ { +/*?*/ Ref1.nTab = n2; +/*?*/ Ref2.nTab = n1; +/*?*/ n1 = Ref1.nRelTab; +/*?*/ Ref1.nRelTab = Ref2.nRelTab; +/*?*/ Ref2.nRelTab = n1; +/*?*/ if ( Ref1.Flags.bRelName && Ref1.Flags.bTabRel ) +/*?*/ nRelState2 |= 4; +/*?*/ else +/*?*/ nRelState2 &= ~4; +/*?*/ if ( Ref2.Flags.bRelName && Ref2.Flags.bTabRel ) +/*?*/ nRelState1 |= 4; +/*?*/ else +/*?*/ nRelState1 &= ~4; +/*?*/ bTmp = Ref1.Flags.bTabRel; +/*?*/ Ref1.Flags.bTabRel = Ref2.Flags.bTabRel; +/*?*/ Ref2.Flags.bTabRel = bTmp; +/*?*/ bTmp = Ref1.Flags.bTabDeleted; +/*?*/ Ref1.Flags.bTabDeleted = Ref2.Flags.bTabDeleted; +/*?*/ Ref2.Flags.bTabDeleted = bTmp; +/*?*/ bTmp = Ref1.Flags.bFlag3D; +/*?*/ Ref1.Flags.bFlag3D = Ref2.Flags.bFlag3D; +/*?*/ Ref2.Flags.bFlag3D = bTmp; +/*N*/ } +/*N*/ Ref1.Flags.bRelName = ( nRelState1 ? TRUE : FALSE ); +/*N*/ Ref2.Flags.bRelName = ( nRelState2 ? TRUE : FALSE ); +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_refreshtimer.cxx b/binfilter/bf_sc/source/core/tool/sc_refreshtimer.cxx new file mode 100644 index 000000000000..392942d34b05 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_refreshtimer.cxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "refreshtimer.hxx" +#include <tools/debug.hxx>//STRIP001 +namespace binfilter { + +/*N*/ ScRefreshTimerProtector::ScRefreshTimerProtector( ScRefreshTimerControl * const * pp ) +/*N*/ : +/*N*/ ppControl( pp ) +/*N*/ { +/*N*/ if ( ppControl && *ppControl ) +/*N*/ { +/*N*/ (*ppControl)->SetAllowRefresh( FALSE ); +/*N*/ // wait for any running refresh in another thread to finnish +/*N*/ ::osl::MutexGuard aGuard( (*ppControl)->GetMutex() ); +/*N*/ } +/*N*/ } + + +/*N*/ ScRefreshTimer::~ScRefreshTimer() +/*N*/ { +/*N*/ if ( IsActive() ) +/*?*/ Stop(); +/*N*/ RemoveFromControl(); +/*N*/ } + + +/*N*/ void ScRefreshTimer::SetRefreshDelay( ULONG nSeconds ) +/*N*/ { +/*N*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 BOOL bActive = IsActive(); +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_refupdat.cxx b/binfilter/bf_sc/source/core/tool/sc_refupdat.cxx new file mode 100644 index 000000000000..3965c1bb0376 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_refupdat.cxx @@ -0,0 +1,768 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + + +#include "refupdat.hxx" +#include "compiler.hxx" +#include "chgtrack.hxx" +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ BOOL lcl_MoveStart( short& rRef, short nStart, short nDelta, short nMask ) +/*N*/ { +/*N*/ BOOL bCut = FALSE; +/*N*/ if ( rRef >= nStart ) +/*N*/ rRef += nDelta; +/*N*/ else if ( nDelta < 0 && rRef >= nStart + nDelta ) +/*N*/ rRef = nStart + nDelta; //! begrenzen ??? +/*N*/ if ( rRef < 0 ) +/*N*/ { +/*N*/ rRef = 0; +/*N*/ bCut = TRUE; +/*N*/ } +/*N*/ else if ( rRef > nMask ) +/*N*/ { +/*N*/ rRef = nMask; +/*N*/ bCut = TRUE; +/*N*/ } +/*N*/ return bCut; +/*N*/ } + +/*N*/ BOOL lcl_MoveEnd( short& rRef, short nStart, short nDelta, short nMask ) +/*N*/ { +/*N*/ BOOL bCut = FALSE; +/*N*/ if ( rRef >= nStart ) +/*N*/ rRef += nDelta; +/*N*/ else if ( nDelta < 0 && rRef >= nStart + nDelta ) +/*N*/ rRef = nStart + nDelta - 1; //! begrenzen ??? +/*N*/ if ( rRef < 0 ) +/*N*/ { +/*N*/ rRef = 0; +/*N*/ bCut = TRUE; +/*N*/ } +/*N*/ else if ( rRef > nMask ) +/*N*/ { +/*N*/ rRef = nMask; +/*N*/ bCut = TRUE; +/*N*/ } +/*N*/ return bCut; +/*N*/ } + + +/*N*/ BOOL lcl_MoveItCut( short& rRef, short nDelta, short nMask ) +/*N*/ { +/*N*/ BOOL bCut = FALSE; +/*N*/ rRef += nDelta; +/*N*/ if ( rRef < 0 ) +/*N*/ { +/*N*/ rRef = 0; +/*N*/ bCut = TRUE; +/*N*/ } +/*N*/ else if ( rRef > nMask ) +/*N*/ { +/*N*/ rRef = nMask; +/*N*/ bCut = TRUE; +/*N*/ } +/*N*/ return bCut; +/*N*/ } + +/*N*/ void lcl_MoveItWrap( short& rRef, short nDelta, short nMask ) +/*N*/ { +/*N*/ rRef += nDelta; +/*N*/ if ( rRef < 0 ) +/*N*/ rRef += nMask+1; +/*N*/ else if ( rRef > nMask ) +/*N*/ rRef -= nMask+1; +/*N*/ } + +/*N*/ BOOL lcl_MoveRefPart( short& rRef1Val, BOOL& rRef1Del, +/*N*/ short& rRef2Val, BOOL& rRef2Del, +/*N*/ short nStart, short nEnd, short nDelta, short nMask ) +/*N*/ { +/*N*/ if ( nDelta ) +/*N*/ { +/*N*/ BOOL bDel, bCut1, bCut2; +/*N*/ bDel = bCut1 = bCut2 = FALSE; +/*N*/ short n; +/*N*/ if ( nDelta < 0 ) +/*N*/ { +/*N*/ n = nStart + nDelta; +/*N*/ if ( n <= rRef1Val && rRef1Val < nStart +/*N*/ && n <= rRef2Val && rRef2Val < nStart ) +/*N*/ bDel = TRUE; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ n = nEnd + nDelta; +/*N*/ if ( nEnd < rRef1Val && rRef1Val <= n +/*N*/ && nEnd < rRef2Val && rRef2Val <= n ) +/*N*/ bDel = TRUE; +/*N*/ } +/*N*/ if ( bDel ) +/*N*/ { // geloeschte mitverschieben +/*N*/ rRef1Val += nDelta; +/*N*/ rRef2Val += nDelta; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( rRef1Del ) +/*N*/ rRef1Val += nDelta; +/*N*/ else +/*N*/ bCut1 = lcl_MoveStart( rRef1Val, nStart, nDelta, nMask ); +/*N*/ if ( rRef2Del ) +/*N*/ rRef2Val += nDelta; +/*N*/ else +/*N*/ bCut2 = lcl_MoveEnd( rRef2Val, nStart, nDelta, nMask ); +/*N*/ } +/*N*/ if ( bDel || (bCut1 && bCut2) ) +/*N*/ rRef1Del = rRef2Del = TRUE; +/*N*/ return bDel || bCut1 || bCut2 || rRef1Del || rRef2Del; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } + +/*N*/ #if OSL_DEBUG_LEVEL < 2 +/*N*/ inline +/*N*/ #endif +/*N*/ BOOL IsExpand( short n1, short n2, short nStart, short nD ) +/*N*/ { //! vor normalem Move... +/*N*/ return +/*N*/ nD > 0 // Insert +/*N*/ && n1 < n2 // mindestens zwei Cols/Rows/Tabs in Ref +/*N*/ && ( +/*N*/ (nStart <= n1 && n1 < nStart + nD) // n1 innerhalb des Insert +/*N*/ || (n2 + 1 == nStart) // n2 direkt vor Insert +/*N*/ ); // n1 < nStart <= n2 wird sowieso expanded! +/*N*/ } + + +/*N*/ #if OSL_DEBUG_LEVEL < 2 +/*N*/ inline +/*N*/ #endif +/*N*/ void Expand( short& n1, short& n2, short nStart, short nD ) +/*N*/ { //! nach normalem Move..., nur wenn IsExpand vorher TRUE war! +/*N*/ //! erst das Ende +/*N*/ if ( n2 + 1 == nStart ) +/*N*/ { // am Ende +/*N*/ n2 += nD; +/*N*/ return; +/*N*/ } +/*N*/ // am Anfang +/*N*/ n1 -= nD; +/*N*/ } + + +/*N*/ BOOL lcl_IsWrapBig( INT32 nRef, INT32 nDelta ) +/*N*/ { +/*N*/ if ( nRef > 0 && nDelta > 0 ) +/*N*/ return nRef + nDelta <= 0; +/*N*/ else if ( nRef < 0 && nDelta < 0 ) +/*N*/ return nRef + nDelta >= 0; +/*N*/ return FALSE; +/*N*/ } + + +/*N*/ BOOL lcl_MoveBig( INT32& rRef, INT32 nStart, INT32 nDelta ) +/*N*/ { +/*N*/ BOOL bCut = FALSE; +/*N*/ if ( rRef >= nStart ) +/*N*/ { +/*N*/ if ( nDelta > 0 ) +/*N*/ bCut = lcl_IsWrapBig( rRef, nDelta ); +/*N*/ if ( bCut ) +/*N*/ rRef = nInt32Max; +/*N*/ else +/*N*/ rRef += nDelta; +/*N*/ } +/*N*/ return bCut; +/*N*/ } + +/*N*/ BOOL lcl_MoveItCutBig( INT32& rRef, INT32 nDelta ) +/*N*/ { +/*N*/ BOOL bCut = lcl_IsWrapBig( rRef, nDelta ); +/*N*/ rRef += nDelta; +/*N*/ return bCut; +/*N*/ } + + +/*N*/ ScRefUpdateRes ScRefUpdate::Update( ScDocument* pDoc, UpdateRefMode eUpdateRefMode, +/*N*/ USHORT nCol1, USHORT nRow1, USHORT nTab1, +/*N*/ USHORT nCol2, USHORT nRow2, USHORT nTab2, +/*N*/ short nDx, short nDy, short nDz, +/*N*/ USHORT& theCol1, USHORT& theRow1, USHORT& theTab1, +/*N*/ USHORT& theCol2, USHORT& theRow2, USHORT& theTab2 ) +/*N*/ { +/*N*/ ScRefUpdateRes eRet = UR_NOTHING; +/*N*/ +/*N*/ USHORT oldCol1 = theCol1; +/*N*/ USHORT oldRow1 = theRow1; +/*N*/ USHORT oldTab1 = theTab1; +/*N*/ USHORT oldCol2 = theCol2; +/*N*/ USHORT oldRow2 = theRow2; +/*N*/ USHORT oldTab2 = theTab2; +/*N*/ +/*N*/ BOOL bCut1, bCut2; +/*N*/ +/*N*/ if (eUpdateRefMode == URM_INSDEL) +/*N*/ { +/*N*/ BOOL bExpand = pDoc->IsExpandRefs(); +/*N*/ if ( nDx && (theRow1 >= nRow1) && (theRow2 <= nRow2) && +/*N*/ (theTab1 >= nTab1) && (theTab2 <= nTab2) ) +/*N*/ { +/*N*/ BOOL bExp = (bExpand && IsExpand( theCol1, theCol2, nCol1, nDx )); +/*N*/ bCut1 = lcl_MoveStart( (short&) theCol1, nCol1, nDx, MAXCOL ); +/*N*/ bCut2 = lcl_MoveEnd( (short&) theCol2, nCol1, nDx, MAXCOL ); +/*N*/ if ( theCol2 < theCol1 ) +/*N*/ { +/*N*/ eRet = UR_INVALID; +/*N*/ theCol2 = theCol1; +/*N*/ } +/*N*/ else if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bExp ) +/*N*/ { +/*N*/ Expand( (short&) theCol1, (short&) theCol2, nCol1, nDx ); +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ } +/*N*/ if ( nDy && (theCol1 >= nCol1) && (theCol2 <= nCol2) && +/*N*/ (theTab1 >= nTab1) && (theTab2 <= nTab2) ) +/*N*/ { +/*?*/ BOOL bExp = (bExpand && IsExpand( theRow1, theRow2, nRow1, nDy )); +/*?*/ bCut1 = lcl_MoveStart( (short&) theRow1, nRow1, nDy, MAXROW ); +/*?*/ bCut2 = lcl_MoveEnd( (short&) theRow2, nRow1, nDy, MAXROW ); +/*?*/ if ( theRow2 < theRow1 ) +/*?*/ { +/*?*/ eRet = UR_INVALID; +/*?*/ theRow2 = theRow1; +/*?*/ } +/*?*/ else if ( bCut1 || bCut2 ) +/*?*/ eRet = UR_UPDATED; +/*?*/ if ( bExp ) +/*?*/ { +/*?*/ Expand( (short&) theRow1, (short&) theRow2, nRow1, nDy ); +/*?*/ eRet = UR_UPDATED; +/*?*/ } +/*N*/ } +/*N*/ if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) && +/*N*/ (theRow1 >= nRow1) && (theRow2 <= nRow2) ) +/*N*/ { +/*N*/ short nMaxTab = pDoc->GetTableCount() - 1; +/*N*/ nMaxTab += nDz; // auf die neue Anzahl anpassen +/*N*/ BOOL bExp = (bExpand && IsExpand( theTab1, theTab2, nTab1, nDz )); +/*N*/ bCut1 = lcl_MoveStart( (short&) theTab1, nTab1, nDz, nMaxTab ); +/*N*/ bCut2 = lcl_MoveEnd( (short&) theTab2, nTab1, nDz, nMaxTab ); +/*N*/ if ( theTab2 < theTab1 ) +/*N*/ { +/*N*/ eRet = UR_INVALID; +/*N*/ theTab2 = theTab1; +/*N*/ } +/*N*/ else if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bExp ) +/*N*/ { +/*?*/ Expand( (short&) theTab1, (short&) theTab2, nTab1, nDz ); +/*?*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else if (eUpdateRefMode == URM_MOVE) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 if ((theCol1 >= nCol1-nDx) && (theRow1 >= nRow1-nDy) && (theTab1 >= nTab1-nDz) && +/*N*/ } +/*N*/ else if (eUpdateRefMode == URM_REORDER) +/*N*/ { +/*?*/ // bisher nur fuer nDz (MoveTab) +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 DBG_ASSERT ( !nDx && !nDy, "URM_REORDER fuer x und y noch nicht implementiert" ); +/*N*/ } +/*N*/ +/*N*/ if ( eRet == UR_NOTHING ) +/*N*/ { +/*N*/ if (oldCol1 != theCol1 +/*N*/ || oldRow1 != theRow1 +/*N*/ || oldTab1 != theTab1 +/*N*/ || oldCol2 != theCol2 +/*N*/ || oldRow2 != theRow2 +/*N*/ || oldTab2 != theTab2 +/*N*/ ) +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ return eRet; +/*N*/ } + + +// simples UpdateReference fuer ScBigRange (ScChangeAction/ScChangeTrack) +// Referenzen koennen auch ausserhalb des Dokuments liegen! +// Ganze Spalten/Zeilen (nInt32Min..nInt32Max) bleiben immer solche! +/*N*/ ScRefUpdateRes ScRefUpdate::Update( UpdateRefMode eUpdateRefMode, +/*N*/ const ScBigRange& rWhere, INT32 nDx, INT32 nDy, INT32 nDz, +/*N*/ ScBigRange& rWhat ) +/*N*/ { +/*N*/ ScRefUpdateRes eRet = UR_NOTHING; +/*N*/ const ScBigRange aOldRange( rWhat ); +/*N*/ +/*N*/ INT32 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; +/*N*/ INT32 theCol1, theRow1, theTab1, theCol2, theRow2, theTab2; +/*N*/ rWhere.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); +/*N*/ rWhat.GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 ); +/*N*/ +/*N*/ BOOL bCut1, bCut2; +/*N*/ +/*N*/ if (eUpdateRefMode == URM_INSDEL) +/*N*/ { +/*N*/ if ( nDx && (theRow1 >= nRow1) && (theRow2 <= nRow2) && +/*N*/ (theTab1 >= nTab1) && (theTab2 <= nTab2) && +/*N*/ !(theCol1 == nInt32Min && theCol2 == nInt32Max) ) +/*N*/ { +/*N*/ bCut1 = lcl_MoveBig( theCol1, nCol1, nDx ); +/*N*/ bCut2 = lcl_MoveBig( theCol2, nCol1, nDx ); +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ rWhat.aStart.SetCol( theCol1 ); +/*N*/ rWhat.aEnd.SetCol( theCol2 ); +/*N*/ } +/*N*/ if ( nDy && (theCol1 >= nCol1) && (theCol2 <= nCol2) && +/*N*/ (theTab1 >= nTab1) && (theTab2 <= nTab2) && +/*N*/ !(theRow1 == nInt32Min && theRow2 == nInt32Max) ) +/*N*/ { +/*N*/ bCut1 = lcl_MoveBig( theRow1, nRow1, nDy ); +/*N*/ bCut2 = lcl_MoveBig( theRow2, nRow1, nDy ); +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ rWhat.aStart.SetRow( theRow1 ); +/*N*/ rWhat.aEnd.SetRow( theRow2 ); +/*N*/ } +/*N*/ if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) && +/*N*/ (theRow1 >= nRow1) && (theRow2 <= nRow2) && +/*N*/ !(theTab1 == nInt32Min && theTab2 == nInt32Max) ) +/*N*/ { +/*N*/ bCut1 = lcl_MoveBig( theTab1, nTab1, nDz ); +/*N*/ bCut2 = lcl_MoveBig( theTab2, nTab1, nDz ); +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ rWhat.aStart.SetTab( theTab1 ); +/*N*/ rWhat.aEnd.SetTab( theTab2 ); +/*N*/ } +/*N*/ } +/*N*/ else if (eUpdateRefMode == URM_MOVE) +/*N*/ { +/*N*/ if ( rWhere.In( rWhat ) ) +/*N*/ { +/*N*/ if ( nDx && !(theCol1 == nInt32Min && theCol2 == nInt32Max) ) +/*N*/ { +/*N*/ bCut1 = lcl_MoveItCutBig( theCol1, nDx ); +/*N*/ bCut2 = lcl_MoveItCutBig( theCol2, nDx ); +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ rWhat.aStart.SetCol( theCol1 ); +/*N*/ rWhat.aEnd.SetCol( theCol2 ); +/*N*/ } +/*N*/ if ( nDy && !(theRow1 == nInt32Min && theRow2 == nInt32Max) ) +/*N*/ { +/*N*/ bCut1 = lcl_MoveItCutBig( theRow1, nDy ); +/*N*/ bCut2 = lcl_MoveItCutBig( theRow2, nDy ); +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ rWhat.aStart.SetRow( theRow1 ); +/*N*/ rWhat.aEnd.SetRow( theRow2 ); +/*N*/ } +/*N*/ if ( nDz && !(theTab1 == nInt32Min && theTab2 == nInt32Max) ) +/*N*/ { +/*N*/ bCut1 = lcl_MoveItCutBig( theTab1, nDz ); +/*N*/ bCut2 = lcl_MoveItCutBig( theTab2, nDz ); +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ rWhat.aStart.SetTab( theTab1 ); +/*N*/ rWhat.aEnd.SetTab( theTab2 ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( eRet == UR_NOTHING && rWhat != aOldRange ) +/*N*/ eRet = UR_UPDATED; +/*N*/ +/*N*/ return eRet; +/*N*/ } + + +// vor dem Aufruf muessen die Abs-Refs aktualisiert werden! +/*N*/ ScRefUpdateRes ScRefUpdate::Update( ScDocument* pDoc, UpdateRefMode eMode, +/*N*/ const ScAddress& rPos, const ScRange& r, +/*N*/ short nDx, short nDy, short nDz, +/*N*/ ComplRefData& rRef ) +/*N*/ { +/*N*/ ScRefUpdateRes eRet = UR_NOTHING; +/*N*/ +/*N*/ short nCol1 = r.aStart.Col(); +/*N*/ short nRow1 = r.aStart.Row(); +/*N*/ short nTab1 = r.aStart.Tab(); +/*N*/ short nCol2 = r.aEnd.Col(); +/*N*/ short nRow2 = r.aEnd.Row(); +/*N*/ short nTab2 = r.aEnd.Tab(); +/*N*/ +/*N*/ if( eMode == URM_INSDEL ) +/*N*/ { +/*N*/ BOOL bExpand = pDoc->IsExpandRefs(); +/*N*/ +/*N*/ const ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack(); +/*N*/ BOOL bInDeleteUndo = +/*N*/ ( pChangeTrack ? pChangeTrack->IsInDeleteUndo() : FALSE ); +/*N*/ +/*N*/ USHORT oldCol1 = rRef.Ref1.nCol; +/*N*/ USHORT oldRow1 = rRef.Ref1.nRow; +/*N*/ USHORT oldTab1 = rRef.Ref1.nTab; +/*N*/ USHORT oldCol2 = rRef.Ref2.nCol; +/*N*/ USHORT oldRow2 = rRef.Ref2.nRow; +/*N*/ USHORT oldTab2 = rRef.Ref2.nTab; +/*N*/ +/*N*/ BOOL bRef1ColDel = rRef.Ref1.IsColDeleted(); +/*N*/ BOOL bRef2ColDel = rRef.Ref2.IsColDeleted(); +/*N*/ BOOL bRef1RowDel = rRef.Ref1.IsRowDeleted(); +/*N*/ BOOL bRef2RowDel = rRef.Ref2.IsRowDeleted(); +/*N*/ BOOL bRef1TabDel = rRef.Ref1.IsTabDeleted(); +/*N*/ BOOL bRef2TabDel = rRef.Ref2.IsTabDeleted(); +/*N*/ +/*N*/ if( nDx && +/*N*/ ((rRef.Ref1.nRow >= nRow1 +/*N*/ && rRef.Ref2.nRow <= nRow2) || (bRef1RowDel || bRef2RowDel)) +/*N*/ && +/*N*/ ((rRef.Ref1.nTab >= nTab1 +/*N*/ && rRef.Ref2.nTab <= nTab2) || (bRef1TabDel || bRef2TabDel)) +/*N*/ ) +/*N*/ { +/*N*/ BOOL bExp = (bExpand && !bInDeleteUndo && IsExpand( rRef.Ref1.nCol, +/*N*/ rRef.Ref2.nCol, nCol1, nDx )); +/*N*/ if ( lcl_MoveRefPart( rRef.Ref1.nCol, bRef1ColDel, +/*N*/ rRef.Ref2.nCol, bRef2ColDel, +/*N*/ nCol1, nCol2, nDx, MAXCOL ) ) +/*N*/ { +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bInDeleteUndo && (bRef1ColDel || bRef2ColDel) ) +/*N*/ { +/*N*/ if ( bRef1ColDel && nCol1 <= rRef.Ref1.nCol && +/*N*/ rRef.Ref1.nCol <= nCol1 + nDx ) +/*N*/ rRef.Ref1.SetColDeleted( FALSE ); +/*N*/ if ( bRef2ColDel && nCol1 <= rRef.Ref2.nCol && +/*N*/ rRef.Ref2.nCol <= nCol1 + nDx ) +/*N*/ rRef.Ref2.SetColDeleted( FALSE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( bRef1ColDel ) +/*N*/ rRef.Ref1.SetColDeleted( TRUE ); +/*N*/ if ( bRef2ColDel ) +/*N*/ rRef.Ref2.SetColDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ if ( bExp ) +/*N*/ { +/*N*/ Expand( rRef.Ref1.nCol, rRef.Ref2.nCol, nCol1, nDx ); +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ } +/*N*/ if( nDy && +/*N*/ ((rRef.Ref1.nCol >= nCol1 +/*N*/ && rRef.Ref2.nCol <= nCol2) || (bRef1ColDel || bRef2ColDel)) +/*N*/ && +/*N*/ ((rRef.Ref1.nTab >= nTab1 +/*N*/ && rRef.Ref2.nTab <= nTab2) || (bRef1TabDel || bRef2TabDel)) +/*N*/ ) +/*N*/ { +/*N*/ BOOL bExp = (bExpand && !bInDeleteUndo && IsExpand( rRef.Ref1.nRow, +/*N*/ rRef.Ref2.nRow, nRow1, nDy )); +/*N*/ if ( lcl_MoveRefPart( rRef.Ref1.nRow, bRef1RowDel, +/*N*/ rRef.Ref2.nRow, bRef2RowDel, +/*N*/ nRow1, nRow2, nDy, MAXROW ) ) +/*N*/ { +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bInDeleteUndo && (bRef1RowDel || bRef2RowDel) ) +/*N*/ { +/*N*/ if ( bRef1RowDel && nRow1 <= rRef.Ref1.nRow && +/*N*/ rRef.Ref1.nRow <= nRow1 + nDy ) +/*N*/ rRef.Ref1.SetRowDeleted( FALSE ); +/*N*/ if ( bRef2RowDel && nRow1 <= rRef.Ref2.nRow && +/*N*/ rRef.Ref2.nRow <= nRow1 + nDy ) +/*N*/ rRef.Ref2.SetRowDeleted( FALSE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( bRef1RowDel ) +/*N*/ rRef.Ref1.SetRowDeleted( TRUE ); +/*N*/ if ( bRef2RowDel ) +/*N*/ rRef.Ref2.SetRowDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ if ( bExp ) +/*N*/ { +/*N*/ Expand( rRef.Ref1.nRow, rRef.Ref2.nRow, nRow1, nDy ); +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ } +/*N*/ if( nDz && +/*N*/ ((rRef.Ref1.nCol >= nCol1 +/*N*/ && rRef.Ref2.nCol <= nCol2) || (bRef1ColDel || bRef2ColDel)) +/*N*/ && +/*N*/ ((rRef.Ref1.nRow >= nRow1 +/*N*/ && rRef.Ref2.nRow <= nRow2) || (bRef1RowDel || bRef2RowDel)) +/*N*/ ) +/*N*/ { +/*N*/ BOOL bExp = (bExpand && !bInDeleteUndo && IsExpand( rRef.Ref1.nTab, +/*N*/ rRef.Ref2.nTab, nTab1, nDz )); +/*N*/ short nMaxTab = (short) pDoc->GetTableCount() - 1; +/*N*/ if ( lcl_MoveRefPart( rRef.Ref1.nTab, bRef1TabDel, +/*N*/ rRef.Ref2.nTab, bRef2TabDel, +/*N*/ nTab1, nTab2, nDz, nMaxTab ) ) +/*N*/ { +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bInDeleteUndo && (bRef1TabDel || bRef2TabDel) ) +/*N*/ { +/*N*/ if ( bRef1TabDel && nTab1 <= rRef.Ref1.nTab && +/*N*/ rRef.Ref1.nTab <= nTab1 + nDz ) +/*N*/ rRef.Ref1.SetTabDeleted( FALSE ); +/*N*/ if ( bRef2TabDel && nTab1 <= rRef.Ref2.nTab && +/*N*/ rRef.Ref2.nTab <= nTab1 + nDz ) +/*N*/ rRef.Ref2.SetTabDeleted( FALSE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( bRef1TabDel ) +/*N*/ rRef.Ref1.SetTabDeleted( TRUE ); +/*N*/ if ( bRef2TabDel ) +/*N*/ rRef.Ref2.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ if ( bExp ) +/*N*/ { +/*N*/ Expand( rRef.Ref1.nTab, rRef.Ref2.nTab, nTab1, nDz ); +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ } +/*N*/ if ( eRet == UR_NOTHING ) +/*N*/ { +/*N*/ if (oldCol1 != rRef.Ref1.nCol +/*N*/ || oldRow1 != rRef.Ref1.nRow +/*N*/ || oldTab1 != rRef.Ref1.nTab +/*N*/ || oldCol2 != rRef.Ref2.nCol +/*N*/ || oldRow2 != rRef.Ref2.nRow +/*N*/ || oldTab2 != rRef.Ref2.nTab +/*N*/ ) +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ rRef.CalcRelFromAbs( rPos ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if( eMode == URM_MOVE ) +/*N*/ { +/*N*/ if ( rRef.Ref1.nCol >= nCol1-nDx +/*N*/ && rRef.Ref1.nRow >= nRow1-nDy +/*N*/ && rRef.Ref1.nTab >= nTab1-nDz +/*N*/ && rRef.Ref2.nCol <= nCol2-nDx +/*N*/ && rRef.Ref2.nRow <= nRow2-nDy +/*N*/ && rRef.Ref2.nTab <= nTab2-nDz ) +/*N*/ { +/*N*/ eRet = Move( pDoc, rPos, nDx, nDy, nDz, rRef, FALSE, TRUE ); // immer verschieben +/*N*/ } +/*N*/ else if ( nDz && r.In( rPos ) ) +/*N*/ { +/*N*/ rRef.Ref1.SetFlag3D( TRUE ); +/*N*/ rRef.Ref2.SetFlag3D( TRUE ); +/*N*/ eRet = UR_UPDATED; +/*N*/ rRef.CalcRelFromAbs( rPos ); +/*N*/ } +/*N*/ else +/*N*/ rRef.CalcRelFromAbs( rPos ); +/*N*/ } +/*N*/ else if( eMode == URM_COPY && r.In( rPos ) ) +/*N*/ eRet = Move( pDoc, rPos, nDx, nDy, nDz, rRef, FALSE, FALSE ); // nur relative +/*N*/ // sollte nicht mehr verwendet werden muessen +/*N*/ else +/*N*/ rRef.CalcRelFromAbs( rPos ); +/*N*/ } +/*N*/ return eRet; +/*N*/ } + +// vor dem Aufruf muessen die Abs-Refs aktualisiert werden! +/*N*/ ScRefUpdateRes ScRefUpdate::Move( ScDocument* pDoc, const ScAddress& rPos, +/*N*/ short nDx, short nDy, short nDz, +/*N*/ ComplRefData& rRef, BOOL bWrap, BOOL bAbsolute ) +/*N*/ { +/*N*/ ScRefUpdateRes eRet = UR_NOTHING; +/*N*/ +/*N*/ USHORT oldCol1 = rRef.Ref1.nCol; +/*N*/ USHORT oldRow1 = rRef.Ref1.nRow; +/*N*/ USHORT oldTab1 = rRef.Ref1.nTab; +/*N*/ USHORT oldCol2 = rRef.Ref2.nCol; +/*N*/ USHORT oldRow2 = rRef.Ref2.nRow; +/*N*/ USHORT oldTab2 = rRef.Ref2.nTab; +/*N*/ +/*N*/ BOOL bCut1, bCut2; +/*N*/ if ( nDx ) +/*N*/ { +/*N*/ bCut1 = bCut2 = FALSE; +/*N*/ if( bAbsolute || rRef.Ref1.IsColRel() ) +/*N*/ { +/*N*/ if( bWrap ) +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref1.nCol, nDx, MAXCOL ); +/*N*/ else +/*N*/ bCut1 = lcl_MoveItCut( (short&) rRef.Ref1.nCol, nDx, MAXCOL ); +/*N*/ } +/*N*/ if( bAbsolute || rRef.Ref2.IsColRel() ) +/*N*/ { +/*N*/ if( bWrap ) +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref2.nCol, nDx, MAXCOL ); +/*N*/ else +/*N*/ bCut2 = lcl_MoveItCut( (short&) rRef.Ref2.nCol, nDx, MAXCOL ); +/*N*/ } +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bCut1 && bCut2 ) +/*N*/ { +/*N*/ rRef.Ref1.SetColDeleted( TRUE ); +/*N*/ rRef.Ref2.SetColDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ if ( nDy ) +/*N*/ { +/*N*/ bCut1 = bCut2 = FALSE; +/*N*/ if( bAbsolute || rRef.Ref1.IsRowRel() ) +/*N*/ { +/*N*/ if( bWrap ) +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref1.nRow, nDy, MAXROW ); +/*N*/ else +/*N*/ bCut1 = lcl_MoveItCut( (short&) rRef.Ref1.nRow, nDy, MAXROW ); +/*N*/ } +/*N*/ if( bAbsolute || rRef.Ref2.IsRowRel() ) +/*N*/ { +/*N*/ if( bWrap ) +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref2.nRow, nDy, MAXROW ); +/*N*/ else +/*N*/ bCut2 = lcl_MoveItCut( (short&) rRef.Ref2.nRow, nDy, MAXROW ); +/*N*/ } +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bCut1 && bCut2 ) +/*N*/ { +/*N*/ rRef.Ref1.SetRowDeleted( TRUE ); +/*N*/ rRef.Ref2.SetRowDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ if ( nDz ) +/*N*/ { +/*N*/ bCut1 = bCut2 = FALSE; +/*N*/ short nMaxTab = (short) pDoc->GetTableCount() - 1; +/*N*/ if( bAbsolute || rRef.Ref1.IsTabRel() ) +/*N*/ { +/*N*/ if( bWrap ) +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref1.nTab, nDz, nMaxTab ); +/*N*/ else +/*N*/ bCut1 = lcl_MoveItCut( (short&) rRef.Ref1.nTab, nDz, nMaxTab ); +/*N*/ rRef.Ref1.SetFlag3D( rPos.Tab() != rRef.Ref1.nTab ); +/*N*/ } +/*N*/ if( bAbsolute || rRef.Ref2.IsTabRel() ) +/*N*/ { +/*N*/ if( bWrap ) +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref2.nTab, nDz, nMaxTab ); +/*N*/ else +/*N*/ bCut2 = lcl_MoveItCut( (short&) rRef.Ref2.nTab, nDz, nMaxTab ); +/*N*/ rRef.Ref2.SetFlag3D( rPos.Tab() != rRef.Ref2.nTab ); +/*N*/ } +/*N*/ if ( bCut1 || bCut2 ) +/*N*/ eRet = UR_UPDATED; +/*N*/ if ( bCut1 && bCut2 ) +/*N*/ { +/*N*/ rRef.Ref1.SetTabDeleted( TRUE ); +/*N*/ rRef.Ref2.SetTabDeleted( TRUE ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( eRet == UR_NOTHING ) +/*N*/ { +/*N*/ if (oldCol1 != rRef.Ref1.nCol +/*N*/ || oldRow1 != rRef.Ref1.nRow +/*N*/ || oldTab1 != rRef.Ref1.nTab +/*N*/ || oldCol2 != rRef.Ref2.nCol +/*N*/ || oldRow2 != rRef.Ref2.nRow +/*N*/ || oldTab2 != rRef.Ref2.nTab +/*N*/ ) +/*N*/ eRet = UR_UPDATED; +/*N*/ } +/*N*/ if ( bWrap && eRet != UR_NOTHING ) +/*N*/ rRef.PutInOrder(); +/*N*/ rRef.CalcRelFromAbs( rPos ); +/*N*/ return eRet; +/*N*/ } + +/*N*/ void ScRefUpdate::MoveRelWrap( ScDocument* pDoc, const ScAddress& rPos, +/*N*/ ComplRefData& rRef ) +/*N*/ { +/*N*/ if( rRef.Ref1.IsColRel() ) +/*N*/ { +/*N*/ rRef.Ref1.nCol = rRef.Ref1.nRelCol + rPos.Col(); +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref1.nCol, 0, MAXCOL ); +/*N*/ } +/*N*/ if( rRef.Ref2.IsColRel() ) +/*N*/ { +/*N*/ rRef.Ref2.nCol = rRef.Ref2.nRelCol + rPos.Col(); +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref2.nCol, 0, MAXCOL ); +/*N*/ } +/*N*/ if( rRef.Ref1.IsRowRel() ) +/*N*/ { +/*N*/ rRef.Ref1.nRow = rRef.Ref1.nRelRow + rPos.Row(); +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref1.nRow, 0, MAXROW ); +/*N*/ } +/*N*/ if( rRef.Ref2.IsRowRel() ) +/*N*/ { +/*N*/ rRef.Ref2.nRow = rRef.Ref2.nRelRow + rPos.Row(); +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref2.nRow, 0, MAXROW ); +/*N*/ } +/*?*/ short nMaxTab = (short) pDoc->GetTableCount() - 1; +/*?*/ if( rRef.Ref1.IsTabRel() ) +/*N*/ { +/*N*/ rRef.Ref1.nTab = rRef.Ref1.nRelTab + rPos.Tab(); +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref1.nTab, 0, nMaxTab ); +/*N*/ } +/*N*/ if( rRef.Ref2.IsTabRel() ) +/*N*/ { +/*N*/ rRef.Ref2.nTab = rRef.Ref2.nRelTab + rPos.Tab(); +/*N*/ lcl_MoveItWrap( (short&) rRef.Ref2.nTab, 0, nMaxTab ); +/*N*/ } +/*N*/ rRef.PutInOrder(); +/*N*/ rRef.CalcRelFromAbs( rPos ); +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_scmatrix.cxx b/binfilter/bf_sc/source/core/tool/sc_scmatrix.cxx new file mode 100644 index 000000000000..1c429d542438 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_scmatrix.cxx @@ -0,0 +1,565 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include <tools/debug.hxx> +#include <math.h> + +#include "scmatrix.hxx" + +#include <rtl/math.hxx> +namespace binfilter { + +//------------------------------------------------------------------------ + +/*N*/ void ScMatrix::CreateMatrix(USHORT nC, USHORT nR) // nur fuer ctor +/*N*/ { +/*N*/ nAnzCol = nC; +/*N*/ nAnzRow = nR; +/*N*/ ULONG nCount = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( !nCount || nCount > GetElementsMax() ) +/*N*/ { +/*N*/ DBG_ERRORFILE("ScMatrix::CreateMatrix: dimension error"); +/*N*/ nAnzCol = nAnzRow = 1; +/*N*/ pMat = new MatValue[1]; +/*N*/ } +/*N*/ else +/*N*/ pMat = new MatValue[nCount]; +/*N*/ bIsString = NULL; +/*N*/ } + +/*N*/ ScMatrix::~ScMatrix() +/*N*/ { +/*N*/ DeleteIsString(); +/*N*/ delete [] pMat; +/*N*/ } + +/*N*/ ScMatrix* ScMatrix::Clone() const +/*N*/ { +/*N*/ ScMatrix* pScMat = new ScMatrix(nAnzCol, nAnzRow); +/*N*/ MatCopy(*pScMat); +/*N*/ return pScMat; +/*N*/ } + +// +// File format: USHORT columns, USHORT rows, (columns*rows) entries: +// BYTE type ( CELLTYPE_NONE, CELLTYPE_VALUE, CELLTYPE_STRING ); nothing, double or String +// + +/*N*/ ScMatrix::ScMatrix(SvStream& rStream) +/*N*/ { +/*N*/ USHORT nC, nR; +/*N*/ +/*N*/ rStream >> nC; +/*N*/ rStream >> nR; +/*N*/ +/*N*/ CreateMatrix(nC, nR); +/*N*/ DBG_ASSERT( pMat, "pMat == NULL" ); +/*N*/ +/*N*/ String aMatStr; +/*N*/ double fVal; +/*N*/ rtl_TextEncoding eCharSet = rStream.GetStreamCharSet(); +/*N*/ ULONG nCount = (ULONG) nAnzCol * nAnzRow; +/*N*/ ULONG nReadCount = (ULONG) nC * nR; +/*N*/ for (ULONG i=0; i<nReadCount; i++) +/*N*/ { +/*N*/ BYTE nType; +/*N*/ rStream >> nType; +/*N*/ if ( nType == CELLTYPE_VALUE ) +/*N*/ { +/*N*/ if ( i < nCount ) +/*N*/ rStream >> pMat[i].fVal; +/*N*/ else +/*N*/ rStream >> fVal; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ // For unknown types read and forget string (upwards compatibility) +/*N*/ +/*N*/ if ( nType != CELLTYPE_NONE ) +/*N*/ rStream.ReadByteString( aMatStr, eCharSet ); +/*N*/ +/*N*/ if ( i < nCount ) +/*N*/ { +/*N*/ if (!bIsString) +/*N*/ ResetIsString(); // init string flags +/*N*/ bIsString[i] = ( nType == CELLTYPE_NONE ? SC_MATVAL_EMPTY : SC_MATVAL_STRING ); +/*N*/ +/*N*/ if ( nType == CELLTYPE_STRING ) +/*N*/ pMat[i].pS = new String(aMatStr); +/*N*/ else +/*N*/ pMat[i].pS = NULL; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::Store(SvStream& rStream) const +/*N*/ { +/*N*/ ULONG nCount = (ULONG) nAnzCol * nAnzRow; +/*N*/ // Don't store matrix with more than USHORT max elements, old versions +/*N*/ // might get confused in loops for(USHORT i=0; i<nC*nR; i++) +/*N*/ if ( !pMat || nCount > ((USHORT)(~0)) ) +/*N*/ { +/*N*/ DBG_ASSERT( pMat, "ScMatrix::Store: pMat == NULL" ); +/*N*/ // We can't store a 0 dimension because old versions rely on some +/*N*/ // matrix being present, e.g. DDE link results, and old versions didn't +/*N*/ // create a matrix if dimension was 0. Store an error result. +/*N*/ rStream << (USHORT) 1; +/*N*/ rStream << (USHORT) 1; +/*N*/ rStream << (BYTE) CELLTYPE_VALUE; +/*N*/ double fVal; +/*N*/ ::rtl::math::setNan( &fVal ); +/*N*/ rStream << fVal; +/*N*/ return; +/*N*/ } +/*N*/ +/*N*/ rStream << nAnzCol; +/*N*/ rStream << nAnzRow; +/*N*/ +/*N*/ String aMatStr; +/*N*/ rtl_TextEncoding eCharSet = rStream.GetStreamCharSet(); +/*N*/ for (ULONG i=0; i<nCount; i++) +/*N*/ { +/*N*/ BYTE nType = CELLTYPE_VALUE; +/*N*/ if ( bIsString && bIsString[i] ) +/*N*/ { +/*N*/ if ( pMat[i].pS ) +/*N*/ aMatStr = *pMat[i].pS; +/*N*/ else +/*N*/ aMatStr.Erase(); +/*N*/ +/*N*/ if ( bIsString[i] == SC_MATVAL_STRING ) +/*N*/ nType = CELLTYPE_STRING; +/*N*/ else +/*N*/ nType = CELLTYPE_NONE; +/*N*/ } +/*N*/ rStream << nType; +/*N*/ if ( nType == CELLTYPE_VALUE ) +/*N*/ rStream << pMat[i].fVal; +/*N*/ else if ( nType == CELLTYPE_STRING ) +/*N*/ rStream.WriteByteString( aMatStr, eCharSet ); +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::ResetIsString() +/*N*/ { +/*N*/ ULONG nCount = (ULONG) nAnzCol * nAnzRow; +/*N*/ if (bIsString) +/*N*/ { +/*N*/ for (ULONG i = 0; i < nCount; i++) +/*N*/ { +/*N*/ if ( bIsString[i] ) +/*N*/ delete pMat[i].pS; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ bIsString = new BYTE[nCount]; +/*N*/ memset( bIsString, 0, nCount * sizeof( BYTE ) ); +/*N*/ } + +/*N*/ void ScMatrix::DeleteIsString() +/*N*/ { +/*N*/ if ( bIsString ) +/*N*/ { +/*?*/ ULONG nCount = (ULONG) nAnzCol * nAnzRow; +/*?*/ for ( ULONG i = 0; i < nCount; i++ ) +/*?*/ { +/*?*/ if ( bIsString[i] ) +/*?*/ delete pMat[i].pS; +/*?*/ } +/*?*/ delete [] bIsString; +/*?*/ bIsString = NULL; +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::PutDouble(double fVal, USHORT nC, USHORT nR) +/*N*/ { +/*N*/ if (nC < nAnzCol && nR < nAnzRow) +/*N*/ PutDouble( fVal, (ULONG) nC * nAnzRow + nR ); +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::PutDouble: dimension error"); +/*N*/ } + + + +/*N*/ void ScMatrix::PutString(const String& rStr, USHORT nC, USHORT nR) +/*N*/ { +/*N*/ if (nC < nAnzCol && nR < nAnzRow) +/*N*/ PutString( rStr, (ULONG) nC * nAnzRow + nR ); +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::PutString: dimension error"); +/*N*/ } + +/*N*/ void ScMatrix::PutString(const String& rStr, ULONG nIndex) +/*N*/ { +/*N*/ if (bIsString == NULL) +/*N*/ ResetIsString(); +/*N*/ if ( bIsString[nIndex] && pMat[nIndex].pS ) +/*N*/ *(pMat[nIndex].pS) = rStr; +/*N*/ else +/*N*/ pMat[nIndex].pS = new String(rStr); +/*N*/ bIsString[nIndex] = SC_MATVAL_STRING; +/*N*/ } + +/*N*/ void ScMatrix::PutStringEntry( const String* pStr, BYTE bFlag, ULONG nIndex ) +/*N*/ { +/*N*/ DBG_ASSERT( bFlag, "ScMatrix::PutStringEntry: bFlag == 0" ); +/*N*/ if (bIsString == NULL) +/*N*/ ResetIsString(); +/*N*/ if ( bIsString[nIndex] && pMat[nIndex].pS ) +/*N*/ { +/*N*/ if ( pStr ) +/*N*/ *(pMat[nIndex].pS) = *pStr; +/*N*/ else +/*N*/ pMat[nIndex].pS->Erase(); +/*N*/ } +/*N*/ else +/*N*/ pMat[nIndex].pS = (pStr ? new String(*pStr) : NULL); +/*N*/ bIsString[nIndex] = bFlag; +/*N*/ } + +/*N*/ void ScMatrix::PutEmpty(USHORT nC, USHORT nR) +/*N*/ { +/*N*/ if (nC < nAnzCol && nR < nAnzRow) +/*N*/ PutEmpty( (ULONG) nC * nAnzRow + nR ); +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::PutString: dimension error"); +/*N*/ } + +/*N*/ void ScMatrix::PutEmpty(ULONG nIndex) +/*N*/ { +/*N*/ if (bIsString == NULL) +/*N*/ ResetIsString(); +/*N*/ if ( bIsString[nIndex] && pMat[nIndex].pS ) +/*N*/ delete pMat[nIndex].pS; +/*N*/ bIsString[nIndex] = SC_MATVAL_EMPTY; +/*N*/ pMat[nIndex].pS = NULL; +/*N*/ pMat[nIndex].fVal = 0.0; +/*N*/ } + +/*N*/ double ScMatrix::GetDouble(USHORT nC, USHORT nR) const +/*N*/ { +/*N*/ if (nC < nAnzCol && nR < nAnzRow) +/*N*/ return GetDouble( (ULONG) nC * nAnzRow + nR ); +/*N*/ else +/*N*/ { +/*N*/ DBG_ERRORFILE("ScMatrix::GetDouble: dimension error"); +/*N*/ return 0.0; +/*N*/ } +/*N*/ } + +/*N*/ const String& ScMatrix::GetString(USHORT nC, USHORT nR) const +/*N*/ { +/*N*/ if (nC < nAnzCol && nR < nAnzRow) +/*N*/ { +/*N*/ ULONG nIndex = (ULONG) nC * nAnzRow + nR; +/*N*/ if ( IsString( nIndex ) ) +/*N*/ return GetString( nIndex ); +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::GetString: access error, no string"); +/*N*/ } +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::GetString: dimension error"); +/*N*/ return ScGlobal::GetEmptyString(); +/*N*/ } + +/*N*/ const MatValue* ScMatrix::Get(USHORT nC, USHORT nR, BOOL& bString) const +/*N*/ { +/*N*/ if (nC < nAnzCol && nR < nAnzRow) +/*N*/ { +/*N*/ ULONG nIndex = (ULONG) nC * nAnzRow + nR; +/*N*/ if (bIsString && bIsString[nIndex]) +/*N*/ bString = TRUE; +/*N*/ else +/*N*/ bString = FALSE; +/*N*/ return &pMat[nIndex]; +/*N*/ } +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::Get: dimension error"); +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScMatrix::MatCopy(ScMatrix& mRes) const +/*N*/ { +/*N*/ if (nAnzCol != mRes.nAnzCol || nAnzRow != mRes.nAnzRow) +/*N*/ { +/*N*/ DBG_ERRORFILE("ScMatrix::MatCopy: dimension error"); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (bIsString) +/*N*/ { +/*N*/ mRes.ResetIsString(); +/*N*/ for (USHORT i = 0; i < nAnzCol; i++) +/*N*/ { +/*N*/ ULONG nStart = (ULONG) i * nAnzRow; +/*N*/ for (USHORT j = 0; j < nAnzRow; j++) +/*N*/ { +/*N*/ if ( bIsString[nStart+j] ) +/*N*/ mRes.PutStringEntry( pMat[nStart+j].pS, +/*N*/ bIsString[nStart+j], nStart+j ); +/*N*/ else +/*N*/ mRes.pMat[nStart+j].fVal = pMat[nStart+j].fVal; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ mRes.DeleteIsString(); +/*N*/ ULONG nCount = (ULONG) nAnzCol * nAnzRow; +/*N*/ for (ULONG i = 0; i < nCount; i++) +/*N*/ mRes.pMat[i].fVal = pMat[i].fVal; +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::MatTrans(ScMatrix& mRes) const +/*N*/ { +/*N*/ if (nAnzCol != mRes.nAnzRow || nAnzRow != mRes.nAnzCol) +/*N*/ { +/*N*/ DBG_ERRORFILE("ScMatrix::MatTrans: dimension error"); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if (bIsString) +/*N*/ { +/*N*/ mRes.ResetIsString(); +/*N*/ for ( ULONG i = 0; i < nAnzCol; i++ ) +/*N*/ { +/*N*/ ULONG nStart = i * nAnzRow; +/*N*/ for ( ULONG j = 0; j < nAnzRow; j++ ) +/*N*/ { +/*N*/ if ( bIsString[nStart+j] ) +/*N*/ mRes.PutStringEntry( pMat[nStart+j].pS, +/*N*/ bIsString[nStart+j], j*mRes.nAnzRow+i ); +/*N*/ else +/*N*/ mRes.pMat[j*mRes.nAnzRow+i].fVal = pMat[nStart+j].fVal; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ mRes.DeleteIsString(); +/*N*/ for ( ULONG i = 0; i < nAnzCol; i++ ) +/*N*/ { +/*N*/ ULONG nStart = i * nAnzRow; +/*N*/ for ( ULONG j = 0; j < nAnzRow; j++ ) +/*N*/ { +/*N*/ mRes.pMat[j*mRes.nAnzRow+i].fVal = pMat[nStart+j].fVal; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + + +/*N*/ void ScMatrix::FillDouble( double fVal, USHORT nC1, USHORT nR1, +/*N*/ USHORT nC2, USHORT nR2 ) +/*N*/ { +/*N*/ if (nC2 < nAnzCol && nR2 < nAnzRow) +/*N*/ { +/*N*/ if ( nC1 == 0 && nR1 == 0 && nC2 == nAnzCol-1 && nR2 == nAnzRow-1 ) +/*N*/ { +/*N*/ ULONG nEnd = (ULONG) nAnzCol * nAnzRow; +/*N*/ for ( ULONG j=0; j<nEnd; j++ ) +/*N*/ pMat[j].fVal = fVal; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( USHORT i=nC1; i<=nC2; i++ ) +/*N*/ { +/*N*/ ULONG nOff1 = (ULONG) i * nAnzRow + nR1; +/*N*/ ULONG nOff2 = nOff1 + nR2 - nR1; +/*N*/ for ( ULONG j=nOff1; j<=nOff2; j++ ) +/*N*/ pMat[j].fVal = fVal; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::FillDouble: dimension error"); +/*N*/ } + +/*N*/ void ScMatrix::FillDoubleLowerLeft( double fVal, USHORT nC2 ) +/*N*/ { +/*N*/ if (nC2 < nAnzCol && nC2 < nAnzRow) +/*N*/ { +/*N*/ for ( USHORT i=1; i<=nC2; i++ ) +/*N*/ { +/*N*/ ULONG nOff1 = (ULONG) i * nAnzRow; +/*N*/ ULONG nOff2 = nOff1 + i; +/*N*/ for ( ULONG j=nOff1; j<nOff2; j++ ) +/*N*/ pMat[j].fVal = fVal; +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ DBG_ERRORFILE("ScMatrix::FillDoubleLowerLeft: dimension error"); +/*N*/ } + +/*N*/ void ScMatrix::CompareEqual() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ if ( !bIsString[j]) // else: #WERT! +/*N*/ pMat[j].fVal = (pMat[j].fVal == 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ pMat[j].fVal = (pMat[j].fVal == 0.0); +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::CompareNotEqual() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ if ( !bIsString[j]) // else: #WERT! +/*N*/ pMat[j].fVal = (pMat[j].fVal != 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ pMat[j].fVal = (pMat[j].fVal != 0.0); +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::CompareLess() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ if ( !bIsString[j]) // else: #WERT! +/*N*/ pMat[j].fVal = (pMat[j].fVal < 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ pMat[j].fVal = (pMat[j].fVal < 0.0); +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::CompareGreater() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ if ( !bIsString[j]) // else: #WERT! +/*N*/ pMat[j].fVal = (pMat[j].fVal > 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ pMat[j].fVal = (pMat[j].fVal > 0.0); +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::CompareLessEqual() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ if ( !bIsString[j]) // else: #WERT! +/*N*/ pMat[j].fVal = (pMat[j].fVal <= 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ pMat[j].fVal = (pMat[j].fVal <= 0.0); +/*N*/ } +/*N*/ } + +/*N*/ void ScMatrix::CompareGreaterEqual() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ if ( !bIsString[j]) // else: #WERT! +/*N*/ pMat[j].fVal = (pMat[j].fVal >= 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; j<n; j++ ) +/*N*/ pMat[j].fVal = (pMat[j].fVal >= 0.0); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScMatrix::And() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ BOOL bAnd = TRUE; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; bAnd && j<n; j++ ) +/*N*/ if ( bIsString[j] ) +/*N*/ bAnd = FALSE; // we're assuming a CompareMat +/*N*/ else +/*N*/ bAnd = (pMat[j].fVal != 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; bAnd && j<n; j++ ) +/*N*/ bAnd = (pMat[j].fVal != 0.0); +/*N*/ } +/*N*/ return bAnd; +/*N*/ } + +/*N*/ BOOL ScMatrix::Or() +/*N*/ { +/*N*/ ULONG n = (ULONG) nAnzCol * nAnzRow; +/*N*/ BOOL bOr = FALSE; +/*N*/ if ( bIsString ) +/*N*/ { +/*N*/ for ( ULONG j=0; !bOr && j<n; j++ ) +/*N*/ if ( !bIsString[j] ) +/*N*/ bOr = (pMat[j].fVal != 0.0); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ for ( ULONG j=0; !bOr && j<n; j++ ) +/*N*/ bOr = (pMat[j].fVal != 0.0); +/*N*/ } +/*N*/ return bOr; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_subtotal.cxx b/binfilter/bf_sc/source/core/tool/sc_subtotal.cxx new file mode 100644 index 000000000000..823141b1012e --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_subtotal.cxx @@ -0,0 +1,144 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef RS6000 + +#include <fptrap.h> +#include <fpxcp.h> + +#elif defined ( MAC ) + +#include <MAC_START.h> +#include <fp.h> +#include <MAC_END.h> + +#endif + + +#include <float.h> +#ifdef SOLARIS +#include <ieeefp.h> +#endif +#include <signal.h> + +#include "subtotal.hxx" +#include "interpre.hxx" +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + +jmp_buf SubTotal::aGlobalJumpBuf; + +// ----------------------------------------------------------------------- + +/*N*/ SubTotal::SubTotal() +/*N*/ { +/*N*/ nIndex = 0; //! test fuer Pivot +/*N*/ +/*N*/ nCount = 0; +/*N*/ nCount2 = 0; +/*N*/ nSum = 0.0; +/*N*/ nSumSqr = 0.0; +/*N*/ nMax = -MAXDOUBLE; +/*N*/ nMin = MAXDOUBLE; +/*N*/ nProduct = 1.0; +/*N*/ bSumOk = TRUE; +/*N*/ bSumSqrOk = TRUE; +/*N*/ bProductOk = TRUE; +/*N*/ } + + +/*N*/ SubTotal::~SubTotal() +/*N*/ { +/*N*/ } + + + + +/*N*/ void SubTotal::Update( double nVal ) +/*N*/ { +/*N*/ SAL_MATH_FPEXCEPTIONS_OFF(); +/*N*/ nCount++; +/*N*/ nCount2++; +/*N*/ if (nVal > nMax) nMax = nVal; +/*N*/ if (nVal < nMin) nMin = nVal; +/*N*/ nProgress = 0; +/*N*/ if (bSumOk) nSum += nVal; +/*N*/ nProgress = 1; +/*N*/ if (bProductOk) nProduct *= nVal; +/*N*/ nProgress = 2; +/*N*/ if (bSumSqrOk) nSumSqr += nVal*nVal; +/*N*/ if (!::rtl::math::isFinite(nSum)) +/*N*/ bSumOk = FALSE; +/*N*/ if (!::rtl::math::isFinite(nProduct)) +/*N*/ bProductOk = FALSE; +/*N*/ if (!::rtl::math::isFinite(nSumSqr)) +/*N*/ bSumSqrOk = FALSE; +/*N*/ } + + + + + + + + +/*N*/ BOOL SubTotal::SafePlus(double& fVal1, double fVal2) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ SAL_MATH_FPEXCEPTIONS_OFF(); +/*N*/ fVal1 += fVal2; +/*N*/ if (!::rtl::math::isFinite(fVal1)) +/*N*/ { +/*N*/ bOk = FALSE; +/*N*/ if (fVal2 > 0.0) +/*N*/ fVal1 = DBL_MAX; +/*N*/ else +/*N*/ fVal1 = -DBL_MAX; +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +/*N*/ BOOL SubTotal::SafeMult(double& fVal1, double fVal2) +/*N*/ { +/*N*/ BOOL bOk = TRUE; +/*N*/ SAL_MATH_FPEXCEPTIONS_OFF(); +/*N*/ fVal1 *= fVal2; +/*N*/ if (!::rtl::math::isFinite(fVal1)) +/*N*/ { +/*N*/ bOk = FALSE; +/*N*/ fVal1 = DBL_MAX; +/*N*/ } +/*N*/ return bOk; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_token.cxx b/binfilter/bf_sc/source/core/tool/sc_token.cxx new file mode 100644 index 000000000000..fe98c35eb5c6 --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_token.cxx @@ -0,0 +1,1819 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// INCLUDE --------------------------------------------------------------- + +#if STLPORT_VERSION<321 +#include <stddef.h> +#else +#include <cstddef> +#endif +#include <string.h> + +#include <tools/debug.hxx> + +#include "compiler.hxx" +#include "rechead.hxx" +namespace binfilter { + +/*N*/ struct ImpTokenIterator +/*N*/ { +/*N*/ ImpTokenIterator* pNext; +/*N*/ ScTokenArray* pArr; +/*N*/ short nPC; +/*N*/ +/*N*/ DECL_FIXEDMEMPOOL_NEWDEL( ImpTokenIterator ); +/*N*/ }; + +// ImpTokenIterator wird je Interpreter angelegt, mehrfache auch durch +// SubCode via ScTokenIterator Push/Pop moeglich +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ImpTokenIterator, 32, 16 )//STRIP008 ; + +// Align MemPools on 4k boundaries - 64 bytes (4k is a MUST for OS/2) + +// Since RawTokens are temporary for the compiler, don't align on 4k and waste memory. +// ScRawToken size is FixMembers + MAXSTRLEN ~= 264 +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScRawToken, 8, 4 )//STRIP008 ; +// Some ScDoubleRawToken, FixMembers + sizeof(double) ~= 16 +/*N*/ const USHORT nMemPoolDoubleRawToken = 0x0400 / sizeof(ScDoubleRawToken); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScDoubleRawToken, nMemPoolDoubleRawToken, nMemPoolDoubleRawToken )//STRIP008 ; + +// Need a whole bunch of ScSingleRefToken +/*N*/ const USHORT nMemPoolSingleRefToken = (0x4000 - 64) / sizeof(ScSingleRefToken); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScSingleRefToken, nMemPoolSingleRefToken, nMemPoolSingleRefToken )//STRIP008 ; +// Need a lot of ScDoubleToken +/*N*/ const USHORT nMemPoolDoubleToken = (0x3000 - 64) / sizeof(ScDoubleToken); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScDoubleToken, nMemPoolDoubleToken, nMemPoolDoubleToken )//STRIP008 ; +// Need a lot of ScByteToken +/*N*/ const USHORT nMemPoolByteToken = (0x3000 - 64) / sizeof(ScByteToken); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScByteToken, nMemPoolByteToken, nMemPoolByteToken )//STRIP008 ; +// Need quite a lot of ScDoubleRefToken +/*N*/ const USHORT nMemPoolDoubleRefToken = (0x2000 - 64) / sizeof(ScDoubleRefToken); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScDoubleRefToken, nMemPoolDoubleRefToken, nMemPoolDoubleRefToken )//STRIP008 ; +// Need several ScStringToken +/*N*/ const USHORT nMemPoolStringToken = (0x1000 - 64) / sizeof(ScStringToken); +/*N*/ IMPL_FIXEDMEMPOOL_NEWDEL( ScStringToken, nMemPoolStringToken, nMemPoolStringToken )//STRIP008 ; + + +// --- helpers -------------------------------------------------------------- + +/*N*/ inline BOOL lcl_IsReference( OpCode eOp, StackVar eType ) +/*N*/ { +/*N*/ return +/*N*/ (eOp == ocPush && (eType == svSingleRef || eType == svDoubleRef)) +/*N*/ || (eOp == ocColRowNameAuto && eType == svDoubleRef) +/*N*/ || (eOp == ocColRowName && eType == svSingleRef) +/*N*/ || (eOp == ocMatRef && eType == svSingleRef) +/*N*/ ; +/*N*/ } + + +// --- class ScRawToken ----------------------------------------------------- + +/*N*/ xub_StrLen ScRawToken::GetStrLen( const sal_Unicode* pStr ) +/*N*/ { +/*N*/ if ( !pStr ) +/*N*/ return 0; +/*N*/ register const sal_Unicode* p = pStr; +/*N*/ while ( *p ) +/*N*/ p++; +/*N*/ return p - pStr; +/*N*/ } + + +/*N*/ void ScRawToken::SetOpCode( OpCode e ) +/*N*/ { +/*N*/ eOp = e; +/*N*/ if( eOp == ocIf ) +/*N*/ { +/*N*/ eType = svJump; nJump[ 0 ] = 3; // If, Else, Behind +/*N*/ } +/*N*/ else if( eOp == ocChose ) +/*N*/ { +/*N*/ eType = svJump; nJump[ 0 ] = MAXJUMPCOUNT+1; +/*N*/ } +/*N*/ else if( eOp == ocMissing ) +/*N*/ eType = svMissing; +/*N*/ else +/*N*/ eType = svByte, cByte = 0; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ void ScRawToken::SetString( const sal_Unicode* pStr ) +/*N*/ { +/*N*/ eOp = ocPush; +/*N*/ eType = svString; +/*N*/ if ( pStr ) +/*N*/ { +/*N*/ xub_StrLen nLen = GetStrLen( pStr ) + 1; +/*N*/ if( nLen > MAXSTRLEN ) +/*N*/ nLen = MAXSTRLEN; +/*N*/ memcpy( cStr, pStr, GetStrLenBytes( nLen ) ); +/*N*/ cStr[ nLen-1 ] = 0; +/*N*/ } +/*N*/ else +/*N*/ cStr[0] = 0; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ void ScRawToken::SetSingleReference( const SingleRefData& rRef ) +/*N*/ { +/*N*/ eOp = ocPush; +/*N*/ eType = svSingleRef; +/*N*/ aRef.Ref1 = +/*N*/ aRef.Ref2 = rRef; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ void ScRawToken::SetDoubleReference( const ComplRefData& rRef ) +/*N*/ { +/*N*/ eOp = ocPush; +/*N*/ eType = svDoubleRef; +/*N*/ aRef = rRef; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ void ScRawToken::SetDouble(double rVal) +/*N*/ { +/*N*/ eOp = ocPush; +/*N*/ eType = svDouble; +/*N*/ nValue = rVal; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ void ScRawToken::SetName( USHORT n ) +/*N*/ { +/*N*/ eOp = ocName; +/*N*/ eType = svIndex; +/*N*/ nIndex = n; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ void ScRawToken::SetExternal( const sal_Unicode* pStr ) +/*N*/ { +/*N*/ eOp = ocExternal; +/*N*/ eType = svExternal; +/*N*/ xub_StrLen nLen = GetStrLen( pStr ) + 1; +/*N*/ if( nLen >= MAXSTRLEN ) +/*N*/ nLen = MAXSTRLEN-1; +/*N*/ // Platz fuer Byte-Parameter lassen! +/*N*/ memcpy( cStr+1, pStr, GetStrLenBytes( nLen ) ); +/*N*/ cStr[ nLen+1 ] = 0; +/*N*/ nRefCnt = 0; +/*N*/ } + +/*N*/ ScRawToken* ScRawToken::Clone() const +/*N*/ { +/*N*/ ScRawToken* p; +/*N*/ if ( eType == svDouble ) +/*N*/ { +/*N*/ p = (ScRawToken*) new ScDoubleRawToken; +/*N*/ p->eOp = eOp; +/*N*/ p->eType = eType; +/*N*/ p->nValue = nValue; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ USHORT n = offsetof( ScRawToken, cByte ); +/*N*/ switch( eType ) +/*N*/ { +/*N*/ case svByte: n++; break; +/*N*/ case svDouble: n += sizeof(double); break; +/*N*/ case svString: n += GetStrLenBytes( cStr ) + GetStrLenBytes( 1 ); break; +/*N*/ case svSingleRef: +/*N*/ case svDoubleRef: n += sizeof(aRef); break; +/*N*/ case svMatrix: n += sizeof(ScMatrix*); break; +/*N*/ case svIndex: n += sizeof(USHORT); break; +/*N*/ case svJump: n += nJump[ 0 ] * 2 + 2; break; +/*N*/ case svExternal: n += GetStrLenBytes( cStr+1 ) + GetStrLenBytes( 2 ); break; +/*N*/ default: n += *((BYTE*)cStr); // read in unknown! +/*N*/ } +/*N*/ p = (ScRawToken*) new BYTE[ n ]; +/*N*/ memcpy( p, this, n * sizeof(BYTE) ); +/*N*/ } +/*N*/ p->nRefCnt = 0; +/*N*/ p->bRaw = FALSE; +/*N*/ return p; +/*N*/ } + + +/*N*/ ScToken* ScRawToken::CreateToken() const +/*N*/ { +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case svByte : +/*N*/ return new ScByteToken( eOp, cByte ); +/*N*/ break; +/*N*/ case svDouble : +/*N*/ return new ScDoubleToken( eOp, nValue ); +/*N*/ break; +/*N*/ case svString : +/*N*/ return new ScStringToken( eOp, String( cStr ) ); +/*N*/ break; +/*N*/ case svSingleRef : +/*N*/ return new ScSingleRefToken( eOp, aRef.Ref1 ); +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ return new ScDoubleRefToken( eOp, aRef ); +/*N*/ break; +/*?*/ case svMatrix : +/*?*/ return new ScMatrixToken( eOp, pMat ); +/*?*/ break; +/*N*/ case svIndex : +/*N*/ return new ScIndexToken( eOp, nIndex ); +/*N*/ break; +/*N*/ case svJump : +/*N*/ return new ScJumpToken( eOp, (short*) nJump ); +/*N*/ break; +/*N*/ case svExternal : +/*N*/ return new ScExternalToken( eOp, cByte, String( cStr+1 ) ); +/*N*/ break; +/*N*/ case svFAP : +/*?*/ return new ScFAPToken( eOp, cByte, NULL ); +/*?*/ break; +/*?*/ case svMissing : +/*?*/ return new ScMissingToken( eOp ); +/*?*/ break; +/*?*/ case svErr : +/*?*/ return new ScErrToken( eOp ); +/*?*/ break; +/*?*/ default: +/*?*/ // read in unknown! +/*?*/ return new ScUnknownToken( eOp, GetType(), (BYTE*) cStr ); +/*N*/ } +/*N*/ } + + +/*N*/ void ScRawToken::Delete() +/*N*/ { +/*N*/ if ( bRaw ) +/*?*/ delete this; // FixedMemPool ScRawToken +/*N*/ else +/*N*/ { // created per Clone +/*N*/ switch ( eType ) +/*N*/ { +/*N*/ case svDouble : +/*N*/ delete (ScDoubleRawToken*) this; // FixedMemPool ScDoubleRawToken +/*N*/ break; +/*N*/ default: +/*N*/ delete [] (BYTE*) this; +/*N*/ } +/*N*/ } +/*N*/ } + + +// --- class ScToken -------------------------------------------------------- + +/*N*/ SingleRefData lcl_ScToken_InitSingleRef() +/*N*/ { +/*N*/ SingleRefData aRef; +/*N*/ aRef.InitAddress( ScAddress() ); +/*N*/ return aRef; +/*N*/ } + +/*N*/ ComplRefData lcl_ScToken_InitDoubleRef() +/*N*/ { +/*N*/ ComplRefData aRef; +/*N*/ aRef.Ref1 = lcl_ScToken_InitSingleRef(); +/*N*/ aRef.Ref2 = aRef.Ref1; +/*N*/ return aRef; +/*N*/ } + +/*N*/ SingleRefData ScToken::aDummySingleRef = lcl_ScToken_InitSingleRef(); +/*N*/ ComplRefData ScToken::aDummyDoubleRef = lcl_ScToken_InitDoubleRef(); +/*N*/ String ScToken::aDummyString; + + +/*N*/ ScToken::~ScToken() +/*N*/ { +/*N*/ } + + +/*N*/ BYTE ScToken::GetParamCount() const +/*N*/ { +/*N*/ if ( eOp <= ocEndDiv && eOp != ocExternal && eOp != ocMacro && +/*N*/ eOp != ocIf && eOp != ocChose && eOp != ocPercentSign ) +/*N*/ return 0; // parameters and specials +/*N*/ // ocIf and ocChose not for FAP, have cByte then +/*N*/ //2do: BOOL parameter whether FAP or not? +/*N*/ else if ( GetByte() ) +/*N*/ return GetByte(); // all functions, also ocExternal and ocMacro +/*N*/ else if ( ocEndDiv < eOp && eOp <= ocEndBinOp ) +/*N*/ return 2; // binary +/*N*/ else if ( (ocEndBinOp < eOp && eOp <= ocEndUnOp) || eOp == ocPercentSign ) +/*N*/ return 1; // unary +/*N*/ else if ( ocEndUnOp < eOp && eOp <= ocEndNoPar ) +/*N*/ return 0; // no parameter +/*N*/ else if ( ocEndNoPar < eOp && eOp <= ocEnd1Par ) +/*N*/ return 1; // one parameter +/*N*/ else +/*N*/ return 0; // all the rest, no Parameter, or +/*N*/ // if so then it should be in cByte +/*N*/ } + + +/*N*/ ScToken* ScToken::Clone() const +/*N*/ { +/*N*/ switch ( GetType() ) +/*N*/ { +/*N*/ case svByte : +/*N*/ return new ScByteToken( *static_cast<const ScByteToken*>(this) ); +/*N*/ break; +/*N*/ case svDouble : +/*N*/ return new ScDoubleToken( *static_cast<const ScDoubleToken*>(this) ); +/*N*/ break; +/*N*/ case svString : +/*N*/ return new ScStringToken( *static_cast<const ScStringToken*>(this) ); +/*N*/ break; +/*N*/ case svSingleRef : +/*N*/ return new ScSingleRefToken( *static_cast<const ScSingleRefToken*>(this) ); +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ return new ScDoubleRefToken( *static_cast<const ScDoubleRefToken*>(this) ); +/*N*/ break; +/*?*/ case svMatrix : +/*?*/ return new ScMatrixToken( *static_cast<const ScMatrixToken*>(this) ); +/*?*/ break; +/*?*/ case svIndex : +/*?*/ return new ScIndexToken( *static_cast<const ScIndexToken*>(this) ); +/*?*/ break; +/*N*/ case svJump : +/*N*/ return new ScJumpToken( *static_cast<const ScJumpToken*>(this) ); +/*N*/ break; +/*?*/ case svExternal : +/*?*/ return new ScExternalToken( *static_cast<const ScExternalToken*>(this) ); +/*?*/ break; +/*?*/ case svFAP : +/*?*/ return new ScFAPToken( *static_cast<const ScFAPToken*>(this) ); +/*?*/ break; +/*?*/ case svMissing : +/*?*/ return new ScMissingToken( *static_cast<const ScMissingToken*>(this) ); +/*?*/ break; +/*?*/ case svErr : +/*?*/ return new ScErrToken( *static_cast<const ScErrToken*>(this) ); +/*?*/ break; +/*?*/ default: +/*?*/ // read in unknown! +/*?*/ return new ScUnknownToken( *static_cast<const ScUnknownToken*>(this) ); +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScToken::operator==( const ScToken& rToken ) const +/*N*/ { +/*N*/ // don't compare reference count! +/*N*/ return eOp == rToken.eOp && eType == rToken.eType; +/*N*/ } + + +// TextEqual: if same formula entered (for optimization in sort) +/*N*/ BOOL ScToken::TextEqual( const ScToken& rToken ) const +/*N*/ { +/*N*/ if ( eType == svSingleRef || eType == svDoubleRef ) +/*N*/ { +/*N*/ // in relative Refs only compare relative parts +/*N*/ +/*N*/ if ( eOp != rToken.eOp || eType != rToken.eType ) +/*N*/ return FALSE; +/*N*/ +/*N*/ ComplRefData aTemp1; +/*N*/ if ( eType == svSingleRef ) +/*N*/ { +/*N*/ aTemp1.Ref1 = GetSingleRef(); +/*N*/ aTemp1.Ref2 = aTemp1.Ref1; +/*N*/ } +/*N*/ else +/*N*/ aTemp1 = GetDoubleRef(); +/*N*/ +/*N*/ ComplRefData aTemp2; +/*N*/ if ( rToken.eType == svSingleRef ) +/*N*/ { +/*N*/ aTemp2.Ref1 = rToken.GetSingleRef(); +/*N*/ aTemp2.Ref2 = aTemp2.Ref1; +/*N*/ } +/*N*/ else +/*N*/ aTemp2 = rToken.GetDoubleRef(); +/*N*/ +/*N*/ ScAddress aPos; +/*N*/ aTemp1.SmartRelAbs(aPos); +/*N*/ aTemp2.SmartRelAbs(aPos); +/*N*/ +/*N*/ // memcmp doesn't work because of the alignment byte after bFlags. +/*N*/ // After SmartRelAbs only absolute parts have to be compared. +/*N*/ return aTemp1.Ref1.nCol == aTemp2.Ref1.nCol && +/*N*/ aTemp1.Ref1.nRow == aTemp2.Ref1.nRow && +/*N*/ aTemp1.Ref1.nTab == aTemp2.Ref1.nTab && +/*N*/ aTemp1.Ref1.bFlags == aTemp2.Ref1.bFlags && +/*N*/ aTemp1.Ref2.nCol == aTemp2.Ref2.nCol && +/*N*/ aTemp1.Ref2.nRow == aTemp2.Ref2.nRow && +/*N*/ aTemp1.Ref2.nTab == aTemp2.Ref2.nTab && +/*N*/ aTemp1.Ref2.bFlags == aTemp2.Ref2.bFlags; +/*N*/ } +/*N*/ else +/*N*/ return *this == rToken; // else normal operator== +/*N*/ } + +// --- virtual dummy methods ------------------------------------------------- + +/*N*/ BYTE ScToken::GetByte() const +/*N*/ { +/*N*/ // ok to be called for any derived class +/*N*/ return 0; +/*N*/ } + +/*N*/ void ScToken::SetByte( BYTE n ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::SetByte: virtual dummy called" ); +/*N*/ } + +/*N*/ double ScToken::GetDouble() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetDouble: virtual dummy called" ); +/*N*/ return 0.0; +/*N*/ } + +/*N*/ const String& ScToken::GetString() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetString: virtual dummy called" ); +/*N*/ return aDummyString; +/*N*/ } + +/*N*/ const SingleRefData& ScToken::GetSingleRef() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetSingleRef: virtual dummy called" ); +/*N*/ return aDummySingleRef; +/*N*/ } + +/*N*/ SingleRefData& ScToken::GetSingleRef() +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetSingleRef: virtual dummy called" ); +/*N*/ return aDummySingleRef; +/*N*/ } + +/*N*/ const ComplRefData& ScToken::GetDoubleRef() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetDoubleRef: virtual dummy called" ); +/*N*/ return aDummyDoubleRef; +/*N*/ } + +/*N*/ ComplRefData& ScToken::GetDoubleRef() +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetDoubleRef: virtual dummy called" ); +/*N*/ return aDummyDoubleRef; +/*N*/ } + +/*N*/ const SingleRefData& ScToken::GetSingleRef2() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetSingleRef2: virtual dummy called" ); +/*N*/ return aDummySingleRef; +/*N*/ } + +/*N*/ SingleRefData& ScToken::GetSingleRef2() +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetSingleRef2: virtual dummy called" ); +/*N*/ return aDummySingleRef; +/*N*/ } + +/*N*/ void ScToken::CalcAbsIfRel( const ScAddress& rPos ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::CalcAbsIfRel: virtual dummy called" ); +/*N*/ } + +/*N*/ void ScToken::CalcRelFromAbs( const ScAddress& rPos ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::CalcRelFromAbs: virtual dummy called" ); +/*N*/ } + +/*N*/ ScMatrix* ScToken::GetMatrix() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetMatrix: virtual dummy called" ); +/*N*/ return NULL; +/*N*/ } + +/*N*/ USHORT ScToken::GetIndex() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetIndex: virtual dummy called" ); +/*N*/ return 0; +/*N*/ } + +/*N*/ void ScToken::SetIndex( USHORT n ) +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::SetIndex: virtual dummy called" ); +/*N*/ } + +/*N*/ short* ScToken::GetJump() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetJump: virtual dummy called" ); +/*N*/ return NULL; +/*N*/ } + +/*N*/ const String& ScToken::GetExternal() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetExternal: virtual dummy called" ); +/*N*/ return aDummyString; +/*N*/ } + +/*N*/ BYTE* ScToken::GetUnknown() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetUnknown: virtual dummy called" ); +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScToken::GetFAPOrigToken() const +/*N*/ { +/*N*/ DBG_ERRORFILE( "ScToken::GetFAPOrigToken: virtual dummy called" ); +/*N*/ return NULL; +/*N*/ } + + +// real implementations of virtual functions + +/*N*/ BYTE ScByteToken::GetByte() const { return nByte; } +/*N*/ void ScByteToken::SetByte( BYTE n ) { nByte = n; } +/*N*/ BOOL ScByteToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && nByte == r.GetByte(); +/*N*/ } + + +/*N*/ ScToken* ScFAPToken::GetFAPOrigToken() const { return pOrigToken; } +/*N*/ BOOL ScFAPToken::operator==( const ScToken& r ) const +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return FALSE;/*N*/ return ScToken::operator==( r ) && pOrigToken == r.GetFAPOrigToken(); +/*N*/ } + + +/*N*/ double ScDoubleToken::GetDouble() const { return fDouble; } +/*N*/ BOOL ScDoubleToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && fDouble == r.GetDouble(); +/*N*/ } + + +/*N*/ const String& ScStringToken::GetString() const { return aString; } +/*N*/ BOOL ScStringToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && aString == r.GetString(); +/*N*/ } + + +/*N*/ const SingleRefData& ScSingleRefToken::GetSingleRef() const { return aSingleRef; } +/*N*/ SingleRefData& ScSingleRefToken::GetSingleRef() { return aSingleRef; } +/*N*/ void ScSingleRefToken::CalcAbsIfRel( const ScAddress& rPos ) +/*N*/ { aSingleRef.CalcAbsIfRel( rPos ); } +/*N*/ void ScSingleRefToken::CalcRelFromAbs( const ScAddress& rPos ) +/*N*/ { aSingleRef.CalcRelFromAbs( rPos ); } +/*N*/ BOOL ScSingleRefToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && aSingleRef == r.GetSingleRef(); +/*N*/ } + + +/*N*/ const SingleRefData& ScDoubleRefToken::GetSingleRef() const { return aDoubleRef.Ref1; } +/*N*/ SingleRefData& ScDoubleRefToken::GetSingleRef() { return aDoubleRef.Ref1; } +/*N*/ const ComplRefData& ScDoubleRefToken::GetDoubleRef() const { return aDoubleRef; } +/*N*/ ComplRefData& ScDoubleRefToken::GetDoubleRef() { return aDoubleRef; } +/*N*/ const SingleRefData& ScDoubleRefToken::GetSingleRef2() const { return aDoubleRef.Ref2; } +/*N*/ SingleRefData& ScDoubleRefToken::GetSingleRef2() { return aDoubleRef.Ref2; } +/*N*/ void ScDoubleRefToken::CalcAbsIfRel( const ScAddress& rPos ) +/*N*/ { aDoubleRef.CalcAbsIfRel( rPos ); } +/*N*/ void ScDoubleRefToken::CalcRelFromAbs( const ScAddress& rPos ) +/*N*/ { aDoubleRef.CalcRelFromAbs( rPos ); } +/*N*/ BOOL ScDoubleRefToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && aDoubleRef == r.GetDoubleRef(); +/*N*/ } + + +/*N*/ ScMatrix* ScMatrixToken::GetMatrix() const { return pMatrix; } +/*N*/ BOOL ScMatrixToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && pMatrix == r.GetMatrix(); +/*N*/ } + + +/*N*/ USHORT ScIndexToken::GetIndex() const { return nIndex; } +/*N*/ void ScIndexToken::SetIndex( USHORT n ) { nIndex = n; } +/*N*/ BOOL ScIndexToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && nIndex == r.GetIndex(); +/*N*/ } + + +/*N*/ short* ScJumpToken::GetJump() const { return pJump; } +/*N*/ BOOL ScJumpToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && pJump[0] == r.GetJump()[0] && +/*N*/ memcmp( pJump+1, r.GetJump()+1, pJump[0] * sizeof(short) ) == 0; +/*N*/ } +/*N*/ ScJumpToken::~ScJumpToken() +/*N*/ { +/*N*/ delete [] pJump; +/*N*/ } + + +/*N*/ const String& ScExternalToken::GetExternal() const { return aExternal; } +/*N*/ BYTE ScExternalToken::GetByte() const { return nByte; } +/*N*/ void ScExternalToken::SetByte( BYTE n ) { nByte = n; } +/*N*/ BOOL ScExternalToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && nByte == r.GetByte() && +/*N*/ aExternal == r.GetExternal(); +/*N*/ } + + +/*N*/ double ScMissingToken::GetDouble() const { return 0.0; } +/*N*/ const String& ScMissingToken::GetString() const { return aDummyString; } +/*N*/ BOOL ScMissingToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ); +/*N*/ } + + +/*N*/ BOOL ScErrToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ); +/*N*/ } + + +/*N*/ BYTE* ScUnknownToken::GetUnknown() const { return pUnknown; } +/*N*/ BOOL ScUnknownToken::operator==( const ScToken& r ) const +/*N*/ { +/*N*/ return ScToken::operator==( r ) && pUnknown[0] == r.GetUnknown()[0] && +/*N*/ memcmp( pUnknown+1, r.GetUnknown()+1, pUnknown[0] * sizeof(BYTE) ) == 0; +/*N*/ } +/*N*/ ScUnknownToken::~ScUnknownToken() +/*N*/ { +/*N*/ delete [] pUnknown; +/*N*/ } + + +////////////////////////////////////////////////////////////////////////// + +/*N*/ ScToken* ScTokenArray::GetNextReference() +/*N*/ { +/*N*/ while( nIndex < nLen ) +/*N*/ { +/*N*/ ScToken* t = pCode[ nIndex++ ]; +/*N*/ switch( t->GetType() ) +/*N*/ { +/*N*/ case svSingleRef: +/*N*/ case svDoubleRef: +/*N*/ return t; +/*N*/ } +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::GetNextReferenceRPN() +/*N*/ { +/*N*/ while( nIndex < nRPN ) +/*N*/ { +/*N*/ ScToken* t = pRPN[ nIndex++ ]; +/*N*/ switch( t->GetType() ) +/*N*/ { +/*N*/ case svSingleRef: +/*N*/ case svDoubleRef: +/*N*/ return t; +/*N*/ } +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::GetNextReferenceOrName() +/*N*/ { +/*N*/ for( ScToken* t = Next(); t; t = Next() ) +/*N*/ { +/*N*/ switch( t->GetType() ) +/*N*/ { +/*N*/ case svSingleRef: +/*N*/ case svDoubleRef: +/*N*/ case svIndex: +/*N*/ return t; +/*N*/ } +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::GetNextOpCodeRPN( OpCode eOp ) +/*N*/ { +/*N*/ while( nIndex < nRPN ) +/*N*/ { +/*?*/ ScToken* t = pRPN[ nIndex++ ]; +/*?*/ if ( t->GetOpCode() == eOp ) +/*?*/ return t; +/*N*/ } +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::Next() +/*N*/ { +/*N*/ if( pCode && nIndex < nLen ) +/*N*/ return pCode[ nIndex++ ]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::NextRPN() +/*N*/ { +/*N*/ if( pRPN && nIndex < nRPN ) +/*N*/ return pRPN[ nIndex++ ]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ void ScTokenArray::DelRPN() +/*N*/ { +/*N*/ if( nRPN ) +/*N*/ { +/*N*/ ScToken** p = pRPN; +/*N*/ for( USHORT i = 0; i < nRPN; i++ ) +/*N*/ { +/*N*/ (*p++)->DecRef(); +/*N*/ } +/*N*/ delete [] pRPN; +/*N*/ } +/*N*/ pRPN = NULL; +/*N*/ nRPN = nIndex = 0; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::PeekNext() +/*N*/ { +/*N*/ if( pCode && nIndex < nLen ) +/*N*/ return pCode[ nIndex ]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::PeekNextNoSpaces() +/*N*/ { +/*N*/ if( pCode && nIndex < nLen ) +/*N*/ { +/*N*/ USHORT j = nIndex; +/*N*/ while ( pCode[j]->GetOpCode() == ocSpaces && j < nLen ) +/*N*/ j++; +/*N*/ if ( j < nLen ) +/*N*/ return pCode[ j ]; +/*N*/ else +/*N*/ return NULL; +/*N*/ } +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ ScToken* ScTokenArray::PeekPrevNoSpaces() +/*N*/ { +/*N*/ if( pCode && nIndex > 1 ) +/*N*/ { +/*?*/ USHORT j = nIndex - 2; +/*?*/ while ( pCode[j]->GetOpCode() == ocSpaces && j > 0 ) +/*?*/ j--; +/*?*/ if ( j > 0 || pCode[j]->GetOpCode() != ocSpaces ) +/*?*/ return pCode[ j ]; +/*?*/ else +/*?*/ return NULL; +/*N*/ } +/*N*/ else +/*N*/ return NULL; +/*N*/ } + +/*N*/ BOOL ScTokenArray::HasOpCodeRPN( OpCode eOp ) const +/*N*/ { +/*N*/ for ( USHORT j=0; j < nRPN; j++ ) +/*N*/ { +/*N*/ if ( pRPN[j]->GetOpCode() == eOp ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScTokenArray::HasNameOrColRowName() const +/*N*/ { +/*N*/ for ( USHORT j=0; j < nLen; j++ ) +/*N*/ { +/*N*/ if( pCode[j]->GetType() == svIndex || pCode[j]->GetOpCode() == ocColRowName ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +/*N*/ BOOL ScTokenArray::ImplGetReference( ScRange& rRange, BOOL bValidOnly ) const +/*N*/ { +/*N*/ BOOL bIs = FALSE; +/*N*/ if ( pCode && nLen == 1 ) +/*N*/ { +/*N*/ const ScToken* pToken = pCode[0]; +/*N*/ if ( pToken ) +/*N*/ { +/*N*/ if ( pToken->GetType() == svSingleRef ) +/*N*/ { +/*N*/ const SingleRefData& rRef = ((const ScSingleRefToken*)pToken)->GetSingleRef(); +/*N*/ rRange.aStart = rRange.aEnd = ScAddress( rRef.nCol, rRef.nRow, rRef.nTab ); +/*N*/ bIs = !bValidOnly || !rRef.IsDeleted(); +/*N*/ } +/*N*/ else if ( pToken->GetType() == svDoubleRef ) +/*N*/ { +/*N*/ const ComplRefData& rCompl = ((const ScDoubleRefToken*)pToken)->GetDoubleRef(); +/*N*/ const SingleRefData& rRef1 = rCompl.Ref1; +/*N*/ const SingleRefData& rRef2 = rCompl.Ref2; +/*N*/ rRange.aStart = ScAddress( rRef1.nCol, rRef1.nRow, rRef1.nTab ); +/*N*/ rRange.aEnd = ScAddress( rRef2.nCol, rRef2.nRow, rRef2.nTab ); +/*N*/ bIs = !bValidOnly || (!rRef1.IsDeleted() && !rRef2.IsDeleted()); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return bIs; +/*N*/ } + +/*N*/ BOOL ScTokenArray::IsReference( ScRange& rRange ) const +/*N*/ { +/*N*/ return ImplGetReference( rRange, FALSE ); +/*N*/ } + +/*N*/ inline void lcl_GetAddress( ScAddress& rAddress, const ScToken& rToken ) +/*N*/ { +/*N*/ if ( rToken.GetType() == svSingleRef ) +/*N*/ { +/*N*/ const SingleRefData& rRef = ((const ScSingleRefToken&)rToken).GetSingleRef(); +/*N*/ rAddress.Set( rRef.nCol, rRef.nRow, rRef.nTab ); +/*N*/ } +/*N*/ } + +/*N*/ void ScTokenArray::Load30( SvStream& rStream, const ScAddress& rPos ) +/*N*/ { +/*N*/ Clear(); +/*N*/ ScToken* pToks[ MAXCODE ]; +/*N*/ ScRawToken t; +/*N*/ for( nLen = 0; nLen < MAXCODE; nLen++ ) +/*N*/ { +/*N*/ t.Load30( rStream ); +/*N*/ if( t.GetOpCode() == ocStop ) +/*N*/ break; +/*N*/ else if( t.GetOpCode() == ocPush +/*N*/ && ( t.GetType() == svSingleRef || t.GetType() == svDoubleRef ) ) +/*N*/ { +/*N*/ nRefs++; +/*N*/ t.aRef.CalcRelFromAbs( rPos ); +/*N*/ } +/*N*/ ScToken* p = pToks[ nLen ] = t.CreateToken(); +/*N*/ p->IncRef(); +/*N*/ } +/*N*/ pCode = new ScToken*[ nLen ]; +/*N*/ memcpy( pCode, pToks, nLen * sizeof( ScToken* ) ); +/*N*/ } + +/*N*/ void ScTokenArray::Load( SvStream& rStream, USHORT nVer, const ScAddress& rPos ) +/*N*/ { +/*N*/ Clear(); +/*N*/ // 0x10 - nRefs +/*N*/ // 0x20 - nError +/*N*/ // 0x40 - TokenArray +/*N*/ // 0x80 - CodeArray +/*N*/ BYTE cData; +/*N*/ rStream >> cData; +/*N*/ if( cData & 0x0F ) +/*?*/ rStream.SeekRel( cData & 0x0F ); +/*N*/ if ( nVer < SC_RECALC_MODE_BITS ) +/*N*/ { +/*N*/ BYTE cMode; +/*N*/ rStream >> cMode; +/*N*/ ImportRecalcMode40( (ScRecalcMode40) cMode ); +/*N*/ } +/*N*/ else +/*N*/ rStream >> nMode; +/*N*/ if( cData & 0x10 ) +/*N*/ rStream >> nRefs; +/*N*/ if( cData & 0x20 ) +/*N*/ rStream >> nError; +/*N*/ ScToken* pToks[ MAXCODE ]; +/*N*/ ScToken** pp = pToks; +/*N*/ ScRawToken t; +/*N*/ if( cData & 0x40 ) +/*N*/ { +/*N*/ rStream >> nLen; +/*N*/ for( USHORT i = 0; i < nLen; i++ ) +/*N*/ { +/*N*/ t.Load( rStream, nVer ); +/*N*/ if ( t.GetType() == svSingleRef || t.GetType() == svDoubleRef ) +/*N*/ t.aRef.CalcRelFromAbs( rPos ); +/*N*/ // gespeichert wurde und wird immer absolut +/*N*/ *pp = t.CreateToken(); +/*N*/ (*pp++)->IncRef(); +/*N*/ } +/*N*/ pCode = new ScToken*[ nLen ]; +/*N*/ memcpy( pCode, pToks, nLen * sizeof( ScToken* ) ); +/*N*/ } +/*N*/ pp = pToks; +/*N*/ if( cData & 0x80 ) +/*N*/ { +/*N*/ rStream >> nRPN; +/*N*/ for( USHORT i = 0; i < nRPN; i++, pp++ ) +/*N*/ { +/*N*/ BYTE b1, b2 = 0; +/*N*/ UINT16 nIdx; +/*N*/ rStream >> b1; +/*N*/ // 0xFF - Token folgt +/*N*/ // 0x40-0x7F - untere 6 Bits, 1 Byte mit 8 weiteren Bits +/*N*/ // 0x00-0x3F - Index +/*N*/ if( b1 == 0xFF ) +/*N*/ { +/*N*/ t.Load( rStream, nVer ); +/*N*/ if ( t.GetType() == svSingleRef || t.GetType() == svDoubleRef ) +/*N*/ t.aRef.CalcRelFromAbs( rPos ); +/*N*/ // gespeichert wurde und wird immer absolut +/*N*/ *pp = t.CreateToken(); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if( b1 & 0x40 ) +/*N*/ { +/*N*/ rStream >> b2; +/*N*/ nIdx = ( b1 & 0x3F ) | ( b2 << 6 ); +/*N*/ } +/*N*/ else +/*N*/ nIdx = b1; +/*N*/ *pp = pCode[ nIdx ]; +/*N*/ } +/*N*/ (*pp)->IncRef(); +/*N*/ // #73616# CONVERT function recalculated on each load +/*N*/ if ( nVer < SC_CONVERT_RECALC_ON_LOAD && (*pp)->GetOpCode() == ocConvert ) +/*N*/ AddRecalcMode( RECALCMODE_ONLOAD ); +/*N*/ } +/*N*/ pRPN = new ScToken*[ nRPN ]; +/*N*/ memcpy( pRPN, pToks, nRPN * sizeof( ScToken* ) ); +/*N*/ // Aeltere Versionen: kein UPN-Array laden +/*N*/ if( nVer < SC_NEWIF ) +/*?*/ DelRPN(); +/*N*/ } +/*N*/ } + +/*N*/ void ScTokenArray::Store( SvStream& rStream, const ScAddress& rPos ) const +/*N*/ { +/*N*/ // 0x10 - nRefs +/*N*/ // 0x20 - nError +/*N*/ // 0x40 - TokenArray +/*N*/ // 0x80 - CodeArray +/*N*/ BYTE cFlags = 0; +/*N*/ if( nRefs ) +/*N*/ cFlags |= 0x10; +/*N*/ if( nError ) +/*N*/ cFlags |= 0x20; +/*N*/ if( nLen ) +/*N*/ cFlags |= 0x40; +/*N*/ if( nRPN ) +/*N*/ cFlags |= 0x80; +/*N*/ rStream << cFlags; +/*N*/ // Hier ggf. Zusatzdaten! +/*N*/ if ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_40 ) +/*N*/ rStream << (BYTE) ExportRecalcMode40(); +/*N*/ else +/*N*/ rStream << (BYTE) nMode; +/*N*/ if( cFlags & 0x10 ) +/*N*/ rStream << (INT16) nRefs; +/*N*/ if( cFlags & 0x20 ) +/*N*/ rStream << (UINT16) nError; +/*N*/ if( cFlags & 0x40 ) +/*N*/ { +/*N*/ rStream << nLen; +/*N*/ ScToken** p = pCode; +/*N*/ for( USHORT i = 0; i < nLen; i++, p++ ) +/*N*/ { +/*N*/ // gespeichert wurde und wird immer absolut +/*N*/ switch ( (*p)->GetType() ) +/*N*/ { +/*N*/ case svSingleRef : +/*N*/ (*p)->GetSingleRef().CalcAbsIfRel( rPos ); +/*N*/ break; +/*N*/ case svDoubleRef : +/*N*/ (*p)->GetDoubleRef().CalcAbsIfRel( rPos ); +/*N*/ break; +/*N*/ } +/*N*/ (*p)->Store( rStream ); +/*N*/ } +/*N*/ } +/*N*/ if( cFlags & 0x80 ) +/*N*/ { +/*N*/ rStream << nRPN; +/*N*/ ScToken** p = pRPN; +/*N*/ for( USHORT i = 0; i < nRPN; i++, p++ ) +/*N*/ { +/*N*/ ScToken* t = *p; +/*N*/ USHORT nIdx = 0xFFFF; +/*N*/ if( t->GetRef() > 1 ) +/*N*/ { +/*N*/ ScToken** p2 = pCode; +/*N*/ for( USHORT j = 0; j < nLen; j++, p2++ ) +/*N*/ { +/*N*/ if( *p2 == t ) +/*N*/ { +/*N*/ nIdx = j; break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ // 0xFF - Token folgt +/*N*/ // 0x40-0x7F - untere 6 Bits, 1 Byte mit 8 weiteren Bits +/*N*/ // 0x00-0x3F - Index +/*N*/ if( nIdx == 0xFFFF ) +/*N*/ { +/*N*/ // gespeichert wurde und wird immer absolut +/*N*/ switch ( t->GetType() ) +/*N*/ { +/*N*/ case svSingleRef : +/*N*/ t->GetSingleRef().CalcAbsIfRel( rPos ); +/*N*/ break; +/*?*/ case svDoubleRef : +/*?*/ t->GetDoubleRef().CalcAbsIfRel( rPos ); +/*?*/ break; +/*N*/ } +/*N*/ rStream << (BYTE) 0xFF; +/*N*/ t->Store( rStream ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if( nIdx < 0x40 ) +/*N*/ rStream << (BYTE) nIdx; +/*N*/ else +/*N*/ rStream << (BYTE) ( ( nIdx & 0x3F ) | 0x40 ) +/*N*/ << (BYTE) ( nIdx >> 6 ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +//////////////////////////////////////////////////////////////////////////// + +/*N*/ ScTokenArray::ScTokenArray() +/*N*/ { +/*N*/ pCode = NULL; pRPN = NULL; +/*N*/ nError = nLen = nIndex = nRPN = nRefs = 0; +/*M*/ bReplacedSharedFormula = FALSE; +/*N*/ ClearRecalcMode(); +/*N*/ } + +/*N*/ ScTokenArray::ScTokenArray( const ScTokenArray& rArr ) +/*N*/ { +/*N*/ Assign( rArr ); +/*N*/ } + +/*N*/ ScTokenArray::~ScTokenArray() +/*N*/ { +/*N*/ Clear(); +/*N*/ } + +/*N*/ void ScTokenArray::Assign( const ScTokenArray& r ) +/*N*/ { +/*N*/ nLen = r.nLen; +/*N*/ nRPN = r.nRPN; +/*N*/ nIndex = r.nIndex; +/*N*/ nError = r.nError; +/*N*/ nRefs = r.nRefs; +/*N*/ nMode = r.nMode; +/*M*/ bReplacedSharedFormula = FALSE; +/*N*/ pCode = NULL; +/*N*/ pRPN = NULL; +/*N*/ ScToken** pp; +/*N*/ if( nLen ) +/*N*/ { +/*N*/ pp = pCode = new ScToken*[ nLen ]; +/*N*/ memcpy( pp, r.pCode, nLen * sizeof( ScToken* ) ); +/*N*/ for( USHORT i = 0; i < nLen; i++ ) +/*N*/ (*pp++)->IncRef(); +/*N*/ } +/*N*/ if( nRPN ) +/*N*/ { +/*?*/ pp = pRPN = new ScToken*[ nRPN ]; +/*?*/ memcpy( pp, r.pRPN, nRPN * sizeof( ScToken* ) ); +/*?*/ for( USHORT i = 0; i < nRPN; i++ ) +/*?*/ (*pp++)->IncRef(); +/*N*/ } +/*N*/ } + +/*N*/ ScTokenArray& ScTokenArray::operator=( const ScTokenArray& rArr ) +/*N*/ { +/*N*/ Clear(); +/*N*/ Assign( rArr ); +/*N*/ return *this; +/*N*/ } + +/*N*/ ScTokenArray* ScTokenArray::Clone() const +/*N*/ { +/*N*/ ScTokenArray* p = new ScTokenArray; +/*N*/ p->nLen = nLen; +/*N*/ p->nRPN = nRPN; +/*N*/ p->nRefs = nRefs; +/*N*/ p->nMode = nMode; +/*N*/ p->nError = nError; +/*N*/ ScToken** pp; +/*N*/ if( nLen ) +/*N*/ { +/*N*/ pp = p->pCode = new ScToken*[ nLen ]; +/*N*/ memcpy( pp, pCode, nLen * sizeof( ScToken* ) ); +/*N*/ for( USHORT i = 0; i < nLen; i++, pp++ ) +/*N*/ { +/*N*/ *pp = (*pp)->Clone(); +/*N*/ (*pp)->IncRef(); +/*N*/ } +/*N*/ } +/*N*/ if( nRPN ) +/*N*/ { +/*N*/ pp = p->pRPN = new ScToken*[ nRPN ]; +/*N*/ memcpy( pp, pRPN, nRPN * sizeof( ScToken* ) ); +/*N*/ for( USHORT i = 0; i < nRPN; i++, pp++ ) +/*N*/ { +/*N*/ ScToken* t = *pp; +/*N*/ if( t->GetRef() > 1 ) +/*N*/ { +/*N*/ ScToken** p2 = pCode; +/*N*/ USHORT nIdx = 0xFFFF; +/*N*/ for( USHORT j = 0; j < nLen; j++, p2++ ) +/*N*/ { +/*N*/ if( *p2 == t ) +/*N*/ { +/*N*/ nIdx = j; break; +/*N*/ } +/*N*/ } +/*N*/ if( nIdx == 0xFFFF ) +/*?*/ *pp = t->Clone(); +/*N*/ else +/*N*/ *pp = p->pCode[ nIdx ]; +/*N*/ } +/*N*/ else +/*N*/ *pp = t->Clone(); +/*N*/ (*pp)->IncRef(); +/*N*/ } +/*N*/ } +/*N*/ return p; +/*N*/ } + +/*N*/ void ScTokenArray::Clear() +/*N*/ { +/*N*/ if( nRPN ) DelRPN(); +/*N*/ if( pCode ) +/*N*/ { +/*N*/ ScToken** p = pCode; +/*N*/ for( USHORT i = 0; i < nLen; i++ ) +/*N*/ { +/*N*/ (*p++)->DecRef(); +/*N*/ } +/*N*/ delete [] pCode; +/*N*/ } +/*N*/ pCode = NULL; pRPN = NULL; +/*N*/ nError = nLen = nIndex = nRPN = nRefs = 0; +/*M*/ bReplacedSharedFormula = FALSE; +/*N*/ ClearRecalcMode(); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddToken( const ScRawToken& r ) +/*N*/ { +/*N*/ return Add( r.CreateToken() ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddToken( const ScToken& r ) +/*N*/ { +/*N*/ return Add( r.Clone() ); +/*N*/ } + +// Wird auch vom Compiler genutzt. Das Token ist per new angelegt! + +/*N*/ ScToken* ScTokenArray::Add( ScToken* t ) +/*N*/ { +/*N*/ if( !pCode ) +/*N*/ pCode = new ScToken*[ MAXCODE ]; +/*N*/ if( nLen < MAXCODE-1 ) +/*N*/ { +/*N*/ pCode[ nLen++ ] = t; +/*N*/ if( t->GetOpCode() == ocPush +/*N*/ && ( t->GetType() == svSingleRef || t->GetType() == svDoubleRef ) ) +/*N*/ nRefs++; +/*N*/ t->IncRef(); +/*N*/ return t; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ t->Delete(); +/*?*/ if ( nLen == MAXCODE-1 ) +/*?*/ { +/*?*/ t = new ScByteToken( ocStop ); +/*?*/ pCode[ nLen++ ] = t; +/*?*/ t->IncRef(); +/*?*/ } +/*?*/ return NULL; +/*N*/ } +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddOpCode( OpCode e ) +/*N*/ { +/*N*/ ScRawToken t; +/*N*/ t.SetOpCode( e ); +/*N*/ return AddToken( t ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddString( const sal_Unicode* pStr ) +/*N*/ { +/*N*/ return AddString( String( pStr ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddString( const String& rStr ) +/*N*/ { +/*N*/ return Add( new ScStringToken( rStr ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddDouble( double fVal ) +/*N*/ { +/*N*/ return Add( new ScDoubleToken( fVal ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddSingleReference( const SingleRefData& rRef ) +/*N*/ { +/*N*/ return Add( new ScSingleRefToken( rRef ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddDoubleReference( const ComplRefData& rRef ) +/*N*/ { +/*N*/ return Add( new ScDoubleRefToken( rRef ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddExternal( const sal_Unicode* pStr ) +/*N*/ { +/*N*/ return AddExternal( String( pStr ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddExternal( const String& rStr ) +/*N*/ { +/*N*/ return Add( new ScExternalToken( ocExternal, rStr ) ); +/*N*/ } + +/*N*/ ScToken* ScTokenArray::AddBad( const String& rStr ) +/*N*/ { +/*N*/ return Add( new ScStringToken( ocBad, rStr ) ); +/*N*/ } + +/*N*/ void ScTokenArray::ImportRecalcMode40( ScRecalcMode40 eMode ) +/*N*/ { +/*N*/ switch ( eMode ) +/*N*/ { +/*N*/ case RC_NORMAL : +/*N*/ nMode = RECALCMODE_NORMAL; +/*N*/ break; +/*?*/ case RC_ALWAYS : +/*?*/ nMode = RECALCMODE_ALWAYS; +/*?*/ break; +/*?*/ case RC_ONLOAD : +/*?*/ nMode = RECALCMODE_ONLOAD; +/*?*/ break; +/*?*/ case RC_ONLOAD_ONCE : +/*?*/ nMode = RECALCMODE_ONLOAD_ONCE; +/*?*/ break; +/*?*/ case RC_FORCED : +/*?*/ nMode = RECALCMODE_NORMAL | RECALCMODE_FORCED; +/*?*/ break; +/*?*/ case RC_ONREFMOVE : +/*?*/ nMode = RECALCMODE_NORMAL | RECALCMODE_ONREFMOVE; +/*?*/ break; +/*?*/ default: +/*?*/ DBG_ERRORFILE( "ScTokenArray::ImportRecalcMode40: unknown ScRecalcMode40" ); +/*?*/ nMode = RECALCMODE_NORMAL; +/*N*/ } +/*N*/ } + + +/*N*/ ScRecalcMode40 ScTokenArray::ExportRecalcMode40() const +/*N*/ { +/*N*/ //! Reihenfolge ist wichtig +/*N*/ if ( nMode & RECALCMODE_ALWAYS ) +/*N*/ return RC_ALWAYS; +/*N*/ if ( nMode & RECALCMODE_ONLOAD ) +/*N*/ return RC_ONLOAD; +/*N*/ if ( nMode & RECALCMODE_FORCED ) +/*N*/ return RC_FORCED; +/*N*/ if ( nMode & RECALCMODE_ONREFMOVE ) +/*N*/ return RC_ONREFMOVE; +/*N*/ // kommt eigentlich nicht vor weil in Calc bereits umgesetzt, +/*N*/ // und woanders gibt es keinen 4.0-Export, deswegen als letztes +/*N*/ if ( nMode & RECALCMODE_ONLOAD_ONCE ) +/*N*/ return RC_ONLOAD_ONCE; +/*N*/ return RC_NORMAL; +/*N*/ } + + +/*N*/ void ScTokenArray::AddRecalcMode( ScRecalcMode nBits ) +/*N*/ { +/*N*/ //! Reihenfolge ist wichtig +/*N*/ if ( nBits & RECALCMODE_ALWAYS ) +/*?*/ SetRecalcModeAlways(); +/*N*/ else if ( !IsRecalcModeAlways() ) +/*N*/ { +/*N*/ if ( nBits & RECALCMODE_ONLOAD ) +/*N*/ SetRecalcModeOnLoad(); +/*N*/ else if ( nBits & RECALCMODE_ONLOAD_ONCE && !IsRecalcModeOnLoad() ) +/*?*/ SetRecalcModeOnLoadOnce(); +/*N*/ } +/*N*/ SetCombinedBitsRecalcMode( nBits ); +/*N*/ } + + +/*N*/ BOOL ScTokenArray::HasMatrixDoubleRefOps() +/*N*/ { +/*N*/ if ( pRPN && nRPN ) +/*N*/ { +/*N*/ // RPN-Interpreter Simulation +/*N*/ // als Ergebnis jeder Funktion wird einfach ein Double angenommen +/*N*/ ScToken** pStack = new ScToken* [nRPN]; +/*N*/ ScToken* pResult = new ScDoubleToken( ocPush, 0.0 ); +/*N*/ short sp = 0; +/*N*/ for ( USHORT j = 0; j < nRPN; j++ ) +/*N*/ { +/*N*/ ScToken* t = pRPN[j]; +/*N*/ OpCode eOp = t->GetOpCode(); +/*N*/ BYTE nParams = t->GetParamCount(); +/*N*/ switch ( eOp ) +/*N*/ { +/*N*/ case ocAdd : +/*N*/ case ocSub : +/*N*/ case ocMul : +/*N*/ case ocDiv : +/*N*/ case ocPow : +/*N*/ case ocPower : +/*N*/ case ocAmpersand : +/*N*/ case ocEqual : +/*N*/ case ocNotEqual : +/*N*/ case ocLess : +/*N*/ case ocGreater : +/*N*/ case ocLessEqual : +/*N*/ case ocGreaterEqual : +/*N*/ { +/*N*/ for ( BYTE k = nParams; k; k-- ) +/*N*/ { +/*N*/ if ( sp >= k && pStack[sp-k]->GetType() == svDoubleRef ) +/*N*/ { +/*?*/ pResult->Delete(); +/*?*/ delete [] pStack; +/*?*/ return TRUE; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ if ( eOp == ocPush || lcl_IsReference( eOp, t->GetType() ) ) +/*N*/ pStack[sp++] = t; +/*N*/ else if ( eOp == ocIf || eOp == ocChose ) +/*N*/ { // Jumps ignorieren, vorheriges Result (Condition) poppen +/*N*/ if ( sp ) +/*N*/ --sp; +/*N*/ } +/*N*/ else +/*N*/ { // pop parameters, push result +/*N*/ sp -= nParams; +/*N*/ if ( sp < 0 ) +/*N*/ { +/*N*/ DBG_ERROR( "ScTokenArray::HasMatrixDoubleRefOps: sp < 0" ); +/*N*/ sp = 0; +/*N*/ } +/*N*/ pStack[sp++] = pResult; +/*N*/ } +/*N*/ } +/*N*/ pResult->Delete(); +/*N*/ delete [] pStack; +/*N*/ } +/*N*/ +/*N*/ return FALSE; +/*N*/ } + +/////////////////////////////////////////////////////////////////////////// + +/*N*/ void ScRawToken::Load30( SvStream& rStream ) +/*N*/ { +/*N*/ UINT16 nOp; +/*N*/ BYTE n; +/*N*/ nRefCnt = 0; +/*N*/ rStream >> nOp; +/*N*/ eOp = (OpCode) nOp; +/*N*/ switch( eOp ) +/*N*/ { +/*N*/ case ocIf: +/*?*/ eType = svJump; nJump[ 0 ] = 3; break; // then, else, behind +/*N*/ case ocChose: +/*?*/ eType = svJump; nJump[ 0 ] = MAXJUMPCOUNT+1; break; +/*N*/ case ocPush: +/*N*/ rStream >> n; +/*N*/ eType = (StackVar) n; +/*N*/ switch( eType ) +/*N*/ { +/*N*/ case svByte: +/*?*/ rStream >> cByte; +/*?*/ break; +/*N*/ case svDouble: +/*N*/ rStream >> nValue; +/*N*/ break; +/*N*/ case svString: +/*N*/ { +/*?*/ sal_Char c[ MAXSTRLEN+1 ]; +/*?*/ rStream >> nOp; +/*?*/ if( nOp > MAXSTRLEN-1 ) +/*?*/ { +/*?*/ DBG_ERROR("Dokument huehnerich"); +/*?*/ USHORT nDiff = nOp - (MAXSTRLEN-1); +/*?*/ nOp = MAXSTRLEN-1; +/*?*/ rStream.Read( c, nOp ); +/*?*/ rStream.SeekRel( nDiff ); +/*?*/ } +/*?*/ else +/*?*/ rStream.Read( c, nOp ); +/*?*/ CharSet eSrc = rStream.GetStreamCharSet(); +/*?*/ for ( BYTE j=0; j<nOp; j++ ) +/*?*/ cStr[j] = ByteString::ConvertToUnicode( c[j], eSrc ); +/*?*/ cStr[ nOp ] = 0; +/*?*/ break; +/*N*/ } +/*N*/ case svSingleRef: +/*N*/ { +/*N*/ OldSingleRefBools aBools; +/*N*/ rStream >> aRef.Ref1.nCol +/*N*/ >> aRef.Ref1.nRow +/*N*/ >> aRef.Ref1.nTab +/*N*/ >> aBools.bRelCol +/*N*/ >> aBools.bRelRow +/*N*/ >> aBools.bRelTab +/*N*/ >> aBools.bOldFlag3D; +/*N*/ aRef.Ref1.OldBoolsToNewFlags( aBools ); +/*N*/ aRef.Ref2 = aRef.Ref1; +/*N*/ break; +/*N*/ } +/*N*/ case svDoubleRef: +/*N*/ { +/*N*/ OldSingleRefBools aBools1; +/*N*/ OldSingleRefBools aBools2; +/*N*/ rStream >> aRef.Ref1.nCol +/*N*/ >> aRef.Ref1.nRow +/*N*/ >> aRef.Ref1.nTab +/*N*/ >> aRef.Ref2.nCol +/*N*/ >> aRef.Ref2.nRow +/*N*/ >> aRef.Ref2.nTab +/*N*/ >> aBools1.bRelCol +/*N*/ >> aBools1.bRelRow +/*N*/ >> aBools1.bRelTab +/*N*/ >> aBools2.bRelCol +/*N*/ >> aBools2.bRelRow +/*N*/ >> aBools2.bRelTab +/*N*/ >> aBools1.bOldFlag3D +/*N*/ >> aBools2.bOldFlag3D; +/*N*/ aRef.Ref1.OldBoolsToNewFlags( aBools1 ); +/*N*/ aRef.Ref2.OldBoolsToNewFlags( aBools2 ); +/*N*/ break; +/*N*/ } +/*N*/ default: DBG_ERROR("Unknown Stack Variable"); +/*N*/ break; +/*N*/ } +/*N*/ break; +/*N*/ case ocName: +/*?*/ eType = svIndex; +/*?*/ rStream >> nIndex; +/*?*/ break; +/*?*/ case ocExternal: +/*?*/ { +/*?*/ sal_Char c[ MAXSTRLEN+1 ]; +/*?*/ eType = svExternal; +/*?*/ rStream >> nOp; +/*?*/ // lieber ein rottes Dokument als stack overwrite +/*?*/ if( nOp > MAXSTRLEN-2 ) +/*?*/ { +/*?*/ DBG_ERROR("Dokument huehnerich"); +/*?*/ USHORT nDiff = nOp - (MAXSTRLEN-2); +/*?*/ nOp = MAXSTRLEN-2; +/*?*/ rStream.Read( c, nOp ); +/*?*/ rStream.SeekRel( nDiff ); +/*?*/ } +/*?*/ else +/*?*/ rStream.Read( c, nOp ); +/*?*/ CharSet eSrc = rStream.GetStreamCharSet(); +/*?*/ for ( BYTE j=1; j<nOp; j++ ) +/*?*/ cStr[j] = ByteString::ConvertToUnicode( c[j-1], eSrc ); +/*?*/ cStr[ 0 ] = 0; //! parameter count is what?!? +/*?*/ cStr[ nOp ] = 0; +/*?*/ break; +/*?*/ } +/*N*/ default: +/*N*/ eType = svByte; +/*N*/ cByte = 0; +/*N*/ } +/*N*/ } + +// Bei unbekannten Tokens steht in cStr (k)ein Pascal-String (cStr[0] = Laenge), +// der nur gepuffert wird. cStr[0] = GESAMT-Laenge inkl. [0] !!! + +/*N*/ void ScRawToken::Load( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ BYTE n; +/*N*/ UINT16 nOp; +/*N*/ USHORT i; +/*N*/ rStream >> nOp >> n; +/*N*/ eOp = (OpCode) nOp; +/*N*/ eType = (StackVar) n; +/*N*/ switch( eType ) +/*N*/ { +/*N*/ case svByte: +/*N*/ rStream >> cByte; +/*N*/ break; +/*N*/ case svDouble: +/*N*/ rStream >> nValue; +/*N*/ break; +/*N*/ case svExternal: +/*N*/ { +/*N*/ sal_Char c[ MAXSTRLEN+1 ]; +/*N*/ rStream >> cByte >> n; +/*N*/ if( n > MAXSTRLEN-2 ) +/*N*/ { +/*?*/ DBG_ERRORFILE( "bad string array boundary" ); +/*?*/ USHORT nDiff = n - (MAXSTRLEN-2); +/*?*/ n = MAXSTRLEN-2; +/*?*/ rStream.Read( c+1, n ); +/*?*/ rStream.SeekRel( nDiff ); +/*N*/ } +/*N*/ else +/*N*/ rStream.Read( c+1, n ); +/*N*/ //! parameter count is in cByte (cStr[0] little endian) +/*N*/ CharSet eSrc = rStream.GetStreamCharSet(); +/*N*/ for ( BYTE j=1; j<n+1; j++ ) +/*N*/ cStr[j] = ByteString::ConvertToUnicode( c[j], eSrc ); +/*N*/ cStr[ n+1 ] = 0; +/*N*/ break; +/*N*/ } +/*N*/ case svString: +/*N*/ { +/*N*/ sal_Char c[ MAXSTRLEN+1 ]; +/*N*/ rStream >> n; +/*N*/ if( n > MAXSTRLEN-1 ) +/*N*/ { +/*?*/ DBG_ERRORFILE( "bad string array boundary" ); +/*?*/ USHORT nDiff = n - (MAXSTRLEN-1); +/*?*/ n = MAXSTRLEN-1; +/*?*/ rStream.Read( c, n ); +/*?*/ rStream.SeekRel( nDiff ); +/*N*/ } +/*N*/ else +/*N*/ rStream.Read( c, n ); +/*N*/ cStr[ n ] = 0; +/*N*/ CharSet eSrc = rStream.GetStreamCharSet(); +/*N*/ for ( BYTE j=0; j<n; j++ ) +/*N*/ cStr[j] = ByteString::ConvertToUnicode( c[j], eSrc ); +/*N*/ cStr[ n ] = 0; +/*N*/ break; +/*N*/ } +/*N*/ case svSingleRef: +/*N*/ case svDoubleRef: +/*N*/ { +/*N*/ SingleRefData& r = aRef.Ref1; +/*N*/ rStream >> r.nCol +/*N*/ >> r.nRow +/*N*/ >> r.nTab +/*N*/ >> n; +/*N*/ if ( nVer < SC_RELATIVE_REFS ) +/*N*/ { +/*N*/ OldSingleRefBools aBools; +/*N*/ aBools.bRelCol = ( n & 0x03 ); +/*N*/ aBools.bRelRow = ( ( n >> 2 ) & 0x03 ); +/*N*/ aBools.bRelTab = ( ( n >> 4 ) & 0x03 ); +/*N*/ aBools.bOldFlag3D = ( ( n >> 6 ) & 0x03 ); +/*N*/ r.OldBoolsToNewFlags( aBools ); +/*N*/ } +/*N*/ else +/*N*/ r.CreateFlagsFromLoadByte( n ); +/*N*/ if( eType == svSingleRef ) +/*N*/ aRef.Ref2 = r; +/*N*/ else +/*N*/ { +/*N*/ SingleRefData& r = aRef.Ref2; +/*N*/ rStream >> r.nCol +/*N*/ >> r.nRow +/*N*/ >> r.nTab +/*N*/ >> n; +/*N*/ if ( nVer < SC_RELATIVE_REFS ) +/*N*/ { +/*N*/ OldSingleRefBools aBools; +/*N*/ aBools.bRelCol = ( n & 0x03 ); +/*N*/ aBools.bRelRow = ( ( n >> 2 ) & 0x03 ); +/*N*/ aBools.bRelTab = ( ( n >> 4 ) & 0x03 ); +/*N*/ aBools.bOldFlag3D = ( ( n >> 6 ) & 0x03 ); +/*N*/ r.OldBoolsToNewFlags( aBools ); +/*N*/ } +/*N*/ else +/*N*/ r.CreateFlagsFromLoadByte( n ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ case svIndex: +/*N*/ rStream >> nIndex; +/*N*/ break; +/*N*/ case svJump: +/*N*/ rStream >> n; +/*N*/ nJump[ 0 ] = n; +/*N*/ for( i = 1; i <= n; i++ ) +/*N*/ rStream >> nJump[ i ]; +/*N*/ break; +/*?*/ case svMissing: +/*?*/ case svErr: +/*?*/ break; +/*?*/ default: +/*?*/ { +/*?*/ rStream >> n; +/*?*/ if( n > MAXSTRLEN-2 ) +/*?*/ { +/*?*/ DBG_ERRORFILE( "bad unknown token type array boundary" ); +/*?*/ USHORT nDiff = n - (MAXSTRLEN-2); +/*?*/ n = MAXSTRLEN-2; +/*?*/ rStream.Read( ((BYTE*)cStr)+1, n ); +/*?*/ rStream.SeekRel( nDiff ); +/*?*/ ++n; +/*?*/ } +/*?*/ else if ( n > 1 ) +/*?*/ rStream.Read( ((BYTE*)cStr)+1, n-1 ); +/*?*/ else if ( n == 0 ) +/*?*/ { +/*?*/ DBG_ERRORFILE( "unknown token type length==0" ); +/*?*/ n = 1; +/*?*/ } +/*?*/ *((BYTE*)cStr) = n; // length including length byte +/*?*/ } +/*N*/ } +/*N*/ } + +/*N*/ void ScToken::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ short i; +/*N*/ rStream << (UINT16) eOp << (BYTE) eType; +/*N*/ switch( eType ) +/*N*/ { +/*N*/ case svByte: +/*N*/ rStream << GetByte(); +/*N*/ break; +/*N*/ case svDouble: +/*N*/ rStream << GetDouble(); +/*N*/ break; +/*N*/ case svExternal: +/*N*/ { +/*N*/ ByteString aTmp( GetExternal(), rStream.GetStreamCharSet() ); +/*N*/ aTmp.Erase( 255 ); // old SO5 can't handle more +/*N*/ rStream << GetByte() +/*N*/ << (UINT8) aTmp.Len(); +/*N*/ rStream.Write( aTmp.GetBuffer(), (UINT8) aTmp.Len() ); +/*N*/ } +/*N*/ break; +/*N*/ case svString: +/*N*/ { +/*N*/ ByteString aTmp( GetString(), rStream.GetStreamCharSet() ); +/*N*/ aTmp.Erase( 255 ); // old SO5 can't handle more +/*N*/ rStream << (UINT8) aTmp.Len(); +/*N*/ rStream.Write( aTmp.GetBuffer(), (UINT8) aTmp.Len() ); +/*N*/ } +/*N*/ break; +/*N*/ case svSingleRef: +/*N*/ { +/*N*/ const SingleRefData& r = GetSingleRef(); +/*N*/ BYTE n = r.CreateStoreByteFromFlags(); +/*N*/ rStream << (INT16) r.nCol +/*N*/ << (INT16) r.nRow +/*N*/ << (INT16) r.nTab +/*N*/ << (BYTE) n; +/*N*/ } +/*N*/ break; +/*N*/ case svDoubleRef: +/*N*/ { +/*N*/ const ComplRefData& rRef = GetDoubleRef(); +/*N*/ const SingleRefData& r1 = rRef.Ref1; +/*N*/ BYTE n = r1.CreateStoreByteFromFlags(); +/*N*/ rStream << (INT16) r1.nCol +/*N*/ << (INT16) r1.nRow +/*N*/ << (INT16) r1.nTab +/*N*/ << (BYTE) n; +/*N*/ const SingleRefData& r2 = rRef.Ref2; +/*N*/ n = r2.CreateStoreByteFromFlags(); +/*N*/ rStream << (INT16) r2.nCol +/*N*/ << (INT16) r2.nRow +/*N*/ << (INT16) r2.nTab +/*N*/ << (BYTE) n; +/*N*/ } +/*N*/ break; +/*N*/ case svIndex: +/*N*/ rStream << (UINT16) GetIndex(); +/*N*/ break; +/*N*/ case svJump: +/*N*/ { +/*N*/ short* pJump = GetJump(); +/*N*/ rStream << (BYTE) pJump[ 0 ]; +/*N*/ for( i = 1; i <= pJump[ 0 ]; i++ ) +/*N*/ rStream << (UINT16) pJump[ i ]; +/*N*/ } +/*N*/ break; +/*?*/ case svMissing: +/*?*/ case svErr: +/*?*/ break; +/*?*/ default: +/*?*/ { +/*?*/ BYTE* pUnknown = GetUnknown(); +/*?*/ if ( pUnknown ) +/*?*/ rStream.Write( pUnknown, pUnknown[ 0 ] ); +/*?*/ } +/*N*/ } +/*N*/ } + +/*----------------------------------------------------------------------*/ + +/*N*/ ScTokenIterator::ScTokenIterator( const ScTokenArray& rArr ) +/*N*/ { +/*N*/ pCur = NULL; +/*N*/ Push( (ScTokenArray*) &rArr ); +/*N*/ } + +/*N*/ ScTokenIterator::~ScTokenIterator() +/*N*/ { +/*N*/ while( pCur ) +/*N*/ Pop(); +/*N*/ } + +/*N*/ void ScTokenIterator::Push( ScTokenArray* pArr ) +/*N*/ { +/*N*/ ImpTokenIterator* p = new ImpTokenIterator; +/*N*/ p->pArr = pArr; +/*N*/ p->nPC = -1; +/*N*/ p->pNext = pCur; +/*N*/ pCur = p; +/*N*/ } + +/*N*/ void ScTokenIterator::Pop() +/*N*/ { +/*N*/ ImpTokenIterator* p = pCur; +/*N*/ if( p ) +/*N*/ { +/*N*/ pCur = p->pNext; +/*N*/ delete p; +/*N*/ } +/*N*/ } + +/*N*/ void ScTokenIterator::Reset() +/*N*/ { +/*N*/ while( pCur->pNext ) +/*?*/ Pop(); +/*N*/ pCur->nPC = -1; +/*N*/ } + +/*N*/ const ScToken* ScTokenIterator::Next() +/*N*/ { +/*N*/ const ScToken* t = NULL; +/*N*/ if( ++pCur->nPC < pCur->pArr->nRPN ) +/*N*/ { +/*N*/ t = pCur->pArr->pRPN[ pCur->nPC ]; +/*N*/ // ein derartiger Opcode endet einen WENN- oder WAHL-Bereich +/*N*/ if( t->GetOpCode() == ocSep || t->GetOpCode() == ocClose ) +/*N*/ t = NULL; +/*N*/ } +/*N*/ if( !t && pCur->pNext ) +/*N*/ { +/*N*/ Pop(); t = Next(); +/*N*/ } +/*N*/ return t; +/*N*/ } + +// Die PC-Werte sind -1! + +/*N*/ void ScTokenIterator::Jump( short nStart, short nNext ) +/*N*/ { +/*N*/ pCur->nPC = nNext; +/*N*/ if( nStart != nNext ) +/*N*/ { +/*N*/ Push( pCur->pArr ); +/*N*/ pCur->nPC = nStart; +/*N*/ } +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_unitconv.cxx b/binfilter/bf_sc/source/core/tool/sc_unitconv.cxx new file mode 100644 index 000000000000..f06952cf4ded --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_unitconv.cxx @@ -0,0 +1,179 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + + +#include "unitconv.hxx" +#include "viewopti.hxx" //! move ScLinkConfigItem to separate header! +namespace binfilter { + +using namespace utl; +using namespace rtl; +using namespace ::com::sun::star::uno; + +// -------------------------------------------------------------------- + +/*N*/ const sal_Unicode cDelim = 0x01; // Delimiter zwischen From und To + + +// --- ScUnitConverterData -------------------------------------------- + +/*N*/ ScUnitConverterData::ScUnitConverterData( const String& rFromUnit, +/*N*/ const String& rToUnit, double fVal ) +/*N*/ : +/*N*/ StrData( rFromUnit ), +/*N*/ fValue( fVal ) +/*N*/ { +/*N*/ String aTmp; +/*N*/ ScUnitConverterData::BuildIndexString( aTmp, rFromUnit, rToUnit ); +/*N*/ SetString( aTmp ); +/*N*/ } + + +/*N*/ ScUnitConverterData::ScUnitConverterData( const ScUnitConverterData& r ) +/*N*/ : +/*N*/ StrData( r ), +/*N*/ fValue( r.fValue ) +/*N*/ { +/*N*/ } + + +/*N*/ DataObject* ScUnitConverterData::Clone() const +/*N*/ { +/*N*/ return new ScUnitConverterData( *this ); +/*N*/ } + + +// static +/*N*/ void ScUnitConverterData::BuildIndexString( String& rStr, +/*N*/ const String& rFromUnit, const String& rToUnit ) +/*N*/ { +/*N*/ #if 1 +/*N*/ // case sensitive +/*N*/ rStr = rFromUnit; +/*N*/ rStr += cDelim; +/*N*/ rStr += rToUnit; +/*N*/ #else +/*N*/ // not case sensitive +/*N*/ rStr = rFromUnit; +/*N*/ String aTo( rToUnit ); +/*N*/ ScGlobal::pCharClass->toUpper( rStr ); +/*N*/ ScGlobal::pCharClass->toUpper( aTo ); +/*N*/ rStr += cDelim; +/*N*/ rStr += aTo; +/*N*/ #endif +/*N*/ } + + +// --- ScUnitConverter ------------------------------------------------ + +/*N*/ #define CFGPATH_UNIT "Office.Calc/UnitConversion" +/*N*/ #define CFGSTR_UNIT_FROM "FromUnit" +/*N*/ #define CFGSTR_UNIT_TO "ToUnit" +/*N*/ #define CFGSTR_UNIT_FACTOR "Factor" + +/*N*/ ScUnitConverter::ScUnitConverter( USHORT nInit, USHORT nDelta ) : +/*N*/ StrCollection( nInit, nDelta, FALSE ) +/*N*/ { +/*N*/ // read from configuration - "convert.ini" is no longer used +/*N*/ //! config item as member to allow change of values +/*N*/ +/*N*/ ScLinkConfigItem aConfigItem( OUString::createFromAscii( CFGPATH_UNIT ) ); +/*N*/ +/*N*/ // empty node name -> use the config item's path itself +/*N*/ OUString aEmptyString; +/*N*/ Sequence<OUString> aNodeNames = aConfigItem.GetNodeNames( aEmptyString ); +/*N*/ +/*N*/ long nNodeCount = aNodeNames.getLength(); +/*N*/ if ( nNodeCount ) +/*N*/ { +/*N*/ const OUString* pNodeArray = aNodeNames.getConstArray(); +/*N*/ Sequence<OUString> aValNames( nNodeCount * 3 ); +/*N*/ OUString* pValNameArray = aValNames.getArray(); +/*N*/ const OUString sSlash('/'); +/*N*/ +/*N*/ long nIndex = 0; +/*N*/ for (long i=0; i<nNodeCount; i++) +/*N*/ { +/*N*/ OUString sPrefix = pNodeArray[i]; +/*N*/ sPrefix += sSlash; +/*N*/ +/*N*/ pValNameArray[nIndex] = sPrefix; +/*N*/ pValNameArray[nIndex++] += OUString::createFromAscii( CFGSTR_UNIT_FROM ); +/*N*/ pValNameArray[nIndex] = sPrefix; +/*N*/ pValNameArray[nIndex++] += OUString::createFromAscii( CFGSTR_UNIT_TO ); +/*N*/ pValNameArray[nIndex] = sPrefix; +/*N*/ pValNameArray[nIndex++] += OUString::createFromAscii( CFGSTR_UNIT_FACTOR ); +/*N*/ } +/*N*/ +/*N*/ Sequence<Any> aProperties = aConfigItem.GetProperties(aValNames); +/*N*/ +/*N*/ if (aProperties.getLength() == aValNames.getLength()) +/*N*/ { +/*N*/ const Any* pProperties = aProperties.getConstArray(); +/*N*/ +/*N*/ OUString sFromUnit; +/*N*/ OUString sToUnit; +/*N*/ double fFactor; +/*N*/ +/*N*/ nIndex = 0; +/*N*/ for (long i=0; i<nNodeCount; i++) +/*N*/ { +/*N*/ pProperties[nIndex++] >>= sFromUnit; +/*N*/ pProperties[nIndex++] >>= sToUnit; +/*N*/ pProperties[nIndex++] >>= fFactor; +/*N*/ +/*N*/ ScUnitConverterData* pNew = new ScUnitConverterData( sFromUnit, sToUnit, fFactor ); +/*N*/ if ( !Insert( pNew ) ) +/*N*/ delete pNew; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScUnitConverter::GetValue( double& fValue, const String& rFromUnit, +/*N*/ const String& rToUnit ) const +/*N*/ { +/*N*/ ScUnitConverterData aSearch( rFromUnit, rToUnit ); +/*N*/ USHORT nIndex; +/*N*/ if ( Search( &aSearch, nIndex ) ) +/*N*/ { +/*N*/ fValue = ((const ScUnitConverterData*)(At( nIndex )))->GetValue(); +/*N*/ return TRUE; +/*N*/ } +/*N*/ fValue = 1.0; +/*N*/ return FALSE; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_userlist.cxx b/binfilter/bf_sc/source/core/tool/sc_userlist.cxx new file mode 100644 index 000000000000..84218b5ebf0c --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_userlist.cxx @@ -0,0 +1,241 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include <unotools/charclass.hxx> +#include <string.h> + +#include "global.hxx" +#include "userlist.hxx" + +#include <unotools/localedatawrapper.hxx> +namespace binfilter { + +// STATIC DATA ----------------------------------------------------------- + + +//------------------------------------------------------------------------ + +/*N*/ void ScUserListData::InitTokens() +/*N*/ { +/*N*/ sal_Unicode cSep = ScGlobal::cListDelimiter; +/*N*/ nTokenCount = (USHORT) aStr.GetTokenCount(cSep); +/*N*/ if (nTokenCount) +/*N*/ { +/*N*/ pSubStrings = new String[nTokenCount]; +/*N*/ pUpperSub = new String[nTokenCount]; +/*N*/ for (USHORT i=0; i<nTokenCount; i++) +/*N*/ { +/*N*/ pUpperSub[i] = pSubStrings[i] = aStr.GetToken((xub_StrLen)i,cSep); +/*N*/ ScGlobal::pCharClass->toUpper(pUpperSub[i]); +/*N*/ } +/*N*/ } +/*N*/ else +/*?*/ pSubStrings = pUpperSub = NULL; +/*N*/ } + +/*N*/ ScUserListData::ScUserListData(const String& rStr) : +/*N*/ aStr(rStr) +/*N*/ { +/*N*/ InitTokens(); +/*N*/ } + +/*N*/ ScUserListData::ScUserListData(const ScUserListData& rData) : +/*N*/ aStr(rData.aStr) +/*N*/ { +/*N*/ InitTokens(); +/*N*/ } + +/*N*/ __EXPORT ScUserListData::~ScUserListData() +/*N*/ { +/*N*/ delete[] pSubStrings; +/*N*/ delete[] pUpperSub; +/*N*/ } + +/*N*/ ScUserListData::ScUserListData( SvStream& rStream ) +/*N*/ { +/*N*/ rStream.ReadByteString( aStr, rStream.GetStreamCharSet() ); +/*N*/ InitTokens(); +/*N*/ } + +/*N*/ BOOL ScUserListData::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ rStream.WriteByteString( aStr, rStream.GetStreamCharSet() ); +/*N*/ return TRUE; +/*N*/ } + + + +/*N*/ BOOL ScUserListData::GetSubIndex(const String& rSubStr, USHORT& rIndex) const +/*N*/ { +/*N*/ USHORT i; +/*N*/ for (i=0; i<nTokenCount; i++) +/*N*/ if (rSubStr == pSubStrings[i]) +/*N*/ { +/*N*/ rIndex = i; +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ String aUpStr = rSubStr; +/*N*/ ScGlobal::pCharClass->toUpper(aUpStr); +/*N*/ for (i=0; i<nTokenCount; i++) +/*N*/ if (aUpStr == pUpperSub[i]) +/*N*/ { +/*N*/ rIndex = i; +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ return FALSE; +/*N*/ } + + + + +/*N*/ ScUserList::ScUserList(USHORT nLim, USHORT nDel) : +/*N*/ Collection ( nLim, nDel ) +/*N*/ { +/*N*/ using namespace ::com::sun::star; +/*N*/ +/*N*/ sal_Unicode cDelimiter = ScGlobal::cListDelimiter; +/*N*/ uno::Sequence< i18n::CalendarItem > xCal; +/*N*/ +/*N*/ uno::Sequence< i18n::Calendar > xCalendars( +/*N*/ ScGlobal::pLocaleData->getAllCalendars() ); +/*N*/ +/*N*/ for ( sal_Int32 j = 0; j < xCalendars.getLength(); ++j ) +/*N*/ { +/*N*/ xCal = xCalendars[j].Days; +/*N*/ if ( xCal.getLength() ) +/*N*/ { +/*N*/ String sDayShort, sDayLong; +/*N*/ sal_Int32 i; +/*N*/ sal_Int32 nCount = xCal.getLength() - 1; +/*N*/ for (i = 0; i < nCount; i++) +/*N*/ { +/*N*/ sDayShort += String( xCal[i].AbbrevName ); +/*N*/ sDayShort += cDelimiter; +/*N*/ sDayLong += String( xCal[i].FullName ); +/*N*/ sDayLong += cDelimiter; +/*N*/ } +/*N*/ sDayShort += String( xCal[i].AbbrevName ); +/*N*/ sDayLong += String( xCal[i].FullName ); +/*N*/ +/*N*/ if ( !HasEntry( sDayShort ) ) +/*N*/ Insert( new ScUserListData( sDayShort )); +/*N*/ if ( !HasEntry( sDayLong ) ) +/*N*/ Insert( new ScUserListData( sDayLong )); +/*N*/ } +/*N*/ +/*N*/ xCal = xCalendars[j].Months; +/*N*/ if ( xCal.getLength() ) +/*N*/ { +/*N*/ String sMonthShort, sMonthLong; +/*N*/ sal_Int32 i; +/*N*/ sal_Int32 nCount = xCal.getLength() - 1; +/*N*/ for (i = 0; i < nCount; i++) +/*N*/ { +/*N*/ sMonthShort += String( xCal[i].AbbrevName ); +/*N*/ sMonthShort += cDelimiter; +/*N*/ sMonthLong += String( xCal[i].FullName ); +/*N*/ sMonthLong += cDelimiter; +/*N*/ } +/*N*/ sMonthShort += String( xCal[i].AbbrevName ); +/*N*/ sMonthLong += String( xCal[i].FullName ); +/*N*/ +/*N*/ if ( !HasEntry( sMonthShort ) ) +/*N*/ Insert( new ScUserListData( sMonthShort )); +/*N*/ if ( !HasEntry( sMonthLong ) ) +/*N*/ Insert( new ScUserListData( sMonthLong )); +/*N*/ } +/*N*/ } +/*N*/ } + +/*N*/ BOOL ScUserList::Load( SvStream& rStream ) +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ USHORT nNewCount; +/*N*/ +/*N*/ while( nCount > 0 ) +/*N*/ AtFree(0); // alles loeschen +/*N*/ +/*N*/ rStream >> nNewCount; +/*N*/ +/*N*/ for ( USHORT i=0; i<nNewCount && bSuccess; i++ ) +/*N*/ Insert( new ScUserListData( rStream ) ); +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ BOOL ScUserList::Store( SvStream& rStream ) const +/*N*/ { +/*N*/ BOOL bSuccess = TRUE; +/*N*/ +/*N*/ rStream << nCount; +/*N*/ +/*N*/ for ( USHORT i=0; i<nCount && bSuccess; i++ ) +/*N*/ bSuccess = ((const ScUserListData*)At(i))->Store( rStream ); +/*N*/ +/*N*/ return bSuccess; +/*N*/ } + +/*N*/ DataObject* ScUserList::Clone() const +/*N*/ { +/*N*/ return ( new ScUserList( *this ) ); +/*N*/ } + +/*N*/ ScUserListData* ScUserList::GetData(const String& rSubStr) const +/*N*/ { +/*N*/ USHORT nIndex; +/*N*/ USHORT i = 0; +/*N*/ for (i=0; i < nCount; i++) +/*N*/ if (((ScUserListData*)pItems[i])->GetSubIndex(rSubStr, nIndex)) +/*?*/ return (ScUserListData*)pItems[i]; +/*N*/ return NULL; +/*N*/ } + + + +/*N*/ BOOL ScUserList::HasEntry( const String& rStr ) const +/*N*/ { +/*N*/ for ( USHORT i=0; i<nCount; i++) +/*N*/ { +/*N*/ const ScUserListData* pMyData = (ScUserListData*) At(i); +/*N*/ if ( pMyData->aStr == rStr ) +/*N*/ return TRUE; +/*N*/ } +/*N*/ return FALSE; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_viewopti.cxx b/binfilter/bf_sc/source/core/tool/sc_viewopti.cxx new file mode 100644 index 000000000000..83d97e80056f --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_viewopti.cxx @@ -0,0 +1,675 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + + + +#include "globstr.hrc" +#include "viewopti.hxx" +#include "rechead.hxx" +#include "bf_sc.hrc" +#include "miscuno.hxx" +namespace binfilter { + +using namespace utl; +using namespace rtl; +using namespace ::com::sun::star::uno; + +//------------------------------------------------------------------ + + +#define SC_VERSION ((USHORT)302) + + +//======================================================================== +// class ScGridOptions +//======================================================================== + + +/*N*/ void ScGridOptions::SetDefaults() +/*N*/ { +/*N*/ *this = ScGridOptions(); +/*N*/ +/*N*/ // Raster-Defaults sind jetzt zwischen den Apps unterschiedlich +/*N*/ // darum hier selber eintragen (alles in 1/100mm) +/*N*/ +/*N*/ if ( ScOptionsUtil::IsMetricSystem() ) +/*N*/ { +/*N*/ nFldDrawX = 1000; // 1cm +/*N*/ nFldDrawY = 1000; +/*N*/ nFldSnapX = 1000; +/*N*/ nFldSnapY = 1000; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ nFldDrawX = 1270; // 0,5" +/*N*/ nFldDrawY = 1270; +/*N*/ nFldSnapX = 1270; +/*N*/ nFldSnapY = 1270; +/*N*/ } +/*N*/ nFldDivisionX = 1; +/*N*/ nFldDivisionY = 1; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ const ScGridOptions& ScGridOptions::operator=( const ScGridOptions& rCpy ) +/*N*/ { +/*N*/ nFldDrawX = rCpy.nFldDrawX; // UINT32 +/*N*/ nFldDrawX = rCpy.nFldDrawX; +/*N*/ nFldDivisionX = rCpy.nFldDivisionX; +/*N*/ nFldDrawY = rCpy.nFldDrawY; +/*N*/ nFldDivisionY = rCpy.nFldDivisionY; +/*N*/ nFldSnapX = rCpy.nFldSnapX; +/*N*/ nFldSnapY = rCpy.nFldSnapY; +/*N*/ bUseGridsnap = rCpy.bUseGridsnap; // BitBool +/*N*/ bSynchronize = rCpy.bSynchronize; +/*N*/ bGridVisible = rCpy.bGridVisible; +/*N*/ bEqualGrid = rCpy.bEqualGrid; +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ int ScGridOptions::operator==( const ScGridOptions& rCpy ) const +/*N*/ { +/*N*/ return ( nFldDrawX == rCpy.nFldDrawX +/*N*/ && nFldDrawX == rCpy.nFldDrawX +/*N*/ && nFldDivisionX == rCpy.nFldDivisionX +/*N*/ && nFldDrawY == rCpy.nFldDrawY +/*N*/ && nFldDivisionY == rCpy.nFldDivisionY +/*N*/ && nFldSnapX == rCpy.nFldSnapX +/*N*/ && nFldSnapY == rCpy.nFldSnapY +/*N*/ && bUseGridsnap == rCpy.bUseGridsnap +/*N*/ && bSynchronize == rCpy.bSynchronize +/*N*/ && bGridVisible == rCpy.bGridVisible +/*N*/ && bEqualGrid == rCpy.bEqualGrid ); +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator>>( SvStream& rStream, ScGridOptions& rOpt ) +/*N*/ { +/*N*/ BYTE nDummy; +/*N*/ rStream >> rOpt.nFldDrawX; +/*N*/ rStream >> rOpt.nFldDrawY; +/*N*/ rStream >> rOpt.nFldDivisionX; +/*N*/ rStream >> rOpt.nFldDivisionY; +/*N*/ rStream >> rOpt.nFldSnapX; +/*N*/ rStream >> rOpt.nFldSnapY; +/*N*/ rStream >> nDummy; rOpt.bUseGridsnap = (BOOL)nDummy; +/*N*/ rStream >> nDummy; rOpt.bSynchronize = (BOOL)nDummy; +/*N*/ rStream >> nDummy; rOpt.bGridVisible = (BOOL)nDummy; +/*N*/ rStream >> nDummy; rOpt.bEqualGrid = (BOOL)nDummy; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator<<( SvStream& rStream, const ScGridOptions& rOpt ) +/*N*/ { +/*N*/ rStream << rOpt.nFldDrawX; +/*N*/ rStream << rOpt.nFldDrawY; +/*N*/ rStream << rOpt.nFldDivisionX; +/*N*/ rStream << rOpt.nFldDivisionY; +/*N*/ rStream << rOpt.nFldSnapX; +/*N*/ rStream << rOpt.nFldSnapY; +/*N*/ rStream << (BOOL)rOpt.bUseGridsnap; +/*N*/ rStream << (BOOL)rOpt.bSynchronize; +/*N*/ rStream << (BOOL)rOpt.bGridVisible; +/*N*/ rStream << (BOOL)rOpt.bEqualGrid; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//======================================================================== +// class ScViewOptions +//======================================================================== + +/*N*/ ScViewOptions::ScViewOptions() +/*N*/ { +/*N*/ SetDefaults(); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ ScViewOptions::ScViewOptions( const ScViewOptions& rCpy ) +/*N*/ { +/*N*/ *this = rCpy; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ __EXPORT ScViewOptions::~ScViewOptions() +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScViewOptions::SetDefaults() +/*N*/ { +/*N*/ aOptArr[ VOPT_FORMULAS ] = +/*N*/ aOptArr[ VOPT_SYNTAX ] = +/*N*/ aOptArr[ VOPT_HELPLINES ] = +/*N*/ aOptArr[ VOPT_BIGHANDLES ] = FALSE; +/*N*/ aOptArr[ VOPT_NOTES ] = +/*N*/ aOptArr[ VOPT_NULLVALS ] = +/*N*/ aOptArr[ VOPT_VSCROLL ] = +/*N*/ aOptArr[ VOPT_HSCROLL ] = +/*N*/ aOptArr[ VOPT_TABCONTROLS ] = +/*N*/ aOptArr[ VOPT_OUTLINER ] = +/*N*/ aOptArr[ VOPT_HEADER ] = +/*N*/ aOptArr[ VOPT_GRID ] = +/*N*/ aOptArr[ VOPT_ANCHOR ] = +/*N*/ aOptArr[ VOPT_PAGEBREAKS ] = +/*N*/ aOptArr[ VOPT_SOLIDHANDLES] = +/*N*/ aOptArr[ VOPT_CLIPMARKS ] = TRUE; +/*N*/ +/*N*/ aModeArr[VOBJ_TYPE_OLE ] = +/*N*/ aModeArr[VOBJ_TYPE_CHART] = +/*N*/ aModeArr[VOBJ_TYPE_DRAW ] = VOBJ_MODE_SHOW; +/*N*/ +/*N*/ aGridCol = Color( SC_STD_GRIDCOLOR ); +/*N*/ aGridColName = ScGlobal::GetRscString( STR_GRIDCOLOR ); +/*N*/ +/*N*/ aGridOpt.SetDefaults(); +/*N*/ +/*N*/ bHideAutoSpell = FALSE; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ Color ScViewOptions::GetGridColor( String* pStrName ) const +/*N*/ { +/*N*/ if ( pStrName ) +/*N*/ *pStrName = aGridColName; +/*N*/ +/*N*/ return aGridCol; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ const ScViewOptions& ScViewOptions::operator=( const ScViewOptions& rCpy ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ for ( i=0; i<MAX_OPT; i++ ) aOptArr [i] = rCpy.aOptArr[i]; +/*N*/ for ( i=0; i<MAX_TYPE; i++ ) aModeArr[i] = rCpy.aModeArr[i]; +/*N*/ +/*N*/ aGridCol = rCpy.aGridCol; +/*N*/ aGridColName = rCpy.aGridColName; +/*N*/ aGridOpt = rCpy.aGridOpt; +/*N*/ bHideAutoSpell = rCpy.bHideAutoSpell; +/*N*/ +/*N*/ return *this; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ int ScViewOptions::operator==( const ScViewOptions& rOpt ) const +/*N*/ { +/*N*/ BOOL bEqual = TRUE; +/*N*/ USHORT i; +/*N*/ +/*N*/ for ( i=0; i<MAX_OPT && bEqual; i++ ) bEqual = (aOptArr [i] == rOpt.aOptArr[i]); +/*N*/ for ( i=0; i<MAX_TYPE && bEqual; i++ ) bEqual = (aModeArr[i] == rOpt.aModeArr[i]); +/*N*/ +/*N*/ bEqual = bEqual && (aGridCol == rOpt.aGridCol); +/*N*/ bEqual = bEqual && (aGridColName == rOpt.aGridColName); +/*N*/ bEqual = bEqual && (aGridOpt == rOpt.aGridOpt); +/*N*/ bEqual = bEqual && (bHideAutoSpell == rOpt.bHideAutoSpell); +/*N*/ +/*N*/ return bEqual; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& operator>>( SvStream& rStream, ScViewOptions& rOpt ) +/*N*/ { +/*N*/ USHORT i; +/*N*/ BYTE n; +/*N*/ +/*N*/ ScReadHeader aHdr( rStream ); +/*N*/ +/*N*/ for ( i=0; i<=VOPT_GRID; i++ ) // kompatibel bleiben -> nur bis VOPT_GRID +/*N*/ rStream >> rOpt.aOptArr[i]; +/*N*/ +/*N*/ for ( i=0; i<MAX_TYPE; i++ ) +/*N*/ rStream >> n, rOpt.aModeArr[i] = (ScVObjMode)n; +/*N*/ +/*N*/ rStream >> rOpt.aGridCol; +/*N*/ rStream.ReadByteString( rOpt.aGridColName, rStream.GetStreamCharSet() ); +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aOptArr[VOPT_HELPLINES]; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aGridOpt; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.bHideAutoSpell; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aOptArr[VOPT_ANCHOR]; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aOptArr[VOPT_PAGEBREAKS]; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aOptArr[VOPT_SOLIDHANDLES]; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aOptArr[VOPT_CLIPMARKS]; +/*N*/ +/*N*/ if( aHdr.BytesLeft() ) +/*N*/ rStream >> rOpt.aOptArr[VOPT_BIGHANDLES]; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ void ScViewOptions::Save(SvStream& rStream, BOOL bConfig) const +/*N*/ { +/*N*/ USHORT i; +/*N*/ +/*N*/ ScWriteHeader aHdr( rStream, 68 ); +/*N*/ +/*N*/ for ( i=0; i<=VOPT_GRID; i++ ) // kompatibel bleiben -> nur bis VOPT_GRID +/*N*/ rStream << aOptArr[i]; +/*N*/ +/*N*/ for ( i=0; i<MAX_TYPE; i++ ) +/*N*/ rStream << (BYTE)aModeArr[i]; +/*N*/ +/*N*/ rStream << aGridCol; +/*N*/ rStream.WriteByteString( aGridColName, rStream.GetStreamCharSet() ); +/*N*/ rStream << aOptArr[VOPT_HELPLINES]; +/*N*/ rStream << aGridOpt; +/*N*/ rStream << bHideAutoSpell; +/*N*/ rStream << aOptArr[VOPT_ANCHOR]; +/*N*/ rStream << aOptArr[VOPT_PAGEBREAKS]; +/*N*/ rStream << aOptArr[VOPT_SOLIDHANDLES]; +/*N*/ +/*N*/ if ( bConfig || rStream.GetVersion() > SOFFICE_FILEFORMAT_40 ) // nicht bei 4.0 Export +/*N*/ { +/*N*/ rStream << aOptArr[VOPT_CLIPMARKS]; +/*N*/ +/*N*/ // big handles are not saved in 5.0-documents to avoid warning messages +/*N*/ //! save to files after 5.0 !!! +/*N*/ +/*N*/ if ( bConfig ) +/*N*/ rStream << aOptArr[VOPT_BIGHANDLES]; +/*N*/ } +/*N*/ } + +//------------------------------------------------------------------------ + + +//======================================================================== +// ScTpViewItem - Daten fuer die ViewOptions-TabPage +//======================================================================== + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//================================================================== +// Config Item containing view options +//================================================================== + +#define CFGPATH_LAYOUT "Office.Calc/Layout" + +#define SCLAYOUTOPT_GRIDLINES 0 +#define SCLAYOUTOPT_GRIDCOLOR 1 +#define SCLAYOUTOPT_PAGEBREAK 2 +#define SCLAYOUTOPT_GUIDE 3 +#define SCLAYOUTOPT_SIMPLECONT 4 +#define SCLAYOUTOPT_LARGECONT 5 +#define SCLAYOUTOPT_COLROWHDR 6 +#define SCLAYOUTOPT_HORISCROLL 7 +#define SCLAYOUTOPT_VERTSCROLL 8 +#define SCLAYOUTOPT_SHEETTAB 9 +#define SCLAYOUTOPT_OUTLINE 10 +#define SCLAYOUTOPT_COUNT 11 + +#define CFGPATH_DISPLAY "Office.Calc/Content/Display" + +#define SCDISPLAYOPT_FORMULA 0 +#define SCDISPLAYOPT_ZEROVALUE 1 +#define SCDISPLAYOPT_NOTETAG 2 +#define SCDISPLAYOPT_VALUEHI 3 +#define SCDISPLAYOPT_ANCHOR 4 +#define SCDISPLAYOPT_TEXTOVER 5 +#define SCDISPLAYOPT_OBJECTGRA 6 +#define SCDISPLAYOPT_CHART 7 +#define SCDISPLAYOPT_DRAWING 8 +#define SCDISPLAYOPT_COUNT 9 + +#define CFGPATH_GRID "Office.Calc/Grid" + +#define SCGRIDOPT_RESOLU_X 0 +#define SCGRIDOPT_RESOLU_Y 1 +#define SCGRIDOPT_SUBDIV_X 2 +#define SCGRIDOPT_SUBDIV_Y 3 +#define SCGRIDOPT_OPTION_X 4 +#define SCGRIDOPT_OPTION_Y 5 +#define SCGRIDOPT_SNAPTOGRID 6 +#define SCGRIDOPT_SYNCHRON 7 +#define SCGRIDOPT_VISIBLE 8 +#define SCGRIDOPT_SIZETOGRID 9 +#define SCGRIDOPT_COUNT 10 + + +/*N*/ Sequence<OUString> ScViewCfg::GetLayoutPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "Line/GridLine", // SCLAYOUTOPT_GRIDLINES +/*N*/ "Line/GridLineColor", // SCLAYOUTOPT_GRIDCOLOR +/*N*/ "Line/PageBreak", // SCLAYOUTOPT_PAGEBREAK +/*N*/ "Line/Guide", // SCLAYOUTOPT_GUIDE +/*N*/ "Line/SimpleControlPoint", // SCLAYOUTOPT_SIMPLECONT +/*N*/ "Line/LargeControlPoint", // SCLAYOUTOPT_LARGECONT +/*N*/ "Window/ColumnRowHeader", // SCLAYOUTOPT_COLROWHDR +/*N*/ "Window/HorizontalScroll", // SCLAYOUTOPT_HORISCROLL +/*N*/ "Window/VerticalScroll", // SCLAYOUTOPT_VERTSCROLL +/*N*/ "Window/SheetTab", // SCLAYOUTOPT_SHEETTAB +/*N*/ "Window/OutlineSymbol" // SCLAYOUTOPT_OUTLINE +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCLAYOUTOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCLAYOUTOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScViewCfg::GetDisplayPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "Formula", // SCDISPLAYOPT_FORMULA +/*N*/ "ZeroValue", // SCDISPLAYOPT_ZEROVALUE +/*N*/ "NoteTag", // SCDISPLAYOPT_NOTETAG +/*N*/ "ValueHighlighting", // SCDISPLAYOPT_VALUEHI +/*N*/ "Anchor", // SCDISPLAYOPT_ANCHOR +/*N*/ "TextOverflow", // SCDISPLAYOPT_TEXTOVER +/*N*/ "ObjectGraphic", // SCDISPLAYOPT_OBJECTGRA +/*N*/ "Chart", // SCDISPLAYOPT_CHART +/*N*/ "DrawingObject" // SCDISPLAYOPT_DRAWING +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCDISPLAYOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCDISPLAYOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ return aNames; +/*N*/ } + +/*N*/ Sequence<OUString> ScViewCfg::GetGridPropertyNames() +/*N*/ { +/*N*/ static const char* aPropNames[] = +/*N*/ { +/*N*/ "Resolution/XAxis/NonMetric", // SCGRIDOPT_RESOLU_X +/*N*/ "Resolution/YAxis/NonMetric", // SCGRIDOPT_RESOLU_Y +/*N*/ "Subdivision/XAxis", // SCGRIDOPT_SUBDIV_X +/*N*/ "Subdivision/YAxis", // SCGRIDOPT_SUBDIV_Y +/*N*/ "Option/XAxis/NonMetric", // SCGRIDOPT_OPTION_X +/*N*/ "Option/YAxis/NonMetric", // SCGRIDOPT_OPTION_Y +/*N*/ "Option/SnapToGrid", // SCGRIDOPT_SNAPTOGRID +/*N*/ "Option/Synchronize", // SCGRIDOPT_SYNCHRON +/*N*/ "Option/VisibleGrid", // SCGRIDOPT_VISIBLE +/*N*/ "Option/SizeToGrid" // SCGRIDOPT_SIZETOGRID +/*N*/ }; +/*N*/ Sequence<OUString> aNames(SCGRIDOPT_COUNT); +/*N*/ OUString* pNames = aNames.getArray(); +/*N*/ for(int i = 0; i < SCGRIDOPT_COUNT; i++) +/*N*/ pNames[i] = OUString::createFromAscii(aPropNames[i]); +/*N*/ +/*N*/ // adjust for metric system +/*N*/ if (ScOptionsUtil::IsMetricSystem()) +/*N*/ { +/*N*/ pNames[SCGRIDOPT_RESOLU_X] = OUString::createFromAscii( "Resolution/XAxis/Metric" ); +/*N*/ pNames[SCGRIDOPT_RESOLU_Y] = OUString::createFromAscii( "Resolution/YAxis/Metric" ); +/*N*/ pNames[SCGRIDOPT_OPTION_X] = OUString::createFromAscii( "Option/XAxis/Metric" ); +/*N*/ pNames[SCGRIDOPT_OPTION_Y] = OUString::createFromAscii( "Option/YAxis/Metric" ); +/*N*/ } +/*N*/ +/*N*/ return aNames; +/*N*/ } + + +/*N*/ ScViewCfg::ScViewCfg() : +/*N*/ aLayoutItem( OUString::createFromAscii( CFGPATH_LAYOUT ) ), +/*N*/ aDisplayItem( OUString::createFromAscii( CFGPATH_DISPLAY ) ), +/*N*/ aGridItem( OUString::createFromAscii( CFGPATH_GRID ) ) +/*N*/ { +/*N*/ sal_Int32 nIntVal; +/*N*/ +/*N*/ Sequence<OUString> aNames = GetLayoutPropertyNames(); +/*N*/ Sequence<Any> aValues = aLayoutItem.GetProperties(aNames); +/*N*/ aLayoutItem.EnableNotification(aNames); +/*N*/ const Any* pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCLAYOUTOPT_GRIDCOLOR: +/*N*/ if ( pValues[nProp] >>= nIntVal ) +/*N*/ SetGridColor( Color(nIntVal), EMPTY_STRING ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_GRIDLINES: +/*N*/ SetOption( VOPT_GRID, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_PAGEBREAK: +/*N*/ SetOption( VOPT_PAGEBREAKS, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_GUIDE: +/*N*/ SetOption( VOPT_HELPLINES, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_SIMPLECONT: +/*N*/ // content is reversed +/*N*/ SetOption( VOPT_SOLIDHANDLES, !ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_LARGECONT: +/*N*/ SetOption( VOPT_BIGHANDLES, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_COLROWHDR: +/*N*/ SetOption( VOPT_HEADER, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_HORISCROLL: +/*N*/ SetOption( VOPT_HSCROLL, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_VERTSCROLL: +/*N*/ SetOption( VOPT_VSCROLL, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_SHEETTAB: +/*N*/ SetOption( VOPT_TABCONTROLS, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCLAYOUTOPT_OUTLINE: +/*N*/ SetOption( VOPT_OUTLINER, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aLayoutItem.SetCommitLink( LINK( this, ScViewCfg, LayoutCommitHdl ) ); +/*N*/ +/*N*/ aNames = GetDisplayPropertyNames(); +/*N*/ aValues = aDisplayItem.GetProperties(aNames); +/*N*/ aDisplayItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCDISPLAYOPT_FORMULA: +/*N*/ SetOption( VOPT_FORMULAS, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_ZEROVALUE: +/*N*/ SetOption( VOPT_NULLVALS, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_NOTETAG: +/*N*/ SetOption( VOPT_NOTES, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_VALUEHI: +/*N*/ SetOption( VOPT_SYNTAX, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_ANCHOR: +/*N*/ SetOption( VOPT_ANCHOR, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_TEXTOVER: +/*N*/ SetOption( VOPT_CLIPMARKS, ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_OBJECTGRA: +/*N*/ if ( pValues[nProp] >>= nIntVal ) +/*N*/ SetObjMode( VOBJ_TYPE_OLE, (ScVObjMode) nIntVal ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_CHART: +/*N*/ if ( pValues[nProp] >>= nIntVal ) +/*N*/ SetObjMode( VOBJ_TYPE_CHART, (ScVObjMode) nIntVal ); +/*N*/ break; +/*N*/ case SCDISPLAYOPT_DRAWING: +/*N*/ if ( pValues[nProp] >>= nIntVal ) +/*N*/ SetObjMode( VOBJ_TYPE_DRAW, (ScVObjMode) nIntVal ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ aDisplayItem.SetCommitLink( LINK( this, ScViewCfg, DisplayCommitHdl ) ); +/*N*/ +/*N*/ ScGridOptions aGrid = GetGridOptions(); //! initialization necessary? +/*N*/ aNames = GetGridPropertyNames(); +/*N*/ aValues = aGridItem.GetProperties(aNames); +/*N*/ aGridItem.EnableNotification(aNames); +/*N*/ pValues = aValues.getConstArray(); +/*N*/ DBG_ASSERT(aValues.getLength() == aNames.getLength(), "GetProperties failed"); +/*N*/ if(aValues.getLength() == aNames.getLength()) +/*N*/ { +/*N*/ for(int nProp = 0; nProp < aNames.getLength(); nProp++) +/*N*/ { +/*N*/ DBG_ASSERT(pValues[nProp].hasValue(), "property value missing"); +/*N*/ if(pValues[nProp].hasValue()) +/*N*/ { +/*N*/ switch(nProp) +/*N*/ { +/*N*/ case SCGRIDOPT_RESOLU_X: +/*N*/ if (pValues[nProp] >>= nIntVal) aGrid.SetFldDrawX( nIntVal ); +/*N*/ break; +/*N*/ case SCGRIDOPT_RESOLU_Y: +/*N*/ if (pValues[nProp] >>= nIntVal) aGrid.SetFldDrawY( nIntVal ); +/*N*/ break; +/*N*/ case SCGRIDOPT_SUBDIV_X: +/*N*/ if (pValues[nProp] >>= nIntVal) aGrid.SetFldDivisionX( nIntVal ); +/*N*/ break; +/*N*/ case SCGRIDOPT_SUBDIV_Y: +/*N*/ if (pValues[nProp] >>= nIntVal) aGrid.SetFldDivisionY( nIntVal ); +/*N*/ break; +/*N*/ case SCGRIDOPT_OPTION_X: +/*N*/ if (pValues[nProp] >>= nIntVal) aGrid.SetFldSnapX( nIntVal ); +/*N*/ break; +/*N*/ case SCGRIDOPT_OPTION_Y: +/*N*/ if (pValues[nProp] >>= nIntVal) aGrid.SetFldSnapY( nIntVal ); +/*N*/ break; +/*N*/ case SCGRIDOPT_SNAPTOGRID: +/*N*/ aGrid.SetUseGridSnap( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCGRIDOPT_SYNCHRON: +/*N*/ aGrid.SetSynchronize( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCGRIDOPT_VISIBLE: +/*N*/ aGrid.SetGridVisible( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ case SCGRIDOPT_SIZETOGRID: +/*N*/ aGrid.SetEqualGrid( ScUnoHelpFunctions::GetBoolFromAny( pValues[nProp] ) ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ SetGridOptions( aGrid ); +/*N*/ aGridItem.SetCommitLink( LINK( this, ScViewCfg, GridCommitHdl ) ); +/*N*/ } + +/*N*/ IMPL_LINK( ScViewCfg, LayoutCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetLayoutPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScViewCfg, DisplayCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 Sequence<OUString> aNames = GetDisplayPropertyNames(); +/*N*/ return 0; +/*N*/ } + +/*N*/ IMPL_LINK( ScViewCfg, GridCommitHdl, void *, EMPTYARG ) +/*N*/ { + DBG_BF_ASSERT(0, "STRIP"); //STRIP001 const ScGridOptions& rGrid = GetGridOptions(); +/*N*/ return 0; +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_sc/source/core/tool/sc_zforauto.cxx b/binfilter/bf_sc/source/core/tool/sc_zforauto.cxx new file mode 100644 index 000000000000..8d9d2cd141bd --- /dev/null +++ b/binfilter/bf_sc/source/core/tool/sc_zforauto.cxx @@ -0,0 +1,86 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +//------------------------------------------------------------------------ + +#include <bf_svtools/zformat.hxx> +#include <vcl/svapp.hxx> +#include <tools/debug.hxx> + +#include "zforauto.hxx" +#include "global.hxx" +namespace binfilter { + +static const sal_Char __FAR_DATA pStandardName[] = "Standard"; + +//------------------------------------------------------------------------ + +/*N*/ ScNumFormatAbbrev::ScNumFormatAbbrev() : +/*N*/ eLnge (LANGUAGE_SYSTEM), +/*N*/ eSysLnge (LANGUAGE_GERMAN), // sonst passt "Standard" nicht +/*N*/ sFormatstring ( RTL_CONSTASCII_USTRINGPARAM( pStandardName ) ) +/*N*/ { +/*N*/ } + +/*N*/ ScNumFormatAbbrev::ScNumFormatAbbrev(const ScNumFormatAbbrev& aFormat) : +/*N*/ eLnge (aFormat.eLnge), +/*N*/ eSysLnge (aFormat.eSysLnge), +/*N*/ sFormatstring (aFormat.sFormatstring) +/*N*/ { +/*N*/ } + +/*N*/ void ScNumFormatAbbrev::Load( SvStream& rStream ) +/*N*/ { +/*N*/ USHORT nSysLang, nLang; +/*N*/ rStream.ReadByteString( sFormatstring, rStream.GetStreamCharSet() ); +/*N*/ rStream >> nSysLang >> nLang; +/*N*/ eLnge = (LanguageType) nLang; +/*N*/ eSysLnge = (LanguageType) nSysLang; +/*N*/ if ( eSysLnge == LANGUAGE_SYSTEM ) // old versions did write it +/*N*/ eSysLnge = Application::GetSettings().GetLanguage(); +/*N*/ } + +/*N*/ void ScNumFormatAbbrev::Save( SvStream& rStream ) const +/*N*/ { +/*N*/ rStream.WriteByteString( sFormatstring, rStream.GetStreamCharSet() ); +/*N*/ rStream << (USHORT) eSysLnge << (USHORT) eLnge; +/*N*/ } + + + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |