1b3f79822SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3b3f79822SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4b3f79822SAndrew Rist * or more contributor license agreements. See the NOTICE file
5b3f79822SAndrew Rist * distributed with this work for additional information
6b3f79822SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7b3f79822SAndrew Rist * to you under the Apache License, Version 2.0 (the
8b3f79822SAndrew Rist * "License"); you may not use this file except in compliance
9b3f79822SAndrew Rist * with the License. You may obtain a copy of the License at
10b3f79822SAndrew Rist *
11b3f79822SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12b3f79822SAndrew Rist *
13b3f79822SAndrew Rist * Unless required by applicable law or agreed to in writing,
14b3f79822SAndrew Rist * software distributed under the License is distributed on an
15b3f79822SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16b3f79822SAndrew Rist * KIND, either express or implied. See the License for the
17b3f79822SAndrew Rist * specific language governing permissions and limitations
18b3f79822SAndrew Rist * under the License.
19b3f79822SAndrew Rist *
20b3f79822SAndrew Rist *************************************************************/
21b3f79822SAndrew Rist
22b3f79822SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sc.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir // INCLUDE ---------------------------------------------------------------
28cdf0e10cSrcweir
29cdf0e10cSrcweir #include <com/sun/star/script/vba/XVBAEventProcessor.hpp>
30cdf0e10cSrcweir #include "scitems.hxx"
31cdf0e10cSrcweir #include <editeng/langitem.hxx>
32cdf0e10cSrcweir #include <svl/srchitem.hxx>
33cdf0e10cSrcweir #include <sfx2/linkmgr.hxx>
34cdf0e10cSrcweir #include <sfx2/bindings.hxx>
35cdf0e10cSrcweir #include <sfx2/objsh.hxx>
36cdf0e10cSrcweir #include <svl/zforlist.hxx>
37cdf0e10cSrcweir #include <svl/PasswordHelper.hxx>
38cdf0e10cSrcweir #include <vcl/svapp.hxx>
39cdf0e10cSrcweir #include "document.hxx"
40cdf0e10cSrcweir #include "attrib.hxx"
41cdf0e10cSrcweir #include "cell.hxx"
42cdf0e10cSrcweir #include "table.hxx"
43cdf0e10cSrcweir #include "rangenam.hxx"
44cdf0e10cSrcweir #include "dbcolect.hxx"
45cdf0e10cSrcweir #include "pivot.hxx"
46cdf0e10cSrcweir #include "docpool.hxx"
47cdf0e10cSrcweir #include "poolhelp.hxx"
48cdf0e10cSrcweir #include "autoform.hxx"
49cdf0e10cSrcweir #include "rangelst.hxx"
50cdf0e10cSrcweir #include "chartarr.hxx"
51cdf0e10cSrcweir #include "chartlock.hxx"
52cdf0e10cSrcweir #include "refupdat.hxx"
53cdf0e10cSrcweir #include "docoptio.hxx"
54cdf0e10cSrcweir #include "viewopti.hxx"
55cdf0e10cSrcweir #include "scextopt.hxx"
56cdf0e10cSrcweir #include "brdcst.hxx"
57cdf0e10cSrcweir #include "bcaslot.hxx"
58cdf0e10cSrcweir #include "tablink.hxx"
59cdf0e10cSrcweir #include "externalrefmgr.hxx"
60cdf0e10cSrcweir #include "markdata.hxx"
61cdf0e10cSrcweir #include "validat.hxx"
62cdf0e10cSrcweir #include "dociter.hxx"
63cdf0e10cSrcweir #include "detdata.hxx"
64cdf0e10cSrcweir #include "detfunc.hxx"
65cdf0e10cSrcweir #include "scmod.hxx" // SC_MOD
66cdf0e10cSrcweir #include "inputopt.hxx" // GetExpandRefs
67cdf0e10cSrcweir #include "chartlis.hxx"
68cdf0e10cSrcweir #include "sc.hrc" // SID_LINK
69cdf0e10cSrcweir #include "hints.hxx"
70cdf0e10cSrcweir #include "dpobject.hxx"
71cdf0e10cSrcweir #include "unoguard.hxx"
72cdf0e10cSrcweir #include "drwlayer.hxx"
73cdf0e10cSrcweir #include "unoreflist.hxx"
74cdf0e10cSrcweir #include "listenercalls.hxx"
75cdf0e10cSrcweir // Wang Xu Ming -- 2009-8-17
76cdf0e10cSrcweir // DataPilot Migration - Cache&&Performance
77cdf0e10cSrcweir #include "dpshttab.hxx"
78cdf0e10cSrcweir #include "dptablecache.hxx"
79cdf0e10cSrcweir // End Comments
80cdf0e10cSrcweir #include "tabprotection.hxx"
81cdf0e10cSrcweir #include "formulaparserpool.hxx"
82cdf0e10cSrcweir #include "clipparam.hxx"
83cdf0e10cSrcweir #include "sheetevents.hxx"
84cdf0e10cSrcweir
85cdf0e10cSrcweir #include <memory>
86cdf0e10cSrcweir
87cdf0e10cSrcweir using namespace com::sun::star;
88cdf0e10cSrcweir
89cdf0e10cSrcweir //------------------------------------------------------------------------
90cdf0e10cSrcweir
GetRangeName()91cdf0e10cSrcweir ScRangeName* ScDocument::GetRangeName()
92cdf0e10cSrcweir {
93cdf0e10cSrcweir return pRangeName;
94cdf0e10cSrcweir }
95cdf0e10cSrcweir
SetRangeName(ScRangeName * pNewRangeName)96cdf0e10cSrcweir void ScDocument::SetRangeName( ScRangeName* pNewRangeName )
97cdf0e10cSrcweir {
98*5b2f55ddSSteve Yin if (pRangeName == pNewRangeName)
99*5b2f55ddSSteve Yin return;
100*5b2f55ddSSteve Yin
101cdf0e10cSrcweir if (pRangeName)
102cdf0e10cSrcweir delete pRangeName;
103cdf0e10cSrcweir pRangeName = pNewRangeName;
104cdf0e10cSrcweir }
105cdf0e10cSrcweir
106cdf0e10cSrcweir //UNUSED2008-05 ScRangeData* ScDocument::GetRangeAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab,
107cdf0e10cSrcweir //UNUSED2008-05 sal_Bool bStartOnly) const
108cdf0e10cSrcweir //UNUSED2008-05 {
109cdf0e10cSrcweir //UNUSED2008-05 if ( pRangeName )
110cdf0e10cSrcweir //UNUSED2008-05 return pRangeName->GetRangeAtCursor( ScAddress( nCol, nRow, nTab ), bStartOnly );
111cdf0e10cSrcweir //UNUSED2008-05 else
112cdf0e10cSrcweir //UNUSED2008-05 return NULL;
113cdf0e10cSrcweir //UNUSED2008-05 }
114cdf0e10cSrcweir
GetRangeAtBlock(const ScRange & rBlock,String * pName) const115cdf0e10cSrcweir ScRangeData* ScDocument::GetRangeAtBlock( const ScRange& rBlock, String* pName ) const
116cdf0e10cSrcweir {
117cdf0e10cSrcweir ScRangeData* pData = NULL;
118cdf0e10cSrcweir if ( pRangeName )
119cdf0e10cSrcweir {
120cdf0e10cSrcweir pData = pRangeName->GetRangeAtBlock( rBlock );
121cdf0e10cSrcweir if (pData && pName)
122cdf0e10cSrcweir *pName = pData->GetName();
123cdf0e10cSrcweir }
124cdf0e10cSrcweir return pData;
125cdf0e10cSrcweir }
126cdf0e10cSrcweir
GetDBCollection() const127cdf0e10cSrcweir ScDBCollection* ScDocument::GetDBCollection() const
128cdf0e10cSrcweir {
129cdf0e10cSrcweir return pDBCollection;
130cdf0e10cSrcweir }
131cdf0e10cSrcweir
SetDBCollection(ScDBCollection * pNewDBCollection,sal_Bool bRemoveAutoFilter)132cdf0e10cSrcweir void ScDocument::SetDBCollection( ScDBCollection* pNewDBCollection, sal_Bool bRemoveAutoFilter )
133cdf0e10cSrcweir {
134cdf0e10cSrcweir if ( bRemoveAutoFilter )
135cdf0e10cSrcweir {
136cdf0e10cSrcweir // remove auto filter attribute if new db data don't contain auto filter flag
137cdf0e10cSrcweir // start position is also compared, so bRemoveAutoFilter must not be set from ref-undo!
138cdf0e10cSrcweir
139cdf0e10cSrcweir if ( pDBCollection )
140cdf0e10cSrcweir {
141cdf0e10cSrcweir sal_uInt16 nOldCount = pDBCollection->GetCount();
142cdf0e10cSrcweir for (sal_uInt16 nOld=0; nOld<nOldCount; nOld++)
143cdf0e10cSrcweir {
144cdf0e10cSrcweir ScDBData* pOldData = (*pDBCollection)[nOld];
145cdf0e10cSrcweir if ( pOldData->HasAutoFilter() )
146cdf0e10cSrcweir {
147cdf0e10cSrcweir ScRange aOldRange;
148cdf0e10cSrcweir pOldData->GetArea( aOldRange );
149cdf0e10cSrcweir
150cdf0e10cSrcweir sal_Bool bFound = sal_False;
151cdf0e10cSrcweir sal_uInt16 nNewIndex = 0;
152cdf0e10cSrcweir if ( pNewDBCollection &&
153cdf0e10cSrcweir pNewDBCollection->SearchName( pOldData->GetName(), nNewIndex ) )
154cdf0e10cSrcweir {
155cdf0e10cSrcweir ScDBData* pNewData = (*pNewDBCollection)[nNewIndex];
156cdf0e10cSrcweir if ( pNewData->HasAutoFilter() )
157cdf0e10cSrcweir {
158cdf0e10cSrcweir ScRange aNewRange;
159cdf0e10cSrcweir pNewData->GetArea( aNewRange );
160cdf0e10cSrcweir if ( aOldRange.aStart == aNewRange.aStart )
161cdf0e10cSrcweir bFound = sal_True;
162cdf0e10cSrcweir }
163cdf0e10cSrcweir }
164cdf0e10cSrcweir
165cdf0e10cSrcweir if ( !bFound )
166cdf0e10cSrcweir {
167cdf0e10cSrcweir aOldRange.aEnd.SetRow( aOldRange.aStart.Row() );
168cdf0e10cSrcweir RemoveFlagsTab( aOldRange.aStart.Col(), aOldRange.aStart.Row(),
169cdf0e10cSrcweir aOldRange.aEnd.Col(), aOldRange.aEnd.Row(),
170cdf0e10cSrcweir aOldRange.aStart.Tab(), SC_MF_AUTO );
171cdf0e10cSrcweir RepaintRange( aOldRange );
172cdf0e10cSrcweir }
173cdf0e10cSrcweir }
174cdf0e10cSrcweir }
175cdf0e10cSrcweir }
176cdf0e10cSrcweir }
177cdf0e10cSrcweir
178cdf0e10cSrcweir if (pDBCollection)
179cdf0e10cSrcweir delete pDBCollection;
180cdf0e10cSrcweir pDBCollection = pNewDBCollection;
181cdf0e10cSrcweir }
182cdf0e10cSrcweir
GetDBAtCursor(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_Bool bStartOnly) const183cdf0e10cSrcweir ScDBData* ScDocument::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly) const
184cdf0e10cSrcweir {
185cdf0e10cSrcweir if (pDBCollection)
186cdf0e10cSrcweir return pDBCollection->GetDBAtCursor(nCol, nRow, nTab, bStartOnly);
187cdf0e10cSrcweir else
188cdf0e10cSrcweir return NULL;
189cdf0e10cSrcweir }
190cdf0e10cSrcweir
GetDBAtArea(SCTAB nTab,SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2) const191cdf0e10cSrcweir ScDBData* ScDocument::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
192cdf0e10cSrcweir {
193cdf0e10cSrcweir if (pDBCollection)
194cdf0e10cSrcweir return pDBCollection->GetDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2);
195cdf0e10cSrcweir else
196cdf0e10cSrcweir return NULL;
197cdf0e10cSrcweir }
198cdf0e10cSrcweir
GetFilterDBAtTable(SCTAB nTab) const199cdf0e10cSrcweir ScDBData* ScDocument::GetFilterDBAtTable(SCTAB nTab) const
200cdf0e10cSrcweir {
201cdf0e10cSrcweir if (pDBCollection)
202cdf0e10cSrcweir return pDBCollection->GetFilterDBAtTable(nTab);
203cdf0e10cSrcweir else
204cdf0e10cSrcweir return NULL;
205cdf0e10cSrcweir }
206cdf0e10cSrcweir
GetDPCollection()207cdf0e10cSrcweir ScDPCollection* ScDocument::GetDPCollection()
208cdf0e10cSrcweir {
209cdf0e10cSrcweir if (!pDPCollection)
210cdf0e10cSrcweir pDPCollection = new ScDPCollection(this);
211cdf0e10cSrcweir return pDPCollection;
212cdf0e10cSrcweir }
213cdf0e10cSrcweir
GetDPAtCursor(SCCOL nCol,SCROW nRow,SCTAB nTab) const214cdf0e10cSrcweir ScDPObject* ScDocument::GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const
215cdf0e10cSrcweir {
216cdf0e10cSrcweir if (!pDPCollection)
217cdf0e10cSrcweir return NULL;
218cdf0e10cSrcweir
219cdf0e10cSrcweir sal_uInt16 nCount = pDPCollection->GetCount();
220cdf0e10cSrcweir ScAddress aPos( nCol, nRow, nTab );
221cdf0e10cSrcweir for (sal_uInt16 i=0; i<nCount; i++)
222cdf0e10cSrcweir if ( (*pDPCollection)[i]->GetOutRange().In( aPos ) )
223cdf0e10cSrcweir return (*pDPCollection)[i];
224cdf0e10cSrcweir
225cdf0e10cSrcweir return NULL;
226cdf0e10cSrcweir }
227cdf0e10cSrcweir
GetDPAtBlock(const ScRange & rBlock) const228cdf0e10cSrcweir ScDPObject* ScDocument::GetDPAtBlock( const ScRange & rBlock ) const
229cdf0e10cSrcweir {
230cdf0e10cSrcweir if (!pDPCollection)
231cdf0e10cSrcweir return NULL;
232cdf0e10cSrcweir
233cdf0e10cSrcweir /* Walk the collection in reverse order to get something of an
234cdf0e10cSrcweir * approximation of MS Excels 'most recent' effect. */
235cdf0e10cSrcweir sal_uInt16 i = pDPCollection->GetCount();
236cdf0e10cSrcweir while ( i-- > 0 )
237cdf0e10cSrcweir if ( (*pDPCollection)[i]->GetOutRange().In( rBlock ) )
238cdf0e10cSrcweir return (*pDPCollection)[i];
239cdf0e10cSrcweir
240cdf0e10cSrcweir return NULL;
241cdf0e10cSrcweir }
242cdf0e10cSrcweir
GetChartCollection() const243cdf0e10cSrcweir ScChartCollection* ScDocument::GetChartCollection() const
244cdf0e10cSrcweir {
245cdf0e10cSrcweir return pChartCollection;
246cdf0e10cSrcweir }
247cdf0e10cSrcweir
StopTemporaryChartLock()248cdf0e10cSrcweir void ScDocument::StopTemporaryChartLock()
249cdf0e10cSrcweir {
250cdf0e10cSrcweir if( apTemporaryChartLock.get() )
251cdf0e10cSrcweir apTemporaryChartLock->StopLocking();
252cdf0e10cSrcweir }
253cdf0e10cSrcweir
SetChartListenerCollection(ScChartListenerCollection * pNewChartListenerCollection,sal_Bool bSetChartRangeLists)254cdf0e10cSrcweir void ScDocument::SetChartListenerCollection(
255cdf0e10cSrcweir ScChartListenerCollection* pNewChartListenerCollection,
256cdf0e10cSrcweir sal_Bool bSetChartRangeLists )
257cdf0e10cSrcweir {
258cdf0e10cSrcweir ScChartListenerCollection* pOld = pChartListenerCollection;
259cdf0e10cSrcweir pChartListenerCollection = pNewChartListenerCollection;
260cdf0e10cSrcweir if ( pChartListenerCollection )
261cdf0e10cSrcweir {
262cdf0e10cSrcweir if ( pOld )
263cdf0e10cSrcweir pChartListenerCollection->SetDiffDirty( *pOld, bSetChartRangeLists );
264cdf0e10cSrcweir pChartListenerCollection->StartAllListeners();
265cdf0e10cSrcweir }
266cdf0e10cSrcweir delete pOld;
267cdf0e10cSrcweir }
268cdf0e10cSrcweir
SetScenario(SCTAB nTab,sal_Bool bFlag)269cdf0e10cSrcweir void ScDocument::SetScenario( SCTAB nTab, sal_Bool bFlag )
270cdf0e10cSrcweir {
271cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
272cdf0e10cSrcweir pTab[nTab]->SetScenario(bFlag);
273cdf0e10cSrcweir }
274cdf0e10cSrcweir
IsScenario(SCTAB nTab) const275cdf0e10cSrcweir sal_Bool ScDocument::IsScenario( SCTAB nTab ) const
276cdf0e10cSrcweir {
277cdf0e10cSrcweir return ValidTab(nTab) && pTab[nTab] &&pTab[nTab]->IsScenario();
278cdf0e10cSrcweir //if (ValidTab(nTab) && pTab[nTab])
279cdf0e10cSrcweir // return pTab[nTab]->IsScenario();
280cdf0e10cSrcweir
281cdf0e10cSrcweir //return sal_False;
282cdf0e10cSrcweir }
283cdf0e10cSrcweir
SetScenarioData(SCTAB nTab,const String & rComment,const Color & rColor,sal_uInt16 nFlags)284cdf0e10cSrcweir void ScDocument::SetScenarioData( SCTAB nTab, const String& rComment,
285cdf0e10cSrcweir const Color& rColor, sal_uInt16 nFlags )
286cdf0e10cSrcweir {
287cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab] && pTab[nTab]->IsScenario())
288cdf0e10cSrcweir {
289cdf0e10cSrcweir pTab[nTab]->SetScenarioComment( rComment );
290cdf0e10cSrcweir pTab[nTab]->SetScenarioColor( rColor );
291cdf0e10cSrcweir pTab[nTab]->SetScenarioFlags( nFlags );
292cdf0e10cSrcweir }
293cdf0e10cSrcweir }
294cdf0e10cSrcweir
GetTabBgColor(SCTAB nTab) const295cdf0e10cSrcweir Color ScDocument::GetTabBgColor( SCTAB nTab ) const
296cdf0e10cSrcweir {
297cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
298cdf0e10cSrcweir return pTab[nTab]->GetTabBgColor();
299cdf0e10cSrcweir return Color(COL_AUTO);
300cdf0e10cSrcweir }
301cdf0e10cSrcweir
SetTabBgColor(SCTAB nTab,const Color & rColor)302cdf0e10cSrcweir void ScDocument::SetTabBgColor( SCTAB nTab, const Color& rColor )
303cdf0e10cSrcweir {
304cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
305cdf0e10cSrcweir pTab[nTab]->SetTabBgColor(rColor);
306cdf0e10cSrcweir }
307cdf0e10cSrcweir
IsDefaultTabBgColor(SCTAB nTab) const308cdf0e10cSrcweir bool ScDocument::IsDefaultTabBgColor( SCTAB nTab ) const
309cdf0e10cSrcweir {
310cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
311cdf0e10cSrcweir return pTab[nTab]->GetTabBgColor() == COL_AUTO;
312cdf0e10cSrcweir return true;
313cdf0e10cSrcweir }
314cdf0e10cSrcweir
GetScenarioData(SCTAB nTab,String & rComment,Color & rColor,sal_uInt16 & rFlags) const315cdf0e10cSrcweir void ScDocument::GetScenarioData( SCTAB nTab, String& rComment,
316cdf0e10cSrcweir Color& rColor, sal_uInt16& rFlags ) const
317cdf0e10cSrcweir {
318cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab] && pTab[nTab]->IsScenario())
319cdf0e10cSrcweir {
320cdf0e10cSrcweir pTab[nTab]->GetScenarioComment( rComment );
321cdf0e10cSrcweir rColor = pTab[nTab]->GetScenarioColor();
322cdf0e10cSrcweir rFlags = pTab[nTab]->GetScenarioFlags();
323cdf0e10cSrcweir }
324cdf0e10cSrcweir }
325cdf0e10cSrcweir
GetScenarioFlags(SCTAB nTab,sal_uInt16 & rFlags) const326cdf0e10cSrcweir void ScDocument::GetScenarioFlags( SCTAB nTab, sal_uInt16& rFlags ) const
327cdf0e10cSrcweir {
328cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab] && pTab[nTab]->IsScenario())
329cdf0e10cSrcweir rFlags = pTab[nTab]->GetScenarioFlags();
330cdf0e10cSrcweir }
331cdf0e10cSrcweir
IsLinked(SCTAB nTab) const332cdf0e10cSrcweir sal_Bool ScDocument::IsLinked( SCTAB nTab ) const
333cdf0e10cSrcweir {
334cdf0e10cSrcweir return ValidTab(nTab) && pTab[nTab] && pTab[nTab]->IsLinked();
335cdf0e10cSrcweir // euqivalent to
336cdf0e10cSrcweir //if (ValidTab(nTab) && pTab[nTab])
337cdf0e10cSrcweir // return pTab[nTab]->IsLinked();
338cdf0e10cSrcweir //return sal_False;
339cdf0e10cSrcweir }
340cdf0e10cSrcweir
GetAddressConvention() const341cdf0e10cSrcweir formula::FormulaGrammar::AddressConvention ScDocument::GetAddressConvention() const
342cdf0e10cSrcweir {
343cdf0e10cSrcweir return formula::FormulaGrammar::extractRefConvention(eGrammar);
344cdf0e10cSrcweir }
345cdf0e10cSrcweir
GetGrammar() const346cdf0e10cSrcweir formula::FormulaGrammar::Grammar ScDocument::GetGrammar() const
347cdf0e10cSrcweir {
348cdf0e10cSrcweir return eGrammar;
349cdf0e10cSrcweir }
350cdf0e10cSrcweir
SetGrammar(formula::FormulaGrammar::Grammar eGram)351cdf0e10cSrcweir void ScDocument::SetGrammar( formula::FormulaGrammar::Grammar eGram )
352cdf0e10cSrcweir {
353cdf0e10cSrcweir eGrammar = eGram;
354cdf0e10cSrcweir }
355cdf0e10cSrcweir
GetLinkMode(SCTAB nTab) const356cdf0e10cSrcweir sal_Bool ScDocument::GetLinkMode( SCTAB nTab ) const
357cdf0e10cSrcweir {
358cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
359cdf0e10cSrcweir return pTab[nTab]->GetLinkMode();
360cdf0e10cSrcweir return SC_LINK_NONE;
361cdf0e10cSrcweir }
362cdf0e10cSrcweir
GetLinkDoc(SCTAB nTab) const363cdf0e10cSrcweir const String& ScDocument::GetLinkDoc( SCTAB nTab ) const
364cdf0e10cSrcweir {
365cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
366cdf0e10cSrcweir return pTab[nTab]->GetLinkDoc();
367cdf0e10cSrcweir return EMPTY_STRING;
368cdf0e10cSrcweir }
369cdf0e10cSrcweir
GetLinkFlt(SCTAB nTab) const370cdf0e10cSrcweir const String& ScDocument::GetLinkFlt( SCTAB nTab ) const
371cdf0e10cSrcweir {
372cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
373cdf0e10cSrcweir return pTab[nTab]->GetLinkFlt();
374cdf0e10cSrcweir return EMPTY_STRING;
375cdf0e10cSrcweir }
376cdf0e10cSrcweir
GetLinkOpt(SCTAB nTab) const377cdf0e10cSrcweir const String& ScDocument::GetLinkOpt( SCTAB nTab ) const
378cdf0e10cSrcweir {
379cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
380cdf0e10cSrcweir return pTab[nTab]->GetLinkOpt();
381cdf0e10cSrcweir return EMPTY_STRING;
382cdf0e10cSrcweir }
383cdf0e10cSrcweir
GetLinkTab(SCTAB nTab) const384cdf0e10cSrcweir const String& ScDocument::GetLinkTab( SCTAB nTab ) const
385cdf0e10cSrcweir {
386cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
387cdf0e10cSrcweir return pTab[nTab]->GetLinkTab();
388cdf0e10cSrcweir return EMPTY_STRING;
389cdf0e10cSrcweir }
390cdf0e10cSrcweir
GetLinkRefreshDelay(SCTAB nTab) const391cdf0e10cSrcweir sal_uLong ScDocument::GetLinkRefreshDelay( SCTAB nTab ) const
392cdf0e10cSrcweir {
393cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
394cdf0e10cSrcweir return pTab[nTab]->GetLinkRefreshDelay();
395cdf0e10cSrcweir return 0;
396cdf0e10cSrcweir }
397cdf0e10cSrcweir
SetLink(SCTAB nTab,sal_uInt8 nMode,const String & rDoc,const String & rFilter,const String & rOptions,const String & rTabName,sal_uLong nRefreshDelay)398cdf0e10cSrcweir void ScDocument::SetLink( SCTAB nTab, sal_uInt8 nMode, const String& rDoc,
399cdf0e10cSrcweir const String& rFilter, const String& rOptions,
400cdf0e10cSrcweir const String& rTabName, sal_uLong nRefreshDelay )
401cdf0e10cSrcweir {
402cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
403cdf0e10cSrcweir pTab[nTab]->SetLink( nMode, rDoc, rFilter, rOptions, rTabName, nRefreshDelay );
404cdf0e10cSrcweir }
405cdf0e10cSrcweir
HasLink(const String & rDoc,const String & rFilter,const String & rOptions) const406cdf0e10cSrcweir sal_Bool ScDocument::HasLink( const String& rDoc,
407cdf0e10cSrcweir const String& rFilter, const String& rOptions ) const
408cdf0e10cSrcweir {
409cdf0e10cSrcweir SCTAB nCount = GetTableCount();
410cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
411cdf0e10cSrcweir if (pTab[i]->IsLinked()
412cdf0e10cSrcweir && pTab[i]->GetLinkDoc() == rDoc
413cdf0e10cSrcweir && pTab[i]->GetLinkFlt() == rFilter
414cdf0e10cSrcweir && pTab[i]->GetLinkOpt() == rOptions)
415cdf0e10cSrcweir return sal_True;
416cdf0e10cSrcweir
417cdf0e10cSrcweir return sal_False;
418cdf0e10cSrcweir }
419cdf0e10cSrcweir
LinkExternalTab(SCTAB & rTab,const String & aDocTab,const String & aFileName,const String & aTabName)420cdf0e10cSrcweir sal_Bool ScDocument::LinkExternalTab( SCTAB& rTab, const String& aDocTab,
421cdf0e10cSrcweir const String& aFileName, const String& aTabName )
422cdf0e10cSrcweir {
423cdf0e10cSrcweir if ( IsClipboard() )
424cdf0e10cSrcweir {
425cdf0e10cSrcweir DBG_ERRORFILE( "LinkExternalTab in Clipboard" );
426cdf0e10cSrcweir return sal_False;
427cdf0e10cSrcweir }
428cdf0e10cSrcweir rTab = 0;
429cdf0e10cSrcweir String aFilterName; // wird vom Loader gefuellt
430cdf0e10cSrcweir String aOptions; // Filter-Optionen
431cdf0e10cSrcweir sal_uInt32 nLinkCnt = pExtDocOptions ? pExtDocOptions->GetDocSettings().mnLinkCnt : 0;
432cdf0e10cSrcweir ScDocumentLoader aLoader( aFileName, aFilterName, aOptions, nLinkCnt + 1 );
433cdf0e10cSrcweir if ( aLoader.IsError() )
434cdf0e10cSrcweir return sal_False;
435cdf0e10cSrcweir ScDocument* pSrcDoc = aLoader.GetDocument();
436cdf0e10cSrcweir
437cdf0e10cSrcweir // Tabelle kopieren
438cdf0e10cSrcweir SCTAB nSrcTab;
439cdf0e10cSrcweir if ( pSrcDoc->GetTable( aTabName, nSrcTab ) )
440cdf0e10cSrcweir {
441cdf0e10cSrcweir if ( !InsertTab( SC_TAB_APPEND, aDocTab, sal_True ) )
442cdf0e10cSrcweir {
443cdf0e10cSrcweir DBG_ERRORFILE("can't insert external document table");
444cdf0e10cSrcweir return sal_False;
445cdf0e10cSrcweir }
446cdf0e10cSrcweir rTab = GetTableCount() - 1;
447cdf0e10cSrcweir // nicht neu einfuegen, nur Ergebnisse
448cdf0e10cSrcweir TransferTab( pSrcDoc, nSrcTab, rTab, sal_False, sal_True );
449cdf0e10cSrcweir }
450cdf0e10cSrcweir else
451cdf0e10cSrcweir return sal_False;
452cdf0e10cSrcweir
453cdf0e10cSrcweir sal_uLong nRefreshDelay = 0;
454cdf0e10cSrcweir
455cdf0e10cSrcweir sal_Bool bWasThere = HasLink( aFileName, aFilterName, aOptions );
456cdf0e10cSrcweir SetLink( rTab, SC_LINK_VALUE, aFileName, aFilterName, aOptions, aTabName, nRefreshDelay );
457cdf0e10cSrcweir if ( !bWasThere ) // Link pro Quelldokument nur einmal eintragen
458cdf0e10cSrcweir {
459cdf0e10cSrcweir ScTableLink* pLink = new ScTableLink( pShell, aFileName, aFilterName, aOptions, nRefreshDelay );
460cdf0e10cSrcweir pLink->SetInCreate( sal_True );
461cdf0e10cSrcweir GetLinkManager()->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aFileName,
462cdf0e10cSrcweir &aFilterName );
463cdf0e10cSrcweir pLink->Update();
464cdf0e10cSrcweir pLink->SetInCreate( sal_False );
465cdf0e10cSrcweir SfxBindings* pBindings = GetViewBindings();
466cdf0e10cSrcweir if (pBindings)
467cdf0e10cSrcweir pBindings->Invalidate( SID_LINKS );
468cdf0e10cSrcweir }
469cdf0e10cSrcweir return sal_True;
470cdf0e10cSrcweir }
471cdf0e10cSrcweir
GetExternalRefManager() const472cdf0e10cSrcweir ScExternalRefManager* ScDocument::GetExternalRefManager() const
473cdf0e10cSrcweir {
474cdf0e10cSrcweir ScDocument* pThis = const_cast<ScDocument*>(this);
475cdf0e10cSrcweir if (!pExternalRefMgr.get())
476cdf0e10cSrcweir pThis->pExternalRefMgr.reset( new ScExternalRefManager( pThis));
477cdf0e10cSrcweir
478cdf0e10cSrcweir return pExternalRefMgr.get();
479cdf0e10cSrcweir }
480cdf0e10cSrcweir
IsInExternalReferenceMarking() const481cdf0e10cSrcweir bool ScDocument::IsInExternalReferenceMarking() const
482cdf0e10cSrcweir {
483cdf0e10cSrcweir return pExternalRefMgr.get() && pExternalRefMgr->isInReferenceMarking();
484cdf0e10cSrcweir }
485cdf0e10cSrcweir
MarkUsedExternalReferences()486cdf0e10cSrcweir void ScDocument::MarkUsedExternalReferences()
487cdf0e10cSrcweir {
488cdf0e10cSrcweir if (!pExternalRefMgr.get())
489cdf0e10cSrcweir return;
490cdf0e10cSrcweir if (!pExternalRefMgr->hasExternalData())
491cdf0e10cSrcweir return;
492cdf0e10cSrcweir // Charts.
493cdf0e10cSrcweir bool bAllMarked = pExternalRefMgr->markUsedByLinkListeners();
494cdf0e10cSrcweir // Formula cells.
495cdf0e10cSrcweir bAllMarked = pExternalRefMgr->markUsedExternalRefCells();
496cdf0e10cSrcweir
497cdf0e10cSrcweir /* NOTE: Conditional formats and validation objects are marked when
498cdf0e10cSrcweir * collecting them during export. */
499cdf0e10cSrcweir }
500cdf0e10cSrcweir
GetFormulaParserPool() const501cdf0e10cSrcweir ScFormulaParserPool& ScDocument::GetFormulaParserPool() const
502cdf0e10cSrcweir {
503cdf0e10cSrcweir if( !mxFormulaParserPool.get() )
504cdf0e10cSrcweir mxFormulaParserPool.reset( new ScFormulaParserPool( *this ) );
505cdf0e10cSrcweir return *mxFormulaParserPool;
506cdf0e10cSrcweir }
507cdf0e10cSrcweir
GetSheetEvents(SCTAB nTab) const508cdf0e10cSrcweir const ScSheetEvents* ScDocument::GetSheetEvents( SCTAB nTab ) const
509cdf0e10cSrcweir {
510cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab])
511cdf0e10cSrcweir return pTab[nTab]->GetSheetEvents();
512cdf0e10cSrcweir return NULL;
513cdf0e10cSrcweir }
514cdf0e10cSrcweir
SetSheetEvents(SCTAB nTab,const ScSheetEvents * pNew)515cdf0e10cSrcweir void ScDocument::SetSheetEvents( SCTAB nTab, const ScSheetEvents* pNew )
516cdf0e10cSrcweir {
517cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab])
518cdf0e10cSrcweir pTab[nTab]->SetSheetEvents( pNew );
519cdf0e10cSrcweir }
520cdf0e10cSrcweir
HasSheetEventScript(SCTAB nTab,sal_Int32 nEvent,bool bWithVbaEvents) const521cdf0e10cSrcweir bool ScDocument::HasSheetEventScript( SCTAB nTab, sal_Int32 nEvent, bool bWithVbaEvents ) const
522cdf0e10cSrcweir {
523cdf0e10cSrcweir if (pTab[nTab])
524cdf0e10cSrcweir {
525cdf0e10cSrcweir // check if any event handler script has been configured
526cdf0e10cSrcweir const ScSheetEvents* pEvents = pTab[nTab]->GetSheetEvents();
527cdf0e10cSrcweir if ( pEvents && pEvents->GetScript( nEvent ) )
528cdf0e10cSrcweir return true;
529cdf0e10cSrcweir // check if VBA event handlers exist
530cdf0e10cSrcweir if (bWithVbaEvents && mxVbaEvents.is()) try
531cdf0e10cSrcweir {
532cdf0e10cSrcweir uno::Sequence< uno::Any > aArgs( 1 );
533cdf0e10cSrcweir aArgs[ 0 ] <<= nTab;
534cdf0e10cSrcweir if (mxVbaEvents->hasVbaEventHandler( ScSheetEvents::GetVbaSheetEventId( nEvent ), aArgs ) ||
535cdf0e10cSrcweir mxVbaEvents->hasVbaEventHandler( ScSheetEvents::GetVbaDocumentEventId( nEvent ), uno::Sequence< uno::Any >() ))
536cdf0e10cSrcweir return true;
537cdf0e10cSrcweir }
538cdf0e10cSrcweir catch( uno::Exception& )
539cdf0e10cSrcweir {
540cdf0e10cSrcweir }
541cdf0e10cSrcweir }
542cdf0e10cSrcweir return false;
543cdf0e10cSrcweir }
544cdf0e10cSrcweir
HasAnySheetEventScript(sal_Int32 nEvent,bool bWithVbaEvents) const545cdf0e10cSrcweir bool ScDocument::HasAnySheetEventScript( sal_Int32 nEvent, bool bWithVbaEvents ) const
546cdf0e10cSrcweir {
547cdf0e10cSrcweir for (SCTAB nTab = 0; nTab <= MAXTAB; nTab++)
548cdf0e10cSrcweir if (HasSheetEventScript( nTab, nEvent, bWithVbaEvents ))
549cdf0e10cSrcweir return true;
550cdf0e10cSrcweir return false;
551cdf0e10cSrcweir }
552cdf0e10cSrcweir
HasAnyCalcNotification() const553cdf0e10cSrcweir bool ScDocument::HasAnyCalcNotification() const
554cdf0e10cSrcweir {
555cdf0e10cSrcweir for (SCTAB nTab = 0; nTab <= MAXTAB; nTab++)
556cdf0e10cSrcweir if (pTab[nTab] && pTab[nTab]->GetCalcNotification())
557cdf0e10cSrcweir return true;
558cdf0e10cSrcweir return false;
559cdf0e10cSrcweir }
560cdf0e10cSrcweir
HasCalcNotification(SCTAB nTab) const561cdf0e10cSrcweir sal_Bool ScDocument::HasCalcNotification( SCTAB nTab ) const
562cdf0e10cSrcweir {
563cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab])
564cdf0e10cSrcweir return pTab[nTab]->GetCalcNotification();
565cdf0e10cSrcweir return sal_False;
566cdf0e10cSrcweir }
567cdf0e10cSrcweir
SetCalcNotification(SCTAB nTab)568cdf0e10cSrcweir void ScDocument::SetCalcNotification( SCTAB nTab )
569cdf0e10cSrcweir {
570cdf0e10cSrcweir // set only if not set before
571cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab] && !pTab[nTab]->GetCalcNotification())
572cdf0e10cSrcweir pTab[nTab]->SetCalcNotification(sal_True);
573cdf0e10cSrcweir }
574cdf0e10cSrcweir
ResetCalcNotifications()575cdf0e10cSrcweir void ScDocument::ResetCalcNotifications()
576cdf0e10cSrcweir {
577cdf0e10cSrcweir for (SCTAB nTab = 0; nTab <= MAXTAB; nTab++)
578cdf0e10cSrcweir if (pTab[nTab] && pTab[nTab]->GetCalcNotification())
579cdf0e10cSrcweir pTab[nTab]->SetCalcNotification(sal_False);
580cdf0e10cSrcweir }
581cdf0e10cSrcweir
GetOutlineTable(SCTAB nTab,sal_Bool bCreate)582cdf0e10cSrcweir ScOutlineTable* ScDocument::GetOutlineTable( SCTAB nTab, sal_Bool bCreate )
583cdf0e10cSrcweir {
584cdf0e10cSrcweir ScOutlineTable* pVal = NULL;
585cdf0e10cSrcweir
586cdf0e10cSrcweir if (VALIDTAB(nTab))
587cdf0e10cSrcweir if (pTab[nTab])
588cdf0e10cSrcweir {
589cdf0e10cSrcweir pVal = pTab[nTab]->GetOutlineTable();
590cdf0e10cSrcweir if (!pVal)
591cdf0e10cSrcweir if (bCreate)
592cdf0e10cSrcweir {
593cdf0e10cSrcweir pTab[nTab]->StartOutlineTable();
594cdf0e10cSrcweir pVal = pTab[nTab]->GetOutlineTable();
595cdf0e10cSrcweir }
596cdf0e10cSrcweir }
597cdf0e10cSrcweir
598cdf0e10cSrcweir return pVal;
599cdf0e10cSrcweir }
600cdf0e10cSrcweir
SetOutlineTable(SCTAB nTab,const ScOutlineTable * pNewOutline)601cdf0e10cSrcweir sal_Bool ScDocument::SetOutlineTable( SCTAB nTab, const ScOutlineTable* pNewOutline )
602cdf0e10cSrcweir {
603cdf0e10cSrcweir return VALIDTAB(nTab) && pTab[nTab] && pTab[nTab]->SetOutlineTable(pNewOutline);
604cdf0e10cSrcweir //if (VALIDTAB(nTab))
605cdf0e10cSrcweir // if (pTab[nTab])
606cdf0e10cSrcweir // return pTab[nTab]->SetOutlineTable(pNewOutline);
607cdf0e10cSrcweir
608cdf0e10cSrcweir //return sal_False;
609cdf0e10cSrcweir }
610cdf0e10cSrcweir
DoAutoOutline(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab)611cdf0e10cSrcweir void ScDocument::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow,
612cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
613cdf0e10cSrcweir {
614cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab])
615cdf0e10cSrcweir pTab[nTab]->DoAutoOutline( nStartCol, nStartRow, nEndCol, nEndRow );
616cdf0e10cSrcweir }
617cdf0e10cSrcweir
TestRemoveSubTotals(SCTAB nTab,const ScSubTotalParam & rParam)618cdf0e10cSrcweir sal_Bool ScDocument::TestRemoveSubTotals( SCTAB nTab, const ScSubTotalParam& rParam )
619cdf0e10cSrcweir {
620cdf0e10cSrcweir return VALIDTAB(nTab) && pTab[nTab] && pTab[nTab]->TestRemoveSubTotals( rParam );
621cdf0e10cSrcweir //if (VALIDTAB(nTab) && pTab[nTab] )
622cdf0e10cSrcweir // return pTab[nTab]->TestRemoveSubTotals( rParam );
623cdf0e10cSrcweir
624cdf0e10cSrcweir //return sal_False;
625cdf0e10cSrcweir }
626cdf0e10cSrcweir
RemoveSubTotals(SCTAB nTab,ScSubTotalParam & rParam)627cdf0e10cSrcweir void ScDocument::RemoveSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
628cdf0e10cSrcweir {
629cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
630cdf0e10cSrcweir pTab[nTab]->RemoveSubTotals( rParam );
631cdf0e10cSrcweir }
632cdf0e10cSrcweir
DoSubTotals(SCTAB nTab,ScSubTotalParam & rParam)633cdf0e10cSrcweir sal_Bool ScDocument::DoSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
634cdf0e10cSrcweir {
635cdf0e10cSrcweir return VALIDTAB(nTab) && pTab[nTab] && pTab[nTab]->DoSubTotals( rParam );
636cdf0e10cSrcweir //if (VALIDTAB(nTab))
637cdf0e10cSrcweir // if (pTab[nTab])
638cdf0e10cSrcweir // return pTab[nTab]->DoSubTotals( rParam );
639cdf0e10cSrcweir
640cdf0e10cSrcweir //return sal_False;
641cdf0e10cSrcweir }
642cdf0e10cSrcweir
HasSubTotalCells(const ScRange & rRange)643cdf0e10cSrcweir sal_Bool ScDocument::HasSubTotalCells( const ScRange& rRange )
644cdf0e10cSrcweir {
645cdf0e10cSrcweir ScCellIterator aIter( this, rRange );
646cdf0e10cSrcweir ScBaseCell* pCell = aIter.GetFirst();
647cdf0e10cSrcweir while (pCell)
648cdf0e10cSrcweir {
649cdf0e10cSrcweir if ( pCell->GetCellType() == CELLTYPE_FORMULA && ((ScFormulaCell*)pCell)->IsSubTotal() )
650cdf0e10cSrcweir return sal_True;
651cdf0e10cSrcweir
652cdf0e10cSrcweir pCell = aIter.GetNext();
653cdf0e10cSrcweir }
654cdf0e10cSrcweir return sal_False; // none found
655cdf0e10cSrcweir }
656cdf0e10cSrcweir
657cdf0e10cSrcweir // kopiert aus diesem Dokument die Zellen von Positionen, an denen in pPosDoc
658cdf0e10cSrcweir // auch Zellen stehen, nach pDestDoc
659cdf0e10cSrcweir
CopyUpdated(ScDocument * pPosDoc,ScDocument * pDestDoc)660cdf0e10cSrcweir void ScDocument::CopyUpdated( ScDocument* pPosDoc, ScDocument* pDestDoc )
661cdf0e10cSrcweir {
662cdf0e10cSrcweir SCTAB nCount = GetTableCount();
663cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nCount; nTab++)
664cdf0e10cSrcweir if (pTab[nTab] && pPosDoc->pTab[nTab] && pDestDoc->pTab[nTab])
665cdf0e10cSrcweir pTab[nTab]->CopyUpdated( pPosDoc->pTab[nTab], pDestDoc->pTab[nTab] );
666cdf0e10cSrcweir }
667cdf0e10cSrcweir
CopyScenario(SCTAB nSrcTab,SCTAB nDestTab,sal_Bool bNewScenario)668cdf0e10cSrcweir void ScDocument::CopyScenario( SCTAB nSrcTab, SCTAB nDestTab, sal_Bool bNewScenario )
669cdf0e10cSrcweir {
670cdf0e10cSrcweir if (ValidTab(nSrcTab) && ValidTab(nDestTab) && pTab[nSrcTab] && pTab[nDestTab])
671cdf0e10cSrcweir {
672cdf0e10cSrcweir // Flags fuer aktive Szenarios richtig setzen
673cdf0e10cSrcweir // und aktuelle Werte in bisher aktive Szenarios zurueckschreiben
674cdf0e10cSrcweir
675cdf0e10cSrcweir ScRangeList aRanges = *pTab[nSrcTab]->GetScenarioRanges();
676cdf0e10cSrcweir const sal_uLong nRangeCount = aRanges.Count();
677cdf0e10cSrcweir
678cdf0e10cSrcweir // nDestTab ist die Zieltabelle
679cdf0e10cSrcweir for ( SCTAB nTab = nDestTab+1;
680cdf0e10cSrcweir nTab<=MAXTAB && pTab[nTab] && pTab[nTab]->IsScenario();
681cdf0e10cSrcweir nTab++ )
682cdf0e10cSrcweir {
683cdf0e10cSrcweir if ( pTab[nTab]->IsActiveScenario() ) // auch wenn's dasselbe Szenario ist
684cdf0e10cSrcweir {
685cdf0e10cSrcweir sal_Bool bTouched = sal_False;
686cdf0e10cSrcweir for ( sal_uLong nR=0; nR<nRangeCount && !bTouched; nR++)
687cdf0e10cSrcweir {
688cdf0e10cSrcweir const ScRange* pRange = aRanges.GetObject(nR);
689cdf0e10cSrcweir if ( pTab[nTab]->HasScenarioRange( *pRange ) )
690cdf0e10cSrcweir bTouched = sal_True;
691cdf0e10cSrcweir }
692cdf0e10cSrcweir if (bTouched)
693cdf0e10cSrcweir {
694cdf0e10cSrcweir pTab[nTab]->SetActiveScenario(sal_False);
695cdf0e10cSrcweir if ( pTab[nTab]->GetScenarioFlags() & SC_SCENARIO_TWOWAY )
696cdf0e10cSrcweir pTab[nTab]->CopyScenarioFrom( pTab[nDestTab] );
697cdf0e10cSrcweir }
698cdf0e10cSrcweir }
699cdf0e10cSrcweir }
700cdf0e10cSrcweir
701cdf0e10cSrcweir pTab[nSrcTab]->SetActiveScenario(sal_True); // da kommt's her...
702cdf0e10cSrcweir if (!bNewScenario) // Daten aus dem ausgewaehlten Szenario kopieren
703cdf0e10cSrcweir {
704cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
705cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
706cdf0e10cSrcweir pTab[nSrcTab]->CopyScenarioTo( pTab[nDestTab] );
707cdf0e10cSrcweir SetDirty();
708cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
709cdf0e10cSrcweir }
710cdf0e10cSrcweir }
711cdf0e10cSrcweir }
712cdf0e10cSrcweir
MarkScenario(SCTAB nSrcTab,SCTAB nDestTab,ScMarkData & rDestMark,sal_Bool bResetMark,sal_uInt16 nNeededBits) const713cdf0e10cSrcweir void ScDocument::MarkScenario( SCTAB nSrcTab, SCTAB nDestTab, ScMarkData& rDestMark,
714cdf0e10cSrcweir sal_Bool bResetMark, sal_uInt16 nNeededBits ) const
715cdf0e10cSrcweir {
716cdf0e10cSrcweir if (bResetMark)
717cdf0e10cSrcweir rDestMark.ResetMark();
718cdf0e10cSrcweir
719cdf0e10cSrcweir if (ValidTab(nSrcTab) && pTab[nSrcTab])
720cdf0e10cSrcweir pTab[nSrcTab]->MarkScenarioIn( rDestMark, nNeededBits );
721cdf0e10cSrcweir
722cdf0e10cSrcweir rDestMark.SetAreaTab( nDestTab );
723cdf0e10cSrcweir }
724cdf0e10cSrcweir
HasScenarioRange(SCTAB nTab,const ScRange & rRange) const725cdf0e10cSrcweir sal_Bool ScDocument::HasScenarioRange( SCTAB nTab, const ScRange& rRange ) const
726cdf0e10cSrcweir {
727cdf0e10cSrcweir return ValidTab(nTab) && pTab[nTab] && pTab[nTab]->HasScenarioRange( rRange );
728cdf0e10cSrcweir //if (ValidTab(nTab) && pTab[nTab])
729cdf0e10cSrcweir // return pTab[nTab]->HasScenarioRange( rRange );
730cdf0e10cSrcweir
731cdf0e10cSrcweir //return sal_False;
732cdf0e10cSrcweir }
733cdf0e10cSrcweir
GetScenarioRanges(SCTAB nTab) const734cdf0e10cSrcweir const ScRangeList* ScDocument::GetScenarioRanges( SCTAB nTab ) const
735cdf0e10cSrcweir {
736cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
737cdf0e10cSrcweir return pTab[nTab]->GetScenarioRanges();
738cdf0e10cSrcweir
739cdf0e10cSrcweir return NULL;
740cdf0e10cSrcweir }
741cdf0e10cSrcweir
IsActiveScenario(SCTAB nTab) const742cdf0e10cSrcweir sal_Bool ScDocument::IsActiveScenario( SCTAB nTab ) const
743cdf0e10cSrcweir {
744cdf0e10cSrcweir return ValidTab(nTab) && pTab[nTab] && pTab[nTab]->IsActiveScenario( );
745cdf0e10cSrcweir //if (ValidTab(nTab) && pTab[nTab])
746cdf0e10cSrcweir // return pTab[nTab]->IsActiveScenario();
747cdf0e10cSrcweir
748cdf0e10cSrcweir //return sal_False;
749cdf0e10cSrcweir }
750cdf0e10cSrcweir
SetActiveScenario(SCTAB nTab,sal_Bool bActive)751cdf0e10cSrcweir void ScDocument::SetActiveScenario( SCTAB nTab, sal_Bool bActive )
752cdf0e10cSrcweir {
753cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
754cdf0e10cSrcweir pTab[nTab]->SetActiveScenario( bActive );
755cdf0e10cSrcweir }
756cdf0e10cSrcweir
TestCopyScenario(SCTAB nSrcTab,SCTAB nDestTab) const757cdf0e10cSrcweir sal_Bool ScDocument::TestCopyScenario( SCTAB nSrcTab, SCTAB nDestTab ) const
758cdf0e10cSrcweir {
759cdf0e10cSrcweir if (ValidTab(nSrcTab) && ValidTab(nDestTab))
760cdf0e10cSrcweir return pTab[nSrcTab]->TestCopyScenarioTo( pTab[nDestTab] );
761cdf0e10cSrcweir
762cdf0e10cSrcweir DBG_ERROR("falsche Tabelle bei TestCopyScenario");
763cdf0e10cSrcweir return sal_False;
764cdf0e10cSrcweir }
765cdf0e10cSrcweir
AddUnoObject(SfxListener & rObject)766cdf0e10cSrcweir void ScDocument::AddUnoObject( SfxListener& rObject )
767cdf0e10cSrcweir {
768cdf0e10cSrcweir if (!pUnoBroadcaster)
769cdf0e10cSrcweir pUnoBroadcaster = new SfxBroadcaster;
770cdf0e10cSrcweir
771cdf0e10cSrcweir rObject.StartListening( *pUnoBroadcaster );
772cdf0e10cSrcweir }
773cdf0e10cSrcweir
RemoveUnoObject(SfxListener & rObject)774cdf0e10cSrcweir void ScDocument::RemoveUnoObject( SfxListener& rObject )
775cdf0e10cSrcweir {
776cdf0e10cSrcweir if (pUnoBroadcaster)
777cdf0e10cSrcweir {
778cdf0e10cSrcweir rObject.EndListening( *pUnoBroadcaster );
779cdf0e10cSrcweir
780cdf0e10cSrcweir if ( bInUnoBroadcast )
781cdf0e10cSrcweir {
782cdf0e10cSrcweir // #107294# Broadcasts from ScDocument::BroadcastUno are the only way that
783cdf0e10cSrcweir // uno object methods are called without holding a reference.
784cdf0e10cSrcweir //
785cdf0e10cSrcweir // If RemoveUnoObject is called from an object dtor in the finalizer thread
786cdf0e10cSrcweir // while the main thread is calling BroadcastUno, the dtor thread must wait
787cdf0e10cSrcweir // (or the object's Notify might try to access a deleted object).
788cdf0e10cSrcweir // The SolarMutex can't be locked here because if a component is called from
789cdf0e10cSrcweir // a VCL event, the main thread has the SolarMutex locked all the time.
790cdf0e10cSrcweir //
791cdf0e10cSrcweir // This check is done after calling EndListening, so a later BroadcastUno call
792cdf0e10cSrcweir // won't touch this object.
793cdf0e10cSrcweir
794cdf0e10cSrcweir vos::IMutex& rSolarMutex = Application::GetSolarMutex();
795cdf0e10cSrcweir if ( rSolarMutex.tryToAcquire() )
796cdf0e10cSrcweir {
797cdf0e10cSrcweir // BroadcastUno is always called with the SolarMutex locked, so if it
798cdf0e10cSrcweir // can be acquired, this is within the same thread (should not happen)
799cdf0e10cSrcweir DBG_ERRORFILE( "RemoveUnoObject called from BroadcastUno" );
800cdf0e10cSrcweir rSolarMutex.release();
801cdf0e10cSrcweir }
802cdf0e10cSrcweir else
803cdf0e10cSrcweir {
804cdf0e10cSrcweir // let the thread that called BroadcastUno continue
805cdf0e10cSrcweir while ( bInUnoBroadcast )
806cdf0e10cSrcweir {
807cdf0e10cSrcweir vos::OThread::yield();
808cdf0e10cSrcweir }
809cdf0e10cSrcweir }
810cdf0e10cSrcweir }
811cdf0e10cSrcweir }
812cdf0e10cSrcweir else
813cdf0e10cSrcweir {
814cdf0e10cSrcweir DBG_ERROR("No Uno broadcaster");
815cdf0e10cSrcweir }
816cdf0e10cSrcweir }
817cdf0e10cSrcweir
BroadcastUno(const SfxHint & rHint)818cdf0e10cSrcweir void ScDocument::BroadcastUno( const SfxHint &rHint )
819cdf0e10cSrcweir {
820cdf0e10cSrcweir if (pUnoBroadcaster)
821cdf0e10cSrcweir {
822cdf0e10cSrcweir bInUnoBroadcast = sal_True;
823cdf0e10cSrcweir pUnoBroadcaster->Broadcast( rHint );
824cdf0e10cSrcweir bInUnoBroadcast = sal_False;
825cdf0e10cSrcweir
826cdf0e10cSrcweir // During Broadcast notification, Uno objects can add to pUnoListenerCalls.
827cdf0e10cSrcweir // The listener calls must be processed after completing the broadcast,
828cdf0e10cSrcweir // because they can add or remove objects from pUnoBroadcaster.
829cdf0e10cSrcweir
830cdf0e10cSrcweir if ( pUnoListenerCalls && rHint.ISA( SfxSimpleHint ) &&
831cdf0e10cSrcweir ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DATACHANGED &&
832cdf0e10cSrcweir !bInUnoListenerCall )
833cdf0e10cSrcweir {
834cdf0e10cSrcweir // Listener calls may lead to BroadcastUno calls again. The listener calls
835cdf0e10cSrcweir // are not nested, instead the calls are collected in the list, and the
836cdf0e10cSrcweir // outermost call executes them all.
837cdf0e10cSrcweir
838cdf0e10cSrcweir ScChartLockGuard aChartLockGuard(this);
839cdf0e10cSrcweir bInUnoListenerCall = sal_True;
840cdf0e10cSrcweir pUnoListenerCalls->ExecuteAndClear();
841cdf0e10cSrcweir bInUnoListenerCall = sal_False;
842cdf0e10cSrcweir }
843cdf0e10cSrcweir }
844cdf0e10cSrcweir }
845cdf0e10cSrcweir
AddUnoListenerCall(const uno::Reference<util::XModifyListener> & rListener,const lang::EventObject & rEvent)846cdf0e10cSrcweir void ScDocument::AddUnoListenerCall( const uno::Reference<util::XModifyListener>& rListener,
847cdf0e10cSrcweir const lang::EventObject& rEvent )
848cdf0e10cSrcweir {
849cdf0e10cSrcweir DBG_ASSERT( bInUnoBroadcast, "AddUnoListenerCall is supposed to be called from BroadcastUno only" );
850cdf0e10cSrcweir
851cdf0e10cSrcweir if ( !pUnoListenerCalls )
852cdf0e10cSrcweir pUnoListenerCalls = new ScUnoListenerCalls;
853cdf0e10cSrcweir pUnoListenerCalls->Add( rListener, rEvent );
854cdf0e10cSrcweir }
855cdf0e10cSrcweir
BeginUnoRefUndo()856cdf0e10cSrcweir void ScDocument::BeginUnoRefUndo()
857cdf0e10cSrcweir {
858cdf0e10cSrcweir DBG_ASSERT( !pUnoRefUndoList, "BeginUnoRefUndo twice" );
859cdf0e10cSrcweir delete pUnoRefUndoList;
860cdf0e10cSrcweir
861cdf0e10cSrcweir pUnoRefUndoList = new ScUnoRefList;
862cdf0e10cSrcweir }
863cdf0e10cSrcweir
EndUnoRefUndo()864cdf0e10cSrcweir ScUnoRefList* ScDocument::EndUnoRefUndo()
865cdf0e10cSrcweir {
866cdf0e10cSrcweir ScUnoRefList* pRet = pUnoRefUndoList;
867cdf0e10cSrcweir pUnoRefUndoList = NULL;
868cdf0e10cSrcweir return pRet; // must be deleted by caller!
869cdf0e10cSrcweir }
870cdf0e10cSrcweir
AddUnoRefChange(sal_Int64 nId,const ScRangeList & rOldRanges)871cdf0e10cSrcweir void ScDocument::AddUnoRefChange( sal_Int64 nId, const ScRangeList& rOldRanges )
872cdf0e10cSrcweir {
873cdf0e10cSrcweir if ( pUnoRefUndoList )
874cdf0e10cSrcweir pUnoRefUndoList->Add( nId, rOldRanges );
875cdf0e10cSrcweir }
876cdf0e10cSrcweir
GetNewUnoId()877cdf0e10cSrcweir sal_Int64 ScDocument::GetNewUnoId()
878cdf0e10cSrcweir {
879cdf0e10cSrcweir return ++nUnoObjectId;
880cdf0e10cSrcweir }
881cdf0e10cSrcweir
UpdateReference(UpdateRefMode eUpdateRefMode,SCCOL nCol1,SCROW nRow1,SCTAB nTab1,SCCOL nCol2,SCROW nRow2,SCTAB nTab2,SCsCOL nDx,SCsROW nDy,SCsTAB nDz,ScDocument * pUndoDoc,sal_Bool bIncludeDraw,bool bUpdateNoteCaptionPos)882cdf0e10cSrcweir void ScDocument::UpdateReference( UpdateRefMode eUpdateRefMode,
883cdf0e10cSrcweir SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
884cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
885cdf0e10cSrcweir SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
886cdf0e10cSrcweir ScDocument* pUndoDoc, sal_Bool bIncludeDraw,
887cdf0e10cSrcweir bool bUpdateNoteCaptionPos )
888cdf0e10cSrcweir {
889cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
890cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
891cdf0e10cSrcweir PutInOrder( nTab1, nTab2 );
892cdf0e10cSrcweir if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
893cdf0e10cSrcweir {
894cdf0e10cSrcweir sal_Bool bExpandRefsOld = IsExpandRefs();
895cdf0e10cSrcweir if ( eUpdateRefMode == URM_INSDEL && (nDx > 0 || nDy > 0 || nDz > 0) )
896cdf0e10cSrcweir SetExpandRefs( SC_MOD()->GetInputOptions().GetExpandRefs() );
897cdf0e10cSrcweir SCTAB i;
898cdf0e10cSrcweir SCTAB iMax;
899cdf0e10cSrcweir if ( eUpdateRefMode == URM_COPY )
900cdf0e10cSrcweir {
901cdf0e10cSrcweir i = nTab1;
902cdf0e10cSrcweir iMax = nTab2;
903cdf0e10cSrcweir }
904cdf0e10cSrcweir else
905cdf0e10cSrcweir {
906cdf0e10cSrcweir ScRange aRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
907cdf0e10cSrcweir xColNameRanges->UpdateReference( eUpdateRefMode, this, aRange, nDx, nDy, nDz );
908cdf0e10cSrcweir xRowNameRanges->UpdateReference( eUpdateRefMode, this, aRange, nDx, nDy, nDz );
909cdf0e10cSrcweir pDBCollection->UpdateReference( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz );
910cdf0e10cSrcweir pRangeName->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
911cdf0e10cSrcweir if ( pDPCollection )
912cdf0e10cSrcweir pDPCollection->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
913cdf0e10cSrcweir UpdateChartRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz );
914cdf0e10cSrcweir UpdateRefAreaLinks( eUpdateRefMode, aRange, nDx, nDy, nDz );
915cdf0e10cSrcweir if ( pCondFormList )
916cdf0e10cSrcweir pCondFormList->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
917cdf0e10cSrcweir if ( pValidationList )
918cdf0e10cSrcweir pValidationList->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
919cdf0e10cSrcweir if ( pDetOpList )
920cdf0e10cSrcweir pDetOpList->UpdateReference( this, eUpdateRefMode, aRange, nDx, nDy, nDz );
921cdf0e10cSrcweir if ( pUnoBroadcaster )
922cdf0e10cSrcweir pUnoBroadcaster->Broadcast( ScUpdateRefHint(
923cdf0e10cSrcweir eUpdateRefMode, aRange, nDx, nDy, nDz ) );
924cdf0e10cSrcweir i = 0;
925cdf0e10cSrcweir iMax = MAXTAB;
926cdf0e10cSrcweir }
927cdf0e10cSrcweir for ( ; i<=iMax; i++)
928cdf0e10cSrcweir if (pTab[i])
929cdf0e10cSrcweir pTab[i]->UpdateReference(
930cdf0e10cSrcweir eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2,
931cdf0e10cSrcweir nDx, nDy, nDz, pUndoDoc, bIncludeDraw, bUpdateNoteCaptionPos );
932cdf0e10cSrcweir
933cdf0e10cSrcweir if ( bIsEmbedded )
934cdf0e10cSrcweir {
935cdf0e10cSrcweir SCCOL theCol1;
936cdf0e10cSrcweir SCROW theRow1;
937cdf0e10cSrcweir SCTAB theTab1;
938cdf0e10cSrcweir SCCOL theCol2;
939cdf0e10cSrcweir SCROW theRow2;
940cdf0e10cSrcweir SCTAB theTab2;
941cdf0e10cSrcweir theCol1 = aEmbedRange.aStart.Col();
942cdf0e10cSrcweir theRow1 = aEmbedRange.aStart.Row();
943cdf0e10cSrcweir theTab1 = aEmbedRange.aStart.Tab();
944cdf0e10cSrcweir theCol2 = aEmbedRange.aEnd.Col();
945cdf0e10cSrcweir theRow2 = aEmbedRange.aEnd.Row();
946cdf0e10cSrcweir theTab2 = aEmbedRange.aEnd.Tab();
947cdf0e10cSrcweir if ( ScRefUpdate::Update( this, eUpdateRefMode, nCol1,nRow1,nTab1, nCol2,nRow2,nTab2,
948cdf0e10cSrcweir nDx,nDy,nDz, theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) )
949cdf0e10cSrcweir {
950cdf0e10cSrcweir aEmbedRange = ScRange( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 );
951cdf0e10cSrcweir }
952cdf0e10cSrcweir }
953cdf0e10cSrcweir SetExpandRefs( bExpandRefsOld );
954cdf0e10cSrcweir
955cdf0e10cSrcweir // #30428# after moving, no clipboard move ref-updates are possible
956cdf0e10cSrcweir if ( eUpdateRefMode != URM_COPY && IsClipboardSource() )
957cdf0e10cSrcweir {
958cdf0e10cSrcweir ScDocument* pClipDoc = SC_MOD()->GetClipDoc();
959cdf0e10cSrcweir if (pClipDoc)
960cdf0e10cSrcweir pClipDoc->GetClipParam().mbCutMode = false;
961cdf0e10cSrcweir }
962cdf0e10cSrcweir }
963cdf0e10cSrcweir }
964cdf0e10cSrcweir
UpdateTranspose(const ScAddress & rDestPos,ScDocument * pClipDoc,const ScMarkData & rMark,ScDocument * pUndoDoc)965cdf0e10cSrcweir void ScDocument::UpdateTranspose( const ScAddress& rDestPos, ScDocument* pClipDoc,
966cdf0e10cSrcweir const ScMarkData& rMark, ScDocument* pUndoDoc )
967cdf0e10cSrcweir {
968cdf0e10cSrcweir DBG_ASSERT(pClipDoc->bIsClip, "UpdateTranspose: kein Clip");
969cdf0e10cSrcweir
970cdf0e10cSrcweir ScRange aSource;
971cdf0e10cSrcweir ScClipParam& rClipParam = GetClipParam();
972cdf0e10cSrcweir if (rClipParam.maRanges.Count())
973cdf0e10cSrcweir aSource = *rClipParam.maRanges.First();
974cdf0e10cSrcweir ScAddress aDest = rDestPos;
975cdf0e10cSrcweir
976cdf0e10cSrcweir SCTAB nClipTab = 0;
977cdf0e10cSrcweir for (SCTAB nDestTab=0; nDestTab<=MAXTAB && pTab[nDestTab]; nDestTab++)
978cdf0e10cSrcweir if (rMark.GetTableSelect(nDestTab))
979cdf0e10cSrcweir {
980cdf0e10cSrcweir while (!pClipDoc->pTab[nClipTab]) nClipTab = (nClipTab+1) % (MAXTAB+1);
981cdf0e10cSrcweir aSource.aStart.SetTab( nClipTab );
982cdf0e10cSrcweir aSource.aEnd.SetTab( nClipTab );
983cdf0e10cSrcweir aDest.SetTab( nDestTab );
984cdf0e10cSrcweir
985cdf0e10cSrcweir // wie UpdateReference
986cdf0e10cSrcweir
987cdf0e10cSrcweir pRangeName->UpdateTranspose( aSource, aDest ); // vor den Zellen!
988cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
989cdf0e10cSrcweir if (pTab[i])
990cdf0e10cSrcweir pTab[i]->UpdateTranspose( aSource, aDest, pUndoDoc );
991cdf0e10cSrcweir
992cdf0e10cSrcweir nClipTab = (nClipTab+1) % (MAXTAB+1);
993cdf0e10cSrcweir }
994cdf0e10cSrcweir }
995cdf0e10cSrcweir
UpdateGrow(const ScRange & rArea,SCCOL nGrowX,SCROW nGrowY)996cdf0e10cSrcweir void ScDocument::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
997cdf0e10cSrcweir {
998cdf0e10cSrcweir //! pDBCollection
999cdf0e10cSrcweir //! pPivotCollection
1000cdf0e10cSrcweir //! UpdateChartRef
1001cdf0e10cSrcweir
1002cdf0e10cSrcweir pRangeName->UpdateGrow( rArea, nGrowX, nGrowY );
1003cdf0e10cSrcweir
1004cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB && pTab[i]; i++)
1005cdf0e10cSrcweir pTab[i]->UpdateGrow( rArea, nGrowX, nGrowY );
1006cdf0e10cSrcweir }
1007cdf0e10cSrcweir
Fill(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,const ScMarkData & rMark,sal_uLong nFillCount,FillDir eFillDir,FillCmd eFillCmd,FillDateCmd eFillDateCmd,double nStepValue,double nMaxValue)1008cdf0e10cSrcweir void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark,
1009cdf0e10cSrcweir sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
1010cdf0e10cSrcweir double nStepValue, double nMaxValue)
1011cdf0e10cSrcweir {
1012cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
1013cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
1014cdf0e10cSrcweir for (SCTAB i=0; i <= MAXTAB; i++)
1015cdf0e10cSrcweir if (pTab[i])
1016cdf0e10cSrcweir if (rMark.GetTableSelect(i))
1017cdf0e10cSrcweir pTab[i]->Fill(nCol1, nRow1, nCol2, nRow2,
1018cdf0e10cSrcweir nFillCount, eFillDir, eFillCmd, eFillDateCmd,
1019cdf0e10cSrcweir nStepValue, nMaxValue);
1020cdf0e10cSrcweir }
1021cdf0e10cSrcweir
GetAutoFillPreview(const ScRange & rSource,SCCOL nEndX,SCROW nEndY)1022cdf0e10cSrcweir String ScDocument::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY )
1023cdf0e10cSrcweir {
1024cdf0e10cSrcweir SCTAB nTab = rSource.aStart.Tab();
1025cdf0e10cSrcweir if (pTab[nTab])
1026cdf0e10cSrcweir return pTab[nTab]->GetAutoFillPreview( rSource, nEndX, nEndY );
1027cdf0e10cSrcweir
1028cdf0e10cSrcweir return EMPTY_STRING;
1029cdf0e10cSrcweir }
1030cdf0e10cSrcweir
AutoFormat(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,sal_uInt16 nFormatNo,const ScMarkData & rMark)1031cdf0e10cSrcweir void ScDocument::AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1032cdf0e10cSrcweir sal_uInt16 nFormatNo, const ScMarkData& rMark )
1033cdf0e10cSrcweir {
1034cdf0e10cSrcweir PutInOrder( nStartCol, nEndCol );
1035cdf0e10cSrcweir PutInOrder( nStartRow, nEndRow );
1036cdf0e10cSrcweir for (SCTAB i=0; i <= MAXTAB; i++)
1037cdf0e10cSrcweir if (pTab[i])
1038cdf0e10cSrcweir if (rMark.GetTableSelect(i))
1039cdf0e10cSrcweir pTab[i]->AutoFormat( nStartCol, nStartRow, nEndCol, nEndRow, nFormatNo );
1040cdf0e10cSrcweir }
1041cdf0e10cSrcweir
GetAutoFormatData(SCTAB nTab,SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,ScAutoFormatData & rData)1042cdf0e10cSrcweir void ScDocument::GetAutoFormatData(SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1043cdf0e10cSrcweir ScAutoFormatData& rData)
1044cdf0e10cSrcweir {
1045cdf0e10cSrcweir if (VALIDTAB(nTab))
1046cdf0e10cSrcweir {
1047cdf0e10cSrcweir if (pTab[nTab])
1048cdf0e10cSrcweir {
1049cdf0e10cSrcweir PutInOrder(nStartCol, nEndCol);
1050cdf0e10cSrcweir PutInOrder(nStartRow, nEndRow);
1051cdf0e10cSrcweir pTab[nTab]->GetAutoFormatData(nStartCol, nStartRow, nEndCol, nEndRow, rData);
1052cdf0e10cSrcweir }
1053cdf0e10cSrcweir }
1054cdf0e10cSrcweir }
1055cdf0e10cSrcweir
1056cdf0e10cSrcweir // static
GetSearchAndReplaceStart(const SvxSearchItem & rSearchItem,SCCOL & rCol,SCROW & rRow)1057cdf0e10cSrcweir void ScDocument::GetSearchAndReplaceStart( const SvxSearchItem& rSearchItem,
1058cdf0e10cSrcweir SCCOL& rCol, SCROW& rRow )
1059cdf0e10cSrcweir {
1060cdf0e10cSrcweir sal_uInt16 nCommand = rSearchItem.GetCommand();
1061cdf0e10cSrcweir sal_Bool bReplace = ( nCommand == SVX_SEARCHCMD_REPLACE ||
1062cdf0e10cSrcweir nCommand == SVX_SEARCHCMD_REPLACE_ALL );
1063cdf0e10cSrcweir if ( rSearchItem.GetBackward() )
1064cdf0e10cSrcweir {
1065cdf0e10cSrcweir if ( rSearchItem.GetRowDirection() )
1066cdf0e10cSrcweir {
1067cdf0e10cSrcweir if ( rSearchItem.GetPattern() )
1068cdf0e10cSrcweir {
1069cdf0e10cSrcweir rCol = MAXCOL;
1070cdf0e10cSrcweir rRow = MAXROW+1;
1071cdf0e10cSrcweir }
1072cdf0e10cSrcweir else if ( bReplace )
1073cdf0e10cSrcweir {
1074cdf0e10cSrcweir rCol = MAXCOL;
1075cdf0e10cSrcweir rRow = MAXROW;
1076cdf0e10cSrcweir }
1077cdf0e10cSrcweir else
1078cdf0e10cSrcweir {
1079cdf0e10cSrcweir rCol = MAXCOL+1;
1080cdf0e10cSrcweir rRow = MAXROW;
1081cdf0e10cSrcweir }
1082cdf0e10cSrcweir }
1083cdf0e10cSrcweir else
1084cdf0e10cSrcweir {
1085cdf0e10cSrcweir if ( rSearchItem.GetPattern() )
1086cdf0e10cSrcweir {
1087cdf0e10cSrcweir rCol = MAXCOL+1;
1088cdf0e10cSrcweir rRow = MAXROW;
1089cdf0e10cSrcweir }
1090cdf0e10cSrcweir else if ( bReplace )
1091cdf0e10cSrcweir {
1092cdf0e10cSrcweir rCol = MAXCOL;
1093cdf0e10cSrcweir rRow = MAXROW;
1094cdf0e10cSrcweir }
1095cdf0e10cSrcweir else
1096cdf0e10cSrcweir {
1097cdf0e10cSrcweir rCol = MAXCOL;
1098cdf0e10cSrcweir rRow = MAXROW+1;
1099cdf0e10cSrcweir }
1100cdf0e10cSrcweir }
1101cdf0e10cSrcweir }
1102cdf0e10cSrcweir else
1103cdf0e10cSrcweir {
1104cdf0e10cSrcweir if ( rSearchItem.GetRowDirection() )
1105cdf0e10cSrcweir {
1106cdf0e10cSrcweir if ( rSearchItem.GetPattern() )
1107cdf0e10cSrcweir {
1108cdf0e10cSrcweir rCol = 0;
1109cdf0e10cSrcweir rRow = (SCROW) -1;
1110cdf0e10cSrcweir }
1111cdf0e10cSrcweir else if ( bReplace )
1112cdf0e10cSrcweir {
1113cdf0e10cSrcweir rCol = 0;
1114cdf0e10cSrcweir rRow = 0;
1115cdf0e10cSrcweir }
1116cdf0e10cSrcweir else
1117cdf0e10cSrcweir {
1118cdf0e10cSrcweir rCol = (SCCOL) -1;
1119cdf0e10cSrcweir rRow = 0;
1120cdf0e10cSrcweir }
1121cdf0e10cSrcweir }
1122cdf0e10cSrcweir else
1123cdf0e10cSrcweir {
1124cdf0e10cSrcweir if ( rSearchItem.GetPattern() )
1125cdf0e10cSrcweir {
1126cdf0e10cSrcweir rCol = (SCCOL) -1;
1127cdf0e10cSrcweir rRow = 0;
1128cdf0e10cSrcweir }
1129cdf0e10cSrcweir else if ( bReplace )
1130cdf0e10cSrcweir {
1131cdf0e10cSrcweir rCol = 0;
1132cdf0e10cSrcweir rRow = 0;
1133cdf0e10cSrcweir }
1134cdf0e10cSrcweir else
1135cdf0e10cSrcweir {
1136cdf0e10cSrcweir rCol = 0;
1137cdf0e10cSrcweir rRow = (SCROW) -1;
1138cdf0e10cSrcweir }
1139cdf0e10cSrcweir }
1140cdf0e10cSrcweir }
1141cdf0e10cSrcweir }
1142cdf0e10cSrcweir
SearchAndReplace(const SvxSearchItem & rSearchItem,SCCOL & rCol,SCROW & rRow,SCTAB & rTab,ScMarkData & rMark,String & rUndoStr,ScDocument * pUndoDoc)1143cdf0e10cSrcweir sal_Bool ScDocument::SearchAndReplace(const SvxSearchItem& rSearchItem,
1144cdf0e10cSrcweir SCCOL& rCol, SCROW& rRow, SCTAB& rTab,
1145cdf0e10cSrcweir ScMarkData& rMark,
1146cdf0e10cSrcweir String& rUndoStr, ScDocument* pUndoDoc)
1147cdf0e10cSrcweir {
1148cdf0e10cSrcweir //! getrennte Markierungen pro Tabelle verwalten !!!!!!!!!!!!!
1149cdf0e10cSrcweir
1150cdf0e10cSrcweir rMark.MarkToMulti();
1151cdf0e10cSrcweir
1152cdf0e10cSrcweir sal_Bool bFound = sal_False;
1153cdf0e10cSrcweir if (VALIDTAB(rTab))
1154cdf0e10cSrcweir {
1155cdf0e10cSrcweir SCCOL nCol;
1156cdf0e10cSrcweir SCROW nRow;
1157cdf0e10cSrcweir SCTAB nTab;
1158cdf0e10cSrcweir sal_uInt16 nCommand = rSearchItem.GetCommand();
1159cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_FIND_ALL ||
1160cdf0e10cSrcweir nCommand == SVX_SEARCHCMD_REPLACE_ALL )
1161cdf0e10cSrcweir {
1162cdf0e10cSrcweir for (nTab = 0; nTab <= MAXTAB; nTab++)
1163cdf0e10cSrcweir if (pTab[nTab])
1164cdf0e10cSrcweir {
1165cdf0e10cSrcweir if (rMark.GetTableSelect(nTab))
1166cdf0e10cSrcweir {
1167cdf0e10cSrcweir nCol = 0;
1168cdf0e10cSrcweir nRow = 0;
1169cdf0e10cSrcweir bFound |= pTab[nTab]->SearchAndReplace(
1170cdf0e10cSrcweir rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc );
1171cdf0e10cSrcweir }
1172cdf0e10cSrcweir }
1173cdf0e10cSrcweir
1174cdf0e10cSrcweir // Markierung wird innen schon komplett gesetzt
1175cdf0e10cSrcweir }
1176cdf0e10cSrcweir else
1177cdf0e10cSrcweir {
1178cdf0e10cSrcweir nCol = rCol;
1179cdf0e10cSrcweir nRow = rRow;
1180cdf0e10cSrcweir if (rSearchItem.GetBackward())
1181cdf0e10cSrcweir {
1182cdf0e10cSrcweir for (nTab = rTab; ((SCsTAB)nTab >= 0) && !bFound; nTab--)
1183cdf0e10cSrcweir if (pTab[nTab])
1184cdf0e10cSrcweir {
1185cdf0e10cSrcweir if (rMark.GetTableSelect(nTab))
1186cdf0e10cSrcweir {
1187cdf0e10cSrcweir bFound = pTab[nTab]->SearchAndReplace(
1188cdf0e10cSrcweir rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc );
1189cdf0e10cSrcweir if (bFound)
1190cdf0e10cSrcweir {
1191cdf0e10cSrcweir rCol = nCol;
1192cdf0e10cSrcweir rRow = nRow;
1193cdf0e10cSrcweir rTab = nTab;
1194cdf0e10cSrcweir }
1195cdf0e10cSrcweir else
1196cdf0e10cSrcweir ScDocument::GetSearchAndReplaceStart(
1197cdf0e10cSrcweir rSearchItem, nCol, nRow );
1198cdf0e10cSrcweir }
1199cdf0e10cSrcweir }
1200cdf0e10cSrcweir }
1201cdf0e10cSrcweir else
1202cdf0e10cSrcweir {
1203cdf0e10cSrcweir for (nTab = rTab; (nTab <= MAXTAB) && !bFound; nTab++)
1204cdf0e10cSrcweir if (pTab[nTab])
1205cdf0e10cSrcweir {
1206cdf0e10cSrcweir if (rMark.GetTableSelect(nTab))
1207cdf0e10cSrcweir {
1208cdf0e10cSrcweir bFound = pTab[nTab]->SearchAndReplace(
1209cdf0e10cSrcweir rSearchItem, nCol, nRow, rMark, rUndoStr, pUndoDoc );
1210cdf0e10cSrcweir if (bFound)
1211cdf0e10cSrcweir {
1212cdf0e10cSrcweir rCol = nCol;
1213cdf0e10cSrcweir rRow = nRow;
1214cdf0e10cSrcweir rTab = nTab;
1215cdf0e10cSrcweir }
1216cdf0e10cSrcweir else
1217cdf0e10cSrcweir ScDocument::GetSearchAndReplaceStart(
1218cdf0e10cSrcweir rSearchItem, nCol, nRow );
1219cdf0e10cSrcweir }
1220cdf0e10cSrcweir }
1221cdf0e10cSrcweir }
1222cdf0e10cSrcweir }
1223cdf0e10cSrcweir }
1224cdf0e10cSrcweir return bFound;
1225cdf0e10cSrcweir }
1226cdf0e10cSrcweir
1227cdf0e10cSrcweir // Outline anpassen
1228cdf0e10cSrcweir
UpdateOutlineCol(SCCOL nStartCol,SCCOL nEndCol,SCTAB nTab,sal_Bool bShow)1229cdf0e10cSrcweir sal_Bool ScDocument::UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, sal_Bool bShow )
1230cdf0e10cSrcweir {
1231cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1232cdf0e10cSrcweir return pTab[nTab]->UpdateOutlineCol( nStartCol, nEndCol, bShow );
1233cdf0e10cSrcweir
1234cdf0e10cSrcweir DBG_ERROR("missing tab");
1235cdf0e10cSrcweir return sal_False;
1236cdf0e10cSrcweir }
1237cdf0e10cSrcweir
UpdateOutlineRow(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,sal_Bool bShow)1238cdf0e10cSrcweir sal_Bool ScDocument::UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_Bool bShow )
1239cdf0e10cSrcweir {
1240cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1241cdf0e10cSrcweir return pTab[nTab]->UpdateOutlineRow( nStartRow, nEndRow, bShow );
1242cdf0e10cSrcweir
1243cdf0e10cSrcweir DBG_ERROR("missing tab");
1244cdf0e10cSrcweir return sal_False;
1245cdf0e10cSrcweir }
1246cdf0e10cSrcweir
Sort(SCTAB nTab,const ScSortParam & rSortParam,sal_Bool bKeepQuery)1247cdf0e10cSrcweir void ScDocument::Sort(SCTAB nTab, const ScSortParam& rSortParam, sal_Bool bKeepQuery)
1248cdf0e10cSrcweir {
1249cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1250cdf0e10cSrcweir {
1251cdf0e10cSrcweir sal_Bool bOldDisableIdle = IsIdleDisabled();
1252cdf0e10cSrcweir DisableIdle( sal_True );
1253cdf0e10cSrcweir pTab[nTab]->Sort(rSortParam, bKeepQuery);
1254cdf0e10cSrcweir DisableIdle( bOldDisableIdle );
1255cdf0e10cSrcweir }
1256cdf0e10cSrcweir }
1257cdf0e10cSrcweir
Query(SCTAB nTab,const ScQueryParam & rQueryParam,sal_Bool bKeepSub)1258cdf0e10cSrcweir SCSIZE ScDocument::Query(SCTAB nTab, const ScQueryParam& rQueryParam, sal_Bool bKeepSub)
1259cdf0e10cSrcweir {
1260cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1261cdf0e10cSrcweir return pTab[nTab]->Query((ScQueryParam&)rQueryParam, bKeepSub);
1262cdf0e10cSrcweir
1263cdf0e10cSrcweir DBG_ERROR("missing tab");
1264cdf0e10cSrcweir return 0;
1265cdf0e10cSrcweir }
1266cdf0e10cSrcweir
1267cdf0e10cSrcweir
ValidQuery(SCROW nRow,SCTAB nTab,const ScQueryParam & rQueryParam,sal_Bool * pSpecial)1268cdf0e10cSrcweir sal_Bool ScDocument::ValidQuery( SCROW nRow, SCTAB nTab, const ScQueryParam& rQueryParam, sal_Bool* pSpecial )
1269cdf0e10cSrcweir {
1270cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1271cdf0e10cSrcweir return pTab[nTab]->ValidQuery( nRow, rQueryParam, pSpecial );
1272cdf0e10cSrcweir
1273cdf0e10cSrcweir DBG_ERROR("missing tab");
1274cdf0e10cSrcweir return sal_False;
1275cdf0e10cSrcweir }
1276cdf0e10cSrcweir
1277cdf0e10cSrcweir
GetUpperCellString(SCCOL nCol,SCROW nRow,SCTAB nTab,String & rStr)1278cdf0e10cSrcweir void ScDocument::GetUpperCellString(SCCOL nCol, SCROW nRow, SCTAB nTab, String& rStr)
1279cdf0e10cSrcweir {
1280cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1281cdf0e10cSrcweir pTab[nTab]->GetUpperCellString( nCol, nRow, rStr );
1282cdf0e10cSrcweir else
1283cdf0e10cSrcweir rStr.Erase();
1284cdf0e10cSrcweir }
1285cdf0e10cSrcweir
CreateQueryParam(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,SCTAB nTab,ScQueryParam & rQueryParam)1286cdf0e10cSrcweir sal_Bool ScDocument::CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCTAB nTab, ScQueryParam& rQueryParam)
1287cdf0e10cSrcweir {
1288cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1289cdf0e10cSrcweir return pTab[nTab]->CreateQueryParam(nCol1, nRow1, nCol2, nRow2, rQueryParam);
1290cdf0e10cSrcweir
1291cdf0e10cSrcweir DBG_ERROR("missing tab");
1292cdf0e10cSrcweir return sal_False;
1293cdf0e10cSrcweir }
1294cdf0e10cSrcweir
HasAutoFilter(const SCCOL nCurCol,const SCROW nCurRow,const SCTAB nCurTab)129522407013SOliver-Rainer Wittmann sal_Bool ScDocument::HasAutoFilter(
129622407013SOliver-Rainer Wittmann const SCCOL nCurCol,
129722407013SOliver-Rainer Wittmann const SCROW nCurRow,
129822407013SOliver-Rainer Wittmann const SCTAB nCurTab )
1299cdf0e10cSrcweir {
130022407013SOliver-Rainer Wittmann ScDBData* pDBData = GetDBAtCursor( nCurCol, nCurRow, nCurTab );
1301cdf0e10cSrcweir sal_Bool bHasAutoFilter = ( pDBData != NULL );
1302cdf0e10cSrcweir
1303cdf0e10cSrcweir if ( pDBData )
1304cdf0e10cSrcweir {
1305cdf0e10cSrcweir if ( pDBData->HasHeader() )
1306cdf0e10cSrcweir {
1307cdf0e10cSrcweir SCCOL nCol;
1308cdf0e10cSrcweir SCROW nRow;
1309cdf0e10cSrcweir sal_Int16 nFlag;
1310cdf0e10cSrcweir
1311cdf0e10cSrcweir ScQueryParam aParam;
1312cdf0e10cSrcweir pDBData->GetQueryParam( aParam );
1313cdf0e10cSrcweir nRow = aParam.nRow1;
1314cdf0e10cSrcweir
1315cdf0e10cSrcweir for ( nCol=aParam.nCol1; nCol<=aParam.nCol2 && bHasAutoFilter; nCol++ )
1316cdf0e10cSrcweir {
1317cdf0e10cSrcweir nFlag = ((ScMergeFlagAttr*)
1318cdf0e10cSrcweir GetAttr( nCol, nRow, nCurTab, ATTR_MERGE_FLAG ))->
1319cdf0e10cSrcweir GetValue();
1320cdf0e10cSrcweir
1321cdf0e10cSrcweir if ( (nFlag & SC_MF_AUTO) == 0 )
1322cdf0e10cSrcweir bHasAutoFilter = sal_False;
1323cdf0e10cSrcweir }
1324cdf0e10cSrcweir }
1325cdf0e10cSrcweir else
1326cdf0e10cSrcweir bHasAutoFilter = sal_False;
1327cdf0e10cSrcweir }
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir return bHasAutoFilter;
1330cdf0e10cSrcweir }
1331cdf0e10cSrcweir
HasColHeader(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab)1332cdf0e10cSrcweir sal_Bool ScDocument::HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1333cdf0e10cSrcweir SCTAB nTab )
1334cdf0e10cSrcweir {
1335cdf0e10cSrcweir return VALIDTAB(nTab) && pTab[nTab] && pTab[nTab]->HasColHeader( nStartCol, nStartRow, nEndCol, nEndRow );
1336cdf0e10cSrcweir //if (VALIDTAB(nTab))
1337cdf0e10cSrcweir // if (pTab[nTab])
1338cdf0e10cSrcweir // return pTab[nTab]->HasColHeader( nStartCol, nStartRow, nEndCol, nEndRow );
1339cdf0e10cSrcweir
1340cdf0e10cSrcweir //return sal_False;
1341cdf0e10cSrcweir }
1342cdf0e10cSrcweir
HasRowHeader(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab)1343cdf0e10cSrcweir sal_Bool ScDocument::HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1344cdf0e10cSrcweir SCTAB nTab )
1345cdf0e10cSrcweir {
1346cdf0e10cSrcweir return VALIDTAB(nTab) && pTab[nTab] && pTab[nTab]->HasRowHeader( nStartCol, nStartRow, nEndCol, nEndRow );
1347cdf0e10cSrcweir //if (VALIDTAB(nTab))
1348cdf0e10cSrcweir // if (pTab[nTab])
1349cdf0e10cSrcweir // return pTab[nTab]->HasRowHeader( nStartCol, nStartRow, nEndCol, nEndRow );
1350cdf0e10cSrcweir
1351cdf0e10cSrcweir //return sal_False;
1352cdf0e10cSrcweir }
1353cdf0e10cSrcweir
1354cdf0e10cSrcweir //
1355cdf0e10cSrcweir // GetFilterEntries - Eintraege fuer AutoFilter-Listbox
1356cdf0e10cSrcweir //
1357cdf0e10cSrcweir
GetFilterEntries(SCCOL nCol,SCROW nRow,SCTAB nTab,bool bFilter,TypedScStrCollection & rStrings,bool & rHasDates)1358cdf0e10cSrcweir sal_Bool ScDocument::GetFilterEntries(
1359cdf0e10cSrcweir SCCOL nCol, SCROW nRow, SCTAB nTab, bool bFilter, TypedScStrCollection& rStrings, bool& rHasDates)
1360cdf0e10cSrcweir {
1361cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] && pDBCollection )
1362cdf0e10cSrcweir {
1363cdf0e10cSrcweir ScDBData* pDBData = pDBCollection->GetDBAtCursor(nCol, nRow, nTab, sal_False); //!??
1364cdf0e10cSrcweir if (pDBData)
1365cdf0e10cSrcweir {
1366cdf0e10cSrcweir SCTAB nAreaTab;
1367cdf0e10cSrcweir SCCOL nStartCol;
1368cdf0e10cSrcweir SCROW nStartRow;
1369cdf0e10cSrcweir SCCOL nEndCol;
1370cdf0e10cSrcweir SCROW nEndRow;
1371cdf0e10cSrcweir pDBData->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow );
1372cdf0e10cSrcweir
1373cdf0e10cSrcweir //Add for i85305
1374cdf0e10cSrcweir SCCOL nTmpStartCol = nCol;
1375cdf0e10cSrcweir SCROW nTmpStartRow = nRow;
1376cdf0e10cSrcweir SCCOL nTmpEndCol = nCol;
1377cdf0e10cSrcweir SCROW nTmpEndRow = nRow;
1378cdf0e10cSrcweir GetDataArea( nTab, nTmpStartCol, nTmpStartRow, nTmpEndCol, nTmpEndRow, sal_False, false);
1379cdf0e10cSrcweir if (nTmpEndRow > nEndRow)
1380cdf0e10cSrcweir {
1381cdf0e10cSrcweir nEndRow = nTmpEndRow;
1382cdf0e10cSrcweir pDBData->SetArea(nAreaTab, nStartCol,nStartRow, nEndCol,nEndRow);
1383cdf0e10cSrcweir }
1384cdf0e10cSrcweir //End of i85305
1385cdf0e10cSrcweir
1386cdf0e10cSrcweir if (pDBData->HasHeader())
1387cdf0e10cSrcweir ++nStartRow;
1388cdf0e10cSrcweir
1389cdf0e10cSrcweir ScQueryParam aParam;
1390cdf0e10cSrcweir pDBData->GetQueryParam( aParam );
1391cdf0e10cSrcweir rStrings.SetCaseSensitive( aParam.bCaseSens );
1392cdf0e10cSrcweir
1393cdf0e10cSrcweir // return all filter entries, if a filter condition is connected with a boolean OR
1394cdf0e10cSrcweir if ( bFilter )
1395cdf0e10cSrcweir {
1396cdf0e10cSrcweir SCSIZE nEntryCount = aParam.GetEntryCount();
1397cdf0e10cSrcweir for ( SCSIZE i = 0; i < nEntryCount && aParam.GetEntry(i).bDoQuery; ++i )
1398cdf0e10cSrcweir {
1399cdf0e10cSrcweir ScQueryEntry& rEntry = aParam.GetEntry(i);
1400cdf0e10cSrcweir if ( rEntry.eConnect != SC_AND )
1401cdf0e10cSrcweir {
1402cdf0e10cSrcweir bFilter = false;
1403cdf0e10cSrcweir break;
1404cdf0e10cSrcweir }
1405cdf0e10cSrcweir }
1406cdf0e10cSrcweir }
1407cdf0e10cSrcweir
1408cdf0e10cSrcweir if ( bFilter )
1409cdf0e10cSrcweir {
1410cdf0e10cSrcweir pTab[nTab]->GetFilteredFilterEntries( nCol, nStartRow, nEndRow, aParam, rStrings, rHasDates );
1411cdf0e10cSrcweir }
1412cdf0e10cSrcweir else
1413cdf0e10cSrcweir {
1414cdf0e10cSrcweir pTab[nTab]->GetFilterEntries( nCol, nStartRow, nEndRow, rStrings, rHasDates );
1415cdf0e10cSrcweir }
1416cdf0e10cSrcweir
1417cdf0e10cSrcweir return sal_True;
1418cdf0e10cSrcweir }
1419cdf0e10cSrcweir }
1420cdf0e10cSrcweir
1421cdf0e10cSrcweir return sal_False;
1422cdf0e10cSrcweir }
1423cdf0e10cSrcweir
1424cdf0e10cSrcweir //
1425cdf0e10cSrcweir // GetFilterEntriesArea - Eintraege fuer Filter-Dialog
1426cdf0e10cSrcweir //
1427cdf0e10cSrcweir
GetFilterEntriesArea(SCCOL nCol,SCROW nStartRow,SCROW nEndRow,SCTAB nTab,TypedScStrCollection & rStrings,bool & rHasDates)1428cdf0e10cSrcweir sal_Bool ScDocument::GetFilterEntriesArea( SCCOL nCol, SCROW nStartRow, SCROW nEndRow,
1429cdf0e10cSrcweir SCTAB nTab, TypedScStrCollection& rStrings, bool& rHasDates )
1430cdf0e10cSrcweir {
1431cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
1432cdf0e10cSrcweir {
1433cdf0e10cSrcweir pTab[nTab]->GetFilterEntries( nCol, nStartRow, nEndRow, rStrings, rHasDates );
1434cdf0e10cSrcweir return sal_True;
1435cdf0e10cSrcweir }
1436cdf0e10cSrcweir
1437cdf0e10cSrcweir return sal_False;
1438cdf0e10cSrcweir }
1439cdf0e10cSrcweir
1440cdf0e10cSrcweir //
1441cdf0e10cSrcweir // GetDataEntries - Eintraege fuer Auswahlliste-Listbox (keine Zahlen / Formeln)
1442cdf0e10cSrcweir //
1443cdf0e10cSrcweir
GetDataEntries(SCCOL nCol,SCROW nRow,SCTAB nTab,TypedScStrCollection & rStrings,sal_Bool bLimit)1444cdf0e10cSrcweir sal_Bool ScDocument::GetDataEntries( SCCOL nCol, SCROW nRow, SCTAB nTab,
1445cdf0e10cSrcweir TypedScStrCollection& rStrings, sal_Bool bLimit )
1446cdf0e10cSrcweir {
1447cdf0e10cSrcweir if( !bLimit )
1448cdf0e10cSrcweir {
1449cdf0e10cSrcweir /* Try to generate the list from list validation. This part is skipped,
1450cdf0e10cSrcweir if bLimit==sal_True, because in that case this function is called to get
1451cdf0e10cSrcweir cell values for auto completion on input. */
1452cdf0e10cSrcweir sal_uInt32 nValidation = static_cast< const SfxUInt32Item* >( GetAttr( nCol, nRow, nTab, ATTR_VALIDDATA ) )->GetValue();
1453cdf0e10cSrcweir if( nValidation )
1454cdf0e10cSrcweir {
1455cdf0e10cSrcweir const ScValidationData* pData = GetValidationEntry( nValidation );
1456cdf0e10cSrcweir if( pData && pData->FillSelectionList( rStrings, ScAddress( nCol, nRow, nTab ) ) )
1457cdf0e10cSrcweir return sal_True;
1458cdf0e10cSrcweir }
1459cdf0e10cSrcweir }
1460cdf0e10cSrcweir
1461cdf0e10cSrcweir return ValidTab(nTab) && pTab[nTab] && pTab[nTab]->GetDataEntries( nCol, nRow, rStrings, bLimit );
1462cdf0e10cSrcweir //if (ValidTab(nTab) && pTab[nTab])
1463cdf0e10cSrcweir // return pTab[nTab]->GetDataEntries( nCol, nRow, rStrings, bLimit );
1464cdf0e10cSrcweir
1465cdf0e10cSrcweir //return sal_False;
1466cdf0e10cSrcweir }
1467cdf0e10cSrcweir
1468cdf0e10cSrcweir //
1469cdf0e10cSrcweir // GetFormulaEntries - Eintraege fuer Formel-AutoEingabe
1470cdf0e10cSrcweir //
1471cdf0e10cSrcweir
1472cdf0e10cSrcweir // Funktionen werden als 1 schon vom InputHandler eingefuegt
1473cdf0e10cSrcweir #define SC_STRTYPE_NAMES 2
1474cdf0e10cSrcweir #define SC_STRTYPE_DBNAMES 3
1475cdf0e10cSrcweir #define SC_STRTYPE_HEADERS 4
1476cdf0e10cSrcweir
GetFormulaEntries(TypedScStrCollection & rStrings)1477cdf0e10cSrcweir sal_Bool ScDocument::GetFormulaEntries( TypedScStrCollection& rStrings )
1478cdf0e10cSrcweir {
1479cdf0e10cSrcweir sal_uInt16 i;
1480cdf0e10cSrcweir
1481cdf0e10cSrcweir //
1482cdf0e10cSrcweir // Bereichsnamen
1483cdf0e10cSrcweir //
1484cdf0e10cSrcweir
1485cdf0e10cSrcweir if ( pRangeName )
1486cdf0e10cSrcweir {
1487cdf0e10cSrcweir sal_uInt16 nRangeCount = pRangeName->GetCount();
1488cdf0e10cSrcweir for ( i=0; i<nRangeCount; i++ )
1489cdf0e10cSrcweir {
1490cdf0e10cSrcweir ScRangeData* pData = (*pRangeName)[i];
1491cdf0e10cSrcweir if (pData)
1492cdf0e10cSrcweir {
1493cdf0e10cSrcweir TypedStrData* pNew = new TypedStrData( pData->GetName(), 0.0, SC_STRTYPE_NAMES );
1494cdf0e10cSrcweir if ( !rStrings.Insert(pNew) )
1495cdf0e10cSrcweir delete pNew;
1496cdf0e10cSrcweir }
1497cdf0e10cSrcweir }
1498cdf0e10cSrcweir }
1499cdf0e10cSrcweir
1500cdf0e10cSrcweir //
1501cdf0e10cSrcweir // Datenbank-Bereiche
1502cdf0e10cSrcweir //
1503cdf0e10cSrcweir
1504cdf0e10cSrcweir if ( pDBCollection )
1505cdf0e10cSrcweir {
1506cdf0e10cSrcweir sal_uInt16 nDBCount = pDBCollection->GetCount();
1507cdf0e10cSrcweir for ( i=0; i<nDBCount; i++ )
1508cdf0e10cSrcweir {
1509cdf0e10cSrcweir ScDBData* pData = (*pDBCollection)[i];
1510cdf0e10cSrcweir if (pData)
1511cdf0e10cSrcweir {
1512cdf0e10cSrcweir TypedStrData* pNew = new TypedStrData( pData->GetName(), 0.0, SC_STRTYPE_DBNAMES );
1513cdf0e10cSrcweir if ( !rStrings.Insert(pNew) )
1514cdf0e10cSrcweir delete pNew;
1515cdf0e10cSrcweir }
1516cdf0e10cSrcweir }
1517cdf0e10cSrcweir }
1518cdf0e10cSrcweir
1519cdf0e10cSrcweir //
1520cdf0e10cSrcweir // Inhalte von Beschriftungsbereichen
1521cdf0e10cSrcweir //
1522cdf0e10cSrcweir
1523cdf0e10cSrcweir ScRangePairList* pLists[2];
1524cdf0e10cSrcweir pLists[0] = GetColNameRanges();
1525cdf0e10cSrcweir pLists[1] = GetRowNameRanges();
1526cdf0e10cSrcweir for (sal_uInt16 nListNo=0; nListNo<2; nListNo++)
1527cdf0e10cSrcweir {
1528cdf0e10cSrcweir ScRangePairList* pList = pLists[nListNo];
1529cdf0e10cSrcweir if (pList)
1530cdf0e10cSrcweir for ( ScRangePair* pPair = pList->First(); pPair; pPair = pList->Next() )
1531cdf0e10cSrcweir {
1532cdf0e10cSrcweir ScRange aRange = pPair->GetRange(0);
1533cdf0e10cSrcweir ScCellIterator aIter( this, aRange );
1534cdf0e10cSrcweir for ( ScBaseCell* pCell = aIter.GetFirst(); pCell; pCell = aIter.GetNext() )
1535cdf0e10cSrcweir if ( pCell->HasStringData() )
1536cdf0e10cSrcweir {
1537cdf0e10cSrcweir String aStr = pCell->GetStringData();
1538cdf0e10cSrcweir TypedStrData* pNew = new TypedStrData( aStr, 0.0, SC_STRTYPE_HEADERS );
1539cdf0e10cSrcweir if ( !rStrings.Insert(pNew) )
1540cdf0e10cSrcweir delete pNew;
1541cdf0e10cSrcweir }
1542cdf0e10cSrcweir }
1543cdf0e10cSrcweir }
1544cdf0e10cSrcweir
1545cdf0e10cSrcweir return sal_True;
1546cdf0e10cSrcweir }
1547cdf0e10cSrcweir
1548cdf0e10cSrcweir
IsEmbedded() const1549cdf0e10cSrcweir sal_Bool ScDocument::IsEmbedded() const
1550cdf0e10cSrcweir {
1551cdf0e10cSrcweir return bIsEmbedded;
1552cdf0e10cSrcweir }
1553cdf0e10cSrcweir
GetEmbedded(ScRange & rRange) const1554cdf0e10cSrcweir void ScDocument::GetEmbedded( ScRange& rRange ) const
1555cdf0e10cSrcweir {
1556cdf0e10cSrcweir rRange = aEmbedRange;
1557cdf0e10cSrcweir }
1558cdf0e10cSrcweir
GetEmbeddedRect() const1559cdf0e10cSrcweir Rectangle ScDocument::GetEmbeddedRect() const // 1/100 mm
1560cdf0e10cSrcweir {
1561cdf0e10cSrcweir Rectangle aRect;
1562cdf0e10cSrcweir ScTable* pTable = pTab[aEmbedRange.aStart.Tab()];
1563cdf0e10cSrcweir if (!pTable)
1564cdf0e10cSrcweir {
1565cdf0e10cSrcweir DBG_ERROR("GetEmbeddedRect ohne Tabelle");
1566cdf0e10cSrcweir }
1567cdf0e10cSrcweir else
1568cdf0e10cSrcweir {
1569cdf0e10cSrcweir SCCOL i;
1570cdf0e10cSrcweir
1571cdf0e10cSrcweir for (i=0; i<aEmbedRange.aStart.Col(); i++)
1572cdf0e10cSrcweir aRect.Left() += pTable->GetColWidth(i);
1573cdf0e10cSrcweir aRect.Top() += pTable->GetRowHeight( 0, aEmbedRange.aStart.Row() - 1);
1574cdf0e10cSrcweir aRect.Right() = aRect.Left();
1575cdf0e10cSrcweir for (i=aEmbedRange.aStart.Col(); i<=aEmbedRange.aEnd.Col(); i++)
1576cdf0e10cSrcweir aRect.Right() += pTable->GetColWidth(i);
1577cdf0e10cSrcweir aRect.Bottom() = aRect.Top();
1578cdf0e10cSrcweir aRect.Bottom() += pTable->GetRowHeight( aEmbedRange.aStart.Row(), aEmbedRange.aEnd.Row());
1579cdf0e10cSrcweir
1580cdf0e10cSrcweir aRect.Left() = (long) ( aRect.Left() * HMM_PER_TWIPS );
1581cdf0e10cSrcweir aRect.Right() = (long) ( aRect.Right() * HMM_PER_TWIPS );
1582cdf0e10cSrcweir aRect.Top() = (long) ( aRect.Top() * HMM_PER_TWIPS );
1583cdf0e10cSrcweir aRect.Bottom() = (long) ( aRect.Bottom() * HMM_PER_TWIPS );
1584cdf0e10cSrcweir }
1585cdf0e10cSrcweir return aRect;
1586cdf0e10cSrcweir }
1587cdf0e10cSrcweir
SetEmbedded(const ScRange & rRange)1588cdf0e10cSrcweir void ScDocument::SetEmbedded( const ScRange& rRange )
1589cdf0e10cSrcweir {
1590cdf0e10cSrcweir bIsEmbedded = sal_True;
1591cdf0e10cSrcweir aEmbedRange = rRange;
1592cdf0e10cSrcweir }
1593cdf0e10cSrcweir
ResetEmbedded()1594cdf0e10cSrcweir void ScDocument::ResetEmbedded()
1595cdf0e10cSrcweir {
1596cdf0e10cSrcweir bIsEmbedded = sal_False;
1597cdf0e10cSrcweir aEmbedRange = ScRange();
1598cdf0e10cSrcweir }
1599cdf0e10cSrcweir
1600cdf0e10cSrcweir
1601cdf0e10cSrcweir /** Similar to ScViewData::AddPixelsWhile(), but add height twips and only
1602cdf0e10cSrcweir while result is less than nStopTwips.
1603cdf0e10cSrcweir @return sal_True if advanced at least one row.
1604cdf0e10cSrcweir */
lcl_AddTwipsWhile(long & rTwips,long nStopTwips,SCROW & rPosY,SCROW nEndRow,const ScTable * pTable)1605cdf0e10cSrcweir bool lcl_AddTwipsWhile( long & rTwips, long nStopTwips, SCROW & rPosY, SCROW nEndRow, const ScTable * pTable )
1606cdf0e10cSrcweir {
1607cdf0e10cSrcweir SCROW nRow = rPosY;
1608cdf0e10cSrcweir bool bAdded = false;
1609cdf0e10cSrcweir bool bStop = false;
1610cdf0e10cSrcweir while (rTwips < nStopTwips && nRow <= nEndRow && !bStop)
1611cdf0e10cSrcweir {
1612cdf0e10cSrcweir SCROW nHeightEndRow;
1613cdf0e10cSrcweir sal_uInt16 nHeight = pTable->GetRowHeight( nRow, NULL, &nHeightEndRow);
1614cdf0e10cSrcweir if (nHeightEndRow > nEndRow)
1615cdf0e10cSrcweir nHeightEndRow = nEndRow;
1616cdf0e10cSrcweir if (!nHeight)
1617cdf0e10cSrcweir nRow = nHeightEndRow + 1;
1618cdf0e10cSrcweir else
1619cdf0e10cSrcweir {
1620cdf0e10cSrcweir SCROW nRows = nHeightEndRow - nRow + 1;
1621cdf0e10cSrcweir sal_Int64 nAdd = static_cast<sal_Int64>(nHeight) * nRows;
1622cdf0e10cSrcweir if (nAdd + rTwips >= nStopTwips)
1623cdf0e10cSrcweir {
1624cdf0e10cSrcweir sal_Int64 nDiff = nAdd + rTwips - nStopTwips;
1625cdf0e10cSrcweir nRows -= static_cast<SCROW>(nDiff / nHeight);
1626cdf0e10cSrcweir nAdd = nHeight * nRows;
1627cdf0e10cSrcweir // We're looking for a value that satisfies loop condition.
1628cdf0e10cSrcweir if (nAdd + rTwips >= nStopTwips)
1629cdf0e10cSrcweir {
1630cdf0e10cSrcweir --nRows;
1631cdf0e10cSrcweir nAdd -= nHeight;
1632cdf0e10cSrcweir }
1633cdf0e10cSrcweir bStop = true;
1634cdf0e10cSrcweir }
1635cdf0e10cSrcweir rTwips += static_cast<long>(nAdd);
1636cdf0e10cSrcweir nRow += nRows;
1637cdf0e10cSrcweir }
1638cdf0e10cSrcweir }
1639cdf0e10cSrcweir if (nRow > rPosY)
1640cdf0e10cSrcweir {
1641cdf0e10cSrcweir --nRow;
1642cdf0e10cSrcweir bAdded = true;
1643cdf0e10cSrcweir }
1644cdf0e10cSrcweir rPosY = nRow;
1645cdf0e10cSrcweir return bAdded;
1646cdf0e10cSrcweir }
1647cdf0e10cSrcweir
GetRange(SCTAB nTab,const Rectangle & rMMRect)1648cdf0e10cSrcweir ScRange ScDocument::GetRange( SCTAB nTab, const Rectangle& rMMRect )
1649cdf0e10cSrcweir {
1650cdf0e10cSrcweir ScTable* pTable = pTab[nTab];
1651cdf0e10cSrcweir if (!pTable)
1652cdf0e10cSrcweir {
1653cdf0e10cSrcweir DBG_ERROR("GetRange ohne Tabelle");
1654cdf0e10cSrcweir return ScRange();
1655cdf0e10cSrcweir }
1656cdf0e10cSrcweir
1657cdf0e10cSrcweir Rectangle aPosRect = rMMRect;
1658cdf0e10cSrcweir if ( IsNegativePage( nTab ) )
1659cdf0e10cSrcweir ScDrawLayer::MirrorRectRTL( aPosRect ); // always with positive (LTR) values
1660cdf0e10cSrcweir
1661cdf0e10cSrcweir long nSize;
1662cdf0e10cSrcweir long nTwips;
1663cdf0e10cSrcweir long nAdd;
1664cdf0e10cSrcweir sal_Bool bEnd;
1665cdf0e10cSrcweir
1666cdf0e10cSrcweir nSize = 0;
1667cdf0e10cSrcweir nTwips = (long) (aPosRect.Left() / HMM_PER_TWIPS);
1668cdf0e10cSrcweir
1669cdf0e10cSrcweir SCCOL nX1 = 0;
1670cdf0e10cSrcweir bEnd = sal_False;
1671cdf0e10cSrcweir while (!bEnd)
1672cdf0e10cSrcweir {
1673cdf0e10cSrcweir nAdd = (long) pTable->GetColWidth(nX1);
1674cdf0e10cSrcweir if (nSize+nAdd <= nTwips+1 && nX1<MAXCOL)
1675cdf0e10cSrcweir {
1676cdf0e10cSrcweir nSize += nAdd;
1677cdf0e10cSrcweir ++nX1;
1678cdf0e10cSrcweir }
1679cdf0e10cSrcweir else
1680cdf0e10cSrcweir bEnd = sal_True;
1681cdf0e10cSrcweir }
1682cdf0e10cSrcweir
1683cdf0e10cSrcweir nTwips = (long) (aPosRect.Right() / HMM_PER_TWIPS);
1684cdf0e10cSrcweir
1685cdf0e10cSrcweir SCCOL nX2 = nX1;
1686cdf0e10cSrcweir bEnd = sal_False;
1687cdf0e10cSrcweir while (!bEnd)
1688cdf0e10cSrcweir {
1689cdf0e10cSrcweir nAdd = (long) pTable->GetColWidth(nX2);
1690cdf0e10cSrcweir if (nSize+nAdd < nTwips && nX2<MAXCOL)
1691cdf0e10cSrcweir {
1692cdf0e10cSrcweir nSize += nAdd;
1693cdf0e10cSrcweir ++nX2;
1694cdf0e10cSrcweir }
1695cdf0e10cSrcweir else
1696cdf0e10cSrcweir bEnd = sal_True;
1697cdf0e10cSrcweir }
1698cdf0e10cSrcweir
1699cdf0e10cSrcweir
1700cdf0e10cSrcweir nSize = 0;
1701cdf0e10cSrcweir nTwips = (long) (aPosRect.Top() / HMM_PER_TWIPS);
1702cdf0e10cSrcweir
1703cdf0e10cSrcweir SCROW nY1 = 0;
1704cdf0e10cSrcweir // Was if(nSize+nAdd<=nTwips+1) inside loop => if(nSize+nAdd<nTwips+2)
1705cdf0e10cSrcweir if (lcl_AddTwipsWhile( nSize, nTwips+2, nY1, MAXROW, pTable) && nY1 < MAXROW)
1706cdf0e10cSrcweir ++nY1; // original loop ended on last matched +1 unless that was MAXROW
1707cdf0e10cSrcweir
1708cdf0e10cSrcweir nTwips = (long) (aPosRect.Bottom() / HMM_PER_TWIPS);
1709cdf0e10cSrcweir
1710cdf0e10cSrcweir SCROW nY2 = nY1;
1711cdf0e10cSrcweir // Was if(nSize+nAdd<nTwips) inside loop => if(nSize+nAdd<nTwips)
1712cdf0e10cSrcweir if (lcl_AddTwipsWhile( nSize, nTwips, nY2, MAXROW, pTable) && nY2 < MAXROW)
1713cdf0e10cSrcweir ++nY2; // original loop ended on last matched +1 unless that was MAXROW
1714cdf0e10cSrcweir
1715cdf0e10cSrcweir return ScRange( nX1,nY1,nTab, nX2,nY2,nTab );
1716cdf0e10cSrcweir }
1717cdf0e10cSrcweir
SetEmbedded(const Rectangle & rRect)1718cdf0e10cSrcweir void ScDocument::SetEmbedded( const Rectangle& rRect ) // aus VisArea (1/100 mm)
1719cdf0e10cSrcweir {
1720cdf0e10cSrcweir bIsEmbedded = sal_True;
1721cdf0e10cSrcweir aEmbedRange = GetRange( nVisibleTab, rRect );
1722cdf0e10cSrcweir }
1723cdf0e10cSrcweir
1724cdf0e10cSrcweir // VisArea auf Zellgrenzen anpassen
1725cdf0e10cSrcweir
lcl_SnapHor(ScTable * pTable,long & rVal,SCCOL & rStartCol)1726cdf0e10cSrcweir void lcl_SnapHor( ScTable* pTable, long& rVal, SCCOL& rStartCol )
1727cdf0e10cSrcweir {
1728cdf0e10cSrcweir SCCOL nCol = 0;
1729cdf0e10cSrcweir long nTwips = (long) (rVal / HMM_PER_TWIPS);
1730cdf0e10cSrcweir long nSnap = 0;
1731cdf0e10cSrcweir while ( nCol<MAXCOL )
1732cdf0e10cSrcweir {
1733cdf0e10cSrcweir long nAdd = pTable->GetColWidth(nCol);
1734cdf0e10cSrcweir if ( nSnap + nAdd/2 < nTwips || nCol < rStartCol )
1735cdf0e10cSrcweir {
1736cdf0e10cSrcweir nSnap += nAdd;
1737cdf0e10cSrcweir ++nCol;
1738cdf0e10cSrcweir }
1739cdf0e10cSrcweir else
1740cdf0e10cSrcweir break;
1741cdf0e10cSrcweir }
1742cdf0e10cSrcweir rVal = (long) ( nSnap * HMM_PER_TWIPS );
1743cdf0e10cSrcweir rStartCol = nCol;
1744cdf0e10cSrcweir }
1745cdf0e10cSrcweir
lcl_SnapVer(ScTable * pTable,long & rVal,SCROW & rStartRow)1746cdf0e10cSrcweir void lcl_SnapVer( ScTable* pTable, long& rVal, SCROW& rStartRow )
1747cdf0e10cSrcweir {
1748cdf0e10cSrcweir SCROW nRow = 0;
1749cdf0e10cSrcweir long nTwips = (long) (rVal / HMM_PER_TWIPS);
1750cdf0e10cSrcweir long nSnap = 0;
1751cdf0e10cSrcweir
1752cdf0e10cSrcweir bool bFound = false;
1753cdf0e10cSrcweir for (SCROW i = nRow; i <= MAXROW; ++i)
1754cdf0e10cSrcweir {
1755cdf0e10cSrcweir SCROW nLastRow;
1756cdf0e10cSrcweir if (pTable->RowHidden(i, NULL, &nLastRow))
1757cdf0e10cSrcweir {
1758cdf0e10cSrcweir i = nLastRow;
1759cdf0e10cSrcweir continue;
1760cdf0e10cSrcweir }
1761cdf0e10cSrcweir
1762cdf0e10cSrcweir nRow = i;
1763cdf0e10cSrcweir long nAdd = pTable->GetRowHeight(i);
1764cdf0e10cSrcweir if ( nSnap + nAdd/2 < nTwips || nRow < rStartRow )
1765cdf0e10cSrcweir {
1766cdf0e10cSrcweir nSnap += nAdd;
1767cdf0e10cSrcweir ++nRow;
1768cdf0e10cSrcweir }
1769cdf0e10cSrcweir else
1770cdf0e10cSrcweir {
1771cdf0e10cSrcweir bFound = true;
1772cdf0e10cSrcweir break;
1773cdf0e10cSrcweir }
1774cdf0e10cSrcweir }
1775cdf0e10cSrcweir if (!bFound)
1776cdf0e10cSrcweir nRow = MAXROW; // all hidden down to the bottom
1777cdf0e10cSrcweir
1778cdf0e10cSrcweir rVal = (long) ( nSnap * HMM_PER_TWIPS );
1779cdf0e10cSrcweir rStartRow = nRow;
1780cdf0e10cSrcweir }
1781cdf0e10cSrcweir
SnapVisArea(Rectangle & rRect) const1782cdf0e10cSrcweir void ScDocument::SnapVisArea( Rectangle& rRect ) const
1783cdf0e10cSrcweir {
1784cdf0e10cSrcweir ScTable* pTable = pTab[nVisibleTab];
1785cdf0e10cSrcweir if (!pTable)
1786cdf0e10cSrcweir {
1787cdf0e10cSrcweir DBG_ERROR("SetEmbedded ohne Tabelle");
1788cdf0e10cSrcweir return;
1789cdf0e10cSrcweir }
1790cdf0e10cSrcweir
1791cdf0e10cSrcweir sal_Bool bNegativePage = IsNegativePage( nVisibleTab );
1792cdf0e10cSrcweir if ( bNegativePage )
1793cdf0e10cSrcweir ScDrawLayer::MirrorRectRTL( rRect ); // calculate with positive (LTR) values
1794cdf0e10cSrcweir
1795cdf0e10cSrcweir SCCOL nCol = 0;
1796cdf0e10cSrcweir lcl_SnapHor( pTable, rRect.Left(), nCol );
1797cdf0e10cSrcweir ++nCol; // mindestens eine Spalte
1798cdf0e10cSrcweir lcl_SnapHor( pTable, rRect.Right(), nCol );
1799cdf0e10cSrcweir
1800cdf0e10cSrcweir SCROW nRow = 0;
1801cdf0e10cSrcweir lcl_SnapVer( pTable, rRect.Top(), nRow );
1802cdf0e10cSrcweir ++nRow; // mindestens eine Zeile
1803cdf0e10cSrcweir lcl_SnapVer( pTable, rRect.Bottom(), nRow );
1804cdf0e10cSrcweir
1805cdf0e10cSrcweir if ( bNegativePage )
1806cdf0e10cSrcweir ScDrawLayer::MirrorRectRTL( rRect ); // back to real rectangle
1807cdf0e10cSrcweir }
1808cdf0e10cSrcweir
GetDocProtection() const1809cdf0e10cSrcweir ScDocProtection* ScDocument::GetDocProtection() const
1810cdf0e10cSrcweir {
1811cdf0e10cSrcweir return pDocProtection.get();
1812cdf0e10cSrcweir }
1813cdf0e10cSrcweir
SetDocProtection(const ScDocProtection * pProtect)1814cdf0e10cSrcweir void ScDocument::SetDocProtection(const ScDocProtection* pProtect)
1815cdf0e10cSrcweir {
1816cdf0e10cSrcweir if (pProtect)
1817cdf0e10cSrcweir pDocProtection.reset(new ScDocProtection(*pProtect));
1818cdf0e10cSrcweir else
18193d762826SHerbert Dürr pDocProtection.reset();
1820cdf0e10cSrcweir }
1821cdf0e10cSrcweir
IsDocProtected() const1822cdf0e10cSrcweir sal_Bool ScDocument::IsDocProtected() const
1823cdf0e10cSrcweir {
1824cdf0e10cSrcweir return pDocProtection.get() && pDocProtection->isProtected();
1825cdf0e10cSrcweir }
1826cdf0e10cSrcweir
IsDocEditable() const1827cdf0e10cSrcweir sal_Bool ScDocument::IsDocEditable() const
1828cdf0e10cSrcweir {
1829cdf0e10cSrcweir // import into read-only document is possible
1830cdf0e10cSrcweir return !IsDocProtected() && ( bImportingXML || mbChangeReadOnlyEnabled || !pShell || !pShell->IsReadOnly() );
1831cdf0e10cSrcweir }
1832cdf0e10cSrcweir
IsTabProtected(SCTAB nTab) const1833cdf0e10cSrcweir sal_Bool ScDocument::IsTabProtected( SCTAB nTab ) const
1834cdf0e10cSrcweir {
1835cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab])
1836cdf0e10cSrcweir return pTab[nTab]->IsProtected();
1837cdf0e10cSrcweir
1838cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
1839cdf0e10cSrcweir return sal_False;
1840cdf0e10cSrcweir }
1841cdf0e10cSrcweir
GetTabProtection(SCTAB nTab) const1842cdf0e10cSrcweir ScTableProtection* ScDocument::GetTabProtection( SCTAB nTab ) const
1843cdf0e10cSrcweir {
1844cdf0e10cSrcweir if (VALIDTAB(nTab) && pTab[nTab])
1845cdf0e10cSrcweir return pTab[nTab]->GetProtection();
1846cdf0e10cSrcweir
1847cdf0e10cSrcweir return NULL;
1848cdf0e10cSrcweir }
1849cdf0e10cSrcweir
SetTabProtection(SCTAB nTab,const ScTableProtection * pProtect)1850cdf0e10cSrcweir void ScDocument::SetTabProtection(SCTAB nTab, const ScTableProtection* pProtect)
1851cdf0e10cSrcweir {
1852cdf0e10cSrcweir if (!ValidTab(nTab))
1853cdf0e10cSrcweir return;
1854cdf0e10cSrcweir
1855cdf0e10cSrcweir pTab[nTab]->SetProtection(pProtect);
1856cdf0e10cSrcweir }
1857cdf0e10cSrcweir
CopyTabProtection(SCTAB nTabSrc,SCTAB nTabDest)1858cdf0e10cSrcweir void ScDocument::CopyTabProtection(SCTAB nTabSrc, SCTAB nTabDest)
1859cdf0e10cSrcweir {
1860cdf0e10cSrcweir if (!ValidTab(nTabSrc) || !ValidTab(nTabDest))
1861cdf0e10cSrcweir return;
1862cdf0e10cSrcweir
1863cdf0e10cSrcweir pTab[nTabDest]->SetProtection( pTab[nTabSrc]->GetProtection() );
1864cdf0e10cSrcweir }
1865cdf0e10cSrcweir
GetDocOptions() const1866cdf0e10cSrcweir const ScDocOptions& ScDocument::GetDocOptions() const
1867cdf0e10cSrcweir {
1868cdf0e10cSrcweir DBG_ASSERT( pDocOptions, "No DocOptions! :-(" );
1869cdf0e10cSrcweir return *pDocOptions;
1870cdf0e10cSrcweir }
1871cdf0e10cSrcweir
SetDocOptions(const ScDocOptions & rOpt)1872cdf0e10cSrcweir void ScDocument::SetDocOptions( const ScDocOptions& rOpt )
1873cdf0e10cSrcweir {
1874cdf0e10cSrcweir DBG_ASSERT( pDocOptions, "No DocOptions! :-(" );
1875cdf0e10cSrcweir *pDocOptions = rOpt;
1876cdf0e10cSrcweir
1877cdf0e10cSrcweir xPoolHelper->SetFormTableOpt(rOpt);
1878cdf0e10cSrcweir }
1879cdf0e10cSrcweir
GetViewOptions() const1880cdf0e10cSrcweir const ScViewOptions& ScDocument::GetViewOptions() const
1881cdf0e10cSrcweir {
1882cdf0e10cSrcweir DBG_ASSERT( pViewOptions, "No ViewOptions! :-(" );
1883cdf0e10cSrcweir return *pViewOptions;
1884cdf0e10cSrcweir }
1885cdf0e10cSrcweir
SetViewOptions(const ScViewOptions & rOpt)1886cdf0e10cSrcweir void ScDocument::SetViewOptions( const ScViewOptions& rOpt )
1887cdf0e10cSrcweir {
1888cdf0e10cSrcweir DBG_ASSERT( pViewOptions, "No ViewOptions! :-(" );
1889cdf0e10cSrcweir *pViewOptions = rOpt;
1890cdf0e10cSrcweir }
1891cdf0e10cSrcweir
GetLanguage(LanguageType & rLatin,LanguageType & rCjk,LanguageType & rCtl) const1892cdf0e10cSrcweir void ScDocument::GetLanguage( LanguageType& rLatin, LanguageType& rCjk, LanguageType& rCtl ) const
1893cdf0e10cSrcweir {
1894cdf0e10cSrcweir rLatin = eLanguage;
1895cdf0e10cSrcweir rCjk = eCjkLanguage;
1896cdf0e10cSrcweir rCtl = eCtlLanguage;
1897cdf0e10cSrcweir }
1898cdf0e10cSrcweir
SetLanguage(LanguageType eLatin,LanguageType eCjk,LanguageType eCtl)1899cdf0e10cSrcweir void ScDocument::SetLanguage( LanguageType eLatin, LanguageType eCjk, LanguageType eCtl )
1900cdf0e10cSrcweir {
1901cdf0e10cSrcweir eLanguage = eLatin;
1902cdf0e10cSrcweir eCjkLanguage = eCjk;
1903cdf0e10cSrcweir eCtlLanguage = eCtl;
1904cdf0e10cSrcweir if ( xPoolHelper.isValid() )
1905cdf0e10cSrcweir {
1906cdf0e10cSrcweir ScDocumentPool* pPool = xPoolHelper->GetDocPool();
1907cdf0e10cSrcweir pPool->SetPoolDefaultItem( SvxLanguageItem( eLanguage, ATTR_FONT_LANGUAGE ) );
1908cdf0e10cSrcweir pPool->SetPoolDefaultItem( SvxLanguageItem( eCjkLanguage, ATTR_CJK_FONT_LANGUAGE ) );
1909cdf0e10cSrcweir pPool->SetPoolDefaultItem( SvxLanguageItem( eCtlLanguage, ATTR_CTL_FONT_LANGUAGE ) );
1910cdf0e10cSrcweir }
1911cdf0e10cSrcweir
1912cdf0e10cSrcweir UpdateDrawLanguages(); // set edit engine defaults in drawing layer pool
1913cdf0e10cSrcweir }
1914cdf0e10cSrcweir
GetMMRect(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab)1915cdf0e10cSrcweir Rectangle ScDocument::GetMMRect( SCCOL nStartCol, SCROW nStartRow,
1916cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
1917cdf0e10cSrcweir {
1918cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
1919cdf0e10cSrcweir {
1920cdf0e10cSrcweir DBG_ERROR("GetMMRect: falsche Tabelle");
1921cdf0e10cSrcweir return Rectangle(0,0,0,0);
1922cdf0e10cSrcweir }
1923cdf0e10cSrcweir
1924cdf0e10cSrcweir SCCOL i;
1925cdf0e10cSrcweir Rectangle aRect;
1926cdf0e10cSrcweir
1927cdf0e10cSrcweir for (i=0; i<nStartCol; i++)
1928cdf0e10cSrcweir aRect.Left() += GetColWidth(i,nTab);
1929cdf0e10cSrcweir aRect.Top() += GetRowHeight( 0, nStartRow-1, nTab);
1930cdf0e10cSrcweir
1931cdf0e10cSrcweir aRect.Right() = aRect.Left();
1932cdf0e10cSrcweir aRect.Bottom() = aRect.Top();
1933cdf0e10cSrcweir
1934cdf0e10cSrcweir for (i=nStartCol; i<=nEndCol; i++)
1935cdf0e10cSrcweir aRect.Right() += GetColWidth(i,nTab);
1936cdf0e10cSrcweir aRect.Bottom() += GetRowHeight( nStartRow, nEndRow, nTab);
1937cdf0e10cSrcweir
1938cdf0e10cSrcweir aRect.Left() = (long)(aRect.Left() * HMM_PER_TWIPS);
1939cdf0e10cSrcweir aRect.Right() = (long)(aRect.Right() * HMM_PER_TWIPS);
1940cdf0e10cSrcweir aRect.Top() = (long)(aRect.Top() * HMM_PER_TWIPS);
1941cdf0e10cSrcweir aRect.Bottom() = (long)(aRect.Bottom() * HMM_PER_TWIPS);
1942cdf0e10cSrcweir
1943cdf0e10cSrcweir if ( IsNegativePage( nTab ) )
1944cdf0e10cSrcweir ScDrawLayer::MirrorRectRTL( aRect );
1945cdf0e10cSrcweir
1946cdf0e10cSrcweir return aRect;
1947cdf0e10cSrcweir }
1948cdf0e10cSrcweir
SetExtDocOptions(ScExtDocOptions * pNewOptions)1949cdf0e10cSrcweir void ScDocument::SetExtDocOptions( ScExtDocOptions* pNewOptions )
1950cdf0e10cSrcweir {
1951cdf0e10cSrcweir delete pExtDocOptions;
1952cdf0e10cSrcweir pExtDocOptions = pNewOptions;
1953cdf0e10cSrcweir }
1954cdf0e10cSrcweir
DoMergeContents(SCTAB nTab,SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow)1955cdf0e10cSrcweir void ScDocument::DoMergeContents( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
1956cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow )
1957cdf0e10cSrcweir {
1958cdf0e10cSrcweir String aEmpty;
1959cdf0e10cSrcweir String aTotal;
1960cdf0e10cSrcweir String aCellStr;
1961cdf0e10cSrcweir SCCOL nCol;
1962cdf0e10cSrcweir SCROW nRow;
1963cdf0e10cSrcweir for (nRow=nStartRow; nRow<=nEndRow; nRow++)
1964cdf0e10cSrcweir for (nCol=nStartCol; nCol<=nEndCol; nCol++)
1965cdf0e10cSrcweir {
1966cdf0e10cSrcweir GetString(nCol,nRow,nTab,aCellStr);
1967cdf0e10cSrcweir if (aCellStr.Len())
1968cdf0e10cSrcweir {
1969cdf0e10cSrcweir if (aTotal.Len())
1970cdf0e10cSrcweir aTotal += ' ';
1971cdf0e10cSrcweir aTotal += aCellStr;
1972cdf0e10cSrcweir }
1973cdf0e10cSrcweir if (nCol != nStartCol || nRow != nStartRow)
1974cdf0e10cSrcweir SetString(nCol,nRow,nTab,aEmpty);
1975cdf0e10cSrcweir }
1976cdf0e10cSrcweir
1977cdf0e10cSrcweir SetString(nStartCol,nStartRow,nTab,aTotal);
1978cdf0e10cSrcweir }
1979cdf0e10cSrcweir
DoMerge(SCTAB nTab,SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,bool bDeleteCaptions)1980cdf0e10cSrcweir void ScDocument::DoMerge( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
1981cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, bool bDeleteCaptions )
1982cdf0e10cSrcweir {
1983cdf0e10cSrcweir ScMergeAttr aAttr( nEndCol-nStartCol+1, nEndRow-nStartRow+1 );
1984cdf0e10cSrcweir ApplyAttr( nStartCol, nStartRow, nTab, aAttr );
1985cdf0e10cSrcweir
1986cdf0e10cSrcweir if ( nEndCol > nStartCol )
1987cdf0e10cSrcweir ApplyFlagsTab( nStartCol+1, nStartRow, nEndCol, nStartRow, nTab, SC_MF_HOR );
1988cdf0e10cSrcweir if ( nEndRow > nStartRow )
1989cdf0e10cSrcweir ApplyFlagsTab( nStartCol, nStartRow+1, nStartCol, nEndRow, nTab, SC_MF_VER );
1990cdf0e10cSrcweir if ( nEndCol > nStartCol && nEndRow > nStartRow )
1991cdf0e10cSrcweir ApplyFlagsTab( nStartCol+1, nStartRow+1, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
1992cdf0e10cSrcweir
1993cdf0e10cSrcweir // remove all covered notes (removed captions are collected by drawing undo if active)
1994cdf0e10cSrcweir sal_uInt16 nDelFlag = IDF_NOTE | (bDeleteCaptions ? 0 : IDF_NOCAPTIONS);
1995cdf0e10cSrcweir if( nStartCol < nEndCol )
1996cdf0e10cSrcweir DeleteAreaTab( nStartCol + 1, nStartRow, nEndCol, nStartRow, nTab, nDelFlag );
1997cdf0e10cSrcweir if( nStartRow < nEndRow )
1998cdf0e10cSrcweir DeleteAreaTab( nStartCol, nStartRow + 1, nEndCol, nEndRow, nTab, nDelFlag );
1999cdf0e10cSrcweir }
2000cdf0e10cSrcweir
RemoveMerge(SCCOL nCol,SCROW nRow,SCTAB nTab)2001cdf0e10cSrcweir void ScDocument::RemoveMerge( SCCOL nCol, SCROW nRow, SCTAB nTab )
2002cdf0e10cSrcweir {
2003cdf0e10cSrcweir const ScMergeAttr* pAttr = (const ScMergeAttr*)
2004cdf0e10cSrcweir GetAttr( nCol, nRow, nTab, ATTR_MERGE );
2005cdf0e10cSrcweir
2006cdf0e10cSrcweir if ( pAttr->GetColMerge() <= 1 && pAttr->GetRowMerge() <= 1 )
2007cdf0e10cSrcweir return;
2008cdf0e10cSrcweir
2009cdf0e10cSrcweir SCCOL nEndCol = nCol + pAttr->GetColMerge() - 1;
2010cdf0e10cSrcweir SCROW nEndRow = nRow + pAttr->GetRowMerge() - 1;
2011cdf0e10cSrcweir
2012cdf0e10cSrcweir RemoveFlagsTab( nCol, nRow, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
2013cdf0e10cSrcweir
2014cdf0e10cSrcweir const ScMergeAttr* pDefAttr = (const ScMergeAttr*)
2015cdf0e10cSrcweir &xPoolHelper->GetDocPool()->GetDefaultItem( ATTR_MERGE );
2016cdf0e10cSrcweir ApplyAttr( nCol, nRow, nTab, *pDefAttr );
2017cdf0e10cSrcweir }
2018cdf0e10cSrcweir
ExtendPrintArea(OutputDevice * pDev,SCTAB nTab,SCCOL nStartCol,SCROW nStartRow,SCCOL & rEndCol,SCROW nEndRow)2019cdf0e10cSrcweir void ScDocument::ExtendPrintArea( OutputDevice* pDev, SCTAB nTab,
2020cdf0e10cSrcweir SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow )
2021cdf0e10cSrcweir {
2022cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
2023cdf0e10cSrcweir pTab[nTab]->ExtendPrintArea( pDev, nStartCol, nStartRow, rEndCol, nEndRow );
2024cdf0e10cSrcweir }
2025cdf0e10cSrcweir
IncSizeRecalcLevel(SCTAB nTab)2026cdf0e10cSrcweir void ScDocument::IncSizeRecalcLevel( SCTAB nTab )
2027cdf0e10cSrcweir {
2028cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
2029cdf0e10cSrcweir pTab[nTab]->IncRecalcLevel();
2030cdf0e10cSrcweir }
2031cdf0e10cSrcweir
DecSizeRecalcLevel(SCTAB nTab,bool bUpdateNoteCaptionPos)2032cdf0e10cSrcweir void ScDocument::DecSizeRecalcLevel( SCTAB nTab, bool bUpdateNoteCaptionPos )
2033cdf0e10cSrcweir {
2034cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
2035cdf0e10cSrcweir pTab[nTab]->DecRecalcLevel( bUpdateNoteCaptionPos );
2036cdf0e10cSrcweir }
2037cdf0e10cSrcweir
2038cdf0e10cSrcweir // Wang Xu Ming -- 2009-8-17
2039cdf0e10cSrcweir // DataPilot Migration - Cache&&Performance
GetDPObjectCache(long nID)2040cdf0e10cSrcweir ScDPTableDataCache* ScDocument::GetDPObjectCache( long nID )
2041cdf0e10cSrcweir {
2042cdf0e10cSrcweir for ( std::list<ScDPTableDataCache*>::iterator iter = m_listDPObjectsCaches.begin(); iter!=m_listDPObjectsCaches.end(); iter++ )
2043cdf0e10cSrcweir { //
2044cdf0e10cSrcweir if ( nID == (*iter)->GetId() )
2045cdf0e10cSrcweir return *iter;
2046cdf0e10cSrcweir }
2047cdf0e10cSrcweir return NULL;
2048cdf0e10cSrcweir }
2049cdf0e10cSrcweir
GetUsedDPObjectCache(ScRange rRange)2050cdf0e10cSrcweir ScDPTableDataCache* ScDocument::GetUsedDPObjectCache ( ScRange rRange )
2051cdf0e10cSrcweir {
2052cdf0e10cSrcweir ScDPTableDataCache* pCache = NULL;
2053cdf0e10cSrcweir sal_uInt16 nCount = GetDPCollection()->GetCount();
2054cdf0e10cSrcweir for ( short i=nCount-1; i>=0 ; i--)
2055cdf0e10cSrcweir {
2056cdf0e10cSrcweir if ( const ScSheetSourceDesc* pUsedSheetDesc = (*pDPCollection)[i]->GetSheetDesc() )
2057cdf0e10cSrcweir if ( rRange == pUsedSheetDesc->aSourceRange )
2058cdf0e10cSrcweir {
2059cdf0e10cSrcweir long nID = (*pDPCollection)[i]->GetCacheId();
2060cdf0e10cSrcweir if ( nID >= 0 )
2061cdf0e10cSrcweir pCache= GetDPObjectCache( nID );
2062cdf0e10cSrcweir if ( pCache )
2063cdf0e10cSrcweir return pCache;
2064cdf0e10cSrcweir }
2065cdf0e10cSrcweir }
2066cdf0e10cSrcweir return pCache;
2067cdf0e10cSrcweir }
2068cdf0e10cSrcweir
AddDPObjectCache(ScDPTableDataCache * pData)2069cdf0e10cSrcweir long ScDocument::AddDPObjectCache( ScDPTableDataCache* pData )
2070cdf0e10cSrcweir {
2071cdf0e10cSrcweir if ( pData->GetId() < 0 )
2072cdf0e10cSrcweir { //create a id for it
2073cdf0e10cSrcweir pData->SetId( GetNewDPObjectCacheId() );
2074cdf0e10cSrcweir }
2075cdf0e10cSrcweir m_listDPObjectsCaches.push_back( pData );
2076cdf0e10cSrcweir return pData->GetId();
2077cdf0e10cSrcweir }
2078cdf0e10cSrcweir
GetNewDPObjectCacheId()2079cdf0e10cSrcweir long ScDocument::GetNewDPObjectCacheId()
2080cdf0e10cSrcweir {
2081cdf0e10cSrcweir long nID = 0;
2082cdf0e10cSrcweir
2083cdf0e10cSrcweir bool bFound = false;
2084cdf0e10cSrcweir std::list<ScDPTableDataCache*>::iterator iter;
2085cdf0e10cSrcweir do {
2086cdf0e10cSrcweir for ( iter = m_listDPObjectsCaches.begin(); iter!=m_listDPObjectsCaches.end(); iter++ )
2087cdf0e10cSrcweir { //Get a new Id
2088cdf0e10cSrcweir if ( nID == (*iter)->GetId() )
2089cdf0e10cSrcweir {
2090cdf0e10cSrcweir nID++;
2091cdf0e10cSrcweir bFound = true;
2092cdf0e10cSrcweir break;
2093cdf0e10cSrcweir }
2094cdf0e10cSrcweir }
2095cdf0e10cSrcweir if ( iter == m_listDPObjectsCaches.end() )
2096cdf0e10cSrcweir bFound = false;
2097cdf0e10cSrcweir } while ( bFound );
2098cdf0e10cSrcweir
2099cdf0e10cSrcweir return nID;
2100cdf0e10cSrcweir }
2101cdf0e10cSrcweir
RemoveDPObjectCache(long nID)2102cdf0e10cSrcweir void ScDocument::RemoveDPObjectCache( long nID )
2103cdf0e10cSrcweir {
2104cdf0e10cSrcweir for ( std::list<ScDPTableDataCache*>::iterator iter = m_listDPObjectsCaches.begin(); iter!=m_listDPObjectsCaches.end(); iter++ )
2105cdf0e10cSrcweir {
2106cdf0e10cSrcweir if ( nID == (*iter)->GetId() )
2107cdf0e10cSrcweir {
2108cdf0e10cSrcweir ScDPTableDataCache* pCache = *iter;
2109cdf0e10cSrcweir m_listDPObjectsCaches.erase( iter );
2110cdf0e10cSrcweir delete pCache;
2111cdf0e10cSrcweir break;
2112cdf0e10cSrcweir }
2113cdf0e10cSrcweir }
2114cdf0e10cSrcweir
2115cdf0e10cSrcweir }
2116cdf0e10cSrcweir
RemoveUnusedDPObjectCaches()2117cdf0e10cSrcweir void ScDocument::RemoveUnusedDPObjectCaches()
2118cdf0e10cSrcweir {
2119cdf0e10cSrcweir for ( std::list<ScDPTableDataCache*>::iterator iter = m_listDPObjectsCaches.begin(); iter!=m_listDPObjectsCaches.end(); )
2120cdf0e10cSrcweir {
2121cdf0e10cSrcweir long nID = (*iter)->GetId();
2122cdf0e10cSrcweir sal_uInt16 nCount = GetDPCollection()->GetCount();
2123cdf0e10cSrcweir sal_uInt16 i ;
2124cdf0e10cSrcweir for ( i=0; i<nCount; i++)
2125cdf0e10cSrcweir {
2126cdf0e10cSrcweir if ( nID == (*pDPCollection)[i]->GetCacheId() )
2127cdf0e10cSrcweir break;
2128cdf0e10cSrcweir }
2129cdf0e10cSrcweir if ( i == nCount )
2130cdf0e10cSrcweir {
2131cdf0e10cSrcweir ScDPTableDataCache* pCache = *iter;
2132cdf0e10cSrcweir iter = m_listDPObjectsCaches.erase( iter );
2133cdf0e10cSrcweir delete pCache;
2134cdf0e10cSrcweir continue;
2135cdf0e10cSrcweir }
2136cdf0e10cSrcweir ++iter;
2137cdf0e10cSrcweir }
2138cdf0e10cSrcweir }
2139cdf0e10cSrcweir
GetUsedDPObjectCache(std::list<ScDPTableDataCache * > & usedlist)2140cdf0e10cSrcweir void ScDocument::GetUsedDPObjectCache( std::list<ScDPTableDataCache*>& usedlist )
2141cdf0e10cSrcweir {
2142cdf0e10cSrcweir for ( std::list<ScDPTableDataCache*>::iterator iter = m_listDPObjectsCaches.begin(); iter!=m_listDPObjectsCaches.end(); iter++ )
2143cdf0e10cSrcweir {
2144cdf0e10cSrcweir long nID = (*iter)->GetId();
2145cdf0e10cSrcweir sal_uInt16 nCount = GetDPCollection()->GetCount();
2146cdf0e10cSrcweir sal_uInt16 i=0;
2147cdf0e10cSrcweir for ( i=0; i<nCount; i++)
2148cdf0e10cSrcweir if ( nID == (*pDPCollection)[i]->GetCacheId() )
2149cdf0e10cSrcweir break;
2150cdf0e10cSrcweir if ( i != nCount )
2151cdf0e10cSrcweir usedlist.push_back( *iter );
2152cdf0e10cSrcweir }
2153cdf0e10cSrcweir }
2154cdf0e10cSrcweir // End Comments
21558f4c7c28SSteve Yin
GetPatternCount(SCTAB nTab,SCCOL nCol)21568f4c7c28SSteve Yin SCSIZE ScDocument::GetPatternCount( SCTAB nTab, SCCOL nCol )
21578f4c7c28SSteve Yin {
21588f4c7c28SSteve Yin if( ValidTab(nTab) && pTab[nTab] )
21598f4c7c28SSteve Yin return pTab[nTab]->GetPatternCount( nCol );
21608f4c7c28SSteve Yin else
21618f4c7c28SSteve Yin return 0;
21628f4c7c28SSteve Yin }
21638f4c7c28SSteve Yin
GetPatternCount(SCTAB nTab,SCCOL nCol,SCROW nRw1,SCROW nRw2)21648f4c7c28SSteve Yin SCSIZE ScDocument::GetPatternCount( SCTAB nTab, SCCOL nCol, SCROW nRw1, SCROW nRw2 )
21658f4c7c28SSteve Yin {
21668f4c7c28SSteve Yin if( ValidTab(nTab) && pTab[nTab] )
21678f4c7c28SSteve Yin return pTab[nTab]->GetPatternCount( nCol, nRw1, nRw2 );
21688f4c7c28SSteve Yin else
21698f4c7c28SSteve Yin return 0;
21708f4c7c28SSteve Yin }
21718f4c7c28SSteve Yin
ReservedPatternCount(SCTAB nTab,SCCOL nCol,SCSIZE nReserved)21728f4c7c28SSteve Yin bool ScDocument::ReservedPatternCount( SCTAB nTab, SCCOL nCol, SCSIZE nReserved )
21738f4c7c28SSteve Yin {
21748f4c7c28SSteve Yin if( ValidTab(nTab) && pTab[nTab] )
21758f4c7c28SSteve Yin return pTab[nTab]->ReservedPatternCount( nCol, nReserved );
21768f4c7c28SSteve Yin else
21778f4c7c28SSteve Yin return false;
21788f4c7c28SSteve Yin }
2179