NSPopup or something similar to indicate progress - cocoa

I am not sure which class I need. I am looking to implement the following:
User clicks on NSButton ( Have this working)
Have a background task run once he does this. (have this working)
While the task is in progress, I want to display a small popup which indicates the task is in progress and asks the user to wait/give him some more informtion. ( This is where I need help)
I am not really sure what class would help me get this popup..NSPopup /NsAlert ?
Appreciate any pointers. Thanks.

In addition to Peter's answer: Spend some time perusing Interface Builder's Library palette so you know what standard controls are available and what they're called. Spend more time reading the AppKit API reference to get a feel for how they work in general.
The specific control to display progress is an NSProgressIndicator. As Peter said, you can put this in a view or a sheet but the best approach really depends on the factors Peter mentioned.

It should simply be a view in your window.
If the user cannot do anything in the window until the operation finishes (and you should do everything you can to prevent such obstruction), then it should be a sheet over the window.
If the user can do more than one of these operations at the same time and they don't prevent the user from doing other things with the window, then a view in the window will become unwieldy, and you should move the progress display to a dedicated progress window, as done by Transmit, Mail, Adium, Finder, Amadeus Pro, and many other applications.

Related

Drop down window to edit Cocoa pop-up menu items

I'm relatively new to Cocoa and I would like to implement the ability to add or delete items from a pop-up menu in the same way that the OS X System Preferences/Network Location pop-up works. Selecting the 'Edit Locations...' option rolls down a window that provides the ability to add to, or delete from the existing Location list. My interest in doing things this way is as much about conforming to the relevant Human Interface Guidelines as having a way to dynamically change the menu content. (I have no real problem with the 'background' coding side of things, it's the user interface that's my primary issue at this stage.)
Is this a standard IB View?
On the surface, I can't see anything appropriate, but maybe that's just my inexperience. I'm assuming that, because this is not an uncommon sort of requirement, the task should be pretty straightforward and that Apple, or someone, would even have a relevant code sample to show how to define such a window.
Can anyone point me in the right direction?
Sorry for the late answer. I found this tutorial: http://cocoadevcentral.com/articles/000014.php

Best UI to be shown to User while his request is still in process behind the scenes?

