Contributor Warbo

The emblems on icons give hints to the user about files and folders, however these mainly have to be added manually. Examples of more dynamic emblems are the read-only and symbolic link emblems.

I propose that more icon emblems be made which are dynamically allocated. These could even be animated and programmatically updated. Emblems could indicate things like:

* this file is being downloaded (with progress bar)
* this file has an unsaved version open
* this file is being accessed by another user
* this device is unsafe to remove
* this device is safe to remove
* a device's free space (as a progress bar)
* this version controlled folder can be updated
and so on

Applications could even add and update emblems on their own icons. For example:

* email programs could show an unread message count
* news programs could show an unread story count
* messaging programs could show a status icon
* messaging programs could show an unread message counter
* networked applications could show when they're disconnected
* editing programs could show if there are documents to be recovered
* downloading/transferring programs (like BitTorrent) could show a progress bar (or bars)

I would not go as far as allowing interactive elements (like play/next/etc. buttons on a music player) since these would interfere with the icon's main function, plus such things are more like full-blown applets/widgets/screenlets.

A nice benefit of this approach would be the ability to display a large amount of information completely in context (ie. only the information relevant to the displayed icons will be shown)

[....]

Progress bars are a nice idea, but they become pretty meaningless when they fill up, empty, fill up again, and so on since different tasks are running. Similarly, it is difficult to use a single progress bar to cover many tasks.

A nice progress bar implementation was used on the Amiga (and probably elsewhere) where there are two progress bars, one at the top for the current task and one underneath for the total task.

It would be nice to see a GTK/QT widget made which implements thi behaviour with a simple API and GNOME and KDE encouraging its use in applications where long-running, complex things are being done (like installing, for example).

The "breadcrumb" part of Nautilus (the string of buttons showing the folders above the current one) should have drag 'n' drop support, so that dragging files over them for a certain time changes the current folder view to that place.

For example, wanting to move files from a folder /home/user/Downloads to /home/user/Music would involve navigating to /home/user/Downloads, selecting the desired files, dragging them over the breadcrumb button for user's Home folder, which then navigates to that folder, where the files can be dropped over the Music folder.

As for what happens afterwards, either the original folder is shown again (Downloads in the example), or the Home folder is left, with the original folder available through the breadcrumbs.

A while back there were some ideas floating around on the Wiki about the login screen and the screensaver.

If I remember correctly this started it off https://wiki.ubuntu.com/ConsistentLoginScreen which discusses moving back to the login screen when input occurs during screensaver, but this seems a bad idea as it could be seen as losing the session by unknowing users.

After some thought this https://wiki.ubuntu.com/UnifiedLoginUnlock was made, which proposes a unified login screen for any time users need to log in (after bootup, when switching user & to unlock the screen) which seems more thorough.

Also proposed is this https://wiki.ubuntu.com/FaceBrowserLogin reworking of the login screen.

I feel that with ConsoleKit, GDM3, PolicyKit and all manner of DBus going on that these are ready for some prototyping. What are people's thoughts?

Since Ubuntu is now using PulseAudio, which gives volume control on an application by application basis, there is no need for multimedia programs to use their own volume control.

For instance, if I change the volume slider in Totem this shouldn't change an internal Totem volume, it should change the PulseAudio volume for Totem. The same with Rhythmbox, Amarok, etc.

Having multiple volume controls for the same thing can be really annoying, for example wanting to unmute some music and having to check the Rhythmbox volume, PulseAudio's volume for Rhythmbox, the master volume and physical speaker volume. To me the speaker and master volumes have an obvious reason to exist, but there seems to be no difference between the internal and PulseAudio volume control for Rhythmbox, hence they should be merged.

BTW I proposed this to a PulseAudio developer who said that this is one of the main reasons for having PulseAudio.

Some programs ask the user if they want to save files before they close and when the computer is shutting down. However, some do not.

For those which do the shutdown procedure can either be interrupted or the warning goes away too quickly to be useful due to the shutdown, especially if the application is on another desktop where the user can't see it.

For those which don't obviously data (and thus users' time) can be lost.

I think it would be a good idea to have a list of issues which might make the user think twice about shutting down present in the shutdown selection screen.

Part of the dialogue box would say, for example:

WARNING! Shutting down will interrupt the following activities:
Editing of unsaved document Essay.odt (save button)
Download of large_video.ogg (pause button)
Writing disc MY_SONGS (abort button)

This could perhaps be implemented in a similar way to http://brainstorm.ubuntu.com/idea/72/ Unmount Resolution (I am thinking DBus)

When a gecko-based browser opens a PNG which is too big for the window it can be shrunk to fit, with successive clicks on the image changing the size from normal to fitted.

