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
28cdf0e10cSrcweir // INCLUDE ---------------------------------------------------------------
29cdf0e10cSrcweir #include "xmlsubti.hxx"
30cdf0e10cSrcweir #include "global.hxx"
31cdf0e10cSrcweir #include "xmlstyli.hxx"
32cdf0e10cSrcweir #include "xmlimprt.hxx"
33cdf0e10cSrcweir #include "document.hxx"
34cdf0e10cSrcweir #include "markdata.hxx"
35cdf0e10cSrcweir #include "XMLConverter.hxx"
36cdf0e10cSrcweir #include "docuno.hxx"
37cdf0e10cSrcweir #include "cellsuno.hxx"
38cdf0e10cSrcweir #include "XMLStylesImportHelper.hxx"
39cdf0e10cSrcweir #include "sheetdata.hxx"
40cdf0e10cSrcweir #include "tabprotection.hxx"
41cdf0e10cSrcweir #include <svx/svdpage.hxx>
42cdf0e10cSrcweir
43cdf0e10cSrcweir #include <xmloff/xmltkmap.hxx>
44cdf0e10cSrcweir #include <xmloff/nmspmap.hxx>
45cdf0e10cSrcweir #include <xmloff/xmluconv.hxx>
46cdf0e10cSrcweir #include <xmloff/xmlerror.hxx>
47cdf0e10cSrcweir #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
48cdf0e10cSrcweir #include <com/sun/star/util/XMergeable.hpp>
49cdf0e10cSrcweir #include <com/sun/star/sheet/XSheetCellRange.hpp>
50cdf0e10cSrcweir #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
51cdf0e10cSrcweir #include <com/sun/star/sheet/CellInsertMode.hpp>
52cdf0e10cSrcweir #include <com/sun/star/sheet/XCellRangeMovement.hpp>
53cdf0e10cSrcweir #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
54cdf0e10cSrcweir #include <com/sun/star/container/XNamed.hpp>
55cdf0e10cSrcweir #include <com/sun/star/util/XProtectable.hpp>
56cdf0e10cSrcweir #include <com/sun/star/sheet/XArrayFormulaRange.hpp>
57cdf0e10cSrcweir
58cdf0e10cSrcweir #include <memory>
59cdf0e10cSrcweir
60cdf0e10cSrcweir using ::std::auto_ptr;
61cdf0e10cSrcweir
62cdf0e10cSrcweir //------------------------------------------------------------------
63cdf0e10cSrcweir
64cdf0e10cSrcweir using namespace com::sun::star;
65cdf0e10cSrcweir
ScMyTableData(sal_Int32 nSheet,sal_Int32 nCol,sal_Int32 nRow)66cdf0e10cSrcweir ScMyTableData::ScMyTableData(sal_Int32 nSheet, sal_Int32 nCol, sal_Int32 nRow)
67cdf0e10cSrcweir : nColsPerCol(nDefaultColCount, 1),
68cdf0e10cSrcweir nRealCols(nDefaultColCount + 1, 0),
69cdf0e10cSrcweir nRowsPerRow(nDefaultRowCount, 1),
70cdf0e10cSrcweir nRealRows(nDefaultRowCount + 1, 0),
71cdf0e10cSrcweir nChangedCols()
72cdf0e10cSrcweir {
73cdf0e10cSrcweir aTableCellPos.Sheet = sal::static_int_cast<sal_Int16>( nSheet );
74cdf0e10cSrcweir aTableCellPos.Column = nCol;
75cdf0e10cSrcweir aTableCellPos.Row = nRow;
76cdf0e10cSrcweir
77cdf0e10cSrcweir for (sal_Int32 i = 0; i < 3; ++i)
78cdf0e10cSrcweir nRealCols[i] = i;
79cdf0e10cSrcweir for (sal_Int32 j = 0; j < 3; ++j)
80cdf0e10cSrcweir nRealRows[j] = j;
81cdf0e10cSrcweir
82cdf0e10cSrcweir nSpannedCols = 1;
83cdf0e10cSrcweir nColCount = 0;
84cdf0e10cSrcweir nSubTableSpanned = 1;
85cdf0e10cSrcweir }
86cdf0e10cSrcweir
~ScMyTableData()87cdf0e10cSrcweir ScMyTableData::~ScMyTableData()
88cdf0e10cSrcweir {
89cdf0e10cSrcweir }
90cdf0e10cSrcweir
AddRow()91cdf0e10cSrcweir void ScMyTableData::AddRow()
92cdf0e10cSrcweir {
93cdf0e10cSrcweir ++aTableCellPos.Row;
94cdf0e10cSrcweir if (static_cast<sal_uInt32>(aTableCellPos.Row) >= nRowsPerRow.size())
95cdf0e10cSrcweir {
96cdf0e10cSrcweir nRowsPerRow.resize(nRowsPerRow.size() + nDefaultRowCount, 1);
97cdf0e10cSrcweir nRealRows.resize(nRowsPerRow.size() + nDefaultRowCount + 1, 0);
98cdf0e10cSrcweir }
99cdf0e10cSrcweir nRealRows[aTableCellPos.Row + 1] = nRealRows[aTableCellPos.Row] + nRowsPerRow[aTableCellPos.Row];
100cdf0e10cSrcweir }
101cdf0e10cSrcweir
AddColumn()102cdf0e10cSrcweir void ScMyTableData::AddColumn()
103cdf0e10cSrcweir {
104cdf0e10cSrcweir ++aTableCellPos.Column;
105cdf0e10cSrcweir if (static_cast<sal_uInt32>(aTableCellPos.Column) >= nColsPerCol.size())
106cdf0e10cSrcweir {
107cdf0e10cSrcweir nColsPerCol.resize(nColsPerCol.size() + nDefaultColCount, 1);
108cdf0e10cSrcweir nRealCols.resize(nColsPerCol.size() + nDefaultColCount + 1, 0);
109cdf0e10cSrcweir }
110cdf0e10cSrcweir nRealCols[aTableCellPos.Column + 1] = nRealCols[aTableCellPos.Column] + nColsPerCol[aTableCellPos.Column];
111cdf0e10cSrcweir }
112cdf0e10cSrcweir
GetRealCols(const sal_Int32 nIndex,const sal_Bool) const113cdf0e10cSrcweir sal_Int32 ScMyTableData::GetRealCols(const sal_Int32 nIndex, const sal_Bool /* bIsNormal */) const
114cdf0e10cSrcweir {
115cdf0e10cSrcweir return (nIndex < 0) ? 0 : nRealCols[nIndex];
116cdf0e10cSrcweir }
117cdf0e10cSrcweir
GetChangedCols(const sal_Int32 nFromIndex,const sal_Int32 nToIndex) const118cdf0e10cSrcweir sal_Int32 ScMyTableData::GetChangedCols(const sal_Int32 nFromIndex, const sal_Int32 nToIndex) const
119cdf0e10cSrcweir {
120cdf0e10cSrcweir ScMysalIntList::const_iterator i(nChangedCols.begin());
121cdf0e10cSrcweir ScMysalIntList::const_iterator endi(nChangedCols.end());
122cdf0e10cSrcweir while ((i != endi) && ((*i < nToIndex) && !(*i >= nFromIndex)))
123cdf0e10cSrcweir ++i;
124cdf0e10cSrcweir if (i == endi)
125cdf0e10cSrcweir return -1;
126cdf0e10cSrcweir else
127cdf0e10cSrcweir if ((*i >= nFromIndex) && (*i < nToIndex))
128cdf0e10cSrcweir return *i;
129cdf0e10cSrcweir else
130cdf0e10cSrcweir return -1;
131cdf0e10cSrcweir }
132cdf0e10cSrcweir
SetChangedCols(const sal_Int32 nValue)133cdf0e10cSrcweir void ScMyTableData::SetChangedCols(const sal_Int32 nValue)
134cdf0e10cSrcweir {
135cdf0e10cSrcweir ScMysalIntList::iterator i(nChangedCols.begin());
136cdf0e10cSrcweir ScMysalIntList::iterator endi(nChangedCols.end());
137cdf0e10cSrcweir while ((i != endi) && (*i < nValue))
138cdf0e10cSrcweir {
139cdf0e10cSrcweir ++i;
140cdf0e10cSrcweir }
141cdf0e10cSrcweir if ((i == endi) || (*i != nValue))
142cdf0e10cSrcweir nChangedCols.insert(i, nValue);
143cdf0e10cSrcweir }
144cdf0e10cSrcweir
145cdf0e10cSrcweir /*******************************************************************************************************************************/
146cdf0e10cSrcweir
ScMyTables(ScXMLImport & rTempImport)147cdf0e10cSrcweir ScMyTables::ScMyTables(ScXMLImport& rTempImport)
148cdf0e10cSrcweir : rImport(rTempImport),
149cdf0e10cSrcweir aResizeShapes(rTempImport),
150cdf0e10cSrcweir nCurrentColStylePos(0),
151cdf0e10cSrcweir nCurrentDrawPage( -1 ),
152cdf0e10cSrcweir nCurrentXShapes( -1 ),
153cdf0e10cSrcweir nTableCount( 0 ),
154cdf0e10cSrcweir nCurrentSheet( -1 )
155cdf0e10cSrcweir {
156cdf0e10cSrcweir aTableVec.resize(nDefaultTabCount, NULL);
157cdf0e10cSrcweir }
158cdf0e10cSrcweir
~ScMyTables()159cdf0e10cSrcweir ScMyTables::~ScMyTables()
160cdf0e10cSrcweir {
161cdf0e10cSrcweir ScMyTableData* pTable;
162cdf0e10cSrcweir while (nTableCount > 0)
163cdf0e10cSrcweir {
164cdf0e10cSrcweir pTable = aTableVec[nTableCount - 1];
165cdf0e10cSrcweir delete pTable;
166cdf0e10cSrcweir aTableVec[nTableCount - 1] = NULL;
167cdf0e10cSrcweir --nTableCount;
168cdf0e10cSrcweir }
169cdf0e10cSrcweir }
170cdf0e10cSrcweir
NewSheet(const rtl::OUString & sTableName,const rtl::OUString & sStyleName,const sal_Bool bTempProtection,const rtl::OUString & sTempPassword)171cdf0e10cSrcweir void ScMyTables::NewSheet(const rtl::OUString& sTableName, const rtl::OUString& sStyleName,
172cdf0e10cSrcweir const sal_Bool bTempProtection, const rtl::OUString& sTempPassword)
173cdf0e10cSrcweir {
174cdf0e10cSrcweir if (rImport.GetModel().is())
175cdf0e10cSrcweir {
176cdf0e10cSrcweir nCurrentColStylePos = 0;
177cdf0e10cSrcweir sCurrentSheetName = sTableName;
178cdf0e10cSrcweir ScMyTableData* aTable;
179cdf0e10cSrcweir while (nTableCount > 0)
180cdf0e10cSrcweir {
181cdf0e10cSrcweir aTable = aTableVec[nTableCount - 1];
182cdf0e10cSrcweir delete aTable;
183cdf0e10cSrcweir aTableVec[nTableCount - 1] = NULL;
184cdf0e10cSrcweir --nTableCount;
185cdf0e10cSrcweir }
186cdf0e10cSrcweir ++nCurrentSheet;
187cdf0e10cSrcweir
188cdf0e10cSrcweir bProtection = bTempProtection;
189cdf0e10cSrcweir sPassword = sTempPassword;
190cdf0e10cSrcweir uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( rImport.GetModel(), uno::UNO_QUERY );
191cdf0e10cSrcweir if ( xSpreadDoc.is() )
192cdf0e10cSrcweir {
193cdf0e10cSrcweir uno::Reference <sheet::XSpreadsheets> xSheets(xSpreadDoc->getSheets());
194cdf0e10cSrcweir if (xSheets.is())
195cdf0e10cSrcweir {
196cdf0e10cSrcweir if (nCurrentSheet > 0)
197cdf0e10cSrcweir {
198cdf0e10cSrcweir try
199cdf0e10cSrcweir {
200cdf0e10cSrcweir xSheets->insertNewByName(sTableName, sal::static_int_cast<sal_Int16>(nCurrentSheet));
201cdf0e10cSrcweir }
202cdf0e10cSrcweir catch ( uno::RuntimeException& )
203cdf0e10cSrcweir {
204cdf0e10cSrcweir ScDocument *pDoc = ScXMLConverter::GetScDocument(rImport.GetModel());
205cdf0e10cSrcweir if (pDoc)
206cdf0e10cSrcweir {
207cdf0e10cSrcweir rImport.LockSolarMutex();
208cdf0e10cSrcweir String sTabName(String::CreateFromAscii("Table"));
209cdf0e10cSrcweir pDoc->CreateValidTabName(sTabName);
210cdf0e10cSrcweir rtl::OUString sOUTabName(sTabName);
211cdf0e10cSrcweir xSheets->insertNewByName(sOUTabName, sal::static_int_cast<sal_Int16>(nCurrentSheet));
212cdf0e10cSrcweir rImport.UnlockSolarMutex();
213cdf0e10cSrcweir }
214cdf0e10cSrcweir }
215cdf0e10cSrcweir }
216cdf0e10cSrcweir uno::Reference <container::XIndexAccess> xIndex( xSheets, uno::UNO_QUERY );
217cdf0e10cSrcweir if ( xIndex.is() )
218cdf0e10cSrcweir {
219cdf0e10cSrcweir xCurrentSheet.set(xIndex->getByIndex(nCurrentSheet), uno::UNO_QUERY);
220cdf0e10cSrcweir if ( xCurrentSheet.is() )
221cdf0e10cSrcweir {
222cdf0e10cSrcweir xCurrentCellRange.set(xCurrentSheet, uno::UNO_QUERY);
223cdf0e10cSrcweir if (!(nCurrentSheet > 0))
224cdf0e10cSrcweir {
225cdf0e10cSrcweir uno::Reference < container::XNamed > xNamed(xCurrentSheet, uno::UNO_QUERY );
226cdf0e10cSrcweir if ( xNamed.is() )
227cdf0e10cSrcweir try
228cdf0e10cSrcweir {
229cdf0e10cSrcweir xNamed->setName(sTableName);
230cdf0e10cSrcweir }
231cdf0e10cSrcweir catch ( uno::RuntimeException& )
232cdf0e10cSrcweir {
233cdf0e10cSrcweir ScDocument *pDoc = ScXMLConverter::GetScDocument(rImport.GetModel());
234cdf0e10cSrcweir if (pDoc)
235cdf0e10cSrcweir {
236cdf0e10cSrcweir rImport.LockSolarMutex();
237cdf0e10cSrcweir String sTabName(String::CreateFromAscii("Table"));
238cdf0e10cSrcweir pDoc->CreateValidTabName(sTabName);
239cdf0e10cSrcweir rtl::OUString sOUTabName(sTabName);
240cdf0e10cSrcweir xNamed->setName(sOUTabName);
241cdf0e10cSrcweir rImport.UnlockSolarMutex();
242cdf0e10cSrcweir }
243cdf0e10cSrcweir }
244cdf0e10cSrcweir }
245cdf0e10cSrcweir rImport.SetTableStyle(sStyleName);
246cdf0e10cSrcweir
247cdf0e10cSrcweir if ( sStyleName.getLength() )
248cdf0e10cSrcweir {
249cdf0e10cSrcweir // #i57869# All table style properties for all sheets are now applied here,
250cdf0e10cSrcweir // before importing the contents.
251cdf0e10cSrcweir // This is needed for the background color.
252cdf0e10cSrcweir // Sheet visibility has special handling in ScDocFunc::SetTableVisible to
253cdf0e10cSrcweir // allow hiding the first sheet.
254cdf0e10cSrcweir // RTL layout is only remembered, not actually applied, so the shapes can
255cdf0e10cSrcweir // be loaded before mirroring.
256cdf0e10cSrcweir
257cdf0e10cSrcweir uno::Reference <beans::XPropertySet> xProperties(xCurrentSheet, uno::UNO_QUERY);
258cdf0e10cSrcweir if (xProperties.is())
259cdf0e10cSrcweir {
260cdf0e10cSrcweir XMLTableStylesContext *pStyles = (XMLTableStylesContext *)rImport.GetAutoStyles();
261cdf0e10cSrcweir if (pStyles)
262cdf0e10cSrcweir {
263cdf0e10cSrcweir XMLTableStyleContext* pStyle = (XMLTableStyleContext *)pStyles->FindStyleChildContext(
264cdf0e10cSrcweir XML_STYLE_FAMILY_TABLE_TABLE, sStyleName, sal_True);
265cdf0e10cSrcweir if (pStyle)
266cdf0e10cSrcweir {
267cdf0e10cSrcweir pStyle->FillPropertySet(xProperties);
268cdf0e10cSrcweir
269cdf0e10cSrcweir ScSheetSaveData* pSheetData = ScModelObj::getImplementation(rImport.GetModel())->GetSheetSaveData();
270cdf0e10cSrcweir pSheetData->AddTableStyle( sStyleName, ScAddress( 0, 0, (SCTAB)nCurrentSheet ) );
271cdf0e10cSrcweir }
272cdf0e10cSrcweir }
273cdf0e10cSrcweir }
274cdf0e10cSrcweir }
275cdf0e10cSrcweir }
276cdf0e10cSrcweir
277cdf0e10cSrcweir }
278cdf0e10cSrcweir }
279cdf0e10cSrcweir }
280cdf0e10cSrcweir }
281cdf0e10cSrcweir
282cdf0e10cSrcweir NewTable(1);
283cdf0e10cSrcweir }
284cdf0e10cSrcweir
IsMerged(const uno::Reference<table::XCellRange> & xCellRange,const sal_Int32 nCol,const sal_Int32 nRow,table::CellRangeAddress & aCellAddress) const285cdf0e10cSrcweir sal_Bool ScMyTables::IsMerged (const uno::Reference <table::XCellRange>& xCellRange, const sal_Int32 nCol, const sal_Int32 nRow,
286cdf0e10cSrcweir table::CellRangeAddress& aCellAddress) const
287cdf0e10cSrcweir {
288cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCellRange->getCellRangeByPosition(nCol,nRow,nCol,nRow), uno::UNO_QUERY);
289cdf0e10cSrcweir if (xMergeable.is())
290cdf0e10cSrcweir {
291cdf0e10cSrcweir uno::Reference<sheet::XSheetCellRange> xMergeSheetCellRange (xMergeable, uno::UNO_QUERY);
292cdf0e10cSrcweir uno::Reference<sheet::XSpreadsheet> xTable(xMergeSheetCellRange->getSpreadsheet());
293cdf0e10cSrcweir uno::Reference<sheet::XSheetCellCursor> xMergeSheetCursor(xTable->createCursorByRange(xMergeSheetCellRange));
294cdf0e10cSrcweir if (xMergeSheetCursor.is())
295cdf0e10cSrcweir {
296cdf0e10cSrcweir xMergeSheetCursor->collapseToMergedArea();
297cdf0e10cSrcweir uno::Reference<sheet::XCellRangeAddressable> xMergeCellAddress (xMergeSheetCursor, uno::UNO_QUERY);
298cdf0e10cSrcweir if (xMergeCellAddress.is())
299cdf0e10cSrcweir {
300cdf0e10cSrcweir aCellAddress = xMergeCellAddress->getRangeAddress();
301cdf0e10cSrcweir if (aCellAddress.StartColumn == nCol && aCellAddress.EndColumn == nCol &&
302cdf0e10cSrcweir aCellAddress.StartRow == nRow && aCellAddress.EndRow == nRow)
303cdf0e10cSrcweir return sal_False;
304cdf0e10cSrcweir else
305cdf0e10cSrcweir return sal_True;
306cdf0e10cSrcweir }
307cdf0e10cSrcweir }
308cdf0e10cSrcweir }
309cdf0e10cSrcweir return sal_False;
310cdf0e10cSrcweir }
311cdf0e10cSrcweir
UnMerge()312cdf0e10cSrcweir void ScMyTables::UnMerge()
313cdf0e10cSrcweir {
314cdf0e10cSrcweir if ( xCurrentCellRange.is() )
315cdf0e10cSrcweir {
316cdf0e10cSrcweir table::CellRangeAddress aCellAddress;
317cdf0e10cSrcweir if (IsMerged(xCurrentCellRange, GetRealCellPos().Column, GetRealCellPos().Row, aCellAddress))
318cdf0e10cSrcweir {
319cdf0e10cSrcweir //unmerge
320cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
321cdf0e10cSrcweir aCellAddress.EndColumn, aCellAddress.EndRow), uno::UNO_QUERY);
322cdf0e10cSrcweir if (xMergeable.is())
323cdf0e10cSrcweir xMergeable->merge(sal_False);
324cdf0e10cSrcweir }
325cdf0e10cSrcweir }
326cdf0e10cSrcweir }
327cdf0e10cSrcweir
DoMerge(sal_Int32 nCount)328cdf0e10cSrcweir void ScMyTables::DoMerge(sal_Int32 nCount)
329cdf0e10cSrcweir {
330cdf0e10cSrcweir if ( xCurrentCellRange.is() )
331cdf0e10cSrcweir {
332cdf0e10cSrcweir table::CellRangeAddress aCellAddress;
333cdf0e10cSrcweir if (IsMerged(xCurrentCellRange, GetRealCellPos().Column, GetRealCellPos().Row, aCellAddress))
334cdf0e10cSrcweir {
335cdf0e10cSrcweir //unmerge
336cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
337cdf0e10cSrcweir aCellAddress.EndColumn, aCellAddress.EndRow), uno::UNO_QUERY);
338cdf0e10cSrcweir if (xMergeable.is())
339cdf0e10cSrcweir xMergeable->merge(sal_False);
340cdf0e10cSrcweir }
341cdf0e10cSrcweir
342cdf0e10cSrcweir //merge
343cdf0e10cSrcweir uno::Reference <table::XCellRange> xMergeCellRange;
344cdf0e10cSrcweir if (nCount == -1)
345cdf0e10cSrcweir xMergeCellRange.set(xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
346cdf0e10cSrcweir aCellAddress.EndColumn
347cdf0e10cSrcweir + aTableVec[nTableCount - 1]->GetColsPerCol(aTableVec[nTableCount - 1]->GetColumn()) - 1,
348cdf0e10cSrcweir aCellAddress.EndRow
349cdf0e10cSrcweir + aTableVec[nTableCount - 1]->GetRowsPerRow(aTableVec[nTableCount - 1]->GetRow()) - 1));
350cdf0e10cSrcweir else
351cdf0e10cSrcweir xMergeCellRange.set(xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
352cdf0e10cSrcweir aCellAddress.StartColumn
353cdf0e10cSrcweir + nCount - 1,
354cdf0e10cSrcweir aCellAddress.EndRow));
355cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xMergeCellRange, uno::UNO_QUERY);
356cdf0e10cSrcweir if (xMergeable.is())
357cdf0e10cSrcweir xMergeable->merge(sal_True);
358cdf0e10cSrcweir }
359cdf0e10cSrcweir }
360cdf0e10cSrcweir
InsertRow()361cdf0e10cSrcweir void ScMyTables::InsertRow()
362cdf0e10cSrcweir {
363cdf0e10cSrcweir if ( xCurrentCellRange.is() )
364cdf0e10cSrcweir {
365cdf0e10cSrcweir table::CellRangeAddress aCellAddress;
366cdf0e10cSrcweir sal_Int32 nRow(GetRealCellPos().Row);
367cdf0e10cSrcweir for (sal_Int32 j = 0; j < GetRealCellPos().Column - aTableVec[nTableCount - 1]->GetColumn() - 1; ++j)
368cdf0e10cSrcweir {
369cdf0e10cSrcweir if (IsMerged(xCurrentCellRange, j, nRow - 1, aCellAddress))
370cdf0e10cSrcweir {
371cdf0e10cSrcweir //unmerge
372cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
373cdf0e10cSrcweir aCellAddress.EndColumn, aCellAddress.EndRow), uno::UNO_QUERY);
374cdf0e10cSrcweir if (xMergeable.is())
375cdf0e10cSrcweir xMergeable->merge(sal_False);
376cdf0e10cSrcweir }
377cdf0e10cSrcweir
378cdf0e10cSrcweir //merge
379cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
380cdf0e10cSrcweir aCellAddress.EndColumn, aCellAddress.EndRow + 1), uno::UNO_QUERY);
381cdf0e10cSrcweir if (xMergeable.is())
382cdf0e10cSrcweir xMergeable->merge(sal_True);
383cdf0e10cSrcweir j += aCellAddress.EndColumn - aCellAddress.StartColumn;
384cdf0e10cSrcweir }
385cdf0e10cSrcweir rImport.GetStylesImportHelper()->InsertRow(nRow, nCurrentSheet, rImport.GetDocument());
386cdf0e10cSrcweir }
387cdf0e10cSrcweir }
388cdf0e10cSrcweir
NewRow()389cdf0e10cSrcweir void ScMyTables::NewRow()
390cdf0e10cSrcweir {
391cdf0e10cSrcweir if (nTableCount > 1)
392cdf0e10cSrcweir if (aTableVec[nTableCount - 1]->GetRealRows(aTableVec[nTableCount - 1]->GetRow()) >
393cdf0e10cSrcweir aTableVec[nTableCount - 2]->GetRowsPerRow(aTableVec[nTableCount - 2]->GetRow()) - 1)
394cdf0e10cSrcweir {
395cdf0e10cSrcweir if (GetRealCellPos().Column > 0)
396cdf0e10cSrcweir InsertRow();
397cdf0e10cSrcweir for (sal_Int16 i = sal::static_int_cast<sal_Int16>(nTableCount - 1); i > 0; i--)
398cdf0e10cSrcweir {
399cdf0e10cSrcweir sal_Int32 nRow = aTableVec[i - 1]->GetRow();
400cdf0e10cSrcweir aTableVec[i - 1]->SetRowsPerRow(nRow,
401cdf0e10cSrcweir aTableVec[i - 1]->GetRowsPerRow(nRow) + 1);
402cdf0e10cSrcweir aTableVec[i - 1]->SetRealRows(nRow + 1,
403cdf0e10cSrcweir aTableVec[i - 1]->GetRealRows(nRow)
404cdf0e10cSrcweir + aTableVec[i - 1]->GetRowsPerRow(nRow));
405cdf0e10cSrcweir }
406cdf0e10cSrcweir }
407cdf0e10cSrcweir }
408cdf0e10cSrcweir
AddRow()409cdf0e10cSrcweir void ScMyTables::AddRow()
410cdf0e10cSrcweir {
411cdf0e10cSrcweir aTableVec[nTableCount - 1]->AddRow();
412cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetFirstColumn();
413cdf0e10cSrcweir sal_Int32 nRow = aTableVec[nTableCount - 1]->GetRow();
414cdf0e10cSrcweir if (nRow > 0)
415cdf0e10cSrcweir NewRow();
416cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetRealRows(nRow + 1,
417cdf0e10cSrcweir aTableVec[nTableCount - 1]->GetRealRows(nRow)
418cdf0e10cSrcweir + aTableVec[nTableCount - 1]->GetRowsPerRow(nRow));
419cdf0e10cSrcweir }
420cdf0e10cSrcweir
SetRowStyle(const rtl::OUString & rCellStyleName)421cdf0e10cSrcweir void ScMyTables::SetRowStyle(const rtl::OUString& rCellStyleName)
422cdf0e10cSrcweir {
423cdf0e10cSrcweir rImport.GetStylesImportHelper()->SetRowStyle(rCellStyleName);
424cdf0e10cSrcweir }
425cdf0e10cSrcweir
InsertColumn()426cdf0e10cSrcweir void ScMyTables::InsertColumn()
427cdf0e10cSrcweir {
428cdf0e10cSrcweir if ( xCurrentCellRange.is() )
429cdf0e10cSrcweir {
430cdf0e10cSrcweir table::CellRangeAddress aCellAddress;
431cdf0e10cSrcweir sal_Int32 nCol(GetRealCellPos().Column);
432cdf0e10cSrcweir for (sal_Int32 j = 0; j <= GetRealCellPos().Row - aTableVec[nTableCount - 1]->GetRow() - 1; ++j)
433cdf0e10cSrcweir {
434cdf0e10cSrcweir table::CellRangeAddress aTempCellAddress;
435cdf0e10cSrcweir if (IsMerged(xCurrentCellRange, nCol - 1, j, aCellAddress))
436cdf0e10cSrcweir {
437cdf0e10cSrcweir //unmerge
438cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
439cdf0e10cSrcweir aCellAddress.EndColumn, aCellAddress.EndRow), uno::UNO_QUERY);
440cdf0e10cSrcweir if (xMergeable.is())
441cdf0e10cSrcweir xMergeable->merge(sal_False);
442cdf0e10cSrcweir aTempCellAddress = aCellAddress;
443cdf0e10cSrcweir aTempCellAddress.StartColumn = aTempCellAddress.EndColumn + 1;
444cdf0e10cSrcweir aTempCellAddress.EndColumn = aTempCellAddress.StartColumn;
445cdf0e10cSrcweir }
446cdf0e10cSrcweir else
447cdf0e10cSrcweir {
448cdf0e10cSrcweir aTempCellAddress = aCellAddress;
449cdf0e10cSrcweir aTempCellAddress.StartColumn += 1;
450cdf0e10cSrcweir aTempCellAddress.EndColumn = aTempCellAddress.StartColumn;
451cdf0e10cSrcweir }
452cdf0e10cSrcweir
453cdf0e10cSrcweir //insert Cell
454cdf0e10cSrcweir sheet::CellInsertMode aCellInsertMode(sheet::CellInsertMode_RIGHT);
455cdf0e10cSrcweir uno::Reference <sheet::XCellRangeMovement> xCellRangeMovement (xCurrentSheet, uno::UNO_QUERY);
456cdf0e10cSrcweir xCellRangeMovement->insertCells(aTempCellAddress, aCellInsertMode);
457cdf0e10cSrcweir
458cdf0e10cSrcweir //merge
459cdf0e10cSrcweir uno::Reference <util::XMergeable> xMergeable (xCurrentCellRange->getCellRangeByPosition(aCellAddress.StartColumn, aCellAddress.StartRow,
460cdf0e10cSrcweir aCellAddress.EndColumn + 1, aCellAddress.EndRow), uno::UNO_QUERY);
461cdf0e10cSrcweir if (xMergeable.is())
462cdf0e10cSrcweir xMergeable->merge(sal_True);
463cdf0e10cSrcweir j += aCellAddress.EndRow - aCellAddress.StartRow;
464cdf0e10cSrcweir }
465cdf0e10cSrcweir rImport.GetStylesImportHelper()->InsertCol(nCol, nCurrentSheet, rImport.GetDocument());
466cdf0e10cSrcweir }
467cdf0e10cSrcweir }
468cdf0e10cSrcweir
NewColumn(sal_Bool bIsCovered)469cdf0e10cSrcweir void ScMyTables::NewColumn(sal_Bool bIsCovered)
470cdf0e10cSrcweir {
471cdf0e10cSrcweir if (!bIsCovered)
472cdf0e10cSrcweir {
473cdf0e10cSrcweir sal_Int32 nColCount(aTableVec[nTableCount - 1]->GetColCount());
474cdf0e10cSrcweir sal_Int32 nSpannedCols(aTableVec[nTableCount - 1]->GetSpannedCols());
475cdf0e10cSrcweir if ( (nSpannedCols > nColCount) &&
476cdf0e10cSrcweir (aTableVec[nTableCount - 1]->GetRow() == 0) &&
477cdf0e10cSrcweir (aTableVec[nTableCount - 1]->GetColumn() == 0) )
478cdf0e10cSrcweir {
479cdf0e10cSrcweir if (nColCount > 0)
480cdf0e10cSrcweir {
481cdf0e10cSrcweir sal_Int32 FirstColsSpanned(nSpannedCols / nColCount);
482cdf0e10cSrcweir sal_Int32 LastColSpanned(FirstColsSpanned
483cdf0e10cSrcweir + (nSpannedCols % nColCount));
484cdf0e10cSrcweir for (sal_Int32 i = 0; i < nColCount - 1; ++i)
485cdf0e10cSrcweir {
486cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetColsPerCol(i, FirstColsSpanned);
487cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetRealCols(i + 1,
488cdf0e10cSrcweir aTableVec[nTableCount - 1]->GetRealCols(i)
489cdf0e10cSrcweir + FirstColsSpanned);
490cdf0e10cSrcweir }
491cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetColsPerCol(nColCount - 1, LastColSpanned);
492cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetRealCols(nColCount - 1 + 1,
493cdf0e10cSrcweir aTableVec[nTableCount - 1]->GetRealCols(nColCount - 1)
494cdf0e10cSrcweir + LastColSpanned);
495cdf0e10cSrcweir }
496cdf0e10cSrcweir }
497cdf0e10cSrcweir if (aTableVec[nTableCount - 1]->GetRealCols(aTableVec[nTableCount - 1]->GetColumn()) > nSpannedCols - 1)
498cdf0e10cSrcweir {
499cdf0e10cSrcweir if ( aTableVec[nTableCount - 1]->GetRow() == 0)
500cdf0e10cSrcweir {
501cdf0e10cSrcweir InsertColumn();
502cdf0e10cSrcweir for (sal_Int16 i = sal::static_int_cast<sal_Int16>(nTableCount - 1); i > 0; i--)
503cdf0e10cSrcweir {
504cdf0e10cSrcweir sal_Int32 nColPos = aTableVec[i - 1]->GetColumn() +
505cdf0e10cSrcweir aTableVec[i]->GetSpannedCols() - 1;
506cdf0e10cSrcweir aTableVec[i - 1]->SetColsPerCol(nColPos,
507cdf0e10cSrcweir aTableVec[i - 1]->GetColsPerCol(nColPos) +
508cdf0e10cSrcweir aTableVec[nTableCount - 1]->GetColsPerCol(aTableVec[nTableCount - 1]->GetColumn()));
509cdf0e10cSrcweir aTableVec[i - 1]->SetRealCols(nColPos + 1,
510cdf0e10cSrcweir aTableVec[i - 1]->GetRealCols(nColPos)
511cdf0e10cSrcweir + aTableVec[i - 1]->GetColsPerCol(nColPos));
512cdf0e10cSrcweir aTableVec[i - 1]->SetChangedCols(nColPos);
513cdf0e10cSrcweir }
514cdf0e10cSrcweir }
515cdf0e10cSrcweir }
516cdf0e10cSrcweir }
517cdf0e10cSrcweir }
518cdf0e10cSrcweir
AddColumn(sal_Bool bIsCovered)519cdf0e10cSrcweir void ScMyTables::AddColumn(sal_Bool bIsCovered)
520cdf0e10cSrcweir {
521cdf0e10cSrcweir aTableVec[nTableCount - 1]->AddColumn();
522cdf0e10cSrcweir if (aTableVec[nTableCount - 1]->GetSubTableSpanned() > 1)
523cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetSubTableSpanned(aTableVec[nTableCount - 1]->GetSubTableSpanned() - 1);
524cdf0e10cSrcweir else
525cdf0e10cSrcweir {
526cdf0e10cSrcweir NewColumn(bIsCovered);
527cdf0e10cSrcweir // if (!bIsCovered)
528cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetRealCols(aTableVec[nTableCount - 1]->GetColumn() + 1,
529cdf0e10cSrcweir aTableVec[nTableCount - 1]->GetRealCols(aTableVec[nTableCount - 1]->GetColumn())
530cdf0e10cSrcweir + aTableVec[nTableCount - 1]->GetColsPerCol(aTableVec[nTableCount - 1]->GetColumn()));
531cdf0e10cSrcweir if ((!bIsCovered) || (bIsCovered &&
532cdf0e10cSrcweir (aTableVec[nTableCount - 1]->GetColsPerCol(aTableVec[nTableCount - 1]->GetColumn()) > 1)))
533cdf0e10cSrcweir {
534cdf0e10cSrcweir if ((aTableVec[nTableCount - 1]->GetRowsPerRow(aTableVec[nTableCount - 1]->GetRow()) > 1) ||
535cdf0e10cSrcweir (aTableVec[nTableCount - 1]->GetColsPerCol(aTableVec[nTableCount - 1]->GetColumn()) > 1))
536cdf0e10cSrcweir DoMerge();
537cdf0e10cSrcweir }
538cdf0e10cSrcweir }
539cdf0e10cSrcweir }
540cdf0e10cSrcweir
NewTable(sal_Int32 nTempSpannedCols)541cdf0e10cSrcweir void ScMyTables::NewTable(sal_Int32 nTempSpannedCols)
542cdf0e10cSrcweir {
543cdf0e10cSrcweir ++nTableCount;
544cdf0e10cSrcweir if (static_cast<sal_uInt32>(nTableCount) >= aTableVec.size())
545cdf0e10cSrcweir aTableVec.resize(aTableVec.size() + nDefaultTabCount);
546cdf0e10cSrcweir ScMyTableData* aTable(new ScMyTableData(nCurrentSheet));
547cdf0e10cSrcweir if (nTableCount > 1)
548cdf0e10cSrcweir {
549cdf0e10cSrcweir ScMyTableData* pTableData = aTableVec[nTableCount - 2];
550cdf0e10cSrcweir const sal_Int32 nCol(pTableData->GetColumn());
551cdf0e10cSrcweir const sal_Int32 nColCount(pTableData->GetColCount());
552cdf0e10cSrcweir const sal_Int32 nColsPerCol(pTableData->GetColsPerCol(nCol));
553cdf0e10cSrcweir sal_Int32 nSpannedCols(pTableData->GetSpannedCols());
554cdf0e10cSrcweir sal_Int32 nTemp(nSpannedCols - nColCount);
555cdf0e10cSrcweir sal_Int32 nTemp2(nCol - (nColCount - 1));
556cdf0e10cSrcweir if ((nTemp > 0) && (nTemp2 == 0))
557cdf0e10cSrcweir nTempSpannedCols *= (nTemp + 1);
558cdf0e10cSrcweir else
559cdf0e10cSrcweir if (nColsPerCol > 1)
560cdf0e10cSrcweir nTempSpannedCols *= nColsPerCol;
561cdf0e10cSrcweir
562cdf0e10cSrcweir sal_Int32 nToMerge;
563cdf0e10cSrcweir if (nSpannedCols > nColCount)
564cdf0e10cSrcweir nToMerge = pTableData->GetChangedCols(nCol, nCol + nColsPerCol + nSpannedCols - nColCount);
565cdf0e10cSrcweir else
566cdf0e10cSrcweir nToMerge = pTableData->GetChangedCols(nCol, nCol + nColsPerCol);
567cdf0e10cSrcweir if (nToMerge > nCol)
568cdf0e10cSrcweir nTempSpannedCols += nToMerge;
569cdf0e10cSrcweir }
570cdf0e10cSrcweir aTable->SetSpannedCols(nTempSpannedCols);
571cdf0e10cSrcweir aTableVec[nTableCount - 1] = aTable;
572cdf0e10cSrcweir if (nTableCount > 1)
573cdf0e10cSrcweir {
574cdf0e10cSrcweir aTableVec[nTableCount - 2]->SetSubTableSpanned(aTable->GetSpannedCols());
575cdf0e10cSrcweir UnMerge();
576cdf0e10cSrcweir }
577cdf0e10cSrcweir }
578cdf0e10cSrcweir
UpdateRowHeights()579cdf0e10cSrcweir void ScMyTables::UpdateRowHeights()
580cdf0e10cSrcweir {
581cdf0e10cSrcweir if (rImport.GetModel().is())
582cdf0e10cSrcweir {
583cdf0e10cSrcweir rImport.LockSolarMutex();
584cdf0e10cSrcweir // update automatic row heights
585cdf0e10cSrcweir
586cdf0e10cSrcweir // For sheets with any kind of shapes (including notes),
587cdf0e10cSrcweir // update row heights immediately (before setting the positions).
588cdf0e10cSrcweir // For sheets without shapes, set "pending" flag
589cdf0e10cSrcweir // and update row heights when a sheet is shown.
590cdf0e10cSrcweir // The current sheet (from view settings) is always updated immediately.
591cdf0e10cSrcweir
592cdf0e10cSrcweir ScDocument* pDoc = ScXMLConverter::GetScDocument(rImport.GetModel());
593cdf0e10cSrcweir if (pDoc)
594cdf0e10cSrcweir {
595cdf0e10cSrcweir SCTAB nCount = pDoc->GetTableCount();
596cdf0e10cSrcweir ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
597cdf0e10cSrcweir
598cdf0e10cSrcweir SCTAB nVisible = static_cast<SCTAB>( rImport.GetVisibleSheet() );
599cdf0e10cSrcweir
600cdf0e10cSrcweir ScMarkData aUpdateSheets;
601cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nCount; ++nTab)
602cdf0e10cSrcweir {
603cdf0e10cSrcweir const SdrPage* pPage = pDrawLayer ? pDrawLayer->GetPage(nTab) : NULL;
604cdf0e10cSrcweir if ( nTab == nVisible || ( pPage && pPage->GetObjCount() != 0 ) )
605cdf0e10cSrcweir aUpdateSheets.SelectTable( nTab, sal_True );
606cdf0e10cSrcweir else
607cdf0e10cSrcweir pDoc->SetPendingRowHeights( nTab, sal_True );
608cdf0e10cSrcweir }
609cdf0e10cSrcweir
610cdf0e10cSrcweir if (aUpdateSheets.GetSelectCount())
611cdf0e10cSrcweir {
612cdf0e10cSrcweir pDoc->LockStreamValid( true ); // ignore draw page size (but not formula results)
613cdf0e10cSrcweir // #i114839# make sure the output factor is valid for UpdateAllRowHeights
614cdf0e10cSrcweir ScModelObj::getImplementation(rImport.GetModel())->UpdateAllRowHeights(&aUpdateSheets, true);
615cdf0e10cSrcweir pDoc->LockStreamValid( false );
616cdf0e10cSrcweir }
617cdf0e10cSrcweir }
618cdf0e10cSrcweir
619cdf0e10cSrcweir rImport.UnlockSolarMutex();
620cdf0e10cSrcweir }
621cdf0e10cSrcweir }
622cdf0e10cSrcweir
DeleteTable()623cdf0e10cSrcweir void ScMyTables::DeleteTable()
624cdf0e10cSrcweir {
625cdf0e10cSrcweir rImport.LockSolarMutex();
626cdf0e10cSrcweir
627cdf0e10cSrcweir nCurrentColStylePos = 0;
628cdf0e10cSrcweir if (nTableCount > 0)
629cdf0e10cSrcweir {
630cdf0e10cSrcweir ScMyTableData* aTable = aTableVec[nTableCount - 1];
631cdf0e10cSrcweir delete aTable;
632cdf0e10cSrcweir aTableVec[nTableCount - 1] = NULL;
633cdf0e10cSrcweir nTableCount--;
634cdf0e10cSrcweir }
635cdf0e10cSrcweir if (nTableCount == 0) // only set the styles if all subtables are importet and the table is finished
636cdf0e10cSrcweir {
637cdf0e10cSrcweir rImport.GetStylesImportHelper()->SetStylesToRanges();
638cdf0e10cSrcweir rImport.SetStylesToRangesFinished();
639cdf0e10cSrcweir }
640cdf0e10cSrcweir
641cdf0e10cSrcweir //#i48793#; has to be set before protection
642cdf0e10cSrcweir if (!aMatrixRangeList.empty())
643cdf0e10cSrcweir {
644cdf0e10cSrcweir ScMyMatrixRangeList::iterator aItr = aMatrixRangeList.begin();
645cdf0e10cSrcweir ScMyMatrixRangeList::iterator aEndItr = aMatrixRangeList.end();
646cdf0e10cSrcweir while(aItr != aEndItr)
647cdf0e10cSrcweir {
648cdf0e10cSrcweir SetMatrix(aItr->aRange, aItr->sFormula, aItr->sFormulaNmsp, aItr->eGrammar);
649cdf0e10cSrcweir ++aItr;
650cdf0e10cSrcweir }
651cdf0e10cSrcweir aMatrixRangeList.clear();
652cdf0e10cSrcweir }
653cdf0e10cSrcweir
654cdf0e10cSrcweir if (rImport.GetDocument() && bProtection)
655cdf0e10cSrcweir {
656cdf0e10cSrcweir uno::Sequence<sal_Int8> aPass;
657cdf0e10cSrcweir SvXMLUnitConverter::decodeBase64(aPass, sPassword);
658cdf0e10cSrcweir auto_ptr<ScTableProtection> pProtect(new ScTableProtection);
659cdf0e10cSrcweir pProtect->setProtected(bProtection);
660cdf0e10cSrcweir pProtect->setPasswordHash(aPass, PASSHASH_OOO);
661cdf0e10cSrcweir rImport.GetDocument()->SetTabProtection(static_cast<SCTAB>(nCurrentSheet), pProtect.get());
662cdf0e10cSrcweir }
663cdf0e10cSrcweir
664cdf0e10cSrcweir rImport.UnlockSolarMutex();
665cdf0e10cSrcweir
666cdf0e10cSrcweir //#95582#; find out whether it was possible to set the sheet name
667cdf0e10cSrcweir // test it here, because if it is a linked table the name is changed by importing
668cdf0e10cSrcweir // the linking informations
669cdf0e10cSrcweir uno::Reference < container::XNamed > xNamed(xCurrentSheet, uno::UNO_QUERY );
670cdf0e10cSrcweir if ( xNamed.is() )
671cdf0e10cSrcweir {
672cdf0e10cSrcweir rtl::OUString sCurrentName(xNamed->getName());
673cdf0e10cSrcweir if (sCurrentName != sCurrentSheetName && rImport.GetDocument())
674cdf0e10cSrcweir {
675cdf0e10cSrcweir rImport.GetDocument()->RenameTab( static_cast<SCTAB>(nCurrentSheet),
676cdf0e10cSrcweir sCurrentSheetName, sal_False, sal_True);
677cdf0e10cSrcweir
678cdf0e10cSrcweir /* rtl::OUString sErrorMessage(RTL_CONSTASCII_USTRINGPARAM("Could not create a table with the name "));
679cdf0e10cSrcweir sErrorMessage += sCurrentSheetName;
680cdf0e10cSrcweir sErrorMessage += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(". The new name is "));
681cdf0e10cSrcweir sErrorMessage += sCurrentName;
682cdf0e10cSrcweir uno::Sequence<rtl::OUString> aSeq(1);
683cdf0e10cSrcweir aSeq[0] = sErrorMessage;
684cdf0e10cSrcweir uno::Reference<xml::sax::XLocator> xLocator;
685cdf0e10cSrcweir rImport.SetError(XMLERROR_API | XMLERROR_FLAG_ERROR, aSeq, rtl::OUString(), xLocator);*/
686cdf0e10cSrcweir }
687cdf0e10cSrcweir }
688cdf0e10cSrcweir }
689cdf0e10cSrcweir
GetRealCellPos()690cdf0e10cSrcweir table::CellAddress ScMyTables::GetRealCellPos()
691cdf0e10cSrcweir {
692cdf0e10cSrcweir sal_Int32 nRow(0);
693cdf0e10cSrcweir sal_Int32 nCol(0);
694cdf0e10cSrcweir for (sal_Int32 i = 0; i < nTableCount; ++i)
695cdf0e10cSrcweir {
696cdf0e10cSrcweir ScMyTableData* pTableData = aTableVec[i];
697cdf0e10cSrcweir nCol += pTableData->GetRealCols(pTableData->GetColumn());
698cdf0e10cSrcweir nRow += pTableData->GetRealRows(pTableData->GetRow());
699cdf0e10cSrcweir }
700cdf0e10cSrcweir aRealCellPos.Row = nRow;
701cdf0e10cSrcweir aRealCellPos.Column = nCol;
702cdf0e10cSrcweir aRealCellPos.Sheet = sal::static_int_cast<sal_Int16>(nCurrentSheet);
703cdf0e10cSrcweir return aRealCellPos;
704cdf0e10cSrcweir }
705cdf0e10cSrcweir
AddColCount(sal_Int32 nTempColCount)706cdf0e10cSrcweir void ScMyTables::AddColCount(sal_Int32 nTempColCount)
707cdf0e10cSrcweir {
708cdf0e10cSrcweir aTableVec[nTableCount - 1]->SetColCount(aTableVec[nTableCount - 1]->GetColCount() + nTempColCount);
709cdf0e10cSrcweir }
710cdf0e10cSrcweir
AddColStyle(const sal_Int32 nRepeat,const rtl::OUString & rCellStyleName)711cdf0e10cSrcweir void ScMyTables::AddColStyle(const sal_Int32 nRepeat, const rtl::OUString& rCellStyleName)
712cdf0e10cSrcweir {
713cdf0e10cSrcweir DBG_ASSERT(nTableCount == 1, "not possible to use default styles on columns in subtables");
714cdf0e10cSrcweir rImport.GetStylesImportHelper()->AddColumnStyle(rCellStyleName, nCurrentColStylePos, nRepeat);
715cdf0e10cSrcweir nCurrentColStylePos += nRepeat;
716cdf0e10cSrcweir }
717cdf0e10cSrcweir
GetCurrentXDrawPage()718cdf0e10cSrcweir uno::Reference< drawing::XDrawPage > ScMyTables::GetCurrentXDrawPage()
719cdf0e10cSrcweir {
720cdf0e10cSrcweir if( (nCurrentSheet != nCurrentDrawPage) || !xDrawPage.is() )
721cdf0e10cSrcweir {
722cdf0e10cSrcweir uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier( xCurrentSheet, uno::UNO_QUERY );
723cdf0e10cSrcweir if( xDrawPageSupplier.is() )
724cdf0e10cSrcweir xDrawPage.set(xDrawPageSupplier->getDrawPage());
725cdf0e10cSrcweir nCurrentDrawPage = sal::static_int_cast<sal_Int16>(nCurrentSheet);
726cdf0e10cSrcweir }
727cdf0e10cSrcweir return xDrawPage;
728cdf0e10cSrcweir }
729cdf0e10cSrcweir
GetCurrentXShapes()730cdf0e10cSrcweir uno::Reference< drawing::XShapes > ScMyTables::GetCurrentXShapes()
731cdf0e10cSrcweir {
732cdf0e10cSrcweir if( (nCurrentSheet != nCurrentXShapes) || !xShapes.is() )
733cdf0e10cSrcweir {
734cdf0e10cSrcweir xShapes.set(GetCurrentXDrawPage(), uno::UNO_QUERY);
735cdf0e10cSrcweir rImport.GetShapeImport()->startPage(xShapes);
736cdf0e10cSrcweir rImport.GetShapeImport()->pushGroupForSorting ( xShapes );
737cdf0e10cSrcweir nCurrentXShapes = sal::static_int_cast<sal_Int16>(nCurrentSheet);
738cdf0e10cSrcweir return xShapes;
739cdf0e10cSrcweir }
740cdf0e10cSrcweir else
741cdf0e10cSrcweir return xShapes;
742cdf0e10cSrcweir }
743cdf0e10cSrcweir
HasDrawPage()744cdf0e10cSrcweir sal_Bool ScMyTables::HasDrawPage()
745cdf0e10cSrcweir {
746cdf0e10cSrcweir return !((nCurrentSheet != nCurrentDrawPage) || !xDrawPage.is());
747cdf0e10cSrcweir }
748cdf0e10cSrcweir
HasXShapes()749cdf0e10cSrcweir sal_Bool ScMyTables::HasXShapes()
750cdf0e10cSrcweir {
751cdf0e10cSrcweir return !((nCurrentSheet != nCurrentXShapes) || !xShapes.is());
752cdf0e10cSrcweir }
753cdf0e10cSrcweir
AddShape(uno::Reference<drawing::XShape> & rShape,rtl::OUString * pRangeList,table::CellAddress & rStartAddress,table::CellAddress & rEndAddress,sal_Int32 nEndX,sal_Int32 nEndY)754cdf0e10cSrcweir void ScMyTables::AddShape(uno::Reference <drawing::XShape>& rShape,
755cdf0e10cSrcweir rtl::OUString* pRangeList,
756cdf0e10cSrcweir table::CellAddress& rStartAddress, table::CellAddress& rEndAddress,
757cdf0e10cSrcweir sal_Int32 nEndX, sal_Int32 nEndY)
758cdf0e10cSrcweir {
759cdf0e10cSrcweir aResizeShapes.AddShape(rShape, pRangeList, rStartAddress, rEndAddress, nEndX, nEndY);
760cdf0e10cSrcweir }
761cdf0e10cSrcweir
AddMatrixRange(sal_Int32 nStartColumn,sal_Int32 nStartRow,sal_Int32 nEndColumn,sal_Int32 nEndRow,const rtl::OUString & rFormula,const rtl::OUString & rFormulaNmsp,const formula::FormulaGrammar::Grammar eGrammar)762cdf0e10cSrcweir void ScMyTables::AddMatrixRange(
763cdf0e10cSrcweir sal_Int32 nStartColumn, sal_Int32 nStartRow, sal_Int32 nEndColumn, sal_Int32 nEndRow,
764cdf0e10cSrcweir const rtl::OUString& rFormula, const rtl::OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar)
765cdf0e10cSrcweir {
766cdf0e10cSrcweir DBG_ASSERT(nEndRow >= nStartRow, "wrong row order");
767cdf0e10cSrcweir DBG_ASSERT(nEndColumn >= nStartColumn, "wrong column order");
768cdf0e10cSrcweir table::CellRangeAddress aRange;
769cdf0e10cSrcweir aRange.StartColumn = nStartColumn;
770cdf0e10cSrcweir aRange.StartRow = nStartRow;
771cdf0e10cSrcweir aRange.EndColumn = nEndColumn;
772cdf0e10cSrcweir aRange.EndRow = nEndRow;
773cdf0e10cSrcweir aRange.Sheet = sal::static_int_cast<sal_Int16>(nCurrentSheet);
774cdf0e10cSrcweir ScMatrixRange aMRange(aRange, rFormula, rFormulaNmsp, eGrammar);
775cdf0e10cSrcweir aMatrixRangeList.push_back(aMRange);
776cdf0e10cSrcweir }
777cdf0e10cSrcweir
IsPartOfMatrix(sal_Int32 nColumn,sal_Int32 nRow)778cdf0e10cSrcweir sal_Bool ScMyTables::IsPartOfMatrix(sal_Int32 nColumn, sal_Int32 nRow)
779cdf0e10cSrcweir {
780cdf0e10cSrcweir sal_Bool bResult(sal_False);
781cdf0e10cSrcweir if (!aMatrixRangeList.empty())
782cdf0e10cSrcweir {
783cdf0e10cSrcweir ScMyMatrixRangeList::iterator aItr(aMatrixRangeList.begin());
784cdf0e10cSrcweir ScMyMatrixRangeList::iterator aEndItr(aMatrixRangeList.end());
785cdf0e10cSrcweir sal_Bool bReady(sal_False);
786cdf0e10cSrcweir while(!bReady && aItr != aEndItr)
787cdf0e10cSrcweir {
788cdf0e10cSrcweir if (nCurrentSheet > aItr->aRange.Sheet)
789cdf0e10cSrcweir {
790*86e1cf34SPedro Giffuni DBG_ERROR("should never happen, because the list should be cleared in DeleteTable");
791cdf0e10cSrcweir aItr = aMatrixRangeList.erase(aItr);
792cdf0e10cSrcweir }
793cdf0e10cSrcweir else if ((nRow > aItr->aRange.EndRow) && (nColumn > aItr->aRange.EndColumn))
794cdf0e10cSrcweir {
795cdf0e10cSrcweir SetMatrix(aItr->aRange, aItr->sFormula, aItr->sFormulaNmsp, aItr->eGrammar);
796cdf0e10cSrcweir aItr = aMatrixRangeList.erase(aItr);
797cdf0e10cSrcweir }
798cdf0e10cSrcweir else if (nColumn < aItr->aRange.StartColumn)
799cdf0e10cSrcweir bReady = sal_True;
800cdf0e10cSrcweir else if (nColumn >= aItr->aRange.StartColumn && nColumn <= aItr->aRange.EndColumn && nRow >= aItr->aRange.StartRow && nRow <= aItr->aRange.EndRow)
801cdf0e10cSrcweir {
802cdf0e10cSrcweir bReady = sal_True;
803cdf0e10cSrcweir bResult = sal_True;
804cdf0e10cSrcweir }
805cdf0e10cSrcweir else
806cdf0e10cSrcweir ++aItr;
807cdf0e10cSrcweir }
808cdf0e10cSrcweir }
809cdf0e10cSrcweir return bResult;
810cdf0e10cSrcweir }
811cdf0e10cSrcweir
SetMatrix(const table::CellRangeAddress & rRange,const rtl::OUString & rFormula,const rtl::OUString & rFormulaNmsp,const formula::FormulaGrammar::Grammar eGrammar)812cdf0e10cSrcweir void ScMyTables::SetMatrix(const table::CellRangeAddress& rRange, const rtl::OUString& rFormula,
813cdf0e10cSrcweir const rtl::OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar)
814cdf0e10cSrcweir {
815cdf0e10cSrcweir uno::Reference <table::XCellRange> xMatrixCellRange(
816cdf0e10cSrcweir GetCurrentXCellRange()->getCellRangeByPosition(rRange.StartColumn, rRange.StartRow,
817cdf0e10cSrcweir rRange.EndColumn, rRange.EndRow));
818cdf0e10cSrcweir if (xMatrixCellRange.is())
819cdf0e10cSrcweir {
820cdf0e10cSrcweir uno::Reference <sheet::XArrayFormulaRange> xArrayFormulaRange(xMatrixCellRange, uno::UNO_QUERY);
821cdf0e10cSrcweir if (xArrayFormulaRange.is())
822cdf0e10cSrcweir {
823cdf0e10cSrcweir ScCellRangeObj* pCellRangeObj =
824cdf0e10cSrcweir static_cast<ScCellRangeObj*>(ScCellRangesBase::getImplementation(
825cdf0e10cSrcweir xMatrixCellRange));
826cdf0e10cSrcweir if (pCellRangeObj)
827cdf0e10cSrcweir pCellRangeObj->SetArrayFormulaWithGrammar( rFormula, rFormulaNmsp, eGrammar);
828cdf0e10cSrcweir }
829cdf0e10cSrcweir }
830cdf0e10cSrcweir }
831