In 2008 I did a Google Summer of Code project for the Kate text editor where I wrote a Vi Input Mode – making it possible to use Kate in a modal, Vi[m]-like manner. The project was successful and I continued to maintain this code and added more features over the years. This summer I took the step of signing up as a mentor myself and put out a project proposal for further improving the Vi Mode in Kate and adding a good unit test framework for the code. To my surprise – and delight! – many students were interested in the project and we ended up getting quite a few applications from students wanting to work on “my” project. In the end the Russian computer science student  Святослав Кузьмич (Svyatoslav Kuzmich) from Moscow Institute of Physics and Technology was chosen.

The Kate Editor

Over the summer he wrote a test framework for the Vi Mode and wrote test for the functionality already present. Having an easy way of adding tests for the Vi mode had been on my wish list for a long time and it was really nice to see it implemented. It did not take long for the new test system to show its value: Svyatoslav found some corner case bugs that had probably been in the code for a long time and fixed them. A short overview of the new test framework can be found at the Kate blog: Kate Vi Mode Test Suite.

Svyatoslav also made many more visible improvements to the Vi Mode such as jump lists (making it possible to jump back/forward to where you were in the text), making it possible to control sub windows with the keyboard, many new command line mode commands and much more. An overview can be found in his blog post at kate-editor.org.

For me personally it was an interesting experience to act as a mentor for another programmer. My function also changed as the project progressed. In the beginning I tried to give Svyatoslav an overview of the current code and answer some questions as they came up. The programming work itself was rarely a theme – Svyatoslav was already a really good coder and generally just needed to be pointed in the right direction or – even more commonly – just get a confirming nod that his suggested solution sounded good. Since I had a few years to think about many of the features he wanted to implement I also had a few “that does sound like a good idea, but…” often learned the hard way.

In the end the project turned out very well and the users will get many new features – some of which have been wished for for years.

As a wrap-up of Google Summer of Code 2011 I am going to San Francisco next week to take part in the GSoC 2011 mentor summit where mentors from the organizations taking part in the Summer of Code meet to exchange experiences and discuss future directions for the programme. I am really looking forward to that!

A block selected by visual block mode

One of the most oft-missed features of Kate’s Vi input mode is Vim’s visual block mode. Visual block mode is entered by pressing ctrl+v and allow a rectangular block of text to be selected and manipulated. Also, text can be prepended or appended to the block, which is useful for, e.g. commenting out a range of lines.

Well, good news, everyone! There is now experimental support for visual block mode in Kate’s Vi input mode. Most text manipulation commands should already support visual block mode, and prepending/appending text (shift+i and shift+a, respectively) works, and you can select to end-of-line with $, as in Vim. I also made it possible to re-select the last visual selection with gv, and the marks ‘<’ and ‘>’ are set to the start and end position of the last visual selection. (Further down the road it will hopefully be possible to use marks in ex commands, too.)

There are probably still some rough edges, but visual block mode should already be usable. If you want to help test it, build Kate from git and try it out.

// BEGIN USER CONFIGURATION
var cfgIndentCase = true; // indent ‘case’ and ‘default’ in a switch?
var cfgIndentNamespace = true; // indent after ‘namespace’?
var cfgAutoInsertStar = false; // auto insert ‘*’ in C-comments
var cfgSnapSlash = false; // snap ‘/’ to ‘*/’ in C-comments
var cfgAutoInsertSlashes = false; // auto insert ‘//’ after C++-comments
// END USER CONFIGURATION

To set these options one would first have to actually find the indenting scripts under /usr/share, then copy it to one’s home directory to be able to modify it, and then modify the javascript source. This could – of course – be done in a much better way. In an ideal world options like these should be available in Kate’s settings as check boxes. It should also be possible to have non-boolean options, like choosing a value from a list of possible values for a setting.

I would love to see something like the following:

registerSetting(“Indent ‘case’ and ‘default’ in switch statements”, “cfgIndentCase”,  “boolean”);

produce

☑ Indent ‘case’ and ‘default’ in switch statements

in Kate’s settings.

I don’t have the time myself, but I don’t think it would be very hard, and I’m sure that many people would be a bit happier. Me and the other Kate developers would glady be of assistance. ☺

Dear “Katevim” users.  Kate’s Vi Mode is steadily improving and I want to take a moment to tell what’s on the horizon for KDE 4.4. There has been quite a few bugs fixed since 4.3, but some major new features have also been introduced:

