Text-based user interface
From Wikipedia, the free
encyclopedia
Not to be confused with Command-line
interface
Snapshot of a TUI used in a BBS system called Synchronet
cmus,
an audio player with a TUI
Text-based user interface (TUI), also called textual user interface or terminal
user interface,[clarification needed] is a retronym
that was coined sometime after the invention of graphical
user interfaces, to distinguish a text-based interface that processed events from command-line
interfaces that operated sequentially . An
advanced TUI may, like GUIs, use the entire screen area and accept mouse input. A TUI does not necessarily provide line-by-line
output, although TUIs only use text, symbols
and colors
available on a given text environment.
Types
of text terminals
From text application's
point of view, there exists following three possibilities about the text screen
and communications with it, ordered by decreasing of accessibility.
- A genuine text mode display, controlled by a video adapter or
the central processor itself. This is a normal condition for a
locally-running application on various types of personal computers and mobile devices. If
not deterred by the operating system, a smart program may exploit the full power of a
hardware text mode.
- A text mode emulator. Examples are xterm for X Window System
and win32 console
(in a window mode) for Microsoft Windows. This usually supports programs which expect a real
text mode display, but may run considerably slower. Certain functions of
an advanced text mode, such as an own font uploading, almost certainly
become unavailable.
- A remote text terminal. The
communication capabilities usually become reduced to a serial line or
its emulation, possibly with few ioctl()s as an out-of-band
channel in such cases as Telnet and Secure Shell.
This is the worst case, because software restrictions hinder the use of
capabilities of a remote display device.
Under Linux and other Unix-like systems, a program easily accommodates
to any of three cases because the same interface (namely, standard
streams) is used to control the display and
keyboard. Also, specialized
programming libraries help to output the text in a way
appropriate to the given display device and interface to it. See below a comparison to Windows.
On
ANSI-compatible terminals
American National
Standards Institute (ANSI) standard ANSI
X3.64 defines a standard set of escape
sequences that can be used to drive terminals
to create TUIs (see ANSI
escape code). Escape sequences may be supported
for all three cases mentioned in the above section, allowing random cursor movements and color changes. However, not all terminals
follow this standard, and many non-compatible but functionally equivalent
sequences exist.
Under
DOS and Microsoft Windows
On IBM Personal Computers and compatibles, the Basic Input Output System (BIOS) and DOS
system calls provide a way to write text on the screen, and the ANSI.SYS driver could process standard ANSI escape sequences.
However, programmers soon learned that writing data directly to the screen
buffer was far faster and simpler to
program, and less error-prone; see VGA-compatible text mode for details. This change in programming methods resulted in
many DOS TUI programs. The win32
console environment is notorious for its
emulation of certain EGA/VGA text mode features, particularly a random access
to the text buffer, even if the application runs in a window. On the other
hand, programs running under Windows (both native and DOS applications) have
much less control of the display and keyboard than Linux and DOS programs can
have, because of aforementioned win32 console layer.
Mouse cursor in Impulse
Tracker. A more precise cursor (per-pixel
resolution) was achieved by regenerating the glyphs of characters used where
the cursor was visible, at each mouse movement in real-time.[citation needed]
Most often those programs used a
blue background for the main screen, with white or yellow characters, although
commonly they had also user color customization. Later, the interface became
deeply influenced by graphical user interfaces (GUI), adding pull-down
menus, overlapping windows,
dialog
boxes and GUI
widgets operated by mnemonics
or keyboard shortcuts.
Soon mouse
input was added – either at text resolution as a simple colored box or at
graphical resolution thanks to the ability of the Enhanced Graphics Adapter (EGA) and Video Graphics Array (VGA) display adapters to redefine the text character shapes by
software – providing additional
functions.
Some notable programs of this kind
were Microsoft Word,
DOS
Shell, WordPerfect, Norton
Commander, Turbo
Vision based Borland Turbo Pascal
and Turbo
C (the latter included the conio library), Lotus 1-2-3
and many others. Some of these interfaces survived even during the Microsoft Windows 3.1x
period in the early 1990s. For example, the Microsoft
C 6.0 compiler, used to write true
GUI programs under 16-bit
Windows, still has its own TUI.
Since its start, Microsoft
Windows includes a console to display DOS
software. Later versions added the Win32
console as a native interface for command-line interface and TUI programs. The console usually opens in window mode,
but it can be switched to full true text mode screen and vice versa by pressing
the Alt and Enter
keys together. Full-screen mode is not available in Windows Vista and later,
but may be used with some workarounds.[1]
Under
Unix-like systems
In Unix-like operating systems, TUIs are often constructed using the
terminal control library curses, or ncurses,
a mostly compatible library.
The advent of the curses
library with Berkeley
Unix created a portable and stable API
for which to write TUIs. The ability to talk to various text
terminal types using the same interfaces led to more widespread use of "visual" Unix
programs, which occupied the entire terminal screen instead of using a simple
line interface. This can be seen in text
editors such as vi, mail clients
such as pine
or mutt,
system management tools such as SMIT, SAM, FreeBSD's
Sysinstall and web
browsers such as lynx.
Some applications, such as w3m,
and older versions of pine
and vi use the less-able termcap library, performing many of the functions associated with curses within the application.
In addition, the rise in popularity
of Linux brought many former DOS users to a Unix-like platform,
which has fostered a DOS influence in many TUIs. The program minicom, for example, is modeled after the popular DOS program Telix. Some other TUI programs, such as the Twin
desktop, were ported
over.
The Linux kernel supports virtual
consoles, typically accessed through a
Ctrl-Alt-Fkey combination. Up to 10 consoles may be accessed, each displaying
in full-screen text mode.
The free
software program GNU
Screen provides for managing multiple
sessions inside a single TUI, and so can be thought of as being like a window
manager for text-mode and command-line
interfaces. Tmux can also do this.
The proprietary OS X text editor
BBEdit includes a shell worksheet function that works as a
full-screen shell window. The free Emacs
text editor can run a shell inside of one of its buffers to provide similar
functionality.
In
embedded systems
Embedded system displaying menu on
an LCD screen
Modern embedded
systems are capable of displaying TUI on a
monitor like personal computers. This functionality is usually implemented
using specialized integrated circuits, modules, or using FPGA.
Video circuits or modules are
usually controlled using VT100-compatible
command set over UART,[citation needed] FPGA
designs usually allow direct video memory access.[citation needed]
Other
uses
- The typical interface of Lisp Machines used
a TUI.
- The full screen editor of the Commodore 64
8-bit computers was advanced in its market segment for its time. Users
could move the cursor over the entire screen area, entering and editing BASIC program lines, as well as direct mode
commands. All Commodore 8-bit
computers used the PETSCII
character set, which included character glyphs suitable for making a TUI.
- Apple's Macintosh
Programmer's Workshop
programming environment included Commando, a TUI shell. It was the
inspiration for BBEdit's shell worksheet.
- Another kind of TUI was the primary interface of the Oberon operating
system as released in 1988
Screenshot
of the desktop of an Oberon System showing an image and several text viewers
.
In contrast to the so far mentioned uses of text user interfaces, the Oberon
system did not use a console or terminal based mode but required a large
bit-mapped display on which text was used as primary target for mouse clicks.
Commands of the form Module.Procedure parameters ~ were activated by a
middle-mouse click on Module.Procedure. Any text displayed on the screen
could be edited and every command displayed in a text, which complied to the
required syntax, could be clicked and executed. Any text with a bunch of
commands could be used as a so-called tool text serving as a user-configurable
menu. Even the output of a previous command could be edited and used as a
command. This approach is radically different from the dialogue oriented
command prompt and console menus described so far. Since it did not use
graphical elements, but text elements, it was termed a text user interface. For
a short introduction see p. 3-4 of the first published report[2]
on it.
- Later Apple II models included MouseText, a set of graphical glyphs
used for making a TUI.
- The Corvus Concept
computer of 1982 used a function key-based
text interface on a full-page pivoting display.
References
- cmd prompt full screen in Windows 7. Social.technet.microsoft.com. Retrieved on
2013-06-15.
- Niklaus Wirth & Jürg Gutknecht: (1988) The Oberon
System. Report Nr. 88.
Graphical user interface
From Wikipedia, the free encyclopedia
In computing, a graphical user interface (GUI,[1] sometimes pronounced "gooey" (or "gee-you-eye"))[2] is a type of interface that allows users to interact with electronic devices through graphical icons and visual indicators such as secondary notation, as opposed to text-based interfaces, typed command labels or text navigation. GUIs were introduced in reaction to the perceived steep learning curve of command-line interfaces (CLIs),[3][4][4] which require commands to be typed on the keyboard.
The actions in a GUI are usually performed through direct manipulation of the graphical elements.[5] In addition to computers, GUIs can be found in hand-held devices such as MP3 players, portable media players, gaming devices and smaller household, office and industry equipment. The term "GUI" tends not to be applied to other low-resolution types of interfaces with display resolutions, such as video games (where HUD[6] is preferred), or not restricted to flat screens, like volumetric displays[7] because the term is restricted to the scope of two-dimensional display screens able to describe generic information, in the tradition of the computer science research at the PARC (Palo Alto Research Center).
User interface and
interaction design
The graphical user interface is presented
(displayed) on the computer screen. It is the result of processed user input
and usually the primary interface for human-machine interaction. The touch user interfaces popular on
small mobile devices are an overlay of the visual output to the visual input.
Designing the visual composition and temporal behavior of a GUI is an
important part of software application programming in the
area of human-computer interaction. Its goal is to
enhance the efficiency and ease of use for the underlying logical design of a
stored program, a design discipline known as usability.
Methods of user-centered design are used to ensure
that the visual language introduced in the design is well tailored to the
tasks.The visible graphical interface features of an application are sometimes referred to as "chrome" or "Gui" (Goo-ee).[8][9] Typically, the user interacts with information by manipulating visual widgets that allow for interactions appropriate to the kind of data they hold. The widgets of a well-designed interface are selected to support the actions necessary to achieve the goals of the user. A model-view-controller allows for a flexible structure in which the interface is independent from and indirectly linked to application functionality, so the GUI can be easily customized. This allows the user to select or design a different skin at will, and eases the designer's work to change the interface as the user needs evolve. Good user interface design relates to the user, not the system architecture.
Large widgets, such as windows, usually provide a frame or container for the main presentation content such as a web page, email message or drawing. Smaller ones usually act as a user-input tool.
A GUI may be designed for the requirements of a vertical market as application-specific graphical user interfaces. Examples of application-specific GUIs are:
- Automated
teller machines (ATM)
- Point-Of-Sale
touchscreens at restaurants [10]
- Self-service checkouts used in a
retail store
- Airline
self-ticketing and check-in
- Information
kiosks in a public space, like a train station or a museum
- Monitors or
control screens in an embedded industrial application which employ a real time operating system (RTOS).
The latest cell phones and handheld game systems also employ application specific touchscreen GUIs. Newer automobiles use GUIs in their navigation systems and touch screen multimedia centers.
