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