KWTextFrameSet.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999, 2000 Reginald Stadlbauer <reggie@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#ifndef kwtextframeset_h
#define kwtextframeset_h
 
#include "KoRichText.h"
#include "KWFrameSet.h"
#include "KWFrameSetEdit.h"
#include <KoTextView.h>
#include <KoParagLayout.h>
#include <KoChangeCaseDia.h>
#include "KWVariable.h"
 
class KoGenStyles;
class KoParagStyle;
class KWDocument;
class DCOPObject;
#ifndef KWTextFormat
#define KWTextFormat KoTextFormat
#endif
class KWViewMode;
class KWTextDocument;
class KWordFrameSetIface;
class KWFrame;
class KWFrameViewManager;
 
class KoTextObject;
class KoDataToolInfo;
class KoVariable;
 
class TDEAction;
class KNamedCommand;
class KMacroCommand;
 
class TQDragObject;
class TQProgressDialog;

class KWTextFrameSet : public KWFrameSet, public KoTextFlow, public KoTextFormatInterface
{
    TQ_OBJECT
  
public:
    KWTextFrameSet( KWDocument *_doc, const TQString & name );
    KWTextFrameSet( KWDocument* doc, const TQDomElement& tag, KoOasisContext& context );
    ~KWTextFrameSet();
 
    virtual KWordFrameSetIface* dcopObject();

    virtual FrameSetType type() const { return FT_TEXT; }
 
    virtual KWFrameSetEdit * createFrameSetEdit( KWCanvas * canvas );

    KoTextObject * textObject() const { return m_textobj; }
 
    KoTextDocument *textDocument() const;
    KWTextDocument *kwTextDocument() const;
 
    void setProtectContent ( bool _protect ) { textObject()->setProtectContent(_protect);}
    bool protectContent() const { return textObject()->protectContent();}
 
    void clearUndoRedoInfo();

    KWFrame * documentToInternal( const KoPoint &dPoint, TQPoint &iPoint ) const;

    enum RelativePosition { InsideFrame, LeftOfFrame, TopOfFrame, AtEnd };
    KWFrame * documentToInternalMouseSelection( const KoPoint &dPoint, TQPoint &iPoint, RelativePosition& relPos, KWViewMode *viewMode ) const;

    KWFrame * internalToDocument( const KoPoint &relPoint, KoPoint &dPoint ) const;
    // version taking a LU point as input
    KWFrame * internalToDocument( const TQPoint &iPoint, KoPoint &dPoint ) const;

    KWFrame * internalToDocumentWithHint( const TQPoint &iPoint, KoPoint &dPoint, const KoPoint &hintDPoint ) const;

    KoPoint internalToDocumentKnowingFrame( const KoPoint &relPoint, KWFrame* theFrame ) const;
    // [deprecated?] version taking a LU point as input
    KoPoint internalToDocumentKnowingFrame( const TQPoint &iPoint, KWFrame* theFrame ) const;

    TQPoint moveToPage( int currentPgNum, short int direction ) const;

    virtual int availableHeight() const;

    bool isFrameEmpty( KWFrame * frame );
    virtual bool canRemovePage( int num );
    // reimp for internal reasons
    virtual void deleteFrame( unsigned int num, bool remove = true, bool recalc = true );
    void deleteFrame( KWFrame *frm, bool remove = true, bool recalc = true )
        { KWFrameSet::deleteFrame( frm, remove, recalc ); } // strange C++ feature ;)

    virtual void updateFrames( int flags = 0xff );

    void updateViewArea( TQWidget * w, KWViewMode* viewMode, const TQPoint & nPointBottom );
 
    virtual TQDomElement save( TQDomElement &parentElem, bool saveFrames = true )
    { return saveInternal( parentElem, saveFrames, false ); }

    virtual TQDomElement toXML( TQDomElement &parentElem, bool saveFrames = true )
    { return saveInternal( parentElem, saveFrames, true ); }
 
    virtual void load( TQDomElement &attributes, bool loadFrames = true );
    void loadOasisContent( const TQDomElement &bodyElem, KoOasisContext& context );
    KWFrame* loadOasis( const TQDomElement& frame, const TQDomElement &bodyElem, KoOasisContext& context );

    KWFrame* loadOasisTextFrame( const TQDomElement& frameTag, const TQDomElement &tag, KoOasisContext& context );

