Planet Compiz

Dear Phoronix

2010-08-20T02:53:17+00:00

OK, so we have another article about how LLVMpipe and the Copy Mode don’t play along.

A tidbit of information, even though it isn’t particularly made obvious: The enabling the “Copy To Texture” plugin doesn’t make all textures bound with this “copy mode” by default – it is only enabled if the pixmap is larger than the maximum texture size. The plugin isn’t there to fix broken drivers, it is only there to work around texture size limitations.

So in essence, what you are seeing is the same old TFP backend in action there Phoronix

The final piece of the puzzle

2010-08-18T13:52:47+00:00

We’ve had 3D docks like Mac OS X Leopard +, but we haven’t had reflective ones yet.

Because we Kan[tm]

2010-08-13T01:12:18+00:00

KDE 4.5 is released. And what better time to support all of the updated plasma blur hints!

Some weekend hacking.

2010-08-07T20:02:57+00:00

People kept asking me about minimized window thumbnails. I caved.

There’s something else interesting that went into the scaleaddon plugin too, a new layout mode for scale. But it’s 4AM. I’m too tired to blog.

Compile Compiz 0.9.0 in Ubuntu

2010-07-26T04:56:28+00:00

Sam pointed me to thread that had some build directions that he had put there. I’ve had trouble in the past getting Compiz 0.9 to run, usually with gtk-window-decorator not working. Update: This is really easy now because of Soreau’s script.

Download Desktop.tar.gz which has the script with execute permissions and the source directory
Delete ~/Desktop/compiz-0.9.0 if you have it
Extract Desktop.tar.gz on your desktop (right click works) or in a terminal cd ~/Desktop && tar -xf Desktop.tgz
Open a terminal and type ./install_compiz_090.sh
After it builds it can launch CCSM, which worked for me
Run /opt/compiz/bin/compiz++ (I didn’t need pass --replace or anything)
Thank Soreau

Changes I made to the script:

It uses ~/Desktop/compiz-0.9.0 for source code and that directory is in the tar empty
It installs to /opt/compiz instead of /opt/compiz++

There also seems to be a PPA that falkTX has created. I haven’t tried it yet, but looks promising has been reported to not work and can be added by doing this in a terminal:

sudo add-apt-repository ppa:falk-t-j/lucid-latest

Now you’ll either have updated versions of the packages, or renamed compiz packages (haven’t tried it yet)

Update: This got picked up by OMG! Ubuntu

Update: If you followed the guide exactly for the first few hours it was up it didn’t change directory into the build/ directory properly in the install step. Thanks to Eugeny at OMG! Ubuntu! for the tip.

Update: Much of this was replaced with Soreau’s Script, who I welcome as our Compiz overlord.

What’s happening in compizland?

2010-07-24T03:32:57+00:00

Another blog post!

Since the release the core team has been doing a bit of planning for what we want to do in the upcoming 0.9.2 release. A roadmap of “big features” will be coming in the next week or so.

In the meantime I’ve been trying my hand at porting some of the other non-official plugins. Work is going pretty well so far, we now have the following plugins done:

Dodge Windows
Dim Dialog
Simple Animations
Screensaver (ongoing work here too, stay tuned)
Anaglyph (thanks soreau)
Toggle Decoration (thanks soreau)
Freewins
Desktopclick
Mousetrails

There are still a few more unofficial plugins to go until we have 100% feature parity with the 0.8 branch. Among some of the ones I’m working on right now:

Animations Plus
Newton (Physics Engine for Compiz)
Sound (ALSA based sounds on window events)

We’ve also had some bugfixes, particularly to the animation plugin where animations wouldn’t fire for some windows (thanks Jay!)

Otherwise, it looks like we’ll be implementing *small* user requested features in the time being and continuing to fix bugs. It’s all quite fun!

Sam Ported Simple Animations to Compiz 0.9!

2010-07-14T02:41:23+00:00

Sam ported the Simple Animations plug-in to the new version of Compiz (in C++), so I’m checking it out and going to see if anything is in my version that is worth porting. I only slightly modified it to slide entirely off the screen for a minimize animation and took away some blending operation hooks I didn’t want.

Just a small tidbit

2010-07-09T01:28:17+00:00

Seems that a lot of news sites are reporting that Compiz 0.9 includes changes from the NOMAD branch. NOMAD hasn’t yet been merged, although I would like to merge it at some point.

That is all.

In the meantime….

2010-07-07T06:30:22+00:00

I decided to go back to some of my own work, namely the simple-animations and freewins plugins. Simple-Animations was just ported today by yours truly, and now I am addicted to the iPhone-like-ness of some of the animations in there, namely “bounce”, which is probably the best animation ever for tooltips. I haven’t played with freewins in a long time and I look forward to porting it, it is a very simple plugin and should be easy to port. Today I also watched Martin Gräßlin‘s presentation on compositing window managers in mobile devices, operating on top of openGL ES. It looks like there might be an opportunity to work together with KWin to co-ordinate efforts to improve window management for mobile. Perhaps that would be cool to add to our roadmap.

Speaking of which, one should be coming in the next few days, as soon as Kristian Lyngstol gets his new computer. I have some rather big ideas on the horizon.

Linux ePoc headset update

2010-07-06T03:16:43+00:00

I had a short email discussion with the folks from ePoc, making the headset I blogged about a bit ago. Their SDK is available for beta on Linux, so finally I can start the real work – and put their SDK to a test.

This is pretty good timing too because 0.9 is released and packaged, since this is not compatible with the old C code.

The developer headset is $500 while the consumer one is $300.

More soon…

It’s 2AM – where is your release

2010-07-04T09:13:59+00:00

That’s right

Compiz 0.9 and GCC 4.5

2010-06-25T07:24:39+00:00

Hi everyone,

It appears that several uses of git master and distributions with GCC/G++ 4.5, such as openSUSE 11.3 and Arch Linux are experiencing random crashes when loading or unloading plugins. We think(*) this is a bug in GCC/G++ and I am currently drafting a testcase to confirm this and also a workaround for the bug. At the moment, in order to avoid this crash, you will need to use an older version of GCC/G++, such as GCC 4.4.3. For Arch Linux you can get this from the AUR with “yaourt gcc4″, selection 6, and I would imagine a package is available for openSUSE. When compiling, press ‘t’ in ccmake to get advanced options and change the compiler executable paths to your older compiler.

Technical Details of what we think the bug is:
We use a static variable within a template class in order to reference count it, so whenever a new class of some template is instantiated, the reference count increases (since the variable is static and is effectively global, only accessed with the operator of scope (::)). However, when new plugins are opened using ltdl, the constructor for this static variable can be called again, and so the reference count will decrease to zero. This creates a dangerous situation where if any more of those classes go away, then core will think all of them are gone and start removing bits necessary to make those classes work. I shall post a testcase in this bug as soon as it is ready.

Serialization and Packages!

2010-06-12T09:10:43+00:00

So it’s finally post-exams again. No more writing 100′s of pages of notes for me

In development news, I finally pushed out the serialization stuff I was talking about a while ago. Well, a bit of a change from what I was talking about a while ago. “rasterman” of an enlightenment fame gave me the idea to use full-on serialization, and since we already use the wonderful boost libraries, this implementation uses the boost::serialization library to store the state of plugins after they are unloaded and restore them as they load. This means that if you momentarily unload and reload compiz, or unload a plugin, or load a plugin that has to be loaded before others, then you don’t have to go and re-toggle all of your effects, or redraw any fire that you had on the screen

Currently, there is a bug with the serialization library and the linux functions which provide dynamic open/close for plugins. Because of this, it is disabled by default until I can work it out. You can test it out with enabling the “save plugin states on unload” option in core.

Packages!

During these few weeks our packagers have been hard at work creating compiz 0.9 packages for you to test out on your distributions if compiling from git is too scary. Behold:

Fedora – Thanks drago01! (link coming soon)
OpenSUSE – Thanks DimStar!
Arch Linux - Thanks some-guy

Ubuntu packages are on the way, although I believe they are working something out with Debian (who also does not have packages yet)

Release for real soon!

Half a logical step

2010-05-25T02:21:24+00:00

So after it seems like everyone was “suprised” that running compiz might actually add 3D overhead, I wrote a blog post try to explain why you get a performance hit, but the reasons why you get a performance it being good. So when I was reading the news on my phone this morning, I saw the next headline that made me laugh so hard that I got out of bed and into wordpress to blog about it. Turns out too, that our friends KWin can also add 3D overhead. You’d think with that explanation of how an OpenGL compositing manager works and how redirected direct rendering works, you could easily say that every OpenGL based compositing manager will add 3D overhead, and that includes Compiz, KWin, Mutter, etc etc etc the list goes on forever. Nope – the only way phoronix can make an argument is with benchmarks and not logical analysis.

I’m waiting for phoronix to run a story about how “apparently” running Mutter will also add 3D overhead. Or maybe they could just say “compositing managers add 3D overhead, just like running two applications at the same time is always going to result in them getting slightly smaller timeslices”.

In news of an actual feature

