User Observation Hackfest

User Observation Hackfest

A couple of weeks ago, I was in Florida with another bunch of awesome GNOME contributors for the User Observation Hackfest, held together with the openSUSE Summit.

Other people already wrote some reports about the event, whose central part was a day trip to the City of Largo; the administration of the city has one of the biggest public GNOME deployments, with hundreds of users daily doing their work from SUSE-powered thin clients. For me it was a very interesting experience, mostly because I’ve never seen such a big GNOME deployment in reality, and being a developer, I am pretty new to this sort of systematic user testing.

We put together some transcriptions and notes from the interviews we did at Largo, which I now made available on the GNOME Wiki. I look forward for these being useful in improving the pattern language we use to design user interaction in GNOME, and in helping shaping the new HIG people have been working on for a while.

My most sincere thanks go to the sponsors of the event, without which all of this woudldn’t have happened.

By the way, this weekend I’ll attend the GNOME Boston Summit, where we are also hosting a set of sessions specifically for people who want to start contributing to GNOME. See you there if you happen to be in town!

Wacom tablets in GNOME 3.6

Following up from Bastien’s previous reports, GNOME 3.6 will ship with another whole set of new features for Wacom tablets support, thanks to the work of my colleague Olivier Fourdan.

Video demo


Olivier demonstrating the new features.

What’s new

A lot of work has been put in making the user experience flawless and working as expected with complex and multihead monitor layouts. In particular:

  • Wacom input devices coordinates are now automatically translated according to the monitor layout reported by Xorg (using XRandr). In a nutshell, this means that if you change display configuration or layout, and one of the displays is a screen tablet (or a tablet bound to a specific display), such changes are automatically propagated to the tablet pen devices, which will keep reporting the right coordinates.
  • Screen rotation is now correctly mirrored in the input device coordinates. Again, this is all automatically taken care for the user; for bonus points, the left-handed orientation flipping of the tablet, as set by the option in the panel, will be taken into account when rotating the input.
  • Related to these, we now have an option that allows the users to change how the screen aspect ratio influences the active input area on the tablet. By default, we map the whole input pad to the screen area, even in case they differ in aspect ratio; the new option allows instead for the active area on input pad to be cropped to the same aspect ratio of the display.
  • Last but not least, it’s now possible to map a “Switch Monitor” action to a device button, that is, to change the output a tablet is bound to on the fly directly from the tablet itself! This will make it very easy to do complex operations involving multiple monitors without having to go to the settings panel every time.

What’s next

GNOME 3.6 hasn’t been released yet, but we’re already planning features for the next 3.8 development cycle. In particular, a great feature demonstrated in the video, which I’m really looking forward to, is the introduction of an on-screen-display showing the layout of the tablet buttons, and all the action shortcuts associated with them. As you can see, the OSD itself is multihead and left-handed orientation aware.

Thanks a lot to Olivier and all the other developers who made all of this possible!

GTK and CSS updates

I’ve written before about the powerful GTK3 CSS engine that drives the appearance of our favorite desktop OS.

Since my last post on the topic, GTK 3.4 brought in a lot of improvements, including among the others, support for most of the properties of the CSS3 backgrounds and borders family, linear gradients and the long requested inactive windows theming feature, which is showcased in GNOME 3.4.

Inactive windows theming

In the meanwhile, work didn’t stop on the development branch of GTK, and Benjamin, after improving the performance of our CSS parsing/caching engine by a factor of 10 or so, implemented support for transitions. CSS animations are around the corner too, and GNOME 3.6 will make use of all this goodness for a look cooler than ever!

Another feature that will be in GTK 3.6 is support for multiple layers of background images for a single element, as specified by CSS3; in other words, where you could only render a gradient or a solid color before, you can now render an unbounded set of images and patterns. If you combine this with the other CSS3 background properties, and transitions, the possibilities of what you can do are basically endless! Code for this is already in the GTK master branch, so go grab it and play with it while it’s hot!

