Planet INdT

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

Installing Qt for Symbian SDK 4.6.1 on Linux

2010-02-18T04:03:54+00:00

***For Qt 4.6.2 and S60 3.1 SDK support, be sure to read the updated post***

Update (2010-01-27): New version of Qt installer (v2).

Qt 4.6.1 was released last Tuesday, so I took some time to update my Linux support patches for Qt (which are now merged in qt-s60 tree and hopefully will be in main Qt tree at some point) and GnuPoc (which, thanks to Martin, are now integrated into the latest release).

I had a couple of previous posts detailing instructions on how to install the SDK on Linux, but after some time, it became too boring to run those commands manually, and some people asked for a script. So, from now on, I will provide two installers to make the process much more automated and simple: one installer for GnuPoc + Open C/C++ plugin, and another for the Qt for Symbian SDK.

Note that currently the GnuPoc installer handles only the S60 5.0 SDK. If someone is interested on a 3.1 SDK installer let me know so I can add support for it too.

Preparation

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

S60_5th_Edition_SDK_v1_0_en.zip (623MB): S60 5th Edition SDK for Symbian OS (be sure to click on the “Download all-in-one SDKs” button on that page)
s60_open_c_cpp_plug_in_v1_6_en.zip (35MB): Open C/C++ Plug-in
qt-symbian-opensource-4.6.1.exe (209MB): 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_S60_5.0_installer_v1.sh: Unofficial GnuPoc installer (currently supports only 5.0 SDK)
qt_for_symbian_4.6.1_linux_installer_v2.sh: Unofficial Qt 4.6.1 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 5.0 SDK + the Open C/C++ plugin:

./gnupoc_1.15_S60_5.0_installer_v1.sh \ <download-dir> \ <gnupoc-dir>

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

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

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

./qt_for_symbian_4.6.1_linux_installer_v2.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.1″). 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 (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/

Open collidingmice.pro and replace these two lines:

TARGET.UID3 = 0xA000A643 include($$QT_SOURCE_TREE/examples/symbianpkgrules.pri)
with:
TARGET.UID3 = 0xE000A643
In other words: replace the UID3 “0xA000A643″ with “0xE000A643″ and remove (or comment out) the “include(…)” line. This will allow to sign the built SIS file using a self-signed certificate, otherwise you would need a R&D certificate.

Now build the example and generate the SIS file

qmake make debug-gcce make sis

A few notes:

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 4.6.1 release only ships debug versions of the libraries
Make sure you do similar changes as described above if you want to try compiling other Qt examples. Otherwise, you will receive errors like “Unable to install” while trying to install the SIS file on the phone.

OpenVG whatz up?

2010-02-07T17:05:39+00:00

KDE has been used SVG images for Themes for a long time. So i begun to have an interest in how i could optimize it and look in OpenVG. The OpenVG definition by Khronos is: Cross-platform API that provides a low-level hardware acceleration interface for vector graphics libraries such as Flash and SVG. OpenVG has many low [...]

Preparing Mamona 0.3 - sync with OpenEmbedded (alpha)

2010-02-05T22:46:27+00:00

Hi folks,

After a long time working on internal projects, we got time to work on Mamona development. The main goal is get it working on OpenEmbedded.git tree and use OE directly.

Main contributions in our patches:

* Linux-omap kernel 2.6.29 working fine N800 and N810

* N8×0 Wlan working with opensource driver(stlc45xx)

* N810 sound working with opensource driver (OMAP ASoC) and ALSA changes

* N810 with Fn key working correctly

* Xserver-kdriver-xomap - xserver-kdrive with custom changes to n8×0

* Linux-omap kernel 2.6.30 to Nokia 770 (unstable)

* Mplayer-Maemo - Mplayer with custom changes to n8×0

* Eve - Web browser based on Webkit-EFL

* Basic SDK chroot (use mamona-chroot)

* Ofono - Open Source telephony

* Antico - lightweight window manager based on Qt X11

* Others minor changes.

Current development: http://gitorious.org/mamona

I created flashable images that are available on HERE.

Platform developers can use this quick howto to build Mamona latest version.

Now it’s time to review changes and submit to Openembedded.

You can see more pictures and videos of Mamona with N810 using the links

* More pictures of Mamona 0.3 (alpha)

* Videos:

…not so long after all

2010-02-04T02:40:06+00:00

After all the stuff that happened in my professional and personal life last month we can extract some technical bits

First of all, during Camp KDE it was awesome to talk to people like Jos, Celeste, Alexandra, Till, Leo and Jeff (and many others). It’s good to share your thoughts with many people that you just don’t have this big bandwith for chat that you have when you’re physically together

Our awesome dragons

I spent last month studying and working with QML, trying to get the most of it and I think that I (and the team that I work with of course) reached a very good level of knowledge regarding the new Qt’s declarative language. We have some expertise with declarative languages for some time now (started with Edje three years ago) and went through QEdje and now we have a proper Qt solution for this that will probably be released with Qt 4.7.

QML is awesome. Big tip: just try to avoid “leaking” code from your c++ controllers and models and you’ll get any interface that your designers want for free . We achieved very good results working with this architecture for software and I really recommend it for everybody (I’m not talking about this right now as it can be a whole paper – hmm, maybe a paper for next Akademy ? ).

Alexis showing QML mobile shell on N900

Ok, so after studying QML and talking a lot with Alexis and others (like Helio) we had great ideas to try out on mobile devices (read N900 here). Let’s see what we can do during tokamak 4. Good to read Aaron’s post about it and to know that he’s excited with this possibility too. I talked about this during my talk at Latinoware conference and right now we can expand and make “my dreams” come true. We have really good use cases for this and we should really focus on this at first. We need help from designers (Nuno and oxygen team?) and usability experts (Celeste, here I am again – I know you should hate me every time I say your name under this circumstances hehe ). The design of this kind of product should be the first step after studying technologies.

Talking about KDE: for KDE 4.5 I’m really going to change the pastebin applet. Feature-wise it’s really in good shape but it’s not very healthy code-wise and we can really improve it and it’s data engines to something more user friendly and also that can be easily improved with the use of plugins (anybody thinking about service providers and GHNS ?). First of all, it’s not user friendly to call it “pastebin”. My mom have no clue what pastebin is. For sure she knows what “Share it” means and we can make use of KIPI plugins to allow it to export things to Flickr and other services too. So, for 4.5 expect some big improvements on the developer side of pastebin. From a user’s perspective it should just have a better config dialog, interface and will have support for much more services (at least I hope so).

Just upgraded to trunk (KDE SC 4.5) and it already looks awesome: from the KDE theme to the new notification messages that Marco is working on. Amarok (as always) had (good) surprises for me and this “Photo” widget is awesome. It ties together the awesome experience of one of your senses (audition) to another sense (vision) and it’s awesome. Great pictures from my favorite artists and songs. Amarok++.

Amarok and new Photo Widget

Right now, I want to work on so many cool stuff and I just don’t have the time. Probably work is going to consume most of my time for the next 2 months but I’ll make it work and will help KDE to get even better and to start working on Maemo for example. Konquer the world!

Ah, as a simple tip: if you own an N900 just install the “Angry birds” game, it’s awesome hehe

A long time ago…

2010-02-04T02:13:11+00:00

Well, it has been a long time since my last post and a lot of stuff happened during that, specially regarding work and that explains a little bit why I was so “offline” last days (month).

It all started when I received my N900 from Maemo’s developer program that is just awesome as it gives the opportunity for developer to have access to the platform and keep developing for it. Comparing to other options: for some fruit company’s platform you have to pay to develop for a closed platform and for other you receive devices to develop to an open platform. Big kudos to Nokia for everything it’s doing with Maemo.

Regarding Maemo, I used my N900 in the last month on all business trips that I did and the vision of having contacts instead of accounts really made a difference. It was so easy to use Skype or my SIP provider (Inphonex) while I was out of the country that my mobile phone just worked as it should always work: as a personal extension of my home phone. Perfect.

So, the trips began with Camp KDE and I went to Los Angeles one week before the conference itself as I had some days to take as vacations. It was really great, from watching a live record of one of my favourite TV shows (Two and a Half men) to watching all the amazing talks during Camp KDE it was all great. I would like to also send some kudos to Camp KDE organizers. I know how hard it is to actually make an event like that happen.

The gate where the show was recorded

After Camp KDE I just had three days at home and then went to Oslo/Tampere for Qt work and it was really great to actually see snow for the second time. First time I’ve ever seen it snowing actually (the first time I needed to go up to a mountain last Tokamak hehe – thanks Marius for the chance!! it was awesome).

During this trips I had some ideas regarding mobile platforms and discussed a little bit of it during my talk at Camp KDE and also with Alexis Menard (former Troll). I think that for Tokamak 4 we’re going to have some nice ideas to work on for mobile platforms. It’s important to say that this is all at “pre-pre-pre-pre beginning stage” and that we have a lot of work to be done on the Netbook effort for example that Marco is taking care in an awesome way

Back to reality I have some work to be done and we are already setting things up for Bossa Conference. So I have Carnival, Tokamak 4 and Bossa Conference in a row. And still job to be done…well, I think I can handle that

Bossa Conference

So, this is all that happened last month (trust me, a lot happened) and next post will be a little more technical or at least more KDE related and for sure I’ll have some more Maemo related posts in the (very) near future (specially after Tokamak 4).

Python tutorial: Accessing APIs without Python bindings

2010-02-02T13:44:21+00:00

The PyMaemo team has prepared a short tutorial with an actual example on how to access APIs for which there are no Python bindings yet. libosso-abook was used as an example, but in practice, you can access any C libraries using the same approach. This technique can be used while we do not finish implementing the full Maemo API.

Enjoy.

Liquid Update

2010-02-01T00:40:53+00:00

Even after the long session at UDS it took us some more time and lots more caffeine to get Liquid finally down on the wiki. We thought we were the crazy mobile heads until Adenilson showed up at one meeting raving about plasma mobile!.

After this the major tasks came down to packaging plasma mobile and modifying kwin and kdm for a mobile device.These are the most important things we need to do before Feature Freeze in mid February. We also of course need to do the meta package, default-settings and work on the theme but we can do this right up to the Lucid release of Liquid

I have been travelling and otherwise occupied since UDS so have not had as much time as I would like to hack on this.

Luckily Rodrigo wanted to 'tocar a bola' for a while and he has been working with the rest of the Ubuntu Mobile team on some fancy liquid moves. This included setting up an icecc compile farm which meant that today we managed to finally get plasma-mobile compiled, packaged and put up on REVU for some feedback. The obligatory screenshot on Ubuntu Lucid is here

Any designers looking at this screenshot will I imagine have lots of ideas about how this 'user experience' could be improved. The nice thing about plasma is that according to Caio the whole interface can be changed very easily using just a qml template. If you feel excited by this then join the Liquid Hackers team on Launchpad or if you feel really inspired come to the Bossa in the Jungle in March where more mobile madness is sure to go down.

Animating the Web(Kit)

2010-01-28T09:16:00+00:00

After the landing of QGraphicsWebView implementation (in summary, a mimic of QWebView widget but for the QGraphicsView world) in WebKit trunk, your creativity is your guide :-)

