Archive for the 'GSoC' Category

GSoC – The End

What We Have Done

So, Google Summer of Code has ended (more than a month ago, but I haven’t managed to write a wrap-up post since). It’s been great. Challenging though, but a nice and useful experience.

First of all, we have managed to have a usable and relevant GUI framework for handling searching of Nepomuk resources as well as displaying and editing them in either a generic or a customized way. As described in an earlier post, I wrote components such as a list widget for Nepomuk resources with its appropriate model and delegate, an editor to handle resources and their important properties using a plugin system (editing plugins are used based on the resource type), a flexible widget for editing single Nepomuk properties and other GUI elements.

Sebastian and I also implemented a flexible framework for faceted searching using Nepomuk search terms. (This has been changed since by Sebastian, switching to a revamped version of the old faceting approach used by Alessandro Silvieri, but I haven’t been able to check that out yet.)

Finally, the search GUI application built upon the API features a query editor, a facet widget and the list widget which provides the editing widgets for relevant displaying and editing of resources.


Not to flood the post with screenshots, I’m showing three relevant usage scenarios:

Example 1: The Result List

Simple searching based on two tags (latex and thesis) from the facets widget. It shows all resources having those two tags.

Notice that the label, description (grey text with italics, where applicable),  and resource type are displayed in the list for each item (icons are also displayed, but none of the items have them in this example)

Also, the available (but not shown) context menu actions on the items are Copy Label, Copy URI and Delete Resource.

Example 2: Displaying an Item

An item is expanded and displays relevant details, such as rating, tags or creation date.

When an item is expanded, it can be modified by either double-clicking on a value or by enabling editing mode for all the properties.

A resource can be saved or the values can be reverted.

Notice also the Actions menu which lists the available actions defined on a resource, such as the default Show Related Resources, or the custom-defined Reply to Email and Forward Email for Email resources.

Example 3: Editing a Property

Editing the hasTag property

Each value type has its own editor defined, such as a spinner for an int or a KDateTimePicker for a DateTime value, or a ResourceCreateAndSearchWidget for Resource values, etc.. If a user double clicks on a value, its editor is displayed.

In this case, the hasTag property can have multiple Resource objects, so you can see a widget for each of the tags (latex, work, thesis, testtag) and a + button at the bottom for adding a new resource.  Each widget allows for 1.) opening the corresponding resource for a more detailed examination, 2.) replacing the current one by creating a new one or searching for a resource of the give type, and 3.) removing it.

The End

Since GSoC ended, I haven’t been able to work on it at all because of two summer camps I’ve co-organized (a children’s camp and a youth camp, trying to present Christ’s love and forgiveness of sins and a blessed life in Him) and the time-consuming job-hunt I’ve been doing (writing the CV, looking for companies, writing cover letters, studying for a technical interview).

Sebastian has done a lot of work since, revamping the facet framework, preparing it all for Dolphin integration and for moving it to kdelibs. This is awesome and I’m really looking forward to see the end result.

Finally, I want to thank Sebastian for the great mentoring he’s done, also Evgeny for all the useful advices and assistance. It was nice to work with Artem and Vishesh who had nice ideas and occasional bug reports. The Nepomuk and KDE community in general were of big help as well. Of Course, gratitude go to Google for this great opportunity of being financially supported in working on an open-source project.

As for me, I’m not sure what the future holds. I would’ve been nice to continue to be involved with the project and with Nepomuk in general, but if I’ll start to work (and commute 54 km daily), I’m not sure I can pledge for that. It’s been a great 2.5 years, even if mostly just using it as a programmer, I always felt being part of KDE and Nepomuk.

GSoC – After Five Weeks

We are in the sixth week of the Google Summer of Code program, and so far it’s been both a challenge and a great experience to do development together with the Nepomuk-KDE team. In the meantime (last Friday) I have finally managed to submit my Masters thesis, and will be wrapping it up with a presentation given to my fellow researchers at DERI.

When I first set out undertaking this project, my mentors and I had two main goals and a third optional one. With this post I’d like to report on how and to what degree have we managed to accomplish the first two.

Displaying and Editing Items

I started with the second main task, i.e. displaying and editing items. For that we have decided on the following approach:

  • Have a custom Model, View and Delegate for Nepomuk items. The Delegate is expandable, and when it is expanded, a  ResourceEditWidget is used to handle (display and edit) a resource.
  • ResourceSearchWidget takes the above three, together with a query builder and a facets widget to provide a convenience widget for searching. It is used as the main GUI of the application as well as in PropertyEditWidget (see below).
  • The ResourceEditWidget displays the icon and rating and queries for a plugin based on the resource type. If a plugin is found, it is used, otherwise a generic fallback widget is created. The fallback widget uses PropertyEditWidget instances to display and edit properties (this can also be done by the custom plugins).
  • PropertyEditWidget is a widget for displaying and editing properties. For displaying (read-only mode), it uses the label or the value of the properties, based on the type. For editing, it provides a custom editor, based on the range type of the property.  The editor’s behaviour depends on whether we have a single value or multiple values for the given property:
    • For single values, it is quite simple. If we have a date range, it will display a KDatePicker, for a string it creates a KLineEdit, in case of an int it uses a spinner, and so on. For non-literal resources it creates a widget that allows to add a new resource (using NewResourceDialog from nepomukutils) or search for an existing one (using ResourceSearchWidget).
    • For multiple values, the approach is based on the first one: for each of the values it creates a disabled editor and a – (remove) button, and places a + (add) button at the bottom. Thus, values can be removed or new ones can be added.
Displaying a Task item

Displaying a Task item using its custom plugin

Editing a File item

Editing a File item using the generic fallback

Query building

At the beginning we didn’t exactly know what approach this query builder should take, but in the meantime we figured out that it will actually be quite simple: take the search widget that has a query editor, a widget with facets and a widget displaying the resulting items. The user can the query customizing the query editor and the facets widget, until they are happy with the result, thus having built the desired query.

Now, this can be extended with adding more advanced features, like auto-completion to the query editor, or one could even take the main components making up the search widget and manually assemble them to fit one’s own purposes.

What’s next?

The following immediate steps will be to polish the editing of multiple values, perform general cleanup on the core display/edit mechanism and the UI, implement the facets widget and create custom plugins.

It also seems like there will be time for other things, such as to deal with the third main goal (to define custom actions on the resources) and other cool stuff Sebastian or Evgeny come up with.

GSoC Vision

Nepomuk Dedicated Desktop Search GUI – after “wild discussions” and deep pondering I now have an overall picture of what this actually means, and what I want to accomplish this summer with my Google Summer of Code project.
As Sebastian described it, my project wants to provide a satisfying search experience on KDE using Nepomuk mainly consists of three reusable parts:

  1. A query builder: this component will reuse the work of Addam Kidder’s GSoC 2009 work, and the subsequent Dolphin integration by Peter Penz. I’m not sure to what degree, but we’ve been discussing changes to this, so I’m not sure yet what direction is this going in.
  2. A result displaying widget: this widget aims to display items in a more relevant way, displaying essential information (like properties and snippets for emails, details for contact items, etc.). It will have a custom ItemDelegate that can be reused in Dolphin, but it might have more fancy stuff too, like KMail-style grouping.
  3. A way to properly open the presented results (using appropriate applications). As Sebastian said, hopefully I’ll have time to “attack” this issue as well.

As a final word, I am thankful for this opportunity and I want to thank the Nepomuk KDE mentors (Sebastian Trüg and Evgeny “Phreedom” Egorochkin) for the acceptance, Google for making this possible and not least to God from whom all blessings come.

Now on to making those 3 months count!