Skip to content
June 22, 2012 / thebengaliheart

GSOC Progress Report

I am working under Ankur India for this GSoC, trying to bring easy localization support for programs which do not use gettext. In essence, this means, for Mozilla applications (like Thunderbird, Seamonkey, Firefox), all android applications, it will be easier to make them available to people who want to use it in some other language than English. Initially, the idea is to write a library that allows us to do this easily by performing queries for finding the localized string for a specific locale and making some simple calls to update the translation of a string. This library will then be integrated into Lokalize. The library needs to be written in a reusable way, so I am writing the library in GLib, so that other translation applications, which use C, like gtranslator, can also make use of it for providing localization support for non .po files. The idea is to make the library support file format plugins, or backends. There will be a backend for Mozilla DTD files, one for Mozilla properties files. Both of these are used by applications like Firefox for localization. There will also be backends for stuff like android app string resources, and apple .string files, but for now, the first two backends are the primary targets.

For integrating into Lokalize, I am probably going to create a Qt wrapper around my library (which is named bong), and then use that wrapper from within Lokalize. I have been able to implement .properties file read and write in my library, along with localization notes. Right now, I am working on the Mozilla DTD file format backend. As a side experiment, I have written a version of the library in C++ using Qt from scratch. It is an alternative port of the library in Qt, with the same functionality, just written in Qt. It already has both properties and DTD file format support. Also, I am working on  creating a backend in Lokalize that is able to use our library.
I am really looking forward to completion of my project, since the localization scenario in the free software community is going to vastly improve, with all kinds of applications which do not use gettext (among them, the thousands of android applications that are written every week) becoming easily localizable through Lokalize, the KDE translation tool. And along with the excellent features of Lokalize, it will be a much better and easier experience for translators.
Looking forward to your comments, suggestions, and encouraging words.
January 8, 2012 / thebengaliheart

KDE 4.8 Release Party in Durgapur, India

A very long time since my last blog post. This is to inform everyone that NIT Durgapur GLUG is organizing its FOSS festival, Mukti ’12 from February 3 to 5. The fest will be a good learning experience for those starting out with free software, and introduce them to a lot of areas in which they can make a difference. There are beginner as well as intermediate workshops on getting started with KDE development, Android development, internationalization and localization, and documentation. We have organized an overnight hackfest where we will produce lots of code and fix many bugs while having loads of fun and frolic.

And here comes the best part – we will celebrate the KDE 4.8 Release Party during Mukti. So people who will be in and around West Bengal are invited to come to the party and make it a wonderful experience with food, fun, jokes and code.
July 18, 2011 / thebengaliheart

Kpaste – a friend for the lazy

I often work on vi, and also do a lot of work through the konsole. At such times, selecting the entire code, copying it, and pasting it on paste.kde.org seems like … uhm… too much work. The plasma pastebin applet offers a nice alternative, it has support for multiple backends(even image uploads). But even then, i have to select the text and drag-drop it on the applet. Most often, its a trouble to do this with text from konsole. Also, its too much work to use a mouse (I know there are people who are as lazy as me, and find typing letters at the keyboard easier than playing with the mouse 🙂 ).

Without further ado, I present KPaste, a simple command-line tool to paste to paste.kde.org. It supports both GET and POST, clipboard input and output, automatic retries, and a little syntax detection (if you are pasting files).
Use it like
$ git diff | kpaste
this pipes the output of git diff to kpaste
$ kpaste abc.cpp -x
this pastes abc.cpp (while correctly detecting syntax from filename), and prompts for a password for the paste(-x does it).
or
$ kpaste -i -o
this will paste your clipboard, and give the url back to your clipboard.

you may paste text directly like this …

$ kpaste -l python
1..2..3..testing...testing
^D

I just started with it, so I am sure it has many bugs. Would be great if everyone tests it out and helps with the code. I also plan support for multiple paste backends, but at the moment, paste.kde.org is hardcoded into it. I also need translations and documentation (a man page), so anyone offering to help is most welcome. Not to forget, a large part of the functionality and code is influenced by the fpaste tool by FedoraUnity used for posting to fpaste.org.
Thanks in advance for help with coding, testing, documentation and translations, or just rendering it useful by assimilating it as a tool for your work routine. Just let me know if it made your day 🙂

