kate Library API Documentation

katedocument.h

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
00003    Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
00004    Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License version 2 as published by the Free Software Foundation.
00009 
00010    This library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Library General Public License for more details.
00014 
00015    You should have received a copy of the GNU Library General Public License
00016    along with this library; see the file COPYING.LIB.  If not, write to
00017    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018    Boston, MA 02111-1307, USA.
00019 */
00020 
00021 #ifndef kate_document_h
00022 #define kate_document_h
00023 
00024 #include "katesupercursor.h"
00025 #include "katetextline.h"
00026 
00027 #include "../interfaces/document.h"
00028 
00029 #include <ktexteditor/configinterfaceextension.h>
00030 #include <ktexteditor/encodinginterface.h>
00031 #include <ktexteditor/sessionconfiginterface.h>
00032 #include <ktexteditor/editinterfaceext.h>
00033 
00034 #include <dcopobject.h>
00035 
00036 #include <qintdict.h>
00037 #include <qdatetime.h>
00038 
00039 namespace KTextEditor { class Plugin; }
00040 
00041 namespace KIO { class TransferJob; }
00042 
00043 class KateUndoGroup;
00044 class KateCmd;
00045 class KateAttribute;
00046 class KateAutoIndent;
00047 class KateCodeFoldingTree;
00048 class KateBuffer;
00049 class KateView;
00050 class KateViewInternal;
00051 class LineRange;
00052 class KateArbitraryHighlight;
00053 class KateSuperRange;
00054 class KateLineInfo;
00055 class KateBrowserExtension;
00056 class KateDocumentConfig;
00057 class Highlight;
00058 class KatePartPluginItem;
00059 class KatePartPluginInfo;
00060 
00061 class KSpell;
00062 class KTempFile;
00063 
00064 class QTimer;
00065 
00066 //
00067 // Kate KTextEditor::Document class (and even KTextEditor::Editor ;)
00068 //
00069 class KateDocument : public Kate::Document,
00070                      public KTextEditor::ConfigInterfaceExtension,
00071                      public KTextEditor::EncodingInterface,
00072                      public KTextEditor::SessionConfigInterface,
00073                      public KTextEditor::EditInterfaceExt,
00074                      public DCOPObject
00075 {
00076   K_DCOP
00077   Q_OBJECT
00078 
00079   friend class KateViewInternal;
00080   friend class KateRenderer;
00081 
00082   public:
00083     KateDocument (bool bSingleViewMode=false, bool bBrowserView=false, bool bReadOnly=false,
00084         QWidget *parentWidget = 0, const char *widgetName = 0, QObject * = 0, const char * = 0);
00085     ~KateDocument ();
00086 
00087     bool closeURL();
00088 
00089   //
00090   // Plugins section
00091   //
00092   public:
00093     void unloadAllPlugins ();
00094     
00095     void enableAllPluginsGUI (KateView *view);
00096     void disableAllPluginsGUI (KateView *view);
00097 
00098     void loadPlugin (uint pluginIndex);
00099     void unloadPlugin (uint pluginIndex);
00100     
00101     void enablePluginGUI (KTextEditor::Plugin *plugin, KateView *view);
00102     void enablePluginGUI (KTextEditor::Plugin *plugin);
00103     
00104     void disablePluginGUI (KTextEditor::Plugin *plugin, KateView *view);
00105     void disablePluginGUI (KTextEditor::Plugin *plugin);
00106 
00107   private:
00108      QMemArray<KTextEditor::Plugin *> m_plugins; 
00109    
00110   public:
00111     bool readOnly () const { return m_bReadOnly; }
00112     bool browserView () const { return m_bBrowserView; }
00113     bool singleViewMode () const { return m_bSingleViewMode; }
00114     KateBrowserExtension *browserExtension () { return m_extension; }
00115      
00116   private:
00117     // only to make part work, don't change it !
00118     bool m_bSingleViewMode;
00119     bool m_bBrowserView;
00120     bool m_bReadOnly;
00121     KateBrowserExtension *m_extension;
00122 
00123   //
00124   // KTextEditor::Document stuff
00125   //
00126   public:
00127     KTextEditor::View *createView( QWidget *parent, const char *name );
00128     QPtrList<KTextEditor::View> views () const;
00129 
00130     inline KateView *activeView () const { return m_activeView; }
00131 
00132   private:
00133     QPtrList<KateView> m_views;
00134     QPtrList<KTextEditor::View> m_textEditViews;
00135     KateView *m_activeView;
00136 
00137   //
00138   // KTextEditor::ConfigInterfaceExtension stuff
00139   //
00140   public slots:
00141     uint configPages () const;
00142     KTextEditor::ConfigPage *configPage (uint number = 0, QWidget *parent = 0, const char *name=0 );
00143     QString configPageName (uint number = 0) const;
00144     QString configPageFullName (uint number = 0) const;
00145     QPixmap configPagePixmap (uint number = 0, int size = KIcon::SizeSmall) const;
00146 
00147   //
00148   // KTextEditor::EditInterface stuff
00149   //
00150   public slots:
00151     QString text() const;
00152 
00153     QString text ( uint startLine, uint startCol, uint endLine, uint endCol ) const;
00154     QString text ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise ) const;
00155 
00156     QString textLine ( uint line ) const;
00157 
00158     bool setText(const QString &);
00159     bool clear ();
00160 
00161     bool insertText ( uint line, uint col, const QString &s );
00162     bool insertText ( uint line, uint col, const QString &s, bool blockwise );
00163 
00164     bool removeText ( uint startLine, uint startCol, uint endLine, uint endCol );
00165     bool removeText ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise );
00166 
00167     bool insertLine ( uint line, const QString &s );
00168     bool removeLine ( uint line );
00169 
00170     uint numLines() const;
00171     uint numVisLines() const;
00172     uint length () const;
00173     int lineLength ( uint line ) const;
00174 
00175   signals:
00176     void textChanged ();
00177     void charactersInteractivelyInserted(int ,int ,const QString&);
00178     void backspacePressed();
00179 
00180   public:
00181     //
00182     // start edit / end edit (start/end undo, cursor update, view update)
00183     //
00184     void editBegin () { editStart(); }
00185     void editStart (bool withUndo = true);
00186     void editEnd ();
00187 
00188     //
00189     // functions for insert/remove stuff (atomic)
00190     //
00191     bool editInsertText ( uint line, uint col, const QString &s );
00192     bool editRemoveText ( uint line, uint col, uint len );
00193 
00194     bool editMarkLineAutoWrapped ( uint line, bool autowrapped );
00195 
00196     bool editWrapLine ( uint line, uint col, bool newLine = true, bool *newLineAdded = 0 );
00197     bool editUnWrapLine ( uint line, bool removeLine = true, uint length = 0 );
00198 
00199     bool editInsertLine ( uint line, const QString &s );
00200     bool editRemoveLine ( uint line );
00201 
00202     bool wrapText (uint startLine, uint endLine);
00203 
00204   signals:
00209     void editTextInserted ( uint line, uint col, uint len);
00210 
00214     void editTextRemoved ( uint line, uint col, uint len);
00215 
00219     void editLineWrapped ( uint line, uint col, uint len );
00220 
00224     void editLineUnWrapped ( uint line, uint col );
00225 
00229     void editLineInserted ( uint line );
00230 
00234     void editLineRemoved ( uint line );
00235 
00236   private:
00237     void undoStart();
00238     void undoEnd();
00239 
00240   private slots:
00241     void undoCancel();
00242 
00243   private:
00244     void editAddUndo (uint type, uint line, uint col, uint len, const QString &text);
00245     void editTagLine (uint line);
00246     void editRemoveTagLine (uint line);
00247     void editInsertTagLine (uint line);
00248 
00249     uint editSessionNumber;
00250     bool editIsRunning;
00251     bool noViewUpdates;
00252     bool editWithUndo;
00253     uint editTagLineStart;
00254     uint editTagLineEnd;
00255     bool editTagFrom;
00256     KateUndoGroup* m_editCurrentUndo;
00257 
00258   //
00259   // KTextEditor::SelectionInterface stuff
00260   //
00261   public slots:
00262     bool setSelection ( const KateTextCursor & start,
00263       const KateTextCursor & end );
00264     bool setSelection ( uint startLine, uint startCol,
00265       uint endLine, uint endCol );
00266     bool clearSelection ();
00267     bool clearSelection (bool redraw, bool finishedChangingSelection = true);
00268 
00269     bool hasSelection () const;
00270     QString selection () const ;
00271 
00272     bool removeSelectedText ();
00273 
00274     bool selectAll();
00275 
00276     //
00277     // KTextEditor::SelectionInterfaceExt
00278     //
00279     int selStartLine() { return selectStart.line(); };
00280     int selStartCol()  { return selectStart.col(); };
00281     int selEndLine()   { return selectEnd.line(); };
00282     int selEndCol()    { return selectEnd.col(); };
00283 
00284   private:
00285     // some internal functions to get selection state of a line/col
00286     bool lineColSelected (int line, int col);
00287     bool lineSelected (int line);
00288     bool lineEndSelected (int line, int endCol);
00289     bool lineHasSelected (int line);
00290     bool lineIsSelection (int line);
00291 
00292     QPtrList<KateSuperCursor> m_superCursors;
00293 
00294     // stores the current selection
00295     KateSuperCursor selectStart;
00296     KateSuperCursor selectEnd;
00297 
00298   signals:
00299     void selectionChanged ();
00300 
00301   //
00302   // KTextEditor::BlockSelectionInterface stuff
00303   //
00304   public slots:
00305     bool blockSelectionMode ();
00306     bool setBlockSelectionMode (bool on);
00307     bool toggleBlockSelectionMode ();
00308 
00309   private:
00310     // do we select normal or blockwise ?
00311     bool blockSelect;
00312 
00313   //
00314   // KTextEditor::UndoInterface stuff
00315   //
00316   public slots:
00317     void undo ();
00318     void redo ();
00319     void clearUndo ();
00320     void clearRedo ();
00321 
00322     uint undoCount () const;
00323     uint redoCount () const;
00324 
00325     uint undoSteps () const;
00326     void setUndoSteps ( uint steps );
00327 
00328   private:
00329     //
00330     // some internals for undo/redo
00331     //
00332     QPtrList<KateUndoGroup> undoItems;
00333     QPtrList<KateUndoGroup> redoItems;
00334     bool m_undoDontMerge;
00335     bool m_undoIgnoreCancel;
00336     QTimer* m_undoMergeTimer;
00337     // these two variables are for resetting the document to
00338     // non-modified if all changes have been undone...
00339     KateUndoGroup* lastUndoGroupWhenSaved;
00340     bool docWasSavedWhenUndoWasEmpty;
00341 
00342     // this sets
00343     void updateModified();
00344 
00345   signals:
00346     void undoChanged ();
00347 
00348   //
00349   // KTextEditor::CursorInterface stuff
00350   //
00351   public slots:
00352     KTextEditor::Cursor *createCursor ();
00353     QPtrList<KTextEditor::Cursor> cursors () const;
00354 
00355   private:
00356     QPtrList<KTextEditor::Cursor> myCursors;
00357 
00358   //
00359   // KTextEditor::SearchInterface stuff
00360   //
00361   public slots:
00362     bool searchText (unsigned int startLine, unsigned int startCol,
00363         const QString &text, unsigned int *foundAtLine, unsigned int *foundAtCol,
00364         unsigned int *matchLen, bool casesensitive = true, bool backwards = false);
00365     bool searchText (unsigned int startLine, unsigned int startCol,
00366         const QRegExp &regexp, unsigned int *foundAtLine, unsigned int *foundAtCol,
00367         unsigned int *matchLen, bool backwards = false);
00368 
00369   //
00370   // KTextEditor::HighlightingInterface stuff
00371   //
00372   public slots:
00373     uint hlMode ();
00374     bool setHlMode (uint mode);
00375     uint hlModeCount ();
00376     QString hlModeName (uint mode);
00377     QString hlModeSectionName (uint mode);
00378 
00379   private:
00380     bool internalSetHlMode (uint mode);
00381     void setDontChangeHlOnSave();
00382 
00383   signals:
00384     void hlChanged ();
00385 
00386   //
00387   // Kate::ArbitraryHighlightingInterface stuff
00388   //
00389   public:
00390     KateArbitraryHighlight* arbitraryHL() const { return m_arbitraryHL; };
00391 
00392   private slots:
00393     void tagArbitraryLines(KateView* view, KateSuperRange* range);
00394 
00395   //
00396   // KTextEditor::ConfigInterface stuff
00397   //
00398   public slots:
00399     void readConfig ();
00400     void writeConfig ();
00401     void readConfig (KConfig *);
00402     void writeConfig (KConfig *);
00403     void readSessionConfig (KConfig *);
00404     void writeSessionConfig (KConfig *);
00405     void configDialog ();
00406 
00407   //
00408   // KTextEditor::MarkInterface and MarkInterfaceExtension
00409   //
00410   public slots:
00411     uint mark( uint line );
00412 
00413     void setMark( uint line, uint markType );
00414     void clearMark( uint line );
00415 
00416     void addMark( uint line, uint markType );
00417     void removeMark( uint line, uint markType );
00418 
00419     QPtrList<KTextEditor::Mark> marks();
00420     void clearMarks();
00421 
00422     void setPixmap( MarkInterface::MarkTypes, const QPixmap& );
00423     void setDescription( MarkInterface::MarkTypes, const QString& );
00424     QString markDescription( MarkInterface::MarkTypes );
00425     QPixmap *markPixmap( MarkInterface::MarkTypes );
00426     QColor markColor( MarkInterface::MarkTypes );
00427 
00428     void setMarksUserChangable( uint markMask );
00429     uint editableMarks();
00430 
00431   signals:
00432     void marksChanged();
00433     void markChanged( KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction );
00434 
00435   private:
00436     QIntDict<KTextEditor::Mark> m_marks;
00437     QIntDict<QPixmap>           m_markPixmaps;
00438     QIntDict<QString>           m_markDescriptions;
00439     uint                        m_editableMarks;
00440 
00441   //
00442   // KTextEditor::PrintInterface
00443   //
00444   public slots:
00445     bool printDialog ();
00446     bool print ();
00447 
00448   //
00449   // KParts::ReadWrite stuff
00450   //
00451   public:
00452     bool openURL( const KURL &url );
00453 
00454     /* Anders:
00455       I reimplemented this, since i need to check if backup succeeded
00456       if requested */
00457     bool save();
00458 
00459     bool openFile (KIO::Job * job);
00460     bool openFile ();
00461 
00462     bool saveFile ();
00463 
00464     void setReadWrite ( bool rw = true );
00465 
00466     void setModified( bool m );
00467 
00468   private slots:
00469     void slotDataKate ( KIO::Job* kio_job, const QByteArray &data );
00470     void slotFinishedKate ( KIO::Job * job );
00471 
00472   private:
00473     void abortLoadKate();
00474     
00475     void activateDirWatch ();
00476     void deactivateDirWatch ();
00477     
00478     QString m_dirWatchFile;
00479 
00480   //
00481   // Kate::Document stuff
00482   //
00483   public:
00484     Kate::ConfigPage *colorConfigPage (QWidget *);
00485     Kate::ConfigPage *fontConfigPage (QWidget *);
00486     Kate::ConfigPage *indentConfigPage (QWidget *);
00487     Kate::ConfigPage *selectConfigPage (QWidget *);
00488     Kate::ConfigPage *editConfigPage (QWidget *);
00489     Kate::ConfigPage *keysConfigPage (QWidget *);
00490     Kate::ConfigPage *hlConfigPage (QWidget *);
00491     Kate::ConfigPage *viewDefaultsConfigPage (QWidget *);
00492     Kate::ConfigPage *saveConfigPage( QWidget * );
00493 
00494     Kate::ActionMenu *hlActionMenu (const QString& text, QObject* parent = 0, const char* name = 0);
00495     Kate::ActionMenu *exportActionMenu (const QString& text, QObject* parent = 0, const char* name = 0);
00496 
00497   public:
00501     bool typeChars ( KateView *type, const QString &chars );
00502 
00506     uint lastLine() const { return numLines()-1;}
00507 
00508     TextLine::Ptr kateTextLine(uint i);
00509     TextLine::Ptr plainKateTextLine(uint i);
00510 
00511     uint configFlags ();
00512     void setConfigFlags (uint flags);
00513 
00517     void tagSelection(const KateTextCursor &oldSelectStart, const KateTextCursor &oldSelectEnd);
00518 
00519     // Repaint all of all of the views
00520     void repaintViews(bool paintOnlyDirty = true);
00521 
00522     Highlight *highlight () { return m_highlight; }
00523 
00524   public slots:    //please keep prototypes and implementations in same order
00525     void tagLines(int start, int end);
00526     void tagLines(KateTextCursor start, KateTextCursor end);
00527 
00528   //export feature
00529   public slots:
00530      void exportAs(const QString&);
00531 
00532   private: //the following things should become plugins
00533     bool exportDocumentToHTML (QTextStream *outputStream,const QString &name);
00534     QString HTMLEncode (QChar theChar);
00535 
00536   signals:
00537     void modifiedChanged ();
00538     void preHighlightChanged(uint);
00539 
00540   private slots:
00541     void internalHlChanged();
00542 
00543   public:
00544     void addView(KTextEditor::View *);
00545     void removeView(KTextEditor::View *);
00546 
00547     void addSuperCursor(class KateSuperCursor *, bool privateC);
00548     void removeSuperCursor(class KateSuperCursor *, bool privateC);
00549 
00550     bool ownedView(KateView *);
00551     bool isLastView(int numViews);
00552 
00553     uint currentColumn( const KateTextCursor& );
00554     void newLine(             KateTextCursor&, KateViewInternal * ); // Changes input
00555     void backspace(     const KateTextCursor& );
00556     void del(           const KateTextCursor& );
00557     void transpose(     const KateTextCursor& );
00558     void cut();
00559     void copy();
00560     void paste ( KateView* view );
00561 
00562     void selectWord(   const KateTextCursor& cursor );
00563     void selectLine(   const KateTextCursor& cursor );
00564     void selectLength( const KateTextCursor& cursor, int length );
00565 
00566   public:
00567     void insertIndentChars ( KateView *view );
00568 
00569     void indent ( KateView *view, uint line, int change );
00570     void comment ( KateView *view, uint line, int change );
00571 
00572     enum TextTransform { Uppercase, Lowercase, Capitalize };
00573 
00581     void transform ( KateView *view, const KateTextCursor &, TextTransform );
00585     void joinLines( uint first, uint last );
00586 
00587   private:
00588     void optimizeLeadingSpace( uint line, int flags, int change );
00589     void replaceWithOptimizedSpace( uint line, uint upto_column, uint space, int flags );
00590 
00591     bool removeStringFromBegining(int line, QString &str);
00592     bool removeStringFromEnd(int line, QString &str);
00593 
00603     bool nextNonSpaceCharPos(int &line, int &col);
00604     
00612     bool previousNonSpaceCharPos(int &line, int &col);
00613 
00614     void addStartLineCommentToSingleLine(int line);
00615     bool removeStartLineCommentFromSingleLine(int line);
00616 
00617     void addStartStopCommentToSingleLine(int line);
00618     bool removeStartStopCommentFromSingleLine(int line);
00619 
00620     void addStartStopCommentToSelection();
00621     void addStartLineCommentToSelection();
00622 
00623     bool removeStartStopCommentFromSelection();
00624     bool removeStartLineCommentFromSelection();
00625 
00626   public:
00627     QString getWord( const KateTextCursor& cursor );
00628 
00629   public:
00630     void tagAll();
00631     void updateViews();
00632 
00633     void newBracketMark( const KateTextCursor& start, KateTextRange& bm );
00634     bool findMatchingBracket( KateTextCursor& start, KateTextCursor& end );
00635 
00636   private:
00637     void guiActivateEvent( KParts::GUIActivateEvent *ev );
00638 
00639   private slots:
00640     void slotBufferChanged();
00641 
00642   public:
00648     void isModOnHD(bool forceReload=false);
00649 
00650     QString docName () {return m_docName;};
00651 
00652     void setDocName (QString docName);
00653 
00654     void lineInfo (KateLineInfo *info, unsigned int line);
00655 
00656     KateCodeFoldingTree *foldingTree ();
00657 
00658   public slots:
00662     void reloadFile();
00663 
00664   public slots:
00665     void setEncoding (const QString &e);
00666     QString encoding() const;
00667 
00668   public slots:
00669     void setWordWrap (bool on);
00670     bool wordWrap ();
00671 
00672     void setWordWrapAt (uint col);
00673     uint wordWrapAt ();
00674 
00675   public slots:
00676     void setPageUpDownMovesCursor(bool on);
00677     bool pageUpDownMovesCursor();
00678 
00679   signals:
00680     void modStateChanged (Kate::Document *doc);
00681     void nameChanged (Kate::Document *doc);
00682 
00683   public slots:
00684     // clear buffer/filename - update the views
00685     void flush ();
00686 
00687   signals:
00692     void fileNameChanged ();
00693 
00694   public slots:
00695      void applyWordWrap ();
00696 
00697   public:
00698 
00699  // code folding
00700   public:
00701     unsigned int getRealLine(unsigned int virtualLine);
00702     unsigned int getVirtualLine(unsigned int realLine);
00703     unsigned int visibleLines ();
00704 
00705   signals:
00706     void codeFoldingUpdated();
00707 
00708   public slots:
00709     void dumpRegionTree();
00710 
00711   private slots:
00712     void slotModOnHdDirty (const QString &path);
00713     void slotModOnHdCreated (const QString &path);
00714     void slotModOnHdDeleted (const QString &path);
00715 
00716   public:
00717     // should cursor be wrapped ? take config + blockselection state in account
00718     bool wrapCursor ();
00719 
00720   public:
00721     void updateFileType (int newType, bool user = false);
00722 
00723     int fileType () const { return m_fileType; };
00724 
00725   //
00726   // REALLY internal data ;)
00727   //
00728   private:
00729     // text buffer
00730     KateBuffer *buffer;
00731 
00732     Highlight *m_highlight;
00733 
00734     KateArbitraryHighlight* m_arbitraryHL;
00735 
00736     KateAutoIndent *m_indenter;
00737 
00738     bool hlSetByUser;
00739 
00740     bool m_modOnHd;
00741     unsigned char m_modOnHdReason;
00742 
00743     QString m_docName;
00744     int m_docNameNumber;
00745 
00746     // file type !!!
00747     int m_fileType;
00748     bool m_fileTypeSetByUser;
00749 
00750   public slots:
00751     void spellcheck();
00752     void ready(KSpell *);
00753     void misspelling( const QString&, const QStringList&, unsigned int );
00754     void corrected  ( const QString&, const QString&, unsigned int);
00755     void spellResult( const QString& );
00756     void spellCleanDone();
00757   
00758   
00759     void slotQueryClose_save(bool *handled, bool* abortClosing);
00760 
00761   private:
00762     void makeAttribs ();
00763 
00764     void locatePosition( uint pos, uint& line, uint& col );
00765     KSpell*         m_kspell;
00766     int             m_mispellCount;
00767     int             m_replaceCount;
00768     bool            m_reloading;
00769 
00770   public:
00771     static bool checkOverwrite( KURL u );
00772 
00773     static void setDefaultEncoding (const QString &encoding);
00774 
00778   public:
00779     inline KateDocumentConfig *config () { return m_config; };
00780 
00781     void updateConfig ();
00782 
00783   private:
00784     KateDocumentConfig *m_config;
00785 
00790   private:
00795     void readVariables(bool onlyViewAndRenderer = false);
00796 
00801     void readVariableLine( QString t, bool onlyViewAndRenderer = false );
00805     void setViewVariable( QString var, QString val );
00811     static bool checkBoolValue( QString value, bool *result );
00817     static bool checkIntValue( QString value, int *result );
00818     /*
00819       Feeds value into @p col using QColor::setNamedColor() and returns
00820       wheather the color is valid
00821     */
00822     static bool checkColorValue( QString value, QColor &col );
00823 
00824     static QRegExp kvLine;
00825     static QRegExp kvVar;
00826 
00827     KIO::TransferJob *m_job;
00828     KTempFile *m_tempFile;
00829     
00830   //
00831   // IM input stuff
00832   //
00833   public:
00834     void setIMSelectionValue( uint imStartLine, uint imStart, uint imEnd,
00835                               uint imSelStart, uint imSelEnd, bool m_imComposeEvent );
00836     void getIMSelectionValue( uint *imStartLine, uint *imStart, uint *imEnd,
00837                               uint *imSelStart, uint *imSelEnd );
00838 
00839   private:
00840     uint m_imStartLine;
00841     uint m_imStart;
00842     uint m_imEnd;
00843     uint m_imSelStart;
00844     uint m_imSelEnd;
00845     bool m_imComposeEvent;
00846 
00847   k_dcop:
00848     uint documentNumber () const;
00849 };
00850 
00851 #endif
00852 
00853 // kate: space-indent on; indent-width 2; replace-tabs on;
00854 
KDE Logo
This file is part of the documentation for kate Library Version 3.2.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Mar 4 22:45:59 2004 by doxygen 1.3.6-20040222 written by Dimitri van Heesch, © 1997-2003