document.h

/* This file is part of the KDE libraries
   Copyright (C) 2001 Christoph Cullmann <cullmann@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 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_INCLUDE_
#define _KATE_DOCUMENT_INCLUDE_
 
#include <tdetexteditor/document.h>
#include <tdetexteditor/view.h>
#include <tdetexteditor/editinterface.h>
#include <tdetexteditor/undointerface.h>
#include <tdetexteditor/cursorinterface.h>
#include <tdetexteditor/documentinfo.h>
#include <tdetexteditor/selectioninterface.h>
#include <tdetexteditor/selectioninterfaceext.h>
#include <tdetexteditor/blockselectioninterface.h>
#include <tdetexteditor/searchinterface.h>
#include <tdetexteditor/highlightinginterface.h>
#include <tdetexteditor/configinterface.h>
#include <tdetexteditor/configinterfaceextension.h>
#include <tdetexteditor/markinterface.h>
#include <tdetexteditor/markinterfaceextension.h>
#include <tdetexteditor/wordwrapinterface.h>
#include <tdetexteditor/printinterface.h>
#include <tdetexteditor/variableinterface.h>
 
#include <tdeaction.h>
 
class TDECompletion;
 
namespace Kate
{
 
class View;
 
class KATEPARTINTERFACES_EXPORT Cursor : public KTextEditor::Cursor
{
  public:
    Cursor () { ; };
    virtual ~Cursor () { ; };
};
 
class KATEPARTINTERFACES_EXPORT ConfigPage : public KTextEditor::ConfigPage
{
  TQ_OBJECT
 
  public:
    ConfigPage ( TQWidget *parent=0, const char *name=0 ) : KTextEditor::ConfigPage (parent, name) { ; };
    virtual ~ConfigPage () { ; };
 
  public slots:
    virtual void apply () { ; };
    virtual void reload () { ; };
    virtual void reset () {};
    virtual void defaults () {};
 
  protected slots:
    void slotChanged();
};
 
class KATEPARTINTERFACES_EXPORT ActionMenu : public TDEActionMenu
{
  TQ_OBJECT
 
  public:
    ActionMenu ( const TQString& text, TQObject* parent = 0, const char* name = 0 )
      : TDEActionMenu(text, parent, name) { ; };
    virtual ~ActionMenu () { ; };
 
  public:
    virtual void updateMenu (class Document *) = 0;
};
 
class KATEPARTINTERFACES_EXPORT Command
{
  public:
    Command () {};
    virtual ~Command () {};
 
  public:
    virtual TQStringList cmds () = 0;
 
    virtual bool exec (View *view, const TQString &cmd, TQString &msg) = 0;
 
    virtual bool help (View *view, const TQString &cmd, TQString &msg) = 0;
};
 
class CommandExtension
{
  public:
    CommandExtension() {;}
    virtual ~CommandExtension() {;}
 //### this is yet to be tried
    virtual void flagCompletions( TQStringList& /*list*/ ) {;}
 
    virtual TDECompletion *completionObject( const TQString & cmdname, Kate::View * /*view*/ ) { Q_UNUSED(cmdname); return 0L; }
 
    virtual bool wantsToProcessText( const TQString &cmdname ) { Q_UNUSED(cmdname); return false; }
 // ### yet to be tested. The obvious candidate is isearch.
    virtual void processText( Kate::View *view, const TQString &text ) { Q_UNUSED(view); Q_UNUSED(text); }
};
 