The Comma Text Object

This is something that I have been missing in Vim. The comma text object makes it easy to modify parameter lists in C-like languages and other comma separated lists. It is basically the area between two commas or between a comma and a bracket. In the line below, the three ranges this text object would cover is highlighted in red.

Comma text object ranges. If the cursor is over, say, "arg2", pressing c i , ("change inner comma") would delete "double arg2" and place the cursor between the two commas in insert mode. A very convenient way to change a function's parameter

This has actually been in Kate’s Vi Mode for a while now, but since it has not been announced until now, I guess I am the only one using it.

Limited Normal Mode Mapping Support

It is now possible to add mappings in normal mode (:nnoremap in Vim). There are still some flaws, such as the fact that one cannot map a keypress to “:somecommand<enter>“, but hopefully people who are using dvorak/colemake can make use of the vi mode now.

It is now possible to map keypresses in normal mode

Command Line Mode Commands

Yes, really! Kate’s Vi Mode finally support some of the most command commandline mode commands from Vim. What can be done from the Kate editor part is limited by the fact that it can’t control its hosting application, but Kate – the application – has now gotten support for the following commands:

• q, qa
  
• w, wq, wa, wqa
  
• x, xa
  
• bn, bp
  
• new, vnew
  
• edit

Kate showing help text for a command line mode command

(Ok, not really.)

Kate’s maintainer, Christoph Cullmann, shared a funny story over a beer one of the first days here at GCDS.

In ye olden days, what is now Kate and Kwrite was one application called “KWrite – KDE’s Advanced Text Editor”. However, the author of Kwrite mysteriously disappeared. Christoph forked Kwrite and continued working on it and after some time it greatly surpassed Kwrite’s capabilities and was becoming more of a power tool. A name change was long overdue.
Being a good German, Christoph decided to name it after the philosopher Immanuel Kant, so in KDE 2.1 the editor “Kant” was born.
For some strange reason, probably easier to understand for native English speakers, it was renamed to “Kate” in KDE 2.2. And thus what still is KDE’s Advanced Text Editor was born.

It’s not a simple, 27 line python script any more, but now it’s much more usable. (unless there are some stupid bugs I have overlooked. )

As suggested I uploaded it to KDE Look: http://www.kde-look.org/content/show.php?content=104182, so you can install it from the “Add widgets…” dialogue or download it and install it with plasmapkg -i gcal-1.1.plasmoid.

The login is just a quick hack, btw. This pretty much sums it up:

src = src.replace("id="Email"",
    "id="Email" value=""+self.settings['username']+""")
src = src.replace("id="Passwd"",
    "id="Passwd" value=""+self.settings['password']+""")
src = src.replace("id="gaia_loginform"",
    "id="gaia_loginform" name="gaia_loginform"")
