Planet INdT

QTestLib / Plasma Animations presentations @ FISL11

2010-07-24T10:59:39+00:00

Hi again :)
It's been amazing days here at Porto Alegre, Brazil, where the 11th Forum Internacional de Software Livre (Free Software International Forum - aka. FISL11), one of the biggest open-source conferences in the world. On 22nd I've made a presentation about QTestLib, entitled "QTestLib: Creating intelligent unit tests for Qt-based projects" (slides available below - sorry, portuguese only), and yesterday me and Igor Oliveira spoke about Plasma Animations, pretty much similar to what I've had talked about in Akademy this year. Today we'll have Igor talking solely about Gallium3D, so things are pretty much on the way we've expected :)

QTestLib slides available here.

ps: And of course, we have pictures taken with Tux and GNU!

Tubarão

2010-07-19T19:23:31+00:00

Antigamente pensava que, embora goste muito dele, tinha pouco em comum com meu pai. Não estava completamente errado, mas esta estória não é sobre isso.

Fomos lá no hospital Santa Maria, na minha cidade, pra render o turno da minha mãe, que está acompanhando meu tio na internação.
O hospital fica uns duzentos metros da casa dos meus pais. Mais duzentos metros e temos a casa do tio, e com mais duzetos é o cemitério. Tudo é perto na minha cidade, pouca necessidade de carro ou ônibus.

Só pra localizar melhor as coisas, esse tio não é um tio genérico, ele criou minha mãe como pai, logo é como se fosse meu avô. Todos chamamos ele de Nêgo (com ê mesmo). Ele tomava conta do pequeno eu de 5 anos (acho) enquanto minha mãe analisava amostras de sangue no laboratório. Mas meu tio também tinha seus compromissos de sacristão de uma paróquia, pra onde ele me levava. Lembro de ir pra uma extrema unção (ou era um velório?) onde fiquei cantando com o folhetinho virado de cabeça pra baixo.

Chegando na enfermaria do hospital mandamos minha mãe jantar. Eu tinha a intenção de entreter o doente, mas ele estava com a voz bem fraquinha pra conversar. Melhor uma estória. Então fiz a pergunta mágica ao meu pai sobre como vovô aprendeu a nadar tão bem vivendo num sítio no interior de Pernambuco.

Então, era uma vez meu bisavô, que não sei o nome, por causa de quem começa tudo. Tem essa estória vaga e difusa de que ele matou duas pessoas, em duas situações distintas, com tiros à queima roupa de seu perverso bacamarte. Me foi contado que ele socava vidro e pregos junto com a pólvora. Um dos tiros teria arrancado o coração de uma mulher e o outro a cabeça de um sujeito. Mas pode ter sido o oposto. A causa de tanta raiva pode ter sido fofoca e ciúme. Ele tinha uma amante e estavam contando pra minha bisavó. Meu bisavô, amante da paz que era tentou resolver do jeito dele. Contudo, nada é preciso nessa estória. Essas lendas de família são assim mesmo.

Fato é que nos idos de mil novecentos e dez e poucos os bandidos perigosos iam para… O que é que ele vai ganhar Lombardi? Uma viagem com tudo pago pra Fernando de Noronha, Silvio! E a estranheza só aumenta, meu pai contou que a família do condenado ia junto com ele, mas ficavam numa casa de verdade na ilha, e o meliante só precisava dormir na cela com provável vista pro mar. E essa era vida do meu bisavô, dormir no xilindró e fazer mais filhos durante o dia. Penso que ele só fazia pela diversão, mas cada filho nascido na ilha diminuia sua pena.

E foi assim que meu avô aprendeu a nadar, praticando dos 13 aos 18 em Fernando de Noronha, enquanto o pai cumpria pena por crimes hediondos.

Sabia desse conto só até essa parte, mas o mais legal de ouvir meu pai narrando tudo de novo é que sempre posso confiar na ampliação da estória com um detalhe que lembrou na hora. O detalhe dessa vez foi um tubarão.

Estavam pescando numa jangada lá no mar azul de Fernando de Noronha meu avô e seu irmão. Pescavam com anzol grande e corda resistente, esperando pegar algo graúdo. Pois foi um tubarão que veio, não sei a espécie, só sei que era do tipo com dentes afiados e do tamanho da jangada onde cabem duas pessoas.

Eles lutaram com o peixão por um bom tempo, até que o bicho virou o barquinho. Nessa parte da narrativa eu só acreditei que meu avô saiu vivo porque estavam o filho e o neto conversando sobre ele. Assisti muitos filmes de tubarão pra saber que o objetivo da espécie, em todas suas variantes, é o extermínio da raça humana. Veja o tubarão baleia por exemplo, aquele jeitão simpático dele, aquela boca de garagem de fusca, isso é só pra baixar nossa guarda.

Na vida real o tubarão com um gancho na boca só quer fugir. Vovô e seu irmão com suas inseparáveis facas (sim, os filhos do condenado andavam por aí com facas – eram aqueles tempos que todo mundo fala de amarrar cachorro com salsicha) só queriam um almoço de frutos do mar.

Bem, voltando, vovô conseguiu furar o tubarão e logo o bicho enfraquecia. Eles desviraram a jangada e jogaram o peixão no meio. Os pescadores adultos festejaram a habilidade e ousadia dos meus antepassados adolescentes e todos fizeram um feliz churrasco de tubarão.

Essas horas minha mãe já voltou e tenho um ônibus pra pegar.

Applying transformations to your bugs

2010-07-16T18:45:27+00:00

Today there was this presentation from Apple to talk about the famous iPhone4 antenna problem. I’ll represent this problem (bug) with the picture below made by one of INdT’s designers (Patricia Montenegro) some time ago:

The Bug - watch out the way it looks to you!

To be honest I wasn’t expecting anything “technical” in the sense that I wasn’t expecting a technical explanation to the problem itself (you can find it in numerous places on the web) or for a possible solution, but I wanted to watch how Jobs would deal with with the situation.

Being honest again, he did what he does best! At first, he acknowledged the problem as it couldn’t be denied. Then he said that actually they did a favor to the smartphone’s industry because there were other phones with the same problem (showed pictures of other phones having the same issue – what doesn’t prove much, but…) but instead of “hiding” the antenna and hiding the problem, they actually put a big “X” on the problem (see picture below).

iPhone4 antenna

From my point of view it was just what we would call a “n00b” mistake . I mean, Apple is doing phones since not so many time ago. It’s their 4th device (iPhone, iPhone 3G, iPhone 3GS and iPhone4 now), and they just didn’t face this problem before and had the brilliant idea. The problem may show up on other phones? Sure, but I’m sure that the other manufacturers know about the problem and try to “fix” it, being that hiding the antenna inside the case or whatever.

The next steps were just the table’s “turn over” (not sure if this expression exists in English, but it works pretty well in Portuguese ): some (small) numbers about the how many people were actually affected by the bug. It was less than 1 in a 100 users (a beautiful way of saying less than 1% hehe). They get these numbers from the people that actually complained at Apple Care about the issue so those out there that just reading Engadget and Gizmodo about the issue were not counted of course.

But besides the number being so small, Apple does care about it’s users. All of them. See the kind of words used here? This is the place to do the magic trick. This is the place where you say that you’re not evil or bad but you actually care. Just after stating that you human enough to make mistakes, you ensure your “human position” showing that you care about others. Genious! It’s a statement that just makes the others stronger .

In order to take care of those 1% Apple will give for free cases for the iPhones, what prevents the bug and users will even be able to choose colors! And if they do not want the case, then a refund is offered. In Brazil this would be something that they would need to do because of the law: if you sell something that doesn’t work, you need to refund. I’m not sure how this works out on US but anyway, he transformed the user’s “right” into a company’s “feature”. Points again for Apple and Jobs for playing nice with the words.

After that, it was just more slides about all the nice features of iPhone4, why you should have one and more and more statements that Apple loves it’s users (yes, the word love is used in all the slides).

Apple and Love

Summary: from the technical point of view it was just “we don’t have a way to fix this as this is a hardware problem and it’s a huge problem then.”. But saying so is the same as pushing the picture of our fellow bug in every user’s face.

Instead of doing that, they will solve the issue by giving the users a rubber case that costs less than 1 dollar and then create a link between the users and the company that is: “we are all humans. have you ever made a mistake? this is our first mistake. sorry. take this gift. ah, by the way we love you.”. This creates compassion (every human did something wrong once in his life) and then people stop bashing the company and it’s product. This “love history” also reinforces that they are humans, enabling them to screw things eventually. So with a few minutes, Jobs got our fellow and dressed him properly transforming The Bug in a Feature:

The feature - not so ugly anymore!

From my point of view, the truth is that Apple is a company with a product that costs you some money and just like any other company in any other industry, the products should be properly tested and should not have this kind of problems that are not solvable (what if they didn’t have the luck of the case solving the issue?). The good about open source products is that at least from the software side we can fix stuff as quick as possible. So please vendors: pay attention to the hardware you manufacture and leave them as open as possible to software that we want to put into that!

Cairo State Tracker what we already have done

2010-07-11T15:47:40+00:00

In my last post I showed how we can fill self intersected polygons using stencil buffer. It is one of the operations I have implemented in Cairo Gallium backend.

We already have many features implemented and others one in WIP. This week i was working in make the stroke operation styles, like join, caps and dashes. I already have them working, Cairo has a nice helper function called _cairo_path_fixed_stroke_to_shaper, it converts the stroke in polygons like quads and triangles. The result can be seen below.

We already have the fill operation also working(like you saw in my last post) , mask, clip and paint(solid pattern). Now i am working in blend operations, Cairo has many and some ones i need to write a shader like i did in my openvg branch not commited.

Cairo state tracker: filling rules(the power of stencil buffer)

2010-07-10T20:15:08+00:00

When creating a Cairo Graphics Backend we need to implement some operations, one of them is the fill operation.

Fill operation basically describe how a polygon is filled, and cairo has two fill rules:

Non-Zero Winding: takes into account the direction of the path. Being enclosed by a clockwise loop counts as +1 and being enclosed by a counter-clockwise loop counts as -1. When of the sum of these counts is zero, it is a hole otherwise it is filled.

Evend-Odd: Every area that is inside of an even number of “interiors” is a hole and every region that is inside a odd number of “interiors” is filled.

These operations are easily implemented using stencil buffer. About the Even-Odd we just need draw each of the polygons in turn, using the PIPE_STENCIL_OP_INVERT function in the stencil buffer. This flips the value between zero and a nonzero value every time a triangle is drawn that covers a pixel. After all the triangles are drawn, if a pixel is covered an even number of times, the value in the stencil buffers is zero; otherwise, it’s nonzero. Finally, draw a large polygon over the whole region.[1]

And the No n-Zero rule we need to know using the cull face if we are drawing the polygon into clockwise or counter-clockwise, we increment the stencil(PIPE_STENCIL_OP_INCR_WRAP) if is in clockwise and we decrement(PIPE_STENCIL_OP_INCR_DECR) the stencil if is in counter-clockwise. After we just need to draw a large polygon over the whole region.

So thinking about a star with the coordinates:

(Remember the star is a self intersected polygon)

cairo_move_to(cr, 0, 1.0);
cairo_line_to(cr, 0.5, 0.0);
cairo_line_to(cr, 1.0, 1.0);
cairo_line_to(cr, 0.0, 0.5);
cairo_line_to(cr, 1.0, 0.5);
cairo_line_to(cr, 0, 1.0);

Using Even odd rule this star is draw with a hole:

Using Winding rule we have the all the star filled:

So see you in the next post .

[1] Drawing Filled, Concave Polygons Using the Stencil Buffer.

link:http://www.dei.isep.ipp.pt/~jpp/sgrai/livros/RedBook/chapter14.html

KDE calls ‘home’

2010-07-10T19:42:58+00:00

Yep, I didn’t have time to blog during aKademy as you may have noticed The main reason is that I had a lot of discussions and attended to a huge number of BoFs. This aKademy rocked just as the others that I went. Huge thanks to the organization team, KDE e.V and sponsors for providing ways to make this happen and to have a lot of KDE hackers there!

Instead of doing a technical blog today, I will just say that during this aKademy KDE ‘called home’ for the first time. This means that for the first time in history we had KDE running on a mobile phone and we made a call with it! This was AWESOME! Just a summary: Plasma-Mobile and a plasmoid that worked as a dialer did the work, using the phone API of Maemo5 on a N900.

As Aaron noticed, our first call was a little bit more “interesting” than Graham Bell’s one. The first words on a telephone in history are:

Mr. Watson, come here. I want to see you.

Interesting…..but you may think that the transcription below is a little bit more interesting. I will also omit some context that would explain some of the questions/answers during this talk as I think that it may turn this more…let’s say…special Enjoy!

My phone rings (for the sake of curiosity, my ringtone is “Snow” by Red Hot Chili Peppers) and the ID of the caller is “+41″. I answer and the call drops. I tell Helio that it should be some company from Brazil during TeleMarketing. While we walk to the bus for aKademy’s day trip it rings again. Alexis Menard is the caller this time:

Me: Bonsoir! er, Bonjour Alexis!
Alexis: Guess what?!
Me: hhmm, you’re going to miss the dray trip because you just woke up?
Alexis: NO! Guess what ‘amiguinho’!? (note: ‘amiguinho’ means ‘little friend’ in portuguese)
Me: Oh, I got it! You’re the guy! Your bed is warmer than it should be?
Alexis: What?! No, no, no! Come on! GUESS WHAT?!
Me: I don’t know then! Let me think….ow yeah! GREAT! This phone call was made through the Plasma-Mobile stuff that we did yesterday?!
Alexis: Yes!! Finally!! I’m turning off my computer and meet you at the bus!
Me: OK! See you!

And then I tell everybody that was by my side that it was the first KDE phone call in history! REALLY GREAT! The conversation above may seem non-sense but all the questions had a reason and the answers too

Soon we should post some more technical bits about Plasma-Mobile and also I plan to talk a little bit about KDE-Pim-Mobile, the new Sharebin engine (that will support scripted plugins and GHNS) and if you want to contribute to some use cases of Plasma-Mobile take a look at this link.

As a kind of “sad note”, I would also like to tell you that the QEdje scriptengine was removed due (my) lack of maintenance of the QEdje project.

Plasma Animations Overview Slides Available

2010-07-07T04:43:52+00:00

Hi KDE :)

It's been quite awesome times for me in these days, since I was able to meet the guys behind the code or IRC channels. Today I've presented my workshop entitled "Plasma Animations Overview", and it was quite good, with useful feedback from the crowd about JavaScript animations and the plans for implementing support for QML-based widgets animations. You can find the download links for the presentation (and source code for the examples) below:

Plasma Animations Overview (PDF)
Plasma Animations Examples

Also I would like to share the beautiful view of the Tammerkoski river took on my way to Demola:

Sliderlayout

2010-07-04T09:05:50+00:00

It all started with a simple problem: I want to change from one list of things to another, doing a ‘slider’ like transition (like you would do for example in a music player when you choose an artist and go to another list with the tracks).

That sounds pretty simple, right? Just fire a QPropertyAnimation (or if you are using Plasma, a SliderAnimation is even better) and animate the position of 2 widgets.

But what if I want to have those widgets inside of a layout (e.g. QGraphicsLinearLayout)? After all, I want my UI to scale between different window sizes, screen resolutions (and in mobile devices, adjust to screen rotations).

Hum… you could draw your widgets *over* the linear layout and check for resize events of the main widget *while* correctly positioning your set of widgets in the scene. But that sounds a bit too much hack-ish.

I asked 2 friends about this very same issue and one suggested me to create a layout with this behavior. Initially, I was not sure about it, after all, I have never worked before with QGraphicsLayouts and I got almost no time to have something working.

Well, the good news are that it only took me a couple of hours to get this:

Explanation: it is a layout were you can add several widgets and move from one to another by calling next()/previous(). And since it is just a layout, can be inserted in another layouts (in this case, inside of QGraphicsLinearLayout).

Maybe a bit of code would help to explain… say that you have 2 widgets and you want to move next when the current one is clicked:

Item obj1, obj2;

SliderLayout *slider = new SliderLayout;

slider->addWidget(&obj1);

slider->addWidget(&obj2);

connect(&obj1, SIGNAL(clicked()), slider, SLOT(next()));

slider->setCurrentWidgetIndex(0);

and you are done.

The secret here is to keep hidden all the widgets (except by the current one) and in the slider event, animate the position of both widgets (the current and soon-to-be-current widget) while correctly repositioning the widgets in the scene (and setting to show state both widgets of course).

Since I have the movement methods on this layout as slots, I have to derive from both QObject and QGraphicsLayout (and that I’m not completely happy, anyone has suggestions to workaround that?).

I have tested this layout (integrated with *far* more complex widgets) in varied devices (from ARM@430Mhz up to Intel Atom@1.6Ghz))and it behaved pretty well, basically because I’m only animating the position of 2 widgets. It might happen that if you have an overly complex widget, that your hardware is not able to do the animation with good frame rate (but here you can workaround by hiding some of the content of this overly complex widget, and that will be probably the subject of my next post).

There are 2 other remarks about the code:

I used Plasma SliderAnimation just because it was easier, but it could be replaced by a QPropertyAnimation
Since Plasma Animations expect to receive a QGraphicsWidget, I assumed that you are going to supply a QGraphicsWidget to the SliderLayout. But the real requirement could be a QGraphicsItem, since it is the position that is being animated.

