svx/source/table/cell.cxx

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