initial import

1 files changed, 353 insertions, 0 deletions

diff --git a/sw/inc/ndarr.hxx b/sw/inc/ndarr.hxx
new file mode 100644
index 000000000000..c6958373c493
--- /dev/null
+++ b/sw/inc/ndarr.hxx
@@ -0,0 +1,353 @@
+/*************************************************************************
+ *
+ *  $RCSfile: ndarr.hxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:14:27 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#ifndef _NDARR_HXX
+#define _NDARR_HXX
+
+#ifndef _SVARRAY_HXX //autogen
+#include <svtools/svarray.hxx>
+#endif
+
+#ifndef _BPARR_HXX
+#include <bparr.hxx>
+#endif
+#ifndef _NDTYP_HXX
+#include <ndtyp.hxx>
+#endif
+
+class Graphic;
+class UniString;
+class SvInPlaceObject;
+class SwAttrSet;
+class SwCntntFrm;
+class SwCntntNode;
+class SwDoc;
+class SwGrfFmtColl;
+class SwGrfNode;
+class SwHistory;
+class SwNode;
+class SwNodeIndex;
+class SwNodeRange;
+class SwOLENode;
+class SwOutlineNodes;
+class SwPaM;
+class SwSection;
+class SwSectionFmt;
+class SwSectionNode;
+class SwStartNode;
+class SwTableBoxFmt;
+class SwTableFmt;
+class SwTableLine;
+class SwTableLineFmt;
+class SwTableNode;
+class SwTblToTxtSaves;
+class SwTxtFmtColl;
+class SwTxtNode;
+class SwUndoInsNum;
+class SwUndoTblToTxt;
+class SwUndoTxtToTbl;
+struct SwPosition;
+
+
+// --------------------
+// class SwNodes
+// --------------------
+
+typedef SwNode * SwNodePtr;
+typedef BOOL (*FnForEach_SwNodes)( const SwNodePtr&, void* pArgs );
+
+SV_DECL_PTRARR_SORT( SwOutlineNodes, SwNodePtr, 0, 10 )
+
+class SwNodes: private BigPtrArray
+{
+    friend class SwDoc;
+    friend class SwNode;
+    friend class SwNodeIndex;
+
+    SwNodePtr operator[]( USHORT n ) const;
+    SwNodePtr operator[]( int n ) const;
+
+    SwNodeIndex* pRoot;                 // Liste aller Indizies auf Nodes
+
+    void Insert( const SwNodePtr pNode, const SwNodeIndex& rPos );
+    void Insert( const SwNodePtr pNode, ULONG nPos);
+//  void Remove( const SwNodeIndex& rPos, USHORT nLen = 1 );
+//  void Remove( ULONG nPos, USHORT nLen = 1 );
+//  BOOL Move( const SwIndex & rOldPos, const SwIndex & rNewPos );
+
+
+    SwDoc* pMyDoc;                      // in diesem Doc ist das Nodes-Array
+
+    SwNode *pEndOfPostIts, *pEndOfInserts,  // das sind die festen Bereiche
+           *pEndOfAutotext, *pEndOfRedlines,
+           *pEndOfContent;
+
+    SwOutlineNodes* pOutlineNds;        // Array aller GliederiungsNodes
+
+    BOOL bInNodesDel : 1;               // falls rekursiv aufgerufen wird
+                                        // Num/Outline nicht aktualisierem
+    BOOL bInDelUpdOutl : 1;             // Flags fuers aktualisieren von Outl.
+    BOOL bInDelUpdNum : 1;              // Flags fuers aktualisieren von Outl.
+
+    // fuer dier Verwaltung der Indizies
+    void RegisterIndex( SwNodeIndex& rIdx );
+    void DeRegisterIndex( SwNodeIndex& rIdx );
+    void RemoveNode( ULONG nDelPos, ULONG nLen, FASTBOOL bDel );
+
+    // Aktionen auf die Nodes
+    void SectionUpDown( const SwNodeIndex & aStart, const SwNodeIndex & aEnd );
+    void DelNodes( const SwNodeIndex& rStart, ULONG nCnt = 1 );
+
+    void ChgNode( SwNodeIndex& rDelPos, ULONG nSize,
+                  SwNodeIndex& rInsPos, BOOL bNewFrms );
+
+    void UpdtOutlineIdx( const SwNode& );   // Update ab Node alle OutlineNodes
+
+    void _CopyNodes( const SwNodeRange&, const SwNodeIndex&,
+                    BOOL bNewFrms = TRUE, BOOL bTblInsDummyNode = FALSE ) const;
+    void _DelDummyNodes( const SwNodeRange& rRg );
+
+protected:
+    SwNodes( SwDoc* pDoc );
+
+public:
+    ~SwNodes();
+
+    SwNodePtr operator[]( ULONG n ) const
+        { return (SwNodePtr)BigPtrArray::operator[] ( n ); }
+
+//JP 29.09.97: impl. steht im ndindex.hxx - sollte moeglichst bald auf die
+//              neue Schnittstelle angepasst werden
+    inline SwNodePtr operator[]( const SwNodeIndex& rIdx ) const;
+
+    ULONG Count() const { return BigPtrArray::Count(); }
+    void ForEach( FnForEach_SwNodes fnForEach, void* pArgs = 0 )
+    {
+        BigPtrArray::ForEach( 0, BigPtrArray::Count(),
+                                (FnForEach) fnForEach, pArgs );
+    }
+    void ForEach( ULONG nStt, ULONG nEnd, FnForEach_SwNodes fnForEach, void* pArgs = 0 )
+    {
+        BigPtrArray::ForEach( nStt, nEnd, (FnForEach) fnForEach, pArgs );
+    }
+    void ForEach( const SwNodeIndex& rStart, const SwNodeIndex& rEnd,
+                    FnForEach_SwNodes fnForEach, void* pArgs = 0 );
+
+    // eine noch leere Section
+    SwNode& GetEndOfPostIts() const     { return *pEndOfPostIts; }
+    // Section fuer alle Fussnoten
+    SwNode& GetEndOfInserts() const     { return *pEndOfInserts; }
+    // Section fuer alle Flys/Header/Footers
+    SwNode& GetEndOfAutotext() const    { return *pEndOfAutotext; }
+    // Section fuer alle Redlines
+    SwNode& GetEndOfRedlines() const    { return *pEndOfRedlines; }
+    // das ist der letzte EndNode einer SonderSection. Hier nach kommt nur
+    // noch die normale ContentSection (also der BodyText)
+    SwNode& GetEndOfExtras() const      { return *pEndOfRedlines; }
+    // die normale ContentSection (also der BodyText)
+    SwNode& GetEndOfContent() const     { return *pEndOfContent; }
+
+    // ist das NodesArray das normale vom Doc? (nicht das UndoNds, .. )
+    // Implementierung steht im doc.hxx (weil man dazu Doc kennen muss) !
+    inline BOOL IsDocNodes() const;
+
+    USHORT GetSectionLevel(const SwNodeIndex &rIndex) const;
+    void Delete(const SwNodeIndex &rPos, ULONG nNodes = 1);
+
+    BOOL _MoveNodes( const SwNodeRange&, SwNodes& rNodes, const SwNodeIndex&,
+                BOOL bNewFrms = TRUE );
+    void Move( SwPaM&, SwPosition&, SwNodes& rNodes, BOOL bSplitNd=TRUE );
+
+    void _Copy( const SwNodeRange& rRg, const SwNodeIndex& rInsPos,
+                BOOL bNewFrms = TRUE ) const
+        {   _CopyNodes( rRg, rInsPos, bNewFrms ); }
+
+    void SectionUp( SwNodeRange *);
+    void SectionDown( SwNodeRange *pRange, SwStartNodeType = SwNormalStartNode );
+
+    BOOL CheckNodesRange( const SwNodeIndex& rStt, const SwNodeIndex& rEnd ) const;
+
+    void GoStartOfSection(SwNodeIndex *) const;
+    void GoEndOfSection(SwNodeIndex *) const;
+
+    SwCntntNode* GoNext(SwNodeIndex *) const;
+    SwCntntNode* GoPrevious(SwNodeIndex *) const;
+
+    //Gehe zum naechsten/vorherigen Cntnt/Tabellennode, fuer den
+    //es LayoutFrames gibt, dabei Kopf-/Fusszeilen/Rahmen etc. nicht verlassen
+    SwNode* GoNextWithFrm(SwNodeIndex *) const;
+    SwNode* GoPreviousWithFrm(SwNodeIndex *) const;
+
+    // zum naechsten Content-Node, der nicht geschuetzt oder versteckt ist
+    // (beides auf FALSE ==> GoNext/GoPrevious!!!)
+    SwCntntNode* GoNextSection( SwNodeIndex *, int bSkipHidden  = TRUE,
+                                           int bSkipProtect = TRUE ) const;
+    SwCntntNode* GoPrevSection( SwNodeIndex *, int bSkipHidden  = TRUE,
+                                           int bSkipProtect = TRUE ) const;
+
+    // erzeuge ein leere Section von Start und EndNode. Darf nur gerufen
+    // werden, wenn eine neue Section mit Inhalt erzeugt werden soll.
+    // Zum Beispiel bei den Filtern/Undo/...
+    SwStartNode* MakeEmptySection( const SwNodeIndex& rIdx,
+                                    SwStartNodeType = SwNormalStartNode );
+
+    SwCntntFrm *MakeFrm(const SwNodeIndex &rIndex);
+
+    // die Impl. von "Make...Node" stehen in den angegebenen .ccx-Files
+    SwTxtNode *MakeTxtNode( const SwNodeIndex & rWhere,
+                            SwTxtFmtColl *pColl,
+                            SwAttrSet* pAutoAttr = 0 ); // in ndtxt.cxx
+    SwStartNode* MakeTextSection( const SwNodeIndex & rWhere,
+                            SwStartNodeType eSttNdTyp,
+                            SwTxtFmtColl *pColl,
+                            SwAttrSet* pAutoAttr = 0 );
+
+    SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
+                            const UniString& rGrfName,
+                            const UniString& rFltName,
+                            const Graphic* pGraphic,
+                            SwGrfFmtColl *pColl,
+                            SwAttrSet* pAutoAttr = 0,
+                            BOOL bDelayed = FALSE );    // in ndgrf.cxx
+
+    SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
+                            SvInPlaceObject *pObj,
+                            SwGrfFmtColl *pColl,
+                            SwAttrSet* pAutoAttr = 0 ); // in ndole.cxx
+    SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
+                            UniString &rName,
+                            SwGrfFmtColl *pColl,
+                            SwAttrSet* pAutoAttr = 0 ); // in ndole.cxx
+
+        // Array aller GliederiungsNodes;
+    const SwOutlineNodes& GetOutLineNds() const { return *pOutlineNds; }
+        // ab einem bestimmten TextNode alle Updaten
+    void UpdateOutlineNode( const SwNode&, BYTE nOldLevel, BYTE nNewLevel );
+        // alle Nodes Updaten - Rule/Format-Aenderung
+    void UpdateOutlineNodes();
+
+        // fuege die Nodes fuer die Tabelle ein
+        // wenn Lines angegeben, erzeuge die Matrix aus Lines & Boxen
+        // ansonsten nur die Anzahl von Boxen.
+    SwTableNode* InsertTable( const SwNodeIndex& rNdIdx,
+                        USHORT nBoxes, SwTxtFmtColl* pCntntTxtColl,
+                        USHORT nLines=0, SwTxtFmtColl* pHeadlineTxtColl=0 );
+        // erzeuge aus dem makierten Bereich eine ausgeglichene Tabelle
+    SwTableNode* TextToTable( const SwNodeRange& rRange, sal_Unicode cCh,
+                                SwTableFmt* pTblFmt,
+                                SwTableLineFmt* pLineFmt,
+                                SwTableBoxFmt* pBoxFmt,
+                                SwTxtFmtColl* pTxtColl,
+                                SwUndoTxtToTbl* pUndo = 0 );
+        // erzeuge aus der Tabelle wieder normalen Text
+    BOOL TableToText( const SwNodeRange& rRange, sal_Unicode cCh,
+                        SwUndoTblToTxt* = 0 );
+        // steht im untbl.cxx und darf nur vom Undoobject gerufen werden
+    SwTableNode* UndoTableToText( ULONG nStt, ULONG nEnd,
+                        const SwTblToTxtSaves& rSavedData );
+
+        // fuege in der Line, vor der InsPos eine neue Box ein. Das Format
+        // wird von der nachfolgenden (vorhergenden;wenn an Ende) genommen
+        // in der Line muss schon eine Box vorhanden sein !
+    BOOL InsBoxen( SwTableNode*, SwTableLine*, SwTableBoxFmt*,
+                        // Formate fuer den TextNode der Box
+                        SwTxtFmtColl*, SwAttrSet* pAutoAttr,
+                        USHORT nInsPos, USHORT nCnt = 1 );
+        // Splittet eine Tabelle in der Grund-Zeile, in der der Index steht.
+        // Alle GrundZeilen dahinter wandern in eine neue Tabelle/-Node.
+        // Ist das Flag bCalcNewSize auf TRUE, wird fuer beide neuen Tabellen
+        // die neue SSize aus dem Max der Boxen errechnet; vorrausgesetzt,
+        // die SSize ist "absolut" gesetzt (LONG_MAX)
+        // (Wird zur Zeit nur fuer den RTF-Parser benoetigt)
+    SwTableNode* SplitTable( const SwNodeIndex& rPos, BOOL bAfter = TRUE,
+                                BOOL bCalcNewSize = FALSE );
+        // fuegt 2 Tabellen, die hintereinander stehen, wieder zusammen
+    BOOL MergeTable( const SwNodeIndex& rPos, BOOL bWithPrev = TRUE,
+                    USHORT nMode = 0, SwHistory* pHistory = 0 );
+
+        // fuege eine neue SwSection ein
+    SwSectionNode* InsertSection( const SwNodeIndex& rNdIdx,
+                                SwSectionFmt& rSectionFmt,
+                                const SwSection&,
+                                const SwNodeIndex* pEnde,
+                                BOOL bInsAtStart = TRUE,
+                                BOOL bCreateFrms = TRUE );
+
+        // in welchem Doc steht das Nodes-Array ?
+            SwDoc* GetDoc()         { return pMyDoc; }
+    const   SwDoc* GetDoc() const   { return pMyDoc; }
+
+        // suche den vorhergehenden [/nachfolgenden ] ContentNode oder
+        // TabellenNode mit Frames. Wird kein Ende angeben, dann wird mit
+        // dem FrameIndex begonnen; ansonsten, wird mit dem vor rFrmIdx und
+        // dem hintern pEnd die Suche gestartet. Sollte kein gueltiger Node
+        // gefunden werden, wird 0 returnt. rFrmIdx zeigt auf dem Node mit
+        // Frames
+    SwNode* FindPrvNxtFrmNode( SwNodeIndex& rFrmIdx,
+                                const SwNode* pEnd = 0 ) const;
+private:
+    // privater Constructor, weil nie kopiert werden darf !!
+    SwNodes( const SwNodes & rNodes );
+};
+
+
+
+#endif