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