As it turns out, in 2010 I did my Computer Science final project about this subject, successfully implementing an HTML extension in KHTML that fixed what during one talk I was giving on the subject I coined to be the Server in the middle problem (project memory in spanish, code in github).

The solution I developed is just a proof of concept and not a final proposition. It basically extends the div element and input type=text element by adding two attributes, encryption=”gpg” and encryption-key=”<keyid>”, so that a div containing a gpg ascii encoded encrypted text is automatically decrypted shown the plaintext, and when a form with an encrypted input type=”text” element is sent, the data is automatically encrypted.

The key point about this proposition is twofold:

1. The security it provides is website-independent, you only need to trust the web browser.. It’s not possible using javascript, the DOM, CSS or any other tactics to access to the contents of the plaintext.
2. It’s easy to implement as an HTML extension that  could be standardized.

This is what makes the proposal differ from other approaches like the deceased FirePGP Mozilla Firefox extension, the javascript API that some web browsers like Mozilla Firefox provide for cryptographic primitives, or javascript libraries like Slow AES that currently provide cryptographic support for some websites that uses them.

I have spent this weekend updating the code to work in recent KDE versions and creating an ready-to-go usb live opensuse-based [1] appliance called “Server in the middle” that shows Sweeetter, a microblogging application that allows users to exchange messages using the aforementioned HTML extension. Check it out! it’s for you to test it =)

SSL was the first step for securing the web. End to end encryption is the next, and it will allow cloud applications like web chats, web mails, and even office apps in the cloud with privacy being orthogonal to the servers used. When you chat using gmail with your peers using HTTPS, there’s someone else listening: it’s Google. It’s the server that is in the middle by design. When a Los Angeles employee sends an email to another peer using Gmail, it ain’t Google’s business.  Perhaps if an end-to-end encryption scheme as proposed was available as a standard, Google would offer it in Gmail for businesses and for geeks like us , and certainly other service providers would.

I will say it again: what I proposed is just a proof of concept. We could perhaps encrypt whole forms in a similar manner, or  use a secure sandbox inside which plaintext data can be freely manipulated, but whose details are well known to the browser, are being recorded and the user can see in a details dialog, similar to the details of HTTPS connections in current web browsers, and the data going out from the sandbox is encrypted in a controlled and secure way.

The issue of privacy in the web will arise sooner or later. All the applications are jumping to the web wagon and some applications just need to be secure. It’s not only cryptonerds that need to take this seriously. Big companies that need their data to be secure will either continue using old-fashioned software, or request something better than we have now. This has already happened sooner than you might think (1999). Thus, we need to take this seriously, and begin standardizing and developing similar solutions to the one proposed for the shiny future that is about to come.

–

[1] BTW, SUSE Studio rocks!