    void saveOasisContent( KoXmlWriter& writer, KoSavingContext& context ) const;
    virtual void saveOasis( KoXmlWriter& writer, KoSavingContext& context, bool saveFrames ) const;
 
    virtual TQString toPlainText() const;
 
    virtual void finalize();
    //virtual void preparePrinting( TQPainter *painter, TQProgressDialog *progress, int &processedParags );

    bool hasSelection() const;
    TQString selectedText() const;
 
    virtual void drawContents( TQPainter *painter, const TQRect &crect,
                               const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
                               KWFrameSetEdit* edit, KWViewMode *viewMode,
                               KWFrameViewManager *frameViewManager );
 
    virtual void drawFrame( KWFrame * frame, TQPainter *painter, const TQRect& fcrect, const TQRect& crect,
                            const TQPoint& translationOffset,
                            KWFrame *settingsFrame, const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
                            KWFrameSetEdit * edit, KWViewMode *viewMode, bool drawUnderlyingFrames );
 
    virtual void drawFrameContents( KWFrame * frame, TQPainter *painter, const TQRect & fcrect,
                                    const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
                                    KWFrameSetEdit * edit, KWViewMode *viewMode );
 
    void drawCursor( TQPainter *p, KoTextCursor *cursor, bool cursorVisible, KWCanvas *canvas, KWFrame *currentFrame );
    TQPoint cursorPos( KoTextCursor *cursor, KWCanvas* canvas, KWFrame* currentFrame );
 
 
    KCommand* pasteOasis( KoTextCursor * cursor, const TQByteArray & data, bool removeSelected );
    void insertTOC( KoTextCursor * cursor );
    KNamedCommand* insertFrameBreakCommand( KoTextCursor *cursor );
    void insertFrameBreak( KoTextCursor * cursor );
    KCommand * setPageBreakingCommand( KoTextCursor * cursor, int pageBreaking );
 
    TQRect paragRect( KoTextParag * parag ) const; // in normal coords
 
    KCommand *deleteAnchoredFrame( KWAnchor * anchor );
    void findPosition( const KoPoint &dPoint, KoTextParag * & parag, int & index );

    void highlightPortion( KoTextParag * parag, int index, int length, KWCanvas * canvas, bool repaint = true, KDialogBase* dialog = 0 );
    void removeHighlight( bool repaint = true );
 
    virtual void addTextFrameSets( TQPtrList<KWTextFrameSet> &lst, bool onlyReadWrite=false );

    void applyStyleChange( KoStyleChangeDefMap changed );

    virtual void setVisible( bool v );

    void setInlineFramesVisible(bool);
 
#ifndef NDEBUG
    virtual void printDebug();
#endif

    virtual void layout();
    virtual void invalidate();
 
    virtual int paragraphs();
    virtual int paragraphsSelected();
    virtual bool statistics( TQProgressDialog *progress, ulong & charsWithSpace, ulong & charsWithoutSpace,
        ulong & words, ulong& sentences, ulong & syllables, ulong & lines, bool selected );

    virtual void adjustMargins( int yp, int h, int reqMinWidth, int& leftMargin, int& rightMargin, int& pageWidth, KoTextParag* parag );
    virtual int adjustFlow( int y, int w, int h );

    int formatVertically( KoTextParag *parag, const TQRect& rect );
    void fixParagWidth( KWTextParag* parag );

    void ensureFormatted( KoTextParag * parag, bool emitAfterFormatting = true );

    KWViewMode * currentViewMode() const { return m_currentViewMode; }
    KWFrame * currentDrawnFrame() const { return m_currentDrawnFrame; }

    virtual KoTextFormat * currentFormat() const;

    virtual KCommand *setFormatCommand( const KoTextFormat * newFormat, int flags, bool zoomFont = false );

    virtual const KoParagLayout * currentParagLayoutFormat() const;
 
    virtual bool rtl() const ;
 

    virtual KCommand *setParagLayoutFormatCommand( KoParagLayout *newLayout, int flags, int marginIndex=-1);
 
    virtual KCommand *setChangeCaseOfTextCommand(KoChangeCaseDia::TypeOfCase _type);

    void renumberFootNotes( bool repaint = true );

    virtual KWTextFrameSet* nextTextObject( KWFrameSet * ) { return this;}

    bool minMaxInternalOnPage( int pageNum, int& topLU, int& bottomLU ) const;

    KoTextParag* paragAtLUPos( int yLU ) const;

