Category Archives: Users

GSoC 2011 – Kate Code Folding – week 3 (Folding algorithm started)

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

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 .gdbinitqt4.py, libstdcxx.py and kde4.py.

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

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)

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 classes diagramsimplicity. 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<Nodes>, or a Set<row,Vector<Nodes>>.

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<row,Vector>. 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