I am currently involved with an Application where I need to design the UI part of the Application and current I am in the process of implementation of UI which would be displayed to end user while his or her request is being processed behind the scenes.
So my question is that:
What is the best UI approach/symbol/suggestions to be displayed to end User while his or her request is still being processed behind the scenes ?
Thanks.
Any sort of throbber is adequate enough. Here's a nice throbber generator you can use.
And there's nothing wrong with progress bars, unless there the kind of progress bars that start over without actually indicating progress.
If you don't take your program too seriously, this one is always a crowd pleaser:
This is going to take a while, so to pass the time, here's a dancing bunny:
http://img251.imageshack.us/img251/4828/thdancingbunny.gif
A Loading screen of some sort may work.
It depends on how long your user must wait. If it will be <10 seconds, then just show the spinning pie of death as an animated GIF (or flash if you prefer to be non-accessible) (a simple jquery hide/show with CSS)
If it is a longer wait, like >10 seconds, you may want to implement a short but entertaining caption system. Something like the old "Reticulating Splines" type system to give the users a bit of humor while they wait.. see https://stackoverflow.com/questions/182112/what-are-some-funny-loading-statements-to-keep-users-amused for a list of such statements.
If you've got a long running background process, I'd simply display a progress bar with a message below it that states in the least technical terms possible what the current task is. And then, if possible, a cancel button in case the user gets impatient or mistakenly started the process.
I can't provide any specific links to back me up, but I believe its been proven that just the presence of a progress bar can make a longer task seem shorter than a task without the progress bar.
The worst thing you can do is nothing. Users have been conditioned to think that no feedback = locked up program.
Note on typical implementation (that I use):
jQuery has the .ajax function. When I call the function (onClick or whatever) I .remove() the contents of the (div or whatever seems appropriate) and add a css class of waiting which looks like:
.waiting {
background-color: #eee;
background-image: url('some-spinner.png');
}
the .ajax function has a success callback where I remove the .waiting class and put in the new data I got back from ajax (or put back the data I took out with .remove().
Additionally you may change default mouse cursor to wait or progress states with CSS.
Details about changing cursor with CSS here.

User interface paradigms that need changing?

Often times convention is one of the most important design consideration for user interface. Usually the advice goes to do it like Microsoft does.
This is for three reasons:
If it ain't broke, don't fix it.
If your users expect to click on a floppy disk icon to save, don't change the icon (even though some of them may have never seen an actual floppy disk).
Users don't want to re-learn the interface (and hot keys, etc.) with each different application they use.
At the same time Emmerson said "*A foolish consistency is the hobgoblin of little minds.*" So when does maintaining a consistent user interface cross the line from a good idea to stagnated innovation?
Microsoft shook up the good old WIMP GUI with the introduction of the tool bar, and then again with the Ribbon control (which is the natural evolution of the tool bar, like it or not.) Now we are seeing ribbons everywhere.
So my question is, what are some user interface paradigms that are accepted and consistent across multiple applications, but have stayed past their prime and are starting to reek? Are there some important changes that would benefit from a grass roots push by developers to innovate and improve the user interface experience for our users?
One thought that came to mind for me is the modal pop-up dialog. You know the ones that say: "Are you sure you want to . . .. - [Yes] [No] [Cancel] [Maybe]" and its evil twin "Successfully completed what you wanted to do! [OK]." We are seeing a movement away from these with the "info panel" in browsers. I think they need to be adopted in windows application development as well.
If possible please list a solution for each stale UI item.
And please don't list clippy. We all know he was a bad idea.
NOTE: This is specifically Windows client user interface paradigms, but I am certainly open to drawing inspiration from the web, the Mac, etc.
You mentioned popup modal dialogs , and I'd argue that non-modal ones are just as bad. Any dialog box remove focus from the program, they could end up behind the program and make it hard to find it, they might not even appear on the same virtual screen.
I'd like to see an end to all dialog boxes. If you need to stop someone from using the UI because of some non-normal circumstance, then remove the relevant parts of the UI from the window, and replace it with what the dialog would contain. Bring back the UI once the problem has been handled.
Clicking things on touch interfaces
It's incredibly difficult to click on things on a touch interface, because you don't know when you have pressed the screen hard enough. And if you add an animation to the button you are clicking, you most likely wont see it, because your finger is in the way. Adding other reactions, like vibrating the phone or painting waves on the screen might work, but there is usually a delay which is too large, much larger than the tactile sense of a button being pressed. So until they invent a screen with buttons that can be pressed, all touch devices should move towards dragging user interfaces (DUIs) instead.
Counter intuitively it is easier to press an object on the screen, drag it, and then release it than it is to just press and release it. It's probably because you can see the object moving when you start dragging, and you can adjust the pressure while dragging it. Dragging also has a lot more options, because you now have a direction, not just a point that you clicked. You can do different things if the user drags the object in different directions. Speed might also be used, as well as the point where the user releases the object. The release point is the real strength of DUIs, because it is very easy to release something, even with pixel precession.
Some designs have started to use DUIs, like (here we go) the iPhone, palm pre and android phones. But only part of their design is DUI, the rest is clicking. One area they all have in common is the keyboard. Instead of clicking on a key the user presses any key, then drags their finger towards the key they really wanted to click. Unlocking these phones also uses dragging.
Other easily implemented DUI features would be things like mouse gestures, where dragging in different directions, or drawing different shapes does different things. There are also alternate keyboards being researched which puts a bigger emphasis on dragging. All buttons can be changed into switches, so have to drag them down a bit to click them. With a well designed graphics, this should be intuitive to the user as well.
The Apple Human Interface Guidelines are a good read on this topic. They discuss this from a very broad point of view and the guidelines apply to any platform, not only Mac.
The file system. I want to save a file.. >OOOPs I need to think of a file name first. Well.... how about ... blah.doc.
6 months later...
Where the %#*(%& * did I save that %()#*()*ing file?
The solution is build a versioning system into the application, or better, the OS. Make files findable by their content, with a search engine, instead of forcing the user to come up with a memorable name, when all they want is for their file to not get lost.
Eliminate the save step. Type something in to the application, and it's just there, and there's no risk of losing it by some misstep, like forgetting to save. If you want an older version, you can just pick a date and see what the document looked like back then.
To build on the search engine idea: It's a pain having to navigate some arbitrary tree structure to find your stuff. Searching is much easier. However, you might still want to have something like a "folder" to group multiple files together. Well, you can build a richer metadata system, and have a "category" or "project" field, and setup the search engine to show items by project, or by category. Or group by those, or whatever new UI discovery we make next.
This question is a bit too open-ended, IMHO.
However, my main approach when designing anything is:
Fits in to wherever it is. If it's a windows app, I copy MS as much as a possible
It's simple.
It provides options
Buttons have a nice description of what the result of clicking will be, as opposed to 'yes or 'no'
Harder to answer the rest of your post without spending hours typing out an arguably useless (and repeated) set of guidelines.
In my mind, the one thing that really stands out is that USERS need more and easier control over the application's user interface appearance and organization.
So many interfaces can not be modified by the user so that the most used/favorite functions can be grouped together. This ability would make your favorite software even easier for you to get things done.
Error messages need a "Just do it!" button.
Seriously, I really don't care about your stupid error message, just DO WHAT I TOLD YOU TO DO!!!
I think the entire Document model of the web needs to change. It's not a user interface, but it leads to many, many bad user interfaces.
The document model was a good idea to connect a bunch of documents, but now the web is also a collection of applications. Today, I think the Page/document model corrupts our thinking. We end up lumping things together that aren't related, modularizing our code wrong, and in the end confusing users with our monolithic control board type websites.
Find dialogs that sit over the widget in which you are doing the search are terrible. Loads of apps do that. The find bar in Firefox works much better.
Many applications have multiple panes within the UI - eg in Outlook there's the preview pane and the inbox pane (amongst others). In these applications typically cursor key presses apply to the currently focussed pane. But there's very poor hinting to show the user which pane has focus and there are seldom keyboard shortcuts to move the focus between panes.
The focussed pane should be highlighted somehow.
Something like alt+cursor keys should move the focus around.
Ctrl-Tab and Ctrl-Shift-Tab cycle left and right through tabs instead of MRU behavior, even though in most cases the same behavior is duplicated with Ctrl-PageUp and Ctrl-PageDown.
There are a lot but here's an idea for a couple of them:
Remove some clicks like in "add another" or "search item" and the like.
This is well done with interfaces like ajax which have autocompletes ( and auto search ) but is slowly being adopted for platform UI's ( and in some cases they were originated in platform UI's. )
This is how StackOverflow does it for some scenarios.
But of course, we all know that already don't we? No need for "Seach tag" or "Add another tag" buttons, they just happen
Dialogs as you described.
Guys at Humanized proposed Transparent messages which actually are used in their product Enso and some other places.
Mac uses them for notifications ( like in Growl ) use them very well, or Ubuntu new notification system.
alt text http://blogs.sun.com/plamere/resource/NowPlayingGrowl.png
Firefox replaces the traditional "Search" dialog box with a search bar at the bottom.
Although not everyone likes the placement for next/previous as in this screenshot
And even SO ( again ) :) replace the notification with the yellow bar.
Finally:
File managers
I really like ( sometimes ) the simplicity of regular file managers, but some times I would like to work faster/better with them.
If you compare IE 4 with IE 8 you can tell the advance ( even better compare IE 4 with Google Chrome )
But if you compare Windows 95 Explorer with Win XP they are almost the same!! ( Win Vista/7 is a step forward )
But I wonder: Why haven't file managers improved as much as webbrowsers?
That's one reason I like stuff like QuickSilver but it is just a step. Much work is needed to create something like a "Perfect program launcher" or (FileManager/DesktopSearcher etc as you wish )
QuickSilver featuring "move to" action

