sc/source/ui/unoobj/notesuno.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: notesuno.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33 #include <svtools/smplhint.hxx>
  34
  35
  36 #include "rangelst.hxx"
  37 #include <svx/unotext.hxx>
  38
  39 #include "notesuno.hxx"
  40 #include "textuno.hxx"
  41 #include "cellsuno.hxx"         // getParent
  42 #include "docsh.hxx"
  43 #include "docfunc.hxx"
  44 #include "hints.hxx"
  45 #include "editsrc.hxx"
  46 #include "miscuno.hxx"
  47
  48 // setVisible:
  49 #include <svx/svdundo.hxx>
  50 #include "drwlayer.hxx"
  51 #include "detfunc.hxx"
  52 #include "undocell.hxx"
  53 #include "unoguard.hxx"
  54 #include "userdat.hxx"
  55 #include <svx/outlobj.hxx>
  56 #include <svx/unoshape.hxx>
  57 #include <svx/svdocapt.hxx>
  58 #include <svx/svditer.hxx>
  59 #include <svx/svdpage.hxx>
  60 #include <com/sun/star/drawing/XShapeDescriptor.hpp>
  61
  62 using namespace com::sun::star;
  63
  64 //------------------------------------------------------------------------
  65
  66 //      keine Properties fuer Text in Notizen
  67 const SvxItemPropertySet* lcl_GetAnnotationPropertySet()
  68 {
  69     static SfxItemPropertyMapEntry aAnnotationPropertyMap_Impl[] =
  70     {
  71         {0,0,0,0,0,0}
  72     };
  73     static SvxItemPropertySet aAnnotationPropertySet_Impl( aAnnotationPropertyMap_Impl );
  74     return &aAnnotationPropertySet_Impl;
  75 }
  76
  77 //------------------------------------------------------------------------
  78
  79 SC_SIMPLE_SERVICE_INFO( ScAnnotationObj, "ScAnnotationObj", "com.sun.star.sheet.CellAnnotation" )
  80 SC_SIMPLE_SERVICE_INFO( ScAnnotationShapeObj, "ScAnnotationShapeObj", "com.sun.star.sheet.CellAnnotationShape" )
  81
  82 //------------------------------------------------------------------------
  83
  84 ScAnnotationObj::ScAnnotationObj(ScDocShell* pDocSh, const ScAddress& rPos) :
  85     pDocShell( pDocSh ),
  86     aCellPos( rPos ),
  87     pUnoText( NULL )
  88 {
  89     pDocShell->GetDocument()->AddUnoObject(*this);
  90
  91     //  pUnoText is allocated on demand (GetUnoText)
  92     //  can't be aggregated because getString/setString is handled here
  93 }
  94
  95 ScAnnotationObj::~ScAnnotationObj()
  96 {
  97     if (pDocShell)
  98         pDocShell->GetDocument()->RemoveUnoObject(*this);
  99
 100     if (pUnoText)
 101         pUnoText->release();
 102 }
 103
 104 void ScAnnotationObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 105 {
 106     if ( rHint.ISA( ScUpdateRefHint ) )
 107     {
 108 //        const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
 109
 110         //!     Ref-Update
 111     }
 112     else if ( rHint.ISA( SfxSimpleHint ) &&
 113             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 114     {
 115         pDocShell = NULL;               // ungueltig geworden
 116     }
 117 }
 118
 119
 120 // XChild
 121
 122 uno::Reference<uno::XInterface> SAL_CALL ScAnnotationObj::getParent() throw(uno::RuntimeException)
 123 {
 124     ScUnoGuard aGuard;
 125
 126     //  Parent der Notiz ist die zugehoerige Zelle
 127     //! existierendes Objekt finden und zurueckgeben ???
 128
 129     if (pDocShell)
 130         return (cppu::OWeakObject*)new ScCellObj( pDocShell, aCellPos );
 131
 132     return NULL;
 133 }
 134
 135 void SAL_CALL ScAnnotationObj::setParent( const uno::Reference<uno::XInterface>& /* Parent */ )
 136                                     throw(lang::NoSupportException, uno::RuntimeException)
 137 {
 138     //  hamma nich
 139     //! Exception oder so ??!
 140 }
 141
 142 // XSimpleText
 143
 144 uno::Reference<text::XTextCursor> SAL_CALL ScAnnotationObj::createTextCursor()
 145                                                     throw(uno::RuntimeException)
 146 {
 147     ScUnoGuard aGuard;
 148     //  Notizen brauchen keine Extrawurst
 149     return GetUnoText().createTextCursor();
 150 }
 151
 152 uno::Reference<text::XTextCursor> SAL_CALL ScAnnotationObj::createTextCursorByRange(
 153                                     const uno::Reference<text::XTextRange>& aTextPosition )
 154                                                     throw(uno::RuntimeException)
 155 {
 156     ScUnoGuard aGuard;
 157     //  Notizen brauchen keine Extrawurst
 158     return GetUnoText().createTextCursorByRange(aTextPosition);
 159 }
 160
 161 rtl::OUString SAL_CALL ScAnnotationObj::getString() throw(uno::RuntimeException)
 162 {
 163     ScUnoGuard aGuard;
 164     return GetUnoText().getString();
 165 }
 166
 167 void SAL_CALL ScAnnotationObj::setString( const rtl::OUString& aText ) throw(uno::RuntimeException)
 168 {
 169     ScUnoGuard aGuard;
 170     GetUnoText().setString(aText);
 171 }
 172
 173 void SAL_CALL ScAnnotationObj::insertString( const uno::Reference<text::XTextRange>& xRange,
 174                                             const rtl::OUString& aString, sal_Bool bAbsorb )
 175                                 throw(uno::RuntimeException)
 176 {
 177     ScUnoGuard aGuard;
 178     GetUnoText().insertString( xRange, aString, bAbsorb );
 179 }
 180
 181 void SAL_CALL ScAnnotationObj::insertControlCharacter( const uno::Reference<text::XTextRange>& xRange,
 182                                             sal_Int16 nControlCharacter, sal_Bool bAbsorb )
 183                                 throw(lang::IllegalArgumentException, uno::RuntimeException)
 184 {
 185     ScUnoGuard aGuard;
 186     GetUnoText().insertControlCharacter( xRange, nControlCharacter, bAbsorb );
 187 }
 188
 189 uno::Reference<text::XText> SAL_CALL ScAnnotationObj::getText() throw(uno::RuntimeException)
 190 {
 191     ScUnoGuard aGuard;
 192     return GetUnoText().getText();
 193 }
 194
 195 uno::Reference<text::XTextRange> SAL_CALL ScAnnotationObj::getStart() throw(uno::RuntimeException)
 196 {
 197     ScUnoGuard aGuard;
 198     return GetUnoText().getStart();
 199 }
 200
 201 uno::Reference<text::XTextRange> SAL_CALL ScAnnotationObj::getEnd() throw(uno::RuntimeException)
 202 {
 203     ScUnoGuard aGuard;
 204     return GetUnoText().getEnd();
 205 }
 206
 207 // XSheetAnnotation
 208
 209 table::CellAddress SAL_CALL ScAnnotationObj::getPosition() throw(uno::RuntimeException)
 210 {
 211     ScUnoGuard aGuard;
 212     table::CellAddress aAdr;
 213     aAdr.Sheet  = aCellPos.Tab();
 214     aAdr.Column = aCellPos.Col();
 215     aAdr.Row    = aCellPos.Row();
 216     return aAdr;
 217 }
 218
 219 rtl::OUString SAL_CALL ScAnnotationObj::getAuthor() throw(uno::RuntimeException)
 220 {
 221     ScUnoGuard aGuard;
 222     const ScPostIt* pNote = ImplGetNote();
 223     return pNote ? pNote->GetAuthor() : rtl::OUString();
 224 }
 225
 226 rtl::OUString SAL_CALL ScAnnotationObj::getDate() throw(uno::RuntimeException)
 227 {
 228     ScUnoGuard aGuard;
 229     const ScPostIt* pNote = ImplGetNote();
 230     return pNote ? pNote->GetDate() : rtl::OUString();
 231 }
 232
 233 sal_Bool SAL_CALL ScAnnotationObj::getIsVisible() throw(uno::RuntimeException)
 234 {
 235     ScUnoGuard aGuard;
 236     const ScPostIt* pNote = ImplGetNote();
 237     return pNote && pNote->IsCaptionShown();
 238 }
 239
 240 void SAL_CALL ScAnnotationObj::setIsVisible( sal_Bool bIsVisible ) throw(uno::RuntimeException)
 241 {
 242     ScUnoGuard aGuard;
 243     // show/hide note with undo action
 244     if( pDocShell )
 245         pDocShell->GetDocFunc().ShowNote( aCellPos, bIsVisible );
 246 }
 247
 248 // XSheetAnnotationShapeSupplier
 249 uno::Reference < drawing::XShape > SAL_CALL ScAnnotationObj::getAnnotationShape()
 250                                 throw(::com::sun::star::uno::RuntimeException)
 251 {
 252     ScUnoGuard aGuard;
 253     return new ScAnnotationShapeObj(pDocShell, aCellPos);
 254 }
 255
 256 SvxUnoText& ScAnnotationObj::GetUnoText()
 257 {
 258     if (!pUnoText)
 259     {
 260         ScAnnotationEditSource aEditSource( pDocShell, aCellPos );
 261         pUnoText = new SvxUnoText( &aEditSource, lcl_GetAnnotationPropertySet(),
 262                                     uno::Reference<text::XText>() );
 263         pUnoText->acquire();
 264     }
 265     return *pUnoText;
 266 }
 267
 268 const ScPostIt* ScAnnotationObj::ImplGetNote() const
 269 {
 270     return pDocShell ? pDocShell->GetDocument()->GetNote( aCellPos ) : 0;
 271 }
 272 //------------------------------------------------------------------------
 273
 274 ScAnnotationShapeObj::ScAnnotationShapeObj(ScDocShell* pDocSh, const ScAddress& rPos) :
 275     pDocShell( pDocSh ),
 276     aCellPos( rPos ),
 277     pUnoText( NULL )
 278 {
 279     pDocShell->GetDocument()->AddUnoObject(*this);
 280
 281     //  pUnoText is allocated on demand (GetUnoText)
 282     //  can't be aggregated because getString/setString is handled here
 283 }
 284
 285 SvxUnoText&     ScAnnotationShapeObj::GetUnoText()
 286 {
 287     if (!pUnoText)
 288     {
 289         ScAnnotationEditSource aEditSource( pDocShell, aCellPos );
 290         pUnoText = new SvxUnoText( &aEditSource, lcl_GetAnnotationPropertySet(),
 291                                     uno::Reference<text::XText>() );
 292         pUnoText->acquire();
 293     }
 294     return *pUnoText;
 295 }
 296
 297 uno::Reference < drawing::XShape > ScAnnotationShapeObj::GetXShape()
 298 {
 299     if (!xShape.is())
 300         if( ScPostIt* pNote = pDocShell->GetDocument()->GetNote( aCellPos ) )
 301             if( SdrObject* pCaption = pNote->GetOrCreateCaption( aCellPos ) )
 302                 xShape.set( pCaption->getUnoShape(), uno::UNO_QUERY );
 303     return xShape;
 304 }
 305
 306 ScAnnotationShapeObj::~ScAnnotationShapeObj()
 307 {
 308     if (pDocShell)
 309         pDocShell->GetDocument()->RemoveUnoObject(*this);
 310     if (pUnoText)
 311         pUnoText->release();
 312 }
 313
 314 void ScAnnotationShapeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 315 {
 316     if ( rHint.ISA( ScUpdateRefHint ) )
 317     {
 318 //        const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
 319
 320         //!     Ref-Update
 321     }
 322     else if ( rHint.ISA( SfxSimpleHint ) &&
 323             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 324     {
 325         pDocShell = NULL;               // ungueltig geworden
 326     }
 327 }
 328
 329
 330 // XChild
 331
 332 uno::Reference<uno::XInterface> SAL_CALL ScAnnotationShapeObj::getParent() throw(uno::RuntimeException)
 333 {
 334     ScUnoGuard aGuard;
 335
 336     //  Parent der Notiz ist die zugehoerige Zelle
 337     //! existierendes Objekt finden und zurueckgeben ???
 338
 339     if (pDocShell)
 340         return (cppu::OWeakObject*)new ScCellObj( pDocShell, aCellPos );
 341
 342     return NULL;
 343 }
 344
 345 void SAL_CALL ScAnnotationShapeObj::setParent( const uno::Reference<uno::XInterface>& /* Parent */ )
 346                                     throw(lang::NoSupportException, uno::RuntimeException)
 347 {
 348     //  hamma nich
 349     //! Exception oder so ??!
 350 }
 351
 352 // XElementAccess
 353 uno::Type SAL_CALL ScAnnotationShapeObj::getElementType(  ) throw (uno::RuntimeException)
 354 {
 355     ScUnoGuard aGuard;
 356
 357     return GetUnoText().getElementType();
 358 }
 359
 360 sal_Bool SAL_CALL ScAnnotationShapeObj::hasElements(  ) throw (uno::RuntimeException)
 361 {
 362     ScUnoGuard aGuard;
 363
 364     return GetUnoText().hasElements();
 365 }
 366
 367 // XEnumerationAccess
 368 uno::Reference< container::XEnumeration > SAL_CALL ScAnnotationShapeObj::createEnumeration(  ) throw (uno::RuntimeException)
 369 {
 370     ScUnoGuard aGuard;
 371
 372     return GetUnoText().createEnumeration();
 373 }
 374
 375 // XTextRangeMover
 376 void SAL_CALL ScAnnotationShapeObj::moveTextRange( const uno::Reference< text::XTextRange >& xRange, sal_Int16 nParagraphs )
 377                                 throw (uno::RuntimeException)
 378 {
 379     ScUnoGuard aGuard;
 380
 381     GetUnoText().moveTextRange( xRange, nParagraphs );
 382 }
 383
 384 // XText
 385 void SAL_CALL ScAnnotationShapeObj::insertTextContent( const uno::Reference< text::XTextRange >& xRange,
 386                                     const uno::Reference< text::XTextContent >& xContent, sal_Bool bAbsorb )
 387                                     throw (lang::IllegalArgumentException,
 388                                         uno::RuntimeException)
 389 {
 390     ScUnoGuard aGuard;
 391
 392     GetUnoText().insertTextContent( xRange, xContent, bAbsorb );
 393 }
 394
 395 void SAL_CALL ScAnnotationShapeObj::removeTextContent( const uno::Reference< text::XTextContent >& xContent )
 396                                     throw (container::NoSuchElementException,
 397                                         uno::RuntimeException)
 398 {
 399     ScUnoGuard aGuard;
 400
 401     GetUnoText().removeTextContent( xContent );
 402 }
 403
 404 // XSimpleText
 405
 406 uno::Reference<text::XTextCursor> SAL_CALL ScAnnotationShapeObj::createTextCursor()
 407                                                     throw(uno::RuntimeException)
 408 {
 409     ScUnoGuard aGuard;
 410     //  Notizen brauchen keine Extrawurst
 411     return GetUnoText().createTextCursor();
 412 }
 413
 414 uno::Reference<text::XTextCursor> SAL_CALL ScAnnotationShapeObj::createTextCursorByRange(
 415                                     const uno::Reference<text::XTextRange>& aTextPosition )
 416                                                     throw(uno::RuntimeException)
 417 {
 418     ScUnoGuard aGuard;
 419     //  Notizen brauchen keine Extrawurst
 420     return GetUnoText().createTextCursorByRange(aTextPosition);
 421 }
 422
 423 rtl::OUString SAL_CALL ScAnnotationShapeObj::getString() throw(uno::RuntimeException)
 424 {
 425     ScUnoGuard aGuard;
 426     return GetUnoText().getString();
 427 }
 428
 429 void SAL_CALL ScAnnotationShapeObj::setString( const rtl::OUString& aText ) throw(uno::RuntimeException)
 430 {
 431     ScUnoGuard aGuard;
 432     GetUnoText().setString(aText);
 433 }
 434
 435 void SAL_CALL ScAnnotationShapeObj::insertString( const uno::Reference<text::XTextRange>& xRange,
 436                                             const rtl::OUString& aString, sal_Bool bAbsorb )
 437                                 throw(uno::RuntimeException)
 438 {
 439     ScUnoGuard aGuard;
 440     GetUnoText().insertString( xRange, aString, bAbsorb );
 441 }
 442
 443 void SAL_CALL ScAnnotationShapeObj::insertControlCharacter( const uno::Reference<text::XTextRange>& xRange,
 444                                             sal_Int16 nControlCharacter, sal_Bool bAbsorb )
 445                                 throw(lang::IllegalArgumentException, uno::RuntimeException)
 446 {
 447     ScUnoGuard aGuard;
 448     GetUnoText().insertControlCharacter( xRange, nControlCharacter, bAbsorb );
 449 }
 450
 451 uno::Reference<text::XText> SAL_CALL ScAnnotationShapeObj::getText() throw(uno::RuntimeException)
 452 {
 453     ScUnoGuard aGuard;
 454     return GetUnoText().getText();
 455 }
 456
 457 uno::Reference<text::XTextRange> SAL_CALL ScAnnotationShapeObj::getStart() throw(uno::RuntimeException)
 458 {
 459     ScUnoGuard aGuard;
 460     return GetUnoText().getStart();
 461 }
 462
 463 uno::Reference<text::XTextRange> SAL_CALL ScAnnotationShapeObj::getEnd() throw(uno::RuntimeException)
 464 {
 465     ScUnoGuard aGuard;
 466     return GetUnoText().getEnd();
 467 }
 468
 469 // XShapeDescriptor
 470 ::rtl::OUString SAL_CALL ScAnnotationShapeObj::getShapeType(  )
 471     throw (uno::RuntimeException)
 472 {
 473     ScUnoGuard aGuard;
 474     uno::Reference < drawing::XShapeDescriptor > xDesc(GetXShape(), uno::UNO_QUERY);
 475     if (xDesc.is())
 476         return xDesc->getShapeType();
 477     return rtl::OUString();
 478 }
 479
 480 // XShape
 481 awt::Point SAL_CALL ScAnnotationShapeObj::getPosition(  )
 482     throw (uno::RuntimeException)
 483 {
 484     ScUnoGuard aGuard;
 485     GetXShape();
 486     return xShape.is() ? xShape->getPosition() : awt::Point();
 487 }
 488
 489 void SAL_CALL ScAnnotationShapeObj::setPosition( const awt::Point& aPosition )
 490     throw (uno::RuntimeException)
 491 {
 492     ScUnoGuard aGuard;
 493     GetXShape();
 494     if( xShape.is() )
 495         xShape->setPosition(aPosition);
 496 }
 497
 498 awt::Size SAL_CALL ScAnnotationShapeObj::getSize(  )
 499     throw (uno::RuntimeException)
 500 {
 501     ScUnoGuard aGuard;
 502     GetXShape();
 503     return xShape.is() ? xShape->getSize() : awt::Size();
 504 }
 505
 506 void SAL_CALL ScAnnotationShapeObj::setSize( const awt::Size& aSize )
 507     throw (beans::PropertyVetoException, uno::RuntimeException)
 508 {
 509     ScUnoGuard aGuard;
 510     GetXShape();
 511     if( xShape.is() )
 512         xShape->setSize(aSize);
 513 }
 514
 515 // XPropertyState
 516 beans::PropertyState SAL_CALL ScAnnotationShapeObj::getPropertyState( const rtl::OUString& PropertyName )
 517                                     throw (beans::UnknownPropertyException,
 518                                         uno::RuntimeException)
 519 {
 520     ScUnoGuard aGuard;
 521     uno::Reference < beans::XPropertyState > xState (GetXShape(), uno::UNO_QUERY);
 522     if (xState.is())
 523         return xState->getPropertyState( PropertyName );
 524     return beans::PropertyState();
 525 }
 526
 527 uno::Sequence< beans::PropertyState > SAL_CALL ScAnnotationShapeObj::getPropertyStates(
 528                                     const uno::Sequence< rtl::OUString >& aPropertyName )
 529                                     throw (beans::UnknownPropertyException,
 530                                         uno::RuntimeException)
 531 {
 532     ScUnoGuard aGuard;
 533     uno::Reference < beans::XPropertyState > xState (GetXShape(), uno::UNO_QUERY);
 534     if (xState.is())
 535         return xState->getPropertyStates( aPropertyName );
 536     return uno::Sequence< beans::PropertyState >();
 537 }
 538
 539 void SAL_CALL ScAnnotationShapeObj::setPropertyToDefault( const ::rtl::OUString& PropertyName )
 540                                     throw (::com::sun::star::beans::UnknownPropertyException,
 541                                         ::com::sun::star::uno::RuntimeException)
 542 {
 543     ScUnoGuard aGuard;
 544     uno::Reference < beans::XPropertyState > xState (GetXShape(), uno::UNO_QUERY);
 545     if (xState.is())
 546         xState->setPropertyToDefault( PropertyName );
 547 }
 548
 549 uno::Any SAL_CALL ScAnnotationShapeObj::getPropertyDefault( const rtl::OUString& aPropertyName )
 550                                     throw (beans::UnknownPropertyException,
 551                                         lang::WrappedTargetException, uno::RuntimeException)
 552 {
 553     ScUnoGuard aGuard;
 554     uno::Reference < beans::XPropertyState > xState (GetXShape(), uno::UNO_QUERY);
 555     if (xState.is())
 556         return xState->getPropertyDefault( aPropertyName );
 557     return uno::Any();
 558 }
 559
 560 // XPropertySet
 561 uno::Reference< beans::XPropertySetInfo > SAL_CALL ScAnnotationShapeObj::getPropertySetInfo(  )
 562                                     throw (uno::RuntimeException)
 563 {
 564     ScUnoGuard aGuard;
 565     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 566     if (xProp.is())
 567         return xProp->getPropertySetInfo();
 568     return uno::Reference< beans::XPropertySetInfo >();
 569 }
 570
 571 void SAL_CALL ScAnnotationShapeObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue )
 572                                     throw (beans::UnknownPropertyException,
 573                                         beans::PropertyVetoException,
 574                                         lang::IllegalArgumentException,
 575                                         lang::WrappedTargetException,
 576                                         uno::RuntimeException)
 577 {
 578     ScUnoGuard aGuard;
 579     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 580     if (xProp.is())
 581         xProp->setPropertyValue( aPropertyName, aValue );
 582 }
 583
 584 uno::Any SAL_CALL ScAnnotationShapeObj::getPropertyValue( const rtl::OUString& PropertyName )
 585                                     throw (beans::UnknownPropertyException,
 586                                         lang::WrappedTargetException,
 587                                         uno::RuntimeException)
 588 {
 589     ScUnoGuard aGuard;
 590     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 591     if (xProp.is())
 592         return xProp->getPropertyValue( PropertyName );
 593     return uno::Any();
 594 }
 595
 596 void SAL_CALL ScAnnotationShapeObj::addPropertyChangeListener( const rtl::OUString& aPropertyName,
 597                                     const uno::Reference< beans::XPropertyChangeListener >& xListener )
 598                                     throw (beans::UnknownPropertyException,
 599                                         lang::WrappedTargetException,
 600                                         uno::RuntimeException)
 601 {
 602     ScUnoGuard aGuard;
 603     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 604     if (xProp.is())
 605         return xProp->addPropertyChangeListener( aPropertyName, xListener );
 606 }
 607
 608 void SAL_CALL ScAnnotationShapeObj::removePropertyChangeListener( const rtl::OUString& aPropertyName,
 609                                     const uno::Reference< beans::XPropertyChangeListener >& aListener )
 610                                     throw (beans::UnknownPropertyException,
 611                                         lang::WrappedTargetException,
 612                                         uno::RuntimeException)
 613 {
 614     ScUnoGuard aGuard;
 615     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 616     if (xProp.is())
 617         return xProp->removePropertyChangeListener( aPropertyName, aListener );
 618 }
 619
 620 void SAL_CALL ScAnnotationShapeObj::addVetoableChangeListener( const rtl::OUString& PropertyName,
 621                                     const uno::Reference< beans::XVetoableChangeListener >& aListener )
 622                                     throw (beans::UnknownPropertyException,
 623                                         lang::WrappedTargetException,
 624                                         uno::RuntimeException)
 625 {
 626     ScUnoGuard aGuard;
 627     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 628     if (xProp.is())
 629         return xProp->addVetoableChangeListener( PropertyName, aListener );
 630 }
 631
 632 void SAL_CALL ScAnnotationShapeObj::removeVetoableChangeListener( const rtl::OUString& PropertyName,
 633                                     const uno::Reference< beans::XVetoableChangeListener >& aListener )
 634                                     throw (beans::UnknownPropertyException,
 635                                         lang::WrappedTargetException,
 636                                         uno::RuntimeException)
 637 {
 638     ScUnoGuard aGuard;
 639     uno::Reference < beans::XPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 640     if (xProp.is())
 641         return xProp->removeVetoableChangeListener( PropertyName, aListener );
 642 }
 643
 644                             // XMultiPropertySet
 645 void SAL_CALL ScAnnotationShapeObj::setPropertyValues( const uno::Sequence< rtl::OUString >& aPropertyNames,
 646                                     const uno::Sequence< uno::Any >& aValues )
 647                                     throw (beans::PropertyVetoException,
 648                                         lang::IllegalArgumentException,
 649                                         lang::WrappedTargetException,
 650                                         uno::RuntimeException)
 651 {
 652     ScUnoGuard aGuard;
 653     uno::Reference < beans::XMultiPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 654     if (xProp.is())
 655         xProp->setPropertyValues( aPropertyNames, aValues );
 656 }
 657
 658 uno::Sequence< uno::Any > SAL_CALL ScAnnotationShapeObj::getPropertyValues(
 659                                     const uno::Sequence< rtl::OUString >& aPropertyNames )
 660                                     throw (uno::RuntimeException)
 661 {
 662     ScUnoGuard aGuard;
 663     uno::Reference < beans::XMultiPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 664     if (xProp.is())
 665         return xProp->getPropertyValues( aPropertyNames );
 666     return uno::Sequence< uno::Any >();
 667 }
 668
 669 void SAL_CALL ScAnnotationShapeObj::addPropertiesChangeListener( const uno::Sequence< rtl::OUString >& aPropertyNames,
 670                                     const uno::Reference< beans::XPropertiesChangeListener >& xListener )
 671                                     throw (uno::RuntimeException)
 672 {
 673     ScUnoGuard aGuard;
 674     uno::Reference < beans::XMultiPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 675     if (xProp.is())
 676         xProp->addPropertiesChangeListener( aPropertyNames, xListener );
 677 }
 678
 679 void SAL_CALL ScAnnotationShapeObj::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& xListener )
 680                                     throw (uno::RuntimeException)
 681 {
 682     ScUnoGuard aGuard;
 683     uno::Reference < beans::XMultiPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 684     if (xProp.is())
 685         xProp->removePropertiesChangeListener( xListener );
 686 }
 687
 688 void SAL_CALL ScAnnotationShapeObj::firePropertiesChangeEvent( const uno::Sequence< rtl::OUString >& aPropertyNames,
 689                                     const uno::Reference< beans::XPropertiesChangeListener >& xListener )
 690                                     throw (uno::RuntimeException)
 691 {
 692     ScUnoGuard aGuard;
 693     uno::Reference < beans::XMultiPropertySet > xProp (GetXShape(), uno::UNO_QUERY);
 694     if (xProp.is())
 695         xProp->firePropertiesChangeEvent( aPropertyNames, xListener );
 696 }
 697
 698                             // XComponent
 699 void SAL_CALL ScAnnotationShapeObj::dispose(  ) throw (uno::RuntimeException)
 700 {
 701     ScUnoGuard aGuard;
 702     uno::Reference < lang::XComponent > xComp (GetXShape(), uno::UNO_QUERY);
 703     if (xComp.is())
 704         xComp->dispose();
 705     if (xShape.is())
 706         xShape.clear();
 707 }
 708
 709 void SAL_CALL ScAnnotationShapeObj::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 710                                     throw (uno::RuntimeException)
 711 {
 712     ScUnoGuard aGuard;
 713     uno::Reference < lang::XComponent > xComp (GetXShape(), uno::UNO_QUERY);
 714     if (xComp.is())
 715         xComp->addEventListener( xListener );
 716 }
 717
 718 void SAL_CALL ScAnnotationShapeObj::removeEventListener( const uno::Reference< lang::XEventListener >& aListener )
 719                                     throw (uno::RuntimeException)
 720 {
 721     ScUnoGuard aGuard;
 722     uno::Reference < lang::XComponent > xComp (GetXShape(), uno::UNO_QUERY);
 723     if (xComp.is())
 724         xComp->removeEventListener( aListener );
 725 }
 726
 727 //------------------------------------------------------------------------
 728
 729
 730
 731