A week ago, I tried to quickly exercise what it is up to, and inspired in Kent's flipin widget idea, I got some cool rotation effects on the Web content. See the (amateur) show off below:

Nice stuff thanks to Qt and its QGraphicsView and QStateMachine flexibility.

--
--Antonio Gomes

Using an TV as secondary screen via HDMI – 1

2010-01-26T03:15:18+00:00

If you have a fancy HD television and a box with a HDMI port, it’s (kinda) easy to setup your TV as a secondary monitor at full resolution, with audio support. Needless to say, it’s great for watch all those HD movies in a big TV instead of staring at your monitor or a small netbook screen

First, the video. Run xrandr and see which devices you have available. My Acer AS1410-8414 running Arch Linux gives this output:

Screen 0: minimum 320 x 200, current 3286 x 1080, maximum 8192 x 8192 VGA1 disconnected (normal left inverted right x axis y axis) LVDS1 connected 1366x768+0+0 (normal left inverted right x axis y axis) 256mm x 144mm 1366x768 60.0*+ 1024x768 85.0 75.0 70.1 60.0 832x624 74.6 800x600 85.1 72.2 75.0 60.3 56.2 640x480 85.0 72.8 75.0 59.9 720x400 85.0 640x400 85.1 640x350 85.1 HDMI1 connected 1920x1080+1366+0 (normal left inverted right x axis y axis) 698mm x 392mm 1920x1080 50.0*+ 60.0 1280x720 60.0 50.0 720x576 50.0 DP1 disconnected (normal left inverted right x axis y axis) HDMI2 disconnected (normal left inverted right x axis y axis) DP2 disconnected (normal left inverted right x axis y axis) DP3 disconnected (normal left inverted right x axis y axis) TV1 disconnected (normal left inverted right x axis y axis)

The GPU is a Intel GMA 4500MHD, by the way. LVDS1 is the default LCD screen and HDMI1 the port I’m using. So, to maintain your current screen and create a new one in the TV, run:

xrandr --output HDMI1 --auto --output LVDS1 --auto --left-of HDMI1

This will output a screen on the TV with automatic resoution (1920×1080, in my case), and also keep the current one in the laptop screen at the left side of the TV. Different GPUs have different ways of doing the same thing – in a laptop with a Quadro NVS 140M I was able to use nvidia-settings to configure a second monitor, even having the option of a unified desktop using TwinView (the same effect attained here) or two separate X screens. I suspect ATI-based GPUs have a fancy GUI program as well.

In a next post I’ll explain how to easily redirect the audio to the HDMI port using PulseAudio, if your system insists on outputting sound through your computer speakers. In this case, you could just use a cable with a 3.5mm plug in each end, but why waste plastic and metal when your powerful HDMI cable can transport sound too?

P.S.: I tried to watch a sample from the Apple QuickTime HD Gallery , but my netbook’s Core2 Solo 1.4GHz just doesn’t have what it takes to watch 1080p in all its glory. Meh

15 dias de Google Chrome: de volta ao Firefox

2010-01-22T12:12:32+00:00

Seguindo o hype e o movimento de mudança de vários amigos e da internerds, resolvi experimentar o Chrome como meu browser principal. Migrei as abas abertas, fechei o firefox e deixei apenas o novo navegador do google no meu desktop (na verdade utilizei o Chromium, versão opensource do Google Chrome, como disponibilizado para o Fedora Linux 12).

No início fiquei muito impressionado com a velocidade do Chrome e me senti de certo modo aliviado em deixar o Firefox. Repeti algumas vezes pra quem estava próximo: “o Firefox está com os dias contados, não tem a mínima chance”.

Mas depois de 15 dias, estou voltando pro Firefox 3.5. Os ganhos em velocidade do Chrome não foram suficientes pra compensar as inconveniências e a (falta das) boas extensões do concorrente. O navegador do Google ainda tem que amadurecer um pouco até se tornar o browser definitivo.

O que eu gostei no Chrome:

Rápido, muito rápido. Da inicialização aos sites carregados de java-script, o Chrome dá de lavada no Firefox;
A ideia de um processo por aba/extensão e o isolamento entre eles me agrada;

Existem outras características e mudanças que são boas, mas que não fizeram diferença considerável no uso do browser.

Os principais inconvenientes, em ordem de prioridade:

Não suporta master-password;
~~Pra colar uma nova URL, é preciso clicar na barra de endereços~~ (em outros browsers no Linux é só clicar com o botão do meio – colar – em uma área livre do browser); update: é só clicar com o botão do meio no botão de nova aba (thanks to Andreas)
O Chrome usa $LC_CTYPE pra definir o idioma (o correto é usar $LC_MESSAGES ou $LANG);
Force-reload não funciona como esperado;
Compatibilidade com sites: foram poucos problemas, mas notavelmente mais do que com o Firefox. Alguns exemplos de sites que apresentaram um ou outro problema: gvt.com.br, mercadolivre.com.br, voeazul.com.br;
Entre a omnibox do Chrome e a awesome bar do Firefox, eu prefiro esta última combinada com uma caixa de busca;
Extensões, sempre elas: deixei esse item por último, mas talvez seja o que mais impactou minha produtividade. Pra mim as que fizeram mais falta foram: tabmixplus, echofon/twitterfox, delicious bookmarks, multiproxy switch, dns cache e web developper. Eu tentei substituí-las pelas alternativas do Chrome, mas estas ainda são muito fracas.

O que eu aprendi com essa experiência é que, contrário do que eu achava originalmente, trocar um browser não é tão simples como parece e o Chrome ainda tem muito chão pela frente até se tornar um browser maduro. Além disso também não vejo mais o Chrome como uma ameaça tão séria ao Firefox: levará pelo menos mais um ano até ele se tornar tão usável quanto e, até lá, quem sabe o Firefox 4.0 já esteja nas ruas incorporando suas principais características positivas.

De qualquer modo, é bom ver o aparecimento de uma nova “guerra dos browsers”. Tomara que dessa vez não haja um vencedor.

Posts possivelmente relacionados:

Link Permanente | Nenhum comentário
Post tags: computação, google, linux

God bless America!

2010-01-22T04:24:00+00:00

Yesterday, people attending camp KDE decided to give a break and go to Stone Brewing Co (that deserves a post for itself!) and later we went to Fry’s electronics. While in our way to there, I noticed a Gamestop store and Ian Monroe saved my day by making a stop in the place (thank you very much man!).

Thanks to the fact that Nintendo Wii is backward compatible (i.e. it plays gamecube games), I have being trying to find some ‘old’ Gamecube titles (and searched in 4 different gamestop stores in San Francisco around a year ago): Soul Calibur II, Crazy Taxi and Eternal Darkness. The last one is *specially* difficult to find, since was one of the premiere games of Gamecube.

And guess what? I finally found it!

Installing Qt for Symbian on Linux

2010-01-21T17:28:21+00:00

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

Update (2009-09-24): Add workaround for GCCE issue.
Update (2009-10-05): Update gnupoc patch to apply against 20091005 snapshot. Remove workarounds from “Known Issues” sections that are already integrated into new patch.
Update (2009-10-07): Add instruction for installing gnupoc build dependencies.
Update (2009-10-23): New patch version (v9), that now applies cleanly to latest snapshots.
Update (2009-11-17): New patch version (v10), now applies against the 4.6.0 RC1 release.

In a previous post, I provided instructions on running Qt for Symbian (the “Tower” release) on Linux. However, for those who want to play with the bleeding edge Qt for Symbian development, you might want to try out the latest 4.6 development code from Qt GIT. I put some instructions for compiling Qt for Symbian from GIT on Linux as well, but unfortunately it requires the RVCT compiler to build.

Fortunately, today espenr announced daily snapshots, that will allow those who don’t have access to RVCT to try out the latest 4.6 development as well . So how to get this thing running on Linux? The snapshots so far consist only of the Windows installer and a .zip containing the source code.

By “merging” information from my two previous posts, I will describe below how to install the Qt for Symbian daily snapshots on Linux. Even if you have a previous installation of the Symbian SDK, you will need to follow the full instructions again (sorry), as these instructions contain a bunch of bug fixes to the Symbian SDK. Hopefully this requirement will go away at some point, when all Symbian SDK portability issues are addressed.

These instructions also work for the just released 4.6.0 RC1.

These instructions were tested only in the following environment:

Host: x86 32-bits (running Ubuntu 8.10)
Device and SDK: S60 5.0 (N97 and 5800)

Preparation

Download all required files:

S60_5th_Edition_SDK_v1_0_en.zip (623MB): S60 Platform SDK for Symbian OS, for C++
s60_open_c_cpp_plug_in_v1_6_en.zip (35MB): Open C/C++ Plugin
qt-symbian-opensource-4.6.0-snapshot-YYYYMMDD.exe or qt-symbian-opensource-4.6.0-rc1.exe: Qt for Symbian latest daily snapshot (you need only the .exe for running the SDK). Last tested version: 4.6.0 RC1
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 Symbian SDK on Linux
qt_s60_gnupoc_v10.patch: patch for gnupoc, adding support for Qt for Symbian installation and various bug fixes

(many thanks to Francisco Keppler for hosting this last file on his web site!)

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, 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 # Symbian SDK directory S60_SDK_DIR=$GNUPOC_ROOT/symbian-sdks/5.0 # 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 for Symbian support:

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

Install Symbian SDK:

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:

Create a “gnupoc_env.sh” script to be used for gnupoc environment setup, by running this command:

cat > $GNUPOC_ROOT/gnupoc_env.sh << EOF export PATH=$WRAPPER_DIR:\$PATH export EPOCROOT=$S60_SDK_DIR/ # trailing "/" is required! EOF
(Note: the “cat << EOF … EOF” snippet above will generate a “gnupoc_env.sh” file in $GNUPOC_ROOT.)

Initialize the Symbian SDK environment (you will need to do this every time you close the current shell session):