2010-05-23T15:53:58+00:00

Today I actually added a feature to the 0.9 branch. Well, not so much of a feature, but a framework to fix a long-time annoyance to do with loading and unloading plugins.

Compiz’ plugin stack

Compiz, as you probably know, is a highly plugin-based window manager. If you’ve ever done development, we usually like people to implement things in plugins where possible since this means that we can mold to all sorts of situations. At the moment, compiz’ plugin architecture is a bit primitive – we have all plugins in a sort of “stack” or list and every plugin can register for certain events in core and in other plugins like “I’m painting the screen” or “I’m painting the cube” and modify the way the event is done. Unfortunately, this means that removing plugins from this chain without breaking it is difficult. So what we do at the moment is if you are removing a plugin which was inserted before other ones, then we unload every plugin after the plugin you are removing, remove your plugin and then re-load all the plugins that were just unloaded. It works, but it has some nasty side-effects, since the plugins all behave as though they were just loaded once one plugin is unloaded.

This effect was made particularly worse when we made the composite and opengl functionality plugins, because if they were unloaded momentarily and then reloaded you end up with all of your windows being rapidly unredirected then redirected which looks ugly. Or worse, there is a bug in libdri which could cause your card to hardlock if you were rapidly creating and destroying GL contexts. To fix this at least, we load every plugin after composite and opengl. However, we can’t use that to fix the next problem.

When you unload and reload a plugin, all of it’s memory is cleared and it behaves as though you just started compiz. That means that if you had effects like opacify or dim inactive enabled, they would be disabled once you unloaded any plugin that was loaded before them. Of course, this sucks. The solution was to write a new class in compiztoolbox called PropertyWriter. This wraps the X11 window property feature and allows plugins to easily store data in the X Server memory attached to certain windows. This means that the plugin can store data there, unload, reload and load their state from that property data on the root window. Which means that your effects stay enabled and survive through plugin unload/reload.

Of course, this needs to be implemented on a per-plugin basis, but I have already done it with opacify and dim inactive (formerly addhelper). The implementation could definitely benefit from some serialization though. Currently it works by templating what the data stored looks like and then reading back the property from that template data.

Don’t file a bug if …

2010-05-22T07:42:49+00:00

If you are using the 0.9 testbuilds and your settings got reset.

I recently changed the settings storage path to avoid conflicts and weird file names. That is all.

Beware the benchmarks.

2010-05-21T10:34:47+00:00

Today phoronix published an article called “The Cost of Running Compiz“. While the content in the article is mostly true, and likely points out the obvious, I should probably clarify a few things before my inbox fills up with (n readers * ~ 8 ) mails telling me that compiz is slow and I need to fix it.

The article basically tests the performance of applications while they are being run as redirected windows. What does that mean? Well, for the better part of the year, pretty much 95% of graphics hardware has some support for what we call “redirected direct rendering”, both through open source and proprietary drivers. NVIDIA was the first to get this feature, and then most of the other drivers picked it up last year.

Historically speaking, graphics drivers pre Mac OS X, pre Vista and pre TTM/GEM had onboard video memory which was used to draw the screen. This video memory usually contained a huge block which was basically just the contents of what the next screen redraw was going to be, then come next refresh, that is what ends up on the screen, and applications automatically draw to the other huge block. This approach is quite primitive, but it worked – it was much like the time when pre-x86 computers had no such thing as multi-tasking and everyone had the same access to all the memory. Have two applications run at the same time, and if they weren’t careful, then the whole thing just turned to crap as one application just dumped new data over whatever another application was just doing.

The same thing also happened for video memory. As soon as you had two applications running at the same time, it was perfectly possible for one to just dump whatever it was doing on top of whatever another application was doing. And for that, you generally end up with this fail:

Rendering Fail

Obviously you don’t want that. But for the applications, and performance reasons it’s great! This is because each application will get full access to the video display and so once you’ve written to this huge block of memory, you are guaranteed to get a place on the screen (unless some other application writes on top of you) and there are no extra steps required.

Of course, to the user, this makes pretty much everything drawing directly to the framebuffer (like opengl) pretty much unusable, because you are essentially multitasking compiz which might as well be a full screen 3D application and your other opengl application with no sort of memory management. So they’ll just fight. All the time. There are similar problems with other compositors on linux and also compositors on operating systems which didn’t have driver supported memory management at the time (Windows XP, Mac OS 9 etc). Which is why the graphics frameworks were rewritten for Vista and Mac OS X. And also the reason why we rewrote them too.

So now, for your applications, the steps for getting on-screen are a little bit more. You don’t have access to the big framebuffer anymore where you can just dump your drawing and forget about it. Now, you ask for a particular size of buffer, and the graphics driver gives you your own private buffer for you to dump your applications’ contents into to your hearts content without the worry that some other application will go ahead and overwrite it. The problem is: how do we get this on screen? Well, you could do it in-driver so that the applications’ output are dumped onto the big screen buffer again. For that you get a performance hit due to the overhead of copying buffers around, and this:

Fail Again!

So the idea was – why not just expose those buffers to the compositing manager and they can just draw them to their buffer like a regular 2D object. And so that is what we do! The buffer is exposed to us as a pixmap, we then bind that pixmap content to an OpenGL texture through our magic and then we just draw that texture on screen.

So how does this affect benchmarks?

Well first of all, any in application that displays a refresh rate, that refresh rate is never going to be accurate, since you really need to measure the net refresh rate of everything going on in your screen. The system is going to be slowest at it’s slowest point. This means that the only meaningful refresh rate is compiz’ refresh rate, since that is how fast the total compiz buffer which includes everything in the other applications’ buffers is getting shoved on screen. (Of course, at that point, we get into how fast your monitor is, and this is usually 60FPS in any case, but we won’t get into that.) When running without compiz, your application just gets blitted to the screen and THEN you can somewhat accurately tell how fast or slow things are running.
Secondly, there is always going to be semi-significant overhead when you have to do additional transforms on what an application has just drawn to get it on screen. The good thing is that the open drivers have largely mitigated this problem and optimized the drivers a LOT to reduce the performance hit. If this were all done in software, we’d be stuck back in the days of XGL where we had really really really slow 3D performance since it was all done in software. So in essence, phoronix is just pointing out the programmatically obvious. More operations = slower.
Thirdly, you might notice that our friend the NVIDIA driver seems to take massive performance hits when running with a compositor. This is because they have their own implementation of pixmap to texture binding as well as redirected direct rendering and memory management. Unfortunately, probably because of the code paths that are shared between all operating systems or their preference towards windows drivers, their texture binding is quite slow (slow resize) and their RDR is slow too. As phoronix helpfully pointed out, and what may have actually given them somewhat more balanced numbers, we’ve actually had an in-core workaround for this initiated with the “–loose-binding” switch, which only binds textures once they are activated. It does not follow the OpenGL GLX_EXT_texture_from_pixmap specification, which is why we do not use it by default. In Compiz 0.9, onestone introduced a new method of pixmap to texture binding, which does have a minor (2%~) tradeoff in performance for NVIDIA compated to –loose-binding, but is now the default because it follows the specification. Our recommendation: Use nouveau.

Compistors on most operating systems have had an option now to disable compositing when you are running a full screen application and they deserve the entire screen buffer. We have *semi* supported this for a while with the “Unredirect Fullscreen Windows” option, which disables the redirected rendering path for fullscreen windows. Now that composite and opengl plugins are separate, we will soon be able to just unload the opengl plugin on a fullscreen game so there is no compositing whatsoever. This is what Windows and KWin already do.

tl;dr: The phoronix benchmarks point out the obvious and you have a choice between horrible rendering glitches or a slight performance hit.

Bugfixing and Testing

2010-05-16T16:31:32+00:00

Hi everyone,

So a release is coming around, but there is nothing stopping you from testing the next development version of compiz right now!

Over the past 2 or so weeks, I’ve gotten some phenomenal amounts of input varying from quirks, crash reports and other problems which I probably wouldn’t have spotted otherwise. As a result, I fixed some really quite serious bugs, including:

Really ugly visual glitches on the switcher and static-switcher plugins
Various crashes in the animation plugin
Rapid redirects/unredirects as a result of the opengl plugin being reloaded all the time which could lead to a hang in libDRI
Windows not being focused in some cases
Immovable tabbed windows
The “Elements Behind Windows” option not working
Various build quirks

Over the past 2 or so days, I did some refactoring of the buildsystem so that plugins do not need to use ‘rpath’ in order to link to libraries such as libcompizconfig and libdecoration. This means that we can finally build RPM and Debian packages. Hopefully a PPA for Ubuntu will be coming soon, and we might even see Compiz 0.9.2~ in Ubuntu Maverick Meerkat if we’re lucky

However, what I really need now is some user input on some of the more crucial elements of this release. This includes:

Ensuring that compiz builds from a fresh build from the new commits that have gone into the master branches
Going into CCSM and disabling the “opengl” and “composite” and relaunching your window decorator and telling me if it works as expected (albeit, it’s a little slow, but I will work on this for 0.9.2)
If you have a screen resolution that is higher than your maximum texture size, enabling the “Copy To Texture” plugin and telling me if compiz appears to work.