This is a video I made to demonstrate these new features, enjoy :)

Introducing Documents

Many people asked me at Desktop Summit about the work I’ve been doing recently on implementing the awesome Documents designs from Jon and Jakub; so here it is, I am very happy to announce the first release of GNOME Documents. Here’s the obligatory screenshot.

The application makes full use of the latest 3.0 platform technologies: it’s written in Javascript thanks to the awesome GObject Introspection, it uses Tracker to read and store information about the documents on the system, integrates with GNOME Online Accounts for accounts and credentials, and ships with a Tracker miner for Google Docs, powered by libgdata.

Some of the design features are already in place: searching, grid and list view, the Favorites and Shared categories, document preview, and opening in browser for Google documents.

Of course, on the other hand this is just the very first release of the project, so there’s a lot still missing and rough edges to be fixed. If you want to help, feel free to reach me on IRC!

Berlin Fever

I am very excited I’ll be flying to Berlin this Friday to drink ice cold german beer attend the Desktop Summit.

If you are interested in theming and the huge improvements GTK3 and CSS have to offer on the matter, make sure you don’t miss my talk Sunday morning at 10:20. Coffee not included.

See you in Berlin!

Desktop Summit 2011

Hotplug hotness

Back in the GNOME 2.x days, device hotplug management was done entirely by Nautilus; you know, those dialogs that pop up when you plug your photo camera or your USB drive. This worked fine, as Nautilus was always running in the session, being it also the process drawing the desktop. The desktop itself provided a way to eject the devices, by right clicking on their icon and selecting the appropriate menu action.

In the 3.0 era Nautilus moved away from being a central component of the user experience, and if you used GNOME 3, you will have seen we actually dropped the desktop metaphor by default already; that unfortunately left us with no place to access the list of devices plugged into our machine; in fact, in 3.0 you have to open Nautilus manually to eject an USB drive. Also, the code for handling autorun notifications was moved to gnome-settings-daemon, which will trigger the old-style GTK+ dialog when a device is plugged in.

Clearly, we could do a lot better. A while ago I started a design whiteboard page to analyse the current state of the art in this area, and last week I finally sat with Jon thinking about the user experience we want to achieve here. You can read more about it in the tentative design section of the whiteboard page.

Shell Integration

We decided to implement the feature with using notifications in gnome-shell

When a new device is plugged, the shell will trigger a notification (after having consulted the settings from the ‘Removable Media’ panel in gnome-control-center) containing a list of applications suitable for handling that device. This is similar to what we used to have in 2.x; if you plug in a blank optical disc, you will find “CD/DVD Creator” (Brasero) in that list, if you plug an iPod we’ll show “Rhythmbox” or your default music player, if you plug your photo camera Shotwell will be shown…you get the idea; you can also eject the device directly from the notification.

After you dismiss the notification, you will be able to access the list of your devices from the message tray, which will grow a ‘Removable Devices’ item as long as there’s at least one device connected to the system.

From this menu you can still activate the default autorun action by clicking on the device name/icon, or you can eject it, by clicking on the button on the right hand side. If the device cannot unmount, due to a file still open on it, we will show a nice dialog from where you can get to the application directly, or force unmount if you prefer.

Generic drives

One problem the 2.x implementation didn’t really tackle is what to do when generic drives (like, say, an external hard disk, or a random USB pendrive) were attached. I believe the default was just to run Nautilus in those cases, or worse, we would show a meaningless autorun dialog with no choices inside it.
In my new implementation, I wrote a small crawler program that gets DBus-activated by the mounter process (in this case the shell) and tries to gather as much information as it can about the content type of the files in the device. Of course, we don’t want to hammer your 2TB drive with a full scan, so the crawler has a hard time-limit not to do I/O for more than a fixed amount of time (I empirically found 1.5 seconds is a good value for this). The crawler doesn’t care about the specific mime type of the files (say, FLAC vs OGG) but rather what the file is about (say, Music vs. Video), so it will return a list of up to three “generic” mimetypes for the drive content, ordered by relevance; applications that claim to handle those generic mimetypes will appear in the notification. As a last fallback, if we don’ t have any of these applications available, we will show an entry to open the drive in Nautilus from the notification. This aims to integrate with the upcoming application design for Finding and Reminding.

