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