KWin tiling is merged

I'm glad to announce that yesterday the kwin-tiling branch was merged into kwin trunk by commit 1118677!. It will be available in KDE SC 4.5. Please keep in mind that it is an experimental feature with rough edges. Bug fixes are already on the way, but some things, like session saving and so on are absent. Please do add feature requests and bugs to the KDE bug tracker.

This screencast should show off a few things. Apparently xvidcap produced really bad video, so I will have to do it again, watch out for updates here.

Thanks to Martin Graesslin for being my mentor during Season of KDE, and all the others who bugged me with emails about when tiling would be integrated into KWin :)

GSoC results now 13 hours away...

( Mamma, I'm not stressed out :-) )

Trending

Twitter usually syncs with the (developed) world pretty fast in hashtags. But I'm surprised Copenhagen is not on it.

To add some semblance of code: I've been mucking with node.js and some of the effect is simple TagLib bindings with that being used for something more important soon. Much improved ( or rather simplified ) kwin-tiling too with a few regressions like moving and resizing.

Tiling screencast

With a lot of requests to see tiling in action, I've uploaded my first ever video. Unfortunately I couldn't get my microphone to work. There are also a few glitches, forgive me for that.

Dynamic layouts are here

kwin-tiling now features dynamic layout switching per desktop. Use Meta+PgUp for Columns and Meta+PgDn for Spiral. Watch the windows change their place on the fly!

A few bugs in both the layouts are also fixed. Overall kwin-tiling is pretty stable for now, so give it a whirl and notify me of any bugs you can find.

What it still lacks is Xinerama awareness, but otherwise its virtually feature complete for the first release.

Unfortunately since college has begun I've been able to work on Kwin for only a few hours a week, so progress is a bit slow.

But the good news is that since GSoC is over, we should start seeing loads of new features being integrated into trunk/ to play around with.

KWin tiling progress

Between yesterday and today I made quite a lot of changes in kwin-tiling. Layouts now have a superclass which manages certain things. Each desktop now has its own layout. The root tile is no longer stored directly by the workspace, instead the workspace stores layouts for each desktop. For now each desktop has the Spiral layout, but it should be possible to dynamically change layouts for each desktop a few weeks down the line. Right now the plan is to fix certain layout issues ( such as spiral not understanding when a window is removed and adjusting the next one properly ).

The other major change is that cross virtual desktop moving is now supported. This was a major problem when it first arose, but once the first change was implemented, it was simply a matter of removing a tile from the old desktop and adding it to the new desktop.

There is no screenshot because none of these changes can be shown in a static image. But you can always try using the branch!

In other news I'm back in college. The third semester began yesterday, which means development time is now seriously down. I hacked on a (cool?) tool in the last two weeks, and I'll be announcing that soon. I'm also planning to add my blog to PlanetKDE.

The little things screw up

I had this really weird bug in kwin for half a week. When you started resizing windows, all of them would start dancing about the screen. There would be little gaps between them and so on. And I couldn't figure out why. So today I finally tried comparing ( x + width ) and ( right ) of a window. Turns out they are always off by one. So to the QRect::right() documentation:

Returns the x-coordinate of the rectangle's right edge.

Note that for historical reasons this function returns left() + width() - 1; use x() + width() to retrieve the true x-coordinate.

Argh! That ( and bottom() ) was causing the mess. What a relief.

KWin tiling ratios and orientations...

... now with minimize support.

KWin tiling has been proceeding forward at a steady rate. If you check out the latest revision, you will not only have a pretty stable experience, but will also get a design document for free.

So orientation is horizontal and vertical, and ratio is how much space the left child gets. Using these two properties I expect to be able to do most layouts. For now you can use D-BUS calls to actually use tiling pretty well.

Here are the calls

qdbus org.kde.kwin /KWin slotToggleOrientation
qdbus org.kde.kwin /KWin slotSetRatio <float> # between 0 and 1
qdbus org.kde.kwin /KWin dumpTiles  # get a nice tree if you have debugging enabled and visible

Some applications will cause trouble. Especially some plasma widgets and Kruler aren't setting the right window attributes, so I can't exempt them from tiling. So don't launch panel settings or Kickoff menu, it won't look so well.

Minimize and restore works now, it will keep track of where the window was before you minimized it and put it back there.

Please leave feedback about bugs here or on the KWin mailing list, it will be appreciated.

Kwin : tree based tiling

In the quest to implement tiling in KWin, I've decided to use binary trees as an internal representation. This morning, I hacked on it to produce a decent prototype, just to check if the idea would work well enough, without introducing too much complexity in the code. At the moment, it does tend to crash or have repaint issues once in a while. But it works, and it does what tiling is supposed to do. Of course there is a lot to do yet. Moving and Resizing remain particularly icky because so many choices about what is good as a default, what is expected, how to implement it, will have to be made. If you are adventurous enough to try the kwin-tiling branch, do not move the windows, or basically abuse it in anyway :)

KWin preliminary tiling

Yesterday I committed code which adds a semblance of tiling to kwin. Every time you launch a window, it will be maximized vertically, but each window shares the width of the screen equally. You can check out code from KDE svn. The location is /home/kde/branches/work/kwin-tiling/

You'll need to edit $KDEDIR/share/config/kwinrc and set Placement=Tiling.

Then you are ready to go.

Right now there are no configuration options, no key bindings, nothing! Still a long long way from a functional release.

Please leave feedback and bugs.

May updates

I'm home! Till almost the end of July I'll be @ home. Which means a better internet connection at the very least :p

So I've been swimming and learning to drive! Driving is fun, I've finished five days out of the 22 and I've managed not to hit anyone or anything.

In programming, I'm working on a game using Canvas for the CodeChef game contest. You can track its progress on github.

Also I've been doing some C socket programming, mainly doing segmented multithreaded HTTP downloads. Right now all the code is prototype, but someday it will be a decent download manager.

I'm also working on implementing tiling in KWin along with Martin Graesslin, my mentor. Right now there isn't much real progress apart from a KWin branch which maximizes every window you open.

And yesterday I got a copy of Real World Haskell. Yay!

Proposal for Tiling support in KWin

*Note to my normal blog readers, this post may not be of interest to you

Abstract:
This project will add a tiling layout mode to KWin. Tiling window managers displays all windows on the desktop at once, side by side. This allows easy navigation and allows tasks shared across applications to be carried out effortlessly. Unfortunately it is usually presented as a power user option. This will be an attempt to make it more accessible to new users.

Name: Nikhil Marathe



Email Address: nsm.nikhil@gmail.com



Freenode IRC Nick: nsm



Location (City, Country and/or Time Zone): Mumbai, India ( GMT + 5:30 )



Proposal Name:
Implement support for tiling in KWin



Motivation for Proposal / Goal:

Tiling is a very good way to view multiple tasks/windows together. This is well
suited for tasks like writing reports where you can keep looking at references, or watching multiple pictures/videos and even programming. Fast window
switching via the keyboard also improves productivity and decreases needless
Alt+Tabbing. Although tiling window managers have existed for a long time, KWin
does not have this feature. It has been requested for a long time now too ( https://bugs.kde.org/show_bug.cgi?id=59338 ), and
will be useful for those who want to use KDE yet still want a tiling WM.
In addition tiling WMs have always tried to appeal to power users, leaving a gap for the new user to jump. They eschew the mouse and more often the configurability, while available in abundance, often requires scripting. My belief is that the tiling mode should be an intuitive and friendly user experience and should be offered to the new user as a must-have feature.

Goals:
* Provide an intuitive tiling mode, with different layouts ( like Awesome ) and
support for certain floating windows.
* Expose a D-BUS API for tiling so other applications, including Plasma can hook into it.
* Use compositing and the mouse wherever possible for a fluid experience.
* A feature where windows dragged to the edges will automatically resize themselves to half the screen size as suggested here http://lists.kde.org/?l=kwin&m=122749581132588&w=2 . Of course this could be extended and made more powerful.
* Marking/Selection - Move/tile only certain windows.
* Tiling Stacks - An entire set of
windows could be pushed back, brought in front or moved, each preserving there tiled layout. This could easily be extended to work across multiple monitors.
* Another UI feature that I would like to bring in from 'Present Windows'. The user should be able to select windows by typing a certain filter for the window titles. So a search for Dolphin followed by a keystroke would only tile dolphin instances, leaving xchat floating in the centre.

Implementation Details:

My goal would be to implement a complete tiling solution for KWin. This would
involve:

* Communicate with KWin team and community feedback, along with some help from the KDE Usability team to decide how best it can be made user friendly.

* Add tiling code to the core, including new Placement modes, support for Stacks, session management and screen edge gestures. ( Currently when a window is being moved, edge gestures are still passed on to KWin which rotates the desktop or something else. I'd like to intercept these if the user says so to enable tiling )

* Tiling architecture would be somewhat based on Awesome. Awesome is well engineered and well commented, and some of its principles can be adopted into KWin's tiling mode.

* Ensure tiling plays well with layout commands like Cascade or Unclutter or Present Windows.

* Add marking/selection and relevant key bindings.
Marking would be light weight, relevant only for the current window motion, while a Stack would be more permanent. This would use something like the resize geometry display box or if compositing is enabled, tinting or some similar effect.

* Add D-BUS API.
* Is tiling enabled?
* Available layouts, current layout.
* Switching layouts
* Stack awareness.

* Add configuration options for movement, shortcuts to layouts.
This would be intuitive. The shortcuts would only be active in tiling mode and not clash with application shortcuts. For example. in a multimedia keyboard Next would go to next track in Amarok, but Meta + Next would go to next layout or next stack.
Mouse (especially the scroll wheel) would be used extensively to do almost anything the keyboard can.

* Implement panel applet and plasma grouping by editing relevant taskbar code and leveraging the D-BUS API.

* Allow certain windows/applications to preserve their tiling by using KWin's Special Window/Application settings.

* Write user documentation, fix up bugs.

Tentative Timeline:

now - May 23rd : Understand relevant KWin code. Use KWin less, use a tiling WM more. Read KDE documentation, interact with the mentor and
community. Investigate entry points into code. Design the project and plan how the user interface should behave in
tiling mode.


May 23rd - June end: Attempt to implement the core completely. This includes the main tiling
components, the D-BUS API, working well with Plasma and so on. This will include
testing and bug squashing. Have a working tiling mode by the evaluation period.

July : Implement configuration dialogs/options, write user documentation, make the UI
sensible. Implement non critical features such as compositing support, bells and whistles.

August 1-10th: Fix remaining bugs, wrap loose ends, test test test.

Do you have other obligations from late May to early August (school, work,
etc.)?:

My 3rd semester begins in the last week of July, which means I'll have
a bit less time ( around 25 hours a week ) towards the last two weeks of coding. Therefore I will attempt to finish almost all
of my proposal by the end of July.

About Me (let us know who you are!):

I'm 18 years old. I study in Gandhinagar, India. I'm pursuing
a B. Tech. in Information and Communication Technology at DA-IICT where I'm in
the first year.

I've been programming and using Linux for about 6 years now. I'm fascinated by
all the areas of computing, including compilers, operating systems, graphics and
web design+development. Python is the coolest language for me, although C/++

comes pretty close. I have significant experience in Qt ( including the new MVC
architecture ) - having developed a local network instant messaging client using
it.

A complete list of my projects can be found at
http://22bits.exofire.net/browse/code

KDE has been a really great piece of software for me ever since I first used
version 3.2. I've always been a fan of its configurability and the momentum and
innovation in the KDE community, and KDE 4 totally took it to the next level.
Okular and Amarok are the killer applications for me. It has been a kind of
dream to work on KDE someday. Unfortunately I could never participate in GSoC due to age restrictions. I also didn't have the experience to enter such a huge project until last year, but now I'm ready to become a full time contributor to KDE.

When not in front of the computer I also love playing football ( soccer ).
Otherwise I can be found reading or listening to music.