/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ #ifndef SC_BCASLOT_HXX #define SC_BCASLOT_HXX #include #include #include #include #include #include "global.hxx" #include "brdcst.hxx" /** Used in a Unique Associative Container. */ class ScBroadcastArea { private: ScBroadcastArea* pUpdateChainNext; SvtBroadcaster aBroadcaster; ScRange aRange; sal_uLong nRefCount; sal_Bool bInUpdateChain; public: ScBroadcastArea( const ScRange& rRange ) : pUpdateChainNext( NULL ), aRange( rRange ), nRefCount( 0 ), bInUpdateChain( sal_False ) {} inline SvtBroadcaster& GetBroadcaster() { return aBroadcaster; } inline const SvtBroadcaster& GetBroadcaster() const { return aBroadcaster; } inline void UpdateRange( const ScRange& rNewRange ) { aRange = rNewRange; } inline const ScRange& GetRange() const { return aRange; } inline const ScAddress& GetStart() const { return aRange.aStart; } inline const ScAddress& GetEnd() const { return aRange.aEnd; } inline void IncRef() { ++nRefCount; } inline sal_uLong DecRef() { return nRefCount ? --nRefCount : 0; } inline sal_uLong GetRef() { return nRefCount; } inline ScBroadcastArea* GetUpdateChainNext() const { return pUpdateChainNext; } inline void SetUpdateChainNext( ScBroadcastArea* p ) { pUpdateChainNext = p; } inline sal_Bool IsInUpdateChain() const { return bInUpdateChain; } inline void SetInUpdateChain( sal_Bool b ) { bInUpdateChain = b; } /** Equalness of this or range. */ inline bool operator==( const ScBroadcastArea & rArea ) const; }; inline bool ScBroadcastArea::operator==( const ScBroadcastArea & rArea ) const { return aRange == rArea.aRange; } //============================================================================= struct ScBroadcastAreaHash { size_t operator()( const ScBroadcastArea* p ) const { return p->GetRange().hashArea(); } }; struct ScBroadcastAreaEqual { bool operator()( const ScBroadcastArea* p1, const ScBroadcastArea* p2) const { return *p1 == *p2; } }; typedef ::std::hash_set< ScBroadcastArea*, ScBroadcastAreaHash, ScBroadcastAreaEqual > ScBroadcastAreas; //============================================================================= struct ScBroadcastAreaBulkHash { size_t operator()( const ScBroadcastArea* p ) const { return reinterpret_cast(p); } }; struct ScBroadcastAreaBulkEqual { bool operator()( const ScBroadcastArea* p1, const ScBroadcastArea* p2) const { return p1 == p2; } }; typedef ::std::hash_set< const ScBroadcastArea*, ScBroadcastAreaBulkHash, ScBroadcastAreaBulkEqual > ScBroadcastAreasBulk; //============================================================================= class ScBroadcastAreaSlotMachine; /// Collection of BroadcastAreas class ScBroadcastAreaSlot { private: ScBroadcastAreas aBroadcastAreaTbl; mutable ScBroadcastArea aTmpSeekBroadcastArea; // for FindBroadcastArea() ScDocument* pDoc; ScBroadcastAreaSlotMachine* pBASM; ScBroadcastAreas::iterator FindBroadcastArea( const ScRange& rRange ) const; /** More hypothetical (memory would probably be doomed anyway) check whether there would be an overflow when adding an area, setting the proper state if so. @return sal_True if a HardRecalcState is effective and area is not to be added. */ bool CheckHardRecalcStateCondition() const; public: ScBroadcastAreaSlot( ScDocument* pDoc, ScBroadcastAreaSlotMachine* pBASM ); ~ScBroadcastAreaSlot(); const ScBroadcastAreas& GetBroadcastAreas() const { return aBroadcastAreaTbl; } /** Only here new ScBroadcastArea objects are created, prevention of dupes. @param rpArea If NULL, a new ScBroadcastArea is created and assigned ton the reference if a matching area wasn't found. If a matching area was found, that is assigned. In any case, the SvtListener is added to the broadcaster. If not NULL then no listeners are startet, only the area is inserted and the reference count incremented. Effectively the same as InsertListeningArea(), so use that instead. @return sal_True if rpArea passed was NULL and ScBroadcastArea is newly created. */ bool StartListeningArea( const ScRange& rRange, SvtListener* pListener, ScBroadcastArea*& rpArea ); /** Insert a ScBroadcastArea obtained via StartListeningArea() to subsequent slots. */ void InsertListeningArea( ScBroadcastArea* pArea ); void EndListeningArea( const ScRange& rRange, SvtListener* pListener, ScBroadcastArea*& rpArea ); sal_Bool AreaBroadcast( const ScHint& rHint ) const; /// @return sal_True if at least one broadcast occurred. sal_Bool AreaBroadcastInRange( const ScRange& rRange, const ScHint& rHint ) const; void DelBroadcastAreasInRange( const ScRange& rRange ); void UpdateRemove( UpdateRefMode eUpdateRefMode, const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz ); void UpdateRemoveArea( ScBroadcastArea* pArea ); void UpdateInsert( ScBroadcastArea* pArea ); }; /** BroadcastAreaSlots and their management, once per document. */ class ScBroadcastAreaSlotMachine { private: /** Slot offset arrangement of columns and rows, once per sheet. +---+---+ | 0 | 3 | +---+---+ | 1 | 4 | +---+---+ | 2 | 5 | +---+---+ */ class TableSlots { public: TableSlots(); ~TableSlots(); inline ScBroadcastAreaSlot** getSlots() { return ppSlots; } /** Obtain slot pointer, no check on validity! It is assumed that all calls are made with the results of ComputeSlotOffset(), ComputeAreaPoints() and ComputeNextSlot() */ inline ScBroadcastAreaSlot* getAreaSlot( SCSIZE nOff ) { return *(ppSlots + nOff); } private: ScBroadcastAreaSlot** ppSlots; // prevent usage TableSlots( const TableSlots& ); TableSlots& operator=( const TableSlots& ); }; typedef ::std::map< SCTAB, TableSlots* > TableSlotsMap; private: ScBroadcastAreasBulk aBulkBroadcastAreas; TableSlotsMap aTableSlotsMap; SvtBroadcaster *pBCAlways; // for the RC_ALWAYS special range ScDocument *pDoc; ScBroadcastArea *pUpdateChain; ScBroadcastArea *pEOUpdateChain; sal_uLong nInBulkBroadcast; inline SCSIZE ComputeSlotOffset( const ScAddress& rAddress ) const; void ComputeAreaPoints( const ScRange& rRange, SCSIZE& nStart, SCSIZE& nEnd, SCSIZE& nRowBreak ) const; public: ScBroadcastAreaSlotMachine( ScDocument* pDoc ); ~ScBroadcastAreaSlotMachine(); void StartListeningArea( const ScRange& rRange, SvtListener* pListener ); void EndListeningArea( const ScRange& rRange, SvtListener* pListener ); sal_Bool AreaBroadcast( const ScHint& rHint ) const; // return: at least one broadcast occurred sal_Bool AreaBroadcastInRange( const ScRange& rRange, const ScHint& rHint ) const; void DelBroadcastAreasInRange( const ScRange& rRange ); void UpdateBroadcastAreas( UpdateRefMode eUpdateRefMode, const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz ); void EnterBulkBroadcast(); void LeaveBulkBroadcast(); bool InsertBulkArea( const ScBroadcastArea* p ); /// @return: how many removed size_t RemoveBulkArea( const ScBroadcastArea* p ); 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; } inline bool IsInBulkBroadcast() const { return nInBulkBroadcast > 0; } }; class ScBulkBroadcast { ScBroadcastAreaSlotMachine* pBASM; public: explicit ScBulkBroadcast( ScBroadcastAreaSlotMachine* p ) : pBASM(p) { if (pBASM) pBASM->EnterBulkBroadcast(); } ~ScBulkBroadcast() { if (pBASM) pBASM->LeaveBulkBroadcast(); } void LeaveBulkBroadcast() { if (pBASM) { pBASM->LeaveBulkBroadcast(); pBASM = NULL; } } }; #endif