katedocument.h

/* This file is part of the KDE libraries
   Copyright (C) 2001-2004 Christoph Cullmann <cullmann@kde.org>
   Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
   Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 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
   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 _KATE_DOCUMENT_H_
#define _KATE_DOCUMENT_H_
 
#include "katesupercursor.h"
#include "katetextline.h"
#include "kateundo.h"
#include "katebuffer.h"
#include "katecodefoldinghelpers.h"
 
#include "../interfaces/document.h"
 
#include <tdetexteditor/configinterfaceextension.h>
#include <tdetexteditor/encodinginterface.h>
#include <tdetexteditor/sessionconfiginterface.h>
#include <tdetexteditor/editinterfaceext.h>
#include <tdetexteditor/templateinterface.h>
 
#include <dcopobject.h>
 
#include <kmimetype.h>
#include <tdelocale.h>
 
#include <tqintdict.h>
#include <tqmap.h>
#include <tqdatetime.h>
 
namespace KTextEditor { class Plugin; }
 
namespace TDEIO { class TransferJob; }
 
class KateUndoGroup;
class KateCmd;
class KateAttribute;
class KateAutoIndent;
class KateCodeFoldingTree;
class KateBuffer;
class KateView;
class KateViewInternal;
class KateArbitraryHighlight;
class KateSuperRange;
class KateLineInfo;
class KateBrowserExtension;
class KateDocumentConfig;
class KateHighlighting;
class KatePartPluginItem;
class KatePartPluginInfo;
 
class KTempFile;
 
class TQTimer;
 
class KateKeyInterceptorFunctor;
 
//
// Kate KTextEditor::Document class (and even KTextEditor::Editor ;)
//
class KateDocument : public Kate::Document,
                     public Kate::DocumentExt,
                     public KTextEditor::ConfigInterfaceExtension,
                     public KTextEditor::EncodingInterface,
                     public KTextEditor::SessionConfigInterface,
                     public KTextEditor::EditInterfaceExt,
                     public KTextEditor::TemplateInterface,
                     public DCOPObject
{
  K_DCOP
  TQ_OBJECT
 
  friend class KateViewInternal;
  friend class KateRenderer;
 
  public:
    KateDocument (bool bSingleViewMode=false, bool bBrowserView=false, bool bReadOnly=false,
        TQWidget *parentWidget = 0, const char *widgetName = 0, TQObject * = 0, const char * = 0);
    ~KateDocument ();
 
    bool closeURL();
 
  //
  // Plugins section
  //
  public:
    void unloadAllPlugins ();
 
    void enableAllPluginsGUI (KateView *view);
    void disableAllPluginsGUI (KateView *view);
 
    void loadPlugin (uint pluginIndex);
    void unloadPlugin (uint pluginIndex);
 
    void enablePluginGUI (KTextEditor::Plugin *plugin, KateView *view);
    void enablePluginGUI (KTextEditor::Plugin *plugin);
 
    void disablePluginGUI (KTextEditor::Plugin *plugin, KateView *view);
    void disablePluginGUI (KTextEditor::Plugin *plugin);
 
  private:
     TQMemArray<KTextEditor::Plugin *> m_plugins;
 
  public:
    bool readOnly () const { return m_bReadOnly; }
    bool browserView () const { return m_bBrowserView; }
    bool singleViewMode () const { return m_bSingleViewMode; }
    KateBrowserExtension *browserExtension () { return m_extension; }
 
  private:
    // only to make part work, don't change it !
    bool m_bSingleViewMode;
    bool m_bBrowserView;
    bool m_bReadOnly;
    KateBrowserExtension *m_extension;
 
  //
  // KTextEditor::Document stuff
  //
  public:
    KTextEditor::View *createView( TQWidget *parent, const char *name );
    TQPtrList<KTextEditor::View> views () const;
 
    inline KateView *activeView () const { return m_activeView; }
 
  private:
    TQPtrList<KateView> m_views;
    TQPtrList<KTextEditor::View> m_textEditViews;
    KateView *m_activeView;
 
    void setActiveView( KateView *view );
 
  //
  // KTextEditor::ConfigInterfaceExtension stuff
  //
  public slots:
    uint configPages () const;
    KTextEditor::ConfigPage *configPage (uint number = 0, TQWidget *parent = 0, const char *name=0 );
    TQString configPageName (uint number = 0) const;
    TQString configPageFullName (uint number = 0) const;
    TQPixmap configPagePixmap (uint number = 0, int size = TDEIcon::SizeSmall) const;
 
  //
  // KTextEditor::EditInterface stuff
  //
  public slots:
    TQString text() const;
 
    TQString text ( uint startLine, uint startCol, uint endLine, uint endCol ) const;
    TQString text ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise ) const;
 
    TQString textLine ( uint line ) const;
 
    bool setText(const TQString &);
    bool clear ();
 
    bool insertText ( uint line, uint col, const TQString &s );
    bool insertText ( uint line, uint col, const TQString &s, bool blockwise );
 
    bool removeText ( uint startLine, uint startCol, uint endLine, uint endCol );
    bool removeText ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise );
 
    bool insertLine ( uint line, const TQString &s );
    bool removeLine ( uint line );
 
    uint numLines() const;
    uint numVisLines() const;
    uint length () const;
    int lineLength ( uint line ) const;
 
  signals:
    void textChanged ();
    void charactersInteractivelyInserted(int ,int ,const TQString&);
    void charactersSemiInteractivelyInserted(int ,int ,const TQString&);
    void backspacePressed();
 
  public:
//BEGIN editStart/editEnd (start, end, undo, cursor update, view update)
    void editStart (bool withUndo = true);
    void editBegin () { editStart(); }
    void editEnd ();
  private:
    bool m_isInUndo; 
 
//END editStart/editEnd
 
//BEGIN LINE BASED INSERT/REMOVE STUFF (editStart() and editEnd() included)
  public:
    bool editInsertText ( uint line, uint col, const TQString &s );
    bool editRemoveText ( uint line, uint col, uint len );
 
    bool editMarkLineAutoWrapped ( uint line, bool autowrapped );
 
    bool editWrapLine ( uint line, uint col, bool newLine = true, bool *newLineAdded = 0 );
    bool editUnWrapLine ( uint line, bool removeLine = true, uint length = 0 );
 
    bool editInsertLine ( uint line, const TQString &s );
    bool editRemoveLine ( uint line );
 
    bool wrapText (uint startLine, uint endLine);
//END LINE BASED INSERT/REMOVE STUFF
 
  signals:
    void editTextInserted ( uint line, uint col, uint len);
 
    void editTextRemoved ( uint line, uint col, uint len);
 
    void editLineWrapped ( uint line, uint col, uint len );
 
    void editLineUnWrapped ( uint line, uint col );
 
    void editLineInserted ( uint line );
 
    void editLineRemoved ( uint line );
 
  private:
    void undoStart();
    void undoEnd();
    void undoSafePoint();
 
  private slots:
    void undoCancel();
 
  private:
    void editAddUndo (KateUndoGroup::UndoType type, uint line, uint col, uint len, const TQString &text);
 
    uint editSessionNumber;
    bool editIsRunning;
    bool editWithUndo;
    bool m_undoComplexMerge;
    KateUndoGroup* m_editCurrentUndo;
 
  //
  // KTextEditor::UndoInterface stuff
  //
  public slots:
    void undo ();
    void redo ();
    void clearUndo ();
    void clearRedo ();
 
    uint undoCount () const;
    uint redoCount () const;
 
    uint undoSteps () const;
    void setUndoSteps ( uint steps );
 
  private:
    friend class KateTemplateHandler;
 
  private:
    TQPtrList<KateSuperCursor> m_superCursors;
 
    //
    // some internals for undo/redo
    //
    TQPtrList<KateUndoGroup> undoItems;
    TQPtrList<KateUndoGroup> redoItems;
    bool m_undoDontMerge; //create a setter later on and remove the friend declaration
    bool m_undoIgnoreCancel;
    TQTimer* m_undoMergeTimer;
    // these two variables are for resetting the document to
    // non-modified if all changes have been undone...
    KateUndoGroup* lastUndoGroupWhenSaved;
    KateUndoGroup* lastRedoGroupWhenSaved;
    bool docWasSavedWhenUndoWasEmpty;
    bool docWasSavedWhenRedoWasEmpty;
 
    // this sets
    void updateModified();
 
  signals:
    void undoChanged ();
    void textInserted(int line,int column);
 
  //
  // KTextEditor::CursorInterface stuff
  //
  public slots:
    KTextEditor::Cursor *createCursor ();
    TQPtrList<KTextEditor::Cursor> cursors () const;
 
  private:
    TQPtrList<KTextEditor::Cursor> myCursors;
 
  //
  // KTextEditor::SearchInterface stuff
  //
  public slots:
    bool searchText (unsigned int startLine, unsigned int startCol,
        const TQString &text, unsigned int *foundAtLine, unsigned int *foundAtCol,
        unsigned int *matchLen, bool casesensitive = true, bool backwards = false);
    bool searchText (unsigned int startLine, unsigned int startCol,
        const TQRegExp &regexp, unsigned int *foundAtLine, unsigned int *foundAtCol,
        unsigned int *matchLen, bool backwards = false);
 
  //
  // KTextEditor::HighlightingInterface stuff
  //
  public slots:
    uint hlMode ();
    bool setHlMode (uint mode);
    uint hlModeCount ();
    TQString hlModeName (uint mode);
    TQString hlModeSectionName (uint mode);
 
  public:
    void bufferHlChanged ();
 
  private:
    void setDontChangeHlOnSave();
 
  signals:
    void hlChanged ();
 
  //
  // Kate::ArbitraryHighlightingInterface stuff
  //
  public:
    KateArbitraryHighlight* arbitraryHL() const { return m_arbitraryHL; };
 
  private slots:
    void tagArbitraryLines(KateView* view, KateSuperRange* range);
 
  //
  // KTextEditor::ConfigInterface stuff
  //
  public slots:
    void readConfig ();
    void writeConfig ();
    void readConfig (TDEConfig *);
    void writeConfig (TDEConfig *);
    void readSessionConfig (TDEConfig *);
    void writeSessionConfig (TDEConfig *);
    void configDialog ();
 
  //
  // KTextEditor::MarkInterface and MarkInterfaceExtension
  //
  public slots:
    uint mark( uint line );
 
    void setMark( uint line, uint markType );
    void clearMark( uint line );
 
    void addMark( uint line, uint markType );
    void removeMark( uint line, uint markType );
 
    TQPtrList<KTextEditor::Mark> marks();
    void clearMarks();
 
    void setPixmap( MarkInterface::MarkTypes, const TQPixmap& );
    void setDescription( MarkInterface::MarkTypes, const TQString& );
    TQString markDescription( MarkInterface::MarkTypes );
    TQPixmap *markPixmap( MarkInterface::MarkTypes );
    TQColor markColor( MarkInterface::MarkTypes );
 
    void setMarksUserChangable( uint markMask );
    uint editableMarks();
 
  signals:
    void marksChanged();
    void markChanged( KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction );
 
  private:
    TQIntDict<KTextEditor::Mark> m_marks;
    TQIntDict<TQPixmap>           m_markPixmaps;
    TQIntDict<TQString>           m_markDescriptions;
    uint                        m_editableMarks;
 
  //
  // KTextEditor::PrintInterface
  //
  public slots:
    bool printDialog ();
    bool print ();
 
  //
  // KTextEditor::DocumentInfoInterface ( ### unfinished )
  //
  public:
    TQString mimeType();
 
    long fileSize();
 
    TQString niceFileSize();
 
    KMimeType::Ptr mimeTypeForContent();
 
  //
  // KTextEditor::VariableInterface
  //
  public:
    TQString variable( const TQString &name ) const;
 
  signals:
    void variableChanged( const TQString &, const TQString & );
 
  private:
    TQMap<TQString, TQString> m_storedVariables;
 
  //
  // KParts::ReadWrite stuff
  //
  public:
    bool openURL( const KURL &url );
 
    /* Anders:
      I reimplemented this, since i need to check if backup succeeded
      if requested */
    bool save();
 
    /* Anders: Reimplemented to do kate specific stuff */
    bool saveAs( const KURL &url );
 
    bool openFile (TDEIO::Job * job);
    bool openFile ();
 
    bool saveFile ();
 
    void setReadWrite ( bool readwrite = true );
 
    void setModified( bool m );
 
  private slots:
    void slotDataKate ( TDEIO::Job* tdeio_job, const TQByteArray &data );
    void slotFinishedKate ( TDEIO::Job * job );
 
  private:
    void abortLoadKate();
 
    void activateDirWatch ();
    void deactivateDirWatch ();
 
    TQString m_dirWatchFile;
 
  //
  // Kate::Document stuff, this is all deprecated!!!!!!!!!!
  //
  public:
    Kate::ConfigPage *colorConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *fontConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *indentConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *selectConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *editConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *keysConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *hlConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *viewDefaultsConfigPage (TQWidget *) { return 0; }
    Kate::ConfigPage *saveConfigPage( TQWidget * ) { return 0; }
 
    Kate::ActionMenu *hlActionMenu (const TQString& /* text */, TQObject* /* parent */ = 0, const char* /* name */ = 0) { return 0; }
    Kate::ActionMenu *exportActionMenu (const TQString& /* text */, TQObject* /* parent */ = 0, const char* /* name */ = 0) { return 0; }
 
  public:
    bool typeChars ( KateView *type, const TQString &chars );
 
    inline uint lastLine() const { return numLines()-1; }
 
    uint configFlags ();
    void setConfigFlags (uint flags);
 
    // Repaint all of all of the views
    void repaintViews(bool paintOnlyDirty = true);
 
    inline KateHighlighting *highlight () { return m_buffer->highlight(); }
 
    inline KateHighlighting *highlight () const { return m_buffer->highlight(); }
 
  public slots:    //please keep prototypes and implementations in same order
    void tagLines(int start, int end);
    void tagLines(KateTextCursor start, KateTextCursor end);
 
  //export feature, obsolute
  public slots:
     void exportAs(const TQString&) { };
 
  signals:
    void modifiedChanged ();
    void preHighlightChanged(uint);
 
  private slots:
    void internalHlChanged();
 
  public:
    void addView(KTextEditor::View *);
    void removeView(KTextEditor::View *);
 
    void addSuperCursor(class KateSuperCursor *, bool privateC);
    void removeSuperCursor(class KateSuperCursor *, bool privateC);
 
    bool ownedView(KateView *);
    bool isLastView(int numViews);
 
    uint currentColumn( const KateTextCursor& );
    void newLine(             KateTextCursor&, KateViewInternal * ); // Changes input
    void backspace(     KateView *view, const KateTextCursor& );
    void del(           KateView *view, const KateTextCursor& );
    void transpose(     const KateTextCursor& );
 
    void paste ( KateView* view );
 
  public:
    void insertIndentChars ( KateView *view );
 
    void indent ( KateView *view, uint line, int change );
    void comment ( KateView *view, uint line, uint column, int change );
    void align ( KateView *view, uint line );
 
    enum TextTransform { Uppercase, Lowercase, Capitalize };
 
    void transform ( KateView *view, const KateTextCursor &, TextTransform );
    void joinLines( uint first, uint last );
 
  private:
    void optimizeLeadingSpace( uint line, int flags, int change );
    void replaceWithOptimizedSpace( uint line, uint upto_column, uint space, int flags );
 
    bool removeStringFromBegining(int line, TQString &str);
    bool removeStringFromEnd(int line, TQString &str);
 
    bool nextNonSpaceCharPos(int &line, int &col);
 
    bool previousNonSpaceCharPos(int &line, int &col);
 
    void addStartLineCommentToSingleLine(int line, int attrib=0);
    bool removeStartLineCommentFromSingleLine(int line, int attrib=0);
 
    void addStartStopCommentToSingleLine(int line, int attrib=0);
    bool removeStartStopCommentFromSingleLine(int line, int attrib=0);
    bool removeStartStopCommentFromRegion(const KateTextCursor &start, const KateTextCursor &end, int attrib=0);
 
           void addStartStopCommentToSelection( KateView *view, int attrib=0 );
          void addStartLineCommentToSelection( KateView *view, int attrib=0 );
 
    bool removeStartStopCommentFromSelection( KateView *view, int attrib=0 );
    bool removeStartLineCommentFromSelection( KateView *view, int attrib=0 );
 
  public:
    TQString getWord( const KateTextCursor& cursor );
 
  public:
    void tagAll();
 
    void newBracketMark( const KateTextCursor& start, KateBracketRange& bm, int maxLines = -1 );
    bool findMatchingBracket( KateTextCursor& start, KateTextCursor& end, int maxLines = -1 );
 
  private:
    void guiActivateEvent( KParts::GUIActivateEvent *ev );
 
  public:
 
    TQString docName () {return m_docName;};
 
    void setDocName (TQString docName);
 
    void lineInfo (KateLineInfo *info, unsigned int line);
 
    KateCodeFoldingTree *foldingTree ();
 
  public:
    bool isModifiedOnDisc() { return m_modOnHd; };
 
    void isModOnHD( bool =false ) {};
 
    void setModifiedOnDisk( int reason );
 
  public slots:
    void slotModifiedOnDisk( Kate::View *v=0 );
 
    void reloadFile();
 
  private:
    int m_isasking; // don't reenter slotModifiedOnDisk when this is true
                    // -1: ignore once, 0: false, 1: true
 
  public slots:
    void setEncoding (const TQString &e);
    TQString encoding() const;
 
  public slots:
    void setWordWrap (bool on);
    bool wordWrap ();
 
    void setWordWrapAt (uint col);
    uint wordWrapAt ();
 
  public slots:
    void setPageUpDownMovesCursor(bool on);
    bool pageUpDownMovesCursor();
 
  signals:
    void modStateChanged (Kate::Document *doc);
    void nameChanged (Kate::Document *doc);
 
  public slots:
    // clear buffer/filename - update the views
    void flush ();
 
  signals:
    void fileNameChanged ();
 
  public slots:
     void applyWordWrap ();
 
   // code folding
  public:
    inline uint getRealLine(unsigned int virtualLine)
    {
      return m_buffer->lineNumber (virtualLine);
    }
 
    inline uint getVirtualLine(unsigned int realLine)
    {
      return m_buffer->lineVisibleNumber (realLine);
    }
 
    inline uint visibleLines ()
    {
      return m_buffer->countVisible ();
    }
 
    inline KateTextLine::Ptr kateTextLine(uint i)
    {
      return m_buffer->line (i);
    }
 
    inline KateTextLine::Ptr plainKateTextLine(uint i)
    {
      return m_buffer->plainLine (i);
    }
 
  signals:
    void codeFoldingUpdated();
    void aboutToRemoveText(const KateTextRange&);
    void textRemoved();
 
  private slots:
    void slotModOnHdDirty (const TQString &path);
    void slotModOnHdCreated (const TQString &path);
    void slotModOnHdDeleted (const TQString &path);
 
  private:
    bool createDigest ( TQCString &result );
 
    TQString reasonedMOHString() const;
 
    void removeTrailingSpace( uint line );
 
  public:
    void updateFileType (int newType, bool user = false);
 
    int fileType () const { return m_fileType; };
 
  //
  // REALLY internal data ;)
  //
  private:
    // text buffer
    KateBuffer *m_buffer;
 
    KateArbitraryHighlight* m_arbitraryHL;
 
    KateAutoIndent *m_indenter;
 
    bool hlSetByUser;
 
    bool m_modOnHd;
    unsigned char m_modOnHdReason;
    TQCString m_digest; // MD5 digest, updated on load/save
 
    TQString m_docName;
    int m_docNameNumber;
 
    // file type !!!
    int m_fileType;
    bool m_fileTypeSetByUser;
 
    bool m_reloading;
    bool m_loading; 
    bool m_encodingSticky; 
 
  public slots:
    void slotQueryClose_save(bool *handled, bool* abortClosing);
 
  public:
    void makeAttribs (bool needInvalidate = true);
 
    static bool checkOverwrite( KURL u );
 
    static void setDefaultEncoding (const TQString &encoding);
 
    void setEncodingSticky( bool e ) { m_encodingSticky = e; }
 
  public:
    inline KateDocumentConfig *config () { return m_config; };
 
    void updateConfig ();
 
  private:
    KateDocumentConfig *m_config;
 
  private:
    void readDirConfig ();
 
    void readVariables(bool onlyViewAndRenderer = false);
 
    void readVariableLine( TQString t, bool onlyViewAndRenderer = false );
    void setViewVariable( TQString var, TQString val );
    static bool checkBoolValue( TQString value, bool *result );
    static bool checkIntValue( TQString value, int *result );
    static bool checkColorValue( TQString value, TQColor &col );
 
    static TQRegExp kvLine;
    static TQRegExp kvLineWildcard;
    static TQRegExp kvLineMime;
    static TQRegExp kvVar;
 
    TDEIO::TransferJob *m_job;
    KTempFile *m_tempFile;
 
  // TemplateInterface
  public:
      bool setTabInterceptor(KateKeyInterceptorFunctor *interceptor); /* perhaps make it moregeneral like an eventfilter*/
      bool removeTabInterceptor(KateKeyInterceptorFunctor *interceptor);
      bool invokeTabInterceptor(KKey);
 
  protected:
      virtual bool insertTemplateTextImplementation ( uint line, uint column, const TQString &templateString, const TQMap<TQString,TQString> &initialValues, TQWidget *parentWindow=0 );
      KateKeyInterceptorFunctor *m_tabInterceptor;
 
  protected slots:
      void testTemplateCode();
      void dumpRegionTree();
 
  //BEGIN DEPRECATED
  //
  // KTextEditor::SelectionInterface stuff
  // DEPRECATED, this will be removed for KDE 4.x !!!!!!!!!!!!!!!!!!!!
  //
  public slots:
    bool setSelection ( uint startLine, uint startCol, uint endLine, uint endCol );
    bool clearSelection ();
    bool hasSelection () const;
    TQString selection () const;
    bool removeSelectedText ();
    bool selectAll();
 
    //
    // KTextEditor::SelectionInterfaceExt
    //
    int selStartLine();
    int selStartCol();
    int selEndLine();
    int selEndCol();
 
 
  // hack, only there to still support the deprecated stuff, will be removed for KDE 4.x
  #undef signals
  #define signals public
  signals:
  #undef signals
  #define signals protected
    void selectionChanged ();
 
  //
  // KTextEditor::BlockSelectionInterface stuff
  // DEPRECATED, this will be removed for KDE 4.x !!!!!!!!!!!!!!!!!!!!
  //
  public slots:
    bool blockSelectionMode ();
    bool setBlockSelectionMode (bool on);
    bool toggleBlockSelectionMode ();
 
  private:
//END DEPRECATED
 
  k_dcop:
    uint documentNumber () const;
    long documentListPosition () const;
    void setDocumentListPosition (long pos);
};
 
#endif