diff options
Diffstat (limited to 'quanta/src/document.h')
| -rw-r--r-- | quanta/src/document.h | 352 |
1 files changed, 352 insertions, 0 deletions
diff --git a/quanta/src/document.h b/quanta/src/document.h new file mode 100644 index 00000000..7b6ef151 --- /dev/null +++ b/quanta/src/document.h @@ -0,0 +1,352 @@ +/*************************************************************************** + document.h - description + ------------------- + begin : Tue Jun 6 2000 + copyright : (C) 2000 by Dmitry Poplavsky & Alexander Yakovlev & Eric Laffoon <pdima@users.sourceforge.net,yshurik@penguinpowered.com,sequitur@easystreet.com> + (C) 2001-2004 Andras Mantia <amantia@kde.org> + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#ifndef DOCUMENT_H +#define DOCUMENT_H + +//qt includes +#include <qdatetime.h> +#include <qdict.h> +#include <qmap.h> +#include <qwidget.h> + +#include <kurl.h> +#include <ktexteditor/markinterfaceextension.h> + +//own includes +#include "qtag.h" + +/** + *@author Dmitry Poplavsky & Alexander Yakovlev & Eric Laffoon & Andras Mantia + */ + +class QDomDocument; +class QEvent; +class QFocusEvent; +class QTextCodec; +class QStringList; +class KConfig; +class KTempFile; +class KURL; +class Tag; +class Node; +class Project; +class undoRedo; +struct AreaStruct; +struct DTDStruct; + +namespace KTextEditor +{ + class CodeCompletionInterface; + class CompletionEntry; + class ConfigInterface; + class Document; + class EditInterface; + class EditInterfaceExt; + class EncodingInterface; + class MarkInterface; + class SelectionInterface; + class SelectionInterfaceExt; + class View; + class ViewCursorInterface; + class Mark; +} + +class Document : public QWidget{ + Q_OBJECT + +public: + Document(KTextEditor::Document *doc, + QWidget *parent = 0, const char *name = 0, WFlags f=0); + ~Document(); + + KURL url(); + + bool isUntitled(); + void setUntitledUrl(const QString &url); + /** Returns tag name at specified position */ + QString getTagNameAt(int line, int col ); + + void selectText(int x1, int y1, int x2, int y2 ); + void replaceSelected(const QString &s); + + /** insert tag in document */ + void insertTag(const QString &s1, const QString &s2 = QString::null); + /** Change the current tag's attributes with those from dict */ + void changeTag(Tag *tag, QDict<QString> *dict ); + /**Change the attr value of the called attrName to attrValue*/ + void changeTagAttribute(Tag *tag, const QString& attrName, const QString&attrValue); + /**Change the namespace in a tag. Add if it's not present, or remove if the + namespace argument is empty*/ + void changeTagNamespace(Tag *tag, const QString& nameSpace); + /** Insert the content of the url into the document. */ + void insertFile(const KURL& url); + /** Inserts text at the current cursor position */ + void insertText(const QString &text, bool adjustCursor = true, bool reparse = true); + /** Recursively insert the mandatory childs of tag. Returns true if a child was + inserted.*/ + bool insertChildTags(QTag *tag, QTag* lastTag = 0L); + + QPoint getGlobalCursorPos(); + QString find(const QRegExp& rx, int sLine, int sCol, int& fbLine, int&fbCol, int &feLine, int&feCol); + QString findRev(const QRegExp& rx, int sLine, int sCol, int& fbLine, int&fbCol, int &feLine, int&feCol); + /** Get the view of the document */ + KTextEditor::View* view(); + /** Get the KTextEditor::Document of the document */ + KTextEditor::Document* doc(); + /** Sets the modifiedFlag value. */ + void setModified(bool flag); + /** Returns true if the document was modified. */ + bool isModified(); + + /** Creates a temporary file where the editor content is saved. + */ + void createTempFile(); + /** Closes and removes the temporary file. */ + void closeTempFile(); + /** Returns the name of the temporary file, QString::null if no temporary file exists. */ + QString tempFileName(); + + /** Returns the DTD identifier for the document */ + QString getDTDIdentifier(); + /** Sets the DTD identifier */ + void setDTDIdentifier(const QString &id); + /** Get a pointer to the current active DTD. If fallback is true, this always gives back a valid and known DTD pointer: the active, the document specified and in last case the application default document type. */ + const DTDStruct* currentDTD(bool fallback = true); + /** Get a pointer to the default DTD (document, or app). */ + const DTDStruct* defaultDTD() const; + /** Find the DTD name for a part of the document. */ + QString findDTDName(Tag **tag); + /** Retrives the text from the specified rectangle. The KTextEditor::EditInterface::text seems to not +work correctly. */ + QString text(int bLine, int bCol, int eLine, int eCol) const; + /** Same as the above, but using AreaStruct as an argument */ + QString text(const AreaStruct &area) const; + /** Code completion was requested by the user. */ + void codeCompletionRequested(); + /** Bring up the code completion tooltip. */ + void codeCompletionHintRequested(); + /** Returns the dirty status. */ + bool dirty() const {return m_dirty;}; + void setDirtyStatus(bool status) {m_dirty = status;}; + /** Ask for user confirmation if the file was changed outside. */ + void checkDirtyStatus(); + /** Save the document and reset the dirty status. */ + void save(); + /** Save the document under a new name and calculate the new md5sum. */ + bool saveAs(const KURL& url); + /** Enable or disable the visibility of groups for a DTEP.*/ + void enableGroupsForDTEP(const QString& dtepName, bool enable = true); + /** Clears the selected DTEP list */ + void resetGroupsForDTEPList(); + /** Find the word until the first word boundary backwards */ + QString findWordRev(const QString& textToSearch, const DTDStruct *dtd = 0L); + /** Returns the changed status since the last query. Resets changed.*/ + bool hasChanged(); + /** Sets the changed status.*/ + void setChanged(bool newStatus); + /** Paste the contents of clipboard into the document */ + void paste(); + + /** disable/enable the parser*/ + void activateParser(bool activation) {reparseEnabled = activation;} + bool parserActivated() {return reparseEnabled;} + + /** returns all the areas that are between tag and it's closing pair */ + QStringList tagAreas(const QString &tag, bool includeCoordinates, bool skipFoundContent); + + /** disable/enable the repaint of the Kate view */ + void activateRepaintView(bool activation); + bool RepaintViewActivated() {return repaintEnabled;} + + void setErrorMark(int line); + void clearErrorMarks(); + void convertCase(); + + /** returns the word under the cursor */ + QString currentWord(); + /** Opens the url. The url must be valid and the file pointed to it must exists. */ + void open(const KURL &url, const QString &encoding); + /** + * Opens a file in the editor part. + * @param url + */ + bool openURL(const KURL& url); + /** Reads the DTD info from the file, tries to find the correct DTD and builds the tag/attribute list from the DTD file. */ + void processDTD(const QString& documentType = QString::null); + + /** Resets the list of DTEPs found in the document */ + void resetDTEPs(); + /** Adds a DTEP to the list of DTEPs present in the document */ + void addDTEP(const QString &dtepName); + /** Returns the list of DTEPs that should appear in the structure tree. By default + this is the list of DTEPs present in the document, but the user can turn on/ + off them with the help of RMB->Show Groups For in the structure tree */ + QStringList groupsForDTEPs(); + + bool busy; + + KTextEditor::ViewCursorInterface *viewCursorIf; + KTextEditor::SelectionInterface *selectionIf; + KTextEditor::SelectionInterfaceExt *selectionIfExt; + KTextEditor::EditInterface *editIf; + KTextEditor::EncodingInterface *encodingIf; + KTextEditor::EditInterfaceExt *editIfExt; + KTextEditor::CodeCompletionInterface *codeCompletionIf; + KTextEditor::ConfigInterface* configIf; + KTextEditor::MarkInterface* markIf; + + /** Hold the list of user tags (real or not, like functions) that are in the document*/ + QTagList userTagList; + /** The undo/redo stack */ + undoRedo *docUndoRedo; + + bool isBackedUp(); + /** Creates an automatic backup copy for the crash recovering mechanism */ + void createBackup(KConfig* config); + /** No descriptions */ + QString backupPathEntryValue(); + /** No descriptions */ + void setBackupPathEntryValue(const QString& ev); + /** Removes automatic backup copies */ + void removeBackup(KConfig *config); + /** create a string using document path string */ + static QString hashFilePath(const QString& p); + QString annotationText(uint line); + void setAnnotationText(uint line, const QString& text); + QMap<uint, QPair<QString, QString> > annotations() {return m_annotations;} + void addAnnotation(uint line, const QPair<QString, QString>& annotation); + void clearAnnotations(); + +public slots: + + /** Called after a completion is inserted */ + void slotCompletionDone( KTextEditor::CompletionEntry completion ); + /** Called when a user selects a completion, we then can modify it */ + void slotFilterCompletion(KTextEditor::CompletionEntry*,QString *); + /** Called whenever a user inputs text */ + void slotCharactersInserted(int ,int ,const QString&); + /** Called when the code completion is aborted.*/ + void slotCompletionAborted(); + /** Called whenever the text in the document is changed. */ + void slotTextChanged(); + /** Handle the text changed events. Usually called from slotTextChanged, + but it's possible to force the handling by calling manually and setting + forced to true. */ + void slotDelayedTextChanged(bool forced = false); + void slotDelayedScriptAutoCompletion(); + void slotDelayedShowCodeCompletion(); + +signals: + /** Emitted when the internal text editor got the focus */ + void editorGotFocus(); + void openingFailed(const KURL &url); + void openingCompleted(const KURL &url); + + void breakpointMarked(Document*, int); + void breakpointUnmarked(Document*, int); + void showAnnotation(uint, const QString&, const QPair<QString, QString>&); + +private slots: + void slotReplaceChar(); + void slotOpeningCompleted(); + void slotOpeningFailed(const QString &errorMessage); + /** Called when a file on the disk has changed. */ + void slotFileDirty(const QString& fileName); + + void slotMarkChanged(KTextEditor::Mark mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction action); +private: + /** + * Finds the beginning of a tag in the document, starting from a position. + * @param position start to look from this position backwards + * @return the position of the starting character or an empty QPoint if not found + */ + QPoint findTagBeginning(const QPoint& position); + QPoint findTagEnd(const QPoint& position); + + + + QMap<uint, QPair<QString, QString> > m_annotations; + QString untitledUrl; + int m_replaceLine; + int m_replaceCol; + QString m_replaceStr; + + KTextEditor::Document *m_doc; + KTextEditor::View *m_view; + + KTempFile *tempFile; + QString m_tempFileName; + QDateTime m_modifTime; + /* path of the backup copy file of the document */ + QString m_backupPathValue; + QString dtdName; + QString m_encoding; + QTextCodec *m_codec; +/*The DTD valid in the place where the completion was invoked.*/ + const DTDStruct *completionDTD; + + bool changed; + bool completionInProgress; + bool completionRequested; ///< true if the code completion was explicitely requested by the user + bool argHintVisible; + bool hintRequested; + bool reparseEnabled; + bool repaintEnabled; + bool delayedTextChangedEnabled; + /** True if the document is dirty (has been modified outside). */ + bool m_dirty; + QString m_md5sum; + Project *m_project; + /** Parse the document according to this DTD. */ + QStringList m_groupsForDTEPs; ///< The list of the DTEPs for which the groups should appear in the structure tree + QStringList m_DTEPList; ///< The list of all DTEPs found in the document + //stores the data after an autocompletion. Used when bringing up the + //autocompletion box delayed with the singleshot timer (workaround for + //a bug: the box is not showing up if it is called from slotCompletionDone) + int m_lastLine, m_lastCol; + QValueList<KTextEditor::CompletionEntry>* m_lastCompletionList; + + /** Get list of possibile variable name completions */ + QValueList<KTextEditor::CompletionEntry>* getGroupCompletions(Node *node, const StructTreeGroup& groupName, int line, int col); + /** Get list of possibile tag name completions */ + QValueList<KTextEditor::CompletionEntry>* getTagCompletions(int line, int col); + /** Get list of possibile tag attribute completions */ + QValueList<KTextEditor::CompletionEntry>* getAttributeCompletions(const QString& tagName,const QString& startsWith=QString::null); + /** Get list of possibile tag attribute value completions */ + QValueList<KTextEditor::CompletionEntry>* getAttributeValueCompletions(const QString& tagName, const QString& attribute, const QString& startsWith=QString::null); + /** Get list of possibile completions in normal text input (nt creating a tag) */ + QValueList<KTextEditor::CompletionEntry>* getCharacterCompletions(const QString& starstWith=QString::null); + /** Invoke code completion dialog for XML like tags according to the position (line, col), using DTD dtd. */ + bool xmlCodeCompletion(int line, int col); + /** Returns list of values for attribute. If deleteResult is true after the call, + the caller must delete the returned list. */ + QStringList* tagAttributeValues(const QString& dtdName, const QString& tag, const QString& attribute, bool &deleteResult); + /** Brings up list of code completions */ + void showCodeCompletions( QValueList<KTextEditor::CompletionEntry> *completions ); + /** Called whenever a user inputs text in an XML type document. */ + bool xmlAutoCompletion(int , int , const QString & ); + /** Called whenever a user inputs text in a script type document. */ + bool scriptAutoCompletion(int line, int col, const QString &insertedString); + /** Returns true if the number of " (excluding \") inside text is even. */ + bool evenQuotes(const QString &text); + void handleCodeCompletion(); + bool isDerivatedFrom(const QString& className, const QString &baseClass); +}; + +#endif + |