kateautoindent.h

/* This file is part of the KDE libraries
   Copyright (C) 2003 Jesse Yurkovich <yurkjes@iit.edu>
   Copyright (C) 2004 >Anders Lund <anders@alweb.dk> (KateVarIndent class)
   Copyright (C) 2005 Dominik Haumann <dhdev@gmx.de> (basic support for config page)
 
   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_AUTO_INDENT_H__
#define __KATE_AUTO_INDENT_H__
 
#include <tqobject.h>
 
#include "katecursor.h"
#include "kateconfig.h"
#include "katejscript.h"
class KateDocument;
 
class IndenterConfigPage : public TQWidget
{
  TQ_OBJECT
 
  public:
    IndenterConfigPage ( TQWidget *parent=0, const char *name=0 ) : TQWidget(parent, name) {}
    virtual ~IndenterConfigPage () {}
 
  public slots:
    virtual void apply () = 0;
};
 
class KateAutoIndent : public TQObject
{
  TQ_OBJECT
 
  public:
    static KateAutoIndent *createIndenter (KateDocument *doc, uint mode);
 
    static TQStringList listModes ();
 
    static TQString modeName (uint mode);
 
    static TQString modeDescription (uint mode);
 
    static uint modeNumber (const TQString &name);
 
    static bool hasConfigPage (uint mode);
 
    static IndenterConfigPage* configPage(TQWidget *parent, uint mode);
 
  public:
    KateAutoIndent (KateDocument *doc);
 
    virtual ~KateAutoIndent ();
 
  public slots:
    virtual void updateConfig () {};
 
  public:
    virtual bool canProcessNewLine () const { return false; }
 
    virtual void processNewline (KateDocCursor &cur, bool needContinue) { Q_UNUSED(cur); Q_UNUSED(needContinue); }
 
    virtual void processChar (TQChar c) { Q_UNUSED(c); }
 
    virtual void processLine (KateDocCursor &/*line*/) { }
 
    virtual void processSection (const KateDocCursor &/*begin*/, const KateDocCursor &/*end*/) { }
 
    virtual bool canProcessLine() const { return false; }
 
    virtual uint modeNumber () const { return KateDocumentConfig::imNone; };
 
  protected:
    KateDocument *doc;
};
 
class KateViewIndentationAction : public TDEActionMenu
{
  TQ_OBJECT
 
  public:
    KateViewIndentationAction(KateDocument *_doc, const TQString& text, TQObject* parent = 0, const char* name = 0);
 
    ~KateViewIndentationAction(){;};
 
  private:
    KateDocument* doc;
 
  public  slots:
    void slotAboutToShow();
 
  private slots:
    void setMode (int mode);
};
 
class KateNormalIndent : public KateAutoIndent
{
  TQ_OBJECT
 
public:
  KateNormalIndent (KateDocument *doc);
 
  virtual ~KateNormalIndent ();
 
public slots:
  virtual void updateConfig ();
 
public:
  virtual bool canProcessNewLine () const { return true; }
 
  virtual void processNewline (KateDocCursor &cur, bool needContinue);
 
  virtual void processChar (TQChar c) { Q_UNUSED(c); }
 
  virtual void processLine (KateDocCursor &/*line*/) { }
 
  virtual void processSection (const KateDocCursor &/*begin*/, const KateDocCursor &/*end*/) { }
 
  virtual bool canProcessLine() const { return false; }
 
  virtual uint modeNumber () const { return KateDocumentConfig::imNormal; };
 
protected:
 
  bool isBalanced (KateDocCursor &begin, const KateDocCursor &end, TQChar open, TQChar close, uint &pos) const;
 
  bool skipBlanks (KateDocCursor &cur, KateDocCursor &max, bool newline) const;
 
  uint measureIndent (KateDocCursor &cur) const;
 
  TQString tabString(uint length) const;
 
  uint  tabWidth;     
  uint  indentWidth;  
 
public:
    // Attributes that we should skip over or otherwise know about
  uchar commentAttrib;
  uchar doxyCommentAttrib;
  uchar regionAttrib;
  uchar symbolAttrib;
  uchar alertAttrib;
  uchar tagAttrib;
  uchar wordAttrib;
  uchar keywordAttrib;
  uchar normalAttrib;
  uchar extensionAttrib;
  uchar preprocessorAttrib;
  uchar stringAttrib;
  uchar charAttrib;
 
protected:
  bool  useSpaces;    
  bool  mixedIndent;  
  bool  keepProfile;  
};
 
class KateCSmartIndent : public KateNormalIndent
{
  TQ_OBJECT
 
  public:
    KateCSmartIndent (KateDocument *doc);
    ~KateCSmartIndent ();
 
    virtual void processNewline (KateDocCursor &cur, bool needContinue);
    virtual void processChar (TQChar c);
 
    virtual void processLine (KateDocCursor &line);
    virtual void processSection (const KateDocCursor &begin, const KateDocCursor &end);
 
    virtual bool canProcessLine() const { return true; }
 
    virtual uint modeNumber () const { return KateDocumentConfig::imCStyle; };
 
  private:
    uint calcIndent (KateDocCursor &begin, bool needContinue);
    uint calcContinue (KateDocCursor &begin, KateDocCursor &end);
    uint findOpeningBrace (KateDocCursor &start);
    uint findOpeningParen (KateDocCursor &start);
    uint findOpeningComment (KateDocCursor &start);
    bool firstOpeningBrace (KateDocCursor &start);
    bool handleDoxygen (KateDocCursor &begin);
 