    KWFootNoteFrameSet * insertFootNote( NoteType noteType, KWFootNoteVariable::Numbering numType, const TQString &manualString );
 
    KoTextDocCommand *deleteTextCommand( KoTextDocument *textdoc, int id, int index, const TQMemArray<KoTextStringChar> & str, const CustomItemsMap & customItemsMap, const TQValueList<KoParagLayout> & oldParagLayouts );
 
    TQString copyTextParag( KoXmlWriter& writer, KoSavingContext& context, int selectionId );

    TQByteArray sortText(SortType type) const;
 
    KoLinkVariable* linkVariableUnderMouse( const KoPoint& dPoint );
    KoVariable* variableUnderMouse( const KoPoint& dPoint );
 
signals:
    void frameDeleted( KWFrame* frame );

    void mainTextHeightChanged();
 
public slots:
    // Connected to KoTextObject
    void slotRepaintChanged();
 
protected slots:
    // All those slots are connected to KoTextObject
    void slotAvailableHeightNeeded();
    void slotAfterFormatting( int bottom, KoTextParag *lastFormatted, bool* abort );
    void slotNewCommand( KCommand *cmd );
    void slotParagraphDeleted(KoTextParag*_parag);
    void slotParagraphCreated(KoTextParag*_parag);
    void slotParagraphModified(KoTextParag*_parag, int /*KoTextParag::ParagModifyType*/, int, int);
 
 
protected: // for testing purposes
    KWTextFrameSet( const TQString & name );
 
private:
    void init();
    bool slotAfterFormattingNeedMoreSpace( int bottom, KoTextParag *lastFormatted );
    void slotAfterFormattingTooMuchSpace( int bottom );
    void getMargins( int yp, int h, int reqMinWidth, int* marginLeft, int* marginRight, int* pageWidth, int* validHeight,
                     int* breakBegin, int* breakEnd, KoTextParag* parag );
    bool checkVerticalBreak( int & yp, int & h, KoTextParag * parag, bool linesTogether, int breakBegin, int breakEnd );
    void frameResized( KWFrame *theFrame, bool invalidateLayout );
    TQValueList<KWFrame*> framesFromTo( int y1, int y2 ) const;
    double footerHeaderSizeMax( KWFrame *theFrame );
    double footNoteSize( KWFrame *theFrame );
    TQDomElement saveInternal( TQDomElement &parentElem, bool saveFrames, bool saveAnchorsFramesets );
    bool createNewPageAndNewFrame( KoTextParag* lastFormatted, int difference );
 
private:
    KoTextObject * m_textobj;
    KWViewMode * m_currentViewMode;
    KWFrame * m_currentDrawnFrame;
    int m_lastTextDocHeight;
};

class KWTextFrameSetEdit : public KoTextView, public KWFrameSetEdit
{
    TQ_OBJECT
  
public:
    KWTextFrameSetEdit( KWTextFrameSet * fs, KWCanvas * canvas );
    virtual ~KWTextFrameSetEdit();
 
    virtual KoTextViewIface* dcopObject();
 
    virtual KWFrameSetEdit* currentTextEdit(){return this;}
 
    virtual void terminate(bool removeselection=true);
 
    KWTextFrameSet * textFrameSet() const
    {
        return static_cast<KWTextFrameSet*>(frameSet());
    }
    KoTextDocument * textDocument() const
    {
        return textFrameSet()->textDocument();
    }
 
    // Just in case we change to containing a textview instead
    KoTextView * textView() { return this; }
 
    // Events forwarded by the canvas (when being in "edit" mode)
    virtual void keyPressEvent( TQKeyEvent * );
    virtual void keyReleaseEvent( TQKeyEvent * );
    virtual void imStartEvent( TQIMEvent * );
    virtual void imComposeEvent( TQIMEvent * );
    virtual void imEndEvent( TQIMEvent * );
    virtual void mousePressEvent( TQMouseEvent *, const TQPoint &, const KoPoint & );
    virtual void mouseMoveEvent( TQMouseEvent *, const TQPoint &, const KoPoint & ); // only called if button is pressed
    virtual void mouseReleaseEvent( TQMouseEvent *, const TQPoint &, const KoPoint & );
    virtual void mouseDoubleClickEvent( TQMouseEvent *, const TQPoint &, const KoPoint & );
    virtual void dragEnterEvent( TQDragEnterEvent * );
    virtual void dragMoveEvent( TQDragMoveEvent *, const TQPoint &, const KoPoint & );
    virtual void dragLeaveEvent( TQDragLeaveEvent * );
    virtual void dropEvent( TQDropEvent *, const TQPoint &, const KoPoint &, KWView* view );
    virtual void focusInEvent();
    virtual void focusOutEvent();
    virtual void selectAll();
 