As usual, you can post any quirks to this forum thread [1] and see this post by soreau for a nice script to do everything for you

[1] Speaking of the forum, if you miss the old theme, then I can tell you that one is being worked on for the new phpBB forum. Also, I’m aware of the spam problems – if anybody wants to nominate themselves to be a moderator and has some kind of significant community experience then feel free to apply and clean off the spam on the forum, I hardly have any time these days

edit: I created a google form for people to fill out bugs while testing. Go Go Go!

edit: If you’re getting build errors for libcompizconfig when upgrading, do rm ${PREFIX}/share/cmake/LibCompizConfigCommon.cmake and compile again.

Bye Bye WordPress.com

2010-05-13T00:42:13+00:00

WordPress appears to be putting ads on my blog. I didn’t ask for this; nor did I want it.

I know that they need to pay the bills, but I don’t think it’s right that my readers should be hit with ads. I’ll be moving my blog somewhere else (probably to .compiz.org) so stay tuned

Thank you canonical

2010-05-11T13:10:30+00:00

For proving to everyone that yes, you can in fact do a clutter based panel without shoving it inside the window manager

It's compiz running along side a "next gen panel interface!"

I can see that they still plan to use Mutter in the next UNR, but I don’t really care – as long as users are allowed the opportunity to use another window manager, I’m always happy (whether that be compiz, enlightenment, kwin, xmonad etc).

Now if only one particular project could learn something from this.

edit: Damn, it looks like Unity also draws the desktop background. If they could just make it two separate X windows using rgba-glx (or the clutter equivalent thereof) then I could show off some really really cool tricks reproducing the famous “overlay mode” using expo and cube.

Compiz master testers needed

2010-05-08T02:53:55+00:00

Hi everyone,

So we have about 95% of all the bugs fixed for a release and now we need YOUR help to identify the remaining bugs in git master before making the new development branch *official*.

Testing is relatively easy, and can be done without detroying your existing compiz install.

Instructions here.

edit: Instructions updated, since they were causing a few builds to be wonky. Also, the 0.8 dependencies can be installed through installing the various -dev/-devel packages on your distribution for compiz. In ubuntu you can probably use apt-get build-dep compiz or something of the like.

P.S: This /is/ a rewrite from a code perspective, so it’s basically supposed to be functionally equal to 0.8 (with the addition of pluggable rendering backends and reparenting decorations among others). There isn’t any major new functionality, so Phoronix please don’t run a story about how there isn’t any progress whatsoever, because once a release happens you can definitely definitely definitely expect progress

Something I should draw your attention to

2010-05-05T16:03:55+00:00

Today there was a bit of an uproar as the Ayatana team over at *buntu came up with a new way to use their influence to change the design of every open source project out there. Windicators. While I think that the idea is great in theory (per-window volume controls via pulseaudio anyone?), there are really quite a lot of problems with the implementation Mark has suggested.

Basically, they want to use something called “client side window decorations“, something that the GNOME developers have been trying to push in for a while now. What is basically does is implement window decorations as a widget for a window, which is handled on the side of the application which creates the window. While there are benefits to this (don’t have to talk to the WM, can draw whatever you want up there), there are some inconsistencies, and I think Martin Grasslein over at KWin did a good job of showing what the problems with this are

However, there are specific ways that this affects compiz too. Aside from tying all of your GTK applications to a gnome window decoration style (bad bad bad!), it also means that any work that we want to do with decorators will be essentially redundant. This means that you can’t have your wicked looking emerald themes, and we can’t write a new decorator which supports customizable window actions across all windows. A lot of the windicators could actually be implemented using a DBus system and plugins for different decorators. It will require significant rewrites on the metacity and gtk-w-d end, but I think this is much much easier than trying to rewrite every single application for client side decorations

To clarify why you can do consistent UI elements without client side decorations:

1. The majority of window managers which draw window decorations are what we call ‘reparenting’. This means that for every window on-screen, the window manager creates another window, draws decorations into that and then puts the actual window inside the window with the decorations. This allows for a much more consistent approach to decorations (as it is all just one window) and also means you can do cool tricks like kwin-tabbing. One of the arguments in favour of client side decorations is that it allows for a consistent style between the window and the decoration. But with reparenting decorators, you can already do this, simply by drawing a stylized background on the window itself (with hints from the application), which already blend into the window titlebar and then the application doesn’t draw any background, but instead just some widgets. To clarify: your window manager takes care of drawing the window chrome and does so consistently and in a space-efficient way with every other window. I believe on Martin Graesslin’s blog this has already been demonstrated (and is, in fact ready to go into KDE4.5)
For the reasons above, you can also make window side decorations UI consistent as well – but we need a standard way of doing this (window properties?)
I don’t think the GNOME developers are trying to push this by any sense of the word – but I think it has been an idea of theirs for a long time.

To clarify even further:

Today Bastien Nocera posted some reasons as to why Martin’s approach to client side window decorations was wrong. Unfortunately, I think that he is missing the point that Martin was trying to make on that blog post. To clarify

You can only run one window manager at a time and that window manager allows you to provide a consistent approach to … window management. X11 wasn’t ever designed with the concept of having some external process do the window management, and historically speaking it was up to windows to place themselves on screen. Unfortunately, the behaviour between the way all applications did this was largely inconsistent and thus (quickly) came the need for window managers to sort out how to handle multiple clients on the same X Server. Thus regardless of the application, toolkit or whatever, the user should expect a consistent approach to the management of their windows and this should be enforced.
It is possible to run multiple toolkits at the same time, and those toolkits do not provide any sort of shared consistent approach to window management. There is no way, that GTK+, Motif and Qt could all talk to each other to figure out exactly how the window border should be drawn (Unless you want to negotiate some huge shared standard, which would be much more difficult than just negotiating a D-BUS standard for implementing windicators in the decorations)
The reason why that top titlebar has always been drawn by the window manager for years and years and years is because that top titlebar is to do with one fundamental thing and that is window management, which is soley the domain of the window manager.The window manager controls the rules for how windows close, maximize, are moved, are resized etc etc etc. Think of that top bar as the window manager saying to the user “What do you want to do with this window” and presenting to the user a whole host of things that the window manager can do with the window (such as tile it, close it, minimize it (a window manager concept), maximize it (ditto), maximumize it, tab it, shade it, pin/unpin it, move it to another desktop etc etc etc). It is NOT there for the application to say “what do you want to do with me”. Because all the application can do in that circumstance is draw on a few shared understandings of what window management is (likely close, maximize, minimize). There are ways for the application to check to see what kind of window operations are supported and draw appropriate buttons for them. But this will result in MORE pain, because it means you have to go to EWMH and figure out a whole host of property names that the window manager tacks on a window if it supports a feature. But then this means that window managers have no flexibility whatsoever to implement clever window management paradigms, since every single time they want some new feature, they have to go create YET ANOTHER specification for it.

So; window management should be consistent, toolkits are not a way to provide that consistency, the titlebar is the area of interaction with the window manager. Keep this in mind when I answer the next few questions:

