KoTextObject.h

/* This file is part of the KDE project
   Copyright (C) 2001-2006 David Faure <faure@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 kotextobject_h
#define kotextobject_h
 
#include <KoRichText.h>
#include "KoChangeCaseDia.h"
#include "KoStyleCollection.h"
#include "KoTextDocument.h"
#include <koffice_export.h>
 
class KoSavingContext;
class KCommand;
class KoTextFormat;
class TQProgressDialog;
class KoLinkVariable;
class KoVariable;
 
//#define TIMING_FORMAT
//#include <tqdatetime.h>
 
class KOTEXT_EXPORT KoTextFormatInterface
{
public:
    KoTextFormatInterface() {}
    virtual ~KoTextFormatInterface() {}
 
    virtual KoTextFormat * currentFormat() const = 0;
 
    virtual bool rtl() const = 0;
 
    virtual KCommand *setFormatCommand( const KoTextFormat *format, int flags, bool zoomFont = false ) = 0;
 
    virtual const KoParagLayout * currentParagLayoutFormat() const = 0;
 
    virtual KCommand *setParagLayoutFormatCommand( KoParagLayout *newLayout, int flags, int marginIndex=-1) = 0;
 
    virtual KCommand *setChangeCaseOfTextCommand(KoChangeCaseDia::TypeOfCase _type)=0;
 
    KoTextDocCommand *deleteTextCommand( KoTextDocument *textdoc, int id, int index, const TQMemArray<KoTextStringChar> & str, const CustomItemsMap & customItemsMap, const TQValueList<KoParagLayout> & oldParagLayouts );
 
    void setParagLayoutFormat( KoParagLayout *newLayout,int flags, int marginIndex=-1);
    void setFormat( KoTextFormat * newFormat, int flags, bool zoomFont = false );
 
    // Warning: use the methods that return a command! The others just leak the commands away
    //void setBold(bool on);
    KCommand *setBoldCommand(bool on);
    //void setItalic(bool on);
    KCommand *setItalicCommand(bool on);
    //void setUnderline(bool on);
    KCommand *setUnderlineCommand(bool on);
    //void setStrikeOut(bool on);
    KCommand *setDoubleUnderlineCommand( bool on );
    KCommand *setUnderlineColorCommand( const TQColor &color );
    KCommand *setStrikeOutCommand(bool on);
    //void setTextColor(const TQColor &color);
    KCommand *setTextColorCommand(const TQColor &color);
    //void setPointSize( int s );
    KCommand *setPointSizeCommand( int s );
    //void setFamily(const TQString &font);
    KCommand *setFamilyCommand(const TQString &font);
    //void setTextSubScript(bool on);
    KCommand *setTextSubScriptCommand(bool on);
    //void setTextSuperScript(bool on);
    KCommand *setTextSuperScriptCommand(bool on);
 
    //void setDefaultFormat();
    KCommand *setDefaultFormatCommand();
 
    //void setTextBackgroundColor(const TQColor &);
    KCommand *setTextBackgroundColorCommand(const TQColor &);
 
    //void setAlign(int align);
    KCommand *setAlignCommand(int align);
 
    //void setMargin(TQStyleSheetItem::Margin m, double margin);
    KCommand *setMarginCommand(TQStyleSheetItem::Margin m, double margin);
 
    //void setTabList(const KoTabulatorList & tabList );
    KCommand *setTabListCommand(const KoTabulatorList & tabList );
 
    //void setBackgroundColor(const TQColor & color );
    KCommand *setBackgroundColorCommand(const TQColor & color );
 
    //void setCounter(const KoParagCounter & counter );
    KCommand *setCounterCommand(const KoParagCounter & counter );
 
    KCommand *setLanguageCommand(const TQString &);
 
    KCommand *setShadowTextCommand( double shadowDistanceX, double shadowDistanceY, const TQColor& shadowColor );
 
    KCommand *setHyphenationCommand( bool _b );
 
 
    KCommand *setFontAttributeCommand( KoTextFormat::AttributeStyle _att);
 
    KCommand *setRelativeTextSizeCommand( double _size );
 
    KCommand *setOffsetFromBaseLineCommand( int _offset );
 
    KCommand *setWordByWordCommand( bool _b );
 
 
    TQColor textColor() const;
    TQFont textFont() const;
    TQString textFontFamily()const;
    TQString language() const;
    TQColor textBackgroundColor()const;
    TQColor textUnderlineColor()const;
 
    KoTextFormat::UnderlineType underlineType()const;
    KoTextFormat::StrikeOutType strikeOutType()const;
    KoTextFormat::UnderlineStyle underlineStyle()const;
    KoTextFormat::StrikeOutStyle strikeOutStyle()const;
 
 
 
    bool textUnderline()const;
    bool textDoubleUnderline()const;
 
    bool textBold()const;
    bool textStrikeOut()const;
    bool textItalic() const;
    bool textSubScript() const;
    bool textSuperScript() const;
    double shadowDistanceX() const;
    double shadowDistanceY() const;
    TQColor shadowColor() const;
    KoTextFormat::AttributeStyle fontAttribute() const;
    double relativeTextSize() const;
    int offsetFromBaseLine()const;
    bool wordByWord()const;
    bool hyphenation()const;
};
 
class KOTEXT_EXPORT KoTextObject : public TQObject, public KoTextFormatInterface
{
    TQ_OBJECT
  
public:
    KoTextObject( KoTextZoomHandler *zh, const TQFont& defaultFont, const TQString &defaultLanguage,
                  bool defaultHyphenation, KoParagStyle* defaultStyle, int tabStopWidth = -1,
                  TQObject* parent = 0, const char *name = 0 );
 
    KoTextObject( KoTextDocument *textdoc, KoParagStyle* defaultStyle,
                  TQObject* parent = 0, const char *name = 0 );
 
    virtual ~KoTextObject();
 
 
    static const char * acceptSelectionMimeType();
    static TQCString providesOasis( TQMimeSource* mime );
 
    void setNeedSpellCheck(bool b);
    bool needSpellCheck() const { return m_needsSpellCheck;}
    void setProtectContent(bool b) { m_protectContent = b; }
    bool protectContent() const{ return m_protectContent;}
    KoTextDocument *textDocument() const { return textdoc; }
 
    void setAvailableHeight( int avail ) { m_availableHeight = avail; }
    int availableHeight() const;
 
    void undo();
    void redo();
    void clearUndoRedoInfo();
 
    bool hasSelection() const { return textdoc->hasSelection( KoTextDocument::Standard, true ); }
    TQString selectedText( KoTextDocument::SelectionId selectionId = KoTextDocument::Standard ) const {
        return textdoc->selectedText( selectionId );
    }
    bool selectionHasCustomItems( KoTextDocument::SelectionId selectionId = KoTextDocument::Standard ) const;
 
    enum InsertFlag {
        DefaultInsertFlags = 0,
        CheckNewLine = 1, 
        OverwriteMode = 2,
        DoNotRemoveSelected = 4, 
        DoNotRepaint = 8         
    };
 
    void insert( KoTextCursor * cursor, KoTextFormat * currentFormat, const TQString &text,
                 const TQString & commandName,
                 KoTextDocument::SelectionId selectionId = KoTextDocument::Standard,
                 int insertFlags = DefaultInsertFlags, // KDE4: TODO use TQFlags
                 CustomItemsMap customItemsMap = CustomItemsMap() );
 
    void removeSelectedText( KoTextCursor * cursor, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard,
                             const TQString & cmdName = TQString(), bool createUndoRedo=true  );
 
    KCommand * replaceSelectionCommand( KoTextCursor * cursor, const TQString & replacement,
                                        const TQString & cmdName,
                                        KoTextDocument::SelectionId selectionId = KoTextDocument::Standard,
                                        int insertFlags = DefaultInsertFlags, // KDE4: TODO use TQFlags
                                        CustomItemsMap customItemsMap = CustomItemsMap() );
    KCommand * removeSelectedTextCommand( KoTextCursor * cursor, KoTextDocument::SelectionId selectionId, bool repaint = true );
    KCommand* insertParagraphCommand( KoTextCursor * cursor );
 
    void pasteText( KoTextCursor * cursor, const TQString & text, KoTextFormat * currentFormat,
                    bool removeSelected );
    void selectAll( bool select );
 
    void highlightPortion( KoTextParag * parag, int index, int length, bool repaint );
    void removeHighlight( bool repaint );
 
    KCommand *setFormatCommand( const KoTextFormat *format, int flags, bool zoomFont = false );
 
    KCommand *setFormatCommand( KoTextCursor * cursor, KoTextFormat ** currentFormat, const KoTextFormat *format, int flags, bool zoomFont = false, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
 
    enum KeyboardAction { // keep in sync with TQTextEdit
    ActionBackspace,
    ActionDelete,
    ActionReturn,
    ActionKill
    };
    void doKeyboardAction( KoTextCursor * cursor, KoTextFormat * & currentFormat, KeyboardAction action );
 
    // -- Paragraph settings --
    KCommand * setCounterCommand( KoTextCursor * cursor, const KoParagCounter & counter, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
    KCommand * setAlignCommand( KoTextCursor * cursor, int align , KoTextDocument::SelectionId selectionId = KoTextDocument::Standard);
    KCommand * setLineSpacingCommand( KoTextCursor * cursor, double spacing, KoParagLayout::SpacingType _type,KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
    KCommand * setBordersCommand( KoTextCursor * cursor, const KoBorder& leftBorder, const KoBorder& rightBorder, const KoBorder& topBorder, const KoBorder& bottomBorder, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
    KCommand * setJoinBordersCommand( KoTextCursor * cursor, bool join, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
    KCommand * setMarginCommand( KoTextCursor * cursor, TQStyleSheetItem::Margin m, double margin, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard);
    KCommand* setTabListCommand( KoTextCursor * cursor,const KoTabulatorList & tabList , KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
    KCommand* setBackgroundColorCommand( KoTextCursor * cursor,const TQColor & color , KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
 
    KCommand * setParagDirectionCommand( KoTextCursor * cursor, TQChar::Direction d, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
 
    void applyStyle( KoTextCursor * cursor, const KoParagStyle * style,
                     KoTextDocument::SelectionId selectionId = KoTextDocument::Standard,
                     int paragLayoutFlags = KoParagLayout::All, int formatFlags = KoTextFormat::Format,
                     bool createUndoRedo = true, bool interactive = true );
 
    KCommand* applyStyleCommand( KoTextCursor * cursor, const KoParagStyle * style,
                     KoTextDocument::SelectionId selectionId = KoTextDocument::Standard,
                     int paragLayoutFlags = KoParagLayout::All, int formatFlags = KoTextFormat::Format,
                     bool createUndoRedo = true, bool interactive = true );
 
 
    void applyStyleChange( KoStyleChangeDefMap changed );
    void setFormat( KoTextCursor * cursor, KoTextFormat ** currentFormat, KoTextFormat *format, int flags, bool zoomFont = false );
 
 
    virtual KoTextFormat * currentFormat() const;
 
    virtual const KoParagLayout * currentParagLayoutFormat() const;
 
    virtual bool rtl() const;
 
    virtual KCommand *setParagLayoutFormatCommand( KoParagLayout *newLayout, int flags, int marginIndex=-1);
 
    // common for setParagLayoutFormatCommand above and KoTextView::setParagLayoutFormatCommand
    KCommand *setParagLayoutCommand( KoTextCursor * cursor, const KoParagLayout& paragLayout,
                                     KoTextDocument::SelectionId selectionId, int paragLayoutFlags,
                                     int marginIndex, bool createUndoRedo );
    virtual void setFormat( KoTextFormat * newFormat, int flags, bool zoomFont = false );
 
    int docFontSize( KoTextFormat * format ) const;
    int zoomedFontSize( int docFontSize ) const;
 
    void setViewArea( TQWidget* w, int maxY );
    void ensureFormatted( KoTextParag * parag, bool emitAfterFormatting = true );
    void setLastFormattedParag( KoTextParag *parag );
 
    static TQChar customItemChar() { return TQChar( s_customItemChar ); }
 
    // TQt should really have support for public signals
    void emitHideCursor() { emit hideCursor(); }
    void emitShowCursor() { emit showCursor(); }
    void emitEnsureCursorVisible() { emit ensureCursorVisible(); }
    void emitUpdateUI( bool updateFormat, bool force = false ) { emit updateUI( updateFormat, force ); }
 
    void typingStarted();
    void typingDone();
 
    void abortFormatting();
 
    void selectionChangedNotify( bool enableActions = true );
 
    void emitNewCommand(KCommand *cmd);
 
    virtual KCommand *setChangeCaseOfTextCommand(KoChangeCaseDia::TypeOfCase _type);
 
    KCommand *changeCaseOfText(KoTextCursor *cursor, KoChangeCaseDia::TypeOfCase _type);
    TQString textChangedCase(const TQString& _text, KoChangeCaseDia::TypeOfCase _type);
    KCommand *changeCaseOfTextParag(int cursorPosStart, int cursorPosEnd,KoChangeCaseDia::TypeOfCase _type,KoTextCursor *cursor, KoTextParag *parag);
 
    void loadOasisContent( const TQDomElement &bodyElem, KoOasisContext& context, KoStyleCollection * styleColl );
    void saveOasisContent( KoXmlWriter& writer, KoSavingContext& context ) const;
 
    // Similar to KoTextDocument::loadOasisText but there's no newline inserted before the first paragraph
    // or after the last one - so it's possible to paste just a few chars.
    // It also handles m_lastFormatted
    KoTextCursor pasteOasisText( const TQDomElement &bodyElem, KoOasisContext& context,
                                 KoTextCursor& cursor, KoStyleCollection * styleColl );
 
#ifndef NDEBUG
    void printRTDebug(int);
#endif
 
    bool statistics( TQProgressDialog *progress, ulong & charsWithSpace, ulong & charsWithoutSpace, ulong & words, ulong & sentences, ulong & syllables, ulong & lines, bool selected );
    int numberOfparagraphLineSelected( KoTextParag *parag);
 
    KoVariable* variableAtPoint( const TQPoint& iPoint ) const;
 
    KoVariable* variableAtPosition( KoTextParag* parag, int index ) const;
 
    enum ParagModifyType { AddChar = 0, RemoveChar = 1, ChangeFormat = 2 };
 
signals:
    void availableHeightNeeded();
 
    void afterFormatting( int bottom, KoTextParag* m_lastFormatted, bool* abort );
 
    void chapterParagraphFormatted( KoTextParag* parag );
 
    void formattingFirstParag();
 
    void newCommand( KCommand *cmd );
 
    void repaintChanged( KoTextObject * );
 
    void hideCursor();
    void showCursor();
    void setCursor( KoTextCursor * cursor );
    void updateUI( bool updateFormat, bool force = false );
    void showCurrentFormat();
    void ensureCursorVisible();
    void selectionChanged( bool hasSelection );
 
    void showFormatObject(const KoTextFormat &);
 
    // Keeping track of text modifications - not emitted during loading/closing.
    void paragraphCreated( KoTextParag* parag );
    void paragraphModified( KoTextParag* parag, int /*ParagModifyType*/, int pos, int length );
    void paragraphDeleted( KoTextParag* parag );
 
