LCOV - code coverage report
Current view: top level - sw/source/core/unocore - unoframe.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 2017 0.0 %
Date: 2014-04-14 Functions: 0 152 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <com/sun/star/embed/NoVisualAreaSizeException.hpp>
      21             : #include <com/sun/star/container/XChild.hpp>
      22             : #include <com/sun/star/drawing/BitmapMode.hpp>
      23             : #include <com/sun/star/drawing/FillStyle.hpp>
      24             : #include <com/sun/star/awt/Gradient.hpp>
      25             : #include <com/sun/star/embed/XClassifiedObject.hpp>
      26             : #include <com/sun/star/embed/XVisualObject.hpp>
      27             : #include <com/sun/star/embed/XComponentSupplier.hpp>
      28             : #include <com/sun/star/embed/EmbedStates.hpp>
      29             : #include <com/sun/star/embed/Aspects.hpp>
      30             : #include <com/sun/star/graphic/XGraphicProvider.hpp>
      31             : #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
      32             : #include <svx/svxids.hrc>
      33             : #include <svx/xfillit0.hxx>
      34             : #include <svx/xflgrit.hxx>
      35             : #include <svx/sdtaitm.hxx>
      36             : #include <svx/xflclit.hxx>
      37             : #include <editeng/memberids.hrc>
      38             : 
      39             : #include <swtypes.hxx>
      40             : #include <cmdid.h>
      41             : 
      42             : #include <memory>
      43             : #include <hints.hxx>
      44             : #include <doc.hxx>
      45             : #include <IDocumentUndoRedo.hxx>
      46             : #include <docsh.hxx>
      47             : #include <editsh.hxx>
      48             : #include <swcli.hxx>
      49             : #include <ndindex.hxx>
      50             : #include <pam.hxx>
      51             : #include <ndnotxt.hxx>
      52             : #include <svx/unomid.hxx>
      53             : #include <unocrsr.hxx>
      54             : #include <unocrsrhelper.hxx>
      55             : #include <docstyle.hxx>
      56             : #include <dcontact.hxx>
      57             : #include <fmtcnct.hxx>
      58             : #include <ndole.hxx>
      59             : #include <frmfmt.hxx>
      60             : #include <frame.hxx>
      61             : #include <unotextrange.hxx>
      62             : #include <unotextcursor.hxx>
      63             : #include <unoparagraph.hxx>
      64             : #include <unomap.hxx>
      65             : #include <unoprnms.hxx>
      66             : #include <unoevent.hxx>
      67             : #include <com/sun/star/util/XModifyBroadcaster.hpp>
      68             : #include <com/sun/star/table/ShadowFormat.hpp>
      69             : #include <com/sun/star/style/GraphicLocation.hpp>
      70             : #include <com/sun/star/text/GraphicCrop.hpp>
      71             : #include <com/sun/star/text/TextContentAnchorType.hpp>
      72             : #include <com/sun/star/text/XTextColumns.hpp>
      73             : #include <com/sun/star/text/WrapTextMode.hpp>
      74             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      75             : #include <com/sun/star/drawing/PointSequenceSequence.hpp>
      76             : #include <com/sun/star/drawing/PointSequence.hpp>
      77             : #include <com/sun/star/drawing/ColorMode.hpp>
      78             : #include <tools/poly.hxx>
      79             : #include <swundo.hxx>
      80             : #include <unostyle.hxx>
      81             : #include <svx/svdmodel.hxx>
      82             : #include <svx/svdpage.hxx>
      83             : #include <editeng/brushitem.hxx>
      84             : #include <editeng/protitem.hxx>
      85             : #include <fmtornt.hxx>
      86             : #include <fmturl.hxx>
      87             : #include <editeng/lrspitem.hxx>
      88             : #include <editeng/ulspitem.hxx>
      89             : #include <editeng/boxitem.hxx>
      90             : #include <editeng/opaqitem.hxx>
      91             : #include <editeng/prntitem.hxx>
      92             : #include <editeng/shaditem.hxx>
      93             : #include <fmtsrnd.hxx>
      94             : #include <fmtfsize.hxx>
      95             : #include <grfatr.hxx>
      96             : #include <unoframe.hxx>
      97             : #include <fmtanchr.hxx>
      98             : #include <fmtclds.hxx>
      99             : #include <fmtcntnt.hxx>
     100             : #include <frmatr.hxx>
     101             : #include <ndtxt.hxx>
     102             : #include <ndgrf.hxx>
     103             : #include <osl/mutex.hxx>
     104             : #include <vcl/svapp.hxx>
     105             : #include <sfx2/printer.hxx>
     106             : #include <SwStyleNameMapper.hxx>
     107             : #include <editeng/xmlcnitm.hxx>
     108             : #include <poolfmt.hxx>
     109             : #include <pagedesc.hxx>
     110             : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
     111             : #include <editeng/frmdiritem.hxx>
     112             : #include <fmtfollowtextflow.hxx>
     113             : #include <fmtwrapinfluenceonobjpos.hxx>
     114             : #include <toolkit/helper/vclunohelper.hxx>
     115             : #include <switerator.hxx>
     116             : #include <comphelper/servicehelper.hxx>
     117             : #include <cppuhelper/supportsservice.hxx>
     118             : 
     119             : //UUUU
     120             : #include <unobrushitemhelper.hxx>
     121             : #include <svx/xfillit0.hxx>
     122             : #include <svx/xbtmpit.hxx>
     123             : #include <svx/xgrscit.hxx>
     124             : #include <svx/xflbmtit.hxx>
     125             : #include <svx/xflbmpit.hxx>
     126             : #include <svx/xflbmsxy.hxx>
     127             : #include <svx/xflbmsxy.hxx>
     128             : #include <svx/xflftrit.hxx>
     129             : #include <svx/xsflclit.hxx>
     130             : #include <svx/xflbmsli.hxx>
     131             : #include <svx/xflbtoxy.hxx>
     132             : #include <svx/xflbstit.hxx>
     133             : #include <svx/xflboxy.hxx>
     134             : #include <svx/xflbckit.hxx>
     135             : #include <svx/unoshape.hxx>
     136             : #include <svx/xflhtit.hxx>
     137             : #include <svx/xfltrit.hxx>
     138             : 
     139             : // from fefly1.cxx
     140             : extern sal_Bool sw_ChkAndSetNewAnchor( SwEditShell& rEditShell, const SwFlyFrm& rFly, SfxItemSet& rSet );
     141             : 
     142             : using namespace ::com::sun::star;
     143             : 
     144             : using ::com::sun::star::frame::XModel;
     145             : using ::com::sun::star::container::XNameAccess;
     146             : using ::com::sun::star::style::XStyleFamiliesSupplier;
     147             : 
     148             : const sal_Char sPackageProtocol[] = "vnd.sun.star.Package:";
     149             : const sal_Char sGraphicObjectProtocol[] = "vnd.sun.star.GraphicObject:";
     150             : 
     151             : //UUUU
     152             : #define OWN_ATTR_FILLBMP_MODE   (OWN_ATTR_VALUE_START+45)
     153             : 
     154             : /****************************************************************************
     155             :     Rahmenbeschreibung
     156             : ****************************************************************************/
     157           0 : class BaseFrameProperties_Impl
     158             : {
     159             :     SwUnoCursorHelper::SwAnyMapHelper aAnyMap;
     160             : 
     161             : public:
     162             :     virtual ~BaseFrameProperties_Impl();
     163             : 
     164             :     void            SetProperty(sal_uInt16 nWID, sal_uInt8 nMemberId, const uno::Any& rVal);
     165             :     bool            GetProperty(sal_uInt16 nWID, sal_uInt8 nMemberId, const uno::Any*& pAny );
     166             :     bool FillBaseProperties(SfxItemSet& rToSet, const SfxItemSet &rFromSet, bool& rSizeFound);
     167             : 
     168             :     virtual bool AnyToItemSet( SwDoc* pDoc, SfxItemSet& rFrmSet, SfxItemSet& rSet, bool& rSizeFound) = 0;
     169             : };
     170             : 
     171           0 : BaseFrameProperties_Impl::~BaseFrameProperties_Impl()
     172             : {
     173           0 : }
     174             : 
     175           0 : void BaseFrameProperties_Impl::SetProperty(sal_uInt16 nWID, sal_uInt8 nMemberId, const uno::Any& rVal)
     176             : {
     177           0 :     aAnyMap.SetValue( nWID, nMemberId, rVal );
     178           0 : }
     179             : 
     180           0 : bool BaseFrameProperties_Impl::GetProperty(sal_uInt16 nWID, sal_uInt8 nMemberId, const uno::Any*& rpAny)
     181             : {
     182           0 :     return aAnyMap.FillValue( nWID, nMemberId, rpAny );
     183             : }
     184             : 
     185           0 : bool BaseFrameProperties_Impl::FillBaseProperties(SfxItemSet& rToSet, const SfxItemSet& rFromSet, bool& rSizeFound)
     186             : {
     187           0 :     bool bRet = true;
     188             :     //Anker kommt auf jeden Fall in den Set
     189           0 :     SwFmtAnchor aAnchor ( static_cast < const SwFmtAnchor & > ( rFromSet.Get ( RES_ANCHOR ) ) );
     190             :     {
     191             :         const ::uno::Any* pAnchorPgNo;
     192           0 :         if(GetProperty(RES_ANCHOR, MID_ANCHOR_PAGENUM, pAnchorPgNo))
     193           0 :             bRet &= ((SfxPoolItem&)aAnchor).PutValue(*pAnchorPgNo, MID_ANCHOR_PAGENUM);
     194             :         const ::uno::Any* pAnchorType;
     195           0 :         if(GetProperty(RES_ANCHOR, MID_ANCHOR_ANCHORTYPE, pAnchorType))
     196           0 :             bRet &= ((SfxPoolItem&)aAnchor).PutValue(*pAnchorType, MID_ANCHOR_ANCHORTYPE);
     197             :     }
     198             : 
     199           0 :     rToSet.Put(aAnchor);
     200             : 
     201             :     //UUUU check for SvxBrushItem (RES_BACKGROUND) properties
     202           0 :     const ::uno::Any* pCol = 0; GetProperty(RES_BACKGROUND, MID_BACK_COLOR, pCol );
     203           0 :     const ::uno::Any* pRGBCol = 0; GetProperty(RES_BACKGROUND, MID_BACK_COLOR_R_G_B, pRGBCol );
     204           0 :     const ::uno::Any* pColTrans = 0; GetProperty(RES_BACKGROUND, MID_BACK_COLOR_TRANSPARENCY, pColTrans);
     205           0 :     const ::uno::Any* pTrans = 0; GetProperty(RES_BACKGROUND, MID_GRAPHIC_TRANSPARENT, pTrans );
     206           0 :     const ::uno::Any* pGrLoc = 0; GetProperty(RES_BACKGROUND, MID_GRAPHIC_POSITION, pGrLoc );
     207           0 :     const ::uno::Any* pGrURL = 0; GetProperty(RES_BACKGROUND, MID_GRAPHIC_URL, pGrURL     );
     208           0 :     const ::uno::Any* pGrFilter = 0; GetProperty(RES_BACKGROUND, MID_GRAPHIC_FILTER, pGrFilter     );
     209           0 :     const ::uno::Any* pGrTranparency = 0; GetProperty(RES_BACKGROUND, MID_GRAPHIC_TRANSPARENCY, pGrTranparency     );
     210             :     const bool bSvxBrushItemPropertiesUsed(
     211           0 :         pCol ||
     212           0 :         pTrans ||
     213           0 :         pGrURL ||
     214           0 :         pGrFilter ||
     215           0 :         pGrLoc ||
     216           0 :         pGrTranparency ||
     217           0 :         pColTrans ||
     218           0 :         pRGBCol);
     219             : 
     220             :     //UUUU check for FillStyle properties in the range XATTR_FILL_FIRST, XATTR_FILL_LAST
     221           0 :     const uno::Any* pXFillStyleItem = 0; GetProperty(XATTR_FILLSTYLE, 0, pXFillStyleItem);
     222           0 :     const uno::Any* pXFillColorItem = 0; GetProperty(XATTR_FILLCOLOR, 0, pXFillColorItem);
     223             : 
     224             :     // XFillGradientItem: two possible slots supported in UNO API
     225           0 :     const uno::Any* pXFillGradientItem = 0; GetProperty(XATTR_FILLGRADIENT, MID_FILLGRADIENT, pXFillGradientItem);
     226           0 :     const uno::Any* pXFillGradientNameItem = 0; GetProperty(XATTR_FILLGRADIENT, MID_NAME, pXFillGradientNameItem);
     227             : 
     228             :     // XFillHatchItem: two possible slots supported in UNO API
     229           0 :     const uno::Any* pXFillHatchItem = 0; GetProperty(XATTR_FILLHATCH, MID_FILLHATCH, pXFillHatchItem);
     230           0 :     const uno::Any* pXFillHatchNameItem = 0; GetProperty(XATTR_FILLHATCH, MID_NAME, pXFillHatchNameItem);
     231             : 
     232             :     // XFillBitmapItem: three possible slots supported in UNO API
     233           0 :     const uno::Any* pXFillBitmapItem = 0; GetProperty(XATTR_FILLBITMAP, MID_BITMAP, pXFillBitmapItem);
     234           0 :     const uno::Any* pXFillBitmapNameItem = 0; GetProperty(XATTR_FILLBITMAP, MID_NAME, pXFillBitmapNameItem);
     235           0 :     const uno::Any* pXFillBitmapURLItem = 0; GetProperty(XATTR_FILLBITMAP, MID_GRAFURL, pXFillBitmapURLItem);
     236             : 
     237           0 :     const uno::Any* pXFillTransparenceItem = 0; GetProperty(XATTR_FILLTRANSPARENCE, 0, pXFillTransparenceItem);
     238           0 :     const uno::Any* pXGradientStepCountItem = 0; GetProperty(XATTR_GRADIENTSTEPCOUNT, 0, pXGradientStepCountItem);
     239           0 :     const uno::Any* pXFillBmpPosItem = 0; GetProperty(XATTR_FILLBMP_POS, 0, pXFillBmpPosItem);
     240           0 :     const uno::Any* pXFillBmpSizeXItem = 0; GetProperty(XATTR_FILLBMP_SIZEX, 0, pXFillBmpSizeXItem);
     241           0 :     const uno::Any* pXFillBmpSizeYItem = 0; GetProperty(XATTR_FILLBMP_SIZEY, 0, pXFillBmpSizeYItem);
     242             : 
     243             :     // XFillFloatTransparenceItem: two possible slots supported in UNO API
     244           0 :     const uno::Any* pXFillFloatTransparenceItem = 0; GetProperty(XATTR_FILLFLOATTRANSPARENCE, MID_FILLGRADIENT, pXFillFloatTransparenceItem);
     245           0 :     const uno::Any* pXFillFloatTransparenceNameItem = 0; GetProperty(XATTR_FILLFLOATTRANSPARENCE, MID_NAME, pXFillFloatTransparenceNameItem);
     246             : 
     247           0 :     const uno::Any* pXSecondaryFillColorItem = 0; GetProperty(XATTR_SECONDARYFILLCOLOR, 0, pXSecondaryFillColorItem);
     248           0 :     const uno::Any* pXFillBmpSizeLogItem = 0; GetProperty(XATTR_FILLBMP_SIZELOG, 0, pXFillBmpSizeLogItem);
     249           0 :     const uno::Any* pXFillBmpTileOffsetXItem = 0; GetProperty(XATTR_FILLBMP_TILEOFFSETX, 0, pXFillBmpTileOffsetXItem);
     250           0 :     const uno::Any* pXFillBmpTileOffsetYItem = 0; GetProperty(XATTR_FILLBMP_TILEOFFSETY, 0, pXFillBmpTileOffsetYItem);
     251           0 :     const uno::Any* pXFillBmpPosOffsetXItem = 0; GetProperty(XATTR_FILLBMP_POSOFFSETX, 0, pXFillBmpPosOffsetXItem);
     252           0 :     const uno::Any* pXFillBmpPosOffsetYItem = 0; GetProperty(XATTR_FILLBMP_POSOFFSETY, 0, pXFillBmpPosOffsetYItem);
     253           0 :     const uno::Any* pXFillBackgroundItem = 0; GetProperty(XATTR_FILLBACKGROUND, 0, pXFillBackgroundItem);
     254           0 :     const uno::Any* pOwnAttrFillBmpItem = 0; GetProperty(OWN_ATTR_FILLBMP_MODE, 0, pOwnAttrFillBmpItem);
     255             : 
     256             :     const bool bXFillStyleItemUsed(
     257           0 :         pXFillStyleItem ||
     258           0 :         pXFillColorItem ||
     259           0 :         pXFillGradientItem || pXFillGradientNameItem ||
     260           0 :         pXFillHatchItem || pXFillHatchNameItem ||
     261           0 :         pXFillBitmapItem || pXFillBitmapNameItem || pXFillBitmapURLItem ||
     262           0 :         pXFillTransparenceItem ||
     263           0 :         pXGradientStepCountItem ||
     264           0 :         pXFillBmpPosItem ||
     265           0 :         pXFillBmpSizeXItem ||
     266           0 :         pXFillBmpSizeYItem ||
     267           0 :         pXFillFloatTransparenceItem || pXFillFloatTransparenceNameItem ||
     268           0 :         pXSecondaryFillColorItem ||
     269           0 :         pXFillBmpSizeLogItem ||
     270           0 :         pXFillBmpTileOffsetXItem ||
     271           0 :         pXFillBmpTileOffsetYItem ||
     272           0 :         pXFillBmpPosOffsetXItem ||
     273           0 :         pXFillBmpPosOffsetYItem ||
     274           0 :         pXFillBackgroundItem ||
     275           0 :         pOwnAttrFillBmpItem);
     276             : 
     277             :     // use brush items, but *only* if no FillStyle properties are used; if both are used and when applying both
     278             :     // in the obvious order some attributes may be wrong since they are set by the 1st set, but not
     279             :     // redefined as needed by the 2nd set when they are default (and thus no tset) in the 2nd set. If
     280             :     // it is necessary for any reason to set both (it should not) a in-between step will be needed
     281             :     // that resets the items for FillAttributes in rToSet to default
     282           0 :     if(bSvxBrushItemPropertiesUsed && !bXFillStyleItemUsed)
     283             :     {
     284             :         //UUUU create a temporary SvxBrushItem, fill the attributes to it and use it to set
     285             :         // the corresponding FillAttributes
     286           0 :         SvxBrushItem aBrush(RES_BACKGROUND);
     287             : 
     288           0 :         if(pCol)
     289             :         {
     290           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pCol,MID_BACK_COLOR    );
     291             :         }
     292             : 
     293           0 :         if(pColTrans)
     294             :         {
     295           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pColTrans, MID_BACK_COLOR_TRANSPARENCY);
     296             :         }
     297             : 
     298           0 :         if(pRGBCol)
     299             :         {
     300           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pRGBCol, MID_BACK_COLOR_R_G_B);
     301             :         }
     302             : 
     303           0 :         if(pTrans)
     304             :         {
     305             :             // don't overwrite transparency with a non-transparence flag
     306           0 :             if(!pColTrans || Any2Bool( *pTrans ))
     307           0 :                 bRet &= ((SfxPoolItem&)aBrush).PutValue(*pTrans, MID_GRAPHIC_TRANSPARENT);
     308             :         }
     309             : 
     310           0 :         if(pGrURL)
     311             :         {
     312           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pGrURL, MID_GRAPHIC_URL);
     313             :         }
     314             : 
     315           0 :         if(pGrFilter)
     316             :         {
     317           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pGrFilter, MID_GRAPHIC_FILTER);
     318             :         }
     319             : 
     320           0 :         if(pGrLoc)
     321             :         {
     322           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pGrLoc, MID_GRAPHIC_POSITION);
     323             :         }
     324             : 
     325           0 :         if(pGrTranparency)
     326             :         {
     327           0 :             bRet &= ((SfxPoolItem&)aBrush).PutValue(*pGrTranparency, MID_GRAPHIC_TRANSPARENCY);
     328             :         }
     329             : 
     330           0 :         sw::setSvxBrushItemAsFillAttributesToTargetSet(aBrush, rToSet);
     331             :     }
     332             : 
     333           0 :     if(bXFillStyleItemUsed)
     334             :     {
     335           0 :         XFillStyleItem aXFillStyleItem;
     336           0 :         SvxBrushItem aBrush(RES_BACKGROUND);
     337             : 
     338           0 :         if(pXFillStyleItem)
     339             :         {
     340           0 :             aXFillStyleItem.PutValue(*pXFillStyleItem);
     341           0 :             rToSet.Put(aXFillStyleItem);
     342             :         }
     343             : 
     344           0 :         if(pXFillColorItem)
     345             :         {
     346           0 :             const Color aNullCol(COL_DEFAULT_SHAPE_FILLING);
     347           0 :             XFillColorItem aXFillColorItem(OUString(), aNullCol);
     348             : 
     349           0 :             aXFillColorItem.PutValue(*pXFillColorItem);
     350           0 :             rToSet.Put(aXFillColorItem);
     351             :         }
     352           0 :         else if (aXFillStyleItem.GetValue() == XFILL_SOLID && pCol)
     353             :         {
     354             :             // Fill style is set to solid, but no fill color is given.
     355             :             // On the other hand, we have a BackColor, so use that.
     356           0 :             aBrush.PutValue(*pCol, MID_BACK_COLOR);
     357           0 :             sw::setSvxBrushItemAsFillAttributesToTargetSet(aBrush, rToSet);
     358             :         }
     359             : 
     360           0 :         if(pXFillGradientItem || pXFillGradientNameItem)
     361             :         {
     362           0 :             if(pXFillGradientItem)
     363             :             {
     364           0 :                 const XGradient aNullGrad(RGB_Color(COL_BLACK), RGB_Color(COL_WHITE));
     365           0 :                 XFillGradientItem aXFillGradientItem(aNullGrad);
     366             : 
     367           0 :                 aXFillGradientItem.PutValue(*pXFillGradientItem, MID_FILLGRADIENT);
     368           0 :                 rToSet.Put(aXFillGradientItem);
     369             :             }
     370             : 
     371           0 :             if(pXFillGradientNameItem)
     372             :             {
     373           0 :                 OUString aTempName;
     374             : 
     375           0 :                 if(!(*pXFillGradientNameItem >>= aTempName ))
     376             :                 {
     377           0 :                     throw lang::IllegalArgumentException();
     378             :                 }
     379             : 
     380           0 :                 bRet &= SvxShape::SetFillAttribute(XATTR_FILLGRADIENT, aTempName, rToSet);
     381             :             }
     382             :         }
     383             : 
     384           0 :         if(pXFillHatchItem || pXFillHatchNameItem)
     385             :         {
     386           0 :             if(pXFillHatchItem)
     387             :             {
     388           0 :                 const Color aNullCol(COL_DEFAULT_SHAPE_STROKE);
     389           0 :                 const XHatch aNullHatch(aNullCol);
     390           0 :                 XFillHatchItem aXFillHatchItem(rToSet.GetPool(), aNullHatch);
     391             : 
     392           0 :                 aXFillHatchItem.PutValue(*pXFillHatchItem, MID_FILLHATCH);
     393           0 :                 rToSet.Put(aXFillHatchItem);
     394             :             }
     395             : 
     396           0 :             if(pXFillHatchNameItem)
     397             :             {
     398           0 :                 OUString aTempName;
     399             : 
     400           0 :                 if(!(*pXFillHatchNameItem >>= aTempName ))
     401             :                 {
     402           0 :                     throw lang::IllegalArgumentException();
     403             :                 }
     404             : 
     405           0 :                 bRet &= SvxShape::SetFillAttribute(XATTR_FILLHATCH, aTempName, rToSet);
     406             :             }
     407             :         }
     408             : 
     409           0 :         if(pXFillBitmapItem || pXFillBitmapNameItem || pXFillBitmapURLItem)
     410             :         {
     411           0 :             if(pXFillBitmapItem)
     412             :             {
     413           0 :                 const Graphic aNullGraphic;
     414           0 :                 XFillBitmapItem aXFillBitmapItem(rToSet.GetPool(), aNullGraphic);
     415             : 
     416           0 :                 aXFillBitmapItem.PutValue(*pXFillBitmapItem, MID_BITMAP);
     417           0 :                 rToSet.Put(aXFillBitmapItem);
     418             :             }
     419             : 
     420           0 :             if(pXFillBitmapNameItem)
     421             :             {
     422           0 :                 OUString aTempName;
     423             : 
     424           0 :                 if(!(*pXFillBitmapNameItem >>= aTempName ))
     425             :                 {
     426           0 :                     throw lang::IllegalArgumentException();
     427             :                 }
     428             : 
     429           0 :                 bRet &= SvxShape::SetFillAttribute(XATTR_FILLBITMAP, aTempName, rToSet);
     430             :             }
     431             : 
     432           0 :             if(pXFillBitmapURLItem)
     433             :             {
     434           0 :                 const Graphic aNullGraphic;
     435           0 :                 XFillBitmapItem aXFillBitmapItem(rToSet.GetPool(), aNullGraphic);
     436             : 
     437           0 :                 aXFillBitmapItem.PutValue(*pXFillBitmapURLItem, MID_GRAFURL);
     438           0 :                 rToSet.Put(aXFillBitmapItem);
     439             :             }
     440             :         }
     441             : 
     442           0 :         if(pXFillTransparenceItem)
     443             :         {
     444           0 :             const XGradient aNullGrad(RGB_Color(COL_BLACK), RGB_Color(COL_WHITE));
     445           0 :             XFillTransparenceItem aXFillTransparenceItem;
     446             : 
     447           0 :             aXFillTransparenceItem.PutValue(*pXFillTransparenceItem);
     448           0 :             rToSet.Put(aXFillTransparenceItem);
     449             :         }
     450           0 :         else if (aXFillStyleItem.GetValue() == XFILL_SOLID && pColTrans)
     451             :         {
     452             :             // Fill style is set to solid, but no fill transparency is given.
     453             :             // On the other hand, we have a BackColorTransparency, so use that.
     454           0 :             aBrush.PutValue(*pColTrans, MID_BACK_COLOR_TRANSPARENCY);
     455           0 :             sw::setSvxBrushItemAsFillAttributesToTargetSet(aBrush, rToSet);
     456             :         }
     457             : 
     458           0 :         if(pXGradientStepCountItem)
     459             :         {
     460           0 :             XGradientStepCountItem aXGradientStepCountItem;
     461             : 
     462           0 :             aXGradientStepCountItem.PutValue(*pXGradientStepCountItem);
     463           0 :             rToSet.Put(aXGradientStepCountItem);
     464             :         }
     465             : 
     466           0 :         if(pXFillBmpPosItem)
     467             :         {
     468           0 :             XFillBmpPosItem aXFillBmpPosItem;
     469             : 
     470           0 :             aXFillBmpPosItem.PutValue(*pXFillBmpPosItem);
     471           0 :             rToSet.Put(aXFillBmpPosItem);
     472             :         }
     473             : 
     474           0 :         if(pXFillBmpSizeXItem)
     475             :         {
     476           0 :             XFillBmpSizeXItem aXFillBmpSizeXItem;
     477             : 
     478           0 :             aXFillBmpSizeXItem.PutValue(*pXFillBmpSizeXItem);
     479           0 :             rToSet.Put(aXFillBmpSizeXItem);
     480             :         }
     481             : 
     482           0 :         if(pXFillBmpSizeYItem)
     483             :         {
     484           0 :             XFillBmpSizeYItem aXFillBmpSizeYItem;
     485             : 
     486           0 :             aXFillBmpSizeYItem.PutValue(*pXFillBmpSizeYItem);
     487           0 :             rToSet.Put(aXFillBmpSizeYItem);
     488             :         }
     489             : 
     490           0 :         if(pXFillFloatTransparenceItem || pXFillFloatTransparenceNameItem)
     491             :         {
     492           0 :             if(pXFillFloatTransparenceItem)
     493             :             {
     494           0 :                 const XGradient aNullGrad(RGB_Color(COL_BLACK), RGB_Color(COL_WHITE));
     495           0 :                 XFillFloatTransparenceItem aXFillFloatTransparenceItem(rToSet.GetPool(), aNullGrad, false);
     496             : 
     497           0 :                 aXFillFloatTransparenceItem.PutValue(*pXFillFloatTransparenceItem, MID_FILLGRADIENT);
     498           0 :                 rToSet.Put(aXFillFloatTransparenceItem);
     499             :             }
     500             : 
     501           0 :             if(pXFillFloatTransparenceNameItem)
     502             :             {
     503           0 :                 OUString aTempName;
     504             : 
     505           0 :                 if(!(*pXFillFloatTransparenceNameItem >>= aTempName ))
     506             :                 {
     507           0 :                     throw lang::IllegalArgumentException();
     508             :                 }
     509             : 
     510           0 :                 bRet &= SvxShape::SetFillAttribute(XATTR_FILLFLOATTRANSPARENCE, aTempName, rToSet);
     511             :             }
     512             :         }
     513             : 
     514           0 :         if(pXSecondaryFillColorItem)
     515             :         {
     516           0 :             const Color aNullCol(COL_DEFAULT_SHAPE_FILLING);
     517           0 :             XSecondaryFillColorItem aXSecondaryFillColorItem(OUString(), aNullCol);
     518             : 
     519           0 :             aXSecondaryFillColorItem.PutValue(*pXSecondaryFillColorItem);
     520           0 :             rToSet.Put(aXSecondaryFillColorItem);
     521             :         }
     522             : 
     523           0 :         if(pXFillBmpSizeLogItem)
     524             :         {
     525           0 :             XFillBmpSizeLogItem aXFillBmpSizeLogItem;
     526             : 
     527           0 :             aXFillBmpSizeLogItem.PutValue(*pXFillBmpSizeLogItem);
     528           0 :             rToSet.Put(aXFillBmpSizeLogItem);
     529             :         }
     530             : 
     531           0 :         if(pXFillBmpTileOffsetXItem)
     532             :         {
     533           0 :             XFillBmpTileOffsetXItem aXFillBmpTileOffsetXItem;
     534             : 
     535           0 :             aXFillBmpTileOffsetXItem.PutValue(*pXFillBmpTileOffsetXItem);
     536           0 :             rToSet.Put(aXFillBmpTileOffsetXItem);
     537             :         }
     538             : 
     539           0 :         if(pXFillBmpTileOffsetYItem)
     540             :         {
     541           0 :             XFillBmpTileOffsetYItem aXFillBmpTileOffsetYItem;
     542             : 
     543           0 :             aXFillBmpTileOffsetYItem.PutValue(*pXFillBmpTileOffsetYItem);
     544           0 :             rToSet.Put(aXFillBmpTileOffsetYItem);
     545             :         }
     546             : 
     547           0 :         if(pXFillBmpPosOffsetXItem)
     548             :         {
     549           0 :             XFillBmpPosOffsetXItem aXFillBmpPosOffsetXItem;
     550             : 
     551           0 :             aXFillBmpPosOffsetXItem.PutValue(*pXFillBmpPosOffsetXItem);
     552           0 :             rToSet.Put(aXFillBmpPosOffsetXItem);
     553             :         }
     554             : 
     555           0 :         if(pXFillBmpPosOffsetYItem)
     556             :         {
     557           0 :             XFillBmpPosOffsetYItem aXFillBmpPosOffsetYItem;
     558             : 
     559           0 :             aXFillBmpPosOffsetYItem.PutValue(*pXFillBmpPosOffsetYItem);
     560           0 :             rToSet.Put(aXFillBmpPosOffsetYItem);
     561             :         }
     562             : 
     563           0 :         if(pXFillBackgroundItem)
     564             :         {
     565           0 :             XFillBackgroundItem aXFillBackgroundItem;
     566             : 
     567           0 :             aXFillBackgroundItem.PutValue(*pXFillBackgroundItem);
     568           0 :             rToSet.Put(aXFillBackgroundItem);
     569             :         }
     570             : 
     571           0 :         if(pOwnAttrFillBmpItem)
     572             :         {
     573             :             drawing::BitmapMode eMode;
     574             : 
     575           0 :             if(!(*pOwnAttrFillBmpItem >>= eMode))
     576             :             {
     577           0 :                 sal_Int32 nMode = 0;
     578             : 
     579           0 :                 if(!(*pOwnAttrFillBmpItem >>= nMode))
     580             :                 {
     581           0 :                     throw lang::IllegalArgumentException();
     582             :                 }
     583             : 
     584           0 :                 eMode = (drawing::BitmapMode)nMode;
     585             :             }
     586             : 
     587           0 :             rToSet.Put(XFillBmpStretchItem(drawing::BitmapMode_STRETCH == eMode));
     588           0 :             rToSet.Put(XFillBmpTileItem(drawing::BitmapMode_REPEAT == eMode));
     589           0 :         }
     590             :     }
     591             :     {
     592           0 :         const ::uno::Any* pCont = 0;
     593           0 :         GetProperty(RES_PROTECT, MID_PROTECT_CONTENT, pCont );
     594           0 :         const ::uno::Any* pPos = 0;
     595           0 :         GetProperty(RES_PROTECT,MID_PROTECT_POSITION, pPos );
     596           0 :         const ::uno::Any* pName = 0;
     597           0 :         GetProperty(RES_PROTECT, MID_PROTECT_SIZE, pName );
     598           0 :         if(pCont||pPos||pName)
     599             :         {
     600           0 :             SvxProtectItem aProt ( static_cast < const :: SvxProtectItem & > ( rFromSet.Get ( RES_PROTECT ) ) );
     601           0 :             if(pCont)
     602           0 :                 bRet &= ((SfxPoolItem&)aProt).PutValue(*pCont, MID_PROTECT_CONTENT);
     603           0 :             if(pPos )
     604           0 :                 bRet &= ((SfxPoolItem&)aProt).PutValue(*pPos, MID_PROTECT_POSITION);
     605           0 :             if(pName)
     606           0 :                 bRet &= ((SfxPoolItem&)aProt).PutValue(*pName, MID_PROTECT_SIZE);
     607           0 :             rToSet.Put(aProt);
     608             :         }
     609             :     }
     610             :     {
     611           0 :         const ::uno::Any* pHori  = 0;
     612           0 :         GetProperty(RES_HORI_ORIENT, MID_HORIORIENT_ORIENT, pHori );
     613           0 :         const ::uno::Any* pHoriP = 0;
     614           0 :         GetProperty(RES_HORI_ORIENT, MID_HORIORIENT_POSITION|CONVERT_TWIPS, pHoriP );
     615           0 :         const ::uno::Any* pHoriR = 0;
     616           0 :         GetProperty(RES_HORI_ORIENT, MID_HORIORIENT_RELATION, pHoriR );
     617           0 :         const ::uno::Any* pPageT = 0;
     618           0 :         GetProperty(RES_HORI_ORIENT, MID_HORIORIENT_PAGETOGGLE, pPageT);
     619           0 :         if(pHori||pHoriP||pHoriR||pPageT)
     620             :         {
     621           0 :             SwFmtHoriOrient aOrient ( static_cast < const :: SwFmtHoriOrient & > ( rFromSet.Get ( RES_HORI_ORIENT ) ) );
     622           0 :             if(pHori )
     623           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pHori, MID_HORIORIENT_ORIENT);
     624           0 :             if(pHoriP)
     625           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pHoriP, MID_HORIORIENT_POSITION|CONVERT_TWIPS);
     626           0 :             if(pHoriR)
     627           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pHoriR, MID_HORIORIENT_RELATION);
     628           0 :             if(pPageT)
     629           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pPageT, MID_HORIORIENT_PAGETOGGLE);
     630           0 :             rToSet.Put(aOrient);
     631             :         }
     632             :     }
     633             : 
     634             :     {
     635           0 :         const ::uno::Any* pVert  = 0;
     636           0 :         GetProperty(RES_VERT_ORIENT, MID_VERTORIENT_ORIENT, pVert);
     637           0 :         const ::uno::Any* pVertP = 0;
     638           0 :         GetProperty(RES_VERT_ORIENT, MID_VERTORIENT_POSITION|CONVERT_TWIPS, pVertP );
     639           0 :         const ::uno::Any* pVertR = 0;
     640           0 :         GetProperty(RES_VERT_ORIENT, MID_VERTORIENT_RELATION, pVertR );
     641           0 :         if(pVert||pVertP||pVertR)
     642             :         {
     643           0 :             SwFmtVertOrient aOrient ( static_cast < const :: SwFmtVertOrient & > ( rFromSet.Get ( RES_VERT_ORIENT ) ) );
     644           0 :             if(pVert )
     645           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pVert, MID_VERTORIENT_ORIENT);
     646           0 :             if(pVertP)
     647           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pVertP, MID_VERTORIENT_POSITION|CONVERT_TWIPS);
     648           0 :             if(pVertR)
     649           0 :                 bRet &= ((SfxPoolItem&)aOrient).PutValue(*pVertR, MID_VERTORIENT_RELATION);
     650           0 :             rToSet.Put(aOrient);
     651             :         }
     652             :     }
     653             :     {
     654           0 :         const ::uno::Any* pURL = 0;
     655           0 :         GetProperty(RES_URL, MID_URL_URL, pURL );
     656           0 :         const ::uno::Any* pTarget = 0;
     657           0 :         GetProperty(RES_URL, MID_URL_TARGET, pTarget );
     658           0 :         const ::uno::Any* pHyLNm = 0;
     659           0 :         GetProperty(RES_URL, MID_URL_HYPERLINKNAME, pHyLNm );
     660           0 :         const ::uno::Any* pHySMp = 0;
     661           0 :         GetProperty(RES_URL, MID_URL_SERVERMAP, pHySMp );
     662           0 :         if(pURL||pTarget||pHyLNm||pHySMp)
     663             :         {
     664           0 :             SwFmtURL aURL ( static_cast < const :: SwFmtURL & > ( rFromSet.Get ( RES_URL ) ) );
     665           0 :             if(pURL)
     666           0 :                 bRet &= ((SfxPoolItem&)aURL).PutValue(*pURL, MID_URL_URL);
     667           0 :             if(pTarget)
     668           0 :                 bRet &= ((SfxPoolItem&)aURL).PutValue(*pTarget, MID_URL_TARGET);
     669           0 :             if(pHyLNm)
     670           0 :                 bRet &= ((SfxPoolItem&)aURL).PutValue(*pHyLNm, MID_URL_HYPERLINKNAME  );
     671           0 :             if(pHySMp)
     672           0 :                 bRet &= ((SfxPoolItem&)aURL).PutValue(*pHySMp, MID_URL_SERVERMAP);
     673           0 :             rToSet.Put(aURL);
     674             :         }
     675             :     }
     676           0 :     const ::uno::Any* pL = 0;
     677           0 :     GetProperty(RES_LR_SPACE, MID_L_MARGIN|CONVERT_TWIPS, pL );
     678           0 :     const ::uno::Any* pR = 0;
     679           0 :     GetProperty(RES_LR_SPACE, MID_R_MARGIN|CONVERT_TWIPS, pR );
     680           0 :     if(pL||pR)
     681             :     {
     682           0 :         SvxLRSpaceItem aLR ( static_cast < const :: SvxLRSpaceItem & > ( rFromSet.Get ( RES_LR_SPACE ) ) );
     683           0 :         if(pL)
     684           0 :             bRet &= ((SfxPoolItem&)aLR).PutValue(*pL, MID_L_MARGIN|CONVERT_TWIPS);
     685           0 :         if(pR)
     686           0 :             bRet &= ((SfxPoolItem&)aLR).PutValue(*pR, MID_R_MARGIN|CONVERT_TWIPS);
     687           0 :         rToSet.Put(aLR);
     688             :     }
     689           0 :     const ::uno::Any* pT = 0;
     690           0 :     GetProperty(RES_UL_SPACE, MID_UP_MARGIN|CONVERT_TWIPS, pT );
     691           0 :     const ::uno::Any* pB = 0;
     692           0 :     GetProperty(RES_UL_SPACE, MID_LO_MARGIN|CONVERT_TWIPS, pB );
     693           0 :     if(pT||pB)
     694             :     {
     695           0 :         SvxULSpaceItem aTB ( static_cast < const :: SvxULSpaceItem &> ( rFromSet.Get ( RES_UL_SPACE ) ) );
     696           0 :         if(pT)
     697           0 :             bRet &= ((SfxPoolItem&)aTB).PutValue(*pT, MID_UP_MARGIN|CONVERT_TWIPS);
     698           0 :         if(pB)
     699           0 :             bRet &= ((SfxPoolItem&)aTB).PutValue(*pB, MID_LO_MARGIN|CONVERT_TWIPS);
     700           0 :         rToSet.Put(aTB);
     701             :     }
     702             :     const ::uno::Any* pOp;
     703           0 :     if(GetProperty(RES_OPAQUE, 0, pOp))
     704             :     {
     705           0 :         SvxOpaqueItem aOp ( static_cast < const :: SvxOpaqueItem& > ( rFromSet.Get ( RES_OPAQUE ) ) );
     706           0 :         bRet &= ((SfxPoolItem&)aOp).PutValue(*pOp, 0);
     707           0 :         rToSet.Put(aOp);
     708             :     }
     709             :     const ::uno::Any* pPrt;
     710           0 :     if(GetProperty(RES_PRINT, 0, pPrt))
     711             :     {
     712           0 :         SvxPrintItem aPrt ( static_cast < const :: SvxPrintItem & > ( rFromSet.Get ( RES_PRINT ) ) );
     713           0 :         bRet &= ((SfxPoolItem&)aPrt).PutValue(*pPrt, 0);
     714           0 :         rToSet.Put(aPrt);
     715             :     }
     716             :     const ::uno::Any* pSh;
     717           0 :     if(GetProperty(RES_SHADOW, CONVERT_TWIPS, pSh))
     718             :     {
     719           0 :         SvxShadowItem aSh ( static_cast < const :: SvxShadowItem& > ( rFromSet.Get ( RES_SHADOW ) ) );
     720           0 :         bRet &= ((SfxPoolItem&)aSh).PutValue(*pSh, CONVERT_TWIPS);
     721           0 :         rToSet.Put(aSh);
     722             :     }
     723             :     const ::uno::Any* pShTr;
     724           0 :     if(GetProperty(RES_SHADOW, MID_SHADOW_TRANSPARENCE, pShTr) && rToSet.HasItem(RES_SHADOW))
     725             :     {
     726           0 :         SvxShadowItem aSh(static_cast<const SvxShadowItem&>(rToSet.Get(RES_SHADOW)));
     727           0 :         bRet &= aSh.PutValue(*pShTr, MID_SHADOW_TRANSPARENCE);
     728           0 :         rToSet.Put(aSh);
     729             :     }
     730           0 :     const ::uno::Any* pSur      = 0;
     731           0 :     GetProperty(RES_SURROUND, MID_SURROUND_SURROUNDTYPE, pSur);
     732           0 :     const ::uno::Any* pSurAnch = 0;
     733           0 :     GetProperty(RES_SURROUND, MID_SURROUND_ANCHORONLY, pSurAnch);
     734           0 :     if(pSur || pSurAnch)
     735             :     {
     736           0 :         SwFmtSurround aSrnd ( static_cast < const :: SwFmtSurround & > ( rFromSet.Get ( RES_SURROUND ) ) );
     737           0 :         if(pSur)
     738           0 :             bRet &= ((SfxPoolItem&)aSrnd).PutValue(*pSur, MID_SURROUND_SURROUNDTYPE );
     739           0 :         if(pSurAnch)
     740           0 :             bRet &= ((SfxPoolItem&)aSrnd).PutValue(*pSurAnch, MID_SURROUND_ANCHORONLY);
     741           0 :         rToSet.Put(aSrnd);
     742             :     }
     743           0 :     const ::uno::Any* pLeft        = 0;
     744           0 :     GetProperty(RES_BOX, LEFT_BORDER  |CONVERT_TWIPS,    pLeft  );
     745           0 :     const ::uno::Any* pRight       = 0;
     746           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|RIGHT_BORDER ,    pRight );
     747           0 :     const ::uno::Any* pTop         = 0;
     748           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|TOP_BORDER     , pTop   );
     749           0 :     const ::uno::Any* pBottom  = 0;
     750           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|BOTTOM_BORDER,    pBottom);
     751           0 :     const ::uno::Any* pDistance    = 0;
     752           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|BORDER_DISTANCE,  pDistance);
     753           0 :     const ::uno::Any* pLeftDistance    = 0;
     754           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|LEFT_BORDER_DISTANCE, pLeftDistance);
     755           0 :     const ::uno::Any* pRightDistance   = 0;
     756           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|RIGHT_BORDER_DISTANCE,    pRightDistance);
     757           0 :     const ::uno::Any* pTopDistance     = 0;
     758           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|TOP_BORDER_DISTANCE,  pTopDistance);
     759           0 :     const ::uno::Any* pBottomDistance  = 0;
     760           0 :     GetProperty(RES_BOX, CONVERT_TWIPS|BOTTOM_BORDER_DISTANCE,   pBottomDistance);
     761           0 :     const ::uno::Any* pLineStyle  = 0;
     762           0 :     GetProperty(RES_BOX, LINE_STYLE,   pLineStyle);
     763           0 :     const ::uno::Any* pLineWidth  = 0;
     764           0 :     GetProperty(RES_BOX, LINE_WIDTH,   pLineWidth);
     765           0 :     if( pLeft || pRight || pTop ||  pBottom || pDistance ||
     766           0 :         pLeftDistance  || pRightDistance || pTopDistance || pBottomDistance ||
     767           0 :         pLineStyle || pLineWidth )
     768             :     {
     769           0 :         SvxBoxItem aBox ( static_cast < const :: SvxBoxItem & > ( rFromSet.Get ( RES_BOX ) ) );
     770           0 :         if( pLeft )
     771           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pLeft, CONVERT_TWIPS|LEFT_BORDER );
     772           0 :         if( pRight )
     773           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pRight, CONVERT_TWIPS|RIGHT_BORDER );
     774           0 :         if( pTop )
     775           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pTop, CONVERT_TWIPS|TOP_BORDER);
     776           0 :         if( pBottom )
     777           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pBottom, CONVERT_TWIPS|BOTTOM_BORDER);
     778           0 :         if( pDistance )
     779           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pDistance, CONVERT_TWIPS|BORDER_DISTANCE);
     780           0 :         if( pLeftDistance )
     781           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pLeftDistance, CONVERT_TWIPS|LEFT_BORDER_DISTANCE);
     782           0 :         if( pRightDistance )
     783           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pRightDistance, CONVERT_TWIPS|RIGHT_BORDER_DISTANCE);
     784           0 :         if( pTopDistance )
     785           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pTopDistance, CONVERT_TWIPS|TOP_BORDER_DISTANCE);
     786           0 :         if( pBottomDistance )
     787           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pBottomDistance, CONVERT_TWIPS|BOTTOM_BORDER_DISTANCE);
     788           0 :         if( pLineStyle )
     789           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pLineStyle, LINE_STYLE);
     790           0 :         if( pLineWidth )
     791           0 :             bRet &= ((SfxPoolItem&)aBox).PutValue(*pLineWidth, LINE_WIDTH|CONVERT_TWIPS);
     792           0 :         rToSet.Put(aBox);
     793             :     }
     794             :     {
     795           0 :         const ::uno::Any* pRelH = 0;
     796           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_REL_HEIGHT, pRelH);
     797           0 :         const ::uno::Any* pRelHRelation = 0;
     798           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_REL_HEIGHT_RELATION, pRelHRelation);
     799           0 :         const ::uno::Any* pRelW = 0;
     800           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_REL_WIDTH, pRelW);
     801           0 :         const ::uno::Any* pRelWRelation = 0;
     802           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_REL_WIDTH_RELATION, pRelWRelation);
     803           0 :         const ::uno::Any* pSyncWidth = 0;
     804           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT, pSyncWidth);
     805           0 :         const ::uno::Any* pSyncHeight = 0;
     806           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH, pSyncHeight);
     807           0 :         const ::uno::Any* pWidth = 0;
     808           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_WIDTH|CONVERT_TWIPS, pWidth);
     809           0 :         const ::uno::Any* pHeight = 0;
     810           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_HEIGHT|CONVERT_TWIPS, pHeight);
     811           0 :         const ::uno::Any* pSize = 0;
     812           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_SIZE|CONVERT_TWIPS, pSize);
     813           0 :         const ::uno::Any* pSizeType = 0;
     814           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_SIZE_TYPE, pSizeType);
     815           0 :         const ::uno::Any* pWidthType = 0;
     816           0 :         GetProperty(RES_FRM_SIZE, MID_FRMSIZE_WIDTH_TYPE, pWidthType);
     817           0 :         if( pWidth || pHeight ||pRelH || pRelHRelation || pRelW || pRelWRelation || pSize ||pSizeType ||
     818           0 :             pWidthType ||pSyncWidth || pSyncHeight )
     819             :         {
     820           0 :             rSizeFound = true;
     821           0 :             SwFmtFrmSize aFrmSz ( static_cast < const :: SwFmtFrmSize& > ( rFromSet.Get ( RES_FRM_SIZE ) ) );
     822           0 :             if(pWidth)
     823           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pWidth, MID_FRMSIZE_WIDTH|CONVERT_TWIPS);
     824           0 :             if(pHeight)
     825           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pHeight, MID_FRMSIZE_HEIGHT|CONVERT_TWIPS);
     826           0 :             if(pRelH )
     827           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pRelH, MID_FRMSIZE_REL_HEIGHT);
     828           0 :             if (pRelHRelation)
     829           0 :                 bRet &= const_cast<SwFmtFrmSize&>(aFrmSz).PutValue(*pRelHRelation, MID_FRMSIZE_REL_HEIGHT_RELATION);
     830           0 :             if(pRelW )
     831           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pRelW, MID_FRMSIZE_REL_WIDTH);
     832           0 :             if (pRelWRelation)
     833           0 :                 bRet &= const_cast<SwFmtFrmSize&>(aFrmSz).PutValue(*pRelWRelation, MID_FRMSIZE_REL_WIDTH_RELATION);
     834           0 :             if(pSyncWidth)
     835           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pSyncWidth, MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT);
     836           0 :             if(pSyncHeight)
     837           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pSyncHeight, MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH);
     838           0 :             if(pSize)
     839           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pSize, MID_FRMSIZE_SIZE|CONVERT_TWIPS);
     840           0 :             if(pSizeType)
     841           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pSizeType, MID_FRMSIZE_SIZE_TYPE);
     842           0 :             if(pWidthType)
     843           0 :                 bRet &= ((SfxPoolItem&)aFrmSz).PutValue(*pWidthType, MID_FRMSIZE_WIDTH_TYPE);
     844           0 :             if(!aFrmSz.GetWidth())
     845           0 :                 aFrmSz.SetWidth(MINFLY);
     846           0 :             if(!aFrmSz.GetHeight())
     847           0 :                 aFrmSz.SetHeight(MINFLY);
     848           0 :             rToSet.Put(aFrmSz);
     849             :         }
     850             :         else
     851             :         {
     852           0 :             rSizeFound = false;
     853           0 :             SwFmtFrmSize aFrmSz;
     854           0 :             awt::Size aSize;
     855           0 :             aSize.Width = 2 * MM50;
     856           0 :             aSize.Height = 2 * MM50;
     857           0 :             ::uno::Any aSizeVal;
     858           0 :             aSizeVal <<= aSize;
     859           0 :             ((SfxPoolItem&)aFrmSz).PutValue(aSizeVal, MID_FRMSIZE_SIZE|CONVERT_TWIPS);
     860           0 :             rToSet.Put(aFrmSz);
     861             :         }
     862             :     }
     863           0 :     const ::uno::Any* pFrameDirection = 0;
     864           0 :     GetProperty(RES_FRAMEDIR, 0, pFrameDirection);
     865           0 :     if(pFrameDirection)
     866             :     {
     867           0 :         SvxFrameDirectionItem aAttr(FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR);
     868           0 :         aAttr.PutValue(*pFrameDirection, 0);
     869           0 :         rToSet.Put(aAttr);
     870             :     }
     871           0 :     const ::uno::Any* pUnknown = 0;
     872           0 :     GetProperty(RES_UNKNOWNATR_CONTAINER, 0, pUnknown);
     873           0 :     if(pUnknown)
     874             :     {
     875           0 :         SvXMLAttrContainerItem aAttr(RES_UNKNOWNATR_CONTAINER);
     876           0 :         aAttr.PutValue(*pUnknown, 0);
     877           0 :         rToSet.Put(aAttr);
     878             :     }
     879             : 
     880             :     // #i18732#
     881           0 :     const ::uno::Any* pFollowTextFlow = 0;
     882           0 :     GetProperty(RES_FOLLOW_TEXT_FLOW, 0, pFollowTextFlow);
     883           0 :     if ( pFollowTextFlow )
     884             :     {
     885           0 :         SwFmtFollowTextFlow aFmtFollowTextFlow;
     886           0 :         aFmtFollowTextFlow.PutValue(*pFollowTextFlow, 0);
     887           0 :         rToSet.Put(aFmtFollowTextFlow);
     888             :     }
     889             : 
     890             :     // #i28701# - RES_WRAP_INFLUENCE_ON_OBJPOS
     891           0 :     const ::uno::Any* pWrapInfluenceOnObjPos = 0;
     892           0 :     GetProperty(RES_WRAP_INFLUENCE_ON_OBJPOS, MID_WRAP_INFLUENCE, pWrapInfluenceOnObjPos);
     893           0 :     if ( pWrapInfluenceOnObjPos )
     894             :     {
     895           0 :         SwFmtWrapInfluenceOnObjPos aFmtWrapInfluenceOnObjPos;
     896           0 :         aFmtWrapInfluenceOnObjPos.PutValue( *pWrapInfluenceOnObjPos, MID_WRAP_INFLUENCE );
     897           0 :         rToSet.Put(aFmtWrapInfluenceOnObjPos);
     898             :     }
     899             : 
     900             :     {
     901           0 :         const ::uno::Any* pTextVertAdjust = 0;
     902           0 :         GetProperty(RES_TEXT_VERT_ADJUST, 0, pTextVertAdjust);
     903           0 :         if ( pTextVertAdjust )
     904             :         {
     905           0 :             SdrTextVertAdjustItem aTextVertAdjust(static_cast <const :: SdrTextVertAdjustItem & > ( rFromSet.Get ( RES_TEXT_VERT_ADJUST ) ));
     906           0 :             bRet &= ((SfxPoolItem&)aTextVertAdjust).PutValue(*pTextVertAdjust);
     907           0 :             rToSet.Put(aTextVertAdjust);
     908             :         }
     909             :     }
     910             : 
     911           0 :     return bRet;
     912             : }
     913             : 
     914             : class SwFrameProperties_Impl : public BaseFrameProperties_Impl
     915             : {
     916             : public:
     917             :     SwFrameProperties_Impl();
     918           0 :     virtual ~SwFrameProperties_Impl(){}
     919             : 
     920             :     bool AnyToItemSet( SwDoc* pDoc, SfxItemSet& rFrmSet, SfxItemSet& rSet, bool& rSizeFound) SAL_OVERRIDE;
     921             : };
     922             : 
     923           0 : SwFrameProperties_Impl::SwFrameProperties_Impl():
     924           0 :     BaseFrameProperties_Impl(/*aSwMapProvider.GetPropertyMap(PROPERTY_MAP_TEXT_FRAME)*/ )
     925             : {
     926           0 : }
     927             : 
     928           0 : static inline void lcl_FillCol ( SfxItemSet &rToSet, const :: SfxItemSet &rFromSet, const :: uno::Any *pAny)
     929             : {
     930           0 :     if ( pAny )
     931             :     {
     932           0 :         SwFmtCol aCol ( static_cast < const :: SwFmtCol & > ( rFromSet.Get ( RES_COL ) ) );
     933           0 :         ((SfxPoolItem&)aCol).PutValue( *pAny, MID_COLUMNS);
     934           0 :         rToSet.Put(aCol);
     935             :     }
     936           0 : }
     937             : 
     938           0 : bool SwFrameProperties_Impl::AnyToItemSet(SwDoc *pDoc, SfxItemSet& rSet, SfxItemSet&, bool& rSizeFound)
     939             : {
     940             :     //Properties fuer alle Frames
     941             :     const ::uno::Any *pStyleName;
     942           0 :     SwDocStyleSheet* pStyle = NULL;
     943             :     bool bRet;
     944             : 
     945           0 :     if ( GetProperty ( FN_UNO_FRAME_STYLE_NAME, 0, pStyleName ) )
     946             :     {
     947           0 :         OUString sStyle;
     948           0 :         *pStyleName >>= sStyle;
     949           0 :         pStyle = (SwDocStyleSheet*)pDoc->GetDocShell()->GetStyleSheetPool()->Find(sStyle,
     950           0 :                                                     SFX_STYLE_FAMILY_FRAME);
     951             :     }
     952             : 
     953           0 :     const ::uno::Any* pColumns = NULL;
     954           0 :     GetProperty (RES_COL, MID_COLUMNS, pColumns);
     955           0 :     if ( pStyle )
     956             :     {
     957           0 :         rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *pStyle ) );
     958           0 :         const :: SfxItemSet *pItemSet = &xStyle->GetItemSet();
     959           0 :            bRet = FillBaseProperties( rSet, *pItemSet, rSizeFound );
     960           0 :         lcl_FillCol ( rSet, *pItemSet, pColumns );
     961             :     }
     962             :     else
     963             :     {
     964           0 :         const :: SfxItemSet *pItemSet = &pDoc->GetFrmFmtFromPool( RES_POOLFRM_FRAME )->GetAttrSet();
     965           0 :            bRet = FillBaseProperties( rSet, *pItemSet, rSizeFound );
     966           0 :         lcl_FillCol ( rSet, *pItemSet, pColumns );
     967             :     }
     968             :     const ::uno::Any* pEdit;
     969           0 :     if(GetProperty(RES_EDIT_IN_READONLY, 0, pEdit))
     970             :     {
     971           0 :         SfxBoolItem aBool(RES_EDIT_IN_READONLY);
     972           0 :         ((SfxPoolItem&)aBool).PutValue(*pEdit, 0);
     973           0 :         rSet.Put(aBool);
     974             :     }
     975           0 :     return bRet;
     976             : }
     977             : 
     978             : /****************************************************************************
     979             :     Grafik-Descriptor
     980             : ****************************************************************************/
     981             : class SwGraphicProperties_Impl : public BaseFrameProperties_Impl
     982             : {
     983             : public:
     984             :     SwGraphicProperties_Impl();
     985           0 :     virtual ~SwGraphicProperties_Impl(){}
     986             : 
     987             :     virtual bool AnyToItemSet( SwDoc* pDoc, SfxItemSet& rFrmSet, SfxItemSet& rSet, bool& rSizeFound) SAL_OVERRIDE;
     988             : };
     989             : 
     990           0 : SwGraphicProperties_Impl::SwGraphicProperties_Impl( ) :
     991           0 :     BaseFrameProperties_Impl(/*aSwMapProvider.GetPropertyMap(PROPERTY_MAP_TEXT_GRAPHIC)*/ )
     992             : {
     993           0 : }
     994             : 
     995           0 : static inline void lcl_FillMirror ( SfxItemSet &rToSet, const :: SfxItemSet &rFromSet, const ::uno::Any *pHEvenMirror, const ::uno::Any *pHOddMirror, const ::uno::Any *pVMirror, bool &rRet )
     996             : {
     997           0 :     if(pHEvenMirror || pHOddMirror || pVMirror )
     998             :     {
     999           0 :         SwMirrorGrf aMirror ( static_cast < const :: SwMirrorGrf& > ( rFromSet.Get ( RES_GRFATR_MIRRORGRF ) ) );
    1000           0 :         if(pHEvenMirror)
    1001           0 :             rRet &= ((SfxPoolItem&)aMirror).PutValue(*pHEvenMirror, MID_MIRROR_HORZ_EVEN_PAGES);
    1002           0 :         if(pHOddMirror)
    1003           0 :             rRet &= ((SfxPoolItem&)aMirror).PutValue(*pHOddMirror, MID_MIRROR_HORZ_ODD_PAGES);
    1004           0 :         if(pVMirror)
    1005           0 :             rRet &= ((SfxPoolItem&)aMirror).PutValue(*pVMirror, MID_MIRROR_VERT);
    1006           0 :         rToSet.Put(aMirror);
    1007             :     }
    1008           0 : }
    1009             : 
    1010           0 : bool SwGraphicProperties_Impl::AnyToItemSet(
    1011             :             SwDoc* pDoc,
    1012             :             SfxItemSet& rFrmSet,
    1013             :             SfxItemSet& rGrSet,
    1014             :             bool& rSizeFound)
    1015             : {
    1016             :     //Properties fuer alle Frames
    1017             :     bool bRet;
    1018             :     const ::uno::Any *pStyleName;
    1019           0 :     SwDocStyleSheet* pStyle = NULL;
    1020             : 
    1021           0 :     if ( GetProperty ( FN_UNO_FRAME_STYLE_NAME, 0, pStyleName ) )
    1022             :     {
    1023           0 :         OUString sStyle;
    1024           0 :         *pStyleName >>= sStyle;
    1025           0 :         pStyle = (SwDocStyleSheet*)pDoc->GetDocShell()->GetStyleSheetPool()->Find(sStyle,
    1026           0 :                                                     SFX_STYLE_FAMILY_FRAME);
    1027             :     }
    1028             : 
    1029           0 :     const ::uno::Any* pHEvenMirror = 0;
    1030           0 :     const ::uno::Any* pHOddMirror = 0;
    1031           0 :     const ::uno::Any* pVMirror = 0;
    1032           0 :     GetProperty(RES_GRFATR_MIRRORGRF, MID_MIRROR_HORZ_EVEN_PAGES, pHEvenMirror);
    1033           0 :     GetProperty(RES_GRFATR_MIRRORGRF, MID_MIRROR_HORZ_ODD_PAGES, pHOddMirror);
    1034           0 :     GetProperty(RES_GRFATR_MIRRORGRF, MID_MIRROR_VERT, pVMirror);
    1035             : 
    1036           0 :     if ( pStyle )
    1037             :     {
    1038           0 :         rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet(*pStyle) );
    1039           0 :         const :: SfxItemSet *pItemSet = &xStyle->GetItemSet();
    1040           0 :         bRet = FillBaseProperties(rFrmSet, *pItemSet, rSizeFound);
    1041           0 :         lcl_FillMirror ( rGrSet, *pItemSet, pHEvenMirror, pHOddMirror, pVMirror, bRet );
    1042             :     }
    1043             :     else
    1044             :     {
    1045           0 :         const :: SfxItemSet *pItemSet = &pDoc->GetFrmFmtFromPool( RES_POOLFRM_GRAPHIC )->GetAttrSet();
    1046           0 :         bRet = FillBaseProperties(rFrmSet, *pItemSet, rSizeFound);
    1047           0 :         lcl_FillMirror ( rGrSet, *pItemSet, pHEvenMirror, pHOddMirror, pVMirror, bRet );
    1048             :     }
    1049             : 
    1050             :     static const :: sal_uInt16 nIDs[] =
    1051             :     {
    1052             :         RES_GRFATR_CROPGRF,
    1053             :         RES_GRFATR_ROTATION,
    1054             :         RES_GRFATR_LUMINANCE,
    1055             :         RES_GRFATR_CONTRAST,
    1056             :         RES_GRFATR_CHANNELR,
    1057             :         RES_GRFATR_CHANNELG,
    1058             :         RES_GRFATR_CHANNELB,
    1059             :         RES_GRFATR_GAMMA,
    1060             :         RES_GRFATR_INVERT,
    1061             :         RES_GRFATR_TRANSPARENCY,
    1062             :         RES_GRFATR_DRAWMODE,
    1063             :         0
    1064             :     };
    1065             :     const ::uno::Any* pAny;
    1066           0 :     for(sal_Int16 nIndex = 0; nIDs[nIndex]; nIndex++)
    1067             :     {
    1068           0 :         sal_uInt8 nMId = RES_GRFATR_CROPGRF == nIDs[nIndex] ? CONVERT_TWIPS : 0;
    1069           0 :         if(GetProperty(nIDs[nIndex], nMId, pAny ))
    1070             :         {
    1071           0 :             SfxPoolItem* pItem = ::GetDfltAttr( nIDs[nIndex] )->Clone();
    1072           0 :             bRet &= pItem->PutValue(*pAny, nMId );
    1073           0 :             rGrSet.Put(*pItem);
    1074           0 :             delete pItem;
    1075             :         }
    1076             :     }
    1077             : 
    1078           0 :     return bRet;
    1079             : }
    1080             : 
    1081             : class SwOLEProperties_Impl : public SwFrameProperties_Impl
    1082             : {
    1083             : public:
    1084           0 :     SwOLEProperties_Impl() :
    1085           0 :         SwFrameProperties_Impl(/*aSwMapProvider.GetPropertyMap(PROPERTY_MAP_EMBEDDED_OBJECT)*/ ){}
    1086           0 :     virtual ~SwOLEProperties_Impl(){}
    1087             : 
    1088             :     virtual bool AnyToItemSet( SwDoc* pDoc, SfxItemSet& rFrmSet, SfxItemSet& rSet, bool& rSizeFound) SAL_OVERRIDE;
    1089             : };
    1090             : 
    1091           0 : bool SwOLEProperties_Impl::AnyToItemSet(
    1092             :         SwDoc* pDoc, SfxItemSet& rFrmSet, SfxItemSet& rSet, bool& rSizeFound)
    1093             : {
    1094             :     const ::uno::Any* pTemp;
    1095           0 :     if(!GetProperty(FN_UNO_CLSID, 0, pTemp) && !GetProperty(FN_UNO_STREAM_NAME, 0, pTemp)
    1096           0 :          && !GetProperty(FN_EMBEDDED_OBJECT, 0, pTemp) )
    1097           0 :         return false;
    1098           0 :     SwFrameProperties_Impl::AnyToItemSet( pDoc, rFrmSet, rSet, rSizeFound);
    1099             : 
    1100           0 :     return true;
    1101             : }
    1102             : 
    1103           0 : class SwXFrame::Impl
    1104             : {
    1105             : private:
    1106             :     ::osl::Mutex m_Mutex; // just for OInterfaceContainerHelper
    1107             : 
    1108             : public:
    1109             :     ::cppu::OInterfaceContainerHelper m_EventListeners;
    1110             : 
    1111           0 :     Impl() : m_EventListeners(m_Mutex) { }
    1112             : };
    1113             : 
    1114             : namespace
    1115             : {
    1116             :     class theSwXFrameUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXFrameUnoTunnelId > {};
    1117             : }
    1118             : 
    1119           0 : const :: uno::Sequence< sal_Int8 > & SwXFrame::getUnoTunnelId()
    1120             : {
    1121           0 :     return theSwXFrameUnoTunnelId::get().getSeq();
    1122             : }
    1123             : 
    1124           0 : sal_Int64 SAL_CALL SwXFrame::getSomething( const :: uno::Sequence< sal_Int8 >& rId )
    1125             :     throw(uno::RuntimeException, std::exception)
    1126             : {
    1127           0 :     if( rId.getLength() == 16
    1128           0 :         && 0 == memcmp( getUnoTunnelId().getConstArray(),
    1129           0 :                                         rId.getConstArray(), 16 ) )
    1130             :     {
    1131           0 :         return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
    1132             :     }
    1133           0 :     return 0;
    1134             : }
    1135             : 
    1136           0 : TYPEINIT1(SwXFrame, SwClient);
    1137             : 
    1138           0 : OUString SwXFrame::getImplementationName(void) throw( uno::RuntimeException, std::exception )
    1139             : {
    1140           0 :     return OUString("SwXFrame");
    1141             : }
    1142             : 
    1143           0 : sal_Bool SwXFrame::supportsService(const :: OUString& rServiceName) throw( uno::RuntimeException, std::exception )
    1144             : {
    1145           0 :     return cppu::supportsService(this, rServiceName);
    1146             : }
    1147             : 
    1148           0 : uno::Sequence< OUString > SwXFrame::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
    1149             : {
    1150           0 :     uno::Sequence< OUString > aRet(3);
    1151           0 :     aRet[0] = "com.sun.star.text.BaseFrame";
    1152           0 :     aRet[1] = "com.sun.star.text.TextContent";
    1153           0 :     aRet[2] = "com.sun.star.document.LinkTarget";
    1154           0 :     return aRet;
    1155             : }
    1156             : 
    1157           0 : SwXFrame::SwXFrame(FlyCntType eSet, const :: SfxItemPropertySet* pSet, SwDoc *pDoc)
    1158           0 :     : m_pImpl(new Impl)
    1159             :     , m_pPropSet(pSet)
    1160             :     , m_pDoc(pDoc)
    1161             :     , eType(eSet)
    1162             :     , bIsDescriptor(true)
    1163           0 :     , m_pCopySource(0)
    1164             : {
    1165             :     // Register ourselves as a listener to the document (via the page descriptor)
    1166           0 :     pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
    1167             :     // get the property set for the default style data
    1168             :     // First get the model
    1169           0 :     uno::Reference < XModel > xModel = pDoc->GetDocShell()->GetBaseModel();
    1170             :     // Ask the model for it's family supplier interface
    1171           0 :     uno::Reference < XStyleFamiliesSupplier > xFamilySupplier ( xModel, uno::UNO_QUERY );
    1172             :     // Get the style families
    1173           0 :     uno::Reference < XNameAccess > xFamilies = xFamilySupplier->getStyleFamilies();
    1174             :     // Get the Frame family (and keep it for later)
    1175           0 :     const ::uno::Any aAny = xFamilies->getByName ("FrameStyles");
    1176           0 :     aAny >>= mxStyleFamily;
    1177             :     // In the derived class, we'll ask mxStyleFamily for the relevant default style
    1178             :     // mxStyleFamily is initialised in the SwXFrame constructor
    1179           0 :     switch(eType)
    1180             :     {
    1181             :         case FLYCNTTYPE_FRM:
    1182             :         {
    1183           0 :             uno::Any aAny2 = mxStyleFamily->getByName ("Frame");
    1184           0 :             aAny2 >>= mxStyleData;
    1185           0 :             pProps = new SwFrameProperties_Impl( );
    1186             :         }
    1187           0 :         break;
    1188             :         case FLYCNTTYPE_GRF:
    1189             :         {
    1190           0 :             uno::Any aAny2 = mxStyleFamily->getByName ("Graphics");
    1191           0 :             aAny2 >>= mxStyleData;
    1192           0 :             pProps = new SwGraphicProperties_Impl( );
    1193             :         }
    1194           0 :         break;
    1195             :         case FLYCNTTYPE_OLE:
    1196             :         {
    1197           0 :             uno::Any aAny2 = mxStyleFamily->getByName ("OLE");
    1198           0 :             aAny2 >>= mxStyleData;
    1199           0 :             pProps = new SwOLEProperties_Impl( );
    1200             :         }
    1201           0 :         break;
    1202             : 
    1203             :         default:
    1204           0 :             pProps = NULL;
    1205             :             ;
    1206           0 :     }
    1207           0 : }
    1208             : 
    1209           0 : SwXFrame::SwXFrame(SwFrmFmt& rFrmFmt, FlyCntType eSet, const :: SfxItemPropertySet* pSet)
    1210             :     : SwClient( &rFrmFmt )
    1211           0 :     , m_pImpl(new Impl)
    1212             :     ,
    1213             :     m_pPropSet(pSet),
    1214             :     m_pDoc( 0 ),
    1215             :     eType(eSet),
    1216             :     pProps(0),
    1217             :     bIsDescriptor(false),
    1218           0 :     m_pCopySource(0)
    1219             : {
    1220             : 
    1221           0 : }
    1222             : 
    1223           0 : SwXFrame::~SwXFrame()
    1224             : {
    1225           0 :     delete m_pCopySource;
    1226           0 :     delete pProps;
    1227           0 : }
    1228             : 
    1229           0 : OUString SwXFrame::getName(void) throw( uno::RuntimeException, std::exception )
    1230             : {
    1231           0 :     SolarMutexGuard aGuard;
    1232           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    1233           0 :     if(pFmt)
    1234           0 :         return pFmt->GetName();
    1235           0 :     if(!bIsDescriptor)
    1236           0 :         throw uno::RuntimeException();
    1237           0 :     return m_sName;
    1238             : }
    1239             : 
    1240           0 : void SwXFrame::setName(const OUString& rName) throw( uno::RuntimeException, std::exception )
    1241             : {
    1242           0 :     SolarMutexGuard aGuard;
    1243           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    1244           0 :     if(pFmt)
    1245             :     {
    1246           0 :         pFmt->GetDoc()->SetFlyName((SwFlyFrmFmt&)*pFmt, rName);
    1247           0 :         if(pFmt->GetName() != rName)
    1248             :         {
    1249           0 :             throw uno::RuntimeException();
    1250             :         }
    1251             :     }
    1252           0 :     else if(bIsDescriptor)
    1253           0 :         m_sName = rName;
    1254             :     else
    1255           0 :         throw uno::RuntimeException();
    1256           0 : }
    1257             : 
    1258           0 : uno::Reference< beans::XPropertySetInfo >  SwXFrame::getPropertySetInfo(void) throw( uno::RuntimeException, std::exception )
    1259             : {
    1260           0 :     uno::Reference< beans::XPropertySetInfo >  xRef;
    1261           0 :     static uno::Reference< beans::XPropertySetInfo >  xFrmRef;
    1262           0 :     static uno::Reference< beans::XPropertySetInfo >  xGrfRef;
    1263           0 :     static uno::Reference< beans::XPropertySetInfo >  xOLERef;
    1264           0 :     switch(eType)
    1265             :     {
    1266             :     case FLYCNTTYPE_FRM:
    1267           0 :         if( !xFrmRef.is() )
    1268           0 :             xFrmRef = m_pPropSet->getPropertySetInfo();
    1269           0 :         xRef = xFrmRef;
    1270           0 :         break;
    1271             :     case FLYCNTTYPE_GRF:
    1272           0 :         if( !xGrfRef.is() )
    1273           0 :             xGrfRef = m_pPropSet->getPropertySetInfo();
    1274           0 :         xRef = xGrfRef;
    1275           0 :         break;
    1276             :     case FLYCNTTYPE_OLE:
    1277           0 :         if( !xOLERef.is() )
    1278           0 :             xOLERef = m_pPropSet->getPropertySetInfo();
    1279           0 :         xRef = xOLERef;
    1280           0 :         break;
    1281             :     default:
    1282             :         ;
    1283             :     }
    1284           0 :     return xRef;
    1285             : }
    1286             : 
    1287           0 : void SwXFrame::SetSelection(SwPaM& rCopySource)
    1288             : {
    1289           0 :     delete m_pCopySource;
    1290           0 :     m_pCopySource = new SwPaM( *rCopySource.Start() );
    1291           0 :     m_pCopySource->SetMark();
    1292           0 :     *m_pCopySource->GetMark() = *rCopySource.End();
    1293           0 : }
    1294             : 
    1295           0 : SdrObject *SwXFrame::GetOrCreateSdrObject( SwFlyFrmFmt *pFmt )
    1296             : {
    1297           0 :     SdrObject* pObject = pFmt->FindSdrObject();
    1298           0 :     if( !pObject )
    1299             :     {
    1300           0 :         SwDoc *pDoc = pFmt->GetDoc();
    1301             :         // #i52858# - method name changed
    1302           0 :         SdrModel *pDrawModel = pDoc->GetOrCreateDrawModel();
    1303             :         SwFlyDrawContact* pContactObject
    1304           0 :                     = new SwFlyDrawContact( pFmt, pDrawModel );
    1305           0 :         pObject = pContactObject->GetMaster();
    1306             : 
    1307           0 :         const :: SwFmtSurround& rSurround = pFmt->GetSurround();
    1308             :         pObject->SetLayer(
    1309           0 :             ( SURROUND_THROUGHT == rSurround.GetSurround() &&
    1310           0 :               !pFmt->GetOpaque().GetValue() ) ? pDoc->GetHellId()
    1311           0 :                                              : pDoc->GetHeavenId() );
    1312             : 
    1313           0 :         pDrawModel->GetPage(0)->InsertObject( pObject );
    1314             :     }
    1315             : 
    1316           0 :     return pObject;
    1317             : }
    1318             : 
    1319           0 : static SwFrmFmt *lcl_GetFrmFmt( const :: uno::Any& rValue, SwDoc *pDoc )
    1320             : {
    1321           0 :     SwFrmFmt *pRet = 0;
    1322           0 :     SwDocShell* pDocSh = pDoc->GetDocShell();
    1323           0 :     if(pDocSh)
    1324             :     {
    1325           0 :         OUString uTemp;
    1326           0 :         rValue >>= uTemp;
    1327           0 :         OUString sStyle;
    1328             :         SwStyleNameMapper::FillUIName(uTemp, sStyle,
    1329           0 :                 nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, true);
    1330             :         SwDocStyleSheet* pStyle =
    1331           0 :                 (SwDocStyleSheet*)pDocSh->GetStyleSheetPool()->Find(sStyle,
    1332           0 :                                                     SFX_STYLE_FAMILY_FRAME);
    1333           0 :         if(pStyle)
    1334           0 :             pRet = pStyle->GetFrmFmt();
    1335             :     }
    1336             : 
    1337           0 :     return pRet;
    1338             : }
    1339             : 
    1340           0 : void SwXFrame::setPropertyValue(const :: OUString& rPropertyName, const :: uno::Any& _rValue)
    1341             :     throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    1342             : {
    1343           0 :     SolarMutexGuard aGuard;
    1344           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    1345           0 :     const :: SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap().getByName(rPropertyName);
    1346             : 
    1347           0 :     if (!pEntry)
    1348           0 :         throw beans::UnknownPropertyException(OUString( "Unknown property: " ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
    1349             : 
    1350             :     //UUUU
    1351           0 :     const sal_uInt8 nMemberId(pEntry->nMemberId & (~SFX_METRIC_ITEM));
    1352           0 :     uno::Any aValue(_rValue);
    1353             : 
    1354             :     //UUUU check for needed metric translation
    1355           0 :     if(pEntry->nMemberId & SFX_METRIC_ITEM)
    1356             :     {
    1357           0 :         bool bDoIt(true);
    1358             : 
    1359           0 :         if(XATTR_FILLBMP_SIZEX == pEntry->nWID || XATTR_FILLBMP_SIZEY == pEntry->nWID)
    1360             :         {
    1361             :             // exception: If these ItemTypes are used, do not convert when these are negative
    1362             :             // since this means they are intended as percent values
    1363           0 :             sal_Int32 nValue = 0;
    1364             : 
    1365           0 :             if(aValue >>= nValue)
    1366             :             {
    1367           0 :                 bDoIt = nValue > 0;
    1368             :             }
    1369             :         }
    1370             : 
    1371           0 :         if(bDoIt)
    1372             :         {
    1373           0 :             const SwDoc* pDoc = (IsDescriptor() ? m_pDoc : GetFrmFmt()->GetDoc());
    1374           0 :             const SfxItemPool& rPool = pDoc->GetAttrPool();
    1375           0 :             const SfxMapUnit eMapUnit(rPool.GetMetric(pEntry->nWID));
    1376             : 
    1377           0 :             if(eMapUnit != SFX_MAPUNIT_100TH_MM)
    1378             :             {
    1379           0 :                 SvxUnoConvertFromMM(eMapUnit, aValue);
    1380             :             }
    1381             :         }
    1382             :     }
    1383             : 
    1384           0 :     if(pFmt)
    1385             :     {
    1386           0 :         bool bNextFrame = false;
    1387           0 :         if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
    1388           0 :             throw beans::PropertyVetoException("Property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
    1389             : 
    1390           0 :         SwDoc* pDoc = pFmt->GetDoc();
    1391           0 :         if ( ((eType == FLYCNTTYPE_GRF) && isGRFATR(pEntry->nWID)) ||
    1392           0 :             (FN_PARAM_COUNTOUR_PP        == pEntry->nWID) ||
    1393           0 :             (FN_UNO_IS_AUTOMATIC_CONTOUR == pEntry->nWID) ||
    1394           0 :             (FN_UNO_IS_PIXEL_CONTOUR     == pEntry->nWID) )
    1395             :         {
    1396           0 :             const :: SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    1397           0 :             if(pIdx)
    1398             :             {
    1399           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    1400           0 :                 SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    1401           0 :                 if(pEntry->nWID == FN_PARAM_COUNTOUR_PP)
    1402             :                 {
    1403           0 :                     drawing::PointSequenceSequence aParam;
    1404           0 :                     if(!aValue.hasValue())
    1405           0 :                         pNoTxt->SetContour(0);
    1406           0 :                     else if(aValue >>= aParam)
    1407             :                     {
    1408           0 :                         PolyPolygon aPoly((sal_uInt16)aParam.getLength());
    1409           0 :                         for(sal_Int32 i = 0; i < aParam.getLength(); i++)
    1410             :                         {
    1411           0 :                             const :: drawing::PointSequence* pPointSeq = aParam.getConstArray();
    1412           0 :                             sal_Int32 nPoints = pPointSeq[i].getLength();
    1413           0 :                             const :: awt::Point* pPoints = pPointSeq[i].getConstArray();
    1414           0 :                             Polygon aSet( (sal_uInt16)nPoints );
    1415           0 :                             for(sal_Int32 j = 0; j < nPoints; j++)
    1416             :                             {
    1417           0 :                                 Point aPoint(pPoints[j].X, pPoints[j].Y);
    1418           0 :                                 aSet.SetPoint(aPoint, (sal_uInt16)j);
    1419             :                             }
    1420             :                             // Close polygon if it isn't closed already.
    1421           0 :                             aSet.Optimize( POLY_OPTIMIZE_CLOSE );
    1422           0 :                             aPoly.Insert( aSet );
    1423           0 :                         }
    1424           0 :                         pNoTxt->SetContourAPI( &aPoly );
    1425             :                     }
    1426             :                     else
    1427           0 :                         throw lang::IllegalArgumentException();
    1428             :                 }
    1429           0 :                 else if(pEntry->nWID == FN_UNO_IS_AUTOMATIC_CONTOUR )
    1430             :                 {
    1431           0 :                     pNoTxt->SetAutomaticContour( *(sal_Bool *)aValue.getValue() );
    1432             :                 }
    1433           0 :                 else if(pEntry->nWID == FN_UNO_IS_PIXEL_CONTOUR )
    1434             :                 {
    1435             :                     // The IsPixelContour property can only be set if there
    1436             :                     // is no contour, or if the contour has been set by the
    1437             :                     // API itself (or in other words, if the contour isn't
    1438             :                     // used already).
    1439           0 :                     if( !pNoTxt->_HasContour() ||
    1440           0 :                         !pNoTxt->IsContourMapModeValid() )
    1441           0 :                         pNoTxt->SetPixelContour( *(sal_Bool *)aValue.getValue() );
    1442             :                     else
    1443           0 :                         throw lang::IllegalArgumentException();
    1444             :                 }
    1445             :                 else
    1446             :                 {
    1447           0 :                     SfxItemSet aSet(pNoTxt->GetSwAttrSet());
    1448           0 :                     m_pPropSet->setPropertyValue(*pEntry, aValue, aSet);
    1449           0 :                     pNoTxt->SetAttr(aSet);
    1450           0 :                 }
    1451             :             }
    1452             :         }
    1453             :         // New attribute Title
    1454           0 :         else if( FN_UNO_TITLE == pEntry->nWID )
    1455             :         {
    1456           0 :             SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(pFmt);
    1457             :             OSL_ENSURE( pFmt,
    1458             :                     "unexpected type of <pFmt> --> crash" );
    1459           0 :             OUString sTitle;
    1460           0 :             aValue >>= sTitle;
    1461             :             // assure that <SdrObject> instance exists.
    1462           0 :             GetOrCreateSdrObject( pFlyFmt );
    1463           0 :             pFlyFmt->GetDoc()->SetFlyFrmTitle( *(pFlyFmt), sTitle );
    1464             :         }
    1465             :         // New attribute Description
    1466           0 :         else if( FN_UNO_DESCRIPTION == pEntry->nWID )
    1467             :         {
    1468           0 :             SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(pFmt);
    1469             :             OSL_ENSURE( pFmt,
    1470             :                     "unexpected type of <pFmt> --> crash" );
    1471           0 :             OUString sDescription;
    1472           0 :             aValue >>= sDescription;
    1473             :             // assure that <SdrObject> instance exists.
    1474           0 :             GetOrCreateSdrObject( pFlyFmt );
    1475           0 :             pFlyFmt->GetDoc()->SetFlyFrmDescription( *(pFlyFmt), sDescription );
    1476             :         }
    1477           0 :         else if(FN_UNO_FRAME_STYLE_NAME == pEntry->nWID)
    1478             :         {
    1479           0 :             SwFrmFmt *pFrmFmt = lcl_GetFrmFmt( aValue, pFmt->GetDoc() );
    1480           0 :             if( pFrmFmt )
    1481             :             {
    1482           0 :                 UnoActionContext aAction(pFmt->GetDoc());
    1483             : 
    1484           0 :                 SfxItemSet* pSet = 0;
    1485             :                 // #i31771#, #i25798# - No adjustment of
    1486             :                 // anchor ( no call of method <sw_ChkAndSetNewAnchor(..)> ),
    1487             :                 // if document is currently in reading mode.
    1488           0 :                 if ( !pFmt->GetDoc()->IsInReading() )
    1489             :                 {
    1490             :                     // see SwFEShell::SetFrmFmt( SwFrmFmt *pNewFmt, bool bKeepOrient, Point* pDocPos )
    1491           0 :                     SwFlyFrm *pFly = 0;
    1492             :                     {
    1493           0 :                         const :: SwFrmFmt* pFmtXX = pFmt;
    1494           0 :                         if (PTR_CAST(SwFlyFrmFmt, pFmtXX))
    1495           0 :                             pFly = ((SwFlyFrmFmt*)pFmtXX)->GetFrm();
    1496             :                     }
    1497           0 :                     if ( pFly )
    1498             :                     {
    1499             :                         const :: SfxPoolItem* pItem;
    1500           0 :                         if( SFX_ITEM_SET == pFrmFmt->GetItemState( RES_ANCHOR, false, &pItem ))
    1501             :                         {
    1502           0 :                             pSet = new SfxItemSet( pDoc->GetAttrPool(), aFrmFmtSetRange );
    1503           0 :                             pSet->Put( *pItem );
    1504           0 :                             if ( pFmt->GetDoc()->GetEditShell() != NULL
    1505           0 :                                  && !sw_ChkAndSetNewAnchor( *(pFmt->GetDoc()->GetEditShell()), *pFly, *pSet ) )
    1506           0 :                                 delete pSet, pSet = 0;
    1507             :                         }
    1508             :                     }
    1509             :                 }
    1510             : 
    1511           0 :                 pFmt->GetDoc()->SetFrmFmtToFly( *pFmt, *pFrmFmt, pSet, false );
    1512           0 :                 delete pSet;
    1513             :             }
    1514             :             else
    1515           0 :                 throw lang::IllegalArgumentException();
    1516             :         }
    1517           0 :         else if( FN_UNO_GRAPHIC_U_R_L == pEntry->nWID ||
    1518           0 :                 FN_UNO_GRAPHIC_FILTER == pEntry->nWID)
    1519             :         {
    1520           0 :             OUString sGrfName;
    1521           0 :             OUString sFltName;
    1522           0 :             GraphicObject *pGrfObj = 0;
    1523           0 :             pFmt->GetDoc()->GetGrfNms( *(SwFlyFrmFmt*)pFmt, &sGrfName, &sFltName );
    1524           0 :             OUString sTmp;
    1525           0 :             aValue >>= sTmp;
    1526           0 :             UnoActionContext aAction(pFmt->GetDoc());
    1527           0 :             if(FN_UNO_GRAPHIC_U_R_L == pEntry->nWID)
    1528             :             {
    1529           0 :                 if( sTmp.startsWith(sPackageProtocol) )
    1530             :                 {
    1531           0 :                     pGrfObj = new GraphicObject;
    1532           0 :                     pGrfObj->SetUserData( sTmp );
    1533           0 :                     pGrfObj->SetSwapState();
    1534           0 :                     sGrfName = "";
    1535             :                 }
    1536           0 :                 else if( sTmp.startsWith(sGraphicObjectProtocol) )
    1537             :                 {
    1538             :                     const OString sId(OUStringToOString(
    1539           0 :                         sTmp.copy(sizeof(sGraphicObjectProtocol)-1),
    1540           0 :                         RTL_TEXTENCODING_ASCII_US));
    1541           0 :                     pGrfObj = new GraphicObject( sId );
    1542           0 :                     sGrfName = "";
    1543             :                 }
    1544             :                 else
    1545             :                 {
    1546           0 :                     sGrfName = sTmp;
    1547             :                 }
    1548             :             }
    1549             :             else
    1550             :             {
    1551           0 :                 sFltName = sTmp;
    1552             :             }
    1553             : 
    1554           0 :             const :: SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    1555           0 :             if(pIdx)
    1556             :             {
    1557           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    1558             : //              SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    1559           0 :                 SwGrfNode* pGrfNode = aIdx.GetNode().GetGrfNode();
    1560           0 :                 if(!pGrfNode)
    1561             :                 {
    1562           0 :                     delete pGrfObj;
    1563           0 :                     throw uno::RuntimeException();
    1564             :                 }
    1565           0 :                 SwPaM aGrfPaM(*pGrfNode);
    1566           0 :                 pFmt->GetDoc()->ReRead( aGrfPaM, sGrfName, sFltName, 0,
    1567           0 :                                         pGrfObj );
    1568             :             }
    1569           0 :             delete pGrfObj;
    1570             :         }
    1571           0 :         else if( FN_UNO_GRAPHIC == pEntry->nWID )
    1572             :         {
    1573           0 :             uno::Reference< graphic::XGraphic > xGraphic;
    1574           0 :             aValue >>= xGraphic;
    1575           0 :             if(xGraphic.is())
    1576             :             {
    1577           0 :                 const :: SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    1578           0 :                 if(pIdx)
    1579             :                 {
    1580           0 :                     SwNodeIndex aIdx(*pIdx, 1);
    1581           0 :                     SwGrfNode* pGrfNode = aIdx.GetNode().GetGrfNode();
    1582           0 :                     if(!pGrfNode)
    1583             :                     {
    1584           0 :                         throw uno::RuntimeException();
    1585             :                     }
    1586           0 :                     SwPaM aGrfPaM(*pGrfNode);
    1587           0 :                     Graphic aGraphic( xGraphic );
    1588           0 :                     pFmt->GetDoc()->ReRead( aGrfPaM, OUString(), OUString(), &aGraphic, 0 );
    1589             :                 }
    1590           0 :             }
    1591             :         }
    1592           0 :         else if( FN_UNO_REPLACEMENT_GRAPHIC_URL == pEntry->nWID || FN_UNO_REPLACEMENT_GRAPHIC == pEntry->nWID )
    1593             :         {
    1594           0 :             bool bURL = FN_UNO_REPLACEMENT_GRAPHIC_URL == pEntry->nWID;
    1595           0 :             bool bApply = false;
    1596           0 :             Graphic aGraphic;
    1597           0 :             if( bURL )
    1598             :             {
    1599           0 :                 GraphicObject *pGrfObj = 0;
    1600           0 :                 OUString aGrfUrl;
    1601           0 :                 aValue >>= aGrfUrl;
    1602             : 
    1603             :                 // the package URL based graphics are handled in different way currently
    1604             :                 // TODO/LATER: actually this is the correct place to handle them
    1605           0 :                 OUString aGraphicProtocol( sGraphicObjectProtocol );
    1606           0 :                 if( aGrfUrl.startsWith( aGraphicProtocol ) )
    1607             :                 {
    1608             :                     OString sId(OUStringToOString(
    1609           0 :                         aGrfUrl.copy(sizeof(sGraphicObjectProtocol)-1),
    1610           0 :                         RTL_TEXTENCODING_ASCII_US));
    1611           0 :                     pGrfObj = new GraphicObject( sId );
    1612           0 :                     aGraphic = pGrfObj->GetGraphic();
    1613           0 :                     bApply = true;
    1614           0 :                 }
    1615             :             }
    1616             :             else
    1617             :             {
    1618           0 :                 uno::Reference< graphic::XGraphic > xGraphic;
    1619           0 :                 aValue >>= xGraphic;
    1620           0 :                 if( xGraphic.is() )
    1621             :                 {
    1622           0 :                     aGraphic = Graphic( xGraphic );
    1623           0 :                     bApply = true;
    1624           0 :                 }
    1625             :             }
    1626             : 
    1627           0 :             if ( bApply )
    1628             :             {
    1629           0 :                 const :: SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    1630           0 :                 if ( pCnt->GetCntntIdx() && pDoc->GetNodes()[ pCnt->GetCntntIdx()->GetIndex() + 1 ] )
    1631             :                 {
    1632           0 :                     SwOLENode* pOleNode =  pDoc->GetNodes()[ pCnt->GetCntntIdx()->GetIndex() + 1 ]->GetOLENode();
    1633             : 
    1634           0 :                     if ( pOleNode )
    1635             :                     {
    1636           0 :                         svt::EmbeddedObjectRef &rObj = pOleNode->GetOLEObj().GetObject();
    1637             : 
    1638           0 :                         OUString aMediaType;
    1639           0 :                         rObj.SetGraphic( aGraphic, aMediaType );
    1640             :                     }
    1641             :                 }
    1642           0 :             }
    1643             :         }
    1644           0 :         else if((bNextFrame = (rPropertyName == UNO_NAME_CHAIN_NEXT_NAME))
    1645           0 :             || rPropertyName == UNO_NAME_CHAIN_PREV_NAME)
    1646             :         {
    1647           0 :             OUString sChainName;
    1648           0 :             aValue >>= sChainName;
    1649           0 :             if (sChainName.isEmpty())
    1650             :             {
    1651           0 :                 if(bNextFrame)
    1652           0 :                     pDoc->Unchain(*pFmt);
    1653             :                 else
    1654             :                 {
    1655           0 :                     SwFmtChain aChain( pFmt->GetChain() );
    1656           0 :                     SwFrmFmt *pPrev = aChain.GetPrev();
    1657           0 :                     if(pPrev)
    1658           0 :                         pDoc->Unchain(*pPrev);
    1659             :                 }
    1660             :             }
    1661             :             else
    1662             :             {
    1663           0 :                 sal_uInt16 nCount = pDoc->GetFlyCount(FLYCNTTYPE_FRM);
    1664             : 
    1665           0 :                 SwFrmFmt* pChain = 0;
    1666           0 :                 for( sal_uInt16 i = 0; i < nCount; i++)
    1667             :                 {
    1668           0 :                     SwFrmFmt* pFmt2 = pDoc->GetFlyNum(i, FLYCNTTYPE_FRM);
    1669           0 :                     if(sChainName == pFmt2->GetName() )
    1670             :                     {
    1671           0 :                         pChain = pFmt2;
    1672           0 :                         break;
    1673             :                     }
    1674             :                 }
    1675           0 :                 if(pChain)
    1676             :                 {
    1677           0 :                     SwFrmFmt* pSource = bNextFrame ? pFmt : pChain;
    1678           0 :                     SwFrmFmt* pDest = bNextFrame ? pChain: pFmt;
    1679           0 :                     pDoc->Chain(*pSource, *pDest);
    1680             :                 }
    1681           0 :             }
    1682             :         }
    1683           0 :         else if(FN_UNO_Z_ORDER == pEntry->nWID)
    1684             :         {
    1685           0 :             sal_Int32 nZOrder = - 1;
    1686           0 :             aValue >>= nZOrder;
    1687           0 :             if( nZOrder >= 0)
    1688             :             {
    1689             :                 SdrObject* pObject =
    1690           0 :                     GetOrCreateSdrObject( (SwFlyFrmFmt*)pFmt );
    1691           0 :                 SdrModel *pDrawModel = pDoc->GetDrawModel();
    1692           0 :                 pDrawModel->GetPage(0)->
    1693           0 :                             SetObjectOrdNum(pObject->GetOrdNum(), nZOrder);
    1694             :             }
    1695             :         }
    1696           0 :         else if(RES_ANCHOR == pEntry->nWID && MID_ANCHOR_ANCHORFRAME == nMemberId)
    1697             :         {
    1698           0 :             bool bDone = false;
    1699           0 :             uno::Reference<text::XTextFrame> xFrame;
    1700           0 :             if(aValue >>= xFrame)
    1701             :             {
    1702           0 :                 uno::Reference<lang::XUnoTunnel> xTunnel(xFrame, uno::UNO_QUERY);
    1703           0 :                 SwXFrame* pFrame = xTunnel.is() ?
    1704           0 :                         reinterpret_cast< SwXFrame * >( sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(SwXFrame::getUnoTunnelId()) ))
    1705           0 :                         : 0;
    1706           0 :                 if(pFrame && this != pFrame && pFrame->GetFrmFmt() && pFrame->GetFrmFmt()->GetDoc() == pDoc)
    1707             :                 {
    1708           0 :                     SfxItemSet aSet( pDoc->GetAttrPool(),
    1709           0 :                                 RES_FRMATR_BEGIN, RES_FRMATR_END - 1 );
    1710           0 :                     aSet.SetParent(&pFmt->GetAttrSet());
    1711           0 :                     SwFmtAnchor aAnchor = (const :: SwFmtAnchor&)aSet.Get(pEntry->nWID);
    1712             : 
    1713           0 :                     SwPosition aPos(*pFrame->GetFrmFmt()->GetCntnt().GetCntntIdx());
    1714           0 :                     aAnchor.SetAnchor(&aPos);
    1715           0 :                     aAnchor.SetType(FLY_AT_FLY);
    1716           0 :                     aSet.Put(aAnchor);
    1717           0 :                     pDoc->SetFlyFrmAttr( *pFmt, aSet );
    1718           0 :                     bDone = true;
    1719           0 :                 }
    1720             :             }
    1721           0 :             if(!bDone)
    1722           0 :                 throw lang::IllegalArgumentException();
    1723             :         }
    1724             :         else
    1725             :         {   //UUUU
    1726             :             // standard UNO API write attributes
    1727             :             // adapt former attr from SvxBrushItem::PutValue to new items XATTR_FILL_FIRST, XATTR_FILL_LAST
    1728           0 :             SfxItemSet aSet( pDoc->GetAttrPool(),
    1729             :                 RES_FRMATR_BEGIN, RES_FRMATR_END - 1,
    1730             :                 RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER,
    1731             : 
    1732             :                 //UUUU FillAttribute support
    1733             :                 XATTR_FILL_FIRST, XATTR_FILL_LAST,
    1734             : 
    1735           0 :                 0L);
    1736           0 :             bool bDone(false);
    1737             : 
    1738           0 :             aSet.SetParent(&pFmt->GetAttrSet());
    1739             : 
    1740           0 :             if(RES_BACKGROUND == pEntry->nWID)
    1741             :             {
    1742           0 :                 const SwAttrSet& rSet = pFmt->GetAttrSet();
    1743           0 :                 const SvxBrushItem aOriginalBrushItem(sw::getSvxBrushItemFromSourceSet(rSet));
    1744           0 :                 SvxBrushItem aChangedBrushItem(aOriginalBrushItem);
    1745             : 
    1746           0 :                 aChangedBrushItem.PutValue(aValue, nMemberId);
    1747             : 
    1748           0 :                 if(!(aChangedBrushItem == aOriginalBrushItem))
    1749             :                 {
    1750           0 :                     sw::setSvxBrushItemAsFillAttributesToTargetSet(aChangedBrushItem, aSet);
    1751           0 :                     pFmt->GetDoc()->SetFlyFrmAttr( *pFmt, aSet );
    1752             :                 }
    1753             : 
    1754           0 :                 bDone = true;
    1755             :             }
    1756           0 :             else if(OWN_ATTR_FILLBMP_MODE == pEntry->nWID)
    1757             :             {
    1758             :                 //UUUU
    1759             :                 drawing::BitmapMode eMode;
    1760             : 
    1761           0 :                 if(!(aValue >>= eMode))
    1762             :                 {
    1763           0 :                     sal_Int32 nMode = 0;
    1764             : 
    1765           0 :                     if(!(aValue >>= nMode))
    1766             :                     {
    1767           0 :                         throw lang::IllegalArgumentException();
    1768             :                     }
    1769             : 
    1770           0 :                     eMode = (drawing::BitmapMode)nMode;
    1771             :                 }
    1772             : 
    1773           0 :                 aSet.Put(XFillBmpStretchItem(drawing::BitmapMode_STRETCH == eMode));
    1774           0 :                 aSet.Put(XFillBmpTileItem(drawing::BitmapMode_REPEAT == eMode));
    1775           0 :                 pFmt->GetDoc()->SetFlyFrmAttr( *pFmt, aSet );
    1776           0 :                 bDone = true;
    1777             :             }
    1778             : 
    1779           0 :             if(!bDone)
    1780             :             {
    1781           0 :                 m_pPropSet->setPropertyValue(*pEntry, aValue, aSet);
    1782             :             }
    1783             : 
    1784           0 :             if(RES_ANCHOR == pEntry->nWID && MID_ANCHOR_ANCHORTYPE == nMemberId)
    1785             :             {
    1786           0 :                 SwFmtAnchor aAnchor = (const :: SwFmtAnchor&)aSet.Get(pEntry->nWID);
    1787           0 :                 if(aAnchor.GetAnchorId() == FLY_AT_FLY)
    1788             :                 {
    1789           0 :                     const :: SwPosition* pPosition = aAnchor.GetCntntAnchor();
    1790           0 :                     SwFrmFmt* pFlyFmt = pPosition ? pPosition->nNode.GetNode().GetFlyFmt() : 0;
    1791           0 :                     if(!pFlyFmt || pFlyFmt->Which() == RES_DRAWFRMFMT)
    1792             :                     {
    1793           0 :                         lang::IllegalArgumentException aExcept;
    1794           0 :                         aExcept.Message = "Anchor to frame: no frame found";
    1795           0 :                         throw aExcept;
    1796             :                     }
    1797             :                     else
    1798             :                     {
    1799           0 :                         SwPosition aPos = *pPosition;
    1800           0 :                         aPos.nNode = *pFlyFmt->GetCntnt().GetCntntIdx();
    1801           0 :                         aAnchor.SetAnchor(&aPos);
    1802           0 :                         aSet.Put(aAnchor);
    1803             :                     }
    1804             :                 }
    1805           0 :                 else if ((aAnchor.GetAnchorId() != FLY_AT_PAGE) &&
    1806           0 :                          !aAnchor.GetCntntAnchor())
    1807             :                 {
    1808           0 :                     SwNode& rNode = pDoc->GetNodes().GetEndOfContent();
    1809           0 :                     SwPaM aPam(rNode);
    1810           0 :                     aPam.Move( fnMoveBackward, fnGoDoc );
    1811           0 :                     aAnchor.SetAnchor( aPam.Start() );
    1812           0 :                     aSet.Put(aAnchor);
    1813             :                 }
    1814             : 
    1815             :                 // #i31771#, #i25798# - No adjustment of
    1816             :                 // anchor ( no call of method <sw_ChkAndSetNewAnchor(..)> ),
    1817             :                 // if document is currently in reading mode.
    1818           0 :                 if ( !pFmt->GetDoc()->IsInReading() )
    1819             :                 {
    1820             :                     // see SwFEShell::SetFlyFrmAttr( SfxItemSet& rSet )
    1821           0 :                     SwFlyFrm *pFly = 0;
    1822           0 :                     if (PTR_CAST(SwFlyFrmFmt, pFmt))
    1823           0 :                         pFly = ((SwFlyFrmFmt*)pFmt)->GetFrm();
    1824           0 :                     if (pFly)
    1825             :                     {
    1826             :                         const :: SfxPoolItem* pItem;
    1827           0 :                         if( SFX_ITEM_SET == aSet.GetItemState( RES_ANCHOR, false, &pItem ))
    1828             :                         {
    1829           0 :                             aSet.Put( *pItem );
    1830           0 :                             if ( pFmt->GetDoc()->GetEditShell() != NULL )
    1831             :                             {
    1832           0 :                                 sw_ChkAndSetNewAnchor( *(pFmt->GetDoc()->GetEditShell()), *pFly, aSet );
    1833             :                             }
    1834             :                         }
    1835             :                     }
    1836             :                 }
    1837             : 
    1838           0 :                 pFmt->GetDoc()->SetFlyFrmAttr( *pFmt, aSet );
    1839             :             }
    1840           0 :             else if(FN_UNO_CLSID == pEntry->nWID || FN_UNO_STREAM_NAME == pEntry->nWID || FN_EMBEDDED_OBJECT == pEntry->nWID)
    1841             :             {
    1842           0 :                 throw lang::IllegalArgumentException();
    1843             :             }
    1844             :             else
    1845           0 :                 pFmt->SetFmtAttr(aSet);
    1846             :         }
    1847             :     }
    1848           0 :     else if(IsDescriptor())
    1849             :     {
    1850           0 :         pProps->SetProperty(pEntry->nWID, nMemberId, aValue);
    1851           0 :         if( FN_UNO_FRAME_STYLE_NAME == pEntry->nWID )
    1852             :         {
    1853           0 :             OUString sStyleName;
    1854           0 :             aValue >>= sStyleName;
    1855             :             try
    1856             :             {
    1857           0 :                 uno::Any aAny = mxStyleFamily->getByName ( sStyleName );
    1858           0 :                 aAny >>= mxStyleData;
    1859             :             }
    1860           0 :             catch ( container::NoSuchElementException const & )
    1861             :             {
    1862             :             }
    1863           0 :             catch ( lang::WrappedTargetException const  & )
    1864             :             {
    1865             :             }
    1866           0 :             catch ( uno::RuntimeException const & )
    1867             :             {
    1868           0 :             }
    1869             :         }
    1870             :     }
    1871             :     else
    1872           0 :         throw uno::RuntimeException();
    1873           0 : }
    1874             : 
    1875           0 : uno::Any SwXFrame::getPropertyValue(const OUString& rPropertyName)
    1876             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    1877             : {
    1878           0 :     SolarMutexGuard aGuard;
    1879           0 :     uno::Any aAny;
    1880           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    1881           0 :     const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap().getByName(rPropertyName);
    1882           0 :     if (!pEntry)
    1883           0 :         throw beans::UnknownPropertyException(OUString( "Unknown property: " ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
    1884             : 
    1885             :     //UUUU
    1886           0 :     const sal_uInt8 nMemberId(pEntry->nMemberId & (~SFX_METRIC_ITEM));
    1887             : 
    1888           0 :     if(FN_UNO_ANCHOR_TYPES == pEntry->nWID)
    1889             :     {
    1890           0 :         uno::Sequence<text::TextContentAnchorType> aTypes(5);
    1891           0 :          text::TextContentAnchorType* pArray = aTypes.getArray();
    1892           0 :         pArray[0] = text::TextContentAnchorType_AT_PARAGRAPH;
    1893           0 :         pArray[1] = text::TextContentAnchorType_AS_CHARACTER;
    1894           0 :         pArray[2] = text::TextContentAnchorType_AT_PAGE;
    1895           0 :         pArray[3] = text::TextContentAnchorType_AT_FRAME;
    1896           0 :         pArray[4] = text::TextContentAnchorType_AT_CHARACTER;
    1897           0 :         aAny.setValue(&aTypes, ::getCppuType(static_cast<uno::Sequence<text::TextContentAnchorType>*>(0)));
    1898             :     }
    1899           0 :     else if(pFmt)
    1900             :     {
    1901           0 :         if( ((eType == FLYCNTTYPE_GRF) || (eType == FLYCNTTYPE_OLE)) &&
    1902           0 :                 pEntry &&
    1903           0 :                 (isGRFATR(pEntry->nWID) ||
    1904           0 :                         pEntry->nWID == FN_PARAM_COUNTOUR_PP ||
    1905           0 :                         pEntry->nWID == FN_UNO_IS_AUTOMATIC_CONTOUR ||
    1906           0 :                         pEntry->nWID == FN_UNO_IS_PIXEL_CONTOUR ))
    1907             :         {
    1908           0 :             const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    1909           0 :             if(pIdx)
    1910             :             {
    1911           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    1912           0 :                 SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    1913           0 :                 if(pEntry->nWID == FN_PARAM_COUNTOUR_PP)
    1914             :                 {
    1915           0 :                     PolyPolygon aContour;
    1916           0 :                     if( pNoTxt->GetContourAPI( aContour ) )
    1917             :                     {
    1918           0 :                         drawing::PointSequenceSequence aPtSeq(aContour.Count());
    1919           0 :                         drawing::PointSequence* pPSeq = aPtSeq.getArray();
    1920           0 :                         for(sal_uInt16 i = 0; i < aContour.Count(); i++)
    1921             :                         {
    1922           0 :                             const Polygon& rPoly = aContour.GetObject(i);
    1923           0 :                             pPSeq[i].realloc(rPoly.GetSize());
    1924           0 :                             awt::Point* pPoints = pPSeq[i].getArray();
    1925           0 :                             for(sal_uInt16 j = 0; j < rPoly.GetSize(); j++)
    1926             :                             {
    1927           0 :                                 const Point& rPoint = rPoly.GetPoint(j);
    1928           0 :                                 pPoints[j].X = rPoint.X();
    1929           0 :                                 pPoints[j].Y = rPoint.Y();
    1930             :                             }
    1931             :                         }
    1932           0 :                         aAny <<= aPtSeq;
    1933           0 :                     }
    1934             :                 }
    1935           0 :                 else if(pEntry->nWID == FN_UNO_IS_AUTOMATIC_CONTOUR )
    1936             :                 {
    1937           0 :                     sal_Bool bValue = pNoTxt->HasAutomaticContour();
    1938           0 :                     aAny.setValue( &bValue, ::getBooleanCppuType() );
    1939             :                 }
    1940           0 :                 else if(pEntry->nWID == FN_UNO_IS_PIXEL_CONTOUR )
    1941             :                 {
    1942           0 :                     sal_Bool bValue = pNoTxt->IsPixelContour();
    1943           0 :                     aAny.setValue( &bValue, ::getBooleanCppuType() );
    1944             :                 }
    1945             :                 else
    1946             :                 {
    1947           0 :                     SfxItemSet aSet(pNoTxt->GetSwAttrSet());
    1948           0 :                     m_pPropSet->getPropertyValue(*pEntry, aSet, aAny);
    1949           0 :                 }
    1950             :             }
    1951             :         }
    1952           0 :         else if( FN_UNO_GRAPHIC_U_R_L == pEntry->nWID)
    1953             :         {
    1954           0 :             OUString sGrfName;
    1955           0 :             const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    1956           0 :             if(pIdx)
    1957             :             {
    1958           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    1959             : //              SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    1960           0 :                 SwGrfNode* pGrfNode = aIdx.GetNode().GetGrfNode();
    1961           0 :                 if(!pGrfNode)
    1962           0 :                     throw uno::RuntimeException();
    1963           0 :                 if( pGrfNode->IsGrfLink() )
    1964             :                 {
    1965           0 :                     pFmt->GetDoc()->GetGrfNms( *(SwFlyFrmFmt*)pFmt, &sGrfName, 0 );
    1966             :                 }
    1967             :                 else
    1968             :                 {
    1969             :                     OUString sId(OStringToOUString(
    1970           0 :                         pGrfNode->GetGrfObj().GetUniqueID(),
    1971           0 :                         RTL_TEXTENCODING_ASCII_US));
    1972           0 :                     sGrfName = sGraphicObjectProtocol + sId;
    1973           0 :                 }
    1974             :             }
    1975           0 :             aAny <<= sGrfName;
    1976             :         }
    1977           0 :         else if( FN_UNO_REPLACEMENT_GRAPHIC_U_R_L == pEntry->nWID)
    1978             :         {
    1979           0 :             OUString sGrfName;
    1980           0 :             const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    1981             : 
    1982           0 :             if(pIdx)
    1983             :             {
    1984           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    1985           0 :                 SwGrfNode* pGrfNode = aIdx.GetNode().GetGrfNode();
    1986           0 :                 if(!pGrfNode)
    1987           0 :                     throw uno::RuntimeException();
    1988             : 
    1989           0 :                 const GraphicObject* pGraphicObject = pGrfNode->GetReplacementGrfObj();
    1990             : 
    1991           0 :                 if(pGraphicObject)
    1992             :                 {
    1993           0 :                     sGrfName = sGraphicObjectProtocol
    1994           0 :                              + OStringToOUString( pGraphicObject->GetUniqueID(), RTL_TEXTENCODING_ASCII_US );
    1995           0 :                 }
    1996             :             }
    1997             : 
    1998           0 :             aAny <<= sGrfName;
    1999             :         }
    2000           0 :         else if( FN_UNO_GRAPHIC_FILTER == pEntry->nWID )
    2001             :         {
    2002           0 :             OUString sFltName;
    2003           0 :             pFmt->GetDoc()->GetGrfNms( *(SwFlyFrmFmt*)pFmt, 0, &sFltName );
    2004           0 :                 aAny <<= sFltName;
    2005             :         }
    2006           0 :         else if( FN_UNO_GRAPHIC == pEntry->nWID )
    2007             :         {
    2008           0 :             const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2009           0 :             if(pIdx)
    2010             :             {
    2011           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    2012           0 :                 SwGrfNode* pGrfNode = aIdx.GetNode().GetGrfNode();
    2013           0 :                 if(!pGrfNode)
    2014           0 :                     throw uno::RuntimeException();
    2015           0 :                 aAny <<= pGrfNode->GetGrf().GetXGraphic();
    2016             :             }
    2017             :         }
    2018           0 :         else if(FN_UNO_FRAME_STYLE_NAME == pEntry->nWID)
    2019             :         {
    2020           0 :             aAny <<= OUString(SwStyleNameMapper::GetProgName(pFmt->DerivedFrom()->GetName(), nsSwGetPoolIdFromName::GET_POOLID_FRMFMT ) );
    2021             :         }
    2022             :         // #i73249#
    2023             :         // Attribute AlternativeText was never published.
    2024             :         // Now it has been replaced by Attribute Title - valid for all <SwXFrame> instances
    2025             : //        else if(eType != FLYCNTTYPE_FRM &&
    2026             : //                FN_UNO_ALTERNATIVE_TEXT == pEntry->nWID)
    2027             : //        {
    2028             : //            const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2029             : //            if(pIdx)
    2030             : //            {
    2031             : //                SwNodeIndex aIdx(*pIdx, 1);
    2032             : //                SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    2033             : //                aAny <<= OUString(pNoTxt->GetAlternateText());
    2034             : //            }
    2035             : //        }
    2036           0 :         else if( FN_UNO_TITLE == pEntry->nWID )
    2037             :         {
    2038           0 :             SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(pFmt);
    2039             :             OSL_ENSURE( pFmt,
    2040             :                     "unexpected type of <pFmt> --> crash" );
    2041             :             // assure that <SdrObject> instance exists.
    2042           0 :             GetOrCreateSdrObject( pFlyFmt );
    2043           0 :             aAny <<= OUString(pFlyFmt->GetObjTitle());
    2044             :         }
    2045             :         // New attribute Description
    2046           0 :         else if( FN_UNO_DESCRIPTION == pEntry->nWID )
    2047             :         {
    2048           0 :             SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(pFmt);
    2049             :             OSL_ENSURE( pFmt,
    2050             :                     "unexpected type of <pFmt> --> crash" );
    2051             :             // assure that <SdrObject> instance exists.
    2052           0 :             GetOrCreateSdrObject( pFlyFmt );
    2053           0 :             aAny <<= OUString(pFlyFmt->GetObjDescription());
    2054             :         }
    2055           0 :         else if(eType == FLYCNTTYPE_GRF &&
    2056           0 :                 (rPropertyName == UNO_NAME_ACTUAL_SIZE))
    2057             :         {
    2058           0 :             const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2059           0 :             if(pIdx)
    2060             :             {
    2061           0 :                 SwNodeIndex aIdx(*pIdx, 1);
    2062             :                 // --> OD #i85105#
    2063             : //                SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    2064             : //                Size aActSize = ((SwGrfNode*)pNoTxt)->GetTwipSize();
    2065           0 :                 Size aActSize;
    2066             :                 {
    2067           0 :                     SwGrfNode* pGrfNode = dynamic_cast<SwGrfNode*>(aIdx.GetNode().GetNoTxtNode());
    2068           0 :                     if ( pGrfNode )
    2069             :                     {
    2070           0 :                         aActSize = pGrfNode->GetTwipSize();
    2071           0 :                         if ( aActSize.Width() == 0 && aActSize.Height() == 0 &&
    2072           0 :                              pGrfNode->IsLinkedFile() )
    2073             :                         {
    2074           0 :                             pGrfNode->SwapIn( true );
    2075           0 :                             aActSize = pGrfNode->GetTwipSize();
    2076             :                         }
    2077             :                     }
    2078             :                 }
    2079             :                 // <--
    2080           0 :                 awt::Size aTmp;
    2081           0 :                 aTmp.Width = convertTwipToMm100(aActSize.Width());
    2082           0 :                 aTmp.Height = convertTwipToMm100(aActSize.Height());
    2083           0 :                 aAny.setValue(&aTmp, ::getCppuType(static_cast<const awt::Size*>(0)));
    2084             :             }
    2085             :         }
    2086           0 :         else if(FN_PARAM_LINK_DISPLAY_NAME == pEntry->nWID)
    2087             :         {
    2088           0 :             aAny <<= pFmt->GetName();
    2089             :         }
    2090           0 :         else if(FN_UNO_Z_ORDER == pEntry->nWID)
    2091             :         {
    2092           0 :             const SdrObject* pObj = pFmt->FindRealSdrObject();
    2093           0 :             if( pObj == NULL )
    2094           0 :                 pObj = pFmt->FindSdrObject();
    2095           0 :             if( pObj )
    2096             :             {
    2097           0 :                 aAny <<= (sal_Int32)pObj->GetOrdNum();
    2098             :             }
    2099             :         }
    2100           0 :         else if(FN_UNO_CLSID == pEntry->nWID || FN_UNO_MODEL == pEntry->nWID||
    2101           0 :                 FN_UNO_COMPONENT == pEntry->nWID ||FN_UNO_STREAM_NAME == pEntry->nWID||
    2102           0 :                 FN_EMBEDDED_OBJECT == pEntry->nWID)
    2103             :         {
    2104           0 :             SwDoc* pDoc = pFmt->GetDoc();
    2105           0 :             const SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    2106             :             OSL_ENSURE( pCnt->GetCntntIdx() &&
    2107             :                            pDoc->GetNodes()[ pCnt->GetCntntIdx()->
    2108             :                                             GetIndex() + 1 ]->GetOLENode(), "kein OLE-Node?");
    2109             : 
    2110           0 :             SwOLENode* pOleNode =  pDoc->GetNodes()[ pCnt->GetCntntIdx()
    2111           0 :                                             ->GetIndex() + 1 ]->GetOLENode();
    2112           0 :             uno::Reference < embed::XEmbeddedObject > xIP = pOleNode->GetOLEObj().GetOleRef();
    2113           0 :             OUString aHexCLSID;
    2114             :             {
    2115           0 :                 SvGlobalName aClassName( xIP->getClassID() );
    2116           0 :                 aHexCLSID = aClassName.GetHexName();
    2117           0 :                 if(FN_UNO_CLSID != pEntry->nWID)
    2118             :                 {
    2119           0 :                     if ( svt::EmbeddedObjectRef::TryRunningState( xIP ) )
    2120             :                     {
    2121           0 :                         uno::Reference < lang::XComponent > xComp( xIP->getComponent(), uno::UNO_QUERY );
    2122           0 :                         uno::Reference < frame::XModel > xModel( xComp, uno::UNO_QUERY );
    2123           0 :                         if ( FN_EMBEDDED_OBJECT == pEntry->nWID )
    2124             :                         {
    2125             :                             // ensure the
    2126             :                             OSL_ENSURE( pDoc->GetDocShell(), "no doc shell => no client site" );
    2127           0 :                             if ( pDoc->GetDocShell() )
    2128           0 :                                 pDoc->GetDocShell()->GetIPClient( svt::EmbeddedObjectRef( xIP, embed::Aspects::MSOLE_CONTENT ) );
    2129           0 :                             aAny <<= xIP;
    2130             :                         }
    2131           0 :                         else if ( xModel.is() )
    2132           0 :                             aAny <<= xModel;
    2133           0 :                         else if ( FN_UNO_COMPONENT == pEntry->nWID )
    2134           0 :                             aAny <<= xComp;
    2135             :                     }
    2136           0 :                 }
    2137             :             }
    2138             : 
    2139           0 :             if(FN_UNO_CLSID == pEntry->nWID)
    2140           0 :                 aAny <<= aHexCLSID;
    2141           0 :             else if(FN_UNO_STREAM_NAME == pEntry->nWID)
    2142             :             {
    2143           0 :                 aAny <<= OUString(pOleNode->GetOLEObj().GetCurrentPersistName());
    2144             :             }
    2145           0 :             else if(FN_EMBEDDED_OBJECT == pEntry->nWID)
    2146             :             {
    2147           0 :                 aAny <<= pOleNode->GetOLEObj().GetOleRef();
    2148           0 :             }
    2149             :         }
    2150           0 :         else if(WID_LAYOUT_SIZE == pEntry->nWID)
    2151             :         {
    2152             :             // format document completely in order to get correct value
    2153           0 :             pFmt->GetDoc()->GetEditShell()->CalcLayout();
    2154             : 
    2155           0 :             SwFrm* pTmpFrm = SwIterator<SwFrm,SwFmt>::FirstElement( *pFmt );
    2156           0 :             if ( pTmpFrm )
    2157             :             {
    2158             :                 OSL_ENSURE( pTmpFrm->IsValid(), "frame not valid" );
    2159           0 :                 const SwRect &rRect = pTmpFrm->Frm();
    2160             :                 Size aMM100Size = OutputDevice::LogicToLogic(
    2161             :                         Size( rRect.Width(), rRect.Height() ),
    2162           0 :                         MapMode( MAP_TWIP ), MapMode( MAP_100TH_MM ));
    2163           0 :                 aAny <<= awt::Size( aMM100Size.Width(), aMM100Size.Height() );
    2164             :             }
    2165             :         }
    2166             :         else
    2167             :         {   //UUUU
    2168             :             // standard UNO API read attributes
    2169             :             // adapt former attr from SvxBrushItem::PutValue to new items XATTR_FILL_FIRST, XATTR_FILL_LAST
    2170           0 :             const SwAttrSet& rSet = pFmt->GetAttrSet();
    2171           0 :             bool bDone(false);
    2172             : 
    2173           0 :             if(RES_BACKGROUND == pEntry->nWID)
    2174             :             {
    2175             :                 //UUUU
    2176           0 :                 const SvxBrushItem aOriginalBrushItem(sw::getSvxBrushItemFromSourceSet(rSet));
    2177             : 
    2178           0 :                 if(!aOriginalBrushItem.QueryValue(aAny, nMemberId))
    2179             :                 {
    2180             :                     OSL_ENSURE(false, "Error getting attribute from RES_BACKGROUND (!)");
    2181             :                 }
    2182             : 
    2183           0 :                 bDone = true;
    2184             :             }
    2185           0 :             else if(OWN_ATTR_FILLBMP_MODE == pEntry->nWID)
    2186             :             {
    2187             :                 //UUUU
    2188           0 :                 const XFillBmpStretchItem* pStretchItem = dynamic_cast< const XFillBmpStretchItem* >(&rSet.Get(XATTR_FILLBMP_STRETCH));
    2189           0 :                 const XFillBmpTileItem* pTileItem = dynamic_cast< const XFillBmpTileItem* >(&rSet.Get(XATTR_FILLBMP_TILE));
    2190             : 
    2191           0 :                 if( pTileItem && pTileItem->GetValue() )
    2192             :                 {
    2193           0 :                     aAny <<= drawing::BitmapMode_REPEAT;
    2194             :                 }
    2195           0 :                 else if( pStretchItem && pStretchItem->GetValue() )
    2196             :                 {
    2197           0 :                     aAny <<= drawing::BitmapMode_STRETCH;
    2198             :                 }
    2199             :                 else
    2200             :                 {
    2201           0 :                     aAny <<= drawing::BitmapMode_NO_REPEAT;
    2202             :                 }
    2203             : 
    2204           0 :                 bDone = true;
    2205             :             }
    2206             : 
    2207           0 :             if(!bDone)
    2208             :             {
    2209           0 :                 m_pPropSet->getPropertyValue(*pEntry, rSet, aAny);
    2210             :             }
    2211             :         }
    2212             :     }
    2213           0 :     else if(IsDescriptor())
    2214             :     {
    2215           0 :         if ( ! m_pDoc )
    2216           0 :             throw uno::RuntimeException();
    2217           0 :         if(WID_LAYOUT_SIZE != pEntry->nWID)  // there is no LayoutSize in a descriptor
    2218             :         {
    2219           0 :             const uno::Any* pAny = 0;
    2220           0 :             if( !pProps->GetProperty( pEntry->nWID, nMemberId, pAny ) )
    2221           0 :                 aAny = mxStyleData->getPropertyValue( rPropertyName );
    2222           0 :             else if ( pAny )
    2223           0 :                 aAny = *pAny;
    2224             :         }
    2225             :     }
    2226             :     else
    2227           0 :         throw uno::RuntimeException();
    2228             : 
    2229             :     //UUUU
    2230           0 :     if(pEntry && pEntry->aType == ::getCppuType((const sal_Int16*)0) && pEntry->aType != aAny.getValueType())
    2231             :     {
    2232             :         // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
    2233           0 :         sal_Int32 nValue = 0;
    2234           0 :         aAny >>= nValue;
    2235           0 :         aAny <<= (sal_Int16)nValue;
    2236             :     }
    2237             : 
    2238             :     //UUUU check for needed metric translation
    2239           0 :     if(pEntry->nMemberId & SFX_METRIC_ITEM)
    2240             :     {
    2241           0 :         bool bDoIt(true);
    2242             : 
    2243           0 :         if(XATTR_FILLBMP_SIZEX == pEntry->nWID || XATTR_FILLBMP_SIZEY == pEntry->nWID)
    2244             :         {
    2245             :             // exception: If these ItemTypes are used, do not convert when these are negative
    2246             :             // since this means they are intended as percent values
    2247           0 :             sal_Int32 nValue = 0;
    2248             : 
    2249           0 :             if(aAny >>= nValue)
    2250             :             {
    2251           0 :                 bDoIt = nValue > 0;
    2252             :             }
    2253             :         }
    2254             : 
    2255           0 :         if(bDoIt)
    2256             :         {
    2257           0 :             const SwDoc* pDoc = (IsDescriptor() ? m_pDoc : GetFrmFmt()->GetDoc());
    2258           0 :             const SfxItemPool& rPool = pDoc->GetAttrPool();
    2259           0 :             const SfxMapUnit eMapUnit(rPool.GetMetric(pEntry->nWID));
    2260             : 
    2261           0 :             if(eMapUnit != SFX_MAPUNIT_100TH_MM)
    2262             :             {
    2263           0 :                 SvxUnoConvertToMM(eMapUnit, aAny);
    2264             :             }
    2265             :         }
    2266             :     }
    2267             : 
    2268           0 :     return aAny;
    2269             : }
    2270             : 
    2271           0 : void SwXFrame::addPropertyChangeListener(const OUString& /*PropertyName*/,
    2272             :     const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
    2273             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    2274             : {
    2275             :     OSL_FAIL("not implemented");
    2276           0 : }
    2277             : 
    2278           0 : void SwXFrame::removePropertyChangeListener(const OUString& /*PropertyName*/,
    2279             :     const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
    2280             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    2281             : {
    2282             :     OSL_FAIL("not implemented");
    2283           0 : }
    2284             : 
    2285           0 : void SwXFrame::addVetoableChangeListener(const OUString& /*PropertyName*/,
    2286             :                                 const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
    2287             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    2288             : {
    2289             :     OSL_FAIL("not implemented");
    2290           0 : }
    2291             : 
    2292           0 : void SwXFrame::removeVetoableChangeListener(
    2293             :     const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
    2294             :         throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    2295             : {
    2296             :     OSL_FAIL("not implemented");
    2297           0 : }
    2298             : 
    2299           0 : beans::PropertyState SwXFrame::getPropertyState( const OUString& rPropertyName )
    2300             :     throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
    2301             : {
    2302           0 :     SolarMutexGuard aGuard;
    2303           0 :     uno::Sequence< OUString > aPropertyNames(1);
    2304           0 :     OUString* pNames = aPropertyNames.getArray();
    2305           0 :     pNames[0] = rPropertyName;
    2306           0 :     uno::Sequence< beans::PropertyState > aStates = getPropertyStates(aPropertyNames);
    2307           0 :     return aStates.getConstArray()[0];
    2308             : }
    2309             : 
    2310             : //UUUU
    2311           0 : bool SwXFrame::needToMapFillItemsToSvxBrushItemTypes() const
    2312             : {
    2313           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    2314             : 
    2315           0 :     if(!pFmt)
    2316             :     {
    2317           0 :         return false;
    2318             :     }
    2319             : 
    2320           0 :     const SwAttrSet& rFmtSet = pFmt->GetAttrSet();
    2321           0 :     const XFillStyleItem* pXFillStyleItem(static_cast< const XFillStyleItem*  >(rFmtSet.GetItem(XATTR_FILLSTYLE, false)));
    2322             : 
    2323           0 :     if(!pXFillStyleItem)
    2324             :     {
    2325           0 :         return false;
    2326             :     }
    2327             : 
    2328             :     //UUUU here different FillStyles can be excluded for export; it will depend on the
    2329             :     // quality these fallbacks can reach. That again is done in sw::getSvxBrushItemFromSourceSet,
    2330             :     // take a look there how the superset of DrawObject FillStyles is mapped to SvxBrushItem.
    2331             :     // For now, take them all - except XFILL_NONE
    2332             : 
    2333           0 :     if(XFILL_NONE != pXFillStyleItem->GetValue())
    2334             :     {
    2335           0 :         return true;
    2336             :     }
    2337             : 
    2338             :     //if(XFILL_SOLID == pXFillStyleItem->GetValue() || XFILL_BITMAP == pXFillStyleItem->GetValue())
    2339             :     //{
    2340             :     //    return true;
    2341             :     //}
    2342             : 
    2343           0 :     return false;
    2344             : }
    2345             : 
    2346           0 : uno::Sequence< beans::PropertyState > SwXFrame::getPropertyStates(
    2347             :     const uno::Sequence< OUString >& aPropertyNames )
    2348             :         throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
    2349             : {
    2350           0 :     SolarMutexGuard aGuard;
    2351           0 :     uno::Sequence< beans::PropertyState > aStates(aPropertyNames.getLength());
    2352           0 :     beans::PropertyState* pStates = aStates.getArray();
    2353           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    2354           0 :     if(pFmt)
    2355             :     {
    2356           0 :         const OUString* pNames = aPropertyNames.getConstArray();
    2357           0 :         const SwAttrSet& rFmtSet = pFmt->GetAttrSet();
    2358           0 :         for(int i = 0; i < aPropertyNames.getLength(); i++)
    2359             :         {
    2360           0 :             const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap().getByName(pNames[i]);
    2361           0 :             if (!pEntry)
    2362           0 :                 throw beans::UnknownPropertyException(OUString( "Unknown property: " ) + pNames[i], static_cast < cppu::OWeakObject * > ( this ) );
    2363             : 
    2364           0 :             if(pEntry->nWID == FN_UNO_ANCHOR_TYPES||
    2365           0 :                 pEntry->nWID == FN_PARAM_LINK_DISPLAY_NAME||
    2366           0 :                 FN_UNO_FRAME_STYLE_NAME == pEntry->nWID||
    2367           0 :                 FN_UNO_GRAPHIC_U_R_L == pEntry->nWID||
    2368           0 :                 FN_UNO_GRAPHIC_FILTER     == pEntry->nWID||
    2369           0 :                 FN_UNO_ACTUAL_SIZE == pEntry->nWID||
    2370           0 :                 FN_UNO_ALTERNATIVE_TEXT == pEntry->nWID)
    2371             :             {
    2372           0 :                 pStates[i] = beans::PropertyState_DIRECT_VALUE;
    2373             :             }
    2374           0 :             else if(OWN_ATTR_FILLBMP_MODE == pEntry->nWID)
    2375             :             {
    2376             :                 //UUUU
    2377           0 :                 if(SFX_ITEM_SET == rFmtSet.GetItemState(XATTR_FILLBMP_STRETCH, false)
    2378           0 :                     || SFX_ITEM_SET == rFmtSet.GetItemState(XATTR_FILLBMP_TILE, false))
    2379             :                 {
    2380           0 :                     pStates[i] = beans::PropertyState_DIRECT_VALUE;
    2381             :                 }
    2382             :                 else
    2383             :                 {
    2384           0 :                     pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
    2385             :                 }
    2386             :             }
    2387             :             //UUUU for FlyFrames we need to mark all properties from type RES_BACKGROUND
    2388             :             // as beans::PropertyState_DIRECT_VALUE to let users of this property call
    2389             :             // getPropertyValue where the member properties will be mapped from the
    2390             :             // fill attributes to the according SvxBrushItem entries
    2391           0 :             else if(RES_BACKGROUND == pEntry->nWID && needToMapFillItemsToSvxBrushItemTypes())
    2392             :             {
    2393           0 :                 pStates[i] = beans::PropertyState_DIRECT_VALUE;
    2394             :             }
    2395             :             else
    2396             :             {
    2397           0 :                 if ((eType == FLYCNTTYPE_GRF) &&
    2398           0 :                         pEntry && isGRFATR(pEntry->nWID))
    2399             :                 {
    2400           0 :                     const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2401           0 :                     if(pIdx)
    2402             :                     {
    2403           0 :                         SwNodeIndex aIdx(*pIdx, 1);
    2404           0 :                         SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    2405           0 :                         SfxItemSet aSet(pNoTxt->GetSwAttrSet());
    2406           0 :                         aSet.GetItemState(pEntry->nWID);
    2407           0 :                         if(SFX_ITEM_SET == aSet.GetItemState( pEntry->nWID, false ))
    2408           0 :                             pStates[i] = beans::PropertyState_DIRECT_VALUE;
    2409             :                     }
    2410             :                 }
    2411             :                 else
    2412             :                 {
    2413           0 :                     if(SFX_ITEM_SET == rFmtSet.GetItemState( pEntry->nWID, false ))
    2414           0 :                         pStates[i] = beans::PropertyState_DIRECT_VALUE;
    2415             :                     else
    2416           0 :                         pStates[i] = beans::PropertyState_DEFAULT_VALUE;
    2417             :                 }
    2418             :             }
    2419             :         }
    2420             :     }
    2421           0 :     else if(IsDescriptor())
    2422             :     {
    2423           0 :         for(int i = 0; i < aPropertyNames.getLength(); i++)
    2424           0 :             pStates[i] = beans::PropertyState_DIRECT_VALUE;
    2425             :     }
    2426             :     else
    2427           0 :         throw uno::RuntimeException();
    2428           0 :     return aStates;
    2429             : }
    2430             : 
    2431           0 : void SwXFrame::setPropertyToDefault( const OUString& rPropertyName )
    2432             :     throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
    2433             : {
    2434           0 :     SolarMutexGuard aGuard;
    2435           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    2436           0 :     if(pFmt)
    2437             :     {
    2438           0 :         const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap().getByName(rPropertyName);
    2439           0 :         if (!pEntry)
    2440           0 :             throw beans::UnknownPropertyException(OUString( "Unknown property: " ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
    2441           0 :         if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
    2442           0 :             throw uno::RuntimeException("setPropertyToDefault: property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
    2443             : 
    2444             :         bool bNextFrame;
    2445           0 :         if(OWN_ATTR_FILLBMP_MODE == pEntry->nWID)
    2446             :         {
    2447             :             //UUUU
    2448           0 :             SwDoc* pDoc = pFmt->GetDoc();
    2449           0 :             SfxItemSet aSet(pDoc->GetAttrPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST);
    2450           0 :             aSet.SetParent(&pFmt->GetAttrSet());
    2451             : 
    2452           0 :             aSet.ClearItem(XATTR_FILLBMP_STRETCH);
    2453           0 :             aSet.ClearItem(XATTR_FILLBMP_TILE);
    2454             : 
    2455           0 :             pFmt->SetFmtAttr(aSet);
    2456             :         }
    2457           0 :         else if( pEntry->nWID &&
    2458           0 :             pEntry->nWID != FN_UNO_ANCHOR_TYPES &&
    2459           0 :             pEntry->nWID != FN_PARAM_LINK_DISPLAY_NAME)
    2460             :         {
    2461           0 :             if ( (eType == FLYCNTTYPE_GRF) && isGRFATR(pEntry->nWID) )
    2462             :             {
    2463           0 :                 const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2464           0 :                 if(pIdx)
    2465             :                 {
    2466           0 :                     SwNodeIndex aIdx(*pIdx, 1);
    2467           0 :                     SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    2468             :                     {
    2469           0 :                         SfxItemSet aSet(pNoTxt->GetSwAttrSet());
    2470           0 :                         aSet.ClearItem(pEntry->nWID);
    2471           0 :                         pNoTxt->SetAttr(aSet);
    2472           0 :                     }
    2473             :                 }
    2474             :             }
    2475             :             // #i73249#
    2476             :             // Attribute AlternativeText was never published.
    2477             :             // Now it has been replaced by Attribute Title - valid for all <SwXFrame> instances
    2478             : //            else if( eType != FLYCNTTYPE_FRM && FN_UNO_ALTERNATIVE_TEXT == pEntry->nWID )
    2479             : //            {
    2480             : //                const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2481             : //                if(pIdx)
    2482             : //                {
    2483             : //                    SwNodeIndex aIdx(*pIdx, 1);
    2484             : //                    SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    2485             : //                    pNoTxt->SetAlternateText(aEmptyOUStr);
    2486             : //                }
    2487             : //            }
    2488             :             // New attribute Title
    2489           0 :             else if( FN_UNO_TITLE == pEntry->nWID )
    2490             :             {
    2491           0 :                 SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(pFmt);
    2492             :                 OSL_ENSURE( pFmt,
    2493             :                         "unexpected type of <pFmt> --> crash" );
    2494             :                 // assure that <SdrObject> instance exists.
    2495           0 :                 GetOrCreateSdrObject( pFlyFmt );
    2496           0 :                 pFlyFmt->GetDoc()->SetFlyFrmTitle( *(pFlyFmt), aEmptyOUStr );
    2497             :             }
    2498             :             // New attribute Description
    2499           0 :             else if( FN_UNO_DESCRIPTION == pEntry->nWID )
    2500             :             {
    2501           0 :                 SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(pFmt);
    2502             :                 OSL_ENSURE( pFmt,
    2503             :                         "unexpected type of <pFmt> --> crash" );
    2504             :                 // assure that <SdrObject> instance exists.
    2505           0 :                 GetOrCreateSdrObject( pFlyFmt );
    2506           0 :                 pFlyFmt->GetDoc()->SetFlyFrmDescription( *(pFlyFmt), aEmptyOUStr );
    2507             :             }
    2508             :             else
    2509             :             {
    2510           0 :                 SwDoc* pDoc = pFmt->GetDoc();
    2511           0 :                 SfxItemSet aSet( pDoc->GetAttrPool(),
    2512           0 :                     RES_FRMATR_BEGIN, RES_FRMATR_END - 1 );
    2513           0 :                 aSet.SetParent(&pFmt->GetAttrSet());
    2514           0 :                 aSet.ClearItem(pEntry->nWID);
    2515           0 :                 if(rPropertyName != UNO_NAME_ANCHOR_TYPE)
    2516           0 :                     pFmt->SetFmtAttr(aSet);
    2517           0 :             }
    2518             :         }
    2519           0 :         else if((bNextFrame = (rPropertyName == UNO_NAME_CHAIN_NEXT_NAME))
    2520           0 :                 || rPropertyName == UNO_NAME_CHAIN_PREV_NAME)
    2521             :         {
    2522           0 :             SwDoc* pDoc = pFmt->GetDoc();
    2523           0 :             if(bNextFrame)
    2524           0 :                 pDoc->Unchain(*pFmt);
    2525             :             else
    2526             :             {
    2527           0 :                 SwFmtChain aChain( pFmt->GetChain() );
    2528           0 :                 SwFrmFmt *pPrev = aChain.GetPrev();
    2529           0 :                 if(pPrev)
    2530           0 :                     pDoc->Unchain(*pPrev);
    2531             :             }
    2532             :         }
    2533             :     }
    2534           0 :     else if(!IsDescriptor())
    2535           0 :         throw uno::RuntimeException();
    2536             : 
    2537           0 : }
    2538             : 
    2539           0 : uno::Any SwXFrame::getPropertyDefault( const OUString& rPropertyName )
    2540             :     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
    2541             : {
    2542           0 :     SolarMutexGuard aGuard;
    2543           0 :     uno::Any aRet;
    2544           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    2545           0 :     if(pFmt)
    2546             :     {
    2547           0 :         const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap().getByName(rPropertyName);
    2548           0 :         if(pEntry)
    2549             :         {
    2550           0 :             if ( pEntry->nWID < RES_FRMATR_END )
    2551             :             {
    2552             :                 const SfxPoolItem& rDefItem =
    2553           0 :                     pFmt->GetDoc()->GetAttrPool().GetDefaultItem(pEntry->nWID);
    2554             :                 //UUUU
    2555           0 :                 const sal_uInt8 nMemberId(pEntry->nMemberId & (~SFX_METRIC_ITEM));
    2556             : 
    2557           0 :                 rDefItem.QueryValue(aRet, nMemberId);
    2558             :             }
    2559             :         }
    2560             :         else
    2561           0 :             throw beans::UnknownPropertyException(OUString( "Unknown property: " ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
    2562             :     }
    2563           0 :     else if(!IsDescriptor())
    2564           0 :         throw uno::RuntimeException();
    2565           0 :     return aRet;
    2566             : }
    2567             : 
    2568           0 : void SAL_CALL SwXFrame::addEventListener(
    2569             :         const uno::Reference<lang::XEventListener> & xListener)
    2570             : throw (uno::RuntimeException, std::exception)
    2571             : {
    2572             :     // no need to lock here as m_pImpl is const and container threadsafe
    2573           0 :     m_pImpl->m_EventListeners.addInterface(xListener);
    2574           0 : }
    2575             : 
    2576           0 : void SAL_CALL SwXFrame::removeEventListener(
    2577             :         const uno::Reference<lang::XEventListener> & xListener)
    2578             : throw (uno::RuntimeException, std::exception)
    2579             : {
    2580             :     // no need to lock here as m_pImpl is const and container threadsafe
    2581           0 :     m_pImpl->m_EventListeners.removeInterface(xListener);
    2582           0 : }
    2583             : 
    2584           0 : void    SwXFrame::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
    2585             : {
    2586           0 :     ClientModify(this, pOld, pNew);
    2587           0 :     if(!GetRegisteredIn())
    2588             :     {
    2589           0 :         mxStyleData.clear();
    2590           0 :         mxStyleFamily.clear();
    2591           0 :         m_pDoc = 0;
    2592           0 :         lang::EventObject const ev(static_cast< ::cppu::OWeakObject&>(*this));
    2593           0 :         m_pImpl->m_EventListeners.disposeAndClear(ev);
    2594             :     }
    2595           0 : }
    2596             : 
    2597           0 : void SwXFrame::dispose(void) throw( uno::RuntimeException, std::exception )
    2598             : {
    2599           0 :     SolarMutexGuard aGuard;
    2600           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    2601           0 :     if ( pFmt )
    2602             :     {
    2603           0 :         SdrObject* pObj = pFmt->FindSdrObject();
    2604             :         // OD 11.09.2003 #112039# - add condition to perform delete of
    2605             :         // format/anchor sign, not only if the object is inserted, but also
    2606             :         // if a contact object is registered, which isn't in the destruction.
    2607           0 :         if ( pObj &&
    2608           0 :              ( pObj->IsInserted() ||
    2609           0 :                ( pObj->GetUserCall() &&
    2610           0 :                  !static_cast<SwContact*>(pObj->GetUserCall())->IsInDTOR() ) ) )
    2611             :         {
    2612           0 :             if (pFmt->GetAnchor().GetAnchorId() == FLY_AS_CHAR)
    2613             :             {
    2614           0 :                 const SwPosition &rPos = *(pFmt->GetAnchor().GetCntntAnchor());
    2615           0 :                 SwTxtNode *pTxtNode = rPos.nNode.GetNode().GetTxtNode();
    2616           0 :                 const sal_Int32 nIdx = rPos.nContent.GetIndex();
    2617           0 :                 pTxtNode->DeleteAttributes( RES_TXTATR_FLYCNT, nIdx, nIdx );
    2618             :             }
    2619             :             else
    2620           0 :                 pFmt->GetDoc()->DelLayoutFmt(pFmt);
    2621             :         }
    2622           0 :     }
    2623             : 
    2624           0 : }
    2625             : 
    2626           0 : uno::Reference< text::XTextRange >  SwXFrame::getAnchor(void) throw( uno::RuntimeException, std::exception )
    2627             : {
    2628           0 :     SolarMutexGuard aGuard;
    2629           0 :     uno::Reference< text::XTextRange >  aRef;
    2630           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    2631           0 :     if(pFmt)
    2632             :     {
    2633           0 :         const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
    2634             :         // return an anchor for non-page bound frames
    2635             :         // and for page bound frames that have a page no == NULL and a content position
    2636           0 :         if ((rAnchor.GetAnchorId() != FLY_AT_PAGE) ||
    2637           0 :             (rAnchor.GetCntntAnchor() && !rAnchor.GetPageNum()))
    2638             :         {
    2639           0 :             const SwPosition &rPos = *(rAnchor.GetCntntAnchor());
    2640           0 :             aRef = SwXTextRange::CreateXTextRange(*pFmt->GetDoc(), rPos, 0);
    2641             :         }
    2642             :     }
    2643             :     else
    2644           0 :         throw uno::RuntimeException();
    2645           0 :     return aRef;
    2646             : }
    2647             : 
    2648           0 : void SwXFrame::ResetDescriptor()
    2649             : {
    2650           0 :     bIsDescriptor = false;
    2651           0 :     mxStyleData.clear();
    2652           0 :     mxStyleFamily.clear();
    2653           0 :     DELETEZ(pProps);
    2654           0 : }
    2655             : 
    2656           0 : void SwXFrame::attachToRange(const uno::Reference< text::XTextRange > & xTextRange)
    2657             :             throw( lang::IllegalArgumentException, uno::RuntimeException )
    2658             : {
    2659           0 :     SolarMutexGuard aGuard;
    2660           0 :     if(!IsDescriptor())
    2661           0 :         throw uno::RuntimeException();
    2662           0 :     uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
    2663           0 :     SwXTextRange* pRange = 0;
    2664           0 :     OTextCursorHelper* pCursor = 0;
    2665           0 :     if(xRangeTunnel.is())
    2666             :     {
    2667             :         pRange  = reinterpret_cast< SwXTextRange * >(
    2668           0 :                 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
    2669             :         pCursor = reinterpret_cast< OTextCursorHelper * >(
    2670           0 :                 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
    2671             :     }
    2672             : 
    2673           0 :     SwDoc* pDoc = pRange ? (SwDoc*)pRange->GetDoc() : pCursor ? (SwDoc*)pCursor->GetDoc() : 0;
    2674           0 :     if(pDoc)
    2675             :     {
    2676           0 :         SwUnoInternalPaM aIntPam(*pDoc);
    2677             :         //das muss jetzt true liefern
    2678           0 :         ::sw::XTextRangeToSwPaM(aIntPam, xTextRange);
    2679             : 
    2680           0 :         SwNode& rNode = pDoc->GetNodes().GetEndOfContent();
    2681           0 :         SwPaM aPam(rNode);
    2682           0 :         aPam.Move( fnMoveBackward, fnGoDoc );
    2683             :         static sal_uInt16 const aFrmAttrRange[] =
    2684             :         {
    2685             :             RES_FRMATR_BEGIN,       RES_FRMATR_END-1,
    2686             :             RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER,
    2687             : 
    2688             :             //UUUU FillAttribute support
    2689             :             XATTR_FILL_FIRST, XATTR_FILL_LAST,
    2690             : 
    2691             :             SID_ATTR_BORDER_INNER,  SID_ATTR_BORDER_INNER,
    2692             :             0
    2693             :         };
    2694             :         static sal_uInt16 const aGrAttrRange[] =
    2695             :         {
    2696             :             RES_GRFATR_BEGIN,       RES_GRFATR_END-1,
    2697             :             0
    2698             :         };
    2699           0 :         SfxItemSet aGrSet(pDoc->GetAttrPool(), aGrAttrRange );
    2700             : 
    2701           0 :         SfxItemSet aFrmSet(pDoc->GetAttrPool(), aFrmAttrRange );
    2702             :         //jetzt muessen die passenden Items in den Set
    2703             :         bool bSizeFound;
    2704           0 :         if(!pProps->AnyToItemSet( pDoc, aFrmSet, aGrSet, bSizeFound))
    2705           0 :             throw lang::IllegalArgumentException();
    2706             :         //der TextRange wird einzeln behandelt
    2707           0 :         *aPam.GetPoint() = *aIntPam.GetPoint();
    2708           0 :         if(aIntPam.HasMark())
    2709             :         {
    2710           0 :             aPam.SetMark();
    2711           0 :             *aPam.GetMark() = *aIntPam.GetMark();
    2712             :         }
    2713             : 
    2714             :         const SfxPoolItem* pItem;
    2715           0 :         RndStdIds eAnchorId = FLY_AT_PARA;
    2716           0 :         if(SFX_ITEM_SET == aFrmSet.GetItemState(RES_ANCHOR, false, &pItem) )
    2717             :         {
    2718           0 :             eAnchorId = ((const SwFmtAnchor*)pItem)->GetAnchorId();
    2719           0 :             if( FLY_AT_FLY == eAnchorId &&
    2720           0 :                 !aPam.GetNode()->FindFlyStartNode())
    2721             :             {
    2722             :                 //rahmengebunden geht nur dort, wo ein Rahmen ist!
    2723           0 :                 SwFmtAnchor aAnchor(FLY_AT_PARA);
    2724           0 :                 aFrmSet.Put(aAnchor);
    2725             :             }
    2726           0 :             else if ((FLY_AT_PAGE == eAnchorId) &&
    2727           0 :                      0 == ((const SwFmtAnchor*)pItem)->GetPageNum() )
    2728             :             {
    2729           0 :                 SwFmtAnchor aAnchor( *((const SwFmtAnchor*)pItem) );
    2730           0 :                 aAnchor.SetAnchor( aPam.GetPoint() );
    2731           0 :                 aFrmSet.Put(aAnchor);
    2732             :             }
    2733             :         }
    2734             : 
    2735             :         const ::uno::Any* pStyle;
    2736           0 :         SwFrmFmt *pParentFrmFmt = 0;
    2737           0 :         if(pProps->GetProperty(FN_UNO_FRAME_STYLE_NAME, 0, pStyle))
    2738           0 :             pParentFrmFmt = lcl_GetFrmFmt( *pStyle, pDoc );
    2739             : 
    2740           0 :         SwFlyFrmFmt* pFmt = 0;
    2741           0 :         if( eType == FLYCNTTYPE_FRM)
    2742             :         {
    2743           0 :             UnoActionContext aCont(pDoc);
    2744           0 :             if(m_pCopySource)
    2745             :             {
    2746           0 :                 SwFmtAnchor* pAnchorItem = 0;
    2747             :                 // the frame is inserted bound to page
    2748             :                 // to prevent conflicts if the to-be-anchored position is part of the to-be-copied text
    2749           0 :                 if (eAnchorId != FLY_AT_PAGE)
    2750             :                 {
    2751           0 :                     pAnchorItem = static_cast<SwFmtAnchor*>(aFrmSet.Get(RES_ANCHOR).Clone());
    2752           0 :                     aFrmSet.Put( SwFmtAnchor( FLY_AT_PAGE, 1 ));
    2753             :                 }
    2754             : 
    2755           0 :                 aPam.DeleteMark(); // mark position node will be deleted!
    2756           0 :                 aIntPam.DeleteMark(); // mark position node will be deleted!
    2757             :                 pFmt = pDoc->MakeFlyAndMove( *m_pCopySource, aFrmSet,
    2758             :                                0,
    2759           0 :                                pParentFrmFmt );
    2760           0 :                 if(pAnchorItem && pFmt)
    2761             :                 {
    2762           0 :                     pFmt->DelFrms();
    2763           0 :                     pAnchorItem->SetAnchor( m_pCopySource->Start() );
    2764           0 :                     SfxItemSet aAnchorSet( pDoc->GetAttrPool(), RES_ANCHOR, RES_ANCHOR );
    2765           0 :                     aAnchorSet.Put( *pAnchorItem );
    2766           0 :                     pDoc->SetFlyFrmAttr( *pFmt, aAnchorSet );
    2767           0 :                     delete pAnchorItem;
    2768             :                 }
    2769           0 :                 DELETEZ( m_pCopySource );
    2770             :             }
    2771             :             else
    2772             :             {
    2773           0 :                 pFmt = pDoc->MakeFlySection( FLY_AT_PARA, aPam.GetPoint(),
    2774           0 :                                          &aFrmSet, pParentFrmFmt );
    2775             :             }
    2776           0 :             if(pFmt)
    2777             :             {
    2778           0 :                 pFmt->Add(this);
    2779           0 :                 if(!m_sName.isEmpty())
    2780           0 :                     pDoc->SetFlyName((SwFlyFrmFmt&)*pFmt, m_sName);
    2781             :             }
    2782             :             //den SwXText wecken
    2783           0 :             ((SwXTextFrame*)this)->SetDoc( bIsDescriptor ? m_pDoc : GetFrmFmt()->GetDoc() );
    2784             :         }
    2785           0 :         else if( eType == FLYCNTTYPE_GRF)
    2786             :         {
    2787           0 :             UnoActionContext aCont(pDoc);
    2788             :             const ::uno::Any* pGraphicURL;
    2789           0 :             OUString sGraphicURL;
    2790           0 :             GraphicObject *pGrfObj = 0;
    2791           0 :             if(pProps->GetProperty(FN_UNO_GRAPHIC_U_R_L, 0, pGraphicURL))
    2792             :             {
    2793           0 :                 (*pGraphicURL) >>= sGraphicURL;
    2794           0 :                 if( sGraphicURL.startsWith(sPackageProtocol) )
    2795             :                 {
    2796           0 :                     pGrfObj = new GraphicObject;
    2797           0 :                     pGrfObj->SetUserData( sGraphicURL );
    2798           0 :                     pGrfObj->SetSwapState();
    2799           0 :                     sGraphicURL = "";
    2800             :                 }
    2801           0 :                 else if( sGraphicURL.startsWith(sGraphicObjectProtocol) )
    2802             :                 {
    2803             :                     OString sId(OUStringToOString(
    2804           0 :                         sGraphicURL.copy( sizeof(sGraphicObjectProtocol)-1 ),
    2805           0 :                         RTL_TEXTENCODING_ASCII_US));
    2806           0 :                     pGrfObj = new GraphicObject( sId );
    2807           0 :                     sGraphicURL = "";
    2808             :                 }
    2809             :             }
    2810           0 :             Graphic aGraphic;
    2811             :             const ::uno::Any* pGraphic;
    2812           0 :             if( pProps->GetProperty( FN_UNO_GRAPHIC, 0, pGraphic ))
    2813             :             {
    2814           0 :                 uno::Reference< graphic::XGraphic > xGraphic;
    2815           0 :                 (*pGraphic) >>= xGraphic;
    2816           0 :                 aGraphic = Graphic( xGraphic );
    2817             :             }
    2818             : 
    2819           0 :             OUString sFltName;
    2820             :             const ::uno::Any* pFilter;
    2821           0 :             if(pProps->GetProperty(FN_UNO_GRAPHIC_FILTER, 0, pFilter))
    2822             :             {
    2823           0 :                 (*pFilter) >>= sFltName;
    2824             :             }
    2825             : 
    2826             :             pFmt =
    2827             :                 pGrfObj ? pDoc->Insert( aPam, *pGrfObj, &aFrmSet, &aGrSet,
    2828           0 :                                         pParentFrmFmt )
    2829             :                         : pDoc->Insert( aPam, sGraphicURL, sFltName, &aGraphic,
    2830           0 :                                         &aFrmSet, &aGrSet, pParentFrmFmt  );
    2831           0 :             delete pGrfObj;
    2832           0 :             if(pFmt)
    2833             :             {
    2834           0 :                 SwGrfNode *pGrfNd = pDoc->GetNodes()[ pFmt->GetCntnt().GetCntntIdx()
    2835           0 :                                             ->GetIndex()+1 ]->GetGrfNode();
    2836           0 :                 if (pGrfNd)
    2837           0 :                     pGrfNd->SetChgTwipSize( !bSizeFound );
    2838           0 :                 pFmt->Add(this);
    2839           0 :                 if(!m_sName.isEmpty())
    2840           0 :                     pDoc->SetFlyName((SwFlyFrmFmt&)*pFmt, m_sName);
    2841             : 
    2842             :             }
    2843             :             const ::uno::Any* pSurroundContour;
    2844           0 :             if(pProps->GetProperty(RES_SURROUND, MID_SURROUND_CONTOUR, pSurroundContour))
    2845           0 :                 setPropertyValue(UNO_NAME_SURROUND_CONTOUR, *pSurroundContour);
    2846             :             const ::uno::Any* pContourOutside;
    2847           0 :             if(pProps->GetProperty(RES_SURROUND, MID_SURROUND_CONTOUROUTSIDE, pContourOutside))
    2848           0 :                 setPropertyValue(UNO_NAME_CONTOUR_OUTSIDE, *pContourOutside);
    2849             :             const ::uno::Any* pContourPoly;
    2850           0 :             if(pProps->GetProperty(FN_PARAM_COUNTOUR_PP, 0, pContourPoly))
    2851           0 :                 setPropertyValue(UNO_NAME_CONTOUR_POLY_POLYGON, *pContourPoly);
    2852             :             const ::uno::Any* pPixelContour;
    2853           0 :             if(pProps->GetProperty(FN_UNO_IS_PIXEL_CONTOUR, 0, pPixelContour))
    2854           0 :                 setPropertyValue(UNO_NAME_IS_PIXEL_CONTOUR, *pPixelContour);
    2855             :             const ::uno::Any* pAutoContour;
    2856           0 :             if(pProps->GetProperty(FN_UNO_IS_AUTOMATIC_CONTOUR, 0, pAutoContour))
    2857           0 :                 setPropertyValue(UNO_NAME_IS_AUTOMATIC_CONTOUR, *pAutoContour);
    2858             :         }
    2859             :         else
    2860             :         {
    2861           0 :             const ::uno::Any* pCLSID = 0;
    2862           0 :             const ::uno::Any* pStreamName = 0;
    2863           0 :             const ::uno::Any* pEmbeddedObject = 0;
    2864           0 :             if(!pProps->GetProperty(FN_UNO_CLSID, 0, pCLSID)
    2865           0 :                 && !pProps->GetProperty( FN_UNO_STREAM_NAME, 0, pStreamName )
    2866           0 :                 && !pProps->GetProperty( FN_EMBEDDED_OBJECT, 0, pEmbeddedObject ))
    2867           0 :                 throw uno::RuntimeException();
    2868           0 :             if(pCLSID)
    2869             :             {
    2870           0 :                 OUString aCLSID;
    2871           0 :                 SvGlobalName aClassName;
    2872           0 :                 uno::Reference < embed::XEmbeddedObject > xIPObj;
    2873           0 :                 std::auto_ptr < comphelper::EmbeddedObjectContainer > pCnt;
    2874           0 :                 if( (*pCLSID) >>= aCLSID )
    2875             :                 {
    2876           0 :                     if( !aClassName.MakeId( aCLSID ) )
    2877             :                     {
    2878           0 :                         lang::IllegalArgumentException aExcept;
    2879           0 :                         aExcept.Message = "CLSID invalid";
    2880           0 :                         throw aExcept;
    2881             :                     }
    2882             : 
    2883           0 :                     pCnt.reset( new comphelper::EmbeddedObjectContainer );
    2884           0 :                     OUString aName;
    2885           0 :                     xIPObj = pCnt->CreateEmbeddedObject( aClassName.GetByteSequence(), aName );
    2886             :                 }
    2887           0 :                 if ( xIPObj.is() )
    2888             :                 {
    2889             :                     //TODO/LATER: MISCSTATUS_RESIZEONPRINTERCHANGE
    2890             :                     //if( SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE & xIPObj->GetMiscStatus() && pDoc->getPrinter( false ) )
    2891             :                     //    xIPObj->OnDocumentPrinterChanged( pDoc->getPrinter( false ) );
    2892             : 
    2893           0 :                     UnoActionContext aAction(pDoc);
    2894           0 :                     pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_INSERT, NULL);
    2895           0 :                     if(!bSizeFound)
    2896             :                     {
    2897             :                         //TODO/LATER: from where do I get a ViewAspect? And how do I transport it to the OLENode?
    2898           0 :                         sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT;
    2899             : 
    2900             :                         // TODO/LEAN: VisualArea still needs running state
    2901           0 :                         svt::EmbeddedObjectRef::TryRunningState( xIPObj );
    2902             : 
    2903             :                         // set parent to get correct VisArea(in case of object needing parent printer)
    2904           0 :                         uno::Reference < container::XChild > xChild( xIPObj, uno::UNO_QUERY );
    2905           0 :                         if ( xChild.is() )
    2906           0 :                             xChild->setParent( pDoc->GetDocShell()->GetModel() );
    2907             : 
    2908             :                         //The Size should be suggested by the OLE server if not manually set
    2909           0 :                         MapUnit aRefMap = VCLUnoHelper::UnoEmbed2VCLMapUnit( xIPObj->getMapUnit( nAspect ) );
    2910           0 :                         awt::Size aSize;
    2911             :                         try
    2912             :                         {
    2913           0 :                             aSize = xIPObj->getVisualAreaSize( nAspect );
    2914             :                         }
    2915           0 :                         catch ( embed::NoVisualAreaSizeException& )
    2916             :                         {
    2917             :                             // the default size will be set later
    2918             :                         }
    2919             : 
    2920           0 :                         Size aSz( aSize.Width, aSize.Height );
    2921           0 :                         if ( !aSz.Width() || !aSz.Height() )
    2922             :                         {
    2923           0 :                             aSz.Width() = aSz.Height() = 5000;
    2924             :                             aSz = OutputDevice::LogicToLogic
    2925           0 :                                                     ( aSz, MapMode( MAP_100TH_MM ), aRefMap );
    2926             :                         }
    2927           0 :                         MapMode aMyMap( MAP_TWIP );
    2928           0 :                         aSz = OutputDevice::LogicToLogic( aSz, aRefMap, aMyMap );
    2929           0 :                         SwFmtFrmSize aFrmSz;
    2930           0 :                         aFrmSz.SetSize(aSz);
    2931           0 :                         aFrmSet.Put(aFrmSz);
    2932             :                     }
    2933           0 :                     SwFlyFrmFmt* pFmt2 = 0;
    2934             : 
    2935             :                     // TODO/LATER: Is it the only possible aspect here?
    2936           0 :                     sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT;
    2937           0 :                     ::svt::EmbeddedObjectRef xObjRef( xIPObj, nAspect );
    2938           0 :                     pFmt2 = pDoc->Insert(aPam, xObjRef, &aFrmSet, NULL, NULL );
    2939             :                     OSL_ENSURE( pFmt2, "Doc->Insert(notxt) failed." );
    2940             : 
    2941           0 :                     pDoc->GetIDocumentUndoRedo().EndUndo(UNDO_INSERT, NULL);
    2942           0 :                     pFmt2->Add(this);
    2943           0 :                     if(!m_sName.isEmpty())
    2944           0 :                         pDoc->SetFlyName((SwFlyFrmFmt&)*pFmt2, m_sName);
    2945           0 :                 }
    2946             :             }
    2947           0 :             else if( pStreamName )
    2948             :             {
    2949           0 :                 OUString sStreamName;
    2950           0 :                 (*pStreamName) >>= sStreamName;
    2951           0 :                 pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_INSERT, NULL);
    2952             : 
    2953           0 :                 SwFlyFrmFmt* pFrmFmt = 0;
    2954           0 :                 pFrmFmt = pDoc->InsertOLE( aPam, sStreamName, embed::Aspects::MSOLE_CONTENT, &aFrmSet, NULL, NULL );
    2955           0 :                 pDoc->GetIDocumentUndoRedo().EndUndo(UNDO_INSERT, NULL);
    2956           0 :                 pFrmFmt->Add(this);
    2957           0 :                 if(!m_sName.isEmpty())
    2958           0 :                     pDoc->SetFlyName((SwFlyFrmFmt&)*pFrmFmt, m_sName);
    2959             :             }
    2960           0 :             else if( pEmbeddedObject || pStreamName )
    2961             :             {
    2962           0 :                 uno::Reference< embed::XEmbeddedObject > obj;
    2963           0 :                 (*pEmbeddedObject) >>= obj;
    2964           0 :                 svt::EmbeddedObjectRef xObj;
    2965           0 :                 xObj.Assign( obj, embed::Aspects::MSOLE_CONTENT );
    2966             : 
    2967           0 :                 pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_INSERT, NULL);
    2968             : 
    2969             :                 // Not sure if these setParent() and InsertEmbeddedObject() calls are really
    2970             :                 // needed, it seems to work without, but logic from code elsewhere suggests
    2971             :                 // they should be done.
    2972           0 :                 SfxObjectShell& mrPers = *pDoc->GetPersist();
    2973           0 :                 uno::Reference < container::XChild > xChild( obj, uno::UNO_QUERY );
    2974           0 :                 if ( xChild.is() )
    2975           0 :                     xChild->setParent( mrPers.GetModel() );
    2976           0 :                 OUString rName;
    2977           0 :                 mrPers.GetEmbeddedObjectContainer().InsertEmbeddedObject( obj, rName );
    2978             : 
    2979           0 :                 SwFlyFrmFmt* pFrmFmt = 0;
    2980           0 :                 pFrmFmt = pDoc->Insert( aPam, xObj, &aFrmSet, NULL, NULL );
    2981           0 :                 pDoc->GetIDocumentUndoRedo().EndUndo(UNDO_INSERT, NULL);
    2982           0 :                 pFrmFmt->Add(this);
    2983           0 :                 if(!m_sName.isEmpty())
    2984           0 :                     pDoc->SetFlyName((SwFlyFrmFmt&)*pFrmFmt, m_sName);
    2985             :             }
    2986             :         }
    2987           0 :         if( pFmt && pDoc->GetDrawModel() )
    2988           0 :             GetOrCreateSdrObject( pFmt );
    2989             :         const ::uno::Any* pOrder;
    2990           0 :         if( pProps->GetProperty(FN_UNO_Z_ORDER, 0, pOrder) )
    2991           0 :             setPropertyValue(UNO_NAME_Z_ORDER, *pOrder);
    2992             :         const ::uno::Any* pReplacement;
    2993           0 :         if( pProps->GetProperty(FN_UNO_REPLACEMENT_GRAPHIC, 0, pReplacement) )
    2994           0 :             setPropertyValue(UNO_NAME_GRAPHIC, *pReplacement);
    2995             :         // new attribute Title
    2996             :         const ::uno::Any* pTitle;
    2997           0 :         if ( pProps->GetProperty(FN_UNO_TITLE, 0, pTitle) )
    2998             :         {
    2999           0 :             setPropertyValue(UNO_NAME_TITLE, *pTitle);
    3000             :         }
    3001             :         // new attribute Description
    3002             :         const ::uno::Any* pDescription;
    3003           0 :         if ( pProps->GetProperty(FN_UNO_DESCRIPTION, 0, pDescription) )
    3004             :         {
    3005           0 :             setPropertyValue(UNO_NAME_DESCRIPTION, *pDescription);
    3006           0 :         }
    3007             :     }
    3008             :     else
    3009           0 :         throw lang::IllegalArgumentException();
    3010             :     //setzt das Flag zurueck und loescht den Descriptor-Pointer
    3011           0 :     ResetDescriptor();
    3012           0 : }
    3013             : 
    3014           0 : void SwXFrame::attach(const uno::Reference< text::XTextRange > & xTextRange)
    3015             :     throw( lang::IllegalArgumentException, uno::RuntimeException )
    3016             : {
    3017             :     SwFrmFmt* pFmt;
    3018           0 :     if(IsDescriptor())
    3019           0 :         attachToRange(xTextRange);
    3020           0 :     else if(0 != (pFmt = GetFrmFmt()))
    3021             :     {
    3022           0 :         uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
    3023           0 :         SwDoc* pDoc = pFmt->GetDoc();
    3024           0 :         SwUnoInternalPaM aIntPam(*pDoc);
    3025           0 :         if (::sw::XTextRangeToSwPaM(aIntPam, xTextRange))
    3026             :         {
    3027           0 :             SfxItemSet aSet( pDoc->GetAttrPool(), RES_ANCHOR, RES_ANCHOR );
    3028           0 :             aSet.SetParent(&pFmt->GetAttrSet());
    3029           0 :             SwFmtAnchor aAnchor = (const SwFmtAnchor&)aSet.Get(RES_ANCHOR);
    3030           0 :             aAnchor.SetAnchor( aIntPam.Start() );
    3031           0 :             aSet.Put(aAnchor);
    3032           0 :             pDoc->SetFlyFrmAttr( *pFmt, aSet );
    3033             :         }
    3034             :         else
    3035           0 :             throw lang::IllegalArgumentException();
    3036             :     }
    3037           0 : }
    3038             : 
    3039           0 : awt::Point SwXFrame::getPosition(void) throw( uno::RuntimeException, std::exception )
    3040             : {
    3041           0 :     SolarMutexGuard aGuard;
    3042           0 :     uno::RuntimeException aRuntime;
    3043           0 :     aRuntime.Message = "position cannot be determined with this method";
    3044           0 :     throw aRuntime;
    3045             : }
    3046             : 
    3047           0 : void SwXFrame::setPosition(const awt::Point& /*aPosition*/) throw( uno::RuntimeException, std::exception )
    3048             : {
    3049           0 :     SolarMutexGuard aGuard;
    3050           0 :     uno::RuntimeException aRuntime;
    3051           0 :     aRuntime.Message = "position cannot be changed with this method";
    3052           0 :     throw aRuntime;
    3053             : }
    3054             : 
    3055           0 : awt::Size SwXFrame::getSize(void) throw( uno::RuntimeException, std::exception )
    3056             : {
    3057           0 :     const ::uno::Any aVal = getPropertyValue("Size");
    3058           0 :     awt::Size* pRet =  (awt::Size*)aVal.getValue();
    3059           0 :     return *pRet;
    3060             : }
    3061             : 
    3062           0 : void SwXFrame::setSize(const awt::Size& aSize)
    3063             :     throw( beans::PropertyVetoException, uno::RuntimeException, std::exception )
    3064             : {
    3065           0 :     const ::uno::Any aVal(&aSize, ::getCppuType(static_cast<const awt::Size*>(0)));
    3066           0 :     setPropertyValue("Size", aVal);
    3067           0 : }
    3068             : 
    3069           0 : OUString SwXFrame::getShapeType(void) throw( uno::RuntimeException, std::exception )
    3070             : {
    3071           0 :     return OUString("FrameShape");
    3072             : }
    3073             : 
    3074             : /******************************************************************
    3075             :  *  SwXTextFrame
    3076             :  ******************************************************************/
    3077           0 : SwXTextFrame::SwXTextFrame( SwDoc *_pDoc ) :
    3078             :     SwXText(0, CURSOR_FRAME),
    3079           0 :     SwXFrame(FLYCNTTYPE_FRM, aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_FRAME), _pDoc )
    3080             : {
    3081           0 : }
    3082             : 
    3083           0 : SwXTextFrame::SwXTextFrame(SwFrmFmt& rFmt) :
    3084             :     SwXText(rFmt.GetDoc(), CURSOR_FRAME),
    3085           0 :     SwXFrame(rFmt, FLYCNTTYPE_FRM, aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_FRAME))
    3086             : {
    3087             : 
    3088           0 : }
    3089             : 
    3090           0 : SwXTextFrame::~SwXTextFrame()
    3091             : {
    3092           0 : }
    3093             : 
    3094           0 : void SAL_CALL SwXTextFrame::acquire(  )throw()
    3095             : {
    3096           0 :     SwXFrame::acquire();
    3097           0 : }
    3098             : 
    3099           0 : void SAL_CALL SwXTextFrame::release(  )throw()
    3100             : {
    3101           0 :     SwXFrame::release();
    3102           0 : }
    3103             : 
    3104           0 : ::uno::Any SAL_CALL SwXTextFrame::queryInterface( const uno::Type& aType )
    3105             :     throw (uno::RuntimeException, std::exception)
    3106             : {
    3107           0 :     ::uno::Any aRet = SwXFrame::queryInterface(aType);
    3108           0 :     if(aRet.getValueType() == ::getCppuVoidType())
    3109           0 :         aRet = SwXText::queryInterface(aType);
    3110           0 :     if(aRet.getValueType() == ::getCppuVoidType())
    3111           0 :         aRet = SwXTextFrameBaseClass::queryInterface(aType);
    3112           0 :     return aRet;
    3113             : }
    3114             : 
    3115           0 : uno::Sequence< uno::Type > SAL_CALL SwXTextFrame::getTypes(  ) throw(uno::RuntimeException, std::exception)
    3116             : {
    3117           0 :     uno::Sequence< uno::Type > aTextFrameTypes = SwXTextFrameBaseClass::getTypes();
    3118           0 :     uno::Sequence< uno::Type > aFrameTypes = SwXFrame::getTypes();
    3119           0 :     uno::Sequence< uno::Type > aTextTypes = SwXText::getTypes();
    3120             : 
    3121           0 :     long nIndex = aTextFrameTypes.getLength();
    3122             :     aTextFrameTypes.realloc(
    3123           0 :         aTextFrameTypes.getLength() +
    3124           0 :         aFrameTypes.getLength() +
    3125           0 :         aTextTypes.getLength());
    3126             : 
    3127           0 :     uno::Type* pTextFrameTypes = aTextFrameTypes.getArray();
    3128           0 :     const uno::Type* pFrameTypes = aFrameTypes.getConstArray();
    3129             :     long nPos;
    3130           0 :     for(nPos = 0; nPos <aFrameTypes.getLength(); nPos++)
    3131           0 :         pTextFrameTypes[nIndex++] = pFrameTypes[nPos];
    3132             : 
    3133           0 :     const uno::Type* pTextTypes = aTextTypes.getConstArray();
    3134           0 :     for(nPos = 0; nPos <aTextTypes.getLength(); nPos++)
    3135           0 :         pTextFrameTypes[nIndex++] = pTextTypes[nPos];
    3136             : 
    3137           0 :     return aTextFrameTypes;
    3138             : }
    3139             : 
    3140           0 : uno::Sequence< sal_Int8 > SAL_CALL SwXTextFrame::getImplementationId(  ) throw(uno::RuntimeException, std::exception)
    3141             : {
    3142           0 :     return css::uno::Sequence<sal_Int8>();
    3143             : }
    3144             : 
    3145           0 : uno::Reference< text::XText >  SwXTextFrame::getText(void) throw( uno::RuntimeException, std::exception )
    3146             : {
    3147           0 :     return this;
    3148             : }
    3149             : 
    3150           0 : const SwStartNode *SwXTextFrame::GetStartNode() const
    3151             : {
    3152           0 :     const SwStartNode *pSttNd = 0;
    3153             : 
    3154           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    3155           0 :     if(pFmt)
    3156             :     {
    3157           0 :         const SwFmtCntnt& rFlyCntnt = pFmt->GetCntnt();
    3158           0 :         if( rFlyCntnt.GetCntntIdx() )
    3159           0 :             pSttNd = rFlyCntnt.GetCntntIdx()->GetNode().GetStartNode();
    3160             :     }
    3161             : 
    3162           0 :     return pSttNd;
    3163             : }
    3164             : 
    3165             : uno::Reference< text::XTextCursor >
    3166           0 : SwXTextFrame::CreateCursor() throw (uno::RuntimeException)
    3167             : {
    3168           0 :     return createTextCursor();
    3169             : }
    3170             : 
    3171           0 : uno::Reference< text::XTextCursor >  SwXTextFrame::createTextCursor(void) throw( uno::RuntimeException, std::exception )
    3172             : {
    3173           0 :     SolarMutexGuard aGuard;
    3174           0 :     uno::Reference< text::XTextCursor >  aRef;
    3175           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    3176           0 :     if(pFmt)
    3177             :     {
    3178             :         //save current start node to be able to check if there is content after the table -
    3179             :         //otherwise the cursor would be in the body text!
    3180           0 :         const SwNode& rNode = pFmt->GetCntnt().GetCntntIdx()->GetNode();
    3181           0 :         const SwStartNode* pOwnStartNode = rNode.FindSttNodeByType(SwFlyStartNode);
    3182             : 
    3183           0 :         SwPaM aPam(rNode);
    3184           0 :         aPam.Move(fnMoveForward, fnGoNode);
    3185           0 :         SwTableNode* pTblNode = aPam.GetNode()->FindTableNode();
    3186           0 :         SwCntntNode* pCont = 0;
    3187           0 :         while( pTblNode )
    3188             :         {
    3189           0 :             aPam.GetPoint()->nNode = *pTblNode->EndOfSectionNode();
    3190           0 :             pCont = GetDoc()->GetNodes().GoNext(&aPam.GetPoint()->nNode);
    3191           0 :             pTblNode = pCont->FindTableNode();
    3192             :         }
    3193           0 :         if(pCont)
    3194           0 :             aPam.GetPoint()->nContent.Assign(pCont, 0);
    3195             : 
    3196             :         const SwStartNode* pNewStartNode =
    3197           0 :             aPam.GetNode()->FindSttNodeByType(SwFlyStartNode);
    3198           0 :         if(!pNewStartNode || pNewStartNode != pOwnStartNode)
    3199             :         {
    3200           0 :             uno::RuntimeException aExcept;
    3201           0 :             aExcept.Message = "no text available";
    3202           0 :             throw aExcept;
    3203             :         }
    3204             : 
    3205             :         SwXTextCursor *const pXCursor = new SwXTextCursor(
    3206           0 :                  *pFmt->GetDoc(), this, CURSOR_FRAME, *aPam.GetPoint());
    3207           0 :         aRef =  static_cast<text::XWordCursor*>(pXCursor);
    3208             : #if OSL_DEBUG_LEVEL > 1
    3209             :         SwUnoCrsr *const pUnoCrsr = pXCursor->GetCursor();
    3210             :         (void) pUnoCrsr;
    3211             : #endif
    3212             :     }
    3213             :     else
    3214           0 :         throw uno::RuntimeException();
    3215           0 :     return aRef;
    3216             : }
    3217             : 
    3218           0 : uno::Reference< text::XTextCursor >  SwXTextFrame::createTextCursorByRange(const uno::Reference< text::XTextRange > & aTextPosition) throw( uno::RuntimeException, std::exception )
    3219             : {
    3220           0 :     SolarMutexGuard aGuard;
    3221           0 :     uno::Reference< text::XTextCursor >  aRef;
    3222           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    3223           0 :     SwUnoInternalPaM aPam(*GetDoc());
    3224           0 :     if (pFmt && ::sw::XTextRangeToSwPaM(aPam, aTextPosition))
    3225             :     {
    3226           0 :         SwNode& rNode = pFmt->GetCntnt().GetCntntIdx()->GetNode();
    3227             : #if OSL_DEBUG_LEVEL > 1
    3228             :         const SwStartNode* p1 = aPam.GetNode()->FindFlyStartNode();
    3229             :         const SwStartNode* p2 = rNode.FindFlyStartNode();
    3230             :         (void)p1;
    3231             :         (void)p2;
    3232             : #endif
    3233           0 :         if(aPam.GetNode()->FindFlyStartNode() == rNode.FindFlyStartNode())
    3234             :         {
    3235             :             aRef = static_cast<text::XWordCursor*>(
    3236           0 :                     new SwXTextCursor(*pFmt->GetDoc(), this, CURSOR_FRAME,
    3237           0 :                         *aPam.GetPoint(), aPam.GetMark()));
    3238             :         }
    3239             :     }
    3240             :     else
    3241           0 :         throw uno::RuntimeException();
    3242           0 :     return aRef;
    3243             : }
    3244             : 
    3245           0 : uno::Reference< container::XEnumeration >  SwXTextFrame::createEnumeration(void) throw( uno::RuntimeException, std::exception )
    3246             : {
    3247           0 :     SolarMutexGuard aGuard;
    3248           0 :     uno::Reference< container::XEnumeration >  aRef;
    3249           0 :     SwFrmFmt* pFmt = GetFrmFmt();
    3250           0 :     if(pFmt)
    3251             :     {
    3252           0 :         SwPosition aPos(pFmt->GetCntnt().GetCntntIdx()->GetNode());
    3253             :         ::std::auto_ptr<SwUnoCrsr> pUnoCursor(
    3254           0 :                 GetDoc()->CreateUnoCrsr(aPos, false));
    3255           0 :         pUnoCursor->Move(fnMoveForward, fnGoNode);
    3256             : //      // no Cursor in protected sections
    3257             : //      SwCrsrSaveState aSave( *pUnoCrsr );
    3258             : //      if(pUnoCrsr->IsInProtectTable(true) ||
    3259             : //          pUnoCrsr->IsSelOvr( SELOVER_TOGGLE | SELOVER_CHANGEPOS ))
    3260             : //          throw  uno::RuntimeException() );
    3261           0 :         aRef = new SwXParagraphEnumeration(this, pUnoCursor, CURSOR_FRAME);
    3262             :     }
    3263           0 :     return aRef;
    3264             : }
    3265             : 
    3266           0 : uno::Type  SwXTextFrame::getElementType(void) throw( uno::RuntimeException, std::exception )
    3267             : {
    3268           0 :     return ::getCppuType(static_cast<uno::Reference<text::XTextRange>*>(0));
    3269             : }
    3270             : 
    3271           0 : sal_Bool SwXTextFrame::hasElements(void) throw( uno::RuntimeException, std::exception )
    3272             : {
    3273           0 :     return sal_True;
    3274             : }
    3275             : 
    3276           0 : void SwXTextFrame::attach(const uno::Reference< text::XTextRange > & xTextRange)
    3277             :     throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
    3278             : {
    3279           0 :     SwXFrame::attach(xTextRange);
    3280           0 : }
    3281             : 
    3282           0 : uno::Reference< text::XTextRange >  SwXTextFrame::getAnchor(void) throw( uno::RuntimeException, std::exception )
    3283             : {
    3284           0 :     SolarMutexGuard aGuard;
    3285           0 :     return SwXFrame::getAnchor();
    3286             : }
    3287             : 
    3288           0 : void SwXTextFrame::dispose(void) throw( uno::RuntimeException, std::exception )
    3289             : {
    3290           0 :     SolarMutexGuard aGuard;
    3291           0 :     SwXFrame::dispose();
    3292           0 : }
    3293             : 
    3294           0 : void SwXTextFrame::addEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException, std::exception )
    3295             : {
    3296           0 :     SwXFrame::addEventListener(aListener);
    3297           0 : }
    3298             : 
    3299           0 : void SwXTextFrame::removeEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException, std::exception )
    3300             : {
    3301           0 :     SwXFrame::removeEventListener(aListener);
    3302           0 : }
    3303             : 
    3304           0 : OUString SwXTextFrame::getImplementationName(void) throw( uno::RuntimeException, std::exception )
    3305             : {
    3306           0 :     return OUString("SwXTextFrame");
    3307             : }
    3308             : 
    3309           0 : sal_Bool SwXTextFrame::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
    3310             : {
    3311           0 :     return cppu::supportsService(this, rServiceName);
    3312             : }
    3313             : 
    3314           0 : uno::Sequence< OUString > SwXTextFrame::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
    3315             : {
    3316           0 :     uno::Sequence < OUString > aRet = SwXFrame::getSupportedServiceNames();
    3317           0 :     aRet.realloc(aRet.getLength() + 2);
    3318           0 :     OUString* pArray = aRet.getArray();
    3319           0 :     pArray[aRet.getLength() - 2] = "com.sun.star.text.TextFrame";
    3320           0 :     pArray[aRet.getLength() - 1] = "com.sun.star.text.Text";
    3321           0 :     return aRet;
    3322             : }
    3323             : 
    3324           0 : void * SAL_CALL SwXTextFrame::operator new( size_t t) throw()
    3325             : {
    3326           0 :     return SwXTextFrameBaseClass::operator new( t);
    3327             : }
    3328             : 
    3329           0 : void SAL_CALL SwXTextFrame::operator delete( void * p) throw()
    3330             : {
    3331           0 :     SwXTextFrameBaseClass::operator delete(p);
    3332           0 : }
    3333             : 
    3334           0 : uno::Reference<container::XNameReplace > SAL_CALL SwXTextFrame::getEvents()
    3335             :     throw(uno::RuntimeException, std::exception)
    3336             : {
    3337           0 :     return new SwFrameEventDescriptor( *this );
    3338             : }
    3339             : 
    3340           0 : sal_Int64 SAL_CALL SwXTextFrame::getSomething( const uno::Sequence< sal_Int8 >& rId )
    3341             :     throw(uno::RuntimeException, std::exception)
    3342             : {
    3343           0 :     sal_Int64 nRet = SwXFrame::getSomething( rId );
    3344           0 :     if( !nRet )
    3345           0 :         nRet = SwXText::getSomething( rId );
    3346             : 
    3347           0 :     return nRet;
    3348             : }
    3349             : 
    3350           0 : ::uno::Any SwXTextFrame::getPropertyValue(const OUString& rPropertyName)
    3351             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
    3352             : {
    3353           0 :     SolarMutexGuard aGuard;
    3354           0 :     ::uno::Any aRet;
    3355           0 :     if(rPropertyName == UNO_NAME_START_REDLINE||
    3356           0 :             rPropertyName == UNO_NAME_END_REDLINE)
    3357             :     {
    3358             :         //redline can only be returned if it's a living object
    3359           0 :         if(!IsDescriptor())
    3360           0 :             aRet = SwXText::getPropertyValue(rPropertyName);
    3361             :     }
    3362             :     else
    3363           0 :         aRet = SwXFrame::getPropertyValue(rPropertyName);
    3364           0 :     return aRet;
    3365             : }
    3366             : 
    3367             : /******************************************************************
    3368             :  *  SwXTextGraphicObject
    3369             :  ******************************************************************/
    3370           0 : SwXTextGraphicObject::SwXTextGraphicObject( SwDoc *pDoc ) :
    3371           0 :     SwXFrame(FLYCNTTYPE_GRF, aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_GRAPHIC), pDoc)
    3372             : {
    3373           0 : }
    3374             : 
    3375           0 : SwXTextGraphicObject::SwXTextGraphicObject(SwFrmFmt& rFmt) :
    3376           0 :     SwXFrame(rFmt, FLYCNTTYPE_GRF, aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_GRAPHIC))
    3377             : {
    3378             : 
    3379           0 : }
    3380             : 
    3381           0 : SwXTextGraphicObject::~SwXTextGraphicObject()
    3382             : {
    3383             : 
    3384           0 : }
    3385             : 
    3386           0 : void SAL_CALL SwXTextGraphicObject::acquire(  )throw()
    3387             : {
    3388           0 :     SwXFrame::acquire();
    3389           0 : }
    3390             : 
    3391           0 : void SAL_CALL SwXTextGraphicObject::release(  )throw()
    3392             : {
    3393           0 :     SwXFrame::release();
    3394           0 : }
    3395             : 
    3396           0 : ::uno::Any SAL_CALL SwXTextGraphicObject::queryInterface( const uno::Type& aType )
    3397             :     throw(uno::RuntimeException, std::exception)
    3398             : {
    3399           0 :     ::uno::Any aRet = SwXFrame::queryInterface(aType);
    3400           0 :     if(aRet.getValueType() == ::getCppuVoidType())
    3401           0 :         aRet = SwXTextGraphicObjectBaseClass::queryInterface(aType);
    3402           0 :     return aRet;
    3403             : }
    3404             : 
    3405             : uno::Sequence< uno::Type > SAL_CALL
    3406           0 :     SwXTextGraphicObject::getTypes(  ) throw(uno::RuntimeException, std::exception)
    3407             : {
    3408           0 :     uno::Sequence< uno::Type > aGraphicTypes = SwXTextGraphicObjectBaseClass::getTypes();
    3409           0 :     uno::Sequence< uno::Type > aFrameTypes = SwXFrame::getTypes();
    3410             : 
    3411           0 :     long nIndex = aGraphicTypes.getLength();
    3412             :     aGraphicTypes.realloc(
    3413           0 :         aGraphicTypes.getLength() +
    3414           0 :         aFrameTypes.getLength());
    3415             : 
    3416           0 :     uno::Type* pGraphicTypes = aGraphicTypes.getArray();
    3417           0 :     const uno::Type* pFrameTypes = aFrameTypes.getConstArray();
    3418             :     long nPos;
    3419           0 :     for(nPos = 0; nPos <aFrameTypes.getLength(); nPos++)
    3420           0 :         pGraphicTypes[nIndex++] = pFrameTypes[nPos];
    3421             : 
    3422           0 :     return aGraphicTypes;
    3423             : }
    3424             : 
    3425           0 : uno::Sequence< sal_Int8 > SAL_CALL SwXTextGraphicObject::getImplementationId(  ) throw(uno::RuntimeException, std::exception)
    3426             : {
    3427           0 :     return css::uno::Sequence<sal_Int8>();
    3428             : }
    3429             : 
    3430           0 : void SwXTextGraphicObject::attach(const uno::Reference< text::XTextRange > & xTextRange) throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
    3431             : {
    3432           0 :     SwXFrame::attach(xTextRange);
    3433           0 : }
    3434             : 
    3435           0 : uno::Reference< text::XTextRange >  SwXTextGraphicObject::getAnchor(void) throw( uno::RuntimeException, std::exception )
    3436             : {
    3437           0 :     SolarMutexGuard aGuard;
    3438           0 :     return SwXFrame::getAnchor();
    3439             : }
    3440             : 
    3441           0 : void SwXTextGraphicObject::dispose(void) throw( uno::RuntimeException, std::exception )
    3442             : {
    3443           0 :     SolarMutexGuard aGuard;
    3444           0 :     SwXFrame::dispose();
    3445           0 : }
    3446             : 
    3447           0 : void SwXTextGraphicObject::addEventListener(const uno::Reference< lang::XEventListener > & aListener)
    3448             :                                                     throw( uno::RuntimeException, std::exception )
    3449             : {
    3450           0 :     SwXFrame::addEventListener(aListener);
    3451           0 : }
    3452             : 
    3453           0 : void SwXTextGraphicObject::removeEventListener(const uno::Reference< lang::XEventListener > & aListener)
    3454             :                                                     throw( uno::RuntimeException, std::exception )
    3455             : {
    3456           0 :     SwXFrame::removeEventListener(aListener);
    3457           0 : }
    3458             : 
    3459           0 : OUString SwXTextGraphicObject::getImplementationName(void) throw( uno::RuntimeException, std::exception )
    3460             : {
    3461           0 :     return OUString("SwXTextGraphicObject");
    3462             : }
    3463             : 
    3464           0 : sal_Bool SwXTextGraphicObject::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
    3465             : {
    3466           0 :     return cppu::supportsService(this, rServiceName);
    3467             : }
    3468             : 
    3469           0 : uno::Sequence< OUString > SwXTextGraphicObject::getSupportedServiceNames(void)
    3470             :         throw( uno::RuntimeException, std::exception )
    3471             : {
    3472           0 :     uno::Sequence < OUString > aRet = SwXFrame::getSupportedServiceNames();
    3473           0 :     aRet.realloc(aRet.getLength() + 1);
    3474           0 :     OUString* pArray = aRet.getArray();
    3475           0 :     pArray[aRet.getLength() - 1] = "com.sun.star.text.TextGraphicObject";
    3476           0 :     return aRet;
    3477             : }
    3478             : 
    3479           0 : void * SAL_CALL SwXTextGraphicObject::operator new( size_t t) throw()
    3480             : {
    3481           0 :     return SwXTextGraphicObjectBaseClass::operator new(t);
    3482             : }
    3483             : 
    3484           0 : void SAL_CALL SwXTextGraphicObject::operator delete( void * p) throw()
    3485             : {
    3486           0 :     SwXTextGraphicObjectBaseClass::operator delete(p);
    3487           0 : }
    3488             : 
    3489             : uno::Reference<container::XNameReplace> SAL_CALL
    3490           0 :     SwXTextGraphicObject::getEvents()
    3491             :         throw(uno::RuntimeException, std::exception)
    3492             : {
    3493           0 :     return new SwFrameEventDescriptor( *this );
    3494             : }
    3495             : 
    3496           0 : SwXTextEmbeddedObject::SwXTextEmbeddedObject( SwDoc *pDoc ) :
    3497           0 :     SwXFrame(FLYCNTTYPE_OLE, aSwMapProvider.GetPropertySet(PROPERTY_MAP_EMBEDDED_OBJECT), pDoc)
    3498             : {
    3499           0 : }
    3500             : 
    3501           0 : SwXTextEmbeddedObject::SwXTextEmbeddedObject(SwFrmFmt& rFmt) :
    3502           0 :     SwXFrame(rFmt, FLYCNTTYPE_OLE, aSwMapProvider.GetPropertySet(PROPERTY_MAP_EMBEDDED_OBJECT))
    3503             : {
    3504             : 
    3505           0 : }
    3506             : 
    3507           0 : SwXTextEmbeddedObject::~SwXTextEmbeddedObject()
    3508             : {
    3509             : 
    3510           0 : }
    3511           0 : void SAL_CALL SwXTextEmbeddedObject::acquire()throw()
    3512             : {
    3513           0 :     SwXFrame::acquire();
    3514           0 : }
    3515             : 
    3516           0 : void SAL_CALL SwXTextEmbeddedObject::release()throw()
    3517             : {
    3518           0 :     SwXFrame::release();
    3519           0 : }
    3520             : 
    3521           0 : ::uno::Any SAL_CALL SwXTextEmbeddedObject::queryInterface( const uno::Type& aType )
    3522             :     throw( uno::RuntimeException, std::exception)
    3523             : {
    3524           0 :     ::uno::Any aRet = SwXFrame::queryInterface(aType);;
    3525           0 :     if(aRet.getValueType() == ::getCppuVoidType())
    3526           0 :         aRet = SwXTextEmbeddedObjectBaseClass::queryInterface(aType);
    3527           0 :     return aRet;
    3528             : }
    3529             : 
    3530           0 : uno::Sequence< uno::Type > SAL_CALL SwXTextEmbeddedObject::getTypes(  ) throw(uno::RuntimeException, std::exception)
    3531             : {
    3532           0 :     uno::Sequence< uno::Type > aTextEmbeddedTypes = SwXTextEmbeddedObjectBaseClass::getTypes();
    3533           0 :     uno::Sequence< uno::Type > aFrameTypes = SwXFrame::getTypes();
    3534             : 
    3535           0 :     long nIndex = aTextEmbeddedTypes.getLength();
    3536             :     aTextEmbeddedTypes.realloc(
    3537           0 :         aTextEmbeddedTypes.getLength() +
    3538           0 :         aFrameTypes.getLength());
    3539             : 
    3540           0 :     uno::Type* pTextEmbeddedTypes = aTextEmbeddedTypes.getArray();
    3541             : 
    3542           0 :     const uno::Type* pFrameTypes = aFrameTypes.getConstArray();
    3543             :     long nPos;
    3544           0 :     for(nPos = 0; nPos <aFrameTypes.getLength(); nPos++)
    3545           0 :         pTextEmbeddedTypes[nIndex++] = pFrameTypes[nPos];
    3546             : 
    3547           0 :     return aTextEmbeddedTypes;
    3548             : }
    3549             : 
    3550           0 : uno::Sequence< sal_Int8 > SAL_CALL SwXTextEmbeddedObject::getImplementationId(  ) throw(uno::RuntimeException, std::exception)
    3551             : {
    3552           0 :     return css::uno::Sequence<sal_Int8>();
    3553             : }
    3554             : 
    3555           0 : void SwXTextEmbeddedObject::attach(const uno::Reference< text::XTextRange > & xTextRange) throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
    3556             : {
    3557           0 :     SwXFrame::attach(xTextRange);
    3558           0 : }
    3559             : 
    3560           0 : uno::Reference< text::XTextRange >  SwXTextEmbeddedObject::getAnchor(void) throw( uno::RuntimeException, std::exception )
    3561             : {
    3562           0 :     SolarMutexGuard aGuard;
    3563           0 :     return SwXFrame::getAnchor();
    3564             : }
    3565             : 
    3566           0 : void SwXTextEmbeddedObject::dispose(void) throw( uno::RuntimeException, std::exception )
    3567             : {
    3568           0 :     SolarMutexGuard aGuard;
    3569           0 :     SwXFrame::dispose();
    3570           0 : }
    3571             : 
    3572           0 : void SwXTextEmbeddedObject::addEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException, std::exception )
    3573             : {
    3574           0 :     SwXFrame::addEventListener(aListener);
    3575           0 : }
    3576             : 
    3577           0 : void SwXTextEmbeddedObject::removeEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException, std::exception )
    3578             : {
    3579           0 :     SwXFrame::removeEventListener(aListener);
    3580           0 : }
    3581             : 
    3582           0 : uno::Reference< lang::XComponent >  SwXTextEmbeddedObject::getEmbeddedObject(void) throw( uno::RuntimeException, std::exception )
    3583             : {
    3584           0 :     uno::Reference< lang::XComponent >  xRet;
    3585           0 :     SwFrmFmt*   pFmt = GetFrmFmt();
    3586           0 :     if(pFmt)
    3587             :     {
    3588           0 :         SwDoc* pDoc = pFmt->GetDoc();
    3589           0 :         const SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    3590             :         OSL_ENSURE( pCnt->GetCntntIdx() &&
    3591             :                        pDoc->GetNodes()[ pCnt->GetCntntIdx()->
    3592             :                                         GetIndex() + 1 ]->GetOLENode(), "kein OLE-Node?");
    3593             : 
    3594           0 :         SwOLENode* pOleNode =  pDoc->GetNodes()[ pCnt->GetCntntIdx()
    3595           0 :                                         ->GetIndex() + 1 ]->GetOLENode();
    3596           0 :         uno::Reference < embed::XEmbeddedObject > xIP = pOleNode->GetOLEObj().GetOleRef();
    3597           0 :         if ( svt::EmbeddedObjectRef::TryRunningState( xIP ) )
    3598             :         {
    3599             :             // TODO/LATER: the listener registered after client creation should be able to handle scaling, after that the client is not necessary here
    3600           0 :             if ( pDoc->GetDocShell() )
    3601           0 :                 pDoc->GetDocShell()->GetIPClient( svt::EmbeddedObjectRef( xIP, embed::Aspects::MSOLE_CONTENT ) );
    3602             : 
    3603           0 :             xRet = uno::Reference < lang::XComponent >( xIP->getComponent(), uno::UNO_QUERY );
    3604           0 :             uno::Reference< util::XModifyBroadcaster >  xBrdcst( xRet, uno::UNO_QUERY);
    3605           0 :             uno::Reference< frame::XModel > xModel( xRet, uno::UNO_QUERY);
    3606           0 :             if( xBrdcst.is() && xModel.is() )
    3607             :             {
    3608           0 :                 SwXOLEListener* pListener = SwIterator<SwXOLEListener,SwFmt>::FirstElement( *pFmt );
    3609             :                 //create a new one if the OLE object doesn't have one already
    3610           0 :                 if( !pListener )
    3611             :                 {
    3612           0 :                     uno::Reference< util::XModifyListener > xOLEListener = new SwXOLEListener(*pFmt, xModel);
    3613           0 :                     xBrdcst->addModifyListener( xOLEListener );
    3614             :                 }
    3615           0 :             }
    3616           0 :         }
    3617             :     }
    3618           0 :     return xRet;
    3619             : }
    3620             : 
    3621           0 : uno::Reference< embed::XEmbeddedObject > SAL_CALL SwXTextEmbeddedObject::getExtendedControlOverEmbeddedObject()
    3622             :         throw( uno::RuntimeException, std::exception )
    3623             : {
    3624           0 :     uno::Reference< embed::XEmbeddedObject > xResult;
    3625           0 :     SwFrmFmt*   pFmt = GetFrmFmt();
    3626           0 :     if(pFmt)
    3627             :     {
    3628           0 :         SwDoc* pDoc = pFmt->GetDoc();
    3629           0 :         const SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    3630             :         OSL_ENSURE( pCnt->GetCntntIdx() &&
    3631             :                        pDoc->GetNodes()[ pCnt->GetCntntIdx()->
    3632             :                                         GetIndex() + 1 ]->GetOLENode(), "kein OLE-Node?");
    3633             : 
    3634           0 :         SwOLENode* pOleNode =  pDoc->GetNodes()[ pCnt->GetCntntIdx()
    3635           0 :                                         ->GetIndex() + 1 ]->GetOLENode();
    3636           0 :         xResult = pOleNode->GetOLEObj().GetOleRef();
    3637           0 :         if ( svt::EmbeddedObjectRef::TryRunningState( xResult ) )
    3638             :         {
    3639             :             // TODO/LATER: the listener registered after client creation should be able to handle scaling, after that the client is not necessary here
    3640           0 :             if ( pDoc->GetDocShell() )
    3641           0 :                 pDoc->GetDocShell()->GetIPClient( svt::EmbeddedObjectRef( xResult, embed::Aspects::MSOLE_CONTENT ) );
    3642             : 
    3643           0 :             uno::Reference < lang::XComponent > xComp( xResult->getComponent(), uno::UNO_QUERY );
    3644           0 :             uno::Reference< util::XModifyBroadcaster >  xBrdcst( xComp, uno::UNO_QUERY);
    3645           0 :             uno::Reference< frame::XModel > xModel( xComp, uno::UNO_QUERY);
    3646           0 :             if( xBrdcst.is() && xModel.is() )
    3647             :             {
    3648           0 :                 SwXOLEListener* pListener = SwIterator<SwXOLEListener,SwFmt>::FirstElement( *pFmt );
    3649             :                 //create a new one if the OLE object doesn't have one already
    3650           0 :                 if( !pListener )
    3651             :                 {
    3652           0 :                     uno::Reference< util::XModifyListener > xOLEListener = new SwXOLEListener(*pFmt, xModel);
    3653           0 :                     xBrdcst->addModifyListener( xOLEListener );
    3654             :                 }
    3655           0 :             }
    3656             :         }
    3657             :     }
    3658           0 :     return xResult;
    3659             : }
    3660             : 
    3661           0 : sal_Int64 SAL_CALL SwXTextEmbeddedObject::getAspect() throw (uno::RuntimeException, std::exception)
    3662             : {
    3663           0 :     SwFrmFmt*   pFmt = GetFrmFmt();
    3664           0 :     if(pFmt)
    3665             :     {
    3666           0 :         SwDoc* pDoc = pFmt->GetDoc();
    3667           0 :         const SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    3668             :         OSL_ENSURE( pCnt->GetCntntIdx() &&
    3669             :                        pDoc->GetNodes()[ pCnt->GetCntntIdx()->
    3670             :                                         GetIndex() + 1 ]->GetOLENode(), "kein OLE-Node?");
    3671             : 
    3672           0 :         return pDoc->GetNodes()[ pCnt->GetCntntIdx()->GetIndex() + 1 ]->GetOLENode()->GetAspect();
    3673             :     }
    3674             : 
    3675           0 :     return embed::Aspects::MSOLE_CONTENT; // return the default value
    3676             : }
    3677             : 
    3678           0 : void SAL_CALL SwXTextEmbeddedObject::setAspect( sal_Int64 nAspect ) throw (uno::RuntimeException, std::exception)
    3679             : {
    3680           0 :     SwFrmFmt*   pFmt = GetFrmFmt();
    3681           0 :     if(pFmt)
    3682             :     {
    3683           0 :         SwDoc* pDoc = pFmt->GetDoc();
    3684           0 :         const SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    3685             :         OSL_ENSURE( pCnt->GetCntntIdx() &&
    3686             :                        pDoc->GetNodes()[ pCnt->GetCntntIdx()->
    3687             :                                         GetIndex() + 1 ]->GetOLENode(), "kein OLE-Node?");
    3688             : 
    3689           0 :         pDoc->GetNodes()[ pCnt->GetCntntIdx()->GetIndex() + 1 ]->GetOLENode()->SetAspect( nAspect );
    3690             :     }
    3691           0 : }
    3692             : 
    3693           0 : uno::Reference< graphic::XGraphic > SAL_CALL SwXTextEmbeddedObject::getReplacementGraphic() throw (uno::RuntimeException, std::exception)
    3694             : {
    3695           0 :     SwFrmFmt*   pFmt = GetFrmFmt();
    3696           0 :     if(pFmt)
    3697             :     {
    3698           0 :         SwDoc* pDoc = pFmt->GetDoc();
    3699           0 :         const SwFmtCntnt* pCnt = &pFmt->GetCntnt();
    3700             :         OSL_ENSURE( pCnt->GetCntntIdx() &&
    3701             :                        pDoc->GetNodes()[ pCnt->GetCntntIdx()->
    3702             :                                         GetIndex() + 1 ]->GetOLENode(), "kein OLE-Node?");
    3703             : 
    3704           0 :         const Graphic* pGraphic = pDoc->GetNodes()[ pCnt->GetCntntIdx()->GetIndex() + 1 ]->GetOLENode()->GetGraphic();
    3705           0 :         if ( pGraphic )
    3706           0 :             return pGraphic->GetXGraphic();
    3707             :     }
    3708             : 
    3709           0 :     return uno::Reference< graphic::XGraphic >();
    3710             : }
    3711             : 
    3712           0 : OUString SwXTextEmbeddedObject::getImplementationName(void) throw( uno::RuntimeException, std::exception )
    3713             : {
    3714           0 :     return OUString("SwXTextEmbeddedObject");
    3715             : }
    3716             : 
    3717           0 : sal_Bool SwXTextEmbeddedObject::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
    3718             : {
    3719           0 :     return cppu::supportsService(this, rServiceName);
    3720             : }
    3721             : 
    3722           0 : uno::Sequence< OUString > SwXTextEmbeddedObject::getSupportedServiceNames(void)
    3723             :         throw( uno::RuntimeException, std::exception )
    3724             : {
    3725           0 :     uno::Sequence < OUString > aRet = SwXFrame::getSupportedServiceNames();
    3726           0 :     aRet.realloc(aRet.getLength() + 1);
    3727           0 :     OUString* pArray = aRet.getArray();
    3728           0 :     pArray[aRet.getLength() - 1] = "com.sun.star.text.TextEmbeddedObject";
    3729           0 :     return aRet;
    3730             : }
    3731             : 
    3732           0 : void * SAL_CALL SwXTextEmbeddedObject::operator new( size_t t) throw()
    3733             : {
    3734           0 :     return SwXTextEmbeddedObjectBaseClass::operator new(t);
    3735             : }
    3736             : 
    3737           0 : void SAL_CALL SwXTextEmbeddedObject::operator delete( void * p) throw()
    3738             : {
    3739           0 :     SwXTextEmbeddedObjectBaseClass::operator delete(p);
    3740           0 : }
    3741             : 
    3742             : uno::Reference<container::XNameReplace> SAL_CALL
    3743           0 :     SwXTextEmbeddedObject::getEvents()
    3744             :         throw(uno::RuntimeException, std::exception)
    3745             : {
    3746           0 :     return new SwFrameEventDescriptor( *this );
    3747             : }
    3748             : 
    3749           0 : TYPEINIT1(SwXOLEListener, SwClient);
    3750             : 
    3751           0 : SwXOLEListener::SwXOLEListener( SwFmt& rOLEFmt, uno::Reference< XModel > xOLE) :
    3752             :     SwClient(&rOLEFmt),
    3753           0 :     xOLEModel(xOLE)
    3754             : {
    3755           0 : }
    3756             : 
    3757           0 : SwXOLEListener::~SwXOLEListener()
    3758           0 : {}
    3759             : 
    3760           0 : void SwXOLEListener::modified( const lang::EventObject& /*rEvent*/ )
    3761             :                                         throw( uno::RuntimeException, std::exception )
    3762             : {
    3763           0 :     SolarMutexGuard aGuard;
    3764             : 
    3765           0 :     SwOLENode* pNd = 0;
    3766           0 :     SwFmt* pFmt = GetFmt();
    3767           0 :     if(pFmt)
    3768           0 :     {const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    3769           0 :         if(pIdx)
    3770             :         {
    3771           0 :             SwNodeIndex aIdx(*pIdx, 1);
    3772           0 :             SwNoTxtNode* pNoTxt = aIdx.GetNode().GetNoTxtNode();
    3773           0 :             pNd = pNoTxt->GetOLENode();
    3774             :         }
    3775             :     }
    3776           0 :     if(!pNd)
    3777           0 :         throw uno::RuntimeException();
    3778             : 
    3779           0 :     uno::Reference < embed::XEmbeddedObject > xIP = pNd->GetOLEObj().GetOleRef();
    3780           0 :     if ( xIP.is() )
    3781             :     {
    3782           0 :         sal_Int32 nState = xIP->getCurrentState();
    3783           0 :         if ( nState == embed::EmbedStates::INPLACE_ACTIVE || nState == embed::EmbedStates::UI_ACTIVE )
    3784           0 :             return;
    3785             :     }
    3786             : 
    3787             :     // if the OLE-Node is UI-Active do nothing
    3788           0 :     pNd->SetOLESizeInvalid(true);
    3789           0 :     pNd->GetDoc()->SetOLEObjModified();
    3790             : }
    3791             : 
    3792           0 : void SwXOLEListener::disposing( const lang::EventObject& rEvent )
    3793             :                         throw( uno::RuntimeException, std::exception )
    3794             : {
    3795           0 :     SolarMutexGuard aGuard;
    3796             : 
    3797           0 :     uno::Reference< util::XModifyListener >  xListener( this );
    3798             : 
    3799           0 :     uno::Reference< frame::XModel >  xModel( rEvent.Source, uno::UNO_QUERY );
    3800           0 :     uno::Reference< util::XModifyBroadcaster >  xBrdcst(xModel, uno::UNO_QUERY);
    3801             : 
    3802             :     try
    3803             :     {
    3804           0 :         if( xBrdcst.is() )
    3805           0 :             xBrdcst->removeModifyListener( xListener );
    3806             :     }
    3807           0 :     catch(uno::Exception const &)
    3808             :     {
    3809             :         OSL_FAIL("OLE Listener couldn't be removed");
    3810           0 :     }
    3811           0 : }
    3812             : 
    3813           0 : void SwXOLEListener::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
    3814             : {
    3815           0 :     ClientModify(this, pOld, pNew);
    3816           0 :     if(!GetRegisteredIn())
    3817           0 :         xOLEModel = 0;
    3818           0 : }
    3819             : 
    3820             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10