svx/source/table/cell.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cell.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #include <com/sun/star/drawing/BitmapMode.hpp>
  35 #include <com/sun/star/style/XStyle.hpp>
  36 #include <com/sun/star/text/WritingMode.hpp>
  37 #include <com/sun/star/table/TableBorder.hpp>
  38
  39 #include <cppuhelper/typeprovider.hxx>
  40 #include <svtools/style.hxx>
  41 #include <svtools/itemset.hxx>
  42
  43 #include <vos/mutex.hxx>
  44 #include <vcl/svapp.hxx>
  45
  46 #include "svx/sdr/properties/textproperties.hxx"
  47 #include "svx/outlobj.hxx"
  48 #include "svx/writingmodeitem.hxx"
  49 #include "svx/svdotable.hxx"
  50 #include "svx/svdoutl.hxx"
  51 #include "svx/unoshtxt.hxx"
  52 #include "svx/svdmodel.hxx"
  53
  54 #include "tableundo.hxx"
  55 #include "cell.hxx"
  56 #include "svx/svdotable.hxx"
  57 #include "svx/svdoutl.hxx"
  58 #include "svx/unoshtxt.hxx"
  59 #include "svx/unoshprp.hxx"
  60 #include "svx/unoshape.hxx"
  61 #include "svx/editobj.hxx"
  62 #include "svx/boxitem.hxx"
  63 #include "svx/xflbstit.hxx"
  64 #include "svx/xflbmtit.hxx"
  65
  66 // -----------------------------------------------------------------------------
  67
  68 using ::rtl::OUString;
  69 using ::vos::OGuard;
  70 using namespace ::com::sun::star::uno;
  71 using namespace ::com::sun::star::beans;
  72 using namespace ::com::sun::star::lang;
  73 using namespace ::com::sun::star::text;
  74 using namespace ::com::sun::star::table;
  75 using namespace ::com::sun::star::drawing;
  76 using namespace ::com::sun::star::style;
  77 using namespace ::com::sun::star::container;
  78
  79 extern sal_Bool lcl_LineToSvxLine(const BorderLine& rLine, SvxBorderLine& rSvxLine, sal_Bool bConvert);
  80 extern BorderLine lcl_SvxLineToLine(const SvxBorderLine* pLine, sal_Bool bConvert);
  81
  82 // -----------------------------------------------------------------------------
  83
  84 static const SvxItemPropertySet* ImplGetSvxCellPropertySet()
  85 {
  86     // Propertymap fuer einen Outliner Text
  87     static const SfxItemPropertyMapEntry aSvxCellPropertyMap[] =
  88     {
  89         FILL_PROPERTIES
  90 //              { MAP_CHAR_LEN("HasLevels"),                                    OWN_ATTR_HASLEVELS,                             &::getBooleanCppuType(), ::com::sun::star::beans::PropertyAttribute::READONLY,          0},
  91         { MAP_CHAR_LEN("Style"),                                                OWN_ATTR_STYLE,                                 &::com::sun::star::style::XStyle::static_type(),                                                                        ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
  92         { MAP_CHAR_LEN(UNO_NAME_TEXT_WRITINGMODE),              SDRATTR_TEXTDIRECTION,                  &::getCppuType( (::com::sun::star::text::WritingMode*) 0 ),                                                     0,              0},
  93         { MAP_CHAR_LEN(UNO_NAME_TEXT_HORZADJUST),               SDRATTR_TEXT_HORZADJUST,                &::getCppuType((const ::com::sun::star::drawing::TextHorizontalAdjust*)0),      0,              0}, \
  94         { MAP_CHAR_LEN(UNO_NAME_TEXT_LEFTDIST),                 SDRATTR_TEXT_LEFTDIST,                  &::getCppuType((const sal_Int32*)0),            0,              SFX_METRIC_ITEM}, \
  95         { MAP_CHAR_LEN(UNO_NAME_TEXT_LOWERDIST),                SDRATTR_TEXT_LOWERDIST,                 &::getCppuType((const sal_Int32*)0),            0,              SFX_METRIC_ITEM}, \
  96         { MAP_CHAR_LEN(UNO_NAME_TEXT_RIGHTDIST),                SDRATTR_TEXT_RIGHTDIST,                 &::getCppuType((const sal_Int32*)0),            0,              SFX_METRIC_ITEM}, \
  97         { MAP_CHAR_LEN(UNO_NAME_TEXT_UPPERDIST),                SDRATTR_TEXT_UPPERDIST,                 &::getCppuType((const sal_Int32*)0),            0,              SFX_METRIC_ITEM}, \
  98         { MAP_CHAR_LEN(UNO_NAME_TEXT_VERTADJUST),               SDRATTR_TEXT_VERTADJUST,                &::getCppuType((const ::com::sun::star::drawing::TextVerticalAdjust*)0),        0,              0},\
  99         { MAP_CHAR_LEN(UNO_NAME_TEXT_WORDWRAP),                 SDRATTR_TEXT_WORDWRAP,                  &::getBooleanCppuType(),                0,              0}, \
 100
 101         { MAP_CHAR_LEN("TableBorder"),                                  OWN_ATTR_TABLEBORDER,                   &::getCppuType((const TableBorder*)0), 0, 0 }, \
 102         { MAP_CHAR_LEN("TopBorder"),                                    SDRATTR_TABLE_BORDER,                   &::getCppuType((const BorderLine*)0), 0, TOP_BORDER }, \
 103         { MAP_CHAR_LEN("BottomBorder"),                                 SDRATTR_TABLE_BORDER,                   &::getCppuType((const BorderLine*)0), 0, BOTTOM_BORDER }, \
 104         { MAP_CHAR_LEN("LeftBorder"),                                   SDRATTR_TABLE_BORDER,                   &::getCppuType((const BorderLine*)0), 0, LEFT_BORDER }, \
 105         { MAP_CHAR_LEN("RightBorder"),                                  SDRATTR_TABLE_BORDER,                   &::getCppuType((const BorderLine*)0), 0, RIGHT_BORDER }, \
 106
 107         SVX_UNOEDIT_OUTLINER_PROPERTIES,
 108         SVX_UNOEDIT_CHAR_PROPERTIES,
 109         SVX_UNOEDIT_PARA_PROPERTIES,
 110         {0,0,0,0,0,0}
 111     };
 112
 113     static SvxItemPropertySet aSvxCellPropertySet( aSvxCellPropertyMap );
 114     return &aSvxCellPropertySet;
 115 }
 116
 117 namespace sdr
 118 {
 119     namespace properties
 120     {
 121         class CellProperties : public TextProperties
 122         {
 123         protected:
 124             // create a new itemset
 125             SfxItemSet& CreateObjectSpecificItemSet(SfxItemPool& rPool);
 126
 127         public:
 128             // basic constructor
 129             CellProperties(SdrObject& rObj, sdr::table::Cell* pCell );
 130
 131             // constructor for copying, but using new object
 132             CellProperties(const CellProperties& rProps, SdrObject& rObj, sdr::table::Cell* pCell);
 133
 134             // destructor
 135             ~CellProperties();
 136
 137             // Clone() operator, normally just calls the local copy constructor
 138             BaseProperties& Clone(SdrObject& rObj) const;
 139
 140             void ForceDefaultAttributes();
 141
 142             void ItemSetChanged(const SfxItemSet& rSet);
 143
 144             void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem);
 145
 146             void SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr);
 147
 148             sdr::table::CellRef mxCell;
 149         };
 150
 151         // create a new itemset
 152         SfxItemSet& CellProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
 153         {
 154             return *(new SfxItemSet(rPool,
 155
 156                 // range from SdrAttrObj
 157                 SDRATTR_START, SDRATTR_SHADOW_LAST,
 158                 SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
 159                 SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,
 160
 161                 // range for SdrTableObj
 162                 SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
 163
 164                 // range from SdrTextObj
 165                 EE_ITEMS_START, EE_ITEMS_END,
 166
 167                 // end
 168                 0, 0));
 169         }
 170
 171         CellProperties::CellProperties(SdrObject& rObj, sdr::table::Cell* pCell)
 172         :       TextProperties(rObj)
 173         ,       mxCell(pCell)
 174         {
 175         }
 176
 177         CellProperties::CellProperties(const CellProperties& rProps, SdrObject& rObj, sdr::table::Cell* pCell)
 178         :       TextProperties(rProps, rObj)
 179         ,       mxCell( pCell )
 180         {
 181         }
 182
 183         CellProperties::~CellProperties()
 184         {
 185         }
 186
 187         BaseProperties& CellProperties::Clone(SdrObject& rObj) const
 188         {
 189             DBG_ERROR("CellProperties::Clone(), does not work yet!");
 190             return *(new CellProperties(*this, rObj,0));
 191         }
 192
 193         void CellProperties::ForceDefaultAttributes()
 194         {
 195         }
 196
 197         void CellProperties::ItemSetChanged(const SfxItemSet& rSet )
 198         {
 199             SdrTextObj& rObj = (SdrTextObj&)GetSdrObject();
 200
 201             if( mxCell.is() )
 202             {
 203                 OutlinerParaObject* pParaObj = mxCell->GetEditOutlinerParaObject();
 204
 205                 bool bOwnParaObj = pParaObj != 0;
 206
 207                 if( pParaObj == 0 )
 208                     pParaObj = mxCell->GetOutlinerParaObject();
 209
 210                 if(pParaObj)
 211                 {
 212                     // handle outliner attributes
 213                     Outliner* pOutliner = 0;
 214
 215                     if(mxCell->IsTextEditActive())
 216                     {
 217                         pOutliner = rObj.GetTextEditOutliner();
 218                     }
 219                     else
 220                     {
 221                         pOutliner = &rObj.ImpGetDrawOutliner();
 222                         pOutliner->SetText(*pParaObj);
 223                     }
 224
 225                     sal_uInt32 nParaCount(pOutliner->GetParagraphCount());
 226
 227                     for(sal_uInt16 nPara = 0; nPara < nParaCount; nPara++)
 228                     {
 229                         SfxItemSet aSet(pOutliner->GetParaAttribs(nPara));
 230                         aSet.Put(rSet);
 231                         pOutliner->SetParaAttribs(nPara, aSet);
 232                     }
 233
 234                     if(!mxCell->IsTextEditActive())
 235                     {
 236                         if(nParaCount)
 237                         {
 238                             // force ItemSet
 239                             GetObjectItemSet();
 240
 241                             SfxItemSet aNewSet(pOutliner->GetParaAttribs(0L));
 242                             mpItemSet->Put(aNewSet);
 243                         }
 244
 245                         OutlinerParaObject* pTemp = pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount);
 246                         pOutliner->Clear();
 247
 248                         mxCell->SetOutlinerParaObject(pTemp);
 249                     }
 250
 251                     if( bOwnParaObj )
 252                         delete pParaObj;
 253                 }
 254             }
 255
 256             // call parent
 257             AttributeProperties::ItemSetChanged(rSet);
 258
 259             if( mxCell.is() )
 260                 mxCell->notifyModified();
 261         }
 262
 263         void CellProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
 264         {
 265             if(pNewItem && (SDRATTR_TEXTDIRECTION == nWhich))
 266             {
 267                 sal_Bool bVertical(com::sun::star::text::WritingMode_TB_RL == ((SvxWritingModeItem*)pNewItem)->GetValue());
 268
 269                 sdr::table::SdrTableObj& rObj = (sdr::table::SdrTableObj&)GetSdrObject();
 270                 if( rObj.IsVerticalWriting() != bVertical )
 271                     rObj.SetVerticalWriting(bVertical);
 272             }
 273
 274             // call parent
 275             AttributeProperties::ItemChange( nWhich, pNewItem );
 276         }
 277
 278         void CellProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
 279         {
 280             TextProperties::SetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr );
 281         }
 282     } // end of namespace properties
 283 } // end of namespace sdr
 284
 285 namespace sdr { namespace table {
 286
 287 // -----------------------------------------------------------------------------
 288 // Cell
 289 // -----------------------------------------------------------------------------
 290
 291 rtl::Reference< Cell > Cell::create( SdrTableObj& rTableObj, OutlinerParaObject* pOutlinerParaObject )
 292 {
 293     rtl::Reference< Cell > xCell( new Cell( rTableObj, pOutlinerParaObject ) );
 294     if( xCell->mxTable.is() )
 295     {
 296         Reference< XEventListener > xListener( xCell.get() );
 297         xCell->mxTable->addEventListener( xListener );
 298     }
 299     return xCell;
 300 }
 301
 302 // -----------------------------------------------------------------------------
 303
 304 Cell::Cell( SdrTableObj& rTableObj, OutlinerParaObject* pOutlinerParaObject ) throw()
 305 : SdrText( rTableObj, pOutlinerParaObject )
 306 , SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
 307 , mpPropSet( ImplGetSvxCellPropertySet() )
 308 , mpProperties( new sdr::properties::CellProperties( rTableObj, this ) )
 309 , mnCellContentType( CellContentType_EMPTY )
 310 , mfValue( 0.0 )
 311 , mnError( 0 )
 312 , mbMerged( sal_False )
 313 , mnRowSpan( 1 )
 314 , mnColSpan( 1 )
 315 , mxTable( rTableObj.getTable() )
 316 {
 317     if( rTableObj.GetModel() )
 318         SetModel( rTableObj.GetModel() );
 319 }
 320
 321 // -----------------------------------------------------------------------------
 322
 323 Cell::~Cell() throw()
 324 {
 325     dispose();
 326 }
 327
 328 // -----------------------------------------------------------------------------
 329
 330 void Cell::dispose()
 331 {
 332     if( mxTable.is() )
 333     {
 334         try
 335         {
 336             Reference< XEventListener > xThis( this );
 337             mxTable->removeEventListener( xThis );
 338         }
 339         catch( Exception& )
 340         {
 341             DBG_ERROR("Cell::dispose(), exception caught!");
 342         }
 343         mxTable.clear();
 344     }
 345
 346     if( mpProperties )
 347     {
 348         delete mpProperties;
 349         mpProperties = 0;
 350     }
 351     SetOutlinerParaObject( 0 );
 352 }
 353
 354 // -----------------------------------------------------------------------------
 355
 356 void Cell::SetModel(SdrModel* pNewModel)
 357 {
 358     SvxTextEditSource* pTextEditSource = dynamic_cast< SvxTextEditSource* >( GetEditSource() );
 359     if( (GetModel() != pNewModel) || ( pNewModel && !pTextEditSource) )
 360     {
 361         if( mpProperties )
 362         {
 363             SfxItemPool* pItemPool = mpProperties->GetObjectItemSet().GetPool();
 364
 365             // test for correct pool in ItemSet; move to new pool if necessary
 366             if( pNewModel && pItemPool && pItemPool != &pNewModel->GetItemPool())
 367                 mpProperties->MoveToItemPool(pItemPool, &pNewModel->GetItemPool(), pNewModel);
 368         }
 369
 370         if( pTextEditSource )
 371         {
 372             pTextEditSource->ChangeModel( pNewModel );
 373         }
 374         else
 375         {
 376             SetEditSource( new SvxTextEditSource( &GetObject(), this, static_cast< XWeak * >( this ) ) );
 377         }
 378
 379         SetStyleSheet( 0, sal_True );
 380         SdrText::SetModel( pNewModel );
 381         ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
 382     }
 383 }
 384
 385 // -----------------------------------------------------------------------------
 386
 387 void Cell::merge( sal_Int32 nColumnSpan, sal_Int32 nRowSpan )
 388 {
 389     if( (mnColSpan != nColumnSpan) || (mnRowSpan != nRowSpan) || (mbMerged != sal_False) )
 390     {
 391         mnColSpan = nColumnSpan;
 392         mnRowSpan = nRowSpan;
 393         mbMerged = sal_False;
 394         notifyModified();
 395     }
 396 }
 397
 398 // -----------------------------------------------------------------------------
 399
 400 void Cell::mergeContent( const CellRef& xSourceCell )
 401 {
 402     SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
 403
 404     if( xSourceCell->hasText() )
 405     {
 406         SdrOutliner& rOutliner=rTableObj.ImpGetDrawOutliner();
 407         rOutliner.SetUpdateMode(TRUE);
 408
 409         if( hasText() )
 410         {
 411             rOutliner.SetText(*GetOutlinerParaObject());
 412             rOutliner.AddText(*xSourceCell->GetOutlinerParaObject());
 413         }
 414         else
 415         {
 416             rOutliner.SetText(*xSourceCell->GetOutlinerParaObject());
 417         }
 418
 419         SetOutlinerParaObject( rOutliner.CreateParaObject() );
 420         rOutliner.Clear();
 421         xSourceCell->SetOutlinerParaObject(rOutliner.CreateParaObject());
 422         rOutliner.Clear();
 423         SetStyleSheet( GetStyleSheet(), sal_True );
 424     }
 425 }
 426
 427 // -----------------------------------------------------------------------------
 428
 429 void Cell::cloneFrom( const CellRef& xCell )
 430 {
 431     if( xCell.is() )
 432     {
 433         replaceContentAndFormating( xCell );
 434
 435         mnCellContentType = xCell->mnCellContentType;
 436
 437         msFormula = xCell->msFormula;
 438         mfValue = xCell->mfValue;
 439         mnError = xCell->mnError;
 440
 441         mbMerged = xCell->mbMerged;
 442         mnRowSpan = xCell->mnRowSpan;
 443         mnColSpan = xCell->mnColSpan;
 444
 445     }
 446     notifyModified();
 447 }
 448
 449 void Cell::replaceContentAndFormating( const CellRef& xSourceCell )
 450 {
 451     if( xSourceCell.is() && mpProperties )
 452     {
 453         mpProperties->SetMergedItemSet( xSourceCell->GetObjectItemSet() );
 454         SetOutlinerParaObject( new OutlinerParaObject(*xSourceCell->GetOutlinerParaObject()) );
 455
 456         SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
 457         SdrTableObj& rSourceTableObj = dynamic_cast< SdrTableObj& >( xSourceCell->GetObject() );
 458
 459         if(rSourceTableObj.GetModel() != rTableObj.GetModel())
 460         {
 461             SetStyleSheet( 0, sal_True );
 462         }
 463     }
 464 }
 465
 466 // -----------------------------------------------------------------------------
 467
 468 void Cell::setMerged()
 469 {
 470     if( !mbMerged )
 471     {
 472         mbMerged = sal_True;
 473         notifyModified();
 474     }
 475 }
 476
 477 // -----------------------------------------------------------------------------
 478
 479 void Cell::notifyModified()
 480 {
 481     if( mxTable.is() )
 482         mxTable->setModified( sal_True );
 483 }
 484
 485 // -----------------------------------------------------------------------------
 486 // SdrTextShape proxy
 487 // -----------------------------------------------------------------------------
 488
 489 bool Cell::IsTextEditActive()
 490 {
 491     bool isActive = false;
 492     SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
 493     if(rTableObj.getActiveCell().get() == this )
 494     {
 495         OutlinerParaObject* pParaObj = rTableObj.GetEditOutlinerParaObject();
 496         if( pParaObj != 0 )
 497         {
 498             isActive = true;
 499             delete pParaObj;
 500         }
 501     }
 502     return isActive;
 503 }
 504
 505 // -----------------------------------------------------------------------------
 506
 507 bool Cell::hasText() const
 508 {
 509     OutlinerParaObject* pParaObj = GetOutlinerParaObject();
 510     if( pParaObj )
 511     {
 512         const EditTextObject& rTextObj = pParaObj->GetTextObject();
 513         if( rTextObj.GetParagraphCount() >= 1 )
 514         {
 515             if( rTextObj.GetParagraphCount() == 1 )
 516             {
 517                 if( rTextObj.GetText(0).Len() == 0 )
 518                     return false;
 519             }
 520             return true;
 521         }
 522     }
 523
 524     return false;
 525 }
 526
 527 // -----------------------------------------------------------------------------
 528
 529 OutlinerParaObject* Cell::GetEditOutlinerParaObject() const
 530 {
 531     SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
 532     if( rTableObj.getActiveCell().get() == this )
 533         return rTableObj.GetEditOutlinerParaObject();
 534     return 0;
 535 }
 536
 537 // -----------------------------------------------------------------------------
 538
 539 void Cell::SetStyleSheet( SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr )
 540 {
 541     // only allow cell styles for cells
 542     if( pStyleSheet && pStyleSheet->GetFamily() != SFX_STYLE_FAMILY_FRAME )
 543         return;
 544
 545     if( mpProperties && (mpProperties->GetStyleSheet() != pStyleSheet) )
 546     {
 547         mpProperties->SetStyleSheet( pStyleSheet, bDontRemoveHardAttr );
 548     }
 549 }
 550
 551 // -----------------------------------------------------------------------------
 552
 553 const SfxItemSet& Cell::GetObjectItemSet()
 554 {
 555     if( mpProperties )
 556     {
 557         return mpProperties->GetObjectItemSet();
 558     }
 559         else if( hasText() )
 560     {
 561         DBG_ERROR("Cell::GetObjectItemSet(), called without properties!");
 562         return GetObject().GetObjectItemSet();
 563     }
 564 }
 565
 566 void Cell::SetObjectItem(const SfxPoolItem& rItem)
 567 {
 568     if( mpProperties )
 569     {
 570         mpProperties->SetObjectItem( rItem );
 571         notifyModified();
 572     }
 573 }
 574
 575 void Cell::SetMergedItem(const SfxPoolItem& rItem)
 576 {
 577     SetObjectItem(rItem);
 578 }
 579
 580 SfxStyleSheet* Cell::GetStyleSheet() const
 581 {
 582     if( mpProperties )
 583         return mpProperties->GetStyleSheet();
 584     else
 585         return 0;
 586 }
 587
 588 // -----------------------------------------------------------------------------
 589
 590 SfxStyleSheetPool* Cell::GetStyleSheetPool() const
 591 {
 592     if( mpProperties && mpProperties->GetStyleSheet() )
 593         return dynamic_cast< SfxStyleSheetPool* >( &mpProperties->GetStyleSheet()->GetPool() );
 594     else
 595         return 0;
 596 }
 597
 598 // -----------------------------------------------------------------------------
 599
 600 const Rectangle& Cell::GetCurrentBoundRect() const
 601 {
 602     return maCellRect;
 603 }
 604
 605 // -----------------------------------------------------------------------------
 606
 607 void Cell::TakeTextAnchorRect(Rectangle& rAnchorRect) const
 608 {
 609     rAnchorRect.nLeft = maCellRect.nLeft + GetTextLeftDistance();
 610     rAnchorRect.nRight = maCellRect.nRight - GetTextRightDistance();
 611     rAnchorRect.nTop = maCellRect.nTop + GetTextUpperDistance();
 612     rAnchorRect.nBottom = maCellRect.nBottom - GetTextLowerDistance();
 613 }
 614
 615 // -----------------------------------------------------------------------------
 616
 617 const SfxItemSet& Cell::GetItemSet() const
 618 {
 619     return mpProperties->GetObjectItemSet();
 620 }
 621
 622 // -----------------------------------------------------------------------------
 623
 624 void Cell::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, sal_Bool bClearAllItems)
 625 {
 626     if( mpProperties )
 627     {
 628         mpProperties->SetMergedItemSetAndBroadcast(rSet, bClearAllItems);
 629         notifyModified();
 630     }
 631 }
 632
 633 // -----------------------------------------------------------------------------
 634
 635 sal_Int32 Cell::getMinimumWidth()
 636 {
 637     return GetTextLeftDistance() + GetTextRightDistance() + 100;
 638 }
 639
 640 // -----------------------------------------------------------------------------
 641
 642 sal_Int32 Cell::getMinimumHeight()
 643 {
 644     if( !mpProperties )
 645         return 0;
 646
 647     SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
 648     sal_Int32 nMinimumHeight = 0;
 649
 650     Rectangle aTextRect;
 651     TakeTextAnchorRect( aTextRect );
 652     Size aSize( aTextRect.GetSize() );
 653     aSize.Height()=0x0FFFFFFF;
 654
 655     SdrOutliner* pEditOutliner = rTableObj.GetCellTextEditOutliner( *this );
 656     if(pEditOutliner)
 657     {
 658         pEditOutliner->SetMaxAutoPaperSize(aSize);
 659         nMinimumHeight = pEditOutliner->GetTextHeight()+1;
 660     }
 661     else /*if ( hasText() )*/
 662     {
 663         Outliner& rOutliner=rTableObj.ImpGetDrawOutliner();
 664         rOutliner.SetPaperSize(aSize);
 665         rOutliner.SetUpdateMode(TRUE);
 666         ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
 667
 668         if( GetOutlinerParaObject() )
 669         {
 670             rOutliner.SetText(*GetOutlinerParaObject());
 671         }
 672         nMinimumHeight=rOutliner.GetTextHeight()+1;
 673         rOutliner.Clear();
 674     }
 675
 676     nMinimumHeight += GetTextUpperDistance() + GetTextLowerDistance();
 677     return nMinimumHeight;
 678 }
 679
 680 // -----------------------------------------------------------------------------
 681
 682 long Cell::GetTextLeftDistance() const
 683 {
 684     return ((SdrTextLeftDistItem&)(GetItemSet().Get(SDRATTR_TEXT_LEFTDIST))).GetValue();
 685 }
 686
 687 // -----------------------------------------------------------------------------
 688
 689 long Cell::GetTextRightDistance() const
 690 {
 691     return ((SdrTextRightDistItem&)(GetItemSet().Get(SDRATTR_TEXT_RIGHTDIST))).GetValue();
 692 }
 693
 694 // -----------------------------------------------------------------------------
 695
 696 long Cell::GetTextUpperDistance() const
 697 {
 698     return ((SdrTextUpperDistItem&)(GetItemSet().Get(SDRATTR_TEXT_UPPERDIST))).GetValue();
 699 }
 700
 701 // -----------------------------------------------------------------------------
 702
 703 long Cell::GetTextLowerDistance() const
 704 {
 705     return ((SdrTextLowerDistItem&)(GetItemSet().Get(SDRATTR_TEXT_LOWERDIST))).GetValue();
 706 }
 707
 708 // -----------------------------------------------------------------------------
 709
 710 SdrTextVertAdjust Cell::GetTextVerticalAdjust() const
 711 {
 712     return ((SdrTextVertAdjustItem&)(GetItemSet().Get(SDRATTR_TEXT_VERTADJUST))).GetValue();
 713 }
 714
 715 // -----------------------------------------------------------------------------
 716
 717 SdrTextHorzAdjust Cell::GetTextHorizontalAdjust() const
 718 {
 719     return ((SdrTextHorzAdjustItem&)(GetItemSet().Get(SDRATTR_TEXT_HORZADJUST))).GetValue();
 720 }
 721
 722 // -----------------------------------------------------------------------------
 723
 724 void Cell::SetOutlinerParaObject( OutlinerParaObject* pTextObject )
 725 {
 726     SdrText::SetOutlinerParaObject( pTextObject );
 727     maSelection.nStartPara = 0xffff;
 728
 729     if( pTextObject == 0 )
 730         ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
 731 }
 732
 733 // -----------------------------------------------------------------------------
 734
 735 void Cell::AddUndo()
 736 {
 737     SdrObject& rObj = GetObject();
 738     if( rObj.IsInserted() && GetModel() && GetModel()->IsUndoEnabled() )
 739     {
 740         CellRef xCell( this );
 741         GetModel()->AddUndo( new CellUndo( &rObj, xCell ) );
 742     }
 743 }
 744
 745 // -----------------------------------------------------------------------------
 746
 747 sdr::properties::TextProperties* Cell::CloneProperties( sdr::properties::TextProperties* pProperties, SdrObject& rNewObj, Cell& rNewCell )
 748 {
 749     if( pProperties )
 750         return new sdr::properties::CellProperties( *static_cast<sdr::properties::CellProperties*>(pProperties), rNewObj, &rNewCell );
 751     else
 752         return 0;
 753 }
 754
 755 // -----------------------------------------------------------------------------
 756
 757 sdr::properties::TextProperties* Cell::CloneProperties( SdrObject& rNewObj, Cell& rNewCell )
 758 {
 759     return CloneProperties(mpProperties,rNewObj,rNewCell);
 760 }
 761
 762 // -----------------------------------------------------------------------------
 763 // XInterface
 764 // -----------------------------------------------------------------------------
 765
 766 Any SAL_CALL Cell::queryInterface( const Type & rType ) throw(RuntimeException)
 767 {
 768     if( rType == XMergeableCell::static_type() )
 769         return Any( Reference< XMergeableCell >( this ) );
 770
 771     if( rType == XCell::static_type() )
 772         return Any( Reference< XCell >( this ) );
 773
 774     if( rType == XLayoutConstrains::static_type() )
 775         return Any( Reference< XLayoutConstrains >( this ) );
 776
 777     if( rType == XEventListener::static_type() )
 778         return Any( Reference< XEventListener >( this ) );
 779
 780     Any aRet( SvxUnoTextBase::queryAggregation( rType ) );
 781     if( aRet.hasValue() )
 782         return aRet;
 783
 784     return ::cppu::OWeakObject::queryInterface( rType );
 785 }
 786
 787 // -----------------------------------------------------------------------------
 788
 789 void SAL_CALL Cell::acquire() throw ()
 790 {
 791     ::cppu::OWeakObject::acquire();
 792 }
 793
 794 // -----------------------------------------------------------------------------
 795
 796 void SAL_CALL Cell::release() throw ()
 797 {
 798     ::cppu::OWeakObject::release();
 799 }
 800
 801 // -----------------------------------------------------------------------------
 802 // XTypeProvider
 803 // -----------------------------------------------------------------------------
 804
 805 Sequence< Type > SAL_CALL Cell::getTypes(  ) throw (RuntimeException)
 806 {
 807     Sequence< Type > aTypes( SvxUnoTextBase::getTypes() );
 808
 809     sal_Int32 nLen = aTypes.getLength();
 810     aTypes.realloc(nLen + 2);
 811     aTypes[nLen++] = XMergeableCell::static_type();
 812     aTypes[nLen++] = XLayoutConstrains::static_type();
 813
 814     return aTypes;
 815 }
 816
 817 // -----------------------------------------------------------------------------
 818
 819 Sequence< sal_Int8 > SAL_CALL Cell::getImplementationId(  ) throw (RuntimeException)
 820 {
 821     static ::cppu::OImplementationId* pId = 0;
 822     if (! pId)
 823     {
 824         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 825         if (! pId)
 826         {
 827             static ::cppu::OImplementationId aId;
 828             pId = &aId;
 829         }
 830     }
 831     return pId->getImplementationId();
 832 }
 833
 834 // -----------------------------------------------------------------------------
 835 // XServiceInfo
 836 // -----------------------------------------------------------------------------
 837
 838 OUString SAL_CALL Cell::getImplementationName(  ) throw (RuntimeException)
 839 {
 840     return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.svx.table.Cell" ) );
 841 }
 842
 843 // -----------------------------------------------------------------------------
 844
 845 sal_Bool SAL_CALL Cell::supportsService( const OUString& ServiceName ) throw (RuntimeException)
 846 {
 847     if( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.table.cell" ) ) == 0 )
 848         return sal_True;
 849
 850     if( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.cell" ) ) == 0 )
 851         return sal_True;
 852
 853     return SvxUnoTextBase::supportsService( ServiceName );
 854 }
 855
 856 // -----------------------------------------------------------------------------
 857
 858 Sequence< OUString > SAL_CALL Cell::getSupportedServiceNames(  ) throw (RuntimeException)
 859 {
 860     Sequence< OUString > aSeq( SvxUnoTextBase::getSupportedServiceNames() );
 861     sal_Int32 nIndex = aSeq.getLength();
 862     aSeq.realloc( nIndex + 2 );
 863     aSeq[nIndex++] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.table.cell" ) );
 864     aSeq[nIndex++] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.cell" ) );
 865     return aSeq;
 866 }
 867
 868 // -----------------------------------------------------------------------------
 869 // XLayoutConstrains
 870 // -----------------------------------------------------------------------------
 871
 872 ::com::sun::star::awt::Size SAL_CALL Cell::getMinimumSize(  ) throw (RuntimeException)
 873 {
 874     return ::com::sun::star::awt::Size( getMinimumWidth(),  getMinimumHeight() );
 875 }
 876
 877 // -----------------------------------------------------------------------------
 878
 879 ::com::sun::star::awt::Size SAL_CALL Cell::getPreferredSize(  ) throw (RuntimeException)
 880 {
 881     return getMinimumSize();
 882 }
 883
 884 // -----------------------------------------------------------------------------
 885
 886 ::com::sun::star::awt::Size SAL_CALL Cell::calcAdjustedSize( const ::com::sun::star::awt::Size& aNewSize ) throw (RuntimeException)
 887 {
 888     return aNewSize;
 889 }
 890
 891 // -----------------------------------------------------------------------------
 892 // XMergeableCell
 893 // -----------------------------------------------------------------------------
 894
 895 sal_Int32 SAL_CALL Cell::getRowSpan() throw (RuntimeException)
 896 {
 897     return mnRowSpan;
 898 }
 899
 900 // -----------------------------------------------------------------------------
 901
 902 sal_Int32 SAL_CALL Cell::getColumnSpan() throw (RuntimeException)
 903 {
 904     return mnColSpan;
 905 }
 906
 907 // -----------------------------------------------------------------------------
 908
 909 sal_Bool SAL_CALL Cell::isMerged() throw (RuntimeException)
 910 {
 911     return mbMerged;
 912 }
 913
 914 // -----------------------------------------------------------------------------
 915 // XCell
 916 // -----------------------------------------------------------------------------
 917
 918 OUString SAL_CALL Cell::getFormula(  ) throw (RuntimeException)
 919 {
 920     return msFormula;
 921 }
 922
 923 // -----------------------------------------------------------------------------
 924
 925 void SAL_CALL Cell::setFormula( const OUString& aFormula ) throw (RuntimeException)
 926 {
 927     if( msFormula != aFormula )
 928     {
 929         msFormula = aFormula;
 930     }
 931 }
 932
 933 // -----------------------------------------------------------------------------
 934
 935 double SAL_CALL Cell::getValue(  ) throw (RuntimeException)
 936 {
 937     return mfValue;
 938 }
 939
 940 // -----------------------------------------------------------------------------
 941
 942 void SAL_CALL Cell::setValue( double nValue ) throw (RuntimeException)
 943 {
 944     if( mfValue == nValue )
 945     {
 946         mfValue = nValue;
 947         mnCellContentType = CellContentType_VALUE;
 948     }
 949 }
 950
 951 // -----------------------------------------------------------------------------
 952
 953 CellContentType SAL_CALL Cell::getType() throw (RuntimeException)
 954 {
 955     return mnCellContentType;
 956 }
 957
 958 // -----------------------------------------------------------------------------
 959
 960 sal_Int32 SAL_CALL Cell::getError(  ) throw (RuntimeException)
 961 {
 962     return mnError;
 963 }
 964
 965 // -----------------------------------------------------------------------------
 966 // XPropertySet
 967 // -----------------------------------------------------------------------------
 968
 969 Any Cell::GetAnyForItem( SfxItemSet& aSet, const SfxItemPropertySimpleEntry* pMap )
 970 {
 971     Any aAny( mpPropSet->getPropertyValue( pMap, aSet ) );
 972
 973     if( *pMap->pType != aAny.getValueType() )
 974     {
 975         // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
 976         if( ( *pMap->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) )
 977         {
 978             sal_Int32 nValue = 0;
 979             aAny >>= nValue;
 980             aAny <<= (sal_Int16)nValue;
 981         }
 982         else
 983         {
 984             DBG_ERROR("GetAnyForItem() Returnvalue has wrong Type!" );
 985         }
 986     }
 987
 988     return aAny;
 989 }
 990
 991 Reference< XPropertySetInfo > SAL_CALL Cell::getPropertySetInfo() throw(RuntimeException)
 992 {
 993     return mpPropSet->getPropertySetInfo();
 994 }
 995
 996 // -----------------------------------------------------------------------------
 997
 998 void SAL_CALL Cell::setPropertyValue( const OUString& rPropertyName, const Any& rValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
 999 {
1000     OGuard aGuard( Application::GetSolarMutex() );
1001
1002     if( (mpProperties == 0) || (GetModel() == 0) )
1003         throw DisposedException();
1004
1005     const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName);
1006     if( pMap )
1007     {
1008         if( (pMap->nFlags & PropertyAttribute::READONLY ) != 0 )
1009             throw PropertyVetoException();
1010
1011         switch( pMap->nWID )
1012         {
1013         case OWN_ATTR_STYLE:
1014         {
1015             Reference< XStyle > xStyle;
1016             if( !( rValue >>= xStyle ) )
1017                 throw IllegalArgumentException();
1018
1019             SfxUnoStyleSheet* pStyle = SfxUnoStyleSheet::getUnoStyleSheet(xStyle);
1020             SetStyleSheet( pStyle, sal_True );
1021             return;
1022         }
1023         case OWN_ATTR_TABLEBORDER:
1024         {
1025             if(rValue.getValueType() != ::getCppuType((const TableBorder*)0) )
1026                 break;
1027
1028             const TableBorder* pBorder = (const TableBorder* )rValue.getValue();
1029             if( pBorder == NULL )
1030                 break;
1031
1032             SvxBoxItem aBox( SDRATTR_TABLE_BORDER );
1033             SvxBoxInfoItem aBoxInfo( SDRATTR_TABLE_BORDER_INNER );
1034             SvxBorderLine aLine;
1035
1036             sal_Bool bSet = lcl_LineToSvxLine(pBorder->TopLine, aLine, false);
1037             aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_TOP);
1038             aBoxInfo.SetValid(VALID_TOP, pBorder->IsTopLineValid);
1039
1040             bSet = lcl_LineToSvxLine(pBorder->BottomLine, aLine, false);
1041             aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_BOTTOM);
1042             aBoxInfo.SetValid(VALID_BOTTOM, pBorder->IsBottomLineValid);
1043
1044             bSet = lcl_LineToSvxLine(pBorder->LeftLine, aLine, false);
1045             aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_LEFT);
1046             aBoxInfo.SetValid(VALID_LEFT, pBorder->IsLeftLineValid);
1047
1048             bSet = lcl_LineToSvxLine(pBorder->RightLine, aLine, false);
1049             aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_RIGHT);
1050             aBoxInfo.SetValid(VALID_RIGHT, pBorder->IsRightLineValid);
1051
1052             bSet = lcl_LineToSvxLine(pBorder->HorizontalLine, aLine, false);
1053             aBoxInfo.SetLine(bSet ? &aLine : 0, BOXINFO_LINE_HORI);
1054             aBoxInfo.SetValid(VALID_HORI, pBorder->IsHorizontalLineValid);
1055
1056             bSet = lcl_LineToSvxLine(pBorder->VerticalLine, aLine, false);
1057             aBoxInfo.SetLine(bSet ? &aLine : 0, BOXINFO_LINE_VERT);
1058             aBoxInfo.SetValid(VALID_VERT, pBorder->IsVerticalLineValid);
1059
1060             aBox.SetDistance(pBorder->Distance, false);
1061             aBoxInfo.SetValid(VALID_DISTANCE, pBorder->IsDistanceValid);
1062
1063             mpProperties->SetObjectItem(aBox);
1064             mpProperties->SetObjectItem(aBoxInfo);
1065             return;
1066         }
1067         case OWN_ATTR_FILLBMP_MODE:
1068         {
1069             BitmapMode eMode;
1070             if(!(rValue >>= eMode) )
1071             {
1072                 sal_Int32 nMode = 0;
1073                 if(!(rValue >>= nMode))
1074                     throw IllegalArgumentException();
1075
1076                     eMode = (BitmapMode)nMode;
1077             }
1078
1079             mpProperties->SetObjectItem( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) );
1080             mpProperties->SetObjectItem( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) );
1081             return;
1082         }
1083         default:
1084         {
1085             SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
1086             aSet.Put(mpProperties->GetItem(pMap->nWID));
1087
1088             bool bSpecial = false;
1089
1090             switch( pMap->nWID )
1091             {
1092                 case XATTR_FILLBITMAP:
1093                 case XATTR_FILLGRADIENT:
1094                 case XATTR_FILLHATCH:
1095                 case XATTR_FILLFLOATTRANSPARENCE:
1096                 case XATTR_LINEEND:
1097                 case XATTR_LINESTART:
1098                 case XATTR_LINEDASH:
1099                 {
1100                     if( pMap->nMemberId == MID_NAME )
1101                     {
1102                         OUString aApiName;
1103                         if( rValue >>= aApiName )
1104                         {
1105                             if( SvxShape::SetFillAttribute( pMap->nWID, aApiName, aSet, GetModel() ) )
1106                                 bSpecial = true;
1107                         }
1108                     }
1109                 }
1110                 break;
1111             }
1112
1113             if( !bSpecial )
1114             {
1115
1116                 if( !SvxUnoTextRangeBase::SetPropertyValueHelper( aSet, pMap, rValue, aSet ))
1117                 {
1118                     if( aSet.GetItemState( pMap->nWID ) != SFX_ITEM_SET )
1119                     {
1120                         // Default aus ItemPool holen
1121                         if(GetModel()->GetItemPool().IsWhich(pMap->nWID))
1122                             aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
1123                     }
1124
1125                     if( aSet.GetItemState( pMap->nWID ) == SFX_ITEM_SET )
1126                     {
1127                         mpPropSet->setPropertyValue( pMap, rValue, aSet );
1128                     }
1129                 }
1130             }
1131
1132             GetModel()->SetChanged();
1133             mpProperties->SetMergedItemSetAndBroadcast( aSet );
1134             return;
1135         }
1136         }
1137     }
1138     throw UnknownPropertyException();
1139 }
1140
1141 // -----------------------------------------------------------------------------
1142
1143 Any SAL_CALL Cell::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1144 {
1145     OGuard aGuard( Application::GetSolarMutex() );
1146
1147     if( (mpProperties == 0) || (GetModel() == 0) )
1148         throw DisposedException();
1149
1150     const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1151     if( pMap )
1152     {
1153         switch( pMap->nWID )
1154         {
1155 /*
1156         case OWN_ATTR_HASLEVELS:
1157         {
1158             return Any( hasLevels() );
1159         }
1160 */
1161         case OWN_ATTR_STYLE:
1162         {
1163             return Any( Reference< XStyle >( dynamic_cast< SfxUnoStyleSheet* >( GetStyleSheet() ) ) );
1164         }
1165         case OWN_ATTR_TABLEBORDER:
1166         {
1167             const SvxBoxInfoItem& rBoxInfoItem = static_cast<const SvxBoxInfoItem&>(mpProperties->GetItem(SDRATTR_TABLE_BORDER_INNER));
1168             const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(mpProperties->GetItem(SDRATTR_TABLE_BORDER));
1169
1170              TableBorder aTableBorder;
1171             aTableBorder.TopLine                                = lcl_SvxLineToLine(rBox.GetTop(), false);
1172             aTableBorder.IsTopLineValid                 = rBoxInfoItem.IsValid(VALID_TOP);
1173             aTableBorder.BottomLine                             = lcl_SvxLineToLine(rBox.GetBottom(), false);
1174             aTableBorder.IsBottomLineValid              = rBoxInfoItem.IsValid(VALID_BOTTOM);
1175             aTableBorder.LeftLine                               = lcl_SvxLineToLine(rBox.GetLeft(), false);
1176             aTableBorder.IsLeftLineValid                = rBoxInfoItem.IsValid(VALID_LEFT);
1177             aTableBorder.RightLine                              = lcl_SvxLineToLine(rBox.GetRight(), false);
1178             aTableBorder.IsRightLineValid               = rBoxInfoItem.IsValid(VALID_RIGHT );
1179             aTableBorder.HorizontalLine                 = lcl_SvxLineToLine(rBoxInfoItem.GetHori(), false);
1180             aTableBorder.IsHorizontalLineValid  = rBoxInfoItem.IsValid(VALID_HORI);
1181             aTableBorder.VerticalLine                   = lcl_SvxLineToLine(rBoxInfoItem.GetVert(), false);
1182             aTableBorder.IsVerticalLineValid    = rBoxInfoItem.IsValid(VALID_VERT);
1183             aTableBorder.Distance                               = rBox.GetDistance();
1184             aTableBorder.IsDistanceValid                = rBoxInfoItem.IsValid(VALID_DISTANCE);
1185
1186             return Any( aTableBorder );
1187         }
1188         case OWN_ATTR_FILLBMP_MODE:
1189         {
1190             const XFillBmpStretchItem& rStretchItem = static_cast<const XFillBmpStretchItem&>(mpProperties->GetItem(XATTR_FILLBMP_STRETCH));
1191             const XFillBmpTileItem& rTileItem = static_cast<const XFillBmpTileItem&>(mpProperties->GetItem(XATTR_FILLBMP_TILE));
1192             if( rTileItem.GetValue() )
1193             {
1194                 return Any( BitmapMode_REPEAT );
1195             }
1196             else if( rStretchItem.GetValue() )
1197             {
1198                 return Any(  BitmapMode_STRETCH );
1199             }
1200             else
1201             {
1202                 return Any(  BitmapMode_NO_REPEAT );
1203             }
1204         }
1205         default:
1206         {
1207             SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
1208             aSet.Put(mpProperties->GetItem(pMap->nWID));
1209
1210             Any aAny;
1211             if(!SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pMap, aAny ))
1212             {
1213                 if(!aSet.Count())
1214                 {
1215                     // Default aus ItemPool holen
1216                     if(GetModel()->GetItemPool().IsWhich(pMap->nWID))
1217                         aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
1218                 }
1219
1220                 if( aSet.Count() )
1221                     aAny = GetAnyForItem( aSet, pMap );
1222             }
1223
1224             return aAny;
1225         }
1226         }
1227     }
1228     throw UnknownPropertyException();
1229 }
1230
1231 // -----------------------------------------------------------------------------
1232
1233 void SAL_CALL Cell::addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1234 {
1235 }
1236
1237 // -----------------------------------------------------------------------------
1238
1239 void SAL_CALL Cell::removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1240 {
1241 }
1242
1243 // -----------------------------------------------------------------------------
1244
1245 void SAL_CALL Cell::addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1246 {
1247 }
1248
1249 // -----------------------------------------------------------------------------
1250
1251 void SAL_CALL Cell::removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1252 {
1253 }
1254
1255 // -----------------------------------------------------------------------------
1256 // XMultiPropertySet
1257 // -----------------------------------------------------------------------------
1258
1259 void SAL_CALL Cell::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues ) throw (PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1260 {
1261     OGuard aSolarGuard( Application::GetSolarMutex() );
1262
1263     if( (mpProperties == 0) || (GetModel() == 0) )
1264         throw DisposedException();
1265
1266     const sal_Int32 nCount = aPropertyNames.getLength();
1267
1268     const OUString* pNames = aPropertyNames.getConstArray();
1269     const Any* pValues = aValues.getConstArray();
1270
1271     for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
1272     {
1273         try
1274         {
1275             setPropertyValue( *pNames, *pValues );
1276         }
1277         catch( UnknownPropertyException& )
1278         {
1279             DBG_ERROR("svx::Cell::setPropertyValues(), unknown property!" );
1280         }
1281         catch( Exception& )
1282         {
1283             DBG_ERROR("svx::Cell::setPropertyValues(), Exception caught!" );
1284         }
1285     }
1286 }
1287
1288 // -----------------------------------------------------------------------------
1289
1290 Sequence< Any > SAL_CALL Cell::getPropertyValues( const Sequence< OUString >& aPropertyNames ) throw (RuntimeException)
1291 {
1292     OGuard aSolarGuard( Application::GetSolarMutex() );
1293
1294     if( (mpProperties == 0) || (GetModel() == 0) )
1295         throw DisposedException();
1296
1297     const sal_Int32 nCount = aPropertyNames.getLength();
1298     const OUString* pNames = aPropertyNames.getConstArray();
1299
1300     Sequence< Any > aRet( nCount );
1301     Any* pValue = aRet.getArray();
1302
1303     for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
1304     {
1305         try
1306         {
1307             *pValue = getPropertyValue( *pNames );
1308         }
1309         catch( UnknownPropertyException& )
1310         {
1311             DBG_ERROR("svx::Cell::setPropertyValues(), unknown property!" );
1312         }
1313         catch( Exception& )
1314         {
1315             DBG_ERROR( "svx::Cell::getPropertyValues(), Exception caught!" );
1316         }
1317     }
1318
1319     return aRet;
1320 }
1321
1322 // -----------------------------------------------------------------------------
1323
1324 void SAL_CALL Cell::addPropertiesChangeListener( const Sequence< OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
1325 {
1326 }
1327
1328 // -----------------------------------------------------------------------------
1329
1330 void SAL_CALL Cell::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
1331 {
1332 }
1333
1334 // -----------------------------------------------------------------------------
1335
1336 void SAL_CALL Cell::firePropertiesChangeEvent( const Sequence< OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
1337 {
1338 }
1339
1340 // -----------------------------------------------------------------------------
1341 // XPropertyState
1342 // -----------------------------------------------------------------------------
1343
1344 PropertyState SAL_CALL Cell::getPropertyState( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
1345 {
1346     OGuard aGuard( Application::GetSolarMutex() );
1347
1348     if( (mpProperties == 0) || (GetModel() == 0) )
1349         throw DisposedException();
1350
1351     const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1352
1353     if( pMap )
1354     {
1355         PropertyState eState;
1356         switch( pMap->nWID )
1357         {
1358         case OWN_ATTR_FILLBMP_MODE:
1359         {
1360             const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
1361
1362             const bool bStretch = rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET;
1363             const bool bTile = rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET;
1364             if( bStretch || bTile )
1365             {
1366                 eState = PropertyState_DIRECT_VALUE;
1367             }
1368             else
1369             {
1370                 eState = PropertyState_DEFAULT_VALUE;
1371             }
1372         }
1373 /*
1374         case OWN_ATTR_HASLEVELS:
1375         {
1376             return PropertyState_DIRECT_VALUE;
1377         }
1378 */
1379         case OWN_ATTR_STYLE:
1380         {
1381             return PropertyState_DIRECT_VALUE;
1382         }
1383         case OWN_ATTR_TABLEBORDER:
1384         {
1385             const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
1386             if( (rSet.GetItemState( SDRATTR_TABLE_BORDER_INNER, sal_False ) == SFX_ITEM_DEFAULT) && (rSet.GetItemState( SDRATTR_TABLE_BORDER, sal_False ) == SFX_ITEM_DEFAULT) )
1387                 return PropertyState_DEFAULT_VALUE;
1388
1389             return PropertyState_DIRECT_VALUE;
1390         }
1391         default:
1392         {
1393             const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
1394
1395             switch( rSet.GetItemState( pMap->nWID, sal_False ) )
1396             {
1397             case SFX_ITEM_READONLY:
1398             case SFX_ITEM_SET:
1399                 eState = PropertyState_DIRECT_VALUE;
1400                 break;
1401             case SFX_ITEM_DEFAULT:
1402                 eState = PropertyState_DEFAULT_VALUE;
1403                 break;
1404     //          case SFX_ITEM_UNKNOWN:
1405     //          case SFX_ITEM_DONTCARE:
1406     //          case SFX_ITEM_DISABLED:
1407             default:
1408                 eState = PropertyState_AMBIGUOUS_VALUE;
1409                 break;
1410             }
1411
1412             // if a item is set, this doesn't mean we want it :)
1413             if( ( PropertyState_DIRECT_VALUE == eState ) )
1414             {
1415                 switch( pMap->nWID )
1416                 {
1417                 // the following items are disabled by changing the
1418                 // fill style or the line style. so there is no need
1419                 // to export items without names which should be empty
1420                 case XATTR_FILLBITMAP:
1421                 case XATTR_FILLGRADIENT:
1422                 case XATTR_FILLHATCH:
1423                 case XATTR_LINEDASH:
1424                     {
1425                         NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((USHORT)pMap->nWID);
1426                         if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) )
1427                             eState = PropertyState_DEFAULT_VALUE;
1428                     }
1429                     break;
1430
1431                 // #i36115#
1432                 // If e.g. the LineStart is on NONE and thus the string has length 0, it still
1433                 // may be a hard attribute covering the set LineStart of the parent (Style).
1434                 // #i37644#
1435                 // same is for fill float transparency
1436                 case XATTR_LINEEND:
1437                 case XATTR_LINESTART:
1438                 case XATTR_FILLFLOATTRANSPARENCE:
1439                     {
1440                         NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((USHORT)pMap->nWID);
1441                         if( ( pItem == NULL ) )
1442                             eState = PropertyState_DEFAULT_VALUE;
1443                     }
1444                     break;
1445                 }
1446             }
1447         }
1448         }
1449         return eState;
1450     }
1451     throw UnknownPropertyException();
1452 }
1453
1454 // -----------------------------------------------------------------------------
1455
1456 Sequence< PropertyState > SAL_CALL Cell::getPropertyStates( const Sequence< OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException)
1457 {
1458     OGuard aGuard( Application::GetSolarMutex() );
1459
1460     if( (mpProperties == 0) || (GetModel() == 0) )
1461         throw DisposedException();
1462
1463     const sal_Int32 nCount = aPropertyName.getLength();
1464
1465     Sequence< PropertyState > aRet( nCount );
1466
1467     const OUString* pNames = aPropertyName.getConstArray();
1468     PropertyState* pState = aRet.getArray();
1469
1470     for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pState++ )
1471     {
1472         try
1473         {
1474             *pState = getPropertyState( *pNames );
1475         }
1476         catch( Exception& )
1477         {
1478             *pState = PropertyState_AMBIGUOUS_VALUE;
1479         }
1480     }
1481
1482     return aRet;
1483 }
1484
1485 // -----------------------------------------------------------------------------
1486
1487 void SAL_CALL Cell::setPropertyToDefault( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
1488 {
1489     OGuard aGuard( Application::GetSolarMutex() );
1490
1491     if( (mpProperties == 0) || (GetModel() == 0) )
1492         throw DisposedException();
1493
1494     const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1495     if( pMap )
1496     {
1497         switch( pMap->nWID )
1498         {
1499         case OWN_ATTR_FILLBMP_MODE:
1500         {
1501             mpProperties->ClearObjectItem( XATTR_FILLBMP_STRETCH );
1502             mpProperties->ClearObjectItem( XATTR_FILLBMP_TILE );
1503             break;
1504         }
1505 //              case OWN_ATTR_HASLEVELS:
1506         case OWN_ATTR_STYLE:
1507             break;
1508
1509         case OWN_ATTR_TABLEBORDER:
1510         {
1511             mpProperties->ClearObjectItem( SDRATTR_TABLE_BORDER_INNER );
1512             mpProperties->ClearObjectItem( SDRATTR_TABLE_BORDER );
1513             break;
1514         }
1515
1516         default:
1517         {
1518             mpProperties->ClearObjectItem( pMap->nWID );
1519         }
1520         }
1521
1522         GetModel()->SetChanged();
1523         return;
1524     }
1525     throw UnknownPropertyException();
1526 }
1527
1528 // -----------------------------------------------------------------------------
1529
1530 Any SAL_CALL Cell::getPropertyDefault( const OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1531 {
1532     OGuard aGuard( Application::GetSolarMutex() );
1533
1534     if( (mpProperties == 0) || (GetModel() == 0) )
1535         throw DisposedException();
1536
1537     const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName);
1538     if( pMap )
1539     {
1540         switch( pMap->nWID )
1541         {
1542         case OWN_ATTR_FILLBMP_MODE:
1543             return Any(  BitmapMode_NO_REPEAT );
1544
1545 /*
1546         case OWN_ATTR_HASLEVELS:
1547             return Any( sal_False );
1548 */
1549         case OWN_ATTR_STYLE:
1550         {
1551             Reference< XStyle > xStyle;
1552             return Any( xStyle );
1553         }
1554
1555         case OWN_ATTR_TABLEBORDER:
1556         {
1557             TableBorder aBorder;
1558             return Any( aBorder );
1559         }
1560
1561         default:
1562         {
1563             if(  GetModel()->GetItemPool().IsWhich(pMap->nWID) )
1564             {
1565                 SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
1566                 aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
1567                 return GetAnyForItem( aSet, pMap );
1568             }
1569         }
1570         }
1571     }
1572     throw UnknownPropertyException();
1573 }
1574
1575 // -----------------------------------------------------------------------------
1576 // XMultiPropertyStates
1577 // -----------------------------------------------------------------------------
1578
1579 void SAL_CALL Cell::setAllPropertiesToDefault(  ) throw (RuntimeException)
1580 {
1581     if( mpProperties )
1582         delete mpProperties;
1583     mpProperties = new sdr::properties::CellProperties( static_cast< SdrTableObj& >( GetObject() ), this );
1584
1585     SdrOutliner& rOutliner = GetObject().ImpGetDrawOutliner();
1586
1587     OutlinerParaObject* pParaObj = GetOutlinerParaObject();
1588     if( pParaObj )
1589     {
1590         rOutliner.SetText(*pParaObj);
1591         sal_uInt32 nParaCount(rOutliner.GetParagraphCount());
1592
1593         if(nParaCount)
1594         {
1595             ESelection aSelection( 0, 0, EE_PARA_ALL, EE_PARA_ALL);
1596             rOutliner.RemoveAttribs(aSelection, sal_True, 0);
1597
1598             OutlinerParaObject* pTemp = rOutliner.CreateParaObject(0, (sal_uInt16)nParaCount);
1599             rOutliner.Clear();
1600
1601             SetOutlinerParaObject(pTemp);
1602         }
1603     }
1604 }
1605
1606 // -----------------------------------------------------------------------------
1607
1608 void SAL_CALL Cell::setPropertiesToDefault( const Sequence< OUString >& aPropertyNames ) throw (UnknownPropertyException, RuntimeException)
1609 {
1610     sal_Int32 nCount = aPropertyNames.getLength();
1611     const OUString* pName = aPropertyNames.getConstArray();
1612
1613     while(nCount--)
1614         setPropertyToDefault( *pName++ );
1615 }
1616
1617 // -----------------------------------------------------------------------------
1618
1619 Sequence< Any > SAL_CALL Cell::getPropertyDefaults( const Sequence< OUString >& aPropertyNames ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
1620 {
1621     sal_Int32 nCount = aPropertyNames.getLength();
1622     Sequence< Any > aDefaults( nCount );
1623     Any* pDefaults = aDefaults.getArray();
1624     const OUString* pName = aPropertyNames.getConstArray();
1625
1626     while(nCount--)
1627         *pDefaults++ = getPropertyDefault( *pName++ );
1628
1629     return aDefaults;
1630 }
1631
1632 // -----------------------------------------------------------------------------
1633 // XFastPropertySet
1634 // -----------------------------------------------------------------------------
1635
1636 void SAL_CALL Cell::setFastPropertyValue( sal_Int32 nHandle, const Any& aValue ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1637 {
1638     (void)aValue;
1639     (void)nHandle;
1640     throw UnknownPropertyException();
1641 }
1642
1643 // -----------------------------------------------------------------------------
1644 // TODO: Refactor this method!
1645 Any SAL_CALL Cell::getFastPropertyValue( sal_Int32 nHandle ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
1646 {
1647     (void)nHandle;
1648     throw UnknownPropertyException();
1649 }
1650
1651 // -----------------------------------------------------------------------------
1652 // XText
1653 // -----------------------------------------------------------------------------
1654
1655 void SAL_CALL Cell::insertTextContent( const Reference< XTextRange >& xRange, const Reference< XTextContent >& xContent, sal_Bool bAbsorb ) throw (IllegalArgumentException, RuntimeException)
1656 {
1657     SvxUnoTextBase::insertTextContent( xRange, xContent, bAbsorb );
1658     notifyModified();
1659 }
1660
1661 // -----------------------------------------------------------------------------
1662
1663 void SAL_CALL Cell::removeTextContent( const Reference< XTextContent >& xContent ) throw (NoSuchElementException, RuntimeException)
1664 {
1665     SvxUnoTextBase::removeTextContent( xContent );
1666     notifyModified();
1667 }
1668
1669 // -----------------------------------------------------------------------------
1670 // XSimpleText
1671 // -----------------------------------------------------------------------------
1672
1673 Reference< XTextCursor > SAL_CALL Cell::createTextCursor(  ) throw (RuntimeException)
1674 {
1675     return SvxUnoTextBase::createTextCursor();
1676 }
1677
1678 // -----------------------------------------------------------------------------
1679
1680 Reference< XTextCursor > SAL_CALL Cell::createTextCursorByRange( const Reference< XTextRange >& aTextPosition ) throw (RuntimeException)
1681 {
1682     return SvxUnoTextBase::createTextCursorByRange( aTextPosition );
1683 }
1684
1685 // -----------------------------------------------------------------------------
1686
1687 void SAL_CALL Cell::insertString( const Reference< XTextRange >& xRange, const OUString& aString, sal_Bool bAbsorb ) throw (RuntimeException)
1688 {
1689     SvxUnoTextBase::insertString( xRange, aString, bAbsorb );
1690     notifyModified();
1691 }
1692
1693 // -----------------------------------------------------------------------------
1694
1695 void SAL_CALL Cell::insertControlCharacter( const Reference< XTextRange >& xRange, sal_Int16 nControlCharacter, sal_Bool bAbsorb ) throw (IllegalArgumentException, RuntimeException)
1696 {
1697     SvxUnoTextBase::insertControlCharacter( xRange, nControlCharacter, bAbsorb );
1698     notifyModified();
1699 }
1700
1701 // -----------------------------------------------------------------------------
1702 // XTextRange
1703 // -----------------------------------------------------------------------------
1704
1705 Reference< XText > SAL_CALL Cell::getText(  ) throw (RuntimeException)
1706 {
1707     return SvxUnoTextBase::getText();
1708 }
1709
1710 // -----------------------------------------------------------------------------
1711
1712 Reference< XTextRange > SAL_CALL Cell::getStart(  ) throw (RuntimeException)
1713 {
1714     return SvxUnoTextBase::getStart();
1715 }
1716
1717 // -----------------------------------------------------------------------------
1718
1719 Reference< XTextRange > SAL_CALL Cell::getEnd(  ) throw (RuntimeException)
1720 {
1721     return SvxUnoTextBase::getEnd();
1722 }
1723
1724 // -----------------------------------------------------------------------------
1725
1726 OUString SAL_CALL Cell::getString(  ) throw (RuntimeException)
1727 {
1728     maSelection.nStartPara = 0xffff;
1729     return SvxUnoTextBase::getString();
1730 }
1731
1732 // -----------------------------------------------------------------------------
1733
1734 void SAL_CALL Cell::setString( const OUString& aString ) throw (RuntimeException)
1735 {
1736     SvxUnoTextBase::setString( aString );
1737     notifyModified();
1738 }
1739
1740 // XEventListener
1741 void SAL_CALL Cell::disposing( const EventObject& /*Source*/ ) throw (RuntimeException)
1742 {
1743     mxTable.clear();
1744     dispose();
1745 }
1746
1747 static OUString getCellName( sal_Int32 nCol, sal_Int32 nRow )
1748 {
1749     rtl::OUStringBuffer aBuf;
1750
1751     if (nCol < 26*26)
1752     {
1753         if (nCol < 26)
1754             aBuf.append( static_cast<sal_Unicode>( 'A' +
1755                         static_cast<sal_uInt16>(nCol)));
1756         else
1757         {
1758             aBuf.append( static_cast<sal_Unicode>( 'A' +
1759                         (static_cast<sal_uInt16>(nCol) / 26) - 1));
1760             aBuf.append( static_cast<sal_Unicode>( 'A' +
1761                         (static_cast<sal_uInt16>(nCol) % 26)));
1762         }
1763     }
1764     else
1765     {
1766         String aStr;
1767         while (nCol >= 26)
1768         {
1769             sal_Int32 nC = nCol % 26;
1770             aStr += static_cast<sal_Unicode>( 'A' +
1771                     static_cast<sal_uInt16>(nC));
1772             nCol = nCol - nC;
1773             nCol = nCol / 26 - 1;
1774         }
1775         aStr += static_cast<sal_Unicode>( 'A' +
1776                 static_cast<sal_uInt16>(nCol));
1777         aStr.Reverse();
1778         aBuf.append( aStr);
1779     }
1780     aBuf.append( OUString::valueOf(nRow+1) );
1781     return aBuf.makeStringAndClear();
1782 }
1783
1784 OUString Cell::getName()
1785 {
1786     // todo: optimize!
1787     OUString sName;
1788     if( mxTable.is() ) try
1789     {
1790         Reference< XCell > xThis( static_cast< XCell* >( this ) );
1791
1792         sal_Int32 nRowCount = mxTable->getRowCount();
1793         sal_Int32 nColCount = mxTable->getColumnCount();
1794         for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
1795         {
1796             for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
1797             {
1798                 Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) );
1799                 if( xCell == xThis )
1800                 {
1801                     return getCellName( nCol, nRow );
1802                 }
1803             }
1804         }
1805     }
1806     catch( Exception& )
1807     {
1808     }
1809
1810     return sName;
1811 }
1812
1813 } }
1814