. $GNUPOC_ROOT/gnupoc_env.sh

Install OpenC:

cd ../sdks chmod +x install_openc_16_s60 ./install_openc_16_s60 \ $SRC_DIR/s60_open_c_cpp_plug_in_v1_6_en.zip \ $S60_SDK_DIR

Install Qt for Symbian (it will take some time because some tools need to be compiled for Linux):

chmod +x install_qt_s60 ./install_qt_s60 \ $SRC_DIR/qt-symbian-opensource-<version>.exe \ $S60_SDK_DIR \ $QT_S60_DIR

If installation went well, you should see the following:
... Qt is now configured for building. To start the build run:make debug-winscw|debug-armv5|release-armv5. To reconfigure, run 'make confclean' and configure.

Of course, you do not want to build Qt, so just ignore it and proceed with the next step.

Create a “qt_s60_env.sh” script to be used to setup Qt for Symbian environment, by running this command:

cat > $GNUPOC_ROOT/qt_s60_env.sh << EOF export PATH=$QT_S60_DIR/bin:\$PATH export QMAKESPEC=symbian-abld EOF
(Note: the “cat << EOF … EOF” snippet above will generate a “qt_s60_env.sh” file in $GNUPOC_ROOT.)

Initialize the Qt for Symbian environment (you will need to do this every time you close the current shell session):

. $GNUPOC_ROOT/qt_s60_env.sh

Install the following SIS files on your device:

$EPOCROOT/nokia_plugin/openc/s60opencsis/pips_s60_1_6_ss.sis
$EPOCROOT/nokia_plugin/openc/s60opencsis/openc_ssl_s60_1_6_ss.sis
$EPOCROOT/nokia_plugin/opencpp/s60opencppsis/stdcpp_s60_1_6_ss.sis
$QT_S60_DIR/qt_selfsigned.sis

Unset all temporary variables we used earlier:

unset GNUPOC_ROOT TOOLCHAIN_DIR S60_SDK_DIR \ QT_S60_DIR WRAPPER_DIR SRC_DIR

Usage

You need to setup the environment, so tools like qmake, bldmake, abld, makesis etc. are found (not necessary if you just did the installation, unless you closed the shell session):

. /path/to/gnupoc_env.sh . /path/to/qt_s60_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 debug-gcce # or make debug-armv5 (if using RVCT) make sis # to generate .sis file

And to clean the source:

make distclean

Notes:

Be sure to use qmake from Qt for Symbian. Otherwise the generated Makefiles will be for your host system
The trailing slash on the EPOCROOT variable is important (this is assumed in many places on Symbian SDK scripts)

Known Issues

The snapshots contain only the the “debug” libraries. Therefore, only the debug targets will work, i.e. use only “make debug-gcce” (if using GCCE compiler) or “make debug-armv5″ (if using RVCT)

See also the more general known issues related to Qt for Symbian.

Ideas for improvements and TODO items

Add Symbian support to Qt configure script, eliminating the need to compile configure.bin
Create a nice GUI installer for Linux
Allow to easily upgrade Qt for Symbian SDK installation, without requiring to reinstall the entire Symbian SDK
Itegration with Qt Creator, KDevelop or some other IDE

Feel free to contribute with your ideas or even better, help implementing them

Live@CampKDE

2010-01-20T23:47:03+00:00

Friends

Internet connectivity has being a bit fuzzy in the hostel (as also insulation and electric energy), so the long delayed update.

So far, its is being a really interesting event for both technical content and social aspects (assigning faces to IRC names is always refreshing).

Last Monday I had 2 presentations in a row, resulting to near 1 hour. I realized that I would bore the audience to death, so I tried to mix my slides with both technical content and some humour as also included a 5 minutes pause between the first presentation (Plasma new Animation classes) and the second (KDE-PIM google sync).

The first presentation is split in 2 parts, where the first part gives some context to the subject and the second part includes usage example, demos and some code. There were some really nice responses to the animations running in a Nokia N5800 that I made accessible to the people in the room (you can see a video of the same program running in a N97 in a previous post). I think what is really interesting is to known that some of this animations are already being used in the upcoming KDE SC 4.4. (I was really happy to see that they are running pretty smoothly even on KDE port for MS-Windows).

The second presentation featured some wireshark porn (a.k.a. screenshots of network packages traffic) and was more dense since I got to explain details of google data protocol. Overall, besides struggling with my English and at same time exposing some technical content, I think was able to deliver some not-so-stinky talks.

Below there is a picture snapped by Will Stephenson (I completely forgot about asking someone for snapping a photo of my first presentation).

ps: For the people who asked about how I was controlling the slides with my cellphone, the answer is Amora (A mobile remote assistant), one of my pet projects.

Qt Mobile Demos in extras-devel

2010-01-19T20:30:54+00:00

A small post.

In the first season, the focus was S60 devices. After the holidays, the new season is about Maemo. =)

Qt Mobile Demos are in Maemo 5 extras-devel, so now it’s easier to check them in a N900 near you. First, you need to enable the extras-devel repository/catalogue and the demos should appear if you search for “qtmobile”.

The packages are:

hyperui -> qtmobiledemo-hyperui

mybudget -> qtmobiledemo-mybudget

shoplist -> qtmobiledemo-shoplist

weather -> qtmobiledemo-weather

Future? Well, soon QAbstractKineticScroller will replace our kinetic list implementation. (Read the comments).

And yes, we have a list of known issues to solve in our free time…

The code still in the same place, http://qt.gitorious.org/qt-labs/mobile-demos

That’s all for today.

PS: Thanks to Etrunko, who helped a lot with packaging stuff =)

Going to Camp KDE: touchdown in Atlanta!

2010-01-15T12:50:57+00:00

I’m on my way to San Diego in 30 to 60 minutes, after flying from Manaus/Amazonas in Brazil.

I will use this post to collect ideas and suggestions about what you people and fellow hackers like to see in my presentation titled Plasma new animation classes. I was planning to show the new animations currently available in KDE, some examples of porting from Plasma::Animator and some embedded stuff.

So, what else would you like to known about it?

BOSSA’10 – Presentation submission deadline extended

2010-01-05T18:38:43+00:00

Bossa Conference 2010

After some people’s requests, it’s nice to hear that the BOSSA committee decided to extend the call for presentation to January 17, 2010.

This is the first year that the conference is doing a call for presentation, so if you are working with free and open source technologies related to mobile embedded platforms, please submit an abstract of your presentation at http://www.bossaconference.indt.org/.

The conference will be held in Manaus, Amazonas – Brazil, a different city from the other years. As always, it’ll be an awesome conference, having lots of interesting talks and people, and also the opportunity to hack and discuss new ideas

If you have something with Qt, WebKit, Android, OpenEmbedded, Linux Kernel, Maemo, etc, please, go there and try it out, I guarantee that if accepted, you won’t regret!

See you there!

Retrospectiva 2009, planos pra 2010

2010-01-01T02:55:50+00:00

É fim de ano e chegou a hora do tradicional cliché desse blog: recapitular o ano que passou e traçar alguns planos pro que está começando.

Ao longo de 2009 escrevi pouco no blog, reflexo do uso do twitter, onde mantive pequenos relatos de acontecimentos que normalmente ganhariam um post por aqui. Mas segue uma recapitulação dos principais acontecimentos e a tradicional lista dos planos de 2010:

Resumo de 2009:

Viviane teve um ano bem ativo: resolveu mudar de profissão (voltou a estudar e agora está fazendo um curso técnico de Design de Interiores) e tirou a carteira de motorista;
Passamos 30 dias de férias viajando pela Patagônia;
Eu fiz um curso de mergulho autônomo (básico);
Comprei uma câmera fotográfica nova (Canon Rebel T1i) e um novo kit de lentes (farei um review no futuro);
Minha sogra e meus pais vieram nos visitar;
Recebemos couchsurfers três vezes em casa (um polonês, um casal de franceses e um casal de alemães);
No trabalho não tivemos grandes novidades, foi um ano atípico, de muitas mudanças mas poucos resultados concretos;
Eu completei 30 anos de vida.

Dos objetivos que eu havia traçado no final de 2008, dois ficaram no quase, mas até que o aproveitamento foi bom:

Terminar os relatos da viagem à África do Sul – até abril; Na trave: terminei, mas foi em maio.
Fazer uma viagem pelo interior de Pernambuco; Na trave: fomos até Caruaru, mas não foi o suficiente pra declarar esse item OK.
~~Ir a pelo menos uma partida oficial de futebol;~~ OK: Sport Recife 1 x 2 São Paulo pelo Campeonato Brasileiro.
~~Visitar um país que eu ainda não conheça;~~ OK: Chile!
~~Levar a Viviane pra conhecer neve de verdade;~~ OK: Bastante neve e gelo na Patagônia em junho.
~~Comprar um notebook de pequeno porte (como o EeePC 900).~~ OK: comprei um Acer AspireOne, excelente companheiro de viagens.

Os objetivos pra 2010, em ordem arbitrária:

Fazer pelo menos um passeio (nem que seja de final de semana) em Maragogi – AL;
Ir de carro até Petrolina, no interior de Pernambuco (734km de Recife);
Visitar um país que ainda não conheça;
Publicar os relatos e fotos da viagem à Patagônia;
Ter um celular com bom acesso à Internet e teclado qwerty (ex.: Nokia N900);
Começar a estudar um novo idioma;
Fazer um upgrade do meu velho desktop, deixando-o pronto pra StarCraft II que vem aí.

Não, nem filho nem videogame estão na lista. Quem sabe em 2011. :-)

Um ótimo 2010 a todos!

Posts possivelmente relacionados:

Link Permanente | Nenhum comentário
Post tags: retrospectiva

Natal em São Miguel do Gostoso – RN

2009-12-31T00:25:50+00:00

No feriadão de Natal resolvemos que seria uma boa ideia ir pra alguma praia desconhecida, pra descansar. A grande questão era pra onde ir, uma vez que queríamos um lugar bonito, tranquilo e pacato. Foi então que a Viviane se lembrou de ter visto no Jornal Hoje da Rede Globo uma matéria sobre uma cidadezinha do Rio Grande do Norte chamada “São Miguel do Gostoso”. Após uma rápida googlada, nos pareceu o destino perfeito.

São Miguel do Gostoso é uma pequena vila/cidade de pescadores 110km ao norte de Natal – RN. A cidade é a última a ser acessada pela BR-101 (ou melhor, a primeira, já que a BR-101 começa lá). A cidade é bem calma, com moradores muito amistosos e ainda pouco explorada turisticamente. Tem cerca de 9000 habitantes.

