sc/source/ui/unoobj/shapeuno.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 #include <sal/config.h>
  21
  22 #include <comphelper/sequence.hxx>
  23 #include <svtools/unoevent.hxx>
  24 #include <svtools/unoimap.hxx>
  25 #include <svx/svdobj.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <svx/unoshape.hxx>
  28 #include <editeng/unofield.hxx>
  29 #include <svx/shapepropertynotifier.hxx>
  30 #include <toolkit/helper/convert.hxx>
  31 #include <cppuhelper/implbase2.hxx>
  32 #include <cppuhelper/supportsservice.hxx>
  33
  34 #include <com/sun/star/drawing/XShape.hpp>
  35 #include <com/sun/star/beans/PropertyAttribute.hpp>
  36
  37 #include "shapeuno.hxx"
  38 #include "miscuno.hxx"
  39 #include "cellsuno.hxx"
  40 #include "textuno.hxx"
  41 #include "fielduno.hxx"
  42 #include "docsh.hxx"
  43 #include "drwlayer.hxx"
  44 #include "userdat.hxx"
  45 #include "unonames.hxx"
  46
  47 using namespace ::com::sun::star;
  48
  49 static const SfxItemPropertyMapEntry* lcl_GetShapeMap()
  50 {
  51     static const SfxItemPropertyMapEntry aShapeMap_Impl[] =
  52     {
  53         {OUString(SC_UNONAME_ANCHOR), 0, cppu::UnoType<uno::XInterface>::get(), 0, 0 },
  54         {OUString(SC_UNONAME_HORIPOS), 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
  55         {OUString(SC_UNONAME_IMAGEMAP), 0, cppu::UnoType<container::XIndexContainer>::get(), 0, 0 },
  56         {OUString(SC_UNONAME_VERTPOS), 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
  57         {OUString(SC_UNONAME_MOVEPROTECT), 0, cppu::UnoType<sal_Bool>::get(), 0, 0 },
  58         // #i66550 HLINK_FOR_SHAPES
  59         {OUString(SC_UNONAME_HYPERLINK), 0, cppu::UnoType<OUString>::get(), 0, 0 },
  60         {OUString(SC_UNONAME_URL), 0, cppu::UnoType<OUString>::get(), 0, 0 },
  61         { OUString(), 0, css::uno::Type(), 0, 0 }
  62     };
  63     return aShapeMap_Impl;
  64 }
  65
  66 const SvEventDescription* ScShapeObj::GetSupportedMacroItems()
  67 {
  68     static const SvEventDescription aMacroDescriptionsImpl[] =
  69     {
  70         { 0, NULL }
  71     };
  72     return aMacroDescriptionsImpl;
  73 }
  74 // #i66550 HLINK_FOR_SHAPES
  75 ScMacroInfo* ScShapeObj_getShapeHyperMacroInfo( ScShapeObj* pShape, bool bCreate = false )
  76 {
  77         if( pShape )
  78             if( SdrObject* pObj = pShape->GetSdrObject() )
  79                 return ScDrawLayer::GetMacroInfo( pObj, bCreate );
  80         return 0;
  81 }
  82
  83 namespace
  84 {
  85     void lcl_initializeNotifier( SdrObject& _rSdrObj, ::cppu::OWeakObject& _rShape )
  86     {
  87         svx::PPropertyValueProvider pProvider( new svx::PropertyValueProvider( _rShape, "Anchor" ) );
  88         _rSdrObj.getShapePropertyChangeNotifier().registerProvider( svx::eSpreadsheetAnchor, pProvider );
  89     }
  90 }
  91
  92 ScShapeObj::ScShapeObj( uno::Reference<drawing::XShape>& xShape ) :
  93       pShapePropertySet(NULL),
  94       pShapePropertyState(NULL),
  95       bIsTextShape(false),
  96       bIsNoteCaption(false),
  97       bInitializedNotifier(false)
  98 {
  99     osl_atomic_increment( &m_refCount );
 100
 101     {
 102         mxShapeAgg = uno::Reference<uno::XAggregation>( xShape, uno::UNO_QUERY );
 103         // extra block to force deletion of the temporary before setDelegator
 104     }
 105
 106     if (mxShapeAgg.is())
 107     {
 108         xShape = NULL;      // during setDelegator, mxShapeAgg must be the only ref
 109
 110         mxShapeAgg->setDelegator( (cppu::OWeakObject*)this );
 111
 112         xShape.set(uno::Reference<drawing::XShape>( mxShapeAgg, uno::UNO_QUERY ));
 113
 114         bIsTextShape = ( SvxUnoTextBase::getImplementation( mxShapeAgg ) != NULL );
 115     }
 116
 117     {
 118         SdrObject* pObj = GetSdrObject();
 119         if ( pObj )
 120         {
 121             bIsNoteCaption = ScDrawLayer::IsNoteCaption( pObj );
 122             lcl_initializeNotifier( *pObj, *this );
 123             bInitializedNotifier = true;
 124         }
 125     }
 126
 127     osl_atomic_decrement( &m_refCount );
 128 }
 129
 130 ScShapeObj::~ScShapeObj()
 131 {
 132 //  if (mxShapeAgg.is())
 133 //      mxShapeAgg->setDelegator(uno::Reference<uno::XInterface>());
 134 }
 135
 136 // XInterface
 137
 138 uno::Any SAL_CALL ScShapeObj::queryInterface( const uno::Type& rType )
 139                                                 throw(uno::RuntimeException, std::exception)
 140 {
 141     uno::Any aRet = ScShapeObj_Base::queryInterface( rType );
 142
 143     if ( !aRet.hasValue() && bIsTextShape )
 144         aRet = ScShapeObj_TextBase::queryInterface( rType );
 145
 146     if ( !aRet.hasValue() && bIsNoteCaption )
 147         aRet = ScShapeObj_ChildBase::queryInterface( rType );
 148
 149     if ( !aRet.hasValue() && mxShapeAgg.is() )
 150         aRet = mxShapeAgg->queryAggregation( rType );
 151
 152     return aRet;
 153 }
 154
 155 void SAL_CALL ScShapeObj::acquire() throw()
 156 {
 157         OWeakObject::acquire();
 158 }
 159
 160 void SAL_CALL ScShapeObj::release() throw()
 161 {
 162         OWeakObject::release();
 163 }
 164
 165 void ScShapeObj::GetShapePropertySet()
 166 {
 167     // #i61908# Store the result of queryAggregation in a member.
 168     // The reference in mxShapeAgg is kept for this object's lifetime, so the pointer is always valid.
 169
 170     if (!pShapePropertySet)
 171     {
 172         uno::Reference<beans::XPropertySet> xProp;
 173         if ( mxShapeAgg.is() )
 174             mxShapeAgg->queryAggregation( cppu::UnoType<beans::XPropertySet>::get()) >>= xProp;
 175         pShapePropertySet = xProp.get();
 176     }
 177 }
 178
 179 void ScShapeObj::GetShapePropertyState()
 180 {
 181     // #i61908# Store the result of queryAggregation in a member.
 182     // The reference in mxShapeAgg is kept for this object's lifetime, so the pointer is always valid.
 183
 184     if (!pShapePropertyState)
 185     {
 186         uno::Reference<beans::XPropertyState> xState;
 187         if ( mxShapeAgg.is() )
 188             mxShapeAgg->queryAggregation( cppu::UnoType<beans::XPropertyState>::get()) >>= xState;
 189         pShapePropertyState = xState.get();
 190     }
 191 }
 192
 193 static uno::Reference<lang::XComponent> lcl_GetComponent( const uno::Reference<uno::XAggregation>& xAgg )
 194 {
 195     uno::Reference<lang::XComponent> xRet;
 196     if ( xAgg.is() )
 197         xAgg->queryAggregation( cppu::UnoType<lang::XComponent>::get()) >>= xRet;
 198     return xRet;
 199 }
 200
 201 static uno::Reference<text::XText> lcl_GetText( const uno::Reference<uno::XAggregation>& xAgg )
 202 {
 203     uno::Reference<text::XText> xRet;
 204     if ( xAgg.is() )
 205         xAgg->queryAggregation( cppu::UnoType<text::XText>::get()) >>= xRet;
 206     return xRet;
 207 }
 208
 209 static uno::Reference<text::XSimpleText> lcl_GetSimpleText( const uno::Reference<uno::XAggregation>& xAgg )
 210 {
 211     uno::Reference<text::XSimpleText> xRet;
 212     if ( xAgg.is() )
 213         xAgg->queryAggregation( cppu::UnoType<text::XSimpleText>::get()) >>= xRet;
 214     return xRet;
 215 }
 216
 217 static uno::Reference<text::XTextRange> lcl_GetTextRange( const uno::Reference<uno::XAggregation>& xAgg )
 218 {
 219     uno::Reference<text::XTextRange> xRet;
 220     if ( xAgg.is() )
 221         xAgg->queryAggregation( cppu::UnoType<text::XTextRange>::get()) >>= xRet;
 222     return xRet;
 223 }
 224
 225 //  XPropertySet
 226
 227 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScShapeObj::getPropertySetInfo()
 228                                                         throw(uno::RuntimeException, std::exception)
 229 {
 230     SolarMutexGuard aGuard;
 231
 232     // #i61527# cache property set info for this object
 233     if ( !mxPropSetInfo.is() )
 234     {
 235         //  mix own and aggregated properties:
 236         GetShapePropertySet();
 237         if (pShapePropertySet)
 238         {
 239             uno::Reference<beans::XPropertySetInfo> xAggInfo(pShapePropertySet->getPropertySetInfo());
 240             const uno::Sequence<beans::Property> aPropSeq(xAggInfo->getProperties());
 241             mxPropSetInfo.set(new SfxExtItemPropertySetInfo( lcl_GetShapeMap(), aPropSeq ));
 242         }
 243     }
 244     return mxPropSetInfo;
 245 }
 246
 247 static bool lcl_GetPageNum( SdrPage* pPage, SdrModel& rModel, SCTAB& rNum )
 248 {
 249     sal_uInt16 nCount = rModel.GetPageCount();
 250     for (sal_uInt16 i=0; i<nCount; i++)
 251         if ( rModel.GetPage(i) == pPage )
 252         {
 253             rNum = static_cast<SCTAB>(i);
 254             return true;
 255         }
 256
 257     return false;
 258 }
 259
 260 static bool lcl_GetCaptionPoint( uno::Reference< drawing::XShape >& xShape, awt::Point& rCaptionPoint )
 261 {
 262     bool bReturn = false;
 263     OUString sType(xShape->getShapeType());
 264     bool bCaptionShape( sType == "com.sun.star.drawing.CaptionShape" );
 265     if (bCaptionShape)
 266     {
 267         uno::Reference < beans::XPropertySet > xShapeProp (xShape, uno::UNO_QUERY);
 268         if (xShapeProp.is())
 269         {
 270             xShapeProp->getPropertyValue("CaptionPoint") >>= rCaptionPoint;
 271             bReturn = true;
 272         }
 273     }
 274     return bReturn;
 275 }
 276
 277 static ScRange lcl_GetAnchorCell( uno::Reference< drawing::XShape >& xShape, ScDocument* pDoc, SCTAB nTab,
 278                           awt::Point& rUnoPoint, awt::Size& rUnoSize, awt::Point& rCaptionPoint )
 279 {
 280     ScRange aReturn;
 281     rUnoPoint = xShape->getPosition();
 282     bool bCaptionShape(lcl_GetCaptionPoint(xShape, rCaptionPoint));
 283     if (pDoc->IsNegativePage(nTab))
 284     {
 285         rUnoSize = xShape->getSize();
 286         rUnoPoint.X += rUnoSize.Width; // the right top point is base
 287         if (bCaptionShape)
 288         {
 289             if (rCaptionPoint.X > 0 && rCaptionPoint.X > rUnoSize.Width)
 290                 rUnoPoint.X += rCaptionPoint.X - rUnoSize.Width;
 291             if (rCaptionPoint.Y < 0)
 292                 rUnoPoint.Y += rCaptionPoint.Y;
 293         }
 294         aReturn = pDoc->GetRange( nTab, Rectangle( VCLPoint(rUnoPoint), VCLPoint(rUnoPoint) ));
 295     }
 296     else
 297     {
 298         if (bCaptionShape)
 299         {
 300             if (rCaptionPoint.X < 0)
 301                 rUnoPoint.X += rCaptionPoint.X;
 302             if (rCaptionPoint.Y < 0)
 303                 rUnoPoint.Y += rCaptionPoint.Y;
 304         }
 305         aReturn = pDoc->GetRange( nTab, Rectangle( VCLPoint(rUnoPoint), VCLPoint(rUnoPoint) ));
 306     }
 307
 308     return aReturn;
 309 }
 310
 311 static awt::Point lcl_GetRelativePos( uno::Reference< drawing::XShape >& xShape, ScDocument* pDoc, SCTAB nTab, ScRange& rRange,
 312                               awt::Size& rUnoSize, awt::Point& rCaptionPoint)
 313 {
 314     awt::Point aUnoPoint;
 315     rRange = lcl_GetAnchorCell(xShape, pDoc, nTab, aUnoPoint, rUnoSize, rCaptionPoint);
 316     Rectangle aRect(pDoc->GetMMRect( rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aStart.Tab() ));
 317     Point aPoint = pDoc->IsNegativePage(nTab) ? aRect.TopRight() : aRect.TopLeft();
 318     aUnoPoint.X -= aPoint.X();
 319     aUnoPoint.Y -= aPoint.Y();
 320     return aUnoPoint;
 321 }
 322
 323 void SAL_CALL ScShapeObj::setPropertyValue(const OUString& aPropertyName, const uno::Any& aValue)
 324     throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 325           lang::IllegalArgumentException, lang::WrappedTargetException,
 326           uno::RuntimeException, std::exception)
 327 {
 328     SolarMutexGuard aGuard;
 329     OUString aNameString(aPropertyName);
 330
 331     if ( aNameString == SC_UNONAME_ANCHOR )
 332     {
 333         uno::Reference<sheet::XCellRangeAddressable> xRangeAdd(aValue, uno::UNO_QUERY);
 334         if (xRangeAdd.is())
 335         {
 336             SdrObject *pObj = GetSdrObject();
 337             if (pObj)
 338             {
 339                 ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
 340                 SdrPage* pPage = pObj->GetPage();
 341                 if ( pModel && pPage )
 342                 {
 343                     ScDocument* pDoc = pModel->GetDocument();
 344                     if ( pDoc )
 345                     {
 346                         SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
 347                         if ( pObjSh && pObjSh->ISA(ScDocShell) )
 348                         {
 349                             ScDocShell* pDocSh = static_cast<ScDocShell*>(pObjSh);
 350
 351                             SCTAB nTab = 0;
 352                             if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
 353                             {
 354                                 table::CellRangeAddress aAddress = xRangeAdd->getRangeAddress();
 355                                 if (nTab == aAddress.Sheet)
 356                                 {
 357                                     Rectangle aRect(pDoc->GetMMRect( static_cast<SCCOL>(aAddress.StartColumn), static_cast<SCROW>(aAddress.StartRow),
 358                                         static_cast<SCCOL>(aAddress.EndColumn), static_cast<SCROW>(aAddress.EndRow), aAddress.Sheet ));
 359                                     awt::Point aRelPoint;
 360                                     uno::Reference<drawing::XShape> xShape( mxShapeAgg, uno::UNO_QUERY );
 361                                     if (xShape.is())
 362                                     {
 363                                         Point aPoint;
 364                                         Point aEndPoint;
 365                                         if (pDoc->IsNegativePage(nTab))
 366                                         {
 367                                             aPoint = aRect.TopRight();
 368                                             aEndPoint = aRect.BottomLeft();
 369                                         }
 370                                         else
 371                                         {
 372                                             aPoint = aRect.TopLeft();
 373                                             aEndPoint = aRect.BottomRight();
 374                                         }
 375                                         awt::Size aUnoSize;
 376                                         awt::Point aCaptionPoint;
 377                                         ScRange aRange;
 378                                         aRelPoint = lcl_GetRelativePos( xShape, pDoc, nTab, aRange, aUnoSize, aCaptionPoint );
 379                                         awt::Point aUnoPoint(aRelPoint);
 380
 381                                         aUnoPoint.X += aPoint.X();
 382                                         aUnoPoint.Y += aPoint.Y();
 383
 384                                         if ( aUnoPoint.Y > aEndPoint.Y() )
 385                                             aUnoPoint.Y = aEndPoint.Y() - 2;
 386                                         if (pDoc->IsNegativePage(nTab))
 387                                         {
 388                                             if ( aUnoPoint.X < aEndPoint.X() )
 389                                                 aUnoPoint.X = aEndPoint.X() + 2;
 390                                             aUnoPoint.X -= aUnoSize.Width;
 391                                             // remove difference to caption point
 392                                             if (aCaptionPoint.X > 0 && aCaptionPoint.X > aUnoSize.Width)
 393                                                 aUnoPoint.X -= aCaptionPoint.X - aUnoSize.Width;
 394                                         }
 395                                         else
 396                                         {
 397                                             if ( aUnoPoint.X > aEndPoint.X() )
 398                                                 aUnoPoint.X = aEndPoint.X() - 2;
 399                                             if (aCaptionPoint.X < 0)
 400                                                 aUnoPoint.X -= aCaptionPoint.X;
 401                                         }
 402                                         if (aCaptionPoint.Y < 0)
 403                                             aUnoPoint.Y -= aCaptionPoint.Y;
 404
 405                                         xShape->setPosition(aUnoPoint);
 406                                         pDocSh->SetModified();
 407                                     }
 408
 409                                     if (aAddress.StartRow != aAddress.EndRow) //should be a Spreadsheet
 410                                     {
 411                                         OSL_ENSURE(aAddress.StartRow == 0 && aAddress.EndRow == MAXROW &&
 412                                             aAddress.StartColumn == 0 && aAddress.EndColumn == MAXCOL, "here should be a XSpreadsheet");
 413                                         ScDrawLayer::SetPageAnchored(*pObj);
 414                                     }
 415                                     else
 416                                     {
 417                                         OSL_ENSURE(aAddress.StartRow == aAddress.EndRow &&
 418                                             aAddress.StartColumn == aAddress.EndColumn, "here should be a XCell");
 419                                         ScDrawObjData aAnchor;
 420                                         aAnchor.maStart = ScAddress(aAddress.StartColumn, aAddress.StartRow, aAddress.Sheet);
 421                                         aAnchor.maStartOffset = Point(aRelPoint.X, aRelPoint.Y);
 422                                         //Uno sets the Anchor in terms of the unorotated shape, not much we can do
 423                                         //about that since uno also displays the shape geometry in terms of the unrotated
 424                                         //shape. #TODO think about changing the anchoring behaviour here too
 425                                         //Currently we've only got a start anchor, not an end-anchor, so generate that now
 426                                         ScDrawLayer::UpdateCellAnchorFromPositionEnd(*pObj, aAnchor, *pDoc, aAddress.Sheet);
 427                                         ScDrawLayer::SetCellAnchored(*pObj, aAnchor);
 428                                     }
 429                                 }
 430                             }
 431                         }
 432                     }
 433                 }
 434             }
 435         }
 436         else
 437             throw lang::IllegalArgumentException("only XCell or XSpreadsheet objects allowed", static_cast<cppu::OWeakObject*>(this), 0);
 438     }
 439     else if ( aNameString == SC_UNONAME_IMAGEMAP )
 440     {
 441         SdrObject* pObj = GetSdrObject();
 442         if ( pObj )
 443         {
 444             ImageMap aImageMap;
 445             uno::Reference< uno::XInterface > xImageMapInt(aValue, uno::UNO_QUERY);
 446
 447             if( !xImageMapInt.is() || !SvUnoImageMap_fillImageMap( xImageMapInt, aImageMap ) )
 448                 throw lang::IllegalArgumentException();
 449
 450             ScIMapInfo* pIMapInfo = ScDrawLayer::GetIMapInfo(pObj);
 451             if( pIMapInfo )
 452             {
 453                 // replace existing image map
 454                 pIMapInfo->SetImageMap( aImageMap );
 455             }
 456             else
 457             {
 458                 // insert new user data with image map
 459                 pObj->AppendUserData(new ScIMapInfo(aImageMap) );
 460             }
 461         }
 462     }
 463     else if ( aNameString == SC_UNONAME_HORIPOS )
 464     {
 465         sal_Int32 nPos = 0;
 466         if (aValue >>= nPos)
 467         {
 468             SdrObject *pObj = GetSdrObject();
 469             if (pObj)
 470             {
 471                 ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
 472                 SdrPage* pPage = pObj->GetPage();
 473                 if ( pModel && pPage )
 474                 {
 475                     SCTAB nTab = 0;
 476                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
 477                     {
 478                         ScDocument* pDoc = pModel->GetDocument();
 479                         if ( pDoc )
 480                         {
 481                             SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
 482                             if ( pObjSh && pObjSh->ISA(ScDocShell) )
 483                             {
 484                                 ScDocShell* pDocSh = static_cast<ScDocShell*>(pObjSh);
 485                                 uno::Reference<drawing::XShape> xShape( mxShapeAgg, uno::UNO_QUERY );
 486                                 if (xShape.is())
 487                                 {
 488                                     if (ScDrawLayer::GetAnchorType(*pObj) == SCA_PAGE)
 489                                     {
 490                                         awt::Point aPoint(xShape->getPosition());
 491                                         awt::Size aSize(xShape->getSize());
 492                                         awt::Point aCaptionPoint;
 493                                         if (pDoc->IsNegativePage(nTab))
 494                                         {
 495                                             nPos *= -1;
 496                                             nPos -= aSize.Width;
 497                                         }
 498                                         if (lcl_GetCaptionPoint(xShape, aCaptionPoint))
 499                                         {
 500                                             if (pDoc->IsNegativePage(nTab))
 501                                             {
 502                                                 if (aCaptionPoint.X > 0 && aCaptionPoint.X > aSize.Width)
 503                                                     nPos -= aCaptionPoint.X - aSize.Width;
 504                                             }
 505                                             else
 506                                             {
 507                                                 if (aCaptionPoint.X < 0)
 508                                                     nPos -= aCaptionPoint.X;
 509                                             }
 510                                         }
 511                                         aPoint.X = nPos;
 512                                         xShape->setPosition(aPoint);
 513                                         pDocSh->SetModified();
 514                                     }
 515                                     else if (ScDrawLayer::GetAnchorType(*pObj) == SCA_CELL)
 516                                     {
 517                                         awt::Size aUnoSize;
 518                                         awt::Point aCaptionPoint;
 519                                         ScRange aRange;
 520                                         awt::Point aUnoPoint(lcl_GetRelativePos( xShape, pDoc, nTab, aRange, aUnoSize, aCaptionPoint ));
 521                                         Rectangle aRect(pDoc->GetMMRect( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() ));
 522                                         if (pDoc->IsNegativePage(nTab))
 523                                         {
 524                                             aUnoPoint.X = -nPos;
 525                                             Point aPoint(aRect.TopRight());
 526                                             Point aEndPoint(aRect.BottomLeft());
 527                                             aUnoPoint.X += aPoint.X();
 528                                             if (aUnoPoint.X < aEndPoint.X())
 529                                                 aUnoPoint.X = aEndPoint.X() + 2;
 530                                             aUnoPoint.X -= aUnoSize.Width;
 531                                             if (aCaptionPoint.X > 0 && aCaptionPoint.X > aUnoSize.Width)
 532                                                 aUnoPoint.X -= aCaptionPoint.X - aUnoSize.Width;
 533                                         }
 534                                         else
 535                                         {
 536                                             aUnoPoint.X = nPos;
 537                                             Point aPoint(aRect.TopLeft());
 538                                             Point aEndPoint(aRect.BottomRight());
 539                                             aUnoPoint.X += aPoint.X();
 540                                             if (aUnoPoint.X > aEndPoint.X())
 541                                                 aUnoPoint.X = aEndPoint.X() - 2;
 542                                             if (aCaptionPoint.X < 0)
 543                                                 aUnoPoint.X -= aCaptionPoint.X;
 544                                         }
 545                                         aUnoPoint.Y = xShape->getPosition().Y;
 546                                         xShape->setPosition(aUnoPoint);
 547                                         pDocSh->SetModified();
 548                                     }
 549                                     else
 550                                     {
 551                                         OSL_FAIL("unknown anchor type");
 552                                     }
 553                                 }
 554                             }
 555                         }
 556                     }
 557                 }
 558             }
 559         }
 560     }
 561     else if ( aNameString == SC_UNONAME_VERTPOS )
 562     {
 563         sal_Int32 nPos = 0;
 564         if (aValue >>= nPos)
 565         {
 566             SdrObject *pObj = GetSdrObject();
 567             if (pObj)
 568             {
 569                 ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
 570                 SdrPage* pPage = pObj->GetPage();
 571                 if ( pModel && pPage )
 572                 {
 573                     SCTAB nTab = 0;
 574                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
 575                     {
 576                         ScDocument* pDoc = pModel->GetDocument();
 577                         if ( pDoc )
 578                         {
 579                             SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
 580                             if ( pObjSh && pObjSh->ISA(ScDocShell) )
 581                             {
 582                                 ScDocShell* pDocSh = static_cast<ScDocShell*>(pObjSh);
 583                                 uno::Reference<drawing::XShape> xShape( mxShapeAgg, uno::UNO_QUERY );
 584                                 if (xShape.is())
 585                                 {
 586                                     if (ScDrawLayer::GetAnchorType(*pObj) == SCA_PAGE)
 587                                     {
 588                                         awt::Point aPoint = xShape->getPosition();
 589                                         awt::Point aCaptionPoint;
 590                                         if (lcl_GetCaptionPoint(xShape, aCaptionPoint))
 591                                         {
 592                                             if (aCaptionPoint.Y < 0)
 593                                                 nPos -= aCaptionPoint.Y;
 594                                         }
 595                                         aPoint.Y = nPos;
 596                                         xShape->setPosition(aPoint);
 597                                         pDocSh->SetModified();
 598                                     }
 599                                     else if (ScDrawLayer::GetAnchorType(*pObj) == SCA_CELL)
 600                                     {
 601                                         awt::Size aUnoSize;
 602                                         awt::Point aCaptionPoint;
 603                                         ScRange aRange;
 604                                         awt::Point aUnoPoint(lcl_GetRelativePos( xShape, pDoc, nTab, aRange, aUnoSize, aCaptionPoint ));
 605                                         Rectangle aRect(pDoc->GetMMRect( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() ));
 606                                         Point aPoint(aRect.TopRight());
 607                                         Point aEndPoint(aRect.BottomLeft());
 608                                         aUnoPoint.Y = nPos;
 609                                         aUnoPoint.Y += aPoint.Y();
 610                                         if (aUnoPoint.Y > aEndPoint.Y())
 611                                             aUnoPoint.Y = aEndPoint.Y() - 2;
 612                                         if (aCaptionPoint.Y < 0)
 613                                             aUnoPoint.Y -= aCaptionPoint.Y;
 614                                         aUnoPoint.X = xShape->getPosition().X;
 615                                         xShape->setPosition(aUnoPoint);
 616                                         pDocSh->SetModified();
 617                                     }
 618                                     else
 619                                     {
 620                                         OSL_FAIL("unknown anchor type");
 621                                     }
 622                                 }
 623                             }
 624                         }
 625                     }
 626                 }
 627             }
 628         }
 629     }
 630     else if  ( aNameString == SC_UNONAME_HYPERLINK ||
 631                aNameString == SC_UNONAME_URL )
 632     {
 633         OUString sHlink;
 634         ScMacroInfo* pInfo = ScShapeObj_getShapeHyperMacroInfo(this, true);
 635         if ( ( aValue >>= sHlink ) && pInfo )
 636             pInfo->SetHlink( sHlink );
 637     }
 638     else if ( aNameString == SC_UNONAME_MOVEPROTECT )
 639     {
 640         if( SdrObject* pObj = this->GetSdrObject() )
 641         {
 642             bool aProt = false;
 643             if( aValue >>= aProt )
 644                 pObj->SetMoveProtect( aProt );
 645         }
 646     }
 647     else
 648     {
 649         GetShapePropertySet();
 650         if (pShapePropertySet)
 651             pShapePropertySet->setPropertyValue( aPropertyName, aValue );
 652     }
 653 }
 654
 655 uno::Any SAL_CALL ScShapeObj::getPropertyValue( const OUString& aPropertyName )
 656     throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 657           uno::RuntimeException, std::exception)
 658 {
 659     SolarMutexGuard aGuard;
 660     OUString aNameString = aPropertyName;
 661
 662     uno::Any aAny;
 663     if ( aNameString == SC_UNONAME_ANCHOR )
 664     {
 665         SdrObject *pObj = GetSdrObject();
 666         if (pObj)
 667         {
 668             ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
 669             SdrPage* pPage = pObj->GetPage();
 670             if ( pModel && pPage )
 671             {
 672                 ScDocument* pDoc = pModel->GetDocument();
 673                 if ( pDoc )
 674                 {
 675                     SCTAB nTab = 0;
 676                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
 677                     {
 678                         SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
 679                         if ( pObjSh && pObjSh->ISA(ScDocShell) )
 680                         {
 681                             ScDocShell* pDocSh = static_cast<ScDocShell*>(pObjSh);
 682                             uno::Reference< uno::XInterface > xAnchor;
 683                             if (ScDrawObjData *pAnchor = ScDrawLayer::GetObjDataTab(pObj, nTab))
 684                                 xAnchor.set(static_cast<cppu::OWeakObject*>(new ScCellObj( pDocSh, pAnchor->maStart)));
 685                             else
 686                                 xAnchor.set(static_cast<cppu::OWeakObject*>(new ScTableSheetObj( pDocSh, nTab )));
 687                             aAny <<= xAnchor;
 688                         }
 689                     }
 690                 }
 691             }
 692         }
 693     }
 694     else if ( aNameString == SC_UNONAME_IMAGEMAP )
 695     {
 696         uno::Reference< uno::XInterface > xImageMap;
 697         SdrObject* pObj = GetSdrObject();
 698         if ( pObj )
 699         {
 700             ScIMapInfo* pIMapInfo = ScDrawLayer::GetIMapInfo(GetSdrObject());
 701             if( pIMapInfo )
 702             {
 703                 const ImageMap& rIMap = pIMapInfo->GetImageMap();
 704                 xImageMap.set(SvUnoImageMap_createInstance( rIMap, GetSupportedMacroItems() ));
 705             }
 706             else
 707                 xImageMap = SvUnoImageMap_createInstance( GetSupportedMacroItems() );
 708         }
 709         aAny <<= uno::Reference< container::XIndexContainer >::query( xImageMap );
 710     }
 711     else if ( aNameString == SC_UNONAME_HORIPOS )
 712     {
 713         SdrObject *pObj = GetSdrObject();
 714         if (pObj)
 715         {
 716             ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
 717             SdrPage* pPage = pObj->GetPage();
 718             if ( pModel && pPage )
 719             {
 720                 ScDocument* pDoc = pModel->GetDocument();
 721                 if ( pDoc )
 722                 {
 723                     SCTAB nTab = 0;
 724                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
 725                     {
 726                         uno::Reference<drawing::XShape> xShape( mxShapeAgg, uno::UNO_QUERY );
 727                         if (xShape.is())
 728                         {
 729                             if (ScDrawLayer::GetAnchorType(*pObj) == SCA_CELL)
 730                             {
 731                                 awt::Size aUnoSize;
 732                                 awt::Point aCaptionPoint;
 733                                 ScRange aRange;
 734                                 awt::Point aUnoPoint(lcl_GetRelativePos( xShape, pDoc, nTab, aRange, aUnoSize, aCaptionPoint ));
 735                                 if (pDoc->IsNegativePage(nTab))
 736                                     aUnoPoint.X *= -1;
 737                                 aAny <<= aUnoPoint.X;
 738                             }
 739                             else
 740                             {
 741                                 awt::Point aCaptionPoint;
 742                                 awt::Point aUnoPoint(xShape->getPosition());
 743                                 awt::Size aUnoSize(xShape->getSize());
 744                                 if (pDoc->IsNegativePage(nTab))
 745                                 {
 746                                     aUnoPoint.X *= -1;
 747                                     aUnoPoint.X -= aUnoSize.Width;
 748                                 }
 749                                 if (lcl_GetCaptionPoint(xShape, aCaptionPoint))
 750                                 {
 751                                     if (pDoc->IsNegativePage(nTab))
 752                                     {
 753                                         if (aCaptionPoint.X > 0 && aCaptionPoint.X > aUnoSize.Width)
 754                                             aUnoPoint.X -= aCaptionPoint.X - aUnoSize.Width;
 755                                     }
 756                                     else
 757                                     {
 758                                         if (aCaptionPoint.X < 0)
 759                                             aUnoPoint.X += aCaptionPoint.X;
 760                                     }
 761                                 }
 762                                 aAny <<= aUnoPoint.X;
 763                             }
 764                         }
 765                     }
 766                 }
 767             }
 768         }
 769     }
 770     else if ( aNameString ==  SC_UNONAME_VERTPOS )
 771     {
 772         SdrObject *pObj = GetSdrObject();
 773         if (pObj)
 774         {
 775             ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
 776             SdrPage* pPage = pObj->GetPage();
 777             if ( pModel && pPage )
 778             {
 779                 ScDocument* pDoc = pModel->GetDocument();
 780                 if ( pDoc )
 781                 {
 782                     SCTAB nTab = 0;
 783                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
 784                     {
 785                         uno::Reference<drawing::XShape> xShape( mxShapeAgg, uno::UNO_QUERY );
 786                         if (xShape.is())
 787                         {
 788                             uno::Reference< uno::XInterface > xAnchor;
 789                             if (ScDrawLayer::GetAnchorType(*pObj) == SCA_CELL)
 790                             {
 791                                 awt::Size aUnoSize;
 792                                 awt::Point aCaptionPoint;
 793                                 ScRange aRange;
 794                                 awt::Point aUnoPoint(lcl_GetRelativePos( xShape, pDoc, nTab, aRange, aUnoSize, aCaptionPoint ));
 795
 796                                 aAny <<= aUnoPoint.Y;
 797                             }
 798                             else
 799                             {
 800                                 awt::Point aUnoPoint(xShape->getPosition());
 801                                 awt::Point aCaptionPoint;
 802                                 if (lcl_GetCaptionPoint(xShape, aCaptionPoint))
 803                                 {
 804                                     if (aCaptionPoint.Y < 0)
 805                                         aUnoPoint.Y += aCaptionPoint.Y;
 806                                 }
 807                                 aAny <<= aUnoPoint.Y;
 808                             }
 809                         }
 810                     }
 811                 }
 812             }
 813         }
 814     }
 815     else if ( aNameString == SC_UNONAME_HYPERLINK ||
 816               aNameString == SC_UNONAME_URL )
 817     {
 818         OUString sHlink;
 819         if ( ScMacroInfo* pInfo = ScShapeObj_getShapeHyperMacroInfo(this) )
 820             sHlink = pInfo->GetHlink();
 821         aAny <<= sHlink;
 822     }
 823     else if ( aNameString == SC_UNONAME_MOVEPROTECT )
 824     {
 825         bool aProt = false;
 826         if ( SdrObject* pObj = this->GetSdrObject() )
 827             aProt = pObj->IsMoveProtect();
 828         aAny <<= aProt;
 829     }
 830     else
 831     {
 832         if(!pShapePropertySet) //performance consideration
 833             GetShapePropertySet();
 834         if (pShapePropertySet)
 835             aAny = pShapePropertySet->getPropertyValue( aPropertyName );
 836     }
 837
 838     return aAny;
 839 }
 840
 841 void SAL_CALL ScShapeObj::addPropertyChangeListener( const OUString& aPropertyName,
 842                             const uno::Reference<beans::XPropertyChangeListener>& aListener)
 843                             throw(beans::UnknownPropertyException,
 844                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
 845 {
 846     SolarMutexGuard aGuard;
 847
 848     GetShapePropertySet();
 849     if (pShapePropertySet)
 850         pShapePropertySet->addPropertyChangeListener( aPropertyName, aListener );
 851
 852     if ( !bInitializedNotifier )
 853     {
 854         // here's the latest chance to initialize the property notification at the SdrObject
 855         // (in the ctor, where we also attempt to do this, we do not necessarily have
 856         // and SdrObject, yet)
 857         SdrObject* pObj = GetSdrObject();
 858         OSL_ENSURE( pObj, "ScShapeObj::addPropertyChangeListener: no SdrObject -> no property change notification!" );
 859         if ( pObj )
 860             lcl_initializeNotifier( *pObj, *this );
 861         bInitializedNotifier = true;
 862     }
 863 }
 864
 865 void SAL_CALL ScShapeObj::removePropertyChangeListener( const OUString& aPropertyName,
 866                             const uno::Reference<beans::XPropertyChangeListener>& aListener)
 867                             throw(beans::UnknownPropertyException,
 868                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
 869 {
 870     SolarMutexGuard aGuard;
 871
 872     GetShapePropertySet();
 873     if (pShapePropertySet)
 874         pShapePropertySet->removePropertyChangeListener( aPropertyName, aListener );
 875 }
 876
 877 void SAL_CALL ScShapeObj::addVetoableChangeListener( const OUString& aPropertyName,
 878                             const uno::Reference<beans::XVetoableChangeListener>& aListener)
 879                             throw(beans::UnknownPropertyException,
 880                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
 881 {
 882     SolarMutexGuard aGuard;
 883
 884     GetShapePropertySet();
 885     if (pShapePropertySet)
 886         pShapePropertySet->addVetoableChangeListener( aPropertyName, aListener );
 887 }
 888
 889 void SAL_CALL ScShapeObj::removeVetoableChangeListener( const OUString& aPropertyName,
 890                             const uno::Reference<beans::XVetoableChangeListener>& aListener)
 891                             throw(beans::UnknownPropertyException,
 892                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
 893 {
 894     SolarMutexGuard aGuard;
 895
 896     GetShapePropertySet();
 897     if (pShapePropertySet)
 898         pShapePropertySet->removeVetoableChangeListener( aPropertyName, aListener );
 899 }
 900
 901 //  XPropertyState
 902
 903 beans::PropertyState SAL_CALL ScShapeObj::getPropertyState( const OUString& aPropertyName )
 904                                 throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
 905 {
 906     SolarMutexGuard aGuard;
 907     OUString aNameString(aPropertyName);
 908
 909     beans::PropertyState eRet = beans::PropertyState_DIRECT_VALUE;
 910     if ( aNameString == SC_UNONAME_IMAGEMAP )
 911     {
 912         // ImageMap is always "direct"
 913     }
 914     else if ( aNameString == SC_UNONAME_ANCHOR )
 915     {
 916         // Anchor is always "direct"
 917     }
 918     else if ( aNameString == SC_UNONAME_HORIPOS )
 919     {
 920         // HoriPos is always "direct"
 921     }
 922     else if ( aNameString == SC_UNONAME_VERTPOS )
 923     {
 924         // VertPos is always "direct"
 925     }
 926     else
 927     {
 928         GetShapePropertyState();
 929         if (pShapePropertyState)
 930             eRet = pShapePropertyState->getPropertyState( aPropertyName );
 931     }
 932
 933     return eRet;
 934 }
 935
 936 uno::Sequence<beans::PropertyState> SAL_CALL ScShapeObj::getPropertyStates(
 937                                 const uno::Sequence<OUString>& aPropertyNames )
 938                             throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
 939 {
 940     SolarMutexGuard aGuard;
 941
 942     //  simple loop to get own and aggregated states
 943
 944     const OUString* pNames = aPropertyNames.getConstArray();
 945     uno::Sequence<beans::PropertyState> aRet(aPropertyNames.getLength());
 946     beans::PropertyState* pStates = aRet.getArray();
 947     for(sal_Int32 i = 0; i < aPropertyNames.getLength(); i++)
 948         pStates[i] = getPropertyState(pNames[i]);
 949     return aRet;
 950 }
 951
 952 void SAL_CALL ScShapeObj::setPropertyToDefault( const OUString& aPropertyName )
 953     throw (beans::UnknownPropertyException, uno::RuntimeException,
 954            std::exception)
 955 {
 956     SolarMutexGuard aGuard;
 957     OUString aNameString(aPropertyName);
 958
 959     if ( aNameString == SC_UNONAME_IMAGEMAP )
 960     {
 961         SdrObject* pObj = GetSdrObject();
 962         if ( pObj )
 963         {
 964             ScIMapInfo* pIMapInfo = ScDrawLayer::GetIMapInfo(pObj);
 965             if( pIMapInfo )
 966             {
 967                 ImageMap aEmpty;
 968                 pIMapInfo->SetImageMap( aEmpty );   // replace with empty image map
 969             }
 970             else
 971             {
 972                 // nothing to do (no need to insert user data for an empty map)
 973             }
 974         }
 975     }
 976     else
 977     {
 978         GetShapePropertyState();
 979         if (pShapePropertyState)
 980             pShapePropertyState->setPropertyToDefault( aPropertyName );
 981     }
 982 }
 983
 984 uno::Any SAL_CALL ScShapeObj::getPropertyDefault( const OUString& aPropertyName )
 985                                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 986                                         uno::RuntimeException, std::exception)
 987 {
 988     SolarMutexGuard aGuard;
 989     OUString aNameString = aPropertyName;
 990
 991     uno::Any aAny;
 992     if ( aNameString == SC_UNONAME_IMAGEMAP )
 993     {
 994         //  default: empty ImageMap
 995         uno::Reference< uno::XInterface > xImageMap(SvUnoImageMap_createInstance( GetSupportedMacroItems() ));
 996         aAny <<= uno::Reference< container::XIndexContainer >::query( xImageMap );
 997     }
 998     else
 999     {
1000         GetShapePropertyState();
1001         if (pShapePropertyState)
1002             aAny = pShapePropertyState->getPropertyDefault( aPropertyName );
1003     }
1004
1005     return aAny;
1006 }
1007
1008 // XTextContent
1009
1010 void SAL_CALL ScShapeObj::attach( const uno::Reference<text::XTextRange>& /* xTextRange */ )
1011                                 throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1012 {
1013     SolarMutexGuard aGuard;
1014
1015     throw lang::IllegalArgumentException();     // anchor cannot be changed
1016 }
1017
1018 uno::Reference<text::XTextRange> SAL_CALL ScShapeObj::getAnchor()
1019     throw(uno::RuntimeException, std::exception)
1020 {
1021     SolarMutexGuard aGuard;
1022
1023     uno::Reference<text::XTextRange> xRet;
1024
1025     SdrObject* pObj = GetSdrObject();
1026     if( pObj )
1027     {
1028         ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
1029         SdrPage* pPage = pObj->GetPage();
1030         if ( pModel )
1031         {
1032             ScDocument* pDoc = pModel->GetDocument();
1033             if ( pDoc )
1034             {
1035                 SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
1036                 if ( pObjSh && pObjSh->ISA(ScDocShell) )
1037                 {
1038                     ScDocShell* pDocSh = static_cast<ScDocShell*>(pObjSh);
1039
1040                     SCTAB nTab = 0;
1041                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
1042                     {
1043                         Point aPos(pObj->GetCurrentBoundRect().TopLeft());
1044                         ScRange aRange(pDoc->GetRange( nTab, Rectangle( aPos, aPos ) ));
1045
1046                         //  anchor is always the cell
1047
1048                         xRet.set(new ScCellObj( pDocSh, aRange.aStart ));
1049                     }
1050                 }
1051             }
1052         }
1053     }
1054
1055     return xRet;
1056 }
1057
1058 // XComponent
1059
1060 void SAL_CALL ScShapeObj::dispose() throw(uno::RuntimeException, std::exception)
1061 {
1062     SolarMutexGuard aGuard;
1063
1064     uno::Reference<lang::XComponent> xAggComp(lcl_GetComponent(mxShapeAgg));
1065     if ( xAggComp.is() )
1066         xAggComp->dispose();
1067 }
1068
1069 void SAL_CALL ScShapeObj::addEventListener(
1070                         const uno::Reference<lang::XEventListener>& xListener )
1071                                                     throw(uno::RuntimeException, std::exception)
1072 {
1073     SolarMutexGuard aGuard;
1074
1075     uno::Reference<lang::XComponent> xAggComp(lcl_GetComponent(mxShapeAgg));
1076     if ( xAggComp.is() )
1077         xAggComp->addEventListener(xListener);
1078 }
1079
1080 void SAL_CALL ScShapeObj::removeEventListener(
1081                         const uno::Reference<lang::XEventListener>& xListener )
1082                                                     throw(uno::RuntimeException, std::exception)
1083 {
1084     SolarMutexGuard aGuard;
1085
1086     uno::Reference<lang::XComponent> xAggComp(lcl_GetComponent(mxShapeAgg));
1087     if ( xAggComp.is() )
1088         xAggComp->removeEventListener(xListener);
1089 }
1090
1091 // XText
1092 // (special handling for ScCellFieldObj)
1093
1094 static void lcl_CopyOneProperty( beans::XPropertySet& rDest, beans::XPropertySet& rSource, const sal_Char* pName )
1095 {
1096     OUString aNameStr(OUString::createFromAscii(pName));
1097     try
1098     {
1099         rDest.setPropertyValue( aNameStr, rSource.getPropertyValue( aNameStr ) );
1100     }
1101     catch (uno::Exception&)
1102     {
1103         OSL_FAIL("Exception in text field");
1104     }
1105 }
1106
1107 void SAL_CALL ScShapeObj::insertTextContent( const uno::Reference<text::XTextRange>& xRange,
1108                                                 const uno::Reference<text::XTextContent>& xContent,
1109                                                 sal_Bool bAbsorb )
1110                                     throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1111 {
1112     SolarMutexGuard aGuard;
1113
1114     uno::Reference<text::XTextContent> xEffContent;
1115
1116     ScEditFieldObj* pCellField = ScEditFieldObj::getImplementation( xContent );
1117     if ( pCellField )
1118     {
1119         //  createInstance("TextField.URL") from the document creates a ScCellFieldObj.
1120         //  To insert it into drawing text, a SvxUnoTextField is needed instead.
1121         //  The ScCellFieldObj object is left in non-inserted state.
1122
1123         SvxUnoTextField* pDrawField = new SvxUnoTextField( text::textfield::Type::URL );
1124         xEffContent.set(pDrawField);
1125         lcl_CopyOneProperty( *pDrawField, *pCellField, SC_UNONAME_URL );
1126         lcl_CopyOneProperty( *pDrawField, *pCellField, SC_UNONAME_REPR );
1127         lcl_CopyOneProperty( *pDrawField, *pCellField, SC_UNONAME_TARGET );
1128     }
1129     else
1130         xEffContent.set(xContent);
1131
1132     uno::Reference<text::XText> xAggText(lcl_GetText(mxShapeAgg));
1133     if ( xAggText.is() )
1134         xAggText->insertTextContent( xRange, xEffContent, bAbsorb );
1135 }
1136
1137 void SAL_CALL ScShapeObj::removeTextContent( const uno::Reference<text::XTextContent>& xContent )
1138                                 throw(container::NoSuchElementException, uno::RuntimeException, std::exception)
1139 {
1140     SolarMutexGuard aGuard;
1141
1142     //  ScCellFieldObj can't be used here.
1143
1144     uno::Reference<text::XText> xAggText(lcl_GetText(mxShapeAgg));
1145     if ( xAggText.is() )
1146         xAggText->removeTextContent( xContent );
1147 }
1148
1149 // XSimpleText (parent of XText)
1150 // Use own SvxUnoTextCursor subclass - everything is just passed to aggregated object
1151
1152 uno::Reference<text::XTextCursor> SAL_CALL ScShapeObj::createTextCursor()
1153                                                     throw(uno::RuntimeException, std::exception)
1154 {
1155     SolarMutexGuard aGuard;
1156
1157     if ( mxShapeAgg.is() )
1158     {
1159         //  ScDrawTextCursor must be used to ensure the ScShapeObj is returned by getText
1160
1161         SvxUnoTextBase* pText = SvxUnoTextBase::getImplementation( mxShapeAgg );
1162         if (pText)
1163             return new ScDrawTextCursor( this, *pText );
1164     }
1165
1166     return uno::Reference<text::XTextCursor>();
1167 }
1168
1169 uno::Reference<text::XTextCursor> SAL_CALL ScShapeObj::createTextCursorByRange(
1170                                     const uno::Reference<text::XTextRange>& aTextPosition )
1171                                                     throw(uno::RuntimeException, std::exception)
1172 {
1173     SolarMutexGuard aGuard;
1174
1175     if ( mxShapeAgg.is() && aTextPosition.is() )
1176     {
1177         //  ScDrawTextCursor must be used to ensure the ScShapeObj is returned by getText
1178
1179         SvxUnoTextBase* pText = SvxUnoTextBase::getImplementation( mxShapeAgg );
1180         SvxUnoTextRangeBase* pRange = SvxUnoTextRangeBase::getImplementation( aTextPosition );
1181         if ( pText && pRange )
1182         {
1183             SvxUnoTextCursor* pCursor = new ScDrawTextCursor( this, *pText );
1184             uno::Reference<text::XTextCursor> xCursor( pCursor );
1185             pCursor->SetSelection( pRange->GetSelection() );
1186             return xCursor;
1187         }
1188     }
1189
1190     return uno::Reference<text::XTextCursor>();
1191 }
1192
1193 void SAL_CALL ScShapeObj::insertString( const uno::Reference<text::XTextRange>& xRange,
1194                                         const OUString& aString, sal_Bool bAbsorb )
1195                                     throw(uno::RuntimeException, std::exception)
1196 {
1197     SolarMutexGuard aGuard;
1198
1199     uno::Reference<text::XSimpleText> xAggSimpleText(lcl_GetSimpleText(mxShapeAgg));
1200     if ( xAggSimpleText.is() )
1201         xAggSimpleText->insertString( xRange, aString, bAbsorb );
1202     else
1203         throw uno::RuntimeException();
1204 }
1205
1206 void SAL_CALL ScShapeObj::insertControlCharacter( const uno::Reference<text::XTextRange>& xRange,
1207                                                 sal_Int16 nControlCharacter, sal_Bool bAbsorb )
1208                                     throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1209 {
1210     SolarMutexGuard aGuard;
1211
1212     uno::Reference<text::XSimpleText> xAggSimpleText(lcl_GetSimpleText(mxShapeAgg));
1213     if ( xAggSimpleText.is() )
1214         xAggSimpleText->insertControlCharacter( xRange, nControlCharacter, bAbsorb );
1215     else
1216         throw uno::RuntimeException();
1217 }
1218
1219 // XTextRange
1220 // (parent of XSimpleText)
1221
1222 uno::Reference<text::XText> SAL_CALL ScShapeObj::getText() throw(uno::RuntimeException, std::exception)
1223 {
1224     SolarMutexGuard aGuard;
1225     return this;
1226 }
1227
1228 uno::Reference<text::XTextRange> SAL_CALL ScShapeObj::getStart() throw(uno::RuntimeException, std::exception)
1229 {
1230     SolarMutexGuard aGuard;
1231
1232     uno::Reference<text::XTextRange> xAggTextRange(lcl_GetTextRange(mxShapeAgg));
1233     if ( xAggTextRange.is() )
1234         return xAggTextRange->getStart();
1235     else
1236         throw uno::RuntimeException();
1237
1238 //    return uno::Reference<text::XTextRange>();
1239 }
1240
1241 uno::Reference<text::XTextRange> SAL_CALL ScShapeObj::getEnd() throw(uno::RuntimeException, std::exception)
1242 {
1243     SolarMutexGuard aGuard;
1244
1245     uno::Reference<text::XTextRange> xAggTextRange(lcl_GetTextRange(mxShapeAgg));
1246     if ( xAggTextRange.is() )
1247         return xAggTextRange->getEnd();
1248     else
1249         throw uno::RuntimeException();
1250
1251 //    return uno::Reference<text::XTextRange>();
1252 }
1253
1254 OUString SAL_CALL ScShapeObj::getString() throw(uno::RuntimeException, std::exception)
1255 {
1256     SolarMutexGuard aGuard;
1257
1258     uno::Reference<text::XTextRange> xAggTextRange(lcl_GetTextRange(mxShapeAgg));
1259     if ( xAggTextRange.is() )
1260         return xAggTextRange->getString();
1261     else
1262         throw uno::RuntimeException();
1263
1264 //    return OUString();
1265 }
1266
1267 void SAL_CALL ScShapeObj::setString( const OUString& aText ) throw(uno::RuntimeException, std::exception)
1268 {
1269     SolarMutexGuard aGuard;
1270
1271     uno::Reference<text::XTextRange> xAggTextRange(lcl_GetTextRange(mxShapeAgg));
1272     if ( xAggTextRange.is() )
1273         xAggTextRange->setString( aText );
1274     else
1275         throw uno::RuntimeException();
1276 }
1277
1278 // XChild
1279
1280 uno::Reference< uno::XInterface > SAL_CALL ScShapeObj::getParent() throw (uno::RuntimeException, std::exception)
1281 {
1282     SolarMutexGuard aGuard;
1283
1284     // receive cell position from caption object (parent of a note caption is the note cell)
1285     SdrObject* pObj = GetSdrObject();
1286     if( pObj )
1287     {
1288         ScDrawLayer* pModel = static_cast<ScDrawLayer*>(pObj->GetModel());
1289         SdrPage* pPage = pObj->GetPage();
1290         if ( pModel )
1291         {
1292             ScDocument* pDoc = pModel->GetDocument();
1293             if ( pDoc )
1294             {
1295                 SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
1296                 if ( pObjSh && pObjSh->ISA(ScDocShell) )
1297                 {
1298                     ScDocShell* pDocSh = static_cast<ScDocShell*>(pObjSh);
1299
1300                     SCTAB nTab = 0;
1301                     if ( lcl_GetPageNum( pPage, *pModel, nTab ) )
1302                     {
1303                         const ScDrawObjData* pCaptData = ScDrawLayer::GetNoteCaptionData( pObj, nTab );
1304                         if( pCaptData )
1305                             return static_cast< ::cppu::OWeakObject* >( new ScCellObj( pDocSh, pCaptData->maStart ) );
1306                     }
1307                 }
1308             }
1309         }
1310     }
1311
1312     return 0;
1313 }
1314
1315 void SAL_CALL ScShapeObj::setParent( const uno::Reference< uno::XInterface >& ) throw (lang::NoSupportException, uno::RuntimeException, std::exception)
1316 {
1317     throw lang::NoSupportException();
1318 }
1319
1320 // XTypeProvider
1321
1322 uno::Sequence<uno::Type> SAL_CALL ScShapeObj::getTypes() throw(uno::RuntimeException, std::exception)
1323 {
1324     uno::Sequence< uno::Type > aBaseTypes( ScShapeObj_Base::getTypes() );
1325
1326     uno::Sequence< uno::Type > aTextTypes;
1327     if ( bIsTextShape )
1328         aTextTypes = ScShapeObj_TextBase::getTypes();
1329
1330     uno::Reference<lang::XTypeProvider> xBaseProvider;
1331     if ( mxShapeAgg.is() )
1332         mxShapeAgg->queryAggregation( cppu::UnoType<lang::XTypeProvider>::get()) >>= xBaseProvider;
1333     OSL_ENSURE( xBaseProvider.is(), "ScShapeObj: No XTypeProvider from aggregated shape!" );
1334
1335     uno::Sequence< uno::Type > aAggTypes;
1336     if( xBaseProvider.is() )
1337         aAggTypes = xBaseProvider->getTypes();
1338
1339     return ::comphelper::concatSequences( aBaseTypes, aTextTypes, aAggTypes );
1340 }
1341
1342 uno::Sequence<sal_Int8> SAL_CALL ScShapeObj::getImplementationId()
1343                                                     throw(uno::RuntimeException, std::exception)
1344 {
1345     return css::uno::Sequence<sal_Int8>();
1346 }
1347
1348 SdrObject* ScShapeObj::GetSdrObject() const throw()
1349 {
1350     if(mxShapeAgg.is())
1351     {
1352         SvxShape* pShape = SvxShape::getImplementation( mxShapeAgg );
1353         if(pShape)
1354             return pShape->GetSdrObject();
1355     }
1356
1357     return NULL;
1358 }
1359
1360 #define SC_EVENTACC_ONCLICK     "OnClick"
1361 #define SC_EVENTACC_SCRIPT      "Script"
1362 #define SC_EVENTACC_EVENTTYPE   "EventType"
1363
1364 typedef ::cppu::WeakImplHelper1< container::XNameReplace > ShapeUnoEventAcess_BASE;
1365 class ShapeUnoEventAccessImpl : public ShapeUnoEventAcess_BASE
1366 {
1367 private:
1368     ScShapeObj* mpShape;
1369
1370     ScMacroInfo* getInfo( bool bCreate = false )
1371     {
1372         return ScShapeObj_getShapeHyperMacroInfo( mpShape, bCreate );
1373     }
1374
1375 public:
1376     ShapeUnoEventAccessImpl( ScShapeObj* pShape ): mpShape( pShape )
1377     {
1378     }
1379
1380     // XNameReplace
1381     virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement )
1382         throw (lang::IllegalArgumentException, container::NoSuchElementException,
1383                lang::WrappedTargetException, uno::RuntimeException,
1384                std::exception) SAL_OVERRIDE
1385     {
1386         if ( !hasByName( aName ) )
1387             throw container::NoSuchElementException();
1388         uno::Sequence< beans::PropertyValue > aProperties;
1389         aElement >>= aProperties;
1390         const beans::PropertyValue* pProperties = aProperties.getConstArray();
1391         const sal_Int32 nCount = aProperties.getLength();
1392         sal_Int32 nIndex;
1393         bool isEventType = false;
1394         for( nIndex = 0; nIndex < nCount; nIndex++, pProperties++ )
1395         {
1396             if ( pProperties->Name == SC_EVENTACC_EVENTTYPE )
1397             {
1398                 isEventType = true;
1399                 continue;
1400             }
1401             if ( isEventType && (pProperties->Name == SC_EVENTACC_SCRIPT) )
1402             {
1403                 OUString sValue;
1404                 if ( pProperties->Value >>= sValue )
1405                 {
1406                     ScMacroInfo* pInfo = getInfo( true );
1407                     OSL_ENSURE( pInfo, "shape macro info could not be created!" );
1408                     if ( !pInfo )
1409                         break;
1410                     if ( pProperties->Name == SC_EVENTACC_SCRIPT )
1411                         pInfo->SetMacro( sValue );
1412                     else
1413                         pInfo->SetHlink( sValue );
1414                 }
1415             }
1416         }
1417     }
1418
1419     // XNameAccess
1420     virtual uno::Any SAL_CALL getByName( const OUString& aName )
1421         throw (container::NoSuchElementException, lang::WrappedTargetException,
1422                uno::RuntimeException, std::exception) SAL_OVERRIDE
1423     {
1424         uno::Sequence< beans::PropertyValue > aProperties;
1425         ScMacroInfo* pInfo = getInfo();
1426
1427         if ( aName == SC_EVENTACC_ONCLICK )
1428         {
1429             if ( pInfo && !pInfo->GetMacro().isEmpty() )
1430             {
1431                 aProperties.realloc( 2 );
1432                 aProperties[ 0 ].Name = SC_EVENTACC_EVENTTYPE;
1433                 aProperties[ 0 ].Value <<= OUString(SC_EVENTACC_SCRIPT);
1434                 aProperties[ 1 ].Name = SC_EVENTACC_SCRIPT;
1435                 aProperties[ 1 ].Value <<= pInfo->GetMacro();
1436             }
1437         }
1438         else
1439         {
1440             throw container::NoSuchElementException();
1441         }
1442
1443         return uno::Any( aProperties );
1444     }
1445
1446     virtual uno::Sequence< OUString > SAL_CALL getElementNames() throw(uno::RuntimeException, std::exception) SAL_OVERRIDE
1447     {
1448         uno::Sequence< OUString > aSeq( 1 );
1449         aSeq[ 0 ] = SC_EVENTACC_ONCLICK;
1450         return aSeq;
1451     }
1452
1453     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) throw(uno::RuntimeException, std::exception) SAL_OVERRIDE
1454     {
1455         return aName == SC_EVENTACC_ONCLICK;
1456     }
1457
1458     // XElementAccess
1459     virtual uno::Type SAL_CALL getElementType() throw(uno::RuntimeException, std::exception) SAL_OVERRIDE
1460     {
1461         return cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get();
1462     }
1463
1464     virtual sal_Bool SAL_CALL hasElements() throw(uno::RuntimeException, std::exception) SAL_OVERRIDE
1465     {
1466         // elements are always present (but contained property sequences may be empty)
1467         return sal_True;
1468     }
1469 };
1470
1471 ::uno::Reference< container::XNameReplace > SAL_CALL
1472 ScShapeObj::getEvents(  ) throw(uno::RuntimeException, std::exception)
1473 {
1474     return new ShapeUnoEventAccessImpl( this );
1475 }
1476
1477 OUString SAL_CALL ScShapeObj::getImplementationName(  ) throw (uno::RuntimeException, std::exception)
1478 {
1479     return OUString( "com.sun.star.comp.sc.ScShapeObj" );
1480 }
1481
1482 sal_Bool SAL_CALL ScShapeObj::supportsService( const OUString& _ServiceName ) throw (uno::RuntimeException, std::exception)
1483 {
1484     return cppu::supportsService(this, _ServiceName);
1485 }
1486
1487 uno::Sequence< OUString > SAL_CALL ScShapeObj::getSupportedServiceNames(  ) throw (uno::RuntimeException, std::exception)
1488 {
1489     uno::Reference<lang::XServiceInfo> xSI;
1490     if ( mxShapeAgg.is() )
1491         mxShapeAgg->queryAggregation( cppu::UnoType<lang::XServiceInfo>::get() ) >>= xSI;
1492
1493     uno::Sequence< OUString > aSupported;
1494     if ( xSI.is() )
1495         aSupported = xSI->getSupportedServiceNames();
1496
1497     aSupported.realloc( aSupported.getLength() + 1 );
1498     aSupported[ aSupported.getLength() - 1 ] = "com.sun.star.sheet.Shape";
1499
1500     if( bIsNoteCaption )
1501     {
1502         aSupported.realloc( aSupported.getLength() + 1 );
1503         aSupported[ aSupported.getLength() - 1 ] = "com.sun.star.sheet.CellAnnotationShape";
1504     }
1505
1506     return aSupported;
1507 }
1508
1509 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */