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