czeidler's blog

Results: S&T Evaluation and Web Survey

Blog post by czeidler on Tue, 2013-09-24 00:27

Most work on my PhD thesis is done and I like to provide you with the results from our research at Uni Auckland on Stack & Tile. At BeGeistert 023 (October 2010) I conducted a user evaluation of Stack & Tile to answer the question whether stacking and tiling within an overlapping window manager bring any benefits to the user. At the end of last year I used a web survey to investigate if and how Stack & Tile is used by actual users. The results of both studies have been presented recently at the INTERACT'13 conference in Cape Town. INTERACT is an A ranked conference for Human Computer Interaction (HCI) and hopefully I was able to interest some other researchers in Haiku. Thanks again for all participants of the evaluation and the survey!

The encouraging results are summarized in the following. The complete paper can be found here.

Stack & Tile Evaluation (BeGeistert 023)

We investigated the benefits of Stack & Tile's stacking and tiling features in a traditional overlapping window manager. Therefore we looked at use-cases where the user is working with documents of the same or of different applications, and a use-case where data is exchanged between documents of the same application, and designed experimental tasks accordingly. Another task measured the time needed to switch between different groups of windows.

In a controlled experiment, we found that stacking and tiling features can significantly improve completion times for tasks involving several windows (of the same application as well as of different applications). Furthermore, switching between different tasks was found to be much faster when windows were grouped by task using Stack & Tile. Setting up a Stack & Tile group is an initial overhead that may prevent users from using these features. However, the potential time savings as well as questionnaire answers indicate that the advantages outweigh this overhead.

Stack & Tile Web Survey

Stack & Tile is already integrated into Haiku for over two years, and thus is already exposed to a large group of developers and users. This allowed us to target another interesting question: How are stacking and tiling features used and accepted by real users? In a web-based survey we asked the Haiku community about their opinions and experiences of Stack & Tile. From 146 responses we got a detailed insight into how, how often and for what applications Stack & Tile is used.

There was a wide agreement that Stack & Tile can be useful, especially by participants who had used Stack & Tile before the survey. The stacking feature was perceived as being slightly more useful and also estimated to be used more than the tiling feature. We found that people were using the stacking and tiling features for a multitude of different use-cases, e.g., programming, browsing or file management. In a field for general comments many people wrote that they like Stack & Tile and suggested further ideas to integrate it more into the desktop. These ideas include future works such as grouping of windows by their Stack & Tile group in the taskbar and Stack & Tile group persistence.

Stack & Tile web questionnaire closes on Sun 23/11/12

Blog post by czeidler on Mon, 2012-12-10 23:06

Thanks to everybody who has participated in the Stack & Tile web questionnaire! We have got much more participants than we had expected! So far there were 140 complete responses. I think this is great number! From these 140 participants there were 75 who had already tried S&T. It also shows that the Haiku community is not that small at all. This should be quite motivating for all developers :).

The questionnaire closes on Sun 23/11/12. So if you haven't participated yet but you are willing to fill the questionnaire please do so before this date.

Stack & Tile web questionnaire

In case you have already participated but you have some more interesting screenshots of how you use Stack & Tile feel free to send them directly to me ( Thank you!

UPDATE: the database is up again and the survey is working now.

Stack & Tile web questionnaire

Blog post by czeidler on Fri, 2012-10-19 19:55


as part of my PhD thesis at the Uni Auckland I would like to do a web survey about Stack & Tile.

Stack & Tile (S&T) is an extension of the window manager used in HAIKU. S&T allows the user to stack windows on top of one other or tile windows beside each other.

With the questionnaire we would like to gather some information about how and how often people are using S&T. Even if you never tried S&T before or you don't know S&T at all, we have some general questions for you and we are interested in your feedback! If you don't know S&T please take a look at the Haiku user guide *).

In the questionnaire you are asked to upload some screenshots as examples of how you typically use S&T. If you want to provide some screenshots please take them beforehand to avoid eventual problems with the web questionnaire (e.g. timeouts).

To participate click:

Stack & Tile web questionnaire

Thank you for your help!

*) Haiku user guide (S&T)

ALE (Auckland Layout Editor)

