In the night of May 18, mages, sorcerers, witches, and fairies took from the cauldron the new stable release of Mageia, now in your third version.

Mageia is a community Linux distribution based on Mandriva. This version have several softwares in their recent versions: KDE 4.10.2, GNOME 3.6, XFCE 4.10, Linux 3.8, systemd 195, rpm 4.11, LibreOffice 4.0.3, and more.

This release is dedicated to Eugeni Dodonov, former employer in Mandiva and a great free software developer. In your last work, Dodonov was in Intel developing a better integration between Intel graphics cards and Linux kernel. Dodonov died very young. He was cycling when was hit by a car. This accident happened in Sao Carlo city, Brazil, in 2012.

This release is special for me because the packages that I am the maintainer are available for Mageia users now. I am packing SWI-Prolog and abnTeX2. I intend make packages for scientific softwares and KDE stuff like themes and plasma applets. And, maybe, make a package to Cave Story because it is a beautiful game and everyone must play it! =)

Release notes, download link, tutorials to update from Mageia 2, and more news  are here.

Jono blogged about respect in community discussions. I have zero to say on the storm-in-a-teacup (his words) that started it other than, perhaps, suggest that when there are waves, there is wind. But whatever direction that wind blows, I'd like to focus on something else. Jono made the following statement:

Ubuntu is not a consensus-based community. Consensus communities rarely work, and I am not aware of any Open Source project that bases their work on wider consensus in the community.

I'm not entirely sure what he means with consensus and community here. He himself defines community as "a collection of people (or animals) who interact with one another in the same environment". Consensus decision making, according to Wikipedia, is:

"a group decision making process that seeks the consent of all participants. Consensus may be defined professionally as an acceptable resolution, one that can be supported, even if not the "favourite" of each individual"

Talking consensus

Let me take this as an opportunity to address a common misconception about consensus: that consensus means full agreement. The Wikipedia entry already points out that the outcome has to be 'acceptable', one that 'can be supported'. This matters: Jono probably meant to say that there is no sizeable community where everybody fully agrees on every decision and I can't imagine he is wrong on that. But that is not what consensus means.

(dis)agreement

The reality is that in a large and diverse group of people, it is impossible to really reach full agreement on any sufficiently complicated matter. Making decisions on agreement of all participants thus doesn't work. Consensus, instead, allows a decision to be made even in the face of disagreement. Essentially, it is a form of democracy without voting.

Ever heard the phrase: "Let's agree to disagree"? That is it: at some point in a decision making process, consensus requires some of the participants to be mature enough to step out of the way and let a decision actually get made. And others need to respect them for that.

Voluntairy

What makes consensus different from voting?

Usually, those in a small minority are the ones who have to (wo)man up and accept that the decision and project is more important than them. The main difference between voting however, where minorities (anything below 50%, usually) don't get their way, is that it is not mandatory. In some cases, the minority can get their way and it can be the majority which steps back and lets them. And even if that doesn't happen, the difference between being forcefully over-ruled and gracefully accepting that you can't always win is big.

A second key point is that ruling by consensus requires discussion, much more than voting does. You can't make decisions by consensus without informing people of the choices - you have to know what you (dis)agree with. Certainly, a community where a few take decisions without talking about it does not decide based on consensus.

Last, the two are not incompattible. It makes all the sense in the world to occasionally do an 'opinion poll' (as opposed to doing a decisive vote) to aid the decision making process. This is valuable input for a consensual decision: vocal supporters of either side can create rather distorted views on how strong the support for a certain opinion really is.

Trust and respect

So I think Jono is wrong when he states that there are no communities which decide based on consensus - KDE is an example of one, Gnome does it often and it's pretty much the way of the Geeko, too. Others usually prefer to vote (Debian) or have a more top-down structure like Ubuntu. There are many ways to Rome, as they say. Being aware of that is a good thing - and being dismissive of ways other than yours is not.

I want to add that Valerie Zimmerman made an excellent argument for the importance of trust and respect. No structure of decision making works without these - trust that those who disagree will have the courage to agree-to-disagree, trust that the majority is right or trust that those who decide for you make the right decisions. And respect each other while debating it.

How can I get paid for free software development? That's a question many developers ask. And it's a good question, because software development is expensive, no matter what the license is. Money is one way to pay for this, but fortunately there are many other ways to get paid for free software. The one thing you should never do, though, is to sell free software cheap.

It's tempting. Put some ads on your blog, a donation button on the project page, get a low paid student job, etc. It's fine, if you can work on free software, right? Some money is better than nothing, isn't it?

No, it isn't. Because it interferes with other ways of being compensated for free software development, such as reputation, control, freedom, learning, or just satisfying your curiosity. Money adds dynamics which can go against these. It changes to whom you are accountable, it alters expectations, and it can actually harm your motivation, because money is a bad motivator. So you need to be very careful when putting money into the equation.