What’s next

I need to post my current iteration of the patchset for review, but I already have some further improvements and polish planned in the pipeline:

  • we need to handle password-protected volumes (e.g. encrypted USB sticks) directly from the notification, e.g. having an entry there to unlock the device directly
  • we probably want to show an entry in the device list if the laptop is plugged into a docking station. Clicking the eject button there would be equivalent to pushing the hardware button on the dock itself.
  • we need to find a good story for fallback mode. I think we can just keep the current gnome-settings-daemon plugin in place, and activate it only if fallback mode is detected, but this is currently not implemented.

Adventures in the CSS land

Some time ago I blogged about a number of improvements which made its way into the GNOME 3.0 theme, thanks to the new GTK3 CSS-powered theming engine.

This cycle, Benjamin and I have been working on making the CSS parser in GTK3 more conforming to the W3C specifications, while adding some cool new features in the meanwhile.

What’s already there

  • The parser from GTK master will now report errors consistently when it fails to parse the CSS data, including the position in the data where the error occurred. This can be used nicely e.g. to highlight the broken line in an editor, such as Carlos’ nice gedit-cossa plugin (GTK master also recently grew a very simple live-editor too if you feel like toying with this).
  • It’s really easy to hook up parsing for new properties; CSS features such as inheritance and shorthand properties are now supported natively by GtkThemingEngine. Existing properties have been extended to be shorthands according to the CSS specification (e.g. border-width, padding, border-radius), and the non-shorthand versions have been added too (e.g. setting border-right will now do the right thing).
  • nth-child structural pseudo-class support have been extended to work for generic containers. GtkBox already supports this, with other popular containers (e.g. GtkToolbar) to follow shortly. This means it’s easy now for themes to visually connect contiguous borders.

New properties

We’re adding support for new CSS properties, to allow themes to specify subtle eye-candy directly from the stylesheet. Here’s a list of additions targeting GTK 3.2.

  • text-shadow is supported already in GTK master.

  • icon-shadow is a custom property which behaves similar to text-shadow for icons. It looks great with symbolic icons. It’s also generic enough to be used with icon-like UI elements such as arrows, spinners and whatnot in the future – git branch

  • box-shadow allows to render inset and outset frame shadows. Outset box-shadow support is unfortunately really hard to implement within the current GTK drawing process, so it won’t make it in 3.2.

  • border-image will be expanded to be a shorthand property as well, and match the CSS3 specification for drawing.

Considerations

CSS is huge and complete property coverage is not interesting for GTK. We plan to incrementally add support for new properties/pseudo-classes based on the requirements of the designs to be implemented; help/feedback is gladly appreciated. If you have a CSS attribute in mind that should be supported at the GTK level, please file a bug, possibly with a patch attached :)

We’re still carrying over a legacy of many per-widget style properties that specify paddings/borders; I think we should try to get rid of them where possible, and try to use standard CSS and style classes (e.g. to define different areas inside a widget) as much as possible: CSS is documented very well, and we can trust the specification for any semantic of the properties, not reinventing the wheel for every widget. This is a GTK4-ish goal, but I think it’d be great to start soon porting and deprecating.

I also think native theming engines should be as small as possible; ideally they should be able to get any desired effect using the CSS stylesheet only. This means the builtin GTK theming engine should be flexible enough for most of the use cases.

Sushi

With the 3.0 release out, I kind of wanted to breath some fresh air and try something new, so I decided to experiment a bit with GtkClutter and Javascript, which I’ve been meaning to for a long time. I ended up writing a quick previewer for Nautilus, a-la Quick Look.

Here is the obligatory screencast of what’s currently in git.