It would be good to have this ability with SVGs, since an SVG is meant to be size and resolution independent anyway. SVGs with large default dimensions are currently annoying to view (for example http://upload.wikimedia.org/wikipedia/commons/7/77/Unix_history-simple.svg ). Implementation in a click-to-change-zoom way would be difficult for interactive SVGs, hence I think always rendering to fit in the browser window is best.

PS: I'd say the question of scaling up SVGs designed to be small is out of scope for this idea. I think SVGs with dimensions smaller than the browser window should rendered with those dimensions.

If a user does not have an Internet connection then the Restricted Manager and codec tools become pretty useless. This can be an issue if the Restricted Manager is needed for a Wifi card, for instance.

However, if the user doesn't specifically decline such drivers/codecs then they should be reminded when they do get an Internet connection.

For example, a user needs non-free firmware for her Wifi card, but can't download it since she can't use Wifi. Later on she tries playing an MP3 which doesn't work either. The next day she is at a friend's house and plugs an ethernet cable in to browse the web. Ubuntu should notify her that she can get the components she was trying to access earlier.

I think this would be a good idea because making users remember what they were after is unneeded when Ubuntu can do it, especially since they may have completely different things on their mind whenever a connection is available and thus not realise that their earlier problems can now be fixed. Also, a user might not be attempting to play MP3s at the exact time they have an Internet connection, but this doesn't mean they haven't been trying earlier, so Ubuntu should pick up on this.

Presence systems allow users to set arbitrary information about themselves, such as Location:Work, Mood:Bored or Status:Out for lunch, primarily designed for online services like instant messaging.

These settings, however, could be used by the system as well, in a two-way arrangement. For example:

* A user can tell the system to turn off or tone down notifications when their status is set to "Busy"

* A user can tell the system that when a 3G network card is being used then their location should be set to "On the train"

* Power saving settings can be told to become more extreme when the user sets their status to "Away"

* If a screensaver comes on then status can be set to Idle or Away, and vice versa

* If the screen is locked then status can be set to Away

* The system could choose a network setup based on the current "Location" and could set a "Location" when known Wifi networks are discovered

There are far more possibilities than I can think of, but the presence system of this could be done with Telepathy. Since Telepathy is accessed over DBus it wouldn't be too difficult to integrate some of this functionality.

This is a very preference based idea, so should have a suitable default state and configuration tool.

I booted into Hardy's new recovery mode to see what it's like, but to my dismay I say the phrase "X server".

I think that any user-facing interface (ie. not technical documentation) should use familiar, generic phrases rather than application names or brands, and for this reason I would like to see an effort to create a lookup table for understandable phrases.

For example:

X, X server -> Display, graphics system
apt -> Package manager, program installer
un/mount -> un/load, access, close/open
etc.

This is because a term such as "mount" is technical, and doesn't mean anything to someone who doesn't already know it, whilst terms like X or apt are program names which are only meaningful to those who know them. Since those who know what mounting is know that accessing a drive involves mounting it, the term "accessing" should be obvious to mean mounting. For those who know what apt and X are they will know that their graphics system is X and their package manager is apt.

I am NOT advocating a name change for anything here, I am advocating the use of generic, descriptive terms in user interfaces instead of unneccessary technical terminology or program/brand names.

New hardware accelerated toolkits like Clutter ( http://www.clutter-project.org ) and Pigment ( https://code.fluendo.com/pigment/trac/wiki/WikiStart ) make fancy effects easy to use, but also offer the ability to use subtle effects to increase the general feel of the desktop. For example, if a big thumbnail view is used in an application: would it be more pleasing for the selected thumbnail to bulge? Are smoother transitions/scrolls possible? How is the display populated/closed, could it be improved?

I think some investigation into these kinds of questions would be good. I wouldn't like to see "bling", ie. every button exploding into view, but adding useful abilities (eg. zooming) and removing the sudden, jerky transitions we are used to at the moment would make the whole desktop seem smoother and more polished.

Please try to remove the screen flickering in X when changing display.

Software from http://www.portableapps.com is Free Software for Windows tweaked and packaged up so that it runs from a single folder without needing installation, editing registry keys, etc. It is really useful to have on a FAT32 USB stick, since it gives access to familiar programs on any Windows machine.

These programs generally run under WINE, but there are a few small glitches like multiple PortableApps icons appearing in the notification area and not going away, etc. I think polishing up these few remaining issues would make general use of Ubuntu more enjoyable, especially since having Free Software with a "works anywhere" assumption that breaks down on a Free Software OS like Ubuntu can seem rather unprofessional.

Voters please keep in mind that the point of PortableApps is that it works on machines where this software cannot be installed. Using Add/Remove in an Internet Cafe, University computer lab, office, etc. is not an option.

When copying or moving files to somewhere that doesn't have enough space, an error message appears straight away saying that there's not enough space. However, if many files and folders are being copied, permission issues are only reported when they are encountered, and likewise with overwrite issues.

Copying files should be, as much as possible, a 'fire and forget' action, meaning that once it has been initiated it should continue until it's finished without needing the user's supervision. If the issues mentioned above are all reported at the start of the copy process, like the "not enough free space" issue is, then there would be less frustration at copying processes waiting for user input before carrying on.

Since this only involves file metadata (permissions for permission issues and filenames for overwrite conflicts), not the file's contents, it should be a relatively fast action to perform before copying.

As it stands animation support in toolkits only seems to involve moving around widgets (eg. Clutter, Pigment, etc.) and outside that there's not much else.

Trying to incorporate small amounts of animation that isn't just moving/spinning/rotating existing things seems quite difficult, for example the network manager applet's connecting animation and the Nautilus 'throbber' (which make the icon directories a mess of animation frames).

I think some thinking needs to be done to allow hand-made animations like these (probably frame based since animated SVG support is currently non existant) to be integrated more easily and more perform more efficiently (single image files rather than multiple? An efficient animation-specific format?).

A good example is Enlightenment 0.17 with their "Enlightenment Foundation Libraries", but reinventing GTK just to make this easier seems a bit excessive.

Nepomuk ( http://nepomuk.semanticdesktop.org/xwiki/bin/view/Main1/ ) is an EU-driven initiative to get semantic ideas into the desktop. This means that files (amongst other things) can be "tagged", rated, linked to each other, etc., allowing users or programs to run queries like "show me every photo that Dave sent to me over Jabber last March which has an elephant in it" (see http://en.wikipedia.org/wiki/SPARQL ).

The project currently includes work on Mozilla and KDE integration (work is here http://nepomuk.semanticdesktop.org/xwiki/bin/view/Main1/Deliverables ) amongst other things.

My idea is this: Integrate Nepomuk technologies (for instance the KDE Nepomuk server) with Gnome, for instance tagging in Nautilus, rating in Rhythmbox, who email attachments are from in Evolution, who has sent files in Empathy, etc..

The KDE implementation makes heavy use of the Strigi search/indexing system, although Tracker and Beagle should be able to work just as well following the XESAM standard ( http://xesam.org/main ).

I had this idea a while ago. When updates are installed or the system is upgraded there are sometimes unwanted side-effects where the user's customised settings and config files no longer work in the newer system. The user is asked if they want to replace customised files or not at upgrade time, but this doesn't allow any testing.

For example, say that a user has changed the /etc/network/interfaces file to get their connection running, and has edited /etc/X11/xorg.conf to get a tablet working. After updates to the packages which contain/control these files are made the user can be asked if their setup is still working (through the update manager originally, then as occasional popups until all questions are answered). If not then a list of potential solutions can be given (using the new config file, comparing the changes between old and new, etc. maybe even downgrading to the old package version).

I made a rather crude mockup of what I mean here http://bp0.blogger.com/_6BhjMzysLTs/RhcwYV86WOI/AAAAAAAAAAk/Pits9qYzRVY/s1600-h /UpgradeIssuesMockup.png

Some tests could be done automatically, but some cleverness would have to be employed to make sure non-networked computers aren't being thought of as broken, etc.

PS: The blueprint isn't entirely for this, but I commented in the full specification

Many programs have stop buttons, such as web browsers, file managers, etc. These are rarely used when the application is functioning correctly, since web pages and even large folders can load in a matter of seconds. Where they do get used is when the application misbehaves during loading, either due to a bug or a malicious web page. The UI often becomes unresponsive in such situations, which means that the stop button becomes useless, since it only acknowledges clicks after everything has finished loading (if it ever finishes).

I propose that if UIs cannot be made completely responsive then stop buttons should be special widgets which are given priority* by the toolkit above the program's own code. This would mean that even if the UI freezes whilst the application is parsing a page or whatever, the parsing would freeze to allow the Stop button to receive events, ensuring that programs' stop buttons do not become useless and the programs do not have to be manually killed and reloaded (if the whole event system has to be given priority in order to do this then so be it, but other widgets do not need to have their signal handling methods run)

* When I say priority I do not mean process niceness, I mean the order in which main loops like gtk.main run things. At the moment the UI freezes when an action is taken, with programs able to manually force an update at certain points in the code. I believe the UI should take priority, at least the event system which handles clicks to see whether Stop has been clicked.

When a download is started in the Epiphany browser an icon appears in the notification area ( www.kryogenix.org/days/wp-content/uploads/2008/01/epiphany-download-icon.png ) and a "Downloads" window pops up with this as its window icon.

I think that instead of showing a misleading image of a half-filled progress bar it should have an actual progress bar. Similar things can be seen in the battery monitor, network manager, volume control (such a tiny progress bar would only have a few states, which could be images) and in the window icons for copying files (and I think burning CDs too).

Currently choosing a mouse cursor is pretty simple. However, using a non-default cursor is hit-and-miss as to where it comes up.

For instance, at the moment I am running KDE4 with the Oxygen-yellow cursor, but Ubuntu's standard white-with-black-border cursor comes up everywhere except for window resizing. This is not KDE or GNOME specific though. I've encountered times when moving over a web browser changes the mouse cursor, and many others.

I'm not fluent in the inner workings of X.org so I can't write a spec, but as a user I think this needs sorting out. Thanks :)