That doesn't mean that there are no good ways to get paid money for free software development. In fact an increasing number of companies have realized that they are better off developing a good part of their software as free software, and they don't compromise on quality or payment. So there are well-paid jobs for free software developers. Guess who gets these jobs. Not those who do it for cheap, but those who have built up a good reputation as a free software developer.

Contributing to free software actually is a great way to build up a career. You are in control. You don't need a university or company program, you can start any time. You can build a reputation doing something you want, something that matters. You can learn and grow following your passion. This is a great foundation for a professional career, and studies show that committers to free software actually get higher salaries than those who don't do this.

Your work on free software is an investment in your happiness, your career, and a better world. Don't sell it cheap.

Jolla has finally launched the first hints to their first hardware. Being an old N9 user, having dropped his phone, I really do want one. The N9 easily outperformed my current Samsung S3, despite its ancient hardware, so I’m really excited about what Jolla will be able to do with modern hardware.

The specs are a bit sketchy at the moment, but I guess things might become more clear tonight. For €399 you will bet a 4.5″ Estrade display, a dual core CPU and 4G support (in some markets, which will be announced later). 16GB of on-board FLASH and support for microSD means that there will be ample space for music, photos, videos and applications.

An 8MP camera seems to be commodity today, but the user-replaceable battery is a nicety.

So, nothing about the performance of the CPU, or even the family. I expect an ARM in the 1GHz range, which will be more than double the power, compared to the N9. Regarding the screen, I do hope for a screen as nice as the N9. I’m kind of worried that no resolution is specified, and Google does not seem to know what an “Estrade” screen is – hopefully it is good. As Europe is targeted first, I hope that the 4G standard supported will be LTE and will work in Swedish networks.

On the software side, I’m really excited about the Sailfish OS and the Gestures. This is what the N9 started, and the N9 is the only real one-hand device I’ve experienced. Finally a Qt / QML environment with the ambition to bring something new to the table.

As for Android app support, I’m not convinced. The power of the N9 was the pure performance of native applications. Adding an Android stack will use system resources and experience the same performance penalty that pure Android systems face. Also, I guess “app compliant” does not mean certified, i.e. does Google Play work? Still, there will be loads of apps, so everyone can use their favorite service. I hope that the Android stack is loaded when needed, so that it doesn’t take resources when using a purely native setup of apps.

At the time of writing, I cannot register a pre-order as the site is down. I only get 503. This must be a good sign, I guess ;-).

I was very sceptic for a long time. Then, I slowly started to trust the kmail2/akonadi combination. I've been using it on my office desktop for a long time, and it works well and is very stable and fast there. (Might be related to the fact that the IMAP server is just across the lawn.) Some time ago, when I deemed things solid enough I even upgraded my laptop again, despite earlier problems. In Gentoo, we've been keeping kdepim-4.4 around all the time, and as you may have read, internal discussions led indeed to the decision to finally drop it some time ago.
What happened in the meantime?
1) One of the more annoying bugs mentioned in my last blog post was fixed with some help from Kevin Kofler. Seems like Debian stumbled into the same issue long ago.
2) I was on vacation. Which was fun, but mostly unrelated to the issue at hand. None of my Gentoo colleagues went ahead with the removal in the meantime. A lot of e-mails accumulated in my account.
3) Coming back, I was on the train with my laptop, sorting the mail. The train was full, the onboard WLAN slightly overstressed, the 4G network just about more reliable. Network comes and goes sometime with a tunnel, no problem. Or so I thought.
4) Half an hour before arriving back home I realized that silently a large part of the e-mails that I had (I though) moved (using kmail2-4.10.3 / akonadi-1.9.2) from one folder to another over ~3 hours had disappeared on one side, and not re-appeared on the other. Restarting kmail2 and akonadi did not help. A quick check of the webmail interface of my provider confirmed that also on the IMAP server the mails were gone in both folders. &%(/&%(&/$/&%$§&/
I wasn't happy. Luckily there were daily server backup snapshots, and after a few days delay I had all the documents back. Nevertheless... Now, I am considering what to do next. (Needless to say, in my opinion we should forget dropping kmail1 in Gentoo for now.) Options...
a) migrate the laptop back to kmail1, which is way more resistant to dropped connections and flaky internet connection - doable but takes a bit of time
b) install OfflineIMAP and Dovecot on the laptop, and let kmail2/akonadi access the localhost Dovecot server - probably the most elegant solution but for the fact that OfflineIMAP seems to have trouble mirroring our Novell Groupwise IMAP server
c) other e-mail client? I've heard good things about trojita...
Summarizing... no idea still how to go ahead, no good solution available. And I actually like the kdepim integration idea, so I'll never be the first one to completely migrate away from it! I am sincerely sorry for the sure fact that this post is disheartening to all the people who put a lot of effort into improving kmail2 and akonadi. It has become a huge lot better. However, I am just getting more and more convinced that the complexity of this combined system is too much to handle and that kmail should never have gone the akonadi way.

