Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <list>
21 : #include <utility>
22 : #include <vector>
23 :
24 : #include <svx/svxids.hrc>
25 : #include <editeng/memberids.hrc>
26 : #include <float.h>
27 : #include <swtypes.hxx>
28 : #include <cmdid.h>
29 : #include <unotbl.hxx>
30 : #include <unostyle.hxx>
31 : #include <section.hxx>
32 : #include <unocrsr.hxx>
33 : #include <svx/unomid.hxx>
34 : #include <hints.hxx>
35 : #include <swtblfmt.hxx>
36 : #include <doc.hxx>
37 : #include <IDocumentUndoRedo.hxx>
38 : #include <IDocumentContentOperations.hxx>
39 : #include <IDocumentFieldsAccess.hxx>
40 : #include <IDocumentState.hxx>
41 : #include <shellres.hxx>
42 : #include <docary.hxx>
43 : #include <ndole.hxx>
44 : #include <frame.hxx>
45 : #include <vcl/svapp.hxx>
46 : #include <fmtfsize.hxx>
47 : #include <tblafmt.hxx>
48 : #include <tabcol.hxx>
49 : #include <cellatr.hxx>
50 : #include <fmtpdsc.hxx>
51 : #include <pagedesc.hxx>
52 : #include <viewsh.hxx>
53 : #include <tabfrm.hxx>
54 : #include <redline.hxx>
55 : #include <unoport.hxx>
56 : #include <unoprnms.hxx>
57 : #include <unocrsrhelper.hxx>
58 : #include <com/sun/star/text/WrapTextMode.hpp>
59 : #include <com/sun/star/text/TextContentAnchorType.hpp>
60 : #include <com/sun/star/text/TableColumnSeparator.hpp>
61 : #include <com/sun/star/text/XTextSection.hpp>
62 : #include <com/sun/star/table/ShadowFormat.hpp>
63 : #include <com/sun/star/table/TableBorder.hpp>
64 : #include <com/sun/star/table/TableBorder2.hpp>
65 : #include <com/sun/star/table/BorderLine2.hpp>
66 : #include <com/sun/star/table/BorderLineStyle.hpp>
67 : #include <com/sun/star/table/TableBorderDistances.hpp>
68 : #include <com/sun/star/style/PageStyleLayout.hpp>
69 : #include <com/sun/star/style/BreakType.hpp>
70 : #include <com/sun/star/style/GraphicLocation.hpp>
71 : #include <com/sun/star/beans/PropertyAttribute.hpp>
72 : #include <com/sun/star/chart/XChartDataChangeEventListener.hpp>
73 : #include <com/sun/star/chart/ChartDataChangeEvent.hpp>
74 : #include <com/sun/star/chart2/data/XDataSequence.hpp>
75 : #include <com/sun/star/chart2/data/XLabeledDataSequence.hpp>
76 : #include <com/sun/star/table/CellContentType.hpp>
77 : #include <unotextrange.hxx>
78 : #include <unotextcursor.hxx>
79 : #include <unoparagraph.hxx>
80 : #include <svl/zforlist.hxx>
81 : #include <editeng/formatbreakitem.hxx>
82 : #include <editeng/shaditem.hxx>
83 : #include <editeng/lrspitem.hxx>
84 : #include <editeng/ulspitem.hxx>
85 : #include <fmtornt.hxx>
86 : #include <editeng/keepitem.hxx>
87 : #include <fmtlsplt.hxx>
88 : #include <swundo.hxx>
89 : #include <osl/mutex.hxx>
90 : #include <SwStyleNameMapper.hxx>
91 : #include <frmatr.hxx>
92 : #include <crsskip.hxx>
93 : #include <unochart.hxx>
94 : #include <sortopt.hxx>
95 : #include <rtl/math.hxx>
96 : #include <editeng/frmdiritem.hxx>
97 : #include <switerator.hxx>
98 : #include <comphelper/servicehelper.hxx>
99 : #include <comphelper/string.hxx>
100 : #include <cppuhelper/supportsservice.hxx>
101 : #include <comphelper/sequenceashashmap.hxx>
102 : #include <swtable.hxx>
103 :
104 : using namespace ::com::sun::star;
105 : using ::editeng::SvxBorderLine;
106 :
107 : #define UNO_TABLE_COLUMN_SUM 10000
108 :
109 4 : static void lcl_SendChartEvent(::cppu::OWeakObject & rSource,
110 : ::cppu::OInterfaceContainerHelper & rListeners)
111 : {
112 : //TODO: find appropriate settings of the Event
113 4 : chart::ChartDataChangeEvent event;
114 4 : event.Source = & rSource;
115 4 : event.Type = chart::ChartDataChangeType_ALL;
116 4 : event.StartColumn = 0;
117 4 : event.EndColumn = 1;
118 4 : event.StartRow = 0;
119 4 : event.EndRow = 1;
120 : rListeners.notifyEach(
121 4 : & chart::XChartDataChangeEventListener::chartDataChanged, event);
122 4 : }
123 :
124 6648 : static void lcl_SendChartEvent(::cppu::OWeakObject & rSource,
125 : ::cppu::OMultiTypeInterfaceContainerHelper & rListeners)
126 : {
127 : ::cppu::OInterfaceContainerHelper *const pContainer(rListeners.getContainer(
128 6648 : cppu::UnoType<chart::XChartDataChangeEventListener>::get()));
129 6648 : if (pContainer)
130 : {
131 4 : lcl_SendChartEvent(rSource, *pContainer);
132 : }
133 6648 : }
134 :
135 6408 : static bool lcl_LineToSvxLine(const table::BorderLine& rLine, SvxBorderLine& rSvxLine)
136 : {
137 6408 : rSvxLine.SetColor(Color(rLine.Color));
138 :
139 : rSvxLine.GuessLinesWidths( table::BorderLineStyle::NONE,
140 6408 : convertMm100ToTwip( rLine.OuterLineWidth ),
141 6408 : convertMm100ToTwip( rLine.InnerLineWidth ),
142 19224 : convertMm100ToTwip( rLine.LineDistance ) );
143 :
144 6408 : bool bRet = rLine.InnerLineWidth > 0 || rLine.OuterLineWidth > 0;
145 6408 : return bRet;
146 : }
147 :
148 2336 : static void lcl_SetSpecialProperty(SwFrmFmt* pFmt,
149 : const SfxItemPropertySimpleEntry* pEntry,
150 : const uno::Any& aValue)
151 : throw (lang::IllegalArgumentException,
152 : uno::RuntimeException)
153 : {
154 : // special treatment for "non-items"
155 2336 : switch(pEntry->nWID)
156 : {
157 : case FN_TABLE_HEADLINE_REPEAT:
158 : case FN_TABLE_HEADLINE_COUNT:
159 : {
160 1064 : SwTable* pTable = SwTable::FindTable( pFmt );
161 : {
162 1064 : UnoActionContext aAction(pFmt->GetDoc());
163 1064 : if( pEntry->nWID == FN_TABLE_HEADLINE_REPEAT)
164 : {
165 2 : bool bVal = *(sal_Bool*)aValue.getValue();
166 2 : pFmt->GetDoc()->SetRowsToRepeat( *pTable, bVal ? 1 : 0 );
167 : }
168 : else
169 : {
170 1062 : sal_Int32 nRepeat = 0;
171 1062 : aValue >>= nRepeat;
172 1062 : if( nRepeat >= 0 && nRepeat < USHRT_MAX )
173 1062 : pFmt->GetDoc()->SetRowsToRepeat( *pTable, (sal_uInt16) nRepeat );
174 1064 : }
175 : }
176 : }
177 1064 : break;
178 :
179 : case FN_TABLE_IS_RELATIVE_WIDTH:
180 : case FN_TABLE_WIDTH:
181 : case FN_TABLE_RELATIVE_WIDTH:
182 : {
183 1214 : SwFmtFrmSize aSz( pFmt->GetFrmSize() );
184 1214 : if(FN_TABLE_WIDTH == pEntry->nWID)
185 : {
186 928 : sal_Int32 nWidth = 0;
187 928 : aValue >>= nWidth;
188 928 : aSz.SetWidthPercent(0);
189 928 : aSz.SetWidth ( convertMm100ToTwip ( nWidth ) );
190 : }
191 286 : else if(FN_TABLE_RELATIVE_WIDTH == pEntry->nWID)
192 : {
193 148 : sal_Int16 nSet = 0;
194 148 : aValue >>= nSet;
195 148 : if(nSet && nSet <=100)
196 148 : aSz.SetWidthPercent( (sal_uInt8)nSet );
197 : }
198 138 : else if(FN_TABLE_IS_RELATIVE_WIDTH == pEntry->nWID)
199 : {
200 138 : bool bPercent = *(sal_Bool*)aValue.getValue();
201 138 : if(!bPercent)
202 2 : aSz.SetWidthPercent(0);
203 : else
204 : {
205 136 : lang::IllegalArgumentException aExcept;
206 136 : aExcept.Message = "relative width cannot be switched on with this property";
207 136 : throw aExcept;
208 : }
209 : }
210 1214 : pFmt->GetDoc()->SetAttr(aSz, *pFmt);
211 : }
212 1078 : break;
213 :
214 : case RES_PAGEDESC:
215 : {
216 58 : OUString sPageStyle;
217 58 : aValue >>= sPageStyle;
218 58 : const SwPageDesc* pDesc = 0;
219 58 : if (!sPageStyle.isEmpty())
220 : {
221 58 : SwStyleNameMapper::FillUIName(sPageStyle, sPageStyle, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, true );
222 58 : pDesc = SwPageDesc::GetByName(*pFmt->GetDoc(), sPageStyle);
223 : }
224 116 : SwFmtPageDesc aDesc( pDesc );
225 116 : pFmt->GetDoc()->SetAttr(aDesc, *pFmt);
226 : }
227 58 : break;
228 :
229 : default:
230 0 : throw lang::IllegalArgumentException();
231 : }
232 2200 : }
233 :
234 504 : static uno::Any lcl_GetSpecialProperty(SwFrmFmt* pFmt, const SfxItemPropertySimpleEntry* pEntry )
235 : {
236 504 : uno::Any aRet;
237 504 : switch(pEntry->nWID)
238 : {
239 : case FN_TABLE_HEADLINE_REPEAT:
240 : case FN_TABLE_HEADLINE_COUNT:
241 : {
242 4 : SwTable* pTable = SwTable::FindTable( pFmt );
243 4 : const sal_uInt16 nRepeat = pTable->GetRowsToRepeat();
244 4 : if(pEntry->nWID == FN_TABLE_HEADLINE_REPEAT)
245 : {
246 4 : sal_Bool bTemp = nRepeat > 0;
247 4 : aRet.setValue(&bTemp, ::getCppuBooleanType());
248 : }
249 : else
250 0 : aRet <<= (sal_Int32)nRepeat;
251 : }
252 4 : break;
253 :
254 : case FN_TABLE_WIDTH:
255 : case FN_TABLE_IS_RELATIVE_WIDTH:
256 : case FN_TABLE_RELATIVE_WIDTH:
257 : {
258 488 : const SwFmtFrmSize& rSz = pFmt->GetFrmSize();
259 488 : if(FN_TABLE_WIDTH == pEntry->nWID)
260 108 : rSz.QueryValue(aRet, MID_FRMSIZE_WIDTH|CONVERT_TWIPS);
261 380 : else if(FN_TABLE_RELATIVE_WIDTH == pEntry->nWID)
262 14 : rSz.QueryValue(aRet, MID_FRMSIZE_REL_WIDTH);
263 : else
264 : {
265 366 : sal_Bool bTemp = 0 != rSz.GetWidthPercent();
266 366 : aRet.setValue(&bTemp, ::getBooleanCppuType());
267 : }
268 : }
269 488 : break;
270 :
271 : case RES_PAGEDESC:
272 : {
273 4 : const SfxItemSet& rSet = pFmt->GetAttrSet();
274 : const SfxPoolItem* pItem;
275 4 : OUString sPDesc;
276 4 : if(SfxItemState::SET == rSet.GetItemState(RES_PAGEDESC, false, &pItem))
277 : {
278 2 : const SwPageDesc* pDsc = ((const SwFmtPageDesc*)pItem)->GetPageDesc();
279 2 : if(pDsc)
280 : {
281 2 : sPDesc = SwStyleNameMapper::GetProgName(pDsc->GetName(), nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
282 : }
283 : }
284 4 : aRet <<= sPDesc;
285 : }
286 4 : break;
287 :
288 : case RES_ANCHOR :
289 0 : aRet <<= text::TextContentAnchorType_AT_PARAGRAPH;
290 0 : break;
291 :
292 : case FN_UNO_ANCHOR_TYPES :
293 : {
294 4 : uno::Sequence<text::TextContentAnchorType> aTypes(1);
295 4 : text::TextContentAnchorType* pArray = aTypes.getArray();
296 4 : pArray[0] = text::TextContentAnchorType_AT_PARAGRAPH;
297 4 : aRet <<= aTypes;
298 : }
299 4 : break;
300 :
301 : case FN_UNO_WRAP :
302 : {
303 0 : aRet <<= text::WrapTextMode_NONE;
304 : }
305 0 : break;
306 :
307 : case FN_PARAM_LINK_DISPLAY_NAME :
308 0 : aRet <<= pFmt->GetName();
309 0 : break;
310 :
311 : case FN_UNO_REDLINE_NODE_START:
312 : case FN_UNO_REDLINE_NODE_END:
313 : {
314 4 : SwTable* pTable = SwTable::FindTable( pFmt );
315 4 : SwNode* pTblNode = pTable->GetTableNode();
316 4 : if(FN_UNO_REDLINE_NODE_END == pEntry->nWID)
317 2 : pTblNode = pTblNode->EndOfSectionNode();
318 4 : const SwRedlineTbl& rRedTbl = pFmt->GetDoc()->getIDocumentRedlineAccess().GetRedlineTbl();
319 4 : for(size_t nRed = 0; nRed < rRedTbl.size(); ++nRed)
320 : {
321 0 : const SwRangeRedline* pRedline = rRedTbl[nRed];
322 0 : const SwNode& rRedPointNode = pRedline->GetNode(true);
323 0 : const SwNode& rRedMarkNode = pRedline->GetNode(false);
324 0 : if(&rRedPointNode == pTblNode || &rRedMarkNode == pTblNode)
325 : {
326 0 : const SwNode& rStartOfRedline = SwNodeIndex(rRedPointNode) <= SwNodeIndex(rRedMarkNode) ?
327 0 : rRedPointNode : rRedMarkNode;
328 0 : bool bIsStart = &rStartOfRedline == pTblNode;
329 0 : aRet <<= SwXRedlinePortion::CreateRedlineProperties(*pRedline, bIsStart);
330 0 : break;
331 : }
332 : }
333 : }
334 4 : break;
335 : }
336 504 : return aRet;
337 : }
338 :
339 : /** get position of a cell with a given name
340 : *
341 : * If everything was OK, the indices for column and row are changed (both >= 0).
342 : * In case of errors, at least one of them is < 0.
343 : *
344 : * Also since the implementations of tables does not really have columns using
345 : * this function is appropriate only for tables that are not complex (i.e.
346 : * where IsTblComplex() returns false).
347 : *
348 : * @param rCellName e.g. A1..Z1, a1..z1, AA1..AZ1, Aa1..Az1, BA1..BZ1, Ba1..Bz1, ...
349 : * @param [IN,OUT] rColumn (0-based)
350 : * @param [IN,OUT] rRow (0-based)
351 : */
352 : //TODO: potential for throwing proper exceptions instead of having every caller to check for errors
353 8 : void sw_GetCellPosition(const OUString &rCellName,
354 : sal_Int32 &rColumn, sal_Int32 &rRow)
355 : {
356 8 : rColumn = rRow = -1; // default return values indicating failure
357 8 : const sal_Int32 nLen = rCellName.getLength();
358 8 : if (nLen)
359 : {
360 8 : sal_Int32 nRowPos = 0;
361 24 : while (nRowPos<nLen)
362 : {
363 16 : if (rCellName[nRowPos]>='0' && rCellName[nRowPos]<='9')
364 : {
365 8 : break;
366 : }
367 8 : ++nRowPos;
368 : }
369 8 : if (nRowPos>0 && nRowPos<nLen)
370 : {
371 8 : sal_Int32 nColIdx = 0;
372 16 : for (sal_Int32 i = 0; i < nRowPos; ++i)
373 : {
374 8 : nColIdx *= 52;
375 8 : if (i < nRowPos - 1)
376 0 : ++nColIdx;
377 8 : const sal_Unicode cChar = rCellName[i];
378 8 : if ('A' <= cChar && cChar <= 'Z')
379 8 : nColIdx += cChar - 'A';
380 0 : else if ('a' <= cChar && cChar <= 'z')
381 0 : nColIdx += 26 + cChar - 'a';
382 : else
383 : {
384 0 : nColIdx = -1; // sth failed
385 0 : break;
386 : }
387 : }
388 :
389 8 : rColumn = nColIdx;
390 8 : rRow = rCellName.copy(nRowPos).toInt32() - 1; // - 1 because indices ought to be 0 based
391 : }
392 : }
393 : OSL_ENSURE( rColumn >= 0 && rRow >= 0, "failed to get column or row index" );
394 8 : }
395 :
396 : /** compare position of two cells (check rows first)
397 : *
398 : * @note this function probably also make sense only
399 : * for cell names of non-complex tables
400 : *
401 : * @param rCellName1 e.g. "A1" (non-empty string with valid cell name)
402 : * @param rCellName2 e.g. "A1" (non-empty string with valid cell name)
403 : * @return -1 if cell_1 < cell_2; 0 if both cells are equal; +1 if cell_1 > cell_2
404 : */
405 0 : int sw_CompareCellsByRowFirst( const OUString &rCellName1, const OUString &rCellName2 )
406 : {
407 0 : sal_Int32 nCol1 = -1, nRow1 = -1, nCol2 = -1, nRow2 = -1;
408 0 : sw_GetCellPosition( rCellName1, nCol1, nRow1 );
409 0 : sw_GetCellPosition( rCellName2, nCol2, nRow2 );
410 :
411 0 : if (nRow1 < nRow2 || (nRow1 == nRow2 && nCol1 < nCol2))
412 0 : return -1;
413 0 : else if (nCol1 == nCol2 && nRow1 == nRow2)
414 0 : return 0;
415 : else
416 0 : return +1;
417 : }
418 :
419 : /** compare position of two cells (check columns first)
420 : *
421 : * @note this function probably also make sense only
422 : * for cell names of non-complex tables
423 : *
424 : * @param rCellName1 e.g. "A1" (non-empty string with valid cell name)
425 : * @param rCellName2 e.g. "A1" (non-empty string with valid cell name)
426 : * @return -1 if cell_1 < cell_2; 0 if both cells are equal; +1 if cell_1 > cell_2
427 : */
428 0 : int sw_CompareCellsByColFirst( const OUString &rCellName1, const OUString &rCellName2 )
429 : {
430 0 : sal_Int32 nCol1 = -1, nRow1 = -1, nCol2 = -1, nRow2 = -1;
431 0 : sw_GetCellPosition( rCellName1, nCol1, nRow1 );
432 0 : sw_GetCellPosition( rCellName2, nCol2, nRow2 );
433 :
434 0 : if (nCol1 < nCol2 || (nCol1 == nCol2 && nRow1 < nRow2))
435 0 : return -1;
436 0 : else if (nRow1 == nRow2 && nCol1 == nCol2)
437 0 : return 0;
438 : else
439 0 : return +1;
440 : }
441 :
442 : /** compare position of two cell ranges
443 : *
444 : * @note this function probably also make sense only
445 : * for cell names of non-complex tables
446 : *
447 : * @param rRange1StartCell e.g. "A1" (non-empty string with valid cell name)
448 : * @param rRange1EndCell e.g. "A1" (non-empty string with valid cell name)
449 : * @param rRange2StartCell e.g. "A1" (non-empty string with valid cell name)
450 : * @param rRange2EndCell e.g. "A1" (non-empty string with valid cell name)
451 : * @param bCmpColsFirst if <true> position in columns will be compared first before rows
452 : *
453 : * @return -1 if cell_range_1 < cell_range_2; 0 if both cell ranges are equal; +1 if cell_range_1 > cell_range_2
454 : */
455 0 : int sw_CompareCellRanges(
456 : const OUString &rRange1StartCell, const OUString &rRange1EndCell,
457 : const OUString &rRange2StartCell, const OUString &rRange2EndCell,
458 : bool bCmpColsFirst )
459 : {
460 : int (*pCompareCells)( const OUString &, const OUString & ) =
461 0 : bCmpColsFirst ? &sw_CompareCellsByColFirst : &sw_CompareCellsByRowFirst;
462 :
463 0 : int nCmpResStartCells = pCompareCells( rRange1StartCell, rRange2StartCell );
464 0 : if ((-1 == nCmpResStartCells ) ||
465 0 : ( 0 == nCmpResStartCells &&
466 0 : -1 == pCompareCells( rRange1EndCell, rRange2EndCell ) ))
467 0 : return -1;
468 0 : else if (0 == nCmpResStartCells &&
469 0 : 0 == pCompareCells( rRange1EndCell, rRange2EndCell ))
470 0 : return 0;
471 : else
472 0 : return +1;
473 : }
474 :
475 : /** get cell name at a specified coordinate
476 : *
477 : * @param nColumn column index (0-based)
478 : * @param nRow row index (0-based)
479 : * @return the cell name
480 : */
481 21414 : OUString sw_GetCellName( sal_Int32 nColumn, sal_Int32 nRow )
482 : {
483 : #if OSL_DEBUG_LEVEL > 0
484 : {
485 : sal_Int32 nCol, nRow2;
486 : sw_GetCellPosition( OUString("z1"), nCol, nRow2);
487 : OSL_ENSURE( nCol == 51, "sw_GetCellPosition failed" );
488 : sw_GetCellPosition( OUString("AA1"), nCol, nRow2);
489 : OSL_ENSURE( nCol == 52, "sw_GetCellPosition failed" );
490 : sw_GetCellPosition( OUString("AB1"), nCol, nRow2);
491 : OSL_ENSURE( nCol == 53, "sw_GetCellPosition failed" );
492 : sw_GetCellPosition( OUString("BB1"), nCol, nRow2);
493 : OSL_ENSURE( nCol == 105, "sw_GetCellPosition failed" );
494 : }
495 : #endif
496 :
497 21414 : if (nColumn < 0 || nRow < 0)
498 0 : return OUString();
499 21414 : OUString sCellName;
500 21414 : sw_GetTblBoxColStr( static_cast< sal_uInt16 >(nColumn), sCellName );
501 21414 : return sCellName + OUString::number( nRow + 1 );
502 : }
503 :
504 : /** Find the top left or bottom right corner box in given table.
505 : Consider nested lines when finding the box.
506 :
507 : @param rTableLines the table
508 : @param i_bTopLeft if true, find top left box, otherwise find bottom
509 : right box
510 : */
511 76 : const SwTableBox* lcl_FindCornerTableBox(const SwTableLines& rTableLines, const bool i_bTopLeft)
512 : {
513 76 : bool bFirst = true;
514 76 : const SwTableBox* pBox = 0;
515 76 : do
516 : {
517 76 : const SwTableLines& rLines(bFirst ? rTableLines : pBox->GetTabLines());
518 76 : bFirst = false;
519 : OSL_ASSERT(rLines.size() != 0);
520 76 : if (!rLines.empty())
521 : {
522 76 : const SwTableLine* pLine(i_bTopLeft ? rLines.front() : rLines.back());
523 : OSL_ASSERT(pLine);
524 76 : const SwTableBoxes& rBoxes(pLine->GetTabBoxes());
525 : OSL_ASSERT(rBoxes.size() != 0);
526 76 : pBox = i_bTopLeft ? rBoxes.front() : rBoxes.back();
527 : OSL_ASSERT(pBox);
528 : }
529 : else
530 : {
531 0 : pBox = 0;
532 : }
533 76 : } while (pBox && !pBox->GetSttNd());
534 76 : return pBox;
535 : }
536 :
537 : /** cleanup order in a range
538 : *
539 : * Sorts the input to a uniform format. I.e. for the four possible representation
540 : * A1:C5, C5:A1, A5:C1, C1:A5
541 : * the result will be always A1:C5.
542 : *
543 : * @param [IN,OUT] rCell1 cell name (will be modified to upper-left corner), e.g. "A1" (non-empty string with valid cell name)
544 : * @param [IN,OUT] rCell2 cell name (will be modified to lower-right corner), e.g. "A1" (non-empty string with valid cell name)
545 : */
546 0 : void sw_NormalizeRange(OUString &rCell1, OUString &rCell2)
547 : {
548 0 : sal_Int32 nCol1 = -1, nRow1 = -1, nCol2 = -1, nRow2 = -1;
549 0 : sw_GetCellPosition( rCell1, nCol1, nRow1 );
550 0 : sw_GetCellPosition( rCell2, nCol2, nRow2 );
551 0 : if (nCol2 < nCol1 || nRow2 < nRow1)
552 : {
553 0 : rCell1 = sw_GetCellName( std::min(nCol1, nCol2), std::min(nRow1, nRow2) );
554 0 : rCell2 = sw_GetCellName( std::max(nCol1, nCol2), std::max(nRow1, nRow2) );
555 : }
556 0 : }
557 :
558 22 : void SwRangeDescriptor::Normalize()
559 : {
560 22 : if (nTop > nBottom)
561 : {
562 0 : sal_Int32 nTmp = nTop;
563 0 : nTop = nBottom;
564 0 : nBottom = nTmp;
565 : }
566 22 : if (nLeft > nRight)
567 : {
568 0 : sal_Int32 nTmp = nLeft;
569 0 : nLeft = nRight;
570 0 : nRight = nTmp;
571 : }
572 22 : }
573 :
574 21384 : static SwXCell* lcl_CreateXCell(SwFrmFmt* pFmt, sal_Int32 nColumn, sal_Int32 nRow)
575 : {
576 21384 : SwXCell* pXCell = 0;
577 21384 : const OUString sCellName = sw_GetCellName(nColumn, nRow);
578 21384 : SwTable* pTable = SwTable::FindTable( pFmt );
579 21384 : SwTableBox* pBox = (SwTableBox*)pTable->GetTblBox( sCellName );
580 21384 : if(pBox)
581 : {
582 21382 : pXCell = SwXCell::CreateXCell(pFmt, pBox, pTable);
583 : }
584 21384 : return pXCell;
585 : }
586 :
587 60 : static void lcl_InspectLines(SwTableLines& rLines, std::vector<OUString*>& rAllNames)
588 : {
589 192 : for( size_t i = 0; i < rLines.size(); ++i )
590 : {
591 132 : SwTableLine* pLine = rLines[i];
592 132 : SwTableBoxes& rBoxes = pLine->GetTabBoxes();
593 818 : for(size_t j = 0; j < rBoxes.size(); ++j)
594 : {
595 686 : SwTableBox* pBox = rBoxes[j];
596 686 : if(!pBox->GetName().isEmpty() && pBox->getRowSpan() > 0 )
597 686 : rAllNames.push_back( new OUString(pBox->GetName()) );
598 686 : SwTableLines& rBoxLines = pBox->GetTabLines();
599 686 : if(!rBoxLines.empty())
600 : {
601 0 : lcl_InspectLines(rBoxLines, rAllNames);
602 : }
603 : }
604 : }
605 60 : }
606 :
607 786 : static void lcl_FormatTable(SwFrmFmt* pTblFmt)
608 : {
609 786 : SwIterator<SwFrm,SwFmt> aIter( *pTblFmt );
610 1500 : for( SwFrm* pFrm = aIter.First(); pFrm; pFrm = aIter.Next() )
611 : {
612 : // mba: no TYPEINFO for SwTabFrm
613 714 : if( pFrm->IsTabFrm() )
614 : {
615 714 : if(pFrm->IsValid())
616 602 : pFrm->InvalidatePos();
617 714 : ((SwTabFrm*)pFrm)->SetONECalcLowers();
618 714 : ((SwTabFrm*)pFrm)->Calc();
619 : }
620 786 : }
621 786 : }
622 :
623 42 : static void lcl_CrsrSelect(SwPaM& rCrsr, bool bExpand)
624 : {
625 42 : if(bExpand)
626 : {
627 10 : if(!rCrsr.HasMark())
628 10 : rCrsr.SetMark();
629 : }
630 32 : else if(rCrsr.HasMark())
631 4 : rCrsr.DeleteMark();
632 42 : }
633 :
634 36 : static void lcl_GetTblSeparators(uno::Any& rRet, SwTable* pTable, SwTableBox* pBox, bool bRow)
635 : {
636 36 : SwTabCols aCols;
637 36 : aCols.SetLeftMin ( 0 );
638 36 : aCols.SetLeft ( 0 );
639 36 : aCols.SetRight ( UNO_TABLE_COLUMN_SUM );
640 36 : aCols.SetRightMax( UNO_TABLE_COLUMN_SUM );
641 :
642 36 : pTable->GetTabCols( aCols, pBox, false, bRow );
643 :
644 36 : const size_t nSepCount = aCols.Count();
645 72 : uno::Sequence< text::TableColumnSeparator> aColSeq(nSepCount);
646 36 : text::TableColumnSeparator* pArray = aColSeq.getArray();
647 36 : bool bError = false;
648 158 : for(size_t i = 0; i < nSepCount; ++i)
649 : {
650 122 : pArray[i].Position = static_cast< sal_Int16 >(aCols[i]);
651 122 : pArray[i].IsVisible = !aCols.IsHidden(i);
652 122 : if(!bRow && !pArray[i].IsVisible)
653 : {
654 0 : bError = true;
655 0 : break;
656 : }
657 : }
658 36 : if(!bError)
659 72 : rRet.setValue(&aColSeq, ::getCppuType((uno::Sequence< text::TableColumnSeparator>*)0));
660 :
661 36 : }
662 :
663 5354 : static void lcl_SetTblSeparators(const uno::Any& rVal, SwTable* pTable, SwTableBox* pBox, bool bRow, SwDoc* pDoc)
664 : {
665 5354 : SwTabCols aOldCols;
666 :
667 5354 : aOldCols.SetLeftMin ( 0 );
668 5354 : aOldCols.SetLeft ( 0 );
669 5354 : aOldCols.SetRight ( UNO_TABLE_COLUMN_SUM );
670 5354 : aOldCols.SetRightMax( UNO_TABLE_COLUMN_SUM );
671 :
672 5354 : pTable->GetTabCols( aOldCols, pBox, false, bRow );
673 5354 : const size_t nOldCount = aOldCols.Count();
674 : // there is no use in setting tab cols if there is only one column
675 5354 : if( !nOldCount )
676 6104 : return;
677 :
678 : const uno::Sequence< text::TableColumnSeparator>* pSepSeq =
679 4604 : (uno::Sequence< text::TableColumnSeparator>*) rVal.getValue();
680 4604 : if(pSepSeq && static_cast<size_t>(pSepSeq->getLength()) == nOldCount)
681 : {
682 4604 : SwTabCols aCols(aOldCols);
683 4604 : bool bError = false;
684 4604 : const text::TableColumnSeparator* pArray = pSepSeq->getConstArray();
685 4604 : long nLastValue = 0;
686 : //sal_Int32 nTblWidth = aCols.GetRight() - aCols.GetLeft();
687 14160 : for(size_t i = 0; i < nOldCount; ++i)
688 : {
689 9560 : aCols[i] = pArray[i].Position;
690 28676 : if(pArray[i].IsVisible == (aCols.IsHidden(i) ? 1 : 0) ||
691 19112 : (!bRow && aCols.IsHidden(i)) ||
692 28672 : aCols[i] < nLastValue ||
693 9556 : UNO_TABLE_COLUMN_SUM < aCols[i] )
694 : {
695 4 : bError = true;
696 4 : break;
697 : }
698 9556 : nLastValue = aCols[i];
699 : }
700 4604 : if(!bError)
701 : {
702 4600 : pDoc->SetTabCols(*pTable, aCols, aOldCols, pBox, bRow );
703 4604 : }
704 4604 : }
705 : }
706 :
707 64 : static inline OUString lcl_getString( SwXCell &rCell )
708 : {
709 : // getString is a member function of the base class...
710 64 : return rCell.getString();
711 : }
712 :
713 : /* non UNO function call to set string in SwXCell */
714 238 : void sw_setString( SwXCell &rCell, const OUString &rTxt,
715 : bool bKeepNumberFmt = false )
716 : {
717 238 : if(rCell.IsValid())
718 : {
719 238 : SwFrmFmt* pBoxFmt = rCell.pBox->ClaimFrmFmt();
720 238 : pBoxFmt->LockModify();
721 238 : pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMULA );
722 238 : pBoxFmt->ResetFmtAttr( RES_BOXATR_VALUE );
723 238 : if (!bKeepNumberFmt)
724 94 : pBoxFmt->SetFmtAttr( SwTblBoxNumFormat(NUMBERFORMAT_TEXT) );
725 238 : pBoxFmt->UnlockModify();
726 : }
727 238 : rCell.SwXText::setString(rTxt);
728 238 : }
729 :
730 : /* non UNO function call to get value from SwXCell */
731 192 : double sw_getValue( SwXCell &rCell )
732 : {
733 : double fRet;
734 192 : if(rCell.IsValid() && !rCell.getString().isEmpty())
735 132 : fRet = rCell.pBox->GetFrmFmt()->GetTblBoxValue().GetValue();
736 : else
737 60 : ::rtl::math::setNan( &fRet );
738 192 : return fRet;
739 : }
740 :
741 : /* non UNO function call to set value in SwXCell */
742 144 : void sw_setValue( SwXCell &rCell, double nVal )
743 : {
744 144 : if(rCell.IsValid())
745 : {
746 : // first this text (maybe) needs to be deleted
747 144 : sal_uLong nNdPos = rCell.pBox->IsValidNumTxtNd( true );
748 144 : if(ULONG_MAX != nNdPos)
749 144 : sw_setString( rCell, OUString(), true ); // sal_True == keep number format
750 144 : SwDoc* pDoc = rCell.GetDoc();
751 144 : UnoActionContext aAction(pDoc);
752 144 : SwFrmFmt* pBoxFmt = rCell.pBox->ClaimFrmFmt();
753 288 : SfxItemSet aSet(pDoc->GetAttrPool(), RES_BOXATR_FORMAT, RES_BOXATR_VALUE);
754 : const SfxPoolItem* pItem;
755 :
756 : //!! do we need to set a new number format? Yes, if
757 : // - there is no current number format
758 : // - the current number format is not a number format according to the number formatter, but rather a text format
759 : // - the current number format is not even a valid number formatter number format, but rather Writer's own 'special' text number format
760 288 : if(SfxItemState::SET != pBoxFmt->GetAttrSet().GetItemState(RES_BOXATR_FORMAT, true, &pItem)
761 60 : || pDoc->GetNumberFormatter()->IsTextFormat(((SwTblBoxNumFormat*)pItem)->GetValue())
762 204 : || ((SwTblBoxNumFormat*)pItem)->GetValue() == NUMBERFORMAT_TEXT)
763 : {
764 134 : aSet.Put(SwTblBoxNumFormat(0));
765 : }
766 :
767 288 : SwTblBoxValue aVal(nVal);
768 144 : aSet.Put(aVal);
769 144 : pDoc->SetTblBoxFormulaAttrs( *rCell.pBox, aSet );
770 : // update table
771 288 : SwTableFmlUpdate aTblUpdate( SwTable::FindTable( rCell.GetFrmFmt() ));
772 288 : pDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate );
773 : }
774 144 : }
775 :
776 119344 : TYPEINIT1(SwXCell, SwClient);
777 :
778 22002 : SwXCell::SwXCell(SwFrmFmt* pTblFmt, SwTableBox* pBx, size_t const nPos) :
779 : SwXText(pTblFmt->GetDoc(), CURSOR_TBLTEXT),
780 : SwClient(pTblFmt),
781 22002 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TABLE_CELL)),
782 : pBox(pBx),
783 : pStartNode(0),
784 44004 : nFndPos(nPos)
785 : {
786 22002 : }
787 :
788 0 : SwXCell::SwXCell(SwFrmFmt* pTblFmt, const SwStartNode& rStartNode) :
789 : SwXText(pTblFmt->GetDoc(), CURSOR_TBLTEXT),
790 : SwClient(pTblFmt),
791 0 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TABLE_CELL)),
792 : pBox(0),
793 : pStartNode(&rStartNode),
794 0 : nFndPos(NOTFOUND)
795 : {
796 0 : }
797 :
798 44004 : SwXCell::~SwXCell()
799 : {
800 44004 : }
801 :
802 : namespace
803 : {
804 : class theSwXCellUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXCellUnoTunnelId > {};
805 : }
806 :
807 974 : const uno::Sequence< sal_Int8 > & SwXCell::getUnoTunnelId()
808 : {
809 974 : return theSwXCellUnoTunnelId::get().getSeq();
810 : }
811 :
812 974 : sal_Int64 SAL_CALL SwXCell::getSomething( const uno::Sequence< sal_Int8 >& rId )
813 : throw(uno::RuntimeException, std::exception)
814 : {
815 1948 : if( rId.getLength() == 16
816 2922 : && 0 == memcmp( getUnoTunnelId().getConstArray(),
817 1948 : rId.getConstArray(), 16 ) )
818 : {
819 0 : return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
820 : }
821 : else
822 974 : return SwXText::getSomething(rId);
823 : }
824 :
825 0 : uno::Sequence< uno::Type > SAL_CALL SwXCell::getTypes( ) throw(uno::RuntimeException, std::exception)
826 : {
827 0 : static uno::Sequence< uno::Type > aRetTypes;
828 0 : if(!aRetTypes.getLength())
829 : {
830 0 : aRetTypes = SwXCellBaseClass::getTypes();
831 0 : uno::Sequence< uno::Type > aTextTypes = SwXText::getTypes();
832 :
833 0 : long nIndex = aRetTypes.getLength();
834 : aRetTypes.realloc(
835 0 : aRetTypes.getLength() +
836 0 : aTextTypes.getLength());
837 :
838 0 : uno::Type* pRetTypes = aRetTypes.getArray();
839 :
840 0 : const uno::Type* pTextTypes = aTextTypes.getConstArray();
841 0 : for(long nPos = 0; nPos <aTextTypes.getLength(); nPos++)
842 0 : pRetTypes[nIndex++] = pTextTypes[nPos];
843 : }
844 0 : return aRetTypes;
845 : }
846 :
847 0 : uno::Sequence< sal_Int8 > SAL_CALL SwXCell::getImplementationId( ) throw(uno::RuntimeException, std::exception)
848 : {
849 0 : return css::uno::Sequence<sal_Int8>();
850 : }
851 :
852 289342 : void SAL_CALL SwXCell::acquire( ) throw()
853 : {
854 289342 : SwXCellBaseClass::acquire();
855 289342 : }
856 :
857 289342 : void SAL_CALL SwXCell::release( ) throw()
858 : {
859 289342 : SwXCellBaseClass::release();
860 289342 : }
861 :
862 53496 : uno::Any SAL_CALL SwXCell::queryInterface( const uno::Type& aType )
863 : throw (uno::RuntimeException, std::exception)
864 : {
865 53496 : uno::Any aRet = SwXCellBaseClass::queryInterface(aType);
866 53496 : if(aRet.getValueType() == ::getCppuVoidType())
867 32004 : aRet = SwXText::queryInterface(aType);
868 53496 : return aRet;
869 : }
870 :
871 1002 : const SwStartNode *SwXCell::GetStartNode() const
872 : {
873 1002 : const SwStartNode *pSttNd = 0;
874 :
875 1002 : if( pStartNode || ((SwXCell *)this)->IsValid() )
876 1002 : pSttNd = pStartNode ? pStartNode : pBox->GetSttNd();
877 :
878 1002 : return pSttNd;
879 : }
880 :
881 : uno::Reference< text::XTextCursor >
882 644 : SwXCell::CreateCursor() throw (uno::RuntimeException)
883 : {
884 644 : return createTextCursor();
885 : }
886 :
887 206760 : bool SwXCell::IsValid() const
888 : {
889 : // FIXME: this is now a const method, to make SwXText::IsValid invisible
890 : // but the const_cast here are still ridiculous. TODO: find a better way.
891 206760 : SwFrmFmt* pTblFmt = pBox ? GetFrmFmt() : 0;
892 206760 : if(!pTblFmt)
893 : {
894 0 : const_cast<SwXCell*>(this)->pBox = 0;
895 : }
896 : else
897 : {
898 206760 : SwTable* pTable = SwTable::FindTable( pTblFmt );
899 : SwTableBox const*const pFoundBox =
900 206760 : const_cast<SwXCell*>(this)->FindBox(pTable, pBox);
901 206760 : if (!pFoundBox)
902 : {
903 0 : const_cast<SwXCell*>(this)->pBox = 0;
904 : }
905 : }
906 206760 : return 0 != pBox;
907 : }
908 :
909 8 : OUString SwXCell::getFormula(void) throw( uno::RuntimeException, std::exception )
910 : {
911 8 : SolarMutexGuard aGuard;
912 8 : OUString sRet;
913 8 : if(IsValid())
914 : {
915 8 : SwTblBoxFormula aFormula( pBox->GetFrmFmt()->GetTblBoxFormula() );
916 8 : SwTable* pTable = SwTable::FindTable( GetFrmFmt() );
917 8 : aFormula.PtrToBoxNm( pTable );
918 8 : sRet = aFormula.GetFormula();
919 : }
920 8 : return sRet;
921 : }
922 :
923 : ///@see sw_setValue (TODO: seems to be copy and paste programming here)
924 0 : void SwXCell::setFormula(const OUString& rFormula) throw( uno::RuntimeException, std::exception )
925 : {
926 0 : SolarMutexGuard aGuard;
927 0 : if(IsValid())
928 : {
929 : // first this text (maybe) needs to be deleted
930 0 : sal_uInt32 nNdPos = pBox->IsValidNumTxtNd( true );
931 0 : if(USHRT_MAX == nNdPos)
932 0 : sw_setString( *this, OUString(), true );
933 0 : OUString sFml(comphelper::string::stripStart(rFormula, ' '));
934 0 : if( !sFml.isEmpty() && '=' == sFml[0] )
935 0 : sFml = sFml.copy( 1 );
936 0 : SwTblBoxFormula aFml( sFml );
937 0 : SwDoc* pMyDoc = GetDoc();
938 0 : UnoActionContext aAction(pMyDoc);
939 0 : SfxItemSet aSet(pMyDoc->GetAttrPool(), RES_BOXATR_FORMAT, RES_BOXATR_FORMULA);
940 : const SfxPoolItem* pItem;
941 0 : SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
942 0 : if(SfxItemState::SET != pBoxFmt->GetAttrSet().GetItemState(RES_BOXATR_FORMAT, true, &pItem)
943 0 : || pMyDoc->GetNumberFormatter()->IsTextFormat(((SwTblBoxNumFormat*)pItem)->GetValue()))
944 : {
945 0 : aSet.Put(SwTblBoxNumFormat(0));
946 : }
947 0 : aSet.Put(aFml);
948 0 : GetDoc()->SetTblBoxFormulaAttrs( *pBox, aSet );
949 : // update table
950 0 : SwTableFmlUpdate aTblUpdate( SwTable::FindTable( GetFrmFmt() ));
951 0 : pMyDoc->getIDocumentFieldsAccess().UpdateTblFlds( &aTblUpdate );
952 0 : }
953 0 : }
954 :
955 128 : double SwXCell::getValue(void) throw( uno::RuntimeException, std::exception )
956 : {
957 128 : SolarMutexGuard aGuard;
958 :
959 128 : double const fRet = sw_getValue( *this );
960 : // #i112652# a table cell may contain NaN as a value, do not filter that
961 128 : return fRet;
962 : }
963 :
964 80 : void SwXCell::setValue(double rValue) throw( uno::RuntimeException, std::exception )
965 : {
966 80 : SolarMutexGuard aGuard;
967 80 : sw_setValue( *this, rValue );
968 80 : }
969 :
970 0 : table::CellContentType SwXCell::getType(void) throw( uno::RuntimeException, std::exception )
971 : {
972 0 : SolarMutexGuard aGuard;
973 :
974 0 : table::CellContentType nRes = table::CellContentType_EMPTY;
975 0 : sal_uInt32 nNdPos = pBox->IsFormulaOrValueBox();
976 0 : switch (nNdPos)
977 : {
978 0 : case 0 : nRes = table::CellContentType_TEXT; break;
979 0 : case USHRT_MAX : nRes = table::CellContentType_EMPTY; break;
980 0 : case RES_BOXATR_VALUE : nRes = table::CellContentType_VALUE; break;
981 0 : case RES_BOXATR_FORMULA : nRes = table::CellContentType_FORMULA; break;
982 : default :
983 : OSL_FAIL( "unexpected case" );
984 : }
985 0 : return nRes;
986 : }
987 :
988 30 : void SwXCell::setString(const OUString& aString) throw( uno::RuntimeException, std::exception )
989 : {
990 30 : SolarMutexGuard aGuard;
991 30 : sw_setString( *this, aString );
992 30 : }
993 :
994 0 : sal_Int32 SwXCell::getError(void) throw( uno::RuntimeException, std::exception )
995 : {
996 0 : SolarMutexGuard aGuard;
997 0 : OUString sContent = getString();
998 0 : return sal_Int32(sContent.equals(SwViewShell::GetShellRes()->aCalc_Error));
999 : }
1000 :
1001 31506 : uno::Reference< text::XTextCursor > SwXCell::createTextCursor(void) throw( uno::RuntimeException, std::exception )
1002 : {
1003 31506 : SolarMutexGuard aGuard;
1004 31506 : uno::Reference< text::XTextCursor > aRef;
1005 31506 : if(pStartNode || IsValid())
1006 : {
1007 31506 : const SwStartNode* pSttNd = pStartNode ? pStartNode : pBox->GetSttNd();
1008 31506 : SwPosition aPos(*pSttNd);
1009 : SwXTextCursor *const pXCursor =
1010 31506 : new SwXTextCursor(*GetDoc(), this, CURSOR_TBLTEXT, aPos);
1011 31506 : SwUnoCrsr *const pUnoCrsr = pXCursor->GetCursor();
1012 31506 : pUnoCrsr->Move(fnMoveForward, fnGoNode);
1013 31506 : aRef = static_cast<text::XWordCursor*>(pXCursor);
1014 : }
1015 : else
1016 0 : throw uno::RuntimeException();
1017 31506 : return aRef;
1018 : }
1019 :
1020 1928 : uno::Reference< text::XTextCursor > SwXCell::createTextCursorByRange(const uno::Reference< text::XTextRange > & xTextPosition)
1021 : throw( uno::RuntimeException, std::exception )
1022 : {
1023 1928 : SolarMutexGuard aGuard;
1024 1928 : uno::Reference< text::XTextCursor > aRef;
1025 3856 : SwUnoInternalPaM aPam(*GetDoc());
1026 3856 : if ((pStartNode || IsValid())
1027 3856 : && ::sw::XTextRangeToSwPaM(aPam, xTextPosition))
1028 : {
1029 1928 : const SwStartNode* pSttNd = pStartNode ? pStartNode : pBox->GetSttNd();
1030 : // skip sections
1031 1928 : SwStartNode* p1 = aPam.GetNode().StartOfSectionNode();
1032 3856 : while(p1->IsSectionNode())
1033 0 : p1 = p1->StartOfSectionNode();
1034 :
1035 1928 : if( p1 == pSttNd )
1036 : {
1037 : aRef = static_cast<text::XWordCursor*>(
1038 1928 : new SwXTextCursor(*GetDoc(), this, CURSOR_TBLTEXT,
1039 1928 : *aPam.GetPoint(), aPam.GetMark()));
1040 : }
1041 : }
1042 : else
1043 0 : throw uno::RuntimeException();
1044 3856 : return aRef;
1045 : }
1046 :
1047 4 : uno::Reference< beans::XPropertySetInfo > SwXCell::getPropertySetInfo(void) throw( uno::RuntimeException, std::exception )
1048 : {
1049 4 : static uno::Reference< beans::XPropertySetInfo > xRef = m_pPropSet->getPropertySetInfo();
1050 4 : return xRef;
1051 : }
1052 :
1053 164980 : void SwXCell::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
1054 : throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1055 : {
1056 164980 : SolarMutexGuard aGuard;
1057 164980 : if(IsValid())
1058 : {
1059 : // Hack to support hidden property to transfer textDirection
1060 164980 : if ( rPropertyName == "FRMDirection" )
1061 : {
1062 66 : SvxFrameDirection eDir = FRMDIR_ENVIRONMENT;
1063 66 : sal_Int16 nNum = 0;
1064 66 : aValue >>= nNum;
1065 : OSL_TRACE("FRMDirection val %d", nNum );
1066 66 : switch (nNum)
1067 : {
1068 : case 0:
1069 64 : eDir = FRMDIR_HORI_LEFT_TOP;
1070 64 : break;
1071 : case 1:
1072 0 : eDir = FRMDIR_HORI_RIGHT_TOP;
1073 0 : break;
1074 : case 2:
1075 2 : eDir = FRMDIR_VERT_TOP_RIGHT;
1076 2 : break;
1077 : default:
1078 : OSL_FAIL( "unknown direction code, maybe it's a bitfield");
1079 : }
1080 66 : SvxFrameDirectionItem aItem( eDir, RES_FRAMEDIR);
1081 66 : pBox->GetFrmFmt()->SetFmtAttr(aItem);
1082 : }
1083 164914 : else if ( rPropertyName == "TableRedlineParams" )
1084 : {
1085 : // Get the table row properties
1086 12 : uno::Sequence< beans::PropertyValue > tableCellProperties;
1087 12 : tableCellProperties = aValue.get< uno::Sequence< beans::PropertyValue > >();
1088 24 : comphelper::SequenceAsHashMap aPropMap( tableCellProperties );
1089 24 : OUString sRedlineType;
1090 24 : uno::Any sRedlineTypeValue;
1091 12 : sRedlineTypeValue = aPropMap.getUnpackedValueOrDefault("RedlineType", sRedlineTypeValue);
1092 12 : if( sRedlineTypeValue >>= sRedlineType )
1093 : {
1094 : // Create a 'Table Cell Redline' object
1095 12 : SwUnoCursorHelper::makeTableCellRedline( *pBox, sRedlineType, tableCellProperties);
1096 : }
1097 : else
1098 : {
1099 0 : throw beans::UnknownPropertyException("No redline type property: ", static_cast < cppu::OWeakObject * > ( this ) );
1100 12 : }
1101 : }
1102 : else
1103 : {
1104 : const SfxItemPropertySimpleEntry* pEntry =
1105 164902 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
1106 164902 : if( !pEntry )
1107 : {
1108 30744 : beans::UnknownPropertyException aEx;
1109 30744 : aEx.Message = rPropertyName;
1110 30744 : throw( aEx );
1111 : }
1112 134158 : if( pEntry->nWID == FN_UNO_CELL_ROW_SPAN )
1113 : {
1114 246 : sal_Int32 nRowSpan = 0;
1115 246 : if( aValue >>= nRowSpan )
1116 246 : pBox->setRowSpan( nRowSpan );
1117 : }
1118 : else
1119 : {
1120 133912 : SwFrmFmt* pBoxFmt = pBox->ClaimFrmFmt();
1121 133912 : SwAttrSet aSet(pBoxFmt->GetAttrSet());
1122 133912 : m_pPropSet->setPropertyValue(rPropertyName, aValue, aSet);
1123 133912 : pBoxFmt->GetDoc()->SetAttr(aSet, *pBoxFmt);
1124 : }
1125 : }
1126 164980 : }
1127 134236 : }
1128 :
1129 890 : uno::Any SwXCell::getPropertyValue(const OUString& rPropertyName)
1130 : throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1131 : {
1132 890 : SolarMutexGuard aGuard;
1133 890 : uno::Any aRet;
1134 890 : if(IsValid())
1135 : {
1136 : const SfxItemPropertySimpleEntry* pEntry =
1137 890 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
1138 890 : if( !pEntry )
1139 : {
1140 0 : beans::UnknownPropertyException aEx;
1141 0 : aEx.Message = rPropertyName;
1142 0 : throw( aEx );
1143 : }
1144 890 : switch( pEntry->nWID )
1145 : {
1146 : case FN_UNO_CELL_ROW_SPAN:
1147 0 : aRet <<= pBox->getRowSpan();
1148 0 : break;
1149 : case FN_UNO_TEXT_SECTION:
1150 : {
1151 6 : SwFrmFmt* pTblFmt = GetFrmFmt();
1152 6 : SwTable* pTable = SwTable::FindTable( pTblFmt );
1153 6 : SwTableNode* pTblNode = pTable->GetTableNode();
1154 6 : SwSectionNode* pSectionNode = pTblNode->FindSectionNode();
1155 6 : if(pSectionNode)
1156 : {
1157 0 : const SwSection& rSect = pSectionNode->GetSection();
1158 : uno::Reference< text::XTextSection > xSect =
1159 0 : SwXTextSections::GetObject( *rSect.GetFmt() );
1160 0 : aRet <<= xSect;
1161 : }
1162 : }
1163 6 : break;
1164 : case FN_UNO_CELL_NAME:
1165 8 : aRet <<= pBox->GetName();
1166 8 : break;
1167 : case FN_UNO_REDLINE_NODE_START:
1168 : case FN_UNO_REDLINE_NODE_END:
1169 : {
1170 : //redline can only be returned if it's a living object
1171 20 : aRet = SwXText::getPropertyValue(rPropertyName);
1172 : }
1173 20 : break;
1174 : default:
1175 : {
1176 856 : const SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
1177 856 : const SwAttrSet& rSet = pBoxFmt->GetAttrSet();
1178 856 : m_pPropSet->getPropertyValue(rPropertyName, rSet, aRet);
1179 : }
1180 : }
1181 : }
1182 890 : return aRet;
1183 : }
1184 :
1185 0 : void SwXCell::addPropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1186 : {
1187 : OSL_FAIL("not implemented");
1188 0 : }
1189 :
1190 0 : void SwXCell::removePropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1191 : {
1192 : OSL_FAIL("not implemented");
1193 0 : }
1194 :
1195 0 : void SwXCell::addVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1196 : {
1197 : OSL_FAIL("not implemented");
1198 0 : }
1199 :
1200 0 : void SwXCell::removeVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1201 : {
1202 : OSL_FAIL("not implemented");
1203 0 : }
1204 :
1205 5872 : uno::Reference< container::XEnumeration > SwXCell::createEnumeration(void) throw( uno::RuntimeException, std::exception )
1206 : {
1207 5872 : SolarMutexGuard aGuard;
1208 5872 : uno::Reference< container::XEnumeration > aRef;
1209 5872 : if(IsValid())
1210 : {
1211 5872 : const SwStartNode* pSttNd = pBox->GetSttNd();
1212 5872 : SwPosition aPos(*pSttNd);
1213 : ::std::unique_ptr<SwUnoCrsr> pUnoCursor(
1214 11744 : GetDoc()->CreateUnoCrsr(aPos, false));
1215 5872 : pUnoCursor->Move(fnMoveForward, fnGoNode);
1216 :
1217 : // remember table and start node for later travelling
1218 : // (used in export of tables in tables)
1219 5872 : SwTable const*const pTable( & pSttNd->FindTableNode()->GetTable() );
1220 : SwXParagraphEnumeration *const pEnum =
1221 : new SwXParagraphEnumeration(this, std::move(pUnoCursor), CURSOR_TBLTEXT,
1222 5872 : pSttNd, pTable);
1223 :
1224 11744 : aRef = pEnum;
1225 : }
1226 5872 : return aRef;
1227 : }
1228 :
1229 2 : uno::Type SAL_CALL SwXCell::getElementType(void) throw( uno::RuntimeException, std::exception )
1230 : {
1231 2 : return cppu::UnoType<text::XTextRange>::get();
1232 : }
1233 :
1234 2 : sal_Bool SwXCell::hasElements(void) throw( uno::RuntimeException, std::exception )
1235 : {
1236 2 : return sal_True;
1237 : }
1238 :
1239 178 : void SwXCell::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
1240 : {
1241 178 : ClientModify(this, pOld, pNew);
1242 178 : }
1243 :
1244 22960 : SwXCell* SwXCell::CreateXCell(SwFrmFmt* pTblFmt, SwTableBox* pBox, SwTable *pTable )
1245 : {
1246 22960 : SwXCell* pRet = 0;
1247 22960 : if(pTblFmt && pBox)
1248 : {
1249 22960 : if( !pTable )
1250 1554 : pTable = SwTable::FindTable( pTblFmt );
1251 22960 : SwTableSortBoxes::const_iterator it = pTable->GetTabSortBoxes().find( pBox );
1252 :
1253 : // if the box exists, then return a cell
1254 22960 : if( it != pTable->GetTabSortBoxes().end() )
1255 : {
1256 22960 : size_t const nPos = it - pTable->GetTabSortBoxes().begin();
1257 22960 : SwIterator<SwXCell,SwFmt> aIter( *pTblFmt );
1258 22960 : SwXCell* pXCell = aIter.First();
1259 55426 : while( pXCell )
1260 : {
1261 : // is there already a proper cell?
1262 10464 : if(pXCell->GetTblBox() == pBox)
1263 958 : break;
1264 9506 : pXCell = aIter.Next();
1265 : }
1266 : // otherwise create it
1267 22960 : if(!pXCell)
1268 : {
1269 22002 : pXCell = new SwXCell(pTblFmt, pBox, nPos);
1270 : }
1271 22960 : pRet = pXCell;
1272 : }
1273 : }
1274 22960 : return pRet;
1275 : }
1276 :
1277 : /** search if a box exists in a table
1278 : *
1279 : * @param pTable the table to search in
1280 : * @param pBox2 box model to find
1281 : * @return the box if existent in pTable, 0 (!!!) if not found
1282 : */
1283 206760 : SwTableBox* SwXCell::FindBox(SwTable* pTable, SwTableBox* pBox2)
1284 : {
1285 : // check if nFndPos happens to point to the right table box
1286 413519 : if( nFndPos < pTable->GetTabSortBoxes().size() &&
1287 206759 : pBox2 == pTable->GetTabSortBoxes()[ nFndPos ] )
1288 206758 : return pBox2;
1289 :
1290 : // if not, seek the entry (and return, if successful)
1291 2 : SwTableSortBoxes::const_iterator it = pTable->GetTabSortBoxes().find( pBox2 );
1292 2 : if( it != pTable->GetTabSortBoxes().end() )
1293 : {
1294 2 : nFndPos = it - pTable->GetTabSortBoxes().begin();
1295 2 : return pBox2;
1296 : }
1297 :
1298 : // box not found: reset nFndPos pointer
1299 0 : nFndPos = NOTFOUND;
1300 0 : return 0;
1301 : }
1302 :
1303 0 : OUString SwXCell::getImplementationName(void) throw( uno::RuntimeException, std::exception )
1304 : {
1305 0 : return OUString("SwXCell");
1306 : }
1307 :
1308 2 : sal_Bool SwXCell::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
1309 : {
1310 2 : return cppu::supportsService(this, rServiceName);
1311 : }
1312 :
1313 2 : uno::Sequence< OUString > SwXCell::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
1314 : {
1315 2 : uno::Sequence< OUString > aRet(1);
1316 2 : OUString* pArray = aRet.getArray();
1317 2 : pArray[0] = "com.sun.star.text.CellProperties";
1318 2 : return aRet;
1319 : }
1320 :
1321 0 : OUString SwXTextTableRow::getImplementationName(void) throw( uno::RuntimeException, std::exception )
1322 : {
1323 0 : return OUString("SwXTextTableRow");
1324 : }
1325 :
1326 2 : sal_Bool SwXTextTableRow::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
1327 : {
1328 2 : return cppu::supportsService(this, rServiceName);
1329 : }
1330 :
1331 2 : uno::Sequence< OUString > SwXTextTableRow::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
1332 : {
1333 2 : uno::Sequence< OUString > aRet(1);
1334 2 : OUString* pArray = aRet.getArray();
1335 2 : pArray[0] = "com.sun.star.text.TextTableRow";
1336 2 : return aRet;
1337 : }
1338 10910 : TYPEINIT1(SwXTextTableRow, SwClient);
1339 :
1340 5406 : SwXTextTableRow::SwXTextTableRow(SwFrmFmt* pFmt, SwTableLine* pLn) :
1341 : SwClient(pFmt),
1342 5406 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_TABLE_ROW)),
1343 10812 : pLine(pLn)
1344 : {
1345 5406 : }
1346 :
1347 10812 : SwXTextTableRow::~SwXTextTableRow()
1348 : {
1349 10812 : }
1350 :
1351 38 : uno::Reference< beans::XPropertySetInfo > SwXTextTableRow::getPropertySetInfo(void) throw( uno::RuntimeException, std::exception )
1352 : {
1353 38 : static uno::Reference< beans::XPropertySetInfo > xRef = m_pPropSet->getPropertySetInfo();
1354 38 : return xRef;
1355 : }
1356 :
1357 16634 : void SwXTextTableRow::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
1358 : throw (beans::UnknownPropertyException,
1359 : beans::PropertyVetoException,
1360 : lang::IllegalArgumentException,
1361 : lang::WrappedTargetException,
1362 : uno::RuntimeException,
1363 : std::exception)
1364 : {
1365 16634 : SolarMutexGuard aGuard;
1366 16634 : SwFrmFmt* pFmt = GetFrmFmt();
1367 16634 : if(pFmt)
1368 : {
1369 16634 : SwTable* pTable = SwTable::FindTable( pFmt );
1370 16634 : SwTableLine* pLn = SwXTextTableRow::FindLine(pTable, pLine);
1371 16634 : if(pLn)
1372 : {
1373 : // Check for a specific property
1374 16634 : if ( rPropertyName == "TableRedlineParams" )
1375 : {
1376 : // Get the table row properties
1377 56 : uno::Sequence< beans::PropertyValue > tableRowProperties;
1378 56 : tableRowProperties = aValue.get< uno::Sequence< beans::PropertyValue > >();
1379 112 : comphelper::SequenceAsHashMap aPropMap( tableRowProperties );
1380 112 : OUString sRedlineType;
1381 112 : uno::Any sRedlineTypeValue;
1382 56 : sRedlineTypeValue = aPropMap.getUnpackedValueOrDefault("RedlineType", sRedlineTypeValue);
1383 56 : if( sRedlineTypeValue >>= sRedlineType )
1384 : {
1385 : // Create a 'Table Row Redline' object
1386 56 : SwUnoCursorHelper::makeTableRowRedline( *pLn, sRedlineType, tableRowProperties);
1387 : }
1388 : else
1389 : {
1390 0 : throw beans::UnknownPropertyException("No redline type property: ", static_cast < cppu::OWeakObject * > ( this ) );
1391 56 : }
1392 : }
1393 : else
1394 : {
1395 : const SfxItemPropertySimpleEntry* pEntry =
1396 16578 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
1397 16578 : SwDoc* pDoc = pFmt->GetDoc();
1398 16578 : if (!pEntry)
1399 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1400 16578 : if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
1401 0 : throw beans::PropertyVetoException("Property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1402 :
1403 16578 : switch(pEntry->nWID)
1404 : {
1405 : case FN_UNO_ROW_HEIGHT:
1406 : case FN_UNO_ROW_AUTO_HEIGHT:
1407 : {
1408 2644 : SwFmtFrmSize aFrmSize(pLn->GetFrmFmt()->GetFrmSize());
1409 2644 : if(FN_UNO_ROW_AUTO_HEIGHT== pEntry->nWID)
1410 : {
1411 6 : bool bSet = *(sal_Bool*)aValue.getValue();
1412 6 : aFrmSize.SetHeightSizeType(bSet ? ATT_VAR_SIZE : ATT_FIX_SIZE);
1413 : }
1414 : else
1415 : {
1416 2638 : sal_Int32 nHeight = 0;
1417 2638 : aValue >>= nHeight;
1418 2638 : Size aSz(aFrmSize.GetSize());
1419 2638 : aSz.Height() = convertMm100ToTwip(nHeight);
1420 2638 : aFrmSize.SetSize(aSz);
1421 : }
1422 2644 : pDoc->SetAttr(aFrmSize, *pLn->ClaimFrmFmt());
1423 : }
1424 2644 : break;
1425 :
1426 : case FN_UNO_TABLE_COLUMN_SEPARATORS:
1427 : {
1428 5352 : UnoActionContext aContext(pDoc);
1429 5352 : SwTable* pTable2 = SwTable::FindTable( pFmt );
1430 5352 : lcl_SetTblSeparators(aValue, pTable2, pLine->GetTabBoxes()[0], true, pDoc);
1431 : }
1432 5352 : break;
1433 :
1434 : default:
1435 : {
1436 8582 : SwFrmFmt* pLnFmt = pLn->ClaimFrmFmt();
1437 8582 : SwAttrSet aSet(pLnFmt->GetAttrSet());
1438 8582 : m_pPropSet->setPropertyValue(*pEntry, aValue, aSet);
1439 8582 : pDoc->SetAttr(aSet, *pLnFmt);
1440 : }
1441 : }
1442 : }
1443 : }
1444 16634 : }
1445 16632 : }
1446 :
1447 162 : uno::Any SwXTextTableRow::getPropertyValue(const OUString& rPropertyName) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1448 : {
1449 162 : SolarMutexGuard aGuard;
1450 162 : uno::Any aRet;
1451 162 : SwFrmFmt* pFmt = GetFrmFmt();
1452 162 : if(pFmt)
1453 : {
1454 162 : SwTable* pTable = SwTable::FindTable( pFmt );
1455 162 : SwTableLine* pLn = SwXTextTableRow::FindLine(pTable, pLine);
1456 162 : if(pLn)
1457 : {
1458 : const SfxItemPropertySimpleEntry* pEntry =
1459 162 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
1460 162 : if (!pEntry)
1461 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1462 :
1463 162 : switch(pEntry->nWID)
1464 : {
1465 : case FN_UNO_ROW_HEIGHT:
1466 : case FN_UNO_ROW_AUTO_HEIGHT:
1467 : {
1468 32 : const SwFmtFrmSize& rSize = pLn->GetFrmFmt()->GetFrmSize();
1469 32 : if(FN_UNO_ROW_AUTO_HEIGHT== pEntry->nWID)
1470 : {
1471 14 : sal_Bool bTmp = ATT_VAR_SIZE == rSize.GetHeightSizeType();
1472 14 : aRet.setValue(&bTmp, ::getCppuBooleanType());
1473 : }
1474 : else
1475 18 : aRet <<= (sal_Int32)(convertTwipToMm100(rSize.GetSize().Height()));
1476 : }
1477 32 : break;
1478 :
1479 : case FN_UNO_TABLE_COLUMN_SEPARATORS:
1480 : {
1481 32 : lcl_GetTblSeparators(aRet, pTable, pLine->GetTabBoxes()[0], true);
1482 : }
1483 32 : break;
1484 :
1485 : default:
1486 : {
1487 98 : const SwAttrSet& rSet = pLn->GetFrmFmt()->GetAttrSet();
1488 98 : m_pPropSet->getPropertyValue(*pEntry, rSet, aRet);
1489 : }
1490 : }
1491 : }
1492 : }
1493 162 : return aRet;
1494 : }
1495 :
1496 0 : void SwXTextTableRow::addPropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1497 : {
1498 : OSL_FAIL("not implemented");
1499 0 : }
1500 :
1501 0 : void SwXTextTableRow::removePropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1502 : {
1503 : OSL_FAIL("not implemented");
1504 0 : }
1505 :
1506 0 : void SwXTextTableRow::addVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1507 : {
1508 : OSL_FAIL("not implemented");
1509 0 : }
1510 :
1511 0 : void SwXTextTableRow::removeVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1512 : {
1513 : OSL_FAIL("not implemented");
1514 0 : }
1515 :
1516 6 : void SwXTextTableRow::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
1517 : {
1518 6 : ClientModify(this, pOld, pNew);
1519 6 : }
1520 :
1521 16796 : SwTableLine* SwXTextTableRow::FindLine(SwTable* pTable, SwTableLine* pLine)
1522 : {
1523 16796 : SwTableLine* pRet = 0;
1524 16796 : SwTableLines &rLines = pTable->GetTabLines();
1525 592638 : for(size_t i = 0; i < rLines.size(); ++i)
1526 592638 : if(rLines[i] == pLine)
1527 : {
1528 16796 : pRet = pLine;
1529 16796 : break;
1530 : }
1531 16796 : return pRet;
1532 : }
1533 :
1534 : // SwXTextTableCursor
1535 :
1536 0 : OUString SwXTextTableCursor::getImplementationName(void) throw( uno::RuntimeException, std::exception )
1537 : {
1538 0 : return OUString("SwXTextTableCursor");
1539 : }
1540 :
1541 6 : sal_Bool SwXTextTableCursor::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
1542 : {
1543 6 : return cppu::supportsService(this, rServiceName);
1544 : }
1545 :
1546 160 : IMPLEMENT_FORWARD_XINTERFACE2(SwXTextTableCursor,SwXTextTableCursor_Base,OTextCursorHelper)
1547 0 : const SwPaM* SwXTextTableCursor::GetPaM() const { return GetCrsr(); }
1548 0 : SwPaM* SwXTextTableCursor::GetPaM() { return GetCrsr(); }
1549 0 : const SwDoc* SwXTextTableCursor::GetDoc() const { return GetFrmFmt()->GetDoc(); }
1550 0 : SwDoc* SwXTextTableCursor::GetDoc() { return GetFrmFmt()->GetDoc(); }
1551 0 : const SwUnoCrsr* SwXTextTableCursor::GetCrsr() const { return (SwUnoCrsr*)aCrsrDepend.GetRegisteredIn(); }
1552 654 : SwUnoCrsr* SwXTextTableCursor::GetCrsr() { return (SwUnoCrsr*)aCrsrDepend.GetRegisteredIn(); }
1553 :
1554 6 : uno::Sequence< OUString > SwXTextTableCursor::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
1555 : {
1556 6 : uno::Sequence< OUString > aRet(1);
1557 6 : OUString* pArray = aRet.getArray();
1558 6 : pArray[0] = "com.sun.star.text.TextTableCursor";
1559 6 : return aRet;
1560 : }
1561 :
1562 12 : SwXTextTableCursor::SwXTextTableCursor(SwFrmFmt* pFmt, SwTableBox* pBox) :
1563 : SwClient(pFmt),
1564 : aCrsrDepend(this, 0),
1565 12 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_TABLE_CURSOR))
1566 : {
1567 12 : SwDoc* pDoc = pFmt->GetDoc();
1568 12 : const SwStartNode* pSttNd = pBox->GetSttNd();
1569 12 : SwPosition aPos(*pSttNd);
1570 12 : SwUnoCrsr* pUnoCrsr = pDoc->CreateUnoCrsr(aPos, true);
1571 12 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
1572 12 : pUnoCrsr->Add(&aCrsrDepend);
1573 12 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1574 12 : rTblCrsr.MakeBoxSels();
1575 12 : }
1576 :
1577 0 : SwXTextTableCursor::SwXTextTableCursor(SwFrmFmt& rTableFmt, const SwTableCursor* pTableSelection) :
1578 : SwClient(&rTableFmt),
1579 : aCrsrDepend(this, 0),
1580 0 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_TABLE_CURSOR))
1581 : {
1582 0 : SwUnoCrsr* pUnoCrsr = pTableSelection->GetDoc()->CreateUnoCrsr(*pTableSelection->GetPoint(), true);
1583 0 : if(pTableSelection->HasMark())
1584 : {
1585 0 : pUnoCrsr->SetMark();
1586 0 : *pUnoCrsr->GetMark() = *pTableSelection->GetMark();
1587 : }
1588 0 : const SwSelBoxes& rBoxes = pTableSelection->GetSelectedBoxes();
1589 0 : SwTableCursor& rTableCrsr = dynamic_cast<SwTableCursor&>(*pUnoCrsr);
1590 0 : for (size_t i = 0; i < rBoxes.size(); i++)
1591 : {
1592 0 : rTableCrsr.InsertBox( *rBoxes[i] );
1593 : }
1594 :
1595 0 : pUnoCrsr->Add(&aCrsrDepend);
1596 0 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1597 0 : rTblCrsr.MakeBoxSels();
1598 0 : }
1599 :
1600 36 : SwXTextTableCursor::~SwXTextTableCursor()
1601 : {
1602 12 : SolarMutexGuard aGuard;
1603 12 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1604 12 : delete pUnoCrsr;
1605 24 : }
1606 :
1607 14 : OUString SwXTextTableCursor::getRangeName()
1608 : throw (uno::RuntimeException, std::exception)
1609 : {
1610 14 : SolarMutexGuard aGuard;
1611 14 : OUString aRet;
1612 14 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1613 14 : SwUnoTableCrsr* pTblCrsr = dynamic_cast<SwUnoTableCrsr*>(pUnoCrsr);
1614 : //!! see also SwChartDataSequence::getSourceRangeRepresentation
1615 14 : if (pTblCrsr)
1616 : {
1617 14 : pTblCrsr->MakeBoxSels();
1618 14 : const SwStartNode* pNode = pTblCrsr->GetPoint()->nNode.GetNode().FindTableBoxStartNode();
1619 14 : const SwTable* pTable = SwTable::FindTable( GetFrmFmt() );
1620 14 : const SwTableBox* pEndBox = pTable->GetTblBox( pNode->GetIndex());
1621 14 : aRet = pEndBox->GetName();
1622 :
1623 14 : if(pTblCrsr->HasMark())
1624 : {
1625 0 : pNode = pTblCrsr->GetMark()->nNode.GetNode().FindTableBoxStartNode();
1626 0 : const SwTableBox* pStartBox = pTable->GetTblBox( pNode->GetIndex());
1627 0 : if(pEndBox != pStartBox)
1628 : {
1629 : // need to switch start and end?
1630 0 : if (*pTblCrsr->GetPoint() < *pTblCrsr->GetMark())
1631 : {
1632 0 : const SwTableBox* pTmpBox = pStartBox;
1633 0 : pStartBox = pEndBox;
1634 0 : pEndBox = pTmpBox;
1635 : }
1636 :
1637 0 : aRet = pStartBox->GetName() + ":" + pEndBox->GetName();
1638 : }
1639 : }
1640 : }
1641 14 : return aRet;
1642 : }
1643 :
1644 6 : sal_Bool SwXTextTableCursor::gotoCellByName(const OUString& sCellName, sal_Bool Expand)
1645 : throw( uno::RuntimeException, std::exception )
1646 : {
1647 6 : SolarMutexGuard aGuard;
1648 6 : bool bRet = false;
1649 6 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1650 6 : if(pUnoCrsr)
1651 : {
1652 6 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1653 6 : lcl_CrsrSelect(rTblCrsr, Expand);
1654 6 : bRet = rTblCrsr.GotoTblBox(sCellName);
1655 : }
1656 6 : return bRet;
1657 : }
1658 :
1659 4 : sal_Bool SwXTextTableCursor::goLeft(sal_Int16 Count, sal_Bool Expand) throw( uno::RuntimeException, std::exception )
1660 : {
1661 4 : SolarMutexGuard aGuard;
1662 4 : bool bRet = false;
1663 4 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1664 4 : if(pUnoCrsr)
1665 : {
1666 4 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1667 4 : lcl_CrsrSelect(rTblCrsr, Expand);
1668 4 : bRet = rTblCrsr.Left(Count, CRSR_SKIP_CHARS, false, false);
1669 : }
1670 4 : return bRet;
1671 : }
1672 :
1673 4 : sal_Bool SwXTextTableCursor::goRight(sal_Int16 Count, sal_Bool Expand) throw( uno::RuntimeException, std::exception )
1674 : {
1675 4 : SolarMutexGuard aGuard;
1676 4 : bool bRet = false;
1677 4 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1678 4 : if(pUnoCrsr)
1679 : {
1680 4 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1681 4 : lcl_CrsrSelect(rTblCrsr, Expand);
1682 4 : bRet = rTblCrsr.Right(Count, CRSR_SKIP_CHARS, false, false);
1683 : }
1684 4 : return bRet;
1685 : }
1686 :
1687 4 : sal_Bool SwXTextTableCursor::goUp(sal_Int16 Count, sal_Bool Expand) throw( uno::RuntimeException, std::exception )
1688 : {
1689 4 : SolarMutexGuard aGuard;
1690 4 : bool bRet = false;
1691 4 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1692 4 : if(pUnoCrsr)
1693 : {
1694 4 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1695 4 : lcl_CrsrSelect(rTblCrsr, Expand);
1696 4 : bRet = rTblCrsr.UpDown(true, Count, 0, 0);
1697 : }
1698 4 : return bRet;
1699 : }
1700 :
1701 2 : sal_Bool SwXTextTableCursor::goDown(sal_Int16 Count, sal_Bool Expand) throw( uno::RuntimeException, std::exception )
1702 : {
1703 2 : SolarMutexGuard aGuard;
1704 2 : bool bRet = false;
1705 2 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1706 2 : if(pUnoCrsr)
1707 : {
1708 2 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1709 2 : lcl_CrsrSelect(rTblCrsr, Expand);
1710 2 : bRet = rTblCrsr.UpDown(false, Count, 0, 0);
1711 : }
1712 2 : return bRet;
1713 : }
1714 :
1715 8 : void SwXTextTableCursor::gotoStart(sal_Bool Expand) throw( uno::RuntimeException, std::exception )
1716 : {
1717 8 : SolarMutexGuard aGuard;
1718 8 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1719 8 : if(pUnoCrsr)
1720 : {
1721 8 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1722 8 : lcl_CrsrSelect(rTblCrsr, Expand);
1723 8 : rTblCrsr.MoveTable(fnTableCurr, fnTableStart);
1724 8 : }
1725 8 : }
1726 :
1727 14 : void SwXTextTableCursor::gotoEnd(sal_Bool Expand) throw( uno::RuntimeException, std::exception )
1728 : {
1729 14 : SolarMutexGuard aGuard;
1730 14 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1731 14 : if(pUnoCrsr)
1732 : {
1733 14 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1734 14 : lcl_CrsrSelect(rTblCrsr, Expand);
1735 14 : rTblCrsr.MoveTable(fnTableCurr, fnTableEnd);
1736 14 : }
1737 14 : }
1738 :
1739 6 : sal_Bool SwXTextTableCursor::mergeRange()
1740 : throw (uno::RuntimeException, std::exception)
1741 : {
1742 6 : SolarMutexGuard aGuard;
1743 6 : bool bRet = false;
1744 6 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1745 6 : if(pUnoCrsr)
1746 : {
1747 : {
1748 : // The Actions need to be revoked here
1749 6 : UnoActionRemoveContext aRemoveContext(pUnoCrsr->GetDoc());
1750 : }
1751 6 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1752 6 : rTblCrsr.MakeBoxSels();
1753 :
1754 : {
1755 6 : UnoActionContext aContext(pUnoCrsr->GetDoc());
1756 6 : bRet = TBLMERGE_OK == rTblCrsr.GetDoc()->MergeTbl(rTblCrsr);
1757 6 : if(bRet)
1758 : {
1759 6 : size_t nCount = rTblCrsr.GetSelectedBoxesCount();
1760 20 : while (nCount--)
1761 : {
1762 8 : rTblCrsr.DeleteBox(nCount);
1763 : }
1764 6 : }
1765 : }
1766 6 : rTblCrsr.MakeBoxSels();
1767 : }
1768 6 : return bRet;
1769 : }
1770 :
1771 4 : sal_Bool SwXTextTableCursor::splitRange(sal_Int16 Count, sal_Bool Horizontal)
1772 : throw (uno::RuntimeException, std::exception)
1773 : {
1774 4 : SolarMutexGuard aGuard;
1775 4 : if (Count <= 0)
1776 0 : throw uno::RuntimeException("Illegal first argument: needs to be > 0", static_cast < cppu::OWeakObject * > ( this ) );
1777 4 : bool bRet = false;
1778 4 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1779 4 : if(pUnoCrsr)
1780 : {
1781 : {
1782 : // here, all actions need to be revoked
1783 4 : UnoActionRemoveContext aRemoveContext(pUnoCrsr->GetDoc());
1784 : }
1785 4 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1786 4 : rTblCrsr.MakeBoxSels();
1787 : {
1788 4 : UnoActionContext aContext(pUnoCrsr->GetDoc());
1789 : bRet = rTblCrsr.GetDoc()->SplitTbl(
1790 4 : rTblCrsr.GetSelectedBoxes(), !Horizontal, Count);
1791 : }
1792 4 : rTblCrsr.MakeBoxSels();
1793 : }
1794 4 : return bRet;
1795 : }
1796 :
1797 302 : uno::Reference< beans::XPropertySetInfo > SwXTextTableCursor::getPropertySetInfo(void) throw( uno::RuntimeException, std::exception )
1798 : {
1799 302 : static uno::Reference< beans::XPropertySetInfo > xRef = m_pPropSet->getPropertySetInfo();
1800 302 : return xRef;
1801 : }
1802 :
1803 186 : void SwXTextTableCursor::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
1804 : throw (beans::UnknownPropertyException,
1805 : beans::PropertyVetoException,
1806 : lang::IllegalArgumentException,
1807 : lang::WrappedTargetException,
1808 : uno::RuntimeException,
1809 : std::exception)
1810 : {
1811 186 : SolarMutexGuard aGuard;
1812 186 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1813 186 : if(pUnoCrsr)
1814 : {
1815 186 : SwStartNode* pSttNode = pUnoCrsr->GetNode().StartOfSectionNode();
1816 186 : const SwTableNode* pTblNode = pSttNode->FindTableNode();
1817 186 : lcl_FormatTable((SwFrmFmt*)pTblNode->GetTable().GetFrmFmt());
1818 186 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1819 : const SfxItemPropertySimpleEntry* pEntry =
1820 186 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
1821 186 : if(pEntry)
1822 : {
1823 186 : if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
1824 0 : throw beans::PropertyVetoException("Property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1825 186 : rTblCrsr.MakeBoxSels();
1826 186 : SwDoc* pDoc = pUnoCrsr->GetDoc();
1827 186 : switch(pEntry->nWID )
1828 : {
1829 : case FN_UNO_TABLE_CELL_BACKGROUND:
1830 : {
1831 0 : SvxBrushItem aBrush( RES_BACKGROUND );
1832 0 : pDoc->GetBoxAttr( *pUnoCrsr, aBrush );
1833 0 : aBrush.PutValue(aValue, pEntry->nMemberId);
1834 0 : pDoc->SetBoxAttr( *pUnoCrsr, aBrush );
1835 :
1836 : }
1837 0 : break;
1838 : case RES_BOXATR_FORMAT:
1839 : {
1840 0 : SfxUInt32Item aNumberFormat(RES_BOXATR_FORMAT);
1841 0 : aNumberFormat.PutValue(aValue, 0);
1842 0 : pDoc->SetBoxAttr( *pUnoCrsr, aNumberFormat);
1843 : }
1844 0 : break;
1845 : case FN_UNO_PARA_STYLE:
1846 0 : SwUnoCursorHelper::SetTxtFmtColl(aValue, *pUnoCrsr);
1847 0 : break;
1848 : default:
1849 : {
1850 186 : SfxItemSet aItemSet( pDoc->GetAttrPool(), pEntry->nWID, pEntry->nWID );
1851 186 : SwUnoCursorHelper::GetCrsrAttr(rTblCrsr.GetSelRing(),
1852 186 : aItemSet);
1853 :
1854 186 : if (!SwUnoCursorHelper::SetCursorPropertyValue(
1855 186 : *pEntry, aValue, rTblCrsr.GetSelRing(), aItemSet))
1856 : {
1857 184 : m_pPropSet->setPropertyValue(*pEntry, aValue, aItemSet);
1858 : }
1859 184 : SwUnoCursorHelper::SetCrsrAttr(rTblCrsr.GetSelRing(),
1860 186 : aItemSet, nsSetAttrMode::SETATTR_DEFAULT, true);
1861 : }
1862 : }
1863 : }
1864 : else
1865 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1866 186 : }
1867 184 : }
1868 :
1869 390 : uno::Any SwXTextTableCursor::getPropertyValue(const OUString& rPropertyName)
1870 : throw (beans::UnknownPropertyException,
1871 : lang::WrappedTargetException,
1872 : uno::RuntimeException,
1873 : std::exception)
1874 : {
1875 390 : SolarMutexGuard aGuard;
1876 390 : uno::Any aRet;
1877 390 : SwUnoCrsr* pUnoCrsr = GetCrsr();
1878 390 : if(pUnoCrsr)
1879 : {
1880 390 : SwStartNode* pSttNode = pUnoCrsr->GetNode().StartOfSectionNode();
1881 390 : const SwTableNode* pTblNode = pSttNode->FindTableNode();
1882 390 : lcl_FormatTable((SwFrmFmt*)pTblNode->GetTable().GetFrmFmt());
1883 390 : SwUnoTableCrsr& rTblCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
1884 : const SfxItemPropertySimpleEntry* pEntry =
1885 390 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
1886 390 : if(pEntry)
1887 : {
1888 390 : rTblCrsr.MakeBoxSels();
1889 390 : switch(pEntry->nWID )
1890 : {
1891 : case FN_UNO_TABLE_CELL_BACKGROUND:
1892 : {
1893 0 : SvxBrushItem aBrush( RES_BACKGROUND );
1894 0 : if (rTblCrsr.GetDoc()->GetBoxAttr( *pUnoCrsr, aBrush ))
1895 0 : aBrush.QueryValue(aRet, pEntry->nMemberId);
1896 :
1897 : }
1898 0 : break;
1899 : case RES_BOXATR_FORMAT:
1900 : // TODO: GetAttr for table selections in a Doc is missing
1901 : OSL_FAIL("not implemented");
1902 0 : break;
1903 : case FN_UNO_PARA_STYLE:
1904 : {
1905 : SwFmtColl *const pFmt =
1906 0 : SwUnoCursorHelper::GetCurTxtFmtColl(*pUnoCrsr, false);
1907 0 : OUString sRet;
1908 0 : if(pFmt)
1909 0 : sRet = pFmt->GetName();
1910 0 : aRet <<= sRet;
1911 : }
1912 0 : break;
1913 : default:
1914 : {
1915 390 : SfxItemSet aSet(rTblCrsr.GetDoc()->GetAttrPool(),
1916 : RES_CHRATR_BEGIN, RES_FRMATR_END -1,
1917 : RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER,
1918 390 : 0L);
1919 390 : SwUnoCursorHelper::GetCrsrAttr(rTblCrsr.GetSelRing(),
1920 390 : aSet);
1921 390 : m_pPropSet->getPropertyValue(*pEntry, aSet, aRet);
1922 : }
1923 : }
1924 : }
1925 : else
1926 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1927 : }
1928 390 : return aRet;
1929 : }
1930 :
1931 0 : void SwXTextTableCursor::addPropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1932 : {
1933 : OSL_FAIL("not implemented");
1934 0 : }
1935 :
1936 0 : void SwXTextTableCursor::removePropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1937 : {
1938 : OSL_FAIL("not implemented");
1939 0 : }
1940 :
1941 0 : void SwXTextTableCursor::addVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1942 : {
1943 : OSL_FAIL("not implemented");
1944 0 : }
1945 :
1946 0 : void SwXTextTableCursor::removeVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
1947 : {
1948 : OSL_FAIL("not implemented");
1949 0 : }
1950 :
1951 8 : void SwXTextTableCursor::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
1952 : {
1953 8 : ClientModify(this, pOld, pNew);
1954 8 : }
1955 :
1956 2248 : class SwXTextTable::Impl
1957 : {
1958 : private:
1959 : ::osl::Mutex m_Mutex; // just for OInterfaceContainerHelper
1960 :
1961 : public:
1962 : uno::WeakReference<uno::XInterface> m_wThis;
1963 : ::cppu::OMultiTypeInterfaceContainerHelper m_Listeners;
1964 :
1965 2248 : Impl() : m_Listeners(m_Mutex) { }
1966 : };
1967 :
1968 : class SwTableProperties_Impl
1969 : {
1970 : SwUnoCursorHelper::SwAnyMapHelper aAnyMap;
1971 : public:
1972 : SwTableProperties_Impl();
1973 : ~SwTableProperties_Impl();
1974 :
1975 : void SetProperty(sal_uInt16 nWhichId, sal_uInt16 nMemberId, const uno::Any& aVal);
1976 : bool GetProperty(sal_uInt16 nWhichId, sal_uInt16 nMemberId, const uno::Any*& rpAny);
1977 :
1978 : void ApplyTblAttr(const SwTable& rTbl, SwDoc& rDoc);
1979 : };
1980 :
1981 196 : SwTableProperties_Impl::SwTableProperties_Impl()
1982 : {
1983 196 : }
1984 :
1985 196 : SwTableProperties_Impl::~SwTableProperties_Impl()
1986 : {
1987 196 : }
1988 :
1989 2 : void SwTableProperties_Impl::SetProperty(sal_uInt16 nWhichId, sal_uInt16 nMemberId, const uno::Any& rVal)
1990 : {
1991 2 : aAnyMap.SetValue( nWhichId, nMemberId, rVal );
1992 2 : }
1993 :
1994 3612 : bool SwTableProperties_Impl::GetProperty(sal_uInt16 nWhichId, sal_uInt16 nMemberId, const uno::Any*& rpAny )
1995 : {
1996 3612 : return aAnyMap.FillValue( nWhichId, nMemberId, rpAny );
1997 : }
1998 :
1999 172 : void SwTableProperties_Impl::ApplyTblAttr(const SwTable& rTbl, SwDoc& rDoc)
2000 : {
2001 172 : SfxItemSet aSet(rDoc.GetAttrPool(),
2002 : RES_LAYOUT_SPLIT, RES_LAYOUT_SPLIT,
2003 : RES_BACKGROUND, RES_BACKGROUND,
2004 : RES_FRM_SIZE, RES_UL_SPACE,
2005 : RES_HORI_ORIENT, RES_HORI_ORIENT,
2006 : RES_BREAK, RES_BREAK,
2007 : RES_KEEP, RES_KEEP,
2008 : RES_SHADOW, RES_SHADOW,
2009 : RES_PAGEDESC, RES_PAGEDESC,
2010 : 0
2011 172 : );
2012 : const uno::Any* pRepHead;
2013 172 : const SwFrmFmt &rFrmFmt = *rTbl.GetFrmFmt();
2014 172 : if(GetProperty(FN_TABLE_HEADLINE_REPEAT, 0xff, pRepHead ))
2015 : {
2016 0 : bool bVal = *(sal_Bool*)pRepHead->getValue();
2017 0 : ((SwTable&)rTbl).SetRowsToRepeat( bVal ? 1 : 0 ); // TODO: MULTIHEADER
2018 : }
2019 :
2020 172 : const uno::Any* pBackColor = 0;
2021 172 : GetProperty(RES_BACKGROUND, MID_BACK_COLOR, pBackColor );
2022 172 : const uno::Any* pBackTrans = 0;
2023 172 : GetProperty(RES_BACKGROUND, MID_GRAPHIC_TRANSPARENT, pBackTrans );
2024 172 : const uno::Any* pGrLoc = 0;
2025 172 : GetProperty(RES_BACKGROUND, MID_GRAPHIC_POSITION, pGrLoc );
2026 172 : const uno::Any* pGrURL = 0;
2027 172 : GetProperty(RES_BACKGROUND, MID_GRAPHIC_URL, pGrURL );
2028 172 : const uno::Any* pGrFilter = 0;
2029 172 : GetProperty(RES_BACKGROUND, MID_GRAPHIC_FILTER, pGrFilter );
2030 :
2031 172 : if(pBackColor||pBackTrans||pGrURL||pGrFilter||pGrLoc)
2032 : {
2033 2 : SvxBrushItem aBrush(rFrmFmt.makeBackgroundBrushItem());
2034 2 : if(pBackColor)
2035 2 : aBrush.PutValue(*pBackColor, MID_BACK_COLOR);
2036 2 : if(pBackTrans)
2037 0 : aBrush.PutValue(*pBackTrans, MID_GRAPHIC_TRANSPARENT);
2038 2 : if(pGrURL)
2039 0 : aBrush.PutValue(*pGrURL, MID_GRAPHIC_URL);
2040 2 : if(pGrFilter)
2041 0 : aBrush.PutValue(*pGrFilter, MID_GRAPHIC_FILTER);
2042 2 : if(pGrLoc)
2043 0 : aBrush.PutValue(*pGrLoc, MID_GRAPHIC_POSITION);
2044 2 : aSet.Put(aBrush);
2045 : }
2046 :
2047 172 : bool bPutBreak = true;
2048 : const uno::Any* pPage;
2049 172 : if(GetProperty(FN_UNO_PAGE_STYLE, 0, pPage) || GetProperty(RES_PAGEDESC, 0xff, pPage))
2050 : {
2051 0 : OUString sPageStyle;
2052 0 : (*pPage) >>= sPageStyle;
2053 0 : if (!sPageStyle.isEmpty())
2054 : {
2055 0 : SwStyleNameMapper::FillUIName(sPageStyle, sPageStyle, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, true );
2056 0 : const SwPageDesc* pDesc = SwPageDesc::GetByName(rDoc, sPageStyle);
2057 0 : if(pDesc)
2058 : {
2059 0 : SwFmtPageDesc aDesc( pDesc );
2060 : const uno::Any* pPgNo;
2061 0 : if(GetProperty(RES_PAGEDESC, MID_PAGEDESC_PAGENUMOFFSET, pPgNo ))
2062 : {
2063 0 : sal_Int16 nTmp = 0;
2064 0 : (*pPgNo) >>= nTmp;
2065 0 : aDesc.SetNumOffset( nTmp );
2066 : }
2067 0 : aSet.Put(aDesc);
2068 0 : bPutBreak = false;
2069 : }
2070 :
2071 0 : }
2072 : }
2073 : const uno::Any* pBreak;
2074 172 : if(bPutBreak && GetProperty(RES_BREAK, 0, pBreak))
2075 : {
2076 0 : SvxFmtBreakItem aBreak ( rFrmFmt.GetBreak() );
2077 0 : aBreak.PutValue(*pBreak, 0);
2078 0 : aSet.Put(aBreak);
2079 : }
2080 : const uno::Any* pShadow;
2081 172 : if(GetProperty(RES_SHADOW, 0, pShadow))
2082 : {
2083 0 : SvxShadowItem aShd ( rFrmFmt.GetShadow() );
2084 0 : aShd.PutValue(*pShadow, CONVERT_TWIPS);
2085 0 : aSet.Put(aShd);
2086 : }
2087 : const uno::Any* pKeep;
2088 172 : if(GetProperty(RES_KEEP, 0, pKeep))
2089 : {
2090 0 : SvxFmtKeepItem aKeep( rFrmFmt.GetKeep() );
2091 0 : aKeep.PutValue(*pKeep, 0);
2092 0 : aSet.Put(aKeep);
2093 : }
2094 :
2095 : const uno::Any* pHOrient;
2096 172 : if(GetProperty(RES_HORI_ORIENT, MID_HORIORIENT_ORIENT, pHOrient))
2097 : {
2098 0 : SwFmtHoriOrient aOrient ( rFrmFmt.GetHoriOrient() );
2099 0 : ((SfxPoolItem&)aOrient).PutValue(*pHOrient, MID_HORIORIENT_ORIENT|CONVERT_TWIPS);
2100 0 : aSet.Put(aOrient);
2101 : }
2102 :
2103 172 : const uno::Any* pSzRel = 0;
2104 172 : GetProperty(FN_TABLE_IS_RELATIVE_WIDTH, 0xff, pSzRel );
2105 172 : const uno::Any* pRelWidth = 0;
2106 172 : GetProperty(FN_TABLE_RELATIVE_WIDTH, 0xff, pRelWidth);
2107 172 : const uno::Any* pWidth = 0;
2108 172 : GetProperty(FN_TABLE_WIDTH, 0xff, pWidth );
2109 :
2110 172 : bool bPutSize = pWidth != 0;
2111 344 : SwFmtFrmSize aSz( ATT_VAR_SIZE);
2112 172 : if(pWidth)
2113 : {
2114 0 : ((SfxPoolItem&)aSz).PutValue(*pWidth, MID_FRMSIZE_WIDTH);
2115 0 : bPutSize = true;
2116 : }
2117 172 : bool bTemp = pSzRel ? *(sal_Bool*)pSzRel->getValue() : sal_False;
2118 172 : if(pSzRel && bTemp && pRelWidth)
2119 : {
2120 0 : ((SfxPoolItem&)aSz).PutValue(*pRelWidth, MID_FRMSIZE_REL_WIDTH|CONVERT_TWIPS);
2121 0 : bPutSize = true;
2122 : }
2123 172 : if(bPutSize)
2124 : {
2125 0 : if(!aSz.GetWidth())
2126 0 : aSz.SetWidth(MINLAY);
2127 0 : aSet.Put(aSz);
2128 : }
2129 172 : const uno::Any* pL = 0;
2130 172 : GetProperty(RES_LR_SPACE, MID_L_MARGIN|CONVERT_TWIPS, pL);
2131 172 : const uno::Any* pR = 0;
2132 172 : GetProperty(RES_LR_SPACE, MID_R_MARGIN|CONVERT_TWIPS, pR);
2133 172 : if(pL||pR)
2134 : {
2135 0 : SvxLRSpaceItem aLR ( rFrmFmt.GetLRSpace() );
2136 0 : if(pL)
2137 0 : ((SfxPoolItem&)aLR).PutValue(*pL, MID_L_MARGIN|CONVERT_TWIPS);
2138 0 : if(pR)
2139 0 : ((SfxPoolItem&)aLR).PutValue(*pR, MID_R_MARGIN|CONVERT_TWIPS);
2140 0 : aSet.Put(aLR);
2141 : }
2142 172 : const uno::Any* pU = 0;
2143 172 : GetProperty(RES_UL_SPACE, MID_UP_MARGIN|CONVERT_TWIPS, pU);
2144 172 : const uno::Any* pLo = 0;
2145 172 : GetProperty(RES_UL_SPACE, MID_LO_MARGIN|CONVERT_TWIPS, pLo);
2146 172 : if(pU||pLo)
2147 : {
2148 0 : SvxULSpaceItem aUL ( rFrmFmt.GetULSpace() );
2149 0 : if(pU)
2150 0 : ((SfxPoolItem&)aUL).PutValue(*pU, MID_UP_MARGIN|CONVERT_TWIPS);
2151 0 : if(pLo)
2152 0 : ((SfxPoolItem&)aUL).PutValue(*pLo, MID_LO_MARGIN|CONVERT_TWIPS);
2153 0 : aSet.Put(aUL);
2154 : }
2155 : const::uno::Any* pSplit;
2156 172 : if(GetProperty(RES_LAYOUT_SPLIT, 0, pSplit ))
2157 : {
2158 0 : bool bTmp = *(sal_Bool*)pSplit->getValue();
2159 0 : SwFmtLayoutSplit aSp(bTmp);
2160 0 : aSet.Put(aSp);
2161 : }
2162 :
2163 172 : if(aSet.Count())
2164 : {
2165 2 : rDoc.SetAttr( aSet, *rTbl.GetFrmFmt() );
2166 172 : }
2167 172 : }
2168 :
2169 : namespace
2170 : {
2171 : class theSwXTextTableUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXTextTableUnoTunnelId > {};
2172 : }
2173 :
2174 1392 : const uno::Sequence< sal_Int8 > & SwXTextTable::getUnoTunnelId()
2175 : {
2176 1392 : return theSwXTextTableUnoTunnelId::get().getSeq();
2177 : }
2178 :
2179 1246 : sal_Int64 SAL_CALL SwXTextTable::getSomething( const uno::Sequence< sal_Int8 >& rId )
2180 : throw(uno::RuntimeException, std::exception)
2181 : {
2182 2492 : if( rId.getLength() == 16
2183 3738 : && 0 == memcmp( getUnoTunnelId().getConstArray(),
2184 2492 : rId.getConstArray(), 16 ) )
2185 : {
2186 138 : return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
2187 : }
2188 1108 : return 0;
2189 : }
2190 :
2191 111303 : TYPEINIT1(SwXTextTable, SwClient)
2192 :
2193 196 : SwXTextTable::SwXTextTable()
2194 196 : : m_pImpl(new Impl)
2195 : ,
2196 196 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_TABLE)),
2197 196 : pTableProps(new SwTableProperties_Impl),
2198 : bIsDescriptor(true),
2199 : nRows(2),
2200 : nColumns(2),
2201 : bFirstRowAsLabel(false),
2202 784 : bFirstColumnAsLabel(false)
2203 : {
2204 196 : }
2205 :
2206 2052 : SwXTextTable::SwXTextTable(SwFrmFmt& rFrmFmt)
2207 : : SwClient( &rFrmFmt )
2208 2052 : , m_pImpl(new Impl)
2209 : ,
2210 2052 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_TABLE)),
2211 : pTableProps(0),
2212 : bIsDescriptor(false),
2213 : nRows(0),
2214 : nColumns(0),
2215 : bFirstRowAsLabel(false),
2216 6156 : bFirstColumnAsLabel(false)
2217 : {
2218 2052 : }
2219 :
2220 6744 : SwXTextTable::~SwXTextTable()
2221 : {
2222 2248 : delete pTableProps;
2223 4496 : }
2224 :
2225 : uno::Reference<text::XTextTable>
2226 2258 : SwXTextTable::CreateXTextTable(SwFrmFmt *const pFrmFmt)
2227 : {
2228 2258 : uno::Reference<text::XTextTable> xTable;
2229 2258 : if (pFrmFmt)
2230 : {
2231 2062 : xTable.set(pFrmFmt->GetXObject(), uno::UNO_QUERY); // cached?
2232 : }
2233 2258 : if (!xTable.is())
2234 : {
2235 : SwXTextTable *const pNew(
2236 2248 : (pFrmFmt) ? new SwXTextTable(*pFrmFmt) : new SwXTextTable());
2237 2248 : xTable.set(pNew);
2238 2248 : if (pFrmFmt)
2239 : {
2240 2052 : pFrmFmt->SetXObject(xTable);
2241 : }
2242 : // need a permanent Reference to initialize m_wThis
2243 2248 : pNew->m_pImpl->m_wThis = xTable;
2244 : }
2245 2258 : return xTable;
2246 : }
2247 :
2248 162 : void SwXTextTable::initialize(sal_Int32 nR, sal_Int32 nC) throw( uno::RuntimeException, std::exception )
2249 : {
2250 162 : if(!bIsDescriptor || nR <= 0 || nC <= 0 || nR >= USHRT_MAX || nC >= USHRT_MAX )
2251 0 : throw uno::RuntimeException();
2252 : else
2253 : {
2254 162 : nRows = (sal_uInt16)nR;
2255 162 : nColumns = (sal_uInt16)nC;
2256 : }
2257 162 : }
2258 :
2259 1098 : uno::Reference< table::XTableRows > SwXTextTable::getRows(void) throw( uno::RuntimeException, std::exception )
2260 : {
2261 1098 : SolarMutexGuard aGuard;
2262 1098 : uno::Reference< table::XTableRows > xRet;
2263 1098 : if (SwFrmFmt* pFmt = GetFrmFmt())
2264 : {
2265 1098 : SwXTableRows* pRows = SwIterator<SwXTableRows,SwFmt>::FirstElement(*pFmt);
2266 1098 : if (!pRows)
2267 1098 : pRows = new SwXTableRows(*pFmt);
2268 1098 : xRet = pRows;
2269 : }
2270 1098 : if (!xRet.is())
2271 0 : throw uno::RuntimeException();
2272 1098 : return xRet;
2273 : }
2274 :
2275 8 : uno::Reference< table::XTableColumns > SwXTextTable::getColumns(void) throw( uno::RuntimeException, std::exception )
2276 : {
2277 8 : SolarMutexGuard aGuard;
2278 8 : uno::Reference< table::XTableColumns > xRet;
2279 8 : if (SwFrmFmt* pFmt = GetFrmFmt())
2280 : {
2281 8 : SwXTableColumns* pCols = SwIterator<SwXTableColumns,SwFmt>::FirstElement(*pFmt);
2282 8 : if (!pCols)
2283 8 : pCols = new SwXTableColumns(*pFmt);
2284 8 : xRet = pCols;
2285 : }
2286 8 : if (!xRet.is())
2287 0 : throw uno::RuntimeException();
2288 8 : return xRet;
2289 : }
2290 :
2291 652 : uno::Reference< table::XCell > SwXTextTable::getCellByName(const OUString& sCellName) throw( uno::RuntimeException, std::exception )
2292 : {
2293 652 : SolarMutexGuard aGuard;
2294 652 : uno::Reference< table::XCell > xRet;
2295 652 : SwFrmFmt* pFmt = GetFrmFmt();
2296 652 : if(pFmt)
2297 : {
2298 652 : SwTable* pTable = SwTable::FindTable( pFmt );
2299 652 : SwTableBox* pBox = (SwTableBox*)pTable->GetTblBox( sCellName );
2300 652 : if(pBox)
2301 : {
2302 652 : xRet = SwXCell::CreateXCell(pFmt, pBox);
2303 : }
2304 : }
2305 : else
2306 0 : throw uno::RuntimeException();
2307 652 : return xRet;
2308 : }
2309 :
2310 60 : uno::Sequence< OUString > SwXTextTable::getCellNames(void) throw( uno::RuntimeException, std::exception )
2311 : {
2312 60 : SolarMutexGuard aGuard;
2313 60 : SwFrmFmt* pFmt = GetFrmFmt();
2314 60 : if(pFmt)
2315 : {
2316 60 : SwTable* pTable = SwTable::FindTable( pFmt );
2317 : // exists at the table and at all boxes
2318 60 : SwTableLines& rTblLines = pTable->GetTabLines();
2319 60 : std::vector<OUString*> aAllNames;
2320 60 : lcl_InspectLines(rTblLines, aAllNames);
2321 120 : uno::Sequence< OUString > aRet( static_cast<sal_Int32>(aAllNames.size()) );
2322 60 : OUString* pArray = aRet.getArray();
2323 746 : for( size_t i = 0; i < aAllNames.size(); ++i)
2324 : {
2325 686 : pArray[i] = *aAllNames[i];
2326 686 : delete aAllNames[i];
2327 : }
2328 120 : return aRet;
2329 : }
2330 0 : return uno::Sequence< OUString >();
2331 : }
2332 :
2333 12 : uno::Reference< text::XTextTableCursor > SwXTextTable::createCursorByCellName(const OUString& sCellName)
2334 : throw (uno::RuntimeException, std::exception)
2335 : {
2336 12 : SolarMutexGuard aGuard;
2337 12 : uno::Reference< text::XTextTableCursor > xRet;
2338 12 : SwFrmFmt* pFmt = GetFrmFmt();
2339 12 : if(pFmt)
2340 : {
2341 12 : SwTable* pTable = SwTable::FindTable( pFmt );
2342 12 : SwTableBox* pBox = (SwTableBox*)pTable->GetTblBox( sCellName );
2343 12 : if(pBox && pBox->getRowSpan() > 0 )
2344 : {
2345 12 : xRet = new SwXTextTableCursor(pFmt, pBox);
2346 : }
2347 : }
2348 12 : if(!xRet.is())
2349 0 : throw uno::RuntimeException();
2350 12 : return xRet;
2351 : }
2352 :
2353 172 : void SwXTextTable::attachToRange(const uno::Reference< text::XTextRange > & xTextRange)
2354 : throw( lang::IllegalArgumentException, uno::RuntimeException )
2355 : {
2356 : // attachToRange must only be called once
2357 172 : if(!bIsDescriptor) /* already attached ? */
2358 0 : throw uno::RuntimeException("SwXTextTable: already attached to range.", static_cast < cppu::OWeakObject * > ( this ) );
2359 :
2360 172 : uno::Reference<XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
2361 172 : SwXTextRange* pRange = 0;
2362 172 : OTextCursorHelper* pCursor = 0;
2363 172 : if(xRangeTunnel.is())
2364 : {
2365 : pRange = reinterpret_cast< SwXTextRange * >(
2366 172 : sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
2367 : pCursor = reinterpret_cast< OTextCursorHelper * >(
2368 172 : sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
2369 : }
2370 172 : SwDoc* pDoc = pRange ? (SwDoc*)pRange->GetDoc() : pCursor ? (SwDoc*)pCursor->GetDoc() : 0;
2371 172 : if(pDoc && nRows && nColumns)
2372 : {
2373 172 : SwUnoInternalPaM aPam(*pDoc);
2374 : // this now needs to return TRUE
2375 172 : ::sw::XTextRangeToSwPaM(aPam, xTextRange);
2376 :
2377 : {
2378 172 : UnoActionContext aCont( pDoc );
2379 :
2380 172 : pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
2381 172 : const SwTable *pTable = 0;
2382 172 : if( 0 != aPam.Start()->nContent.GetIndex() )
2383 : {
2384 0 : pDoc->getIDocumentContentOperations().SplitNode(*aPam.Start(), false );
2385 : }
2386 : //TODO: if it is the last paragraph than add another one!
2387 172 : if( aPam.HasMark() )
2388 : {
2389 0 : pDoc->getIDocumentContentOperations().DeleteAndJoin(aPam);
2390 0 : aPam.DeleteMark();
2391 : }
2392 : pTable = pDoc->InsertTable( SwInsertTableOptions( tabopts::HEADLINE | tabopts::DEFAULT_BORDER | tabopts::SPLIT_LAYOUT, 0 ),
2393 172 : *aPam.GetPoint(),
2394 : nRows,
2395 : nColumns,
2396 344 : text::HoriOrientation::FULL );
2397 172 : if(pTable)
2398 : {
2399 : // here, the properties of the descriptor need to be analyzed
2400 172 : pTableProps->ApplyTblAttr(*pTable, *pDoc);
2401 172 : SwFrmFmt* pTblFmt = pTable->GetFrmFmt();
2402 172 : lcl_FormatTable( pTblFmt );
2403 :
2404 172 : pTblFmt->Add(this);
2405 172 : if(!m_sTableName.isEmpty())
2406 : {
2407 4 : sal_uInt16 nIndex = 1;
2408 4 : OUString sTmpNameIndex(m_sTableName);
2409 8 : while(pDoc->FindTblFmtByName( sTmpNameIndex, true ) && nIndex < USHRT_MAX)
2410 : {
2411 0 : sTmpNameIndex = m_sTableName + OUString::number(nIndex++);
2412 : }
2413 4 : pDoc->SetTableName( *pTblFmt, sTmpNameIndex);
2414 : }
2415 :
2416 : const::uno::Any* pName;
2417 172 : if(pTableProps->GetProperty(FN_UNO_TABLE_NAME, 0, pName))
2418 : {
2419 0 : OUString sTmp;
2420 0 : (*pName) >>= sTmp;
2421 0 : setName(sTmp);
2422 : }
2423 172 : bIsDescriptor = false;
2424 172 : DELETEZ(pTableProps);
2425 : }
2426 172 : pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL );
2427 172 : }
2428 : }
2429 : else
2430 0 : throw lang::IllegalArgumentException();
2431 172 : }
2432 :
2433 172 : void SwXTextTable::attach(const uno::Reference< text::XTextRange > & xTextRange)
2434 : throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
2435 : {
2436 172 : SolarMutexGuard aGuard;
2437 172 : attachToRange( xTextRange );
2438 172 : }
2439 :
2440 1070 : uno::Reference< text::XTextRange > SwXTextTable::getAnchor(void)
2441 : throw( uno::RuntimeException, std::exception )
2442 : {
2443 1070 : SolarMutexGuard aGuard;
2444 1070 : SwFrmFmt* pFmt = GetFrmFmt();
2445 1070 : if(!pFmt)
2446 0 : throw uno::RuntimeException();
2447 1070 : uno::Reference< text::XTextRange > xRet = new SwXTextRange(*pFmt);
2448 1070 : return xRet;
2449 : }
2450 :
2451 8 : void SwXTextTable::dispose(void) throw( uno::RuntimeException, std::exception )
2452 : {
2453 8 : SolarMutexGuard aGuard;
2454 8 : SwFrmFmt* pFmt = GetFrmFmt();
2455 8 : if(pFmt)
2456 : {
2457 8 : SwTable* pTable = SwTable::FindTable( pFmt );
2458 8 : SwTableSortBoxes& rBoxes = pTable->GetTabSortBoxes();
2459 8 : SwSelBoxes aSelBoxes;
2460 176 : for(SwTableSortBoxes::const_iterator it = rBoxes.begin(); it != rBoxes.end(); ++it )
2461 168 : aSelBoxes.insert( *it );
2462 8 : pFmt->GetDoc()->DeleteRowCol(aSelBoxes);
2463 : }
2464 : else
2465 0 : throw uno::RuntimeException();
2466 8 : }
2467 :
2468 4 : void SAL_CALL SwXTextTable::addEventListener(
2469 : const uno::Reference<lang::XEventListener> & xListener)
2470 : throw (uno::RuntimeException, std::exception)
2471 : {
2472 : // no need to lock here as m_pImpl is const and container threadsafe
2473 4 : m_pImpl->m_Listeners.addInterface(
2474 8 : cppu::UnoType<lang::XEventListener>::get(), xListener);
2475 4 : }
2476 :
2477 2 : void SAL_CALL SwXTextTable::removeEventListener(
2478 : const uno::Reference< lang::XEventListener > & xListener)
2479 : throw (uno::RuntimeException, std::exception)
2480 : {
2481 : // no need to lock here as m_pImpl is const and container threadsafe
2482 2 : m_pImpl->m_Listeners.removeInterface(
2483 4 : cppu::UnoType<lang::XEventListener>::get(), xListener);
2484 2 : }
2485 :
2486 21008 : uno::Reference< table::XCell > SwXTextTable::getCellByPosition(sal_Int32 nColumn, sal_Int32 nRow)
2487 : throw( uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception )
2488 : {
2489 21008 : SolarMutexGuard aGuard;
2490 21008 : uno::Reference< table::XCell > aRef;
2491 21008 : SwFrmFmt* pFmt = GetFrmFmt();
2492 : // sheet is unimportant
2493 21008 : if(nColumn >= 0 && nRow >= 0 && nColumn < USHRT_MAX && nRow < USHRT_MAX && pFmt)
2494 : {
2495 21006 : SwXCell* pXCell = lcl_CreateXCell(pFmt, nColumn, nRow);
2496 21006 : if(pXCell)
2497 21004 : aRef = pXCell;
2498 : }
2499 21008 : if(!aRef.is())
2500 4 : throw lang::IndexOutOfBoundsException();
2501 21008 : return aRef;
2502 : }
2503 :
2504 10 : uno::Reference< table::XCellRange > SwXTextTable::GetRangeByName(SwFrmFmt* pFmt, SwTable* pTable,
2505 : const OUString& rTLName, const OUString& rBRName,
2506 : SwRangeDescriptor& rDesc)
2507 : {
2508 10 : SolarMutexGuard aGuard;
2509 10 : uno::Reference< table::XCellRange > aRef;
2510 10 : const SwTableBox* pTLBox = pTable->GetTblBox( rTLName );
2511 10 : if(pTLBox)
2512 : {
2513 : // invalidate all actions
2514 10 : UnoActionRemoveContext aRemoveContext(pFmt->GetDoc());
2515 10 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
2516 20 : SwPosition aPos(*pSttNd);
2517 : // set cursor to the upper-left cell of the range
2518 10 : SwUnoCrsr* pUnoCrsr = pFmt->GetDoc()->CreateUnoCrsr(aPos, true);
2519 10 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
2520 10 : pUnoCrsr->SetRemainInSection( false );
2521 10 : const SwTableBox* pBRBox = pTable->GetTblBox( rBRName );
2522 10 : if(pBRBox)
2523 : {
2524 10 : pUnoCrsr->SetMark();
2525 10 : pUnoCrsr->GetPoint()->nNode = *pBRBox->GetSttNd();
2526 10 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
2527 10 : SwUnoTableCrsr* pCrsr = dynamic_cast<SwUnoTableCrsr*>(pUnoCrsr);
2528 10 : pCrsr->MakeBoxSels();
2529 : // pUnoCrsr will be provided and will not be deleted
2530 10 : SwXCellRange* pCellRange = new SwXCellRange(pUnoCrsr, *pFmt, rDesc);
2531 10 : aRef = pCellRange;
2532 : }
2533 : else
2534 10 : delete pUnoCrsr;
2535 : }
2536 10 : return aRef;
2537 : }
2538 :
2539 10 : uno::Reference< table::XCellRange > SwXTextTable::getCellRangeByPosition(sal_Int32 nLeft, sal_Int32 nTop,
2540 : sal_Int32 nRight, sal_Int32 nBottom)
2541 : throw (uno::RuntimeException,
2542 : lang::IndexOutOfBoundsException,
2543 : std::exception)
2544 : {
2545 10 : SolarMutexGuard aGuard;
2546 10 : uno::Reference< table::XCellRange > aRef;
2547 10 : SwFrmFmt* pFmt = GetFrmFmt();
2548 10 : if(pFmt && nRight < USHRT_MAX && nBottom < USHRT_MAX &&
2549 10 : nLeft <= nRight && nTop <= nBottom &&
2550 8 : nLeft >= 0 && nRight >= 0 && nTop >= 0 && nBottom >= 0 )
2551 : {
2552 8 : SwTable* pTable = SwTable::FindTable( pFmt );
2553 8 : if(!pTable->IsTblComplex())
2554 : {
2555 : SwRangeDescriptor aDesc;
2556 8 : aDesc.nTop = nTop;
2557 8 : aDesc.nBottom = nBottom;
2558 8 : aDesc.nLeft = nLeft;
2559 8 : aDesc.nRight = nRight;
2560 8 : const OUString sTLName = sw_GetCellName(aDesc.nLeft, aDesc.nTop);
2561 16 : const OUString sBRName = sw_GetCellName(aDesc.nRight, aDesc.nBottom);
2562 :
2563 : // please note that according to the 'if' statement at the begin
2564 : // sTLName:sBRName already denotes the normalized range string
2565 :
2566 16 : aRef = GetRangeByName(pFmt, pTable, sTLName, sBRName, aDesc);
2567 : }
2568 : }
2569 10 : if(!aRef.is())
2570 2 : throw lang::IndexOutOfBoundsException();
2571 10 : return aRef;
2572 : }
2573 :
2574 2 : uno::Reference< table::XCellRange > SwXTextTable::getCellRangeByName(const OUString& sRange)
2575 : throw (uno::RuntimeException, std::exception)
2576 : {
2577 2 : SolarMutexGuard aGuard;
2578 2 : uno::Reference< table::XCellRange > aRef;
2579 2 : SwFrmFmt* pFmt = GetFrmFmt();
2580 2 : if(pFmt)
2581 : {
2582 2 : SwTable* pTable = SwTable::FindTable( pFmt );
2583 2 : if(!pTable->IsTblComplex())
2584 : {
2585 2 : sal_Int32 nPos = 0;
2586 2 : const OUString sTLName(sRange.getToken(0, ':', nPos));
2587 4 : const OUString sBRName(sRange.getToken(0, ':', nPos));
2588 2 : if(sTLName.isEmpty() || sBRName.isEmpty())
2589 0 : throw uno::RuntimeException();
2590 : SwRangeDescriptor aDesc;
2591 2 : aDesc.nTop = aDesc.nLeft = aDesc.nBottom = aDesc.nRight = -1;
2592 2 : sw_GetCellPosition(sTLName, aDesc.nLeft, aDesc.nTop );
2593 2 : sw_GetCellPosition(sBRName, aDesc.nRight, aDesc.nBottom );
2594 :
2595 : // we should normalize the range now (e.g. A5:C1 will become A1:C5)
2596 : // since (depending on what is done later) it will be troublesome
2597 : // elsewhere when the cursor in the implementation does not
2598 : // point to the top-left and bottom-right cells
2599 2 : aDesc.Normalize();
2600 :
2601 4 : aRef = GetRangeByName(pFmt, pTable, sTLName, sBRName, aDesc);
2602 : }
2603 : }
2604 2 : if(!aRef.is())
2605 0 : throw uno::RuntimeException();
2606 2 : return aRef;
2607 : }
2608 :
2609 4 : uno::Sequence< uno::Sequence< uno::Any > > SAL_CALL SwXTextTable::getDataArray()
2610 : throw (uno::RuntimeException, std::exception)
2611 : {
2612 : // see SwXTextTable::getData(...) also
2613 :
2614 4 : SolarMutexGuard aGuard;
2615 4 : const sal_uInt16 nRowCount = getRowCount();
2616 4 : const sal_uInt16 nColCount = getColumnCount();
2617 4 : if(!nRowCount || !nColCount)
2618 : {
2619 0 : uno::RuntimeException aRuntime;
2620 0 : aRuntime.Message = "Table too complex";
2621 0 : throw aRuntime;
2622 : }
2623 4 : SwFrmFmt* pFmt = GetFrmFmt();
2624 4 : uno::Sequence< uno::Sequence< uno::Any > > aRowSeq(nRowCount);
2625 4 : if(pFmt)
2626 : {
2627 4 : uno::Sequence< uno::Any > * pRowArray = aRowSeq.getArray();
2628 28 : for(sal_uInt16 nRow = 0; nRow < nRowCount; nRow++)
2629 : {
2630 24 : uno::Sequence< uno::Any > aColSeq(nColCount);
2631 24 : uno::Any * pColArray = aColSeq.getArray();
2632 48 : uno::Reference< table::XCell > xCellRef;
2633 72 : for(sal_uInt16 nCol = 0; nCol < nColCount; nCol++)
2634 : {
2635 48 : SwXCell* pXCell = lcl_CreateXCell(pFmt, nCol, nRow);
2636 : //! keep (additional) reference to object to prevent implicit destruction
2637 : //! in following UNO calls (when object will get referenced)
2638 48 : xCellRef = pXCell;
2639 48 : SwTableBox * pBox = pXCell ? pXCell->GetTblBox() : 0;
2640 48 : if(!pBox)
2641 : {
2642 0 : throw uno::RuntimeException();
2643 : }
2644 : else
2645 : {
2646 : // check if table box value item is set
2647 48 : SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
2648 48 : bool bIsNum = pBoxFmt->GetItemState( RES_BOXATR_VALUE, false ) == SfxItemState::SET;
2649 48 : if(!bIsNum)
2650 24 : pColArray[nCol] <<= lcl_getString(*pXCell);
2651 : else
2652 24 : pColArray[nCol] <<= sw_getValue(*pXCell);
2653 : }
2654 : }
2655 24 : pRowArray[nRow] = aColSeq;
2656 24 : }
2657 : }
2658 : else
2659 0 : throw uno::RuntimeException();
2660 4 : return aRowSeq;
2661 : }
2662 :
2663 4 : void SAL_CALL SwXTextTable::setDataArray(
2664 : const uno::Sequence< uno::Sequence< uno::Any > >& rArray )
2665 : throw (uno::RuntimeException, std::exception)
2666 : {
2667 : // see SwXTextTable::setData(...) also
2668 :
2669 4 : SolarMutexGuard aGuard;
2670 4 : const sal_uInt16 nRowCount = getRowCount();
2671 4 : const sal_uInt16 nColCount = getColumnCount();
2672 :
2673 4 : SwFrmFmt* pFmt = GetFrmFmt();
2674 4 : if(pFmt)
2675 : {
2676 4 : SwTable* pTable = SwTable::FindTable( pFmt );
2677 4 : if(pTable->IsTblComplex())
2678 : {
2679 0 : uno::RuntimeException aRuntime;
2680 0 : aRuntime.Message = "Table too complex";
2681 0 : throw aRuntime;
2682 : }
2683 :
2684 4 : if(rArray.getLength() != nRowCount)
2685 : {
2686 0 : throw uno::RuntimeException();
2687 : }
2688 4 : const uno::Sequence< uno::Any >* pRowArray = rArray.getConstArray();
2689 28 : for(sal_uInt16 nRow = 0; nRow < nRowCount; nRow++)
2690 : {
2691 24 : const uno::Sequence< uno::Any >& rColSeq = pRowArray[nRow];
2692 24 : if(rColSeq.getLength() != nColCount)
2693 : {
2694 0 : throw uno::RuntimeException();
2695 : }
2696 24 : const uno::Any * pColArray = rColSeq.getConstArray();
2697 24 : uno::Reference< table::XCell > xCellRef;
2698 72 : for(sal_uInt16 nCol = 0; nCol < nColCount; nCol++)
2699 : {
2700 48 : SwXCell* pXCell = lcl_CreateXCell(pFmt, nCol, nRow);
2701 : //! keep (additional) reference to object to prevent implicit destruction
2702 : //! in following UNO calls (when object will get referenced)
2703 48 : xCellRef = pXCell;
2704 48 : SwTableBox * pBox = pXCell ? pXCell->GetTblBox() : 0;
2705 48 : if(!pBox)
2706 : {
2707 0 : throw uno::RuntimeException();
2708 : }
2709 : else
2710 : {
2711 48 : const uno::Any &rAny = pColArray[nCol];
2712 48 : if (uno::TypeClass_STRING == rAny.getValueTypeClass())
2713 24 : sw_setString( *pXCell, *(OUString *) rAny.getValue() );
2714 : else
2715 : {
2716 24 : double d = 0;
2717 : // #i20067# don't throw exception just do nothing if
2718 : // there is no value set
2719 24 : if( (rAny >>= d) )
2720 24 : sw_setValue( *pXCell, d );
2721 : else
2722 0 : sw_setString( *pXCell, OUString(), true );
2723 :
2724 : }
2725 : }
2726 : }
2727 24 : }
2728 4 : }
2729 4 : }
2730 :
2731 8 : uno::Sequence< uno::Sequence< double > > SwXTextTable::getData(void)
2732 : throw( uno::RuntimeException, std::exception )
2733 : {
2734 8 : SolarMutexGuard aGuard;
2735 8 : const sal_uInt16 nRowCount = getRowCount();
2736 8 : const sal_uInt16 nColCount = getColumnCount();
2737 8 : if(!nRowCount || !nColCount)
2738 : {
2739 0 : uno::RuntimeException aRuntime;
2740 0 : aRuntime.Message = "Table too complex";
2741 0 : throw aRuntime;
2742 : }
2743 :
2744 8 : SwFrmFmt* pFmt = GetFrmFmt();
2745 8 : uno::Sequence< uno::Sequence< double > > aRowSeq(bFirstRowAsLabel ? nRowCount - 1 : nRowCount);
2746 8 : if(pFmt)
2747 : {
2748 8 : uno::Sequence< double >* pArray = aRowSeq.getArray();
2749 :
2750 8 : const sal_uInt16 nRowStart = bFirstRowAsLabel ? 1 : 0;
2751 48 : for(sal_uInt16 nRow = nRowStart; nRow < nRowCount; nRow++)
2752 : {
2753 40 : uno::Sequence< double > aColSeq(bFirstColumnAsLabel ? nColCount - 1 : nColCount);
2754 40 : double* pColArray = aColSeq.getArray();
2755 40 : const sal_uInt16 nColStart = bFirstColumnAsLabel ? 1 : 0;
2756 80 : for(sal_uInt16 nCol = nColStart; nCol < nColCount; nCol++)
2757 : {
2758 40 : uno::Reference< table::XCell > xCell = getCellByPosition(nCol, nRow);
2759 40 : if(!xCell.is())
2760 : {
2761 0 : throw uno::RuntimeException();
2762 : }
2763 40 : pColArray[nCol - nColStart] = xCell->getValue();
2764 40 : }
2765 40 : pArray[nRow - nRowStart] = aColSeq;
2766 40 : }
2767 : }
2768 : else
2769 0 : throw uno::RuntimeException();
2770 8 : return aRowSeq;
2771 : }
2772 :
2773 6 : void SwXTextTable::setData(const uno::Sequence< uno::Sequence< double > >& rData)
2774 : throw( uno::RuntimeException, std::exception )
2775 : {
2776 6 : SolarMutexGuard aGuard;
2777 6 : const sal_uInt16 nRowCount = getRowCount();
2778 6 : const sal_uInt16 nColCount = getColumnCount();
2779 6 : bool bChanged = false;
2780 :
2781 6 : if(!nRowCount || !nColCount)
2782 : {
2783 0 : uno::RuntimeException aRuntime;
2784 0 : aRuntime.Message = "Table too complex";
2785 0 : throw aRuntime;
2786 : }
2787 :
2788 6 : SwFrmFmt* pFmt = GetFrmFmt();
2789 6 : if(pFmt )
2790 : {
2791 6 : const sal_uInt16 nRowStart = bFirstRowAsLabel ? 1 : 0;
2792 6 : if(rData.getLength() < nRowCount - nRowStart)
2793 : {
2794 0 : throw uno::RuntimeException();
2795 : }
2796 6 : const uno::Sequence< double >* pRowArray = rData.getConstArray();
2797 36 : for(sal_uInt16 nRow = nRowStart; nRow < nRowCount; nRow++)
2798 : {
2799 30 : const uno::Sequence< double >& rColSeq = pRowArray[nRow - nRowStart];
2800 30 : const sal_uInt16 nColStart = bFirstColumnAsLabel ? 1 : 0;
2801 30 : if(rColSeq.getLength() < nColCount - nColStart)
2802 : {
2803 0 : throw uno::RuntimeException();
2804 : }
2805 30 : const double * pColArray = rColSeq.getConstArray();
2806 60 : for(sal_uInt16 nCol = nColStart; nCol < nColCount; nCol++)
2807 : {
2808 30 : uno::Reference< table::XCell > xCell = getCellByPosition(nCol, nRow);
2809 30 : if(!xCell.is())
2810 : {
2811 0 : throw uno::RuntimeException();
2812 : }
2813 30 : xCell->setValue(pColArray[nCol - nColStart]);
2814 30 : bChanged=true;
2815 30 : }
2816 : }
2817 6 : if ( bChanged )
2818 : {
2819 6 : lcl_SendChartEvent(*this, m_pImpl->m_Listeners);
2820 : }
2821 6 : }
2822 6 : }
2823 :
2824 6 : uno::Sequence< OUString > SwXTextTable::getRowDescriptions(void) throw( uno::RuntimeException, std::exception )
2825 : {
2826 6 : SolarMutexGuard aGuard;
2827 6 : const sal_uInt16 nRowCount = getRowCount();
2828 6 : if(!nRowCount)
2829 : {
2830 0 : uno::RuntimeException aRuntime;
2831 0 : aRuntime.Message = "Table too complex";
2832 0 : throw aRuntime;
2833 : }
2834 6 : uno::Sequence< OUString > aRet(bFirstColumnAsLabel ? nRowCount - 1 : nRowCount);
2835 :
2836 6 : SwFrmFmt* pFmt = GetFrmFmt();
2837 6 : if(pFmt)
2838 : {
2839 6 : OUString* pArray = aRet.getArray();
2840 6 : if(bFirstColumnAsLabel)
2841 : {
2842 6 : const sal_uInt16 nStart = bFirstRowAsLabel ? 1 : 0;
2843 36 : for(sal_uInt16 i = nStart; i < nRowCount; i++)
2844 : {
2845 30 : uno::Reference< table::XCell > xCell = getCellByPosition(0, i);
2846 30 : if(!xCell.is())
2847 : {
2848 : //exception ...
2849 0 : break;
2850 : }
2851 60 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
2852 30 : pArray[i - nStart] = xText->getString();
2853 30 : }
2854 : }
2855 : else
2856 : {
2857 : OSL_FAIL("Where do these labels come from?");
2858 : }
2859 : }
2860 : else
2861 0 : throw uno::RuntimeException();
2862 6 : return aRet;
2863 : }
2864 :
2865 2 : void SwXTextTable::setRowDescriptions(const uno::Sequence< OUString >& rRowDesc) throw( uno::RuntimeException, std::exception )
2866 : {
2867 2 : SolarMutexGuard aGuard;
2868 2 : SwFrmFmt* pFmt = GetFrmFmt();
2869 2 : if(pFmt)
2870 : {
2871 2 : const sal_uInt16 nRowCount = getRowCount();
2872 2 : if(!nRowCount || rRowDesc.getLength() < (bFirstRowAsLabel ? nRowCount - 1 : nRowCount))
2873 : {
2874 0 : throw uno::RuntimeException();
2875 : }
2876 2 : const OUString* pArray = rRowDesc.getConstArray();
2877 2 : if(bFirstColumnAsLabel)
2878 : {
2879 2 : const sal_uInt16 nStart = bFirstRowAsLabel ? 1 : 0;
2880 12 : for(sal_uInt16 i = nStart; i < nRowCount; i++)
2881 : {
2882 10 : uno::Reference< table::XCell > xCell = getCellByPosition(0, i);
2883 10 : if(!xCell.is())
2884 : {
2885 0 : throw uno::RuntimeException();
2886 : }
2887 20 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
2888 10 : xText->setString(pArray[i - nStart]);
2889 10 : }
2890 : }
2891 : else
2892 : {
2893 : OSL_FAIL("Where to put theses labels?");
2894 : }
2895 : }
2896 : else
2897 0 : throw uno::RuntimeException();
2898 2 : }
2899 :
2900 6 : uno::Sequence< OUString > SwXTextTable::getColumnDescriptions(void)
2901 : throw( uno::RuntimeException, std::exception )
2902 : {
2903 6 : SolarMutexGuard aGuard;
2904 6 : const sal_uInt16 nColCount = getColumnCount();
2905 6 : if(!nColCount)
2906 : {
2907 0 : uno::RuntimeException aRuntime;
2908 0 : aRuntime.Message = "Table too complex";
2909 0 : throw aRuntime;
2910 : }
2911 6 : uno::Sequence< OUString > aRet(bFirstRowAsLabel ? nColCount - 1 : nColCount);
2912 6 : SwFrmFmt* pFmt = GetFrmFmt();
2913 6 : if(pFmt)
2914 : {
2915 6 : OUString* pArray = aRet.getArray();
2916 6 : if(bFirstRowAsLabel)
2917 : {
2918 6 : const sal_uInt16 nStart = bFirstColumnAsLabel ? 1 : 0;
2919 12 : for(sal_uInt16 i = nStart; i < nColCount; i++)
2920 : {
2921 6 : uno::Reference< table::XCell > xCell = getCellByPosition(i, 0);
2922 6 : if(!xCell.is())
2923 : {
2924 0 : throw uno::RuntimeException();
2925 : }
2926 12 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
2927 :
2928 6 : pArray[i - nStart] = xText->getString();
2929 6 : }
2930 : }
2931 : else
2932 : {
2933 : OSL_FAIL("Where do these labels come from?");
2934 : }
2935 : }
2936 : else
2937 0 : throw uno::RuntimeException();
2938 6 : return aRet;
2939 : }
2940 :
2941 2 : void SwXTextTable::setColumnDescriptions(const uno::Sequence< OUString >& rColumnDesc) throw( uno::RuntimeException, std::exception )
2942 : {
2943 2 : SolarMutexGuard aGuard;
2944 2 : const sal_uInt16 nColCount = getColumnCount();
2945 2 : if(!nColCount)
2946 : {
2947 0 : uno::RuntimeException aRuntime;
2948 0 : aRuntime.Message = "Table too complex";
2949 0 : throw aRuntime;
2950 : }
2951 2 : SwFrmFmt* pFmt = GetFrmFmt();
2952 2 : if(pFmt)
2953 : {
2954 2 : const OUString* pArray = rColumnDesc.getConstArray();
2955 2 : if(bFirstRowAsLabel && rColumnDesc.getLength() >= nColCount - (bFirstColumnAsLabel ? 1 : 0))
2956 : {
2957 2 : const sal_uInt16 nStart = bFirstColumnAsLabel ? 1 : 0;
2958 4 : for(sal_uInt16 i = nStart; i < nColCount; i++)
2959 : {
2960 2 : uno::Reference< table::XCell > xCell = getCellByPosition(i, 0);
2961 2 : if(!xCell.is())
2962 : {
2963 0 : throw uno::RuntimeException();
2964 : }
2965 4 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
2966 2 : xText->setString(pArray[i - nStart]);
2967 2 : }
2968 : }
2969 : else
2970 : {
2971 : OSL_FAIL("Where do these labels come from?");
2972 : }
2973 : }
2974 : else
2975 0 : throw uno::RuntimeException();
2976 2 : }
2977 :
2978 4 : void SAL_CALL SwXTextTable::addChartDataChangeEventListener(
2979 : const uno::Reference<chart::XChartDataChangeEventListener> & xListener)
2980 : throw (uno::RuntimeException, std::exception)
2981 : {
2982 : // no need to lock here as m_pImpl is const and container threadsafe
2983 4 : m_pImpl->m_Listeners.addInterface(
2984 8 : cppu::UnoType<chart::XChartDataChangeEventListener>::get(), xListener);
2985 4 : }
2986 :
2987 4 : void SAL_CALL SwXTextTable::removeChartDataChangeEventListener(
2988 : const uno::Reference<chart::XChartDataChangeEventListener> & xListener)
2989 : throw (uno::RuntimeException, std::exception)
2990 : {
2991 : // no need to lock here as m_pImpl is const and container threadsafe
2992 4 : m_pImpl->m_Listeners.removeInterface(
2993 8 : cppu::UnoType<chart::XChartDataChangeEventListener>::get(), xListener);
2994 4 : }
2995 :
2996 4 : sal_Bool SwXTextTable::isNotANumber(double nNumber) throw( uno::RuntimeException, std::exception )
2997 : {
2998 : // We use DBL_MIN because starcalc does (which uses it because chart
2999 : // wants it that way!)
3000 4 : return ( nNumber == DBL_MIN );
3001 : }
3002 :
3003 2 : double SwXTextTable::getNotANumber(void) throw( uno::RuntimeException, std::exception )
3004 : {
3005 : // We use DBL_MIN because starcalc does (which uses it because chart
3006 : // wants it that way!)
3007 2 : return DBL_MIN;
3008 : }
3009 :
3010 2 : uno::Sequence< beans::PropertyValue > SwXTextTable::createSortDescriptor(void)
3011 : throw( uno::RuntimeException, std::exception )
3012 : {
3013 2 : SolarMutexGuard aGuard;
3014 :
3015 2 : return SwUnoCursorHelper::CreateSortDescriptor(true);
3016 : }
3017 :
3018 8 : void SwXTextTable::sort(const uno::Sequence< beans::PropertyValue >& rDescriptor)
3019 : throw (uno::RuntimeException, std::exception)
3020 : {
3021 8 : SolarMutexGuard aGuard;
3022 16 : SwSortOptions aSortOpt;
3023 8 : SwFrmFmt* pFmt = GetFrmFmt();
3024 16 : if(pFmt &&
3025 8 : SwUnoCursorHelper::ConvertSortProperties(rDescriptor, aSortOpt))
3026 : {
3027 8 : SwTable* pTable = SwTable::FindTable( pFmt );
3028 8 : SwSelBoxes aBoxes;
3029 8 : const SwTableSortBoxes& rTBoxes = pTable->GetTabSortBoxes();
3030 104 : for (size_t n = 0; n < rTBoxes.size(); ++n)
3031 : {
3032 96 : SwTableBox* pBox = rTBoxes[ n ];
3033 96 : aBoxes.insert( pBox );
3034 : }
3035 16 : UnoActionContext aContext( pFmt->GetDoc() );
3036 16 : pFmt->GetDoc()->SortTbl(aBoxes, aSortOpt);
3037 8 : }
3038 8 : }
3039 :
3040 0 : void SwXTextTable::autoFormat(const OUString& sAutoFmtName)
3041 : throw (lang::IllegalArgumentException, uno::RuntimeException,
3042 : std::exception)
3043 : {
3044 0 : SolarMutexGuard aGuard;
3045 0 : SwFrmFmt* pFmt = GetFrmFmt();
3046 0 : if(pFmt)
3047 : {
3048 0 : SwTable* pTable = SwTable::FindTable( pFmt );
3049 0 : if(!pTable->IsTblComplex())
3050 : {
3051 0 : SwTableAutoFmtTbl aAutoFmtTbl;
3052 0 : aAutoFmtTbl.Load();
3053 0 : for (size_t i = aAutoFmtTbl.size(); i;)
3054 0 : if( sAutoFmtName == aAutoFmtTbl[ --i ].GetName() )
3055 : {
3056 0 : SwSelBoxes aBoxes;
3057 0 : const SwTableSortBoxes& rTBoxes = pTable->GetTabSortBoxes();
3058 0 : for (size_t n = 0; n < rTBoxes.size(); ++n)
3059 : {
3060 0 : SwTableBox* pBox = rTBoxes[ n ];
3061 0 : aBoxes.insert( pBox );
3062 : }
3063 0 : UnoActionContext aContext( pFmt->GetDoc() );
3064 0 : pFmt->GetDoc()->SetTableAutoFmt( aBoxes, aAutoFmtTbl[i] );
3065 0 : break;
3066 0 : }
3067 : }
3068 : }
3069 : else
3070 0 : throw uno::RuntimeException();
3071 0 : }
3072 :
3073 118 : uno::Reference< beans::XPropertySetInfo > SwXTextTable::getPropertySetInfo(void) throw( uno::RuntimeException, std::exception )
3074 : {
3075 118 : static uno::Reference< beans::XPropertySetInfo > xRef = m_pPropSet->getPropertySetInfo();
3076 118 : return xRef;
3077 : }
3078 :
3079 14258 : void SwXTextTable::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
3080 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
3081 : lang::IllegalArgumentException, lang::WrappedTargetException,
3082 : uno::RuntimeException, std::exception)
3083 : {
3084 14258 : SolarMutexGuard aGuard;
3085 14258 : SwFrmFmt* pFmt = GetFrmFmt();
3086 14258 : if(!aValue.hasValue())
3087 0 : throw lang::IllegalArgumentException();
3088 : const SfxItemPropertySimpleEntry* pEntry =
3089 14258 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
3090 14258 : if( !pEntry )
3091 4412 : throw lang::IllegalArgumentException();
3092 9846 : if(pFmt)
3093 : {
3094 9844 : if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
3095 8 : throw beans::PropertyVetoException("Property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
3096 :
3097 9836 : if(0xFF == pEntry->nMemberId)
3098 : {
3099 2336 : lcl_SetSpecialProperty(pFmt, pEntry, aValue);
3100 : }
3101 : else
3102 : {
3103 7500 : switch(pEntry->nWID)
3104 : {
3105 : case FN_UNO_TABLE_NAME :
3106 : {
3107 0 : OUString sName;
3108 0 : aValue >>= sName;
3109 0 : setName( sName );
3110 : }
3111 0 : break;
3112 :
3113 : case FN_UNO_RANGE_ROW_LABEL:
3114 : {
3115 14 : bool bTmp = *(sal_Bool*)aValue.getValue();
3116 14 : if(bFirstRowAsLabel != bTmp)
3117 : {
3118 14 : lcl_SendChartEvent(*this, m_pImpl->m_Listeners);
3119 14 : bFirstRowAsLabel = bTmp;
3120 : }
3121 : }
3122 14 : break;
3123 :
3124 : case FN_UNO_RANGE_COL_LABEL:
3125 : {
3126 14 : bool bTmp = *(sal_Bool*)aValue.getValue();
3127 14 : if(bFirstColumnAsLabel != bTmp)
3128 : {
3129 14 : lcl_SendChartEvent(*this, m_pImpl->m_Listeners);
3130 14 : bFirstColumnAsLabel = bTmp;
3131 : }
3132 : }
3133 14 : break;
3134 :
3135 : case FN_UNO_TABLE_BORDER:
3136 : case FN_UNO_TABLE_BORDER2:
3137 : {
3138 1072 : table::TableBorder oldBorder;
3139 1072 : table::TableBorder2 aBorder;
3140 1072 : SvxBorderLine aTopLine;
3141 1072 : SvxBorderLine aBottomLine;
3142 1072 : SvxBorderLine aLeftLine;
3143 1072 : SvxBorderLine aRightLine;
3144 1072 : SvxBorderLine aHoriLine;
3145 1072 : SvxBorderLine aVertLine;
3146 1072 : if (aValue >>= oldBorder)
3147 : {
3148 1068 : aBorder.IsTopLineValid = oldBorder.IsTopLineValid;
3149 1068 : aBorder.IsBottomLineValid = oldBorder.IsBottomLineValid;
3150 1068 : aBorder.IsLeftLineValid = oldBorder.IsLeftLineValid;
3151 1068 : aBorder.IsRightLineValid = oldBorder.IsRightLineValid;
3152 1068 : aBorder.IsHorizontalLineValid = oldBorder.IsHorizontalLineValid;
3153 1068 : aBorder.IsVerticalLineValid = oldBorder.IsVerticalLineValid;
3154 1068 : aBorder.Distance = oldBorder.Distance;
3155 1068 : aBorder.IsDistanceValid = oldBorder.IsDistanceValid;
3156 : lcl_LineToSvxLine(
3157 1068 : oldBorder.TopLine, aTopLine);
3158 : lcl_LineToSvxLine(
3159 1068 : oldBorder.BottomLine, aBottomLine);
3160 : lcl_LineToSvxLine(
3161 1068 : oldBorder.LeftLine, aLeftLine);
3162 : lcl_LineToSvxLine(
3163 1068 : oldBorder.RightLine, aRightLine);
3164 : lcl_LineToSvxLine(
3165 1068 : oldBorder.HorizontalLine, aHoriLine);
3166 : lcl_LineToSvxLine(
3167 1068 : oldBorder.VerticalLine, aVertLine);
3168 : }
3169 4 : else if (aValue >>= aBorder)
3170 : {
3171 : SvxBoxItem::LineToSvxLine(
3172 4 : aBorder.TopLine, aTopLine, true);
3173 : SvxBoxItem::LineToSvxLine(
3174 4 : aBorder.BottomLine, aBottomLine, true);
3175 : SvxBoxItem::LineToSvxLine(
3176 4 : aBorder.LeftLine, aLeftLine, true);
3177 : SvxBoxItem::LineToSvxLine(
3178 4 : aBorder.RightLine, aRightLine, true);
3179 : SvxBoxItem::LineToSvxLine(
3180 4 : aBorder.HorizontalLine, aHoriLine, true);
3181 : SvxBoxItem::LineToSvxLine(
3182 4 : aBorder.VerticalLine, aVertLine, true);
3183 : }
3184 : else
3185 : {
3186 1062 : break; // something else
3187 : }
3188 1072 : SwDoc* pDoc = pFmt->GetDoc();
3189 1072 : SwFrm* pFrm = SwIterator<SwFrm,SwFmt>::FirstElement( *pFmt );
3190 : // tables without layout (invisible header/footer?)
3191 1072 : if (!pFrm)
3192 : {
3193 1062 : break;
3194 : }
3195 10 : lcl_FormatTable(pFmt);
3196 10 : SwTable* pTable = SwTable::FindTable( pFmt );
3197 10 : SwTableLines &rLines = pTable->GetTabLines();
3198 :
3199 : // invalidate all actions
3200 10 : UnoActionRemoveContext aRemoveContext(pDoc);
3201 10 : const SwTableBox* pTLBox = lcl_FindCornerTableBox(rLines, true);
3202 10 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
3203 20 : SwPosition aPos(*pSttNd);
3204 : // set cursor to top left cell
3205 10 : SwUnoCrsr* pUnoCrsr = pDoc->CreateUnoCrsr(aPos, true);
3206 10 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
3207 10 : pUnoCrsr->SetRemainInSection( false );
3208 :
3209 10 : const SwTableBox* pBRBox = lcl_FindCornerTableBox(rLines, false);
3210 10 : pUnoCrsr->SetMark();
3211 10 : pUnoCrsr->GetPoint()->nNode = *pBRBox->GetSttNd();
3212 10 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
3213 10 : SwUnoTableCrsr& rCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
3214 10 : rCrsr.MakeBoxSels();
3215 :
3216 10 : SfxItemSet aSet(pDoc->GetAttrPool(),
3217 : RES_BOX, RES_BOX,
3218 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
3219 20 : 0);
3220 :
3221 20 : SvxBoxItem aBox( RES_BOX );
3222 20 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
3223 :
3224 10 : aBox.SetLine(aTopLine.isEmpty() ? 0 : &aTopLine, BOX_LINE_TOP);
3225 10 : aBoxInfo.SetValid(VALID_TOP, aBorder.IsTopLineValid);
3226 :
3227 10 : aBox.SetLine(aBottomLine.isEmpty() ? 0 : &aBottomLine, BOX_LINE_BOTTOM);
3228 10 : aBoxInfo.SetValid(VALID_BOTTOM, aBorder.IsBottomLineValid);
3229 :
3230 10 : aBox.SetLine(aLeftLine.isEmpty() ? 0 : &aLeftLine, BOX_LINE_LEFT);
3231 10 : aBoxInfo.SetValid(VALID_LEFT, aBorder.IsLeftLineValid);
3232 :
3233 10 : aBox.SetLine(aRightLine.isEmpty() ? 0 : &aRightLine, BOX_LINE_RIGHT);
3234 10 : aBoxInfo.SetValid(VALID_RIGHT, aBorder.IsRightLineValid);
3235 :
3236 10 : aBoxInfo.SetLine(aHoriLine.isEmpty() ? 0 : &aHoriLine, BOXINFO_LINE_HORI);
3237 10 : aBoxInfo.SetValid(VALID_HORI, aBorder.IsHorizontalLineValid);
3238 :
3239 10 : aBoxInfo.SetLine(aVertLine.isEmpty() ? 0 : &aVertLine, BOXINFO_LINE_VERT);
3240 10 : aBoxInfo.SetValid(VALID_VERT, aBorder.IsVerticalLineValid);
3241 :
3242 10 : aBox.SetDistance((sal_uInt16)convertMm100ToTwip(aBorder.Distance));
3243 10 : aBoxInfo.SetValid(VALID_DISTANCE, aBorder.IsDistanceValid);
3244 :
3245 10 : aSet.Put(aBox);
3246 10 : aSet.Put(aBoxInfo);
3247 :
3248 10 : pDoc->SetTabBorders(rCrsr, aSet);
3249 20 : delete pUnoCrsr;
3250 : }
3251 10 : break;
3252 :
3253 : case FN_UNO_TABLE_BORDER_DISTANCES:
3254 : {
3255 1062 : table::TableBorderDistances aTableBorderDistances;
3256 2124 : if( !(aValue >>= aTableBorderDistances) ||
3257 1062 : (!aTableBorderDistances.IsLeftDistanceValid &&
3258 0 : !aTableBorderDistances.IsRightDistanceValid &&
3259 0 : !aTableBorderDistances.IsTopDistanceValid &&
3260 0 : !aTableBorderDistances.IsBottomDistanceValid ))
3261 0 : break;
3262 :
3263 1062 : const sal_uInt16 nLeftDistance = convertMm100ToTwip(aTableBorderDistances.LeftDistance);
3264 1062 : const sal_uInt16 nRightDistance = convertMm100ToTwip(aTableBorderDistances.RightDistance);
3265 1062 : const sal_uInt16 nTopDistance = convertMm100ToTwip(aTableBorderDistances.TopDistance);
3266 1062 : const sal_uInt16 nBottomDistance = convertMm100ToTwip(aTableBorderDistances.BottomDistance);
3267 1062 : SwDoc* pDoc = pFmt->GetDoc();
3268 1062 : SwTable* pTable = SwTable::FindTable( pFmt );
3269 1062 : SwTableLines &rLines = pTable->GetTabLines();
3270 1062 : pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_START, NULL);
3271 6424 : for(size_t i = 0; i < rLines.size(); ++i)
3272 : {
3273 5362 : SwTableLine* pLine = rLines[i];
3274 5362 : SwTableBoxes& rBoxes = pLine->GetTabBoxes();
3275 20302 : for(size_t k = 0; k < rBoxes.size(); ++k)
3276 : {
3277 14940 : SwTableBox* pBox = rBoxes[k];
3278 14940 : const SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
3279 14940 : const SvxBoxItem& rBox = pBoxFmt->GetBox();
3280 14940 : if(
3281 14940 : (aTableBorderDistances.IsLeftDistanceValid && nLeftDistance != rBox.GetDistance( BOX_LINE_LEFT )) ||
3282 804 : (aTableBorderDistances.IsRightDistanceValid && nRightDistance != rBox.GetDistance( BOX_LINE_RIGHT )) ||
3283 29880 : (aTableBorderDistances.IsTopDistanceValid && nTopDistance != rBox.GetDistance( BOX_LINE_TOP )) ||
3284 684 : (aTableBorderDistances.IsBottomDistanceValid && nBottomDistance != rBox.GetDistance( BOX_LINE_BOTTOM )))
3285 : {
3286 14256 : SvxBoxItem aSetBox( rBox );
3287 14256 : SwFrmFmt* pSetBoxFmt = pBox->ClaimFrmFmt();
3288 14256 : if( aTableBorderDistances.IsLeftDistanceValid )
3289 14256 : aSetBox.SetDistance( nLeftDistance, BOX_LINE_LEFT );
3290 14256 : if( aTableBorderDistances.IsRightDistanceValid )
3291 14256 : aSetBox.SetDistance( nRightDistance, BOX_LINE_RIGHT );
3292 14256 : if( aTableBorderDistances.IsTopDistanceValid )
3293 14256 : aSetBox.SetDistance( nTopDistance, BOX_LINE_TOP );
3294 14256 : if( aTableBorderDistances.IsBottomDistanceValid )
3295 14256 : aSetBox.SetDistance( nBottomDistance, BOX_LINE_BOTTOM );
3296 14256 : pDoc->SetAttr( aSetBox, *pSetBoxFmt );
3297 : }
3298 : }
3299 : }
3300 1062 : pDoc->GetIDocumentUndoRedo().EndUndo(UNDO_END, NULL);
3301 : }
3302 1062 : break;
3303 :
3304 : case FN_UNO_TABLE_COLUMN_SEPARATORS:
3305 : {
3306 2 : UnoActionContext aContext(pFmt->GetDoc());
3307 2 : SwTable* pTable = SwTable::FindTable( pFmt );
3308 2 : lcl_SetTblSeparators(aValue, pTable, pTable->GetTabLines()[0]->GetTabBoxes()[0], false, pFmt->GetDoc());
3309 : }
3310 2 : break;
3311 :
3312 0 : case FN_UNO_TABLE_COLUMN_RELATIVE_SUM:/*_readonly_*/ break;
3313 :
3314 : default:
3315 : {
3316 5336 : SwAttrSet aSet(pFmt->GetAttrSet());
3317 5336 : m_pPropSet->setPropertyValue(*pEntry, aValue, aSet);
3318 5336 : pFmt->GetDoc()->SetAttr(aSet, *pFmt);
3319 : }
3320 : }
3321 : }
3322 : }
3323 2 : else if(bIsDescriptor)
3324 : {
3325 2 : pTableProps->SetProperty( pEntry->nWID, pEntry->nMemberId, aValue);
3326 : }
3327 : else
3328 0 : throw uno::RuntimeException();
3329 9702 : }
3330 :
3331 640 : uno::Any SwXTextTable::getPropertyValue(const OUString& rPropertyName)
3332 : throw (beans::UnknownPropertyException,
3333 : lang::WrappedTargetException,
3334 : uno::RuntimeException,
3335 : std::exception)
3336 : {
3337 640 : SolarMutexGuard aGuard;
3338 640 : uno::Any aRet;
3339 640 : SwFrmFmt* pFmt = GetFrmFmt();
3340 : const SfxItemPropertySimpleEntry* pEntry =
3341 640 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
3342 :
3343 640 : if (!pEntry)
3344 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
3345 :
3346 640 : if(pFmt)
3347 : {
3348 640 : if(0xFF == pEntry->nMemberId)
3349 : {
3350 504 : aRet = lcl_GetSpecialProperty(pFmt, pEntry );
3351 : }
3352 : else
3353 : {
3354 136 : switch(pEntry->nWID)
3355 : {
3356 : case FN_UNO_TABLE_NAME:
3357 : {
3358 0 : aRet <<= getName();
3359 : }
3360 0 : break;
3361 :
3362 : case FN_UNO_ANCHOR_TYPES:
3363 : case FN_UNO_TEXT_WRAP:
3364 : case FN_UNO_ANCHOR_TYPE:
3365 : ::sw::GetDefaultTextContentValue(
3366 8 : aRet, OUString(), pEntry->nWID);
3367 8 : break;
3368 :
3369 : case FN_UNO_RANGE_ROW_LABEL:
3370 : {
3371 6 : sal_Bool bTemp = bFirstRowAsLabel;
3372 6 : aRet.setValue(&bTemp, ::getCppuBooleanType());
3373 : }
3374 6 : break;
3375 :
3376 : case FN_UNO_RANGE_COL_LABEL:
3377 : {
3378 6 : sal_Bool bTemp = bFirstColumnAsLabel;
3379 6 : aRet.setValue(&bTemp, ::getCppuBooleanType());
3380 : }
3381 6 : break;
3382 :
3383 : case FN_UNO_TABLE_BORDER:
3384 : case FN_UNO_TABLE_BORDER2:
3385 : {
3386 28 : SwDoc* pDoc = pFmt->GetDoc();
3387 28 : SwFrm* pFrm = SwIterator<SwFrm,SwFmt>::FirstElement( *pFmt );
3388 : // tables without layout (invisible header/footer?)
3389 28 : if (!pFrm)
3390 : {
3391 0 : break;
3392 : }
3393 28 : lcl_FormatTable(pFmt);
3394 28 : SwTable* pTable = SwTable::FindTable( pFmt );
3395 28 : SwTableLines &rLines = pTable->GetTabLines();
3396 :
3397 : // invalidate all actions
3398 28 : UnoActionRemoveContext aRemoveContext(pDoc);
3399 28 : const SwTableBox* pTLBox = lcl_FindCornerTableBox(rLines, true);
3400 28 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
3401 56 : SwPosition aPos(*pSttNd);
3402 : // set cursor to top left cell
3403 28 : SwUnoCrsr* pUnoCrsr = pDoc->CreateUnoCrsr(aPos, true);
3404 28 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
3405 28 : pUnoCrsr->SetRemainInSection( false );
3406 :
3407 28 : const SwTableBox* pBRBox = lcl_FindCornerTableBox(rLines, false);
3408 28 : pUnoCrsr->SetMark();
3409 28 : const SwStartNode* pLastNd = pBRBox->GetSttNd();
3410 28 : pUnoCrsr->GetPoint()->nNode = *pLastNd;
3411 :
3412 28 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
3413 28 : SwUnoTableCrsr& rCrsr = dynamic_cast<SwUnoTableCrsr&>(*pUnoCrsr);
3414 28 : rCrsr.MakeBoxSels();
3415 :
3416 28 : SfxItemSet aSet(pDoc->GetAttrPool(),
3417 : RES_BOX, RES_BOX,
3418 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
3419 56 : 0);
3420 28 : aSet.Put(SvxBoxInfoItem( SID_ATTR_BORDER_INNER ));
3421 28 : pDoc->GetTabBorders(rCrsr, aSet);
3422 : const SvxBoxInfoItem& rBoxInfoItem =
3423 28 : (const SvxBoxInfoItem&)aSet.Get(SID_ATTR_BORDER_INNER);
3424 28 : const SvxBoxItem& rBox = (const SvxBoxItem&)aSet.Get(RES_BOX);
3425 :
3426 28 : if (FN_UNO_TABLE_BORDER == pEntry->nWID)
3427 : {
3428 14 : table::TableBorder aTableBorder;
3429 14 : aTableBorder.TopLine = SvxBoxItem::SvxLineToLine(rBox.GetTop(), true);
3430 14 : aTableBorder.IsTopLineValid = rBoxInfoItem.IsValid(VALID_TOP);
3431 14 : aTableBorder.BottomLine = SvxBoxItem::SvxLineToLine(rBox.GetBottom(), true);
3432 14 : aTableBorder.IsBottomLineValid = rBoxInfoItem.IsValid(VALID_BOTTOM);
3433 14 : aTableBorder.LeftLine = SvxBoxItem::SvxLineToLine(rBox.GetLeft(), true);
3434 14 : aTableBorder.IsLeftLineValid = rBoxInfoItem.IsValid(VALID_LEFT);
3435 14 : aTableBorder.RightLine = SvxBoxItem::SvxLineToLine(rBox.GetRight(), true);
3436 14 : aTableBorder.IsRightLineValid = rBoxInfoItem.IsValid(VALID_RIGHT );
3437 14 : aTableBorder.HorizontalLine = SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetHori(), true);
3438 14 : aTableBorder.IsHorizontalLineValid = rBoxInfoItem.IsValid(VALID_HORI);
3439 14 : aTableBorder.VerticalLine = SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetVert(), true);
3440 14 : aTableBorder.IsVerticalLineValid = rBoxInfoItem.IsValid(VALID_VERT);
3441 14 : aTableBorder.Distance = convertTwipToMm100( rBox.GetDistance() );
3442 14 : aTableBorder.IsDistanceValid = rBoxInfoItem.IsValid(VALID_DISTANCE);
3443 14 : aRet <<= aTableBorder;
3444 : }
3445 : else
3446 : {
3447 14 : table::TableBorder2 aTableBorder;
3448 14 : aTableBorder.TopLine = SvxBoxItem::SvxLineToLine(rBox.GetTop(), true);
3449 14 : aTableBorder.IsTopLineValid = rBoxInfoItem.IsValid(VALID_TOP);
3450 14 : aTableBorder.BottomLine = SvxBoxItem::SvxLineToLine(rBox.GetBottom(), true);
3451 14 : aTableBorder.IsBottomLineValid = rBoxInfoItem.IsValid(VALID_BOTTOM);
3452 14 : aTableBorder.LeftLine = SvxBoxItem::SvxLineToLine(rBox.GetLeft(), true);
3453 14 : aTableBorder.IsLeftLineValid = rBoxInfoItem.IsValid(VALID_LEFT);
3454 14 : aTableBorder.RightLine = SvxBoxItem::SvxLineToLine(rBox.GetRight(), true);
3455 14 : aTableBorder.IsRightLineValid = rBoxInfoItem.IsValid(VALID_RIGHT );
3456 14 : aTableBorder.HorizontalLine = SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetHori(), true);
3457 14 : aTableBorder.IsHorizontalLineValid = rBoxInfoItem.IsValid(VALID_HORI);
3458 14 : aTableBorder.VerticalLine = SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetVert(), true);
3459 14 : aTableBorder.IsVerticalLineValid = rBoxInfoItem.IsValid(VALID_VERT);
3460 14 : aTableBorder.Distance = convertTwipToMm100( rBox.GetDistance() );
3461 14 : aTableBorder.IsDistanceValid = rBoxInfoItem.IsValid(VALID_DISTANCE);
3462 14 : aRet <<= aTableBorder;
3463 : }
3464 56 : delete pUnoCrsr;
3465 : }
3466 28 : break;
3467 :
3468 : case FN_UNO_TABLE_BORDER_DISTANCES :
3469 : {
3470 0 : table::TableBorderDistances aTableBorderDistances( 0, sal_True, 0, sal_True, 0, sal_True, 0, sal_True ) ;
3471 0 : SwTable* pTable = SwTable::FindTable( pFmt );
3472 0 : const SwTableLines &rLines = pTable->GetTabLines();
3473 0 : bool bFirst = true;
3474 0 : sal_uInt16 nLeftDistance = 0;
3475 0 : sal_uInt16 nRightDistance = 0;
3476 0 : sal_uInt16 nTopDistance = 0;
3477 0 : sal_uInt16 nBottomDistance = 0;
3478 :
3479 0 : for(size_t i = 0; i < rLines.size(); ++i)
3480 : {
3481 0 : const SwTableLine* pLine = rLines[i];
3482 0 : const SwTableBoxes& rBoxes = pLine->GetTabBoxes();
3483 0 : for(size_t k = 0; k < rBoxes.size(); ++k)
3484 : {
3485 0 : const SwTableBox* pBox = rBoxes[k];
3486 0 : SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
3487 0 : const SvxBoxItem& rBox = pBoxFmt->GetBox();
3488 0 : if( bFirst )
3489 : {
3490 0 : nLeftDistance = convertTwipToMm100( rBox.GetDistance( BOX_LINE_LEFT ));
3491 0 : nRightDistance = convertTwipToMm100( rBox.GetDistance( BOX_LINE_RIGHT ));
3492 0 : nTopDistance = convertTwipToMm100( rBox.GetDistance( BOX_LINE_TOP ));
3493 0 : nBottomDistance = convertTwipToMm100( rBox.GetDistance( BOX_LINE_BOTTOM ));
3494 0 : bFirst = false;
3495 : }
3496 : else
3497 : {
3498 0 : if( aTableBorderDistances.IsLeftDistanceValid &&
3499 0 : nLeftDistance != convertTwipToMm100( rBox.GetDistance( BOX_LINE_LEFT )))
3500 0 : aTableBorderDistances.IsLeftDistanceValid = sal_False;
3501 0 : if( aTableBorderDistances.IsRightDistanceValid &&
3502 0 : nRightDistance != convertTwipToMm100( rBox.GetDistance( BOX_LINE_RIGHT )))
3503 0 : aTableBorderDistances.IsRightDistanceValid = sal_False;
3504 0 : if( aTableBorderDistances.IsTopDistanceValid &&
3505 0 : nTopDistance != convertTwipToMm100( rBox.GetDistance( BOX_LINE_TOP )))
3506 0 : aTableBorderDistances.IsTopDistanceValid = sal_False;
3507 0 : if( aTableBorderDistances.IsBottomDistanceValid &&
3508 0 : nBottomDistance != convertTwipToMm100( rBox.GetDistance( BOX_LINE_BOTTOM )))
3509 0 : aTableBorderDistances.IsBottomDistanceValid = sal_False;
3510 : }
3511 :
3512 : }
3513 0 : if( !aTableBorderDistances.IsLeftDistanceValid &&
3514 0 : !aTableBorderDistances.IsRightDistanceValid &&
3515 0 : !aTableBorderDistances.IsTopDistanceValid &&
3516 0 : !aTableBorderDistances.IsBottomDistanceValid )
3517 0 : break;
3518 : }
3519 0 : if( aTableBorderDistances.IsLeftDistanceValid)
3520 0 : aTableBorderDistances.LeftDistance = nLeftDistance;
3521 0 : if( aTableBorderDistances.IsRightDistanceValid)
3522 0 : aTableBorderDistances.RightDistance = nRightDistance;
3523 0 : if( aTableBorderDistances.IsTopDistanceValid)
3524 0 : aTableBorderDistances.TopDistance = nTopDistance;
3525 0 : if( aTableBorderDistances.IsBottomDistanceValid)
3526 0 : aTableBorderDistances.BottomDistance = nBottomDistance;
3527 :
3528 0 : aRet <<= aTableBorderDistances;
3529 : }
3530 0 : break;
3531 :
3532 : case FN_UNO_TABLE_COLUMN_SEPARATORS:
3533 : {
3534 4 : SwTable* pTable = SwTable::FindTable( pFmt );
3535 4 : lcl_GetTblSeparators(aRet, pTable, pTable->GetTabLines()[0]->GetTabBoxes()[0], false);
3536 : }
3537 4 : break;
3538 :
3539 : case FN_UNO_TABLE_COLUMN_RELATIVE_SUM:
3540 4 : aRet <<= (sal_Int16) UNO_TABLE_COLUMN_SUM;
3541 4 : break;
3542 :
3543 : case RES_ANCHOR:
3544 : // AnchorType is readonly and might be void (no return value)
3545 0 : break;
3546 :
3547 : case FN_UNO_TEXT_SECTION:
3548 : {
3549 4 : SwTable* pTable = SwTable::FindTable( pFmt );
3550 4 : SwTableNode* pTblNode = pTable->GetTableNode();
3551 4 : SwSectionNode* pSectionNode = pTblNode->FindSectionNode();
3552 4 : if(pSectionNode)
3553 : {
3554 0 : const SwSection& rSect = pSectionNode->GetSection();
3555 : uno::Reference< text::XTextSection > xSect =
3556 0 : SwXTextSections::GetObject( *rSect.GetFmt() );
3557 0 : aRet <<= xSect;
3558 : }
3559 : }
3560 4 : break;
3561 :
3562 : default:
3563 : {
3564 76 : const SwAttrSet& rSet = pFmt->GetAttrSet();
3565 76 : m_pPropSet->getPropertyValue(*pEntry, rSet, aRet);
3566 : }
3567 : }
3568 : }
3569 : }
3570 0 : else if(bIsDescriptor)
3571 : {
3572 0 : const uno::Any* pAny = 0;
3573 0 : if(!pTableProps->GetProperty(pEntry->nWID, pEntry->nMemberId, pAny))
3574 0 : throw lang::IllegalArgumentException();
3575 0 : else if(pAny)
3576 0 : aRet = *pAny;
3577 : }
3578 : else
3579 0 : throw uno::RuntimeException();
3580 640 : return aRet;
3581 : }
3582 :
3583 0 : void SwXTextTable::addPropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
3584 : {
3585 : OSL_FAIL("not implemented");
3586 0 : }
3587 :
3588 0 : void SwXTextTable::removePropertyChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
3589 : {
3590 : OSL_FAIL("not implemented");
3591 0 : }
3592 :
3593 0 : void SwXTextTable::addVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
3594 : {
3595 : OSL_FAIL("not implemented");
3596 0 : }
3597 :
3598 0 : void SwXTextTable::removeVetoableChangeListener(const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
3599 : {
3600 : OSL_FAIL("not implemented");
3601 0 : }
3602 :
3603 6 : OUString SwXTextTable::getName(void) throw( uno::RuntimeException, std::exception )
3604 : {
3605 6 : SolarMutexGuard aGuard;
3606 6 : SwFrmFmt* pFmt = GetFrmFmt();
3607 6 : if(!pFmt && !bIsDescriptor)
3608 0 : throw uno::RuntimeException();
3609 6 : if(pFmt)
3610 : {
3611 6 : return pFmt->GetName();
3612 : }
3613 0 : return m_sTableName;
3614 : }
3615 :
3616 8 : void SwXTextTable::setName(const OUString& rName) throw( uno::RuntimeException, std::exception )
3617 : {
3618 8 : SolarMutexGuard aGuard;
3619 8 : SwFrmFmt* pFmt = GetFrmFmt();
3620 20 : if((!pFmt && !bIsDescriptor) ||
3621 16 : rName.isEmpty() ||
3622 24 : rName.indexOf('.')>=0 ||
3623 8 : rName.indexOf(' ')>=0 )
3624 0 : throw uno::RuntimeException();
3625 :
3626 8 : if(pFmt)
3627 : {
3628 4 : const OUString aOldName( pFmt->GetName() );
3629 : SwFrmFmt* pTmpFmt;
3630 4 : const SwFrmFmts* pTbl = pFmt->GetDoc()->GetTblFrmFmts();
3631 12 : for( size_t i = pTbl->size(); i; )
3632 24 : if( !( pTmpFmt = (*pTbl)[ --i ] )->IsDefault() &&
3633 24 : pTmpFmt->GetName() == rName &&
3634 0 : pFmt->GetDoc()->IsUsed( *pTmpFmt ))
3635 : {
3636 0 : throw uno::RuntimeException();
3637 : }
3638 :
3639 4 : pFmt->SetName( rName );
3640 :
3641 : SwStartNode *pStNd;
3642 8 : SwNodeIndex aIdx( *pFmt->GetDoc()->GetNodes().GetEndOfAutotext().StartOfSectionNode(), 1 );
3643 8 : while ( 0 != (pStNd = aIdx.GetNode().GetStartNode()) )
3644 : {
3645 0 : ++aIdx;
3646 0 : SwNode *const pNd = & aIdx.GetNode();
3647 0 : if ( pNd->IsOLENode() &&
3648 0 : aOldName == ((SwOLENode*)pNd)->GetChartTblName() )
3649 : {
3650 0 : ((SwOLENode*)pNd)->SetChartTblName( rName );
3651 :
3652 0 : ((SwOLENode*)pNd)->GetOLEObj();
3653 :
3654 0 : SwTable* pTable = SwTable::FindTable( pFmt );
3655 : //TL_CHART2: chart needs to be notfied about name changes
3656 0 : pFmt->GetDoc()->UpdateCharts( pTable->GetFrmFmt()->GetName() );
3657 : }
3658 0 : aIdx.Assign( *pStNd->EndOfSectionNode(), + 1 );
3659 : }
3660 8 : pFmt->GetDoc()->getIDocumentState().SetModified();
3661 : }
3662 : else
3663 4 : m_sTableName = rName;
3664 8 : }
3665 :
3666 30 : sal_uInt16 SwXTextTable::getRowCount(void)
3667 : {
3668 30 : SolarMutexGuard aGuard;
3669 30 : sal_uInt16 nRet = 0;
3670 30 : SwFrmFmt* pFmt = GetFrmFmt();
3671 30 : if(pFmt)
3672 : {
3673 30 : SwTable* pTable = SwTable::FindTable( pFmt );
3674 30 : if(!pTable->IsTblComplex())
3675 : {
3676 30 : nRet = pTable->GetTabLines().size();
3677 : }
3678 : }
3679 30 : return nRet;
3680 : }
3681 :
3682 30 : sal_uInt16 SwXTextTable::getColumnCount(void)
3683 : {
3684 30 : SolarMutexGuard aGuard;
3685 30 : SwFrmFmt* pFmt = GetFrmFmt();
3686 30 : sal_uInt16 nRet = 0;
3687 30 : if(pFmt)
3688 : {
3689 30 : SwTable* pTable = SwTable::FindTable( pFmt );
3690 30 : if(!pTable->IsTblComplex())
3691 : {
3692 30 : SwTableLines& rLines = pTable->GetTabLines();
3693 30 : SwTableLine* pLine = rLines.front();
3694 30 : nRet = pLine->GetTabBoxes().size();
3695 : }
3696 : }
3697 30 : return nRet;
3698 : }
3699 :
3700 6695 : void SwXTextTable::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
3701 : {
3702 6776 : if(pOld && pOld->Which() == RES_REMOVE_UNO_OBJECT &&
3703 81 : (void*)GetRegisteredIn() == ((SwPtrMsgPoolItem *)pOld)->pObject )
3704 81 : ((SwModify*)GetRegisteredIn())->Remove(this);
3705 : else
3706 6614 : ClientModify(this, pOld, pNew);
3707 6695 : if(!GetRegisteredIn())
3708 : {
3709 81 : uno::Reference<uno::XInterface> const xThis(m_pImpl->m_wThis);
3710 81 : if (!xThis.is())
3711 : { // fdo#72695: if UNO object is already dead, don't revive it with event
3712 6695 : return;
3713 : }
3714 162 : lang::EventObject const ev(xThis);
3715 162 : m_pImpl->m_Listeners.disposeAndClear(ev);
3716 : }
3717 : else
3718 : {
3719 6614 : lcl_SendChartEvent(*this, m_pImpl->m_Listeners);
3720 : }
3721 : }
3722 :
3723 0 : OUString SAL_CALL SwXTextTable::getImplementationName(void) throw( uno::RuntimeException, std::exception )
3724 : {
3725 0 : return OUString("SwXTextTable");
3726 : }
3727 :
3728 64 : sal_Bool SwXTextTable::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
3729 : {
3730 64 : return cppu::supportsService(this, rServiceName);
3731 : }
3732 :
3733 64 : uno::Sequence< OUString > SwXTextTable::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
3734 : {
3735 64 : uno::Sequence< OUString > aRet(4);
3736 64 : OUString* pArr = aRet.getArray();
3737 64 : pArr[0] = "com.sun.star.document.LinkTarget";
3738 64 : pArr[1] = "com.sun.star.text.TextTable";
3739 64 : pArr[2] = "com.sun.star.text.TextContent";
3740 64 : pArr[2] = "com.sun.star.text.TextSortable";
3741 64 : return aRet;
3742 : }
3743 :
3744 : namespace
3745 : {
3746 : class theSwXCellRangeUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXCellRangeUnoTunnelId > {};
3747 : }
3748 :
3749 0 : const uno::Sequence< sal_Int8 > & SwXCellRange::getUnoTunnelId()
3750 : {
3751 0 : return theSwXCellRangeUnoTunnelId::get().getSeq();
3752 : }
3753 :
3754 0 : sal_Int64 SAL_CALL SwXCellRange::getSomething( const uno::Sequence< sal_Int8 >& rId )
3755 : throw(uno::RuntimeException, std::exception)
3756 : {
3757 0 : if( rId.getLength() == 16
3758 0 : && 0 == memcmp( getUnoTunnelId().getConstArray(),
3759 0 : rId.getConstArray(), 16 ) )
3760 : {
3761 0 : return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
3762 : }
3763 0 : return 0;
3764 : }
3765 :
3766 888 : TYPEINIT1(SwXCellRange, SwClient);
3767 :
3768 6 : OUString SwXCellRange::getImplementationName(void) throw( uno::RuntimeException, std::exception )
3769 : {
3770 6 : return OUString("SwXCellRange");
3771 : }
3772 :
3773 10 : sal_Bool SwXCellRange::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
3774 : {
3775 10 : return cppu::supportsService(this, rServiceName);
3776 : }
3777 :
3778 10 : uno::Sequence< OUString > SwXCellRange::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
3779 : {
3780 10 : uno::Sequence< OUString > aRet(7);
3781 10 : OUString* pArray = aRet.getArray();
3782 10 : pArray[0] = "com.sun.star.text.CellRange";
3783 10 : pArray[1] = "com.sun.star.style.CharacterProperties";
3784 10 : pArray[2] = "com.sun.star.style.CharacterPropertiesAsian";
3785 10 : pArray[3] = "com.sun.star.style.CharacterPropertiesComplex";
3786 10 : pArray[4] = "com.sun.star.style.ParagraphProperties";
3787 10 : pArray[5] = "com.sun.star.style.ParagraphPropertiesAsian";
3788 10 : pArray[6] = "com.sun.star.style.ParagraphPropertiesComplex";
3789 10 : return aRet;
3790 : }
3791 :
3792 14 : SwXCellRange::SwXCellRange(SwUnoCrsr* pCrsr, SwFrmFmt& rFrmFmt,
3793 : SwRangeDescriptor& rDesc)
3794 : : SwClient(&rFrmFmt)
3795 : , aCursorDepend(this, pCrsr)
3796 : , m_ChartListeners(m_Mutex)
3797 : ,
3798 : aRgDesc(rDesc),
3799 14 : m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TABLE_RANGE)),
3800 : pTblCrsr(pCrsr),
3801 : bFirstRowAsLabel(false),
3802 28 : bFirstColumnAsLabel(false)
3803 : {
3804 14 : aRgDesc.Normalize();
3805 14 : }
3806 :
3807 42 : SwXCellRange::~SwXCellRange()
3808 : {
3809 14 : SolarMutexGuard aGuard;
3810 14 : delete pTblCrsr;
3811 28 : }
3812 :
3813 124 : uno::Reference< table::XCell > SwXCellRange::getCellByPosition(sal_Int32 nColumn, sal_Int32 nRow)
3814 : throw( uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception )
3815 : {
3816 124 : SolarMutexGuard aGuard;
3817 124 : uno::Reference< table::XCell > aRet;
3818 124 : SwFrmFmt* pFmt = GetFrmFmt();
3819 124 : if(pFmt)
3820 : {
3821 368 : if(nColumn >= 0 && nRow >= 0 &&
3822 368 : getColumnCount() > nColumn && getRowCount() > nRow )
3823 : {
3824 : SwXCell* pXCell = lcl_CreateXCell(pFmt,
3825 122 : aRgDesc.nLeft + nColumn, aRgDesc.nTop + nRow);
3826 122 : if(pXCell)
3827 122 : aRet = pXCell;
3828 : }
3829 : }
3830 124 : if(!aRet.is())
3831 2 : throw lang::IndexOutOfBoundsException();
3832 124 : return aRet;
3833 : }
3834 :
3835 6 : uno::Reference< table::XCellRange > SwXCellRange::getCellRangeByPosition(
3836 : sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom)
3837 : throw (uno::RuntimeException, lang::IndexOutOfBoundsException,
3838 : std::exception)
3839 : {
3840 6 : SolarMutexGuard aGuard;
3841 6 : uno::Reference< table::XCellRange > aRet;
3842 6 : SwFrmFmt* pFmt = GetFrmFmt();
3843 12 : if(pFmt && getColumnCount() > nRight && getRowCount() > nBottom &&
3844 6 : nLeft <= nRight && nTop <= nBottom
3845 12 : && nLeft >= 0 && nRight >= 0 && nTop >= 0 && nBottom >= 0 )
3846 : {
3847 4 : SwTable* pTable = SwTable::FindTable( pFmt );
3848 4 : if(!pTable->IsTblComplex())
3849 : {
3850 : SwRangeDescriptor aNewDesc;
3851 4 : aNewDesc.nTop = nTop + aRgDesc.nTop;
3852 4 : aNewDesc.nBottom = nBottom + aRgDesc.nTop;
3853 4 : aNewDesc.nLeft = nLeft + aRgDesc.nLeft;
3854 4 : aNewDesc.nRight = nRight + aRgDesc.nLeft;
3855 4 : aNewDesc.Normalize();
3856 4 : const OUString sTLName = sw_GetCellName(aNewDesc.nLeft, aNewDesc.nTop);
3857 8 : const OUString sBRName = sw_GetCellName(aNewDesc.nRight, aNewDesc.nBottom);
3858 4 : const SwTableBox* pTLBox = pTable->GetTblBox( sTLName );
3859 4 : if(pTLBox)
3860 : {
3861 : // invalidate all actions
3862 4 : UnoActionRemoveContext aRemoveContext(pFmt->GetDoc());
3863 4 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
3864 8 : SwPosition aPos(*pSttNd);
3865 : // set cursor in the upper-left cell of the range
3866 4 : SwUnoCrsr* pUnoCrsr = pFmt->GetDoc()->CreateUnoCrsr(aPos, true);
3867 4 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
3868 4 : pUnoCrsr->SetRemainInSection( false );
3869 4 : const SwTableBox* pBRBox = pTable->GetTblBox( sBRName );
3870 4 : if(pBRBox)
3871 : {
3872 4 : pUnoCrsr->SetMark();
3873 4 : pUnoCrsr->GetPoint()->nNode = *pBRBox->GetSttNd();
3874 4 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
3875 4 : SwUnoTableCrsr* pCrsr = dynamic_cast<SwUnoTableCrsr*>(pUnoCrsr);
3876 4 : pCrsr->MakeBoxSels();
3877 : // pUnoCrsr will be provided and will not be deleted
3878 4 : SwXCellRange* pCellRange = new SwXCellRange(pUnoCrsr, *pFmt, aNewDesc);
3879 4 : aRet = pCellRange;
3880 : }
3881 : else
3882 4 : delete pUnoCrsr;
3883 4 : }
3884 : }
3885 : }
3886 6 : if(!aRet.is())
3887 2 : throw lang::IndexOutOfBoundsException();
3888 6 : return aRet;
3889 : }
3890 :
3891 2 : uno::Reference< table::XCellRange > SwXCellRange::getCellRangeByName(const OUString& rRange)
3892 : throw( uno::RuntimeException, std::exception )
3893 : {
3894 2 : SolarMutexGuard aGuard;
3895 2 : sal_Int32 nPos = 0;
3896 4 : const OUString sTLName(rRange.getToken(0, ':', nPos));
3897 4 : const OUString sBRName(rRange.getToken(0, ':', nPos));
3898 2 : if(sTLName.isEmpty() || sBRName.isEmpty())
3899 0 : throw uno::RuntimeException();
3900 : SwRangeDescriptor aDesc;
3901 2 : aDesc.nTop = aDesc.nLeft = aDesc.nBottom = aDesc.nRight = -1;
3902 2 : sw_GetCellPosition( sTLName, aDesc.nLeft, aDesc.nTop );
3903 2 : sw_GetCellPosition( sBRName, aDesc.nRight, aDesc.nBottom );
3904 2 : aDesc.Normalize();
3905 : return getCellRangeByPosition(aDesc.nLeft - aRgDesc.nLeft, aDesc.nTop - aRgDesc.nTop,
3906 4 : aDesc.nRight - aRgDesc.nLeft, aDesc.nBottom - aRgDesc.nTop);
3907 : }
3908 :
3909 310 : uno::Reference< beans::XPropertySetInfo > SwXCellRange::getPropertySetInfo(void) throw( uno::RuntimeException, std::exception )
3910 : {
3911 310 : static uno::Reference< beans::XPropertySetInfo > xRef = m_pPropSet->getPropertySetInfo();
3912 310 : return xRef;
3913 : }
3914 :
3915 146 : void SwXCellRange::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
3916 : throw (beans::UnknownPropertyException,
3917 : beans::PropertyVetoException,
3918 : lang::IllegalArgumentException,
3919 : lang::WrappedTargetException,
3920 : uno::RuntimeException,
3921 : std::exception)
3922 : {
3923 146 : SolarMutexGuard aGuard;
3924 146 : SwFrmFmt* pFmt = GetFrmFmt();
3925 146 : if(pFmt)
3926 : {
3927 : const SfxItemPropertySimpleEntry* pEntry =
3928 146 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
3929 146 : if(pEntry)
3930 : {
3931 146 : if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
3932 0 : throw beans::PropertyVetoException("Property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
3933 :
3934 146 : SwDoc* pDoc = pTblCrsr->GetDoc();
3935 : {
3936 : // remove actions to enable box selection
3937 146 : UnoActionRemoveContext aRemoveContext(pDoc);
3938 : }
3939 146 : SwUnoTableCrsr& rCrsr = dynamic_cast<SwUnoTableCrsr&>(*pTblCrsr);
3940 146 : rCrsr.MakeBoxSels();
3941 146 : switch(pEntry->nWID )
3942 : {
3943 : case FN_UNO_TABLE_CELL_BACKGROUND:
3944 : {
3945 0 : SvxBrushItem aBrush( RES_BACKGROUND );
3946 0 : pDoc->GetBoxAttr( *pTblCrsr, aBrush );
3947 0 : ((SfxPoolItem&)aBrush).PutValue(aValue, pEntry->nMemberId);
3948 0 : pDoc->SetBoxAttr( *pTblCrsr, aBrush );
3949 :
3950 : }
3951 0 : break;
3952 : case RES_BOX :
3953 : {
3954 0 : SfxItemSet aSet(pDoc->GetAttrPool(),
3955 : RES_BOX, RES_BOX,
3956 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
3957 0 : 0);
3958 0 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
3959 0 : aBoxInfo.SetValid(0xff, false);
3960 0 : sal_uInt8 nValid = 0;
3961 0 : switch(pEntry->nMemberId & ~CONVERT_TWIPS)
3962 : {
3963 0 : case LEFT_BORDER : nValid = VALID_LEFT; break;
3964 0 : case RIGHT_BORDER: nValid = VALID_RIGHT; break;
3965 0 : case TOP_BORDER : nValid = VALID_TOP; break;
3966 0 : case BOTTOM_BORDER: nValid = VALID_BOTTOM; break;
3967 : case LEFT_BORDER_DISTANCE :
3968 : case RIGHT_BORDER_DISTANCE:
3969 : case TOP_BORDER_DISTANCE :
3970 : case BOTTOM_BORDER_DISTANCE:
3971 0 : nValid = VALID_DISTANCE;
3972 0 : break;
3973 : }
3974 0 : aBoxInfo.SetValid(nValid, true);
3975 :
3976 0 : aSet.Put(aBoxInfo);
3977 0 : pDoc->GetTabBorders(rCrsr, aSet);
3978 :
3979 0 : aSet.Put(aBoxInfo);
3980 0 : SvxBoxItem aBoxItem((const SvxBoxItem&)aSet.Get(RES_BOX));
3981 0 : ((SfxPoolItem&)aBoxItem).PutValue(aValue, pEntry->nMemberId);
3982 0 : aSet.Put(aBoxItem);
3983 0 : pDoc->SetTabBorders( *pTblCrsr, aSet );
3984 : }
3985 0 : break;
3986 : case RES_BOXATR_FORMAT:
3987 : {
3988 0 : SfxUInt32Item aNumberFormat(RES_BOXATR_FORMAT);
3989 0 : ((SfxPoolItem&)aNumberFormat).PutValue(aValue, 0);
3990 0 : pDoc->SetBoxAttr(rCrsr, aNumberFormat);
3991 : }
3992 0 : break;
3993 : case FN_UNO_RANGE_ROW_LABEL:
3994 : {
3995 0 : bool bTmp = *(sal_Bool*)aValue.getValue();
3996 0 : if(bFirstRowAsLabel != bTmp)
3997 : {
3998 0 : lcl_SendChartEvent(*this, m_ChartListeners);
3999 0 : bFirstRowAsLabel = bTmp;
4000 : }
4001 : }
4002 0 : break;
4003 : case FN_UNO_RANGE_COL_LABEL:
4004 : {
4005 0 : bool bTmp = *(sal_Bool*)aValue.getValue();
4006 0 : if(bFirstColumnAsLabel != bTmp)
4007 : {
4008 0 : lcl_SendChartEvent(*this, m_ChartListeners);
4009 0 : bFirstColumnAsLabel = bTmp;
4010 : }
4011 : }
4012 0 : break;
4013 : default:
4014 : {
4015 146 : SfxItemSet aItemSet( pDoc->GetAttrPool(), pEntry->nWID, pEntry->nWID );
4016 146 : SwUnoCursorHelper::GetCrsrAttr(rCrsr.GetSelRing(),
4017 146 : aItemSet);
4018 :
4019 146 : if (!SwUnoCursorHelper::SetCursorPropertyValue(
4020 146 : *pEntry, aValue, rCrsr.GetSelRing(), aItemSet))
4021 : {
4022 144 : m_pPropSet->setPropertyValue(*pEntry, aValue, aItemSet);
4023 : }
4024 146 : SwUnoCursorHelper::SetCrsrAttr(rCrsr.GetSelRing(),
4025 146 : aItemSet, nsSetAttrMode::SETATTR_DEFAULT, true);
4026 : }
4027 : }
4028 : }
4029 : else
4030 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
4031 146 : }
4032 146 : }
4033 :
4034 298 : uno::Any SwXCellRange::getPropertyValue(const OUString& rPropertyName)
4035 : throw (beans::UnknownPropertyException,
4036 : lang::WrappedTargetException,
4037 : uno::RuntimeException,
4038 : std::exception)
4039 : {
4040 298 : SolarMutexGuard aGuard;
4041 298 : uno::Any aRet;
4042 298 : SwFrmFmt* pFmt = GetFrmFmt();
4043 298 : if(pFmt)
4044 : {
4045 : const SfxItemPropertySimpleEntry* pEntry =
4046 298 : m_pPropSet->getPropertyMap().getByName(rPropertyName);
4047 298 : if(pEntry)
4048 : {
4049 298 : switch(pEntry->nWID )
4050 : {
4051 : case FN_UNO_TABLE_CELL_BACKGROUND:
4052 : {
4053 0 : SvxBrushItem aBrush( RES_BACKGROUND );
4054 0 : if(pTblCrsr->GetDoc()->GetBoxAttr( *pTblCrsr, aBrush ))
4055 0 : aBrush.QueryValue(aRet, pEntry->nMemberId);
4056 :
4057 : }
4058 0 : break;
4059 : case RES_BOX :
4060 : {
4061 0 : SwDoc* pDoc = pTblCrsr->GetDoc();
4062 0 : SfxItemSet aSet(pDoc->GetAttrPool(),
4063 : RES_BOX, RES_BOX,
4064 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
4065 0 : 0);
4066 0 : aSet.Put(SvxBoxInfoItem( SID_ATTR_BORDER_INNER ));
4067 0 : pDoc->GetTabBorders(*pTblCrsr, aSet);
4068 0 : const SvxBoxItem& rBoxItem = ((const SvxBoxItem&)aSet.Get(RES_BOX));
4069 0 : rBoxItem.QueryValue(aRet, pEntry->nMemberId);
4070 : }
4071 0 : break;
4072 : case RES_BOXATR_FORMAT:
4073 : OSL_FAIL("not implemented");
4074 0 : break;
4075 : case FN_UNO_PARA_STYLE:
4076 : {
4077 : SwFmtColl *const pTmpFmt =
4078 0 : SwUnoCursorHelper::GetCurTxtFmtColl(*pTblCrsr, false);
4079 0 : OUString sRet;
4080 0 : if(pFmt)
4081 0 : sRet = pTmpFmt->GetName();
4082 0 : aRet <<= sRet;
4083 : }
4084 0 : break;
4085 : case FN_UNO_RANGE_ROW_LABEL:
4086 : {
4087 0 : sal_Bool bTemp = bFirstRowAsLabel;
4088 0 : aRet.setValue(&bTemp, ::getCppuBooleanType());
4089 : }
4090 0 : break;
4091 : case FN_UNO_RANGE_COL_LABEL:
4092 : {
4093 0 : sal_Bool bTemp = bFirstColumnAsLabel;
4094 0 : aRet.setValue(&bTemp, ::getCppuBooleanType());
4095 : }
4096 0 : break;
4097 : default:
4098 : {
4099 298 : SfxItemSet aSet(pTblCrsr->GetDoc()->GetAttrPool(),
4100 : RES_CHRATR_BEGIN, RES_FRMATR_END -1,
4101 : RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER,
4102 : RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER,
4103 298 : 0L);
4104 : // first look at the attributes of the cursor
4105 298 : SwUnoTableCrsr* pCrsr = dynamic_cast<SwUnoTableCrsr*>(pTblCrsr);
4106 298 : SwUnoCursorHelper::GetCrsrAttr(pCrsr->GetSelRing(), aSet);
4107 298 : m_pPropSet->getPropertyValue(*pEntry, aSet, aRet);
4108 : }
4109 : }
4110 : }
4111 : else
4112 0 : throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
4113 : }
4114 298 : return aRet;
4115 : }
4116 :
4117 0 : void SwXCellRange::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
4118 : {
4119 : OSL_FAIL("not implemented");
4120 0 : }
4121 :
4122 0 : void SwXCellRange::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
4123 : {
4124 : OSL_FAIL("not implemented");
4125 0 : }
4126 :
4127 0 : void SwXCellRange::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
4128 : {
4129 : OSL_FAIL("not implemented");
4130 0 : }
4131 :
4132 0 : void SwXCellRange::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
4133 : {
4134 : OSL_FAIL("not implemented");
4135 0 : }
4136 :
4137 0 : void SwXCellRange::GetDataSequence(
4138 : uno::Sequence< uno::Any > *pAnySeq, //-> first pointer != 0 is used
4139 : uno::Sequence< OUString > *pTxtSeq, //-> as output sequence
4140 : uno::Sequence< double > *pDblSeq, //-> (previous data gets overwritten)
4141 : bool bForceNumberResults ) //-> when 'true' requires to make an
4142 : // extra effort to return a value different
4143 : // from 0 even if the cell is formatted to text
4144 : throw (uno::RuntimeException)
4145 : {
4146 0 : SolarMutexGuard aGuard;
4147 :
4148 : // compare to SwXCellRange::getDataArray (note different return types though)
4149 :
4150 0 : const sal_uInt16 nRowCount = getRowCount();
4151 0 : const sal_uInt16 nColCount = getColumnCount();
4152 :
4153 0 : if(!nRowCount || !nColCount)
4154 : {
4155 0 : uno::RuntimeException aRuntime;
4156 0 : aRuntime.Message = "Table too complex";
4157 0 : throw aRuntime;
4158 : }
4159 :
4160 0 : sal_Int32 nSize = nRowCount * nColCount;
4161 0 : if (pAnySeq)
4162 0 : pAnySeq->realloc( nSize );
4163 0 : else if (pTxtSeq)
4164 0 : pTxtSeq->realloc( nSize );
4165 0 : else if (pDblSeq)
4166 0 : pDblSeq->realloc( nSize );
4167 : else
4168 : {
4169 : OSL_FAIL( "argument missing" );
4170 0 : return;
4171 : }
4172 0 : uno::Any *pAnyData = pAnySeq ? pAnySeq->getArray() : 0;
4173 0 : OUString *pTxtData = pTxtSeq ? pTxtSeq->getArray() : 0;
4174 0 : double *pDblData = pDblSeq ? pDblSeq->getArray() : 0;
4175 :
4176 0 : sal_Int32 nDtaCnt = 0;
4177 0 : SwFrmFmt* pFmt = GetFrmFmt();
4178 0 : if(pFmt)
4179 : {
4180 : double fNan;
4181 0 : ::rtl::math::setNan( & fNan );
4182 :
4183 0 : uno::Reference< table::XCell > xCellRef;
4184 0 : for(sal_uInt16 nRow = 0; nRow < nRowCount; nRow++)
4185 : {
4186 0 : for(sal_uInt16 nCol = 0; nCol < nColCount; nCol++)
4187 : {
4188 : SwXCell * pXCell = lcl_CreateXCell(pFmt,
4189 : aRgDesc.nLeft + nCol,
4190 0 : aRgDesc.nTop + nRow);
4191 : //! keep (additional) reference to object to prevent implicit destruction
4192 : //! in following UNO calls (when object will get referenced)
4193 0 : xCellRef = pXCell;
4194 0 : SwTableBox * pBox = pXCell ? pXCell->GetTblBox() : 0;
4195 0 : if(!pBox)
4196 : {
4197 0 : throw uno::RuntimeException();
4198 : }
4199 : else
4200 : {
4201 0 : if (pAnyData)
4202 : {
4203 : // check if table box value item is set
4204 0 : bool bIsNum = pBox->GetFrmFmt()->GetItemState( RES_BOXATR_VALUE, false ) == SfxItemState::SET;
4205 0 : if (!bIsNum)
4206 0 : pAnyData[nDtaCnt++] <<= lcl_getString(*pXCell);
4207 : else
4208 0 : pAnyData[nDtaCnt++] <<= sw_getValue(*pXCell);
4209 : }
4210 0 : else if (pTxtData)
4211 0 : pTxtData[nDtaCnt++] = lcl_getString(*pXCell);
4212 0 : else if (pDblData)
4213 : {
4214 0 : double fVal = fNan;
4215 0 : if (!bForceNumberResults || table::CellContentType_TEXT != pXCell->getType())
4216 0 : fVal = sw_getValue(*pXCell);
4217 : else
4218 : {
4219 : OSL_ENSURE( table::CellContentType_TEXT == pXCell->getType(),
4220 : "this branch of 'if' is only for text formatted cells" );
4221 :
4222 : // now we'll try to get a useful numerical value
4223 : // from the text in the cell...
4224 :
4225 : sal_uInt32 nFIndex;
4226 0 : SvNumberFormatter* pNumFormatter = pTblCrsr->GetDoc()->GetNumberFormatter();
4227 :
4228 : // look for SwTblBoxNumFormat value in parents as well
4229 : const SfxPoolItem* pItem;
4230 0 : SwFrmFmt *pBoxFmt = pXCell->GetTblBox()->GetFrmFmt();
4231 0 : SfxItemState eState = pBoxFmt->GetAttrSet().GetItemState(RES_BOXATR_FORMAT, true, &pItem);
4232 :
4233 0 : if (eState == SfxItemState::SET)
4234 : {
4235 : // please note that the language of the numberformat
4236 : // is implicitly coded into the below value as well
4237 0 : nFIndex = ((SwTblBoxNumFormat*)pItem)->GetValue();
4238 :
4239 : // since the current value indicates a text format but the call
4240 : // to 'IsNumberFormat' below won't work for text formats
4241 : // we need to get rid of the part that indicates the text format.
4242 : // According to ER this can be done like this:
4243 0 : nFIndex -= (nFIndex % SV_COUNTRY_LANGUAGE_OFFSET);
4244 : }
4245 : else
4246 : {
4247 : // system language is probably not the best possible choice
4248 : // but since we have to guess anyway (because the language of at
4249 : // the text is NOT the one used for the number format!)
4250 : // it is at least conform to to what is used in
4251 : // SwTableShell::Execute when
4252 : // SID_ATTR_NUMBERFORMAT_VALUE is set...
4253 0 : LanguageType eLang = LANGUAGE_SYSTEM;
4254 0 : nFIndex = pNumFormatter->GetStandardIndex( eLang );
4255 : }
4256 :
4257 : double fTmp;
4258 0 : if (pNumFormatter->IsNumberFormat( lcl_getString(*pXCell), nFIndex, fTmp ))
4259 0 : fVal = fTmp;
4260 : }
4261 0 : pDblData[nDtaCnt++] = fVal;
4262 : }
4263 : else {
4264 : OSL_FAIL( "output sequence missing" );
4265 : }
4266 : }
4267 : }
4268 0 : }
4269 : }
4270 : OSL_ENSURE( nDtaCnt == nSize, "size mismatch. Invalid cell range?" );
4271 0 : if (pAnySeq)
4272 0 : pAnySeq->realloc( nDtaCnt );
4273 0 : else if (pTxtSeq)
4274 0 : pTxtSeq->realloc( nDtaCnt );
4275 0 : else if (pDblSeq)
4276 0 : pDblSeq->realloc( nDtaCnt );
4277 : }
4278 :
4279 : ///@see SwXCellRange::getData
4280 : ///@see SwXCellRange::GetDataSequence
4281 4 : uno::Sequence< uno::Sequence< uno::Any > > SAL_CALL SwXCellRange::getDataArray()
4282 : throw (uno::RuntimeException, std::exception)
4283 : {
4284 4 : SolarMutexGuard aGuard;
4285 4 : const sal_uInt16 nRowCount = getRowCount();
4286 4 : const sal_uInt16 nColCount = getColumnCount();
4287 :
4288 4 : if(!nRowCount || !nColCount)
4289 : {
4290 0 : uno::RuntimeException aRuntime;
4291 0 : aRuntime.Message = "Table too complex";
4292 0 : throw aRuntime;
4293 : }
4294 4 : uno::Sequence< uno::Sequence< uno::Any > > aRowSeq(nRowCount);
4295 4 : SwFrmFmt* pFmt = GetFrmFmt();
4296 4 : if(pFmt)
4297 : {
4298 4 : uno::Sequence< uno::Any >* pRowArray = aRowSeq.getArray();
4299 4 : uno::Reference< table::XCell > xCellRef;
4300 24 : for(sal_uInt16 nRow = 0; nRow < nRowCount; nRow++)
4301 : {
4302 20 : uno::Sequence< uno::Any > aColSeq(nColCount);
4303 20 : uno::Any * pColArray = aColSeq.getArray();
4304 100 : for(sal_uInt16 nCol = 0; nCol < nColCount; nCol++)
4305 : {
4306 : SwXCell * pXCell = lcl_CreateXCell(pFmt,
4307 : aRgDesc.nLeft + nCol,
4308 80 : aRgDesc.nTop + nRow);
4309 : //! keep (additional) reference to object to prevent implicit destruction
4310 : //! in following UNO calls (when object will get referenced)
4311 80 : xCellRef = pXCell;
4312 80 : SwTableBox * pBox = pXCell ? pXCell->GetTblBox() : 0;
4313 80 : if(!pBox)
4314 : {
4315 0 : throw uno::RuntimeException();
4316 : }
4317 : else
4318 : {
4319 : // check if table box value item is set
4320 80 : SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
4321 80 : bool bIsNum = pBoxFmt->GetItemState( RES_BOXATR_VALUE, false ) == SfxItemState::SET;
4322 80 : if(!bIsNum)
4323 40 : pColArray[nCol] <<= lcl_getString(*pXCell);
4324 : else
4325 40 : pColArray[nCol] <<= sw_getValue(*pXCell);
4326 : }
4327 : }
4328 20 : pRowArray[nRow] = aColSeq;
4329 24 : }
4330 : }
4331 4 : return aRowSeq;
4332 : }
4333 :
4334 : ///@see SwXCellRange::setData
4335 4 : void SAL_CALL SwXCellRange::setDataArray(
4336 : const uno::Sequence< uno::Sequence< uno::Any > >& rArray )
4337 : throw (uno::RuntimeException, std::exception)
4338 : {
4339 4 : SolarMutexGuard aGuard;
4340 4 : const sal_uInt16 nRowCount = getRowCount();
4341 4 : const sal_uInt16 nColCount = getColumnCount();
4342 4 : if(!nRowCount || !nColCount)
4343 : {
4344 0 : uno::RuntimeException aRuntime;
4345 0 : aRuntime.Message = "Table too complex";
4346 0 : throw aRuntime;
4347 : }
4348 4 : SwFrmFmt* pFmt = GetFrmFmt();
4349 4 : if(pFmt )
4350 : {
4351 4 : if(rArray.getLength() != nRowCount)
4352 : {
4353 0 : throw uno::RuntimeException();
4354 : }
4355 4 : const uno::Sequence< uno::Any >* pRowArray = rArray.getConstArray();
4356 24 : for(sal_uInt16 nRow = 0; nRow < nRowCount; nRow++)
4357 : {
4358 20 : const uno::Sequence< uno::Any >& rColSeq = pRowArray[nRow];
4359 20 : if(rColSeq.getLength() != nColCount)
4360 : {
4361 0 : throw uno::RuntimeException();
4362 : }
4363 20 : const uno::Any * pColArray = rColSeq.getConstArray();
4364 20 : uno::Reference< table::XCell > xCellRef;
4365 100 : for(sal_uInt16 nCol = 0; nCol < nColCount; nCol++)
4366 : {
4367 : SwXCell * pXCell = lcl_CreateXCell(pFmt,
4368 : aRgDesc.nLeft + nCol,
4369 80 : aRgDesc.nTop + nRow);
4370 : //! keep (additional) reference to object to prevent implicit destruction
4371 : //! in following UNO calls (when object will get referenced)
4372 80 : xCellRef = pXCell;
4373 80 : SwTableBox * pBox = pXCell ? pXCell->GetTblBox() : 0;
4374 80 : if(!pBox)
4375 : {
4376 0 : throw uno::RuntimeException();
4377 : }
4378 : else
4379 : {
4380 80 : const uno::Any &rAny = pColArray[nCol];
4381 80 : if (uno::TypeClass_STRING == rAny.getValueTypeClass())
4382 40 : sw_setString( *pXCell, *(OUString *) rAny.getValue() );
4383 : else
4384 : {
4385 40 : double d = 0;
4386 : // #i20067# don't throw exception just do nothing if
4387 : // there is no value set
4388 40 : if( (rAny >>= d) )
4389 40 : sw_setValue( *pXCell, d );
4390 : else
4391 0 : sw_setString( *pXCell, OUString(), true );
4392 : }
4393 : }
4394 : }
4395 20 : }
4396 4 : }
4397 4 : }
4398 :
4399 4 : uno::Sequence< uno::Sequence< double > > SwXCellRange::getData(void) throw( uno::RuntimeException, std::exception )
4400 : {
4401 4 : SolarMutexGuard aGuard;
4402 4 : const sal_uInt16 nRowCount = getRowCount();
4403 4 : const sal_uInt16 nColCount = getColumnCount();
4404 :
4405 4 : if(!nRowCount || !nColCount)
4406 : {
4407 0 : uno::RuntimeException aRuntime;
4408 0 : aRuntime.Message = "Table too complex";
4409 0 : throw aRuntime;
4410 : }
4411 4 : uno::Sequence< uno::Sequence< double > > aRowSeq(bFirstRowAsLabel ? nRowCount - 1 : nRowCount);
4412 4 : SwFrmFmt* pFmt = GetFrmFmt();
4413 4 : if(pFmt)
4414 : {
4415 4 : uno::Sequence< double >* pRowArray = aRowSeq.getArray();
4416 :
4417 4 : const sal_uInt16 nRowStart = bFirstRowAsLabel ? 1 : 0;
4418 24 : for(sal_uInt16 nRow = nRowStart; nRow < nRowCount; nRow++)
4419 : {
4420 20 : uno::Sequence< double > aColSeq(bFirstColumnAsLabel ? nColCount - 1 : nColCount);
4421 20 : double * pArray = aColSeq.getArray();
4422 20 : const sal_uInt16 nColStart = bFirstColumnAsLabel ? 1 : 0;
4423 100 : for(sal_uInt16 nCol = nColStart; nCol < nColCount; nCol++)
4424 : {
4425 80 : uno::Reference< table::XCell > xCell = getCellByPosition(nCol, nRow);
4426 80 : if(!xCell.is())
4427 : {
4428 0 : throw uno::RuntimeException();
4429 : }
4430 80 : pArray[nCol - nColStart] = xCell->getValue();
4431 80 : }
4432 20 : pRowArray[nRow - nRowStart] = aColSeq;
4433 20 : }
4434 : }
4435 4 : return aRowSeq;
4436 : }
4437 :
4438 2 : void SwXCellRange::setData(const uno::Sequence< uno::Sequence< double > >& rData)
4439 : throw( uno::RuntimeException, std::exception )
4440 : {
4441 2 : SolarMutexGuard aGuard;
4442 2 : const sal_uInt16 nRowCount = getRowCount();
4443 2 : const sal_uInt16 nColCount = getColumnCount();
4444 2 : if(!nRowCount || !nColCount)
4445 : {
4446 0 : uno::RuntimeException aRuntime;
4447 0 : aRuntime.Message = "Table too complex";
4448 0 : throw aRuntime;
4449 : }
4450 2 : SwFrmFmt* pFmt = GetFrmFmt();
4451 2 : if(pFmt )
4452 : {
4453 2 : const sal_uInt16 nRowStart = bFirstRowAsLabel ? 1 : 0;
4454 2 : if(rData.getLength() < nRowCount - nRowStart)
4455 : {
4456 0 : throw uno::RuntimeException();
4457 : }
4458 2 : const uno::Sequence< double >* pRowArray = rData.getConstArray();
4459 12 : for(sal_uInt16 nRow = nRowStart; nRow < nRowCount; nRow++)
4460 : {
4461 10 : const uno::Sequence< double >& rColSeq = pRowArray[nRow - nRowStart];
4462 10 : const sal_uInt16 nColStart = bFirstColumnAsLabel ? 1 : 0;
4463 10 : if(rColSeq.getLength() < nColCount - nColStart)
4464 : {
4465 0 : throw uno::RuntimeException();
4466 : }
4467 10 : const double * pColArray = rColSeq.getConstArray();
4468 50 : for(sal_uInt16 nCol = nColStart; nCol < nColCount; nCol++)
4469 : {
4470 40 : uno::Reference< table::XCell > xCell = getCellByPosition(nCol, nRow);
4471 40 : if(!xCell.is())
4472 : {
4473 0 : throw uno::RuntimeException();
4474 : }
4475 40 : xCell->setValue(pColArray[nCol - nColStart]);
4476 40 : }
4477 : }
4478 2 : }
4479 2 : }
4480 :
4481 : ///@see SwXTextTable::getRowDescriptions (TODO: seems to be copy and paste programming here)
4482 4 : uno::Sequence< OUString > SwXCellRange::getRowDescriptions(void)
4483 : throw( uno::RuntimeException, std::exception )
4484 : {
4485 4 : SolarMutexGuard aGuard;
4486 4 : const sal_uInt16 nRowCount = getRowCount();
4487 4 : if(!nRowCount)
4488 : {
4489 0 : uno::RuntimeException aRuntime;
4490 0 : aRuntime.Message = "Table too complex";
4491 0 : throw aRuntime;
4492 : }
4493 4 : uno::Sequence< OUString > aRet(bFirstColumnAsLabel ? nRowCount - 1 : nRowCount);
4494 4 : SwFrmFmt* pFmt = GetFrmFmt();
4495 4 : if(pFmt)
4496 : {
4497 4 : OUString* pArray = aRet.getArray();
4498 4 : if(bFirstColumnAsLabel)
4499 : {
4500 0 : const sal_uInt16 nStart = bFirstRowAsLabel ? 1 : 0;
4501 0 : for(sal_uInt16 i = nStart; i < nRowCount; i++)
4502 : {
4503 0 : uno::Reference< table::XCell > xCell = getCellByPosition(0, i);
4504 0 : if(!xCell.is())
4505 : {
4506 0 : throw uno::RuntimeException();
4507 : }
4508 0 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
4509 0 : pArray[i - nStart] = xText->getString();
4510 0 : }
4511 : }
4512 : else
4513 : {
4514 : OSL_FAIL("Where do these labels come from?");
4515 : }
4516 : }
4517 : else
4518 0 : throw uno::RuntimeException();
4519 4 : return aRet;
4520 : }
4521 :
4522 : ///@see SwXTextTable::setRowDescriptions (TODO: seems to be copy and paste programming here)
4523 0 : void SwXCellRange::setRowDescriptions(const uno::Sequence< OUString >& rRowDesc)
4524 : throw( uno::RuntimeException, std::exception )
4525 : {
4526 0 : SolarMutexGuard aGuard;
4527 0 : SwFrmFmt* pFmt = GetFrmFmt();
4528 0 : if(pFmt)
4529 : {
4530 0 : const sal_uInt16 nRowCount = getRowCount();
4531 0 : if(!nRowCount || rRowDesc.getLength() < (bFirstRowAsLabel ? nRowCount - 1 : nRowCount))
4532 : {
4533 0 : throw uno::RuntimeException();
4534 : }
4535 0 : const OUString* pArray = rRowDesc.getConstArray();
4536 0 : if(bFirstColumnAsLabel)
4537 : {
4538 0 : const sal_uInt16 nStart = bFirstRowAsLabel ? 1 : 0;
4539 0 : for(sal_uInt16 i = nStart; i < nRowCount; i++)
4540 : {
4541 0 : uno::Reference< table::XCell > xCell = getCellByPosition(0, i);
4542 0 : if(!xCell.is())
4543 : {
4544 0 : throw uno::RuntimeException();
4545 : }
4546 0 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
4547 0 : xText->setString(pArray[i - nStart]);
4548 0 : }
4549 : }
4550 : else
4551 : {
4552 : OSL_FAIL("Where to put theses labels?");
4553 : }
4554 0 : }
4555 0 : }
4556 :
4557 : ///@see SwXTextTable::setColumnDescriptions (TODO: seems to be copy and paste programming here)
4558 4 : uno::Sequence< OUString > SwXCellRange::getColumnDescriptions(void)
4559 : throw( uno::RuntimeException, std::exception )
4560 : {
4561 4 : SolarMutexGuard aGuard;
4562 4 : const sal_uInt16 nColCount = getColumnCount();
4563 4 : if(!nColCount)
4564 : {
4565 0 : uno::RuntimeException aRuntime;
4566 0 : aRuntime.Message = "Table too complex";
4567 0 : throw aRuntime;
4568 : }
4569 4 : uno::Sequence< OUString > aRet(bFirstRowAsLabel ? nColCount - 1 : nColCount);
4570 4 : SwFrmFmt* pFmt = GetFrmFmt();
4571 4 : if(pFmt)
4572 : {
4573 4 : OUString* pArray = aRet.getArray();
4574 4 : if(bFirstRowAsLabel)
4575 : {
4576 0 : const sal_uInt16 nStart = bFirstColumnAsLabel ? 1 : 0;
4577 0 : for(sal_uInt16 i = nStart; i < nColCount; i++)
4578 : {
4579 0 : uno::Reference< table::XCell > xCell = getCellByPosition(i, 0);
4580 0 : if(!xCell.is())
4581 : {
4582 0 : throw uno::RuntimeException();
4583 : }
4584 0 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
4585 0 : pArray[i - nStart] = xText->getString();
4586 0 : }
4587 : }
4588 : else
4589 : {
4590 : OSL_FAIL("Where do these labels come from?");
4591 : }
4592 : }
4593 : else
4594 0 : throw uno::RuntimeException();
4595 4 : return aRet;
4596 : }
4597 :
4598 : ///@see SwXTextTable::setColumnDescriptions (TODO: seems to be copy and paste programming here)
4599 0 : void SwXCellRange::setColumnDescriptions(const uno::Sequence< OUString >& ColumnDesc)
4600 : throw( uno::RuntimeException, std::exception )
4601 : {
4602 0 : SolarMutexGuard aGuard;
4603 0 : const sal_uInt16 nColCount = getColumnCount();
4604 0 : SwFrmFmt* pFmt = GetFrmFmt();
4605 0 : if(pFmt)
4606 : {
4607 0 : const OUString* pArray = ColumnDesc.getConstArray();
4608 0 : if(bFirstRowAsLabel && ColumnDesc.getLength() >= nColCount - (bFirstColumnAsLabel ? 1 : 0))
4609 : {
4610 0 : const sal_uInt16 nStart = bFirstColumnAsLabel ? 1 : 0;
4611 0 : for(sal_uInt16 i = nStart; i < nColCount; i++)
4612 : {
4613 0 : uno::Reference< table::XCell > xCell = getCellByPosition(i, 0);
4614 0 : if(!xCell.is())
4615 : {
4616 0 : throw uno::RuntimeException();
4617 : }
4618 0 : uno::Reference< text::XText > xText(xCell, uno::UNO_QUERY);
4619 :
4620 0 : xText->setString(pArray[i - nStart]);
4621 0 : }
4622 : }
4623 : else
4624 : {
4625 : OSL_FAIL("Where to put theses labels?");
4626 : }
4627 0 : }
4628 0 : }
4629 :
4630 0 : void SAL_CALL SwXCellRange::addChartDataChangeEventListener(
4631 : const uno::Reference<chart::XChartDataChangeEventListener> & xListener)
4632 : throw (uno::RuntimeException, std::exception)
4633 : {
4634 : // no need to lock here as m_pImpl is const and container threadsafe
4635 0 : m_ChartListeners.addInterface(xListener);
4636 0 : }
4637 :
4638 0 : void SAL_CALL SwXCellRange::removeChartDataChangeEventListener(
4639 : const uno::Reference<chart::XChartDataChangeEventListener> & xListener)
4640 : throw (uno::RuntimeException, std::exception)
4641 : {
4642 : // no need to lock here as m_pImpl is const and container threadsafe
4643 0 : m_ChartListeners.removeInterface(xListener);
4644 0 : }
4645 :
4646 0 : sal_Bool SwXCellRange::isNotANumber(double /*fNumber*/) throw( uno::RuntimeException, std::exception )
4647 : {
4648 : OSL_FAIL("not implemented");
4649 0 : return sal_False;
4650 : }
4651 :
4652 0 : double SwXCellRange::getNotANumber(void) throw( uno::RuntimeException, std::exception )
4653 : {
4654 : OSL_FAIL("not implemented");
4655 0 : return 0.;
4656 : }
4657 :
4658 0 : uno::Sequence< beans::PropertyValue > SwXCellRange::createSortDescriptor(void) throw( uno::RuntimeException, std::exception )
4659 : {
4660 0 : SolarMutexGuard aGuard;
4661 :
4662 0 : return SwUnoCursorHelper::CreateSortDescriptor(true);
4663 : }
4664 :
4665 0 : void SAL_CALL SwXCellRange::sort(const uno::Sequence< beans::PropertyValue >& rDescriptor)
4666 : throw (uno::RuntimeException,
4667 : std::exception)
4668 : {
4669 0 : SolarMutexGuard aGuard;
4670 0 : SwSortOptions aSortOpt;
4671 0 : SwFrmFmt* pFmt = GetFrmFmt();
4672 0 : if(pFmt &&
4673 0 : SwUnoCursorHelper::ConvertSortProperties(rDescriptor, aSortOpt))
4674 : {
4675 0 : SwUnoTableCrsr& rTableCrsr = dynamic_cast<SwUnoTableCrsr&>(*pTblCrsr);
4676 0 : rTableCrsr.MakeBoxSels();
4677 0 : UnoActionContext aContext( pFmt->GetDoc() );
4678 0 : pFmt->GetDoc()->SortTbl(rTableCrsr.GetSelectedBoxes(), aSortOpt);
4679 0 : }
4680 0 : }
4681 :
4682 146 : sal_uInt16 SwXCellRange::getColumnCount(void)
4683 : {
4684 146 : return static_cast< sal_uInt16 >(aRgDesc.nRight - aRgDesc.nLeft + 1);
4685 : }
4686 :
4687 146 : sal_uInt16 SwXCellRange::getRowCount(void)
4688 : {
4689 146 : return static_cast< sal_uInt16 >(aRgDesc.nBottom - aRgDesc.nTop + 1);
4690 : }
4691 :
4692 0 : const SwUnoCrsr* SwXCellRange::GetTblCrsr() const
4693 : {
4694 0 : const SwUnoCrsr* pRet = 0;
4695 0 : SwFrmFmt* pFmt = GetFrmFmt();
4696 0 : if(pFmt)
4697 0 : pRet = pTblCrsr;
4698 0 : return pRet;
4699 : }
4700 :
4701 14 : void SwXCellRange::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
4702 : {
4703 14 : ClientModify(this, pOld, pNew );
4704 14 : if(!GetRegisteredIn() || !aCursorDepend.GetRegisteredIn())
4705 : {
4706 : /*
4707 : * Not sure if this will cause a memory leak - this pTblCrsr
4708 : * is deleted in SwDoc and segfaults here when deleted again
4709 : * if(!aCursorDepend.GetRegisteredIn())
4710 : delete pTblCrsr;
4711 : */
4712 14 : pTblCrsr = 0;
4713 14 : lang::EventObject const ev(static_cast< ::cppu::OWeakObject&>(*this));
4714 14 : m_ChartListeners.disposeAndClear(ev);
4715 : }
4716 : else
4717 : {
4718 0 : lcl_SendChartEvent(*this, m_ChartListeners);
4719 : }
4720 14 : }
4721 :
4722 : // SwXTableRows
4723 :
4724 0 : OUString SwXTableRows::getImplementationName(void) throw( uno::RuntimeException, std::exception )
4725 : {
4726 0 : return OUString("SwXTableRows");
4727 : }
4728 :
4729 0 : sal_Bool SwXTableRows::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
4730 : {
4731 0 : return cppu::supportsService(this, rServiceName);
4732 : }
4733 :
4734 0 : uno::Sequence< OUString > SwXTableRows::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
4735 : {
4736 0 : uno::Sequence< OUString > aRet(1);
4737 0 : OUString* pArray = aRet.getArray();
4738 0 : pArray[0] = "com.sun.star.text.TableRows";
4739 0 : return aRet;
4740 : }
4741 63288 : TYPEINIT1(SwXTableRows, SwClient);
4742 :
4743 1098 : SwXTableRows::SwXTableRows(SwFrmFmt& rFrmFmt) :
4744 1098 : SwClient(&rFrmFmt)
4745 : {
4746 1098 : }
4747 :
4748 2196 : SwXTableRows::~SwXTableRows()
4749 : {
4750 2196 : }
4751 :
4752 6432 : sal_Int32 SwXTableRows::getCount(void) throw( uno::RuntimeException, std::exception )
4753 : {
4754 6432 : SolarMutexGuard aGuard;
4755 6432 : sal_Int32 nRet = 0;
4756 6432 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4757 6432 : if(!pFrmFmt)
4758 0 : throw uno::RuntimeException();
4759 : else
4760 : {
4761 6432 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
4762 6432 : nRet = pTable->GetTabLines().size();
4763 : }
4764 6432 : return nRet;
4765 : }
4766 :
4767 : ///@see SwXCell::CreateXCell (TODO: seems to be copy and paste programming here)
4768 5410 : uno::Any SwXTableRows::getByIndex(sal_Int32 nIndex)
4769 : throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
4770 : {
4771 5410 : SolarMutexGuard aGuard;
4772 5410 : uno::Any aRet;
4773 5410 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4774 5410 : if(!pFrmFmt || nIndex < 0 )
4775 0 : throw lang::IndexOutOfBoundsException();
4776 : else
4777 : {
4778 5410 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
4779 5410 : if( pTable->GetTabLines().size() > static_cast<size_t>(nIndex))
4780 : {
4781 5408 : SwTableLine* pLine = pTable->GetTabLines()[nIndex];
4782 5408 : SwIterator<SwXTextTableRow,SwFmt> aIter( *pFrmFmt );
4783 5408 : SwXTextTableRow* pXRow = aIter.First();
4784 10820 : while( pXRow )
4785 : {
4786 : // is there already a proper cell?
4787 6 : if(pXRow->GetTblRow() == pLine)
4788 2 : break;
4789 4 : pXRow = aIter.Next();
4790 : }
4791 : // otherwise create it
4792 5408 : if(!pXRow)
4793 5406 : pXRow = new SwXTextTableRow(pFrmFmt, pLine);
4794 : uno::Reference< beans::XPropertySet > xRet =
4795 10816 : (beans::XPropertySet*)pXRow;
4796 10816 : aRet.setValue(&xRet, cppu::UnoType<beans::XPropertySet>::get());
4797 : }
4798 : else
4799 2 : throw lang::IndexOutOfBoundsException();
4800 : }
4801 5410 : return aRet;
4802 : }
4803 :
4804 2 : uno::Type SAL_CALL SwXTableRows::getElementType(void) throw( uno::RuntimeException, std::exception )
4805 : {
4806 2 : return cppu::UnoType<beans::XPropertySet>::get();
4807 : }
4808 :
4809 2 : sal_Bool SwXTableRows::hasElements(void) throw( uno::RuntimeException, std::exception )
4810 : {
4811 2 : SolarMutexGuard aGuard;
4812 2 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4813 2 : if(!pFrmFmt)
4814 0 : throw uno::RuntimeException();
4815 : // a table always has rows
4816 2 : return sal_True;
4817 : }
4818 :
4819 4 : void SwXTableRows::insertByIndex(sal_Int32 nIndex, sal_Int32 nCount)
4820 : throw (uno::RuntimeException, std::exception)
4821 : {
4822 4 : SolarMutexGuard aGuard;
4823 4 : if (nCount == 0)
4824 2 : return;
4825 4 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4826 4 : if(!pFrmFmt)
4827 0 : throw uno::RuntimeException();
4828 : else
4829 : {
4830 4 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
4831 4 : if(!pTable->IsTblComplex())
4832 : {
4833 4 : const size_t nRowCount = pTable->GetTabLines().size();
4834 4 : if (nCount <= 0 || !(0 <= nIndex && static_cast<size_t>(nIndex) <= nRowCount))
4835 : {
4836 2 : uno::RuntimeException aExcept;
4837 2 : aExcept.Message = "Illegal arguments";
4838 2 : throw aExcept;
4839 : }
4840 :
4841 2 : const OUString sTLName = sw_GetCellName(0, nIndex);
4842 2 : const SwTableBox* pTLBox = pTable->GetTblBox( sTLName );
4843 2 : bool bAppend = false;
4844 2 : if(!pTLBox)
4845 : {
4846 0 : bAppend = true;
4847 : // to append at the end the cursor must be in the last line
4848 0 : SwTableLines& rLines = pTable->GetTabLines();
4849 0 : SwTableLine* pLine = rLines.back();
4850 0 : SwTableBoxes& rBoxes = pLine->GetTabBoxes();
4851 0 : pTLBox = rBoxes.front();
4852 : }
4853 2 : if(pTLBox)
4854 : {
4855 2 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
4856 2 : SwPosition aPos(*pSttNd);
4857 : // set cursor to the upper-left cell of the range
4858 4 : UnoActionContext aAction(pFrmFmt->GetDoc());
4859 2 : SwUnoCrsr* pUnoCrsr = pFrmFmt->GetDoc()->CreateUnoCrsr(aPos, true);
4860 2 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
4861 :
4862 : {
4863 : // remove actions
4864 2 : UnoActionRemoveContext aRemoveContext(pUnoCrsr->GetDoc());
4865 : }
4866 :
4867 2 : pFrmFmt->GetDoc()->InsertRow(*pUnoCrsr, (sal_uInt16)nCount, bAppend);
4868 4 : delete pUnoCrsr;
4869 2 : }
4870 : }
4871 4 : }
4872 : }
4873 :
4874 4 : void SwXTableRows::removeByIndex(sal_Int32 nIndex, sal_Int32 nCount)
4875 : throw (uno::RuntimeException, std::exception)
4876 : {
4877 4 : SolarMutexGuard aGuard;
4878 4 : if (nCount == 0)
4879 2 : return;
4880 4 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4881 4 : if(!pFrmFmt || nIndex < 0 || nCount <=0 )
4882 2 : throw uno::RuntimeException();
4883 : else
4884 : {
4885 2 : bool bSuccess = false;
4886 2 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
4887 2 : if(!pTable->IsTblComplex())
4888 : {
4889 2 : OUString sTLName = sw_GetCellName(0, nIndex);
4890 2 : const SwTableBox* pTLBox = pTable->GetTblBox( sTLName );
4891 2 : if(pTLBox)
4892 : {
4893 : {
4894 : // invalidate all actions
4895 2 : UnoActionRemoveContext aRemoveContext(pFrmFmt->GetDoc());
4896 : }
4897 2 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
4898 2 : SwPosition aPos(*pSttNd);
4899 : // set cursor to the upper-left cell of the range
4900 2 : SwUnoCrsr* pUnoCrsr = pFrmFmt->GetDoc()->CreateUnoCrsr(aPos, true);
4901 2 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
4902 2 : pUnoCrsr->SetRemainInSection( false );
4903 4 : const OUString sBLName = sw_GetCellName(0, nIndex + nCount - 1);
4904 2 : const SwTableBox* pBLBox = pTable->GetTblBox( sBLName );
4905 2 : if(pBLBox)
4906 : {
4907 2 : pUnoCrsr->SetMark();
4908 2 : pUnoCrsr->GetPoint()->nNode = *pBLBox->GetSttNd();
4909 2 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
4910 : SwUnoTableCrsr* pCrsr =
4911 2 : dynamic_cast<SwUnoTableCrsr*>(pUnoCrsr);
4912 2 : pCrsr->MakeBoxSels();
4913 : { // these braces are important
4914 2 : UnoActionContext aAction(pFrmFmt->GetDoc());
4915 2 : pFrmFmt->GetDoc()->DeleteRow(*pUnoCrsr);
4916 2 : delete pUnoCrsr;
4917 2 : bSuccess = true;
4918 : }
4919 : {
4920 : // invalidate all actions
4921 2 : UnoActionRemoveContext aRemoveContext(pFrmFmt->GetDoc());
4922 : }
4923 2 : }
4924 2 : }
4925 : }
4926 2 : if(!bSuccess)
4927 : {
4928 0 : uno::RuntimeException aExcept;
4929 0 : aExcept.Message = "Illegal arguments";
4930 0 : throw aExcept;
4931 : }
4932 4 : }
4933 : }
4934 :
4935 6 : void SwXTableRows::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
4936 : {
4937 6 : ClientModify(this, pOld, pNew);
4938 6 : }
4939 :
4940 : // SwXTableColumns
4941 :
4942 0 : OUString SwXTableColumns::getImplementationName(void) throw( uno::RuntimeException, std::exception )
4943 : {
4944 0 : return OUString("SwXTableColumns");
4945 : }
4946 :
4947 0 : sal_Bool SwXTableColumns::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
4948 : {
4949 0 : return cppu::supportsService(this, rServiceName);
4950 : }
4951 :
4952 0 : uno::Sequence< OUString > SwXTableColumns::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
4953 : {
4954 0 : uno::Sequence< OUString > aRet(1);
4955 0 : OUString* pArray = aRet.getArray();
4956 0 : pArray[0] = "com.sun.star.text.TableColumns";
4957 0 : return aRet;
4958 : }
4959 :
4960 34 : TYPEINIT1(SwXTableColumns, SwClient);
4961 :
4962 8 : SwXTableColumns::SwXTableColumns(SwFrmFmt& rFrmFmt) :
4963 8 : SwClient(&rFrmFmt)
4964 : {
4965 8 : }
4966 :
4967 16 : SwXTableColumns::~SwXTableColumns()
4968 : {
4969 16 : }
4970 :
4971 8 : sal_Int32 SwXTableColumns::getCount(void) throw( uno::RuntimeException, std::exception )
4972 : {
4973 8 : SolarMutexGuard aGuard;
4974 8 : sal_Int32 nRet = 0;
4975 8 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4976 8 : if(!pFrmFmt)
4977 0 : throw uno::RuntimeException();
4978 : else
4979 : {
4980 8 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
4981 8 : if(!pTable->IsTblComplex())
4982 : {
4983 8 : SwTableLines& rLines = pTable->GetTabLines();
4984 8 : SwTableLine* pLine = rLines.front();
4985 8 : nRet = pLine->GetTabBoxes().size();
4986 : }
4987 : }
4988 8 : return nRet;
4989 : }
4990 :
4991 8 : uno::Any SwXTableColumns::getByIndex(sal_Int32 nIndex)
4992 : throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
4993 : {
4994 8 : SolarMutexGuard aGuard;
4995 16 : uno::Reference< uno::XInterface > xRet;
4996 8 : SwFrmFmt* pFrmFmt = GetFrmFmt();
4997 8 : if(!pFrmFmt)
4998 0 : throw uno::RuntimeException();
4999 : else
5000 : {
5001 8 : size_t nCount = 0;
5002 8 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
5003 8 : if(!pTable->IsTblComplex())
5004 : {
5005 8 : SwTableLines& rLines = pTable->GetTabLines();
5006 8 : SwTableLine* pLine = rLines.front();
5007 8 : nCount = pLine->GetTabBoxes().size();
5008 : }
5009 8 : if(nIndex < 0 || nCount <= static_cast<size_t>(nIndex))
5010 2 : throw lang::IndexOutOfBoundsException();
5011 6 : xRet = uno::Reference<uno::XInterface>(); //!! writer tables do not have columns !!
5012 : }
5013 14 : return uno::Any(&xRet, cppu::UnoType<uno::XInterface>::get());
5014 : }
5015 :
5016 2 : uno::Type SAL_CALL SwXTableColumns::getElementType(void) throw( uno::RuntimeException, std::exception )
5017 : {
5018 2 : return cppu::UnoType<uno::XInterface>::get();
5019 : }
5020 :
5021 2 : sal_Bool SwXTableColumns::hasElements(void) throw( uno::RuntimeException, std::exception )
5022 : {
5023 2 : SolarMutexGuard aGuard;
5024 2 : SwFrmFmt* pFrmFmt = GetFrmFmt();
5025 2 : if(!pFrmFmt)
5026 0 : throw uno::RuntimeException();
5027 2 : return sal_True;
5028 : }
5029 :
5030 : ///@see SwXTableRows::insertByIndex (TODO: seems to be copy and paste programming here)
5031 0 : void SwXTableColumns::insertByIndex(sal_Int32 nIndex, sal_Int32 nCount)
5032 : throw (uno::RuntimeException, std::exception)
5033 : {
5034 0 : SolarMutexGuard aGuard;
5035 0 : if (nCount == 0)
5036 0 : return;
5037 0 : SwFrmFmt* pFrmFmt = GetFrmFmt();
5038 0 : if(!pFrmFmt)
5039 0 : throw uno::RuntimeException();
5040 : else
5041 : {
5042 0 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
5043 0 : if(!pTable->IsTblComplex())
5044 : {
5045 0 : SwTableLines& rLines = pTable->GetTabLines();
5046 0 : SwTableLine* pLine = rLines.front();
5047 0 : const size_t nColCount = pLine->GetTabBoxes().size();
5048 0 : if (nCount <= 0 || !(0 <= nIndex && static_cast<size_t>(nIndex) <= nColCount))
5049 : {
5050 0 : uno::RuntimeException aExcept;
5051 0 : aExcept.Message = "Illegal arguments";
5052 0 : throw aExcept;
5053 : }
5054 :
5055 0 : const OUString sTLName = sw_GetCellName(nIndex, 0);
5056 0 : const SwTableBox* pTLBox = pTable->GetTblBox( sTLName );
5057 0 : bool bAppend = false;
5058 0 : if(!pTLBox)
5059 : {
5060 0 : bAppend = true;
5061 : // to append at the end the cursor must be in the last line
5062 0 : SwTableBoxes& rBoxes = pLine->GetTabBoxes();
5063 0 : pTLBox = rBoxes.back();
5064 : }
5065 0 : if(pTLBox)
5066 : {
5067 0 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
5068 0 : SwPosition aPos(*pSttNd);
5069 0 : UnoActionContext aAction(pFrmFmt->GetDoc());
5070 0 : SwUnoCrsr* pUnoCrsr = pFrmFmt->GetDoc()->CreateUnoCrsr(aPos, true);
5071 0 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
5072 :
5073 : {
5074 : // remove actions
5075 0 : UnoActionRemoveContext aRemoveContext(pUnoCrsr->GetDoc());
5076 : }
5077 :
5078 0 : pFrmFmt->GetDoc()->InsertCol(*pUnoCrsr, (sal_uInt16)nCount, bAppend);
5079 0 : delete pUnoCrsr;
5080 0 : }
5081 : }
5082 0 : }
5083 : }
5084 :
5085 : ///@see SwXTableRows::removeByIndex (TODO: seems to be copy and paste programming here)
5086 0 : void SwXTableColumns::removeByIndex(sal_Int32 nIndex, sal_Int32 nCount)
5087 : throw (uno::RuntimeException, std::exception)
5088 : {
5089 0 : SolarMutexGuard aGuard;
5090 0 : if (nCount == 0)
5091 0 : return;
5092 0 : SwFrmFmt* pFrmFmt = GetFrmFmt();
5093 0 : if(!pFrmFmt|| nIndex < 0 || nCount <=0 )
5094 0 : throw uno::RuntimeException();
5095 : else
5096 : {
5097 0 : bool bSuccess = false;
5098 0 : SwTable* pTable = SwTable::FindTable( pFrmFmt );
5099 0 : if(!pTable->IsTblComplex())
5100 : {
5101 0 : const OUString sTLName = sw_GetCellName(nIndex, 0);
5102 0 : const SwTableBox* pTLBox = pTable->GetTblBox( sTLName );
5103 0 : if(pTLBox)
5104 : {
5105 : {
5106 : // invalidate all actions
5107 0 : UnoActionRemoveContext aRemoveContext(pFrmFmt->GetDoc());
5108 : }
5109 0 : const SwStartNode* pSttNd = pTLBox->GetSttNd();
5110 0 : SwPosition aPos(*pSttNd);
5111 : // set cursor to the upper-left cell of the range
5112 0 : SwUnoCrsr* pUnoCrsr = pFrmFmt->GetDoc()->CreateUnoCrsr(aPos, true);
5113 0 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
5114 0 : pUnoCrsr->SetRemainInSection( false );
5115 0 : const OUString sTRName = sw_GetCellName(nIndex + nCount - 1, 0);
5116 0 : const SwTableBox* pTRBox = pTable->GetTblBox( sTRName );
5117 0 : if(pTRBox)
5118 : {
5119 0 : pUnoCrsr->SetMark();
5120 0 : pUnoCrsr->GetPoint()->nNode = *pTRBox->GetSttNd();
5121 0 : pUnoCrsr->Move( fnMoveForward, fnGoNode );
5122 : SwUnoTableCrsr* pCrsr =
5123 0 : dynamic_cast<SwUnoTableCrsr*>(pUnoCrsr);
5124 0 : pCrsr->MakeBoxSels();
5125 : { // these braces are important
5126 0 : UnoActionContext aAction(pFrmFmt->GetDoc());
5127 0 : pFrmFmt->GetDoc()->DeleteCol(*pUnoCrsr);
5128 0 : delete pUnoCrsr;
5129 0 : bSuccess = true;
5130 : }
5131 : {
5132 : // invalidate all actions
5133 0 : UnoActionRemoveContext aRemoveContext(pFrmFmt->GetDoc());
5134 : }
5135 0 : }
5136 0 : }
5137 : }
5138 0 : if(!bSuccess)
5139 : {
5140 0 : uno::RuntimeException aExcept;
5141 0 : aExcept.Message = "Illegal arguments";
5142 0 : throw aExcept;
5143 : }
5144 0 : }
5145 : }
5146 :
5147 4 : void SwXTableColumns::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
5148 : {
5149 4 : ClientModify(this, pOld, pNew);
5150 274 : }
5151 :
5152 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
