LCOV - code coverage report
Current view: top level - sw/source/core/unocore - unotbl.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 2776 0.0 %
Date: 2014-04-14 Functions: 0 263 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10