kateviinputmodemanager.h

Go to the documentation of this file.

/*  This file is part of the KDE libraries and the Kate part.
 *
 *  Copyright (C) 2008 Erlend Hamberg <ehamberg@gmail.com>
 *  Copyright (C) 2011 Svyatoslav Kuzmich <svatoslav1@gmail.com>
 *  Copyright (C) 2012 - 2013 Simon St James <kdedevel@etotheipiplusone.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  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_VI_INPUT_MODE_MANAGER_INCLUDED
#define KATE_VI_INPUT_MODE_MANAGER_INCLUDED

#include <QKeyEvent>
#include <QList>
#include "katepartprivate_export.h"
#include <ktexteditor/cursor.h>
#include "katedocument.h"

class KConfigGroup;
class KateView;
class KateDocument;
class KateViewInternal;
class KateViModeBase;
class KateViNormalMode;
class KateViInsertMode;
class KateViVisualMode;
class KateViReplaceMode;
class KateViKeyParser;
class KateViKeyMapper;
class QString;

enum ViMode {
  NormalMode,
  InsertMode,
  VisualMode,
  VisualLineMode,
  VisualBlockMode,
  ReplaceMode
};

struct KateViJump {
    int line;
    int column;
};

namespace KTextEditor {
  class MovingCursor;
  class Mark;
  class MarkInterface;
}

class KATEPART_TESTS_EXPORT KateViInputModeManager : public QObject
{
    Q_OBJECT

public:
  KateViInputModeManager(KateView* view, KateViewInternal* viewInternal);
  ~KateViInputModeManager();

  bool handleKeypress(const QKeyEvent *e);

  void feedKeyPresses(const QString &keyPresses) const;

  bool isHandlingKeypress() const;

  ViMode getCurrentViMode() const;

  KateViModeBase* getCurrentViModeHandler() const;

  const QString getVerbatimKeys() const;

  void changeViMode(ViMode newMode);

  void viEnterNormalMode();

  void viEnterInsertMode();

  void viEnterVisualMode( ViMode visualMode = VisualMode );

  void viEnterReplaceMode();

  KateViNormalMode* getViNormalMode();

  KateViInsertMode* getViInsertMode();

  KateViVisualMode* getViVisualMode();

  KateViReplaceMode* getViReplaceMode();

  bool isReplayingLastChange() const { return m_isReplayingLastChange; }

  void appendKeyEventToLog(const QKeyEvent &e);

  void clearCurrentChangeLog() { m_currentChangeKeyEventsLog.clear(); m_currentChangeCompletionsLog.clear(); }

  void storeLastChangeCommand();

  void repeatLastChange();

  class Completion
  {
  public:
    enum CompletionType { PlainText, FunctionWithoutArgs, FunctionWithArgs };
    Completion(const QString& completedText, bool removeTail, CompletionType completionType);
    QString completedText() const;
    bool removeTail() const;
    CompletionType completionType() const;
  private:
    QString m_completedText;
    bool m_removeTail;
    CompletionType m_completionType;
  };
  void startRecordingMacro(QChar macroRegister);
  void finishRecordingMacro();
  bool isRecordingMacro();
  void replayMacro(QChar macroRegister);
  bool isReplayingMacro();
  void logCompletionEvent(const Completion& completion);
  Completion nextLoggedCompletion();
  void doNotLogCurrentKeypress();

  const QString getLastSearchPattern() const;

  void setLastSearchPattern( const QString &p );

  bool lastSearchBackwards() const { return m_lastSearchBackwards; }

  void setLastSearchBackwards( bool b ) { m_lastSearchBackwards = b; }

  void setLastSearchCaseSensitive(bool caseSensitive) { m_lastSearchCaseSensitive = caseSensitive; };

  void setLastSearchPlacesCursorAtEndOfMatch(bool b) { m_lastSearchPlacedCursorAtEndOfMatch = b; };

  bool lastSearchCaseSensitive() { return m_lastSearchCaseSensitive; };

  bool lastSearchPlacesCursorAtEndOfMatch() { return m_lastSearchPlacedCursorAtEndOfMatch; };

  bool getTemporaryNormalMode() { return m_temporaryNormalMode; }

  void setTemporaryNormalMode(bool b) {  m_temporaryNormalMode = b; }

  void reset();

  // Jump Lists
  void addJump(KTextEditor::Cursor cursor);
  KTextEditor::Cursor getNextJump(KTextEditor::Cursor cursor);
  KTextEditor::Cursor getPrevJump(KTextEditor::Cursor cursor);
  void PrintJumpList();

  // session stuff
  void readSessionConfig( const KConfigGroup& config );
  void writeSessionConfig( KConfigGroup& config );

  // marks
  void addMark( KateDocument* doc, const QChar& mark, const KTextEditor::Cursor& pos,
                const bool moveoninsert = true, const bool showmark = true );
  KTextEditor::Cursor getMarkPosition( const QChar& mark ) const;
  void syncViMarksAndBookmarks();
  QString getMarksOnTheLine(int line);

  static QString modeToString(ViMode mode);

  KateViKeyMapper* keyMapper();

private Q_SLOTS:
  void markChanged (KTextEditor::Document* doc,
                    KTextEditor::Mark mark,
                    KTextEditor::MarkInterface::MarkChangeAction action);

private:
  KateViNormalMode* m_viNormalMode;
  KateViInsertMode* m_viInsertMode;
  KateViVisualMode* m_viVisualMode;
  KateViReplaceMode* m_viReplaceMode;

  ViMode m_currentViMode;

  KateView *m_view;
  KateViewInternal *m_viewInternal;
  KateViKeyParser *m_keyParser;

  // Create a new keymapper for each macro event, to simplify expansion of mappings in macros
  // where the macro itself was triggered by expanding a mapping!
  QStack<QSharedPointer<KateViKeyMapper> > m_keyMapperStack;

  int m_insideHandlingKeyPressCount;

  bool m_isReplayingLastChange;

  bool m_isRecordingMacro;

  QChar m_recordingMacroRegister;
  QList<QKeyEvent> m_currentMacroKeyEventsLog;

  int m_macrosBeingReplayedCount;
  QChar m_lastPlayedMacroRegister;

  QList<Completion> m_currentMacroCompletionsLog;

  QStack<QList<Completion> > m_macroCompletionsToReplay;
  QStack< int > m_nextLoggedMacroCompletionIndex;

  QList<QKeyEvent> m_currentChangeKeyEventsLog;
  QList<Completion> m_currentChangeCompletionsLog;
  QList<Completion> m_lastChangeCompletionsLog;
  int m_nextLoggedLastChangeComplexIndex;

  QString m_lastChange;

  QString m_lastSearchPattern;
  bool m_lastSearchBackwards;
  bool m_lastSearchCaseSensitive;

  bool m_lastSearchPlacedCursorAtEndOfMatch;

  bool m_temporaryNormalMode;

  bool m_markSetInsideViInputModeManager;

  // jump list
  QList<KateViJump> *jump_list;
  QList<KateViJump>::iterator current_jump;

  // marks
  QMap<QChar, KTextEditor::MovingCursor*> m_marks;

};

#endif