# kate Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kateautoindent.h

    00001 /* This file is part of the KDE libraries
    00002    Copyright (C) 2003 Jesse Yurkovich <yurkjes@iit.edu>
    00003    Copyright (C) 2004 >Anders Lund <anders@alweb.dk> (KateVarIndent class)
    00004
    00005    This library is free software; you can redistribute it and/or
    00006    modify it under the terms of the GNU Library General Public
    00007    License version 2 as published by the Free Software Foundation.
    00008
    00009    This library is distributed in the hope that it will be useful,
    00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00012    Library General Public License for more details.
    00013
    00014    You should have received a copy of the GNU Library General Public License
    00015    along with this library; see the file COPYING.LIB.  If not, write to
    00016    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00017    Boston, MA 02111-1307, USA.
    00018 */
    00019
    00020 #ifndef __KATE_AUTO_INDENT_H__
    00021 #define __KATE_AUTO_INDENT_H__
    00022
    00023 #include <qobject.h>
    00024
    00025 #include "katecursor.h"
    00026 #include "kateconfig.h"
    00027
    00028 class KateDocument;
    00029
    00035 class KateAutoIndent
    00036 {
    00040   public:
    00047     static KateAutoIndent *createIndenter (KateDocument *doc, uint mode);
    00048
    00053     static QStringList listModes ();
    00054
    00060     static QString modeName (uint mode);
    00061
    00067     static QString modeDescription (uint mode);
    00068
    00074     static uint modeNumber (const QString &name);
    00075
    00076   public:
    00081     KateAutoIndent (KateDocument *doc);
    00082
    00086     virtual ~KateAutoIndent ();
    00087
    00091     virtual void updateConfig () {};
    00092
    00097     virtual bool canProcessNewLine () const { return false; }
    00098
    00105     virtual void processNewline (KateDocCursor &/*cur*/, bool /*needContinue*/) {}
    00106
    00111     virtual void processChar (QChar /*c*/) { }
    00112
    00116     virtual void processLine (KateDocCursor &/*line*/) { }
    00117
    00121     virtual void processSection (KateDocCursor &/*begin*/, KateDocCursor &/*end*/) { }
    00122
    00127     virtual bool canProcessLine() const { return false; }
    00128
    00133     virtual uint modeNumber () const { return KateDocumentConfig::imNone; };
    00134
    00135   protected:
    00136     KateDocument *doc;
    00137 };
    00138
    00139 class KateViewIndentationAction : public KActionMenu
    00140 {
    00141   Q_OBJECT
    00142
    00143   public:
    00144     KateViewIndentationAction(KateDocument *_doc, const QString& text, QObject* parent = 0, const char* name = 0);
    00145
    00146     ~KateViewIndentationAction(){;};
    00147
    00148   private:
    00149     KateDocument* doc;
    00150
    00151   public  slots:
    00152     void slotAboutToShow();
    00153
    00154   private slots:
    00155     void setMode (int mode);
    00156 };
    00157
    00161 class KateNormalIndent : public KateAutoIndent
    00162 {
    00163 public:
    00168   KateNormalIndent (KateDocument *doc);
    00169
    00173   virtual ~KateNormalIndent ();
    00174
    00178   virtual void updateConfig ();
    00179
    00184   virtual bool canProcessNewLine () const { return true; }
    00185
    00192   virtual void processNewline (KateDocCursor &cur, bool needContinue);
    00193
    00198   virtual void processChar (QChar /*c*/) { }
    00199
    00203   virtual void processLine (KateDocCursor &/*line*/) { }
    00204
    00208   virtual void processSection (KateDocCursor &/*begin*/, KateDocCursor &/*end*/) { }
    00209
    00214   virtual bool canProcessLine() const { return false; }
    00215
    00220   virtual uint modeNumber () const { return KateDocumentConfig::imNormal; };
    00221
    00222 protected:
    00223
    00235   bool isBalanced (KateDocCursor &begin, const KateDocCursor &end, QChar open, QChar close, uint &pos) const;
    00236
    00246   bool skipBlanks (KateDocCursor &cur, KateDocCursor &max, bool newline) const;
    00247
    00253   uint measureIndent (KateDocCursor &cur) const;
    00254
    00261   QString tabString(uint length) const;
    00262
    00263   uint  tabWidth;
    00264   uint  indentWidth;
    00265
    00266     // Attributes that we should skip over or otherwise know about
    00267   uchar commentAttrib;
    00268   uchar doxyCommentAttrib;
    00269   uchar regionAttrib;
    00270   uchar symbolAttrib;
    00271   uchar alertAttrib;
    00272   uchar tagAttrib;
    00273   uchar wordAttrib;
    00274   uchar keywordAttrib;
    00275   uchar normalAttrib;
    00276   uchar extensionAttrib;
    00277
    00278   bool  useSpaces;
    00279   bool  mixedIndent;
    00280   bool  keepProfile;
    00281 };
    00282
    00283 class KateCSmartIndent : public KateNormalIndent
    00284 {
    00285   public:
    00286     KateCSmartIndent (KateDocument *doc);
    00287     ~KateCSmartIndent ();
    00288
    00289     virtual void processNewline (KateDocCursor &begin, bool needContinue);
    00290     virtual void processChar (QChar c);
    00291
    00292     virtual void processLine (KateDocCursor &line);
    00293     virtual void processSection (KateDocCursor &begin, KateDocCursor &end);
    00294
    00295     virtual bool canProcessLine() const { return true; }
    00296
    00297     virtual uint modeNumber () const { return KateDocumentConfig::imCStyle; };
    00298
    00299   private:
    00300     uint calcIndent (KateDocCursor &begin, bool needContinue);
    00301     uint calcContinue (KateDocCursor &begin, KateDocCursor &end);
    00302     uint findOpeningBrace (KateDocCursor &start);
    00303     uint findOpeningParen (KateDocCursor &start);
    00304     uint findOpeningComment (KateDocCursor &start);
    00305     bool firstOpeningBrace (KateDocCursor &start);
    00306     bool handleDoxygen (KateDocCursor &begin);
    00307
    00308     bool allowSemi;
    00309     bool processingBlock;
    00310 };
    00311
    00312 class KatePythonIndent : public KateNormalIndent
    00313 {
    00314   public:
    00315     KatePythonIndent (KateDocument *doc);
    00316     ~KatePythonIndent ();
    00317
    00318     virtual void processNewline (KateDocCursor &begin, bool needContinue);
    00319
    00320     virtual uint modeNumber () const { return KateDocumentConfig::imPythonStyle; };
    00321
    00322   private:
    00323     int calcExtra (int &prevBlock, int &pos, KateDocCursor &end);
    00324
    00325     static QRegExp endWithColon;
    00326     static QRegExp stopStmt;
    00327     static QRegExp blockBegin;
    00328 };
    00329
    00330 class KateXmlIndent : public KateNormalIndent
    00331 {
    00332   public:
    00333     KateXmlIndent (KateDocument *doc);
    00334     ~KateXmlIndent ();
    00335
    00336     virtual uint modeNumber () const { return KateDocumentConfig::imXmlStyle; }
    00337     virtual void processNewline (KateDocCursor &begin, bool needContinue);
    00338     virtual void processChar (QChar c);
    00339     virtual void processLine (KateDocCursor &line);
    00340     virtual bool canProcessLine() const { return true; }
    00341     virtual void processSection (KateDocCursor &begin, KateDocCursor &end);
    00342
    00343   private:
    00344     // sets the indentation of a single line based on previous line
    00345     //  (returns indentation width)
    00346     uint processLine (uint line);
    00347
    00348     // gets information about a line
    00349     void getLineInfo (uint line, uint &prevIndent, int &numTags,
    00350       uint &attrCol, bool &unclosedTag);
    00351
    00352     // useful regular expressions
    00353     static const QRegExp startsWithCloseTag;
    00354     static const QRegExp unclosedDoctype;
    00355 };
    00356
    00357 class KateCSAndSIndent : public KateNormalIndent
    00358 {
    00359   public:
    00360     KateCSAndSIndent (KateDocument *doc);
    00361     ~KateCSAndSIndent ();
    00362
    00363     virtual void processNewline (KateDocCursor &begin, bool needContinue);
    00364     virtual void processChar (QChar c);
    00365
    00366     virtual void processLine (KateDocCursor &line);
    00367     virtual void processSection (KateDocCursor &begin, KateDocCursor &end);
    00368
    00369     virtual bool canProcessLine() const { return true; }
    00370
    00371     virtual uint modeNumber () const { return KateDocumentConfig::imCSAndS; };
    00372
    00373   private:
    00374     void updateIndentString();
    00375
    00376     bool inForStatement( int line );
    00377     int lastNonCommentChar( const KateDocCursor &line );
    00378     bool startsWithLabel( int line );
    00379     bool inStatement( const KateDocCursor &begin );
    00380     QString continuationIndent( const KateDocCursor &begin );
    00381
    00382     QString calcIndent (const KateDocCursor &begin);
    00383     QString calcIndentAfterKeyword(const KateDocCursor &indentCursor, const KateDocCursor &keywordCursor, int keywordPos, bool blockKeyword);
    00384     QString calcIndentInBracket(const KateDocCursor &indentCursor, const KateDocCursor &bracketCursor, int bracketPos);
    00385     QString calcIndentInBrace(const KateDocCursor &indentCursor, const KateDocCursor &braceCursor, int bracePos);
    00386
    00387     bool handleDoxygen (KateDocCursor &begin);
    00388     QString findOpeningCommentIndentation (const KateDocCursor &start);
    00389
    00390     QString indentString;
    00391 };
    00392
    00418 class KateVarIndent :  public QObject, public KateNormalIndent
    00419 {
    00420   Q_OBJECT
    00421   public:
    00425     enum pairs {
    00426       Parens=1,
    00427       Braces=2,
    00428       Brackets=4,
    00429       AngleBrackets=8
    00430     };
    00431
    00432     KateVarIndent( KateDocument *doc );
    00433     virtual ~KateVarIndent();
    00434
    00435     virtual void processNewline (KateDocCursor &begin, bool needContinue);
    00436     virtual void processChar (QChar c);
    00437
    00438     virtual void processLine (KateDocCursor &line);
    00439     virtual void processSection (KateDocCursor &begin, KateDocCursor &end);
    00440
    00441     virtual bool canProcessLine() const { return true; }
    00442
    00443     virtual uint modeNumber () const { return KateDocumentConfig::imVarIndent; };
    00444
    00445   private slots:
    00446     void slotVariableChanged(const QString&, const QString&);
    00447
    00448   private:
    00457     int coupleBalance( int line, const QChar &open, const QChar &close ) const;
    00458
    00463     bool hasRelevantOpening( const KateDocCursor &end ) const;
    00464
    00465     class KateVarIndentPrivate *d;
    00466 };
    00467
    00468 #endif
    00469
    00470 // kate: space-indent on; indent-width 2; replace-tabs on;

This file is part of the documentation for kate Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:36:29 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003