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