Pôr do sol em São Miguel do Gostoso

As praias
As praias são muito agradáveis, mas não são paradisíacas como as de Porto de Galinhas (PE) ou Maragogi (AL). A água é morna (como em todo o nordeste brasileiro) mas é relativamente turva, não dando pra enchergar os próprios pés com a água pela cintura.

Uma vantagem pra quem tem um 4×4, um buggy ou uma moto é que praticamente todo litoral é trafegável, então é fácil visitar várias praias ou procurar um lugar isolado.

Como as praias estão de frente pro norte, tanto o pôr quanto o nascer do sol são muito bonitos. Outra característica é que o vento lateral é constante e forte, o que faz o local ser perfeito pra esportes como kite-surf e wind-surf. O número de kites na Praia de Santo Cristo – um dos balneários da cidade – estava sempre entre 15 e 25, todos os dias.

Praia em São Miguel do Gostoso

Infra estrutura
A cidade é bem pequena – praticamente uma vila – e ainda tem pouca infra estrutura turística. Pra gente isso foi visto como vantagem, mas algumas pessoas podem sentir falta dos vendedores de praia, do característico som ambiente da maioria dos destinos no nordeste (NOT!) e da agitação da vida noturna. Por exemplo, existem 3 ou 4 restaurantes à beira mar em 4kms de praias e só encontramos duas lojas de artesanato (pequenas, no centro da cidade). O programa principal das nossas noites era caminhar pela pacata avenida observando/cumprimentando os moradores em suas varandas e tomar um sorvete de R$ 1,00 em uma das lanchonetes. :-)

O único sinal de celular na área é da Claro, mas as principais pousadas oferecem serviço de Internet via wi-fi. Não dá pra esperar muito, mas deu pra usar o skype pra ligar pra nossas famílias na noite de natal.

Mas não tivemos dificuldades: há pousadas suficientes e no centro existem mais restaurantes, pizzarias, padarias, supermercados, etc. Procurando no google você encontra rapidamente vários sites com informações turísticas em geral.

Nós ficamos na Pousada Porto do Trapiá que merece a nossa recomendação. É bem verdade que não conhecemos as outras, mas a qualidade do atendimento e das acomodações nos agradou bastante.

Não podemos deixar de mencionar que passeando pela cidade avistamos duas bibliotecas públicas. Tá aí um exemplo a ser seguido por mais cidades do Brasil. :-)

Passeio de Buggy
A melhor parte da viagem foi alugar um buggy e sair dirigindo pelas praias desertas. Rodamos um total de +- 80kms, quase sempre na areia à beira-mar. Pra quem gosta de aventura, é uma excelente opção (sempre há o risco do buggy atolar, quebrar ou ficar sem gasolina em um local deserto, mas acho que vale a pena). Outra opção é contratar o passeio com motorista, mas isso seria 80% menos divertido. :-)

Buggy numa praia deserta com uma sombra à beira-mar

Passeio de Buggy em São Miguel do Gostoso

Dicas e curiosidades gerais:

Venta bastante, geralmente um vento lateral. Com isso as vezes fica um pouco complicado comer na areia bem próximo do mar (a não ser que o que você queira seja comer a areia);
Se tiver espírito de aventura, não deixe de alugar um buggy e sair por conta própria. Se tiver uma caixa ou bolsa térmica, será perfeito;
Nós alugamos o nosso buggy com o “Pedrinho da Oficina”. R$ 100,00/dia. Foi muito tranquilo, ele nem sequer anotou nossos nomes na hora de entregar/receber os documentos e a chave;
A pizza e o ambiente da Pizzaria Quintal (na entrada pra Praia do Xêpa) nos agradou bastante;
O restaurante Caranguejo e Cia tem atendimento, preços e cardápio excelentes. Não é em qualquer lugar que se come, à beira mar, uma porção de macaxeira frita por R$ 3,00 e uma Cioba (peixe) por R$ 18,00. Fica ao lado da pousada Porto do Trapiá.

Nós ficamos 4 noites no total (23-27/dez) e achamos que foi de bom tamanho. Mais que isso só se for pra ficar realmente à toa descansando ou praticar kite ou wind-surf. Se você quer sossego, vai encontrar um bom ambiente lá.

Finalmente, confira o álbum de fotos de São Miguel do Gostoso – RN com as principais fotos da viagem.

Posts possivelmente relacionados:

Link Permanente | 5 commentários
Post tags: praia, viagem

Plasma animations running embedded

2009-12-27T06:48:53+00:00

Friends

This a quick post about the animation classes in the upcoming KDE SC 4.4, showing them running in an embedded device (Nokia N97).

Enjoy:

Some further info: since the animations depend only on QAbstractAnimation, is just trivial to strip it to a ‘raw’ Qt application. A few days ago I had sent a tarball with a standalone application using the Plasma animations to my friend Andre Loureiro and asked him to use it as a base and mimic the kdeexample C++ plasmoid featured in a previous post.

You can grab the code here and give it a try (pay attention that the user code has not being reviewed yet…).

Sweet dreams are made of… chromed metal!

2009-12-25T21:28:13+00:00

Dear friends

This is a non hacker related post (so disclaimers are already made). This Christmas (*insert_your_religious_holiday_name_here) I decided to make real an old childhood dream and bought to myself a… motorcycle!

Yeah, bad hackers on motorcycles are around the corner (My guess that this must be an influence of playing Lucas Arts Full Throttle a decade and half ago).

So, for your amusement, here goes some snapshots of my motorcycle (a second hand Honda Shadow 600cc with just 18000KM of use):

a) ‘Naked’ motorcycle (without the accessories)

b) After installing the accessories

c) Left side of engine

d) Right side of engine

It is not a Corley but its engine sound is just sweet to my ears.

need I say more?

2009-12-19T13:53:25+00:00

Nokia WebKit Code Camp

2009-12-18T13:48:23+00:00

So last week Nokia ASF hosted a Qt WebKit Code Camp in Wiesbaden, Germany. It was the first time most of the people working on - or using WebKit inside Nokia, got together and met face-to-face. It is obvious that we have a great bunch of clever people, but also that we still have a lot of work to do before out Qt port is up to the level of the Google and Apple ports, but don'tworry, we are definitely getting there!

Before the event, I had a look at adding tiling support to see if it would actually bring noticable performance improvements. I did a small presentation about it, which you can find below. [UPDATE] The implementation is an experiment to avoid doing unnecessary calls into WebCore and is only meant as input for other people working on adding tiling support to WebKit. I would like to thanks ProFusion, Antti Koivisto and Benjamin Poulain for fruitful discussions who helped to the current implementation.

Considering Tiling for a better User Interface

View more documents from kchristi.

Having working on NPAPI plugin support before, I can tell you it is not a very beautiful part of a browser. Some time ago, we were so lucky that Girish joined us and implemented support for windowless plugins. Now he has even gone one step further and written a huge blog post about it, something that is definately worth checking out. You can find it here:

http://blog.forwardbias.in/2009/12/flash-in-qgraphicsview.html

Also, join me in congratulating him in becoming an official WebKit committer!

At the office we are starting to get into Christmas mood! and friday I'm heading off to Europe to celebrate the Christmas holidays with my family and girlfriend.

Anselmo just took this nice picture from our office:

Merry Christmas to you all!

Bossa Conference ‘10 – Call for presentations

2009-12-16T21:17:03+00:00

‘As always, the Bossa’10 conference changes paradigms and moves its structure to Manaus – Amazonia. Looking for a new atmosphere the Organization committee found the perfect place for next years conference. So, wait for the new website in December’09 and be part of this new ERA of Bossa Conference. BOSSA’10 – The Bossa in the Jungle!’

The Call for presentation is Officially Opened! So, if you want to share with us your knowledge, feel free to submit your presentation. The period for submissions is from September, 1st to January, 1st, but as soon you send your submission, more chances you’ll have.

To submit a presentation, all you have to do is send an e-mail to cfp AT bossaconference DOT org with the following informations:

Name:

Nickname (handle):

Email:

City:

Country:

Presentation Title:

Abstract ([200,500] words):

Keywords:

Attachments (paper, presentation, pictures, videos, docs, links, …) or Links:

Need sponsorship ?!

Reasons for sponsorship:

For mor information, see the Bossa Conference Homepage: http://bossaconference.indt.org/

We are waiting for you!

Plasma new animation classes: video

2009-12-11T11:45:54+00:00

As promised in an earlier post, here goes the video showing the kdeexample plasmoids, showing the current pre-made plasma animations (pulse, grow, fade, zoom, slide, 2d rotation, stacked rotation).

Those are based on QAbstractAnimation, allowing the libplasma user to access a common set of stock animations and mesh it together with his own animations. Pay attention that this is *not* a framework, you should compare it to QAbstractAnimation based classes in Qt, like QPropertyAnimation and its friends.

Smoothness is not great thanks to the video screen capture software (I increased the duration of the animations to make it easier to follow them). The animations can run in both directions, so it makes it easier to return a widget to its initial state (e.g. opacity, grow, rotation) but will not make sense for all animations (e.g. pulse). This is done by just changing the animation direction (Forward and Backward) property.

In the video, each button will run its own animation when clicked and later all the animations will run inside of an animation group. You can download it in ogg format, or watch it below:

The video is a slightly changed version of kdeexamples C++ plasmoid code.

Plasma new animation classes

2009-12-10T20:50:14+00:00

One of KDE 4 objectives was to create an organic and even more pleasant environment (and it is being achieved with both plasma-desktop and plasma-netbook). One of the features that contributes significantly to achieve a natural look and feel (together with really *great artwork*) are animations.

KDE 4 introduced plasma Animator class with the purpose of applying effects and animations to plasma widgets. With the new Qt 4.6 animation framework (a.k.a. kinetic), plasma effects started to be ported to it, introducing some new animations (e.g. Pulse, Rotation, Stacked rotation, kinetic scrolling) which are already being used in the upcoming KDE SC 4.4.

Kinetic scrolling made its debut in Plasma::ScrollWidget, used internally in uBlog (the twitter/identica plasmoid client) and plasma-netbook (i.e. to scroll through icons in application containment). It has a long story and was rewritten at least 4 times:
- Using a single timer and coordinates for scrolling (with bouncing effect);
- Using percentages for scrolling and properties for position;
- Using coordinates with properties again and implementing the concept of scrolling manager;
- Using QPropertyAnimation to do the animation instead of a timer (and having the bouncing by just changing the easing curve)