Healthy relationships. I've been thinking about them not in my personal life, but in terms of teams in free software. When I first began contributing, it was within a team creating an application (Amarok), so rather small. Then I became active in Ubuntu-Women, which is larger, but still not huge. Then Kubuntu, then the larger Ubuntu community, and now KDE, which is truly enormous.

In all of these projects, communication and trust are paramount. Dialog which fosters creativity and progress is only possible when people enlarge their trust in one another. Along the way to the highest trust levels, many barriers will come down, as people allow them. Sometimes these barriers are invisible, until someone points them out.

I thought I'd seen a cartoon illustrating this story, but a web search tells me it's a story by David Foster Wallace:

Two young fish meet an older fish, who asks them “How’s the water?” The younger fish look at each other and say, “What the hell is water?”

I was reminded of this story recently while observing the various reactions to the removal of the Community link on Ubuntu.com, the portal to the Ubuntu project. The link is coming back, so I'm not complaining. However, what I've noticed is that most of the people discussing the issue seem to be talking past the folks they are hoping to connect with. The emotions expressed range from puzzlement, to shock and outrage, with little understanding on the other "side" on the perceptions causing these reactions.

So how is the water? To me, the drama played out completely predictably, because any time you have one company selling a product, and volunteers working in that same project, you will have class issues, and class is like the water fish swim in. People are often not aware of it, and thus have difficulty dealing with their emotions around it, because they have been taught to ignore it, or even that it doesn't exist. So when the designers removed the link, it was felt as a slap to the face of community members, while the designers see it as just a step to a clean, functional design. The conversation about this change at the recent vUDS clearly betrays this lack of understanding of the other on all sides. http://summit.ubuntu.com/uds-1305/meeting/21740/community-1305-ubuntu-website-planning/

There is no such thing as a culture without class. There are always power imbalances, and privileges. However, that doesn't mean that class is the death of the Ubuntu project, or that volunteers and companies can't happily co-exist. They can, but the fact of class must be acknowledged, and those with privilege and power must realize what they have, and use them on behalf of the project.

A healthy culture has hierarchy, but not one based on domination. In fact, in FOSS that is part of what we are attempting to dislodge, right? We want our hierarchies to be constructed for function, not to rule over us. For instance, those who demonstrate their skill in packaging or coding are given the right to upload to the repositories. And those who grant them that right are those who already have built their reputations by using their skill and trustworthiness in that domain.

Recently there has been a breakdown -- or an apparent breakdown -- in that hierarchy of function in Ubuntu. And I think that both those inside Canonical and those outside, perceive that the other is the one causing that break. So, some repair is needed.

All of our differences can be overcome as we build (or re-build) trust. However, all sides of the issue will need to think about, process emotion about, and finally discuss openly what has gone on. The replacement of the Community link alone will not mend this breach, nor will brief virtual UDS sessions. In fact, I think the lack of in-person face-to-face interaction is allowing this divide to grow.

Folks, we don't want resentment and suspicion to grow, so we are all going to need to work on this if the Ubuntu project is going to continue to thrive as a free software enterprise. In my opinion, thinking about and discussing class issues are fundamental to that effort.

This blog appears on the Linuxchix, KDE and Ubuntu planets, and these issues of class appear in all teams. Health and progress are the goal, and honest dialog is the means. I propose we look one another in the eye and start a conversation. These are difficult dialogs, but our health is at stake.

Globaleaks 0.2 Alpha is out.

Globaleaks is an open source project aimed at creating a worldwide, anonymous, censorship-resistant, distributed whistle-blowing platform. It enables organizations interested in running whistle-blowing initiatives to setup their own safe zone, where whistle-blowers and recipients can exchange data.

2 Years ago I helped out with the development of Globaleaks 0.1. And although I am not active anymore, I really support the initiative behind it. Now with the HERMES Center for Transparency and Digital Human Rights backing it up, it has grown a lot and shaped up to be a very organized and thought through project.

TL;DR:

• Full rewrite
• More flexible and extensible
• Linux ready-made system and network hardened installation
• Written in python using twisted
• New Frontend

Try it out:

Try out the demo. It is pretty straight forward.

Help out:

As young project, Globaleaks can use some help fixing bugs. Just head to the wiki and read through it. It is pretty straight forward, and explains the modules, security concepts and set up instructions.

