No, not World of Goo.

Go is a wonderful board game. The rules themselves are very simple, but the game itself is fascinating. It’s a bit like Conway’s Game of Life – with a few simple rules you can create something really interesting. However, the similarities pretty much stop there.

A game of Go

Introduction to the game

The equipment consist of black and white stones and a board with a grid (usually 19×19). Playing the game is easy:

• Two players, Black and White, take turns to place a stone on an intersection on the board. First out is Black.
• You can capture stones by “surrounding” them. There’s a nicer way to describe this involving the term liberties, but it’s too lengthy for this post.
• In the end, the player with the largest territory + most captured stones wins.

There are some additional rules, but this is basically how you play.

White's stone is captured by Black

“Piece of cake”, you might think, “but how do you actually play it?” That’s one of the things I found difficult in Go – what are the objectives, and how do you achieve them? As for the first question, a key word is territory. If you look at pros, you’ll see that it’s not about capturing most stones. As you play more, you’ll surely discover many answers.

The second question then? Ikuro Ishigure writes in Elementary Go Series, Volume 1: “When black puts his first stone onto the empty go board, he has three-hundred sixty-one points among which to choose. Even if symmetry is taken into account, there are fifty-five different possible opening moves”.

As if that isn’t scary enough, let’s look at some more statistics. According to Wikipedia, the number of possible Go games exceeds the number of atoms in the known universe. Needless to say, Go gives the player a lot of freedom.

Now don’t be discouraged. Go is a very interesting game, and there are many online guides to get you started. I think this one teaches Go in a fun way (requires Java):

The Interactive Way To Go

Here’s a video tutorial. I haven’t watched it myself, but videos are usually nice to get a basic understanding of something.

Some more useful links are listed on this page.

My experience

I’ve know the rules of Go for a very long time – similar to how most western people know the rules of Chess. And similarly, I didn’t know how to actually play it well.

I still don’t. But I’m confident that I’m a stronger player than I was one year ago. And I’m sure that there’s a lot of room for improvement.

The reason I became more interested in Go was an anime called Hikaru no Go (recommended if you like anime). I read some guides on the Internet, but soon other things demanded my attention and the Go board¹ started to collect dust again.

About one year ago, I stumbled upon KGS and decided to give it a try. Playing people online was much more fun than the Go programs I had tried. A yotta more fun. I’ve learned a lot from playing persons from all around the world. There’s a handicap system in Go, so playing stronger player is not futile; actually quite the contrary, since some kind people don’t mind to spend some time and review the game afterwards.

Now I’m become hooked again. I even bought some Go books, currently reading the Elementary Go Series when I find the time and play on KGS. I wish I had more people in Real Life to play against – maybe I should visit the local Go club, or make more friends discover the beauty of Go.

… [it is] something unearthly… If there are sentient beings on other planets, then they play Go.
- Emuanel Lasker

¹ To be honest, I didn’t even own a board at that time. If you’re a mathematician, you can call it an iGo board if it makes you feel more comfortable. /me hides

Lately my blog posts have all been about KDE, a Free software project that I’m interested in. However, since this is also a personal blog, I’ve decided to write a bit more about myself. Therefore I’ve added a category called Interests, where I’ll write about my hobbies and interests.

I’ve always had a lot of hobbies. When I was a child, I usually had one or two activities every weekday (except on Sundays). Many were dropped due to lack of time, but I’ve also picked up a few new interests. I think I’m pretty open to new things, as long as they look fun or seem useful.

Regardless of how much I enjoy a hobby, it’ll only be just that – a hobby. I don’t plan to take either to a professional level.

Still, I want to work with something I’m interested in. The scientific world seems to be perfect – a place with constant new challenges, a place where you’re relatively independent and learn new things every day. Of course it won’t be perfect all the time. specially not in the beginning I would guess. But it’s hopefully interesting enough to give me something to blog about besides the usual KDE-related stuff.

Note: This isn’t directly related to KDE. However, since there isn’t such a tool for KDE at the moment, I figured some KDE users might find it interesting as well.

I recently bought a new mouse for my desktop computer, more specifically a Logitech Corded Mouse M500. Up until then I had been using an old mouse with two buttons and a scroll wheel. Now I suddenly have two extra mouse buttons, and a scroll wheel that you can tilt to the left and right. Let’s see how to take advantage of this.

