The original Lancelot icon is usually considered weird-looking when seen on a panel (or desktop). Even I have had Lancelot set up not to use it.

I like the old icon very much, and I’m still proud I succeed in making something like that with a vector-graphics program (Inkscape) so it still is, and will be until the end of time, the main icon of the Lancelot project. But from now on, it will not be used for the applet button.

Now, the default icon is the standard KDE icon – the same one other launchers use.

For those of you who want to have a normal-looking icon but still want others to see that you are using Lancelot and not something else, you can use the following one:

The new icon can be set through the applet configuration dialogue.

I have been really lazy to write anything here for quite some time now. I enjoyed the simple life away from the blogocube (it’s actually a dodecahedron, but blogododecahedron is a mouthful) but now I’m back.

I’ve realized that I’ve made more commits to Kickoff since Tokamak 3 (mostly related to krunner integration) than to Lancelot, which is just plain wrong. So, I decided to change that and do something I was planning for quite some time now – a huge refactoring.

Puck

The first thing I noticed is that the Puck (Plasma UI compiler used in Lancelot) modules are rather outdated and reflect Lancelot widgets from the old liblancelot and not the new liblancelot2 so it got updated. It was rather cool to see that despite that, Puck still worked and didn’t break the build.

Puck will eventually (read: when Qt Declarative UI becomes stable and Plasma-integrated) be abandoned and left to rust, but ATM it seems a not so near future.

libLancelot and libLancelot-datamodels

The next step was the /fork/ from the title. The data models (aka every item list you see in Lancelot) are moved into a separate library called liblancelot-datamodels. Both libraries (liblancelot and liblancelot-datamodels) now reside in kdeplasma-addons/libs so that they can be used by any other plasmoid (or any other program for that matter).

This is a way of saying “liblancelot is now considered stable enough to be used even outside of Lancelot”.

It wasn’t only a simple move from one place in SVN to another – both libs received some beautifying, fixing, got pretty meta-includes just like all KDE libs have, so you can now do a #include <Lancelot/ExtenderButton> instead of writing the full path of the header file…

…

Ok, I got bored writing, so this is all for this post now, expect a couple more soon – there are two top-secret projects that need revealing. Cheerio!

For quite some time now (seems like forever) I’ve used a bit modified scripts from Techbase: Increased Productivity in KDE4 with Scripts to build KDE.

I don’t know why, but I’ve never even tried kdesvn-build script, so the things I’ll write here are maybe (probably) already present in it.

So, if you don’t use kdesvn-build, and have your system set up like it is explained in the above link, keep reading.

Important: I’m using ZSH, so the scripts here maybe need changing in order to be usable in BASH.

Environment

First of all, we need to add some global, environment variables. You should put this in the script for setting KDE4 variables (for example in .my-setup)

The first variable will be used by the build logging system. You should define it near the definitions of KDE_SRC and KDE_BUILD variables.


# build and src folders
# you might want to change these!
export KDE_BUILD=$KDE4ROOT/build
export KDE_SRC=$KDE4ROOT/src
export KDE_LOG=$KDE4ROOT/log


After this, we are making a variable that holds all the dirs to be included in the automatic build system.

# all build dirs
KDE_BUILD_DIRS=""