Globaleaks already has Debian and Ubuntu ready packages. An easy way to help out is to set up a  PPA for us on Launchpad.

Get in touch:

You can contact the Globaleaks team at info () globaleaks org or on IRC on #globaleaks at irc.oftc.net

Here are some screenshots of the new frontend

It’s one of those yearly things, scheduled for less than two months from now. Frankly, I’m a little surprised that no one else — Paul Adams is a usual suspect — has bunged up some badges for this year yet. So here’s my entry for Akademy 2013 in Bilbao, showcasing, as always, my most excellent kolourpaint skills. And, like it says on the tin (brass? what material are badges made of anyway), Akademy doesn’t fit my schedule this year either. My only remaining hope is to integrate the conference with a three week train-and-bicycle vacation for two adults and two kids.

What does every development team want? New contributors!

I'd like to suggest a simple process that can turn visitors to your website, list or IRC channel into a successful part of the development team. When people actually contribute, they quickly feel like a valuable part of the group. New people bring fresh energy, and new ideas.

At your next sprint or meeting, start dreaming. Is your user documentation well-written and up-to-date? Do you need promotion, or video guides? How about art or diagrams for your website? Speaking of your website, when was the last time all the links were tested, and it was checked for spelling and grammar? Create a nice, friendly list of tasks for your newcomers.

Could your codebase use some grooming, for common misspellings, for instance? (EBN is a great source for these). When you run across a bit of code which needs pruning or refactoring, or normalizing signal-slot stuff, the easy thing is to fix it while it's in front of your eyes. Instead, consider which of these small tasks can be filed as a "Junior Job", created for the purpose of getting those knowledgeable people to move from faithful user, to part of the team.

The Bugsquad and Quality Control teams can likely suggest more ideas, too.

KDE Junior Jobs can be easily found: http://kde.org/jj. Teams can create their own shortcut links too, such as Amarok has done, listed in the #amarok IRC channel topic: http://tinyurl.com/amarokjjs. Other tasks can be blogged about, posted on a trello, on the Community wiki; whatever your team likes to use. For more ideas, see http://community.kde.org/Getinvolved.

The Kubuntu team has a list of tasks in Trello, which works well.

So, when you feel like not fixing a little issue, don't feel lazy. Feel responsible! File a bug, make it a JJ, and call attention to those issues when new folks show up and ask, how can I help?


PS: Thanks to the #kde-www team for suggesting this blog. Einar77, neverdingo, mamarok; you are wonderful.

PPS: How LibreOffice does it: https://wiki.documentfoundation.org/Development/Easy_Hacks

In KMail all themes are hard-coded, so it’s not possible for end user to customize his mail header theme.
It’s right in KMail we have several themes:
- fancy Headers

• enterprise Headers
• Brief Headers
• Standard Headers
• Long Headers
• All Headers
• Custom Header (in 4.11 see previous blog)

But to improve it we need to help user to create them.

So I studied Grantlee.
Grantlee is an HTML generator. So it was ok for header theme.

Grantlee generates HTML from an initial HTML template + some keywords defined by developer.
So now just an HTML developer can customize it, it’s not necessary to rebuild KMail.

And I used knewstuff library to allow to upload/download new themes as you can see in next screenshot:

Ok I am not a artist, I can’t show you a new theme, but you can see that I can recreate fancy theme with Grantlee.

Example:

<div dir=”ltr”>
<div dir=”ltr”> {{ header.subject|safe }}
</div>
<table>
<tbody>
<tr>
<td width=”100%”>

<table>

<tr>
<th align=”left” style=”font-size: 10px;”>{{ header.fromi18n }}</th>
<td style=”font-size: 10px;”>{{ header.from|safe }}

{% if header.resentfrom %}
&nbsp; {{ header.resentfromi18n }}: {{ header.resentfrom|safe }}
{% endif %}

{% if vCardName %}
&nbsp;&nbsp;<a href=”{{ header.vcardname|safe }}”>{{ header.vcardi18n }}</a>
{% endif %}

…….. (see all theme code in messageviewer/theme/example_fancy/header.html)

We have a desktop file which define theme name but also the extra headers to displaying.

In example I add “Sender” which is not default header.

I hope that it will have more header theme create (I created a application for generate them, I will blog about it soon)

This week I decided to do some research for the Wayland porting of the KDE Plasma workspaces. One of the features we will need in future is a Wayland session compositor which runs nested on a Wayland system compositor. Of course one could think of setups without a system compositor, but overall I think that a nested compositor simplifies the setup and allows to have all the low level technologies in one place without duplication in all the various compositors. +1 for working together.

After three days of work I already have something to demo (video on youtube):