    bool allowSemi;
    bool processingBlock;
};
 
class KatePythonIndent : public KateNormalIndent
{
  TQ_OBJECT
 
  public:
    KatePythonIndent (KateDocument *doc);
    ~KatePythonIndent ();
 
    virtual void processNewline (KateDocCursor &cur, bool needContinue);
 
    virtual uint modeNumber () const { return KateDocumentConfig::imPythonStyle; };
 
  private:
    int calcExtra (int &prevBlock, int &pos, KateDocCursor &end);
    void traverseString( const TQChar &stringChar, KateDocCursor &cur, KateDocCursor &end );
 
    static TQRegExp endWithColon;
    static TQRegExp stopStmt;
    static TQRegExp blockBegin;
};
 
class KateXmlIndent : public KateNormalIndent
{
  TQ_OBJECT
 
  public:
    KateXmlIndent (KateDocument *doc);
    ~KateXmlIndent ();
 
    virtual uint modeNumber () const { return KateDocumentConfig::imXmlStyle; }
    virtual void processNewline (KateDocCursor &cur, bool needContinue);
    virtual void processChar (TQChar c);
    virtual void processLine (KateDocCursor &line);
    virtual bool canProcessLine() const { return true; }
    virtual void processSection (const KateDocCursor &begin, const KateDocCursor &end);
 
  private:
    // sets the indentation of a single line based on previous line
    //  (returns indentation width)
    uint processLine (uint line);
 
    // gets information about a line
    void getLineInfo (uint line, uint &prevIndent, int &numTags,
      uint &attrCol, bool &unclosedTag);
 
    // useful regular expressions
    static const TQRegExp startsWithCloseTag;
    static const TQRegExp unclosedDoctype;
};
 
class KateCSAndSIndent : public KateNormalIndent
{
  TQ_OBJECT
 
  public:
    KateCSAndSIndent (KateDocument *doc);
    ~KateCSAndSIndent ();
 
    virtual void processNewline (KateDocCursor &begin, bool needContinue);
    virtual void processChar (TQChar c);
 
    virtual void processLine (KateDocCursor &line);
    virtual void processSection (const KateDocCursor &begin, const KateDocCursor &end);
 
    virtual bool canProcessLine() const { return true; }
 
    virtual uint modeNumber () const { return KateDocumentConfig::imCSAndS; };
 
  private:
    void updateIndentString();
 
    bool inForStatement( int line );
    int lastNonCommentChar( const KateDocCursor &line );
    bool startsWithLabel( int line );
    bool inStatement( const KateDocCursor &begin );
    TQString continuationIndent( const KateDocCursor &begin );
 
    TQString calcIndent (const KateDocCursor &begin);
    TQString calcIndentAfterKeyword(const KateDocCursor &indentCursor, const KateDocCursor &keywordCursor, int keywordPos, bool blockKeyword);
    TQString calcIndentInBracket(const KateDocCursor &indentCursor, const KateDocCursor &bracketCursor, int bracketPos);
    TQString calcIndentInBrace(const KateDocCursor &indentCursor, const KateDocCursor &braceCursor, int bracePos);
 
    bool handleDoxygen (KateDocCursor &begin);
    TQString findOpeningCommentIndentation (const KateDocCursor &start);
 
    TQString indentString;
};
 
class KateVarIndent : public KateNormalIndent
{
  TQ_OBJECT
 
  public:
    enum pairs {
      Parens=1,
      Braces=2,
      Brackets=4,
      AngleBrackets=8
    };
 
    KateVarIndent( KateDocument *doc );
    virtual ~KateVarIndent();
 
    virtual void processNewline (KateDocCursor &cur, bool needContinue);
    virtual void processChar (TQChar c);
 
    virtual void processLine (KateDocCursor &line);
    virtual void processSection (const KateDocCursor &begin, const KateDocCursor &end);
 
    virtual bool canProcessLine() const { return true; }
 
    virtual uint modeNumber () const { return KateDocumentConfig::imVarIndent; };
 
  private slots:
    void slotVariableChanged(const TQString&, const TQString&);
 
  private:
    int coupleBalance( int line, const TQChar &open, const TQChar &close ) const;
 
    bool hasRelevantOpening( const KateDocCursor &end ) const;
 
    class KateVarIndentPrivate *d;
};
 
class KateScriptIndent : public KateNormalIndent
{
  TQ_OBJECT
 
  public:
    KateScriptIndent( KateDocument *doc );
    ~KateScriptIndent();
 
    virtual void processNewline( KateDocCursor &cur, bool needContinue );
    virtual void processChar( TQChar c );
 
    virtual void processLine (KateDocCursor &line);
//     virtual void processSection (const KateDocCursor &begin, const KateDocCursor &end);
 
    virtual bool canProcessLine() const { return true; }
 
    virtual uint modeNumber () const { return KateDocumentConfig::imScriptIndent; };
  private:
    KateIndentScript m_script;
};
 
class ScriptIndentConfigPage : public IndenterConfigPage
{
    TQ_OBJECT
 
  public:
    ScriptIndentConfigPage ( TQWidget *parent=0, const char *name=0 );
    virtual ~ScriptIndentConfigPage ();
 
  public slots:
    virtual void apply ();
};
 
#endif