On UI inconsistency: How can you say that when there’s no agreements on the implementation yet? Of course Athena widget apps will look different, they already do. As long as the theming and behaviour is known and agreed upon, there’s no reasons why it should happen.
- So in order to implement this, we need to agree on a consistent theming specification between /every/ /single/ /toolkit/. This is like asking GNOME and KDE to merge. (Read: it won’t happen). Doing this means that you will vastly limit the number of themes that you can do between all toolkits for the sake of specification, since you need to find some common supported ground between all toolkits. Remember, you have to cater for ancient toolkits as well.
Window Tabbing (KWin specific): Why would that be impossible to implement? You’d just need help from the toolkit to do that.
- First of all, window tabbing is achieved through the use of reparenting inside decoration windows (at least in KWin). In compiz its done through clearing the input shape of one window and hiding it. Things like reparenting and tabbing are /fundamentally/ the job of the window manager because the window manager needs to be /aware/ of what the state of all the windows are. Reparenting applications through the use of a toolkit on the side of a client is just asking for trouble. First of all, moving tabs between clients of different tookits would be a nightmare, considering that you’d have to write some spec to get DnD of tabs between them right. Second of all, reparenting is an extremely tricky thing to get right. Dennis and I have worked on the compiz implementation of reparenting for quite some time now and it is still difficult to iron out the bugs. Moving the job of reparenting to the client means that /every/ /single/ /client/ will have to get it right, other wise you could wreck the X window tree. Even if it was the job of the toolkit, you need to wait for every single toolkit to implement some kind of window management feature your window manager should have (and could have !) had all along because it was a window manager.
Accessibility features like big border and button sizes for all windows: Certainly not. It would even mean that you wouldn’t get a disconnect between application and window manager implementing accessibility features
- Accessibility features are generally done by the desktop environment setting a whole bunch of environment variables and window properties telling clients how big their buttons should be, etc. Generally speaking, desktops really only set these environment variables and window properties for applications of their own toolkit. Even on KDE, you need external modules to set things like the GTK+ theme. So what you’ll end up having is a situation where a11y only works for both the window decorations and the application itself where the application is the same toolkit as what the desktop might expect. Or, I guess you could go off to freedesktop.org and negotiate yet another standard for how to do this.
Easily changeable window themes: Why wouldn’t they be easily changeable? That’s highly dependent on how the theming is implemented in toolkits. I guess it would be the case if you had a half-hearted implementation.
- I use Qt, GTK+ and Tk applications in my daily workflow. This means that in order to change window theme, I must change the theme 3 times in 3 different settings tools (considering that I use KDE, and there is currently no “draw my theme with Qt widgets” in GTK like there is the inverse in Qt). Or you could have some standard theming tool which changes all 3 themes at the same time (and would be highly limited).
Shadows which are part of the theme (KWin would not paint shadows for a client-side window-decorated window): Why not? If KWin knows that the application is drawing its own decorations, it could draw the shadows, or you could make the application’s toolkit be aware that it needs to draw the shadows. Either way, it’s not impossible to implement.
- The reason both Compiz and KWin dont draw shadows on client side windows is because with client side decorations, you simply cannot predict the actual shape that the window will take, unlike if you are drawing decorations on the window manager. This is very important because the window manger would have to assume a square rectangle to draw a shadow around. But what if your client side decorations whizz-bang application is round? You get a round application with square shadows. Fun times. The application themselves could be burdened with the task of drawing the shadows yes. But that has one very big requirement that a lot of old applications wont be able to facilitate for; which is the requirement for an RGBA window. This has been implemented very recently in Qt and GTK, but it required heavy lifting there and for older toolkits it will require even more heavy lifting.
We gain tear-free window resizing (when the client is doing the resizing, with a proper resize grip for example)
- Tearing during resizing is a simple fact of reparenting when the parent window has finished resizing and the client has not. But we have _NET_WM_SYNC for this in EWMH already, which means that the parent window (or in our case a compiz texture) is only resized once the window client itself has finished resizing.
Proper way to do tabs in titlebar, a-la Google Chrome
- The window manager can handle applications drawing elements over the chrome of the window as I previously stated.

Moral of the story: Leave the decorations alone – that is where the user talks to the window manager, NOT the application.

A shout-out to nouveau

2010-05-02T13:24:32+00:00

So a quick shout-out to nouveau to show how impressed I am that I have compiz running without any proprietary software whatsoever.

Blurriness

And that behind the terminal is what is blurry. Which means that nouveau’s gallium3d has at least some support for GL_ARB_fragment_program and framebuffer_object. And even though the performance isn’t up to the levels provided by the binary driver (yet), it is still *much* faster than it was 3 months ago.

So props goes to nouveau. They basically wrote a driver for an incredibly complicated piece of hardware, completely through memory trace dumps, with no help from nvidia whatsoever and can operate the 3D engine so well that one of the world’s most awesome pieces of software runs on it. So from now on, I will no longer be using the binary nvidia driver, but instead nouveau, since it offers exactly what I need + next gen linux graphics technologies such as KMS, XRandR1.2 and G3D. Win Win Win.

Compiz Mind Control

2010-04-03T23:18:12+00:00

I’ve been looking at the Developer Nanoheadset ($500) by Emotiv and will likely be purchasing one to fiddle with. My first idea was to add a plugin to 0.9.0 so that we can have a Brain Input, much like the keyboard and mouse input dialogs now. You could map some kind of brain activity, such as thinking of all windows to be gone, to the show desktop functionality.

Another idea I’ve had is to monitor the sensor data while an application is active, possibly quantifying them by other data like CPU activity and input activity, and use this to develop patterns and map them to functionality. An example would be while using Eclipse and wanting documentation, opening a Javadoc page.

Will it work for Linux? Yes! (Read updates below!)

There is another feature that allows for manipulation of objects on screen, which is what I’ve seen demoed via Fora. It may be possible to move windows with your mind!

Update: This is NOT an April Fools joke! There was some speculation after the story was put on OMG! Ubuntu!

Update: I spoke with Geoff with Emotiv about the headset to discuss some questions I had about the software integration, Linux support, and hardware features. He did address my concern and inform me the headset has an SDK for Linux is being developed, so the Epoc headet will support Linux! He briefly described some of the features available and the Linux adapter, which is basically a port from the Windows driver in terms of behavior. He also told me they have mouse support in it, as well as a 2-axis gyroscope, which will integrate great with Compiz Head Tracking!

iCompiz for iPhone

2010-04-01T20:26:51+00:00

I'd like to announce a new project I've been working on for the past few months. With the restructuring of Compiz's core in 0.9.0, the dependence on X11 was removed, allowing us to port Compiz to other platforms. The first official port of Compiz is to the iPhone, with the new iCompiz, which we have submitted to the App Store today.

Discuss this news post here.
(One comment)

Compiz Documentation Update

2010-03-29T20:33:36+00:00

As the release for Compiz 0.9.0 gets closer, now is a good time to let everyone know what I’ve been most involved with: Documenting the API. Until recently, there was no API documentation for Compiz. You really have to admire the amount of time the core developers and others have spent working with a system that had no reference.

We’re now on the path to having a fully documented API. You can view the most recent documentation from the master branch here:

Compiz API Reference

I thought I would take a minute to thank all the developers involved and give much due credit:

Guillaume Seguin (iXce) hooked together Doxygen and git as a post-commit hook to master, so you’ll always see the most up-to-date API reference at docs.compiz.org

Sam Spilsbury (smspillaz) helped merge my staging branch into master and helped me with git, since I appear to be handicapped with it

Of course this documentation is for the 0.0.9 version that should be getting released soon, and the old 0.8.x (and before) code will remain likely remain undocumented. The new C++ architecture is much cleaner, and I’m expecting a surge in new plugins now that we have a simpler and better documented system.

If you’re a Compiz developer and you see a TODO laying around in a doc tag, help out and fill it in. Looking at the commit log, it appears this should work out nicely!

Coding by proxy

2010-03-28T09:18:21+00:00

Ceiling collapsed, house flooded, written off car, damage to $$$ of electricals including laptop’s AC adapter.

Doesn’t stop me from setting up a VM on someone else’s machine and coding on that instead. And fixing a huge bug in gtk-w-d-2d in the meantime.

A C++sy world awaits.

Meters from the finish line

2010-03-24T12:44:11+00:00

Hailstorm Destroys UWA

2010-03-22T13:50:42+00:00

In case it hasn’t hit international news yet, a hailstorm completely brushed Perth today, which is where I live. This must be the first time we have had such weather in about 30 years.

Here are some photos from the damage

Ubuntu 10.04 - Lucid

2010-03-22T00:18:57+00:00

Finally getting back into using my laptop as a testbed for the newest Ubuntu betas. After having some issues with Karmic (which I updated to on Thursday, and found that my laptop would randomly lose power - my netbook is doing fine, my desktop has been running it since around release time), I decided I'd try Lucid. I booted into an older kernel, which alleviated my random shutdowns, and upgraded.

So my first thoughts:
- Yeah, yeah, the window buttons. I fixed those with a simple configuration change. Sorry, Shuttleworth, I don't even use the default theme, and whatever you're working on is probably not something I'm going to use anyway.
- What the hell happened to my Compiz config? I thought I was safe enough using GConf to store my settings, but it appears some of my minor appearance settings have been changed a bit.
- Murrine isn't accepting my dark gray scroll bar - it's now the highlight color (blue). While I can get used to this, it makes my laptop no longer fit the uniform style.
- Byobu (awesome screen profile that Ubuntu started shipping by default in 9.10) has a conflicting default color scheme.
- The volume applet isn't starting by default. I can run it with `gnome-volume-control-applet`, though.
- iBus is pretty messy. I can't seem to get to my Anthy controls to reenable commit-on-close, and the tray icon disappears and reappears when I switch focuses (it also doesn't let me right click it).
- After logging out and logging back in, I now have the Universal Access icon appearing in my tray, and I can't seem to find a way to get rid of it. Going to `kill` something when I'm done typing this to see if it helps.
- Gah, Windows fonts on my Firefox screwing with hinting! I'm typing this in a box that's using Tahoma instead of a properly-hinted Deja Vu!

Good things:
- My laptop hasn't lost power yet. This bodes well. e: And there it went. Guess that's not fixed.
- I like the new theme, but I'm not using it. I have my own theme that is universal to all of my systems, and I'm going to stick to it.
- KMS. I know I had it in Karmic, but I didn't have enough time to appreciate it, having just upgraded on Thursday, and then going to Lucid today.

Discuss this news post here.
(No comments)

Another status update

2010-03-21T12:07:48+00:00

A quick update of where we are at the moment

First of all, some eyecandy

Those are the cubemodel and atlantis plugins, of which are arguably quite complex. Regardless of their size, I actually managed to get them done within a day for each (so about ~4h), which is good considering atlantis is over 8000 LOC (most of it autogenerated). I’ve refined my porting technique to use member variable prefixing, of which I wish I knew about earlier, since it would have saved me sooo much time debugging silly typoes at runtime.