And then the idea came out of the blue. QML could be (in my dreams the successor of HTML. I know, sounds crazy doesn’t it? That’s because it is crazy. So anyway, I wanted to test the concept, and today I coded this litle KPart called QmlPart that simply loads a .qml file into the KPart. The code is really minimal and it works beautifully, both in Konqueror and in rekonq, and loads fine both local and remote QML files and remote files, even if the QML application is divided in multiple files.

I am really surprised how easy it was to do this KPart. I uploaded to wadobo’s web server the Qt Declarative examples and most of them work out of the box with QmlPart. Here is a screencast:

Why would we want to make the web declarative? Because QML is much more powerful than HTML/CSS. Those of you that know QML will probably agree. HTML doesn’t even have a proper way to create column or row layouts. All kind of animations, transitions, states are easy-peasy in QML. And its object orientation is quite powerful, as they have properties, inheritance, etc. The web of 2011 can be much easily done in QML than in current web technologies.

What would be the path of action? This is just a proof of concept, and it might end here. Or it might not. If we get serious, we would first try to agree in a standard for a declarative web (talk to Gnome/ClutterScript guys), work in including this standard in web browsers, create a library in Javascript that allows loading declarative files as HTML/JS as a fallback for browsers without native declarative web support, and that way we can attract people to the platform, and then we would have something.

Either way, I had my fun today with this little kpart and all those crazy ideas around it. Mission accomplished.

The idea behind Cloud9 IDE is being able to develop javascript collaboratively  using only the web browser. It even supports debugging, but that’s because the browser actually can run javascript code itself. They plan to support syntax highlighting for more languages. They of course have a chat for those connected to the ide, and changes occur live to the code for everyone connected at the same time.

Gobby/Kobby are native (gnome, kde) collaborative editors which use the infinote protocol for collaborative editing. So you connect to a infinote server, and then you can see the files in that session, edit them, add/remove files, and chat with your colleagues.

None of those solutions provide real general purpose “cloud development” for me.  These are the features I¡m looking for:

• The server side is a bunch of machines in a cloud configuration which provide an API.
• The server side provides compilation for languages like C/C++.
• The server side provides inexpensive VMs that can be easily cloned/forked.
• When you create a new project in the cloud, a new VM is given to you, and you can configure it as you like. There you install the deps for your project development, download the source code, etc.
• The server side has an rich API and has knowledge of high level concepts like:
  • VMs that can be forked, and cloned, for creating new live sessions.
  • Compilation, which can be done quickly and distributedly in the cloud.
  • Execution, to be able to see and control remotely the execution and debugging of gui applications.
• The client side could as well be web app like with cloud9 ide, or it could be a native standalone application with “cloud development” support (Kdevelop, Eclipse, whatever..)

A simple cloud computing use case:

An Amarok developer configures a cloud development vm for trunk. Then he forks it, and creates a git branch in which he starts working in a new feature for amarok. This feature might need new libraries, difficult to compile. He doesn’t know much about how to use this library and it’s giving him headaches: he asks in the irc channel of #lib, and gives a link to clouddevelopment://kde.org/amarok/livesessions/featurex and the developer of libx sees the problem in the system while the amarok developer sees live how it’s getting resolved.

Then he posts in his blog about his new feature, and some other amarok developers think it’s really cool and connect to the feature branch’s live session and improve a bit the code, effortesly.
As you can see, this would mean,  among other things:

• No more “person1: it’s broken! person2: it works here”.
• No more pastebin: just connect to the live session and see (and even fix) the problem yourself.
• Configure the VM once, and then everyone can use it.
• You don’t need to install all the deps in your system.
• If your computer breaks, you don’t lose the data and configuration.
• You can access to different development environments that might require different versions of the same libs from your own computer, no dependency hell guaranteed, and no extra local disk usage.
• Compilation can be really fast and the speed of it would not depend on how powerful your computer is:  you can have preconfigured already in the VMs an icecream+ccache set of computers.
• You could develop for KDE in Mac OS X within Linux, or Windows, or whatever you want.

Of course this is just an idea… and I don’t currently have time for making it happen, but… wouldn’t it be nice? I thought I had to share it =)

I can’t resist to try, and here is why. The future is a sea of posibilities, and our mind is developed precisely to predict it. We are machines that are always classifying, archiving information and making relations between the data. Using this knowledge we can find out things about the world. Childs are bad understanding the speed of moving things, and that’s one of the reasons you should be careful letting a child cross the street. The other of course is that childs don’t understand that they need to focus on the important task of crossing the street, and even if they do, they don’t know what data should they be looking for and how to mine that data. With time and experience, we grow, and we can predict this kind of events much better and it also stops being something important.

Such a thing happens all the time. We learn something, and it becomes trivial, and suddently it’s boring stuff. But it’s much more difficult to learn anything if you didn’t experience it. That’s why learning history is so important. And even if you know history, you’ll probably not internalize it. Errors of the past will come over and over again by new people. And trial and error is often a very convenient and powerful way of learning with computers that everyone uses, but it’s not much so covenient in other matters.