You can get the code here, my personal sandbox for experimenting with plasma animations and other stuff (please, please, we *do* need to migrate away from svn and start using git) and look for src/lib/sliderlayout.cpp and src/example/slidertest.cpp. I wonder when the feature freeze of KDE is over, if this could be part of libplasma.

Maybe this concept could be expanded so there would be a layout class and the animation behavior (fade, rotate, slide, etc) be defined by a delegate. Anyone is tempted to help me to develop this further?

Open Source Community Support Developer at INdT

2010-06-29T19:59:05+00:00

A great opportunity has arisen to come and work with us on the Service Experience team @ INdT

I need someone to work on my team creating, maintaining and supporting a community of open source developers and implementers around the world. The full job spec is pasted below but the most important skills are experience working with open source development, fluency in English and some experience working with social projects in the areas of Education, Health or the Environment.

Please, if you would like to be considered either send me your CV or get in contact directly with our human resources department at INdT.

Please pass this opportunity on to anyone you think might be ideal for this role and I am looking forward to meeting some really cool people at the interviews :).

Mandatory

Education Level: Degree - but exceptional candidates without will be considered
Desirable Experience: 0-1 year
English: Fluent
Must Have: Demonstrable open source community involvement preferably as a committer to an open source project.
Would Like But Not Essential: Java, Debian, MySQL, ECMA script, Previous voluntary work in the fields of Education, Health or the Environment

Job Role

You will evangelize the adoption of our developer products and support implementations of our solutions worldwide. You will bring strong and well-rounded coding skills in a wide range of open source technologies along with excellent writing, presentation and support skills. You will be measured on growth in adoption of our developer products and customer satisfaction in our implementer communities. You need to be able to work equally well answering simple questions with NGO's, highly technical ones with developers at our partner companies as well as reporting accurately to senior managers.

Key Responsibilities

Actively tweet, blog and write sample code, developer articles and tutorials for our products as well as provide support online through our forums.
Provide on-line support and advice.
Advocate for and evangelize our developer products and APIs in multiple mediums.
Participate in architectural,design and support discussions with strategic partners to speed adoption and ensure best practices during implementation.
Influence our developer product strategy by working with product management, engineering, marketing, business development and operations.

We are building an outstanding team around our social investment projects here at INdT - if you want to be a part of this write and tell us why.

Good Luck!

QtWebKit goes Mobile

2010-06-23T12:40:16+00:00

Repost of Jesus' post, that I helped write.

There is a lot of effort being put into QtWebKit in order to make it attractive on the mobile front.

Among a tons of bug fixes and good performance improvements there are also lots of new features being developed, mainly geared toward mobile deployment.

The goal with this tutorial is to help you understand some of these new features and how to make the best of them. Or said in other words; how to create a good mobile web view that can be used on touch devices.

First we should make it clear that QGraphicsWebView is the way forward, so if you want to target mobile devices, it is bye bye QWebView. Why is that? Well, the QWebView is based on the QWidget system, thus it cannot easily support rotation, overlays, hardware accelerated compositing and tiling. If you need a QWidget anyway, you can always construct a QGraphicsView (which is a QWidget) with a QGraphicsWebView inside. This is more or less what we will start with.

Let's start with the most simple QGraphicsWebView based "browser" ever:

int main(int argc, char **argv)
{
   QApplication app(argc, argv);
   const int width = 640;
   const int height = 480;

   QGraphicsScene scene;

   QGraphicsView view(&scene);
   view.setFrameShape(QFrame::NoFrame);
   view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
   view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

   QGraphicsWebView webview;
   webview.resize(width, height);
   webview.load(QUrl("http://www.wouwlabs.com/blogs/jeez"));

   scene.addItem(&webview);
   view.resize(width, height);
   view.show();

   return app.exec();
}

Here we just bootstrap a QGraphicsView application and add a QGraphicsWebView to the scene.

It might seem a bit useless as you can only navigate through one website, but it serves well as a simple example. Notice that I'm disabling the scrollbars on the graphics view because QtWebKit handles scrolling and scrollbars automatically. This is due to scrolling optimizations and due to the fact that web authors can interact with the scrollbars for instance style them differently.

On touch-based mobile devices a feature known as tiling is often used. It is used due to the interaction model (touch) as well as a scrolling "optimization". With this optimization we will have to deal with scrolling ourselves and we thus will have to say good bye to the scrollbar styling. Not a big thing, as mobile browsers usually do not even show scrollbars, but use scroll indicators instead.

Tiling basically means that the contents of the viewport is separated into a grid of tiles, so that when you update some area, instead of just updating the area you actually update the whole tile. This gives a few advantages for scrolling as when you scroll you do not need to repaint the new visible area for each scroll step, as you update a row of tiles each time; tiles that are often only partly on the screen. This minimized all the paint calls that we have to do and makes it possible to make nicely kinetic scrolling a possibility.

Loading, layouting etc are blocking operations. Though barely noticeable on a Desktop machines, these operations can block for a long time on a mobile device, letting the user believe the application has become unresponsive and died. Scrolling which is done by using fingers will also stall and give a bad user experience.

One way to over come this issue, is to do all loading, layouting and painting (basically all non-UI related work) in another thread or process, and just blit the result from the web process/thread to the UI. When using tiles, you can blit any tile available when scrolling. When no tile is available you can show a checkerboard tile instead, not letting the scrolling wait for the tiles to be updated. This results in a responsive interface, with the only disadvantage that you from time to time might see checkerboard tiles.

Tiles also helps with zooming. Repainting at each zoom level change during a zoom animation is basically impossible on a mobile device (or desktop for that sake) and thus with tiling, you can stop the tiles from being updates and just scale the already existing tiles, and then at the end of the animation update tiles on top of the scaled ones.

For now we will ignore the blocking issue and concentrate on the tiling and the interaction model.

Resize to contents

When using tiling, we basically want the QGraphicsWebView to act as our contents, as it supports tiling a.o. things. In order for this we need to make it resize itself to the size of its contents. For this we will use QGraphicsWebView::resizesToContents.

From Qt 4.7 documentation: "If this property is set, the QGraphicsWebView will automatically change its size to match the size of the main frame contents. As a result the top level frame will never have scrollbars. It will also make CSS fixed positioning to behave like absolute positioning with elements positioned relative to the document instead of the viewport."

This setting, thus, removes the scrollbars for us on the main frame and makes our QGraphicsWebView resize itself to the size of its content.

Enabling it, is as easy as:

    webview.setResizesToContents(true);

Qt 4.7 docs also says: "This property should be used in conjunction with the QWebPage::preferredContentsSize property. If not explicitly set, the preferredContentsSize is automatically set to a reasonable value."

If we are going to expand our mobile web view to the size of the contents of its contained page, then that is going to make the view a lot bigger that what can fit on the device's screen!

Using a view as the window to the contents

The idea is to have a custom widget which has a QGraphicsWebView as a class member. Remember that the QGraphicsWebView will be as big as its content's size, so this custom widget will serve as a window, as a viewport.

There is not much more to say here, and the following code snippet illustrates it well:

class MobileWebView : public QGraphicsWidget
{
    Q_OBJECT

public:
    MobileWebView(QGraphicsItem *parent = 0);
    ~MobileWebView();

    bool mousePress(const QPoint &value);
    void mouseMove(const QPoint &value);
    void mouseRelease(const QPoint &value);

private:
    QGraphicsWebView *webView;
};

In order to properly handle mouse events you must install an event filter on web view or stack it behind its parent object (search for QGraphicsItem::ItemStacksBehindParent). By doing this the mouse events will reach a MobileWebView instance before they reach the member QGraphicsWebView.

Keep in mind that you'll need to add some logic in order to distinguish different mouse events and gestures like a single click, double click, click-and-pan, etc. That is left as an exercise to the reader.

Also keep in mind that as stated earlier, scrolling will have to be implemented manually, just as zoom etc.

Adjusting how contents is laid out

When testing the above on a device, you will notice that many pages do not layout very nicely. In particular the width is larger than the width of the device!

The way web contents is laid out, is that the first the viewport width is used for fitting the contents. If the contents doesn't fit due to non-flexible element with a width larger than the viewport width, the min width possible will be used. As most pages are written with a desktop browser in mind, that makes only very few sites fit into the width of a mobile device.

QtWebKit has a way to force a layout to a given width/height. What really matters here is the width. If you layout a size to a given width, it will get that width and images etc might get cut of. The width/height is also used for laying out fixed elements, but when we resize the QGraphicsWebView to the size of the contents, fixed elements will not be relative to the view, which is the behaviour found on most mobile browsers.

From Qt 4.7 documentation: "If this property is set to a valid size, it is used to lay out the page."

We saw that this property is automatically set to a reasonable value when using QGraphicsWebView::resizesToContents.

As you can imaging, laying out with a smaller viewport can cause pages to break, and as thus, a default value has been chosen so that it almost breaks no pages while still making the sites fit. This value is 960x800.

If the device have a bigger resolution, this value can be changed using:

    webview.page()->setPreferredContentsSize(QSize(desiredWidth, desiredHeight));

You can play around with this and find your own magic number, but let's stick to this 960px wide for now.

The 'viewport' meta tag

As some sites do not work with 960 or want to have control on how the page is laid out, QtWebKit as well as Android, Firefox Mobile and the iPhone Safari supports a meta tag called viewport.

This one also deserves a whole blog post for itself. For now let's just say that this is a meta tag that Apple came up with to make a web page capable of "telling" the browser how it wants to be shown.

More information: http://developer.apple.com/safari/library/documentation/appleapplications/reference/safarihtmlref/articles/metatags.html and http://developer.apple.com/safari/library/documentation/appleapplications/reference/safariwebcontent/usingtheviewport/usingtheviewport.html

In QtWebKit trunk we already have support for this with a nice API. You must connect the signal from QWebPage::viewportChangeRequested(const ViewportHints& hints) to a slot of your mobile web view and use what is provided by QWebPage::ViewportHints to updated your viewport size, scale range, and so on.

This can be tricky and that's why I'm not going deeper on it right now. Since I know you are curious about it I'll leave you with one more exercise! So try to understand how the guys from MicroB and Firefox Mobile dealt with this:

http://hacks.mozilla.org/2010/05/upcoming-changes-to-the-viewport-meta-tag-for-firefox-mobile

Enabling the tiling

We haven't actually enabled tiling yet, so lets go ahead and do that. That is very simple as it is basically a setting:

    QWebSettings::globalSettings()->setAttribute(QWebSettings::TiledBackingStoreEnabled, true);

Voila! Mind that if you are going to add animations to your zoom/scale or want to implement a fancy kinetic scrolling you might want to take a look at QGraphicsWebView::setTiledBackingStoreFrozen. With this you can avoid updates to your tiles during an animation, for instance.

Avoiding scrollable sub elements

One big issue with the above is that, iframes and sites using frames can contain scrollable sub elements. That doesn't work well with the touch interaction model, as you want a finger swipe to scroll the whole page and not end up just scrolling a sub frame. Most mobile browser work around this by enabling something called frame flattening.

Going straight to the point:

    QWebSettings::globalSettings()->setAttribute(QWebSettings::FrameFlatteningEnable, true);

This will make all frames from a web page expand themselves to the size of their contents, keeping us free of scrollable subareas.

QtWebKit goes Mobile

2010-06-22T23:22:04+00:00

There is a lot of effort being put into QtWebKit in order to make it attractive on the mobile front.

Among a tons of bug fixes and good performance improvements there are also lots of new features being developed, mainly geared toward mobile deployment.
The goal with this tutorial is to help you understand some of these new features and how to make the best of them. Or said in other words; how to create a good mobile web view that can be used on touch devices.

First we should make it clear that QGraphicsWebView is the way forward, so if you want to target mobile devices, it is bye bye QWebView. Why is that? Well, the QWebView is based on the QWidget system, thus it cannot easily support rotation, overlays, hardware accelerated compositing and tiling. If you need a QWidget anyway, you can always construct a QGraphicsView (which is a QWidget) with a QGraphicsWebView inside.

So let’s start with the most simple QGraphicsWebView based “browser” ever:

int main(int argc, char **argv) { QApplication app(argc, argv); const int width = 640; const int height = 480; QGraphicsScene scene; QGraphicsView view(&scene); view.setFrameShape(QFrame::NoFrame); view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); QGraphicsWebView webview; webview.resize(width, height); webview.load(QUrl("http://www.wouwlabs.com/blogs/jeez")); scene.addItem(&webview); view.resize(width, height); view.show(); return app.exec(); }
Here we just bootstrap a QGraphicsView application and add a QGraphicsWebView to the scene.
It might seem a bit useless as you can only navigate through one website, but it serves well as a simple example. Notice that I’m disabling the scrollbars on the graphics view because QtWebKit handles scrolling and scrollbars automatically. This is due to scrolling optimizations and due to the fact that web authors can interact with the scrollbars for instance style them differently.

On touch-based mobile devices a feature known as tiling is often used. It is used due to the interaction model (touch) as well as a scrolling “optimization”. With this optimization we will have to deal with scrolling ourselves and we thus will have to say good bye to the scrollbar styling. Not a big thing, as mobile browsers usually do not even show scrollbars, but use scroll indicators instead.

Tiling basically means that the contents of the viewport is separated into a grid of tiles, so that when you update some area, instead of just updating the area you actually update the whole tile. This gives a few advantages for scrolling as when you scroll you do not need to repaint the new visible area for each scroll step, as you update a row of tiles each time; tiles that are often only partly on the screen. This minimized all the paint calls that we have to do and makes it possible to make nicely kinetic scrolling a possibility.

Loading, layouting etc are blocking operations. Though barely noticeable on a Desktop machines, these operations can block for a long time on a mobile device, letting the user believe the application has become unresponsive and died. Scrolling which is done by using fingers will also stall and give a bad user experience.

One way to over come this issue, is to do all loading, layouting and painting (basically all non-UI related work) in another thread or process, and just blit the result from the web process/thread to the UI. When using tiles, you can blit any tile available when scrolling. When no tile is available you can show a checkerboard tile instead, not letting the scrolling wait for the tiles to be updated. This results in a responsive interface, with the only disadvantage that you from time to time might see checkerboard tiles.

Tiles also helps with zooming. Repainting at each zoom level change during a zoom animation is basically impossible on a mobile device (or desktop for that sake) and thus with tiling, you can stop the tiles from being updates and just scale the already existing tiles, and then at the end of the animation update tiles on top of the scaled ones.
For now we will ignore the blocking issue and concentrate on the tiling and the interaction model.

Resize to contents
When using tiling, we basically want the QGraphicsWebView to act as our contents, as it supports tiling a.o. things. In order for this we need to make it resize itself to the size of its contents. For this we will use QGraphicsWebView::resizesToContents.

From Qt 4.7 documentation: “If this property is set, the QGraphicsWebView will automatically change its size to match the size of the main frame contents. As a result the top level frame will never have scrollbars. It will also make CSS fixed positioning to behave like absolute positioning with elements positioned relative to the document instead of the viewport.”

This setting, thus, removes the scrollbars for us on the main frame and makes our QGraphicsWebView resize itself to the size of its content.

Enabling it, is as easy as: webview.setResizesToContents(true);
Qt 4.7 docs also says: “This property should be used in conjunction with the QWebPage::preferredContentsSize property. If not explicitly set, the preferredContentsSize is automatically set to a reasonable value.”

If we are going to expand our mobile web view to the size of the contents of its contained page, then that is going to make the view a lot bigger than what can fit on the device’s screen!

Using a view as the window to the contents
The idea is to have a custom widget which has a QGraphicsWebView as a class member. Remember that the QGraphicsWebView will be as big as its content’s size, so this custom widget will serve as a window, as a viewport.

There is not much more to say here, and the following code snippet illustrates it well:

class MobileWebView : public QGraphicsWidget { Q_OBJECT public: MobileWebView(QGraphicsItem *parent = 0); ~MobileWebView(); bool mousePress(const QPoint &value); void mouseMove(const QPoint &value); void mouseRelease(const QPoint &value); private: QGraphicsWebView *webView; };
In order to properly handle mouse events you must install an event filter on web view or stack it behind its parent object (search for QGraphicsItem::ItemStacksBehindParent). By doing this the mouse events will reach a MobileWebView instance before they reach the member QGraphicsWebView. Keep in mind that you’ll need to add some logic in order to distinguish different mouse events and gestures like a single click, double click, click-and-pan, besides scrolling will have to be implemented manually, as zoom, etc. That is left as an exercise to the reader.

Adjusting how contents is laid out
When testing the above on a device, you will notice that many pages do not layout very nicely. In particular the width is larger than the width of the device!
The way web contents is laid out, is that the first the viewport width is used for fitting the contents. If the contents doesn’t fit due to non-flexible element with a width larger than the viewport width, the min width possible will be used. As most pages are written with a desktop browser in mind, that makes only very few sites fit into the width of a mobile device.

QtWebKit has a way to force a layout to a given width/height. What really matters here is the width. If you layout a size to a given width, it will get that width and images etc might get cut of. The width/height is also used for laying out fixed elements, but when we resize the QGraphicsWebView to the size of the contents, fixed elements will not be relative to the view, which is the behaviour found on most mobile browsers.

From Qt 4.7 documentation: “If this property is set to a valid size, it is used to lay out the page.”.
We saw that this property is automatically set to a reasonable value when using QGraphicsWebView::resizesToContents.