The content type viewers are implemented with a simple plugin system, which Javascript and gjs make it very easy to have. I plan to add other viewers in the future for at least plain text and font files, and it would be nice to also have HTML, source code files with syntax highlight and maybe archives.

Although I’m not completely familiar with it yet, I found the JS experience quite positive, with most of the introspected methods I tried using working out of the box. It’s also perfect for developing nice UIs much faster. The project has in fact a mixed C/Javascript codebase, with some low-level object helpers written in C + GObject and all the UI in JS, like other projects such as gnome-shell and The Board (from which I copied most of the autofoo/build infrastructure and some code to play audio files, thanks Lucas!!) already do.

How do I get it?

I didn’t make a release out of it yet, as it still has a few minor bugs, but it’s actually quite usable already, and you can try it by downloading it from here

http://git.gnome.org/browse/sushi

Note that you will also need the “previewer” branch of Nautilus I published here to enable Nautilus integration

http://git.gnome.org/browse/nautilus/log/?h=previewer

Once a release is out I plan to merge the Nautilus branch and start using it by default, if it’s installed.

Need more?

I have other things in the pipeline for Nautilus and Adwaita this next cycle, which I will write soon about, so stay tuned!

Adwaita 3.0 coolness

Quite a lot of things have happened in my life since I last had the occasion to write on this blog…the most important is I moved to Boston last January, to work in the awesome Red Hat Desktop Team. It’s very exciting and inspiring to work together with this great people, and it is even more cool these days when we’re all working hard to delivery the best GNOME 3 experience possible; I think it’s going to be great!

Here’s some of the things I’ve been working on in the last month I want to show you.

Nautilus 3.0

Allan has been doing a great job showing off the mockups for Nautilus 3.0 by the design team; the good news is that now those mockups are mostly implemented in the latest beta tarballs. Here’s how Nautilus from git master looks like

The most outstanding changes are the new streamlined toolbar, a new sidebar design, and the use of “floating” statusbars to reduce the UI chrome. Another important change is that “spatial” mode is now gone for good; we still allow opening new folders in separate windows, but we use a single UI now.

Adwaita

Adwaita is the GNOME 3 default theme, which include themes for GTK+ applications, the window manager, cursors and the background. In the last week I’ve been implementing the gnome design team mockups for the GTK+ theme, and I must say I’m quite pleased with the result. Here are some screenshots of what you get with the current theme (the Nautilus screenshot above uses the new theme too):

The changes are too many to describe them one by one, but notable improvements include toolbars, checkbuttons, radiobuttons, notebook tabs and treeviews.

We’re almost there, April 2011 is around the corner now…

Long time no blog

Hi there! It’s been a long time since I last wrote something on this blog, which reminds me how many things have happened in my life in the last year and a half.

As some of you might know, I’ve been working part-time for Collabora (on Empathy), helping fixing misc bugs and implementing nice things like file transfer, the accounts dialog user interface and the transition to the Mission Control 5 framework.

In the meanwhile I kept myself busy with my university and finally, last week, I took the last exam of my course! This means I’ll hopefully graduate on April :) Since November, I already started digging into my thesis, which will be aTelepathy implementation of the XTLS protocol, an end to end solution to crypt communication over XMPP.

In order for Telepathy to support channel encryption, some new interfaces need to be written. I drafted some proposals for this on the telepathy mailing list in the last few months, and I’m happy that Eitan Isaacson picked them up and turned them into something more concrete. In order to discuss with him and the rest of Collabora about the proposal, I’ll visit the Cambridge office at the end of the month, right in time to attend FOSDEM and the XMPP summit together with the Collabora gang.

After that, the items on my TODO list include:

  • draft a proof-of-concept implementation of the XTLS handshake into Wocky(I already started coding for this before I had to stop for my exams).
  • make sure the new Telepathy interfaces work fine in telepathy-glib
  • implement the interfaces into Gabble.

Hope to see you all in FOSDEM :)