Blog post by czeidler on Mon, 2012-09-03 09:49

Recently I spend some time to develop ALE the Auckland Layout Editor and now it's getting time to release a first testing version! ALE is a tool for developers to create GUIs. These GUIs can then be loaded from an application. This first version is still very basic and I hope I can get some feedback what can be improved and which features are most needed. It mainly focus on layout creation and less on editing view properties.

While working on user interface customization it turned out that the step to creating a GUI builder is not that big. When changing a layout at runtime the user must be able to move existing views around, insert them between other views or swap the position of two views. Furthermore, it should be possible to temporary remove unused views from the layout and add them again at a later point. It is also important that the user can't create invalid layouts. For example, views should never overlap each other and the layout must stay solvable. What is missing for a GUI builder is that new views can be created and added to a layout. Furthermore, it must be possible to save and restore a layout and access the items from within an application, i.e. get a pointer to the c++ object.

ALE is a constraint based layout editor that based on the BALMLayout layout class. BALMLayout is a very powerful constraint based layout and can describe layouts that can't be described with other layout classes, like for example the grid-bag layout. Layouts created with ALE are automatically resizable and overlap-free. This means while editing a layout you can't create a layout that has two overlapping views.

ALE has a component factory that can be used to create GUI elements, e.g. buttons or text views. Each view in the layout gets a string id which can be changed in the editor. After the GUI developer designed a GUI the layout can be saved into a BMessage and be attached to a GUI specification file. From the c++ application this BMessage can be read and restored using a LayoutArchive class. This class also allows to map the string identifier of a view to an actual c++ object.

A test version of the editor can be downloaded from *) This is a debug version and relatively large. If you want to take a look at the source code, it is on github **). I you want to build it please come back to me and I will give you some more information about that.

There is also a very simple sample application in the Demo directory. This piece of code shows how to get a pointer to the objects in the layout. To build it just call make in the demo directory. It is using a GUI specification file called TestLayout which is also in the Demo directory. This file must be in the same folder as the app binary file is. Furthermore, it can be opened in the editor to change the layout or add new views.

Known bugs:
- some crashes
- explicit sizes are not stored at the moment
- the layout min size is not restored from the layout specification, this means overlap can occur in your app.

thanks for testing and feedback is welcome!


Decorators and Stack and Tile

Blog post by czeidler on Mon, 2012-05-21 21:40

Just saw on Haikuware that there is another GUI for setting a decorator. First, I'm happy that people are actually using this "hidden" functionality to write custom applications. However, after Alpha 3 I changed the decorator API which broke all other decorators.

The reason for that is that the stacking feature of Stack and Tile is now integrated into the decorator. In other words all decorators have to support Stack and Tile now! Stacked windows share the same decorator and the decorator is responsible to display multiple tabs. This has the advantage that the developer has more freedom to design the appearance of the tabs. Furthermore, tabs can be arranged more flexible. For example, you can add the stacking features to the Amiga decorator by drawing the tabs beside each other into the title bar.

Updating the existing decorators is not too difficult but it's a bit of work. First, most decorator methods take a tab index now which has to be handled correctly. Secondly, the decorator must be able to somehow draw multiple tabs.

If you are interested to port an alternative decorator to the new API and so make it support Stack and Tile take a look at Decorator.h header and the DefaultDecorator *).

Status Report (Stack and Tile)

Blog post by czeidler on Mon, 2012-05-14 23:31

Having started my PhD at the University of Auckland two years ago I think it's time to provide a brief overview for the Haiku community about what I am doing here. Since a complete overview would result in a pretty big post I intend to split it into multiple smaller posts. Fingers crossed that I remain motivated enough to keep writing :).

The topic of my PhD is "User Interface Customization" and covers three aspects. First, customization in the large which targets the management of multiple windows of different applications using Stack and Tile. Secondly, customization in the small. Here I take a look at how customization can be effected within an application, especially how the user can change the layout of an application at runtime, e.g. to optimize an application for his special use-cases. Finally, I'd like to take a look at how far it is possible to also let the user customize the functionality of an application, e.g. connect a button click event to a new component that plays a sound effect to emphasize the importance of the button clicked event.