As you can imaging, laying out with a smaller viewport can cause pages to break, and as thus, a default value has been chosen so that it almost breaks no pages while still making the sites fit. This value is 960×800. If the device have a bigger resolution, this value can be changed using: webview.page()->setPreferredContentsSize(QSize(desiredWidth, desiredHeight));
You can play around with this and find your own magic number, but let’s stick to this 960px wide for now.

The ‘viewport’ meta tag
As some sites do not work with 960 or want to have control on how the page is laid out, QtWebKit as well as Android, Firefox Mobile and the iPhone Safari supports a meta tag called viewport.
This one also deserves a whole blog post for itself. For now let’s just say that this is a meta tag that Apple came up with to make a web page capable of “telling” the browser how it wants to be shown.
More info here and here, both from Apple’s docs.

In QtWebKit trunk we already have support for this with a nice API. You must connect the signal from QWebPage::viewportChangeRequested(const QWebPage::ViewportHints& hints) to a slot of your mobile web view and use what is provided by QWebPage::ViewportHints to updated your viewport size, scale range, and so on.
This can be tricky and that’s why I’m not going deeper on it right now. Since I know you are curious about it I’ll leave you with one more exercise! So go ahead and try to understand how the guys from MicroB and Firefox Mobile dealt with this.

Enabling the Tiling
We haven’t actually enabled tiling yet, so lets go ahead and do that. That is very simple as it is basically a setting: QWebSettings::globalSettings()->setAttribute(QWebSettings::TiledBackingStoreEnabled, true);
Voila! Mind that if you are going to add animations to your zoom/scale or want to implement a fancy kinetic scrolling
you might want to take a look at QGraphicsWebView::setTiledBackingStoreFrozen. With this you can avoid updates to your
tiles during an animation, for instance.

Avoiding scrollable sub elements
One big issue with the above is that, iframes and sites using frames can contain scrollable sub elements. That doesn’t work well with the touch interaction model, as you want a finger swipe to scroll the whole page and not end up just scrolling a sub frame. Most mobile browser work around this by enabling something called frame flattening.
Going straight to the point: QWebSettings::globalSettings()->setAttribute(QWebSettings::FrameFlatteningEnable, true);
This will make all frames from a web page expand themselves to the size of their contents, keeping us free of scrollable subareas.

Conclusion
As you can see the inner truth here is that there is no “black-underground-magic” at all!
QtWebKit is getting better and better and you have plenty of APIs to help you out developing your applications, be it a browser or a piece of software with embedded web contents.

If you want to take a closer look at some real world examples of QtWebKit in action I’d recommend the raskbrowser and the yberbrowser. I’m sure you will recognize each of the above steps in their source code!

Keep hacking!

Announcing QFacebook: Qt port of Facebook Graph API

2010-06-22T22:55:06+00:00

Hi, everyone. Sorry, but no coding examples for today (even though I haven’t posted anything in a while ).

Today, I’m announcing a new project open for development: QFacebook. It consists of a Qt port of the Facebook Graph API.

The interest in creating this project came from another one that we are currently working on at INDT. We needed to access and manage Facebook accounts, but we didn’t want to use the old rest API.

There are three non-C++ solutions available: the official Javascript SDK from Facebook, a PHP SDK and a Python SDK. Seeing the lack of a Qt port for this API we decided to make our own library.

The project is hosted at gitorious and the the URL is:

http://gitorious.org/qfacebook

As of now, the project has two usage examples that you can start coding with. But we are still working on the documentation.

Anyone is welcome use it or even join our development effort.

Finally some news….and more Akademy!

2010-06-22T13:53:24+00:00

I’ve been busy with some “internal work” that was not that fun and due to that, it was not worth it talking about it . However during this time I wrote some KDE stuff and right now I’m busy with some awesome work and this one I’ll share with everybody

During what I call “bad days” I focused on writing the new Plasma data engine for the pastebin services. Actually, I decided to call it “sharebin” as pastebin remembers about just one service and doesn’t mean too much for the end user, while “share” is a great word to describe what this engine actually does. Basically it will be plugin based and the plugins (backends for services) can be written using JavaScript.

The benefits? It’s easier to extend and support new services so no more bugs on bko asking for this or that service (you can *easily* implement it and provide it through kde-apps.org). Because of that, applets using the new data engine will be able to use GHNS to extend the amount of services that it uses.

As soon as we unfreeze trunk, I’ll send the engine for review and then update the pastebin applet to support it. Ah, we are also using KIO inside the data engine now! So, we also have support for “remote shares” (remote as in getting a file that is in the network – samba share for example). Good news right?

Now, I started to help the KDE PIM dudes and KDAB with their mobile version of the suite and anything that is related to it. So, I’m really looking forward having a great PIM suite for mobile devices. It uses all of the KDE infrastructure and the brand new Qt technology for creating rich UI interfaces: QML. It’s important to say that everything is being done on the open and upstream. Take a look at kmail mobile right now:

At the same time I’ll be in touch with the guys working on the Qt Components project, to provide feedback and use the stuff they are getting done. This is a really important project for QML and if you ever played with QML you know what I’m talking about .

I’m also going to Akademy this year thanks to the help of the e.V. and it’s sponsors (special thanks to Claudia that helped me with the booking ). I’ll have a talk there with my fellow Alexis Menard about Plasma mobile and I hope that everybody that will be there enjoy the talk and the paper that we are working on! I also recommend the talk about Qt Components from Eduardo Fleury! If you want to talk about KDE Mobile, any other mobile subject (MeeGo, Maemo), anything KDE related, just about soccer or say hello…just do it I’m too small to prevent you from doing any of the above listed things

Unofficial Qt 4.6.3 for Symbian Linux Installer + Qt Mobility + Smart Installer

2010-06-22T00:23:25+00:00

Hi again!
Qt for Symbian 4.6.3 has been released since last week, and now I've finally updated the unofficial Qt for Symbian Linux installer to work with this version. I'm glad to share this tutorial, with many thanks to my colleagues Anderson Lizardo and Danilo Cesar for helping me understand how the Qt for Symbian installer scripts works. This updated "All-In-One" installer installs the following:

Qt for Symbian 4.6.3
Qt Mobility 1.0.0 (opensource)
Nokia Smart Installer 0.18beta

I must advice beforehand that besides everything's woking as expected, I still haven't had time to fix a small issue (don't worry! it's not critical) that outputs when building a source code, which happens to be some annoying warning messages regarding missing include paths:

(WARNING): ../myproject/src/src_0xE4023dec.mmp(53) : SYSTEMINCLUDE path "../5.0/epoc32/include/osextensions/stdapis/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(54) : SYSTEMINCLUDE path "../5.0/epoc32/include/osextensions/stdapis/sys/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(57) : SYSTEMINCLUDE path "../5.0/epoc32/include/osextensions/stdapis/stlport/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(59) : SYSTEMINCLUDE path "../5.0/epoc32/include/oem/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(62) : SYSTEMINCLUDE path "../5.0/epoc32/include/osextensions/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(63) : SYSTEMINCLUDE path "../5.0/epoc32/include/domain/osextensions/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(64) : SYSTEMINCLUDE path "../5.0/epoc32/include/domain/osextensions/loc/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(66) : SYSTEMINCLUDE path "../5.0/epoc32/include/domain/osextensions/loc/sc/" not found
(WARNING): ../myproject/src/src_0xE4023dec.mmp(67) : SYSTEMINCLUDE path "../5.0/epoc32/include/domain/middleware/loc/sc/" not found

The install instructions pretty much follows the guidelines for Lizardo's Qt for Symbian 4.6.2 Linux installer (see below).

Preparation

You need to download the following files:

Download all the required files and store them on a common folder (ie. ~/Downloads). For building the native tools from GnuPoc, you will need the following packages:

GCC C/C++ compilers
ZLib library development files
OpenSSL library development files

Additionally, you will need Wine to execute Qt-related buildsystem utilities. On Ubuntu, you can install these running the command below:

$ sudo apt-get install build-essential zlib1g-dev libssl-dev wine

Installation

Everything set, now we can proceed for install. First, install GnuPoc + S60 SDK + Open C/C++ plugin for S60 SDK:

$ ./gnupoc_1.15_installer_v2.sh <download-dir> <gnupoc-dir> <x.y>

Where <download-dir> is the common downloads directory (ie. ~/Downloads), <gnupoc-dir> is the destination directory for GnuPoc and the SDK files (ie. ~/gnupoc) and <x.y> is the SDK version you want to install (ie. 3.1 or 5.0). Note that both directories must have absolute paths.
If installation was successful, you should see an output like:

Installation has finished. Before using the GnuPoc SDK, run these commands on the console:
 
export PATH=<gnupoc-dir>/bin:$PATH
export EPOCROOT=<gnupoc-dir>/symbian-sdks/5.0/ # trailing "/" is required!
 
(These commands must be run again every time a new console is opened.)

Run the commands as instructed on the message. Now we can proceed to install the Qt for Symbian 4.6.3 All-In-One Linux installer:

$ export PATH=<qt-s60-dir>/bin:$PATH
$ ./qt_for_symbian_4.6.3_all_in_one_linux_installer_v1.sh <download-dir> <qt-s60-dir>

Where <download-dir> is the common downloads directory (ie. ~/Downloads), and <qt-s60-dir> is the directory for Qt Symbian files (ie. ~/gnupoc/qt-4.6.3). Note that both directories must have absolute paths.
If installation was successful, you should see an output like:

Installation has finished. Before using the Qt for Symbian SDK, run this command on the console:

export PATH=<qt-s60-dir>/bin:$PATH
unset QMAKESPEC # make sure there is no QMAKESPEC variable set
 
(This command must be run again every time a new console is opened.)

Before using Qt for Symbian, you should run the command as instructed on the message above. Now you can start coding in Qt for Symbian directly from you Linux machine :)

ps: Thanks to Pinaraf for the feedback when executing the steps from this tutorial!

ps2: I would like to notice that I'm going to KDE's Akademy this year to present a workshop called "Plasma Animations Overview (aka. Pimp my Plasmoids!)". So, if you're also going there and still needs some help regarding Qt for Symbian usage on Linux, be sure to ask!

libgcal 0.9.5 plus a video

2010-06-20T21:04:59+00:00

It is being a quite busy week and it shows since it is being just a few days since previous release of libgcal.

This is a highly recommended upgrade, and also I point every pacman (Package Manager/Maintainer) to use version 0.9.5 of libgcal to create packages for your distribution. As Fathi Boudra (the debian packager of libgcal) pointed to me, release 0.9.4 was missing 3 public user functions featured in previous releases.

Now ABI has being restored, plus some extras:

Support for IM field. This is not exported to akonadi resource yet, since it seems that in KAddressBook there is not an easy way to specify the IM type (i.e. skype, AIM, etc)
As said previously, restored ABI (gcal_contact_get_phone, _set_phone, _set_mail will map to the prefered field)
some memory leaks are fixed
improved unit test coverage

The akonadi resource has not changed, so you can continue using akonadi-googledata-1.1.0 *with* libgcal 0.9.5.

And last, but not least, special thanks to Holger Kral who is helping me to make KDE support for google contacts near to perfection.

To close this post, a nice video showing kaddressbook updating a google contact with basically all possible fields.

Accelerating 2D with Gallium3D

2010-06-15T00:40:15+00:00

Gallium3D is the Linux/Unix(tm) 3D infrastructure. It can be described as a set of interfaces and a collection of supporting libraries[1].

It has module called state tracker that translate the graphics api states, shaders and primitives in something that the pipe driver can understand.[1]So when you want to create a new Graphics API you need to write a new state tracker.

The pipe driver basically translate the shader, primitives and all others state in something that the hardware can understand. [1]

And finally the Winsys communicates with the OS. This archicture does gallium3d work in every Operating System.

So what i am doing?

Now i am hacking a State Tracker to cairo graphics[2]. With cairo i just care with the Canvas trying to make it fast and fast.

I hope writing the Gallium3d backend improve cairo perfomance in some advanced operations like some kind of Blend or creating a GPU like AA(Anti Aliasing).

So what is the advantage of it?

Well, We are removing a layer. Normally the Graphics ToolKits have the backends implemented over OpenGL, OpenVG or X11. And OpenGL and OpenVG are done over Gallium3D. Creating Cairo State Tracker we can access gallium directly.

But there are problems too. Removing a layer we are adding complexity. With OpenVG we can draw and fill complex paths. Creating the state tracker we need to implement algorithms to draw paths and fill them for example.

What we have right now?

Now we have some basic operations like draw paths, clipping and filling.

It is in the early stages but it is a start.

By the way, In the next post i can explain a little bit about the code.

[1] http://jrfonseca.blogspot.com/2008/04/gallium3d-introduction.html

[2] http://cgit.freedesktop.org/~igor.oliveira/cairo-drm-gallium/

libgcal 0.9.4 released

2010-06-11T02:20:58+00:00

Sweet! But what the heck is this ‘libgcal’ thingie? For starts, the name can and is misleading, since it should read as ‘library for google calendar’ but in reality, it implements both Contacts and Calendar google data protocol.

When I got it started, back in February of 2008, it was supposed to implement just calendar, but later on I realized that adding contact support only required +25% of code on it (thanks for well modular software design). Back then, there was no other good alternative for any C/C++ programmer that would fit the following requirements:

easy to use;
well documented;
few dependencies;

So, I got my library started! After studying the google data protocol 1.0 (at the time) for while, I realized that using XPath would make my life way easier than say, browsing through the DOM tree searching for the attributes and tags that I wanted.

At that time, Qt didn’t have support for XPath (it only started with 4.5), so I went with libxml. For networking I used libcurl, which is fast/reliable and has great documentation (and a very welcoming community, from time to time I asked for help and always got answers for my questions).

From the very early beginning, I set a high quality standard in the development (after all, parsing XML in C is already prone to errors by itself) and followed a TDD (Test Driven Development) approach where *first* I write the test and *later* write the implementation of functions. Having an average of test coverage of 80% helped a lot when google released version 2.0 of the protocol (back in december 2008) and now more recently, version 3.0 of Contact’s protocol. I did the porting from version 1.0 to version 2.0 of the protocol in few hours, mostly because I could detect any regression by simply running the test suites.

IIRC in about 4 months I got the basic (authenticate, retrieve, add/edit/delete, query for updates) done and the library even got featured in the google official blog (that was surprising to say the least)!

So, the library was ‘done’, let’s put it to good use. I decided to integrate it with Opensync (it was rather cool, I got google contacts and calendar sync for my Nokia N95 over bluetooth working 6 months before google decided to release a syncml server for S60 devices). You can see a pre-jurassic video of this here. I think up until now libsyncml is a pretty good syncml implementation, it is just a shame that there is not a good UI bounded to it.

But I needed a good UI and the alternative seemed to write an akonadi resource. In just 3 weeks I got contacts working, while also implementing missing features in libgcal to make possible to do fast-sync (i.e. when you download only what has changed in server side). Contacts resource was done in just 3 days (I think this is clearly a good signal that akonadi API is well designed).

Developing the akonadi resources gave the opportunity to better understand how KDE community works and also to start running KDE trunk as my default desktop (after all, pre-packaged software are for sissies and developers should eat their own dog food).

So, why I wrote all this story? Well, to help to understand some numbers:

10 months ……. since last release (0.9.3)
6 distros ………. pre-packages libgcal (Debian, Ubuntu, OpenSuse, Gentoo, Mandriva, FreeBSD) and counting
2326 downloads .. directly from libgcal project website (hey, this is a source code tarball of a library and not some porn!)
20681 views …… reported by google analytics in a 1 year period
3000 ms……… the lag to ping google servers in a bad day in Manaus/Amazonas (yeah, truly it is unbeliavable how I managed to write a *networking* library in this enviroment but what doesn’t kill you makes you stronger)
6762 LOC ……. lines of C code (34% are unit tests)
76.5 % ……… current *real* code coverage (here I slipped a bit, it used to be 80%)
10th ……….. of most wanted KDE features

So, what this new release brings? For start, support for multiple email addresses, patch by Stefano Avallone (Andre Loureiro helped to fix the unit test) and migration to Google Contacts API 3.0. Next, support for structured names and several other fields (nickname, blog, etc) by Holger Kral. I think currently only IM field is missing from the library (but is quite easy to implement that).

You can have access to both the library and the akonadi resource in libgcal website. The only issue is that is required to purge your akonadi resource and do a slow-sync again because the ETags and urls of contacts have changed thanks to migration to version 3.0 of protocol.

So, what is missing in the library for a 1.0 release? The following features:

support multiple calendars (easy to do, is a matter of using another URL as base to do the network operations)
support recurrent events in calendar (thanks to the fact that google uses an invalid iCal to represent it, it gets tricky to implement it since a iCal parser would fail to read this data). An idea to implement this would be to ‘convert’ the invalid iCal from google to a valid one and do the opposite when sending data back to the google server.
batch commit (nice to have, but not a hard requirement)
port/rewrite it all to Qt (seriously, this was actually started already: http://code.google.com/p/libgdata-cpp/). Here I’m somewhat unsure, if Qt has support for the XPath/XQuery in Symbian (it seems that RTTI is not supported in this OS).

Oh well… so, why not give it a try? If you got the skills, go on and download the sources (please check the README and INSTALL files) and feel free to report to me how things worked (or not…).

If you are a normal user, I think in a couple of weeks it should get packaged for your loved distro.

MADDE + Qt 4.7

2010-06-10T03:10:57+00:00

Maemo 5 PR 1.2 is out with Qt 4.6.2 installed, so developers now can create applications with Qt 4.6 using either the official scratchbox based SDK or MADDE (remember, “MADDE is currently a technology preview.”)

BUT… there are people who prefer “Livin’ on the Edge“. If you are one of those and already want/need to develop with Qt 4.7 (not released yet!) for Maemo 5, using MADDE to build your applications / packages, here is an update to the procedure first published by the troll Harald Fernengel (AKA harryF). Although the title says “on MacOS X”, the steps also work on Linux.

Step-by-step:

Install MADDE. Download it here.
If you are not using a Debian based distro, you need to install the “Tools for Debian Packages” package of your distribution (e.g. “deb” on openSUSE, sys-apps/debianutils on Gentoo).
Download the script ~~fetch-qt4.7.0~git20100520-0maemo1.sh~~ fetch-qt4.7.0~git20100614-0maemo1.sh . This script downloads the libqt4-experimental packages from repository.maemo.org and installs then in your MADDE – Before you run the script, remember to adjust the MADDE_PATH variable according to the path you installed MADDE.
Download ~~qt4-maemo5-qt4.7.0~git20100520-0maemo1.tar.gz~~ qt4-maemo5-qt4.7.0~git20100614-0maemo1.tar.gz. It contains the Qt tools compiled for the correspondent version, configured for cross compiling. Extract to /opt/qt4-maemo5.
Check if mad is in your PATH.

To build an application using your fresh environment, run /opt/qt4-maemo5/bin/qmake && make .

If you succeeded in the setup process, this should result in a armel binary ready to run on N900. To generate a deb package, you can use the tools offered by MADDE to build a skeleton of debian package and so on.

To run your application on N900, install libqt4-experimental-* packages. If QtQuick (QML) is part of your plans, qmlviewer is in the package qt4-experimental-declarative-qmlviewer .

UPDATE (2010-06-15): For newer (or older) versions, check http://anselmolsm.org/public/qt/madde-qt47/

I am going to Debconf 10

2010-06-01T15:31:21+00:00

Yes, thanks to the excellent Valessio Brito I already put the “I’m going to DebConf10” button on my front page. Absolutely stoked!

New Qt WebKit nearing release

2010-05-31T18:06:03+00:00

So, for the first time, we are going to release Qt WebKit as a separate project. This does not mean that we will stop releasing it as part of Qt, but that if you are stuck on an older Qt 4.6 release, it is still possible to use a newer Qt WebKit. In the future this also allows us to release more often, independently of Qt.

The last half year we have been hard at work on enabling the use of Qt WebKit on mobile devices, while still supporting and maintaining our brilliant support of Desktop applications. Targeting mobile devices is an ongoing challenge due to other interaction modes, smaller screen sizes and less powerful processor.

We have been growing our teams and our responsibilities and it has been an interesting, if not tiring, half a year :-) Locally, we have been growing our Brazilian core team to 5 people, plus creating some new teams working on related projects. What a rush! :-) We now have teams in at least Norway, Finland, Brazil and Boston working directly on WebKit.

So what have our distributed teams been up to?

Well, Qt WebKit has always felt reasonable fast on the Desktop. Not top in the class, but working quite well. On mobile devices the story was very different; dog slow, barely usable! Lots of time has gone into improving that situation by doing profiling and hunting down performance bottlenecks. Improvements that also help the Desktop case. We are not done yet, but our upcoming QtWebKit 2.0 release is a major improvement. Combining QtWebKit 2.0 with the upcoming Qt 4.7, are you will even get a few extra optimizations for free.

Sometimes we had to make more drastic changes, such as using tiling for archiving good scrolling performance. Tiling basically means that you don't paint directly to the screen, but instead to surfaces (which then can actually benefit from hardware acceleration). When scrolling you then move/blit these tiles. The standard way of doing scrolling, is that you copy an area and move that area, but you always have to paint the new area visible. With tiling you normally update a few more row of tiles than those visible on the screen, so when moving you do not always need to repaint. Repainting can actually mostly be done when you are idle.

We also experimented with rendering the tiles in another process, so that scrolling would never be blocked by loading or painting, but with the downside than when there is no tile painted, a checkerboard pattern would be shown, very similarly to the iPhone. Getting this right is a lot of work and with the announcement of WebKit2, we decided to postpone it for now and later concentrate on WebKit2 instead, as that will bring similar benefits, a.o.

Tiling helps with the mobile interaction model, as it is quite fast to zoom. Zooming basically scaled the tiles and then re-renders, which can be done with a smooth animation. Unfortunately, just as on the iPhone, we cannot support fixed elements, so if page authors really need that, they will have to go for CSS3 Transformations which with accelerated compositing will be painted as another layer on top of the tiles.

Which brings me to the next feature: accelerated compositing. Some of the new CSS3 features such as animation and transformations were created with hardware acceleration in mind, for instance the CSS 3 transformation live in another coordinate system, and thus animating a transformation change does not change any DOM values such as for instance 'left'. The idea is that the elements being transformed are painted as a separate layer, composited on top of the normal web contents. On the iPhone, this is implemented using CoreAnimation, I believe, and is thus, tied to hardware support. For Qt, we implemented it on top of out Graphics View system, which means that even when the Graphics System is not being accelerated by hardware, we will archive better performance due to caching of the painted elements. Pretty cool stuff. Unfortunately, just as with tiling, it is only possible to take advantage of this new feature if you use the QGraphicsWebView and not the older brother, QWebView.

You can imagine that most web sites were written for a width a lot larger than what you find on most phones, so either you can show the page in its original size and you will have to scroll a lot, or you can zoom it out to fit within the width of the page. The latter makes it impossible to read the text, so instead of laying out to the size of the width, we have new API (actually originally introduced in Qt 4.6) that makes it possible to lay out the contents as it was having a different viewport. The iPhone and Android does the same, using a value between 800 and 1008 pixels (980 is always default on the iPhone, where as Android varies). Laying out with such a width makes the site's contents still readable most of the time, without breaking the layout. To give the page authors a bit more control over this, Apple introduced a meta tag called "viewport", which is now supported by most mobile browsers, including Mozilla Fennec. This tag allows the site author to specify which width should be used for laying out the contents as well as which zoom factor should be used, and within which limits.

As touch is becoming standard on cell phones, we also had to make a few other adaptations. For instance sites with frame sets are mostly useless due to various scrolling sub elements; the same count for sites with iframes. What most mobile browsers do to fix this, is to apply frame flattening, which we now also supports/ Originally a feature invented by Nokia, but first really being put to good use on the iPhone and on Android.

We didn't leave out non-touch phones either, and as such implemented spatial navigation (aka. keyboard navigation), which is not only useful for cellphones with keyboard only, but also by tv's and set-top boxes.

Not everything has been related to mobile though, and as such our teams have been working on implementing new HTML5 elements such as the Progress element and concentrating on some CSS features and DOM features, such as DOM Level 3 CustomEvents, 'view-mode' Media Feature, as well as some features from CSSOM Views making it possible to listen to media and media feature changes; very useful for creating Web applications.

Wow, it has been a loooong half year it seems! Now time to prepare for our local release parties! :-)

6 months of plasma in 10 minutes

2010-05-21T03:42:23+00:00

Not really… It is actually 7 months of “kdelibs/plasma” (or libplasma) repository activity in 15 minutes (but that would not sound really as attractive as a post title).

Today a fellow co-worker showed to me a really nice application: gource (like ‘source’ but with ‘g’ letter, maybe for ‘graphics’) written by Andrew Caudwell. This application offers some really nifty source code control visualization and supports git/mercurial and other source code control systems using some hacks.

Since internet speed (not even talking about latency…) in Manaus/Amazonas is lacking to say the least, I decided to use git-svn to checkout a specific revision of kdelibs/plasma directory and later I did a rebase to update the code with the trunk.

So, for your amusement, enjoy.

I have some hints about this visualization:

in the first seconds there is an explosion of files (because I didn’t checkout the code from the very first commit in svn, is like the touched files warped inside of logs)
the code seems to be rather modular (there are a well defined set of clusters on it)
development speed is affected by some special dates (feature freeze, Christmas, Tokamak, etc)
there are a quite varied number of contributors working in libplasma (which is good! KDE is a pretty open community)
the overall champions in commits are (unsurprisingly!) Aaron and Marco

Partindo para novos desafios – Obrigado INdT

2010-05-20T18:11:12+00:00

Recebo incentivos do INdT desde a universidade, quando era bolsista laboratório de VoIP(UFAM) financiado pelo INdT. Depois disto, passei a fazer parte do stream 10LE dentro INdT, agora chamado de OpenBossa pela comunidade. Foram muitos projetos e mudanças neste 4 anos!

Durante estes 4 anos de trabalho, aprendi muito tecnicamente. Acredito que dentro da empresa existam vários pontos a serem melhorados, mas estes problemas são pequenos perto das vantagens de trabalhar em projetos envolvendo GNU/Linux/OpenSource para a Nokia. Percebo que as habilidades desenvolvidas aqui nos permitem concorrer igualmente em vagas para vários lugares do mundo. Prova disto é termos vários colegas do INdT que passaram a trabalhar em ótimas vagas fora do país, apenas por possuírem as habilidades e contatos criados aqui. Por estas razões, acredito que o INdT seja um ótimo lugar para trabalhar.

Esta semana deixarei de trabalhar no INdT! Partirei para novos desafios em Brasília. Irie mudar de cidade por razões pessoais, pois minha noiva passou a morar lá. Aguardo desde do começo do ano a oportunidade de mudar para o stream do INdT em Brasília, mas infelizmente nenhuma oportunidade surgiu neste período. Agora parto para outra empresa, onde espero ter bons desafios, como os enfrentas aqui no INdT.

Dentro do INdT, fiz vários amigos dos quais sentirei muito saudade! :’( Estes me ajudaram a crescer como pessoa. Agradeço a todos pelo companherismo e amizade que tivemos!

Muito obrigado,

Alecrim!

Create Meego rootfs using Ubuntu Lucid

2010-05-20T15:46:29+00:00

This week I took some time playing with Meego distro. I got a D510MO motherbord with Atom processor to put Meego working on it. It wasn’t a hard work regarding Meego already contain a X86 repository. Last Meego release was from March 31st but they have a repository contain more recent packages. So I created a new image with most recent packages. I faced some problems to create Meego image using Ubuntu and notes about my experience with Meego are available on my wiki page.

Notes available HERE!

PySide v0.3.1 (’Knightsbridge’) is now available!

2010-05-05T16:02:50+00:00

A new version of PySide is now available.

What’s changed since 0.3.0?

With the technical preview release a few weeks ago we moved from a Boost based source code to a CPython one. This move was necessary to reduce our footprint. Now we have the first official release of this new PySide based on Shiboken (CPython) generator. Since the technical preview the main points are:

- Bindings for the last missing modules: Phonon, QtScript, QtScriptTools, QtMaemo5, QtHelp, QtMultimedia, QUiTools and QXmlPatterns;
- Fixed some memory and reference leaks;
- Lots of bugs fixed;
- Revamped documentation.

For more Qt 4.6 information, Qt 4.6 webpage

We hope you enjoy this new release! Feel free to contribute with comments,
bug reports and suggestions.

Packages for Fremantle are available on extra devel repository. More info in PySide webpage.

Symbian development using Linux on real life…

2010-05-05T13:30:13+00:00

I believe most companies that develop Symbian products uses windows, and only windows, on their development process. Well… We don’t =)

When we started to develop symbian applications at INdT we, as open source developers, decided to find a way to keep using linux as our development environment.
On the beginning we didn’t have yet an official way to compile our applications on linux, so we used (and still use) Lizardo’s patchs that enables gnupoc to compile Qt-symbian applications on Linux.

First tip:

Personally I think finding errors on gnupoc output is an exhaustive job. So, the first tip for those who’re using Lizardo’s approach is to use a small piece of code in your .bashrc

function makes60
{
  make debug-gcce 2>&1 | while read line
  do
    echo -e $(echo $line |
      sed 's@\\@\\\\@g' |
      sed "s/.*error.*/\\\e[0;31m(&)\\\e[0;31m/I" |
      sed "s/warning/\\\E[33m(&)\\\E[0;37m/gI" |
      sed "s/No such file/\\\E[33m(&)\\\E[0;37m/gI"
      )
  tput sgr0;
done;
}

By calling makes60, every error/warning message will be highlighted in read/yellow.
It's a simple tweak, but it is very useful.

So, we can compile our application, easily read the compiler messages... Now what?

Analyzing the process:

Let me list our development phases:

Coding: OK with vim
Compiling: OK with gcce and some tweaks
Debugging: (As we work almost only with default Qt API, we build for linux first and debug there). So, it's almost OK.
Packaging .sis: OK with make sis
Send to device, install and test: It's a slow process yet.

Testing on the device is a very difficult/slow task on linux. We don't have a debugger. We don't even have any output message (Ok, we have: with stdioserver writing on an txt file. Too hard!).

How does it works for Windows developers? Carbide++ and TRK!

Of course we don't want to install Carbide++ on linux. So, can we use TRK with linux? Yes, we can! First of all you need to get the TRK application in Carbide++ package or in newly released Nokia SDK.

Installing TRK:

Send and execute TRK.sis on the device.
Open TRK application / Options / Settings, and select Connection = USB instead of bluetooth.
Go to TRK mainscreen / Options / Connect.

If your USB cable is plugged you will receive a "Status: Connected" message on your phone.

Now you need to create a serial connection between the device and your linux machine. If you're using a 2.6.33 kernel you don't need to do that. Otherwise you need to create it manually.

Before you do that you need some information about the device. It can be retrieved with:

[danilo@docbrown ~]$ lsusb  | grep Nokia
Bus 001 Device 011: ID 0421:0154 Nokia Mobile Phones

So, my vendor ID is 0421, and my product ID is 0154. Remember to use your own numbers =)
And then you can load the usbserial mobule with the command:

sudo modprobe usbserial vendor=0x0421 product=0x0154

If everything went OK you should see a message like this:

[danilo@docbrown ~]$ dmesg | grep ttyUSB
[34063.949446] usb 1-4.3.1.4: generic converter now attached to ttyUSB0

Your serial port was created on /dev/ttyYSB0.

Ok, perfect! But how to communicate with TRK?

Trolls are working on that, but for now we’re using the runonphone tool. It’s the same tool used by QtCreator on Windows and you can get it by cloning Qt Repository and compiling the /tools/runonphone folder.

On device testing

After compiled, runonphone can be used by passing the serial port, the sis package and the executable file to it.
runonphone -p /dev/ttyUSB0 -s test_package.sis test_package.exe

As you probably noticed all your qWarning() messages are being redirected to runonphone output. Which is very nice!

On device debugging

We don’t have an interative gdb tool as we have on windows, but Qt guys are close and I’m sure we will have good news in a few days.

Concluding

I’m sure that Symbian development on Linux is near, and it will be massively adopted when those tools became part of QtCreator for linux. For those who can’t wait, or think that VIM is the best IDE ever, I hope those tips can help you. =)

And for those who’re working with Qt for symbian, remember to join the #qt-symbian on Freenode.

Mapping mouse position to angles (QtQuick example)

2010-04-30T20:53:02+00:00

Hi there! This post is to share with you something I hacked these days.

The use case

Image you are writing a widget or a piece of an application interface and you want to rotate something based on a mouse click. For instance, you may have a widget that looks like a rotating knob, or a round analogue gauge.

For this post, let’s use a car dashboard speedometer. What I want here is to click somewhere on the gauge and have the needle rotated towards the current mouse position. Check this video of how it should work.

The problem

In Qt, rotating a widget is easy in the context of QtQuick or QGraphicsView, just define the “rotation” property to the desired angle and you are all set. The problem here is to find out what the desired angle is.

Here I want to find out which is the angle formed between a given mouse position and centre of the gauge, or the origin of the needle rotation. Getting the mouse position is easy in QtQuick, simply watch the “mouseX” and “mouseY” properties of a MouseArea. But what about converting that to an “angle” ?

In mathematical terms what I want is to convert the mouse position from linear coordinates (X,Y pair) to circular coordinates (angle, radius pair) with the centre of the gauge being the origin of my plane. But designers using QtQuick really don’t want to deal with that.

The solution

I made a Qt class meant to be used as a “model” or “helper” for both C++ and QtQuick applications. This class hides the trigonometry required for that conversion by exporting a set of properties, namely:

originX
originY
x
y
angle
radius

So how would we use it in our example?

Set “originX” and “originY” to the centre of the gauge. That’s the origin of the needle, right?
Set “x” and “y” to the current mouse position. In QML that would be “x: mouseArea.mouseX” and “y: mouseArea.mouseY”.
Read the value of “angle“. In QML that would be something like “needleRotation.angle: angleModel.angle”

Then QtQuick data binding system will handle everything else. Every time the mouse moves, the properties “x” and “y” will be updated, the model will then recalculate the values of “angle” and “radius” causing the needle to update itself.

Below you can see a diagram of that behaviour. Note that the opposite also works, that is, once I explicitly set an “angle” and “radius” in the model, the values of “x” and “y” are automatically updated.

Relationship between AngleModel and different coordinates

The Source

To grab the code go to Qt Components Gitorious and check:

examples/clickable-dial
examples/angle-model

Hope you enjoy it. Comments are always welcome.

Exchanging experiences – Bluetooth Linux Kernel

2010-04-30T19:04:24+00:00

It’s time to develop Bluez!