Sorry for the bad audio. I’ll just explain what one can see. The video starts with the normal X-Server. After that it switches to a VT and we start Weston there. On Weston I’m starting KWin with some environment variables set to pick the correct libraries and force KWin into Wayland mode. KWin creates a connection to Wayland, creates a Wayland surface and uses it for OpenGL output. All the windows from the running X Server are rendered into this surface just as if it were a normal X11 output.

KWin also gets input from Wayland and passes it to the X Server. That’s the reason why we can see mouse interaction and working keyboard.

How it works

The OpenGL backend

KWin supports multiple backends for providing an OpenGL context and doing the texture from pixmap operation. At the moment we have an GLX and an EGL backend. Both create the OpenGL context on the XComposite overlay window and provide the texture from pixmap in the GLX case through the GLX_EXT_TEXTURE_FROM_PIXMAP extension and in the EGL case through the the EGL_KHR_image_pixmap extension.

A new backend is added which creates the OpenGL context on a Wayland surface. The backend started as a fork of the existing EGL backend with the X code stripped out. What’s a little bit tricky is getting the texture from pixmap working. The extension used in the normal EGL on X11 backend is not available. The proper solution would be a setup with XWayland, but that’s still too early as KWin does not yet support Wayland clients.

The solution I came up with is inspired by a fallback mechanism in KWin from the time when GLX_EXT_TEXTURE_FROM_PIXMAP was not guaranteed to be around: XShm to copy the pixmap content into an OpenGL texture. Not a nice solution but it works.

Input handling

Input is currently also a rather hackish solution until we have XWayland up and running. We just take all input events and forward them to the XServer with the XTest extension to inject fake events. It’s a huge hack and one can see how old X is there and how limited. I was rather surprised that it works at all. At the time of this writing the code supports keyboard events and the left, middle and right mouse button. Wheel events are tricky as X uses mouse buttons for them and for more mouse buttons I have problems with mapping them as I’m lacking a multi button mouse.

We are also not able to back sync the mouse position from X to Wayland. As far as I understood the Wayland protocol there is nothing like XWarpPointer, so if something in X warps the pointer we have a mismatch. I agree that warping is evil, but we use it in KWin for activating the screen edges

Next Steps

Cursor

What is to do next is to get the changes to the cursor in X11 and set the cursor on the Wayland surface. That should not be really difficult as the XFixes extension provides everything one would need for that.

Thread

A rather huge limitation at the moment is that the connection to the Wayland display is hold in the main thread. We cannot block there, so we only get events when we actively check for them. This is currently during repainting the screen. So if you wondered why the ShowFPS effect in the video is turned on: it’s to force repaints and to keep the connection alive. This connection needs to go into a thread so that we can block there.

Buffer age

Currently the code forces as to do full-screen repaints. The two solutions we have for non-fullscreen repaints in the EGL backend do not work in the EGL on Wayland backend. The Wayland demo code shows that the EGL_EXT_buffer_age implementation could be used. We wanted to have support for that one anyway in KWin.

Giving it a try

Building from source

I just pushed the code into branch “kwin/wayland-egl-backend” on my clone kde:clones/kde-workspace/graesslin/kde-workspace. Be aware that I intend to force push to this branch.

To build you need to have the Wayland libraries around. The CMake module tries to find it through package kit. Watch the output of CMake, Wayland is only an optional dependency! If you build Wayland and Weston from source, please follow the instructions. You might also need to build Mesa from source.

How to start

Starting is rather simple. Just have an Xserver running somewhere, start Weston on a VT (don’t do nested on X, you would only get a black screen once KWin started) and open a terminal. Setup your environment variables to be able to start KWin and then start KWin in the following way:

DISPLAY=:0 KWIN_DIRECT_GL=1 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace &

KWIN_DIRECT_GL makes KWin skip the OpenGL Test application which is currently only supporting GLX and seems to fail if one is on a different VT. KWIN_OPENGL_INTERFACE tells KWin which backend to use. So by using “egl_wayland” one forces KWin to use the Wayland backend. In future we will probably detect whether the Wayland display environment variable is defined and just pick it directly (though that is dangerous in case of nested Weston on X).

When will it be available in a release

I want to get this work into 4.11 as an experimental feature for multiple reasons. I wanted to have a build dependency to Wayland in 4.11 for quite some time. So that’s a nice excuse. Unfortunately feature freeze is approaching.

Of course I want to give users something to play with. We have talked about Wayland for such a long time and there is nothing to really see that we are walking the way. Last but not least that might be a rather important solution for Plasma Active as that hopefully allows to run on hardware where we currently would not get OpenGL. With libhybris we should be able to get KWin working with OpenGL and being an X11 compositor even if the driver doesn’t support X11. Though I have not tested this case yet and have no devices to play with. But I know a few people in the community who might be interested to play with that.