Bottom line is, it’s very interesting to see how the predictions of these prominent people of the past failed. Sometimes reality surpassed their predictions, some others it came short. For example, Doctor Mayopredicted correctly that most infectius ailments would be minimized and controlled and most deaths would be due to heart issues, cancer, etc. He predicted 70 years of life expectancy in USA, and it’s now 77. However, these greats minds of the past predicted poverty will have ended, and that we would have an equitative wealth distribution, and it’s clear that it’s not the case.

When doing a prediction for the distant future, it’s difficult not fall into wishful thinking. Things changes faster than ever, and currently technology is indistinguishable from magic. Because of that, and that my field of expertise is that one related to Computers, that’s where I will make (most) predictions for: I have a better insight on it. However that will be more difficult for me, because as you know 80 in computers might be comparable to 5 centuries in other fields.

My predictions for 2091:

Privacy will be at the same time a very important legislated issue, and futile. Governments and private companies will have found unimaginable ways of cooperating for invading citiziens’ privacy, and still most people will think/find that it is for the good of them and cooperate with this task every single day at all hours. There will be some countries like Iceland that will have put a limit to this, but people will still be so dependent on technology that it won’t matter that much.

Most people won’t call themselves cyborgs, but they will be: they’ll have some kind of alien tecnology in their bodies to gather information and communicate, or perhaps they might wear fancy stylish hats that read their minds. Silent people walking on the street will be able to talk with each other using this technology.

Computers will have changed a lot, but then again not that much. We will still be using very similar devices as some that we use today: screens and keyboards – or at least computer programers will. Non-trivial software will still be created in a written computer language. Of course, trivial will have a different meaning in the future.

Cars will still be a very important means of transport. But they will be electric cars, in most cases public taxis in big important cities, and no person will drive them, they will drive themselves and thus roads will be much more secure than today.

Genetic advances will still be happening and feel like the field has just started to emerge. It will be like it was computer intelligence for us: it will feel like it never quite started, but it did indeed. We the people born before year ~2030 will be old and very ugy in the eyes of the new youth generation that will all be tall, in good health, beautiful and have perfect bodies. Life expectancy will have reached 100 years, so I might still be alive but I’ll probably have forgotten this post.

It’s quite simple to use: you do a git timetrack –start, the clock starts counting. Then you go for a coffee, you use git timetrack –stop for that, and then when you come back, you can continue counting the time executing git timetrack –start. Then you do a commit, and it gets automatically annotated with the time spent, and the clock stops counting. Some random notes:

• To start using git timetrack, you need to first execute git timetrack –init in your project to add the needed hooks and options to .git/config.
• The time annotations will appear in git log in seconds, and will be shown more nicely when using git timetrack –log.
• If you forgot to start tracking the time for a commit, you can execute git timetrack –set X to set the clock to X minutes, and then continue counting the time with git timetrack –stop. And if you messed the time and want to start from zero, you can do a git timetrack –reset (or git timetrack –set 0).
• You can add an estimation of the time you spent in last commit with git timetrack –set X and then “amending” the commit (adding the times-pent) with git timetrack –amend. Using that, you can also change the time spent in last commit, and you can also change/set the time spent in any commit giving the commit-ref to the –amend option.
• For consulting how much time have you been currently spent in next commit (i.e. the status of the stopwatch), use git timetrack –current.
• For consulting the time spent in the project, use git timetrack –summary . It internally makes use of git log, and allows the same options as git log, so git timetrack –summary –author=foo@server.com –since=1week dir/file.c would tell you the time foo@server.com spent in dir/file.c since last week.
• If you’re going to start hacking and thus do a batch of commits, you might not want to execute git timetrack –start to start counting the time after each commit. That’s automatically done for you if you use the properly named option git timetrack –start-hacking!
• List all the options available with git timetrack -h.

Git timetracker uses Git notes to add time-spent annotations to commits.  That means that thos annotations do not modify the commits and leave them intact, and are stored in a git notes branch instead. Git notes itself is quite recent and git timetracker  requires git-next (git development unstable branch) because it makes use of the git notes merge feature to be able to share the timetracker notes between users and merge changes on it nicely.

