Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / filter / rtf / rtffly.cxx
blob: bc70f8532247221e6992993099ed83466220d416 [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"
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
#include <hintids.hxx>
#include <tools/list.hxx>
#include <tools/cachestr.hxx>
#include <svtools/rtftoken.h>
#include <svl/itemiter.hxx>
#include <editeng/prntitem.hxx>
#include <editeng/opaqitem.hxx>
#include <editeng/protitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/frmdiritem.hxx>
#include <fmtfsize.hxx>
#include <fmtanchr.hxx>
#include <fmtpdsc.hxx>
#include <fmtsrnd.hxx>
#include <fmtclds.hxx>
#include <fmtcntnt.hxx>
#include <frmatr.hxx>
#include <doc.hxx>
#include <pam.hxx>
#include <ndtxt.hxx>
#include <shellio.hxx>
#include <swparrtf.hxx>
#include <grfatr.hxx>
#include <paratr.hxx>
#include <rtf.hxx>
#include <ndgrf.hxx>
#include <pagedesc.hxx>
#include <swtable.hxx>
#include <txtflcnt.hxx>
#include <fmtflcnt.hxx>
#include <fltini.hxx>
#include <unoframe.hxx>
#include <deque>
#include <map>
#include <utility>
// --> OD 2004-06-30 #i27767#
#include <fmtwrapinfluenceonobjpos.hxx>
// <--
#include <editeng/brshitem.hxx>
#include <fmtfollowtextflow.hxx>
// --> OD, FLR 2006-02-16 #131205#
#include "dcontact.hxx"
// <--
using namespace ::com::sun::star;
#define ANCHOR(p) ((SwFmtAnchor*)p)
// steht in shellio.hxx
extern SwCntntNode* GoNextNds( SwNodeIndex * pIdx, sal_Bool bChk );
SV_IMPL_PTRARR( SwFlySaveArr, SwFlySave* )
inline const SwFmtFrmSize GetFrmSize(const SfxItemSet& rSet, sal_Bool bInP=sal_True)
{
return (const SwFmtFrmSize&)rSet.Get(RES_FRM_SIZE,bInP);
}
SwFlySave::SwFlySave(const SwPaM& rPam, SfxItemSet& rSet)
: aFlySet(rSet), nSttNd(rPam.GetPoint()->nNode), nEndNd(nSttNd), nEndCnt(0),
nPageWidth(ATT_MIN_SIZE), nDropLines(0), nDropAnchor(0)
{
}
int SwFlySave::IsEqualFly( const SwPaM& rPos, SfxItemSet& rSet )
{
if( rSet.Count() != aFlySet.Count() || nDropAnchor )
return sal_False;
// nur TextNodes zusammenfassen
if( nSttNd == nEndNd && nEndNd.GetNode().IsNoTxtNode() )
return sal_False;
// teste auf gleiche / naechste Position
if( rPos.GetPoint()->nNode.GetIndex() == nEndNd.GetIndex() )
{
if( 1 < (rPos.GetPoint()->nContent.GetIndex() - nEndCnt) )
return sal_False;
}
else if( rPos.GetPoint()->nContent.GetIndex() )
return sal_False;
else
{
SwNodeIndex aIdx( nEndNd );
SwCntntNode *const pCNd = aIdx.GetNode().GetCntntNode();
if( !GoNextNds( &aIdx, sal_True ) ||
aIdx.GetIndex() != rPos.GetPoint()->nNode.GetIndex() ||
( pCNd && pCNd->Len() != nEndCnt ))
{
return sal_False;
}
}
if( rSet.Count() )
{
SfxItemIter aIter( rSet );
const SfxPoolItem *pItem, *pCurr = aIter.GetCurItem();
while( sal_True )
{
if( SFX_ITEM_SET != aFlySet.GetItemState( pCurr->Which(),
sal_False, &pItem ) ||
// Ankerattribute gesondert behandeln
( RES_ANCHOR == pCurr->Which()
? (ANCHOR(pCurr)->GetAnchorId() != ANCHOR(pItem)->GetAnchorId() ||
ANCHOR(pCurr)->GetPageNum() != ANCHOR(pItem)->GetPageNum())
: *pItem != *pCurr ))
return sal_False;
if( aIter.IsAtEnd() )
break;
pCurr = aIter.NextItem();
}
}
return sal_True;
}
void SwFlySave::SetFlySize( const SwTableNode& rTblNd )
{
// sollte der Fly kleiner als diese Tabelle sein, dann
// korrigiere diesen (nur bei abs. Angaben!)
SwTwips nWidth = rTblNd.GetTable().GetFrmFmt()->GetFrmSize().GetWidth();
const SwFmtFrmSize& rSz = GetFrmSize( aFlySet );
if( nWidth > rSz.GetWidth() )
aFlySet.Put( SwFmtFrmSize( rSz.GetHeightSizeType(), nWidth, rSz.GetHeight() ));
}
sal_Bool lcl_HasBreakAttrs( const SwCntntNode& rNd )
{
sal_Bool bRet = sal_False;
const SfxItemSet& rSet = rNd.GetSwAttrSet();
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == rSet.GetItemState( RES_BREAK, sal_True, &pItem ) &&
SVX_BREAK_NONE != ((SvxFmtBreakItem*)pItem)->GetBreak() )
bRet = sal_True;
else if( SFX_ITEM_SET == rSet.GetItemState( RES_PAGEDESC, sal_True, &pItem )&&
0 != ((SwFmtPageDesc*)pItem)->GetPageDesc() )
bRet = sal_True;
return bRet;
}
void lcl_CpyBreakAttrs( SwCntntNode* pSrcNd, SwCntntNode* pDstNd,
SwNodeIndex* pNewIdx )
{
const SfxItemSet* pSet;
if( pSrcNd && pDstNd && 0 != ( pSet = pSrcNd->GetpSwAttrSet() ) )
{
const SfxPoolItem *pDescItem, *pBreakItem;
if( SFX_ITEM_SET != pSet->GetItemState( RES_BREAK,
sal_False, &pBreakItem ) )
pBreakItem = 0;
if( SFX_ITEM_SET != pSet->GetItemState( RES_PAGEDESC,
sal_False, &pDescItem ) )
pDescItem = 0;
if( pDescItem || pBreakItem )
{
if( lcl_HasBreakAttrs( *pDstNd ))
{
SwPosition aPos( *pDstNd, SwIndex( pDstNd ));
aPos.nNode--;
pDstNd->GetDoc()->AppendTxtNode( aPos );
if( pNewIdx )
*pNewIdx = aPos.nNode;
SwCntntNode* pOldNd = pDstNd;
pDstNd = aPos.nNode.GetNode().GetCntntNode();
pDstNd->ChgFmtColl( pOldNd->GetFmtColl() );
if( pDstNd->HasSwAttrSet() )
{
SfxItemSet aSet( *pDstNd->GetpSwAttrSet() );
aSet.ClearItem( RES_BREAK );
aSet.ClearItem( RES_PAGEDESC );
pDstNd->SetAttr( aSet );
}
}
if( pBreakItem )
{
pDstNd->SetAttr( *pBreakItem );
pSrcNd->ResetAttr( RES_BREAK );
}
if( pDescItem )
{
pDstNd->SetAttr( *pDescItem );
pSrcNd->ResetAttr( RES_PAGEDESC );
}
}
}
}
void SwRTFParser::SetFlysInDoc()
{
// !! von Oben abarbeiten, CntntPos ist kein Index !
SwNodes & rNds = pDoc->GetNodes();
typedef std::pair<SwFlyFrmFmt*, SwFmtAnchor> frameEntry;
typedef std::deque<frameEntry> rtfframesAtIndex;
typedef std::map<const SwNode*, rtfframesAtIndex> rtfFmtMap;
rtfFmtMap aPrevFmts;
SwFrmFmt* pParent = pDoc->GetFrmFmtFromPool( RES_POOLFRM_FRAME );
for( sal_uInt16 n = 0; n < aFlyArr.Count(); ++n )
{
SwFlySave* pFlySave = aFlyArr[ n ];
ASSERT( !pFlySave->nSttNd.GetNode().FindFlyStartNode(),
"Content vom Fly steht in einem Fly" );
ASSERT( pFlySave->nSttNd.GetIndex() <= pFlySave->nEndNd.GetIndex(),
"Fly hat falschen Bereich" );
//JP 21.09.98: wenn ein DropCap ist, dann Text im Node belassen, am
// Absatz das Absatz Attribut setzen. Ggfs noch die
// FontSize zuruecksetzen, damit das DropCap nicht zu
// gro? wird.
if( pFlySave->nDropAnchor )
{
SwTxtNode* pSttNd = pFlySave->nSttNd.GetNode().GetTxtNode();
SwTxtNode* pEndNd = pFlySave->nEndNd.GetNode().GetTxtNode();
if( pSttNd && pEndNd &&
pSttNd->GetIndex() + 1 == pEndNd->GetIndex()
&& pSttNd->GetTxt().Len()>0 /* #i38227# leave drop caps with no content as fly frames */ )
{
sal_uLong nPos = pSttNd->GetIndex();
SwDoc * pDoc1 = pSttNd->GetDoc();
sal_Bool bJoined;
{
SwPaM aTmp( *pSttNd, pSttNd->GetTxt().Len(), *pEndNd, 0 );
bJoined = pDoc1->DeleteAndJoin( aTmp );
}
SwTxtNode * pNd = (pDoc1->GetNodes()[nPos])->GetTxtNode();
if( bJoined && pNd != NULL)
{
SwFmtDrop aDropCap;
aDropCap.GetLines() = (sal_uInt8)pFlySave->nDropLines;
aDropCap.GetChars() = 1;
SwIndex aIdx( pEndNd );
pNd->RstTxtAttr( aIdx, 1, RES_CHRATR_FONTSIZE );
pNd->SetAttr( aDropCap );
}
delete pFlySave;
continue;
}
}
// liegt Ende und Start vom Naechsten im gleichen Node, dann muss
// gesplittet werden
if (((static_cast<size_t>(n) + 1) < aFlyArr.Count()) &&
pFlySave->nEndCnt &&
pFlySave->nEndNd == aFlyArr[ n + 1 ]->nSttNd )
{
SwCntntNode *const pCNd = pFlySave->nEndNd.GetNode().GetCntntNode();
if( pCNd )
{
SwPosition aPos( pFlySave->nEndNd,
SwIndex( pCNd, pFlySave->nEndCnt ));
pDoc->SplitNode( aPos, false );
pFlySave->nEndNd--;
}
else
pFlySave->nEndCnt = 0;
}
// verschiebe den Inhalt von diesem Anchor in den Auto-TextBereich
// und erzeuge dadurch den richtigen SwG-Rahmen
SwNodeRange aRg(pFlySave->nSttNd, 0, pFlySave->nEndNd, 0);
//Make a new section, unless there is no content at all
const bool bMakeEmptySection = aRg.aStart < aRg.aEnd || ((aRg.aStart == aRg.aEnd) && pFlySave->nEndCnt);
{
// Nur TextNodes koennen in Tabellen stehen !!
const SwNode* pNd = &pFlySave->nSttNd.GetNode();
if( pNd->IsNoTxtNode() )
{
// die Size muss noch korrigiert werden!
nAktPageDesc = 0; // Standart PageDesc
if( SFX_ITEM_SET != pFlySave->aFlySet.GetItemState(
RES_FRM_SIZE, sal_False ) )
_SetPictureSize( *(SwNoTxtNode*)pNd, aRg.aStart,
pFlySave->aFlySet );
if( 0 != ( pNd = pNd->FindTableNode() ) )
pFlySave->SetFlySize( *(SwTableNode*)pNd );
}
else
{
// Take care for table nodes
pNd = pNd->GetNodes()[ pNd->GetIndex() - 2 ]->GetTableNode();
if( pNd ) // if the table starts imediately before aRg -> expand aRg
aRg.aStart = *pNd;
if( bMakeEmptySection )
{
pNd = &aRg.aEnd.GetNode();
sal_uLong nSectEnd = pNd->EndOfSectionIndex()+1;
if (!pNd->IsTableNode() && 0 !=(pNd = pNd->FindTableNode())
&& (pNd->GetIndex() >= aRg.aStart.GetNode().GetIndex()) )
{
const SwNode* pTblBxNd;
// Ende der Tabelle ist hinter dieser Box ??
if( pNd->EndOfSectionIndex() == nSectEnd )
aRg.aEnd = nSectEnd+1;
// is the end in the first box of the table, then
// move before the table (Bug 67663)
// but the range must not become emtpy, i.e. aStart==aEnd
// because otherwise we will get a crash (126506) later on
else if( 0 != ( pTblBxNd = aRg.aEnd.GetNode().
FindTableBoxStartNode()) &&
pTblBxNd->GetIndex() - 1 == pNd->GetIndex() &&
&aRg.aStart.GetNode() != pNd )
aRg.aEnd = *pNd;
else
{
// Tabelle ist noch groesser, also splitte sie hier.
rNds.SplitTable( aRg.aEnd, sal_True );
aRg.aEnd = pNd->EndOfSectionIndex() + 1;
}
}
}
}
}
// vorm verschieben muss sich der Index auf die alte Position
// gemerkt werden, der Index wird mit verschoben !!!
SwNodeIndex aTmpIdx( rNds.GetEndOfAutotext() );
SwStartNode* pSttNd = bMakeEmptySection
? rNds.MakeEmptySection( aTmpIdx, SwFlyStartNode )
: rNds.MakeTextSection( aTmpIdx, SwFlyStartNode,
(SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
// das ist die Verankerungs-Position (fuers Layout!)
pFlySave->nSttNd = aRg.aStart.GetIndex()-1;
if( bMakeEmptySection )
{
// check: the move does not clear the surrounded section. If all
// nodes moved away, then create a new TxtNode
{
// i76403: an empty selection is not a good idea
if( aRg.aStart == aRg.aEnd && aRg.aStart.GetNode().GetTxtNode() )
aRg.aEnd++;
SwNodeIndex aPrev( aRg.aStart, -1 );
if( aPrev.GetNode().IsStartNode() &&
aPrev.GetNode().EndOfSectionNode() == &aRg.aEnd.GetNode())
{
// create new txtnode, because the section does never be empty
pDoc->GetNodes().MakeTxtNode( aRg.aEnd,
(SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
aRg.aEnd--;
}
}
aTmpIdx = *pSttNd->EndOfSectionNode();
pDoc->MoveNodeRange( aRg, aTmpIdx,
IDocumentContentOperations::DOC_MOVEDEFAULT );
}
// patch from cmc for #i52542#
if (pSttNd->GetIndex() + 1 == pSttNd->EndOfSectionIndex())
{
ASSERT(!this, "nothing in this frame, not legal");
delete pFlySave;
continue;
}
pFlySave->aFlySet.Put( SwFmtCntnt( pSttNd ));
CalculateFlySize( pFlySave->aFlySet, pFlySave->nSttNd,
pFlySave->nPageWidth );
// THIS >>>>>
// if the section only contains one Node and this has a
// border or backgorund, then put it to the frame
// Not in our own RTF-Format!
// <<<<< DOES NOT MAKE SENSE TO ME (flr)
// #102781#. Added support for transparent frames.
if( pSttNd->GetIndex() + 1 != pSttNd->EndOfSectionIndex() &&
!bSwPageDesc )
{
SwCntntNode* pSrcNd = pDoc->GetNodes()[ pSttNd->GetIndex() + 1 ]->GetCntntNode();
SfxItemSet aTmpSet( pDoc->GetAttrPool(),
RES_BACKGROUND, RES_BOX );
const SvxBrushItem* pBackgroundBrush = (const SvxBrushItem*)pFlySave->aFlySet.GetItem(RES_BACKGROUND, sal_False);
if( pSrcNd && pSrcNd->HasSwAttrSet() )
aTmpSet.Put( *pSrcNd->GetpSwAttrSet() );
if (pBackgroundBrush)
{
aTmpSet.Put(*pBackgroundBrush, RES_BACKGROUND);
}
else
{
pBackgroundBrush = (const SvxBrushItem*)aTmpSet.GetItem(RES_BACKGROUND, sal_False);
if (pBackgroundBrush)
{
Color& rBackgroundColor = const_cast<SvxBrushItem*>(pBackgroundBrush)->GetColor();
rBackgroundColor.SetTransparency(0xFE);
}
else
{
Color aColor = Color(0xff, 0xff, 0xff);
aColor.SetTransparency( 0xFE);
SvxBrushItem aBrush(aColor, RES_BACKGROUND);
aTmpSet.Put(aBrush, RES_BACKGROUND);
}
}
// #117914# Topic 6.
pFlySave->aFlySet.Put( aTmpSet );
if( pSrcNd && pSrcNd->HasSwAttrSet() )
{
pSrcNd->ResetAttr( RES_BACKGROUND, RES_BOX );
}
}
SwFlyFrmFmt* pFmt = pDoc->MakeFlyFrmFmt( aEmptyStr, pParent );
pFmt->SetFmtAttr( pFlySave->aFlySet );
const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
if (FLY_AS_CHAR != rAnchor.GetAnchorId())
{
// korrigiere noch den Absatz, ist immer der vorhergehende !
// JP 20.09.95: wenn es diesen gibt! (DocAnfang!)
//JP 02.08.99: that is wrong. The anchor is ever the NEXT!
//JP 05.08.99: there are an Bug in the ExportFilter which will
// be fixed in the Version 517 - by SWG-Export
// the fly will be after the paragraph - but in RTF
// the flys will be before the paragraph.
if( !bSwPageDesc || 5430 < GetVersionNo() )
pFlySave->nSttNd++;
// if( !pFlySave->nSttNd.GetNode().IsCntntNode() )
{
// Seitenumbrueche in den Bodybereich verschieben!
SwCntntNode* pSrcNd = aRg.aStart.GetNode().GetCntntNode();
SwCntntNode* pDstNd = pFlySave->nSttNd.GetNode().GetCntntNode();
if( !pDstNd )
pDstNd = pDoc->GetNodes().GoNext( &pFlySave->nSttNd );
::lcl_CpyBreakAttrs( pSrcNd, pDstNd, &pFlySave->nSttNd );
}
const SwNodeIndex aSttNd(*pSttNd);
SwNodeIndex aEndNd(*pSttNd->EndOfSectionNode());
aEndNd--;
SwPosition aPos( pFlySave->nSttNd );
SwFmtAnchor aAnchor(rAnchor);
aAnchor.SetAnchor(&aPos);
const SwNode *pCurrentAnchor = &(pFlySave->nSttNd.GetNode());
aPrevFmts[pCurrentAnchor].push_back(frameEntry(pFmt, aAnchor));
while (aEndNd > aSttNd)
{
typedef rtfframesAtIndex::iterator myIter;
rtfframesAtIndex &rDeque = aPrevFmts[&(aEndNd.GetNode())];
myIter aEnd = rDeque.end();
for (myIter aIter = rDeque.begin(); aIter != aEnd; ++aIter)
{
aIter->second.SetAnchor(&aPos);
// --> OD 2004-06-30 #i27767# - push on front to keep order
// of objects for the correct object positioning
//aPrevFmts[pCurrentAnchor].push_back(*aIter);
aPrevFmts[pCurrentAnchor].push_front(*aIter);
}
rDeque.clear();
aEndNd--;
}
}
// --> OD, FLR 2006-02-16 #131205#
// Create draw contact object, which also creates a <SdrObject> instance,
// in order to set the order number.
// The order number is assumed to be the order of the text flow.
SwFlyDrawContact* pContact =
new SwFlyDrawContact( pFmt,
pFmt->GetDoc()->GetOrCreateDrawModel() );
pContact->GetMaster()->SetOrdNum( n );
// <--
delete pFlySave;
}
typedef rtfFmtMap::reverse_iterator myriter;
myriter aEnd = aPrevFmts.rend();
for(myriter aIter = aPrevFmts.rbegin(); aIter != aEnd; ++aIter)
{
rtfframesAtIndex &rDeque = aIter->second;
typedef rtfframesAtIndex::iterator myIter;
myIter aQEnd = rDeque.end();
for (myIter aQIter = rDeque.begin(); aQIter != aQEnd; ++aQIter)
{
frameEntry &rEntry = *aQIter;
SwFlyFrmFmt *pFrm = rEntry.first;
SwFmtAnchor &rAnchor = rEntry.second;
pFrm->SetFmtAttr(rAnchor);
}
}
aFlyArr.Remove(0, aFlyArr.Count());
}
// clips the text box to the min or max position if it is outside our min or max boundry
long SwRTFParser::GetSafePos(long nPos)
{
if(nPos > SHRT_MAX)
nPos = SHRT_MAX;
else if(nPos < SHRT_MIN)
nPos = SHRT_MIN;
return nPos;
}
void SwRTFParser::ReadFly( int nToken, SfxItemSet* pSet )
{
// ein Set fuer die FrmFmt-Attribute
SfxItemSet aSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN, RES_FRMATR_END-1 );
if( !IsNewDoc() )
Reader::ResetFrmFmtAttrs( aSet );
// der Fly beginnt immer in einem neuen Absatz
if( pPam->GetPoint()->nContent.GetIndex() )
InsertPara();
// RTF-Defaults setzen:
// --> OD 2004-06-24 #i27767#
SwFmtAnchor aAnchor( FLY_AT_PARA );
SwFmtHoriOrient aHori( 0, text::HoriOrientation::LEFT, text::RelOrientation::FRAME );
SwFmtVertOrient aVert( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME );
// <--
SvxFrameDirectionItem aFrmDir( FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR );
sal_uInt16 nCols = USHRT_MAX, nColSpace = USHRT_MAX, nAktCol = 0;
SvUShorts aColumns;
sal_Bool bChkDropCap = 0 == pSet;
sal_uInt16 nDropCapLines = 0, nDropCapAnchor = 0;
int nNumOpenBrakets = GetOpenBrakets();
if( !pSet )
{
pSet = &aSet;
}
else
{
// die Werte aus dem uebergebenen!
aAnchor = (SwFmtAnchor&)pSet->Get( RES_ANCHOR );
aHori = (SwFmtHoriOrient&)pSet->Get( RES_HORI_ORIENT );
aVert = (SwFmtVertOrient&)pSet->Get( RES_VERT_ORIENT );
}
// dann sammel mal alle Attribute zusammen
int bWeiter = sal_True;
int nAppliedProps=0;
do {
sal_uInt16 nVal = sal_uInt16(nTokenValue);
/*
#i5263#
Assume that a property genuinely contributes towards creating a frame,
and if turns out to be a non contributing one reduce the count.
*/
++nAppliedProps;
switch( nToken )
{
case RTF_ABSW:
{
SwFmtFrmSize aSz( ATT_MIN_SIZE, nTokenValue, 0 );
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == pSet->GetItemState( RES_FRM_SIZE, sal_True,
&pItem ))
{
aSz.SetHeightSizeType( ((SwFmtFrmSize*)pItem)->GetHeightSizeType() );
aSz.SetHeight( ((SwFmtFrmSize*)pItem)->GetHeight() );
}
if( MINFLY > nTokenValue ) nTokenValue = MINFLY;
aSet.Put( aSz );
}
break;
case RTF_ABSH:
{
SwFmtFrmSize aSz( ATT_MIN_SIZE, 0, MINFLY );
const SfxPoolItem* pItem;
if( SFX_ITEM_SET == pSet->GetItemState( RES_FRM_SIZE, sal_True,
&pItem ))
{
aSz.SetWidth( ((SwFmtFrmSize*)pItem)->GetWidth() );
}
if( 0 > nTokenValue )
{
nTokenValue = -nTokenValue;
aSz.SetHeightSizeType( ATT_FIX_SIZE );
}
if( MINFLY > nTokenValue ) nTokenValue = MINFLY;
aSz.SetHeight( nTokenValue );
aSet.Put( aSz );
}
break;
case RTF_NOWRAP:
{
pSet->Put( SwFmtSurround( SURROUND_NONE ));
}
break;
case RTF_DXFRTEXT:
{
SvxULSpaceItem aUL( RES_UL_SPACE );
SvxLRSpaceItem aLR( RES_LR_SPACE );
aUL.SetUpper( nVal ); aUL.SetLower( nVal );
aLR.SetLeft( nVal ); aLR.SetRight( nVal );
pSet->Put( aUL );
pSet->Put( aLR );
}
break;
case RTF_DFRMTXTX:
{
SvxLRSpaceItem aLR( RES_LR_SPACE );
aLR.SetLeft( nVal ); aLR.SetRight( nVal );
pSet->Put( aLR );
}
break;
case RTF_DFRMTXTY:
{
SvxULSpaceItem aUL( RES_UL_SPACE );
aUL.SetUpper( nVal ); aUL.SetLower( nVal );
pSet->Put( aUL );
}
break;
case RTF_POSNEGX:
case RTF_POSX: aHori.SetHoriOrient( text::HoriOrientation::NONE );
aHori.SetPos( GetSafePos((long)nTokenValue) );
break;
case RTF_POSXC: aHori.SetHoriOrient( text::HoriOrientation::CENTER ); break;
case RTF_POSXI: aHori.SetHoriOrient( text::HoriOrientation::LEFT );
aHori.SetPosToggle( sal_True );
break;
case RTF_POSXO: aHori.SetHoriOrient( text::HoriOrientation::RIGHT );
aHori.SetPosToggle( sal_True );
break;
case RTF_POSXL: aHori.SetHoriOrient( text::HoriOrientation::LEFT ); break;
case RTF_POSXR: aHori.SetHoriOrient( text::HoriOrientation::RIGHT ); break;
case RTF_POSNEGY:
case RTF_POSY: aVert.SetVertOrient( text::VertOrientation::NONE );
aVert.SetPos( GetSafePos((long)nTokenValue) );
break;
case RTF_POSYT: aVert.SetVertOrient( text::VertOrientation::TOP ); break;
case RTF_POSYB: aVert.SetVertOrient( text::VertOrientation::BOTTOM ); break;
case RTF_POSYC: aVert.SetVertOrient( text::VertOrientation::CENTER ); break;
case RTF_PHMRG: aHori.SetRelationOrient( text::RelOrientation::PAGE_PRINT_AREA ); break;
case RTF_PVMRG: aVert.SetRelationOrient( text::RelOrientation::PAGE_PRINT_AREA ); break;
case RTF_PHPG: aHori.SetRelationOrient( text::RelOrientation::PAGE_FRAME ); break;
case RTF_PVPG: aVert.SetRelationOrient( text::RelOrientation::PAGE_FRAME );break;
case RTF_PHCOL: aHori.SetRelationOrient( text::RelOrientation::FRAME ); break;
case RTF_PVPARA: aVert.SetRelationOrient( text::RelOrientation::FRAME ); break;
case RTF_POSYIL:
break;
case RTF_ABSLOCK:
/*
#i5263#
Not sufficient to make a frame at least word won't do it with just
an abslock
*/
--nAppliedProps;
break;
case RTF_FRMTXLRTB:
aFrmDir.SetValue( FRMDIR_HORI_LEFT_TOP );
break;
case RTF_FRMTXTBRL:
aFrmDir.SetValue( FRMDIR_HORI_RIGHT_TOP );
break;
case RTF_FRMTXLRTBV:
aFrmDir.SetValue( FRMDIR_VERT_TOP_LEFT );
break;
case RTF_FRMTXTBRLV:
aFrmDir.SetValue( FRMDIR_VERT_TOP_RIGHT );
break;
case RTF_DROPCAPLI: // Dropcaps !!
if( bChkDropCap )
{
nDropCapLines = sal_uInt16( nTokenValue );
if( !nDropCapAnchor )
nDropCapAnchor = 1;
}
break;
case RTF_DROPCAPT:
if( bChkDropCap )
{
nDropCapAnchor = sal_uInt16( nTokenValue );
if( !nDropCapLines )
nDropCapLines = 3;
}
break;
// fuer die "alten" Writer - haben die Spaltigkeit falsch heraus-
// geschrieben
case RTF_COLS: nCols = sal_uInt16( nTokenValue ); break;
case RTF_COLSX: nColSpace = sal_uInt16( nTokenValue ); break;
case RTF_COLNO:
nAktCol = sal_uInt16( nTokenValue );
if( RTF_COLW == GetNextToken() )
{
sal_uInt16 nWidth = sal_uInt16( nTokenValue ), nSpace = 0;
if( RTF_COLSR == GetNextToken() )
nSpace = sal_uInt16( nTokenValue );
else
SkipToken( -1 ); // wieder zurueck
if( --nAktCol == ( aColumns.Count() / 2 ) )
{
aColumns.Insert( nWidth + nSpace, aColumns.Count() );
aColumns.Insert( nSpace, aColumns.Count() );
}
}
break;
case '{':
{
short nSkip = 0;
if( RTF_IGNOREFLAG != ( nToken = GetNextToken() ))
{
if( RTF_SHADINGDEF == (nToken & ~0xff) )
{
ReadBackgroundAttr( nToken, aSet );
GetNextToken(); // Klammer ueberlesen
}
else
nSkip = -1;
}
else if( RTF_APOCTL ==
((nToken = GetNextToken() ) & ~(0xff | RTF_SWGDEFS)) )
{
bReadSwFly = true; // alles kommt in den akt. Fly
SvxLRSpaceItem aLR( RES_LR_SPACE );
SvxULSpaceItem aUL( RES_UL_SPACE );
nCols = USHRT_MAX; // neu aufsetzen
nColSpace = USHRT_MAX;
do {
nVal = sal_uInt16(nTokenValue);
switch( nToken )
{
// Swg-Frame-Tokens
case RTF_FLYPRINT:
{
pSet->Put( SvxPrintItem( RES_PRINT, sal_False ));
}
break;
case RTF_FLYOPAQUE:
{
pSet->Put( SvxOpaqueItem( RES_OPAQUE, sal_False ));
}
break;
case RTF_FLYPRTCTD:
{
RTFProtect aP( (sal_uInt8)nTokenValue );
SvxProtectItem aProtectItem( RES_PROTECT );
aProtectItem.SetCntntProtect( aP.GetCntnt() );
aProtectItem.SetSizeProtect( aP.GetSize() );
aProtectItem.SetPosProtect( aP.GetPos() );
pSet->Put( aProtectItem );
}
break;
case RTF_FLYMAINCNT:
{
RTFSurround aMC( (sal_uInt8)nTokenValue );
SwFmtSurround aSurr( (SwSurround)aMC.GetOrder());
if( aMC.GetGoldCut() )
aSurr.SetSurround( SURROUND_IDEAL );
pSet->Put( aSurr );
}
break;
case RTF_FLYVERT:
{
RTFVertOrient aVO( nVal );
aVert.SetVertOrient( aVO.GetOrient() );
aVert.SetRelationOrient( aVO.GetRelation() );
}
break;
case RTF_FLYHORZ:
{
RTFHoriOrient aHO( nVal );
aHori.SetHoriOrient( aHO.GetOrient() );
aHori.SetRelationOrient( aHO.GetRelation() );
}
break;
case RTF_FLYOUTLEFT: aLR.SetLeft( nVal ); break;
case RTF_FLYOUTRIGHT: aLR.SetRight( nVal ); break;
case RTF_FLYOUTUPPER: aUL.SetUpper( nVal ); break;
case RTF_FLYOUTLOWER: aUL.SetLower( nVal ); break;
case RTF_FLYANCHOR:
switch( GetNextToken() )
{
case RTF_FLY_PAGE:
aAnchor.SetType( FLY_AT_PAGE );
aAnchor.SetPageNum( sal_uInt16(nTokenValue));
aAnchor.SetAnchor( 0 );
break;
case RTF_FLY_CNTNT:
{
SwNodeIndex aIdx( pPam->GetPoint()->nNode );
pDoc->GetNodes().GoPrevious( &aIdx );
SwPosition aPos( aIdx );
aAnchor.SetType( FLY_AT_PARA );
aAnchor.SetAnchor( &aPos );
}
break;
// JP 26.09.94: die Bindung an die Spalte gibt es nicht mehr !!
// case RTF_FLY_COLUMN:
}
break;
case RTF_COLS: nCols = sal_uInt16( nTokenValue ); break;
case RTF_COLSX: nColSpace = sal_uInt16( nTokenValue ); break;
case RTF_COLNO:
nAktCol = sal_uInt16( nTokenValue );
if( RTF_COLW == GetNextToken() )
{
sal_uInt16 nWidth = sal_uInt16( nTokenValue ), nSpace = 0;
if( RTF_COLSR == GetNextToken() )
nSpace = sal_uInt16( nTokenValue );
else
SkipToken( -1 ); // wieder zurueck
if( --nAktCol == ( aColumns.Count() / 2 ) )
{
aColumns.Insert( nWidth + nSpace, aColumns.Count() );
aColumns.Insert( nSpace, aColumns.Count() );
}
}
break;
case '{':
if( RTF_BRDBOX == ( nToken = GetNextToken() ) )
ReadBorderAttr( nToken, aSet );
else if( RTF_SHADINGDEF == (nToken & ~0xff ) )
ReadBackgroundAttr( nToken, aSet );
else if( RTF_IGNOREFLAG == nToken )
{
int bSkipGrp = sal_True;
switch( nToken = GetNextToken() )
{
case RTF_SHADOW:
case RTF_BRDBOX:
ReadAttr( SkipToken( -2 ), &aSet );
bSkipGrp = sal_False;
break;
case RTF_BRDRT:
case RTF_BRDRB:
case RTF_BRDRR:
case RTF_BRDRL:
bSkipGrp = sal_False;
ReadBorderAttr( SkipToken( -2 ), aSet );
break;
}
// keine weitere Klammer mehr ueberlesen!!!
if( !bSkipGrp )
break;
SkipGroup();
}
else
SkipGroup();
GetNextToken(); // Klammer ueberlesen
break;
}
} while( IsParserWorking() &&
'}' != ( nToken = GetNextToken() ));
if( aUL.GetUpper() || aUL.GetLower() )
pSet->Put( aUL );
if( aLR.GetLeft() || aLR.GetRight() )
pSet->Put( aLR );
}
else if( RTF_BRDBOX == nToken )
ReadBorderAttr( nToken, aSet );
else if( RTF_SHADOW == nToken )
ReadAttr( SkipToken( -2 ), &aSet );
else if( RTF_SHADINGDEF == (nToken & ~0xff ) )
ReadBackgroundAttr( nToken, aSet );
else if( RTF_UNKNOWNCONTROL == nToken )
SkipGroup();
else
nSkip = -2;
if( nSkip )
{
nToken = SkipToken( nSkip );
bWeiter = sal_False;
}
}
break;
default:
--nAppliedProps; //Not sufficient to make a frame
bWeiter = sal_False;
}
if( bWeiter )
nToken = GetNextToken();
} while( bWeiter && IsParserWorking() );
pSet->Put( aAnchor );
pSet->Put( aHori );
pSet->Put( aVert );
// --> OD 2004-06-30 #i27767# - set wrapping style influence
// --> OD 2004-10-18 #i35017# - constant name has changed
pSet->Put( SwFmtWrapInfluenceOnObjPos(
text::WrapInfluenceOnPosition::ONCE_SUCCESSIVE ));
// <--
SwFmtFollowTextFlow aFollowTextFlow( sal_False );
pSet->Put( aFollowTextFlow );
if( !( aFrmDir == pSet->Get( RES_FRAMEDIR )) )
pSet->Put( aFrmDir );
if( nCols && USHRT_MAX != nCols )
{
SwFmtCol aCol;
if( USHRT_MAX == nColSpace )
nColSpace = 720;
sal_uLong nWidth = USHRT_MAX;
aCol.Init( nCols, nColSpace, sal_uInt16( nWidth ) );
if( nCols == ( aColumns.Count() / 2 ) )
{
for( sal_uInt16 n = 0, i = 0; n < aColumns.Count(); n += 2, ++i )
{
SwColumn* pCol = aCol.GetColumns()[ i ];
sal_uLong nTmp = aColumns[ n ];
nTmp *= USHRT_MAX;
nTmp /= nWidth;
pCol->SetWishWidth( sal_uInt16(nTmp) );
/*
JP 07.07.95: der Dialog kennt nur eine Breite fuer alle Spalten
darum hier nicht weiter beachten
nTmp = aColumns[ n+1 ];
if( nTmp )
pCol->SetRight( sal_uInt16(nTmp) );
else
pCol->SetRight( 0 );
pCol->SetLeft( 0 );
*/
}
}
pSet->Put( aCol );
}
if( pSet != &aSet ) // wurde der Set uebergeben, dann wars das
return ;
// ein neues FlyFormat anlegen oder das alte benutzen ?
// (teste ob es die selben Attribute besitzt!)
SwFlySave* pFlySave = 0;
sal_uInt16 nFlyArrCnt = aFlyArr.Count();
/*
#i5263#
There were not enough frame properties found to actually justify creating
an absolutely positioned frame.
*/
if (nAppliedProps)
{
if( !nFlyArrCnt ||
!( pFlySave = aFlyArr[ nFlyArrCnt-1 ])->IsEqualFly( *pPam, aSet ))
{
pFlySave = new SwFlySave( *pPam, aSet );
Size aPgSize;
GetPageSize( aPgSize );
pFlySave->nPageWidth = aPgSize.Width();
if( nDropCapAnchor )
{
pFlySave->nDropAnchor = nDropCapAnchor;
pFlySave->nDropLines = nDropCapLines;
}
if (nFlyArrCnt >0){
SwFlySave* pFlySavePrev = aFlyArr[nFlyArrCnt-1];
if (pFlySave->nSttNd.GetIndex() < pFlySavePrev->nEndNd.GetIndex())
{
pFlySavePrev->nEndNd=pFlySave->nSttNd;
}
}
aFlyArr.Insert( pFlySave, nFlyArrCnt++ );
// --> OD 2008-12-22 #i83368# - reset
mbReadCellWhileReadSwFly = false;
// <--
}
}
SetPardTokenRead( sal_False );
const SwTableNode* pTblNd = pPam->GetNode()->FindTableNode();
while( !IsPardTokenRead() && IsParserWorking() )
{
if( RTF_PARD == nToken || nNumOpenBrakets > GetOpenBrakets() )
break;
NextToken( nToken );
if( !IsPardTokenRead() )
{
// #102781#. Added support for transparent frames.
if (nToken == RTF_CBPAT && nFlyArrCnt > 0)
{
sal_uInt16 _index=sal_uInt16(nTokenValue);
const Color& rColor = GetColor(_index);
SvxBrushItem aBrush(rColor, RES_BACKGROUND);
SwFlySave* pFS = aFlyArr[nFlyArrCnt-1];
pFS->aFlySet.Put(aBrush, RES_BACKGROUND);
}
nToken = GetNextToken();
// BUG 22036: kommt zwischen Fly-Attributen ein unbekanntes,
// dann erzeuge nie 2 FlyFrames, sondern fasse
// beide zusammen !!!
while( RTF_APOCTL == ( nToken & ~(0xff | RTF_SWGDEFS) ))
{
if( RTF_FLY_INPARA == nToken )
break;
if( RTF_IGNOREFLAG == SkipToken( -1 ) )
{
if( '{' == SkipToken( -1 ) )
nToken = '{';
else
SkipToken( 2 );
}
else
SkipToken( 1 );
ReadFly( nToken, pFlySave ? &pFlySave->aFlySet : 0);
nToken = GetNextToken();
}
}
}
/*
#i5263#
There were enough frame properties found to actually justify creating
an absolutely positioned frame.
*/
if (!nAppliedProps)
{
bReadSwFly = false;
SkipToken( -1 );
return;
}
if( pTblNd && !pPam->GetPoint()->nContent.GetIndex() &&
pTblNd->EndOfSectionIndex() + 1 ==
pPam->GetPoint()->nNode.GetIndex() )
{
// nicht mehr in der Tabelle, sondern dahinter ?
// Dann aber wieder zurueck in die Tabelle
pPam->Move( fnMoveBackward );
}
else
pTblNd = 0;
// wurde garnichts eingefuegt?
if( !pTblNd &&
pPam->GetPoint()->nNode == pFlySave->nSttNd &&
!pPam->GetPoint()->nContent.GetIndex() )
{
// // dann erzeuge mindestens einen leeren TextNode
// pDoc->AppendTxtNode(*pPam);
// dann zerstoere den FlySave wieder.
aFlyArr.DeleteAndDestroy( --nFlyArrCnt );
}
else
{
sal_Bool bMovePaM = 0 != pTblNd;
pFlySave->nEndNd = pPam->GetPoint()->nNode;
pFlySave->nEndCnt = pPam->GetPoint()->nContent.GetIndex();
if( bMovePaM )
pPam->Move( fnMoveForward );
pTblNd = pFlySave->nSttNd.GetNode().FindTableNode();
if( pTblNd && !pFlySave->nEndCnt &&
pTblNd == pFlySave->nEndNd.GetNode().FindTableNode() )
{
// dann teste mal, ob das \pard nicht zu spaet kam und
// eigentlich in die vorherige Zelle gehoert
const SwStartNode* pSttBoxNd = pFlySave->nSttNd.GetNode().
FindTableBoxStartNode(),
* pEndBoxNd = pFlySave->nEndNd.GetNode().
FindTableBoxStartNode();
if( pSttBoxNd && pEndBoxNd &&
bMovePaM ? ( pSttBoxNd == pEndBoxNd )
: ( pSttBoxNd->EndOfSectionIndex() + 1 ==
pEndBoxNd->GetIndex() &&
pEndBoxNd->GetIndex() + 1 ==
pFlySave->nEndNd.GetIndex() ))
{
// dann gehoert das Ende in die vorherige Box!
SwPosition aPos( *pPam->GetPoint() );
pPam->GetPoint()->nNode = *pSttBoxNd->EndOfSectionNode();
pPam->Move( fnMoveBackward, fnGoNode );
DelLastNode();
pPam->GetPoint()->nNode = *pSttBoxNd->EndOfSectionNode();
pPam->Move( fnMoveBackward, fnGoNode );
pFlySave->nEndNd = pPam->GetPoint()->nNode;
pFlySave->nEndCnt = pPam->GetPoint()->nContent.GetIndex();
*pPam->GetPoint() = aPos;
}
}
else if( !bReadSwFly && !pFlySave->nEndCnt &&
pFlySave->nSttNd.GetIndex() + 1 == pFlySave->nEndNd.GetIndex() &&
pFlySave->nSttNd.GetNode().IsTxtNode() )
{
SwTxtNode* pTxtNd = pFlySave->nSttNd.GetNode().GetTxtNode();
SwTxtFlyCnt* pFlyCnt = 0;
if( 1 == pTxtNd->GetTxt().Len() &&
0 != (pFlyCnt = static_cast<SwTxtFlyCnt*>(
pTxtNd->GetTxtAttrForCharAt(0, RES_TXTATR_FLYCNT))) &&
pFlyCnt->GetFlyCnt().GetFrmFmt() )
{
// then move the content into the surrounded fly
SwFrmFmt* pFlyFmt = pFlyCnt->GetFlyCnt().GetFrmFmt();
const SwNodeIndex* pFlySNd = pFlyFmt->GetCntnt().GetCntntIdx();
SwNodeRange aRg( *pFlySNd, 1,
*pFlySNd->GetNode().EndOfSectionNode(), 0 );
// merge the itemsets
SwFmtFrmSize aSz1( (SwFmtFrmSize&)pFlyFmt->GetAttrSet().
Get( RES_FRM_SIZE ));
SwFmtFrmSize aSz2( (SwFmtFrmSize&)pFlySave->aFlySet.
Get( RES_FRM_SIZE ));
// if
if( !aRg.aStart.GetNode().IsNoTxtNode() ||
!aSz1.GetHeight() || !aSz1.GetWidth() ||
!aSz2.GetHeight() || !aSz2.GetWidth() ||
( aSz1.GetHeight() == aSz2.GetHeight() &&
aSz1.GetWidth() == aSz2.GetWidth() ) )
{
SfxItemSet aDiffs( pFlyFmt->GetAttrSet() );
aDiffs.ClearItem( RES_ANCHOR );
aDiffs.ClearItem( RES_FRM_SIZE );
aDiffs.ClearItem( RES_CNTNT );
aDiffs.Differentiate( pFlySave->aFlySet );
pFlySave->aFlySet.Put( aDiffs );
sal_Bool bSet = sal_False;
if( aSz1.GetHeight() && !aSz2.GetHeight() )
{
bSet = sal_True;
aSz2.SetHeight( aSz1.GetHeight() );
}
if( aSz1.GetWidth() && !aSz2.GetWidth() )
{
bSet = sal_True;
aSz2.SetWidth( aSz1.GetWidth() );
}
if( bSet )
pFlySave->aFlySet.Put( aSz2 );
// move any PageBreak/Desc Attr to the next Para
{
SwCntntNode* pSrcNd = pFlySave->nSttNd.GetNode().GetCntntNode();
SwCntntNode* pDstNd = pFlySave->nEndNd.GetNode().GetCntntNode();
::lcl_CpyBreakAttrs( pSrcNd, pDstNd, &pFlySave->nEndNd );
}
// create new txtnode, because the section does never be empty
pDoc->GetNodes().MakeTxtNode( aRg.aStart,
(SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
SwNodeIndex aTmp( pFlySave->nSttNd, +1 );
pDoc->MoveNodeRange( aRg, aTmp,
IDocumentContentOperations::DOC_MOVEDEFAULT );
// now delete the redundant txtnode
pDoc->GetNodes().Delete( pFlySave->nSttNd, 1 );
}
}
}
}
bReadSwFly = false;
SkipToken( -1 );
}
void SwRTFParser::InsPicture( const String& rGrfNm, const Graphic* pGrf,
const SvxRTFPictureType* pPicType )
{
// kennzeichen fuer Swg-Dokumente:
// (dann ist das FlyFmt fuer die Grafik!)
SwGrfNode * pGrfNd;
// --> OD 2008-12-22 #i83368#
// Assure that graphic node is enclosed by fly frame node.
// if( bReadSwFly )
if ( bReadSwFly && !mbReadCellWhileReadSwFly )
// <--
{
OSL_ENSURE(aFlyArr.Count(),
"SwRTFParser::InsPicture: fly array empty.");
if (aFlyArr.Count())
{
// erzeuge nur einen normalen GrafikNode und ersetze diesen gegen
// den vorhandenen Textnode
SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
pGrfNd = pDoc->GetNodes().MakeGrfNode( rIdx,
rGrfNm, aEmptyStr, // Name der Graphic !!
pGrf,
(SwGrfFmtColl*)pDoc->GetDfltGrfFmtColl() );
if( pGrfAttrSet )
pGrfNd->SetAttr( *pGrfAttrSet );
SwFlySave* pFlySave = aFlyArr[ aFlyArr.Count()-1 ];
pFlySave->nSttNd = rIdx.GetIndex() - 1;
if( 1 < aFlyArr.Count() )
{
pFlySave = aFlyArr[ aFlyArr.Count() - 2 ];
if( pFlySave->nEndNd == rIdx )
pFlySave->nEndNd = rIdx.GetIndex() - 1;
}
}
}
else
{
// wenn normale RTF-Grafik, dann steht diese im Textfluss !
SwAttrSet aFlySet( pDoc->GetAttrPool(), RES_OPAQUE, /*RES_OPAQUE,
RES_VERT_ORIENT,*/ RES_ANCHOR );
const SwPosition* pPos = pPam->GetPoint();
SwFmtAnchor aAnchor( FLY_AS_CHAR );
aAnchor.SetAnchor( pPos );
aFlySet.Put( aAnchor );
aFlySet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP ));
if (pDoc->IsInHeaderFooter(pPos->nNode))
{
SvxOpaqueItem aOpaqueItem(RES_OPAQUE, sal_False);
SwFmtSurround aSurroundItem(SURROUND_THROUGHT);
aFlySet.Put(aOpaqueItem);
aFlySet.Put(aSurroundItem);
}
SwFlyFrmFmt* pFlyFmt = pDoc->Insert( *pPam,
rGrfNm, aEmptyStr, // Name der Graphic !!
pGrf,
&aFlySet, // Attribute fuer den FlyFrm
pGrfAttrSet, NULL ); // Attribute fuer die Grafik
pGrfNd = pDoc->GetNodes()[ pFlyFmt->GetCntnt().GetCntntIdx()->
GetIndex()+1 ]->GetGrfNode();
_SetPictureSize( *pGrfNd, pPos->nNode,
(SfxItemSet&)pFlyFmt->GetAttrSet(),
pPicType );
if( pPicType )
{
PictPropertyNameValuePairs::const_iterator aIt = pPicType->aPropertyPairs.begin();
PictPropertyNameValuePairs::const_iterator aEnd = pPicType->aPropertyPairs.end();
while( aIt != aEnd)
{
if( aIt->first.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM( "wzDescription") ))
{
SwXFrame::GetOrCreateSdrObject( pFlyFmt );
pDoc->SetFlyFrmDescription( *(pFlyFmt), aIt->second );
}
else if( aIt->first.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM( "wzName") ))
{
SwXFrame::GetOrCreateSdrObject( pFlyFmt );
pDoc->SetFlyFrmTitle( *(pFlyFmt), aIt->second );
}
++aIt;
}
}
}
if( pGrfAttrSet )
DELETEZ( pGrfAttrSet );
}
void SwRTFParser::_SetPictureSize( const SwNoTxtNode& rNd,
const SwNodeIndex& rAnchor,
SfxItemSet& rSet,
const SvxRTFPictureType* pPicType )
{
Size aSize( ((SwNoTxtNode&)rNd).GetTwipSize() );
if( pPicType )
{
if( rNd.IsGrfNode() )
{
if( SvxRTFPictureType::WIN_METAFILE != pPicType->eStyle &&
pPicType->nGoalWidth && pPicType->nGoalHeight )
{
aSize.Width() = pPicType->nGoalWidth;
aSize.Height() =pPicType->nGoalHeight;
}
else if( SvxRTFPictureType::MAC_QUICKDRAW == pPicType->eStyle )
{
// IMMER auf 72 DPI bezogen, also 1pt == 20 Twip !!
aSize.Width() = pPicType->nWidth * 20;
aSize.Height() = pPicType->nHeight * 20;
}
else
{
// von 100TH_MM nach TWIP umrechenen!
// #117879# when \picwgoal resp \pichgoal are present, then use them.
// The values of \picwgoal and \picwgoal are already given in twips.
aSize.Width() = (pPicType->nGoalWidth?pPicType->nGoalWidth:(pPicType->nWidth*144)/254);
aSize.Height() = (pPicType->nGoalHeight?pPicType->nGoalHeight:(pPicType->nHeight*144)/254);
}
((SwGrfNode&)rNd).SetTwipSize( aSize );
}
if( 100 != pPicType->nScalX )
aSize.Width() = (((long)pPicType->nScalX) * ( aSize.Width() -
( pPicType->nCropL + pPicType->nCropR ))) / 100L;
if( 100 != pPicType->nScalY )
aSize.Height() = (((long)pPicType->nScalY) * ( aSize.Height() -
( pPicType->nCropT + pPicType->nCropB ))) / 100L;
}
//steht der Fly etwa in einer Tabelle ?
const SwNode* pAnchorNd = & rAnchor.GetNode();
const SwTableNode* pTblNd = pAnchorNd->FindTableNode();
if( pTblNd )
{
// Box feststellen:
const SwTableBox* pBox = pTblNd->GetTable().GetTblBox(
pAnchorNd->StartOfSectionIndex() );
if( pBox )
{
long nBoxWidth = pBox->GetFrmFmt()->GetFrmSize().GetWidth();
if( aSize.Width() > nBoxWidth )
aSize.Width() = nBoxWidth;
}
}
//JP 8.11.2001: bug 94450 - if no size exist, then the size is set by
// the swapin of the graphic.
SwGrfNode* pGrfNd;
if( !aSize.Width() && !aSize.Height() &&
0 != (pGrfNd = (SwGrfNode*)rNd.GetGrfNode() ) && pGrfNd->IsGrfLink() )
pGrfNd->SetChgTwipSize( sal_True );
// min. Werte einhalten !!
if( aSize.Width() < MINFLY )
aSize.Width() = MINFLY;
if( aSize.Height() < MINFLY)
aSize.Height() = MINFLY;
if( pPicType )
{
sal_Bool bChg = sal_False;
SwCropGrf aCrop;
/*
JP 28.07.99: Bug 67800 - no crop by MAC_QUICKDRAW. At time i dont know why
it has been coded. But this has used for any
RTF-File, but i dont found them.
if( SvxRTFPictureType::MAC_QUICKDRAW == pPicType->eStyle )
{
// evt. ein wenig Croppen ??
// IMMER auf 72 DPI bezogen, also 1pt == 20 Twip !!
long nTmp = pPicType->nWidth * 20;
if( nTmp != aSize.Width() )
{
// in der Breite (also rechts) croppen
aCrop.Right() = nTmp - aSize.Width();
aSize.Width() = nTmp;
bChg = sal_True;
}
nTmp = pPicType->nHeight * 20;
if( nTmp != aSize.Height() )
{
// in der Hoehe (also unten) croppen
aCrop.Bottom() = nTmp - aSize.Height();
aSize.Height() = nTmp;
bChg = sal_True;
}
}
*/
if( pPicType->nCropT )
{
aCrop.SetTop( pPicType->nCropT );
bChg = sal_True;
}
if( pPicType->nCropB )
{
aCrop.SetBottom( pPicType->nCropB );
bChg = sal_True;
}
if( pPicType->nCropL )
{
aCrop.SetLeft( pPicType->nCropL );
bChg = sal_True;
}
if( pPicType->nCropR )
{
aCrop.SetRight( pPicType->nCropR );
bChg = sal_True;
}
if( bChg )
{
// dann mal an die CropWerte an die GrafikSize anpassen.
((SwNoTxtNode&)rNd).SetAttr( aCrop );
}
}
rSet.Put( SwFmtFrmSize( ATT_FIX_SIZE, aSize.Width(), aSize.Height() ));
}
void SwRTFParser::GetPageSize( Size& rSize )
{
ASSERT(!maSegments.empty(), "not possible");
if (maSegments.empty())
{
rSize.Width() = 12240 - 1800 - 1800;
rSize.Height() = 15840 - 1440 - 1440;
return;
}
const rtfSection &rSect = maSegments.back();
rSize.Width() = rSect.maPageInfo.mnPgwsxn - rSect.maPageInfo.mnMarglsxn - rSect.maPageInfo.mnMargrsxn;
rSize.Height() = rSect.maPageInfo.mnPghsxn - rSect.maPageInfo.mnMargtsxn - rSect.maPageInfo.mnMargbsxn;
long nCols = rSect.NoCols();
if (1 < nCols)
{
rSize.Width() /= nCols;
rSize.Height() /= nCols;
}
}
void SwRTFParser::ReadBitmapData()
{
Graphic aGrf;
SvxRTFPictureType aPicType;
if( ReadBmpData( aGrf, aPicType ) )
InsPicture( aEmptyStr, &aGrf, &aPicType );
}
#ifdef READ_OLE_OBJECT
void SwRTFParser::ReadOLEData()
{
SvCacheStream aTmpFile( 0xA000 );
Graphic aGrf;
SvxRTFPictureType aPicType, aOleType;
int nToken, bValidOle = sal_True, bWeiter = sal_True;
int nOpenBrakets = 1; // die erste wurde schon vorher erkannt !!
String* pStr = 0;
String sObjClass, sObjName, sObjData;
while( nOpenBrakets && IsParserWorking() && bWeiter && bValidOle )
{
nToken = GetNextToken();
sal_uInt16 nVal = sal_uInt16( nTokenValue );
switch( nToken )
{
case '}': --nOpenBrakets; pStr = 0; break;
case '{':
{
if( RTF_IGNOREFLAG != GetNextToken() )
nToken = SkipToken( -1 );
else if( RTF_UNKNOWNCONTROL != GetNextToken() )
nToken = SkipToken( -2 );
else
{
// gleich herausfiltern
ReadUnknownData();
nToken = GetNextToken();
if( '}' != nToken )
eState = SVPAR_ERROR;
break;
}
++nOpenBrakets;
}
break;
case RTF_OBJECT:
case RTF_OBJEMB: // default ist embedded
case RTF_LINKSELF: // ??
case RTF_OBJLOCK: // ??
case RTF_OBJUPDATE: // ??
case RTF_OBJTIME: // ??
case RTF_OBJSETSIZE:
case RTF_OBJALIGN:
case RTF_OBJTRANSY:
case RTF_OBJATTPH:
break;
case RTF_OBJLINK: // ?? welche Daten sind das ??
case RTF_OBJAUTLINK: // ?? -""- ??
case RTF_OBJSUB:
case RTF_OBJPUB:
case RTF_OBJICEMB:
case RTF_OBJOCX:
case RTF_OBJHTML:
case RTF_OBJALIAS:
case RTF_OBJSECT:
bValidOle = sal_False; // diese Typen koennen wir nicht
break;
case RTF_OBJCLASS:
// Daten lesen
pStr = &sObjClass;
break;
case RTF_OBJNAME:
// Daten lesen
pStr = &sObjName;
break;
case RTF_OBJDATA:
pStr = &sObjData;
break;
case RTF_RESULT:
{
// hier weitermachen, wenn das OLE-Object ungueltig ist
bWeiter = sal_False;
}
break;
case RTF_RSLTBMP: // diese sollten wir ignorieren
case RTF_RSLTMERGE:
case RTF_RSLTPICT:
case RTF_RSLTRTF:
case RTF_RSLTTXT:
break;
case RTF_OBJW: aOleType.nWidth = nVal; break;
case RTF_OBJH: aOleType.nHeight = nVal; break;
case RTF_OBJCROPT: aOleType.nCropT = (short)nTokenValue; break;
case RTF_OBJCROPB: aOleType.nCropB = (short)nTokenValue; break;
case RTF_OBJCROPL: aOleType.nCropL = (short)nTokenValue; break;
case RTF_OBJCROPR: aOleType.nCropR = (short)nTokenValue; break;
case RTF_OBJSCALEX: aOleType.nScalX = nVal; break;
case RTF_OBJSCALEY: aOleType.nScalY = nVal; break;
case RTF_TEXTTOKEN:
if( 1 < nOpenBrakets && pStr )
{
if( pStr == &sObjData )
{
xub_StrLen nHexLen = HexToBin( aToken );
if( STRING_NOTFOUND != nHexLen )
bValidOle = sal_False;
else
{
aTmpFile.Write( (sal_Char*)aToken.GetBuffer(), nHexLen );
bValidOle = 0 == aTmpFile.GetError();
}
}
else
*pStr += aToken;
}
break;
}
}
if( bValidOle )
{
bValidOle = sal_False; // erstmal
}
if( !bWeiter ) // dann stehen wir noch im Result
{
// ist das Ole-Object Ok?
// -> dann solange SkipGroup rufen, bis zur letzten
// schliessenden Klammer
// ansonsten alle Token verarbeiten, bis zur letzten
// schliessenden Klammer
bWeiter = sal_True;
while( nOpenBrakets && IsParserWorking() && bWeiter )
{
switch( nToken = GetNextToken() )
{
case '}': --nOpenBrakets; break;
case '{': ++nOpenBrakets; break;
}
if( nOpenBrakets && !bValidOle )
NextToken( nToken );
}
}
if( !bValidOle && '}' != nToken )
SkipGroup();
SkipToken( -1 ); // die schliesende Klammer wird "oben" ausgewertet
}
#endif
/* vi:set tabstop=4 shiftwidth=4 expandtab: */