Stack and Tile

Stack and Tile is now integrated into the Haiku app_server and is enabled on default. There are two main operations in Stack and Tile which are, guess what?, stacking and tiling. Stacking allows the user to stack windows on top of one another and tiling allows the tiling of windows beside each other. To do this, just press the Windows key while dragging a window:
a) by the tab onto another window tab to stack them or
b) beside another window to tile them. In this way it's possible to create complex groups of stacked and tiled windows.

The main purpose of Stack and Tile is to make window management easier and working with multiple windows more efficient. When using multiple windows on the same desktop the user frequently runs into the problem that windows occlude each other. To make the occluded parts visible the user has to move other windows aside or bring the occluded window to the front. All these operations can result in more occlusion of other windows. This problem can makes window management quite tedious. Another problem arises when working on multiple tasks in parallel. For example, if one task is a programming task and involves multiple editor windows and a terminal, and another task uses a browser and a mail application, while a third task has a word processor and tracker window with related documents. Switching from one task to another could make it necessary to activate all windows of a task. This can be done by bringing the windows of a task to the front or moving unrelated windows aside. The more windows which belong to a certain task, the more window operations are needed to bring all windows of that task to the front thus slowing down task switching.

Stack and Tile provides a solution to these problems. Windows in a Stack and Tile group are not occluded at all if they are tiled, and windows are completely occluded if they are stacked. This solves the first problem that windows are fully or partially occluded. Tiled windows in a Stack and Tile group are always visible and stacked windows do not occlude other windows unintentionally. Furthermore, the problem of task switching is targeted, activating one window in a Stack and Tile group brings the complete group to the front and thus switching between Stack and Tile groups is very easy.

User Evaluation

To evaluate how Stack and Tile performs compared to the traditional window system a user evaluation has been done. During BeGeistert10 many of the attendees participated in this evaluation. Thanks again for that! The results have been very positive. The measured task completion time and task switching time have been significantly lower using Stack and Tile than under non Stack and Tile conditions. Furthermore, the setup time to create a Stack and Tile group is acceptably low and does not outweigh the time saved while using a Stack and Tile group.

There were four different groups of tasks:
1) Window switching between windows with unrelated content of the same application (e.g. a stacked group of pictures).
2) Window switching between windows with unrelated content of different applications (e.g. a stacked group of a pdf viewer, a browser and a text document).
3) Window switching between related windows (e.g. exchange data between text documents which are tiled beside each other).
4) Task switching between multi-window tasks.

In all tasks Stack and Tile was superior to the non Stack and Tile setup and on average participants were able to complete the tasks much faster. If somebody is interested in more details I'd like to publish a more detailed summary at a later point.

Future Work and Session Management

Although I have finished working on Stack and Tile as part of my PhD there are still many ideas around to improve Stack and Tile and integrate it further into Haiku. There are, for example, ideas to show Stack and Tile groups in the Deskbar, merge two different Stack and Tile groups, or make the Stack and Tile key customizable. Moreover, there are still some drawing bugs which should be fixed one day.

Personally, the most important missing feature is to make Stack and Tile groups persistent. This means Stack and Tile groups can be reloaded or can be restored after a Haiku restart. To implement that functionality the states of all windows of an application in a group and the Stack and Tile configuration of these windows must be stored. At first, that sounds not very difficult but is actually quite complicated and can not be
implemented using the current Haiku API. The first problem is that a stacked or tiled window is not the main window of an application. Just starting an application would not give the right window in this case. The second problem is that windows in Haiku have no ID and cannot be identified after an application restart.

To solve these problems a new API has to be introduced that allows for storing and restoring an application state. When storing an application state each window of the application gets a unique ID which can be used by Stack and Tile to store the group configuration. To restore all Stack and Tile groups after a reboot, first all applications have to be restored and then all windows have to be stacked and tiled again.

A base implementation of a session manager that also is able to restore Stack and Tile groups can be found on github *) There was also some discussion about the session manager API on the developer mailing list a while ago **)
As I have not much time to work on any of these, volunteers are welcome!

*) (SessionManager branch)

Syndicate content