Last month I started working on a new project at INdT. I’m going to help BlueZ development and the new features that are coming, Bluetooth Low Energy is the next generation of Bluetooth. At this moment Bluetooth SIG is still finishing specifications but I need to get used to BlueZ development and current Bluetooth protocol. I’ve been working with some small BlueZ features to get some experience with it. And I got some patches applied to bluez.git .

Part of our team has experience with Linux kernel development(INdT-Manaus) and some co-workers have good experience with BlueZ(INdT-Recife). Sharing this knowledge was something very important for the team. Now I’m in Recife learning a lot about BlueZ, Bluetooth and Obex with Claudio Takahasi and Vinicius Gomes.

I prepared some material to introduce Linux kernel development. You can access this material HERE!

I’m very excited about this new project! It’s gonna be challenging!

Palestra no FLISOL 2010

2010-04-30T04:41:04+00:00

Semana passada estive realizando um palestra no FLISOL 2010. O evento estava lotado, especialmente por alunos da UNINORTE que vem demonstrando cada vez mais interesse na utilização de sistemas GNU/Linux. A material da apresentação foi o mesmo utilizado em evento interno na UNINORTE, mas desta vez tive bem mais tempo e pude falar mais detalhes e dicas de desenvolvimento.

Acredito que mais da metade dos participantes não havia tido contato com Linux e para estes non-linux, tivemos INSTALL FEST durante todo o evento.

Excelente iniciativa da Comunidade Software Livre do Amazonas!

Material disponível!

PS: Obrigado a Daniel Bruno pelas fotos.

Maemo @ GSoC 2010: Accepted Projects

2010-04-28T15:28:00+00:00

Last Monday, Google announced the list of accepted projects for the Summer of Code Program. Like last year, Maemo has got 10 slots. As Valério said in a previous post, we received about 90 submissions this year, which made the task of selecting the best proposals much more difficult. Many thanks to all people involved on the selection process. :)

Enough talk. Here is the list (in no particular order, just copied and pasted the contents of the wiki page):

Porting Canola to Maemo 5 and beyond
Student: Andrei Mirestean (andrei1089)
Mentor: Eduardo Lima (etrunko)

FaceBrick - a facebook client for Maemo / the N900
Student: Kamilla Bremeraunet (brik)
Mentor: Robin Burchell (w00t)

UPnP Remote Access
Student: Sunil Kumar Ghai
Mentor: Zeeshan Ali

The Tablet of Adventure: a location-based social adventure
Student: Susanna Huhtanen
Mentor: Henri Bergius (bergie)

Extending Shepherd
Student: Linus Wallgren (ecksun)
Mentor: Attila Csipa (achipa)

eBook reader for Maemo 5
Student: Juhana Jauhiainen
Mentor: Valerio Valerio (VDVsx)

Gtk+ Input Method for the Harmattan Input Method UI Framework
Student: Javier De San Pedro Martin
Mentor: Mohammad Dhani Anwari

Transifex mobile
Student: Lauri Vosandi (v6sa)
Mentor: Thomas Perl (Thp)

Optical Page Reader for the N900
Student: David Jordan
Mentor: Florian Boor (Florian)

MeeGo Cloud Storage Integration
Student: Eli Foley
Mentor: Yan Li

Congratulations to all accepted students! Some of them already had worked on projects related to Maemo on GSoC last year. In either case would be really cool to post a small introduction about yourself and the project you will work on during the next months. If you have a blog, request it to be syndicated on Planet Maemo.

For those whose projects were not accepted, and still think it is worth to work on it, you are be more than welcome. Although there won't be any assigned mentor, I am sure you can find help on the mailing lists.

Fun with OpenGL and Shaders

2010-04-23T23:31:20+00:00

Last week i was having fun with OpenGL(in fact QGL) and creating some interesting effects with it like edge detection, embossing and sharpening. So i decided to work with GLSL(OpenGL Shading Language) and create the same effects using Fragment Shaders(yeah hardware accelerated effects).

So i used QGLShaderProgam that allows me create Fragment shaders in a Qt Way(tm). Initially i create two filters the first one was sharpening and the second was edge detection. Both work in a same way(with little modifications), applying a matrix convolution in the image.

The matrix convolution used in sharpening is:

0 -1 0

-1 5 -1

0 -1 0

And the matrix convolution used in edge dection is:

-1 -1 -1

-1 8 -1

-1 -1 -1

Below you can see the fragment shader used in sharpening.

uniform sampler2D sampler;

uniform vec2 offset[9];

uniform int kernel[9];

void main()
{
vec4 sum = vec4(0.0);
int i;

for (i = 0; i < 9; i++) {
vec4 color = texture2D(sampler, gl_TexCoord[0].st + offset[i]);
sum += color * kernel[i];
}

gl_FragColor = sum;
}

The shader used in edge is almost the same

uniform sampler2D sampler;

uniform vec2 offset[9];

uniform int kernel[9];

void main()
{
vec4 sum = vec4(0.0);
int i;

for (i = 0; i < 9; i++) {
vec4 color = texture2D(sampler, gl_TexCoord[0].st + offset[i]);
sum += color * kernel[i];
}

sum += 0.51;

gl_FragColor = sum;
}

The original image used in my experiments can be seen below:

The result of sharpening filter is:

Yeah we have a little bit improvement on the image.

And the result of edge filter is:

The embossing filter is a little bit complicated as you can see:

uniform sampler2D sampler;
uniform vec2 offset[9];
uniform int kernel[9];

void main()
{
vec4 sum = vec4(0.0);
int i = 0;
for( i = 0; i < 9; i++) {
vec4 color_tmp = texture2D(sampler, gl_TexCoord[0].st + offset[i]);
float h = (color_tmp.x + color_tmp.y + color_tmp.z + color_tmp.w)/4.0;
if (h > 1)
h = 1.0;

if (h < 0)
h = 0.0;

vec4 color = vec4(h, h, h, h);
sum.x += color.x * kernel[i];
}

sum.x /= 1.0;
sum.x += 0.51;

if (sum.x > 1)
sum.x = 1;
if (sum.x < 0)
sum.x = 0;

gl_FragColor = vec4(sum.x, sum.x, sum.x, 1);
}

And the result is:

Qt already do OpenGL accelerated filters in QGraphicsEffects classes(look in qt_top_dir/src/opengl/qglpixmapfilter*) it is not anything new but it is interesting use it in others KDE application like krita filters .

Linux Collaboration Summit - MeeGo Workgroup

2010-04-20T13:41:55+00:00

Hey all,

It was a great time in San Francisco last week when I attended the Linux Collaboration Summit.

Presentations from key people of big companies (there were also summit sponsors) fulfill the first day agenda.

I highlight Intel and Nokia presentations, both showing what they want with Meego and both emphasizing the collaborative and open source aspects of the project. Of course the “paradox” of being open and possibly include closed components were source of some questions that the speakers tried to answer, but somehow I feel that some people didn’t get satisfied. The answer is simple in my point of view: products may need more code then Meego provides. Meego could avoid vendors to add closed code to Meego based products by a pedantic licensing scheme but it may be harmful to a project that is just launching and that has a competitor that allows proprietary code to be added. Meego already sees that open source is the way to best quality products, this is very good. Now the vendors that must follow the same way…

In the second day the Meego workgroup!

Firstly, the obvious that everybody says after a conference: very nice to assign faces to nicknames, very nice to have opportunity to answer the questions you have directly to the right person and very nice to do networking.

There were no news in the presentations but the talks were very productive in a way that lot of questions were raised and answered by the speakers like that the Qt will be more than a UI toolkit to become the application toolkit, acting as an interface to access the device resources. There was the nice talk from Marcel also about the connectivity part followed by the technical panel with architects from Nokia and Intel.

I could not forget to say that San Francisco is a very nice city, lot of places to visit, nice weather.. impossible to refuse to take some hours to visit touristic places there!

Well, I just want to say that was very nice to be part of this event! Looking forward next year

Palestra – Uninorte – Introdução desenv. mov. Nokia usando Linux

2010-04-19T18:33:39+00:00

Ontem estive na Uninorte falando sobre o desenvolvimento para dispositivos móveis da Nokia usando Linux. Este foi o maior público para o qual já palestrei. Acredito que mais de 200 600 300 pessoas estavam no evento. Muito bom este tipo de evento interno com o objetivo de promover a integração entre os alunos de redes da Uninorte. Acho sensacional o fato do departamento de computação estimular a utilização de SW livre por meio de palestras e eventos.

APRESENTAÇÃO DISPONÍVEL AQUI!

Na próxima semana teremos outro evento na Uninorte, o FLISOL!

O FLISOL é aberto para o público em geral e as inscrições já estão abertas!

Você que quer conhece mais sobre SW livre? Resposta: SIIIIIIIMMMM !!!

Quer instalar Linux no seu laptop, mas não se sente muito confortável? Resposta: SIIIIIIIMMMM !!!

Este evento é para você! FLISOL!

[]’s

PS: Obrigado a Afonso Costa e Tâmia Costa pelas fotos!

New kid on the block: Plasma Water Animation

2010-04-19T13:04:44+00:00

Hello!
I'm glad to make available a fresh new Plasma animation: WaterAnimation. This animations uses the ripple effect to produce a liquefied behavior on the target widget. An example of the animation behavior can be seen below, enjoy! :-)

Click To Play

If you're curious about how this works, the ripple effect uses a pair of matrices with the same size as the widget, providing the previous and current wave heigths. These wave heights are used to calculate the water reflection. If the widget gets resized, these matrices are resized as well, so the animations keeps on going in every situation :-)

STE U8500

2010-04-15T02:40:55+00:00

One of the latest board we’ve been playing with is the new STE U8500.

The U8500 is a smartphone platform created by ST-Ericsson, offering a dual ARMv7-A Cortex A9 core, with strong hardware decoding power and ARM Mali 400 GPU.

More about it’s features:
* Full HD 1080p camcorder, multiple codecs supported via OMX (H264 HP, VC-1, MPEG-4)
* High-resolution, touchscreen display support up to XGA
* Simultaneous dual display support
* High performance 3D graphics, support for OpenVG 1.1 and OpenGL ES 2.0
* Dual camera support with Integrated ISP 18 Mpixel and 5 Mpixel
* Wi-Fi, Bluetooth and GPS enabled platform
* Built-in USB 2.0, HDMI out

And technology:
* Highly efficient, low-power ARM dual Cortex™- A9 processor
* Dual multimedia DSP for low-power, flexible media processing
* High-bandwidth LP-DDR2 interface
* ARM Mali™ 400 GPU and NEON®CPU extensions

U8500 with Ubuntu Lucid

Now, about the things that interest me the most, the current status in Linux in general:

Kernel:
The kernel we’ve been working on is a vendor’s based one, using 2.6.29 as base. With this kernel we have many features implemented, like blitter support, framebuffer, hdmi output and many more.

At upstream side, the code is just starting to be merged, and you can see already some basic commits going on linux-2.6, like commits 1, 2, 3, 4 and 5. STE seems to be doing a great job on getting the changes upstream, since it’s the only feasible way to make it supported in mid, long term in linux. So expect more changes at 2.6.34 and 2.6.35.

U-Boot:
Similar with the kernel, we’re also using a custom vendor’s version. They’re just starting to make the support upstream, and you can find the patch series here.

Once we get the basic U-Boot and Linux support upstream, we can start working directly with mainline, fixing and improving it when needed.

Connectors - HDMI, uSD, Headset and micro USB.

Our work:
Since we got the board we’ve been playing on supporting many different Linux platforms, and optimizing the basic Linux OS core to be commonly used by different distros.

We started with Maemo 5, as a proof of concept, and we got it up and running with a very good performance and hopefully soon we’ll be able to share more details.

OE Angstrom/Mamona is very easy to support, since we just need to create the machine configuration and use the same compilers already used by other ARMv7 architectures.

Personally I started testing Ubuntu Lucid release, and just got the very basic support, with a custom and simple image. Ubuntu is now a very good option since it’s targeting ARMv7 platforms, with compiler optimizations and Thumb2 support. NEON support is not included by default, but you can support it by compiling specific components by hand. For more information please check at ubuntu wikipage.

Meego also boots and runs fine at this platform, but since it’s just a basic OS ATM (armv5 only), doesn’t have anything interesting to play with.

Besides platform support, we’ve been working on creating the hardware accelerated X server video driver, to use EXA, DRI2 and Xvideo with overlay. Once we get it all running we can easily use it in any Linux distro we want, and X we’ll be accelerated by default.

Connectors - RJ45, Uart and MIPI34, for debug.

Now the important question, where’s the code?
STE still didn’t deliver the main software in public, so we can’t just release the Kernel, U-Boot and other development that requires support from these software components. But this is changing, and I believe that very soon we’ll be able to get most of the things in public, so others can download and test if needed.

In the next posts I’ll be showing more about the status of these distros on this hardware, also showing the performance and demonstrating it.

Board I’ve being playing on:

root ~# cat /proc/cpuinfo
Processor : ARMv7 Processor rev 1 (v7l)
processor : 0
BogoMIPS : 1199.30

processor : 1
BogoMIPS : 1199.30

Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU implementer : 0×41
CPU architecture: 7
CPU variant : 0×1
CPU part : 0xc09
CPU revision : 1

Hardware : ST Ericsson U8500 Platform
Revision : 0000
Serial : 0000000000000000

Links and videos about U8500:
* ST-Ericsson U8500
* ST-Ericsson U8500: PlayStation controller, PlayStation grap
* U8500 3D Video

Qt event dispatchers and loops

2010-04-14T17:58:10+00:00

Lately I’ve been working with Qt, a C++ framework for developing cross platform applications. Like many other frameworks/environments Qt enables event-driven programming. Using that methodology of programming, a typical Qt applications does something like this:

Setup the UI, start listening in socket.
Connect objects to react to: user manipulating the UI, connection happening in socket.
Calls app.exec().

That’s it. Then it’s job of app to act like a dispatcher, waiting for external world events to happen and propagating them to the application objects. Qt uses QEvent to propagate those events.

Well, this is common in other frameworks. In some of them the word mainloop or eventloop is used to describe the job that app in Qt is doing. For example: EFL has the ecore mainloop, glib has a mainloop and Node.js has this concept built in as well.

In this article I’ll focus mostly on Qt machinery to work with mainloops.

Underneath `app`

One interesting aspect of the Qt implementation is that the concept of mainloop is abstracted, so other parts of Qt don’t heavily depend on how the mainloop is implemented. This supports Qt’s goal of being crossplatform. So the real class that implements a mainloop in Qt is not the QApplication, but another platform dependent class that implements the interface defined by QAbstractEventDispatcher.

This abstract class is the minimum interface that QApplication needs to provide the event-driven programming for its users. This allows different implementations for each platform, and even multiple implementations on the same platform.

In Unix, for example, besides the default dispatcher implemented using POSIX API, you can use an event dispatcher implemented on top of glib mainloop. And this gives you something very nice: your program can make use of libraries that rely on the glib mainloop as well. This kind of integration has been done in other libraries as well, for example with ecore on top of glib.

When you instantiate QApplication, Qt will automatically create a proper event dispatcher for the platform and use it. However if you instantiate one before, QApplication will use it. But before we play with that, let’s look at event dispatchers a little bit more.

What can an event dispatcher do?

Well, if we look at QAbstractEventDispatcher, we’ll see the following groups of methods:

Timer: to register/unregister timers, so the mainloop will send a QTimerEvent to an object after certain time.
Socket notifier: in Unix-world this would be registering/unregistering file descriptors to watch. The mainloop will send a QSockAct type of event to the socket notifier object.
Control: to run one iteration of the mainloop, to enable another thread wake the mainloop if it is idle waiting for new external events.

If you’re familiar with the select() function from POSIX, you can imagine how this functionality can be implemented. Running an iteration of the mainloop would be the select() call for example. Actually, that’s the way the default unix event dispatcher works in Qt.

With such an interface, it’s easy to see that Qt could run on top of most mainloops, and for this article I wrote a simple QEventDispatcherEcore, which implements this interface on top of EFL’s ecore mainloop.

Show me the code!

The code is in my playground repository, and the important file for now is the dispatcher.cpp. You’ll see that it is all marked with ### comments, which indicates points of the code that are incomplete: this is just a simple example of the concept, be warned!

I won’t go step by step in the code, because it should be not so hard to understand. The Ecore library gives us enough functionality to implement all Qt needs. I’ll highlight two pieces that I think deserve special explanation

First, how the wakeUp() call was implemented: since ecore mainloop didn’t have a similar functionality, I used the same trick as the Unix event dispatcher. The trick is to create a pipe and watch one of the ends inside the mainloop. Then, to wake up we simply write on the other end of the pipe.

A second important point is: the processEvents() function takes a flags argument, which indicates to the event dispatcher important parameters about the iteration it is going to run: whether it should ignore UI events or whether it should block waiting for the next event if there’s no event right now.

The block until event show up is a very important functionality, since we don’t want to spend all CPU cycles calling processEvents() again and again with no side effect, no new event being delivered, and avoid busy loop.

In the code for the event dispatcher example, what’s tricky is that while Ecore does have a iterate() primitive it doesn’t have a iterate_and_wait(). The rationale is that part of the work that Qt is doing here inside QApplication code

    // Simplified version of what QApplication do
    while (!quitLoop)
        processEvents(flagToWait);

is something that usually libraries encapsulate for the user. In our case has a mainloop_begin() function to encapsulate the while-loop.

