| /************************************************************** |
| * |
| * 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 <set> |
| #include <hash_set> |
| #include <functional> |
| #include <svl/broadcast.hxx> |
| #include <svl/svarray.hxx> |
| |
| #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<size_t>(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::const_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 |