Edit: As pointed out by estan, I forgot to mention where the code is 😉
git://anongit.kde.org/kpaste.git
July 6, 2011 / thebengaliheart

A post to test my hackergotchi

I created a hackergotchi for myself in Krita yesterday using the particle brush, and I’m posting this to see how it looks on the planet 😉

June 13, 2011 / thebengaliheart

GSOC Rekonq – A Screenshot

As some of you may know, I am working to implement tab grouping in Rekonq using a Panorama view. After so many days of not blogging, I thought I should post an update. I have a screenshot to show. Not very attractive though, looks very very blank, but its still something. At this stage, Rekonq just shows the sessions and thumbnails of the tab – including the deactivated ones. I haven’t been able to find a nice way to show the deactivated sessions – i know it looks clumsy 🙂 Right now I am working on beautifying the UI, using QGraphicsView for it. Any cool UI ideas are welcome. Here’s the screenshot

And here’s how the session file for the same is stored internally

<!DOCTYPE sessionFile>
<sessionFile>
  <session title="" active="true">
    <tab title="Maths 'N' Tech Club | NIT Durgapur" url="http://localhost/mntc/"/>
    <tab title="Fedora Project Homepage" url="http://fedoraproject.org/"/>
    <tab title="Downloads" current="true" url="about:downloads"/>
    <tab title="Test Page for the Apache HTTP Server on Fedora" url="http://localhost/"/>
  </session>
  <session title="" current="true">
    <tab title="Twitter / Home" url="http://twitter.com/"/>
    <tab title="Bookmarks" current="true" url="about:bookmarks"/>
  </session>
  <session title="" active="true">
    <tab title="Planet KDE" current="true" url="http://planetkde.org/"/>
  </session>
</sessionFile>

Do send in your awesome ideas/criticism that might help me improve 🙂

June 2, 2011 / thebengaliheart

GSOC – Tab grouping in Rekonq

I’m writing this to blog about my progress, though there is nothing much spectacular to blog about. One great thing is, a first version of the backend code for session management is in place now. Sadly, there is no UI yet to access it. Now I am working on the UI written using QGraphicsView. Hope I’ll be able to come out with something usable in a week. Also, I and my mentor Pierre Rossi were discussing about storing the session data inside Nepomuk instead of storing them locally. We decided to mark this as a TODO for after the initial commit.

Bye Planet folks! Hope to blog again soon.

May 14, 2011 / thebengaliheart

Live and Dead sessions

I have come up with this model as the solution to the problem of persistent session storage and tab grouping –

Sessions in Rekonq will be of two types – dead sessions and live sessions. Sessions of both kinds will be showed in a unified panorama-view

a sketch of the panorama view

Let me describe each kind of session in detail –

  1. Dead sessions – These are displayed as grayed-out in the panorama view. Basically, the dead session views are read-only, so that one can have a look at the tabs in it. These sessions are not yet loaded. When we click on the load button, the session gets loaded in Rekonq and opens up in a new window. Now the dead session becomes a live session.
  2. Live sessions – These sessions correspond to open windows. When a new window opens, a live session starts. Dead sessions can be loaded to live sessions, whilst creating a window and opening all the tabs of that session in it. Tabs can be closed or drag-dropped in the panorama view between live sessions. Since live sessions can be mapped to windows, any changes in the window affects the live session, and vice-versa. When a window is closed, its live session becomes a dead session. This can also be done through a panorama view. We can also add new live sessions from the panorama view. The sessions that were live when Rekonq was closed are loaded as live sessions automatically when Rekonq starts the next time.

This hybrid system of managing sessions has quite a few advantages over traditional session management like in Kate or Konqueror –

  1. Tab grouping is made easy. When the tab clutter increases, one can go to the panorama view, create a new session, and drag-drop tabs into it.
  2. The division of tabs into activities like ‘work’, ‘study’, ‘games’ can take place using sessions, while loading only the ones relevant at a time. Thus memory and bandwidth is saved by not needing to have all tabs open at once.
May 14, 2011 / thebengaliheart

Thoughts about tab grouping in Rekonq

