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