On the more serious front, I merged in my 2D GTK Window Decorator changes, which was quite a feat considering Danny and I had to rewrite the entire event handler to make the 2D Mode work (because of fundamental differences in the way the 2D and 3D modes are implemented). Unfortunately, the technique that we use for reparenting decorations does not play nice with GTK/GDK, which is a nightmare of a toolkit to use (hello QT/KDE!), so stability is an issue I need to work on.

On the plugins front there is only one more plugin to go. That’s right, one more – and it’s already half done .

As you can probably see, that plugin is DBus – of which I really know nothing about. I don’t know how long it will take me to do but for one thing or another, progress is still being made and we are still a (fairly) healthy project. I’ll never give up on this

Conky

2010-03-08T22:06:36+00:00

Also, rain. Lots of rain.

Discuss this news post here.
(No comments)

A 2D GTK Window Decorator

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

Hi everyone

Not compositing

Above is a screenshot of a GTK Window Decorator running in the non-compositing mode of compiz.

This isn’t blingy though. So why is it significant? It means a significant amount of work is done on the GNOME side of things so we don’t need need to change window managers when you want to switch off compositing. It took a particularly long time to get right, simply because the original GTK-Window-Decorator wasn’t architectures with the fact that it might be painted to a window in mind, which meant that I had to rewrite the entire event handler, for example.
There are still a few bugs and I am in the process of fixing them.

Emerald

2010-02-12T04:18:43+00:00

I did the adjustments to make emerald work with the new decoration API today ….

*cough*

I figured that while we don’t have another custom decorator, it’s probably worth while keeping it around, even if it is somewhat broken.

Don’t ask if its supported because it isn’t. I would advise distributors not to ship it, ever. When we do a release, emerald would only ever be released under 0.5.7 NOT 0.9 if at all.

In other news, development has been progressing nicely. Dennis fixed the Glow issue in group, a whole bunch of reparenting bugs, the incorrect initial window stacking bug etc. I am porting the gtk-window-decorator to use the 2D Mode (emerald will NOT support this) and hopefully can have something to show for that in the next week. Then release?

My New Bash Prompt

2010-02-04T19:31:26+00:00

Last night, I set up a new bash prompt. It's a modified version of my old prompt with a bit more information added:

In a normal prompt, it's pretty much the same as my old one: user, host, date, time. I added a seconds display, moved the path into the brackets, and then added a new line. When in a git repo, I can see the current branch name, whether I have modified files lying around, and whether I have yet to push (if I'm ahead of the current branch). I'm thinking of expanding this to subversion and Bazaar, both of which I use quite a bit. When a program returns a value other than 0, I also display that after the current time, in bright red. If I'm root, the prompt symbol changes from a green $ to a red #.

The more interesting things to note are why I have so much information there by default. I ssh to a lot of different machines and sometimes into different users, so it's good to be able to identify what user I currently am (whether it be `klange` on my personal systems, `lange7` on a university system, or any of the random users I `sudo --` into on my server). For the same reason, I always need to know immediately what machine I'm connected to, but I don't need the full hostname (I know what machines are part of the ACM network and which are part of EWS, and which are mine, based on naming schemes). I use the clock because my panel is on auto-hide, so the quickest way to glance at the time is to look at the prompt, rather than having to move my mouse to show my panel. It's also good to see when a command ended.

Code:

function prompt_command {
    local RETURN_CODE="$?"
    local ASCII_RESET="\[\e[0m\]"
    local ASCII_BOLD="\[\e[1m\]"
    local USER_COLOR="\[\e[1;33m\]"
    local PROMPT_COLOR="\[\e[1;32m\]"
    if [[ ${EUID} == 0 ]] ; then
        PROMPT_COLOR="\[\e[1;31m\]"
    fi
    local HOST_COLOR="\[\e[1;32m\]"
    local DATE_COLOR="\[\e[1;31m\]"
    local TIME_COLOR="\[\e[1;34m\]"
    local DATE_STRING="\$(date +%m/%d)"
    local TIME_STRING="\$(date +%H:%M:%S)"
    local CYAN_COLOR="\[\e[1;36m\]"
    local PINK_COLOR="\[\e[1;35m\]"
    
    local PROMPT_PREFIX="$PROMPT_COLOR"
    if [[ $RETURN_CODE != 0 ]] ; then
        PROMPT_PREFIX="$DATE_COLOR$RETURN_CODE$ASCII_RESET " # do nothing
    fi
    local GIT_STATUS=`git status 2>/dev/null`
    if [[ $GIT_STATUS != "" ]] ; then
        local REFS=$(git symbolic-ref HEAD 2>/dev/null)
        REFS="${REFS#refs/heads/}"
        if [[ `echo $GIT_STATUS | grep "modified:"` != "" ]] ; then
            REFS="$REFS$ASCII_RESET ${PINK_COLOR}modified"
        fi
        if [[ `echo $GIT_STATUS | grep "ahead of"` != "" ]] ; then
            REFS="$REFS$ASCII_RESET ${CYAN_COLOR}not pushed"
        fi 
        PROMPT_PREFIX="$PROMPT_PREFIX$USER_COLOR$REFS$ASCII_RESET "
    fi
    
    
    PS1="$ASCII_BOLD[$USER_COLOR\u $HOST_COLOR\h $DATE_COLOR$DATE_STRING $TIME_COLOR$TIME_STRING $PROMPT_PREFIX$ASCII_RESET\w$ASCII_BOLD]$ASCII_RESET\n$PROMPT_COLOR\\\$$ASCII_RESET "
}
export PROMPT_COMMAND=prompt_command

Discuss this news post here.
(No comments)

Easy Compiz Tricks

2010-02-04T07:46:48+00:00

A while ago I tweaked Sam’s simple animations plug-in for Compiz, mainly so windows I minimized would slide away to match some of my other settings. This was to strike a balance between usability and performance, since none of these effects use alpha blending. During this time I made some jokes about a Spinner Rims plug-in to illustrate how people rev the Compiz engine when they first hop behind the wheel. Oddly enough, I’ve actually had others ask me for this plug-in and had Google Alerts on random forums about it – as if it was real, which perplexes me.

Sometimes applications don’t always (or can’t) describe a window correctly, which can make Compiz use a different animation. For example, when I drag a tab out of Google Chrome it uses my open animation for the window, which really disrupts the feel of drag and drop tabs that otherwise is very elegant. Another example is with generic frameworks like Adobe AIR or Java Swing, where all the widgets are treated the same. How do we work around this?

Luckily, Compiz is well equipped to handle this. You’ll need the Compiz Configuration Settings Manager (CCSM), which I think almost everyone has installed, and it should exist out-of-the-box so users can see how powerful the software really is. In the case of Google Chrome:

Open CCSM (ALT+F2 ccsm or Preferences/Compiz Configuration Settings Manager)
Click the Animations plugin
Press the New button underneath the list
Select None for the animation with the lowest possible duration
Click the Add icon near the Window Match field
Click the Grab button and target Chrome (it should give you class=Chromium-browser)

Make sure this is moved up the list so it overrides any other settings, since it’s specific to Chrome. You can later go back and click the Grab button again and add more windows to the blacklist. Now when you drag tabs in Chrome they won’t be so awkward. After getting used to no opening animation with one application, I ended up disabling them for all. I still use the other animations, but I’ve enjoyed not having any opening animations for non-decoration windows.

Reddit AMA?

2010-01-30T07:50:12+00:00

Going to try to get Sam and whoever else is still working to do an AMA on Reddit. Why? idunno, I'm a bit bored at the moment, not much to work on.

If we do, we'll be using the account IAmACompizDev.

Just an idea though.

Discuss this news post here.
(No comments)

No Glow

2010-01-29T16:04:38+00:00

I finally uploaded a C++ port of the group plugin to git today [at 3am, yes, I know ....].

It’s currently missing two things:

Number one is glow: This is the functionality where group paints a special ‘glow’ around windows that have been grouped. Apparently it’s useful for telling which windows are grouped, but it’s been the number one difficult thing to port of the entire plugin (asides from tab bar drawing perhaps) and I personally find it annoying. However, despite my toils, calculations (I’m an arts major, what maths did you expect) and uninterrupted proofreading, I can tell that I have the calculations correct (the numbers between 0.8 and 0.9 match up), but alas the glow is drawn upside down, and I have no idea why. And no, I can’t just scale by -1, it doesn’t work like that. Perhaps I might be able to work it out for 0.9.2
Number two is text drawing. I intend to add that within the next few hours if I can.

Other than that, I have all major plugins 100% ported asides from DBUS which I have deferred to 0.9.2 anyways.

So I guess now is the time to say “But seriously, there will be a release soon”. Because there will be. As soon as I fix number two and get the plugins-* sorted there will be.

Promise.

We interrupt your usual programming with this special message

2010-01-25T16:35:08+00:00

“The worst thing about censorship is ——– and ———-”

