/* -*- 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 * * for a copy of the LGPLv3 License. * ************************************************************************/ #ifndef SC_TABLE_HXX #define SC_TABLE_HXX #include #include #include #include #include #include #include "column.hxx" #include "sortparam.hxx" #include "compressedarray.hxx" #include #include #include namespace utl { class SearchParam; class TextSearch; } namespace com { namespace sun { namespace star { namespace sheet { struct TablePageBreakData; } } } } class SfxItemSet; class SfxStyleSheetBase; class SvxBoxInfoItem; class SvxBoxItem; class SvxSearchItem; class ScAutoFormat; class ScAutoFormatData; class ScBaseCell; class ScDocument; class ScDrawLayer; class ScEditDataArray; class ScFormulaCell; class ScOutlineTable; class ScPostIt; class ScPrintSaverTab; class ScProgress; class ScProgress; class ScRangeList; class ScSheetEvents; class ScSortInfoArray; class ScStyleSheet; class ScTableLink; class ScTableProtection; class ScUserListData; struct RowInfo; struct ScFunctionData; struct ScLineFlags; class CollatorWrapper; class ScFlatUInt16RowSegments; class ScFlatBoolRowSegments; class ScFlatBoolColSegments; struct ScSetStringParam; struct ScColWidthParam; struct ScColWidthParam; typedef std::hash_map< ::rtl::OUString, rtl::OUString, ::rtl::OUStringHash, ::std::equal_to< ::rtl::OUString > > NameToNameMap; class ScTable { private: typedef ::std::vector< ScRange > ScRangeVec; typedef ::std::pair< SCCOL, SCROW > ScAddress2D; typedef ::std::vector< ScAddress2D > ScAddress2DVec; typedef ::std::auto_ptr< ScAddress2DVec > ScAddress2DVecPtr; // Daten pro Tabelle ------------------ ScColumn aCol[MAXCOLCOUNT]; String aName; String aCodeName; String aComment; BOOL bScenario; BOOL bLayoutRTL; BOOL bLoadingRTL; String aLinkDoc; String aLinkFlt; String aLinkOpt; String aLinkTab; ULONG nLinkRefreshDelay; BYTE nLinkMode; // Seitenformatvorlage String aPageStyle; BOOL bPageSizeValid; Size aPageSizeTwips; // Groesse der Druck-Seite SCCOL nRepeatStartX; // Wiederholungszeilen/Spalten SCCOL nRepeatEndX; // REPEAT_NONE, wenn nicht benutzt SCROW nRepeatStartY; SCROW nRepeatEndY; ::std::auto_ptr pTabProtection; USHORT* pColWidth; ::boost::shared_ptr mpRowHeights; BYTE* pColFlags; ScBitMaskCompressedArray< SCROW, BYTE>* pRowFlags; ::boost::shared_ptr mpHiddenCols; ::boost::shared_ptr mpHiddenRows; ::boost::shared_ptr mpFilteredCols; ::boost::shared_ptr mpFilteredRows; ::std::set maRowPageBreaks; ::std::set maRowManualBreaks; ::std::set maColPageBreaks; ::std::set maColManualBreaks; ScOutlineTable* pOutlineTable; ScSheetEvents* pSheetEvents; SCCOL nTableAreaX; SCROW nTableAreaY; BOOL bTableAreaValid; // interne Verwaltung ------------------ BOOL bVisible; BOOL bStreamValid; BOOL bPendingRowHeights; BOOL bCalcNotification; SCTAB nTab; USHORT nRecalcLvl; // Rekursionslevel Size-Recalc ScDocument* pDocument; utl::SearchParam* pSearchParam; utl::TextSearch* pSearchText; mutable String aUpperName; // #i62977# filled only on demand, reset in SetName ScAddress2DVecPtr mxUninitNotes; // SortierParameter um den Stackbedarf von Quicksort zu Minimieren ScSortParam aSortParam; CollatorWrapper* pSortCollator; BOOL bGlobalKeepQuery; BOOL bSharedNameInserted; ScRangeVec aPrintRanges; bool bPrintEntireSheet; ScRange* pRepeatColRange; ScRange* pRepeatRowRange; USHORT nLockCount; ScRangeList* pScenarioRanges; Color aScenarioColor; Color aTabBgColor; USHORT nScenarioFlags; BOOL bActiveScenario; NameToNameMap localNameToGlobalName; bool mbPageBreaksValid; friend class ScDocument; // fuer FillInfo friend class ScDocumentIterator; friend class ScValueIterator; friend class ScDBQueryDataIterator; friend class ScCellIterator; friend class ScQueryCellIterator; friend class ScHorizontalCellIterator; friend class ScHorizontalAttrIterator; friend class ScDocAttrIterator; friend class ScAttrRectIterator; public: ScTable( ScDocument* pDoc, SCTAB nNewTab, const String& rNewName, BOOL bColInfo = TRUE, BOOL bRowInfo = TRUE ); ~ScTable(); ScOutlineTable* GetOutlineTable() { return pOutlineTable; } SCSIZE GetCellCount(SCCOL nCol) const; ULONG GetCellCount() const; ULONG GetWeightedCount() const; ULONG GetCodeCount() const; // RPN-Code in Formeln BOOL SetOutlineTable( const ScOutlineTable* pNewOutline ); void StartOutlineTable(); void DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ); BOOL TestRemoveSubTotals( const ScSubTotalParam& rParam ); void RemoveSubTotals( ScSubTotalParam& rParam ); BOOL DoSubTotals( ScSubTotalParam& rParam ); const ScSheetEvents* GetSheetEvents() const { return pSheetEvents; } void SetSheetEvents( const ScSheetEvents* pNew ); BOOL IsVisible() const { return bVisible; } void SetVisible( BOOL bVis ); BOOL IsStreamValid() const { return bStreamValid; } void SetStreamValid( BOOL bSet, BOOL bIgnoreLock = FALSE ); BOOL IsPendingRowHeights() const { return bPendingRowHeights; } void SetPendingRowHeights( BOOL bSet ); BOOL GetCalcNotification() const { return bCalcNotification; } void SetCalcNotification( BOOL bSet ); BOOL IsLayoutRTL() const { return bLayoutRTL; } BOOL IsLoadingRTL() const { return bLoadingRTL; } void SetLayoutRTL( BOOL bSet ); void SetLoadingRTL( BOOL bSet ); BOOL IsScenario() const { return bScenario; } void SetScenario( BOOL bFlag ); void GetScenarioComment( String& rComment) const { rComment = aComment; } void SetScenarioComment( const String& rComment ) { aComment = rComment; } const Color& GetScenarioColor() const { return aScenarioColor; } void SetScenarioColor(const Color& rNew) { aScenarioColor = rNew; } const Color& GetTabBgColor() const; void SetTabBgColor(const Color& rColor); USHORT GetScenarioFlags() const { return nScenarioFlags; } void SetScenarioFlags(USHORT nNew) { nScenarioFlags = nNew; } void SetActiveScenario(BOOL bSet) { bActiveScenario = bSet; } BOOL IsActiveScenario() const { return bActiveScenario; } BYTE GetLinkMode() const { return nLinkMode; } BOOL IsLinked() const { return nLinkMode != SC_LINK_NONE; } const String& GetLinkDoc() const { return aLinkDoc; } const String& GetLinkFlt() const { return aLinkFlt; } const String& GetLinkOpt() const { return aLinkOpt; } const String& GetLinkTab() const { return aLinkTab; } ULONG GetLinkRefreshDelay() const { return nLinkRefreshDelay; } void SetLink( BYTE nMode, const String& rDoc, const String& rFlt, const String& rOpt, const String& rTab, ULONG nRefreshDelay ); void GetName( String& rName ) const; void SetName( const String& rNewName ); void GetCodeName( String& rName ) const { rName = aCodeName; } void SetCodeName( const String& rNewName ) { aCodeName = rNewName; } const String& GetUpperName() const; const String& GetPageStyle() const { return aPageStyle; } void SetPageStyle( const String& rName ); void PageStyleModified( const String& rNewName ); BOOL IsProtected() const; void SetProtection(const ScTableProtection* pProtect); ScTableProtection* GetProtection(); Size GetPageSize() const; void SetPageSize( const Size& rSize ); void SetRepeatArea( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow ); void RemoveAutoSpellObj(); void LockTable(); void UnlockTable(); BOOL IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, BOOL* pOnlyNotBecauseOfMatrix = NULL ) const; BOOL IsSelectionEditable( const ScMarkData& rMark, BOOL* pOnlyNotBecauseOfMatrix = NULL ) const; BOOL HasBlockMatrixFragment( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const; BOOL HasSelectionMatrixFragment( const ScMarkData& rMark ) const; BOOL IsBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bIgnoreNotes = false ) const; void PutCell( const ScAddress&, ScBaseCell* pCell ); void PutCell( SCCOL nCol, SCROW nRow, ScBaseCell* pCell ); void PutCell(SCCOL nCol, SCROW nRow, ULONG nFormatIndex, ScBaseCell* pCell); // TRUE = Zahlformat gesetzt BOOL SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const String& rString, ScSetStringParam* pParam = NULL ); void SetValue( SCCOL nCol, SCROW nRow, const double& rVal ); void SetError( SCCOL nCol, SCROW nRow, USHORT nError); void GetString( SCCOL nCol, SCROW nRow, String& rString ); void GetInputString( SCCOL nCol, SCROW nRow, String& rString ); double GetValue( const ScAddress& rPos ) const { return ValidColRow(rPos.Col(),rPos.Row()) ? aCol[rPos.Col()].GetValue( rPos.Row() ) : 0.0; } double GetValue( SCCOL nCol, SCROW nRow ); void GetFormula( SCCOL nCol, SCROW nRow, String& rFormula, BOOL bAsciiExport = FALSE ); CellType GetCellType( const ScAddress& rPos ) const { return ValidColRow(rPos.Col(),rPos.Row()) ? aCol[rPos.Col()].GetCellType( rPos.Row() ) : CELLTYPE_NONE; } CellType GetCellType( SCCOL nCol, SCROW nRow ) const; ScBaseCell* GetCell( const ScAddress& rPos ) const { return ValidColRow(rPos.Col(),rPos.Row()) ? aCol[rPos.Col()].GetCell( rPos.Row() ) : NULL; } ScBaseCell* GetCell( SCCOL nCol, SCROW nRow ) const; void GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const; void GetLastDataPos(SCCOL& rCol, SCROW& rRow) const; /** Returns the pointer to a cell note object at the passed cell address. */ ScPostIt* GetNote( SCCOL nCol, SCROW nRow ); /** Sets the passed cell note object at the passed cell address. Takes ownership! */ void TakeNote( SCCOL nCol, SCROW nRow, ScPostIt*& rpNote ); /** Returns and forgets the cell note object at the passed cell address. */ ScPostIt* ReleaseNote( SCCOL nCol, SCROW nRow ); /** Deletes the note at the passed cell address. */ void DeleteNote( SCCOL nCol, SCROW nRow ); /** Creates the captions of all uninitialized cell notes. @param bForced True = always create all captions, false = skip when Undo is disabled. */ void InitializeNoteCaptions( bool bForced = false ); BOOL TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCSIZE nSize ); void InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize ); void DeleteRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize, BOOL* pUndoOutline = NULL ); BOOL TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ); void InsertCol( SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ); void DeleteCol( SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize, BOOL* pUndoOutline = NULL ); void DeleteArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, USHORT nDelFlag); void CopyToClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pTable, BOOL bKeepScenarioFlags, BOOL bCloneNoteCaptions); void CopyToClip(const ScRangeList& rRanges, ScTable* pTable, bool bKeepScenarioFlags, bool bCloneNoteCaptions); void CopyFromClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCsCOL nDx, SCsROW nDy, USHORT nInsFlag, BOOL bAsLink, BOOL bSkipAttrForEmpty, ScTable* pTable); void StartListeningInArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ); void BroadcastInArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ); void CopyToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, USHORT nFlags, BOOL bMarked, ScTable* pDestTab, const ScMarkData* pMarkData = NULL, BOOL bAsLink = FALSE, BOOL bColRowFlags = TRUE); void UndoToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, USHORT nFlags, BOOL bMarked, ScTable* pDestTab, const ScMarkData* pMarkData = NULL); void TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScTable* pTransClip, USHORT nFlags, BOOL bAsLink ); // Markierung von diesem Dokument void MixMarked( const ScMarkData& rMark, USHORT nFunction, BOOL bSkipEmpty, ScTable* pSrcTab ); void MixData( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, USHORT nFunction, BOOL bSkipEmpty, ScTable* pSrcTab ); void CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCCOL nDestCol, SCROW nDestRow, SCTAB nDestTab ); void CopyScenarioFrom( const ScTable* pSrcTab ); void CopyScenarioTo( ScTable* pDestTab ) const; BOOL TestCopyScenarioTo( const ScTable* pDestTab ) const; void MarkScenarioIn( ScMarkData& rMark, USHORT nNeededBits ) const; BOOL HasScenarioRange( const ScRange& rRange ) const; void InvalidateScenarioRanges(); const ScRangeList* GetScenarioRanges() const; void CopyUpdated( const ScTable* pPosTab, ScTable* pDestTab ) const; void InvalidateTableArea(); void InvalidatePageBreaks(); BOOL GetCellArea( SCCOL& rEndCol, SCROW& rEndRow ) const; // FALSE = leer BOOL GetTableArea( SCCOL& rEndCol, SCROW& rEndRow ) const; BOOL GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, BOOL bNotes ) const; BOOL GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow, SCCOL& rEndCol, BOOL bNotes ) const; BOOL GetPrintAreaVer( SCCOL nStartCol, SCCOL nEndCol, SCROW& rEndRow, BOOL bNotes ) const; BOOL GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const; void ExtendPrintArea( OutputDevice* pDev, SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow ); void GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow, BOOL bIncludeOld, bool bOnlyDown ) const; bool ShrinkToUsedDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly ) const; SCSIZE GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScDirection eDir ); void FindAreaPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY ); void GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY, BOOL bMarked, BOOL bUnprotected, const ScMarkData& rMark ); void LimitChartArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ); BOOL HasData( SCCOL nCol, SCROW nRow ); BOOL HasStringData( SCCOL nCol, SCROW nRow ); BOOL HasValueData( SCCOL nCol, SCROW nRow ); BOOL HasStringCells( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const; USHORT GetErrCode( const ScAddress& rPos ) const { return ValidColRow(rPos.Col(),rPos.Row()) ? aCol[rPos.Col()].GetErrCode( rPos.Row() ) : 0; } void ResetChanged( const ScRange& rRange ); void SetDirty(); void SetDirty( const ScRange& ); void SetDirtyAfterLoad(); void SetDirtyVar(); void SetTableOpDirty( const ScRange& ); void CalcAll(); void CalcAfterLoad(); void CompileAll(); void CompileXML( ScProgress& rProgress ); void UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, SCsCOL nDx, SCsROW nDy, SCsTAB nDz, ScDocument* pUndoDoc = NULL, BOOL bIncludeDraw = TRUE, bool bUpdateNoteCaptionPos = true ); void UpdateDrawRef( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, SCsCOL nDx, SCsROW nDy, SCsTAB nDz, bool bUpdateNoteCaptionPos = true ); void UpdateTranspose( const ScRange& rSource, const ScAddress& rDest, ScDocument* pUndoDoc ); void UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY ); void UpdateInsertTab(SCTAB nTable); void UpdateDeleteTab( SCTAB nTable, BOOL bIsMove, ScTable* pRefUndo = NULL ); void UpdateMoveTab(SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo, ScProgress& ); void UpdateCompile( BOOL bForceIfNameInUse = FALSE ); void SetTabNo(SCTAB nNewTab); BOOL IsRangeNameInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, USHORT nIndex) const; void FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, std::set& rIndexes) const; void ReplaceRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScRangeData::IndexMap& rMap ); void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, double nStepValue, double nMaxValue); String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY ); void UpdateSelectionFunction( ScFunctionData& rData, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScMarkData& rMark ); void AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, USHORT nFormatNo ); void GetAutoFormatData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScAutoFormatData& rData); void ScReplaceTabsStr( String& rStr, const String& rSrch, const String& rRepl ); // aus sw BOOL SearchAndReplace(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); void FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2 ); void GetBorderLines( SCCOL nCol, SCROW nRow, const SvxBorderLine** ppLeft, const SvxBorderLine** ppTop, const SvxBorderLine** ppRight, const SvxBorderLine** ppBottom ) const; bool HasAttrib( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, USHORT nMask ) const; BOOL HasAttribSelection( const ScMarkData& rMark, USHORT nMask ) const; BOOL ExtendMerge( SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW& rEndRow, BOOL bRefresh, BOOL bAttrs ); const SfxPoolItem* GetAttr( SCCOL nCol, SCROW nRow, USHORT nWhich ) const; const ScPatternAttr* GetPattern( SCCOL nCol, SCROW nRow ) const; const ScPatternAttr* GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const; ULONG GetNumberFormat( const ScAddress& rPos ) const { return ValidColRow(rPos.Col(),rPos.Row()) ? aCol[rPos.Col()].GetNumberFormat( rPos.Row() ) : 0; } ULONG GetNumberFormat( SCCOL nCol, SCROW nRow ) const; sal_uInt32 GetNumberFormat( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const; void MergeSelectionPattern( ScMergePatternState& rState, const ScMarkData& rMark, BOOL bDeep ) const; void MergePatternArea( ScMergePatternState& rState, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, BOOL bDeep ) const; void MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner, ScLineFlags& rFlags, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const; void ApplyBlockFrame( const SvxBoxItem* pLineOuter, const SvxBoxInfoItem* pLineInner, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ); void ApplyAttr( SCCOL nCol, SCROW nRow, const SfxPoolItem& rAttr ); void ApplyPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr ); void ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScPatternAttr& rAttr, ScEditDataArray* pDataArray = NULL ); bool SetAttrEntries(SCCOL nCol, ScAttrEntry* pData, SCSIZE nSize); void SetPattern( const ScAddress& rPos, const ScPatternAttr& rAttr, BOOL bPutToPool = FALSE ) { if (ValidColRow(rPos.Col(),rPos.Row())) aCol[rPos.Col()].SetPattern( rPos.Row(), rAttr, bPutToPool ); } void SetPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr, BOOL bPutToPool = FALSE ); void ApplyPatternIfNumberformatIncompatible( const ScRange& rRange, const ScPatternAttr& rPattern, short nNewType ); void ApplyStyle( SCCOL nCol, SCROW nRow, const ScStyleSheet& rStyle ); void ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScStyleSheet& rStyle ); void ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark); void ApplySelectionLineStyle( const ScMarkData& rMark, const SvxBorderLine* pLine, BOOL bColorOnly ); const ScStyleSheet* GetStyle( SCCOL nCol, SCROW nRow ) const; const ScStyleSheet* GetSelectionStyle( const ScMarkData& rMark, BOOL& rFound ) const; const ScStyleSheet* GetAreaStyle( BOOL& rFound, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const; void StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, BOOL bRemoved, OutputDevice* pDev, double nPPTX, double nPPTY, const Fraction& rZoomX, const Fraction& rZoomY ); BOOL IsStyleSheetUsed( const ScStyleSheet& rStyle, BOOL bGatherAllStyles ) const; BOOL ApplyFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, INT16 nFlags ); BOOL RemoveFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, INT16 nFlags ); void ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark, ScEditDataArray* pDataArray = NULL ); void DeleteSelection( USHORT nDelFlag, const ScMarkData& rMark ); void ClearSelectionItems( const USHORT* pWhich, const ScMarkData& rMark ); void ChangeSelectionIndent( BOOL bIncrement, const ScMarkData& rMark ); const ScRange* GetRepeatColRange() const { return pRepeatColRange; } const ScRange* GetRepeatRowRange() const { return pRepeatRowRange; } void SetRepeatColRange( const ScRange* pNew ); void SetRepeatRowRange( const ScRange* pNew ); USHORT GetPrintRangeCount() const { return static_cast< USHORT >( aPrintRanges.size() ); } const ScRange* GetPrintRange(USHORT nPos) const; /** Returns true, if the sheet is always printed. */ bool IsPrintEntireSheet() const { return bPrintEntireSheet; } /** Removes all print ranges. */ void ClearPrintRanges(); /** Adds a new print ranges. */ void AddPrintRange( const ScRange& rNew ); /** Marks the specified sheet to be printed completely. Deletes old print ranges! */ void SetPrintEntireSheet(); void FillPrintSaver( ScPrintSaverTab& rSaveTab ) const; void RestorePrintRanges( const ScPrintSaverTab& rSaveTab ); USHORT GetOptimalColWidth( SCCOL nCol, OutputDevice* pDev, double nPPTX, double nPPTY, const Fraction& rZoomX, const Fraction& rZoomY, BOOL bFormula, const ScMarkData* pMarkData, const ScColWidthParam* pParam ); BOOL SetOptimalHeight( SCROW nStartRow, SCROW nEndRow, USHORT nExtra, OutputDevice* pDev, double nPPTX, double nPPTY, const Fraction& rZoomX, const Fraction& rZoomY, BOOL bForce, ScProgress* pOuterProgress = NULL, ULONG nProgressStart = 0 ); void SetOptimalHeightOnly(SCROW nStartRow, SCROW nEndRow, USHORT nExtra, OutputDevice* pDev, double nPPTX, double nPPTY, const Fraction& rZoomX, const Fraction& rZoomY, BOOL bForce, ScProgress* pOuterProgress = NULL, ULONG nProgressStart = 0 ); long GetNeededSize( SCCOL nCol, SCROW nRow, OutputDevice* pDev, double nPPTX, double nPPTY, const Fraction& rZoomX, const Fraction& rZoomY, BOOL bWidth, BOOL bTotalSize ); void SetColWidth( SCCOL nCol, USHORT nNewWidth ); void SetColWidthOnly( SCCOL nCol, USHORT nNewWidth ); void SetRowHeight( SCROW nRow, USHORT nNewHeight ); BOOL SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, USHORT nNewHeight, double nPPTX, double nPPTY ); /** * Set specified row height to specified ranges. Don't check for drawing * objects etc. Just set the row height. Nothing else. * * Note that setting a new row height via this function will not * invalidate page breaks. */ void SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, USHORT nNewHeight ); // nPPT fuer Test auf Veraenderung void SetManualHeight( SCROW nStartRow, SCROW nEndRow, BOOL bManual ); USHORT GetColWidth( SCCOL nCol ) const; SC_DLLPUBLIC USHORT GetRowHeight( SCROW nRow, SCROW* pStartRow = NULL, SCROW* pEndRow = NULL, bool bHiddenAsZero = true ) const; ULONG GetRowHeight( SCROW nStartRow, SCROW nEndRow ) const; ULONG GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale ) const; ULONG GetColOffset( SCCOL nCol ) const; ULONG GetRowOffset( SCROW nRow ) const; /** * Get the last row such that the height of row 0 to the end row is as * high as possible without exceeding the specified height value. * * @param nHeight maximum desired height * * @return SCROW last row of the range within specified height. */ SCROW GetRowForHeight(ULONG nHeight) const; USHORT GetOriginalWidth( SCCOL nCol ) const; USHORT GetOriginalHeight( SCROW nRow ) const; USHORT GetCommonWidth( SCCOL nEndCol ); SCROW GetHiddenRowCount( SCROW nRow ); void ShowCol(SCCOL nCol, bool bShow); void ShowRow(SCROW nRow, bool bShow); void DBShowRow(SCROW nRow, bool bShow); void ShowRows(SCROW nRow1, SCROW nRow2, bool bShow); void DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow); void SetColFlags( SCCOL nCol, BYTE nNewFlags ); void SetRowFlags( SCROW nRow, BYTE nNewFlags ); void SetRowFlags( SCROW nStartRow, SCROW nEndRow, BYTE nNewFlags ); /// @return the index of the last row with any set flags (auto-pagebreak is ignored). SCROW GetLastFlaggedRow() const; /// @return the index of the last changed column (flags and column width, auto pagebreak is ignored). SCCOL GetLastChangedCol() const; /// @return the index of the last changed row (flags and row height, auto pagebreak is ignored). SCROW GetLastChangedRow() const; BYTE GetColFlags( SCCOL nCol ) const; BYTE GetRowFlags( SCROW nRow ) const; const ScBitMaskCompressedArray< SCROW, BYTE> * GetRowFlagsArray() const { return pRowFlags; } BOOL UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, BOOL bShow ); BOOL UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, BOOL bShow ); void UpdatePageBreaks( const ScRange* pUserArea ); void RemoveManualBreaks(); BOOL HasManualBreaks() const; void SetRowManualBreaks( const ::std::set& rBreaks ); void SetColManualBreaks( const ::std::set& rBreaks ); void GetAllRowBreaks(::std::set& rBreaks, bool bPage, bool bManual) const; void GetAllColBreaks(::std::set& rBreaks, bool bPage, bool bManual) const; bool HasRowPageBreak(SCROW nRow) const; bool HasColPageBreak(SCCOL nCol) const; bool HasRowManualBreak(SCROW nRow) const; bool HasColManualBreak(SCCOL nCol) const; /** * Get the row position of the next manual break that occurs at or below * specified row. When no more manual breaks are present at or below * the specified row, -1 is returned. * * @param nRow row at which the search begins. * * @return SCROW next row position with manual page break, or -1 if no * more manual breaks are present. */ SCROW GetNextManualBreak(SCROW nRow) const; void RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow); void RemoveRowBreak(SCROW nRow, bool bPage, bool bManual); void RemoveColBreak(SCCOL nCol, bool bPage, bool bManual); void SetRowBreak(SCROW nRow, bool bPage, bool bManual); void SetColBreak(SCCOL nCol, bool bPage, bool bManual); ::com::sun::star::uno::Sequence< ::com::sun::star::sheet::TablePageBreakData> GetRowBreakData() const; bool RowHidden(SCROW nRow, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL) const; bool RowHidden(SCROW nRow, SCROW& rLastRow) const; bool HasHiddenRows(SCROW nStartRow, SCROW nEndRow) const; bool ColHidden(SCCOL nCol, SCCOL& rLastCol) const; bool ColHidden(SCCOL nCol, SCCOL* pFirstCol = NULL, SCCOL* pLastCol = NULL) const; void SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden); void SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden); void CopyColHidden(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol); void CopyRowHidden(ScTable& rTable, SCROW nStartRow, SCROW nEndRow); void CopyRowHeight(ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset); SCROW FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const; SCROW LastVisibleRow(SCROW nStartRow, SCROW nEndRow) const; SCROW CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const; sal_uInt32 GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow) const; SCCOLROW LastHiddenColRow(SCCOLROW nPos, bool bCol) const; bool RowFiltered(SCROW nRow, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL) const; bool ColFiltered(SCCOL nCol, SCCOL* pFirstCol = NULL, SCCOL* pLastCol = NULL) const; bool HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const; void CopyColFiltered(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol); void CopyRowFiltered(ScTable& rTable, SCROW nStartRow, SCROW nEndRow); void SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered); void SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered); SCROW FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const; SCROW LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const; SCROW CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const; void SyncColRowFlags(); void StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 ); void ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 ); void Sort(const ScSortParam& rSortParam, BOOL bKeepQuery); BOOL ValidQuery(SCROW nRow, const ScQueryParam& rQueryParam, BOOL* pSpecial = NULL, ScBaseCell* pCell = NULL, BOOL* pbTestEqualCondition = NULL ); void TopTenQuery( ScQueryParam& ); SCSIZE Query(ScQueryParam& rQueryParam, BOOL bKeepSub); BOOL CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam); void GetFilterEntries(SCCOL nCol, SCROW nRow1, SCROW nRow2, TypedScStrCollection& rStrings, bool& rHasDates); void GetFilteredFilterEntries( SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScQueryParam& rParam, TypedScStrCollection& rStrings, bool& rHasDates ); BOOL GetDataEntries(SCCOL nCol, SCROW nRow, TypedScStrCollection& rStrings, BOOL bLimit); BOOL HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ); BOOL HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ); void DoColResize( SCCOL nCol1, SCCOL nCol2, SCSIZE nAdd ); sal_Int32 GetMaxStringLen( SCCOL nCol, SCROW nRowStart, SCROW nRowEnd, CharSet eCharSet ) const; xub_StrLen GetMaxNumberStringLen( sal_uInt16& nPrecision, SCCOL nCol, SCROW nRowStart, SCROW nRowEnd ) const; void FindConditionalFormat( ULONG nKey, ScRangeList& rRanges ); void IncRecalcLevel() { ++nRecalcLvl; } void DecRecalcLevel( bool bUpdateNoteCaptionPos = true ) { if (!--nRecalcLvl) SetDrawPageSize(true, bUpdateNoteCaptionPos); } BOOL IsSortCollatorGlobal() const; void InitSortCollator( const ScSortParam& rPar ); void DestroySortCollator(); void SetDrawPageSize( bool bResetStreamValid = true, bool bUpdateNoteCaptionPos = true ); private: void FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, double nStepValue, double nMaxValue, USHORT nMinDigits, BOOL bAttribs, ScProgress& rProgress ); void FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, FillCmd& rCmd, FillDateCmd& rDateCmd, double& rInc, USHORT& rMinDigits, ScUserListData*& rListData, USHORT& rListIndex); void FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ULONG nFillCount, FillDir eFillDir, ScProgress& rProgress ); BOOL ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark, BOOL bMarked, BOOL bUnprotected ); void AutoFormatArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScPatternAttr& rAttr, USHORT nFormatNo); void GetAutoFormatAttr(SCCOL nCol, SCROW nRow, USHORT nIndex, ScAutoFormatData& rData); void GetAutoFormatFrame(SCCOL nCol, SCROW nRow, USHORT nFlags, USHORT nIndex, ScAutoFormatData& rData); BOOL SearchCell(const SvxSearchItem& rSearchItem, SCCOL nCol, SCROW nRow, const ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); BOOL Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); BOOL SearchAll(const SvxSearchItem& rSearchItem, ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); BOOL Replace(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); BOOL ReplaceAll(const SvxSearchItem& rSearchItem, ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); BOOL SearchStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, ScMarkData& rMark); BOOL ReplaceStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, ScMarkData& rMark, BOOL bIsUndo); BOOL SearchAllStyle(const SvxSearchItem& rSearchItem, ScMarkData& rMark); BOOL ReplaceAllStyle(const SvxSearchItem& rSearchItem, ScMarkData& rMark, ScDocument* pUndoDoc); bool SearchAndReplaceEmptyCells( const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); bool SearchRangeForEmptyCell(const ScRange& rRange, const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, String& rUndoStr, ScDocument* pUndoDoc); bool SearchRangeForAllEmptyCells(const ScRange& rRange, const SvxSearchItem& rSearchItem, ScMarkData& rMark, String& rUndoStr, ScDocument* pUndoDoc); // benutzen globalen SortParam: BOOL IsSorted(SCCOLROW nStart, SCCOLROW nEnd); void DecoladeRow( ScSortInfoArray*, SCROW nRow1, SCROW nRow2 ); void SwapCol(SCCOL nCol1, SCCOL nCol2); void SwapRow(SCROW nRow1, SCROW nRow2); short CompareCell( USHORT nSort, ScBaseCell* pCell1, SCCOL nCell1Col, SCROW nCell1Row, ScBaseCell* pCell2, SCCOL nCell2Col, SCROW nCell2Row ); short Compare(SCCOLROW nIndex1, SCCOLROW nIndex2); short Compare( ScSortInfoArray*, SCCOLROW nIndex1, SCCOLROW nIndex2); ScSortInfoArray* CreateSortInfoArray( SCCOLROW nInd1, SCCOLROW nInd2 ); void QuickSort( ScSortInfoArray*, SCsCOLROW nLo, SCsCOLROW nHi); void SortReorder( ScSortInfoArray*, ScProgress& ); BOOL CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam); BOOL CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam); void GetUpperCellString(SCCOL nCol, SCROW nRow, String& rStr); BOOL RefVisible(ScFormulaCell* pCell); BOOL IsEmptyLine(SCROW nRow, SCCOL nStartCol, SCCOL nEndCol); void IncDate(double& rVal, USHORT& nDayOfMonth, double nStep, FillDateCmd eCmd); void FillFormula(ULONG& nFormulaCounter, BOOL bFirst, ScFormulaCell* pSrcCell, SCCOL nDestCol, SCROW nDestRow, BOOL bLast ); void UpdateInsertTabAbs(SCTAB nNewPos); BOOL GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, BOOL bInSel, const ScMarkData& rMark) const; BOOL GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark ); BOOL TestTabRefAbs(SCTAB nTable); void CompileDBFormula(); void CompileDBFormula( BOOL bCreateFormulaString ); void CompileNameFormula( BOOL bCreateFormulaString ); void CompileColRowNameFormula(); void StartListening( const ScAddress& rAddress, SvtListener* pListener ); void EndListening( const ScAddress& rAddress, SvtListener* pListener ); void StartAllListeners(); void StartNeededListeners(); // only for cells where NeedsListening()==TRUE void SetRelNameDirty(); void SetLoadingMedium(bool bLoading); SCSIZE FillMaxRot( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2, SCCOL nCol, SCROW nAttrRow1, SCROW nAttrRow2, SCSIZE nArrY, const ScPatternAttr* pPattern, const SfxItemSet* pCondSet ); // idle calculation of OutputDevice text width for cell // also invalidates script type, broadcasts for "calc as shown" void InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo, BOOL bNumFormatChanged, BOOL bBroadcast ); void SkipFilteredRows(SCROW& rRow, SCROW& rLastNonFilteredRow, bool bForward); /** * In case the cell text goes beyond the column width, move the max column * position to the right. This is called from ExtendPrintArea. */ void MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, double nPPTX, double nPPTY); /** * Use this to iterate through non-empty visible cells in a single column. */ class VisibleDataCellIterator { public: static SCROW ROW_NOT_FOUND; explicit VisibleDataCellIterator(ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn); ~VisibleDataCellIterator(); /** * Set the start row position. In case there is not visible data cell * at the specified row position, it will move to the position of the * first visible data cell below that point. * * @return First visible data cell if found, or NULL otherwise. */ ScBaseCell* reset(SCROW nRow); /** * Find the next visible data cell position. * * @return Next visible data cell if found, or NULL otherwise. */ ScBaseCell* next(); /** * Get the current row position. * * @return Current row position, or ROW_NOT_FOUND if the iterator * doesn't point to a valid data cell position. */ SCROW getRow() const; private: ScFlatBoolRowSegments& mrRowSegs; ScColumn& mrColumn; ScBaseCell* mpCell; SCROW mnCurRow; SCROW mnUBound; }; }; #endif /* vim:set shiftwidth=4 softtabstop=4 expandtab: */