src = src.replace("",
src = src.replace("</body>",
    "<script>document.gaia_loginform.submit()</script></body>")

I also tried the ninja trick from Ariya’s blog to get a transparent webview, but Google’s 1995 gif logo pretty much destroyed the appearance, so I dropped that.

http://hamberg.no/erlend/2009/05/07/google-calendar-plasmoid-take-two/

In case anyone is interested:

I made a simple Plasmoid for viewing coming events from Google Calendar. It’s simply a webview showing the iPhone version of Google Calendar. It’s written in Python and took 10 minutes to write (27 lines of code) by following the excellent tutorial on techbase.

You can download it here: http://hamberg.no/erlend/files/gcal.zip. If you improve it or make another Google Calendar plasmoid: let me know!

Oh, btw. To install it run plasmapkg -i gcal.zip.

P.S: openSuse users: I had to install python-dev to actually run a python plasmoid. Don’t know why.

Among the new books I’ll bring there will also be at least one wikibook. Yes, a real, physical wikibook.
You see, I have been using the x86 disassembly wikibook quite often, and recently I read that there were a “a collection for print-on-demand publishing from PediaPress” available for the book. Being curious, I had to click the link to see what that actually meant…

It turns out that PediaPress will print a copy of a wikibook for a very fair price. It can even be your own compilation of parts of books (and Wikipedia support is coming, according to their webpage). Printing and shipping of the book (200 pages) to Norway was a little over 10 EUR.

I’m now sitting with three printed wikibooks in front of me, and the quality of the printed book are very good. Needless to say, I’m very happy. They even donate a portion of the proceeds to the Wikimedia Foundation (though, they don’t say how much).

Shiny new books

Okteta is of course mentioned

I just marked the Vi input mode (“V.I.M.”? ) for the Kate kpart as done in the feature plan for KDE 4.2. It feels a bit weird to mark it as done, though, as there are tonnes of things I want to implement after KDE 4.2.

As you may know this started as a Google Summer of Code project and I’m quite happy with the way things have turned out. Since we are in feature freeze I would like to present the features that will be in the Vi input mode for the Kate part in KDE 4.2.

Kate Vi Input Mode in action – visual mode selection

The Vi input mode can be used as the default editing mode by selecting it in Settings → Configure Kate… → Editing → Vi Input Mode and/or toggled any time by selecting View → Vi Input Mode. Nifty, eh?

[Edit: this has been moved to the "Edit" menu.]

Vi Input Mode toggle

Thanks to Dmitry Suzdalev there is also an (optional) vi mode status bar. This shows commands while they are being entered, output from commands like ‘ga’ (the character code of the character under the cursor) and of coruse the current mode.

Kate Vi Input mode status bar – "a4d has been pressed

Quite a few of the vi commands crash with “regular” Kate shortcuts, like ctrl+b/ctrl+f for scrolling up/down one page. If you want to use these as vi commands, you can choose to let Vi commands override Kate shortcuts in the Vi input mode settings. As you might know, ctrl+r is used for “redo” in vim. To make it possible to redo for people not wanting to override Kate’s shortcuts shift+u is also used for undo. (This key press is used for “undoing all latest changes on one line” in Vim.)

I have also added support for ranges to Kate’s command line commands. So you can do 1,10kill-line (“kill-line” is a Kate command, not a vi(m) command). This also works for the substitute command which is already a part of Kate: s/foo/bar/g. This is something whose potential hopefully will be fully exploited in the future when more commands are added.

For now, the only “ex commands” supported are :w and :hardcopy. Part of the reason not more commands are supported is because I need to figure out how to send requests from the editor part to the hosting application requesting to e.g. quit or close a buffer. I also want to be able to add several forms of commands like :d[elete], :w[rite] and so on. (But only the long form should be shown in the autocompletion to not clutter the dropdown with confusing one-letter commands.)

But, enough of what’s not supported! Here is the list of the commands that actually made it into the Vi Input Mode before the feature freeze:

Supported normal/visual mode commands

Supported motions

Supported text objects

Supported insert mode commands

The missing pieces

The aim of Kate’s Vi input mode is—as I have said before—is not to replace vim’s functionality, but to have a editor kpart that is comfortable to use for us Vi(m)-heads. There are however some things I feel is still missing and would like to implement after KDE 4.2 (some of them mentioned above):

• Proper command mode (“ex commands”) support (very few commands are supported as of now)
• Saving of registers and marks between editing sessions
• “Replace mode” (shift+r in vim)
• Integrating the Vi input mode marks with Kate’s bookmarks system
• Making it possible to use registers in ranges and add support for the the ‘<’ and ‘>’ registers

Please test!

I will be studying for my exams until 19 December so I won’t have much time for coding, but I would still like people to test the Vi Input Mode and report bugs so I have a better chance of fixing them before the end of January and the 4.2 release.

There are also lots of new commands and support for setting and jumping to marks. These are not saved between sessions yet, though. Overall, it’s already quite usable, even if it still has its small quirks and bugs here and there. This will definitely better quite soon as I use it quite extensively myself, and fix bugs as I find them.

A really nice feature is that one can quickly toggle the vi input mode on and off by using the view menu or a short cut (default is ctrl+meta+v).

The big thing left to do is to enchance Kate’s built-in command line. I want to add support for the most command vi commands and make it support ranges, setting of options, etc. The current command line implementation isn’t really suited for this, so it probably needs to be modified quite a bit. Hopefully it will eventually be possible to send commands to the app hosting the katepart too. Asking it to quit, close a buffer, etc. Right now the only command supported is :w.

I am very satified with what I accomplished during GSoC. I had to change some of my plans underway, mostly due to actually using my work, and seeing which features I missed the most. GSoC was a nice start, but there are still lots of things I want to do.