UI design - Include a Cancel button or not?

We are designing the UI for a new line of business application. We have no real constraints and are free to design the UI as we see fit. The UI will be done in WPF and targeted for Windows 7, Vista, and XP Pro users.
Many dialog boxes contain OK and Cancel buttons in their lower right corner. Do you feel it is necessary to have this Cancel button or is the red X in the upper right corner sufficient? We are discussing this as we have been noticing more UIs that do not have cancel buttons, only the red X.
Not only you should add it but also make sure ESC is mapped to it.
Present the two designs to the customer - one with the "Cancel" button, the other without. See what their thoughts are.
Better still present them as partially working prototypes and watch them as they use the dialogs. If you ask them to perform a set of tasks and see if they have trouble when asked to cancel an operation.
Having said that, my preference is to include a "Cancel" button for the reasons others have mentioned:
Accessibility (especially as Esc should be mapped to it).
Convention (users will be expecting it).
Include the Cancel button. The red X is VERY hard to tab to. ;)
Include it. This is very common in other user interfaces. Give the user the choice of which to use; making it for them might make them annoyed with your interface.
Users are used to having standard GUI layouts - otherwise they get confused. They also have different ways of using the standard interface. Some people only use the X, some people only use Cancel. People usually ignore the one they're not using, but get confused if their one isn't present. So be safe and keep them both in - it should only be a one-liner function for Cancek anyway.
Include it!
From a user interface perspective, not including a cancel button might leave some users feeling like they have no choice, which is certainly not the case. Imagine the following simple decision scenario:
Warning: All of the files in the selected folder will be deleted. This action cannot be undone. Are you sure you would like to continue?
How silly would an interface be if the only option was Ok? Also, as noted above, on many platforms the Escape key is mapped to Cancel. It's also probably worthwhile setting a default button so that pressing the Enter/Space key doesn't inadvertently perform the action that cannot be undone.
+1 on including it. If you don't include it now and then need some different functionality on Cancel to Close later on, your users will already be used to automatically closing.
Just like we have 'ESC' button on keyboard, we need 'Cancel' in dialogs.
A matter of usability :-)
Include it. And please also make sure that you make sure that hitting the Escape key does the same thing as the Cancel button.
Also, just because you're designing from scratch, please don't throw out all convention. Take a look at MSFT's UX Guidelines for dialog boxes.
The red button is really for 'Close' rather than 'Cancel'. 'Cancel' canceling a running task. Use a 'Close' button instead. And yes include the 'Close' if there is a reason for people to click on it. The red button is quite difficult to click when you really want to close something quickly.
If you have that kind of freedom, consider eliminating dialog boxes from your application entirely, especially ones with the typical "OK | CANCEL" paradigm. Dialog boxes disrupt the flow of action and generally should only be used for things which absolutely require the program to interrupt the user.
You'll notice how disruptive they are in the web environment -- e.g., Stack Overflow only uses them when it needs to be able to OVERRIDE your action, e.g., when you navigate away from an unsubmitted answer.