To the event dispatcher example, what I did was to simulate the functionality I wanted by making use of Ecore’s idle_exiter mechanism, which allow functions to be registered to be called after a iteration the mainloop

    // Simplified version of what Ecore do...
    while (!quitLoop) {
        // ...
        processEvents(flagToWait);
        // ...
        runIdleExiters();
    }

The trick was to register an idle_exiter that caused the mainloop to quit. After inspecting Ecore implementation, the result of doing this be exactly what I wanted to achieve with an iterate_and_wait() primitive without changing the API.

Hmmm, what’s the `guidispatcher`?

If you followed the repository link, you’ll see there’s another dispatcher there in the guidispatcher.cpp file, that’s the QEventDispatcherEcoreGUI. To understand it we need to remember the difference between a QCoreApplication and a QApplication: the former doesn’t depend on GUI code, and the latter is the subclass with GUI functionality.

This separation also happens in event dispatchers. Using the case of Unix again, in Qt the GUI for Unix is based on X11. So a QApplication needs to create a X11 connection and watch for events, translate them to QEvents and send them to the proper objects.

This job is exactly what an event dispatcher is for. So in Unix, QCoreApplication uses the Unix’ select() implementation we mentioned before, while QApplication uses a subclass of it, which also handles X11 events.

Letting the UI event handling inside the event dispatcher allows the existence of a flag to skip handling of UI events.

Back on our example. This new dispatcher is GUI-enabled, it watches for X11 events and translates them to QEvents for delivery with help of the function QApplication::x11ProcessEvent(). Note that since this is just a proof-of-concept, we are not checking for all the flags passed.

Inside the directory ‘qapplication’, there is one example using this dispatcher. It mixes a QWidget on the screen (using QApplication for the GUI) and an EFL window showing Evas in other. They are in the same process but with different X connections.

Last but not least: the `QEventLoop`

If you look the Qt documentation, you can see there’s a QEventLoop class. But, does this class do if the mainloop is already in the event dispatcher?

Simply put: QEventLoop is a helper class that provides convenient access to the dispatcher’s processEvents() call. For example, QEventLoop has an exec() method, that looks like this

    // Simplified version of QEventLoop::exec()
    while (!eventLoopQuit)
        dispatcher->processEvents();

One usage of this pattern is to make a function blocks but still running the mainloop (so things like UI still work). This enable APIs like the ones used in some QDialogs

    QMessageBox msgBox;
    msgBox.setText("The document has been modified.");
    msgBox.setInformativeText("Do you want to save your changes?");
    msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
    msgBox.setDefaultButton(QMessageBox::Save);

    // Blocks until a button is clicked in the dialog, ret will contain information
    // to identify that button.
    int ret = msgBox.exec();

To see some downsides of this kind of API in dialogs, I recommend reading the article Unpredictable exec() from Qt Labs blogs.

Lies, big fat lies and benchmarks

2010-04-07T23:14:32+00:00

There is the old saying, ‘there are lies, big fat lies and there are benchmarks’, but after my previous post about the jsanim, it was time to try to measure how good or bad the javascript based animations are when comparing it against Plasma::Animations (written in C++).

== what to measure? ==

The first task was to have a meaningful number and frames per second (FPS) sounds like a good idea. The only issue is that QGraphicsView will only update parts in the scene that need redrawing (besides it seems that there is not an easy way to access the draw events without subclassing). My solution was to set a counter for the Animation::updateCurrentTime() method that is called while the animation is running, given that the documentation says that “… neither the interval between calls nor the number of calls to this function are defined; though, it will normally be 60 updates per second.”. Maybe I should call it Function calls Per Second (FCPS).

Another important factor that can impact hugely is this kind of benchmark is both the hardware as also the graphics system used by Qt (and finally if the window manager has composite effect turned on). My test computer is a macbook (version 4.1), Intel Core 2 Duo (T8300@2.4Ghz), video Intel Mobile GM965/GL960), Qt 4.7 from master repository and I run the tests with composite disabled and got this results.

As the test application, I used the code available in playground/plasma/libs/jsanim, where a set of QGraphicsWidgets (each one drawing a pixmap) will run an animation group where 2 animations (zoom and fade) run in parallel followed next by a rotation.

== equal or not? ==

Next task is to extract any meaning from the results and I remembered what an old statistician professor that I had used to joke “Torture the data enough and it will confess”. I used to be good on this subject (back in the day I wrote some Bootstrap simulations and model fitting for biological data as also geostatistics studies using R), but it is being 5 years since I last have done any statistical analysis, I was worried about making some mistakes while using more advanced methods.

So I went with the lazier approach and decided to use a boxplot, following bellow:

The js based animations seems to have a somewhat bigger variance (see second boxplot) but overall you can’t really tell if there is a difference between them (just in case, the p-values for t-student means tests was for each animation respectively: 0.54, 0.43, 0.86).

So… what about mobile? I did the same tests in a Nokia N900 (using the opengl and raster engines) and got this data, which yielded the following boxplot:

this time without the js variance and again without any sensible difference between js and C++ animations (p-values: 0.42, 0.16, 1).

== wrapping up ==

From the data (and after asking 4 different people to inspect visually how the animations were running in js X C++ apps), I can say that following the path of using javascript to code the logic of animations in Qt seems to be a valid approach with no sensible difference in performance. Kudos to QScriptEngine (and Qt development frameworks) for making it perform really fast.

There are indeed some issues in this study, following:

CPU and memory usage: I measure it informally using ‘top’ and they seems to be on the same level, but a more formal benchmarking ideally should measure this variables;
samples: I was a bit in a hurry and run each animation only 3 times (ideally a bigger sample like 20 should be used).

Parallel package downloads for Debian-based distros

2010-04-07T15:40:32+00:00

When trying to install some packages in my Karmic box and noticing that it would take a long time, I wondered why the downloads couldn’t be made in parallel – the one-of-a-time download method used by apt-get is far from optimal. A quick search resulted in these very useful blog posts – it seems that I wasn’t the only one with that question in my mind. So, starting from the solution from the second hyperlink and putting all inside a single bash script, we have:

#!/bin/bash
# Must be run with sudo or as (gasp!) root

apt-get -y --print-uris install "$@" |
egrep -o -e "http://[^\']+" |
aria2c -c -d /var/cache/apt/archives -i - && apt-get install "$@"

You’ll need aria2 for this, download it in the classic way . In a nutshell, the script obtains the list of packages do be downloaded, pass them to aria2 for downloading and runs the proper install command in the end. Now you just have to chmod u+x and it you’re set. For example, if you wanted to use xfce4 in your Ubuntu box instead of Gnome, you could just do

$ sudo ./parallelInstall.sh xubuntu-desktop

and go grab a coffee. Other apt-get commands work: if you want to do an apt-get upgrade just change install to upgrade (or dist-upgrade) in the script. The script is not fully automated, you see – the last command may need mandatory interaction because installing things may nicely break your system without your ever noticing until the damage is done. If all the packages are from official repos and signed and whatnot, though, all will happen in a very automatic way

Although this script is tailored for Debian-flavored distros, you could just adapt the first and last commands to match your favourite distro.

Arbitrary and/or animated opacity masks to QGraphicsItems with QGraphicsEffect

2010-04-05T14:09:47+00:00

Last week I dropped by this neat image slider and was wondering how could that be done in Qt (C++ or Quick). And basically what we need is an animated opacity mask, or “clipper”.

While QGraphicsView and QML already provide rectangular clipping, it does not support clipping to arbitrary forms and opacity, something we would need in order to implement the “moving bars” transition used in the image slider I mentioned above.

I expected QGraphicsEffect to be suitable for that usecase but I had no experience with it, so I decided to try and make a proof of concept effect class that would clip an arbitrary QGraphicsItem to the shape of a bouncing circle.

A more useful class would be one that received as parameter a mask image instead of the “hard-coded” bouncing circle, but I’ll let that as an exercise to those reading

Code is attached, I complied against Qt 4.6 and it works fine. Just run:

# qmake
# make
# ./effect

l class would be one that received as parameter a mask image instead of the “hard-coded” bouncing circle, but I’ll let that as an exercise to those read.

Download and try it here.

UPDATE: If your default graphics system is not raster, ie. if you get errors like:

QPainter::setCompositionMode: Blend modes not supported on device

Try running the example as follows:
# ./effect -graphicssystem raster

QPainter::setCompositionMode: Blend modes not supported on device

jsanim: current status

2010-03-30T00:35:29+00:00

From my previous post about jsanim (javascript animations) where I explained the motivations about the idea, I’m writing to report the current status.

I got stuck while trying to create an instance of a javascript class from C++ side in QScriptEngine, but I was helped by khansen (you rock man!).

Being able to create an instance got to address an important issue in the first PoC: run more than 1 animation. Now each animation type will have a javascript class, where its instance will point to the animation target widget and hold the animation parameters. This design has some advantages:

uses a single QScriptEngine object (implemented as a singleton);
can run multiple animations;
multiple animations can access the same widget;
is more OOP oriented (the animation loop will call a method on the javascript class);

How fast (or slow…) is it to use QScriptEngine to animate a widget’s properties? What about a video?

Notes: it has 8 QGraphicsWidgets, 24 animation objects (zoom, fade, rotate), running in the Nokia N5800.

What is next is profiling and comparing it against our Plasma::Animation classes doing preferably the same type of work. But since it is still in the very early beginning, it is already looking promising.

Secure memory (a.k.a. mlock)

2010-03-30T00:33:56+00:00

Last week, while trying to slim down the software dependencies of an application, I figured it out that one library could be dismissed if we could provide a secure/safe memory block to store a key.

This is a common requisite in 2 areas (real time systems and security applications): having a way to ensure that a segment of memory will not be swapped to the disk. For real time, swapping from the disk back to the memory can ruin the purpose of having deterministic performance and for security let’s just say that is bad to save passwords/keys in a non encrypted filesystem (even worst if you run our swap in a filesystem that can’t couple with user privileges).

After googling a lot to no avail, I decided to ask Arnaldo Carvalho (a.k.a. acme) if there was a syscall for letting the O.S. know that a memory block should not be swapped. The answer: man mlock (it turned to be a POSIX 2001 function to my surprise).

The idea is quite simple:

malloc some memory;
ask the O.S. to lock it (make it un-swappable);
use it;
unlock the memory and clean it later.

The only tricky part is that thanks to COW (Copy On Write), you can have access to a segment of memory that is being shared by your process parent (so the way to ensure that the memory is actually being duplicated to your process is by writing on it). A memset could do it, but I decided to be fancier and use another POSIX call sysconf (getpagesize is marked as deprecated in the man pages) to mark as dirty only one byte at each page. You can have the code here.

The way to use it:

unsigned int size;
char *ptr;
ptr = alloc_secure_memory(size);
if (ptr) {
//do something with the memory and later clean it

free_secure_memory(ptr, size);

}

I limited the amount of memory lockable to 20K, since it is way more than you usually need for storing a key and besides linux (in my case, Ubuntu) will limit the amount of lockable memory to 64K (of course if you are the root user you can set another value with ‘ulimit -l xxxx’).

Pay attention that mlockall can lock the whole memory of your application (with the risk of bringing the whole system performance down if you are running out of memory for other processes) and you should not use it.

Delayed post: Nuremberg

2010-03-29T22:40:22+00:00

Friends

A lonng delay to post it, but here goes some photos I snapped in Nuremberg. Since I got a travel to Finland that was delayed, I was happy to have a weekend to enjoy the city.

And boy, it was really cool! Sandro reported some of the places we visited (hey, man! What about the karaoke video?). But the best of the whole cultural experience came in the Saturday: visiting the Museum of Industrial Culture (by suggestion of Will Stephenson).

Have a look on some photos:

a) When your grandpa says that people nowadays lack the guts, believe it!

b) Feeling like a kid in a candyshop (and yes, most of the motorcycles still work!). It seems that up until the 60′s, there used to be several local motorcycle companys in Nuremberg (some of the items in the collection are older than 100 years and some feature engines with more than 1000cc).

c) From my poor German, there was a sign saying something like “Kids, you can ask you mommy or daddy to snap a photo”.

d) Visiting the train exhibition gives you a good idea of how the old and the new can be present together in the city.

Some extra notes:

the stereotype of German people being unwilling to help tourists is completely false, as long you are at least capable of asking for help in the local language;
local food is delicious and way cheaper than Northern countries or say San Francisco/USA. You can eat very well by paying 10 euros a meal (included the dunkel beer!) in Nuremberg;
train system is cheap and effective (but not always on time);
The beer is awesome and the cars german!

Hello Planet KDE!

2010-03-25T13:25:54+00:00

Hi!
This is my first post on the Planet KDE, so I would like to take advantage of this to introduce myself :)
My name is Bruno Abinader (aka. abinader on Freenode), and I'm an open-source developer guy which lives in Manaus, Brazil and works for the OpenBossa labs/INdT since 2005. I've started contributing to the Plasma project since January/2010 (doing some ports of the deprecated animation API usage to the current one) and plan to keep contributing with cool stuff like new animation effects, MediaCenter plasmoids (Last.FM currently in progress!) and mentoring in some GSoC ideas (like Plasmoid data caching and core library test suite). For this little time I've been working on Plasma I would like to thank some people that helped me begin this the right way: Savago, igorto, notmart and aseigo, thanks!

ps: I must recognize I'm not an avid blogger, but I'll try to keep things in touch for now on :D

Bossa Conference

2010-03-16T00:03:49+00:00

So, once more I'm in the Amazon, but this time not for any fancy jungle trip, but instead for the great Bossa Conference! The conference has been really great, with a focus a bit different that other conferences as the focus is on socializing, getting to know people, and actually getting stuff done.

It was really nice to meet my friends from Qt again, as well as meet my fellow WebKit hacker, Ariya Hidayat, who has since moved on to Qualcomm. The conference spotted a lot of technical talks about everything from audio details, bluetooth to now we should develop UI widgets in the near future.

This year is the first year that I did any presentation, so I started out by doing two :-) Here you have the first one, enjoy.

Connecting Technology for Great Experiences - How does QML and Web fit together?

View more presentations from kchristi.

Ubuntu Mobile Development at the Bossa Conference 2010

2010-03-13T23:22:47+00:00

Rodrigo and I were invited to talk about Ubuntu Mobile at the Bossa Conference this year in Manaus.The finished presentation is here but what follows is a short rundown of what the Lucid release means for Ubuntu. Some highlights are

Rootstock/Rootstock gui – integrated with oem-config
Qemu-arm-static
ARM/Thumb2 support - the archive in lucid is built for the ARMv7 architecture with thumb2 support.
EFL 2D Launcher

Rootstock is a graphical (and command line of course) set of tools to create a fully configured tarball or VM image of an ubuntu rootfs from scratch

so that you can extract it to a root device. One nice thing about this is that various tasks can be included in the image. This is very useful when working with ARM. Other tools such as Moblin Image Creator exist to do more or less the same thing but Rootstock is leading the way in innovation at the moment IMO. If you want to really customize an image then you need to use seeds and germinate a set of packages - for this you will need to read our book ;)

The binfmt-misc module in the Ubuntu kernel makes it possible to execute binaries of foreign arches under linux. This means it is possible to have an arm eabi enabled chroot on a i386 system :) - this is as simple as running

$ sudo apt-get update
$ sudo apt-get install qemu-arm-static
$ build-arm-chroot karmic eabi-chroot

ARM/Thumb 2 is the instruction set underlying the ARM Cortex architecture which provides enhanced levels of performance, energy efficiency, and code density for a wide range of embedded applications.The whole Ubuntu archive is being ported to Thumb 2 and we still have some some build failures- if you can help with ftbfs (failed to build from source) please help out here.

This has already been covered extensively elsewhere but the new UI for ARM based Ubuntu devices will rock hard for Lucid. The tool will detect hardware and if a device does not have 3D capabilities it wall fall back to the EFL launcher It is hard to stress why this is rocks so much but a unified user experience across i386/Atom and ARM devices should ring a few bells in marketing departments everywhere, right.

Exciting times.

Progress bar in cp command

2010-03-12T19:34:08+00:00

Reading Planet Debian (http://planet.debian.org) i’ve seen an interesting post, made by Daniel Stone (http://www.fooishbar.org/blog/tech/), in which he links to Chris Lamb’s blog (http://chris-lamb.co.uk/).

In the post, he answers the following question: ‘Can you get cp to give a progress bar like wget?’. The answer is the name of the post: ‘damn right you can’.

Check it out: http://www.fooishbar.org/blog/tech/cp-progress-bar-2010-03-04-12-15.html

:wq

Chamada de trabalhos para FLISOL 2010 Amazonas

2010-03-12T13:51:56+00:00

No dia 24 de Abril de 2010, será realizado, em toda a América-latina, o Festival Latino-Americano de Instalação de Software, FLISoL.

Em Manaus, este evento já virou tradição. O evento é realizado com palestras, oficinas e mini-cursos relacionados ao mundo do Software Livre, visando a difusão de sua filosofia e incentivando o uso de alternativas livres para softwares proprietários.

Se você possui uma palestra (técnica ou filosófica), oficina ou minicurso, relacionado a Software Livre, que gostaria de ministrar no evento, envie um e-mail para brankinhu@gmail.com e danielbrunos@gmail.com no seguinte formato:

ASSUNTO: Proposta de [Palestra/Minicurso/Oficina] FLISoL 2010
MENSAGEM:
Nome do palestrante
Título da [Palestra/Minicurso/Oficina]
Resumo da [Palestra/Minicurso/Oficina]

Escolhendo entre um dos tipos: Palestra, Minicurso ou Oficina.

O prazo para envio de proposta é até o dia 4 de abril.

Aguardamos a sua proposta!

Links:
Projeto Software Livre Amazonas: http://am.softwarelivre.org
FLISOL 2010 Amazonas: http://am.softwarelivre.org/flisol

Leaving INdT...

2010-03-10T19:00:00+00:00

I've been cooking this post for a couple of weeks, but due to many reasons, I was not able to publish it; until now.

Since Feb 19th, I have left my job at INdT. I remember as if it was yesterday. Almost 5 years ago, I was moving from the Central region of Brazil to the Northeast, 2.500 km away from home, in search of new challenges in my professional career and also in my personal life. I was leaving a very good job in the technical center of one of the biggest (if not the biggest) bank in Brazil to try something new and very exciting.

The proposal was to join a selected group of highly skilled people, whose task was to ramp up an arm of Nokia here in Brazil, focused on research and development, which I had never heard about before. That was how I met the Instituto Nokia de Tecnologia, or simply, INdT. The thing that really caught my attention was the possibility to work directly with FOSS, while getting very well paid for that. What could ever be possibly better than that? ;)