The new plasma animation classes has also an interesting story, being submitted through at least 4 big refactorings:
- Initial import based on gSoC project done by Mehmet Ali Akmanalp;
- Animation objects caching;
- Using QAbstractAnimation as base class;
- Reimplementing QAbstractAnimation::updateCurrentTime and non longer using an internal QPropertyAnimation/Group object to actually do the animation;

The good news are that the code is being made more flexible and paradoxically simpler at each review session. What about an example? Say that you want to have that nice pulse effect when a widget name button (i.e.that has QGraphicsWidget as base) is selected you just need to write something like this:

Animation *pulseAnim = Animator::create(Animator::PulseAnimation); pulseAnim->setWidgetToAnimate(button); connect(button, SIGNAL(clicked()), pulseAnim, SLOT(start()));

And the same concept is used for the following animations: rotation (2D), fade, grow, zoom, slide, stacked rotation (‘3D’), geometry. Obviously, that depending on the animation type, you got to setup more parameters, like movement direction/reference/distance/axis. Selecting easing curves is also possible, but we are working to have good pre-selected curves that makes sense for each animation class.

Those plasma animations can easily be integrated together with your own animations and directly used in animation groups (i.e. QAnimationGroup) being parallel or linear. Finally, all those classes are being bind with javascript making it dirty easy to have future js plasmoids with nice animations.

So, where to start now? My suggestion is to have a look in kdeexamples where there is a test C++ plasmoid that exercises pretty much all the current available animations.

Next post: video showing the animations.

Handling GraphicsView events – Part. 2

2009-12-09T22:40:56+00:00

In my previous post, I’ve shown you how to handle events (specifically mouse events) inside GraphicsView.

Lets expand this idea and create a customized widget on Graphics View. The simplest widget of them all is the Push Button (actually the simplest widget is the Label, but then, I wouldn’t have much to write on this post ).

The Button widget has the following characteristics:

Display 2 images depending on its state (normal & pressed);
Detects mouse clicks (including moving the mouse while clicked);

On to the coding part…

There’s only one attribute for storing the Button’s state: m_isPressed. Depending on the value of m_isPressed, the paint() method will either draw one of two QPixmap objects, m_normal or m_pressed.

Here’s the paint() method for the Button class:

void Button::paint(QPainter *painter,
                   const QStyleOptionGraphicsItem *option,
                   QWidget *widget)
{
    Q_UNUSED(option);
    Q_UNUSED(widget);
 
    if (m_isPressed)
        painter->drawPixmap(0, 0, m_pressed);
    else
        painter->drawPixmap(0, 0, m_normal);
}

The change between the normal and pressed image happens through the mouse handling methods. Here’s the mousePressEvent() method:

void Button::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        if (contains(event->pos()))
            m_isPressed = true;
 
        update();
    }
}

If the user clicks within the image area, m_isPressed is set. Therefore, the pressed image is displayed.

Now the mouseMoveEvent() method:

void Button::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    if (event->buttons() & Qt::LeftButton) {
        if (contains(event->pos())) {
            m_isPressed = true;
        } else {
            m_isPressed = false;
        }
 
        update();
    }
}

It the user moves the mouse (while clicking) to outside the image area, m_isPressed is changed.

And finally, the mouseReleaseEvent() method:

void Button::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        m_isPressed = false;
 
        update();
 
        if (contains(event->pos())) {
            emit clicked();
        }
    }
}

The m_isPressed attribute is unset and the clicked() signal is emitted (if the mouse stays within the image area).
Here’s the customized Button in action:

The source code for this example is at my gitorious repository, under the button dir:

http://gitorious.org/tech-blog/sources/trees/master/button

Because the image is a rounded one, there are some parts “outside” of the Button that also receive mouse events. This happens because we still need to determine the “clickable” area through the shape() method. But that’s something for another post.

Till next time.

How CMake simplifies the build process: Part 2 (Advanced build system)

2009-12-09T16:55:59+00:00

Hello everyone,
My previous post explained how CMake could manage a simple project (containing only one definition and implementation file). Now we can have a look at a complex project, containing a common shared library, examples and unit tests. In this case, instead of a dumb HelloWorld project, I've chosen the Itemviews-NG project, which is an experimental project hosted by the Qt Labs and currently uses qmake as build system. The project itself consists of the following:

A common shared library containing the base classes;
A collection of examples for each class from the library;
A collection of unit tests for each class from the library;

NOTE: Documentation won't be created for now - Itemview-NG uses qdoc to generate documentation, which AFAIK isn't well integrated with CMake yet. There will be another post about using doxygen with CMake, together with lcov coverage and gcov HTML output integrated.

As a starting point, the project itself contains various files which needs to be processed by the MOC. To simplify this process, CMake can use the automoc tool which automagically finds the required files to be preprocessed and includes them at the target build. Qt libraries and includes are also provided by the Qt4 cmake package (built-in). To use Qt4 plus automoc cmake packages, you can include the following code on the CMakeFiles.txt located at the project's root directory:

# Qt4 package is mandatory
find_package(Qt4 REQUIRED)
include(${QT_USE_FILE})

# Automoc4 is also mandatory
find_package(Automoc4 REQUIRED)

Now let's see how the CMakeFiles.txt from the src/ directory changes:

set(CMAKE_INCLUDE_CURRENT_DIR ON)

# Create a variable containing a list of all implementation files
file(GLOB itemviews-ng_SOURCES *.cpp)

# The same applies for headers which generates MOC files (excluding private implementation ones)
file(GLOB itemviews-ng HEADERS *[^_p].h)

# Now the magic happens: The function below is responsible for generating the MOC files)
automoc4_moc_headers(itemviews-ng ${itemviews-ng_HEADERS})

# Creates a target itemviews-ng which creates a shard library with the given sources
automoc4_add_library(itemviews-ng SHARED ${itemviews-ng_SOURCES})

# Tells the shared library to be linked against Qt ones
target_link_libraries(itemviews-ng ${QT_LIBRARIES})

# Installs the header files into the {build_dir}/include/itemviews-ng directory
install(FILES ${itemviews-ng_HEADERS} DESTINATION include/itemviews-ng)

# Installs the target file (libitemviews-ng.so) into the {build_dir}/lib directory
install(TARGETS itemviews-ng LIBRARY DESTINATION lib)

Now every example or test from the project which uses that library could use the target itemviews-ng as a link dependency. As each examples and tests are compiled in a similar way, we can use functions which eases the compilation process. Below is an example of those functions:

function(example example_NAME example_SOURCES example_HEADERS)
    automoc4_moc_headers(${example_NAME}_example ${examples_HEADERS})

    # The third argument (resource files) is optional:
    set(example_RESOURCES ${ARGV3})
    if(example_RESOURCES)
        automoc4_add_executable(${example_NAME}_example
            ${example_SOURCES} ${example_RESOURCES})
    else(example_RESOURCES)
        automoc4_add_executable(${example_NAME}_example
            ${example_SOURCES})
    endif(example_RESOURCES)

    target_link_libraries(${example_NAME}_example
        itemviews-ng ${QT_LIBRARIES})
endfunction(example)

function(test test_NAME test_SOURCES)

    set(test_RESOURCES ${ARGV2})
    if(test_RESOURCES)
        automoc4_add_executable(${test_NAME}_test
            {test_SOURCES} ${test_RESOURCES})
    else(test_RESOURCES)
        automoc4_add_executable(${test_NAME}_test
            ${test_SOURCES})
    endif(test_RESOURCES)

    target_link_libraries(${test_NAME}_test
        itemviews-ng ${QT_LIBRARIES})
    include_directories(${itemviews-ng_BINARY_DIR}/tests/${test_NAME})

    add_test(${test_NAME} ${test_NAME}_test)
    add_dependencies(check ${test_NAME}_test)
endfunction(test)

The functions above can be inserted into a .cmake file (eg: InternalMacros.cmake) that goes into cmake/modules directory. To load it, put the following line inside CMakeLists.txt from the root directory:

include(InternalMacros)

Now you can create a CMakeLists.txt for each example like this:

set(mycustomexample_SOURCES
    mycustomexample.cpp
    main.cpp
    )

set(mycustomexample_HEADERS
    mycustomexample.h
    )

example(mycustomexample "${mycustomexample_SOURCES}" "${mycustomexample_HEADERS}")

The same applies for tests:

test(mycustomtest "${mycustomtest_SOURCES}")

I've made a branch cmake at my personal gitorious itemviews-ng clone. You can have a look at it to see how does the code explained above behaves.

How CMake simplifies the build process: Part 1 (Basic build system)

2009-12-07T14:39:56+00:00

Hi!

After a long period of abstinence from blogging (mainly because I was freaking my head out with internal work), I'm going to share my achievements on learning how to use CMake. I must confess as a previous autotools (aka. auto-hell) and qmake user I got a little bit biased about CMake, but after looking at a few examples and reading some documentations I've found that it is way easier to learn and use than the previous build systems I've used. Basically, CMake uses a series of macros and functions which finds the required components for you, in a simple and precise way - this means no unnecessary dependencies!

As an example, I've found a very useful macro called MacroOutOfSourceBuild, which requires the user to build the source code outside the source code directory (build directory != source directory). This ensures the user uses a shadow build directory, which is a very good practice, by the way. Enough of talking, let's have a look at some code examples. Suppose you have a small project "Hello World" (download source code here) which has its source files arranged like the diagram below:

helloworld/
  \_ CMakeLists.txt
  \_ cmake/
    \_ modules/
      \_ MacroOutOfSourceBuild.cmake
  \_ src/
    \_ CMakeLists.txt
    \_ main.cpp
    \_ helloworld.cpp
    \_ helloworld.h

In the case above, the files helloworld.cpp, main.cpp and hello.h are located inside the src/ directory, which is itself located on the project's root directory. CMake states that each project directory (including recursive sub-directories) which contains source code should have a fille called CMakeLists.txt, which contains the build instructions for each directory. As the "Hello World" project does have two directories (root directory plus src/ directory), then two CMakeLists.txt files are created (shown below):

CMakeLists.txt - root directory:

# Project name is not mandatory, but you should use it
project(helloworld)

# States that CMake required version must be >= 2.6
cmake_minimum_required(VERSION 2.6)

# Appends the cmake/modules path inside the MAKE_MODULE_PATH variable which stores the
# directories of additional CMake modules (eg MacroOutOfSourceBuild.cmake):
set(CMAKE_MODULE_PATH ${helloworld_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})

# The macro below forces the build directory to be different from source directory:
include(MacroOutOfSourceBuild)

macro_ensure_out_of_source_build("${PROJECT_NAME} requires an out of source build.")

add_subdirectory(src)

