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

Generated by: LCOV version 1.11