    // Reimplemented from KoTextView
    virtual void drawCursor( bool b );
    virtual void showFormat( KoTextFormat *format );
    virtual bool pgUpKeyPressed();
    virtual bool pgDownKeyPressed();
    virtual void ctrlPgUpKeyPressed();
    virtual void ctrlPgDownKeyPressed();
 
    void setCursor( KoTextParag* parag, int index );
 
    void insertFrameBreak() { textFrameSet()->insertFrameBreak( cursor() ); }
    void insertWPPage();
    void insertVariable( int type, int subtype = 0 );
    void insertFootNote( NoteType noteType, KWFootNoteVariable::Numbering numType, const TQString& manualString );
    void insertCustomVariable( const TQString &name);
    void insertVariable( KoVariable *var,
                         KoTextFormat *format = 0 /*means currentFormat()*/,
                         bool refreshCustomMenu = false/*don't refresh all the time custom menu*/ );
 
    void insertLink(const TQString &_linkName, const TQString & hrefName);
    void insertComment(const TQString &_comment);
 
    void insertExpression(const TQString &_c);
    void insertFloatingFrameSet( KWFrameSet * fs, const TQString & commandName );
    void insertTOC() { textFrameSet()->insertTOC( cursor() ); }
    KCommand * setPageBreakingCommand( int pageBreaking )
    { return textFrameSet()->setPageBreakingCommand( cursor(), pageBreaking ); }
 
 
    //const KoParagLayout & currentParagLayout() const { return m_paragLayout; }
    double currentLeftMargin() const { return m_paragLayout.margins[TQStyleSheetItem::MarginLeft]; }
 
    virtual void removeToolTipCompletion();
 
    //bool isLinkVariable(const KoPoint &, bool setUrl=false);

    bool openLink( KoLinkVariable* variable );
    void openLink();
 
    void pasteData( TQMimeSource* data, int provides, bool drop );
    KCommand* pasteOasisCommand( TQMimeSource* data );

    KoBorder border(KoBorder::BorderType type);
 
public slots:
    // Reimplemented from KWFrameSet and connected to KoTextView's signals
    virtual void cut();
    virtual void copy();
    virtual void paste();
 
    // Reimplemented from KoTextView
    virtual void updateUI( bool updateFormat, bool force = false );
    virtual void ensureCursorVisible();
 
protected:
    // Reimplemented from KoTextView
    virtual void doAutoFormat( KoTextCursor* cursor, KoTextParag *parag, int index, TQChar ch );
    virtual bool doIgnoreDoubleSpace(KoTextParag * parag, int index,TQChar ch );
    virtual bool doCompletion( KoTextCursor* cursor, KoTextParag *parag, int index );
    virtual bool doToolTipCompletion( KoTextCursor* cursor, KoTextParag *parag, int index,int keyPress );
    virtual void showToolTipBox(KoTextParag *parag, int index, TQWidget *widget, const TQPoint &pos);
    virtual void textIncreaseIndent();
    virtual bool textDecreaseIndent();
 
    virtual void startDrag();
    TQDragObject * newDrag( TQWidget * parent );
 
private slots:
    void slotFrameDeleted(KWFrame *);
 
private:
    bool enterCustomItem( KoTextCustomItem* customItem, bool fromRight );
 
    KoParagLayout m_paragLayout;
    bool m_rtl; // maybe make part of KoParagLayout later
};
 
class KWFootNoteVariable;
class KWFootNoteFrameSet : public KWTextFrameSet
{
public:
    KWFootNoteFrameSet( KWDocument *doc, const TQString & name )
        : KWTextFrameSet( doc, name ), m_footNoteVar( 0L ) {}
 
    virtual KWordFrameSetIface* dcopObject();
 
    void setFootNoteVariable( KWFootNoteVariable* var );
    KWFootNoteVariable* footNoteVariable() const { return m_footNoteVar; }

    void createInitialFrame( int pageNum );

    void startEditing( KWCanvas* canvas );

    void setCounterText( const TQString& text );
 
    virtual bool isFootNote() const;
    virtual bool isEndNote() const;
 
private:
    KWFootNoteVariable* m_footNoteVar;
};
#endif