CMakeLists.txt - src/ directory:

# Include the directory itself as a path to include directories
set(CMAKE_INCLUDE_CURRENT_DIR ON)

# Create a variable called helloworld_SOURCES containing all .cpp files:
set(helloworld_SOURCES helloworld.cpp main.cpp)

# For a large number of source files you can create it in a simpler way
# using file() function:
# file(GLOB hellworld_SOURCES *.cpp)

# Create an executable file called helloworld from sources:
add_executable(helloworld ${helloworld_SOURCES})

Now you create a shadow build directory (eg. build/) and build your project, as shown with the commands below:

$ mkdir build
$ cd build
$ cmake ..
$ make

That's it! This finishes the first part of a series of useful tips about using CMake as the build system from basic to complex projects. If you need further information, please have a look at the tutorial website.

Qt's Animation framework API updates

2009-12-05T11:31:40+00:00

Hi again,
Since my previous post, we've been using the QAnimationState class together with the convenience method addAnimateTransition() to get animated transitions between states. Now the API's got even cleaner and easier to understand, you don't have to use a special state in order to associate animated transitions to it any longer ;) I've updated the Qt's documentation about the animation framework, you can read it below:

Animations and States

When using a state machine, we can associate an animation to a transition between states using a QSignalTransition or QEventTransition class. These classes are both derived from QAbstractTransition, which defines the convenience function addAnimation() that enables the appending of one or more animations triggered when the transition occurs.

We also have the possibility to associate properties with the states rather than setting the start and end values ourselves. Below is a complete code example that animates the geometry of a QPushButton.

QPushButton *button = new QPushButton("Animated Button");
button->show();

QStateMachine *machine = new QStateMachine;

QState *state1 = new QState(machine->rootState());
state1->assignProperty(button, "geometry", QRect(0, 0, 100, 30));

machine->setInitialState(state1);

QState *state2 = new QState(machine->rootState());
state2->assignProperty(button, "geometry", QRect(250, 250, 100, 30));

QSignalTransition *transition1 = state1->addTransition(button,
SIGNAL(clicked()), state2);
transition1->addAnimation(new QPropertyAnimation(button, "geometry"));

QSignalTransition *transition2 = state2->addTransition(button,
SIGNAL(clicked()), state1);

transition2->addAnimation(new QPropertyAnimation(button, "geometry"));

machine->start();

You can find the most up-to-date documentation about the Animation Framework and State Machine framework here: http://doc.trolltech.com/4.6-snapshot/index.html

Sending patches using git-email

2009-12-05T11:17:47+00:00

If you work on a project that uses GIT as repository, you should probably need a simple way to send your patches to others in a simple, clean way. For this, I've started (for a while now) using a very cool tool called git-send-email. For Ubuntu users, It is available on the git-email package (sudo apt-get install git-email) and provides a way to send patches through email to others. See HOWTO below:

Install 'git-email' package:

$ sudo apt-get install git-email

Add these options to ~/.gitconfig:

[sendemail]
smtpserver = "yourmailserver.com"
smtpuser = "user"
smtppass = "abc123"

Now suppose you have a local patch that needs reviews/acks. Pick up
its hash with 'git log -n 2':

$ git log -n2
commit a268d86e547dffe73c9f7b4633913ffdf91b1a8e
[..]
commit bf14b2f140fc84a57f61c7f59efae294b2a9a1df
[..]

Pick up commit hashes and create a formal patch file using 'git
format-patch -C ..':

$ git format-patch -C bf14b2f140fc84a57f61c7f59efae294b2a9a1df..a268d86e547dffe73c9f7b4633913ffdf91b1a8e

0001-COMMIT-SOMETHING.patch

Note

$ git format-patch -n

Almost there! Now send your patch to mail list using 'git send-email':

$ git send-email --to "mail@list.com" 0001-COMMIT-SOMETHING.patch

Done!

Playing with QAnimationState

2009-12-05T11:08:42+00:00

After some time studying and learning how Qt's Animation framework and State Machine framework works, I've come to this little example I would like to show:

As you can see from the video above, the horizontal list shows a subset of all its items, and the focused item always stays on the first position. List navigation happens when the user presses a keyboard key (in this case, left/right keys), which then emits a signal which is connected to the horizontal list controller slots. The horizontal list internal state machine is then responsible for managing the animations using QAnimationStates, which executes the demanded animation and then returns to the default state:

initialState->addFinishedTransition(stoppedState);
stoppedState->addTransition(this, SIGNAL(moveItemsToLeft()), m_NextItemState);
stoppedState->addTransition(this, SIGNAL(moveItemsToRight()), m_PreviousItemState);
m_NextItemState->addFinishedTransition(stoppedState);
m_PreviousItemState->addFinishedTransition(stoppedState);

On the horizontal list state machine, initialState executes the initial animation (not shown on this video), then it goes to stoppedState. From this, every time the list needs to animate something, it uses a QAnimationState (eg. m_NextItemState, m_PreviousItemState) to do the job. I general, these new Qt frameworks have a very intuitive API and provides an easy way to implement nice animations. Kudos for Qt developers!

Creating Web Albums with gThumb

2009-12-04T20:31:52+00:00

If you want to create a web album with some images you have in your computer, with Linux as your OS, i recommend you to use gThumb.

gThumb is, as said in WikiPedia (http://en.wikipedia.org/wiki/GThumb):

… an open-source image viewer and organizer for the GNOME desktop environment released under the GNU General Public License. It was originally based on GQView, and is designed to have a clean, simple interface.

gThumb Homepage: http://gthumb.sourceforge.net/

INSTALLING GTHUMB:
I’m using Ubuntu 9.04, named Jaunty Jackalope, to write this tutorial, so the installation process is very simple, all you have to do is run:

1	# aptitude install gthumb

This should work the same way for Debian GNU/Linux, but if you’re using another distro Linux, you might have to compile gThumb.

CREATING WEB ALBUM:
When you run gThumb you’ll see this interface:

I mapped it to make it easier to follow:

The steps to create the Web Album are:
1 – Create directory to keep the images:
First create a directory and put the images you’d like to be in the album in it.

2 – Open directory with gThumb:
In gThumb interface, select the directory in which the images are (#1 in MAP)

3 – Select the images you’d like to show in the album:
After opening the directory, which contains the images, you’ll have to select the images you’d like to show in the album (#2 in MAP)

4 – Open the “Create Web Album” window and configure it:
Now, with all images selected, go to Tools > Create Web Album (#3 in MAP)
Then you should see a window like this:

This is where you’ll configure your web album. The options are:

#1 – Where the web album files will be saved.
#2 – The name of the page, i recommend you to leave it as it is.
#3 – How many images per line and per column will be shown.
#4 – The title of the page, or header message, if you preffer.
#5 – The footer message of the page.
#6 – The theme that will be used in the web album.

The other options are not so important for me, so i didn’t put them in here.

In the end, you’ll have something like this: http://am.softwarelivre.org/galeria/fedora12releaseparty/

:wq

PySide maemo packages

2009-12-02T15:14:02+00:00

It has been a week since the official PySide 0.2.2 release and we finally finished the Maemo packages, that includes full implementition of Qt 4.6 and the new module QtMaemo5.

The packages are available at extras-devel repository. More instructions on how to install (into device and/or Scratchbox) can be found at PySide website - download section.

The PySide team would like to thank all those who helped on this release, reporting bugs, sending patchs and discussing on irc channel. Also, we would like to invite users and developers to discuss the future of a new PySide "pythonic" API, and help us to produce a powerful Qt binding.

PySide contacts:
WebPage: http://www.pyside.org
irc channel: #pyside at freenode
mailing-list: pyside@lists.openbossa.org
bugzilla: http://bugs.openbossa.org/

Qt 4.6 & mobile-demos also on desktop

2009-12-02T14:27:06+00:00

You may have seen these posts about mobile demos , this nice video showing the making of the weather demo and also the last video released yesterday.

To celebrate the new version of Qt, the first with the S60 port, we thought it would be nice if people could also check those demos on desktop platforms. You know, Qt is everywhere =)

As the release was yesterday, probably there are people without Qt 4.6 installed in their desktops yet… so we prepared binaries with Qt 4.6.0 statically linked =)

Linux version

Windows version

Mac version (Unfortunately I don’t have a Mac available here right now. Contributions are welcome =)

It’s worth a mention. The source code for all platforms is basically the same, the only difference are due to different screen sizes, different connections methods. This code is still available in the same place: http://gitorious.org/qt-labs/mobile-demos

And again, owners of either S60 devices or N900 find packages at: http://qtlabs.openbossa.org/mobile-demos .

—

TODO: Fix the bug in the weather demo when there’s no connection…

PS1: As an extra activity, support for keypads is work in progress (I have a N85 =P )

PS2: Now that Qt 4.6.0 is out, it’s a good moment to make it work again …

PS3: Hello planet KDE! \o/

Changing the Weather with Qt by INdT

2009-12-01T16:41:10+00:00

It all started like the video says. I got to Patricia asked her to do something really beautiful with Qt 4.6 in mind. Ian, Tam and Patricia then got together for this really fast project and now they also did a small video to show how it was done. When they told me that they were going to make this small movie for fun 2 days ago and I knew something as cute as the app was coming. So proud :) Now we have the miniEbook Reader filled with envy dying for a video too :)

This app is for Maemo and Symbian, showing some cross platform real power from Qt.

Update: Patricia is back on blogging, so here’s her full post on the small Qt app :

Changing the weather from Ian Moreira on Vimeo.

Foi lançado o Qt 4.6 !

2009-12-01T16:15:34+00:00

Está disponível desde hoje cedo a versão 4.6.0 do Qt com diversas novidades, como diz o post oficial dos nossos amigos do Qt.

A nova versão está disponível para download em qt.nokia.com, em versões pré compiladas para Windows, MacOS e Symbian, além do código fonte (para todas as plataformas). Usuários Linux podem baixar e compilar o fonte ou então instalar usando os procedimentos normais de cada distribuição, tão logo estejam disponíveis os pacotes desta versão.

Entre as novidades dessa versão estão:

API de Animação (QAnimation)
Máquina de Estados (QStateMachine)
Novo layout (QGraphicsAnchorLayout)
Suporte para a plataforma Symbian, o que permite que o Qt rode em dezenas de milhões de novos aparelhos

A documentação atualizada com todas as novas classes está pronta também, ou pelo Qt Assistant ou online.

