Kate | Get an Edge in Editing

External Tools Plugin is Back

Sat, 21 Sep 2019 21:50:00 +0200

Back in 2011, we decided to remove the External Tools plugin in Kate for the KDE 4.8 release, since it was unmaintained and we got more and more bugs that were not fixed. However, over the years, we got many requests (and complaints) to bring this plugin back to life, since it was very useful to start little helper scripts with just a shortcut, via the command line, or the menu.

The good news is that for the KDE Applications 19.12 release, the External Tools plugin will be back! And it is much improved compared to the previous version.

I’ve been looking at many external tools implementations, including Microsoft Visual Studio, Visual Studio Code, CLion, KDevelop, Eclipse, and Qt Creator. And I must say the implementation in Qt Creator was by far the most flexible one, so that’s what I used as reference.

So let’s have a look. Once you enable the plugin, a new entry “External Tools” appears in the config page. Selecting the “External Tools” entry, you will be presented with several tools by default:

Editing a tool opens a config dialog that allows fine-grained configuration of the tool:

As you can see, many details can be defined, namely:

Name: The name of the tool, which will later appear in the menu.
Icon: Optional icon that is visible in the menu.
Executable: the executable. You can either provide an absolute path, or your executable must be in the PATH environment variable.
Arguments: Optional arguments that are passed to the process.
Input: Optional input that is passed to the process via stdin.
Working directory: The working directory the tool will be started in. If empty, the working directory is set to the current document’s path.
Mime types: If set, the tool is active only if the current document’s mime type matches.
Save: When invoked, saves none, the current document, or all documents.
[ ] Reload current document after execution: Useful when the current file is modified on disk.
Output: The output defines the target of stdout.
Editor command: Optional command that can be used to invoke the external tool via Kate’s built-in command line (by default shortcut F7).

Support for Variables

The Executable, the Arguments, the Input and the Working Directory support variables that are expanded on tool invocation. This is indicated by the icon {} that appears once one of these text input fields has focus (cf. red circle):

Hovering over one of these text inputs also shows a tooltip with the current expanded text. Further, clicking on the {} action will open a dialog that lists all available variables:

This feature provides a lot of flexibility when defining an external tool since all variables of the form %{...} are expanded when the tool gets invoked. There are two kind of variables supported:

%{variable-name}
%{variable-name:<value>}

The first form %{variable-name} simply replaces the variable with its contents. For instance, the variable %{Document:FileName} is replaced by the current document’s filename without its path. The second form %{variable-name:<value>} gets the <value> as contents. For example, this can be used to expand an environment variable with %{ENV:HOME}. Or you can obtain the current date in your preferred format like %{Date:yyyy-MM-dd}.

Developer info: The concept of variable expansion was added to the KTextEditor framework with version 5.63 (cf. API documentation).

Supported variables include:

Document:FileBaseName: File base name without path and suffix of the current document.
Document:FileExtension: File extension of the current document.
Document:FileName: File name without path of the current document.
Document:FilePath: Full path of the current document including the file name.
Document:Text: Contents of the current document.
Document:Path: Full path of the current document excluding the file name.
Document:NativeFilePath: Full document path including file name, with native path separator (backslash on Windows).
Document:NativePath: Full document path excluding file name, with native path separator (backslash on Windows).
Document:Cursor:Line: Line number of the text cursor position in current document (starts with 0).
Document:Cursor:Column: Column number of the text cursor position in current document (starts with 0).
Document:Cursor:XPos: X component in global screen coordinates of the cursor position.
Document:Cursor:YPos: Y component in global screen coordinates of the cursor position.
Document:Selection:Text: Text selection of the current document.
Document:Selection:StartLine: Start line of selected text of the current document.
Document:Selection:StartColumn: Start column of selected text of the current document.
Document:Selection:EndLine: End line of selected text of the current document.
Document:Selection:EndColumn: End column of selected text of the current document.
Document:RowCount: Number of rows of the current document.
Date:Locale: The current date in current locale format.
Date:ISO: The current date (ISO).
Date:<value>: The current date (QDate formatstring).
Time:Locale: The current time in current locale format.
Time:ISO: The current time (ISO).
Time:<value>: The current time (QTime formatstring).
ENV:<value>: Access to environment variables.
JS:<expression>: Evaluate simple JavaScript statements.
UUID: Generate a new UUID.

List of Default Tools

Some tools are shipped by default. These tools mostly came to my mind, but if you have more useful tools please let us know at kwrite-devel@kde.org so that we can add them to this list.

git-cola

git-cola is a graphical git client that enables you to easily stage and commit changes. If installed, it is available also through the command line with “git-cola”.

Name: git-cola
Icon: git-cola
Executable: git-cola
Arguments: -r %{Document:Path}
Editor command: git-cola

gitk

gitk is a git client as well that allows to nicely visualize the git history.

Name: gitk
Icon: git-gui
Executable: gitk
Working directory: %{Document:Path}
Editor command: gitk

git blame

Starts git blame to easily follow git changes in the current file.

Name: git blame
Executable: git
Arguments: gui blame %{Document:FileName}
Save: Current Document
Working directory: %{Document:Path}
Editor command: git-blame

Run Shell Script

Starts an external konsole in which the current document is executed.

Name: Run Shell Script
Icon: system-run
Executable: konsole
Arguments: -e sh -c “cd %{Document:Path} && pwd && chmod -vc a+x %{Document:FileName} && ./%{Document:FileName} ; echo Press any key to continue. && read -n 1”
Working directory: %{Document:Path}
Save: Current Document
Editor command: run-script

Google Selected Text

Search in google for the selected text.

Name: Google Selected Text
Icon: globe
Executable: xdg-open
Arguments: “https://www.google.com/search?q=%{Document:Selection:Text}"
Editor command: google

Insert UUID

Inserts a new UUID each time this action is invoked.

Name: Insert UUID
Executable: echo
Arguments: %{UUID}
Output: Insert at Cursor Position
Editor command: uuid

Clang Format Full File

Runs clang-format on the current file on disk. The document is reloaded afterwards.

Name: Clang Format Full File
Executable: clang-format
Arguments: -i %{Document:FileName}
Working directory: %{Document:Path}
Save: Current Document
Reload: yes
Editor command: clang-format-file

Clang Format Selected Text

Runs clang-format just on the selected text in the current document.

Name: Clang Format Selected Text
Executable: clang-format
Arguments: -assume-fileName: %{Document:FileName}
Working directory: %{Document:Path}
Input: %{Document:Selection:Text}
Output: Replace Selected Text
Editor command: clang-format-selection

Qt Quick 2 Preview (qmlscene)

Previews the current qml file in qmlscene.

Name: Qt Quick 2 Preview (qmlscene)
Executable: qmlscene
Arguments: %{Document:FileName}
Save: Current Document
Working directory: %{Document:Path}
Editor command: qml-preview

Feel free to join the discussion at the KDE reddit.

Kate in the Windows Store

Thu, 12 Sep 2019 18:25:00 +0200

Our Windows Store submission succeeded, we are now officially in the store.

Try out how the Kate text editor performs on Windows for your personal workflow.

If you see issues and want to help out, contributions are welcome on our GitLab instance.

Our Windows team is small, any help is very welcome! Thanks again to all the people that made it possible to use Kate nicely on Windows.

Kate got submitted to the Windows Store

Thu, 12 Sep 2019 14:25:00 +0200

Since a few years Kate is working well on Windows. You can grab fresh installers since then from our download page.

But the visibility of it was very low for Windows users.

Already last year the plan was made to increase the visibility of KDE applications by getting them into the official Windows Store.

Like always, Akademy is a great chance to get the last bits ironed out and the stuff done!

Now, thanks to the help of Hannah von Reth and others, we finally got Kate submitted to the Windows Store!

The submission still needs to be processed by Microsoft, stay tuned when our nifty editor will really be available there for download!

Thanks to all people that contributed to this!

Kate Planning

Mon, 09 Sep 2019 17:44:00 +0200

The Opportunity

During Akademy 2019 here in Milan, Dominik and me had time to sit together and discuss a bit what we shall do to evolve Kate :)

Whereas Kate already works well as a general purpose editor, the competition in the text editor space got more intense in the last years.

Beside the well established stuff like GNU Emacs & Vim, new editor projects got started that did set the bar higher on what users expect from a advanced GUI text editor.

For example Sublime, Atom and Visual Studio Code are things to keep an eye on feature & polishing wise.

Therefore we decided it would make sense to think a bit about which stuff should be improved or altered in the near future.

The Rough Ideas

Kate Plugin Interfaces

From the KDE 4.x Kate to the KF5 based Kate version, we removed the Kate specific plugin interfaces and went with more generic interfaces in KTextEditor.

The idea was to be able to share more plugins e.g. between Kate and KDevelop. This idea never really did take off, at the moment just two of our plugins are shared at all…

On the other side, this makes it much harder to expose new functionality to our plugins, as we need to stay binary compatible.

Moving back to having some Kate only stuff that has not even installed headers but is just usable for the plugins we bundle in our kate.git will make it again more flexible what to expose.

One can still think about moving “proven in practice” parts back to the KTextEditor interface part.

Make Projects a Core-Feature

At the moment the projects feature is located in a plugin.

For exposure of some things like the current project files some evil Qt property hacks are used.

By moving this feature into the Kate core we can use a sane way to search in project, list project stuff in quick open, …

Other state of the art editors provide that per default, too

Still stuff like “shall we create projects on the fly” can be deactivated like today

LSP Support per default

We shall get the LSP support in a shape that it can be shipped enabled per default.

Users expect that modern editors provide advanced language integration off the shelf, like Atom, Visual Studio Code, …

We shall provide the user with better code navigation.

We will provide the plugins with an interface to register location jumps.

This will enable the user to seamlessly jump back and forth for any kind of location change e.g. due declaration lookup or search in files match lookup, …

Consolidate the plugins

The new LSP plugin shall subsume stuff like the Rust or D specific code completion plugins.

Think about the future of unmaintained plugins!

External Tools Plugin

Revive the external tools in a improved way, e.g. like in Qt Creator.

Improve Port to KSyntaxHighlighting

Porting the highlighting over to KSyntaxHighlighting was a big success.

Kate and Qt Creator now finally share the same highlighting engine and we got a lot of new contributions to our highlightings. (we support now over 300 different languages, something to be proud of)

Still, e.g. the theme support is still not moved over to what the new framework provides.

Further Brainstorming

Git Integration

We shall take a look what other editors provide.

Diff/Patch Viewer

Want we to integrate with stuff like KDiff3/Kompare/… to have a better handling of e.g. git diff, patches, …?

Improve View Management

Try to improve the way we handle splitting the views and the tabbing.

Take a look how other editors do that!

KDevelop vs. Kate?

Given already today we enter the area of KDevelop by providing the LSP client, we need to think about what happens in the future with overlapping features.

It is no goal to evolve Kate into an IDE.

We think Kate shall be a competitor for editors like Atom, not for full-fledged IDEs like KDevelop or Visual Studio.

Still, e.g. in the area of project management/code navigation/version control support there will be some overlap.

The question is: can we share stuff there? What shall be the focus of Kate and KDevelop in e.g. language support?

I think here it will be interesting which future direction the KDevelop project will take.

Discussion

If you want to chime in on this, feel free to join the discussion at the KDE reddit.

If you want to contribute, just join us at invent.kde.org or on kwrite-devel@kde.org.

KSyntaxHighlighting - Over 300 Highlightings...

Sun, 25 Aug 2019 14:06:00 +0200

I worked yesterday again on the Perl script that creates the highlighting update site used by e.g. Qt Creator.

I thought it would be perhaps a good idea to create some simple human readable overview with all existing highlighting definitions, too.

The result is this auto-generated Syntax Highlightings page.

Astonishing enough, at the moment the script counts 307 highlighting definitions. I wasn’t aware that we already crossed the 300 line.

Still, it seems people miss some highlighting definitions, take a look at the bug list of KSyntaxHighlighting.

The bugs with requests for new definition requests got marked with [New Syntax].

I am actually not sure if we should at all keep bugs for such requests, if no patch is provided there to add such an highlighting. Obviously, we want to have proper highlighting for all stuff people use.

But, as we have these bugs at the moment, if you feel you have the time to help us, take a look. Some Perl 6 highlighting is appreciated, or any of the others there ;=) Or perhaps you have a own itch to scratch and provide something completely different!

Our documentation provides hints how to write a highlighting definition. Or just take a look at the existing XML files in our KSyntaxHighlighting repository.

Patches are welcome on the KDE Phabricator.

Otherwise, if you provide a new definition XML + one test case, you can attach them to the bug, too (or send them to kwrite-devel@kde.org).

With test case an example file in the new language is wanted, with some liberal license. This will be used to store reference results of the highlighting to avoid later regressions and to judge the quality of the highlighting and later improvements.

We would prefer MIT licensed new files, if they are not derived from older files that enforce a different license, thanks! (in that case, it would be good to mention in some XML comment which file was used as base)

Kate - Document Preview Plugin - Maintainer Wanted!

Sat, 24 Aug 2019 18:46:00 +0200

At the moment the Document Preview plugin that e.g. allows to preview Markdown or other documents layout-ed via embedding a matching KPart is no longer maintained.

You can find more information about why the plugin got abandoned in this phabricator ticket.

If you want to step up and keep that plugin alive and kicking, now is your chance!

Even if you don’t want to maintain it, you can help out with taking care of existing bugs for this plugin.

Just head over to the KDE Bugzilla bugs for this plugin.

Any help with this is welcome!

Kate - More languages supported via LSP!

Sat, 10 Aug 2019 18:41:00 +0200

The default configuration for the Kate LSP client does now support more stuff than just C/C++ and Python out of the box.

In addition to the recently added Rust support we now support Go and LaTeX/BibTeX, too.

Configuration

The default supported server are configured via some JSON settings file we embed in our plugin resources.

Currently this looks like:

{
"servers": {
"bibtex": {
"use": "latex"
},
"c": {
"command": ["clangd", "-log=error", "--background-index"],
"commandDebug": ["clangd", "-log=verbose", "--background-index"],
"url": "https://clang.llvm.org/extra/clangd/"
},
"cpp": {
"use": "c"
},
"latex": {
"command": ["texlab"],
"url": "https://texlab.netlify.com/"
},
"go": {
"command": ["go-langserver"],
"commandDebug": ["go-langserver", "-trace"],
"url": "https://github.com/sourcegraph/go-langserver"
},
"python": {
"command": ["python3", "-m", "pyls", "--check-parent-process"],
"url": "https://github.com/palantir/python-language-server"
},
"rust": {
"command": ["rls"],
"rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
"url": "https://github.com/rust-lang/rls"
}
}
}

The file is located at kate.git/addons/lspclient/settings.json. Merge requests to add additional languages are welcome.

I assume we need still to improve what we allow to specify in the configuration.

Currently supported configuration keys

At the moment, the following keys inside the per-language object are supported:

use

Tell the LSP client to use the LSP server for the given language for this one, too. Useful to dispatch stuff to a server supporting multiple languages, like clangd for C and C++.

command

Command line to start the LSP server.

commandDebug

Command line to start the LSP server in debug mode. This is used by Kate if the LSPCLIENT_DEBUG environment var is set to 1. If this variable is set, the LSP client itself will output debug information on stdout/stderr and the commandDebug command line should try to trigger the same for the LSP server, like e.g. using -log=verbose for clangd.

rootIndicationFileNames

For the Rust rls LSP server we added the possibility to specify a list of file names that will indicate which folder is the root for the language server. Our client will search upwards for the given file names based on the file path of the document you edit. For Rust that means we first try to locate some Cargo.lock, if that failed, we do the same for Cargo.toml.

url

URL of the home page of the LSP server implementation. At the moment not used internally, later should be shown in the UI to give people hints where to find further documentation for the matching LSP server (and how to install it).

Current State

For C/C++ with clangd the experience is already good enough for day-to-day working. What is possible can be seen in one of my previous posts, video included. I and some colleagues use the master version of Kate at work for daily coding. Sometimes Kate confuses clangd during saving of files but otherwise, no larger hiccups occur.

For Rust with rls many things work, too. We now discover the root directory for it more easily thanks to hints to look for the Cargo files. We adapted the client to support the Hover message type rls emits, too.

For the other languages: Beside some initial experiments that the servers start and you get some completion/…, not much work went into that. Help is welcome to improve their configuration and our client code to get a better experience.

Just give Kate from the master branch a test drive, here is our build it how-to. We are open for feedback on kwrite-devel@kde.org or directly via patches on invent.kde.org.

Btw., if you think our how-to or other stuff on this website is lacking, patches are welcome for that, too! The complete page is available via our GitHub instance, to try changes locally, see our README.md.

Kate - Initial Rust LSP support landed!

Wed, 07 Aug 2019 21:02:00 +0200

Initial support for the rls Rust LSP server has landed in kate.git master. The matching rls issue about this can be found here.

Given I am no Rust expert, I can only verify that at least some operations seem to work for me if the Rust toolchain is setup correctly ;=)

The current experience isn’t that nice as with clangd, for example I get no symbols outline here. What is possible with clangd can be seen in one of my previous posts, video included.

Any help to improve this is welcome. The patch that landed can be viewed here, lend a hand if you know how to fix up stuff!

kate-editor.org Update

Sat, 03 Aug 2019 20:48:00 +0200

Like my personal homepage cullmann.io, I ported the kate-editor.org website to the Hugo framework.

The new website uses zero cookies (yes, no stupid cookie question) and no kind of analytic software. It should be self-contained, too. No external resources that will leak your data to e.g. Google are requested.

But more important: unlike before, the website content will be fully hosted in a git repository on KDE infrastructure.

The current intermediate location is on invent.kde.org/websites/kate-editor-org.

Before, the KDE sysadmin team just got access to a backup of the WordPress instance.

The new website contains an import of all old pages & posts. I hopefully preserved the old URLs, but there might be some minor glitches for some older posts that still need fixing.

Some pages still have broken markup, that needs some fixes, too.

But all-in-all the import of the WordPress content did work really well.

Some nice step-by-step description how to do such a port can be found in the “Moving 18 years of this personal blog from Wordpress to Hugo” post.

If you want to contribute, feel free to send me some patch or merge request ;=)

As a simple template for a new post, take a look at the sources of this one:

---
title: kate-editor.org Update
author: Christoph Cullmann
date: 2019-08-03T20:48:00+02:00
---
Like my personal homepage [cullmann.io](https://cullmann.io), I ported the [kate-editor.org](https://kate-editor.org) website to the [Hugo framework](https://gohugo.io/).
...

The date is important, no stuff in the future is visible on the real web server. You can hide stuff from publishing by adding

draft: true

to the header information. The server.sh script will still show such things on your local machine.

Kate LSP Status – July 22

Mon, 22 Jul 2019 20:16:00 +0000

After my series of LSP client posts, I got the question: What does this actually do? And why should I like this or help with it?

For the basic question: What the heck is the Language Server Protocol (LSP), I think my first post can help. Or, for more details, just head over to the official what/why/… page.

But easier than to describe why it is nice, I can just show the stuff in action. Below is a video that shows the features that at the moment work with our master branch. It is shown using the build directory of Kate itself.

To get a usable build directory, I build my stuff locally with kdesrc-build, the only extra config I have in the global section of my .kdesrc-buildrc is:

cmake-options -DCMAKE_BUILD_TYPE=RelWithDebInfo -G “Kate - Unix Makefiles” -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

This will auto generate the needed .kateproject files for the Kate project plugin and the compile_commands.json for clangd (the LSP server for C/C++ the plugin uses).

If you manually build your stuff with cmake, you can just add the

-G “Kate - Unix Makefiles” -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

parts to your cmake call. If you use ninja and not make, just use

-G “Kate - Ninja” -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

Then, let’s see what you can do, once you are in a prepared build directory and have a master version of Kate in your PATH.

I hope the quality is acceptable, that is my first try in a long time to do some screen-cast ;)

As you can see, this is already in an usable state at least for C/C++ in combination with clangd.

For details how to build Kate master with it’s plugins, please take a look at this guide.

If you want to start to hack on the plugin, you find it in the kate.git, addons/lspclient.

Feel welcome to show up on kwrite-devel@kde.org and help out! All development discussions regarding this plugin happen there.

If you are already familiar with Phabricator, post some patch directly at KDE’s Phabricator instance.

Kate LSP Status – July 21

Sun, 21 Jul 2019 13:18:00 +0000

The new LSP client by Mark Nauwelaerts keeps making nice progress.

It will not be shipped with the KDE Applications 19.08 release, but in master it is now compiled & installed per default. You only need to activate it on the plugin configuration page in Kate’s settings dialog to be able to use it.

For details how to build Kate master with it’s plugins, please take a look at this guide.

If you want to start to hack on the plugin, you find it in the kate.git, addons/lspclient.

Feel welcome to show up on kwrite-devel@kde.org and help out! All development discussions regarding this plugin happen there.

If you are already familiar with Phabricator, post some patch directly at KDE’s Phabricator instance.

What is new this week?

The most thing are internal cleanups and minor improvements.

Feature wise, the hover implementation works now more like in other editors or IDEs, you get some nice tool tip after some delay:

Never try to guess again what some auto means ;=)

There is still a lot that can be improved, e.g. a filter for the symbols outline is in work:

D22592 - port symbols view to model/view concept

To be able to later out-source some parts of the generic LSP client code to a library, if there is demand, we will aim to make the plugin be licensed under the MIT license. This should make it easier for other projects to depend of our code, if wanted.

Kate LSP Client Continued

Sun, 14 Jul 2019 13:33:00 +0000

The new LSP client by Mark Nauwelaerts made nice progress since the LSP client restart post last week.

Reminder: The plugin is not compiled per default, you can turn it on via:

cmake -DCMAKE_INSTALL_PREFIX=“your prefix” -DENABLE_LSPCLIENT=ON “kate src dir”

The code can still be found kate.git master, see lspclient in the addons directory.

What is new?

Diagnostics support: A tab in the LSP client toolview will show the diagnistics, grouped by file with links to jump to the locations. Issues will be highlighted in the editor view, too.
Find references: Find all references for some variable/function in your complete program. They are listed like the diagnostics grouped per file in an extra tab.
Improved document highlight: Highlight all occurrences of a variable/… inside the current document. Beside highlighting the reads/writes/uses, you get a jump list like for the other stuff as tab, too.

A feature I missed to show last time:

Hover support: Show more meta info about a code location, like the proper type, useful e.g. for almost-always-auto C++ programming.

We even got already two patches for the fresh plugin:

Both are aimed to improve the support of the Rust LSP server. As you can see, they got already reviewed and merged.

Feel welcome to show up on kwrite-devel@kde.org and help out! All development discussions regarding this plugin happen there.

If you are already familiar with Phabricator, post some patch directly at KDE’s Phabricator instance.

You want more LSP servers supported? You want to have feature X? You have seen some bug and want it to vanish? => Join!

Kate LSP Client Restart

Sun, 07 Jul 2019 13:10:00 +0000

Since my last post about the LSP client progress in May I didn’t work on that project at all I think.

But the good news is, somebody else did scratch that itch on his own ;=)

We have now a prototype plugin in kate.git master, see lspclient in the addons directory.

It is not compiled per default, you can turn it on via:

cmake -DCMAKE_INSTALL_PREFIX=“your prefix” -DENABLE_LSPCLIENT=ON “kate src dir”

It shares no code with my initial prototype. The author started this without knowing of my work. This might actually be not that bad, as this plugin is composed of a much smaller code base. This allows to get familiar with the code easier as with the code I copied over from Qt Creator for my initial try.

But, even nicer, it does actually work a lot better than my variant, already now!

What does work (tested with clangd and kate.git/work projects) at the moment:

Auto completion: you get the proper LSP server provided completion items
Outline view: Get an extra tool view with the symbols of your current view
Document highlight: highlight all occurrences of a variable/… inside the current view
Code navigation: jump to the definition/declaration

There is still a lot of stuff missing and this is all prototype quality. For example the document highlight implementation I added has no way to clear the highlighting at the moment beside document reload.

But given I just needed one hour to add the document highlight support, I would say the code base is easy to adjust.

=> If you have time and want a good LSP client, now you can join the fun and have direct results.

As the author was kind enough to move his work on the plugin to the KDE infrastructure, feel welcome to show up on kwrite-devel@kde.org and help out! All development discussions regarding this plugin happen there. We are happy to accept patches, too, if you are a new contributor!

Kate & C++ Developer Survey

Mon, 10 Jun 2019 20:45:00 +0000

While browsing the ISO C++ homepage I stumbled over the results PDF of the Second Annual C++ Foundation Developer Survey “Lite”.

I was astonished that Kate made it into the “Which development environments (IDEs) or editors do you use for C++ development?” results.

;=) Seems not only I use it as my normal editor for working on C++ code.

And heads up, KDevelop is there, too!

This is actually the second survey, I missed to notice the first one last year. The results PDF from last year shows Kate did show up already there.

We shouldn’t be that proud of only having less than three percent usage, but still, we are there at all. I hope we can rise here a bit in the future.

At least we work on supporting modern C++ standards in the highlighting, e.g. see the recent C++20 improvements (Phabricator + Commit). Thanks to Jonathan Poelen for the patch!

Language Server Protocol (LSP) would help, too, but my initial work is far from usable, help appreciated. Beside a hacked “goto definition” nothing works at the moment (and it is hardcoded to just start clangd, no other LSP server).

KTextEditor/Kate Bugs – Scratch Your Own Itch

Sun, 26 May 2019 12:25:00 +0000

Two days ago I mentioned here that the bug report count of KTextEditor and Kate has risen to some not that manageable amount.

For developers that report a bugs or wish, the best way to really get it solved is to scratch your own itch and provide some patch.

I know this is not feasible for all bug reporters, as not all are developers nor will even the developers all have either time nor perhaps the right skill set to tackle the issue on their own.

But if you have the time and you are at least a bit familiar with C++/Qt, you should give it a try.

We can help you to get your patch done, that is much easier for e.g. myself than to motivate me to work on a bug or wish that doesn’t concern my normal workflow or lie within my skill set.

For example we have a lot of issues with left-to-right text rendering or related to languages that use complex Unicode surrogates. Given I have zero knowledge of any language using this my motivation to dig into these issues is small (and I will more likely break more things than fix them).

The same holds for issues in our Vi mode. I don’t use this mode myself nor do I really know how Vi commands shall behave in real life. Therefore any fix or enhancement there is beyond me.

A good example for such a “Scratch Your Own Itch” approach is bug 407910.

It is a small request, to have some action/shortcut to reset the font size to the default one. We have since years some zoom in/out actions/shortcuts but nothing to go back to the configured one.

I rarely use the zoom stuff, perhaps once in a month, if I want to show something to a colleague on my screen or projector and it is really not readable with my normal font size. Therefore my motivation to invest any work into yet an other action I will not use regularly is small.

But, in this case, the reporter had the time to invest a bit work into this.

He provided a patch via our KDE Phabricator - D21412.

We needed some iterations to get the patch into a usable shape in the bug report and in Phabricator, but thanks to the persistence of the reporter, it got now pushed to our repository.

If nobody would have stepped up to provide at least some initial patch for this, such a request for sure would have rotted again in our bug database.

This is not the first time such a nice thing happened, this is just a recent example how such things can work out.

Therefore, if you report something and are capable of given it a try on your own, please do so!

Perhaps even some of the existing bugs or wishes are stuff you want to take care of yourself because they concern you!

I think not a lot motivates your more to do something than an issue you have with a tool for your workflow. At least for me that was the reason to at all start the development of Kate (I missed a MDI variant of KWrite) and join the work on stuff like KTextEditor.

KTextEditor/Kate Bugs – Help Appreciated

Fri, 24 May 2019 14:20:00 +0000

The bug report count of KTextEditor (implementing the editing part used in Kate/KWrite/KDevelop/Kile/…) and Kate itself reached again some value over 200.

If you have time and need an itch to scratch, any help to tackle the currently open bugs would be highly appreciated.

The full list can be found with this bugs.kde.org query.

Easy things anybody with a bit time could do would be:

check if the bug still is there with current master builds, if not, close it it
check if it is the duplicate of a similar still open bug, if yes, mark it as duplicate

Beside that, patches for any of the existing issues are very welcome.

I think the best guide how to setup some development environment is on our KDE Community Wiki. I myself use a kdesrc-build environment like described there, too.

Patches can be submitted for an review via our KDE Phabricator.

If it is just a small change and you don’t want to spend time on Phabricator, attaching a git diff versus current master to the bug is ok, too. Best mark the bug with a [PATCH] prefix in the subject.

The team working on the code is small, therefore please be a bit patient if you wait for reactions. I hope we have improved our reaction time in the last months but we still are lacking in that respect.

Kate LSP Client Progress

Sun, 12 May 2019 21:54:00 +0000

The Kate lsp branch contains now the infrastructure as used by Qt Creator. In addition, clangd is now somehow started in a working state for the first project opened inside Kate.

For example, if you use the CMake Kate project generator and you compile Kate from the “lsp” branch, clangd should pick up the compile_commands.json for a CMake generated Kate project.

;=) Unfortunately not much more than starting and informing clangd about the open workspaces (for the first opened project) works ATM.

If you press ALT-1 over some identifier, you will get some debug output on the console about found links, like below:

qtc.languageclient.parse: content: “{“id”:“{812e04c6-2bca-42e3-a632-d616fdc2f7d4}“,“jsonrpc”:“2.0“,“result”:[{“range”:{“end”:{“character”:20,“line”:67},“start”:{“character”:6,“line”:67}},“uri”:“file:///local/cullmann/kde/src/kate/kate/katemainwindow.h“}]}”

The current ALT-1 handling is a big hack, as then one just adds the current document and triggers the GotoDefinitionRequest. A proper implementation tracks the opened/closed documented of the editor.

But at least in principle Kate is now able to start some language server processes and talk a bit with them, all thanks to the nice code borrowed from Qt Creator.

:=) As my spare time is limited, any help in bringing the branch up-to-speed is highly welcome, just drop us a mail to kwrite-devel@kde.org or mail me in private (cullmann@kde.org). A working LSP integration will help to make Kate more attractive for programmers of many languages.

Kate Language Server Protocol Client

Sun, 28 Apr 2019 18:36:00 +0000

The Language Server Protocol (LSP) allows the integration of stuff like code completion, jump to definition, symbol search and more into an application without manual re-implementation for each language one wants to support. LSP doesn’t fully allow an integration like KDevelop or Qt Creator do with the libclang based tooling aimed for C/C++ but on the other side offers the possibility to interface with plenty of languages without a large effort on the client side.

If one takes a look at some current LSP clients list, a lot of editors and IDEs have joined the LSP family in the last years.

In the past I was always scared away to start implementing this in Kate, as no readily available library was around to do the low-level work for the client. Whereas you get some reference stuff for the JSON based protocol for JavaScript and such, for Qt nothing was around.

Fortunately Qt Creator started to implement an LSP client beginning with the 4.8 release.

Based on this code, I started now to get this into the Kate project plugin. At the moment not much more has happened then some initial import of the Qt Creator LSP infrastructure code into the Kate lsp branch.

If I get this working (help is welcome!), any improvements will be submitted back to the Qt Creator implementation. If it really starts to work well in Kate, one might think about some better code sharing in the long term. But before such plans, first at least some basic things must work for some initial language server like clangd.

Qt Creator 4.9 uses KSyntaxHighlighting

Tue, 16 Apr 2019 18:45:00 +0000

As you can read in the official Creator 4.9.0 release announcement, Qt Creator now uses the KSyntaxHighlighting Framework for providing the generic highlighting.

This is a nice step for the wider adoption of this MIT licensed part of the KDE Frameworks.

And this is not just an one-way consumption of our work.

The framework got actively patches back that make it more usable for other consumers, too, like Kate ;=)

If you want concrete examples, take a look at:

D18982: prevent assertion in regex load
D18996: Fix building with namespaced Qt
D18997: Add functions returning all definitions for a mimetype or file name
D19200: Return sorted definitions for file names and mime types
D19215: Install DefinitionDownloader header

I hope this cooperation will continue in the future. I thank the people working on Qt Creator that made this integration possible. I hope the initial effort will pay of with less code for them to maintain on their own and more improvements of the framework for all users.

Removing Files from Git History

Mon, 15 Apr 2019 18:00:00 +0000

Today I did run again into an old problem: You need to archive a lot small and large files inside a single Git repository and you have no support for Git LFS available. You did this several year and now you ended up in a state where cloning and working with the repository is unbearable slow.

What now? Last time I did run into that, I archived the overfull repository to some “rest in peace” space and used git filter-branch to filter out no longer needed and too large objects from a repository copy that then will replace the old one for daily use.

There are a lot of guides available how to use git filter-branch for that. All variants I ever used were complex to do and did take very long. Especially if you need several tries to get a sane set of stuff you want to remove to gain enough space savings.

This time, I searched once more and stumbled on the BFG Repo-Cleaner. And yes, it does what it promises on the web site and it seems to be trusted enough to be advertised by e.g. GitHub, too.

Just following the steps described on their landing page allows to shrink your stuff nicely and without a lot of round-trip time.

If you still are just in the “experimenting” phase to see which space decrease one can archive with which file size filter (or which files you want to purge by removing them from master before running the tool), I recommend to swap the step

git reflog expire –expire=now –all && git gc –prune=now –aggressive

with just

git reflog expire –expire=now –all && git gc –prune=now

to not wait potential hours for the aggressive GC. For me that was good enough to get some estimate of the later size for my experiments before I settled to some final settings and did the real run.

And as always, if you touch your Git history: Do that only if you really need to, keep backups, check carefully that afterwards the repository is in some sensible state (git fsck --strict is your friend) and inform all people using that repository that they will need to do a full new clone.

Kate History – KDE 4 Porting

Fri, 12 Apr 2019 21:50:00 +0000

During my web site upgrade, I reviewed the old stuff I had hosted on my long gone web sites but still archived here locally. An interesting thing I stumbled on are the KDE 3 -> 4 porting screenshots of Kate I saved in 2005.

They actually show pretty nicely how far we have gone since 2005 with our development stack.

The KDE 3 -> 4 transition was a large hassle. It did take weeks of work just to get Kate back into an usable state.

We first started with some trivial KTextEditor container (a mini KWrite) for the porting to get KTextEditor at all doing something. That started out with something that even had no menu or toolbars working:

This evolved after two days into a kind of working KWrite port (icons still randomly missing):

After the KTextEditor part did work “reasonable”, we started with Kate:

And ended up with an initial ported prototype three days later:

And after that a long time of actual polishing for KDE 4.0 did start. Kate was actually one of the first ported applications during the KDE 3 -> 4 transition.

The KDE 4 -> KF5 transition was much nicer, even thought the Frameworks split did cost a lot of time and resources. But the actual changes to the application code bases were not that radical.

And where did we end up with this ~14 years later? Actually, just here:

It is still recognizable the same application, thought I hope some progress is visible :=)

Web-Server Transition

Mon, 08 Apr 2019 20:45:00 +0000

Several years the kate-editor.org & cullmann.io pages got hosted on a Hetzner root server. To reduce costs and switch away from old hardware they got now moved to a OpenVZ based virtual server at Host Europe.

On both servers CentOS 7.x is running, it did always provide a stable foundation of the web services.

As with any server move in the past, I always need to search how to best move the data/config from one server to the other. To document this for me and others, here the quick way to move the basic things needed for web services using just plain Apache & MariaDB.

The following steps assume you have installed the same packages on both machines and the new machine is allowed to ssh as root to the old one. If you have non-system users, you should create them with the same ids as on the old server.

For the following shell commands, the old server address is $SERV and the MariaDB root password is $PASS on both machines. Best use the raw IP as address if you are in parallel updating your DNS entries to avoid confusion (and wrong syncs).

Attention: Wrong syncing of stuff can have disastrous consequences! Check all commands again before executing them, don’t trust random people like me without verification!

sync your data, assuming it is in /home and /srv/(ftp/www)

rsync –delete -av root@$SERV:/home/ /home
rsync –delete -av root@$SERV:/srv/ftp /srv
rsync –delete -av root@$SERV:/srv/www /srv

transfer your databases

ssh root@$SERV “mysqldump -u root -p$PASS –all-databases > /root/db.sql”
scp root@$SERV:/root/db.sql /root/
mysql -u root -p$PASS < /root/db.sql

sync configs (you might need more, this is just apache & vsftp)

rsync –delete -av root@$SERV:/etc/httpd /etc
rsync –delete -av root@$SERV:/etc/letsencrypt /etc
rsync –delete -av root@$SERV:/etc/vsftpd /etc

get crontabs over for later re-use, store them in the root home

rsync –delete -av root@$SERV:/var/spool/cron /root

Now all things should be there and after some service restarts e.g. WordPress powered pages should be up-and-running again.

I hope this short how-to helps others and allows me to avoid searching stuff in the future once again from scratch.

Privacy and Hugo Themes

Sun, 07 Apr 2019 15:10:00 +0000

I use the “Hugo Coder” theme for this page. After creating the privacy page (Impressum), I did take a closer look at the generated HTML code to confirm I didn’t miss to state things there. I thought, given Hugo generates plain static HTML pages, I would be on the safe side. But unfortunately, the theme I use includes some external resources, like the Google web fonts… I now patched that out in my fork of the theme and provide local copies on my own server.

Hugo Extended on CentOS 7

Sat, 06 Apr 2019 20:55:00 +0000

After first using the Hermit theme, I moved to the Hugo Coder theme to have a nicer front page and menu at the top. Unfortunately that needs Hugo in the “extended” version. The binary one can download on https://github.com/gohugoio/hugo/releases doesn’t run on CentOS 7, unlike the normal variant you get there (too new libstdc++ needed). One has to recompile it to get that working. To make it easier for others, to do so, just:

New Website

Sat, 06 Apr 2019 16:00:00 +0000

After several years of failing to update my personal WordPress page, I restarted my website with the Hugo framework. The new website uses zero cookies (yes, no stupid cookie question) and no kind of analytic software. I hope my Impressum is done well enough to avoid any legal issues. At the moment the website is still very empty, I hope to fill in more content about my open source projects and academic stuff in the near future.

MIT licensed KSyntaxHighlighting usage

Sun, 21 Oct 2018 10:52:52 +0000

With the KDE Frameworks 5.50 release, the KSyntaxHighlighting framework was re-licensed to the MIT license.

This re-licensing only covers the actual code in the library and the bundled themes but not all of the syntax highlighting definition data files.

One of the main motivation points was to get QtCreator to use this, if possible, instead of their own implementation of the Kate highlighting they needed to create in the past due to the incompatible licensing of KatePart at that time (and the impossibility to do a quick split/re-licensing of the parts in question).

We talked about that possibility on Akademy this year and it seems, that if time permits, this will be picked up by the QtCreator team.

The current state allows the use of this tier 1 framework by projects like Qt(Creator), that require non-copyleft licenses for bundled 3rd-party source components, but in addition also for commercial applications that do static linking against a commercial Qt version.

Whereas at the moment, the QtCreator integration has not yet started (at least I am not aware of any work for that), a first commercial consumer already exists.

The company AbsInt I work at does develop both binary and source level analysis tools. Our GUI is Qt based, statically linked with a commercial license.

Before the current release, our GUI used a handcrafted highlighter for our own annotation languages and the programming languages we support (e.g. C and C++). After the release of the 5.50 MIT licensed KSyntaxHighlighting, this was changed to use the framework through its QSyntaxHighlighter implementation.

The framework was easy to integrate into our static build process. To make it possible to be used without violating licensing for the bundled highlighting definitions that are not MIT and ensure no other installed instances of the framework will mess up the shipped highlighting definitions, the following two changes were contributed upstream.

A CMake switch to disable the bundling of the syntax definition data files into the library. This avoids mixing non-MIT files into the created static library, which then only contains MIT licensed code and data. One can then let people either download the definitions or ship some as extra data files with an extra licensing.

cmake -DQRC_SYNTAX=OFF

A CMake switch to disable the lookup for syntax and theme definitions in the normal locations via QStandardPaths. This allows the user of the library to only load definitions from search paths specified manually. No definitions that e.g. are installed by users for Kate or other applications using the framework will mess up your lookup, which is really important if you rely on exactly your files to be used.

cmake -DNO_STANDARD_PATHS=ON

These two options might be interesting for the QtCreator people, too. If they need additional configurability, I am sure we can find ways to integrate that.

After the transition, my colleagues compared the speed of the old implementation versus the new generic highlighting engine. At first, they were not that impressed, which did lead to several performance improvements to be implemented and up-streamed.

All directly visible bottle-necks got perf’d away. The most CPU consumption now more or less boils down to the costs of the used regular expressions via QRegularExpression. Same for the allocations, we reduced them by taking a look on the heaptrack profiles for the KSyntaxHighlighting benchmark suite.

But as always, performance work is never done, if you have time, you can take a look by profiling the “highlighter_benchmark” autotest, that applies the shipped highlightings to the test files we have in the repository.

There is no divergence in the local git clone at AbsInt at the moment, nor is there any plan to have that in the future. Both sides profit from up-streaming the changes. Other consumers of the framework get improvements and AbsInt doesn’t need to maintain a patched version.

Starting with the 18.10 release of our tools, all highlighting is handled by the framework, no more error-prone handcrafting of QSyntaxHighlighter implementations.

Thanks to all people that helped making this possible ;=)

I hope more projects/companies will pick up the use of this pure qt-dependent tier 1 framework in the future and up-stream their improvements. Be welcome.

Support KDE via AmazonSmile

Sun, 14 Oct 2018 20:02:50 +0000

For quite some time, the KDE e.V. – KDE’s non-profit organization – is listed in the AmazonSmile program. On the AmazonSmile website it says:

AmazonSmile is a website operated by Amazon that lets customers enjoy the same wide selection of products, […]. The difference is that when customers shop on AmazonSmile (smile.amazon.com), the AmazonSmile Foundation will donate 0.5% of the price of eligible purchases to the charitable organizations selected by customers.

In other words, if you do a lot of shopping on Amazon anyways, make sure to start shopping via smile.amazon.de and choose the “KDE e.V.” as organization. This way you financially support the KDE e.V., even without having to pay more. I am posting this here since I know many people who buy things on Amazon several times a week. Feel free to spread the word & happy shopping :-)

PS: This is not supposed to be advertisement for Amazon. You can also donate to the KDE e.V. directly.

PPS: It seems the KDE e.V. is only available on German Amazon.

Who is Hiring?

Sun, 14 Oct 2018 18:08:59 +0000

Just as quick info: For some time, there is a sticky thread on r/cpp about who is hiring C++ developers. This thread gets cleaned quarterly, so all the open jobs listed there are likely still open. The same was just started on reddit for r/Qt5: Who’s Hiring Qt Devs – Q4 2018: So if you are looking for either C++ or Qt jobs, this is a good place to have a look at from time to time. When I just looked for r/Qt5, the list was still empty, but this hopefully changes soon, given that the post was added just some hours ago. :-)

Kate projects and out-of-source builds

Sun, 19 Aug 2018 20:39:46 +0000

During Akademy I once more was a bit disappointed how bad the project plugin of Kate can cope with out-of-source builds.

At work, we use in-source-builds, as we normally only build in one configuration and have no issues with left-overs in the source directories locally. For this use-case, the project plugin works really well. You have your project local terminal view and that allows you all normal things you need during work, e.g. building + using the git command line client for the version control work.

On the other side, with out-of-source builds, that no longer is that nice to use. Either you use the .kateproject generated by the “Kate – Ninja” or “Kate – Unix Makefiles” CMake generators, then your terminal defaults to the build directory, which allows building just fine, but no version control stuff, or you use the .kateproject (or auto-project creation) in the source directory, which doesn’t allow you to build nicely inside the terminal prompt of Kate. There are workaround for that, like having shell magic to switch between source and build directory with ease, but that all feels a bit unnatural.

Therefore, I added today a very simple “fix” for the issue: If you have a .kateproject that has a different base directory (the toplevel “directory” entry) than the directory the .kateproject file is located in, you will get two terminal tabs in the project view. One is the “old one” that has the directory of the .kateproject as base, the other has the base directory of the project as base.

With these two views, you can easily switch between build/source directory without any hassle or extra setup for any properly setup .kateproject as generated by CMake.

I hope this improves the usability of the project plugin for the normal setup of out-of-source builds with CMake. If this sparked your interest: any further improvement ideas are welcome, best as patches submitted on phabricator.kde.org.

I think this small change is something that shows how many open source contributions work: You have some itch to scratch and you share your solution to help others that have a similar issue.

If you look at the open bugs & wishes for Kate/KWrite/KTexteditor/… you will see that there are still a lot things that need some scratching. It might look like the developers don’t care for the issues of their users, but that is not correct. We just don’t have the time to scratch all these itches (nor are all that easy solvable). Sometimes we unfortunately did even lack time or motivation to do proper reviews for some proposed solutions, I hope we improve on that in the future. Any volunteers that help us taking care are always welcome. The addition of the inline notes interface is a nice example. Michal Srb provided an initial solution for his own needs to us and sparked some new development with that.

Kate gains Support for Inline Notes

Fri, 17 Aug 2018 20:48:13 +0000

Thanks to Michal Srb and Sven Brauch for pioneering the work an a new KTextEditor interface that allows applications like Kate, KDevelop, etc. to display inline notes in a text document. As demo, we quickly prototyped one application to display colors in CSS documents:

Clicking on the color rectangle will launch the color chooser:

Choosing a color and clicking OK finally adapts the color in the CSS document:

The code for this is just a demo and looks as follows:

class NoteProvider : public KTextEditor::InlineNoteProvider {
public:
QVector<int> inlineNotes(int line) const override
{
if (line == 1) return { 29 };
if (line == 11) return { 29 };
if (line == 12) return { 29 };
if (line == 13) return { 29 };
return {};
}
QSize inlineNoteSize(const KTextEditor::InlineNote& note) const override
{
return QSize(note.lineHeight(), note.lineHeight());
}
void paintInlineNote(const KTextEditor::InlineNote& note, QPainter& painter) const override
{
const auto line = note.position().line();
const auto color = QColor(note.view()->document()->text({line, 22, line, 29}));
painter.setPen(color);
painter.setBrush(color.lighter(150));
painter.drawRoundedRect(1, 1, note.width() - 2, note.lineHeight() - 2, 2, 2);
}
void inlineNoteActivated(const KTextEditor::InlineNote& note, Qt::MouseButtons buttons, const QPoint& globalPos) override
{
const int line = note.position().line();
const auto oldColor = QColor(note.view()->document()->text({line, 22, line, 29}));
const auto newColor = QColorDialog::getColor(oldColor);
note.view()->document()->replaceText({line, 22, line, 29}, newColor.name(QColor::HexRgb));
}
void inlineNoteFocusInEvent(const KTextEditor::InlineNote& note, const QPoint& globalPos) override
{} // unused in this example
void inlineNoteFocusOutEvent(const KTextEditor::InlineNote& note) override
{} // unused in this example
void inlineNoteMouseMoveEvent(const KTextEditor::InlineNote& note, const QPoint& globalPos) override
{} // unused in this example
};
// later in code:
auto provider = new NoteProvider();
view->registerInlineNoteProvider(provider);
// final cleanup
view->unregisterInlineNoteProvider(provider);

As you can see, it’s actually not much code at all: We have to derive a class from KTextEditor::InlineNoteProvider, and then register an instance of our Note Provider in the KTextEditor::View. In a next step, we implement the inlineNotes(), inlineNoteSize(), and the paintInlineNote() functions to get basic visual drawing at the desired location. The above code is just a tech-demo, since it uses hard-coded lines and color positions. Additionally, one can also track mouse events (unused in the example above). On mouse click, we open the QColorDialog to let the user choose a new color.

To give more examples of what’s possible, the initial Phabricator review requests contained many other interesting examples (the examples were really implemented). From review request D12662:

Kate showing additional information for loops and structs.

Or a KDevelop addition that adds a lot of meta information on the current code if desired:

KDevelop showing detailed code meta information

We believe this addition to the KTextEditor component has a lot of potential for nice features and plugins. Feel free to use this interfaces starting with KDE Frameworks 5.50. Happy coding! :-)

A big thanks also goes to this year’s Akademy organizers. Thanks to this event, we could meet up in person and also finalize the InlineNoteInterface, InlineNoteProvider, and InlineNote class to make it ready for public release. This again shows the importance of the yearly KDE conferences since it enables us to significantly push things forward.

Akademy 2018 Wrap-Up

Fri, 17 Aug 2018 15:06:46 +0000

The Akademy 2018 ends today.

Like each Akademy I attended, it was an interesting experience. As the location switches around each year, so does the set of people attending change every year, too.

That is actually nice, as you get always to meet some of your old “friends” but additionally new members of the KDE community. I think this kind of “conferences” or “meetings” are an important way to get some more cohesion in the community, which is sometimes a bit lacking between people only meeting online via mail/…

Beside the presentation tracks and the e.V. meeting, several of the BoFs did spark my interest.

In the KDevelop BoF, Sven talked about what could be done to give the current KDevelop project a bit more focus on the parts it does well to polish them more for a better user experience. The idea is that if you get KDevelop shining even more in the areas it is good at and perhaps cut off some parts that are really given bad impressions, one might attract more people to both use it and contribute. It is still to be discussed if this idea is shared with the other KDevelop contributors.

In the kdesrc-build BoF Michael talked about the current state and collected pain points from the audience and potential future extensions. For example an API to allow to build a light-weight GUI tooling around kdesrc-build to ease the entry to the KDE development was one topic of interest.

Between the conference/BoF/socializing parts of Akademy, I got plenty of time to finally work again on some KTextEditor/Kate related tasks.

With help of Dominik and Volker I got to integrate the KSyntaxHighlighting framework and we even got at least some initial contact with the QtCreator team about the topic of integrating this framework to replace their own implementation of the Kate syntax definition handling. If you experience any issues with the highlighting or folding in the master branch, please file a bug or even better provide some patch on phabricator.

In addition some small KTextEditor and Kate bugs got either solved or at least started to be worked on again. Help with any bug fixing is always welcome!

As small but perhaps for users important step was to actually link to the new and shiny Windows installers that the Binary Factory for KDE produces. Thanks to the team behind that, once more. Hopefully that will lead to more users and developers for Kate on Windows.

Thanks to the organizers to make this Akademy happen and all people that volunteered! Great job! The sponsors are highly appreciated for their contributions, too.

So, thanks for all the fish (or Krapfen), lets see how Akademy next year will be :=)

Akademy & Binary Factory

Thu, 16 Aug 2018 14:11:09 +0000

During Akademy it was brought to my (and the other Kate developers) attention, that we should take a closer look on the Binary Factory for KDE. There were some blogs about the Binary Factory in the past but we somehow never really linked it on our homepage as potential source for up-to-date installers for the different operating systems. I feel a bit sorry for neglecting that area in the past year.

Therefore, as we have now some time during Akademy together as team, we did take a look at the current state of the installers there for Windows and macOS.

The Windows installer is working fine. Kåre’s manually created installers are better optimized for size by stripping out things not that commonly used, on the other side the Binary Factory installers bundle more stuff like all translations/dictionaries that might be interesting for some people, too. One other thing that might be fine tuned is the used frameworks. For example the KActivities is not useful for Kate on Windows and we normally disable that for our own build, at the moment the factory still includes that (as it is an optional dependency). If we fine tune that a bit more in the future, I think we can close the gap between the hand-tuned installer and the autogenerated one even more. In other parts like the KHotNewStuff integration the current factory installer even provides a better experience than our last published own one. And last but not least, the binary factory creates an installer every night for the stable and the development version, so we get up-to-date installers with no manual work.

The macOS installer is on-par with what I did manually a year ago (but than gave up due to loss of interest). Therefore we now link the nightly build for that on our homepage as primary preview build. The state is still not that good, but that is not a fault of the installer creation. The macOS port just lacks manpower, as myself has no longer that much interest in improving it and it still is in a “usable” but non-polished state that will still crash in a few situations, which makes using it not that nice. Any help there would be appreciated.

As a conclusion I must say, I am personally impressed how well the Binary Factory installers work. They are a real big step towards having people use up-to-date versions of our tools on operating systems other than the usual unices. Thanks to the team behind that and all others that contributed, including our sysadmins that keep all the stuff running the whole time! I hope we make good use of that infrastructure in the future. Thanks to Hannah, Kevin, Ben and all others that contribute to this effort! And thanks to Kåre and everybody else taking care of issues on Windows or macOS.

The download page is now updated to provide links to both the latest successful Kate release and nightly builds of the Binary Factory.

Porting KTextEditor to KSyntaxHighlighting => Done :=)

Tue, 14 Aug 2018 16:05:22 +0000

During Akademy there was finally enough time to finalize the porting of KTextEditor to KSyntaxHighlighting.

Thanks to the help of Dominik and Volker, the needed extensions to the KSyntaxHighlighting framework were done in no time ;=)

Thanks for that!

The branch for the integration was merged to master yesterday, unit tests look OK and I am using that state now for my normal coding work. Beside minor glitches that should now be corrected, no issues came up until now.

But as with all changes, for sure some regressions slipped in.

If you notice strange behavior of the highlighting in master, please report the issues on bugs.kde.org or on our mailing list (or even better: provide a fix on phabricator).

For sure there are potential further cleanups and now that we have only one implementation of the highlighting infrastructure, we will be able to move forward with extensions of it much easier.

We contacted the QtCreator people, to see if we might be able to share a common implementation, as they have an own one at the moment. Hopefully that works out in a nice way and our KDE syntax-highlighting framework gets an even broader user base!

Downloading Kate Highlighting Files

Tue, 14 Aug 2018 12:58:03 +0000

Starting with the KDE Frameworks 5.50 release we decided to remove the capability in Kate/KTextEditor to download / update syntax highlighting files from the Kate homepage.

The reasons for this are as follows:

The KTextEditor framework is released once a month, meaning that users who use latest KDE software usually anyways have the most recent versions. Other users who do not follow the latest development releases (like your mom) are likely not the target audience for downloading highlighting files.
There are technical problems with only updating certain highlighting files, since it can lead to an inconsistent state when one highlighting file needs another one that was not updated or does not exist, or also if a highlighting file needs a certain indenter that does not yet exist or contains bugs.
We have a nice small cleanup in the UI, since we have now one button less.

Git changes:

Contributing new Highlighting Files

By the way, we are always very happy to accept new highlighting files under MIT license. Documentation about how to write a syntax highlighting file can be found in the Kate Handbook. When you are done, please contribute your highlighting file in phabricator for the ‘syntax-highlighting’ framework (click Code Review, then on the very top right “Create Diff”). You can find nice instructions also on the Community wiki.

Porting KTextEditor to KSyntaxHighlighting – Folding

Sat, 04 Aug 2018 15:37:44 +0000

After fixing some first porting bugs to KSyntaxHighlighting, code folding (non-indentation based) is back working, too.

There is a still a lot to do (and e.g. the syntax colors are still kind of randomized), but already all KTextEditor original highlighting code is gone without ending up in an unusable state.

Porting KTextEditor to KSyntaxHighlighting

Tue, 31 Jul 2018 19:52:28 +0000

After several years, the time has come that KTextEditor finally starts to use more of KSyntaxHighlighting than just the syntax definitions resources.

At the moment, we still do everything on our own (parsing the xml, doing the highlighting, …) and only use the XML files bundled inside the KSyntaxHighlighting library as “code sharing”.

I started a “syntax-highlighting” branch in ktexteditor.git to change that. Dominik helped out by starting to add missing API to KSyntaxHighlighting that will ease the porting.

The first step will be: Having full working highlighting without color scheme or configuration support inside the branch.

If that is done, we will take a look at the scheme/configuration stuff.

The current state only handles the highlighting, folding is ATM out of order. It speaks for the quality of Volker’s KSyntaxHighlighting implementation that with minimal additions only 1-2 hours of work did lead to a “usable” result.

=> obligatory screenshot

Beside the missing folding markers, it doesn’t look that bad, or?

I hope we can work on that during Akademy, too, to finally move on and not keep all things duplicated just because we got no time to work on it.

Btw., thanks again to Volker for the work on the framework!

Going to Akademy, too ;)

Tue, 31 Jul 2018 19:43:11 +0000

Like Dominik, I will be around the whole Akademy, too.

Looking forward to see new and old friends, lets have a productive week there!

Going to Akademy

Sat, 28 Jul 2018 10:33:45 +0000

Of course, I am going to Akademy. I’ll be there from Friday 10th to Saturday 18th. See you! :-)

Improving Syntax Highlighting Files

Sat, 10 Mar 2018 20:54:47 +0000

When building the KSyntaxHighlighting framework, the syntax highlighting xml files are compiled into the KSyntaxHighlighting library. In order to do so, we have a small little helper program that generates an index of all xml files. This indexer also validates the xml files against the XML Schema, and performs some more sanity checks.

Review request D10621 tries to extend the indexer even further and suggest optimizations for our highlighting files. For instance, the rule

<AnyChar context="#stay" String="&space;" attribute="Normal Text" />

should be replaced by the faster rule

<DetectChar context="#stay" char="&space;" attribute="Normal Text" />

Similarly, the rule

<RegExpr attribute="Normal" context="conditionNot" String="\bnot\b" lookAhead="true" insensitive="true"/>

should be replaced by the much faster rule

<WordDetect attribute="Normal" context="conditionNot" String="not" lookAhead="true" insensitive="true"/>

The proposed patch above generates more than 1500 suggestions to improve our highlighting files, so a lot of work. Help would be very much appreciated. So if you would like to contribute to KDE and are looking for simple work to do, then feel free to get started by sending improved highlighting files to us via phabricator.kde.org (click “Code Review” on the left, and then “Create Diff” on the top right – or even better use arc to automatically manage your patches). Oh, and please increase the version number in the xml files whenever you provide a patch :-)

Article about cmake

Wed, 21 Feb 2018 22:21:19 +0000

Just in case someone is interested: two days ago a very good article about cmake popped up, called It’s Time to do CMake Right. There also is a discussion about it on reddit/r/cpp. happy reading :)

Rendering issues and the power of open source

Sat, 10 Feb 2018 20:59:29 +0000

After a long time of constant distraction by my daily work, I finally found again a bit time to take care of KTextEditor/Kate/… issues.

One thing that really started to be an itch I wanted to scratch is some rendering fault that occur with ‘special’ font sizes.

Given I wanted to do again a bit work on the macOS port, I was really annoyed that on my screen the only application with text rendering issues was “my” one :/

I assume a lot of people have sometimes seen stuff like that in KTextEditor based applications like Kate or KDevelop:

These small white lines really stick out like a sore thumb :( It looked like some off-by-one rounding issue, surely one should be able to find it…

I tried to track down where in our rendering in KTextEditor we do create these artifacts, but I never found any place that looks like a possible cause.

After a bit more tinkering it became obvious that actually it would be more or less impossible for the KTextEditor code to mess up the painting in such a way, as we normally draw one line more or less as one thing using QTextLayout that handles the painting of the selection background, too.

Using QtCreator as an non-KTextEditor based application that uses the Qt layouting & rendering it was possible to get similar effects on macOS (or X11):

:=) Good thing that Qt is open source. A quick look into the qtextlayout.cpp and a qt5 compile later, I was able to trace the issue down to some qFloor calls for painting the selections.

I hope my patch is correct and will be accepted (QTBUG-66036 / Gerrit 219804) or at least helps others to do the correct fix.

At least for the syntaxhighlighter example shipped with Qt I was able to reproduce the issue before my patch but not afterwards.

Would Qt not be open-source, I would have been at the end of the line after seeing no “error” in our codebase in KTextEditor.

With Qt as some open-source project, it is a completely different story.

Besides, the Qt documentation for “how to build it” and “how to contribute” on the Qt Wiki are well enough to understand that I was able to nicely compile the stuff from scratch on macOS and provide the Gerrit review request in no time.

Fancy Terminal Prompt

Mon, 08 Jan 2018 20:55:15 +0000

By default, the terminal looks as follows on my Linux distribution:

However, if you are working a lot on the terminal, there are a lot of scripts and tricks available in the net that improve the information displayed in the terminal in many ways. For instance, since many many years, I have the following at the end of my ~/.bashrc:

# use a fancy prompt
PS1="\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\W\[\033[00m\]"
PS1="$PS1 \`if [ \$? = 0 ]; then echo -e '\[\033[01;32m\]:-)';"
PS1="$PS1 else echo -e '\[\033[01;31m\]:-(' \$?; fi\`\[\033[00m\]"
PS1="$PS1 \$(__git_ps1 \"(%s)\") \$ "

Once you open a new terminal, then the appearance is as follows:

As you can see, now I have nice colors: The hostname is green, the folder is blue, the return value of the last executed command is a green :-) in case of success (exit code = 0), and a red :-( in case of errors (exit code != 0). In addition, the last part shows the current git branch (master). Showing the git branch is very useful especially if you are using arc a lot and work with many branches.

I am sure there are many more cool additions to the terminal. If you have some nice additions, please share – maybe also as a new blog?

Tracking KDE Development

Sun, 31 Dec 2017 18:00:27 +0000

A central place to track KDE development is the kde-commits@kde.org mailing list. To this mailing list, all code changes are sent, containing the log message as well as the diff that quickly shows what really changed. In the early days of KDE development, the changes were maintained by the CVS version control system. Later, this was changed to subversion. Nowadays, KDE mostly uses git, but some svn modules are still around.

Since KDE is developed by many contributors, the kde-commits@kde.org mailing list obviously has high traffic, ranging from ~100 mails up to 400 mails a day (see marc.info for statistics).

Many developers are subscribed to this mailing list. However, due to high traffic and possibly many changes that are unrelated to your pet project, a commit filter was invented, which was available on https://commitfilter.kde.org for a long time. Essentially, this commit filter allowed to easily setup filters in terms of regular expressions, such that you’d only get mails for changes you are interested in. While this was convenient, the commit filter also had its drawbacks: Instead of getting all KDE changes, you missed a lot possibly interesting conversations: Since post-code reviews are often done by others through email conversation directly on the code changes.

Nowadays, the commit filter is not available anymore, mostly for security reasons since it was unmaintained for a long time.

What does that mean? I’m subscribed to kde-commits@kde.org again, getting all changes. In fact, I am enjoying skimming quickly through the changes, even doing a code review here and there.

I recommend every KDE contributor to subscribe to this mailing list, since it is very interesting to see which projects are actively developed and who really contributes to KDE in person. Even better, sometimes there are discussions on this list, helping you to learn things you didn’t know. Of course, nowadays we also have many code reviews on phabricator, but still the commit mailing list is a nice addon to track KDE development.

Syntax Highlighting Checker

Sun, 03 Dec 2017 17:20:47 +0000

The KTextEditor Framework uses the syntax highlighting files provided by the KSyntaxHighlighting Framework since the KDE Frameworks release 5.28.

The KSyntaxHighlighting Framework implements Kate’s highlighting system and meanwhile is used in quite some applications (e.g. LabPlot, KDE PIM). What is quite nice is that the KSyntaxHighlighting framework is nicely unit tested. And while we do not have tests for all highlighting files, we still provide some quality assurance through a compile time checker.

How does it work? Well – in former times, Kate loaded all highlighting .xml files from disk (through the KTextEditor framework). This lead to a slow startup over time, since there are >250 .xml files that needed a stat system call at startup.

With the KSyntaxHighlighting Framework, all these xml files are compiled into a Qt resource (qrc file), that then is included into the KSyntaxHighlighting library.

In order to create the Qt resource file, we need to iterate over all available xml files anyways. So what happens is that we take this opportunity and also scan the highlighting files for common mistakes.

As of today, we are checking the following:

RegExpr: A warning is raised, if a regular expression has syntax errors.
DetectChars: A warning is raised, if the char=”x” attribute contains more or less than one character, e.g. when char=”xyz”, or char=”\” (no escaping required), or similar.
Detect2Chars: Same as DetectChars, just for char=”x” and char1=”y”.
Keyword lists: A warning is raised, if a keyword entry contains leading or trailing spaces. Additional trimming just takes time.
Keyword lists: A warning is raised if a keyword list is unused.
Keyword lists: A warning is raised if multiple keyword lists use the same me (=identifier).
Keyword lists: A warning is raised if a non-existing keyword list is used.
Contexts: A warning is raised, if a non-existing context is referenced.
Contexts: A warning is raised, if a context is unused.
Contexts: A warning is raised, if multiple contexts have the same name (identifier clash).
Attributes: A warning is raised, if non-existing itemData is used.
Attributes: A warning is raised, if multiple itemDatas use the same name (identifier clash).
Attributes: A warning is raised, if an itemData is unused.

This list helps us nicely to catch many mistakes at compile time even before running unit tests.

Update (2017-12-17): All above issues are fixed for all highlighting files starting with the KSyntaxHighlighting 5.42 framework, to be released in January 2018.

New Kate on Windows installer

Sun, 17 Sep 2017 20:28:57 +0000

We have a new round of Kate installers for Windows. This round comes with some installer-bug fixes (all project plugin dlls) and support for editorconfig files http://editorconfig.org/.

In the above screen-shot you can see the project plugin analyzing Kate code. This works if you have cppcheck installed and added to the path.

Grab the installers now at download.kde.org: Kate-setup-17.08.1-KF5.38-32bit or Kate-setup-17.08.1-KF5.38-64bit

Kate is now translated also on Windows!

Thu, 20 Jul 2017 19:04:47 +0000

This release includes all the feature-enhancements the Linux version has received (frameworks announcements for 5.36.0)

– Actually working spell-checking.
– Possibility to switch interface language.

EDIT: Adding an extra fall-back UI language does not wok properly yet.

[][2]

Kate in Sweedish

Grab it now at download.kde.org: Kate-setup-17.04.3-KF5.36-32bit or Kate-setup-17.04.3-KF5.36-64bit

Kate 17.04.1 available for Windows

Mon, 22 May 2017 19:03:48 +0000

Installers for Kate 17.04.1 are now available for download!

This release includes, besides bug-fixing and features, an update to the search in files plugin. The search-while-you-type in the current file should not “destroy” your last search in files results as easily as previously. The search-combo-box-history handling is also improved.

Grab it now at download.kde.org: Kate-setup-17.04.1-KF5.34-32bit or Kate-setup-17.04.1-KF5.34-64bit

KTextEditor depends on KSyntaxHighlighting

Mon, 23 Jan 2017 21:02:51 +0000

Recently, the KSyntaxHighlighting framework was added to the KDE Frameworks 5.29 release. And starting with KDE Frameworks 5.29, KTextEditor depends on KSyntaxHighlighting. This also means that KTextEditor now queries KSyntaxHighlighting for available xml highlighting files. As such, the location for syntax highlighting files changed from $HOME/.local/share/katepart5/syntax to

$HOME/.local/share/org.kde.syntax-highlighting/syntax

So if you want to add your own syntax highlighting files to Kate/KDevelop, then you have to use the new location.

By the way, in former times, all syntax highlighting files were located somewhere in /usr/share/. However, since some time, there are no xml highlighting files anymore, since all xml files are compiled into the KSyntaxHighlighting library by default. This leads to much faster startup times for KTextEditor-based applications.

Running Unit Tests

If you build Kate (or KTextEditor, or KSyntaxHighlighting) from sources and run the unit tests (`make test`), then the location typically is /$HOME/.qttest/share/org.kde.syntax-highlighting/syntax.

FirstAid – PDF Help Viewer

Sun, 15 Jan 2017 13:18:32 +0000

Hi,

in the recent months, I didn’t find much time to spend on Kate/KTextEditor development. But at least I was now able to spend a bit more time on OpenSource & Qt things even during work time in our company. Normally I am stuck there with low level binary or source analysis work.

For our products, we were in the need of some online help. As our documentation is delivered as PDFs generated by the tools of the TeX Live distro, a natural idea was to use some PDF viewer and integrate it more tightly in our software than just “open the manual at page 1”.

We did review PDF viewers out there, but most (like Okular) have too many dependencies to be just bundled with our product (or a license not permitting that).

Without bundling, we can’t ensure that the tight coupling is working, without starting to test the integration with X different viewers which more or less all need other kinds of command line arguments to open the right page or even lack that feature or will not reuse an already running instance, ….

Therefore, as our GUIs are developed with Qt anyways, we did take a look at libpoppler (and its Qt 5 bindings), which is the base of Okular, too.

Easy enough, taking the small demo program shipped with the library and adding a small stdin based interface to tell it “goto ” we arrived at some small PDF viewer that is fit enough for our use case.

We named the thing “FirstAid”, the sources can be grabbed at github.com/AbsInt/FirstAid. Like libpoppler and the demo, its licensed as GPLv2+.

As already the README states, the aim of this small project is not to replace some full fledged viewer like Okular, the design goal is to have a small viewer that is auto-started by some host application and will jump to the requested labels for a tightly coupled online help. It can be used as a pure standalone PDF viewer, too, but that is more intended for testing it e.g. on the documents that should later be shown as online help.

I already annoyed Albert with some small issue I had with libpoppler, perhaps I will provide more useful fixes in the future if more things come up during FirstAid development. In any case, already THANKS A LOT for the Qt 5 bindings around libpoppler, they work nicely for us!

I really think this small project shows the benefit of OpenSource: We needed a PDF viewer, we were able to create a small one in less than a month based on OpenSource libraries and we can give back the results to the community (if it is useful for others is a different story, but perhaps other people have the same itch to scratch, if not, ignore it). I hope more possibilities for such things come up at work in the future.

For building: It should build out of the box if you have some recent Qt and libpoppler-qt5-dev installed, at least the Travis CI is able to build it out of the box with the given config. For me, it shows some small bugs if used with Qt 5.⁶⁄₇ compared to the Qt 5.8 Beta I used here for testing.

Windows installer for Kate 16.08.3 KF5.28

Mon, 21 Nov 2016 09:59:48 +0000

New Kate installer for Windows!

Except for the general bug-fixes and feature additions in Kate and KF5 this installer also fixes a rename file failure bug by including the needed KIO dll.

Grab it while it is hot: Kate 16.08.3 KF5.28 64bit or Kate 16.08.3 KF5.28 32bit

KSyntaxHighlighting – A new Syntax Highlighting Framework

Tue, 15 Nov 2016 21:35:36 +0000

Today, KDE Frameworks 5.28 was released with the brand new KSyntaxHighlighting framework. The announcement says:

New framework: syntax-highlighting
Syntax highlighting engine for Kate syntax definitions

This is a stand-alone implementation of the Kate syntax highlighting engine. It’s meant as a building block for text editors as well as for simple highlighted text rendering (e.g. as HTML), supporting both integration with a custom editor as well as a ready-to-use QSyntaxHighlighter sub-class.

This year, on March 31st, KDE’s advanced text editor Kate had its 15th birthday. 15 years are a long time in the software world, and during this time Kate won the hearts of many users and developers. As text editing component, Kate uses the KTextEditor framework, which is used also by applications such as KDevelop or Kile.

The KTextEditor framework essentially is an embeddable text editing component. It ships everything from painting the line numbers, the background color, the text lines with syntax highlighting, the blinking cursor to code completion and many more features. One major feature is its very powerful syntax highlighting engine, enabling us to properly highlight around 275 languages.

Each syntax highlighting is defined in terms of an xml file (many examples), as described in Kate’s documentation. These xml files are read by KTextEditor and the context based highlighting rules in these files are then used to highlight the file contents.

For the last 15 years, this syntax highlighting engine was tightly coupled with the rest of the KTextEditor code. As such, it was not possible to simply reuse the highlighting engine in other projects without using KTextEditor. This lead to the unfortunate situation, where e.g. the Qt Creator developers partly reimplemented Kate’s syntax highlighting engine in order to support other languages next to C/C++.

This changed as of today: The KSyntaxHighlighting framework is a tier 1 functional framework that solely depends on Qt (no dependency on Qt Widgets or QML), is very well unit tested, and licensed under the LGPLv2+. As mentioned in the announcement and in the API documentation, it is a stand-alone implementation of the Kate syntax highlighting engine. It’s meant as a building block for text editors as well as for simple highlighted text rendering (e.g. as HTML), supporting both integration with a custom editor as well as a ready-to-use QSyntaxHighlighter sub-class. This also implies that you can reuse this framework to add syntax highlighting to e.g. QML applications.

We hope that other applications such as Qt Creator will start to use the KSyntaxHighlighting framework, since it allows us to cleanly share one single implementation of the syntax highlighting engine.

In the next KDE Frameworks releases, we will remove KTextEditors syntax highlighting engine in favor of just using KSyntaxHighlighting. This will happen step by step. For instance, we already have a pending patch that removes all xml files from KTextEditor.git in favor of using the ones shipped by the KSyntaxHighlighting framework. That means, with the KDE Frameworks 5.29 release, Kate’s and KTextEditors dependency (and other application’s dependencies) will look as follows:

This is quite an interesting change, especially since moving the syntax highlighting engine out of KTextEditor was already planned since Akademy 2013 in Bilbao:

Another idea was raised at this year’s Akademy in Bilbao: Split Kate Part’s highlighting into a separate library. This way, other applications could use the Kate Part’s highlighting system. Think of a command line tool to create highlighted html pages, or a syntax highlighter for QTextEdits. The highlighting engine right now is mostly internal to Kate Part, so such a split could happen also later after the initial release of KTextEditor on 5.

This goal is now reached – thanks to Volker Krause who did most of the work. Pretty cool!

If you are interested in using the KSyntaxHighlighting framework, feel free to contact us on our mailing list. Further, we welcome all contributions, so please send patches to our mailing list, or post them on phabricator. (You can also find the KSyntaxHighlighting framework on github for convenience, but it’s not our primary platform).

You can also support Kate and the KDE Frameworks by donating to the KDE e.V., KDE’s non-profit organization.

Update: Changed XML Syntax Definition File Location

Starting with KDE Frameworks 5.29, the KTextEditor framework now uses the syntax highlighting files from KSyntaxHighlighting. These files are located in $HOME/.local/share/org.kde.syntax-highlighting/syntax. If this folder does not exist, just create it. Futher, you will not find any syntax highlighting files in your system installation, since the syntax highlighting files shipped with KSyntaxHighlighting are compiled into the executable.

Embedded Notifications for Externally Modified Files

Wed, 07 Sep 2016 20:51:33 +0000

In the past, KTextEditor notified the user about externally modified files with a modal dialog. Many users were annoyed by this behavior.

Starting with KDE Frameworks 5.27, KTextEditor will show an embedded widget for external changes, see:

Kate & Akademy Awards 2016

Wed, 07 Sep 2016 12:34:23 +0000

Dominik and me got the Akademy 2016 Award for our work on Kate and KTextEditor.

I want to pass that on to all other contributors of both the application and the framework: You all rock and people seem to appreciate our work!

Lets keep on improving our stuff and providing people with a very usable editor and editor component for various use cases.

Akademy 2016

Thu, 01 Sep 2016 10:55:26 +0000

Arrived at Berlin for Akademy/QtCon 2016, too ;=)

Already met some other KDE & Kate people, lets see how the week goes.

Bug Triaging Guest Blog: The wandering bug triager was here

Fri, 12 Aug 2016 20:10:15 +0000

I was contacted by Buovjaga from the LibreOffice QA team to spread the word about the current bug triaging efforts going on.

Therefore now a short guest block about that ;=)

Thanks to Buovjaga for trying to get some public interest in this important aspect of open source work: handling our flood of bugs!

Free software needs more contributors from the non-coding user community. The problem is that there is no scientifically proven method for attracting them.

After dealing with thousands of LibreOffice bug reports and simultaneously trying to recruit more testers through various cunning plans, I realized the topic of free software quality assurance needs to become more prominent. I came up with the idea for a publicity stunt where I camp out at different bug trackers while telling the world about it. I chose KDE and Kate for my first month of triaging.

Bug triagers act as guardians of the bug tracker and save the developers from a lot of wasted time. If the number of unconfirmed reports in a project is not close to zero, it needs more triagers.

There were about 120 reports I deemed suitable for testing. I skipped crash debugging, testing of advanced features and only focused on the basic stuff. My take on the stats is that there is currently no one doing this sort of thing regularly for Kate.

To get started in triaging KDE bugs, you

– start testing unconfirmed reports and ancient confirmed ones while keeping the Bug triage guide at hand https://community.kde.org/Bugsquad/Guide_To_BugTriaging

– join #kde-bugs IRC channel after having commented on a bunch of reports and request rights to edit report details

– join the IRC channels of the products you are helping and coordinate testing with others https://userbase.kde.org/IRC_Channels#Applications

I believe a goal should be set for recruiting one person to deal with triaging per every actively-developed KDE product. After achieving this goal, it will quickly become apparent to each product team just how many triagers are needed in order for the work to be sustainable. However, the teams should not remain in isolation. The whole of KDE needs to become transparent. An “Everything about KDE” web dashboard would enable contributors to quickly see, which teams are in need of assistance. Tools for this are available in the Grimoire Lab suite http://grimoirelab.github.io/. KDE sysadmin team does not have the resources to set them up, so if you have the necessary skills and want to make this happen, please contact them on the #kde-sysadmin IRC channel.

If you want to contact me, you can find me on the #libreoffice-qa channel @ Freenode network, nickname: buovjaga.

What happened to Kate in Randa?

Fri, 08 Jul 2016 19:52:21 +0000

This years topic for the Randa meeting, was multi-platform end-user application development. That was a golden opportunity to work on the Windows and Mac versions.

One thing that happened was that the icon.rcc file generation is moved to the breeze-icons repository in stead of doing it separately for every application. The icon.rcc file loading was moved to KIconThemes so that all applications linking to it don’t have to invent the wheel again. This would not have been so easy if we hadn’t been at the same place discussing things face to face.

A more noticeable thing is that Kate now does not need a DBus server on Windows and Apple any more. Both Kate and KDevelop now use QtSingleApplication to open all documents in one window.

The search plugin also got a face-lift. Hopefully the new layout will be a bit more useful than the previous :)

A Randa development release of Kate on Windows was also done. Download the installer from here.

To be able to continue with similar activities we need your help.

KTextEditor gets Scrollbar and Code Folding Preview (Updated)

Sun, 19 Jun 2016 16:50:54 +0000

The KTextEditor Framework just got a new features for the next KDE Frameworks 5.24 release: A Text Preview on the vertical scrollbar.

If enabled in the options, the KTextEditor now shows a preview of the text when the mouse hovers over the scrollbar. The feature is available both when the minimap is used and also when the standard scrollbar is used. The text preview is only visible when vertical scrolling is possible.

This feature is enabled by default, and is also automatically available in Kile and KDevelop, so we hope this is useful to you!

For developers, to ensure this feature is off, the ConfigInterface of the View can be used through the config key “scrollbar-preview” of type bool.

And in addition to the preview in the scrollbar, it is now also possible to have a preview for folded code: Hovering over folded code pops up a preview of the hidden lines. When clicked, the code folding opens.

These features got added during the KDE Randa sprint, where around 40 KDE developers focus on improving KDE software and bringing KDE software to other platforms such as Windows and Mac OS. You can support us by donating through the following banner: :)

Bug fixed after 13 years

Fri, 17 Jun 2016 21:42:44 +0000

During the Randa sprint an 13 year old bug was fixed :P

I myself moved it to kxmlgui (out of Kate/KWrites’s harm, good to delegate stuff away :) in 2003 and since then we got a lot of duplicates but never somebody got the time to track it down. (333 votes for it, really nice number)

Now, after 13 years, it got done (and yet another chance that a bug becomes a sentient intelligence has vanished ;=)

Bug 64754 – XMLGUI items (toolbar icons, menu items) from merge sections move or disappear

Thanks to David, Dominik and Sune to get this fixed ;=)

And I really like the comment we got after the fix, awesome:

David Faure, you deserve a medal.

A 13 year old KDE bug finally fixed. Just think, when this bug was first reported:

— The current Linux Kernel was 2.6.31

— Top Movie? The ORIGINAL Underworld.

— Windows XP was the most current desktop verison. Vista was still 3 years away.

— Top 2 Linux verions? Mandrake and Redhat (Fedora wouldn’t be released for another 2 months, Ubuntu’s first was more than a year away.)

— Top billboard song? Crazy In Love by Jay-Z & Beyoncé (who was barely old enough to drink)

— 3 of the 5 KDE ev board members hadn’t ever used KDE

— Palestinian Prime Minister Mahmoud Abbas resigns ending “Road Map for Peace”

— Current KDE version? 3.1.4 (KDE 3 had only been out for a year)

Very very cool!

Not sure if the kernel version is right, more likely some < 2.6.0 kernel was the king of the hill at that time, but otherwise, great :P

Therefore: Support us, Randa sprint and other sprints really bring our software stack forward! Nowhere else such a nice group of KDE developers can meet up to solve such problems together!

KDE Software for Windows & Chocolatey

Thu, 16 Jun 2016 19:33:59 +0000

KDE applications providing Windows installers can now be additionally listed in the Chocolatey software repository on an dedicated KDE profile. If you want to be added to this profile with your application, contact kde-windows@kde.org.

At the moment, you can find digiKam, Kate & Krita. The profile allows an quick overview about the KDE applications that are available.

This is a nice addition to the downloads provided via download.kde.org or the application homepages and increases the visibility of our applications on Windows.

More info about KDE software on Windows and how to join the KDE Windows initiative can be found on our windows.kde.org page.

Would be nice if you support us to make things like this at the Randa sprint possible! ;)

New Kate/KWrite Bundles for Mac

Thu, 16 Jun 2016 10:57:09 +0000

I updated again the Kate/KWrite application bundles following the new guide on KDE on Mac.

With the same guide, other application developers should be able to create stand-alone application bundles for Mac OS X, too. Btw., the guide is on a wiki page, feel free to enhance the documentation, I doubt it is optimal ATM.

What needs to be solved to make it easier: At the moment, the guide uses a stock Qt as obtainable from qt.io but unfortunately, macdeployqt needs to be patched to deploy non-qt plugins

For this see the review request “add support for -extra-plugins command line option”. I hope this gets into Qt or we get an alternative solution, hint, hint => help appreciated :=))

KWrite on Mac looks unspectacular:

But the cool thing is: This is the result of a plain compile of KF5 & kate.git. We patch NONE of the frameworks anymore and we don’t need to build Qt on our own, we can use the stock Qt installer (the bundles use 5.7.0, the build that should be the final one to be released these days).

For deployment problems like: “how to get our icons” or “how to locate our plugins or ioslaves” generic solutions were implemented in the KF5 libraries.

If the above review request is accepted or an other solution is found you will have exactly the same developer experience on Mac as on e.g. Linux. No ugly hacks, no patching, etc.

For Kate we even have a kind of working embedded Konsole again with this updated build, enjoy:

I think overall, the Mac developer experience for KF5 based stuff really improved in the last months and the latest things that happened this week were only possible thanks to the Randa sprint. Would be nice if you support us ;)

Kate & Co. on Tour

Wed, 15 Jun 2016 15:19:52 +0000

We used the nice weather for some small trip near Randa between hacking ;=)

But beside getting a bit fresh air, we did other nice things like fixing together with David Faure of Frameworks fame the issue “how to get automagically icons loaded if you want to bundle them in your installer/app bundle”, see the change: “Add support for loading and using an icontheme in a RCC file automatically.”

Would be nice if you support us to make things like the Randa sprint possible! ;)

Kate’s TabBar gets Movable Tabs

Wed, 15 Jun 2016 11:00:46 +0000

With the next Applications 16.08 release, Kate5’s tabs will be movable with the mouse. This was a feature request for quite some time, which is now fixed.For the record, the animated gif was created with the following two commands:

ffmpeg -f alsa -f x11grab -r 30 -s 680x385 -i :0.0+0,0 -threads 0 output%04d.png
convert -delay 1/30 -loop 0 -layers OptimizeFrame -size 680x385 -fuzz 2% output*.png output.gif

Much more work is going on at the Randa spring currently held in Switzerland. Would be nice if you support us ;)

New Mac OS X Build Documentation

Tue, 14 Jun 2016 21:52:50 +0000

During the Mac OS X platform meeting here at Randa, the point was made that the current build documentation for Mac OS X is a bit lacking, as e.g. the steps to create an application bundle are only documented somewhere for Kate, Krita, KDevelop, … but in no central place.

I started to writeup a new howto at the mac.kde.org page that utilizes emerge for the heavy lifting like the KDE Windows team uses it.

I think this might be nice to have synergy effects between both ports, thanks to Hannah for hinting to this and the help for setting it up. Might be interesting for the CI, too.

MiniMap Fine-Tuning

Tue, 14 Jun 2016 18:06:56 +0000

Kate also supports a minimap of the text contents instead of a classical scrollbar. To enable it, just go to

Here at the Randa meeting, we just invested some time to bring this minimap more in line with the Breeze style. You can see the difference here: Note the scrollbar slider frame, the new version (right) is more distinct and in line with the rounded corners of the Breeze style.

Old Scrollbar Slider

New Scrollbar Slider

 <p>
This change will be in the KDE Frameworks 5.24 release. If you want to support the KDE Randa developer meeting, please click on the banner :-)<br /> <a href="https://www.kde.org/fundraisers/randameetings2016/"><img class="aligncenter" src="https://www.kde.org/fundraisers/randameetings2016/images/banner-fundraising2016.png" width="1400" height="200" /></a>
</p>

Updated bundles, now release builds and less frameworks

Mon, 13 Jun 2016 22:21:36 +0000

I updated the bundles, now they are release builds of Kate & KWrite and they contain less frameworks. The size is only one half of the last bundles, less than 50 MB per app. Visit “Get It” for the download links or below.

Mac Application Bundles

New “Get It” page & “Build It” split out

Mon, 13 Jun 2016 16:32:13 +0000

As we now have some binaries available for Windows & Mac, I renovated the “Get It” page.

You now have there links to the latest versions of our binaries (installer for Windows & application bundle for Mac) beside the link to the distribution packages for Linux/BSD/* as provided by our dear packagers.

For building Kate from sources, we now have the building instructions on a separate “Build It” page.

We will try to update the binary builds in the next days at Randa.

Working on Kate in Randa

Mon, 13 Jun 2016 16:12:59 +0000

Right now, around 40 developers are working together on bringing KDE to other platforms in Randa (Switzerland) for an entire week.

So far, I just fixed some bugs, e.g.:

Kate: Correctly restore view config of all split views (commit, bug, review)
Kate: Sort Kate Session Menu alphabetically (commit, bug, review)
Kate: Avoid hidden view spaces on start (commit, bug, review)
Kate, KDevelop: Tab Switcher Plugin: Make sure the height fits all items (commit, bug)

Much more work is going on, especially also with bringing Kate to Mac OS, or making it work better on Windows. For instance, thanks to Kåre and David, renaming documents already works now, and soon the filesystem browser plugin will be available in the next Kate on Windows release :)

If you want to support us, please donate to help us keeping up these developer meetings.

Kate/KWrite Application Bundle Update

Mon, 13 Jun 2016 10:11:31 +0000

I just created new bundles for Kate & KWrite.

By accident they are a bit large, as stuff as web engine is moved to the bundle, but they should work ;=)

How to create them?

mac.txt in kate.git shows how that works.

But you need a macqtdeploy with the patch for QTBUG-48836.

Download links:

Thanks to the Randa meetup I got time for this, if you want to sponsor, click the image below ;)

First Day in Randa

Mon, 13 Jun 2016 06:41:02 +0000

Yesterday afternoon I and others arrived in Randa. After some first meetup, started to try out how much work it is to e.g. compile Konsole or KDevelop on my Mac without patching Qt and stuff.

Two review requests pending to get Konsole working at least on some basic level. Lets see what more is needed to get it in some usable state (at least the terminal toolview in Kate now can use the konsole part ;=)

Randa Meeting 2016 – Tomorrow on Tour ;=)

Sat, 11 Jun 2016 11:31:02 +0000

Tomorrow I will start to travel to the Randa Meeting 2016.

I hope I can help to make it possible to spread KF5 based stuff more easy on platforms like Windows & Mac.

Lets see what can be done, will be an interesting week ;=)

If you want to support us, please consider to donate, we have a fundraising campaign running!

Breeze Dark Color Scheme

Sat, 28 May 2016 12:14:29 +0000

Just as quick info, with the next KDE Frameworks 5 release, namely KF5 version 5.23, the KTextEditor framework gains a Breeze Dark color scheme. The colors mostly stick to the Breeze color palette, with some minor changes, since KTextEditor needs more colors the the color palette itself ships. To use this color scheme, go to the config dialog and choose “Breeze Dark” in the Fonts & Colors config page. We hope this is useful – mandatory screenshot:

Update: Screenshot of KDevelop 5 with Breeze Dark theme and color schema:

Kate 16.04 on Windows (64bit)

Fri, 29 Apr 2016 17:39:00 +0000

It seems the Kate Alpha Release in January was well received by some users. So we are happy to announce that we are releasing an updated Windows installer for Kate (64bit) today. Essentially, this is the same version that is shipped with the KDE Applications 16.04 release under Linux.

Kate-setup-16.04.1-64bit.exe (64bit) installer, compiled on Windows 10
If you have git in your PATH, then the Kate Projects plugin will work as expected.
As mentioned in the previous post, you may want to also install D-Bus for Windows, so that all documents opened use the same Kate instance.
You can compile Kate yourself with Visual Studio 2015 community edition by following the steps in kate-windows.git. For me, a few tweaks were necessary, though: If some modules do not compile, just run the cmake build command again (and again). The “NMake Makefiles JOM” do not work for me, I had to use “Visual Studio 14 2015 Win64” generator. You can start the Visual Studio with `devenv KateOnWindows.sln`. If you have further questions, please contact us on the mailing list.

Screenshot of running Kate under Windows 10:

If you want to contribute or have questions, please contact the Kate developers on kwrite-devel@kde.org (subscribe). Also, you can sometimes reach us via IRC on irc.freenode.net in the channel #kate.

Further, if you want to support Kate and the KDE project in general, it is very much appreciated if you donate to the KDE e.V., KDE’s support organization – thank you! :-)

Making Windows Phones work in Dolphin

Wed, 16 Mar 2016 07:28:52 +0000

Hi all,

if you have a Windows Phone (e.g. Lumia or similar), then please help us on MTP & Windows Phones so we can find the correct patch to make these devices work in the kio-mtp io slave.

Thanks! :-)

Kate on Windows

Thu, 28 Jan 2016 18:41:39 +0000

NOTE: Please refer to Get It for up-to-date Windows versions

It took some time but here is now an installer for Kate on Windows.

First the proof :)

[][2]

The installer

[][3]

An example of what it can look like

There are still some things that needs fixing. The current installer is built from git master and not from released packages so the translation stuff hat you usually get with the release packages are missing. So only partially translated. Another feature that I’m still missing is the spell-check. I need to still add a/hspell and language dictionaries to get that to work.

But for now you can try it out here: http://download.kde.org/unstable/kate/ (updated link)

And if you are eager to help here is my scratch repo for the build recipes:
git://anongit.kde.org/scratch/sars/kate-windows.git

And if you happen to want to have only one kate window for all the documents that you open, you might want to install DBus. This is the installer that I have tested with:
https://dbus-windows-installer.googlecode.com/files/DBus-Windows-Installer-1.4.1-2.exe
Happy Hacking!

Note: This would not have been possible without the big effort that the KDE on Windows people have made to get stuff to compile on Windows and keeping sure that it continues to compile. Thank you!

Kate/KWrite on Mac – More Icons & More Plugins

Sat, 24 Oct 2015 15:52:00 +0000

After a bit more work, toolbars (and other places ;=) have icons, too. More Kate plugins do work, like the nice project plugin I use the whole day, see:

Updated .dmg files can be found at (alpha quality, only tested on Mac OS 10.10):

ftp://kate-editor.org/cullmann/kate-20151024.dmg

ftp://kate-editor.org/cullmann/kwrite-20151024.dmg

Help to get more stuff working and fix the remaining crashs is highly appreciated. A script how to build that all can be found at:

https://quickgit.kde.org/?p=kate.git&a=blob&f=mac.txt

You can use a plain Qt and current KDE Frameworks & Kate master to get that running. Guess the next goal would be to get KIO working without patching Qt, lets see how much work that is.

P.S. With the guide in mac.txt you should be able to try out how to port other KDE based applications, too, and get a application bundle, as most stuff should be available now, for the average application. How to use some bundled Breeze icon set can be found here, just call code like that after QApplication is constructed:

https://quickgit.kde.org/?p=kate.git&a=blob&f=icons.h

Where to put the Breeze resource see mac.txt (its actually toplevel in the .app folder, not in Resources like told by Qt docs).

Alpha Kate & KWrite Application Bundles

Wed, 21 Oct 2015 19:58:02 +0000

Hi,

with my latest changes in kate.git, icons work, too, on windows and mac, without any qt patch, if you put some qt resource file containing breeze inside your share or Resources folder (one up from the application binary).

mac.txt contains the rcc calls needed to create such a package and all others things you need to run to get .dmg files. (you need Qt 5.5.0 + a recent CMake + XCode with command line stuff enabled)

Kate plugins should work, too, if you have a qt.conf that points to the local plugins (like macdeployqt will create for you in the mac.txt run).

Things not working ATM without patched Qt or more work: KIO slaves and all dbus related stuff.

With that in place, I consider Kate/KWrite on Mac at least of alpha quality. Still some plugins are missing, optimizations for the .dmg generation could be done like removing stuff we don’t use like QtWebKit from the bundle, but besides, the programs do something and don’t crash immediately, at least not on my Mac OS 10.10 installation.

Mandatory Screenshot :=)

Links to Kate & KWrite .dmg files: (ALPHA quality still, only tested on Mac OS 10.10, now just with icons and some plugins and too many Qt libraries and plugins to make the .dmg large :)

kwrite-alpha-20151021.dmg

kate-alpha-20151021.dmg

P.S. Testers are welcome, but help of any other kind even more ;) Given Kate/KWrite are trivial to build on a Mac with just XCode around and the stuff described in mac.txt it would be really GREAT if somebody could step up to help to fine tune this to have some more usable beta or even “real” release for Mac in the future. I will continue to work on this, but my Mac isn’t my main working machine nor what I use for my daily company work, therefore, this is not my highest priority.

KWrite on Mac – Application Bundle

Mon, 19 Oct 2015 13:11:32 +0000

Hi,

after one week of patching frameworks (and KWrite/Kate), the first success can be seen: a kind of working application bundle for KWrite.

Still no icons, need to set icon theme + search paths right and bundle that, too, but need to investigate more how the icon lookup works.

You can build the stuff on your own just following kate.git/mac.txt and calling once the macdeployqt tool afterwards on the /Applications/KDE/kwrite.app bundle (with -dmg to get the disk image file).

For Kate, the macdeployqt still misses an additional switch to deploy own plugins in addition, will add that in the next days, I hope. Have already some local hack, but want to have some patch I can hand in to Qt Company.

Here a link to the version you see above in the screenshot (not tested below Mac OS 10.10):

/download/kwrite-alpha-no-icons.dmg

A colleague tested it for me on a Mac without any dbus/macports/homebrew/co. stuff installed and it seems to work and not eat all his data ;=) But this is ALPHA quality, this means all things can happen, I didn’t test it that much beside using it for my last kate.git commit and starting it up for that screenshot above, not more ;=)

The good things: This stuff needs no patched Qt nor any patches to any KF5 stuff, this uses plain Qt 5.5.0 from the Qt Company installer and all modifications for frameworks are inside our master branch of framworks already.

The bad things: e.g. KIO doesn’t work atm (even if the io slaves would be in the bundle), therefore only local file support.

Kate on Mac, HiDPI

Wed, 14 Oct 2015 20:48:32 +0000

Kate runs ;=)

But as you can see, we have no icons, but that is as no work was invested into it and not even any icons are installed ;=)

I will maintain a guide how to build it on mac in the kate.git/mac.txt file. At the moment, this is all not that nice. Kate is able to open files via file dialog and it renders OK, modulo some glitches.

Still a long way to go, ATM the application bundle contains just the application binary + plist + icons. The libraries are still found only because of they are were they were compiled & installed. Plugins are not found either, need to take a look if that is just missing env vars or more.

At least, this is far better than at the beginning of the year, were all I had was instant segfaults.

Kate runs here btw. without any dbus server running, which means file opening in that window via command line won’t work, but still, compared to KWrite, which crashs on open dialog because of dbus missing, that is nice ;=)

KWrite on Mac

Mon, 12 Oct 2015 21:36:24 +0000

After some hacking on frameworks, I have the first running KWrite version on Mac that uses an unpatched Qt from the qt.io offline installer:

It is still ugly, as scaled on my HiDPI display as the plist file is missing and it crashs on everything (aka open dialog) and has no icons.

But beside that, it works.

No magic, just the xcode clang toolchain + stock qt + stock cmake + gettext + KDE Frameworks 5 ;)

Script that did the job (still some patches to frameworks missing in master that remove optional deps and fixes linking), it is available in updated form in kate.git:

https://quickgit.kde.org/?p=kate.git&a=blob&f=mac.txt

The changes will benefit Windows builds, too, as they made the dependencies a bit smaller. You for example need no longer phonon to get this running, nor do you need to hassle around with the xslt/xml doctools on Windows.

Patches that are needed t to be applied to have this working:

https://git.reviewboard.kde.org/r/125614/

https://git.reviewboard.kde.org/r/125616/

Kate/KDevelop Sprint 2015 – Summary for Kate

Sun, 11 Oct 2015 13:49:06 +0000

The end of the joint Kate/KDevelop Sprint 2015 is coming closer, half of the people already have left to get home.

It was a good thing to have this sprint sponsored by the KDE e.V. and organized by Milian Wolff directly after the Qt World Summit 2015 here in Berlin. I think that made it easier for people to attend both events, like myself ;=)

I came to the sprint to work on getting our bugs sorted and fixed and to improve the state of the Mac port. I must confess, the bug fixing session worked out well, but I didn’t take a shot at Mac at all.

What did I achieve? I fixed many small bugs and I reintroduced the automatic brackets completion removed by accident in the KDE 4.x => KF5 transition.

In addition I cleaned up old things in our bugzilla. The new policy for Kate will be: wishes that not got any attention since 2 years will be closed, it makes no sense to keep them around for ever and it will only make overview about what is really wanted impossible.

In addition, I tried to help Kåre Särs to get Kate running on Windows. We want to have a way to build Kate with a unpatched Qt. At the moment that is not really feasible, as things like ui files are not found, xml syntax files are not found and so on. I started to solve that issues and at least KTextEditor framework itself should now be more or less Windows (and therefore Mac) compatible. But the other frameworks will still need love, like KXmlGui not being able to locate its own ui_standards.rc. Kate application is now compilable without any strange patches, too, on Windows.

Mandatory screenshot (be aware, to get menus and stuff working, we here randomly copied all files into the right user local directories):

Dominik Haumann did help us in our bug fixing effort, too. At the end of the sprint he started the painful work to review and fix the use of hard-coded colors in our highlighting files, work nobody really wants to do :=)

Sven Brauch helped to improve my reintroduced bracket completion to be not completely dumb .P

All in all, I think it was a productive sprint. Not that we all reached our goals, but we did make progress.

I think Kate & KTextEditor will be in a very good shape for the 15.16 KF5 Frameworks and the next KDE Applications release. In addition you always get again momentum to work on more stuff in the close future by meeting up in person and do some socializing aka eating ;)

Therefore, to wrap it up: Nice work all guys, thanks by the Kate maintainer to all people that joint the sprint and special thanks to Milian for setting it up and the KDE e.V. for sponsoring it ;=)

P.S. Yeah, sponsoring implies that the e.V. has money for that. To keep such spring sponsoring possible in the future => give us money!

Kate/KDevelop 2015

Sat, 10 Oct 2015 20:48:57 +0000

From the 7th to the 11th of October Kate and KDevelop contricutors once again met to work on both Kate and KDevelop.

The work in Kate was mostly spent on fixing bugs, as can be seen by the following bug chart for Kate:

That is, more than 300 bug and wish reports were closed. Granted, many of the reports were just old and given our limited manpower we were closing many wishes since it is unlikely that old wishes get implemented. Then again, we also fixed a lot of bugs that required code changes, and also fine tuning of KTextEditor and Kate. The fixed bugs are roughly KDE bug tracker (yes, the auto-brackets option is back!), besides there are also a lot of changes there were not listed in bug reports. We hope the changes are useful to you, so be sure to get the KDE Frameworks version 5.16 as soon as it’s released :-)

Qt World Summit + Kate/KDevelop Sprint in Berlin

Fri, 09 Oct 2015 08:39:44 +0000

This week is really busy, first three days of Qt World Summit and now hacking away at the Kate/KDevelop sprint in Berlin.

This year my personal goal will be to get our bugs & wishes back into shape.

One major decision I as the maintainer did take was to close all wishes that not got changed since two years. Our team is very small and we have plenty of real bugs to take care of (and their number is rising) such that we will never be able to implement random requests.

If an user is really interested in the feature to come into existance, the wish can be reopened. Still, if no new arguments are brought up that might lead to some more interest by the Kate team, I think that won’t help a lot. The best solution would be if people could provide patches, which in some cases, like for missing highlighting features in the syntax files, is really easy. At least it should be for the advanced user crowd attracted by an advanced text editor.

Again about Relicensing KDE’s Source Code

Sun, 09 Aug 2015 19:37:58 +0000

To get started with KDE development, newcomers usually first sent patches. Having sent several patches, the newcomers are typically encouraged by us (the reviewers) to apply for a KDE contributor account. This application includes the question of “who encouraged you to apply for a KDE contributor account”.

Then, the KDE sysadmins contact the mentioned developers to make sure the application is valid and trustworthy. Hence, you, as someone who encouraged others to apply for an account, get a mail with the subject “Developer account application approval […]”.

To all KDE contributors: Given you probably also were involved with getting other contributors involved with KDE, please follow these steps:

Filter your KDE mails for “Developer account application approval”
For each contributor, get the contributors commit name (you can look this up on identity.kde.org > Prople.
Check, whether the new contributor added him/herself to the relicensecheck.pl script.
If not, please send this contributor a mail and encourage him/her to add him/herself to this script.

You really should check this, since you are also responsible for getting these new contributors commit access.

I did that with 8 contributors. 7 already added themselves within one week. Only one is not reachable by mail anymore… So it seems to work quite well.

Plasma 5: Keeping an Eye on the Disk Quota

Sun, 02 Aug 2015 09:39:43 +0000

At this year’s KDE conference Akademy, I was working on a small plasmoid to continuously track the disk quota.

The disk quota is usually used in enterprise installations where network shares are mounted locally. Typically, sysadmins want to avoid that users copy lots of data into their folders, and therefor set quotas (the quota limit has nothing to do with the physical size of a partition). Typically, once a user gets over the hard limit of the quota, the account is blocked and the user cannot login anymore. This happens from time to time, since the users are not really aware of the current quota limit and the already used disk space.

Disk Quota as Plasmoid

Here is where the “Disk Quota” plasmoid helps: Once added to the panel, it shows all quota limits when clicking on the plasmoid:

On mouse over, a nice tool tip shows the used quota in percent (in case multiple quota limits exist, the highest quota is displayed):

When a quota is > 50% but smaller than 75%, the quota icon gets orange:

50%” width=“543” height=“379” srcset=“/wp-content/uploads/2015/08/diskquota-low.png 543w, /wp-content/uploads/2015/08/diskquota-low-300x209.png 300w” sizes=“(max-width: 543px) 100vw, 543px” /> And if the quota is between 75% and 90%, the quota icon gets red: Finally, a quota > 90% will urge the user to cleanup data by showing a exclamation mark as well:

Clicking on a quota entry will launch Filelight in the correct folder, if it is installed.

Disk Quota in System Tray

If the quota plasmoid is shown in the system tray (configure the systray and add it there), then the quota information is shown inline in the system tray popup:

As soon as the quota is equal to or greater than 50%, the quota icon automatically gets visible in the system tray panel:

Finally, if the quota is >= 98%, the quota icon pulses to get the user’s attention (a nice Plasma 5 feature!).

To decrease the quota again, simply click on the respective quota entry in the list view. This launches Filelight with the correct location.

Code Internals

As of now, the Disk Quota plasmoid internally calls the command line tool ‘quota‘ to retrieve the quota information. The output of this tool is parsed and then interpreted to show the quota information as can be seen in the screen shots. If the quota command line tool is not installed, then the Disk Quota plasmoid shows diagnostics like this:

Infos for Packagers

Since Disk Quota uses the command line tool ‘quota’ and launches ‘filelight’ when clicking on quota entries, you should ship ‘quota’ and ‘filelight’ when installing this applet. Most certainly, this plasmoid is only useful for networked systems (with remote mount points) and enterprise installations.

Release Info

Status: Included in Plasma 5.5. ( Review Request: Disk Quota)

Credit where Credit is Due

During implementation lots of questions popped up. Thankfully, we were all at the KDE conference Akademy, and Kai, Sebas, Marco, Martin and the Visual Design group (for design help and icons) were there for quick help – Thanks a lot! Hope you all like the result :-)

Akademy 2015 & Kate

Fri, 31 Jul 2015 08:53:34 +0000

Today, I will travel back home from Akademy 2015.

I must say, it was really a nice KDE meeting and I had a lot of fun ;=)
The first day the KDE e.V. general assembly did take place, then two days of actually interesting talks (including the great announcement of Plasma Mobile). After some more days with interesting BoFs and hacking, Akademy is now ending for me.

I didn’t do that much work on Kate, I mostly did small bugfixes for the applications bundled with the KDE Applications releases regarding their HiDPI support, finally no Konsole that can’t redraw correctly on scrolling on a HiDPI screen with scaling activated!

For Kate, the most stuff I did was porting one more plugin (the text filter plugin), fixing some small bugs and rearranging the search bars for in document and in files search. I hope it now is a bit nicer to use, still that is not the final state and I guess we will ask the VDG for more input later on. (btw., if you see any HiDPI glitches in Kate/KTextEditor master, please inform me, I really want to have non-pixelated output ;=)

A big thanks to all organizers & helpers of Akademy 2015! You did a great job, it was a lot of fun, the location was nice, the social event + day trip was good, all fine :) One of the nicer Akademy experiences! Lets hope that the flight home works out, as Dominik is taking the same plane, otherwise the Kate workforce will be seriously diminished.

Licensing of KDE Code

Sun, 26 Jul 2015 12:57:27 +0000

Akademy, the yearly KDE conference is alive and kicking. During the last days we were discussing again about potential KDE licensing issues (for instance code that is licensed under GPLv2, but not GPLv3). That’s why KDE is maintaining a relicense checker script, that every KDE contributor should enter herself/himself. I’ve blogged about it already in January 2015, but it cannot hurt to repeat it from time to time: From the KDE relicensing page:

A couple of KDE dependent projects or even libraries have moved or are going to move to GPLv3.

Unfortunately, GPL v3 is incompatible with GPL v2. This means that it is not possible to create a project linking GPL v2 and v3 code together. There is no problem for projects which are licensed GPLv2+ (version 2 or above).

A few parts of KDE are currently licensed as GPLv2 only. So far we have no reason to believe that this was something other than an oversight. However, we still need to validate with the individual copyright holders that a relicense to GPLv2+ or GPLv2+v3 is okay with them.

Therefore, in an effort we’re trying to identify the contributors that have contributed under the terms of GPLv2 and where the “+” part was not explicitly mentioned. If we know that all contributors agreed to a relicense, we can go ahead and flip the license of the individual source file.

Short story: If you have not done so yet, please add yourself to the kde relicensecheck.pl file!

If you cannot add yourself right now, please consider sending a mail to kde-devel@kde.org publically stating that you’re ok with relicensing all your contributions hosted on the KDE services under either GPLv23, LGPLv23, GPLv2+, LGPLv2+. Additionally, you can give the membership of the KDE e.V. the credentials to relicense your contributions in future (this makes a lot of sense if you cannot contribute to KDE anymore and are no longer around). Many of the KDE contributors did this already. Thanks! :-)

PS: The official way to give KDE the rights to change licenses would be by signing the KDE e.V.’s FLA. Please note, that the KDE e.V. will not abuse this by immediately changing licenses you chose. Instead, this mostly about emergency cases (think of someone who suddenly passes away). But the script mentioned above is already a good start, since we can use it to quickly scan our code and identify problematic parts.

Update: With signing the FLA, you give the KDE e.V. several rights:

update KDE SC license
can protect KDE projects/code
can proect you (e.g. in copyright lawsuits)
make sure your code will live on even if you can’t contribute anymore

It is important to note, thought, that signing the FLA also includes that the KDE e.V. gives you back all your rights, so for you and your contributions, nothing changes. There is a BOF session about all this on Monday, so make sure you attend if you’re interested!

KDE Applications Versioning

Sun, 26 Jul 2015 12:25:23 +0000

A common problem for many applications contained in the KDE Applications releases are non-incremented version numbers. Often the maintainer forgets to update the version number of the application, like I did it for Kate since the first KF5 based release.

This means: On Bugzilla, I get bugreports that always tell me “Kate 5.0.0”, not very helpful.

KDE Frameworks solves this by automatic setting of the current framework release version in all framework CMakeLists.txt.

For KDE Applications, we have now optional the same concept. For details: visit https://community.kde.org/Applications/Versioning

In short: If you are to lazy to update your version number yourself or are just fine with using the same version number als the KDE Applications releases, you can add the following three lines to your toplevel CMakeLists.txt:

# KDE Application Version, managed by release script set (KDE_APPLICATIONS_VERSION_MAJOR "15") set (KDE_APPLICATIONS_VERSION_MINOR "04") set (KDE_APPLICATIONS_VERSION_MICRO "0")

These variables will then be patched by the release scripts to the “right” version for the current release series.
You can than either just use the MICRO version to suffix your own applications version to differentiate the bugfix releases or like Kate construct your complete version number from the three vars and be done ;=)

I hope this helps to have more consistent and more important meaningful version numbers once again in the applications we bundle. Thanks to all people that made this “magic” happen ;=)

Reception of Plasma Mobile

Sun, 26 Jul 2015 10:04:04 +0000

The yearly KDE conference Akademy is currently being held with lots of interesting talks and workshops. One big thing that was announced yesterday is Plasma Mobile, a free mobile platform.

The presentation of Plasma Mobile was quite impressive: A video of using Plasma Mobile on a Nexus 5 showed a nice visual design, smooth transitions and quite some usable functionality already. This impression was confirmed later when I was playing around with Plasma Mobile on the Nexus 5 myself.

So good job, plasma team!

Plasma Mobile already raised quite some interest in lots of news sites, with lots of user comments (mostly positive), see for instance:

Slashdot: KDE Community Announces Fully Open Source Plasma Mobile
OSNews: Plasma Phone OS, a KDE project for mobile
Hacker News: Plasma Mobile
Reddit: Plasma Mobile on Nexus 5 (Kwin/Wayland in action)
Golem: KDE Plasma 5 läuft auf Smartphones (german)
Heise: Plasma Mobile bringt KDE 5 auf Smartphones (german)

What’s important to note is that the project is still in a very early stage of development, and its target is to be really usable around mid of 2016. As such, there are most certainly stability issues and lots of features missing.

But this also opens opportunities: If you are into mobile platforms, this is the right time to get in contact and contribute! The plasma developers are really nice people and welcome every single contribution, be it in terms of brainstorming ideas (e.g. graphical mockups), code, or organizing developer events. So get in touch now through the Plasma Mobile forums and through the Plasma Contributor Mailing List! Just say hi and ask how to get involved :-)

KF5 & Plasma 5 at work ;=)

Sun, 07 Jun 2015 13:46:25 +0000

In the last months, I didn’t get much time to work on Kate nor KTextEditor. Beside some small bugfixes and cleanups I got nothing commited :/

Guess one of the main issues is, I don’t use the KF5 based version of Kate that much ATM. At home, it is the only editor I use, but I have not much time to hack at home anyway.

Therefore today I installed the same setup on my work machine and will now use the KF5 based Kate for all of my day job, perhaps that motivates me more to take a look at the issues the Qt5/KF5 port still has. (And I will work in a KDE Plasma 5 session with most stuff KF5 based now, including all important stuff like the nice Konsole ;=)

First update: The Get It page got an update to show how to install KF5 based Kate/KWrite from kate.git on openSUSE 13.2 ;) Feel free to send in the needed hints for other distros (to kwrite-devel@kde.org).

Kate from KDE Applications 15.04 – KF 5.9

Sun, 03 May 2015 16:29:19 +0000

I reinstalled my home machine last week with openSUSE 13.2 and installed their latest 15.04 packages from the KDE repos ;=)

That is the first time that I use a distro-shipped Kate that is based on KF5 (and no other Kate 4.x is installed any more as escape route).

I think I already have seen 1-2 glitches (like not needed questions for reload and some repaint issue on reload), still, overall, I am happy with what is shipped as 15.04.

Thanks to all people contributing to KF5 and Kate 5.x! Well done!
And thanks to the packagers of 15.04, too. Nice to have up-to-date applications with just an additional repository to add!

Add yourself to the relicense checker script

Sat, 21 Feb 2015 10:28:54 +0000

From the KDE relicensing page:

A couple of KDE dependent projects or even libraries have moved or are going to move to GPLv3.

Unfortunately, GPL v3 is incompatible with GPL v2. This means that it is not possible to create a project linking GPL v2 and v3 code together. There is no problem for projects which are licensed GPLv2+ (version 2 or above).

A few parts of KDE are currently licensed as GPLv2 only. So far we have no reason to believe that this was something other than an oversight. However, we still need to validate with the individual copyright holders that a relicense to GPLv2+ or GPLv2+v3 is okay with them.

Therefore, in an effort we’re trying to identify the contributors that have contributed under the terms of GPLv2 and where the “+” part was not explicitly mentioned. If we know that all contributors agreed to a relicense, we can go ahead and flip the license of the individual source file.

Short story: If you have not done so yet, please add yourself to the kde relicensecheck.pl file!

What holds you on KDE

Sun, 11 Jan 2015 15:55:32 +0000

Look here, if you are interested.

Kate5 on Mac

Sat, 03 Jan 2015 16:52:44 +0000

Given that the KF5 based Kate works OK on Windows, I would like to get the Mac version up and running, too.

As virtualization of MacOS X is kind of “forbidden” and not that nicely usable anyway, as no nice accelerating drivers are available for the standard vm solutions, I just went out into the world and bought some Retina MacBook.

I followed the nice guide on https://github.com/haraldF/homebrew-kf5 (thanks Harald :=) and got some installed Kate/KWrite (after patching kio to skip X11 detection).

But ok, not that usable, at least without any investigation which env vars are missing per default you get a Kate that crashs or just shows the main window central content without any actions/menus/toolbars/sidebars/…

In addition, the application is scaled, as the manifest that tells we are able to handle retina bla stuff is missing.

Guess lots of work ahead, but given I have now some Mac, I will work on that in the following months ;)

P.S. I never had a Mac before and got often told by “Mac Fans” that I should switch to some “real” operating system from my stupid borked unusable cluttered hacky … Linux. Given that the new shiny MacBook directly stalled for ever during the guided “create your user and give us all your data” installation wizard on first boot, I am not that impressed ;=) My mother would have been stuck and after some googling that seems to be a “known issue”, at least for me, after a hard reboot, the thingy worked and I had a login, more luck than others :P

Qt 5.4 on Red Hat Enterprise 5

Mon, 22 Dec 2014 19:25:44 +0000

For my job, I need to take care of the support of old Linux distributions for our products, therefore I experimented in building Qt 5.x for Red Hat Enterprise 5 (or CentOS 5 or other clones).

Whereas Red Hat Enterprise 6 works more or less out of the box, to build Qt (even with WebKit and Co.) on Red Hat Enterprise 5, more work is needed. Even the xcb library is not yet existent there.

Therefore, here a small howto, for other people having problems with building it. It contains some hacks and any input is for sure nice to have as an comment (to help others to avoid my faults).

Disclaimer: I am not responsible for creating a completely messy and buggy Qt 5.x build :=)

First, lets assume you have some CentOS 5.11 box or chroot.

You will need some new development toolsets to get rolling:

wget http://people.centos.org/tru/devtools-1.1/devtools-1.1.repo -O /etc/yum.repos.d/devtools-1.1.repo
wget http://people.centos.org/tru/devtools-2/devtools-2.repo -O /etc/yum.repos.d/devtools-2.repo

I tend to use the version 2, version 1.1 does work, too (GCC 4.7.2 vs. 4.8.2).

We will needed EPEL, for a more up-to-date python (2.6, for xcb):

wget http://ftp.tu-chemnitz.de/pub/linux/fedora-epel/5/x86_64/epel-release-5-4.noarch.rpm
rpm -i epel-release-5-4.noarch.rpm

Then, lets install the minimal deps (I install both toolsets, you can choose one):

yum install devtoolset-1.1 devtoolset-2 python26 fontconfig-devel libX11-devel libXau-devel libXext-devel libXrender-devel

Then, get some compile shell ready:

scl enable devtoolset-2 bash

I will just for excercise build Qt and stuff into /tmp/usr/(qt)?

To build Qt, you need libxcb, get that (with deps):

# package config for xcb stuff
export PKG_CONFIG_PATH=/tmp/usr/lib/pkgconfig

# xcb proto
wget http://xcb.freedesktop.org/dist/xcb-proto-1.11.tar.gz
tar -xzf xcb-proto-1.11.tar.gz
cd xcb-proto-1.11
./configure –prefix=/tmp/usr
make -j8
make install
cd ..

# pthread stubs
wget http://xcb.freedesktop.org/dist/libpthread-stubs-0.3.tar.gz
tar -xzf libpthread-stubs-0.3.tar.gz
cd libpthread-stubs-0.3
./configure –prefix=/tmp/usr
make -j8
make install
cd ..

# xcb
wget http://xcb.freedesktop.org/dist/libxcb-1.11.tar.gz
tar -xzf libxcb-1.11.tar.gz
cd libxcb-1.11
./configure –prefix=/tmp/usr
make -j8
make install
cd ..

Now we are ready to build Qt 5.4, at least some parts ;=)
I skip here the GL stuff, I don’t need it and I skip some other modules.

# unpack qt
tar -xzf qt-everywhere-opensource-src-5.4.0.tar.gz
cd qt-everywhere-opensource-src-5.4.0

# no perf events => patch that out, won’t compile, at least not for me because of missing syscall/broken kernel header
sed -i “s/#define QTESTLIB_USE_PERF_EVENTS/#undef QTESTLIB_USE_PERF_EVENTS/g” qtbase/src/testlib/qbenchmark_p.h

# configure with some defines to work on centos 5 (fake some defines)
./configure -R ‘\\$$ORIGIN’ -D _X_INLINE=inline -D XK_dead_currency=0xfe6f -D XK_ISO_Level5_Lock=0xfe13 -D FC_WEIGHT_EXTRABLACK=215 -D FC_WEIGHT_ULTRABLACK=FC_WEIGHT_EXTRABLACK -v -opensource -confirm-license -sysconfdir /etc/xdg -prefix /tmp/usr/qt -release -shared -qt-zlib -qt-libpng -qt-libjpeg -qt-pcre -qt-xcb -qt-xkbcommon -xkb-config-root /usr/share/X11/xkb -no-xcb-xlib -c++11 -nomake examples -nomake tests -no-dbus -no-icu -no-opengl -skip activeqt -skip androidextras -skip connectivity -skip enginio -skip location -skip macextras -skip multimedia -skip quick1 -skip sensors -skip serialport -skip wayland -skip webchannel -skip webengine -skip webkit -skip webkit-examples -skip websockets -skip winextras -skip x11extras

# build and install
make -j8
make install

=> You have some Qt, but keep in mind you need to bundle at least the libxcb.so* library, as your Red Hat Enterprise 5.x guys won’t have it!

KDE at its very best!

Mon, 15 Dec 2014 21:32:53 +0000

Recently, there were some thoughts on where KDE is going, and related to that what’s the driving force behind it in terms of the pillars of KDE. Albeit it is true our development model changed significantly, I’m not convinced that it’s all about git.

No, I rather believe that it is the excitement about the KDE that makes it stand out – KDE as a community if you wish, but also KDE as a software project.

Going back to the late nineties, I was developing small games for DOS (Turpo Pascal, anyone? Snake and Gorillas in QBasic? :-) ) and also for Windows. At around that time, Linux got also a bit more popular so that I finally had a SuSE 6.0 in my hands. I installed it and was able to run KDE 2, iirc (?). It certainly was interesting, but then I also wasn’t involved in any free software projects, so it also wasn’t that a big deal.

Still, I started to look into how to develop GUI applications for Linux. Since under Windows I used MFC (oh well, now it’s out, but you know, I quickly got back on the right track) I found Qt quite nice (for CPoint you had QPoint, for CDialog a QDialog, and so on). As I used KDE in Linux, I started to change small things like an Emoticon preview in Kopete (one of my first contributions?), or some wizards for KDevelop in 2003. These were projects that were fairly easy to compile and run. Still, what might seem so little was a huge success for the following reason:

More or less still being child, getting in touch with C++, KDE, and all the tools around it was completely new. CVS? Never heard about it before, and anyways, what was a version control system? How it worked with the mailing lists. With entering a bug. Compiling kdelibs: It took me more than 2 weeks to succeed (Which btw. to myself proves that even at that time it was really hard for a newbe to compile KDE, just like today). All in all, these were times where I learned a lot. I started to read the cvs-commit mailing list (around 400 mails a day, I read them almost all, more than 5 years long).

But that was not yet it. It continued like that for years. For instance, understanding how KIO slaves worked was just amazing. How all KDE components integrate into and interact with each other. There were a lot of parts where KDE was simply the best in terms of the software technology it provided and created.

To me, this was KDE at its best.

In my opinion, KDE followed this route for a long time, also with KDE4. I even say KDE still follows this way today.

But it’s much harder to get excited about it. Why? Think of yourself as seeing snow for the first time. It’s just awesome, you’re excited and can’t believe how awesome this is. Or maybe also New Years eve with nicely looking fireworks coming. It’s something you simply can’t wait for enough. Kind of like a small child… This is the excitement KDE raised in lots of us. Getting a new KDE release was totally something I wanted. I saw the improvements everywhere. What also helped a lot was the detailed commit digest Derek Kite worked on so hard each week, showing what was going on even with detailed discussions and screenshots (today the KDE commit digest is mostly an auto-generated list of commits, which I already have through the KDE commit filter).

Today, I know all the details. All the KDE technology. Of course, it got even better over time, and certainly still is an immensely powerful technology. But I’m not that much excited about it anymore.

I believe this in itself is not an issue. For exactly this reason, developers come and go, leaving room for other developers to implement their ideas. It helps the project to stay young and agile.

It is often said, the KDE has grown up. This is certainly a good thing for instance in terms of the KDE e.V. supporting the KDE project as much as possible, or the KDE Free Qt Foundation that helps us to make sure Qt will always be freely available to us, or a strong background in legal issues.

At the same time, it is a very bad thing in terms of getting people excited about KDE. We need developers with freaky ideas who just sit down and implement new features (btw., this is very much true for all free software projects). For instance, why has no one come up with a better KXmlGui concept? I’m sure it can be done better!

Where does that put us? Is there really no cool stuff in KDE?

Well, the reason for this post is to show that we did not loose what once was cool. In fact, we see it every day. For instance, yesterday I was using Dolphin and had to change a lot between subfolders in the same level (e.g. from some_folder/foo to some_folder/bar and so on). I accidentally used the mouse wheel over “foo”, and whohooo! You can switch to the next folder just by scrolling with the mouse wheel over the navigation bar. This is immensely useful, and in fact, this is why KDE shines also today, it’s just not so visible to users and maybe also to developers. You now may say that it’s just some little detail. But this is exactly it: Yesterday I was totally amazed by how cool this is, just like 10 years back from now… Therefore, I say, this still is

KDE at its very Best!

Getting people excited about KDE is what defines KDE’s future, not git.

Edit (imho): I would like to add something here. When reading these kind of blogs, you may get the impression that KDE is getting a less and less attractive platform, or that KDE is kind of dying. This is absolutely not the case. Quite contrary: With KDE’s foundation libraries, and applications being about to released on top of the KDE Frameworks 5 libraries, KDE can certainly make the statement that the project and its software will definitely be available and certainly just as strong in 10 years from now. I have absolutely no doubt that you can count on that. And that is a really cool thing only few free software projects can claim! Let’s talk about it again in 2024 :-)

PS: On a unrelated note, KDE currently runs the End of Year 2014 Fundraiser. Support is very much welcome!

Kate5 on Windows

Sun, 30 Nov 2014 15:52:10 +0000

Here it goes, Kate5 running on Windows:This is an early version of Kate5 on Windows. It runs just fine but has some glitches, such as the ~~white lines between selected text lines, or wrong margins in the search&replace bar, or showing a ‘+1’ in the top right corner, although all documents are visible~~.

Update: After installing oxygen-icons and switching the font to Consolas (what Visual Studio uses), the glitches above are gone. Here is an updated screenshot:

So essentially it works, and if all goes well, we hope to provide a good text editor experience with Kate5 on Windows in the next year(s). To this end, we are currently discussing having a joint Kate/KDevelop/Windows developer sprint early next year.

You can support this also by donating to the End of Year 2014 fundraiser. Thanks!

Support Kate and KDE by Donating Money

Sat, 18 Oct 2014 13:46:59 +0000

Since some weeks, the Kate homepage features a way to support Kate and KDE by donating money to the KDE e.V., see this screenshot:

The reason for showing a donation pane might not be obvious, since the KDE project is open source and mostly developed by lots of contributors in their free time. So why do we need money?

The KDE project, and thus also the Kate project, highly depends on getting financial support. For instance, our IT infrastructure running the KDE websites and all sorts of services such as mailing lists or hosting KDE’s source code along with the version control systems rely on it. All these services need money. And here is where the KDE e.V., KDE’s non-profit organization comes into play. KDE e.V.’s purpose is the promotion and distribution of free desktop software in terms of free software, and KDE in particular, to promote the free exchange of knowledge and equality of opportunity in accessing software as well as education, science and research.

For instance, the KDE e.V. supports developers through travel reimbursement, such that contributors that could otherwise not attend developer meetings are still able to take part. These developer meetings have proven to be immensely useful to the success of KDE, and typically a developer sprint moves a project forward by magnitues, as you can see in the list of past developer meetings. Next to that, there is also the annual KDE conference where all KDE contributors and users are invited to discuss and shape the future of KDE. Next to other events, KDE is usually also present at fairs such as the CeBit or LinuxTag. There, we also need material and support to make a good presentation of KDE. Another significant job of KDE e.V. is to support KDE legally. For instance, the KDE e.V. is maintaining an agreement with the owners of Qt in terms of the KDE Free Qt Foundation, which potentially is also of high interest for companies using Qt.

Several days ago we also started the KDE End of Year 2014 Fundraiser, through which we hope to get a significant amount of money that we can plan with in the next year.

Please, if you use KDE at home or in your company, please make a donation. And if you are a company, please consider being generous! Your support is much more needed and appreciated than you might think! Thanks you!

Kate’s Mascot: Kate the Woodpecker

Sun, 12 Oct 2014 12:47:54 +0000

After the first KF 5 release, I contacted the creator of the Krita mascot Kiki and the KF 5 dragons artwork, Tyson Tan, if he would be interested in design a Kate mascot, too. He immediately agreed to help out and after some months of roundtrips, here we go!

Kate has a mascot: Kate the Woodpecker

The short design summary (by Tyson Tan):

Why a woodpecker? I said I was going to draw a humming bird, but she turned out to look more like a woodpecker, and the sound a woodpecker makes knocking on a tree is coincidentally similar to the sound of keyboard strokes).

Kate is female because of her name. I thought about other names like Klicky and Katherine, but I would rather save them for other future KDE projects to pick up as their names.

Design elements:
“{}” on the chest, “/” of the feathers, and “*” in the eyes.
The wing feathers also resembles multiple document tabs.
Color scheme inspired by doxygen source code highlighting.

And how does the first version of the mascot look like? Here is the mandatory version 1.0 mascot picture:

Tyson Tan allows that artwork to be Creative Commons BY-SA and/or GPL and/or GFDL licensed and donates it to the KDE Kate project.

This is version 1.0, changes might be made and more variants are possible in the future.

Thanks to Tyson Tan for this contribution, he rocks (more of his artwork can be found on his homepage). We will see the mascot soon a lot more on the Kate homepage and other Kate material.

This once more shows: the community shall never underestimate any non-code contributions. You designers, translators, documentation writers, …., that help us all out, you all rock!

Auto-loading Projects in the Projects Plugin (Kate 5)

Sun, 12 Oct 2014 12:18:00 +0000

Since KDE SC 4.10, Kate ships with the Projects plugin. This plugin provides an automatically generated structured list of files belonging to a project. Currently, in Kate 5, the Projects plugin looks like this:

What’s new in the Project plugin in Kate 5 since some weeks is an auto-loading feature. In 4.x times you needed to create a .kateproject file that was then read by the Projects plugin to populate the listview. This still works in Kate 5, of course. But if a .kateproject file does not exists, you can now still read the file list from the version control system. To this end, auto-loading for the respective version control system needs to be enabled in the settings (enabled by default):

We hope this is useful to you :-)

Kate needs you!

Tue, 23 Sep 2014 19:54:26 +0000

The next major step in Kate’s evolution is close: Kate based on KDE Frameworks 5.

Whereas it already works well enough for me (and others), it would be nice to clear out as many issues as possible before we have our first official KF 5 based release.

Our Bugzilla is full with smaller and larger Kate/KTextEditor (aka KatePart) issues, see:

Our bugs in the KDE bugtracker
Our wishes in the KDE bugtracker

Whereas Kate/KTextEditor has people working on it and continue to improve it over time, we don’t have enough people to keep track and care for all our reported bugs/wishs.

Therefore, if you have a clue about Qt and if you use Kate or any application using our KTextEditor editing component, like KDevelop, Kile, …. => Think about helping us out.

Here is a nice guide how to build KF 5 stuff.

We are happy to review your patches, any help is welcome!

(And yes, shame on me, during Akademy I found patches older than one year hanging around on Bugzilla, now applied, and still some controversial ones are floating around.)

Even if you are no developer, reviewing bugs/wishs and killing off issues that got already solved or are not applicable would already be a great help!

Kate and KTextEditor 5 after Akademy 2014

Sat, 13 Sep 2014 11:15:42 +0000

The yearly KDE conference Akademy just ended, so it’s time to look at what changed in the holy Kate in the Frameworks 5 land.

KTextEditor Framework

silent reload of document: Switching a git branch, Kate always pops up a dialog asking whether to reload the document. With this patch, if the document is version controlled by git, the git hash of the file computed and then it’s checked whether the file exists in git. If so, the file is reloaded without asking you. This should be very handy for developers using git! Thanks to Sven Brauch for this idea!
new highlighting unit testing infrastructure
several new syntax highlighting files
cursor down in the last line in the document moves the cursor to the end of the line, same for the cursor up behavior, after just 8 years a bugzilla wish becomes true ;)
properly load/save the search & replace history
fix kateversion tags in all our >200 highlighting files, thanks to Martin Walch
as always: lots of improvements to the vi input mode

Kate Application

use native dialogs on all platforms, including OS X, Windows
split view: action to toggle splitter orientation
the toolbar is by default turned off (see screenshot), resulting in a very cleaned up interface. You can turn it on in the Settings menu.
new document switcher plugin (see screenshot) through Ctrl+Tab, providing quick access to the most recently used documents (similar to Alt+Tab in kwin), based on KDevelops code
improvements to the tab bar
revive, cleanup and improve the text snippet plugin by Sven Brauch
projects plugin: autoload project even if no .kateproject is found (configurable to not clash with the auto-generated cmake .kateproject file), implemented by Michal Humpula
the Plasma 5 applet to start a Kate session is back, thanks to the work of Josef Wenninger

A big thanks to the organizers of this year’s Akademy, and a big thanks to all our sponsors and supporting members. The location was amazing and the venue allowed us all to have a very productive week! Looking forward to next year! :-)

Akademy 2014 – Soon ;=)

Mon, 01 Sep 2014 18:12:41 +0000

Only some days until the yearly Akademy starts.

Its a real great thing to get known to other KDE/Qt contributors and meet old and new friends.

Already amazed, lets hope the airlines don’t go on strike during my travel :=)

See you all there, lets have fun & be productive! Already now thanks to all people that help to organize this cool event and all our sponsors!

Kate “master” branch now KF5 based!

Thu, 24 Jul 2014 18:18:55 +0000

Hi,

from today on, the master branch of kate.git is KF5 based.

That means, for the next KDE applications release after 4.14, Kate will use the awesome KF5 stuff!

The KTextEditor framework is already in a good shape and most active KatePart development is since months pure KF5 based.

The same should now be true for Kate itself (and KWrite).

Pâté will need a lot of love, as PyQt5 is there, but PyKDE5/PyKF5 still in the works.

Happy hacking, help us to make KF5 based Kate awesome, too.

For 4.14: keep fixing bugs, but all new shiny stuff that might regress things really should only go into our KF5 based master branch!

Help to make KF5 awesome!

Mon, 02 Jun 2014 16:46:01 +0000

You like KDE software?

You like to have a polished and nice KDE Frameworks 5 release?

But you can’t help out yourself by coding, translating, bug finding, designing, documenting and whatever?

=> Feel free to fund our Randa Meetings 2014.

Perhaps it feels strange that a free/open source project wants money, but sprints & meetings are not for free, given you need to pay for the accommodations, travel, rooms for hacking, …

Therefore: Spread the word and help us to reach our fundraising goal!

Links about C++ and Programming

Tue, 13 May 2014 13:28:42 +0000

Just like some time ago, here are several links that might be of interest:

C++11 compiler support overview
Five new algorithms to C++11 that you should know about: Interesting read about std::all_of, any_of, none_of, is_sorted, is_sorted_until, is_partitioned and some others. (And here some more generic numeric algorithms)
noexcept – what for? An interesting read about C++11’s noexcept. Also interesting: Scott Meyers’ thoughts.
An overview of C++14 language features: Mostly highlights constexpr and auto
All about C++11 move semantics
Number and string conversion in C++11
What you should know about C++11
Lock-free data structures (part 1, part 2)
Use of assertions
Static code analysis of Qt5
Interpreter pattern vs. stack-based bytecode interpreter: very good introduction to bytecode interpreters
Overview of design patterns
Programming sucks: There is quite some truth in this, although this is probably less valid in open source projects.

Linux Voice – Kate wins the advanced text editors group test

Mon, 21 Apr 2014 16:21:23 +0000

Happy news arrived on the kwrite-devel mailing list with this post before Easter ;)

Kate has won the advanced text editor comparison in the Linux Voice magazine – Issue 2, yeah ;)

Nice to see that our work on Kate is awarded.

About Linux Voice: Seems to be some pretty new magazine about Linux & Open Source (Issue 2 says it all) and they promise to give 50% of their profit back to the Free Software community, developers and events. Hope that works out, it is a nice goal.

P.S. And yeah, this is just one comparison and no, lets not start the “editors wars, … edition” in the comments, there are a lot of text editors to choose between and depending on your needs and preferences Kate might not be your favorite ;)

Coming in 4.13: Improvements in the project plugin

Wed, 09 Apr 2014 20:01:29 +0000

Since version 4.10 Kate comes with a simple project plugin, as introduced here .
The project plugin works by automatically reading a simple json file and providing the information found there to various parts and plugins in Kate.

“Opening” a project

Projects are opened automatically by Kate. Whenever a file is opened, Kate goes the directories from that file upwards until it finds a file named .kateproject , which defines the project. This is a simple json file, which is intended to be written manually by the user.

The .kateproject file defines the name of the project, the set of files which belong to the project, and optionally commands for the build plugin .

In 4.13, “out-of-source” project files are now also supported (actually already in 4.12). What does that mean ? You can create a .kateproject file in some directory, but it will refer to a different directory as root of the project. This is useful if you have multiple build trees for one source tree, and then need different build commands for each build tree.

Creating such a .kateproject file is easy, simply add a top-level “directory” entry:

{
"name": "MyProject",
"directory": "/home/alex/src/myproject",
"files": [ { "filters": [ "*.cpp", "*.h"] } ]
}

So if you create this file e.g. in /home/alex/src/myproject-build/.kateproject, once the project is opened, the files below /home/alex/src/myproject/ will belong to the project “MyProject”. Again, to “open” this project, open any file in the same directory as the .kateproject file or any of its subdirectories in Kate. Kate will again automatically find the .kateproject file and load it.

Support for the improved build plugin

In 4.13 the build plugin has seen several improvements, the main one being that it is now possible to define an arbitrary number of targets, instead of being limited to 3. This is fully supported by the project plugin. Also the “old” format is still fully supported, and the .kateproject files can even contain both the old and the new format, so it works with the build plugin in version before 4.13 and also after.

Below there is a simple example for a hello-world project, which defines 4 targets for the build plugin: build all, clean, install and building just “hello”:

{
    "name": "Hello",
    "files": [ { "filters": [ "*.cpp", "*.h"] } ],
    "build": {
        "directory": "/home/alex/src/tests/hello/build",
        "targets":[
             {"name":"all", "build_cmd":"make -j4 all"}
            ,{"name":"clean", "build_cmd":"make -j4 clean"}
            ,{"name":"hello", "build_cmd":"make -j4 hello"}
            ,{"name":"install", "build_cmd":"make install"}
        ],
        "default_target": "all",
        "clean_target": "clean"
    }
}

So, for each target, a “name” and a “build_cmd” is defined, and that’s it. One of the targets can be chosen to be the default target (which can be assigned a dedicated shortcut in the build plugin), and one can be chosen to be the “clean” target (again, which can be assigned a dedicated shortcut in the build plugin).

The screenshot below shows what you get when opening this project in Kate:

[][1]

Build plugin showing 4 targets from a .kateproject file

I mentioned above that both the “old” and the new build plugin can be supported within one .kateproject file. To do that, simply put both target definitions in the file, they don’t interfer:

{
    "name": "Hello",
    "files": [ { "filters": [ "*.cpp", "*.h"] } ],
    "build": {
        "directory": "/home/alex/src/tests/hello/build",
        "targets":[
             {"name":"all", "build_cmd":"make -j4 all"}
            ,{"name":"clean", "build_cmd":"make -j4 clean"}
            ,{"name":"hello", "build_cmd":"make -j4 hello"}
            ,{"name":"install", "build_cmd":"make install"}
        ],
        "default_target": "all",
        "clean_target": "clean",
        "build": "make -j4 all",
        "clean": "make -j4 clean",
        "quick": "make -j4 install",
    }
}

Here, additionally to the 4 custom build targets, the three hardcoded targets “build”, “clean” and “quick” for the “old” build plugin are defined. When this project is opened in Kate 4.13 or newer, these three old entries are ignored, and only the four new entries are used. When this project is opened in Kat 4.12 or earlier, the four new targets are ignored and only the old ones are used.

In the case that an “old” .kateproject file is opened, which contains only the old entries, these are used, and the three entries are used to create three targets, as shown in the screenshot below:

[][2]

Build plugin showing 3 targets from an “old” .kateproject file

Using the project plugin with CMake-based projects

Until now, the only way to create .kateproject files was to write them manually. If you are using Kate with C/C++ projects which are built using CMake, there are more news for you. CMake 3.0.0 will be released soon, and among others, it will contain a generator for, guess what: project files for the Kate project plugin! With that, run CMake, select “Kate – Unix Makefiles” as generator, and there you go, everything set up ready to use for you, including all targets of the project available in the build plugin.

Below is a screenshot showing running cmake-gui on CMake itself:

[][3]

Running cmake-gui on the CMake sources, showing the available generators

As you can see, ninja is also supported.

Personally I still prefer Makefiles, especially for use with Kate projects. When using the Makefile generator, you get build targets for compiling every individual source file into an object file. This can save a lot of time when working on some source file and trying to get it to compile. Instead of starting to build everything, which involves dependency checking, and linking afterwards, you can simply just compile that one file (via the quick target select dialog of the updated build plugin), and if it failed, simply build the previous target again (there’s a shortcut for that) until it compiles, and then switch back to building everything (by building the default target).

In the screenshot below you can see Kate having loaded the project for CMake itself, listing the whole bunch of source files on the left, a long list of available build targets in the lower part, and the select-target-dialog on top, filtered already and the target for compiling cmMakefile.cxx is selected.

[][5]

Kate showing a full project for CMake itself

After trying to compile the file, Kate shows you which errors occurred, and using a dedicated shortcut (I set it to F9) it jumps to the line in the code:

[][6]

Build plugin: jump to error works

As can be seen, there is the parsed error, the status tells you that there were errors when building the target “cmMakefile.cxx.o”, and if you want to try again, there’s a “Build again” button right there.

Now, how do you actually open CMake-generated projects in Kate? The .kateproject file is generated in the build tree, and usually you never have to open any files from the build tree in Kate. But to open the project in Kate, you have to open any, at least one, file from the build tree (this will trigger searching the .kateproject file, which will point the project plugin to the source tree). To help with this, CMake additionally generates a file “ProjectName@buildDirectory.kateproject” in the top level build dir, right next to the generated .kateproject file. Open this file, and Kate loads the project.

[][7]

Loading a project via opening the “dummy” ProjectName@BuildDir.kateproject file

This has been done in the screenshot above, and already you’re ready to go !

Documentation

Last but not least, starting with 4.13, you can find documentation for the project json file in /share/apps/apps/kate/plugins/project/kateproject.example.

So that’s it for now, I hope you find the new stuff useful. :-)

Kate: What’s cool, and what should be improved?

Tue, 18 Mar 2014 10:59:06 +0000

This is sort of a poll: Please write in the comments below exactly

one line about what you like on Kate, and
one line what you want improved.

Please spread the word so we get a lot of feedback – Thanks! :-)

Coming in 4.13: Improvements in the build plugin

Sun, 16 Mar 2014 21:51:08 +0000

Kate comes with a build plugin, which supports running make, or ninja, or actually any arbitrary command directly from within Kate. This is obvisouly useful when using Kate as development editor, and this plugin has seen several improvements for the 4.13 release.

A small change, but for affected developers a major improvement, is that Kate can now parse warning and error messages from the Intel compilers, icpc and icc.
So for those of you using icpc, Kate can now automatically jump to the line of code which caused the error. Actually you don’t have to wait for 4.13 for this, it is already available since 4.12.3.

Beside that, there are improvements which benefit all users of the build plugin. Let’s start with a screenshot, which already shows one of the major changes.

[][1]

Build plugin showing the list of targets and the Build-menu

Up to 4.12, it was possible to create multiple “targets”, and each of these targets could contain a “Build” command, a “Clean” command and a “Quick” command. As of 4.13, the build plugin is not limited anymore to these three commands. As can be seen in the screenshot, every “target set” can now contain an arbitrary number of actual targets.
They are listed in a table widget. To add a target, click the green “plus”-button in the lower right. This will append a target to the end of the list. It can be edited by simply double clicking it (or pressing F2 while keyboard focus is in the table).
To delete a target, click the “minus”-button right next to the “plus”
One of the targets can be marked as the “default” target. This will typically be the target which runs “make all”. Additionally one target can be marked as the “clean” target, this will typically be “make clean”. For these two special targets separate keyboard shortcuts can be assigned, so they are always quickly available.

A whole set of actions which can be bound to shortcuts can be seen here:

[][2]

Configuring keyboard shortcuts for the build plugin

Now to the actually interesting part: building something.
There are multiple ways how to start building a target.

The default and the clean targets can be built directly using keyboard shortcuts, in the screenshot above I assigned F8 to the default target.
To build another than the default target, you can select the target you want in the table and then build it by clicking the blue “check”-button next to the “plus” and “minus” buttons.
For keyboard users, there is a quick-select dialog. It shows a list with the names of all targets, which can be filtered by typing part of the target name. That’s a really quick way to build any of the available targets. Here’s a screenshot:

[][3]

The Quick-select dialog for building a target

Once building has started, the output is displayed in the log view.
As can be seen, there is only one output tab left, where the “level of detail” can be adjusted using a slider. While building, the plugin automatically switches to the log display.

[][4]

Build plugin showing the output while building.

Also new, there is now a simple status display, which tells you which target is currently being built or was built previously.
Next to it, there is yet another way to start a build, the “Build again” button. Once some target has been built, using this button the same target can be built again. Oh, and there is now also a button to cancel a build, in case you forgot the assigned keyboard shortcut.

When building has finished, the output tab automatically switches to a parsed output mode, which lists the warning – and error messages. By double clicking on one of them or using the keyboard shortcut of your choice, I assigned F9, you can jump directly to the line of code which caused the error.

[][5]

Build plugin showing the parsed errors after the build failed.

All that together, should make the build plugin even more useful than before.
Have fun compiling ! :-)

Alex

Kate Part (KF5): New Default Styles for better Color Schemes

Fri, 07 Mar 2014 21:31:06 +0000

Kate Part gained 17 new default styles in addition to the existing 14 default styles. These changes are available for Kate based on the KDE frameworks 5 initiative and currently live in ktexteditor.git module.

Default Styles are predefined font and color styles that are used by Kate Part’s syntax highlighting. For instance, Kate Part always had a default style for comments. Therewith, the comments in all syntax highlighting files look the same (by default, a gray color). Or keywords are by default always bold and black.

However, during the last years it became apparent that the list of 14 default styles were not always enough. Consequently, lots of syntax highlighting files defined their own hard-coded colors. For instance, doxygen comments were hard-coded in a dark blue color. The problem with hard-coded colors is that they do not adapt when changing the default styles. Hence, doxygen comments were barely readable on a dark color scheme.

Therefore, a discussion took place on kwrite-devel (thread 1, thread 2, thread 3) that ended in 17 new default styles and a categorization of these as follows (the new default styles are bold):

Category “Normal Text and Source Code”

dsNormal: default for normal text and source code.
dsKeyword: Used for language keywords.
dsFunction: Used for function definitions and function calls.
dsVariable: Used for variables, if applicable. Example: $foo in PHP.
dsControlFlow: Used for control flow highlighting, e.g., if, then, else, return, continue.
dsOperator: Used for operators such as +, -, *, / and :: etc.
dsBuiltIn: Used for built-in language classes and functions, if applicable.
dsExtension: Used for extensions, such as Qt or boost.
dsPreprocessor: Used for preprocessor statements.
dsAttribute: Used for attributes of functions or objects, e.g. @override in Java, or __declspec(…) and __attribute__((…))in C/C++.

Category “Strings & Characters”

dsChar: Used for a single character.
dsSpecialChar: Used for an escaped character in strings, e.g. “hello\n”.
dsString: Default for strings.
dsVerbatimString: Used for verbatim strings such as HERE docs.
dsSpecialString: Used for special strings such as regular expressions in ECMAScript or LaTeX math mode.
dsImport: Used for includes, imports, modules, or LaTeX packages

Category “Numbers, Types & Constants”

dsDataType: Used for data types such as int, char, float etc.
dsDecVal: Used for decimal values.
dsBaseN: Used for numbers with base other than 10.
dsFloat: Used for floating point numbers.
dsConstant: Used for language constants, e.g. True, False, None in Python or nullptr in C/C++.

Category “Comments & Documentation”

dsComment: Used for normal comments.
dsDocumentation: Used for comments that reflect API documentation, e.g., the default style for /** */ comments.
dsAnnotation: Used for annotations in comments, e.g. @param in Doxygen or JavaDoc.
dsCommentVar: Used to refer to variables in a comment, e.g. after @param in Doxygen or JavaDoc.
dsRegionMarker: Used for region markers, typically defined by BEGIN/END.
dsInformation: Used for information, e.g. the keyword @note in Doxygen.
dsWarning: Used for warnings, e.g. the keyword @warning in Doxygen.
dsAlert: Used for comment specials such as TODO and WARNING in comments.

Category “Miscellaneous”

dsOthers: Used for attributes that do not match any of the other default styles.
dsError: Used to indicate wrong syntax.

Existing Syntax Highlighting Files

If the new default styles are not used, syntax highlighting files are backwards compatible to Kate Part in KDE SC 4. However, the plan is to use the new default styles where applicable to avoid hard-coded colors. To this end, the kateversion attribute in the language element will be set to 5.0 (yes, Kate Part’s version changed from 3 to 5 to match KDE frameworks 5) to avoid loading incompatible syntax highlighting xml files in older Kate Part versions. Example:

<language name="C++" kateversion="5.0" [other attributes omitted]>

With the new default styles, the Default Styles tab looks as follows:

In comparison, the KDE 4.x version looks like this:

The new default style colors are not fixed yet, so improvements and additional color themes we can ship with Kate Part by default are a welcome addition!

A Note at 3rd Party Developers

There are other implementations (such as in Qt Creator or for Haskell). If you developers read this, we encourage you to add these default styles as well once Kate Part 5 is released (stable). Otherwise, the new syntax highlighting files may not be compatible.

Jump to Next/Prev Modified Line

Thu, 20 Feb 2014 21:27:19 +0000

In KDE SC 4.8, Kate was extended by the line modification indicators. These indicators show you what lines currently contain unsaved data, but also lines that were once changed but now are saved to disk:

With Kate in KDE 4.13, we have two new actions in the Edit menu:

Move to Previous Modified Line
Move to Next Modified Line

In the screenshot above, moving to the next modified line does nothing, since we are already at the very end of the document. Moving to the previous modified line first goes to line 4, then to line 2, and finally to line 1. By default, no shortcuts are assigned, so if you you want to use this, it makes a lot of sense to configure shortcuts.

Modified and saved lines are treated equally, so maybe we should rather call it “touched” lines, since all lines that were touched by the user at some point in the edit history are taken into account.

The rationale behind these two actions is to allow fast navigation in the text that you actually work on. Jumping over hundreds of untouched lines is quite handy.

Hope this is useful :-)

Lumen – A Code-Completion Plugin for the D Programming Language

Thu, 20 Feb 2014 14:11:03 +0000

I am the original author of the Lumen KTextEditor plugin and I am happy to announce, I just committed it to the Kate repository for KDE 4.13!

Lumen is just the name for a plugin providing code-completion for the D programming language in KTextEditor/Kate and KDevelop. But Lumen is just a connection between the editor and the D Completion Daemon (a server providing all the information) called DCD. The plugin currently supports all major features of the completion server: feeding the server with import files, displaying documentation and several types of completion:

Imports:

Basic Completion:

Completion (overloaded Function):

Calltips:

To make Lumen work you have to install DCD, unfortunately no Linux distribution has DCD packaged so far. Luckily the D community provides a remedy.

For all Debian/apt based distributions like Ubuntu and Debian of course, there is the d-apt, simply follow the instructions on how to setup the apt-repository and install DCD via apt. For Archlinux exists an AUR Package. Everyone else has to setup DCD manually, but it’s really not hard, simply follow these instructions.

After installing DCD edit _~/.config/dcd/dcd.conf (create if it does not exist already) and add a path to your D include/import files (phobos), for me this is /usr/include/dlang/dmd_ (on ArchLinux), for other installations this would most likely be /usr/include/d. Furthermore Lumen will try to read a .lumenconfig in every parent folder of the currently opened D source file and add every line in this file as include path to the DCD server. Add all dependencies of your current project to this file.

Now start the completion server with dcd-server, enable the Lumen plugin in your settings and you will have code completion for the D programming language in your favorite editor!

Kate/KDevelop/Skanlite Sprint Wrap-Up

Sun, 02 Feb 2014 13:20:42 +0000

From 18th to 25th of January 2014, the Kate, KDevelop and Skanlite developers met in Barcelona to work on these projects full time for a week. Full time usually implies about 14 hours per person a day (yes, besides food, we do nothing but developing). 11 developers working 14 hours a day for 7 days makes a total of 1078 hours. If we divide this by 8 hours, the typical amount of work hours in a day, this makes 134 man-days of work, or about 27 weeks of continued development time. While this calculation is a bit theoretical, it is still very valid to estimate the amount of work that is put into these projects during such a sprint, especially since usually developers have far less time for development in their spare time.

The efforts focus mostly on KDE Frameworks 5, so what is listed next is mostly relevant only for the KF5/Qt5 version of Kate etc. Going through the Kate and Skanlite commits from 18th to the 25th of January, we have (not listing all commits):

January, 18th (arrival day):

KTextEditor::Cursor and KTextEditor::Range are declared as Q_MOVABLE_TYPE, telling Qt containers that these primitive types can be mem-moved without copy constructor.
since KTextEditor and KatePart are now merged into a single list, the API was changed such that KTextEditor::Editor::instance() is a singleton. Therefore, KTextEditor::Document::editor() was dropped, as it is not needed anymore.
vi input mode: new sentence text object
merged code completion models
some API cleanups
removed ModeInterface, which was never implemented

January, 19th:

vi input mode: enabled numbered registers for “q” command
removed hack setSuppressOpeningErrorDialogs
cleaner codeflow for default encoding
more API cleanups
merged HighlightInterface into KTE::Document
change Editor implementation such that it can be extended in a binary compatible way
make find previous button in searchbar in vi-mode work
change View implementation such that it can be extended in a binary compatible way
change Document implementation such that it can be extended in a binary comptible way
vi input mode: added “(” and “)” motions
run astyle on KTextEditor interfaces
API cleanup: return strings by value
port accessibility interface to Qt5 (more, more)
start of porting libksane to Qt5 and KDE Frameworks 5 (more)
make KateRenderer work without a view
add back KTextEditor::Document::print/printPreview() interface
file tree: add print actions to context menu
remove complex KTE::Document::textChanged() signal
libksane: remove compiler warnings
port the gdb backtrace browser plugin to Qt5 and the new KTextEditor plugin interfaces
adapt the Konsole plugin to interface changes
gdb backtrace browser: compile without kde4support
fix invalid disconnect due to new Qt connect syntax (tricky one!)
libksane: remove kde4support (more)
KTE::Document: do not emit signals on file close
gdb backtrace browser fully ported, ran astyle, add unit test
delete KTextEditor::Smart* convenience includes
KTextEditor::Editor is a singleton now
libksane: make make install work
KWrite: singleton cleanup
refactor KTextEditor module: part 1, part 2, part 3,
vi input mode: don’t launch commands through commandBar
remove autobrace plugin in favour of sanebrace plugin in KF5
vi input mode: add paragraph text object
KateScriptDocument cleanups
more interface cleanups
fix XML indentation after self-closing tags
completion model: properly emit layoutChanged
SQL plugin: start port, more porting, and more¸more, more, ....., done!
libksane: adhere to KF5 frameworks template, more, more, works
Skanlite: start porting to KDE Frameworks 5
port CTags plugin to KTextEditor framework
vi input mode: cleanups
vi input mode: remove vi specifics from KateCmdLineEdit
fix frameworks template

January, 20th:

fix cstyle indenter bug
cleanup cmake files
port File System Browser plugin to new KTextEditor plugin interfaces
fix porting bugs, more fixing
xml tools: port to new KTextEditor interfaces, remove kde4support, run astyle
huge KWrite code cleanup
let automoc do the work
move filetree “Documents” to addons folder, add Messages.sh
KMessageWidget: extend API, show example image in docs
remove tip of the day
fix generation of API documentaion, extend API documentation
removed KateScriptConsole, was unfortunately not used much
refactor unit tests, more
vi input mode: fix two crashes in undo/redo operations
use new KMessageWidget API in KatePart’s notification system
fix queuing of “Search Wrapped” messages
port GDB Plugin to new KTextEditor interfcaes in KDE frameworks 5
Skanlite: use cmake frameworks template
turn dynamic word wrap on by default
completion popup: better sorting
Build Plugin: add support for Intel icpc error messages
port Open Header plugin¸ cleanups

January, 21th:

Kate App: less friend classes, and even more less friends
Kate App: refactor waiter class
.kateconfig files are now always searched in ALL parent folders (not configurable anymore)
better recursion guard for .kateconfig lookup
DocumentPrivate::closeUrl() cleanup
Skanlite: port dialogs, use QApplication¸more porting
KTextEditor API documentation: KF5 porting notes” href=“http://commits.kde.org/ktexteditor/6d4b8dd991d936a6ad30be52dda9544e18aba603" target=”_blank”>porting notes
Search: Ctrl+H now sets cursor to end of selection
KTextEditor: start adding a default status bar
KWrite: use KTextEditor default status bar
Kate App: use KTextEditor default status bar
Status bar: finetuning
KTE::Application: add closeView/splitView, quit() methods
add API to disable default status bar
add Encoding and Mode to status bar
Status bar: port modified on disk notification
port close except like plugin
Open Header plugin: search list of open document before stating files
Skanlite: start porting KDialog to QDialog, fix help button, and more
Kate App: add built-in tab bar for switching documents in a LRU fashion
Kate config dialog: fix help button
template interface, use QHostInfo
port session chooser
Kate App: ViewManager cleanup
port the Build plugin to the new KTextEditor interfaces
word completion: remove beep()
Skanlite: fix about data handling, use QCommandLineParser
less *.moc includes

January, 22th:

vi input mode: expose more motions in visual mode

status bar: better sorting

tab bar: add tab also for documents without view

tab tracking: simplify, make tab switching work

tab bar tabs: track document name changes

status bar: fix sizing mess (part 1¸ part 2, part 3, part 4, part 5)

work around QSpinBox pluralizable issues

revert quick open shortcut

fix viewChanged() signals

search & replace plugin: fix signals

remove all tab bar plugins due to the built-in one

sync syntax xml file changes from master

Skanlite: fix layout¸more porting, less K classes

status bar: no resize between status bar, goto line and internal command line, more, more¸more

add split view actions to view space navigation tab bar

no document duplicates in quick open

fix broken scroll bars when opening remove files

derive KateViewSpace from QWidget instead of QFrame

remove focus rect from view

Fix painting bug when scrolling while floating widgets are shown

allow empty view spaces

cleanup of ViewManager and ViewSpace logic (1, 2, 3,

extend ConfigInterface: icon-border-color, folding-marker-color, line-number-color, modification-markers

Skanlite: bug finding in framworksintegration module, fix focus

status bar: make spaces and tabs configurable

use popup for split actions in view space bar

show short cut in tool tip (cool one!)

remove KTE::View::informationMessage() in favour of the MessageInterface

January, 23th:

Kate, KWrite: show modification asterisk in title bar

view space tab bar: refactor, polish, fix sizing of tabs, more

status bar: polishing, cleanups

relicense file tree

Kate’s view manager: cleanup, more cleanup¸more, more

KWrite: reformat to kdelibs coding style

Kate: reformat to kdelibs coding style

set Document read-only on too long lines wrap

view space tab buttons: elide if too long text

view space tab bar: add action “Close other Views“

avoid flicker in Kate

Kate: in fullscreen mode, show a button in the corner of the menu bar to escape the fullscreen mode

KTextEditor: add actions jump to bracket and select to bracket

API documentation: split docs

kate view space tab bar: implement correct document switching

tab bar: attempt for better sizing, again

API documentation: update porting guide

better order of elements in status bar¸not bold

Kate: turn SessionConfigWigdet into .ui-file

src/” href=“http://commits.kde.org/kate/751431df3eaa48b96cd905c7fff11e28da0aad86" target=”_blank”>refactor Kate source code

attempt to make tab bar work as expected, another one

Python plugin updates

Kate View Space: allow to maximize a view space (cool!)

refactor Kate View Space a bit

small cleanup of view manager¸ again

performance: use QHash instead of QList for lookups

more cleanups with respect to view/document management, remove more API, and more removal¸ more

fix bug in bash.xml

loading message for file with too long lines: provide button to reload without limit

January, 24th:

huge refactor of how document management works
fix view activation workflow
avoid empty view spaces
view manager: less public api
avoid hell breaking loose
document manager: less public api, same for view manager
include cleanups
move plugins, same for plasma launcher
improve expanding tree in code completion
tab bar: huge code cleanup, close action as context menu
avoid recursive opening of folders
Kate: add Recent File List count setting, more¸and done
double click on Line/Column in status bar: open goto bar
status bar: double click toggles INSERT/OVR¸and cleanup
Kate: less flicker caused by doc manager
remove api from editor
KateGlobal: less linear searches in lists
view space tab bar: add close button
no hard-coded plugin loading
resort status bar once more :-)
Kate Part’s default indentation is now 4 spaces (fix unit test)
Kate View Space: merge tabs of closed view space into active view space
fix indent option caused by indent width change
adapt message catalog to ktexteditor5.pot” href=“http://commits.kde.org/ktexteditor/5e5ea3bf69e62f9a09324ebb385af88f20477413" target=”_blank”>ktexteditor5.pot
cleanup TODO list
Kate: merge show/hide single-view-mode
KTE::Document: use a hash
Kate view space tab bar: allow to hide tab bar
KTextEditor plugins: allow with X-KTextEditor-Load-Default to add apps that load a plugin by default, implement in Kate
load Search & Replace plugin and File Tree by default
cleanup KTextEditor::TextHintInterface
avoid crash on first Kate start
status bar indent settings: "Other…"” href=“http://commits.kde.org/ktexteditor/9d06984a613e5827c8fedb7ed3caea4f5d90f2ea" target=”_blank”>indicate dialog with …

January, 25th (departure day):

nice breakfast with croissants, then to the airport :-)
double click in empty space in tab bar creates new document
swap quick open and window splitting buttons in view space tab bar
Projects plugin: only create tool views if applicable
port some commits from KDE 4 branch to KF5 branch
allow detection of HTML encoding
vi input mode: fix some unit tests¸more tests
same for file tree unit tests
Skanlite: more porting

In the days after the sprint we did a lot more fine tuning and cleanups with respect to the changes we did during the sprint. So let’s have a look at Kate before the sprint:

Kate after the sprint:

So Kate changed in several ways:

New status bar: The status bar is in the KTextEditor interfaces now. That implies that KDevelop, Kile, and all other applications using the KTextEditor framework will have the same status bar.
It is now possible to change the indent settings (tabs, spaces) through the status bar. The same holds for the encoding and the current highlighting.
Double click on “Line: …, Column: …” switches into goto-mode (Ctrl+G).
Double click on INSERT changes to OVERWRITE mode, if not in vi input mode.
New Tab Bar in each view space: This tab bar shows the documents you are working on in a least recently used (LRU) fashion. It only shows as many tabs as fit into the tab bar, since we want to avoid horizonal scrolling (it does not scale). If not all documents fit into the tab bar, just use the Documents tab on the left, or the quick open icon in the view space tab bar bar on the right to to launch quick open.
Since we now have a tab bar, we can now show the splitting actions at a more prominent place on the very right. New features include to hide inactive views, which equals maximizing the current view space.
Yes, no worries, the tab bar can be disabled.

We’ll cover the workflow of the tab bar in a separate blog post.

…oh, and we have much more in the pipe (not related to the sprint) :-)

Kate/KDevelop Sprint – Finishing Line

Sat, 25 Jan 2014 01:47:16 +0000

Saturday most Kate developers will depart, therefore now the most work has been finalized (or at least brought to some intermediate state that works OK).

Below, the mandatory screenshot, Kate started without any configuration set in the framework branch, new and shiny:

Find the differences :P

And one screenshot with some files open:

Kate/KDevelop Sprint – Status Bar Take 2

Thu, 23 Jan 2014 16:51:06 +0000

After the first initial status bar integration into the KatePart, we thought a bit more about what users might expect. Looking at the competition, one common feature is to allow quick-switching the indentation settings.

Joseph gave that a try and we now have an even better version available in the KF5 KTextEditor framework.

Mandatory screenshot (KWrite, Kate or other applications using it will look the same), updated version after feedback below:(Update: Using now again non-bold + Line/Column swapped with status)

Kate/KDevelop Sprint – Improved Status Bar

Tue, 21 Jan 2014 17:50:43 +0000

Just started to introduce a default status bar to KatePart.

Instead of forcing all applications to implement an own one with varying quality and features, it provides a default status bar that is an improved variant of the status bar of the Kate application. Now Kate and KWrite have exactly the same features there ;)

If the host application doesn’t want that, the KTextEditor interface allows to deactivate it completely.

The new status bar allows e.g. finally to switch the file mode (== highlighting) and encoding directly from the status bar ;)

Mandatory screenshot:

Kate/KDevelop Sprint – First Weekend

Mon, 20 Jan 2014 13:52:58 +0000

Here we sit, in Barcelona, hacking away at KTextEditor & Kate.
During the first 2 days, we already got some stuff done, like cleaning up KTextEditor interfaces and port more parts to KF5 (like ctags plugin, sql plugin, …).

More and more, KTextEditor & Kate get into a usable state for frameworks ;)
It is really good to have some free days in a nice location to focus on that goal!

We will not fundamentally change a lot of stuff but really concentrate on long term items we had on the radar for the 4.x => 5.x change and on having a GOOD 5.0 release that is as usable as the 4.x series with hopefully only as few regressions as possible.

Interfacing Lua With Templates in C++11

Fri, 17 Jan 2014 15:13:41 +0000

I thought I’d share a very interesting read about how to wrap the lua C bindings with C++11 variadic templates: part 1, part 2, part 3.

These type of cool articles pop up from time to time on reddit/r/cpp, so if you are interested in C++ topics, this is definitely worth to follow.

KTextEditor on Frameworks 5: Timing is everything

Sat, 11 Jan 2014 22:14:36 +0000

This is a follow-up to Aaron’s blog Frameworks 5: Timing is everything, put into the perspective of Kate and the KTextEditor interfaces. In short, Aaron suggests application developers the following:

When Frameworks 5 has a firm release schedule, then it makes sense to start coordinating application releases targets with that and syncing up development cycles.

I agree with this entirely, provided it’s really about applications. In the context of Kate, this is not the case, since the term ‘Kate’ usually also refers to the ‘KTextEditor’ interfaces along with its implementation ‘Kate Part’.

In essence, the KTextEditor interfaces together with Kate Part provide a text editor in a library that can be used by applications, or more to the point, KTextEditor+Kate Part build a framework.

In fact, about a week ago, the KTextEditor interfaces and Kate Part were split out of the kate.git repository. So from now on, kate.git contains the Kate and KWrite applications. The ktexteditor.git module contains the KTextEditor interfaces and Kate Part.

ktexteditor.git is is a tier3 framework and meanwhile officially part of the frameworks initiative: if you want so, KDE now provides 58 frameworks instead of the previously announced 57!

Why timing is everything

Now what about timing? Started on November 28th 2013, Christoph pushed the first compiling version of Kate into the frameworks branch. This was very good timing, since the split of kdelibs into all the frameworks was more or less just finished at that time. Or to put it the other way round: Christoph started porting Kate pretty much as early as the KF5 initialive allowed us – cool!

Around that time by coincidence, Michal started to work on Kate in the master branch and committed lots of cool features. However, since Kate was already rudimentary ported to Qt5 and KF5, the code base diverged more and more, so merging got more complicated. Therefore, Michal started to work in Kate’s frameworks branch. And within only a week (!), Kate, KWrite, the KTextEditor interfaces and Kate Part build without a single warning, meaning that the code was completely free of Qt4 and kde4support – wow! :-)

Again, a month before would have been too early – so this was perfect timing. The result was a pretty stable and mostly bug-free Kate in mid of December.

Well, not completely free of porting bugs. For instance, file saving did not work correctly, ending up in data corruption. It turned out that this was an issue in the framework karchive, which David Faure was able to reproduce and fix. This is good timing in the sense that without Kate’s usage of karchive, the bug would have probably ended up in the technical preview TP1. But it didn’t – yay! :-)

Last but not least, the Kate and KDevelop developers planned already months ago to have a joint Kate/KDevelop sprint from 18th to 26th of January, 2014. Given the current state of Kate and KTextEditor, this again is perfect timing, since most of the KTextEditor cleanup are already done. So the Kate developers can focus on the needs of e.g. KDevelop, on fine-tuning and implementing interfaces, etc. So in about two weeks, when our developer sprint will have ended, Kate will most probably shine as it never did before. And this is the case already now, even before a firm release date of Plasma 2 exists.

This is great news for Kate and all applications that use the KTextEditor interfaces, as Kate/KTextEditor already now reached a maturity that they never had before.

And this is so awesome! I cannot think of better timing :-) Thanks to all who made this happen!

Kate in 4.12

Thu, 09 Jan 2014 10:20:30 +0000

Since the KDE SC 4.12 release a month ago, it’s about time to look at the changes of Kate in 4.12:

Vi input mode: complete macro support
Heavily improved vi input mode
Multi-column text editing (thanks to Andrey Matveyakin)
MiniMap: align to the top (instead of vertically centered)
Projects plugin: modified files now show a modified icon
Improved C++/Boost Style indenter
in total, 21 issues (including wishes and bugs) were fixed

What comes next?

Kate will get more polishing in the next 4.x releases, for instance, in KDE SC 4.13 Kate optionally supports animated bracket matching.

However, as already mentioned in Kate in 4.11, the main efforts are put into making Kate on Qt5 and Frameworks 5 rock solid. Already now Kate, KWrite and Kate Part are fully ported, i.e. all are free of KDE4support libraries. A preview (already one month old!) can be found here.

Besides that, Kate and KDevelop again join forces and there is a developer meeting from 18th to 25th of January 2014. So expect quite some blogs about Kate on 5 then!

Kate Licensing

Fri, 03 Jan 2014 07:12:02 +0000

Hi,

a long time ago, the license of most parts of Kate/KWrite/KatePart/KTextEditor was LGPLv2+ (in the old time, where it was named KWritePart/Kant/…, the original KWrite had that license originally, at least all parts of the component of it).

Then, we changed that to be LGPLv2 (only).

It seems, that was a poor choice, as we now run in v2 vs. v3 vs. any later version problems.

Most parts of the code are easy to relicense, as the contributors either acknowledged the request to change the license to that to the Kate team (on kwrite-devel@kde.org) or added themselves to the relicensecheck.pl in kde-dev-scripts.git.

KTextEditor is now LGPLv2+ only, which is nice ;)

KatePart is only missing the re-licensing of some files.

Kate has more files to look at, but should be less a problem, as it has less people that did commits, compared to the part.

So, if you didn’t already get a mail from me about some “please allow on kwrite-devel@kde.org for license change to LGPLv2+” and you know you have contributed, even if it was only some patch, it would be really nice to get some short “I am ok with LGPLv2+” on kwrite-devel@kde.org.

That will make it much easier to sort out the remaining issues!

This really would help to have no licensing issues coming up in the future years and further incompatibilities. I really would like to strife for LGPLv2+ only code in KTextEditor/KatePart/Kate, at least in the core parts (e.g. without the plugins), which seems to be realistic in the short term to reach.

Thanks a lot and a happy new year.

Multiple Windows & Kate on KF5

Sun, 22 Dec 2013 17:16:40 +0000

In KDE 4, you can open a new window for Kate via “View -> New Window”.

This won’t start a new application instance but just add an other Kate main window to the current instance (which shows the same documents & session & projects).

This is kind of complex to handle internally and we think about dropping that behavior and instead launching just an other Kate application instance if you trigger that menu action.

Pro: Easier code structure, less to maintain, less bugs. Each window is an own process, e.g. if one crashs, not the others die, too.

Contra: You will loose the have the same documents open in two windows with syncing (as the two windows would then be individual processes).

Any opinions about that out there in the lazy web? Feedback is welcome.

Kate on KDE Frameworks 5

Sun, 08 Dec 2013 17:03:01 +0000

After the initial porting of KTextEditor interfaces and KatePart, now the Kate application itself runs on KF5, too.
It still has a LOT of issues (and I marked all commented out pieces with FIXME KF5), but at least, it launches and loads the essential file tree plugin and allows you to open files via the “Open” action. Any help in fixing the remaining issues is welcome (and removing deprecated cruft), but keep in mind, it might eat all the files you edit :)

That means now all stuff in the “frameworks” branch of kate.git beside the “addons” directory containing plugins/plasma stuff at least compiles and launches with KF5.

Now the question is how we handle further development. Shall we switch to “frameworks” for all major stuff in interfaces/part/application and only let feature work be done in the “master” branch for addons (which we then can port later on)?

Feedback is welcome ;)

Current State of Kate on 5

Tue, 03 Dec 2013 23:14:14 +0000

Just a quick update on the frameworks 5 port: KTextEditor, Kate Part and KWrite build and run. Kate is not yet ported and does not compile. These changes were already committed:

made KTE::Cursor and KTE::Range non-virtual for maximum speed
removed KTE::EditorChooser, since Kate Part is the only implementation since over 10 years. Just use KTE::Editor* editor = KTE::editor(); to get KatePart.
new signal KTE::Document::readWriteChanged()
removed KTE::LoadSaveFilterCheckPlugin, was unused since years
removed all KTE::Smart* classes in favor of KTE::Moving* classes
merged KTE::CoordinatesToCursorInterface into KTE::View
new: KTE::Range KTE::Document::wordRangeAt(KTE::Cursor)
new: QString KTE::Document::wordAt(KTE::Cursor)
new: KTE::DocumentCursor
ported lots of KSharedPtr to QSharedData
updated Mainpage.dox to reflect porting notes
some small interface cleanups and additions

Please feel free to join the porting fun. Just follow the Frameworks compile guide and checkout the git branch “frameworks” in the Kate git module.

Kate: “C++/boost Style” Indenter

Sun, 01 Dec 2013 19:36:38 +0000

Greetings from the Kate land again. This time, Alex Turbov will spend a few words about his “C++/boost Style” indenter that is part of Kate Part for several releases.

The Initial Motivation

This indenter (initially) was designed to help _code typing_ in a “boost::mpl” style (i.e. with leading comma in formatted (template) parameters list). One may read the rationale of such approach in the “C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond” by David Abrahams and Aleksey Gurtovoy. It is really easy to miss a comma when invoke metafunctions and it usually leads to a lot of complicated compile errors. The indenting technique should help to visualize the control syntax and prevent stupid errors like missed commas.

Small example:

typedef typename boost::mpl::fold<
typename boost::mpl::transform_view<
Seq
, boost::remove_pointer
>::type
, boost::mpl::long_
, boost::mpl::eval_if<
boost::mpl::less
, boost::mpl::_2
, boost::mpl::_1
>
>::type type;

In practice I’ve noticed that this style can be used to format long function calls or even `for` statements. Actually everything that can be split into several lines could be formatted that way. And yes, it is convenient to have a delimiter (comma, semicolon, whatever) as a leading character to make it visually noticeable.

// Inheritance list formatting
struct sample
: public base_1
, public base_2
, ...
, public base_N
{
// Parameter list formatting
void foo(
const std::string& param_1 ///< A string parameter
, double param_2 ///< A double parameter
, ...
, const some_type& param_N ///< An user defined type parameter
)
{
// Split `for` parts into few shorter lines
for (
auto first = std::begin(param_1)
, last = std::end(param_1)
; it != last && !is_found && !is_exit_requested
; ++it
)
{
auto val = check_some_condition()
? get_then_value()
: get_else_value()
;
}
}
};

It looks unusual for awhile :) but later it becomes (quite) normal and easy to read and edit :) Really! When you want to add one more parameter to a function declaration it takes less typing if compare to a “traditional” way :) (especially if you have some help from an editor, like move/duplicate the current line or a selected block up/down by a hot-key or having an indenter like this :)

Next improvements was designed to simplify typing C++ code, using most common syntactic rules, like:

add spaces around operators and after a comma
add space after control keywords, but not after a function name in a call expression
etc.

Further improvements bring to the indenter some cute features and nowadays I’d prefer to consider it similar to a T9 (input method) for C++ coding, but not as a “real indenter” in contrast to others, shipped with kate out of the box :) Particularly this indenter “exploit” can see “impossible” syntax and (try to) transform it to something “reasonable” — i.e. just like T9 it tries to be a predictive.

For example, if you have autobrackets plugin turned ON, when typing `some(nested(` gives you `some(nested(|))` w/ `|` indicating a current cursor position. If you press `,` at this position, it gives you the following snippet `some(nested(), |)` supposing that you want to add one more parameter to a `some()` call. While typing `;` looks like you’ve done with that nested calls and gives you the `some(nested());|` snippet. Both cases help you to avoid couple of redundant key presses ;)

… but do not even try to use this indenter to (re)format blocks of code! :) It can do some really simple/primitive formatting, but far from good — as I’ve mentioned above: this “not quite indenter”™ designed to help you to __”do little more with less typing”__ for C++ ;)

Some of the Features

to start a C-style comment block type `/` and press ENTER key — it gives you
```
/
```
| */

to start doxygen comment block use /** + ENTER. Every following ENTER just extend the current block.

to start C++ style comment just type `//` it will add a one space after ;)
I prefer to have on-line-comments (i.e. C++-style comments after some expression) to be aligned at 60th position. So typing `//` will automatically move comment to that position if there was some code before. Moreover the indenter tries to keep that comments when you use ENTER key to break some complex expressions into a few lines
```
// Before pressing ENTER at position marked by ‘|’
some_call_with_long parameters_list(|param1, …, paramN); // Comment starts here…
// After pressing ENTER: keep comment at the original line
some_call_with_long parameters_list( // Comment starts here…
|param1, …, paramN);
```
Also try to use ENTER in the middle of a comment text ;-)

typing `///` gives you `/// ` (with a space) or `///< ` depending on presence of code at the current line

from time to time I use grouping in a doxygen documentation, so typing //@ gives you:
```
//@{
|
//@}
```
always add a space after `,` character — simple, but really convenient! really soon you’ve stopped typing a space after any comma and feel yourself inconvenient with other indenters ;)
typing `<` without a space after some identifier adds a closing angle bracket (like notorious autobrackets plugin do for other bracket types), because template instantiation guessed. So typing `std::vector<|` gives you `std::vector<|>`. But `std::cout<|>` turns into `std::cout << |` after pressing one more `<` ;-)
a lot punctuation characters being typed withing parenthesis is a some operator (or at least part of), so will be moved out of parenthesis (most likely call expression). Try to type various punctuators at marked position in the following snippet `some(|)`…

typing a backslash in on a line of a long `MACRO` definition cause realign all others to fit to a longest line:

#define PP_FORM_A_ROW(State, Data, Elem) 

{ 

{ 

field_path( 

BOOST_PP_TUPLE_ELEM(2, 0, Data) 

, BOOST_PP_TUPLE_ELEM(2, 1, Data) 

, BOOST_PP_TUPLE_ELEM(2, 0, Elem) 

) 

, BOOST_PP_TUPLE_ELEM(2, 1, Elem) 

} 

, manage_config_keys::action::GET 

},

- typing `R”` will initiate a raw string literal

This advanced indenter has some other (smaller) features to reduce typing. Hope, you’ll like them if found! ;)

PS: The other things I’ve found useful when typing C++ code can be plugged with some Python plugins dedicated to C++.

KatePart/KWrite arrives in the KDE Frameworks 5 world

Thu, 28 Nov 2013 22:03:20 +0000

After starting the “frameworks” branch in kate.git more than a week ago but doing not much beside an initial KTextEditor compile & link port I felt a big guilty ;)

Given a lot of people blog about the progress of programs X and Y for Qt 5.2 and KDE Frameworks 5 I guess it is time that KatePart joins this club.

Some hours later, a ‘working’ version of KatePart and KWrite have landed in the “frameworks” branch of kate.git. KWrite launches, loads the part and the open action even works (command line parsing is off-line btw. ATM).

From the let it run ;) commit on, KWrite should at least launch and open files via file dialog and here is the mandatory screenshot (a KDE Frameworks 5 KWrite over an Kate 4.x window):

I marked all places where I commented stuff out or did a hack with “FIXME KF5” in a comment or “#if 0” region. Help welcome, Kate application still to be ported ;) But please mark your “hacks” in the same fashion, otherwise, we will never find them again.

To remember the history, the initial KatePart KDE 4 port happened more than 8 years ago, here a screenshots of that time (2005-05-15):

I think the first KDE Frameworks 5 version looks a bit better. Thanks a lot for all the people getting both the kdelibs frameworks branch in such good shape and all the contributors to Qt 5.x!

The Kate team will do its best to make the KDE Frameworks 5 version of Kate as popular as the 4.x variant is.

KDE Frameworks 5 & Kate, let the fun begin :)

Tue, 19 Nov 2013 21:42:03 +0000

After thinking some days about how to tackle the 4.x => 5.x transition in Kate (KTextEditor/Part/Application) and the nice “what we should do” blog by Dominik, I think the time for fun is there.

Therefore I started to port our stuff to KF5 in the “frameworks” branch.

The basic idea would be: get it compiling and running.

Then we can decide if the frameworks branch is a mere “hack to see if it works” experiment which can be later used to port master without a lot of work or if we say “ok, works kind of well” and we just switch development over for new features from master to frameworks and with that from 4.x to 5.x.

The KTextEditor interfaces compile now, KatePart should be the next thing to tackle. Then KWrite and Kate.

Happy hacking ;)

(To get a working KF5 development environment, just follow this howto.)

Kate on 5: The Future of KTextEditor and Kate Part

Mon, 11 Nov 2013 20:02:41 +0000

Recently, there was a dot story about Frameworks 5: Started in spring of 2011, the KDE software stack is undergoing a heavy split. The idea is to modularize the KDE libraries into lots of rather small units. Each unit has well-defined dependencies, depending on whether it’s in the tier 1, tier 2, or tier 3 layer, and depending on whether it provides plain functionality, integration, or a solution. If you haven’t yet, please read the article on the dot for a better understanding.

With this modularization, the question arises about what will happen to the KTextEditor interfaces and its implementation Kate Part – and of course all the applications using Kate Part through the KTextEditor interfaces, namely Kate, KWrite, KDevelop, Kile, RKWard, and all the others… The purpose of this blog is to give an answer to these questions, and to start a discussion to get feedback.

A Bit of History (Funny Read Here)

Since not everyone is familiar with “Kate & friends” and its sources, let’s have a quick look at its software architecture:

From this figure, we can see that the software stack has 3 layers: the application layer, the interfaces layer and the backend layer. KTextEditor provides an interface to all functions of an advanced editor component: Documents, Views, etc. (see also the API documentation). However, KTextEditor itself does not implement the functionality. So it’s just a thin layer that is guaranteed to stay compatible for a long time (for the KDE 4 line, KTextEditor is compatible since 2007, so as of now 7 years). This compatibility, or better yet _interface continuity_ is required, since applications in the Application layer use the KTextEditor interfaces to embed a text editor component. The implementation of the text editor itself is completely hidden in Kate Part. Think of a backend library implementing all the KTextEditor interfaces. When an application queries KDE for a KTextEditor component, KDE loads a Kate Part behind the scenes and returns a pointer to the respective KTextEditor classes. This has the advantage, that Kate Part itself can be change without breaking any applications, as long as the interfaces stay the same. Now, with KDE Frameworks 5, this principle will not change. However, interfaces will undergo a huge cleanup, as will be explained now. As a consequence, all nodes that point to or from the KTextEditor node, namely Kate Part on the backend layer as well as applications, will need to adapt to these interfaces.

Milestone 1: KTextEditor and Kate Part on 5

KTextEditor will be a separate unit in the frameworks split. Therefore, the KTextEditor interfaces will not come bundled with one monolithic ‘kdelibs’ as it was the case for that last 10 years. Instead, the KTextEditor interfaces are developed and provided in a separate git repository. This is already now the case: The KTextEditor interfaces exist as a copy in Kate’s git repository, and relevant changes were merged into kdelibs/interfaces/ktexteditor in the KDE 4.x line. For “KTextEditor on 5,” the first milestone will be to get KTextEditor compile with the libraries and tools from the frameworks 5 branch. Along with this port, the KTextEditor interfaces have a lot of places that are annotated with “KDE 5 todos.” That is, the KTextEditor interfaces will undergo a huge cleanup, providing an even better API for developers than before.

Currently, the KTextEditor and therewith also its implementation Kate Part use the KParts component model. The KParts model allows to easily embed Kate Part in other applications along with Kate Part’s actions and menus. Further, Kate Part internally uses KIO to load and save files to support network transparent text editing. KParts itself and KIO are both Tier 3 solutions. This implies that KTextEditor along with its implementation Kate Part are a Tier 3 solution.

In other words, a straight port and cleanup of KTextEditor and Kate Part will depend on a lot of high level frameworks. This solution will provide all the features the KTextEditor interfaces provides right now in the KDE SC 4.x line.

Currently, we plan one major change in the KTextEditor on 5: We will remove KTextEditor plugins. Over the last 10 years, we got close to no contributions to the KTextEditor plugins. Existing KTextEditor plugins partly clash with code in Kate Part (for instance the Auto Brackets with the Autobrace plugin), and merging the plugin’s xml gui into the KTextEditor::Views always requires some hacks to avoid flickering and make it work correctly. Besides, if the KTextEditor plugins are removed, for instance the Kate config dialog only shows one “Plugins” item instead of two. This is much cleaner to the user. Existing functionality, like for instance the “Highlight Selected Text” plugin, will be included into Kate Part directly. The same holds true for the HTML export feature. This is a bold change. So if you want to discuss this, please write to our mailing list kwrite-devel@kde.org.

The time frame for the KTextEditor port & cleanup is rather short: We want to provide rather stable KTextEditor interfaces so that other applications can rely on it. Therefore, we will probably create a frameworks branch in the Kate git repository in December (current proposal on kwrite-devel). Binary and source incompatible changes will be allowed until other applications like KDevelop or Kile are ported to Frameworks 5. Then, the KTextEditor interfaces will again stay binary compatible for years.

Milestone 2: KWrite and Kate on 5

KWrite is just a thin wrapper around the KTextEditor interfaces and therewith Kate Part. Therefore, KWrite will mostly support just the same functionality as it provides now. The same holds true for Kate. However, Kate itself provides quite a lot of advanced features, for instance to have multiple main windows (View > New Window), or sessions, and a good plugin infrastructure. Of course, Kate itself will also undergo cleanups: i) cleanups due to changes in the KTextEditor interfaces, and ii) cleanups like for instance moving the Projects plugin Kate itself, making it more easily accessible to other plugins like the Search & Replace or Build plugin. We will also remove support for multiple main windows through “View > New Window.” This is due to the fact, that many Kate plugin developers were not aware of this feature, and therefore completely messing up their code by not separating the logic from the view, resulting in crashes or broken behavior when using multiple main windows. Removing the support for multiple main windows, we will loose this feature. However, we get simpler and more maintainable code.

There are other small details that will change. For instance, as it looks right now, the Python pate host plugin in Kate on 5 will only support Python 3 (current discussion on kwrite-devel). Python developers, you are welcome to contribute here, as always! :-)

Milestone 3: More Modularization in the KTextEditor Interfaces?

Milestone 1 & milestone 2 will happen rather sooner than later (fixed dates will follow once we’re sure we can satisfy them). Since the transition to Frameworks 5 allows us to change KTextEditor interfaces, it is the right time to think how we can improve the KTextEditor interfaces and its implementation Kate Part even further. For instance, on the mailing list, the idea was raised to make the KParts model optional. This could be achieved for instance by deriving KTextEditor::Document from QObject directly, and create a thin KParts wrapper, say KTextEditor::DocumentPart that wraps KTextEditor::Document. This would be a major change, though, and possibly require a lot of changes in applications using the KTextEditor interfaces. As of now, it is unclear whether such a solution is feasible.

Another idea was raised at this year’s Akademy in Bilbao: Split Kate Part’s highlighting into a separate library. This way, other applications could use the Kate Part’s highlighting system. Think of a command line tool to create highlighted html pages, or a syntax highlighter for QTextEdits. The highlighting engine right now is mostly internal to Kate Part, so such a split could happen also later after the initial release of KTextEditor on 5.

Join Us!

The Kate text editor only exists thanks to all its contributors. Moving to frameworks, it is the perfect time to follow and contribute to the development of Kate. In fact, you can learn a lot (!) in contributing. In case you are interested, have ideas or want to discuss with us, please join our mailing list kwrite-devel@kde.org.

Animated Bracket Matching in Kate Part

Wed, 06 Nov 2013 15:20:43 +0000

Kate in 4.13 will have a new features: Animated bracket matching!

Since the feature might be visually distracting, it is turned off by default. To enable this feature, you have to go into the “Appearance” config page and check “[x] Animate bracket matching.” Due to feature and message freeze, this feature will be available in 4.13 and not in 4.12.

By the way, over the years we were asked several times to add the feature to jump to the matching bracket. This feature already exists. It is called “Move to Matching Bracket” and is bound by default to the shortcut “Ctrl+6”. You can change the shortcut in the “Configure Shortcuts” dialog.

Kate XML Completion: Converting DTD to MetaDTD

Sat, 26 Oct 2013 11:36:47 +0000

Kate has this nifty little plugin called “XML Completion.” This plugin loads a Meta DTD file and uses this information for context sensitive completion. To use it, you first have to load it in the settings dialog, and then assign a Meta DTD through the XML menu:

In our example, we work on a Kate XML highlighting definition file and therefore loaded the file “language.dtd.xml” which is shipped with Kate. Having assigned a Meta DTD file, we now have these nice code hints:

Kate ships with several Meta DTD files, such as HTML4 (strict, loose) or XHTML 1.0 transitional, KConfigXT DTD, KPartsGUI or XSLT. While this is really cool, you may ask about arbitrary DTDs you may be using. Unfortunately, Kate only supports Meta DTD, so what now?

Installing dtdparser

Luckily, the tool dtdparser (on sourceforge) converts a DTD to Meta DTD. We first need to install dtdparse. Since openSUSE does not provide a package (what about other distros?), I downloaded SGML-DTDParse-2.00.zip, extracted it and ran (see README file)

perl Makefile.PL

Make sure there are no missing perl dependencies. I for instance had to install perl-Text-DelimMatch and perl-XML-DOM:

sudo zypper install perl-Text-DelimMatch perl-XML-DOM

Then continue with the build and install process (the result of make test should be PASS):

make
make test
sudo make install

Now we successfully installed dtdparse on the system. So we are finally ready to convert DTDs.

Converting DTD to Meta DTD with dtdparser

Having installed dtdparser, it is as easy as calling

dtdparse file.dtd > file.dtd.xml

to convert a DTD to Meta DTD. The conversion should work out of the box. If you want, you can edit the generated .xml file, for instance the “title” attribute is always set to “?untitled?”. While this is not used by the XML Completion plugin (yet?), it’s still nicer to have it properly fixed.

Contributing Meta DTDs to Kate

Whenever you have a DTD that is of use also for other users, please send the generated Meta DTD to kwrite-devel@kde.org (our mailing list). Further, it would be really cool if someone added support to convert DTDs on the fly to Meta DTD, so the Kate XML Completion plugin would just work for DTDs as well. Any takers?

Call at Distribution Packagers

Please consider including dtdparser by default, as it seems to be a very useful too. Are there alternatives to convert DTD to Meta DTD?

Video Tutorials Learning C++ (in German)

Wed, 23 Oct 2013 13:39:43 +0000

I just stumbled over a really good tutorial on youtube that teaches C++ from the very beginning (in German). The tutorial is split into lots of small episodes, each about 10 to 15 minutes. The quality of these tutorials is very good in terms of video, voice and also contents. Subject is mostly “pure” C++ and later a bit of Qt is used, so it does not cover C nor lots of additional libraries. Still, if you want to understand the details, you might want to give it a try :-)

PS: The tutorials use Kate Part, just look at the code folding bar on the left. So the author is definitely doing something right :-p

Multiple Keyboard Layouts and Shortcuts

Mon, 07 Oct 2013 16:21:47 +0000

KDE has a very handy feature to switch keyboard layouts on the fly. This is for instance useful if you use the German keyboard layout by default, and the US layout for programming. To enable keyboard layout switching, go into System Settings > Input Devices (category Hardware) > Keyboard item > Layouts tab:

Here, ‘[x] Configure layouts‘ is checked, enabling the list view. I added the German keyboard layout, and then the English (US) layout. Notice also, that the shortcut is set to ‘Ctrl+Alt+K‘. Clicking apply, a tiny little indicator appears in the panel:

You now can quickly switch with Ctrl+Alt+K between the German and the US layout. Quite efficient, especially since the keyboard layout config page allows to switch the language on application basis.

Unchanged Keyboard Shortcuts

Switching the keyboard layout has one potential issue, though: The shortcuts remain unchanged. So if undo is mapped to Ctrl+z in the German layout, it is still mapped to Ctrl+z in the US layout. Note that by ‘z’ we refer to the hardware key on the keyboard. As a consequence, in the US layout, hitting the hardware key ‘y’ on the German keyboard inserts the character ‘z’, but the z in Ctrl+z is still on the hardware key ‘z’. This behavior may or may not be wanted.

Getting more into detail reveals that the order of the keyboard layouts in the first screen shot is of importance: If you first add the German ‘de‘ layout, and then the English ‘us‘ layout, then the shortcuts will always use the Germany keyboard layout, independent of what keyboard layout is chosen.

Reversely, if you first add the English ‘us’ layout, and then the German ‘de‘ layout, then the shortcuts will always use the English ‘us‘ keyboard layout.

So it seems that the order defines a priority, and the shortcuts always use the first entry in the list.

The correct solution to fix this would (in my humble opinion) be to add an option ‘[x] Shorcuts follow keyboard layout‘ or similar. But since this option does not exist, let’s do a quick hack to still get what we want here.

A Workaround

First we reset the shortcut in the settings of the keyboard layout options:

Click apply and close the dialog. Now, the shortcut ‘Ctrl+Alt+K‘ is unbound. Our idea is now to create a script that toggles the keyboard layout by calling setxkbmap with the appropriate parameters and bind this script via a global shortcut to ‘Ctrl+Alt+K‘.

To this end, we first have to create the script. So let’s first type `setxkbmap -query` in the console and check the output. For me, this results in:

$ setxkbmap -query
rules: evdev
model: pc101
layout: de,us
variant: nodeadkeys,

From this, we can follow that the current xkb layout is achieved with:

setxkbmap -model pc101 -layout de,us -variant nodeadkeys

Now, let’s switch the de,us to us,de and try the following:

setxkbmap -model pc101 -layout us,de -variant nodeadkeys

Notice, that the keyboard layout indicator in the panel switched to ‘us‘. Calling the first variant with de,us again, we get back to the German layout.

This discovery leads us to the following script switch-keyboard-layout.sh:

#!/bin/sh
# query xkb map: us,de -> us is primary; de,us -> de is primary
dummy=`setxkbmap -query | grep us,de`
# return value 0: us,de; return value != 0, de,us
if [ $? -ne 0 ]; then
# de is primary, now make us primary in list
setxkbmap -model pc101 -layout us,de -variant nodeadkeys
else
# us is primary, now make de primary in list
setxkbmap -model pc101 -layout de,us -variant nodeadkeys
fi

Save this script somewhere to switch-keyboard-layout.sh and make it executable with

chmod 755 switch-keyboard-layout.sh

Each time we execute this script, the keyboard layout is toggled.

Next, we go into System Settings again and navigate to Shortcuts and Gestures (Common Appearance and Behavior), there in the Custom Shortcuts we add a new Command/URL item named ‘SwitchKeyboardLayout’ as follows:

As a comment for this new item, we write ‘Switch Keyboard Layout‘, in the ‘Trigger‘ tab, bind the global shortcut to ‘Ctrl+Alt+K‘, and in the ‘Action‘ tab, choose the switch-keyboard-layout.sh script. Finally click Apply, and close the dialog.

Now, hitting Ctrl+Alt+K calls our script and correctly toggles the keyboard layout including the shortcuts.

Unfortunately, this approach does not support e.g. switching the keyboard layout on application basis as the switching policy of the Keyboard settings (first screen shot) allows. Still it works.

A final remark, though: For GTK applications this works out of the box. So is there any real reason why this is not the case for KDE / Qt applications? A real fix would be very much appreciated, I’d be also fine with an option. But not providing this feature at all is very thin ice…

Update: This issue was reported as KDE bug #197552 in 2009, and resolved as an upstream issue. However, it never was reported to Qt upstream. If I may say so, this is not how resolving bugs in KDE usually works. Grrr…

Multi-Line Text Editing in Kate

Mon, 09 Sep 2013 20:51:04 +0000

Right after the vim blog and the ‘what’s new in 4.11‘ blog we have another feature that was long requested and finally is available in 4.12: Multi-line editing in block selection mode.

Needless to say that it also supports undo/redo and pasting text. Kudos go to Andrey Matveyakin for implementing it!

Kate in 4.11

Mon, 09 Sep 2013 10:06:26 +0000

Another release cycle gone, and the KDE Software Compilation 4.11 is out in the open (well, for quite some time already), and with that it is time to talk about what changed in Kate the last half year since the 4.10 release. Besides the usual bug fixing (~50 bugs since 4.10), the following sections present some major improvements and features of Kate in 4.11.

Python Plugins

Since KDE 4.10, Kate features the Python »Pâté« plugin. This plugin basically wraps the API of all Kate application interfaces. Therewith, together with the Python KDE (PyKDE) bindings you can develop full-featured Kate plugins in Python. Being relatively new, there are quite some Python plugins available already now (see this blog, this blog, or this blog).

@Python community: You can interpret this as an invitation for writing lots of cool addons for the Kate text editor in python. All contributions are usually very much welcome!

Vi Input Mode

Enabling the vi input mode turns Kate into a full-fleged vim compatible editor: modal editing exactly like in vim. This mode is especially suited for vim users who want a fully KDE integrated text editor with all the beloved vim features. Started as GSoC project in 2010, the vi input mode evolved over the years to become a very mature alternative to vim itself. However, there is always room for improvements. The good news is, that Kate Part’s vi input mode gained a lot of attention thanks to Simon, mostly in the form of small “papercuts” that fixed small bugs and annoyances and made behaviour more compatible with Vim, including:

Yank highlighting, which helps you to see what text you just yanked;
“Yank to clipboard” (courtesy of Fabian Kosmale!);
The “last edit” markers, “.”, “[” and “]”;
Recursive vs non-recursive mappings, for if you want to e.g. map “j” to “gj” …
… plus plenty of fixes to gj and gk;
and countless other small tweaks to things like the “inner block” text object; cursor position after paste; fixes to ctrl-a/x (add to/ subtract from number under cursor); making more motions available in Visual Mode and more motions counted, etc!

One fairly major change is the introduction of an experimental Emulated Vim Command Bar. This, as you will probably have guessed, is a replacement for the current Search dialog that behaves more like Vim’s, allowing one to e.g. insert the contents of registers via ctrl-r; dismiss via ctrl-c/ ctrl-[ as well as ESC; work properly with both forward (“/”) and backward (“?”) incremental searches; use smart case for case-sensitivity; allow the use of Vim-style regex’s etc. As an extension to Vim, I’ve also added the ability to auto-complete words from the document via ctrl-space: not that useful for searching, but very useful for when you want to do a search+replace command (command mode (“:”) did not make it into 4.11, alas).

In 4.11, it is disabled by default as it is not yet ready for primetime, but may be enabled by setting the hidden config option “Vi Input Mode Emulate Command Bar” to “true”. It is much more powerful and featureful in current master (see the blog here!) and will likely be the default in 4.12.

New Text Folding

Back in KDE SC 4.8, Kate got a new code folding implementation as part of the yearly GSoC project. Compared to the previous implementation, the amount of bugs indeed reduced, but during the 4.9 and 4.10 release it became apparent, that the code folding was still not where it should be. Maybe writing a good code folding implementation was also a bit too much in terms of a newby developer in a GSoC project.

So Christoph sat down and wrote it completely new from scratch, this time very clean and simple. And as a new feature, the text folding is now per view, so the folded parts can be different in each view of a document. And as another feature for those who do not use text folding at all: Not using text folding means you have zero overhead, no matter how large the file. Besides that, code folding in Python works now better than ever before, in fact, it should be bug-free.

Passive Notifications & KTextEditor Interfaces

Passive notifications are meant to provide a non-intrusive way showing notifications (replacing KPassivePopup). Used e.g. by the data recovery, these notifications were also introduced for the search & replace feature (most of this is already available in KDE SC 4.10.3). In KDE SC 4.11, the interface for showing these passive notifications got officially included into the KTextEditor interfaces, meaning that applications like Kile or KDevelop can show notifications as well. (Issues in KDE 4.11.0 should be fixed for 4.11.1).

Next to the KTextEditor::MessageInterface, Kate has a so-called TextHintInterface since year 2003, but it seems its implementation never got finished. For 4.11, Sven Brauch stepped up and finally fixed the text hint interface. So showing tool tips for text under the mouse (section Text tooltips) is as easy as it was never before:

Saving Files

When saving files, Kate uses the class KSaveFile (in Qt5 available as QSaveFile thanks to David Faure). In short, to avoid data loss, KSaveFile saves the file to a temporary file in the same directory as the target file, and on successful write finally moves the temporary file to the target filename. If the folder of the file does not allow creating new files, KSaveFile automatically falls back to writing the file directly. In this case, data loss could happen if e.g. the system crashes in this moment, but saving the file would otherwise be not possible at all.

What Comes Next?

Announced just a few days ago, the KDE community prepares for KDE Frameworks 5 and much more: The KDE libraries and the KDE Plasma Workspace are now in long term support mode, meaning that bugs will get fixed for another two years. That means that the KTextEditor interfaces are frozen as well, there will not be any feature updates at all in the KTextEditor interfaces itself. Since Kate Part and the Kate Application are developed outside of kdelibs, Kate Part and Kate will most certainly see another feature release. Especially, since there are already a lot of improvements for the vi input mode in the pipe for Kate in KDE SC 4.12.

After that, we plan to port Kate to Qt5 and the new frameworks 5 libraries. We already added a lot of “KDE 5” todo-markers to the Kate source code, meaning that we will probably work on a 5 port rather sooner than later. We will address this schedule in a separate post later this year, so stay tuned!

Kate Vim Progress

Fri, 06 Sep 2013 15:13:50 +0000

Hi all,

Just an eye-glazingly brief blog post about some of the stuff I’ve been working on in the Kate Vim emulation mode since my last blog. Once more, I’ll mostly be dumping them all as bullet points, Gräßlin-Style™, with some longer sections on the more important changes, but this time around I’ve added some nifty animated gifs which you can skip to should the full text prove too harrowing!

In roughly chronological order, I:

Fixed regression with gv (“re-select last selection”).
Laid the groundwork for improved behaviour when repeating a change that involved an auto-completion, for now just fixing a bug where if auto-completion was automatically invoked and we repeat the change via “.”, only a portion of what we typed gets repeated.
As promised, implemented “yank highlighting”, which shows the portion of the text that you just yanked; very handy if you do complex yanks like e.g “y2f)”:

“Yank Highlighting”, 444KB, Click to Play.

Fixed a bug with keypad handling.
Made ctrl-p and ctrl-n wrap around in completion lists.

… and a biggie:

Emulated Vim Command Bar

There are quite a lot of issues with the interaction between Vim mode and Kate’s own Find dialog:

The cursor is not positioned at the beginning of the match.
The full match is not highlighted.
“?” does not search backwards(!)
The Find dialog cannot be used in mappings.
The Find dialog could not be used to either record or playback macros.
Aborts Visual Mode when summoned.

etc. On top of that, we miss out on some nice features of Vim’s search bars, such as ctrl-r for insertion of register contents; ctrl-w for deleting previous word; ctrl-h for delete; ctrl-b/e for jumping to the beginning or end (more conveniently located, IMO, than HOME or END); plus the Qt regex syntax is different from Vim’s. In light of this, I decided to add a new KateViewBarWidget called “KateViEmulatedCommandBar”:

“Emulated Command Bar Search”, 697KB, Click to Play. This behaves much more like Vim, and has the features and bugfixes mentioned above; it even does a reasonable job (in current master; it missed 4.11) of translating Vim regexes to Qt ones e.g. with Vim, a “+” is a literal “+”, not an “at least one of the preceding” marker; with Qt it is the reverse. The emulated command bar performs this, and other, conversions for you.

The searches carried out can be repeated correctly via “n” and “N”. Search history can be navigated via ctrl-p and ctrl-n, and searches “external” to the emulated command bar (e.g. those carried out by “*” and “#”) are added to this history. “Smart Case” is used for specifying case-sensitivity – if the search term has any capitals, then the search is assumed to be case-sensitive; else it is case-insensitive. More on the emulated command bar later! Back to the micro-fixes:

Distinguished recursive vs non-recursive mappings; inspired by this bug report which highlighted a nasty crashing problem if we tried to map j -> gj and k -> gk …
… and relatedly, completely reworked gk and gj, fixing a bunch of bugs in the process.
Yet more fixes to the “inner block” text object, which is much more complex than you would credit!
A bunch of fixes and patches to ctrl-a/ctrl-x (“increment/ decrement number under-or-to-the-right-of cursor”) culminating in me just writing the whole thing from scratch :)
Indented paste (]p, ]P etc).

Everything above made it for 4.11, I think. The Emulated Command Bar was disabled by default but can be enabled by setting the hidden config option “Vi Input Mode Emulate Command Bar” to “true”. Continuing:

Made “/” and “?”, when using the Emulated Command Bar, usable as (countable) motions: so one can, for example, do d3/foo to delete up to just before the third occurence of “foo”.
Allowed one to set the whole selection to a given text object even after we’ve formed a selection in Visual Mode e.g. you can start visual mode, navigate to inside a pair of brackets, and do “ib” to re-set the current selection to just the inside of that pair of brackets. I think this worked once upon a time and I broke it, so this is more of a regression fix than a new feature :/
Made the emulated command bar usable for Commands (like the “F7” command box in normal Kate) as well as for forwards and backwards searches when summoned via “:”. Note that since the emulated command bar is usable in mappings, we can now incorporate the execution of your Javascript script(s) into the Vim key mapping system, which could end up being a very powerful addition.
Allowed mappings for InsertMode and VisualMode as well as for NormalMode. Oddly, this was accomplished mainly as a side-effect of a fix for a tiny bug with mappings. There is no gui for this, yet, but I’ve implemented imap, vmap, inoremap, etc so they can be set from the command line. I’ve also added the special key for use in mappings, so that you can do e.g. imap ab cd to specify a mapping containing spaces from the command line.
Implemented “g~” (“toggle case” with motion).
A bunch more fixes for t/T/f/F to bring them more in line with Vim’s behaviour, especially when there aren’t enough characters to find.
Made ‘r’ (“replace single character”) counted, so it can actually replace several characters.
Made “\C” (“case-sensitivity marker”) work in the emulated command-bar search: this marker is used to specify that the current search should be case-sensitive (handy if you want a case-sensitive search for an all-lower-case search term) after which it is stripped out and ignored completely.
Made “//” and “??” (“repeat last search forward/ backwards”) work in the emulated command bar, and also allow the “/e” marker (“place the cursor at the end of the match”), although this latter is a little buggy at the moment.
Added fix for the usage of Alt-0, Alt-1 etc shortcuts in normal mode; this is for use with KDevelop’s automatic refactoring support which relies on these shorcuts (e.g. “Rename [variable] to [newvariable] Alt-0 | Hide Alt-1”, etc).
A bunch of fixes for J (“join lines”), including making it work in Visual Mode when the selection runs from top to bottom; not crashing if all lines are empty; fixing countedness (it would join one too many lines); cursor positioning after the join; etc.
Fixed occasional bug where counted inserts e.g. 5ixyz would start each repetition on a new line.
Implemented iW and aW (“inner/ a WORD”) text objects.

… and then on to:

Making the Emulated Command Bar Suitable for Default

The emulated command bar has a lot of advantages over the default Find dialog and command-line for Kate Vim users, but there are drawbacks, too: firstly, it can only perform regex searches and not literal searches, which is awkward when searching for complex expressions pasted from your document that may contain characters that have a special meaning when interpreted as regex’s (e.g. “*”) or which have special meaning in a Vim search bar (e.g. “/” when searching forward, and “?” when searching backwards). The necessity of going through the search term and escaping all such characters is a big strike against its use.

Secondly, Vim’s Find/ Replace dialog has most of the same flaws, when used in Vim mode, as its Find dialog has: in fact, incremental Find & Replace doesn’t work at all with Vim mode(!), and the emulated command bar is of no use here.

Since I’d really like to make the emulated command bar the default (and possibly only) option for use in Vim mode, I really needed to sort out a solution for these two dealbreakers.

For the first, there are basically two options: one is to add some kind of flag that says “look for literal matches for this string; don’t treat it as a regex!”; the other is to make it easy to perform the escaping of special characters. I eventually opted for the second, as it allowed one to treat portions of an expression as a regex if one desired, plus it allowed one to always use the same delimiters in a sed-replace expression (i.e. :s/find/replace/gci) without having to worry about whether the “find” term contained “/”‘s or not. So I added a shortcut (ctrl-g) to the emulated command bar that behaved much like ctrl-r (“insert contents of the following register”) except that it escapes the inserted register contents in such a way that a regex search for the contents would behave the same as a literal search for the contents. The gif below highlights the problem and the solution; the “:) :) :)” bit used ctrl-g to insert the (correctly escaped) yanked expression:

“Escape Expression for Regex”, 483KB, Click to Play. For the second problem, improving the good old sed-replace seemed the obvious choice, so I added some code in the emulated command bar to translate the regex in the “find” term from Vim style to Qt style. Kate’s own Find/ Replace dialog maintains separate histories for both the “find” and “replace” terms, so I needed to follow suit if I wanted the emulated command bar to be a credible replacement: if the cursor is placed over the “find” or “replace” terms in a sed-replace expression, pressing ctrl-p will summon the relevant history:

“Sed Search/ Replace History”, 259KB, Click to Play. Kate’s own Find/ Replace dialog makes it easy to focus on the “find” and “replace” fields, so I also added shortcuts “ctrl-d” and “ctrl-f” to the emulated command bar that clears and places the cursor at the “find” and “replace” portions of a sed-replace expression, respectively. As an extra bonus, ctrl-space can be used anywhere in the emulated command bar to complete words from the document, which is handy when filling out your find/ replace terms.

Still missing, though, were interactive search and replace; multi-line search; usage of \U and \L in the “replace” expression to make regex captures upper/ lower cased; etc. Multi-line search and \U and \L codes are available in a class called KateRegExpSearch, so I initially pulled out the guts of the SedReplace code and replaced it with that, and then made the whole thing interactive:

“Sed Multi-Line”, 399KB, Click to Play. (in the gif above, I constructed my regex with the standard “/” search bar so I could get immediate feedback as I am a giant regex baby who still needs his stabilisers; this final regex was then added to the “find” history, which I then added to the sed-replace search expression with a ctrl-d + ctrl-p).

The emulated command bar now seemed to me to be a decent alternative to Kate’s own Find/ Find & Replace dialogs, so with that out of the way, I then moved on to …

Macro Support!

The lack of macro support is what got me into Kate Vim hacking in the first place, so it seems weird that it ended up being almost the last thing I tackled. The reason, of course, is that macro support would be a bit crippled if we couldn’t run searches or execute commands in our macros, so I really needed to finish the emulated command bar first. It ended up being quite easy in the end; the main difficulty was in interacting with mappings, especially the situation where a mapping triggered a macro which in turn needed to execute another mapping! Anyway, here’s a small, real-life example of a Kate Vim macro in action:

“Macro”, 300KB, Click to Play. One difficulty with macros comes from recording and replaying auto-completions. In Vim itself, macros are “dumb” sequence of keypresses that are recorded and replayed verbatim, including those that summon, navigate and execute lists of completions. In Kate Vim, though, this approach doesn’t work so well, partly because the available completions at any time are less predictable (e.g. we could have a function appear in the list of completions when we record the macro, but not when we replay it, due to e.g. problems with the C++ parser etc) and also because, in KDevelop at least, the added completions are context-sensitive: for example, a completion of a function will add its own opening bracket if there is not one immediately after the cursor position, but will re-use the existing one otherwise. The “repeat last change” runs into a similar problem and has some measures to mitigate this, but is still far from fool-proof. The gif below illustrates the problem:

“Old Completion”, 184KB, Click to Play. In what probably represents the worst effort:payoff ratio in all of history, I spent a while re-working the macro recording and playback system to store attributes of completions as they occur, and then attempt to play them back using the same context-sensitive system; the “repeat last change” mechanism was re-worked to also use this system, so I’ll use that to demonstrate:

“New Completion”, 176KB, Click to Play.

That’s about it for macro support; now back to the small changes!

Fixed regression where opening a view and immediately giving it a selection (for example, by clicking an entry in KDevelop’s grepview) didn’t switch to Visual mode, leaving us with a “stuck” selection that we needed to manually enter & exit Visual Mode to clear.
Got rid of the baffling “No more chars for bookmark” message every time we set a breakpoint in KDevelop ;)
Fixed crashes with guu & gUU on empty line.
Implemented command-mode mappings (cmap etc) for use in the emulated command bar; this was prompted by my preference for using “ctrl-e” instead of “ctrl-g” for the “insert escaped register contents” (‘e’ is right next to ‘r’ on my keyboard) and for “ctrl-m” instead of “ctrl-e” (“jump to the end of the command bar”).
Implemented the *unmap (vunmap, iunmap, cunmap etc) family of commands for removing mappings from the command line.

… and that’s about it! I’m going to take a break from Kate stuff for a while to work on some other projects I’ve been neglecting, but will return to finish off some odds and ends later :)

The Kate Vim mode is in pretty good shape nowadays, so if you were thinking of trying it out, now (with the current master) would be a good time :)

Intel Threading Building Blocks Scalable Allocator & Valgrind

Mon, 29 Jul 2013 18:01:56 +0000

Hi,

if you ever use the TBB (Intel Threading Building Blocks) allocator to overwrite malloc/free/* and want to use Valgrind for leak checking and fail, here is the simple trick to get it working:

valgrind --soname-synonyms=somalloc=\*tbbmalloc\* <your-application-here>

I missed that hint in the Valgrind documentation for my first tries ;)

Btw., the scalable allocator from TBB is a really BIG improvement over the normal system allocator on current Linux & Windows machines if you allocate mostly fixed size small object, like what happens if you heavily use STL data structures like std::map/set that are implemented as trees and you have other stuff like DOM/AST like data structures (even in the single threaded case, for which it just saves a LOT of memory).

Ramblings about compilers…

Mon, 08 Jul 2013 20:03:52 +0000

In my job I work on binary and source level analysis software running on Linux and Windows. One of my tasks is to maintain the build farm and compile environment, therefore I am responsible for keeping care of the compilers and libraries we use (like the beloved Qt, congratulations for the nice 5.1 release, btw.).

For Linux, we normally use the GNU C/C++ compiler. That works out very well since years. We have hit compiler bugs only a few times and there was always already some patch-release out in the wild that fixed our issues. In addition the GCC developers brought a constant stream of improvements in the area of C and C++ standard compliance. I am more than happy with the GCC quality.

I did some brief experiments with LLVM/Clang two years ago and was not that impressed in the stability of the C++ support (especially of the fresh libc++ STL implementation) but even for a such young project, it was fast as light to get issues fixed, like a crash in the unordered containers (see Bug 10278, only some hours from report to fix, even if it was only a trivial size variable used uninitialized in the libc++ implementation). I guess today LLVM would perform ok to compile our software (including Qt), still I will stick to GCC, given we use some libraries that normally only get love for that compiler on Linux (at least at the moment).

But now, after my experiences with open source compilers, lets take a look at the wonderful world of Windows.

I know for Windows GCC variants are available (like the 32 bit MinGW-builds shipped with some Qt library variant) and some experimental work on some LLVM able to compile applications using Windows SDK headers is ongoing. Still, the most common way on Windows is to use the Visual Studio compiler and given we always have some libraries of 3rd-parties around that we need to use and that are Visual Studio compiled the Microsoft compiler is more or less unavoidable.

Now, lets take a look of this fabulous compiler you get there. At the moment two major Version are of interest, the 2010 and 2012 variant of Visual Studio.

As I started to evaluate Visual Studio 2010 in 2010, I was immediately hit by its nice 64 bit optimizer bug. Not a single Qt application would start up without immediate segfault… More about this here and even in the Qt bugtracker, especially the answers from the support are interesting, it seems to be forbidden to return a object per value from a function ;)

From report to “hotfix” it has taken some months, that means with the release version of 2010, you couldn’t build any optimized x64 application using Qt (and I guess most other evil libraries using object on the stack that got misaligned by the optimizer) for some months.

Afterwards I was that adventurous to install the SP1 to get the included further compiler fixes. Unfortunately that meant I got all my x64 compilers deleted, but no problem, just close to a month later (until which you need to reinstall your Visual Studio/SDK without SP1 and reapply you hotfix) you got again some fix that reinstalls the compilers that SP1 will remove. Really, you will need to install the 2010 + SP1 + then a fix that restores the compilers SP1 removes if you want to have a working VS 2010 Express for x64 (or stay without SP1 and use the above hotfix for the x64 compiler).

For Visual Studio 2012, which I started to eval months ago, you will get the same story, but reversed. Now we have some nice and nasty x86 optimizer bug. That bug is reported since long see here, it leads to problems for software that use libicu, see the matching icu bug. But given the simple code pattern that can make it occur, it may hit other parts, too. Until now, no fix, only some “will be fixed in next version”…

For me that means, I need to stick with 2010 for x86 and with 2012 for x64, given I want to use the pre-build Qt binaries and not to dive into the “compile qt on windows” fun once more. I would like 2012 for x86, too, to benefit from the C++11 feature improvements and to not have to support two different compiler variants, but I guess that will have to wait, seems its not that easy to build some working x86 compiler that can do optimizations.

Therefore, really, +1 to the compiler developers of the GCC and LLVM project. Its amazing what they have archived!
And +1 for the improvements in the C99 and C++ area in Visual Studio, too. Still I really would be more than happy to get a fix for the x86 optimizer issue in VS 2012. Even no report that it is really fixed in 2013 until now, but I am not sure that was really tried, I didn’t try it myself because I am lazy and must blog instead ;=)

QUndoStack versus Kate’s Undo System

Tue, 25 Jun 2013 09:08:57 +0000

I’m currently using QUndoStack in a project of mine. A QUndoStack contains a list of QUndoCommands which then can be executed with QUndoStack::undo() and QUndoStack:.redo().

Now I thought when deleting an instance of the class Node, I can just hock the creation of the respective UndoDeleteNode class (derived from QUndoCommand) into the destructor, like this:

class Node {
public:
// ...
~Node() {
undoStack()->push(new UndoDeleteNode(this));
}
};
class UndoDeleteNode : public QUndoCommand {
public:
// ...
void undo() {
// create node again
}
void redo() {
// delete node again
}
};

Now the problem with this code is, that executing UndoDeleteNode::redo() will delete the node through the undo/redo system. In this case, the destructor ~Node() will create another UndoDeleteNode item. So what I was looking for a way to only create the undo item when the undo/redo system is not active, i.e.:

class Node {
public:
// ...
~Node() {
if (!undoStack()->undoOrRedoRunning()) {
undoStack()->push(new UndoDeleteNode(this));
} 
}
};

I found QUndoStack::isActive(), but isActive() does something completely different. In fact, it looks as if there is no way to tell that the QUndoStack is currently operating. This finally also gets clear by reading the API docs of QUndoStack::push(QUndoCommand* cmd):

[...] Executes cmd by calling its redo() function. [...]

In other words, each QUndoCommand you push on the stack is executed immediately. This obviously is a design decision: Following this paradigm, you should not just call “delete node;” Instead, you should simply create a UndoDeleteNode() instance and push it to the stack. The undo command is then immediately executed by calling redo().

This design has the advantage that developers are forced to go this route. Following this paradigm, you very easily get macro support, since all actions are undo/redo items. This is cool.

However, what I dislike about this approach is the fact that it seems you loose the nice API to simply delete the node. You cannot write “delete node;”. Instead, you have to have some helper class such as a Document, that provides a Document::deleteNode(Node* node) function. This function then just creates a new UndoDeleteNode and pushes it to the stack.

Is this how the QUndoStack is supposed to be used? Does it imply that the destructor should be protected, and UndoDeleteNode must be a friend class of Node, to avoid other classes from just calling delete Node?

In Kate, we indeed go the other way: We have a KateUndoManager::isActive(), which indicates whether the edit actions should be tracked by the undo manager or not…

I’m not yet convinced that the approach of QUndoStack is ultimately cool. To me it looks like I’m forced into some design decision I didn’t want to take. Maybe I’m missing something?

Akademy 2013

Thu, 20 Jun 2013 07:08:01 +0000

So Akademy 2013 is nearing and this time it takes place at Bilbao, Spain. As it happens, Bilbao is located quite near to the beach as well as very close to the mountains. So I stumbled over a page with several hiking trails starting in Bilbao ranging from easy to hard. For instance, this route starts in a nearby village and then goes from about 65 meters in height up to 1000 (this is the point where you stop to hack on KDE, of course), and then down to 30 in Bilbao again. Anyone? :-)

PS: Maybe there are any locals who know the place around and can recommend a hiking track?

How to convert pdf to svg

Sat, 01 Jun 2013 14:24:01 +0000

In a project I’m currently working on I need to display the result of TeX code. So I thought it would be nice and accurate to compile the TeX code to produce a pdf, and then use libpoppler-qt4 to draw the pdf. This works in principal, but there is a licensing problem: libpoppler is GPL, and I want to use it in a LGPL library.

So I searched the net and found dvipng, which converts a dvi file to png. It even supports transparent backgrounds. So I could convert the dvi file to png through QProcess+dvipng, and then display the png file. This works, but whenever you scale the canvas the result looks ugly since png is not a vector graphic.

Next, I found pdf2svg that converts a pdf file into the scalable vector graphics format svg. In theory, I then can use QSvgRenderer to load and render the SVG on-the-fly using QSvgRenderer::render(QPainter*, …). So I first tested to convert the pdf to svg with this tool and then view it in InkScape. The result was perfect: InkScape renders the svg file exactly like Okular renders the pdf file:

So I looked into the source code of pdf2svg and saw that it uses libpoppler with Cairo. This reflects an additional dependency on cairo, so I went ahead and converted the cairo based code to Qt, using libpopper-qt4. The code basically boils down to:

// create poppler pdf document
Poppler::Document *document = Poppler::Document::load(args[1]);
document->setRenderBackend(Poppler::Document::ArthurBackend);
document->setRenderHint(Poppler::Document::Antialiasing, true);
document->setRenderHint(Poppler::Document::TextAntialiasing, true);
document->setRenderHint(Poppler::Document::TextHinting, true);
document->setRenderHint(Poppler::Document::TextSlightHinting, true);
document->setPaperColor(Qt::transparent);

// prepare QSvgGenerator as QPaintDevice
QSvgGenerator svgGenerator;
svgGenerator.setResolution(72); // resolution in dpi
svgGenerator.setFileName("out.svg");
svgGenerator.setSize(document->page(0)->pageSize());
// perform painting
QPainter painter(&svgGenerator);
document->page(0)->renderToPainter(&painter);
painter.end();

This code does indeed generate the svg code for the pdf file. However, the result is surprisingly ugly and wrong:

First, the pen seems too thick, and second the character ‘d’ is wrong on the left. I’ve tried changing the resolution (setResolution()) and also the page size (setSize()) of QSvgGenerator, always getting the same result. Searching the net reveals that QSvgGenerator seems to have quite some glitches with respect to WYSIWYG rendering. I tried to use QSvgGenerator before in 2009 and came out with unusable results. Maybe I’m missing something?

Update 1: It’s not QSvgGenerator that is to blame here. It’s indeed the Arthur backend of libpoppler. I send a patch to the poppler developers that fixes the issue with too bold glyphs. The pahts are still too inaccurate, though.

Update2: Using dvisvgm with the option –no-fonts results in an SVG file that QSvgRenderer renders correctly. So this is the current solution to get a TeX document rendered via SVG in Qt.

A rich python console and more in Kate editor

Fri, 31 May 2013 08:32:48 +0000

I have done some improvements in the plugins: python_console_ipython, python_autocomplete, python_utils, js_utils, xml_pretty and django_utils. These plugins I added a month and a half ago (except python_console_ipython) to the kate repository. I have done two improvements and a new feature:

Now they work with Python2 and Python3 (except python_autocomplete, this only works with Python2, due pysmell dependence)
Now they have a configuration page (except python_autocomplete, this should not have configuration parameters)

Page Config Plugins

The new feature is the integration of the python_autocomplete and python_console_ipython plugins with the project plugin. The behaviour of these plugins depends of the loaded project. That is to say, the python_autocomplete plugin autocompletes with our project modules. Currently the kate community is working to add a new python autocomplete using jedi (this will work with Python2 and Python3).

Python Autocomplete (with our modules)

And the python_console_ipython plugin has something that we can name the project console. A ipython shell with the python path of our project and with the environments variables that the project plugin needs.

IPython Console (converted in a django shell)

To use this we need to add in the project file (.kateproject) a new attribute named “python”, with this structure:

{
"name": "MyProject",
"files": [ { "git": 1 } ],
"python": {
"extraPath": ["/python/path/1",
"/python/path/2",
"/python/path/n"
],
"environs": {"key": "value"},
"version": "3.2"
}
}

I am a django developer, as we say in Django we can come to have a django shell (python manage.py shell) integrated in our editor. But this feature is a generic feature not tied to Django. This feature can be used by other Python developers. I have added only a specific feature to the django developers. If we set in the project file (.kateproject) the attribute projectType with the value Django, the ipython shell automatically loads the models and the settings like a shell_plus does.

{
"name": "MyProject",
"files": [ { "hg": 1 } ],
"python": {
"extraPath": ["/python/path/1",
"/python/path/2",
"/python/path/n"
],
"environs": {"DJANGO_SETTINGS_MODULE": "myproject.settings"},
"version": "2.7.3",
"projectType": "django"
}
}

I hope you like it :-)

Google Summer of Code 2013

Sun, 14 Apr 2013 09:04:30 +0000

If someone is interested in doing some coding for Kate-Part, Kate, KTexteditor during this years Summer of Code, just drop a proposal at the kwrite-devel mailing list for discussion.

Kate D-Bus Interfaces, used at all?

Fri, 05 Apr 2013 22:35:49 +0000

I just started to clean up the content of kate.git, moving things around, fixing compile warnings and similar stuff.

I stumbled over warnings in our dbus interfaces.

The main use of them is to allow Kate to reuse an existing instance for opening files and sessions. This part (e.g. the interface of the application object itself) works fine and is needed.

But all other interfaces, like the ones for docmanager, mainwindows, … are mostly non-existant or not implemented. I now play with the idea of just removing the nearly empty skeleton implementations, as it seems nobody missed them during the complete 4.x series.

Is there somebody out there that actually uses them and if, how?

Kate: Search & Replace Notifications in KDE 4.11

Tue, 02 Apr 2013 19:31:50 +0000

In KDE 4.10, the “Find All” and “Replace All” highlights all matches and at the same time shows a passive notification in a bar below the view. This bar is animated, and takes quite a lot of place in addition to the search & replace bar.

Since some days, Kate Part can also show passive notifications floating in the view. Hence, we’ve changed the passive notification to appear on the bottom right as a small info message, showing the number of matches. However, in order to make this passive notification as small as possible, we removed the “Close” button, since the notification is hidden after 3 seconds anyway. Further, we removed the “Keep Highlighting” button. If you want to keep the highlights, just do not close the search & replace bar. The following video demonstrates this behavior, first for KDE 4.10, then how it currently will be in KDE 4.11 (watch the video in 720p):

New Text Folding in kate.git master

Wed, 27 Mar 2013 21:16:45 +0000

In the kate.git master branch the text folding is now new and shiny.

In addition to be faster and less memory hungry (no folding tree is around if you fold nothing, it is only created on-demand exactly for the folded regions), the new code is less complex and smaller (and hopefully better documented + unit tested, it actually has a test for most internal operations).

There is actually now a clean separation, the folding does not mix with highlighting and can be used without it, too.

This allows for a better integration of indentation based foldings like in Python (and already fixes the most ugly miss-placements of folding regions there) and empowers the user to fold arbitrary regions manually.

This can be done at the moment with two kate commands (for the F7 command line):

“fold” will create persistent fold for the current selection, this fold will stay until next reload of document (will implement some dfold command later, to delete it)
“tfold” will create temporary fold for the current selection, this fold will disappear again on unfolding

This should allow better vi mode integration, too, as vi is able to fold arbitrary regions, too. (There is an internal API to fold any KTextEditor::Range you pass in, which should allow to fold by regex and other ways, too, if somebody steps up to implement it.)

If you find glitches, please report them as bugs and please attach some file to reproduce, I am very interested to get this all in even better shape for KDE 4.11, be folding crashs a thing of the past.

P.S.

For all people not using folding at all, be happy, it no longer will crash you (and me), as it is a nop if no folding ranges are created by the user and some extreme cases got a speedup of 1000% because of less overhead, like VERY large C++ sources ;)

Text Folding Reloaded

Sun, 24 Mar 2013 15:54:59 +0000

If we look at the incoming bug reports, a lot still seem to be located in our code folding implementation.

The problem of the current code folding code, even after the GSoC rewrite of large parts, is that it is inter weaved with the syntax highlighting engine.

During highlighting, we try to build up some tree containing all folding start/ends. To accommodate languages that have indentation based folding like Python, we started to fake such starts/ends which are normally tokens like { or }. As these tree can be unbalanced and contain overlapping regions, the implementation is quiet complex.

Additionally, as the folding relies heavily on the syntax highlighting, which is done per document, it is impossible to have different folding per view.

After looking again at the code to solve some issues, it got more and more clear to me, that we need to restart that from scratch.

Instead of feeding the highlighting info into a tree, I started to implement text folding that just allows you to mark regions as folding ranges manually. Then internally a non-overlapping tree of ranges is created that uses our moving cursors to keep track of changes in the document. Each view will have an instance of such a tree, which allows to have folding per view.

These folds are only created on demand, e.g. if you decide to fold some region via selection + “fold” command. This already works quiet well in my Kate repository clone. The missing part is now the integration with the highlighting, that should use this well defined API to only create a folding region in the moment the user wants to fold it. In addition some API for the highlighters is needed to indicate that for some line there is the fold action. After that is done, I might consider to replace the current implementation with the novel one, which is btw. much easier to unit test (which is already done for most API primitives).

Btw., the work is done in this repository, if somebody wants to contribute, patches are welcome .P

Kate: New contributors, Valgrind, and a fixed bug

Sun, 17 Mar 2013 19:38:49 +0000

In the recent months Kate saw quite some contributions from developers other than “the usual kate developers”. This is really cool, areas include more work on python plugins, a lot of bug fixing and fine tuning in the vi input mode, an improved python indenter, and more unit tests. Especially one unit test turned out to be immensely useful and resulted in a fix for the infamous “rangesForLine” crash (about 40 times reported). We even decided to backport this to KDE 4.10.2, so KDevelopers and Kile LaTeXers please keep an eye open on whether this has any side effects!

Basically, the unit test provided us with a valgrind trace. Since valgrind is a very useful tool for all developers, we’ll have a closer look at the valgrind trace:

==10276== Invalid read of size 4
==10276== at 0x62F2116: Kate::TextCursor::lineInternal() const (katetextcursor.h:134)
==10276== by 0x62F9035: Kate::TextBlock::updateRange(Kate::TextRange*) (katetextblock.cpp:572)
==10276== by 0x62F8C57: Kate::TextBlock::mergeBlock(Kate::TextBlock*) (katetextblock.cpp:522)
==10276== by 0x62EFAA1: Kate::TextBuffer::balanceBlock(int) (katetextbuffer.cpp:494)
==10276== by 0x62EF1B2: Kate::TextBuffer::unwrapLine(int) (katetextbuffer.cpp:298)
==10276== by 0x637BB9C: KateBuffer::unwrapLines(int, int) (katebuffer.cpp:292)
==10276== by 0x6359DE9: KateDocument::editRemoveLines(int, int) (katedocument.cpp:1321)
==10276== by 0x6359AD6: KateDocument::editRemoveLine(int) (katedocument.cpp:1293)
==10276== by 0x6357841: KateDocument::removeLine(int) (katedocument.cpp:732)
==10276== by 0x6394C6A: KateScriptDocument::removeLine(int) (katescriptdocument.cpp:513)
==10276== Address 0x14353470 is 96 bytes inside a block of size 152 free’d
==10276== at 0x4C2A44B: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==10276== by 0x62FDE4D: Kate::TextRange::~TextRange() (katetextrange.cpp:66)
==10276== by 0x6470B1E: KateOnTheFlyChecker::deleteMovingRange(KTextEditor::MovingRange*) (ontheflycheck.cpp:535)
==10276== by 0x6470657: KateOnTheFlyChecker::rangeEmpty(KTextEditor::MovingRange*) (ontheflycheck.cpp:489)
==10276== by 0x62FE641: Kate::TextRange::checkValidity(int, int, bool) (katetextrange.cpp:196)
==10276== by 0x62F6C84: Kate::TextBlock::wrapLine(KTextEditor::Cursor const&) (katetextblock.cpp:168)
==10276== by 0x62EEF1D: Kate::TextBuffer::wrapLine(KTextEditor::Cursor const&) (katetextbuffer.cpp:231)
==10276== by 0x637BA6D: KateBuffer::wrapLine(KTextEditor::Cursor const&) (katebuffer.cpp:275)
==10276== by 0x635972E: KateDocument::editInsertLine(int, QString const&) (katedocument.cpp:1246)
==10276== by 0x6357690: KateDocument::insertLine(int, QString const&) (katedocument.cpp:706)
==10276== by 0x6394C32: KateScriptDocument::insertLine(int, QString const&) (katescriptdocument.cpp:508)

The trace tells us that somewhere in TextCursor::lineIntern() we read a variable/address that is invalid. In fact, we are reading a pointer called m_block that should be valid. In this case, as we know the pointer should be valid, we can conclude that the entire TextCursor object is then corrupted/invalid. Since the cursor is part of a TextRange, it means the TextRange is already invalid. Interestingly, this is exactly what valgrind is telling us in the lower part: The TextRange destructor that lead to the invalid read above is called in the 2nd half of the valgrind trace. From this, we can conclude that the function KateTextBuffer::mergeBlock() accesses a dangling pointer to a TextRange.

That’s a good start, but in fact, this is where the hard work begins. I’ve invesed about 2 hours to find that probably the dangling pointer is in a cache that is supposed to make the access of the TextRanges (MovingRanges to be precise) faster. Christoph then looked into it and tried several attempts to fix the nasty bug, finally showing us that the cache was indeed wrong but due to a too-late fixup of the start/end text cursors with respect to the TextBlocks. In total, Christoph probably invested about 6 hours, and given that Gerald certainly took quite a lot of time too to write the unit test, we probably have more than 10 ours just to get this bug fixed. Still, the good news is that we got it! And if we are lucky, this was the last bug in Kate’s text buffer. So on to the next crashes… Help welcome!

Kate Vim Mode: Papercuts (+ bonus emscripten-qt stuff!)

Sat, 16 Mar 2013 14:58:23 +0000

I was a long time Vim holdout and often wondered to myself, “just why do those nutheads use vim?” until I googled and read the blog I just linked. After trying Vim out for a few days, I was completely hooked, but didn’t want to leave KDevelop with its awesome Intellisense/ code completion/ navigation features. Thankfully, Kate has a Vim mode, so I could get the best of both worlds :)

However, I’d often run into small but jarring inconsistencies with Vim, or sometimes find missing features, and so I set about trying to fix as many as I could. Since these were usually very small and unimportant things, I’ll just go ahead and list them, Graesslin-style :)

Vim mode is one of those rare and happy pieces of code which you can very easily write tests for: just add the starting text; the list of keypresses; and the expected, final text. Kuzmich Svyatoslav wrote a big battery of them a while back, and my first ever patch was an incredibly trivial little one that fixed a hole in the test framework and a bug that the hole obscured.

After that, I:

Improved the test framework to enable us to test Insert Mode features;
Fixed the inner curly bracket text object to be more like Vim (rather than deleting everything between the curly braces on a diB, Vim usually attempts to leave the closing curly bracket on its own line);
Added { and } motions to Visual Mode;
Fix a few bugs with Erlend’s very handy “comma text object” extension;
Fixed numerous bugs with t/T and , & ; involving them getting “stuck” behind occurrences of the character to search for, and also made them “counted” so that one can do e.g. 3ta, and also mirroring Vim’s behaviour where if we can’t find the required count of characters on the line, we don’t move at all;
Stopped the transition from Visual Mode to Normal mode from resetting the cursor position if we exited via ESC or Ctrl-c;
Fixed a bug with the nifty “block append” feature;
Fixed a nice bug with replaying the last command via . when the last command was an insertion that had a Ctrl-o in the middle of it (all the characters after we exited the Ctrl-o were treated as commands, with predictably zany results!)
Ensured that the bracket text object worked in Visual Mode;
Made the very handy Key Mapping feature “counted”, so you could perform your chosen Mapping several times in a row, and also made them count as one edit that could be reverted with just one request to Undo;
Made p & P move the cursor to the end of the pasted text instead of leaving it at the beginning (whoops!), and similarly for gp/gP which places the cursor one past the end, hopefully respecting Vim’s slightly obscure exceptions and corner cases (e.g. p and P act as gp and gp when in Temporary Normal Mode);
When doing Ctrl-o in Insert Mode, move the cursor back one step if we are at the end of the line;
Try to keep the length of the number under the cursor unchanged on Ctrl-x and Ctrl-a and also don’t let the cursor stray off the number;
Respect Vim’s rules for counting with Ctrl-x and Ctrl-a, especially with repeats;
Fix a lovely bug with some of the key parsing where the repeat last change command did not work after a Ctrl-a;
Made inserts (i, I, a, A, o, O and block append) counted, so you can do e.g. 100oHello, World!, although I now see that the old implementation of counted o and O was “by design”. Oops – I’ll have to sort that out at some point :/;
Make Ctrl-c reset the parser so that e.g. d aborts the deletion. This one was cool as it remained undetected for ages by a sheer fluke: the only visible signs were that after doing e.g. d, the cursor would stay at half size, and also another bug that I had been promising myself I’d investigate for a while: typing r would replace the current character with a nonsense character, which turned out to be the representation of the keypress Ctrl-c!;
Fixed a few minor flaws where after e.g. osometext, we would have to request an Undo *twice* before getting back to where we issued the command;
Arranged for a return to Normal Mode if we Ctrl-c or ESC when in Temporary Normal Mode. Vim is weird, here: its behaviour is just as you would expect if you were in Normal Mode, but the status bar still claims we are in Insert Mode!
Fixed a bug where issuing y% would actually move the cursor as well as yanking the text;
Added the last edit markers, [,] and .;
Fixed a few bugs with inner bracket text objects being treated as invalid if there were less than three characters long;
Respected Vim’s rules for the [[, ][ etc motions when used with commands: they behave slightly differently than when they are used as cursor motions;

and that’s about it! Kate Vim’s testability make it very pleasant to develop features/ fixes Test First, so all of these are buttressed by a decent amount of automated tests.

The Future

I’m nearing the end of the papercuts stuff, and will shortly move onto slightly larger scale things. This will consist of implementing a Vim-style search and replace bar, with all the usual Vim shortcuts: Ctrl-c to dismiss; Ctrl-r to insert contents of register; Ctrl-rCtrl-w to insert the word under the cursor; etc, and with proper Vim style searching e.g. positioning the cursor on the first letter of the current match; return to where we were if cancelled; interactive search and replace with Y/N/Q/A; etc. I think I’ll use “smartcase” for deciding case sensitivity, but might make this configurable through a hidden config option if there is any demand for it.

There’s currently quite a lot of Vim-specific code that has leaked into Kate’s own Find/ Replace dialog, and I’d really like to be able to delete that and just have Vim use this Vim-specific version. What do people think? I’d have to get it at least as functional as Kate’s own one before I’d consider this, so we’d need e.g. some way of going through the Find and the Replace history separately (I don’t think stock Vim can do this?) and easily toggling whether this is a regex or a literal search, etc. I’d really like some feedback on this, and a suggestion for shortcuts etc!

Done properly, this would give us a powerful, keyboard-friendly Find (and Command Line) dialog where we can easily track the keypresses, which would set us up nicely for the next major task – Vim Macro support!

Before all that, though, I just have a couple of smaller odds and ends to sort out: I need to get auto-completion properly working with . (currently, if auto-completion is automatically invoked, pressing . won’t include the completed text), and it would be nice if Ctrl-p and Ctrl-n could wrap around in the list of completions as they do in Vim (need to sort out a Kate bug with completion first). I also have an another idea which I’d like some feedback on; it would be nice if people would try it out and let me know if they find it helpful, annoying, etc. If only there was a way of letting people test out a patch that hasn’t been committed yet … ! Which leads nicely on to:

emscripten-kate :)

You may have seen my blogs on emscripten-qt, a port of Qt to Emscripten, an awesome technology that allows one to compile C/C++ to Javascript. This caught the eye of Mozilla, who were looking for an example of a “serious” app to go along with the games and utilities in their current list of Emscripten demos, and they kindly offered to sponsor me to work on this. After looking through a list of candidate apps, they eventually suggested porting Kate: not exactly an easy task, as Kate obviously requires not only a big chunk of kdelibs (with its reliance on DBUS and external processes like kded, etc) but also QtScript for its extensibility (the automatic code indentation for various programming languages, for example, is implemented in JS) meaning I’d need to get a C++-based Javascript interpreter ported to Javascript ;)

This ended up being not as hard as I feared, and now we have a decent (though very cut-down; there are no plugins, so it’s more like KWrite than Kate ;)) version of Kate ported to Javascript. I’ve merged in the patch I’d like feedback on as mentioned above so you can easily try it out as long as you have a modern browser, plenty of bandwidth (even after server-side compression, you’re still looking at a tens of MB download :/) and also plenty of free RAM and CPU. There’s an unfortunate bug in Chrome which means you’ll need to use the no icons version, alas. Konqueror and reKonq also do not work, to my knowledge. Let me know what you think, and if anyone has any thoughts on shortcuts for the extended Find/ Command Line bar, do let me know!

Navigation in Okular: Back & Forward

Sun, 10 Mar 2013 15:18:19 +0000

Okular, KDE’s universal document viewer, has a really cool feature I’m using for years already: “Go > Forward” and “Go > Backward”. These two actions allow to quickly jump to positions in the document where you came from in a chronological order. Consider e.g. reading the phrase “As shown in [15], …”, and you want to know quickly lookup reference [15]. So you click on it, and okular will jump to the list of references. And “Go > Back” will bring you back to exactly the position where you came from.

Awesome :-D

In fact, I removed the “Previous” and “Next”-page buttons from the toolbar in favor of the “Back” and “Forward” feature, which is much more useful to me :) Given that my colleagues were not aware of this feature (all experts in LaTeX and all using Kile and Okular), I thought to praise it here in a dedicated blog. Interestingly, the Okular Handbook is missing this feature. Any takers to fix this? :-) Update: This is also mentioned in the Okular handbook :-)

Idea: Code Completion for JavaScript

Wed, 27 Feb 2013 20:17:54 +0000

In 2012, Kate had a GSoC project with the aim of adding a Scripting IDE plugin. The idea was to make it easy to write Kate Part scripts (command line scripts, indenters), that should include rudimentary code completion and a gui to manage available scripts. As detailed in the blog post, a rudimentary list that showed all available scripts is available. However, due to changes in Kate Part’s scripting framework (e.g. changes in the folder structure, require() function to load libraries), the plugin in its current form is not applicable anymore. Still, the idea of having a better JavaScript support is valid.

So this blog post is about some ideas how we can add possibly really cool JavaScript support to Kate as a plugin. This plugin should provide the following features:

provide code completion
support for loading additional modules (jQuery, Node.js, Prototype, Kate Scripting API, …)
specialized support for Kate Part scripting
outline in terms of a function and prototype browser

JavaScript Code Completion

Providing code completion to JavaScript requires a parser so we have an abstract syntax tree (AST) of the current file. This parser needs to be error-tolerant, since during the process of programming, the source code often violates the syntax. Searching the Web, relatively few information about such a parser exists. But one tiny parser shines: Esprima (source code, more info), written by KDE’s “very own” Ariya :-)

Esprima is a JavaScript parser written in JavaScript. It is (to some degree) error-tolerant and returns an AST as shown in the parse demo. The AST is returned in simple JSON syntax, meaning it can be easily parsed with either the JavaScript JSON functions or JSON in Qt5 (JSON for Qt4). Along the error-tolerant mode, the AST returned by Esprima also contains comments and line/column information, if desired.

Interestingly, the idea of using Esprima for code completion arose about a year ago, and meanwhile there are several projects that successfully use the Esprima AST: Eclipse Orion, a web-based IDE, uses Esprima for code completion and for the outline view (sources). The source code for the code completion is available in the orion client git module: lib, code completion (content assist), unit tests.

So What Next?

As it seems the code is all there, the next step would be to start a small standalone project and write a proof of concept to check whether this approach is feasible. I’d suggest to use Qt’s JavaScript interpreter (QtScript in Qt4, QJS in Qt5). In the long run, the goal would be to have code completion and possibly an outline view. If this works, more functionality like support for Kate Scripting could be added. So there is a lot to play around with.

If you are interested, just start working on it. It might be a good GSoC project (although we’d require a quite skilled developer here) :-P Thoughts? Comments?

Kate Git Statistics

Wed, 27 Feb 2013 19:26:43 +0000

Now the statistics of the kate.git are online for public viewing.
They will be updated daily, located on: /stats/

Unfortunately, the statistics of the last years are not that “representative”, as the moves of Kate around in SVN and to Git biased the statistics, as I did a lot of the commits for syncing and moving and so on.

Still it is amazing how MANY people did contribute during Kate’s history! (see Kate Authors)

A big THANK YOU to all contributors that appear there (and all the people that provided patches others merged in, did the testing, bug reporting, translations, …).

(And thanks to the authors of git_stats.)

Git Tools

Mon, 25 Feb 2013 19:51:11 +0000

The Projects plugin in Kate just gained a context menu for the tree view that shows several git tools, if available:

Clicking will open the corresponding application in the correct working directory. Currently, only gitk, qgit and git-cola are supported. If you want more git integration, you probably have to use KDevelop or QtCreator :-)

New plugins to the Kate, utils to: Python, JavaScript, Django and XML

Mon, 18 Feb 2013 09:17:00 +0000

The project plugin in kate.git master now has four new more plugins, with many features in each one: Python (autocomplete, smart snippets, parse checker, pep8 checker and pyflakes checker), Javascript (autocompletes, jquery snippet, pretty JSON, and jslint checker), Django (smart snippets and utils to Django template) and XML (pretty xml). There are also many generic functions and generic classes in these that will be useful to the new plugins developers.

I began to develop these plugins in 2009, this was my first version :-). I wanted to set a shortcut to a snippet, as it was not possible (now it is posible) I started to develop these plugins to Kate.

In November 2011, I created a repository on github to develop new features and share them. I have to thank Alejandro Blanco, Jeroen van Veen, Javier Romero, Martin Borho, Justin Chudgar and Yaco Sistemas for helping me in this project.

In October 2012 Christoph Cullmann (Kate maintainer) sent me an e-mail, in which he asked me if I was interested to contribute with KDE project. I answered: “Of course!”…. finally I have a little time, and I have been able to integrate these plugins in the kate.git

Features to Python Plugin:

Python dynamic autocomplete using pyplete, this is in beta… It requires development, but now it is very useful.
Smart snippets:
1. Insert an __init__ method into a class.
2. Insert a super call into a method.
3. Insert a call recursive into a method or into a function
Simple snippet: Insert the debug instrunctions “import ipdb; ipdb.set_trace()”
Checkers: When you save the file it is syntax checked, pep8 checked and pyflakes checked. You can invocate them any other time.

[

][3]

Python auto complete

Features to Javascript Plugin:

JavaScript static autocomplete, using a JSON file.
JQuery static autocomplete using a JSON file.
Pretty JSON: Pretty format of a JSON code selected
JSLint checker: When you save the file it is JSLint checked. You can invocate it any other time.
JQuery snippet, insert the ready code of the jQuery

JSLint checker

Features to Django Plugin:

Smart snippets:
1. Create a model class
2. Create a form class
3. Template to the urls.py file
Simple snippet: Insert the typical imports of a views.py file
Template Django utils
1. Insert the tag block/endblock. The name of the block will be the text selected
2. Close the last templatetag open

Create a form class

Pretty XML:

Pretty format of an XML code selected

Pretty XML

Generic features:

Also I have added many generic functions and generic classes, likely the more outstanding are the autocompletations. Now you can create a code completion model with very few lines:

import kate
from libkatepate.autocomplete import AbstractJSONFileCodeCompletionModel, reset
class MyCodeCompletionModel(AbstractJSONFileCodeCompletionModel):
MIMETYPES = [] # List of mimetypes E.G.: ['application/javascript', 'text/html']
TITLE_AUTOCOMPLETION = "My Auto Completion Model"
FILE_PATH = 'my_autocompletion.json'
# Operators to separate the instrunctions
OPERATORS = ["=", " ", "[", "]", "(", ")", "{", "}", ":", ">", "<",
"+", "-", "*", "/", "%", " && ", " || ", ","]
@kate.init
@kate.viewCreated
def createSignalAutocompleteJS(view=None, *args, **kwargs):
view = view or kate.activeView()
cci = view.codeCompletionInterface()
cci.registerCompletionModel(my_code_completion_model)
my_code_completion_model = MyCodeCompletionModel(kate.application)
my_code_completion_model.modelReset.connect(reset)

The my_autocompletion.json file should have this format:

{
"xxx": {
"category": "module",
"children": {
"www": {
"category": "class",
"children": {}
},
"yyy": {
"category": "constant",
"children": {}
},
"zzz": {
"category": "function",
"args": "(x1, x2, x3)",
"children": {}
}
}
}
}

I encourage you to participate in the KDE project, for me this participation has been very simple because this community is very, very open.

Thanks all,

Highlight Text Selection Plugin

Fri, 15 Feb 2013 08:42:18 +0000

As a quick notice: The highlight selection plugin was not removed in KDE SC 4.10.0. Instead, a silly bug results in not loading the plugin. This is fixed for DKE 4.10.1. If you cannot wait, you can find a workaround here :-)

Kate Project Plugin News – Code Analysis

Sat, 02 Feb 2013 20:28:58 +0000

The project plugin in kate.git master has now the ability to call cppcheck.

This is just hacked in at the moment and needs more love, but it works.
Feel free to contribute integration of other code checkers, cppcheck is only the first, I hope ;)

Kate in KDE 4.10

Sun, 06 Jan 2013 15:10:42 +0000

According to our release schedule, KDE SC 4.10.0 will be available to the public in early February 2013. Following Kate in KDE 4.7, Kate in KDE 4.8 and Kate in KDE 4.9, this blog post highlights what’s new in Kate in KDE 4.10.

New Features

Kate Part got a unified notification system. It’s used in several places already, for instance for remote file loading, data recovery and Search & Replace information.
Kate Part can now be configured to show a minimap of the document instead of a scrollbar. The minimap shows text in a miniature view and is useful for fast text navigation in the document. While the feature itself is stable, it may be changed and should be considered experimental. Feedback is welcome on our mailing list.
Kate Part got several predefined color schemes. Feel free to contact us with improvements.
Kate Part shows the current line while scrolling.
Kate got an integrated Quick Open feature (ctrl+alt+o) for fast file navigation.

News in the Plugins World

Kate’s Pate plugin now provides several new plugins by default, with Python 3 support.
Kate gained a new and very powerful Project plugin with ctags code completion. It is tightly integrated with the Search & Replace plugin as well as the GDB Plugin and the Quick Open feature.
Kate Search & Replace plugin gained find-as-you-type support.

Improvements

Kate Part’s remove trailing spaces feature is improved.
Kate Part’s scripting API gained several new features (e.g. zen coding script). The API now is more fine grained, e.g. you now need to “require(“cursor.js”);” in order to have the Cursor API.
a lot of other little improvements, see our bug tracker for a full list.

Bug Fixes

Most of the following work was done during the yearly KDE conference and especially the joint Kate/KDevelop meeting this October in Vienna. A massive bug database cleanup was performed mainly by Christoph, so we closed several hundreds of bug reports, where ~280 are really fixed. So we are down to a total of 400 reports (only 70 of these 400 reports are bugs), where we initially had > 800 open issues. This also is reflected in the Kate bug charts:

Thanks to all contributors to make yet another release rock! :-) And as always: We are happy for every contribution, so check out the Kate sources and send us patches! We hope you enjoy using Kate as much as we enjoy its development :-)

Python plugin gets support for Python3

Sun, 02 Dec 2012 18:29:39 +0000

Being vaguely aware that Python3 had some “interesting” differences compared to Python2, I had decided to not think about Python3 for now, but then one of our dear users piped up to say that even building it was broken! That seemed weird, so I started poking around only to find myself falling Alice-like into a Wonderland where strings were not always strings…

Well, I’ve long been interested in i18n and l10n in all their forms, especially as they apply to Indic languages, so I was somewhat aware of the sorts of issues that Unicode can throw up. Luckily, as a KDE developer I’m used to depending on QString handle all the routine grunt work so it was a bit of a rude awakening to discover that, the C API for Python strings takes many forms:

Python 2.x has 2 run-time variants with 3 compile-time variants.
- http://docs.python.org/2/c-api/unicode.html
Python 3.2 or less has 3 compile-time variants
- http://docs.python.org/3.2/c-api/unicode.html#unicode-objects
Python 3.3 or greater has 3 run-time variants
- http://docs.python.org/3.3/c-api/unicode.html#unicode-objects

Note only that, but:

Ubuntu does not yet have 3.3.
The cmake support in KDE before 4.9.4 cannot find the right libraries.
The PyKDE4 support for strings was broken-then-fixed.
Python3 pickles structures differently than Python2.

Anyway, with some excellent support from Luca Beltrame and Alex Turbov, I’m glad to say that Pate and its plugins should now work with any of Python 2.x, <= 3.2, or 3.3 in the upcoming 4.9.4 and 4.10 releases. Thanks Luca and Alex!

ID + etags > ID || etags

Wed, 21 Nov 2012 23:41:07 +0000

ID files and TAGS files are generated by GNU idutils and etags respectively. They are often used in coding projects to facilitate looking up, for example, the name of a function, and then visiting where it is defined, etc. In large projects, ID files can be hundres of MB in size, and TAGS files several times that. That looking up is obviously nice to have integrated into your favourite editor…

When I started on getting ID file support into Kate, my need was to efficiently navigate source code indexed using an ID file a bit over 100 MB in size. The bad news is that I now have ID files over 300 MB in size, but the good news is even that is not a problem! Not only that, but by combining the ID file with dynamic invocation of etags, I can have all the TAGS functionality I care about without needing to pre-generate a 600 MB TAGS file as well.

It even works reasonably well even when the ID files and the source files are mounted via SSHFS over a WAN link!

But best of all, you can have it too, from today’s Kate 4.10 beta, using a shiny new Python plugin. Here is how…

First enable Python plugin support.
Then use its configuration dialog to enable the gid plugin:

You may need to restart Kate, but then you should see a new menu bar entry:

Selecting any of them will display a configuration dialog which allows the ID file to be selected:

You are probably thinking “Wow, that’s quite complicated for a file open dialog!”, so let’s go through the features step-by-step…

Remember that KDE’s file open dialog (icon on top right) understands environment variables. So if your workspace has a handy environment variable point to its root, getting to an ID file near the root is very fast (I use “$ws” because it is quick to type).
The Browse Tokens functionality performs completion on the token, and setting the “Complete Tokens after” prevent the completion kicking in annoyingly before you have finished typing even a first few characters. Values like 3 or 4 work well in many cases.
The Transform Filenamessection allows the filenames inside the ID file to be mapped to slightly different filenames in your $ws. That is useful when:
- The ID file was built somewhere other than your current $ws. That might be another of your workspaces, or possibly an archived workspace for a released build.
- The ID file was built on your compile server, but you’ve mounted your workspace at a different mountpoint on your laptop (so you have access to the latest version of Kate :-)). Or perhaps you are using Clearcase, and don’t have it on your laptop.
Try “What’s This” on the “With this file prefix” to see how you can simply the setting of this value. In the example shown, notice how the first part of the ID filename “/view/myview/vob” is the same as this value? It seems common practice to put the ID file at or near the top of $ws, so including %{idPrefix} helps support this.
- More important than saving a bit of typing is that if all your workspaces are built using a common recipe, you will never need to touch this value again!
- The ID file was built somewhere other than your current $ws. That might be another of your workspaces, or possibly an archived workspace for a released build.
The Highlight Matches section allows:
- etags to be run on the matches in the ID file to distinguish the definition(s) of the token from mere declarations and usage with a distinctive icon.
- Matches in files with the given suffixes will be flagged with another distinctive icon.

Once you’ve chosen a usable ID file, a toolbar will spring into existence at the bottom of your window:

As you can see, the Token field allows browsing by token. Selecting a value will cause the table below it to be filled with the matches from the ID file, highlighted using the Settings chosen previously. (They can also be tweaked using the button top right).
Click on an entry in the table to open the file and jump to the match. When you do, two entries will also be added to the table on the right which record where you were before the jump, and where you jumped to. That allows you to easily move backwards and forwards though the browsing history.
So what is that Filter thingy? Any matches returned from the ID file, can be further filtered using a regular expression. For example, a filter expression of “%{token} =” will find assignments to “malloc_failure” here:

(Note that you have to use Shift-F1 to get to the What’s This since the toolbar is missing the nice little “?” button).

Another nice use of the filter is as a poor man’s full text search: ID files will contain tokens including words in strings. So putting a second word of interest in the Filter will return only the matches which contain both words…
Finally, in 4.11, auto-completion is enabled (don’t forget to configure it in Kate->Settings->Configure Kate->Editing->Auto-completion)

I hope you’ll find these useful add ons to the normal experience of using ID files, but feedback is always welcome!

Bug Hunting – Please help poor Kate ;)

Fri, 09 Nov 2012 21:03:16 +0000

The Kate/KDevelop sprint in Vienna was a really productive time.

Thanks to Joseph Wenninger for organizing it and the KDE e.V. for the additional funding!

The Kate team was able to really wade through a lot of bugs & wishes and fix/invalidate a lot of them.

After some more days of work, this really is visible in our nice bug chart ;)

Kate, KatePart & KWrite are now down to a bug level as low as years ago ;)

Still, there is a lot to do.

If you have some spare time and Qt/KDE knowledge, please help us to have an even better KDE 4.10 release and look at the remaining bugs.

We have the following ~60 bugs and ~330 wishes still around. They vary from small stuff to “a lot” of work. If you want to help out, just pick the bug you want to work on and assign it ;)

Default Color Schemas

Wed, 07 Nov 2012 11:25:48 +0000

With KDE 4.10, the naming of the color schemas in Kate Part changed. Instead of having “ – Normal” and “ – Printing” we now just have “Normal” and “Printing,” meaning that all applications using Kate Part now share these color schemas. In other words: If you change the Normal schema in KDevelop, you also will see these changes in Kile, Kate, or any other application that embeds Kate Part. If you just want to change the color schema for a single application, create a new color schema and then use this new schema as default!

Besides that, it’s been a looong way, but finally Kate will ship several default color schemas in KDE 4.10:

Normal Color Schema

Solarized (light)

Vim (dark)

The colors are not all perfect, so we hope to improve them over time, so if you always wanted to contribute to Kate, we could need help here :-)

Kate Scripting Updates & Zen-like Quick Coding

Tue, 06 Nov 2012 17:41:15 +0000

In KDE >= 4.10, Kate Part’s scripting changed a bit. The changes are already documented in the Kate handbook, but we’ll quickly have a look into it now anyway.

Prior to KDE SC 4.10, scripts in Kate Part always had to contain the “type” in the scripting header, like indentation or command. This was changed to simply using different folders (system wide or in your $HOME kde folder) as follows:

indenters are located in share/apps/katepart/script/indentation
commands are located in share/apps/katepart/script/commands
api is located in share/apps/katepart/script/libraries

Further, the API is not loaded automatically anymore. Instead, we introduced the function require(“file.js”), which takes one argument. For instance, if you want to use the Cursor and Range API, you just write

require("cursor.js");
require("range.js");

In this example, it would even suffice to just write require(“range.js”); since range.js itself contains the line require(“cursor.js”); Kate Part tracks, which files are already included through require, so you don’t have to worry about include guards like in C/C++.

Now as we are able to just load the libraries that we really need, we can add as many libraries as wanted. For instance, the author of zen-coding wrote a thin wrapper to make all the zen-coding goodies available to Kate Part. It’s included in the emmet subfolder in the script/libraries folder. So if you need this stuff, you just write require(“emmet/desired-file.js”);

It’s a bit unfortunate that we still break how the scripting works from time to time, but it’s better to fix and improve the scripting instead of living with limited capabilities. So if you have own scripts, it’s the best time to contribute them to Kate!

Generic Quick Coding Features

Further, we have some new command line script called quickcoding.js that already uses the zen-coding idea: If you for instance write

 c#n:Test#p:Parent

and press Ctrl+Alt+# in C++ files (the Mode must be C++!), it will automatically expand to

/**
 * Class Test
 */
class Test : public Parent
{
public:
/**
* Constructor of Test
*/
Test ();

/**
* Destructor of Test
*/
~Test ();

};

So how does it work? Since the file mode is C++, the quick coding command will read files from katepart/script/files/quickcoding/cpp/. The first character of this cryptic string is ‘c’, which tells the quick coding command to look into c.template. This template now expands according to the specified arguments: n:Test sets the class name to Test, and the optional p:Parent derives Test from Parent.

This is just a proof of concept, and you can do the same with Text Snippts in Kate. But still, this is another way adding support for quick coding for arbitrary languges, and the implementation is completely in JavaScript, so it is rather easy to extend and customize it to your needs. We’ll probably extend/change this feature a bit more over time, let’s see :-) It’s also not yet documented in the Kate Handbook. We’ll probably add ‘official’ documentation for this in later Kate releases. Happy coding!

Passive Notifications in Kate Part

Tue, 06 Nov 2012 13:06:11 +0000

In KDE 4.10, Kate Part got a new MessageInterface. The idea of this interface is to have a standardized way of showing notifications in a non-intrusive way, similar to how KMessageWidget in kdelibs works. Using the MessageInterface is extremly easy, for instance to show a quick notification, you write

KTextEditor::Message *message = new KTextEditor::Message(KTextEditor::Message::Positive,
"Code successfully reformated.");
document->postMessage(message);

That’s basically it! The result looks like this (with a nice fade-in and fade-out animation):

As developer, once you called postMessage(), you can safely forget the message pointer. It’s automatically deleted either if the user closes the notification, or if the document is closed or reloaded. The API for more tricks. You can add multiple actions through KTextEditor::Message::addAction(), which then appear as buttons. For each added action, you can control whether triggering the action should close the widget or not.

Further, you can set an auto hide timer through Message::setAutoHide(int timeInMilliSeconds).

If you want a message to only appear in one specific KTextEditor::View of the Document, you just call Message::setView() before calling postMessage(). If several messages are in the queue, the one with the highest Message::priority() is shown first.

This notification system is already used in Kate Part by the data recovery (swap files), or to show a notification when loading remote files, and in some other places.

The cool thin is that this solution requires no special code in KateView or other classes, hence, it’s a perfectly clean solution with an easy-to-use API. You as KTextEditor user (developer) should definitely consider using it when it’s public.

Note: The MessageInterface is a KTextEditor interface; however, since the 4.10 branch is frozen for BIC changes, we cannot just add this interface for KDE 4.10. Instead, for Kate Part users (Kile, KDevelop, …) this interface will only be available in KDE5.

Finally, an example of all four message types: Positive, Information, Warning and Error:

Loading Remote Files

Mon, 05 Nov 2012 21:01:09 +0000

Loading huge files over the internet may take quite a long time. In KDE 4.10, Kate Part will show a passive message after 1 second that tells you the file is still being loaded, and, if wanted, the user can abort the loading process. It looks like this:

This also fixes bug #128273. Again, cookies go to Christoph ;)

Kate needs BiDi/Unicode aware developers ;)

Sat, 03 Nov 2012 12:32:38 +0000

During our long bug hunting and fixing sprint I came along some nasty BiDi or Unicode related bugs.

I and most others in the Kate team are not really able to fix such issues :( We lack both the knowledge of the underlying techniques and are not able to write/read any language that really uses complex unicode chars or BiDi text.

Therefore: If you know Qt and you want to help out with fixing BiDi/Unicode related bugs, please provide patches for them in the KDE Bugzilla!

Here are the relevant bugs:

Any help here is highly appreciated! If you have questions about the internals of KatePart needed to fix such an issue, just ask in the bug or kwrite-devel@kde.org.

Busy Kate/KDevelop Sprint results in Mini-Map

Sat, 03 Nov 2012 11:08:57 +0000

One of the results of the Kate/KDevelop sprint in Vienna is the new “MiniMap” that can be used instead of the vertical scrollbar. I came to the sprint with a black and white version of it for the symbols viewer, but got encouraged to integrate it to the core. The result, in cooperation with Sven Brauch from KDevelop, is a nice Mini-Map that can be enabled both in Kate and KDevelop.

And to make this into a real blog and to provide proof, here are a couple of screenshots:

[][1]

The MiniMap enabled

[][2]

Here is where/how you turn it on in Kate

Using the Projects Plugin in Kate

Fri, 02 Nov 2012 15:42:26 +0000

Update (2014-10-18): Auto-Loading Projects in Kate 5

Introducing the Projects Plugin for KDE SC 4.10

The basic idea of the Projects plugin is to have a structured list of files belonging to the project with the following properties:

provide a structured view of the files
make it easy and very fast to open and switch projects
support search & replace for a project
provide simple auto completion
make it simple to quickly open files in the project
support for building the project

We’re going to address all these points now.

1. Provide a Structured View of the Files

Once the “Projects Plugin” is loaded in the Kate config page, a sidebar appears that lists all projects as well as the projects files as follows:

As you can see, the currently active project is “Kate”, and it’s contents is listed in the tree view. Clicking on files in the tree view opens the file in the editor. Further, a context menu is provided with which you can open files with other applications, such as a .ui file with Qt Designer.

2. Switching Projects

The idea is that you never have to open a project manually, this is even not supported at all. Hence, what happens if you open a file, the Project Plugin quickly scans the folder and its parent folders for a .kateproject file. If found, the project is automatically loaded. Very simple and efficient.

Further, if you open another document in Kate, that belongs to another project, the Project plugin automatically switches the current project. So intuitively, always the correct project is active. Of course, you can also switch the currently active project through the combo box.

3. Search & Replace in Projects

Kate has a “Search & Replace” plugin that shows up in the bottom sidebar. If a project is loaded and you open the “Search & Replace” sidebar, it automatically switches to the mode to search & replace in the current project, which usually is exactly what you want:

4. Simple Auto Completion

With the knowledge of all files belonging to a project, the Project plugin provides simple auto completion facilities based on ctags. If a project is initially opened, ctags parses all project files in a background thread and saves the ctags information to /tmp. This file then is used to populate the auto completion popup in Kate. In contrast, without this auto completion, Kate was only capable of showing auto completion items based on the words in the current file. So the auto completion provided by the Project plugin is much more powerful.

If ctags is missing, a passive popup warns you about this. It is also noteworthy, that the ctags file in /tmp is cleaned up when Kate exists, so you the plugin does not pollute any folder with unwanted files.

5. Quick Opening Files

As clicking on files in the tree view is not the fastest way to open a file, Kate provides a built-in quick open mechanism you can activate with CTRL+ALT+o. What you the get is a list like this:

You can filter by typing parts of the file name you are looking for, and you can also navigate with the arrow keys and page up/down through the list. Hitting enter activates the selected file, while escape hides the quick open view again.

Further, the quick open remembers the previous file. So when you change to the quick open view the previously activated file is automatically selected and you just need to hit enter, which comes very handy at times.

6. Support for Building the Project

Another feature is to have support in the Build plugin, so that it automatically is configured correctly.

Creating Projects

Currently, creating a project requires some manual work, although it is really not much. You just have to create a .kateproject file in the root folder of the project. For instance, the Kate .kateproject file looks like this:

{
"name": "Kate"
, "files": [ { "git": 1 } ]
}

As you may have noted, this is JSON syntax (because there is a nice jason library for Qt to parse this). The project name is “Kate”, and the files contained in should be read from git.

What’s also supported instead of “git” is subversion through “svn” and mercurial through “hg” (btw, it would be nice to have support for other version control systems as well *hint*). If you do not want to read from a version control system, you can tell it to recursively load files from directories as follows:

{
"name": "Kate"
, "files": [ { "directory": "kate", "filters": ["*.cpp", "*.h", "*.ui", "CMakeLists.txt", "Find*.cmake"], "recursive": 1 } ]
}

Here, subfolders and filters define what’s part of the project. You can also mix version control and files based on filters.

If you want to add support for the Build plugin, you could write a .kateconfig like this:

{
"name": "Kate"
, "files": [ { "git": 1 } ]
, "build": {
"directory": "build"
, "build": "make all"
, "clean": "make clean"
, "install": "make install"
}
}

Hopefully, these examples help you to setup your own project.

Kudos

Kudos go to Christoph, he implemented all the features in here. The Project plugin will be shipped with KDE SC 4.10, and you should really try it out :-)

Contribute to Kate

Sun, 28 Oct 2012 18:45:02 +0000

Currently we are at the Kate/KDevelop sprint in Vienna. Christoph and me took the time to look a bit around in the net for Kate, and more or less accidently stumbled over quite a lot of extensions by our users. Here are some examples:

script to jump to next/previous paragraph
several really good highlighting files, e.g. for C++11
several Kate plugins written in Python
many more python plugins for Kate, even officially listed in the Python index
there is more, I won’t list it all :)

Kate has just about 20 plugins written in C++. And, ironically, there are more plugins for Kate written in python. This is totally awesome, but still, the Kate developers didn’t even know about it ?¿? :-o

So we started contacting these potential contributors, and also asked why they e.g. upload it in some other git repository. One time, we got the answer, that they uploaded it somewhere to share it with other users. But really, the perfect way to share additions for Kate is to put it into the Kate git repository directly. This is how open source works…

So if you make additions or changes to Kate, please let us know, create a patch and send it to review board, come to our developer sprints, come to the annual KDE conferences… Talk to us, usually we are all pretty friendly and really happy about every single contribution!

Show Line while Scrolling

Sun, 28 Oct 2012 01:56:35 +0000

Another quick update: Jowenn just implemented a decent tool tip that displays the current view line while scrolling, a wish from 9 years ago. Mandatory screenshot (pimped with my “awesome” Gimp skills):

Remove Trailing Spaces

Sat, 27 Oct 2012 14:01:05 +0000

Up to KDE 4.9, Kate Part had support to remove trailing spaces in two ways:

Remove trailing spaces while editing
Remove trailing spaces on save

The reasoning behind removing trailing spaces while editing is that when working on a document, we want to keep our own changes clean of trailing spaces. This way, we can for instance provide patches that are not cluttered with whitespace changes, and we just change lines that we really want to change.

The implementation of this feature unfortunately had quite some regressions that we were able to “fix” over time. For instance, you do not want to remove trailing spaces if the cursor is currently in the trailing spaces area. This alone means we have to kind of remember that we touched this line, and then remove it later. This was always hacky, and in fact, there are still corner cases that did not work.

For KDE 4.10, the both options were merged into just one option Remove trailing spaces with three possible values:

So we only support removing trailing spaces on save from KDE 4.10 on. The implementation is now very clean and based on the line modification system available since KDE 4.8: Thanks to this system we know exactly which lines in the document were changed. So if you choose “Modified Lines” in the configuration, trailing spaces of these modified lines are removed, and other lines remain untouched. If you choose “Entire Document”, then all trailing spaces in the document will be removed. And, needless to say, “Never” implies that trailing spaces are never removed.

For compatibility, the old mode-lines “remove-trailing-space” and “replace-trailing-spaces-save” are still supported, but you’ll get a kWarning() on the console. All these changes are also documented in the Kate handbook (once KDE 4.10 is released). From KDE 4.10 on, you should switch to the modelines

– remove-trailing-spaces none;
– remove-trailing-spaces modified;
– remove-trailing-spaces all;

Hope you like it…

How to remove a file with Kate

Thu, 25 Oct 2012 21:51:05 +0000

KDE has all these little nifty features, and – guess what – Kate has them, too. Here, we’ll have a look at how to delete a file with Kate. We’ll start with opening the file we want to delete. Example:

Next, we open the menu File > Open With and choose Other… as follows:

We’re almost done: Type ‘rm’ in the Open With dialog:

Now click OK to perform the action, et voila:

Now as you can see, Kate notifies you about the successful deletion. In case you change your mind, you can write it to disk again by clicking Overwrite. Reloading will tell you, that the file can indeed not be found, proving that Kate did exactly what you want. You can also ignore what you just did, which is probably the best choice. Don’t tell anyone :-)

PS: This tip comes from the KDevelop developers. So all Kudos and Cake go to them!
PPS: We are working hard at the Kate/KDevelop sprint in Vienna to provide the best tools for our users!

Data Recovery in 4.10

Thu, 25 Oct 2012 12:05:27 +0000

Recently I’ve blogged about the usage of KMessageWidget in the data recovery process in Kate Part. Finally, we decided to stick with KMessageWidget, since it is a standard kdelibs widget, used by a lot of KDE applications. Besides, it is visually appealing and attracts the user’s attention. In KDE SC 4.10, it will look like this:

Now if you recover the data, it may happen that the swap file is broken, e.g. because it was accidently manipulated for whatever reason. Then you get notified like this:

Besides that, we are currently at our Kate/KDevelop meeting in Vienna. Lots of exciting stuff is happening, so expect more in the next days :-)

Kate/KDevelop Sprint – Update

Thu, 25 Oct 2012 10:57:46 +0000

Its nice to be here in Vienna with all the other hackers ;)
Most have already arrived and are busy fixing issues in Kate & KDevelop, some more will arrive tomorrow.

Already got bit work done on existing bugs, one bug was really nasty: a nearly 8 year old typo by myself messing around with highlighting in combination with line continuation.

But a guy did a really perfect bug report: Bug 300009
He wrote even a example highlighting file + test to trigger the issue, with that help, the fix was trivial to do, after I got time to read the bug ;)

Thanks to all people reporting bugs in such a useful way!

Kate/KDevelop Sprint in Vienna

Sun, 21 Oct 2012 14:54:18 +0000

In some days our nice sprint will start, more information can be found on KDE Sprints.

I am very happy that Joseph Wenninger organizes this event and the KDE e.V. aided with additional sponsorship! Sprints are a real important thing for all KDE projects and it is nice to see that thanks to the help of the community our e.V. is able to sponsor a lot of such events.

I will head over to Vienna on Tuesday, lets see what happens during the week ;)

Kate Script IDE Plugin

Wed, 29 Aug 2012 21:05:49 +0000

Hello everyone! In this post i am going to introduce the new Scripting IDE Plugin for Kate. Although scripting KatePart via ECMAScript is a powerful feature that has been available for quite some time now, it is still rarely used. In order to make it appealing for a wider public, the Script IDE aims at supporting the user with the process of creating and managing scripts.

The Plugin mainly consists of a tree view which shows currently available scripts, as well as functions contained in these scripts.

Additional scripts can be imported and new scripts can be created via a dialog, which requests necessary information about the script. Supported is the creation of all three types of scripts used in KPart: indentation scripts, command line scripts and API scripts. Further, help for command line scripts will be editable via the GUI.

After i have finished some crucial refactoring, the future plan for Scripting IDE features involves auto-completion for available APIs in the document view, as long as the Script IDE Plugin is loaded. Also, some restructuring of the way KPart handles scripts will most likely be necessary.

As soon as there are new major features implemented, i will post them here. Everyone’s welcome to comment with his own ideas!

Project Plugin, Current State

Mon, 20 Aug 2012 22:30:18 +0000

After some days of more hacking on the plugin, there current state is already nice for my daily use.

A simple file like

{
"name": "Kate"
, "files": [ { "git": 1 } ]
}

defines already the complete project for the kate.git.

If you open any file with Kate inside your local kate.git clone (and the project plugin from master branch is loaded), Kate will auto-open the project and highlight the file you just opened there in the tree. No need to think about opening some project in the menu, just open the file you want to start working at and start. The project plugin won’t get into your way or require additional steps.

It will allow you nice and fast file switching between your project files in the filesystem tree like structure without any noise of non-git tracked files ;) Still the normal “Documents” view is around like it used to be, if you want to just navigate between currently opened files.

If you modify the project file, the project will auto-refresh itself, still a reload button is needed to trigger e.g. reparsing of git files, if your add/remove files and want a fresh project tree. The auto-reload won’t help there, as is is more or less a nop if the project file content was unchanged.

The “Search and Replace” plugin will integrate nicely and per default will do project wide searches, if any project is currently active (you can switch to other search modes like before in the combobox, just the default is changed, if the project plugin is active). Thanks to Kåre’s nice design of the plugin, this addition was really easy to implement.

Exuberant Ctags integration is work-in-progress. At the moment on project load, a background thread will generate a ctags index (after it has constructed the file tree from git/svn/…) and the auto-completion will use this index for all files associated with your project. An additional toolview, that allows you to search inside the index will be implemented, too. It is a bit like the current ctags plugin, but without any setup or manual indexing ;) For the kate.git, the indexing (in the background) needs less than half second, even for kdelibs frameworks branch it is only 2-3 seconds. On Kate exit the index files (created as temp files in your local temp directory) will vanish again. No index database polluting your checkouts/clones or homes.

Will try to add more features I like for my daily work, if you have any ideas to improve the plugin, just let me know here or on bugs.kde.org ;)

Mercurial Support in Project Plugin

Wed, 15 Aug 2012 13:28:13 +0000

Christoph already wrote several blog posts about the upcoming projects plugin. In his last blog, he mentioned that a project can now be created on-the-fly by reading the git or subversion output: All the files under version control are automatically listed as files in the project.

However, this is restricted to git and subversion. If you always wanted to contribute to Kate, you can give other version control systems a try, such as Mercurial (command: hg manifest). Just quickly build Kate, and send us a patch!

Update (2013-10-31): Support was added in commit on 2013-03-02 and is available in KDE 4.10.5 and later versions.

Project Management, Take Three

Sun, 12 Aug 2012 19:32:18 +0000

After bit more playing around with the project plugin, I did get aware that I am even to lazy to open project files. Normally if I need to fix something or add new features, I just go to the directory and open the source or build system files I need to work on. Therefore the project plugin now just watches which files you open and will load the corresponding project on the fly for you ;) (instead of naming your project, you create a .kateproject hidden file in the toplevel project dir, just like Git would do it with its .git directory)

Next issue that arised: even with the simple pattern syntax like:

"files": [ { "directory": "kate", "filters": ["*.cpp", "*.h", "*.ui", "CMakeLists.txt", "Find*.cmake"], "recursive": 1 } ]

it is hard to enumerate all files in the kate.git, as we have .py files, .xml files, .desktop files, .sh files and so on.

As I started here locally to add more and more extensions, I got the impression that just asking Git would be an better idea, and voila:

"files": [ { "directory": "kate", "git": 1, "recursive": 1 } ]

and you get recursively all files that are registered in your Git clone in the kate directory ;)

If you still have SVN, no problem, for your project this will work:

"files": [ { "directory": "kate", "svn": 1, "recursive": 1 } ]

These extensions make creating your Kate project much easier I guess and avoid any battling with regular expressions to keep track of the important files.

Other improvements:

Current file will be selected correctly in the projects view
Search and Replace is enhanced with an “in Project” option, if the project plugin is loaded and any project active, for this a bit work was needed to allow inter-plugin communication ;)

And again, the mandatory screenshot:

Project Management, Take Two

Mon, 06 Aug 2012 19:38:30 +0000

After a bit toying around, the first version of project management plugin has landed in the master branch of the kate.git.

First time I developed a new feature in a feature-clone in my scratch space on git.kde.org. Very cool, KDE sysadmins did a GREAT job with that stuff: easy to setup and use ;)

Now, people wanting to try out that, just clone our kate.git and compile the master branch.

Example project is toplevel in kate.git: kate.kateproject

To load it, open Kate, activate the “Project Plugin” and hit the “Open Project” button in your main menu bar and go to the “Projects” tool view on the left.

No, it won’t auto-raise atm and yeah, the button looks awful :P

And here the mandatory screenshot:

It still is not much, but I am happy with the result as this is first time since long for me to code something with model-view and Qt.

Project Management

Sun, 05 Aug 2012 13:31:06 +0000

Some years ago the Kate team introduced the “Session” feature.

This allows you easily to keep around different Kate sessions for different work tasks, like coding, web design, writing, …

Whereas I used that feature a lot at start during my normal daily work, I kind of no longer used it already since some years.

For my normal work pattern: Checkout a project, fix something in it or code an extension, then hop over to the next one, the session feature doesn’t really provide the right workflow.

My checkouts not always stay at the same location on disk, I keep multiple different checkouts of the same project around (or different clones) and I have too many different projects in company to create for all of them a session and keep any overview.

Even more years ago I wrote some project plugin for Kate allowing you to manage a more IDE style kind of project in Kate.

Instead of global sessions in your user account Kate allowed you to create project files which you can check in with your individual projects into your version control.

I purged that plugin later on again, as I lost interest in it because of one major design flaw: You really needed to use the UI to configure your project and add your stuff. That is REALLY annoying if your code base in in a state of flux or evolution and things really keep changing. (The removal wasn’t that well perceived, btw., sorry, but without maintainer, such plugins really cause a lot of pain.)

Now, here we are, six years later :) Given I still have my itch to scratch, I decided to give the project plugin a new try. But this time with a completely different approach: don’t create any UI to create/modify projects but come up with a simple file format for them that a Kate plugin can load.

And yeah, given my history as researcher in compiler construction area, what would be better than write just and other parser for some not understandable language? But no, I want to focus on the real stuff, make the description of the projects lightweight and easy to understand and not try to invent some new syntax yet again.

Therefore I settled with just using JSON to describe the project and started to implement some simple format, like:

{
"name": "Kate",
"projects": [
{
"name": "KTextEditor",
"files": [ { "directory": "ktexteditor", "filters": ["*.cpp", "*.h"] } ]
},
{
"name": "KatePart",
"files": [ { "directory": "part", "filters": ["*.cpp", "*.h"], "recursive": 1 } ]
},
{
"name": "Kate",
"files": [ { "directory": "kate", "filters": ["*.cpp", "*.h"], "recursive": 1 } ]
},
{
"name": "KWrite",
"files": [ { "directory": "kwrite", "filters": ["*.cpp", "*.h"] } ]
}
]
}

This small description should be enough to create the project “Kate” in my kate.git, containing 4 different toplevel parts: KTextEditor, KatePart, Kate and KWrite.

Without many hassle it just collects everything I need for daily work and constructs some tree structure (hehe, that part is not really done at the moment, but the output in my konsole looks OK).

Actually for my normal company work that format suites even better, as the projects there are normally even more fine grained than kate.git is (and for kate.git subprojects in kate/part/kwrite would even make more sense, above that is just an example).

Unfortunately there is not much done atm, beside some basic format handling in JSON and konsole output of the results, but I hope more will be done in the next weeks in my scratch repo.

Help Frameworks ;)

Thu, 02 Aug 2012 20:01:40 +0000

It is easy and fun, please help to fix the remaining small things in the cleanups section of the frameworks branch.

See here:
http://community.kde.org/Frameworks/Epics/kdelibs_cleanups

And use the nice and complete build howto here:
http://community.kde.org/Frameworks/Building

And yeah, I have already stolen some really easy tasks :)
Don’t allow David to have all the fun.

Bug Charts on bko

Mon, 23 Jul 2012 13:52:01 +0000

Since the upgrade on bko, the bug charts were a bit broken. Thanks to our awesome sysadmins, this is fixed now: Example for Kate. In case you notice any wrong behavior, please let the sysadmins know immediately! Thanks :)

kate-editor.org moving

Mon, 09 Jul 2012 21:18:56 +0000

The Kate homepage will move to a new faster server.

There will be some downtime in the next days, as DNS update will take some time and stuff needs to be setup on the new machine.

Hope we are back with an even faster homepage afterwards ;)

RFC: Data Recovery

Sun, 08 Jul 2012 19:15:25 +0000

Currently, we use our own passive notification bar to show a recovery bar when a swap file was found:

Since version 4.7 we have a class called KMessageWidget (api documentation). Using KMessageWidget, the notification could also look like this:

Imo, the new one looks nicer, as it much better distinguishes the notification popup from the rest of the ui. However, it several drawbacks:

the minimum width is now 800 pixel due to the label (too large, might break layout in apps)
the title “Data Recovery” was omitted
the “Help” link, showing a tool tip with further information, can not be added anymore (the api does not allow it)

Possible solutions:

put the buttons under the label, as it was in the old version (currently, the api does not allow it, so we’d need something like setButtonsUnderText(bool))
wrap the text in the label (looks aweful, since the buttons appear then between two lines of text)
to get the “Help” label back, the api would need to forward the QLabel’s signal linkActivated(const QString&)

I’m not sure whether the API can be extended in the 4.x line, though…

Comments?

And it is on…

Sun, 08 Jul 2012 17:35:26 +0000

Let’s see what comes out of it and let’s hope for the best (link on heise) :-)

Contributors, join and help the KDE e.V.

Wed, 04 Jul 2012 14:59:09 +0000

Hi,

just yesterday I got asked by one long time contributor, if he can at all join the KDE e.V. or if he needs to do something special for that. He thought it would be more an invitation only club.

It’s not ;) Anybody who does contribute to KDE can join us.

KDE e.V. definition from its homepage:
“KDE e.V. is a registered non-profit organization that represents the KDE Community in legal and financial matters.”

If you want to have a vote on such stuff and are ok with the rules and goals of the e.V. like you can read on the e.V. homepage, please join.

You just need to fill out the questionaire on the e.V. page and send it to some e.V. member you know and that will support your application.

Even if you are no contributor, but want to support us with money to make our conferences & sprints possible (and our infrastructure), please take a look at our “Join The Game” campaign.

Python plugin developer guide, part 1

Sun, 01 Jul 2012 11:46:19 +0000

I’m a Python newbie, so if you are at least that good :-D, you should be able to dive in and write useful Python plugins for your favourite editor too! This is the first in what I hope will be a series of notes and tutorials to help you along the way.

Where can I find examples to steal from inspire me?

Any good developer knows that a good way to launch into a new area is to look at examples, so here is a list of places I’ve encountered.

Plugins that came with Kate. These will be in the directory shown when you open the Python plugin configuration page, probably someplace like /usr/share/apps/kate/pate.
http://pypi.python.org/pypi/Kate-plugins
https://github.com/goinnn/Kate-plugins
https://github.com/mtorromeo
https://github.com/zaufi/kate-pate-plugins

Remember to respect others’ copyrights, and give credit where it is due.

Where do I put my code?

The Pâté Python plugin looks in several places to find usable plugins, you should be able to use the Python console to find a directory you can use for your developments. Select it, and press “Reload”:

Launch it from the View menu, and then ask KDE where your files should go:

Or, if that’s a bit hard to read, like this:

>>> from PyKDE4.kdecore import *

>>> print KStandardDirs.locateLocal(“appdata”,”pate”)

/home/srhaque/.kde/share/apps/kate/pate

Try the directory

If the given directory does not exist, create it. Press Reload, and the new directory should be visible:

You are ready to create your plugin in the new directory! This plugin directory will be added to the initial value of sys.path used for _all_ plugins.

Plugin structure and naming

Your plugin can be just a single .py file, such as “console.py”, or multiple files contained in a directory. A single .py file is useful for simple things, but if you want to use .ui files or multiple Python files, a directory is recommended. If you use this option, the main plugin file must be named after the directory, so:

If the directory is called “console”
The main plugin file must be named “console/console.py”

In the directory case, the directory is added to sys.path to load the main plugin file and other Python modules you may have. Since sys.path is _searched_ by Python in order to load modules, having the same plugin in multiple locations would be very confusing. Pâté supports this by refusing to load identically named plugins; instead they are highlighted as being hidden:

This also means you can just copy one of the plugins supplied with Kate to get started!

Kate in KDE 4.9

Sat, 30 Jun 2012 15:16:19 +0000

With KDE SC 4.9 around the corner and according to tradition, it’s time to have a look at what’s new in Kate.

**Improved Support for Custom Color Schemas
**

improved “Colors” tab in the “Fonts & Colors” config page
configurable colors: search & replace, code folding, indentation line,
schema export and import honor background colors (bug #291868) and font
“highlight selection” plugin and “search and replace” plugin now use search & replace colors from Kate’s color schema

Line Modification System

new option to disable in the editor settings: Appearance > Borders > [ ] Show line modification markers
colors of the line modification system are configurable

Build Plugin

reworked config page (including advanced settings for remote debugging)
support for remote debugging

Further Changes

new option in Open/Save config page: [ ] Add newline at end of file on save
all fixes in the bug tracker

Python plugin user guide

Tue, 26 Jun 2012 21:12:44 +0000

KDE 4.9 has branched, and so the Pâté plugin “host” for Python plugins has moved from Kate’s playground to be a mainstream plugin. Since a plugin-for-plugins might be a bit confusing, here is a quick tour of how it is managed and works, and especially a few rough edges it still has.

NOTE If you’ve installed this from a package, hopefully your distro will have added kate.so under PyKDE4 as needed, but if you are building from source, see the notes at the end of this post.

Start by enabling the enabling the Pâté plugin:

That should cause the Pâté plugin’s configuration page to pop into existence, but you may need to press the Reload button to see the right hand pane filled in like this:

Enable specific Python plugins of interest, and press the Reload button. The comment will be set to “Loaded”, then close and reopen the dialog (rough edge #1) to see any new configuration pages that the plugin provides:

Go back to the Pâté plugin’s configuration page, and now look at the second tab:

Use the combo box to select one of the built-in support modules (kate and kate.gui) or any of the loaded plugins. The first tab shows HTML documentation for the Python code and you can see any actions it has added into the Kate UI on the second tab (this will be empty for the built-in modules, but not for console):

It looks as though the Python console has added one entry to the View menu, alog with a shortcut. And so it has:

Yaay! See if you can guess what to do next :-)

IF YOU HAVE BUILT FROM SOURCE

And then installed the results in say /usr/local, attempting to enable the plugin may result in a crash with something this on the terminal:

>  File "/home/.../kate/plugins/pate/kate/__init__.py", line 38, in <module> from PyKDE4.kate import Kate
> No module named kate
> Could not import kate"

This is because the Pate build should install kate.so as part of the PyKDE4 bindings, but typically, a developer build will install this locally, and not to where the remaining system-supplied PyKDE4 files are installed:

Install the project...
-- Install configuration: "RelWithDebInfo"
-- Up-to-date: /usr/local/lib/python2.7/dist-packages/PyKDE4/kate.so
...

The system-supplied PyKDE4 binding modules should be in Python’s sys.path:

srhaque> python
Python 2.7.3 (default, Apr 20 2012, 22:39:59)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> print sys.path
['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7']

For me, Ubuntu puts PyKDE4 at /usr/lib/python2.7/dist-packages/PyKDE4, so we need a link from there to the actual location:

srhaque> ls -l /usr/lib/python2.7/dist-packages/PyKDE4/kate.so

lrwxrwxrwx 1 root root 53 May 20 09:51 /usr/lib/python2.7/dist-packages/PyKDE4/kate.so -> /usr/local/lib/python2.7/dist-packages/PyKDE4/kate.so

Note that just having this location in PYTHONPATH and/or in sys.path does not work because the PyKDE4 needs an __init__.py to be seen (see the one in the system directory to understand why).

I’ve not thought of a good way to simplify this for developers, and I assume end-users won’t see it because we’ll install in the default path. Suggestions/fixes welcome.

Extending Kate with Python

Mon, 25 Jun 2012 23:18:44 +0000

So there I am, a confirmed Kate user, and now I need to find my way around a codebase of over 100,000 files using GNU ID utils. The rather crude answer for Kate 3 was to write a wrapper around the lid(1) utility and the DCOP scripting interface of Kate, all driven from the built-in Konsole. The result was clunky but somewhat usable. But Kate 3? In 2010? Because the version of KDE on our primary development environment is the venerable KDE 3.3!

Eventually though, I decide the time had come for something a little nicer, and the answer seemed to lie in Kate 4 and scripting, except that the Javascript API didn’t seem to offer a way to get to the ID database. That had me stumped for a while until I came across Pâté, which allowed Kate 4 to be extended in Python. Sadly, it was unmaintained and there things stalled until, inexorably, I got to the point where the itch needed scratching.

That most basic driver of Open Source usually comes with strings attached, like the need to find a way to work in a new codebase, and with a new team of hackers. Plus, in the this case, the minor issue of being pretty much a Python newbie. Luckily it turns out that Kate has one of the most responsive teams I’ve encountered, the Pâté code seemed reasonably tractable, and the Python C API solidly documented. What could possibly go wrong? :-) Not that much, because we now have:

A Kate plugin based on Pâté
A Python debugger console Pâté plugin
And oh yes, an ID file integration Pâté plugin

The Kate plugin has a configuration page that allows individual Python plugins to be enabled or disabled, and if need be, system installed plugins to be overridden. Like the original Pâté, Python plugins can hook into Kate’s menus and shortcuts. Unlike the original, this version:

Allows Python plugins to supply Kate configuration pages just like native Kate plugins
Uses Python pickling to save configuration data, so arbitrary Python objects can be part of a plugin’s configuration
Provides for reloading Python plugins, which is really handy when writing new plugins
Supported threaded Python
Provides direct access to the documentation for Python plugins (though if anybody can figure out how to be information for variables, as well as classes and function, that would be wonderful!)
The sample Console and ID plugins try to show a selection of techniques

But help is always welcome to do better (How *should* i18n be done? What might Python 3 involve? What about some decent developer docs?). Any takers or clues much appreciated!

GSoC 2012: Vi Input Mode

Mon, 25 Jun 2012 20:45:28 +0000

Like last summer I am mentoring a student working on Kate’s Vi mode this summer. This year’s student is Vegard Øye from Oslo, Norway. I’ll let him introduce himself:

My name is Vegard Øye. I am a computer science student at the University of Oslo, Norway. I also have a bachelor’s degree in electrical engineering from Sør-Trøndelag University College in Trondheim, where I programmed for integrated circuits. It was a lot of fun, so I decided to embark on a grade with an even larger emphasis on programming.

My goal is to make modal editing more widespread outside of Vim. There is a Zen-like benefit to using a tool that does just what you tell it to – slicing and dicing text with surgical precision. My focus is not on adding new features to Kate (although I have implemented a few), but on sharpening existing functionality. In particular, I want to improve the integration between Kate’s vi mode and its extension system, as well as sort out various bugs pertaining to the vi mode.

Vegard has already done some really great work, and his changes should be trickling in to Kate’s git repository the next weeks. You can follow his work at http://quickgit.kde.org/index.php?p=clones%2Fkate%2Fvegardoye%2Fvegard_gsoc_2012.git.

Akademy 2012 – See you in Tallinn ;)

Mon, 25 Jun 2012 18:35:51 +0000

One year more passed and the next Akademy will soon open its doors.

Was never before in Tallinn or Estonia, will be an interesting visit.

Hope to meet again a lot of old and new KDE people.

Didn’t code a lot at all since last years meeting, too busy to finalize my phd thesis.
Hope to get more time for Kate in the next months again ;) And at the meeting.

Why KDE, and Kate

Wed, 20 Jun 2012 23:49:10 +0000

I’ve been using and contributing to KDE on-and-off for a while, but our friends over in Gnome land were already busy by the time I got into the game. So why did I conceptually commit to KDE, and thence Kate? Consistency.

I grew up on VAX/VMS where it was possible – and even easy – to mix Ada code with C and Pascal, mix in a CLI that used the standard parser, generate error messages that looked and *were* like every other message in the system. Everything felt integrated.

And the editors? Ah yes, the editors. VAX EDT was where I started, and I *loved* the fact that I used the same editor whether I was writing a VAXmail, posting a VAXnote, or editing a file. So it was a bit of a dilemma when I encountered VAX Emacs, with all its seductive extensibility. I ended up using Emacs for serious editing, and EDT for everything else…that was hateful. Eventually, TPU and its precocious offspring LSE restored the status ante, and my sanity.

Scroll forward a few years, past Windows NT 3.5 and Visual Studio where I got hooked on GUIs, and we get to Qt and KDE libs. Even though there were several KDE text editors in those early days, it was a reasonable bet we’d rationalise, and I’m delighted to say we did (even when Kmail’s default isn’t KWrite – at least the look’n’feel was the same). I even went round making every Find and Replace dialog throughout KDE the same.

So we get to Kate. Right out of the box, even in its Kate 3 incarnation, I loved Kate. Standalone was good, in KDevelop it was even better. I didn’t miss the relative lack of extensibility because well, it did pretty much everything I wanted. And then I changed job…

RFC: Exporting JavaScript API

Sat, 12 May 2012 13:36:10 +0000

Since quite some time, Kate Part has build-in scripting support through JavaScript. Our plan is to make this API public, so other applications like Kile, Kate App and KDevelop can use it. However, we are currently unsure how to best implement it, so this is a rfc to get feedback.

The bindings for a Kate Document are for instance located in part/script/katescriptdocument.h (header, implementation). As you can see, there are functions like

Q_INVOKABLE bool insertLine(int line, const QString &s),

which can be invoked in our scripting by a call of ‘document.insertLine(5, “hello world”)’. The API only contains basic functions. But for instance Kile maybe also wants to provide a function called ‘document.insertSection()’ or similar LaTeX related functions. The question now is as follows: How can Kile extend our QObject based prototype with their own QObject based classes?

We do not want to make the class KateScriptDocument public. Instead, we just want to return a QScriptValue containing a QObject based KateScriptDocument. You can think of the problem also as follows:

// in Kile:
QScriptEngine *engine = ...;
KTextEditor::Document *kteDocument = ...;
QObject* kateScriptDocument = kteDocument->scriptDocument();
engine->globalObject().setProperty("document", engine->newQObject(kateScriptDocument));
// at this point, the JavaScript object 'document' contains all KateScriptDocument functions
// next, we want to add the Kile related document functions
KileTextDocument* kileDocument = ...;
QObject* kileScriptDocument = kileDocument->...(); // some function that returns the binginds object
// now: how can we populate the 'document' property with the functions in kileScriptDocument?
engine->globalObject().setProperty("document", ? );

If you have any idea or other solutions how to do it right, please let us know!

Crash through D-Bus calls

Fri, 06 Apr 2012 10:36:51 +0000

Years ago, there was a blog on the planet with the title “How to crash (almost) every Qt/KDE Application and how to fix it“. In short, if you are showing a dialog, KWin prevents you from closing the application by clicking on the close button in the window decoration. However, through D-Bus, you can still quit the application. A solution was also provided: Use a guarded pointer to create the dialog.While this fixes the issue, it looks like fixing the blame, and not the real issue. Stricktly speaking, even the Qt documentation would be wrong then.

Searching for ‘Accepted’ on lxr.kde.org shows lots of dialogs that lead to possible crashes. I wonder whether developers are really aware of this crash? Even if we took care of this issue as proposed, it’s just a matter of time until dialogs are created the `wrong’ way again (do we have krazy checks for that?). In Kate, no one took care of this situation, meaning that you can indeed crash the application through D-Bus.

Is there a better way to fix this?

On Removing an Element from a List

Sat, 17 Mar 2012 12:10:11 +0000

Recently, there was a very good blog about The Importance of Mentoring. It was mentioned that the 3200 slocs of the gsoc projects could be cut down to 500 slocs, doing exactly the same thing.

While hunting some crashes in the new code folding code from the last gsoc project, I obviously had a closer look on how things are implemented. The code folding uses a simple tree structure. Nodes can be added, removed or moved around. So I stumbled over the following code:

01 // removes it from children list (QVector)
02 bool SomeClass::removeItem(Item* it)
03 {
04 bool found = false;
05 int i;
06
07 for (i = 0 ; i < children.size(); ++i) {
08 if (children[i] == it) {
09 found = true;
10 break;
11 }
12 }
13
14 if (found) {
15 children.remove(i);
16 return true;
17 }
18
19 return false;
20 }

This code appears several times in different locations. It can easily be rewritten as

01 // removes it from children list (QVector)
02 bool SomeClass::removeItem(Item* it)
03 {
04 int i = children.indexOf(it);
05 if (i != -1) {
06 children.remove(i);
07 }
08
09 return i != -1;
10 }

So without much work, the code is reduced to the half. Diving further into the code, I stumbled over a class KateDocumentPosition. This class is a line/column tuple representing a position in the document. It features operators like <, >, for convenience. Now you may guess it: Kate Part is a _text editor_ using “document positions”all over the place, e.g. for the cursor, the text selection, bracket matching, search & replace and what not. In fact, there is no way around using line/column tuples as position markers. Thus, it should not be surprising that we have a public class called KTextEditor::Cursor, featuring everything what KateDocumentPosition implements (and more). The Cursor class is basically used everywhere, and it works as expected (our unit test rely on it, too). There is no need to duplicate the code. This probably happened because the student was not aware of it.

Martin writes “Be prepared for the worst“. Well, true. In this case, the project was successful and the new code folding works better than the old one (after fixing the crashes). Now if you are a gsoc student reading this blog, don’t feel discouraged. Rather feel encouraged to communicate with the developers a lot, e.g. by discussions on the mailing list :-)

Append Newline at End of File

Mon, 12 Mar 2012 21:20:58 +0000

In KDE SC 4.9, Kate Part will have an option in the Open/Save config tab called

[ ] Append newline at end of file on save

By default (and Kate tradition), this option is off. You can also use the document variable (modeline) newline-at-eof [bool], either in the file itself, in a .kateconfig file, or in the “Modes & Filetypes” config page. If a newline was added, it is visible only after reloading the document. This finally fixes wish #256134.

Some Kate Color Schemas

Wed, 07 Mar 2012 21:31:18 +0000

As already mentioned, Kate Part much better chooses colors from the default KDE color palette configured in System Settings in upcoming KDE SC 4.9. As teaser, here are some examples – hope you like it.

Default “Oxygen” Color Schema

Default “Obsidian Coast” Color Schema

Dark “Vim” Color Schema

Note: The yellow search background comes from the “Highlight Selection” plugin, which is still a hard-coded yellow. Kate Part’s “Search & Replace”chooses more fitting highlight colors for matching and replaced text.

Yet another update for the Colors tab

Thu, 01 Mar 2012 19:07:13 +0000

Now, the categories in the “Colors” tab are painted like in System Settings (top: new, bottom: old):

Thanks to Rafael Fernández López for relicensing the code of SystemSettings’ CategoryDrawer under LGPLv{2,3}.

Color Settings

Thu, 01 Mar 2012 10:28:44 +0000

This week, Kate Part received an update of the “Colors” tab in the settings dialog, available in KDE 4.9. The major features include

configurable colors: search highlight, replace highlight and modified line colors – finally :-)
possibility to always use colors from the KDE color scheme.
the implementation works in a way that at some point, the host application (KDevelop, Kile, …) can put items into this list.

Here are screenshots of the new (top) and the old (bottom) color tab:

The new implementation uses a QTreeWidget along with a custom delegate to draw the colors button and reset icon. It would be nice to have an appearance of the categories like in systemsettings, or like in dolphin. Dolphin probably uses a KCategorizedView, which in turn uses KCategoryDrawer. KCategoryDrawer could be used, but needs fine tuning in order to make it look nice. Does someone know how systemsettings draws the nice shaded backgrounds of the categories?

Akademy 2012 – We are on the way! (soon)

Sun, 26 Feb 2012 16:54:12 +0000

Perhaps a bit early, but typical german, me and Dominik booked our flights to Tallinn.

Lets hope we will have a lot fun there and meet old and new friends ;)

See you all, at Tallinn.

Disable Line Modification Indicators

Sun, 26 Feb 2012 12:15:17 +0000

On KDE 4.8.0, there is no way to disable the line modification markers.

In KDE >= 4.8.1, you can disable them as follows by first closing Kate and then typing

kwriteconfig --file katerc --group "Kate View Defaults" --key "Line Modification" --type bool false

To enable it again, close Kate and run

kwriteconfig --file katerc --group "Kate View Defaults" --key "Line Modification" --type bool true

However, this only affects Kate; not KWrite, Kile, KDevelop or any other application using Kate Part. If you want to disable the markers for KWrite, Kile or KDevelop, use kwriterc, kilerc or kdeveloprc instead of katerc.

In KDE >= 4.9, there is a graphical option in the editor configuration dialog in “Appearance > Borders > [x] Show line modification markers”.

Scripting in Kate

Sat, 21 Jan 2012 11:13:41 +0000

Since several releases, Kate Part has scripting support through javascript. So far, it seems it is not much used by users. Still, I stumbled over two extensions:

If you have more user defined scripts, it would be nice if you let us know! For KDE5, we plan to extend this, so applications like Kile or KDevelop can reuse Kate’s internal code.

On another note, here is a nice blog about the upcoming KDE 4.8 release :-)

Highlighting Search & Replace Matches

Thu, 22 Dec 2011 10:30:52 +0000

On Being Wrong

Wed, 21 Dec 2011 22:27:48 +0000

Maybe a good read: On being wrong. It’s about why it’s so hard to admit that you are wrong, and more.

Kate in KDE 4.8

Tue, 20 Dec 2011 23:17:07 +0000

About half a year ago, Kate 3.7 was released as part of KDE 4.7. Now that KDE 4.8 is about to be released, let’s have a look at what Kate brings in KDE 4.8.

Bug Fixes

According to KDE’s bug tracker, about 190 issues were solved. Taking a closer look, lots of small issues were fixed, amongst them:

improved printing support (report 1, report 2, report 3, report 4, report 5, and more)
syntax highlighting files added and updated
zoom in/out with ctrl+mouse wheel, scroll over folding area
wrong active view when resuming session with split view
ambiguous shortcuts in file system browser resolved
improved GDB plugin
we heavily cleaned up our bug database (bugs + wishes):

Heavily Reworked Code Folding

As part of the Google Summer of Code (GSoC) 2011, the code folding code was improved. The main goal was to eliminate wrong folding behavior and fix all crashes while making the code more maintainable. We are quite happy with the results: Given the robust behavior, it now was possible to remember code folding state past sessions and during document reload. So folded regions are not lost anymore.

Additionally, the visual appearance was changed to be rather decent.

Improved Vi Mode

Also as part of the GSoC 2011, Kate’s vi input mode was heavily improved.

Search & Replace in Files

The “Find in Files” plugin is now replaced with the new “Search and Replace” plugin: It basically contains all the features of “Find in Files,” but additionally has the following features:

either search in files-on-disk, or in all the opened documents
all search matches are highlighted
replace support: matches can be (selectively) replaced with other text

Line Modification Indicators

Kate has a shiny new line modification system. Read all about it in this dedicated article. Mandatory screenshot:

Document Variable (Modeline) Editor

Kate (and thus all applications use Kate Part) can be configured by using document variables, also known as modelines. Since it’s hard to remember all the available keys and values, a dialog helps out in the config dialog. You can read about all the details in this dedicated post (screenshots).

Documentation Updates

T.C. Hollingworth put a huge amount of work into the Kate and KWrite handbook. Thus, the documentation is much more up-to-date and we hope it helps to learn using Kate effectively more quickly. The official version is available on docs.kde.org.

Current State & The Road Ahead

Apart from the upcoming KDE 4.8 release, Kate turned 10 years old this summer. All in all, we can proudly say that Kate has a solid code base in its current state. The smart ranges were replaced by the moving ranges. Code folding is more clean with less bugs. Our plugins got a lot of updates. The documentation has improved. Of course, more help is always welcome. So if you are interested in Kate development, you are welcome to build Kate from sources and join our team by sending patches.

Thanks to everyone contributing to this great release :)

Evolution of Kate Development (Take 2)

Sun, 06 Nov 2011 14:31:15 +0000

Dominik’s video is cool, but we agreed that perhaps the names should be around and we can have a bit higher resolution to make them readable ;)
Therefore here is a second take of the video, this time with names and 720p. (I have no luck with music, therefore, silence)

You only get to see the video if you visit our blog page here.
Direct HD link to YouTube here.

Command to create it (if YouTube eats it):

gource --multi-sampling --seconds-per-day 0.02 --auto-skip-seconds 0.1 --camera-mode track --stop-at-end -b 000000 --hide filenames,dirnames --disable-progress --date-format “%Y-%m” --viewport 1280x720 --output-ppm-stream - -r 60 | ffmpeg -y -r 60 -f image2pipe -vcodec ppm -i - -vcodec libvpx -b 10000K -threads 4 kate-gource.webm

Evolution of Kate Development

Thu, 03 Nov 2011 21:49:44 +0000

Recently, the Kate project celebrated its 10th anniversary. The gource visualization of 10 years Kate development (2001 to 2011) looks as follows. Have fun :-)

PS: In case you do not see any video, click here.

PPS:Launch gource on kdelibs, that’s much more interesting!

qt-project.org online ;)

Fri, 21 Oct 2011 11:10:07 +0000

Seems the Trolls made it, qt-project.org is online ;) Grats.

Plasma Active

Sat, 15 Oct 2011 18:09:20 +0000

At the desktop summit, many contributors got a ExoPC from Intel, but the software on it was quite a disappointment. Meanwhile, there is an official release of Plasma Active that fills the gap. So I sat down and installed it on the ExoPC. It really works quite nice and smooth. Applications like Amarok and a browser make it usable to hear music and do some quick internet surfing. I documented the steps in order to get everything up and running.

Running Plasma Active One from the USB Stick (LIVE version)

To get a quick impression, you can download the file plasma-active-one.iso from open-slx.com. Then, plug in a USB stick to your computer and run the comand

sudo dd if=plasma-active-one.iso of=/dev/<DEVICE> bs=1M

where corresponds to the USB stick (in my case, this is sdc). When finished, plug the USB stick into the upper USB port of your ExoPC and press the power on button. Make sure to tap “BBS” immediately and choose the USB stick as boot device. After this, choose the first entry to start the live version of Plasma Active.

Note: As of 2011-10-15, a installation with this live version is not possible (even though some documentation at some point or the splash screen suggest otherwise).

Installing Plasma Active on the Hard Disk

In order to get Plasma Active on your hard disk, you first have to install openSUSE 11.4. To this end,

download the 4.7 GB DVD image of openSUSE 11.4 (32 bit), and copy it on the USB stick (in my case = sdc):
sudo dd if=openSUSE-11.4-DVD-i586.iso of=/dev/ bs=1M
plug the USB stick into the upper USB port of your ExoPC and press the power on button
make sure to tap “BBS” immediately and choose the USB stick as boot device
after this, choose “Installation” to start the install process (you need an external keyboard on the lower USB port)
follow the installation routine, choose the KDE desktop, do the partition setup, create a new user account and finally start the installation
copying files takes some time. After this, the system finally boots to proceed with the automatic configuration.
Finally, the system arrives in KDE. (From now on, the USB stick is not needed anymore.)

The touch screen does not work out of the box. Hence, I restarted X from the console with /etc/init.d/xdm restart. After that, the external mouse and keyboard worked (ignore the fact that you might be greeted by 6 crashed akonadi windows).

Once you have the internet up and running, proceed with 1.5 Installation on Balsam Professional or openSUSE. This updates your kernel to properly support the touchpad and replaces the default Plasma Desktop with Plasma Active.

Kudos to the Plasma Active team and all involved contributors and supporters!

PS: Although a text editor is probably not of much use on a tablet PC, KWrite is available :-)

One great man less :(

Thu, 13 Oct 2011 15:03:16 +0000

Dennis MacAlistair Ritchie died at home this weekend.

[][2]

Dennis MacAlistair Ritchie

As the creator of the C programming language and one of the main developers of Unix, he impacted the life of me and other developers a lot.

Even today, 30 years after their initial creation, many people work on Unix like systems (like Linux or Mac OS) and develop in (Objective) C(++).

For me C was one of my starting languages for my real programming work and even today I analyze the whole day software written in C for embedded systems that control our modern world, be it the flight control of airplanes or engine control of cars.

Without his initial ideas and work, today there would be no Linux kernel, no Mac OS, …

We all owe him a lot. He changed the world.

Thanks for your great inventions! You won’t be forgotten.

Just two impressive Ritchie cites:

“Unix is simple and coherent, but it takes a genius – or at any rate a programmer – to understand and appreciate the simplicity.”

“The greatest danger to good computer science research today may be excessive relevance. If we can keep alive enough openess to new ideas, enough freedom of communication, enough patience to allow the novel to prosper, it will remain possible for a future Ken Thompson to find a little-used Cray/1 computer and fashion a system as creative, and as influential, as Unix.”

About Kate Redesigned

Sat, 24 Sep 2011 09:32:19 +0000

With some of my gimp skills, I updated Kate’s feature list. Hope you like the face-lift :-)

Qt open governance will go live!

Mon, 12 Sep 2011 18:15:59 +0000

Finally some sustainable announcements about the future of Qt and its open governance project:

http://labs.qt.nokia.com/2011/09/12/qt-project/

http://blog.qt.nokia.com/2011/09/12/qt-project/

I hope this will be well received and we will see yet another increase in contributions to our Qt/KDE ecosystem ;)

Thanks for all the effort to all people who made this possible!

Code Folding Updates

Sun, 11 Sep 2011 17:23:17 +0000

Christoph and me cleaned up the visualization of the code folding for KDE 4.8 a bit. In the snapshot, the left image shows the old behavior, and the right one shows the new behavior. The background highlighting appears as soon as you hover over the code folding bar. We hope you like it :) Mockups of how to make it even better are welcome, of course! You can try it by building Kate yourself, if you want.

Line Modification System

Tue, 06 Sep 2011 18:31:54 +0000

Some days ago, Dominik implemented a line modification system in the KatePart.
For all who don’t know what that means at all (like me before the DS 2011), here some screenshots.

First, starting with a fresh loaded file:

Now, lets write some lines:

Next, after saving:

Now, lets change some stuff again:

Awesome :)

First I thought: Why to hell do I need such a feature? But after using it some days now, I think it is really VERY useful.

Yesterday I worked in parallel on code that generates integer linear programs as CPLEX files and read the output files (which are > 100000 lines) to find regressions.
I had to manually tweak the ILP files a bit to reveal the reason of my issues and it was just cool to exactly know even after save, which lines in the ILP I touched.
Normally I would have written some comments like \changed… above my modified lines in the output files, but yeah, KatePart does track such stuff now automatically ;)

Even for the much less big source files, it was nice to see:
Oh, I just tweaked that few C++ lines and it did remove the issue, maybe I should look at the lines below/above of that lines, too, for more possible problems?

Therefor: Thanks to Dominik for this nifty feature, I hope others appreciate it, too!

If you want this feature now: Use the guide at kate-editor.org’s Get It!.

Coding Style and API Design

Sun, 28 Aug 2011 19:06:45 +0000

Once in a while, there are really interesting blogs, presentations and reports about how to do things right as software developer. This is a quick list of links about API design and coding style:

Designing Qt-Style C++ APIs (Qt4), by Matthias Ettrich, 2005
API Design Principles, extended version of (1), Qt Developer Network (Nokia)
The Little Manual of API Design, an in-depth summary of (1) and (2), Jasmin Blanchette, 2008 (Nokia)
Developing Quality Libraries, presentation of (1)-(3) on the Desktop Summit in Gran Canaria, Oliver Goffart, 2009
How to Design a Good API and Why It Matters, Joshua Bloch, 2007 (Google)
Qt Coding Style, good coding style not limited to Qt, Qt Developer Network (Nokia)
Guidelines for KDE Development, similar to e.g. (6), KDE Techbase
Hall of API Shame: Boolean Trap, Ariya Hidayat, 2011

Thanks to all the authors for sharing & happy reading!

GSoC’s ending

Thu, 18 Aug 2011 11:42:35 +0000

Soon the GSoC projects of this year are over again.

I would like to thank our two students Adrian Lungu and Svyatoslav Kuzmich for their work!

They both did a nice job and improved both the code folding and the vi mode a lot.

Thanks to them and I hope they stick around in our project, more help is always welcome ;)

And thanks to Google for sponsoring their efforts.

Kate Banner Wanted

Wed, 17 Aug 2011 16:39:59 +0000

As part of Christophs idea to give Kate a new face, it would be nice also to have a Kate banner, that every Kate fan can use to show in the Web. Something like the following, but any ideas are welcome!

kate-editor.org Updates

Tue, 16 Aug 2011 18:44:22 +0000

After adding the new design to the Kate homepage, I got some feedback about broken fonts and other stuff. Most should be fixed now, e.g. the “The Team” page now looks kind of okay again.

In addition, we now have some nice feed display with the latest commits and overall a bit cleanup page. For mobile devices, like my Android phone, we now have WPtouch installed, which provides some rather nice layout for small screens (but allows easy switch back to normal layout, too).

If you have any additional comments, what could be changed, just write me a comment or a mail.

The (GSoC) season is ending…

Mon, 15 Aug 2011 15:54:56 +0000

Hi everyone!

So… this GSoC season came to its end. This week is the official deadline for the projects and, happily, my project is done, but my collaboration with Kate is just starting, so I’ll see you around :)

As I mentioned in the previous post, I used this last week for some fine tuning and to close the bugs that slipped the previous scan. The folding-related bugs remained on bug.kde.org are highlight related too, so I can’t do much about them. The folding submenu was changed, so we can add more features into the feature. You can find the old and the new folding’s submenus in this article. You can see that the new folding has new features and it’s more flexible. Now you can fold/unfold a specific level entirely, or you can fold/unfold the node that contains the cursor. I have one regret regarding these new features: we couldn’t find some key-shortcuts for them :(

The last feature added is: collapse all multi-line comments. This was a wish from bugs.kde.org. I couldn’t solve it entirely (to collapse all comments at once) because, as you might know from my previous articles, Kate’s folding is based on Kate’s highlight; it doesn’t have its own parser. There is no highlight for single-line comments, so we can’t fold them. But I hope this will help too (it might prove very useful in large XML files for example).

Another cool (new feature) is remembering the folded lines. I don’t remember having talked about it so far. :)
What does that mean? Well, if you work hard to fold a lot of lines and you accidentally close your file, you don’t have to take it over again. All the folded nodes remain folded when you close/open a file or when you reload it. Pretty nice, don’t you think ? ;)

The new folding will probably be included in version 4.8. For now, you can use it if you download Kate’s sources and compile them.
Finally, I would like to thank you guys for supporting me and my project and if you didn’t use Kate’s new code folding, then get the last sources, compile them and let the magic begin! :P

Greetings,
Adrian

Kate needs a Face, Artists wanted

Mon, 15 Aug 2011 15:29:16 +0000

Kate’s icon is quiet nice, but for our website and other stuff, it would be really cool to have some eye catcher and something to know: yeah, that is Kate :)

As Kate is obviously a woman, at least in most languages, it would be quiet nice if some artist could come up with a painted or rendered one to put on our page.

Perhaps something Sintel like, at least she played with dragons (hope poor Konqui got not killed, too) and I guess a mascot like here won’t scare of either men or women.

And no, we don’t want here any men’s dream images or sexist stuff like that, just something that looks cute. If you want to help with this, just drop a mail to either me or the kwrite-devel list. Be aware, it must be original work and it should be licensed under something like the CC license.

If nothing arrives for us, perhaps I really need to bug the Blender foundation to use their stuff for the website. Better eye catcher than my normally used insect of the day ;)

Kate in Berlin

Mon, 15 Aug 2011 08:46:56 +0000

Just as proof that we really were at the desktop summit in Berlin: We Kate developers sat one evening together for dinner. From left to right: Kate’s plugin master, the Holy Belliness, KDevelop, Gnome, Kate Finder, Kate Vi Mode, Kate Snippets (and myself not visible, taking the photo) :-)

Good Morning Kate – New Day, New Design

Mon, 15 Aug 2011 01:47:12 +0000

Kate has since more than one year a new WordPress powered site. During last years Akademy, Dominik and I installed it and filled it with first life.

It replaced the old Drupal powered site, that Anders did set up years ago. Thanks again to Anders here, for the work he did on the old page. But since the day Anders didn’t have that much time any more for Kate development, it somehow lost its drive (as Dominik an I are not at all capable to work with Drupal, whereas Anders really was an well practiced Drupal admininstrator). The current WordPress site is much more usable for us, as we know WordPress much better than Drupal. The initial import of the content of the old Drupal page was kind of painful, but most stuff was moved over even during Akademy, just some outdated howtos and faqs got purged.

Since over an year, the current page is a vibrant source of news around Kate and KDE in general. It helped to promote Kate and for example provided our GSoC students with a central place to post about their projects.

Today I was kind of bored, after being back from the Desktop Summit in Berlin, therefore I have taken a look at the design of our page (and I searched for nice eyecatcher, here a Monarch, link to german Wikipedia, as there the image was found).

As we started the page, I experimented some days with WordPress themes and finally ended using Carrington Blog. Whereas it did not really have a suitable layout for our page, its look and feel was nice and 5 lines code later, it had a for us usable one column layout.

Today I revisited the design and somehow thought why not refresh the page. After wading for several hours through “free” themes of any kind, I arrived at PressWork. Its very plain design just caught my eye. And even better, it has some nice HTML5 based interactive editor to fiddle around with stuff like sidebar placement, sizes, fonts, colors, … Nice! After a bit over a hour playing around with it, I got a kind of nifty new and fresh design going. Event without any pictures, it really is kind of elegant ;) (At least for my taste).

Therefore, all that wake up soon, here it is, kate-editor.org in a new fresh design. It is not really finished, will play a bit with colors/widgets/sizes/… around in the next days. But overall, I think it will stay that way. Lets hope for a next successful year for both my poor small editor (component) and its website!

Together with the new design, I added buttons to allow easy sharing of posts with social media of any kind (thanks to Dominik for the idea). Lets see if that keeps even more readers rolling in here. Spread the work. We both want a lot more users and a lot more contributors (and yes, I count documentation writers, usability guys and others in, not only developers).

Thanks to all contributors, keep rocking!

Now: good night, or better, good morning!

200 Bugs only ;)

Sun, 14 Aug 2011 12:34:35 +0000

Kate (App + Part + KWrite) is down to 200 bugs, thanks a lot to all people helping with this effort, e.g. Dominik, Erlend, Adrian, …

Perhaps others want to join, we have still a lot bugs and many are quiet some work (and stuff like BiDi errors are not that nice to fix, if you have actually no clue about the used languages :/)

Added “gq” (format text) command for the Vi Input Mode

Fri, 12 Aug 2011 13:14:31 +0000

It’s been a nice week here in Berlin at the Desktop summit. I have even got some coding done. A command I often missed from Vim was the gq command that re-formats text based on your text width setting. For example, if you want to stick to a sixty-columns layout, you often have to re-format the text when adding or removing something, like in this screenshot where some text has been surrounded by HTML tags:

By using the gq command, the text will be re-formatted and looks nice again:

I have implemented this command now, so this will be in Kate for KDE 4.8. I hope other users of the Vi Input Mode find it useful too. :-)

Bug Fight!

Fri, 12 Aug 2011 11:47:42 +0000

Lets fight the bugs (or here bugs fighting each other, from de.wikipedia).

Dominik and I did a nice bug squashing here at Berlin Desktop Summit 2011. We already met some weeks ago to hunt down bugs in Kate at Saarbrücken, but this additional time really helped a lot. The progress of the last 365 days look quiet promising.

We actually really fixed quiet a lot of them and sorted out no longer valid ones. In addition a lot of wish list items got either done or invalidated. We just can’t keep wishlist items for any missing feature we have, e.g. for any missing highlighting. It is not manageable. We won’t close any wishs for valid extensions, but stuff like: i would like a hl xml file for XYZ or I would like a js indenter for XYZ must go away. Either submit a own .xml or .js file for the job or we won’t get it anyway.

Here a BIG THANKS to all people that actually submitted for example new highlighting files in their wish list items or who pointed to places to get open source highlighting files to add!

It would be really nice to get some help with the bugs/wishs.
A lot are just very small things to do, but nobody in the Kate team has really a lot time for it.
Others just take a lot of time to debug and fix, which is not available, either :(

To write a highlighting, we have a real well tutorial here.
The same holds for indentation javascripts, look here.
If the tutorial lack anything, we are really happy about any update for them!

If you like Kate and use it and have any clue about developing with C++ (and a bit knowledge about Qt/KDE), please step up and help us to fix the remaining issues. Any help is welcome and on any recent distribution you can build Kate in no time with this tutorial. You need no bleeding edge KDE, 4.⁵⁄₆ should be ok, for sure 4.7 will work, too!

Please all interested people, head over to Kate’s bugs and Kate’s wishs and help to get rid of them!

But please have a hearth for the real bugs, like the above shown Lucanus cervus, they are quiet rare, at least here in Germany!

Kate Turning 10 Years Old

Thu, 11 Aug 2011 14:59:39 +0000

We almost missed it, but 10 years ago Kate was included in KDE’s CVS repository and shipped the first time with KDE 2.2. Details about the history can be found here. So Happy Birthday Kate! And Kate in KDE 2.2 looked like this:

In comparison, Kate nowadays looks like this (KDE 4.7):

Plasma Active, the stage is yours

Thu, 11 Aug 2011 09:29:27 +0000

Thanks a lot to Intel for passing around the ExoPC at the AppUp workshop yesterday. Its kind of nice hardware to start developing for Intel based tablets, whereas for normal use, the battery life and weight is kind of problematic. I really like the idea to be able to write nice and shiny Qt applications which run both on MeeGo and Windows and the AppUp store is really open in respect to allowing distribute open source software.

But…

After playing a bit with it last night (it runs some preloaded MeeGo image with the table UX from Intel), for me it is clear, Plasma Active is here the way to go.

The pre-installed tablet UX is really, lets say, interesting. Already the startup is kind of weired: your X comes up, you see the ugly X11 default cursor and then, after some flashing around small windows, the UX is there. Some triangle at the right let you go to the main screen. But no, you not drag at it, you need to click. If you then start using the UX, you get kind of scared away by either rendering artefacts, lags or really interesting design concepts (to go back to main screen from an application, you need to touch the left/right upper corner, without any visual hints, kind of confusing, I am dumb, I just rebooted several times to come back to the main screen). In addition, at least this MeeGo version doesn’t seem to be able to handle multi-touch, which really kills off any fun on using, you can’t even zoom your pictures (or just the applications don’t support it, in any case compared to this, Nokia’s N9 has really a powerful UI).

The good thing is: You need not to use the default MeeGo installation. The hardware is really open in the sense that driver support is no issue (the nice thing with mostly standard Intel hardware). So, go fetch your most recent and flashy Plasma Active image and have fun.

Plasma Active has really a big chance here! Given the current state of the “default” MeeGo table UX, Plasma Active is BIG step into the right direction. I hope the Plasma and KWin developers keep on improving this.

A shiny Wayland based KWin + Plasma combo might really be a game changer here (presentation about KWin + Wayland).

I hope more people and perhaps companies (like basysKom, which did a real nice job with the above shown Contour shell for Plasma Active, short article here) step up and start pushing this effort even more.

Therefore: Thanks again to Intel, I guess they will see more MeeGo apps around soon and lets hope that Plasma Active will get a nice boost, too. Intel will benefit from a better UX in any case!

Maintainer Needed: Kate – External Tools Plugin

Tue, 09 Aug 2011 16:11:49 +0000

The “External Tools” plugin is one of the oldest plugins of Kate. A big hug to Anders Lund for writing it years ago, a lot of people enjoyed using it.

It allows the user to specify own commands (aka snippets of shell programs) to be executed with the text of the current document or the current file.

Basic stuff you can do with it:

Create you a little command that shows an Git/SVN/… diff of current file
Sort the file with command line sort program (or more advanced scripts)
Pipe the text of the document into your most loved perl script

Unfortunately there is no maintainer for it at the moment. Therefore it will be disabled for KDE 4.8, as a lot of bugs sneaked into it during the late 3.x and whole 4.x life-cycle. (Mostly because of bad porting done by me and others and no time to fixup any real bugs)

If you want to step up for maintainer ship, please contact me (cullmann@kde.org) or kwrite-devel@kde.org.

Thanks a lot in advance ;P

Btw., some of the bugs (now no longer valid but interesting for future maintainers):

GSoC – Kate Code Folding (Bug-less)

Sun, 07 Aug 2011 20:21:28 +0000

Hi everyone!

Another season of Google Summer of Code is approaching its end. :(

I feel pretty bad about that, because I enjoy it and I love working on Kate.

I used the last two weeks to solve all the bugs and requests (folding related) from bugs.kde.org. If you find any folded related bugs, please send the report using bugs.kde.org and I will solve them (the warranty period is unlimited, so you don’t have to worry about that ;) )

The next two weeks (the time remained until the dead line) will be used to write the documentation and to do some look changes, according to the code reviews received from the Kate community. Also, I will write some tests. Writing automatic tests for the folding is not such an easy task because you have to check a lot of stuff: the highlight, the folding sign, the folded lines, the line that remains visible and other things. And there are so many languages that act differently. That’s why I preferred to do the tests manually, so far. Anyway, I will write some units that will test the bases of the code folding, like number of lines left after a folding or some delete/insert operations occurred.

I consider this project a success and I hope that the Kate team has no regrets for choosing me for this GSoC season. :)

Enjoy Kate’s new code folding! ;)

Adrian

Kate Vi Mode Test Suite – GSoC 2011

Sun, 07 Aug 2011 09:06:02 +0000

This summer vi mode has a new test suite. Now there are over 250 tests and the number of them still growing.
It’s very easy to add a new test. All you need is just to add the
DoTest(“Original text”,”Vi command”,”Expected text after doing vi command”);
line to part/tests/vimode_test.cpp.
Format for command with CTRL – modifier: \ctrl-x, for command -mode command: *\:command\*.
There are little restriction: you can’t input text while being in input mode.

Exampls:
DoTest(“foobar”,”Vypp”,”foobar\nfoobar\nfoobar”);
DoTest(“foo\nbar”,”\ctrl-vjl~”,”FOo\nBAr”);
DoTest(“foo\nbar\nbaz”,”\:2,3delete\”,”foo”);

It’s also a good format for bug report or for feature wish for vi-mode.

Code Folding Updates

Sun, 31 Jul 2011 08:22:15 +0000

As you may know the Kate code folding implementation gets some love these days. The last days, several bug fixes dropped in by our GSoC student. And the good news is that if all works well, we’ll be able to backport these fixes so that the code folding is much more robust in our beloved Kate even in KDE 4.7.x. These changes probably fix several crashes that were around since 2005 as well. I believe the word we’re looking for is: owned! :-)

GSoC – Kate Code Folding (some more details about folding)

Tue, 26 Jul 2011 19:29:11 +0000

Hi!

Yesterday I received a comment on my previous blog post that it would be nice to give some more technical details about the folding.

Initially, this was a comment response, but because it proved to be pretty interesting and more of you read the articles than the comments, I decided to post it as an article :)

Here are some details that you could find interesting:

Kate’s folding is based on a real / virtual line system. All the folded block’s lines have the same virtual line (they are literally folded under the first block’s line).
But how are these blocks defined?
Kate uses the file extension to determine what defines a block (special characters like “{“ or “}”, text alignment and so on). Kate’s highlight sends some info about these to Kate’s code folding. Let’s call them “document’s anchors”. This info is rudimentary. It is mentioned only the type of anchor (encoded as a number greater than 0 if it is a start anchor and lower than 0 if it is an end anchor) and its position in the document (real position). I use this info to build the “folding nodes” (I will detail them later) and to keep their position updated as well. So, here we have the first data structure: the “line mapping”. Line mapping is a QMap and contains an entry for each document line that has at least one anchor I was talking about earlier. If this structure is updated correctly, then I am sure that all the folding nodes have their position set correctly and I don’t need to worry about that.

Now, I know where the document anchors are. But that isn’t enough – I need to form folding blocks with them.
I found two solutions for this “matching” problem:
1. Use a stack and rebuild (using the line mapping) the folding tree from scratch every time something is changing. The algorithm was very simple (parenthesis matching problem), but I found it pretty ugly (and slow) to rebuild the entire tree so often. I didn’t discard the idea either. The algorithm was perfect to be used as a term of comparison for the other algorithm.
2. Use a tree algorithm that changes itself dynamically. This was the solution I chose. I developed an entire project (see my previous posts) that helped me improve this algorithm and I believe it works pretty well.
The folding tree is made of folding nodes. These nodes contain info about their position (actually the document’s anchor that they represent), parent, type, matching node – all the info needed to define the folding blocks. If this tree is correct, then the blocks are defined correctly.

If you have the folding blocks defined, then you can fold them. To do this I use the third (and the last) data structures: a QList with the folded nodes. You might ask why we needed another(!) data structure. There are 3 methods that are called very, very often: getRealLine (virtualLine), getVirtualLine(realLine) and getHiddenLines(). Search through all the folding nodes (using the folding tree or the line mapping) is slow. Imagine if we do this search for every line of the document (actually there are about 2 or 3 calls per line every time something changes in the document!). I have also made one more improvement here: if a folded block contains another folded block, then the inner folded block is removed from this structure (it won’t help us discover the virtual or real lines).

Basically, these 3 methods are the code folding – the real / virtual line system I was talking about in the beginning. But.. there is a long way and lot of work to be able to answer these 3 questions fast and correctly.

Kate Vi Input Mode – GSoC 2011

Tue, 26 Jul 2011 12:44:04 +0000

I want to introduce you my GSoC-2011 project. I was working on improvement the vi input mode for the Kate part.

There are a lot of improvements for normal mode. Now it’s able to use jump list by pressing ctrl-i/ctrl-o in normal mode like in vim. And now not only registers but also marks, and jumps stored in the config of the session. H, M and L commands moves cursor to the first(Home), Middle and Last line of the screen. To go to the any percent of the document you can use the % command by typing the number of percent(1-100) before it. gk and gj motions will make you able to go visual(display) lines up and down. It’s useful when you using line wrap.

You can split the screen vertically and horizontally by ctrl-s and ctrl-v shortcuts and move around them in different directions using ctrl-w{h,j,k,l,w} or also ctrl-w{←,↑,↓,→}.

In insert mode added commands ctrl-r+[register] to insert the contents of a register and ctrl-o to switch to the normal mode only for a one command and automatically get back to insert. The ctrl-a, ctrl-x command now increase and decrease the negative numbers too.

There are also some new command-line features. Now you can use the marks for a command ranges. It’s possible to add and subtract line numbers in the ranges many times. For example command :.+3d will delete the third line after current position and the command :’a,’b-1y will yank the line-wise range between the line of mark ‘a’ and the one line before the line of ‘b‘ mark.

Also there a some new basic vim commands:

:d or :delete – delete range;
:c or :change – change range;
:j – join all the lines in range;
:> – indent range;
:< – unindent range;
:y or :yank – yank range;
:ma or :mark or :k – set mark;
:bn – switch to next buffer(document);
:bp – switch to previous buffer(document);
:bf – to first buffer;
:bl – to last buffer;
:b [N] or :buffer [N] – to Nth buffer

Text objects are also improved and fixed. There are new objects: ( a{ , i{ , a< , i< , a` , i` ). And now they normally works with nested objects. So for now the i( object (for position of multiply symbol *) will be “(1*2/(2+3)–4)” instead of “(1*2/(2+3)–4)”. Some of the objects like (),{},[],<> works with several lines.

Visual mode now is integrated with mouse, so the mouse dragging starts the visual mode. All kind of Kate-way selection is also starts the visual mode. For example if you use “Select all” menu line or shortcut ctrl-a(by default) this will starts visual mode with the selected text and waits you for a command to execute :) . One point mouse click will exit the visual mode. Kate selection and vi mode selection is actually the same thing now. So you can, say, to select a bloc by using the Visual Block mode (ctrl-v), to do a context menu on them and to copy them to a clipboard :). When you exit visual mode the ‘< and ‘> marks have a start and end position of selection. It useful when you want to execute some command line command on the selected text. Just press the “:” when you select something and it automatically fill the command line with “‘<,’>” to have a quick access to selected area.

Vi marks and Kate bookmarks are integrated too. If you set the mark then this line becomes bookmarked by Kate. And vice versa: if you set a Kate’s bookmark and there no vi marks on this like vi mode sets the vim mark on this line and zero column, and shows you what letter for this mark is used.You can see the position of all vi marks in the bookmark menu in the menu bar or also in the context menu.

I hope this features will make you feel even more comfortable while using Kate. You can try it now in the git version of Kate.
Any notice or bug report are welcome !

You, KDE!

Mon, 25 Jul 2011 15:28:16 +0000

For me, it (still) feels very unnatural to talk about us as KDE. I’m still thinking in terms of the KDE community; and _the KDE Project_ releases the _KDE Desktop_ (or just KDE). I’m also fine with _the KDE Workspace_ and other specialized variants. However, the login manager now also shows the term KDE Plasma Workspace. In my very own humble opinion, this is already too much of buzz words.

At university, I’m helping out with system administration. And since I’m very familiar with KDE, I fix all KDE related issues (and usually enjoy doing so). We have lots of colleagues that never used KDE. Now, try to explain the term Plasma… Well, it’s a desktop shell – also too complex. It’s the desktop, with all the icons and panels. That’s more understandable :) But next, a dialog pops up with some status messages: Akonadi. Well, try to explain the term Akonadi. It’s similar with other technologies. Explain what Nepomuk is doing with the difference to Strigi… When I try to explain what’s happening, and what all these components do, I sometimes feel ~~pretty much stupid~~ uncomfortable using these words.

It is similar with the term KDE SC. As part of the rebranding, the KDE Software Compilation or short KDE SC was introduced. I can understand that we build a platform and our target is more than just the Desktop. But talking to other people, I feel stupid saying KDE SC. For me, it simply is (and probably will always be) a no-go. But it changed already, to the KDE platform, or maybe I misunderstood that ? :-)

Funnily, I think it’s fine to use application names such as dolphin, kate, amarok and what not. So to some degree, I’m certainly simply used to these terms. But still, it feels right, also when talking to other users. We have to be very careful to use fancy names in very prominent places. Ah, and with respect to naming applications, there is a similar discussion on kde-core-devel right now ;)

GSoC 2011 – Kate Code Folding – (Try Kate’s new code folding)

Sun, 24 Jul 2011 17:20:32 +0000

Hi everyone!

Kate’s new code folding was merged with the master branch. :)
You can try it by yourself. If you do find any bugs, please send a bug report on KDE’s bug tracker or leave a comment here.
I will use a test unit to solve those bugs, so I will need a full backtrace and some info to help me replicate it.
Please notice that there are no new features added yet – just the basic code folding.

I’m waiting for your feedback!

Kate Modeline Editor

Sat, 23 Jul 2011 15:34:40 +0000

As you may know, Kate supports the concept of document variables, also known as modelines. In short, document variables can be used to set Kate settings local to a file. For instance, this is useful for settings specific indenter options than the ones defined in Kate’s settings dialog. Assume you work on two projects, the first indents with spaces and the second with tabs, then you can simply add a modeline that contains the specific document variables that set the specific indentation properties.

While the concept is very mighty, it is not intuitive to use: You have to know the exact syntax and correct varialbes and their valid values.

To improve this for the next KDE release (v4.8?), Kate gained a variable / modeline editor this week:

If you click the Edit button, a list view pops up showing all valid document variables with the valid values. Right now, this editor is included only in the “Modes & Filetypes” config page. However, the idea is to support it in the context menu over a Kate modeline in the text editor area as well.

GSoC 2011 – Kate Code Folding – week 5 (New Code Folding is taking shape)

Wed, 13 Jul 2011 09:48:23 +0000

Hey!

The new code folding is taking shape. Actually it is implemented. :)
The next step will be testing it (and debugging, if necessary) and implementing some new features.
Also there are some keyboard shortcuts that didn’t worked so well on the previous version and they need to be fixed too.

If you want to help us with the testing, you can download my clone and play a little with code folding. Also, if you have some ideas about the new features that Kate’s folding should have, let me know. If it is possible and there is time, they will be implemented.
Greetings,
Adrian

KDE 4.6.5 > StarCraft 2

Sun, 10 Jul 2011 16:47:23 +0000

I normally enjoy StarCraft 2 in the evening a bit or like now, if it is raining and I have no fun in any more real work.

But just now and some days ago, it has again proven, KDE > StarCraft 2.

Just again, StarCraft 2 (played with wine, thanks a lot wine team, you do a great job!) got sluggish and then terminated.
A quick dmesg call shows the cause.
Like last time, the OOM killer got me.

Now, first I thought: What, this stupid game uses more than my 4 GB of RAM? (I have no swap, have only one ssd)
But now, the reason is much easier: KDE has beaten StarCraft 2…. (even if we call it KDE SC, it still not loves SC 2 :)

Looking at my process table, is is just clear: StarCraft 2 is the biggest memory user, that is just normal, around 2.5 GB, at peak.
But no reason to crash, or? With 4 GB.
But wait, I let my kontact run the background, big failure.

My stats here:

Kontact and co, just only taken the > 50 MB RSS offenders, there are lot of other smaller processes running around:

cullmann 1452 2.1 10.7 1243552 436228 ? Sl 11:05 9:33 /usr/bin/kontact
cullmann 1132 0.5 9.6 813136 391996 ? S 10:38 2:33 /usr/bin/akonadi_nepomuk_email_feeder –identifier akonadi_nepomuk_email_feeder
cullmann 1127 2.6 1.3 550532 54860 ? Sl 10:38 12:13 /usr/bin/akonadi_imap_resource –identifier akonadi_imap_resource_0
cullmann 1060 2.0 2.8 481124 114288 ? Sl 10:38 9:34 /usr/bin/mysqld –defaults-file=/home/cullmann/.local/share/akonadi//mysql.conf –datadir=/h

Summa around 1 GB, with the smaller ones.

my friend the semantic desktop :/
cullmann 1104 41.6 2.1 168752 88320 ? SNl 10:38 193:59 /usr/bin/virtuoso-t +foreground +configfile /tmp/virtuoso_hX1095.ini +wait

The planet is no place for bugs, I know, but anyway, this is no bug report. What should I report at all? That just using KDE + Kontact eats >> 1 GB of my RAM and virtuoso around 40% of my CPU? And yes, it even uses that with Kontact shutdown and all other apps closed… And no, I have no indexing active, that OOM’d me last time, even before Kontact + Akonadi on :/

I kind of think, we need to improve in that area, really.
Beside, in the old days, if Kontact did take too much RAM, I just closed it, now, still the akonadi parts + mysql stay alive, with around ¹⁄₂ GB memory usage :/
Guess need to kill them hard before starting to play :)

A lot of persons at work switched back to GNOME or whatever, because we can’t get rid of these problems. Either kdeinit eats our CPU (with Ubuntu Natty) or nepomuk/strigi/akonadi and Co. eat the memory + fill our NFS homes :/ And no, we don’t do bug reports for this, as these are not reproducable problems. (Beside the memory usage I guess and that virtuoso runs amok, but that are known issues if you look at our bug tracker)

Good side of things: In that light, Kate’s memory usage is kind of non-existing in comparison :P

I will continue to use KDE for sure and try to be more clever and shut down Kontact and co before playing (and turn of nepomuk completly, even if I get here and then a error message because of this) or I will just buy more RAM, 4GB to ease the pain should be not the biggest issue. Happy enough, at work I have anyway 8GB or more in every workstation because of our static analysis software needing it ;)

Kate in KDE 4.7

Sat, 09 Jul 2011 20:20:50 +0000

Now that the next version of the KDE platform is branched, it’s time to have a look at all the changes in Kate in KDE 4.7.

More than 150 wishes and issues have been resolved. A detailed list of the resolved issues can be found in the KDE bug tracker.
All Kate development is done in the KDE git infrastructure as submodule of kdebase. It is very straight forward to build Kate within a few minutes according to our excellent documentation.
New Search Plugin with the ability to search in files on disk or opened files (will replace the Find in Files plugin in KDE 4.8).
Plugin improvements: Build Plugin., GDB Plugin
Kate’s tab bar plugins gained several new features.
Swap files: If lost data is found, documents are marked as read-only.
Further noteworthy changes: Improved printing, change of line ending triggers modified flag, fixed shortcut issues, fixed auto completion popup, and more.

Current State of Kate

In KDE 4.6, we replaced the document list by the new File Tree. We got relatively few critical reports, meaning that the file tree seems to work pretty well for the majority.
Kate has two GSoC projects at the moment: Rewrite of the code folding, and Improving Kate’s vi mode. The work done in both projects will be available in KDE 4.8, so we are already working on the next major KDE release.
About 6 Kate developers are present at the annual KDE conference.
A year ago, the Kate homepage was redesigned. Looking back the last year, we can say that this has been a success.

Just in case you missed it: you can read about Kate’s state 6 months ago here.

GSoC 2011 – Kate Code Folding – week 4 (Integrating the folding algorithm)

Mon, 04 Jul 2011 11:46:56 +0000

Hi!

I bring good news about Kate’s folding today. The algorithm was implemented and tested successfully. ;)
As I mentioned in the previous article, I implemented it in a new (simpler) project. It is a Qt project (developed using Qt Creator) and you can find it in my Kate clone, “tree_alg” folder.

Actually, I have implemented two folding algorithms: one that uses a tree that changes itself dynamically whenever you insert or delete a node, and one based on stack that rebuilds the entire folding tree whenever you insert or delete a node. I needed two algorithms because I wanted to implement an automatic testing mechanism and for that I needed a way to test the output. The second algorithm was easier to be implemented and it was very stable (bug-less) from the beginning, so it was great to use it for my testing.

The automatic testing proved to be a success. I hope I found all the bugs, but I would like to invite you to download the project and to play a little with this application. If you do find any bugs, please send the history files on the mailing list and I will fix them. About these history files, when you save the history two files will be created. E.g.: if you save your history in a file called “history_1”, then you will have (in the same directory) a file called “history_1” and a file called “history_1_moves”. Please send them both if you notice any bug. It will make my debugging much easier.

My next move is to integrate this tree folding algorithm into Kate’s folding. For this part, I will have to finish an undone job from a previous week (rewrite the interface and the update methods) and add the algorithm I have just implemented.
I think that in ten days at most we will have a new code folding for c style languages. :)

All the best,
Adrian

Kate plugin updates part 3

Tue, 28 Jun 2011 05:03:34 +0000

Well I’m not sure this really qualifies as an update, because it is actually a new plugin. And the plugin I’m talking about is the Search plugin. This is going to be mostly a series of screen-shots.
The first shot contains the “new” feature differentiating itself from the other one. You can now select to search in the currently open files. This is especially good if you are working on files on a remote server.

The “Find in files” plugin opens new searches in new toolviews while this one has a button for adding new tabs if you want to save the old search.

Of course you can also search in a folder as before :) When you select to search in a folder the folder searching specific options are displayed. Those options can also be toggled with the rightmost tool-button.

And the final screen-shot is to show that it is possible to use regular expressions.

The “Replace” feature is not yet implemented, but who knows ;) Ideas for a UI are welcome.
And that was it for this time. I hope you like the updates :)

Bug Squashing

Sat, 25 Jun 2011 22:41:22 +0000

We’ve managed to push our bugs down from ~430 to ~310 during the last two days. Some bugs are not valid anymore, but lots of bugs also really have been fixed. So in KDE 4.7 we will have the best Kate release ever :-)

Going to the Desktop Summit 2011 in Berlin :)

Sat, 25 Jun 2011 10:28:14 +0000

Just a quick “me too” post, will be around in Berlin ;)

Hope to meet up with a lot of KDE people once more.
For the Kate team, at least me, Dominik and Erlend are around there.

GSoC 2011 – Kate Code Folding – week 3 (Folding algorithm started)

Fri, 24 Jun 2011 20:08:34 +0000

Hello guys!

I’m writing my weekly article today because I have already started working on something else. I didn’t have time to finish the previous stage because I started the next phase of the project.

I had a talk with my GSoC mentor and a couple of Kate developers and we all concluded that I should start working on the folding algorithm as soon as possible because this is the main (and most important) part. For this part, I built a small new project that will help me implement the algorithm and test it independently from Kate project. You can find this project (and my Kate clone) at this address. There are not so many methods implemented, but you can figure out how things will be developed.

Fortunately, I don’t have to build this algorithm from scratch. I made some research and had some results by the time I was working on my proposal. Here is the paper I wrote based on that research and here is my GSoC proposal, too (it is public now, so anyone can see it).

If you have any questions or ideas, feel free to leave a comment here or to send an e-mail on Kate’s mailing list.

I’ll keep you in touch with my progress,

Adrian

Kate plugin updates part 2

Thu, 23 Jun 2011 18:32:15 +0000

Second out in the this series of plugins update is the GDB plugin which has gained a view for local variables. If you have GDB pretty printes in use, you can even get various Qt types displayed nicely. Here are direct links to the relevant printers and an example .gdbinit: qt4.py, libstdcxx.py and kde4.py.

[][6]

Locals view

The locals view does not (yet?) have any fancy features as editing the values and does not show which variables have changed.

The handling of breakpoint and execution markers has also improved a bit.

Last but not least in this series will be the new “Search in files” plugin.

Kate plugin updates part 1

Tue, 21 Jun 2011 03:32:24 +0000

KDE SC (or was it Platform?) 4.7 will bring some enhancements to Kate plugins. First up is the build plugin. The new thing for the build plugin is the ability to specify multiple targets per session. This means that you can build debug/releas/… targets without having to jump between sessions. The default setup/targets contain a configure target with a CMake command and a build target that runs make.

Screenshot of the default "Config" target

Screenshot of the default "Build" target

Targets can be added, copied and deleted. If the last target is deleted the default targets will be re-added.

When the targets are set up, you can of course select a specific target by selecting the settings tab and there select the desired target from the small combo box. To make target switching faster, there is a “Next Target” action. This action will switch to the next target in the target combo-box. If the settings tab is not visible it will open the tab to display the current target. There is no default shortcut-key for the actions, but fortunately it is not hard to change a shortcut in KDE applications :) My personal shortcut-setup can be seen in the build-menu screen-shot.

Screenshot of the "Build" menu

Next up will be the GDB plugin

GSoC 2011 – Kate Code Folding – week 2 (Architectural design)

Mon, 20 Jun 2011 12:50:39 +0000

Hello!

Last week I focused on analyzing the interface of the actual implementation. Now, it’s time to develop the new interface.

As I mentioned in my proposal, one of my project’s goals is compatibility: I want to make as few changes as possible in the other sources. This is the reason why I studied the previous implementation for a whole week.

Another goal of my project is simplicity. The interface will be implemented in an abstract class. This class will be inherited by two other classes: one for C style languages (those who use elements like “{}”) and one for Python style languages (those who use indentation level to define the code blocks), as you can see from the diagram. I believe the code will be simpler and clearer if it is more specialized.

Because this part of the projects it’s about design, I would also like to define my data structures. Of course, there will be a Tree, the code folding tree, and some Nodes. It is very important to know where those Nodes are placed in document (row and column). This info needs to be updated when something changes in your document (e.g.: you add a new line, so all the Nodes change their rows). Because it is very time consuming to search through the folding tree, I suggest adding a second data structure.

For this part, I have a dilemma: whether to use a Vector of Vector, or a Set>.

Let’s make it clear: I want to use a Vector of Nodes (actually pointers of Nodes) for each line (because we might have more than one Node per line). But how will be those Vectors stored?

The first option is to use another Vector. The size of this Vector will be the same with the number of rows of the document and Vector[i] = all the nodes placed on the line “i”. This method is easy to be implemented and very fast. The complexity of the updates will be constant and that’s great. So, where is the problem? Memory usage: If we have a 10.000 document lines, then we have about 40 KB of data reserved for this data structure (even though there are no folding nodes at all).

The second option is to use a Set. For each row, that has at least one folding node, there will be a single entry into this set. This method uses the memory very optimally, but update functions will have a logarithmic (if the set is kept sorted) or linear complexity (much slower than the previous method).

If you have any ideas, feel free to leave some feedback to this article. ;)

Adrian

GSoC 2011 – Kate Code Folding

Sat, 11 Jun 2011 17:10:30 +0000

Hi everybody!

I am Adrian and, as Erlend already mentioned in a previous post, I will rewrite Kate’s code folding algorithm on this GSoC edition.

Starting from this week, I will post a weekly report of my work. At the end of each week I will post some info about the project’s progress and some details about what I have scheduled for the next week (according to my presented timeline).

I know that GSoC coding started for about 3 weeks, but, as you will see in my timeline, I had school exams until yesterday so I couldn’t work during this time. This won’t be a problem. I knew about that from the beginning and I scheduled my timeline starting with June 13^th. Also, this was mentioned in my proposal, so all the mentors are aware of it.

My objective for the next week (13 June – 19 June) is to get familiar with Kate project and QT. I already downloaded the source files, compiled them and took a look through them, so I will do that again (more carefully) and build a list of questions which will be sent to my mentor or posted on the mailing list. This way I will be able to focus later on what I will write and not on how I will do it.

One more thing: Because this is my first post, I will also post my full timeline so that everyone knows what my next move will be. Here it is (pasted from my proposal):

Tentative Timeline

May 23 – June 12 – I won’t be able to work during this period because I will have some school exams during this time.

Weeks 1-2 (13 June – 26 June) – Plan on how to fit all the “puzzle pieces” (algorithms, data structure and other objects used); implementing the abstract class that will ensure backwards compatibility; take an overall picture of Kate code folding.

Weeks 3-4 (27 June – 10 July) – I will implement and test my tree-algorithms, which is the base of the code folding. The algorithms will be implemented in C++ using QT objects but as a separate project in order to test them as much (and easily) as possible.

Weeks 5-6 (11 July – 24 July) – Implementing the two classes that extend the abstract class using all the information gained in previous weeks.

Weeks 7-8 (25 June – 7 August) – Implementing a new feature for Kate code folding – “Code folding preview” (presented above)

Weeks 9-10 (8 August – 22 August) – Lots of testing and some documentation (I saw that Kate source files have a little lack of code documentation, but I think some explanations about the implementation would be great).

I am open to proposals about this project, so if you have any ideas that can make it better let me know and we will talk about them.

Wish me good luck! :)

Getting Involved

Sat, 04 Jun 2011 12:47:29 +0000

Recently we’ve had several feature requests in comments of a blog post. If you are interested, you can easily implement this and contribute to Kate. And I’ll even show you how to get started for the following feature. First, build Kate according to /get-it/.

Adding support for ctrl+w {left, right, up, down} to switch the active view.

Kate has a vi input mode. This way, vim users can still use their default work flow but still use Kate at the same time. What’s missing in the current vi input mode implementation is support for view navigation. In vim, to move between different windows, press ctrl-w to switch to the neighboring view. Implementing this is rather easy – the following steps need to be taken care of:

Add vim bindings (=vim shortcuts) to the Kate’s implementation of the ‘normal mode’.
In the implementation, find all visible KateViews.
Compare the global coordinates of the window geometry by using QWidget::mapToGlobal(const QPoint& pos) (for QPoint(0, 0) and QPoint(width(), height()) of all KateViews)
Call setFocus to the nearest matching of the visible views.

Patches are welcome :)

Kate’s Folding Code and Vi Mode to be improved by GSoC students

Mon, 23 May 2011 20:30:34 +0000

This year’s Google Summer of Code (GSoC) has started and the Kate project has been lucky to get two students who will work on improving Kate’s folding code and Vi input mode.

[][1]

Adrian

Adrian will work on improving the folding code which is in need of an overhaul:

My name is Adrian. I’m studying in Bucharest, Romania, but my hometown is Constanta, a seaside town from Romania as well. I am a 3rd year student at “Politehnica” University of Bucharest, majoring in Computer Science and Engineering. I have developed a passion for algorithms since High school when I participate in many programming competitions and took things to a new level during college.

My GSoC project is called “Kate Code Folding” and I believe its name is quite explicit. I chose this project because I am very familiar with the editor, as well as its code folding bugs. :) Besides that, I am pretty excited that I have to develop a new algorithm for this project and I must say I find this task very challenging. For a better understanding of my project, here there are 2 paragraphs from my proposal, with no details, just the main ideas:

My project idea is based on two elements. The first one is a new approach of the problem: transform one more complex problem into two simpler problems. To be more specific, as far as I know there are two types of programming languages: there are languages that use syntactical elements like {} or any other begin/end constructions (e.g.: C/C++) and there are languages that use indentation level to define their code blocks (e.g.: Python).

The second idea is to have the new implementations compatible with the current one. What I mean is that most of the actual public functions will still be used in the new implementation (some of them will suffer a few modifications), to solve the dependencies problem in a smart and simple way. So there won’t be too many changes in the other source files.

[][2]

Svyatoslav

Svyatoslav will work on improving the Vi input mode in Kate:

I am Svyatoslav Kuzmich. I’m a 2nd year student of Moscow Institute of Physics and Technology, department of Radioengineering and Computer Science.I usually write something like emulators and compilers but this Summer I am doing GSoC for KDE. I want to improve Vi input mode for Kate kpart. There are a lot of features already implemented. In some ways they works rather good. But there are some commands do not work like commands in Vim. So I want to fix them and to expand the list of commands by adding some insert and command mode’s commands for working with Kate’s tabs, window splits and bookmarks.

In more behind-the-scenes work, Svyatoslav will also write an extensive test suite for the Kate Vi Mode to make it easier to introduce new features without at the same time introducing regressions. This work has already begun.

We will try to keep you updated throughout the summer. Please wish our GSoC students good luck! :-)

Kate Behavior at Exit

Thu, 28 Apr 2011 20:37:16 +0000

From time to time it happens that bug reports get pretty much nasty. A single user or some users request a feature. If you argue, bashing starts.

In this case, it’s about Kate and the following scenario: You are editing several files (e.g. because you clicked on text files in dolphin). So Kate starts and you are not using an explicit session. If all files are saved, you can simply quit Kate. Bug #267356 requests, that the user is asked whether to save the session or not. Right now, if you are not using a session, Kate simply closes and the file list is lost. Comments are welcome, especially in the report. But please be objective and polite. Thanks…

PS: Sometimes open source development is real fun. Sometimes it’s not :p

Kate’s Tab Bar Plugins

Mon, 25 Apr 2011 14:30:59 +0000

If you check Kate’s plugin list, you will recognize that there are two different tab bar plugins available. The first one is Tabify. This plugin adds a standard KDE tab bar to the top of Kate’s main window:

The plugin shows the same entries as the “Documents” tool view on the left. With drag&drop, the tabs can be moved around. In KDE SC <= 4.6.2 this plugin is called Tabify. In KDE SC >= 4.6.3 the name is simply “Tab Bar”.

There is another plugin, called Tab Bar Extension in KDE SC <=4.6.2 (and Multiline Tab Bar in KDE SC >=4.6.3) that also adds a tab bar to Kate’s mainwindow:

As can be seen, this tab bar can be configured to span multiple lines in order to show more documents at the same time. Further, there are features like tab highlighting so that a document can quickly be found when working on a huge list of documents. There are more options in the configure dialog of this plugin (click small configure button on the right). In KDE 4.7, it is possible to change to highlight a tab by clicking on it with the middle mouse button and clear the highlight with CTRL+middle-click.

There have been requests to remove the non-standard plugin from Kate and just provide the standard conform Tabify plugin. I was about to do that, but then, we do have users that use the multiline tab bar. And as it works well and provides some features the default tab bar does not have, I’ve finally decided to keep it.

It is worth to mention that there were quite a lot of voices in the past requesting a tab bar. It was even requested to remove the “Documents” tool view, listing all the documents. However both tab bar plugins are not able to provide easy access to the opened documents, if you have e.g. 50 documents opened. Hence, the Documents tool view will remain the default, just as it always was in Kate’s life :)

KDE Everywhere?

Tue, 08 Mar 2011 07:36:29 +0000

My last post mentioned Necessitas which provides the means to have Qt on Android.
Whereas still a early preview release, it already allows you to compile and run Qt applications on Android >= 1.6 without any big hassle and integrates that into QtCreator!

I tried out the SDK in the last days, it is really easy to use and setup, like seen here and here (with good video that shows the steps).

What is missing here? KDE :)

I think a nice thing to have would be a port of parts of kdelibs, like the embedded profile or how you name it and providing an app like Ministro in Necessitas that allows a system wide install of this libs.
Having tried Ministro and the example app from the market, that works like a charm for Qt already. I would love to see that for kdelibs as well. Then really a lot of users are just two clicks away from great KDE apps like the good edu stuff and games which really can fly on phones and even more tablets ;)
Embedded developers with spare time: Get the fame and port it .P

I doubt Kate itself would make a good appearance on a phone, and I doubt even I would use it there. But for tablets? Who knows, that might be nice for the “I hack one liners during Fringe” session in the evening.

Qt Everywhere?

Sun, 06 Mar 2011 15:40:25 +0000

After the latest changes in Nokia, I was kind of scared that “Qt Everywhere!” like printed on my nice bathing towel won’t really happen any more, at least not as fast as thought.

Now I got my new phone, Android based, and tried out Necessitas. And I must say, I am impressed. Just downloaded Ministro from the Android Market (yes, just like that, no rooting, no hacking, nothing) and the hello world demo and it runs :P

I hope this project will really take off even more as soon as a stable Qt 4.8 is around! And that we see some KDE fame there, too. Really, this is not to be underestimated. The Android market share grows and the current market policies allow open source there, unlike what we see for the WP7 or iOS systems.

Already now: Thanks to the Necessitas team, great work! Really necessary ;)

KDE and Git, Current Changes

Sun, 30 Jan 2011 10:14:46 +0000

Thanks to the massive work of sysadmin and others (like Ian Monroe), kdelibs and kdebase are now converted to Git.

In parallel, the move of all kate related code to the kate.git was done and announced. Kate Part / App + KWrite reside now in kate.git on git.kde.org and this is the central place for kate development, like it was already before, but now without the shadow-copies in three other repositories.

As it has shown in the past, this centralisation of parts which belong together helps to get stuff done for our project. The Get It! page on kate-editor.org is already updated (as now documentation is in the module, too, and some CMake parameters have changed).

I can only say: If you want to add some feature or hassle with some bug, give it a try. It’s dead easy to get and compile a fresh Kate (even with a bit older kdelibs around). You are welcome ;)

P.S. Thanks again all the people working on the transition to Git and sysadmin for operating the nice projects.kde.org and git.kde.org services!

Kate progress, Git and happy new year ;)

Wed, 29 Dec 2010 18:04:01 +0000

As Dominik already points out in his blog, Kate has made nice progress for KDE 4.6.

Some of the latest fixes, like for some nasty search bug didn’t make it in RC1, btw., I was too lame with Git -> SVN syncs.
Anyway, I have now synced and backported to KDE 4.6 branch all pending fixes.

For the next KDE SC release 4.7 (here you go, I wrote SC :)), I hope this syncing will no longer be necessary.
At least Kate app + part + KWrite should then be only in the kate.git.
I can live with ktexteditor remaining in kdelibs, if removing that and still keeping BC and SC would be too much work. But part and app are at most runtime dependencies anyway.

Last but not least, I wish you all a good start into a happy new year ;)

Kate in KDE 4.6

Wed, 29 Dec 2010 10:47:20 +0000

Some days ago KDE 4.6 was branched. So what will Kate in KDE 4.6 bring?

The new tree view as “Documents” sidebar completely replaces the old file list. It supports the simple list mode as well as a pseudo-intelligent tree view to group files. The “Documents” tab is now implemented as plugin (always loaded), meaning that it brought a code cleanup as well. We hope you like it! :)
Swap file support, meaning that you can recover all your unsaved data for local files on the next Kate startup.
Ability to always load plugins.
New SQL Query plugin. The day we blogged about it had the most visits in the entire kate-editor.org history. So it seems the the SQL plugin is a really nice addon for web developers! :)
New GNU Debugger (GDB) Plugin!
New Highlight Selected Text Plugin.
Ability to add scripts to the menu and bind shortcuts.
Kate got a new homepage on http://www.kate-editor.org featuring WordPress.
Lots of bugs fixed since the KDE 4.5.0 release.
SmartCursors and SmartRanges are gone, resulting in more stable and clean code. MovingCursors and MovingRanges replace the old classes and work reliable. For instance, KDevelop is already ported leading to less crashes.
Christoph found the emails of the early days of Kate again. A funny read! :)
Daily unit test runs. We have more and more unit tests, securing the correct behavior of e.g. search&replace, the text buffer, encoding detection or indenters.
Kate development mostly moved to KDE’s git infrastructure, resulting in very easy build instructions.
The default settings of a session are now stored in the katerc file again, rendering the default.katesession obsolete. This means you will have to configure your default session again (sorry!). On the other hand, this fixed quite some bugs with regard to the session handling.

Credit where credit is due!

There were lots of developers involved who helped to improve Kate. Thanks a lot to every one of you! Without your contribution, Kate would not be what it is :-) Keep it up!

KDevelop 4.2 Beta 1 released

Fri, 17 Dec 2010 20:49:29 +0000

Hey all,

I’m happy to announce the immediate availability of KDevelop 4.2 Beta 1. This is a testing version and any kind of feedback would be welcome and appreciated. Please use our bugtracker. You can download the sources or wait for your distribution to create packages.

Note: Anyone who runs KDE 4.6 or later needs this version (or any later). This is because the SmartRange interface in Kate got nuked and replaced with MovingRange interface. Many thanks to David Nolden for more or less single handedly porting KDevelop to this new architecture.

The good news doesn’t end here though, KDevelop 4.2 ships with lots of notable changes and new features:

MovingRange` support (Thanks to David Nolden)
Grep Plugin rewrite with replace functionality (Thanks to Silvere Lestang, Julien Desgats, Benjamin Port)
QtHelp plugin now supports arbitrary .qch files (Thanks to Benjamin Port)
ManPage plugin (Thanks to Benjamin Port, Yannick Motta)
new look for code assistants (Thanks to Olivier JG)
filter for the project model view (Thanks to Eugene Agafonov)
improved “Problems” toolview, along with “TODO/FIXME” browsing (Thanks to Dmitry Risenberg)
better standards compliance in the C++ macro implementation (Thanks to Dmitry Risenberg)
argument dependent lookup for the C++ plugin (Thanks to Ciprian Ciubotariu)
open with external application by default (esp. useful for Qt Designer .ui files)
PHP: rainbow colors for all vars (and no nested functions or similar), esp. useful for scripts without Classes/Functions
code cleanup for working sets
better handling of locked sessions (locked session gets activated or the user gets asked whether he wants to remove the lock file)
improved Snippets editing usability

Along with these big changes, lots of small improvements have been made and we will continue to polish and harden out this branch in order to give you a stable, fast KDevelop 4.2 soon. Considering the impact and amount of changes, testing would be very welcome in order to prevent regressions and similar in the final 4.2 version.

Bye and thanks again to all contributors who made this possible. I’m especially thrilled to welcome so many new people, well done!

KDevelop 4.2 Beta 1 released

Fri, 17 Dec 2010 20:49:29 +0000

Hey all,

The good news doesn’t end here though, KDevelop 4.2 ships with lots of notable changes and new features:

MovingRange` support (Thanks to David Nolden)
Grep Plugin rewrite with replace functionality (Thanks to Silvere Lestang, Julien Desgats, Benjamin Port)
QtHelp plugin now supports arbitrary .qch files (Thanks to Benjamin Port)
ManPage plugin (Thanks to Benjamin Port, Yannick Motta)
new look for code assistants (Thanks to Olivier JG)
filter for the project model view (Thanks to Eugene Agafonov)
improved “Problems” toolview, along with “TODO/FIXME” browsing (Thanks to Dmitry Risenberg)
better standards compliance in the C++ macro implementation (Thanks to Dmitry Risenberg)
argument dependent lookup for the C++ plugin (Thanks to Ciprian Ciubotariu)
open with external application by default (esp. useful for Qt Designer .ui files)
PHP: rainbow colors for all vars (and no nested functions or similar), esp. useful for scripts without Classes/Functions
code cleanup for working sets
better handling of locked sessions (locked session gets activated or the user gets asked whether he wants to remove the lock file)
improved Snippets editing usability

Bye and thanks again to all contributors who made this possible. I’m especially thrilled to welcome so many new people, well done!

KDevelop and Kate advancements over the last weeks

Sun, 21 Nov 2010 15:38:15 +0000

Hey all,

I didn’t blog in a long while so I thought I’d dump some notable things I did over the last weeks. It’s probably neither complete nor thorough - you should try it all out to see it for yourself :)

Kate

Lets start small with my Kate contributions. I really concentrate on KDevelop nowadays since Kate works quite well for me and I don’t have many itches to scratch anymore :) So, what did I do these last weeks? Mostly cleanup and performance work, especially regarding MovingRanges which of course is mostly needed for a good experience in the upcoming KDevelop 4.2. With the help of Dominik Haumann I also went through our indentation unit tests and made sure we expect all currently failing test cases, as well as fixing those I could. Now we (finally!) have a passing test suite and get noticed about introduced regressions. Awesome!

KDevelop

Of course I still concentrate my contributions on KDevelop and related plugins. What I find quite interesting is that I’m now for over two months in a “polish-and-bugfixing”-mode, without adding much new features. I think that shows that I’m quite satisfied with the existing features, just not with the way they are integrated. E.g. the Kate performance improvements above were done in order to make “reformat source” not hang the IDE for a couple of seconds anymore, in KDevelop 4.2 it will only be like one second for really big source files. I’ve also tackled our black sheep, the “launch configuration” dialog. I didn’t rewrite it, but I did some polishing and have some more ideas to hopefully get it into a useable state. Oh, I just remember: I also spent some time on the “Snippets” plugin, restructured the editor dialogs a bit and made them use Katepart as well, for syntax highlighting and proper editor features :)

I generally care about small things nowadays, like e.g. that all widgets have a proper tooltip. This is also something where you all could help: If you find a widget in KDevelop master (4.2) that has no tooltip, please notify me! I’ve added those e.g. to the outline and quickopen toolbar widgets among others.

And since KDevelop 4.1 was in beta stage I’ve fixed lots of bugs and continue to do that. I triage each new bug for KDevelop/KDevplatform, request feedback and valgrind logs and try to fix whatever I can. Even now I can safely assume that KDevelop 4.2 will be more stable than 4.1, even though we did lots of architectural changes in the platform, esp. regarding MovingRanges.

And now to the last and to me most pleasing part: New features! Remember how I said I didn’t do lots of feature development at all these past days? This is basically true, instead I let others do the work :) We really get more and more patches and merge requests by other people, and I did merge quite some changes already. We have an improved “find in files” plugin now, and the French students are working hard on giving it replace functionality as well! We already merged their improved QtHelp plugin that gives you the ability to integrate arbitrary .qch files into KDevelop, e.g. the KDE Api documentation. They also work on [man integration](, which will be a joy for all STD C / C++ developers.

Furthermore we now have a “Filter…” line edit above the project manager view, “Argument Dependent Lookup” for the C++ plugin, a much improved “Problems” toolview, with the ability to show TODOs etc. pp.

This is just from the last few weeks, and it’s work done by many new contributors. It’s really very cool to see this happening.

Oh, and I personally worked a bit on the QMake support for KDevelop, I’m not sure whether I will manage to get this into a usable state for KDevelop 4.2, but I already use it at work.

Which brings me to the last part of this blog post, release schedules! I’ll finally release a KDevelop 4.1.1 bug fix version next week, and will make sure that there is a 4.2 release just before / shortly after the KDE 4.6 release in January. The big “issue” there is that KDevelop 4.1 will not work with KDE 4.6+, since there are no SmartRanges in Kate from 4.6 anymore. So a big fat warning to any adventurous tester out there: If you want to try KDE 4.6 betas, remember that you’ll have to get KDevelop master (== 4.2) as well somehow!

So, that’s it for now, have a nice sunday everyone :)

KDevelop and Kate advancements over the last weeks

Sun, 21 Nov 2010 15:38:15 +0000

Hey all,

Kate

KDevelop

This is just from the last few weeks, and it’s work done by many new contributors. It’s really very cool to see this happening.

Oh, and I personally worked a bit on the QMake support for KDevelop, I’m not sure whether I will manage to get this into a usable state for KDevelop 4.2, but I already use it at work.

So, that’s it for now, have a nice sunday everyone :)

Kate on git.kde.org

Tue, 16 Nov 2010 19:32:47 +0000

Goodbye to Gitorious, welcome to git.kde.org.

You can find the Kate project here.
The “Get It!” page on the homepage is updated, too.
Push access is still restricted, but that will not last for ever ;)

Thanks to the sysadmin team of KDE, thanks guys, for all the work you put into the new infrastructure (and to help me with my faults ;)
And thanks to Gitorious, it was a nice time there, and I learned to appreciate Git, like many Kate developers (some appreciated it even before).

Like before, all changes in SVN and Git will be synced by me, as Kate is still released with KDE SC from SVN.

For the future I would like (and most kate devs, too) to develop solely in the Kate repository and have Kate released from there with KDE SC (instead spread over several modules).
But this must still be discussed with the release team after 4.6.
Beside, this means no split off from KDE, but it makes contributing to Kate that much easier, given atm you would need to checkout/clone kdelibs + kdebase + kdesdk and try to build there the Kate relevant parts, which is just no fun, if you just want to hack on some small bug or feature :/

Kate git repository moving to git.kde.org soon!

Sun, 14 Nov 2010 18:40:32 +0000

We tried to move weeks ago already, but in our current repository some small glitches occured during the SVN => Git transition.
I have redone the conversion now and soon we will be on git.kde.org (if I not screw that again, thanks already to sysadmin for all help, now and in past!).
Still some small stuff will then need to be ported, which I will do after the initial repository is up there.
After this, the repository on Gitorious will vanish.

I will keep syncing KDE SVN and the repository, until KDE has migrated, too.
But please, if you work on features rather than simple oneliner fixes, use the git repository on git.kde.org after it is announced to be available.
You have automagically a git account and it makes merges for me much easier, if there are not too many conflicts from SVN -><- Git. I hope the Kate team can keep the kate repository then as sole workspace, as working on the kate part/app is much easier for all contributors if you don’t have to get whole kdelibs/kdesdk. But that is still not discussed out I think, release team has a say here, as I would rather like to stay in KDE release cycle.

Highlight Selected Text

Sun, 14 Nov 2010 12:49:04 +0000

Kate has a new plugin called “Highlight Selection”. Since it is a KTextEditor plugin, it is available for all apps using KatePart (e.g.: Kile, Kate, KWrite, KDevelop etc). What does it do? If you select a whole word, all occurrences of this word are highlighted as well:

You can jump to the next occurrence with ctrl+h (btw: ctrl+h works already since KDE 4.2 or so). The plugin will be included in KDE 4.6. If you can’t wait, you can use it already now by building Kate from the sources.

(Side note: Be careful with enabling this plugin in KDevelop, since KDevelop itself is already doing extensive highlighting)

PHP treeview improvements in Kate

Wed, 27 Oct 2010 19:04:31 +0000

Being a regular Kate user (more than half a dozen hours each day), I was not satisfied by the PHP treeview (available from the SymbolViewer plugin). As some of you have probably noticed, it is quite outdated and seems to only support the PHP4 syntax.

Here is a screenshot:

The recent switch of Kate to gitourious was the trigger to try compile it on my own and to dive into the source code. A few hours later, the PHP treeview was rewritten. It currently supports the PHP5 syntax (even the namespaces).

Here is screenshot with the same file:

I’ve submitted my patch to the Kate Team (via the mailing list) and it was kindly accepted and merged. Thanks.

PS: Hi Planet KDE, this is my first post :)

Recent Files Menu in Kate

Wed, 27 Oct 2010 10:13:48 +0000

As many other applications Kate has the menu File > Recent Files, which lists all files you recently used. This recent file list right now is per session, i.e., each session has its own entries listed as recent files. Now there is a request to change it such that there is just one single global recent file list. I think having two recent files menus (one for the session and one global) is a bad solution. Further, adding an option for that also sounds wrong.

To change or not to change, that’s the question?! :) What do you think?

File Tree plugin and Kate in KDE SC 4.6

Wed, 20 Oct 2010 07:38:29 +0000

Hi! It’s me again. Got some exciting news.

The file tree is now the default (and only) document list/view widget. It actually took me by surprise. After I got the list mode and other features implemented, the old document list was unceremoniously ripped out, and extensions were added to allow kate to always load a given plugin, and give its settings tab a little more prominence.

Since then however I’ve fixed a few issues regarding the settings in the plugin. The file tree settings tab now sets the plugins global settings, and will clear out the setting overrides for the current session so they will get pulled from the global settings. And I just finished up adding back the “Go” menu, and the “next” and “prev” document shortcuts.

Just to be clear, you are NOT forced to use a tree view from now on. That is just the current default. You can switch to list mode using either the settings dialog (which will apply to kate globally, minus any sessions you have used the document view context menu to change the mode for), or using the context menu on the document view (file tree) widget.

Thank you to everyone who has used my plugin in the past, and to everyone who will be using it in the future :)

Introducing Kate GDB Plugin

Wed, 06 Oct 2010 21:08:34 +0000

Have you, like me, had to switch to an external debugger or run raw gdb in the terminal plugin to debug the C/C++ application you develop with Kate? That might not be necessary any more. There is now a “GDB Plugin” in trunk that gives you the power of raw GDB with some QAction candy for the most common actions.

I have always been a bit frustrated with not having a debugger directly in Kate, but too lazy/busy to start a debugger plugin project. Fortunately Ian Wakeling started this GDB plugin and got it off the ground. When I got introduced to it at Akademy, it triggered an itch in me to get this plugin into kdesdk and to add some features for the more point and click type of persons. As it seemed I had a bit more free time to spend on the plugin, Ian let me take over as maintainer.

Main features of the plugin:
– Jump to the corresponding file and line whenever gdb stops.
– Insert and remove breakpoints.
– Tool-bar buttons for the most often used actions like step into/over/out. Those actions can of course also be assigned to keyboard shortcuts.
– Execution markers and breakpoint markers on the icon border.
– A call stack tab for point and click navigation of the call stack.
– Optional IO redirection to a separate tab.
– Printing the value of the currently selected variable or expression. QStrings and friends are not supported (yet?).
– And last but not least. A GDB console for the full power of GDB.

And now the screen-shots

GDB Console, execution marker and a breakpoint marker.

The current call stack.

Settings tab.

Redirected IO.

The selected variable and the GDB value output.

The debug menu.

Kate Tree View Plugin Update

Sun, 12 Sep 2010 15:27:23 +0000

It’s me again. Given how much people seem to like the plugin, and that some would like to see this plugin replace the existing simple list view, I’ve put in a bit of work to make it so the tree view plugin replaces as much functionality of the original file list as possible.

There’s now a list mode (which was surprisingly easy to do), as well as the tree mode and I’ve extended the sorting support to include all but the “custom sort order” option of the original file list (it’ll take a bit more work to support that, if its something people actually use, I just haven’t felt like doing the work to get drag and drop to work, and before now it didn’t make much sense to add). While I was at it I also added a Settings Dialog Page for the plugin.

One improvement (imo) over the old file list, is that all tree view settings are session specific. Each session saves its own sorting, view mode, and item highlighting color settings.

Now for some gratuitous screen shots:

Here we see the new sort order context menu items, pretty dull so far.

Now it starts to get a little more interesting. The view mode context menu!

Ooh, and now we can see it displaying in list mode!

Again in list mode, but sorted by the document’s path, rather than just by document name.

And here’s the new config page. Nothing much to look at, but it works :)

I still have a couple more things I want to add, like a fancy way to filter and eventually, if everyone’s agreeable, I’ll thief the back/forward actions, and the “Go” menu from the main file list.

Before I go, I was wondering if people would be willing to help me with some distro packages, I might be able to manage some Debian packages, but I’m not sure when I’ll get to it so if anyone is willing and capable, have at it.

Thats all for now. Thanks for reading :)

Tree View plugin introduction

Fri, 10 Sep 2010 01:07:36 +0000

Kate has been my favorite editor for some time now. And only recently has it not been able to do something I asked it do to. I was working on a rather large project in Perl when things started getting confusing. The classic file list had 50+ files in it, some of them have the same file name, so would have (1) or (2) or even (4) after the file name, and while thats handy, it gets confusing pretty quickly.

So I spent a week to try and bring order to the chaos. And this is what I came up with.

Now I can tell people are thinking, but Thomas, that doesn’t look so confusing.. Granted.

Here’s what my larger project looks like with the file list:

I think anyone will have a hard time working with that unholy mess. After trying to manage that for more than a couple of days I sat down and decided to write the tree plugin. Heres what the mess looks like now:

Is that not a lot better?

Some of you reading this might have noticed that it isn’t creating a full file system tree. That is it isn’t making “/” or “C:” the root of the tree. Indeed. It uses a couple tricks to make sure the tree isn’t cluttered with directories you really don’t care about. If people are interested I can explain more about how it does what it does in a more technical post.

I’ve heard a few people ask if this shouldn’t just outright replace the existing file list. The Kate developers don’t see why not, but I have my doubts that it is a proper “one size fits all” solution. As far as I can tell, it is impossible to make the tree behave in a fully sane and expected manner. In some cases it won’t merge some folders you think it should, but (IMO) trying to make the tree behave any “better” would make it less useful (at least to me). I’m interested in what people think, is it “good enough” to become the default document list, or even replace the existing one outright?

I’ve committed the plugin to KDE svn, and just uploaded to kde-apps if anyone is interested in giving it a try. I’ve tested it with Kate/KDE 4.4, 4.5, and Kate from trunk. Please let me know what you think, and tell me if you have any problems or concerns! Thanks :)

p.s. I’m new to this whole blogging thing, please be gentle ;)

Beware of KDevelop Master and KDELibs 4.5.1 or lower

Wed, 08 Sep 2010 15:57:41 +0000

Hey all,

please don’t use KDevelop master with KDELibs 4.5.1 or lower. Katepart in that version misses a crucial commit that makes KDevelop crash. It is fixed for 4.5.2. In the meantime you have on of the following options:

Build kate from sources
Switch to the stable branches, i.e.: KDevplatform 1.1, KDevelop 4.1, PHP 1.1, …
wait for the 4.5.2 release

bye

Beware of KDevelop Master and KDELibs 4.5.1 or lower

Wed, 08 Sep 2010 15:57:41 +0000

Hey all,

Build kate from sources
Switch to the stable branches, i.e.: KDevplatform 1.1, KDevelop 4.1, PHP 1.1, …
wait for the 4.5.2 release

bye

Encoding Detection Revised

Thu, 26 Aug 2010 16:26:43 +0000

In recent KDE releases up to version 4.4 Kate unfortunately very often selected the wrong encoding. The result is that e.g. german umlauts (öäü) show up as cryptic signs in the text editor. What I’ve seen lots of times is that in this case people start to fix those characters manually for the entire document. In other words: They totally do not get at all that the text document simply was opened with the wrong encoding. In fact, the users usually do not even know what encoding is at all. While this is of course kind of sad, this certainly won’t change…

Given this fact, the only correct “fix” is a very good automatic encoding detection, such that the encoding is usually chosen correctly. In the rewrite of Kate’s text buffer for KDE 4.5, Christoph also rewrote the file loader including the encoding detection. The detection now works as follows:

try selected encoding by the user (through the open-file-dialog or the console)
try encoding detection (some intelligent trial & error method)
use fallback encoding

In step 1, Kate tries to use the encoding specified in the open-file-dialog or the one given when launching Kate from the console. On success, we are done.

The encoding detection in step 2 first tries unicode encoding by looking for a Byte Order Mark (BOM). If found, it is certain that the text document is unicode encoded. If there is no BOM, Kate next uses a tool from KDElibs (KEncodingProber) to detect the correct encoding. This is basically trial & error: Try encoding A, if there are characters in the document the encoding is not able to represent, try encoding B. Then C and so on… Unfortunately, this also doesn’t always work, because a byte sequence might be valid in several encodings and represent different characters. This is why it’s more or less impossible to get the encoding always right. There is simply no way…

If the encoding detection fails, Kate uses a fallback encoding. You can configure this fallback encoding in the editor component settings in the “Open/Save” category. If the fallback encoding fails as well, the document is marked as read-only and a warning is shown.

What about Kile and KDevelop?

One of the applications that heavily suffered of the wrong encoding detection in the past was the LaTeX editor Kile. The same holds probably for KDevelop (although it’s usually less critical with source code). The good news is, that with KDE >= 4.5 the problems with respect to wrong encoding should be gone. So it’s certainly worth to update if you are affected by this issue.

Kate – GSoC Summary

Thu, 26 Aug 2010 10:43:35 +0000

Hello planet,

As Google Summer of Code is now finished and I have successfully passed the final evaluation, I would like to give a brief description of my project.

Kate is now able to recover (most of) what was written after last save in case of a crash or power failure. A swap file is created after the first editing action on a document that was successfully saved. If the user closes the document normally or saves its content, the swap file is deleted, otherwise, if Kate crashes, it remains on the disk. On load, Kate searches for the swap file, and if it exists, a warning bar pops from the top and provides the user with three possibilities: recover the lost data, discard the swap file or view differences between the original data and the recovered one. If the user chooses to restore the lost data, the editing actions from the swap file are replayed over the current content of the document. If somehow the swap file is not valid, for example a finishEditing statement is missing, the recovery is done, but the user is warned that it might be incomplete.

Only the core feature for swap file is implemented at the moment. I know I could have done more, but things went slow at the beginning, as I was new to Qt and KDE development and also had a demanding exam period. But this has a positive aspect, too, as will motivate me to continue my work at this project.

This has been a great summer for me as I was accepted into GSoC program and got a chance to do what I like and get paid for it. I want to thank Christoph, my mentor, for having patience with me and helping me with all the problems I have encountered. I also want to thank the whole Kate team, KDE community and Google :).

Kate Night-Make

Mon, 23 Aug 2010 19:31:08 +0000

Each night now Kate (part/app) is build from git and all unit tests are run. Yeah, we even got some tests .P
Until now, that just reminds on of our failures ;) But I hope the daily mail will perhaps motivate me and others more to fix them ;)

Beside, thanks for all the people working to write these tests, like Bernhard, Dominik and Milian.

Kate Nightmake Tests
From: cullmann@kate-editor.org
To: kwrite-devel@kde.org
Date: Today 05:06:46
[HANDLER_OUTPUT]
Test project /home/www/kate-editor.org/build/build
Start  1: katetextbuffertest
1/34 Test  #1: katetextbuffertest ...............   Passed    0.02 sec
Start  2: range_test
2/34 Test  #2: range_test .......................   Passed    1.09 sec
Start  3: testkateregression
3/34 Test  #3: testkateregression ...............***Failed    0.03 sec
Start  4: undomanager_test
4/34 Test  #4: undomanager_test .................   Passed    1.34 sec
Start  5: plaintextsearch_test
5/34 Test  #5: plaintextsearch_test .............   Passed    7.56 sec
Start  6: regexpsearch_test
6/34 Test  #6: regexpsearch_test ................   Passed    8.45 sec
Start  7: scriptdocument_test
7/34 Test  #7: scriptdocument_test ..............   Passed    1.36 sec
Start  8: completion_test
8/34 Test  #8: completion_test ..................***Failed    0.95 sec
Start  9: searchbar_test
9/34 Test  #9: searchbar_test ...................***Failed   11.24 sec
Start 10: movingcursor_test
10/34 Test #10: movingcursor_test ................   Passed    0.94 sec
Start 11: movingrange_test
11/34 Test #11: movingrange_test .................   Passed    1.79 sec
Start 12: katedocument_test
12/34 Test #12: katedocument_test ................   Passed    1.09 sec
Start 13: revision_test
13/34 Test #13: revision_test ....................   Passed    0.63 sec
Start 14: templatehandler_test
14/34 Test #14: templatehandler_test .............   Passed    0.44 sec
Start 15: indenttest
15/34 Test #15: indenttest .......................***Failed   25.87 sec
Start 16: bug213964_test
16/34 Test #16: bug213964_test ...................   Passed    0.73 sec
Start 17: utf8.txt_create
17/34 Test #17: utf8.txt_create ..................   Passed    0.17 sec
Start 18: utf8.txt_diff
18/34 Test #18: utf8.txt_diff ....................   Passed    0.01 sec
Start 19: latin15.txt_create
19/34 Test #19: latin15.txt_create ...............***Exception: SegFault  0.04 sec
Start 20: latin15.txt_diff
20/34 Test #20: latin15.txt_diff .................***Failed    0.01 sec
Start 21: utf32.txt_create
21/34 Test #21: utf32.txt_create .................   Passed    0.13 sec
Start 22: utf32.txt_diff
22/34 Test #22: utf32.txt_diff ...................   Passed    0.01 sec
Start 23: utf16.txt_create
23/34 Test #23: utf16.txt_create .................   Passed    0.10 sec
Start 24: utf16.txt_diff
24/34 Test #24: utf16.txt_diff ...................   Passed    0.01 sec
Start 25: utf32be.txt_create
25/34 Test #25: utf32be.txt_create ...............   Passed    0.10 sec
Start 26: utf32be.txt_diff
26/34 Test #26: utf32be.txt_diff .................   Passed    0.01 sec
Start 27: utf16be.txt_create
27/34 Test #27: utf16be.txt_create ...............   Passed    0.10 sec
Start 28: utf16be.txt_diff
28/34 Test #28: utf16be.txt_diff .................   Passed    0.01 sec
Start 29: cyrillic_utf8.txt_create
29/34 Test #29: cyrillic_utf8.txt_create .........   Passed    0.10 sec
Start 30: cyrillic_utf8.txt_diff
30/34 Test #30: cyrillic_utf8.txt_diff ...........   Passed    0.01 sec
Start 31: cp1251.txt_create
31/34 Test #31: cp1251.txt_create ................   Passed    0.10 sec
Start 32: cp1251.txt_diff
32/34 Test #32: cp1251.txt_diff ..................   Passed    0.01 sec
Start 33: koi8-r.txt_create
33/34 Test #33: koi8-r.txt_create ................   Passed    0.11 sec
Start 34: koi8-r.txt_diff
34/34 Test #34: koi8-r.txt_diff ..................   Passed    0.01 sec
82% tests passed, 6 tests failed out of 34
Total Test time (real) =  64.64 sec
The following tests FAILED:
3 - testkateregression (Failed)
8 - completion_test (Failed)
9 - searchbar_test (Failed)
15 - indenttest (Failed)
19 - latin15.txt_create (SEGFAULT)
20 - latin15.txt_diff (Failed)
[ERROR_MESSAGE]
Errors while running CTest

Kate History ;)

Sun, 15 Aug 2010 16:16:46 +0000

While setting up the new server for the Kate homepage, I actually found again old stuff ;)
Amazing that mails nearly ten years old can still be somewhere on the filesystem.
Perhaps a little hint, to post the beginnings of what today is Kate/KatePart/KWrite and KTextEditor.

Ten years ago, I asked the original author of KWrite, if he is interested in a MDI version of it (sorry, german, original mail):

From: Cullmann Christoph <crossfire@babylon2k.de>
To: digisnap@cs.tu-berlin.de
Subject: KWrite - Verbesserungsvorschläge
Date: Thu, 14 Dec 2000 18:38:42 +0100
Hallo
Ich benutze KWrite regelmässig um Quellcode zu bearbeiten und das
Syntaxhighlighting ist sehr praktisch.
Es wäre jedoch schön wenn KWrite eine MDI-Oberfläche hätte.
Ich baue gerade eine und falls jemand Interesse hat können sie sich ja melden.
Danke und Tschö
Christoph Cullmann

I actually never got any reaction from the author Jochen Wilhelmy. Guess the mail address was already abandoned at that time.
Later I tried my luck with kde-devel:

From: Cullmann Christoph <crossfire@babylon2k.de>
To: kde-devel@max.tat.physik.uni-tuebingen.de
Subject: Need help - KWrite
Date: Thu, 4 Jan 2001 00:21:35 +0100
Hi,
i am building a mdi texteditor using the kwrite-widget.
I want to use most of the extended features of the kwrite class, like search
dialog, kspell, ....
Is there any way to do this using the KParts system or must i use the kwrite
include files and compile the kwrite widget into my program ?
cu and thanks for any answer
C. Cullmann

Not much reactions, thought, but I kept to be persistent ;)

From: Cullmann Christoph <crossfire@babylon2k.de>
To: kde-devel@max.tat.physik.uni-tuebingen.de
Subject: Re: Looking for kwrite developers.
Date: Thu, 11 Jan 2001 17:30:19 +0100
Hi all,
I have build up a editor using the KWrite Widget and a QTabWidget to provide
a multidocument interface :-)
It has some bugs at the moment (I think QTabWidget is the problem) but works
real nice.
Anybody interested in this ?
cu
C. cullmann

Shortly after this mail, one of the developers which stayed around for years joined, Anders Lund (more at the team page).
I named the starting project “KCEdit” and put it up on sourceforge.net:

From: Cullmann Christoph <crossfire@babylon2k.de>
To: kde-devel@max.tat.physik.uni-tuebingen.de
Subject: MDI TextEditor - KCEdit
Date: Sat, 13 Jan 2001 12:04:33 +0100
Hi all,
I have build up a small mdi texteditor using the kwrite widget :-)
If someone is interested in helping to improve it or only wants to
test it a bit, i have set a sourceforge.net project up.
url : http://sourceforge.net/projects/kcedit
It would be nice if someone wants to take part in the development.
cu
C.Cullmann

After that, the next nice guy joined: Michael Bartl.
We searched for a new name for the editor, as KCEdit was not that nice, as very similar to KEdit and no longer only “Cullmann”‘s pet project.
What did we choose? Here you see:

From: Cullmann Christoph <crossfire@babylon2k.de>
To: Michael Bartl <michael.bartl1@chello.at>
Subject: Kant is born ;-)
Date: Fri, 19 Jan 2001 20:55:59 +0100
Here it is ;-)
kant-0.1.0.tar.gz

As sourceforge.net failed to be a nice hosting, we moved the project to http://www.openave.net (and later back again, lol).
Because of family problems Michael dropped out of the time after sometime, still BIG THANK YOU.

Later, I tried to get my changes back in KDE, as I didn’t want to do a permanent fork:

From: Cullmann Christoph <crossfire@babylon2k.de>
To: kde-devel@max.tat.physik.uni-tuebingen.de
Subject: How can I participate in the KWrite project ?
Date: Tue, 20 Feb 2001 20:25:15 +0100
Cc: kde-core-devel@max.tat.physik.uni-tuebingen.de
Hi,
I want to help as a developer in the kwrite project. I and some other people
are working on Kant (http://www.sourceforge.net/projects/kant), a MDI
texteditor for kde >=2.0 and we often find bugs in the kwrite code or missing
features we would need. It would be great if I could help to develop kwrite
because only sending bug reports and hoping that new features in kwrite will
come up sometime is really annoying.
How can I join the KWrite team and get CVS read/write access (perhaps ;-) ?
To have an overview about my skills please look at the Kant sourcecode or
simply download and test Kant out of the CVS at sourceforge.net.
cu and thx for you interest
Christoph Cullmann
P.S.
Sorry for the bad English ;-)

Without much problems, I got a CVS account on the KDE server and was allowed to add my code and the code of the others to the KWrite codebase.
All other contributors which were still active got accounts later, too. Worked all like a charm thanks to Waldo Bastian.
Still Kant itself was not in KDE, therefor next try:

From: Cullmann Christoph <crossfire@babylon2k.de>
To: kde-devel@max.tat.physik.uni-tuebingen.de
Subject: Could Kant replace or extend KWrite in KDE ?
Date: Sat, 24 Feb 2001 17:28:58 +0100
Hi,
I am the projectmanager of Kant, a MDI texteditor which uses the KWrite
widget for displaying text (no MDI like you know it from windows, MDI like
you know it from Emacs or Konqueror :).
Kant has come to a level of stability which would it allow to put it into the
kde cvs i hope. I have talked with Carsten Pfeiffer (he likes Kant :) and he
told me to send a message to this list to start a discussion if and where
Kant could be integrated.
I just released a new Kant version (kant-0.2.0-prerelease) on sourceforge.net
for testing the app that you have an overview about its features.
Kant Homepage:
http://sourceforge.net/projects/kant/
newest Kant version to download:
http://download.sourceforge.net/kant/kant-0.2.0-prerelease.tar.gz
nice screenshot of Kant:
http://sourceforge.net/dbimage.php?id=1590
If you want to look at the unstable development code just look into the Kant
CVS at sourceforge.net, you find the exact description to checkout at the
Kant Homepage under "CVS" (cvs-modulename: kant).
Kant links dynamic to kwritepart and konsolepart. This must be considered if
you want to put Kant into kde cvs.
I hope you all like Kant, I think it would be a nice replacement for KWrite.
cu and thx
Christoph
P.S.
Sorry for my poor English and the big tar.gz file (something isn't right with
make dist in kant, must fix it :)

After some changes to the code, we were allowed to move the development completly to KDE CVS.
Joseph Wenninger joined the development, too.

Btw., my nice old e-mail footer:

| | / / - get an edge in editing -
| | / / »»»» GET KANT ««««
| |/ / a fast and capable multiple document,
| \ multiple view text editor for KDE
| |\ \
| | \ \ http://devel-home.kde.org/~kant

Whereas Kant was just a fine name for us, it had some pronunciation in english which was not that political correct ;)
Therefor we searched a new name:

From: Cullmann Christoph <crossfire@babylon2k.de>
To: David Faure <david@mandrakesoft.com>
Subject: Hi, is Kate a good name ?
Date: Sat, 31 Mar 2001 15:15:47 +0200
Hi David,
would be Kate a political correct name for Kant ?
Kate - KDE Advanced Text Editor
cu
Christoph

We even asked the developers of Katy, an other text editor, if they would have problems with that name change ;)
Kate was born ;)

kate-editor.org moved

Sat, 14 Aug 2010 14:10:56 +0000

The website is now on a new server, which is a lot faster than the old one and software/hardware is fresh again.
Hope the problems we had in the past few weeks are over now.
No other real downtimes are planned, perhaps some reboots but nothing more than some minutes ;)
Hope I can now finally setup my planned automated unit-tests and build ;)
The DNS transfer seems to be faster than thought, still some people might arrive at the old server, where now only a stupid “Maintainance” page is up. The IP of the new server is 85.214.230.250.

kate-editor.org moving

Fri, 13 Aug 2010 15:31:44 +0000

In the last weeks, the homepage was sometimes down, as the server it is on is slowly dying. I just negotiate the transfer to a new one. That one will allow additional stuff to be run, guess we than even have nightly unit test runs (at least I hope so) ;)

Therefor it may be, that the site is not reachable, as DNS transfer might always take some days.

SmartRanges goodbye

Fri, 13 Aug 2010 06:53:13 +0000

Like told in previous posts here and there, KDE 4.6 won’t have a KatePart that supports the SmartInterface but instead KatePart moves on to the new and shiny (and much simpler) MovingInterface for the handling of automatic moving cursors and ranges.

Now the big cut is done: KatePart in /trunk no longer implements the SmartInterface. KDevelop already adopted the new interface in a development branch, lets see how that all evolves.

SVN commit 1162946 by cullmann:
Smart* handling is purged in kate part now for KDE 4.6.
It seems to work, at least I used it in that state now more than a day.
More stuff needs polishing still, like removing the duplicated edit history, but nice first start.
M +0 -7 CMakeLists.txt
M +0 -1 completion/katecompletiondelegate.cpp
M +13 -49 completion/katecompletionwidget.cpp
M +5 -6 completion/katecompletionwidget.h
M +6 -215 document/katedocument.cpp
M +0 -64 document/katedocument.h
M +1 -5 render/katerenderer.cpp
M +0 -191 render/katerenderrange.cpp
M +1 -25 render/katerenderrange.h
D smart (directory)
M +0 -2 tests/completion_test.cpp
M +0 -81 view/kateview.cpp
M +0 -17 view/kateview.h
M +0 -1 view/kateviewhelpers.cpp
M +7 -184 view/kateviewinternal.cpp
M +1 -20 view/kateviewinternal.h

Featured Articles

Thu, 12 Aug 2010 12:38:11 +0000

Looking back at the last month, migrating our Kate homepage over to WordPress was a vast success. The useful content we had on our old Drupal was copied over. The benefit of WordPress is that we now have a nice blog software as well with which we even aggregate some external blogs related to Kate. The new homepage is also more structured by having a list of featured articles showing useful resources, such as links to user or developer documentation.

The idea behind of the featured articles is to provide links to blog entries explaining in more depth what you can do with Kate. There are lots of useful tricks probably even some KDE developers aren’t aware of. If you have further hints of how to efficiently use Kate, please contact us and write a blog entry on kate-editor.org.

Besides that, thanks to all contributors for our awesome release in 4.5! :)

KDE 4.5 is approaching, thanks to all Kate contributors

Fri, 06 Aug 2010 08:10:11 +0000

KDE 4.5 will be released in the next days with the most polished Kate/KWrite and KatePart during the KDE 4.x series.

A lot of work went into fixing bugs and cleaning up old code for this release. Many important aspects where redone, just to enumerate a few:

encoding detection & handling
the text buffer
the undo/redo system (thanks Bernhard)
search/replace (thanks again Bernhard)
handling cursors and ranges
improved spell checking (thanks Michel)
improved indentation (thanks Milian)
speed improvements (Milian too)
better JS scripting (Dominik)
porting of KDevelop to new interfaces (David Nolden)

It will be the most unit-tested release of KatePart ever I guess, but still a long way to go until we have a good test coverage. (we just scratch the surface)

Many thanks to the people contributing to this release (not only to the ones named above or below!), without that much helping hands, never such an amount of cool stuff would have happened ;)

I guess one of the real kickoffs was the great Kate/KDevelop sprint in Berlin, handled by Milian and sponsored by the e.V., thanks a lot!

For the next release, with KDE 4.6, already new cool stuff is in production:

vim-like swapfiles by Diana (see here and here)
the awesome SQL plugin by Marco

If you think, you can help us, just join us and make Kate for KDE 4.6 even more awesome.

KateSQL, a new plugin for Kate

Thu, 29 Jul 2010 21:45:22 +0000

Hello,

today i will show you a new plugin for Kate, called KateSQL.
As you may have guessed, it brings to Kate the basic features of an SQL client, allowing you to open connections, execute queries, and display result data from SELECT statements or stored procedures.
Since this plugin makes an extreme use of the Qt Sql module, most of database drivers are supported..

Said this, let me explain how it works..

First of all, you have to create a new db connection through a simple wizard, specifying driver, connection parameters (hostname, username, password, etc…), and a descriptive name, that KateSQL will use as identifier.
Done this, what you need to do is just select the query text in the editor and press F5 (or your preferred shortcut). The whole text will be executed through the selected connection.

For SQL output, two toolbox are disposed in the bottom area:

The first will show messages returned from the server (errors in red, others in green, like number of affected rows).
The second contains a table view with a custom model associated, to show resultsets of a query. This custom model does nothing more than a QSqlQueryModel, only provides colors and formatting for each cell..

Ah, about this, my last commit implements a configuration widget that let you choose colors and font styles for text fields, numbers, blobs, nulls, booleans and dates… cool, yeah? :)

Last but not least, on the left panel you can find a basic and useful schema browser, that show the tree schema of the database connection currently selected. With this tree widget you can browse through tables, system tables and views, up to individual fields. obviously, primary key fields are distinguished by the classic yellow key icon.

Currently, there are few problems with multiple query handling.. Some engines doesn’t supports it natively, others can receive queries separated by a semicolon, but the QSqlQueryModel can handle only one resultset at time.. probably the best solution is to parse the text, split queries, and execute them separately.. Surely, this feature will be implemented soon.
Stay tuned!

Of course, if you want to help us with development, you are welcome!

GSoC – View differences for Kate’s swap files

Tue, 27 Jul 2010 09:16:07 +0000

Hello,

As I stated in a previous post, the swap file feature for Kate is almost done. Back then, the view differences feature wasn’t ready, but now we have a basic implementation of it.

So now, by pressing the “View changes” button, a new KProcess is created, which receives as command line arguments the ‘diff’ program and the two files to be compared. One file is the original file on the disk, and the other one is represented by the recovered data read from the standard input. Then, Kompare launches, and there you can see the differences.

But sadly, at the moment you can’t merge the changes or some of them through Kompare, but I’m working on it. All you can do is see the differences and decide whether you want to recover the lost data or not. Close Kompare, and then press the “Recover” button or the “Discard” one, depending on what you want to do.

Spotlight: Kate Scripting

Mon, 26 Jul 2010 22:51:25 +0000

Hey ho everyone.

Dominik asked me to blog about a feature in Kate that is still (sadly!) pretty unknown and seldom used: Kate Scripting. As you should know you can script KatePart completely via JavaScript. As those articles explain, it’s rather simple to write functions and put them into a file to have them reusable. But what for those write-use-throwaway kind of cases, where you simply need to get a job done quickly and don’t want to go through the overhead of writing some full fledged, documented, action-binded, localized script?

Utility Functions and why JavaScript rocks

Note: Neither map nor filter will be shipped with 4.5 to my knowledge, sorry about that. But you can still use the each helper (see below) to achieve the same with a bit more typing…

Take a look at utils.js on current git master: http://gitorious.org/kate/kate/blobs/master/part/script/data/utils.js

Put a special note on the helper functions map, filter and each and how they are used to implement e.g. rmblank, [rl]trim and the other functions. Cool eh? And the best part, you can reuse them directly from inside KatePart to get a job done:

mail-style quoting

Lets assume you write an email or use something like Markdown or Textile and want to quote. You’ll have to prepend a few lines with the two chars ‘> ‘. Instead of copy’n’pasting like a maniac do this instead and save yourself some breath:

press F7 to open the Kate command line
write e.g. map “function(l) { return ‘> ‘ + l; }”
execute

Note: When you don’t have anything selected, the whole document will get “quoted”.

remove lines that match a pattern

This is something everyone needs to do sooner or later, happened quite a few times to me already. I bet vim has some esoteric command I cannot remember and emacs has something like C-x M-c M-butterfly. But with Kate most users only see search & replace and forfeit to the command line. Well, now it’s again a good time to use the command line:

press F7 again
write e.g. filter “function(l) { return l.indexOf(‘myNeedle’) == -1; }”
execute

Now all lines that contain ‘myNeedle’ will get removed. Sure, this is “verbose” but assuming you know JavaScript it’s actually quite easy, expendable and - best of all - good to remember. At least for me, YMMV.

shortcuts

For simple cases I’ve now introduced a shortcut way of doing the above, that saves you even more typing, but is limited to simple evaluations like the ones above. If you need something fancy, you’ll have to stick to the type-intensive way. Aynhow, here’s the shortcut version of the two scripts:

map “’> ‘ + line”
filter “line.indexOf(‘myNeedle’) == -1”

the guts: `each` (interesting for users of KDE 4.x, x < 6)

Both of the above are implemented using the each helper I introduced even before KDE 4.4 afair. If you are using KDE 4.5 and want to do one of the above, a bit more typing is required:

for map, you write something like this:
each “function(lines) { return lines.map(function(l){ /** actual map code **/ }); }”
for filter you do the same but replace map with filter:
each “function(lines) { return lines.filter(function(l){ /** actual filter code **/ }); }”

Conclusion

You see, it’s quite simple and powerful. I really love map-reduce and how easy it is to use with JavaScript. Hope you like it as well.

PS: I actually think about making it yet even easier, by allowing some syntax like this: map ‘> ‘ + line or filter line.indexOf(‘myNeedle’) == -1, must take a look on how hard it would be (beside the need for extensive documentation, but hey we have the help command in the Kate CLI, who can complain now? :) Implemented

Bye

Spotlight: Kate Scripting

Mon, 26 Jul 2010 22:51:25 +0000

Hey ho everyone.

Utility Functions and why JavaScript rocks

Note: Neither map nor filter will be shipped with 4.5 to my knowledge, sorry about that. But you can still use the each helper (see below) to achieve the same with a bit more typing…

Take a look at utils.js on current git master: http://gitorious.org/kate/kate/blobs/master/part/script/data/utils.js

mail-style quoting

press F7 to open the Kate command line
write e.g. map “function(l) { return ‘> ‘ + l; }”
execute

Note: When you don’t have anything selected, the whole document will get “quoted”.

remove lines that match a pattern

press F7 again
write e.g. filter “function(l) { return l.indexOf(‘myNeedle’) == -1; }”
execute

shortcuts

map “’> ‘ + line”
filter “line.indexOf(‘myNeedle’) == -1”

the guts: `each` (interesting for users of KDE 4.x, x < 6)

Both of the above are implemented using the each helper I introduced even before KDE 4.4 afair. If you are using KDE 4.5 and want to do one of the above, a bit more typing is required:

for map, you write something like this:
each “function(lines) { return lines.map(function(l){ /** actual map code **/ }); }”
for filter you do the same but replace map with filter:
each “function(lines) { return lines.filter(function(l){ /** actual filter code **/ }); }”

Conclusion

You see, it’s quite simple and powerful. I really love map-reduce and how easy it is to use with JavaScript. Hope you like it as well.

Bye

The Mission of KDE’s Wikis

Sun, 25 Jul 2010 22:21:36 +0000

KDE has three wikis: TechBase, Community and UserBase. The separation has the following meaning according to http://wiki.kde.org:

TechBase: The primary place for high quality technical information about KDE targeted at 3rd party developers, ISVs and system administrators.
Community: The working area for the KDE community. It provides a place for sharing information within the community and coordinating community teams.
UserBase: The home for KDE users and enthusiasts. It provides high quality information for end users on how to use KDE applications.

So TechBase is a source of mostly technical information. This includes step-by-step howtos for all sorts of KDE development as well as the feature plans and schedules for KDE releases and so forth. It’s mainly static content. Think of a howto for a Plasma Widget or a howto for building KDE. The content usually is valid for a long time, mostly even for years. For those of you longer in the KDE project, TechBase is the same as our good old developer.kde.org page (and we’ve never put arbitrary content there). The only difference is, that it’s now maintained as wiki.

UserBase is the same thing for users. It provides information about tips and tricks for KDE application, links to further pages an so on. It’s also rather static content. This is also why TechBase and UserBase both feature the “high quality” term.

This leaves us with the youngest of our wikis: the Community wiki. The purpose of the Community wiki is to give the KDE community a place where to coordinate. Think of leaving notes for thoughts. Or a list of contributors attending a conference. The current todo-list of a KDE project. In other words: **The community wiki is a scratch pad for all sorts of content that does not really fit into TechBase or UserBase. If you are unsure, the community wiki is most likely the right place.
**

Currently, there is a lot of content on TechBase that never was supposed to be put there. This is because the Community wiki did not exist earlier. So what should be moved from TechBase to the Community wiki? All the articles in the Projects page without exception belong in the Community wiki. Just read through the list and you’ll get the impression that it’s more a dumping ground for some project related content. This is exactly what we NOT want on TechBase. However, people keep putting content there. So this is an appeal to the KDE community: Please use the community wiki! You are free to do there whatever you want :) We have to take care to keep TechBase maintainable (this is also why techbase uses the subpages to structure the content). Sometimes less is more, so please take the time to remove Projects pages no longer needed, or move them to the community wiki. And especially put new content to the Community wiki instead of TechBase. Thanks!!!

Join Kate Development!

Fri, 23 Jul 2010 17:10:53 +0000

The Wheel of Time turns… meaning that the Kate Project has quite along history by now. The Kate Project was started back in December 2000, so it’s almost 10 years old. Development sometimes continues with a fast pace; and at other times there is almost no progress for weeks. But all in all, looking back at those 10 years, we can proudly tell you that the project is very much alive. Let’s take a look at the traffic of our mailing list:

The traffic itself does not say much about the development. It probably tells us that there are quite a lot of people using Kate and reporting wishes and bugs. This is a good thing :) The commit statistics for Kate, KWrite and the KTextEditor interfaces look like this:

Before 2000, Kate did not exist yet. Instead, so these commits come from the KWrite days. The commit rate is quite constant according to this statistic. In fact, there usually are always several developers working on Kate. Some only for a short period to implement single features or fix some bugs, and some long-term contributors. A very nice trend is given by the fact that the core team of Kate grew from about 4 to 7 developers over the last two years. So the Kate Project is very healthy – nice! And of course we are happy for every single contribution. So if you want to get involved in Kate development, join us!

MovingRanges moving on ;)

Fri, 23 Jul 2010 07:55:09 +0000

As with any new code, during adoption bottlenecks show up.

For example the rendering of text lines with many ranges inside was quiet slow. This is now partly addressed by Milian Wolff, thanks a lot.

An other bottleneck was the assumption, that it is fast enough to hash the ranges just by their block and iterate over all of them to search the ranges matching a specific line. This does scale well enough for KatePart itself, but KDevelop creates multi-thousand ranges for small documents. To improve this, an internal special mapping was implemented by David Nolden for ranges which don’t span more than one line. For them an efficient line => range mapping is easy and not to costly.

If both changes are tested a bit more, they can be backported in time for KDE 4.5, which will allow a good usability of KatePart for KDevelop once again after the rewrite, given other bugs are fixed.

The Holy Church of Kate!

Fri, 16 Jul 2010 20:51:31 +0000

Last year we already discovered that Kate is truly the only holy text editor* (again thanks to rms for making us aware of it)! (and btw, xkcd is totally wrong). And now we even have yet another proof: The holy Kate maintainer and the naked woman! Enjoy :-)

(*) this is an insider from the joint KDE and Gnome conference (gcds) in Las Palmas, Gran Canaria, 2009.

KDE 4.5: SmartRange => MovingRange

Tue, 13 Jul 2010 13:57:46 +0000

Dominik already blogged about the issues we have in KatePart with the current SmartRange/SmartCursor/Smart* interfaces that were designed during the early KDE 4.0 release.

Given that large amounts of the internal implementation are exposed to the outside in the interfaces, there was no feasible way to fix the issues with them. The problem with the not thread-safe behaviour could have been prevented by just stating the plain fact that multi-threaded access to the ranges doesn’t work, even thought there is a mutex in the interface exposed which should be locked to gain this safety. Still the real problems of the unchangable bad implemenation and design choices would have remained.

Given the fact, that the SmartInterface is an additional interface for a KTextEditor component and no component is required to implement it, we went the way to create a new redesigned additional interface, the MovingInterface.

In short: it is a stripped down version of the SmartInterface, which tries to avoid to expose any implementation details and is focused on provide the features actually used by other applications like KDevelop and have them working correct instead of providing just a mass of features, which doesn’t work at all in all corner cases.

For KDE 4.5, to not just break all applications which rely on the SmartInterface be implemented in KatePart, both interfaces will be implemented there.

As the SmartRange stuff somehow slipped into the CodeCompletionModelControllerInterface, we will provide a new version of this interface, too, version 3, subsuming 1 + 2, but without SmartRanges inside.

For KDE 4.6, KatePart won’t implement any longer the SmartInterface nor the old CodeCompletionModelControllerInterface(2), but:

MovingInterface
CodeCompletionModelControllerInterface3

If your application relies on any of these two interfaces to be implemented (or will be crippled without them), you should switch over to the new interfaces and require KDE 4.5, as soon as it is released.
That way the applications will just keep working with KDE 4.5 and higher.

KDevelop already is on the way to do so, hope others might follow (the interfaces are not widely used it seems, that at least means not that much applications are hit, KDevelop and Kile are for sure the major ones).

I can understand that this change might not be really liked by any project using the interfaces, but the plain facts are:

the code doesn’t work
it is not maintained
nobody still around really understands it
the BC of the interfaces disallows to fix the design flaws without a new interface

There will be more information for about the new stuff in the future, but thought it is a good idea to remember people outside of the Kate development about the changes, before KDE 4.5 releases (which still will provide a KatePart implementing the old interfaces).

GSoC – Swap Files for Kate

Mon, 12 Jul 2010 09:59:04 +0000

Hello,

As mid-term evaluations have started, I would like to show my current state of GSoC project, because I’ve never found the time to do it.

The swap file feature is implemented, except for the view differences feature and few TODOs. Some more testing need to be done, though. Below are some screenshots of how it works.

When you start editing in a document, a swap file for the document is created (“.swp.originalFileName”). If Kate crashes and the user didn’t save the changes, the swap file remains on the disk.

On the load of the original file, Kate checks if there is a swap file on the disk, and if it is, a warning bar pops from the top, asking if you either want to recover the data loss, discard it or view differences. If the recover button is pressed, the lost data is replayed. Otherwise, if the discard button is pressed, the swap file is removed from the disk. This also happens on normal close and on save of the original file.

Many thanks to Christoph and Dominik who helped me get it through.

Akademy 2010 – Best experience so far

Sun, 11 Jul 2010 18:23:13 +0000

My first Akademy was the greatest thing I’ve ever experienced. I remember I was quite unsure a month ago, wheter to come or not, but finally decided and booked my flight and hotel. In my first day, I was very shy and didn’t know what to do, but people came and talked to me and everything got better. The talks had very interesting topics and the speakers did their job professionally. I also want to congratulate the organization team, for making everything happen as scheduled.

The BoFs at Demola were even more interesting. You go there, find a place to sit, and start hacking with many other KDE developers. I never did this before and it is simply amazing. You can’t believe the things that can come out from these hacking days/nights :).

I have never thought that KDE is such a great community, but now I am convinced. Akademy gave me a lot of confidence ( especially “Highlights on KDE Women” talk :P ) and now I really feel I can bring something to KDE. I am a little sad because I couldn’t attend the whole Akademy, but I think that more Akademies are to come :).

kate-editor.org shaping up

Sat, 10 Jul 2010 08:27:28 +0000

kate-editor.org now contains all articles from the old page still applicable to Kate in KDE 4 and in addition all blog entries of Dominik which are Kate centric.

Beside that it will aggregate the blog entries of Milian for Kate ;)

Still, a lot of work is needed. We already got an offer for help to beautify the page by a web designer, still content writers are missing. You have a nice short post about how to use Kate best? You have some howto? Just contact us or me in private. We can either give you an account on the page or just add your content if you like that more.

New kate-editor.org launched

Fri, 09 Jul 2010 09:23:39 +0000

After some years of no real updates, beside the brave work of Dominik, a new kate-editor.org is launched.

It will be used to aggregate the blogs of the Kate developers and provide information about current development in Kate/KWrite/KatePart and guides for users.

Hope more people join the effort to once again provide a constant stream of up-to-date information.

Kate: Scripted Actions

Fri, 09 Jul 2010 09:04:00 +0000

Finally, I came around to implement scripted actions for Kate in KDE SC 4.6. Let’s take a look at how this works. When Kate starts, it searches for $KDEDIRS/share/apps/katepart/script/ for *.js files. As example, let’s take a look at utils.js there:

/* kate-script
* author: Dominik Haumann Haumann
* license: LGPL
* revision: 3
* kate-version: 3.4
* type: commands
* functions: moveLinesDown
*/
function moveLinesDown()
{
var fromLine = -1;
var toLine = -1;
var selectionRange = view.selection();
if (selectionRange.isValid() &&
selectionRange.end.line < document.lines() - 1)
{
toLine = selectionRange.start.line;
fromLine = selectionRange.end.line + 1;
} else if (view.cursorPosition().line < document.lines() - 1) {
toLine = view.cursorPosition().line;
fromLine = toLine + 1;
}
if (fromLine != -1 && toLine != -1) {
var text = document.line(fromLine);
document.editBegin();
document.removeLine(fromLine);
document.insertLine(toLine, text);
document.editEnd();
}
}
function action(cmd)
{
var a = new Object();
if (cmd == "moveLinesDown") {
a.text = i18n("Move Lines Down");
a.icon = "";
a.category = "";
a.interactive = false;
a.shortcut = "";
}
return a;
}
function help(cmd)
{
if (cmd == "moveLinesDown") {
return i18n("Move selected lines down.");
}
}

What happens is the following:

the header tells kate that there is an exported function “moveLinesDown”
so when Kate Part is loaded, it calls “action(moveLinesDown)” to check whether this function should be exposed in the GUI. Here, we return the action info that includes the displayed text, an icon, a category, whether the script needs user input (interactive) and a default shortcut. Of course, you can change the shortcuts, and also configure the toolbars to show the actions.

With this, every user is able to script arbitrary editing functions for Kate Part. We don’t have to implement all those helpers in C++ anymore. The result looks like this:
You can have this already now, you just have to use the development version of Kate :)

Enjoying Tampere

Tue, 06 Jul 2010 22:11:00 +0000

As always, the KDE conference has its funny sides, as you can see on the photo: 4 Kate developers shaping the future of the (as you all know) most awesome application: Kate :-)

A Flashback of Kate in Gitorious

Thu, 24 Jun 2010 20:32:00 +0000

Back in February, I blogged about Kate’s move to gitorious. The main reason for this move was to make building Kate as easy as possible. If you want to build Kate as part of KDE, (as of now) you have to compile kdesupport, phonon, dbusmenu-qt, kdelibs, kdepimlibs, kdebase for kwrite and kdesdk for the kate application. Getting all this done is a huge effort, especially if you are new to KDE development (I very well remember my own times spending weeks to get everything going. Be aware of new contributors might now close to nothing about KDE and all the dependencies!).
As getting new contributors is essential for keeping a project alive, the barrier to get involved should be as low as possible. And exactly this was achieved by moving all pieces to one place (this was gitorious for us). Building Kate is so simple right now that we can even make bug reporters build Kate out of the box. This helps a lot, and even results in patches from time to time. We also got quite some merge requests.
There were several voices at that time that considered moving “away from KDE” was very bad. However, this is not the case, as Christoph is synchronizing all the changes in KDE’s subversion and gitorious almost every day. This is certainly not optimal, but looking back at the last months, we can say it was worth it.
KDE is moving to git.kde.org in the near future. This also raises the discussion about how KDE’s source code will be organized. Speaking for Kate, we certainly want to have all of Kate’s code in one place, just as it is now with gitorious, no matter what :) I hope we can find a solution the KDE community can live with. To be discussed, maybe in Tampere in two weeks? :)

Debugging Kate with Qt Creator

Sat, 19 Jun 2010 09:48:00 +0000

Let’s have a quick look at how to debug Kate and KWrite with Qt Creator. First, make sure you meet the requirements:

build Kate according to this tutorial
install Qt-Creator (in my case this is version 2.0.0)

Setup the Kate project Qt-Creator once like this

start Qt-Creator like this (important to get all environment variables right):
~/kde/run.sh qtcreator
invoke File > Open File or Project and choose ~/kde/kate/CMakeLists.txt
Build Location: choose ~/kde/build
Run CMake arguments: type
../kate -DCMAKE_BUILD_TYPE=debugfull -DCMAKE_INSTALL_PREFIX=~/kde/usr
click the button “Run CMake” and then “Finish”

Start debugging like this

click the (B) “computer” icon button and choose “kate” (or “kwrite”) in the Run combo box
choose the (A) “Debug” icon in the left pane
invoke “Debug > Start Debugging (F5)”, now Kate starts
open part/document/katedocument.cpp in the file tree view on the left
go to the line “KateDocument::insertText” and click “Debug > Toggle Breakpoint (F9)”
now if you type a character in Kate, Qt-Crator will halt in KateDocument::insertText
chose “Debug > Step Opver (F10)” (and “Debug > Stip Into (F11)”) to step through the code
click on “Locals and Watchers” in the debugging pane on the bottom and you see the values of local variables

Happy debugging! :)

Kate: Code Folding Crash

Thu, 10 Jun 2010 20:55:00 +0000

We still have a crash in Kate’s code folding code; no one was able to find a proper fix, yet. So if you want to get your hands dirty, just build Kate, find a fix and be the hero of all Kate developers :)

Update: Fixed by Stefan Schenk in this commit for KDE 4.5. Awesome! :)

Kate Internals: Smart Cursors and Smart Ranges

Wed, 28 Apr 2010 15:53:00 +0000

SmartCursors and SmartRanges in KDE 4.0 – KDE 4.4

Since KDE 4.0 the KTextEditor interfaces have so called SmartCursors and SmartRanges. A SmartCursor is a text cursor (i.e. a line/column tuple) , which is bound to a text document. When editing the text document, the cursor is automatically moved such that it maintains its position. You need this for the displayed text cursor in a view for instance. If you type text, the cursor automatically moves.
A SmartRange consists of two SmartCursors: start and end. We use that for instance for the text selection or the inline spell checking, or KDevelop uses it to add arbitrary highlighting to parsed C/C++ code. Again, if you modify text in the document, the text range automatically moves, expands or shrinks.

The concept of SmartCursors and SmartRanges is doubtless very useful. However, for KDE 4.5 the Kate developers came up with an alternative implementation that will even deprecate the SmartCursors and SmartRanges in KDE 4.6. The reason for this is that the current implementation has several problems, which we will discuss in the following.

API Usage

The SmartRanges API can be used in very wrong ways. For instance, the SmartInterface has the two functions deleteCursors() and deleteRanges(). Besides that, a document reload also deletes all SmartCursors and SmartRanges. Both cases lead to a dangling pointer if you use SmartCursors or SmartRanges. Hence, whenever you use them, you always need a so-called SmartCursorWatcher / SmartCursorNotifier and SmartRangeWatcher / SmartRangeNotifier, which tell you that your SmartCursor or SmartRange is about to be deleted. Watcher and Notifier basically do the same thing. Besides deletion notification, they also tell you more e.g. that the SmartCursor position changed. If you use a notifier, those notifications are sent via signals. If you use a watcher, you have to overwrite virtuals. That is, we have two different concepts that basically do the same thing. If you use thousands of SmartRanges e.g. for arbitrary highlighting, we have possibly thousands of those emits, which does not really scale.

The API also allows to have parent/child relations, i.e. a SmartRange can have children and a parent. It is possible to traverse this hierarchy, and again since you get the pointers you can delete arbitrary SmartRanges or SmartCursors. Another reason why you always need a notifier or watcher. And if you have a notifier/watcher, you always have the signals emitted when e.g. a cursor changes, as explained above.

Further, we have lots of places where we use reference object KTextEditor::Cursor& as parameter. This const reference-object signals that it does not change. But due to SmartRange deriving from KTextEditor::Cursor, this object might also be a SmartCursor. So despite of being declared as a const object, it may change its position behind your back. This may lead to unexpected behaviours in e.g. loops where the line or column of the cursor is assumed to be constant. This is a problem in almost all functions in KatePart, so passing SmartCursors as Cursors is a very bad idea, but of course allowed.

Scaleability Problems

As mentioned above, you always need a Notifier or Watcher for all SmartCursors and SmartRanges. This will emit lots of signals you probably rarely need. Still, there is no way around it. This is a huge overhead, it simply does not scale.

Implementation

The implementation is really complex and rather undocumented in most areas. Unfortunately, only very few (or maybe even no one) really understand the code. Besides that, it is very fragile. If you change something, you might break the code. Hence, we often heard similar comments like “don’t touch the code, otherwise it will break”. Such comments alone already indicate that the current implementation is not maintainable. Unmaintainable code is bad, especially in open source projects (this is not a good way to gain new developers at all). There are other downsides of the current implementation: SmartCursors need a lot of memory for each instance; there are lots of features like animations for SmartRanges, which make the code even more complex; redundancy of watchers and notifiers bloat the code and influence the runtime behavior.

Threading

It seems there was the idea of making the KTextEditor interfaces thread safe. The SmartRanges interact with the content of the document, e.g. querying lines count and line length of lines in the text buffer. As this is done by other threads we need correct locking in all places: in document content changes, in smart cursors, in smart ranges, in the painting routines, etc. The current state in KatePart is that not all functions do the right locking. That’s why we have lots of asserts/crashs. KatePart already has more than 150 lockings at the moment, but they still do not voer problems. And very few developers (or no one?) really know when to lock and when not to. This is especially complex since we want to ensure that the locks are not hold while emitting signals or calling functions provided from the outside as callbacks, this is still not done completely right, too.

If you think about Qt, the GUI widgets are also not thread-safe, they all live in the main thread. And if you need data in other threads, you always use queued signals. This is pretty much what we experience in KatePart now. Not enough locking? Too much locking? In other words: It’s far too complex to make the KTextEditor interfaces thread-safe…

Threading and Revisions

Now to another issue in the implementation. KDevelop uses KTextEditor::Ranges in the parsing thread. Think of the following use case: KDevelop gets all the document text in the current revision (or version, if you prefer). Now it takes some time until the parsing is finished. When it’s finished, KDevelop uses the Ranges (which initially belong to the old revision of the document), and then translates those ranges to the current version of the text document (this is simple: Just track all edits inside KatePart (delete, insert, wrap, unwrap) and apply those transformations to the ranges). Now we transformed ranges from an old text revision to the current text revision. This means KDevelop does not have to parse everything again, as it knows exactly which parts changed. Awesome indeed :) However, now comes the problem: To transform Cursors and Ranges between revisions, you have to tell the SmartInterface about the revision you are working with. This is done via SmartInterface::useRevision(int). The API documentation says: Tell the smart interface to work against the given revision when creating cursors and ranges. That is, if you call useRevision() once, all succeeding calls like newSmartRange() etc are working in the past (at that revision). Also kind of cool, since useRevision() works locally in each thread. That is different threads don’t influence each other. But there is huge problem with this: Think of a KTextEditor user (KDevelop, Kile, …) uses useRevision() in the main thread. Then all succeding calls of e.g. newSmartRange() use an old revision instead of the current one. Hence, KatePart itself is completely broken in that case. (This case is now catched via a qFatal() in KatePart). But again this shows that multi-threading simply complicates the matter a lot. It would have been much easier to say transformRange(int fromRevision, int toRevision) instead of just one translateFromRevision() that translates the given range against the revision specified through useRevision(). Hence, the current API is unfortunately pretty much broken by design.

A necessary Step?

Often it’s hard to get things done right in the first try. So maybe the issues above are a necessary step to a much better implementation. And that is exactly what happened in the last two months: We have new interfaces called MovingInterface, MovingCursor and MovingRange. For feedback there is MovingRangeFeedback, which uses callbacks for notification (no signals by intention). All those classes have unit tests. KatePart in KDE 4.6 will not implement any Smart* interface anymore. Hence, KatePart will be completely single threaded again. We already started to remove several thousands of lines Smart* code that was never used/finished. Much more will follow immediately after the KDE 4.5 release. This means all developers using Smart* from the KTextEditor interfaces should migrate to the Moving* pendents for KDE 4.5 already, if possible.

I’ll provide very detailed information about the Moving* implementation in further blogs during the next month.

Kate XML Completion Plugin

Tue, 27 Apr 2010 19:45:00 +0000

A while ago I’ve blogged about the Kate’s most powerful plugins: the XML completion plugin. Thanks to Tomáš Trnka this plugin is back alive with all its features since today and compiled by default in trunk: It will be included in KDE 4.5. Yay! :) And if you need it already now for KDE 4.4, you can build Kate yourself very easily according to this howto, without touching your global KDE installation (probably interesting for KDE documentation writers!). Have fun!

Quick Compiling Kate in a stable KDE Environment

Sat, 17 Apr 2010 12:10:00 +0000

Since all of the Kate code is now co-hosted on gitorious, it became very easy to build Kate in your stable KDE >= 4.4 environment. This means you can run the newest version of Kate with very few effort. Just give it a try and do the following steps:

make sure you have the following packages installed: git, cmake and kdelibs development package (on openSUSE this is git, cmake and libkde4-devel)
create and change into a KDE development directory:
mkdir ~/kde; cd ~/kde
get a copy of the Kate code:
git clone git://gitorious.org/kate/kate.git
create and change into a build directory for compilation:
mkdir build; cd build
run the configure process with cmake:
cmake ../kate -DCMAKE_BUILD_TYPE=debugfull -DCMAKE_INSTALL_PREFIX=~/kde/usr
compile Kate:
make
finally install Kate:
make install

That’s all! This installs Kate locally into the separate directory ~/kde/usr, so that your global KDE installation will not be touched at all.

Now on to starting the newly compiled Kate. Create a file ~/kde/run.sh with the following content:

#!/bin/bashexport KATE_DIR=~/kde/usr
export PATH=$KATE_DIR/bin:$PATH
export LD_LIBRARY_PATH=$KATE_DIR/lib:$LD_LIBRARY_PATH
export KDEDIR=$KATE_DIR
export KDEDIRS=$KDEDIRexport XDG_DATA_DIRS=$XDG_DATA_DIRS:$KATE_DIR/share
# update KDE's system configuration cache
kbuildsycoca4
# start app
$@

Now you can run the compiled Kate version with ~/kde/run.sh kate. Just calling kate directly will start the system version of Kate.

Your copy of Kate contains all of the Kate code, i.e.: the KTextEditor interfaces, Kate Part, KWrite and the Kate Application. Feel free to send patches to our mailing list kwrite-devel@kde.org. And join #kate on irc.kde.org :-)

Note for KDE developers: All the changes in git are merged back to KDE’s subversion repository in a timely manner. So don’t worry about Kate moving away from KDE; this is not the case.

(Updated on 2010-04-17: Allow installation into local directory.)

Kate Internals: Text Buffer

Tue, 02 Mar 2010 23:17:00 +0000

Right now, in Kate’s gitorious repository we, or rather mainly Christoph, is rewriting the heart of Kate: The text buffer. In this blog I’ll explain how the text buffer works in detail. After reading, you’ll be able to understand the code. And be warned: Probably you will be desperately amazed about its awesomeness! So this is a must read :^)

Storage. Kate Part internally stores the content of a text document as a QVector of text lines. Each text line holds the text in a QString object as well as additional data like color attributes for highlighting. Inserting and removing text lines implies inserting or removing items in the QVector of the text lines. This is can get slow when there are thousands of text lines in a document, because QVector has to move the memory every time. Thus, to keep text operations fast, Kate splits all text lines into several text blocks: Each text block contains a certain amount of lines (e.g. 256). The expense of memory movement is then always limited. When a text block grows too much, it is automatically split. When the amount of lines in a text block shrinks, it is merged with the previous text block. In other words, Kate’s text buffer automatically balances the text blocks. The basic idea of Kate’s text buffer, the text blocks and text lines looks like this:

Text Cursors and Ranges. Text manipulation always takes place at certain positions in a text. Such a position is called a text cursor. Each text cursor is defined by a line and a column. Further, to specify e.g. text selections, we need text ranges. A text range has a start cursor and an end cursor. For instance, if you have two views of the same document, you want the cursor in the 2nd view to keep its correct position in the text if you insert text in the 1st view. Thus, text cursors have to be kind of intelligent. Whenever text changes, each text cursor needs to be moved. As a text range just consists of two text cursors, we will focus only on text cursors for now. The question is how to implement this efficiently? If we store all text cursors in a list in the text buffer, we have to iterate over all text cursors on every editing operation. This obviously does not scale for thousands of text cursors (KDevelop for instance uses thousands of text cursors for the highlighting). The solution is the same as with the text content itself: Let’s just put a list of all text cursors in a text block to the text block itself. During text editing, we only have to adapt all text cursors of a single text block instead of all text cursors in a document. This looks as follows:

Editing Operations. When editing text, you usually have only four different types of text manipulation:

insert text at a text cursor inside one line
remove text at a text cursor inside one line
wrap line at a text cursor (e.g. by hitting )
unwrap line (e.g. by hitting at the beginning of a line)

Those editing primitives are implemented in the Kate::TextBuffer and Kate::TextBlock and take care of balancing the text blocks. For each one the set of text cursors in a text block has to be adapted. Of course, corner cases need to be taken into account: For instance, unwrapping the first line in a text block means that cursors in the first line need to be moved to the previous text block. All editing primitives emit a signal, such that additional layers later can track what happens. For instance, the undo/redo system needs to know all editing operations. Or on top of that we could implement vim like swap file support, i.e., track all changes from the beginning, and if Kate crashes, replay all the editing primitives on the original files.

Transactions. A transaction consists of several of the four editing operations. For instance, if you select text and then move it to another location in the document with drag & drop you want this to be grouped together to a single text operation on undo/redo. (The text operations in this case are unwrap lines and remove text, then insert text and wrap line). To be able to specify which parts of text operations belong together, the text buffer provides two functions: startEditing() starts a transaction and finishEditing() closes it. Those functions use reference counting, so you can call startEditing() multiple times and only the last finishEditing() completes a transaction. Again, signals are emitted e.g. in finishEditing() such that other layers (undo/redo system) are notified about this.

Revisions. As an easy way to check whether a document changed you can get the current revision of the text buffer. The revision is simply an int64 starting with 0 after loading a document. The revision is incremented in every of the 4 editing primitives. This way you don’t have to listen to multiple signals like textInserted() and textRemoved(). This could be useful for e.g. KDevelop’s background parser: Parse a file. When done, check whether the revision is the same. If yes, parsing was successful. If not, parse again. This is how QtCreator does it. Easy and straight forward.

Unit Tests. The text buffer, text block, text line, text cursors are all designed such that unit tests can be written. Hence, each of the above implementation details will be covered by unit tests.

Further ideas. As mentioned previously, the design of the text buffer leaves room for further features. For now, let’s face two ideas:

Vim like swap files: If Kate or the application using Kate Part crashes, the unsaved data in the text document is lost. Vim has a backup mechanism called ‘swap files’ to recover from crashes to avoid data loss since years, and it works as follows: Each of the 4 editing primitives explained above are streamed into a separate file. When you save a file successfully, the swap file is cleared. If a crash happens, vim loads the original text document and then replays all editing operations in the swap file. This way the current unsaved editing state is recovered; no data is lost. Since the text buffer emits all necessary signals, implementing this feature is kind of trivial. Any takers?
Right now, the highlighting works in an extra class, accessing the text buffer’s text lines and setting the text attributes such as the color. As idea, we could also derive a class Kate::HighlightingBuffer from Kate::TextBuffer and do the additional modifications in the derived class instead of an extra class. We’ll have to see whether that makes sense.

Please Contribute.

join #kate on irc://irc.kde.org
checkout the code base, clone it, create branches, and merge back!
other kate internals: undo/redo system (little bit outdated, but all in all still valid)

Design Ideas of the Kate::TextBuffer

Sun, 28 Feb 2010 13:11:16 +0000

Storage

Basic idea: text stored as lines
Lines hold text and additional data (like for highlighting)
Advanced Concept: Stores lines in blocks of xxx lines, to have better performance

Cursor Support

They will move on editing
Cursors can be combined to ranges
KateTextCursor will be stored in the buffer blocks

Transactions

Each edit action must be encapsuled in a transaction
startEdit/endEdit will do this
Signals for starting and ending this transactions

Revisions

After loading, buffer has revision 0
Each edit action which is no nop will lead to increment in revision number
Successful saving will reset revision back to 0

Editing Operations (only 4 different editing primitives)

Insert Text (inside one line)
Remove Text (inside one line)
Wrap Line (wrap a line at given position, create a new line with content behind wrap position)
Unwrap Line (unites the line with its predecessor)
Signals for all of these actions, containing the change (to allow to layer undo/swap file support/…) on top of the buffer

Load/Save & Encodings

Loading will try to use given codec, if that doesn’t work, try to detect the codec by the BOM at start of file or use fallback codec, if that again doesn’t work, given codec will be used again, and errors reported
Saving will just use the given codec

Unit Tests

Each of the above implementation details will be covered by unit tests
KateTextBuffer (+KateTextLine and Cursor) must therefor be usable without other components

Kate Partly Moving to Gitorious

Sat, 27 Feb 2010 16:55:00 +0000

We are about to move the applications Kate and KWrite as well as the libraries KTextEditor and Kate Part to gitorious. Christoph is working on the migration right now in order to keep the development history. Things look good so far, so the migration is soon finished.
We have discussed a bit about the migration to gitorious on the Kate Developer Meeting and Christoph came up with this mainly because building only KTextEditor, Kate Part, KWrite and Kate is much faster and easier compared to building the KDE modules kdesupport, kdelibs, kdepimlibs, kdebase, kdesdk.
I myself remember the time where I started KDE development, and it took more than two weeks to have a first successful build of KDE. You have to learn so many things at once, like revision control, lots of so far unknown software, and what not. Talking to other developers verifies this. In other words: Getting into KDE development is not easy and straight forward.
Moving to gitorious removes this barrier for Kate development: You just checkout the Kate repository and that’s all you need. It would be nice if you join Kate development and contribute patches :)
What does that mean for Kate in KDE? Nothing changes. We will merge the changes in Gitorious back to the main KDE development line and vice versa.

Kate Highlighting for QML, JavaScript

Fri, 26 Feb 2010 14:45:21 +0000

Hey everyone!

I’ve started my internship at KDAB this week, it’s great fun so far! Though I spent most of my time this week on Bertjans KDevelop plugin, I couldn’t resist on a bit of Kate hacking:

steveire is experimenting with QML so I couldn’t stop but notice that there is no highlighting for it in Kate. Well, there was none ;-) Now you get pretty colors, rejoice!

Note: Since QML is basically JSON with some added sugar, I reused the existing JavaScript highlighter and improved it. Hence you get imrpoved JSON and member highlighting in plain.js as well. Enjoy!

Kate Highlighting for QML, JavaScript

Fri, 26 Feb 2010 14:45:21 +0000

Hey everyone!

I’ve started my internship at KDAB this week, it’s great fun so far! Though I spent most of my time this week on Bertjans KDevelop plugin, I couldn’t resist on a bit of Kate hacking:

steveire is experimenting with QML so I couldn’t stop but notice that there is no highlighting for it in Kate. Well, there was none ;-) Now you get pretty colors, rejoice!

Kate/KDevelop HackSprint – Up To Day 4

Wed, 17 Feb 2010 17:43:38 +0000

Woha, quite a few days flew by without me blogging about anything. Thankfully the others started to write so I don’t have to repeat it all ;-) Instead I’ll concentrate on stuff I did or learned.

GHNS for Snippets

Well, first I think an excuse is in oder: There is a GHNS button for Kate Snippets in 4.4.0 but it’s broken, neither me nor Joseph had time to acutally use and fix it… But anyways, I fixed it now for 4.4.1. For 4.5 we’ll also have an Upload Dialog.

I also added both now to KDevelop, you can now upload and download snippets from it. I added a few dump examples but will probably improve it steadily.

Kate Performance

On Saturday and Sunday I started to profile Kate highlighting for a large MySQL dump and managed to greatly improve the speed. Actually the funny thing is that I could improve RegExp based highlighting (you still should try to prevent using it, it will always be slower than simple char/string based highlighting). And the knowledge for this optimization I had from my time as an active contributor for GeSHi. I feel like it was ages ago, he funny :)

So if anybody has a big file that takes ages to load (but only if you use KDE 4.5 trunk or higher), tell me and give me the file. I might find some more ways to optimize different languages.

Other Stuff

Other than that I also managed to fix a few more bugs in Kate and KDevelop and had a good time with the other guys here in Berlin. Yesterday I showed some others how I spent quite a few nights: Partying in Berlin is nice :)

Oh and Bernhard showed me a little gem of his: Kate Standalone which you can use to build only KatePart from kdelibs trunk. This actually works very well (up until some new API from KDE trunk is used).

Kate/KDevelop HackSprint – Up To Day 4

Wed, 17 Feb 2010 17:43:38 +0000

Woha, quite a few days flew by without me blogging about anything. Thankfully the others started to write so I don’t have to repeat it all ;-) Instead I’ll concentrate on stuff I did or learned.

GHNS for Snippets

I also added both now to KDevelop, you can now upload and download snippets from it. I added a few dump examples but will probably improve it steadily.

Kate Performance

So if anybody has a big file that takes ages to load (but only if you use KDE 4.5 trunk or higher), tell me and give me the file. I might find some more ways to optimize different languages.

Other Stuff

The Power of Developer Meetings

Wed, 17 Feb 2010 14:15:00 +0000

Since several years, we have lots of small developer meetings in the KDE project, gratefully supported by the KDE e.V. There, developers of a certain project (e.g. KMail/kdepim, Plasma, you name it) meet to discuss further plans and to push the project further. From experience we can tell that those meetings are really beneficial in several ways:

Social aspect: You get to know the other developers involved in the project in real life, which is a great motivation factor. This also happens at KDE’s annual conference Akademy, although there are a lot more people.
Productivity: Since you are sitting next to each other discussions about how to do what are very focused. It’s amazing how quickly a project can evolve this way. (I haven’t seen such focused work in companies, yet. I guess the variance in the knowledge of people involved is higher. And the motivation is usually very different).
Knowledge Transfer: Since participants are experts in different areas, discussions lead to knowledge transfer. This is essential, as sometimes developers have very few free time to contributes to a project. Spreading the knowledge helps a lot to keep the project alive.
Steady Contributions: We are always open for new contributors. Just send a patch, get commit access and join development. Experience shows that participants of a developer meeting usually contribute for years to come.

Enough said, here is what happened the last three days in Kate:

There are even more changes I left out. Most of those changes will be in KDE 4.4.1. If you want to help, join #kate in irc.kde.org!

Developer Meeting: More on scripting Kate

Wed, 17 Feb 2010 13:57:00 +0000

We are 10 people here at the developer meeting in Berlin. Kate, KDevelop as well as Okteta see a lot of commits. I’ll mainly talk about what’s happening in the holy Kate land, though :-)
Yesterday I closed a bug requesting an “unwrap” feature in Kate that works like “Tools > Join Lines” but maintains paragraph separation, i.e., empty lines are not removed. This feature is implemented now in javascript. Further infos:

To run the script simply switch to the command line (F7) and write “unwrap”. If you have further ideas about useful scripts, don’t hesitate to start hacking right away, see also

how to extend Kate with scripting

Fixes with regard to the scripting support in the last days are

Those fixes will be in KDE 4.4.1. More to come in other blog entries :-)

Kate/KDevelop HackSprint Day 1

Sat, 13 Feb 2010 23:58:53 +0000

So, first day of the Kate/KDevelop hacksprint.

We just talked and hacked at the rented flat,got to know each other and had a fun time. Everybody made it more or less in time, even last minute attendee Adymo from Ukraine, nice! Hacking-wise the productivity wasn’t that high, esp. for me, but a few patches got committed here and there.

Right now I’m working on a little speedup for Kate, esp. for big MySQL files - lets see how it turns out. Cullmann showed me a few things I could do so maybe it works out, lets see.

Over the next week I plan to push in user configurable include paths for the PHP plugin and do some more Snippets & Scripting work in Kate, lets see how it turns out. I’ll go home now, kinda sucks that I don’t stay with the others here at the flat but have to take a 1h ride into the city… Berlin is definitely too big :D

Kate/KDevelop HackSprint Day 1

Sat, 13 Feb 2010 23:58:53 +0000

So, first day of the Kate/KDevelop hacksprint.

Right now I’m working on a little speedup for Kate, esp. for big MySQL files - lets see how it turns out. Cullmann showed me a few things I could do so maybe it works out, lets see.

Snippets In KDevelop / Kate

Wed, 03 Feb 2010 15:59:46 +0000

Hey all!

Just wanted to give you a little rundown on Snippets in Kate 4.4 (via the snippets_tng plugin) and KDevelop Beta 8 (soon to be released).

Note: The Kate plugin was written by Jowenn and introduced me to all these nice features. For KDevelop I wrote a somewhat simpler yet imo better implementation. We will try to get the best of both worlds into KDE 4.5. Stay tuned!

General Usage & Features

create a snippet repository (or download via GHNS [see below])
create snippets in that repository
insert snippets via the snippets view (i.e. double click), or (imo better/faster) insert them via code-completion (remember: CTRL + Space requests code completion at the current cursor position!).
snippet gets inserted (properly indented) and potential placeholders/variables get expanded. A variable is something like %{date} or ${email}. Also take a look at the API documentation.
variables that get inserted via “${…}” will be “selectable”, meaning you can jump from one var to the other by hitting TAB / Shift TAB
the %{…} vars will only get expanded and inserted, without getting selectable.
multiple occurrences of the same variable will be updated once one of them gets edited, something that is called “mirroring” in other editors.
once one edits ESC the cursor is placed at the end of the snippet or to the first occurrence of ${cursor} or %{cursor} and the user types something, the snippet-handler quits and you are left with your normal editor until you insert the next snippet
nested snippets (i.e. insert snippet than insert another one) should “just work”.

Snippet Management

group snippets by file type, i.e. PHP snippets will only be offered during code completion when one edits a PHP file.
Note: In KDevelop and KDE 4.4 nested documents are supported, e.g. create a CSS snippet and it will be shown inside the CSS parts of a HTML document or similar. This uses my HighlightInterface I wrote for KDE 4.4. I still have to rewrite some parts of the snippets_tng plugin for Kate so that it works there as well
group snippets in repositories, set an Author and a License of your choice
publish snippet repositories via GHNS: In Kate you can already download snippets from GHNS but we sadly don’t have any repos up on opendesktop… I’ll have to add some prior to KDE 4.4. Also we didn’t have enough time to implement uploading of Repos from inside Kate in time for KDE 4.4. So stay tuned for KDE 4.5. KDevelop currently has no support for GHNS, but I plan to fix this tomorrow or the next days - together with uploading from inside KDevelop, i.e. all the nice features of GHNS v3.
in KDevelop (and someday in Kate as well) you can simply select a part of your currently opened document and select the “create snippet from selection” in the ContextMenu - easy & fast!

TODO

There’s much to do.

Highest priority right now for me is to get GHNS with all bells and whistles supported for KDevelop.
Then I’ll merge and integrate the Kate & KDevelop plugins as much as possible, so we have a reduce code base.
Also important is to make all shortcuts configurable
Another thing is: How could we improve interoperability even between e.g. editors like TextMate or Gedit? Both have snippets features and their bundles are available in the net. If we can support those we’d save us a lot of work

Also, I should probably do a screencast… Not now though ;-)

Snippets In KDevelop / Kate

Wed, 03 Feb 2010 15:59:46 +0000

Hey all!

Just wanted to give you a little rundown on Snippets in Kate 4.4 (via the snippets_tng plugin) and KDevelop Beta 8 (soon to be released).

General Usage & Features

create a snippet repository (or download via GHNS [see below])
create snippets in that repository
insert snippets via the snippets view (i.e. double click), or (imo better/faster) insert them via code-completion (remember: CTRL + Space requests code completion at the current cursor position!).
snippet gets inserted (properly indented) and potential placeholders/variables get expanded. A variable is something like %{date} or ${email}. Also take a look at the API documentation.
variables that get inserted via “${…}” will be “selectable”, meaning you can jump from one var to the other by hitting TAB / Shift TAB
the %{…} vars will only get expanded and inserted, without getting selectable.
multiple occurrences of the same variable will be updated once one of them gets edited, something that is called “mirroring” in other editors.
once one edits ESC the cursor is placed at the end of the snippet or to the first occurrence of ${cursor} or %{cursor} and the user types something, the snippet-handler quits and you are left with your normal editor until you insert the next snippet
nested snippets (i.e. insert snippet than insert another one) should “just work”.

Snippet Management

group snippets by file type, i.e. PHP snippets will only be offered during code completion when one edits a PHP file.
Note: In KDevelop and KDE 4.4 nested documents are supported, e.g. create a CSS snippet and it will be shown inside the CSS parts of a HTML document or similar. This uses my HighlightInterface I wrote for KDE 4.4. I still have to rewrite some parts of the snippets_tng plugin for Kate so that it works there as well
group snippets in repositories, set an Author and a License of your choice
publish snippet repositories via GHNS: In Kate you can already download snippets from GHNS but we sadly don’t have any repos up on opendesktop… I’ll have to add some prior to KDE 4.4. Also we didn’t have enough time to implement uploading of Repos from inside Kate in time for KDE 4.4. So stay tuned for KDE 4.5. KDevelop currently has no support for GHNS, but I plan to fix this tomorrow or the next days - together with uploading from inside KDevelop, i.e. all the nice features of GHNS v3.
in KDevelop (and someday in Kate as well) you can simply select a part of your currently opened document and select the “create snippet from selection” in the ContextMenu - easy & fast!

TODO

There’s much to do.

Highest priority right now for me is to get GHNS with all bells and whistles supported for KDevelop.
Then I’ll merge and integrate the Kate & KDevelop plugins as much as possible, so we have a reduce code base.
Also important is to make all shortcuts configurable
Another thing is: How could we improve interoperability even between e.g. editors like TextMate or Gedit? Both have snippets features and their bundles are available in the net. If we can support those we’d save us a lot of work

Also, I should probably do a screencast… Not now though ;-)

Kate polishing

Thu, 21 Jan 2010 00:09:47 +0000

Phew, I just finished some last-minute backports to the KDE 4.3.5 branch. Lets hope the bug fixes I and pletourn did are as good as they look. Expect a much more stable Kate for 4.3.5 & 4.4! We managed to fix two bugs which are potentially the cause for dozens of bug reports, all seemingly random. Lets see whether our fixes hold up to our hopes!

Other than that: You should look forward to Kate scripting (with JavaScript) in 4.4. It’s dead simple but actually useful. In the utils.js file we ship with Kate there are now the following tools (all operate on the selection or - if none exists - on the whole document):

sort - simple sorting
natsort - natural sorting
uniq - filter duplicates
trim - remove leading & trailing whitespace
ltrim - remove leading whitespace
rtrim - remove trailing whitespace

Do you have more ideas for such simple helper functions?

Kate polishing

Thu, 21 Jan 2010 00:09:47 +0000

sort - simple sorting
natsort - natural sorting
uniq - filter duplicates
trim - remove leading & trailing whitespace
ltrim - remove leading whitespace
rtrim - remove trailing whitespace

Do you have more ideas for such simple helper functions?

Kate XML Completion Plugin: Help Wanted

Sun, 17 Jan 2010 12:58:00 +0000

In KDE3 Kate had a plugin called “XML Completion Plugin”. It was able to list XML elements, attributes and attribute values and entities in a completion popup menu depending on the currently active DTD. For instance, it was able to complete all your KDE/docbook tags and, thus, was one of the best tools for writing KDE documentation.

Unfortunately, this plugin has not been ported to KDE4, yet. So this is a request for developers: Please someone pick it up and make it available for Kate in KDE4.

The location in svn is: trunk/KDE/kdesdk/kate/plugins/xmltools
Just enable this folder in the kate/plugins/CMakeLists.txt file and start porting it. The code completion interface changed quite a lot, but there are other plugins and good api documentation (KTextEditor interfaces, Kate Application interfaces) where you can have a look at how things work.

Having a working XML Completion plugin for KDE4.5 would be awesome.

Kate Love: HighlightInterface, Autobrace

Sun, 22 Nov 2009 18:15:34 +0000

Well, I have to admit: I didn’t spent much time developing the PHP plugin for KDevelop these past weeks. Instead I hacked on Kate:

HighlightInterface

I added another Kate interface, this time to access some of the highlighting information:

what’s the Attribute for a given default style right now? Default styles are those known from syntax files, e.g. dsKeyword, dsFunction,…
what are used Attributes in a given line and what range do they occupy?
what modes do we embed? E.g. PHP embeds HTML, JavaScript, CSS, …
what mode is used at a given Cursor position?

This made it possible to port the “Export to HTML” action to a real plugin. If you come up with other output formats I might add them, I wondered about LaTeX support… might do this at some point.

This should also make it possible to use KatePart in other applications and than export the highlighting to a different format, e.g. a Flake shape for Koffice. Afaik this is actually planned by The_User - lets see if it works out!

The other stuff gives huge potential in various places, but I fear it won’t make it in KDE 4.4. But think of it:

simple code completion based on keyword databases, dependent on the mode at the position where completion was requested
same as above for snippets (actually this will make it to 4.4).
insert your ideas here :)

Auto-Brace plugin

Jakob Petsovits created this gem of a plugin some time ago, yet it lived in playground was probably only used by few. I imported it to kdelibs, hence it will be shipped with KDE 4.4. It supersedes the limited “auto-brackets” feature of Kate and only adds braces when a newline gets added. I find this fits my personal coding habits much better than blindly copying brackets when they get added.

And I don’t just copied to kdelibs, I also added a few features:

automatically add a semicolon after the closing brace when we start a new struct/class in C++ mode
check for auto-brackets feature and disable it automatically

Also did this:

don’t add brace when current line contains namespace and a following line starts with class or struct (C++ mode only)
don’t add brace when current line contains class, interface or struct and the following line contains private, public, protected. C++ code is also checked for signals, Q_SIGNALS”, other modes are checked forfunction`.

This should fix the bug for code like (note the indendation levels):




namespace foo { // insert line here




class bar;




}




class asdf { // insert line here




private:




...




};

Kate Love: HighlightInterface, Autobrace

Sun, 22 Nov 2009 18:15:34 +0000

Well, I have to admit: I didn’t spent much time developing the PHP plugin for KDevelop these past weeks. Instead I hacked on Kate:

HighlightInterface

I added another Kate interface, this time to access some of the highlighting information:

what’s the Attribute for a given default style right now? Default styles are those known from syntax files, e.g. dsKeyword, dsFunction,…
what are used Attributes in a given line and what range do they occupy?
what modes do we embed? E.g. PHP embeds HTML, JavaScript, CSS, …
what mode is used at a given Cursor position?

The other stuff gives huge potential in various places, but I fear it won’t make it in KDE 4.4. But think of it:

simple code completion based on keyword databases, dependent on the mode at the position where completion was requested
same as above for snippets (actually this will make it to 4.4).
insert your ideas here :)

Auto-Brace plugin

And I don’t just copied to kdelibs, I also added a few features:

automatically add a semicolon after the closing brace when we start a new struct/class in C++ mode
check for auto-brackets feature and disable it automatically

Also did this:

don’t add brace when current line contains namespace and a following line starts with class or struct (C++ mode only)
don’t add brace when current line contains class, interface or struct and the following line contains private, public, protected. C++ code is also checked for signals, Q_SIGNALS”, other modes are checked forfunction`.

This should fix the bug for code like (note the indendation levels):




namespace foo { // insert line here




class bar;




}




class asdf { // insert line here




private:




...




};

KDevelop & KWrite/Kate hacksprint 2010 in Berlin

Mon, 16 Nov 2009 15:38:01 +0000

Hey everybody!

If you are a KDevelop and/or Kate/Kwrite developer and do not read the mailing lists: There’s a hack sprint coming up in Berlin in 2010. I think there’ve been enough sprints in Berlin already so that you know it’s a great city for such an event. Though this time it won’t be at KDAB or Nokia offices, but at the Physics Faculty of the FU-Berlin. Since I (currently) work there as an IT admin, it was my first choice and worked out. I hope it will be a good location for the meeting. If you want to attend, vote on doodle:

http://www.doodle.com/vkyh9up9794zr4s8

But you probably also should register either on the KDevelop or KWrite mailing lists so I have some kind of way to contact you.

PS: in unrelated news I’ll do an internship at KDAB next year! yay

Scripting Kate

Sun, 01 Nov 2009 15:04:00 +0000

In my last blog I explained Kate’s scripting features in KDE 4.4. To better understand how scripting can be used let’s look at some use cases.

join lines: This feature request wants the action “join lines” to not join different paragraphs, i.e. not remove empty lines. We have not implemented this wish, as there are probably users who prefer the current behaviour. This request can be fixed by writing a small script that joins the lines according to the user’s wishes.
reformat paragraph: An intelligent reformatter for paragraphs. Should be rather straight forward to implement.
XML tools: In KDE3, Kate once had a xmltools plugin. Unfortunately noone ported it to KDE4. The plugin provided lots of very useful features for xml editing. For example, you could select text and then wrap it with xml elements, e.g. “text” would become “text”. This is a perfect example for a command line script as well. Any volunteers? :)

Scripting also brings us closer to fixing the following reports:

macro system: Kate still does not have a macro system. A macro can be interpreted as a group of scripts, executed in a sequence (more or less). The vi input mode already supports pretty complex commands, and the code for scripting is all there. It’s just a matter of putting this together so it’s usable for users.
word count: maybe the word count features can be implemented by a script (too slow?). Problem is, that a script cannot show dialogs etc.

To make scripting an even better experience, we still need to implement binding shortcuts to scripts. Again: any volunteers? :)

Extending Kate with Scripts

Thu, 29 Oct 2009 18:41:00 +0000

As mentioned in one of my last blogs, there has been quite some work for JavaScript scripting support in trunk recently. So what will Kate 3.4 (KDE 4.4) will bring? This is explained in detail in the sections:

Indentation Scripting
Command Line Scripting
Some Remarks

The scripting allows to extend Kate with lots of little helper functions. All users can add scripts as they wish. The documentation here is copied from the official Kate handbook. So instead of using this blog as reference, please use the handbook later for an up-to-date version. To script something useful, you’ll need to know the scripting API. All the available functions are documented in the section Scripting API in the handbook as well. Enough said, here we go:

Extending Kate with Scripts

Since Kate 3.4 in KDE 4.4 the Kate editor component is easily extensible by writing scripts. The scripting language is ECMAScript (widely known as JavaScript). Kate supports two kinds of scripts: indentation and command line scripts.

Indentation Scripts

Indentation scripts – also referred as indenters – automatically indent the source code while typing text. As example, after hitting the return-key code the indentation level often increases.

The following sections describe step by step how to create the skeleton for a simple indenter. As first step, create a new *.js file called e.g. javascript.js in the local home folder $KDEHOME/share/apps/katepart/script.

The Indentation Script Header

<p>
The header of the file <code class="filename">javascript.js</code> is embedded in a comment and is of the following form
</p>
<pre>/* kate-script

name: JavaScript
author: Example Name
license: BSD
revision: 1
kate-version: 3.4
type: indentation
required-syntax-style: javascript
indent-languages: javascript
priority: 0 *
A line without colon ‘:’ stops header parsing. That is, you can add optional
text here such as a detailed license. */

Each entry is explained in detail now:
- kate-script [required]: This text string has to appear in the first line of the *.js file, otherwise Kate skips the script.
- name [required]: This is the indenter name that appears in the menu Tools->Indentation and in the configuration dialog.
- author [optional]: The author’s name and contact information.
- license [optional]: Short form of the license, such as BSD or LGPLv3.
- revision [required]: The revision of the script. This number should be increased whenever the script is modified.
- kate-version [required]: Minimal required Kate version.
- type [required]: The type must be “indentation”, otherwise Kate skips this script.
- required-syntax-style [optional]: Comma separated list of required syntax highlighting styles. This is important for indenters that rely on specific highlight information in the document. If a required syntax style is specified, the indenter is available only when the appropriate highlighter is active. This prevents “undefined behavior” caused by using the indenter without the expected highlighting schema. For instance, the Ruby indenter makes use of this in the files ruby.js and ruby.xml.
- indent-languages [optional]: Comma separated list of syntax styles the indenter can indent correctly, e.g.: c++, java.
- priority [optional]: If several indenters are suited for a certain highlighted file, the priority decides which indenter is chosen as default indenter.
Kate reads all pairs of the form “key:value” until it cannot fine a colon anymore. This implies that the header can contain arbitrary text such as a license as shown in the example.

The Indenter Source Code

<p>
Having specified the header this section explains how the indentation scripting itself works. The basic skeleton of the body looks like this:
</p>
<pre>triggerCharacters = "{}/:;";

function indent(line, indentWidth, ch) { // called for each newline (ch == ‘\n’) and all characters specified in // the global variable triggerCharacters. When calling Tools -> Align // the variable ch is empty, i.e. ch == “. // // see also: Scripting API return -2; }

<p>
The function <code class="function">indent()</code> has three parameters:
</p>
<div class="itemizedlist">
<ul type="disc">
<li>
<code class="literal">line</code>: the line that has to be indented
</li>
<li>
<code class="literal">indentWidth</code>: the indentation width in amount of spaces
</li>
<li>
<code class="literal">ch</code>: either a newline character (<code class="literal">ch == '\n'</code>), the trigger character specified in <code class="literal">triggerCharacters</code> or empty if the user invoked the action <span class="guiitem"><span class="guimenu">Tools</span></span>-><span class="guiitem"><span class="guimenuitem">Align</span></span>.
</li>
</ul>
</div>
<p>
The return value of the <code class="function">indent()</code> function specifies how the line will be indented. If the return value is a simple integer number, it is interpreted as follows:
</p>
<div class="itemizedlist">
<ul type="disc">
<li>
return value <code class="literal">-2</code>: do nothing
</li>
<li>
return value <code class="literal">-1</code>: keep indentation (searches for previous non-blank line)
</li>
<li>
return value <code class="literal"> 0</code>: numbers >= 0 specify the indentation depth in spaces
</li>
</ul>
</div>
<p>
Alternatively, an array of two elements can be returned:
</p>
<div class="itemizedlist">
<ul type="disc">
<li>
<code class="literal">return [ indent, align ];</code>
</li>
</ul>
</div>
<p>
In this case, the first element is the indentation depth like above with the same meaning of the special values. However, the second element is an absolute value representing a column for “<span class="quote">alignment</span>”. If this value is higher than the indent value, the difference represents a number of spaces to be added after the indentation of the first parameter. Otherwise, the second number is ignored. Using tabs and spaces for indentation is often referred to as “<span class="quote">mixed mode</span>”.
</p>
<p>
Consider the following example: Assume using tabs to indent, and tab width is set to 4. Here, <tab> represents a tab and &#8216;.&#8217; a space:
</p>
<pre>1: &lt;tab&gt;&lt;tab&gt;foobar("hello",

2: <tab><tab>…….“world”);

<p>
When indenting line 2, the <code class="function">indent()</code> function returns [8, 15]. As result, two tabs are inserted to indent to column 8, and 7 spaces are added to align the second parameter under the first, so that it stays aligned if the file is viewed with a different tab width.
</p>
<p>
A default KDE installation ships <span class="application">Kate</span> with several indenters. The corresponding JavaScript source code can be found in <code class="filename">$KDRDIR/share/apps/katepart/script</code>.
</p>
<p>
Developing an indenter requires to reload the scripts to see whether the changes behave appropriately. Instead of restarting the application, simply switch to the command line and invoke the command <span class="command"><strong class="command">reload-scripts</strong></span>.
</p>
<p>
If you develop useful scripts please consider contributing to the <span class="application">Kate</span> Project by <a href="mailto:kwrite-devel@kde.org" target="_top">contacting the mailing list</a>.
</p>

Command Line Scripts

As it is hard to satisfy everyone’s needs, Kate supports little helper tools for quick text manipulation through the built-in command line. For instance, the command sort is implemented as script. This section explains how to create *.js files to extend Kate with arbitrary helper scripts.

Command line scripts are located in the save folder as indentation scripts. So as first step, create a new *.js file called myutils.js in the local home folder $KDEHOME/share/apps/katepart/script.

The Command Line Script Header

<p>
The header of each command line script is embedded in a comment and is of the following form
</p>
<pre>/* kate-script

author: Example Name
license: BSD
revision: 1
kate-version: 3.4
type: commands
functions: sort, format-paragraph *
A line without colon ‘:’ stops header parsing. That is, you can add optional
text here such as a detailed license. */

Each entry is explained in detail now:
- kate-script [required]: This text string has to appear in the first line of the *.js file, otherwise Kate skips the script.
- author [optional]: The author’s name and contact information.
- license [optional]: Short form of the license, such as BSD or LGPLv3.
- revision [required]: The revision of the script. This number should be increased whenever the script is modified.
- kate-version [required]: Minimal required Kate version.
- type [required]: The type must be ‘commands’, otherwise Kate skips this script.
- functions [required]: Comma separated list of commands in the script.
Kate reads all pairs of the form “key:value” until it cannot fine a colon anymore. This implies that the header can contain arbitrary text such as a license as shown in the example. The value of the key functions is a comma separated list of command line commands. This means a single script contains an arbitrary amount of command line commands. Each function is available through Kate‘s built-in command line.

The Script Source Code

<p>
All functions specified in the header have to be implemented in the script. For instance, the script file from the example above needs to implement the two functions <span class="command"><strong class="command">sort</strong></span> and <span class="command"><strong class="command">format-paragraph</strong></span>. All functions have the following syntax:
</p>
<pre class="programlisting">function (arg1, arg2, ...) {

// … implementation, see also: Scripting API }

<p>
Arguments in the command line are passed to the function as <span class="parameter"><em class="parameter"><code>arg1</code></em></span>, <span class="parameter"><em class="parameter"><code>arg2</code></em></span>, etc. In order to provide documentation for each command, simply implement the &#8216;<code class="function">help</code>&#8216; function as follows:
</p>
<pre class="programlisting">function help(cmd)

{ if (cmd == “sort”) { return “Sort the selected text.”; } else if (cmd == “…”) { // … } }

<p>
Executing <span class="command"><strong class="command">help sort</strong></span> in the command line then calls this help function with the argument <span class="parameter"><em class="parameter"><code>cmd</code></em></span> set to the given command, i.e. <span class="parameter"><em class="parameter"><code>cmd == "sort"</code></em></span>. <span class="application">Kate</span> then presents the returned text as documentation to the user.
</p>
<p>
Developing a command line script requires to reload the scripts to see whether the changes behave appropriately. Instead of restarting the application, simply switch to the command line and invoke the command <span class="command"><strong class="command">reload-scripts</strong></span>.
</p>
<p>
If you develop useful scripts please consider contributing to the <span class="application">Kate</span> Project by <a href="mailto:kwrite-devel@kde.org" target="_top">contacting the mailing list</a>.
</p>
<h2 class="title" style="clear: both;">
Final Remarks
</h2>
<p>
The command line scripting can be accessed for all KTextEditor users through the <a href="http://api.kde.org/4.x-api/kdelibs-apidocs/interfaces/ktexteditor/html/classKTextEditor_1_1CommandInterface.html">KTextEditor::CommandInterface</a>. That is, you can query a specific command and <a href="http://api.kde.org/4.x-api/kdelibs-apidocs/interfaces/ktexteditor/html/classKTextEditor_1_1Command.html#afcf59107ca87d860fc7a17e507df02d2">execute it</a> with arbitrary parameters (The parameter cmd contains the command itself including all arguments. Example: cmd = &#8220;goto 65&#8221;).
</p>
<p>
Kate&#8217;s command line itself is actually a quite powerful tool. It&#8217;s a little bit sad that it&#8217;s rather unknown. If you want to know more, just invoke &#8220;View -> Swith to command line&#8221; (shortcut: F7) and start typing text. More details are in the <a title="Kate Command Line" href="http://docs.kde.org/stable/en/kde-baseapps/kate/advanced-editing-tools-commandline.html" target="_blank" rel="noopener">Kate handbook</a> as well.
</p>
<p>
The Kate scripting API can be found <a title="Kate Scripting API" href="http://docs.kde.org/stable/en/kde-baseapps/kate/advanced-editing-tools-scripting.html#advanced-editing-tools-scripting-api" target="_blank" rel="noopener">here</a>.
</p>

first experience with Archlinux

Sun, 18 Oct 2009 00:24:14 +0000

So, I kinda messed up my desktop right after the upgrade to karmic, because I was too greedy for performance and converted my root file system to ext4. Well, that worked like a charm on my laptop, but it broke my desktop. This is in no way karmic’s fault, it’s my own misbehavior. Thankfully I could rescue most of my data.

Since I’d had to reinstall anyways, I decided to finally try out Archlinux. I find the rolling release mantra very intriguing. Together with a “simpler” packaging, namely no splitting between -dev and -dbg packages like debian/ubuntu does, this is destined to be a good environment for a developer. I always hated it to track down missing -dev packages when compiling software. And don’t get me started on outdated software in repos… I just compiled kdelibs and the only missing build dependency was hspell, that I don’t need anyways. Under Jaunty I had to compile stuff from kdesupport to fulfill updated dependencies. And the list of not-found optional dependencies was huge, since I did not spent time to install all those -dev packages by hand…

My first impression of Archlinux is very good so far. I also finally migrated to 64bit wich works like a charm, no issues with flash or anything. Since I never used a 64bit Ubuntu/Debian I’m not sure, whether the perceived performance increase is due to the switch to 64bit or whether Archlinux optimized packages are responsible. Probably both. Nevertheless I can safely say that my system feels snappier than before.

Of course, the installation and initial setup is not as straight forward / easy as with Debian/Ubuntu: Yet it’s no big deal for anyone with some Linux experience. And, once everything is setup, you are running KDE again, so no real difference. Thanks to the Chakra team for kdemod, it works like a charm!

I might have spent a bit more time during the installation / initial configuration, but I think this would have happened also if I’d installed any other distro I’ve never used before, like OpenSuse or Fedora.

Oh and since I can install sudo I can keep my old habits. Neat.

The only thing I miss so far is aptitude with it’s straight forward command structure. Yaourt/Pacman is fast and nice, esp. with pacman-color, but the commands don’t feel as straight forward to me… Personal preference I’d say.

To conclude: Archlinux is very nice, I can wholeheartedly recommend using it so far. Probably nothing for a novice Linux user, yet perfect for advanced users. Very good as a development environment. Fast. Up to date. I like it :)

Now I can finally continue hacking on Kate/Kdelibs again :) I’m currently in the process of refactoring Kate’s implementation of the TemplateInterface. Even in it’s current state it already implements features like mirrored snippets and the like. But once I’ve finished with the cleanup I will try to implement some more of the features that are found in e.g. yasnippet for Emacs. I really wonder why nobody else did that already…

Once this is finished, you can expect that I will deeply integrate that feature in various places in KDevelop, especially for code completion, snippet plugin etc. pp. Stay tuned!

News from the Holy Kate Land

Thu, 17 Sep 2009 22:36:00 +0000

Since we now all know that Kate is holy (thanks to rms. By accident, he obviously confused Kate with emacs, though) let’s have a look at what’s going on. In the last months Kate development is quite active, so here is a quick update:

new: on-the-fly spell checking thanks to Michel Ludwig. Highlights include e.g. spell checking in comments of source code or latex parts. Also, constructs like sch”on work in latex.
extended scripting support in the command line, more on that later
more and more mature vi input mode
lots of bug fixing. quite impressive bug squashing by Pascal Létourneau for more than 4 months now
lots of refactoring and code cleanups thanks to Bernhard!
“Find in Files” appears by default again in the tool view,
“File Browser” uses UrlNavigator, huge code cleanup
convenience updates of syntax highlighting
delayed highlighting of code folding ranges to prevent flickering on mouse move
new command line commands: ‘toggle-header’ in the Open Header plugin. ‘grep’ and ‘find-in-files’
haskell and lilypond indenter
much, much more, see commits for details.

Thanks to all contributors involved in Kate development. Keep it up :)

Improved PHP support in Kate

Wed, 26 Aug 2009 14:20:49 +0000

Not only KDevelop gets better and better PHP support — the Kate PHP syntax file also got a few new features and fixes over the last weeks. The good thing is of course that all users of KWrite, Kate, Quanta, KDevelop and other editors leveraging the Katepart benefit from these changes.

Improved HereDocs

screenshot of improved highlighting in PHP heredocs

I went over PHP related bugs on bugs.kde.org today and spotted one that was fairly easy to fix:

vim-like syntax highlighting support for heredocs in php.xml

With some magic (IncludeRules just rocks) I got it working fairly easy. You can see the results to the right.

Additionally I added code folding to heredocs, since often these strings include lots of text and hiding it often makes sense.

Better support for overlapping syntax regions

code folding with overlapping syntax regions

Another long standing bug (”accommodate overlapping syntax regions (especially for php)”) got fixed by James Sleeman.

Finally PHP templates with code such as




<?php if ( true ) : ?>




<!-- some html stuff -->




<?php elseif ( false ) { ?>




<!-- some other html stuff -->




<?php } ?>

can be folded properly. This kind of spaghetti code is used quite often in simple templates and having the posibility to fold it properly is a huge win in my opinion. Thanks to James Sleeman again!

Followup on Kate’s on-the-fly spellchecking

Wed, 08 Jul 2009 10:09:00 +0000

As there was a lot of feedback in the last blog, I’ll answer some of the questions here.

Where can I get this patch?
The relevant subversion revisions are r992778, r992779, r992780, r992784.

Will it be available in 4.3, or only in 4.4?
As KDE 4.3 will be released end of the month, this feature will be available in KDE 4.4 and not earlier.

Please, please tell me that it’s powered by Sonnet, one of the most awaited KDE4 pillar by me…
Yes, it uses Sonnet :)
The old spellcheck dialog however still uses the old spellchecking code without Sonnet. Any volunteers to port this? Also, the on-the-fly spellchecking needs to be more configurable in Kate’s config dialog, e.g. selecting the correct language.

Thanks so much, this was the feature I was mostly longing for in kate.
Yes, it is one of the oldest reports with 1245 votes!

What languages are supported support?
On-the-fly spellchecking works if the specific itemDatas are marked with spellChecking=”true” or “1” in the xml highlighting definition files. UPDATE: On-the-fly spellchecking is enabled for all itemDatas by default in the xml highlighting defintion files. To disable it, you have to add spellChecking=”false” or “0” to an itemData, e.g. at the end of the cpp.xml file:

<itemDatas>
<itemData name="Normal Text" spellChecking="0" />
...
<itemData name="String" />
<itemData name="String Char" spellChecking="0" />
<itemData name="Comment" />
<itemData name="Symbol" spellChecking="0" />
...
</itemData>

So we have to go through all .xml files and change the relevant parts in the itemDatas section. And that’s where we need your help, as we don’t know all the languages :) …and if you want to test this feature, you first have to enable it in Tools > On-the-fly spellchecking.
PS: Is there a better name? Maybe Inline spellchecking? Any linguistic experts around? :)

On-the-fly spellchecking in Kate

Tue, 07 Jul 2009 18:51:00 +0000

Christoph just added an awesome and long awaited feature: on-the-fly spellchecking. ‘Kate’s xml highlighting files now have an additional attribute in the itemData section: spellChecking=”true/false”. C++ comments and strings can be spellchecked now :) Same for all other languages such as Latex. Really big thanks to Michel Ludwig for the patch, good work! Screenshot for latex highlighting:

Kate Test Regression Suite

Sun, 07 Jun 2009 11:55:00 +0000

This blog is mainly about documenting the process how to run Kate Part’s test regression suite and probably not much use for other developers.

Step I: Setup the environment

create the file ~/.testkateregression. The content of this file is a single line pointing to the folder of the checkout of the test regression suite data. For me this is
/home/dh/kde/tests/katetests/regression/
Create the folder where you checkout the suite
mkdir /home/dh/kde/tests
Change to this folder
Checkout the data:
svn co svn://anonsvn.kde.org/home/kde/trunk/tests/katetests

Now all the data is there for testing.

Step II: Run the test suite

go to your build directory of kate (e.g. kdelibs/build/kate/tests/
run the complete suite:
./testkateregression.shell
run specific tests, e.g. for the c indenter:
./testkateregression.shell -t indent/csmart

That’s it.

Kate linter plugin

Thu, 15 Jan 2009 17:58:24 +0000

Just a quicky: I wrote a little plugin for KTextEditor which supplies you with basic error checking when you save documents. Currently only PHP (via php -l) and JavaScript (via JavaScript Lint) are supported.

Screenshots

Requirements

usual tools for compiling C++, e.g. gcc.
cmake
Qt development packages, i.e. under Ubuntu: sudo aptitude install libqt4-dev
KDE 4.2 with development packages for kdelibs and kdebase, i.e. under Ubuntu: sudo aptitude install kdebase-dev kdebase-workspace-dev kdelibs5-dev. Note: You’ll need the experimental KDE 4.2 packages activated as of now, see for example the Kubuntu news on KDE 4.2 RC1 for hints.
proper setup of environment variables, read this techbase article for more information. the .bashrc linked there should be enough for most people
For PHP support: a PHP executable which supports the -l switch for linting
For JavaScript support: a JavaScript Lint executable, you could download and compile the sources for example.

Installing

Get the sources for the linter plugin from KDE SVN and compile it, using e.g. the functions supplied via the .bashrc mentioned above:




# go to your development folder




cs




# checkout sources




svn co svn://anonsvn.kde.org/home/kde/trunk/playground/devtools/kte_linter




cd kte_linter




# build base linter plugin




cd linter




cmakekde




# build php linter plugin




cd ../phplinter




cmakekde




# build javascript linter plugin




cd ../jslinter




cmakekde




# update sycoca




kbuildsycoca4




# start editor and select the plugins - happy coding!




kwrite

Todo

Support for more languages

If you know good linters drop me a note. But it would be even better if you could write your own linter plugin. It’s pretty easy, take a look at one of the existing plugins for a skeleton & documentation.
Right now each plugin returns a hardcoded list of highlighting-modes which it supports for linting. This should be made configurable so that custom highlighting modes are supported
make error messages more pretty

Happy coding!

System Load Viewer

Fri, 02 Jan 2009 17:28:00 +0000

Last year I’ve blogged about the missing system monitor with the three bars for the panel and about its port to Plasma. Meanwhile other developers also did a port called System Status. In a collaboration with them we finally have the applet back in KDE’s subversion, the name is now “System Load Viewer” and it uses the data engine “systemmonitor” that already exists in KDE 4.2.
So if you want to have the plasmoid for your KDE4.2 desktop, it should be straightforward to compile/install.
On the screenshot you can see the plasmoid in action. There are two instances, one on the panel and one on the desktop. The one on the left is the KDE3 one.

It’s worth to mention that the plasmoid already supports more featues than the KDE3 version. Features include:

show all cpus (for computers with multicores)
tooltip updates continuously
nicer visualization (maybe needs some more tweaks)

As soon as the KDE 4.2 freeze is over we’ll have to see where we can put the plasmoid to make sure it’s available for KDE 4.3 :)

Kate Internals: The Undo/Redo System

Fri, 14 Nov 2008 16:10:00 +0000

The Kate Editor Component (also called KatePart) has its own undo/redo system. It did not change much since KDE2 and basically it is very simple. Meanwhile there are classes for undo/redo support in Qt as well. In fact both systems are very similar. This article focuses on Kate Part’s system.

Text Operations

First we have to take a look at what actions need to be saved. In Kate Part this basically comes down to

insert text or line
remove text or line
selection changes
(and a few others like wrapping a line)

When typing text, each keystroke inserts a character. This is exactly one undo/redo item. As example, typing a character ‘x’ creates a new undo item:

the content is ‘x’
the type is ‘insert text‘

Undo in this case means ‘remove x‘. Redo means ‘insert x (again)‘. Hence, the undo/redo history is just a list (more like a stack to be precise) of simple edit actions.

KateUndo Items

In KatePart, each edit primitive in the undo history is based on the class KateUndo:

class KateUndo {
public:
KateUndo(KateDocument* document);
virtual ~KateUndo();
enum UndoType {
editInsertText,
editRemoveText,
editWrapLine,
editUnWrapLine,
editInsertLine,
editRemoveLine,
editMarkLineAutoWrapped,
editInvalid
};
virtual bool mergeWith(const KateUndo* undo);
virtual void undo() = 0;
virtual void redo() = 0;
virtual KateUndo::UndoType type() const = 0;
};

For each of the edit primitives above exists a subclass of KateUndo, for instance the class for inserting text looks like this:

class KateEditInsertTextUndo : public KateUndo
{
public:
KateEditInsertTextUndo (KateDocument *document,
int line, int col, const QString &text);
virtual void undo();
virtual void redo();
bool mergeWith (const KateUndo *undo);
KateUndo::UndoType type() const { return KateUndo::editInsertText; }
private:
const int m_line;
const int m_col;
QString m_text;
};

Item Merging

Note the function KateUndo::mergeWith(const KateUndo* undo); This functions merges two undo items of the same type if possible. For instance, typing ‘hello world’ inserts one undo item for every character, i.e. 11 undo items of type ‘insert text’. Kate merges those 11 items into only 1 item with the string ‘hello world’. Merging leads to less KateUndo items (less memory) and faster undo/redo replaying.

Item Grouping

What’s still missing is the possibility to group several undo items together. Imagine you have selected the text ‘hello world’ and paste the text ‘cheers’ from the clipboard. What happens is this

remove selected text
insert text from clipboard

So there are two undo items of different type. They cannot be merged into only one KateUndo item. Though, we want to support undoing both items in one go, that’s why we add several undo items into undo groups. In KatePart, this is done by the class KateUndoGroup:

class KateUndoGroup {
public:
explicit KateUndoGroup (KateUndoManager *manager,
const KTextEditor::Cursor &cursorPosition,
const KTextEditor::Range &selectionRange);
void undo(KTextEditor::View *view);
void redo(KTextEditor::View *view);
enum UndoType { ... };
void addItem (KateUndoGroup::UndoType type, uint line,
uint col, uint len, const QString &text);
void setUndoSelection (const KTextEditor::Range &selection);
void setRedoSelection (const KTextEditor::Range &selection);
void setUndoCursor(const KTextEditor::Cursor &cursor);
void setRedoCursor(const KTextEditor::Cursor &cursor);
bool merge(KateUndoGroup* newGroup,bool complex);
void safePoint (bool safePoint=true);
};

Every KateUndo item belongs to one KateUndoGroup. A KateUndoGroup can have an arbitrary count of KateUndo items. In the example above we want to group ‘remove selected text‘ and ‘insert text‘ together. Grouping can be explicitely done in the code as follows (simplified version):

void KateDocument::paste( KateView* view, QClipboard::Mode mode )
{
QString s = QApplication::clipboard()->text(mode);
editStart();
view->removeSelectedText();
insertText(pos, s, view->blockSelectionMode());
editEnd();
}

Grouping: editStart()/editEnd()

The call of editStart() tells the document that an edit operation is running. All text operations are added to the current KateUndoGroup, until editEnd() is called. editStart() and editEnd() do reference counting, i.e. editStart() can be called nested as long as for each call of editStart() there is (finally) a call of editEnd().

Grouping: Cursors and Selections

Undoing the paste-action above should restore the selection if there was one previously. Redo (i.e. paste again) should remove the selection again. So there are two different types of selections: one before the undo group, and one after. That’s why each undo group has the functions setUndoSelection() and setRedoSelection(). The same applies for the cursor position: We have to store two different cursor positions, one for undo and one for redo.
For instance, imagine we removed the text ‘world’. Undo (i.e. insert ‘hello‘) should set the cursor position to the end of ‘hello’. Redo (i.e. remove ‘hello‘) should set the cursor position to the start of it.

Luckily a programmer does not have to set the undo/redo cursor positions and text selections manually. undoStart() is called the first time editStart() is called. The closing editEnd() finally calls undoEnd(). So undoStart() sets the undo cursor position and undo text selection, while undoEnd() sets the redo cursor position and redo text selection.

Group Merging

The careful reader might have noticed KateUndoGroup::merge(). So merging of two groups is also supported. Whether text operations should be merged into an existing undo group can be controlled with KateDocument::setUndoDontMerge(). Pasting text for example set’s this flag.

Undo and Redo

Every document in KatePart has two lists: An undo list, and a redo list. Suppose we have 10 KateUndoGroups in the undo list and the user invokes undo 4 times. Then the undo list only contains 6 items and the redo list 4. Now it is also possible to redo. However, typing text clears the redo list.

Document Modified Flag

KateDocument::updateModifed() is called to update the modified flag of a file. This update also relies on the current active undo group. Saving the file saves a pointer to the current undo group, and later we simply can check whether the current undo group is the active one. Pretty simple mechanism.

Akademy 08: Kate Flashback

Thu, 14 Aug 2008 21:28:00 +0000

This Akademy’s Kate changes include

fix: drag & drop of text
code completion: only show group header if the group name is not empty
reintroduction of buffer blocks in Kate’s document buffer (one buffer contains up to 4096 lines). The blocks build a linked list. Editing a 500 MB file kind of works now again. It’s still rather slow, though.
more speedup in Kate’s document buffer
Kate is using KEncodingProber instead of KEncodingDetector now
generate internal version of KatePart automatically, so developers don’t have to adapt it manually each release
python encoding detection plugin that warns if encoding is not correct while saving
new plugin: Backtrace browser, mainly for developers
find in files: several speed optimizations
find in files: progress indicator while search is active
find in files: redesign of workflow. Search happens with non-modal dialog and results are shown in toolviews.
lots of vi mode changes
lots of bugs closed, mainly old ones
some real bug fixes…
things I forgot

Kate: Fast backtrace navigation

Tue, 12 Aug 2008 15:13:00 +0000

I’ve added a new plugin to kdesdk/kate/plugin: a backtrace browser. It’s meant for developers and probably of no use for users. What does it do? It shows a backtrace delivered by gdb in a listview in a Kate toolview. Clicking on an item opens the selected file and jumps to the correct line number. It works for backtraces generated on your own machine, but it will also work for backtraces from other people, i.e. with /home/dummy/qt-copy/…/qwidget.cpp will still be found on other machines. For that to work, you have to index the directories where the source code is located.
Sometimes there are several files with the same name, e.g.

trunk/kdegraphics/okular/generators/dvi/config.h
trunk/kdepim/mimelib/mimelib/config.h

To pick the right choice, the plugin picks the last two parts of the url, in this case this would be

dvi/config.h
mimelib/config.h

and then usually finds the correct one. Indexing trunk/KDE and branches/KDE/4.1 of course will lead to a clash, now way to fix it. Maybe I could present a list of valid files to the user and let the user pick the right one. I don’t think that’s necessary though for now.

How to configure

Enable the plugin: go to Settings > Configure Kate > Application Plugins and enable ‘Kate Backtrace Browser’
A config page appeared, so click on it and add the directories containing the source code
Clicking OK will start indexing. It will take some time (the index of kdesupport + kdelibs + kdepimlibs + kdebase + kdesdk + playground/plasma + plasma-addons + kdevplatform + kdegraphics is about 6MB)

When indexing is finished, open the toolview “Backtrace Browser”. Now you can load a backtrace from the clipboard (e.g. when you clicked “Copy to Clipboard” in Dr. Konqi) or from a file.

Hope it’s useful :)

Do you understand the word HTML?

Wed, 16 Apr 2008 09:39:00 +0000

During the Kate developer meeting we also thought about simplifying KWrite and how to make the decision whether KWrite should be launched in full featured mode or in a stripped version. …well, and we found a really funny idea:

Note, that this would even work, the question would be rather annoying, though :) The solution right now is to always start KWrite in a simple mode. Mostly only actions are hidden in the menus (@distributors: kdelibs/kate/data/katepartsimpleui.rc), but you can also change c++ code at Kate part level, as there are some functions:

bool KateDocument::simpleMode() (kate part internal), and
bool KTextEditor::Editor::simpleMode() (along with setSimpleMode())

This way config dialogs can be adapted depending on the mode as well. Ah, and if you want the normal mode back, go into the KWrite settings and enable [x] Enable Developer Mode. Then restart KWrite.

PS: Tackat, we came up with this image before our phone call. That’s why it was really funny when you said HTML is something that should not be removed. hehe… :)

Kate Meeting: Day 1 and 2

Tue, 15 Apr 2008 13:29:00 +0000

The Kate Developer Meeting was a productive weekend and once more shows how important the developer sprints are. The summary will be on the dot shortly. Work already started on several topics. As everyone want screenshots, here we go: The new annotation interface available now in KTextEditor can be use to e.g. show svn annotations directly in kate:
basysKom’s coffee maching is simply the best: It can do everything, you just have to press the right key combos:

Kate Developer Sprint 2008 Results

Tue, 15 Apr 2008 11:58:22 +0000

The below notes is what was decided at the development sprint in Darmstadt on April 11-13, 2008

Short term goals

Scripting, part level QtScript
API for indentation scripts
Sessions handling
make text completion work!
VI-Modes (GSoC-project)

Long term goals

Scripting at application level (Kate): Kross
Combination of highlightings & indentations

Scripting
Indentation
Kate Sessions
Extending the highlighting system (Highlighting combination)
Collaborative editing
Text input modes (vi mode)
Minor topics: Search & Replace, text completion
Interface Review
Simplifying KWrite

Scripting

Use cases
- indentation
- helper scripts + assign shortcut
- useful for vi-mode scripting
right now: kjs (barely documented, future uncertain)
choices: Kross, QtScript
- Kross: language independent, depends on available bindings/plugins at runtime
- QtScript, Kross: simply wrap QObjects (signals/slots, Q_SCRIPTABLE automatically exported)

Kate Part: QtScript

flexible integration possible
make it fast for specific use cases (e.g. indentation)
script header
- meta information: key/value pairs (type, name, mimetype, wildcard, …)
- contact i18n people: how to do translation
- translation possible outside KDE?

Kate App

Kross

Indentation

allow multiple indenters for documents with mixed languages (e.g. php and html)
- document variables: e.g. indent-mode [ ];
- document variables: allow different settings (indent-width, …)
remove option “Default Indenter”, it does not make sense (really?)
the script header should state which hl-modes it can indent (instead of mimetype/wildcard in the header)

Auto-completion:

build word completion plugin into kate part by default
fix implementation to actually complete stuff
simplfy the popupmenu (!), just as in KDE3
remove code completion config dialog, this must be implemented in the code completion model, as this is not applicable to any other than the cpp model. Better have something tiny working instead of a broken monster

Kate Sessions (profiles)

data stored:
- application plugin config
- file list (opened files)
- window configuration
- editor component config
- ktexteditor plugin config (maybe kpluginselector problems)
session level configuration / document variables
kill default.katesession file, always use katerc
do not show the session chooser at startup, instead, make a good default (katerc)
clone session: “save as” opens a small dialog with line edit and options like window config, file list
remove option “restore view config” -> simply always do it
make sure kate part plugins can save data to sessions: fork kpluginselector, if necessary :)

Highlighting

extend highlighting system to allow combined highlighting
- add e.g. “entercontext” rules
- separate highlighting loader from hightlight class

Explanation: The purpose of this is to combine template languages such as PHP, EmbPerl, Mason etc with any other syntax highlighting on the fly, as opposed to the current practice which requires a combined set of files to be generated at build time. This is only done for the HTML + PHP combination, so with the new way a multitude of combination becomes available. In addition to that, nothing needs to be regenerated when a highlight is updated, makeing it much easier for users to keep their highlightings updated.

Highlighting / Modes

when opening the config page choose the current used entries (highlight and mode) in the combo box, so that it is immediately clear to the user which mode/hl is active
- “Fonts & Colors” > Highlight Text Styles
- “Open/Save” > Modes & Filetypes
- -> implement in kate part internally: simply track an active view (the last that got focus)

Collaborative Editing

example: gobby
as KTextEditor plugin?
- probably not completely possible right now, missing internal access
Decibel (realtime communication protocol)
- move communication framework into separate process and use dbus interfaces
implementation postponed

Input modes (vi mode)

background: yzis
- rewrite from scratch
- idea of abstracting away “everything” to be flexible (e.g. to support different front ends)
- development stalled 2 years ago
right now in kate part
- command line already similar to vim’s “input mode”
- keep this mode + extend, if needed
idea: integrate into kate part: extend/refactor kate to support input modes
- make code reusable (in other modes)
- extend KTE::Commands to support ranges (e.g. <1,10>)
- add “normal mode”

Search & Replace

bar has big minimum width, works bad in split view
make it possible to embed widgets in the host application (KTE extension?)
search & replace over multiple buffers

Interfaces

Rule of thumb: Introduce interfaces only if usecase is known and best thing is always to have an implementation ready to get out the bugs before binary compatibility issues count

Annotation Interfaces

derive AnnotationViewInterface from AnnotationInterface
—> allow for KTE::Document and KTE::View
merge header files into one

Spellchecking Interface / Viewport Interface

both aim to support Kile doing spellcheck
conclusions
- spellcheck should be first integrated in katepart
- on-the-fly spellcheck support
- highlighting should feed info which parts are able to be spellchecked (extend highlighting system)
- after this is done, an interface can be invented to help Kile to enrich the spellcheck with meta-info like languages, additional spellcheckable ranges, …

Message Interface

implement a way to show messages in a non-intrusive way in the view bar
avoid message boxes by using it, this won’t influence the workflow!
allow quering the user (buttons like OK, Yes, No, i.e. KMessageBox-like)
multiple messages should be queued (or stacked?)
allow both implementation in the part for messages per view and a fallback provided by the application for messages when no view is available

Load/Save Filter Interfaces

preprocessing/postprocessing of text streamed from/to file
checking of input/output, warning, error, …
allow lazy loading, using .desktop files to describe mime-type + wildcards
allow to trigger usage of the plugins via document vars or mode config
default: not allow any plugin, user must allow them (!)

KWrite: should be more simple

extend the kate part to allow blacklist/whitelist highlightings/plugins
remove some advanced actions from ui file, provide simple mode, dummy mode
remove hl
remove folding option
remove bookmarks (menu, settings)
remove modus
remove almost all of extras
all in all: strip down to make it usable for the average user

Kate Meeting: Day 0

Fri, 11 Apr 2008 16:20:00 +0000

Finally it all begins: Anders and Joseph arrived at basysKom and we’ve started to discuss some things we want to do for KDE 4.1. Later, we are going to meet with the rest of the attendees in a restaurant to get to know each other. The official start of the meeting is tomorrow morning. If you are interested in contributing to Kate, just join #kate on irc.kde.org. I’m looking forward to the next two days :)

Kate Developer Sprint 2008

Tue, 25 Mar 2008 12:53:43 +0000

In April there will be a Kate Developer Sprint, similar to previous sprints for Decibel, Akonadi, KDevelop and others. This is a great opportunity as developers interested in development of KDE’s text editor will discuss what to do to make Kate the best text editor on earth. This also means lots of polishing so that Kate in KDE 4.1 will shine even more! The meeting will take place from 2008-04-11 till 2008-04-13. The location is hosted by basysKom in Darmstadt, Germany. Many thanks goes especially to the KDE e.V. for their financial support. If you are interested in Kate development, join our mailing list. More to come, stay tuned!

The event is organized by Dominik Haumann, and is supported by the kde.ev.

On the agenda is discussing Kates future development and improving scripting capabilities amongst others.

Encapsulation is not Information Hiding

Fri, 21 Dec 2007 13:03:00 +0000

As food for thought and in reply to Why Encapsulation is a Good Thing it’s interesting to take a closer look. What does encapsulation mean exactly, and what can you do with it? Maybe what you really want is Information Hiding? …and encapsulation is just a way of possibly achieving it? If you are interested in the details/differences, read the article Encapsulation is not Information Hiding.

Memory Leak Continued

Thu, 22 Nov 2007 11:55:00 +0000

There was some confusion with regard to my last blog about leaking memory. Suppose the ui_mywidget.h files looks like this:

class Ui_Widget
{
public:
QGridLayout *gridLayout;
QGroupBox *groupBox;
QGridLayout *gridLayout1;
QListWidget *listWidget;
QSpacerItem *spacerItem;
QPushButton *pushButton;
void setupUi(QWidget *Widget);
void retranslateUi(QWidget *Widget);
};

Of course, those 6 QObject derived classes are deleted. But the sizeof(Ui_Widget) = 6 * sizeof(void*) = 24 bytes are not deleted. As Ui_Widget is not QObject derived those 24 bytes leak. Confirmed by valgrind.

In a comment to my last blog Paolo suggested to use auto_ptr or scoped_ptr, which is more elegant than an extra wrapper class :)

Memory leak: Ui files and direct approach

Wed, 21 Nov 2007 22:38:00 +0000

The KDE codebase often uses a forward declaration in the .h-file to speedup compilation. The code often looks like this:

// header file
namespace Ui { class MyWidget; }
class MyDialog : public KDialog {
// ...
private:
Ui::MyWidget *ui;
};

The impl looks like this:

// source file
#include "mydialog.h"
#include "ui_mywidget.h"
MyDialog::MyDialog() : KDialog()
{
QWidget *w = new QWidget(this);
setMainWidget(w);
ui = new Ui::MyWidget(); // allocation
ui->setupUi(w);
// ui->...
}

See the memory leak? You have to call »delete ui;« in the destructor if you use the »direct approach«. Searching in lxr.kde.org shows lots of results, and in some places this delete is missing indeed. Happy fixing :)

Update: The really correct fix is to guard the pointer with an auto_ptr or scoped_ptr. For further details read the comments below. Or use another approach to include your ui-file.

* *If you do not want to delete it manually, you can for instance use a workaround like this:

// header file
namespace Ui { class MyWidget; }
class MyWidget;
class MyDialog : public KDialog {
// ...
private:
Ui::MyWidget *ui;
};

Source file:

// source file
#include "mydialog.h"
#include "ui_mywidget.h"
class MyWidget : public QWidget, public Ui::MyWidget {
public:
 MyWidget( QWidget * parent = 0 ) : QWidget( parent )
 { setupUi(this); }
};
MyDialog::MyDialog() : KDialog()
{
ui = new MyWidget(this);
setMainWidget(ui);
QWidget *w = new QWidget(this);
setMainWidget(w);
ui = new Ui::MyDialog(); // allocation
ui->setupUi(w);
// ui->...
}

Kate Highlighting Power

Wed, 12 Sep 2007 19:23:00 +0000

Kate’s highlighting capabilities are amazing. If you want you can highlight really complex syntax, without having to hardcode rules in C++. As an example, we’ll take a look at how Lua comments can be realized:

–[=[ starts a multiline comment (the ‘=’ chars are optional)
]=] ends the multiline comment
the number of ‘=’ chars in ]=] must match the number of –[=[

That means: When the highlighting processor matches the end of a multiline comment, it has to know how many ‘=’ chars started the comment. Thanks to the concept of dynamic rules and contexts Kate is able to do that. The highlighting file looks like this. First comes the header

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE language SYSTEM "language.dtd" >
<language name="Test" version="1.0" kateversion="2.4" section="Markup" extensions="" mimetype="">
<highlighting>

Then the body with the contexts. We start in the first context called “Normal Text”. When the regular expression –[(=*)[ matches it switches to the context Comment.

<contexts>
<context attribute="Normal Text" lineEndContext="#stay" name="Normal">
<RegExpr attribute="Comment" context="Comment" String="--\[(=*)\[" dynamic="true"/>
</context>

The part (=*) is now available as %1 in the rule below:

<context name="Comment" attribute="Comment" lineEndContext="#stay" dynamic="true" >
<RegExpr attribute="Comment" context="#pop" String="\]%1\]" dynamic="true" />
</context>
</contexts>

The last part is the footer:

<itemDatas>
<itemData name="Normal Text" defStyleNum="dsNormal" />
<itemData name="Comment" defStyleNum="dsComment" />
</itemDatas>
</highlighting>
</language>

If you want to know more about Kate’s highlighting, have a look at the documentation :) There are also lots of bug reports, so if you want to contribute you can fix them!

PS: As I don’t know much about Lua, comments might work differently. That does not really matter, as the example still shows what you can do :)

Extending Kate by Scripts

Sat, 21 Jul 2007 11:29:00 +0000

We have seen how scripting basically works for indentation. It’s also possible to register commandline functions (The command line is bound to F7 by default, or invoke View > Switch to Command Line). We will consider a small example again: sort the selected text.

/ kate-script
  name: unused
  author: foo bar
  license: LGPL
  version: 1
  kate-version: 3.0
  functions: sorter
/

function sorter ()
{
    if (view.hasSelection()) {
        var start = view.startOfSelection().line;
        var end = view.endOfSelection().line;

        var text = document.textRange(start, 0, end, document.lineLength(end));

        var lines = text.split(“\n”);
        lines.sort();
        text = lines.join(“\n”);

        view.clearSelection();

        document.editBegin();
        document.removeText(start, 0, end, document.lineLength(end));
        document.insertText(start, 0, text);
        document.editEnd();
    }
}

The header line functions: sorter makes Kate Part aware of the function in the script. A list of functions is supported, separated by white spaces. You can use the function by typing ‘sorter’ in the commandline.
Some todo items:

provide better JavaScript API. For example: document.textRange() takes 4 parameters. It would be more elegant to take one range or two cursors, just like we do in the KTextEditor interfaces in kdelibs/interfaces/ktexteditor
make is possible to bind scripts to shortcuts. This could be done by e.g. binding commandline functions to shortcuts or implementing a vim-like command-mode in Kate’s commandline. How to configure the shortcuts is unclear, though.
then, think about replacing the C++ implementations of ‘uppercase’, ‘lowercase’, ‘capitalize’ etc. with scripts
things I forgot…

If you are interested subscribe to kwrite-devel@kde.org and contribute :) We also need indentation scripts, of course!

Kate: More on Indentation Scripting

Fri, 20 Jul 2007 17:18:00 +0000

My last blog was about the theory of how indentation works by using javascripts. Now we will look at a concrete example: a LISP-style indenter. (LISP indentation is easy, that’s why it’s a good example).
The rules:

comments starting with ;;; always have indentation 0
comments starting with ;; should be aligned with the next line
comments starting with ; should only appear behind code, so they are simply ignored
every ‘(‘ indents and every ‘)’ unindents

lisp.js looks like this:

/** kate-script
* name: LISP
* license: LGPL
* author: foo bar
* version: 1
* kate-version: 3.0
* type: indentation
/
// indent should be called when ; is pressed
triggerCharacters = “;”;
function indent(line, indentWidth, ch)
{
// special rules: ;;; -> indent 0
// ;; -> align with next line, if possible
// ; -> usually on the same line as code -> ignore
textLine = document.line(line);
if (textLine.search(/^\s;;;/) != -1) {
return 0;
} else if (textLine.search(/^\s*;;/) != -1) {
// try to align with the next line
nextLine = document.nextNonEmptyLine(line + 1);
if (nextLine != -1) {
return document.firstVirtualColumn(nextLine);
}
}

cursor = document.anchor(line, 0, ‘(‘);
if (cursor) {
return document.toVirtualColumn(cursor.line, cursor.column) + indentWidth;
} else {
return 0;
}
}

The result:

;;; fib : number -> number
(define (fib n)
(if (< n 2)
1
(+ (fib (- n 1)) (fib (- n 2)))))

As this indenter is scripted, everybody can adapt the style to the own needs.

Kate Scripting: Indentation

Wed, 18 Jul 2007 11:17:00 +0000

Kate Part in KDE4 supports the ECMAScript (JavaScript) language by using kjs. In KDE3 we had several hard-coded indenters in C++, the idea is to let scripts do all the indentation in KDE4.
How does it work? It is similar to vim: You simply create a script in the directory $KDEDIR/share/apps/katepart/jscript. An indentation script has to follow several rules:

it must have a valid script header (the first line must include the string kate-script and indentation scripts must have the type: indentation)
it must define some variables and functions

Whenever the user types a character, the flow in Kate Part works like this

check the indentation script’s trigger characters, i.e. whether the script wants to indent code for the typed character
if yes, call the indentation function
the return value of the indentation function is an integer value representing the new indentation depth in spaces.

In the 3rd step there are 2 special cases for the return value:

return value = -1: Kate keeps the indentation, that is it searches for the last non-empty line and uses its indentation for the current line
return value < -1 tells Kate to do nothing

So how does a script look like exactly?
The name does not really matter, so let’s call it foobar.js:

/* kate-script
* name: MyLanguage Indenter
* license: LGPL
* author: Foo Bar
* version: 1
* kate-version: 3.0
* type: indentation
*
* optional bla bla here
*/
// specifies the characters which should trigger indent() beside the default '\n'
triggerCharacters = "{}";
// called for the triggerCharacters {} and
function indent(line, indentWidth, typedChar)
{
// do calculations here
// if typedChar is an empty string, the user hit enter/return
// todo: Implement your indentation algorithms here.
return -1; // keep indentation
}

More details on the header:

name [required]: the name will appear in Kate’s menus
license [optional]: not visible in gui, but should be specified in js-files. it is always better to have a defined license
author [optional]: name
version [optional]: recommended. an integer
kate-version [required]: the minimum required kate-version (e.g. for api changes)
type [required]: must be set to indentation

The only missing part is the API which Kate Part exports to access the document and the view. Right now, there is no API documentation, so you have to look at the code:

kdelibs/kate/jscript/katejscript.cpp search for “@Begin” tags

You will find, that the current document exports functions like

document.fileName()
document.isModified()
document.charAt(line, column)
etc…

The view exports functions like

view.cursorPosition()
view.hasSelection()
view.clearSelection()
…

That’s the boring part of this blog. The interesting one is unfortunately shorter: we are looking for contributors who want to write scripts or help in the C++ implementation :)

API documentation & refactored kdelibs/kdeui

Wed, 27 Dec 2006 23:05:00 +0000

During the last weeks/days the directory structure of especially kdelibs/kdeui got a major overhaul: in KDE 3 all files of a module were in the same directory which was more or less a mess as you did not know immediately which files belonged to the same category. kdelibs/kdeui in KDE4 has a rather clean structure now (similar to the one in Qt) by using subfolders like

actions
dialogs
widgets
xmlgui
several others…

Compare this to KDE3’s kdelibs/kdeui structure. For KDE4 this is a huge benefit, as we have clearly defined groups. We already had lots of discussions in the past about API documentation and this is exactly where the new structure is important: In Qt every class usually belongs to a group (example). Our API documentation tool doxygen of course supports grouping, and now it is even easy to know which class should be in which group. For instance, all classes in the widgets directory should be in the ‘Widgets‘ group, and then maybe even more fine-grained divided into sub-groups.
By the way, we have a policy that every widget in kdelibs has a screenshot to immediately see how it looks like – another nice way to get involved :)
All in all this is really awesome and I’d like to thank all involved developers. Next prey is kdelibs/kdecore? =)

Share Kate Highlighting Files

Thu, 12 Oct 2006 21:35:00 +0000

Thanks to Frank we have a dedicated section for Kate Highlighting files on kde-files.org now. We encourage everyone to publish their .xml files there. The Kate team agreed to add more highlighting files to the official Kate releases, though, as long as they are of general use. For KDE4 we plan to have a section for Kate Indentation scripts, too. But that’s content for another blog, which will follow later :)

Kate: More eye-candy

Fri, 29 Sep 2006 17:34:00 +0000

Two years ago we had the KDE conference in Ludwigsburg, Germany. At that time, Martijn Klingens committed a patch to show trailing spaces in Kate. I just change the visualization a bit, the change is in for KDE4 :) Tabs are marked with a ‘»’ character, and spaces with a dot. On the left you can see the old and on the right the new version; Here is a screenshot:

The Wheel of Time Turns…

Sat, 16 Sep 2006 05:53:00 +0000

…and this time it turns out that I am going to akademy. Dublin I’m coming, wheee! :)

Smart End

Wed, 09 Aug 2006 10:33:00 +0000

Since KDE 3.5.4 Kate Part supports “smart end“. Right now it behaves like this when pressing “end”:

go to last non-space character
go to the last character (i.e. hit end twice)

I’m writing this blog to get feedback about what’s the right/expected behaviour. Is it as described above, or should we first go to the very last character, and to the last non-space only when hitting then end-key twice?

Feedback along with why you prefer solution A or B is welcome!

Kate in KDE 3.5.4

Wed, 02 Aug 2006 18:51:00 +0000

Finally, KDE 3.5.4 is out! We were able to fix a lot of issues in Kate and the bug curves went noticeably down. Thanks to all contributors for the nice KDE release :)

Kate: Shortcomings of .kateconfig file

Sun, 23 Jul 2006 19:02:00 +0000

Assume you have a .kateconfig file optimized for C++ code that replaces tabs on save. Now you open a Makefile that contains tabs (due to its strict syntax). If you save the Makefile in kate, the tabs then are replaced which results in a corrupted Makefile.

In other words: The .kateconfig file applies to every file. It lacks mimetype/extension support and thus can lead to unwanted behaviours.

So if you use a .kateconfig file, keep that in mind :) Maybe we should simply use modelines in the h/cpp files for now.

Indentation and Coding Style

Sun, 23 Jul 2006 08:56:00 +0000

kdelibs will have coding style conventions. In general. this is not a bad idea. Our 45528 slocs in KatePart all use a consistent indent-width of 2 spaces. Changing this does not really make sense – ok, if svn praise -w (sure, we never need svn blame in our code ;) finally works, we can discuss this again.

In other words: How “consistent” will kdelibs get with this new conventions? The interesting part of Zack’s mail is

[…]
No exceptions. Either everything or nothing
[…]

While everything would really be cool, in truth it’s not possible to achieve, is it? We will have exceptions or rather violations, I’m pretty sure :)

Some developers already start adding katepart modelines to their souce code. For those who don’t know yet: You also can simply use a single .kateconfig file, which is the equivalent to emacs dir config files. You just have to make sure to set the search depth for a .kateconfig file to – let’s say – 3. Do this in

Settings > Configure Kate… > Open/Save

Kate Project Plugin

Thu, 20 Jul 2006 08:24:00 +0000

It is not a secret that removing Kate’s project manager in KDE 3.5 was not the right thing to do. It seems a lot of people used it and we got many complaints about this decision. That also shows that it is hard go get feedback about what users are really using. If a feature is done well, noone will ever talk about it. This is paradox, as we thought the project manager was not well integrated :) (I still think that)

Ok, let’s come to the interesting part: Three developers wrote a new Kate Project Manager Plugin and published an initial release on sourceforge.net and on kde-apps.org. It works quite well already and reading the comments on kde-apps.org gives me the impression that there are more features to come with the next release. — If you are interested maybe you want to join the project…

PS: I have the secret hope the plugin will be ported to KDE4 using Qt’s model/view architecture, so that it has good support for multiple mainwindows :)

Triple clicks

Fri, 30 Jun 2006 10:13:00 +0000

Text editors and line edits support the so-called triple clicks according to 1. The document says

Triple Click: Select the targeted row. […]

It is unclear whether the “targeted row” includes the trailing linebreak. Kate Part selects the targeted line including the linebreak. You get the following behavior:

If you move the selected row with the mouse, you usually have the linebreaks right. The same applies for copy/cut & paste. If you are used to it, it really is a nice feature.

While this behavior is pretty straightforward, it is not widely in use. If you look at text edit widgets like in firefox, konqueror, Qt, KWord or OOo you will notice that they do not include the trailing newline character.

Question now is: Should we change it for KDE 4 in Kate Part just to be compliant with the others? As Kate Part is an editor component mainly used for programming, my favourite option is to include it, i.e. to keep the current behavior.

(update) I just stumbled over http://bugs.kde.org/show_bug.cgi?id=91041 =)

1 http://developer.kde.org/documentation/standards/kde/style/mouse/selection.html

Kate Part in upcoming KDE 3.5.4

Wed, 28 Jun 2006 19:03:00 +0000

The last week was highly productive for Kate Part, as the following bugs were fixed:

89042 while pressing “del” key kate crashes (crash, bt)
103648 Codefolding Crash – Reproducable
118584 scroll position not upgrading (dynamic word wrap)
119435 kate crash when a file is saved
123315 kwrite/kate crashes randomly after save
124102 changing syntax highlighting when code is folded crashes katepart
127928 kate crashes deleting a block of text
128690 Dynamic word wrap makes text input slow
129853 Horizontal scrollbar and view not synced, if dynamic and static word wrap are off
and some minor issues

That are 6 crash fixes. Kate Part in KDE 3.5.4 will be more stable than ever :) That’s especially cool for KDevelop, Quanta+, Kile – well and Kate.
Special thanks to Andreas Kling for initiating the bug squashing sessions! You are like a blackbox: The input is a bug and your output is the fix ;)

Kate Modes & Filetypes

Thu, 09 Feb 2006 15:57:45 +0000

Modes allow the user to override the default configuration for documents of specified mimetypes or file extensions. When the editor loads a document and the mimetype or file extensions match for one of the defined filetypes, KatePart will read the configuration from the mode and apply the modelines defined. If more filetypes match, the one with the highest priority will be used.

To create a filetype, go into the settings dialog available in Kate via Settings > Configure Kate > Open/Save > Modes/Filetypes, then press the New button and fill in the properties. To remove an existing filetype, select it from the dropdown list and press the Delete button. To edit an existing mode, select it from the dropdown list.

Some Available Properties

Name
This is a user friendly name that will be displayed in the menu Tools > Mode.
Section
A submenu of Tools > Mode in which to place this filetype. If the section does not already exist, it will automatically be created.
Variables
This is where the actual configuration goes. Variables set here will overwrite the default configuration values. Be aware that this line must begin with kate: and end with a semicolon. For a full list of available variables refer to modelines.
File Extensions
A semicolon separated list of filename globs used to determine if a document matches this filetype.
Mimetypes
A semicolon separated list of mime types used to determine if a document matches this filetype.
Priority
If a document matches several filetypes, the one with the highest priority will be chosen.

Example

As an example we will create a new mode configuration for C++ and Java files. It should use the C Style indenter and indent with 4 spaces (no tabs). The configuration could look like this:

Name: C++ and Java settings
Section: Sources
Variables: kate: space-indent on; indent-width 4; mixed-indent off; indent-mode cstyle;
File Extensions: *.cpp;*.java
Mimetypes: text/x-c++hdr;text/x-c++src;text/x-java
Priority: 10

.kateconfig Files

Thu, 09 Feb 2006 12:45:52 +0000

Kate allows you to specify local document variables by setting the corresponding modelines. The hidden file .kateconfig provides exactly the same functionality, but for all files in the directory.

Enable the Feature

To use a .kateconfig file you first have to enable the feature by invoking Settings > Configure Kate. In the config page Open/Save you can find the option Search depth for config file, which defaults to Do not use a config file. Change the value to an appropriate number,

__ means look in the current folder
1 means look in the current folder, and if there is no .kateconfig file, look in the parent folder
etc…

In short – Kate will search the number of given folder levels upwards for a .kateconfig file and load the settings from it.

Fill the .kateconfig File

The .kateconfig file simply contains modelines.

The following example will cause all documents to indent with 4 spaces with a tab width of 4. Tabs will be replaced during editing text and the end-of-line symbol is a linefeed (\n).

kate: space-indent on; tab-width 4; indent-width 4; replace-tabs on; eol unix;

Extended Options in KDE 3.5.x, KDE 4 and Kate 5

Kate in KDE 4 as well as later versions of Kate always search for a .kateconfig file for local files (not remote files). In addition, it is now possible to set options based on wildcards (file extensions) as follows:

kate: tab-width 4; indent-width 4; replace-tabs on;
kate-wildcard(*.xml): indent-width 2;
kate-wildcard(Makefile): replace-tabs off;

In this example, all files use a tab-width of 4 spaces, an indent-width of 4 spaces, and tabs are replaced expanded to spaces. However, for all *.xml files, the indent width is set to 2 spaces. And Makefiles use tabs, i.e. tabs are not replaced with spaces. Wildcards are semicolon separated, i.e. you can also specify multiple file extensions as follows:

kate-wildcard(*.json;*.xml): indent-width 2;

Further, you can also use the mimetype to match certain files, e.g. to indent all C++ source files with 4 spaces, you can write :

kate-mimetype(text/x-c++src): indent-width 4;

Note: Next to the support in .kateconfig files, wildcard and mimetype dependent document variables are also supported in the files itself as comments.

Kate Modelines

Thu, 09 Feb 2006 12:41:07 +0000

Kate Part’s modelines – also called Kate document variables – are Kate Part’s implementation of document variables, similar to Emacs and vim modelines.

Document variables can be used to set Kate settings local to a file. This is for example for using another indenter than the one defined in the GUI settings. Or assume you work on two projects, the first indents with spaces and the second with tabs, then you can simply add a modeline that contains the specific document variables that set the specific indentation properties.

The following contents is mainly from the Kate Handbook.

Modeline Format

A modeline in the Kate Part has the following format:

kate: VARIABLENAME VALUE; [ VARIABLENAME VALUE; ... ]

The lines can be in a comment, in C++ for example in /*...*/ sections. Multiple modelines are supported, i.e. modelines can be split over several lines for better visibility. Variable names are single words (no whitespace), and anything up to the next semicolon is the value. The trailing semicolon (;) is required.

Here is an example of how a modeline could look like, forcing indentation settings for a C++, Java or JavaScript file:

// kate: space-indent on; indent-width 4; mixedindent off; indent-mode cstyle;

NOTE: Only the first and last 10 lines in a file are searched for modelines.

There are variables to support almost all options in Kate Part, and additionally plugins can use variables, in which case it should be documented in the plugin’s documentation.

How Kate Part uses Variables

When reading settings, Kate Part looks in the following places in the order

the global configuration, i.e. settings made in the user interface
the Modes & Filetypes configuration
the .kateconfig file
the modelines in the document itself

This means Kate Part’s modelines have actually the highest precedence. Whenever a document is saved, the document variables are reread, and will overwrite changes made using menu items or the command line.
Any variable not listed below is stored in the document and can be queried by other objects such as plugins, which can use them for their own purpose.

Available Modelines

The variables listed here documents Kate version 2.4. More variables may be added in the future. There are defied 3 types of values for variables, with the following valid expressions:

BOOL – on|off|true|false|1|0
INTEGER – any integer number
STRING – anything else

Available modelines are, in detail:

auto-brackets [BOOL]
Set auto insertion of brackets on or off.
auto-center-lines [INT]
Set the number of autocenter lines.
auto-insert-doxygen [BOOL]
Turn insertion of the leading asterisk in doxygen comments on or off. This has no effect unless you use the cstyle auto-indenter.
background-color [STRING]
Sets the document background color. The value must be something that can be evaluated to a valid color, for example #ff0000.
backspace-indents [BOOL]Turn backspace indenting on or off.
block-selection [BOOL]
Turn block selection on or off.
bom | byte-order-marker [BOOL] (new in Kate 3.4/KDE 4.4)
Enable/disable the byte order marker when saving files in unicode format (utf-8/utf-16/utf-32).
bracket-highlight-color [STRING]
Sets the color for the bracket highlight. The value must be something that can be evaluated to a valid color, for example #ff0000.
current-line-color [STRING]
Sets the color for the current line. The value must be something that can be evaluated to a valid color, for example #ff0000.
default-dictionary [STRING] (new in Kate 3.4/KDE 4.4)Sets the default dictionary used for spell checking.
dynamic-word-wrap [BOOL]
Turns dynamic word wrap on or off.
eol | end-of-line [STRING]
Sets the end of line mode. Valid settings are unix, mac and dos
folding-markers [BOOL]
Set the display of folding markers on or off.
font-size [INT]Sets the point size of the document font.
font [STRING]
Sets the font of the document. The value should be a valid font name, for example courier.
hl | syntax [STRING]Set the syntax highlighting. Valid strings are all the names you can find in the menus. For instance, for C++ you write C++.
icon-bar-color [STRING]
Sets the icon bar color. The value must be something that can be evaluated to a valid color, for example #ff0000.
icon-border [BOOL]
Set the display of the icon border on or off.
indent-mode [STRING]
Set the auto-indentation mode. The options none, normal, cstyle, haskell, python, lilypond, lisp are recognized. See the section Using Automatic Indenting for details.
indent-width [INT]
Sets the indentation width.
keep-extra-spaces [BOOL]
Set weather to keep extra spaces when calculating indentation width.
keep-indent-profile [BOOL] (Removed in Kate 3, i.e. since KDE4)
If enabled, prevents unindenting a block if at least one line has no indentation.
line-numbers [BOOL]
Set the display of line numbers on or off.
mixed-indent [BOOL]
Set mixed indentation ala Emacs on or off.
DEPRECATED for Kate 3.0 From version 3.0 this variable is ignored, set replace-tabs on; instead for that version.
overwrite-mode [BOOL]
Set overwrite mode on or off.
persistent-selection [BOOL]
Set persistent selection on or off.
remove-trailing-space [BOOL]
Set dynamic end of line cleanup on or off.
replace-tabs-save [BOOL]
Set tab->space conversion on save on or off.
replace-tabs [BOOL]
Set dynamic tab->space conversion on or off.
replace-trailing-space-save [BOOL]
Set end of line cleanup on save on or off.
scheme [STRING]
Set the color scheme. The string must be the name of a color scheme that exists in your configuration to have any effect.
selection-color [STRING]
Set the selection color. The value must be something that can be evaluated to a valid color, for example #ff0000.
show-tabs [BOOL]Set the visual TAB character on or off.
smart-home [BOOL]
Set smart home navigation on or off.
space-indent [BOOL]
Set indentation with spaces on or off.
DEPRECATED for Kate 3.0 — From Kate 3.0 mixed-indent is the default behavior, set replace-tabs on; to achieve space-only indentation.
tab-indents [BOOL]
Set the TAB key indentation on or off.
tab-width [INT]
Set the tab display width.
undo-steps [INT]
Set the number of undo steps to remember.
word-wrap-column [INT]
Set the hard word wrap width.
word-wrap-marker-color [STRING]
Set the work wrap marker color. The value must be something that can be evaluated to a valid color, for example #ff0000.
word-wrap [BOOL]
Set hard word wrapping on or off.
wrap-cursor [BOOL]
Set cursor wrapping on or off.

Writing a Syntax Highlighting File

Thu, 24 Mar 2005 15:46:11 +0000

Note: Please refer to the Kate Handbook for the most recent version of how to write syntax highlighting files.

Hint: If you want to write a syntax highlighting file, the XML Completion plugin might be of great help.

This section is an overview of the Highlight Definition XML format in KDE4. Based on a small example it will describe the main components and their meaning and usage. The next section will go into detail with the highlight detection rules.

Main sections of Kate Highlight Definition files

The formal definition, aka the DTD is stored in the file language.dtd which should be installed on your system in the folder $KDEDIR/share/apps/katepart/syntax. If $KDEDIR is unset look up the folder by using kde4-config --prefix.

An Example

A highlighting file contains a header that sets the XML version and the doctype:

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language SYSTEM "language.dtd">

The root of the definition file is the element language. Available attributes are:

Required attributes:

name sets the name of the language. It appears in the menus and dialogs.
section specifies the category.
extensions defines file extensions, like “.cpp;.h”

Optional attributes:

mimetype associates files Mime Type based.
version specifies the current version of the definition file.
kateversion specifies the latest supported version of Kate.
casesensitive defines, whether the keywords are case sensitive or not. NOTE: not implemented yet.
priority is necessary if another highlight definition file uses the same extensions. The higher priority will win.
author contains the name of the author and his email-address.
license contains the license, usually LGPL, Artistic, GPL and others. It’s important to specify a license, as the kate team needs some legal backing for the distribution of the files.
hidden defines, whether the name should appear in Kate’s menus.

So the next line may look like this:

<language name="C++" version="1.00" kateversion="2.4" section="Sources" extensions="*.cpp;*.h" >

Next comes the highlighting element, which contains the optional element list and the required elements contexts and itemDatas.

list elements contain a list of keywords. In this case the keywords are class and const. You can add as many lists as you need. The contexts element contains all contexts. The first context is by default the start of the highlighting. There are two rules in the context Normal Text, which match the list of keywords with the name somename and a rule that detects a quote and switches the context to string. To learn more about rules read the next chapter.
The third part is the itemDatas element. It contains all color and font styles needed by the contexts and rules.
In this example, the itemData Normal Text, String and Keyword are used.

 <highlighting> <list name="somename"> <item> class </item> <item> const </item> </list> <contexts> <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" > <keyword attribute="Keyword" context="#stay" String="somename" /> <DetectChar attribute="String" context="string" char="&quot;" /> </context> <context attribute="String" lineEndContext="#stay" name="string" > <DetectChar attribute="String" context="#pop" char="&quot;" /> </context> </contexts> <itemDatas> <itemData name="Normal Text" defStyleNum="dsNormal" /> <itemData name="Keyword" defStyleNum="dsKeyword" /> <itemData name="String" defStyleNum="dsString" /> </itemDatas> </highlighting>

The last part of a highlight definition is the optional general section. It may contain information about keywords, code folding, comments and indentation.

The comment section defines with what string a single line comment is introduced. You also can define a multiline comments using multiLine with the additional attribute end. This is used if the user presses the corresponding shortcut for comment/uncomment.
The keywords section defines whether keyword lists are case sensitive or not. Other attributes will be explained later.

 <general> <comments> <comment name="singleLine" start="#"/> </comments> <keywords casesensitive="1"/> </general> </language>

The Sections in Detail

This part will describe all available attributes for contexts,
itemDatas, keywords, comments, code folding and indentation.

The element context belongs into the group contexts. A context itself defines context specific rules like what should happen if the highlight system reaches the end of a line. Available attributes are:

name the context name/identifier. Rules will use this name to specify the context to switch to if the rule matches.
attribute the default item data that is used if no rules match in the current context.
lineEndContext defines the context the highlight system switches to if it reaches the end of a line. This may either be a name of another context, #stay to not switch the context (i.e. do nothing) or #pop which will cause to leave this context. It is possible to use for example #pop#pop#pop to pop three times.
lineBeginContext defines the context if a begin of a line is encountered. Default: #stay.
fallthrough defines if the highlight system switches to the context specified in fallthroughContext if no rule matches. Default: false.
fallthroughContext specifies the next context if no rule matches.
dynamic if true, the context remembers strings/placeholders saved by dynamic rules. This is needed for HERE documents for example. Default: false.

The element itemData is in the group itemDatas. It defines the font style and colors. So it is possible to define your own styles and colors, however we recommend to stick to the default styles if possible so that the user will always see the same colors used in different languages. Though, sometimes there is no other way and it is necessary to change color and font attributes. The attributes name and defStyleNum are required, the other optional. Available attributes are:

name sets the name of the itemData. Contexts and rules will use this name in their attribute.
attribute to reference an itemData.
defStyleNum defines which default style to use. Available default styles are explained in detail later.
color defines a color. Valid formats are ‘#rrggbb’ or ‘#rgb’.
selColor defines the selection color.
italic if true, the text will be italic.
bold if true, the text will be bold.
underline if true, the text will be underlined.
strikeout if true, the text will be stroked out.
spellChecking if true, the text will be spell checked, otherwise it will be ignored during spell check.

The element keywords in the group general defines keyword properties. Available attributes are:

casesensitive may be true or false. If true, all keywords are matched case sensitive. Default: true.
weakDeliminator is a list of characters that do not act as word delimiters. For example the dot (.) is a word delimiter. Assume a keyword in a list contains a dot, it will only match if you specify the dot as a weak delimiter.
additionalDeliminator defines additional delimiters.
wordWrapDeliminator defines characters after which a line wrap may occur. Default delimiters and word wrap delimiters are the characters .():!+,-<=>%&_/;?[]^{|}~_*, space (‘ ‘) and tabulator (\t).

The element comment in the group comments defines comment properties which are used
for Tools > Comment and Tools > Uncomment.
Available attributes are:

name is either singleLine or multiLine.
If you choose singleLine the optinal attribute position is available. Default for this attribute is to insert the single line comment string in column 0. If you want it to appear after the whitespaces you have to set it to afterwhitespace, like: position="afterwhitespace".
If you choose multiLine the attributes end and region are required.
start defines the string used to start a comment. In C++ this is /*.
end defines the string used to close a comment. In C++ this is */.
region should be the name of the the foldable multiline comment. Assume you have beginRegion=”Comment” … endRegion=”Comment” in your rules, you should use region=”Comment”. This way uncomment works even if you do not select all the text of the multiline comment. The cursor only must be in the multiline comment.

The element folding in the group general defines code folding properties. Available attributes are:

indentationsensitive if true, the code folding markers will be added indentation based, like in the scripting language Python. Usually you do not need to set it, as it defaults to false.

The element indentation in the group general defines which indenter will be used, however we strongly recommend to omit this element, as the indenter usually will be set by either defining a File Type or by adding a mode line to the text file. If you specify an indenter though, you will force a specific indentation on the user, which he might not like at all.
Available attributes are:

mode is the name of the indenter. Available indenters right now are: none, normal, cstyle, haskell, lilypond, lisp, python, ruby and xml.

Available Default Styles

Default styles are predefined font and color styles. For convenience Kate provides several default styles, in detail:

dsNormal, used for normal text.
dsKeyword, used for keywords.
dsDataType, used for data types.
dsDecVal, used for decimal values.
dsBaseN, used for values with a base other than 10.
dsFloat, used for float values.
dsChar, used for a character.
dsString, used for strings.
dsComment, used for comments.
dsOthers, used for ‘other’ things.
dsAlert, used for warning messages.
dsFunction, used for function calls.
dsRegionMarker, used for region markers.
dsError, used for error highlighting and wrong syntax.

Highlight Detection Rules

This section describes the syntax detection rules.

Each rule can match zero or more characters at the beginning of the string they are tested against. If the rule matches, the matching characters are assigned the style or attribute defined by the rule, and a rule may ask that the current context is switched.

A rule looks like this:

The attribute identifies the style to use for matched characters by name, and the context identifies the context to use from here.

The context can be identified by:

An identifier, which is the name/identifier of another context.
An order telling the engine to stay in the current context (#stay), or to pop back to a previous context used in the string (#pop). To go back more steps, the #pop keyword can be repeated: #pop#pop#pop

Some rules can have child rules which are then evaluated only if the parent rule matched. The entire matched string will be given the attribute defined by the parent rule. A rule with child rules looks like this:

<RuleName (attributes)> <ChildRuleName (attributes) /> ... </RuleName>

Rule specific attributes vary and are described in the following sections.

Common attributes

All rules have the following attributes in common and are available whenever a (common attributes) appears. All following attributes are optional.

attribute maps to a defined itemData. Default: the attribute from the destination context
context specifies the context to which the highlighting system switches if the rule matches. Default: #stay
beginRegion starts a code folding block. Default: unset.
endRegion closes a code folding block. Default: unset.
lookAhead, if true, the highlighting system will not process the matches length. Default: false.
firstNonSpace, if true, the rule only matches, if the string is the first non-whitespace in the line. Default: false.
column defines the column. The rule only matches, if the current column matches the given one. Default: unset.

Dynamic rules

Some rules allow the optional attribute dynamic of type boolean that defaults to false. If dynamic is true, a rule can use placeholders representing the text matched by a regular expression rule that switched to the current context in its string or char attributes. In a string, the placeholder %N (where N is a number) will be replaced with the corresponding capture N from the calling regular expression. In a char the placeholer must be a number N and it will be replaced with the first character of the corresponding capture N from the calling regular expression. Whenever a rule allows this attribute it will contain a (dynamic).

dynamic may be either true or false. Default: false.

The Rules in Detail

DetectChar

Detect a single specific character. Commonly used for example to find the ends of quoted strings.

<DetectChar char="(character)" (common attributes) (dynamic) />

The char attribute defines the character to match.

Detect2Chars

Detect two specific characters in a defined order.

<Detect2Chars char="(character)" char1="(character)" (common attributes) (dynamic) />

The char attribute defines the first character to match, char1 the second.

AnyChar

Detect one character of a set of specified characters.

<AnyChar String="(string)" (common attributes) />

The String attribute defines the set of characters.

StringDetect

Detect an exact string.

<StringDetect String="(string)" [insensitive="true|false"] (common attributes) (dynamic) />

The String attribute defines the string to match. The insensitive attribute defaults to false and is passed to the string comparison function. If the value is true insensitive comparing is used.

WordDetect (KDE >= 4.5, Kate >= 3.5)

Detect an exact string but additionally require word boundaries like a dot (.) or a whitespace on the beginning and the end of the word. You can think of \b\b in terms of a regular expression.

<WordDetect String="(string)" [insensitive="true|false"] (common attributes) (dynamic) />

RegExpr

Matches against a regular expression.

<RegExpr String="(string)" [insensitive="true|false"] [minimal="true|false"] (common attributes) (dynamic) />

The String attribute defines the regular expression.
insensitive defaults to false and is passed to the regular expression engine.
minimal defaults to false and is passed to the regular expression engine.

Because the rules are always matched against the beginning of the current string, a regular expression starting with a caret (^) indicates that the rule should only be matched against the start of a line.

keyword

Detect a keyword from a specified list.

<keyword String="(list name)" (common attributes) />

The String attribute identifies the keyword list by name. A list with that name must exist.

Int

Detect an integer number.

<Int (common attributes) (dynamic) />

This rule has no specific attributes. Child rules are typically used to detect combinations of L and U after the number, indicating the integer type in program code. Actually all rules are allowed as child rules, though, the DTD only allowes the child rule StringDetect.
The following example matches integer numbers follows by the character ‘L’.

<Int attribute="Decimal" context="#stay" > <StringDetect attribute="Decimal" context="#stay" String="L" insensitive="true"/> </Int>

Float

Detect a floating point number.

<Float (common attributes) />

This rule has no specific attributes. AnyChar is allowed as a child rules and typically used to detect combinations, see rule Int for reference.

HlCOct

Detect an octal point number representation.

<HlCOct (common attributes) />

This rule has no specific attributes.

HlCHex

Detect a hexadecimal number representation.

<HlCHex (common attributes) />

This rule has no specific attributes.

HlCStringChar

Detect an escaped character.

<HlCStringChar (common attributes) />

This rule has no specific attributes.

It matches literal representations of characters commonly used in program code, for example \n (newline) or \t (tabulator).

The following characters will match if they follow a backslash (**): *abefnrtv”’?*. Additionally, escaped hexadecimal numbers like for example \xff and escaped octal numbers, for example \033 will match.

HlCChar

Detect an C character.

<HlCChar (common attributes) />

This rule has no specific attributes.

It matches C characters enclosed in a tick (Example: ‘c’). So in the ticks may be a simple character or an escaped character. See HlCStringChar for matched escaped character sequences.

RangeDetect

Detect a string with defined start and end characters.

<RangeDetect char="(character)" char1="(character)" (common attributes) />

char defines the character starting the range, char1 the character ending the range. Usefull to detect for example small quoted strings and the like, but note that since the highlighting engine works on one line at a time, this will not find strings spanning over a line break.

LineContinue

Matches a backslash (‘’) at the end of a line.

<LineContinue (common attributes) />

This rule has no specific attributes.
This rule is useful for switching context at end of line, if the last character is a backslash (‘****’). This is needed for example in C/C++ to continue macros or strings.

IncludeRules

Include rules from another context or language/file.

<IncludeRules context="contextlink" [includeAttrib="true|false"] />

The context attribute defines which context to include.
If it a simple string it includes all defined rules into the current context, example:

<IncludeRules context="anotherContext" />

If the string begins with ## the highlight system will look for another language definition with the given name, example:

<IncludeRules context="##C++" />

If includeAttrib attribute is true, change the destination attribute to the one of the source. This is required to make for example commenting work, if text matched by the included context is a different highlight than the host context.

DetectSpaces

Detect whitespaces.

<DetectSpaces (common attributes) />

This rule has no specific attributes.
Use this rule if you know that there can several whitespaces ahead, for example in the beginning of indented lines. This rule will skip all whitespace at once, instead of testing multiple rules and skipping one at the time due to no match.

DetectIdentifier

Detect identifier strings (as a regular expression: [a-zA-Z][a-zA-Z0-9]*).

<DetectIdentifier (common attributes) />

This rule has no specific attributes.
Use this rule to skip a string of word characters at once, rather than testing with multiple rules and skipping one at the time due to no match.

Tips & Tricks

Once you have understood how the context switching works it will be easy to write highlight definitions. Though you should carefully check what rule you choose in what situation. Regular expressions are very mighty, but they are slow compared to the other rules. So you may consider the following tips.

If you only match two characters use Detect2Chars instead of StringDetect. The same applies to DetectChar.
Regular expressions are easy to use but often there is another much faster way to achieve the same result. Consider you only want to match the character #if it is the first character in the line. A regular expression based solution would look like this:

You can achieve the same much faster in using:
```
<DetectChar attribute="Macro" context="macro" char="#" firstNonSpace="true" /> 
```
If you want to match the regular expression ‘^#’ you can still use DetectChar with the attribute column=”0″. The attribute column counts character based, so a tabulator still is only one character.

You can switch contexts without processing characters. Assume that you want to switch context when you meet the string /*, but need to process that string in the next context. The below rule will match, and the lookAheadattribute will cause the highlighter to keep the matched string for the next context.
Use DetectSpaces if you know that many whitespaces occur.
Use DetectIdentifier instead of the regular expression ‘[a-zA-Z_]\w*’.
Use default styles whenever you can. This way the user will find a familiar environment.
Look into other XML-files to see how other people implement tricky rules.
You can validate every XML file by using the command xmllint --dtdvalid language.dtd mySyntax.xml.
If you repeat complex regular expression very often you can use ENTITIES. Example: <?xml version=“1.0” encoding=“UTF-8”?> <!DOCTYPE language SYSTEM “language.dtd” [ <!ENTITY myref “[A-Za-z:][\w.:-]*“> ]>

Now you can use &myref; instead of the regular expression.

Writing a Kate Plugin

Tue, 06 Jan 2004 15:50:59 +0000

Introduction

First at all, why writing plugins for an editor ? Good question, and I hope I have a good answer: Because we want Kate to be small and all extended features not all users need should go into plugins (like CVS suppport, project managment, coffee cooking ;) Therefore Kate provides a quite full-featured plugin interface and interfaces to all important stuff in the Kate application (the documents, views, windows, sidebar …).

This tutorial is for people knowing the Qt/KDE libraries and will not describe how to compile, make … a kde/qt application/library in detail.

The “helloworld” plugin which is here described can be found in the “kdesdk” package of kde (located in kdesdk/kate/plugins/helloworld). A detailed description of the Kate API is available here..

Coding example: The Konsole plugin

This is one of standard plugins shipped with Kate which embeds the awesome KonsolePart into it to have a nice terminal emulator around.

Needed files for a plugin

Each plugin consists of at least three files which are needed:

a desktop file with some information about the plugin (correct syntax described later – named like kate”pluginname”.desktop
a XmlGui rc file named ui.rc
a library containing the plugin (named like kate”pluginname”plugin)

About the desktop file

The desktop file needs the syntax shown here and must be located in kde services directory with the name kate”yourpluginname”.desktop,

Example: katekonsoleplugin.desktop

[Desktop Entry]
Type=Service
ServiceTypes=Kate/Plugin
X-KDE-Library=katekonsoleplugin
X-Kate-Version=2.8
Name=Terminal tool view
Comment=Toolview embedding a terminal widget
X-Kate-MajorProfiles=Kate
X-Kate-MinorProfiles=*

The “X-Kate-Version=2.8” line is important! Kate for KDE 4 and up won’t load your plugin unless the property is similar to the version with which you want to use the plugin!

To install this desktop file to KDE’s services directory, we’ll later add the following line to the CMakeLists.txt file:

install( FILES katekonsoleplugin.desktop  DESTINATION  ${SERVICES_INSTALL_DIR} )

About the xmlGUI rc file

The xmlgui resource file describes how the menu and toolbar actions appear in the Kate application. For more detailed examples look into other plugins. The ui.rc file for the katekonsoleplugin looks like this:

<!DOCTYPE kpartgui>
<gui name="katekonsole" library="katekonsoleplugin" version="3">
<MenuBar>
<Menu name="tools"><text>&Tools</text>
<Action name="katekonsole_tools_pipe_to_terminal" group="tools_operations"/>
<Action name="katekonsole_tools_sync" group="tools_operations"/>
<Action name="katekonsole_tools_toggle_focus" group="tools_operations"/>
</Menu>
</MenuBar>
</gui>

To automatically install the ui.rc file into the right directory later we add the following line to CMakeLists.txt:

install( FILES ui.rc  DESTINATION  ${DATA_INSTALL_DIR}/kate/plugins/katekonsole )

About plugin lib

Each Kate plugin is a library which Kate will dynamically load on demand via KLibLoader. The name of the library is kate”yourpluginname”plugin.so and should be installed into KDE’s plugin directory.

The complete result for the file CMakeLists.txt looks like this:

########### compile and link and install plugin library ###############
set(katekonsoleplugin_PART_SRCS kateconsole.cpp )
kde4_add_plugin(katekonsoleplugin ${katekonsoleplugin_PART_SRCS})
target_link_libraries(katekonsoleplugin  ${KDE4_KDEUI_LIBS} ${KDE4_KPARTS_LIBS} kateinterfaces )
install(TARGETS katekonsoleplugin  DESTINATION ${PLUGIN_INSTALL_DIR} )
########### install support files ###############
install( FILES ui.rc  DESTINATION  ${DATA_INSTALL_DIR}/kate/plugins/katekonsole )
install( FILES katekonsoleplugin.desktop  DESTINATION  ${SERVICES_INSTALL_DIR} )

Start the real coding ;)

Now we can start with the real coding, The Konsole plugin consists of 2 files, kateconsole.cpp and .h.

The plugin header file – kateconsole.h

#ifndef __KATE_CONSOLE_H__
#define __KATE_CONSOLE_H__
#include <kate/plugin.h>
#include <kate/mainwindow.h>
#include <kate/pluginconfigpageinterface.h>
#include <kurl.h>
#include <kxmlguiclient.h>
#include <kvbox.h>
#include <QList>
class QShowEvent;
namespace KParts
{
class ReadOnlyPart;
}
namespace KateMDI
{
}
class KateConsole;
class KateKonsolePluginView;
class KateKonsolePlugin: public Kate::Plugin, public Kate::PluginConfigPageInterface
{
Q_OBJECT
Q_INTERFACES(Kate::PluginConfigPageInterface)
friend class KateKonsolePluginView;
public:
explicit KateKonsolePlugin( QObject* parent = 0, const QList<QVariant>& = QList<QVariant>() );
virtual ~KateKonsolePlugin();
Kate::PluginView *createView (Kate::MainWindow *mainWindow);
// PluginConfigPageInterface
uint configPages() const { return 1; };
Kate::PluginConfigPage *configPage (uint number = 0, QWidget *parent = 0, const char *name = 0);
QString configPageName (uint number = 0) const;
QString configPageFullName (uint number = 0) const;
KIcon configPageIcon (uint number = 0) const;
void readConfig();
QByteArray previousEditorEnv() {return m_previousEditorEnv;}
private:
QList<KateKonsolePluginView*> mViews;
QByteArray m_previousEditorEnv;
};
class KateKonsolePluginView : public Kate::PluginView
{
Q_OBJECT
public:
/**
* Constructor.
*/
KateKonsolePluginView (KateKonsolePlugin* plugin, Kate::MainWindow *mainWindow);
/**
* Virtual destructor.
*/
~KateKonsolePluginView ();
void readConfig();
private:
KateKonsolePlugin *m_plugin;
KateConsole *m_console;
};
/**
* KateConsole
* This class is used for the internal terminal emulator
* It uses internally the konsole part, thx to konsole devs :)
*/
class KateConsole : public KVBox, public Kate::XMLGUIClient
{
Q_OBJECT
public:
/**
* construct us
* @param mw main window
* @param parent toolview
*/
KateConsole (KateKonsolePlugin* plugin, Kate::MainWindow *mw, QWidget* parent);
/**
* destruct us
*/
~KateConsole ();
void readConfig();
/**
* cd to dir
* @param url given dir
*/
void cd (const KUrl &url);
/**
* send given text to console
* @param text commands for console
*/
void sendInput( const QString& text );
Kate::MainWindow *mainWindow()
{
return m_mw;
}
public Q_SLOTS:
/**
* pipe current document to console
*/
void slotPipeToConsole ();
/**
* synchronize the konsole with the current document (cd to the directory)
*/
void slotSync();
/**
* When syncing is done by the user, also show the terminal if it is hidden
*/
void slotManualSync();
private Q_SLOTS:
/**
* the konsole exited ;)
* handle that, hide the dock
*/
void slotDestroyed ();
/**
* construct console if needed
*/
void loadConsoleIfNeeded();
/**
* set or clear focus as appropriate.
*/
void slotToggleFocus();
protected:
/**
* the konsole get shown
* @param ev show event
*/
void showEvent(QShowEvent *ev);
private:
/**
* console part
*/
KParts::ReadOnlyPart *m_part;
/**
* main window of this console
*/
Kate::MainWindow *m_mw;
/**
* toolview for this console
*/
QWidget *m_toolView;
KateKonsolePlugin *m_plugin;
};
class KateKonsoleConfigPage : public Kate::PluginConfigPage {
Q_OBJECT
public:
explicit KateKonsoleConfigPage( QWidget* parent = 0, KateKonsolePlugin *plugin = 0 );
virtual ~KateKonsoleConfigPage()
{}
virtual void apply();
virtual void reset();
virtual void defaults()
{}
private:
class QCheckBox *cbAutoSyncronize;
class QCheckBox *cbSetEditor;
KateKonsolePlugin *mPlugin;
};
#endif
// kate: space-indent on; indent-width 2; replace-tabs on;

The plugin source file – kateconsole.cpp

#include "kateconsole.h"
#include "kateconsole.moc"
#include <kicon.h>
#include <kiconloader.h>
#include <ktexteditor/document.h>
#include <ktexteditor/view.h>
#include <kde_terminal_interface.h>
#include <kshell.h>
#include <kparts/part.h>
#include <kaction.h>
#include <kactioncollection.h>
#include <KDialog>
#include <kurl.h>
#include <klibloader.h>
#include <klocale.h>
#include <kdebug.h>
#include <kmessagebox.h>
//Added by qt3to4:
#include <QShowEvent>
#include <QLabel>
#include <QCheckBox>
#include <QVBoxLayout>
#include <kpluginloader.h>
#include <kaboutdata.h>
#include <kpluginfactory.h>
#include <kauthorized.h>
K_PLUGIN_FACTORY(KateKonsoleFactory, registerPlugin<KateKonsolePlugin>();)
K_EXPORT_PLUGIN(KateKonsoleFactory(KAboutData("katekonsole","katekonsoleplugin",ki18n("Konsole"), "0.1", ki18n("Embedded Konsole"), KAboutData::License_LGPL_V2)) )
KateKonsolePlugin::KateKonsolePlugin( QObject* parent, const QList<QVariant>& ):
Kate::Plugin ( (Kate::Application*)parent )
{
m_previousEditorEnv=qgetenv("EDITOR");
if (!KAuthorized::authorizeKAction("shell_access"))
{
KMessageBox::sorry(0, i18n ("You do not have enough karma to access a shell or terminal emulation"));
}
}
KateKonsolePlugin::~KateKonsolePlugin()
{
::setenv( "EDITOR", m_previousEditorEnv.data(), 1 );
}
Kate::PluginView *KateKonsolePlugin::createView (Kate::MainWindow *mainWindow)
{
KateKonsolePluginView *view = new KateKonsolePluginView (this, mainWindow);
return view;
}
Kate::PluginConfigPage *KateKonsolePlugin::configPage (uint number, QWidget *parent, const char *name)
{
Q_UNUSED(name)
if (number != 0)
return 0;
return new KateKonsoleConfigPage(parent, this);
}
QString KateKonsolePlugin::configPageName (uint number) const
{
if (number != 0) return QString();
return i18n("Terminal");
}
QString KateKonsolePlugin::configPageFullName (uint number) const
{
if (number != 0) return QString();
return i18n("Terminal Settings");
}
KIcon KateKonsolePlugin::configPageIcon (uint number) const
{
if (number != 0) return KIcon();
return KIcon("utilities-terminal");
}
void KateKonsolePlugin::readConfig()
{
foreach ( KateKonsolePluginView *view, mViews )
view->readConfig();
}
KateKonsolePluginView::KateKonsolePluginView (KateKonsolePlugin* plugin, Kate::MainWindow *mainWindow)
: Kate::PluginView (mainWindow),m_plugin(plugin)
{
// init console
QWidget *toolview = mainWindow->createToolView ("kate_private_plugin_katekonsoleplugin", Kate::MainWindow::Bottom, SmallIcon("utilities-terminal"), i18n("Terminal"));
m_console = new KateConsole(m_plugin, mainWindow, toolview);
// register this view
m_plugin->mViews.append ( this );
}
KateKonsolePluginView::~KateKonsolePluginView ()
{
// unregister this view
m_plugin->mViews.removeAll (this);
// cleanup, kill toolview + console
QWidget *toolview = m_console->parentWidget();
delete m_console;
delete toolview;
}
void KateKonsolePluginView::readConfig()
{
m_console->readConfig();
}
KateConsole::KateConsole (KateKonsolePlugin* plugin, Kate::MainWindow *mw, QWidget *parent)
: KVBox (parent), Kate::XMLGUIClient(KateKonsoleFactory::componentData())
, m_part (0)
, m_mw (mw)
, m_toolView (parent)
, m_plugin(plugin)
{
QAction* a = actionCollection()->addAction("katekonsole_tools_pipe_to_terminal");
a->setIcon(KIcon("utilities-terminal"));
a->setText(i18nc("@action", "&Pipe to Terminal"));
connect(a, SIGNAL(triggered()), this, SLOT(slotPipeToConsole()));
a = actionCollection()->addAction("katekonsole_tools_sync");
a->setText(i18nc("@action", "S&ynchronize Terminal with Current Document"));
connect(a, SIGNAL(triggered()), this, SLOT(slotManualSync()));
a = actionCollection()->addAction("katekonsole_tools_toggle_focus");
a->setIcon(KIcon("utilities-terminal"));
a->setText(i18nc("@action", "&Focus Terminal"));
connect(a, SIGNAL(triggered()), this, SLOT(slotToggleFocus()));
m_mw->guiFactory()->addClient (this);
readConfig();
}
KateConsole::~KateConsole ()
{
m_mw->guiFactory()->removeClient (this);
if (m_part)
disconnect ( m_part, SIGNAL(destroyed()), this, SLOT(slotDestroyed()) );
}
void KateConsole::loadConsoleIfNeeded()
{
if (m_part) return;
if (!window() || !parentWidget()) return;
if (!window() || !isVisibleTo(window())) return;
KPluginFactory *factory = KPluginLoader("libkonsolepart").factory();
if (!factory) return;
m_part = static_cast<KParts::ReadOnlyPart *>(factory->create<QObject>(this, this));
if (!m_part) return;
// start the terminal
qobject_cast<TerminalInterface*>(m_part)->showShellInDir( QString() );
KGlobal::locale()->insertCatalog("konsole");
setFocusProxy(m_part->widget());
m_part->widget()->show();
connect ( m_part, SIGNAL(destroyed()), this, SLOT(slotDestroyed()) );
slotSync();
}
void KateConsole::slotDestroyed ()
{
m_part = 0;
// hide the dockwidget
if (parentWidget())
{
m_mw->hideToolView (m_toolView);
m_mw->centralWidget()->setFocus ();
}
}
void KateConsole::showEvent(QShowEvent *)
{
if (m_part) return;
loadConsoleIfNeeded();
}
void KateConsole::cd (const KUrl &url)
{
sendInput("cd " + KShell::quoteArg(url.path()) + '\n');
}
void KateConsole::sendInput( const QString& text )
{
loadConsoleIfNeeded();
if (!m_part) return;
TerminalInterface *t = qobject_cast<TerminalInterface *>(m_part);
if (!t) return;
t->sendInput (text);
}
void KateConsole::slotPipeToConsole ()
{
if (KMessageBox::warningContinueCancel
(m_mw->window()
, i18n ("Do you really want to pipe the text to the console? This will execute any contained commands with your user rights.")
, i18n ("Pipe to Terminal?")
, KGuiItem(i18n("Pipe to Terminal")), KStandardGuiItem::cancel(), "Pipe To Terminal Warning") != KMessageBox::Continue)
return;
KTextEditor::View *v = m_mw->activeView();
if (!v)
return;
if (v->selection())
sendInput (v->selectionText());
else
sendInput (v->document()->text());
}
void KateConsole::slotSync()
{
if (m_mw->activeView() ) {
if ( m_mw->activeView()->document()->url().isValid()
&& m_mw->activeView()->document()->url().isLocalFile() ) {
cd(KUrl( m_mw->activeView()->document()->url().directory() ));
} else if ( !m_mw->activeView()->document()->url().isEmpty() ) {
sendInput( "### " + i18n("Sorry, can not cd into '%1'", m_mw->activeView()->document()->url().directory() ) + '\n' );
}
}
}
void KateConsole::slotManualSync()
{
slotSync();
if ( ! m_part || ! m_part->widget()->isVisible() )
m_mw->showToolView( parentWidget() );
}
void KateConsole::slotToggleFocus()
{
QAction *action = actionCollection()->action("katekonsole_tools_toggle_focus");
if ( ! m_part ) {
m_mw->showToolView( parentWidget() );
action->setText( i18n("Defocus Terminal") );
return; // this shows and focuses the konsole
}
if ( ! m_part ) return;
if (m_part->widget()->hasFocus()) {
if (m_mw->activeView())
m_mw->activeView()->setFocus();
action->setText( i18n("Focus Terminal") );
} else {
// show the view if it is hidden
if (parentWidget()->isHidden())
m_mw->showToolView( parentWidget() );
else // should focus the widget too!
m_part->widget()->setFocus( Qt::OtherFocusReason );
action->setText( i18n("Defocus Terminal") );
}
}
void KateConsole::readConfig()
{
disconnect( m_mw, SIGNAL(viewChanged()), this, SLOT(slotSync()) );
if ( KConfigGroup(KGlobal::config(), "Konsole").readEntry("AutoSyncronize", false) )
connect( m_mw, SIGNAL(viewChanged()), SLOT(slotSync()) );
if ( KConfigGroup(KGlobal::config(), "Konsole").readEntry("SetEditor", false) )
::setenv( "EDITOR", "kate -b",1);
else
::setenv( "EDITOR", m_plugin->previousEditorEnv().data(), 1 );
}
KateKonsoleConfigPage::KateKonsoleConfigPage( QWidget* parent, KateKonsolePlugin *plugin )
: Kate::PluginConfigPage( parent )
, mPlugin( plugin )
{
QVBoxLayout *lo = new QVBoxLayout( this );
lo->setSpacing( KDialog::spacingHint() );
cbAutoSyncronize = new QCheckBox( i18n("&Automatically synchronize the terminal with the current document when possible"), this );
lo->addWidget( cbAutoSyncronize );
cbSetEditor = new QCheckBox( i18n("Set &EDITOR environment variable to 'kate -b'"), this );
lo->addWidget( cbSetEditor );
QLabel *tmp = new QLabel(this);
tmp->setText(i18n("Important: The document has to be closed to make the console application continue"));
lo->addWidget(tmp);
reset();
lo->addStretch();
connect( cbAutoSyncronize, SIGNAL(stateChanged(int)), SIGNAL(changed()) );
connect( cbSetEditor, SIGNAL(stateChanged(int)), SIGNAL(changed()) );
}
void KateKonsoleConfigPage::apply()
{
KConfigGroup config(KGlobal::config(), "Konsole");
config.writeEntry("AutoSyncronize", cbAutoSyncronize->isChecked());
config.writeEntry("SetEditor", cbSetEditor->isChecked());
config.sync();
mPlugin->readConfig();
}
void KateKonsoleConfigPage::reset()
{
KConfigGroup config(KGlobal::config(), "Konsole");
cbAutoSyncronize->setChecked(config.readEntry("AutoSyncronize", false));
cbSetEditor->setChecked(config.readEntry("SetEditor", false));
}
// kate: space-indent on; indent-width 2; replace-tabs on;

How does the Plugin look & work after install ?

You first have to go to the Settings -> Configure Kate -> Kate -> Plugins in Kate and activate the Konsole plugin.

More information ? Advanced plugin stuff ?

To get more information about the plugin interface and its advanced functions please look at the Kate API documentation and the KTextEditor API documentation or contact us on our mailing list!

Kate | Get an Edge in Editing

External Tools Plugin is Back

Support for Variables

List of Default Tools

git-cola

gitk

git blame

Run Shell Script

Google Selected Text

Insert UUID

Clang Format Full File

Clang Format Selected Text

Qt Quick 2 Preview (qmlscene)

Kate in the Windows Store

Kate got submitted to the Windows Store

Kate Planning

The Opportunity

The Rough Ideas

Kate Plugin Interfaces

Make Projects a Core-Feature

LSP Support per default

Great code navigation

Consolidate the plugins

External Tools Plugin

Improve Port to KSyntaxHighlighting

Further Brainstorming

Git Integration

Diff/Patch Viewer

Improve View Management

KDevelop vs. Kate?

Discussion

KSyntaxHighlighting - Over 300 Highlightings...

Kate - Document Preview Plugin - Maintainer Wanted!

Kate - More languages supported via LSP!

Configuration

Currently supported configuration keys

use

command

commandDebug

rootIndicationFileNames

url

Current State

Kate - Initial Rust LSP support landed!

kate-editor.org Update

Kate LSP Status – July 22

Kate LSP Status – July 21

Kate LSP Client Continued

Kate LSP Client Restart

Kate & C++ Developer Survey

KTextEditor/Kate Bugs – Scratch Your Own Itch

KTextEditor/Kate Bugs – Help Appreciated

Kate LSP Client Progress

Kate Language Server Protocol Client

Qt Creator 4.9 uses KSyntaxHighlighting

Removing Files from Git History

Kate History – KDE 4 Porting

Web-Server Transition

Privacy and Hugo Themes

Hugo Extended on CentOS 7

New Website

MIT licensed KSyntaxHighlighting usage

Support KDE via AmazonSmile

Who is Hiring?

Kate projects and out-of-source builds

Kate gains Support for Inline Notes

Akademy 2018 Wrap-Up

Akademy & Binary Factory

Porting KTextEditor to KSyntaxHighlighting => Done :=)

Downloading Kate Highlighting Files

Porting KTextEditor to KSyntaxHighlighting – Folding

Porting KTextEditor to KSyntaxHighlighting

Going to Akademy, too ;)

Going to Akademy

Improving Syntax Highlighting Files

Article about cmake

Rendering issues and the power of open source

Fancy Terminal Prompt

Tracking KDE Development

Syntax Highlighting Checker

New Kate on Windows installer