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