I was reflecting upon the options I have as to in what manner exactly will I implement tab grouping into Rekonq. I have come up with three possibilities –

  1. Use the Kate / Konqueror model for sessions. The sessions will be collections of tabs, and will load into separate windows. One must explicitly save a session for the tabs to be remembered for next time. The tabs in the sessions do not have correspondence to the actual tab instances. There will be some added eyecandy to modify the sessions, by providing a panorama view to drag / drop tabs between sessions, or remove tabs, without actually loading the session. I do not feel this is of much use. Here are a few reasons why –
    • Being allowed to drag-drop or delete tabs from sessions is very useless without actually opening it.
    • The big reason is, the purpose of tab grouping isn’t actually served in this model. Even if I am able to store or load sessions, what do I achieve? The main reason for tab grouping is that a user keeps clicking and surfing at will, opening more and more tabs till he can’t manage them. This is where a web browser differs from a text editor. Changes in it happen dynamically, and the need for grouping is dynamic and instantaneous. The moment I feel that I am having too many tabs, I should be able to move a few of them to another tab group, clearing up the clutter. A user may have his tabs organized under work, play, school, but when one starts browsing, our surfing patterns hardly follows that organization. We click on links here and there, and may soon land up in an article on the lastest android app in market while in the school session. Now, i have no way to clear the clutter of so many tabs. Most I can do is, save the session, close it, then drag its tabs one by one into another session. Seems astoundingly foolish right? I have come to the conclusion that web browsers, being totally different from text editors or other static applications, require dynamic sessions, that is, sessions that are changed on-the-fly and have a direct way to clear the tab clutter.
  2. The above point brings me to my next option, a similar implementation, but dynamic. Here all sessions will be loaded when the app is loaded. Thus, the sessions stop behaving as sessions, and are better suited to be called tab groups. These tab groups are one per window. We offer the same glossy panorama view to change the tab groups, but here, each tab in the tab group is directly associated with a WebTab instance. That is, since all changes in tabs are immediately stored to the individual tab groups, so each tab in the tab group actually reflects a current tab. Thus, I can now drag/drop tabs between sessions to reduce the clutter, beautifully managing them. Also I do not need to worry about explicitly storing my changes everytime I add a new tab so that I can see it next time I open rekonq.
  3. The third option is amost like the second one, but allows for multiple tab groups per window. This would make the eye-candly look all the more catchy I suppose, but would cause the session management code to become unnecessarily complex. Also, I need to keep track of detached tabs which will not be visible in the KTabWidget. Every addition of a tab into a window would require a process of selecting an appropriate group first. Not to mention, this would cause huge changes in the codebase.

As has been apparent in my judgement of the three options, I prefer the second one more currently. I will still think on it for some days. In the meanwhile please do put in your valuable suggestions.

May 9, 2011 / thebengaliheart

Option to disable KDE wallet in Rekonq

I have this habit, or paranoia rather, of not storing my passwords with the browser. I never let the browser remember passwords for me. Maybe this is because a lot of my friends use my laptop at times, and it becomes risky to have autologin on for websites. So whenever I use a browser, the first thing I do is turn off the ‘Offer to store passwords’ option or similar. I was sad that Rekonq, my favourite browser, did not have this feature. So I wrote this patch that adds a setting which allows the user to disable the notification saying "Do you want to store the …" by unchecking a checkbox. Here goes a screenshot –

Snapshot of the settings dialog

May 2, 2011 / thebengaliheart

Getting GSOC – the awesomest experience!

And finally my dream came true. I am a GSoCer now. Even though it sounds maybe like a GNOME game for soccer, I am going to work under KDE 🙂

My work is for Rekonq, the lightweight browser which is tightly integrated into KDE. It has been two months now since I’ve been using KDE, and it has been ~ 25 days since I wrote my first patch for Rekonq. My idea was original and not already there in the ideas list of KDE. I suggested it on the rekonq mailing list, and it was accepted.

WIll start with the preparations as soon as the exams are over. I’m keeping up with the community in the meantime.

Will come up with details of my project very soon, when my blog is added to planetkde.org. Till then, bye blog. Here is my proposal abstract:
http://www.google-melange.com/gsoc/project/google/gsoc2011/wyuka/12001

And here goes the link to my proposal, in case anyone wants to refer to a sample proposal while participating next time:
http://www.google-melange.com/gsoc/proposal/review/google/gsoc2011/wyuka/1