Why did we develop timetracker? We are creating a small software company called Wadobo, and we needed to do (rough) estimations of the time the development in the projects we work on will take, so we thought that the first thing we needed is having some real information about time spent in those projects.

I think that this can be really useful for the mentioned usecase. The tool is quite new but works-fine-for-me (TM) and we’ve been using it for a project for nearly two weeks already. Hopefully you like this little gem from us.

PS: I wanted to do a screencast, I really tried, but boy is that a difficult task to do. ffmpeg is segfaulting (I don’t use/have pulse audio but directly alsa). xvidcap is not capturing audio in the arch linux binary, and it’s diffcult to compile. recordmydesktop gives me audio artifacts. aur/screencast is not compiling… I gave up, have better things to do. What tools would you recommend to me?

Una de las últimas cosas que he estado haciendo cierta aplicación web, que ya está casi terminada, y en la última reunión con ellas (puesto que son todas mujeres) me pidieron realizar una serie de cambios. Entre ellos, uno que consideraron muy importante era la corrección del género de los mensajes de la aplicación. Para ellas algo tipo “Buscar usuarios” estaba mal dicho, porque se refería a los usuarios pero no a las usuarias. Según ellas lo correcto sería usar “Buscar usuarixs”, “Buscar usuari@s” o “Buscar usuarios y usuarias”.

Les dije que según la RAE el género neutro es igual que el masculino, y me contestaron diciendo que la RAE estaba formada por vejestorios. Tras oir esto, no quise profundizar más en la discusión porque al fin y al cabo son un cliente y además tampoco me sobraba el tiempo en ese momento. Pero me tuve que morder la lengua para callarme. Al terminar la reunión, comenté con el compañero con el que fuí a ella lo absurdo del asunto, y me volví a casa en bici dándole vueltas y mas vueltas.

El objetivo es claro: hacer referencia a un grupo de personas, indistintamente de su sexo. El idioma español ya tiene una manera de hacer esto, y es usando el género neutro que coincide con el masculino. La frase de marras sería “Buscar usuarios”. Las razones por las cuales coincide el neutro con el masculino puede que sea porque antes a las mujeres no se las tenía en cuenta (cosa que tampoco sé a ciencia cierta), pero eso es irrelevante. Todo lenguaje tiene una historia detrás, y muchas palabras, expresiones y reglas verbales vienen de acontecimientos pasados, como es lógico. Ningún moro debería sentirse indignado porque alguien se apellide “matamoros”, pese a que me consta que los hay.

Escribir o decir “usuarios y usuarias” cada vez que nos referimos a las personas que usan algo sin distinguir su sexo es una pérdida de tiempo, o de espacio en la web. Por eso mismo proponen usar “Buscar usuarixs” o “Buscar usuari@s”. Esto si que sería un crimen:

• ¿Cómo demonios pronuncio eso? Elimina una de las bondades del lenguaje español, y es que se pronuncia tal y como se escribe.

• La eliminación de vocales y el uso de caracteres que ni son vocales ni consonantes como la arroba dificulta y enlentence sobremanera la velocidad de lectura y procesamiento del texto.
• Poca gente está habituada a su uso, y menos la gente mayor que es especialmente importante en la aplicación web de marras.
• No es algo aceptado por la RAE.
• Es sexista.

Y con este último punto llegamos a lo que es el meollo de la cuestión. Para igualar al hombre y a la mujer, quieren que haya que estar mencionando de forma separada a los hombres y a las mujeres cada vez que hablemos, o como mínimo escribirlos referenciándolos a ambos por igual con arrobas o X pero no con el género neutro de toda la vida. Eso lo único que hace es recalcar la separación entre ambos.