By the time, besides of being a Linux user at home and having programmed using Open Source Software since the college, I had never actually contributed any single piece of code, documentation, translation or whatever, to an upstream project. Mostly because I had not yet understood the actual dynamic of developing software in the open. I was simply afraid of what was waiting for me on that corner.

I think those were new seas for INdT as well. Some of the guys that joined by that time, already had prior experience on the area, but a big part of us didn't. For this, and many other reasons, every day at the office was a different, joyful and exciting learning experience about the FOSS universe. That is something I am very thankful for.

As it happens very often with any company, it is necessary to make important decisions and focus on given areas. Unfortunately, and important to say, in my very own point of view, I realized that my piece of contribution to INdT had already been given. I really hope that it was useful somehow.

Time has come to find new opportunities, motivations and challenges in both professional and personal life. I'd like to thank very much and wish all the best to everyone I had the opportunity to work with during all this time. See you around!

bossa conference 2010 – my personal scheduler

2010-03-05T22:31:17+00:00

Next week we’re gonne have Bossa Conference. It’ll be a great opportunity to exchange knowledgement.

My personal scheduler

Sunday

14:00 – Welcome reception and I’ll be there.

Monday

10:00 – Johan Hedberg “Bluetooth Audio in Linux – Desktop vs Embedded”

11:00 – Olivier Crête & Marco Barisione – “Building Collaborative Desktop and Mobile applications”

14:00 – Sjoerd Simons – “From RTP to Empathy”

15:00 – Tobias Mueller – “Security in Mobile Devices”

16:30 – Espen Riskedal – “Shipping mobile applications using Qt for Symbian”

Tuesday

10:00 – Lennart Poettering – “Audio Infrastructure in Mobile Devices”

11:00 – Rodrigo Belém – “Ubuntu Mobile Development”

14:00 – Fuad Abinader – “Simplified transition to mobile IPv6 networks with open-source tools”

15:00 – Alexis Menard – “KDE Plasma for mobile phone”

16:30 – Alexandra Leisse – “Managing the Unmanageable”

Wednesday

09:00 - Horácio Oliveira – “Applications and Development in Wireless Sensor Networks”

10:00 – Matti Airas – “Python in Maemo 6″

11:00 – Petri Launiainen – “Through the Hockey Stick – An Insider’s View on the Mobile Revolution”

See you there!

N810/N800 + Linux 2.6.33 + Ubuntu Karmic (ubuntu-minimal)

2010-03-02T18:45:22+00:00

This week I got Ubuntu Karmic(ubuntu-minimal) working on N810/N800 with Linux kernel version 2.6.33. Serial, USB(g_ether) and flash memory are working fine with this version. It’s enough to use console over SSH and test some terminal applications. But it’s going to take time to get it working fully on n8×0 like linux-omap 2.6.29.

—————–

$ ssh ubuntu@10.0.1.10
ubuntu@10.0.1.10’s password:
Linux n810 2.6.33-rc8-07939-g4fe94ed-dirty #149 Fri Feb 26 14:58:22 AMT 2010 armv6l
…
ubuntu@n810:~$ cat /proc/cpuinfo | grep Hardware
Hardware : Nokia N810
ubuntu@n810:~$ uname -a
Linux n810 2.6.33-rc8-07939-g4fe94ed-dirty #149 Fri Feb 26 14:58:22 AMT 2010 armv6l GNU/Linux
ubuntu@n810:~$ cat /etc/issue.net
Ubuntu 9.10

—————–

You can download images:

* linux 2.6.33 to n800/n810

* ubuntu karmic minimal image (just console over SSH)

* howto to create your own images

* patches, pkgs and etc

Some notes about Linux 2.6.33 with n8×0:

* Some corrections are necessary to get USB working.

* My kernel configuration define g_ether(USB gadget ethernet) as built-in(CONFIG_USB_ETH=y).

* initfs is not necessary. My kernel configuration changed to bootup directly by flash memory(CONFIG_CMDLINE=”root=1f04 rootfstype=jffs2 console=ttyS2,115200n8″).

* My personal linux-omap tree is available at gitorious

Some notes about ubuntu Karmic with n8×0:

* Generated using rootstock

* Correction to apt works correctly with JFFS2

* Workaround to startup USB interface(IP 10.0.1.10) automatically using udev

* Using openssh-client/server instead of dropbear(lightweight). Dropbear install fails

PS:
* Thanks to Stskeeps, luke-jr from #mer at irc.freenode.net !

* rbelem, post done. enjoy it! http://www.rbelem.info/

* Doubts, questions or comments? Post it here or use #ubuntu-arm at irc.freenode.net

The Mobile Concept

2010-02-28T15:54:23+00:00

Reading this post you were able to watch a video about Plasma Mobile (actually, Plasma on all kind of devices) and see some screenshots. But if you don’t know the ideas and concepts behind that, you are just going to bash it as it’s just the bootstrap of the project and a lot needs to be done.

And if for some reason you are wondering about the future of the netbook project, don’t worry Plasma Netbook and Plasma Mobile, besides being oriented for smaller form factors than a regular Desktop / Notebook, have different concepts as they’re serving for different purposes. Marco (notmart) and all the Plasma team will still keep working on the netbook shell and if you read this post you can see the netbook shell running on Intel’s Jax10 devices. This was done to give us an idea about how the netbook interface would behave on touchscreen devices and helped Marco to do a lot of bug fixing and improvements.

Back to the mobile shell, this interface presented here was created for the same Jax10 device but the architecture was designed to support different “Views” (as in MVC) for even smaller devices (N900 anyone?) , while still sharing the same concepts though. Even if the interface was not designed for the N900 for example, we were able to run it with great performance and the usability was very good. What means that we’ll just need to slightly tweak the view to make it perfect for the N900. And all of this can be done by designers as the View is 100% done in QML

So our first step was to brainstorm about launching menus (and how regular grid views seems to be so boring) and how different contexts affects the way you use your mobile. I mean, we are making desktops aware of contexts more and more and it’s silly to think that you don’t use this concept on your other devices.

We thought about having regular activities so the user would be able to have different set of plasmoids for each context that he’s working on. However it still needs to be very easy to do some stuff like:

Going to your dialer if it’s a phone;
Change between activities (later we can make the shell location aware so it’s possible to auto switch);
Launch applications easily and context aware (presenting the applications related to that context);

In order to achieve these goals we came with this idea: having a regular containment and a kind of panel that auto hides itself after some seconds. Important to say that right now this panel is 100% QML and is not like the desktop’s panel (that is a containment in another view). This makes the shell use less memory and be faster as it’s just playing with pixmaps in the end. After hiding, it shows a collapsed representation of the panel at the bottom that the user can either click on it or drag it up to show back the panel. This makes it really easy to change between one activity to another one while keeping the user interface clean enough so the user can play with his applets

First Mockup by Nuno

The panel while in it's collapsed mode

But then you ask me: “I want to launch applications ? How can I do that ?”. One solution is to add an application launcher as one of the main activities and the other one is to enable context aware application launchers. So, looking at the pictures above think that you are at the “Internet Activity” and you want to launch your applications. You can always launch the application related to one plasmoid from it so if you have an RSS Feed plasmoid you are able to launch your feeds reader using this plasmoid. But if the applications doesn’t have a related applet, in our concept you can just flip horizontally the current activity and you’ll find on it’s backside a context aware launcher that have shortcut icons for your applications and it’s size is proportional to the times that you launched the application and how much related to that activity the application is. This way it’s easy to find the most important applications for that activity.

Activity flipping to show...

...the context aware application launcher that right now is just a gradient

It’s not there right now but the idea is that at the top we will have this small bar (that will be a containment) to show the status related widgets like battery, signals strength and other stuff very plasma, like clocks! It’s not there yet, but it will be!

Regarding the transitions from one activity to another we thought about sliding the activities up and down so there is the idea that we are throwing the current activity somewhere else and bringing the new one.

Throwing away the current activity....

...bringing the new one and fading out the panel....

...and the switch is done!

\Basically this is the concept behind the Plasma Mobile shell and after this it was just a matter of thinking about nice animations that would make sense, tweaking it’s timers and polishing icons It’s clear to us that during the development we’ll find flaws in this ideas and we will need to fix them, as well as that the implementation right now is a little bit dirty due to time constraints (Tokamak doesn’t last forever unfortunately). Next steps ? Fix all the ugly code, finish implementing the launch menu, polishing and bug fixing…what means that we just bootstrapped!

Ah, if you are wondering: the Plasma Netbook project still keeps up to speed and is not sharing this backend (besides sharing a lot from libplasma). The deal is that the Netbook really needs it’s own concept and implementation while Plasma Mobile is really meant to be used on smaller devices than netbooks

Plasma Mobile before deploying

Plasma Mobile on Jax10

I would like to thanks all tokamakers for providing great ideas and also INdT’s designers that gave me great ideas along the last years that I could apply for this concept.

fisl10: video com apresentação

2010-02-27T21:06:52+00:00

Speech in Portuguese! Sorry!

Finalmente estou postando o video de minha apresentação no FISL10. Alguns meses para a TV-SL liberar e mais algumas semanas até finalmentar fazer um post com o link para o video. Acho que preciso reduzir estes tempos.

Video disponível no site da TV-SL:

ou diretamente HERE.

PS: Já estou pensando no FISL11 !

Follow up on DBus + Emacs

2010-02-26T04:09:41+00:00

In my last post I used the example of NotificationItem protocol to experiment with the D-Bus bindings in Emacs. It was nice because I learned about lexical-let, and in the end it worked!

What is even better is that, not only the author of the D-Bus bindings in Emacs, Michael Albinus, commented on the post, but also implemented functionality that I had to workaround before (thanks, Michael!). This means the code is smaller and the bindings are more complete.

In particular, the bindings now support

registering properties, and the binding will automatically implement the org.freedesktop.DBus.Properties interface (i.e. the Get, GetAll and Set methods).
unregistering objects now will release the service name if there are no more methods/properties registered for that service.

Also during that time, the folks working with the protocol, kept reviewing it and the name of protocol changed, now it’s called StatusNotifier.

The new code is available here and should work with recent development versions of Emacs.

By the way, it’s far from being a complete implementation of the protocol, but it’s a nice start and was an excellent way to learn both DBus and Emacs :-).

tokamak4: some js love

2010-02-25T17:33:08+00:00

Some years ago, I used to think that real programmers only do C or C++ and that script languages were not for real man. Of course, I was wrong and realized that when I did my pet project doing the server in C and the client in python.