Tomorrow is Australia Day. A day where we, for some reason, celebrate our European invasion of native land and subsequent “colonization”. Back then, Australia was a penal colony, designed to house prisoners from the overflowing gaols of England. Basic freedoms such as speech, movement and publication were not even thinkable back then.

Fast forward to today and, as a highly advanced commonwealth democracy, we still do not have enshrined basic human rights in any sort of constitution. They are only implied to be inherited from Britain.

Well, our rights are under threat; and very little noise seems to be made about this. In case you don’t know already, the current Australian government plans to introduce mandatory internet censorship for every Australian internet connection next year, despite massive outcry. A large amount of spin has been placed on the debate, which has degraded to the point of name-calling opponents supporters of extreme content. Communications Minister Stephen Conroy, subtly sidestepped Hillary Clinton’s criticism of Governments who support content filtering such as China and Iran, citing the very same reason they do for his plans; that “Now, all societies recognize that free expression has its limits.”, which sounds similar to China telling internet companies they can operate with freedom “according to law“.

When it comes down to it, this filter is not about protecting children, or stopping the proliferation of extreme content, which arguably leads to messed up people. It is about quietly putting in place a system of regulatory controls for a media which has been totally unregulated for the past 20 or so years, finally adding it to the list of other regulated media such of print and digital media.

I’m sure everyone reading this has already heard the reasons as to why implementing such a filter, even in it’s current state, is a bad idea, but I will re-iterate it for those who have missed it, or for those who have not seen additional reasons.

Filtering technology is nothing new and has been circumvented since it’s inception; we have a complicated system of routers in China and Iran and that can be easily circumvented using widely known technologies such as Psiphon, TOR, DNS Tunneling, Secure VPN’s over SSH and a vast array of open CGI and PHP Web Proxy Servers. The kind of people who would likely be engaging in the proliferation of extreme content are likely to have half-a-brain about the possibility of surveillance, and the implementation of such technology will likely be a signal to drive more of these people to use the technologies listed. In effect, this makes any effort to censor the internet a waste of a taxpayer funds.
Filtering technology will likely slow down internet connections, as there is a high negative correlation between the number of false positives and time spent inspecting traffic. Bandwidth and internet latency is already sparse in Australia, and adding excess filtering overhead will likely cause bottlenecks in speed. This nullifies the advantages on spending money to construct a fibre-to-the-home National Broadband Network (NBN). Even filtering a list of URLs doesn’t scale well.
The blacklist of content that is effectively blocked or “banned”, refused classification [RC] doesn’t just include widely condemned images of child abuse. It also includes politically motivated sites, such as sites supporting the construction weapons, euthanasia and even civil disobedience. While such sites are disruptive to society, there is no good reason we should pretend they don’t exist and hide them from society. People have the right to be aware of differing political opinions. Controversially to be found on the latest leaked blacklist was Wikileaks [No link provided], a civil accountability website for governments and large organizations.
The blacklist of content is a national secret. This means that it is an offence to enquire as to whether a specific site is blocked, or why a site is blocked, or how a site is blocked. The process is completely opaque and sites may be added for any reason.
Filtering technologies give a false sense of security to parents, or even people, who are concerned about their own safety or their children’s safety online. Filtering mechanisms will only censor extreme content, and not adult content. While it may help to prevent people from stumbling on to such websites online, it does nothing to address the wider issues of malware, compromise of personal privacy and secret details, cyber-bullying and more. The current spin is that such a filtering scheme is designed to protect people online. In reality, that is further from the truth.
The scheme will allow additional funds and incentives to ISPs to further block content. Although the majority of ISPs oppose the filtering scheme, some dishonest ISPs may take the money as an incentive to filter additional sites as suggested by lobby groups such as various religious organizations and the Recording Industry. It is also the first step towards removing network-neutrality, by encouraging ISPs with potential conflicts of interests to utilize filtering to their advantage.
Finally, the implementation of an infrastructure to support internet filtering is likely to stay beyond the term of the current Labor government as it is a useful tool for controlling public opinion. The maintenance of the blacklist will be left to an “external organization”, which will most likely be ACMA, which has been heavily influenced by the former lobby groups in the past. Such infrastructure is crucial to the implementation of ACTA, which mandates packet inspection to determine if copyright infringement of recording industry content has taken place. This infrastructure could also be use to block altogether P2P and BitTorrent file-sharing networks, which are used to legitimately distribute open source software. As governments change, the blacklist of content will likely grow to include more politically motivated sites and sites that oppose or hurt organisations with significant lobby groups. This is a dangerous precedent which must be avoided.

What you can do:

If you are an Australian, you will notice that Compiz is participating in the Great Australian Blackout. A small reminder will pop-up when you navigate to any of our sites for the first time to take action against the internet censorship. With that, I would say the following is a good course of action:

Talk to people: A lot of people don’t read technology news because they think it is beyond them or it doesn’t concern them. Tell them about the implications of such a filter. They will surely be outraged; currently opinion polls show that 56% of the population ‘strongly disagree’ with the implementation of a filter with a further 26% ‘disagreeing’ while a small minority, 2% ‘strongly support’ it.
Write to your MP and more importantly your Senator about your disagreement as a voter with the planned scheme. The EFA has provided a great template to writing to your MP. Some tips with this: Writing to Kevin Rudd or Stephen Conroy are going to be futile since a) they will likely already be receiving loads of email about this, and will not be able to personally consider your thoughts and b) Stephen Conroy is stonewalling and unlikely to change his position, and neither is Kevin Rudd going to speak out for the sake of public image. Instead, write to your local MP or Senator. I can tell you that they DO read your letters and you WILL remind them of their responsibility to represent their electorate. I received letters of intent of consideration to oppose the legislation from both my Senator and MP. Remember, any such legislation needs a clear majority to pass, and by convincing your MP and Senator to vote “nay” that is one less vote that Conroy will have.
Join in the protest: Compiz ‘blacks out’ it’s webpage with a simple one-line of javascript that you can find on line 221 of the page source. Just copy and paste that into an appropriate spot on your website/blog if you can do so. You can also darken your avatar on twitter/identica/facebook/chat/forums in protest using the instructions here. More importantly, join the protest by attending in person at the venues and dates announced on the Great Australian Internet Blackout.
Sign the petition: If you haven’t already, sign the petition by the EFA which will be presented to the Senate if the bill passes the House of Representatives. The more signatures here, the better.

If you are not an Australian: then be aware. I can tell you that other countries, such as Canada, the UK and Germany are watching Australia very closely as to how difficult it would be to implement internet censorship. Make sure you make other people aware of our situation and it’s relevance to you. Remember, that no political issue is ever a local problem. If you feel strongly for us, then you can take action similar to the above, asides from writing to MP’s since they will likely not listen to you.

Remember as part of our national anthem, we declare, on Australia Day “for we are Young and Free”. Let us keep our land that way.

STOP MANDATORY INTERNET CENSORSHIP IN AUSTRALIA. SAY NO TO A “CLEAN FEED”

Additional: while not strictly related, if you are living in WA, make a stand against increased stop and search police powers. They represent a further dismantlement of your civil liberties.

-Sm

I accidentally the whole headtracking

2010-01-25T05:26:23+00:00

Yay, it’s in C++ now!

Queue terrible YouTube video recorded with my 5 year old RAZR

-Sm

Bah, nvidia drivers

2010-01-23T17:18:57+00:00

So I had a great idea today.

cornelius1 and onestone still haven’t come back from whatever they are doing yet, so I was like “Lets port stackswitch!”. It was only 1000 lines, took maybe 4 hours and was like the other switchers. No big deal.

Too good to be true

Until

NVRM: Xid (0001:00): 13, 0003 00000000 00008297 00001310 00000000 00000040

Aannnddd GPU Hang. Well that sucks. Now I can’t actually see if what I ported works. Oh well.

Which gives me more incentive to move to nouveau. Because on supported cards [like mine], there is compiz support in their Gallium3D portion. Bare compiz support but it’s there. I won’t miss blur – well, I’ll just have to get it on my intel laptop [how ironic, since this was the reason I moved to nvidia in the first place].

While you're waiting...

2010-01-23T01:23:36+00:00

I'm driving back to college tomorrow (or this morning to be accurate).

