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