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 #define _ZFORLIST_DECLARE_TABLE
30cdf0e10cSrcweir #include "scitems.hxx"
31cdf0e10cSrcweir #include <editeng/eeitem.hxx>
32cdf0e10cSrcweir
33cdf0e10cSrcweir #include <editeng/boxitem.hxx>
34cdf0e10cSrcweir #include <editeng/frmdiritem.hxx>
35cdf0e10cSrcweir #include <svx/pageitem.hxx>
36cdf0e10cSrcweir #include <editeng/editeng.hxx>
37cdf0e10cSrcweir #include <svx/svditer.hxx>
38cdf0e10cSrcweir #include <svx/svdpage.hxx>
39cdf0e10cSrcweir #include <svx/svdocapt.hxx>
40cdf0e10cSrcweir #include <sfx2/app.hxx>
41cdf0e10cSrcweir #include <sfx2/objsh.hxx>
42cdf0e10cSrcweir #include <svl/poolcach.hxx>
43cdf0e10cSrcweir #include <unotools/saveopt.hxx>
44cdf0e10cSrcweir #include <svl/zforlist.hxx>
45cdf0e10cSrcweir #include <unotools/charclass.hxx>
46cdf0e10cSrcweir #include <unotools/transliterationwrapper.hxx>
47cdf0e10cSrcweir #include <tools/tenccvt.hxx>
4814af77b6SArmin Le Grand #include <svx/sdrundomanager.hxx>
49cdf0e10cSrcweir
50cdf0e10cSrcweir #include <com/sun/star/text/WritingMode2.hpp>
51cdf0e10cSrcweir #include <com/sun/star/script/vba/XVBACompatibility.hpp>
52cdf0e10cSrcweir #include <com/sun/star/sheet/TablePageBreakData.hpp>
53cdf0e10cSrcweir
54cdf0e10cSrcweir #include "document.hxx"
55cdf0e10cSrcweir #include "table.hxx"
56cdf0e10cSrcweir #include "attrib.hxx"
57cdf0e10cSrcweir #include "attarray.hxx"
58cdf0e10cSrcweir #include "markarr.hxx"
59cdf0e10cSrcweir #include "patattr.hxx"
60cdf0e10cSrcweir #include "rangenam.hxx"
61cdf0e10cSrcweir #include "poolhelp.hxx"
62cdf0e10cSrcweir #include "docpool.hxx"
63cdf0e10cSrcweir #include "stlpool.hxx"
64cdf0e10cSrcweir #include "stlsheet.hxx"
65cdf0e10cSrcweir #include "globstr.hrc"
66cdf0e10cSrcweir #include "rechead.hxx"
67cdf0e10cSrcweir #include "dbcolect.hxx"
68cdf0e10cSrcweir #include "pivot.hxx"
69cdf0e10cSrcweir #include "chartlis.hxx"
70cdf0e10cSrcweir #include "rangelst.hxx"
71cdf0e10cSrcweir #include "markdata.hxx"
72cdf0e10cSrcweir #include "drwlayer.hxx"
73cdf0e10cSrcweir #include "conditio.hxx"
74cdf0e10cSrcweir #include "validat.hxx"
75cdf0e10cSrcweir #include "prnsave.hxx"
76cdf0e10cSrcweir #include "chgtrack.hxx"
77cdf0e10cSrcweir #include "sc.hrc"
78cdf0e10cSrcweir #include "scresid.hxx"
79cdf0e10cSrcweir #include "hints.hxx"
80cdf0e10cSrcweir #include "detdata.hxx"
81cdf0e10cSrcweir #include "cell.hxx"
82cdf0e10cSrcweir #include "dpobject.hxx"
83cdf0e10cSrcweir #include "detfunc.hxx" // for UpdateAllComments
84cdf0e10cSrcweir #include "scmod.hxx"
85cdf0e10cSrcweir #include "dociter.hxx"
86cdf0e10cSrcweir #include "progress.hxx"
87cdf0e10cSrcweir #include "autonamecache.hxx"
88cdf0e10cSrcweir #include "bcaslot.hxx"
89cdf0e10cSrcweir #include "postit.hxx"
90cdf0e10cSrcweir #include "externalrefmgr.hxx"
91cdf0e10cSrcweir #include "tabprotection.hxx"
92cdf0e10cSrcweir #include "clipparam.hxx"
93cdf0e10cSrcweir
94cdf0e10cSrcweir #include <map>
95cdf0e10cSrcweir #include <limits>
96cdf0e10cSrcweir
97cdf0e10cSrcweir namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
98cdf0e10cSrcweir using ::com::sun::star::uno::Sequence;
99cdf0e10cSrcweir using ::com::sun::star::sheet::TablePageBreakData;
100cdf0e10cSrcweir using ::std::set;
101cdf0e10cSrcweir
102cdf0e10cSrcweir struct ScDefaultAttr
103cdf0e10cSrcweir {
104cdf0e10cSrcweir const ScPatternAttr* pAttr;
105cdf0e10cSrcweir SCROW nFirst;
106cdf0e10cSrcweir SCSIZE nCount;
ScDefaultAttrScDefaultAttr107cdf0e10cSrcweir ScDefaultAttr(const ScPatternAttr* pPatAttr) : pAttr(pPatAttr), nFirst(0), nCount(0) {}
108cdf0e10cSrcweir };
109cdf0e10cSrcweir
110cdf0e10cSrcweir struct ScLessDefaultAttr
111cdf0e10cSrcweir {
operator ()ScLessDefaultAttr112cdf0e10cSrcweir sal_Bool operator() (const ScDefaultAttr& rValue1, const ScDefaultAttr& rValue2) const
113cdf0e10cSrcweir {
114cdf0e10cSrcweir return rValue1.pAttr < rValue2.pAttr;
115cdf0e10cSrcweir }
116cdf0e10cSrcweir };
117cdf0e10cSrcweir
118cdf0e10cSrcweir typedef std::set<ScDefaultAttr, ScLessDefaultAttr> ScDefaultAttrSet;
119cdf0e10cSrcweir
MakeTable(SCTAB nTab,bool _bNeedsNameCheck)120cdf0e10cSrcweir void ScDocument::MakeTable( SCTAB nTab,bool _bNeedsNameCheck )
121cdf0e10cSrcweir {
122cdf0e10cSrcweir if ( ValidTab(nTab) && !pTab[nTab] )
123cdf0e10cSrcweir {
124cdf0e10cSrcweir String aString = ScGlobal::GetRscString(STR_TABLE_DEF); //"Tabelle"
125cdf0e10cSrcweir aString += String::CreateFromInt32(nTab+1);
126cdf0e10cSrcweir if ( _bNeedsNameCheck )
127cdf0e10cSrcweir CreateValidTabName( aString ); // keine doppelten
128cdf0e10cSrcweir
129cdf0e10cSrcweir pTab[nTab] = new ScTable(this, nTab, aString);
130cdf0e10cSrcweir pTab[nTab]->SetLoadingMedium(bLoadingMedium);
131cdf0e10cSrcweir ++nMaxTableNumber;
132cdf0e10cSrcweir }
133cdf0e10cSrcweir }
134cdf0e10cSrcweir
135cdf0e10cSrcweir
HasTable(SCTAB nTab) const136cdf0e10cSrcweir sal_Bool ScDocument::HasTable( SCTAB nTab ) const
137cdf0e10cSrcweir {
138cdf0e10cSrcweir if (VALIDTAB(nTab))
139cdf0e10cSrcweir if (pTab[nTab])
140cdf0e10cSrcweir return sal_True;
141cdf0e10cSrcweir
142cdf0e10cSrcweir return sal_False;
143cdf0e10cSrcweir }
144cdf0e10cSrcweir
145cdf0e10cSrcweir
GetName(SCTAB nTab,String & rName) const146cdf0e10cSrcweir sal_Bool ScDocument::GetName( SCTAB nTab, String& rName ) const
147cdf0e10cSrcweir {
148cdf0e10cSrcweir if (VALIDTAB(nTab))
149cdf0e10cSrcweir if (pTab[nTab])
150cdf0e10cSrcweir {
151cdf0e10cSrcweir pTab[nTab]->GetName( rName );
152cdf0e10cSrcweir return sal_True;
153cdf0e10cSrcweir }
154cdf0e10cSrcweir rName.Erase();
155cdf0e10cSrcweir return sal_False;
156cdf0e10cSrcweir }
157cdf0e10cSrcweir
SetCodeName(SCTAB nTab,const String & rName)158cdf0e10cSrcweir sal_Bool ScDocument::SetCodeName( SCTAB nTab, const String& rName )
159cdf0e10cSrcweir {
160cdf0e10cSrcweir if (VALIDTAB(nTab))
161cdf0e10cSrcweir {
162cdf0e10cSrcweir if (pTab[nTab])
163cdf0e10cSrcweir {
164cdf0e10cSrcweir pTab[nTab]->SetCodeName( rName );
165cdf0e10cSrcweir return sal_True;
166cdf0e10cSrcweir }
167cdf0e10cSrcweir }
168cdf0e10cSrcweir OSL_TRACE( "**** can't set code name %s", rtl::OUStringToOString( rName, RTL_TEXTENCODING_UTF8 ).getStr() );
169cdf0e10cSrcweir return sal_False;
170cdf0e10cSrcweir }
171cdf0e10cSrcweir
GetCodeName(SCTAB nTab,String & rName) const172cdf0e10cSrcweir sal_Bool ScDocument::GetCodeName( SCTAB nTab, String& rName ) const
173cdf0e10cSrcweir {
174cdf0e10cSrcweir if (VALIDTAB(nTab))
175cdf0e10cSrcweir if (pTab[nTab])
176cdf0e10cSrcweir {
177cdf0e10cSrcweir pTab[nTab]->GetCodeName( rName );
178cdf0e10cSrcweir return sal_True;
179cdf0e10cSrcweir }
180cdf0e10cSrcweir rName.Erase();
181cdf0e10cSrcweir return sal_False;
182cdf0e10cSrcweir }
183cdf0e10cSrcweir
184cdf0e10cSrcweir
GetTable(const String & rName,SCTAB & rTab) const185cdf0e10cSrcweir sal_Bool ScDocument::GetTable( const String& rName, SCTAB& rTab ) const
186cdf0e10cSrcweir {
187cdf0e10cSrcweir String aUpperName = rName;
188cdf0e10cSrcweir ScGlobal::pCharClass->toUpper(aUpperName);
189cdf0e10cSrcweir
190cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
191cdf0e10cSrcweir if (pTab[i])
192cdf0e10cSrcweir {
193cdf0e10cSrcweir if ( pTab[i]->GetUpperName() == aUpperName )
194cdf0e10cSrcweir {
195cdf0e10cSrcweir rTab = i;
196cdf0e10cSrcweir return sal_True;
197cdf0e10cSrcweir }
198cdf0e10cSrcweir }
199cdf0e10cSrcweir rTab = 0;
200cdf0e10cSrcweir return sal_False;
201cdf0e10cSrcweir }
202cdf0e10cSrcweir
GetTableByIndex(sal_Int32 nIndex)2030deba7fbSSteve Yin ScTable* ScDocument::GetTableByIndex(sal_Int32 nIndex)
2040deba7fbSSteve Yin {
2050deba7fbSSteve Yin if ( nIndex <= MAXTAB && nIndex >= 0)
2060deba7fbSSteve Yin return pTab[nIndex];
2070deba7fbSSteve Yin
2080deba7fbSSteve Yin return NULL;
2090deba7fbSSteve Yin }
210cdf0e10cSrcweir
ValidTabName(const String & rName) const211cdf0e10cSrcweir sal_Bool ScDocument::ValidTabName( const String& rName ) const
212cdf0e10cSrcweir {
213cdf0e10cSrcweir xub_StrLen nLen = rName.Len();
214cdf0e10cSrcweir if (!nLen)
215cdf0e10cSrcweir return false;
216cdf0e10cSrcweir
217cdf0e10cSrcweir #if 1
218cdf0e10cSrcweir // Restrict sheet names to what Excel accepts.
219cdf0e10cSrcweir /* TODO: We may want to remove this restriction for full ODFF compliance.
220cdf0e10cSrcweir * Merely loading and calculating ODF documents using these characters in
221cdf0e10cSrcweir * sheet names is not affected by this, but all sheet name editing and
222cdf0e10cSrcweir * copying functionality is, maybe falling back to "Sheet4" or similar. */
223cdf0e10cSrcweir for (xub_StrLen i = 0; i < nLen; ++i)
224cdf0e10cSrcweir {
225cdf0e10cSrcweir const sal_Unicode c = rName.GetChar(i);
226cdf0e10cSrcweir switch (c)
227cdf0e10cSrcweir {
228cdf0e10cSrcweir case ':':
229cdf0e10cSrcweir case '\\':
230cdf0e10cSrcweir case '/':
231cdf0e10cSrcweir case '?':
232cdf0e10cSrcweir case '*':
233cdf0e10cSrcweir case '[':
234cdf0e10cSrcweir case ']':
235cdf0e10cSrcweir // these characters are not allowed to match XL's convention.
236cdf0e10cSrcweir return false;
237cdf0e10cSrcweir case '\'':
238cdf0e10cSrcweir if (i == 0 || i == nLen - 1)
239cdf0e10cSrcweir // single quote is not allowed at the first or last
240cdf0e10cSrcweir // character position.
241cdf0e10cSrcweir return false;
242cdf0e10cSrcweir break;
243cdf0e10cSrcweir }
244cdf0e10cSrcweir }
245cdf0e10cSrcweir #endif
246cdf0e10cSrcweir
247cdf0e10cSrcweir return true;
248cdf0e10cSrcweir }
249cdf0e10cSrcweir
250cdf0e10cSrcweir
ValidNewTabName(const String & rName) const251cdf0e10cSrcweir sal_Bool ScDocument::ValidNewTabName( const String& rName ) const
252cdf0e10cSrcweir {
253cdf0e10cSrcweir sal_Bool bValid = ValidTabName(rName);
254cdf0e10cSrcweir for (SCTAB i=0; (i<=MAXTAB) && bValid; i++)
255cdf0e10cSrcweir if (pTab[i])
256cdf0e10cSrcweir {
257cdf0e10cSrcweir String aOldName;
258cdf0e10cSrcweir pTab[i]->GetName(aOldName);
259cdf0e10cSrcweir bValid = !ScGlobal::GetpTransliteration()->isEqual( rName, aOldName );
260cdf0e10cSrcweir }
261cdf0e10cSrcweir return bValid;
262cdf0e10cSrcweir }
263cdf0e10cSrcweir
264cdf0e10cSrcweir
CreateValidTabName(String & rName) const265cdf0e10cSrcweir void ScDocument::CreateValidTabName(String& rName) const
266cdf0e10cSrcweir {
267cdf0e10cSrcweir if ( !ValidTabName(rName) )
268cdf0e10cSrcweir {
269cdf0e10cSrcweir // neu erzeugen
270cdf0e10cSrcweir
271cdf0e10cSrcweir const String aStrTable( ScResId(SCSTR_TABLE) );
272cdf0e10cSrcweir sal_Bool bOk = sal_False;
273cdf0e10cSrcweir
274cdf0e10cSrcweir // vorneweg testen, ob der Prefix als gueltig erkannt wird
275cdf0e10cSrcweir // wenn nicht, nur doppelte vermeiden
276cdf0e10cSrcweir sal_Bool bPrefix = ValidTabName( aStrTable );
277cdf0e10cSrcweir DBG_ASSERT(bPrefix, "ungueltiger Tabellenname");
278cdf0e10cSrcweir SCTAB nDummy;
279cdf0e10cSrcweir
280cdf0e10cSrcweir SCTAB nLoops = 0; // "zur Sicherheit"
281cdf0e10cSrcweir for ( SCTAB i = nMaxTableNumber+1; !bOk && nLoops <= MAXTAB; i++ )
282cdf0e10cSrcweir {
283cdf0e10cSrcweir rName = aStrTable;
284cdf0e10cSrcweir rName += String::CreateFromInt32(i);
285cdf0e10cSrcweir if (bPrefix)
286cdf0e10cSrcweir bOk = ValidNewTabName( rName );
287cdf0e10cSrcweir else
288cdf0e10cSrcweir bOk = !GetTable( rName, nDummy );
289cdf0e10cSrcweir ++nLoops;
290cdf0e10cSrcweir }
291cdf0e10cSrcweir
292cdf0e10cSrcweir DBG_ASSERT(bOk, "kein gueltiger Tabellenname gefunden");
293cdf0e10cSrcweir if ( !bOk )
294cdf0e10cSrcweir rName = aStrTable;
295cdf0e10cSrcweir }
296cdf0e10cSrcweir else
297cdf0e10cSrcweir {
298cdf0e10cSrcweir // uebergebenen Namen ueberpruefen
299cdf0e10cSrcweir
300cdf0e10cSrcweir if ( !ValidNewTabName(rName) )
301cdf0e10cSrcweir {
302cdf0e10cSrcweir SCTAB i = 1;
303cdf0e10cSrcweir String aName;
304cdf0e10cSrcweir do
305cdf0e10cSrcweir {
306cdf0e10cSrcweir i++;
307cdf0e10cSrcweir aName = rName;
308cdf0e10cSrcweir aName += '_';
309cdf0e10cSrcweir aName += String::CreateFromInt32(static_cast<sal_Int32>(i));
310cdf0e10cSrcweir }
311cdf0e10cSrcweir while (!ValidNewTabName(aName) && (i < MAXTAB+1));
312cdf0e10cSrcweir rName = aName;
313cdf0e10cSrcweir }
314cdf0e10cSrcweir }
315cdf0e10cSrcweir }
316cdf0e10cSrcweir
317cdf0e10cSrcweir
InsertTab(SCTAB nPos,const String & rName,sal_Bool bExternalDocument)318cdf0e10cSrcweir sal_Bool ScDocument::InsertTab( SCTAB nPos, const String& rName,
319cdf0e10cSrcweir sal_Bool bExternalDocument )
320cdf0e10cSrcweir {
321cdf0e10cSrcweir SCTAB nTabCount = GetTableCount();
322cdf0e10cSrcweir sal_Bool bValid = ValidTab(nTabCount);
323cdf0e10cSrcweir if ( !bExternalDocument ) // sonst rName == "'Doc'!Tab", vorher pruefen
324cdf0e10cSrcweir bValid = (bValid && ValidNewTabName(rName));
325cdf0e10cSrcweir if (bValid)
326cdf0e10cSrcweir {
327cdf0e10cSrcweir if (nPos == SC_TAB_APPEND || nPos == nTabCount)
328cdf0e10cSrcweir {
329cdf0e10cSrcweir pTab[nTabCount] = new ScTable(this, nTabCount, rName);
330cdf0e10cSrcweir pTab[nTabCount]->SetCodeName( rName );
331cdf0e10cSrcweir ++nMaxTableNumber;
332cdf0e10cSrcweir if ( bExternalDocument )
333cdf0e10cSrcweir pTab[nTabCount]->SetVisible( sal_False );
334cdf0e10cSrcweir }
335cdf0e10cSrcweir else
336cdf0e10cSrcweir {
337cdf0e10cSrcweir if (VALIDTAB(nPos) && (nPos < nTabCount))
338cdf0e10cSrcweir {
339cdf0e10cSrcweir ScRange aRange( 0,0,nPos, MAXCOL,MAXROW,MAXTAB );
340cdf0e10cSrcweir xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
341cdf0e10cSrcweir xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
342cdf0e10cSrcweir pRangeName->UpdateTabRef( nPos, 1 );
343cdf0e10cSrcweir pDBCollection->UpdateReference(
344cdf0e10cSrcweir URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
345cdf0e10cSrcweir if (pDPCollection)
346cdf0e10cSrcweir pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
347cdf0e10cSrcweir if (pDetOpList)
348cdf0e10cSrcweir pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,1 );
349cdf0e10cSrcweir UpdateChartRef( URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
350cdf0e10cSrcweir UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,1 );
351cdf0e10cSrcweir if ( pUnoBroadcaster )
352cdf0e10cSrcweir pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,1 ) );
353cdf0e10cSrcweir
354cdf0e10cSrcweir SCTAB i;
355cdf0e10cSrcweir for (i = 0; i <= MAXTAB; i++)
356cdf0e10cSrcweir if (pTab[i])
357cdf0e10cSrcweir pTab[i]->UpdateInsertTab(nPos);
358cdf0e10cSrcweir
359cdf0e10cSrcweir for (i = nTabCount; i > nPos; i--)
360cdf0e10cSrcweir {
361cdf0e10cSrcweir pTab[i] = pTab[i - 1];
362cdf0e10cSrcweir }
363cdf0e10cSrcweir
364cdf0e10cSrcweir pTab[nPos] = new ScTable(this, nPos, rName);
365cdf0e10cSrcweir pTab[nPos]->SetCodeName( rName );
366cdf0e10cSrcweir ++nMaxTableNumber;
367cdf0e10cSrcweir
368cdf0e10cSrcweir // UpdateBroadcastAreas must be called between UpdateInsertTab,
369cdf0e10cSrcweir // which ends listening, and StartAllListeners, to not modify
370cdf0e10cSrcweir // areas that are to be inserted by starting listeners.
371cdf0e10cSrcweir UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,1);
372cdf0e10cSrcweir for (i = 0; i <= MAXTAB; i++)
373cdf0e10cSrcweir if (pTab[i])
374cdf0e10cSrcweir pTab[i]->UpdateCompile();
375cdf0e10cSrcweir for (i = 0; i <= MAXTAB; i++)
376cdf0e10cSrcweir if (pTab[i])
377cdf0e10cSrcweir pTab[i]->StartAllListeners();
378cdf0e10cSrcweir
379cdf0e10cSrcweir // update conditional formats after table is inserted
380cdf0e10cSrcweir if ( pCondFormList )
381cdf0e10cSrcweir pCondFormList->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
382cdf0e10cSrcweir if ( pValidationList )
383cdf0e10cSrcweir pValidationList->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
384cdf0e10cSrcweir // #81844# sheet names of references are not valid until sheet is inserted
385cdf0e10cSrcweir if ( pChartListenerCollection )
386cdf0e10cSrcweir pChartListenerCollection->UpdateScheduledSeriesRanges();
387cdf0e10cSrcweir
388cdf0e10cSrcweir SetDirty();
389cdf0e10cSrcweir bValid = sal_True;
390cdf0e10cSrcweir }
391cdf0e10cSrcweir else
392cdf0e10cSrcweir bValid = sal_False;
393cdf0e10cSrcweir }
394cdf0e10cSrcweir }
395cdf0e10cSrcweir return bValid;
396cdf0e10cSrcweir }
397cdf0e10cSrcweir
398cdf0e10cSrcweir
DeleteTab(SCTAB nTab,ScDocument * pRefUndoDoc)399cdf0e10cSrcweir sal_Bool ScDocument::DeleteTab( SCTAB nTab, ScDocument* pRefUndoDoc )
400cdf0e10cSrcweir {
401cdf0e10cSrcweir sal_Bool bValid = sal_False;
402cdf0e10cSrcweir if (VALIDTAB(nTab))
403cdf0e10cSrcweir {
404cdf0e10cSrcweir if (pTab[nTab])
405cdf0e10cSrcweir {
406cdf0e10cSrcweir SCTAB nTabCount = GetTableCount();
407cdf0e10cSrcweir if (nTabCount > 1)
408cdf0e10cSrcweir {
409cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
410cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
411cdf0e10cSrcweir ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
412cdf0e10cSrcweir DelBroadcastAreasInRange( aRange );
413cdf0e10cSrcweir
414cdf0e10cSrcweir // #i8180# remove database ranges etc. that are on the deleted tab
415cdf0e10cSrcweir // (restored in undo with ScRefUndoData)
416cdf0e10cSrcweir
417cdf0e10cSrcweir xColNameRanges->DeleteOnTab( nTab );
418cdf0e10cSrcweir xRowNameRanges->DeleteOnTab( nTab );
419cdf0e10cSrcweir pDBCollection->DeleteOnTab( nTab );
420cdf0e10cSrcweir if (pDPCollection)
421cdf0e10cSrcweir pDPCollection->DeleteOnTab( nTab );
422cdf0e10cSrcweir if (pDetOpList)
423cdf0e10cSrcweir pDetOpList->DeleteOnTab( nTab );
424cdf0e10cSrcweir DeleteAreaLinksOnTab( nTab );
425cdf0e10cSrcweir
426cdf0e10cSrcweir // normal reference update
427cdf0e10cSrcweir
428cdf0e10cSrcweir aRange.aEnd.SetTab( MAXTAB );
429cdf0e10cSrcweir xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1 );
430cdf0e10cSrcweir xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1 );
431cdf0e10cSrcweir pRangeName->UpdateTabRef( nTab, 2 );
432cdf0e10cSrcweir pDBCollection->UpdateReference(
433cdf0e10cSrcweir URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 );
434cdf0e10cSrcweir if (pDPCollection)
435cdf0e10cSrcweir pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,-1 );
436cdf0e10cSrcweir if (pDetOpList)
437cdf0e10cSrcweir pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,-1 );
438cdf0e10cSrcweir UpdateChartRef( URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 );
439cdf0e10cSrcweir UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1 );
440cdf0e10cSrcweir if ( pCondFormList )
441cdf0e10cSrcweir pCondFormList->UpdateReference( URM_INSDEL, aRange, 0,0,-1 );
442cdf0e10cSrcweir if ( pValidationList )
443cdf0e10cSrcweir pValidationList->UpdateReference( URM_INSDEL, aRange, 0,0,-1 );
444cdf0e10cSrcweir if ( pUnoBroadcaster )
445cdf0e10cSrcweir pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,-1 ) );
446cdf0e10cSrcweir
447cdf0e10cSrcweir SCTAB i;
448cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
449cdf0e10cSrcweir if (pTab[i])
450cdf0e10cSrcweir pTab[i]->UpdateDeleteTab(nTab,sal_False,
451cdf0e10cSrcweir pRefUndoDoc ? pRefUndoDoc->pTab[i] : 0);
452cdf0e10cSrcweir delete pTab[nTab];
453cdf0e10cSrcweir for (i=nTab + 1; i < nTabCount; i++)
454cdf0e10cSrcweir pTab[i - 1] = pTab[i];
455cdf0e10cSrcweir pTab[nTabCount - 1] = NULL;
456cdf0e10cSrcweir --nMaxTableNumber;
457cdf0e10cSrcweir // UpdateBroadcastAreas must be called between UpdateDeleteTab,
458cdf0e10cSrcweir // which ends listening, and StartAllListeners, to not modify
459cdf0e10cSrcweir // areas that are to be inserted by starting listeners.
460cdf0e10cSrcweir UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1);
461cdf0e10cSrcweir for (i = 0; i <= MAXTAB; i++)
462cdf0e10cSrcweir if (pTab[i])
463cdf0e10cSrcweir pTab[i]->UpdateCompile();
464cdf0e10cSrcweir // Excel-Filter loescht einige Tables waehrend des Ladens,
465cdf0e10cSrcweir // Listener werden erst nach dem Laden aufgesetzt
466cdf0e10cSrcweir if ( !bInsertingFromOtherDoc )
467cdf0e10cSrcweir {
468cdf0e10cSrcweir for (i = 0; i <= MAXTAB; i++)
469cdf0e10cSrcweir if (pTab[i])
470cdf0e10cSrcweir pTab[i]->StartAllListeners();
471cdf0e10cSrcweir SetDirty();
472cdf0e10cSrcweir }
473cdf0e10cSrcweir // #81844# sheet names of references are not valid until sheet is deleted
474cdf0e10cSrcweir pChartListenerCollection->UpdateScheduledSeriesRanges();
475cdf0e10cSrcweir
476cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
477cdf0e10cSrcweir bValid = sal_True;
478cdf0e10cSrcweir }
479cdf0e10cSrcweir }
480cdf0e10cSrcweir }
481cdf0e10cSrcweir return bValid;
482cdf0e10cSrcweir }
483cdf0e10cSrcweir
484cdf0e10cSrcweir
RenameTab(SCTAB nTab,const String & rName,sal_Bool,sal_Bool bExternalDocument)485cdf0e10cSrcweir sal_Bool ScDocument::RenameTab( SCTAB nTab, const String& rName, sal_Bool /* bUpdateRef */,
486cdf0e10cSrcweir sal_Bool bExternalDocument )
487cdf0e10cSrcweir {
488cdf0e10cSrcweir sal_Bool bValid = sal_False;
489cdf0e10cSrcweir SCTAB i;
490cdf0e10cSrcweir if VALIDTAB(nTab)
491cdf0e10cSrcweir if (pTab[nTab])
492cdf0e10cSrcweir {
493cdf0e10cSrcweir if ( bExternalDocument )
494cdf0e10cSrcweir bValid = sal_True; // zusammengesetzter Name
495cdf0e10cSrcweir else
496cdf0e10cSrcweir bValid = ValidTabName(rName);
497cdf0e10cSrcweir for (i=0; (i<=MAXTAB) && bValid; i++)
498cdf0e10cSrcweir if (pTab[i] && (i != nTab))
499cdf0e10cSrcweir {
500cdf0e10cSrcweir String aOldName;
501cdf0e10cSrcweir pTab[i]->GetName(aOldName);
502cdf0e10cSrcweir bValid = !ScGlobal::GetpTransliteration()->isEqual( rName, aOldName );
503cdf0e10cSrcweir }
504cdf0e10cSrcweir if (bValid)
505cdf0e10cSrcweir {
506cdf0e10cSrcweir // #i75258# update charts before renaming, so they can get their live data objects.
507cdf0e10cSrcweir // Once the charts are live, the sheet can be renamed without problems.
508cdf0e10cSrcweir if ( pChartListenerCollection )
509cdf0e10cSrcweir pChartListenerCollection->UpdateChartsContainingTab( nTab );
510cdf0e10cSrcweir pTab[nTab]->SetName(rName);
511cdf0e10cSrcweir
512cdf0e10cSrcweir // If formulas refer to the renamed sheet, the TokenArray remains valid,
513cdf0e10cSrcweir // but the XML stream must be re-generated.
514cdf0e10cSrcweir for (i=0; i<=MAXTAB; ++i)
515cdf0e10cSrcweir if (pTab[i] && pTab[i]->IsStreamValid())
516cdf0e10cSrcweir pTab[i]->SetStreamValid( sal_False );
517cdf0e10cSrcweir }
518cdf0e10cSrcweir }
519cdf0e10cSrcweir return bValid;
520cdf0e10cSrcweir }
521cdf0e10cSrcweir
522cdf0e10cSrcweir
SetVisible(SCTAB nTab,sal_Bool bVisible)523cdf0e10cSrcweir void ScDocument::SetVisible( SCTAB nTab, sal_Bool bVisible )
524cdf0e10cSrcweir {
525cdf0e10cSrcweir if (VALIDTAB(nTab))
526cdf0e10cSrcweir if (pTab[nTab])
527cdf0e10cSrcweir pTab[nTab]->SetVisible(bVisible);
528cdf0e10cSrcweir }
529cdf0e10cSrcweir
530cdf0e10cSrcweir
IsVisible(SCTAB nTab) const531cdf0e10cSrcweir sal_Bool ScDocument::IsVisible( SCTAB nTab ) const
532cdf0e10cSrcweir {
533cdf0e10cSrcweir if (VALIDTAB(nTab))
534cdf0e10cSrcweir if (pTab[nTab])
535cdf0e10cSrcweir return pTab[nTab]->IsVisible();
536cdf0e10cSrcweir
537cdf0e10cSrcweir return sal_False;
538cdf0e10cSrcweir }
539cdf0e10cSrcweir
540cdf0e10cSrcweir
IsStreamValid(SCTAB nTab) const541cdf0e10cSrcweir sal_Bool ScDocument::IsStreamValid( SCTAB nTab ) const
542cdf0e10cSrcweir {
543cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
544cdf0e10cSrcweir return pTab[nTab]->IsStreamValid();
545cdf0e10cSrcweir
546cdf0e10cSrcweir return sal_False;
547cdf0e10cSrcweir }
548cdf0e10cSrcweir
549cdf0e10cSrcweir
SetStreamValid(SCTAB nTab,sal_Bool bSet,sal_Bool bIgnoreLock)550cdf0e10cSrcweir void ScDocument::SetStreamValid( SCTAB nTab, sal_Bool bSet, sal_Bool bIgnoreLock )
551cdf0e10cSrcweir {
552cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
553cdf0e10cSrcweir pTab[nTab]->SetStreamValid( bSet, bIgnoreLock );
554cdf0e10cSrcweir }
555cdf0e10cSrcweir
556cdf0e10cSrcweir
LockStreamValid(bool bLock)557cdf0e10cSrcweir void ScDocument::LockStreamValid( bool bLock )
558cdf0e10cSrcweir {
559cdf0e10cSrcweir mbStreamValidLocked = bLock;
560cdf0e10cSrcweir }
561cdf0e10cSrcweir
562cdf0e10cSrcweir
IsPendingRowHeights(SCTAB nTab) const563cdf0e10cSrcweir sal_Bool ScDocument::IsPendingRowHeights( SCTAB nTab ) const
564cdf0e10cSrcweir {
565cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
566cdf0e10cSrcweir return pTab[nTab]->IsPendingRowHeights();
567cdf0e10cSrcweir
568cdf0e10cSrcweir return sal_False;
569cdf0e10cSrcweir }
570cdf0e10cSrcweir
571cdf0e10cSrcweir
SetPendingRowHeights(SCTAB nTab,sal_Bool bSet)572cdf0e10cSrcweir void ScDocument::SetPendingRowHeights( SCTAB nTab, sal_Bool bSet )
573cdf0e10cSrcweir {
574cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
575cdf0e10cSrcweir pTab[nTab]->SetPendingRowHeights( bSet );
576cdf0e10cSrcweir }
577cdf0e10cSrcweir
578cdf0e10cSrcweir
SetLayoutRTL(SCTAB nTab,sal_Bool bRTL)579cdf0e10cSrcweir void ScDocument::SetLayoutRTL( SCTAB nTab, sal_Bool bRTL )
580cdf0e10cSrcweir {
581cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
582cdf0e10cSrcweir {
583cdf0e10cSrcweir if ( bImportingXML )
584cdf0e10cSrcweir {
585cdf0e10cSrcweir // #i57869# only set the LoadingRTL flag, the real setting (including mirroring)
586cdf0e10cSrcweir // is applied in SetImportingXML(sal_False). This is so the shapes can be loaded in
587cdf0e10cSrcweir // normal LTR mode.
588cdf0e10cSrcweir
589cdf0e10cSrcweir pTab[nTab]->SetLoadingRTL( bRTL );
590cdf0e10cSrcweir return;
591cdf0e10cSrcweir }
592cdf0e10cSrcweir
593cdf0e10cSrcweir pTab[nTab]->SetLayoutRTL( bRTL ); // only sets the flag
594cdf0e10cSrcweir pTab[nTab]->SetDrawPageSize();
595cdf0e10cSrcweir
596cdf0e10cSrcweir // mirror existing objects:
597cdf0e10cSrcweir
598cdf0e10cSrcweir if (pDrawLayer)
599cdf0e10cSrcweir {
600cdf0e10cSrcweir SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
601cdf0e10cSrcweir DBG_ASSERT(pPage,"Page ?");
602cdf0e10cSrcweir if (pPage)
603cdf0e10cSrcweir {
604cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
605cdf0e10cSrcweir SdrObject* pObject = aIter.Next();
606cdf0e10cSrcweir while (pObject)
607cdf0e10cSrcweir {
608cdf0e10cSrcweir // objects with ScDrawObjData are re-positioned in SetPageSize,
609cdf0e10cSrcweir // don't mirror again
610cdf0e10cSrcweir ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject );
611cdf0e10cSrcweir if ( !pData )
612cdf0e10cSrcweir pDrawLayer->MirrorRTL( pObject );
613cdf0e10cSrcweir
614cdf0e10cSrcweir pObject->SetContextWritingMode( bRTL ? WritingMode2::RL_TB : WritingMode2::LR_TB );
615cdf0e10cSrcweir
616cdf0e10cSrcweir pObject = aIter.Next();
617cdf0e10cSrcweir }
618cdf0e10cSrcweir }
619cdf0e10cSrcweir }
620cdf0e10cSrcweir }
621cdf0e10cSrcweir }
622cdf0e10cSrcweir
623cdf0e10cSrcweir
IsLayoutRTL(SCTAB nTab) const624cdf0e10cSrcweir sal_Bool ScDocument::IsLayoutRTL( SCTAB nTab ) const
625cdf0e10cSrcweir {
626cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
627cdf0e10cSrcweir return pTab[nTab]->IsLayoutRTL();
628cdf0e10cSrcweir
629cdf0e10cSrcweir return sal_False;
630cdf0e10cSrcweir }
631cdf0e10cSrcweir
632cdf0e10cSrcweir
IsNegativePage(SCTAB nTab) const633cdf0e10cSrcweir sal_Bool ScDocument::IsNegativePage( SCTAB nTab ) const
634cdf0e10cSrcweir {
635cdf0e10cSrcweir // Negative page area is always used for RTL layout.
636cdf0e10cSrcweir // The separate method is used to find all RTL handling of drawing objects.
637cdf0e10cSrcweir return IsLayoutRTL( nTab );
638cdf0e10cSrcweir }
639cdf0e10cSrcweir
640cdf0e10cSrcweir
641cdf0e10cSrcweir /* ----------------------------------------------------------------------------
642cdf0e10cSrcweir benutzten Bereich suchen:
643cdf0e10cSrcweir
644cdf0e10cSrcweir GetCellArea - nur Daten
645cdf0e10cSrcweir GetTableArea - Daten / Attribute
646cdf0e10cSrcweir GetPrintArea - beruecksichtigt auch Zeichenobjekte,
647cdf0e10cSrcweir streicht Attribute bis ganz rechts / unten
648cdf0e10cSrcweir ---------------------------------------------------------------------------- */
649cdf0e10cSrcweir
650cdf0e10cSrcweir
GetCellArea(SCTAB nTab,SCCOL & rEndCol,SCROW & rEndRow) const651cdf0e10cSrcweir sal_Bool ScDocument::GetCellArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
652cdf0e10cSrcweir {
653cdf0e10cSrcweir if (VALIDTAB(nTab))
654cdf0e10cSrcweir if (pTab[nTab])
655cdf0e10cSrcweir return pTab[nTab]->GetCellArea( rEndCol, rEndRow );
656cdf0e10cSrcweir
657cdf0e10cSrcweir rEndCol = 0;
658cdf0e10cSrcweir rEndRow = 0;
659cdf0e10cSrcweir return sal_False;
660cdf0e10cSrcweir }
661cdf0e10cSrcweir
662cdf0e10cSrcweir
GetTableArea(SCTAB nTab,SCCOL & rEndCol,SCROW & rEndRow) const663cdf0e10cSrcweir sal_Bool ScDocument::GetTableArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
664cdf0e10cSrcweir {
665cdf0e10cSrcweir if (VALIDTAB(nTab))
666cdf0e10cSrcweir if (pTab[nTab])
667cdf0e10cSrcweir return pTab[nTab]->GetTableArea( rEndCol, rEndRow );
668cdf0e10cSrcweir
669cdf0e10cSrcweir rEndCol = 0;
670cdf0e10cSrcweir rEndRow = 0;
671cdf0e10cSrcweir return sal_False;
672cdf0e10cSrcweir }
673cdf0e10cSrcweir
ShrinkToDataArea(SCTAB nTab,SCCOL & rStartCol,SCROW & rStartRow,SCCOL & rEndCol,SCROW & rEndRow) const674cdf0e10cSrcweir bool ScDocument::ShrinkToDataArea(SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow) const
675cdf0e10cSrcweir {
676cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
677cdf0e10cSrcweir return false;
678cdf0e10cSrcweir
679cdf0e10cSrcweir SCCOL nCol1, nCol2;
680cdf0e10cSrcweir SCROW nRow1, nRow2;
681cdf0e10cSrcweir pTab[nTab]->GetFirstDataPos(nCol1, nRow1);
682cdf0e10cSrcweir pTab[nTab]->GetLastDataPos(nCol2, nRow2);
683cdf0e10cSrcweir
684cdf0e10cSrcweir if (nCol1 > nCol2 || nRow1 > nRow2)
685cdf0e10cSrcweir // invalid range.
686cdf0e10cSrcweir return false;
687cdf0e10cSrcweir
688cdf0e10cSrcweir // Make sure the area only shrinks, and doesn't grow.
689cdf0e10cSrcweir if (rStartCol < nCol1)
690cdf0e10cSrcweir rStartCol = nCol1;
691cdf0e10cSrcweir if (nCol2 < rEndCol)
692cdf0e10cSrcweir rEndCol = nCol2;
693cdf0e10cSrcweir if (rStartRow < nRow1)
694cdf0e10cSrcweir rStartRow = nRow1;
695cdf0e10cSrcweir if (nRow2 < rEndRow)
696cdf0e10cSrcweir rEndRow = nRow2;
697cdf0e10cSrcweir
698cdf0e10cSrcweir if (rStartCol > rEndCol || rStartRow > rEndRow)
699cdf0e10cSrcweir // invalid range.
700cdf0e10cSrcweir return false;
701cdf0e10cSrcweir
702cdf0e10cSrcweir return true; // success!
703cdf0e10cSrcweir }
704cdf0e10cSrcweir
ShrinkToUsedDataArea(bool & o_bShrunk,SCTAB nTab,SCCOL & rStartCol,SCROW & rStartRow,SCCOL & rEndCol,SCROW & rEndRow,bool bColumnsOnly) const705cdf0e10cSrcweir bool ScDocument::ShrinkToUsedDataArea( bool& o_bShrunk, SCTAB nTab, SCCOL& rStartCol,
706cdf0e10cSrcweir SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly ) const
707cdf0e10cSrcweir {
708cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
709cdf0e10cSrcweir {
710cdf0e10cSrcweir o_bShrunk = false;
711cdf0e10cSrcweir return false;
712cdf0e10cSrcweir }
713cdf0e10cSrcweir return pTab[nTab]->ShrinkToUsedDataArea( o_bShrunk, rStartCol, rStartRow, rEndCol, rEndRow, bColumnsOnly);
714cdf0e10cSrcweir }
715cdf0e10cSrcweir
716cdf0e10cSrcweir // zusammenhaengender Bereich
717cdf0e10cSrcweir
GetDataArea(SCTAB nTab,SCCOL & rStartCol,SCROW & rStartRow,SCCOL & rEndCol,SCROW & rEndRow,sal_Bool bIncludeOld,bool bOnlyDown) const718cdf0e10cSrcweir void ScDocument::GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
719cdf0e10cSrcweir SCCOL& rEndCol, SCROW& rEndRow, sal_Bool bIncludeOld, bool bOnlyDown ) const
720cdf0e10cSrcweir {
721cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
722cdf0e10cSrcweir pTab[nTab]->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow, bIncludeOld, bOnlyDown );
723cdf0e10cSrcweir }
724cdf0e10cSrcweir
725cdf0e10cSrcweir
LimitChartArea(SCTAB nTab,SCCOL & rStartCol,SCROW & rStartRow,SCCOL & rEndCol,SCROW & rEndRow)726cdf0e10cSrcweir void ScDocument::LimitChartArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
727cdf0e10cSrcweir SCCOL& rEndCol, SCROW& rEndRow )
728cdf0e10cSrcweir {
729cdf0e10cSrcweir if (VALIDTAB(nTab))
730cdf0e10cSrcweir if (pTab[nTab])
731cdf0e10cSrcweir pTab[nTab]->LimitChartArea( rStartCol, rStartRow, rEndCol, rEndRow );
732cdf0e10cSrcweir }
733cdf0e10cSrcweir
734cdf0e10cSrcweir
LimitChartIfAll(ScRangeListRef & rRangeList)735cdf0e10cSrcweir void ScDocument::LimitChartIfAll( ScRangeListRef& rRangeList )
736cdf0e10cSrcweir {
737cdf0e10cSrcweir ScRangeListRef aNew = new ScRangeList;
738cdf0e10cSrcweir if (rRangeList.Is())
739cdf0e10cSrcweir {
740cdf0e10cSrcweir sal_uLong nCount = rRangeList->Count();
741cdf0e10cSrcweir for (sal_uLong i=0; i<nCount; i++)
742cdf0e10cSrcweir {
743cdf0e10cSrcweir ScRange aRange(*rRangeList->GetObject( i ));
744cdf0e10cSrcweir if ( ( aRange.aStart.Col() == 0 && aRange.aEnd.Col() == MAXCOL ) ||
745cdf0e10cSrcweir ( aRange.aStart.Row() == 0 && aRange.aEnd.Row() == MAXROW ) )
746cdf0e10cSrcweir {
747cdf0e10cSrcweir SCCOL nStartCol = aRange.aStart.Col();
748cdf0e10cSrcweir SCROW nStartRow = aRange.aStart.Row();
749cdf0e10cSrcweir SCCOL nEndCol = aRange.aEnd.Col();
750cdf0e10cSrcweir SCROW nEndRow = aRange.aEnd.Row();
751cdf0e10cSrcweir SCTAB nTab = aRange.aStart.Tab();
752cdf0e10cSrcweir if (pTab[nTab])
753cdf0e10cSrcweir pTab[nTab]->LimitChartArea(nStartCol, nStartRow, nEndCol, nEndRow);
754cdf0e10cSrcweir aRange.aStart.SetCol( nStartCol );
755cdf0e10cSrcweir aRange.aStart.SetRow( nStartRow );
756cdf0e10cSrcweir aRange.aEnd.SetCol( nEndCol );
757cdf0e10cSrcweir aRange.aEnd.SetRow( nEndRow );
758cdf0e10cSrcweir }
759cdf0e10cSrcweir aNew->Append(aRange);
760cdf0e10cSrcweir }
761cdf0e10cSrcweir }
762cdf0e10cSrcweir else
763cdf0e10cSrcweir {
764cdf0e10cSrcweir DBG_ERROR("LimitChartIfAll: Ref==0");
765cdf0e10cSrcweir }
766cdf0e10cSrcweir rRangeList = aNew;
767cdf0e10cSrcweir }
768cdf0e10cSrcweir
769cdf0e10cSrcweir
lcl_GetFirstTabRange(SCTAB & rTabRangeStart,SCTAB & rTabRangeEnd,const ScMarkData * pTabMark)770cdf0e10cSrcweir void lcl_GetFirstTabRange( SCTAB& rTabRangeStart, SCTAB& rTabRangeEnd, const ScMarkData* pTabMark )
771cdf0e10cSrcweir {
772cdf0e10cSrcweir // without ScMarkData, leave start/end unchanged
773cdf0e10cSrcweir if ( pTabMark )
774cdf0e10cSrcweir {
775cdf0e10cSrcweir for (SCTAB nTab=0; nTab<=MAXTAB; ++nTab)
776cdf0e10cSrcweir if (pTabMark->GetTableSelect(nTab))
777cdf0e10cSrcweir {
778cdf0e10cSrcweir // find first range of consecutive selected sheets
779cdf0e10cSrcweir rTabRangeStart = nTab;
780cdf0e10cSrcweir while ( nTab+1 <= MAXTAB && pTabMark->GetTableSelect(nTab+1) )
781cdf0e10cSrcweir ++nTab;
782cdf0e10cSrcweir rTabRangeEnd = nTab;
783cdf0e10cSrcweir return;
784cdf0e10cSrcweir }
785cdf0e10cSrcweir }
786cdf0e10cSrcweir }
787cdf0e10cSrcweir
lcl_GetNextTabRange(SCTAB & rTabRangeStart,SCTAB & rTabRangeEnd,const ScMarkData * pTabMark)788cdf0e10cSrcweir bool lcl_GetNextTabRange( SCTAB& rTabRangeStart, SCTAB& rTabRangeEnd, const ScMarkData* pTabMark )
789cdf0e10cSrcweir {
790cdf0e10cSrcweir if ( pTabMark )
791cdf0e10cSrcweir {
792cdf0e10cSrcweir // find next range of consecutive selected sheets after rTabRangeEnd
793cdf0e10cSrcweir for (SCTAB nTab=rTabRangeEnd+1; nTab<=MAXTAB; ++nTab)
794cdf0e10cSrcweir if (pTabMark->GetTableSelect(nTab))
795cdf0e10cSrcweir {
796cdf0e10cSrcweir rTabRangeStart = nTab;
797cdf0e10cSrcweir while ( nTab+1 <= MAXTAB && pTabMark->GetTableSelect(nTab+1) )
798cdf0e10cSrcweir ++nTab;
799cdf0e10cSrcweir rTabRangeEnd = nTab;
800cdf0e10cSrcweir return true;
801cdf0e10cSrcweir }
802cdf0e10cSrcweir }
803cdf0e10cSrcweir return false;
804cdf0e10cSrcweir }
805cdf0e10cSrcweir
806cdf0e10cSrcweir
CanInsertRow(const ScRange & rRange) const807cdf0e10cSrcweir sal_Bool ScDocument::CanInsertRow( const ScRange& rRange ) const
808cdf0e10cSrcweir {
809cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
810cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
811cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
812cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
813cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
814cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
815cdf0e10cSrcweir PutInOrder( nStartCol, nEndCol );
816cdf0e10cSrcweir PutInOrder( nStartRow, nEndRow );
817cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
818cdf0e10cSrcweir SCSIZE nSize = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
819cdf0e10cSrcweir
820cdf0e10cSrcweir sal_Bool bTest = sal_True;
821cdf0e10cSrcweir for (SCTAB i=nStartTab; i<=nEndTab && bTest; i++)
822cdf0e10cSrcweir if (pTab[i])
823cdf0e10cSrcweir bTest &= pTab[i]->TestInsertRow( nStartCol, nEndCol, nSize );
824cdf0e10cSrcweir
825cdf0e10cSrcweir return bTest;
826cdf0e10cSrcweir }
827cdf0e10cSrcweir
828cdf0e10cSrcweir
InsertRow(SCCOL nStartCol,SCTAB nStartTab,SCCOL nEndCol,SCTAB nEndTab,SCROW nStartRow,SCSIZE nSize,ScDocument * pRefUndoDoc,const ScMarkData * pTabMark)829cdf0e10cSrcweir sal_Bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB nStartTab,
830cdf0e10cSrcweir SCCOL nEndCol, SCTAB nEndTab,
831cdf0e10cSrcweir SCROW nStartRow, SCSIZE nSize, ScDocument* pRefUndoDoc,
832cdf0e10cSrcweir const ScMarkData* pTabMark )
833cdf0e10cSrcweir {
834cdf0e10cSrcweir SCTAB i;
835cdf0e10cSrcweir
836cdf0e10cSrcweir PutInOrder( nStartCol, nEndCol );
837cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
838cdf0e10cSrcweir if ( pTabMark )
839cdf0e10cSrcweir {
840cdf0e10cSrcweir nStartTab = 0;
841cdf0e10cSrcweir nEndTab = MAXTAB;
842cdf0e10cSrcweir }
843cdf0e10cSrcweir
844cdf0e10cSrcweir sal_Bool bTest = sal_True;
845cdf0e10cSrcweir sal_Bool bRet = sal_False;
846cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
847cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
848cdf0e10cSrcweir for ( i = nStartTab; i <= nEndTab && bTest; i++)
849cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
850cdf0e10cSrcweir bTest &= pTab[i]->TestInsertRow( nStartCol, nEndCol, nSize );
851cdf0e10cSrcweir if (bTest)
852cdf0e10cSrcweir {
853cdf0e10cSrcweir // UpdateBroadcastAreas muss vor UpdateReference gerufen werden, damit nicht
854cdf0e10cSrcweir // Eintraege verschoben werden, die erst bei UpdateReference neu erzeugt werden
855cdf0e10cSrcweir
856cdf0e10cSrcweir // handle chunks of consecutive selected sheets together
857cdf0e10cSrcweir SCTAB nTabRangeStart = nStartTab;
858cdf0e10cSrcweir SCTAB nTabRangeEnd = nEndTab;
859cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
860cdf0e10cSrcweir do
861cdf0e10cSrcweir {
862cdf0e10cSrcweir UpdateBroadcastAreas( URM_INSDEL, ScRange(
863cdf0e10cSrcweir ScAddress( nStartCol, nStartRow, nTabRangeStart ),
864cdf0e10cSrcweir ScAddress( nEndCol, MAXROW, nTabRangeEnd )), 0, static_cast<SCsROW>(nSize), 0 );
865cdf0e10cSrcweir }
866cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
867cdf0e10cSrcweir
868cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
869cdf0e10cSrcweir do
870cdf0e10cSrcweir {
871cdf0e10cSrcweir UpdateReference( URM_INSDEL, nStartCol, nStartRow, nTabRangeStart,
872cdf0e10cSrcweir nEndCol, MAXROW, nTabRangeEnd,
873cdf0e10cSrcweir 0, static_cast<SCsROW>(nSize), 0, pRefUndoDoc, sal_False ); // without drawing objects
874cdf0e10cSrcweir }
875cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
876cdf0e10cSrcweir
877cdf0e10cSrcweir for (i=nStartTab; i<=nEndTab; i++)
878cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
879cdf0e10cSrcweir pTab[i]->InsertRow( nStartCol, nEndCol, nStartRow, nSize );
880cdf0e10cSrcweir
881cdf0e10cSrcweir // #82991# UpdateRef for drawing layer must be after inserting,
882cdf0e10cSrcweir // when the new row heights are known.
883cdf0e10cSrcweir for (i=nStartTab; i<=nEndTab; i++)
884cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
885cdf0e10cSrcweir pTab[i]->UpdateDrawRef( URM_INSDEL,
886cdf0e10cSrcweir nStartCol, nStartRow, nStartTab, nEndCol, MAXROW, nEndTab,
887cdf0e10cSrcweir 0, static_cast<SCsROW>(nSize), 0 );
888cdf0e10cSrcweir
889cdf0e10cSrcweir if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() )
890cdf0e10cSrcweir { // durch Restaurierung von Referenzen auf geloeschte Bereiche ist
891cdf0e10cSrcweir // ein neues Listening faellig, bisherige Listener wurden in
892cdf0e10cSrcweir // FormulaCell UpdateReference abgehaengt
893cdf0e10cSrcweir StartAllListeners();
894cdf0e10cSrcweir }
895cdf0e10cSrcweir else
896cdf0e10cSrcweir { // Listeners have been removed in UpdateReference
897cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
898cdf0e10cSrcweir if (pTab[i])
899cdf0e10cSrcweir pTab[i]->StartNeededListeners();
900cdf0e10cSrcweir // #69592# at least all cells using range names pointing relative
901cdf0e10cSrcweir // to the moved range must recalculate
902cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
903cdf0e10cSrcweir if (pTab[i])
904cdf0e10cSrcweir pTab[i]->SetRelNameDirty();
905cdf0e10cSrcweir }
906cdf0e10cSrcweir bRet = sal_True;
907cdf0e10cSrcweir }
908cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
909cdf0e10cSrcweir if ( bRet )
910cdf0e10cSrcweir pChartListenerCollection->UpdateDirtyCharts();
911cdf0e10cSrcweir return bRet;
912cdf0e10cSrcweir }
913cdf0e10cSrcweir
914cdf0e10cSrcweir
InsertRow(const ScRange & rRange,ScDocument * pRefUndoDoc)915cdf0e10cSrcweir sal_Bool ScDocument::InsertRow( const ScRange& rRange, ScDocument* pRefUndoDoc )
916cdf0e10cSrcweir {
917cdf0e10cSrcweir return InsertRow( rRange.aStart.Col(), rRange.aStart.Tab(),
918cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Tab(),
919cdf0e10cSrcweir rRange.aStart.Row(), static_cast<SCSIZE>(rRange.aEnd.Row()-rRange.aStart.Row()+1),
920cdf0e10cSrcweir pRefUndoDoc );
921cdf0e10cSrcweir }
922cdf0e10cSrcweir
923cdf0e10cSrcweir
DeleteRow(SCCOL nStartCol,SCTAB nStartTab,SCCOL nEndCol,SCTAB nEndTab,SCROW nStartRow,SCSIZE nSize,ScDocument * pRefUndoDoc,sal_Bool * pUndoOutline,const ScMarkData * pTabMark)924cdf0e10cSrcweir void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB nStartTab,
925cdf0e10cSrcweir SCCOL nEndCol, SCTAB nEndTab,
926cdf0e10cSrcweir SCROW nStartRow, SCSIZE nSize,
927cdf0e10cSrcweir ScDocument* pRefUndoDoc, sal_Bool* pUndoOutline,
928cdf0e10cSrcweir const ScMarkData* pTabMark )
929cdf0e10cSrcweir {
930cdf0e10cSrcweir SCTAB i;
931cdf0e10cSrcweir
932cdf0e10cSrcweir PutInOrder( nStartCol, nEndCol );
933cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
934cdf0e10cSrcweir if ( pTabMark )
935cdf0e10cSrcweir {
936cdf0e10cSrcweir nStartTab = 0;
937cdf0e10cSrcweir nEndTab = MAXTAB;
938cdf0e10cSrcweir }
939cdf0e10cSrcweir
940cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
941cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
942cdf0e10cSrcweir
943cdf0e10cSrcweir // handle chunks of consecutive selected sheets together
944cdf0e10cSrcweir SCTAB nTabRangeStart = nStartTab;
945cdf0e10cSrcweir SCTAB nTabRangeEnd = nEndTab;
946cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
947cdf0e10cSrcweir do
948cdf0e10cSrcweir {
949cdf0e10cSrcweir if ( ValidRow(nStartRow+nSize) )
950cdf0e10cSrcweir {
951cdf0e10cSrcweir DelBroadcastAreasInRange( ScRange(
952cdf0e10cSrcweir ScAddress( nStartCol, nStartRow, nTabRangeStart ),
953cdf0e10cSrcweir ScAddress( nEndCol, nStartRow+nSize-1, nTabRangeEnd ) ) );
954cdf0e10cSrcweir UpdateBroadcastAreas( URM_INSDEL, ScRange(
955cdf0e10cSrcweir ScAddress( nStartCol, nStartRow+nSize, nTabRangeStart ),
956cdf0e10cSrcweir ScAddress( nEndCol, MAXROW, nTabRangeEnd )), 0, -(static_cast<SCsROW>(nSize)), 0 );
957cdf0e10cSrcweir }
958cdf0e10cSrcweir else
959cdf0e10cSrcweir DelBroadcastAreasInRange( ScRange(
960cdf0e10cSrcweir ScAddress( nStartCol, nStartRow, nTabRangeStart ),
961cdf0e10cSrcweir ScAddress( nEndCol, MAXROW, nTabRangeEnd ) ) );
962cdf0e10cSrcweir }
963cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
964cdf0e10cSrcweir
965cdf0e10cSrcweir if ( ValidRow(nStartRow+nSize) )
966cdf0e10cSrcweir {
967cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
968cdf0e10cSrcweir do
969cdf0e10cSrcweir {
970cdf0e10cSrcweir UpdateReference( URM_INSDEL, nStartCol, nStartRow+nSize, nTabRangeStart,
971cdf0e10cSrcweir nEndCol, MAXROW, nTabRangeEnd,
972cdf0e10cSrcweir 0, -(static_cast<SCsROW>(nSize)), 0, pRefUndoDoc, sal_True, false );
973cdf0e10cSrcweir }
974cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
975cdf0e10cSrcweir }
976cdf0e10cSrcweir
977cdf0e10cSrcweir if (pUndoOutline)
978cdf0e10cSrcweir *pUndoOutline = sal_False;
979cdf0e10cSrcweir
980cdf0e10cSrcweir for ( i = nStartTab; i <= nEndTab; i++)
981cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
982cdf0e10cSrcweir pTab[i]->DeleteRow( nStartCol, nEndCol, nStartRow, nSize, pUndoOutline );
983cdf0e10cSrcweir
984cdf0e10cSrcweir if ( ValidRow(nStartRow+nSize) )
985cdf0e10cSrcweir { // Listeners have been removed in UpdateReference
986cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
987cdf0e10cSrcweir if (pTab[i])
988cdf0e10cSrcweir pTab[i]->StartNeededListeners();
989cdf0e10cSrcweir // #69592# at least all cells using range names pointing relative to
990cdf0e10cSrcweir // the moved range must recalculate
991cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
992cdf0e10cSrcweir if (pTab[i])
993cdf0e10cSrcweir pTab[i]->SetRelNameDirty();
994cdf0e10cSrcweir }
995cdf0e10cSrcweir
996cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
997cdf0e10cSrcweir pChartListenerCollection->UpdateDirtyCharts();
998cdf0e10cSrcweir }
999cdf0e10cSrcweir
1000cdf0e10cSrcweir
DeleteRow(const ScRange & rRange,ScDocument * pRefUndoDoc,sal_Bool * pUndoOutline)1001cdf0e10cSrcweir void ScDocument::DeleteRow( const ScRange& rRange, ScDocument* pRefUndoDoc, sal_Bool* pUndoOutline )
1002cdf0e10cSrcweir {
1003cdf0e10cSrcweir DeleteRow( rRange.aStart.Col(), rRange.aStart.Tab(),
1004cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Tab(),
1005cdf0e10cSrcweir rRange.aStart.Row(), static_cast<SCSIZE>(rRange.aEnd.Row()-rRange.aStart.Row()+1),
1006cdf0e10cSrcweir pRefUndoDoc, pUndoOutline );
1007cdf0e10cSrcweir }
1008cdf0e10cSrcweir
1009cdf0e10cSrcweir
CanInsertCol(const ScRange & rRange) const1010cdf0e10cSrcweir sal_Bool ScDocument::CanInsertCol( const ScRange& rRange ) const
1011cdf0e10cSrcweir {
1012cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
1013cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
1014cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
1015cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
1016cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
1017cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
1018cdf0e10cSrcweir PutInOrder( nStartCol, nEndCol );
1019cdf0e10cSrcweir PutInOrder( nStartRow, nEndRow );
1020cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
1021cdf0e10cSrcweir SCSIZE nSize = static_cast<SCSIZE>(nEndCol - nStartCol + 1);
1022cdf0e10cSrcweir
1023cdf0e10cSrcweir sal_Bool bTest = sal_True;
1024cdf0e10cSrcweir for (SCTAB i=nStartTab; i<=nEndTab && bTest; i++)
1025cdf0e10cSrcweir if (pTab[i])
1026cdf0e10cSrcweir bTest &= pTab[i]->TestInsertCol( nStartRow, nEndRow, nSize );
1027cdf0e10cSrcweir
1028cdf0e10cSrcweir return bTest;
1029cdf0e10cSrcweir }
1030cdf0e10cSrcweir
1031cdf0e10cSrcweir
InsertCol(SCROW nStartRow,SCTAB nStartTab,SCROW nEndRow,SCTAB nEndTab,SCCOL nStartCol,SCSIZE nSize,ScDocument * pRefUndoDoc,const ScMarkData * pTabMark)1032cdf0e10cSrcweir sal_Bool ScDocument::InsertCol( SCROW nStartRow, SCTAB nStartTab,
1033cdf0e10cSrcweir SCROW nEndRow, SCTAB nEndTab,
1034cdf0e10cSrcweir SCCOL nStartCol, SCSIZE nSize, ScDocument* pRefUndoDoc,
1035cdf0e10cSrcweir const ScMarkData* pTabMark )
1036cdf0e10cSrcweir {
1037cdf0e10cSrcweir SCTAB i;
1038cdf0e10cSrcweir
1039cdf0e10cSrcweir PutInOrder( nStartRow, nEndRow );
1040cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
1041cdf0e10cSrcweir if ( pTabMark )
1042cdf0e10cSrcweir {
1043cdf0e10cSrcweir nStartTab = 0;
1044cdf0e10cSrcweir nEndTab = MAXTAB;
1045cdf0e10cSrcweir }
1046cdf0e10cSrcweir
1047cdf0e10cSrcweir sal_Bool bTest = sal_True;
1048cdf0e10cSrcweir sal_Bool bRet = sal_False;
1049cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
1050cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1051cdf0e10cSrcweir for ( i = nStartTab; i <= nEndTab && bTest; i++)
1052cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1053cdf0e10cSrcweir bTest &= pTab[i]->TestInsertCol( nStartRow, nEndRow, nSize );
1054cdf0e10cSrcweir if (bTest)
1055cdf0e10cSrcweir {
1056cdf0e10cSrcweir // handle chunks of consecutive selected sheets together
1057cdf0e10cSrcweir SCTAB nTabRangeStart = nStartTab;
1058cdf0e10cSrcweir SCTAB nTabRangeEnd = nEndTab;
1059cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
1060cdf0e10cSrcweir do
1061cdf0e10cSrcweir {
1062cdf0e10cSrcweir UpdateBroadcastAreas( URM_INSDEL, ScRange(
1063cdf0e10cSrcweir ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1064cdf0e10cSrcweir ScAddress( MAXCOL, nEndRow, nTabRangeEnd )), static_cast<SCsCOL>(nSize), 0, 0 );
1065cdf0e10cSrcweir }
1066cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
1067cdf0e10cSrcweir
1068cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
1069cdf0e10cSrcweir do
1070cdf0e10cSrcweir {
1071cdf0e10cSrcweir UpdateReference( URM_INSDEL, nStartCol, nStartRow, nTabRangeStart,
1072cdf0e10cSrcweir MAXCOL, nEndRow, nTabRangeEnd,
1073cdf0e10cSrcweir static_cast<SCsCOL>(nSize), 0, 0, pRefUndoDoc, sal_True, false );
1074cdf0e10cSrcweir }
1075cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
1076cdf0e10cSrcweir
1077cdf0e10cSrcweir for (i=nStartTab; i<=nEndTab; i++)
1078cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1079cdf0e10cSrcweir pTab[i]->InsertCol( nStartCol, nStartRow, nEndRow, nSize );
1080cdf0e10cSrcweir
1081cdf0e10cSrcweir if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() )
1082cdf0e10cSrcweir { // durch Restaurierung von Referenzen auf geloeschte Bereiche ist
1083cdf0e10cSrcweir // ein neues Listening faellig, bisherige Listener wurden in
1084cdf0e10cSrcweir // FormulaCell UpdateReference abgehaengt
1085cdf0e10cSrcweir StartAllListeners();
1086cdf0e10cSrcweir }
1087cdf0e10cSrcweir else
1088cdf0e10cSrcweir { // Listeners have been removed in UpdateReference
1089cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
1090cdf0e10cSrcweir if (pTab[i])
1091cdf0e10cSrcweir pTab[i]->StartNeededListeners();
1092cdf0e10cSrcweir // #69592# at least all cells using range names pointing relative
1093cdf0e10cSrcweir // to the moved range must recalculate
1094cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
1095cdf0e10cSrcweir if (pTab[i])
1096cdf0e10cSrcweir pTab[i]->SetRelNameDirty();
1097cdf0e10cSrcweir }
1098cdf0e10cSrcweir bRet = sal_True;
1099cdf0e10cSrcweir }
1100cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
1101cdf0e10cSrcweir if ( bRet )
1102cdf0e10cSrcweir pChartListenerCollection->UpdateDirtyCharts();
1103cdf0e10cSrcweir return bRet;
1104cdf0e10cSrcweir }
1105cdf0e10cSrcweir
1106cdf0e10cSrcweir
InsertCol(const ScRange & rRange,ScDocument * pRefUndoDoc)1107cdf0e10cSrcweir sal_Bool ScDocument::InsertCol( const ScRange& rRange, ScDocument* pRefUndoDoc )
1108cdf0e10cSrcweir {
1109cdf0e10cSrcweir return InsertCol( rRange.aStart.Row(), rRange.aStart.Tab(),
1110cdf0e10cSrcweir rRange.aEnd.Row(), rRange.aEnd.Tab(),
1111cdf0e10cSrcweir rRange.aStart.Col(), static_cast<SCSIZE>(rRange.aEnd.Col()-rRange.aStart.Col()+1),
1112cdf0e10cSrcweir pRefUndoDoc );
1113cdf0e10cSrcweir }
1114cdf0e10cSrcweir
1115cdf0e10cSrcweir
DeleteCol(SCROW nStartRow,SCTAB nStartTab,SCROW nEndRow,SCTAB nEndTab,SCCOL nStartCol,SCSIZE nSize,ScDocument * pRefUndoDoc,sal_Bool * pUndoOutline,const ScMarkData * pTabMark)1116cdf0e10cSrcweir void ScDocument::DeleteCol(SCROW nStartRow, SCTAB nStartTab, SCROW nEndRow, SCTAB nEndTab,
1117cdf0e10cSrcweir SCCOL nStartCol, SCSIZE nSize, ScDocument* pRefUndoDoc,
1118cdf0e10cSrcweir sal_Bool* pUndoOutline, const ScMarkData* pTabMark )
1119cdf0e10cSrcweir {
1120cdf0e10cSrcweir SCTAB i;
1121cdf0e10cSrcweir
1122cdf0e10cSrcweir PutInOrder( nStartRow, nEndRow );
1123cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
1124cdf0e10cSrcweir if ( pTabMark )
1125cdf0e10cSrcweir {
1126cdf0e10cSrcweir nStartTab = 0;
1127cdf0e10cSrcweir nEndTab = MAXTAB;
1128cdf0e10cSrcweir }
1129cdf0e10cSrcweir
1130cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
1131cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1132cdf0e10cSrcweir
1133cdf0e10cSrcweir // handle chunks of consecutive selected sheets together
1134cdf0e10cSrcweir SCTAB nTabRangeStart = nStartTab;
1135cdf0e10cSrcweir SCTAB nTabRangeEnd = nEndTab;
1136cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
1137cdf0e10cSrcweir do
1138cdf0e10cSrcweir {
1139cdf0e10cSrcweir if ( ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1140cdf0e10cSrcweir {
1141cdf0e10cSrcweir DelBroadcastAreasInRange( ScRange(
1142cdf0e10cSrcweir ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1143cdf0e10cSrcweir ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize-1), nEndRow, nTabRangeEnd ) ) );
1144cdf0e10cSrcweir UpdateBroadcastAreas( URM_INSDEL, ScRange(
1145cdf0e10cSrcweir ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart ),
1146cdf0e10cSrcweir ScAddress( MAXCOL, nEndRow, nTabRangeEnd )), -static_cast<SCsCOL>(nSize), 0, 0 );
1147cdf0e10cSrcweir }
1148cdf0e10cSrcweir else
1149cdf0e10cSrcweir DelBroadcastAreasInRange( ScRange(
1150cdf0e10cSrcweir ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1151cdf0e10cSrcweir ScAddress( MAXCOL, nEndRow, nTabRangeEnd ) ) );
1152cdf0e10cSrcweir }
1153cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
1154cdf0e10cSrcweir
1155cdf0e10cSrcweir if ( ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1156cdf0e10cSrcweir {
1157cdf0e10cSrcweir lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark );
1158cdf0e10cSrcweir do
1159cdf0e10cSrcweir {
1160cdf0e10cSrcweir UpdateReference( URM_INSDEL, sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart,
1161cdf0e10cSrcweir MAXCOL, nEndRow, nTabRangeEnd,
1162cdf0e10cSrcweir -static_cast<SCsCOL>(nSize), 0, 0, pRefUndoDoc, sal_True, false );
1163cdf0e10cSrcweir }
1164cdf0e10cSrcweir while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark ) );
1165cdf0e10cSrcweir }
1166cdf0e10cSrcweir
1167cdf0e10cSrcweir if (pUndoOutline)
1168cdf0e10cSrcweir *pUndoOutline = sal_False;
1169cdf0e10cSrcweir
1170cdf0e10cSrcweir for ( i = nStartTab; i <= nEndTab; i++)
1171cdf0e10cSrcweir if (pTab[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1172cdf0e10cSrcweir pTab[i]->DeleteCol( nStartCol, nStartRow, nEndRow, nSize, pUndoOutline );
1173cdf0e10cSrcweir
1174cdf0e10cSrcweir if ( ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1175cdf0e10cSrcweir { // Listeners have been removed in UpdateReference
1176cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
1177cdf0e10cSrcweir if (pTab[i])
1178cdf0e10cSrcweir pTab[i]->StartNeededListeners();
1179cdf0e10cSrcweir // #69592# at least all cells using range names pointing relative to
1180cdf0e10cSrcweir // the moved range must recalculate
1181cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
1182cdf0e10cSrcweir if (pTab[i])
1183cdf0e10cSrcweir pTab[i]->SetRelNameDirty();
1184cdf0e10cSrcweir }
1185cdf0e10cSrcweir
1186cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
1187cdf0e10cSrcweir pChartListenerCollection->UpdateDirtyCharts();
1188cdf0e10cSrcweir }
1189cdf0e10cSrcweir
1190cdf0e10cSrcweir
DeleteCol(const ScRange & rRange,ScDocument * pRefUndoDoc,sal_Bool * pUndoOutline)1191cdf0e10cSrcweir void ScDocument::DeleteCol( const ScRange& rRange, ScDocument* pRefUndoDoc, sal_Bool* pUndoOutline )
1192cdf0e10cSrcweir {
1193cdf0e10cSrcweir DeleteCol( rRange.aStart.Row(), rRange.aStart.Tab(),
1194cdf0e10cSrcweir rRange.aEnd.Row(), rRange.aEnd.Tab(),
1195cdf0e10cSrcweir rRange.aStart.Col(), static_cast<SCSIZE>(rRange.aEnd.Col()-rRange.aStart.Col()+1),
1196cdf0e10cSrcweir pRefUndoDoc, pUndoOutline );
1197cdf0e10cSrcweir }
1198cdf0e10cSrcweir
1199cdf0e10cSrcweir
1200cdf0e10cSrcweir // fuer Area-Links: Zellen einuegen/loeschen, wenn sich der Bereich veraendert
1201cdf0e10cSrcweir // (ohne Paint)
1202cdf0e10cSrcweir
1203cdf0e10cSrcweir
lcl_GetInsDelRanges(const ScRange & rOld,const ScRange & rNew,ScRange & rColRange,sal_Bool & rInsCol,sal_Bool & rDelCol,ScRange & rRowRange,sal_Bool & rInsRow,sal_Bool & rDelRow)1204cdf0e10cSrcweir void lcl_GetInsDelRanges( const ScRange& rOld, const ScRange& rNew,
1205cdf0e10cSrcweir ScRange& rColRange, sal_Bool& rInsCol, sal_Bool& rDelCol,
1206cdf0e10cSrcweir ScRange& rRowRange, sal_Bool& rInsRow, sal_Bool& rDelRow )
1207cdf0e10cSrcweir {
1208cdf0e10cSrcweir DBG_ASSERT( rOld.aStart == rNew.aStart, "FitBlock: Anfang unterschiedlich" );
1209cdf0e10cSrcweir
1210cdf0e10cSrcweir rInsCol = rDelCol = rInsRow = rDelRow = sal_False;
1211cdf0e10cSrcweir
1212cdf0e10cSrcweir SCCOL nStartX = rOld.aStart.Col();
1213cdf0e10cSrcweir SCROW nStartY = rOld.aStart.Row();
1214cdf0e10cSrcweir SCCOL nOldEndX = rOld.aEnd.Col();
1215cdf0e10cSrcweir SCROW nOldEndY = rOld.aEnd.Row();
1216cdf0e10cSrcweir SCCOL nNewEndX = rNew.aEnd.Col();
1217cdf0e10cSrcweir SCROW nNewEndY = rNew.aEnd.Row();
1218cdf0e10cSrcweir SCTAB nTab = rOld.aStart.Tab();
1219cdf0e10cSrcweir
1220cdf0e10cSrcweir // wenn es mehr Zeilen werden, werden Spalten auf der alten Hoehe eingefuegt/geloescht
1221cdf0e10cSrcweir sal_Bool bGrowY = ( nNewEndY > nOldEndY );
1222cdf0e10cSrcweir SCROW nColEndY = bGrowY ? nOldEndY : nNewEndY;
1223cdf0e10cSrcweir SCCOL nRowEndX = bGrowY ? nNewEndX : nOldEndX;
1224cdf0e10cSrcweir
1225cdf0e10cSrcweir // Spalten
1226cdf0e10cSrcweir
1227cdf0e10cSrcweir if ( nNewEndX > nOldEndX ) // Spalten einfuegen
1228cdf0e10cSrcweir {
1229cdf0e10cSrcweir rColRange = ScRange( nOldEndX+1, nStartY, nTab, nNewEndX, nColEndY, nTab );
1230cdf0e10cSrcweir rInsCol = sal_True;
1231cdf0e10cSrcweir }
1232cdf0e10cSrcweir else if ( nNewEndX < nOldEndX ) // Spalten loeschen
1233cdf0e10cSrcweir {
1234cdf0e10cSrcweir rColRange = ScRange( nNewEndX+1, nStartY, nTab, nOldEndX, nColEndY, nTab );
1235cdf0e10cSrcweir rDelCol = sal_True;
1236cdf0e10cSrcweir }
1237cdf0e10cSrcweir
1238cdf0e10cSrcweir // Zeilen
1239cdf0e10cSrcweir
1240cdf0e10cSrcweir if ( nNewEndY > nOldEndY ) // Zeilen einfuegen
1241cdf0e10cSrcweir {
1242cdf0e10cSrcweir rRowRange = ScRange( nStartX, nOldEndY+1, nTab, nRowEndX, nNewEndY, nTab );
1243cdf0e10cSrcweir rInsRow = sal_True;
1244cdf0e10cSrcweir }
1245cdf0e10cSrcweir else if ( nNewEndY < nOldEndY ) // Zeilen loeschen
1246cdf0e10cSrcweir {
1247cdf0e10cSrcweir rRowRange = ScRange( nStartX, nNewEndY+1, nTab, nRowEndX, nOldEndY, nTab );
1248cdf0e10cSrcweir rDelRow = sal_True;
1249cdf0e10cSrcweir }
1250cdf0e10cSrcweir }
1251cdf0e10cSrcweir
1252cdf0e10cSrcweir
HasPartOfMerged(const ScRange & rRange)1253cdf0e10cSrcweir sal_Bool ScDocument::HasPartOfMerged( const ScRange& rRange )
1254cdf0e10cSrcweir {
1255cdf0e10cSrcweir sal_Bool bPart = sal_False;
1256cdf0e10cSrcweir SCTAB nTab = rRange.aStart.Tab();
1257cdf0e10cSrcweir
1258cdf0e10cSrcweir SCCOL nStartX = rRange.aStart.Col();
1259cdf0e10cSrcweir SCROW nStartY = rRange.aStart.Row();
1260cdf0e10cSrcweir SCCOL nEndX = rRange.aEnd.Col();
1261cdf0e10cSrcweir SCROW nEndY = rRange.aEnd.Row();
1262cdf0e10cSrcweir
1263cdf0e10cSrcweir if (HasAttrib( nStartX, nStartY, nTab, nEndX, nEndY, nTab,
1264cdf0e10cSrcweir HASATTR_MERGED | HASATTR_OVERLAPPED ))
1265cdf0e10cSrcweir {
1266cdf0e10cSrcweir ExtendMerge( nStartX, nStartY, nEndX, nEndY, nTab );
1267cdf0e10cSrcweir ExtendOverlapped( nStartX, nStartY, nEndX, nEndY, nTab );
1268cdf0e10cSrcweir
1269cdf0e10cSrcweir bPart = ( nStartX != rRange.aStart.Col() || nEndX != rRange.aEnd.Col() ||
1270cdf0e10cSrcweir nStartY != rRange.aStart.Row() || nEndY != rRange.aEnd.Row() );
1271cdf0e10cSrcweir }
1272cdf0e10cSrcweir return bPart;
1273cdf0e10cSrcweir }
1274cdf0e10cSrcweir
1275cdf0e10cSrcweir
CanFitBlock(const ScRange & rOld,const ScRange & rNew)1276cdf0e10cSrcweir sal_Bool ScDocument::CanFitBlock( const ScRange& rOld, const ScRange& rNew )
1277cdf0e10cSrcweir {
1278cdf0e10cSrcweir if ( rOld == rNew )
1279cdf0e10cSrcweir return sal_True;
1280cdf0e10cSrcweir
1281cdf0e10cSrcweir sal_Bool bOk = sal_True;
1282cdf0e10cSrcweir sal_Bool bInsCol,bDelCol,bInsRow,bDelRow;
1283cdf0e10cSrcweir ScRange aColRange,aRowRange;
1284cdf0e10cSrcweir lcl_GetInsDelRanges( rOld, rNew, aColRange,bInsCol,bDelCol, aRowRange,bInsRow,bDelRow );
1285cdf0e10cSrcweir
1286cdf0e10cSrcweir if ( bInsCol && !CanInsertCol( aColRange ) ) // Zellen am Rand ?
1287cdf0e10cSrcweir bOk = sal_False;
1288cdf0e10cSrcweir if ( bInsRow && !CanInsertRow( aRowRange ) ) // Zellen am Rand ?
1289cdf0e10cSrcweir bOk = sal_False;
1290cdf0e10cSrcweir
1291cdf0e10cSrcweir if ( bInsCol || bDelCol )
1292cdf0e10cSrcweir {
1293cdf0e10cSrcweir aColRange.aEnd.SetCol(MAXCOL);
1294cdf0e10cSrcweir if ( HasPartOfMerged(aColRange) )
1295cdf0e10cSrcweir bOk = sal_False;
1296cdf0e10cSrcweir }
1297cdf0e10cSrcweir if ( bInsRow || bDelRow )
1298cdf0e10cSrcweir {
1299cdf0e10cSrcweir aRowRange.aEnd.SetRow(MAXROW);
1300cdf0e10cSrcweir if ( HasPartOfMerged(aRowRange) )
1301cdf0e10cSrcweir bOk = sal_False;
1302cdf0e10cSrcweir }
1303cdf0e10cSrcweir
1304cdf0e10cSrcweir return bOk;
1305cdf0e10cSrcweir }
1306cdf0e10cSrcweir
1307cdf0e10cSrcweir
FitBlock(const ScRange & rOld,const ScRange & rNew,sal_Bool bClear)1308cdf0e10cSrcweir void ScDocument::FitBlock( const ScRange& rOld, const ScRange& rNew, sal_Bool bClear )
1309cdf0e10cSrcweir {
1310cdf0e10cSrcweir if (bClear)
1311cdf0e10cSrcweir DeleteAreaTab( rOld, IDF_ALL );
1312cdf0e10cSrcweir
1313cdf0e10cSrcweir sal_Bool bInsCol,bDelCol,bInsRow,bDelRow;
1314cdf0e10cSrcweir ScRange aColRange,aRowRange;
1315cdf0e10cSrcweir lcl_GetInsDelRanges( rOld, rNew, aColRange,bInsCol,bDelCol, aRowRange,bInsRow,bDelRow );
1316cdf0e10cSrcweir
1317cdf0e10cSrcweir if ( bInsCol )
1318cdf0e10cSrcweir InsertCol( aColRange ); // Spalten zuerst einfuegen
1319cdf0e10cSrcweir if ( bInsRow )
1320cdf0e10cSrcweir InsertRow( aRowRange );
1321cdf0e10cSrcweir
1322cdf0e10cSrcweir if ( bDelRow )
1323cdf0e10cSrcweir DeleteRow( aRowRange ); // Zeilen zuerst loeschen
1324cdf0e10cSrcweir if ( bDelCol )
1325cdf0e10cSrcweir DeleteCol( aColRange );
1326cdf0e10cSrcweir
1327cdf0e10cSrcweir // Referenzen um eingefuegte Zeilen erweitern
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir if ( bInsCol || bInsRow )
1330cdf0e10cSrcweir {
1331cdf0e10cSrcweir ScRange aGrowSource = rOld;
1332cdf0e10cSrcweir aGrowSource.aEnd.SetCol(Min( rOld.aEnd.Col(), rNew.aEnd.Col() ));
1333cdf0e10cSrcweir aGrowSource.aEnd.SetRow(Min( rOld.aEnd.Row(), rNew.aEnd.Row() ));
1334cdf0e10cSrcweir SCCOL nGrowX = bInsCol ? ( rNew.aEnd.Col() - rOld.aEnd.Col() ) : 0;
1335cdf0e10cSrcweir SCROW nGrowY = bInsRow ? ( rNew.aEnd.Row() - rOld.aEnd.Row() ) : 0;
1336cdf0e10cSrcweir UpdateGrow( aGrowSource, nGrowX, nGrowY );
1337cdf0e10cSrcweir }
1338cdf0e10cSrcweir }
1339cdf0e10cSrcweir
1340cdf0e10cSrcweir
DeleteArea(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,const ScMarkData & rMark,sal_uInt16 nDelFlag)1341cdf0e10cSrcweir void ScDocument::DeleteArea(SCCOL nCol1, SCROW nRow1,
1342cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
1343cdf0e10cSrcweir const ScMarkData& rMark, sal_uInt16 nDelFlag)
1344cdf0e10cSrcweir {
1345cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
1346cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
1347cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
1348cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1349cdf0e10cSrcweir for (SCTAB i = 0; i <= MAXTAB; i++)
1350cdf0e10cSrcweir if (pTab[i])
1351cdf0e10cSrcweir if ( rMark.GetTableSelect(i) || bIsUndo )
1352cdf0e10cSrcweir pTab[i]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag);
1353cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
1354cdf0e10cSrcweir }
1355cdf0e10cSrcweir
1356cdf0e10cSrcweir
DeleteAreaTab(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,SCTAB nTab,sal_uInt16 nDelFlag)1357cdf0e10cSrcweir void ScDocument::DeleteAreaTab(SCCOL nCol1, SCROW nRow1,
1358cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
1359cdf0e10cSrcweir SCTAB nTab, sal_uInt16 nDelFlag)
1360cdf0e10cSrcweir {
1361cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
1362cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
1363cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
1364cdf0e10cSrcweir {
1365cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
1366cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1367cdf0e10cSrcweir pTab[nTab]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag);
1368cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
1369cdf0e10cSrcweir }
1370cdf0e10cSrcweir }
1371cdf0e10cSrcweir
1372cdf0e10cSrcweir
DeleteAreaTab(const ScRange & rRange,sal_uInt16 nDelFlag)1373cdf0e10cSrcweir void ScDocument::DeleteAreaTab( const ScRange& rRange, sal_uInt16 nDelFlag )
1374cdf0e10cSrcweir {
1375cdf0e10cSrcweir for ( SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); nTab++ )
1376cdf0e10cSrcweir DeleteAreaTab( rRange.aStart.Col(), rRange.aStart.Row(),
1377cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Row(),
1378cdf0e10cSrcweir nTab, nDelFlag );
1379cdf0e10cSrcweir }
1380cdf0e10cSrcweir
1381cdf0e10cSrcweir
InitUndoSelected(ScDocument * pSrcDoc,const ScMarkData & rTabSelection,sal_Bool bColInfo,sal_Bool bRowInfo)1382cdf0e10cSrcweir void ScDocument::InitUndoSelected( ScDocument* pSrcDoc, const ScMarkData& rTabSelection,
1383cdf0e10cSrcweir sal_Bool bColInfo, sal_Bool bRowInfo )
1384cdf0e10cSrcweir {
1385cdf0e10cSrcweir if (bIsUndo)
1386cdf0e10cSrcweir {
1387cdf0e10cSrcweir Clear();
1388cdf0e10cSrcweir
1389cdf0e10cSrcweir xPoolHelper = pSrcDoc->xPoolHelper;
1390cdf0e10cSrcweir
1391cdf0e10cSrcweir String aString;
1392cdf0e10cSrcweir for (SCTAB nTab = 0; nTab <= MAXTAB; nTab++)
1393cdf0e10cSrcweir if ( rTabSelection.GetTableSelect( nTab ) )
1394cdf0e10cSrcweir {
1395cdf0e10cSrcweir pTab[nTab] = new ScTable(this, nTab, aString, bColInfo, bRowInfo);
1396cdf0e10cSrcweir nMaxTableNumber = nTab + 1;
1397cdf0e10cSrcweir }
1398cdf0e10cSrcweir }
1399cdf0e10cSrcweir else
1400cdf0e10cSrcweir {
1401cdf0e10cSrcweir DBG_ERROR("InitUndo");
1402cdf0e10cSrcweir }
1403cdf0e10cSrcweir }
1404cdf0e10cSrcweir
1405cdf0e10cSrcweir
InitUndo(ScDocument * pSrcDoc,SCTAB nTab1,SCTAB nTab2,sal_Bool bColInfo,sal_Bool bRowInfo)1406cdf0e10cSrcweir void ScDocument::InitUndo( ScDocument* pSrcDoc, SCTAB nTab1, SCTAB nTab2,
1407cdf0e10cSrcweir sal_Bool bColInfo, sal_Bool bRowInfo )
1408cdf0e10cSrcweir {
1409cdf0e10cSrcweir if (bIsUndo)
1410cdf0e10cSrcweir {
1411cdf0e10cSrcweir Clear();
1412cdf0e10cSrcweir
1413cdf0e10cSrcweir xPoolHelper = pSrcDoc->xPoolHelper;
1414cdf0e10cSrcweir
1415cdf0e10cSrcweir String aString;
1416cdf0e10cSrcweir for (SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
1417cdf0e10cSrcweir pTab[nTab] = new ScTable(this, nTab, aString, bColInfo, bRowInfo);
1418cdf0e10cSrcweir
1419cdf0e10cSrcweir nMaxTableNumber = nTab2 + 1;
1420cdf0e10cSrcweir }
1421cdf0e10cSrcweir else
1422cdf0e10cSrcweir {
1423cdf0e10cSrcweir DBG_ERROR("InitUndo");
1424cdf0e10cSrcweir }
1425cdf0e10cSrcweir }
1426cdf0e10cSrcweir
1427cdf0e10cSrcweir
AddUndoTab(SCTAB nTab1,SCTAB nTab2,sal_Bool bColInfo,sal_Bool bRowInfo)1428cdf0e10cSrcweir void ScDocument::AddUndoTab( SCTAB nTab1, SCTAB nTab2, sal_Bool bColInfo, sal_Bool bRowInfo )
1429cdf0e10cSrcweir {
1430cdf0e10cSrcweir if (bIsUndo)
1431cdf0e10cSrcweir {
1432cdf0e10cSrcweir String aString;
1433cdf0e10cSrcweir for (SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
1434cdf0e10cSrcweir if (!pTab[nTab])
1435cdf0e10cSrcweir pTab[nTab] = new ScTable(this, nTab, aString, bColInfo, bRowInfo);
1436cdf0e10cSrcweir
1437cdf0e10cSrcweir if ( nMaxTableNumber <= nTab2 )
1438cdf0e10cSrcweir nMaxTableNumber = nTab2 + 1;
1439cdf0e10cSrcweir }
1440cdf0e10cSrcweir else
1441cdf0e10cSrcweir {
1442cdf0e10cSrcweir DBG_ERROR("InitUndo");
1443cdf0e10cSrcweir }
1444cdf0e10cSrcweir }
1445cdf0e10cSrcweir
1446cdf0e10cSrcweir
SetCutMode(sal_Bool bVal)1447cdf0e10cSrcweir void ScDocument::SetCutMode( sal_Bool bVal )
1448cdf0e10cSrcweir {
1449cdf0e10cSrcweir if (bIsClip)
1450cdf0e10cSrcweir GetClipParam().mbCutMode = bVal;
1451cdf0e10cSrcweir else
1452cdf0e10cSrcweir {
1453cdf0e10cSrcweir DBG_ERROR("SetCutMode without bIsClip");
1454cdf0e10cSrcweir }
1455cdf0e10cSrcweir }
1456cdf0e10cSrcweir
1457cdf0e10cSrcweir
IsCutMode()1458cdf0e10cSrcweir sal_Bool ScDocument::IsCutMode()
1459cdf0e10cSrcweir {
1460cdf0e10cSrcweir if (bIsClip)
1461cdf0e10cSrcweir return GetClipParam().mbCutMode;
1462cdf0e10cSrcweir else
1463cdf0e10cSrcweir {
1464cdf0e10cSrcweir DBG_ERROR("IsCutMode ohne bIsClip");
1465cdf0e10cSrcweir return sal_False;
1466cdf0e10cSrcweir }
1467cdf0e10cSrcweir }
1468cdf0e10cSrcweir
1469cdf0e10cSrcweir
CopyToDocument(SCCOL nCol1,SCROW nRow1,SCTAB nTab1,SCCOL nCol2,SCROW nRow2,SCTAB nTab2,sal_uInt16 nFlags,sal_Bool bOnlyMarked,ScDocument * pDestDoc,const ScMarkData * pMarks,sal_Bool bColRowFlags)1470cdf0e10cSrcweir void ScDocument::CopyToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1471cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
1472cdf0e10cSrcweir sal_uInt16 nFlags, sal_Bool bOnlyMarked, ScDocument* pDestDoc,
1473cdf0e10cSrcweir const ScMarkData* pMarks, sal_Bool bColRowFlags )
1474cdf0e10cSrcweir {
1475cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
1476cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
1477cdf0e10cSrcweir PutInOrder( nTab1, nTab2 );
1478cdf0e10cSrcweir if( !pDestDoc->aDocName.Len() )
1479cdf0e10cSrcweir pDestDoc->aDocName = aDocName;
1480cdf0e10cSrcweir if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
1481cdf0e10cSrcweir {
1482cdf0e10cSrcweir sal_Bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1483cdf0e10cSrcweir pDestDoc->SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1484cdf0e10cSrcweir for (SCTAB i = nTab1; i <= nTab2; i++)
1485cdf0e10cSrcweir {
1486cdf0e10cSrcweir if (pTab[i] && pDestDoc->pTab[i])
1487cdf0e10cSrcweir pTab[i]->CopyToTable( nCol1, nRow1, nCol2, nRow2, nFlags,
1488cdf0e10cSrcweir bOnlyMarked, pDestDoc->pTab[i], pMarks,
1489cdf0e10cSrcweir sal_False, bColRowFlags );
1490cdf0e10cSrcweir }
1491cdf0e10cSrcweir pDestDoc->SetAutoCalc( bOldAutoCalc );
1492cdf0e10cSrcweir }
1493cdf0e10cSrcweir }
1494cdf0e10cSrcweir
1495cdf0e10cSrcweir
UndoToDocument(SCCOL nCol1,SCROW nRow1,SCTAB nTab1,SCCOL nCol2,SCROW nRow2,SCTAB nTab2,sal_uInt16 nFlags,sal_Bool bOnlyMarked,ScDocument * pDestDoc,const ScMarkData * pMarks)1496cdf0e10cSrcweir void ScDocument::UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1497cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
1498cdf0e10cSrcweir sal_uInt16 nFlags, sal_Bool bOnlyMarked, ScDocument* pDestDoc,
1499cdf0e10cSrcweir const ScMarkData* pMarks)
1500cdf0e10cSrcweir {
1501cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
1502cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
1503cdf0e10cSrcweir PutInOrder( nTab1, nTab2 );
1504cdf0e10cSrcweir if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
1505cdf0e10cSrcweir {
1506cdf0e10cSrcweir sal_Bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1507cdf0e10cSrcweir pDestDoc->SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1508cdf0e10cSrcweir if (nTab1 > 0)
1509cdf0e10cSrcweir CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, IDF_FORMULA, sal_False, pDestDoc, pMarks );
1510cdf0e10cSrcweir
1511cdf0e10cSrcweir for (SCTAB i = nTab1; i <= nTab2; i++)
1512cdf0e10cSrcweir {
1513cdf0e10cSrcweir if (pTab[i] && pDestDoc->pTab[i])
1514cdf0e10cSrcweir pTab[i]->UndoToTable(nCol1, nRow1, nCol2, nRow2, nFlags,
1515cdf0e10cSrcweir bOnlyMarked, pDestDoc->pTab[i], pMarks);
1516cdf0e10cSrcweir }
1517cdf0e10cSrcweir
1518cdf0e10cSrcweir if (nTab2 < MAXTAB)
1519cdf0e10cSrcweir CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,MAXTAB, IDF_FORMULA, sal_False, pDestDoc, pMarks );
1520cdf0e10cSrcweir pDestDoc->SetAutoCalc( bOldAutoCalc );
1521cdf0e10cSrcweir }
1522cdf0e10cSrcweir }
1523cdf0e10cSrcweir
1524cdf0e10cSrcweir
CopyToDocument(const ScRange & rRange,sal_uInt16 nFlags,sal_Bool bOnlyMarked,ScDocument * pDestDoc,const ScMarkData * pMarks,sal_Bool bColRowFlags)1525cdf0e10cSrcweir void ScDocument::CopyToDocument(const ScRange& rRange,
1526cdf0e10cSrcweir sal_uInt16 nFlags, sal_Bool bOnlyMarked, ScDocument* pDestDoc,
1527cdf0e10cSrcweir const ScMarkData* pMarks, sal_Bool bColRowFlags)
1528cdf0e10cSrcweir {
1529cdf0e10cSrcweir ScRange aNewRange = rRange;
1530cdf0e10cSrcweir aNewRange.Justify();
1531cdf0e10cSrcweir
1532cdf0e10cSrcweir if( !pDestDoc->aDocName.Len() )
1533cdf0e10cSrcweir pDestDoc->aDocName = aDocName;
1534cdf0e10cSrcweir sal_Bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1535cdf0e10cSrcweir pDestDoc->SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1536cdf0e10cSrcweir for (SCTAB i = aNewRange.aStart.Tab(); i <= aNewRange.aEnd.Tab(); i++)
1537cdf0e10cSrcweir if (pTab[i] && pDestDoc->pTab[i])
1538cdf0e10cSrcweir pTab[i]->CopyToTable(aNewRange.aStart.Col(), aNewRange.aStart.Row(),
1539cdf0e10cSrcweir aNewRange.aEnd.Col(), aNewRange.aEnd.Row(),
1540cdf0e10cSrcweir nFlags, bOnlyMarked, pDestDoc->pTab[i],
1541cdf0e10cSrcweir pMarks, sal_False, bColRowFlags);
1542cdf0e10cSrcweir pDestDoc->SetAutoCalc( bOldAutoCalc );
1543cdf0e10cSrcweir }
1544cdf0e10cSrcweir
1545cdf0e10cSrcweir
UndoToDocument(const ScRange & rRange,sal_uInt16 nFlags,sal_Bool bOnlyMarked,ScDocument * pDestDoc,const ScMarkData * pMarks)1546cdf0e10cSrcweir void ScDocument::UndoToDocument(const ScRange& rRange,
1547cdf0e10cSrcweir sal_uInt16 nFlags, sal_Bool bOnlyMarked, ScDocument* pDestDoc,
1548cdf0e10cSrcweir const ScMarkData* pMarks)
1549cdf0e10cSrcweir {
1550cdf0e10cSrcweir ScRange aNewRange = rRange;
1551cdf0e10cSrcweir aNewRange.Justify();
1552cdf0e10cSrcweir SCTAB nTab1 = aNewRange.aStart.Tab();
1553cdf0e10cSrcweir SCTAB nTab2 = aNewRange.aEnd.Tab();
1554cdf0e10cSrcweir
1555cdf0e10cSrcweir sal_Bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1556cdf0e10cSrcweir pDestDoc->SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
1557cdf0e10cSrcweir if (nTab1 > 0)
1558cdf0e10cSrcweir CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, IDF_FORMULA, sal_False, pDestDoc, pMarks );
1559cdf0e10cSrcweir
1560cdf0e10cSrcweir for (SCTAB i = nTab1; i <= nTab2; i++)
1561cdf0e10cSrcweir {
1562cdf0e10cSrcweir if (pTab[i] && pDestDoc->pTab[i])
1563cdf0e10cSrcweir pTab[i]->UndoToTable(aNewRange.aStart.Col(), aNewRange.aStart.Row(),
1564cdf0e10cSrcweir aNewRange.aEnd.Col(), aNewRange.aEnd.Row(),
1565cdf0e10cSrcweir nFlags, bOnlyMarked, pDestDoc->pTab[i], pMarks);
1566cdf0e10cSrcweir }
1567cdf0e10cSrcweir
1568cdf0e10cSrcweir if (nTab2 < MAXTAB)
1569cdf0e10cSrcweir CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,MAXTAB, IDF_FORMULA, sal_False, pDestDoc, pMarks );
1570cdf0e10cSrcweir pDestDoc->SetAutoCalc( bOldAutoCalc );
1571cdf0e10cSrcweir }
1572cdf0e10cSrcweir
CopyToClip(const ScClipParam & rClipParam,ScDocument * pClipDoc,const ScMarkData * pMarks,bool bAllTabs,bool bKeepScenarioFlags,bool bIncludeObjects,bool bCloneNoteCaptions)1573cdf0e10cSrcweir void ScDocument::CopyToClip(const ScClipParam& rClipParam,
1574cdf0e10cSrcweir ScDocument* pClipDoc, const ScMarkData* pMarks,
1575cdf0e10cSrcweir bool bAllTabs, bool bKeepScenarioFlags, bool bIncludeObjects, bool bCloneNoteCaptions)
1576cdf0e10cSrcweir {
1577cdf0e10cSrcweir DBG_ASSERT( bAllTabs || pMarks, "CopyToClip: ScMarkData fehlt" );
1578cdf0e10cSrcweir
1579cdf0e10cSrcweir if (bIsClip)
1580cdf0e10cSrcweir return;
1581cdf0e10cSrcweir
1582cdf0e10cSrcweir if (!pClipDoc)
1583cdf0e10cSrcweir {
1584cdf0e10cSrcweir DBG_ERROR("CopyToClip: no ClipDoc");
1585cdf0e10cSrcweir pClipDoc = SC_MOD()->GetClipDoc();
1586cdf0e10cSrcweir }
1587cdf0e10cSrcweir
1588cdf0e10cSrcweir pClipDoc->aDocName = aDocName;
1589cdf0e10cSrcweir pClipDoc->SetClipParam(rClipParam);
1590cdf0e10cSrcweir pClipDoc->ResetClip(this, pMarks);
1591cdf0e10cSrcweir
1592cdf0e10cSrcweir ScRange aClipRange = rClipParam.getWholeRange();
1593cdf0e10cSrcweir CopyRangeNamesToClip(pClipDoc, aClipRange, pMarks, bAllTabs);
1594cdf0e10cSrcweir
1595cdf0e10cSrcweir for (SCTAB i = 0; i <= MAXTAB; ++i)
1596cdf0e10cSrcweir {
1597cdf0e10cSrcweir if (!pTab[i] || !pClipDoc->pTab[i])
1598cdf0e10cSrcweir continue;
1599cdf0e10cSrcweir
1600cdf0e10cSrcweir if (pMarks && !pMarks->GetTableSelect(i))
1601cdf0e10cSrcweir continue;
1602cdf0e10cSrcweir
1603cdf0e10cSrcweir pTab[i]->CopyToClip(rClipParam.maRanges, pClipDoc->pTab[i], bKeepScenarioFlags, bCloneNoteCaptions);
1604cdf0e10cSrcweir
1605cdf0e10cSrcweir if (pDrawLayer && bIncludeObjects)
1606cdf0e10cSrcweir {
1607cdf0e10cSrcweir // also copy drawing objects
1608cdf0e10cSrcweir Rectangle aObjRect = GetMMRect(
1609cdf0e10cSrcweir aClipRange.aStart.Col(), aClipRange.aStart.Row(), aClipRange.aEnd.Col(), aClipRange.aEnd.Row(), i);
1610cdf0e10cSrcweir pDrawLayer->CopyToClip(pClipDoc, i, aObjRect);
1611cdf0e10cSrcweir }
1612cdf0e10cSrcweir }
1613cdf0e10cSrcweir
1614cdf0e10cSrcweir // Make sure to mark overlapped cells.
1615cdf0e10cSrcweir pClipDoc->ExtendMerge(aClipRange, true);
1616cdf0e10cSrcweir }
1617cdf0e10cSrcweir
CopyTabToClip(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,SCTAB nTab,ScDocument * pClipDoc)1618cdf0e10cSrcweir void ScDocument::CopyTabToClip(SCCOL nCol1, SCROW nRow1,
1619cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
1620cdf0e10cSrcweir SCTAB nTab, ScDocument* pClipDoc)
1621cdf0e10cSrcweir {
1622cdf0e10cSrcweir if (!bIsClip)
1623cdf0e10cSrcweir {
1624cdf0e10cSrcweir PutInOrder( nCol1, nCol2 );
1625cdf0e10cSrcweir PutInOrder( nRow1, nRow2 );
1626cdf0e10cSrcweir if (!pClipDoc)
1627cdf0e10cSrcweir {
1628cdf0e10cSrcweir DBG_ERROR("CopyTabToClip: no ClipDoc");
1629cdf0e10cSrcweir pClipDoc = SC_MOD()->GetClipDoc();
1630cdf0e10cSrcweir }
1631cdf0e10cSrcweir
1632cdf0e10cSrcweir ScClipParam& rClipParam = pClipDoc->GetClipParam();
1633cdf0e10cSrcweir pClipDoc->aDocName = aDocName;
1634cdf0e10cSrcweir rClipParam.maRanges.RemoveAll();
1635cdf0e10cSrcweir rClipParam.maRanges.Append(ScRange(nCol1, nRow1, 0, nCol2, nRow2, 0));
1636cdf0e10cSrcweir pClipDoc->ResetClip( this, nTab );
1637cdf0e10cSrcweir
1638cdf0e10cSrcweir if (pTab[nTab] && pClipDoc->pTab[nTab])
1639cdf0e10cSrcweir pTab[nTab]->CopyToClip(nCol1, nRow1, nCol2, nRow2, pClipDoc->pTab[nTab], sal_False, sal_True);
1640cdf0e10cSrcweir
1641cdf0e10cSrcweir pClipDoc->GetClipParam().mbCutMode = false;
1642cdf0e10cSrcweir }
1643cdf0e10cSrcweir }
1644cdf0e10cSrcweir
1645cdf0e10cSrcweir
TransposeClip(ScDocument * pTransClip,sal_uInt16 nFlags,sal_Bool bAsLink)1646cdf0e10cSrcweir void ScDocument::TransposeClip( ScDocument* pTransClip, sal_uInt16 nFlags, sal_Bool bAsLink )
1647cdf0e10cSrcweir {
1648cdf0e10cSrcweir DBG_ASSERT( bIsClip && pTransClip && pTransClip->bIsClip,
1649cdf0e10cSrcweir "TransposeClip mit falschem Dokument" );
1650cdf0e10cSrcweir
1651cdf0e10cSrcweir // initialisieren
1652cdf0e10cSrcweir // -> pTransClip muss vor dem Original-Dokument geloescht werden!
1653cdf0e10cSrcweir
1654cdf0e10cSrcweir pTransClip->ResetClip(this, (ScMarkData*)NULL); // alle
1655cdf0e10cSrcweir
1656cdf0e10cSrcweir // Bereiche uebernehmen
1657cdf0e10cSrcweir
1658cdf0e10cSrcweir pTransClip->pRangeName->FreeAll();
1659cdf0e10cSrcweir for (sal_uInt16 i = 0; i < pRangeName->GetCount(); i++) //! DB-Bereiche Pivot-Bereiche auch !!!
1660cdf0e10cSrcweir {
1661cdf0e10cSrcweir sal_uInt16 nIndex = ((ScRangeData*)((*pRangeName)[i]))->GetIndex();
1662cdf0e10cSrcweir ScRangeData* pData = new ScRangeData(*((*pRangeName)[i]));
1663cdf0e10cSrcweir if (!pTransClip->pRangeName->Insert(pData))
1664cdf0e10cSrcweir delete pData;
1665cdf0e10cSrcweir else
1666cdf0e10cSrcweir pData->SetIndex(nIndex);
1667cdf0e10cSrcweir }
1668cdf0e10cSrcweir
1669cdf0e10cSrcweir // Daten
1670cdf0e10cSrcweir
1671cdf0e10cSrcweir ScRange aClipRange = GetClipParam().getWholeRange();
1672cdf0e10cSrcweir if ( ValidRow(aClipRange.aEnd.Row()-aClipRange.aStart.Row()) )
1673cdf0e10cSrcweir {
1674cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
1675cdf0e10cSrcweir if (pTab[i])
1676cdf0e10cSrcweir {
1677cdf0e10cSrcweir DBG_ASSERT( pTransClip->pTab[i], "TransposeClip: Tabelle nicht da" );
1678cdf0e10cSrcweir pTab[i]->TransposeClip( aClipRange.aStart.Col(), aClipRange.aStart.Row(),
1679cdf0e10cSrcweir aClipRange.aEnd.Col(), aClipRange.aEnd.Row(),
1680cdf0e10cSrcweir pTransClip->pTab[i], nFlags, bAsLink );
1681cdf0e10cSrcweir
1682cdf0e10cSrcweir if ( pDrawLayer && ( nFlags & IDF_OBJECTS ) )
1683cdf0e10cSrcweir {
1684cdf0e10cSrcweir // Drawing objects are copied to the new area without transposing.
1685cdf0e10cSrcweir // CopyFromClip is used to adjust the objects to the transposed block's
1686cdf0e10cSrcweir // cell range area.
1687cdf0e10cSrcweir // (pDrawLayer in the original clipboard document is set only if there
1688cdf0e10cSrcweir // are drawing objects to copy)
1689cdf0e10cSrcweir
1690cdf0e10cSrcweir pTransClip->InitDrawLayer();
1691cdf0e10cSrcweir Rectangle aSourceRect = GetMMRect( aClipRange.aStart.Col(), aClipRange.aStart.Row(),
1692cdf0e10cSrcweir aClipRange.aEnd.Col(), aClipRange.aEnd.Row(), i );
1693cdf0e10cSrcweir Rectangle aDestRect = pTransClip->GetMMRect( 0, 0,
1694cdf0e10cSrcweir static_cast<SCCOL>(aClipRange.aEnd.Row() - aClipRange.aStart.Row()),
1695cdf0e10cSrcweir static_cast<SCROW>(aClipRange.aEnd.Col() - aClipRange.aStart.Col()), i );
1696cdf0e10cSrcweir pTransClip->pDrawLayer->CopyFromClip( pDrawLayer, i, aSourceRect, ScAddress(0,0,i), aDestRect );
1697cdf0e10cSrcweir }
1698cdf0e10cSrcweir }
1699cdf0e10cSrcweir
1700cdf0e10cSrcweir pTransClip->SetClipParam(GetClipParam());
1701cdf0e10cSrcweir pTransClip->GetClipParam().transpose();
1702cdf0e10cSrcweir }
1703cdf0e10cSrcweir else
1704cdf0e10cSrcweir {
1705cdf0e10cSrcweir DBG_ERROR("TransposeClip: zu gross");
1706cdf0e10cSrcweir }
1707cdf0e10cSrcweir
1708cdf0e10cSrcweir // Dies passiert erst beim Einfuegen...
1709cdf0e10cSrcweir
1710cdf0e10cSrcweir GetClipParam().mbCutMode = false;
1711cdf0e10cSrcweir }
1712cdf0e10cSrcweir
CopyRangeNamesToClip(ScDocument * pClipDoc,const ScRange & rClipRange,const ScMarkData * pMarks,bool bAllTabs)1713cdf0e10cSrcweir void ScDocument::CopyRangeNamesToClip(ScDocument* pClipDoc, const ScRange& rClipRange, const ScMarkData* pMarks, bool bAllTabs)
1714cdf0e10cSrcweir {
1715cdf0e10cSrcweir std::set<sal_uInt16> aUsedNames; // indexes of named ranges that are used in the copied cells
1716cdf0e10cSrcweir for (SCTAB i = 0; i <= MAXTAB; ++i)
1717cdf0e10cSrcweir if (pTab[i] && pClipDoc->pTab[i])
1718cdf0e10cSrcweir if ( bAllTabs || !pMarks || pMarks->GetTableSelect(i) )
1719cdf0e10cSrcweir pTab[i]->FindRangeNamesInUse(
1720cdf0e10cSrcweir rClipRange.aStart.Col(), rClipRange.aStart.Row(),
1721cdf0e10cSrcweir rClipRange.aEnd.Col(), rClipRange.aEnd.Row(), aUsedNames);
1722cdf0e10cSrcweir
1723cdf0e10cSrcweir pClipDoc->pRangeName->FreeAll();
1724cdf0e10cSrcweir for (sal_uInt16 i = 0; i < pRangeName->GetCount(); i++) //! DB-Bereiche Pivot-Bereiche auch !!!
1725cdf0e10cSrcweir {
1726cdf0e10cSrcweir sal_uInt16 nIndex = ((ScRangeData*)((*pRangeName)[i]))->GetIndex();
1727cdf0e10cSrcweir bool bInUse = ( aUsedNames.find(nIndex) != aUsedNames.end() );
1728cdf0e10cSrcweir if (bInUse)
1729cdf0e10cSrcweir {
1730cdf0e10cSrcweir ScRangeData* pData = new ScRangeData(*((*pRangeName)[i]));
1731cdf0e10cSrcweir if (!pClipDoc->pRangeName->Insert(pData))
1732cdf0e10cSrcweir delete pData;
1733cdf0e10cSrcweir else
1734cdf0e10cSrcweir pData->SetIndex(nIndex);
1735cdf0e10cSrcweir }
1736cdf0e10cSrcweir }
1737cdf0e10cSrcweir }
1738cdf0e10cSrcweir
NumFmtMergeHandler(ScDocument * pDoc,ScDocument * pSrcDoc)1739cdf0e10cSrcweir ScDocument::NumFmtMergeHandler::NumFmtMergeHandler(ScDocument* pDoc, ScDocument* pSrcDoc) :
1740cdf0e10cSrcweir mpDoc(pDoc)
1741cdf0e10cSrcweir {
1742cdf0e10cSrcweir mpDoc->MergeNumberFormatter(pSrcDoc);
1743cdf0e10cSrcweir }
1744cdf0e10cSrcweir
~NumFmtMergeHandler()1745cdf0e10cSrcweir ScDocument::NumFmtMergeHandler::~NumFmtMergeHandler()
1746cdf0e10cSrcweir {
1747cdf0e10cSrcweir mpDoc->pFormatExchangeList = NULL;
1748cdf0e10cSrcweir }
1749cdf0e10cSrcweir
MergeNumberFormatter(ScDocument * pSrcDoc)1750cdf0e10cSrcweir void ScDocument::MergeNumberFormatter(ScDocument* pSrcDoc)
1751cdf0e10cSrcweir {
1752cdf0e10cSrcweir SvNumberFormatter* pThisFormatter = xPoolHelper->GetFormTable();
1753cdf0e10cSrcweir SvNumberFormatter* pOtherFormatter = pSrcDoc->xPoolHelper->GetFormTable();
1754cdf0e10cSrcweir if (pOtherFormatter && pOtherFormatter != pThisFormatter)
1755cdf0e10cSrcweir {
1756cdf0e10cSrcweir SvNumberFormatterIndexTable* pExchangeList =
1757cdf0e10cSrcweir pThisFormatter->MergeFormatter(*(pOtherFormatter));
1758cdf0e10cSrcweir if (pExchangeList->Count() > 0)
1759cdf0e10cSrcweir pFormatExchangeList = pExchangeList;
1760cdf0e10cSrcweir }
1761cdf0e10cSrcweir }
1762cdf0e10cSrcweir
CopyRangeNamesFromClip(ScDocument * pClipDoc,ScClipRangeNameData & rRangeNames)1763cdf0e10cSrcweir void ScDocument::CopyRangeNamesFromClip(ScDocument* pClipDoc, ScClipRangeNameData& rRangeNames)
1764cdf0e10cSrcweir {
1765cdf0e10cSrcweir sal_uInt16 nClipRangeNameCount = pClipDoc->pRangeName->GetCount();
1766cdf0e10cSrcweir ScClipRangeNameData aClipRangeNames;
1767cdf0e10cSrcweir
1768cdf0e10cSrcweir // array containing range names which might need update of indices
1769cdf0e10cSrcweir aClipRangeNames.mpRangeNames.resize(nClipRangeNameCount, NULL);
1770cdf0e10cSrcweir
1771cdf0e10cSrcweir for (sal_uInt16 i = 0; i < nClipRangeNameCount; ++i) //! DB-Bereiche Pivot-Bereiche auch
1772cdf0e10cSrcweir {
1773cdf0e10cSrcweir /* Copy only if the name doesn't exist in this document.
1774cdf0e10cSrcweir If it exists we use the already existing name instead,
1775cdf0e10cSrcweir another possibility could be to create new names if
1776cdf0e10cSrcweir documents differ.
1777cdf0e10cSrcweir A proper solution would ask the user how to proceed.
1778cdf0e10cSrcweir The adjustment of the indices in the formulas is done later.
1779cdf0e10cSrcweir */
1780cdf0e10cSrcweir ScRangeData* pClipRangeData = (*pClipDoc->pRangeName)[i];
1781cdf0e10cSrcweir sal_uInt16 k;
1782cdf0e10cSrcweir if ( pRangeName->SearchName( pClipRangeData->GetName(), k ) )
1783cdf0e10cSrcweir {
1784cdf0e10cSrcweir aClipRangeNames.mpRangeNames[i] = NULL; // range name not inserted
1785cdf0e10cSrcweir sal_uInt16 nOldIndex = pClipRangeData->GetIndex();
1786cdf0e10cSrcweir sal_uInt16 nNewIndex = ((*pRangeName)[k])->GetIndex();
1787cdf0e10cSrcweir aClipRangeNames.insert(nOldIndex, nNewIndex);
1788cdf0e10cSrcweir if ( !aClipRangeNames.mbReplace )
1789cdf0e10cSrcweir aClipRangeNames.mbReplace = ( nOldIndex != nNewIndex );
1790cdf0e10cSrcweir }
1791cdf0e10cSrcweir else
1792cdf0e10cSrcweir {
1793cdf0e10cSrcweir ScRangeData* pData = new ScRangeData( *pClipRangeData );
1794cdf0e10cSrcweir pData->SetDocument(this);
1795cdf0e10cSrcweir if ( pRangeName->FindIndex( pData->GetIndex() ) )
1796cdf0e10cSrcweir pData->SetIndex(0); // need new index, done in Insert
1797cdf0e10cSrcweir if ( pRangeName->Insert( pData ) )
1798cdf0e10cSrcweir {
1799cdf0e10cSrcweir aClipRangeNames.mpRangeNames[i] = pData;
1800cdf0e10cSrcweir sal_uInt16 nOldIndex = pClipRangeData->GetIndex();
1801cdf0e10cSrcweir sal_uInt16 nNewIndex = pData->GetIndex();
1802cdf0e10cSrcweir aClipRangeNames.insert(nOldIndex, nNewIndex);
1803cdf0e10cSrcweir if ( !aClipRangeNames.mbReplace )
1804cdf0e10cSrcweir aClipRangeNames.mbReplace = ( nOldIndex != nNewIndex );
1805cdf0e10cSrcweir }
1806cdf0e10cSrcweir else
1807cdf0e10cSrcweir { // must be an overflow
1808cdf0e10cSrcweir delete pData;
1809cdf0e10cSrcweir aClipRangeNames.mpRangeNames[i] = NULL;
1810cdf0e10cSrcweir aClipRangeNames.insert(pClipRangeData->GetIndex(), 0);
1811cdf0e10cSrcweir aClipRangeNames.mbReplace = true;
1812cdf0e10cSrcweir }
1813cdf0e10cSrcweir }
1814cdf0e10cSrcweir }
1815cdf0e10cSrcweir rRangeNames = aClipRangeNames;
1816cdf0e10cSrcweir }
1817cdf0e10cSrcweir
UpdateRangeNamesInFormulas(ScClipRangeNameData & rRangeNames,const ScRangeList & rDestRanges,const ScMarkData & rMark,SCCOL nXw,SCROW nYw)1818cdf0e10cSrcweir void ScDocument::UpdateRangeNamesInFormulas(
1819cdf0e10cSrcweir ScClipRangeNameData& rRangeNames, const ScRangeList& rDestRanges, const ScMarkData& rMark,
1820cdf0e10cSrcweir SCCOL nXw, SCROW nYw)
1821cdf0e10cSrcweir {
1822cdf0e10cSrcweir // nXw and nYw are the extra width and height of the destination range
1823cdf0e10cSrcweir // extended due to presence of merged cell(s).
1824cdf0e10cSrcweir
1825cdf0e10cSrcweir if (!rRangeNames.mbReplace)
1826cdf0e10cSrcweir return;
1827cdf0e10cSrcweir
1828cdf0e10cSrcweir // first update all inserted named formulas if they contain other
1829cdf0e10cSrcweir // range names and used indices changed
1830cdf0e10cSrcweir size_t nRangeNameCount = rRangeNames.mpRangeNames.size();
1831cdf0e10cSrcweir for (size_t i = 0; i < nRangeNameCount; ++i) //! DB-Bereiche Pivot-Bereiche auch
1832cdf0e10cSrcweir {
1833cdf0e10cSrcweir if ( rRangeNames.mpRangeNames[i] )
1834cdf0e10cSrcweir rRangeNames.mpRangeNames[i]->ReplaceRangeNamesInUse(rRangeNames.maRangeMap);
1835cdf0e10cSrcweir }
1836cdf0e10cSrcweir // then update the formulas, they might need just the updated range names
1837cdf0e10cSrcweir for (sal_uLong nRange = 0; nRange < rDestRanges.Count(); ++nRange)
1838cdf0e10cSrcweir {
1839cdf0e10cSrcweir const ScRange* pRange = rDestRanges.GetObject( nRange);
1840cdf0e10cSrcweir SCCOL nCol1 = pRange->aStart.Col();
1841cdf0e10cSrcweir SCROW nRow1 = pRange->aStart.Row();
1842cdf0e10cSrcweir SCCOL nCol2 = pRange->aEnd.Col();
1843cdf0e10cSrcweir SCROW nRow2 = pRange->aEnd.Row();
1844cdf0e10cSrcweir
1845cdf0e10cSrcweir SCCOL nC1 = nCol1;
1846cdf0e10cSrcweir SCROW nR1 = nRow1;
1847cdf0e10cSrcweir SCCOL nC2 = nC1 + nXw;
1848cdf0e10cSrcweir if (nC2 > nCol2)
1849cdf0e10cSrcweir nC2 = nCol2;
1850cdf0e10cSrcweir SCROW nR2 = nR1 + nYw;
1851cdf0e10cSrcweir if (nR2 > nRow2)
1852cdf0e10cSrcweir nR2 = nRow2;
1853cdf0e10cSrcweir do
1854cdf0e10cSrcweir {
1855cdf0e10cSrcweir do
1856cdf0e10cSrcweir {
1857cdf0e10cSrcweir for (SCTAB k = 0; k <= MAXTAB; k++)
1858cdf0e10cSrcweir {
1859cdf0e10cSrcweir if ( pTab[k] && rMark.GetTableSelect(k) )
1860cdf0e10cSrcweir pTab[k]->ReplaceRangeNamesInUse(nC1, nR1,
1861cdf0e10cSrcweir nC2, nR2, rRangeNames.maRangeMap);
1862cdf0e10cSrcweir }
1863cdf0e10cSrcweir nC1 = nC2 + 1;
1864cdf0e10cSrcweir nC2 = Min((SCCOL)(nC1 + nXw), nCol2);
1865cdf0e10cSrcweir } while (nC1 <= nCol2);
1866cdf0e10cSrcweir nC1 = nCol1;
1867cdf0e10cSrcweir nC2 = nC1 + nXw;
1868cdf0e10cSrcweir if (nC2 > nCol2)
1869cdf0e10cSrcweir nC2 = nCol2;
1870cdf0e10cSrcweir nR1 = nR2 + 1;
1871cdf0e10cSrcweir nR2 = Min((SCROW)(nR1 + nYw), nRow2);
1872cdf0e10cSrcweir } while (nR1 <= nRow2);
1873cdf0e10cSrcweir }
1874cdf0e10cSrcweir }
1875cdf0e10cSrcweir
GetClipParam()1876cdf0e10cSrcweir ScClipParam& ScDocument::GetClipParam()
1877cdf0e10cSrcweir {
1878cdf0e10cSrcweir if (!mpClipParam.get())
1879cdf0e10cSrcweir mpClipParam.reset(new ScClipParam);
1880cdf0e10cSrcweir
1881cdf0e10cSrcweir return *mpClipParam;
1882cdf0e10cSrcweir }
1883cdf0e10cSrcweir
SetClipParam(const ScClipParam & rParam)1884cdf0e10cSrcweir void ScDocument::SetClipParam(const ScClipParam& rParam)
1885cdf0e10cSrcweir {
1886cdf0e10cSrcweir mpClipParam.reset(new ScClipParam(rParam));
1887cdf0e10cSrcweir }
1888cdf0e10cSrcweir
IsClipboardSource() const1889cdf0e10cSrcweir sal_Bool ScDocument::IsClipboardSource() const
1890cdf0e10cSrcweir {
1891cdf0e10cSrcweir ScDocument* pClipDoc = SC_MOD()->GetClipDoc();
1892cdf0e10cSrcweir return pClipDoc && pClipDoc->xPoolHelper.isValid() &&
1893cdf0e10cSrcweir xPoolHelper->GetDocPool() == pClipDoc->xPoolHelper->GetDocPool();
1894cdf0e10cSrcweir }
1895cdf0e10cSrcweir
1896cdf0e10cSrcweir
StartListeningFromClip(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,const ScMarkData & rMark,sal_uInt16 nInsFlag)1897cdf0e10cSrcweir void ScDocument::StartListeningFromClip( SCCOL nCol1, SCROW nRow1,
1898cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
1899cdf0e10cSrcweir const ScMarkData& rMark, sal_uInt16 nInsFlag )
1900cdf0e10cSrcweir {
1901cdf0e10cSrcweir if (nInsFlag & IDF_CONTENTS)
1902cdf0e10cSrcweir {
1903cdf0e10cSrcweir for (SCTAB i = 0; i <= MAXTAB; i++)
1904cdf0e10cSrcweir if (pTab[i])
1905cdf0e10cSrcweir if (rMark.GetTableSelect(i))
1906cdf0e10cSrcweir pTab[i]->StartListeningInArea( nCol1, nRow1, nCol2, nRow2 );
1907cdf0e10cSrcweir }
1908cdf0e10cSrcweir }
1909cdf0e10cSrcweir
1910cdf0e10cSrcweir
BroadcastFromClip(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,const ScMarkData & rMark,sal_uInt16 nInsFlag)1911cdf0e10cSrcweir void ScDocument::BroadcastFromClip( SCCOL nCol1, SCROW nRow1,
1912cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
1913cdf0e10cSrcweir const ScMarkData& rMark, sal_uInt16 nInsFlag )
1914cdf0e10cSrcweir {
1915cdf0e10cSrcweir if (nInsFlag & IDF_CONTENTS)
1916cdf0e10cSrcweir {
1917cdf0e10cSrcweir ScBulkBroadcast aBulkBroadcast( GetBASM());
1918cdf0e10cSrcweir for (SCTAB i = 0; i <= MAXTAB; i++)
1919cdf0e10cSrcweir if (pTab[i])
1920cdf0e10cSrcweir if (rMark.GetTableSelect(i))
1921cdf0e10cSrcweir pTab[i]->BroadcastInArea( nCol1, nRow1, nCol2, nRow2 );
1922cdf0e10cSrcweir }
1923cdf0e10cSrcweir }
1924cdf0e10cSrcweir
1925cdf0e10cSrcweir
CopyBlockFromClip(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,const ScMarkData & rMark,SCsCOL nDx,SCsROW nDy,const ScCopyBlockFromClipParams * pCBFCP)1926cdf0e10cSrcweir void ScDocument::CopyBlockFromClip( SCCOL nCol1, SCROW nRow1,
1927cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
1928cdf0e10cSrcweir const ScMarkData& rMark,
1929cdf0e10cSrcweir SCsCOL nDx, SCsROW nDy,
1930cdf0e10cSrcweir const ScCopyBlockFromClipParams* pCBFCP )
1931cdf0e10cSrcweir {
1932cdf0e10cSrcweir ScTable** ppClipTab = pCBFCP->pClipDoc->pTab;
1933cdf0e10cSrcweir SCTAB nTabEnd = pCBFCP->nTabEnd;
1934cdf0e10cSrcweir SCTAB nClipTab = 0;
1935cdf0e10cSrcweir for (SCTAB i = pCBFCP->nTabStart; i <= nTabEnd; i++)
1936cdf0e10cSrcweir {
1937cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i) )
1938cdf0e10cSrcweir {
1939cdf0e10cSrcweir while (!ppClipTab[nClipTab]) nClipTab = (nClipTab+1) % (MAXTAB+1);
1940cdf0e10cSrcweir
1941cdf0e10cSrcweir pTab[i]->CopyFromClip( nCol1, nRow1, nCol2, nRow2, nDx, nDy,
1942cdf0e10cSrcweir pCBFCP->nInsFlag, pCBFCP->bAsLink, pCBFCP->bSkipAttrForEmpty, ppClipTab[nClipTab] );
1943cdf0e10cSrcweir
1944cdf0e10cSrcweir if ( pCBFCP->pClipDoc->pDrawLayer && ( pCBFCP->nInsFlag & IDF_OBJECTS ) )
1945cdf0e10cSrcweir {
1946cdf0e10cSrcweir // also copy drawing objects
1947cdf0e10cSrcweir
1948cdf0e10cSrcweir // drawing layer must be created before calling CopyFromClip
1949cdf0e10cSrcweir // (ScDocShell::MakeDrawLayer also does InitItems etc.)
1950cdf0e10cSrcweir DBG_ASSERT( pDrawLayer, "CopyBlockFromClip: No drawing layer" );
1951cdf0e10cSrcweir if ( pDrawLayer )
1952cdf0e10cSrcweir {
1953cdf0e10cSrcweir // For GetMMRect, the row heights in the target document must already be valid
1954cdf0e10cSrcweir // (copied in an extra step before pasting, or updated after pasting cells, but
1955cdf0e10cSrcweir // before pasting objects).
1956cdf0e10cSrcweir
1957cdf0e10cSrcweir Rectangle aSourceRect = pCBFCP->pClipDoc->GetMMRect(
1958cdf0e10cSrcweir nCol1-nDx, nRow1-nDy, nCol2-nDx, nRow2-nDy, nClipTab );
1959cdf0e10cSrcweir Rectangle aDestRect = GetMMRect( nCol1, nRow1, nCol2, nRow2, i );
1960cdf0e10cSrcweir pDrawLayer->CopyFromClip( pCBFCP->pClipDoc->pDrawLayer, nClipTab, aSourceRect,
1961cdf0e10cSrcweir ScAddress( nCol1, nRow1, i ), aDestRect );
1962cdf0e10cSrcweir }
1963cdf0e10cSrcweir }
1964cdf0e10cSrcweir
1965cdf0e10cSrcweir nClipTab = (nClipTab+1) % (MAXTAB+1);
1966cdf0e10cSrcweir }
1967cdf0e10cSrcweir }
196846674298SDamjan Jovanovic if ( (pCBFCP->nInsFlag & IDF_CONTENTS) &&
1969*90c740b5SDamjan Jovanovic (pCBFCP->pClipDoc->GetClipParam().getSourceDocID() == 0 ||
1970*90c740b5SDamjan Jovanovic pCBFCP->pClipDoc->GetClipParam().getSourceDocID() == GetDocumentID()) ) // #118023# only update references for *intra-document* cut and paste
1971cdf0e10cSrcweir {
1972cdf0e10cSrcweir nClipTab = 0;
1973cdf0e10cSrcweir for (SCTAB i = pCBFCP->nTabStart; i <= nTabEnd; i++)
1974cdf0e10cSrcweir {
1975cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i) )
1976cdf0e10cSrcweir {
1977cdf0e10cSrcweir while (!ppClipTab[nClipTab]) nClipTab = (nClipTab+1) % (MAXTAB+1);
1978cdf0e10cSrcweir SCsTAB nDz = ((SCsTAB)i) - nClipTab;
1979cdf0e10cSrcweir
1980cdf0e10cSrcweir // #89081# ranges of consecutive selected tables (in clipboard and dest. doc)
1981cdf0e10cSrcweir // must be handled in one UpdateReference call
1982cdf0e10cSrcweir SCTAB nFollow = 0;
1983cdf0e10cSrcweir while ( i + nFollow < nTabEnd
1984cdf0e10cSrcweir && rMark.GetTableSelect( i + nFollow + 1 )
1985cdf0e10cSrcweir && nClipTab + nFollow < MAXTAB
1986cdf0e10cSrcweir && ppClipTab[nClipTab + nFollow + 1] )
1987cdf0e10cSrcweir ++nFollow;
1988cdf0e10cSrcweir
1989cdf0e10cSrcweir if ( pCBFCP->pClipDoc->GetClipParam().mbCutMode )
1990cdf0e10cSrcweir {
1991cdf0e10cSrcweir sal_Bool bOldInserting = IsInsertingFromOtherDoc();
1992cdf0e10cSrcweir SetInsertingFromOtherDoc( sal_True);
1993cdf0e10cSrcweir UpdateReference( URM_MOVE,
1994cdf0e10cSrcweir nCol1, nRow1, i, nCol2, nRow2, i+nFollow,
1995cdf0e10cSrcweir nDx, nDy, nDz, pCBFCP->pRefUndoDoc, sal_False );
1996cdf0e10cSrcweir SetInsertingFromOtherDoc( bOldInserting);
1997cdf0e10cSrcweir }
1998cdf0e10cSrcweir else
1999cdf0e10cSrcweir UpdateReference( URM_COPY,
2000cdf0e10cSrcweir nCol1, nRow1, i, nCol2, nRow2, i+nFollow,
2001cdf0e10cSrcweir nDx, nDy, nDz, pCBFCP->pRefUndoDoc, sal_False );
2002cdf0e10cSrcweir
2003cdf0e10cSrcweir nClipTab = (nClipTab+nFollow+1) % (MAXTAB+1);
2004cdf0e10cSrcweir i = sal::static_int_cast<SCTAB>( i + nFollow );
2005cdf0e10cSrcweir }
2006cdf0e10cSrcweir }
2007cdf0e10cSrcweir }
2008cdf0e10cSrcweir }
2009cdf0e10cSrcweir
2010cdf0e10cSrcweir
CopyNonFilteredFromClip(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,const ScMarkData & rMark,SCsCOL nDx,SCsROW,const ScCopyBlockFromClipParams * pCBFCP,SCROW & rClipStartRow)2011cdf0e10cSrcweir void ScDocument::CopyNonFilteredFromClip( SCCOL nCol1, SCROW nRow1,
2012cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2,
2013cdf0e10cSrcweir const ScMarkData& rMark,
2014cdf0e10cSrcweir SCsCOL nDx, SCsROW /* nDy */,
2015cdf0e10cSrcweir const ScCopyBlockFromClipParams* pCBFCP,
2016cdf0e10cSrcweir SCROW & rClipStartRow )
2017cdf0e10cSrcweir {
2018cdf0e10cSrcweir // call CopyBlockFromClip for ranges of consecutive non-filtered rows
2019cdf0e10cSrcweir // nCol1/nRow1 etc. is in target doc
2020cdf0e10cSrcweir
2021cdf0e10cSrcweir // filtered state is taken from first used table in clipboard (as in GetClipArea)
2022cdf0e10cSrcweir SCTAB nFlagTab = 0;
2023cdf0e10cSrcweir ScTable** ppClipTab = pCBFCP->pClipDoc->pTab;
2024cdf0e10cSrcweir while ( nFlagTab < MAXTAB && !ppClipTab[nFlagTab] )
2025cdf0e10cSrcweir ++nFlagTab;
2026cdf0e10cSrcweir
2027cdf0e10cSrcweir SCROW nSourceRow = rClipStartRow;
2028cdf0e10cSrcweir SCROW nSourceEnd = 0;
2029cdf0e10cSrcweir if (pCBFCP->pClipDoc->GetClipParam().maRanges.Count())
2030cdf0e10cSrcweir nSourceEnd = pCBFCP->pClipDoc->GetClipParam().maRanges.First()->aEnd.Row();
2031cdf0e10cSrcweir SCROW nDestRow = nRow1;
2032cdf0e10cSrcweir
2033cdf0e10cSrcweir while ( nSourceRow <= nSourceEnd && nDestRow <= nRow2 )
2034cdf0e10cSrcweir {
2035cdf0e10cSrcweir // skip filtered rows
2036cdf0e10cSrcweir nSourceRow = pCBFCP->pClipDoc->FirstNonFilteredRow(nSourceRow, nSourceEnd, nFlagTab);
2037cdf0e10cSrcweir
2038cdf0e10cSrcweir if ( nSourceRow <= nSourceEnd )
2039cdf0e10cSrcweir {
2040cdf0e10cSrcweir // look for more non-filtered rows following
2041cdf0e10cSrcweir SCROW nLastRow = nSourceRow;
2042cdf0e10cSrcweir pCBFCP->pClipDoc->RowFiltered(nSourceRow, nFlagTab, NULL, &nLastRow);
2043cdf0e10cSrcweir SCROW nFollow = nLastRow - nSourceRow;
2044cdf0e10cSrcweir
2045cdf0e10cSrcweir if (nFollow > nSourceEnd - nSourceRow)
2046cdf0e10cSrcweir nFollow = nSourceEnd - nSourceRow;
2047cdf0e10cSrcweir if (nFollow > nRow2 - nDestRow)
2048cdf0e10cSrcweir nFollow = nRow2 - nDestRow;
2049cdf0e10cSrcweir
2050cdf0e10cSrcweir SCsROW nNewDy = ((SCsROW)nDestRow) - nSourceRow;
2051cdf0e10cSrcweir CopyBlockFromClip( nCol1, nDestRow, nCol2, nDestRow + nFollow, rMark, nDx, nNewDy, pCBFCP );
2052cdf0e10cSrcweir
2053cdf0e10cSrcweir nSourceRow += nFollow + 1;
2054cdf0e10cSrcweir nDestRow += nFollow + 1;
2055cdf0e10cSrcweir }
2056cdf0e10cSrcweir }
2057cdf0e10cSrcweir rClipStartRow = nSourceRow;
2058cdf0e10cSrcweir }
2059cdf0e10cSrcweir
2060cdf0e10cSrcweir
CopyFromClip(const ScRange & rDestRange,const ScMarkData & rMark,sal_uInt16 nInsFlag,ScDocument * pRefUndoDoc,ScDocument * pClipDoc,sal_Bool bResetCut,sal_Bool bAsLink,sal_Bool bIncludeFiltered,sal_Bool bSkipAttrForEmpty,const ScRangeList * pDestRanges)2061cdf0e10cSrcweir void ScDocument::CopyFromClip( const ScRange& rDestRange, const ScMarkData& rMark,
2062cdf0e10cSrcweir sal_uInt16 nInsFlag,
2063cdf0e10cSrcweir ScDocument* pRefUndoDoc, ScDocument* pClipDoc, sal_Bool bResetCut,
2064cdf0e10cSrcweir sal_Bool bAsLink, sal_Bool bIncludeFiltered, sal_Bool bSkipAttrForEmpty,
2065cdf0e10cSrcweir const ScRangeList * pDestRanges )
2066cdf0e10cSrcweir {
2067cdf0e10cSrcweir if (!bIsClip)
2068cdf0e10cSrcweir {
2069cdf0e10cSrcweir if (!pClipDoc)
2070cdf0e10cSrcweir {
2071cdf0e10cSrcweir DBG_ERROR("CopyFromClip: no ClipDoc");
2072cdf0e10cSrcweir pClipDoc = SC_MOD()->GetClipDoc();
2073cdf0e10cSrcweir }
2074cdf0e10cSrcweir if (pClipDoc->bIsClip && pClipDoc->GetTableCount())
2075cdf0e10cSrcweir {
2076cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
2077cdf0e10cSrcweir SetAutoCalc( sal_False ); // avoid multiple recalculations
2078cdf0e10cSrcweir
2079cdf0e10cSrcweir NumFmtMergeHandler aNumFmtMergeHdl(this, pClipDoc);
2080cdf0e10cSrcweir
2081cdf0e10cSrcweir ScClipRangeNameData aClipRangeNames;
2082cdf0e10cSrcweir CopyRangeNamesFromClip(pClipDoc, aClipRangeNames);
2083cdf0e10cSrcweir
2084cdf0e10cSrcweir SCCOL nAllCol1 = rDestRange.aStart.Col();
2085cdf0e10cSrcweir SCROW nAllRow1 = rDestRange.aStart.Row();
2086cdf0e10cSrcweir SCCOL nAllCol2 = rDestRange.aEnd.Col();
2087cdf0e10cSrcweir SCROW nAllRow2 = rDestRange.aEnd.Row();
2088cdf0e10cSrcweir
2089cdf0e10cSrcweir SCCOL nXw = 0;
2090cdf0e10cSrcweir SCROW nYw = 0;
2091cdf0e10cSrcweir ScRange aClipRange = pClipDoc->GetClipParam().getWholeRange();
2092cdf0e10cSrcweir for (SCTAB nTab = 0; nTab <= MAXTAB; nTab++) // find largest merge overlap
2093cdf0e10cSrcweir if (pClipDoc->pTab[nTab]) // all sheets of the clipboard content
2094cdf0e10cSrcweir {
2095cdf0e10cSrcweir SCCOL nThisEndX = aClipRange.aEnd.Col();
2096cdf0e10cSrcweir SCROW nThisEndY = aClipRange.aEnd.Row();
2097cdf0e10cSrcweir pClipDoc->ExtendMerge( aClipRange.aStart.Col(),
2098cdf0e10cSrcweir aClipRange.aStart.Row(),
2099cdf0e10cSrcweir nThisEndX, nThisEndY, nTab );
2100cdf0e10cSrcweir // only extra value from ExtendMerge
2101cdf0e10cSrcweir nThisEndX = sal::static_int_cast<SCCOL>( nThisEndX - aClipRange.aEnd.Col() );
2102cdf0e10cSrcweir nThisEndY = sal::static_int_cast<SCROW>( nThisEndY - aClipRange.aEnd.Row() );
2103cdf0e10cSrcweir if ( nThisEndX > nXw )
2104cdf0e10cSrcweir nXw = nThisEndX;
2105cdf0e10cSrcweir if ( nThisEndY > nYw )
2106cdf0e10cSrcweir nYw = nThisEndY;
2107cdf0e10cSrcweir }
2108cdf0e10cSrcweir
2109cdf0e10cSrcweir SCCOL nDestAddX;
2110cdf0e10cSrcweir SCROW nDestAddY;
2111cdf0e10cSrcweir pClipDoc->GetClipArea( nDestAddX, nDestAddY, bIncludeFiltered );
2112cdf0e10cSrcweir nXw = sal::static_int_cast<SCCOL>( nXw + nDestAddX );
2113cdf0e10cSrcweir nYw = sal::static_int_cast<SCROW>( nYw + nDestAddY ); // ClipArea, plus ExtendMerge value
2114cdf0e10cSrcweir
2115cdf0e10cSrcweir /* Decide which contents to delete before copying. Delete all
2116cdf0e10cSrcweir contents if nInsFlag contains any real content flag.
2117cdf0e10cSrcweir #i102056# Notes are pasted from clipboard in a second pass,
2118cdf0e10cSrcweir together with the special flag IDF_ADDNOTES that states to not
2119cdf0e10cSrcweir overwrite/delete existing cells but to insert the notes into
2120cdf0e10cSrcweir these cells. In this case, just delete old notes from the
2121cdf0e10cSrcweir destination area. */
2122cdf0e10cSrcweir sal_uInt16 nDelFlag = IDF_NONE;
2123cdf0e10cSrcweir if ( (nInsFlag & (IDF_CONTENTS | IDF_ADDNOTES)) == (IDF_NOTE | IDF_ADDNOTES) )
2124cdf0e10cSrcweir nDelFlag |= IDF_NOTE;
2125cdf0e10cSrcweir else if ( nInsFlag & IDF_CONTENTS )
2126cdf0e10cSrcweir nDelFlag |= IDF_CONTENTS;
2127cdf0e10cSrcweir // With bSkipAttrForEmpty, don't remove attributes, copy
2128cdf0e10cSrcweir // on top of existing attributes instead.
2129cdf0e10cSrcweir if ( ( nInsFlag & IDF_ATTRIB ) && !bSkipAttrForEmpty )
2130cdf0e10cSrcweir nDelFlag |= IDF_ATTRIB;
2131cdf0e10cSrcweir
2132cdf0e10cSrcweir ScCopyBlockFromClipParams aCBFCP;
2133cdf0e10cSrcweir aCBFCP.pRefUndoDoc = pRefUndoDoc;
2134cdf0e10cSrcweir aCBFCP.pClipDoc = pClipDoc;
2135cdf0e10cSrcweir aCBFCP.nInsFlag = nInsFlag;
2136cdf0e10cSrcweir aCBFCP.bAsLink = bAsLink;
2137cdf0e10cSrcweir aCBFCP.bSkipAttrForEmpty = bSkipAttrForEmpty;
2138cdf0e10cSrcweir aCBFCP.nTabStart = MAXTAB; // wird in der Schleife angepasst
2139cdf0e10cSrcweir aCBFCP.nTabEnd = 0; // wird in der Schleife angepasst
2140cdf0e10cSrcweir
2141cdf0e10cSrcweir // Inc/DecRecalcLevel einmal aussen, damit nicht fuer jeden Block
2142cdf0e10cSrcweir // die Draw-Seitengroesse neu berechnet werden muss
2143cdf0e10cSrcweir //! nur wenn ganze Zeilen/Spalten kopiert werden?
2144cdf0e10cSrcweir
2145cdf0e10cSrcweir for (SCTAB j = 0; j <= MAXTAB; j++)
2146cdf0e10cSrcweir if (pTab[j] && rMark.GetTableSelect(j))
2147cdf0e10cSrcweir {
2148cdf0e10cSrcweir if ( j < aCBFCP.nTabStart )
2149cdf0e10cSrcweir aCBFCP.nTabStart = j;
2150cdf0e10cSrcweir aCBFCP.nTabEnd = j;
2151cdf0e10cSrcweir pTab[j]->IncRecalcLevel();
2152cdf0e10cSrcweir }
2153cdf0e10cSrcweir
2154cdf0e10cSrcweir ScRangeList aLocalRangeList;
2155cdf0e10cSrcweir if (!pDestRanges)
2156cdf0e10cSrcweir {
2157cdf0e10cSrcweir aLocalRangeList.Append( rDestRange);
2158cdf0e10cSrcweir pDestRanges = &aLocalRangeList;
2159cdf0e10cSrcweir }
2160cdf0e10cSrcweir
2161cdf0e10cSrcweir bInsertingFromOtherDoc = sal_True; // kein Broadcast/Listener aufbauen bei Insert
2162cdf0e10cSrcweir
2163cdf0e10cSrcweir // bei mindestens 64 Zeilen wird in ScColumn::CopyFromClip voralloziert
2164cdf0e10cSrcweir sal_Bool bDoDouble = ( nYw < 64 && nAllRow2 - nAllRow1 > 64);
2165cdf0e10cSrcweir sal_Bool bOldDouble = ScColumn::bDoubleAlloc;
2166cdf0e10cSrcweir if (bDoDouble)
2167cdf0e10cSrcweir ScColumn::bDoubleAlloc = sal_True;
2168cdf0e10cSrcweir
2169cdf0e10cSrcweir SCCOL nClipStartCol = aClipRange.aStart.Col();
2170cdf0e10cSrcweir SCROW nClipStartRow = aClipRange.aStart.Row();
2171cdf0e10cSrcweir // WaE: commented because unused: SCCOL nClipEndCol = pClipDoc->aClipRange.aEnd.Col();
2172cdf0e10cSrcweir SCROW nClipEndRow = aClipRange.aEnd.Row();
2173cdf0e10cSrcweir for (sal_uLong nRange = 0; nRange < pDestRanges->Count(); ++nRange)
2174cdf0e10cSrcweir {
2175cdf0e10cSrcweir const ScRange* pRange = pDestRanges->GetObject( nRange);
2176cdf0e10cSrcweir SCCOL nCol1 = pRange->aStart.Col();
2177cdf0e10cSrcweir SCROW nRow1 = pRange->aStart.Row();
2178cdf0e10cSrcweir SCCOL nCol2 = pRange->aEnd.Col();
2179cdf0e10cSrcweir SCROW nRow2 = pRange->aEnd.Row();
2180cdf0e10cSrcweir
2181cdf0e10cSrcweir DeleteArea(nCol1, nRow1, nCol2, nRow2, rMark, nDelFlag);
2182cdf0e10cSrcweir
2183cdf0e10cSrcweir SCCOL nC1 = nCol1;
2184cdf0e10cSrcweir SCROW nR1 = nRow1;
2185cdf0e10cSrcweir SCCOL nC2 = nC1 + nXw;
2186cdf0e10cSrcweir if (nC2 > nCol2)
2187cdf0e10cSrcweir nC2 = nCol2;
2188cdf0e10cSrcweir SCROW nR2 = nR1 + nYw;
2189cdf0e10cSrcweir if (nR2 > nRow2)
2190cdf0e10cSrcweir nR2 = nRow2;
2191cdf0e10cSrcweir
21928f4c7c28SSteve Yin const unsigned PERFORMANCEOPTIMIZATION4PATTERNTHRESHOLD = 8192;
21938f4c7c28SSteve Yin bool bNeedPerformanceOptimization4Pattern = nRow2 - nRow1 > PERFORMANCEOPTIMIZATION4PATTERNTHRESHOLD;
21948f4c7c28SSteve Yin std::vector< std::vector< SCSIZE > > vvPatternCount( bNeedPerformanceOptimization4Pattern ? nCol2 - nCol1 + 1 : 0 );
21958f4c7c28SSteve Yin std::vector< SCTAB > vTables;
21968f4c7c28SSteve Yin
21978f4c7c28SSteve Yin if( bNeedPerformanceOptimization4Pattern )
21988f4c7c28SSteve Yin {
21998f4c7c28SSteve Yin for (SCTAB i = aCBFCP.nTabStart; i <= aCBFCP.nTabEnd; i++)
22008f4c7c28SSteve Yin if (pTab[i] && rMark.GetTableSelect( i ) )
22018f4c7c28SSteve Yin vTables.push_back( i );
22028f4c7c28SSteve Yin
22038f4c7c28SSteve Yin for( SCSIZE i = 0; i < vvPatternCount.size(); i++ )
22048f4c7c28SSteve Yin {
22058f4c7c28SSteve Yin vvPatternCount[i].resize( vTables.size() );
22068f4c7c28SSteve Yin
22078f4c7c28SSteve Yin for( std::vector< SCTAB >::size_type j = 0; j<vTables.size(); j++ )
22088f4c7c28SSteve Yin vvPatternCount[i][j] = this->GetPatternCount( vTables[j], nCol1+i );
22098f4c7c28SSteve Yin }
22108f4c7c28SSteve Yin }
22118f4c7c28SSteve Yin
2212cdf0e10cSrcweir do
2213cdf0e10cSrcweir {
2214cdf0e10cSrcweir // Pasting is done column-wise, when pasting to a filtered
2215cdf0e10cSrcweir // area this results in partitioning and we have to
2216cdf0e10cSrcweir // remember and reset the start row for each column until
2217cdf0e10cSrcweir // it can be advanced for the next chunk of unfiltered
2218cdf0e10cSrcweir // rows.
2219cdf0e10cSrcweir SCROW nSaveClipStartRow = nClipStartRow;
2220cdf0e10cSrcweir do
2221cdf0e10cSrcweir {
2222cdf0e10cSrcweir nClipStartRow = nSaveClipStartRow;
2223cdf0e10cSrcweir SCsCOL nDx = ((SCsCOL)nC1) - nClipStartCol;
2224cdf0e10cSrcweir SCsROW nDy = ((SCsROW)nR1) - nClipStartRow;
2225cdf0e10cSrcweir if ( bIncludeFiltered )
2226cdf0e10cSrcweir {
2227cdf0e10cSrcweir CopyBlockFromClip( nC1, nR1, nC2, nR2, rMark, nDx,
2228cdf0e10cSrcweir nDy, &aCBFCP );
2229cdf0e10cSrcweir nClipStartRow += nR2 - nR1 + 1;
2230cdf0e10cSrcweir }
2231cdf0e10cSrcweir else
2232cdf0e10cSrcweir {
2233cdf0e10cSrcweir CopyNonFilteredFromClip( nC1, nR1, nC2, nR2, rMark,
2234cdf0e10cSrcweir nDx, nDy, &aCBFCP, nClipStartRow );
2235cdf0e10cSrcweir }
2236cdf0e10cSrcweir // Not needed for columns, but if it was this would be how to.
2237cdf0e10cSrcweir //if (nClipStartCol > nClipEndCol)
2238cdf0e10cSrcweir // nClipStartCol = pClipDoc->aClipRange.aStart.Col();
2239cdf0e10cSrcweir nC1 = nC2 + 1;
2240cdf0e10cSrcweir nC2 = Min((SCCOL)(nC1 + nXw), nCol2);
2241cdf0e10cSrcweir } while (nC1 <= nCol2);
2242cdf0e10cSrcweir if (nClipStartRow > nClipEndRow)
2243cdf0e10cSrcweir nClipStartRow = aClipRange.aStart.Row();
2244cdf0e10cSrcweir nC1 = nCol1;
2245cdf0e10cSrcweir nC2 = nC1 + nXw;
2246cdf0e10cSrcweir if (nC2 > nCol2)
2247cdf0e10cSrcweir nC2 = nCol2;
22488f4c7c28SSteve Yin
22498f4c7c28SSteve Yin if( bNeedPerformanceOptimization4Pattern && vvPatternCount.size() )
22508f4c7c28SSteve Yin {
22518f4c7c28SSteve Yin for( SCSIZE i = 0; i < vvPatternCount.size(); i++ )
22528f4c7c28SSteve Yin {
22538f4c7c28SSteve Yin vvPatternCount[i].resize( vTables.size() );
22548f4c7c28SSteve Yin
22558f4c7c28SSteve Yin for( std::vector< SCTAB >::size_type j = 0; j<vTables.size(); j++ )
22568f4c7c28SSteve Yin this->ReservedPatternCount( vTables[j], nCol1+i, vvPatternCount[i][j] + ( this->GetPatternCount( vTables[j], nCol1+i, nR1, nR2 ) ) * ( ( nRow2 - nRow1 + 1 ) / ( nYw + 1 ) ) );
22578f4c7c28SSteve Yin }
22588f4c7c28SSteve Yin
22598f4c7c28SSteve Yin bNeedPerformanceOptimization4Pattern = false;
22608f4c7c28SSteve Yin vvPatternCount.clear();
22618f4c7c28SSteve Yin }
22628f4c7c28SSteve Yin
2263cdf0e10cSrcweir nR1 = nR2 + 1;
2264cdf0e10cSrcweir nR2 = Min((SCROW)(nR1 + nYw), nRow2);
2265cdf0e10cSrcweir } while (nR1 <= nRow2);
2266cdf0e10cSrcweir }
2267cdf0e10cSrcweir
2268cdf0e10cSrcweir ScColumn::bDoubleAlloc = bOldDouble;
2269cdf0e10cSrcweir
2270cdf0e10cSrcweir for (SCTAB k = 0; k <= MAXTAB; k++)
2271cdf0e10cSrcweir if (pTab[k] && rMark.GetTableSelect(k))
2272cdf0e10cSrcweir pTab[k]->DecRecalcLevel();
2273cdf0e10cSrcweir
2274cdf0e10cSrcweir bInsertingFromOtherDoc = sal_False;
2275cdf0e10cSrcweir
2276cdf0e10cSrcweir UpdateRangeNamesInFormulas(aClipRangeNames, *pDestRanges, rMark, nXw, nYw);
2277cdf0e10cSrcweir
2278cdf0e10cSrcweir // Listener aufbauen nachdem alles inserted wurde
2279cdf0e10cSrcweir StartListeningFromClip( nAllCol1, nAllRow1, nAllCol2, nAllRow2, rMark, nInsFlag );
2280cdf0e10cSrcweir // nachdem alle Listener aufgebaut wurden, kann gebroadcastet werden
2281cdf0e10cSrcweir BroadcastFromClip( nAllCol1, nAllRow1, nAllCol2, nAllRow2, rMark, nInsFlag );
2282cdf0e10cSrcweir if (bResetCut)
2283cdf0e10cSrcweir pClipDoc->GetClipParam().mbCutMode = false;
2284cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
2285cdf0e10cSrcweir }
2286cdf0e10cSrcweir }
2287cdf0e10cSrcweir }
2288cdf0e10cSrcweir
lcl_getLastNonFilteredRow(const ScBitMaskCompressedArray<SCROW,sal_uInt8> & rFlags,SCROW nBegRow,SCROW nEndRow,SCROW nRowCount)2289cdf0e10cSrcweir static SCROW lcl_getLastNonFilteredRow(
2290cdf0e10cSrcweir const ScBitMaskCompressedArray<SCROW, sal_uInt8>& rFlags, SCROW nBegRow, SCROW nEndRow,
2291cdf0e10cSrcweir SCROW nRowCount)
2292cdf0e10cSrcweir {
2293cdf0e10cSrcweir SCROW nFilteredRow = rFlags.GetFirstForCondition(
2294cdf0e10cSrcweir nBegRow, nEndRow, CR_FILTERED, CR_FILTERED);
2295cdf0e10cSrcweir
2296cdf0e10cSrcweir SCROW nRow = nFilteredRow - 1;
2297cdf0e10cSrcweir if (nRow - nBegRow + 1 > nRowCount)
2298cdf0e10cSrcweir // make sure the row range stays within the data size.
2299cdf0e10cSrcweir nRow = nBegRow + nRowCount - 1;
2300cdf0e10cSrcweir
2301cdf0e10cSrcweir return nRow;
2302cdf0e10cSrcweir }
2303cdf0e10cSrcweir
CopyMultiRangeFromClip(const ScAddress & rDestPos,const ScMarkData & rMark,sal_uInt16 nInsFlag,ScDocument * pClipDoc,bool bResetCut,bool bAsLink,bool,bool bSkipAttrForEmpty)2304cdf0e10cSrcweir void ScDocument::CopyMultiRangeFromClip(
2305cdf0e10cSrcweir const ScAddress& rDestPos, const ScMarkData& rMark, sal_uInt16 nInsFlag, ScDocument* pClipDoc,
2306cdf0e10cSrcweir bool bResetCut, bool bAsLink, bool /*bIncludeFiltered*/, bool bSkipAttrForEmpty)
2307cdf0e10cSrcweir {
2308cdf0e10cSrcweir if (bIsClip)
2309cdf0e10cSrcweir return;
2310cdf0e10cSrcweir
2311cdf0e10cSrcweir if (!pClipDoc->bIsClip || !pClipDoc->GetTableCount())
2312cdf0e10cSrcweir // There is nothing in the clip doc to copy.
2313cdf0e10cSrcweir return;
2314cdf0e10cSrcweir
2315cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
2316cdf0e10cSrcweir SetAutoCalc( sal_False ); // avoid multiple recalculations
2317cdf0e10cSrcweir
2318cdf0e10cSrcweir NumFmtMergeHandler aNumFmtMergeHdl(this, pClipDoc);
2319cdf0e10cSrcweir
2320cdf0e10cSrcweir ScClipRangeNameData aClipRangeNames;
2321cdf0e10cSrcweir CopyRangeNamesFromClip(pClipDoc, aClipRangeNames);
2322cdf0e10cSrcweir
2323cdf0e10cSrcweir SCCOL nCol1 = rDestPos.Col();
2324cdf0e10cSrcweir SCROW nRow1 = rDestPos.Row();
2325cdf0e10cSrcweir ScClipParam& rClipParam = pClipDoc->GetClipParam();
2326cdf0e10cSrcweir
2327cdf0e10cSrcweir ScCopyBlockFromClipParams aCBFCP;
2328cdf0e10cSrcweir aCBFCP.pRefUndoDoc = NULL;
2329cdf0e10cSrcweir aCBFCP.pClipDoc = pClipDoc;
2330cdf0e10cSrcweir aCBFCP.nInsFlag = nInsFlag;
2331cdf0e10cSrcweir aCBFCP.bAsLink = bAsLink;
2332cdf0e10cSrcweir aCBFCP.bSkipAttrForEmpty = bSkipAttrForEmpty;
2333cdf0e10cSrcweir aCBFCP.nTabStart = MAXTAB;
2334cdf0e10cSrcweir aCBFCP.nTabEnd = 0;
2335cdf0e10cSrcweir
2336cdf0e10cSrcweir for (SCTAB j = 0; j <= MAXTAB; ++j)
2337cdf0e10cSrcweir {
2338cdf0e10cSrcweir if (pTab[j] && rMark.GetTableSelect(j))
2339cdf0e10cSrcweir {
2340cdf0e10cSrcweir if ( j < aCBFCP.nTabStart )
2341cdf0e10cSrcweir aCBFCP.nTabStart = j;
2342cdf0e10cSrcweir aCBFCP.nTabEnd = j;
2343cdf0e10cSrcweir pTab[j]->IncRecalcLevel();
2344cdf0e10cSrcweir }
2345cdf0e10cSrcweir }
2346cdf0e10cSrcweir
2347cdf0e10cSrcweir ScRange aDestRange;
2348cdf0e10cSrcweir rMark.GetMarkArea(aDestRange);
2349cdf0e10cSrcweir SCROW nLastMarkedRow = aDestRange.aEnd.Row();
2350cdf0e10cSrcweir
2351cdf0e10cSrcweir bInsertingFromOtherDoc = sal_True; // kein Broadcast/Listener aufbauen bei Insert
2352cdf0e10cSrcweir
2353cdf0e10cSrcweir SCROW nBegRow = nRow1;
2354cdf0e10cSrcweir sal_uInt16 nDelFlag = IDF_CONTENTS;
2355cdf0e10cSrcweir const ScBitMaskCompressedArray<SCROW, sal_uInt8>& rFlags = GetRowFlagsArray(aCBFCP.nTabStart);
2356cdf0e10cSrcweir
2357cdf0e10cSrcweir for (ScRange* p = rClipParam.maRanges.First(); p; p = rClipParam.maRanges.Next())
2358cdf0e10cSrcweir {
2359cdf0e10cSrcweir // The begin row must not be filtered.
2360cdf0e10cSrcweir
2361cdf0e10cSrcweir SCROW nRowCount = p->aEnd.Row() - p->aStart.Row() + 1;
2362cdf0e10cSrcweir
2363cdf0e10cSrcweir SCsCOL nDx = static_cast<SCsCOL>(nCol1 - p->aStart.Col());
2364cdf0e10cSrcweir SCsROW nDy = static_cast<SCsROW>(nBegRow - p->aStart.Row());
2365cdf0e10cSrcweir SCCOL nCol2 = nCol1 + p->aEnd.Col() - p->aStart.Col();
2366cdf0e10cSrcweir
2367cdf0e10cSrcweir SCROW nEndRow = lcl_getLastNonFilteredRow(rFlags, nBegRow, nLastMarkedRow, nRowCount);
2368cdf0e10cSrcweir
2369cdf0e10cSrcweir if (!bSkipAttrForEmpty)
2370cdf0e10cSrcweir DeleteArea(nCol1, nBegRow, nCol2, nEndRow, rMark, nDelFlag);
2371cdf0e10cSrcweir
2372cdf0e10cSrcweir CopyBlockFromClip(nCol1, nBegRow, nCol2, nEndRow, rMark, nDx, nDy, &aCBFCP);
2373cdf0e10cSrcweir nRowCount -= nEndRow - nBegRow + 1;
2374cdf0e10cSrcweir
2375cdf0e10cSrcweir while (nRowCount > 0)
2376cdf0e10cSrcweir {
2377cdf0e10cSrcweir // Get the first non-filtered row.
2378cdf0e10cSrcweir SCROW nNonFilteredRow = rFlags.GetFirstForCondition(nEndRow+1, nLastMarkedRow, CR_FILTERED, 0);
2379cdf0e10cSrcweir if (nNonFilteredRow > nLastMarkedRow)
2380cdf0e10cSrcweir return;
2381cdf0e10cSrcweir
2382cdf0e10cSrcweir SCROW nRowsSkipped = nNonFilteredRow - nEndRow - 1;
2383cdf0e10cSrcweir nDy += nRowsSkipped;
2384cdf0e10cSrcweir
2385cdf0e10cSrcweir nBegRow = nNonFilteredRow;
2386cdf0e10cSrcweir nEndRow = lcl_getLastNonFilteredRow(rFlags, nBegRow, nLastMarkedRow, nRowCount);
2387cdf0e10cSrcweir
2388cdf0e10cSrcweir if (!bSkipAttrForEmpty)
2389cdf0e10cSrcweir DeleteArea(nCol1, nBegRow, nCol2, nEndRow, rMark, nDelFlag);
2390cdf0e10cSrcweir
2391cdf0e10cSrcweir CopyBlockFromClip(nCol1, nBegRow, nCol2, nEndRow, rMark, nDx, nDy, &aCBFCP);
2392cdf0e10cSrcweir nRowCount -= nEndRow - nBegRow + 1;
2393cdf0e10cSrcweir }
2394cdf0e10cSrcweir
2395cdf0e10cSrcweir if (rClipParam.meDirection == ScClipParam::Row)
2396cdf0e10cSrcweir // Begin row for the next range being pasted.
2397cdf0e10cSrcweir nBegRow = rFlags.GetFirstForCondition(nEndRow+1, nLastMarkedRow, CR_FILTERED, 0);
2398cdf0e10cSrcweir else
2399cdf0e10cSrcweir nBegRow = nRow1;
2400cdf0e10cSrcweir
2401cdf0e10cSrcweir if (rClipParam.meDirection == ScClipParam::Column)
2402cdf0e10cSrcweir nCol1 += p->aEnd.Col() - p->aStart.Col() + 1;
2403cdf0e10cSrcweir }
2404cdf0e10cSrcweir
2405cdf0e10cSrcweir for (SCTAB i = 0; i <= MAXTAB; i++)
2406cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
2407cdf0e10cSrcweir pTab[i]->DecRecalcLevel();
2408cdf0e10cSrcweir
2409cdf0e10cSrcweir bInsertingFromOtherDoc = sal_False;
2410cdf0e10cSrcweir
2411cdf0e10cSrcweir ScRangeList aRanges;
2412cdf0e10cSrcweir aRanges.Append(aDestRange);
2413cdf0e10cSrcweir SCCOL nCols = aDestRange.aEnd.Col() - aDestRange.aStart.Col() + 1;
2414cdf0e10cSrcweir SCROW nRows = aDestRange.aEnd.Row() - aDestRange.aStart.Row() + 1;
2415cdf0e10cSrcweir UpdateRangeNamesInFormulas(aClipRangeNames, aRanges, rMark, nCols-1, nRows-1);
2416cdf0e10cSrcweir
2417cdf0e10cSrcweir // Listener aufbauen nachdem alles inserted wurde
2418cdf0e10cSrcweir StartListeningFromClip(aDestRange.aStart.Col(), aDestRange.aStart.Row(),
2419cdf0e10cSrcweir aDestRange.aEnd.Col(), aDestRange.aEnd.Row(), rMark, nInsFlag );
2420cdf0e10cSrcweir // nachdem alle Listener aufgebaut wurden, kann gebroadcastet werden
2421cdf0e10cSrcweir BroadcastFromClip(aDestRange.aStart.Col(), aDestRange.aStart.Row(),
2422cdf0e10cSrcweir aDestRange.aEnd.Col(), aDestRange.aEnd.Row(), rMark, nInsFlag );
2423cdf0e10cSrcweir
2424cdf0e10cSrcweir if (bResetCut)
2425cdf0e10cSrcweir pClipDoc->GetClipParam().mbCutMode = false;
2426cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
2427cdf0e10cSrcweir }
2428cdf0e10cSrcweir
SetClipArea(const ScRange & rArea,sal_Bool bCut)2429cdf0e10cSrcweir void ScDocument::SetClipArea( const ScRange& rArea, sal_Bool bCut )
2430cdf0e10cSrcweir {
2431cdf0e10cSrcweir if (bIsClip)
2432cdf0e10cSrcweir {
2433cdf0e10cSrcweir ScClipParam& rClipParam = GetClipParam();
2434cdf0e10cSrcweir rClipParam.maRanges.RemoveAll();
2435cdf0e10cSrcweir rClipParam.maRanges.Append(rArea);
2436cdf0e10cSrcweir rClipParam.mbCutMode = bCut;
2437cdf0e10cSrcweir }
2438cdf0e10cSrcweir else
2439cdf0e10cSrcweir {
2440cdf0e10cSrcweir DBG_ERROR("SetClipArea: kein Clip");
2441cdf0e10cSrcweir }
2442cdf0e10cSrcweir }
2443cdf0e10cSrcweir
2444cdf0e10cSrcweir
GetClipArea(SCCOL & nClipX,SCROW & nClipY,sal_Bool bIncludeFiltered)2445cdf0e10cSrcweir void ScDocument::GetClipArea(SCCOL& nClipX, SCROW& nClipY, sal_Bool bIncludeFiltered)
2446cdf0e10cSrcweir {
2447cdf0e10cSrcweir if (!bIsClip)
2448cdf0e10cSrcweir {
2449cdf0e10cSrcweir DBG_ERROR("GetClipArea: kein Clip");
2450cdf0e10cSrcweir return;
2451cdf0e10cSrcweir }
2452cdf0e10cSrcweir
2453cdf0e10cSrcweir ScRangeList& rClipRanges = GetClipParam().maRanges;
2454cdf0e10cSrcweir if (!rClipRanges.Count())
2455cdf0e10cSrcweir // No clip range. Bail out.
2456cdf0e10cSrcweir return;
2457cdf0e10cSrcweir
2458cdf0e10cSrcweir ScRangePtr p = rClipRanges.First();
2459cdf0e10cSrcweir SCCOL nStartCol = p->aStart.Col();
2460cdf0e10cSrcweir SCCOL nEndCol = p->aEnd.Col();
2461cdf0e10cSrcweir SCROW nStartRow = p->aStart.Row();
2462cdf0e10cSrcweir SCROW nEndRow = p->aEnd.Row();
2463cdf0e10cSrcweir for (p = rClipRanges.Next(); p; p = rClipRanges.Next())
2464cdf0e10cSrcweir {
2465cdf0e10cSrcweir if (p->aStart.Col() < nStartCol)
2466cdf0e10cSrcweir nStartCol = p->aStart.Col();
2467cdf0e10cSrcweir if (p->aStart.Row() < nStartRow)
2468cdf0e10cSrcweir nStartRow = p->aStart.Row();
2469cdf0e10cSrcweir if (p->aEnd.Col() > nEndCol)
2470cdf0e10cSrcweir nEndCol = p->aEnd.Col();
2471cdf0e10cSrcweir if (p->aEnd.Row() < nEndRow)
2472cdf0e10cSrcweir nEndRow = p->aEnd.Row();
2473cdf0e10cSrcweir }
2474cdf0e10cSrcweir
2475cdf0e10cSrcweir nClipX = nEndCol - nStartCol;
2476cdf0e10cSrcweir
2477cdf0e10cSrcweir if ( bIncludeFiltered )
2478cdf0e10cSrcweir nClipY = nEndRow - nStartRow;
2479cdf0e10cSrcweir else
2480cdf0e10cSrcweir {
2481cdf0e10cSrcweir // count non-filtered rows
2482cdf0e10cSrcweir // count on first used table in clipboard
2483cdf0e10cSrcweir SCTAB nCountTab = 0;
2484cdf0e10cSrcweir while ( nCountTab < MAXTAB && !pTab[nCountTab] )
2485cdf0e10cSrcweir ++nCountTab;
2486cdf0e10cSrcweir
2487cdf0e10cSrcweir SCROW nResult = CountNonFilteredRows(nStartRow, nEndRow, nCountTab);
2488cdf0e10cSrcweir
2489cdf0e10cSrcweir if ( nResult > 0 )
2490cdf0e10cSrcweir nClipY = nResult - 1;
2491cdf0e10cSrcweir else
2492cdf0e10cSrcweir nClipY = 0; // always return at least 1 row
2493cdf0e10cSrcweir }
2494cdf0e10cSrcweir }
2495cdf0e10cSrcweir
2496cdf0e10cSrcweir
GetClipStart(SCCOL & nClipX,SCROW & nClipY)2497cdf0e10cSrcweir void ScDocument::GetClipStart(SCCOL& nClipX, SCROW& nClipY)
2498cdf0e10cSrcweir {
2499cdf0e10cSrcweir if (bIsClip)
2500cdf0e10cSrcweir {
2501cdf0e10cSrcweir ScRangeList& rClipRanges = GetClipParam().maRanges;
2502cdf0e10cSrcweir if (rClipRanges.Count())
2503cdf0e10cSrcweir {
2504cdf0e10cSrcweir nClipX = rClipRanges.First()->aStart.Col();
2505cdf0e10cSrcweir nClipY = rClipRanges.First()->aStart.Row();
2506cdf0e10cSrcweir }
2507cdf0e10cSrcweir }
2508cdf0e10cSrcweir else
2509cdf0e10cSrcweir {
2510cdf0e10cSrcweir DBG_ERROR("GetClipStart: kein Clip");
2511cdf0e10cSrcweir }
2512cdf0e10cSrcweir }
2513cdf0e10cSrcweir
2514cdf0e10cSrcweir
HasClipFilteredRows()2515cdf0e10cSrcweir sal_Bool ScDocument::HasClipFilteredRows()
2516cdf0e10cSrcweir {
2517cdf0e10cSrcweir // count on first used table in clipboard
2518cdf0e10cSrcweir SCTAB nCountTab = 0;
2519cdf0e10cSrcweir while ( nCountTab < MAXTAB && !pTab[nCountTab] )
2520cdf0e10cSrcweir ++nCountTab;
2521cdf0e10cSrcweir
2522cdf0e10cSrcweir ScRangeList& rClipRanges = GetClipParam().maRanges;
2523cdf0e10cSrcweir if (!rClipRanges.Count())
2524cdf0e10cSrcweir return false;
2525cdf0e10cSrcweir
2526cdf0e10cSrcweir for (ScRange* p = rClipRanges.First(); p; p = rClipRanges.Next())
2527cdf0e10cSrcweir {
2528cdf0e10cSrcweir bool bAnswer = pTab[nCountTab]->HasFilteredRows(p->aStart.Row(), p->aEnd.Row());
2529cdf0e10cSrcweir if (bAnswer)
2530cdf0e10cSrcweir return true;
2531cdf0e10cSrcweir }
2532cdf0e10cSrcweir return false;
2533cdf0e10cSrcweir }
2534cdf0e10cSrcweir
2535cdf0e10cSrcweir
MixDocument(const ScRange & rRange,sal_uInt16 nFunction,sal_Bool bSkipEmpty,ScDocument * pSrcDoc)2536cdf0e10cSrcweir void ScDocument::MixDocument( const ScRange& rRange, sal_uInt16 nFunction, sal_Bool bSkipEmpty,
2537cdf0e10cSrcweir ScDocument* pSrcDoc )
2538cdf0e10cSrcweir {
2539cdf0e10cSrcweir SCTAB nTab1 = rRange.aStart.Tab();
2540cdf0e10cSrcweir SCTAB nTab2 = rRange.aEnd.Tab();
2541cdf0e10cSrcweir for (SCTAB i = nTab1; i <= nTab2; i++)
2542cdf0e10cSrcweir if (pTab[i] && pSrcDoc->pTab[i])
2543cdf0e10cSrcweir pTab[i]->MixData( rRange.aStart.Col(), rRange.aStart.Row(),
2544cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Row(),
2545cdf0e10cSrcweir nFunction, bSkipEmpty, pSrcDoc->pTab[i] );
2546cdf0e10cSrcweir }
2547cdf0e10cSrcweir
2548cdf0e10cSrcweir
FillTab(const ScRange & rSrcArea,const ScMarkData & rMark,sal_uInt16 nFlags,sal_uInt16 nFunction,sal_Bool bSkipEmpty,sal_Bool bAsLink)2549cdf0e10cSrcweir void ScDocument::FillTab( const ScRange& rSrcArea, const ScMarkData& rMark,
2550cdf0e10cSrcweir sal_uInt16 nFlags, sal_uInt16 nFunction,
2551cdf0e10cSrcweir sal_Bool bSkipEmpty, sal_Bool bAsLink )
2552cdf0e10cSrcweir {
2553cdf0e10cSrcweir sal_uInt16 nDelFlags = nFlags;
2554cdf0e10cSrcweir if (nDelFlags & IDF_CONTENTS)
2555cdf0e10cSrcweir nDelFlags |= IDF_CONTENTS; // immer alle Inhalte oder keine loeschen!
2556cdf0e10cSrcweir
2557cdf0e10cSrcweir SCTAB nSrcTab = rSrcArea.aStart.Tab();
2558cdf0e10cSrcweir
2559cdf0e10cSrcweir if (ValidTab(nSrcTab) && pTab[nSrcTab])
2560cdf0e10cSrcweir {
2561cdf0e10cSrcweir SCCOL nStartCol = rSrcArea.aStart.Col();
2562cdf0e10cSrcweir SCROW nStartRow = rSrcArea.aStart.Row();
2563cdf0e10cSrcweir SCCOL nEndCol = rSrcArea.aEnd.Col();
2564cdf0e10cSrcweir SCROW nEndRow = rSrcArea.aEnd.Row();
2565cdf0e10cSrcweir ScDocument* pMixDoc = NULL;
2566cdf0e10cSrcweir sal_Bool bDoMix = ( bSkipEmpty || nFunction ) && ( nFlags & IDF_CONTENTS );
2567cdf0e10cSrcweir
2568cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
2569cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
2570cdf0e10cSrcweir
2571cdf0e10cSrcweir SCTAB nCount = GetTableCount();
2572cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
2573cdf0e10cSrcweir if ( i!=nSrcTab && pTab[i] && rMark.GetTableSelect(i) )
2574cdf0e10cSrcweir {
2575cdf0e10cSrcweir if (bDoMix)
2576cdf0e10cSrcweir {
2577cdf0e10cSrcweir if (!pMixDoc)
2578cdf0e10cSrcweir {
2579cdf0e10cSrcweir pMixDoc = new ScDocument( SCDOCMODE_UNDO );
2580cdf0e10cSrcweir pMixDoc->InitUndo( this, i, i );
2581cdf0e10cSrcweir }
2582cdf0e10cSrcweir else
2583cdf0e10cSrcweir pMixDoc->AddUndoTab( i, i );
2584cdf0e10cSrcweir pTab[i]->CopyToTable( nStartCol,nStartRow, nEndCol,nEndRow,
2585cdf0e10cSrcweir IDF_CONTENTS, sal_False, pMixDoc->pTab[i] );
2586cdf0e10cSrcweir }
2587cdf0e10cSrcweir pTab[i]->DeleteArea( nStartCol,nStartRow, nEndCol,nEndRow, nDelFlags);
2588cdf0e10cSrcweir pTab[nSrcTab]->CopyToTable( nStartCol,nStartRow, nEndCol,nEndRow,
2589cdf0e10cSrcweir nFlags, sal_False, pTab[i], NULL, bAsLink );
2590cdf0e10cSrcweir
2591cdf0e10cSrcweir if (bDoMix)
2592cdf0e10cSrcweir pTab[i]->MixData( nStartCol,nStartRow, nEndCol,nEndRow,
2593cdf0e10cSrcweir nFunction, bSkipEmpty, pMixDoc->pTab[i] );
2594cdf0e10cSrcweir }
2595cdf0e10cSrcweir
2596cdf0e10cSrcweir delete pMixDoc;
2597cdf0e10cSrcweir
2598cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
2599cdf0e10cSrcweir }
2600cdf0e10cSrcweir else
2601cdf0e10cSrcweir {
2602cdf0e10cSrcweir DBG_ERROR("falsche Tabelle");
2603cdf0e10cSrcweir }
2604cdf0e10cSrcweir }
2605cdf0e10cSrcweir
2606cdf0e10cSrcweir
FillTabMarked(SCTAB nSrcTab,const ScMarkData & rMark,sal_uInt16 nFlags,sal_uInt16 nFunction,sal_Bool bSkipEmpty,sal_Bool bAsLink)2607cdf0e10cSrcweir void ScDocument::FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark,
2608cdf0e10cSrcweir sal_uInt16 nFlags, sal_uInt16 nFunction,
2609cdf0e10cSrcweir sal_Bool bSkipEmpty, sal_Bool bAsLink )
2610cdf0e10cSrcweir {
2611cdf0e10cSrcweir sal_uInt16 nDelFlags = nFlags;
2612cdf0e10cSrcweir if (nDelFlags & IDF_CONTENTS)
2613cdf0e10cSrcweir nDelFlags |= IDF_CONTENTS; // immer alle Inhalte oder keine loeschen!
2614cdf0e10cSrcweir
2615cdf0e10cSrcweir if (ValidTab(nSrcTab) && pTab[nSrcTab])
2616cdf0e10cSrcweir {
2617cdf0e10cSrcweir ScDocument* pMixDoc = NULL;
2618cdf0e10cSrcweir sal_Bool bDoMix = ( bSkipEmpty || nFunction ) && ( nFlags & IDF_CONTENTS );
2619cdf0e10cSrcweir
2620cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
2621cdf0e10cSrcweir SetAutoCalc( sal_False ); // Mehrfachberechnungen vermeiden
2622cdf0e10cSrcweir
2623cdf0e10cSrcweir ScRange aArea;
2624cdf0e10cSrcweir rMark.GetMultiMarkArea( aArea );
2625cdf0e10cSrcweir SCCOL nStartCol = aArea.aStart.Col();
2626cdf0e10cSrcweir SCROW nStartRow = aArea.aStart.Row();
2627cdf0e10cSrcweir SCCOL nEndCol = aArea.aEnd.Col();
2628cdf0e10cSrcweir SCROW nEndRow = aArea.aEnd.Row();
2629cdf0e10cSrcweir
2630cdf0e10cSrcweir SCTAB nCount = GetTableCount();
2631cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
2632cdf0e10cSrcweir if ( i!=nSrcTab && pTab[i] && rMark.GetTableSelect(i) )
2633cdf0e10cSrcweir {
2634cdf0e10cSrcweir if (bDoMix)
2635cdf0e10cSrcweir {
2636cdf0e10cSrcweir if (!pMixDoc)
2637cdf0e10cSrcweir {
2638cdf0e10cSrcweir pMixDoc = new ScDocument( SCDOCMODE_UNDO );
2639cdf0e10cSrcweir pMixDoc->InitUndo( this, i, i );
2640cdf0e10cSrcweir }
2641cdf0e10cSrcweir else
2642cdf0e10cSrcweir pMixDoc->AddUndoTab( i, i );
2643cdf0e10cSrcweir pTab[i]->CopyToTable( nStartCol,nStartRow, nEndCol,nEndRow,
2644cdf0e10cSrcweir IDF_CONTENTS, sal_True, pMixDoc->pTab[i], &rMark );
2645cdf0e10cSrcweir }
2646cdf0e10cSrcweir
2647cdf0e10cSrcweir pTab[i]->DeleteSelection( nDelFlags, rMark );
2648cdf0e10cSrcweir pTab[nSrcTab]->CopyToTable( nStartCol,nStartRow, nEndCol,nEndRow,
2649cdf0e10cSrcweir nFlags, sal_True, pTab[i], &rMark, bAsLink );
2650cdf0e10cSrcweir
2651cdf0e10cSrcweir if (bDoMix)
2652cdf0e10cSrcweir pTab[i]->MixMarked( rMark, nFunction, bSkipEmpty, pMixDoc->pTab[i] );
2653cdf0e10cSrcweir }
2654cdf0e10cSrcweir
2655cdf0e10cSrcweir delete pMixDoc;
2656cdf0e10cSrcweir
2657cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
2658cdf0e10cSrcweir }
2659cdf0e10cSrcweir else
2660cdf0e10cSrcweir {
2661cdf0e10cSrcweir DBG_ERROR("falsche Tabelle");
2662cdf0e10cSrcweir }
2663cdf0e10cSrcweir }
2664cdf0e10cSrcweir
2665cdf0e10cSrcweir
PutCell(SCCOL nCol,SCROW nRow,SCTAB nTab,ScBaseCell * pCell,sal_Bool bForceTab)2666cdf0e10cSrcweir void ScDocument::PutCell( SCCOL nCol, SCROW nRow, SCTAB nTab, ScBaseCell* pCell, sal_Bool bForceTab )
2667cdf0e10cSrcweir {
2668cdf0e10cSrcweir if (VALIDTAB(nTab))
2669cdf0e10cSrcweir {
2670cdf0e10cSrcweir if ( bForceTab && !pTab[nTab] )
2671cdf0e10cSrcweir {
2672cdf0e10cSrcweir sal_Bool bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags
2673cdf0e10cSrcweir
2674cdf0e10cSrcweir pTab[nTab] = new ScTable(this, nTab,
2675cdf0e10cSrcweir String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("temp")),
2676cdf0e10cSrcweir bExtras, bExtras);
2677cdf0e10cSrcweir ++nMaxTableNumber;
2678cdf0e10cSrcweir }
2679cdf0e10cSrcweir
2680cdf0e10cSrcweir if (pTab[nTab])
2681cdf0e10cSrcweir pTab[nTab]->PutCell( nCol, nRow, pCell );
2682cdf0e10cSrcweir }
2683cdf0e10cSrcweir }
2684cdf0e10cSrcweir
2685cdf0e10cSrcweir
PutCell(const ScAddress & rPos,ScBaseCell * pCell,sal_Bool bForceTab)2686cdf0e10cSrcweir void ScDocument::PutCell( const ScAddress& rPos, ScBaseCell* pCell, sal_Bool bForceTab )
2687cdf0e10cSrcweir {
2688cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
2689cdf0e10cSrcweir if ( bForceTab && !pTab[nTab] )
2690cdf0e10cSrcweir {
2691cdf0e10cSrcweir sal_Bool bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags
2692cdf0e10cSrcweir
2693cdf0e10cSrcweir pTab[nTab] = new ScTable(this, nTab,
2694cdf0e10cSrcweir String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("temp")),
2695cdf0e10cSrcweir bExtras, bExtras);
2696cdf0e10cSrcweir ++nMaxTableNumber;
2697cdf0e10cSrcweir }
2698cdf0e10cSrcweir
2699cdf0e10cSrcweir if (pTab[nTab])
2700cdf0e10cSrcweir pTab[nTab]->PutCell( rPos, pCell );
2701cdf0e10cSrcweir }
2702cdf0e10cSrcweir
2703cdf0e10cSrcweir
SetString(SCCOL nCol,SCROW nRow,SCTAB nTab,const String & rString,SvNumberFormatter * pFormatter,bool bDetectNumberFormat)2704cdf0e10cSrcweir sal_Bool ScDocument::SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const String& rString,
2705cdf0e10cSrcweir SvNumberFormatter* pFormatter, bool bDetectNumberFormat )
2706cdf0e10cSrcweir {
2707cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
2708cdf0e10cSrcweir return pTab[nTab]->SetString( nCol, nRow, nTab, rString, pFormatter, bDetectNumberFormat );
2709cdf0e10cSrcweir else
2710cdf0e10cSrcweir return sal_False;
2711cdf0e10cSrcweir }
2712cdf0e10cSrcweir
2713cdf0e10cSrcweir
SetValue(SCCOL nCol,SCROW nRow,SCTAB nTab,const double & rVal)2714cdf0e10cSrcweir void ScDocument::SetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rVal )
2715cdf0e10cSrcweir {
2716cdf0e10cSrcweir if (VALIDTAB(nTab))
2717cdf0e10cSrcweir if (pTab[nTab])
2718cdf0e10cSrcweir pTab[nTab]->SetValue( nCol, nRow, rVal );
2719cdf0e10cSrcweir }
2720cdf0e10cSrcweir
2721cdf0e10cSrcweir
GetString(SCCOL nCol,SCROW nRow,SCTAB nTab,String & rString)2722cdf0e10cSrcweir void ScDocument::GetString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString )
2723cdf0e10cSrcweir {
2724cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
2725cdf0e10cSrcweir pTab[nTab]->GetString( nCol, nRow, rString );
2726cdf0e10cSrcweir else
2727cdf0e10cSrcweir rString.Erase();
2728cdf0e10cSrcweir }
2729cdf0e10cSrcweir
FillDPCache(ScDPTableDataCache * pCache,SCTAB nTab,SCCOL nStartCol,SCCOL nEndCol,SCROW nStartRow,SCROW nEndRow)2730b4df81e3SWang Lei void ScDocument::FillDPCache( ScDPTableDataCache * pCache, SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow )
2731b4df81e3SWang Lei {
2732b4df81e3SWang Lei if ( VALIDTAB(nTab) && pTab[nTab] )
2733b4df81e3SWang Lei pTab[nTab]->FillDPCache( pCache, nStartCol, nEndCol, nStartRow, nEndRow );
2734b4df81e3SWang Lei }
2735cdf0e10cSrcweir
GetInputString(SCCOL nCol,SCROW nRow,SCTAB nTab,String & rString)2736cdf0e10cSrcweir void ScDocument::GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString )
2737cdf0e10cSrcweir {
2738cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
2739cdf0e10cSrcweir pTab[nTab]->GetInputString( nCol, nRow, rString );
2740cdf0e10cSrcweir else
2741cdf0e10cSrcweir rString.Erase();
2742cdf0e10cSrcweir }
2743cdf0e10cSrcweir
2744cdf0e10cSrcweir
GetStringForFormula(const ScAddress & rPos,rtl::OUString & rString)2745cdf0e10cSrcweir sal_uInt16 ScDocument::GetStringForFormula( const ScAddress& rPos, rtl::OUString& rString )
2746cdf0e10cSrcweir {
2747cdf0e10cSrcweir // Used in formulas (add-in parameters etc), so it must use the same semantics as
2748cdf0e10cSrcweir // ScInterpreter::GetCellString: always format values as numbers.
2749cdf0e10cSrcweir // The return value is the error code.
2750cdf0e10cSrcweir
2751cdf0e10cSrcweir sal_uInt16 nErr = 0;
2752cdf0e10cSrcweir String aStr;
2753cdf0e10cSrcweir ScBaseCell* pCell = GetCell( rPos );
2754cdf0e10cSrcweir if (pCell)
2755cdf0e10cSrcweir {
2756cdf0e10cSrcweir SvNumberFormatter* pFormatter = GetFormatTable();
2757cdf0e10cSrcweir switch (pCell->GetCellType())
2758cdf0e10cSrcweir {
2759cdf0e10cSrcweir case CELLTYPE_STRING:
2760cdf0e10cSrcweir static_cast<ScStringCell*>(pCell)->GetString(aStr);
2761cdf0e10cSrcweir break;
2762cdf0e10cSrcweir case CELLTYPE_EDIT:
2763cdf0e10cSrcweir static_cast<ScEditCell*>(pCell)->GetString(aStr);
2764cdf0e10cSrcweir break;
2765cdf0e10cSrcweir case CELLTYPE_FORMULA:
2766cdf0e10cSrcweir {
2767cdf0e10cSrcweir ScFormulaCell* pFCell = static_cast<ScFormulaCell*>(pCell);
2768cdf0e10cSrcweir nErr = pFCell->GetErrCode();
2769cdf0e10cSrcweir if (pFCell->IsValue())
2770cdf0e10cSrcweir {
2771cdf0e10cSrcweir double fVal = pFCell->GetValue();
2772cdf0e10cSrcweir sal_uInt32 nIndex = pFormatter->GetStandardFormat(
2773cdf0e10cSrcweir NUMBERFORMAT_NUMBER,
2774cdf0e10cSrcweir ScGlobal::eLnge);
2775cdf0e10cSrcweir pFormatter->GetInputLineString(fVal, nIndex, aStr);
2776cdf0e10cSrcweir }
2777cdf0e10cSrcweir else
2778cdf0e10cSrcweir pFCell->GetString(aStr);
2779cdf0e10cSrcweir }
2780cdf0e10cSrcweir break;
2781cdf0e10cSrcweir case CELLTYPE_VALUE:
2782cdf0e10cSrcweir {
2783cdf0e10cSrcweir double fVal = static_cast<ScValueCell*>(pCell)->GetValue();
2784cdf0e10cSrcweir sal_uInt32 nIndex = pFormatter->GetStandardFormat(
2785cdf0e10cSrcweir NUMBERFORMAT_NUMBER,
2786cdf0e10cSrcweir ScGlobal::eLnge);
2787cdf0e10cSrcweir pFormatter->GetInputLineString(fVal, nIndex, aStr);
2788cdf0e10cSrcweir }
2789cdf0e10cSrcweir break;
2790cdf0e10cSrcweir default:
2791cdf0e10cSrcweir ;
2792cdf0e10cSrcweir }
2793cdf0e10cSrcweir }
2794cdf0e10cSrcweir rString = aStr;
2795cdf0e10cSrcweir return nErr;
2796cdf0e10cSrcweir }
2797cdf0e10cSrcweir
2798cdf0e10cSrcweir
GetValue(SCCOL nCol,SCROW nRow,SCTAB nTab,double & rValue)2799cdf0e10cSrcweir void ScDocument::GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, double& rValue )
2800cdf0e10cSrcweir {
2801cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
2802cdf0e10cSrcweir rValue = pTab[nTab]->GetValue( nCol, nRow );
2803cdf0e10cSrcweir else
2804cdf0e10cSrcweir rValue = 0.0;
2805cdf0e10cSrcweir }
2806cdf0e10cSrcweir
2807cdf0e10cSrcweir
GetValue(const ScAddress & rPos)2808cdf0e10cSrcweir double ScDocument::GetValue( const ScAddress& rPos )
2809cdf0e10cSrcweir {
2810cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
2811cdf0e10cSrcweir if ( pTab[nTab] )
2812cdf0e10cSrcweir return pTab[nTab]->GetValue( rPos );
2813cdf0e10cSrcweir return 0.0;
2814cdf0e10cSrcweir }
2815cdf0e10cSrcweir
2816cdf0e10cSrcweir
GetNumberFormat(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_uInt32 & rFormat)2817cdf0e10cSrcweir void ScDocument::GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab,
2818cdf0e10cSrcweir sal_uInt32& rFormat )
2819cdf0e10cSrcweir {
2820cdf0e10cSrcweir if (VALIDTAB(nTab))
2821cdf0e10cSrcweir if (pTab[nTab])
2822cdf0e10cSrcweir {
2823cdf0e10cSrcweir rFormat = pTab[nTab]->GetNumberFormat( nCol, nRow );
2824cdf0e10cSrcweir return ;
2825cdf0e10cSrcweir }
2826cdf0e10cSrcweir rFormat = 0;
2827cdf0e10cSrcweir }
2828cdf0e10cSrcweir
2829cdf0e10cSrcweir
GetNumberFormat(const ScAddress & rPos) const2830cdf0e10cSrcweir sal_uInt32 ScDocument::GetNumberFormat( const ScAddress& rPos ) const
2831cdf0e10cSrcweir {
2832cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
2833cdf0e10cSrcweir if ( pTab[nTab] )
2834cdf0e10cSrcweir return pTab[nTab]->GetNumberFormat( rPos );
2835cdf0e10cSrcweir return 0;
2836cdf0e10cSrcweir }
2837cdf0e10cSrcweir
2838cdf0e10cSrcweir
GetNumberFormatInfo(short & nType,sal_uLong & nIndex,const ScAddress & rPos,const ScBaseCell * pCell) const2839cdf0e10cSrcweir void ScDocument::GetNumberFormatInfo( short& nType, sal_uLong& nIndex,
2840cdf0e10cSrcweir const ScAddress& rPos, const ScBaseCell* pCell ) const
2841cdf0e10cSrcweir {
2842cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
2843cdf0e10cSrcweir if ( pTab[nTab] )
2844cdf0e10cSrcweir {
2845cdf0e10cSrcweir nIndex = pTab[nTab]->GetNumberFormat( rPos );
2846cdf0e10cSrcweir if ( (nIndex % SV_COUNTRY_LANGUAGE_OFFSET) == 0 && pCell &&
2847cdf0e10cSrcweir pCell->GetCellType() == CELLTYPE_FORMULA )
2848cdf0e10cSrcweir static_cast<const ScFormulaCell*>(pCell)->GetFormatInfo( nType, nIndex );
2849cdf0e10cSrcweir else
2850cdf0e10cSrcweir nType = GetFormatTable()->GetType( nIndex );
2851cdf0e10cSrcweir }
2852cdf0e10cSrcweir else
2853cdf0e10cSrcweir {
2854cdf0e10cSrcweir nType = NUMBERFORMAT_UNDEFINED;
2855cdf0e10cSrcweir nIndex = 0;
2856cdf0e10cSrcweir }
2857cdf0e10cSrcweir }
2858cdf0e10cSrcweir
2859cdf0e10cSrcweir
GetFormula(SCCOL nCol,SCROW nRow,SCTAB nTab,String & rFormula,sal_Bool bAsciiExport) const2860cdf0e10cSrcweir void ScDocument::GetFormula( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rFormula,
2861cdf0e10cSrcweir sal_Bool bAsciiExport ) const
2862cdf0e10cSrcweir {
2863cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
2864cdf0e10cSrcweir pTab[nTab]->GetFormula( nCol, nRow, rFormula, bAsciiExport );
2865cdf0e10cSrcweir else
2866cdf0e10cSrcweir rFormula.Erase();
2867cdf0e10cSrcweir }
2868cdf0e10cSrcweir
2869cdf0e10cSrcweir
GetCellType(const ScAddress & rPos) const2870cdf0e10cSrcweir CellType ScDocument::GetCellType( const ScAddress& rPos ) const
2871cdf0e10cSrcweir {
2872cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
2873cdf0e10cSrcweir if ( pTab[nTab] )
2874cdf0e10cSrcweir return pTab[nTab]->GetCellType( rPos );
2875cdf0e10cSrcweir return CELLTYPE_NONE;
2876cdf0e10cSrcweir }
2877cdf0e10cSrcweir
2878cdf0e10cSrcweir
GetCellType(SCCOL nCol,SCROW nRow,SCTAB nTab,CellType & rCellType) const2879cdf0e10cSrcweir void ScDocument::GetCellType( SCCOL nCol, SCROW nRow, SCTAB nTab,
2880cdf0e10cSrcweir CellType& rCellType ) const
2881cdf0e10cSrcweir {
2882cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
2883cdf0e10cSrcweir rCellType = pTab[nTab]->GetCellType( nCol, nRow );
2884cdf0e10cSrcweir else
2885cdf0e10cSrcweir rCellType = CELLTYPE_NONE;
2886cdf0e10cSrcweir }
2887cdf0e10cSrcweir
2888cdf0e10cSrcweir
GetCell(SCCOL nCol,SCROW nRow,SCTAB nTab,ScBaseCell * & rpCell) const2889cdf0e10cSrcweir void ScDocument::GetCell( SCCOL nCol, SCROW nRow, SCTAB nTab,
2890cdf0e10cSrcweir ScBaseCell*& rpCell ) const
2891cdf0e10cSrcweir {
2892cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
2893cdf0e10cSrcweir rpCell = pTab[nTab]->GetCell( nCol, nRow );
2894cdf0e10cSrcweir else
2895cdf0e10cSrcweir {
2896cdf0e10cSrcweir DBG_ERROR("GetCell ohne Tabelle");
2897cdf0e10cSrcweir rpCell = NULL;
2898cdf0e10cSrcweir }
2899cdf0e10cSrcweir }
2900cdf0e10cSrcweir
2901cdf0e10cSrcweir
GetCell(const ScAddress & rPos) const2902cdf0e10cSrcweir ScBaseCell* ScDocument::GetCell( const ScAddress& rPos ) const
2903cdf0e10cSrcweir {
2904cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
2905cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
2906cdf0e10cSrcweir return pTab[nTab]->GetCell( rPos );
2907cdf0e10cSrcweir
2908cdf0e10cSrcweir DBG_ERROR("GetCell ohne Tabelle");
2909cdf0e10cSrcweir return NULL;
2910cdf0e10cSrcweir }
2911cdf0e10cSrcweir
2912cdf0e10cSrcweir
HasStringData(SCCOL nCol,SCROW nRow,SCTAB nTab) const2913cdf0e10cSrcweir sal_Bool ScDocument::HasStringData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
2914cdf0e10cSrcweir {
2915cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
2916cdf0e10cSrcweir return pTab[nTab]->HasStringData( nCol, nRow );
2917cdf0e10cSrcweir else
2918cdf0e10cSrcweir return sal_False;
2919cdf0e10cSrcweir }
2920cdf0e10cSrcweir
2921cdf0e10cSrcweir
HasValueData(SCCOL nCol,SCROW nRow,SCTAB nTab) const2922cdf0e10cSrcweir sal_Bool ScDocument::HasValueData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
2923cdf0e10cSrcweir {
2924cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
2925cdf0e10cSrcweir return pTab[nTab]->HasValueData( nCol, nRow );
2926cdf0e10cSrcweir else
2927cdf0e10cSrcweir return sal_False;
2928cdf0e10cSrcweir }
2929cdf0e10cSrcweir
2930cdf0e10cSrcweir
HasStringCells(const ScRange & rRange) const2931cdf0e10cSrcweir sal_Bool ScDocument::HasStringCells( const ScRange& rRange ) const
2932cdf0e10cSrcweir {
2933cdf0e10cSrcweir // sal_True, wenn String- oder Editzellen im Bereich
2934cdf0e10cSrcweir
2935cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
2936cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
2937cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
2938cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
2939cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
2940cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
2941cdf0e10cSrcweir
2942cdf0e10cSrcweir for ( SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++ )
2943cdf0e10cSrcweir if ( pTab[nTab] && pTab[nTab]->HasStringCells( nStartCol, nStartRow, nEndCol, nEndRow ) )
2944cdf0e10cSrcweir return sal_True;
2945cdf0e10cSrcweir
2946cdf0e10cSrcweir return sal_False;
2947cdf0e10cSrcweir }
2948cdf0e10cSrcweir
2949cdf0e10cSrcweir
HasSelectionData(SCCOL nCol,SCROW nRow,SCTAB nTab) const2950cdf0e10cSrcweir sal_Bool ScDocument::HasSelectionData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
2951cdf0e10cSrcweir {
2952cdf0e10cSrcweir sal_uInt32 nValidation = static_cast< const SfxUInt32Item* >( GetAttr( nCol, nRow, nTab, ATTR_VALIDDATA ) )->GetValue();
2953cdf0e10cSrcweir if( nValidation )
2954cdf0e10cSrcweir {
2955cdf0e10cSrcweir const ScValidationData* pData = GetValidationEntry( nValidation );
2956cdf0e10cSrcweir if( pData && pData->HasSelectionList() )
2957cdf0e10cSrcweir return sal_True;
2958cdf0e10cSrcweir }
2959cdf0e10cSrcweir return HasStringCells( ScRange( nCol, 0, nTab, nCol, MAXROW, nTab ) );
2960cdf0e10cSrcweir }
2961cdf0e10cSrcweir
2962cdf0e10cSrcweir
GetNote(const ScAddress & rPos)2963cdf0e10cSrcweir ScPostIt* ScDocument::GetNote( const ScAddress& rPos )
2964cdf0e10cSrcweir {
2965cdf0e10cSrcweir ScTable* pTable = ValidTab( rPos.Tab() ) ? pTab[ rPos.Tab() ] : 0;
2966cdf0e10cSrcweir return pTable ? pTable->GetNote( rPos.Col(), rPos.Row() ) : 0;
2967cdf0e10cSrcweir }
2968cdf0e10cSrcweir
2969cdf0e10cSrcweir
TakeNote(const ScAddress & rPos,ScPostIt * & rpNote)2970cdf0e10cSrcweir void ScDocument::TakeNote( const ScAddress& rPos, ScPostIt*& rpNote )
2971cdf0e10cSrcweir {
2972cdf0e10cSrcweir if( ValidTab( rPos.Tab() ) && pTab[ rPos.Tab() ] )
2973cdf0e10cSrcweir pTab[ rPos.Tab() ]->TakeNote( rPos.Col(), rPos.Row(), rpNote );
2974cdf0e10cSrcweir else
2975cdf0e10cSrcweir DELETEZ( rpNote );
2976cdf0e10cSrcweir }
2977cdf0e10cSrcweir
2978cdf0e10cSrcweir
ReleaseNote(const ScAddress & rPos)2979cdf0e10cSrcweir ScPostIt* ScDocument::ReleaseNote( const ScAddress& rPos )
2980cdf0e10cSrcweir {
2981cdf0e10cSrcweir ScTable* pTable = ValidTab( rPos.Tab() ) ? pTab[ rPos.Tab() ] : 0;
2982cdf0e10cSrcweir return pTable ? pTable->ReleaseNote( rPos.Col(), rPos.Row() ) : 0;
2983cdf0e10cSrcweir }
2984cdf0e10cSrcweir
2985cdf0e10cSrcweir
GetOrCreateNote(const ScAddress & rPos)2986cdf0e10cSrcweir ScPostIt* ScDocument::GetOrCreateNote( const ScAddress& rPos )
2987cdf0e10cSrcweir {
2988cdf0e10cSrcweir ScPostIt* pNote = GetNote( rPos );
2989cdf0e10cSrcweir if( !pNote )
2990cdf0e10cSrcweir {
2991cdf0e10cSrcweir pNote = new ScPostIt( *this, rPos, false );
2992cdf0e10cSrcweir TakeNote( rPos, pNote );
2993cdf0e10cSrcweir }
2994cdf0e10cSrcweir return pNote;
2995cdf0e10cSrcweir }
2996cdf0e10cSrcweir
2997cdf0e10cSrcweir
DeleteNote(const ScAddress & rPos)2998cdf0e10cSrcweir void ScDocument::DeleteNote( const ScAddress& rPos )
2999cdf0e10cSrcweir {
3000cdf0e10cSrcweir if( ValidTab( rPos.Tab() ) && pTab[ rPos.Tab() ] )
3001cdf0e10cSrcweir pTab[ rPos.Tab() ]->DeleteNote( rPos.Col(), rPos.Row() );
3002cdf0e10cSrcweir }
3003cdf0e10cSrcweir
3004cdf0e10cSrcweir
InitializeNoteCaptions(SCTAB nTab,bool bForced)3005cdf0e10cSrcweir void ScDocument::InitializeNoteCaptions( SCTAB nTab, bool bForced )
3006cdf0e10cSrcweir {
3007cdf0e10cSrcweir if( ValidTab( nTab ) && pTab[ nTab ] )
3008cdf0e10cSrcweir pTab[ nTab ]->InitializeNoteCaptions( bForced );
3009cdf0e10cSrcweir }
3010cdf0e10cSrcweir
InitializeAllNoteCaptions(bool bForced)3011cdf0e10cSrcweir void ScDocument::InitializeAllNoteCaptions( bool bForced )
3012cdf0e10cSrcweir {
3013cdf0e10cSrcweir for( SCTAB nTab = 0; nTab < GetTableCount(); ++nTab )
3014cdf0e10cSrcweir InitializeNoteCaptions( nTab, bForced );
3015cdf0e10cSrcweir }
3016cdf0e10cSrcweir
SetDirty()3017cdf0e10cSrcweir void ScDocument::SetDirty()
3018cdf0e10cSrcweir {
3019cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
3020cdf0e10cSrcweir bAutoCalc = sal_False; // keine Mehrfachberechnung
3021cdf0e10cSrcweir { // scope for bulk broadcast
3022cdf0e10cSrcweir ScBulkBroadcast aBulkBroadcast( GetBASM());
3023cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
3024cdf0e10cSrcweir if (pTab[i]) pTab[i]->SetDirty();
3025cdf0e10cSrcweir }
3026cdf0e10cSrcweir
3027cdf0e10cSrcweir // Charts werden zwar auch ohne AutoCalc im Tracking auf Dirty gesetzt,
3028cdf0e10cSrcweir // wenn alle Formeln dirty sind, werden die Charts aber nicht mehr erwischt
3029cdf0e10cSrcweir // (#45205#) - darum alle Charts nochmal explizit
3030cdf0e10cSrcweir if (pChartListenerCollection)
3031cdf0e10cSrcweir pChartListenerCollection->SetDirty();
3032cdf0e10cSrcweir
3033cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
3034cdf0e10cSrcweir }
3035cdf0e10cSrcweir
3036cdf0e10cSrcweir
SetDirty(const ScRange & rRange)3037cdf0e10cSrcweir void ScDocument::SetDirty( const ScRange& rRange )
3038cdf0e10cSrcweir {
3039cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
3040cdf0e10cSrcweir bAutoCalc = sal_False; // keine Mehrfachberechnung
3041cdf0e10cSrcweir { // scope for bulk broadcast
3042cdf0e10cSrcweir ScBulkBroadcast aBulkBroadcast( GetBASM());
3043cdf0e10cSrcweir SCTAB nTab2 = rRange.aEnd.Tab();
3044cdf0e10cSrcweir for (SCTAB i=rRange.aStart.Tab(); i<=nTab2; i++)
3045cdf0e10cSrcweir if (pTab[i]) pTab[i]->SetDirty( rRange );
3046cdf0e10cSrcweir }
3047cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
3048cdf0e10cSrcweir }
3049cdf0e10cSrcweir
3050cdf0e10cSrcweir
SetTableOpDirty(const ScRange & rRange)3051cdf0e10cSrcweir void ScDocument::SetTableOpDirty( const ScRange& rRange )
3052cdf0e10cSrcweir {
3053cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
3054cdf0e10cSrcweir bAutoCalc = sal_False; // no multiple recalculation
3055cdf0e10cSrcweir SCTAB nTab2 = rRange.aEnd.Tab();
3056cdf0e10cSrcweir for (SCTAB i=rRange.aStart.Tab(); i<=nTab2; i++)
3057cdf0e10cSrcweir if (pTab[i]) pTab[i]->SetTableOpDirty( rRange );
3058cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
3059cdf0e10cSrcweir }
3060cdf0e10cSrcweir
3061cdf0e10cSrcweir
InterpretDirtyCells(const ScRangeList & rRanges)3062cdf0e10cSrcweir void ScDocument::InterpretDirtyCells( const ScRangeList& rRanges )
3063cdf0e10cSrcweir {
3064cdf0e10cSrcweir sal_uLong nRangeCount = rRanges.Count();
3065cdf0e10cSrcweir for (sal_uLong nPos=0; nPos<nRangeCount; nPos++)
3066cdf0e10cSrcweir {
3067cdf0e10cSrcweir ScCellIterator aIter( this, *rRanges.GetObject(nPos) );
3068cdf0e10cSrcweir ScBaseCell* pCell = aIter.GetFirst();
3069cdf0e10cSrcweir while (pCell)
3070cdf0e10cSrcweir {
3071cdf0e10cSrcweir if (pCell->GetCellType() == CELLTYPE_FORMULA)
3072cdf0e10cSrcweir {
3073cdf0e10cSrcweir if ( static_cast<ScFormulaCell*>(pCell)->GetDirty() && GetAutoCalc() )
3074cdf0e10cSrcweir static_cast<ScFormulaCell*>(pCell)->Interpret();
3075cdf0e10cSrcweir }
3076cdf0e10cSrcweir pCell = aIter.GetNext();
3077cdf0e10cSrcweir }
3078cdf0e10cSrcweir }
3079cdf0e10cSrcweir }
3080cdf0e10cSrcweir
3081cdf0e10cSrcweir
AddTableOpFormulaCell(ScFormulaCell * pCell)3082cdf0e10cSrcweir void ScDocument::AddTableOpFormulaCell( ScFormulaCell* pCell )
3083cdf0e10cSrcweir {
3084cdf0e10cSrcweir ScInterpreterTableOpParams* p = aTableOpList.Last();
3085cdf0e10cSrcweir if ( p && p->bCollectNotifications )
3086cdf0e10cSrcweir {
3087cdf0e10cSrcweir if ( p->bRefresh )
3088cdf0e10cSrcweir { // refresh pointers only
3089cdf0e10cSrcweir p->aNotifiedFormulaCells.push_back( pCell );
3090cdf0e10cSrcweir }
3091cdf0e10cSrcweir else
3092cdf0e10cSrcweir { // init both, address and pointer
3093cdf0e10cSrcweir p->aNotifiedFormulaCells.push_back( pCell );
3094cdf0e10cSrcweir p->aNotifiedFormulaPos.push_back( pCell->aPos );
3095cdf0e10cSrcweir }
3096cdf0e10cSrcweir }
3097cdf0e10cSrcweir }
3098cdf0e10cSrcweir
3099cdf0e10cSrcweir
CalcAll()3100cdf0e10cSrcweir void ScDocument::CalcAll()
3101cdf0e10cSrcweir {
3102cdf0e10cSrcweir ClearLookupCaches(); // Ensure we don't deliver zombie data.
3103cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
3104cdf0e10cSrcweir SetAutoCalc( sal_True );
3105cdf0e10cSrcweir SCTAB i;
3106cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
3107cdf0e10cSrcweir if (pTab[i]) pTab[i]->SetDirtyVar();
3108cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
3109cdf0e10cSrcweir if (pTab[i]) pTab[i]->CalcAll();
3110cdf0e10cSrcweir ClearFormulaTree();
3111cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
3112cdf0e10cSrcweir }
3113cdf0e10cSrcweir
3114cdf0e10cSrcweir
CompileAll()3115cdf0e10cSrcweir void ScDocument::CompileAll()
3116cdf0e10cSrcweir {
3117cdf0e10cSrcweir if ( pCondFormList )
3118cdf0e10cSrcweir pCondFormList->CompileAll();
3119cdf0e10cSrcweir
3120cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
3121cdf0e10cSrcweir if (pTab[i]) pTab[i]->CompileAll();
3122cdf0e10cSrcweir SetDirty();
3123cdf0e10cSrcweir }
3124cdf0e10cSrcweir
3125cdf0e10cSrcweir
CompileXML()3126cdf0e10cSrcweir void ScDocument::CompileXML()
3127cdf0e10cSrcweir {
3128cdf0e10cSrcweir sal_Bool bOldAutoCalc = GetAutoCalc();
3129cdf0e10cSrcweir SetAutoCalc( sal_False );
3130cdf0e10cSrcweir ScProgress aProgress( GetDocumentShell(), ScGlobal::GetRscString(
3131cdf0e10cSrcweir STR_PROGRESS_CALCULATING ), GetXMLImportedFormulaCount() );
3132cdf0e10cSrcweir
3133cdf0e10cSrcweir // #b6355215# set AutoNameCache to speed up automatic name lookup
3134cdf0e10cSrcweir DBG_ASSERT( !pAutoNameCache, "AutoNameCache already set" );
3135cdf0e10cSrcweir pAutoNameCache = new ScAutoNameCache( this );
3136cdf0e10cSrcweir
3137cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
3138cdf0e10cSrcweir if (pTab[i]) pTab[i]->CompileXML( aProgress );
3139cdf0e10cSrcweir
3140cdf0e10cSrcweir DELETEZ( pAutoNameCache ); // valid only during CompileXML, where cell contents don't change
3141cdf0e10cSrcweir
3142cdf0e10cSrcweir if ( pCondFormList )
3143cdf0e10cSrcweir pCondFormList->CompileXML();
3144cdf0e10cSrcweir if ( pValidationList )
3145cdf0e10cSrcweir pValidationList->CompileXML();
3146cdf0e10cSrcweir
3147cdf0e10cSrcweir SetDirty();
3148cdf0e10cSrcweir SetAutoCalc( bOldAutoCalc );
3149cdf0e10cSrcweir }
3150cdf0e10cSrcweir
3151cdf0e10cSrcweir
CalcAfterLoad()3152cdf0e10cSrcweir void ScDocument::CalcAfterLoad()
3153cdf0e10cSrcweir {
3154cdf0e10cSrcweir SCTAB i;
3155cdf0e10cSrcweir
3156cdf0e10cSrcweir if (bIsClip) // Excel-Dateien werden aus dem Clipboard in ein Clip-Doc geladen
3157cdf0e10cSrcweir return; // dann wird erst beim Einfuegen in das richtige Doc berechnet
3158cdf0e10cSrcweir
3159cdf0e10cSrcweir bCalcingAfterLoad = sal_True;
3160cdf0e10cSrcweir for ( i = 0; i <= MAXTAB; i++)
3161cdf0e10cSrcweir if (pTab[i]) pTab[i]->CalcAfterLoad();
3162cdf0e10cSrcweir for (i=0; i<=MAXTAB; i++)
3163cdf0e10cSrcweir if (pTab[i]) pTab[i]->SetDirtyAfterLoad();
3164cdf0e10cSrcweir bCalcingAfterLoad = sal_False;
3165cdf0e10cSrcweir
3166cdf0e10cSrcweir SetDetectiveDirty(sal_False); // noch keine wirklichen Aenderungen
3167cdf0e10cSrcweir
3168cdf0e10cSrcweir // #i112436# If formula cells are already dirty, they don't broadcast further changes.
3169cdf0e10cSrcweir // So the source ranges of charts must be interpreted even if they are not visible,
3170cdf0e10cSrcweir // similar to ScMyShapeResizer::CreateChartListener for loading own files (i104899).
3171cdf0e10cSrcweir if (pChartListenerCollection)
3172cdf0e10cSrcweir {
3173cdf0e10cSrcweir sal_uInt16 nChartCount = pChartListenerCollection->GetCount();
3174cdf0e10cSrcweir for ( sal_uInt16 nIndex = 0; nIndex < nChartCount; nIndex++ )
3175cdf0e10cSrcweir {
3176cdf0e10cSrcweir ScChartListener* pChartListener = static_cast<ScChartListener*>(pChartListenerCollection->At(nIndex));
3177cdf0e10cSrcweir InterpretDirtyCells(*pChartListener->GetRangeList());
3178cdf0e10cSrcweir }
3179cdf0e10cSrcweir }
3180cdf0e10cSrcweir }
3181cdf0e10cSrcweir
3182cdf0e10cSrcweir
GetErrCode(const ScAddress & rPos) const3183cdf0e10cSrcweir sal_uInt16 ScDocument::GetErrCode( const ScAddress& rPos ) const
3184cdf0e10cSrcweir {
3185cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
3186cdf0e10cSrcweir if ( pTab[nTab] )
3187cdf0e10cSrcweir return pTab[nTab]->GetErrCode( rPos );
3188cdf0e10cSrcweir return 0;
3189cdf0e10cSrcweir }
3190cdf0e10cSrcweir
3191cdf0e10cSrcweir
ResetChanged(const ScRange & rRange)3192cdf0e10cSrcweir void ScDocument::ResetChanged( const ScRange& rRange )
3193cdf0e10cSrcweir {
3194cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
3195cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
3196cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
3197cdf0e10cSrcweir if (pTab[nTab])
3198cdf0e10cSrcweir pTab[nTab]->ResetChanged( rRange );
3199cdf0e10cSrcweir }
3200cdf0e10cSrcweir
3201cdf0e10cSrcweir //
3202cdf0e10cSrcweir // Spaltenbreiten / Zeilenhoehen --------------------------------------
3203cdf0e10cSrcweir //
3204cdf0e10cSrcweir
3205cdf0e10cSrcweir
SetColWidth(SCCOL nCol,SCTAB nTab,sal_uInt16 nNewWidth)3206cdf0e10cSrcweir void ScDocument::SetColWidth( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth )
3207cdf0e10cSrcweir {
3208cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3209cdf0e10cSrcweir pTab[nTab]->SetColWidth( nCol, nNewWidth );
3210cdf0e10cSrcweir }
3211cdf0e10cSrcweir
SetColWidthOnly(SCCOL nCol,SCTAB nTab,sal_uInt16 nNewWidth)32123ce8cab8SWang Lei void ScDocument::SetColWidthOnly( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth )
32133ce8cab8SWang Lei {
32143ce8cab8SWang Lei if ( ValidTab(nTab) && pTab[nTab] )
32153ce8cab8SWang Lei pTab[nTab]->SetColWidthOnly( nCol, nNewWidth );
32163ce8cab8SWang Lei }
3217cdf0e10cSrcweir
SetRowHeight(SCROW nRow,SCTAB nTab,sal_uInt16 nNewHeight)3218cdf0e10cSrcweir void ScDocument::SetRowHeight( SCROW nRow, SCTAB nTab, sal_uInt16 nNewHeight )
3219cdf0e10cSrcweir {
3220cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3221cdf0e10cSrcweir pTab[nTab]->SetRowHeight( nRow, nNewHeight );
3222cdf0e10cSrcweir }
3223cdf0e10cSrcweir
3224cdf0e10cSrcweir
SetRowHeightRange(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,sal_uInt16 nNewHeight)3225cdf0e10cSrcweir void ScDocument::SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nNewHeight )
3226cdf0e10cSrcweir {
3227cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3228cdf0e10cSrcweir pTab[nTab]->SetRowHeightRange
3229cdf0e10cSrcweir ( nStartRow, nEndRow, nNewHeight, 1.0, 1.0 );
3230cdf0e10cSrcweir }
3231cdf0e10cSrcweir
SetRowHeightOnly(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,sal_uInt16 nNewHeight)3232cdf0e10cSrcweir void ScDocument::SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nNewHeight )
3233cdf0e10cSrcweir {
3234cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3235cdf0e10cSrcweir pTab[nTab]->SetRowHeightOnly( nStartRow, nEndRow, nNewHeight );
3236cdf0e10cSrcweir }
3237cdf0e10cSrcweir
SetManualHeight(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,sal_Bool bManual)3238cdf0e10cSrcweir void ScDocument::SetManualHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_Bool bManual )
3239cdf0e10cSrcweir {
3240cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3241cdf0e10cSrcweir pTab[nTab]->SetManualHeight( nStartRow, nEndRow, bManual );
3242cdf0e10cSrcweir }
3243cdf0e10cSrcweir
3244cdf0e10cSrcweir
GetColWidth(SCCOL nCol,SCTAB nTab) const3245cdf0e10cSrcweir sal_uInt16 ScDocument::GetColWidth( SCCOL nCol, SCTAB nTab ) const
3246cdf0e10cSrcweir {
3247cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3248cdf0e10cSrcweir return pTab[nTab]->GetColWidth( nCol );
3249cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3250cdf0e10cSrcweir return 0;
3251cdf0e10cSrcweir }
3252cdf0e10cSrcweir
3253cdf0e10cSrcweir
GetOriginalWidth(SCCOL nCol,SCTAB nTab) const3254cdf0e10cSrcweir sal_uInt16 ScDocument::GetOriginalWidth( SCCOL nCol, SCTAB nTab ) const
3255cdf0e10cSrcweir {
3256cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3257cdf0e10cSrcweir return pTab[nTab]->GetOriginalWidth( nCol );
3258cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3259cdf0e10cSrcweir return 0;
3260cdf0e10cSrcweir }
3261cdf0e10cSrcweir
3262cdf0e10cSrcweir
GetCommonWidth(SCCOL nEndCol,SCTAB nTab) const3263cdf0e10cSrcweir sal_uInt16 ScDocument::GetCommonWidth( SCCOL nEndCol, SCTAB nTab ) const
3264cdf0e10cSrcweir {
3265cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3266cdf0e10cSrcweir return pTab[nTab]->GetCommonWidth( nEndCol );
3267cdf0e10cSrcweir DBG_ERROR("Wrong table number");
3268cdf0e10cSrcweir return 0;
3269cdf0e10cSrcweir }
3270cdf0e10cSrcweir
3271cdf0e10cSrcweir
GetOriginalHeight(SCROW nRow,SCTAB nTab) const3272cdf0e10cSrcweir sal_uInt16 ScDocument::GetOriginalHeight( SCROW nRow, SCTAB nTab ) const
3273cdf0e10cSrcweir {
3274cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3275cdf0e10cSrcweir return pTab[nTab]->GetOriginalHeight( nRow );
3276cdf0e10cSrcweir DBG_ERROR("Wrong table number");
3277cdf0e10cSrcweir return 0;
3278cdf0e10cSrcweir }
3279cdf0e10cSrcweir
3280cdf0e10cSrcweir
GetRowHeight(SCROW nRow,SCTAB nTab,bool bHiddenAsZero) const3281cdf0e10cSrcweir sal_uInt16 ScDocument::GetRowHeight( SCROW nRow, SCTAB nTab, bool bHiddenAsZero ) const
3282cdf0e10cSrcweir {
3283cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3284cdf0e10cSrcweir return pTab[nTab]->GetRowHeight( nRow, NULL, NULL, bHiddenAsZero );
3285cdf0e10cSrcweir DBG_ERROR("Wrong sheet number");
3286cdf0e10cSrcweir return 0;
3287cdf0e10cSrcweir }
3288cdf0e10cSrcweir
3289cdf0e10cSrcweir
GetRowHeight(SCROW nRow,SCTAB nTab,SCROW * pStartRow,SCROW * pEndRow,bool bHiddenAsZero) const3290cdf0e10cSrcweir sal_uInt16 ScDocument::GetRowHeight( SCROW nRow, SCTAB nTab, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero ) const
3291cdf0e10cSrcweir {
3292cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3293cdf0e10cSrcweir return pTab[nTab]->GetRowHeight( nRow, pStartRow, pEndRow, bHiddenAsZero );
3294cdf0e10cSrcweir DBG_ERROR("Wrong sheet number");
3295cdf0e10cSrcweir return 0;
3296cdf0e10cSrcweir }
3297cdf0e10cSrcweir
3298cdf0e10cSrcweir
GetRowHeight(SCROW nStartRow,SCROW nEndRow,SCTAB nTab) const3299cdf0e10cSrcweir sal_uLong ScDocument::GetRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) const
3300cdf0e10cSrcweir {
3301cdf0e10cSrcweir if (nStartRow == nEndRow)
3302cdf0e10cSrcweir return GetRowHeight( nStartRow, nTab); // faster for a single row
3303cdf0e10cSrcweir
3304cdf0e10cSrcweir // check bounds because this method replaces former for(i=start;i<=end;++i) loops
3305cdf0e10cSrcweir if (nStartRow > nEndRow)
3306cdf0e10cSrcweir return 0;
3307cdf0e10cSrcweir
3308cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3309cdf0e10cSrcweir return pTab[nTab]->GetRowHeight( nStartRow, nEndRow);
3310cdf0e10cSrcweir
3311cdf0e10cSrcweir DBG_ERROR("wrong sheet number");
3312cdf0e10cSrcweir return 0;
3313cdf0e10cSrcweir }
3314cdf0e10cSrcweir
GetRowForHeight(SCTAB nTab,sal_uLong nHeight) const3315cdf0e10cSrcweir SCROW ScDocument::GetRowForHeight( SCTAB nTab, sal_uLong nHeight ) const
3316cdf0e10cSrcweir {
3317cdf0e10cSrcweir return pTab[nTab]->GetRowForHeight(nHeight);
3318cdf0e10cSrcweir }
3319cdf0e10cSrcweir
GetScaledRowHeight(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,double fScale) const3320cdf0e10cSrcweir sal_uLong ScDocument::GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow,
3321cdf0e10cSrcweir SCTAB nTab, double fScale ) const
3322cdf0e10cSrcweir {
3323cdf0e10cSrcweir // faster for a single row
3324cdf0e10cSrcweir if (nStartRow == nEndRow)
3325cdf0e10cSrcweir return (sal_uLong) (GetRowHeight( nStartRow, nTab) * fScale);
3326cdf0e10cSrcweir
3327cdf0e10cSrcweir // check bounds because this method replaces former for(i=start;i<=end;++i) loops
3328cdf0e10cSrcweir if (nStartRow > nEndRow)
3329cdf0e10cSrcweir return 0;
3330cdf0e10cSrcweir
3331cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3332cdf0e10cSrcweir return pTab[nTab]->GetScaledRowHeight( nStartRow, nEndRow, fScale);
3333cdf0e10cSrcweir
3334cdf0e10cSrcweir DBG_ERROR("wrong sheet number");
3335cdf0e10cSrcweir return 0;
3336cdf0e10cSrcweir }
3337cdf0e10cSrcweir
GetHiddenRowCount(SCROW nRow,SCTAB nTab) const3338cdf0e10cSrcweir SCROW ScDocument::GetHiddenRowCount( SCROW nRow, SCTAB nTab ) const
3339cdf0e10cSrcweir {
3340cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3341cdf0e10cSrcweir return pTab[nTab]->GetHiddenRowCount( nRow );
3342cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3343cdf0e10cSrcweir return 0;
3344cdf0e10cSrcweir }
3345cdf0e10cSrcweir
3346cdf0e10cSrcweir
GetColOffset(SCCOL nCol,SCTAB nTab) const3347cdf0e10cSrcweir sal_uLong ScDocument::GetColOffset( SCCOL nCol, SCTAB nTab ) const
3348cdf0e10cSrcweir {
3349cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3350cdf0e10cSrcweir return pTab[nTab]->GetColOffset( nCol );
3351cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3352cdf0e10cSrcweir return 0;
3353cdf0e10cSrcweir }
3354cdf0e10cSrcweir
3355cdf0e10cSrcweir
GetRowOffset(SCROW nRow,SCTAB nTab) const3356cdf0e10cSrcweir sal_uLong ScDocument::GetRowOffset( SCROW nRow, SCTAB nTab ) const
3357cdf0e10cSrcweir {
3358cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3359cdf0e10cSrcweir return pTab[nTab]->GetRowOffset( nRow );
3360cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3361cdf0e10cSrcweir return 0;
3362cdf0e10cSrcweir }
3363cdf0e10cSrcweir
3364cdf0e10cSrcweir
GetOptimalColWidth(SCCOL nCol,SCTAB nTab,OutputDevice * pDev,double nPPTX,double nPPTY,const Fraction & rZoomX,const Fraction & rZoomY,sal_Bool bFormula,const ScMarkData * pMarkData,sal_Bool bSimpleTextImport)3365cdf0e10cSrcweir sal_uInt16 ScDocument::GetOptimalColWidth( SCCOL nCol, SCTAB nTab, OutputDevice* pDev,
3366cdf0e10cSrcweir double nPPTX, double nPPTY,
3367cdf0e10cSrcweir const Fraction& rZoomX, const Fraction& rZoomY,
3368cdf0e10cSrcweir sal_Bool bFormula, const ScMarkData* pMarkData,
3369cdf0e10cSrcweir sal_Bool bSimpleTextImport )
3370cdf0e10cSrcweir {
3371cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3372cdf0e10cSrcweir return pTab[nTab]->GetOptimalColWidth( nCol, pDev, nPPTX, nPPTY,
3373cdf0e10cSrcweir rZoomX, rZoomY, bFormula, pMarkData, bSimpleTextImport );
3374cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3375cdf0e10cSrcweir return 0;
3376cdf0e10cSrcweir }
3377cdf0e10cSrcweir
3378cdf0e10cSrcweir
GetNeededSize(SCCOL nCol,SCROW nRow,SCTAB nTab,OutputDevice * pDev,double nPPTX,double nPPTY,const Fraction & rZoomX,const Fraction & rZoomY,sal_Bool bWidth,sal_Bool bTotalSize)3379cdf0e10cSrcweir long ScDocument::GetNeededSize( SCCOL nCol, SCROW nRow, SCTAB nTab,
3380cdf0e10cSrcweir OutputDevice* pDev,
3381cdf0e10cSrcweir double nPPTX, double nPPTY,
3382cdf0e10cSrcweir const Fraction& rZoomX, const Fraction& rZoomY,
3383cdf0e10cSrcweir sal_Bool bWidth, sal_Bool bTotalSize )
3384cdf0e10cSrcweir {
3385cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3386cdf0e10cSrcweir return pTab[nTab]->GetNeededSize
3387cdf0e10cSrcweir ( nCol, nRow, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bWidth, bTotalSize );
3388cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3389cdf0e10cSrcweir return 0;
3390cdf0e10cSrcweir }
3391cdf0e10cSrcweir
3392cdf0e10cSrcweir
SetOptimalHeight(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,sal_uInt16 nExtra,OutputDevice * pDev,double nPPTX,double nPPTY,const Fraction & rZoomX,const Fraction & rZoomY,sal_Bool bShrink)3393cdf0e10cSrcweir sal_Bool ScDocument::SetOptimalHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nExtra,
3394cdf0e10cSrcweir OutputDevice* pDev,
3395cdf0e10cSrcweir double nPPTX, double nPPTY,
3396cdf0e10cSrcweir const Fraction& rZoomX, const Fraction& rZoomY,
3397cdf0e10cSrcweir sal_Bool bShrink )
3398cdf0e10cSrcweir {
3399cdf0e10cSrcweir //! MarkToMulti();
3400cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3401cdf0e10cSrcweir return pTab[nTab]->SetOptimalHeight( nStartRow, nEndRow, nExtra,
3402cdf0e10cSrcweir pDev, nPPTX, nPPTY, rZoomX, rZoomY, bShrink );
3403cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3404cdf0e10cSrcweir return sal_False;
3405cdf0e10cSrcweir }
3406cdf0e10cSrcweir
3407cdf0e10cSrcweir
UpdateAllRowHeights(OutputDevice * pDev,double nPPTX,double nPPTY,const Fraction & rZoomX,const Fraction & rZoomY,const ScMarkData * pTabMark)3408cdf0e10cSrcweir void ScDocument::UpdateAllRowHeights( OutputDevice* pDev, double nPPTX, double nPPTY,
3409cdf0e10cSrcweir const Fraction& rZoomX, const Fraction& rZoomY, const ScMarkData* pTabMark )
3410cdf0e10cSrcweir {
3411cdf0e10cSrcweir // one progress across all (selected) sheets
3412cdf0e10cSrcweir
3413cdf0e10cSrcweir sal_uLong nCellCount = 0;
3414cdf0e10cSrcweir for ( SCTAB nTab=0; nTab<=MAXTAB; nTab++ )
3415cdf0e10cSrcweir if ( pTab[nTab] && ( !pTabMark || pTabMark->GetTableSelect(nTab) ) )
3416cdf0e10cSrcweir nCellCount += pTab[nTab]->GetWeightedCount();
3417cdf0e10cSrcweir
3418cdf0e10cSrcweir ScProgress aProgress( GetDocumentShell(), ScGlobal::GetRscString(STR_PROGRESS_HEIGHTING), nCellCount );
3419cdf0e10cSrcweir
3420cdf0e10cSrcweir sal_uLong nProgressStart = 0;
3421cdf0e10cSrcweir for ( SCTAB nTab=0; nTab<=MAXTAB; nTab++ )
3422cdf0e10cSrcweir if ( pTab[nTab] && ( !pTabMark || pTabMark->GetTableSelect(nTab) ) )
3423cdf0e10cSrcweir {
3424cdf0e10cSrcweir pTab[nTab]->SetOptimalHeight( 0, MAXROW, 0,
3425cdf0e10cSrcweir pDev, nPPTX, nPPTY, rZoomX, rZoomY, sal_False, &aProgress, nProgressStart );
3426cdf0e10cSrcweir nProgressStart += pTab[nTab]->GetWeightedCount();
3427cdf0e10cSrcweir }
3428cdf0e10cSrcweir }
3429cdf0e10cSrcweir
3430cdf0e10cSrcweir
3431cdf0e10cSrcweir //
3432cdf0e10cSrcweir // Spalten-/Zeilen-Flags ----------------------------------------------
3433cdf0e10cSrcweir //
3434cdf0e10cSrcweir
ShowCol(SCCOL nCol,SCTAB nTab,sal_Bool bShow)3435cdf0e10cSrcweir void ScDocument::ShowCol(SCCOL nCol, SCTAB nTab, sal_Bool bShow)
3436cdf0e10cSrcweir {
3437cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3438cdf0e10cSrcweir pTab[nTab]->ShowCol( nCol, bShow );
3439cdf0e10cSrcweir }
3440cdf0e10cSrcweir
3441cdf0e10cSrcweir
ShowRow(SCROW nRow,SCTAB nTab,sal_Bool bShow)3442cdf0e10cSrcweir void ScDocument::ShowRow(SCROW nRow, SCTAB nTab, sal_Bool bShow)
3443cdf0e10cSrcweir {
3444cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3445cdf0e10cSrcweir pTab[nTab]->ShowRow( nRow, bShow );
3446cdf0e10cSrcweir }
3447cdf0e10cSrcweir
3448cdf0e10cSrcweir
ShowRows(SCROW nRow1,SCROW nRow2,SCTAB nTab,sal_Bool bShow)3449cdf0e10cSrcweir void ScDocument::ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, sal_Bool bShow)
3450cdf0e10cSrcweir {
3451cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3452cdf0e10cSrcweir pTab[nTab]->ShowRows( nRow1, nRow2, bShow );
3453cdf0e10cSrcweir }
3454cdf0e10cSrcweir
3455cdf0e10cSrcweir
SetColFlags(SCCOL nCol,SCTAB nTab,sal_uInt8 nNewFlags)3456cdf0e10cSrcweir void ScDocument::SetColFlags( SCCOL nCol, SCTAB nTab, sal_uInt8 nNewFlags )
3457cdf0e10cSrcweir {
3458cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3459cdf0e10cSrcweir pTab[nTab]->SetColFlags( nCol, nNewFlags );
3460cdf0e10cSrcweir }
3461cdf0e10cSrcweir
3462cdf0e10cSrcweir
SetRowFlags(SCROW nRow,SCTAB nTab,sal_uInt8 nNewFlags)3463cdf0e10cSrcweir void ScDocument::SetRowFlags( SCROW nRow, SCTAB nTab, sal_uInt8 nNewFlags )
3464cdf0e10cSrcweir {
3465cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3466cdf0e10cSrcweir pTab[nTab]->SetRowFlags( nRow, nNewFlags );
3467cdf0e10cSrcweir }
3468cdf0e10cSrcweir
3469cdf0e10cSrcweir
SetRowFlags(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,sal_uInt8 nNewFlags)3470cdf0e10cSrcweir void ScDocument::SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt8 nNewFlags )
3471cdf0e10cSrcweir {
3472cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3473cdf0e10cSrcweir pTab[nTab]->SetRowFlags( nStartRow, nEndRow, nNewFlags );
3474cdf0e10cSrcweir }
3475cdf0e10cSrcweir
3476cdf0e10cSrcweir
GetColFlags(SCCOL nCol,SCTAB nTab) const3477cdf0e10cSrcweir sal_uInt8 ScDocument::GetColFlags( SCCOL nCol, SCTAB nTab ) const
3478cdf0e10cSrcweir {
3479cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3480cdf0e10cSrcweir return pTab[nTab]->GetColFlags( nCol );
3481cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3482cdf0e10cSrcweir return 0;
3483cdf0e10cSrcweir }
3484cdf0e10cSrcweir
GetRowFlags(SCROW nRow,SCTAB nTab) const3485cdf0e10cSrcweir sal_uInt8 ScDocument::GetRowFlags( SCROW nRow, SCTAB nTab ) const
3486cdf0e10cSrcweir {
3487cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3488cdf0e10cSrcweir return pTab[nTab]->GetRowFlags( nRow );
3489cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
3490cdf0e10cSrcweir return 0;
3491cdf0e10cSrcweir }
3492cdf0e10cSrcweir
GetRowFlagsArrayModifiable(SCTAB nTab)3493cdf0e10cSrcweir ScBitMaskCompressedArray< SCROW, sal_uInt8> & ScDocument::GetRowFlagsArrayModifiable(
3494cdf0e10cSrcweir SCTAB nTab )
3495cdf0e10cSrcweir {
3496cdf0e10cSrcweir return const_cast< ScBitMaskCompressedArray< SCROW, sal_uInt8> & >(
3497cdf0e10cSrcweir GetRowFlagsArray( nTab));
3498cdf0e10cSrcweir }
3499cdf0e10cSrcweir
GetRowFlagsArray(SCTAB nTab) const3500cdf0e10cSrcweir const ScBitMaskCompressedArray< SCROW, sal_uInt8> & ScDocument::GetRowFlagsArray(
3501cdf0e10cSrcweir SCTAB nTab ) const
3502cdf0e10cSrcweir {
3503cdf0e10cSrcweir const ScBitMaskCompressedArray< SCROW, sal_uInt8> * pFlags;
3504cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3505cdf0e10cSrcweir pFlags = pTab[nTab]->GetRowFlagsArray();
3506cdf0e10cSrcweir else
3507cdf0e10cSrcweir {
3508cdf0e10cSrcweir DBG_ERROR("wrong sheet number");
3509cdf0e10cSrcweir pFlags = 0;
3510cdf0e10cSrcweir }
3511cdf0e10cSrcweir if (!pFlags)
3512cdf0e10cSrcweir {
3513cdf0e10cSrcweir DBG_ERROR("no row flags at sheet");
3514cdf0e10cSrcweir static ScBitMaskCompressedArray< SCROW, sal_uInt8> aDummy( MAXROW, 0);
3515cdf0e10cSrcweir pFlags = &aDummy;
3516cdf0e10cSrcweir }
3517cdf0e10cSrcweir return *pFlags;
3518cdf0e10cSrcweir }
3519cdf0e10cSrcweir
GetAllRowBreaks(set<SCROW> & rBreaks,SCTAB nTab,bool bPage,bool bManual) const3520cdf0e10cSrcweir void ScDocument::GetAllRowBreaks(set<SCROW>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const
3521cdf0e10cSrcweir {
3522cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3523cdf0e10cSrcweir return;
3524cdf0e10cSrcweir
3525cdf0e10cSrcweir pTab[nTab]->GetAllRowBreaks(rBreaks, bPage, bManual);
3526cdf0e10cSrcweir }
3527cdf0e10cSrcweir
GetAllColBreaks(set<SCCOL> & rBreaks,SCTAB nTab,bool bPage,bool bManual) const3528cdf0e10cSrcweir void ScDocument::GetAllColBreaks(set<SCCOL>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const
3529cdf0e10cSrcweir {
3530cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3531cdf0e10cSrcweir return;
3532cdf0e10cSrcweir
3533cdf0e10cSrcweir pTab[nTab]->GetAllColBreaks(rBreaks, bPage, bManual);
3534cdf0e10cSrcweir }
3535cdf0e10cSrcweir
HasRowBreak(SCROW nRow,SCTAB nTab) const3536cdf0e10cSrcweir ScBreakType ScDocument::HasRowBreak(SCROW nRow, SCTAB nTab) const
3537cdf0e10cSrcweir {
3538cdf0e10cSrcweir ScBreakType nType = BREAK_NONE;
3539cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab] || !ValidRow(nRow))
3540cdf0e10cSrcweir return nType;
3541cdf0e10cSrcweir
3542cdf0e10cSrcweir if (pTab[nTab]->HasRowPageBreak(nRow))
3543cdf0e10cSrcweir nType |= BREAK_PAGE;
3544cdf0e10cSrcweir
3545cdf0e10cSrcweir if (pTab[nTab]->HasRowManualBreak(nRow))
3546cdf0e10cSrcweir nType |= BREAK_MANUAL;
3547cdf0e10cSrcweir
3548cdf0e10cSrcweir return nType;
3549cdf0e10cSrcweir }
3550cdf0e10cSrcweir
HasColBreak(SCCOL nCol,SCTAB nTab) const3551cdf0e10cSrcweir ScBreakType ScDocument::HasColBreak(SCCOL nCol, SCTAB nTab) const
3552cdf0e10cSrcweir {
3553cdf0e10cSrcweir ScBreakType nType = BREAK_NONE;
3554cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab] || !ValidCol(nCol))
3555cdf0e10cSrcweir return nType;
3556cdf0e10cSrcweir
3557cdf0e10cSrcweir if (pTab[nTab]->HasColPageBreak(nCol))
3558cdf0e10cSrcweir nType |= BREAK_PAGE;
3559cdf0e10cSrcweir
3560cdf0e10cSrcweir if (pTab[nTab]->HasColManualBreak(nCol))
3561cdf0e10cSrcweir nType |= BREAK_MANUAL;
3562cdf0e10cSrcweir
3563cdf0e10cSrcweir return nType;
3564cdf0e10cSrcweir }
3565cdf0e10cSrcweir
SetRowBreak(SCROW nRow,SCTAB nTab,bool bPage,bool bManual)3566cdf0e10cSrcweir void ScDocument::SetRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual)
3567cdf0e10cSrcweir {
3568cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab] || !ValidRow(nRow))
3569cdf0e10cSrcweir return;
3570cdf0e10cSrcweir
3571cdf0e10cSrcweir pTab[nTab]->SetRowBreak(nRow, bPage, bManual);
3572cdf0e10cSrcweir }
3573cdf0e10cSrcweir
SetColBreak(SCCOL nCol,SCTAB nTab,bool bPage,bool bManual)3574cdf0e10cSrcweir void ScDocument::SetColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual)
3575cdf0e10cSrcweir {
3576cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab] || !ValidCol(nCol))
3577cdf0e10cSrcweir return;
3578cdf0e10cSrcweir
3579cdf0e10cSrcweir pTab[nTab]->SetColBreak(nCol, bPage, bManual);
3580cdf0e10cSrcweir }
3581cdf0e10cSrcweir
RemoveRowBreak(SCROW nRow,SCTAB nTab,bool bPage,bool bManual)3582cdf0e10cSrcweir void ScDocument::RemoveRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual)
3583cdf0e10cSrcweir {
3584cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab] || !ValidRow(nRow))
3585cdf0e10cSrcweir return;
3586cdf0e10cSrcweir
3587cdf0e10cSrcweir pTab[nTab]->RemoveRowBreak(nRow, bPage, bManual);
3588cdf0e10cSrcweir }
3589cdf0e10cSrcweir
RemoveColBreak(SCCOL nCol,SCTAB nTab,bool bPage,bool bManual)3590cdf0e10cSrcweir void ScDocument::RemoveColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual)
3591cdf0e10cSrcweir {
3592cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab] || !ValidCol(nCol))
3593cdf0e10cSrcweir return;
3594cdf0e10cSrcweir
3595cdf0e10cSrcweir pTab[nTab]->RemoveColBreak(nCol, bPage, bManual);
3596cdf0e10cSrcweir }
3597cdf0e10cSrcweir
GetRowBreakData(SCTAB nTab) const3598cdf0e10cSrcweir Sequence<TablePageBreakData> ScDocument::GetRowBreakData(SCTAB nTab) const
3599cdf0e10cSrcweir {
3600cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3601cdf0e10cSrcweir return Sequence<TablePageBreakData>();
3602cdf0e10cSrcweir
3603cdf0e10cSrcweir return pTab[nTab]->GetRowBreakData();
3604cdf0e10cSrcweir }
3605cdf0e10cSrcweir
RowHidden(SCROW nRow,SCTAB nTab,SCROW * pFirstRow,SCROW * pLastRow)3606cdf0e10cSrcweir bool ScDocument::RowHidden(SCROW nRow, SCTAB nTab, SCROW* pFirstRow, SCROW* pLastRow)
3607cdf0e10cSrcweir {
3608cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3609cdf0e10cSrcweir return false;
3610cdf0e10cSrcweir
3611cdf0e10cSrcweir return pTab[nTab]->RowHidden(nRow, pFirstRow, pLastRow);
3612cdf0e10cSrcweir }
3613cdf0e10cSrcweir
RowHidden(SCROW nRow,SCTAB nTab,SCROW & rLastRow)3614cdf0e10cSrcweir bool ScDocument::RowHidden(SCROW nRow, SCTAB nTab, SCROW& rLastRow)
3615cdf0e10cSrcweir {
3616cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3617cdf0e10cSrcweir {
3618cdf0e10cSrcweir rLastRow = nRow;
3619cdf0e10cSrcweir return false;
3620cdf0e10cSrcweir }
3621cdf0e10cSrcweir
3622cdf0e10cSrcweir return pTab[nTab]->RowHidden(nRow, rLastRow);
3623cdf0e10cSrcweir }
3624cdf0e10cSrcweir
3625cdf0e10cSrcweir
HasHiddenRows(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3626cdf0e10cSrcweir bool ScDocument::HasHiddenRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3627cdf0e10cSrcweir {
3628cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3629cdf0e10cSrcweir return false;
3630cdf0e10cSrcweir
3631cdf0e10cSrcweir return pTab[nTab]->HasHiddenRows(nStartRow, nEndRow);
3632cdf0e10cSrcweir }
3633cdf0e10cSrcweir
ColHidden(SCCOL nCol,SCTAB nTab,SCCOL & rLastCol)3634cdf0e10cSrcweir bool ScDocument::ColHidden(SCCOL nCol, SCTAB nTab, SCCOL& rLastCol)
3635cdf0e10cSrcweir {
3636cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3637cdf0e10cSrcweir {
3638cdf0e10cSrcweir rLastCol = nCol;
3639cdf0e10cSrcweir return false;
3640cdf0e10cSrcweir }
3641cdf0e10cSrcweir
3642cdf0e10cSrcweir return pTab[nTab]->ColHidden(nCol, rLastCol);
3643cdf0e10cSrcweir }
3644cdf0e10cSrcweir
ColHidden(SCCOL nCol,SCTAB nTab,SCCOL * pFirstCol,SCCOL * pLastCol)3645cdf0e10cSrcweir bool ScDocument::ColHidden(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol, SCCOL* pLastCol)
3646cdf0e10cSrcweir {
3647cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3648cdf0e10cSrcweir {
3649cdf0e10cSrcweir if (pFirstCol)
3650cdf0e10cSrcweir *pFirstCol = nCol;
3651cdf0e10cSrcweir if (pLastCol)
3652cdf0e10cSrcweir *pLastCol = nCol;
3653cdf0e10cSrcweir return false;
3654cdf0e10cSrcweir }
3655cdf0e10cSrcweir
3656cdf0e10cSrcweir return pTab[nTab]->ColHidden(nCol, pFirstCol, pLastCol);
3657cdf0e10cSrcweir }
3658cdf0e10cSrcweir
SetRowHidden(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,bool bHidden)3659cdf0e10cSrcweir void ScDocument::SetRowHidden(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bHidden)
3660cdf0e10cSrcweir {
3661cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3662cdf0e10cSrcweir return;
3663cdf0e10cSrcweir
3664cdf0e10cSrcweir pTab[nTab]->SetRowHidden(nStartRow, nEndRow, bHidden);
3665cdf0e10cSrcweir }
3666cdf0e10cSrcweir
SetColHidden(SCCOL nStartCol,SCCOL nEndCol,SCTAB nTab,bool bHidden)3667cdf0e10cSrcweir void ScDocument::SetColHidden(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bHidden)
3668cdf0e10cSrcweir {
3669cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3670cdf0e10cSrcweir return;
3671cdf0e10cSrcweir
3672cdf0e10cSrcweir pTab[nTab]->SetColHidden(nStartCol, nEndCol, bHidden);
3673cdf0e10cSrcweir }
3674cdf0e10cSrcweir
FirstVisibleRow(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3675cdf0e10cSrcweir SCROW ScDocument::FirstVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3676cdf0e10cSrcweir {
3677cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3678cdf0e10cSrcweir return ::std::numeric_limits<SCROW>::max();;
3679cdf0e10cSrcweir
3680cdf0e10cSrcweir return pTab[nTab]->FirstVisibleRow(nStartRow, nEndRow);
3681cdf0e10cSrcweir }
3682cdf0e10cSrcweir
LastVisibleRow(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3683cdf0e10cSrcweir SCROW ScDocument::LastVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3684cdf0e10cSrcweir {
3685cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3686cdf0e10cSrcweir return ::std::numeric_limits<SCROW>::max();;
3687cdf0e10cSrcweir
3688cdf0e10cSrcweir return pTab[nTab]->LastVisibleRow(nStartRow, nEndRow);
3689cdf0e10cSrcweir }
3690cdf0e10cSrcweir
CountVisibleRows(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3691cdf0e10cSrcweir SCROW ScDocument::CountVisibleRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3692cdf0e10cSrcweir {
3693cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3694cdf0e10cSrcweir return 0;
3695cdf0e10cSrcweir
3696cdf0e10cSrcweir return pTab[nTab]->CountVisibleRows(nStartRow, nEndRow);
3697cdf0e10cSrcweir }
3698cdf0e10cSrcweir
RowFiltered(SCROW nRow,SCTAB nTab,SCROW * pFirstRow,SCROW * pLastRow)3699cdf0e10cSrcweir bool ScDocument::RowFiltered(SCROW nRow, SCTAB nTab, SCROW* pFirstRow, SCROW* pLastRow)
3700cdf0e10cSrcweir {
3701cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3702cdf0e10cSrcweir return false;
3703cdf0e10cSrcweir
3704cdf0e10cSrcweir return pTab[nTab]->RowFiltered(nRow, pFirstRow, pLastRow);
3705cdf0e10cSrcweir }
3706cdf0e10cSrcweir
HasFilteredRows(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3707cdf0e10cSrcweir bool ScDocument::HasFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3708cdf0e10cSrcweir {
3709cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3710cdf0e10cSrcweir return false;
3711cdf0e10cSrcweir
3712cdf0e10cSrcweir return pTab[nTab]->HasFilteredRows(nStartRow, nEndRow);
3713cdf0e10cSrcweir }
3714cdf0e10cSrcweir
ColFiltered(SCCOL nCol,SCTAB nTab,SCCOL * pFirstCol,SCCOL * pLastCol)3715cdf0e10cSrcweir bool ScDocument::ColFiltered(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol, SCCOL* pLastCol)
3716cdf0e10cSrcweir {
3717cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3718cdf0e10cSrcweir return false;
3719cdf0e10cSrcweir
3720cdf0e10cSrcweir return pTab[nTab]->ColFiltered(nCol, pFirstCol, pLastCol);
3721cdf0e10cSrcweir }
3722cdf0e10cSrcweir
SetRowFiltered(SCROW nStartRow,SCROW nEndRow,SCTAB nTab,bool bFiltered)3723cdf0e10cSrcweir void ScDocument::SetRowFiltered(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bFiltered)
3724cdf0e10cSrcweir {
3725cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3726cdf0e10cSrcweir return;
3727cdf0e10cSrcweir
3728cdf0e10cSrcweir pTab[nTab]->SetRowFiltered(nStartRow, nEndRow, bFiltered);
3729cdf0e10cSrcweir }
3730cdf0e10cSrcweir
SetColFiltered(SCCOL nStartCol,SCCOL nEndCol,SCTAB nTab,bool bFiltered)3731cdf0e10cSrcweir void ScDocument::SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bFiltered)
3732cdf0e10cSrcweir {
3733cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3734cdf0e10cSrcweir return;
3735cdf0e10cSrcweir
3736cdf0e10cSrcweir pTab[nTab]->SetColFiltered(nStartCol, nEndCol, bFiltered);
3737cdf0e10cSrcweir }
3738cdf0e10cSrcweir
FirstNonFilteredRow(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3739cdf0e10cSrcweir SCROW ScDocument::FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3740cdf0e10cSrcweir {
3741cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3742cdf0e10cSrcweir return ::std::numeric_limits<SCROW>::max();;
3743cdf0e10cSrcweir
3744cdf0e10cSrcweir return pTab[nTab]->FirstNonFilteredRow(nStartRow, nEndRow);
3745cdf0e10cSrcweir }
3746cdf0e10cSrcweir
LastNonFilteredRow(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3747cdf0e10cSrcweir SCROW ScDocument::LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3748cdf0e10cSrcweir {
3749cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3750cdf0e10cSrcweir return ::std::numeric_limits<SCROW>::max();;
3751cdf0e10cSrcweir
3752cdf0e10cSrcweir return pTab[nTab]->LastNonFilteredRow(nStartRow, nEndRow);
3753cdf0e10cSrcweir }
3754cdf0e10cSrcweir
CountNonFilteredRows(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)3755cdf0e10cSrcweir SCROW ScDocument::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab)
3756cdf0e10cSrcweir {
3757cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
3758cdf0e10cSrcweir return 0;
3759cdf0e10cSrcweir
3760cdf0e10cSrcweir return pTab[nTab]->CountNonFilteredRows(nStartRow, nEndRow);
3761cdf0e10cSrcweir }
3762cdf0e10cSrcweir
SyncColRowFlags()3763cdf0e10cSrcweir void ScDocument::SyncColRowFlags()
3764cdf0e10cSrcweir {
3765cdf0e10cSrcweir for (SCTAB i = 0; i <= nMaxTableNumber; ++i)
3766cdf0e10cSrcweir {
3767cdf0e10cSrcweir if (!ValidTab(i) || !pTab[i])
3768cdf0e10cSrcweir continue;
3769cdf0e10cSrcweir
3770cdf0e10cSrcweir pTab[i]->SyncColRowFlags();
3771cdf0e10cSrcweir }
3772cdf0e10cSrcweir }
3773cdf0e10cSrcweir
GetLastFlaggedRow(SCTAB nTab) const3774cdf0e10cSrcweir SCROW ScDocument::GetLastFlaggedRow( SCTAB nTab ) const
3775cdf0e10cSrcweir {
3776cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3777cdf0e10cSrcweir return pTab[nTab]->GetLastFlaggedRow();
3778cdf0e10cSrcweir return 0;
3779cdf0e10cSrcweir }
3780cdf0e10cSrcweir
3781cdf0e10cSrcweir
GetLastChangedCol(SCTAB nTab) const3782cdf0e10cSrcweir SCCOL ScDocument::GetLastChangedCol( SCTAB nTab ) const
3783cdf0e10cSrcweir {
3784cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3785cdf0e10cSrcweir return pTab[nTab]->GetLastChangedCol();
3786cdf0e10cSrcweir return 0;
3787cdf0e10cSrcweir }
3788cdf0e10cSrcweir
GetLastChangedRow(SCTAB nTab) const3789cdf0e10cSrcweir SCROW ScDocument::GetLastChangedRow( SCTAB nTab ) const
3790cdf0e10cSrcweir {
3791cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3792cdf0e10cSrcweir return pTab[nTab]->GetLastChangedRow();
3793cdf0e10cSrcweir return 0;
3794cdf0e10cSrcweir }
3795cdf0e10cSrcweir
3796cdf0e10cSrcweir
GetNextDifferentChangedCol(SCTAB nTab,SCCOL nStart) const3797cdf0e10cSrcweir SCCOL ScDocument::GetNextDifferentChangedCol( SCTAB nTab, SCCOL nStart) const
3798cdf0e10cSrcweir {
3799cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3800cdf0e10cSrcweir {
3801cdf0e10cSrcweir sal_uInt8 nStartFlags = pTab[nTab]->GetColFlags(nStart);
3802cdf0e10cSrcweir sal_uInt16 nStartWidth = pTab[nTab]->GetOriginalWidth(nStart);
3803cdf0e10cSrcweir for (SCCOL nCol = nStart + 1; nCol <= MAXCOL; nCol++)
3804cdf0e10cSrcweir {
3805cdf0e10cSrcweir if (((nStartFlags & CR_MANUALBREAK) != (pTab[nTab]->GetColFlags(nCol) & CR_MANUALBREAK)) ||
3806cdf0e10cSrcweir (nStartWidth != pTab[nTab]->GetOriginalWidth(nCol)) ||
3807cdf0e10cSrcweir ((nStartFlags & CR_HIDDEN) != (pTab[nTab]->GetColFlags(nCol) & CR_HIDDEN)) )
3808cdf0e10cSrcweir return nCol;
3809cdf0e10cSrcweir }
3810cdf0e10cSrcweir return MAXCOL+1;
3811cdf0e10cSrcweir }
3812cdf0e10cSrcweir return 0;
3813cdf0e10cSrcweir }
3814cdf0e10cSrcweir
GetNextDifferentChangedRow(SCTAB nTab,SCROW nStart,bool bCareManualSize) const3815cdf0e10cSrcweir SCROW ScDocument::GetNextDifferentChangedRow( SCTAB nTab, SCROW nStart, bool bCareManualSize) const
3816cdf0e10cSrcweir {
3817cdf0e10cSrcweir const ScBitMaskCompressedArray< SCROW, sal_uInt8> * pRowFlagsArray;
3818cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] && ((pRowFlagsArray = pTab[nTab]->GetRowFlagsArray()) != NULL) &&
3819cdf0e10cSrcweir pTab[nTab]->mpRowHeights && pTab[nTab]->mpHiddenRows )
3820cdf0e10cSrcweir {
3821cdf0e10cSrcweir size_t nIndex; // ignored
3822cdf0e10cSrcweir SCROW nFlagsEndRow;
3823cdf0e10cSrcweir SCROW nHiddenEndRow;
3824cdf0e10cSrcweir SCROW nHeightEndRow;
3825cdf0e10cSrcweir sal_uInt8 nFlags;
3826cdf0e10cSrcweir bool bHidden;
3827cdf0e10cSrcweir sal_uInt16 nHeight;
3828cdf0e10cSrcweir sal_uInt8 nStartFlags = nFlags = pRowFlagsArray->GetValue( nStart, nIndex, nFlagsEndRow);
3829cdf0e10cSrcweir bool bStartHidden = bHidden = pTab[nTab]->RowHidden( nStart, NULL, &nHiddenEndRow);
3830cdf0e10cSrcweir sal_uInt16 nStartHeight = nHeight = pTab[nTab]->GetRowHeight( nStart, NULL, &nHeightEndRow, false);
3831cdf0e10cSrcweir SCROW nRow;
3832cdf0e10cSrcweir while ((nRow = std::min( nHiddenEndRow, std::min( nFlagsEndRow, nHeightEndRow)) + 1) <= MAXROW)
3833cdf0e10cSrcweir {
3834cdf0e10cSrcweir if (nFlagsEndRow < nRow)
3835cdf0e10cSrcweir nFlags = pRowFlagsArray->GetValue( nRow, nIndex, nFlagsEndRow);
3836cdf0e10cSrcweir if (nHiddenEndRow < nRow)
3837cdf0e10cSrcweir bHidden = pTab[nTab]->RowHidden( nRow, NULL, &nHiddenEndRow);
3838cdf0e10cSrcweir if (nHeightEndRow < nRow)
3839cdf0e10cSrcweir nHeight = pTab[nTab]->GetRowHeight( nRow, NULL, &nHeightEndRow, false);
3840cdf0e10cSrcweir if ( ((nStartFlags & CR_MANUALBREAK) != (nFlags & CR_MANUALBREAK)) ||
3841cdf0e10cSrcweir ((nStartFlags & CR_MANUALSIZE) != (nFlags & CR_MANUALSIZE)) ||
3842cdf0e10cSrcweir (bStartHidden != bHidden) ||
3843cdf0e10cSrcweir (bCareManualSize && (nStartFlags & CR_MANUALSIZE) && (nStartHeight != nHeight)) ||
3844cdf0e10cSrcweir (!bCareManualSize && ((nStartHeight != nHeight))))
3845cdf0e10cSrcweir return nRow;
3846cdf0e10cSrcweir }
3847cdf0e10cSrcweir return MAXROW+1;
3848cdf0e10cSrcweir }
3849cdf0e10cSrcweir return 0;
3850cdf0e10cSrcweir }
3851cdf0e10cSrcweir
GetColDefault(SCTAB nTab,SCCOL nCol,SCROW nLastRow,SCROW & nDefault)3852cdf0e10cSrcweir sal_Bool ScDocument::GetColDefault( SCTAB nTab, SCCOL nCol, SCROW nLastRow, SCROW& nDefault)
3853cdf0e10cSrcweir {
3854cdf0e10cSrcweir sal_Bool bRet(sal_False);
3855cdf0e10cSrcweir nDefault = 0;
3856cdf0e10cSrcweir ScDocAttrIterator aDocAttrItr(this, nTab, nCol, 0, nCol, nLastRow);
3857cdf0e10cSrcweir SCCOL nColumn;
3858cdf0e10cSrcweir SCROW nStartRow;
3859cdf0e10cSrcweir SCROW nEndRow;
3860cdf0e10cSrcweir const ScPatternAttr* pAttr = aDocAttrItr.GetNext(nColumn, nStartRow, nEndRow);
3861cdf0e10cSrcweir if (nEndRow < nLastRow)
3862cdf0e10cSrcweir {
3863cdf0e10cSrcweir ScDefaultAttrSet aSet;
3864cdf0e10cSrcweir ScDefaultAttrSet::iterator aItr = aSet.end();
3865cdf0e10cSrcweir while (pAttr)
3866cdf0e10cSrcweir {
3867cdf0e10cSrcweir ScDefaultAttr aAttr(pAttr);
3868cdf0e10cSrcweir aItr = aSet.find(aAttr);
3869cdf0e10cSrcweir if (aItr == aSet.end())
3870cdf0e10cSrcweir {
3871cdf0e10cSrcweir aAttr.nCount = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
3872cdf0e10cSrcweir aAttr.nFirst = nStartRow;
3873cdf0e10cSrcweir aSet.insert(aAttr);
3874cdf0e10cSrcweir }
3875cdf0e10cSrcweir else
3876cdf0e10cSrcweir {
3877cdf0e10cSrcweir aAttr.nCount = aItr->nCount + static_cast<SCSIZE>(nEndRow - nStartRow + 1);
3878cdf0e10cSrcweir aAttr.nFirst = aItr->nFirst;
3879cdf0e10cSrcweir aSet.erase(aItr);
3880cdf0e10cSrcweir aSet.insert(aAttr);
3881cdf0e10cSrcweir }
3882cdf0e10cSrcweir pAttr = aDocAttrItr.GetNext(nColumn, nStartRow, nEndRow);
3883cdf0e10cSrcweir }
3884cdf0e10cSrcweir ScDefaultAttrSet::iterator aDefaultItr = aSet.begin();
3885cdf0e10cSrcweir aItr = aDefaultItr;
3886cdf0e10cSrcweir aItr++;
3887cdf0e10cSrcweir while (aItr != aSet.end())
3888cdf0e10cSrcweir {
3889cdf0e10cSrcweir // for entries with equal count, use the one with the lowest start row,
3890cdf0e10cSrcweir // don't use the random order of pointer comparisons
3891cdf0e10cSrcweir if ( aItr->nCount > aDefaultItr->nCount ||
3892cdf0e10cSrcweir ( aItr->nCount == aDefaultItr->nCount && aItr->nFirst < aDefaultItr->nFirst ) )
3893cdf0e10cSrcweir aDefaultItr = aItr;
3894cdf0e10cSrcweir aItr++;
3895cdf0e10cSrcweir }
3896cdf0e10cSrcweir nDefault = aDefaultItr->nFirst;
3897cdf0e10cSrcweir bRet = sal_True;
3898cdf0e10cSrcweir }
3899cdf0e10cSrcweir else
3900cdf0e10cSrcweir bRet = sal_True;
3901cdf0e10cSrcweir return bRet;
3902cdf0e10cSrcweir }
3903cdf0e10cSrcweir
GetRowDefault(SCTAB,SCROW,SCCOL,SCCOL &)3904cdf0e10cSrcweir sal_Bool ScDocument::GetRowDefault( SCTAB /* nTab */, SCROW /* nRow */, SCCOL /* nLastCol */, SCCOL& /* nDefault */ )
3905cdf0e10cSrcweir {
3906cdf0e10cSrcweir sal_Bool bRet(sal_False);
3907cdf0e10cSrcweir return bRet;
3908cdf0e10cSrcweir }
3909cdf0e10cSrcweir
StripHidden(SCCOL & rX1,SCROW & rY1,SCCOL & rX2,SCROW & rY2,SCTAB nTab)3910cdf0e10cSrcweir void ScDocument::StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab )
3911cdf0e10cSrcweir {
3912cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3913cdf0e10cSrcweir pTab[nTab]->StripHidden( rX1, rY1, rX2, rY2 );
3914cdf0e10cSrcweir }
3915cdf0e10cSrcweir
3916cdf0e10cSrcweir
ExtendHidden(SCCOL & rX1,SCROW & rY1,SCCOL & rX2,SCROW & rY2,SCTAB nTab)3917cdf0e10cSrcweir void ScDocument::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab )
3918cdf0e10cSrcweir {
3919cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3920cdf0e10cSrcweir pTab[nTab]->ExtendHidden( rX1, rY1, rX2, rY2 );
3921cdf0e10cSrcweir }
3922cdf0e10cSrcweir
3923cdf0e10cSrcweir //
3924cdf0e10cSrcweir // Attribute ----------------------------------------------------------
3925cdf0e10cSrcweir //
3926cdf0e10cSrcweir
GetAttr(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_uInt16 nWhich) const3927cdf0e10cSrcweir const SfxPoolItem* ScDocument::GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const
3928cdf0e10cSrcweir {
3929cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3930cdf0e10cSrcweir {
3931cdf0e10cSrcweir const SfxPoolItem* pTemp = pTab[nTab]->GetAttr( nCol, nRow, nWhich );
3932cdf0e10cSrcweir if (pTemp)
3933cdf0e10cSrcweir return pTemp;
3934cdf0e10cSrcweir else
3935cdf0e10cSrcweir {
3936cdf0e10cSrcweir DBG_ERROR( "Attribut Null" );
3937cdf0e10cSrcweir }
3938cdf0e10cSrcweir }
3939cdf0e10cSrcweir return &xPoolHelper->GetDocPool()->GetDefaultItem( nWhich );
3940cdf0e10cSrcweir }
3941cdf0e10cSrcweir
3942cdf0e10cSrcweir
GetPattern(SCCOL nCol,SCROW nRow,SCTAB nTab) const3943cdf0e10cSrcweir const ScPatternAttr* ScDocument::GetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
3944cdf0e10cSrcweir {
3945cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3946cdf0e10cSrcweir return pTab[nTab]->GetPattern( nCol, nRow );
3947cdf0e10cSrcweir return NULL;
3948cdf0e10cSrcweir }
3949cdf0e10cSrcweir
3950cdf0e10cSrcweir
GetMostUsedPattern(SCCOL nCol,SCROW nStartRow,SCROW nEndRow,SCTAB nTab) const3951cdf0e10cSrcweir const ScPatternAttr* ScDocument::GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) const
3952cdf0e10cSrcweir {
3953cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3954cdf0e10cSrcweir return pTab[nTab]->GetMostUsedPattern( nCol, nStartRow, nEndRow );
3955cdf0e10cSrcweir return NULL;
3956cdf0e10cSrcweir }
3957cdf0e10cSrcweir
3958cdf0e10cSrcweir
ApplyAttr(SCCOL nCol,SCROW nRow,SCTAB nTab,const SfxPoolItem & rAttr)3959cdf0e10cSrcweir void ScDocument::ApplyAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, const SfxPoolItem& rAttr )
3960cdf0e10cSrcweir {
3961cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3962cdf0e10cSrcweir pTab[nTab]->ApplyAttr( nCol, nRow, rAttr );
3963cdf0e10cSrcweir }
3964cdf0e10cSrcweir
3965cdf0e10cSrcweir
ApplyPattern(SCCOL nCol,SCROW nRow,SCTAB nTab,const ScPatternAttr & rAttr)3966cdf0e10cSrcweir void ScDocument::ApplyPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr )
3967cdf0e10cSrcweir {
3968cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
3969cdf0e10cSrcweir pTab[nTab]->ApplyPattern( nCol, nRow, rAttr );
3970cdf0e10cSrcweir }
3971cdf0e10cSrcweir
3972cdf0e10cSrcweir
ApplyPatternArea(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,const ScMarkData & rMark,const ScPatternAttr & rAttr)3973cdf0e10cSrcweir void ScDocument::ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow,
3974cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow,
3975cdf0e10cSrcweir const ScMarkData& rMark,
3976cdf0e10cSrcweir const ScPatternAttr& rAttr )
3977cdf0e10cSrcweir {
3978cdf0e10cSrcweir for (SCTAB i=0; i <= MAXTAB; i++)
3979cdf0e10cSrcweir if (pTab[i])
3980cdf0e10cSrcweir if (rMark.GetTableSelect(i))
3981cdf0e10cSrcweir pTab[i]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr );
3982cdf0e10cSrcweir }
3983cdf0e10cSrcweir
3984cdf0e10cSrcweir
ApplyPatternAreaTab(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab,const ScPatternAttr & rAttr)3985cdf0e10cSrcweir void ScDocument::ApplyPatternAreaTab( SCCOL nStartCol, SCROW nStartRow,
3986cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScPatternAttr& rAttr )
3987cdf0e10cSrcweir {
3988cdf0e10cSrcweir if (VALIDTAB(nTab))
3989cdf0e10cSrcweir if (pTab[nTab])
3990cdf0e10cSrcweir pTab[nTab]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr );
3991cdf0e10cSrcweir }
3992cdf0e10cSrcweir
ApplyPooledPatternAreaTab(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab,const ScPatternAttr & rPooledAttr,const ScPatternAttr & rAttr)39933a02adb1SWang Lei void ScDocument::ApplyPooledPatternAreaTab( SCCOL nStartCol, SCROW nStartRow,
39943a02adb1SWang Lei SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScPatternAttr& rPooledAttr, const ScPatternAttr& rAttr )
39953a02adb1SWang Lei {
39963a02adb1SWang Lei if (VALIDTAB(nTab))
39973a02adb1SWang Lei if (pTab[nTab])
39983a02adb1SWang Lei pTab[nTab]->ApplyPooledPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rPooledAttr, rAttr );
39993a02adb1SWang Lei }
40003a02adb1SWang Lei
ApplyPatternIfNumberformatIncompatible(const ScRange & rRange,const ScMarkData & rMark,const ScPatternAttr & rPattern,short nNewType)4001cdf0e10cSrcweir void ScDocument::ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
4002cdf0e10cSrcweir const ScMarkData& rMark, const ScPatternAttr& rPattern, short nNewType )
4003cdf0e10cSrcweir {
4004cdf0e10cSrcweir for (SCTAB i=0; i <= MAXTAB; i++)
4005cdf0e10cSrcweir if (pTab[i])
4006cdf0e10cSrcweir if (rMark.GetTableSelect(i))
4007cdf0e10cSrcweir pTab[i]->ApplyPatternIfNumberformatIncompatible( rRange, rPattern, nNewType );
4008cdf0e10cSrcweir }
4009cdf0e10cSrcweir
4010cdf0e10cSrcweir
ApplyStyle(SCCOL nCol,SCROW nRow,SCTAB nTab,const ScStyleSheet & rStyle)4011cdf0e10cSrcweir void ScDocument::ApplyStyle( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScStyleSheet& rStyle)
4012cdf0e10cSrcweir {
4013cdf0e10cSrcweir if (VALIDTAB(nTab))
4014cdf0e10cSrcweir if (pTab[nTab])
4015cdf0e10cSrcweir pTab[nTab]->ApplyStyle( nCol, nRow, rStyle );
4016cdf0e10cSrcweir }
4017cdf0e10cSrcweir
4018cdf0e10cSrcweir
ApplyStyleArea(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,const ScMarkData & rMark,const ScStyleSheet & rStyle)4019cdf0e10cSrcweir void ScDocument::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow,
4020cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow,
4021cdf0e10cSrcweir const ScMarkData& rMark,
4022cdf0e10cSrcweir const ScStyleSheet& rStyle)
4023cdf0e10cSrcweir {
4024cdf0e10cSrcweir for (SCTAB i=0; i <= MAXTAB; i++)
4025cdf0e10cSrcweir if (pTab[i])
4026cdf0e10cSrcweir if (rMark.GetTableSelect(i))
4027cdf0e10cSrcweir pTab[i]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle );
4028cdf0e10cSrcweir }
4029cdf0e10cSrcweir
4030cdf0e10cSrcweir
ApplyStyleAreaTab(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab,const ScStyleSheet & rStyle)4031cdf0e10cSrcweir void ScDocument::ApplyStyleAreaTab( SCCOL nStartCol, SCROW nStartRow,
4032cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScStyleSheet& rStyle)
4033cdf0e10cSrcweir {
4034cdf0e10cSrcweir if (VALIDTAB(nTab))
4035cdf0e10cSrcweir if (pTab[nTab])
4036cdf0e10cSrcweir pTab[nTab]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle );
4037cdf0e10cSrcweir }
4038cdf0e10cSrcweir
4039cdf0e10cSrcweir
ApplySelectionStyle(const ScStyleSheet & rStyle,const ScMarkData & rMark)4040cdf0e10cSrcweir void ScDocument::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark)
4041cdf0e10cSrcweir {
4042cdf0e10cSrcweir // ApplySelectionStyle needs multi mark
4043cdf0e10cSrcweir if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
4044cdf0e10cSrcweir {
4045cdf0e10cSrcweir ScRange aRange;
4046cdf0e10cSrcweir rMark.GetMarkArea( aRange );
4047cdf0e10cSrcweir ApplyStyleArea( aRange.aStart.Col(), aRange.aStart.Row(),
4048cdf0e10cSrcweir aRange.aEnd.Col(), aRange.aEnd.Row(), rMark, rStyle );
4049cdf0e10cSrcweir }
4050cdf0e10cSrcweir else
4051cdf0e10cSrcweir {
4052cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4053cdf0e10cSrcweir if ( pTab[i] && rMark.GetTableSelect(i) )
4054cdf0e10cSrcweir pTab[i]->ApplySelectionStyle( rStyle, rMark );
4055cdf0e10cSrcweir }
4056cdf0e10cSrcweir }
4057cdf0e10cSrcweir
4058cdf0e10cSrcweir
ApplySelectionLineStyle(const ScMarkData & rMark,const SvxBorderLine * pLine,sal_Bool bColorOnly)4059cdf0e10cSrcweir void ScDocument::ApplySelectionLineStyle( const ScMarkData& rMark,
4060cdf0e10cSrcweir const SvxBorderLine* pLine, sal_Bool bColorOnly )
4061cdf0e10cSrcweir {
4062cdf0e10cSrcweir if ( bColorOnly && !pLine )
4063cdf0e10cSrcweir return;
4064cdf0e10cSrcweir
4065cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4066cdf0e10cSrcweir if (pTab[i])
4067cdf0e10cSrcweir if (rMark.GetTableSelect(i))
4068cdf0e10cSrcweir pTab[i]->ApplySelectionLineStyle( rMark, pLine, bColorOnly );
4069cdf0e10cSrcweir }
4070cdf0e10cSrcweir
4071cdf0e10cSrcweir
GetStyle(SCCOL nCol,SCROW nRow,SCTAB nTab) const4072cdf0e10cSrcweir const ScStyleSheet* ScDocument::GetStyle( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4073cdf0e10cSrcweir {
4074cdf0e10cSrcweir if ( VALIDTAB(nTab) && pTab[nTab] )
4075cdf0e10cSrcweir return pTab[nTab]->GetStyle(nCol, nRow);
4076cdf0e10cSrcweir else
4077cdf0e10cSrcweir return NULL;
4078cdf0e10cSrcweir }
4079cdf0e10cSrcweir
4080cdf0e10cSrcweir
GetSelectionStyle(const ScMarkData & rMark) const4081cdf0e10cSrcweir const ScStyleSheet* ScDocument::GetSelectionStyle( const ScMarkData& rMark ) const
4082cdf0e10cSrcweir {
4083cdf0e10cSrcweir sal_Bool bEqual = sal_True;
4084cdf0e10cSrcweir sal_Bool bFound;
4085cdf0e10cSrcweir
4086cdf0e10cSrcweir const ScStyleSheet* pStyle = NULL;
4087cdf0e10cSrcweir const ScStyleSheet* pNewStyle;
4088cdf0e10cSrcweir
4089cdf0e10cSrcweir if ( rMark.IsMultiMarked() )
4090cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB && bEqual; i++)
4091cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4092cdf0e10cSrcweir {
4093cdf0e10cSrcweir pNewStyle = pTab[i]->GetSelectionStyle( rMark, bFound );
4094cdf0e10cSrcweir if (bFound)
4095cdf0e10cSrcweir {
4096cdf0e10cSrcweir if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
4097cdf0e10cSrcweir bEqual = sal_False; // unterschiedliche
4098cdf0e10cSrcweir pStyle = pNewStyle;
4099cdf0e10cSrcweir }
4100cdf0e10cSrcweir }
4101cdf0e10cSrcweir if ( rMark.IsMarked() )
4102cdf0e10cSrcweir {
4103cdf0e10cSrcweir ScRange aRange;
4104cdf0e10cSrcweir rMark.GetMarkArea( aRange );
4105cdf0e10cSrcweir for (SCTAB i=aRange.aStart.Tab(); i<=aRange.aEnd.Tab() && bEqual; i++)
4106cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4107cdf0e10cSrcweir {
4108cdf0e10cSrcweir pNewStyle = pTab[i]->GetAreaStyle( bFound,
4109cdf0e10cSrcweir aRange.aStart.Col(), aRange.aStart.Row(),
4110cdf0e10cSrcweir aRange.aEnd.Col(), aRange.aEnd.Row() );
4111cdf0e10cSrcweir if (bFound)
4112cdf0e10cSrcweir {
4113cdf0e10cSrcweir if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
4114cdf0e10cSrcweir bEqual = sal_False; // unterschiedliche
4115cdf0e10cSrcweir pStyle = pNewStyle;
4116cdf0e10cSrcweir }
4117cdf0e10cSrcweir }
4118cdf0e10cSrcweir }
4119cdf0e10cSrcweir
4120cdf0e10cSrcweir return bEqual ? pStyle : NULL;
4121cdf0e10cSrcweir }
4122cdf0e10cSrcweir
4123cdf0e10cSrcweir
StyleSheetChanged(const SfxStyleSheetBase * pStyleSheet,sal_Bool bRemoved,OutputDevice * pDev,double nPPTX,double nPPTY,const Fraction & rZoomX,const Fraction & rZoomY)4124cdf0e10cSrcweir void ScDocument::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, sal_Bool bRemoved,
4125cdf0e10cSrcweir OutputDevice* pDev,
4126cdf0e10cSrcweir double nPPTX, double nPPTY,
4127cdf0e10cSrcweir const Fraction& rZoomX, const Fraction& rZoomY )
4128cdf0e10cSrcweir {
4129cdf0e10cSrcweir for (SCTAB i=0; i <= MAXTAB; i++)
4130cdf0e10cSrcweir if (pTab[i])
4131cdf0e10cSrcweir pTab[i]->StyleSheetChanged
4132cdf0e10cSrcweir ( pStyleSheet, bRemoved, pDev, nPPTX, nPPTY, rZoomX, rZoomY );
4133cdf0e10cSrcweir
4134cdf0e10cSrcweir if ( pStyleSheet && pStyleSheet->GetName() == ScGlobal::GetRscString(STR_STYLENAME_STANDARD) )
4135cdf0e10cSrcweir {
4136cdf0e10cSrcweir // update attributes for all note objects
4137cdf0e10cSrcweir ScDetectiveFunc::UpdateAllComments( *this );
4138cdf0e10cSrcweir }
4139cdf0e10cSrcweir }
4140cdf0e10cSrcweir
4141cdf0e10cSrcweir
IsStyleSheetUsed(const ScStyleSheet & rStyle,sal_Bool bGatherAllStyles) const4142cdf0e10cSrcweir sal_Bool ScDocument::IsStyleSheetUsed( const ScStyleSheet& rStyle, sal_Bool bGatherAllStyles ) const
4143cdf0e10cSrcweir {
4144cdf0e10cSrcweir if ( bStyleSheetUsageInvalid || rStyle.GetUsage() == ScStyleSheet::UNKNOWN )
4145cdf0e10cSrcweir {
4146cdf0e10cSrcweir if ( bGatherAllStyles )
4147cdf0e10cSrcweir {
4148cdf0e10cSrcweir SfxStyleSheetIterator aIter( xPoolHelper->GetStylePool(),
4149cdf0e10cSrcweir SFX_STYLE_FAMILY_PARA );
4150cdf0e10cSrcweir for ( const SfxStyleSheetBase* pStyle = aIter.First(); pStyle;
4151cdf0e10cSrcweir pStyle = aIter.Next() )
4152cdf0e10cSrcweir {
4153cdf0e10cSrcweir const ScStyleSheet* pScStyle = PTR_CAST( ScStyleSheet, pStyle );
4154cdf0e10cSrcweir if ( pScStyle )
4155cdf0e10cSrcweir pScStyle->SetUsage( ScStyleSheet::NOTUSED );
4156cdf0e10cSrcweir }
4157cdf0e10cSrcweir }
4158cdf0e10cSrcweir
4159cdf0e10cSrcweir sal_Bool bIsUsed = sal_False;
4160cdf0e10cSrcweir
4161cdf0e10cSrcweir for ( SCTAB i=0; i<=MAXTAB; i++ )
4162cdf0e10cSrcweir {
4163cdf0e10cSrcweir if ( pTab[i] )
4164cdf0e10cSrcweir {
4165cdf0e10cSrcweir if ( pTab[i]->IsStyleSheetUsed( rStyle, bGatherAllStyles ) )
4166cdf0e10cSrcweir {
4167cdf0e10cSrcweir if ( !bGatherAllStyles )
4168cdf0e10cSrcweir return sal_True;
4169cdf0e10cSrcweir bIsUsed = sal_True;
4170cdf0e10cSrcweir }
4171cdf0e10cSrcweir }
4172cdf0e10cSrcweir }
4173cdf0e10cSrcweir
4174cdf0e10cSrcweir if ( bGatherAllStyles )
4175cdf0e10cSrcweir bStyleSheetUsageInvalid = sal_False;
4176cdf0e10cSrcweir
4177cdf0e10cSrcweir return bIsUsed;
4178cdf0e10cSrcweir }
4179cdf0e10cSrcweir
4180cdf0e10cSrcweir return rStyle.GetUsage() == ScStyleSheet::USED;
4181cdf0e10cSrcweir }
4182cdf0e10cSrcweir
4183cdf0e10cSrcweir
ApplyFlagsTab(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab,sal_Int16 nFlags)4184cdf0e10cSrcweir sal_Bool ScDocument::ApplyFlagsTab( SCCOL nStartCol, SCROW nStartRow,
4185cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, sal_Int16 nFlags )
4186cdf0e10cSrcweir {
4187cdf0e10cSrcweir if (VALIDTAB(nTab))
4188cdf0e10cSrcweir if (pTab[nTab])
4189cdf0e10cSrcweir return pTab[nTab]->ApplyFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags );
4190cdf0e10cSrcweir
4191cdf0e10cSrcweir DBG_ERROR("ApplyFlags: falsche Tabelle");
4192cdf0e10cSrcweir return sal_False;
4193cdf0e10cSrcweir }
4194cdf0e10cSrcweir
4195cdf0e10cSrcweir
RemoveFlagsTab(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab,sal_Int16 nFlags)4196cdf0e10cSrcweir sal_Bool ScDocument::RemoveFlagsTab( SCCOL nStartCol, SCROW nStartRow,
4197cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, sal_Int16 nFlags )
4198cdf0e10cSrcweir {
4199cdf0e10cSrcweir if (VALIDTAB(nTab))
4200cdf0e10cSrcweir if (pTab[nTab])
4201cdf0e10cSrcweir return pTab[nTab]->RemoveFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags );
4202cdf0e10cSrcweir
4203cdf0e10cSrcweir DBG_ERROR("RemoveFlags: falsche Tabelle");
4204cdf0e10cSrcweir return sal_False;
4205cdf0e10cSrcweir }
4206cdf0e10cSrcweir
4207cdf0e10cSrcweir
SetPattern(SCCOL nCol,SCROW nRow,SCTAB nTab,const ScPatternAttr & rAttr,sal_Bool bPutToPool)4208cdf0e10cSrcweir void ScDocument::SetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr,
4209cdf0e10cSrcweir sal_Bool bPutToPool )
4210cdf0e10cSrcweir {
4211cdf0e10cSrcweir if (VALIDTAB(nTab))
4212cdf0e10cSrcweir if (pTab[nTab])
4213cdf0e10cSrcweir pTab[nTab]->SetPattern( nCol, nRow, rAttr, bPutToPool );
4214cdf0e10cSrcweir }
4215cdf0e10cSrcweir
4216cdf0e10cSrcweir
SetPattern(const ScAddress & rPos,const ScPatternAttr & rAttr,sal_Bool bPutToPool)4217cdf0e10cSrcweir void ScDocument::SetPattern( const ScAddress& rPos, const ScPatternAttr& rAttr,
4218cdf0e10cSrcweir sal_Bool bPutToPool )
4219cdf0e10cSrcweir {
4220cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
4221cdf0e10cSrcweir if (pTab[nTab])
4222cdf0e10cSrcweir pTab[nTab]->SetPattern( rPos, rAttr, bPutToPool );
4223cdf0e10cSrcweir }
4224cdf0e10cSrcweir
4225cdf0e10cSrcweir
CreateSelectionPattern(const ScMarkData & rMark,sal_Bool bDeep)4226cdf0e10cSrcweir ScPatternAttr* ScDocument::CreateSelectionPattern( const ScMarkData& rMark, sal_Bool bDeep )
4227cdf0e10cSrcweir {
4228cdf0e10cSrcweir ScMergePatternState aState;
4229cdf0e10cSrcweir
4230cdf0e10cSrcweir if ( rMark.IsMultiMarked() ) // multi selection
4231cdf0e10cSrcweir {
4232cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4233cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4234cdf0e10cSrcweir pTab[i]->MergeSelectionPattern( aState, rMark, bDeep );
4235cdf0e10cSrcweir }
4236cdf0e10cSrcweir if ( rMark.IsMarked() ) // simle selection
4237cdf0e10cSrcweir {
4238cdf0e10cSrcweir ScRange aRange;
4239cdf0e10cSrcweir rMark.GetMarkArea(aRange);
4240cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4241cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4242cdf0e10cSrcweir pTab[i]->MergePatternArea( aState,
4243cdf0e10cSrcweir aRange.aStart.Col(), aRange.aStart.Row(),
4244cdf0e10cSrcweir aRange.aEnd.Col(), aRange.aEnd.Row(), bDeep );
4245cdf0e10cSrcweir }
4246cdf0e10cSrcweir
4247cdf0e10cSrcweir DBG_ASSERT( aState.pItemSet, "SelectionPattern Null" );
4248cdf0e10cSrcweir if (aState.pItemSet)
4249cdf0e10cSrcweir return new ScPatternAttr( aState.pItemSet );
4250cdf0e10cSrcweir else
4251cdf0e10cSrcweir return new ScPatternAttr( GetPool() ); // empty
4252cdf0e10cSrcweir }
4253cdf0e10cSrcweir
4254cdf0e10cSrcweir
GetSelectionPattern(const ScMarkData & rMark,sal_Bool bDeep)4255cdf0e10cSrcweir const ScPatternAttr* ScDocument::GetSelectionPattern( const ScMarkData& rMark, sal_Bool bDeep )
4256cdf0e10cSrcweir {
4257cdf0e10cSrcweir delete pSelectionAttr;
4258cdf0e10cSrcweir pSelectionAttr = CreateSelectionPattern( rMark, bDeep );
4259cdf0e10cSrcweir return pSelectionAttr;
4260cdf0e10cSrcweir }
4261cdf0e10cSrcweir
4262cdf0e10cSrcweir
GetSelectionFrame(const ScMarkData & rMark,SvxBoxItem & rLineOuter,SvxBoxInfoItem & rLineInner)4263cdf0e10cSrcweir void ScDocument::GetSelectionFrame( const ScMarkData& rMark,
4264cdf0e10cSrcweir SvxBoxItem& rLineOuter,
4265cdf0e10cSrcweir SvxBoxInfoItem& rLineInner )
4266cdf0e10cSrcweir {
4267cdf0e10cSrcweir rLineOuter.SetLine(NULL, BOX_LINE_TOP);
4268cdf0e10cSrcweir rLineOuter.SetLine(NULL, BOX_LINE_BOTTOM);
4269cdf0e10cSrcweir rLineOuter.SetLine(NULL, BOX_LINE_LEFT);
4270cdf0e10cSrcweir rLineOuter.SetLine(NULL, BOX_LINE_RIGHT);
4271cdf0e10cSrcweir rLineOuter.SetDistance(0);
4272cdf0e10cSrcweir
4273cdf0e10cSrcweir rLineInner.SetLine(NULL, BOXINFO_LINE_HORI);
4274cdf0e10cSrcweir rLineInner.SetLine(NULL, BOXINFO_LINE_VERT);
4275cdf0e10cSrcweir rLineInner.SetTable(sal_True);
4276cdf0e10cSrcweir rLineInner.SetDist(sal_True);
4277cdf0e10cSrcweir rLineInner.SetMinDist(sal_False);
4278cdf0e10cSrcweir
4279cdf0e10cSrcweir ScLineFlags aFlags;
4280cdf0e10cSrcweir
4281cdf0e10cSrcweir if (rMark.IsMarked())
4282cdf0e10cSrcweir {
4283cdf0e10cSrcweir ScRange aRange;
4284cdf0e10cSrcweir rMark.GetMarkArea(aRange);
4285cdf0e10cSrcweir rLineInner.EnableHor( aRange.aStart.Row() != aRange.aEnd.Row() );
4286cdf0e10cSrcweir rLineInner.EnableVer( aRange.aStart.Col() != aRange.aEnd.Col() );
4287cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4288cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4289cdf0e10cSrcweir pTab[i]->MergeBlockFrame( &rLineOuter, &rLineInner, aFlags,
4290cdf0e10cSrcweir aRange.aStart.Col(), aRange.aStart.Row(),
4291cdf0e10cSrcweir aRange.aEnd.Col(), aRange.aEnd.Row() );
4292cdf0e10cSrcweir }
4293cdf0e10cSrcweir
4294cdf0e10cSrcweir // Don't care Status auswerten
4295cdf0e10cSrcweir
4296cdf0e10cSrcweir rLineInner.SetValid( VALID_LEFT, ( aFlags.nLeft != SC_LINE_DONTCARE ) );
4297cdf0e10cSrcweir rLineInner.SetValid( VALID_RIGHT, ( aFlags.nRight != SC_LINE_DONTCARE ) );
4298cdf0e10cSrcweir rLineInner.SetValid( VALID_TOP, ( aFlags.nTop != SC_LINE_DONTCARE ) );
4299cdf0e10cSrcweir rLineInner.SetValid( VALID_BOTTOM, ( aFlags.nBottom != SC_LINE_DONTCARE ) );
4300cdf0e10cSrcweir rLineInner.SetValid( VALID_HORI, ( aFlags.nHori != SC_LINE_DONTCARE ) );
4301cdf0e10cSrcweir rLineInner.SetValid( VALID_VERT, ( aFlags.nVert != SC_LINE_DONTCARE ) );
4302cdf0e10cSrcweir }
4303cdf0e10cSrcweir
4304cdf0e10cSrcweir
HasAttrib(SCCOL nCol1,SCROW nRow1,SCTAB nTab1,SCCOL nCol2,SCROW nRow2,SCTAB nTab2,sal_uInt16 nMask)4305cdf0e10cSrcweir bool ScDocument::HasAttrib( SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
4306cdf0e10cSrcweir SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt16 nMask )
4307cdf0e10cSrcweir {
4308cdf0e10cSrcweir if ( nMask & HASATTR_ROTATE )
4309cdf0e10cSrcweir {
4310cdf0e10cSrcweir // Attribut im Dokument ueberhaupt verwendet?
4311cdf0e10cSrcweir // (wie in fillinfo)
4312cdf0e10cSrcweir
4313cdf0e10cSrcweir ScDocumentPool* pPool = xPoolHelper->GetDocPool();
4314cdf0e10cSrcweir
4315cdf0e10cSrcweir sal_Bool bAnyItem = sal_False;
4316cdf0e10cSrcweir sal_uInt32 nRotCount = pPool->GetItemCount2( ATTR_ROTATE_VALUE );
4317cdf0e10cSrcweir for (sal_uInt32 nItem=0; nItem<nRotCount; nItem++)
4318cdf0e10cSrcweir {
4319cdf0e10cSrcweir const SfxPoolItem* pItem = pPool->GetItem2( ATTR_ROTATE_VALUE, nItem );
4320cdf0e10cSrcweir if ( pItem )
4321cdf0e10cSrcweir {
4322cdf0e10cSrcweir // 90 or 270 degrees is former SvxOrientationItem - only look for other values
4323cdf0e10cSrcweir // (see ScPatternAttr::GetCellOrientation)
4324cdf0e10cSrcweir sal_Int32 nAngle = static_cast<const SfxInt32Item*>(pItem)->GetValue();
4325cdf0e10cSrcweir if ( nAngle != 0 && nAngle != 9000 && nAngle != 27000 )
4326cdf0e10cSrcweir {
4327cdf0e10cSrcweir bAnyItem = sal_True;
4328cdf0e10cSrcweir break;
4329cdf0e10cSrcweir }
4330cdf0e10cSrcweir }
4331cdf0e10cSrcweir }
4332cdf0e10cSrcweir if (!bAnyItem)
4333cdf0e10cSrcweir nMask &= ~HASATTR_ROTATE;
4334cdf0e10cSrcweir }
4335cdf0e10cSrcweir
4336cdf0e10cSrcweir if ( nMask & HASATTR_RTL )
4337cdf0e10cSrcweir {
4338cdf0e10cSrcweir // first check if right-to left is in the pool at all
4339cdf0e10cSrcweir // (the same item is used in cell and page format)
4340cdf0e10cSrcweir
4341cdf0e10cSrcweir ScDocumentPool* pPool = xPoolHelper->GetDocPool();
4342cdf0e10cSrcweir
4343cdf0e10cSrcweir sal_Bool bHasRtl = sal_False;
4344cdf0e10cSrcweir sal_uInt32 nDirCount = pPool->GetItemCount2( ATTR_WRITINGDIR );
4345cdf0e10cSrcweir for (sal_uInt32 nItem=0; nItem<nDirCount; nItem++)
4346cdf0e10cSrcweir {
4347cdf0e10cSrcweir const SfxPoolItem* pItem = pPool->GetItem2( ATTR_WRITINGDIR, nItem );
4348cdf0e10cSrcweir if ( pItem && ((const SvxFrameDirectionItem*)pItem)->GetValue() == FRMDIR_HORI_RIGHT_TOP )
4349cdf0e10cSrcweir {
4350cdf0e10cSrcweir bHasRtl = sal_True;
4351cdf0e10cSrcweir break;
4352cdf0e10cSrcweir }
4353cdf0e10cSrcweir }
4354cdf0e10cSrcweir if (!bHasRtl)
4355cdf0e10cSrcweir nMask &= ~HASATTR_RTL;
4356cdf0e10cSrcweir }
4357cdf0e10cSrcweir
4358cdf0e10cSrcweir if (!nMask)
4359cdf0e10cSrcweir return false;
4360cdf0e10cSrcweir
4361cdf0e10cSrcweir bool bFound = false;
4362cdf0e10cSrcweir for (SCTAB i=nTab1; i<=nTab2 && !bFound; i++)
4363cdf0e10cSrcweir if (pTab[i])
4364cdf0e10cSrcweir {
4365cdf0e10cSrcweir if ( nMask & HASATTR_RTL )
4366cdf0e10cSrcweir {
4367cdf0e10cSrcweir if ( GetEditTextDirection(i) == EE_HTEXTDIR_R2L ) // sheet default
4368cdf0e10cSrcweir bFound = true;
4369cdf0e10cSrcweir }
4370cdf0e10cSrcweir if ( nMask & HASATTR_RIGHTORCENTER )
4371cdf0e10cSrcweir {
4372cdf0e10cSrcweir // On a RTL sheet, don't start to look for the default left value
4373cdf0e10cSrcweir // (which is then logically right), instead always assume sal_True.
4374cdf0e10cSrcweir // That way, ScAttrArray::HasAttrib doesn't have to handle RTL sheets.
4375cdf0e10cSrcweir
4376cdf0e10cSrcweir if ( IsLayoutRTL(i) )
4377cdf0e10cSrcweir bFound = true;
4378cdf0e10cSrcweir }
4379cdf0e10cSrcweir
4380cdf0e10cSrcweir if ( !bFound )
4381cdf0e10cSrcweir bFound = pTab[i]->HasAttrib( nCol1, nRow1, nCol2, nRow2, nMask );
4382cdf0e10cSrcweir }
4383cdf0e10cSrcweir
4384cdf0e10cSrcweir return bFound;
4385cdf0e10cSrcweir }
4386cdf0e10cSrcweir
HasAttrib(const ScRange & rRange,sal_uInt16 nMask)4387cdf0e10cSrcweir bool ScDocument::HasAttrib( const ScRange& rRange, sal_uInt16 nMask )
4388cdf0e10cSrcweir {
4389cdf0e10cSrcweir return HasAttrib( rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
4390cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(),
4391cdf0e10cSrcweir nMask );
4392cdf0e10cSrcweir }
4393cdf0e10cSrcweir
FindMaxRotCol(SCTAB nTab,RowInfo * pRowInfo,SCSIZE nArrCount,SCCOL nX1,SCCOL nX2) const4394cdf0e10cSrcweir void ScDocument::FindMaxRotCol( SCTAB nTab, RowInfo* pRowInfo, SCSIZE nArrCount,
4395cdf0e10cSrcweir SCCOL nX1, SCCOL nX2 ) const
4396cdf0e10cSrcweir {
4397cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
4398cdf0e10cSrcweir pTab[nTab]->FindMaxRotCol( pRowInfo, nArrCount, nX1, nX2 );
4399cdf0e10cSrcweir else
4400cdf0e10cSrcweir {
4401cdf0e10cSrcweir DBG_ERRORFILE("FindMaxRotCol: falsche Tabelle");
4402cdf0e10cSrcweir }
4403cdf0e10cSrcweir }
4404cdf0e10cSrcweir
GetBorderLines(SCCOL nCol,SCROW nRow,SCTAB nTab,const SvxBorderLine ** ppLeft,const SvxBorderLine ** ppTop,const SvxBorderLine ** ppRight,const SvxBorderLine ** ppBottom) const4405cdf0e10cSrcweir void ScDocument::GetBorderLines( SCCOL nCol, SCROW nRow, SCTAB nTab,
4406cdf0e10cSrcweir const SvxBorderLine** ppLeft, const SvxBorderLine** ppTop,
4407cdf0e10cSrcweir const SvxBorderLine** ppRight, const SvxBorderLine** ppBottom ) const
4408cdf0e10cSrcweir {
4409cdf0e10cSrcweir //! Seitengrenzen fuer Druck beruecksichtigen !!!!!
4410cdf0e10cSrcweir
4411cdf0e10cSrcweir const SvxBoxItem* pThisAttr = (const SvxBoxItem*) GetEffItem( nCol, nRow, nTab, ATTR_BORDER );
4412cdf0e10cSrcweir DBG_ASSERT(pThisAttr,"wo ist das Attribut?");
4413cdf0e10cSrcweir
4414cdf0e10cSrcweir const SvxBorderLine* pLeftLine = pThisAttr->GetLeft();
4415cdf0e10cSrcweir const SvxBorderLine* pTopLine = pThisAttr->GetTop();
4416cdf0e10cSrcweir const SvxBorderLine* pRightLine = pThisAttr->GetRight();
4417cdf0e10cSrcweir const SvxBorderLine* pBottomLine = pThisAttr->GetBottom();
4418cdf0e10cSrcweir
4419cdf0e10cSrcweir if ( nCol > 0 )
4420cdf0e10cSrcweir {
4421cdf0e10cSrcweir const SvxBorderLine* pOther = ((const SvxBoxItem*)
4422cdf0e10cSrcweir GetEffItem( nCol-1, nRow, nTab, ATTR_BORDER ))->GetRight();
4423cdf0e10cSrcweir if ( ScHasPriority( pOther, pLeftLine ) )
4424cdf0e10cSrcweir pLeftLine = pOther;
4425cdf0e10cSrcweir }
4426cdf0e10cSrcweir if ( nRow > 0 )
4427cdf0e10cSrcweir {
4428cdf0e10cSrcweir const SvxBorderLine* pOther = ((const SvxBoxItem*)
4429cdf0e10cSrcweir GetEffItem( nCol, nRow-1, nTab, ATTR_BORDER ))->GetBottom();
4430cdf0e10cSrcweir if ( ScHasPriority( pOther, pTopLine ) )
4431cdf0e10cSrcweir pTopLine = pOther;
4432cdf0e10cSrcweir }
4433cdf0e10cSrcweir if ( nCol < MAXCOL )
4434cdf0e10cSrcweir {
4435cdf0e10cSrcweir const SvxBorderLine* pOther = ((const SvxBoxItem*)
4436cdf0e10cSrcweir GetEffItem( nCol+1, nRow, nTab, ATTR_BORDER ))->GetLeft();
4437cdf0e10cSrcweir if ( ScHasPriority( pOther, pRightLine ) )
4438cdf0e10cSrcweir pRightLine = pOther;
4439cdf0e10cSrcweir }
4440cdf0e10cSrcweir if ( nRow < MAXROW )
4441cdf0e10cSrcweir {
4442cdf0e10cSrcweir const SvxBorderLine* pOther = ((const SvxBoxItem*)
4443cdf0e10cSrcweir GetEffItem( nCol, nRow+1, nTab, ATTR_BORDER ))->GetTop();
4444cdf0e10cSrcweir if ( ScHasPriority( pOther, pBottomLine ) )
4445cdf0e10cSrcweir pBottomLine = pOther;
4446cdf0e10cSrcweir }
4447cdf0e10cSrcweir
4448cdf0e10cSrcweir if (ppLeft)
4449cdf0e10cSrcweir *ppLeft = pLeftLine;
4450cdf0e10cSrcweir if (ppTop)
4451cdf0e10cSrcweir *ppTop = pTopLine;
4452cdf0e10cSrcweir if (ppRight)
4453cdf0e10cSrcweir *ppRight = pRightLine;
4454cdf0e10cSrcweir if (ppBottom)
4455cdf0e10cSrcweir *ppBottom = pBottomLine;
4456cdf0e10cSrcweir }
4457cdf0e10cSrcweir
IsBlockEmpty(SCTAB nTab,SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,bool bIgnoreNotes) const4458cdf0e10cSrcweir sal_Bool ScDocument::IsBlockEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
4459cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, bool bIgnoreNotes ) const
4460cdf0e10cSrcweir {
4461cdf0e10cSrcweir if (VALIDTAB(nTab))
4462cdf0e10cSrcweir if (pTab[nTab])
4463cdf0e10cSrcweir return pTab[nTab]->IsBlockEmpty( nStartCol, nStartRow, nEndCol, nEndRow, bIgnoreNotes );
4464cdf0e10cSrcweir
4465cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
4466cdf0e10cSrcweir return sal_False;
4467cdf0e10cSrcweir }
4468cdf0e10cSrcweir
4469cdf0e10cSrcweir
LockTable(SCTAB nTab)4470cdf0e10cSrcweir void ScDocument::LockTable(SCTAB nTab)
4471cdf0e10cSrcweir {
4472cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
4473cdf0e10cSrcweir pTab[nTab]->LockTable();
4474cdf0e10cSrcweir else
4475cdf0e10cSrcweir {
4476cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
4477cdf0e10cSrcweir }
4478cdf0e10cSrcweir }
4479cdf0e10cSrcweir
4480cdf0e10cSrcweir
UnlockTable(SCTAB nTab)4481cdf0e10cSrcweir void ScDocument::UnlockTable(SCTAB nTab)
4482cdf0e10cSrcweir {
4483cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
4484cdf0e10cSrcweir pTab[nTab]->UnlockTable();
4485cdf0e10cSrcweir else
4486cdf0e10cSrcweir {
4487cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
4488cdf0e10cSrcweir }
4489cdf0e10cSrcweir }
4490cdf0e10cSrcweir
4491cdf0e10cSrcweir
IsBlockEditable(SCTAB nTab,SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,sal_Bool * pOnlyNotBecauseOfMatrix) const4492cdf0e10cSrcweir sal_Bool ScDocument::IsBlockEditable( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
4493cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow,
4494cdf0e10cSrcweir sal_Bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
4495cdf0e10cSrcweir {
4496cdf0e10cSrcweir // import into read-only document is possible
4497cdf0e10cSrcweir if ( !bImportingXML && !mbChangeReadOnlyEnabled && pShell && pShell->IsReadOnly() )
4498cdf0e10cSrcweir {
4499cdf0e10cSrcweir if ( pOnlyNotBecauseOfMatrix )
4500cdf0e10cSrcweir *pOnlyNotBecauseOfMatrix = sal_False;
4501cdf0e10cSrcweir return sal_False;
4502cdf0e10cSrcweir }
4503cdf0e10cSrcweir
4504cdf0e10cSrcweir if (VALIDTAB(nTab))
4505cdf0e10cSrcweir if (pTab[nTab])
4506cdf0e10cSrcweir return pTab[nTab]->IsBlockEditable( nStartCol, nStartRow, nEndCol,
4507cdf0e10cSrcweir nEndRow, pOnlyNotBecauseOfMatrix );
4508cdf0e10cSrcweir
4509cdf0e10cSrcweir DBG_ERROR("Falsche Tabellennummer");
4510cdf0e10cSrcweir if ( pOnlyNotBecauseOfMatrix )
4511cdf0e10cSrcweir *pOnlyNotBecauseOfMatrix = sal_False;
4512cdf0e10cSrcweir return sal_False;
4513cdf0e10cSrcweir }
4514cdf0e10cSrcweir
4515cdf0e10cSrcweir
IsSelectionEditable(const ScMarkData & rMark,sal_Bool * pOnlyNotBecauseOfMatrix) const4516cdf0e10cSrcweir sal_Bool ScDocument::IsSelectionEditable( const ScMarkData& rMark,
4517cdf0e10cSrcweir sal_Bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
4518cdf0e10cSrcweir {
4519cdf0e10cSrcweir // import into read-only document is possible
4520cdf0e10cSrcweir if ( !bImportingXML && !mbChangeReadOnlyEnabled && pShell && pShell->IsReadOnly() )
4521cdf0e10cSrcweir {
4522cdf0e10cSrcweir if ( pOnlyNotBecauseOfMatrix )
4523cdf0e10cSrcweir *pOnlyNotBecauseOfMatrix = sal_False;
4524cdf0e10cSrcweir return sal_False;
4525cdf0e10cSrcweir }
4526cdf0e10cSrcweir
4527cdf0e10cSrcweir ScRange aRange;
4528cdf0e10cSrcweir rMark.GetMarkArea(aRange);
4529cdf0e10cSrcweir
4530cdf0e10cSrcweir sal_Bool bOk = sal_True;
4531cdf0e10cSrcweir sal_Bool bMatrix = ( pOnlyNotBecauseOfMatrix != NULL );
4532cdf0e10cSrcweir for ( SCTAB i=0; i<=MAXTAB && (bOk || bMatrix); i++ )
4533cdf0e10cSrcweir {
4534cdf0e10cSrcweir if ( pTab[i] && rMark.GetTableSelect(i) )
4535cdf0e10cSrcweir {
4536cdf0e10cSrcweir if (rMark.IsMarked())
4537cdf0e10cSrcweir {
4538cdf0e10cSrcweir if ( !pTab[i]->IsBlockEditable( aRange.aStart.Col(),
4539cdf0e10cSrcweir aRange.aStart.Row(), aRange.aEnd.Col(),
4540cdf0e10cSrcweir aRange.aEnd.Row(), pOnlyNotBecauseOfMatrix ) )
4541cdf0e10cSrcweir {
4542cdf0e10cSrcweir bOk = sal_False;
4543cdf0e10cSrcweir if ( pOnlyNotBecauseOfMatrix )
4544cdf0e10cSrcweir bMatrix = *pOnlyNotBecauseOfMatrix;
4545cdf0e10cSrcweir }
4546cdf0e10cSrcweir }
4547cdf0e10cSrcweir if (rMark.IsMultiMarked())
4548cdf0e10cSrcweir {
4549cdf0e10cSrcweir if ( !pTab[i]->IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix ) )
4550cdf0e10cSrcweir {
4551cdf0e10cSrcweir bOk = sal_False;
4552cdf0e10cSrcweir if ( pOnlyNotBecauseOfMatrix )
4553cdf0e10cSrcweir bMatrix = *pOnlyNotBecauseOfMatrix;
4554cdf0e10cSrcweir }
4555cdf0e10cSrcweir }
4556cdf0e10cSrcweir }
4557cdf0e10cSrcweir }
4558cdf0e10cSrcweir
4559cdf0e10cSrcweir if ( pOnlyNotBecauseOfMatrix )
4560cdf0e10cSrcweir *pOnlyNotBecauseOfMatrix = ( !bOk && bMatrix );
4561cdf0e10cSrcweir
4562cdf0e10cSrcweir return bOk;
4563cdf0e10cSrcweir }
4564cdf0e10cSrcweir
4565cdf0e10cSrcweir
HasSelectedBlockMatrixFragment(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,const ScMarkData & rMark) const4566cdf0e10cSrcweir sal_Bool ScDocument::HasSelectedBlockMatrixFragment( SCCOL nStartCol, SCROW nStartRow,
4567cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow,
4568cdf0e10cSrcweir const ScMarkData& rMark ) const
4569cdf0e10cSrcweir {
4570cdf0e10cSrcweir sal_Bool bOk = sal_True;
4571cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB && bOk; i++)
4572cdf0e10cSrcweir if (pTab[i])
4573cdf0e10cSrcweir if (rMark.GetTableSelect(i))
4574cdf0e10cSrcweir if (pTab[i]->HasBlockMatrixFragment( nStartCol, nStartRow, nEndCol, nEndRow ))
4575cdf0e10cSrcweir bOk = sal_False;
4576cdf0e10cSrcweir
4577cdf0e10cSrcweir return !bOk;
4578cdf0e10cSrcweir }
4579cdf0e10cSrcweir
4580cdf0e10cSrcweir
GetMatrixFormulaRange(const ScAddress & rCellPos,ScRange & rMatrix)4581cdf0e10cSrcweir sal_Bool ScDocument::GetMatrixFormulaRange( const ScAddress& rCellPos, ScRange& rMatrix )
4582cdf0e10cSrcweir {
4583cdf0e10cSrcweir // if rCell is part of a matrix formula, return its complete range
4584cdf0e10cSrcweir
4585cdf0e10cSrcweir sal_Bool bRet = sal_False;
4586cdf0e10cSrcweir ScBaseCell* pCell = GetCell( rCellPos );
4587cdf0e10cSrcweir if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA)
4588cdf0e10cSrcweir {
4589cdf0e10cSrcweir ScAddress aOrigin = rCellPos;
4590cdf0e10cSrcweir if ( ((ScFormulaCell*)pCell)->GetMatrixOrigin( aOrigin ) )
4591cdf0e10cSrcweir {
4592cdf0e10cSrcweir if ( aOrigin != rCellPos )
4593cdf0e10cSrcweir pCell = GetCell( aOrigin );
4594cdf0e10cSrcweir if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA)
4595cdf0e10cSrcweir {
4596cdf0e10cSrcweir SCCOL nSizeX;
4597cdf0e10cSrcweir SCROW nSizeY;
4598cdf0e10cSrcweir ((ScFormulaCell*)pCell)->GetMatColsRows(nSizeX,nSizeY);
4599cdf0e10cSrcweir if ( !(nSizeX > 0 && nSizeY > 0) )
4600cdf0e10cSrcweir {
4601cdf0e10cSrcweir // GetMatrixEdge computes also dimensions of the matrix
4602cdf0e10cSrcweir // if not already done (may occur if document is loaded
4603cdf0e10cSrcweir // from old file format).
4604cdf0e10cSrcweir // Needs an "invalid" initialized address.
4605cdf0e10cSrcweir aOrigin.SetInvalid();
4606cdf0e10cSrcweir ((ScFormulaCell*)pCell)->GetMatrixEdge(aOrigin);
4607cdf0e10cSrcweir ((ScFormulaCell*)pCell)->GetMatColsRows(nSizeX,nSizeY);
4608cdf0e10cSrcweir }
4609cdf0e10cSrcweir if ( nSizeX > 0 && nSizeY > 0 )
4610cdf0e10cSrcweir {
4611cdf0e10cSrcweir ScAddress aEnd( aOrigin.Col() + nSizeX - 1,
4612cdf0e10cSrcweir aOrigin.Row() + nSizeY - 1,
4613cdf0e10cSrcweir aOrigin.Tab() );
4614cdf0e10cSrcweir
4615cdf0e10cSrcweir rMatrix.aStart = aOrigin;
4616cdf0e10cSrcweir rMatrix.aEnd = aEnd;
4617cdf0e10cSrcweir bRet = sal_True;
4618cdf0e10cSrcweir }
4619cdf0e10cSrcweir }
4620cdf0e10cSrcweir }
4621cdf0e10cSrcweir }
4622cdf0e10cSrcweir return bRet;
4623cdf0e10cSrcweir }
4624cdf0e10cSrcweir
4625cdf0e10cSrcweir
ExtendOverlapped(SCCOL & rStartCol,SCROW & rStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab)4626cdf0e10cSrcweir sal_Bool ScDocument::ExtendOverlapped( SCCOL& rStartCol, SCROW& rStartRow,
4627cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
4628cdf0e10cSrcweir {
4629cdf0e10cSrcweir sal_Bool bFound = sal_False;
4630cdf0e10cSrcweir if ( ValidColRow(rStartCol,rStartRow) && ValidColRow(nEndCol,nEndRow) && ValidTab(nTab) )
4631cdf0e10cSrcweir {
4632cdf0e10cSrcweir if (pTab[nTab])
4633cdf0e10cSrcweir {
4634cdf0e10cSrcweir SCCOL nCol;
4635cdf0e10cSrcweir SCCOL nOldCol = rStartCol;
4636cdf0e10cSrcweir SCROW nOldRow = rStartRow;
4637cdf0e10cSrcweir for (nCol=nOldCol; nCol<=nEndCol; nCol++)
4638cdf0e10cSrcweir while (((ScMergeFlagAttr*)GetAttr(nCol,rStartRow,nTab,ATTR_MERGE_FLAG))->
4639cdf0e10cSrcweir IsVerOverlapped())
4640cdf0e10cSrcweir --rStartRow;
4641cdf0e10cSrcweir
4642cdf0e10cSrcweir //! weiterreichen ?
4643cdf0e10cSrcweir
4644cdf0e10cSrcweir ScAttrArray* pAttrArray = pTab[nTab]->aCol[nOldCol].pAttrArray;
4645cdf0e10cSrcweir SCSIZE nIndex;
4646cdf0e10cSrcweir pAttrArray->Search( nOldRow, nIndex );
4647cdf0e10cSrcweir SCROW nAttrPos = nOldRow;
4648cdf0e10cSrcweir while (nAttrPos<=nEndRow)
4649cdf0e10cSrcweir {
4650cdf0e10cSrcweir DBG_ASSERT( nIndex < pAttrArray->nCount, "Falscher Index im AttrArray" );
4651cdf0e10cSrcweir
4652cdf0e10cSrcweir if (((ScMergeFlagAttr&)pAttrArray->pData[nIndex].pPattern->
4653cdf0e10cSrcweir GetItem(ATTR_MERGE_FLAG)).IsHorOverlapped())
4654cdf0e10cSrcweir {
4655cdf0e10cSrcweir SCROW nLoopEndRow = Min( nEndRow, pAttrArray->pData[nIndex].nRow );
4656cdf0e10cSrcweir for (SCROW nAttrRow = nAttrPos; nAttrRow <= nLoopEndRow; nAttrRow++)
4657cdf0e10cSrcweir {
4658cdf0e10cSrcweir SCCOL nTempCol = nOldCol;
4659cdf0e10cSrcweir do
4660cdf0e10cSrcweir --nTempCol;
4661cdf0e10cSrcweir while (((ScMergeFlagAttr*)GetAttr(nTempCol,nAttrRow,nTab,ATTR_MERGE_FLAG))
4662cdf0e10cSrcweir ->IsHorOverlapped());
4663cdf0e10cSrcweir if (nTempCol < rStartCol)
4664cdf0e10cSrcweir rStartCol = nTempCol;
4665cdf0e10cSrcweir }
4666cdf0e10cSrcweir }
4667cdf0e10cSrcweir nAttrPos = pAttrArray->pData[nIndex].nRow + 1;
4668cdf0e10cSrcweir ++nIndex;
4669cdf0e10cSrcweir }
4670cdf0e10cSrcweir }
4671cdf0e10cSrcweir }
4672cdf0e10cSrcweir else
4673cdf0e10cSrcweir {
4674cdf0e10cSrcweir DBG_ERROR("ExtendOverlapped: falscher Bereich");
4675cdf0e10cSrcweir }
4676cdf0e10cSrcweir
4677cdf0e10cSrcweir return bFound;
4678cdf0e10cSrcweir }
4679cdf0e10cSrcweir
4680cdf0e10cSrcweir
ExtendMergeSel(SCCOL nStartCol,SCROW nStartRow,SCCOL & rEndCol,SCROW & rEndRow,const ScMarkData & rMark,sal_Bool bRefresh,sal_Bool bAttrs)4681cdf0e10cSrcweir sal_Bool ScDocument::ExtendMergeSel( SCCOL nStartCol, SCROW nStartRow,
4682cdf0e10cSrcweir SCCOL& rEndCol, SCROW& rEndRow,
4683cdf0e10cSrcweir const ScMarkData& rMark, sal_Bool bRefresh, sal_Bool bAttrs )
4684cdf0e10cSrcweir {
4685cdf0e10cSrcweir // use all selected sheets from rMark
4686cdf0e10cSrcweir
4687cdf0e10cSrcweir sal_Bool bFound = sal_False;
4688cdf0e10cSrcweir SCCOL nOldEndCol = rEndCol;
4689cdf0e10cSrcweir SCROW nOldEndRow = rEndRow;
4690cdf0e10cSrcweir
4691cdf0e10cSrcweir for (SCTAB nTab = 0; nTab <= MAXTAB; nTab++)
4692cdf0e10cSrcweir if ( pTab[nTab] && rMark.GetTableSelect(nTab) )
4693cdf0e10cSrcweir {
4694cdf0e10cSrcweir SCCOL nThisEndCol = nOldEndCol;
4695cdf0e10cSrcweir SCROW nThisEndRow = nOldEndRow;
4696cdf0e10cSrcweir if ( ExtendMerge( nStartCol, nStartRow, nThisEndCol, nThisEndRow, nTab, bRefresh, bAttrs ) )
4697cdf0e10cSrcweir bFound = sal_True;
4698cdf0e10cSrcweir if ( nThisEndCol > rEndCol )
4699cdf0e10cSrcweir rEndCol = nThisEndCol;
4700cdf0e10cSrcweir if ( nThisEndRow > rEndRow )
4701cdf0e10cSrcweir rEndRow = nThisEndRow;
4702cdf0e10cSrcweir }
4703cdf0e10cSrcweir
4704cdf0e10cSrcweir return bFound;
4705cdf0e10cSrcweir }
4706cdf0e10cSrcweir
4707cdf0e10cSrcweir
ExtendMerge(SCCOL nStartCol,SCROW nStartRow,SCCOL & rEndCol,SCROW & rEndRow,SCTAB nTab,sal_Bool bRefresh,sal_Bool bAttrs)4708cdf0e10cSrcweir sal_Bool ScDocument::ExtendMerge( SCCOL nStartCol, SCROW nStartRow,
4709cdf0e10cSrcweir SCCOL& rEndCol, SCROW& rEndRow,
4710cdf0e10cSrcweir SCTAB nTab, sal_Bool bRefresh, sal_Bool bAttrs )
4711cdf0e10cSrcweir {
4712cdf0e10cSrcweir sal_Bool bFound = sal_False;
4713cdf0e10cSrcweir if ( ValidColRow(nStartCol,nStartRow) && ValidColRow(rEndCol,rEndRow) && ValidTab(nTab) )
4714cdf0e10cSrcweir {
4715cdf0e10cSrcweir if (pTab[nTab])
4716cdf0e10cSrcweir bFound = pTab[nTab]->ExtendMerge( nStartCol, nStartRow, rEndCol, rEndRow, bRefresh, bAttrs );
4717cdf0e10cSrcweir
4718cdf0e10cSrcweir if (bRefresh)
4719cdf0e10cSrcweir RefreshAutoFilter( nStartCol, nStartRow, rEndCol, rEndRow, nTab );
4720cdf0e10cSrcweir }
4721cdf0e10cSrcweir else
4722cdf0e10cSrcweir {
4723cdf0e10cSrcweir DBG_ERROR("ExtendMerge: falscher Bereich");
4724cdf0e10cSrcweir }
4725cdf0e10cSrcweir
4726cdf0e10cSrcweir return bFound;
4727cdf0e10cSrcweir }
4728cdf0e10cSrcweir
4729cdf0e10cSrcweir
ExtendMerge(ScRange & rRange,sal_Bool bRefresh,sal_Bool bAttrs)4730cdf0e10cSrcweir sal_Bool ScDocument::ExtendMerge( ScRange& rRange, sal_Bool bRefresh, sal_Bool bAttrs )
4731cdf0e10cSrcweir {
4732cdf0e10cSrcweir sal_Bool bFound = sal_False;
4733cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
4734cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
4735cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
4736cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
4737cdf0e10cSrcweir
4738cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
4739cdf0e10cSrcweir for (SCTAB nTab = nStartTab; nTab <= nEndTab; nTab++ )
4740cdf0e10cSrcweir {
4741cdf0e10cSrcweir SCCOL nExtendCol = rRange.aEnd.Col();
4742cdf0e10cSrcweir SCROW nExtendRow = rRange.aEnd.Row();
4743cdf0e10cSrcweir if (ExtendMerge( rRange.aStart.Col(), rRange.aStart.Row(),
4744cdf0e10cSrcweir nExtendCol, nExtendRow,
4745cdf0e10cSrcweir nTab, bRefresh, bAttrs ) )
4746cdf0e10cSrcweir {
4747cdf0e10cSrcweir bFound = sal_True;
4748cdf0e10cSrcweir if (nExtendCol > nEndCol) nEndCol = nExtendCol;
4749cdf0e10cSrcweir if (nExtendRow > nEndRow) nEndRow = nExtendRow;
4750cdf0e10cSrcweir }
4751cdf0e10cSrcweir }
4752cdf0e10cSrcweir
4753cdf0e10cSrcweir rRange.aEnd.SetCol(nEndCol);
4754cdf0e10cSrcweir rRange.aEnd.SetRow(nEndRow);
4755cdf0e10cSrcweir
4756cdf0e10cSrcweir return bFound;
4757cdf0e10cSrcweir }
4758cdf0e10cSrcweir
ExtendTotalMerge(ScRange & rRange)4759cdf0e10cSrcweir sal_Bool ScDocument::ExtendTotalMerge( ScRange& rRange )
4760cdf0e10cSrcweir {
4761cdf0e10cSrcweir // Bereich genau dann auf zusammengefasste Zellen erweitern, wenn
4762cdf0e10cSrcweir // dadurch keine neuen nicht-ueberdeckten Zellen getroffen werden
4763cdf0e10cSrcweir
4764cdf0e10cSrcweir sal_Bool bRet = sal_False;
4765cdf0e10cSrcweir ScRange aExt = rRange;
4766cdf0e10cSrcweir if (ExtendMerge(aExt))
4767cdf0e10cSrcweir {
4768cdf0e10cSrcweir if ( aExt.aEnd.Row() > rRange.aEnd.Row() )
4769cdf0e10cSrcweir {
4770cdf0e10cSrcweir ScRange aTest = aExt;
4771cdf0e10cSrcweir aTest.aStart.SetRow( rRange.aEnd.Row() + 1 );
4772cdf0e10cSrcweir if ( HasAttrib( aTest, HASATTR_NOTOVERLAPPED ) )
4773cdf0e10cSrcweir aExt.aEnd.SetRow(rRange.aEnd.Row());
4774cdf0e10cSrcweir }
4775cdf0e10cSrcweir if ( aExt.aEnd.Col() > rRange.aEnd.Col() )
4776cdf0e10cSrcweir {
4777cdf0e10cSrcweir ScRange aTest = aExt;
4778cdf0e10cSrcweir aTest.aStart.SetCol( rRange.aEnd.Col() + 1 );
4779cdf0e10cSrcweir if ( HasAttrib( aTest, HASATTR_NOTOVERLAPPED ) )
4780cdf0e10cSrcweir aExt.aEnd.SetCol(rRange.aEnd.Col());
4781cdf0e10cSrcweir }
4782cdf0e10cSrcweir
4783cdf0e10cSrcweir bRet = ( aExt.aEnd != rRange.aEnd );
4784cdf0e10cSrcweir rRange = aExt;
4785cdf0e10cSrcweir }
4786cdf0e10cSrcweir return bRet;
4787cdf0e10cSrcweir }
4788cdf0e10cSrcweir
ExtendOverlapped(ScRange & rRange)4789cdf0e10cSrcweir sal_Bool ScDocument::ExtendOverlapped( ScRange& rRange )
4790cdf0e10cSrcweir {
4791cdf0e10cSrcweir sal_Bool bFound = sal_False;
4792cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
4793cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
4794cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
4795cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
4796cdf0e10cSrcweir
4797cdf0e10cSrcweir PutInOrder( nStartTab, nEndTab );
4798cdf0e10cSrcweir for (SCTAB nTab = nStartTab; nTab <= nEndTab; nTab++ )
4799cdf0e10cSrcweir {
4800cdf0e10cSrcweir SCCOL nExtendCol = rRange.aStart.Col();
4801cdf0e10cSrcweir SCROW nExtendRow = rRange.aStart.Row();
4802cdf0e10cSrcweir ExtendOverlapped( nExtendCol, nExtendRow,
4803cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Row(), nTab );
4804cdf0e10cSrcweir if (nExtendCol < nStartCol)
4805cdf0e10cSrcweir {
4806cdf0e10cSrcweir nStartCol = nExtendCol;
4807cdf0e10cSrcweir bFound = sal_True;
4808cdf0e10cSrcweir }
4809cdf0e10cSrcweir if (nExtendRow < nStartRow)
4810cdf0e10cSrcweir {
4811cdf0e10cSrcweir nStartRow = nExtendRow;
4812cdf0e10cSrcweir bFound = sal_True;
4813cdf0e10cSrcweir }
4814cdf0e10cSrcweir }
4815cdf0e10cSrcweir
4816cdf0e10cSrcweir rRange.aStart.SetCol(nStartCol);
4817cdf0e10cSrcweir rRange.aStart.SetRow(nStartRow);
4818cdf0e10cSrcweir
4819cdf0e10cSrcweir return bFound;
4820cdf0e10cSrcweir }
4821cdf0e10cSrcweir
RefreshAutoFilter(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,SCTAB nTab)4822cdf0e10cSrcweir sal_Bool ScDocument::RefreshAutoFilter( SCCOL nStartCol, SCROW nStartRow,
4823cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
4824cdf0e10cSrcweir {
4825cdf0e10cSrcweir sal_uInt16 nCount = pDBCollection->GetCount();
4826cdf0e10cSrcweir sal_uInt16 i;
4827cdf0e10cSrcweir ScDBData* pData;
4828cdf0e10cSrcweir SCTAB nDBTab;
4829cdf0e10cSrcweir SCCOL nDBStartCol;
4830cdf0e10cSrcweir SCROW nDBStartRow;
4831cdf0e10cSrcweir SCCOL nDBEndCol;
4832cdf0e10cSrcweir SCROW nDBEndRow;
4833cdf0e10cSrcweir
4834cdf0e10cSrcweir // Autofilter loeschen
4835cdf0e10cSrcweir
4836cdf0e10cSrcweir sal_Bool bChange = RemoveFlagsTab( nStartCol,nStartRow, nEndCol,nEndRow, nTab, SC_MF_AUTO );
4837cdf0e10cSrcweir
4838cdf0e10cSrcweir // Autofilter setzen
4839cdf0e10cSrcweir
4840cdf0e10cSrcweir for (i=0; i<nCount; i++)
4841cdf0e10cSrcweir {
4842cdf0e10cSrcweir pData = (*pDBCollection)[i];
4843cdf0e10cSrcweir if (pData->HasAutoFilter())
4844cdf0e10cSrcweir {
4845cdf0e10cSrcweir pData->GetArea( nDBTab, nDBStartCol,nDBStartRow, nDBEndCol,nDBEndRow );
4846cdf0e10cSrcweir if ( nDBTab==nTab && nDBStartRow<=nEndRow && nDBEndRow>=nStartRow &&
4847cdf0e10cSrcweir nDBStartCol<=nEndCol && nDBEndCol>=nStartCol )
4848cdf0e10cSrcweir {
4849cdf0e10cSrcweir if (ApplyFlagsTab( nDBStartCol,nDBStartRow, nDBEndCol,nDBStartRow,
4850cdf0e10cSrcweir nDBTab, SC_MF_AUTO ))
4851cdf0e10cSrcweir bChange = sal_True;
4852cdf0e10cSrcweir }
4853cdf0e10cSrcweir }
4854cdf0e10cSrcweir }
4855cdf0e10cSrcweir return bChange;
4856cdf0e10cSrcweir }
4857cdf0e10cSrcweir
4858cdf0e10cSrcweir
IsHorOverlapped(SCCOL nCol,SCROW nRow,SCTAB nTab) const4859cdf0e10cSrcweir sal_Bool ScDocument::IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4860cdf0e10cSrcweir {
4861cdf0e10cSrcweir const ScMergeFlagAttr* pAttr = (const ScMergeFlagAttr*)
4862cdf0e10cSrcweir GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG );
4863cdf0e10cSrcweir if (pAttr)
4864cdf0e10cSrcweir return pAttr->IsHorOverlapped();
4865cdf0e10cSrcweir else
4866cdf0e10cSrcweir {
4867cdf0e10cSrcweir DBG_ERROR("Overlapped: Attr==0");
4868cdf0e10cSrcweir return sal_False;
4869cdf0e10cSrcweir }
4870cdf0e10cSrcweir }
4871cdf0e10cSrcweir
4872cdf0e10cSrcweir
IsVerOverlapped(SCCOL nCol,SCROW nRow,SCTAB nTab) const4873cdf0e10cSrcweir sal_Bool ScDocument::IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4874cdf0e10cSrcweir {
4875cdf0e10cSrcweir const ScMergeFlagAttr* pAttr = (const ScMergeFlagAttr*)
4876cdf0e10cSrcweir GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG );
4877cdf0e10cSrcweir if (pAttr)
4878cdf0e10cSrcweir return pAttr->IsVerOverlapped();
4879cdf0e10cSrcweir else
4880cdf0e10cSrcweir {
4881cdf0e10cSrcweir DBG_ERROR("Overlapped: Attr==0");
4882cdf0e10cSrcweir return sal_False;
4883cdf0e10cSrcweir }
4884cdf0e10cSrcweir }
4885cdf0e10cSrcweir
4886cdf0e10cSrcweir
ApplySelectionFrame(const ScMarkData & rMark,const SvxBoxItem * pLineOuter,const SvxBoxInfoItem * pLineInner)4887cdf0e10cSrcweir void ScDocument::ApplySelectionFrame( const ScMarkData& rMark,
4888cdf0e10cSrcweir const SvxBoxItem* pLineOuter,
4889cdf0e10cSrcweir const SvxBoxInfoItem* pLineInner )
4890cdf0e10cSrcweir {
4891cdf0e10cSrcweir ScRangeList aRangeList;
4892cdf0e10cSrcweir rMark.FillRangeListWithMarks( &aRangeList, sal_False );
4893cdf0e10cSrcweir sal_uLong nRangeCount = aRangeList.Count();
4894cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4895cdf0e10cSrcweir {
4896cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4897cdf0e10cSrcweir {
4898cdf0e10cSrcweir for (sal_uLong j=0; j<nRangeCount; j++)
4899cdf0e10cSrcweir {
4900cdf0e10cSrcweir ScRange aRange = *aRangeList.GetObject(j);
4901cdf0e10cSrcweir pTab[i]->ApplyBlockFrame( pLineOuter, pLineInner,
4902cdf0e10cSrcweir aRange.aStart.Col(), aRange.aStart.Row(),
4903cdf0e10cSrcweir aRange.aEnd.Col(), aRange.aEnd.Row() );
4904cdf0e10cSrcweir }
4905cdf0e10cSrcweir }
4906cdf0e10cSrcweir }
4907cdf0e10cSrcweir }
4908cdf0e10cSrcweir
4909cdf0e10cSrcweir
ApplyFrameAreaTab(const ScRange & rRange,const SvxBoxItem * pLineOuter,const SvxBoxInfoItem * pLineInner)4910cdf0e10cSrcweir void ScDocument::ApplyFrameAreaTab( const ScRange& rRange,
4911cdf0e10cSrcweir const SvxBoxItem* pLineOuter,
4912cdf0e10cSrcweir const SvxBoxInfoItem* pLineInner )
4913cdf0e10cSrcweir {
4914cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
4915cdf0e10cSrcweir SCTAB nEndTab = rRange.aStart.Tab();
4916cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4917cdf0e10cSrcweir if (pTab[nTab])
4918cdf0e10cSrcweir pTab[nTab]->ApplyBlockFrame( pLineOuter, pLineInner,
4919cdf0e10cSrcweir rRange.aStart.Col(), rRange.aStart.Row(),
4920cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Row() );
4921cdf0e10cSrcweir }
4922cdf0e10cSrcweir
4923cdf0e10cSrcweir
ApplySelectionPattern(const ScPatternAttr & rAttr,const ScMarkData & rMark)4924cdf0e10cSrcweir void ScDocument::ApplySelectionPattern( const ScPatternAttr& rAttr, const ScMarkData& rMark )
4925cdf0e10cSrcweir {
4926cdf0e10cSrcweir const SfxItemSet* pSet = &rAttr.GetItemSet();
4927cdf0e10cSrcweir sal_Bool bSet = sal_False;
4928cdf0e10cSrcweir sal_uInt16 i;
4929cdf0e10cSrcweir for (i=ATTR_PATTERN_START; i<=ATTR_PATTERN_END && !bSet; i++)
4930cdf0e10cSrcweir if (pSet->GetItemState(i) == SFX_ITEM_SET)
4931cdf0e10cSrcweir bSet = sal_True;
4932cdf0e10cSrcweir
4933cdf0e10cSrcweir if (bSet)
4934cdf0e10cSrcweir {
4935cdf0e10cSrcweir // ApplySelectionCache needs multi mark
4936cdf0e10cSrcweir if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
4937cdf0e10cSrcweir {
4938cdf0e10cSrcweir ScRange aRange;
4939cdf0e10cSrcweir rMark.GetMarkArea( aRange );
4940cdf0e10cSrcweir ApplyPatternArea( aRange.aStart.Col(), aRange.aStart.Row(),
4941cdf0e10cSrcweir aRange.aEnd.Col(), aRange.aEnd.Row(), rMark, rAttr );
4942cdf0e10cSrcweir }
4943cdf0e10cSrcweir else
4944cdf0e10cSrcweir {
4945cdf0e10cSrcweir SfxItemPoolCache aCache( xPoolHelper->GetDocPool(), pSet );
4946cdf0e10cSrcweir for (SCTAB nTab=0; nTab<=MAXTAB; nTab++)
4947cdf0e10cSrcweir if (pTab[nTab])
4948cdf0e10cSrcweir if (rMark.GetTableSelect(nTab))
4949cdf0e10cSrcweir pTab[nTab]->ApplySelectionCache( &aCache, rMark );
4950cdf0e10cSrcweir }
4951cdf0e10cSrcweir }
4952cdf0e10cSrcweir }
4953cdf0e10cSrcweir
4954cdf0e10cSrcweir
ChangeSelectionIndent(sal_Bool bIncrement,const ScMarkData & rMark)4955cdf0e10cSrcweir void ScDocument::ChangeSelectionIndent( sal_Bool bIncrement, const ScMarkData& rMark )
4956cdf0e10cSrcweir {
4957cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4958cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4959cdf0e10cSrcweir pTab[i]->ChangeSelectionIndent( bIncrement, rMark );
4960cdf0e10cSrcweir }
4961cdf0e10cSrcweir
4962cdf0e10cSrcweir
ClearSelectionItems(const sal_uInt16 * pWhich,const ScMarkData & rMark)4963cdf0e10cSrcweir void ScDocument::ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark )
4964cdf0e10cSrcweir {
4965cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4966cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4967cdf0e10cSrcweir pTab[i]->ClearSelectionItems( pWhich, rMark );
4968cdf0e10cSrcweir }
4969cdf0e10cSrcweir
4970cdf0e10cSrcweir
DeleteSelection(sal_uInt16 nDelFlag,const ScMarkData & rMark)4971cdf0e10cSrcweir void ScDocument::DeleteSelection( sal_uInt16 nDelFlag, const ScMarkData& rMark )
4972cdf0e10cSrcweir {
4973cdf0e10cSrcweir for (SCTAB i=0; i<=MAXTAB; i++)
4974cdf0e10cSrcweir if (pTab[i] && rMark.GetTableSelect(i))
4975cdf0e10cSrcweir pTab[i]->DeleteSelection( nDelFlag, rMark );
4976cdf0e10cSrcweir }
4977cdf0e10cSrcweir
4978cdf0e10cSrcweir
DeleteSelectionTab(SCTAB nTab,sal_uInt16 nDelFlag,const ScMarkData & rMark)4979cdf0e10cSrcweir void ScDocument::DeleteSelectionTab( SCTAB nTab, sal_uInt16 nDelFlag, const ScMarkData& rMark )
4980cdf0e10cSrcweir {
4981cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
4982cdf0e10cSrcweir pTab[nTab]->DeleteSelection( nDelFlag, rMark );
4983cdf0e10cSrcweir else
4984cdf0e10cSrcweir {
4985cdf0e10cSrcweir DBG_ERROR("Falsche Tabelle");
4986cdf0e10cSrcweir }
4987cdf0e10cSrcweir }
4988cdf0e10cSrcweir
4989cdf0e10cSrcweir
GetDefPattern() const4990cdf0e10cSrcweir ScPatternAttr* ScDocument::GetDefPattern() const
4991cdf0e10cSrcweir {
4992cdf0e10cSrcweir return (ScPatternAttr*) &xPoolHelper->GetDocPool()->GetDefaultItem(ATTR_PATTERN);
4993cdf0e10cSrcweir }
4994cdf0e10cSrcweir
4995cdf0e10cSrcweir
GetPool()4996cdf0e10cSrcweir ScDocumentPool* ScDocument::GetPool()
4997cdf0e10cSrcweir {
4998cdf0e10cSrcweir return xPoolHelper->GetDocPool();
4999cdf0e10cSrcweir }
5000cdf0e10cSrcweir
5001cdf0e10cSrcweir
5002cdf0e10cSrcweir
GetStyleSheetPool() const5003cdf0e10cSrcweir ScStyleSheetPool* ScDocument::GetStyleSheetPool() const
5004cdf0e10cSrcweir {
5005cdf0e10cSrcweir return xPoolHelper->GetStylePool();
5006cdf0e10cSrcweir }
5007cdf0e10cSrcweir
5008cdf0e10cSrcweir
GetEmptyLinesInBlock(SCCOL nStartCol,SCROW nStartRow,SCTAB nStartTab,SCCOL nEndCol,SCROW nEndRow,SCTAB nEndTab,ScDirection eDir)5009cdf0e10cSrcweir SCSIZE ScDocument::GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
5010cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, ScDirection eDir )
5011cdf0e10cSrcweir {
5012cdf0e10cSrcweir PutInOrder(nStartCol, nEndCol);
5013cdf0e10cSrcweir PutInOrder(nStartRow, nEndRow);
5014cdf0e10cSrcweir PutInOrder(nStartTab, nEndTab);
5015cdf0e10cSrcweir if (VALIDTAB(nStartTab))
5016cdf0e10cSrcweir {
5017cdf0e10cSrcweir if (pTab[nStartTab])
5018cdf0e10cSrcweir return pTab[nStartTab]->GetEmptyLinesInBlock(nStartCol, nStartRow, nEndCol, nEndRow, eDir);
5019cdf0e10cSrcweir else
5020cdf0e10cSrcweir return 0;
5021cdf0e10cSrcweir }
5022cdf0e10cSrcweir else
5023cdf0e10cSrcweir return 0;
5024cdf0e10cSrcweir }
5025cdf0e10cSrcweir
5026cdf0e10cSrcweir
FindAreaPos(SCCOL & rCol,SCROW & rRow,SCTAB nTab,SCsCOL nMovX,SCsROW nMovY)5027cdf0e10cSrcweir void ScDocument::FindAreaPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, SCsCOL nMovX, SCsROW nMovY )
5028cdf0e10cSrcweir {
5029cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5030cdf0e10cSrcweir pTab[nTab]->FindAreaPos( rCol, rRow, nMovX, nMovY );
5031cdf0e10cSrcweir }
5032cdf0e10cSrcweir
5033cdf0e10cSrcweir
GetNextPos(SCCOL & rCol,SCROW & rRow,SCTAB nTab,SCsCOL nMovX,SCsROW nMovY,sal_Bool bMarked,sal_Bool bUnprotected,const ScMarkData & rMark)5034cdf0e10cSrcweir void ScDocument::GetNextPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, SCsCOL nMovX, SCsROW nMovY,
5035cdf0e10cSrcweir sal_Bool bMarked, sal_Bool bUnprotected, const ScMarkData& rMark )
5036cdf0e10cSrcweir {
5037cdf0e10cSrcweir DBG_ASSERT( !nMovX || !nMovY, "GetNextPos: nur X oder Y" );
5038cdf0e10cSrcweir
5039cdf0e10cSrcweir ScMarkData aCopyMark = rMark;
5040cdf0e10cSrcweir aCopyMark.SetMarking(sal_False);
5041cdf0e10cSrcweir aCopyMark.MarkToMulti();
5042cdf0e10cSrcweir
5043cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5044cdf0e10cSrcweir pTab[nTab]->GetNextPos( rCol, rRow, nMovX, nMovY, bMarked, bUnprotected, aCopyMark );
5045cdf0e10cSrcweir }
5046cdf0e10cSrcweir
5047cdf0e10cSrcweir //
5048cdf0e10cSrcweir // Datei-Operationen
5049cdf0e10cSrcweir //
5050cdf0e10cSrcweir
5051cdf0e10cSrcweir
UpdStlShtPtrsFrmNms()5052cdf0e10cSrcweir void ScDocument::UpdStlShtPtrsFrmNms()
5053cdf0e10cSrcweir {
5054cdf0e10cSrcweir ScPatternAttr::pDoc = this;
5055cdf0e10cSrcweir
5056cdf0e10cSrcweir ScDocumentPool* pPool = xPoolHelper->GetDocPool();
5057cdf0e10cSrcweir
5058cdf0e10cSrcweir sal_uInt32 nCount = pPool->GetItemCount2(ATTR_PATTERN);
5059cdf0e10cSrcweir ScPatternAttr* pPattern;
5060cdf0e10cSrcweir for (sal_uInt32 i=0; i<nCount; i++)
5061cdf0e10cSrcweir {
5062cdf0e10cSrcweir pPattern = (ScPatternAttr*)pPool->GetItem2(ATTR_PATTERN, i);
5063cdf0e10cSrcweir if (pPattern)
5064cdf0e10cSrcweir pPattern->UpdateStyleSheet();
5065cdf0e10cSrcweir }
5066cdf0e10cSrcweir ((ScPatternAttr&)pPool->GetDefaultItem(ATTR_PATTERN)).UpdateStyleSheet();
5067cdf0e10cSrcweir }
5068cdf0e10cSrcweir
5069cdf0e10cSrcweir
StylesToNames()5070cdf0e10cSrcweir void ScDocument::StylesToNames()
5071cdf0e10cSrcweir {
5072cdf0e10cSrcweir ScPatternAttr::pDoc = this;
5073cdf0e10cSrcweir
5074cdf0e10cSrcweir ScDocumentPool* pPool = xPoolHelper->GetDocPool();
5075cdf0e10cSrcweir
5076cdf0e10cSrcweir sal_uInt32 nCount = pPool->GetItemCount2(ATTR_PATTERN);
5077cdf0e10cSrcweir ScPatternAttr* pPattern;
5078cdf0e10cSrcweir for (sal_uInt32 i=0; i<nCount; i++)
5079cdf0e10cSrcweir {
5080cdf0e10cSrcweir pPattern = (ScPatternAttr*)pPool->GetItem2(ATTR_PATTERN, i);
5081cdf0e10cSrcweir if (pPattern)
5082cdf0e10cSrcweir pPattern->StyleToName();
5083cdf0e10cSrcweir }
5084cdf0e10cSrcweir ((ScPatternAttr&)pPool->GetDefaultItem(ATTR_PATTERN)).StyleToName();
5085cdf0e10cSrcweir }
5086cdf0e10cSrcweir
5087cdf0e10cSrcweir
GetCellCount() const5088cdf0e10cSrcweir sal_uLong ScDocument::GetCellCount() const
5089cdf0e10cSrcweir {
5090cdf0e10cSrcweir sal_uLong nCellCount = 0L;
5091cdf0e10cSrcweir
5092cdf0e10cSrcweir for ( SCTAB nTab=0; nTab<=MAXTAB; nTab++ )
5093cdf0e10cSrcweir if ( pTab[nTab] )
5094cdf0e10cSrcweir nCellCount += pTab[nTab]->GetCellCount();
5095cdf0e10cSrcweir
5096cdf0e10cSrcweir return nCellCount;
5097cdf0e10cSrcweir }
5098cdf0e10cSrcweir
GetCellCount(SCTAB nTab,SCCOL nCol) const5099cdf0e10cSrcweir SCSIZE ScDocument::GetCellCount(SCTAB nTab, SCCOL nCol) const
5100cdf0e10cSrcweir {
5101cdf0e10cSrcweir if (!ValidTab(nTab) || !pTab[nTab])
5102cdf0e10cSrcweir return 0;
5103cdf0e10cSrcweir
5104cdf0e10cSrcweir return pTab[nTab]->GetCellCount(nCol);
5105cdf0e10cSrcweir }
5106cdf0e10cSrcweir
GetCodeCount() const5107cdf0e10cSrcweir sal_uLong ScDocument::GetCodeCount() const
5108cdf0e10cSrcweir {
5109cdf0e10cSrcweir sal_uLong nCodeCount = 0;
5110cdf0e10cSrcweir
5111cdf0e10cSrcweir for ( SCTAB nTab=0; nTab<=MAXTAB; nTab++ )
5112cdf0e10cSrcweir if ( pTab[nTab] )
5113cdf0e10cSrcweir nCodeCount += pTab[nTab]->GetCodeCount();
5114cdf0e10cSrcweir
5115cdf0e10cSrcweir return nCodeCount;
5116cdf0e10cSrcweir }
5117cdf0e10cSrcweir
5118cdf0e10cSrcweir
GetWeightedCount() const5119cdf0e10cSrcweir sal_uLong ScDocument::GetWeightedCount() const
5120cdf0e10cSrcweir {
5121cdf0e10cSrcweir sal_uLong nCellCount = 0L;
5122cdf0e10cSrcweir
5123cdf0e10cSrcweir for ( SCTAB nTab=0; nTab<=MAXTAB; nTab++ )
5124cdf0e10cSrcweir if ( pTab[nTab] )
5125cdf0e10cSrcweir nCellCount += pTab[nTab]->GetWeightedCount();
5126cdf0e10cSrcweir
5127cdf0e10cSrcweir return nCellCount;
5128cdf0e10cSrcweir }
5129cdf0e10cSrcweir
5130cdf0e10cSrcweir
PageStyleModified(SCTAB nTab,const String & rNewName)5131cdf0e10cSrcweir void ScDocument::PageStyleModified( SCTAB nTab, const String& rNewName )
5132cdf0e10cSrcweir {
5133cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5134cdf0e10cSrcweir pTab[nTab]->PageStyleModified( rNewName );
5135cdf0e10cSrcweir }
5136cdf0e10cSrcweir
5137cdf0e10cSrcweir
SetPageStyle(SCTAB nTab,const String & rName)5138cdf0e10cSrcweir void ScDocument::SetPageStyle( SCTAB nTab, const String& rName )
5139cdf0e10cSrcweir {
5140cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5141cdf0e10cSrcweir pTab[nTab]->SetPageStyle( rName );
5142cdf0e10cSrcweir }
5143cdf0e10cSrcweir
5144cdf0e10cSrcweir
GetPageStyle(SCTAB nTab) const5145cdf0e10cSrcweir const String& ScDocument::GetPageStyle( SCTAB nTab ) const
5146cdf0e10cSrcweir {
5147cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5148cdf0e10cSrcweir return pTab[nTab]->GetPageStyle();
5149cdf0e10cSrcweir
5150cdf0e10cSrcweir return EMPTY_STRING;
5151cdf0e10cSrcweir }
5152cdf0e10cSrcweir
5153cdf0e10cSrcweir
SetPageSize(SCTAB nTab,const Size & rSize)5154cdf0e10cSrcweir void ScDocument::SetPageSize( SCTAB nTab, const Size& rSize )
5155cdf0e10cSrcweir {
5156cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5157cdf0e10cSrcweir pTab[nTab]->SetPageSize( rSize );
5158cdf0e10cSrcweir }
5159cdf0e10cSrcweir
GetPageSize(SCTAB nTab) const5160cdf0e10cSrcweir Size ScDocument::GetPageSize( SCTAB nTab ) const
5161cdf0e10cSrcweir {
5162cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5163cdf0e10cSrcweir return pTab[nTab]->GetPageSize();
5164cdf0e10cSrcweir
5165cdf0e10cSrcweir DBG_ERROR("falsche Tab");
5166cdf0e10cSrcweir return Size();
5167cdf0e10cSrcweir }
5168cdf0e10cSrcweir
5169cdf0e10cSrcweir
SetRepeatArea(SCTAB nTab,SCCOL nStartCol,SCCOL nEndCol,SCROW nStartRow,SCROW nEndRow)5170cdf0e10cSrcweir void ScDocument::SetRepeatArea( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow )
5171cdf0e10cSrcweir {
5172cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5173cdf0e10cSrcweir pTab[nTab]->SetRepeatArea( nStartCol, nEndCol, nStartRow, nEndRow );
5174cdf0e10cSrcweir }
5175cdf0e10cSrcweir
InvalidatePageBreaks(SCTAB nTab)5176cdf0e10cSrcweir void ScDocument::InvalidatePageBreaks(SCTAB nTab)
5177cdf0e10cSrcweir {
5178cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5179cdf0e10cSrcweir pTab[nTab]->InvalidatePageBreaks();
5180cdf0e10cSrcweir }
5181cdf0e10cSrcweir
UpdatePageBreaks(SCTAB nTab,const ScRange * pUserArea)5182cdf0e10cSrcweir void ScDocument::UpdatePageBreaks( SCTAB nTab, const ScRange* pUserArea )
5183cdf0e10cSrcweir {
5184cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5185cdf0e10cSrcweir pTab[nTab]->UpdatePageBreaks( pUserArea );
5186cdf0e10cSrcweir }
5187cdf0e10cSrcweir
RemoveManualBreaks(SCTAB nTab)5188cdf0e10cSrcweir void ScDocument::RemoveManualBreaks( SCTAB nTab )
5189cdf0e10cSrcweir {
5190cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5191cdf0e10cSrcweir pTab[nTab]->RemoveManualBreaks();
5192cdf0e10cSrcweir }
5193cdf0e10cSrcweir
HasManualBreaks(SCTAB nTab) const5194cdf0e10cSrcweir sal_Bool ScDocument::HasManualBreaks( SCTAB nTab ) const
5195cdf0e10cSrcweir {
5196cdf0e10cSrcweir if ( ValidTab(nTab) && pTab[nTab] )
5197cdf0e10cSrcweir return pTab[nTab]->HasManualBreaks();
5198cdf0e10cSrcweir
5199cdf0e10cSrcweir DBG_ERROR("falsche Tab");
5200cdf0e10cSrcweir return sal_False;
5201cdf0e10cSrcweir }
5202cdf0e10cSrcweir
5203cdf0e10cSrcweir
GetDocStat(ScDocStat & rDocStat)5204cdf0e10cSrcweir void ScDocument::GetDocStat( ScDocStat& rDocStat )
5205cdf0e10cSrcweir {
5206cdf0e10cSrcweir rDocStat.nTableCount = GetTableCount();
5207cdf0e10cSrcweir rDocStat.aDocName = aDocName;
5208cdf0e10cSrcweir rDocStat.nCellCount = GetCellCount();
5209cdf0e10cSrcweir }
5210cdf0e10cSrcweir
5211cdf0e10cSrcweir
HasPrintRange()5212cdf0e10cSrcweir sal_Bool ScDocument::HasPrintRange()
5213cdf0e10cSrcweir {
5214cdf0e10cSrcweir sal_Bool bResult = sal_False;
5215cdf0e10cSrcweir
5216cdf0e10cSrcweir for ( SCTAB i=0; !bResult && i<nMaxTableNumber; i++ )
5217cdf0e10cSrcweir if ( pTab[i] )
5218cdf0e10cSrcweir bResult = pTab[i]->IsPrintEntireSheet() || (pTab[i]->GetPrintRangeCount() > 0);
5219cdf0e10cSrcweir
5220cdf0e10cSrcweir return bResult;
5221cdf0e10cSrcweir }
5222cdf0e10cSrcweir
5223cdf0e10cSrcweir
IsPrintEntireSheet(SCTAB nTab) const5224cdf0e10cSrcweir sal_Bool ScDocument::IsPrintEntireSheet( SCTAB nTab ) const
5225cdf0e10cSrcweir {
5226cdf0e10cSrcweir return (ValidTab(nTab) ) && pTab[nTab] && pTab[nTab]->IsPrintEntireSheet();
5227cdf0e10cSrcweir }
5228cdf0e10cSrcweir
5229cdf0e10cSrcweir
GetPrintRangeCount(SCTAB nTab)5230cdf0e10cSrcweir sal_uInt16 ScDocument::GetPrintRangeCount( SCTAB nTab )
5231cdf0e10cSrcweir {
5232cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5233cdf0e10cSrcweir return pTab[nTab]->GetPrintRangeCount();
5234cdf0e10cSrcweir
5235cdf0e10cSrcweir return 0;
5236cdf0e10cSrcweir }
5237cdf0e10cSrcweir
5238cdf0e10cSrcweir
GetPrintRange(SCTAB nTab,sal_uInt16 nPos)5239cdf0e10cSrcweir const ScRange* ScDocument::GetPrintRange( SCTAB nTab, sal_uInt16 nPos )
5240cdf0e10cSrcweir {
5241cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5242cdf0e10cSrcweir return pTab[nTab]->GetPrintRange(nPos);
5243cdf0e10cSrcweir
5244cdf0e10cSrcweir return NULL;
5245cdf0e10cSrcweir }
5246cdf0e10cSrcweir
5247cdf0e10cSrcweir
GetRepeatColRange(SCTAB nTab)5248cdf0e10cSrcweir const ScRange* ScDocument::GetRepeatColRange( SCTAB nTab )
5249cdf0e10cSrcweir {
5250cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5251cdf0e10cSrcweir return pTab[nTab]->GetRepeatColRange();
5252cdf0e10cSrcweir
5253cdf0e10cSrcweir return NULL;
5254cdf0e10cSrcweir }
5255cdf0e10cSrcweir
5256cdf0e10cSrcweir
GetRepeatRowRange(SCTAB nTab)5257cdf0e10cSrcweir const ScRange* ScDocument::GetRepeatRowRange( SCTAB nTab )
5258cdf0e10cSrcweir {
5259cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5260cdf0e10cSrcweir return pTab[nTab]->GetRepeatRowRange();
5261cdf0e10cSrcweir
5262cdf0e10cSrcweir return NULL;
5263cdf0e10cSrcweir }
5264cdf0e10cSrcweir
5265cdf0e10cSrcweir
ClearPrintRanges(SCTAB nTab)5266cdf0e10cSrcweir void ScDocument::ClearPrintRanges( SCTAB nTab )
5267cdf0e10cSrcweir {
5268cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5269cdf0e10cSrcweir pTab[nTab]->ClearPrintRanges();
5270cdf0e10cSrcweir }
5271cdf0e10cSrcweir
5272cdf0e10cSrcweir
AddPrintRange(SCTAB nTab,const ScRange & rNew)5273cdf0e10cSrcweir void ScDocument::AddPrintRange( SCTAB nTab, const ScRange& rNew )
5274cdf0e10cSrcweir {
5275cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5276cdf0e10cSrcweir pTab[nTab]->AddPrintRange( rNew );
5277cdf0e10cSrcweir }
5278cdf0e10cSrcweir
5279cdf0e10cSrcweir
5280cdf0e10cSrcweir //UNUSED2009-05 void ScDocument::SetPrintRange( SCTAB nTab, const ScRange& rNew )
5281cdf0e10cSrcweir //UNUSED2009-05 {
5282cdf0e10cSrcweir //UNUSED2009-05 if (ValidTab(nTab) && pTab[nTab])
5283cdf0e10cSrcweir //UNUSED2009-05 pTab[nTab]->SetPrintRange( rNew );
5284cdf0e10cSrcweir //UNUSED2009-05 }
5285cdf0e10cSrcweir
5286cdf0e10cSrcweir
SetPrintEntireSheet(SCTAB nTab)5287cdf0e10cSrcweir void ScDocument::SetPrintEntireSheet( SCTAB nTab )
5288cdf0e10cSrcweir {
5289cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5290cdf0e10cSrcweir pTab[nTab]->SetPrintEntireSheet();
5291cdf0e10cSrcweir }
5292cdf0e10cSrcweir
5293cdf0e10cSrcweir
SetRepeatColRange(SCTAB nTab,const ScRange * pNew)5294cdf0e10cSrcweir void ScDocument::SetRepeatColRange( SCTAB nTab, const ScRange* pNew )
5295cdf0e10cSrcweir {
5296cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5297cdf0e10cSrcweir pTab[nTab]->SetRepeatColRange( pNew );
5298cdf0e10cSrcweir }
5299cdf0e10cSrcweir
5300cdf0e10cSrcweir
SetRepeatRowRange(SCTAB nTab,const ScRange * pNew)5301cdf0e10cSrcweir void ScDocument::SetRepeatRowRange( SCTAB nTab, const ScRange* pNew )
5302cdf0e10cSrcweir {
5303cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5304cdf0e10cSrcweir pTab[nTab]->SetRepeatRowRange( pNew );
5305cdf0e10cSrcweir }
5306cdf0e10cSrcweir
5307cdf0e10cSrcweir
CreatePrintRangeSaver() const5308cdf0e10cSrcweir ScPrintRangeSaver* ScDocument::CreatePrintRangeSaver() const
5309cdf0e10cSrcweir {
5310cdf0e10cSrcweir SCTAB nCount = GetTableCount();
5311cdf0e10cSrcweir ScPrintRangeSaver* pNew = new ScPrintRangeSaver( nCount );
5312cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
5313cdf0e10cSrcweir if (pTab[i])
5314cdf0e10cSrcweir pTab[i]->FillPrintSaver( pNew->GetTabData(i) );
5315cdf0e10cSrcweir return pNew;
5316cdf0e10cSrcweir }
5317cdf0e10cSrcweir
5318cdf0e10cSrcweir
RestorePrintRanges(const ScPrintRangeSaver & rSaver)5319cdf0e10cSrcweir void ScDocument::RestorePrintRanges( const ScPrintRangeSaver& rSaver )
5320cdf0e10cSrcweir {
5321cdf0e10cSrcweir SCTAB nCount = rSaver.GetTabCount();
5322cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
5323cdf0e10cSrcweir if (pTab[i])
5324cdf0e10cSrcweir pTab[i]->RestorePrintRanges( rSaver.GetTabData(i) );
5325cdf0e10cSrcweir }
5326cdf0e10cSrcweir
5327cdf0e10cSrcweir
NeedPageResetAfterTab(SCTAB nTab) const5328cdf0e10cSrcweir sal_Bool ScDocument::NeedPageResetAfterTab( SCTAB nTab ) const
5329cdf0e10cSrcweir {
5330cdf0e10cSrcweir // Die Seitennummern-Zaehlung faengt bei einer Tabelle neu an, wenn eine
5331cdf0e10cSrcweir // andere Vorlage als bei der vorherigen gesetzt ist (nur Namen vergleichen)
5332cdf0e10cSrcweir // und eine Seitennummer angegeben ist (nicht 0)
5333cdf0e10cSrcweir
5334cdf0e10cSrcweir if ( nTab < MAXTAB && pTab[nTab] && pTab[nTab+1] )
5335cdf0e10cSrcweir {
5336cdf0e10cSrcweir String aNew = pTab[nTab+1]->GetPageStyle();
5337cdf0e10cSrcweir if ( aNew != pTab[nTab]->GetPageStyle() )
5338cdf0e10cSrcweir {
5339cdf0e10cSrcweir SfxStyleSheetBase* pStyle = xPoolHelper->GetStylePool()->Find( aNew, SFX_STYLE_FAMILY_PAGE );
5340cdf0e10cSrcweir if ( pStyle )
5341cdf0e10cSrcweir {
5342cdf0e10cSrcweir const SfxItemSet& rSet = pStyle->GetItemSet();
5343cdf0e10cSrcweir sal_uInt16 nFirst = ((const SfxUInt16Item&)rSet.Get(ATTR_PAGE_FIRSTPAGENO)).GetValue();
5344cdf0e10cSrcweir if ( nFirst != 0 )
5345cdf0e10cSrcweir return sal_True; // Seitennummer in neuer Vorlage angegeben
5346cdf0e10cSrcweir }
5347cdf0e10cSrcweir }
5348cdf0e10cSrcweir }
5349cdf0e10cSrcweir
5350cdf0e10cSrcweir return sal_False; // sonst nicht
5351cdf0e10cSrcweir }
5352cdf0e10cSrcweir
GetUndoManager()5353cdf0e10cSrcweir SfxUndoManager* ScDocument::GetUndoManager()
5354cdf0e10cSrcweir {
5355cdf0e10cSrcweir if (!mpUndoManager)
535614af77b6SArmin Le Grand {
535714af77b6SArmin Le Grand // to support enhanced text edit for draw objects, use an SdrUndoManager
535814af77b6SArmin Le Grand mpUndoManager = new SdrUndoManager;
535914af77b6SArmin Le Grand }
536014af77b6SArmin Le Grand
5361cdf0e10cSrcweir return mpUndoManager;
5362cdf0e10cSrcweir }
5363cdf0e10cSrcweir
GetRowBreakIterator(SCTAB nTab) const5364cdf0e10cSrcweir ScRowBreakIterator* ScDocument::GetRowBreakIterator(SCTAB nTab) const
5365cdf0e10cSrcweir {
5366cdf0e10cSrcweir if (ValidTab(nTab) && pTab[nTab])
5367cdf0e10cSrcweir return new ScRowBreakIterator(pTab[nTab]->maRowPageBreaks);
5368cdf0e10cSrcweir return NULL;
5369cdf0e10cSrcweir }
5370cdf0e10cSrcweir
EnableUndo(bool bVal)5371cdf0e10cSrcweir void ScDocument::EnableUndo( bool bVal )
5372cdf0e10cSrcweir {
5373cdf0e10cSrcweir GetUndoManager()->EnableUndo(bVal);
5374cdf0e10cSrcweir if( pDrawLayer ) pDrawLayer->EnableUndo(bVal);
5375cdf0e10cSrcweir mbUndoEnabled = bVal;
5376cdf0e10cSrcweir }
5377cdf0e10cSrcweir
IsInVBAMode() const5378cdf0e10cSrcweir bool ScDocument::IsInVBAMode() const
5379cdf0e10cSrcweir {
5380cdf0e10cSrcweir bool bResult = false;
5381cdf0e10cSrcweir if ( pShell )
5382cdf0e10cSrcweir {
5383cdf0e10cSrcweir com::sun::star::uno::Reference< com::sun::star::script::vba::XVBACompatibility > xVBA( pShell->GetBasicContainer(), com::sun::star::uno::UNO_QUERY );
5384cdf0e10cSrcweir bResult = xVBA.is() && xVBA->getVBACompatibilityMode();
5385cdf0e10cSrcweir }
5386cdf0e10cSrcweir return bResult;
5387cdf0e10cSrcweir }
5388