| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| #include <tools/bigint.hxx> |
| #include "pagefrm.hxx" |
| #include "cntfrm.hxx" |
| #include "flyfrm.hxx" |
| #include "txtfrm.hxx" |
| #include <doc.hxx> |
| #include <IDocumentUndoRedo.hxx> |
| #include "viewsh.hxx" |
| #include "viewimp.hxx" |
| #include "pam.hxx" |
| #include "frmfmt.hxx" |
| #include "frmtool.hxx" |
| #include "dflyobj.hxx" |
| #include "hints.hxx" |
| #include "ndtxt.hxx" |
| #include "swundo.hxx" |
| #include "errhdl.hxx" |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <fmtanchr.hxx> |
| #include <fmtornt.hxx> |
| #include <fmtfsize.hxx> |
| #include <fmtsrnd.hxx> |
| #include <txatbase.hxx> |
| |
| #include "tabfrm.hxx" |
| #include "flyfrms.hxx" |
| #include "crstate.hxx" |
| #include "sectfrm.hxx" |
| |
| #include <tocntntanchoredobjectposition.hxx> |
| #include <dcontact.hxx> |
| #include <sortedobjs.hxx> |
| #include <layouter.hxx> |
| #include <objectformattertxtfrm.hxx> |
| #include <HandleAnchorNodeChg.hxx> |
| |
| using namespace ::com::sun::star; |
| |
| |
| /************************************************************************* |
| |* |
| |* SwFlyAtCntFrm::SwFlyAtCntFrm() |
| |* |
| |* Ersterstellung MA 11. Nov. 92 |
| |* Letzte Aenderung MA 09. Apr. 99 |
| |* |
| |*************************************************************************/ |
| |
| SwFlyAtCntFrm::SwFlyAtCntFrm( SwFlyFrmFmt *pFmt, SwFrm* pSib, SwFrm *pAnch ) : |
| SwFlyFreeFrm( pFmt, pSib, pAnch ) |
| { |
| bAtCnt = sal_True; |
| bAutoPosition = (FLY_AT_CHAR == pFmt->GetAnchor().GetAnchorId()); |
| } |
| |
| // --> OD 2004-06-29 #i28701# |
| TYPEINIT1(SwFlyAtCntFrm,SwFlyFreeFrm); |
| // <-- |
| /************************************************************************* |
| |* |
| |* SwFlyAtCntFrm::Modify() |
| |* |
| |* Ersterstellung MA 08. Feb. 93 |
| |* Letzte Aenderung MA 23. Nov. 94 |
| |* |
| |*************************************************************************/ |
| |
| void SwFlyAtCntFrm::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew ) |
| { |
| sal_uInt16 nWhich = pNew ? pNew->Which() : 0; |
| const SwFmtAnchor *pAnch = 0; |
| |
| if( RES_ATTRSET_CHG == nWhich && SFX_ITEM_SET == |
| ((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState( RES_ANCHOR, sal_False, |
| (const SfxPoolItem**)&pAnch )) |
| ; // Beim GetItemState wird der AnkerPointer gesetzt ! |
| |
| else if( RES_ANCHOR == nWhich ) |
| { |
| //Ankerwechsel, ich haenge mich selbst um. |
| //Es darf sich nicht um einen Wechsel des Ankertyps handeln, |
| //dies ist nur ueber die SwFEShell moeglich. |
| pAnch = (const SwFmtAnchor*)pNew; |
| } |
| |
| if( pAnch ) |
| { |
| ASSERT( pAnch->GetAnchorId() == GetFmt()->GetAnchor().GetAnchorId(), |
| "Unzulaessiger Wechsel des Ankertyps." ); |
| |
| //Abmelden, neuen Anker besorgen und 'dranhaengen. |
| SwRect aOld( GetObjRectWithSpaces() ); |
| SwPageFrm *pOldPage = FindPageFrm(); |
| const SwFrm *pOldAnchor = GetAnchorFrm(); |
| SwCntntFrm *pCntnt = (SwCntntFrm*)GetAnchorFrm(); |
| AnchorFrm()->RemoveFly( this ); |
| |
| const sal_Bool bBodyFtn = (pCntnt->IsInDocBody() || pCntnt->IsInFtn()); |
| |
| //Den neuen Anker anhand des NodeIdx suchen, am alten und |
| //neuen NodeIdx kann auch erkannt werden, in welche Richtung |
| //gesucht werden muss. |
| const SwNodeIndex aNewIdx( pAnch->GetCntntAnchor()->nNode ); |
| SwNodeIndex aOldIdx( *pCntnt->GetNode() ); |
| |
| //fix: Umstellung, ehemals wurde in der do-while-Schleife nach vorn bzw. |
| //nach hinten gesucht; je nachdem wie welcher Index kleiner war. |
| //Das kann aber u.U. zu einer Endlosschleife fuehren. Damit |
| //wenigstens die Schleife unterbunden wird suchen wir nur in eine |
| //Richtung. Wenn der neue Anker nicht gefunden wird koennen wir uns |
| //immer noch vom Node einen Frame besorgen. Die Change, dass dies dann |
| //der richtige ist, ist gut. |
| const bool bNext = aOldIdx < aNewIdx; |
| // --> OD 2006-02-28 #125892# |
| // consider the case that at found anchor frame candidate already a |
| // fly frame of the given fly format is registered. |
| // --> OD 2006-03-15 #133407# - consider, that <pCntnt> is the already |
| // the new anchor frame. |
| bool bFound( aOldIdx == aNewIdx ); |
| // <-- |
| while ( pCntnt && !bFound ) |
| { |
| do |
| { |
| if ( bNext ) |
| pCntnt = pCntnt->GetNextCntntFrm(); |
| else |
| pCntnt = pCntnt->GetPrevCntntFrm(); |
| } while ( pCntnt && |
| !( bBodyFtn == ( pCntnt->IsInDocBody() || |
| pCntnt->IsInFtn() ) ) ); |
| if ( pCntnt ) |
| aOldIdx = *pCntnt->GetNode(); |
| |
| // --> OD 2006-02-28 #125892# |
| // check, if at found anchor frame candidate already a fly frame |
| // of the given fly frame format is registered. |
| bFound = aOldIdx == aNewIdx; |
| if ( bFound && pCntnt->GetDrawObjs() ) |
| { |
| SwFrmFmt* pMyFlyFrmFmt( &GetFrmFmt() ); |
| SwSortedObjs &rObjs = *pCntnt->GetDrawObjs(); |
| for( sal_uInt16 i = 0; i < rObjs.Count(); ++i) |
| { |
| SwFlyFrm* pFlyFrm = dynamic_cast<SwFlyFrm*>(rObjs[i]); |
| if ( pFlyFrm && |
| &(pFlyFrm->GetFrmFmt()) == pMyFlyFrmFmt ) |
| { |
| bFound = false; |
| break; |
| } |
| } |
| } |
| // <-- |
| } |
| // <-- |
| if ( !pCntnt ) |
| { |
| SwCntntNode *pNode = aNewIdx.GetNode().GetCntntNode(); |
| pCntnt = pNode->getLayoutFrm( getRootFrm(), &pOldAnchor->Frm().Pos(), 0, sal_False ); |
| ASSERT( pCntnt, "Neuen Anker nicht gefunden" ); |
| } |
| //Flys haengen niemals an einem Follow sondern immer am |
| //Master, den suchen wir uns jetzt. |
| SwCntntFrm* pFlow = pCntnt; |
| while ( pFlow->IsFollow() ) |
| pFlow = pFlow->FindMaster(); |
| pCntnt = pFlow; |
| |
| //und schwupp angehaengt das teil... |
| pCntnt->AppendFly( this ); |
| if ( pOldPage && pOldPage != FindPageFrm() ) |
| NotifyBackground( pOldPage, aOld, PREP_FLY_LEAVE ); |
| |
| //Fix(3495) |
| _InvalidatePos(); |
| InvalidatePage(); |
| SetNotifyBack(); |
| // --> OD 2004-06-24 #i28701# - reset member <maLastCharRect> and |
| // <mnLastTopOfLine> for to-character anchored objects. |
| ClearCharRectAndTopOfLine(); |
| } |
| else |
| SwFlyFrm::Modify( pOld, pNew ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwFlyAtCntFrm::MakeAll() |
| |* |
| |* Beschreibung Bei einem Absatzgebunden Fly kann es durchaus sein, |
| |* das der Anker auf die Veraenderung des Flys reagiert. Auf diese |
| |* Reaktion hat der Fly natuerlich auch wieder zu reagieren. |
| |* Leider kann dies zu Oszillationen fuehren z.b. Der Fly will nach |
| |* unten, dadurch kann der Inhalt nach oben, der TxtFrm wird kleiner, |
| |* der Fly muss wieder hoeher woduch der Text wieder nach unten |
| |* verdraengt wird... |
| |* Um derartige Oszillationen zu vermeiden, wird ein kleiner Positions- |
| |* stack aufgebaut. Wenn der Fly ein Position erreicht, die er bereits |
| |* einmal einnahm, so brechen wir den Vorgang ab. Um keine Risiken |
| |* einzugehen, wird der Positionsstack so aufgebaut, dass er fuenf |
| |* Positionen zurueckblickt. |
| |* Wenn der Stack ueberlaeuft, wird ebenfalls abgebrochen. |
| |* Der Abbruch fuer dazu, dass der Fly am Ende eine unguenste Position |
| |* einnimmt. Damit es nicht durch einen wiederholten Aufruf von |
| |* Aussen zu einer 'grossen Oszillation' kommen kann wird im Abbruch- |
| |* fall das Attribut des Rahmens auf automatische Ausrichtung oben |
| |* eingestellt. |
| |* |
| |* Ersterstellung MA 12. Nov. 92 |
| |* Letzte Aenderung MA 20. Sep. 96 |
| |* |
| |*************************************************************************/ |
| //Wir brauchen ein Paar Hilfsklassen zur Kontrolle der Ozillation und ein paar |
| //Funktionen um die Uebersicht zu gewaehrleisten. |
| // OD 2004-08-25 #i3317# - re-factoring of the position stack |
| class SwOszControl |
| { |
| static const SwFlyFrm *pStk1; |
| static const SwFlyFrm *pStk2; |
| static const SwFlyFrm *pStk3; |
| static const SwFlyFrm *pStk4; |
| static const SwFlyFrm *pStk5; |
| |
| const SwFlyFrm *pFly; |
| // --> OD 2004-08-25 #i3317# |
| sal_uInt8 mnPosStackSize; |
| std::vector<Point*> maObjPositions; |
| // <-- |
| |
| public: |
| SwOszControl( const SwFlyFrm *pFrm ); |
| ~SwOszControl(); |
| bool ChkOsz(); |
| static sal_Bool IsInProgress( const SwFlyFrm *pFly ); |
| }; |
| const SwFlyFrm *SwOszControl::pStk1 = 0; |
| const SwFlyFrm *SwOszControl::pStk2 = 0; |
| const SwFlyFrm *SwOszControl::pStk3 = 0; |
| const SwFlyFrm *SwOszControl::pStk4 = 0; |
| const SwFlyFrm *SwOszControl::pStk5 = 0; |
| |
| SwOszControl::SwOszControl( const SwFlyFrm *pFrm ) |
| : pFly( pFrm ), |
| // --> OD 2004-08-25 #i3317# |
| mnPosStackSize( 20 ) |
| // <-- |
| { |
| if ( !SwOszControl::pStk1 ) |
| SwOszControl::pStk1 = pFly; |
| else if ( !SwOszControl::pStk2 ) |
| SwOszControl::pStk2 = pFly; |
| else if ( !SwOszControl::pStk3 ) |
| SwOszControl::pStk3 = pFly; |
| else if ( !SwOszControl::pStk4 ) |
| SwOszControl::pStk4 = pFly; |
| else if ( !SwOszControl::pStk5 ) |
| SwOszControl::pStk5 = pFly; |
| } |
| |
| SwOszControl::~SwOszControl() |
| { |
| if ( SwOszControl::pStk1 == pFly ) |
| SwOszControl::pStk1 = 0; |
| else if ( SwOszControl::pStk2 == pFly ) |
| SwOszControl::pStk2 = 0; |
| else if ( SwOszControl::pStk3 == pFly ) |
| SwOszControl::pStk3 = 0; |
| else if ( SwOszControl::pStk4 == pFly ) |
| SwOszControl::pStk4 = 0; |
| else if ( SwOszControl::pStk5 == pFly ) |
| SwOszControl::pStk5 = 0; |
| // --> OD 2004-08-25 #i3317# |
| while ( !maObjPositions.empty() ) |
| { |
| Point* pPos = maObjPositions.back(); |
| delete pPos; |
| |
| maObjPositions.pop_back(); |
| } |
| // <-- |
| } |
| |
| sal_Bool SwOszControl::IsInProgress( const SwFlyFrm *pFly ) |
| { |
| if ( SwOszControl::pStk1 && !pFly->IsLowerOf( SwOszControl::pStk1 ) ) |
| return sal_True; |
| if ( SwOszControl::pStk2 && !pFly->IsLowerOf( SwOszControl::pStk2 ) ) |
| return sal_True; |
| if ( SwOszControl::pStk3 && !pFly->IsLowerOf( SwOszControl::pStk3 ) ) |
| return sal_True; |
| if ( SwOszControl::pStk4 && !pFly->IsLowerOf( SwOszControl::pStk4 ) ) |
| return sal_True; |
| if ( SwOszControl::pStk5 && !pFly->IsLowerOf( SwOszControl::pStk5 ) ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| bool SwOszControl::ChkOsz() |
| { |
| bool bOscillationDetected = false; |
| |
| if ( maObjPositions.size() == mnPosStackSize ) |
| { |
| // position stack is full -> oscillation |
| bOscillationDetected = true; |
| } |
| else |
| { |
| Point* pNewObjPos = new Point( pFly->GetObjRect().Pos() ); |
| for ( std::vector<Point*>::iterator aObjPosIter = maObjPositions.begin(); |
| aObjPosIter != maObjPositions.end(); |
| ++aObjPosIter ) |
| { |
| if ( *(pNewObjPos) == *(*aObjPosIter) ) |
| { |
| // position already occured -> oscillation |
| bOscillationDetected = true; |
| delete pNewObjPos; |
| break; |
| } |
| } |
| if ( !bOscillationDetected ) |
| { |
| maObjPositions.push_back( pNewObjPos ); |
| } |
| } |
| |
| return bOscillationDetected; |
| } |
| |
| void SwFlyAtCntFrm::MakeAll() |
| { |
| // OD 2004-01-19 #110582# |
| if ( !GetFmt()->GetDoc()->IsVisibleLayerId( GetVirtDrawObj()->GetLayer() ) ) |
| { |
| return; |
| } |
| |
| if ( !SwOszControl::IsInProgress( this ) && !IsLocked() && !IsColLocked() ) |
| { |
| // --> OD 2004-06-30 #i28701# - use new method <GetPageFrm()> |
| if( !GetPageFrm() && GetAnchorFrm() && GetAnchorFrm()->IsInFly() ) |
| { |
| SwFlyFrm* pFly = AnchorFrm()->FindFlyFrm(); |
| SwPageFrm *pTmpPage = pFly ? pFly->FindPageFrm() : NULL; |
| if( pTmpPage ) |
| pTmpPage->AppendFlyToPage( this ); |
| } |
| // --> OD 2004-06-30 #i28701# - use new method <GetPageFrm()> |
| if( GetPageFrm() ) |
| { |
| bSetCompletePaintOnInvalidate = sal_True; |
| { |
| SwFlyFrmFmt *pFmt = (SwFlyFrmFmt*)GetFmt(); |
| const SwFmtFrmSize &rFrmSz = GetFmt()->GetFrmSize(); |
| if( rFrmSz.GetHeightPercent() != 0xFF && |
| rFrmSz.GetHeightPercent() >= 100 ) |
| { |
| pFmt->LockModify(); |
| SwFmtSurround aMain( pFmt->GetSurround() ); |
| if ( aMain.GetSurround() == SURROUND_NONE ) |
| { |
| aMain.SetSurround( SURROUND_THROUGHT ); |
| pFmt->SetFmtAttr( aMain ); |
| } |
| pFmt->UnlockModify(); |
| } |
| } |
| |
| SwOszControl aOszCntrl( this ); |
| |
| // --> OD 2005-02-22 #i43255# |
| // --> OD 2005-06-07 #i50356# - format the anchor frame, which |
| // contains the anchor position. E.g., for at-character anchored |
| // object this can be the follow frame of the anchor frame. |
| const bool bFormatAnchor = |
| !static_cast<const SwTxtFrm*>( GetAnchorFrmContainingAnchPos() )->IsAnyJoinLocked() && |
| !ConsiderObjWrapInfluenceOnObjPos() && |
| !ConsiderObjWrapInfluenceOfOtherObjs(); |
| // <-- |
| |
| const SwFrm* pFooter = GetAnchorFrm()->FindFooterOrHeader(); |
| if( pFooter && !pFooter->IsFooterFrm() ) |
| pFooter = NULL; |
| bool bOsz = false; |
| sal_Bool bExtra = Lower() && Lower()->IsColumnFrm(); |
| // --> OD 2004-08-25 #i3317# - boolean, to apply temporarly the |
| // 'straightforward positioning process' for the frame due to its |
| // overlapping with a previous column. |
| bool bConsiderWrapInfluenceDueToOverlapPrevCol( false ); |
| // <-- |
| // --> OD 2004-10-22 #i35911# - boolean, to apply temporarly the |
| // 'straightforward positioning process' for the frame due to fact |
| // that it causes the complete content of its layout environment |
| // to move forward. |
| // --> OD 2005-01-14 #i40444# - extend usage of this boolean: |
| // apply temporarly the 'straightforward positioning process' for |
| // the frame due to the fact that the frame clears the area for |
| // the anchor frame, thus it has to move forward. |
| bool bConsiderWrapInfluenceDueToMovedFwdAnchor( false ); |
| // <-- |
| do { |
| SWRECTFN( this ) |
| Point aOldPos( (Frm().*fnRect->fnGetPos)() ); |
| SwFlyFreeFrm::MakeAll(); |
| const bool bPosChgDueToOwnFormat = |
| aOldPos != (Frm().*fnRect->fnGetPos)(); |
| // --> OD 2004-08-25 #i3317# |
| if ( !ConsiderObjWrapInfluenceOnObjPos() && |
| OverlapsPrevColumn() ) |
| { |
| bConsiderWrapInfluenceDueToOverlapPrevCol = true; |
| } |
| // <-- |
| // OD 2004-05-12 #i28701# - no format of anchor frame, if |
| // wrapping style influence is considered on object positioning |
| if ( bFormatAnchor ) |
| { |
| SwTxtFrm* pAnchPosAnchorFrm = |
| dynamic_cast<SwTxtFrm*>(GetAnchorFrmContainingAnchPos()); |
| ASSERT( pAnchPosAnchorFrm, |
| "<SwFlyAtCntFrm::MakeAll()> - anchor frame of wrong type -> crash" ); |
| // --> OD 2006-01-27 #i58182# - For the usage of new method |
| // <SwObjectFormatterTxtFrm::CheckMovedFwdCondition(..)> |
| // to check move forward of anchor frame due to the object |
| // positioning it's needed to know, if the object is anchored |
| // at the master frame before the anchor frame is formatted. |
| const bool bAnchoredAtMaster( !pAnchPosAnchorFrm->IsFollow() ); |
| // <-- |
| |
| // --> OD 2005-11-17 #i56300# |
| // perform complete format of anchor text frame and its |
| // previous frames, which have become invalid due to the |
| // fly frame format. |
| SwObjectFormatterTxtFrm::FormatAnchorFrmAndItsPrevs( *pAnchPosAnchorFrm ); |
| // <-- |
| // --> OD 2004-10-22 #i35911# |
| // --> OD 2005-01-14 #i40444# |
| // --> OD 2006-01-27 #i58182# - usage of new method |
| // <SwObjectFormatterTxtFrm::CheckMovedFwdCondition(..)> |
| sal_uInt32 nToPageNum( 0L ); |
| bool bDummy( false ); |
| if ( SwObjectFormatterTxtFrm::CheckMovedFwdCondition( |
| *this, GetPageFrm()->GetPhyPageNum(), |
| bAnchoredAtMaster, nToPageNum, bDummy ) ) |
| { |
| bConsiderWrapInfluenceDueToMovedFwdAnchor = true; |
| // --> OD 2005-09-29 #125370#,#125957# - mark anchor text frame |
| // directly, that it is moved forward by object positioning. |
| SwTxtFrm* pAnchorTxtFrm( static_cast<SwTxtFrm*>(AnchorFrm()) ); |
| bool bInsert( true ); |
| sal_uInt32 nAnchorFrmToPageNum( 0L ); |
| const SwDoc& rDoc = *(GetFrmFmt().GetDoc()); |
| if ( SwLayouter::FrmMovedFwdByObjPos( |
| rDoc, *pAnchorTxtFrm, nAnchorFrmToPageNum ) ) |
| { |
| if ( nAnchorFrmToPageNum < nToPageNum ) |
| SwLayouter::RemoveMovedFwdFrm( rDoc, *pAnchorTxtFrm ); |
| else |
| bInsert = false; |
| } |
| if ( bInsert ) |
| { |
| SwLayouter::InsertMovedFwdFrm( rDoc, *pAnchorTxtFrm, |
| nToPageNum ); |
| } |
| // <-- |
| } |
| // <-- |
| } |
| |
| if ( aOldPos != (Frm().*fnRect->fnGetPos)() || |
| ( !GetValidPosFlag() && |
| ( pFooter || bPosChgDueToOwnFormat ) ) ) |
| { |
| bOsz = aOszCntrl.ChkOsz(); |
| |
| // --> OD 2006-04-13 #b6403541# |
| // special loop prevention for dedicated document: |
| if ( bOsz && |
| HasFixSize() && IsClipped() && |
| GetAnchorFrm()->GetUpper()->IsCellFrm() ) |
| { |
| SwFrmFmt* pFmt = GetFmt(); |
| const SwFmtFrmSize& rFrmSz = pFmt->GetFrmSize(); |
| if ( rFrmSz.GetWidthPercent() && |
| rFrmSz.GetHeightPercent() == 0xFF ) |
| { |
| SwFmtSurround aSurround( pFmt->GetSurround() ); |
| if ( aSurround.GetSurround() == SURROUND_NONE ) |
| { |
| pFmt->LockModify(); |
| aSurround.SetSurround( SURROUND_THROUGHT ); |
| pFmt->SetFmtAttr( aSurround ); |
| pFmt->UnlockModify(); |
| bOsz = false; |
| #if OSL_DEBUG_LEVEL > 1 |
| ASSERT( false, |
| "<SwFlyAtCntFrm::MakeAll()> - special loop prevention for dedicated document of b6403541 applied" ); |
| #endif |
| } |
| } |
| } |
| // <-- |
| } |
| |
| if ( bExtra && Lower() && !Lower()->GetValidPosFlag() ) |
| { |
| // Wenn ein mehrspaltiger Rahmen wg. Positionswechsel ungueltige |
| // Spalten hinterlaesst, so drehen wir lieber hier eine weitere |
| // Runde und formatieren unseren Inhalt via FormatWidthCols nochmal. |
| _InvalidateSize(); |
| bExtra = sal_False; // Sicherhaltshalber gibt es nur eine Ehrenrunde. |
| } |
| } while ( !IsValid() && !bOsz && |
| // --> OD 2004-08-25 #i3317# |
| !bConsiderWrapInfluenceDueToOverlapPrevCol && |
| // <-- |
| // --> OD 2005-01-14 #i40444# |
| !bConsiderWrapInfluenceDueToMovedFwdAnchor && |
| // <-- |
| GetFmt()->GetDoc()->IsVisibleLayerId( GetVirtDrawObj()->GetLayer() ) ); |
| |
| // --> OD 2004-08-25 #i3317# - instead of attribute change apply |
| // temporarly the 'straightforward positioning process'. |
| // --> OD 2007-11-29 #i80924# |
| // handle special case during splitting of table rows |
| if ( bConsiderWrapInfluenceDueToMovedFwdAnchor && |
| GetAnchorFrm()->IsInTab() && |
| GetAnchorFrm()->IsInFollowFlowRow() ) |
| { |
| const SwFrm* pCellFrm = GetAnchorFrm(); |
| while ( pCellFrm && !pCellFrm->IsCellFrm() ) |
| { |
| pCellFrm = pCellFrm->GetUpper(); |
| } |
| if ( pCellFrm ) |
| { |
| SWRECTFN( pCellFrm ) |
| if ( (pCellFrm->Frm().*fnRect->fnGetTop)() == 0 && |
| (pCellFrm->Frm().*fnRect->fnGetHeight)() == 0 ) |
| { |
| bConsiderWrapInfluenceDueToMovedFwdAnchor = false; |
| } |
| } |
| } |
| // <-- |
| if ( bOsz || bConsiderWrapInfluenceDueToOverlapPrevCol || |
| // --> OD 2005-01-14 #i40444# |
| bConsiderWrapInfluenceDueToMovedFwdAnchor ) |
| // <-- |
| { |
| SetTmpConsiderWrapInfluence( true ); |
| SetRestartLayoutProcess( true ); |
| // --> OD 2006-07-24 #b6449874# |
| SetTmpConsiderWrapInfluenceOfOtherObjs( true ); |
| // <-- |
| } |
| // <-- |
| bSetCompletePaintOnInvalidate = sal_False; |
| } |
| } |
| } |
| |
| /** method to determine, if a <MakeAll()> on the Writer fly frame is possible |
| |
| OD 2004-05-11 #i28701# |
| |
| @author OD |
| */ |
| bool SwFlyAtCntFrm::IsFormatPossible() const |
| { |
| return SwFlyFreeFrm::IsFormatPossible() && |
| !SwOszControl::IsInProgress( this ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* FindAnchor() und Hilfsfunktionen. |
| |* |
| |* Beschreibung: Sucht ausgehend von pOldAnch einen Anker fuer |
| |* Absatzgebundene Objekte. |
| |* Wird beim Draggen von Absatzgebundenen Objekten zur Ankeranzeige sowie |
| |* fuer Ankerwechsel benoetigt. |
| |* Ersterstellung MA 22. Jun. 93 |
| |* Letzte Aenderung MA 30. Jan. 95 |
| |* |
| |*************************************************************************/ |
| |
| class SwDistance |
| { |
| public: |
| SwTwips nMain, nSub; |
| SwDistance() { nMain = nSub = 0; } |
| SwDistance& operator=( const SwDistance &rTwo ) |
| { nMain = rTwo.nMain; nSub = rTwo.nSub; return *this; } |
| sal_Bool operator<( const SwDistance& rTwo ) |
| { return nMain < rTwo.nMain || ( nMain == rTwo.nMain && nSub && |
| rTwo.nSub && nSub < rTwo.nSub ); } |
| sal_Bool operator<=( const SwDistance& rTwo ) |
| { return nMain < rTwo.nMain || ( nMain == rTwo.nMain && ( !nSub || |
| !rTwo.nSub || nSub <= rTwo.nSub ) ); } |
| }; |
| |
| const SwFrm * MA_FASTCALL lcl_CalcDownDist( SwDistance &rRet, |
| const Point &rPt, |
| const SwCntntFrm *pCnt ) |
| { |
| rRet.nSub = 0; |
| //Wenn der Point direkt innerhalb des Cnt steht ist die Sache klar und |
| //der Cntnt hat automatisch eine Entfernung von 0 |
| if ( pCnt->Frm().IsInside( rPt ) ) |
| { |
| rRet.nMain = 0; |
| return pCnt; |
| } |
| else |
| { |
| const SwLayoutFrm *pUp = pCnt->IsInTab() ? pCnt->FindTabFrm()->GetUpper() : pCnt->GetUpper(); |
| // einspaltige Bereiche muessen zu ihrem Upper durchschalten |
| while( pUp->IsSctFrm() ) |
| pUp = pUp->GetUpper(); |
| const bool bVert = pUp->IsVertical(); |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| const bool bVertL2R = pUp->IsVertLR(); |
| |
| //Dem Textflus folgen. |
| // --> OD 2009-01-12 #i70582# |
| // --> OD 2009-03-05 - adopted for Support for Classical Mongolian Script |
| const SwTwips nTopForObjPos = |
| bVert |
| ? ( bVertL2R |
| ? ( pCnt->Frm().Left() + |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ) |
| : ( pCnt->Frm().Left() + |
| pCnt->Frm().Width() - |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ) ) |
| : ( pCnt->Frm().Top() + |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ); |
| // <-- |
| if ( pUp->Frm().IsInside( rPt ) ) |
| { |
| // OD 26.09.2003 - <rPt> point is inside environment of given content frame |
| // --> OD 2009-01-12 #i70582# |
| if( bVert ) |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| { |
| if ( bVertL2R ) |
| rRet.nMain = rPt.X() - nTopForObjPos; |
| else |
| rRet.nMain = nTopForObjPos - rPt.X(); |
| } |
| else |
| rRet.nMain = rPt.Y() - nTopForObjPos; |
| // <-- |
| return pCnt; |
| } |
| else if ( rPt.Y() <= pUp->Frm().Top() ) |
| { |
| // OD 26.09.2003 - <rPt> point is above environment of given content frame |
| // OD: correct for vertical layout? |
| rRet.nMain = LONG_MAX; |
| } |
| else if( rPt.X() < pUp->Frm().Left() && |
| rPt.Y() <= ( bVert ? pUp->Frm().Top() : pUp->Frm().Bottom() ) ) |
| { |
| // OD 26.09.2003 - <rPt> point is left of environment of given content frame |
| // OD: seems not to be correct for vertical layout!? |
| const SwFrm *pLay = pUp->GetLeaf( MAKEPAGE_NONE, sal_False, pCnt ); |
| if( !pLay || |
| (bVert && (pLay->Frm().Top() + pLay->Prt().Bottom()) <rPt.Y())|| |
| (!bVert && (pLay->Frm().Left() + pLay->Prt().Right())<rPt.X()) ) |
| { |
| // OD 26.09.2003 - <rPt> point is in left border of environment |
| // --> OD 2009-01-12 #i70582# |
| if( bVert ) |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| { |
| if ( bVertL2R ) |
| rRet.nMain = rPt.X() - nTopForObjPos; |
| else |
| rRet.nMain = nTopForObjPos - rPt.X(); |
| } |
| else |
| rRet.nMain = rPt.Y() - nTopForObjPos; |
| // <-- |
| return pCnt; |
| } |
| else |
| rRet.nMain = LONG_MAX; |
| } |
| else |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| // --> OD 2009-01-12 #i70582# |
| rRet.nMain = bVert |
| ? ( bVertL2R |
| ? ( (pUp->Frm().Left() + pUp->Prt().Right()) - nTopForObjPos ) |
| : ( nTopForObjPos - (pUp->Frm().Left() + pUp->Prt().Left() ) ) ) |
| : ( (pUp->Frm().Top() + pUp->Prt().Bottom()) - nTopForObjPos ); |
| |
| const SwFrm *pPre = pCnt; |
| const SwFrm *pLay = pUp->GetLeaf( MAKEPAGE_NONE, sal_True, pCnt ); |
| SwTwips nFrmTop = 0; |
| SwTwips nPrtHeight = 0; |
| sal_Bool bSct = sal_False; |
| const SwSectionFrm *pSect = pUp->FindSctFrm(); |
| if( pSect ) |
| { |
| rRet.nSub = rRet.nMain; |
| rRet.nMain = 0; |
| } |
| if( pSect && !pSect->IsAnLower( pLay ) ) |
| { |
| bSct = sal_False; |
| const SwSectionFrm* pNxtSect = pLay ? pLay->FindSctFrm() : 0; |
| if( pSect->IsAnFollow( pNxtSect ) ) |
| { |
| if( pLay->IsVertical() ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if ( pLay->IsVertLR() ) |
| nFrmTop = pLay->Frm().Left(); |
| else |
| nFrmTop = pLay->Frm().Left() + pLay->Frm().Width(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Top(); |
| nPrtHeight = pLay->Prt().Height(); |
| } |
| pSect = pNxtSect; |
| } |
| else |
| { |
| pLay = pSect->GetUpper(); |
| if( pLay->IsVertical() ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if ( pLay->IsVertLR() ) |
| { |
| nFrmTop = pSect->Frm().Right(); |
| nPrtHeight = pLay->Frm().Left() + pLay->Prt().Left() |
| + pLay->Prt().Width() - pSect->Frm().Left() |
| - pSect->Frm().Width(); |
| } |
| else |
| { |
| nFrmTop = pSect->Frm().Left(); |
| nPrtHeight = pSect->Frm().Left() - pLay->Frm().Left() |
| - pLay->Prt().Left(); |
| } |
| } |
| else |
| { |
| nFrmTop = pSect->Frm().Bottom(); |
| nPrtHeight = pLay->Frm().Top() + pLay->Prt().Top() |
| + pLay->Prt().Height() - pSect->Frm().Top() |
| - pSect->Frm().Height(); |
| } |
| pSect = 0; |
| } |
| } |
| else if( pLay ) |
| { |
| if( pLay->IsVertical() ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if ( pLay->IsVertLR() ) |
| { |
| nFrmTop = pLay->Frm().Left(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Left() + pLay->Frm().Width(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Top(); |
| nPrtHeight = pLay->Prt().Height(); |
| } |
| bSct = 0 != pSect; |
| } |
| while ( pLay && !pLay->Frm().IsInside( rPt ) && |
| ( pLay->Frm().Top() <= rPt.Y() || pLay->IsInFly() || |
| ( pLay->IsInSct() && |
| pLay->FindSctFrm()->GetUpper()->Frm().Top() <= rPt.Y())) ) |
| { |
| if ( pLay->IsFtnContFrm() ) |
| { |
| if ( !((SwLayoutFrm*)pLay)->Lower() ) |
| { |
| SwFrm *pDel = (SwFrm*)pLay; |
| pDel->Cut(); |
| delete pDel; |
| return pPre; |
| } |
| return 0; |
| } |
| else |
| { |
| if( bSct || pSect ) |
| rRet.nSub += nPrtHeight; |
| else |
| rRet.nMain += nPrtHeight; |
| pPre = pLay; |
| pLay = pLay->GetLeaf( MAKEPAGE_NONE, sal_True, pCnt ); |
| if( pSect && !pSect->IsAnLower( pLay ) ) |
| { // If we're leaving a SwSectionFrm, the next Leaf-Frm |
| // is the part of the upper below the SectionFrm. |
| const SwSectionFrm* pNxtSect = pLay ? |
| pLay->FindSctFrm() : NULL; |
| bSct = sal_False; |
| if( pSect->IsAnFollow( pNxtSect ) ) |
| { |
| pSect = pNxtSect; |
| if( pLay->IsVertical() ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if ( pLay->IsVertLR() ) |
| { |
| nFrmTop = pLay->Frm().Left(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Left() + pLay->Frm().Width(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Top(); |
| nPrtHeight = pLay->Prt().Height(); |
| } |
| } |
| else |
| { |
| pLay = pSect->GetUpper(); |
| if( pLay->IsVertical() ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if ( pLay->IsVertLR() ) |
| { |
| nFrmTop = pSect->Frm().Right(); |
| nPrtHeight = pLay->Frm().Left()+pLay->Prt().Left() |
| + pLay->Prt().Width() - pSect->Frm().Left() |
| - pSect->Frm().Width(); |
| } |
| else |
| { |
| nFrmTop = pSect->Frm().Left(); |
| nPrtHeight = pSect->Frm().Left() - |
| pLay->Frm().Left() - pLay->Prt().Left(); |
| } |
| } |
| else |
| { |
| nFrmTop = pSect->Frm().Bottom(); |
| nPrtHeight = pLay->Frm().Top()+pLay->Prt().Top() |
| + pLay->Prt().Height() - pSect->Frm().Top() |
| - pSect->Frm().Height(); |
| } |
| pSect = 0; |
| } |
| } |
| else if( pLay ) |
| { |
| if( pLay->IsVertical() ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if ( pLay->IsVertLR() ) |
| { |
| nFrmTop = pLay->Frm().Left(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Left() + pLay->Frm().Width(); |
| nPrtHeight = pLay->Prt().Width(); |
| } |
| } |
| else |
| { |
| nFrmTop = pLay->Frm().Top(); |
| nPrtHeight = pLay->Prt().Height(); |
| } |
| bSct = 0 != pSect; |
| } |
| } |
| } |
| if ( pLay ) |
| { |
| if ( pLay->Frm().IsInside( rPt ) ) |
| { |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| SwTwips nDiff = pLay->IsVertical() ? ( pLay->IsVertLR() ? ( rPt.X() - nFrmTop ) : ( nFrmTop - rPt.X() ) ) |
| : ( rPt.Y() - nFrmTop ); |
| if( bSct || pSect ) |
| rRet.nSub += nDiff; |
| else |
| rRet.nMain += nDiff; |
| } |
| if ( pLay->IsFtnContFrm() && !((SwLayoutFrm*)pLay)->Lower() ) |
| { |
| SwFrm *pDel = (SwFrm*)pLay; |
| pDel->Cut(); |
| delete pDel; |
| return 0; |
| } |
| return pLay; |
| } |
| else |
| rRet.nMain = LONG_MAX; |
| } |
| } |
| return 0; |
| } |
| |
| sal_uLong MA_FASTCALL lcl_FindCntDiff( const Point &rPt, const SwLayoutFrm *pLay, |
| const SwCntntFrm *& rpCnt, |
| const sal_Bool bBody, const sal_Bool bFtn ) |
| { |
| //Sucht unterhalb von pLay den dichtesten Cnt zum Point. Der Bezugspunkt |
| //der Cntnts ist immer die linke obere Ecke. |
| //Der Cnt soll moeglichst ueber dem Point liegen. |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| Point arPoint( rPt ); |
| #endif |
| |
| rpCnt = 0; |
| sal_uLong nDistance = ULONG_MAX; |
| sal_uLong nNearest = ULONG_MAX; |
| const SwCntntFrm *pCnt = pLay->ContainsCntnt(); |
| |
| while ( pCnt && (bBody != pCnt->IsInDocBody() || bFtn != pCnt->IsInFtn())) |
| { |
| pCnt = pCnt->GetNextCntntFrm(); |
| if ( !pLay->IsAnLower( pCnt ) ) |
| pCnt = 0; |
| } |
| const SwCntntFrm *pNearest = pCnt; |
| if ( pCnt ) |
| { |
| do |
| { |
| //Jetzt die Entfernung zwischen den beiden Punkten berechnen. |
| //'Delta' X^2 + 'Delta'Y^2 = 'Entfernung'^2 |
| sal_uInt32 dX = Max( pCnt->Frm().Left(), rPt.X() ) - |
| Min( pCnt->Frm().Left(), rPt.X() ), |
| dY = Max( pCnt->Frm().Top(), rPt.Y() ) - |
| Min( pCnt->Frm().Top(), rPt.Y() ); |
| BigInt dX1( dX ), dY1( dY ); |
| dX1 *= dX1; dY1 *= dY1; |
| const sal_uLong nDiff = ::SqRt( dX1 + dY1 ); |
| if ( pCnt->Frm().Top() <= rPt.Y() ) |
| { |
| if ( nDiff < nDistance ) |
| { //Der ist dichter dran |
| nDistance = nNearest = nDiff; |
| rpCnt = pNearest = pCnt; |
| } |
| } |
| else if ( nDiff < nNearest ) |
| { |
| nNearest = nDiff; |
| pNearest = pCnt; |
| } |
| pCnt = pCnt->GetNextCntntFrm(); |
| while ( pCnt && |
| (bBody != pCnt->IsInDocBody() || bFtn != pCnt->IsInFtn())) |
| pCnt = pCnt->GetNextCntntFrm(); |
| |
| } while ( pCnt && pLay->IsAnLower( pCnt ) ); |
| } |
| if ( nDistance == ULONG_MAX ) |
| { rpCnt = pNearest; |
| return nNearest; |
| } |
| return nDistance; |
| } |
| |
| const SwCntntFrm * MA_FASTCALL lcl_FindCnt( const Point &rPt, const SwCntntFrm *pCnt, |
| const sal_Bool bBody, const sal_Bool bFtn ) |
| { |
| //Sucht ausgehen von pCnt denjenigen CntntFrm, dessen linke obere |
| //Ecke am dichtesten am Point liegt. |
| //Liefert _immer_ einen CntntFrm zurueck. |
| |
| //Zunaechst wird versucht den dichtesten Cntnt innerhalt derjenigen |
| //Seite zu suchen innerhalb derer der Cntnt steht. |
| //Ausgehend von der Seite muessen die Seiten in beide |
| //Richtungen beruecksichtigt werden. |
| //Falls moeglich wird ein Cntnt geliefert, dessen Y-Position ueber der |
| //des Point sitzt. |
| const SwCntntFrm *pRet, *pNew; |
| const SwLayoutFrm *pLay = pCnt->FindPageFrm(); |
| sal_uLong nDist; |
| |
| nDist = ::lcl_FindCntDiff( rPt, pLay, pNew, bBody, bFtn ); |
| if ( pNew ) |
| pRet = pNew; |
| else |
| { pRet = pCnt; |
| nDist = ULONG_MAX; |
| } |
| const SwCntntFrm *pNearest = pRet; |
| sal_uLong nNearest = nDist; |
| |
| if ( pLay ) |
| { |
| const SwLayoutFrm *pPge = pLay; |
| sal_uLong nOldNew = ULONG_MAX; |
| for ( sal_uInt16 i = 0; pPge->GetPrev() && (i < 3); ++i ) |
| { |
| pPge = (SwLayoutFrm*)pPge->GetPrev(); |
| const sal_uLong nNew = ::lcl_FindCntDiff( rPt, pPge, pNew, bBody, bFtn ); |
| if ( nNew < nDist ) |
| { |
| if ( pNew->Frm().Top() <= rPt.Y() ) |
| { |
| pRet = pNearest = pNew; |
| nDist = nNearest = nNew; |
| } |
| else if ( nNew < nNearest ) |
| { |
| pNearest = pNew; |
| nNearest = nNew; |
| } |
| } |
| else if ( nOldNew != ULONG_MAX && nNew > nOldNew ) |
| break; |
| else |
| nOldNew = nNew; |
| |
| } |
| pPge = pLay; |
| nOldNew = ULONG_MAX; |
| for ( sal_uInt16 j = 0; pPge->GetNext() && (j < 3); ++j ) |
| { |
| pPge = (SwLayoutFrm*)pPge->GetNext(); |
| const sal_uLong nNew = ::lcl_FindCntDiff( rPt, pPge, pNew, bBody, bFtn ); |
| if ( nNew < nDist ) |
| { |
| if ( pNew->Frm().Top() <= rPt.Y() ) |
| { |
| pRet = pNearest = pNew; |
| nDist = nNearest = nNew; |
| } |
| else if ( nNew < nNearest ) |
| { |
| pNearest = pNew; |
| nNearest = nNew; |
| } |
| } |
| else if ( nOldNew != ULONG_MAX && nNew > nOldNew ) |
| break; |
| else |
| nOldNew = nNew; |
| } |
| } |
| if ( (pRet->Frm().Top() > rPt.Y()) ) |
| return pNearest; |
| else |
| return pRet; |
| } |
| |
| void lcl_PointToPrt( Point &rPoint, const SwFrm *pFrm ) |
| { |
| SwRect aTmp( pFrm->Prt() ); |
| aTmp += pFrm->Frm().Pos(); |
| if ( rPoint.X() < aTmp.Left() ) |
| rPoint.X() = aTmp.Left(); |
| else if ( rPoint.X() > aTmp.Right() ) |
| rPoint.X() = aTmp.Right(); |
| if ( rPoint.Y() < aTmp.Top() ) |
| rPoint.Y() = aTmp.Top(); |
| else if ( rPoint.Y() > aTmp.Bottom() ) |
| rPoint.Y() = aTmp.Bottom(); |
| |
| } |
| |
| const SwCntntFrm *FindAnchor( const SwFrm *pOldAnch, const Point &rNew, |
| const sal_Bool bBodyOnly ) |
| { |
| //Zu der angegebenen DokumentPosition wird der dichteste Cnt im |
| //Textfluss gesucht. AusgangsFrm ist der uebergebene Anker. |
| const SwCntntFrm* pCnt; |
| if ( pOldAnch->IsCntntFrm() ) |
| { |
| pCnt = (const SwCntntFrm*)pOldAnch; |
| } |
| else |
| { |
| Point aTmp( rNew ); |
| SwLayoutFrm *pTmpLay = (SwLayoutFrm*)pOldAnch; |
| if( pTmpLay->IsRootFrm() ) |
| { |
| SwRect aTmpRect( aTmp, Size(0,0) ); |
| pTmpLay = (SwLayoutFrm*)::FindPage( aTmpRect, pTmpLay->Lower() ); |
| } |
| pCnt = pTmpLay->GetCntntPos( aTmp, sal_False, bBodyOnly ); |
| } |
| |
| //Beim Suchen darauf achten, dass die Bereiche sinnvoll erhalten |
| //bleiben. D.h. in diesem Fall nicht in Header/Footer hinein und |
| //nicht aus Header/Footer hinaus. |
| const sal_Bool bBody = pCnt->IsInDocBody() || bBodyOnly; |
| const sal_Bool bFtn = !bBodyOnly && pCnt->IsInFtn(); |
| |
| Point aNew( rNew ); |
| if ( bBody ) |
| { |
| //#38848 Vom Seitenrand in den Body ziehen. |
| const SwFrm *pPage = pCnt->FindPageFrm(); |
| ::lcl_PointToPrt( aNew, pPage->GetUpper() ); |
| SwRect aTmp( aNew, Size( 0, 0 ) ); |
| pPage = ::FindPage( aTmp, pPage ); |
| ::lcl_PointToPrt( aNew, pPage ); |
| } |
| |
| if ( pCnt->IsInDocBody() == bBody && pCnt->Frm().IsInside( aNew ) ) |
| return pCnt; |
| else if ( pOldAnch->IsInDocBody() || pOldAnch->IsPageFrm() ) |
| { |
| //Vielleicht befindet sich der gewuenschte Anker ja auf derselben |
| //Seite wie der aktuelle Anker. |
| //So gibt es kein Problem mit Spalten. |
| Point aTmp( aNew ); |
| const SwCntntFrm *pTmp = pCnt->FindPageFrm()-> |
| GetCntntPos( aTmp, sal_False, sal_True, sal_False ); |
| if ( pTmp && pTmp->Frm().IsInside( aNew ) ) |
| return pTmp; |
| } |
| |
| //Ausgehend vom Anker suche ich jetzt in beide Richtungen bis ich |
| //den jeweils dichtesten gefunden habe. |
| //Nicht die direkte Entfernung ist relevant sondern die Strecke die |
| //im Textfluss zurueckgelegt werden muss. |
| const SwCntntFrm *pUpLst; |
| const SwCntntFrm *pUpFrm = pCnt; |
| SwDistance nUp, nUpLst; |
| ::lcl_CalcDownDist( nUp, aNew, pUpFrm ); |
| SwDistance nDown = nUp; |
| sal_Bool bNegAllowed = sal_True;//Einmal aus dem negativen Bereich heraus lassen. |
| do |
| { |
| pUpLst = pUpFrm; nUpLst = nUp; |
| pUpFrm = pUpLst->GetPrevCntntFrm(); |
| while ( pUpFrm && |
| (bBody != pUpFrm->IsInDocBody() || bFtn != pUpFrm->IsInFtn())) |
| pUpFrm = pUpFrm->GetPrevCntntFrm(); |
| if ( pUpFrm ) |
| { |
| ::lcl_CalcDownDist( nUp, aNew, pUpFrm ); |
| //Wenn die Distanz innnerhalb einer Tabelle waechst, so lohnt es |
| //sich weiter zu suchen. |
| if ( pUpLst->IsInTab() && pUpFrm->IsInTab() ) |
| { |
| while ( pUpFrm && ((nUpLst < nUp && pUpFrm->IsInTab()) || |
| bBody != pUpFrm->IsInDocBody()) ) |
| { |
| pUpFrm = pUpFrm->GetPrevCntntFrm(); |
| if ( pUpFrm ) |
| ::lcl_CalcDownDist( nUp, aNew, pUpFrm ); |
| } |
| } |
| } |
| if ( !pUpFrm ) |
| nUp.nMain = LONG_MAX; |
| if ( nUp.nMain >= 0 && LONG_MAX != nUp.nMain ) |
| { |
| bNegAllowed = sal_False; |
| if ( nUpLst.nMain < 0 ) //nicht den falschen erwischen, wenn der Wert |
| //gerade von negativ auf positiv gekippt ist. |
| { pUpLst = pUpFrm; |
| nUpLst = nUp; |
| } |
| } |
| } while ( pUpFrm && ( ( bNegAllowed && nUp.nMain < 0 ) || ( nUp <= nUpLst ) ) ); |
| |
| const SwCntntFrm *pDownLst; |
| const SwCntntFrm *pDownFrm = pCnt; |
| SwDistance nDownLst; |
| if ( nDown.nMain < 0 ) |
| nDown.nMain = LONG_MAX; |
| do |
| { |
| pDownLst = pDownFrm; nDownLst = nDown; |
| pDownFrm = pDownLst->GetNextCntntFrm(); |
| while ( pDownFrm && |
| (bBody != pDownFrm->IsInDocBody() || bFtn != pDownFrm->IsInFtn())) |
| pDownFrm = pDownFrm->GetNextCntntFrm(); |
| if ( pDownFrm ) |
| { |
| ::lcl_CalcDownDist( nDown, aNew, pDownFrm ); |
| if ( nDown.nMain < 0 ) |
| nDown.nMain = LONG_MAX; |
| //Wenn die Distanz innnerhalb einer Tabelle waechst, so lohnt es |
| //sich weiter zu suchen. |
| if ( pDownLst->IsInTab() && pDownFrm->IsInTab() ) |
| { |
| while ( pDownFrm && ( ( nDown.nMain != LONG_MAX && nDownLst < nDownLst |
| && pDownFrm->IsInTab()) || bBody != pDownFrm->IsInDocBody() ) ) |
| { |
| pDownFrm = pDownFrm->GetNextCntntFrm(); |
| if ( pDownFrm ) |
| ::lcl_CalcDownDist( nDown, aNew, pDownFrm ); |
| if ( nDown.nMain < 0 ) |
| nDown.nMain = LONG_MAX; |
| } |
| } |
| } |
| if ( !pDownFrm ) |
| nDown.nMain = LONG_MAX; |
| |
| } while ( pDownFrm && nDown <= nDownLst && |
| nDown.nMain != LONG_MAX && nDownLst.nMain != LONG_MAX ); |
| |
| //Wenn ich in beide Richtungen keinen gefunden habe, so suche ich mir |
| //denjenigen Cntnt dessen linke obere Ecke dem Point am naechsten liegt. |
| //Eine derartige Situation tritt z.b. auf, wenn der Point nicht im Text- |
| //fluss sondern in irgendwelchen Raendern steht. |
| if ( nDownLst.nMain == LONG_MAX && nUpLst.nMain == LONG_MAX ) |
| { |
| // #102861# If an OLE objects, which is contained in a fly frame |
| // is resized in inplace mode and the new Position is outside the |
| // fly frame, we do not want to leave our fly frame. |
| if ( pCnt->IsInFly() ) |
| return pCnt; |
| |
| return ::lcl_FindCnt( aNew, pCnt, bBody, bFtn ); |
| } |
| else |
| return nDownLst < nUpLst ? pDownLst : pUpLst; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwFlyAtCntFrm::SetAbsPos() |
| |* |
| |* Ersterstellung MA 22. Jun. 93 |
| |* Letzte Aenderung MA 11. Sep. 98 |
| |* |
| |*************************************************************************/ |
| |
| void SwFlyAtCntFrm::SetAbsPos( const Point &rNew ) |
| { |
| SwPageFrm *pOldPage = FindPageFrm(); |
| const SwRect aOld( GetObjRectWithSpaces() ); |
| Point aNew( rNew ); |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| if( ( GetAnchorFrm()->IsVertical() && !GetAnchorFrm()->IsVertLR() ) || GetAnchorFrm()->IsRightToLeft() ) |
| aNew.X() += Frm().Width(); |
| SwCntntFrm *pCnt = (SwCntntFrm*)::FindAnchor( GetAnchorFrm(), aNew ); |
| if( pCnt->IsProtected() ) |
| pCnt = (SwCntntFrm*)GetAnchorFrm(); |
| |
| SwPageFrm *pTmpPage = 0; |
| const bool bVert = pCnt->IsVertical(); |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| const bool bVertL2R = pCnt->IsVertLR(); |
| const sal_Bool bRTL = pCnt->IsRightToLeft(); |
| |
| if( ( !bVert != !GetAnchorFrm()->IsVertical() ) || |
| ( !bRTL != !GetAnchorFrm()->IsRightToLeft() ) ) |
| { |
| if( bVert || bRTL ) |
| aNew.X() += Frm().Width(); |
| else |
| aNew.X() -= Frm().Width(); |
| } |
| |
| if ( pCnt->IsInDocBody() ) |
| { |
| //#38848 Vom Seitenrand in den Body ziehen. |
| pTmpPage = pCnt->FindPageFrm(); |
| ::lcl_PointToPrt( aNew, pTmpPage->GetUpper() ); |
| SwRect aTmp( aNew, Size( 0, 0 ) ); |
| pTmpPage = (SwPageFrm*)::FindPage( aTmp, pTmpPage ); |
| ::lcl_PointToPrt( aNew, pTmpPage ); |
| } |
| |
| //RelPos einstellen, nur auf Wunsch invalidieren. |
| //rNew ist eine Absolute Position. Um die RelPos korrekt einzustellen |
| //muessen wir uns die Entfernung von rNew zum Anker im Textfluss besorgen. |
| //!!!!!Hier kann Optimiert werden: FindAnchor koennte die RelPos mitliefern! |
| const SwFrm *pFrm = 0; |
| SwTwips nY; |
| if ( pCnt->Frm().IsInside( aNew ) ) |
| { |
| // --> OD 2009-01-12 #i70582# |
| const SwTwips nTopForObjPos = |
| bVert |
| ? ( bVertL2R |
| ? ( pCnt->Frm().Left() + |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ) |
| : ( pCnt->Frm().Left() + |
| pCnt->Frm().Width() - |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ) ) |
| : ( pCnt->Frm().Top() + |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ); |
| if( bVert ) |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| { |
| if ( bVertL2R ) |
| nY = rNew.X() - nTopForObjPos; |
| else |
| nY = nTopForObjPos - rNew.X() - Frm().Width(); |
| } |
| else |
| { |
| nY = rNew.Y() - nTopForObjPos; |
| } |
| // <-- |
| } |
| else |
| { |
| SwDistance aDist; |
| pFrm = ::lcl_CalcDownDist( aDist, aNew, pCnt ); |
| nY = aDist.nMain + aDist.nSub; |
| } |
| |
| SwTwips nX = 0; |
| |
| if ( pCnt->IsFollow() ) |
| { |
| //Flys haengen niemals an einem Follow sondern immer am |
| //Master, den suchen wir uns jetzt. |
| const SwCntntFrm *pOriginal = pCnt; |
| const SwCntntFrm *pFollow = pCnt; |
| while ( pCnt->IsFollow() ) |
| { |
| do |
| { pCnt = pCnt->GetPrevCntntFrm(); |
| } while ( pCnt->GetFollow() != pFollow ); |
| pFollow = pCnt; |
| } |
| SwTwips nDiff = 0; |
| do |
| { const SwFrm *pUp = pFollow->GetUpper(); |
| if( pUp->IsVertical() ) |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| { |
| if ( pUp->IsVertLR() ) |
| nDiff += pUp->Prt().Width() - pFollow->GetRelPos().X(); |
| else |
| nDiff += pFollow->Frm().Left() + pFollow->Frm().Width() |
| - pUp->Frm().Left() - pUp->Prt().Left(); |
| } |
| else |
| nDiff += pUp->Prt().Height() - pFollow->GetRelPos().Y(); |
| pFollow = pFollow->GetFollow(); |
| } while ( pFollow != pOriginal ); |
| nY += nDiff; |
| if( bVert ) |
| nX = pCnt->Frm().Top() - pOriginal->Frm().Top(); |
| else |
| nX = pCnt->Frm().Left() - pOriginal->Frm().Left(); |
| } |
| |
| if ( nY == LONG_MAX ) |
| { |
| // --> OD 2009-01-12 #i70582# |
| const SwTwips nTopForObjPos = |
| bVert |
| ? ( bVertL2R |
| ? ( pCnt->Frm().Left() + |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ) |
| : ( pCnt->Frm().Left() + |
| pCnt->Frm().Width() - |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ) ) |
| : ( pCnt->Frm().Top() + |
| pCnt->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid() ); |
| if( bVert ) |
| //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin |
| { |
| if ( bVertL2R ) |
| nY = rNew.X() - nTopForObjPos; |
| else |
| nY = nTopForObjPos - rNew.X(); |
| } |
| else |
| { |
| nY = rNew.Y() - nTopForObjPos; |
| } |
| // <-- |
| } |
| |
| SwFlyFrmFmt *pFmt = (SwFlyFrmFmt*)GetFmt(); |
| const SwFmtSurround& rSurround = pFmt->GetSurround(); |
| const sal_Bool bWrapThrough = |
| rSurround.GetSurround() == SURROUND_THROUGHT; |
| SwTwips nBaseOfstForFly = 0; |
| const SwFrm* pTmpFrm = pFrm ? pFrm : pCnt; |
| if ( pTmpFrm->IsTxtFrm() ) |
| nBaseOfstForFly = |
| ((SwTxtFrm*)pTmpFrm)->GetBaseOfstForFly( !bWrapThrough ); |
| |
| if( bVert ) |
| { |
| if( !pFrm ) |
| nX += rNew.Y() - pCnt->Frm().Top() - nBaseOfstForFly; |
| else |
| nX = rNew.Y() - pFrm->Frm().Top() - nBaseOfstForFly; |
| } |
| else |
| { |
| if( !pFrm ) |
| { |
| if ( pCnt->IsRightToLeft() ) |
| nX += pCnt->Frm().Right() - rNew.X() - Frm().Width() + |
| nBaseOfstForFly; |
| else |
| nX += rNew.X() - pCnt->Frm().Left() - nBaseOfstForFly; |
| } |
| else |
| { |
| if ( pFrm->IsRightToLeft() ) |
| nX += pFrm->Frm().Right() - rNew.X() - Frm().Width() + |
| nBaseOfstForFly; |
| else |
| nX = rNew.X() - pFrm->Frm().Left() - nBaseOfstForFly; |
| } |
| } |
| GetFmt()->GetDoc()->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL ); |
| |
| if( pCnt != GetAnchorFrm() || ( IsAutoPos() && pCnt->IsTxtFrm() && |
| GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::HTML_MODE)) ) |
| { |
| //Das Ankerattribut auf den neuen Cnt setzen. |
| SwFmtAnchor aAnch( pFmt->GetAnchor() ); |
| SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor(); |
| if( IsAutoPos() && pCnt->IsTxtFrm() ) |
| { |
| SwCrsrMoveState eTmpState( MV_SETONLYTEXT ); |
| Point aPt( rNew ); |
| if( pCnt->GetCrsrOfst( pPos, aPt, &eTmpState ) |
| && pPos->nNode == *pCnt->GetNode() ) |
| { |
| if ( pCnt->GetNode()->GetTxtNode() != NULL ) |
| { |
| const SwTxtAttr* pTxtInputFld = |
| pCnt->GetNode()->GetTxtNode()->GetTxtAttrAt( pPos->nContent.GetIndex(), RES_TXTATR_INPUTFIELD, SwTxtNode::PARENT ); |
| if ( pTxtInputFld != NULL ) |
| { |
| pPos->nContent = *(pTxtInputFld->GetStart()); |
| } |
| } |
| ResetLastCharRectHeight(); |
| if( text::RelOrientation::CHAR == pFmt->GetVertOrient().GetRelationOrient() ) |
| nY = LONG_MAX; |
| if( text::RelOrientation::CHAR == pFmt->GetHoriOrient().GetRelationOrient() ) |
| nX = LONG_MAX; |
| } |
| else |
| { |
| pPos->nNode = *pCnt->GetNode(); |
| pPos->nContent.Assign( pCnt->GetNode(), 0 ); |
| } |
| } |
| else |
| { |
| pPos->nNode = *pCnt->GetNode(); |
| pPos->nContent.Assign( pCnt->GetNode(), 0 ); |
| } |
| |
| // handle change of anchor node: |
| // if count of the anchor frame also change, the fly frames have to be |
| // re-created. Thus, delete all fly frames except the <this> before the |
| // anchor attribute is change and re-create them afterwards. |
| { |
| SwHandleAnchorNodeChg aHandleAnchorNodeChg( *pFmt, aAnch, this ); |
| pFmt->GetDoc()->SetAttr( aAnch, *pFmt ); |
| } |
| } |
| else if ( pTmpPage && pTmpPage != GetPageFrm() ) |
| GetPageFrm()->MoveFly( this, pTmpPage ); |
| |
| const Point aRelPos = bVert ? Point( -nY, nX ) : Point( nX, nY ); |
| |
| ChgRelPos( aRelPos ); |
| |
| GetFmt()->GetDoc()->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL ); |
| |
| if ( pOldPage != FindPageFrm() ) |
| ::Notify_Background( GetVirtDrawObj(), pOldPage, aOld, PREP_FLY_LEAVE, sal_False ); |
| } |
| |
| // OD 2004-08-12 #i32795# - Note: method no longer used in <flyincnt.cxx> |
| //void DeepCalc( const SwFrm *pFrm ) |
| //{ |
| // if( pFrm->IsSctFrm() || |
| // ( pFrm->IsFlyFrm() && ((SwFlyFrm*)pFrm)->IsFlyInCntFrm() ) ) |
| // return; |
| // const SwFlowFrm *pFlow = SwFlowFrm::CastFlowFrm( pFrm ); |
| // if( pFlow && pFlow->IsAnyJoinLocked() ) |
| // return; |
| |
| // sal_uInt16 nCnt = 0; |
| |
| // sal_Bool bContinue = sal_False; |
| // do |
| // { |
| // if ( ++nCnt == 10 ) |
| // { |
| // ASSERT( !nCnt, "DeepCalc: Loop detected1?" ); |
| // break; |
| // } |
| |
| // const sal_Bool bSetComplete = !pFrm->IsValid(); |
| // const SwRect aOldFrm( pFrm->Frm() ); |
| // const SwRect aOldPrt( pFrm->Prt() ); |
| |
| // const SwFrm *pUp = pFrm->GetUpper(); |
| // if ( pUp ) |
| // { |
| // //Nicht weiter wenn der Up ein Fly mit Spalten ist. |
| // if( ( !pUp->IsFlyFrm() || !((SwLayoutFrm*)pUp)->Lower() || |
| // !((SwLayoutFrm*)pUp)->Lower()->IsColumnFrm() ) && |
| // !pUp->IsSctFrm() ) |
| // { |
| // SWRECTFN( pUp ) |
| // const Point aPt( (pUp->Frm().*fnRect->fnGetPos)() ); |
| // ::DeepCalc( pUp ); |
| // bContinue = aPt != (pUp->Frm().*fnRect->fnGetPos)(); |
| // } |
| // } |
| // else |
| // pUp = pFrm; |
| |
| // pFrm->Calc(); |
| // if ( bSetComplete && (aOldFrm != pFrm->Frm() || aOldPrt != pFrm->Prt())) |
| // pFrm->SetCompletePaint(); |
| |
| // if ( pUp->IsFlyFrm() ) |
| // { |
| // if ( ((SwFlyFrm*)pUp)->IsLocked() || |
| // (((SwFlyFrm*)pUp)->IsFlyAtCntFrm() && |
| // SwOszControl::IsInProgress( (const SwFlyFrm*)pUp )) ) |
| // { |
| // bContinue = sal_False; |
| // } |
| // } |
| // } while ( bContinue ); |
| //} |
| |
| /** method to assure that anchored object is registered at the correct |
| page frame |
| |
| OD 2004-07-02 #i28701# |
| takes over functionality of deleted method <SwFlyAtCntFrm::AssertPage()> |
| |
| @author OD |
| */ |
| void SwFlyAtCntFrm::RegisterAtCorrectPage() |
| { |
| SwPageFrm* pPageFrm( 0L ); |
| if ( GetVertPosOrientFrm() ) |
| { |
| pPageFrm = const_cast<SwPageFrm*>(GetVertPosOrientFrm()->FindPageFrm()); |
| } |
| if ( pPageFrm && GetPageFrm() != pPageFrm ) |
| { |
| if ( GetPageFrm() ) |
| GetPageFrm()->MoveFly( this, pPageFrm ); |
| else |
| pPageFrm->AppendFlyToPage( this ); |
| } |
| } |
| |
| // OD 2004-03-23 #i26791# |
| //void SwFlyAtCntFrm::MakeFlyPos() |
| void SwFlyAtCntFrm::MakeObjPos() |
| { |
| // OD 02.10.2002 #102646# |
| // if fly frame position is valid, nothing is to do. Thus, return |
| if ( bValidPos ) |
| { |
| return; |
| } |
| |
| // OD 2004-03-24 #i26791# - validate position flag here. |
| bValidPos = sal_True; |
| |
| // --> OD 2004-10-22 #i35911# - no calculation of new position, if |
| // anchored object is marked that it clears its environment and its |
| // environment is already cleared. |
| // --> OD 2006-01-02 #125977# - before checking for cleared environment |
| // check, if member <mpVertPosOrientFrm> is set. |
| if ( GetVertPosOrientFrm() && |
| ClearedEnvironment() && HasClearedEnvironment() ) |
| { |
| return; |
| } |
| // <-- |
| |
| // OD 29.10.2003 #113049# - use new class to position object |
| objectpositioning::SwToCntntAnchoredObjectPosition |
| aObjPositioning( *GetVirtDrawObj() ); |
| aObjPositioning.CalcPosition(); |
| |
| SetVertPosOrientFrm ( aObjPositioning.GetVertPosOrientFrm() ); |
| } |
| |
| // OD 2004-05-12 #i28701# |
| bool SwFlyAtCntFrm::_InvalidationAllowed( const InvalidationType _nInvalid ) const |
| { |
| bool bAllowed( SwFlyFreeFrm::_InvalidationAllowed( _nInvalid ) ); |
| |
| // forbiddance of base instance can't be over ruled. |
| if ( bAllowed ) |
| { |
| if ( _nInvalid == INVALID_POS || |
| _nInvalid == INVALID_ALL ) |
| { |
| bAllowed = InvalidationOfPosAllowed(); |
| } |
| } |
| |
| return bAllowed; |
| } |