The freewheel scroll feature is pretty nice as well

Bind keys with xbindkeys

As the name suggests, xbindkeys is a small program that lets you bind hotkeys to actions under X. Although it doesn’t include a GUI, it’s very easy to use. There is a graphical configuration tool called xbindkeys-config (GTK frontend), but in this guide I’ll edit the config file directly.

1. First of all you need to install xbindkeys, preferably through your package manager.
2. You can create a default configuration file with the command
   

   xbindkeys --defaults > $HOME/.xbindkeysrc

3. Open ~/.xbindkeysrc in your your favorite text editor. (If you can’t find it, make sure you have “Show hidden files” enabled).
   [This guide aims to be quite comprehensive - if you don't want to read everything, you can look at the default configuration file and try to figure out the rest yourself. It's not difficult if you read the included comments]
4. Let’s check the syntax. Everything after # are comments, which means that the program will ignore them.
   You can find the following text in the default file:

   # The format of a command line is:
   #    "command to start"
   #       associated key

   Below are also some examples – great. It’s probably a good idea to include a short comment (start the line with #) before each command, for example

   # short comment
       "command to start"
          associated key

5. "command to start" is simply a shell command (that you can run from a terminal). I’ll talk more about it under Actions.
6. associated key is the hotkey. Let’s take a closer look at how to find what we should write here. But before that, don’t forget the last step.
7. Start xbindkeys by running the command in a terminal.

Keyboard shortcuts

This section deals with keyboard shortcuts. If you’re only interested in mouse shortcuts, please see the next section Mouse shortcuts.

The first example in the generated .xbindkeysrc shows how you can define a hotkey:

 control+shift + q

A list of modifiers is included in the comments.

# List of modifier:
#   Release, Control, Shift, Mod1 (Alt), Mod2 (NumLock),
#   Mod3 (CapsLock), Mod4, Mod5 (Scroll).
#
# The release modifier is not a standard X modifier, but you can
# use it if you want to catch release events instead of press events
#
# By defaults, xbindkeys does not pay attention with the modifiers
# NumLock, CapsLock and ScrollLock.

Pretty straightforward, don’t you think? You can also use raw keycodes, as shown in the next example:

c:41 + m:0x4

Now this might look cryptic, but it’s really no problem – you can easily find the keycodes with the --key option. Run

xbindkeys -k

in a terminal and a window pops up. Press the desired hotkey and you should get an output similar to this:

Press combination of keys or/and click under the window.
You can use one of the two lines after "NoCommand"
in $HOME/.xbindkeysrc to bind a key.
"(Scheme function)"
 m:0x15 + c:34
 Control+Shift+Mod2 + q

In this case I pressed Ctrl+Shift+Q. Mod2 corresponds to Numlock which is ignored by default, as explained in the earlier text about modifiers. Apparently the  keycodes for this hotkey are m:0x15 + c:34.

Mouse shortcuts

Now that we know how to deal with keyboard hotkeys, mouse shortcuts should be a piece of cake. The first mouse button (left) is called b:1, the second (right) b:2 and so forth. Take a look at the third example and you’ll see how a mouse shortcut can be defined:

control + b:2

That’s right, you can combine mouse and keyboard shortcuts – great for those who don’t have a fancy mouse with extra buttons. I used to bind Super+ mouse buttons to various actions with my old mouse (Super is the Windows key on most keyboards).

To find out what a mouse button is called, you can use xev. Similar to xbindkeys -k that you used earlier, it pops up a window. However, this one isn’t closed automatically, and it also grabs mouse movement and clicks. Try to click/scroll in the window (without too much mouse movement), and you should see something like

ButtonPress event, serial 31, synthetic NO, window 0x3a00001,
 root 0x189, subw 0x0, time 55432271, (4,0), root:(1102,842),
 state 0x10, button 9, same_screen YES

in the terminal output. According to the last line, I just pressed mouse button 9, which translates to b:9 in .xbindkeysrc.

Actions

command to start is a command that you can run from a terminal, for example an application (dolphin) or a shell script (out of scope for this article).

Let’s take a concrete example. I want to bind wheel tilt -> switch to previous/next desktop. To do this I have to communicate with KWin, the default KDE window manager. KDE applications use D-Bus to communicate with each other, and you can “talk” to them with D-Bus as well with. (This is for KDE4, in the KDE3 series DCOP is used instead).

I’m not very familiar with D-Bus myself, but with the help of the qdbusviewer tool and some Googling I found that I can use the following command to switch desktop:

qdbus org.kde.kwin /KWin org.kde.KWin.nextDesktop

Find the D-Bus call with qdbusviewer

According to xev (explained in Mouse shortcuts) the tilt to the left and right corresponds to b:6 and  b:7. Therefore, a part of my .xbindkeysrc looks like this:

# Previous desktop
"qdbus org.kde.kwin /KWin org.kde.KWin.previousDesktop"
  b:6

# Next desktop
"qdbus org.kde.kwin /KWin org.kde.KWin.nextDesktop"
  b:7

Don’t forget the quotation marks ("") around the commands!

Emulate key presses

Now I want to map the two other mouse buttons to the KWin effects “Present Windows” and “Desktop Grid”. I couldn’t find any D-Bus calls for this, so let’s try to achieve it in another way. The effects are already mapped to some keyboard shortcuts – maybe we can find a command to “emulate” these key presses?

The tool for doing this is called xte, and is included in the xautomation package. Again, install it with your package manager.

The default shortcut for “Show Desktop Grid” is Ctrl+F8. The following command should then activate the effect:

xte 'keydown Control_L' 'key F8' 'keyup Control_L'

Whether we choose Control_L or Control_R doesn’t really matter. After confirming that it works, I added the following lines to .xbindkeysrc:

# Present Windows
"xte 'keydown Control_L' 'key F10' 'keyup Control_L'"
  b:8

# Desktop Grid
"xte 'keydown Control_L' 'key F8' 'Control Super_L'"
  b:9

If nothing happens for you, make sure you emulate the right key presses. Have you changed any shortcuts?

xte --help displays some helpful text that you might find useful.

Apply settings and make xbindkeys autostart

Now we’re almost done! Remember that you have to restart xbindkeys to apply the changes:

killall xbindkeys && xbindkeys

As a final touch, let’s make xbindkeys autostart with KDE. It’s very easy to do with the new Autostart module.

1. Open System Settings.
2. Go to Advanced tab -> Autostart.
3. Click on “Add Program…”.
4. Write xbindkeys and press OK. A new dialog pops up. Press OK again.
5. Done!

Make xbindkeys autostart

Closing words

In this tutorial we’ve learned how to use the xbindkeys program to bind keyboard and mouse shortcuts to different commands. We also took a quick look at how to communicate with an application using qdbus and emulate key presses with xte. Finally, we made xbindkeys autostart.

I think it would be great if the “Input Actions” module in System Settings also supported mouse shortcuts. A more simple module for assigning mouse buttons to actions would be nice as well.

Hope that you found this guide helpful, don’t hesitate to leave a comment below if there’s anything on your mind.

Good news ahead for all the people who don’t like forums in general, but still want to know what’s going on.

The Feed option has been available for a while and makes it possible to create personalized newsfeeds to follow specific forums and subforums. That’s nice, but sometimes it’s not enough.

If you follow Planet KDE you might have heard about the recent improvements on forum.kde.org, including the better search system. It’s faster, it allows you to search for common words (such as ‘kde’) and it offers more options to give more accurate results. However, that’s not all. Now it’s also possible to display the results as a newsfeed, which means that you can make highly customized feeds with posts that you’re interested in.

Below I’ll show you have to make such a feed with an example. If you want to play around with it yourself,  head to Search.

Update October 10, 2009: Feed has been removed. You can use Search to archive the same thing.

Creating a customized feed

In this example we want a newsfeed for new ideas in Brainstorm that are tagged ‘plasma’. An idea is simply a topic in the Brainstorm forum, and using the tag system we can find Plasma-related ideas that don’t necessary have the word ‘plasma’ in their title or description.

1. Go to the Search page.
2. Search Query
   Enter plasma in the tags textbox. You can enter multiple tags if you want, just remember to separate them with commas (tag1,tag2,tag3).
3. Search Options
   Select KDE Brainstorm in the list. You can select multiple forums by dragging, or clicking on the items while holding down Ctrl. We don’t want to search in subforums, so choose No for Search subforums.
   To only search for ideas (and not their comments), we choose First post of topics only in Search within. This may seem strange, but don’t worry – this will hopefully be fixed in a not too distant future.
4. Display Options
   In this example we don’t need to change any settings in this section. For now only Sort results by and Limit results to previous work for feeds.
5. RSS Options
   Finally! Choose the feed format you prefer (for example RSS 2.0) and a Style (HTML is fine if you’re unsure). You’re finished with the search options – hit the Search button.
6. Add feed to your feed reader
   Now you just have to copy the URL and use it to create a new feed in your feed reader (for example Akregator).

Adding a feed to your feed reader

Your feed reader will handle the rest, and you can stay up-to-date without visiting the forums.

By now, you should have a fairly clear idea of how to make your own custom newsfeed using the new search features. There are more plans to bring the KDE Community Forums closer to the desktop – hope you like it!

Do you remember this guy? In my previous blog post I asked the KDE community what you thought it was, and after many good guesses Kmetamorphosis finally nailed the answer: it’s for voting on questions in KDialogue.

Another person commented that “if it looks like a spinbox, it acts like a spinbox then probably it’s a spinbox. Only it doesn’t apear to be spinning”. Right, I guess we can call it a spinbox. If you’re the type who likes to spin spinboxes, I have good news for you – the first KDialogue opened recently, which means that you can spin to your heart’s content¹ over in the KDialogue forum!

Don’t forget to take the opportunity to ask Jonathan Riddell one question or four – the more spinboxes, the better right? As someone said, there are no stupid questions (as long as they follow the rules) – only good ones and less good ones. And that decision is in your hands.

Take me to the first KDialogue now »

¹ You can only vote on each question once, though.

Let’s see if you’ve done your homework lately – can you guess what this is?

Hint: it has something to do with the KDE Community Forums.

(If you’re a regular visitor to the forum channel, #kde-forum on freenode, you’re not allowed to answer. )

The end of summer

Whew, long time no see! After the summer vacation I’ve had my hands full, so I never found the motivation to sit down and write this. Sorry about the delay.

This step marks the end of summer and will show you what I’ve achieved in these two months. But first something about Qt.

The start of Qt programming

To start off, I need to say this:

Qt is easy.

When I was a child, I made some GUI applications in Visual Basic. It was very easy to get started with – you place some widgets on a form, double click on one (e.g. a pushbutton) and write some code to be run (e.g. when the pushbutton is pressed). Simple.

Even with my limited knowledge of Visual Basic, I could do pretty much. The code was usually awful – I preferred to store values in (invisible) textboxes instead of using variables, just to mention one thing – but they actually worked.

Now, I would argue that Qt is harder to get started with, probably because it uses C++ (yes I know that Qt has a lot of bindings for other languages). It’s easy to lay out widgets in Qt Designer, but it’s far from obvious what to do afterwards. The workflow is probably clearer if you use Qt Creator, but I haven’t tried it yet.

To my aid I had my books, and I soon found that I was able to do a lot in Qt that I didn’t know how to implement in Visual Basic. The Qt layout system makes it easy to lay out widgets and takes care of the position and size of widgets when you resize the window. To make an application with menubar and toolbars, you derive from QMainWindow and add a few objects and functions.

Derive. That’s something you’ll do a lot in Qt. An excellent example of object-oriented programming.

If you want an object A that have the same properties (talking about general properties, not Qt specific) as object B, but further specialized, you can derive A from B. For example, I want a cat that can play Go. Most cats can’t do that, right? A normal Cat is not enough. But I don’t need to create a new Cat from scratch, I can make the new class inherit from Cat (i.e., it is derived from Cat):

class  GoCat : public Cat
{
    Q_OBJECT

public:
    GoCat(QWidget *parent = 0);

private slots:
    void playGo();
};

This is just standard C++. Q_OBJECT is included because we want to make use of Qt’s meta-object system, including signals and slots (read more here).

In a similar fashion, we can build GUI applications by using the classes Qt provides. A Main Window with menubar, toolbar and system tray? No problem, QMainWindow takes care of it. If we want to make a custom widget that consist of two Qt widgets, for example a QSlider that’s connected to QLCDNumber like in this tutorial, we simply derive from QWidget.

MyWidget(QWidget *parent = 0); is a typical constructor declaration for derived classes. We then pass the parent pointer to the base class (the one we derive from) in the constructor:

MyWidget::MyWidget(QWidget *parent)
     : QWidget(parent)
[...]

In this example  (taken from tutorial) MyWidget is derived from QWidget, as you can see.

(Qt’s parent-child mechanism is out of scope for this article. I touched upon the subject in step 2, when I wrote about pointers in Qt).

Result

As promised I’ll show you the two Main Windows (derived from QMainWindow, of course) that I’ve done by following my two Qt books.

In The Book of Qt 4: The Art of Building Qt Applications you create a simple text editor in chapter 4. The GUI is done in Qt Designer and the final application looks like this:

CuteEditor

I liked this application. It’s simple – most of the functionality is already in QTextEdit. You need to setup the actions in the toolbar and menubar and implement a few functions functions, such as loading and saving files. Oh, and don’t forget the status bar. That’s pretty much it.

This chapter gave me a good understanding of how to create similar small applications. However, I found the part about the dock window (“Templates” in screenshot) somewhat vague and incomplete. The code wouldn’t compile for me at first – I need to look into it and see if it’s a mistake from my part.

The application in C++ GUI Programming with Qt 4 is more complex. You build a spreadsheet, completely from a text editor (chapter 3 and 4). Well, for most parts at least.

Spreadsheet

The reason I said “for most parts” is because you create some of the dialogs in Qt Designer in an earlier chapter. It’s very nice that you get to reuse them to create your Spreadsheet application and learn how dialogs work. Completing the application was also a big motivation booster – “woah, I could actually make this application”.

That’s unfortunately also the bad thing about this example – to me, it was a bit too complex and it was easy to get lost in details. Yet it’s listed under “Basic Qt”, which I find somewhat amusing.

Another thing I didn’t like was that I couldn’t compile it until I was finished. I prefer to take it in smaller steps, to be able to see what I’ve accomplished after a while. In hindsight, I should have copied example files from chapter 4 (included on CD) to test the application.

Overall I get the feeling that C++ GUI Programming with Qt 4 assumes the reader has more prior knowledge in C++ than The Book of Qt 4: The Art of Building Qt Applications. In my opinion Daniel Molkentin, the author of the latter book, gives a more expanded explanation on some topics, such as memory management (stack vs heap) and how to use Ui files created in Qt Designer. On the other hand, I also appreciate the insight Jasmin Blanchette and Mark Summerfield (authors of C++ GUI Programming with Qt 4) provides and their elegant code.

To summarize, I don’t regret getting both books – so far, I think they work pretty well as complements.

Johan Thelin has been kind enough to send me a review copy of his book, Foundations of Qt Development - thanks Johan! It’s still at my parents’ place but I’ll pick it up the next time I visit them. I’m looking forward to seeing what this book has to offer.

Final words

Everything above (mainly referring to “The start of Qt programming”) is my interpretation. If you find any errors in the text, please don’t hesitate to correct me.

Next time I’ll show you the applications I recently started working on. Simple small applications, very similar to the ones I showed above (but rewritten from scratch). I do, however, have plans to eventually turn one into a plasmoid later.

My lectures have started again, so I’ll have even less time to learn about KDE Development. That also means less frequent steps, which in unfortunate. I’ll try to keep you updated as often as my time (and motivation) allows.

Since a few people have asked me how I recorded the Plasma HowTo screencasts, I decided to post a short HowTo here. And is there any better way to show this than with an animated GIF? I can almost hear you saying “of course not!”, so here we are:

A typical record session

I use byzanz to record my desktop. It works as a GNOME panel applet but can also be used from the command line. Note that it depends on quite a lot of GNOME libraries and requires Composite to work (according to the website).

[Update October 19, 2009: I tried to remove most of the GNOME libs and byzanz still seems to run fine.]

Now back to the screencast above. I usually do the following steps:

1. Open a terminal to run the command. My terminal emulator of choice is yakuake, because it’s very easy to hide and unhide.
2. I use the following command:
   

   byzanz-record --loop --cursor --delay=delay --duration=duration filename


   where delay is the time before it starts recording, duration the duration of the animation and filename the name of the output file. --loop specifies that the animation will loop and --cursor makes sure that it also captures the mouse cursor. As an example, the command in the screencast is

   byzanz-record --loop --delay=3 --duration=8 -c plasma_howto-throw-ball


   (Don’t ask me why I use -c instead of --cursor; I don’t know myself). Enter byzanz-record --help to see all options.

3. I have a timer beside me which I start when I execute the command. After 4 seconds (3 seconds of delay + 1 second when the mouse cursor is idle) I start to do whatever I want recorded.
4. When the recording is done, I preview the file in Firefox to see if it looks good. I’m pretty strict – a small mistake and I redo the recording. For example, the ball screencast I did in the screencast is on the borderline – I accidentally move the mouse cursor one or two pixels after I’m done.

Tips

Finally here are some tips and tricks:

• I created a new user to do the recording. This has several benefits, one being that you can nuke the Plasma config files without hesitation to restore the settings to default. The command to do this is
  

  kquitapp plasma-desktop; rm $KDEHOME/share/config/plasma-desktop-appletsrc; plasma-desktop


  If the $KDEHOME environment variable isn’t set, try to replace it with ~/.kde4 or ~/.kde.

• Disable Nepomuk/Strigi and other stuff that might pop up.
• For me it didn’t work very well to record the screencast with Desktop Effects enabled. You can disable it temporary in System Settings -> Desktop Effects -> Suspend Compositing.
• Configure the task manager to only show tasks from the current desktop. As you can see in my screencast, I keep a Dolphin and a Firefox window opened on my other virtual desktop to quickly preview the results.
• Gwenview also works for viewing the GIF files. However, note that it’ll loop the animation even if they’re recorded without the --loop option. I warn you because I learned this the hard way.
• Most people probably know this, but to run the same command again you just have to press the up arrow (on your keyboard) to go back in history in the terminal – no need to copy and paste the command over and over again. Just make sure that you don’t overwrite a screencast you’re satisfied with! (Yep, it happened to me).
• As you might have noted, my filename (plasma_howto-throw-ball) doesn’t have the .gif extension. There’s actually a reason for this – to avoid overwriting good screencasts, I add the extension when I’m happy with the screencast. Then it doesn’t matter if I accidentally run the same command again without changing the output file name.
• How to find out the duration beforehand? Unfortunately I don’t have any good tips regarding this – I did it the troublesome way and timed it before recording. After doing a few screencasts I had a pretty good feeling of how long it would take.
  If the duration is too long you should be able to remove the last frames, although you have to figure it out yourself – I would just redo the screencast.

You might have seen my previous posts about Plasma HowTos in form of short screencasts. I’m happy to announce that all screencasts are recorded now and uploaded to UserBase. The full article can be found under Plasma/FAQ/HowTo.

If you don’t know what this is all about, here’s a small taste:

How to unlock your widgets

Obviously you can watch the HowTos to learn more about Plasma, but that’s not all: they can also be used to easily answer beginners’ questions in an easy-to-understand and nice-looking way. In forums, for example, you can use the same thumbnail as the one above to link to a HowTo.

Now, let’s spread the screencasts and make Plasma more comprehensible to new users!

Due to the positive feedback I received in my last post, I decided to take the experiment one step further. A page that listed all Plasma HOWTO screencasts – doesn’t that sound good?

My initial idea was to do it on my blog and eventually move it to UserBase if it was well received by the community. However, some people on IRC already voiced interest for such an article on the wiki, so here it is:

Plasma/HOWTO

Currently it’s on my own page, but the plan is to move it to Plasma/HOWTO when more screencasts have been done. As you can see, I’ve only done the first section (Widgets).

Dear KDE community, now I need your help. Are the sections strange? Do you miss a HOWTO? Should something be rearranged? Please help to improve the article! It’s a wiki, so feel free to edit it. However, if it’s something major, I would appreciate if you wrote a note under Discussion first.

Thanks everyone who commented my last post, you motivated me to continue this experiment.