La no aceptación de un género neutro que por razones históricas es igual al masculino por el hecho de ser igual al masculino es síntoma de que realmente no se está equiparando a hombres con mujeres. Es como cuando los de la derecha exigen que no se llame matrimonio al matrimonio homosexual sino que se le llame unión, porque no quieren que el matrimonio pueda ser entre personas del mismo sexo… porque no quieren que se mezcle a los matrimonios homosexuales con los matrimonios “de gente de bien”.

Es como si dijese “Buscar usuarios pelirojos y no pelirojos, zurdos o distros, tontos o listos, feos o guapos”. ¿Os acordáis del anuncio de la cocacola? “Para los gordos, para los flacos, para los que ríen,…. para ellos, para ellas…” ¿Y al final cómo acababa? Os puedo asegurar que no era con un “Para todos y todas”, aunque igual algún sexista termina pidiendo que se rescriba para que así sea, desde luego visto lo visto no me extrañaría. Aquí el anuncio para que lo comprobéis vosotros mismos:

El feminismo es un movimiento cuyo objetivo la igualdad del hombre con la mujer, en derechos. A mi me parece un objetivo perfectamente válido y loable que además yo comparto. Lo que sí no comparto ni entiendo es el feminismo radical, que es tan discriminatorio sexualmente como el machismo de toda la vida, y es igual de ilógico y sin sentido.

Nos hacemos viejos, sí, pero lo más interesante es que la red madura con nosotros. Pertenezco a una generación que aun recuerda (como algo lejano, eso sí) una época sin Internet. Una época sin apenas teléfonos móviles. Cuando los hombre eran hombres y se programaban sus propios drivers.. bueno, ¡no nos pasemos!.

La cuestión que quiero abordar hoy es que al princio, las cosas eran nuevas, y había ideas que luchaban por emerger.  Cuando querías buscar algo en Internet, te ibas a Altavista, mirabas tres o cuatro páginas de resultados, luego a Yahoo, y así ibas saltando de buscador en buscador hasta que igual dabas con la tecla. Como menciona alguien en un comentario en slashot, cada vez utilizabas un buscador diferente, el que mejor fuese en aquel año o mes.  Lo mismo ocuría con la mensajería instantánea, el email, etc. Tenías cuenta en miles de sitios que servían para lo mismo, ibas cambiando probando decenas de programas hasta encontrar el mejor. Entre los pocos internautas que había entonces, había un interés importante en encontrar mejores herramientas, y los desarrolladores luchaban por dominar un mercado nuevo sin un líder claro y totalmente cambiante. Era la época de las .COM, y cualquiera podía ser el nuevo Microsoft o Terra.

Con la madurez de la red, aumentó el número de usuarios, y bajó el interés por encontrar nuevas redes/protocolos de IM/programas. La gente realmente utiliza lo mismo que el resto y es un mundo mucho menos cambiante en temas trillados. Si quieres una cuenta de correo, usas gmail o hotmail. En España para redes sociales tenemos todos tuenti y a lo mejor facebook. Si quieres chatear, usas los dos anteriores o MSN. A lo mejor si eres friki, usas GMail para chatear. Las noticias las lees en elmundo.es, marca.com, y a lo mejor meneame.net.

Por otra parte, muchos  somos frikis de algo. Uno está registrado en forocoches, el otro es un friki del counter strike, y la otra está en un grupo de flickr que sube fotos hechas con cámaras CANON, y escribe en el foro de canonistas.  Como ahora en Internet somos muchos,  estandarizamos las cosas que hacemos todos en común (tuenti, msn..), y luego nos segregamos en comunidades de menor tamaño para nuestras rarezas. Y de ahí no salimos apenas.

Este comportamiento es normal si no queremos volvernos locos, pero también marca una inercia. Un hecho evidente es que no podemos conocer todo Internet (ni el 0.01% tampoco) así que necesitamos alguna manera de escoger nuestro pedazito de tarta particular. Antes la vida en Internet era más caótica, era más común ir saltando de un sitio a otro. Ahora ya cada uno ha encontrado su lugar, y explora cada vez menos el mundo exterior.