I noticed this video on the Planet and since it's pretty awesome I figured I'd post it here as well (Planet readers, no need to worry, you've seen this already).

Kevin Lange has a pretty awesome video showing an updated version of the desktop head tracking, and it demonstrates its effectiveness much better than Sam's video that I featured a while back.

I may review this in one of my videos depending on the situation, though a video of it in action may prove difficult as the only camera I own in my dorms is my laptop's webcam.

Compiz, Patents, and Ubuntu

2010-01-22T17:22:09+00:00

No, this isn’t about the stupid max_waves conflict with Apple’s patent that everyone has been ranting (and working around) for the last few years. From what I hear the future 0.9.0 release won’t be hampered by it, but how does Compiz fair with patents? Who made Compiz, and who’s working on it today?

From my understand the original Compiz, before all the forks and subsequent merges, was developed by Novell via David Reveman with help from others. Now, in the aftermath of whatever happened, most (if not all) of the core developers aren’t around – and Novell has moved on too. While the developers are gone they did take a little something with them.

SYSTEM AND METHOD FOR EVENT-BASED RENDERING OF VISUAL EFFECTS is patent application #20080313540 by Anna Dirks, David Reveman, Stephen Carter, and Scott Isaacson filed back in 2007. This patent would go to someone who deserves it, but can it ever be used against the project in the future? Now Apple is filing for a patent on head tracking, which is something we’ve seen Compiz devs and plug-in writers have been doing for a while now. We want developers to get attributed for their hard work in Open Source, but nobody should have control over the ideas that power these projects.

Ubuntu is using the old 0.8.x branch written in C, while the team has moved on to the 0.9.0 release written in C++. With Ubuntu 10.4 (Lucid Lynx) being an LTS, it’s obviously not going to be in that release. Even once the package is more mature, there is still a big dependency issue lingering. While it’s obvious that the refactoring of the code yielded performance and maintainability benefits, it’s using libboost and favoring C++. With GIMP kicked off the CD to make space, what’s going to happen to Compiz?

Update 1: There is a thread going on UbuntuForums.org related to this, although some of it’s just anti-Apple rhetoric. I wish people would stop hi-jacking real discussion with this crap.

Update 2: I asked Novell if they could shine any light on the situation on January 26, 2010. Hopefully they are willing to at least take a look and get back with something besides a dear-john letter.

Ignore the apparent fail

2010-01-21T15:10:26+00:00

Hello, this is SmSpillaz;

This is probably the most complicated port I’ve done, the diffstat is around 4000+ lines.

Everything works (mostly), I just need to fix those stupid drawing issues, which I have absolutely no expertise on. cornelius1? onestone?

Once this is done, and refactored, it will be the last plugin that needs to be ported. When it is complete, surely the plugins shall fuse to form THE compiz 0.9.0. And when that happens, forward development can only follow.

Stay tuned

- Sm

Bugs with GDK_NATIVE_WINDOWS

2010-01-18T14:30:00+00:00

There are two bugs that I encounter a lot in Ubuntu 9.10 (Karmic) that irritate me a lot. Both bugs involve mouse clicks not being registered. I’ve got some workarounds and fixes, but first some background on these bugs.

Flash Bug (#410407)

This bug has been misidentified as a bug in Compiz, when in fact it’s a bug in Adobe’s Flash Player plug-in. It causes mouse clicks to not be handled by the Flash application. The bug is inconsistent – it’s an all or nothing thing. You’ll either get the bug on a video, or you won’t, and sometimes it can be coaxed into working by spamming clicks.

Eclipse Bug (#443004)

This bug has caused a lot of wasted time. Similar to the bug with Flash, clicking on a button with some dialogs will not register. It’s also inconsistent, which can be a real pain. Some dialogs in Eclipse can span many pages, such as the Export to JAR dialog.

Both of these bugs are related to a change that happened regarding GDK, the underlying method GTK-style applications use to draw things instead of calling X directly. I think the core problem is:

A small gotcha is that the GDK_WINDOW_XID() call is no longer a trivial accessor for the XID of the window, and thus must not be called from another thread without taking locking precautions.

This matches the inconsistency of the problems, since it’s a related to concurrency.

To combat the bug in Eclipse I’ve started using the repository version, since the SWT-related bug was fixed and they added support for user plugins.

The workaround for the Flash bug isn’t as nice, since Adobe is the master of making horrible “fixes.” For example, they pulled the rug out from underneath a lot of websites using Flash player to do the heavy lifting of uploading multiple files by requiring the file selection dialog to be initiated by a user interface interaction. Essentially you have to tell Flash not to enjoy the benefits of client-side windows by modifying /usr/lib/nspluginwrapper/i386/linux/npviewer to look something like this:

#!/bin/sh
TARGET_OS=linux
TARGET_ARCH=i386
GDK_NATIVE_WINDOWS=1
. /usr/lib/nspluginwrapper/noarch/npviewer

So that’s two features Adobe has nerfed in one configuration file (64-bit and client-side windows)

Another Thought

2010-01-15T15:52:58+00:00

Sorry that the website theme is a bit messed up at the moment, this is due to me losing the hosting I had gotten before. I might be able to use my campus online storage to host the images in the near future. I'm going to clean up the design soon.

Also I changed my Twitter username to gavintlgold, and it's not just FusionCast-centered anymore.

Feel free to follow me :) > http://twitter.com/gavintlgold

On the subject of capturing my desktop

2010-01-15T15:26:01+00:00

So, after hearing the response of the readers I think I may start up again, maybe not just for Compiz Fusion but other things as well. Even though there haven't been that many comments I know that my 400+ subscribers on Youtube might also appreciate more videos.

However, I can't keep using the system I have been so far. Xvidcap, as good as it might seem, is not the best option. All my screencasts were actually sped up because of frame dropping, and the performance wasn't phenomenal even so.

I'm considering buying a capture card to plug in to my graphics card (which has s-video out) to record the video. On Newegg it seems like I can get one for around $25 to $30.

This way video would be nice and smooth and I can show you guys the real truth behind my desktop, which, though it's not the most top-of-the-line in terms of hardware, performs amazingly with Compiz Fusion. Screencasts taken with software just don't do the cube justice.

Also I'd rather not use a camcorder like I did for my big million views video. Having such a capture card would also likely open the doors for linux gaming and other features.

Now, I know capture cards are not designed to capture video from the computer to record onto the computer, but I'm thinking this should be all right. Then again, I could be totally wrong about this increasing performance. Would recording with the capture card on linux be a CPU hog or would it be all right? If it's a CPU hog I suppose the situation isn't any better.

If anyone could give me advice about this or another method of using hardware to record the desktop it would be greatly appreciated.

Finally, I'm removing the Adsense ads and replacing them with a Paypal donation button. I don't think any of the ads are really relevant, they must be annoying, and I've only gotten about $35 total through Adsense after all these years. If you would like to speed up the process of me getting started up again I would always appreciate a small donation. Perhaps if I get enough I could use it for the capture card!

Once again, thanks for your patience and helping me out with this capture card business, I'm not an expert with hardware like this.

Not much happening...

2010-01-09T08:04:02+00:00

I figured I might as well update you by now. I assume most of you have given up hope of seeing a new video.

I'm in college now, studying Engineering at Rensselaer Polytechnic Institute. I still use linux on my laptop (on my desktop I play computer games so I'm forced to use XP).

My current Linux setup uses Compiz Fusion (of course), Docky, and the Global Menu Applet to emulate a sorta pseudo-mac look.

Since Compiz hasn't undergone any major visual changes I haven't really found it necessary to update this blog with anything. However, the underlying code is being restructured completely and ported to C++, which I consider a big step forward. As for me I still like coding in Python but I have a better understanding of how C++ style coding works so I could probably begin to read and tweak the Compiz code myself.

Anyway, the main reason I wanted to post this was to see how many people still visit this site or have it in their feeds. My Youtube account still seems pretty active and I've got a lot of subscribers, so I suppose a new video wouldn't go missed.

However, I'm not sure what to make a video about. I suppose I could make a presentation of my current setup, which I think is excellent for getting work done, or I could make a video showcasing my 30-second boot into Ubuntu Karmic.

If anyone's alive out there let me know in a comment, and give me your opinion about where I should go with FusionCast. Thanks :)

Not quite

2009-12-18T15:02:28+00:00

A while ago, things looked on track to get 0.9.0 out by xmas, although the development pace has slowed a bit, and we’ve hit a few bugs we’d like to get fixed first. Although I can say that functionality-wise we are almost on-par with 0.8.*, group is half-done (tab functionality has yet to be implemented), animationaddon is half-done and dbus and stackswitch remain.

I’ll keep you posted, sorry things are taking so long, it will be here soon but don’t hold your breath since there aren’t any major user related changes and we can push back the release as long as necessary to have some kind of stability.

Re: Spam

2009-11-29T01:59:23+00:00

Hey guys;

REALLY REALLY REALLY REALLY REALLY big apologies over the spam issue. Now that my inbox has been flooded with complaints this issue is much larger than I originally thought. For some reason, my mail address has not been hit with the waves of spam, so I was totally unaware of this issue

If you are able to take actions against the spammers in YOUR jurisdiction, then please do so.

Also, thanks to everyone for pointing out that file on the server. I have arranged for Guillaume to get it removed ASAP as soon as he or someone else who has access to the server is around. edit: done

Once this entire ordeal is over we will launch an investigation as to how the security of our server was compromised. If there is ANY sensitive information you’d prefer not to have leaked then PLEASE remove it from the wiki. The forums are locked down.

Kind Regards,

Sam

Abandon Fail Boat

2009-11-28T15:38:28+00:00

The web team is in a bit of a situation. You see, we’ve been having numerous problems with the forums recently, including but not limited to:

Not being able to log in AT ALL into the Moderator Control Panel or Administration Control Panels intermittently
The ‘Edit’ button being broken for over a year
‘Delete posts as spam’ not working intermittently
Spam getting worse every day, we recently had someone post sexually explicit and extremely objectionable to the boards which we had trouble deleting since the forum software is so horrendously broken
And the most recent incident where confidential user data has *somehow* been leaked to spammers.

This leaves us to conclude that there must have been some exploit performed on the board. This is an extremely bad security risk and as of now the forums have been locked down until we replace them.

However, we can no longer use vBulletin. Asides from our trust being lost in its security for a product we PAID for and the fact that it is a proprietary product which, as an open source project, we cannot support, our licence key as well as user name and password for downloading the forums software has gone missing which means that we cannot upgrade the forum software.

Guillaume and I consulted with the council and a majority decision was made (2 FORs, 2 ABSTEINs, 1 NOT PRESENT) to say ‘good riddance’ to vBulletin and move onto phpBB.

phpBB has the tools for us to import the existing database as well as the theme. Guillaume made it clear that he would rather spend time adjusting the theme so that it works on phpBB rather than fixing broken proprietary software.

edit 1: the new forum has been made – no theme as of yet; it will be ready soon-ish

edgurgel

2009-11-16T00:11:11+00:00

Almost one year ago we presented Swap plugin here. Now we renamed it to Swapper and ported to Compiz++ (future Compiz 0.9).

Just to remember that it allows you to swap the geometry of two windows. Basically we changed Switcher plugin to swap active window with another window.

Swapper could be inserted on new Compiz if everybody likes it. Waiting for replies!

Video:

Code

Tagged: compiz, compiz fusion, development, fusion, linux, management, plugin, swap, swapper, window, window management

Cube finally ported!!!

2009-11-04T11:42:39+00:00

I’ve finally finished the Compiz++ port of the cube and rotate plugins.

Cubeaddon is next

Compiz Documentation Tag Style Vote

2009-10-22T12:29:52+00:00

I’m getting mixed opinions about what kind of doc tags to use in the Compiz project. Overall there are two choices that everyone seems to be okay with. In no particular order the two most popular methods are:

///
/// This does that
///

/**
 *  This does that
 */

The latter is nice because it matches how javadoc works, which I think has made Java (and it’s APIs) one of the best documented languages around. The former I found nice because it’s easy to align in all text editors quickly (always type three forward slashes), but is more verbose. In source the former also seems to make it easier for me to quickly scan for doc tags, since most multi-line comments in C++ are done with /* notation.

Erkin pointed out that we can easily nest /// style of comments inside of /* comment blocks, which makes it easier to comment out portions of code that are documented, such as this:

/*

... code ..

///
/// Method we don't want
///
int foo();

... code ...
*/

Feel free to make your arguments known here. If you see me on IRC feel free to bring it up, but please use the poll below or make a comment so we can get a real idea of what to commit to before we start merging all the doc’d code. This is a good way to avoid many git quilting sessions later.

[poll id="2"]

Compiz 0.9 C++ compared to 0.8.4 C

2009-10-21T05:13:52+00:00

Here is an early look at some of the changes I’ve been investigating as documentation continues on the new Compiz 0.9 branch. The community and development team are pretty awesome folks, and I would like to take a moment to thank everyone in the IRC, Forums, and Planet.

This graph is simply information I collected about the size of the source code files for various plugins. There is also a general graph comparing the sizes of the core. I had started to do a comparison of binary sizes, but because of the optimizations and debugging builds I have – it might be a while before I could get accurate numbers for that.

Compiz 0.8.4

2009-10-14T15:32:38+00:00

Compiz 0.8.4 is now out! This release brings two new plugins, translation updates, many bug fixes, improved stability, and better screen resolution change handling. Also included is additional integration work for KDE 4.

You can find the official announcement in Compiz Community list archives.

Have fun using Compiz!

Beryl back from the ashes

2009-05-15T04:39:15+00:00

Linux_Ubuntu_geek
writes:

Wake up all at Compiz as Beryl is alive and kicking !

You might be interested that over a weekend a mate and myself introduced Beryl back in to the fold. This is a direct result of our frustration of how bloated Compiz has become and is becoming more of a fashion thing rather than functional for having multiple desktops.
OK so I have been using Ubuntu 7.04 on and off for a couple of years now and Beryl comes as default. After Ubuntu 7.04 Compiz Fusion (now Compiz) came as default. To begin with this was not a problem but as Compiz became more complex with spheres, globes and other useless features, performance was becoming impaired.
Late one night I started looking at introducing Beryl to Ubuntu 9.04 (Alpha 6). As expected there were numerous depedendency issues.
Piratesmack looked in to the same possibilty and together we pooled our resources and after running many scripts and testing by myself Piratesmack compiled some dependency free deb. packages.

Piratesmacks Beryl 0.2.1 deb. packages for Ubuntu 9.04
http://files.filefront.com/beryl+fixed+904tarbz2/;13596520;/fileinfo.html

Save to home directory

extract tar.bz2

cd beryl-fixed-9.04

sudo ./install.sh

Piratesmacks Beryl 0.2.1 deb. packages for Ubuntu/Mint
http://files.filefront.com/beryl+packages+021tarbz2/;13508777;/fileinfo.html

Save to home directory

extract tar.bz2

cd beryl-packages-0.2.1

sudo dpkg -i *.deb

Beryl 0.2.1 on Ubuntu 9.04
http://s266.photobucket.com/albums/ii256/Linux_Ubuntu_geek/?action=view&current=Screenshot.png

Beryl 0.2.1 on Mint 6
http://s266.photobucket.com/albums/ii256/Linux_Ubuntu_geek/?action=view&current=Screenshot-1.png

One thing you cannot do is knock the simplicity of Beryl and how much more useful it is than modern day Compiz.

So for those who wish to mock I say Beryl is far from dead and people want it as they are downloading it for the very reasons I have outlined above.

LUg.

New blog

2009-05-14T09:24:24+00:00

Here is my new blog: http://lizards.opensuse.org/author/cyberorg/ update your feed bookmarks to point to the new location

Untitled

2009-04-25T23:59:22+00:00

Compiz is being ported to c++, and this (as well as the usual problem of time) has lead to a temporary postponement of work on jasper. To say that "it lead" is probably a bit deceptive, as I had not made commits for quite a while before the port was announced - but my intention is (in due time) to rewrite it (or, rather, write it again) in c++. Also, since compiz is now a reparenting wm, I have to look into how that affects the decorators. Hopefully, c++ will make it easier to do what I want (which I was having difficulty doing originally, which started the long period of no-commits)

In order to get better acquainted with c++, I started another plugin: tag. This is based, somewhat, off a feature request on the forums.

The idea is that the user can create a number of tags, and assign various tags to different windows. Each tag is either activated or deactivated, and a window with an active tag is considered active (the window with focus is also considered active). Non-active windows are drawn translucent, while active ones are drawn opaquely. Activating or deactivating a tag will restack the windows, so that active windows are sitting on top, while non-active windows are below - the original stacking order is maintained (apart from the active ones are pulled to the top).

There is a slight issue with this, in that it wouldn't work without patches to compiz's stacking code. Unfortunately, these patches haven't yet been committed to compiz, but if anyone is using master and wants to test them they are here (one and two).

There is still some things to do:
- Currently when you entering a tag, things don't work like they should if you press space or shift, etc. I need to copy some code from scalefilter to make this work properly.
- Currently, the only way to create tags, add/remove tags to/from windows, activate/deactivate tags, is by pressing a keybinding which grabs input and catches what you type (nicely displaying it on the screen at the same time). Ideally, you should be able to use Dbus, or add a specific keybinding to say, activate tag foo. The first should already be possible (except dbus isn't yet ported), and the second will need some reworking of the options code (which I hope to do, one day...)
- Let other plugins extend what tag does. For instance, another plugin could use the active status of a window (or whether it has a specific tag, etc) to decide whether it should be, for example, displayed in a scaled mode on the side of the screen, or as a normal window. On the other hand, other plugins should be able to influence the active state of the window (eg, if it is focused, some match rule things, etc)
- Automatically adding tags based on rules (eg, I could make a rule to tag firefox, xchat, pidgin as internet, and another rule to tag gnome-terminal and gedit as dev). At the moment all windows are just tagged with "default"
- Whatever I have forgotten
- Something about tiling?

I've also been accepted for Google Summer [or, rather, winter] of Code. Peter Hutterer will be my mentor, and I'll be working on getting input redirection in X :) So, if my work goes well, we will hopefully have IR next year.

Also, for those with ATi cards, dri2 is working almost very nicely :) Thanks to the work of Dave Airlie and Jerome Glisse (and others). Unfortunately, since I am using compiz master, I have no cube + glxgears to show-off, but it does work very beautifully in scale mode. [though, I don't think I really want to use the word beauty: "Don't use words too big for the subject. Don't say 'infinitely' when you mean 'very'; otherwise you'll have no word left when you want to talk about something really infinite." - C.S. Lewis]

I love spinning my cube round and round and round…

2009-04-15T06:39:34+00:00

Enjoy!

Edit: You’d need to click on post link to see embedded video if reading this from planets. More videos here.