From ce4a32fe52ef09d8f5ff1dd22c001110902b60a2 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kate/part/katehighlight.h | 438 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 438 insertions(+) create mode 100644 kate/part/katehighlight.h (limited to 'kate/part/katehighlight.h') diff --git a/kate/part/katehighlight.h b/kate/part/katehighlight.h new file mode 100644 index 000000000..70b7016a3 --- /dev/null +++ b/kate/part/katehighlight.h @@ -0,0 +1,438 @@ +/* This file is part of the KDE libraries + Copyright (C) 2001,2002 Joseph Wenninger + Copyright (C) 2001 Christoph Cullmann + Copyright (C) 1999 Jochen Wilhelmy + + 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_HIGHLIGHT_H__ +#define __KATE_HIGHLIGHT_H__ + +#include "katetextline.h" +#include "kateattribute.h" + +#include "../interfaces/document.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class KateHlContext; +class KateHlItem; +class KateHlItemData; +class KateHlData; +class KateEmbeddedHlInfo; +class KateHlIncludeRule; +class KateSyntaxDocument; +class KateTextLine; +class KateSyntaxModeListItem; +class KateSyntaxContextData; + +// some typedefs +typedef QPtrList KateAttributeList; +typedef QValueList KateHlIncludeRules; +typedef QPtrList KateHlItemDataList; +typedef QPtrList KateHlDataList; +typedef QMap KateEmbeddedHlInfos; +typedef QMap KateHlUnresolvedCtxRefs; +typedef QValueList IntList; + +//Item Properties: name, Item Style, Item Font +class KateHlItemData : public KateAttribute +{ + public: + KateHlItemData(const QString name, int defStyleNum); + + enum ItemStyles { + dsNormal, + dsKeyword, + dsDataType, + dsDecVal, + dsBaseN, + dsFloat, + dsChar, + dsString, + dsComment, + dsOthers, + dsAlert, + dsFunction, + dsRegionMarker, + dsError }; + + public: + const QString name; + int defStyleNum; +}; + +class KateHlData +{ + public: + KateHlData(const QString &wildcards, const QString &mimetypes,const QString &identifier, int priority); + + public: + QString wildcards; + QString mimetypes; + QString identifier; + int priority; +}; + +class KateHighlighting +{ + public: + KateHighlighting(const KateSyntaxModeListItem *def); + ~KateHighlighting(); + + public: + void doHighlight ( KateTextLine *prevLine, + KateTextLine *textLine, + QMemArray *foldingList, + bool *ctxChanged ); + + void loadWildcards(); + QValueList& getRegexpExtensions(); + QStringList& getPlainExtensions(); + + QString getMimetypes(); + + // this pointer needs to be deleted !!!!!!!!!! + KateHlData *getData(); + void setData(KateHlData *); + + void setKateHlItemDataList(uint schema, KateHlItemDataList &); + + // both methodes return hard copies of the internal lists + // the lists are cleared first + autodelete is set ! + // keep track that you delete them, or mem will be lost + void getKateHlItemDataListCopy (uint schema, KateHlItemDataList &); + + const QString &name() const {return iName;} + const QString &nameTranslated() const {return iNameTranslated;} + const QString §ion() const {return iSection;} + bool hidden() const {return iHidden;} + const QString &version() const {return iVersion;} + const QString &author () const { return iAuthor; } + const QString &license () const { return iLicense; } + int priority(); + const QString &getIdentifier() const {return identifier;} + void use(); + void release(); + + /** + * @return true if the character @p c is not a deliminator character + * for the corresponding highlight. + */ + bool isInWord( QChar c, int attrib=0 ) const; + + /** + * @return true if the character @p c is a wordwrap deliminator as specified + * in the general keyword section of the xml file. + */ + bool canBreakAt( QChar c, int attrib=0 ) const; + + /** + * @return true if @p beginAttr and @p endAttr are members of the same + * highlight, and there are comment markers of either type in that. + */ + bool canComment( int startAttr, int endAttr ) const; + + /** + * @return 0 if highlighting which attr is a member of does not + * define a comment region, otherwise the region is returned + */ + signed char commentRegion(int attr) const; + + /** + * @return the mulitiline comment start marker for the highlight + * corresponding to @p attrib. + */ + QString getCommentStart( int attrib=0 ) const; + + /** + * @return the muiltiline comment end marker for the highlight corresponding + * to @p attrib. + */ + QString getCommentEnd( int attrib=0 ) const; + + /** + * @return the single comment marker for the highlight corresponding + * to @p attrib. + */ + QString getCommentSingleLineStart( int attrib=0 ) const; + + + /** + * This enum is used for storing the information where a single line comment marker should be inserted + */ + enum CSLPos { CSLPosColumn0=0,CSLPosAfterWhitespace=1}; + + /** + * @return the single comment marker position for the highlight corresponding + * to @p attrib. + */ + CSLPos getCommentSingleLinePosition( int attrib=0 ) const; + + /** + * @return the attribute for @p context. + */ + int attribute( int context ) const; + + /** + * map attribute to its highlighting file. + * the returned string is used as key for m_additionalData. + */ + QString hlKeyForAttrib( int attrib ) const; + + + void clearAttributeArrays (); + + QMemArray *attributes (uint schema); + + inline bool noHighlighting () const { return noHl; }; + + // be carefull: all documents hl should be invalidated after calling this method! + void dropDynamicContexts(); + + QString indentation () { return m_indentation; } + + private: + // make this private, nobody should play with the internal data pointers + void getKateHlItemDataList(uint schema, KateHlItemDataList &); + + void init(); + void done(); + void makeContextList (); + int makeDynamicContext(KateHlContext *model, const QStringList *args); + void handleKateHlIncludeRules (); + void handleKateHlIncludeRulesRecursive(KateHlIncludeRules::iterator it, KateHlIncludeRules *list); + int addToContextList(const QString &ident, int ctx0); + void addToKateHlItemDataList(); + void createKateHlItemData (KateHlItemDataList &list); + void readGlobalKeywordConfig(); + void readWordWrapConfig(); + void readCommentConfig(); + void readIndentationConfig (); + void readFoldingConfig (); + + // manipulates the ctxs array directly ;) + void generateContextStack(int *ctxNum, int ctx, QMemArray *ctxs, int *posPrevLine); + + KateHlItem *createKateHlItem(KateSyntaxContextData *data, KateHlItemDataList &iDl, QStringList *RegionList, QStringList *ContextList); + int lookupAttrName(const QString& name, KateHlItemDataList &iDl); + + void createContextNameList(QStringList *ContextNameList, int ctx0); + int getIdFromString(QStringList *ContextNameList, QString tmpLineEndContext,/*NO CONST*/ QString &unres); + + KateHlItemDataList internalIDList; + + QValueVector m_contexts; + inline KateHlContext *contextNum (uint n) { if (n < m_contexts.size()) return m_contexts[n]; return 0; } + + QMap< QPair, short> dynamicCtxs; + + // make them pointers perhaps + KateEmbeddedHlInfos embeddedHls; + KateHlUnresolvedCtxRefs unresolvedContextReferences; + QStringList RegionList; + QStringList ContextNameList; + + bool noHl; + bool folding; + bool casesensitive; + QString weakDeliminator; + QString deliminator; + + QString iName; + QString iNameTranslated; + QString iSection; + bool iHidden; + QString iWildcards; + QString iMimetypes; + QString identifier; + QString iVersion; + QString iAuthor; + QString iLicense; + QString m_indentation; + int m_priority; + int refCount; + int startctx, base_startctx; + + QString errorsAndWarnings; + QString buildIdentifier; + QString buildPrefix; + bool building; + uint itemData0; + uint buildContext0Offset; + KateHlIncludeRules includeRules; + bool m_foldingIndentationSensitive; + + QIntDict< QMemArray > m_attributeArrays; + + + /** + * This class holds the additional properties for one highlight + * definition, such as comment strings, deliminators etc. + * + * When a highlight is added, a instance of this class is appended to + * m_additionalData, and the current position in the attrib and context + * arrays are stored in the indexes for look up. You can then use + * hlKeyForAttrib or hlKeyForContext to find the relevant instance of this + * class from m_additionalData. + * + * If you need to add a property to a highlight, add it here. + */ + class HighlightPropertyBag { + public: + QString singleLineCommentMarker; + QString multiLineCommentStart; + QString multiLineCommentEnd; + QString multiLineRegion; + CSLPos singleLineCommentPosition; + QString deliminator; + QString wordWrapDeliminator; + }; + + /** + * Highlight properties for each included highlight definition. + * The key is the identifier + */ + QDict m_additionalData; + + /** + * Fast lookup of hl properties, based on attribute index + * The key is the starting index in the attribute array for each file. + * @see hlKeyForAttrib + */ + QMap m_hlIndex; + + + QString extensionSource; + QValueList regexpExtensions; + QStringList plainExtensions; + + public: + inline bool foldingIndentationSensitive () { return m_foldingIndentationSensitive; } + inline bool allowsFolding(){return folding;} +}; + +class KateHlManager : public QObject +{ + Q_OBJECT + + private: + KateHlManager(); + + public: + ~KateHlManager(); + + static KateHlManager *self(); + + inline KConfig *getKConfig() { return &m_config; }; + + KateHighlighting *getHl(int n); + int nameFind(const QString &name); + + int detectHighlighting (class KateDocument *doc); + + int findHl(KateHighlighting *h) {return hlList.find(h);} + QString identifierForName(const QString&); + + // methodes to get the default style count + names + static uint defaultStyles(); + static QString defaultStyleName(int n, bool translateNames = false); + + void getDefaults(uint schema, KateAttributeList &); + void setDefaults(uint schema, KateAttributeList &); + + int highlights(); + QString hlName(int n); + QString hlNameTranslated (int n); + QString hlSection(int n); + bool hlHidden(int n); + + void incDynamicCtxs() { ++dynamicCtxsCount; }; + uint countDynamicCtxs() { return dynamicCtxsCount; }; + void setForceNoDCReset(bool b) { forceNoDCReset = b; }; + + // be carefull: all documents hl should be invalidated after having successfully called this method! + bool resetDynamicCtxs(); + + signals: + void changed(); + + private: + int wildcardFind(const QString &fileName); + int mimeFind(KateDocument *); + int realWildcardFind(const QString &fileName); + + private: + friend class KateHighlighting; + + QPtrList hlList; + QDict hlDict; + + static KateHlManager *s_self; + + KConfig m_config; + QStringList commonSuffixes; + + KateSyntaxDocument *syntax; + + uint dynamicCtxsCount; + QTime lastCtxsReset; + bool forceNoDCReset; +}; + +class KateViewHighlightAction: public Kate::ActionMenu +{ + Q_OBJECT + + public: + KateViewHighlightAction(const QString& text, QObject* parent = 0, const char* name = 0) + : Kate::ActionMenu(text, parent, name) { init(); }; + + ~KateViewHighlightAction(){;}; + + void updateMenu (Kate::Document *doc); + + private: + void init(); + + QGuardedPtr m_doc; + QStringList subMenusName; + QStringList names; + QPtrList subMenus; + + public slots: + void slotAboutToShow(); + + private slots: + void setHl (int mode); +}; + +#endif + +// kate: space-indent on; indent-width 2; replace-tabs on; -- cgit v1.2.1