¿Se puede luchar contra los gigantes establecidos? Se puede, pero es difícil. Por las razones mencionadas, estos gigantes tienen más poder que nunca, lo que genera una inercia difícil de vencer. Una inercia que crecerá más si cabe si no se cumple con la neutralidad en la red y los grandes sitios vayan a ir más rápido que los pequeños que no pagan a las telecos.

Los “grandes gigantes” de ahora tienen poder y lo utilizan a su favor: antes la gente subía páginas a geocities, ahora en cambio suben sus fotos a tuenti sin ningún rubor, cediendo los derechos de explotación de esas fotos a Telefónica, incluso pese a también subirlas  a otros sitios como flickr para verlas con mayor calidad. Pero como sus amigos tienen y usan mas frecuentemente tuenti que flickr, pues las suben a tuenti. Y se etiquetan en ellas, y así telefónica puede hacer luego reconocimiento facial de todos nosotros si quiere.

Sin darnos cuenta, por comodidad, por ser prácticos, cedemos nuestros derechos. Ahora que tuenti tiene tanto “moméntum” en España, y facebook en el resto del mundo, va a ser difícil crear un red libre y distribuída como Diaspora que luche contra este tipo de injusticias, y los grandes como Telefónica lo saben. Por eso creo que es importante que nosotros, los desarrolladores y emprendedores, no pensemos tanto en nuestros bolsillos sino en nuestros ideales cuando creemos nuevos servicios disponibles en la red, para conseguir que sea un lugar mejor. Porque al fin y al cabo forma parte de nosotros y formará parte de nuestros hijos.

A la atención de la Oficina Técnica:

Recientemente ustedes han publicado el código fuente del paquete que llaman pkcs11 [1]. He  inspeccionado el código, y no especifican ningún tipo de licencia, por lo que según la ley española se reservan todos los derechos. No obstante esté código está diseñado y así ha sido empaquetado en las versiones compiladas que ustedes mismos ofrecen para ser añadido al paquete opensc que se encuentra bajo licencia LGPL, una licencia cuya naturaleza es vírica y por tanto fuerza a que obras derivadas como la vuestra deban estar bajo una licencia LGPL-compatible. Ustedes parecen estár incumpliendo la licencia. ¿Llamo a la policía o ya se llaman ustedes mismos?

Además, no proveen de un código que pueda utilizarse una vez compilado, porque el código parece estar diseñado para ser incluido en opensc y no es compilable de por sí. Tampoco se incluye ningún tipo de guía (README) de cómo realizar el proceso de compilación. Con el código fuente para cumplir con la  licencia LGPL deben incluirse las instrucciones necesarias para poder ser debidamente compilado.

Como ciudadano que ve sus “impuestos trabajando”, me siento decepcionado porque hayan tardado tanto en abrir el código para que luego lo hiciesen de forma tan chapucera. Existen multitud de aplicaciones que puede tener el DNI electrónico y están realizando un trabajo que va en detrimento de su uso. Deberían de colaborar directamente con la gente del proyecto opensc [2] como ya han realizado otros países de la Unión Europea y dejarse de cutres aperturas de código que ni siquiera ofrecen código bajo una licencia libre, como es el caso actualmente, y que no permiten al ciudadano basarse en ese código para mejorarlo.

Firma un servidor (y no con el DNI-e aun),
Eduardo Robles Elvira.
–
[1] http://www.dnie.es/descargas/codigo_fuente_pkcs11/src.zip
[2] http://www.opensc-project.org/opensc/wiki/GetInvolved

EDIT: He corregido y ampliado algunos aspectos de la carta (como el “detrimenta” que se me escapó y algún otro).

So the state of the art is: we’ve got an akonadi resource for konqueror bookmarks which stores the bookmarks in nepomuk. We’ve got a bookmarks organizer, and we’ve got a bookmarks menu integrated in konqueror. The new location bar is however not finished yet, but that will be fixed within days.