Krita was the first painting application with an OpenGL accelerated canvas. We had that before Photoshop... Which also meant that the code was getting quite old fashioned. These days, life is supposed to be better. More flexible in any case. However, even though a 2D canvas is a simple thing, once you factor in rotation, zooming, panning and so on, the potential for bugs is quite big, and we've been fixing bugs for ages in the old code.

So I didn't want to throw that away, but have as clean and straightforward as possible a port from the old code to start with. The old code mostly looked like this (for painting the transparency checkers background):

KisCoordinatesConverter *converter = coordinatesConverter();

QTransform textureTransform;
QTransform modelTransform;
QRectF textureRect;
QRectF modelRect;

converter->getOpenGLCheckersInfo(&textureTransform, &modelTransform, &textureRect, &modelRect);

KisConfig cfg;
GLfloat checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast(cfg.checkSize());

textureTransform *= QTransform::fromScale(checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE,
                                            checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0, 0, width(), height());
glOrtho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);

glMatrixMode(GL_TEXTURE);
glLoadIdentity();
loadQTransform(textureTransform);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
loadQTransform(modelTransform);

glBindTexture(GL_TEXTURE_2D, m_d->openGLImageTextures->backgroundTexture());
glEnable(GL_TEXTURE_2D);

glBegin(GL_TRIANGLES);

glTexCoord2f(textureRect.left(), textureRect.bottom());
glVertex2f(modelRect.left(), modelRect.bottom());

glTexCoord2f(textureRect.left(), textureRect.top());
glVertex2f(modelRect.left(), modelRect.top());

glTexCoord2f(textureRect.right(), textureRect.bottom());
glVertex2f(modelRect.right(), modelRect.bottom());

glTexCoord2f(textureRect.left(), textureRect.top());
glVertex2f(modelRect.left(), modelRect.top());

glTexCoord2f(textureRect.right(), textureRect.top();
glVertex2f(modelRect.right(), modelRect.top());

glTexCoord2f(textureRect.right(), textureRect.bottom());
glVertex2f(modelRect.right(), modelRect.bottom());

glEnd();

glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);

In other words, we set a projection, a transformation matrix for the texture and for the model/view and then start drawing the vertices. Pretty simple. I was rather surprised when I did not find any clear tutorial on converting code like this through google. I've read a bunch of modern opengl books and tutorials by now, and they pretty much all have the same order of explanation, the same things they emphasize and the same "advanced" topics. But I couldn't figure out how to draw my checkers or the tiles for my image. Yeah, I'm a linguist, not a mathematician, and I probable read these tutorials wrong or something.

In any case, after going through the Qt OpenGL examples, the tutorials on Wikibooks, the Red, Orange and Blue books, the Matt Gattis' notes on porting to WebGL and more confused questions and more confusing answers on Stack Overflow than I care to count, I finally got something that works, and is as straight a translation of the old code as possible.

Purists will cavil at my use of attribute arrays and glDrawArrays -- but the alternative, as far as I can tell, would be to redo all the matrix calculation and use matrices to place my tiles in the right location or to update and send new vertex buffer objects all the times. This works -- and in the future it might even be pretty.

So, for posterity, and because there might be others in the same spot as me (to wit, tasked with porting OpenGL 1.3 code to OpenGL ES 2.0 or OpenGL 3.1 without compatibility profile), here's a summary of my current code.

The vertex shader:

uniform mat4 modelViewProjection;
uniform mat4 textureMatrix;

attribute highp vec4 a_vertexPosition;
attribute mediump vec4 a_textureCoordinate;

varying vec4 v_textureCoordinate;

void main()
{
    gl_Position = modelViewProjection * a_vertexPosition;
    v_textureCoordinate = textureMatrix * a_textureCoordinate;
}

The fragment shader (needs to be expanded to handle color correction):

uniform sampler2D texture0;

varying mediump vec4 v_textureCoordinate;

void main() {
    gl_FragColor = texture2D(texture0, v_textureCoordinate.st);
}

And finally the code. The shader programs are all done using Qt's shader classes, and I don't show that code here -- it's in the calligra git repo anyway.

KisCoordinatesConverter *converter = coordinatesConverter();

QTransform textureTransform;
QTransform modelTransform;
QRectF textureRect;
QRectF modelRect;

converter->getOpenGLCheckersInfo(&textureTransform, &modelTransform, &textureRect, &modelRect);

// XXX: getting a config object every time we draw the checkers is bad for performance!
KisConfig cfg;
GLfloat checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast(cfg.checkSize());

textureTransform *= QTransform::fromScale(checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE,
                                            checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE);

m_d->checkerShader->bind();

QMatrix4x4 projectionMatrix;
projectionMatrix.setToIdentity();
projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);