Is "tip-of-the-day" good? [closed]

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 years ago.
Improve this question
Many programs (often large ones, like MS Office, The GIMP, Maxthon) have a feature called "tip-of-the-day". It explains a small part of the program, like this one in Maxthon:
"You can hide/show the main menu bar by pressing Ctrl+F11"
You can usually browse through them by clicking next. And other options provided are "Previous", "Close", "Do not show at startup".
I think I like the way Maxthon used to handle this; in the browser's statusbar (down at the bottom usually, together with "Done", the progress-bar etc), there would sometimes be a small hint or tip on what else you could do with it.
As Joel Spolsky wrote in his article-series "User Interface Design for Programmers", people don't like reading manuals. But we still want them to use the program, and the features they could benefit from, don't we? Therefore, I think it is useful to have such a feature, without the annoyance of the pop-up on startup.
What do you think? Pop-up? Maxthonstyle? No way?
I really only like the idea of a "tip of the day" if it is displayed when I can't do anything else anyway. For example, when the program is loading a large file. Suppose it has to load some large amount of data when the program is first started. Along with the "loading" splash screen, show a small tip, and have it disappear when the program starts. It's simple, unobtrusive, and can sometimes be very helpful to some users.
I hate to bring up "World of Warcraft" as an example in a programming discussion, but it uses this technique when you first login. Here is an example loading screen. Along with the loading bar and a full screen piece of art, it displays a small tip at the bottom of the screen. Usually these tips lead users to things they can explore further (such as a settings window, character customization tools, etcetera). For example, "Pressing ESCAPE will bring up a menu that lets you customize the the look and feel of the game".
Above all else: allow the user to easily close the tips and stop them from appearing each time. Make every key close the tip dialog when pressed. Have two buttons: "Close Tip" and "Close Tip and Never Show Again", or something to that effect.
It must be easy to banish the tips---but when learning a new GUI, I use them often. If it's a tip at startup I usually turn it off after at most a dozen runs, but if tips are well designed this gives me a sense of the application space.
Ways tips could be improved:
Don't tip a user about a feature that user has used recently.
Making tips sensitive to context can be helpful (the new Vista bars are an example --- pause to get the vapors; I have just said something nice about Vista).
Tips that are unobtrusive or appear during otherwise wasted time are good.
Tip during loading screen is good, but it must be findable after loading is over. Some popular game, maybe it was Baldur's Gate, would give you a tip during loading, and then afterward you could go back and review the tips in your journal. So if you had a vague memory of a useful tip a few screens back, you could find it quickly, in the same place you were accustomed to look for other recent information. A 'recently tipped' item on the help menu perhaps?
Actually, I've never heard of Maxthon. But I actually like those as long as there is a checkbox to make them stop. I like the tips to actually tell me something interesting instead of something very obvious in the UI. But this is really preference. I don't think it is bad design to use them.
No - I dislike them pretty strongly. When I am starting a software application, I almost always have a specific task in mind. The TOTD just interrupts this flow and tries to get me to think about the software rather than the task.
This might not be a direct answer to your question, but personally, I like the way StackOverflow handles this. The badge system essentially acts as a manual, rewarding users for discovering and utilizing the functionality it has to offer. Granted, this isn't really an option for most apps but it works beautifully for StackOverflow.
I think this goes along with the issues against modals -- it's something in a user's way, despite how helpful it may be. Which is why the "Do not show at startup" is needed.
Though I've never used Maxthon before, the way it showed tips sounds like a really good idea. It's unobtrusive and entirely optional as to if users even have to pay them any attention.
IMO, it's not good idea to have a feature that has to ask the user if it should "keep quiet." ;)
And, while some tips can seem blatantly obvious, even these tips can still be useful to users that aren't quite as familiar. Those that already know it can just continue on with their day.
A tip is a good idea, users can discover things they didn't know they didn't know. But rather than using a pop up getting in the way of working, I like how World of Warcraft does it. They put the tip on the loading screen, when you have nothing better to do then stare at the progress bar anyway.
Norman Ramsey made some great points about how tips could be improved. My problem with tips of the day (and I'm speaking as someone who's implemented them in my own apps) is that they are not timely and a bit too intrusive. The typical tip of the day comes up when you start the program, and requires a button click to make it go away. When I actually see a useful tip, my train of thought is usually "I'll have to remember that when I do option ". Of course, it's forgotten by the time I get around to using . And clicking OK during program startup gets old fast, I'll usually disable the tips after the first dozen or so.
My suggestion would be to go the next step and make the tip of the day much more context sensitive. For example, if the program detects that the user is constantly going to Edit | Copy and then Edit | Paste, a good tip would be "Not for nothing, but CTRL+C followed by CTRL+V accomplishes the same thing" and tell them right when they are clicking away at the menu like a lost monkey, not during program startup. Oh, and don't interrupt their work by forcing them to click OK.
What I just suggested - is that what that damn paperclip dude used to do?
IMO Tip of the day (popup) is only within programs that have a certain level of complexity, that you use frequently. So when you open the program you learn a new trick that will help you.
Usually people either like it or hate it, so definitely have an option to disable it.
What I'm worried about with the other type is that it will go unnoticed, you wont believe the areas of programs people never look at.
Maybe put it in something like a "tool tip" (or down at the bottom like the OP described) and make it contextual. A few seconds after you change to a new mode it slides in some text about the current mode.
And YES make the OFF button easy to find!!!
Personally, I prefer software that’s simple enough to not need “Tip of the Day”.
Tip of the day can be good if it's
non-modal, and never in the way
has a "history" I can access
is context sensitive to what I do
Unfortunately, the crappy initial Office implementation Clippy of has completely killed the last idea.
So IMO a good implementation would:
Show up at startup
Make "don't show at startup" the obvious choice
Indicate (with an animation?) that TOTD is accessible from e.g. the toolbar
MouseOver the toolbar icon would give the title/abstract of the "current tip"
clicking on it would give me the tip, give forward/backward navigation through tips,
link to "show all tips" in the manual.
For a large tip database, a "related tips" link might encourage me to explore the manual
Context-sensitive
Later incarnations of Clippy were almost helpful actually: it was nonmodal and stayed out of the way not requiring interaction (the jumping around was attention-grabbing, though), and I remember a few instances where the suggestion was good - e.g. a keyboard shortcut for a command I had accessed repeatedly through the menu.
A simpler method could still be effective:
"Did you know... you can customize the print templates to look like a pie chart on LSD - the manual shows you how! [clickety]" on a print dialog
Did you know... I can remember your custom searches. Just click 'Goof/Barf/Hidden/Create Index for last Query' - and they'll show up in the 'Search' menu. They'll run much faster, too! whe working with a search/query form

Resources