LCOV - code coverage report
Current view: top level - sw/source/core/objectpositioning - tocntntanchoredobjectposition.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 268 425 63.1 %
Date: 2015-06-13 12:38:46 Functions: 12 13 92.3 %
Legend: Lines: hit not hit

          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 <tocntntanchoredobjectposition.hxx>
      21             : #include <anchoredobject.hxx>
      22             : #include <frame.hxx>
      23             : #include <txtfrm.hxx>
      24             : #include <pagefrm.hxx>
      25             : #include <sectfrm.hxx>
      26             : #include <tabfrm.hxx>
      27             : #include "rootfrm.hxx"
      28             : #include "viewopt.hxx"
      29             : #include "viewsh.hxx"
      30             : #include <frmfmt.hxx>
      31             : #include <IDocumentSettingAccess.hxx>
      32             : #include <fmtsrnd.hxx>
      33             : #include <fmtfsize.hxx>
      34             : #include <fmtanchr.hxx>
      35             : #include <fmtornt.hxx>
      36             : #include <editeng/lrspitem.hxx>
      37             : #include <editeng/ulspitem.hxx>
      38             : #include <svx/svdobj.hxx>
      39             : #include <pam.hxx>
      40             : #include <environmentofanchoredobject.hxx>
      41             : #include <frmtool.hxx>
      42             : #include <ndtxt.hxx>
      43             : #include <dflyobj.hxx>
      44             : 
      45             : using namespace objectpositioning;
      46             : using namespace ::com::sun::star;
      47             : 
      48        4587 : SwToContentAnchoredObjectPosition::SwToContentAnchoredObjectPosition( SdrObject& _rDrawObj )
      49             :     : SwAnchoredObjectPosition ( _rDrawObj ),
      50             :       mpVertPosOrientFrm( 0 ),
      51             :       // #i26791#
      52             :       maOffsetToFrmAnchorPos( Point() ),
      53             :       mbAnchorToChar ( false ),
      54             :       mpToCharOrientFrm( 0 ),
      55             :       mpToCharRect( 0 ),
      56             :       // #i22341#
      57        4587 :       mnToCharTopOfLine( 0 )
      58        4587 : {}
      59             : 
      60        4587 : SwToContentAnchoredObjectPosition::~SwToContentAnchoredObjectPosition()
      61        4587 : {}
      62             : 
      63        3842 : bool SwToContentAnchoredObjectPosition::IsAnchoredToChar() const
      64             : {
      65        3842 :     return mbAnchorToChar;
      66             : }
      67             : 
      68           9 : const SwFrm* SwToContentAnchoredObjectPosition::ToCharOrientFrm() const
      69             : {
      70           9 :     return mpToCharOrientFrm;
      71             : }
      72             : 
      73           9 : const SwRect* SwToContentAnchoredObjectPosition::ToCharRect() const
      74             : {
      75           9 :     return mpToCharRect;
      76             : }
      77             : 
      78             : // #i22341#
      79           9 : SwTwips SwToContentAnchoredObjectPosition::ToCharTopOfLine() const
      80             : {
      81           9 :     return mnToCharTopOfLine;
      82             : }
      83             : 
      84        4730 : SwTextFrm& SwToContentAnchoredObjectPosition::GetAnchorTextFrm() const
      85             : {
      86             :     OSL_ENSURE( GetAnchorFrm().ISA(SwTextFrm),
      87             :             "SwToContentAnchoredObjectPosition::GetAnchorTextFrm() - wrong anchor frame type" );
      88             : 
      89        4730 :     return static_cast<SwTextFrm&>(GetAnchorFrm());
      90             : }
      91             : 
      92             : // #i23512#
      93        2818 : static bool lcl_DoesVertPosFits( const SwTwips _nRelPosY,
      94             :                           const SwTwips _nAvail,
      95             :                           const SwLayoutFrm* _pUpperOfOrientFrm,
      96             :                           const bool _bBrowse,
      97             :                           const bool _bGrowInTable,
      98             :                           SwLayoutFrm*& _orpLayoutFrmToGrow )
      99             : {
     100        2818 :     bool bVertPosFits = false;
     101             : 
     102        2818 :     if ( _nRelPosY <= _nAvail )
     103             :     {
     104        2472 :         bVertPosFits = true;
     105             :     }
     106         346 :     else if ( _bBrowse )
     107             :     {
     108           0 :         if ( _pUpperOfOrientFrm->IsInSct() )
     109             :         {
     110             :             SwSectionFrm* pSctFrm =
     111           0 :                     const_cast<SwSectionFrm*>(_pUpperOfOrientFrm->FindSctFrm());
     112           0 :             bVertPosFits = pSctFrm->GetUpper()->Grow( _nRelPosY - _nAvail, true ) > 0;
     113             :             // Note: do not provide a layout frame for a grow.
     114             :         }
     115             :         else
     116             :         {
     117             :             bVertPosFits = const_cast<SwLayoutFrm*>(_pUpperOfOrientFrm)->
     118           0 :                                         Grow( _nRelPosY - _nAvail, true ) > 0;
     119           0 :             if ( bVertPosFits )
     120           0 :                 _orpLayoutFrmToGrow = const_cast<SwLayoutFrm*>(_pUpperOfOrientFrm);
     121             :         }
     122             :     }
     123         346 :     else if ( _pUpperOfOrientFrm->IsInTab() && _bGrowInTable )
     124             :     {
     125             :         // #i45085# - check, if upper frame would grow the
     126             :         // excepted amount of twips.
     127             :         const SwTwips nTwipsGrown = const_cast<SwLayoutFrm*>(_pUpperOfOrientFrm)->
     128           0 :                                         Grow( _nRelPosY - _nAvail, true );
     129           0 :         bVertPosFits = ( nTwipsGrown == ( _nRelPosY - _nAvail ) );
     130           0 :         if ( bVertPosFits )
     131           0 :             _orpLayoutFrmToGrow = const_cast<SwLayoutFrm*>(_pUpperOfOrientFrm);
     132             :     }
     133             : 
     134        2818 :     return bVertPosFits;
     135             : }
     136             : 
     137        4587 : void SwToContentAnchoredObjectPosition::CalcPosition()
     138             : {
     139             :     // get format of object
     140        4587 :     const SwFrameFormat& rFrameFormat = GetFrameFormat();
     141             : 
     142             :     // declare and set <pFooter> to footer frame, if object is anchored
     143             :     // at a frame belonging to the footer.
     144        4587 :     const SwFrm* pFooter = GetAnchorFrm().FindFooterOrHeader();
     145        4587 :     if ( pFooter && !pFooter->IsFooterFrm() )
     146        1497 :         pFooter = NULL;
     147             : 
     148             :     // declare and set <bBrowse> to true, if document is in browser mode and
     149             :     // object is anchored at the body, but not at frame belonging to a table.
     150        4587 :     bool bBrowse = GetAnchorFrm().IsInDocBody() && !GetAnchorFrm().IsInTab();
     151        4587 :     if( bBrowse )
     152             :     {
     153        2161 :         const SwViewShell *pSh = GetAnchorFrm().getRootFrm()->GetCurrShell();
     154        2161 :         if( !pSh || !pSh->GetViewOptions()->getBrowseMode() )
     155        2161 :             bBrowse = false;
     156             :     }
     157             : 
     158             :     // determine left/right and its upper/lower spacing.
     159        4587 :     const SvxLRSpaceItem &rLR = rFrameFormat.GetLRSpace();
     160        4587 :     const SvxULSpaceItem &rUL = rFrameFormat.GetULSpace();
     161             : 
     162             :     // determine, if object has no surrounding.
     163        4587 :     const SwFormatSurround& rSurround = rFrameFormat.GetSurround();
     164        4587 :     const bool bNoSurround = rSurround.GetSurround() == SURROUND_NONE;
     165        4587 :     const bool bWrapThrough = rSurround.GetSurround() == SURROUND_THROUGHT;
     166             : 
     167             :     // new class <SwEnvironmentOfAnchoredObject>
     168        4587 :     SwEnvironmentOfAnchoredObject aEnvOfObj( DoesObjFollowsTextFlow() );
     169             : 
     170             :     // #i18732# - grow only, if object has to follow the text flow
     171        4765 :     const bool bGrow = DoesObjFollowsTextFlow() &&
     172          92 :                        ( !GetAnchorFrm().IsInTab() ||
     173        4590 :                          !rFrameFormat.GetFrmSize().GetHeightPercent() );
     174             : 
     175             :     // get text frame the object is anchored at
     176        4587 :     const SwTextFrm& rAnchorTextFrm = GetAnchorTextFrm();
     177        4587 :     SWRECTFN( (&rAnchorTextFrm) )
     178             : 
     179        4587 :     const SwRect aObjBoundRect( GetAnchoredObj().GetObjRect() );
     180             : 
     181             :     // local variable keeping the calculated relative position; initialized with
     182             :     // current relative position.
     183             :     // #i26791# - use new object instance of <SwAnchoredObject>
     184        4587 :     Point aRelPos( GetAnchoredObj().GetCurrRelPos() );
     185             : 
     186        4587 :     SwTwips nRelDiff = 0;
     187             : 
     188        4587 :     bool bMoveable = rAnchorTextFrm.IsMoveable();
     189             : 
     190             :     // determine frame the object position has to be oriented at.
     191        4587 :     const SwTextFrm* pOrientFrm = &rAnchorTextFrm;
     192        4587 :     const SwTextFrm* pAnchorFrmForVertPos = &rAnchorTextFrm;
     193             :     {
     194             :         // if object is at-character anchored, determine character-rectangle
     195             :         // and frame, position has to be oriented at.
     196        4587 :         mbAnchorToChar = (FLY_AT_CHAR == rFrameFormat.GetAnchor().GetAnchorId());
     197        4587 :         if ( mbAnchorToChar )
     198             :         {
     199        1060 :             const SwFormatAnchor& rAnch = rFrameFormat.GetAnchor();
     200             :             // #i26791# - use new object instance of <SwAnchoredObject>
     201             :             // Due to table break algorithm the character
     202             :             // rectangle can have no height. Thus, check also the width
     203        2143 :             if ( ( !GetAnchoredObj().GetLastCharRect().Height() &&
     204        2097 :                    !GetAnchoredObj().GetLastCharRect().Width() ) ||
     205        1037 :                  !GetAnchoredObj().GetLastTopOfLine() )
     206             :             {
     207          23 :                 GetAnchoredObj().CheckCharRectAndTopOfLine( false );
     208             :                 // Due to table break algorithm the character
     209             :                 // rectangle can have no height. Thus, check also the width
     210          46 :                 if ( ( !GetAnchoredObj().GetLastCharRect().Height() &&
     211          46 :                        !GetAnchoredObj().GetLastCharRect().Width() ) ||
     212          23 :                      !GetAnchoredObj().GetLastTopOfLine() )
     213             :                 {
     214             :                     // Get default for <mpVertPosOrientFrm>, if it's not set.
     215           0 :                     if ( !mpVertPosOrientFrm )
     216             :                     {
     217           0 :                         mpVertPosOrientFrm = rAnchorTextFrm.GetUpper();
     218             :                     }
     219        4587 :                     return;
     220             :                 }
     221             :             }
     222        1060 :             mpToCharRect = &(GetAnchoredObj().GetLastCharRect());
     223             :             // #i22341# - get top of line, in which the anchor character is.
     224        1060 :             mnToCharTopOfLine = GetAnchoredObj().GetLastTopOfLine();
     225             :             pOrientFrm = &(const_cast<SwTextFrm&>(rAnchorTextFrm).GetFrmAtOfst(
     226        1060 :                                 rAnch.GetContentAnchor()->nContent.GetIndex() ) );
     227        1060 :             mpToCharOrientFrm = pOrientFrm;
     228             :         }
     229             :     }
     230        4587 :     SWREFRESHFN( pOrientFrm )
     231             : 
     232             :     // determine vertical position
     233             :     {
     234             : 
     235             :         // determine vertical positioning and alignment attributes
     236        4587 :         SwFormatVertOrient aVert( rFrameFormat.GetVertOrient() );
     237             : 
     238             :         // #i18732# - determine layout frame for vertical
     239             :         // positions aligned to 'page areas'.
     240             :         const SwLayoutFrm& rPageAlignLayFrm =
     241        4587 :                 aEnvOfObj.GetVertEnvironmentLayoutFrm( *pOrientFrm );
     242             : 
     243        4587 :         if ( aVert.GetVertOrient() != text::VertOrientation::NONE )
     244             :         {
     245             :             // #i18732# - adjustments for follow text flow or not
     246             :             // AND vertical alignment at 'page areas'.
     247             :             SwTwips nAlignAreaHeight;
     248             :             SwTwips nAlignAreaOffset;
     249             :             _GetVertAlignmentValues( *pOrientFrm, rPageAlignLayFrm,
     250         614 :                                      aVert.GetRelationOrient(),
     251         614 :                                      nAlignAreaHeight, nAlignAreaOffset );
     252             : 
     253             :             // determine relative vertical position
     254         614 :             SwTwips nRelPosY = nAlignAreaOffset;
     255         614 :             const SwTwips nObjHeight = (aObjBoundRect.*fnRect->fnGetHeight)();
     256             :             const SwTwips nUpperSpace = bVert
     257             :                                         ? ( bVertL2R
     258             :                                             ? rLR.GetLeft()
     259             :                                             : rLR.GetRight() )
     260         614 :                                         : rUL.GetUpper();
     261             :             // --> OD 2009-08-31 #monglianlayout#
     262             :             const SwTwips nLowerSpace = bVert
     263             :                                         ? ( bVertL2R
     264             :                                             ? rLR.GetLeft()
     265             :                                             : rLR.GetRight() )
     266         614 :                                         : rUL.GetLower();
     267         614 :             switch ( aVert.GetVertOrient() )
     268             :             {
     269             :                 case text::VertOrientation::CHAR_BOTTOM:
     270             :                 {
     271           0 :                     if ( mbAnchorToChar )
     272             :                     {
     273             :                         // bottom (to character anchored)
     274           0 :                         nRelPosY += nAlignAreaHeight + nUpperSpace;
     275           0 :                         if ( bVert && !bVertL2R )
     276             :                         {
     277           0 :                             nRelPosY += nObjHeight;
     278             :                         }
     279           0 :                         break;
     280             :                     }
     281             :                 }
     282             :                 // no break here
     283             :                 case text::VertOrientation::TOP:
     284             :                 {
     285             :                     // #i22341# - special case for vertical
     286             :                     // alignment at top of line
     287         326 :                     if ( mbAnchorToChar &&
     288         111 :                          aVert.GetRelationOrient() == text::RelOrientation::TEXT_LINE )
     289             :                     {
     290           0 :                         nRelPosY -= (nObjHeight + nLowerSpace);
     291             :                     }
     292             :                     else
     293             :                     {
     294         215 :                         nRelPosY += nUpperSpace;
     295             :                     }
     296             :                 }
     297         215 :                 break;
     298             :                 // #i22341#
     299             :                 case text::VertOrientation::LINE_TOP:
     300             :                 {
     301           0 :                     if ( mbAnchorToChar &&
     302           0 :                          aVert.GetRelationOrient() == text::RelOrientation::TEXT_LINE )
     303             :                     {
     304           0 :                         nRelPosY -= (nObjHeight + nLowerSpace);
     305             :                     }
     306             :                     else
     307             :                     {
     308             :                         OSL_FAIL( "<SwToContentAnchoredObjectPosition::CalcPosition()> - unknown combination of vertical position and vertical alignment." );
     309             :                     }
     310             :                 }
     311           0 :                 break;
     312             :                 case text::VertOrientation::CENTER:
     313             :                 {
     314         376 :                     nRelPosY += (nAlignAreaHeight / 2) - (nObjHeight / 2);
     315             :                 }
     316         376 :                 break;
     317             :                 // #i22341#
     318             :                 case text::VertOrientation::LINE_CENTER:
     319             :                 {
     320           0 :                     if ( mbAnchorToChar &&
     321           0 :                          aVert.GetRelationOrient() == text::RelOrientation::TEXT_LINE )
     322             :                     {
     323           0 :                         nRelPosY += (nAlignAreaHeight / 2) - (nObjHeight / 2);
     324             :                     }
     325             :                     else
     326             :                     {
     327             :                         OSL_FAIL( "<SwToContentAnchoredObjectPosition::CalcPosition()> - unknown combination of vertical position and vertical alignment." );
     328             :                     }
     329             :                 }
     330           0 :                 break;
     331             :                 case text::VertOrientation::BOTTOM:
     332             :                 {
     333          69 :                     if ( ( aVert.GetRelationOrient() == text::RelOrientation::FRAME ||
     334          23 :                            aVert.GetRelationOrient() == text::RelOrientation::PRINT_AREA ) &&
     335             :                          bNoSurround )
     336             :                     {
     337             :                         // bottom (aligned to 'paragraph areas')
     338           0 :                         nRelPosY += nAlignAreaHeight + nUpperSpace;
     339             :                     }
     340             :                     else
     341             :                     {
     342             :                         // #i22341# - special case for vertical
     343             :                         // alignment at top of line
     344          32 :                         if ( mbAnchorToChar &&
     345           9 :                              aVert.GetRelationOrient() == text::RelOrientation::TEXT_LINE )
     346             :                         {
     347           0 :                             nRelPosY += nUpperSpace;
     348             :                         }
     349             :                         else
     350             :                         {
     351          46 :                             nRelPosY += nAlignAreaHeight -
     352          46 :                                         ( nObjHeight + nLowerSpace );
     353             :                         }
     354             :                     }
     355             :                 }
     356          23 :                 break;
     357             :                 // #i22341#
     358             :                 case text::VertOrientation::LINE_BOTTOM:
     359             :                 {
     360           0 :                     if ( mbAnchorToChar &&
     361           0 :                          aVert.GetRelationOrient() == text::RelOrientation::TEXT_LINE )
     362             :                     {
     363           0 :                         nRelPosY += nUpperSpace;
     364             :                     }
     365             :                     else
     366             :                     {
     367             :                         OSL_FAIL( "<SwToContentAnchoredObjectPosition::CalcPosition()> - unknown combination of vertical position and vertical alignment." );
     368             :                     }
     369             :                 }
     370           0 :                 break;
     371             :                 default:
     372           0 :                 break;
     373             :             }
     374             : 
     375             :             // adjust relative position by distance between anchor frame and
     376             :             // the frame, the object is oriented at.
     377             :             // #i28701# - correction: adjust relative position,
     378             :             // only if the floating screen object has to follow the text flow.
     379         614 :             if ( DoesObjFollowsTextFlow() && pOrientFrm != &rAnchorTextFrm )
     380             :             {
     381             :                 // #i11860# - use new method <_GetTopForObjPos>
     382             :                 // to get top of frame for object positioning.
     383           0 :                 const SwTwips nTopOfOrient = _GetTopForObjPos( *pOrientFrm, fnRect, bVert );
     384             :                 nRelPosY += (*fnRect->fnYDiff)( nTopOfOrient,
     385           0 :                                       _GetTopForObjPos( rAnchorTextFrm, fnRect, bVert ) );
     386             :             }
     387             : 
     388             :             // #i42124# - capture object inside vertical
     389             :             // layout environment.
     390             :             {
     391             :                 const SwTwips nTopOfAnch =
     392         614 :                                 _GetTopForObjPos( *pOrientFrm, fnRect, bVert );
     393             :                 const SwLayoutFrm& rVertEnvironLayFrm =
     394             :                     aEnvOfObj.GetVertEnvironmentLayoutFrm(
     395         614 :                                             *(pOrientFrm->GetUpper()) );
     396         614 :                 const bool bCheckBottom = !DoesObjFollowsTextFlow();
     397             :                 nRelPosY = _AdjustVertRelPos( nTopOfAnch, bVert, bVertL2R,
     398             :                                               rVertEnvironLayFrm, nRelPosY,
     399         614 :                                               DoesObjFollowsTextFlow(),
     400        1228 :                                               bCheckBottom );
     401             :             }
     402             : 
     403             :             // keep calculated relative vertical position - needed for filters
     404             :             // (including the xml-filter)
     405             :             {
     406             :                 // determine position
     407         614 :                 SwTwips nAttrRelPosY = nRelPosY - nAlignAreaOffset;
     408             :                 // set
     409         614 :                 if ( nAttrRelPosY != aVert.GetPos() )
     410             :                 {
     411         113 :                     aVert.SetPos( nAttrRelPosY );
     412         113 :                     const_cast<SwFrameFormat&>(rFrameFormat).LockModify();
     413         113 :                     const_cast<SwFrameFormat&>(rFrameFormat).SetFormatAttr( aVert );
     414         113 :                     const_cast<SwFrameFormat&>(rFrameFormat).UnlockModify();
     415             :                 }
     416             :             }
     417             : 
     418             :             // determine absolute 'vertical' position, depending on layout-direction
     419             :             // #i26791# - determine offset to 'vertical' frame
     420             :             // anchor position, depending on layout-direction
     421         614 :             if ( bVert )
     422             :             {
     423           0 :                 aRelPos.X() = nRelPosY;
     424           0 :                 maOffsetToFrmAnchorPos.X() = nAlignAreaOffset;
     425             :             }
     426             :             else
     427             :             {
     428         614 :                 aRelPos.Y() = nRelPosY;
     429         614 :                 maOffsetToFrmAnchorPos.Y() = nAlignAreaOffset;
     430             :             }
     431             :         }
     432             : 
     433             :         // Determine upper of frame vertical position is oriented at.
     434             :         // #i28701# - determine 'virtual' anchor frame.
     435             :         // This frame is used in the following instead of the 'real' anchor
     436             :         // frame <rAnchorTextFrm> for the 'vertical' position in all cases.
     437        4587 :         const SwLayoutFrm* pUpperOfOrientFrm = 0L;
     438             :         {
     439             :             // #i28701# - As long as the anchor frame is on the
     440             :             // same page as <pOrientFrm> and the vertical position isn't aligned
     441             :             // automatic at the anchor character or the top of the line of the
     442             :             // anchor character, the anchor frame determines the vertical position.
     443        9174 :             if ( &rAnchorTextFrm == pOrientFrm ||
     444           0 :                  ( rAnchorTextFrm.FindPageFrm() == pOrientFrm->FindPageFrm() &&
     445           0 :                    aVert.GetVertOrient() == text::VertOrientation::NONE &&
     446           0 :                    aVert.GetRelationOrient() != text::RelOrientation::CHAR &&
     447           0 :                    aVert.GetRelationOrient() != text::RelOrientation::TEXT_LINE ) )
     448             :             {
     449        4587 :                 pUpperOfOrientFrm = rAnchorTextFrm.GetUpper();
     450        4587 :                 pAnchorFrmForVertPos = &rAnchorTextFrm;
     451             :             }
     452             :             else
     453             :             {
     454           0 :                 pUpperOfOrientFrm = pOrientFrm->GetUpper();
     455           0 :                 pAnchorFrmForVertPos = pOrientFrm;
     456             :             }
     457             :         }
     458             : 
     459             :         // ignore one-column sections.
     460             :         // #i23512# - correction: also ignore one-columned
     461             :         // sections with footnotes/endnotes
     462        4587 :         if ( pUpperOfOrientFrm->IsInSct() )
     463             :         {
     464         155 :             const SwSectionFrm* pSctFrm = pUpperOfOrientFrm->FindSctFrm();
     465         310 :             const bool bIgnoreSection = pUpperOfOrientFrm->IsSctFrm() ||
     466          18 :                                         ( pSctFrm->Lower()->IsColumnFrm() &&
     467         164 :                                           !pSctFrm->Lower()->GetNext() );
     468         155 :             if ( bIgnoreSection )
     469         146 :                 pUpperOfOrientFrm = pSctFrm->GetUpper();
     470             :         }
     471             : 
     472        4587 :         if ( aVert.GetVertOrient() == text::VertOrientation::NONE )
     473             :         {
     474             :             // local variable <nRelPosY> for calculation of relative vertical
     475             :             // distance to anchor.
     476        3973 :             SwTwips nRelPosY = 0;
     477             :             // #i26791# - local variable <nVertOffsetToFrmAnchorPos>
     478             :             // for determination of the 'vertical' offset to the frame anchor
     479             :             // position
     480        3973 :             SwTwips nVertOffsetToFrmAnchorPos( 0L );
     481             :             // #i22341# - add special case for vertical alignment
     482             :             // at top of line.
     483        4583 :             if ( mbAnchorToChar &&
     484        1202 :                  ( aVert.GetRelationOrient() == text::RelOrientation::CHAR ||
     485         601 :                    aVert.GetRelationOrient() == text::RelOrientation::TEXT_LINE ) )
     486             :             {
     487             :                 // #i11860# - use new method <_GetTopForObjPos>
     488             :                 // to get top of frame for object positioning.
     489           9 :                 SwTwips nTopOfOrient = _GetTopForObjPos( *pOrientFrm, fnRect, bVert );
     490           9 :                 if ( aVert.GetRelationOrient() == text::RelOrientation::CHAR )
     491             :                 {
     492             :                     nVertOffsetToFrmAnchorPos = (*fnRect->fnYDiff)(
     493           0 :                                         (ToCharRect()->*fnRect->fnGetBottom)(),
     494           0 :                                         nTopOfOrient );
     495             :                 }
     496             :                 else
     497             :                 {
     498           9 :                     nVertOffsetToFrmAnchorPos = (*fnRect->fnYDiff)( ToCharTopOfLine(),
     499          18 :                                                                     nTopOfOrient );
     500             :                 }
     501           9 :                 nRelPosY = nVertOffsetToFrmAnchorPos - aVert.GetPos();
     502             :             }
     503             :             else
     504             :             {
     505             :                 // #i28701# - correction: use <pAnchorFrmForVertPos>
     506             :                 // instead of <pOrientFrm> and do not adjust relative position
     507             :                 // to get correct vertical position.
     508        3964 :                 nVertOffsetToFrmAnchorPos = 0L;
     509             :                 // #i11860# - use new method <_GetTopForObjPos>
     510             :                 // to get top of frame for object positioning.
     511             :                 const SwTwips nTopOfOrient =
     512        3964 :                         _GetTopForObjPos( *pAnchorFrmForVertPos, fnRect, bVert );
     513             :                 // Increase <nRelPosY> by margin height,
     514             :                 // if position is vertical aligned to "paragraph text area"
     515        3964 :                 if ( aVert.GetRelationOrient() == text::RelOrientation::PRINT_AREA )
     516             :                 {
     517             :                     // #i11860# - consider upper space amount of previous frame
     518           5 :                     SwTwips nTopMargin = (pAnchorFrmForVertPos->*fnRect->fnGetTopMargin)();
     519           5 :                     if ( pAnchorFrmForVertPos->IsTextFrm() )
     520             :                     {
     521             :                         nTopMargin -= static_cast<const SwTextFrm*>(pAnchorFrmForVertPos)->
     522           5 :                             GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid();
     523             :                     }
     524           5 :                     nVertOffsetToFrmAnchorPos += nTopMargin;
     525             :                 }
     526             :                 // #i18732# - adjust <nRelPosY> by difference
     527             :                 // between 'page area' and 'anchor' frame, if position is
     528             :                 // vertical aligned to 'page areas'
     529        3959 :                 else if ( aVert.GetRelationOrient() == text::RelOrientation::PAGE_FRAME )
     530             :                 {
     531             :                     nVertOffsetToFrmAnchorPos += (*fnRect->fnYDiff)(
     532        2619 :                                     (rPageAlignLayFrm.Frm().*fnRect->fnGetTop)(),
     533        3492 :                                     nTopOfOrient );
     534             :                 }
     535        3086 :                 else if ( aVert.GetRelationOrient() == text::RelOrientation::PAGE_PRINT_AREA )
     536             :                 {
     537         170 :                     SwRect aPgPrtRect( rPageAlignLayFrm.Frm() );
     538         170 :                     if ( rPageAlignLayFrm.IsPageFrm() )
     539             :                     {
     540         322 :                         aPgPrtRect =
     541         161 :                             static_cast<const SwPageFrm&>(rPageAlignLayFrm).PrtWithoutHeaderAndFooter();
     542             :                     }
     543             :                     nVertOffsetToFrmAnchorPos += (*fnRect->fnYDiff)(
     544         170 :                                                 (aPgPrtRect.*fnRect->fnGetTop)(),
     545         340 :                                                 nTopOfOrient );
     546             :                 }
     547        3964 :                 nRelPosY = nVertOffsetToFrmAnchorPos + aVert.GetPos();
     548             :             }
     549             : 
     550             :             // <pUpperOfOrientFrm>: layout frame, at which the position has to
     551             :             //                      is oriented at
     552             :             // <nRelPosY>:          rest of the relative distance in the current
     553             :             //                      layout frame
     554             :             // <nAvail>:            space, which is available in the current
     555             :             //                      layout frame
     556             : 
     557             :             // #i26791# - determine offset to 'vertical'
     558             :             // frame anchor position, depending on layout-direction
     559        3973 :             if ( bVert )
     560           0 :                 maOffsetToFrmAnchorPos.X() = nVertOffsetToFrmAnchorPos;
     561             :             else
     562        3973 :                 maOffsetToFrmAnchorPos.Y() = nVertOffsetToFrmAnchorPos;
     563             :             // #i11860# - use new method <_GetTopForObjPos>
     564             :             // to get top of frame for object positioning.
     565        3973 :             const SwTwips nTopOfAnch = _GetTopForObjPos( *pAnchorFrmForVertPos, fnRect, bVert );
     566        3973 :             if( nRelPosY <= 0 )
     567             :             {
     568             :                 // Allow negative position, but keep it
     569             :                 // inside environment layout frame.
     570             :                 const SwLayoutFrm& rVertEnvironLayFrm =
     571        1155 :                     aEnvOfObj.GetVertEnvironmentLayoutFrm( *pUpperOfOrientFrm );
     572             :                 // #i31805# - do not check, if bottom of
     573             :                 // anchored object would fit into environment layout frame, if
     574             :                 // anchored object has to follow the text flow.
     575        1155 :                 const bool bCheckBottom = !DoesObjFollowsTextFlow();
     576             :                 nRelPosY = _AdjustVertRelPos( nTopOfAnch, bVert, bVertL2R,
     577             :                                               rVertEnvironLayFrm, nRelPosY,
     578        1155 :                                               DoesObjFollowsTextFlow(),
     579        2310 :                                               bCheckBottom );
     580        1155 :                 if ( bVert )
     581           0 :                     aRelPos.X() = nRelPosY;
     582             :                 else
     583        1155 :                     aRelPos.Y() = nRelPosY;
     584             :             }
     585             :             else
     586             :             {
     587        2818 :                 SWREFRESHFN( pAnchorFrmForVertPos )
     588             :                 SwTwips nAvail =
     589        8454 :                     (*fnRect->fnYDiff)( (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)(),
     590       11272 :                                         nTopOfAnch );
     591        2818 :                 const bool bInFootnote = pAnchorFrmForVertPos->IsInFootnote();
     592        8454 :                 while ( nRelPosY )
     593             :                 {
     594             :                     // #i23512# - correction:
     595             :                     // consider section frame for grow in online layout.
     596             :                     // use new local method <lcl_DoesVertPosFits(..)>
     597        2818 :                     SwLayoutFrm* pLayoutFrmToGrow = 0L;
     598             :                     const bool bDoesVertPosFits = lcl_DoesVertPosFits(
     599             :                             nRelPosY, nAvail, pUpperOfOrientFrm, bBrowse,
     600        2818 :                             bGrow, pLayoutFrmToGrow );
     601             : 
     602        2818 :                     if ( bDoesVertPosFits )
     603             :                     {
     604             :                         SwTwips nTmpRelPosY =
     605        7416 :                             (*fnRect->fnYDiff)( (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)(),
     606        9888 :                                                 nTopOfAnch ) -
     607        2472 :                             nAvail + nRelPosY;
     608             :                         // #i28701# - adjust calculated
     609             :                         // relative vertical position to object's environment.
     610             :                         const SwFrm& rVertEnvironLayFrm =
     611        2472 :                             aEnvOfObj.GetVertEnvironmentLayoutFrm( *pUpperOfOrientFrm );
     612             :                         // Do not check, if bottom of
     613             :                         // anchored object would fit into environment layout
     614             :                         // frame, if anchored object has to follow the text flow.
     615        2472 :                         const bool bCheckBottom = !DoesObjFollowsTextFlow();
     616             :                         nTmpRelPosY = _AdjustVertRelPos( nTopOfAnch, bVert, bVertL2R,
     617             :                                                          rVertEnvironLayFrm,
     618             :                                                          nTmpRelPosY,
     619        2472 :                                                          DoesObjFollowsTextFlow(),
     620        4944 :                                                          bCheckBottom );
     621        2472 :                         if ( bVert )
     622           0 :                             aRelPos.X() = nTmpRelPosY;
     623             :                         else
     624        2472 :                             aRelPos.Y() = nTmpRelPosY;
     625             : 
     626             :                         // #i23512# - use local variable
     627             :                         // <pLayoutFrmToGrow> provided by new method
     628             :                         // <lcl_DoesVertPosFits(..)>.
     629        2472 :                         if ( pLayoutFrmToGrow )
     630             :                         {
     631           0 :                             pLayoutFrmToGrow->Grow( nRelPosY - nAvail );
     632             :                         }
     633        2472 :                         nRelPosY = 0;
     634             :                     }
     635             :                     else
     636             :                     {
     637             :                         // #i26495# - floating screen objects,
     638             :                         // which are anchored inside a table, doesn't follow
     639             :                         // the text flow.
     640         701 :                         if ( DoesObjFollowsTextFlow() &&
     641           9 :                              !( aVert.GetRelationOrient() == text::RelOrientation::PAGE_FRAME ||
     642         355 :                                 aVert.GetRelationOrient() == text::RelOrientation::PAGE_PRINT_AREA ) &&
     643           0 :                              !GetAnchorFrm().IsInTab() )
     644             :                         {
     645           0 :                             if ( bMoveable )
     646             :                             {
     647             :                                 // follow the text flow
     648           0 :                                 nRelPosY -= nAvail;
     649             :                                 MakePageType eMakePage = bInFootnote ? MAKEPAGE_NONE
     650           0 :                                                                 : MAKEPAGE_APPEND;
     651           0 :                                 const bool bInSct = pUpperOfOrientFrm->IsInSct();
     652           0 :                                 if( bInSct )
     653           0 :                                     eMakePage = MAKEPAGE_NOSECTION;
     654             : 
     655             :                                 const SwLayoutFrm* pTmp =
     656           0 :                                     pUpperOfOrientFrm->GetLeaf( eMakePage, true, &rAnchorTextFrm );
     657           0 :                                 if ( pTmp &&
     658           0 :                                      ( !bInSct ||
     659           0 :                                        pUpperOfOrientFrm->FindSctFrm()->IsAnFollow( pTmp->FindSctFrm() ) ) )
     660             :                                 {
     661           0 :                                     pUpperOfOrientFrm = pTmp;
     662           0 :                                     bMoveable = rAnchorTextFrm.IsMoveable( pUpperOfOrientFrm );
     663           0 :                                     SWREFRESHFN( pUpperOfOrientFrm )
     664           0 :                                     nAvail = (pUpperOfOrientFrm->Prt().*fnRect->fnGetHeight)();
     665             :                                 }
     666             :                                 else
     667             :                                 {
     668             :                                     // if there isn't enough space in the (colmuned)
     669             :                                     // section, leave it and set available space <nAvail>
     670             :                                     // to the space below the section.
     671             :                                     // if the new available space isn't also enough,
     672             :                                     // new pages can be created.
     673           0 :                                     if( bInSct )
     674             :                                     {
     675           0 :                                         const SwFrm* pSct = pUpperOfOrientFrm->FindSctFrm();
     676           0 :                                         pUpperOfOrientFrm = pSct->GetUpper();
     677             :                                         nAvail = (*fnRect->fnYDiff)(
     678           0 :                                                    (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)(),
     679           0 :                                                    (pSct->*fnRect->fnGetPrtBottom)() );
     680             :                                     }
     681             :                                     else
     682             :                                     {
     683             : #if OSL_DEBUG_LEVEL > 1
     684             :                                         OSL_FAIL( "<SwToContentAnchoredObjectPosition::CalcPosition()> - code under investigation by OD, please inform OD about this assertion!" );
     685             : #endif
     686           0 :                                         nRelDiff = nRelPosY;
     687           0 :                                         nRelPosY = 0;
     688             :                                     }
     689             :                                 }
     690             :                             }
     691             :                             else
     692             :                             {
     693           0 :                                 nRelPosY = 0;
     694             :                             }
     695             :                         }
     696             :                         else
     697             :                         {
     698             :                             // #i18732# - do not follow text flow respectively
     699             :                             // align at 'page areas', but stay inside given environment
     700             :                             const SwFrm& rVertEnvironLayFrm =
     701         346 :                                 aEnvOfObj.GetVertEnvironmentLayoutFrm( *pUpperOfOrientFrm );
     702             :                             nRelPosY = _AdjustVertRelPos( nTopOfAnch, bVert, bVertL2R,
     703             :                                                           rVertEnvironLayFrm,
     704             :                                                           nRelPosY,
     705         346 :                                                           DoesObjFollowsTextFlow() );
     706         346 :                             if( bVert )
     707           0 :                                 aRelPos.X() = nRelPosY;
     708             :                             else
     709         346 :                                 aRelPos.Y() = nRelPosY;
     710         346 :                             nRelPosY = 0;
     711             :                         }
     712             :                     }
     713             :                 } // end of <while ( nRelPosY )>
     714             :             } // end of else <nRelPosY <= 0>
     715             :         } // end of <aVert.GetVertOrient() == text::VertOrientation::NONE>
     716             : 
     717             :         // We need to calculate the part's absolute position, in order for
     718             :         // it to be put onto the right page and to be pulled into the
     719             :         // LayLeaf's PrtArea
     720        4587 :         const SwTwips nTopOfAnch = _GetTopForObjPos( *pAnchorFrmForVertPos, fnRect, bVert );
     721        4587 :         if( bVert )
     722             :         {
     723             :             // --> OD 2009-08-31 #monglianlayout#
     724           0 :             if ( !bVertL2R )
     725             :             {
     726           0 :                 GetAnchoredObj().SetObjLeft( nTopOfAnch -
     727           0 :                                              ( aRelPos.X() - nRelDiff ) -
     728           0 :                                              aObjBoundRect.Width() );
     729             :             }
     730             :             else
     731             :             {
     732           0 :                 GetAnchoredObj().SetObjLeft( nTopOfAnch +
     733           0 :                                              ( aRelPos.X() - nRelDiff ) );
     734             :             }
     735             :         }
     736             :         else
     737             :         {
     738        4587 :             GetAnchoredObj().SetObjTop( nTopOfAnch +
     739        9174 :                                         ( aRelPos.Y() - nRelDiff ) );
     740             :         }
     741             : 
     742             :         // grow environment under certain conditions
     743             :         // ignore one-column sections.
     744             :         // #i23512# - correction: also ignore one-columned
     745             :         // sections with footnotes/endnotes
     746        4587 :         if ( pUpperOfOrientFrm->IsInSct() )
     747             :         {
     748           9 :             const SwSectionFrm* pSctFrm = pUpperOfOrientFrm->FindSctFrm();
     749          18 :             const bool bIgnoreSection = pUpperOfOrientFrm->IsSctFrm() ||
     750          18 :                                         ( pSctFrm->Lower()->IsColumnFrm() &&
     751          18 :                                           !pSctFrm->Lower()->GetNext() );
     752           9 :             if ( bIgnoreSection )
     753           0 :                 pUpperOfOrientFrm = pSctFrm->GetUpper();
     754             :         }
     755        4587 :         SwTwips nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     756        9174 :                           (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)() );
     757        4587 :         if( nDist < 0 )
     758             :         {
     759             :             // #i23512# - correction:
     760             :             // consider section frame for grow in online layout and
     761             :             // consider page alignment for grow in table.
     762        1958 :             SwLayoutFrm* pLayoutFrmToGrow = 0L;
     763        1958 :             if ( bBrowse && rAnchorTextFrm.IsMoveable() )
     764             :             {
     765           0 :                 if ( pUpperOfOrientFrm->IsInSct() )
     766             :                 {
     767             :                     pLayoutFrmToGrow = const_cast<SwLayoutFrm*>(
     768           0 :                                     pUpperOfOrientFrm->FindSctFrm()->GetUpper());
     769           0 :                     nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     770           0 :                               (pLayoutFrmToGrow->*fnRect->fnGetPrtBottom)() );
     771           0 :                     if ( nDist >= 0 )
     772             :                     {
     773           0 :                         pLayoutFrmToGrow = 0L;
     774             :                     }
     775             :                 }
     776             :                 else
     777             :                 {
     778             :                     pLayoutFrmToGrow =
     779           0 :                                     const_cast<SwLayoutFrm*>(pUpperOfOrientFrm);
     780             :                 }
     781             :             }
     782        1958 :             else if ( rAnchorTextFrm.IsInTab() && bGrow )
     783             :             {
     784           1 :                 pLayoutFrmToGrow = const_cast<SwLayoutFrm*>(pUpperOfOrientFrm);
     785             :             }
     786        1958 :             if ( pLayoutFrmToGrow )
     787             :             {
     788           1 :                 pLayoutFrmToGrow->Grow( -nDist );
     789             :             }
     790             :         }
     791             : 
     792        4753 :         if ( DoesObjFollowsTextFlow() &&
     793          89 :              !( aVert.GetRelationOrient() == text::RelOrientation::PAGE_FRAME ||
     794          89 :                 aVert.GetRelationOrient() == text::RelOrientation::PAGE_PRINT_AREA ) )
     795             :         {
     796             : 
     797          77 :             nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     798         154 :                       (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)() );
     799             :             // #i26945# - floating screen objects, which are
     800             :             // anchored inside a table, doesn't follow the text flow. But, they
     801             :             // have to stay inside its layout environment.
     802          77 :             if ( nDist < 0 && pOrientFrm->IsInTab() )
     803             :             {
     804             :                 // If the anchor frame is the first content of the table cell
     805             :                 // and has no follow, the table frame is notified,
     806             :                 // that the object doesn't fit into the table cell.
     807             :                 // Adjustment of position isn't needed in this case.
     808           0 :                 if ( pOrientFrm == &rAnchorTextFrm &&
     809           0 :                      !pOrientFrm->GetFollow() &&
     810           0 :                      !pOrientFrm->GetIndPrev() )
     811             :                 {
     812           0 :                     const_cast<SwTabFrm*>(pOrientFrm->FindTabFrm())
     813           0 :                                                     ->SetDoesObjsFit( false );
     814             :                 }
     815             :                 else
     816             :                 {
     817           0 :                     SwTwips nTmpRelPosY( 0L );
     818           0 :                     if ( bVert )
     819           0 :                         nTmpRelPosY = aRelPos.X() - nDist;
     820             :                     else
     821           0 :                         nTmpRelPosY = aRelPos.Y() + nDist;
     822             :                     const SwLayoutFrm& rVertEnvironLayFrm =
     823           0 :                         aEnvOfObj.GetVertEnvironmentLayoutFrm( *pUpperOfOrientFrm );
     824             :                     nTmpRelPosY = _AdjustVertRelPos( nTopOfAnch, bVert, bVertL2R,
     825             :                                                      rVertEnvironLayFrm,
     826             :                                                      nTmpRelPosY,
     827           0 :                                                      DoesObjFollowsTextFlow(),
     828           0 :                                                      false );
     829           0 :                     if ( bVert )
     830             :                     {
     831           0 :                         aRelPos.X() = nTmpRelPosY;
     832             :                         // --> OD 2009-08-31 #mongolianlayout#
     833           0 :                         if ( !bVertL2R )
     834             :                         {
     835           0 :                             GetAnchoredObj().SetObjLeft( nTopOfAnch -
     836           0 :                                                          aRelPos.X() -
     837           0 :                                                          aObjBoundRect.Width() );
     838             :                         }
     839             :                         else
     840             :                         {
     841           0 :                             GetAnchoredObj().SetObjLeft( nTopOfAnch + aRelPos.X() );
     842             :                         }
     843             :                     }
     844             :                     else
     845             :                     {
     846           0 :                         aRelPos.Y() = nTmpRelPosY;
     847           0 :                         GetAnchoredObj().SetObjTop( nTopOfAnch + aRelPos.Y() );
     848             :                     }
     849             :                     // If the anchor frame is the first content of the table cell
     850             :                     // and the object still doesn't fit, the table frame is notified,
     851             :                     // that the object doesn't fit into the table cell.
     852           0 :                     nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     853           0 :                               (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)() );
     854           0 :                     if ( nDist < 0 &&
     855           0 :                          pOrientFrm == &rAnchorTextFrm && !pOrientFrm->GetIndPrev() )
     856             :                     {
     857           0 :                         const_cast<SwTabFrm*>(pOrientFrm->FindTabFrm())
     858           0 :                                                         ->SetDoesObjsFit( false );
     859             :                     }
     860             :                 }
     861             :             }
     862             :             else
     863             :             {
     864             :                 // follow text flow
     865          77 :                 const bool bInFootnote = rAnchorTextFrm.IsInFootnote();
     866         156 :                 while( bMoveable && nDist < 0 )
     867             :                 {
     868           2 :                     bool bInSct = pUpperOfOrientFrm->IsInSct();
     869           2 :                     if ( bInSct )
     870             :                     {
     871           0 :                         const SwLayoutFrm* pTmp = pUpperOfOrientFrm->FindSctFrm()->GetUpper();
     872           0 :                         nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     873           0 :                                   (pTmp->*fnRect->fnGetPrtBottom)() );
     874             :                         // #i23129# - Try to flow into next
     875             :                         // section|section column. Thus, do *not* leave section
     876             :                         // area, if anchored object doesn't fit into upper of section.
     877             :                         // But the anchored object is allowed to overlap bottom
     878             :                         // section|section column.
     879           0 :                         if ( nDist >= 0 )
     880             :                         {
     881           0 :                             break;
     882             :                         }
     883             :                     }
     884           8 :                     if ( !bInSct &&
     885           8 :                          (GetAnchoredObj().GetObjRect().*fnRect->fnGetTop)() ==
     886           2 :                                  (pUpperOfOrientFrm->*fnRect->fnGetPrtTop)() )
     887             :                         // It doesn't fit, moving it would not help either anymore
     888           0 :                         break;
     889             : 
     890             :                     const SwLayoutFrm* pNextLay = pUpperOfOrientFrm->GetLeaf(
     891             :                                     ( bInSct
     892             :                                       ? MAKEPAGE_NOSECTION
     893             :                                       : ( bInFootnote ? MAKEPAGE_NONE : MAKEPAGE_APPEND ) ),
     894           2 :                                     true, &rAnchorTextFrm );
     895             :                     // correction:
     896             :                     // If anchor is in footnote and proposed next layout environment
     897             :                     // isn't a footnote frame, object can't follow the text flow
     898           2 :                     if ( bInFootnote && pNextLay && !pNextLay->IsFootnoteFrm() )
     899             :                     {
     900           0 :                         pNextLay = 0L;
     901             :                     }
     902           2 :                     if ( pNextLay )
     903             :                     {
     904           2 :                         SWRECTFNX( pNextLay )
     905           4 :                         if ( !bInSct ||
     906           0 :                              ( pUpperOfOrientFrm->FindSctFrm()->IsAnFollow( pNextLay->FindSctFrm() ) &&
     907           0 :                                (pNextLay->Prt().*fnRectX->fnGetHeight)() ) )
     908             :                         {
     909             :                             SwTwips nTmpRelPosY =
     910           6 :                                 (*fnRect->fnYDiff)( (pNextLay->*fnRect->fnGetPrtTop)(),
     911           8 :                                                     nTopOfAnch );
     912           2 :                             if ( bVert )
     913           0 :                                 aRelPos.X() = nTmpRelPosY;
     914             :                             else
     915           2 :                                 aRelPos.Y() = nTmpRelPosY;
     916           2 :                             pUpperOfOrientFrm = pNextLay;
     917           2 :                             SWREFRESHFN( pUpperOfOrientFrm )
     918           2 :                             bMoveable = rAnchorTextFrm.IsMoveable( pUpperOfOrientFrm );
     919           2 :                             if( bVertX )
     920             :                             {
     921             :                                 // --> OD 2009-08-31 #mongolianlayout#
     922           0 :                                 if ( !bVertL2R )
     923             :                                 {
     924           0 :                                     GetAnchoredObj().SetObjLeft( nTopOfAnch -
     925           0 :                                                                  aRelPos.X() -
     926           0 :                                                                  aObjBoundRect.Width() );
     927             :                                 }
     928             :                                 else
     929             :                                 {
     930           0 :                                     GetAnchoredObj().SetObjLeft( nTopOfAnch +
     931           0 :                                                                  aRelPos.X() );
     932             :                                 }
     933             :                             }
     934             :                             else
     935           2 :                                 GetAnchoredObj().SetObjTop( nTopOfAnch +
     936           4 :                                                             aRelPos.Y() );
     937           2 :                             nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     938           4 :                                       (pUpperOfOrientFrm->*fnRect->fnGetPrtBottom)() );
     939             :                         }
     940             :                         // #i23129# - leave section area
     941           0 :                         else if ( bInSct )
     942             :                         {
     943           0 :                             const SwLayoutFrm* pTmp = pUpperOfOrientFrm->FindSctFrm()->GetUpper();
     944           0 :                             nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     945           0 :                                       (pTmp->*fnRect->fnGetPrtBottom)() );
     946           0 :                             if( nDist < 0 )
     947           0 :                                 pUpperOfOrientFrm = pTmp;
     948             :                             else
     949           0 :                                 break;
     950             :                         }
     951             :                     }
     952           0 :                     else if ( bInSct )
     953             :                     {
     954             :                         // If we don't have enough room within the Area, we take a look at
     955             :                         // the Page
     956           0 :                         const SwLayoutFrm* pTmp = pUpperOfOrientFrm->FindSctFrm()->GetUpper();
     957           0 :                         nDist = (GetAnchoredObj().GetObjRect().*fnRect->fnBottomDist)(
     958           0 :                                   (pTmp->*fnRect->fnGetPrtBottom)() );
     959           0 :                         if( nDist < 0 )
     960           0 :                             pUpperOfOrientFrm = pTmp;
     961             :                         else
     962           0 :                             break;
     963             :                     }
     964             :                     else
     965           0 :                         bMoveable = false;
     966             :                 }
     967             :             }
     968             :         }
     969             : 
     970             :         // keep layout frame vertical position is oriented at.
     971        4587 :         mpVertPosOrientFrm = pUpperOfOrientFrm;
     972             : 
     973             :     }
     974             : 
     975             :     // determine 'horizontal' position
     976             :     {
     977             :         // determine horizontal positioning and alignment attributes
     978        4587 :         SwFormatHoriOrient aHori( rFrameFormat.GetHoriOrient() );
     979             : 
     980             :         // set calculated vertical position in order to determine correct
     981             :         // frame, the horizontal position is oriented at.
     982        4587 :         const SwTwips nTopOfAnch = _GetTopForObjPos( *pAnchorFrmForVertPos, fnRect, bVert );
     983        4587 :         if( bVert )
     984             :         {
     985             :             // --> OD 2009-08-31 #mongolianlayout#
     986           0 :             if ( !bVertL2R )
     987             :             {
     988           0 :                 GetAnchoredObj().SetObjLeft( nTopOfAnch -
     989           0 :                                              aRelPos.X() - aObjBoundRect.Width() );
     990             :             }
     991             :             else
     992             :             {
     993           0 :                 GetAnchoredObj().SetObjLeft( nTopOfAnch + aRelPos.X() );
     994             :             }
     995             :         }
     996             :         else
     997        4587 :             GetAnchoredObj().SetObjTop( nTopOfAnch + aRelPos.Y() );
     998             : 
     999             :         // determine frame, horizontal position is oriented at.
    1000             :         // #i28701# - If floating screen object doesn't follow
    1001             :         // the text flow, its horizontal position is oriented at <pOrientFrm>.
    1002        4587 :         const SwFrm* pHoriOrientFrm = DoesObjFollowsTextFlow()
    1003          89 :                                       ? &_GetHoriVirtualAnchor( *mpVertPosOrientFrm )
    1004        4676 :                                       : pOrientFrm;
    1005             : 
    1006             :         // #i26791# - get 'horizontal' offset to frame anchor position.
    1007        4587 :         SwTwips nHoriOffsetToFrmAnchorPos( 0L );
    1008             :         SwTwips nRelPosX = _CalcRelPosX( *pHoriOrientFrm, aEnvOfObj,
    1009             :                                          aHori, rLR, rUL, bWrapThrough,
    1010        4587 :                                          ( bVert ? aRelPos.X() : aRelPos.Y() ),
    1011        9174 :                                          nHoriOffsetToFrmAnchorPos );
    1012             : 
    1013             :         // #i26791# - determine offset to 'horizontal' frame
    1014             :         // anchor position, depending on layout-direction
    1015        4587 :         if ( bVert )
    1016             :         {
    1017           0 :             aRelPos.Y() = nRelPosX;
    1018           0 :             maOffsetToFrmAnchorPos.Y() = nHoriOffsetToFrmAnchorPos;
    1019             :         }
    1020             :         else
    1021             :         {
    1022        4587 :             aRelPos.X() = nRelPosX;
    1023        4587 :             maOffsetToFrmAnchorPos.X() = nHoriOffsetToFrmAnchorPos;
    1024             :         }
    1025             : 
    1026             :         // save calculated horizontal position - needed for filters
    1027             :         // (including the xml-filter)
    1028             :         {
    1029        4587 :             SwTwips nAttrRelPosX = nRelPosX - nHoriOffsetToFrmAnchorPos;
    1030        5350 :             if ( aHori.GetHoriOrient() != text::HoriOrientation::NONE &&
    1031         763 :                  aHori.GetPos() != nAttrRelPosX )
    1032             :             {
    1033         218 :                 aHori.SetPos( nAttrRelPosX );
    1034         218 :                 const_cast<SwFrameFormat&>(rFrameFormat).LockModify();
    1035         218 :                 const_cast<SwFrameFormat&>(rFrameFormat).SetFormatAttr( aHori );
    1036         218 :                 const_cast<SwFrameFormat&>(rFrameFormat).UnlockModify();
    1037             :             }
    1038        4587 :         }
    1039             :     }
    1040             : 
    1041             :     // set absolute position at object
    1042        4587 :     const SwTwips nTopOfAnch = _GetTopForObjPos( *pAnchorFrmForVertPos, fnRect, bVert );
    1043        4587 :     if( bVert )
    1044             :     {
    1045             :         // --> OD 2009-08-31 #mongolianlayout#
    1046           0 :         if ( !bVertL2R )
    1047             :         {
    1048           0 :             GetAnchoredObj().SetObjLeft( nTopOfAnch -
    1049           0 :                                          aRelPos.X() - aObjBoundRect.Width() );
    1050             :         }
    1051             :         else
    1052             :         {
    1053           0 :             GetAnchoredObj().SetObjLeft( nTopOfAnch + aRelPos.X() );
    1054             :         }
    1055           0 :         GetAnchoredObj().SetObjTop( rAnchorTextFrm.Frm().Top() +
    1056           0 :                                     aRelPos.Y() );
    1057             :     }
    1058             :     else
    1059             :     {
    1060        9174 :         GetAnchoredObj().SetObjLeft( rAnchorTextFrm.Frm().Left() +
    1061        9174 :                                      aRelPos.X() );
    1062        4587 :         GetAnchoredObj().SetObjTop( nTopOfAnch + aRelPos.Y() );
    1063             :     }
    1064             : 
    1065             :     // set relative position at object
    1066        4587 :     GetAnchoredObj().SetCurrRelPos( aRelPos );
    1067             : }
    1068             : 
    1069             : /**
    1070             :  * Determine frame for horizontal position
    1071             :  */
    1072          89 : const SwFrm& SwToContentAnchoredObjectPosition::_GetHoriVirtualAnchor(
    1073             :                                         const SwLayoutFrm& _rProposedFrm ) const
    1074             : {
    1075          89 :     const SwFrm* pHoriVirtAnchFrm = &_rProposedFrm;
    1076             : 
    1077             :     // Search for first lower content frame, which is the anchor or a follow
    1078             :     // of the anchor (Note: <Anchor.IsAnFollow( Anchor )> is true)
    1079             :     // If none found, <_rProposedFrm> is returned.
    1080          89 :     const SwFrm* pFrm = _rProposedFrm.Lower();
    1081         234 :     while ( pFrm )
    1082             :     {
    1083         286 :         if ( pFrm->IsContentFrm() &&
    1084         143 :              GetAnchorTextFrm().IsAnFollow( static_cast<const SwContentFrm*>(pFrm) ) )
    1085             :         {
    1086          87 :             pHoriVirtAnchFrm = pFrm;
    1087          87 :             break;
    1088             :         }
    1089          56 :         pFrm = pFrm->GetNext();
    1090             :     }
    1091             : 
    1092          89 :     return *pHoriVirtAnchFrm;
    1093         177 : }
    1094             : 
    1095             : 
    1096             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11