A lot has changed since last report. I’ll try to explain here what’s the base structure of the new classes and what I’ve been doing, mainly related to the location bar, and why I followed that design decisions.

KCompletion

The current konqueror location bar uses a KCompletion class for autocompletion, which is mainly handled by KLineEdit. But how does it work? Let’s use a simple example. Imagine you are developing kmail’s new email dialog. For the line in which the user enters the destination email address, you could use a KLineEdit, but in order to easy the task of the user, you could use autocompletion like this:


KLineEdit* destinationLineEdit = new KLineEdit(this);
...
KCompletion completion;
completion.addItem("tigerwoods@fortune.com");
completion.addItem("billgates@microsoft.com");
...
destinationLineEdit->setCompletionObject(completion);


You could of course get the list of items to add to the completion object from the address list too . If you were developing instead the location bar for dolphin, you would like to have directories listed while the user is typing. Instead of adding and removing items manually yourself to the completion each time the user types, you can use a KUrlCompletion object that does that automatically.

But for konqueror location bar we have a problem: it needs to be able to use kurlcompletion for completing directories, but it also needs to complete from bookmarks and history. We need to work with multiple completion objects at once even though KLineEdit and similar classes can work only with one. Also, we need to do more complex completion A normal KCompletion object contains a list of strings and matches what you type with those, but for having an amazing location bar we need more power: if I type “work” and I have a bookmark tagged “work”, I want it to show up in the completion list even if its URL doesn’t contain the word “work” at all. And that’s only the beginning. I want to be able to set an order of the completed items depending on the relevance and type of the items, and more..

Enter Qt Model-views

I need to confess that I love Qt model-views classes. QAbstractItemModel, QAbstractItemView, QAbstractProxyModel, QSortFilterProxyModel, QTreeView.. They provide an standard convinient and flexible way to manage and display almost any kind of collections. Even collections of completed items. Actually, the completed items popup is in reality a QListWidget, which displays a model associated with the completion object..

But that is an internal model which KLineEdit doesn’t let me change. So the question that follows is.. why not use directly my own custom item models instead of a KCompletion object? And that’s what I did, even if it required a lot of work to be done.

First of all, I tried to outline in paper the master plan. What classes needed to be created for everything to work fine. Then I wrote step by step what needed to be done before what. Then I started following those steps one by one and it worked!

Places all over the.. place

The plan was that the location bar autocompletes places. A place could be:

• a history entry from history entries model
• a bookmark from bookmarks model
• an url from a kurlcompletion model

I had already a bookmarks model and konqueror already has an history entries model, but I had no kurlcompletion model. I looked at the code of the KUrlCompletion class I decided that I didn’t want to rewrite it.. so I simply created a KCompletionModel which acts as a proxy and converts a KCompletion object in a QAbstractItemModel. So to create a url completion model, I do:

KUrlCompletion* urlCompletion = new KUrlCompletion();
KCompletionModel* urlCompletionModel = new KCompletionModel();
urlCompletionModel->setCompletion(urlCompletion);


To do a completion, I connect the urlCompletion to the textChanged(QString) signal from the lineedit. And the completion objects reflects the changes which in turn instantly appear in the model. It’s not the best solution but hey it works.

Also, another problem was that the completion object of KLineEdit would be replaced by a model, not three. But now as you see I have again multiple completion objects, so what was the solution? creating an aggregated model created out of multiple models. It works like this:


KAggregatedModel* aggregatedModel = new KAggregatedModel(this);
aggregatedModel->addSourceModel(bookmarksModel);
aggregatedModel->addSourceModel(historyEntriesModel);
aggregatedModel->addSourceModel(urlCompletionModel);


Now, those who know how an item model works will probably have a lot of questions about that. For example one could be.. Do all those models need to share the same columns? The answer is no. The aggregated model I created is quite simplistic in the way it works:

• It assumes the source models have only one level of childrens.
• It only shows one column, which is the default display column (sourceIndex.data(role)).
• It shows the list of items as a list, showing first the items from the first item model, then the ones from the second, etc.