class KATEPARTINTERFACES_EXPORT Document : public KTextEditor::Document, public KTextEditor::EditInterface,
                     public KTextEditor::UndoInterface, public KTextEditor::CursorInterface,
                     public KTextEditor::SelectionInterface, public KTextEditor::SearchInterface,
                     public KTextEditor::HighlightingInterface, public KTextEditor::BlockSelectionInterface,
                     public KTextEditor::ConfigInterface, public KTextEditor::MarkInterface,
                     public KTextEditor::PrintInterface, public KTextEditor::WordWrapInterface,
                     public KTextEditor::MarkInterfaceExtension,
                     public KTextEditor::SelectionInterfaceExt
{
  TQ_OBJECT
 
  public:
    Document ();
    Document ( TQObject* parent, const char* name );
    virtual ~Document ();
 
  public:
    static bool registerCommand (Command *cmd);
    static bool unregisterCommand (Command *cmd);
    static Command *queryCommand (const TQString &cmd);
 
  public:
    virtual void isModOnHD(bool =false) { ; };
 
    virtual TQString docName () { return 0L; };
 
    virtual void setDocName (TQString ) { ; };
 
    virtual ActionMenu *hlActionMenu (const TQString& , TQObject* =0, const char* = 0) = 0;
    virtual ActionMenu *exportActionMenu (const TQString& , TQObject* =0, const char* = 0) = 0;
 
  public slots:
    // clear buffer/filename - update the views
    virtual void flush () { ; };
 
    virtual void reloadFile() = 0;
 
    virtual void spellcheck() {};
 
    virtual void exportAs(const TQString &) = 0;
 
    virtual void applyWordWrap () = 0;
 
 
  public:
    virtual void setWordWrap (bool ) = 0;
    virtual bool wordWrap () = 0;
 
    virtual void setWordWrapAt (unsigned int) = 0;
    virtual uint wordWrapAt () = 0;
 
 
    virtual void setEncoding (const TQString &e) = 0;
    virtual TQString encoding() const = 0;
 
  // FIXME: Remove when BIC allowed.
  public:
    virtual ConfigPage *colorConfigPage (TQWidget *) = 0;
    virtual ConfigPage *fontConfigPage (TQWidget *) = 0;
    virtual ConfigPage *indentConfigPage (TQWidget *) = 0;
    virtual ConfigPage *selectConfigPage (TQWidget *) = 0;
    virtual ConfigPage *editConfigPage (TQWidget *) = 0;
    virtual ConfigPage *keysConfigPage (TQWidget *) = 0;
    virtual ConfigPage *kSpellConfigPage (TQWidget *) { return 0L; }
    virtual ConfigPage *hlConfigPage (TQWidget *) = 0;
 
  public:
    virtual uint configFlags () = 0;
    virtual void setConfigFlags (uint flags) = 0;
 
    // Flags for katedocument config !
    enum ConfigFlags
    {
      cfAutoIndent= 0x1,
      cfBackspaceIndents= 0x2,
      cfWordWrap= 0x4,
      cfReplaceTabs= 0x8,
      cfRemoveSpaces = 0x10,
      cfWrapCursor= 0x20,
      cfAutoBrackets= 0x40,
      cfPersistent= 0x80,
      cfKeepSelection= 0x100,
      cfDelOnInput= 0x400,
      cfXorSelect= 0x800,
      cfOvr= 0x1000,
      cfMark= 0x2000,
      cfKeepIndentProfile= 0x8000,
      cfKeepExtraSpaces= 0x10000,
      cfTabIndents= 0x80000,
      cfShowTabs= 0x200000,
      cfSpaceIndent= 0x400000,
      cfSmartHome = 0x800000
    };
 
  signals:
    void modifiedOnDisc (Kate::Document *doc, bool isModified, unsigned char reason);
 
  /*
   * there static methodes are usefull to turn on/off the dialogs
   * kate part shows up on open file errors + file changed warnings
   * open file errors default on, file changed warnings default off, better
   * for other apps beside kate app using the part
   */
  public:
    // default true
    static void setOpenErrorDialogsActivated (bool on);
 
    // default false
    static void setFileChangedDialogsActivated (bool on);
 
    static const TQString &defaultEncoding ();
 
  protected:
    static bool s_openErrorDialogsActivated;
    static bool s_fileChangedDialogsActivated;
 
    static TQString s_defaultEncoding;
};
 
class KATEPARTINTERFACES_EXPORT DocumentExt
 : public KTextEditor::DocumentInfoInterface,
   public KTextEditor::VariableInterface
{
  public:
    DocumentExt ();
    virtual ~DocumentExt ();
 
  public:
    enum ModifiedOnDiskReason {
      Unmodified = 0, 
      Modified = 1,   
      Created = 2,    
      Deleted = 3     
    };
 
  public:
    virtual void setModifiedOnDisk( int reason ) = 0;
 
  public:
    virtual void slotModifiedOnDisk( View *v=0 ) = 0;
};
 
KATEPARTINTERFACES_EXPORT Document *document (KTextEditor::Document *doc);
 
KATEPARTINTERFACES_EXPORT DocumentExt *documentExt (KTextEditor::Document *doc);
 
KATEPARTINTERFACES_EXPORT Document *createDocument ( TQObject *parent = 0, const char *name = 0 );
 
}
 
#endif