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