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 "cmdid.h"
21 : #include "hintids.hxx"
22 :
23 : #include <svl/stritem.hxx>
24 : #include <editeng/protitem.hxx>
25 : #include <editeng/boxitem.hxx>
26 : #include <editeng/opaqitem.hxx>
27 : #include <editeng/lrspitem.hxx>
28 : #include <editeng/ulspitem.hxx>
29 : #include <editeng/shaditem.hxx>
30 : #include <svx/swframevalidation.hxx>
31 : #include <svx/xdef.hxx>
32 : #include <fmtclds.hxx>
33 : #include "wrtsh.hxx"
34 : #include "view.hxx"
35 : #include "viewopt.hxx"
36 : #include "uitool.hxx"
37 : #include "frmmgr.hxx"
38 : #include "format.hxx"
39 : #include "mdiexp.hxx"
40 : #include "poolfmt.hxx"
41 : #include <com/sun/star/text/TextContentAnchorType.hpp>
42 : #include <com/sun/star/text/HoriOrientation.hpp>
43 : #include <com/sun/star/text/VertOrientation.hpp>
44 : #include <com/sun/star/text/RelOrientation.hpp>
45 :
46 : using namespace ::com::sun::star;
47 :
48 : static sal_uInt16 aFrmMgrRange[] = {
49 : RES_FRMATR_BEGIN, RES_FRMATR_END-1,
50 :
51 : //UUUU FillAttribute support
52 : XATTR_FILL_FIRST, XATTR_FILL_LAST,
53 :
54 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
55 : FN_SET_FRM_NAME, FN_SET_FRM_NAME,
56 : 0};
57 :
58 : // determine frame attributes via Shell
59 0 : SwFlyFrmAttrMgr::SwFlyFrmAttrMgr( bool bNew, SwWrtShell* pSh, sal_uInt8 nType ) :
60 0 : m_aSet( static_cast<SwAttrPool&>(pSh->GetAttrPool()), aFrmMgrRange ),
61 : m_pOwnSh( pSh ),
62 : m_bAbsPos( false ),
63 : m_bNewFrm( bNew ),
64 : m_bIsInVertical( false ),
65 0 : m_bIsInVerticalL2R( false )
66 : {
67 0 : if ( m_bNewFrm )
68 : {
69 : // set defaults:
70 0 : sal_uInt16 nId = 0;
71 0 : switch ( nType )
72 : {
73 0 : case FRMMGR_TYPE_TEXT: nId = RES_POOLFRM_FRAME; break;
74 0 : case FRMMGR_TYPE_OLE: nId = RES_POOLFRM_OLE; break;
75 0 : case FRMMGR_TYPE_GRF: nId = RES_POOLFRM_GRAPHIC; break;
76 : }
77 0 : m_aSet.SetParent( &m_pOwnSh->GetFormatFromPool( nId )->GetAttrSet());
78 0 : m_aSet.Put( SwFormatFrmSize( ATT_MIN_SIZE, DFLT_WIDTH, DFLT_HEIGHT ));
79 0 : if ( 0 != ::GetHtmlMode(pSh->GetView().GetDocShell()) )
80 0 : m_aSet.Put( SwFormatHoriOrient( 0, text::HoriOrientation::LEFT, text::RelOrientation::PRINT_AREA ) );
81 : }
82 0 : else if ( nType == FRMMGR_TYPE_NONE )
83 : {
84 0 : m_pOwnSh->GetFlyFrmAttr( m_aSet );
85 : bool bRightToLeft;
86 0 : m_bIsInVertical = m_pOwnSh->IsFrmVertical(true, bRightToLeft, m_bIsInVerticalL2R);
87 : }
88 0 : ::PrepareBoxInfo( m_aSet, *m_pOwnSh );
89 0 : }
90 :
91 0 : SwFlyFrmAttrMgr::SwFlyFrmAttrMgr( bool bNew, SwWrtShell* pSh, const SfxItemSet &rSet ) :
92 : m_aSet( rSet ),
93 : m_pOwnSh( pSh ),
94 : m_bAbsPos( false ),
95 : m_bNewFrm( bNew ),
96 : m_bIsInVertical(false),
97 0 : m_bIsInVerticalL2R(false)
98 : {
99 0 : if(!bNew)
100 : {
101 : bool bRightToLeft;
102 0 : m_bIsInVertical = pSh->IsFrmVertical(true, bRightToLeft, m_bIsInVerticalL2R);
103 : }
104 0 : }
105 :
106 : // Initialise
107 0 : void SwFlyFrmAttrMgr::UpdateAttrMgr()
108 : {
109 0 : if ( !m_bNewFrm && m_pOwnSh->IsFrmSelected() )
110 0 : m_pOwnSh->GetFlyFrmAttr( m_aSet );
111 0 : ::PrepareBoxInfo( m_aSet, *m_pOwnSh );
112 0 : }
113 :
114 0 : void SwFlyFrmAttrMgr::_UpdateFlyFrm()
115 : {
116 0 : const SfxPoolItem* pItem = 0;
117 :
118 0 : if (m_aSet.GetItemState(FN_SET_FRM_NAME, false, &pItem) == SfxItemState::SET)
119 0 : m_pOwnSh->SetFlyName(static_cast<const SfxStringItem *>(pItem)->GetValue());
120 :
121 0 : m_pOwnSh->SetModified();
122 :
123 0 : if ( m_bAbsPos )
124 : {
125 0 : m_pOwnSh->SetFlyPos( m_aAbsPos );
126 0 : m_bAbsPos = false;
127 : }
128 0 : }
129 :
130 : // change existing Fly-Frame
131 0 : void SwFlyFrmAttrMgr::UpdateFlyFrm()
132 : {
133 : OSL_ENSURE( m_pOwnSh->IsFrmSelected(),
134 : "no frame selected or no shell, update not possible");
135 :
136 0 : if( m_pOwnSh->IsFrmSelected() )
137 : {
138 : //JP 6.8.2001: set never an invalid anchor into the core.
139 : const SfxPoolItem *pGItem, *pItem;
140 0 : if( SfxItemState::SET == m_aSet.GetItemState( RES_ANCHOR, false, &pItem ))
141 : {
142 0 : SfxItemSet aGetSet( *m_aSet.GetPool(), RES_ANCHOR, RES_ANCHOR );
143 0 : if( m_pOwnSh->GetFlyFrmAttr( aGetSet ) && 1 == aGetSet.Count() &&
144 0 : SfxItemState::SET == aGetSet.GetItemState( RES_ANCHOR, false, &pGItem )
145 0 : && static_cast<const SwFormatAnchor*>(pGItem)->GetAnchorId() ==
146 0 : static_cast<const SwFormatAnchor*>(pItem)->GetAnchorId() )
147 0 : m_aSet.ClearItem( RES_ANCHOR );
148 : }
149 :
150 : // return wg. BASIC
151 0 : if( m_aSet.Count() )
152 : {
153 0 : m_pOwnSh->StartAllAction();
154 0 : m_pOwnSh->SetFlyFrmAttr( m_aSet );
155 0 : _UpdateFlyFrm();
156 0 : m_pOwnSh->EndAllAction();
157 : }
158 : }
159 0 : }
160 :
161 : // insert frame
162 0 : bool SwFlyFrmAttrMgr::InsertFlyFrm()
163 : {
164 0 : m_pOwnSh->StartAllAction();
165 :
166 0 : bool bRet = 0 != m_pOwnSh->NewFlyFrm( m_aSet );
167 :
168 : // turn on the right mode at the shell, frame got selected automatically.
169 0 : if ( bRet )
170 : {
171 0 : _UpdateFlyFrm();
172 0 : m_pOwnSh->EnterSelFrmMode();
173 0 : FrameNotify(m_pOwnSh, FLY_DRAG_START);
174 : }
175 0 : m_pOwnSh->EndAllAction();
176 0 : return bRet;
177 : }
178 :
179 : // Insert frames of type eAnchorType. Position and size are being set explicitly.
180 : // Not-allowed values of the enumeration type get corrected.
181 0 : void SwFlyFrmAttrMgr::InsertFlyFrm(RndStdIds eAnchorType,
182 : const Point &rPos,
183 : const Size &rSize,
184 : bool bAbs )
185 : {
186 : OSL_ENSURE( eAnchorType == FLY_AT_PAGE ||
187 : eAnchorType == FLY_AT_PARA ||
188 : eAnchorType == FLY_AT_CHAR ||
189 : eAnchorType == FLY_AT_FLY ||
190 : eAnchorType == FLY_AS_CHAR, "invalid frame type" );
191 :
192 0 : if ( bAbs )
193 0 : SetAbsPos( rPos );
194 : else
195 0 : SetPos( rPos );
196 :
197 0 : SetSize( rSize );
198 0 : SetAnchor( eAnchorType );
199 0 : InsertFlyFrm();
200 0 : }
201 :
202 : // set anchor
203 0 : void SwFlyFrmAttrMgr::SetAnchor( RndStdIds eId )
204 : {
205 : sal_uInt16 nPhyPageNum, nVirtPageNum;
206 0 : m_pOwnSh->GetPageNum( nPhyPageNum, nVirtPageNum );
207 :
208 0 : m_aSet.Put( SwFormatAnchor( eId, nPhyPageNum ) );
209 0 : if ((FLY_AT_PAGE == eId) || (FLY_AT_PARA == eId) || (FLY_AT_CHAR == eId)
210 0 : || (FLY_AT_FLY == eId))
211 : {
212 0 : SwFormatVertOrient aVertOrient( GetVertOrient() );
213 0 : SwFormatHoriOrient aHoriOrient( GetHoriOrient() );
214 0 : aHoriOrient.SetRelationOrient( text::RelOrientation::FRAME );
215 0 : aVertOrient.SetRelationOrient( text::RelOrientation::FRAME );
216 0 : m_aSet.Put( aVertOrient );
217 0 : m_aSet.Put( aHoriOrient );
218 : }
219 0 : }
220 :
221 : // set the attribute for columns
222 0 : void SwFlyFrmAttrMgr::SetCol( const SwFormatCol &rCol )
223 : {
224 0 : m_aSet.Put( rCol );
225 0 : }
226 :
227 : // set absolute position
228 0 : void SwFlyFrmAttrMgr::SetAbsPos( const Point& rPoint )
229 : {
230 0 : m_bAbsPos = true;
231 0 : m_aAbsPos = rPoint;
232 0 : SwFormatVertOrient aVertOrient( GetVertOrient() );
233 0 : SwFormatHoriOrient aHoriOrient( GetHoriOrient() );
234 0 : aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE );
235 0 : aVertOrient.SetVertOrient( text::VertOrientation::NONE );
236 0 : m_aSet.Put( aVertOrient );
237 0 : m_aSet.Put( aHoriOrient );
238 0 : }
239 :
240 : // check metrics for correctness
241 0 : void SwFlyFrmAttrMgr::ValidateMetrics( SvxSwFrameValidation& rVal,
242 : const SwPosition* pToCharContentPos,
243 : bool bOnlyPercentRefValue )
244 : {
245 0 : if (!bOnlyPercentRefValue)
246 : {
247 0 : rVal.nMinHeight = MINFLY + CalcTopSpace() + CalcBottomSpace();
248 0 : rVal.nMinWidth = MINFLY + CalcLeftSpace()+ CalcRightSpace();
249 : }
250 :
251 0 : SwRect aBoundRect;
252 :
253 : // OD 18.09.2003 #i18732# - adjustment for allowing vertical position
254 : // aligned to page for fly frame anchored to paragraph or to character.
255 0 : const RndStdIds eAnchorType = static_cast<RndStdIds >(rVal.nAnchorType);
256 0 : const SwFormatFrmSize& rSize = static_cast<const SwFormatFrmSize&>(m_aSet.Get(RES_FRM_SIZE));
257 : m_pOwnSh->CalcBoundRect( aBoundRect, eAnchorType,
258 : rVal.nHRelOrient,
259 : rVal.nVRelOrient,
260 : pToCharContentPos,
261 : rVal.bFollowTextFlow,
262 : rVal.bMirror, NULL, &rVal.aPercentSize,
263 0 : &rSize);
264 :
265 0 : if (bOnlyPercentRefValue)
266 0 : return;
267 :
268 : // --> OD 2009-09-01 #mongolianlayout#
269 0 : if ( m_bIsInVertical || m_bIsInVerticalL2R )
270 : {
271 0 : Point aPos(aBoundRect.Pos());
272 0 : long nTmp = aPos.X();
273 0 : aPos.X() = aPos.Y();
274 0 : aPos.Y() = nTmp;
275 0 : Size aSize(aBoundRect.SSize());
276 0 : nTmp = aSize.Width();
277 0 : aSize.Width() = aSize.Height();
278 0 : aSize.Height() = nTmp;
279 0 : aBoundRect.Chg( aPos, aSize );
280 : //exchange width/height to enable correct values
281 0 : nTmp = rVal.nWidth;
282 0 : rVal.nWidth = rVal.nHeight;
283 0 : rVal.nHeight = nTmp;
284 : }
285 0 : if ((eAnchorType == FLY_AT_PAGE) || (eAnchorType == FLY_AT_FLY))
286 : {
287 : // MinimalPosition
288 0 : rVal.nMinHPos = aBoundRect.Left();
289 0 : rVal.nMinVPos = aBoundRect.Top();
290 0 : SwTwips nH = rVal.nHPos;
291 0 : SwTwips nV = rVal.nVPos;
292 :
293 0 : if (rVal.nHPos + rVal.nWidth > aBoundRect.Right())
294 : {
295 0 : if (rVal.nHoriOrient == text::HoriOrientation::NONE)
296 : {
297 0 : rVal.nHPos -= ((rVal.nHPos + rVal.nWidth) - aBoundRect.Right());
298 0 : nH = rVal.nHPos;
299 : }
300 : else
301 0 : rVal.nWidth = aBoundRect.Right() - rVal.nHPos;
302 : }
303 :
304 0 : if (rVal.nHPos + rVal.nWidth > aBoundRect.Right())
305 0 : rVal.nWidth = aBoundRect.Right() - rVal.nHPos;
306 :
307 0 : if (rVal.nVPos + rVal.nHeight > aBoundRect.Bottom())
308 : {
309 0 : if (rVal.nVertOrient == text::VertOrientation::NONE)
310 : {
311 0 : rVal.nVPos -= ((rVal.nVPos + rVal.nHeight) - aBoundRect.Bottom());
312 0 : nV = rVal.nVPos;
313 : }
314 : else
315 0 : rVal.nHeight = aBoundRect.Bottom() - rVal.nVPos;
316 : }
317 :
318 0 : if (rVal.nVPos + rVal.nHeight > aBoundRect.Bottom())
319 0 : rVal.nHeight = aBoundRect.Bottom() - rVal.nVPos;
320 :
321 0 : if ( rVal.nVertOrient != text::VertOrientation::NONE )
322 0 : nV = aBoundRect.Top();
323 :
324 0 : if ( rVal.nHoriOrient != text::HoriOrientation::NONE )
325 0 : nH = aBoundRect.Left();
326 :
327 0 : rVal.nMaxHPos = aBoundRect.Right() - rVal.nWidth;
328 0 : rVal.nMaxHeight = aBoundRect.Bottom() - nV;
329 :
330 0 : rVal.nMaxVPos = aBoundRect.Bottom() - rVal.nHeight;
331 0 : rVal.nMaxWidth = aBoundRect.Right() - nH;
332 : }
333 : // OD 12.11.2003 #i22341# - handle to character anchored objects vertical
334 : // aligned at character or top of line in a special case
335 0 : else if ((eAnchorType == FLY_AT_PARA) ||
336 0 : ((eAnchorType == FLY_AT_CHAR) &&
337 0 : !(rVal.nVRelOrient == text::RelOrientation::CHAR) &&
338 0 : !(rVal.nVRelOrient == text::RelOrientation::TEXT_LINE) ) )
339 : {
340 0 : if (rVal.nHPos + rVal.nWidth > aBoundRect.Right())
341 : {
342 0 : if (rVal.nHoriOrient == text::HoriOrientation::NONE)
343 : {
344 0 : rVal.nHPos -= ((rVal.nHPos + rVal.nWidth) - aBoundRect.Right());
345 : }
346 : else
347 0 : rVal.nWidth = aBoundRect.Right() - rVal.nHPos;
348 : }
349 :
350 : // OD 29.09.2003 #i17567#, #i18732# - consider following the text flow
351 : // and alignment at page areas.
352 0 : const bool bMaxVPosAtBottom = !rVal.bFollowTextFlow ||
353 0 : rVal.nVRelOrient == text::RelOrientation::PAGE_FRAME ||
354 0 : rVal.nVRelOrient == text::RelOrientation::PAGE_PRINT_AREA;
355 : {
356 : SwTwips nTmpMaxVPos = ( bMaxVPosAtBottom
357 : ? aBoundRect.Bottom()
358 0 : : aBoundRect.Height() ) -
359 0 : rVal.nHeight;
360 0 : if ( rVal.nVPos > nTmpMaxVPos )
361 : {
362 0 : if (rVal.nVertOrient == text::VertOrientation::NONE)
363 : {
364 0 : rVal.nVPos = nTmpMaxVPos;
365 : }
366 : else
367 : {
368 : rVal.nHeight = ( bMaxVPosAtBottom
369 0 : ? aBoundRect.Bottom()
370 0 : : aBoundRect.Height() ) - rVal.nVPos;
371 : }
372 : }
373 : }
374 :
375 0 : rVal.nMinHPos = aBoundRect.Left();
376 0 : rVal.nMaxHPos = aBoundRect.Right() - rVal.nWidth;
377 :
378 0 : rVal.nMinVPos = aBoundRect.Top();
379 : // OD 26.09.2003 #i17567#, #i18732# - determine maximum vertical position
380 0 : if ( bMaxVPosAtBottom )
381 : {
382 0 : rVal.nMaxVPos = aBoundRect.Bottom() - rVal.nHeight;
383 : }
384 : else
385 : {
386 0 : rVal.nMaxVPos = aBoundRect.Height() - rVal.nHeight;
387 : }
388 :
389 : // maximum width height
390 0 : const SwTwips nH = ( rVal.nHoriOrient != text::HoriOrientation::NONE )
391 : ? aBoundRect.Left()
392 0 : : rVal.nHPos;
393 0 : const SwTwips nV = ( rVal.nVertOrient != text::VertOrientation::NONE )
394 : ? aBoundRect.Top()
395 0 : : rVal.nVPos;
396 0 : rVal.nMaxHeight = rVal.nMaxVPos + rVal.nHeight - nV;
397 0 : rVal.nMaxWidth = rVal.nMaxHPos + rVal.nWidth - nH;
398 : }
399 : // OD 12.11.2003 #i22341# - special case for to character anchored objects
400 : // vertical aligned at character or top of line.
401 : // Note: (1) positive vertical values are positions above the top of line
402 : // (2) negative vertical values are positions below the top of line
403 0 : else if ( (eAnchorType == FLY_AT_CHAR) &&
404 0 : ( rVal.nVRelOrient == text::RelOrientation::CHAR ||
405 0 : rVal.nVRelOrient == text::RelOrientation::TEXT_LINE ) )
406 : {
407 : // determine horizontal values
408 0 : rVal.nMinHPos = aBoundRect.Left();
409 :
410 0 : rVal.nMaxHPos = aBoundRect.Right() - rVal.nWidth;
411 0 : if (rVal.nHPos + rVal.nWidth > aBoundRect.Right())
412 : {
413 0 : if (rVal.nHoriOrient == text::HoriOrientation::NONE)
414 : {
415 0 : rVal.nHPos -= ((rVal.nHPos + rVal.nWidth) - aBoundRect.Right());
416 : }
417 : else
418 0 : rVal.nWidth = aBoundRect.Right() - rVal.nHPos;
419 : }
420 :
421 0 : const SwTwips nH = ( rVal.nHoriOrient != text::HoriOrientation::NONE )
422 : ? aBoundRect.Left()
423 0 : : rVal.nHPos;
424 0 : rVal.nMaxWidth = rVal.nMaxHPos + rVal.nWidth - nH;
425 :
426 : // determine vertical values
427 0 : rVal.nMinVPos = -( aBoundRect.Bottom() - rVal.nHeight );
428 0 : if ( rVal.nVPos < rVal.nMinVPos &&
429 0 : rVal.nVertOrient == text::VertOrientation::NONE )
430 : {
431 0 : rVal.nVPos = rVal.nMinVPos;
432 : }
433 :
434 0 : rVal.nMaxVPos = -aBoundRect.Top();
435 0 : if ( rVal.nVPos > rVal.nMaxVPos &&
436 0 : rVal.nVertOrient == text::VertOrientation::NONE )
437 : {
438 0 : rVal.nVPos = rVal.nMaxVPos;
439 : }
440 :
441 0 : if ( rVal.nVertOrient == text::VertOrientation::NONE )
442 : {
443 0 : rVal.nMaxHeight = aBoundRect.Bottom() + rVal.nVPos;
444 : }
445 : else
446 : {
447 0 : rVal.nMaxHeight = aBoundRect.Height();
448 0 : }
449 : }
450 0 : else if ( eAnchorType == FLY_AS_CHAR )
451 : {
452 0 : rVal.nMinHPos = 0;
453 0 : rVal.nMaxHPos = 0;
454 :
455 0 : rVal.nMaxHeight = aBoundRect.Height();
456 0 : rVal.nMaxWidth = aBoundRect.Width();
457 :
458 0 : rVal.nMaxVPos = aBoundRect.Height();
459 0 : rVal.nMinVPos = -aBoundRect.Height() + rVal.nHeight;
460 0 : if (rVal.nMaxVPos < rVal.nMinVPos)
461 : {
462 0 : rVal.nMinVPos = rVal.nMaxVPos;
463 0 : rVal.nMaxVPos = -aBoundRect.Height();
464 : }
465 : }
466 : // --> OD 2009-09-01 #mongolianlayout#
467 0 : if ( m_bIsInVertical || m_bIsInVerticalL2R )
468 : {
469 : //restore width/height exchange
470 0 : long nTmp = rVal.nWidth;
471 0 : rVal.nWidth = rVal.nHeight;
472 0 : rVal.nHeight = nTmp;
473 : }
474 :
475 0 : if (rVal.nMaxWidth < rVal.nWidth)
476 0 : rVal.nWidth = rVal.nMaxWidth;
477 0 : if (rVal.nMaxHeight < rVal.nHeight)
478 0 : rVal.nHeight = rVal.nMaxHeight;
479 : }
480 :
481 : // correction for border
482 0 : SwTwips SwFlyFrmAttrMgr::CalcTopSpace()
483 : {
484 0 : const SvxShadowItem& rShadow = GetShadow();
485 0 : const SvxBoxItem& rBox = GetBox();
486 0 : return rShadow.CalcShadowSpace(SvxShadowItemSide::TOP ) + rBox.CalcLineSpace(SvxBoxItemLine::TOP);
487 : }
488 :
489 0 : SwTwips SwFlyFrmAttrMgr::CalcBottomSpace()
490 : {
491 0 : const SvxShadowItem& rShadow = GetShadow();
492 0 : const SvxBoxItem& rBox = GetBox();
493 0 : return rShadow.CalcShadowSpace(SvxShadowItemSide::BOTTOM) + rBox.CalcLineSpace(SvxBoxItemLine::BOTTOM);
494 : }
495 :
496 0 : SwTwips SwFlyFrmAttrMgr::CalcLeftSpace()
497 : {
498 0 : const SvxShadowItem& rShadow = GetShadow();
499 0 : const SvxBoxItem& rBox = GetBox();
500 0 : return rShadow.CalcShadowSpace(SvxShadowItemSide::LEFT) + rBox.CalcLineSpace(SvxBoxItemLine::LEFT);
501 : }
502 :
503 0 : SwTwips SwFlyFrmAttrMgr::CalcRightSpace()
504 : {
505 0 : const SvxShadowItem& rShadow = GetShadow();
506 0 : const SvxBoxItem& rBox = GetBox();
507 0 : return rShadow.CalcShadowSpace(SvxShadowItemSide::RIGHT) + rBox.CalcLineSpace(SvxBoxItemLine::RIGHT);
508 : }
509 :
510 : // erase attribute from the set
511 0 : void SwFlyFrmAttrMgr::DelAttr( sal_uInt16 nId )
512 : {
513 0 : m_aSet.ClearItem( nId );
514 0 : }
515 :
516 0 : void SwFlyFrmAttrMgr::SetLRSpace( long nLeft, long nRight )
517 : {
518 : OSL_ENSURE( LONG_MAX != nLeft && LONG_MAX != nRight, "Welchen Raend setzen?" );
519 :
520 0 : SvxLRSpaceItem aTmp( static_cast<const SvxLRSpaceItem&>(m_aSet.Get( RES_LR_SPACE )) );
521 0 : if( LONG_MAX != nLeft )
522 0 : aTmp.SetLeft( sal_uInt16(nLeft) );
523 0 : if( LONG_MAX != nRight )
524 0 : aTmp.SetRight( sal_uInt16(nRight) );
525 0 : m_aSet.Put( aTmp );
526 0 : }
527 :
528 0 : void SwFlyFrmAttrMgr::SetULSpace( long nTop, long nBottom )
529 : {
530 : OSL_ENSURE(LONG_MAX != nTop && LONG_MAX != nBottom, "Welchen Raend setzen?" );
531 :
532 0 : SvxULSpaceItem aTmp( static_cast<const SvxULSpaceItem&>(m_aSet.Get( RES_UL_SPACE )) );
533 0 : if( LONG_MAX != nTop )
534 0 : aTmp.SetUpper( sal_uInt16(nTop) );
535 0 : if( LONG_MAX != nBottom )
536 0 : aTmp.SetLower( sal_uInt16(nBottom) );
537 0 : m_aSet.Put( aTmp );
538 0 : }
539 :
540 0 : void SwFlyFrmAttrMgr::SetPos( const Point& rPoint )
541 : {
542 0 : SwFormatVertOrient aVertOrient( GetVertOrient() );
543 0 : SwFormatHoriOrient aHoriOrient( GetHoriOrient() );
544 :
545 0 : aHoriOrient.SetPos ( rPoint.X() );
546 0 : aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE );
547 :
548 0 : aVertOrient.SetPos ( rPoint.Y() );
549 0 : aVertOrient.SetVertOrient( text::VertOrientation::NONE );
550 :
551 0 : m_aSet.Put( aVertOrient );
552 0 : m_aSet.Put( aHoriOrient );
553 0 : }
554 :
555 0 : void SwFlyFrmAttrMgr::SetHorzOrientation( sal_Int16 eOrient )
556 : {
557 0 : SwFormatHoriOrient aHoriOrient( GetHoriOrient() );
558 0 : aHoriOrient.SetHoriOrient( eOrient );
559 0 : m_aSet.Put( aHoriOrient );
560 0 : }
561 :
562 0 : void SwFlyFrmAttrMgr::SetVertOrientation( sal_Int16 eOrient )
563 : {
564 0 : SwFormatVertOrient aVertOrient( GetVertOrient() );
565 0 : aVertOrient.SetVertOrient( eOrient );
566 0 : m_aSet.Put( aVertOrient );
567 0 : }
568 :
569 0 : void SwFlyFrmAttrMgr::SetHeightSizeType( SwFrmSize eType )
570 : {
571 0 : SwFormatFrmSize aSize( GetFrmSize() );
572 0 : aSize.SetHeightSizeType( eType );
573 0 : m_aSet.Put( aSize );
574 0 : }
575 :
576 0 : void SwFlyFrmAttrMgr::SetSize( const Size& rSize )
577 : {
578 0 : SwFormatFrmSize aSize( GetFrmSize() );
579 0 : aSize.SetSize(Size(std::max(rSize.Width(), long(MINFLY)), std::max(rSize.Height(), long(MINFLY))));
580 0 : m_aSet.Put( aSize );
581 0 : }
582 :
583 0 : void SwFlyFrmAttrMgr::SetAttrSet(const SfxItemSet& rSet)
584 : {
585 0 : m_aSet.ClearItem();
586 0 : m_aSet.Put( rSet );
587 177 : }
588 :
589 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
