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 <anchoredobjectposition.hxx>
21 : #include <environmentofanchoredobject.hxx>
22 : #include <doc.hxx>
23 : #include <flyfrm.hxx>
24 : #include <flyfrms.hxx>
25 : #include <txtfrm.hxx>
26 : #include <pagefrm.hxx>
27 : #include <frmtool.hxx>
28 : #include <svx/svdobj.hxx>
29 : #include <dflyobj.hxx>
30 : #include <dcontact.hxx>
31 : #include <frmfmt.hxx>
32 : #include <fmtornt.hxx>
33 : #include <fmtfsize.hxx>
34 : #include <fmtfollowtextflow.hxx>
35 : #include <editeng/lrspitem.hxx>
36 : #include <editeng/ulspitem.hxx>
37 : #include <ndtxt.hxx>
38 : #include <IDocumentSettingAccess.hxx>
39 : #include <textboxhelper.hxx>
40 :
41 : using namespace ::com::sun::star;
42 : using namespace objectpositioning;
43 :
44 11812 : SwAnchoredObjectPosition::SwAnchoredObjectPosition( SdrObject& _rDrawObj )
45 : : mrDrawObj( _rDrawObj ),
46 : mbIsObjFly( false ),
47 : mpAnchoredObj( 0 ),
48 : mpAnchorFrm( 0 ),
49 : mpContact( 0 ),
50 : // #i62875#
51 : mbFollowTextFlow( false ),
52 11812 : mbDoNotCaptureAnchoredObj( false )
53 : {
54 : #if OSL_DEBUG_LEVEL > 0
55 : // assert, if object isn't of excepted type
56 : const bool bObjOfExceptedType =
57 : mrDrawObj.ISA(SwVirtFlyDrawObj) || // object representing fly frame
58 : mrDrawObj.ISA(SwDrawVirtObj) || // 'virtual' drawing object
59 : ( !mrDrawObj.ISA(SdrVirtObj) && // 'master' drawing object
60 : !mrDrawObj.ISA(SwFlyDrawObj) ); // - indirectly checked
61 : (void) bObjOfExceptedType;
62 : OSL_ENSURE( bObjOfExceptedType,
63 : "SwAnchoredObjectPosition(..) - object of unexpected type!" );
64 : #endif
65 :
66 11812 : _GetInfoAboutObj();
67 11812 : }
68 :
69 : /** determine information about object
70 :
71 : members <mbIsObjFly>, <mpFrmOfObj>, <mpAnchorFrm>, <mpContact>,
72 : <mbFollowTextFlow> and <mbDoNotCaptureAnchoredObj> are set
73 : */
74 11812 : void SwAnchoredObjectPosition::_GetInfoAboutObj()
75 : {
76 : // determine, if object represents a fly frame
77 : {
78 11812 : mbIsObjFly = mrDrawObj.ISA(SwVirtFlyDrawObj);
79 : }
80 :
81 : // determine contact object
82 : {
83 11812 : mpContact = static_cast<SwContact*>(GetUserCall( &mrDrawObj ));
84 : assert(mpContact &&
85 : "SwAnchoredObjectPosition::_GetInfoAboutObj() - missing SwContact-object.");
86 : }
87 :
88 : // determine anchored object, the object belongs to
89 : {
90 : // #i26791#
91 11812 : mpAnchoredObj = mpContact->GetAnchoredObj( &mrDrawObj );
92 : assert(mpAnchoredObj &&
93 : "SwAnchoredObjectPosition::_GetInfoAboutObj() - missing anchored object.");
94 : }
95 :
96 : // determine frame, the object is anchored at
97 : {
98 : // #i26791#
99 11812 : mpAnchorFrm = mpAnchoredObj->AnchorFrm();
100 : OSL_ENSURE( mpAnchorFrm,
101 : "SwAnchoredObjectPosition::_GetInfoAboutObj() - missing anchor frame." );
102 : }
103 :
104 : // determine format the object belongs to
105 : {
106 : // #i28701#
107 11812 : mpFrameFormat = &mpAnchoredObj->GetFrameFormat();
108 : assert(mpFrameFormat &&
109 : "<SwAnchoredObjectPosition::_GetInfoAboutObj() - missing frame format.");
110 : }
111 :
112 : // #i62875# - determine attribute value of <Follow-Text-Flow>
113 : {
114 11812 : mbFollowTextFlow = mpFrameFormat->GetFollowTextFlow().GetValue();
115 : }
116 :
117 : // determine, if anchored object has not to be captured on the page.
118 : // the following conditions must be hold to *not* capture it:
119 : // - corresponding document compatibility flag is set
120 : // - it's a drawing object
121 : // - it doesn't follow the text flow
122 : {
123 16499 : mbDoNotCaptureAnchoredObj = !mbIsObjFly && !mbFollowTextFlow &&
124 16499 : mpFrameFormat->getIDocumentSettingAccess()->get(DocumentSettingId::DO_NOT_CAPTURE_DRAW_OBJS_ON_PAGE);
125 : }
126 11812 : }
127 :
128 11812 : SwAnchoredObjectPosition::~SwAnchoredObjectPosition()
129 11812 : {}
130 :
131 0 : bool SwAnchoredObjectPosition::IsAnchoredToChar() const
132 : {
133 0 : return false;
134 : }
135 :
136 0 : const SwFrm* SwAnchoredObjectPosition::ToCharOrientFrm() const
137 : {
138 0 : return NULL;
139 : }
140 :
141 0 : const SwRect* SwAnchoredObjectPosition::ToCharRect() const
142 : {
143 0 : return NULL;
144 : }
145 :
146 : // #i22341#
147 0 : SwTwips SwAnchoredObjectPosition::ToCharTopOfLine() const
148 : {
149 0 : return 0L;
150 : }
151 :
152 : /** helper method to determine top of a frame for the vertical
153 : object positioning
154 :
155 : #i11860#
156 : */
157 23044 : SwTwips SwAnchoredObjectPosition::_GetTopForObjPos( const SwFrm& _rFrm,
158 : const SwRectFn& _fnRect,
159 : const bool _bVert )
160 : {
161 23044 : SwTwips nTopOfFrmForObjPos = (_rFrm.Frm().*_fnRect->fnGetTop)();
162 :
163 23044 : if ( _rFrm.IsTextFrm() )
164 : {
165 22935 : const SwTextFrm& rTextFrm = static_cast<const SwTextFrm&>(_rFrm);
166 22935 : if ( _bVert )
167 : {
168 : nTopOfFrmForObjPos -=
169 0 : rTextFrm.GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid();
170 : }
171 : else
172 : {
173 : nTopOfFrmForObjPos +=
174 22935 : rTextFrm.GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid();
175 : }
176 : }
177 :
178 23044 : return nTopOfFrmForObjPos;
179 : }
180 :
181 723 : void SwAnchoredObjectPosition::_GetVertAlignmentValues(
182 : const SwFrm& _rVertOrientFrm,
183 : const SwFrm& _rPageAlignLayFrm,
184 : const sal_Int16 _eRelOrient,
185 : SwTwips& _orAlignAreaHeight,
186 : SwTwips& _orAlignAreaOffset ) const
187 : {
188 723 : SwTwips nHeight = 0;
189 723 : SwTwips nOffset = 0;
190 723 : SWRECTFN( (&_rVertOrientFrm) )
191 : // #i11860# - top of <_rVertOrientFrm> for object positioning
192 723 : const SwTwips nVertOrientTop = _GetTopForObjPos( _rVertOrientFrm, fnRect, bVert );
193 : // #i11860# - upper space amount of <_rVertOrientFrm> considered
194 : // for previous frame
195 : const SwTwips nVertOrientUpperSpaceForPrevFrmAndPageGrid =
196 723 : _rVertOrientFrm.IsTextFrm()
197 : ? static_cast<const SwTextFrm&>(_rVertOrientFrm).
198 614 : GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid()
199 1337 : : 0;
200 723 : switch ( _eRelOrient )
201 : {
202 : case text::RelOrientation::FRAME:
203 : {
204 : // #i11860# - consider upper space of previous frame
205 134 : nHeight = (_rVertOrientFrm.Frm().*fnRect->fnGetHeight)() -
206 134 : nVertOrientUpperSpaceForPrevFrmAndPageGrid;
207 134 : nOffset = 0;
208 : }
209 134 : break;
210 : case text::RelOrientation::PRINT_AREA:
211 : {
212 88 : nHeight = (_rVertOrientFrm.Prt().*fnRect->fnGetHeight)();
213 : // #i11860# - consider upper space of previous frame
214 88 : nOffset = (_rVertOrientFrm.*fnRect->fnGetTopMargin)() -
215 88 : nVertOrientUpperSpaceForPrevFrmAndPageGrid;
216 : // if aligned to page in horizontal layout, consider header and
217 : // footer frame height appropriately.
218 88 : if( _rVertOrientFrm.IsPageFrm() && !bVert )
219 : {
220 : const SwFrm* pPrtFrm =
221 3 : static_cast<const SwPageFrm&>(_rVertOrientFrm).Lower();
222 11 : while( pPrtFrm )
223 : {
224 5 : if( pPrtFrm->IsHeaderFrm() )
225 : {
226 0 : nHeight -= pPrtFrm->Frm().Height();
227 0 : nOffset += pPrtFrm->Frm().Height();
228 : }
229 5 : else if( pPrtFrm->IsFooterFrm() )
230 : {
231 0 : nHeight -= pPrtFrm->Frm().Height();
232 : }
233 5 : pPrtFrm = pPrtFrm->GetNext();
234 : }
235 : }
236 : }
237 88 : break;
238 : case text::RelOrientation::PAGE_FRAME:
239 : {
240 150 : nHeight = (_rPageAlignLayFrm.Frm().*fnRect->fnGetHeight)();
241 : nOffset = (*fnRect->fnYDiff)(
242 450 : (_rPageAlignLayFrm.Frm().*fnRect->fnGetTop)(),
243 600 : nVertOrientTop );
244 : }
245 150 : break;
246 : case text::RelOrientation::PAGE_PRINT_AREA:
247 : {
248 342 : nHeight = (_rPageAlignLayFrm.Prt().*fnRect->fnGetHeight)();
249 342 : nOffset = (_rPageAlignLayFrm.*fnRect->fnGetTopMargin)() +
250 : (*fnRect->fnYDiff)(
251 1026 : (_rPageAlignLayFrm.Frm().*fnRect->fnGetTop)(),
252 1368 : nVertOrientTop );
253 : // if aligned to page in horizontal layout, consider header and
254 : // footer frame height appropriately.
255 342 : if( _rPageAlignLayFrm.IsPageFrm() && !bVert )
256 : {
257 : const SwFrm* pPrtFrm =
258 339 : static_cast<const SwPageFrm&>(_rPageAlignLayFrm).Lower();
259 1678 : while( pPrtFrm )
260 : {
261 1000 : if( pPrtFrm->IsHeaderFrm() )
262 : {
263 329 : nHeight -= pPrtFrm->Frm().Height();
264 329 : nOffset += pPrtFrm->Frm().Height();
265 : }
266 671 : else if( pPrtFrm->IsFooterFrm() )
267 : {
268 332 : nHeight -= pPrtFrm->Frm().Height();
269 : }
270 1000 : pPrtFrm = pPrtFrm->GetNext();
271 : }
272 : }
273 : }
274 342 : break;
275 : // #i22341# - vertical alignment at top of line
276 : case text::RelOrientation::TEXT_LINE:
277 : {
278 9 : if ( IsAnchoredToChar() )
279 : {
280 0 : nHeight = 0;
281 0 : nOffset = (*fnRect->fnYDiff)( ToCharTopOfLine(), nVertOrientTop );
282 : }
283 : else
284 : {
285 : OSL_FAIL( "<SwAnchoredObjectPosition::_GetVertAlignmentValues(..)> - invalid relative alignment" );
286 : }
287 : }
288 9 : break;
289 : case text::RelOrientation::CHAR:
290 : {
291 0 : if ( IsAnchoredToChar() )
292 : {
293 0 : nHeight = (ToCharRect()->*fnRect->fnGetHeight)();
294 0 : nOffset = (*fnRect->fnYDiff)( (ToCharRect()->*fnRect->fnGetTop)(),
295 0 : nVertOrientTop );
296 : }
297 : else
298 : {
299 : OSL_FAIL( "<SwAnchoredObjectPosition::_GetVertAlignmentValues(..)> - invalid relative alignment" );
300 : }
301 : }
302 0 : break;
303 : // no break here, because text::RelOrientation::CHAR is invalid, if !mbAnchorToChar
304 : default:
305 : {
306 : OSL_FAIL( "<SwAnchoredObjectPosition::_GetVertAlignmentValues(..)> - invalid relative alignment" );
307 : }
308 : }
309 :
310 723 : _orAlignAreaHeight = nHeight;
311 723 : _orAlignAreaOffset = nOffset;
312 723 : }
313 :
314 : // #i26791# - add output parameter <_roVertOffsetToFrmAnchorPos>
315 109 : SwTwips SwAnchoredObjectPosition::_GetVertRelPos(
316 : const SwFrm& _rVertOrientFrm,
317 : const SwFrm& _rPageAlignLayFrm,
318 : const sal_Int16 _eVertOrient,
319 : const sal_Int16 _eRelOrient,
320 : const SwTwips _nVertPos,
321 : const SvxLRSpaceItem& _rLRSpacing,
322 : const SvxULSpaceItem& _rULSpacing,
323 : SwTwips& _roVertOffsetToFrmAnchorPos ) const
324 : {
325 109 : SwTwips nRelPosY = 0;
326 109 : SWRECTFN( (&_rVertOrientFrm) );
327 :
328 : SwTwips nAlignAreaHeight;
329 : SwTwips nAlignAreaOffset;
330 : _GetVertAlignmentValues( _rVertOrientFrm, _rPageAlignLayFrm,
331 109 : _eRelOrient, nAlignAreaHeight, nAlignAreaOffset );
332 :
333 109 : nRelPosY = nAlignAreaOffset;
334 109 : const SwRect aObjBoundRect( GetAnchoredObj().GetObjRect() );
335 109 : const SwTwips nObjHeight = (aObjBoundRect.*fnRect->fnGetHeight)();
336 :
337 109 : switch ( _eVertOrient )
338 : {
339 : case text::VertOrientation::NONE:
340 : {
341 : // 'manual' vertical position
342 98 : nRelPosY += _nVertPos;
343 : }
344 98 : break;
345 : case text::VertOrientation::TOP:
346 : {
347 : nRelPosY += bVert
348 : ? ( bVertL2R
349 : ? _rLRSpacing.GetLeft()
350 : : _rLRSpacing.GetRight() )
351 5 : : _rULSpacing.GetUpper();
352 : }
353 5 : break;
354 : case text::VertOrientation::CENTER:
355 : {
356 0 : nRelPosY += (nAlignAreaHeight / 2) - (nObjHeight / 2);
357 : }
358 0 : break;
359 : case text::VertOrientation::BOTTOM:
360 : {
361 6 : nRelPosY += nAlignAreaHeight -
362 12 : ( nObjHeight + ( bVert
363 : ? ( bVertL2R
364 : ? _rLRSpacing.GetRight()
365 : : _rLRSpacing.GetLeft() )
366 12 : : _rULSpacing.GetLower() ) );
367 : }
368 6 : break;
369 : default:
370 : {
371 : OSL_FAIL( "<SwAnchoredObjectPosition::_GetVertRelPos(..) - invalid vertical positioning" );
372 : }
373 : }
374 :
375 : // #i26791#
376 109 : _roVertOffsetToFrmAnchorPos = nAlignAreaOffset;
377 :
378 109 : return nRelPosY;
379 : }
380 :
381 : /** adjust calculated vertical in order to keep object inside
382 : 'page' alignment layout frame.
383 :
384 : #i28701# - parameter <_nTopOfAnch> and <_bVert> added
385 : #i31805# - add parameter <_bCheckBottom>
386 : #i26945# - add parameter <_bFollowTextFlow>
387 : #i62875# - method now private and renamed.
388 : OD 2009-09-01 #mongolianlayout# - add parameter <bVertL2R>
389 : */
390 4587 : SwTwips SwAnchoredObjectPosition::_ImplAdjustVertRelPos( const SwTwips nTopOfAnch,
391 : const bool bVert,
392 : const bool bVertL2R,
393 : const SwFrm& rPageAlignLayFrm,
394 : const SwTwips nProposedRelPosY,
395 : const bool bFollowTextFlow,
396 : const bool bCheckBottom ) const
397 : {
398 4587 : SwTwips nAdjustedRelPosY = nProposedRelPosY;
399 :
400 4587 : const Size aObjSize( GetAnchoredObj().GetObjRect().SSize() );
401 :
402 : // determine the area of 'page' alignment frame, to which the vertical
403 : // position is restricted.
404 : // #i28701# - Extend restricted area for the vertical
405 : // position to area of the page frame, if wrapping style influence is
406 : // considered on object positioning. Needed to avoid layout loops in the
407 : // object positioning algorithm considering the wrapping style influence
408 : // caused by objects, which follow the text flow and thus are restricted
409 : // to its environment (e.g. page header/footer).
410 4587 : SwRect aPgAlignArea;
411 : {
412 : // #i26945# - no extension of restricted area, if
413 : // object's attribute follow text flow is set and its inside a table
414 12920 : if ( GetFrameFormat().getIDocumentSettingAccess()->get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) &&
415 4253 : ( !bFollowTextFlow ||
416 85 : !GetAnchoredObj().GetAnchorFrm()->IsInTab() ) )
417 : {
418 4165 : aPgAlignArea = rPageAlignLayFrm.FindPageFrm()->Frm();
419 : }
420 : else
421 : {
422 422 : aPgAlignArea = rPageAlignLayFrm.Frm();
423 : }
424 : }
425 :
426 4587 : if ( bVert )
427 : {
428 : // #i31805# - consider value of <_bCheckBottom>
429 0 : if ( !bVertL2R )
430 : {
431 0 : if ( bCheckBottom &&
432 0 : nTopOfAnch - nAdjustedRelPosY - aObjSize.Width() <
433 0 : aPgAlignArea.Left() )
434 : {
435 0 : nAdjustedRelPosY = aPgAlignArea.Left() +
436 : nTopOfAnch -
437 0 : aObjSize.Width();
438 : }
439 : // #i32964# - correction
440 0 : if ( nTopOfAnch - nAdjustedRelPosY > aPgAlignArea.Right() )
441 : {
442 0 : nAdjustedRelPosY = nTopOfAnch - aPgAlignArea.Right();
443 : }
444 : }
445 : else
446 : {
447 0 : if ( bCheckBottom &&
448 0 : nTopOfAnch + nAdjustedRelPosY + aObjSize.Width() >
449 0 : aPgAlignArea.Right() )
450 : {
451 0 : nAdjustedRelPosY = aPgAlignArea.Right() -
452 : nTopOfAnch -
453 0 : aObjSize.Width();
454 : }
455 0 : if ( nTopOfAnch + nAdjustedRelPosY < aPgAlignArea.Left() )
456 : {
457 0 : nAdjustedRelPosY = aPgAlignArea.Left() - nTopOfAnch;
458 : }
459 : }
460 : }
461 : else
462 : {
463 : // #i31805# - consider value of <bCheckBottom>
464 9094 : if ( bCheckBottom &&
465 4507 : nTopOfAnch + nAdjustedRelPosY + aObjSize.Height() >
466 4507 : aPgAlignArea.Top() + aPgAlignArea.Height() )
467 : {
468 178 : nAdjustedRelPosY = aPgAlignArea.Top() + aPgAlignArea.Height() -
469 : nTopOfAnch -
470 178 : aObjSize.Height();
471 : }
472 4587 : if ( nTopOfAnch + nAdjustedRelPosY < aPgAlignArea.Top() )
473 : {
474 488 : nAdjustedRelPosY = aPgAlignArea.Top() - nTopOfAnch;
475 : }
476 :
477 : // tdf#91260 - allow textboxes extending beyond the page bottom
478 4587 : if ( nAdjustedRelPosY < nProposedRelPosY )
479 : {
480 146 : const SwFrameFormat* pFormat = &(GetFrameFormat());
481 146 : if ( SwTextBoxHelper::isTextBox(&GetObject()) )
482 : {
483 : // shrink textboxes to extend beyond the page bottom
484 27 : SwFrameFormat* pFrameFormat = ::FindFrameFormat(&GetObject());
485 27 : SwFormatFrmSize aSize(pFormat->GetFrmSize());
486 27 : SwTwips nShrinked = aSize.GetHeight() - (nProposedRelPosY - nAdjustedRelPosY);
487 27 : aSize.SetHeight( nShrinked > 0 ? nShrinked : 0 );
488 27 : pFrameFormat->SetFormatAttr(aSize);
489 27 : nAdjustedRelPosY = nProposedRelPosY;
490 119 : } else if ( SwTextBoxHelper::findTextBox(pFormat) )
491 : // when the shape has a textbox, use only the proposed vertical position
492 24 : nAdjustedRelPosY = nProposedRelPosY;
493 : }
494 : }
495 4587 : return nAdjustedRelPosY;
496 : }
497 :
498 : /** adjust calculated horizontal in order to keep object inside
499 : 'page' alignment layout frame.
500 :
501 : #i62875# - method now private and renamed.
502 : */
503 4587 : SwTwips SwAnchoredObjectPosition::_ImplAdjustHoriRelPos(
504 : const SwFrm& _rPageAlignLayFrm,
505 : const SwTwips _nProposedRelPosX ) const
506 : {
507 4587 : SwTwips nAdjustedRelPosX = _nProposedRelPosX;
508 :
509 4587 : const SwFrm& rAnchorFrm = GetAnchorFrm();
510 4587 : const bool bVert = rAnchorFrm.IsVertical();
511 :
512 4587 : const Size aObjSize( GetAnchoredObj().GetObjRect().SSize() );
513 :
514 4587 : if( bVert )
515 : {
516 0 : if ( rAnchorFrm.Frm().Top() + nAdjustedRelPosX + aObjSize.Height() >
517 0 : _rPageAlignLayFrm.Frm().Bottom() )
518 : {
519 0 : nAdjustedRelPosX = _rPageAlignLayFrm.Frm().Bottom() -
520 0 : rAnchorFrm.Frm().Top() -
521 0 : aObjSize.Height();
522 : }
523 0 : if ( rAnchorFrm.Frm().Top() + nAdjustedRelPosX <
524 0 : _rPageAlignLayFrm.Frm().Top() )
525 : {
526 0 : nAdjustedRelPosX = _rPageAlignLayFrm.Frm().Top() -
527 0 : rAnchorFrm.Frm().Top();
528 : }
529 : }
530 : else
531 : {
532 9174 : if ( rAnchorFrm.Frm().Left() + nAdjustedRelPosX + aObjSize.Width() >
533 4587 : _rPageAlignLayFrm.Frm().Right() )
534 : {
535 296 : nAdjustedRelPosX = _rPageAlignLayFrm.Frm().Right() -
536 148 : rAnchorFrm.Frm().Left() -
537 148 : aObjSize.Width();
538 : }
539 9174 : if ( rAnchorFrm.Frm().Left() + nAdjustedRelPosX <
540 4587 : _rPageAlignLayFrm.Frm().Left() )
541 : {
542 54 : nAdjustedRelPosX = _rPageAlignLayFrm.Frm().Left() -
543 54 : rAnchorFrm.Frm().Left();
544 : }
545 : }
546 :
547 4587 : return nAdjustedRelPosX;
548 : }
549 :
550 : /** determine alignment value for horizontal position of object */
551 4696 : void SwAnchoredObjectPosition::_GetHoriAlignmentValues( const SwFrm& _rHoriOrientFrm,
552 : const SwFrm& _rPageAlignLayFrm,
553 : const sal_Int16 _eRelOrient,
554 : const bool _bObjWrapThrough,
555 : SwTwips& _orAlignAreaWidth,
556 : SwTwips& _orAlignAreaOffset,
557 : bool& _obAlignedRelToPage ) const
558 : {
559 4696 : SwTwips nWidth = 0;
560 4696 : SwTwips nOffset = 0;
561 4696 : SWRECTFN( (&_rHoriOrientFrm) )
562 4696 : switch ( _eRelOrient )
563 : {
564 : case text::RelOrientation::PRINT_AREA:
565 : {
566 87 : nWidth = (_rHoriOrientFrm.Prt().*fnRect->fnGetWidth)();
567 87 : nOffset = (_rHoriOrientFrm.*fnRect->fnGetLeftMargin)();
568 87 : if ( _rHoriOrientFrm.IsTextFrm() )
569 : {
570 : // consider movement of text frame left
571 82 : nOffset += static_cast<const SwTextFrm&>(_rHoriOrientFrm).GetBaseOfstForFly( !_bObjWrapThrough );
572 : }
573 5 : else if ( _rHoriOrientFrm.IsPageFrm() && bVert )
574 : {
575 : // for to-page anchored objects, consider header/footer frame
576 : // in vertical layout
577 : const SwFrm* pPrtFrm =
578 0 : static_cast<const SwPageFrm&>(_rHoriOrientFrm).Lower();
579 0 : while( pPrtFrm )
580 : {
581 0 : if( pPrtFrm->IsHeaderFrm() )
582 : {
583 0 : nWidth -= pPrtFrm->Frm().Height();
584 0 : nOffset += pPrtFrm->Frm().Height();
585 : }
586 0 : else if( pPrtFrm->IsFooterFrm() )
587 : {
588 0 : nWidth -= pPrtFrm->Frm().Height();
589 : }
590 0 : pPrtFrm = pPrtFrm->GetNext();
591 : }
592 : }
593 87 : break;
594 : }
595 : case text::RelOrientation::PAGE_LEFT:
596 : {
597 : // align at left border of page frame/fly frame/cell frame
598 4 : nWidth = (_rPageAlignLayFrm.*fnRect->fnGetLeftMargin)();
599 : nOffset = (*fnRect->fnXDiff)(
600 8 : (_rPageAlignLayFrm.Frm().*fnRect->fnGetLeft)(),
601 12 : (_rHoriOrientFrm.Frm().*fnRect->fnGetLeft)() );
602 4 : _obAlignedRelToPage = true;
603 : }
604 4 : break;
605 : case text::RelOrientation::PAGE_RIGHT:
606 : {
607 : // align at right border of page frame/fly frame/cell frame
608 8 : nWidth = (_rPageAlignLayFrm.*fnRect->fnGetRightMargin)();
609 : nOffset = (*fnRect->fnXDiff)(
610 16 : (_rPageAlignLayFrm.*fnRect->fnGetPrtRight)(),
611 24 : (_rHoriOrientFrm.Frm().*fnRect->fnGetLeft)() );
612 8 : _obAlignedRelToPage = true;
613 : }
614 8 : break;
615 : case text::RelOrientation::FRAME_LEFT:
616 : {
617 : // align at left border of anchor frame
618 0 : nWidth = (_rHoriOrientFrm.*fnRect->fnGetLeftMargin)();
619 0 : nOffset = 0;
620 : }
621 0 : break;
622 : case text::RelOrientation::FRAME_RIGHT:
623 : {
624 : // align at right border of anchor frame
625 : // Unify and simplify
626 0 : nWidth = (_rHoriOrientFrm.*fnRect->fnGetRightMargin)();
627 0 : nOffset = (_rHoriOrientFrm.Prt().*fnRect->fnGetRight)();
628 : }
629 0 : break;
630 : case text::RelOrientation::CHAR:
631 : {
632 : // alignment relative to character - assure, that corresponding
633 : // character rectangle is set.
634 9 : if ( IsAnchoredToChar() )
635 : {
636 9 : nWidth = 0;
637 : nOffset = (*fnRect->fnXDiff)(
638 18 : (ToCharRect()->*fnRect->fnGetLeft)(),
639 27 : (ToCharOrientFrm()->Frm().*fnRect->fnGetLeft)() );
640 9 : break;
641 : }
642 : // no break!
643 : }
644 : case text::RelOrientation::PAGE_PRINT_AREA:
645 : {
646 808 : nWidth = (_rPageAlignLayFrm.Prt().*fnRect->fnGetWidth)();
647 : nOffset = (*fnRect->fnXDiff)(
648 1616 : (_rPageAlignLayFrm.*fnRect->fnGetPrtLeft)(),
649 2424 : (_rHoriOrientFrm.Frm().*fnRect->fnGetLeft)() );
650 808 : if ( _rHoriOrientFrm.IsPageFrm() && bVert )
651 : {
652 : // for to-page anchored objects, consider header/footer frame
653 : // in vertical layout
654 : const SwFrm* pPrtFrm =
655 0 : static_cast<const SwPageFrm&>(_rHoriOrientFrm).Lower();
656 0 : while( pPrtFrm )
657 : {
658 0 : if( pPrtFrm->IsHeaderFrm() )
659 : {
660 0 : nWidth -= pPrtFrm->Frm().Height();
661 0 : nOffset += pPrtFrm->Frm().Height();
662 : }
663 0 : else if( pPrtFrm->IsFooterFrm() )
664 : {
665 0 : nWidth -= pPrtFrm->Frm().Height();
666 : }
667 0 : pPrtFrm = pPrtFrm->GetNext();
668 : }
669 : }
670 808 : _obAlignedRelToPage = true;
671 808 : break;
672 : }
673 : case text::RelOrientation::PAGE_FRAME:
674 : {
675 602 : nWidth = (_rPageAlignLayFrm.Frm().*fnRect->fnGetWidth)();
676 : nOffset = (*fnRect->fnXDiff)(
677 1204 : (_rPageAlignLayFrm.Frm().*fnRect->fnGetLeft)(),
678 1806 : (_rHoriOrientFrm.Frm().*fnRect->fnGetLeft)() );
679 602 : _obAlignedRelToPage = true;
680 602 : break;
681 : }
682 : default:
683 : {
684 3178 : nWidth = (_rHoriOrientFrm.Frm().*fnRect->fnGetWidth)();
685 :
686 : // When positioning TextBoxes, always ignore flys anchored at the
687 : // text frame, as we do want to have the textbox overlap with its
688 : // draw shape.
689 3178 : bool bIgnoreFlysAnchoredAtFrame = !_bObjWrapThrough || SwTextBoxHelper::isTextBox(&GetObject());
690 3178 : nOffset = _rHoriOrientFrm.IsTextFrm() ?
691 3127 : static_cast<const SwTextFrm&>(_rHoriOrientFrm).GetBaseOfstForFly( bIgnoreFlysAnchoredAtFrame ) :
692 6305 : 0;
693 3178 : break;
694 : }
695 : }
696 :
697 4696 : _orAlignAreaWidth = nWidth;
698 4696 : _orAlignAreaOffset = nOffset;
699 4696 : }
700 :
701 : /** toggle given horizontal orientation and relative alignment */
702 4696 : void SwAnchoredObjectPosition::_ToggleHoriOrientAndAlign(
703 : const bool _bToggleLeftRight,
704 : sal_Int16& _ioeHoriOrient,
705 : sal_Int16& _iopeRelOrient
706 : )
707 : {
708 4696 : if( _bToggleLeftRight )
709 : {
710 : // toggle orientation
711 0 : switch ( _ioeHoriOrient )
712 : {
713 : case text::HoriOrientation::RIGHT :
714 : {
715 0 : _ioeHoriOrient = text::HoriOrientation::LEFT;
716 : }
717 0 : break;
718 : case text::HoriOrientation::LEFT :
719 : {
720 0 : _ioeHoriOrient = text::HoriOrientation::RIGHT;
721 : }
722 0 : break;
723 : default:
724 0 : break;
725 : }
726 :
727 : // toggle relative alignment
728 0 : switch ( _iopeRelOrient )
729 : {
730 : case text::RelOrientation::PAGE_RIGHT :
731 : {
732 0 : _iopeRelOrient = text::RelOrientation::PAGE_LEFT;
733 : }
734 0 : break;
735 : case text::RelOrientation::PAGE_LEFT :
736 : {
737 0 : _iopeRelOrient = text::RelOrientation::PAGE_RIGHT;
738 : }
739 0 : break;
740 : case text::RelOrientation::FRAME_RIGHT :
741 : {
742 0 : _iopeRelOrient = text::RelOrientation::FRAME_LEFT;
743 : }
744 0 : break;
745 : case text::RelOrientation::FRAME_LEFT :
746 : {
747 0 : _iopeRelOrient = text::RelOrientation::FRAME_RIGHT;
748 : }
749 0 : break;
750 : default:
751 0 : break;
752 : }
753 : }
754 4696 : }
755 :
756 : /** calculate relative horizontal position */
757 4587 : SwTwips SwAnchoredObjectPosition::_CalcRelPosX(
758 : const SwFrm& _rHoriOrientFrm,
759 : const SwEnvironmentOfAnchoredObject& _rEnvOfObj,
760 : const SwFormatHoriOrient& _rHoriOrient,
761 : const SvxLRSpaceItem& _rLRSpacing,
762 : const SvxULSpaceItem& _rULSpacing,
763 : const bool _bObjWrapThrough,
764 : const SwTwips _nRelPosY,
765 : SwTwips& _roHoriOffsetToFrmAnchorPos
766 : ) const
767 : {
768 : // determine 'page' alignment layout frame
769 : const SwFrm& rPageAlignLayFrm =
770 4587 : _rEnvOfObj.GetHoriEnvironmentLayoutFrm( _rHoriOrientFrm );
771 :
772 4587 : const bool bEvenPage = !rPageAlignLayFrm.OnRightPage();
773 4587 : const bool bToggle = _rHoriOrient.IsPosToggle() && bEvenPage;
774 :
775 : // determine orientation and relative alignment
776 4587 : sal_Int16 eHoriOrient = _rHoriOrient.GetHoriOrient();
777 4587 : sal_Int16 eRelOrient = _rHoriOrient.GetRelationOrient();
778 : // toggle orientation and relative alignment
779 4587 : _ToggleHoriOrientAndAlign( bToggle, eHoriOrient, eRelOrient );
780 :
781 : // determine alignment parameter
782 : // <nWidth>: 'width' of alignment area
783 : // <nOffset>: offset of alignment area, relative to 'left' of anchor frame
784 4587 : SwTwips nWidth = 0;
785 4587 : SwTwips nOffset = 0;
786 4587 : bool bAlignedRelToPage = false;
787 : _GetHoriAlignmentValues( _rHoriOrientFrm, rPageAlignLayFrm,
788 : eRelOrient, _bObjWrapThrough,
789 4587 : nWidth, nOffset, bAlignedRelToPage );
790 :
791 4587 : const SwFrm& rAnchorFrm = GetAnchorFrm();
792 4587 : SWRECTFN( (&_rHoriOrientFrm) )
793 4587 : SwTwips nObjWidth = (GetAnchoredObj().GetObjRect().*fnRect->fnGetWidth)();
794 4587 : SwTwips nRelPosX = nOffset;
795 4587 : if ( _rHoriOrient.GetHoriOrient() == text::HoriOrientation::NONE )
796 : {
797 : // 'manual' horizonal position
798 3824 : const bool bR2L = rAnchorFrm.IsRightToLeft();
799 3824 : if( IsAnchoredToChar() && text::RelOrientation::CHAR == eRelOrient )
800 : {
801 9 : if( bR2L )
802 0 : nRelPosX -= _rHoriOrient.GetPos();
803 : else
804 9 : nRelPosX += _rHoriOrient.GetPos();
805 : }
806 3815 : else if ( bToggle || ( !_rHoriOrient.IsPosToggle() && bR2L ) )
807 : {
808 : // Correction: consider <nOffset> also for
809 : // toggling from left to right.
810 0 : nRelPosX += nWidth - nObjWidth - _rHoriOrient.GetPos();
811 : }
812 : else
813 : {
814 3815 : nRelPosX += _rHoriOrient.GetPos();
815 : }
816 : }
817 763 : else if ( text::HoriOrientation::CENTER == eHoriOrient )
818 684 : nRelPosX += (nWidth / 2) - (nObjWidth / 2);
819 79 : else if ( text::HoriOrientation::RIGHT == eHoriOrient )
820 67 : nRelPosX += nWidth -
821 67 : ( nObjWidth +
822 67 : ( bVert ? _rULSpacing.GetLower() : _rLRSpacing.GetRight() ) );
823 : else
824 12 : nRelPosX += bVert ? _rULSpacing.GetUpper() : _rLRSpacing.GetLeft();
825 :
826 : // adjust relative position by distance between anchor frame and
827 : // the frame, the object is oriented at.
828 4587 : if ( &rAnchorFrm != &_rHoriOrientFrm )
829 : {
830 2 : SwTwips nLeftOrient = (_rHoriOrientFrm.Frm().*fnRect->fnGetLeft)();
831 2 : SwTwips nLeftAnchor = (rAnchorFrm.Frm().*fnRect->fnGetLeft)();
832 2 : nRelPosX += (*fnRect->fnXDiff)( nLeftOrient, nLeftAnchor );
833 : }
834 :
835 : // adjust calculated relative horizontal position, in order to
836 : // keep object inside 'page' alignment layout frame
837 : const SwFrm& rEnvironmentLayFrm =
838 4587 : _rEnvOfObj.GetHoriEnvironmentLayoutFrm( _rHoriOrientFrm );
839 4587 : nRelPosX = _AdjustHoriRelPos( rEnvironmentLayFrm, nRelPosX );
840 :
841 : // if object is a Writer fly frame and it's anchored to a content and
842 : // it is horizontal positioned left or right, but not relative to character,
843 : // it has to be drawn aside another object, which have the same horizontal
844 : // position and lay below it.
845 11632 : if ( GetAnchoredObj().ISA(SwFlyFrm) &&
846 5533 : ( GetContact().ObjAnchoredAtPara() || GetContact().ObjAnchoredAtChar() ) &&
847 9552 : ( eHoriOrient == text::HoriOrientation::LEFT || eHoriOrient == text::HoriOrientation::RIGHT ) &&
848 51 : eRelOrient != text::RelOrientation::CHAR )
849 : {
850 : nRelPosX = _AdjustHoriRelPosForDrawAside( _rHoriOrientFrm,
851 : nRelPosX, _nRelPosY,
852 : eHoriOrient, eRelOrient,
853 : _rLRSpacing, _rULSpacing,
854 51 : bEvenPage );
855 : }
856 :
857 : // #i26791#
858 4587 : _roHoriOffsetToFrmAnchorPos = nOffset;
859 :
860 4587 : return nRelPosX;
861 : }
862 :
863 : // method incl. helper methods for adjusting proposed horizontal position,
864 : // if object has to draw aside another object.
865 : /** adjust calculated horizontal position in order to draw object
866 : aside other objects with same positioning
867 : */
868 51 : SwTwips SwAnchoredObjectPosition::_AdjustHoriRelPosForDrawAside(
869 : const SwFrm& _rHoriOrientFrm,
870 : const SwTwips _nProposedRelPosX,
871 : const SwTwips _nRelPosY,
872 : const sal_Int16 _eHoriOrient,
873 : const sal_Int16 _eRelOrient,
874 : const SvxLRSpaceItem& _rLRSpacing,
875 : const SvxULSpaceItem& _rULSpacing,
876 : const bool _bEvenPage
877 : ) const
878 : {
879 : // #i26791#
880 102 : if ( !GetAnchorFrm().ISA(SwTextFrm) ||
881 51 : !GetAnchoredObj().ISA(SwFlyAtCntFrm) )
882 : {
883 : OSL_FAIL( "<SwAnchoredObjectPosition::_AdjustHoriRelPosForDrawAside(..) - usage for wrong anchor type" );
884 0 : return _nProposedRelPosX;
885 : }
886 :
887 51 : const SwTextFrm& rAnchorTextFrm = static_cast<const SwTextFrm&>(GetAnchorFrm());
888 : // #i26791#
889 : const SwFlyAtCntFrm& rFlyAtCntFrm =
890 51 : static_cast<const SwFlyAtCntFrm&>(GetAnchoredObj());
891 51 : const SwRect aObjBoundRect( GetAnchoredObj().GetObjRect() );
892 51 : SWRECTFN( (&_rHoriOrientFrm) )
893 :
894 51 : SwTwips nAdjustedRelPosX = _nProposedRelPosX;
895 :
896 : // determine proposed object bound rectangle
897 51 : Point aTmpPos = (rAnchorTextFrm.Frm().*fnRect->fnGetPos)();
898 51 : if( bVert )
899 : {
900 0 : aTmpPos.X() -= _nRelPosY + aObjBoundRect.Width();
901 0 : aTmpPos.Y() += nAdjustedRelPosX;
902 : }
903 : else
904 : {
905 51 : aTmpPos.X() += nAdjustedRelPosX;
906 51 : aTmpPos.Y() += _nRelPosY;
907 : }
908 51 : SwRect aTmpObjRect( aTmpPos, aObjBoundRect.SSize() );
909 :
910 51 : const sal_uInt32 nObjOrdNum = GetObject().GetOrdNum();
911 51 : const SwPageFrm* pObjPage = rFlyAtCntFrm.FindPageFrm();
912 51 : const SwFrm* pObjContext = ::FindKontext( &rAnchorTextFrm, FRM_COLUMN );
913 51 : sal_uLong nObjIndex = rAnchorTextFrm.GetTextNode()->GetIndex();
914 51 : SwOrderIter aIter( pObjPage, true );
915 51 : const SwFlyFrm* pFly = static_cast<const SwVirtFlyDrawObj*>(aIter.Bottom())->GetFlyFrm();
916 102 : while ( pFly && nObjOrdNum > pFly->GetVirtDrawObj()->GetOrdNumDirect() )
917 : {
918 0 : if ( _DrawAsideFly( pFly, aTmpObjRect, pObjContext, nObjIndex,
919 0 : _bEvenPage, _eHoriOrient, _eRelOrient ) )
920 : {
921 0 : if( bVert )
922 : {
923 0 : const SvxULSpaceItem& rOtherUL = pFly->GetFormat()->GetULSpace();
924 0 : const SwTwips nOtherTop = pFly->Frm().Top() - rOtherUL.GetUpper();
925 0 : const SwTwips nOtherBot = pFly->Frm().Bottom() + rOtherUL.GetLower();
926 0 : if ( nOtherTop <= aTmpObjRect.Bottom() + _rULSpacing.GetLower() &&
927 0 : nOtherBot >= aTmpObjRect.Top() - _rULSpacing.GetUpper() )
928 : {
929 0 : if ( _eHoriOrient == text::HoriOrientation::LEFT )
930 : {
931 0 : SwTwips nTmp = nOtherBot + 1 + _rULSpacing.GetUpper() -
932 0 : rAnchorTextFrm.Frm().Top();
933 0 : if ( nTmp > nAdjustedRelPosX &&
934 0 : rAnchorTextFrm.Frm().Top() + nTmp +
935 0 : aObjBoundRect.Height() + _rULSpacing.GetLower()
936 0 : <= pObjPage->Frm().Height() + pObjPage->Frm().Top() )
937 : {
938 0 : nAdjustedRelPosX = nTmp;
939 : }
940 : }
941 0 : else if ( _eHoriOrient == text::HoriOrientation::RIGHT )
942 : {
943 0 : SwTwips nTmp = nOtherTop - 1 - _rULSpacing.GetLower() -
944 0 : aObjBoundRect.Height() -
945 0 : rAnchorTextFrm.Frm().Top();
946 0 : if ( nTmp < nAdjustedRelPosX &&
947 0 : rAnchorTextFrm.Frm().Top() + nTmp - _rULSpacing.GetUpper()
948 0 : >= pObjPage->Frm().Top() )
949 : {
950 0 : nAdjustedRelPosX = nTmp;
951 : }
952 : }
953 0 : aTmpObjRect.Pos().Y() = rAnchorTextFrm.Frm().Top() +
954 0 : nAdjustedRelPosX;
955 : }
956 : }
957 : else
958 : {
959 0 : const SvxLRSpaceItem& rOtherLR = pFly->GetFormat()->GetLRSpace();
960 0 : const SwTwips nOtherLeft = pFly->Frm().Left() - rOtherLR.GetLeft();
961 0 : const SwTwips nOtherRight = pFly->Frm().Right() + rOtherLR.GetRight();
962 0 : if( nOtherLeft <= aTmpObjRect.Right() + _rLRSpacing.GetRight() &&
963 0 : nOtherRight >= aTmpObjRect.Left() - _rLRSpacing.GetLeft() )
964 : {
965 0 : if ( _eHoriOrient == text::HoriOrientation::LEFT )
966 : {
967 0 : SwTwips nTmp = nOtherRight + 1 + _rLRSpacing.GetLeft() -
968 0 : rAnchorTextFrm.Frm().Left();
969 0 : if ( nTmp > nAdjustedRelPosX &&
970 0 : rAnchorTextFrm.Frm().Left() + nTmp +
971 0 : aObjBoundRect.Width() + _rLRSpacing.GetRight()
972 0 : <= pObjPage->Frm().Width() + pObjPage->Frm().Left() )
973 : {
974 0 : nAdjustedRelPosX = nTmp;
975 : }
976 : }
977 0 : else if ( _eHoriOrient == text::HoriOrientation::RIGHT )
978 : {
979 0 : SwTwips nTmp = nOtherLeft - 1 - _rLRSpacing.GetRight() -
980 0 : aObjBoundRect.Width() -
981 0 : rAnchorTextFrm.Frm().Left();
982 0 : if ( nTmp < nAdjustedRelPosX &&
983 0 : rAnchorTextFrm.Frm().Left() + nTmp - _rLRSpacing.GetLeft()
984 0 : >= pObjPage->Frm().Left() )
985 : {
986 0 : nAdjustedRelPosX = nTmp;
987 : }
988 : }
989 0 : aTmpObjRect.Pos().X() = rAnchorTextFrm.Frm().Left() +
990 0 : nAdjustedRelPosX;
991 : }
992 : } // end of <if (bVert)>
993 : } // end of <if _DrawAsideFly(..)>
994 :
995 0 : pFly = static_cast<const SwVirtFlyDrawObj*>(aIter.Next())->GetFlyFrm();
996 : } // end of <loop on fly frames
997 :
998 51 : return nAdjustedRelPosX;
999 : }
1000 :
1001 : /** detemine, if object has to draw aside given fly frame
1002 :
1003 : method used by <_AdjustHoriRelPosForDrawAside(..)>
1004 : */
1005 0 : bool SwAnchoredObjectPosition::_DrawAsideFly( const SwFlyFrm* _pFly,
1006 : const SwRect& _rObjRect,
1007 : const SwFrm* _pObjContext,
1008 : const sal_uLong _nObjIndex,
1009 : const bool _bEvenPage,
1010 : const sal_Int16 _eHoriOrient,
1011 : const sal_Int16 _eRelOrient
1012 : ) const
1013 : {
1014 0 : bool bRetVal = false;
1015 :
1016 0 : SWRECTFN( (&GetAnchorFrm()) )
1017 :
1018 0 : if ( _pFly->IsFlyAtCntFrm() &&
1019 0 : (_pFly->Frm().*fnRect->fnBottomDist)( (_rObjRect.*fnRect->fnGetTop)() ) < 0 &&
1020 0 : (_rObjRect.*fnRect->fnBottomDist)( (_pFly->Frm().*fnRect->fnGetTop)() ) < 0 &&
1021 0 : ::FindKontext( _pFly->GetAnchorFrm(), FRM_COLUMN ) == _pObjContext )
1022 : {
1023 : sal_uLong nOtherIndex =
1024 0 : static_cast<const SwTextFrm*>(_pFly->GetAnchorFrm())->GetTextNode()->GetIndex();
1025 0 : if( _nObjIndex >= nOtherIndex )
1026 : {
1027 0 : const SwFormatHoriOrient& rHori = _pFly->GetFormat()->GetHoriOrient();
1028 0 : sal_Int16 eOtherRelOrient = rHori.GetRelationOrient();
1029 0 : if( text::RelOrientation::CHAR != eOtherRelOrient )
1030 : {
1031 0 : sal_Int16 eOtherHoriOrient = rHori.GetHoriOrient();
1032 0 : _ToggleHoriOrientAndAlign( _bEvenPage && rHori.IsPosToggle(),
1033 : eOtherHoriOrient,
1034 0 : eOtherRelOrient );
1035 0 : if ( eOtherHoriOrient == _eHoriOrient &&
1036 0 : _Minor( _eRelOrient, eOtherRelOrient, text::HoriOrientation::LEFT == _eHoriOrient ) )
1037 : {
1038 0 : bRetVal = true;
1039 : }
1040 : }
1041 : }
1042 : }
1043 :
1044 0 : return bRetVal;
1045 : }
1046 :
1047 : /** determine, if object has to draw aside another object
1048 :
1049 : the different alignments of the objects determines, if one has
1050 : to draw aside another one. Thus, the given alignment are checked
1051 : against each other, which one has to be drawn aside the other one.
1052 : depending on parameter _bLeft check is done for left or right
1053 : positioning.
1054 : method used by <_DrawAsideFly(..)>
1055 : */
1056 0 : bool SwAnchoredObjectPosition::_Minor( sal_Int16 _eRelOrient1,
1057 : sal_Int16 _eRelOrient2,
1058 : bool _bLeft )
1059 : {
1060 : bool bRetVal;
1061 :
1062 : // draw aside order for left horizontal position
1063 : //! one array entry for each value in text::RelOrientation
1064 : static sal_uInt16 const aLeft[ 10 ] =
1065 : { 5, 6, 0, 1, 8, 4, 7, 2, 3, 9 };
1066 : // draw aside order for right horizontal position
1067 : //! one array entry for each value in text::RelOrientation
1068 : static sal_uInt16 const aRight[ 10 ] =
1069 : { 5, 6, 0, 8, 1, 7, 4, 2, 3, 9 };
1070 :
1071 : // decide depending on given order, which frame has to draw aside another frame
1072 0 : if( _bLeft )
1073 0 : bRetVal = aLeft[ _eRelOrient1 ] >= aLeft[ _eRelOrient2 ];
1074 : else
1075 0 : bRetVal = aRight[ _eRelOrient1 ] >= aRight[ _eRelOrient2 ];
1076 :
1077 0 : return bRetVal;
1078 177 : }
1079 :
1080 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