// Set view/projection matrices
QMatrix4x4 modelMatrix(modelTransform);
modelMatrix.optimize();
modelMatrix = projectionMatrix * modelMatrix;
m_d->checkerShader->setUniformValue("modelViewProjection", modelMatrix);

QMatrix4x4 textureMatrix(textureTransform);
m_d->checkerShader->setUniformValue("textureMatrix", textureMatrix);

//Setup the geometry for rendering
QVector vertices;
vertices << QVector3D(modelRect.left(),  modelRect.bottom(), 0.f)
            << QVector3D(modelRect.left(),  modelRect.top(),    0.f)
            << QVector3D(modelRect.right(), modelRect.bottom(), 0.f)
            << QVector3D(modelRect.left(),  modelRect.top(), 0.f)
            << QVector3D(modelRect.right(), modelRect.top(), 0.f)
            << QVector3D(modelRect.right(), modelRect.bottom(),    0.f);

m_d->checkerShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
m_d->checkerShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());

QVector texCoords;
texCoords << QVector2D(textureRect.left(), textureRect.bottom())
            << QVector2D(textureRect.left(), textureRect.top())
            << QVector2D(textureRect.right(), textureRect.bottom())
            << QVector2D(textureRect.left(), textureRect.top())
            << QVector2D(textureRect.right(), textureRect.top())
            << QVector2D(textureRect.right(), textureRect.bottom());

m_d->checkerShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
m_d->checkerShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, texCoords.constData());

    // render checkers
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, m_d->openGLImageTextures->checkerTexture());

glDrawArrays(GL_TRIANGLES, 0, 6);

glBindTexture(GL_TEXTURE_2D, 0);
m_d->checkerShader->release();

For Krita, there are quite a few todo's left:

• Restore the opengl outline cursor -- now we use the qpainter one
• Render onto a framebuffer object so this code can be integrated in Krita Sketch
• Update the image texture tiles in a thread
• Update the projection in a thread
• Restore the colormanagement using OCIO
• Check whether it runs on Windows, OSX (and Android)
• Maybe move the layer composition to OpenGL using the GPUImage shader code?

Especially the testing on Windows is interesting, since the old opengl canvas never worked on Windows.

Hi there, while we've been working very hard on the next Amarok feature release, the 2.8, we also haven't forgot the majority of our users using the stable versions.

Welcome Amarok 2.7.1, a very close relative of 2.7.0 with just a couple of very important bug fixes. The 2.7.1 is also an opportunity for Arch Linux to package it correctly. :-)

Don't fear that we've made just 8 commits since 2.7.0. In fact, we've made over 300 by 25 different people! Look forward for better transcoding, ASX playlist and Opus audio format support, improved MusicBrainz tag guessing and improvements of existing features all over the place for Amarok 2.8.0.

Remember the 4.11 Soft Feature Freeze is in 7 days so try to get your features ready for merging as soon as possible. If you add your features to the Feature Plan you get two weeks more until Hard Feature Freeze. Even if you don't need those two weeks you should add them anyway since it really helps other teams like promo, Q/A, etc. to have the features listed in one place.

I stumbled across an old blog post of mine about using grep with more than one expression: in the old days I used -e several times, one for each new expression. But as stressed in the comments that way is neither convenient nor reliable on ll platforms. And I have developed as well, so today I usually use egrep if I need to grep for several expressions. Thus, here are some short notes about using it.

The multiple arguments you are searching for a passed to egrep separated by pipes. For example, if you want to grep the output of lspci for all audio and video controllers, the correct command is:

$ lspci|egrep -i 'audio|vga'
00:05.0 Audio device: NVIDIA Corporation MCP61 High Definition Audio (rev a2)
00:0d.0 VGA compatible controller: NVIDIA Corporation C61 [GeForce 6150SE nForce 430] (rev a2)

( Yes, I know, I write my blog post on pretty old hardware right now )

egrep does understand more than two expressions, so you can use the option like $STRING_1|$STRING_2|$STRING_3|.... But don’t forget to include the high tics ' in the command: these ensure that the pipe is used as a separator instead of being interpreted by your shell.

Filed under: Linux, Shell, Short Tip, Technology

Dear all digiKam fans and users!

digiKam team is proud to announce the 3.2.0 release of digiKam Software Collection. This version include a new album interface display mode named list-view. Icon view can be switched to a flat item list, where items can be sorted by properties columns as in a simple file manager. Columns can be customized to show file, image, metadata, or digiKam properties.

read more

Yesterday it was reported that Skype, owned by Microsoft these days, seems to automatically follow each exchanged https link. Besides the fact that this is a huge security and personal rights problem in its own it again shows how important it is to not trust a proprietary system.

The problem, skin deep