pushd $KDE_SRC > /dev/null
	for dir in                  \
		KDE/support         \
		KDE/libs            \
		KDE/pimlibs         \
		KDE/base            \
		KDE/plasmoids       \
		KDE/pim             \
		KDE/accessibility   \
		KDE/artwork         \
		KDE/bindings        \
		KDE/graphics        \
		KDE/multimedia      \
		KDE/network         \
		KDE/sdk             \
		KDE/utils           \
                                    \
		extragear/*         \
		other/*             \
		playground/*        \
	;
	do
		KDE_BUILD_DIRS="$KDE_BUILD_DIRS $dir";
	done

popd > /dev/null

export KDE_BUILD_DIRS

SVN/GIT Updates

Now, we can create two very easy functions for fetching the updates:

function updatesource {
    if [ -n "$1" ]; then
        cd $1;
    fi
    if [ -d .svn ]; then echo "Updating directory: $PWD (svn)"; svn up; fi
    if [ -d .git ]; then echo "Updating directory: $PWD (git)"; git pull; fi
}

function kdeup {
	# clearing update logs
	rm -fr $KDE_LOG/update.log
	rm -fr $KDE_LOG/*.update

	cd $KDE_SRC
	for dir in `echo $KDE_BUILD_DIRS`; do
		updatesource $KDE_SRC/$dir || echo "$dir (see $log_file) update failed" >> $KDE_LOG/update.log
	done
}

Notice that it reports errors in $KDE_LOG/update.log file.

Building

Now we define kdemake command which will build all the directories we specified in $KDE_BUILD_DIRS. Like kdeup, it logs the process. The main log is $KDE_LOG/build.log and each built directory has its own build log (the output of cmake + make).

function kdemake {
	# clearing all logs
	rm -fr $KDE_LOG/build.log
	rm -fr $KDE_LOG/*.build

	cd $KDE_SRC
	for dir in `echo $KDE_BUILD_DIRS`; do
		cd $KDE_SRC/$dir;
		echo "Building $dir";

		log_file=`echo $dir | sed 's/\//_/g'`;
		log_file="$KDE_LOG/$log_file.build";
		echo "Building $dir > $log_file" > $log_file;

		echo "Building $dir" >> $KDE_LOG/build.log
		( ( cmakekde || echo "FAILED: see $log_file" >> $KDE_LOG/build.log ) 2> /dev/stdout | tee -a $log_file )
	done
}

Debug builds

Sometimes you want to have a certain module build with debugging symbols – just replace the default cmakekde function with this one. It checks for the .debug file and if it exists, it builds that module with dbg symbols included.

function cmakekde {
	if test -n "$1"; then
		# srcFolder is defined via command line argument
		srcFolder="$1"
	else
		# get srcFolder for current dir
		srcFolder=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`
	fi
	# we are in the src folder, change to build directory
	# Alternatively, we could just use makeobj in the commands below...
	current=`pwd`
	if [ "$srcFolder" = "$current" ]; then
		cb
	fi
	# to enable tests, add -DKDE4_BUILD_TESTS=TRUE to the next line.
	# you can also change "debugfull" to "debug" to save disk space.
        # added "nice make..." to allow the user to work on the box while
        # compiling
        # Note: To speed up compiling, change 'make -j2' to 'make -jx',
        #   where x is your number of processors +1

	if test -e ".debug"; then
		echo "debug yes" && \
		cmake "$srcFolder" -GKDevelop3 -DCMAKE_INSTALL_PREFIX=$KDEDIR \
			-DCMAKE_BUILD_TYPE=debugfull \
			&& nice make -j3 && make install
	elif test -e ".debug-release"; then
		echo "debug yes [release-debug]" && \
		cmake "$srcFolder" -GKDevelop3 -DCMAKE_INSTALL_PREFIX=$KDEDIR \
			-DCMAKE_BUILD_TYPE=RelWithDebInfo \
			&& nice make -j3 && make install
	else
		echo "debug no" && \
		cmake "$srcFolder" -GKDevelop3 -DCMAKE_INSTALL_PREFIX=$KDEDIR \
			-DCMAKE_BUILD_TYPE=release \
			&& nice make -j3 && make install
	fi
}

Checking logs

So, updating KDE is now a matter of calling kdeup and kdemake. The next thing to do is to create a watching mechanism (to put it in the command watch plasmoid for example).

The first script is outputting what is currently being built – something like this:

/opt/kde4trunk/log/KDE_support.build : [ 49%] Built target phonon

The code for this bash script is:

#!/bin/bash
WHATFILE=`ls -t1 /opt/kde4trunk/log/*.build | head -n 1`
WHAT=`grep '%' $WHATFILE | tail -n 1`
echo $WHATFILE ":" $WHAT

That’s all for today.

Just as a note, since Air is now the default theme for Plasma (and what’s worse, it is even called “default” instead of “air”), you’ll see that the Lancelot themes in 4.3 RC are screwed up. Unfortunately, I wasn’t able to fix this before 4.3 RC tagging today (I was too late to discover the issue in the first place).

It is fixed both in the trunk and in the 4.3 branch, but, as I said, not on the time. So, just that you know, it is already fixed and all will be well in final 4.3.

You have heard many times that Lancelot was a superkaramba applet in the beginning, and that later I screwed it up by turning it into a menu.

In this video, which is demonstrating the developments of the /Plasma Applet Browser/ in the era of pre KDE 4.0, sometime in the middle of it, you can see the first version of Lancelot for Plasma which was generally the crude port of the SK one.

Absolutely no connection to the present one

There are a couple more feature requests marked as FINISHED in Lancelot‘s TODO file.

1. Wasted space

In previous versions of Lancelot, when using the no-click activation, there was some space between the lists while browsing the applications. The space was needed because of extenders and scroll-bars. Scroll-bars, obviously, still need the space like before, but the extenders don’t.

The initial proposal was to make the extender inside the list item itself, so it would be an /intender/, and not extender. This wasn’t that great idea since that would induce a lot of accidental activations – you hover the end of an item, the /intender/ pops right below the cursor, and since it is hovered, it activates.

The alternative was to allow the extenders to go outside the list, and that is exactly what is going on now. The extenders now can overlap the space of the neighbouring list. So, in a nutshell, the extenders from one list, and the scroll-bar of another are sharing the same space.

2. More than breadcrumbs

The second requested feature that was implemented today was to show the trail in the application browser, not only in the breadcrumb bar, but also in the lists. This worked before when using keyboard for navigation through the application browser (aka PassagewayView), but not when using the mouse. It now works for mouse too.

3. Why do I search for empty strings?

This one is the smallest change for today – instead of showing you the message ‘Search query is empty’, Lancelot returns to the Applications section.

UPDATE: I was too lazy to create another post… and not enough news for one.

4. I want to hide my tracks!

It is now possible to right-click and item in Recent Documents, and remove it, as well as to clear the whole document history.

5. Race the Dolphin through the hoops

There were a few requests to make Lancelot use Dolphin’s places. I thought it will be tricky to do that since L separates devices from places, but fortunately it was not the case. Dolphin stores the places information in a XBEL formated file (bookmarks format) and provides a nice distinction between the devices and places. Note that the places are not automatically reloaded. I could do that easily, but IMHO reserving an iNotify slot for just that would be a waste.

This also means that there is now a XBEL-based model for Lancelot. It doesn’t support bookmark folders, but it will eventually.

Breathe, breathe in the air
Don’t be afraid to care

The KDE 4.2 has been released today. Although in the image below, and in this post’s title it says “Breathe”, the official code name is “The Answer” since it is the Answer to Life, the Universe, and Everything [link]

The release announcement can be found here, but for more information you should head straight to the visual guide which was nicely prepared for all of us by the KDE Promo team.

Introducing Lancelot

It is a peculiar feeling, although most of you who read my blog know what Lancelot is, and possibly using it already, KDE 4.2 is the first version that ships it. So, it is like Lancelot didn’t exist before, it is a new KDE application. Therefore, I’ll post here a small introduction of what it is.

Lancelot is an application launcher menu (or ALI) for KDE 4 designed to provide a place from which all your jobs begin. It provides quick access to applications, places, documents, contacts and system information.

For detailed info and documentation, visit the website.

For those of you who know what Lancelot is, here are the improvements since the 1.0 version:

• Full keyboard support
• New lists with scrollbars
• Themes that match Plasma themes from kdeplasma-addons kdeartwork module
• Even less bugs

KRunner integration

The most elusive feature in Lancelot is its KRunner integration. There are two reasons for that, the other menus (I speak mostly of Kickoff, as it is the default menu) tend to search only through the applications they navigate. The second reason is that the users are so accustomed to Alt+F2 to start commands, that they can’t be bothered to try something new.

As you probably know, KRunner now comes with two different interfaces which you can set in its configuration dialogue. Lancelot is the third. It integrates the menu and the usual application (and whatnot) browsing with the power of the /Run/ dialogue. Everything that you can do with the default KRunner interface, you can with Lancelot also (yes, the calculator also works ).

It is not my intention to say that you should ditch KRunner, it is an awesome application, but if you are really accustomed to L’s interface, you don’t need to use two different applications for basically the same task – starting applications. Before KDE 4.2, this was a bit tricky since you had to click on the search result in order to start it, but now, you can just press “Enter” to start the first match, or you could navigate with your arrow keys. The keyboard is a wonder, I say!

Dot

One of the great things that followed 4.2 is the new Dot (dot.kde.org). It looks fantastic! (I’m even thinking of changing the theme of my blog to something like the new dot interface).

In the other news, there were a couple of KDE bashing news lately which I really don’t care for. So, here’s just one quote for them (when I say “them”, I don’t think of poor Linus who doesn’t enjoy the bliss of KDE anymore, but of all others who made it a big deal, and started flames all over the net):

The mind of a bigot is like the pupil of the eye. The more light you shine on it, the more it will contract.
~ Oliver Wendell Holmes Jr.

So, I read the Drive-by Mockups post by Nikolaj Hald Nielsen which is about the new amarok mockups that can be found at kde-look. So, I found out that some people consider the [Amarok] developers to be “quite strange” and stubborn.

One of the reasons for justifying the claim was that the sentence Nikolaj wrote “The truth is that we are aiming squarely at ourselves, as we are some of the biggest music fans out there…” was found to be “extremely arrogant” by one of the visitors.

It reminded me of when I said something similar on my blog – that I develop Lancelot for myself. And I am aware that this type of comment sounds strange, and a bit arrogant, but it is not. So, I’m passing what I wrote as a reply on Nikolaj’s blog here:

I’m sorry if I was the one who started the ‘I develop for myself’ wave of responses (some time ago concerning Lancelot) but you have to understand the developers to understand what that means.

What would you feel if someone, without specifying any specific reason, starts bashing something you have been dedicated to for a couple of years? You could ignore it. You could ignore it a couple or more times. But, eventually, you will have to snap and vent yourself through a reply.

So, be happy, be polite and with a smile in your heart and on your face, and the world will be a much nicer place to live in. (yes, that’s an order )

Well, the QtCentre Programming Contest 2oo8 is finally over and the winners are announced. OK, we all knew we are winners a month ago, but at that time we were called just finalists

Just to notify you all bug seekers out there not to file bugs against Lancelot in the Beta 1 of KDE 4.2 because most of them were fixed since the Beta 1 was tagged. If filing a new bug, please test whether it exists in the trunk.

… or wait for KDE 4.2 Beta 2 …