Outro fato marcante desta versão é o fato de ser a primeira após a abertura do repositório Git do Qt, e assim marca uma integração cada vez maior com a comunidade. Nesse sentido esperamos que todos usem, testem e mandem opiniões e reports de eventuais bugs, para que as próximas versões sejam cada vez melhores!

Para ilustrar um pouco, um vídeo feito pelo pessoal aqui do openBossa mostrando o 4.6.0 rodando em diversos aparelhos!

Para finalizar, algumas fotos do time do Qt.

Em Oslo

Em Berlin

Em Brisbane

Em Munich

Parabéns pessoal!

The Cross platform Qt era is coming!

2009-12-01T15:12:34+00:00

While true, zero effort cross platform would be nearly impossible but what if you could do it for your mobile devices with minimal efforts? Also it would be really nice if designers and developer are able to do more “rich” UI style software with less effort.

This is how I see Qt. I see it as welcoming changing to the Nokia development platforms that will help my team to be more creative, and the developer teams around us to bring our crazy ideas to life with quality and record time.

I am sounding like an paid AD. But I can assure you: is that good, and it’s just starting.

This video is a showcase of 4 small “demo” apps (don’t have full functionality) designed and developed in less than a month, between our real projects and shows some real results on how to be cross platform. Lots of things to do (events for keypads, resize) but the changes are coming, but you can already see why you should really look again at Nokia as your platform of choice.

Qt overload

2009-12-01T13:28:51+00:00

Here’s another video with the Qt demos we worked on, running on S60 3.2, 5.0 and Maemo 5. Get Qt here.

Beware: catchy music.

Solving N810 keyboard problem on linux-omap 2.6.29

2009-12-01T12:43:28+00:00

On previous post, one of the problems mentioned on 'Known Issues' when compiling and flashing the kernel 2.6.29-omap1 was related to the keyboard: some keys doesn't work, so we could not type commands on 'X Terminal'.

I proposed a patch that solves this problem to linux-omap mailing list. It's just need to set the value of platform parameter size_y to the correctly (12, instead of 8).

This simple modification makes now N810' keyboard work properly.

To test it, just apply this patch against the linux-omap tree (on version 2.6.29-omap1 - commit 58cf2f1425abfd3a449f9fe985e48be2d2555022), recompile and reflash the kernel.

Qt 4.6: Ow!

2009-12-01T12:42:37+00:00

So, Qt 4.6.0 is out! It’s really a “big” release: QAnimation Framework, Symbian Release, Qt Creator 1.3, Maemo 5 Tech Preview and Qt Mobility. Ow!

Basically we have been working with the trolls in this release for a year now and it was awesome to see how we got from 4.5 to 4.6. All the work done on the APIs, bug fixing, the release process and also making it more open. The LGPL license, the opening of repositories and bug tracker.

I’ve been advertising about a little piece of this game that is QGraphicsAnchorLayout that is where we spent most of our efforts for this release. We hope that this will help people out there working with rich UI applications and in the need of better layout classes.

Sometime ago I also wrote about some demos for the Maemo and Symbian platforms showing the power of Qt Animation Framework and Qt 4.6 itself as it improved a lot in performance (besides the fact of integration with the platforms as we have the same code for both platforms).

You can take a look at the demos at the video below and try on your mobile phones downloading the sis/deb files from this place. Remember that these are UI demos and some of them are not fully implemented like the Hyper UI not doing real phone calls or not being able to add items to the shopping list (however the Weather and My Budget are probably very, if not 100%, functional).

If you want to take a look at the demo’s code, be my guest and check gitorious for it . Ah, for those that missed the link above for the download, here it is again: http://qtlabs.openbossa.org/mobile-demos/4.6.0/ . Summary of Qt 4.6 ? Ow !!!

Take a look at the official Qt 4.6 pages too:

http://qt.nokia.com/downloads/downloads

http://qt.nokia.com/products/platform/symbian

http://qt.nokia.com/products/platform/maemo

The world just became a bit cuter

2009-12-01T10:47:51+00:00

Today is an important day for me, as Qt 4.6 has been released; the first release that I have been deeply involved in.

Actually, I can say that my employer Nokia Technology Institute, INdT, has done a great job on Qt 4.6, as we have contributed to various areas:

QGraphicsAnchorLayouts: My ex-team implemented a new layout together with Jan Arve, where one can anchor widgets together in the Graphics View. It is extremely flexible, as the layout has no pre-defined concept of how should the items be arranged. The final position of each item is totally dependent on how you set the anchors.
Qt Mobile Demos: Three great demos, showing off the power and flexibility of the Qt 4.6 development framework. This video says it all:

A cool video by my co-worker Ian Andrade
PySide: A Python binding for Qt 4.6, that currently works on Linux, Maemo and Mac OS X, with Windows on the way.
QtWebKit: Great works has happened on the WebKit front. Personally I have worked on plugin issues, a new QGraphics-based widget, testing framework, API reviewing, DOM access from C++, among other things. It has been a crazy 9 months since 4.5, and it is amazing how much we have got done.

For more information on the WebKit work, checkout my Maemo Summit presentation, but keep in mind that the PluginDatabase support has been postponed for the next release.
Developments in the Qt WebKit Integration
View more documents from Nokia, Qt Development Frameworks.

Please enjoy Qt 4.6! Download it today!

Frases soltas sobre a Finlândia

2009-11-29T17:14:44+00:00

Estou em Tampere desde o dia 02/11. Após mais de 20 dias acho que já tenho algumas frases pra deixar aqui…

Clima

Oito horas de (~~sol~~) claridade por dia quando eu cheguei, agora já está das 9:10am até 3:20am.
Mais uma vez tive a felicidade de ver neve e de ver nevar. É muito massa botar a lingua pra fora pra pegar os flocos.
Todos os moradores aqui reclamam muito dessa época do ano pois não tem neve! Sim, como está muito escuro por boa parte do dia, a neve ajuda a deixar a cidade mais clara, já que ela reflete bastante a luz (nem que seja a dos refletores).

Eu: “Caramba… tá ZERO graus hoje!!”
R: “É… tá quente até, ainda bem né? Você não chegou no inverno forte.”
Eu: “Err… e frio é quanto?”
R: “Ah! Chega a -20″

Hobbies

Sauna é como futebol no Brasil. O primeiro apartamento que fiquei tinha 34m2 e acreditem, tinha uma sauna. Mas depois de um tempo percebi que, na verdade, ter sauna em casa não é algo que se encontre em casas mais simples.
Brincar de frio-quente. Eles adoram. Por exemplo algo bem comum aqui é ficar de 10 a 15 minutos numa sauna de 80 oC e depois pular num lago abaixo de 4 oC, daí eles nadam um pouco e voltam pra sauna. Quer tentar?

Comida

O primeiro choque: durante o almoço, percebi que 80% das pessoas tomam leite junto com o prato de comida. Sim, como se fosse suco. Explicação: eles precisam de cálcio dado que o sol não é um cara que costuma aparecer muito por aqui.
Suco natural: não achei.
Batata, batata, batata e mais batata. O cúmulo foi um prato que comi que tinha batata assada e batata frita de guarnição.
Carnes diferentes: já comi ovelha num restaurante estilo Viking e rena (sim, a do papai Noel) aqui do lado de casa.
Comi caviar Bléééééééé
A comida é um bocado gordurosa.

Língua

‘Kiitos‘ é obrigado, ‘hei‘ é oi, ‘hei hei‘ é tchau informal e ‘katu‘ é rua. Pronto, você sabe tanto finlandês quanto eu.
Todo nome de rua possui katu no fim. Eu já fiquei num apartamento na Mustalahdenkatu e agora estou num apartamento na Yliopistonkatu. Tenta falar aí…
As vogais tem o som muito parecido com o português. Isso ajuda na hora de falar nomes das lojas e ruas. Se bem que tem algumas vogais a mais aqui, e pra pronunciar… é difícil.
Em Tampere o inglês é mais comum entre os jovens. É razoavelmente fácil achar um idoso que não fala nada ou quase nada de inglês.

Misc

Eu nunca me considerei um cara alto. Mas aqui algumas vezes tenho a impressão de ser baxinho.. realmente estranho.
A carga horária diária na Finalândia, na média, é de 8h. Dentro desse tempo eles tem 30min de almoço.
O pessoal aqui curte beber. É muito comum achar pessoas cambaleando pelas ruas de madrugada. Além disso, as ruas principais da cidade ficam imundas durante o “período das baladas”. E acreditem, no dia seguinte as ruas estão completamente limpas. Algum milagre acontece no fim da madrugada…

Fotos em http://picasaweb.google.com/aloisiojr

Google Chrome OS. Or, how to miss the shot.

2009-11-25T16:01:59+00:00

Recently there was a lot of noise regarding the new coolest guy on the street: Google Chrome OS. I was traveling and just today I could read all my feeds, emails and put everything on the right place

Some people talked about it but I usually don’t pay attention or even read some articles but unluckily I was doing some reviews of Palm Pre, the new Zune and other devices and it’s software and for some reason I landed in the article of Free Software Magazine regarding Google Chrome OS and how KDE and GNOME shot each other on the head. I really don’t pay attention to any flame wars or trolls and usually just ignore these topics as they don’t take us anywhere. But this one got my attention (unluckily, again).

I’m writing about it for a few reasons: first the (lack) of technical background present in the article (I really don’t know the author and I’m not judging his technical skills besides the ones shown in the article), second due the fact of being a “Free Software” magazine (as it points out in the domain name at least) and third due the fact that people just love hype .

First Act

Let’s talk about technical facts. If I remember correctly the author says that Chrome OS will use a “GNU/Linux” kernel. There is no such thing. The kernel is Linux: period. If it will use a GNU/Linux system is another history. Then there is this talk about Pulseaudio and this is a “hot topic” in the Linux audio system world.

There are people who like it and (from what I hear everyday in mailing lists and IRC channels) more people who doesn’t like it. Personally I don’t use it as I don’t have the need and my distro (slackware) does not ship it by default. The excuse of the author for the fact that Chrome OS was not using GNOME/KDE and/or GNU Linux was that none of them provides what Google wants and because there were too many options and none of them was good enough. If none of them is good enough I’ll let for the reader to decide about it but that is not why Google didn’t use it.

First of all Chrome OS will have the help of Canonical to build it’s stuff so probably behind the Webkit stuff that the user will see as the “workspace” it will just be a regular Linux distribution (probably Ubuntu based) behind the scenes. In the end it is a GNU/Linux based system.