Heise reported yesterday that Skype follows https links which have been exchanged in chats on a regular basis. First and foremost, this is a privacy issue: it looks like Skype, and thus Microsoft, scans your chat history and acts based on these findings on a regular base. That cannot be explained by “security measures” or anything like it and is not acceptable. My personal data are mine, and Microsoft should not have anything to do with as long as there is no need!

Second, there is the security problem: imagine you are exchanging private links, or even links containing passwords and usernames for direct access (you shouldn’t, but sometimes you have to). Microsoft does follows these links -and therefore gains full access to all data hidden there. Imagine these are sensitive data (private or business), you have no idea what Microsoft is going to do with them.

Third, there is the disturbing part: Microsoft only follows the https links, only the encrypted URLs. If this action would be a security thing, they would surely follow the http links as well. So there must be another explanation – but which one? It is disturbing to know that Microsoft has a motivation to regularly follow links to specifically secured content.

The problem, profound

While these news are shocking, the root problem is not Skype or the behavior of Microsoft – I am pretty sure that their Licence Agreement will cover such actions. And it is most likely that others like WhatsApp, Facebook Chat or whatnot do behave in similar ways. So the actual problem is handing over all your data to a company which you have no inside to. You have no idea what they are doing, you have no control about it, and you cannot even be sure that nothing bad is done with it. Also, most vendors try to lock you in with your service, so that switching away from them is painfully due to used workflows, tools and social networks.

The solution

From my point of view, my personal perfect solution is hosting such sensitive services on my own. However, that cannot be a solution for everyone, and I for myself cannot provide for example the SLAs others need.

Thus I guess the best solution is to be conscious about what you do – and what the consequences are. Try to avoid proprietary solutions where possible. For example for chats, try to use open protocols like XMPP. Google Talk is a good example here: company based, but still using open protocols, they even push the development forward (Jingle, …). Or, if you upload files to web services, make sure you have local backup. Also, try not to upload sensitive data – if you have to, encrypt it beforehand. And if you use social networks, try to not depend on one of them too much, use cross posts for various services at the same time if possible.

And, last but not least: ask your service providers to establish transparency and rules for a responsible and acceptable usage of your data. After all, they depend on the users trust, and if enough users are requesting such changes, they will have to follow.

Filed under: Google, IM/VoIP, Microsoft, Politics, Security, Technology, Thoughts

In case you haven't heard about it, Colibri is an alternative to KDE Plasma notifications.

Colibri notifications are completely passive: when you move the mouse over them, they fade out and let you click the content behind them. They also have the handy ability to concatenate multiple notifications if they come from the same application (think about your friend who likes to press Enter every five words on IM...)

It has been a long time (2 years!) since I last touched Colibri code: mainly because it was working for me, so I spent my time on other projects. With the release of KDE SC 4.10, I noticed a problem though: there was no shadow behind the notification bubbles anymore.

This is fixed in 0.3.0. The nice thing about this fix is I was able to drop code I duplicated from Plasma internals by refactoring Colibri to use Plasma::Dialog. Less duplicated code should result in a more robust implementation, hopefully Colibri should be usable without patching for 2 more years :)

Another change I made was moving the project from Gitorious to git.kde.org, this brings you more translations.

You can get the source code from download.kde.org. Kubuntu 13.04 users can also get it from the Colibri PPA.

Here are the bugs which were fixed in Dolphin for last week’s release:

• Aureliéns efforts to make our hover animation as good as possible were not over yet: one little bug remained after his recent fixes. For details, see git commit c3a7ba4e, review request 109960.
• Bug 316129: When entering a directory, load the icons for the visible icons first, rather than loading all icons in random order. See git commit 52a38ee9, review request 109843.
• Bug 317827: Fix possible crash when filtering items. See git commit 34d0ad72.
• Bug 316285: Fix crash in the accessibility code. See git commit f8bf2577.
• Bug 317772: Disable the non-working Find/Replace actions when renaming inline. See git commit a16562cd.
• Bug 193298: Make sure that the correct free space for the current device is shown when viewing a folder with a name whose beginning coincides with a mount point. See git commit 4f2ecbab, review request 110225.
• Bug 318942: When renaming multiple files, make sure that the “Rename” button is enabled if and only if there is exactly one connected sequence of ‘#’ symbols. See git commit cbb2a4cf, review request 110223.
• Bug 305734: Fix the problem that selected hidden items are hard to see with certain color schemes. See git commit 572513a1, review request 110164.
• Bug 302037: Prevent that the view URL changes unexpectedly when the Terminal Panel is enabled and the current path is a symbolic link to a directory. See git commit 2e123de9, review request 110233.

Thanks for providing patches, helpful analysis and testing proposed fixes: Aurélien Gâteau, David Faure, Emmanuel Pescosta, and Jekyll Wu.