public slots:
    // The default arguments are those used by the formatTimer.
    // The return value is used by ensureFormatted
    bool formatMore( int count = 10, bool emitAfterFormatting = true );
 
    void emitRepaintChanged() { emit repaintChanged( this ); }
 
public: // made public for KWTextFrameSet...
 
    void storeParagUndoRedoInfo( KoTextCursor * cursor, KoTextDocument::SelectionId selectionId = KoTextDocument::Standard );
    void copyCharFormatting( KoTextParag *parag, int position, int index /*in text*/, bool moveCustomItems );
    void readFormats( KoTextCursor &c1, KoTextCursor &c2, bool copyParagLayouts = false, bool moveCustomItems = false );
 
    struct KOTEXT_EXPORT UndoRedoInfo { // borrowed from TQTextEdit
        enum Type { Invalid, Insert, Delete, Return, RemoveSelected };
        UndoRedoInfo( KoTextObject* textobj );
        ~UndoRedoInfo() {}
        void clear();
        bool valid() const;
 
        KoTextString text; // storage for formatted text
        int id; // id of first parag
        int eid; // id of last parag
        int index; // index (for insertion/deletion)
        Type type; // type of command
        KoTextObject* textobj; // parent
        CustomItemsMap customItemsMap; // character position -> qtextcustomitem
        TQValueList<KoParagLayout> oldParagLayouts;
        KoParagLayout newParagLayout;
        KoTextCursor *cursor; // basically a "mark" of the view that started this undo/redo info
        // If the view changes, the next call to checkUndoRedoInfo will terminate the previous view's edition
        KMacroCommand *placeHolderCmd;
    };
    void newPlaceHolderCommand( const TQString & name );
    void checkUndoRedoInfo( KoTextCursor * cursor, UndoRedoInfo::Type t );
 
    UndoRedoInfo & undoRedoInfoStruct() { return undoRedoInfo; }
 
    void setVisible(bool vis) { m_visible=vis; }
    bool isVisible() const { return m_visible; }
 
private slots:
    void doChangeInterval();
    void slotAfterUndoRedo();
    void slotParagraphModified(KoTextParag *, int, int , int);
    void slotParagraphCreated(KoTextParag *);
    void slotParagraphDeleted(KoTextParag *);
private:
    void init();
 
private:
    class KoTextObjectPrivate;
    KoTextObjectPrivate* d;
    KoTextDocument *textdoc;
 
    KoParagStyle* m_defaultStyle;
 
    bool m_visible;
 
    UndoRedoInfo undoRedoInfo;
 
    KoTextParag *m_lastFormatted;
    TQTimer *formatTimer, *changeIntervalTimer;
    int interval;
 
    int m_availableHeight;
    TQMap<TQWidget *, int> m_mapViewAreas;
 
    //TQPtrDict<int> m_origFontSizes; // Format -> doc font size.
 
    bool m_highlightSelectionAdded;
 
#ifdef TIMING_FORMAT
    TQTime m_time;
#endif
 
    static const char s_customItemChar;
    bool m_needsSpellCheck;
    bool m_protectContent;
};
 
#endif