One could argue about Android not using a GNU/Linux based system and people often confuse Android with Chrome OS (even Google doesn’t have an answer for it yet and Googlers says that probably in the future they will converge to the same thing). Android not using GNU/Linux is true and they don’t even use some common systems like HAL to handle hardware making some (ugly?) hacks to do what HAL would solve out of the box for them. But I understand their side and probably they had reasons to do that (dead lines, licenses, etc…).

Well, I’ll not talk about Google’s work right now. They are doing their job in the sense that they are presenting the world a new way of looking at the desktop. But some arguments like: “there are too many ‘desktops’ libraries” and this is due the fact GNU/Linux has two different desktop environments are just…how can I say…ah! these are arguments that comes from people with no technical background. I don’t write about economic stuff, do you know why ? Because I surely have an opinion, but I don’t have the technical background to write about it and I’ll probably just create more noise and confuse people instead of helping them understand something.

I’ll not extend myself more on this section as it can get too long: but arguments saying that applications have dependencies of .so and this is harmful to the user and proposing solutions that are already out there in ANY Linux distribution (bundle of libraries are packages and it’s dependencies if anybody has questions regarding this), etc.. just make noise and have no technical background.

Sometimes journalists/bloggers are the ones that write about everything without knowing anything and this leads to at least confusion.

Second act

I’m not sure if everybody knows that but Google is just arriving at Free Software world (as much other companies, like Nokia for example). The first approach of Google was being open source friend but not free software. And there is a huge difference.

Thanks to many people Google is changing this and becoming closer and closer to free software with initiatives such as Google Summer of Code, when they fund students to work on free software projects and much other initiatives.

But the point is that a “Free Software” magazine has an article attacking the free software community (I say attacking because there is no constructive feedback or review inside an article without technical background). Ok, you may be thinking that I’m beating too much in the “technical background” key, but even from the user’s point of view there are almost no valid arguments there besides the fact that we need to improve sound on Linux (big news here ).

So, we have a free software magazine, pushing a non free software initiative and talking about non sense stuff. Google has a great product on it’s hands and no doubt about it. But come on: if you want to compare KDE, GNOME and Chrome Workspace do it the proper way.

Third Act

Hype. It’s all about hype. Google Wave was the brand new silver bullet in the world. Everybody that is not a fan boy and seriously tried to used it know what I’m talking about. But the hype was so big because it was a Google’s product (and usually Google has great products) that everybody started creating use cases, theories and etc.. just due to that. No real use case, no real innovation. Just hype.

Again, Google has great products: GMail, Google Docs, Google Analytics, Google AdSense/AdWords, etc… But sometimes people start talking and expecting things just because of the hype. Trolls and fan boys are species that walks together in the world.

The same is happening with Chrome OS here. It’s not ready yet but people are already saying that it will be the best thing ever. Or even that very solid COMMUNITIES and the software around them are dead just because in one year somebody will bring a new product.

Examples from the past ? ‘Virtual reality’ (being used on browsers with VRML and videogames with those horrible goggles), ‘Java Applets’ (who don’t remember it being the final solution for dynamic web pages ???) or even ‘Director’ who was the killer application for multimedia stuff and would kill Flash ?

Final Act: Summary

Let’s just calm down and learn with each other. Gnome and KDE learned a lot of things with each other and with it’s own communities, Linux and the GNU/Linux distributions too.

Google has great products and can really create expectations on it’s users. Google search, maps, Android…all great products but all of them (as any other software) have problems and bugs (anyone using GMail’s imap?).

So please, for the next ones writing about the brand new thing that will kill all the others out there, calm down, write your opinion but just don’t start saying that projects are going to die if you don’t have any clue about it and don’t start guessing stuff. Want to write a user review ? Write it as a user review and about what is bad (maybe what is good too). But writing guessing articles tending to be a user review but pretending to be a technical article is not good for anybody.

Avoid shooting yourself in the foot.

UDS-L Key takeaways

2009-11-25T03:51:45+00:00

After getting the great news that Canonical would sponsor me for the Lucid Lynx developer summit in Dallas, I wanted to let people know about our book and the good reviews we are getting and find out what we could look forward to in the mobile world for this next LTS release.

After an uneventful trip up to Dallas from Manaus the first thing I did was check out the skyline

photo courtesy of Timo Jyrinki

from the top of the hotel and then sit down to plan the highlights of the week ahead.

No UDS would be complete without the customary 'Future of the LPIA port' session which kicked off the week. It would have been killed off there and then I think but I raised the issue of some interesting results I got when writing the testing chapter for our book. There was a 30% improvement when running a 2GB file encryption test on the LPIA kernel when compared to the generic one which I think warrants more investigation. My action point is to re-run all the tests and put the Ubuntu QA team in the loop

Another perennial mobile track favourite @ UDS is the state of ARM soft bootloaders. The problem to be solved is that the current solutions are limited and mostly incompatible with each other. For the Lucid cycle a new small (<2MB) ARM bootloader will be written which will be easy for device manufacturers to install and which will be placed as the main bootloader option for Ubuntu ARM

Next up was a session to choose the default lightweight browser for ARM. Any potential solution needed to have the following qualities in order of priority

Quick on ARM
Touch screen scrolling
Fast javascript
Support for Flash
Good extension support
Java

as well as a small memory footprint and a responsive upstream. After much discussion of the options (Firefox - good but no ARM optimisation yet, Midori - frustrating to use at times, Epiphany - works but a bit limited, MicroB - great but closed source UI and WebKit - multipleupstream sources) the team decided that it will package Chromium and upload it to the archives. The thinking being that Google for sure will want their browser working well on ARM and judging by the number of people running it @ UDS (80%-90%) it is starting to gain significant traction at least amongst developers. This decision was reinforced later in the week with the news of extensions support in Chrome and the news that Canonical are working with Google on Chrome OS

Midweek saw a session on Ubuntu Liquid. The principal objective of this community based mobile release is to support devices which do not have hardware accelerated graphics and to bring to these devices the latest updates available in the Ubuntu world. It will be built using the Ubuntu infrastructure and so will drop the 'Remix' namespace for the Lucid cycle. There was some considerable interest in the session about creating a common framework for running Android and WebOS applications on Ubuntu and also using QT libraries for this. I am involved in this project in my free time along with some other guys from INdT so we expect to have some long weekends hacking in the coming months.

A definite highlight of the week was the 2D netbook launcher for ARM. This is an EFL based application launcher (soon to be released on Launchpad) which runs well on platforms that do not have accelerated OpenGL drivers for X. It was written in a collaboration between the Canonical OEM team and Profusion. For the Lucid cycle the guys will work on building some intelligence into the launcher to probe X and install either the 3D or 2D launcher at install time depending on device capabilities. It was great to see such innovation @ UDS and to know that Brazilian guys were involved.

Speaking of innovation Friday saw a fascinating demonstration of Ubuntu Server and Cloud on ARM. There was a quad core Ubuntu ARM server running away in the room which created some considerable excitement . The ultimate goal for this project in the Lucid cycle is a build system, bootloader, and installer that supports ARM v7 architectures such as Cortex A8/A9. A question was asked during the session about the benefits of Ubuntu server on ARM and the answer was astounding.

I ran the quad core processor at 90% server load for some hours

said Martin, the project lead

and I could comfortably leave my finger on the processor.

Do not try that at home with an Intel chip folks!

Also Friday saw some lightening talks during the plenary sessions where I got up the courage to give a short talk. As far as I am aware our book is the first technology book *ever* written by authors living in the Amazon and for sure it is the first book on Ubuntu Mobile. I got up, said all that and invited everyone to come and visit us and to see our work in Manaus. The recent news then that Bossa 10 conference next year will be

Bossa in the Jungle!

capped off an unforgettable week. There was just time for a group photo

and it was off to catch the plane home. For me this is when the real adventure started but that will have to be the subject of another post.

PySide with Qt-4.6 support

2009-11-24T18:32:28+00:00

Today the PySide team released a new version of project, with full support for Qt 4.6, including QtMultimedia.

Another great news is support for Mac OS X. The first working package have already been released and you can download it from PySide website.
A package for Fremantle is coming :D

Ogre 3D with OpenGLES render system

2009-11-19T11:26:53+00:00

Some time ago I start a new implementation of a Ogre OpenGLES render system, to get this running in the future on Maemo devices, I finished this but never get a chance to see this working on Maemo. But now the things have changed and the new Maemo device already have support to OpenGLES, and my code was merged in Ogre mainline, I can go back and start the test but first I need update this to OpenGLES 2.0 because the old code is implemented on OpenGLES 1.0. I will keep you updated about the news and I hope show some videos :D.

Ogre OpenGL render system: http://ogre.svn.sourceforge.net/viewvc/ogre/trunk/RenderSystems/GLES/src/

Handling GraphicsView events – Part. 1

2009-11-16T15:42:55+00:00

Hi, everyone. It’s been while since I’ve posted something here.

To take out some of the dust from the blog , I figured we could start with something simple like handling events on the GraphicsView framework.

It works like this: The view (QGraphicsView) receives events and passes them to the scene (QGraphicsScene). In order to pass these events to the scene, the view must first convert these units (pixel coordinates) into scene units (vertex coordinates). This conversion process is transparent, but you access these coordinates through convenience methods like mapFromScene and mapToScene. This also applies for the inverse path (passing events from the scene to the view).

Now, let’s say you want to capture mouse events. To do that, you have to reimplement the mousePressEvent and/or mouseReleaseEvent methods. Depending on your needs, they can be reimplemented from within the QGraphicsItem class (handling single items) or the QGraphicsScene class (handling the whole scene).

Here’s an example (I’ve used the class from the previous post as reference):

void CustomItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
  qDebug() << "Mouse button clicked at position: "
           << event->pos();
}
 
void CustomItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
  qDebug() << "Mouse button released at position: "
           << event->pos();
}

Every time you click on the item, it will display a clicked message, and every time you release the mouse, it will display a released message. These methods are called whenever the desired event happens (Mouse presses, Mouse releases, Mouse moves, Key presses, Key releases, etc).

The QGraphicsSceneMouseEvent is the mouse event object. It’s a similar class to the QMouseEvent class, except that it only handles the QGraphicsView mouse events and not QWidget events.

There are also other handling methods like: mouseMoveEvent and mouseDoubleClickEvent for mouse events or keyPressEvent and keyReleaseEvent for keyboard events. For the keyboard ones, the item must be able to receive keyboard focus (QGraphicsItem::ItemIsFocusable flag set). You just need to reimplement them as in the code above.

And that’s it. I’ve also moved my previous examples (plus this one) to a repository at the Qt Gitorious.

The URL is http://gitorious.org/tech-blog/sources.

The example from this post is under the handling-events dir.