css::uno::UNO_QUERY );

if ( !xTasksSupplier.is() )

{

return;

}

css::uno::Reference< css::container::XElementAccess > xList( xTasksSupplier->getFrames(), css::uno::UNO_QUERY );

if ( !xList.is() )

{

return;

}

if ( !maThreads.empty() )

{

cancelAllJobs();

}

{

if ( !mpCancelJobsThread->allJobsCancelled() )

{

}

mpCancelJobsThread->stopWhenAllJobsCancelled();

if ( !mpCancelJobsThread->create() )

{

// error handling

delete mpCancelJobsThread;

mpCancelJobsThread = 0;

while ( !aThreads.empty() )

m_xContext );

if ( !mpTerminateOfficeThread->create() )

{

delete mpTerminateOfficeThread;

mpTerminateOfficeThread = 0;

}

{

if ( mpTerminateOfficeThread->isRunning() )

{

mpTerminateOfficeThread->StopOfficeTermination(); // thread kills itself.

}

else

if ( !maThreads.empty() )

{

cancelAllJobs();

}

{

if ( !mpCancelJobsThread->allJobsCancelled() )

{

}

mpCancelJobsThread->stopWhenAllJobsCancelled();

#include <pagedesc.hxx>

#include <poolfmt.hxx>

#include <SwNodeNum.hxx>

#define CHECK_TABLE(t) (t).CheckConsistency();

#else

#define CHECK_TABLE(t)

#endif

namespace

{

{

SwNodeIndex aNewIdx( *pCT->pTblNd,

rpBox->GetSttIdx() - pCT->nOldTblSttIdx );

pNewBox = new SwTableBox( pBoxFmt, aNewIdx, pCT->pInsLine );

pNewBox->setRowSpan( rpBox->getRowSpan() );

}

pDoc->InsDeletedFldType( *pDDEType );

else

pDDEType = (SwDDEFieldType*)pDoc->InsertFldType( *pDDEType );

// tauschen am Node den Tabellen-Pointer aus

SwDDETable* pNewTable = new SwDDETable( pTblNd->GetTable(), pDDEType );

}

else

{

"please tell me what you did to get here!");

pDoc->SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));

aRedlRest.Restore();

{

//JP 17.06.99: Bug 66973 - check count only if the selection is in

// the same (or no) section. Becaus not full selected

!rRg.aStart.GetNode().IsSectionNode() &&

!aTmpI.GetNode().IsEndNode() )

{

rRg.aEnd.GetIndex() - rRg.aStart.GetIndex(),

}

}

#endif

{

// This case can *not* happen, but to be robust take the first

// text node in the destination document.

"<SwDoc::_CopyFlyInFly(..)> - anchor text node in copied range not found" );

nAnchorTxtNdNumInRange = 1;

}

{

// This case can *not* happen, but to be robust take the first

// text node in the destination document.

"<SwDoc::_CopyFlyInFly(..)> - found anchor node index isn't a text node" );

aAnchorNdIdx = rStartIdx;

while ( !aAnchorNdIdx.GetNode().IsTxtNode() )

//Alle chains, die im Original vorhanden sind, soweit wie moeglich wieder

//aufbauen.

if ( aArr.Count() == aNewArr.Count() )

{

for ( USHORT n = 0; n < aArr.Count(); ++n )

#include "error.h" // fuers ASSERT

#include "ndindex.hxx"

int SwNodeIndex::nSerial = 0;

#endif

{

rNds.RegisterIndex( *this );

MySerial = ++nSerial; // nur in der nicht PRODUCT-Version

#endif

}

pNd = rIdx.pNd;

pNd->GetNodes().RegisterIndex( *this );

MySerial = ++nSerial; // nur in der nicht PRODUCT-Version

#endif

}

pNd = (SwNode*)&rNd;

pNd->GetNodes().RegisterIndex( *this );

MySerial = ++nSerial; // nur in der nicht PRODUCT-Version

#endif

}

// fuer Frame- und Grafik-Attributen

