Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / core / frmedt / fefly1.cxx
blob: f512519e9507bf87a594930cb27e86006ac5665d [file] [log] [blame]
/**************************************************************
*
* 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 <hintids.hxx>
#include <svl/itemiter.hxx>
#include <svtools/imapobj.hxx>
#include <svtools/soerr.hxx>
#include <editeng/protitem.hxx>
#include <svx/svdogrp.hxx>
#include <svx/svdouno.hxx>
#include <svx/fmglob.hxx>
#include <com/sun/star/form/FormButtonType.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <fmtanchr.hxx>
#include <txtflcnt.hxx>
#include <fmtcntnt.hxx>
#include <fmtornt.hxx>
#include <fmtflcnt.hxx>
#include <fmturl.hxx>
#include <fmtclds.hxx>
#include <fmtfsize.hxx>
#include <docary.hxx>
#include <fesh.hxx>
#include <rootfrm.hxx>
#include <pagefrm.hxx>
#include <cntfrm.hxx>
#include <txtfrm.hxx>
#include <viewimp.hxx>
#include <viscrs.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <dview.hxx>
#include <dflyobj.hxx>
#include <dcontact.hxx>
#include <frmfmt.hxx>
#include <flyfrm.hxx>
#include <ndtxt.hxx>
#include <edimp.hxx>
#include <swtable.hxx>
#include <mvsave.hxx> // Strukturen zum Sichern beim Move/Delete
#include <ndgrf.hxx>
#include <flyfrms.hxx>
#include <flypos.hxx>
#include <fldbas.hxx>
#include <fmtfld.hxx>
#include <swundo.hxx>
#include <frame.hxx>
#include <notxtfrm.hxx>
// --> OD 2006-03-06 #125892#
#include <HandleAnchorNodeChg.hxx>
// <--
#include <frmatr.hxx>
// --> 3.7.2010 #i972#
#include <ndole.hxx>
// <--
// --> OD 2009-12-29 #i89920#
#include <fmtsrnd.hxx>
#include <editeng/opaqitem.hxx>
// <--
using ::rtl::OUString;
using namespace ::com::sun::star;
//Zum anmelden von Flys in Flys in ...
//definiert in layout/frmtool.cxx
void RegistFlys( SwPageFrm*, const SwLayoutFrm* );
/***********************************************************************
#* Class : SwDoc
#* Methode : UseSpzLayoutFmt
#* Beschreibung: Anhand des Request werden zu dem Format entsprechende
#* Aenderungen an den Spezifischen Layouts vorgenommen.
#* Datum : MA 23. Sep. 92
#* Update : JP 09.03.98
#***********************************************************************/
sal_Bool lcl_SetNewFlyPos( const SwNode& rNode, SwFmtAnchor& rAnchor,
const Point& rPt )
{
sal_Bool bRet = sal_False;
const SwStartNode* pStNode = rNode.FindFlyStartNode();
if( pStNode )
{
SwPosition aPos( *pStNode );
rAnchor.SetAnchor( &aPos );
bRet = sal_True;
}
else
{
const SwCntntNode *pCntNd = rNode.GetCntntNode();
const SwCntntFrm* pCFrm = pCntNd ? pCntNd->getLayoutFrm( pCntNd->GetDoc()->GetCurrentLayout(), &rPt, 0, sal_False ) : 0;
const SwPageFrm *pPg = pCFrm ? pCFrm->FindPageFrm() : 0;
rAnchor.SetPageNum( pPg ? pPg->GetPhyPageNum() : 1 );
rAnchor.SetType( FLY_AT_PAGE );
}
return bRet;
}
sal_Bool lcl_FindAnchorPos(
SwEditShell& rEditShell,
SwDoc& rDoc,
const Point& rPt,
const SwFrm& rFrm,
SfxItemSet& rSet )
{
sal_Bool bRet = sal_True;
SwFmtAnchor aNewAnch( (SwFmtAnchor&)rSet.Get( RES_ANCHOR ) );
RndStdIds nNew = aNewAnch.GetAnchorId();
const SwFrm *pNewAnch;
//Neuen Anker ermitteln
Point aTmpPnt( rPt );
switch( nNew )
{
case FLY_AS_CHAR: // sollte der nicht auch mit hinein?
case FLY_AT_PARA:
case FLY_AT_CHAR: // LAYER_IMPL
{
//Ausgehend von der linken oberen Ecke des Fly den
//dichtesten CntntFrm suchen.
const SwFrm* pFrm = rFrm.IsFlyFrm() ? ((SwFlyFrm&)rFrm).GetAnchorFrm()
: &rFrm;
pNewAnch = ::FindAnchor( pFrm, aTmpPnt );
if( pNewAnch->IsProtected() )
{
bRet = sal_False;
break;
}
SwPosition aPos( *((SwCntntFrm*)pNewAnch)->GetNode() );
if ((FLY_AT_CHAR == nNew) || (FLY_AS_CHAR == nNew))
{
// es muss ein TextNode gefunden werden, denn nur in diesen
// ist ein Inhaltsgebundene Frames zu verankern
SwCrsrMoveState aState( MV_SETONLYTEXT );
aTmpPnt.X() -= 1; //nicht im Fly landen!!
if( !pNewAnch->GetCrsrOfst( &aPos, aTmpPnt, &aState ) )
{
SwCntntNode* pCNd = ((SwCntntFrm*)pNewAnch)->GetNode();
if( pNewAnch->Frm().Bottom() < aTmpPnt.Y() )
pCNd->MakeStartIndex( &aPos.nContent );
else
pCNd->MakeEndIndex( &aPos.nContent );
}
else
{
if ( rEditShell.PosInsideInputFld( aPos ) )
{
aPos.nContent = rEditShell.StartOfInputFldAtPos( aPos );
}
}
}
aNewAnch.SetAnchor( &aPos );
}
break;
case FLY_AT_FLY: // LAYER_IMPL
{
//Ausgehend von der linken oberen Ecke des Fly den
//dichtesten SwFlyFrm suchen.
SwCrsrMoveState aState( MV_SETONLYTEXT );
SwPosition aPos( rDoc.GetNodes() );
aTmpPnt.X() -= 1; //nicht im Fly landen!!
rDoc.GetCurrentLayout()->GetCrsrOfst( &aPos, aTmpPnt, &aState ); //swmod 071108//swmod 071225
pNewAnch = ::FindAnchor(
aPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( rFrm.getRootFrm(), 0, 0, sal_False ),
aTmpPnt )->FindFlyFrm();
if( pNewAnch && &rFrm != pNewAnch && !pNewAnch->IsProtected() )
{
aPos.nNode = *((SwFlyFrm*)pNewAnch)->GetFmt()->GetCntnt().
GetCntntIdx();
aNewAnch.SetAnchor( &aPos );
break;
}
}
aNewAnch.SetType( nNew = FLY_AT_PAGE );
// no break
case FLY_AT_PAGE:
pNewAnch = rFrm.FindPageFrm();
aNewAnch.SetPageNum( pNewAnch->GetPhyPageNum() );
break;
default:
ASSERT( !&rDoc, "Falsche ID fuer neuen Anker." );
}
rSet.Put( aNewAnch );
return bRet;
}
//
//! also used in unoframe.cxx
//
sal_Bool lcl_ChkAndSetNewAnchor(
SwEditShell& rEditShell,
const SwFlyFrm& rFly,
SfxItemSet& rSet )
{
const SwFrmFmt& rFmt = *rFly.GetFmt();
const SwFmtAnchor &rOldAnch = rFmt.GetAnchor();
const RndStdIds nOld = rOldAnch.GetAnchorId();
RndStdIds nNew = ((SwFmtAnchor&)rSet.Get( RES_ANCHOR )).GetAnchorId();
if( nOld == nNew )
return sal_False;
SwDoc* pDoc = (SwDoc*)rFmt.GetDoc();
#ifdef DBG_UTIL
ASSERT( !(nNew == FLY_AT_PAGE &&
(FLY_AT_PARA==nOld || FLY_AT_CHAR==nOld || FLY_AS_CHAR==nOld ) &&
pDoc->IsInHeaderFooter( rOldAnch.GetCntntAnchor()->nNode )),
"Unerlaubter Ankerwechsel in Head/Foot." );
#endif
return ::lcl_FindAnchorPos( rEditShell, *pDoc, rFly.Frm().Pos(), rFly, rSet );
}
void SwFEShell::SelectFlyFrm( SwFlyFrm& rFrm, sal_Bool bNew )
{
SET_CURR_SHELL( this );
// Wenn es ein neuer Rahmen ist, so soll er selektiert sein.
// !!Rahmen immer selektieren, wenn sie nicht selektiert sind.
// - Es kann ein neuer 'alter' sein weil der Anker gewechselt wurde.
// - 'alte' Rahmen sind vorher immer selektiert denn sonst wird nix
// an ihnen veraendert.
// Der Rahmen darf nicht per Dokumentposition selektiert werden, weil er
// auf jedenfall selektiert sein muss!
SwViewImp *pImpl = Imp();
if( GetWin() && (bNew || !pImpl->GetDrawView()->AreObjectsMarked()) )
{
ASSERT( rFrm.IsFlyFrm(), "SelectFlyFrm will einen Fly" );
//Wenn der Fly bereits selektiert ist gibt es hier ja wohl nichts
//zu tun.
if ( FindFlyFrm() == &rFrm )
return;
//Damit der Anker ueberhaupt noch gepaintet wird.
if( rFrm.IsFlyInCntFrm() && rFrm.GetAnchorFrm() )
rFrm.GetAnchorFrm()->SetCompletePaint();
// --> OD 2004-06-11 #i28701# - no format at all.
// //Hier wurde immer kalkuliert. Leider ist der Sonderfall Fly in Fly mit
// //Spalten u.U. sehr kritisch wenn der innenliegende zuerst formatiert
// //wird. Um kein Risiko einzugehen entschaerfen wir nur diesen Sonderfall.
// if( !rFrm.GetAnchorFrm()->IsInFly() )
// rFrm.Calc();
if( pImpl->GetDrawView()->AreObjectsMarked() )
pImpl->GetDrawView()->UnmarkAll();
pImpl->GetDrawView()->MarkObj( rFrm.GetVirtDrawObj(),
pImpl->GetPageView(), sal_False, sal_False );
KillPams();
ClearMark();
SelFlyGrabCrsr();
}
}
/*************************************************************************
|*
|* SwFEShell::FindFlyFrm()
|*
|* Beschreibung Liefert den Fly wenn einer Selektiert ist.
|* Ersterstellung MA 03. Nov. 92
|* Letzte Aenderung MA 05. Mar. 96
|*
*************************************************************************/
SwFlyFrm *SwFEShell::FindFlyFrm() const
{
if ( Imp()->HasDrawView() )
{
// Ein Fly ist genau dann erreichbar, wenn er selektiert ist.
const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
if( rMrkList.GetMarkCount() != 1 )
return 0;
SdrObject *pO = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
return ( pO && pO->ISA(SwVirtFlyDrawObj) ) ? ((SwVirtFlyDrawObj*)pO)->GetFlyFrm() : 0;
}
return 0;
}
/*************************************************************************
|*
|* SwFEShell::IsFlyInFly()
|*
|* Beschreibung Liefert sal_True, wenn der aktuelle Fly an einem anderen
|* verankert werden koennte (also innerhalb ist)
|* Ersterstellung AMA 11. Sep. 97
|* Letzte Aenderung AMA 14. Jan. 98
|*
*************************************************************************/
const SwFrmFmt* SwFEShell::IsFlyInFly()
{
SET_CURR_SHELL( this );
if ( !Imp()->HasDrawView() )
return NULL;
const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
if ( !rMrkList.GetMarkCount() )
{
SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
if( !pCntnt )
return NULL;
SwFlyFrm *pFly = pCntnt->FindFlyFrm();
if ( !pFly )
return NULL;
return pFly->GetFmt();
}
else if ( rMrkList.GetMarkCount() != 1 ||
!GetUserCall(rMrkList.GetMark( 0 )->GetMarkedSdrObj()) )
return NULL;
SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
SwFrmFmt *pFmt = FindFrmFmt( pObj );
if( pFmt && FLY_AT_FLY == pFmt->GetAnchor().GetAnchorId() )
{
const SwFrm* pFly = pObj->ISA(SwVirtFlyDrawObj) ?
((SwVirtFlyDrawObj*)pObj)->GetFlyFrm()->GetAnchorFrm() :
((SwDrawContact*)GetUserCall(pObj))->GetAnchorFrm( pObj );
ASSERT( pFly, "IsFlyInFly: Where's my anchor?" );
ASSERT( pFly->IsFlyFrm(), "IsFlyInFly: Funny anchor!" );
return ((SwFlyFrm*)pFly)->GetFmt();
}
Point aTmpPos = pObj->GetCurrentBoundRect().TopLeft();
SwFrm *pTxtFrm;
{
SwCrsrMoveState aState( MV_SETONLYTEXT );
SwNodeIndex aSwNodeIndex( GetDoc()->GetNodes() );
SwPosition aPos( aSwNodeIndex );
Point aPoint( aTmpPos );
aPoint.X() -= 1; //nicht im Fly landen!!
GetLayout()->GetCrsrOfst( &aPos, aPoint, &aState );
// OD 01.07.2003 #108784# - determine text frame by left-top-corner
// of object
//pTxtFrm = aPos.nNode.GetNode().GetCntntNode()->GetFrm( 0, 0, sal_False );
pTxtFrm = aPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( GetLayout(), &aTmpPos, 0, sal_False );
}
const SwFrm *pTmp = ::FindAnchor( pTxtFrm, aTmpPos );
const SwFlyFrm *pFly = pTmp->FindFlyFrm();
if( pFly )
return pFly->GetFmt();
return NULL;
}
/*************************************************************************
|*
|* SwFEShell::SetFlyPos
|*
|* Ersterstellung MA 14. Jan. 93
|* Letzte Aenderung MA 14. Feb. 95
|*
*************************************************************************/
void SwFEShell::SetFlyPos( const Point& rAbsPos )
{
SET_CURR_SHELL( this );
//Bezugspunkt in Dokumentkoordinaten bestimmen
SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
if( !pCntnt )
return;
SwFlyFrm *pFly = pCntnt->FindFlyFrm();
if ( !pFly )
return;
//SwSaveHdl aSaveX( Imp() );
//Bei Absatzgebundenen Flys muss ausgehend von der absoluten
//Position ein neuer Anker gesetzt werden. Anker und neue RelPos werden
//vom Fly selbst berechnet und gesetzt.
if ( pFly->IsFlyAtCntFrm() )
((SwFlyAtCntFrm*)pFly)->SetAbsPos( rAbsPos );
else
{
const SwFrm *pAnch = pFly->GetAnchorFrm();
// --> OD 2004-06-11 #i28701# - no format here
// pAnch->Calc();
Point aOrient( pAnch->Frm().Pos() );
if ( pFly->IsFlyInCntFrm() )
aOrient.X() = rAbsPos.X();
//RelPos errechnen.
aOrient.X() = rAbsPos.X() - aOrient.X();
aOrient.Y() = rAbsPos.Y() - aOrient.Y();
pFly->ChgRelPos( aOrient );
}
// --> OD 2004-06-11 #i28701# - no format here
// pFly->Calc();
CallChgLnk(); // rufe das AttrChangeNotify auf der UI-Seite.
}
/*************************************************************************
|*
|* SwFEShell::FindAnchorPos
|*
|* Ersterstellung AMA 24. Sep. 97
|* Letzte Aenderung AMA 24. Sep. 97
|*
*************************************************************************/
Point SwFEShell::FindAnchorPos( const Point& rAbsPos, sal_Bool bMoveIt )
{
Point aRet;
SET_CURR_SHELL( this );
if ( !Imp()->HasDrawView() )
return aRet;
const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
if ( rMrkList.GetMarkCount() != 1 ||
!GetUserCall(rMrkList.GetMark( 0 )->GetMarkedSdrObj()) )
return aRet;
SdrObject* pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
// --> OD 2004-07-16 #i28701#
SwAnchoredObject* pAnchoredObj = ::GetUserCall( pObj )->GetAnchoredObj( pObj );
SwFrmFmt& rFmt = pAnchoredObj->GetFrmFmt();
const RndStdIds nAnchorId = rFmt.GetAnchor().GetAnchorId();
if ( FLY_AS_CHAR == nAnchorId )
return aRet;
sal_Bool bFlyFrame = pObj->ISA(SwVirtFlyDrawObj);
SwFlyFrm* pFly = 0L;
const SwFrm* pOldAnch;
const SwFrm* pFooterOrHeader = NULL;
if( bFlyFrame )
{
//Bezugspunkt in Dokumentkoordinaten bestimmen
SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
if( !pCntnt )
return aRet;
pFly = pCntnt->FindFlyFrm();
if ( !pFly )
return aRet;
pOldAnch = pFly->GetAnchorFrm();
if( !pOldAnch )
return aRet;
if ( FLY_AT_PAGE != nAnchorId )
{
pFooterOrHeader = pCntnt->FindFooterOrHeader();
}
}
// OD 26.06.2003 #108784# - set <pFooterOrHeader> also for drawing
// objects, but not for control objects.
// Necessary for moving 'anchor symbol' at the user interface inside header/footer.
else if ( !::CheckControlLayer( pObj ) )
{
SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
if( !pCntnt )
return aRet;
pFooterOrHeader = pCntnt->FindFooterOrHeader();
}
SwCntntFrm *pTxtFrm = NULL;
{
SwCrsrMoveState aState( MV_SETONLYTEXT );
SwPosition aPos( GetDoc()->GetNodes().GetEndOfExtras() );
Point aTmpPnt( rAbsPos );
GetLayout()->GetCrsrOfst( &aPos, aTmpPnt, &aState );
if ( nAnchorId != FLY_AT_CHAR
|| !PosInsideInputFld( aPos ) )
{
pTxtFrm = aPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( GetLayout(),0,&aPos,sal_False );
}
}
const SwFrm *pNewAnch = NULL;
if( pTxtFrm != NULL )
{
if ( FLY_AT_PAGE == nAnchorId )
{
pNewAnch = pTxtFrm->FindPageFrm();
}
else
{
pNewAnch = ::FindAnchor( pTxtFrm, rAbsPos );
if( FLY_AT_FLY == nAnchorId ) // LAYER_IMPL
{
pNewAnch = pNewAnch->FindFlyFrm();
}
}
}
if( pNewAnch && !pNewAnch->IsProtected() )
{
const SwFlyFrm* pCheck = bFlyFrame ? pNewAnch->FindFlyFrm() : 0;
// Falls wir innerhalb eines Rahmens landen, muss sichergestellt werden,
// dass der Rahmen nicht in seinem eigenen Inhalt landet!
while( pCheck )
{
if( pCheck == pFly )
break;
const SwFrm *pTmp = pCheck->GetAnchorFrm();
pCheck = pTmp ? pTmp->FindFlyFrm() : NULL;
}
// Es darf nicht aus einer Kopf-/Fusszeile in einen anderen Bereich
// gewechselt werden, es darf nicht in eine Kopf-/Fusszeile hinein-
// gewechselt werden.
if( !pCheck &&
pFooterOrHeader == pNewAnch->FindFooterOrHeader() )
{
aRet = pNewAnch->GetFrmAnchorPos( ::HasWrap( pObj ) );
if ( bMoveIt || (nAnchorId == FLY_AT_CHAR) )
{
SwFmtAnchor aAnch( rFmt.GetAnchor() );
switch ( nAnchorId )
{
case FLY_AT_PARA:
{
SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
pPos->nNode = *pTxtFrm->GetNode();
pPos->nContent.Assign(0,0);
break;
}
case FLY_AT_PAGE:
{
aAnch.SetPageNum( ((const SwPageFrm*)pNewAnch)->
GetPhyPageNum() );
break;
}
case FLY_AT_FLY:
{
SwPosition aPos( *((SwFlyFrm*)pNewAnch)->GetFmt()->
GetCntnt().GetCntntIdx() );
aAnch.SetAnchor( &aPos );
break;
}
case FLY_AT_CHAR:
{
SwPosition *pPos = (SwPosition*)aAnch.GetCntntAnchor();
Point aTmpPnt( rAbsPos );
if( pTxtFrm->GetCrsrOfst( pPos, aTmpPnt, NULL ) )
{
SwRect aTmpRect;
pTxtFrm->GetCharRect( aTmpRect, *pPos );
aRet = aTmpRect.Pos();
}
else
{
pPos->nNode = *pTxtFrm->GetNode();
pPos->nContent.Assign(0,0);
}
break;
}
default:
break;
}
if( bMoveIt )
{
StartAllAction();
// --> OD 2006-02-28 #125892#
// 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* pHandleAnchorNodeChg( 0L );
SwFlyFrmFmt* pFlyFrmFmt( dynamic_cast<SwFlyFrmFmt*>(&rFmt) );
if ( pFlyFrmFmt )
{
pHandleAnchorNodeChg =
new SwHandleAnchorNodeChg( *pFlyFrmFmt, aAnch );
}
rFmt.GetDoc()->SetAttr( aAnch, rFmt );
delete pHandleAnchorNodeChg;
}
// <--
// --> OD 2004-06-24 #i28701# - no call of method
// <CheckCharRectAndTopOfLine()> for to-character anchored
// Writer fly frame needed. This method call can cause a
// format of the anchor frame, which is no longer intended.
// Instead clear the anchor character rectangle and
// the top of line values for all to-character anchored objects.
pAnchoredObj->ClearCharRectAndTopOfLine();
// <--
EndAllAction();
}
}
SwRect aTmpRect( aRet, rAbsPos );
if( aTmpRect.HasArea() )
MakeVisible( aTmpRect );
#ifdef DBG_UTIL
//TODO: That doesn't seem to be intended
if( Color(COL_TRANSPARENT) != GetOut()->GetLineColor() )
{
ASSERT( sal_False, "Hey, Joe: Where's my Null Pen?" );
GetOut()->SetLineColor( Color(COL_TRANSPARENT) );
}
#endif
}
}
return aRet;
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : NewFlyFrm
#* Beschreibung:
#* Datum : MA 03. Nov. 92
#* Update : JP 11. Aug. 93
#***********************************************************************/
const SwFrmFmt *SwFEShell::NewFlyFrm( const SfxItemSet& rSet, sal_Bool bAnchValid,
SwFrmFmt *pParent )
{
SET_CURR_SHELL( this );
StartAllAction();
SwPaM* pCrsr = GetCrsr();
const Point aPt( GetCrsrDocPos() );
SwSelBoxes aBoxes;
sal_Bool bMoveCntnt = sal_True;
if( IsTableMode() )
{
GetTblSel( *this, aBoxes );
if( aBoxes.Count() )
{
// die Crsr muessen noch aus dem Loeschbereich entfernt
// werden. Setze sie immer hinter/auf die Tabelle; ueber die
// Dokument-Position werden sie dann immer an die alte
// Position gesetzt.
ParkCrsr( SwNodeIndex( *aBoxes[0]->GetSttNd() ));
// --> FME 2005-12-01 #i127787# pCurCrsr will be deleted in ParkCrsr,
// we better get the current pCurCrsr instead of working with the
// deleted one:
pCrsr = GetCrsr();
// <--
// KillPams();
}
else
bMoveCntnt = sal_False;
}
else if( !pCrsr->HasMark() && pCrsr->GetNext() == pCrsr )
bMoveCntnt = sal_False;
const SwPosition& rPos = *pCrsr->Start();
SwFmtAnchor& rAnch = (SwFmtAnchor&)rSet.Get( RES_ANCHOR );
RndStdIds eRndId = rAnch.GetAnchorId();
switch( eRndId )
{
case FLY_AT_PAGE:
if( !rAnch.GetPageNum() ) //HotFix: Bug in UpdateByExample
rAnch.SetPageNum( 1 );
break;
case FLY_AT_FLY:
case FLY_AT_PARA:
case FLY_AT_CHAR:
case FLY_AS_CHAR:
if( !bAnchValid )
{
if( FLY_AT_FLY != eRndId )
{
rAnch.SetAnchor( &rPos );
}
else if( lcl_SetNewFlyPos( rPos.nNode.GetNode(), rAnch, aPt ) )
{
eRndId = FLY_AT_PAGE;
}
}
break;
default:
ASSERT( !this, "Was sollte das fuer ein Fly werden?" )
break;
}
SwFlyFrmFmt *pRet;
if( bMoveCntnt )
{
GetDoc()->GetIDocumentUndoRedo().StartUndo( UNDO_INSLAYFMT, NULL );
SwFmtAnchor* pOldAnchor = 0;
sal_Bool bHOriChgd = sal_False, bVOriChgd = sal_False;
SwFmtVertOrient aOldV;
SwFmtHoriOrient aOldH;
if ( FLY_AT_PAGE != eRndId )
{
// erstmal als mit Seitenbindung, Absatz/Zeichenbindung erst wenn
// alles verschoben ist. Dann ist die Position gueltig!
// JP 13.05.98: ggfs. auch noch die Hori/Vert-Orientierung
// umsetzen, damit diese beim Umanker NICHT
// korrigiert wird
pOldAnchor = new SwFmtAnchor( rAnch );
const_cast<SfxItemSet&>(rSet).Put( SwFmtAnchor( FLY_AT_PAGE, 1 ) );
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == rSet.GetItemState( RES_HORI_ORIENT, sal_False, &pItem )
&& text::HoriOrientation::NONE == ((SwFmtHoriOrient*)pItem)->GetHoriOrient() )
{
bHOriChgd = sal_True;
aOldH = *((SwFmtHoriOrient*)pItem);
((SfxItemSet&)rSet).Put( SwFmtHoriOrient( 0, text::HoriOrientation::LEFT ) );
}
if( SFX_ITEM_SET == rSet.GetItemState( RES_VERT_ORIENT, sal_False, &pItem )
&& text::VertOrientation::NONE == ((SwFmtVertOrient*)pItem)->GetVertOrient() )
{
bVOriChgd = sal_True;
aOldV = *((SwFmtVertOrient*)pItem);
((SfxItemSet&)rSet).Put( SwFmtVertOrient( 0, text::VertOrientation::TOP ) );
}
}
pRet = GetDoc()->MakeFlyAndMove( *pCrsr, rSet, &aBoxes, pParent );
KillPams();
if( pOldAnchor )
{
if( pRet )
{
// neue Position bestimmen
//JP 24.03.97: immer ueber die Seitenbindung gehen - der
// chaos::Anchor darf nie im verschobenen Bereich
// liegen
pRet->DelFrms();
const SwFrm* pAnch = ::FindAnchor( GetLayout(), aPt, sal_False );
SwPosition aPos( *((SwCntntFrm*)pAnch)->GetNode() );
if ( FLY_AS_CHAR == eRndId )
{
aPos.nContent.Assign( ((SwCntntFrm*)pAnch)->GetNode(), 0 );
}
pOldAnchor->SetAnchor( &aPos );
// das verschieben von TabelleSelektion ist noch nicht
// Undofaehig - also darf das UmAnkern auch nicht
// aufgezeichnet werden.
bool const bDoesUndo =
GetDoc()->GetIDocumentUndoRedo().DoesUndo();
SwUndoId nLastUndoId(UNDO_EMPTY);
if (bDoesUndo &&
GetDoc()->GetIDocumentUndoRedo().GetLastUndoInfo(0,
& nLastUndoId))
{
if (UNDO_INSLAYFMT == nLastUndoId)
{
GetDoc()->GetIDocumentUndoRedo().DoUndo(false);
}
}
((SfxItemSet&)rSet).Put( *pOldAnchor );
if( bHOriChgd )
((SfxItemSet&)rSet).Put( aOldH );
if( bVOriChgd )
((SfxItemSet&)rSet).Put( aOldV );
GetDoc()->SetFlyFrmAttr( *pRet, (SfxItemSet&)rSet );
GetDoc()->GetIDocumentUndoRedo().DoUndo(bDoesUndo);
}
delete pOldAnchor;
}
GetDoc()->GetIDocumentUndoRedo().EndUndo( UNDO_INSLAYFMT, NULL );
}
else
/* #109161# If called from a shell try to propagate an
existing adjust item from rPos to the content node of the
new frame. */
pRet = GetDoc()->MakeFlySection( eRndId, &rPos, &rSet, pParent, sal_True );
if( pRet )
{
SwFlyFrm* pFrm = pRet->GetFrm( &aPt );
if( pFrm )
SelectFlyFrm( *pFrm, sal_True );
else
{
GetLayout()->SetAssertFlyPages();
pRet = 0;
}
}
EndAllActionAndCall();
return pRet;
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : Insert
#* Datum : ??
#* Update : MA 12. Sep. 94
#***********************************************************************/
void SwFEShell::Insert( const String& rGrfName, const String& rFltName,
const Graphic* pGraphic,
const SfxItemSet* pFlyAttrSet,
const SfxItemSet* pGrfAttrSet,
SwFrmFmt* pFrmFmt )
{
SwFlyFrmFmt* pFmt = 0;
SET_CURR_SHELL( this );
StartAllAction();
SwShellCrsr *pStartCursor = dynamic_cast<SwShellCrsr*>(this->GetSwCrsr());
SwShellCrsr *pCursor = pStartCursor;
do {
// Anker noch nicht oder unvollstaendig gesetzt ?
if( pFlyAttrSet )
{
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == pFlyAttrSet->GetItemState( RES_ANCHOR, sal_False,
&pItem ) )
{
SwFmtAnchor* pAnchor = (SwFmtAnchor*)pItem;
switch( pAnchor->GetAnchorId())
{
case FLY_AT_PARA:
case FLY_AT_CHAR: // LAYER_IMPL
case FLY_AS_CHAR:
if( !pAnchor->GetCntntAnchor() )
{
pAnchor->SetAnchor( pCursor->GetPoint() );
}
break;
case FLY_AT_FLY:
if( !pAnchor->GetCntntAnchor() )
{
lcl_SetNewFlyPos( *pCursor->GetNode(),
*pAnchor, GetCrsrDocPos() );
}
break;
case FLY_AT_PAGE:
if( !pAnchor->GetPageNum() )
{
pAnchor->SetPageNum( pCursor->GetPageNum(
sal_True, &pCursor->GetPtPos() ) );
}
break;
default :
break;
}
}
}
pFmt = GetDoc()->Insert(*pCursor, rGrfName,
rFltName, pGraphic,
pFlyAttrSet,
pGrfAttrSet, pFrmFmt );
ASSERT( pFmt, "Doc->Insert(notxt) failed." );
} while( (pCursor = dynamic_cast<SwShellCrsr*>(pCursor->GetNext()))
!= pStartCursor );
EndAllAction();
if( pFmt )
{
const Point aPt( GetCrsrDocPos() );
SwFlyFrm* pFrm = pFmt->GetFrm( &aPt );
if( pFrm )
SelectFlyFrm( *pFrm, sal_True );
else
GetLayout()->SetAssertFlyPages();
}
}
SwFlyFrmFmt* SwFEShell::InsertObject( const svt::EmbeddedObjectRef& xObj,
const SfxItemSet* pFlyAttrSet,
const SfxItemSet* pGrfAttrSet,
SwFrmFmt* pFrmFmt )
{
SwFlyFrmFmt* pFmt = 0;
SET_CURR_SHELL( this );
StartAllAction();
FOREACHPAM_START( this )
pFmt = GetDoc()->Insert(*PCURCRSR, xObj,
pFlyAttrSet, pGrfAttrSet, pFrmFmt );
ASSERT( pFmt, "Doc->Insert(notxt) failed." );
FOREACHPAM_END()
EndAllAction();
if( pFmt )
{
const Point aPt( GetCrsrDocPos() );
SwFlyFrm* pFrm = pFmt->GetFrm( &aPt );
if( pFrm )
SelectFlyFrm( *pFrm, sal_True );
else
GetLayout()->SetAssertFlyPages();
}
return pFmt;
}
void SwFEShell::InsertDrawObj( SdrObject& rDrawObj,
const Point& rInsertPosition )
{
SET_CURR_SHELL( this );
SfxItemSet rFlyAttrSet( GetDoc()->GetAttrPool(), aFrmFmtSetRange );
rFlyAttrSet.Put( SwFmtAnchor( FLY_AT_PARA ));
// --> OD 2009-12-29 #i89920#
rFlyAttrSet.Put( SwFmtSurround( SURROUND_THROUGHT ) );
rDrawObj.SetLayer( getIDocumentDrawModelAccess()->GetHeavenId() );
// <--
// find anchor position
SwPaM aPam( pDoc->GetNodes() );
{
SwCrsrMoveState aState( MV_SETONLYTEXT );
Point aTmpPt( rInsertPosition );
GetLayout()->GetCrsrOfst( aPam.GetPoint(), aTmpPt, &aState );
const SwFrm* pFrm = aPam.GetCntntNode()->getLayoutFrm( GetLayout(), 0, 0, sal_False );
const Point aRelPos( rInsertPosition.X() - pFrm->Frm().Left(),
rInsertPosition.Y() - pFrm->Frm().Top() );
rDrawObj.SetRelativePos( aRelPos );
::lcl_FindAnchorPos( *this, *GetDoc(), rInsertPosition, *pFrm, rFlyAttrSet );
}
// insert drawing object into the document creating a new <SwDrawFrmFmt> instance
SwDrawFrmFmt* pFmt = GetDoc()->InsertDrawObj( aPam, rDrawObj, rFlyAttrSet );
// move object to visible layer
SwContact* pContact = static_cast<SwContact*>(rDrawObj.GetUserCall());
if ( pContact )
{
pContact->MoveObjToVisibleLayer( &rDrawObj );
}
if ( pFmt )
{
// select drawing object
Imp()->GetDrawView()->MarkObj( &rDrawObj, Imp()->GetPageView(),
sal_False, sal_False );
}
else
{
GetLayout()->SetAssertFlyPages();
}
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : GetPageObjs
#* Datum : ??
#* Update : MA 11. Jan. 95
#***********************************************************************/
void SwFEShell::GetPageObjs( SvPtrarr& rFillArr )
{
if( rFillArr.Count() )
rFillArr.Remove( 0, rFillArr.Count() );
const SwFrmFmt* pFmt;
for( sal_uInt16 n = 0; n < pDoc->GetSpzFrmFmts()->Count(); ++n )
{
pFmt = (const SwFrmFmt*)(*pDoc->GetSpzFrmFmts())[n];
if (FLY_AT_PAGE == pFmt->GetAnchor().GetAnchorId())
{
rFillArr.Insert( (VoidPtr)pFmt, rFillArr.Count() );
}
}
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : SetPageFlysNewPage
#* Datum : ??
#* Update : MA 14. Feb. 95
#***********************************************************************/
void SwFEShell::SetPageObjsNewPage( SvPtrarr& rFillArr, int nOffset )
{
if( !rFillArr.Count() || !nOffset )
return;
StartAllAction();
StartUndo();
SwFrmFmt* pFmt;
long nNewPage;
SwRootFrm* pTmpRootFrm = GetLayout();//swmod 080317
sal_uInt16 nMaxPage = pTmpRootFrm->GetPageNum();
sal_Bool bTmpAssert = sal_False;
for( sal_uInt16 n = 0; n < rFillArr.Count(); ++n )
{
pFmt = (SwFrmFmt*)rFillArr[n];
if( USHRT_MAX != pDoc->GetSpzFrmFmts()->GetPos( pFmt ))
{
// FlyFmt ist noch gueltig, also behandeln
SwFmtAnchor aNewAnchor( pFmt->GetAnchor() );
if ((FLY_AT_PAGE != aNewAnchor.GetAnchorId()) ||
0 >= ( nNewPage = aNewAnchor.GetPageNum() + nOffset ) )
// chaos::Anchor wurde veraendert oder ungueltige SeitenNummer,
// also nicht veraendern !!
continue;
if( sal_uInt16(nNewPage) > nMaxPage )
{
if ( RES_DRAWFRMFMT == pFmt->Which() )
{
SwContact *pCon = pFmt->FindContactObj();
if( pCon )
((SwDrawContact*)pCon)->DisconnectFromLayout();
}
else
pFmt->DelFrms();
bTmpAssert = sal_True;
}
aNewAnchor.SetPageNum( sal_uInt16(nNewPage) );
pDoc->SetAttr( aNewAnchor, *pFmt );
}
}
if( bTmpAssert )
pTmpRootFrm->SetAssertFlyPages();
EndUndo();
EndAllAction();
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : GetFlyFrmAttr
#* Beschreibung: Alle Attribute in dem 'Koerbchen' werden mit den
#* Attributen des aktuellen FlyFrms gefuellt.
#* Sind Attribute nicht zu fuellen weil fehl am Platz oder
#* uneindeutig (Mehrfachtselektionen) so werden sie entfernt.
#* Datum : MA 03. Nov. 92
#* Update : MA 03. Feb. 94
#***********************************************************************/
sal_Bool SwFEShell::GetFlyFrmAttr( SfxItemSet &rSet ) const
{
SwFlyFrm *pFly = FindFlyFrm();
if ( !pFly )
{
// --> OD 2006-11-08 #139670# - make code robust
SwFrm* pCurrFrm( GetCurrFrm() );
if ( !pCurrFrm )
{
ASSERT( false,
"<SwFEShell::GetFlyFrmAttr(..)> - missing current frame. This is a serious defect, please inform OD." );
return sal_False;
}
// <--
pFly = GetCurrFrm()->FindFlyFrm();
if ( !pFly )
{
ASSERT( !this, "GetFlyFrmAttr, no Fly selected." );
return sal_False;
}
}
SET_CURR_SHELL( (ViewShell*)this );
if( !rSet.Set( pFly->GetFmt()->GetAttrSet(), sal_True ) )
return sal_False;
//Und die Attribute durchschaufeln. Unerlaubte Attribute entfernen, dann
//alle restlichen Attribute besorgen und eintragen.
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == rSet.GetItemState( RES_ANCHOR, sal_False, &pItem ) )
{
SwFmtAnchor* pAnchor = (SwFmtAnchor*)pItem;
RndStdIds eType = pAnchor->GetAnchorId();
if ( FLY_AT_PAGE != eType )
{
// OD 12.11.2003 #i22341# - content anchor of anchor item is needed.
// Thus, don't overwrite anchor item by default contructed anchor item.
//rSet.Put( SwFmtAnchor( eType ) );
if ( FLY_AS_CHAR == eType )
{
rSet.ClearItem( RES_OPAQUE );
rSet.ClearItem( RES_SURROUND );
}
}
}
rSet.SetParent( pFly->GetFmt()->GetAttrSet().GetParent() );
//JP 11.02.97: Bug #35894#: die Attribute MUESSEN entfern werden!
rSet.ClearItem( RES_FILL_ORDER );
rSet.ClearItem( RES_CNTNT );
//MA: Ersteinmal entfernen (Template by example usw.)
rSet.ClearItem( RES_CHAIN );
return sal_True;
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : SetFlyFrmAttr
#* Beschreibung: Die Attribute des aktuellen Flys aendern sich.
#* Datum : MA 03. Nov. 92
#* Update : MA 01. Aug. 95
#***********************************************************************/
sal_Bool SwFEShell::SetFlyFrmAttr( SfxItemSet& rSet )
{
SET_CURR_SHELL( this );
sal_Bool bRet = sal_False;
if( rSet.Count() )
{
SwFlyFrm *pFly = FindFlyFrm();
if( !pFly )
{
ASSERT( GetCurrFrm(), "Crsr in parking zone" );
pFly = GetCurrFrm()->FindFlyFrm();
ASSERT( pFly, "SetFlyFrmAttr, no Fly selected." );
}
if( pFly )
{
StartAllAction();
const Point aPt( pFly->Frm().Pos() );
if( SFX_ITEM_SET == rSet.GetItemState( RES_ANCHOR, sal_False ))
::lcl_ChkAndSetNewAnchor( *this, *pFly, rSet );
SwFlyFrmFmt* pFlyFmt = (SwFlyFrmFmt*)pFly->GetFmt();
if( GetDoc()->SetFlyFrmAttr( *pFlyFmt, rSet ))
{
bRet = sal_True;
SwFlyFrm* pFrm = pFlyFmt->GetFrm( &aPt );
if( pFrm )
SelectFlyFrm( *pFrm, sal_True );
else
GetLayout()->SetAssertFlyPages();
}
EndAllActionAndCall();
}
}
return bRet;
}
/*-- 30.03.2004 15:05:07---------------------------------------------------
-----------------------------------------------------------------------*/
sal_Bool SwFEShell::SetDrawingAttr( SfxItemSet& rSet )
{
sal_Bool bRet = sal_False;
SET_CURR_SHELL( this );
if ( !rSet.Count() ||
!Imp()->HasDrawView() )
return bRet;
const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
if ( rMrkList.GetMarkCount() != 1 )
return bRet;
StartUndo();
SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
SwFrmFmt *pFmt = FindFrmFmt( pObj );
StartAllAction();
if( SFX_ITEM_SET == rSet.GetItemState( RES_ANCHOR, sal_False ))
{
RndStdIds nNew = ((SwFmtAnchor&)rSet.Get( RES_ANCHOR )).GetAnchorId();
if ( nNew != pFmt->GetAnchor().GetAnchorId() )
{
ChgAnchor( nNew );
// --> OD 2004-06-17 #i26791# - clear anchor attribute in item set,
// because method <ChgAnchor(..)> takes care of it.
rSet.ClearItem( RES_ANCHOR );
}
}
if( GetDoc()->SetFlyFrmAttr( *pFmt, rSet ))
{
bRet = sal_True;
Point aTmp;
SelectObj( aTmp, 0, pObj );
}
EndAllActionAndCall();
EndUndo();
return bRet;
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : ResetFlyFrmAttr
#* Beschreibung: Das gewuenschte Attribut oder die im Set befindlichen
#* werden zurueckgesetzt.
#* Datum : MA 14. Mar. 97
#* Update : MA 14. Mar. 97
#***********************************************************************/
sal_Bool SwFEShell::ResetFlyFrmAttr( sal_uInt16 nWhich, const SfxItemSet* pSet )
{
sal_Bool bRet = sal_False;
if( RES_ANCHOR != nWhich && RES_CHAIN != nWhich && RES_CNTNT != nWhich )
{
SET_CURR_SHELL( this );
SwFlyFrm *pFly = FindFlyFrm();
if( !pFly )
{
ASSERT( GetCurrFrm(), "Crsr in parking zone" );
pFly = GetCurrFrm()->FindFlyFrm();
ASSERT( pFly, "SetFlyFrmAttr, no Fly selected." );
}
if( pFly )
{
StartAllAction();
if( pSet )
{
SfxItemIter aIter( *pSet );
const SfxPoolItem* pItem = aIter.FirstItem();
while( pItem )
{
if( !IsInvalidItem( pItem ) &&
RES_ANCHOR != ( nWhich = pItem->Which() ) &&
RES_CHAIN != nWhich && RES_CNTNT != nWhich )
pFly->GetFmt()->ResetFmtAttr( nWhich );
pItem = aIter.NextItem();
}
}
else
pFly->GetFmt()->ResetFmtAttr( nWhich );
bRet = sal_True;
EndAllActionAndCall();
GetDoc()->SetModified();
}
}
return bRet;
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : GetCurFrmFmt
#* Beschreibung: liefert wenn Rahmen, dann Rahmenvorlage, sonst 0
#* Datum : ST 04. Jun. 93
#* Update :
#***********************************************************************/
SwFrmFmt* SwFEShell::GetCurFrmFmt() const
{
SwFrmFmt* pRet = 0;
SwLayoutFrm *pFly = FindFlyFrm();
if( pFly && ( pRet = (SwFrmFmt*)pFly->GetFmt()->DerivedFrom() ) ==
GetDoc()->GetDfltFrmFmt() )
pRet = 0;
return pRet;
}
/******************************************************************************
* Methode : void SwFEShell::SetFrmFmt(SwFrmFmt *pNewFmt)
* Beschreibung:
* Erstellt : OK 14.04.94 15:40
* Aenderung : MA 23. Apr. 97
******************************************************************************/
void SwFEShell::SetFrmFmt( SwFrmFmt *pNewFmt, sal_Bool bKeepOrient, Point* pDocPos )
{
SwFlyFrm *pFly = 0;
if(pDocPos)
{
const SwFrmFmt* pFmt = GetFmtFromObj( *pDocPos );
if(PTR_CAST(SwFlyFrmFmt, pFmt))
pFly = ((SwFlyFrmFmt*)pFmt)->GetFrm();
}
else
pFly = FindFlyFrm();
ASSERT( pFly, "SetFrmFmt: kein Frame" );
if( pFly )
{
StartAllAction();
SET_CURR_SHELL( this );
SwFlyFrmFmt* pFlyFmt = (SwFlyFrmFmt*)pFly->GetFmt();
const Point aPt( pFly->Frm().Pos() );
SfxItemSet* pSet = 0;
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == pNewFmt->GetItemState( RES_ANCHOR, sal_False, &pItem ))
{
pSet = new SfxItemSet( GetDoc()->GetAttrPool(), aFrmFmtSetRange );
pSet->Put( *pItem );
if( !::lcl_ChkAndSetNewAnchor( *this, *pFly, *pSet ))
delete pSet, pSet = 0;
}
if( GetDoc()->SetFrmFmtToFly( *pFlyFmt, *pNewFmt, pSet, bKeepOrient ))
{
SwFlyFrm* pFrm = pFlyFmt->GetFrm( &aPt );
if( pFrm )
SelectFlyFrm( *pFrm, sal_True );
else
GetLayout()->SetAssertFlyPages();
}
if( pSet )
delete pSet;
EndAllActionAndCall();
}
}
/*************************************************************************
|*
|* SwFEShell::GetFlyFrmFmt()
|*
|* Ersterstellung OK 23.06.93 13:15
|* Letzte Aenderung OK 23.06.93 13:15
|*
*************************************************************************/
const SwFrmFmt* SwFEShell::GetFlyFrmFmt() const
{
const SwFlyFrm* pFly = FindFlyFrm();
if ( !pFly )
{
SwFrm* pCurrFrm = GetCurrFrm();
pFly = pCurrFrm ? pCurrFrm->FindFlyFrm() : 0;
}
if( pFly )
return pFly->GetFmt();
return 0;
}
SwFrmFmt* SwFEShell::GetFlyFrmFmt()
{
SwFlyFrm* pFly = FindFlyFrm();
if ( !pFly )
{
SwFrm* pCurrFrm = GetCurrFrm();
pFly = pCurrFrm ? pCurrFrm->FindFlyFrm() : 0;
}
if( pFly )
return pFly->GetFmt();
return 0;
}
/*************************************************************************
|*
|* SwFEShell::GetFlyRect()
|*
|* Ersterstellung AMA 6. Mae. 97
|* Letzte Aenderung AMA 6. Mae. 97
|*
*************************************************************************/
SwRect SwFEShell::GetFlyRect() const
{
SwCntntFrm *pCntnt = GetCurrFrm( sal_False );
SwFlyFrm *pFly = pCntnt ? pCntnt->FindFlyFrm() : 0;
if ( !pFly )
{
SwRect aRect;
return aRect;
}
else
return pFly->Frm();
}
/*************************************************************************
|*
|* SwFEShell::GetObjRect()
|*
|* Ersterstellung MA 22. Aug. 93
|* Letzte Aenderung MA 11. Jan. 95
|*
*************************************************************************/
SwRect SwFEShell::GetObjRect() const
{
if( Imp()->HasDrawView() )
return Imp()->GetDrawView()->GetAllMarkedRect();
else
{
SwRect aRect;
return aRect;
}
}
void SwFEShell::SetObjRect( const SwRect& rRect )
{
if ( Imp()->HasDrawView() )
{
Imp()->GetDrawView()->SetAllMarkedRect( rRect.SVRect() );
CallChgLnk(); // rufe das AttrChangeNotify auf der UI-Seite.
}
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : RequestObjectResize()
#* Datum : MA 10. Feb. 95
#* Update : MA 13. Jul. 95
#***********************************************************************/
Size SwFEShell::RequestObjectResize( const SwRect &rRect, const uno::Reference < embed::XEmbeddedObject >& xObj )
{
Size aResult;
SwFlyFrm *pFly = FindFlyFrm( xObj );
if ( !pFly )
{
aResult = rRect.SSize();
return aResult;
}
aResult = pFly->Prt().SSize();
sal_Bool bPosProt = pFly->GetFmt()->GetProtect().IsPosProtected();
sal_Bool bSizeProt = pFly->GetFmt()->GetProtect().IsSizeProtected();
StartAllAction();
//MA wir lassen den Fly nicht Clippen, damit die Ole-Server mit
//beliebigen Wuenschen kommen koennen. Die Formatierung uebernimmt das
//Clippen. Die richtige Darstellung wird per Scalierung erledigt.
//Die Scalierung wird von SwNoTxtFrm::Format durch einen Aufruf von
//SwWrtShell::CalcAndSetScale() erledigt.
if ( rRect.SSize() != pFly->Prt().SSize() && !bSizeProt )
{
Size aSz( rRect.SSize() );
//JP 28.02.2001: Task 74707 - ask for fly in fly with automatic size
//
const SwFrm* pAnchor;
const SwTxtNode* pTNd;
const SwpHints* pHts;
const SwFmtFrmSize& rFrmSz = pFly->GetFmt()->GetFrmSize();
if( bCheckForOLEInCaption &&
0 != rFrmSz.GetWidthPercent() &&
0 != (pAnchor = pFly->GetAnchorFrm()) &&
pAnchor->IsTxtFrm() &&
!pAnchor->GetNext() && !pAnchor->GetPrev() &&
pAnchor->GetUpper()->IsFlyFrm() &&
0 != ( pTNd = ((SwTxtFrm*)pAnchor)->GetNode()->GetTxtNode()) &&
0 != ( pHts = pTNd->GetpSwpHints() ))
{
// search for a sequence field:
const SfxPoolItem* pItem;
for( sal_uInt16 n = 0, nEnd = pHts->Count(); n < nEnd; ++n )
if( RES_TXTATR_FIELD == ( pItem = &(*pHts)[ n ]->GetAttr())->Which()
&& TYP_SEQFLD == ((SwFmtFld*)pItem)->GetField()->GetTypeId() )
{
// sequence field found
SwFlyFrm* pChgFly = (SwFlyFrm*)pAnchor->GetUpper();
// calculate the changed size:
// width must change, height can change
Size aNewSz( aSz.Width() + pChgFly->Frm().Width() -
pFly->Prt().Width(), aSz.Height() );
SwFrmFmt *pFmt = pChgFly->GetFmt();
SwFmtFrmSize aFrmSz( pFmt->GetFrmSize() );
aFrmSz.SetWidth( aNewSz.Width() );
if( ATT_MIN_SIZE != aFrmSz.GetHeightSizeType() )
{
aNewSz.Height() += pChgFly->Frm().Height() -
pFly->Prt().Height();
if( Abs( aNewSz.Height() - pChgFly->Frm().Height()) > 1 )
aFrmSz.SetHeight( aNewSz.Height() );
}
// uebers Doc fuers Undo!
pFmt->GetDoc()->SetAttr( aFrmSz, *pFmt );
break;
}
}
// set the new Size at the fly themself
if ( pFly->Prt().Height() > 0 && pFly->Prt().Width() > 0 )
{
aSz.Width() += pFly->Frm().Width() - pFly->Prt().Width();
aSz.Height()+= pFly->Frm().Height()- pFly->Prt().Height();
}
aResult = pFly->ChgSize( aSz );
//Wenn sich das Objekt aendert ist die Kontur hoechstwahrscheinlich daneben.
ASSERT( pFly->Lower()->IsNoTxtFrm(), "Request ohne NoTxt" );
SwNoTxtNode *pNd = ((SwCntntFrm*)pFly->Lower())->GetNode()->GetNoTxtNode();
ASSERT( pNd, "Request ohne Node" );
pNd->SetContour( 0 );
ClrContourCache();
}
//Wenn nur die Size angepasst werden soll, so wird eine Pos mit
//ausgezeichneten Werten transportiert.
Point aPt( pFly->Prt().Pos() );
aPt += pFly->Frm().Pos();
if ( rRect.Top() != LONG_MIN && rRect.Pos() != aPt && !bPosProt )
{
aPt = rRect.Pos();
aPt.X() -= pFly->Prt().Left();
aPt.Y() -= pFly->Prt().Top();
//Bei Absatzgebundenen Flys muss ausgehend von der neuen Position ein
//neuer Anker gesetzt werden. Anker und neue RelPos werden vom Fly
//selbst berechnet und gesetzt.
if( pFly->IsFlyAtCntFrm() )
((SwFlyAtCntFrm*)pFly)->SetAbsPos( aPt );
else
{
const SwFrmFmt *pFmt = pFly->GetFmt();
const SwFmtVertOrient &rVert = pFmt->GetVertOrient();
const SwFmtHoriOrient &rHori = pFmt->GetHoriOrient();
const long lXDiff = aPt.X() - pFly->Frm().Left();
const long lYDiff = aPt.Y() - pFly->Frm().Top();
const Point aTmp( rHori.GetPos() + lXDiff,
rVert.GetPos() + lYDiff );
pFly->ChgRelPos( aTmp );
}
}
SwFlyFrmFmt *pFlyFrmFmt = pFly->GetFmt();
ASSERT( pFlyFrmFmt, "fly frame format missing!" );
if ( pFlyFrmFmt )
pFlyFrmFmt->SetLastFlyFrmPrtRectPos( pFly->Prt().Pos() ); //stores the value of last Prt rect
EndAllAction();
return aResult;
}
/***********************************************************************
#* Class : SwFEShell
#* Methode : WizzardFindCurFrmFmt
#* Datum : JP 31.07.95
#* Update : JP 31.07.95
#***********************************************************************/
SwFrmFmt* SwFEShell::WizzardGetFly()
{
// mal nicht uebers Layout den Fly suchen. Dann kann auch ohne gueltiges
// Layout ein Rahmen geloescht werden. ( z.B.: fuer die Wizard's )
SwSpzFrmFmts& rSpzArr = *pDoc->GetSpzFrmFmts();
sal_uInt16 nCnt = rSpzArr.Count();
if( nCnt )
{
SwNodeIndex& rCrsrNd = GetCrsr()->GetPoint()->nNode;
if( rCrsrNd.GetIndex() > pDoc->GetNodes().GetEndOfExtras().GetIndex() )
// Cusor steht im Body-Bereich!
return 0;
for( sal_uInt16 n = 0; n < nCnt; ++n )
{
SwFrmFmt* pFmt = rSpzArr[ n ];
const SwNodeIndex* pIdx = pFmt->GetCntnt( sal_False ).GetCntntIdx();
SwStartNode* pSttNd;
if( pIdx &&
0 != ( pSttNd = pIdx->GetNode().GetStartNode() ) &&
pSttNd->GetIndex() < rCrsrNd.GetIndex() &&
rCrsrNd.GetIndex() < pSttNd->EndOfSectionIndex() )
{
// gefunden: also raus damit
return pFmt;
}
}
}
return 0;
}
void SwFEShell::SetFlyName( const String& rName )
{
SwLayoutFrm *pFly = FindFlyFrm();
if( pFly )
GetDoc()->SetFlyName( *(SwFlyFrmFmt*)pFly->GetFmt(), rName );
else {
ASSERT( !this, "kein FlyFrame selektiert" )
}
}
const String& SwFEShell::GetFlyName() const
{
SwLayoutFrm *pFly = FindFlyFrm();
if( pFly )
return pFly->GetFmt()->GetName();
ASSERT( !this, "kein FlyFrame selektiert" )
return aEmptyStr;
}
const uno::Reference < embed::XEmbeddedObject > SwFEShell::GetOleRef() const
{
uno::Reference < embed::XEmbeddedObject > xObj;
SwFlyFrm * pFly = FindFlyFrm();
if (pFly && pFly->Lower() && pFly->Lower()->IsNoTxtFrm())
{
SwOLENode *pNd = ((SwNoTxtFrm*)pFly->Lower())->GetNode()->GetOLENode();
if (pNd)
xObj = pNd->GetOLEObj().GetOleRef();
}
return xObj;
}
String SwFEShell::GetUniqueGrfName() const
{
return GetDoc()->GetUniqueGrfName();
}
const SwFrmFmt* SwFEShell::IsURLGrfAtPos( const Point& rPt, String* pURL,
String *pTargetFrameName,
String *pDescription ) const
{
if( !Imp()->HasDrawView() )
return 0;
SdrObject* pObj;
SdrPageView* pPV;
const SwFrmFmt* pRet = 0;
SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
sal_uInt16 nOld = pDView->GetHitTolerancePixel();
pDView->SetHitTolerancePixel( 2 );
if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPV,SDRSEARCH_PICKMACRO ) &&
pObj->ISA(SwVirtFlyDrawObj) )
{
SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
const SwFmtURL &rURL = pFly->GetFmt()->GetURL();
if( rURL.GetURL().Len() || rURL.GetMap() )
{
sal_Bool bSetTargetFrameName = pTargetFrameName != 0;
sal_Bool bSetDescription = pDescription != 0;
if ( rURL.GetMap() )
{
IMapObject *pObject = pFly->GetFmt()->GetIMapObject( rPt, pFly );
if ( pObject && pObject->GetURL().Len() )
{
if( pURL )
*pURL = pObject->GetURL();
if ( bSetTargetFrameName && pObject->GetTarget().Len() )
{
bSetTargetFrameName = sal_False;
*pTargetFrameName = pObject->GetTarget();
}
if ( bSetDescription )
{
bSetDescription = sal_False;
*pDescription = pObject->GetAltText();
}
pRet = pFly->GetFmt();
}
}
else
{
if( pURL )
{
*pURL = rURL.GetURL();
if( rURL.IsServerMap() )
{
// dann die rel. Pixel Position anhaengen !!
Point aPt( rPt );
aPt -= pFly->Frm().Pos();
// ohne MapMode-Offset, ohne Offset, o ... !!!!!
aPt = GetOut()->LogicToPixel(
aPt, MapMode( MAP_TWIP ) );
((( *pURL += '?' ) += String::CreateFromInt32( aPt.X() ))
+= ',' ) += String::CreateFromInt32(aPt.Y() );
}
}
pRet = pFly->GetFmt();
}
if ( bSetTargetFrameName )
*pTargetFrameName = rURL.GetTargetFrameName();
if ( bSetDescription )
*pDescription = pFly->GetFmt()->GetName();
}
}
pDView->SetHitTolerancePixel( nOld );
return pRet;
}
const Graphic *SwFEShell::GetGrfAtPos( const Point &rPt,
String &rName, sal_Bool &rbLink ) const
{
if( !Imp()->HasDrawView() )
return 0;
SdrObject* pObj;
SdrPageView* pPV;
SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPV ) && pObj->ISA(SwVirtFlyDrawObj) )
{
SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
{
SwGrfNode *pNd = ((SwCntntFrm*)pFly->Lower())->GetNode()->GetGrfNode();
if ( pNd )
{
if ( pNd->IsGrfLink() )
{
//Halbfertige Grafik?
::sfx2::SvLinkSource* pLnkObj = pNd->GetLink()->GetObj();
if( pLnkObj && pLnkObj->IsPending() )
return 0;
rbLink = sal_True;
}
pNd->GetFileFilterNms( &rName, 0 );
if ( !rName.Len() )
rName = pFly->GetFmt()->GetName();
pNd->SwapIn( sal_True );
return &pNd->GetGrf();
}
}
}
return 0;
}
const SwFrmFmt* SwFEShell::GetFmtFromObj( const Point& rPt, SwRect** pRectToFill ) const
{
SwFrmFmt* pRet = 0;
if( Imp()->HasDrawView() )
{
SdrObject* pObj;
SdrPageView* pPView;
SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
sal_uInt16 nOld = pDView->GetHitTolerancePixel();
// Tattergrenze fuer Drawing-SS
pDView->SetHitTolerancePixel( pDView->GetMarkHdlSizePixel()/2 );
if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPView, SDRSEARCH_PICKMARKABLE ) )
{
// dann teste mal was es ist:
if ( pObj->ISA(SwVirtFlyDrawObj) )
pRet = ((SwVirtFlyDrawObj*)pObj)->GetFmt();
else if ( pObj->GetUserCall() ) //nicht fuer Gruppenobjekte
pRet = ((SwDrawContact*)pObj->GetUserCall())->GetFmt();
if(pRet && pRectToFill)
**pRectToFill = pObj->GetCurrentBoundRect();
}
pDView->SetHitTolerancePixel( nOld );
}
return pRet;
}
// returns a format too, if the point is over the text of any fly
const SwFrmFmt* SwFEShell::GetFmtFromAnyObj( const Point& rPt ) const
{
const SwFrmFmt* pRet = GetFmtFromObj( rPt );
if( !pRet || RES_FLYFRMFMT == pRet->Which() )
{
SwPosition aPos( *GetCrsr()->GetPoint() );
Point aPt( rPt );
GetLayout()->GetCrsrOfst( &aPos, aPt );
SwCntntNode *pNd = aPos.nNode.GetNode().GetCntntNode();
SwFrm* pFrm = pNd->getLayoutFrm( GetLayout(), &rPt, 0, sal_False )->FindFlyFrm();
pRet = pFrm ? ((SwLayoutFrm*)pFrm)->GetFmt() : 0;
}
return pRet;
}
ObjCntType SwFEShell::GetObjCntType( const SdrObject& rObj ) const
{
ObjCntType eType = OBJCNT_NONE;
// OD 23.06.2003 #108784# - investigate 'master' drawing object, if method
// is called for a 'virtual' drawing object.
const SdrObject* pInvestigatedObj;
if ( rObj.ISA(SwDrawVirtObj) )
{
const SwDrawVirtObj* pDrawVirtObj = static_cast<const SwDrawVirtObj*>(&rObj);
pInvestigatedObj = &(pDrawVirtObj->GetReferencedObj());
}
else
{
pInvestigatedObj = &rObj;
}
if( FmFormInventor == pInvestigatedObj->GetObjInventor() )
{
eType = OBJCNT_CONTROL;
uno::Reference< awt::XControlModel > xModel =
((SdrUnoObj&)(*pInvestigatedObj)).GetUnoControlModel();
if( xModel.is() )
{
uno::Any aVal;
OUString sName = OUString::createFromAscii("ButtonType");
uno::Reference< beans::XPropertySet > xSet(xModel, uno::UNO_QUERY);
uno::Reference< beans::XPropertySetInfo > xInfo = xSet->getPropertySetInfo();
if(xInfo->hasPropertyByName( sName ))
{
beans::Property xProperty = xInfo->getPropertyByName( sName );
aVal = xSet->getPropertyValue( sName );
if( aVal.getValue() && form::FormButtonType_URL == *((form::FormButtonType*)aVal.getValue()) )
eType = OBJCNT_URLBUTTON;
}
}
}
else if( pInvestigatedObj->ISA(SwVirtFlyDrawObj) )
{
SwFlyFrm *pFly = ((SwVirtFlyDrawObj&)(*pInvestigatedObj)).GetFlyFrm();
if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
{
if ( ((SwCntntFrm*)pFly->Lower())->GetNode()->GetGrfNode() )
eType = OBJCNT_GRF;
else
eType = OBJCNT_OLE;
}
else
eType = OBJCNT_FLY;
}
else if ( pInvestigatedObj->ISA( SdrObjGroup ) )
{
SwDrawContact* pDrawContact( dynamic_cast<SwDrawContact*>(GetUserCall( pInvestigatedObj ) ) );
if ( !pDrawContact )
{
ASSERT( false,
"<SwFEShell::GetObjCntType(..)> - missing draw contact object" );
eType = OBJCNT_NONE;
}
else
{
SwFrmFmt* pFrmFmt( pDrawContact->GetFmt() );
if ( !pFrmFmt )
{
ASSERT( false,
"<SwFEShell::GetObjCntType(..)> - missing frame format" );
eType = OBJCNT_NONE;
}
else if ( FLY_AS_CHAR != pFrmFmt->GetAnchor().GetAnchorId() )
{
eType = OBJCNT_GROUPOBJ;
}
}
}
else
eType = OBJCNT_SIMPLE;
return eType;
}
ObjCntType SwFEShell::GetObjCntType( const Point &rPt, SdrObject *&rpObj ) const
{
ObjCntType eType = OBJCNT_NONE;
if( Imp()->HasDrawView() )
{
SdrObject* pObj;
SdrPageView* pPView;
SwDrawView *pDView = (SwDrawView*)Imp()->GetDrawView();
sal_uInt16 nOld = pDView->GetHitTolerancePixel();
// Tattergrenze fuer Drawing-SS
pDView->SetHitTolerancePixel( pDView->GetMarkHdlSizePixel()/2 );
if( pDView->PickObj( rPt, pDView->getHitTolLog(), pObj, pPView, SDRSEARCH_PICKMARKABLE ) )
eType = GetObjCntType( *(rpObj = pObj) );
pDView->SetHitTolerancePixel( nOld );
}
return eType;
}
ObjCntType SwFEShell::GetObjCntTypeOfSelection( SdrObject** ppObj ) const
{
ObjCntType eType = OBJCNT_NONE;
if( Imp()->HasDrawView() )
{
const SdrMarkList &rMrkList = Imp()->GetDrawView()->GetMarkedObjectList();
for( sal_uInt32 i = 0, nE = rMrkList.GetMarkCount(); i < nE; ++i )
{
SdrObject* pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
if( !pObj )
continue;
ObjCntType eTmp = GetObjCntType( *pObj );
if( !i )
{
eType = eTmp;
if( ppObj ) *ppObj = pObj;
}
else if( eTmp != eType )
{
eType = OBJCNT_DONTCARE;
// einmal DontCare, immer DontCare!
break;
}
}
}
return eType;
}
sal_Bool SwFEShell::ReplaceSdrObj( const String& rGrfName, const String& rFltName,
const Graphic* pGrf )
{
SET_CURR_SHELL( this );
sal_Bool bRet = sal_False;
const SdrMarkList *pMrkList;
if( Imp()->HasDrawView() && 1 ==
( pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList())->GetMarkCount() )
{
SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
SwFrmFmt *pFmt = FindFrmFmt( pObj );
// Attribute sichern und dann an der Grafik setzen
SfxItemSet aFrmSet( pDoc->GetAttrPool(),
pFmt->GetAttrSet().GetRanges() );
aFrmSet.Set( pFmt->GetAttrSet() );
// Groesse und Position setzen ??
if( !pObj->ISA(SwVirtFlyDrawObj) )
{
// dann mal los:
const Rectangle &rBound = pObj->GetSnapRect();
Point aRelPos( pObj->GetRelativePos() );
const long nWidth = rBound.Right() - rBound.Left();
const long nHeight= rBound.Bottom() - rBound.Top();
aFrmSet.Put( SwFmtFrmSize( ATT_MIN_SIZE,
Max( nWidth, long(MINFLY) ),
Max( nHeight, long(MINFLY) )));
if( SFX_ITEM_SET != aFrmSet.GetItemState( RES_HORI_ORIENT ))
aFrmSet.Put( SwFmtHoriOrient( aRelPos.X(), text::HoriOrientation::NONE, text::RelOrientation::FRAME ));
if( SFX_ITEM_SET != aFrmSet.GetItemState( RES_VERT_ORIENT ))
aFrmSet.Put( SwFmtVertOrient( aRelPos.Y(), text::VertOrientation::NONE, text::RelOrientation::FRAME ));
}
pObj->GetOrdNum();
StartAllAction();
StartUndo();
// das "Sdr-Object" loeschen und dafuer die Grafik einfuegen
DelSelectedObj();
pFmt = GetDoc()->Insert( *GetCrsr(), rGrfName, rFltName, pGrf, &aFrmSet, NULL, NULL );
// die Ordnungsnummer (Z-Order) noch uebertragen
// JP 04.07.98: klappt aber nicht richtig!
//SdrObject* pNewObj = ::FindSdrObject( pFmt );
//pNewObj->SetOrdNum( nOrdNum );
EndUndo();
EndAllAction();
bRet = sal_True;
}
return bRet;
}
static sal_uInt16 SwFmtGetPageNum(const SwFlyFrmFmt * pFmt)
{
ASSERT(pFmt != NULL, "invalid argument");
SwFlyFrm * pFrm = pFmt->GetFrm();
sal_uInt16 aResult;
if (pFrm != NULL)
aResult = pFrm->GetPhyPageNum();
else
aResult = pFmt->GetAnchor().GetPageNum();
return aResult;
}
#include <fmtcnct.hxx>
void SwFEShell::GetConnectableFrmFmts(SwFrmFmt & rFmt,
const String & rReference,
sal_Bool bSuccessors,
::std::vector< String > & aPrevPageVec,
::std::vector< String > & aThisPageVec,
::std::vector< String > & aNextPageVec,
::std::vector< String > & aRestVec)
{
StartAction();
SwFmtChain rChain = rFmt.GetChain();
SwFrmFmt * pOldChainNext = (SwFrmFmt *) rChain.GetNext();
SwFrmFmt * pOldChainPrev = (SwFrmFmt *) rChain.GetPrev();
if (pOldChainNext)
pDoc->Unchain(rFmt);
if (pOldChainPrev)
pDoc->Unchain(*pOldChainPrev);
sal_uInt16 nCnt = pDoc->GetFlyCount(FLYCNTTYPE_FRM);
/* potential successors resp. predecessors */
::std::vector< const SwFrmFmt * > aTmpSpzArray;
(SwFrmFmt *) pDoc->FindFlyByName(rReference);
for (sal_uInt16 n = 0; n < nCnt; n++)
{
const SwFrmFmt & rFmt1 = *(pDoc->GetFlyNum(n, FLYCNTTYPE_FRM));
/*
pFmt is a potential successor of rFmt if it is chainable after
rFmt.
pFmt is a potential predecessor of rFmt if rFmt is chainable
after pFmt.
*/
int nChainState;
if (bSuccessors)
nChainState = pDoc->Chainable(rFmt, rFmt1);
else
nChainState = pDoc->Chainable(rFmt1, rFmt);
if (nChainState == SW_CHAIN_OK)
{
aTmpSpzArray.push_back(&rFmt1);
}
}
if (aTmpSpzArray.size() > 0)
{
aPrevPageVec.clear();
aThisPageVec.clear();
aNextPageVec.clear();
aRestVec.clear();
/* number of page rFmt resides on */
sal_uInt16 nPageNum = SwFmtGetPageNum((SwFlyFrmFmt *) &rFmt);
::std::vector< const SwFrmFmt * >::const_iterator aIt;
for (aIt = aTmpSpzArray.begin(); aIt != aTmpSpzArray.end(); aIt++)
{
String aString = (*aIt)->GetName();
/* rFmt is not a vaild successor or predecessor of
itself */
if (aString != rReference && aString != rFmt.GetName())
{
sal_uInt16 nNum1 =
SwFmtGetPageNum((SwFlyFrmFmt *) *aIt);
if (nNum1 == nPageNum -1)
aPrevPageVec.push_back(aString);
else if (nNum1 == nPageNum)
aThisPageVec.push_back(aString);
else if (nNum1 == nPageNum + 1)
aNextPageVec.push_back(aString);
else
aRestVec.push_back(aString);
}
}
}
if (pOldChainNext)
pDoc->Chain(rFmt, *pOldChainNext);
if (pOldChainPrev)
pDoc->Chain(*pOldChainPrev, rFmt);
EndAction();
}
// --> OD 2009-07-13 #i73249#
const String SwFEShell::GetObjTitle() const
{
String aTitle;
if ( Imp()->HasDrawView() )
{
const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
if ( pMrkList->GetMarkCount() == 1 )
{
const SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
const SwFrmFmt* pFmt = FindFrmFmt( pObj );
if ( pFmt->Which() == RES_FLYFRMFMT )
{
aTitle = dynamic_cast<const SwFlyFrmFmt*>(pFmt)->GetObjTitle();
}
else
{
aTitle = pObj->GetTitle();
}
}
}
return aTitle;
}
void SwFEShell::SetObjTitle( const String& rTitle )
{
if ( Imp()->HasDrawView() )
{
const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
if ( pMrkList->GetMarkCount() == 1 )
{
SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
SwFrmFmt* pFmt = FindFrmFmt( pObj );
if ( pFmt->Which() == RES_FLYFRMFMT )
{
GetDoc()->SetFlyFrmTitle( *(dynamic_cast<SwFlyFrmFmt*>(pFmt)),
rTitle );
}
else
{
pObj->SetTitle( rTitle );
}
}
}
}
const String SwFEShell::GetObjDescription() const
{
String aDescription;
if ( Imp()->HasDrawView() )
{
const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
if ( pMrkList->GetMarkCount() == 1 )
{
const SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
const SwFrmFmt* pFmt = FindFrmFmt( pObj );
if ( pFmt->Which() == RES_FLYFRMFMT )
{
aDescription = dynamic_cast<const SwFlyFrmFmt*>(pFmt)->GetObjDescription();
}
else
{
aDescription = pObj->GetDescription();
}
}
}
return aDescription;
}
void SwFEShell::SetObjDescription( const String& rDescription )
{
if ( Imp()->HasDrawView() )
{
const SdrMarkList *pMrkList = &Imp()->GetDrawView()->GetMarkedObjectList();
if ( pMrkList->GetMarkCount() == 1 )
{
SdrObject* pObj = pMrkList->GetMark( 0 )->GetMarkedSdrObj();
SwFrmFmt* pFmt = FindFrmFmt( pObj );
if ( pFmt->Which() == RES_FLYFRMFMT )
{
GetDoc()->SetFlyFrmDescription( *(dynamic_cast<SwFlyFrmFmt*>(pFmt)),
rDescription );
}
else
{
pObj->SetDescription( rDescription );
}
}
}
}
void SwFEShell::AlignFormulaToBaseline( const uno::Reference < embed::XEmbeddedObject >& xObj, SwFlyFrm * pFly )
{
#if OSL_DEBUG_LEVEL > 1
SvGlobalName aCLSID( xObj->getClassID() );
const bool bStarMath = ( SotExchange::IsMath( aCLSID ) != 0 );
ASSERT( bStarMath, "AlignFormulaToBaseline should only be called for Math objects" );
if ( !bStarMath )
return;
#endif
if (!pFly)
pFly = FindFlyFrm( xObj );
ASSERT( pFly , "No fly frame!" );
SwFrmFmt * pFrmFmt = pFly ? pFly->GetFmt() : 0;
// baseline to baseline alignment should only be applied to formulas anchored as char
if ( pFly && pFrmFmt && FLY_AS_CHAR == pFrmFmt->GetAnchor().GetAnchorId() )
{
// get baseline from Math object
uno::Any aBaseline;
if( svt::EmbeddedObjectRef::TryRunningState( xObj ) )
{
uno::Reference < beans::XPropertySet > xSet( xObj->getComponent(), uno::UNO_QUERY );
if ( xSet.is() )
{
try
{
aBaseline = xSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("BaseLine") ) );
}
catch ( uno::Exception& )
{
ASSERT( sal_False , "Baseline could not be retrieved from Starmath!" );
}
}
}
sal_Int32 nBaseline = ::comphelper::getINT32(aBaseline);
const MapMode aSourceMapMode( MAP_100TH_MM );
const MapMode aTargetMapMode( MAP_TWIP );
nBaseline = OutputDevice::LogicToLogic( nBaseline, aSourceMapMode.GetMapUnit(), aTargetMapMode.GetMapUnit() );
ASSERT( nBaseline > 0, "Wrong value of Baseline while retrieving from Starmath!" );
//nBaseline must be moved by aPrt position
const SwFlyFrmFmt *pFlyFrmFmt = pFly->GetFmt();
ASSERT( pFlyFrmFmt, "fly frame format missing!" );
if ( pFlyFrmFmt )
nBaseline += pFlyFrmFmt->GetLastFlyFrmPrtRectPos().Y();
const SwFmtVertOrient &rVert = pFrmFmt->GetVertOrient();
SwFmtVertOrient aVert( rVert );
aVert.SetPos( -nBaseline );
aVert.SetVertOrient( com::sun::star::text::VertOrientation::NONE );
pFrmFmt->LockModify();
pFrmFmt->SetFmtAttr( aVert );
pFrmFmt->UnlockModify();
pFly->InvalidatePos();
}
}
void SwFEShell::AlignAllFormulasToBaseline()
{
StartAllAction();
SwStartNode *pStNd;
SwNodeIndex aIdx( *GetNodes().GetEndOfAutotext().StartOfSectionNode(), 1 );
while ( 0 != (pStNd = aIdx.GetNode().GetStartNode()) )
{
++aIdx;
SwOLENode *pOleNode = dynamic_cast< SwOLENode * >( &aIdx.GetNode() );
if ( pOleNode )
{
const uno::Reference < embed::XEmbeddedObject > & xObj( pOleNode->GetOLEObj().GetOleRef() );
if (xObj.is())
{
SvGlobalName aCLSID( xObj->getClassID() );
if ( SotExchange::IsMath( aCLSID ) )
AlignFormulaToBaseline( xObj );
}
}
aIdx.Assign( *pStNd->EndOfSectionNode(), + 1 );
}
EndAllAction();
}