Javascript seems to be all the rage lately (Palm WebOS anyone?). An amazing idea that I have being discussing for 2 days with aseigo, richmoore, notmart, igorto (all good hackers lurking in the #plasma channel) while in Tokamak4 is somewhat that might sound strange: javascript based animations.

Currently is possible to use our C++ animations in javascript plasmoids, which is good. But if we look at the code of those classes, a significant part is just boiler plate code to setup the object. So, what if we have a single JavascriptAnimation class coded in C++ and put the logic of setting/reseting the properties of animated target widgets on a javascript file?

Some clear advantages:

easier to prototype an animation
easier to make animations theme dependent
easier for users (and designers) to contribute animations

And some obvious disavantages:

execution speed might suffer
exposing some properties of widget objects that might be dangerous for js coders (no offense intended!)

So, maybe you are wondering ‘Nice, but where is the code?’. You can look at it here: svn://anonsvn.kde.org/home/kde/trunk/playground/base/plasma/libs/jsanimation

(it will probably only compile with KDE trunk but might work with KDE 4.4. SC).

It is really interesting to see that a simple zoom animation (and somewhat limited, it is just an example) becomes in javascript:

function updateCurrentTime(currentTime)
{
var delta = currentTime/duration
target.scale = delta
}

So what now? This is just a PoC, a lot of work is waiting for us to port other animations, test, profile, do some js black magic for speed ups. What is really interesting is that until last night I have never used the QScriptEngine class, but thanks to its good documentation (and hacking the whole night on it while in the hostel) I got the PoC working. It is quite funny how Qt can be an enabler for experiments like this.

Interested to join the boat? Follow plasma-devel and KDE techbase.

Tokamak4: high quality pulse

2010-02-25T17:25:11+00:00

In monday after getting bored of being a long time without programming (I told in my previous post that I was in vacation, even hitting the personal record of 2 weeks without programming!), I was talking with Nuno Pinheiro a.k.a ‘da design guy’ of KDE. When he asked me if there was a way to make the KDE 4.4. SC pulse effect with really bigger scaled factor, I was thrilled.

After considering some different approaches and thinking about the limitations, it got to be fast, got to look pixel perfect to please the UI designer and *can’t* break the so loved or hated BC (Binary Compatibility), I got this results: at left there is the new pulse optimization and at right the normal pulse (you can also download the file in ogg format).

The code has still a bug that the pulsed shadow is not centered in the new code but it is looking promising specially for high DPI screens. Another remark is that the animation was set to have a long duration to make it easier to notice the pixels in the outer limits of pulsed shadow.

Updates on tokamak4

2010-02-25T16:00:36+00:00

Hello my Friends

Long time no blog. I was in vacation and made a personal commitment to avoid using computers (yeah… if you don’t count a Wii or a PS3 or a tv as computers…) and start to clean the ever growing stack of books to read. Vacation is over and I’m back to hacking again.

At this very same moment I’m at Nuremberg (Germany) in the Suse/novell office in a room with the finest KDE plasma hackers in Tokamak4. The whole experience is being memorable, hacking until late at night, sleeping 5 hours and having the unique oportunity of talking with some really talented and nice people.

Suse’s office is great, the infrastructure provided is awesome (really neat place to work and being productive). Will Stephenson from opensuse is doing an amazing work at supporting us (Germany can be tricky if you don’t speak or read german).

Finally, when the work day is over(?), we can always enjoy ‘Ein weissbier!’ at the local Thai restaurant.

Running Qt for S60 SDK on Linux

2010-02-25T14:41:43+00:00

*** These instructions have been superseded by the GnuPoc and Qt for Symbian unofficial installers, described in this post***

Update (2009-08-04): fixed qt_s60_gnupoc.patch (thanks grego), plus a few text additions.
Update (2009-08-21): update instructions to support S60 5.0 too.

A while ago I started playing with S60 programming. After downloading rather big SDK files and following instructions from http://www.martin.st/symbian/, I was able to build simple “hello world” applications written in C++, on Linux.

Then I remembered reading about an experimental Qt port to S60. I wanted to try it, given that I also began playing with Qt a while ago. To my surprise, I could not find any actual instructions on how to do that on Linux, although I found a few requests for it in comments from Qt Labs blog posts.

So, without further delay, I describe below the steps I followed to build Qt applications for S60 devices on Linux. These instructions are provided as an extension to those on Martin’s page, so be sure to read it too. But given that some patches are needed on top of Martin’s tools, I will show the full instructions here.

Note: these instructions were tested only in the following environment:

x86 32-bits
Ubuntu 8.04
S60 3.1 (N95) and S60 5.0 (5800 Xpress Music)

I tried making it work for my 3.0 MR based device, but it seems that I need to recompile all Qt using the proprietary ARM RVCT compiler. If someday I make it work, I’ll post instructions for it too.

Preparation

Download all required files:

S60-SDK-200634-3.1-Cpp-f.1090b.zip (355MB) or S60_5th_Edition_SDK_v1_0_en.zip (623MB): S60 Platform SDK for Symbian OS, for C++
OpenC-1.5.5b-beta.zip (29MB): Open C/C++ Plug-ins for S60 3rd Edition (already present on S60 5.0 SDK, only needed for 3.1)
qt-embedded-s60-preview-4.5.2-tower.exe (127MB): Qt for S60 “Tower” pre-release
gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnu.tar.bz2 (11MB): CodeSourcery’s ARM toolchain for Symbian
gnupoc-package-1.13.tar.gz (6.2MB): scripts and patches to run S60 SDK on Linux
qt_s60_gnupoc.patch (12KB): patch for gnupoc to also support Qt S60 installation
qt-s60-extra-files.tar.gz (80KB): files from Qt S60 GIT tree that are missing for a Linux build (needed to compile Qt tools natively for Linux)

(many thanks to Francisco Keppler for hosting the last two files on his web site!)

Installation

First, set some environment variables to be used on the following steps (feel free to modify them to install the SDK on some other location). NOTE: these variables are not necessary after installation.

# root directory where all SDK files will be installed GNUPOC_ROOT=$HOME/gnupoc # toolchain directory TOOLCHAIN_DIR=$GNUPOC_ROOT/csl_gcc # S60 SDK directory (replace "3.1" with "5.0" # for S60 5.0) S60_SDK_DIR=$GNUPOC_ROOT/symbian-sdks/3.1 # Qt SDK directory QT_S60_DIR=$GNUPOC_ROOT/qt_s60 # wrapper directory (used by gnupoc) WRAPPER_DIR=$GNUPOC_ROOT/bin # where all downloaded files are located SRC_DIR=$HOME/downloads

Install ARM toolchain:

mkdir -p $TOOLCHAIN_DIR tar -C $TOOLCHAIN_DIR -xvjf \ $SRC_DIR/gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnu.tar.bz2

Unpack gnupoc sources and apply the patch that adds Qt/S60 support:

tar -xvzf $SRC_DIR/gnupoc-package-1.13.tar.gz cd gnupoc-package-1.13 patch -p1 -i $SRC_DIR/qt_s60_gnupoc.patch

Install gnupoc:

For S60 3.1:

cd sdks ./install_gnupoc_s60_31 \ $SRC_DIR/S60-SDK-200634-3.1-Cpp-f.1090b.zip \ $S60_SDK_DIR

For S60 5.0:

cd sdks ./install_gnupoc_s60_50 \ $SRC_DIR/S60_5th_Edition_SDK_v1_0_en.zip \ $S60_SDK_DIR

Install gnupoc wrappers and native tools:

./install_wrapper $WRAPPER_DIR cd ../tools ./install_eka2_tools $TOOLCHAIN_DIR # adjust EKA2TOOLS variable to point to correct location sed -i "s,EKA2TOOLS=.*,EKA2TOOLS=$TOOLCHAIN_DIR/bin," \ $WRAPPER_DIR/gnupoc-common.sh

Install OpenC (skip this step if using S60 5.0):

cd ../sdks chmod +x install_openc.sh ./install_openc.sh \ $SRC_DIR/OpenC-1.5.5b-beta.zip \ $S60_SDK_DIR

Finally, install Qt/S60 (it will take some time because some tools need to be compiled for Linux):

chmod +x install_qt_s60.sh ./install_qt_s60.sh \ $SRC_DIR/qt-embedded-s60-preview-4.5.2-tower.exe \ $S60_SDK_DIR \ $QT_S60_DIR \ $SRC_DIR/qt-s60-extra-files.tar.gz

Usage

After installation is completed, the usage is very simple. You need to setup a few environment variables, so tools like qmake, bldmake, abld, makesis etc. are found:

export PATH=$WRAPPER_DIR:$QT_S60_DIR/bin:$PATH export EPOCROOT=$S60_SDK_DIR/ # trailing "/" is required! export QMAKESPEC=$QT_S60_DIR/mkspecs/symbian-abld

Optionally, you can create a gnupoc_env.sh file with the lines above, using this command:

cat > $GNUPOC_ROOT/gnupoc_env.sh << EOF export PATH=$WRAPPER_DIR:$QT_S60_DIR/bin:\$PATH export EPOCROOT=$S60_SDK_DIR/ # trailing "/" is required! export QMAKESPEC=$QT_S60_DIR/mkspecs/symbian-abld EOF

Then, every time you need to set the variables, you could simply use:

. $GNUPOC_ROOT/gnupoc_env.sh

Note the “.” (dot) before the gnupoc_env.sh. It says that the contents of the gnupoc_env.sh file will be run in the current shell session, as if you typed them by hand.

To actually build some Qt code, use these commands:

cd path/to/source qmake # assuming the code already has a .pro file make DEL_FILE=rm ABLD=abld release-gcce makesis -c <project>_gcce_urel.pkg <project>.sis

And to clean the source:

make DEL_FILE=rm ABLD=abld distclean

Notes:

Be sure to use qmake from Qt/S60. Otherwise the generated Makefiles will be for your host system
The trailing slash on the EPOCROOT variable is important

Known issue and workaround

The .sis file generated by the instructions above, although installable on the device, does not actually work (clicking on the application icon makes the phone “hang” for a while, but then it returns to the Symbian menu). The workaround is to compile and link some files from Qt/S60 sources directly into the application. For that, just add a “qts60main.pri” file to your application’s source directory, with the following content:

QT_SOURCE_TREE = $$QMAKE_INCDIR_QT/.. DEPENDPATH += $$QT_SOURCE_TREE/src/s60main HEADERS += \ qts60mainapplication.h \ qts60mainappui.h \ qts60maindocument.h SOURCES += \ qts60mainapplication.cpp \ qts60mainappui.cpp \ qts60main.cpp \ qts60maindocument.cpp \ qts60main_mcrt0.cpp LIBS -= qtmain QMAKE_LIBS -= qtmain MMP_RULES += \ "SOURCEPATH $$QT_SOURCE_TREE/src/s60main" \ "START RESOURCE s60main.rss" \ "HEADER" \ "TARGETPATH /resource/apps" \ "END"

Edit the .pro file and add this line:

include(qts60main.pri)

Then try again the sequence of commands listed on the previous section (qmake; bldmake …). I’m not sure why this happens, and I need to check whether this is an issue specific to Linux.

TODO

Remove need to set “DEL_FILE=rm ABLD=abld” when calling make distclean/relase-*
Send patches to Martin’s gnupoc and Qt/S60
Investigate issue with s60main static library not working
Compile Qt/S60 from sources on Linux
Make it work with S60 3.0 too (although Qt/S60 does not support it officially)
Make Symbian emulator (epoc.exe) work under Linux (currently it crashes under WINE)

YATP: Yet Another Tokamak Post

2010-02-25T01:34:35+00:00

So, I just prepared a nice post about the job we have been doing during Tokamak 4 and what happened this days but I really don’t want to spoil cool stuff before we can at least give you some screenshots and videos Keep reading this blog as the next two posts will explain all of this and give some pretty and nice screenshots and videos!

First of all I would like to thank Will Stephenson, openSUSE and KDE e.V. (and of course everybody who supports the KDE e.V.) for hosting this developer sprint. It was awesome to put together people from three different teams that develop stuff that have a huge overlap area (Plasma + KWin + Oxygen). Really, thank you very much. I’m proud that you’re part of the KDE community!

Weather has been good (compared to Oslo and Finland where I was spending the last weeks) and the office is really good to work on. We have a lot of different devices to hack on (big computers with touchscreens, small devices from Intel and Nokia and the regular notebooks and netbooks) and we were able to expose a little bit more of our work to the local community (as well as see some old pictures of a sprint that happened at this same place in 2002).

From my side I was planning to bump the Pastebin applet with some new ideas and work on Plasmate and shell mobile but it seems that in the end I was able to just stick with one of these three targets. Anyway I hope that I can finish at least one more of then until the release of KDE SC 4.5.

Here is everybody that joined our developer sprint and keep watching this blog because tomorrow I’ll have some cool stuff to show everybody! Again: thanks to our hosts and to the Plasma, KWin and Oxygen teams for being so great!

Tokamak Group Photo: Plasma, KWin and Oxygen teams

“Pegadinha”: Cuidado ao encadear múltiplas chamadas de métodos

2010-02-22T16:37:38+00:00

Num dos testes antigos do PySide, havia uma inocente linha de código com QFile().metaObject().methodCount(), que na nova versão estava causando uma falha de segmentação dentro da Qt. O que estava acontecendo era que o QMetaObject retornado pelo metaObject() estava sendo apagado pelo QFile() criado, invalidando a área de memória que methodCount() tentava acessar. Agora por que diabos ele estava sendo deletado, já que eu chamava o método direto nele? A resposta está no modo como o CPython é implementado, sendo uma máquina virtual de pilha.

Usando o módulo dis nessa linha, temos o seguinte resultado:

0 LOAD_GLOBAL              0 (QFile)
3 CALL_FUNCTION            0
6 LOAD_ATTR                1 (metaObject)
9 CALL_FUNCTION            0
12 LOAD_ATTR                2 (foo)
15 CALL_FUNCTION            0
18 POP_TOP
19 LOAD_CONST               0 (None)
22 RETURN_VALUE

Dissecando instrução por instrução e seus efeitos na pilha, vamos assumir que esteja inicialmente vazia. Apenas as 4 primeiras instrução são necessárias:

LOAD_GLOBAL (QFile) – Topo da pilha é a classe QFile
CALL_FUNCTION – Remove QFile do topo e coloca o resultado da chamada, no caso, a nova instância de QFile, com refcount 1
LOAD_ATTR(metaObject) – Remove a instância de QFile do topo (decrementa o refcount) e coloca o resultado de getattr(instância, ‘metaObject’) no topo. Nesse caso, o resultado é um “bound method” A chamada a getattr incrementa a referência da instância de QFile, logo ela não morre.
CALL_FUNCTION – Remove o metodo metaObject do topo e coloca o resultado, no caso a instância de QMetaObject retornada. Ao remover o método, a referência à instância de QFile é removida, chegando a 0. Então o destrutor do binding chama o destrutor de C++, que por sua vez deleta o objeto C++ do QMetaObject, invalidando o ponteiro usado pelo binding.

Ou seja, devido essas instruções, não se pode garantir que um objeto criado anonimamente numa chamada de metodo e usado imediatamente irá estar “vivo” em chamadas subsequentes.

Vale notar que esse problema aparece em outras implementações de Python baseadas no CPython, como o Stackless e o Unladen Swallow. Implementações que usam outros tipos de máquina virtual como o Jython, IronPython e Pypy não sofrem desse problema.

PySide for Maemo 5 rebuilt for Qt 4.6.2 final release

2010-02-19T13:53:13+00:00

Qt 4.6.2 for Maemo 5 was released this week. Due to some changes prior to the final Qt release, PySide users might have seen this error when trying to use QtQui:

Traceback (most recent call last): File "<string>", line 1, in <module> ImportError: /usr/lib/pymodules/python2.5/PySide/QtGui.so: undefined symbol: _ZNK24QAbstractKineticScroller10metaObjectEv

To fix this, we rebuilt the PySide 0.2.3 packages against the Qt 4.6.2 release, and now it should be working again. So make sure you are using the latest PySide packages on Maemo 5 (0.2.3-1maemo3) and enjoy!

Installing Qt for Symbian SDK 4.6.2 on Linux

2010-02-18T13:30:40+00:00

Qt 4.6.2 was released last Monday, so I took some time to update the GnuPoc and Qt installer scripts I previously released for 4.6.1.

Besides the upgrade to Qt 4.6.2, there are other minor changes:

Both installers now check MD5 signatures of the necessary files, to make sure they are not corrupted.
The GnuPoc installer now supports the 3.1 SDK (see updated instructions below).
Added “unset QMAKESPEC” command to setup instructions (at least Gentoo sets it globally, which affects qmake).

The instructions are basically the same as the previous ones, but I will post the full instructions here for completeness.

Preparation

Download all required files to a single directory (e.g. “~/downloads”):

S60_5th_Edition_SDK_v1_0_en.zip (623MB) or S60-SDK-200634-3.1-Cpp-f.1090b.zip (355MB): S60 SDK for Symbian OS (be sure to click on the “Download all-in-one S60 SDKs” button for 5th edition, or “Download S60 SDKs for C++” for 3rd edition, FP1)
s60_open_c_cpp_plug_in_v1_6_en.zip (35MB): Open C/C++ Plug-in
qt-symbian-opensource-4.6.2.exe (201MB): Qt for Open Source C++ development on Symbian
gnu-csl-arm-2005Q1C-arm-none-symbianelf-i686-pc-linux-gnu.tar.bz2 (11MB): CodeSourcery’s ARM toolchain for Symbian
gnupoc-package-1.15.tar.gz (6.2MB): tools and patches to run Symbian SDK on Linux
gnupoc_1.15_installer_v2.sh: Unofficial GnuPoc installer (supports 3.1 and 5.0 SDKs)
qt_for_symbian_4.6.2_linux_installer_v3.sh: Unofficial Qt for Symbian installer for Linux

For building the native tools from gnupoc, you will need:

the GCC C/C++ compilers
development files for zlib
development files for openssl

On Ubuntu, you can install these using the following command:

sudo apt-get install build-essential zlib1g-dev libssl-dev

Installation

First, install GnuPoc + S60 SDK + the Open C/C++ plugin:

./gnupoc_1.15_installer_v2.sh \ <download-dir> \ <gnupoc-dir>\ <x.y>

Replace <download-dir> with the location of all files downloaded in previous section (e.g. “~/downloads”), <gnupoc-dir> with the destination directory for GnuPoc and the SDK files (e.g. “~/gnupoc”) and <x.y> with the SDK version you want to install (e.g. “3.1″ or “5.0″). Note that both directories must have absolute paths.

If installation was successful, you should see an output like:

Installation has finished. Before using the GnuPoc SDK, run these commands on the console: export PATH=<gnupoc-dir>/bin:$PATH export EPOCROOT=<gnupoc-dir>/symbian-sdks/5.0/ # trailing "/" is required! (These commands must be run again every time a new console is opened.)

Run the commands as instructed on the message. Next, install Qt for Symbian:

./qt_for_symbian_4.6.2_linux_installer_v3.sh \ <download-dir> \ <qt-s60-dir>

Replace <download-dir> with the location of all files downloaded in previous section (e.g. “~/downloads”), and <qt-s60-dir> with the destination directory for the Qt files (e.g. “~/gnupoc/qt-4.6.2″). Note that both directories must have absolute paths.

If installation was successful, you should see an output like:
Installation has finished. Before using the Qt for Symbian SDK, run this command on the console: export PATH=<qt-s60-dir>/bin:$PATH unset QMAKESPEC # make sure there is no QMAKESPEC variable set (This command must be run again every time a new console is opened.)

Before using Qt for Symbian, you should run the command as instructed on the message above.

Usage example

To test the installation, I will describe how to build the “colliding mice” example.

cd into the example source:

cd <qt-s60-dir>/examples/graphicsview/collidingmice/

Now build the example and generate the SIS file

qmake make debug-gcce make sis

A few notes:

Make sure Qt is installed on the device before installing Qt applications. The easiest way to install it is to copy the “qt_installer.sis” package found under <qt-s60-dir> over bluetooth and open the received message to begin the installation.
Only the “debug-gcce” (if you are using the GCCE toolchain AKA “CodeSourcery toolchain”) or “debug-armv5″ (if you are using RVCT) will work, because the current Qt releases only ship debug versions of the libraries

Planet INdT

QTestLib / Plasma Animations presentations @ FISL11

Tubarão

Applying transformations to your bugs

Cairo State Tracker what we already have done

Cairo state tracker: filling rules(the power of stencil buffer)

KDE calls ‘home’

Mr. Watson, come here. I want to see you.

Plasma Animations Overview Slides Available

Sliderlayout

Open Source Community Support Developer at INdT

QtWebKit goes Mobile

Resize to contents

Using a view as the window to the contents

Adjusting how contents is laid out

The 'viewport' meta tag

Enabling the tiling

Avoiding scrollable sub elements

QtWebKit goes Mobile

Announcing QFacebook: Qt port of Facebook Graph API

Finally some news….and more Akademy!

Unofficial Qt 4.6.3 for Symbian Linux Installer + Qt Mobility + Smart Installer

Preparation

Installation

libgcal 0.9.5 plus a video

Accelerating 2D with Gallium3D

libgcal 0.9.4 released

MADDE + Qt 4.7

I am going to Debconf 10

New Qt WebKit nearing release

6 months of plasma in 10 minutes

Partindo para novos desafios – Obrigado INdT

Create Meego rootfs using Ubuntu Lucid

PySide v0.3.1 (’Knightsbridge’) is now available!

Symbian development using Linux on real life…

First tip:

Analyzing the process:

Installing TRK:

On device testing

Concluding

Mapping mouse position to angles (QtQuick example)

The use case

The problem

The solution

The Source

Exchanging experiences – Bluetooth Linux Kernel

Palestra no FLISOL 2010

Maemo @ GSoC 2010: Accepted Projects

Fun with OpenGL and Shaders

Linux Collaboration Summit - MeeGo Workgroup

Palestra – Uninorte – Introdução desenv. mov. Nokia usando Linux

New kid on the block: Plasma Water Animation

STE U8500

Qt event dispatchers and loops

Underneath app

What can an event dispatcher do?

Show me the code!

Hmmm, what’s the guidispatcher?

Last but not least: the QEventLoop

Further reading

Lies, big fat lies and benchmarks

Parallel package downloads for Debian-based distros

Arbitrary and/or animated opacity masks to QGraphicsItems with QGraphicsEffect

jsanim: current status

Secure memory (a.k.a. mlock)

Delayed post: Nuremberg

Hello Planet KDE!

Bossa Conference

Ubuntu Mobile Development at the Bossa Conference 2010

Progress bar in cp command

Chamada de trabalhos para FLISOL 2010 Amazonas

Leaving INdT...

bossa conference 2010 – my personal scheduler

N810/N800 + Linux 2.6.33 + Ubuntu Karmic (ubuntu-minimal)

The Mobile Concept

fisl10: video com apresentação

Follow up on DBus + Emacs

tokamak4: some js love

Tokamak4: high quality pulse

Updates on tokamak4

Underneath `app`

Hmmm, what’s the `guidispatcher`?

Last but not least: the `QEventLoop`