Commit 220cf0d2 authored by hjk's avatar hjk
Browse files

Add some sandbox for hjkl folks.

Note that <Esc> is called <Shift-Esc>.
parent 43bf95a1
......@@ -319,6 +319,7 @@ EditorManager::EditorManager(ICore *core, QWidget *parent) :
IActionContainer *advancedMenu = am->createMenu(Constants::M_EDIT_ADVANCED);
medit->addMenu(advancedMenu, Constants::G_EDIT_FORMAT);
advancedMenu->menu()->setTitle(tr("&Advanced"));
cmd = am->registerAction(m_d->m_openInExternalEditorAction, Constants::OPEN_IN_EXTERNAL_EDITOR, editManagerContext);
cmd->setDefaultKeySequence(QKeySequence(tr("Alt+V,Alt+I")));
advancedMenu->addAction(cmd);
......
<plugin name="FakeVim" version="0.9.2" compatVersion="0.9.2">
<vendor>Nokia Corporation</vendor>
<copyright>(C) 2008 Nokia Corporation</copyright>
<license>Nokia Beta Version License</license>
<description>VI-style keyboard navigation.</description>
<url>http://www.trolltech.com/</url>
<dependencyList>
<dependency name="CppEditor" version="0.9.2"/><!-- Plugin adds items to the editor's context menu -->
<dependency name="ProjectExplorer" version="0.9.2"/>
<dependency name="Core" version="0.9.2"/>
</dependencyList>
</plugin>
TEMPLATE = lib
TARGET = FakeVim
# CONFIG += single
include(../../qworkbenchplugin.pri)
include(../../plugins/projectexplorer/projectexplorer.pri)
include(../../plugins/coreplugin/coreplugin.pri)
include(../../plugins/texteditor/texteditor.pri)
# DEFINES += QT_NO_CAST_FROM_ASCII QT_NO_CAST_TO_ASCII
QT += gui
SOURCES += \
handler.cpp \
fakevimplugin.cpp
HEADERS += \
handler.h \
fakevimplugin.h
/***************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Qt Software Information (qt-info@nokia.com)
**
**
** Non-Open Source Usage
**
** Licensees may use this file in accordance with the Qt Beta Version
** License Agreement, Agreement version 2.2 provided with the Software or,
** alternatively, in accordance with the terms contained in a written
** agreement between you and Nokia.
**
** GNU General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the packaging
** of this file. Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
**
** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
** http://www.gnu.org/copyleft/gpl.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt GPL Exception
** version 1.3, included in the file GPL_EXCEPTION.txt in this package.
**
***************************************************************************/
#include "fakevimplugin.h"
#include "handler.h"
#include <coreplugin/actionmanager/actionmanagerinterface.h>
#include <coreplugin/coreconstants.h>
#include <coreplugin/editormanager/editormanager.h>
#include <coreplugin/icore.h>
#include <coreplugin/messagemanager.h>
#include <coreplugin/modemanager.h>
#include <coreplugin/uniqueidmanager.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/session.h>
#include <texteditor/basetexteditor.h>
#include <texteditor/basetextmark.h>
#include <texteditor/itexteditor.h>
#include <texteditor/texteditorconstants.h>
#include <utils/qtcassert.h>
#include <QtCore/QDebug>
#include <QtCore/qplugin.h>
#include <QtCore/QObject>
#include <QtCore/QPoint>
#include <QtCore/QSettings>
#include <QtGui/QPlainTextEdit>
#include <QtGui/QTextBlock>
#include <QtGui/QTextCursor>
using namespace FakeVim::Internal;
//using namespace FakeVim::Constants;
using namespace TextEditor;
using namespace Core;
using namespace ProjectExplorer;
namespace FakeVim {
namespace Constants {
const char * const INSTALL_HANDLER = "FakeVim.InstallHandler";
const char * const INSTALL_KEY = "Alt+V,Alt+V";
} // namespace Constants
} // namespace FakeVim
///////////////////////////////////////////////////////////////////////
//
// FakeVimPlugin
//
///////////////////////////////////////////////////////////////////////
FakeVimPlugin::FakeVimPlugin()
{
m_pm = 0;
m_handler = 0;
}
FakeVimPlugin::~FakeVimPlugin()
{}
void FakeVimPlugin::shutdown()
{
delete m_handler;
m_handler = 0;
}
bool FakeVimPlugin::initialize(const QStringList &arguments, QString *error_message)
{
Q_UNUSED(arguments);
Q_UNUSED(error_message);
m_handler = new FakeVimHandler;
m_pm = ExtensionSystem::PluginManager::instance();
ICore *core = m_pm->getObject<Core::ICore>();
QTC_ASSERT(core, return false);
Core::ActionManagerInterface *actionManager = core->actionManager();
QTC_ASSERT(actionManager, return false);
QList<int> globalcontext;
globalcontext << Core::Constants::C_GLOBAL_ID;
m_installHandlerAction = new QAction(this);
m_installHandlerAction->setText(tr("Set vi-Style Keyboard Action Handler"));
Core::ICommand *cmd = 0;
cmd = actionManager->registerAction(m_installHandlerAction,
Constants::INSTALL_HANDLER, globalcontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::INSTALL_KEY));
IActionContainer *advancedMenu =
actionManager->actionContainer(Core::Constants::M_EDIT_ADVANCED);
advancedMenu->addAction(cmd);
connect(m_installHandlerAction, SIGNAL(triggered()),
this, SLOT(installHandler()));
return true;
}
void FakeVimPlugin::extensionsInitialized()
{
}
void FakeVimPlugin::installHandler()
{
ICore *core = m_pm->getObject<Core::ICore>();
if (!core || !core->editorManager())
return;
Core::IEditor *editor = core->editorManager()->currentEditor();
ITextEditor *textEditor = qobject_cast<ITextEditor*>(editor);
if (!textEditor)
return;
QWidget *widget = textEditor->widget();
QPlainTextEdit *plainTextEdit = qobject_cast<QPlainTextEdit *>(widget);
if (!plainTextEdit)
return;
plainTextEdit->removeEventFilter(m_handler);
plainTextEdit->installEventFilter(m_handler);
QFont font = plainTextEdit->font();
//font.setFamily("Monospace");
m_savedCursorWidth = plainTextEdit->cursorWidth();
plainTextEdit->setCursorWidth(QFontMetrics(font).width(QChar('x')));
//QMainWindow mw;
connect(m_handler, SIGNAL(commandBufferChanged(QString)),
this, SLOT(showCommandBuffer(QString)));
connect(m_handler, SIGNAL(quitRequested(QObject *)),
this, SLOT(removeHandler(QObject *)));
}
void FakeVimPlugin::removeHandler(QObject *ob)
{
ob->removeEventFilter(m_handler);
QPlainTextEdit *plainTextEdit = qobject_cast<QPlainTextEdit *>(ob);
if (!plainTextEdit)
return;
plainTextEdit->setCursorWidth(m_savedCursorWidth);
}
void FakeVimPlugin::showCommandBuffer(const QString &contents)
{
//qDebug() << "CMD: " << contents;
}
//#include "fakevimplugin.moc"
Q_EXPORT_PLUGIN(FakeVimPlugin)
/***************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Qt Software Information (qt-info@nokia.com)
**
**
** Non-Open Source Usage
**
** Licensees may use this file in accordance with the Qt Beta Version
** License Agreement, Agreement version 2.2 provided with the Software or,
** alternatively, in accordance with the terms contained in a written
** agreement between you and Nokia.
**
** GNU General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the packaging
** of this file. Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
**
** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
** http://www.gnu.org/copyleft/gpl.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt GPL Exception
** version 1.3, included in the file GPL_EXCEPTION.txt in this package.
**
***************************************************************************/
#ifndef FAKEVIMPLUGIN_H
#define FAKEVIMPLUGIN_H
#include <extensionsystem/iplugin.h>
#include <QtCore/QObject>
QT_BEGIN_NAMESPACE
class QAction;
class QCursor;
class QAbstractItemView;
QT_END_NAMESPACE
namespace Core { class IEditor; }
namespace TextEditor { class ITextEditor; }
namespace FakeVim {
namespace Internal {
class FakeVimHandler;
class FakeVimPlugin : public ExtensionSystem::IPlugin
{
Q_OBJECT
public:
FakeVimPlugin();
~FakeVimPlugin();
private:
bool initialize(const QStringList &arguments, QString *error_message);
void shutdown();
void extensionsInitialized();
private slots:
void installHandler();
void removeHandler(QObject *ob);
void showCommandBuffer(const QString &contents);
private:
FakeVimHandler *m_handler;
ExtensionSystem::PluginManager *m_pm;
QAction *m_installHandlerAction;
int m_savedCursorWidth;
};
} // namespace Internal
} // namespace FakeVim
#endif // FAKEVIMPLUGIN_H
/***************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Qt Software Information (qt-info@nokia.com)
**
**
** Non-Open Source Usage
**
** Licensees may use this file in accordance with the Qt Beta Version
** License Agreement, Agreement version 2.2 provided with the Software or,
** alternatively, in accordance with the terms contained in a written
** agreement between you and Nokia.
**
** GNU General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the packaging
** of this file. Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
**
** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
** http://www.gnu.org/copyleft/gpl.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt GPL Exception
** version 1.3, included in the file GPL_EXCEPTION.txt in this package.
**
***************************************************************************/
#include "handler.h"
#include <QDebug>
#include <QKeyEvent>
#include <QLineEdit>
#include <QObject>
#include <QPlainTextEdit>
#include <QRegExp>
#include <QStack>
#include <QTextBlock>
#include <QTextEdit>
#include <QTextCursor>
using namespace FakeVim::Internal;
#define StartOfLine QTextCursor::StartOfLine
#define EndOfLine QTextCursor::EndOfLine
#define MoveAnchor QTextCursor::MoveAnchor
#define KeepAnchor QTextCursor::KeepAnchor
#define Up QTextCursor::Up
#define Down QTextCursor::Down
#define Right QTextCursor::Right
#define Left QTextCursor::Left
///////////////////////////////////////////////////////////////////////
//
// FakeVimHandler
//
///////////////////////////////////////////////////////////////////////
const int ParagraphSeparator = 0x00002029;
using namespace Qt;
enum Mode { InsertMode, CommandMode, ExMode };
enum SubMode { NoSubMode, RegisterSubMode, ChangeSubMode, DeleteSubMode };
class FakeVimHandler::Private
{
public:
Private(FakeVimHandler *parent);
bool eventFilter(QObject *ob, QEvent *ev);
static int shift(int key) { return key + 32; }
static int control(int key) { return key + 256; }
void init();
void handleKey(int key);
void handleInsertMode(int key);
void handleCommandMode(int key);
void handleRegisterMode(int key);
void handleExMode(int key);
void finishMovement();
void updateCommandBuffer();
void search(const QString &needle, bool backwards);
void showMessage(const QString &msg);
int count() const { return m_count.isEmpty() ? 1 : m_count.toInt(); }
int leftDist() const { return m_tc.position() - m_tc.block().position(); }
int rightDist() const { return m_tc.block().length() - leftDist() - 1; }
bool atEol() const { return m_tc.atBlockEnd() && m_tc.block().length()>1; }
FakeVimHandler *q;
Mode m_mode;
SubMode m_submode;
QString m_input;
QPlainTextEdit *m_editor;
QTextCursor m_tc;
QHash<int, QString> m_registers;
int m_register;
QString m_count;
QStack<QString> m_undoStack;
QStack<QString> m_redoStack;
bool m_fakeEnd;
int m_commandCode; // ?, /, : ...
QString m_commandBuffer;
bool m_lastSearchBackward;
QString m_lastSearchString;
};
FakeVimHandler::Private::Private(FakeVimHandler *parent)
{
q = parent;
m_mode = CommandMode;
m_fakeEnd = false;
m_lastSearchBackward = false;
m_register = '"';
}
bool FakeVimHandler::Private::eventFilter(QObject *ob, QEvent *ev)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
int key = keyEvent->key();
if (key == Key_Shift || key == Key_Alt || key == Key_Control
|| key == Key_Alt || key == Key_AltGr || key == Key_Meta)
return false;
//qDebug() << "KEY: " << key << Qt::ShiftModifier;
// Fake "End of line"
m_editor = qobject_cast<QPlainTextEdit *>(ob);
if (!m_editor)
return false;
m_tc = m_editor->textCursor();
if (m_fakeEnd) {
//m_fakeEnd = false;
m_tc.movePosition(Right, MoveAnchor, 1);
qDebug() << "Unfake EOL";
}
if (key >= Key_A && key <= Key_Z
&& (keyEvent->modifiers() & Qt::ShiftModifier) == 0)
key += 32;
if ((keyEvent->modifiers() & Qt::ControlModifier) != 0)
key += 256;
handleKey(key);
// We fake vi-style end-of-line behaviour
m_fakeEnd = atEol() && m_mode == CommandMode;
//qDebug() << "POS: " << m_tc.position()
// << " BLOCK LEN: " << m_tc.block().length()
// << " LEFT: " << leftDist() << " RIGHT: " << rightDist();
if (m_fakeEnd) {
m_tc.movePosition(Left, MoveAnchor, 1);
qDebug() << "Fake EOL";
}
//qDebug() << "POS: " << m_tc.position()
// << " BLOCK LEN: " << m_tc.block().length()
// << " LEFT: " << leftDist() << " RIGHT: " << rightDist();
m_editor->setTextCursor(m_tc);
m_editor->ensureCursorVisible();
return true;
}
void FakeVimHandler::Private::handleKey(int key)
{
if (m_mode == InsertMode)
handleInsertMode(key);
else if (m_mode == CommandMode)
handleCommandMode(key);
else if (m_mode == ExMode)
handleExMode(key);
}
void FakeVimHandler::Private::finishMovement()
{
if (m_submode == ChangeSubMode) {
m_registers[m_register] = m_tc.selectedText();
m_tc.removeSelectedText();
m_mode = InsertMode;
m_submode = NoSubMode;
} else if (m_submode == DeleteSubMode) {
m_registers[m_register] = m_tc.selectedText();
m_tc.removeSelectedText();
m_submode = NoSubMode;
if (atEol())
m_tc.movePosition(Left, MoveAnchor, 1);
}
m_count.clear();
m_register = '"';
m_tc.clearSelection();
updateCommandBuffer();
}
void FakeVimHandler::Private::updateCommandBuffer()
{
//qDebug() << "CMD" << m_commandBuffer;
QString msg = QChar(m_commandCode ? m_commandCode : ' ') + m_commandBuffer;
emit q->commandBufferChanged(msg);
}
void FakeVimHandler::Private::showMessage(const QString &msg)
{
emit q->commandBufferChanged(msg);
}
void FakeVimHandler::Private::handleCommandMode(int key)
{
//qDebug() << "-> MODE: " << m_mode << " KEY: " << key;
if (m_submode == RegisterSubMode) {
m_register = key;
m_submode = NoSubMode;
} else if (m_submode == ChangeSubMode && key == 'c') {
m_tc.movePosition(StartOfLine, MoveAnchor);
m_tc.movePosition(Down, KeepAnchor, count());
m_registers[m_register] = m_tc.selectedText();
finishMovement();
} else if (m_submode == DeleteSubMode && key == 'd') {
m_tc.movePosition(StartOfLine, MoveAnchor);
m_tc.movePosition(Down, KeepAnchor, count());
m_registers[m_register] = m_tc.selectedText();
finishMovement();
} else if (key >= '0' && key <= '9') {
if (key == '0' && m_count.isEmpty()) {
m_tc.movePosition(StartOfLine, KeepAnchor);
finishMovement();
} else {
m_count.append(QChar(key));
}
} else if (key == ':' || key == '/' || key == '?') {
m_commandCode = key;
m_mode = ExMode;
updateCommandBuffer();
} else if (key == '|') {
m_tc.movePosition(StartOfLine, KeepAnchor);
m_tc.movePosition(Right, KeepAnchor, qMin(count(), rightDist()) - 1);
finishMovement();
} else if (key == '"') {
m_submode = RegisterSubMode;
} else if (key == Key_Return) {
m_tc.movePosition(StartOfLine);
m_tc.movePosition(Down);
} else if (key == Key_Home) {
m_tc.movePosition(StartOfLine, KeepAnchor);
finishMovement();
} else if (key == '$' || key == Key_End) {
m_tc.movePosition(EndOfLine, KeepAnchor);
finishMovement();
} else if (key == 'A') {
m_tc.movePosition(EndOfLine, MoveAnchor);
m_mode = InsertMode;
} else if (key == 'c') {
m_submode = ChangeSubMode;
} else if (key == 'C') {
m_submode = ChangeSubMode;
m_tc.movePosition(EndOfLine, KeepAnchor);
finishMovement();
} else if (key == 'd') {
if (atEol())
m_tc.movePosition(Left, MoveAnchor, 1);
m_submode = DeleteSubMode;
} else if (key == 'D') {
m_submode = DeleteSubMode;
m_tc.movePosition(EndOfLine, KeepAnchor);
finishMovement();
} else if (key == 'h' || key == Key_Left) {
int n = qMin(count(), leftDist());
if (m_fakeEnd && m_tc.block().length() > 1)
++n;
m_tc.movePosition(Left, KeepAnchor, n);
finishMovement();
} else if (key == 'i') {
m_mode = InsertMode;
} else if (key == 'j' || key == Key_Down) {
m_tc.movePosition(Down, KeepAnchor, count());
finishMovement();
} else if (key == 'k' || key == Key_Up) {
m_tc.movePosition(Up, KeepAnchor, count());
finishMovement();
} else if (key == 'l' || key == Key_Right) {
m_tc.movePosition(Right, KeepAnchor, qMin(count(), rightDist()));
finishMovement();
} else if (key == 'n') {