void SwNoTxtNode::NewAttrSet( SwAttrPool& rPool )

{

SwAttrSet aNewAttrSet( rPool, aNoTxtNodeSetRange );

// put names of parent style and conditional style:

void SwNoTxtNode::CreateContour()

{

pContour = new PolyPolygon(SvxContourDlg::CreateAutoContour(GetGraphic()));

bAutomaticContour = TRUE;

bContourMapModeValid = TRUE;

const MapMode aContourMap( bPixelGrf ? MAP_PIXEL : MAP_100TH_MM );

if( bPixelGrf ? !bPixelContour : aGrfMap != aContourMap )

{

"scale factor for pixel unsupported" );

OutputDevice* pOutDev =

(bPixelGrf || bPixelContour) ? Application::GetDefaultDevice()

void SwNoTxtNode::GetContour( PolyPolygon &rPoly ) const

{

rPoly = *HasContour();

}

{

const MapMode aGrfMap( GetGraphic().GetPrefMapMode() );

const MapMode aContourMap( MAP_100TH_MM );

aGrfMap == MapMode( MAP_PIXEL ),

"scale factor for pixel unsupported" );

if( aGrfMap.GetMapUnit() != MAP_PIXEL &&

}

else

{

aRet = *((SwOLENode*)this)->SwOLENode::GetGraphic();

}

return aRet;

{

// Title attribute of <SdrObject> replaces own AlternateText attribute

SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(GetFlyFmt());

"<SwNoTxtNode::SetTitle(..)> - missing <SwFlyFrmFmt> instance" );

if ( !pFlyFmt )

{

const String SwNoTxtNode::GetTitle() const

{

const SwFlyFrmFmt* pFlyFmt = dynamic_cast<const SwFlyFrmFmt*>(GetFlyFmt());

"<SwNoTxtNode::GetTitle(..)> - missing <SwFlyFrmFmt> instance" );

if ( !pFlyFmt )

{

void SwNoTxtNode::SetDescription( const String& rDescription, bool bBroadcast )

{

SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(GetFlyFmt());

"<SwNoTxtNode::SetDescription(..)> - missing <SwFlyFrmFmt> instance" );

if ( !pFlyFmt )

{

const String SwNoTxtNode::GetDescription() const

{

const SwFlyFrmFmt* pFlyFmt = dynamic_cast<const SwFlyFrmFmt*>(GetFlyFmt());

"<SwNoTxtNode::GetDescription(..)> - missing <SwFlyFrmFmt> instance" );

if ( !pFlyFmt )

{

//JP 17.03.98: aufgrund des Bug 48592 - wo unter anderem nach Undo/Redo

// Nodes aus dem falschen NodesArray im OutlineArray standen,

// jetzt mal einen Check eingebaut.

{

for( USHORT n = 1; n < nO; ++n )

if( &(*this)[ n-1 ]->GetNodes() !=

&(*this)[ n ]->GetNodes() )

{

}

}

#endif

}

else

{

"<SwNodes::UpdateOutlineNode(..)> - given text node isn't in the correct nodes array. This is a serious defect -> inform OD" );

}

// <--

// if( 0 == nOldLevel ) //<-end, zhaojianwei

// {

// // nicht vorhanden, also einfuegen

//

// //JP 12.03.99: 63293 - Nodes vom RedlineBereich NIE aufnehmen

// ULONG nNd = rNd.GetIndex();

// }

// else

// {

// "<SwNodes::UpdateOutlineNode(..)> - node <pSrch> isn't in correct nodes array. This is a serious defect -> inform OD" );

// }

// // <--

? !_rNds.GoPrevSection( &aChkIdx, FALSE, FALSE )

: !_rNds.GoNextSection( &aChkIdx, FALSE, FALSE ) )

{

return false;

}

else

if( rRange.HasMark() &&

0 == ( nRegionRet = IsInsRegionAvailable( rRange, &pPrvNd ) ))

{

return 0;

}

*pEndPos = (SwPosition*)rRange.End();

if( pPrvNd && 3 == nRegionRet )

{

SwNodeIndex aStt( pSttPos->nNode ), aEnd( pEndPos->nNode, +1 );

while( pPrvNd != aStt.GetNode().StartOfSectionNode() )

aStt--;

if( !pEnde ) // kein Bereich also neue Section davor/hinter anlegen

{

// #i26762#

"Section start and end in wrong order!");

if( bInsAtStart )

SwFrm* pTmp = pFrm;

while( pTmp )

{

if( pTmp->IsSctFrm() )

{

SwSectionFrm* pSectFrm = (SwSectionFrm*)pFrm;

SwFrm *pFrm, *pNew;

while( 0 != (pFrm = aNode2Layout.NextFrm()) )

{

pNew = rIdx.GetNode().GetCntntNode()->MakeFrm();

SwSectionNode* pS = rIdx.GetNode().FindSectionNode();

SwLayoutFrm* pUp = pSct;

while( pUp->Lower() ) // for columned sections

{

pUp = (SwLayoutFrm*)pUp->Lower();

}

pNew->Paste( pUp, NULL );

void SwSectionNode::MakeFrms( SwNodeIndex* pIdxBehind, SwNodeIndex* pEndIdx )

{

SwNodes& rNds = GetNodes();

SwDoc* pDoc = rNds.GetDoc();

::std::auto_ptr<SwTOXBase> pTOXBase;

if (TOX_CONTENT_SECTION == GetSection().GetType())

{

SwTOXBaseSection const& rTBS(

dynamic_cast<SwTOXBaseSection const&>(GetSection()));

pTOXBase.reset( new SwTOXBase(rTBS, pDoc) );

BOOL SwSectionNode::IsCntntHidden() const

{

"That's simple: Hidden Section => Hidden Content" );

SwNodeIndex aTmp( *this, 1 );

ULONG nEnd = EndOfSectionIndex();

{

if( aTmp.GetNode().IsCntntNode() || aTmp.GetNode().IsTableNode() )

return FALSE; // Nicht versteckter Inhalt wurde gefunden

}

aTmp++;

}

// verschieben vom Nodes- ins UndoNodes-Array?

if( rNds.IsDocNodes() )

{

"verschieben in unterschiedliche Documente?" );

if (m_pSection->IsLinkType())

{

// <--

#include <fldupde.hxx>

#define CHECK_TABLE(t) (t).CheckConsistency();

#else

#define CHECK_TABLE(t)

#endif

using namespace ::com::sun::star;

{

if( !nCnt )

return FALSE;

// Index hinter die letzte Box der Line

ULONG nIdxPos = 0;

BOOL bCalledFromShell,

BOOL bNewModel )

{

{

// nicht in Fussnoten kopieren !!

if( aRg.aEnd.GetIndex() == aRg.aStart.GetIndex() )

{

aRg.aEnd++;

}

GetTxtCollFromPool( RES_POOLCOLL_STANDARD ), pUndo );

SwTable * pNdTbl = &pTblNd->GetTable();

const USHORT nRowsToRepeat =

tabopts::HEADLINE == (rInsTblOpts.mnInsMode & tabopts::HEADLINE) ?

aSttIdx += 2, nLines++, nBoxes = 0 )

{

SwTxtNode* pTxtNd = aSttIdx.GetNode().GetTxtNode();

if( !nLines && 0x0b == cCh )

{

// damit die Tabelle die richtige Groesse bekommt, im BoxFormat die

// Groesse nach "oben" transportieren.

pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nLastPos ));

}

else

if( aRg.aEnd.GetIndex() == aRg.aStart.GetIndex() )

{

aRg.aEnd++;

}

GetTxtCollFromPool( RES_POOLCOLL_STANDARD )/*, pUndo*/ );

SwTable * pNdTbl = &pTblNd->GetTable();

pTableFmt->Add( pNdTbl ); // das Frame-Format setzen

// const USHORT nRowsToRepeat =

++aRowIter, /*aSttIdx += 2, */nLines++, nBoxes = 0 )

{

// SwTxtNode* pTxtNd = aSttIdx.GetNode().GetTxtNode();

pLine = new SwTableLine( pLineFmt, 1, 0 );

pTable->GetTabLines().C40_INSERT( SwTableLine, pLine, nLines );

// damit die Tabelle die richtige Groesse bekommt, im BoxFormat die

// Groesse nach "oben" transportieren.

pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nLastPos ));

}

else

BOOL lcl_DelLine( const SwTableLine*& rpLine, void* pPara )

{

_DelTabPara aPara( *(_DelTabPara*)pPara );

((SwTableLine*&)rpLine)->GetTabBoxes().ForEach( &lcl_DelBox, &aPara );

if( rpLine->GetUpper() ) // gibt es noch eine uebergeordnete Box ??

BOOL lcl_DelBox( const SwTableBox*& rpBox, void* pPara )

{

// loesche erstmal die Lines der Box

_DelTabPara* pDelPara = (_DelTabPara*)pPara;

BOOL SwDoc::InsertCol( const SwSelBoxes& rBoxes, USHORT nCnt, BOOL bBehind )

{

// uebers SwDoc fuer Undo !!

SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();

if( !pTblNd )

return FALSE;

BOOL SwDoc::InsertRow( const SwSelBoxes& rBoxes, USHORT nCnt, BOOL bBehind )

{

// uebers SwDoc fuer Undo !!

SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();

if( !pTblNd )

return FALSE;

return FALSE;

// uebers SwDoc fuer Undo !!

SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();

if( !pTblNd )

return FALSE;

sal_Bool bSameHeight )

{

// uebers SwDoc fuer Undo !!

SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();

if( !pTblNd )

return FALSE;

SwFrm *pFrm, *pNew;

SwCntntNode * pNode = rIdx.GetNode().GetCntntNode();

BOOL bBefore = rIdx < GetIndex();

void SwTableNode::MakeFrms( SwNodeIndex* pIdxBehind )

{

*pIdxBehind = *this;

SwNode *pNd = GetNodes().FindPrvNxtFrmNode( *pIdxBehind, EndOfSectionNode() );

if( !pNd )

}

else if( !pCrsr && !pBoxFrm )

{

return ;

}

void SwDoc::GetTabRows( SwTabCols &rFill, const SwCursor* ,

const SwCellFrm* pBoxFrm ) const

{

// --> FME 2005-09-12 #121591# Make code robust:

if ( !pBoxFrm )

// --> FME 2005-09-12 #121591# Make code robust:

if ( aDelCheck.HasBeenDeleted() )

{

return;

}

// <--

// --> FME 2005-09-12 #121591# Make code robust:

const SwTabFrm* pTab = pBoxFrm->FindTabFrm();

if ( !pTab )

return;

// <--

}

// delete first and last entry

// --> FME 2006-01-19 #i60818# There may be only one entry in rFill. Make

// code robust by checking count of rFill.

if ( rFill.Count() ) rFill.Remove( 0, 1 );

}

else if( !pCrsr && !pBoxFrm )

{

return ;

}

const SwTableBox* pBox;

SwTabFrm *pTab;

pTab = ((SwFrm*)pBoxFrm)->ImplFindTabFrm();

pBox = pBoxFrm->GetTabBox();

// check for differences between aOld and rNew:

const USHORT nCount = rNew.Count();

const SwTable* pTable = pTab->GetTable();

for ( USHORT i = 0; i <= nCount; ++i )

{

SwTableNode * pNewTblNd;

{

SwEndNode* pOldTblEndNd = (SwEndNode*)pTNd->EndOfSectionNode()->GetEndNode();

SwNodeIndex aIdx( *pBox->GetSttNd() );

new SwEndNode( aIdx, *pTNd );

SwNode* pBoxNd = aIdx.GetNode().GetStartNode();

do {

pBoxNd->pStartOfSection = pNewTblNd;

pBoxNd = (*this)[ pBoxNd->EndOfSectionIndex() + 1 ];

} while( pBoxNd != pOldTblEndNd );

USHORT nMode, SwHistory* )

{

SwTableNode* pDelTblNd = rPos.GetNode().GetTableNode();

SwTableNode* pTblNd = (*this)[ rPos.GetIndex() - 1]->FindTableNode();

if( !pDelTblNd || !pTblNd )

return FALSE;

SwNode* pBoxNd = aIdx.GetNode().GetStartNode();

do {

pBoxNd->pStartOfSection = pTblNd;

pBoxNd = (*this)[ pBoxNd->EndOfSectionIndex() + 1 ];

} while( pBoxNd != pTblEndNd );

// AutoFormat fuer die Tabelle/TabellenSelection

BOOL SwDoc::SetTableAutoFmt( const SwSelBoxes& rBoxes, const SwTableAutoFmt& rNew )

{

SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();

if( !pTblNd )

return FALSE;

// Erfrage wie attributiert ist

BOOL SwDoc::GetTableAutoFmt( const SwSelBoxes& rBoxes, SwTableAutoFmt& rGet )

{

SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();

if( !pTblNd )

return FALSE;

{

SwTableBox* pBox = pInsTblNd->GetTable().GetTblBox(

pSttNd->GetIndex() );

aBoxes.Insert( pBox );

pBoxes = &aBoxes;

}

void lcl_GetStartEndCell( const SwCursor& rCrsr,

SwLayoutFrm *&prStart, SwLayoutFrm *&prEnd )

{

"Tabselection nicht auf Cnt." );

Point aPtPos, aMkPos;

// uns erst wieder zur Zelle hochhangeln

while ( !pCell->IsCellFrm() )

pCell = pCell->GetUpper();

if ( rUnion.IsOver( pCell->Frm() ) )

::InsertCell( rArr, (SwCellFrm*)pCell );

//Dafuer sorgen, dass die Zelle auch verlassen wird (Bereiche)

#***********************************************************************/

void SwDoc::SetBoxAlign( const SwCursor& rCursor, USHORT nAlign )

{

nAlign == text::VertOrientation::CENTER ||

nAlign == text::VertOrientation::BOTTOM, "wrong alignment" );

SwFmtVertOrient aVertOri( 0, nAlign );

const SwFmt* pConditionalFmt )

{

const SwAttrSet* pAttrSet = static_cast<const SwAttrSet*>(mrpAttrSet.get());

const SwAttrSet* pParentSet = pParentFmt ? &pParentFmt->GetAttrSet() : 0;

|*

*******************************************************************/

long SwNode::nSerial = 0;

#endif

pStartOfSection = (SwStartNode*)this;

}

nMySerial = nSerial;

nSerial++;

#endif

pStartOfSection = (SwStartNode*)this;

}

nMySerial = nSerial;

nSerial++;

#endif

}

if( n >= rFmts.Count() )

{

return FALSE;

}

}

// kann jetzt nur noch ein Seitengebundener Fly sein

// oder irgendetwas neueres.

// Hier koennen wir nur noch den Standard returnen

"wo befindet sich dieser Node?" );

pPgDesc = &pDoc->GetPageDesc( 0 );

SwFmtColl *SwCntntNode::ChgFmtColl( SwFmtColl *pNewColl )

{

SwFmtColl *pOldColl = GetFmtColl();

if( pNewColl != pOldColl )

void SwCntntNode::MakeFrms( SwCntntNode& rNode )

{

"Kein Contentnode oder Copy-Node und neuer Node identisch." );

if( !GetDepends() || &rNode == this ) // gibt es ueberhaupt Frames ??

SwFrm *pFrm, *pNew;

SwLayoutFrm *pUpper;

// Frames anlegen fuer Nodes, die vor oder hinter der Tabelle stehen ??

SwNode2Layout aNode2Layout( *this, rNode.GetIndex() );

!pFrm->GetIndPrev() )

{

SwFtnFrm *pFtn = pFrm->FindFtnFrm();

SwCntntFrm* pCFrm;

if( !pFtn->GetFollow() && !pFtn->GetMaster() &&

0 != ( pCFrm = pFtn->GetRefFromAttr()) && pCFrm->IsFollow() )

{

((SwTxtFrm*)pCFrm->FindMaster())->Prepare( PREP_FTN_GONE );

}

}

if( !GetpSwAttrSet() ) // lasse von den entsprechenden Nodes die

NewAttrSet( GetDoc()->GetAttrPool() ); // AttrSets anlegen

if ( IsInCache() )

{

const SfxPoolItem* pFnd = 0;

if( SFX_ITEM_SET == rSet.GetItemState( RES_AUTO_STYLE, FALSE, &pFnd ) )

{

const SwFmtAutoFmt* pTmp = static_cast<const SwFmtAutoFmt*>(pFnd);

// If there already is an attribute set (usually containing a numbering

if ( 0 == rWhichIds.size() )

return nRet;

SwAttrSet aNewAttrSet( *GetpSwAttrSet() );

for ( std::vector<USHORT>::const_iterator aIter = rWhichIds.begin();

aIter != rWhichIds.end();

pMod = (SwModify*)pNd->GetCntntNode();

else

{

pMod = pNd->GetTableNode()->GetTable().GetFrmFmt();

}

pIter = new SwClientIter( *pMod );

while( pRet )

{

SwFlowFrm* pFlow = SwFlowFrm::CastFlowFrm( pRet );

// Follows sind fluechtige Gestalten, deshalb werden sie ignoriert.

// Auch wenn wir hinter dem Frame eingefuegt werden sollen, nehmen wir

// zunaechst den Master, hangeln uns dann aber zum letzten Follow durch.

// und nicht ausserhalb liegt.

if( !pRet->IsInFtn() || pSct->IsInFtn() )

{

SwSectionNode* pNd = pSct->GetSection()->GetFmt()->GetSectionNode();

// Wenn der erhaltene Frame in einem Bereichsframe steht,

// dessen Bereich den Ausgangsnode nicht umfasst, so kehren

// wir mit dem SectionFrm zurueck, sonst mit dem Cntnt/TabFrm

{

pFrm = static_cast<SwLayoutFrm*>(pFrm)->Lower();

}

"<SwNode2LayImpl::UpperFrm(..)> - expected upper frame isn't a layout frame." );

rpFrm = bMaster ? NULL

: static_cast<SwLayoutFrm*>(pFrm)->Lower();

"<SwNode2LayImpl::UpperFrm(..)> - expected sibling isn't a flow frame." );

return static_cast<SwLayoutFrm*>(pFrm);

}

void SwNode2LayImpl::RestoreUpperFrms( SwNodes& rNds, ULONG nStt, ULONG nEnd )

{

SwNode* pNd;

SwDoc *pDoc = rNds.GetDoc();

BOOL bFirst = TRUE;

else

pNxt = pUp->Lower();

pNew = ((SwTableNode*)pNd)->MakeFrm();

pNew->Paste( pUp, pNxt );

((SwTabFrm*)pNew)->RegistFlys();

(*pUpperFrms)[x-2] = pNew;

if( bFirst && pNxt && pNxt->IsSctFrm() )

((SwSectionFrm*)pNxt)->UnlockJoin();

pUp = (SwLayoutFrm*)(*pUpperFrms)[x++];

::_InsertCnt( pUp, pDoc, pNd->GetIndex(), FALSE, nStt+1, pNxt );

pNxt = pUp->GetLastLower();

(*pUpperFrms)[x-2] = pNxt;

void SwNode2Layout::RestoreUpperFrms( SwNodes& rNds, ULONG nStt, ULONG nEnd )

{

pImpl->RestoreUpperFrms( rNds, nStt, nEnd );

}

{

bInNodesDel = bInDelUpdOutl = bInDelUpdNum = FALSE;

ULONG nPos = 0;

SwStartNode* pSttNd = new SwStartNode( *this, nPos++ );

if( !pFrmNd && aFrmNdIdx > rNds.GetEndOfExtras().GetIndex() )

{

aFrmNdIdx = rNds.GetEndOfContent();

pFrmNd = rNds.GoPrevSection( &aFrmNdIdx, TRUE, FALSE );

if( pFrmNd && !((SwCntntNode*)pFrmNd)->GetDepends() )

pFrmNd = 0;

if( !pFrmNd )

#endif

}

if( pFrmNd )

}

else // es wurden alle Nodes innerhalb eines

{ // Start- und End-Nodes verschoben

( pAktNode->IsStartNode() &&

aSttNdStack[nLevel]->IsSectionNode()),

"falscher StartNode" );

}

}

else {

}

aRg.aEnd--;

break;

default:

break;

}

if ( &pStt->nNode.GetNode() == &GetEndOfContent() )

{

const bool bSuccess = GoPrevious( &pStt->nNode );

(void) bSuccess;

}

pStt->nContent.Assign( (*this)[ pStt->nNode ]->GetCntntNode(),

aInsPos++; // ueberspringen

}

else {

}

break;

default:

}

aRg.aStart++;

}

void SwSection::ImplSetHiddenFlag(bool const bTmpHidden, bool const bCondition)

{

SwSectionFmt* pFmt = GetFmt();

if( pFmt )

{

const bool bHide = bTmpHidden && bCondition;

bool SwSection::IsProtect() const

{

SwSectionFmt *const pFmt( GetFmt() );

return (pFmt)

? pFmt->GetProtect().IsCntntProtected()

: IsProtectFlag();

bool SwSection::IsEditInReadonly() const

{

SwSectionFmt *const pFmt( GetFmt() );

return (pFmt)

? pFmt->GetEditInReadonly().GetValue()

: IsEditInReadonlyFlag();

void SwSection::SetProtect(bool const bFlag)

{

SwSectionFmt *const pFormat( GetFmt() );

if (pFormat)

{

SvxProtectItem aItem( RES_PROTECT );

void SwSection::SetEditInReadonly(bool const bFlag)

{

SwSectionFmt *const pFormat( GetFmt() );

if (pFormat)

{

SwFmtEditInReadonly aItem;

return (SwSectionPtr)aIter.First( TYPE(SwSection) );

}

return 0;

}

{

const SwSectionFmt* pFSectFmt = (*(SwSectionPtr*)pFirst)->GetFmt();

const SwSectionFmt* pSSectFmt = (*(SwSectionPtr*)pSecond)->GetFmt();

pFSectFmt->GetCntnt(FALSE).GetCntntIdx() &&

pSSectFmt->GetCntnt(FALSE).GetCntntIdx(),

"ungueltige Sections" );

{

const SwSectionPtr pFSect = *(SwSectionPtr*)pFirst;

const SwSectionPtr pSSect = *(SwSectionPtr*)pSecond;

StringCompare const eCmp =

pFSect->GetSectionName().CompareTo( pSSect->GetSectionName() );

return eCmp == COMPARE_EQUAL ? 0

{

if ( !rSectNd.GetDoc() )

{

"method <lcl_RemoveSectionLinksInSect(..)> - no Doc at SectionNode" );

return;

}

if ( !rSectNd.GetSection().IsConnected() )

{

"method <lcl_RemoveSectionLinksInSect(..)> - no Link at Section of SectionNode" );

return;

}

void SwSection::CreateLink( LinkCreateType eCreateType )

{

SwSectionFmt* pFmt = GetFmt();

if (!pFmt || (CONTENT_SECTION == m_Data.GetType()))

return ;

}

break;

default:

}

switch( eCreateType )

if (m_RefLink.Is())

{

SwSectionFmt *const pFormat( GetFmt() );

if (pFormat)

{

pFormat->GetDoc()->GetLinkManager().Remove( m_RefLink );

{

if( !pCntntNode )

{

return ;

}

if( bWaitForData && !GetObj() )

{

bRes = FALSE;

}

else if( 0 != ( bRes = aValue.hasValue() ) )

}

}

return 0;

}

}

else

{

}

}

}

else

{

}

}

else