Places Manager

So far we have an aggregated model with completed urls, unfiltered bookmarks and unfiltered history entries. That’s yet not complete from being the amazing completer model. What we need to do is the amazing filtering and sorting. That’s done by the final completion model, the master of places..

It’s called PlacesProxyModel and inherits QSortFilterProxyModel. It takes a QAbstractIteModel and takes the Konqueror::PlaceUrlRole for each index, gets the URL, and obtains the corresponding Konqueror::Place for it. Then, knowing already all the available information for that place, tries to match it against the query the user entered in the lineedit and sets its relevance for sorting purposes. It also filters out duplicated entries. Quite an achievement, but how does all that work again?

First off, all previous models (url completion, bookmarks and history entries models) report their items to a Places Manager which keeps track of them and contains a Place for each relevant url. So for example, if the user has bookmark for http://www.kde.org and it’s been visited yesterday, there’s a place in the places manager with the information from both the bookmark and the history entry.

All those models also support obtaining the url related to each item by using the Konqueror::PlaceUrlRole. The aggregated model proxies calls to retrieve data from any role, including that. So in the end the information can be retrieved by the places proxy model. Then an algorithm that takes into account the number of visits, the last visit, if the user-written string matched the place’s url, title or tags, etc sets the relevance of the items in the proxy model.

The road to the location bar

The new location bar inherits from the modified KLineEdit which uses a QAbstractItemModel for completion, which I have named KLineEditView. An amazing location bar needs to be able to show an star that can be clicked to add/remove a bookmark, and the autocompletion needs to show for each place shown if it’s bookmarked, its tags, etc. Contextual information.

State of the art

What has been done? All the previous things I have mentioned are working. They can always improve, but the code is already there. The location bar widget is the last thing I started to write so it’s not finished: it has already plugins support so that new icons/sub-widgets can be shown inside the location bar. Now I need to write the plugin to let the user bookmark the current location, and I also need to write the CompletionPlaceDelegate to have a properly eye-candied completion list. And I’ll do it shortly.

Future and end

Unfortunately, a lot of things need to be done before this new bookmarks system ends up in konqueror trunk. Revamping such an integral part of Konqi is not a simple task. We also want to be sure that when the replacements comes into play the user doesn’t have to suffer it but to enjoy it instead, so I need to find fix and all the regressions. I need to write documentation and test cases too. I honestly don’t really know when the job will be done but I know I’ll continue working on it.

I want to thank specially my mentor David Faure for the support, for giving me a thumbs up even if I didn’t finish on time everything I wrote in my gsoc propossal. You rock david!

This is post has been too large I admit, so I think I’ll stop here . If you read everything yay you’ve got too much free time so go and do something more useful!

The konqueror bookmarks menu is already rewritten to support the new bookmarks system.  I like to read see other people’s code because it can inspire me when I want to develop something. Thus, I’ve been reading Arora code and I liked their idea of using QAbstractItemModel as the data source for QMenu and that’s how I’ve implemented the new bookmarks menu.

I’ve always wanted to have menus more advanced than just normal menus. When I saw that inside Mac OS X Help menu there’s a search bar I knew I wanted to have something like that in KDE and I wondered if that was possible. The answer is yes. Qt Menu system allows to insert custom widgets with WidgetAction class so I’ve added a Search Bar to Bookmarks Menu. When you type in the search bar, the source model of the Bookmark menu changes to a DescendantsPRoxyModel which represent all bookmarks and folders in a flat list and uses a QSortFilterProxyModel to filter out results. It’s not finished yet, there are some issues with the search but all in all I’m quite satisfied. Next step: Awesome bar, and fix more bugs =).

I’ve also been working on the bookmarks organizer, fixing bugs, adding support inline bookmark editing in the bookmarks view using double-click, adding a BreadCrumb view similar to Dolphin’s breadcrumb mode but using a QAbstractItemModel as a source for paths, etc. Here’s a small videocast where I show some of the mentioned features in action: